@tinacms/app 1.0.0 → 1.0.2

package/appFiles/node_modules/@babel/parser/lib/index.js

@@ -455,6 +455,7 @@ var estree = (superClass => class ESTreeParserMixin extends superClass {
       regex = new RegExp(pattern, flags);
     } catch (e) {
     }
+
     const node = this.estreeParseLiteral(regex);
     node.regex = {
       pattern,
@@ -5293,7 +5294,7 @@ var flow = (superClass => class FlowParserMixin extends superClass {
     return super.parseFunctionBodyAndFinish(node, type, isMethod);
   }
 
-  parseStatement(context, topLevel) {
+  parseStatementLike(flags) {
     if (this.state.strict && this.isContextual(127)) {
       const lookahead = this.lookahead();
       if (tokenIsKeywordOrIdentifier(lookahead.type)) {
@@ -5306,7 +5307,7 @@ var flow = (superClass => class FlowParserMixin extends superClass {
       this.next();
       return this.flowParseEnumDeclaration(node);
     }
-    const stmt = super.parseStatement(context, topLevel);
+    const stmt = super.parseStatementLike(flags);
     if (this.flowPragma === undefined && !this.isValidDirective(stmt)) {
       this.flowPragma = null;
     }
@@ -8729,7 +8730,7 @@ var typescript = (superClass => class TypeScriptParserMixin extends superClass {
     return this.tsInAmbientContext(() => {
       if (starttype === 68) {
         nany.declare = true;
-        return super.parseFunctionStatement(nany, false, true);
+        return super.parseFunctionStatement(nany, false, false);
       }
       if (starttype === 80) {
         nany.declare = true;
@@ -9204,7 +9205,7 @@ var typescript = (superClass => class TypeScriptParserMixin extends superClass {
     }
     return declaration;
   }
-  parseStatementContent(context, topLevel, decorators) {
+  parseStatementContent(flags, decorators) {
     if (this.match(75) && this.isLookaheadContextual("enum")) {
       const node = this.startNode();
       this.expect(75);
@@ -9219,7 +9220,7 @@ var typescript = (superClass => class TypeScriptParserMixin extends superClass {
       const result = this.tsParseInterfaceDeclaration(this.startNode());
       if (result) return result;
     }
-    return super.parseStatementContent(context, topLevel, decorators);
+    return super.parseStatementContent(flags, decorators);
   }
   parseAccessModifier() {
     return this.tsParseModifier(["public", "protected", "private"]);
@@ -10048,11 +10049,10 @@ var placeholders = (superClass => class PlaceholdersParserMixin extends superCla
     }
   }
 
-  hasFollowingIdentifier(context) {
-    if (super.hasFollowingIdentifier(context)) {
+  chStartsBindingIdentifier(ch, pos) {
+    if (super.chStartsBindingIdentifier(ch, pos)) {
       return true;
     }
-    if (context) return false;
 
     const nextToken = this.lookahead();
     if (nextToken.type === 142) {
@@ -10073,7 +10073,7 @@ var placeholders = (superClass => class PlaceholdersParserMixin extends superCla
       const stmt = node;
       stmt.label = this.finishPlaceholder(expr, "Identifier");
       this.next();
-      stmt.body = super.parseStatement("label");
+      stmt.body = super.parseStatementOrFunctionDeclaration(false);
       return this.finishNode(stmt, "LabeledStatement");
     }
     this.semicolon();
@@ -11547,7 +11547,7 @@ class ExpressionParser extends LValParser {
             if (type === 68) {
               this.resetPreviousNodeTrailingComments(id);
               this.next();
-              return this.parseFunction(this.startNodeAtNode(id), undefined, true);
+              return this.parseAsyncFunctionExpression(this.startNodeAtNode(id));
             } else if (tokenIsIdentifier(type)) {
               if (this.lookaheadCharCode() === 61) {
                 return this.parseAsyncArrowUnaryFunction(this.startNodeAtNode(id));
@@ -12213,12 +12213,12 @@ class ExpressionParser extends LValParser {
   initFunction(node, isAsync) {
     node.id = null;
     node.generator = false;
-    node.async = !!isAsync;
+    node.async = isAsync;
   }
 
   parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) {
     this.initFunction(node, isAsync);
-    node.generator = !!isGenerator;
+    node.generator = isGenerator;
     const allowModifiers = isConstructor;
     this.scope.enter(SCOPE_FUNCTION | SCOPE_SUPER | (inClassScope ? SCOPE_CLASS : 0) | (allowDirectSuper ? SCOPE_DIRECT_SUPER : 0));
     this.prodParam.enter(functionFlags(isAsync, node.generator));
@@ -12702,10 +12702,20 @@ const loopLabel = {
   switchLabel = {
     kind: "switch"
   };
-const FUNC_NO_FLAGS = 0b000,
-  FUNC_STATEMENT = 0b001,
-  FUNC_HANGING_STATEMENT = 0b010,
-  FUNC_NULLABLE_ID = 0b100;
+var ParseFunctionFlag = {
+  Expression: 0,
+  Declaration: 1,
+  HangingDeclaration: 2,
+  NullableId: 4,
+  Async: 8
+};
+var ParseStatementFlag = {
+  StatementOnly: 0,
+  AllowImportExport: 1,
+  AllowDeclaration: 2,
+  AllowFunctionDeclaration: 4,
+  AllowLabeledFunction: 8
+};
 const loneSurrogate = /[\uD800-\uDFFF]/u;
 const keywordRelationalOperator = /in(?:stanceof)?/y;
 
@@ -12872,23 +12882,15 @@ class StatementParser extends ExpressionParser {
     this.next();
     return this.finishNode(node, "InterpreterDirective");
   }
-  isLet(context) {
+  isLet() {
     if (!this.isContextual(99)) {
       return false;
     }
-    return this.hasFollowingIdentifier(context);
+    return this.hasFollowingBindingAtom();
   }
-
-  hasFollowingIdentifier(context) {
-    const next = this.nextTokenStart();
-    const nextCh = this.codePointAtPos(next);
-    if (nextCh === 92 || nextCh === 91) {
-      return true;
-    }
-    if (context) return false;
-    if (nextCh === 123) return true;
-    if (isIdentifierStart(nextCh)) {
-      keywordRelationalOperator.lastIndex = next;
+  chStartsBindingIdentifier(ch, pos) {
+    if (isIdentifierStart(ch)) {
+      keywordRelationalOperator.lastIndex = pos;
       if (keywordRelationalOperator.test(this.input)) {
         const endCh = this.codePointAtPos(keywordRelationalOperator.lastIndex);
         if (!isIdentifierChar(endCh) && endCh !== 92) {
@@ -12896,8 +12898,26 @@ class StatementParser extends ExpressionParser {
         }
       }
       return true;
+    } else if (ch === 92) {
+      return true;
+    } else {
+      return false;
     }
-    return false;
+  }
+  chStartsBindingPattern(ch) {
+    return ch === 91 || ch === 123;
+  }
+
+  hasFollowingBindingAtom() {
+    const next = this.nextTokenStart();
+    const nextCh = this.codePointAtPos(next);
+    return this.chStartsBindingPattern(nextCh) || this.chStartsBindingIdentifier(nextCh, next);
+  }
+
+  hasFollowingBindingIdentifier() {
+    const next = this.nextTokenStart();
+    const nextCh = this.codePointAtPos(next);
+    return this.chStartsBindingIdentifier(nextCh, next);
   }
   startsUsingForOf() {
     const lookahead = this.lookahead();
@@ -12909,16 +12929,34 @@ class StatementParser extends ExpressionParser {
     }
   }
 
-  parseStatement(context, topLevel) {
+  parseModuleItem() {
+    return this.parseStatementLike(ParseStatementFlag.AllowImportExport | ParseStatementFlag.AllowDeclaration | ParseStatementFlag.AllowFunctionDeclaration | ParseStatementFlag.AllowLabeledFunction);
+  }
+
+  parseStatementListItem() {
+    return this.parseStatementLike(ParseStatementFlag.AllowDeclaration | ParseStatementFlag.AllowFunctionDeclaration | ParseStatementFlag.AllowLabeledFunction);
+  }
+  parseStatementOrFunctionDeclaration(disallowLabeledFunction) {
+    return this.parseStatementLike(ParseStatementFlag.AllowFunctionDeclaration | (disallowLabeledFunction ? 0 : ParseStatementFlag.AllowLabeledFunction));
+  }
+
+  parseStatement() {
+    return this.parseStatementLike(ParseStatementFlag.StatementOnly);
+  }
+
+  parseStatementLike(flags) {
     let decorators = null;
     if (this.match(26)) {
       decorators = this.parseDecorators(true);
     }
-    return this.parseStatementContent(context, topLevel, decorators);
+    return this.parseStatementContent(flags, decorators);
   }
-  parseStatementContent(context, topLevel, decorators) {
+  parseStatementContent(flags, decorators) {
     const starttype = this.state.type;
     const node = this.startNode();
+    const allowDeclaration = !!(flags & ParseStatementFlag.AllowDeclaration);
+    const allowFunctionDeclaration = !!(flags & ParseStatementFlag.AllowFunctionDeclaration);
+    const topLevel = flags & ParseStatementFlag.AllowImportExport;
 
     switch (starttype) {
       case 60:
@@ -12928,25 +12966,25 @@ class StatementParser extends ExpressionParser {
       case 64:
         return this.parseDebuggerStatement(node);
       case 90:
-        return this.parseDoStatement(node);
+        return this.parseDoWhileStatement(node);
       case 91:
         return this.parseForStatement(node);
       case 68:
         if (this.lookaheadCharCode() === 46) break;
-        if (context) {
+        if (!allowDeclaration) {
           if (this.state.strict) {
             this.raise(Errors.StrictFunction, {
               at: this.state.startLoc
             });
-          } else if (context !== "if" && context !== "label") {
+          } else if (!allowFunctionDeclaration) {
             this.raise(Errors.SloppyFunction, {
               at: this.state.startLoc
             });
           }
         }
-        return this.parseFunctionStatement(node, false, !context);
+        return this.parseFunctionStatement(node, false, !allowDeclaration && allowFunctionDeclaration);
       case 80:
-        if (context) this.unexpected();
+        if (!allowDeclaration) this.unexpected();
         return this.parseClass(this.maybeTakeDecorators(decorators, node), true);
       case 69:
         return this.parseIfStatement(node);
@@ -12959,30 +12997,45 @@ class StatementParser extends ExpressionParser {
       case 73:
         return this.parseTryStatement(node);
       case 105:
-        if (this.hasFollowingLineBreak()) {
+        if (this.hasFollowingLineBreak() || this.state.containsEsc || !this.hasFollowingBindingIdentifier()) {
           break;
         }
-      case 99:
-        if (this.state.containsEsc || !this.hasFollowingIdentifier(context)) {
-          break;
+        this.expectPlugin("explicitResourceManagement");
+        if (!this.scope.inModule && this.scope.inTopLevel) {
+          this.raise(Errors.UnexpectedUsingDeclaration, {
+            at: this.state.startLoc
+          });
+        } else if (!allowDeclaration) {
+          this.raise(Errors.UnexpectedLexicalDeclaration, {
+            at: this.state.startLoc
+          });
         }
-      case 75:
-      case 74:
+        return this.parseVarStatement(node, "using");
+      case 99:
         {
-          const kind = this.state.value;
-          if (kind === "using") {
-            this.expectPlugin("explicitResourceManagement");
-            if (!this.scope.inModule && this.scope.inTopLevel) {
-              this.raise(Errors.UnexpectedUsingDeclaration, {
-                at: this.state.startLoc
-              });
+          if (this.state.containsEsc) {
+            break;
+          }
+          const next = this.nextTokenStart();
+          const nextCh = this.codePointAtPos(next);
+          if (nextCh !== 91) {
+            if (!allowDeclaration && this.hasFollowingLineBreak()) break;
+            if (!this.chStartsBindingIdentifier(nextCh, next) && nextCh !== 123) {
+              break;
             }
           }
-          if (context && kind !== "var") {
+        }
+      case 75:
+        {
+          if (!allowDeclaration) {
             this.raise(Errors.UnexpectedLexicalDeclaration, {
               at: this.state.startLoc
             });
           }
+        }
+      case 74:
+        {
+          const kind = this.state.value;
           return this.parseVarStatement(node, kind);
         }
       case 92:
@@ -13028,13 +13081,13 @@ class StatementParser extends ExpressionParser {
       default:
         {
           if (this.isAsyncFunction()) {
-            if (context) {
+            if (!allowDeclaration) {
               this.raise(Errors.AsyncFunctionInSingleStatementContext, {
                 at: this.state.startLoc
               });
             }
             this.next();
-            return this.parseFunctionStatement(node, true, !context);
+            return this.parseFunctionStatement(node, true, !allowDeclaration && allowFunctionDeclaration);
           }
         }
     }
@@ -13043,7 +13096,7 @@ class StatementParser extends ExpressionParser {
     const expr = this.parseExpression();
     if (tokenIsIdentifier(starttype) && expr.type === "Identifier" && this.eat(14)) {
       return this.parseLabeledStatement(node, maybeName,
-      expr, context);
+      expr, flags);
     } else {
       return this.parseExpressionStatement(node, expr, decorators);
     }
@@ -13182,13 +13235,14 @@ class StatementParser extends ExpressionParser {
     this.expect(11);
     return val;
   }
-  parseDoStatement(node) {
+
+  parseDoWhileStatement(node) {
     this.next();
     this.state.labels.push(loopLabel);
 
     node.body =
     this.withSmartMixTopicForbiddingContext(() =>
-    this.parseStatement("do"));
+    this.parseStatement());
     this.state.labels.pop();
     this.expect(92);
     node.test = this.parseHeaderExpression();
@@ -13213,7 +13267,7 @@ class StatementParser extends ExpressionParser {
     }
     const startsWithLet = this.isContextual(99);
     const startsWithUsing = this.isContextual(105) && !this.hasFollowingLineBreak();
-    const isLetOrUsing = startsWithLet && this.hasFollowingIdentifier() || startsWithUsing && this.hasFollowingIdentifier() && this.startsUsingForOf();
+    const isLetOrUsing = startsWithLet && this.hasFollowingBindingAtom() || startsWithUsing && this.hasFollowingBindingIdentifier() && this.startsUsingForOf();
     if (this.match(74) || this.match(75) || isLetOrUsing) {
       const initNode = this.startNode();
       const kind = this.state.value;
@@ -13271,15 +13325,18 @@ class StatementParser extends ExpressionParser {
     }
     return this.parseFor(node, init);
   }
-  parseFunctionStatement(node, isAsync, declarationPosition) {
+
+  parseFunctionStatement(node, isAsync, isHangingDeclaration) {
     this.next();
-    return this.parseFunction(node, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), isAsync);
+    return this.parseFunction(node, ParseFunctionFlag.Declaration | (isHangingDeclaration ? ParseFunctionFlag.HangingDeclaration : 0) | (isAsync ? ParseFunctionFlag.Async : 0));
   }
+
   parseIfStatement(node) {
     this.next();
     node.test = this.parseHeaderExpression();
-    node.consequent = this.parseStatement("if");
-    node.alternate = this.eat(66) ? this.parseStatement("if") : null;
+    node.consequent = this.parseStatementOrFunctionDeclaration(
+    true);
+    node.alternate = this.eat(66) ? this.parseStatementOrFunctionDeclaration(true) : null;
     return this.finishNode(node, "IfStatement");
   }
   parseReturnStatement(node) {
@@ -13298,6 +13355,7 @@ class StatementParser extends ExpressionParser {
     }
     return this.finishNode(node, "ReturnStatement");
   }
+
   parseSwitchStatement(node) {
     this.next();
     node.discriminant = this.parseHeaderExpression();
@@ -13328,7 +13386,7 @@ class StatementParser extends ExpressionParser {
         this.expect(14);
       } else {
         if (cur) {
-          cur.consequent.push(this.parseStatement(null));
+          cur.consequent.push(this.parseStatementListItem());
         } else {
           this.unexpected();
         }
@@ -13394,12 +13452,14 @@ class StatementParser extends ExpressionParser {
     }
     return this.finishNode(node, "TryStatement");
   }
+
   parseVarStatement(node, kind, allowMissingInitializer = false) {
     this.next();
     this.parseVar(node, false, kind, allowMissingInitializer);
     this.semicolon();
     return this.finishNode(node, "VariableDeclaration");
   }
+
   parseWhileStatement(node) {
     this.next();
     node.test = this.parseHeaderExpression();
@@ -13407,7 +13467,7 @@ class StatementParser extends ExpressionParser {
 
     node.body =
     this.withSmartMixTopicForbiddingContext(() =>
-    this.parseStatement("while"));
+    this.parseStatement());
     this.state.labels.pop();
     return this.finishNode(node, "WhileStatement");
   }
@@ -13422,14 +13482,15 @@ class StatementParser extends ExpressionParser {
 
     node.body =
     this.withSmartMixTopicForbiddingContext(() =>
-    this.parseStatement("with"));
+    this.parseStatement());
     return this.finishNode(node, "WithStatement");
   }
   parseEmptyStatement(node) {
     this.next();
     return this.finishNode(node, "EmptyStatement");
   }
-  parseLabeledStatement(node, maybeName, expr, context) {
+
+  parseLabeledStatement(node, maybeName, expr, flags) {
     for (const label of this.state.labels) {
       if (label.name === maybeName) {
         this.raise(Errors.LabelRedeclaration, {
@@ -13453,7 +13514,7 @@ class StatementParser extends ExpressionParser {
       kind: kind,
       statementStart: this.state.start
     });
-    node.body = this.parseStatement(context ? context.indexOf("label") === -1 ? context + "label" : context : "label");
+    node.body = flags & ParseStatementFlag.AllowLabeledFunction ? this.parseStatementOrFunctionDeclaration(false) : this.parseStatement();
     this.state.labels.pop();
     node.label = expr;
     return this.finishNode(node, "LabeledStatement");
@@ -13494,7 +13555,7 @@ class StatementParser extends ExpressionParser {
     let hasStrictModeDirective = false;
     let parsedNonDirective = false;
     while (!this.match(end)) {
-      const stmt = this.parseStatement(null, topLevel);
+      const stmt = topLevel ? this.parseModuleItem() : this.parseStatementListItem();
       if (directives && !parsedNonDirective) {
         if (this.isValidDirective(stmt)) {
           const directive = this.stmtToDirective(stmt);
@@ -13529,7 +13590,7 @@ class StatementParser extends ExpressionParser {
 
     node.body =
     this.withSmartMixTopicForbiddingContext(() =>
-    this.parseStatement("for"));
+    this.parseStatement());
     this.scope.exit();
     this.state.labels.pop();
     return this.finishNode(node, "ForStatement");
@@ -13563,7 +13624,7 @@ class StatementParser extends ExpressionParser {
 
     node.body =
     this.withSmartMixTopicForbiddingContext(() =>
-    this.parseStatement("for"));
+    this.parseStatement());
     this.scope.exit();
     this.state.labels.pop();
     return this.finishNode(node, isForIn ? "ForInStatement" : "ForOfStatement");
@@ -13596,11 +13657,6 @@ class StatementParser extends ExpressionParser {
   }
   parseVarId(decl, kind) {
     const id = this.parseBindingAtom();
-    if (kind === "using" && id.type !== "Identifier") {
-      this.raise(Errors.UsingDeclarationHasBindingPattern, {
-        at: id
-      });
-    }
     this.checkLVal(id, {
       in: {
         type: "VariableDeclarator"
@@ -13610,35 +13666,43 @@ class StatementParser extends ExpressionParser {
     decl.id = id;
   }
 
-  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);
+  parseAsyncFunctionExpression(node) {
+    return this.parseFunction(node, ParseFunctionFlag.Async);
+  }
+
+  parseFunction(node, flags = ParseFunctionFlag.Expression) {
+    const hangingDeclaration = flags & ParseFunctionFlag.HangingDeclaration;
+    const isDeclaration = !!(flags & ParseFunctionFlag.Declaration);
+    const requireId = isDeclaration && !(flags & ParseFunctionFlag.NullableId);
+    const isAsync = !!(flags & ParseFunctionFlag.Async);
     this.initFunction(node, isAsync);
-    if (this.match(55) && isHangingStatement) {
-      this.raise(Errors.GeneratorInSingleStatementContext, {
-        at: this.state.startLoc
-      });
+    if (this.match(55)) {
+      if (hangingDeclaration) {
+        this.raise(Errors.GeneratorInSingleStatementContext, {
+          at: this.state.startLoc
+        });
+      }
+      this.next();
+      node.generator = true;
     }
-    node.generator = this.eat(55);
-    if (isStatement) {
+    if (isDeclaration) {
       node.id = this.parseFunctionId(requireId);
     }
     const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
     this.state.maybeInArrowParameters = false;
     this.scope.enter(SCOPE_FUNCTION);
     this.prodParam.enter(functionFlags(isAsync, node.generator));
-    if (!isStatement) {
+    if (!isDeclaration) {
       node.id = this.parseFunctionId();
     }
     this.parseFunctionParams(node, false);
 
     this.withSmartMixTopicForbiddingContext(() => {
-      this.parseFunctionBodyAndFinish(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
+      this.parseFunctionBodyAndFinish(node, isDeclaration ? "FunctionDeclaration" : "FunctionExpression");
     });
     this.prodParam.exit();
     this.scope.exit();
-    if (isStatement && !isHangingStatement) {
+    if (isDeclaration && !hangingDeclaration) {
       this.registerFunctionStatementId(node);
     }
     this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
@@ -14144,13 +14208,13 @@ class StatementParser extends ExpressionParser {
   }
   parseExportDefaultExpression() {
     const expr = this.startNode();
-    const isAsync = this.isAsyncFunction();
-    if (this.match(68) || isAsync) {
+    if (this.match(68)) {
       this.next();
-      if (isAsync) {
-        this.next();
-      }
-      return this.parseFunction(expr, FUNC_STATEMENT | FUNC_NULLABLE_ID, isAsync);
+      return this.parseFunction(expr, ParseFunctionFlag.Declaration | ParseFunctionFlag.NullableId);
+    } else if (this.isAsyncFunction()) {
+      this.next();
+      this.next();
+      return this.parseFunction(expr, ParseFunctionFlag.Declaration | ParseFunctionFlag.NullableId | ParseFunctionFlag.Async);
     }
     if (this.match(80)) {
       return this.parseClass(expr, true, true);
@@ -14172,13 +14236,14 @@ class StatementParser extends ExpressionParser {
     this.semicolon();
     return res;
   }
+
   parseExportDeclaration(
   node) {
     if (this.match(80)) {
       const node = this.parseClass(this.startNode(), true, false);
       return node;
     }
-    return this.parseStatement(null);
+    return this.parseStatementListItem();
   }
   isExportDefaultSpecifier() {
     const {
@@ -14431,8 +14496,9 @@ class StatementParser extends ExpressionParser {
     let isImportReflection = false;
     if (this.isContextual(125)) {
       const lookahead = this.lookahead();
-      if (tokenIsIdentifier(lookahead.type)) {
-        if (lookahead.type !== 97) {
+      const nextType = lookahead.type;
+      if (tokenIsIdentifier(nextType)) {
+        if (nextType !== 97) {
           isImportReflection = true;
         } else {
           const nextNextTokenFirstChar = this.input.charCodeAt(this.nextTokenStartSince(lookahead.end));
@@ -14440,7 +14506,7 @@ class StatementParser extends ExpressionParser {
             isImportReflection = true;
           }
         }
-      } else {
+      } else if (nextType !== 12) {
         isImportReflection = true;
       }
     }