capydash 0.1.2 → 0.1.4

data/dashboard/node_modules/react-refresh/cjs/react-refresh-babel.production.js

@@ -1,586 +0,0 @@
-/**
- * @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));
-              });
-            }
-          }
-        }
-      }
-    }
-  };
-};