Updated the files.

my-app/node_modules/@babel/generator/lib/node/index.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.needsParens = needsParens;
+exports.needsWhitespace = needsWhitespace;
+exports.needsWhitespaceAfter = needsWhitespaceAfter;
+exports.needsWhitespaceBefore = needsWhitespaceBefore;
+var whitespace = require("./whitespace.js");
+var parens = require("./parentheses.js");
+var _t = require("@babel/types");
+const {
+  FLIPPED_ALIAS_KEYS,
+  isCallExpression,
+  isExpressionStatement,
+  isMemberExpression,
+  isNewExpression
+} = _t;
+function expandAliases(obj) {
+  const map = new Map();
+  function add(type, func) {
+    const fn = map.get(type);
+    map.set(type, fn ? function (node, parent, stack) {
+      var _fn;
+      return (_fn = fn(node, parent, stack)) != null ? _fn : func(node, parent, stack);
+    } : func);
+  }
+  for (const type of Object.keys(obj)) {
+    const aliases = FLIPPED_ALIAS_KEYS[type];
+    if (aliases) {
+      for (const alias of aliases) {
+        add(alias, obj[type]);
+      }
+    } else {
+      add(type, obj[type]);
+    }
+  }
+  return map;
+}
+const expandedParens = expandAliases(parens);
+const expandedWhitespaceNodes = expandAliases(whitespace.nodes);
+function isOrHasCallExpression(node) {
+  if (isCallExpression(node)) {
+    return true;
+  }
+  return isMemberExpression(node) && isOrHasCallExpression(node.object);
+}
+function needsWhitespace(node, parent, type) {
+  var _expandedWhitespaceNo;
+  if (!node) return false;
+  if (isExpressionStatement(node)) {
+    node = node.expression;
+  }
+  const flag = (_expandedWhitespaceNo = expandedWhitespaceNodes.get(node.type)) == null ? void 0 : _expandedWhitespaceNo(node, parent);
+  if (typeof flag === "number") {
+    return (flag & type) !== 0;
+  }
+  return false;
+}
+function needsWhitespaceBefore(node, parent) {
+  return needsWhitespace(node, parent, 1);
+}
+function needsWhitespaceAfter(node, parent) {
+  return needsWhitespace(node, parent, 2);
+}
+function needsParens(node, parent, printStack) {
+  var _expandedParens$get;
+  if (!parent) return false;
+  if (isNewExpression(parent) && parent.callee === node) {
+    if (isOrHasCallExpression(node)) return true;
+  }
+  return (_expandedParens$get = expandedParens.get(node.type)) == null ? void 0 : _expandedParens$get(node, parent, printStack);
+}
+
+//# sourceMappingURL=index.js.map

my-app/node_modules/@babel/generator/lib/node/parentheses.js

@@ -0,0 +1,225 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ArrowFunctionExpression = ArrowFunctionExpression;
+exports.AssignmentExpression = AssignmentExpression;
+exports.Binary = Binary;
+exports.BinaryExpression = BinaryExpression;
+exports.ClassExpression = ClassExpression;
+exports.ConditionalExpression = ConditionalExpression;
+exports.DoExpression = DoExpression;
+exports.FunctionExpression = FunctionExpression;
+exports.FunctionTypeAnnotation = FunctionTypeAnnotation;
+exports.Identifier = Identifier;
+exports.LogicalExpression = LogicalExpression;
+exports.NullableTypeAnnotation = NullableTypeAnnotation;
+exports.ObjectExpression = ObjectExpression;
+exports.OptionalIndexedAccessType = OptionalIndexedAccessType;
+exports.OptionalCallExpression = exports.OptionalMemberExpression = OptionalMemberExpression;
+exports.SequenceExpression = SequenceExpression;
+exports.TSTypeAssertion = exports.TSSatisfiesExpression = exports.TSAsExpression = TSAsExpression;
+exports.TSInferType = TSInferType;
+exports.TSInstantiationExpression = TSInstantiationExpression;
+exports.TSIntersectionType = exports.TSUnionType = TSUnionType;
+exports.UnaryLike = UnaryLike;
+exports.IntersectionTypeAnnotation = exports.UnionTypeAnnotation = UnionTypeAnnotation;
+exports.UpdateExpression = UpdateExpression;
+exports.AwaitExpression = exports.YieldExpression = YieldExpression;
+var _t = require("@babel/types");
+const {
+  isArrayTypeAnnotation,
+  isArrowFunctionExpression,
+  isBinaryExpression,
+  isCallExpression,
+  isExportDeclaration,
+  isForOfStatement,
+  isIndexedAccessType,
+  isMemberExpression,
+  isObjectPattern,
+  isOptionalMemberExpression,
+  isYieldExpression
+} = _t;
+const PRECEDENCE = new Map([["||", 0], ["??", 0], ["|>", 0], ["&&", 1], ["|", 2], ["^", 3], ["&", 4], ["==", 5], ["===", 5], ["!=", 5], ["!==", 5], ["<", 6], [">", 6], ["<=", 6], [">=", 6], ["in", 6], ["instanceof", 6], [">>", 7], ["<<", 7], [">>>", 7], ["+", 8], ["-", 8], ["*", 9], ["/", 9], ["%", 9], ["**", 10]]);
+function isTSTypeExpression(nodeType) {
+  return nodeType === "TSAsExpression" || nodeType === "TSSatisfiesExpression" || nodeType === "TSTypeAssertion";
+}
+const isClassExtendsClause = (node, parent) => {
+  const parentType = parent.type;
+  return (parentType === "ClassDeclaration" || parentType === "ClassExpression") && parent.superClass === node;
+};
+const hasPostfixPart = (node, parent) => {
+  const parentType = parent.type;
+  return (parentType === "MemberExpression" || parentType === "OptionalMemberExpression") && parent.object === node || (parentType === "CallExpression" || parentType === "OptionalCallExpression" || parentType === "NewExpression") && parent.callee === node || parentType === "TaggedTemplateExpression" && parent.tag === node || parentType === "TSNonNullExpression";
+};
+function NullableTypeAnnotation(node, parent) {
+  return isArrayTypeAnnotation(parent);
+}
+function FunctionTypeAnnotation(node, parent, printStack) {
+  if (printStack.length < 3) return;
+  const parentType = parent.type;
+  return parentType === "UnionTypeAnnotation" || parentType === "IntersectionTypeAnnotation" || parentType === "ArrayTypeAnnotation" || parentType === "TypeAnnotation" && isArrowFunctionExpression(printStack[printStack.length - 3]);
+}
+function UpdateExpression(node, parent) {
+  return hasPostfixPart(node, parent) || isClassExtendsClause(node, parent);
+}
+function ObjectExpression(node, parent, printStack) {
+  return isFirstInContext(printStack, 1 | 2);
+}
+function DoExpression(node, parent, printStack) {
+  return !node.async && isFirstInContext(printStack, 1);
+}
+function Binary(node, parent) {
+  const parentType = parent.type;
+  if (node.operator === "**" && parentType === "BinaryExpression" && parent.operator === "**") {
+    return parent.left === node;
+  }
+  if (isClassExtendsClause(node, parent)) {
+    return true;
+  }
+  if (hasPostfixPart(node, parent) || parentType === "UnaryExpression" || parentType === "SpreadElement" || parentType === "AwaitExpression") {
+    return true;
+  }
+  if (parentType === "BinaryExpression" || parentType === "LogicalExpression") {
+    const parentPos = PRECEDENCE.get(parent.operator);
+    const nodePos = PRECEDENCE.get(node.operator);
+    if (parentPos === nodePos && parent.right === node && parentType !== "LogicalExpression" || parentPos > nodePos) {
+      return true;
+    }
+  }
+  return undefined;
+}
+function UnionTypeAnnotation(node, parent) {
+  const parentType = parent.type;
+  return parentType === "ArrayTypeAnnotation" || parentType === "NullableTypeAnnotation" || parentType === "IntersectionTypeAnnotation" || parentType === "UnionTypeAnnotation";
+}
+function OptionalIndexedAccessType(node, parent) {
+  return isIndexedAccessType(parent) && parent.objectType === node;
+}
+function TSAsExpression() {
+  return true;
+}
+function TSUnionType(node, parent) {
+  const parentType = parent.type;
+  return parentType === "TSArrayType" || parentType === "TSOptionalType" || parentType === "TSIntersectionType" || parentType === "TSUnionType" || parentType === "TSRestType";
+}
+function TSInferType(node, parent) {
+  const parentType = parent.type;
+  return parentType === "TSArrayType" || parentType === "TSOptionalType";
+}
+function TSInstantiationExpression(node, parent) {
+  const parentType = parent.type;
+  return (parentType === "CallExpression" || parentType === "OptionalCallExpression" || parentType === "NewExpression" || parentType === "TSInstantiationExpression") && !!parent.typeParameters;
+}
+function BinaryExpression(node, parent) {
+  if (node.operator === "in") {
+    const parentType = parent.type;
+    return parentType === "VariableDeclarator" || parentType === "ForStatement" || parentType === "ForInStatement" || parentType === "ForOfStatement";
+  }
+  return false;
+}
+function SequenceExpression(node, parent) {
+  const parentType = parent.type;
+  if (parentType === "ForStatement" || parentType === "ThrowStatement" || parentType === "ReturnStatement" || parentType === "IfStatement" && parent.test === node || parentType === "WhileStatement" && parent.test === node || parentType === "ForInStatement" && parent.right === node || parentType === "SwitchStatement" && parent.discriminant === node || parentType === "ExpressionStatement" && parent.expression === node) {
+    return false;
+  }
+  return true;
+}
+function YieldExpression(node, parent) {
+  const parentType = parent.type;
+  return parentType === "BinaryExpression" || parentType === "LogicalExpression" || parentType === "UnaryExpression" || parentType === "SpreadElement" || hasPostfixPart(node, parent) || parentType === "AwaitExpression" && isYieldExpression(node) || parentType === "ConditionalExpression" && node === parent.test || isClassExtendsClause(node, parent);
+}
+function ClassExpression(node, parent, printStack) {
+  return isFirstInContext(printStack, 1 | 4);
+}
+function UnaryLike(node, parent) {
+  return hasPostfixPart(node, parent) || isBinaryExpression(parent) && parent.operator === "**" && parent.left === node || isClassExtendsClause(node, parent);
+}
+function FunctionExpression(node, parent, printStack) {
+  return isFirstInContext(printStack, 1 | 4);
+}
+function ArrowFunctionExpression(node, parent) {
+  return isExportDeclaration(parent) || ConditionalExpression(node, parent);
+}
+function ConditionalExpression(node, parent) {
+  const parentType = parent.type;
+  if (parentType === "UnaryExpression" || parentType === "SpreadElement" || parentType === "BinaryExpression" || parentType === "LogicalExpression" || parentType === "ConditionalExpression" && parent.test === node || parentType === "AwaitExpression" || isTSTypeExpression(parentType)) {
+    return true;
+  }
+  return UnaryLike(node, parent);
+}
+function OptionalMemberExpression(node, parent) {
+  return isCallExpression(parent) && parent.callee === node || isMemberExpression(parent) && parent.object === node;
+}
+function AssignmentExpression(node, parent) {
+  if (isObjectPattern(node.left)) {
+    return true;
+  } else {
+    return ConditionalExpression(node, parent);
+  }
+}
+function LogicalExpression(node, parent) {
+  const parentType = parent.type;
+  if (isTSTypeExpression(parentType)) return true;
+  if (parentType !== "LogicalExpression") return false;
+  switch (node.operator) {
+    case "||":
+      return parent.operator === "??" || parent.operator === "&&";
+    case "&&":
+      return parent.operator === "??";
+    case "??":
+      return parent.operator !== "??";
+  }
+}
+function Identifier(node, parent, printStack) {
+  var _node$extra;
+  const parentType = parent.type;
+  if ((_node$extra = node.extra) != null && _node$extra.parenthesized && parentType === "AssignmentExpression" && parent.left === node) {
+    const rightType = parent.right.type;
+    if ((rightType === "FunctionExpression" || rightType === "ClassExpression") && parent.right.id == null) {
+      return true;
+    }
+  }
+  if (node.name === "let") {
+    const isFollowedByBracket = isMemberExpression(parent, {
+      object: node,
+      computed: true
+    }) || isOptionalMemberExpression(parent, {
+      object: node,
+      computed: true,
+      optional: false
+    });
+    return isFirstInContext(printStack, isFollowedByBracket ? 1 | 8 | 16 | 32 : 32);
+  }
+  return node.name === "async" && isForOfStatement(parent) && node === parent.left;
+}
+function isFirstInContext(printStack, checkParam) {
+  const expressionStatement = checkParam & 1;
+  const arrowBody = checkParam & 2;
+  const exportDefault = checkParam & 4;
+  const forHead = checkParam & 8;
+  const forInHead = checkParam & 16;
+  const forOfHead = checkParam & 32;
+  let i = printStack.length - 1;
+  if (i <= 0) return;
+  let node = printStack[i];
+  i--;
+  let parent = printStack[i];
+  while (i >= 0) {
+    const parentType = parent.type;
+    if (expressionStatement && parentType === "ExpressionStatement" && parent.expression === node || exportDefault && parentType === "ExportDefaultDeclaration" && node === parent.declaration || arrowBody && parentType === "ArrowFunctionExpression" && parent.body === node || forHead && parentType === "ForStatement" && parent.init === node || forInHead && parentType === "ForInStatement" && parent.left === node || forOfHead && parentType === "ForOfStatement" && parent.left === node) {
+      return true;
+    }
+    if (i > 0 && (hasPostfixPart(node, parent) && parentType !== "NewExpression" || parentType === "SequenceExpression" && parent.expressions[0] === node || parentType === "UpdateExpression" && !parent.prefix || parentType === "ConditionalExpression" && parent.test === node || (parentType === "BinaryExpression" || parentType === "LogicalExpression") && parent.left === node || parentType === "AssignmentExpression" && parent.left === node)) {
+      node = parent;
+      i--;
+      parent = printStack[i];
+    } else {
+      return false;
+    }
+  }
+  return false;
+}
+
+//# sourceMappingURL=parentheses.js.map

my-app/node_modules/@babel/generator/lib/node/whitespace.js

@@ -0,0 +1,145 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.nodes = void 0;
+var _t = require("@babel/types");
+const {
+  FLIPPED_ALIAS_KEYS,
+  isArrayExpression,
+  isAssignmentExpression,
+  isBinary,
+  isBlockStatement,
+  isCallExpression,
+  isFunction,
+  isIdentifier,
+  isLiteral,
+  isMemberExpression,
+  isObjectExpression,
+  isOptionalCallExpression,
+  isOptionalMemberExpression,
+  isStringLiteral
+} = _t;
+function crawlInternal(node, state) {
+  if (!node) return state;
+  if (isMemberExpression(node) || isOptionalMemberExpression(node)) {
+    crawlInternal(node.object, state);
+    if (node.computed) crawlInternal(node.property, state);
+  } else if (isBinary(node) || isAssignmentExpression(node)) {
+    crawlInternal(node.left, state);
+    crawlInternal(node.right, state);
+  } else if (isCallExpression(node) || isOptionalCallExpression(node)) {
+    state.hasCall = true;
+    crawlInternal(node.callee, state);
+  } else if (isFunction(node)) {
+    state.hasFunction = true;
+  } else if (isIdentifier(node)) {
+    state.hasHelper = state.hasHelper || node.callee && isHelper(node.callee);
+  }
+  return state;
+}
+function crawl(node) {
+  return crawlInternal(node, {
+    hasCall: false,
+    hasFunction: false,
+    hasHelper: false
+  });
+}
+function isHelper(node) {
+  if (!node) return false;
+  if (isMemberExpression(node)) {
+    return isHelper(node.object) || isHelper(node.property);
+  } else if (isIdentifier(node)) {
+    return node.name === "require" || node.name.charCodeAt(0) === 95;
+  } else if (isCallExpression(node)) {
+    return isHelper(node.callee);
+  } else if (isBinary(node) || isAssignmentExpression(node)) {
+    return isIdentifier(node.left) && isHelper(node.left) || isHelper(node.right);
+  } else {
+    return false;
+  }
+}
+function isType(node) {
+  return isLiteral(node) || isObjectExpression(node) || isArrayExpression(node) || isIdentifier(node) || isMemberExpression(node);
+}
+const nodes = exports.nodes = {
+  AssignmentExpression(node) {
+    const state = crawl(node.right);
+    if (state.hasCall && state.hasHelper || state.hasFunction) {
+      return state.hasFunction ? 1 | 2 : 2;
+    }
+  },
+  SwitchCase(node, parent) {
+    return (!!node.consequent.length || parent.cases[0] === node ? 1 : 0) | (!node.consequent.length && parent.cases[parent.cases.length - 1] === node ? 2 : 0);
+  },
+  LogicalExpression(node) {
+    if (isFunction(node.left) || isFunction(node.right)) {
+      return 2;
+    }
+  },
+  Literal(node) {
+    if (isStringLiteral(node) && node.value === "use strict") {
+      return 2;
+    }
+  },
+  CallExpression(node) {
+    if (isFunction(node.callee) || isHelper(node)) {
+      return 1 | 2;
+    }
+  },
+  OptionalCallExpression(node) {
+    if (isFunction(node.callee)) {
+      return 1 | 2;
+    }
+  },
+  VariableDeclaration(node) {
+    for (let i = 0; i < node.declarations.length; i++) {
+      const declar = node.declarations[i];
+      let enabled = isHelper(declar.id) && !isType(declar.init);
+      if (!enabled && declar.init) {
+        const state = crawl(declar.init);
+        enabled = isHelper(declar.init) && state.hasCall || state.hasFunction;
+      }
+      if (enabled) {
+        return 1 | 2;
+      }
+    }
+  },
+  IfStatement(node) {
+    if (isBlockStatement(node.consequent)) {
+      return 1 | 2;
+    }
+  }
+};
+nodes.ObjectProperty = nodes.ObjectTypeProperty = nodes.ObjectMethod = function (node, parent) {
+  if (parent.properties[0] === node) {
+    return 1;
+  }
+};
+nodes.ObjectTypeCallProperty = function (node, parent) {
+  var _parent$properties;
+  if (parent.callProperties[0] === node && !((_parent$properties = parent.properties) != null && _parent$properties.length)) {
+    return 1;
+  }
+};
+nodes.ObjectTypeIndexer = function (node, parent) {
+  var _parent$properties2, _parent$callPropertie;
+  if (parent.indexers[0] === node && !((_parent$properties2 = parent.properties) != null && _parent$properties2.length) && !((_parent$callPropertie = parent.callProperties) != null && _parent$callPropertie.length)) {
+    return 1;
+  }
+};
+nodes.ObjectTypeInternalSlot = function (node, parent) {
+  var _parent$properties3, _parent$callPropertie2, _parent$indexers;
+  if (parent.internalSlots[0] === node && !((_parent$properties3 = parent.properties) != null && _parent$properties3.length) && !((_parent$callPropertie2 = parent.callProperties) != null && _parent$callPropertie2.length) && !((_parent$indexers = parent.indexers) != null && _parent$indexers.length)) {
+    return 1;
+  }
+};
+[["Function", true], ["Class", true], ["Loop", true], ["LabeledStatement", true], ["SwitchStatement", true], ["TryStatement", true]].forEach(function ([type, amounts]) {
+  [type].concat(FLIPPED_ALIAS_KEYS[type] || []).forEach(function (type) {
+    const ret = amounts ? 1 | 2 : 0;
+    nodes[type] = () => ret;
+  });
+});
+
+//# sourceMappingURL=whitespace.js.map