first

node_modules/@babel/generator/lib/node/index.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.needsParens = needsParens;
+exports.needsWhitespace = needsWhitespace;
+exports.needsWhitespaceAfter = needsWhitespaceAfter;
+exports.needsWhitespaceBefore = needsWhitespaceBefore;
+var whitespace = require("./whitespace");
+var parens = require("./parentheses");
+var _t = require("@babel/types");
+const {
+  FLIPPED_ALIAS_KEYS,
+  isCallExpression,
+  isExpressionStatement,
+  isMemberExpression,
+  isNewExpression
+} = _t;
+function expandAliases(obj) {
+  const newObj = {};
+  function add(type, func) {
+    const fn = newObj[type];
+    newObj[type] = fn ? function (node, parent, stack) {
+      const result = fn(node, parent, stack);
+      return result == null ? func(node, parent, stack) : result;
+    } : 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 newObj;
+}
+const expandedParens = expandAliases(parens);
+const expandedWhitespaceNodes = expandAliases(whitespace.nodes);
+function find(obj, node, parent, printStack) {
+  const fn = obj[node.type];
+  return fn ? fn(node, parent, printStack) : null;
+}
+function isOrHasCallExpression(node) {
+  if (isCallExpression(node)) {
+    return true;
+  }
+  return isMemberExpression(node) && isOrHasCallExpression(node.object);
+}
+function needsWhitespace(node, parent, type) {
+  if (!node) return false;
+  if (isExpressionStatement(node)) {
+    node = node.expression;
+  }
+  const flag = find(expandedWhitespaceNodes, 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) {
+  if (!parent) return false;
+  if (isNewExpression(parent) && parent.callee === node) {
+    if (isOrHasCallExpression(node)) return true;
+  }
+  return find(expandedParens, node, parent, printStack);
+}
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/generator/lib/node/parentheses.js

@@ -0,0 +1,305 @@
+"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,
+  isAssignmentExpression,
+  isAwaitExpression,
+  isBinary,
+  isBinaryExpression,
+  isUpdateExpression,
+  isCallExpression,
+  isClass,
+  isClassExpression,
+  isConditional,
+  isConditionalExpression,
+  isExportDeclaration,
+  isExportDefaultDeclaration,
+  isExpressionStatement,
+  isFor,
+  isForInStatement,
+  isForOfStatement,
+  isForStatement,
+  isFunctionExpression,
+  isIfStatement,
+  isIndexedAccessType,
+  isIntersectionTypeAnnotation,
+  isLogicalExpression,
+  isMemberExpression,
+  isNewExpression,
+  isNullableTypeAnnotation,
+  isObjectPattern,
+  isOptionalCallExpression,
+  isOptionalMemberExpression,
+  isReturnStatement,
+  isSequenceExpression,
+  isSwitchStatement,
+  isTSArrayType,
+  isTSAsExpression,
+  isTSInstantiationExpression,
+  isTSIntersectionType,
+  isTSNonNullExpression,
+  isTSOptionalType,
+  isTSRestType,
+  isTSTypeAssertion,
+  isTSUnionType,
+  isTaggedTemplateExpression,
+  isThrowStatement,
+  isTypeAnnotation,
+  isUnaryLike,
+  isUnionTypeAnnotation,
+  isVariableDeclarator,
+  isWhileStatement,
+  isYieldExpression,
+  isTSSatisfiesExpression
+} = _t;
+const PRECEDENCE = {
+  "||": 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(node) {
+  return isTSAsExpression(node) || isTSSatisfiesExpression(node) || isTSTypeAssertion(node);
+}
+const isClassExtendsClause = (node, parent) => isClass(parent, {
+  superClass: node
+});
+const hasPostfixPart = (node, parent) => (isMemberExpression(parent) || isOptionalMemberExpression(parent)) && parent.object === node || (isCallExpression(parent) || isOptionalCallExpression(parent) || isNewExpression(parent)) && parent.callee === node || isTaggedTemplateExpression(parent) && parent.tag === node || isTSNonNullExpression(parent);
+function NullableTypeAnnotation(node, parent) {
+  return isArrayTypeAnnotation(parent);
+}
+function FunctionTypeAnnotation(node, parent, printStack) {
+  if (printStack.length < 3) return;
+  return isUnionTypeAnnotation(parent) || isIntersectionTypeAnnotation(parent) || isArrayTypeAnnotation(parent) || isTypeAnnotation(parent) && 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) {
+  if (node.operator === "**" && isBinaryExpression(parent, {
+    operator: "**"
+  })) {
+    return parent.left === node;
+  }
+  if (isClassExtendsClause(node, parent)) {
+    return true;
+  }
+  if (hasPostfixPart(node, parent) || isUnaryLike(parent) || isAwaitExpression(parent)) {
+    return true;
+  }
+  if (isBinary(parent)) {
+    const parentOp = parent.operator;
+    const parentPos = PRECEDENCE[parentOp];
+    const nodeOp = node.operator;
+    const nodePos = PRECEDENCE[nodeOp];
+    if (parentPos === nodePos && parent.right === node && !isLogicalExpression(parent) || parentPos > nodePos) {
+      return true;
+    }
+  }
+}
+function UnionTypeAnnotation(node, parent) {
+  return isArrayTypeAnnotation(parent) || isNullableTypeAnnotation(parent) || isIntersectionTypeAnnotation(parent) || isUnionTypeAnnotation(parent);
+}
+function OptionalIndexedAccessType(node, parent) {
+  return isIndexedAccessType(parent, {
+    objectType: node
+  });
+}
+function TSAsExpression() {
+  return true;
+}
+function TSUnionType(node, parent) {
+  return isTSArrayType(parent) || isTSOptionalType(parent) || isTSIntersectionType(parent) || isTSUnionType(parent) || isTSRestType(parent);
+}
+function TSInferType(node, parent) {
+  return isTSArrayType(parent) || isTSOptionalType(parent);
+}
+function TSInstantiationExpression(node, parent) {
+  return (isCallExpression(parent) || isOptionalCallExpression(parent) || isNewExpression(parent) || isTSInstantiationExpression(parent)) && !!parent.typeParameters;
+}
+function BinaryExpression(node, parent) {
+  return node.operator === "in" && (isVariableDeclarator(parent) || isFor(parent));
+}
+function SequenceExpression(node, parent) {
+  if (isForStatement(parent) || isThrowStatement(parent) || isReturnStatement(parent) || isIfStatement(parent) && parent.test === node || isWhileStatement(parent) && parent.test === node || isForInStatement(parent) && parent.right === node || isSwitchStatement(parent) && parent.discriminant === node || isExpressionStatement(parent) && parent.expression === node) {
+    return false;
+  }
+  return true;
+}
+function YieldExpression(node, parent) {
+  return isBinary(parent) || isUnaryLike(parent) || hasPostfixPart(node, parent) || isAwaitExpression(parent) && isYieldExpression(node) || isConditionalExpression(parent) && 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, {
+    operator: "**",
+    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) {
+  if (isUnaryLike(parent) || isBinary(parent) || isConditionalExpression(parent, {
+    test: node
+  }) || isAwaitExpression(parent) || isTSTypeExpression(parent)) {
+    return true;
+  }
+  return UnaryLike(node, parent);
+}
+function OptionalMemberExpression(node, parent) {
+  return isCallExpression(parent, {
+    callee: node
+  }) || isMemberExpression(parent, {
+    object: node
+  });
+}
+function AssignmentExpression(node, parent) {
+  if (isObjectPattern(node.left)) {
+    return true;
+  } else {
+    return ConditionalExpression(node, parent);
+  }
+}
+function LogicalExpression(node, parent) {
+  if (isTSTypeExpression(parent)) return true;
+  switch (node.operator) {
+    case "||":
+      if (!isLogicalExpression(parent)) return false;
+      return parent.operator === "??" || parent.operator === "&&";
+    case "&&":
+      return isLogicalExpression(parent, {
+        operator: "??"
+      });
+    case "??":
+      return isLogicalExpression(parent) && parent.operator !== "??";
+  }
+}
+function Identifier(node, parent, printStack) {
+  var _node$extra;
+  if ((_node$extra = node.extra) != null && _node$extra.parenthesized && isAssignmentExpression(parent, {
+    left: node
+  }) && (isFunctionExpression(parent.right) || isClassExpression(parent.right)) && 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) {
+    if (expressionStatement && isExpressionStatement(parent, {
+      expression: node
+    }) || exportDefault && isExportDefaultDeclaration(parent, {
+      declaration: node
+    }) || arrowBody && isArrowFunctionExpression(parent, {
+      body: node
+    }) || forHead && isForStatement(parent, {
+      init: node
+    }) || forInHead && isForInStatement(parent, {
+      left: node
+    }) || forOfHead && isForOfStatement(parent, {
+      left: node
+    })) {
+      return true;
+    }
+    if (i > 0 && (hasPostfixPart(node, parent) && !isNewExpression(parent) || isSequenceExpression(parent) && parent.expressions[0] === node || isUpdateExpression(parent) && !parent.prefix || isConditional(parent, {
+      test: node
+    }) || isBinary(parent, {
+      left: node
+    }) || isAssignmentExpression(parent, {
+      left: node
+    }))) {
+      node = parent;
+      i--;
+      parent = printStack[i];
+    } else {
+      return false;
+    }
+  }
+  return false;
+}
+
+//# sourceMappingURL=parentheses.js.map

node_modules/@babel/generator/lib/node/whitespace.js

@@ -0,0 +1,146 @@
+"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 = {
+  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;
+    }
+  }
+};
+exports.nodes = nodes;
+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