yeet

node_modules/react-refresh/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Facebook, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/react-refresh/README.md

@@ -0,0 +1,7 @@
+# react-refresh
+
+This is an experimental package for hot reloading.
+
+**Its API is not as stable as that of React, React Native, or React DOM, and does not follow the common versioning scheme.**
+
+**Use it at your own risk.**

node_modules/react-refresh/babel.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./cjs/react-refresh-babel.production.min.js');
+} else {
+  module.exports = require('./cjs/react-refresh-babel.development.js');
+}

node_modules/react-refresh/cjs/react-refresh-babel.development.js

@@ -0,0 +1,771 @@
+/** @license React vundefined
+ * react-refresh-babel.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+
+
+if (process.env.NODE_ENV !== "production") {
+  (function() {
+'use strict';
+
+var ReactFreshBabelPlugin = function (babel) {
+  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  if (typeof babel.getEnv === 'function') {
+    // Only available in Babel 7.
+    var env = babel.getEnv();
+
+    if (env !== 'development' && !opts.skipEnvCheck) {
+      throw new Error('React Refresh Babel transform should only be enabled in development environment. ' + 'Instead, the environment is: "' + env + '". If you want to override this check, pass {skipEnvCheck: true} as plugin options.');
+    }
+  }
+
+  var t = babel.types;
+  var registrationsByProgramPath = new Map();
+
+  function createRegistration(programPath, persistentID) {
+    var handle = programPath.scope.generateUidIdentifier('c');
+
+    if (!registrationsByProgramPath.has(programPath)) {
+      registrationsByProgramPath.set(programPath, []);
+    }
+
+    var registrations = registrationsByProgramPath.get(programPath);
+    registrations.push({
+      handle: handle,
+      persistentID: persistentID
+    });
+    return handle;
+  }
+
+  function isComponentishName(name) {
+    return typeof name === 'string' && name[0] >= 'A' && name[0] <= 'Z';
+  }
+
+  function findInnerComponents(inferredName, path, callback) {
+    var node = path.node;
+
+    switch (node.type) {
+      case 'Identifier':
+        {
+          if (!isComponentishName(node.name)) {
+            return false;
+          } // export default hoc(Foo)
+          // const X = hoc(Foo)
+
+
+          callback(inferredName, node, null);
+          return true;
+        }
+
+      case 'FunctionDeclaration':
+        {
+          // function Foo() {}
+          // export function Foo() {}
+          // export default function Foo() {}
+          callback(inferredName, node.id, null);
+          return true;
+        }
+
+      case 'ArrowFunctionExpression':
+        {
+          if (node.body.type === 'ArrowFunctionExpression') {
+            return false;
+          } // let Foo = () => {}
+          // export default hoc1(hoc2(() => {}))
+
+
+          callback(inferredName, node, path);
+          return true;
+        }
+
+      case 'FunctionExpression':
+        {
+          // let Foo = function() {}
+          // const Foo = hoc1(forwardRef(function renderFoo() {}))
+          // export default memo(function() {})
+          callback(inferredName, node, path);
+          return true;
+        }
+
+      case 'CallExpression':
+        {
+          var argsPath = path.get('arguments');
+
+          if (argsPath === undefined || argsPath.length === 0) {
+            return false;
+          }
+
+          var calleePath = path.get('callee');
+
+          switch (calleePath.node.type) {
+            case 'MemberExpression':
+            case 'Identifier':
+              {
+                var calleeSource = calleePath.getSource();
+                var firstArgPath = argsPath[0];
+                var innerName = inferredName + '$' + calleeSource;
+                var foundInside = findInnerComponents(innerName, firstArgPath, callback);
+
+                if (!foundInside) {
+                  return false;
+                } // const Foo = hoc1(hoc2(() => {}))
+                // export default memo(React.forwardRef(function() {}))
+
+
+                callback(inferredName, node, path);
+                return true;
+              }
+
+            default:
+              {
+                return false;
+              }
+          }
+        }
+
+      case 'VariableDeclarator':
+        {
+          var init = node.init;
+
+          if (init === null) {
+            return false;
+          }
+
+          var name = node.id.name;
+
+          if (!isComponentishName(name)) {
+            return false;
+          }
+
+          switch (init.type) {
+            case 'ArrowFunctionExpression':
+            case 'FunctionExpression':
+              // Likely component definitions.
+              break;
+
+            case 'CallExpression':
+              {
+                // Maybe a HOC.
+                // Try to determine if this is some form of import.
+                var callee = init.callee;
+                var calleeType = callee.type;
+
+                if (calleeType === 'Import') {
+                  return false;
+                } else if (calleeType === 'Identifier') {
+                  if (callee.name.indexOf('require') === 0) {
+                    return false;
+                  } else if (callee.name.indexOf('import') === 0) {
+                    return false;
+                  } // Neither require nor import. Might be a HOC.
+                  // Pass through.
+
+                } else if (calleeType === 'MemberExpression') {// Could be something like React.forwardRef(...)
+                  // Pass through.
+                } else {
+                  // More complicated call.
+                  return false;
+                }
+
+                break;
+              }
+
+            case 'TaggedTemplateExpression':
+              // Maybe something like styled.div`...`
+              break;
+
+            default:
+              return false;
+          }
+
+          var initPath = path.get('init');
+
+          var _foundInside = findInnerComponents(inferredName, initPath, callback);
+
+          if (_foundInside) {
+            return true;
+          } // See if this identifier is used in JSX. Then it's a component.
+
+
+          var binding = path.scope.getBinding(name);
+
+          if (binding === undefined) {
+            return;
+          }
+
+          var isLikelyUsedAsType = false;
+          var referencePaths = binding.referencePaths;
+
+          for (var i = 0; i < referencePaths.length; i++) {
+            var ref = referencePaths[i];
+
+            if (ref.node.type !== 'JSXIdentifier' && ref.node.type !== 'Identifier') {
+              continue;
+            }
+
+            var refParent = ref.parent;
+
+            if (refParent.type === 'JSXOpeningElement') {
+              isLikelyUsedAsType = true;
+            } else if (refParent.type === 'CallExpression') {
+              var _callee = refParent.callee;
+              var fnName = void 0;
+
+              switch (_callee.type) {
+                case 'Identifier':
+                  fnName = _callee.name;
+                  break;
+
+                case 'MemberExpression':
+                  fnName = _callee.property.name;
+                  break;
+              }
+
+              switch (fnName) {
+                case 'createElement':
+                case 'jsx':
+                case 'jsxDEV':
+                case 'jsxs':
+                  isLikelyUsedAsType = true;
+                  break;
+              }
+            }
+
+            if (isLikelyUsedAsType) {
+              // const X = ... + later <X />
+              callback(inferredName, init, initPath);
+              return true;
+            }
+          }
+        }
+    }
+
+    return false;
+  }
+
+  function isBuiltinHook(hookName) {
+    switch (hookName) {
+      case 'useState':
+      case 'React.useState':
+      case 'useReducer':
+      case 'React.useReducer':
+      case 'useEffect':
+      case 'React.useEffect':
+      case 'useLayoutEffect':
+      case 'React.useLayoutEffect':
+      case 'useMemo':
+      case 'React.useMemo':
+      case 'useCallback':
+      case 'React.useCallback':
+      case 'useRef':
+      case 'React.useRef':
+      case 'useContext':
+      case 'React.useContext':
+      case 'useImperativeMethods':
+      case 'React.useImperativeMethods':
+      case 'useDebugValue':
+      case 'React.useDebugValue':
+        return true;
+
+      default:
+        return false;
+    }
+  }
+
+  function getHookCallsSignature(functionNode) {
+    var fnHookCalls = hookCalls.get(functionNode);
+
+    if (fnHookCalls === undefined) {
+      return null;
+    }
+
+    return {
+      key: fnHookCalls.map(function (call) {
+        return call.name + '{' + call.key + '}';
+      }).join('\n'),
+      customHooks: fnHookCalls.filter(function (call) {
+        return !isBuiltinHook(call.name);
+      }).map(function (call) {
+        return t.cloneDeep(call.callee);
+      })
+    };
+  }
+
+  var hasForceResetCommentByFile = new WeakMap(); // We let user do /* @refresh reset */ to reset state in the whole file.
+
+  function hasForceResetComment(path) {
+    var file = path.hub.file;
+    var hasForceReset = hasForceResetCommentByFile.get(file);
+
+    if (hasForceReset !== undefined) {
+      return hasForceReset;
+    }
+
+    hasForceReset = false;
+    var comments = file.ast.comments;
+
+    for (var i = 0; i < comments.length; i++) {
+      var cmt = comments[i];
+
+      if (cmt.value.indexOf('@refresh reset') !== -1) {
+        hasForceReset = true;
+        break;
+      }
+    }
+
+    hasForceResetCommentByFile.set(file, hasForceReset);
+    return hasForceReset;
+  }
+
+  function createArgumentsForSignature(node, signature, scope) {
+    var key = signature.key,
+        customHooks = signature.customHooks;
+    var forceReset = hasForceResetComment(scope.path);
+    var customHooksInScope = [];
+    customHooks.forEach(function (callee) {
+      // Check if a corresponding binding exists where we emit the signature.
+      var bindingName;
+
+      switch (callee.type) {
+        case 'MemberExpression':
+          if (callee.object.type === 'Identifier') {
+            bindingName = callee.object.name;
+          }
+
+          break;
+
+        case 'Identifier':
+          bindingName = callee.name;
+          break;
+      }
+
+      if (scope.hasBinding(bindingName)) {
+        customHooksInScope.push(callee);
+      } else {
+        // We don't have anything to put in the array because Hook is out of scope.
+        // Since it could potentially have been edited, remount the component.
+        forceReset = true;
+      }
+    });
+    var finalKey = key;
+
+    if (typeof require === 'function' && !opts.emitFullSignatures) {
+      // Prefer to hash when we can (e.g. outside of ASTExplorer).
+      // This makes it deterministically compact, even if there's
+      // e.g. a useState ininitalizer with some code inside.
+      // We also need it for www that has transforms like cx()
+      // that don't understand if something is part of a string.
+      finalKey = require('crypto').createHash('sha1').update(key).digest('base64');
+    }
+
+    var args = [node, t.stringLiteral(finalKey)];
+
+    if (forceReset || customHooksInScope.length > 0) {
+      args.push(t.booleanLiteral(forceReset));
+    }
+
+    if (customHooksInScope.length > 0) {
+      args.push( // TODO: We could use an arrow here to be more compact.
+      // However, don't do it until AMA can run them natively.
+      t.functionExpression(null, [], t.blockStatement([t.returnStatement(t.arrayExpression(customHooksInScope))])));
+    }
+
+    return args;
+  }
+
+  var seenForRegistration = new WeakSet();
+  var seenForSignature = new WeakSet();
+  var seenForOutro = new WeakSet();
+  var hookCalls = new WeakMap();
+  var HookCallsVisitor = {
+    CallExpression: function (path) {
+      var node = path.node;
+      var callee = node.callee; // Note: this visitor MUST NOT mutate the tree in any way.
+      // It runs early in a separate traversal and should be very fast.
+
+      var name = null;
+
+      switch (callee.type) {
+        case 'Identifier':
+          name = callee.name;
+          break;
+
+        case 'MemberExpression':
+          name = callee.property.name;
+          break;
+      }
+
+      if (name === null || !/^use[A-Z]/.test(name)) {
+        return;
+      }
+
+      var fnScope = path.scope.getFunctionParent();
+
+      if (fnScope === null) {
+        return;
+      } // This is a Hook call. Record it.
+
+
+      var fnNode = fnScope.block;
+
+      if (!hookCalls.has(fnNode)) {
+        hookCalls.set(fnNode, []);
+      }
+
+      var hookCallsForFn = hookCalls.get(fnNode);
+      var key = '';
+
+      if (path.parent.type === 'VariableDeclarator') {
+        // TODO: if there is no LHS, consider some other heuristic.
+        key = path.parentPath.get('id').getSource();
+      } // Some built-in Hooks reset on edits to arguments.
+
+
+      var args = path.get('arguments');
+
+      if (name === 'useState' && args.length > 0) {
+        // useState second argument is initial state.
+        key += '(' + args[0].getSource() + ')';
+      } else if (name === 'useReducer' && args.length > 1) {
+        // useReducer second argument is initial state.
+        key += '(' + args[1].getSource() + ')';
+      }
+
+      hookCallsForFn.push({
+        callee: path.node.callee,
+        name: name,
+        key: key
+      });
+    }
+  };
+  return {
+    visitor: {
+      ExportDefaultDeclaration: function (path) {
+        var node = path.node;
+        var decl = node.declaration;
+        var declPath = path.get('declaration');
+
+        if (decl.type !== 'CallExpression') {
+          // For now, we only support possible HOC calls here.
+          // Named function declarations are handled in FunctionDeclaration.
+          // Anonymous direct exports like export default function() {}
+          // are currently ignored.
+          return;
+        } // Make sure we're not mutating the same tree twice.
+        // This can happen if another Babel plugin replaces parents.
+
+
+        if (seenForRegistration.has(node)) {
+          return;
+        }
+
+        seenForRegistration.add(node); // Don't mutate the tree above this point.
+        // This code path handles nested cases like:
+        // export default memo(() => {})
+        // In those cases it is more plausible people will omit names
+        // so they're worth handling despite possible false positives.
+        // More importantly, it handles the named case:
+        // export default memo(function Named() {})
+
+        var inferredName = '%default%';
+        var programPath = path.parentPath;
+        findInnerComponents(inferredName, declPath, function (persistentID, targetExpr, targetPath) {
+          if (targetPath === null) {
+            // For case like:
+            // export default hoc(Foo)
+            // we don't want to wrap Foo inside the call.
+            // Instead we assume it's registered at definition.
+            return;
+          }
+
+          var handle = createRegistration(programPath, persistentID);
+          targetPath.replaceWith(t.assignmentExpression('=', handle, targetExpr));
+        });
+      },
+      FunctionDeclaration: {
+        enter: function (path) {
+          var node = path.node;
+          var programPath;
+          var insertAfterPath;
+
+          switch (path.parent.type) {
+            case 'Program':
+              insertAfterPath = path;
+              programPath = path.parentPath;
+              break;
+
+            case 'ExportNamedDeclaration':
+              insertAfterPath = path.parentPath;
+              programPath = insertAfterPath.parentPath;
+              break;
+
+            case 'ExportDefaultDeclaration':
+              insertAfterPath = path.parentPath;
+              programPath = insertAfterPath.parentPath;
+              break;
+
+            default:
+              return;
+          }
+
+          var id = node.id;
+
+          if (id === null) {
+            // We don't currently handle anonymous default exports.
+            return;
+          }
+
+          var inferredName = id.name;
+
+          if (!isComponentishName(inferredName)) {
+            return;
+          } // Make sure we're not mutating the same tree twice.
+          // This can happen if another Babel plugin replaces parents.
+
+
+          if (seenForRegistration.has(node)) {
+            return;
+          }
+
+          seenForRegistration.add(node); // Don't mutate the tree above this point.
+          // export function Named() {}
+          // function Named() {}
+
+          findInnerComponents(inferredName, path, function (persistentID, targetExpr) {
+            var handle = createRegistration(programPath, persistentID);
+            insertAfterPath.insertAfter(t.expressionStatement(t.assignmentExpression('=', handle, targetExpr)));
+          });
+        },
+        exit: function (path) {
+          var node = path.node;
+          var id = node.id;
+
+          if (id === null) {
+            return;
+          }
+
+          var signature = getHookCallsSignature(node);
+
+          if (signature === null) {
+            return;
+          } // Make sure we're not mutating the same tree twice.
+          // This can happen if another Babel plugin replaces parents.
+
+
+          if (seenForSignature.has(node)) {
+            return;
+          }
+
+          seenForSignature.add(node); // Don't mutate the tree above this point.
+
+          var sigCallID = path.scope.generateUidIdentifier('_s');
+          path.scope.parent.push({
+            id: sigCallID,
+            init: t.callExpression(t.identifier('$RefreshSig$'), [])
+          }); // The signature call is split in two parts. One part is called inside the function.
+          // This is used to signal when first render happens.
+
+          path.get('body').unshiftContainer('body', t.expressionStatement(t.callExpression(sigCallID, []))); // The second call is around the function itself.
+          // This is used to associate a type with a signature.
+          // Unlike with $RefreshReg$, this needs to work for nested
+          // declarations too. So we need to search for a path where
+          // we can insert a statement rather than hardcoding it.
+
+          var insertAfterPath = null;
+          path.find(function (p) {
+            if (p.parentPath.isBlock()) {
+              insertAfterPath = p;
+              return true;
+            }
+          });
+
+          if (insertAfterPath === null) {
+            return;
+          }
+
+          insertAfterPath.insertAfter(t.expressionStatement(t.callExpression(sigCallID, createArgumentsForSignature(id, signature, insertAfterPath.scope))));
+        }
+      },
+      'ArrowFunctionExpression|FunctionExpression': {
+        exit: function (path) {
+          var node = path.node;
+          var signature = getHookCallsSignature(node);
+
+          if (signature === null) {
+            return;
+          } // Make sure we're not mutating the same tree twice.
+          // This can happen if another Babel plugin replaces parents.
+
+
+          if (seenForSignature.has(node)) {
+            return;
+          }
+
+          seenForSignature.add(node); // Don't mutate the tree above this point.
+
+          var sigCallID = path.scope.generateUidIdentifier('_s');
+          path.scope.parent.push({
+            id: sigCallID,
+            init: t.callExpression(t.identifier('$RefreshSig$'), [])
+          }); // The signature call is split in two parts. One part is called inside the function.
+          // This is used to signal when first render happens.
+
+          if (path.node.body.type !== 'BlockStatement') {
+            path.node.body = t.blockStatement([t.returnStatement(path.node.body)]);
+          }
+
+          path.get('body').unshiftContainer('body', t.expressionStatement(t.callExpression(sigCallID, []))); // The second call is around the function itself.
+          // This is used to associate a type with a signature.
+
+          if (path.parent.type === 'VariableDeclarator') {
+            var insertAfterPath = null;
+            path.find(function (p) {
+              if (p.parentPath.isBlock()) {
+                insertAfterPath = p;
+                return true;
+              }
+            });
+
+            if (insertAfterPath === null) {
+              return;
+            } // Special case when a function would get an inferred name:
+            // let Foo = () => {}
+            // let Foo = function() {}
+            // We'll add signature it on next line so that
+            // we don't mess up the inferred 'Foo' function name.
+
+
+            insertAfterPath.insertAfter(t.expressionStatement(t.callExpression(sigCallID, createArgumentsForSignature(path.parent.id, signature, insertAfterPath.scope)))); // Result: let Foo = () => {}; __signature(Foo, ...);
+          } else {
+            // let Foo = hoc(() => {})
+            path.replaceWith(t.callExpression(sigCallID, createArgumentsForSignature(node, signature, path.scope))); // Result: let Foo = hoc(__signature(() => {}, ...))
+          }
+        }
+      },
+      VariableDeclaration: function (path) {
+        var node = path.node;
+        var programPath;
+        var insertAfterPath;
+
+        switch (path.parent.type) {
+          case 'Program':
+            insertAfterPath = path;
+            programPath = path.parentPath;
+            break;
+
+          case 'ExportNamedDeclaration':
+            insertAfterPath = path.parentPath;
+            programPath = insertAfterPath.parentPath;
+            break;
+
+          case 'ExportDefaultDeclaration':
+            insertAfterPath = path.parentPath;
+            programPath = insertAfterPath.parentPath;
+            break;
+
+          default:
+            return;
+        } // Make sure we're not mutating the same tree twice.
+        // This can happen if another Babel plugin replaces parents.
+
+
+        if (seenForRegistration.has(node)) {
+          return;
+        }
+
+        seenForRegistration.add(node); // Don't mutate the tree above this point.
+
+        var declPaths = path.get('declarations');
+
+        if (declPaths.length !== 1) {
+          return;
+        }
+
+        var declPath = declPaths[0];
+        var inferredName = declPath.node.id.name;
+        findInnerComponents(inferredName, declPath, function (persistentID, targetExpr, targetPath) {
+          if (targetPath === null) {
+            // For case like:
+            // export const Something = hoc(Foo)
+            // we don't want to wrap Foo inside the call.
+            // Instead we assume it's registered at definition.
+            return;
+          }
+
+          var handle = createRegistration(programPath, persistentID);
+
+          if ((targetExpr.type === 'ArrowFunctionExpression' || targetExpr.type === 'FunctionExpression') && targetPath.parent.type === 'VariableDeclarator') {
+            // Special case when a function would get an inferred name:
+            // let Foo = () => {}
+            // let Foo = function() {}
+            // We'll register it on next line so that
+            // we don't mess up the inferred 'Foo' function name.
+            insertAfterPath.insertAfter(t.expressionStatement(t.assignmentExpression('=', handle, declPath.node.id))); // Result: let Foo = () => {}; _c1 = Foo;
+          } else {
+            // let Foo = hoc(() => {})
+            targetPath.replaceWith(t.assignmentExpression('=', handle, targetExpr)); // Result: let Foo = _c1 = hoc(() => {})
+          }
+        });
+      },
+      Program: {
+        enter: function (path) {
+          // This is a separate early visitor because we need to collect Hook calls
+          // and "const [foo, setFoo] = ..." signatures before the destructuring
+          // transform mangles them. This extra traversal is not ideal for perf,
+          // but it's the best we can do until we stop transpiling destructuring.
+          path.traverse(HookCallsVisitor);
+        },
+        exit: function (path) {
+          var registrations = registrationsByProgramPath.get(path);
+
+          if (registrations === undefined) {
+            return;
+          } // Make sure we're not mutating the same tree twice.
+          // This can happen if another Babel plugin replaces parents.
+
+
+          var node = path.node;
+
+          if (seenForOutro.has(node)) {
+            return;
+          }
+
+          seenForOutro.add(node); // Don't mutate the tree above this point.
+
+          registrationsByProgramPath.delete(path);
+          var declarators = [];
+          path.pushContainer('body', t.variableDeclaration('var', declarators));
+          registrations.forEach(function (_ref) {
+            var handle = _ref.handle,
+                persistentID = _ref.persistentID;
+            path.pushContainer('body', t.expressionStatement(t.callExpression(t.identifier('$RefreshReg$'), [handle, t.stringLiteral(persistentID)])));
+            declarators.push(t.variableDeclarator(handle));
+          });
+        }
+      }
+    }
+  };
+};
+
+var ReactFreshBabelPlugin$1 = Object.freeze({
+	default: ReactFreshBabelPlugin
+});
+
+var ReactFreshBabelPlugin$2 = ( ReactFreshBabelPlugin$1 && ReactFreshBabelPlugin ) || ReactFreshBabelPlugin$1;
+
+// This is hacky but makes it work with both Rollup and Jest.
+
+
+var babel = ReactFreshBabelPlugin$2.default || ReactFreshBabelPlugin$2;
+
+module.exports = babel;
+  })();
+}

node_modules/react-refresh/cjs/react-refresh-babel.production.min.js

@@ -0,0 +1,23 @@
+/** @license React vundefined
+ * react-refresh-babel.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';function v(q){function r(a,b){var d=a.scope.generateUidIdentifier("c");l.has(a)||l.set(a,[]);l.get(a).push({handle:d,persistentID:b});return d}function t(a){return"string"===typeof a&&"A"<=a[0]&&"Z">=a[0]}function m(a,b,d){var c=b.node;switch(c.type){case "Identifier":if(!t(c.name))break;d(a,c,null);return!0;case "FunctionDeclaration":return d(a,c.id,null),!0;case "ArrowFunctionExpression":if("ArrowFunctionExpression"===c.body.type)break;d(a,c,b);return!0;case "FunctionExpression":return d(a,
+c,b),!0;case "CallExpression":var f=b.get("arguments");if(void 0===f||0===f.length)break;var g=b.get("callee");switch(g.node.type){case "MemberExpression":case "Identifier":g=g.getSource();if(!m(a+"$"+g,f[0],d))return!1;d(a,c,b);return!0;default:return!1}case "VariableDeclarator":if(f=c.init,null!==f&&(g=c.id.name,t(g))){switch(f.type){case "ArrowFunctionExpression":case "FunctionExpression":break;case "CallExpression":c=f.callee;var e=c.type;if("Import"===e)return!1;if("Identifier"===e){if(0===c.name.indexOf("require")||
+0===c.name.indexOf("import"))return!1}else if("MemberExpression"!==e)return!1;break;case "TaggedTemplateExpression":break;default:return!1}c=b.get("init");if(m(a,c,d))return!0;g=b.scope.getBinding(g);if(void 0===g)return;b=!1;g=g.referencePaths;for(e=0;e<g.length;e++){var h=g[e];if("JSXIdentifier"===h.node.type||"Identifier"===h.node.type){h=h.parent;if("JSXOpeningElement"===h.type)b=!0;else if("CallExpression"===h.type){h=h.callee;var k=void 0;switch(h.type){case "Identifier":k=h.name;break;case "MemberExpression":k=
+h.property.name}switch(k){case "createElement":case "jsx":case "jsxDEV":case "jsxs":b=!0}}if(b)return d(a,f,c),!0}}}}return!1}function w(a){a=n.get(a);return void 0===a?null:{key:a.map(function(a){return a.name+"{"+a.key+"}"}).join("\n"),customHooks:a.filter(function(a){a:switch(a.name){case "useState":case "React.useState":case "useReducer":case "React.useReducer":case "useEffect":case "React.useEffect":case "useLayoutEffect":case "React.useLayoutEffect":case "useMemo":case "React.useMemo":case "useCallback":case "React.useCallback":case "useRef":case "React.useRef":case "useContext":case "React.useContext":case "useImperativeMethods":case "React.useImperativeMethods":case "useDebugValue":case "React.useDebugValue":a=
+!0;break a;default:a=!1}return!a}).map(function(a){return e.cloneDeep(a.callee)})}}function D(a){a=a.hub.file;var b=x.get(a);if(void 0!==b)return b;b=!1;for(var d=a.ast.comments,c=0;c<d.length;c++)if(-1!==d[c].value.indexOf("@refresh reset")){b=!0;break}x.set(a,b);return b}function u(a,b,d){var c=b.key;b=b.customHooks;var f=D(d.path),g=[];b.forEach(function(a){switch(a.type){case "MemberExpression":if("Identifier"===a.object.type)var b=a.object.name;break;case "Identifier":b=a.name}d.hasBinding(b)?
+g.push(a):f=!0});b=c;"function"!==typeof require||y.emitFullSignatures||(b=require("crypto").createHash("sha1").update(c).digest("base64"));a=[a,e.stringLiteral(b)];(f||0<g.length)&&a.push(e.booleanLiteral(f));0<g.length&&a.push(e.functionExpression(null,[],e.blockStatement([e.returnStatement(e.arrayExpression(g))])));return a}var y=1<arguments.length&&void 0!==arguments[1]?arguments[1]:{};if("function"===typeof q.getEnv){var z=q.getEnv();if("development"!==z&&!y.skipEnvCheck)throw Error('React Refresh Babel transform should only be enabled in development environment. Instead, the environment is: "'+
+z+'". If you want to override this check, pass {skipEnvCheck: true} as plugin options.');}var e=q.types,l=new Map,x=new WeakMap,k=new WeakSet,p=new WeakSet,A=new WeakSet,n=new WeakMap,E={CallExpression:function(a){var b=a.node.callee,d=null;switch(b.type){case "Identifier":d=b.name;break;case "MemberExpression":d=b.property.name}if(null!==d&&/^use[A-Z]/.test(d)&&(b=a.scope.getFunctionParent(),null!==b)){b=b.block;n.has(b)||n.set(b,[]);b=n.get(b);var c="";"VariableDeclarator"===a.parent.type&&(c=a.parentPath.get("id").getSource());
+var f=a.get("arguments");"useState"===d&&0<f.length?c+="("+f[0].getSource()+")":"useReducer"===d&&1<f.length&&(c+="("+f[1].getSource()+")");b.push({callee:a.node.callee,name:d,key:c})}}};return{visitor:{ExportDefaultDeclaration:function(a){var b=a.node,d=b.declaration,c=a.get("declaration");if("CallExpression"===d.type&&!k.has(b)){k.add(b);var f=a.parentPath;m("%default%",c,function(a,b,c){null!==c&&(a=r(f,a),c.replaceWith(e.assignmentExpression("=",a,b)))})}},FunctionDeclaration:{enter:function(a){var b=
+a.node;switch(a.parent.type){case "Program":var d=a;var c=a.parentPath;break;case "ExportNamedDeclaration":d=a.parentPath;c=d.parentPath;break;case "ExportDefaultDeclaration":d=a.parentPath;c=d.parentPath;break;default:return}var f=b.id;null!==f&&(f=f.name,t(f)&&!k.has(b)&&(k.add(b),m(f,a,function(a,b){a=r(c,a);d.insertAfter(e.expressionStatement(e.assignmentExpression("=",a,b)))})))},exit:function(a){var b=a.node,d=b.id;if(null!==d){var c=w(b);if(null!==c&&!p.has(b)){p.add(b);b=a.scope.generateUidIdentifier("_s");
+a.scope.parent.push({id:b,init:e.callExpression(e.identifier("$RefreshSig$"),[])});a.get("body").unshiftContainer("body",e.expressionStatement(e.callExpression(b,[])));var f=null;a.find(function(a){if(a.parentPath.isBlock())return f=a,!0});null!==f&&f.insertAfter(e.expressionStatement(e.callExpression(b,u(d,c,f.scope))))}}}},"ArrowFunctionExpression|FunctionExpression":{exit:function(a){var b=a.node,d=w(b);if(null!==d&&!p.has(b)){p.add(b);var c=a.scope.generateUidIdentifier("_s");a.scope.parent.push({id:c,
+init:e.callExpression(e.identifier("$RefreshSig$"),[])});"BlockStatement"!==a.node.body.type&&(a.node.body=e.blockStatement([e.returnStatement(a.node.body)]));a.get("body").unshiftContainer("body",e.expressionStatement(e.callExpression(c,[])));if("VariableDeclarator"===a.parent.type){var f=null;a.find(function(a){if(a.parentPath.isBlock())return f=a,!0});null!==f&&f.insertAfter(e.expressionStatement(e.callExpression(c,u(a.parent.id,d,f.scope))))}else a.replaceWith(e.callExpression(c,u(b,d,a.scope)))}}},
+VariableDeclaration:function(a){var b=a.node;switch(a.parent.type){case "Program":var d=a;var c=a.parentPath;break;case "ExportNamedDeclaration":d=a.parentPath;c=d.parentPath;break;case "ExportDefaultDeclaration":d=a.parentPath;c=d.parentPath;break;default:return}if(!k.has(b)&&(k.add(b),a=a.get("declarations"),1===a.length)){var f=a[0];m(f.node.id.name,f,function(a,b,h){null!==h&&(a=r(c,a),"ArrowFunctionExpression"!==b.type&&"FunctionExpression"!==b.type||"VariableDeclarator"!==h.parent.type?h.replaceWith(e.assignmentExpression("=",
+a,b)):d.insertAfter(e.expressionStatement(e.assignmentExpression("=",a,f.node.id))))})}},Program:{enter:function(a){a.traverse(E)},exit:function(a){var b=l.get(a);if(void 0!==b){var d=a.node;if(!A.has(d)){A.add(d);l.delete(a);var c=[];a.pushContainer("body",e.variableDeclaration("var",c));b.forEach(function(b){var d=b.handle;b=b.persistentID;a.pushContainer("body",e.expressionStatement(e.callExpression(e.identifier("$RefreshReg$"),[d,e.stringLiteral(b)])));c.push(e.variableDeclarator(d))})}}}}}}}
+var B={default:v},C=B&&v||B;module.exports=C.default||C;

node_modules/react-refresh/cjs/react-refresh-runtime.development.js

@@ -0,0 +1,583 @@
+/** @license React vundefined
+ * react-refresh-runtime.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+
+
+if (process.env.NODE_ENV !== "production") {
+  (function() {
+'use strict';
+
+// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
+// nor polyfill, then a plain number is used for performance.
+var hasSymbol = typeof Symbol === 'function' && Symbol.for;
+
+
+
+
+
+
+ // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
+// (unstable) APIs that have been removed. Can we remove the symbols?
+
+
+
+var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
+
+
+var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
+
+var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map; // We never remove these associations.
+// It's OK to reference families, but use WeakMap/Set for types.
+
+var allFamiliesByID = new Map();
+var allFamiliesByType = new PossiblyWeakMap();
+var allSignaturesByType = new PossiblyWeakMap(); // This WeakMap is read by React, so we only put families
+// that have actually been edited here. This keeps checks fast.
+// $FlowIssue
+
+var updatedFamiliesByType = new PossiblyWeakMap(); // This is cleared on every performReactRefresh() call.
+// It is an array of [Family, NextType] tuples.
+
+var pendingUpdates = []; // This is injected by the renderer via DevTools global hook.
+
+var helpersByRendererID = new Map();
+var helpersByRoot = new Map(); // We keep track of mounted roots so we can schedule updates.
+
+var mountedRoots = new Set(); // If a root captures an error, we add its element to this Map so we can retry on edit.
+
+var failedRoots = new Map();
+var didSomeRootFailOnMount = false;
+
+function computeFullKey(signature) {
+  if (signature.fullKey !== null) {
+    return signature.fullKey;
+  }
+
+  var fullKey = signature.ownKey;
+  var hooks;
+
+  try {
+    hooks = signature.getCustomHooks();
+  } catch (err) {
+    // This can happen in an edge case, e.g. if expression like Foo.useSomething
+    // depends on Foo which is lazily initialized during rendering.
+    // In that case just assume we'll have to remount.
+    signature.forceReset = true;
+    signature.fullKey = fullKey;
+    return fullKey;
+  }
+
+  for (var i = 0; i < hooks.length; i++) {
+    var hook = hooks[i];
+
+    if (typeof hook !== 'function') {
+      // Something's wrong. Assume we need to remount.
+      signature.forceReset = true;
+      signature.fullKey = fullKey;
+      return fullKey;
+    }
+
+    var nestedHookSignature = allSignaturesByType.get(hook);
+
+    if (nestedHookSignature === undefined) {
+      // No signature means Hook wasn't in the source code, e.g. in a library.
+      // We'll skip it because we can assume it won't change during this session.
+      continue;
+    }
+
+    var nestedHookKey = computeFullKey(nestedHookSignature);
+
+    if (nestedHookSignature.forceReset) {
+      signature.forceReset = true;
+    }
+
+    fullKey += '\n---\n' + nestedHookKey;
+  }
+
+  signature.fullKey = fullKey;
+  return fullKey;
+}
+
+function haveEqualSignatures(prevType, nextType) {
+  var prevSignature = allSignaturesByType.get(prevType);
+  var nextSignature = allSignaturesByType.get(nextType);
+
+  if (prevSignature === undefined && nextSignature === undefined) {
+    return true;
+  }
+
+  if (prevSignature === undefined || nextSignature === undefined) {
+    return false;
+  }
+
+  if (computeFullKey(prevSignature) !== computeFullKey(nextSignature)) {
+    return false;
+  }
+
+  if (nextSignature.forceReset) {
+    return false;
+  }
+
+  return true;
+}
+
+function isReactClass(type) {
+  return type.prototype && type.prototype.isReactComponent;
+}
+
+function canPreserveStateBetween(prevType, nextType) {
+  if (isReactClass(prevType) || isReactClass(nextType)) {
+    return false;
+  }
+
+  if (haveEqualSignatures(prevType, nextType)) {
+    return true;
+  }
+
+  return false;
+}
+
+function resolveFamily(type) {
+  // Only check updated types to keep lookups fast.
+  return updatedFamiliesByType.get(type);
+}
+
+function performReactRefresh() {
+  {
+    if (pendingUpdates.length === 0) {
+      return null;
+    }
+
+    var staleFamilies = new Set();
+    var updatedFamilies = new Set();
+    var updates = pendingUpdates;
+    pendingUpdates = [];
+    updates.forEach(function (_ref) {
+      var family = _ref[0],
+          nextType = _ref[1];
+      // Now that we got a real edit, we can create associations
+      // that will be read by the React reconciler.
+      var prevType = family.current;
+      updatedFamiliesByType.set(prevType, family);
+      updatedFamiliesByType.set(nextType, family);
+      family.current = nextType; // Determine whether this should be a re-render or a re-mount.
+
+      if (canPreserveStateBetween(prevType, nextType)) {
+        updatedFamilies.add(family);
+      } else {
+        staleFamilies.add(family);
+      }
+    }); // TODO: rename these fields to something more meaningful.
+
+    var update = {
+      updatedFamilies: updatedFamilies,
+      // Families that will re-render preserving state
+      staleFamilies: staleFamilies // Families that will be remounted
+
+    };
+    helpersByRendererID.forEach(function (helpers) {
+      // Even if there are no roots, set the handler on first update.
+      // This ensures that if *new* roots are mounted, they'll use the resolve handler.
+      helpers.setRefreshHandler(resolveFamily);
+    });
+    var didError = false;
+    var firstError = null;
+    failedRoots.forEach(function (element, root) {
+      var helpers = helpersByRoot.get(root);
+
+      if (helpers === undefined) {
+        throw new Error('Could not find helpers for a root. This is a bug in React Refresh.');
+      }
+
+      try {
+        helpers.scheduleRoot(root, element);
+      } catch (err) {
+        if (!didError) {
+          didError = true;
+          firstError = err;
+        } // Keep trying other roots.
+
+      }
+    });
+    mountedRoots.forEach(function (root) {
+      var helpers = helpersByRoot.get(root);
+
+      if (helpers === undefined) {
+        throw new Error('Could not find helpers for a root. This is a bug in React Refresh.');
+      }
+
+      try {
+        helpers.scheduleRefresh(root, update);
+      } catch (err) {
+        if (!didError) {
+          didError = true;
+          firstError = err;
+        } // Keep trying other roots.
+
+      }
+    });
+
+    if (didError) {
+      throw firstError;
+    }
+
+    return update;
+  }
+}
+function register(type, id) {
+  {
+    if (type === null) {
+      return;
+    }
+
+    if (typeof type !== 'function' && typeof type !== 'object') {
+      return;
+    } // This can happen in an edge case, e.g. if we register
+    // return value of a HOC but it returns a cached component.
+    // Ignore anything but the first registration for each type.
+
+
+    if (allFamiliesByType.has(type)) {
+      return;
+    } // Create family or remember to update it.
+    // None of this bookkeeping affects reconciliation
+    // until the first performReactRefresh() call above.
+
+
+    var family = allFamiliesByID.get(id);
+
+    if (family === undefined) {
+      family = {
+        current: type
+      };
+      allFamiliesByID.set(id, family);
+    } else {
+      pendingUpdates.push([family, type]);
+    }
+
+    allFamiliesByType.set(type, family); // Visit inner types because we might not have registered them.
+
+    if (typeof type === 'object' && type !== null) {
+      switch (type.$$typeof) {
+        case REACT_FORWARD_REF_TYPE:
+          register(type.render, id + '$render');
+          break;
+
+        case REACT_MEMO_TYPE:
+          register(type.type, id + '$type');
+          break;
+      }
+    }
+  }
+}
+function setSignature(type, key) {
+  var forceReset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var getCustomHooks = arguments.length > 3 ? arguments[3] : undefined;
+
+  {
+    allSignaturesByType.set(type, {
+      forceReset: forceReset,
+      ownKey: key,
+      fullKey: null,
+      getCustomHooks: getCustomHooks || function () {
+        return [];
+      }
+    });
+  }
+} // This is lazily called during first render for a type.
+// It captures Hook list at that time so inline requires don't break comparisons.
+
+function collectCustomHooksForSignature(type) {
+  {
+    var signature = allSignaturesByType.get(type);
+
+    if (signature !== undefined) {
+      computeFullKey(signature);
+    }
+  }
+}
+function getFamilyByID(id) {
+  {
+    return allFamiliesByID.get(id);
+  }
+}
+function getFamilyByType(type) {
+  {
+    return allFamiliesByType.get(type);
+  }
+}
+function findAffectedHostInstances(families) {
+  {
+    var affectedInstances = new Set();
+    mountedRoots.forEach(function (root) {
+      var helpers = helpersByRoot.get(root);
+
+      if (helpers === undefined) {
+        throw new Error('Could not find helpers for a root. This is a bug in React Refresh.');
+      }
+
+      var instancesForRoot = helpers.findHostInstancesForRefresh(root, families);
+      instancesForRoot.forEach(function (inst) {
+        affectedInstances.add(inst);
+      });
+    });
+    return affectedInstances;
+  }
+}
+function injectIntoGlobalHook(globalObject) {
+  {
+    // For React Native, the global hook will be set up by require('react-devtools-core').
+    // That code will run before us. So we need to monkeypatch functions on existing hook.
+    // For React Web, the global hook will be set up by the extension.
+    // This will also run before us.
+    var hook = globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+
+    if (hook === undefined) {
+      // However, if there is no DevTools extension, we'll need to set up the global hook ourselves.
+      // Note that in this case it's important that renderer code runs *after* this method call.
+      // Otherwise, the renderer will think that there is no global hook, and won't do the injection.
+      var nextID = 0;
+      globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook = {
+        supportsFiber: true,
+        inject: function (injected) {
+          return nextID++;
+        },
+        onCommitFiberRoot: function (id, root, maybePriorityLevel, didError) {},
+        onCommitFiberUnmount: function () {}
+      };
+    } // Here, we just want to get a reference to scheduleRefresh.
+
+
+    var oldInject = hook.inject;
+
+    hook.inject = function (injected) {
+      var id = oldInject.apply(this, arguments);
+
+      if (typeof injected.scheduleRefresh === 'function' && typeof injected.setRefreshHandler === 'function') {
+        // This version supports React Refresh.
+        helpersByRendererID.set(id, injected);
+      }
+
+      return id;
+    }; // We also want to track currently mounted roots.
+
+
+    var oldOnCommitFiberRoot = hook.onCommitFiberRoot;
+
+    hook.onCommitFiberRoot = function (id, root, maybePriorityLevel, didError) {
+      var helpers = helpersByRendererID.get(id);
+
+      if (helpers === undefined) {
+        return;
+      }
+
+      helpersByRoot.set(root, helpers);
+      var current = root.current;
+      var alternate = current.alternate; // We need to determine whether this root has just (un)mounted.
+      // This logic is copy-pasted from similar logic in the DevTools backend.
+      // If this breaks with some refactoring, you'll want to update DevTools too.
+
+      if (alternate !== null) {
+        var wasMounted = alternate.memoizedState != null && alternate.memoizedState.element != null;
+        var isMounted = current.memoizedState != null && current.memoizedState.element != null;
+
+        if (!wasMounted && isMounted) {
+          // Mount a new root.
+          mountedRoots.add(root);
+          failedRoots.delete(root);
+        } else if (wasMounted && isMounted) {// Update an existing root.
+          // This doesn't affect our mounted root Set.
+        } else if (wasMounted && !isMounted) {
+          // Unmount an existing root.
+          mountedRoots.delete(root);
+
+          if (didError) {
+            // We'll remount it on future edits.
+            // Remember what was rendered so we can restore it.
+            failedRoots.set(root, alternate.memoizedState.element);
+          } else {
+            helpersByRoot.delete(root);
+          }
+        } else if (!wasMounted && !isMounted) {
+          if (didError && !failedRoots.has(root)) {
+            // The root had an error during the initial mount.
+            // We can't read its last element from the memoized state
+            // because there was no previously committed alternate.
+            // Ideally, it would be nice if we had a way to extract
+            // the last attempted rendered element, but accessing the update queue
+            // would tie this package too closely to the reconciler version.
+            // So instead, we just set a flag.
+            // TODO: Maybe we could fix this as the same time as when we fix
+            // DevTools to not depend on `alternate.memoizedState.element`.
+            didSomeRootFailOnMount = true;
+          }
+        }
+      } else {
+        // Mount a new root.
+        mountedRoots.add(root);
+      }
+
+      return oldOnCommitFiberRoot.apply(this, arguments);
+    };
+  }
+}
+function hasUnrecoverableErrors() {
+  return didSomeRootFailOnMount;
+} // Exposed for testing.
+
+function _getMountedRootCount() {
+  {
+    return mountedRoots.size;
+  }
+} // This is a wrapper over more primitive functions for setting signature.
+// Signatures let us decide whether the Hook order has changed on refresh.
+//
+// This function is intended to be used as a transform target, e.g.:
+// var _s = createSignatureFunctionForTransform()
+//
+// function Hello() {
+//   const [foo, setFoo] = useState(0);
+//   const value = useCustomHook();
+//   _s(); /* Second call triggers collecting the custom Hook list.
+//          * This doesn't happen during the module evaluation because we
+//          * don't want to change the module order with inline requires.
+//          * Next calls are noops. */
+//   return <h1>Hi</h1>;
+// }
+//
+// /* First call specifies the signature: */
+// _s(
+//   Hello,
+//   'useState{[foo, setFoo]}(0)',
+//   () => [useCustomHook], /* Lazy to avoid triggering inline requires */
+// );
+
+function createSignatureFunctionForTransform() {
+  {
+    // We'll fill in the signature in two steps.
+    // First, we'll know the signature itself. This happens outside the component.
+    // Then, we'll know the references to custom Hooks. This happens inside the component.
+    // After that, the returned function will be a fast path no-op.
+    var status = 'needsSignature';
+    var savedType;
+    var hasCustomHooks;
+    return function (type, key, forceReset, getCustomHooks) {
+      switch (status) {
+        case 'needsSignature':
+          if (type !== undefined) {
+            // If we received an argument, this is the initial registration call.
+            savedType = type;
+            hasCustomHooks = typeof getCustomHooks === 'function';
+            setSignature(type, key, forceReset, getCustomHooks); // The next call we expect is from inside a function, to fill in the custom Hooks.
+
+            status = 'needsCustomHooks';
+          }
+
+          break;
+
+        case 'needsCustomHooks':
+          if (hasCustomHooks) {
+            collectCustomHooksForSignature(savedType);
+          }
+
+          status = 'resolved';
+          break;
+
+        case 'resolved':
+          // Do nothing. Fast path for all future renders.
+          break;
+      }
+
+      return type;
+    };
+  }
+}
+function isLikelyComponentType(type) {
+  {
+    switch (typeof type) {
+      case 'function':
+        {
+          // First, deal with classes.
+          if (type.prototype != null) {
+            if (type.prototype.isReactComponent) {
+              // React class.
+              return true;
+            }
+
+            var ownNames = Object.getOwnPropertyNames(type.prototype);
+
+            if (ownNames.length > 1 || ownNames[0] !== 'constructor') {
+              // This looks like a class.
+              return false;
+            } // eslint-disable-next-line no-proto
+
+
+            if (type.prototype.__proto__ !== Object.prototype) {
+              // It has a superclass.
+              return false;
+            } // Pass through.
+            // This looks like a regular function with empty prototype.
+
+          } // For plain functions and arrows, use name as a heuristic.
+
+
+          var name = type.name || type.displayName;
+          return typeof name === 'string' && /^[A-Z]/.test(name);
+        }
+
+      case 'object':
+        {
+          if (type != null) {
+            switch (type.$$typeof) {
+              case REACT_FORWARD_REF_TYPE:
+              case REACT_MEMO_TYPE:
+                // Definitely React components.
+                return true;
+
+              default:
+                return false;
+            }
+          }
+
+          return false;
+        }
+
+      default:
+        {
+          return false;
+        }
+    }
+  }
+}
+
+var ReactFreshRuntime = Object.freeze({
+	performReactRefresh: performReactRefresh,
+	register: register,
+	setSignature: setSignature,
+	collectCustomHooksForSignature: collectCustomHooksForSignature,
+	getFamilyByID: getFamilyByID,
+	getFamilyByType: getFamilyByType,
+	findAffectedHostInstances: findAffectedHostInstances,
+	injectIntoGlobalHook: injectIntoGlobalHook,
+	hasUnrecoverableErrors: hasUnrecoverableErrors,
+	_getMountedRootCount: _getMountedRootCount,
+	createSignatureFunctionForTransform: createSignatureFunctionForTransform,
+	isLikelyComponentType: isLikelyComponentType
+});
+
+// This is hacky but makes it work with both Rollup and Jest.
+
+
+var runtime = ReactFreshRuntime.default || ReactFreshRuntime;
+
+module.exports = runtime;
+  })();
+}

node_modules/react-refresh/cjs/react-refresh-runtime.production.min.js

@@ -0,0 +1,10 @@
+/** @license React vundefined
+ * react-refresh-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';throw Error("React Refresh runtime should not be included in the production bundle.");

node_modules/react-refresh/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "react-refresh",
+  "description": "React is a JavaScript library for building user interfaces.",
+  "keywords": [
+    "react"
+  ],
+  "version": "0.4.3",
+  "homepage": "https://reactjs.org/",
+  "bugs": "https://github.com/facebook/react/issues",
+  "license": "MIT",
+  "files": [
+    "LICENSE",
+    "README.md",
+    "babel.js",
+    "runtime.js",
+    "build-info.json",
+    "cjs/",
+    "umd/"
+  ],
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/react.git",
+    "directory": "packages/react"
+  },
+  "engines": {
+    "node": ">=0.10.0"
+  }
+}

node_modules/react-refresh/runtime.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./cjs/react-refresh-runtime.production.min.js');
+} else {
+  module.exports = require('./cjs/react-refresh-runtime.development.js');
+}