@depup/sentry__server-utils 10.71.0-depup.0 → 10.72.0-depup.1

package/build/cjs/vendored/astring/dist/astring.js

@@ -0,0 +1,1068 @@
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const astring = require('../../../_virtual/astring.js');
+
+Object.defineProperty(astring.__exports, "__esModule", {
+  value: true
+});
+astring.__exports.generate = generate;
+astring.__exports.baseGenerator = astring.__exports.GENERATOR = astring.__exports.EXPRESSIONS_PRECEDENCE = astring.__exports.NEEDS_PARENTHESES = void 0;
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  return Constructor;
+}
+var stringify = JSON.stringify;
+if (!String.prototype.repeat) {
+  throw new Error("String.prototype.repeat is undefined, see https://github.com/davidbonnet/astring#installation");
+}
+if (!String.prototype.endsWith) {
+  throw new Error("String.prototype.endsWith is undefined, see https://github.com/davidbonnet/astring#installation");
+}
+var OPERATOR_PRECEDENCE = {
+  "||": 2,
+  "??": 3,
+  "&&": 4,
+  "|": 5,
+  "^": 6,
+  "&": 7,
+  "==": 8,
+  "!=": 8,
+  "===": 8,
+  "!==": 8,
+  "<": 9,
+  ">": 9,
+  "<=": 9,
+  ">=": 9,
+  "in": 9,
+  "instanceof": 9,
+  "<<": 10,
+  ">>": 10,
+  ">>>": 10,
+  "+": 11,
+  "-": 11,
+  "*": 12,
+  "%": 12,
+  "/": 12,
+  "**": 13
+};
+var NEEDS_PARENTHESES = 17;
+astring.__exports.NEEDS_PARENTHESES = NEEDS_PARENTHESES;
+var EXPRESSIONS_PRECEDENCE = {
+  ArrayExpression: 20,
+  TaggedTemplateExpression: 20,
+  ThisExpression: 20,
+  Identifier: 20,
+  PrivateIdentifier: 20,
+  Literal: 18,
+  TemplateLiteral: 20,
+  Super: 20,
+  SequenceExpression: 20,
+  MemberExpression: 19,
+  ChainExpression: 19,
+  CallExpression: 19,
+  NewExpression: 19,
+  ArrowFunctionExpression: NEEDS_PARENTHESES,
+  ClassExpression: NEEDS_PARENTHESES,
+  FunctionExpression: NEEDS_PARENTHESES,
+  ObjectExpression: NEEDS_PARENTHESES,
+  UpdateExpression: 16,
+  UnaryExpression: 15,
+  AwaitExpression: 15,
+  BinaryExpression: 14,
+  LogicalExpression: 13,
+  ConditionalExpression: 4,
+  AssignmentExpression: 3,
+  YieldExpression: 2,
+  RestElement: 1
+};
+astring.__exports.EXPRESSIONS_PRECEDENCE = EXPRESSIONS_PRECEDENCE;
+function formatSequence(state, nodes) {
+  var generator = state.generator;
+  state.write("(");
+  if (nodes != null && nodes.length > 0) {
+    generator[nodes[0].type](nodes[0], state);
+    var length = nodes.length;
+    for (var i = 1; i < length; i++) {
+      var param = nodes[i];
+      state.write(", ");
+      generator[param.type](param, state);
+    }
+  }
+  state.write(")");
+}
+function expressionNeedsParenthesis(state, node, parentNode, isRightHand) {
+  var nodePrecedence = state.expressionsPrecedence[node.type];
+  if (nodePrecedence === NEEDS_PARENTHESES) {
+    return true;
+  }
+  var parentNodePrecedence = state.expressionsPrecedence[parentNode.type];
+  if (nodePrecedence !== parentNodePrecedence) {
+    return !isRightHand && nodePrecedence === 15 && parentNodePrecedence === 14 && parentNode.operator === "**" || nodePrecedence < parentNodePrecedence;
+  }
+  if (nodePrecedence !== 13 && nodePrecedence !== 14) {
+    return false;
+  }
+  if (node.operator === "**" && parentNode.operator === "**") {
+    return !isRightHand;
+  }
+  if (nodePrecedence === 13 && parentNodePrecedence === 13 && (node.operator === "??" || parentNode.operator === "??")) {
+    return true;
+  }
+  if (isRightHand) {
+    return OPERATOR_PRECEDENCE[node.operator] <= OPERATOR_PRECEDENCE[parentNode.operator];
+  }
+  return OPERATOR_PRECEDENCE[node.operator] < OPERATOR_PRECEDENCE[parentNode.operator];
+}
+function formatExpression(state, node, parentNode, isRightHand) {
+  var generator = state.generator;
+  if (expressionNeedsParenthesis(state, node, parentNode, isRightHand)) {
+    state.write("(");
+    generator[node.type](node, state);
+    state.write(")");
+  } else {
+    generator[node.type](node, state);
+  }
+}
+function reindent(state, text, indent, lineEnd) {
+  var lines = text.split("\n");
+  var end = lines.length - 1;
+  state.write(lines[0].trim());
+  if (end > 0) {
+    state.write(lineEnd);
+    for (var i = 1; i < end; i++) {
+      state.write(indent + lines[i].trim() + lineEnd);
+    }
+    state.write(indent + lines[end].trim());
+  }
+}
+function formatComments(state, comments, indent, lineEnd) {
+  var length = comments.length;
+  for (var i = 0; i < length; i++) {
+    var comment = comments[i];
+    state.write(indent);
+    if (comment.type[0] === "L") {
+      state.write("// " + comment.value.trim() + "\n", comment);
+    } else {
+      state.write("/*");
+      reindent(state, comment.value, indent, lineEnd);
+      state.write("*/" + lineEnd);
+    }
+  }
+}
+function hasCallExpression(node) {
+  var currentNode = node;
+  while (currentNode != null) {
+    var _currentNode = currentNode, type = _currentNode.type;
+    if (type[0] === "C" && type[1] === "a") {
+      return true;
+    } else if (type[0] === "M" && type[1] === "e" && type[2] === "m") {
+      currentNode = currentNode.object;
+    } else {
+      return false;
+    }
+  }
+}
+function formatVariableDeclaration(state, node) {
+  var generator = state.generator;
+  var declarations = node.declarations;
+  state.write(node.kind + " ");
+  var length = declarations.length;
+  if (length > 0) {
+    generator.VariableDeclarator(declarations[0], state);
+    for (var i = 1; i < length; i++) {
+      state.write(", ");
+      generator.VariableDeclarator(declarations[i], state);
+    }
+  }
+}
+var ForInStatement, FunctionDeclaration, RestElement, BinaryExpression, ArrayExpression, BlockStatement;
+var GENERATOR = {
+  Program: function Program(node, state) {
+    var indent = state.indent.repeat(state.indentLevel);
+    var lineEnd = state.lineEnd, writeComments = state.writeComments;
+    if (writeComments && node.comments != null) {
+      formatComments(state, node.comments, indent, lineEnd);
+    }
+    var statements = node.body;
+    var length = statements.length;
+    for (var i = 0; i < length; i++) {
+      var statement = statements[i];
+      if (writeComments && statement.comments != null) {
+        formatComments(state, statement.comments, indent, lineEnd);
+      }
+      state.write(indent);
+      this[statement.type](statement, state);
+      state.write(lineEnd);
+    }
+    if (writeComments && node.trailingComments != null) {
+      formatComments(state, node.trailingComments, indent, lineEnd);
+    }
+  },
+  BlockStatement: BlockStatement = function BlockStatement2(node, state) {
+    var indent = state.indent.repeat(state.indentLevel++);
+    var lineEnd = state.lineEnd, writeComments = state.writeComments;
+    var statementIndent = indent + state.indent;
+    state.write("{");
+    var statements = node.body;
+    if (statements != null && statements.length > 0) {
+      state.write(lineEnd);
+      if (writeComments && node.comments != null) {
+        formatComments(state, node.comments, statementIndent, lineEnd);
+      }
+      var length = statements.length;
+      for (var i = 0; i < length; i++) {
+        var statement = statements[i];
+        if (writeComments && statement.comments != null) {
+          formatComments(state, statement.comments, statementIndent, lineEnd);
+        }
+        state.write(statementIndent);
+        this[statement.type](statement, state);
+        state.write(lineEnd);
+      }
+      state.write(indent);
+    } else {
+      if (writeComments && node.comments != null) {
+        state.write(lineEnd);
+        formatComments(state, node.comments, statementIndent, lineEnd);
+        state.write(indent);
+      }
+    }
+    if (writeComments && node.trailingComments != null) {
+      formatComments(state, node.trailingComments, statementIndent, lineEnd);
+    }
+    state.write("}");
+    state.indentLevel--;
+  },
+  ClassBody: BlockStatement,
+  StaticBlock: function StaticBlock(node, state) {
+    state.write("static ");
+    this.BlockStatement(node, state);
+  },
+  EmptyStatement: function EmptyStatement(node, state) {
+    state.write(";");
+  },
+  ExpressionStatement: function ExpressionStatement(node, state) {
+    var precedence = state.expressionsPrecedence[node.expression.type];
+    if (precedence === NEEDS_PARENTHESES || precedence === 3 && node.expression.left.type[0] === "O") {
+      state.write("(");
+      this[node.expression.type](node.expression, state);
+      state.write(")");
+    } else {
+      this[node.expression.type](node.expression, state);
+    }
+    state.write(";");
+  },
+  IfStatement: function IfStatement(node, state) {
+    state.write("if (");
+    this[node.test.type](node.test, state);
+    state.write(") ");
+    this[node.consequent.type](node.consequent, state);
+    if (node.alternate != null) {
+      state.write(" else ");
+      this[node.alternate.type](node.alternate, state);
+    }
+  },
+  LabeledStatement: function LabeledStatement(node, state) {
+    this[node.label.type](node.label, state);
+    state.write(": ");
+    this[node.body.type](node.body, state);
+  },
+  BreakStatement: function BreakStatement(node, state) {
+    state.write("break");
+    if (node.label != null) {
+      state.write(" ");
+      this[node.label.type](node.label, state);
+    }
+    state.write(";");
+  },
+  ContinueStatement: function ContinueStatement(node, state) {
+    state.write("continue");
+    if (node.label != null) {
+      state.write(" ");
+      this[node.label.type](node.label, state);
+    }
+    state.write(";");
+  },
+  WithStatement: function WithStatement(node, state) {
+    state.write("with (");
+    this[node.object.type](node.object, state);
+    state.write(") ");
+    this[node.body.type](node.body, state);
+  },
+  SwitchStatement: function SwitchStatement(node, state) {
+    var indent = state.indent.repeat(state.indentLevel++);
+    var lineEnd = state.lineEnd, writeComments = state.writeComments;
+    state.indentLevel++;
+    var caseIndent = indent + state.indent;
+    var statementIndent = caseIndent + state.indent;
+    state.write("switch (");
+    this[node.discriminant.type](node.discriminant, state);
+    state.write(") {" + lineEnd);
+    var occurences = node.cases;
+    var occurencesCount = occurences.length;
+    for (var i = 0; i < occurencesCount; i++) {
+      var occurence = occurences[i];
+      if (writeComments && occurence.comments != null) {
+        formatComments(state, occurence.comments, caseIndent, lineEnd);
+      }
+      if (occurence.test) {
+        state.write(caseIndent + "case ");
+        this[occurence.test.type](occurence.test, state);
+        state.write(":" + lineEnd);
+      } else {
+        state.write(caseIndent + "default:" + lineEnd);
+      }
+      var consequent = occurence.consequent;
+      var consequentCount = consequent.length;
+      for (var _i = 0; _i < consequentCount; _i++) {
+        var statement = consequent[_i];
+        if (writeComments && statement.comments != null) {
+          formatComments(state, statement.comments, statementIndent, lineEnd);
+        }
+        state.write(statementIndent);
+        this[statement.type](statement, state);
+        state.write(lineEnd);
+      }
+    }
+    state.indentLevel -= 2;
+    state.write(indent + "}");
+  },
+  ReturnStatement: function ReturnStatement(node, state) {
+    state.write("return");
+    if (node.argument) {
+      state.write(" ");
+      this[node.argument.type](node.argument, state);
+    }
+    state.write(";");
+  },
+  ThrowStatement: function ThrowStatement(node, state) {
+    state.write("throw ");
+    this[node.argument.type](node.argument, state);
+    state.write(";");
+  },
+  TryStatement: function TryStatement(node, state) {
+    state.write("try ");
+    this[node.block.type](node.block, state);
+    if (node.handler) {
+      var handler = node.handler;
+      if (handler.param == null) {
+        state.write(" catch ");
+      } else {
+        state.write(" catch (");
+        this[handler.param.type](handler.param, state);
+        state.write(") ");
+      }
+      this[handler.body.type](handler.body, state);
+    }
+    if (node.finalizer) {
+      state.write(" finally ");
+      this[node.finalizer.type](node.finalizer, state);
+    }
+  },
+  WhileStatement: function WhileStatement(node, state) {
+    state.write("while (");
+    this[node.test.type](node.test, state);
+    state.write(") ");
+    this[node.body.type](node.body, state);
+  },
+  DoWhileStatement: function DoWhileStatement(node, state) {
+    state.write("do ");
+    this[node.body.type](node.body, state);
+    state.write(" while (");
+    this[node.test.type](node.test, state);
+    state.write(");");
+  },
+  ForStatement: function ForStatement(node, state) {
+    state.write("for (");
+    if (node.init != null) {
+      var init = node.init;
+      if (init.type[0] === "V") {
+        formatVariableDeclaration(state, init);
+      } else {
+        this[init.type](init, state);
+      }
+    }
+    state.write("; ");
+    if (node.test) {
+      this[node.test.type](node.test, state);
+    }
+    state.write("; ");
+    if (node.update) {
+      this[node.update.type](node.update, state);
+    }
+    state.write(") ");
+    this[node.body.type](node.body, state);
+  },
+  ForInStatement: ForInStatement = function ForInStatement2(node, state) {
+    state.write("for ".concat(node["await"] ? "await " : "", "("));
+    var left = node.left;
+    if (left.type[0] === "V") {
+      formatVariableDeclaration(state, left);
+    } else {
+      this[left.type](left, state);
+    }
+    state.write(node.type[3] === "I" ? " in " : " of ");
+    this[node.right.type](node.right, state);
+    state.write(") ");
+    this[node.body.type](node.body, state);
+  },
+  ForOfStatement: ForInStatement,
+  DebuggerStatement: function DebuggerStatement(node, state) {
+    state.write("debugger;", node);
+  },
+  FunctionDeclaration: FunctionDeclaration = function FunctionDeclaration2(node, state) {
+    state.write((node.async ? "async " : "") + (node.generator ? "function* " : "function ") + (node.id ? node.id.name : ""), node);
+    formatSequence(state, node.params);
+    state.write(" ");
+    this[node.body.type](node.body, state);
+  },
+  FunctionExpression: FunctionDeclaration,
+  VariableDeclaration: function VariableDeclaration(node, state) {
+    formatVariableDeclaration(state, node);
+    state.write(";");
+  },
+  VariableDeclarator: function VariableDeclarator(node, state) {
+    this[node.id.type](node.id, state);
+    if (node.init != null) {
+      state.write(" = ");
+      this[node.init.type](node.init, state);
+    }
+  },
+  ClassDeclaration: function ClassDeclaration(node, state) {
+    state.write("class " + (node.id ? "".concat(node.id.name, " ") : ""), node);
+    if (node.superClass) {
+      state.write("extends ");
+      var superClass = node.superClass;
+      var type = superClass.type;
+      var precedence = state.expressionsPrecedence[type];
+      if ((type[0] !== "C" || type[1] !== "l" || type[5] !== "E") && (precedence === NEEDS_PARENTHESES || precedence < state.expressionsPrecedence.ClassExpression)) {
+        state.write("(");
+        this[node.superClass.type](superClass, state);
+        state.write(")");
+      } else {
+        this[superClass.type](superClass, state);
+      }
+      state.write(" ");
+    }
+    this.ClassBody(node.body, state);
+  },
+  ImportDeclaration: function ImportDeclaration(node, state) {
+    state.write("import ");
+    var specifiers = node.specifiers, attributes = node.attributes;
+    var length = specifiers.length;
+    var i = 0;
+    if (length > 0) {
+      for (; i < length; ) {
+        if (i > 0) {
+          state.write(", ");
+        }
+        var specifier = specifiers[i];
+        var type = specifier.type[6];
+        if (type === "D") {
+          state.write(specifier.local.name, specifier);
+          i++;
+        } else if (type === "N") {
+          state.write("* as " + specifier.local.name, specifier);
+          i++;
+        } else {
+          break;
+        }
+      }
+      if (i < length) {
+        state.write("{");
+        for (; ; ) {
+          var _specifier = specifiers[i];
+          var name = _specifier.imported.name;
+          state.write(name, _specifier);
+          if (name !== _specifier.local.name) {
+            state.write(" as " + _specifier.local.name);
+          }
+          if (++i < length) {
+            state.write(", ");
+          } else {
+            break;
+          }
+        }
+        state.write("}");
+      }
+      state.write(" from ");
+    }
+    this.Literal(node.source, state);
+    if (attributes && attributes.length > 0) {
+      state.write(" with { ");
+      for (var _i2 = 0; _i2 < attributes.length; _i2++) {
+        this.ImportAttribute(attributes[_i2], state);
+        if (_i2 < attributes.length - 1) state.write(", ");
+      }
+      state.write(" }");
+    }
+    state.write(";");
+  },
+  ImportAttribute: function ImportAttribute(node, state) {
+    this.Identifier(node.key, state);
+    state.write(": ");
+    this.Literal(node.value, state);
+  },
+  ImportExpression: function ImportExpression(node, state) {
+    state.write("import(");
+    this[node.source.type](node.source, state);
+    state.write(")");
+  },
+  ExportDefaultDeclaration: function ExportDefaultDeclaration(node, state) {
+    state.write("export default ");
+    this[node.declaration.type](node.declaration, state);
+    if (state.expressionsPrecedence[node.declaration.type] != null && node.declaration.type[0] !== "F") {
+      state.write(";");
+    }
+  },
+  ExportNamedDeclaration: function ExportNamedDeclaration(node, state) {
+    state.write("export ");
+    if (node.declaration) {
+      this[node.declaration.type](node.declaration, state);
+    } else {
+      state.write("{");
+      var specifiers = node.specifiers, length = specifiers.length;
+      if (length > 0) {
+        for (var i = 0; ; ) {
+          var specifier = specifiers[i];
+          var name = specifier.local.name;
+          state.write(name, specifier);
+          if (name !== specifier.exported.name) {
+            state.write(" as " + specifier.exported.name);
+          }
+          if (++i < length) {
+            state.write(", ");
+          } else {
+            break;
+          }
+        }
+      }
+      state.write("}");
+      if (node.source) {
+        state.write(" from ");
+        this.Literal(node.source, state);
+      }
+      if (node.attributes && node.attributes.length > 0) {
+        state.write(" with { ");
+        for (var _i3 = 0; _i3 < node.attributes.length; _i3++) {
+          this.ImportAttribute(node.attributes[_i3], state);
+          if (_i3 < node.attributes.length - 1) state.write(", ");
+        }
+        state.write(" }");
+      }
+      state.write(";");
+    }
+  },
+  ExportAllDeclaration: function ExportAllDeclaration(node, state) {
+    if (node.exported != null) {
+      state.write("export * as " + node.exported.name + " from ");
+    } else {
+      state.write("export * from ");
+    }
+    this.Literal(node.source, state);
+    if (node.attributes && node.attributes.length > 0) {
+      state.write(" with { ");
+      for (var i = 0; i < node.attributes.length; i++) {
+        this.ImportAttribute(node.attributes[i], state);
+        if (i < node.attributes.length - 1) state.write(", ");
+      }
+      state.write(" }");
+    }
+    state.write(";");
+  },
+  MethodDefinition: function MethodDefinition(node, state) {
+    if (node["static"]) {
+      state.write("static ");
+    }
+    var kind = node.kind[0];
+    if (kind === "g" || kind === "s") {
+      state.write(node.kind + " ");
+    }
+    if (node.value.async) {
+      state.write("async ");
+    }
+    if (node.value.generator) {
+      state.write("*");
+    }
+    if (node.computed) {
+      state.write("[");
+      this[node.key.type](node.key, state);
+      state.write("]");
+    } else {
+      this[node.key.type](node.key, state);
+    }
+    formatSequence(state, node.value.params);
+    state.write(" ");
+    this[node.value.body.type](node.value.body, state);
+  },
+  ClassExpression: function ClassExpression(node, state) {
+    this.ClassDeclaration(node, state);
+  },
+  ArrowFunctionExpression: function ArrowFunctionExpression(node, state) {
+    state.write(node.async ? "async " : "", node);
+    var params = node.params;
+    if (params != null) {
+      if (params.length === 1 && params[0].type[0] === "I") {
+        state.write(params[0].name, params[0]);
+      } else {
+        formatSequence(state, node.params);
+      }
+    }
+    state.write(" => ");
+    if (node.body.type[0] === "O") {
+      state.write("(");
+      this.ObjectExpression(node.body, state);
+      state.write(")");
+    } else {
+      this[node.body.type](node.body, state);
+    }
+  },
+  ThisExpression: function ThisExpression(node, state) {
+    state.write("this", node);
+  },
+  Super: function Super(node, state) {
+    state.write("super", node);
+  },
+  RestElement: RestElement = function RestElement2(node, state) {
+    state.write("...");
+    this[node.argument.type](node.argument, state);
+  },
+  SpreadElement: RestElement,
+  YieldExpression: function YieldExpression(node, state) {
+    state.write(node.delegate ? "yield*" : "yield");
+    if (node.argument) {
+      state.write(" ");
+      this[node.argument.type](node.argument, state);
+    }
+  },
+  AwaitExpression: function AwaitExpression(node, state) {
+    state.write("await ", node);
+    formatExpression(state, node.argument, node);
+  },
+  TemplateLiteral: function TemplateLiteral(node, state) {
+    var quasis = node.quasis, expressions = node.expressions;
+    state.write("`");
+    var length = expressions.length;
+    for (var i = 0; i < length; i++) {
+      var expression = expressions[i];
+      var _quasi = quasis[i];
+      state.write(_quasi.value.raw, _quasi);
+      state.write("${");
+      this[expression.type](expression, state);
+      state.write("}");
+    }
+    var quasi = quasis[quasis.length - 1];
+    state.write(quasi.value.raw, quasi);
+    state.write("`");
+  },
+  TemplateElement: function TemplateElement(node, state) {
+    state.write(node.value.raw, node);
+  },
+  TaggedTemplateExpression: function TaggedTemplateExpression(node, state) {
+    formatExpression(state, node.tag, node);
+    this[node.quasi.type](node.quasi, state);
+  },
+  ArrayExpression: ArrayExpression = function ArrayExpression2(node, state) {
+    state.write("[");
+    if (node.elements.length > 0) {
+      var elements = node.elements, length = elements.length;
+      for (var i = 0; ; ) {
+        var element = elements[i];
+        if (element != null) {
+          this[element.type](element, state);
+        }
+        if (++i < length) {
+          state.write(", ");
+        } else {
+          if (element == null) {
+            state.write(", ");
+          }
+          break;
+        }
+      }
+    }
+    state.write("]");
+  },
+  ArrayPattern: ArrayExpression,
+  ObjectExpression: function ObjectExpression(node, state) {
+    var indent = state.indent.repeat(state.indentLevel++);
+    var lineEnd = state.lineEnd, writeComments = state.writeComments;
+    var propertyIndent = indent + state.indent;
+    state.write("{");
+    if (node.properties.length > 0) {
+      state.write(lineEnd);
+      if (writeComments && node.comments != null) {
+        formatComments(state, node.comments, propertyIndent, lineEnd);
+      }
+      var comma = "," + lineEnd;
+      var properties = node.properties, length = properties.length;
+      for (var i = 0; ; ) {
+        var property = properties[i];
+        if (writeComments && property.comments != null) {
+          formatComments(state, property.comments, propertyIndent, lineEnd);
+        }
+        state.write(propertyIndent);
+        this[property.type](property, state);
+        if (++i < length) {
+          state.write(comma);
+        } else {
+          break;
+        }
+      }
+      state.write(lineEnd);
+      if (writeComments && node.trailingComments != null) {
+        formatComments(state, node.trailingComments, propertyIndent, lineEnd);
+      }
+      state.write(indent + "}");
+    } else if (writeComments) {
+      if (node.comments != null) {
+        state.write(lineEnd);
+        formatComments(state, node.comments, propertyIndent, lineEnd);
+        if (node.trailingComments != null) {
+          formatComments(state, node.trailingComments, propertyIndent, lineEnd);
+        }
+        state.write(indent + "}");
+      } else if (node.trailingComments != null) {
+        state.write(lineEnd);
+        formatComments(state, node.trailingComments, propertyIndent, lineEnd);
+        state.write(indent + "}");
+      } else {
+        state.write("}");
+      }
+    } else {
+      state.write("}");
+    }
+    state.indentLevel--;
+  },
+  Property: function Property(node, state) {
+    if (node.method || node.kind[0] !== "i") {
+      this.MethodDefinition(node, state);
+    } else {
+      if (!node.shorthand) {
+        if (node.computed) {
+          state.write("[");
+          this[node.key.type](node.key, state);
+          state.write("]");
+        } else {
+          this[node.key.type](node.key, state);
+        }
+        state.write(": ");
+      }
+      this[node.value.type](node.value, state);
+    }
+  },
+  PropertyDefinition: function PropertyDefinition(node, state) {
+    if (node["static"]) {
+      state.write("static ");
+    }
+    if (node.computed) {
+      state.write("[");
+    }
+    this[node.key.type](node.key, state);
+    if (node.computed) {
+      state.write("]");
+    }
+    if (node.value == null) {
+      if (node.key.type[0] !== "F") {
+        state.write(";");
+      }
+      return;
+    }
+    state.write(" = ");
+    this[node.value.type](node.value, state);
+    state.write(";");
+  },
+  ObjectPattern: function ObjectPattern(node, state) {
+    state.write("{");
+    if (node.properties.length > 0) {
+      var properties = node.properties, length = properties.length;
+      for (var i = 0; ; ) {
+        this[properties[i].type](properties[i], state);
+        if (++i < length) {
+          state.write(", ");
+        } else {
+          break;
+        }
+      }
+    }
+    state.write("}");
+  },
+  SequenceExpression: function SequenceExpression(node, state) {
+    formatSequence(state, node.expressions);
+  },
+  UnaryExpression: function UnaryExpression(node, state) {
+    if (node.prefix) {
+      var operator = node.operator, argument = node.argument, type = node.argument.type;
+      state.write(operator);
+      var needsParentheses = expressionNeedsParenthesis(state, argument, node);
+      if (!needsParentheses && (operator.length > 1 || type[0] === "U" && (type[1] === "n" || type[1] === "p") && argument.prefix && argument.operator[0] === operator && (operator === "+" || operator === "-"))) {
+        state.write(" ");
+      }
+      if (needsParentheses) {
+        state.write(operator.length > 1 ? " (" : "(");
+        this[type](argument, state);
+        state.write(")");
+      } else {
+        this[type](argument, state);
+      }
+    } else {
+      this[node.argument.type](node.argument, state);
+      state.write(node.operator);
+    }
+  },
+  UpdateExpression: function UpdateExpression(node, state) {
+    if (node.prefix) {
+      state.write(node.operator);
+      this[node.argument.type](node.argument, state);
+    } else {
+      this[node.argument.type](node.argument, state);
+      state.write(node.operator);
+    }
+  },
+  AssignmentExpression: function AssignmentExpression(node, state) {
+    this[node.left.type](node.left, state);
+    state.write(" " + node.operator + " ");
+    this[node.right.type](node.right, state);
+  },
+  AssignmentPattern: function AssignmentPattern(node, state) {
+    this[node.left.type](node.left, state);
+    state.write(" = ");
+    this[node.right.type](node.right, state);
+  },
+  BinaryExpression: BinaryExpression = function BinaryExpression2(node, state) {
+    var isIn = node.operator === "in";
+    if (isIn) {
+      state.write("(");
+    }
+    formatExpression(state, node.left, node, false);
+    state.write(" " + node.operator + " ");
+    formatExpression(state, node.right, node, true);
+    if (isIn) {
+      state.write(")");
+    }
+  },
+  LogicalExpression: BinaryExpression,
+  ConditionalExpression: function ConditionalExpression(node, state) {
+    var test = node.test;
+    var precedence = state.expressionsPrecedence[test.type];
+    if (precedence === NEEDS_PARENTHESES || precedence <= state.expressionsPrecedence.ConditionalExpression) {
+      state.write("(");
+      this[test.type](test, state);
+      state.write(")");
+    } else {
+      this[test.type](test, state);
+    }
+    state.write(" ? ");
+    this[node.consequent.type](node.consequent, state);
+    state.write(" : ");
+    this[node.alternate.type](node.alternate, state);
+  },
+  NewExpression: function NewExpression(node, state) {
+    state.write("new ");
+    var precedence = state.expressionsPrecedence[node.callee.type];
+    if (precedence === NEEDS_PARENTHESES || precedence < state.expressionsPrecedence.CallExpression || hasCallExpression(node.callee)) {
+      state.write("(");
+      this[node.callee.type](node.callee, state);
+      state.write(")");
+    } else {
+      this[node.callee.type](node.callee, state);
+    }
+    formatSequence(state, node["arguments"]);
+  },
+  CallExpression: function CallExpression(node, state) {
+    var precedence = state.expressionsPrecedence[node.callee.type];
+    if (precedence === NEEDS_PARENTHESES || precedence < state.expressionsPrecedence.CallExpression) {
+      state.write("(");
+      this[node.callee.type](node.callee, state);
+      state.write(")");
+    } else {
+      this[node.callee.type](node.callee, state);
+    }
+    if (node.optional) {
+      state.write("?.");
+    }
+    formatSequence(state, node["arguments"]);
+  },
+  ChainExpression: function ChainExpression(node, state) {
+    this[node.expression.type](node.expression, state);
+  },
+  MemberExpression: function MemberExpression(node, state) {
+    var precedence = state.expressionsPrecedence[node.object.type];
+    if (precedence === NEEDS_PARENTHESES || precedence < state.expressionsPrecedence.MemberExpression) {
+      state.write("(");
+      this[node.object.type](node.object, state);
+      state.write(")");
+    } else {
+      this[node.object.type](node.object, state);
+    }
+    if (node.computed) {
+      if (node.optional) {
+        state.write("?.");
+      }
+      state.write("[");
+      this[node.property.type](node.property, state);
+      state.write("]");
+    } else {
+      if (node.optional) {
+        state.write("?.");
+      } else {
+        state.write(".");
+      }
+      this[node.property.type](node.property, state);
+    }
+  },
+  MetaProperty: function MetaProperty(node, state) {
+    state.write(node.meta.name + "." + node.property.name, node);
+  },
+  Identifier: function Identifier(node, state) {
+    state.write(node.name, node);
+  },
+  PrivateIdentifier: function PrivateIdentifier(node, state) {
+    state.write("#".concat(node.name), node);
+  },
+  Literal: function Literal(node, state) {
+    if (node.raw != null) {
+      state.write(node.raw, node);
+    } else if (node.regex != null) {
+      this.RegExpLiteral(node, state);
+    } else if (node.bigint != null) {
+      state.write(node.bigint + "n", node);
+    } else {
+      state.write(stringify(node.value), node);
+    }
+  },
+  RegExpLiteral: function RegExpLiteral(node, state) {
+    var regex = node.regex;
+    state.write("/".concat(regex.pattern, "/").concat(regex.flags), node);
+  }
+};
+astring.__exports.GENERATOR = GENERATOR;
+var EMPTY_OBJECT = {};
+var baseGenerator = GENERATOR;
+astring.__exports.baseGenerator = baseGenerator;
+var State = (function() {
+  function State2(options) {
+    _classCallCheck(this, State2);
+    var setup = options == null ? EMPTY_OBJECT : options;
+    this.output = "";
+    if (setup.output != null) {
+      this.output = setup.output;
+      this.write = this.writeToStream;
+    } else {
+      this.output = "";
+    }
+    this.generator = setup.generator != null ? setup.generator : GENERATOR;
+    this.expressionsPrecedence = setup.expressionsPrecedence != null ? setup.expressionsPrecedence : EXPRESSIONS_PRECEDENCE;
+    this.indent = setup.indent != null ? setup.indent : "  ";
+    this.lineEnd = setup.lineEnd != null ? setup.lineEnd : "\n";
+    this.indentLevel = setup.startingIndentLevel != null ? setup.startingIndentLevel : 0;
+    this.writeComments = setup.comments ? setup.comments : false;
+    if (setup.sourceMap != null) {
+      this.write = setup.output == null ? this.writeAndMap : this.writeToStreamAndMap;
+      this.sourceMap = setup.sourceMap;
+      this.line = 1;
+      this.column = 0;
+      this.lineEndSize = this.lineEnd.split("\n").length - 1;
+      this.mapping = {
+        original: null,
+        generated: this,
+        name: void 0,
+        source: setup.sourceMap.file || setup.sourceMap._file
+      };
+    }
+  }
+  _createClass(State2, [{
+    key: "write",
+    value: function write(code) {
+      this.output += code;
+    }
+  }, {
+    key: "writeToStream",
+    value: function writeToStream(code) {
+      this.output.write(code);
+    }
+  }, {
+    key: "writeAndMap",
+    value: function writeAndMap(code, node) {
+      this.output += code;
+      this.map(code, node);
+    }
+  }, {
+    key: "writeToStreamAndMap",
+    value: function writeToStreamAndMap(code, node) {
+      this.output.write(code);
+      this.map(code, node);
+    }
+  }, {
+    key: "map",
+    value: function map(code, node) {
+      if (node != null) {
+        var type = node.type;
+        if (type[0] === "L" && type[2] === "n") {
+          this.column = 0;
+          this.line++;
+          return;
+        }
+        if (node.loc != null) {
+          var mapping = this.mapping;
+          mapping.original = node.loc.start;
+          mapping.name = node.name;
+          this.sourceMap.addMapping(mapping);
+        }
+        if (type[0] === "T" && type[8] === "E" || type[0] === "L" && type[1] === "i" && typeof node.value === "string") {
+          var _length = code.length;
+          var column = this.column, line = this.line;
+          for (var i = 0; i < _length; i++) {
+            if (code[i] === "\n") {
+              column = 0;
+              line++;
+            } else {
+              column++;
+            }
+          }
+          this.column = column;
+          this.line = line;
+          return;
+        }
+      }
+      var length = code.length;
+      var lineEnd = this.lineEnd;
+      if (length > 0) {
+        if (this.lineEndSize > 0 && (lineEnd.length === 1 ? code[length - 1] === lineEnd : code.endsWith(lineEnd))) {
+          this.line += this.lineEndSize;
+          this.column = 0;
+        } else {
+          this.column += length;
+        }
+      }
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return this.output;
+    }
+  }]);
+  return State2;
+})();
+function generate(node, options) {
+  var state = new State(options);
+  state.generator[node.type](node, state);
+  return state.output;
+}
+
+exports.default = astring.__exports;
+//# sourceMappingURL=astring.js.map