react-refresh 0.15.0-next-5dd90c562-20230502 → 0.16.0-beta-94eed63c49-20240425

package/babel.js

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

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

@@ -269,6 +269,24 @@ function ReactFreshBabelPlugin (babel) {
       case 'React.useImperativeHandle':
       case 'useDebugValue':
       case 'React.useDebugValue':
+      case 'useId':
+      case 'React.useId':
+      case 'useDeferredValue':
+      case 'React.useDeferredValue':
+      case 'useTransition':
+      case 'React.useTransition':
+      case 'useInsertionEffect':
+      case 'React.useInsertionEffect':
+      case 'useSyncExternalStore':
+      case 'React.useSyncExternalStore':
+      case 'useFormStatus':
+      case 'React.useFormStatus':
+      case 'useFormState':
+      case 'React.useFormState':
+      case 'useActionState':
+      case 'React.useActionState':
+      case 'useOptimistic':
+      case 'React.useOptimistic':
         return true;
 
       default:

package/cjs/react-refresh-babel.production.js

@@ -0,0 +1,586 @@
+/**
+ * @license React
+ * react-refresh-babel.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and 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";
+module.exports = function (babel) {
+  function createRegistration(programPath, persistentID) {
+    var handle = programPath.scope.generateUidIdentifier("c");
+    registrationsByProgramPath.has(programPath) ||
+      registrationsByProgramPath.set(programPath, []);
+    registrationsByProgramPath
+      .get(programPath)
+      .push({ handle: handle, persistentID: persistentID });
+    return handle;
+  }
+  function isComponentishName(name) {
+    return "string" === typeof name && "A" <= name[0] && "Z" >= name[0];
+  }
+  function findInnerComponents(inferredName, path, callback) {
+    var node = path.node;
+    switch (node.type) {
+      case "Identifier":
+        if (!isComponentishName(node.name)) break;
+        callback(inferredName, node, null);
+        return !0;
+      case "FunctionDeclaration":
+        return callback(inferredName, node.id, null), !0;
+      case "ArrowFunctionExpression":
+        if ("ArrowFunctionExpression" === node.body.type) break;
+        callback(inferredName, node, path);
+        return !0;
+      case "FunctionExpression":
+        return callback(inferredName, node, path), !0;
+      case "CallExpression":
+        var argsPath = path.get("arguments");
+        if (void 0 === argsPath || 0 === argsPath.length) break;
+        var calleePath = path.get("callee");
+        switch (calleePath.node.type) {
+          case "MemberExpression":
+          case "Identifier":
+            calleePath = calleePath.getSource();
+            if (
+              !findInnerComponents(
+                inferredName + "$" + calleePath,
+                argsPath[0],
+                callback
+              )
+            )
+              return !1;
+            callback(inferredName, node, path);
+            return !0;
+          default:
+            return !1;
+        }
+      case "VariableDeclarator":
+        if (
+          ((argsPath = node.init),
+          null !== argsPath &&
+            ((calleePath = node.id.name), isComponentishName(calleePath)))
+        ) {
+          switch (argsPath.type) {
+            case "ArrowFunctionExpression":
+            case "FunctionExpression":
+              break;
+            case "CallExpression":
+              node = argsPath.callee;
+              var calleeType = node.type;
+              if (
+                "Import" === calleeType ||
+                ("Identifier" === calleeType &&
+                  (0 === node.name.indexOf("require") ||
+                    0 === node.name.indexOf("import")))
+              )
+                return !1;
+              break;
+            case "TaggedTemplateExpression":
+              break;
+            default:
+              return !1;
+          }
+          node = path.get("init");
+          if (findInnerComponents(inferredName, node, callback)) return !0;
+          calleePath = path.scope.getBinding(calleePath);
+          if (void 0 === calleePath) return;
+          path = !1;
+          calleePath = calleePath.referencePaths;
+          for (calleeType = 0; calleeType < calleePath.length; calleeType++) {
+            var ref = calleePath[calleeType];
+            if (
+              !ref.node ||
+              "JSXIdentifier" === ref.node.type ||
+              "Identifier" === ref.node.type
+            ) {
+              ref = ref.parent;
+              if ("JSXOpeningElement" === ref.type) path = !0;
+              else if ("CallExpression" === ref.type) {
+                ref = ref.callee;
+                var fnName = void 0;
+                switch (ref.type) {
+                  case "Identifier":
+                    fnName = ref.name;
+                    break;
+                  case "MemberExpression":
+                    fnName = ref.property.name;
+                }
+                switch (fnName) {
+                  case "createElement":
+                  case "jsx":
+                  case "jsxDEV":
+                  case "jsxs":
+                    path = !0;
+                }
+              }
+              if (path) return callback(inferredName, argsPath, node), !0;
+            }
+          }
+        }
+    }
+    return !1;
+  }
+  function getHookCallsSignature(functionNode) {
+    functionNode = hookCalls.get(functionNode);
+    return void 0 === functionNode
+      ? null
+      : {
+          key: functionNode
+            .map(function (call) {
+              return call.name + "{" + call.key + "}";
+            })
+            .join("\n"),
+          customHooks: functionNode
+            .filter(function (call) {
+              a: switch (call.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 "useImperativeHandle":
+                case "React.useImperativeHandle":
+                case "useDebugValue":
+                case "React.useDebugValue":
+                case "useId":
+                case "React.useId":
+                case "useDeferredValue":
+                case "React.useDeferredValue":
+                case "useTransition":
+                case "React.useTransition":
+                case "useInsertionEffect":
+                case "React.useInsertionEffect":
+                case "useSyncExternalStore":
+                case "React.useSyncExternalStore":
+                case "useFormStatus":
+                case "React.useFormStatus":
+                case "useFormState":
+                case "React.useFormState":
+                case "useActionState":
+                case "React.useActionState":
+                case "useOptimistic":
+                case "React.useOptimistic":
+                  call = !0;
+                  break a;
+                default:
+                  call = !1;
+              }
+              return !call;
+            })
+            .map(function (call) {
+              return t.cloneDeep(call.callee);
+            })
+        };
+  }
+  function hasForceResetComment(path) {
+    path = path.hub.file;
+    var hasForceReset = hasForceResetCommentByFile.get(path);
+    if (void 0 !== hasForceReset) return hasForceReset;
+    hasForceReset = !1;
+    for (var comments = path.ast.comments, i = 0; i < comments.length; i++)
+      if (-1 !== comments[i].value.indexOf("@refresh reset")) {
+        hasForceReset = !0;
+        break;
+      }
+    hasForceResetCommentByFile.set(path, hasForceReset);
+    return hasForceReset;
+  }
+  function createArgumentsForSignature(node, signature, scope) {
+    var key = signature.key;
+    signature = signature.customHooks;
+    var forceReset = hasForceResetComment(scope.path),
+      customHooksInScope = [];
+    signature.forEach(function (callee) {
+      switch (callee.type) {
+        case "MemberExpression":
+          if ("Identifier" === callee.object.type)
+            var bindingName = callee.object.name;
+          break;
+        case "Identifier":
+          bindingName = callee.name;
+      }
+      scope.hasBinding(bindingName)
+        ? customHooksInScope.push(callee)
+        : (forceReset = !0);
+    });
+    signature = key;
+    "function" !== typeof require ||
+      opts.emitFullSignatures ||
+      (signature = require("crypto")
+        .createHash("sha1")
+        .update(key)
+        .digest("base64"));
+    node = [node, t.stringLiteral(signature)];
+    (forceReset || 0 < customHooksInScope.length) &&
+      node.push(t.booleanLiteral(forceReset));
+    0 < customHooksInScope.length &&
+      node.push(
+        t.functionExpression(
+          null,
+          [],
+          t.blockStatement([
+            t.returnStatement(t.arrayExpression(customHooksInScope))
+          ])
+        )
+      );
+    return node;
+  }
+  function findHOCCallPathsAbove(path) {
+    for (var calls = []; ; ) {
+      if (!path) return calls;
+      var parentPath = path.parentPath;
+      if (!parentPath) return calls;
+      if (
+        "AssignmentExpression" === parentPath.node.type &&
+        path.node === parentPath.node.right
+      )
+        path = parentPath;
+      else if (
+        "CallExpression" === parentPath.node.type &&
+        path.node !== parentPath.node.callee
+      )
+        calls.push(parentPath), (path = parentPath);
+      else return calls;
+    }
+  }
+  var opts =
+    1 < arguments.length && void 0 !== arguments[1] ? arguments[1] : {};
+  if ("function" === typeof babel.env) {
+    var env = babel.env();
+    if ("development" !== env && !opts.skipEnvCheck)
+      throw 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,
+    refreshReg = t.identifier(opts.refreshReg || "$RefreshReg$"),
+    refreshSig = t.identifier(opts.refreshSig || "$RefreshSig$"),
+    registrationsByProgramPath = new Map(),
+    hasForceResetCommentByFile = new WeakMap(),
+    seenForRegistration = new WeakSet(),
+    seenForSignature = new WeakSet(),
+    seenForOutro = new WeakSet(),
+    hookCalls = new WeakMap(),
+    HookCallsVisitor = {
+      CallExpression: function (path) {
+        var callee = path.node.callee,
+          name = null;
+        switch (callee.type) {
+          case "Identifier":
+            name = callee.name;
+            break;
+          case "MemberExpression":
+            name = callee.property.name;
+        }
+        if (
+          null !== name &&
+          /^use[A-Z]/.test(name) &&
+          ((callee = path.scope.getFunctionParent()), null !== callee)
+        ) {
+          callee = callee.block;
+          hookCalls.has(callee) || hookCalls.set(callee, []);
+          callee = hookCalls.get(callee);
+          var key = "";
+          "VariableDeclarator" === path.parent.type &&
+            (key = path.parentPath.get("id").getSource());
+          var args = path.get("arguments");
+          "useState" === name && 0 < args.length
+            ? (key += "(" + args[0].getSource() + ")")
+            : "useReducer" === name &&
+              1 < args.length &&
+              (key += "(" + args[1].getSource() + ")");
+          callee.push({ callee: path.node.callee, name: name, key: key });
+        }
+      }
+    };
+  return {
+    visitor: {
+      ExportDefaultDeclaration: function (path) {
+        var node = path.node,
+          decl = node.declaration,
+          declPath = path.get("declaration");
+        if ("CallExpression" === decl.type && !seenForRegistration.has(node)) {
+          seenForRegistration.add(node);
+          var programPath = path.parentPath;
+          findInnerComponents(
+            "%default%",
+            declPath,
+            function (persistentID, targetExpr, targetPath) {
+              null !== targetPath &&
+                ((persistentID = createRegistration(programPath, persistentID)),
+                targetPath.replaceWith(
+                  t.assignmentExpression("=", persistentID, targetExpr)
+                ));
+            }
+          );
+        }
+      },
+      FunctionDeclaration: {
+        enter: function (path) {
+          var node = path.node,
+            modulePrefix = "";
+          switch (path.parent.type) {
+            case "Program":
+              var insertAfterPath = path;
+              var programPath = path.parentPath;
+              break;
+            case "TSModuleBlock":
+              insertAfterPath = path;
+              programPath = insertAfterPath.parentPath.parentPath;
+              break;
+            case "ExportNamedDeclaration":
+              insertAfterPath = path.parentPath;
+              programPath = insertAfterPath.parentPath;
+              break;
+            case "ExportDefaultDeclaration":
+              insertAfterPath = path.parentPath;
+              programPath = insertAfterPath.parentPath;
+              break;
+            default:
+              return;
+          }
+          if (
+            "TSModuleBlock" === path.parent.type ||
+            "ExportNamedDeclaration" === path.parent.type
+          )
+            for (; "Program" !== programPath.type; ) {
+              if ("TSModuleDeclaration" === programPath.type) {
+                if (
+                  "Program" !== programPath.parentPath.type &&
+                  "ExportNamedDeclaration" !== programPath.parentPath.type
+                )
+                  return;
+                modulePrefix = programPath.node.id.name + "$" + modulePrefix;
+              }
+              programPath = programPath.parentPath;
+            }
+          var id = node.id;
+          null !== id &&
+            ((id = id.name),
+            isComponentishName(id) &&
+              !seenForRegistration.has(node) &&
+              (seenForRegistration.add(node),
+              findInnerComponents(
+                modulePrefix + id,
+                path,
+                function (persistentID, targetExpr) {
+                  persistentID = createRegistration(programPath, persistentID);
+                  insertAfterPath.insertAfter(
+                    t.expressionStatement(
+                      t.assignmentExpression("=", persistentID, targetExpr)
+                    )
+                  );
+                }
+              )));
+        },
+        exit: function (path) {
+          var node = path.node,
+            id = node.id;
+          if (null !== id) {
+            var signature = getHookCallsSignature(node);
+            if (null !== signature && !seenForSignature.has(node)) {
+              seenForSignature.add(node);
+              node = path.scope.generateUidIdentifier("_s");
+              path.scope.parent.push({
+                id: node,
+                init: t.callExpression(refreshSig, [])
+              });
+              path
+                .get("body")
+                .unshiftContainer(
+                  "body",
+                  t.expressionStatement(t.callExpression(node, []))
+                );
+              var insertAfterPath = null;
+              path.find(function (p) {
+                if (p.parentPath.isBlock()) return (insertAfterPath = p), !0;
+              });
+              null !== insertAfterPath &&
+                insertAfterPath.insertAfter(
+                  t.expressionStatement(
+                    t.callExpression(
+                      node,
+                      createArgumentsForSignature(
+                        id,
+                        signature,
+                        insertAfterPath.scope
+                      )
+                    )
+                  )
+                );
+            }
+          }
+        }
+      },
+      "ArrowFunctionExpression|FunctionExpression": {
+        exit: function (path) {
+          var node = path.node,
+            signature = getHookCallsSignature(node);
+          if (null !== signature && !seenForSignature.has(node)) {
+            seenForSignature.add(node);
+            var sigCallID = path.scope.generateUidIdentifier("_s");
+            path.scope.parent.push({
+              id: sigCallID,
+              init: t.callExpression(refreshSig, [])
+            });
+            "BlockStatement" !== path.node.body.type &&
+              (path.node.body = t.blockStatement([
+                t.returnStatement(path.node.body)
+              ]));
+            path
+              .get("body")
+              .unshiftContainer(
+                "body",
+                t.expressionStatement(t.callExpression(sigCallID, []))
+              );
+            if ("VariableDeclarator" === path.parent.type) {
+              var insertAfterPath = null;
+              path.find(function (p) {
+                if (p.parentPath.isBlock()) return (insertAfterPath = p), !0;
+              });
+              null !== insertAfterPath &&
+                insertAfterPath.insertAfter(
+                  t.expressionStatement(
+                    t.callExpression(
+                      sigCallID,
+                      createArgumentsForSignature(
+                        path.parent.id,
+                        signature,
+                        insertAfterPath.scope
+                      )
+                    )
+                  )
+                );
+            } else
+              [path].concat(findHOCCallPathsAbove(path)).forEach(function (p) {
+                p.replaceWith(
+                  t.callExpression(
+                    sigCallID,
+                    createArgumentsForSignature(p.node, signature, p.scope)
+                  )
+                );
+              });
+          }
+        }
+      },
+      VariableDeclaration: function (path) {
+        var node = path.node,
+          modulePrefix = "";
+        switch (path.parent.type) {
+          case "Program":
+            var insertAfterPath = path;
+            var programPath = path.parentPath;
+            break;
+          case "TSModuleBlock":
+            insertAfterPath = path;
+            programPath = insertAfterPath.parentPath.parentPath;
+            break;
+          case "ExportNamedDeclaration":
+            insertAfterPath = path.parentPath;
+            programPath = insertAfterPath.parentPath;
+            break;
+          case "ExportDefaultDeclaration":
+            insertAfterPath = path.parentPath;
+            programPath = insertAfterPath.parentPath;
+            break;
+          default:
+            return;
+        }
+        if (
+          "TSModuleBlock" === path.parent.type ||
+          "ExportNamedDeclaration" === path.parent.type
+        )
+          for (; "Program" !== programPath.type; ) {
+            if ("TSModuleDeclaration" === programPath.type) {
+              if (
+                "Program" !== programPath.parentPath.type &&
+                "ExportNamedDeclaration" !== programPath.parentPath.type
+              )
+                return;
+              modulePrefix = programPath.node.id.name + "$" + modulePrefix;
+            }
+            programPath = programPath.parentPath;
+          }
+        if (
+          !seenForRegistration.has(node) &&
+          (seenForRegistration.add(node),
+          (path = path.get("declarations")),
+          1 === path.length)
+        ) {
+          var declPath = path[0];
+          findInnerComponents(
+            modulePrefix + declPath.node.id.name,
+            declPath,
+            function (persistentID, targetExpr, targetPath) {
+              null !== targetPath &&
+                ((persistentID = createRegistration(programPath, persistentID)),
+                "VariableDeclarator" === targetPath.parent.type
+                  ? insertAfterPath.insertAfter(
+                      t.expressionStatement(
+                        t.assignmentExpression(
+                          "=",
+                          persistentID,
+                          declPath.node.id
+                        )
+                      )
+                    )
+                  : targetPath.replaceWith(
+                      t.assignmentExpression("=", persistentID, targetExpr)
+                    ));
+            }
+          );
+        }
+      },
+      Program: {
+        enter: function (path) {
+          path.traverse(HookCallsVisitor);
+        },
+        exit: function (path) {
+          var registrations = registrationsByProgramPath.get(path);
+          if (void 0 !== registrations) {
+            var node = path.node;
+            if (!seenForOutro.has(node)) {
+              seenForOutro.add(node);
+              registrationsByProgramPath.delete(path);
+              var declarators = [];
+              path.pushContainer(
+                "body",
+                t.variableDeclaration("var", declarators)
+              );
+              registrations.forEach(function (_ref) {
+                var handle = _ref.handle;
+                path.pushContainer(
+                  "body",
+                  t.expressionStatement(
+                    t.callExpression(refreshReg, [
+                      handle,
+                      t.stringLiteral(_ref.persistentID)
+                    ])
+                  )
+                );
+                declarators.push(t.variableDeclarator(handle));
+              });
+            }
+          }
+        }
+      }
+    }
+  };
+};

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

@@ -14,7 +14,6 @@ if (process.env.NODE_ENV !== "production") {
   (function() {
 'use strict';
 
-// ATTENTION
 var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
 var REACT_MEMO_TYPE = Symbol.for('react.memo');
 
@@ -557,7 +556,6 @@ function createSignatureFunctionForTransform() {
         // in HOC chains like _s(hoc1(_s(hoc2(_s(actualFunction))))).
         if (!savedType) {
           // We're in the innermost call, so this is the actual type.
-          // $FlowFixMe[escaped-generic] discovered when updating Flow
           savedType = type;
           hasCustomHooks = typeof getCustomHooks === 'function';
         } // Set the signature for all types (even wrappers!) in case

package/cjs/{react-refresh-runtime.production.min.js → react-refresh-runtime.production.js}

@@ -1,10 +1,14 @@
 /**
  * @license React
- * react-refresh-runtime.production.min.js
+ * react-refresh-runtime.production.js
  *
  * Copyright (c) Meta Platforms, Inc. and 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.");
+
+"use strict";
+throw Error(
+  "React Refresh runtime should not be included in the production bundle."
+);

package/package.json

@@ -4,8 +4,8 @@
   "keywords": [
     "react"
   ],
-  "version": "0.15.0-next-5dd90c562-20230502",
-  "homepage": "https://reactjs.org/",
+  "version": "0.16.0-beta-94eed63c49-20240425",
+  "homepage": "https://react.dev/",
   "bugs": "https://github.com/facebook/react/issues",
   "license": "MIT",
   "files": [
@@ -13,8 +13,7 @@
     "README.md",
     "babel.js",
     "runtime.js",
-    "cjs/",
-    "umd/"
+    "cjs/"
   ],
   "main": "runtime.js",
   "exports": {

package/runtime.js

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

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

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