vaderjs 1.1.3 → 1.1.4

package/website/node_modules/sucrase/dist/parser/plugins/jsx/index.js

@@ -1,367 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-
-
-
-
-
-
-
-var _index = require('../../tokenizer/index');
-var _types = require('../../tokenizer/types');
-var _base = require('../../traverser/base');
-var _expression = require('../../traverser/expression');
-var _util = require('../../traverser/util');
-var _charcodes = require('../../util/charcodes');
-var _identifier = require('../../util/identifier');
-var _typescript = require('../typescript');
-
-/**
- * Read token with JSX contents.
- *
- * In addition to detecting jsxTagStart and also regular tokens that might be
- * part of an expression, this code detects the start and end of text ranges
- * within JSX children. In order to properly count the number of children, we
- * distinguish jsxText from jsxEmptyText, which is a text range that simplifies
- * to the empty string after JSX whitespace trimming.
- *
- * It turns out that a JSX text range will simplify to the empty string if and
- * only if both of these conditions hold:
- * - The range consists entirely of whitespace characters (only counting space,
- *   tab, \r, and \n).
- * - The range has at least one newline.
- * This can be proven by analyzing any implementation of whitespace trimming,
- * e.g. formatJSXTextLiteral in Sucrase or cleanJSXElementLiteralChild in Babel.
- */
-function jsxReadToken() {
-  let sawNewline = false;
-  let sawNonWhitespace = false;
-  while (true) {
-    if (_base.state.pos >= _base.input.length) {
-      _util.unexpected.call(void 0, "Unterminated JSX contents");
-      return;
-    }
-
-    const ch = _base.input.charCodeAt(_base.state.pos);
-    if (ch === _charcodes.charCodes.lessThan || ch === _charcodes.charCodes.leftCurlyBrace) {
-      if (_base.state.pos === _base.state.start) {
-        if (ch === _charcodes.charCodes.lessThan) {
-          _base.state.pos++;
-          _index.finishToken.call(void 0, _types.TokenType.jsxTagStart);
-          return;
-        }
-        _index.getTokenFromCode.call(void 0, ch);
-        return;
-      }
-      if (sawNewline && !sawNonWhitespace) {
-        _index.finishToken.call(void 0, _types.TokenType.jsxEmptyText);
-      } else {
-        _index.finishToken.call(void 0, _types.TokenType.jsxText);
-      }
-      return;
-    }
-
-    // This is part of JSX text.
-    if (ch === _charcodes.charCodes.lineFeed) {
-      sawNewline = true;
-    } else if (ch !== _charcodes.charCodes.space && ch !== _charcodes.charCodes.carriageReturn && ch !== _charcodes.charCodes.tab) {
-      sawNonWhitespace = true;
-    }
-    _base.state.pos++;
-  }
-}
-
-function jsxReadString(quote) {
-  _base.state.pos++;
-  for (;;) {
-    if (_base.state.pos >= _base.input.length) {
-      _util.unexpected.call(void 0, "Unterminated string constant");
-      return;
-    }
-
-    const ch = _base.input.charCodeAt(_base.state.pos);
-    if (ch === quote) {
-      _base.state.pos++;
-      break;
-    }
-    _base.state.pos++;
-  }
-  _index.finishToken.call(void 0, _types.TokenType.string);
-}
-
-// Read a JSX identifier (valid tag or attribute name).
-//
-// Optimized version since JSX identifiers can't contain
-// escape characters and so can be read as single slice.
-// Also assumes that first character was already checked
-// by isIdentifierStart in readToken.
-
-function jsxReadWord() {
-  let ch;
-  do {
-    if (_base.state.pos > _base.input.length) {
-      _util.unexpected.call(void 0, "Unexpectedly reached the end of input.");
-      return;
-    }
-    ch = _base.input.charCodeAt(++_base.state.pos);
-  } while (_identifier.IS_IDENTIFIER_CHAR[ch] || ch === _charcodes.charCodes.dash);
-  _index.finishToken.call(void 0, _types.TokenType.jsxName);
-}
-
-// Parse next token as JSX identifier
-function jsxParseIdentifier() {
-  nextJSXTagToken();
-}
-
-// Parse namespaced identifier.
-function jsxParseNamespacedName(identifierRole) {
-  jsxParseIdentifier();
-  if (!_index.eat.call(void 0, _types.TokenType.colon)) {
-    // Plain identifier, so this is an access.
-    _base.state.tokens[_base.state.tokens.length - 1].identifierRole = identifierRole;
-    return;
-  }
-  // Process the second half of the namespaced name.
-  jsxParseIdentifier();
-}
-
-// Parses element name in any form - namespaced, member
-// or single identifier.
-function jsxParseElementName() {
-  const firstTokenIndex = _base.state.tokens.length;
-  jsxParseNamespacedName(_index.IdentifierRole.Access);
-  let hadDot = false;
-  while (_index.match.call(void 0, _types.TokenType.dot)) {
-    hadDot = true;
-    nextJSXTagToken();
-    jsxParseIdentifier();
-  }
-  // For tags like <div> with a lowercase letter and no dots, the name is
-  // actually *not* an identifier access, since it's referring to a built-in
-  // tag name. Remove the identifier role in this case so that it's not
-  // accidentally transformed by the imports transform when preserving JSX.
-  if (!hadDot) {
-    const firstToken = _base.state.tokens[firstTokenIndex];
-    const firstChar = _base.input.charCodeAt(firstToken.start);
-    if (firstChar >= _charcodes.charCodes.lowercaseA && firstChar <= _charcodes.charCodes.lowercaseZ) {
-      firstToken.identifierRole = null;
-    }
-  }
-}
-
-// Parses any type of JSX attribute value.
-function jsxParseAttributeValue() {
-  switch (_base.state.type) {
-    case _types.TokenType.braceL:
-      _index.next.call(void 0, );
-      _expression.parseExpression.call(void 0, );
-      nextJSXTagToken();
-      return;
-
-    case _types.TokenType.jsxTagStart:
-      jsxParseElement();
-      nextJSXTagToken();
-      return;
-
-    case _types.TokenType.string:
-      nextJSXTagToken();
-      return;
-
-    default:
-      _util.unexpected.call(void 0, "JSX value should be either an expression or a quoted JSX text");
-  }
-}
-
-// Parse JSX spread child, after already processing the {
-// Does not parse the closing }
-function jsxParseSpreadChild() {
-  _util.expect.call(void 0, _types.TokenType.ellipsis);
-  _expression.parseExpression.call(void 0, );
-}
-
-// Parses JSX opening tag starting after "<".
-// Returns true if the tag was self-closing.
-// Does not parse the last token.
-function jsxParseOpeningElement(initialTokenIndex) {
-  if (_index.match.call(void 0, _types.TokenType.jsxTagEnd)) {
-    // This is an open-fragment.
-    return false;
-  }
-  jsxParseElementName();
-  if (_base.isTypeScriptEnabled) {
-    _typescript.tsTryParseJSXTypeArgument.call(void 0, );
-  }
-  let hasSeenPropSpread = false;
-  while (!_index.match.call(void 0, _types.TokenType.slash) && !_index.match.call(void 0, _types.TokenType.jsxTagEnd) && !_base.state.error) {
-    if (_index.eat.call(void 0, _types.TokenType.braceL)) {
-      hasSeenPropSpread = true;
-      _util.expect.call(void 0, _types.TokenType.ellipsis);
-      _expression.parseMaybeAssign.call(void 0, );
-      // }
-      nextJSXTagToken();
-      continue;
-    }
-    if (
-      hasSeenPropSpread &&
-      _base.state.end - _base.state.start === 3 &&
-      _base.input.charCodeAt(_base.state.start) === _charcodes.charCodes.lowercaseK &&
-      _base.input.charCodeAt(_base.state.start + 1) === _charcodes.charCodes.lowercaseE &&
-      _base.input.charCodeAt(_base.state.start + 2) === _charcodes.charCodes.lowercaseY
-    ) {
-      _base.state.tokens[initialTokenIndex].jsxRole = _index.JSXRole.KeyAfterPropSpread;
-    }
-    jsxParseNamespacedName(_index.IdentifierRole.ObjectKey);
-    if (_index.match.call(void 0, _types.TokenType.eq)) {
-      nextJSXTagToken();
-      jsxParseAttributeValue();
-    }
-  }
-  const isSelfClosing = _index.match.call(void 0, _types.TokenType.slash);
-  if (isSelfClosing) {
-    // /
-    nextJSXTagToken();
-  }
-  return isSelfClosing;
-}
-
-// Parses JSX closing tag starting after "</".
-// Does not parse the last token.
-function jsxParseClosingElement() {
-  if (_index.match.call(void 0, _types.TokenType.jsxTagEnd)) {
-    // Fragment syntax, so we immediately have a tag end.
-    return;
-  }
-  jsxParseElementName();
-}
-
-// Parses entire JSX element, including its opening tag
-// (starting after "<"), attributes, contents and closing tag.
-// Does not parse the last token.
-function jsxParseElementAt() {
-  const initialTokenIndex = _base.state.tokens.length - 1;
-  _base.state.tokens[initialTokenIndex].jsxRole = _index.JSXRole.NoChildren;
-  let numExplicitChildren = 0;
-  const isSelfClosing = jsxParseOpeningElement(initialTokenIndex);
-  if (!isSelfClosing) {
-    nextJSXExprToken();
-    while (true) {
-      switch (_base.state.type) {
-        case _types.TokenType.jsxTagStart:
-          nextJSXTagToken();
-          if (_index.match.call(void 0, _types.TokenType.slash)) {
-            nextJSXTagToken();
-            jsxParseClosingElement();
-            // Key after prop spread takes precedence over number of children,
-            // since it means we switch to createElement, which doesn't care
-            // about number of children.
-            if (_base.state.tokens[initialTokenIndex].jsxRole !== _index.JSXRole.KeyAfterPropSpread) {
-              if (numExplicitChildren === 1) {
-                _base.state.tokens[initialTokenIndex].jsxRole = _index.JSXRole.OneChild;
-              } else if (numExplicitChildren > 1) {
-                _base.state.tokens[initialTokenIndex].jsxRole = _index.JSXRole.StaticChildren;
-              }
-            }
-            return;
-          }
-          numExplicitChildren++;
-          jsxParseElementAt();
-          nextJSXExprToken();
-          break;
-
-        case _types.TokenType.jsxText:
-          numExplicitChildren++;
-          nextJSXExprToken();
-          break;
-
-        case _types.TokenType.jsxEmptyText:
-          nextJSXExprToken();
-          break;
-
-        case _types.TokenType.braceL:
-          _index.next.call(void 0, );
-          if (_index.match.call(void 0, _types.TokenType.ellipsis)) {
-            jsxParseSpreadChild();
-            nextJSXExprToken();
-            // Spread children are a mechanism to explicitly mark children as
-            // static, so count it as 2 children to satisfy the "more than one
-            // child" condition.
-            numExplicitChildren += 2;
-          } else {
-            // If we see {}, this is an empty pseudo-expression that doesn't
-            // count as a child.
-            if (!_index.match.call(void 0, _types.TokenType.braceR)) {
-              numExplicitChildren++;
-              _expression.parseExpression.call(void 0, );
-            }
-            nextJSXExprToken();
-          }
-
-          break;
-
-        // istanbul ignore next - should never happen
-        default:
-          _util.unexpected.call(void 0, );
-          return;
-      }
-    }
-  }
-}
-
-// Parses entire JSX element from current position.
-// Does not parse the last token.
- function jsxParseElement() {
-  nextJSXTagToken();
-  jsxParseElementAt();
-} exports.jsxParseElement = jsxParseElement;
-
-// ==================================
-// Overrides
-// ==================================
-
- function nextJSXTagToken() {
-  _base.state.tokens.push(new (0, _index.Token)());
-  _index.skipSpace.call(void 0, );
-  _base.state.start = _base.state.pos;
-  const code = _base.input.charCodeAt(_base.state.pos);
-
-  if (_identifier.IS_IDENTIFIER_START[code]) {
-    jsxReadWord();
-  } else if (code === _charcodes.charCodes.quotationMark || code === _charcodes.charCodes.apostrophe) {
-    jsxReadString(code);
-  } else {
-    // The following tokens are just one character each.
-    ++_base.state.pos;
-    switch (code) {
-      case _charcodes.charCodes.greaterThan:
-        _index.finishToken.call(void 0, _types.TokenType.jsxTagEnd);
-        break;
-      case _charcodes.charCodes.lessThan:
-        _index.finishToken.call(void 0, _types.TokenType.jsxTagStart);
-        break;
-      case _charcodes.charCodes.slash:
-        _index.finishToken.call(void 0, _types.TokenType.slash);
-        break;
-      case _charcodes.charCodes.equalsTo:
-        _index.finishToken.call(void 0, _types.TokenType.eq);
-        break;
-      case _charcodes.charCodes.leftCurlyBrace:
-        _index.finishToken.call(void 0, _types.TokenType.braceL);
-        break;
-      case _charcodes.charCodes.dot:
-        _index.finishToken.call(void 0, _types.TokenType.dot);
-        break;
-      case _charcodes.charCodes.colon:
-        _index.finishToken.call(void 0, _types.TokenType.colon);
-        break;
-      default:
-        _util.unexpected.call(void 0, );
-    }
-  }
-} exports.nextJSXTagToken = nextJSXTagToken;
-
-function nextJSXExprToken() {
-  _base.state.tokens.push(new (0, _index.Token)());
-  _base.state.start = _base.state.pos;
-  jsxReadToken();
-}

package/website/node_modules/sucrase/dist/parser/plugins/jsx/xhtml.js

@@ -1,256 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// Use a Map rather than object to avoid unexpected __proto__ access.
-exports. default = new Map([
-  ["quot", "\u0022"],
-  ["amp", "&"],
-  ["apos", "\u0027"],
-  ["lt", "<"],
-  ["gt", ">"],
-  ["nbsp", "\u00A0"],
-  ["iexcl", "\u00A1"],
-  ["cent", "\u00A2"],
-  ["pound", "\u00A3"],
-  ["curren", "\u00A4"],
-  ["yen", "\u00A5"],
-  ["brvbar", "\u00A6"],
-  ["sect", "\u00A7"],
-  ["uml", "\u00A8"],
-  ["copy", "\u00A9"],
-  ["ordf", "\u00AA"],
-  ["laquo", "\u00AB"],
-  ["not", "\u00AC"],
-  ["shy", "\u00AD"],
-  ["reg", "\u00AE"],
-  ["macr", "\u00AF"],
-  ["deg", "\u00B0"],
-  ["plusmn", "\u00B1"],
-  ["sup2", "\u00B2"],
-  ["sup3", "\u00B3"],
-  ["acute", "\u00B4"],
-  ["micro", "\u00B5"],
-  ["para", "\u00B6"],
-  ["middot", "\u00B7"],
-  ["cedil", "\u00B8"],
-  ["sup1", "\u00B9"],
-  ["ordm", "\u00BA"],
-  ["raquo", "\u00BB"],
-  ["frac14", "\u00BC"],
-  ["frac12", "\u00BD"],
-  ["frac34", "\u00BE"],
-  ["iquest", "\u00BF"],
-  ["Agrave", "\u00C0"],
-  ["Aacute", "\u00C1"],
-  ["Acirc", "\u00C2"],
-  ["Atilde", "\u00C3"],
-  ["Auml", "\u00C4"],
-  ["Aring", "\u00C5"],
-  ["AElig", "\u00C6"],
-  ["Ccedil", "\u00C7"],
-  ["Egrave", "\u00C8"],
-  ["Eacute", "\u00C9"],
-  ["Ecirc", "\u00CA"],
-  ["Euml", "\u00CB"],
-  ["Igrave", "\u00CC"],
-  ["Iacute", "\u00CD"],
-  ["Icirc", "\u00CE"],
-  ["Iuml", "\u00CF"],
-  ["ETH", "\u00D0"],
-  ["Ntilde", "\u00D1"],
-  ["Ograve", "\u00D2"],
-  ["Oacute", "\u00D3"],
-  ["Ocirc", "\u00D4"],
-  ["Otilde", "\u00D5"],
-  ["Ouml", "\u00D6"],
-  ["times", "\u00D7"],
-  ["Oslash", "\u00D8"],
-  ["Ugrave", "\u00D9"],
-  ["Uacute", "\u00DA"],
-  ["Ucirc", "\u00DB"],
-  ["Uuml", "\u00DC"],
-  ["Yacute", "\u00DD"],
-  ["THORN", "\u00DE"],
-  ["szlig", "\u00DF"],
-  ["agrave", "\u00E0"],
-  ["aacute", "\u00E1"],
-  ["acirc", "\u00E2"],
-  ["atilde", "\u00E3"],
-  ["auml", "\u00E4"],
-  ["aring", "\u00E5"],
-  ["aelig", "\u00E6"],
-  ["ccedil", "\u00E7"],
-  ["egrave", "\u00E8"],
-  ["eacute", "\u00E9"],
-  ["ecirc", "\u00EA"],
-  ["euml", "\u00EB"],
-  ["igrave", "\u00EC"],
-  ["iacute", "\u00ED"],
-  ["icirc", "\u00EE"],
-  ["iuml", "\u00EF"],
-  ["eth", "\u00F0"],
-  ["ntilde", "\u00F1"],
-  ["ograve", "\u00F2"],
-  ["oacute", "\u00F3"],
-  ["ocirc", "\u00F4"],
-  ["otilde", "\u00F5"],
-  ["ouml", "\u00F6"],
-  ["divide", "\u00F7"],
-  ["oslash", "\u00F8"],
-  ["ugrave", "\u00F9"],
-  ["uacute", "\u00FA"],
-  ["ucirc", "\u00FB"],
-  ["uuml", "\u00FC"],
-  ["yacute", "\u00FD"],
-  ["thorn", "\u00FE"],
-  ["yuml", "\u00FF"],
-  ["OElig", "\u0152"],
-  ["oelig", "\u0153"],
-  ["Scaron", "\u0160"],
-  ["scaron", "\u0161"],
-  ["Yuml", "\u0178"],
-  ["fnof", "\u0192"],
-  ["circ", "\u02C6"],
-  ["tilde", "\u02DC"],
-  ["Alpha", "\u0391"],
-  ["Beta", "\u0392"],
-  ["Gamma", "\u0393"],
-  ["Delta", "\u0394"],
-  ["Epsilon", "\u0395"],
-  ["Zeta", "\u0396"],
-  ["Eta", "\u0397"],
-  ["Theta", "\u0398"],
-  ["Iota", "\u0399"],
-  ["Kappa", "\u039A"],
-  ["Lambda", "\u039B"],
-  ["Mu", "\u039C"],
-  ["Nu", "\u039D"],
-  ["Xi", "\u039E"],
-  ["Omicron", "\u039F"],
-  ["Pi", "\u03A0"],
-  ["Rho", "\u03A1"],
-  ["Sigma", "\u03A3"],
-  ["Tau", "\u03A4"],
-  ["Upsilon", "\u03A5"],
-  ["Phi", "\u03A6"],
-  ["Chi", "\u03A7"],
-  ["Psi", "\u03A8"],
-  ["Omega", "\u03A9"],
-  ["alpha", "\u03B1"],
-  ["beta", "\u03B2"],
-  ["gamma", "\u03B3"],
-  ["delta", "\u03B4"],
-  ["epsilon", "\u03B5"],
-  ["zeta", "\u03B6"],
-  ["eta", "\u03B7"],
-  ["theta", "\u03B8"],
-  ["iota", "\u03B9"],
-  ["kappa", "\u03BA"],
-  ["lambda", "\u03BB"],
-  ["mu", "\u03BC"],
-  ["nu", "\u03BD"],
-  ["xi", "\u03BE"],
-  ["omicron", "\u03BF"],
-  ["pi", "\u03C0"],
-  ["rho", "\u03C1"],
-  ["sigmaf", "\u03C2"],
-  ["sigma", "\u03C3"],
-  ["tau", "\u03C4"],
-  ["upsilon", "\u03C5"],
-  ["phi", "\u03C6"],
-  ["chi", "\u03C7"],
-  ["psi", "\u03C8"],
-  ["omega", "\u03C9"],
-  ["thetasym", "\u03D1"],
-  ["upsih", "\u03D2"],
-  ["piv", "\u03D6"],
-  ["ensp", "\u2002"],
-  ["emsp", "\u2003"],
-  ["thinsp", "\u2009"],
-  ["zwnj", "\u200C"],
-  ["zwj", "\u200D"],
-  ["lrm", "\u200E"],
-  ["rlm", "\u200F"],
-  ["ndash", "\u2013"],
-  ["mdash", "\u2014"],
-  ["lsquo", "\u2018"],
-  ["rsquo", "\u2019"],
-  ["sbquo", "\u201A"],
-  ["ldquo", "\u201C"],
-  ["rdquo", "\u201D"],
-  ["bdquo", "\u201E"],
-  ["dagger", "\u2020"],
-  ["Dagger", "\u2021"],
-  ["bull", "\u2022"],
-  ["hellip", "\u2026"],
-  ["permil", "\u2030"],
-  ["prime", "\u2032"],
-  ["Prime", "\u2033"],
-  ["lsaquo", "\u2039"],
-  ["rsaquo", "\u203A"],
-  ["oline", "\u203E"],
-  ["frasl", "\u2044"],
-  ["euro", "\u20AC"],
-  ["image", "\u2111"],
-  ["weierp", "\u2118"],
-  ["real", "\u211C"],
-  ["trade", "\u2122"],
-  ["alefsym", "\u2135"],
-  ["larr", "\u2190"],
-  ["uarr", "\u2191"],
-  ["rarr", "\u2192"],
-  ["darr", "\u2193"],
-  ["harr", "\u2194"],
-  ["crarr", "\u21B5"],
-  ["lArr", "\u21D0"],
-  ["uArr", "\u21D1"],
-  ["rArr", "\u21D2"],
-  ["dArr", "\u21D3"],
-  ["hArr", "\u21D4"],
-  ["forall", "\u2200"],
-  ["part", "\u2202"],
-  ["exist", "\u2203"],
-  ["empty", "\u2205"],
-  ["nabla", "\u2207"],
-  ["isin", "\u2208"],
-  ["notin", "\u2209"],
-  ["ni", "\u220B"],
-  ["prod", "\u220F"],
-  ["sum", "\u2211"],
-  ["minus", "\u2212"],
-  ["lowast", "\u2217"],
-  ["radic", "\u221A"],
-  ["prop", "\u221D"],
-  ["infin", "\u221E"],
-  ["ang", "\u2220"],
-  ["and", "\u2227"],
-  ["or", "\u2228"],
-  ["cap", "\u2229"],
-  ["cup", "\u222A"],
-  ["int", "\u222B"],
-  ["there4", "\u2234"],
-  ["sim", "\u223C"],
-  ["cong", "\u2245"],
-  ["asymp", "\u2248"],
-  ["ne", "\u2260"],
-  ["equiv", "\u2261"],
-  ["le", "\u2264"],
-  ["ge", "\u2265"],
-  ["sub", "\u2282"],
-  ["sup", "\u2283"],
-  ["nsub", "\u2284"],
-  ["sube", "\u2286"],
-  ["supe", "\u2287"],
-  ["oplus", "\u2295"],
-  ["otimes", "\u2297"],
-  ["perp", "\u22A5"],
-  ["sdot", "\u22C5"],
-  ["lceil", "\u2308"],
-  ["rceil", "\u2309"],
-  ["lfloor", "\u230A"],
-  ["rfloor", "\u230B"],
-  ["lang", "\u2329"],
-  ["rang", "\u232A"],
-  ["loz", "\u25CA"],
-  ["spades", "\u2660"],
-  ["clubs", "\u2663"],
-  ["hearts", "\u2665"],
-  ["diams", "\u2666"],
-]);

package/website/node_modules/sucrase/dist/parser/plugins/types.js

@@ -1,37 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _index = require('../tokenizer/index');
-var _types = require('../tokenizer/types');
-var _base = require('../traverser/base');
-var _expression = require('../traverser/expression');
-var _flow = require('./flow');
-var _typescript = require('./typescript');
-
-/**
- * Common parser code for TypeScript and Flow.
- */
-
-// An apparent conditional expression could actually be an optional parameter in an arrow function.
- function typedParseConditional(noIn) {
-  // If we see ?:, this can't possibly be a valid conditional. typedParseParenItem will be called
-  // later to finish off the arrow parameter. We also need to handle bare ? tokens for optional
-  // parameters without type annotations, i.e. ?, and ?) .
-  if (_index.match.call(void 0, _types.TokenType.question)) {
-    const nextType = _index.lookaheadType.call(void 0, );
-    if (nextType === _types.TokenType.colon || nextType === _types.TokenType.comma || nextType === _types.TokenType.parenR) {
-      return;
-    }
-  }
-  _expression.baseParseConditional.call(void 0, noIn);
-} exports.typedParseConditional = typedParseConditional;
-
-// Note: These "type casts" are *not* valid TS expressions.
-// But we parse them here and change them when completing the arrow function.
- function typedParseParenItem() {
-  _index.eatTypeToken.call(void 0, _types.TokenType.question);
-  if (_index.match.call(void 0, _types.TokenType.colon)) {
-    if (_base.isTypeScriptEnabled) {
-      _typescript.tsParseTypeAnnotation.call(void 0, );
-    } else if (_base.isFlowEnabled) {
-      _flow.flowParseTypeAnnotation.call(void 0, );
-    }
-  }
-} exports.typedParseParenItem = typedParseParenItem;