condenser 0.0.8 → 0.0.9

data/lib/condenser/processors/node_modules/@babel/parser/lib/parser/node.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NodeUtils = void 0;
+
+var _util = _interopRequireDefault(require("./util"));
+
+var _location = require("../util/location");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class Node {
+  constructor(parser, pos, loc) {
+    this.type = "";
+    this.start = pos;
+    this.end = 0;
+    this.loc = new _location.SourceLocation(loc);
+    if (parser && parser.options.ranges) this.range = [pos, 0];
+    if (parser && parser.filename) this.loc.filename = parser.filename;
+  }
+
+  __clone() {
+    const newNode = new Node();
+    const keys = Object.keys(this);
+
+    for (let i = 0, length = keys.length; i < length; i++) {
+      const key = keys[i];
+
+      if (key !== "leadingComments" && key !== "trailingComments" && key !== "innerComments") {
+        newNode[key] = this[key];
+      }
+    }
+
+    return newNode;
+  }
+
+}
+
+class NodeUtils extends _util.default {
+  startNode() {
+    return new Node(this, this.state.start, this.state.startLoc);
+  }
+
+  startNodeAt(pos, loc) {
+    return new Node(this, pos, loc);
+  }
+
+  startNodeAtNode(type) {
+    return this.startNodeAt(type.start, type.loc.start);
+  }
+
+  finishNode(node, type) {
+    return this.finishNodeAt(node, type, this.state.lastTokEnd, this.state.lastTokEndLoc);
+  }
+
+  finishNodeAt(node, type, pos, loc) {
+    if (process.env.NODE_ENV !== "production" && node.end > 0) {
+      throw new Error("Do not call finishNode*() twice on the same node." + " Instead use resetEndLocation() or change type directly.");
+    }
+
+    node.type = type;
+    node.end = pos;
+    node.loc.end = loc;
+    if (this.options.ranges) node.range[1] = pos;
+    this.processComment(node);
+    return node;
+  }
+
+  resetStartLocation(node, start, startLoc) {
+    node.start = start;
+    node.loc.start = startLoc;
+    if (this.options.ranges) node.range[0] = start;
+  }
+
+  resetEndLocation(node, end = this.state.lastTokEnd, endLoc = this.state.lastTokEndLoc) {
+    node.end = end;
+    node.loc.end = endLoc;
+    if (this.options.ranges) node.range[1] = end;
+  }
+
+  resetStartLocationFromNode(node, locationNode) {
+    this.resetStartLocation(node, locationNode.start, locationNode.loc.start);
+  }
+
+}
+
+exports.NodeUtils = NodeUtils;

data/lib/condenser/processors/node_modules/@babel/parser/lib/parser/statement.js

@@ -0,0 +1,1529 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var N = _interopRequireWildcard(require("../types"));
+
+var _types2 = require("../tokenizer/types");
+
+var _expression = _interopRequireDefault(require("./expression"));
+
+var _identifier = require("../util/identifier");
+
+var _whitespace = require("../util/whitespace");
+
+var _scopeflags = require("../util/scopeflags");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const loopLabel = {
+  kind: "loop"
+},
+      switchLabel = {
+  kind: "switch"
+};
+const FUNC_NO_FLAGS = 0b000,
+      FUNC_STATEMENT = 0b001,
+      FUNC_HANGING_STATEMENT = 0b010,
+      FUNC_NULLABLE_ID = 0b100;
+
+class StatementParser extends _expression.default {
+  parseTopLevel(file, program) {
+    program.sourceType = this.options.sourceType;
+    program.interpreter = this.parseInterpreterDirective();
+    this.parseBlockBody(program, true, true, _types2.types.eof);
+
+    if (this.inModule && !this.options.allowUndeclaredExports && this.scope.undefinedExports.size > 0) {
+      for (let _i = 0, _Array$from = Array.from(this.scope.undefinedExports); _i < _Array$from.length; _i++) {
+        const [name] = _Array$from[_i];
+        const pos = this.scope.undefinedExports.get(name);
+        this.raise(pos, `Export '${name}' is not defined`);
+      }
+    }
+
+    file.program = this.finishNode(program, "Program");
+    file.comments = this.state.comments;
+    if (this.options.tokens) file.tokens = this.state.tokens;
+    return this.finishNode(file, "File");
+  }
+
+  stmtToDirective(stmt) {
+    const expr = stmt.expression;
+    const directiveLiteral = this.startNodeAt(expr.start, expr.loc.start);
+    const directive = this.startNodeAt(stmt.start, stmt.loc.start);
+    const raw = this.input.slice(expr.start, expr.end);
+    const val = directiveLiteral.value = raw.slice(1, -1);
+    this.addExtra(directiveLiteral, "raw", raw);
+    this.addExtra(directiveLiteral, "rawValue", val);
+    directive.value = this.finishNodeAt(directiveLiteral, "DirectiveLiteral", expr.end, expr.loc.end);
+    return this.finishNodeAt(directive, "Directive", stmt.end, stmt.loc.end);
+  }
+
+  parseInterpreterDirective() {
+    if (!this.match(_types2.types.interpreterDirective)) {
+      return null;
+    }
+
+    const node = this.startNode();
+    node.value = this.state.value;
+    this.next();
+    return this.finishNode(node, "InterpreterDirective");
+  }
+
+  isLet(context) {
+    if (!this.isContextual("let")) {
+      return false;
+    }
+
+    const next = this.nextTokenStart();
+    const nextCh = this.input.charCodeAt(next);
+    if (nextCh === 91) return true;
+    if (context) return false;
+    if (nextCh === 123) return true;
+
+    if ((0, _identifier.isIdentifierStart)(nextCh)) {
+      let pos = next + 1;
+
+      while ((0, _identifier.isIdentifierChar)(this.input.charCodeAt(pos))) {
+        ++pos;
+      }
+
+      const ident = this.input.slice(next, pos);
+      if (!_identifier.keywordRelationalOperator.test(ident)) return true;
+    }
+
+    return false;
+  }
+
+  parseStatement(context, topLevel) {
+    if (this.match(_types2.types.at)) {
+      this.parseDecorators(true);
+    }
+
+    return this.parseStatementContent(context, topLevel);
+  }
+
+  parseStatementContent(context, topLevel) {
+    let starttype = this.state.type;
+    const node = this.startNode();
+    let kind;
+
+    if (this.isLet(context)) {
+      starttype = _types2.types._var;
+      kind = "let";
+    }
+
+    switch (starttype) {
+      case _types2.types._break:
+      case _types2.types._continue:
+        return this.parseBreakContinueStatement(node, starttype.keyword);
+
+      case _types2.types._debugger:
+        return this.parseDebuggerStatement(node);
+
+      case _types2.types._do:
+        return this.parseDoStatement(node);
+
+      case _types2.types._for:
+        return this.parseForStatement(node);
+
+      case _types2.types._function:
+        if (this.lookaheadCharCode() === 46) break;
+
+        if (context) {
+          if (this.state.strict) {
+            this.raise(this.state.start, "In strict mode code, functions can only be declared at top level or inside a block");
+          } else if (context !== "if" && context !== "label") {
+            this.raise(this.state.start, "In non-strict mode code, functions can only be declared at top level, " + "inside a block, or as the body of an if statement");
+          }
+        }
+
+        return this.parseFunctionStatement(node, false, !context);
+
+      case _types2.types._class:
+        if (context) this.unexpected();
+        return this.parseClass(node, true);
+
+      case _types2.types._if:
+        return this.parseIfStatement(node);
+
+      case _types2.types._return:
+        return this.parseReturnStatement(node);
+
+      case _types2.types._switch:
+        return this.parseSwitchStatement(node);
+
+      case _types2.types._throw:
+        return this.parseThrowStatement(node);
+
+      case _types2.types._try:
+        return this.parseTryStatement(node);
+
+      case _types2.types._const:
+      case _types2.types._var:
+        kind = kind || this.state.value;
+
+        if (context && kind !== "var") {
+          this.raise(this.state.start, "Lexical declaration cannot appear in a single-statement context");
+        }
+
+        return this.parseVarStatement(node, kind);
+
+      case _types2.types._while:
+        return this.parseWhileStatement(node);
+
+      case _types2.types._with:
+        return this.parseWithStatement(node);
+
+      case _types2.types.braceL:
+        return this.parseBlock();
+
+      case _types2.types.semi:
+        return this.parseEmptyStatement(node);
+
+      case _types2.types._export:
+      case _types2.types._import:
+        {
+          const nextTokenCharCode = this.lookaheadCharCode();
+
+          if (nextTokenCharCode === 40 || nextTokenCharCode === 46) {
+            break;
+          }
+
+          if (!this.options.allowImportExportEverywhere && !topLevel) {
+            this.raise(this.state.start, "'import' and 'export' may only appear at the top level");
+          }
+
+          this.next();
+          let result;
+
+          if (starttype === _types2.types._import) {
+            result = this.parseImport(node);
+
+            if (result.type === "ImportDeclaration" && (!result.importKind || result.importKind === "value")) {
+              this.sawUnambiguousESM = true;
+            }
+          } else {
+            result = this.parseExport(node);
+
+            if (result.type === "ExportNamedDeclaration" && (!result.exportKind || result.exportKind === "value") || result.type === "ExportAllDeclaration" && (!result.exportKind || result.exportKind === "value") || result.type === "ExportDefaultDeclaration") {
+              this.sawUnambiguousESM = true;
+            }
+          }
+
+          this.assertModuleNodeAllowed(node);
+          return result;
+        }
+
+      default:
+        {
+          if (this.isAsyncFunction()) {
+            if (context) {
+              this.raise(this.state.start, "Async functions can only be declared at the top level or inside a block");
+            }
+
+            this.next();
+            return this.parseFunctionStatement(node, true, !context);
+          }
+        }
+    }
+
+    const maybeName = this.state.value;
+    const expr = this.parseExpression();
+
+    if (starttype === _types2.types.name && expr.type === "Identifier" && this.eat(_types2.types.colon)) {
+      return this.parseLabeledStatement(node, maybeName, expr, context);
+    } else {
+      return this.parseExpressionStatement(node, expr);
+    }
+  }
+
+  assertModuleNodeAllowed(node) {
+    if (!this.options.allowImportExportEverywhere && !this.inModule) {
+      this.raise(node.start, `'import' and 'export' may appear only with 'sourceType: "module"'`, {
+        code: "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED"
+      });
+    }
+  }
+
+  takeDecorators(node) {
+    const decorators = this.state.decoratorStack[this.state.decoratorStack.length - 1];
+
+    if (decorators.length) {
+      node.decorators = decorators;
+      this.resetStartLocationFromNode(node, decorators[0]);
+      this.state.decoratorStack[this.state.decoratorStack.length - 1] = [];
+    }
+  }
+
+  canHaveLeadingDecorator() {
+    return this.match(_types2.types._class);
+  }
+
+  parseDecorators(allowExport) {
+    const currentContextDecorators = this.state.decoratorStack[this.state.decoratorStack.length - 1];
+
+    while (this.match(_types2.types.at)) {
+      const decorator = this.parseDecorator();
+      currentContextDecorators.push(decorator);
+    }
+
+    if (this.match(_types2.types._export)) {
+      if (!allowExport) {
+        this.unexpected();
+      }
+
+      if (this.hasPlugin("decorators") && !this.getPluginOption("decorators", "decoratorsBeforeExport")) {
+        this.raise(this.state.start, "Using the export keyword between a decorator and a class is not allowed. " + "Please use `export @dec class` instead.");
+      }
+    } else if (!this.canHaveLeadingDecorator()) {
+      throw this.raise(this.state.start, "Leading decorators must be attached to a class declaration");
+    }
+  }
+
+  parseDecorator() {
+    this.expectOnePlugin(["decorators-legacy", "decorators"]);
+    const node = this.startNode();
+    this.next();
+
+    if (this.hasPlugin("decorators")) {
+      this.state.decoratorStack.push([]);
+      const startPos = this.state.start;
+      const startLoc = this.state.startLoc;
+      let expr;
+
+      if (this.eat(_types2.types.parenL)) {
+        expr = this.parseExpression();
+        this.expect(_types2.types.parenR);
+      } else {
+        expr = this.parseIdentifier(false);
+
+        while (this.eat(_types2.types.dot)) {
+          const node = this.startNodeAt(startPos, startLoc);
+          node.object = expr;
+          node.property = this.parseIdentifier(true);
+          node.computed = false;
+          expr = this.finishNode(node, "MemberExpression");
+        }
+      }
+
+      node.expression = this.parseMaybeDecoratorArguments(expr);
+      this.state.decoratorStack.pop();
+    } else {
+      node.expression = this.parseExprSubscripts();
+    }
+
+    return this.finishNode(node, "Decorator");
+  }
+
+  parseMaybeDecoratorArguments(expr) {
+    if (this.eat(_types2.types.parenL)) {
+      const node = this.startNodeAtNode(expr);
+      node.callee = expr;
+      node.arguments = this.parseCallExpressionArguments(_types2.types.parenR, false);
+      this.toReferencedList(node.arguments);
+      return this.finishNode(node, "CallExpression");
+    }
+
+    return expr;
+  }
+
+  parseBreakContinueStatement(node, keyword) {
+    const isBreak = keyword === "break";
+    this.next();
+
+    if (this.isLineTerminator()) {
+      node.label = null;
+    } else {
+      node.label = this.parseIdentifier();
+      this.semicolon();
+    }
+
+    this.verifyBreakContinue(node, keyword);
+    return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
+  }
+
+  verifyBreakContinue(node, keyword) {
+    const isBreak = keyword === "break";
+    let i;
+
+    for (i = 0; i < this.state.labels.length; ++i) {
+      const lab = this.state.labels[i];
+
+      if (node.label == null || lab.name === node.label.name) {
+        if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
+        if (node.label && isBreak) break;
+      }
+    }
+
+    if (i === this.state.labels.length) {
+      this.raise(node.start, "Unsyntactic " + keyword);
+    }
+  }
+
+  parseDebuggerStatement(node) {
+    this.next();
+    this.semicolon();
+    return this.finishNode(node, "DebuggerStatement");
+  }
+
+  parseHeaderExpression() {
+    this.expect(_types2.types.parenL);
+    const val = this.parseExpression();
+    this.expect(_types2.types.parenR);
+    return val;
+  }
+
+  parseDoStatement(node) {
+    this.next();
+    this.state.labels.push(loopLabel);
+    node.body = this.withTopicForbiddingContext(() => this.parseStatement("do"));
+    this.state.labels.pop();
+    this.expect(_types2.types._while);
+    node.test = this.parseHeaderExpression();
+    this.eat(_types2.types.semi);
+    return this.finishNode(node, "DoWhileStatement");
+  }
+
+  parseForStatement(node) {
+    this.next();
+    this.state.labels.push(loopLabel);
+    let awaitAt = -1;
+
+    if (this.isAwaitAllowed() && this.eatContextual("await")) {
+      awaitAt = this.state.lastTokStart;
+    }
+
+    this.scope.enter(_scopeflags.SCOPE_OTHER);
+    this.expect(_types2.types.parenL);
+
+    if (this.match(_types2.types.semi)) {
+      if (awaitAt > -1) {
+        this.unexpected(awaitAt);
+      }
+
+      return this.parseFor(node, null);
+    }
+
+    const isLet = this.isLet();
+
+    if (this.match(_types2.types._var) || this.match(_types2.types._const) || isLet) {
+      const init = this.startNode();
+      const kind = isLet ? "let" : this.state.value;
+      this.next();
+      this.parseVar(init, true, kind);
+      this.finishNode(init, "VariableDeclaration");
+
+      if ((this.match(_types2.types._in) || this.isContextual("of")) && init.declarations.length === 1) {
+        return this.parseForIn(node, init, awaitAt);
+      }
+
+      if (awaitAt > -1) {
+        this.unexpected(awaitAt);
+      }
+
+      return this.parseFor(node, init);
+    }
+
+    const refShorthandDefaultPos = {
+      start: 0
+    };
+    const init = this.parseExpression(true, refShorthandDefaultPos);
+
+    if (this.match(_types2.types._in) || this.isContextual("of")) {
+      const description = this.isContextual("of") ? "for-of statement" : "for-in statement";
+      this.toAssignable(init, undefined, description);
+      this.checkLVal(init, undefined, undefined, description);
+      return this.parseForIn(node, init, awaitAt);
+    } else if (refShorthandDefaultPos.start) {
+      this.unexpected(refShorthandDefaultPos.start);
+    }
+
+    if (awaitAt > -1) {
+      this.unexpected(awaitAt);
+    }
+
+    return this.parseFor(node, init);
+  }
+
+  parseFunctionStatement(node, isAsync, declarationPosition) {
+    this.next();
+    return this.parseFunction(node, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), isAsync);
+  }
+
+  parseIfStatement(node) {
+    this.next();
+    node.test = this.parseHeaderExpression();
+    node.consequent = this.parseStatement("if");
+    node.alternate = this.eat(_types2.types._else) ? this.parseStatement("if") : null;
+    return this.finishNode(node, "IfStatement");
+  }
+
+  parseReturnStatement(node) {
+    if (!this.scope.inFunction && !this.options.allowReturnOutsideFunction) {
+      this.raise(this.state.start, "'return' outside of function");
+    }
+
+    this.next();
+
+    if (this.isLineTerminator()) {
+      node.argument = null;
+    } else {
+      node.argument = this.parseExpression();
+      this.semicolon();
+    }
+
+    return this.finishNode(node, "ReturnStatement");
+  }
+
+  parseSwitchStatement(node) {
+    this.next();
+    node.discriminant = this.parseHeaderExpression();
+    const cases = node.cases = [];
+    this.expect(_types2.types.braceL);
+    this.state.labels.push(switchLabel);
+    this.scope.enter(_scopeflags.SCOPE_OTHER);
+    let cur;
+
+    for (let sawDefault; !this.match(_types2.types.braceR);) {
+      if (this.match(_types2.types._case) || this.match(_types2.types._default)) {
+        const isCase = this.match(_types2.types._case);
+        if (cur) this.finishNode(cur, "SwitchCase");
+        cases.push(cur = this.startNode());
+        cur.consequent = [];
+        this.next();
+
+        if (isCase) {
+          cur.test = this.parseExpression();
+        } else {
+          if (sawDefault) {
+            this.raise(this.state.lastTokStart, "Multiple default clauses");
+          }
+
+          sawDefault = true;
+          cur.test = null;
+        }
+
+        this.expect(_types2.types.colon);
+      } else {
+        if (cur) {
+          cur.consequent.push(this.parseStatement(null));
+        } else {
+          this.unexpected();
+        }
+      }
+    }
+
+    this.scope.exit();
+    if (cur) this.finishNode(cur, "SwitchCase");
+    this.next();
+    this.state.labels.pop();
+    return this.finishNode(node, "SwitchStatement");
+  }
+
+  parseThrowStatement(node) {
+    this.next();
+
+    if (_whitespace.lineBreak.test(this.input.slice(this.state.lastTokEnd, this.state.start))) {
+      this.raise(this.state.lastTokEnd, "Illegal newline after throw");
+    }
+
+    node.argument = this.parseExpression();
+    this.semicolon();
+    return this.finishNode(node, "ThrowStatement");
+  }
+
+  parseTryStatement(node) {
+    this.next();
+    node.block = this.parseBlock();
+    node.handler = null;
+
+    if (this.match(_types2.types._catch)) {
+      const clause = this.startNode();
+      this.next();
+
+      if (this.match(_types2.types.parenL)) {
+        this.expect(_types2.types.parenL);
+        clause.param = this.parseBindingAtom();
+        const simple = clause.param.type === "Identifier";
+        this.scope.enter(simple ? _scopeflags.SCOPE_SIMPLE_CATCH : 0);
+        this.checkLVal(clause.param, _scopeflags.BIND_LEXICAL, null, "catch clause");
+        this.expect(_types2.types.parenR);
+      } else {
+        clause.param = null;
+        this.scope.enter(_scopeflags.SCOPE_OTHER);
+      }
+
+      clause.body = this.withTopicForbiddingContext(() => this.parseBlock(false, false));
+      this.scope.exit();
+      node.handler = this.finishNode(clause, "CatchClause");
+    }
+
+    node.finalizer = this.eat(_types2.types._finally) ? this.parseBlock() : null;
+
+    if (!node.handler && !node.finalizer) {
+      this.raise(node.start, "Missing catch or finally clause");
+    }
+
+    return this.finishNode(node, "TryStatement");
+  }
+
+  parseVarStatement(node, kind) {
+    this.next();
+    this.parseVar(node, false, kind);
+    this.semicolon();
+    return this.finishNode(node, "VariableDeclaration");
+  }
+
+  parseWhileStatement(node) {
+    this.next();
+    node.test = this.parseHeaderExpression();
+    this.state.labels.push(loopLabel);
+    node.body = this.withTopicForbiddingContext(() => this.parseStatement("while"));
+    this.state.labels.pop();
+    return this.finishNode(node, "WhileStatement");
+  }
+
+  parseWithStatement(node) {
+    if (this.state.strict) {
+      this.raise(this.state.start, "'with' in strict mode");
+    }
+
+    this.next();
+    node.object = this.parseHeaderExpression();
+    node.body = this.withTopicForbiddingContext(() => this.parseStatement("with"));
+    return this.finishNode(node, "WithStatement");
+  }
+
+  parseEmptyStatement(node) {
+    this.next();
+    return this.finishNode(node, "EmptyStatement");
+  }
+
+  parseLabeledStatement(node, maybeName, expr, context) {
+    for (let _i2 = 0, _this$state$labels = this.state.labels; _i2 < _this$state$labels.length; _i2++) {
+      const label = _this$state$labels[_i2];
+
+      if (label.name === maybeName) {
+        this.raise(expr.start, `Label '${maybeName}' is already declared`);
+      }
+    }
+
+    const kind = this.state.type.isLoop ? "loop" : this.match(_types2.types._switch) ? "switch" : null;
+
+    for (let i = this.state.labels.length - 1; i >= 0; i--) {
+      const label = this.state.labels[i];
+
+      if (label.statementStart === node.start) {
+        label.statementStart = this.state.start;
+        label.kind = kind;
+      } else {
+        break;
+      }
+    }
+
+    this.state.labels.push({
+      name: maybeName,
+      kind: kind,
+      statementStart: this.state.start
+    });
+    node.body = this.parseStatement(context ? context.indexOf("label") === -1 ? context + "label" : context : "label");
+    this.state.labels.pop();
+    node.label = expr;
+    return this.finishNode(node, "LabeledStatement");
+  }
+
+  parseExpressionStatement(node, expr) {
+    node.expression = expr;
+    this.semicolon();
+    return this.finishNode(node, "ExpressionStatement");
+  }
+
+  parseBlock(allowDirectives = false, createNewLexicalScope = true) {
+    const node = this.startNode();
+    this.expect(_types2.types.braceL);
+
+    if (createNewLexicalScope) {
+      this.scope.enter(_scopeflags.SCOPE_OTHER);
+    }
+
+    this.parseBlockBody(node, allowDirectives, false, _types2.types.braceR);
+
+    if (createNewLexicalScope) {
+      this.scope.exit();
+    }
+
+    return this.finishNode(node, "BlockStatement");
+  }
+
+  isValidDirective(stmt) {
+    return stmt.type === "ExpressionStatement" && stmt.expression.type === "StringLiteral" && !stmt.expression.extra.parenthesized;
+  }
+
+  parseBlockBody(node, allowDirectives, topLevel, end) {
+    const body = node.body = [];
+    const directives = node.directives = [];
+    this.parseBlockOrModuleBlockBody(body, allowDirectives ? directives : undefined, topLevel, end);
+  }
+
+  parseBlockOrModuleBlockBody(body, directives, topLevel, end) {
+    let parsedNonDirective = false;
+    let oldStrict;
+    let octalPosition;
+
+    while (!this.eat(end)) {
+      if (!parsedNonDirective && this.state.containsOctal && !octalPosition) {
+        octalPosition = this.state.octalPosition;
+      }
+
+      const stmt = this.parseStatement(null, topLevel);
+
+      if (directives && !parsedNonDirective && this.isValidDirective(stmt)) {
+        const directive = this.stmtToDirective(stmt);
+        directives.push(directive);
+
+        if (oldStrict === undefined && directive.value.value === "use strict") {
+          oldStrict = this.state.strict;
+          this.setStrict(true);
+
+          if (octalPosition) {
+            this.raise(octalPosition, "Octal literal in strict mode");
+          }
+        }
+
+        continue;
+      }
+
+      parsedNonDirective = true;
+      body.push(stmt);
+    }
+
+    if (oldStrict === false) {
+      this.setStrict(false);
+    }
+  }
+
+  parseFor(node, init) {
+    node.init = init;
+    this.expect(_types2.types.semi);
+    node.test = this.match(_types2.types.semi) ? null : this.parseExpression();
+    this.expect(_types2.types.semi);
+    node.update = this.match(_types2.types.parenR) ? null : this.parseExpression();
+    this.expect(_types2.types.parenR);
+    node.body = this.withTopicForbiddingContext(() => this.parseStatement("for"));
+    this.scope.exit();
+    this.state.labels.pop();
+    return this.finishNode(node, "ForStatement");
+  }
+
+  parseForIn(node, init, awaitAt) {
+    const isForIn = this.match(_types2.types._in);
+    this.next();
+
+    if (isForIn) {
+      if (awaitAt > -1) this.unexpected(awaitAt);
+    } else {
+      node.await = awaitAt > -1;
+    }
+
+    if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || this.state.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) {
+      this.raise(init.start, `${isForIn ? "for-in" : "for-of"} loop variable declaration may not have an initializer`);
+    } else if (init.type === "AssignmentPattern") {
+      this.raise(init.start, "Invalid left-hand side in for-loop");
+    }
+
+    node.left = init;
+    node.right = isForIn ? this.parseExpression() : this.parseMaybeAssign();
+    this.expect(_types2.types.parenR);
+    node.body = this.withTopicForbiddingContext(() => this.parseStatement("for"));
+    this.scope.exit();
+    this.state.labels.pop();
+    return this.finishNode(node, isForIn ? "ForInStatement" : "ForOfStatement");
+  }
+
+  parseVar(node, isFor, kind) {
+    const declarations = node.declarations = [];
+    const isTypescript = this.hasPlugin("typescript");
+    node.kind = kind;
+
+    for (;;) {
+      const decl = this.startNode();
+      this.parseVarId(decl, kind);
+
+      if (this.eat(_types2.types.eq)) {
+        decl.init = this.parseMaybeAssign(isFor);
+      } else {
+        if (kind === "const" && !(this.match(_types2.types._in) || this.isContextual("of"))) {
+          if (!isTypescript) {
+            this.unexpected();
+          }
+        } else if (decl.id.type !== "Identifier" && !(isFor && (this.match(_types2.types._in) || this.isContextual("of")))) {
+          this.raise(this.state.lastTokEnd, "Complex binding patterns require an initialization value");
+        }
+
+        decl.init = null;
+      }
+
+      declarations.push(this.finishNode(decl, "VariableDeclarator"));
+      if (!this.eat(_types2.types.comma)) break;
+    }
+
+    return node;
+  }
+
+  parseVarId(decl, kind) {
+    decl.id = this.parseBindingAtom();
+    this.checkLVal(decl.id, kind === "var" ? _scopeflags.BIND_VAR : _scopeflags.BIND_LEXICAL, undefined, "variable declaration", kind !== "var");
+  }
+
+  parseFunction(node, statement = FUNC_NO_FLAGS, isAsync = false) {
+    const isStatement = statement & FUNC_STATEMENT;
+    const isHangingStatement = statement & FUNC_HANGING_STATEMENT;
+    const requireId = !!isStatement && !(statement & FUNC_NULLABLE_ID);
+    this.initFunction(node, isAsync);
+
+    if (this.match(_types2.types.star) && isHangingStatement) {
+      this.raise(this.state.start, "Generators can only be declared at the top level or inside a block");
+    }
+
+    node.generator = this.eat(_types2.types.star);
+
+    if (isStatement) {
+      node.id = this.parseFunctionId(requireId);
+    }
+
+    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
+    const oldInClassProperty = this.state.inClassProperty;
+    const oldYieldPos = this.state.yieldPos;
+    const oldAwaitPos = this.state.awaitPos;
+    this.state.maybeInArrowParameters = false;
+    this.state.inClassProperty = false;
+    this.state.yieldPos = -1;
+    this.state.awaitPos = -1;
+    this.scope.enter((0, _scopeflags.functionFlags)(node.async, node.generator));
+
+    if (!isStatement) {
+      node.id = this.parseFunctionId();
+    }
+
+    this.parseFunctionParams(node);
+    this.withTopicForbiddingContext(() => {
+      this.parseFunctionBodyAndFinish(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
+    });
+    this.scope.exit();
+
+    if (isStatement && !isHangingStatement) {
+      this.registerFunctionStatementId(node);
+    }
+
+    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
+    this.state.inClassProperty = oldInClassProperty;
+    this.state.yieldPos = oldYieldPos;
+    this.state.awaitPos = oldAwaitPos;
+    return node;
+  }
+
+  parseFunctionId(requireId) {
+    return requireId || this.match(_types2.types.name) ? this.parseIdentifier() : null;
+  }
+
+  parseFunctionParams(node, allowModifiers) {
+    const oldInParameters = this.state.inParameters;
+    this.state.inParameters = true;
+    this.expect(_types2.types.parenL);
+    node.params = this.parseBindingList(_types2.types.parenR, 41, false, allowModifiers);
+    this.state.inParameters = oldInParameters;
+    this.checkYieldAwaitInDefaultParams();
+  }
+
+  registerFunctionStatementId(node) {
+    if (!node.id) return;
+    this.scope.declareName(node.id.name, this.state.strict || node.generator || node.async ? this.scope.treatFunctionsAsVar ? _scopeflags.BIND_VAR : _scopeflags.BIND_LEXICAL : _scopeflags.BIND_FUNCTION, node.id.start);
+  }
+
+  parseClass(node, isStatement, optionalId) {
+    this.next();
+    this.takeDecorators(node);
+    const oldStrict = this.state.strict;
+    this.state.strict = true;
+    this.parseClassId(node, isStatement, optionalId);
+    this.parseClassSuper(node);
+    node.body = this.parseClassBody(!!node.superClass);
+    this.state.strict = oldStrict;
+    return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
+  }
+
+  isClassProperty() {
+    return this.match(_types2.types.eq) || this.match(_types2.types.semi) || this.match(_types2.types.braceR);
+  }
+
+  isClassMethod() {
+    return this.match(_types2.types.parenL);
+  }
+
+  isNonstaticConstructor(method) {
+    return !method.computed && !method.static && (method.key.name === "constructor" || method.key.value === "constructor");
+  }
+
+  parseClassBody(constructorAllowsSuper) {
+    this.state.classLevel++;
+    const state = {
+      hadConstructor: false
+    };
+    let decorators = [];
+    const classBody = this.startNode();
+    classBody.body = [];
+    this.expect(_types2.types.braceL);
+    this.withTopicForbiddingContext(() => {
+      while (!this.eat(_types2.types.braceR)) {
+        if (this.eat(_types2.types.semi)) {
+          if (decorators.length > 0) {
+            throw this.raise(this.state.lastTokEnd, "Decorators must not be followed by a semicolon");
+          }
+
+          continue;
+        }
+
+        if (this.match(_types2.types.at)) {
+          decorators.push(this.parseDecorator());
+          continue;
+        }
+
+        const member = this.startNode();
+
+        if (decorators.length) {
+          member.decorators = decorators;
+          this.resetStartLocationFromNode(member, decorators[0]);
+          decorators = [];
+        }
+
+        this.parseClassMember(classBody, member, state, constructorAllowsSuper);
+
+        if (member.kind === "constructor" && member.decorators && member.decorators.length > 0) {
+          this.raise(member.start, "Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?");
+        }
+      }
+    });
+
+    if (decorators.length) {
+      throw this.raise(this.state.start, "You have trailing decorators with no method");
+    }
+
+    this.state.classLevel--;
+    return this.finishNode(classBody, "ClassBody");
+  }
+
+  parseClassMember(classBody, member, state, constructorAllowsSuper) {
+    let isStatic = false;
+    const containsEsc = this.state.containsEsc;
+
+    if (this.match(_types2.types.name) && this.state.value === "static") {
+      const key = this.parseIdentifier(true);
+
+      if (this.isClassMethod()) {
+        const method = member;
+        method.kind = "method";
+        method.computed = false;
+        method.key = key;
+        method.static = false;
+        this.pushClassMethod(classBody, method, false, false, false, false);
+        return;
+      } else if (this.isClassProperty()) {
+        const prop = member;
+        prop.computed = false;
+        prop.key = key;
+        prop.static = false;
+        classBody.body.push(this.parseClassProperty(prop));
+        return;
+      } else if (containsEsc) {
+        throw this.unexpected();
+      }
+
+      isStatic = true;
+    }
+
+    this.parseClassMemberWithIsStatic(classBody, member, state, isStatic, constructorAllowsSuper);
+  }
+
+  parseClassMemberWithIsStatic(classBody, member, state, isStatic, constructorAllowsSuper) {
+    const publicMethod = member;
+    const privateMethod = member;
+    const publicProp = member;
+    const privateProp = member;
+    const method = publicMethod;
+    const publicMember = publicMethod;
+    member.static = isStatic;
+
+    if (this.eat(_types2.types.star)) {
+      method.kind = "method";
+      this.parseClassPropertyName(method);
+
+      if (method.key.type === "PrivateName") {
+        this.pushClassPrivateMethod(classBody, privateMethod, true, false);
+        return;
+      }
+
+      if (this.isNonstaticConstructor(publicMethod)) {
+        this.raise(publicMethod.key.start, "Constructor can't be a generator");
+      }
+
+      this.pushClassMethod(classBody, publicMethod, true, false, false, false);
+      return;
+    }
+
+    const containsEsc = this.state.containsEsc;
+    const key = this.parseClassPropertyName(member);
+    const isPrivate = key.type === "PrivateName";
+    const isSimple = key.type === "Identifier";
+    const maybeQuestionTokenStart = this.state.start;
+    this.parsePostMemberNameModifiers(publicMember);
+
+    if (this.isClassMethod()) {
+      method.kind = "method";
+
+      if (isPrivate) {
+        this.pushClassPrivateMethod(classBody, privateMethod, false, false);
+        return;
+      }
+
+      const isConstructor = this.isNonstaticConstructor(publicMethod);
+      let allowsDirectSuper = false;
+
+      if (isConstructor) {
+        publicMethod.kind = "constructor";
+
+        if (state.hadConstructor && !this.hasPlugin("typescript")) {
+          this.raise(key.start, "Duplicate constructor in the same class");
+        }
+
+        state.hadConstructor = true;
+        allowsDirectSuper = constructorAllowsSuper;
+      }
+
+      this.pushClassMethod(classBody, publicMethod, false, false, isConstructor, allowsDirectSuper);
+    } else if (this.isClassProperty()) {
+      if (isPrivate) {
+        this.pushClassPrivateProperty(classBody, privateProp);
+      } else {
+        this.pushClassProperty(classBody, publicProp);
+      }
+    } else if (isSimple && key.name === "async" && !containsEsc && !this.isLineTerminator()) {
+      const isGenerator = this.eat(_types2.types.star);
+
+      if (publicMember.optional) {
+        this.unexpected(maybeQuestionTokenStart);
+      }
+
+      method.kind = "method";
+      this.parseClassPropertyName(method);
+      this.parsePostMemberNameModifiers(publicMember);
+
+      if (method.key.type === "PrivateName") {
+        this.pushClassPrivateMethod(classBody, privateMethod, isGenerator, true);
+      } else {
+        if (this.isNonstaticConstructor(publicMethod)) {
+          this.raise(publicMethod.key.start, "Constructor can't be an async function");
+        }
+
+        this.pushClassMethod(classBody, publicMethod, isGenerator, true, false, false);
+      }
+    } else if (isSimple && (key.name === "get" || key.name === "set") && !containsEsc && !(this.match(_types2.types.star) && this.isLineTerminator())) {
+      method.kind = key.name;
+      this.parseClassPropertyName(publicMethod);
+
+      if (method.key.type === "PrivateName") {
+        this.pushClassPrivateMethod(classBody, privateMethod, false, false);
+      } else {
+        if (this.isNonstaticConstructor(publicMethod)) {
+          this.raise(publicMethod.key.start, "Constructor can't have get/set modifier");
+        }
+
+        this.pushClassMethod(classBody, publicMethod, false, false, false, false);
+      }
+
+      this.checkGetterSetterParams(publicMethod);
+    } else if (this.isLineTerminator()) {
+      if (isPrivate) {
+        this.pushClassPrivateProperty(classBody, privateProp);
+      } else {
+        this.pushClassProperty(classBody, publicProp);
+      }
+    } else {
+      this.unexpected();
+    }
+  }
+
+  parseClassPropertyName(member) {
+    const key = this.parsePropertyName(member);
+
+    if (!member.computed && member.static && (key.name === "prototype" || key.value === "prototype")) {
+      this.raise(key.start, "Classes may not have static property named prototype");
+    }
+
+    if (key.type === "PrivateName" && key.id.name === "constructor") {
+      this.raise(key.start, "Classes may not have a private field named '#constructor'");
+    }
+
+    return key;
+  }
+
+  pushClassProperty(classBody, prop) {
+    if (!prop.computed && (prop.key.name === "constructor" || prop.key.value === "constructor")) {
+      this.raise(prop.key.start, "Classes may not have a field named 'constructor'");
+    }
+
+    classBody.body.push(this.parseClassProperty(prop));
+  }
+
+  pushClassPrivateProperty(classBody, prop) {
+    this.expectPlugin("classPrivateProperties", prop.key.start);
+    classBody.body.push(this.parseClassPrivateProperty(prop));
+  }
+
+  pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
+    classBody.body.push(this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, "ClassMethod", true));
+  }
+
+  pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
+    this.expectPlugin("classPrivateMethods", method.key.start);
+    classBody.body.push(this.parseMethod(method, isGenerator, isAsync, false, false, "ClassPrivateMethod", true));
+  }
+
+  parsePostMemberNameModifiers(methodOrProp) {}
+
+  parseAccessModifier() {
+    return undefined;
+  }
+
+  parseClassPrivateProperty(node) {
+    this.state.inClassProperty = true;
+    this.scope.enter(_scopeflags.SCOPE_CLASS | _scopeflags.SCOPE_SUPER);
+    node.value = this.eat(_types2.types.eq) ? this.parseMaybeAssign() : null;
+    this.semicolon();
+    this.state.inClassProperty = false;
+    this.scope.exit();
+    return this.finishNode(node, "ClassPrivateProperty");
+  }
+
+  parseClassProperty(node) {
+    if (!node.typeAnnotation) {
+      this.expectPlugin("classProperties");
+    }
+
+    this.state.inClassProperty = true;
+    this.scope.enter(_scopeflags.SCOPE_CLASS | _scopeflags.SCOPE_SUPER);
+
+    if (this.match(_types2.types.eq)) {
+      this.expectPlugin("classProperties");
+      this.next();
+      node.value = this.parseMaybeAssign();
+    } else {
+      node.value = null;
+    }
+
+    this.semicolon();
+    this.state.inClassProperty = false;
+    this.scope.exit();
+    return this.finishNode(node, "ClassProperty");
+  }
+
+  parseClassId(node, isStatement, optionalId, bindingType = _scopeflags.BIND_CLASS) {
+    if (this.match(_types2.types.name)) {
+      node.id = this.parseIdentifier();
+
+      if (isStatement) {
+        this.checkLVal(node.id, bindingType, undefined, "class name");
+      }
+    } else {
+      if (optionalId || !isStatement) {
+        node.id = null;
+      } else {
+        this.unexpected(null, "A class name is required");
+      }
+    }
+  }
+
+  parseClassSuper(node) {
+    node.superClass = this.eat(_types2.types._extends) ? this.parseExprSubscripts() : null;
+  }
+
+  parseExport(node) {
+    const hasDefault = this.maybeParseExportDefaultSpecifier(node);
+    const parseAfterDefault = !hasDefault || this.eat(_types2.types.comma);
+    const hasStar = parseAfterDefault && this.eatExportStar(node);
+    const hasNamespace = hasStar && this.maybeParseExportNamespaceSpecifier(node);
+    const parseAfterNamespace = parseAfterDefault && (!hasNamespace || this.eat(_types2.types.comma));
+    const isFromRequired = hasDefault || hasStar;
+
+    if (hasStar && !hasNamespace) {
+      if (hasDefault) this.unexpected();
+      this.parseExportFrom(node, true);
+      return this.finishNode(node, "ExportAllDeclaration");
+    }
+
+    const hasSpecifiers = this.maybeParseExportNamedSpecifiers(node);
+
+    if (hasDefault && parseAfterDefault && !hasStar && !hasSpecifiers || hasNamespace && parseAfterNamespace && !hasSpecifiers) {
+      throw this.unexpected(null, _types2.types.braceL);
+    }
+
+    let hasDeclaration;
+
+    if (isFromRequired || hasSpecifiers) {
+      hasDeclaration = false;
+      this.parseExportFrom(node, isFromRequired);
+    } else {
+      hasDeclaration = this.maybeParseExportDeclaration(node);
+    }
+
+    if (isFromRequired || hasSpecifiers || hasDeclaration) {
+      this.checkExport(node, true, false, !!node.source);
+      return this.finishNode(node, "ExportNamedDeclaration");
+    }
+
+    if (this.eat(_types2.types._default)) {
+      node.declaration = this.parseExportDefaultExpression();
+      this.checkExport(node, true, true);
+      return this.finishNode(node, "ExportDefaultDeclaration");
+    }
+
+    throw this.unexpected(null, _types2.types.braceL);
+  }
+
+  eatExportStar(node) {
+    return this.eat(_types2.types.star);
+  }
+
+  maybeParseExportDefaultSpecifier(node) {
+    if (this.isExportDefaultSpecifier()) {
+      this.expectPlugin("exportDefaultFrom");
+      const specifier = this.startNode();
+      specifier.exported = this.parseIdentifier(true);
+      node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")];
+      return true;
+    }
+
+    return false;
+  }
+
+  maybeParseExportNamespaceSpecifier(node) {
+    if (this.isContextual("as")) {
+      if (!node.specifiers) node.specifiers = [];
+      const specifier = this.startNodeAt(this.state.lastTokStart, this.state.lastTokStartLoc);
+      this.next();
+      specifier.exported = this.parseIdentifier(true);
+      node.specifiers.push(this.finishNode(specifier, "ExportNamespaceSpecifier"));
+      return true;
+    }
+
+    return false;
+  }
+
+  maybeParseExportNamedSpecifiers(node) {
+    if (this.match(_types2.types.braceL)) {
+      if (!node.specifiers) node.specifiers = [];
+      node.specifiers.push(...this.parseExportSpecifiers());
+      node.source = null;
+      node.declaration = null;
+      return true;
+    }
+
+    return false;
+  }
+
+  maybeParseExportDeclaration(node) {
+    if (this.shouldParseExportDeclaration()) {
+      if (this.isContextual("async")) {
+        const next = this.nextTokenStart();
+
+        if (!this.isUnparsedContextual(next, "function")) {
+          this.unexpected(next, `Unexpected token, expected "function"`);
+        }
+      }
+
+      node.specifiers = [];
+      node.source = null;
+      node.declaration = this.parseExportDeclaration(node);
+      return true;
+    }
+
+    return false;
+  }
+
+  isAsyncFunction() {
+    if (!this.isContextual("async")) return false;
+    const next = this.nextTokenStart();
+    return !_whitespace.lineBreak.test(this.input.slice(this.state.pos, next)) && this.isUnparsedContextual(next, "function");
+  }
+
+  parseExportDefaultExpression() {
+    const expr = this.startNode();
+    const isAsync = this.isAsyncFunction();
+
+    if (this.match(_types2.types._function) || isAsync) {
+      this.next();
+
+      if (isAsync) {
+        this.next();
+      }
+
+      return this.parseFunction(expr, FUNC_STATEMENT | FUNC_NULLABLE_ID, isAsync);
+    } else if (this.match(_types2.types._class)) {
+      return this.parseClass(expr, true, true);
+    } else if (this.match(_types2.types.at)) {
+      if (this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport")) {
+        this.raise(this.state.start, "Decorators must be placed *before* the 'export' keyword." + " You can set the 'decoratorsBeforeExport' option to false to use" + " the 'export @decorator class {}' syntax");
+      }
+
+      this.parseDecorators(false);
+      return this.parseClass(expr, true, true);
+    } else if (this.match(_types2.types._const) || this.match(_types2.types._var) || this.isLet()) {
+      throw this.raise(this.state.start, "Only expressions, functions or classes are allowed as the `default` export.");
+    } else {
+      const res = this.parseMaybeAssign();
+      this.semicolon();
+      return res;
+    }
+  }
+
+  parseExportDeclaration(node) {
+    return this.parseStatement(null);
+  }
+
+  isExportDefaultSpecifier() {
+    if (this.match(_types2.types.name)) {
+      return this.state.value !== "async" && this.state.value !== "let";
+    }
+
+    if (!this.match(_types2.types._default)) {
+      return false;
+    }
+
+    const next = this.nextTokenStart();
+    return this.input.charCodeAt(next) === 44 || this.isUnparsedContextual(next, "from");
+  }
+
+  parseExportFrom(node, expect) {
+    if (this.eatContextual("from")) {
+      node.source = this.parseImportSource();
+      this.checkExport(node);
+    } else {
+      if (expect) {
+        this.unexpected();
+      } else {
+        node.source = null;
+      }
+    }
+
+    this.semicolon();
+  }
+
+  shouldParseExportDeclaration() {
+    if (this.match(_types2.types.at)) {
+      this.expectOnePlugin(["decorators", "decorators-legacy"]);
+
+      if (this.hasPlugin("decorators")) {
+        if (this.getPluginOption("decorators", "decoratorsBeforeExport")) {
+          this.unexpected(this.state.start, "Decorators must be placed *before* the 'export' keyword." + " You can set the 'decoratorsBeforeExport' option to false to use" + " the 'export @decorator class {}' syntax");
+        } else {
+          return true;
+        }
+      }
+    }
+
+    return this.state.type.keyword === "var" || this.state.type.keyword === "const" || this.state.type.keyword === "function" || this.state.type.keyword === "class" || this.isLet() || this.isAsyncFunction();
+  }
+
+  checkExport(node, checkNames, isDefault, isFrom) {
+    if (checkNames) {
+      if (isDefault) {
+        this.checkDuplicateExports(node, "default");
+      } else if (node.specifiers && node.specifiers.length) {
+        for (let _i3 = 0, _node$specifiers = node.specifiers; _i3 < _node$specifiers.length; _i3++) {
+          const specifier = _node$specifiers[_i3];
+          this.checkDuplicateExports(specifier, specifier.exported.name);
+
+          if (!isFrom && specifier.local) {
+            this.checkReservedWord(specifier.local.name, specifier.local.start, true, false);
+            this.scope.checkLocalExport(specifier.local);
+          }
+        }
+      } else if (node.declaration) {
+        if (node.declaration.type === "FunctionDeclaration" || node.declaration.type === "ClassDeclaration") {
+          const id = node.declaration.id;
+          if (!id) throw new Error("Assertion failure");
+          this.checkDuplicateExports(node, id.name);
+        } else if (node.declaration.type === "VariableDeclaration") {
+          for (let _i4 = 0, _node$declaration$dec = node.declaration.declarations; _i4 < _node$declaration$dec.length; _i4++) {
+            const declaration = _node$declaration$dec[_i4];
+            this.checkDeclaration(declaration.id);
+          }
+        }
+      }
+    }
+
+    const currentContextDecorators = this.state.decoratorStack[this.state.decoratorStack.length - 1];
+
+    if (currentContextDecorators.length) {
+      const isClass = node.declaration && (node.declaration.type === "ClassDeclaration" || node.declaration.type === "ClassExpression");
+
+      if (!node.declaration || !isClass) {
+        throw this.raise(node.start, "You can only use decorators on an export when exporting a class");
+      }
+
+      this.takeDecorators(node.declaration);
+    }
+  }
+
+  checkDeclaration(node) {
+    if (node.type === "Identifier") {
+      this.checkDuplicateExports(node, node.name);
+    } else if (node.type === "ObjectPattern") {
+      for (let _i5 = 0, _node$properties = node.properties; _i5 < _node$properties.length; _i5++) {
+        const prop = _node$properties[_i5];
+        this.checkDeclaration(prop);
+      }
+    } else if (node.type === "ArrayPattern") {
+      for (let _i6 = 0, _node$elements = node.elements; _i6 < _node$elements.length; _i6++) {
+        const elem = _node$elements[_i6];
+
+        if (elem) {
+          this.checkDeclaration(elem);
+        }
+      }
+    } else if (node.type === "ObjectProperty") {
+      this.checkDeclaration(node.value);
+    } else if (node.type === "RestElement") {
+      this.checkDeclaration(node.argument);
+    } else if (node.type === "AssignmentPattern") {
+      this.checkDeclaration(node.left);
+    }
+  }
+
+  checkDuplicateExports(node, name) {
+    if (this.state.exportedIdentifiers.indexOf(name) > -1) {
+      this.raise(node.start, name === "default" ? "Only one default export allowed per module." : `\`${name}\` has already been exported. Exported identifiers must be unique.`);
+    }
+
+    this.state.exportedIdentifiers.push(name);
+  }
+
+  parseExportSpecifiers() {
+    const nodes = [];
+    let first = true;
+    this.expect(_types2.types.braceL);
+
+    while (!this.eat(_types2.types.braceR)) {
+      if (first) {
+        first = false;
+      } else {
+        this.expect(_types2.types.comma);
+        if (this.eat(_types2.types.braceR)) break;
+      }
+
+      const node = this.startNode();
+      node.local = this.parseIdentifier(true);
+      node.exported = this.eatContextual("as") ? this.parseIdentifier(true) : node.local.__clone();
+      nodes.push(this.finishNode(node, "ExportSpecifier"));
+    }
+
+    return nodes;
+  }
+
+  parseImport(node) {
+    node.specifiers = [];
+
+    if (!this.match(_types2.types.string)) {
+      const hasDefault = this.maybeParseDefaultImportSpecifier(node);
+      const parseNext = !hasDefault || this.eat(_types2.types.comma);
+      const hasStar = parseNext && this.maybeParseStarImportSpecifier(node);
+      if (parseNext && !hasStar) this.parseNamedImportSpecifiers(node);
+      this.expectContextual("from");
+    }
+
+    node.source = this.parseImportSource();
+    this.semicolon();
+    return this.finishNode(node, "ImportDeclaration");
+  }
+
+  parseImportSource() {
+    if (!this.match(_types2.types.string)) this.unexpected();
+    return this.parseExprAtom();
+  }
+
+  shouldParseDefaultImport(node) {
+    return this.match(_types2.types.name);
+  }
+
+  parseImportSpecifierLocal(node, specifier, type, contextDescription) {
+    specifier.local = this.parseIdentifier();
+    this.checkLVal(specifier.local, _scopeflags.BIND_LEXICAL, undefined, contextDescription);
+    node.specifiers.push(this.finishNode(specifier, type));
+  }
+
+  maybeParseDefaultImportSpecifier(node) {
+    if (this.shouldParseDefaultImport(node)) {
+      this.parseImportSpecifierLocal(node, this.startNode(), "ImportDefaultSpecifier", "default import specifier");
+      return true;
+    }
+
+    return false;
+  }
+
+  maybeParseStarImportSpecifier(node) {
+    if (this.match(_types2.types.star)) {
+      const specifier = this.startNode();
+      this.next();
+      this.expectContextual("as");
+      this.parseImportSpecifierLocal(node, specifier, "ImportNamespaceSpecifier", "import namespace specifier");
+      return true;
+    }
+
+    return false;
+  }
+
+  parseNamedImportSpecifiers(node) {
+    let first = true;
+    this.expect(_types2.types.braceL);
+
+    while (!this.eat(_types2.types.braceR)) {
+      if (first) {
+        first = false;
+      } else {
+        if (this.eat(_types2.types.colon)) {
+          throw this.raise(this.state.start, "ES2015 named imports do not destructure. " + "Use another statement for destructuring after the import.");
+        }
+
+        this.expect(_types2.types.comma);
+        if (this.eat(_types2.types.braceR)) break;
+      }
+
+      this.parseImportSpecifier(node);
+    }
+  }
+
+  parseImportSpecifier(node) {
+    const specifier = this.startNode();
+    specifier.imported = this.parseIdentifier(true);
+
+    if (this.eatContextual("as")) {
+      specifier.local = this.parseIdentifier();
+    } else {
+      this.checkReservedWord(specifier.imported.name, specifier.start, true, true);
+      specifier.local = specifier.imported.__clone();
+    }
+
+    this.checkLVal(specifier.local, _scopeflags.BIND_LEXICAL, undefined, "import specifier");
+    node.specifiers.push(this.finishNode(specifier, "ImportSpecifier"));
+  }
+
+}
+
+exports.default = StatementParser;