{"version":3,"sources":["jsdelivr-header.js","/npm/jshint@2.13.1/src/jshint.js"],"names":[],"mappings":"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","file":"/npm/jshint@2.13.1/src/jshint.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/jshint@2.13.1/src/jshint.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/*!\n * JSHint, by JSHint Community.\n *\n * Licensed under the MIT license.\n *\n * JSHint is a derivative work of JSLint:\n *\n *   Copyright (c) 2002 Douglas Crockford  (www.JSLint.com)\n *\n *   Permission is hereby granted, free of charge, to any person obtaining\n *   a copy of this software and associated documentation files (the \"Software\"),\n *   to deal in the Software without restriction, including without limitation\n *   the rights to use, copy, modify, merge, publish, distribute, sublicense,\n *   and/or sell copies of the Software, and to permit persons to whom\n *   the Software is furnished to do so, subject to the following conditions:\n *\n *   The above copyright notice and this permission notice shall be included\n *   in all copies or substantial portions of the Software.\n *\n *   THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n *   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n *   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n *   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n *   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n *   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n *   DEALINGS IN THE SOFTWARE.\n *\n */\n\n/*jshint quotmark:double */\n/*exported console */\n\nvar _            = require(\"lodash\");\nvar events       = require(\"events\");\nvar vars         = require(\"./vars.js\");\nvar messages     = require(\"./messages.js\");\nvar Lexer        = require(\"./lex.js\").Lexer;\nvar reg          = require(\"./reg.js\");\nvar state        = require(\"./state.js\").state;\nvar style        = require(\"./style.js\");\nvar options      = require(\"./options.js\");\nvar scopeManager = require(\"./scope-manager.js\");\nvar prodParams   = require(\"./prod-params.js\");\n\n// We need this module here because environments such as IE and Rhino\n// don't necessarilly expose the 'console' API and browserify uses\n// it to log things. It's a sad state of affair, really.\nvar console = require(\"console-browserify\");\n\n// We build the application inside a function so that we produce only a singleton\n// variable. That function will be invoked immediately, and its return value is\n// the JSHINT function itself.\n\nvar JSHINT = (function() {\n  \"use strict\";\n\n  var api, // Extension API\n\n    // These are operators that should not be used with the ! operator.\n    bang = {\n      \"<\"  : true,\n      \"<=\" : true,\n      \"==\" : true,\n      \"===\": true,\n      \"!==\": true,\n      \"!=\" : true,\n      \">\"  : true,\n      \">=\" : true,\n      \"+\"  : true,\n      \"-\"  : true,\n      \"*\"  : true,\n      \"/\"  : true,\n      \"%\"  : true\n    },\n\n    declared, // Globals that were declared using /*global ... */ syntax.\n\n    functions, // All of the functions\n\n    inblock,\n    indent,\n    lookahead,\n    lex,\n    member,\n    membersOnly,\n    predefined,    // Global variables defined by option\n\n    extraModules = [],\n    emitter = new events.EventEmitter();\n\n  function checkOption(name, isStable, t) {\n    var type, validNames;\n\n    if (isStable) {\n      type = \"\";\n      validNames = options.validNames;\n    } else {\n      type = \"unstable \";\n      validNames = options.unstableNames;\n    }\n\n    name = name.trim();\n\n    if (/^[+-]W\\d{3}$/g.test(name)) {\n      return true;\n    }\n\n    if (validNames.indexOf(name) === -1) {\n      if (t.type !== \"jslint\" && !_.has(options.removed, name)) {\n        error(\"E001\", t, type, name);\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  function isString(obj) {\n    return Object.prototype.toString.call(obj) === \"[object String]\";\n  }\n\n  function isIdentifier(tkn, value) {\n    if (!tkn)\n      return false;\n\n    if (!tkn.identifier || tkn.value !== value)\n      return false;\n\n    return true;\n  }\n\n  /**\n   * ES3 defined a set of \"FutureReservedWords\" in order \"to allow for the\n   * possibility of future adoption of [proposed] extensions.\"\n   *\n   * ES5 reduced the set of FutureReservedWords, in some cases by using them to\n   * define new syntactic forms (e.g. `class` and `const`) and in other cases\n   * by simply allowing their use as Identifiers (e.g. `int` and `goto`).\n   * Separately, ES5 introduced new restrictions on certain tokens, but limited\n   * the restriction to strict mode code (e.g. `let` and `yield`).\n   *\n   * This function determines if a given token describes a reserved word\n   * according to the current state of the parser.\n   *\n   * @param {number} context - the parsing context; see `prod-params.js` for\n   *                           more information\n   * @param {Token} token\n   */\n  function isReserved(context, token) {\n    if (!token.reserved) {\n      return false;\n    }\n    var meta = token.meta;\n\n    if (meta && meta.isFutureReservedWord) {\n      if (state.inES5()) {\n        // ES3 FutureReservedWord in an ES5 environment.\n        if (!meta.es5) {\n          return false;\n        }\n\n        if (token.isProperty) {\n          return false;\n        }\n      }\n    } else if (meta && meta.es5 && !state.inES5()) {\n      return false;\n    }\n\n    // Some identifiers are reserved only within a strict mode environment.\n    if (meta && meta.strictOnly && state.inES5()) {\n      if (!state.option.strict && !state.isStrict()) {\n        return false;\n      }\n    }\n\n    if (token.id === \"await\" && (!(context & prodParams.async) && !state.option.module)) {\n      return false;\n    }\n\n    if (token.id === \"yield\" && (!(context & prodParams.yield))) {\n      return state.isStrict();\n    }\n\n    return true;\n  }\n\n  function supplant(str, data) {\n    return str.replace(/\\{([^{}]*)\\}/g, function(a, b) {\n      var r = data[b];\n      return typeof r === \"string\" || typeof r === \"number\" ? r : a;\n    });\n  }\n\n  function combine(dest, src) {\n    Object.keys(src).forEach(function(name) {\n      if (_.has(JSHINT.blacklist, name)) return;\n      dest[name] = src[name];\n    });\n  }\n\n  function processenforceall() {\n    if (state.option.enforceall) {\n      for (var enforceopt in options.bool.enforcing) {\n        if (state.option[enforceopt] === undefined &&\n            !options.noenforceall[enforceopt]) {\n          state.option[enforceopt] = true;\n        }\n      }\n      for (var relaxopt in options.bool.relaxing) {\n        if (state.option[relaxopt] === undefined) {\n          state.option[relaxopt] = false;\n        }\n      }\n    }\n  }\n\n  /**\n   * Apply all linting options according to the status of the `state` object.\n   */\n  function applyOptions() {\n    var badESOpt = null;\n    processenforceall();\n\n    /**\n     * TODO: Remove in JSHint 3\n     */\n    badESOpt = state.inferEsVersion();\n    if (badESOpt) {\n      quit(\"E059\", state.tokens.next, \"esversion\", badESOpt);\n    }\n\n    if (state.inES5()) {\n      combine(predefined, vars.ecmaIdentifiers[5]);\n    }\n\n    if (state.inES6()) {\n      combine(predefined, vars.ecmaIdentifiers[6]);\n    }\n\n    if (state.inES8()) {\n      combine(predefined, vars.ecmaIdentifiers[8]);\n    }\n\n    /**\n     * Use `in` to check for the presence of any explicitly-specified value for\n     * `globalstrict` because both `true` and `false` should trigger an error.\n     */\n    if (state.option.strict === \"global\" && \"globalstrict\" in state.option) {\n      quit(\"E059\", state.tokens.next, \"strict\", \"globalstrict\");\n    }\n\n    if (state.option.module) {\n      /**\n       * TODO: Extend this restriction to *all* ES6-specific options.\n       */\n      if (!state.inES6()) {\n        warning(\"W134\", state.tokens.next, \"module\", 6);\n      }\n    }\n\n    if (state.option.regexpu) {\n      /**\n       * TODO: Extend this restriction to *all* ES6-specific options.\n       */\n      if (!state.inES6()) {\n        warning(\"W134\", state.tokens.next, \"regexpu\", 6);\n      }\n    }\n\n    if (state.option.couch) {\n      combine(predefined, vars.couch);\n    }\n\n    if (state.option.qunit) {\n      combine(predefined, vars.qunit);\n    }\n\n    if (state.option.rhino) {\n      combine(predefined, vars.rhino);\n    }\n\n    if (state.option.shelljs) {\n      combine(predefined, vars.shelljs);\n      combine(predefined, vars.node);\n    }\n    if (state.option.typed) {\n      combine(predefined, vars.typed);\n    }\n\n    if (state.option.phantom) {\n      combine(predefined, vars.phantom);\n    }\n\n    if (state.option.prototypejs) {\n      combine(predefined, vars.prototypejs);\n    }\n\n    if (state.option.node) {\n      combine(predefined, vars.node);\n      combine(predefined, vars.typed);\n    }\n\n    if (state.option.devel) {\n      combine(predefined, vars.devel);\n    }\n\n    if (state.option.dojo) {\n      combine(predefined, vars.dojo);\n    }\n\n    if (state.option.browser) {\n      combine(predefined, vars.browser);\n      combine(predefined, vars.typed);\n    }\n\n    if (state.option.browserify) {\n      combine(predefined, vars.browser);\n      combine(predefined, vars.typed);\n      combine(predefined, vars.browserify);\n    }\n\n    if (state.option.nonstandard) {\n      combine(predefined, vars.nonstandard);\n    }\n\n    if (state.option.jasmine) {\n      combine(predefined, vars.jasmine);\n    }\n\n    if (state.option.jquery) {\n      combine(predefined, vars.jquery);\n    }\n\n    if (state.option.mootools) {\n      combine(predefined, vars.mootools);\n    }\n\n    if (state.option.worker) {\n      combine(predefined, vars.worker);\n    }\n\n    if (state.option.wsh) {\n      combine(predefined, vars.wsh);\n    }\n\n    if (state.option.yui) {\n      combine(predefined, vars.yui);\n    }\n\n    if (state.option.mocha) {\n      combine(predefined, vars.mocha);\n    }\n  }\n\n  // Produce an error warning.\n  function quit(code, token, a, b) {\n    var percentage = Math.floor((token.line / state.lines.length) * 100);\n    var message = messages.errors[code].desc;\n\n    var exception = {\n      name: \"JSHintError\",\n      line: token.line,\n      character: token.from,\n      message: message + \" (\" + percentage + \"% scanned).\",\n      raw: message,\n      code: code,\n      a: a,\n      b: b\n    };\n\n    exception.reason = supplant(message, exception) + \" (\" + percentage +\n      \"% scanned).\";\n\n    throw exception;\n  }\n\n  function removeIgnoredMessages() {\n    var ignored = state.ignoredLines;\n\n    if (_.isEmpty(ignored)) return;\n    JSHINT.errors = _.reject(JSHINT.errors, function(err) { return ignored[err.line] });\n  }\n\n  function warning(code, t, a, b, c, d) {\n    var ch, l, w, msg;\n\n    if (/^W\\d{3}$/.test(code)) {\n      if (state.ignored[code])\n        return;\n\n      msg = messages.warnings[code];\n    } else if (/E\\d{3}/.test(code)) {\n      msg = messages.errors[code];\n    } else if (/I\\d{3}/.test(code)) {\n      msg = messages.info[code];\n    }\n\n    t = t || state.tokens.next || {};\n    if (t.id === \"(end)\") {  // `~\n      t = state.tokens.curr;\n    }\n\n    l = t.line;\n    ch = t.from;\n\n    w = {\n      id: \"(error)\",\n      raw: msg.desc,\n      code: msg.code,\n      evidence: state.lines[l - 1] || \"\",\n      line: l,\n      character: ch,\n      scope: JSHINT.scope,\n      a: a,\n      b: b,\n      c: c,\n      d: d\n    };\n\n    w.reason = supplant(msg.desc, w);\n    JSHINT.errors.push(w);\n\n    removeIgnoredMessages();\n\n    if (JSHINT.errors.length >= state.option.maxerr)\n      quit(\"E043\", t);\n\n    return w;\n  }\n\n  function warningAt(m, l, ch, a, b, c, d) {\n    return warning(m, {\n      line: l,\n      from: ch\n    }, a, b, c, d);\n  }\n\n  function error(m, t, a, b, c, d) {\n    warning(m, t, a, b, c, d);\n  }\n\n  function errorAt(m, l, ch, a, b, c, d) {\n    return error(m, {\n      line: l,\n      from: ch\n    }, a, b, c, d);\n  }\n\n  // Tracking of \"internal\" scripts, like eval containing a static string\n  function addEvalCode(elem, token) {\n    JSHINT.internals.push({\n      id: \"(internal)\",\n      elem: elem,\n      token: token,\n      code: token.value.replace(/([^\\\\])(\\\\*)\\2\\\\n/g, \"$1\\n\")\n    });\n  }\n\n  /**\n   * Process an inline linting directive\n   *\n   * @param {Token} directiveToken - the directive-bearing comment token\n   * @param {Token} previous - the token that preceeds the directive\n   */\n  function lintingDirective(directiveToken, previous) {\n    var body = directiveToken.body.split(\",\")\n      .map(function(s) { return s.trim(); });\n    var predef = {};\n\n    if (directiveToken.type === \"falls through\") {\n      previous.caseFallsThrough = true;\n      return;\n    }\n\n    if (directiveToken.type === \"globals\") {\n      body.forEach(function(item, idx) {\n        var parts = item.split(\":\");\n        var key = parts[0].trim();\n\n        if (key === \"-\" || !key.length) {\n          // Ignore trailing comma\n          if (idx > 0 && idx === body.length - 1) {\n            return;\n          }\n          error(\"E002\", directiveToken);\n          return;\n        }\n\n        if (key.charAt(0) === \"-\") {\n          key = key.slice(1);\n\n          JSHINT.blacklist[key] = key;\n          delete predefined[key];\n        } else {\n          predef[key] = parts.length > 1 && parts[1].trim() === \"true\";\n        }\n      });\n\n      combine(predefined, predef);\n\n      for (var key in predef) {\n        if (_.has(predef, key)) {\n          declared[key] = directiveToken;\n        }\n      }\n    }\n\n    if (directiveToken.type === \"exported\") {\n      body.forEach(function(e, idx) {\n        if (!e.length) {\n          // Ignore trailing comma\n          if (idx > 0 && idx === body.length - 1) {\n            return;\n          }\n          error(\"E002\", directiveToken);\n          return;\n        }\n\n        state.funct[\"(scope)\"].addExported(e);\n      });\n    }\n\n    if (directiveToken.type === \"members\") {\n      membersOnly = membersOnly || {};\n\n      body.forEach(function(m) {\n        var ch1 = m.charAt(0);\n        var ch2 = m.charAt(m.length - 1);\n\n        if (ch1 === ch2 && (ch1 === \"\\\"\" || ch1 === \"'\")) {\n          m = m\n            .substr(1, m.length - 2)\n            .replace(\"\\\\\\\"\", \"\\\"\");\n        }\n\n        membersOnly[m] = false;\n      });\n    }\n\n    var numvals = [\n      \"maxstatements\",\n      \"maxparams\",\n      \"maxdepth\",\n      \"maxcomplexity\",\n      \"maxerr\",\n      \"maxlen\",\n      \"indent\"\n    ];\n\n    if (directiveToken.type === \"jshint\" || directiveToken.type === \"jslint\" ||\n      directiveToken.type === \"jshint.unstable\") {\n      body.forEach(function(item) {\n        var parts = item.split(\":\");\n        var key = parts[0].trim();\n        var val = parts.length > 1 ? parts[1].trim() : \"\";\n        var numberVal;\n\n        if (!checkOption(key, directiveToken.type !== \"jshint.unstable\", directiveToken)) {\n          return;\n        }\n\n        if (numvals.indexOf(key) >= 0) {\n          // GH988 - numeric options can be disabled by setting them to `false`\n          if (val !== \"false\") {\n            numberVal = +val;\n\n            if (typeof numberVal !== \"number\" || !isFinite(numberVal) ||\n              numberVal <= 0 || Math.floor(numberVal) !== numberVal) {\n              error(\"E032\", directiveToken, val);\n              return;\n            }\n\n            state.option[key] = numberVal;\n          } else {\n            state.option[key] = key === \"indent\" ? 4 : false;\n          }\n\n          return;\n        }\n\n        if (key === \"validthis\") {\n          // `validthis` is valid only within a function scope.\n\n          if (state.funct[\"(global)\"])\n            return void error(\"E009\");\n\n          if (val !== \"true\" && val !== \"false\")\n            return void error(\"E002\", directiveToken);\n\n          state.option.validthis = (val === \"true\");\n          return;\n        }\n\n        if (key === \"quotmark\") {\n          switch (val) {\n          case \"true\":\n          case \"false\":\n            state.option.quotmark = (val === \"true\");\n            break;\n          case \"double\":\n          case \"single\":\n            state.option.quotmark = val;\n            break;\n          default:\n            error(\"E002\", directiveToken);\n          }\n          return;\n        }\n\n        if (key === \"shadow\") {\n          switch (val) {\n          case \"true\":\n            state.option.shadow = true;\n            break;\n          case \"outer\":\n            state.option.shadow = \"outer\";\n            break;\n          case \"false\":\n          case \"inner\":\n            state.option.shadow = \"inner\";\n            break;\n          default:\n            error(\"E002\", directiveToken);\n          }\n          return;\n        }\n\n        if (key === \"unused\") {\n          switch (val) {\n          case \"true\":\n            state.option.unused = true;\n            break;\n          case \"false\":\n            state.option.unused = false;\n            break;\n          case \"vars\":\n          case \"strict\":\n            state.option.unused = val;\n            break;\n          default:\n            error(\"E002\", directiveToken);\n          }\n          return;\n        }\n\n        if (key === \"latedef\") {\n          switch (val) {\n          case \"true\":\n            state.option.latedef = true;\n            break;\n          case \"false\":\n            state.option.latedef = false;\n            break;\n          case \"nofunc\":\n            state.option.latedef = \"nofunc\";\n            break;\n          default:\n            error(\"E002\", directiveToken);\n          }\n          return;\n        }\n\n        if (key === \"ignore\") {\n          switch (val) {\n          case \"line\":\n            state.ignoredLines[directiveToken.line] = true;\n            removeIgnoredMessages();\n            break;\n          default:\n            error(\"E002\", directiveToken);\n          }\n          return;\n        }\n\n        if (key === \"strict\") {\n          switch (val) {\n          case \"true\":\n            state.option.strict = true;\n            break;\n          case \"false\":\n            state.option.strict = false;\n            break;\n          case \"global\":\n          case \"implied\":\n            state.option.strict = val;\n            break;\n          default:\n            error(\"E002\", directiveToken);\n          }\n          return;\n        }\n\n        if (key === \"module\") {\n          /**\n           * TODO: Extend this restriction to *all* \"environmental\" options.\n           */\n          if (!hasParsedCode(state.funct)) {\n            error(\"E055\", directiveToken, \"module\");\n          }\n        }\n\n        if (key === \"esversion\") {\n          switch (val) {\n          case \"3\":\n          case \"5\":\n          case \"6\":\n          case \"7\":\n          case \"8\":\n          case \"9\":\n          case \"10\":\n          case \"11\":\n            state.option.moz = false;\n            state.option.esversion = +val;\n            break;\n          case \"2015\":\n          case \"2016\":\n          case \"2017\":\n          case \"2018\":\n          case \"2019\":\n          case \"2020\":\n            state.option.moz = false;\n            // Translate specification publication year to version number.\n            state.option.esversion = +val - 2009;\n            break;\n          default:\n            error(\"E002\", directiveToken);\n          }\n          if (!hasParsedCode(state.funct)) {\n            error(\"E055\", directiveToken, \"esversion\");\n          }\n          return;\n        }\n\n        var match = /^([+-])(W\\d{3})$/g.exec(key);\n        if (match) {\n          // ignore for -W..., unignore for +W...\n          state.ignored[match[2]] = (match[1] === \"-\");\n          return;\n        }\n\n        var tn;\n        if (val === \"true\" || val === \"false\") {\n          if (directiveToken.type === \"jslint\") {\n            tn = options.renamed[key] || key;\n            state.option[tn] = (val === \"true\");\n\n            if (options.inverted[tn] !== undefined) {\n              state.option[tn] = !state.option[tn];\n            }\n          } else if (directiveToken.type === \"jshint.unstable\") {\n            /* istanbul ignore next */\n            state.option.unstable[key] = (val === \"true\");\n          } else {\n            state.option[key] = (val === \"true\");\n          }\n\n          return;\n        }\n\n        error(\"E002\", directiveToken);\n      });\n\n      applyOptions();\n    }\n  }\n\n  /**\n   * Return a token beyond the token available in `state.tokens.next`. If no\n   * such token exists, return the \"(end)\" token. This function is used to\n   * determine parsing strategies in cases where the value of the next token\n   * does not provide sufficient information, as is the case with `for` loops,\n   * e.g.:\n   *\n   *     for ( var i in ...\n   *\n   * versus:\n   *\n   *     for ( var i = ...\n   *\n   * @param {number} [p] - offset of desired token; defaults to 0\n   *\n   * @returns {token}\n   */\n  function peek(p) {\n    var i = p || 0, j = lookahead.length, t;\n\n    if (i < j) {\n      return lookahead[i];\n    }\n\n    while (j <= i) {\n      t = lex.token();\n\n      // When the lexer is exhausted, this function should produce the \"(end)\"\n      // token, even in cases where the requested token is beyond the end of\n      // the input stream.\n      if (!t) {\n        // If the lookahead buffer is empty, the expected \"(end)\" token was\n        // already emitted by the most recent invocation of `advance` and is\n        // available as the next token.\n        if (!lookahead.length) {\n          return state.tokens.next;\n        }\n\n        return lookahead[j - 1];\n      }\n\n      lookahead[j] = t;\n      j += 1;\n    }\n\n    return t;\n  }\n\n  function peekIgnoreEOL() {\n    var i = 0;\n    var t;\n    do {\n      t = peek(i++);\n    } while (t.id === \"(endline)\");\n    return t;\n  }\n\n  /**\n   * Consume the next token.\n   *\n   * @param {string} [expected] - the expected value of the next token's `id`\n   *                              property (in the case of punctuators) or\n   *                              `value` property (in the case of identifiers\n   *                              and literals); if unspecified, any token will\n   *                              be accepted\n   * @param {object} [relatedToken] - the token that informed the expected\n   *                                  value, if any (for example: the opening\n   *                                  brace when a closing brace is expected);\n   *                                  used to produce more meaningful errors\n   */\n  function advance(expected, relatedToken) {\n    var nextToken = state.tokens.next;\n\n    if (expected && nextToken.id !== expected) {\n      if (relatedToken) {\n        if (nextToken.id === \"(end)\") {\n          error(\"E019\", relatedToken, relatedToken.id);\n        } else {\n          error(\"E020\", nextToken, expected, relatedToken.id,\n            relatedToken.line, nextToken.value);\n        }\n      } else if (nextToken.type !== \"(identifier)\" || nextToken.value !== expected) {\n        error(\"E021\", nextToken, expected, nextToken.value);\n      }\n    }\n\n    state.tokens.prev = state.tokens.curr;\n    state.tokens.curr = state.tokens.next;\n    for (;;) {\n      state.tokens.next = lookahead.shift() || lex.token();\n\n      if (!state.tokens.next) { // No more tokens left, give up\n        quit(\"E041\", state.tokens.curr);\n      }\n\n      if (state.tokens.next.id === \"(end)\" || state.tokens.next.id === \"(error)\") {\n        return;\n      }\n\n      if (state.tokens.next.check) {\n        state.tokens.next.check();\n      }\n\n      if (state.tokens.next.isSpecial) {\n        lintingDirective(state.tokens.next, state.tokens.curr);\n      } else {\n        if (state.tokens.next.id !== \"(endline)\") {\n          break;\n        }\n      }\n    }\n  }\n\n  /**\n   * Determine whether a given token is an operator.\n   *\n   * @param {token} token\n   *\n   * @returns {boolean}\n   */\n  function isOperator(token) {\n    return token.first || token.right || token.left || token.id === \"yield\" || token.id === \"await\";\n  }\n\n  function isEndOfExpr(context, curr, next) {\n    if (arguments.length <= 1) {\n      curr = state.tokens.curr;\n      next = state.tokens.next;\n    }\n\n    if (next.id === \"in\" && context & prodParams.noin) {\n      return true;\n    }\n\n    if (next.id === \";\" || next.id === \"}\" || next.id === \":\") {\n      return true;\n    }\n\n    if (next.infix === curr.infix ||\n      // Infix operators which follow `yield` should only be consumed as part\n      // of the current expression if allowed by the syntactic grammar. In\n      // effect, this prevents automatic semicolon insertion when `yield` is\n      // followed by a newline and a comma operator (without enabling it when\n      // `yield` is followed by a newline and a `[` token).\n      (curr.id === \"yield\" && curr.rbp < next.rbp)) {\n      return !sameLine(curr, next);\n    }\n\n    return false;\n  }\n\n  /**\n   * The `expression` function is the heart of JSHint's parsing behaior. It is\n   * based on the Pratt parser, but it extends that model with a `fud` method.\n   * Short for \"first null denotation,\" it it similar to the `nud` (\"null\n   * denotation\") function, but it is only used on the first token of a\n   * statement. This simplifies usage in statement-oriented languages like\n   * JavaScript.\n   *\n   * .nud  Null denotation\n   * .fud  First null denotation\n   * .led  Left denotation\n   *  lbp  Left binding power\n   *  rbp  Right binding power\n   *\n   * They are elements of the parsing method called Top Down Operator Precedence.\n   *\n   * In addition to parsing, this function applies a number of linting patterns.\n   *\n   * @param {number} context - the parsing context (a bitfield describing\n   *                           conditions of the current parsing operation\n   *                           which can influence how the next tokens are\n   *                           interpreted); see `prod-params.js` for more\n   *                           detail)\n   * @param {number} rbp - the right-binding power of the token to be consumed\n   */\n  function expression(context, rbp) {\n    var left, isArray = false, isObject = false;\n    var initial = context & prodParams.initial;\n    var curr;\n\n    context &= ~prodParams.initial;\n\n    state.nameStack.push();\n\n    if (state.tokens.next.id === \"(end)\")\n      error(\"E006\", state.tokens.curr);\n\n    advance();\n\n    if (initial) {\n      state.funct[\"(verb)\"] = state.tokens.curr.value;\n      state.tokens.curr.beginsStmt = true;\n    }\n\n    curr = state.tokens.curr;\n\n    if (initial && curr.fud && (!curr.useFud || curr.useFud(context))) {\n      left = state.tokens.curr.fud(context);\n    } else {\n      if (state.tokens.curr.nud) {\n        left = state.tokens.curr.nud(context, rbp);\n      } else {\n        error(\"E030\", state.tokens.curr, state.tokens.curr.id);\n      }\n\n      while (rbp < state.tokens.next.lbp && !isEndOfExpr(context)) {\n        isArray = state.tokens.curr.value === \"Array\";\n        isObject = state.tokens.curr.value === \"Object\";\n\n        // #527, new Foo.Array(), Foo.Array(), new Foo.Object(), Foo.Object()\n        // Line breaks in IfStatement heads exist to satisfy the checkJSHint\n        // \"Line too long.\" error.\n        if (left && (left.value || (left.first && left.first.value))) {\n          // If the left.value is not \"new\", or the left.first.value is a \".\"\n          // then safely assume that this is not \"new Array()\" and possibly\n          // not \"new Object()\"...\n          if (left.value !== \"new\" ||\n            (left.first && left.first.value && left.first.value === \".\")) {\n            isArray = false;\n            // ...In the case of Object, if the left.value and state.tokens.curr.value\n            // are not equal, then safely assume that this not \"new Object()\"\n            if (left.value !== state.tokens.curr.value) {\n              isObject = false;\n            }\n          }\n        }\n\n        advance();\n\n        if (isArray && state.tokens.curr.id === \"(\" && state.tokens.next.id === \")\") {\n          warning(\"W009\", state.tokens.curr);\n        }\n\n        if (isObject && state.tokens.curr.id === \"(\" && state.tokens.next.id === \")\") {\n          warning(\"W010\", state.tokens.curr);\n        }\n\n        if (left && state.tokens.curr.led) {\n          left = state.tokens.curr.led(context, left);\n        } else {\n          error(\"E033\", state.tokens.curr, state.tokens.curr.id);\n        }\n      }\n    }\n\n    state.nameStack.pop();\n\n    return left;\n  }\n\n\n  // Functions for conformance of style.\n\n  function sameLine(first, second) {\n    return first.line === (second.startLine || second.line);\n  }\n\n  function nobreaknonadjacent(left, right) {\n    if (!state.option.laxbreak && !sameLine(left, right)) {\n      warning(\"W014\", right, right.value);\n    }\n  }\n\n  function nolinebreak(t) {\n    if (!sameLine(t, state.tokens.next)) {\n      warning(\"E022\", t, t.value);\n    }\n  }\n\n  /**\n   * Validate the comma token in the \"current\" position of the token stream.\n   *\n   * @param {object} [opts]\n   * @param {boolean} [opts.property] - flag indicating whether the current\n   *                                    comma token is situated directly within\n   *                                    an object initializer\n   * @param {boolean} [opts.allowTrailing] - flag indicating whether the\n   *                                         current comma token may appear\n   *                                         directly before a delimiter\n   *\n   * @returns {boolean} flag indicating the validity of the current comma\n   *                    token; `false` if the token directly causes a syntax\n   *                    error, `true` otherwise\n   */\n  function checkComma(opts) {\n    var prev = state.tokens.prev;\n    var curr = state.tokens.curr;\n    opts = opts || {};\n\n    if (!sameLine(prev, curr)) {\n      if (!state.option.laxcomma) {\n        if (checkComma.first) {\n          warning(\"I001\", curr);\n          checkComma.first = false;\n        }\n        warning(\"W014\", prev, curr.value);\n      }\n    }\n\n    if (state.tokens.next.identifier && !(opts.property && state.inES5())) {\n      // Keywords that cannot follow a comma operator.\n      switch (state.tokens.next.value) {\n      case \"break\":\n      case \"case\":\n      case \"catch\":\n      case \"continue\":\n      case \"default\":\n      case \"do\":\n      case \"else\":\n      case \"finally\":\n      case \"for\":\n      case \"if\":\n      case \"in\":\n      case \"instanceof\":\n      case \"return\":\n      case \"switch\":\n      case \"throw\":\n      case \"try\":\n      case \"var\":\n      case \"let\":\n      case \"while\":\n      case \"with\":\n        error(\"E024\", state.tokens.next, state.tokens.next.value);\n        return false;\n      }\n    }\n\n    if (state.tokens.next.type === \"(punctuator)\") {\n      switch (state.tokens.next.value) {\n      case \"}\":\n      case \"]\":\n      case \",\":\n      case \")\":\n        if (opts.allowTrailing) {\n          return true;\n        }\n\n        error(\"E024\", state.tokens.next, state.tokens.next.value);\n        return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * Factory function for creating \"symbols\"--objects that will be inherited by\n   * tokens. The objects created by this function are stored in a symbol table\n   * and set as the prototype of the tokens generated by the lexer.\n   *\n   * Note that this definition of \"symbol\" describes an implementation detail\n   * of JSHint and is not related to the ECMAScript value type introduced in\n   * ES2015.\n   *\n   * @param {string} s - the name of the token; for keywords (e.g. `void`) and\n   *                     delimiters (e.g.. `[`), this is the token's text\n   *                     representation; for literals (e.g. numbers) and other\n   *                     \"special\" tokens (e.g. the end-of-file marker) this is\n   *                     a parenthetical value\n   * @param {number} p - the left-binding power of the token as used by the\n   *                     Pratt parsing semantics\n   *\n   * @returns {object} - the object describing the JSHint symbol (provided to\n   *                     support cases where further refinement is necessary)\n   */\n  function symbol(s, p) {\n    var x = state.syntax[s];\n    if (!x || typeof x !== \"object\") {\n      state.syntax[s] = x = {\n        id: s,\n        lbp: p,\n        // Symbols that accept a right-hand side do so with a binding power\n        // that is commonly identical to their left-binding power. (This value\n        // is relevant when determining if the grouping operator is necessary\n        // to override the precedence of surrounding operators.) Because the\n        // exponentiation operator's left-binding power and right-binding power\n        // are distinct, the values must be encoded separately.\n        rbp: p,\n        value: s\n      };\n    }\n    return x;\n  }\n\n  /**\n   * Convenience function for defining delimiter symbols.\n   *\n   * @param {string} s - the name of the symbol\n   *\n   * @returns {object} - the object describing the JSHint symbol (provided to\n   *                     support cases where further refinement is necessary)\n   */\n  function delim(s) {\n    var x = symbol(s, 0);\n    x.delim = true;\n    return x;\n  }\n\n  /**\n   * Convenience function for defining statement-denoting symbols.\n   *\n   * @param {string} s - the name of the symbol\n   * @param {function} f - the first null denotation function for the symbol;\n   *                       see the `expression` function for more detail\n   *\n   * @returns {object} - the object describing the JSHint symbol (provided to\n   *                     support cases where further refinement is necessary)\n   */\n  function stmt(s, f) {\n    var x = delim(s);\n    x.identifier = x.reserved = true;\n    x.fud = f;\n    return x;\n  }\n\n  /**\n   * Convenience function for defining block-statement-denoting symbols.\n   *\n   * A block-statement-denoting symbol is one like 'if' or 'for', which will be\n   * followed by a block and will not have to end with a semicolon.\n   *\n   * @param {string} s - the name of the symbol\n   * @param {function} - the first null denotation function for the symbol; see\n   *                     the `expression` function for more detail\n   *\n   * @returns {object} - the object describing the JSHint symbol (provided to\n   *                     support cases where further refinement is necessary)\n   */\n  function blockstmt(s, f) {\n    var x = stmt(s, f);\n    x.block = true;\n    return x;\n  }\n  /**\n   * Denote a given JSHint symbol as an identifier and a reserved keyword.\n   *\n   * @param {object} - a JSHint symbol value\n   *\n   * @returns {object} - the provided object\n   */\n  function reserveName(x) {\n    var c = x.id.charAt(0);\n    if ((c >= \"a\" && c <= \"z\") || (c >= \"A\" && c <= \"Z\")) {\n      x.identifier = x.reserved = true;\n    }\n    return x;\n  }\n\n  /**\n   * Convenience function for defining \"prefix\" symbols--operators that accept\n   * expressions as a right-hand side.\n   *\n   * @param {string} s - the name of the symbol\n   * @param {function} [f] - the first null denotation function for the symbol;\n   *                         see the `expression` function for more detail\n   *\n   * @returns {object} - the object describing the JSHint symbol (provided to\n   *                     support cases where further refinement is necessary)\n   */\n  function prefix(s, f) {\n    var x = symbol(s, 150);\n    reserveName(x);\n\n    x.nud = (typeof f === \"function\") ? f : function(context) {\n      this.arity = \"unary\";\n      this.right = expression(context, 150);\n\n      if (this.id === \"++\" || this.id === \"--\") {\n        if (state.option.plusplus) {\n          warning(\"W016\", this, this.id);\n        }\n\n        if (this.right) {\n          checkLeftSideAssign(context, this.right, this);\n        }\n      }\n\n      return this;\n    };\n\n    return x;\n  }\n\n  /**\n   * Convenience function for defining \"type\" symbols--those that describe\n   * literal values.\n   *\n   * @param {string} s - the name of the symbol\n   * @param {function} f - the first null denotation function for the symbol;\n   *                       see the `expression` function for more detail\n   *\n   * @returns {object} - the object describing the JSHint symbol (provided to\n   *                     support cases where further refinement is necessary)\n   */\n  function type(s, f) {\n    var x = symbol(s, 0);\n    x.type = s;\n    x.nud = f;\n    return x;\n  }\n\n  /**\n   * Convenience function for defining JSHint symbols for reserved\n   * keywords--those that are restricted from use as bindings (and as property\n   * names in ECMAScript 3 environments).\n   *\n   * @param {string} s - the name of the symbol\n   * @param {function} func - the first null denotation function for the\n   *                          symbol; see the `expression` function for more\n   *                          detail\n   *\n   * @returns {object} - the object describing the JSHint symbol (provided to\n   *                     support cases where further refinement is necessary)\n   */\n  function reserve(name, func) {\n    var x = type(name, func);\n    x.identifier = true;\n    x.reserved = true;\n    return x;\n  }\n\n  /**\n   * Convenience function for defining JSHint symbols for keywords that are\n   * only reserved in some circumstances.\n   *\n   * @param {string} name - the name of the symbol\n   * @param {object} [meta] - a collection of optional arguments\n   * @param {function} [meta.nud] -the null denotation function for the symbol;\n   *                   see the `expression` function for more detail\n   * @param {boolean} [meta.es5] - `true` if the identifier is reserved\n   *                               in ECMAScript 5 or later\n   * @param {boolean} [meta.strictOnly] - `true` if the identifier is only\n   *                                      reserved in strict mode code.\n   *\n   * @returns {object} - the object describing the JSHint symbol (provided to\n   *                     support cases where further refinement is necessary)\n   */\n  function FutureReservedWord(name, meta) {\n    var x = type(name, state.syntax[\"(identifier)\"].nud);\n\n    meta = meta || {};\n    meta.isFutureReservedWord = true;\n\n    x.value = name;\n    x.identifier = true;\n    x.reserved = true;\n    x.meta = meta;\n\n    return x;\n  }\n\n  /**\n   * Convenience function for defining \"infix\" symbols--operators that require\n   * operands as both \"land-hand side\" and \"right-hand side\".\n   *\n   * @param {string} s - the name of the symbol\n   * @param {function} [f] - a function to be invoked that consumes the\n   *                         right-hand side of the operator\n   * @param {number} p - the left-binding power of the token as used by the\n   *                     Pratt parsing semantics\n   * @param {boolean} [w] - if `true`\n   *\n   * @returns {object} - the object describing the JSHint symbol (provided to\n   *                     support cases where further refinement is necessary)\n   */\n  function infix(s, f, p, w) {\n    var x = symbol(s, p);\n    reserveName(x);\n    x.infix = true;\n    x.led = function(context, left) {\n      if (!w) {\n        nobreaknonadjacent(state.tokens.prev, state.tokens.curr);\n      }\n      if ((s === \"in\" || s === \"instanceof\") && left.id === \"!\") {\n        warning(\"W018\", left, \"!\");\n      }\n      if (typeof f === \"function\") {\n        return f(context, left, this);\n      } else {\n        this.left = left;\n        this.right = expression(context, p);\n        return this;\n      }\n    };\n    return x;\n  }\n\n  /**\n   * Convenience function for defining the `=>` token as used in arrow\n   * functions.\n   *\n   * @param {string} s - the name of the symbol\n   *\n   * @returns {object} - the object describing the JSHint symbol (provided to\n   *                     support cases where further refinement is necessary)\n   */\n  function application(s) {\n    var x = symbol(s, 42);\n\n    x.infix = true;\n    x.led = function(context, left) {\n      nobreaknonadjacent(state.tokens.prev, state.tokens.curr);\n\n      this.left = left;\n      this.right = doFunction(context, { type: \"arrow\", loneArg: left });\n      return this;\n    };\n    return x;\n  }\n\n  /**\n   * Convenience function for defining JSHint symbols for relation operators.\n   *\n   * @param {string} s - the name of the symbol\n   * @param {function} [f] - a function to be invoked to enforce any additional\n   *                         linting rules.\n   *\n   * @returns {object} - the object describing the JSHint symbol (provided to\n   *                     support cases where further refinement is necessary)\n   */\n  function relation(s, f) {\n    var x = symbol(s, 100);\n\n    x.infix = true;\n    x.led = function(context, left) {\n      nobreaknonadjacent(state.tokens.prev, state.tokens.curr);\n      this.left = left;\n      var right = this.right = expression(context, 100);\n\n      if (isIdentifier(left, \"NaN\") || isIdentifier(right, \"NaN\")) {\n        warning(\"W019\", this);\n      } else if (f) {\n        f.apply(this, [context, left, right]);\n      }\n\n      if (!left || !right) {\n        quit(\"E041\", state.tokens.curr);\n      }\n\n      if (left.id === \"!\") {\n        warning(\"W018\", left, \"!\");\n      }\n\n      if (right.id === \"!\") {\n        warning(\"W018\", right, \"!\");\n      }\n\n      return this;\n    };\n    return x;\n  }\n\n  /**\n   * Determine if a given token marks the beginning of a UnaryExpression.\n   *\n   * @param {object} token\n   *\n   * @returns {boolean}\n   */\n  function beginsUnaryExpression(token) {\n    return token.arity === \"unary\" && token.id !== \"++\" && token.id !== \"--\";\n  }\n\n  var typeofValues = {};\n  typeofValues.legacy = [\n    // E4X extended the `typeof` operator to return \"xml\" for the XML and\n    // XMLList types it introduced.\n    // Ref: 11.3.2 The typeof Operator\n    // http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-357.pdf\n    \"xml\",\n    // IE<9 reports \"unknown\" when the `typeof` operator is applied to an\n    // object existing across a COM+ bridge. In lieu of official documentation\n    // (which does not exist), see:\n    // http://robertnyman.com/2005/12/21/what-is-typeof-unknown/\n    \"unknown\"\n  ];\n  typeofValues.es3 = [\n    \"undefined\", \"boolean\", \"number\", \"string\", \"function\", \"object\",\n  ];\n  typeofValues.es3 = typeofValues.es3.concat(typeofValues.legacy);\n  typeofValues.es6 = typeofValues.es3.concat(\"symbol\", \"bigint\");\n\n  /**\n   * Validate comparisons between the result of a `typeof` expression and a\n   * string literal.\n   *\n   * @param {token} [left] - one of the values being compared\n   * @param {token} [right] - the other value being compared\n   * @param {object} state - the global state object (see `state.js`)\n   *\n   * @returns {boolean} - `false` if the second token describes a `typeof`\n   *                       expression and the first token is a string literal\n   *                       whose value is never returned by that operator;\n   *                       `true` otherwise\n   */\n  function isTypoTypeof(left, right, state) {\n    var values;\n\n    if (state.option.notypeof)\n      return false;\n\n    if (!left || !right)\n      return false;\n\n    values = state.inES6() ? typeofValues.es6 : typeofValues.es3;\n\n    if (right.type === \"(identifier)\" && right.value === \"typeof\" && left.type === \"(string)\") {\n      if (left.value === \"bigint\") {\n        if (!state.inES11()) {\n          warning(\"W119\", left, \"BigInt\", \"11\");\n        }\n\n        return false;\n      }\n\n      return !_.includes(values, left.value);\n    }\n\n    return false;\n  }\n\n  /**\n   * Determine if a given token describes the built-in `eval` function.\n   *\n   * @param {token} left\n   * @param {object} state - the global state object (see `state.js`)\n   *\n   * @returns {boolean}\n   */\n  function isGlobalEval(left, state) {\n    var isGlobal = false;\n\n    // permit methods to refer to an \"eval\" key in their own context\n    if (left.type === \"this\" && state.funct[\"(context)\"] === null) {\n      isGlobal = true;\n    }\n    // permit use of \"eval\" members of objects\n    else if (left.type === \"(identifier)\") {\n      if (state.option.node && left.value === \"global\") {\n        isGlobal = true;\n      }\n\n      else if (state.option.browser && (left.value === \"window\" || left.value === \"document\")) {\n        isGlobal = true;\n      }\n    }\n\n    return isGlobal;\n  }\n\n  /**\n   * Determine if a given token describes a property of a built-in object.\n   *\n   * @param {token} left\n   *\n   * @returns {boolean}\n   */\n  function findNativePrototype(left) {\n    var natives = [\n      \"Array\", \"ArrayBuffer\", \"Boolean\", \"Collator\", \"DataView\", \"Date\",\n      \"DateTimeFormat\", \"Error\", \"EvalError\", \"Float32Array\", \"Float64Array\",\n      \"Function\", \"Infinity\", \"Intl\", \"Int16Array\", \"Int32Array\", \"Int8Array\",\n      \"Iterator\", \"Number\", \"NumberFormat\", \"Object\", \"RangeError\",\n      \"ReferenceError\", \"RegExp\", \"StopIteration\", \"String\", \"SyntaxError\",\n      \"TypeError\", \"Uint16Array\", \"Uint32Array\", \"Uint8Array\", \"Uint8ClampedArray\",\n      \"URIError\"\n    ];\n\n    function walkPrototype(obj) {\n      if (typeof obj !== \"object\") return;\n      return obj.right === \"prototype\" ? obj : walkPrototype(obj.left);\n    }\n\n    function walkNative(obj) {\n      while (!obj.identifier && typeof obj.left === \"object\")\n        obj = obj.left;\n\n      if (obj.identifier && natives.indexOf(obj.value) >= 0 &&\n          state.funct[\"(scope)\"].isPredefined(obj.value)) {\n        return obj.value;\n      }\n    }\n\n    var prototype = walkPrototype(left);\n    if (prototype) return walkNative(prototype);\n  }\n\n  /**\n   * Determine if the given token is a valid assignment target; emit errors\n   * and/or warnings as appropriate\n   *\n   * @param {number} context - the parsing context; see `prod-params.js` for\n   *                           more information\n   * @param {token} left - the left hand side of the assignment\n   * @param {token=} assignToken - the token for the assignment, used for\n   *                               reporting\n   * @param {object=} options - optional object\n   * @param {boolean} options.allowDestructuring - whether to allow\n   *                                               destructuring binding\n   *\n   * @returns {boolean} Whether the left hand side is OK\n   */\n  function checkLeftSideAssign(context, left, assignToken, options) {\n\n    var allowDestructuring = options && options.allowDestructuring;\n\n    assignToken = assignToken || left;\n\n    if (state.option.freeze) {\n      var nativeObject = findNativePrototype(left);\n      if (nativeObject)\n        warning(\"W121\", left, nativeObject);\n    }\n\n    if (left.identifier && !left.isMetaProperty) {\n      // The `reassign` method also calls `modify`, but we are specific in\n      // order to catch function re-assignment and globals re-assignment\n      state.funct[\"(scope)\"].block.reassign(left.value, left);\n    }\n\n    if (left.id === \".\") {\n      if (!left.left || left.left.value === \"arguments\" && !state.isStrict()) {\n        warning(\"W143\", assignToken);\n      }\n\n      state.nameStack.set(state.tokens.prev);\n      return true;\n    } else if (left.id === \"{\" || left.id === \"[\") {\n      if (!allowDestructuring || !left.destructAssign) {\n        if (left.id === \"{\" || !left.left) {\n          warning(\"E031\", assignToken);\n        } else if (left.left.value === \"arguments\" && !state.isStrict()) {\n          warning(\"W143\", assignToken);\n        }\n      }\n\n      if (left.id === \"[\") {\n        state.nameStack.set(left.right);\n      }\n\n      return true;\n    } else if (left.identifier && !isReserved(context, left) && !left.isMetaProperty) {\n      if (state.funct[\"(scope)\"].bindingtype(left.value) === \"exception\") {\n        warning(\"W022\", left);\n      }\n\n      if (left.value === \"eval\" && state.isStrict()) {\n        error(\"E031\", assignToken);\n        return false;\n      } else if (left.value === \"arguments\") {\n        if (!state.isStrict()) {\n          warning(\"W143\", assignToken);\n        } else {\n          error(\"E031\", assignToken);\n          return false;\n        }\n      }\n      state.nameStack.set(left);\n      return true;\n    }\n\n    error(\"E031\", assignToken);\n\n    return false;\n  }\n\n  /**\n   * Convenience function for defining JSHint symbols for assignment operators.\n   *\n   * @param {string} s - the name of the symbol\n   * @param {function} [f] - a function to be invoked that consumes the\n   *                         right-hand side of the operator (see the `infix`\n   *                         function)\n   *\n   * @returns {object} - the object describing the JSHint symbol (provided to\n   *                     support cases where further refinement is necessary)\n   */\n  function assignop(s, f) {\n    var x = infix(s, typeof f === \"function\" ? f : function(context, left, that) {\n      that.left = left;\n\n      checkLeftSideAssign(context, left, that, { allowDestructuring: true });\n\n      that.right = expression(context, 10);\n\n      return that;\n    }, 20);\n\n    x.exps = true;\n    x.assign = true;\n\n    return x;\n  }\n\n  /**\n   * Convenience function for defining JSHint symbols for bitwise operators.\n   *\n   * @param {string} s - the name of the symbol\n   * @param {function} [f] - the left denotation function for the symbol; see\n   *                         the `expression` function for more detail\n   * @param {number} p - the left-binding power of the token as used by the\n   *                     Pratt parsing semantics\n   *\n   * @returns {object} - the object describing the JSHint symbol (provided to\n   *                     support cases where further refinement is necessary)\n   */\n  function bitwise(s, f, p) {\n    var x = symbol(s, p);\n    reserveName(x);\n    x.infix = true;\n    x.led = (typeof f === \"function\") ? f : function(context, left) {\n      if (state.option.bitwise) {\n        warning(\"W016\", this, this.id);\n      }\n      this.left = left;\n      this.right = expression(context, p);\n      return this;\n    };\n    return x;\n  }\n\n  /**\n   * Convenience function for defining JSHint symbols for bitwise assignment\n   * operators. See the `assignop` function for more detail.\n   *\n   * @param {string} s - the name of the symbol\n   *\n   * @returns {object} - the object describing the JSHint symbol (provided to\n   *                     support cases where further refinement is necessary)\n   */\n  function bitwiseassignop(s) {\n    symbol(s, 20).exps = true;\n    return infix(s, function(context, left, that) {\n      if (state.option.bitwise) {\n        warning(\"W016\", that, that.id);\n      }\n\n      checkLeftSideAssign(context, left, that);\n\n      that.right = expression(context, 10);\n\n      return that;\n    }, 20);\n  }\n\n  /**\n   * Convenience function for defining JSHint symbols for those operators which\n   * have a single operand that appears before them in the source code.\n   *\n   * @param {string} s - the name of the symbol\n   *\n   * @returns {object} - the object describing the JSHint symbol (provided to\n   *                     support cases where further refinement is necessary)\n   */\n  function suffix(s) {\n    var x = symbol(s, 150);\n\n    x.led = function(context, left) {\n      // this = suffix e.g. \"++\" punctuator\n      // left = symbol operated e.g. \"a\" identifier or \"a.b\" punctuator\n      if (state.option.plusplus) {\n        warning(\"W016\", this, this.id);\n      }\n\n      checkLeftSideAssign(context, left, this);\n\n      this.left = left;\n      return this;\n    };\n    return x;\n  }\n\n  /**\n   * Retrieve the value of the next token if it is an identifier and optionally\n   * advance the parser.\n   *\n   * @param {number} context - the parsing context; see `prod-params.js` for\n   *                           more information\n   * @param {boolean} [isName] - `true` if an IdentifierName should be consumed\n   *                             (e.g. object properties)\n   * @param {boolean} [preserve] - `true` if the token should not be consumed\n   *\n   * @returns {string|undefined} - the value of the identifier, if present\n   */\n  function optionalidentifier(context, isName, preserve) {\n    if (!state.tokens.next.identifier) {\n      return;\n    }\n\n    if (!preserve) {\n      advance();\n    }\n\n    var curr = state.tokens.curr;\n\n    if (isReserved(context, curr) && !(isName && state.inES5())) {\n      warning(\"W024\", state.tokens.curr, state.tokens.curr.id);\n    }\n\n    return curr.value;\n  }\n\n  /**\n   * Consume the \"...\" token which designates \"spread\" and \"rest\" operations if\n   * it is present. If the operator is repeated, consume every repetition, and\n   * issue a single error describing the syntax error.\n   *\n   * @param {string} operation - either \"spread\" or \"rest\"\n   *\n   * @returns {boolean} a value describing whether or not any tokens were\n   *                    consumed in this way\n   */\n  function spreadrest(operation) {\n    if (!checkPunctuator(state.tokens.next, \"...\")) {\n      return false;\n    }\n\n    if (!state.inES6(true)) {\n      warning(\"W119\", state.tokens.next, operation + \" operator\", \"6\");\n    }\n    advance();\n\n    if (checkPunctuator(state.tokens.next, \"...\")) {\n      warning(\"E024\", state.tokens.next, \"...\");\n      while (checkPunctuator(state.tokens.next, \"...\")) {\n        advance();\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Ensure that the current token is an identifier and retrieve its value.\n   *\n   * @param {number} context - the parsing context; see `prod-params.js` for\n   *                           more information\n   * @param {boolean} [isName] - `true` if an IdentifierName should be consumed\n   *                             (e.g. object properties)\n   *\n   * @returns {string|undefined} - the value of the identifier, if present\n   */\n  function identifier(context, isName) {\n    var i = optionalidentifier(context, isName, false);\n    if (i) {\n      return i;\n    }\n\n    error(\"E030\", state.tokens.next, state.tokens.next.value);\n\n    // The token should be consumed after a warning is issued so the parser\n    // can continue as though an identifier were found. The semicolon token\n    // should not be consumed in this way so that the parser interprets it as\n    // a statement delimiter;\n    if (state.tokens.next.id !== \";\") {\n      advance();\n    }\n  }\n\n\n  /**\n   * Determine if the provided token may be evaluated and emit a linting\n   * warning if this is note the case.\n   *\n   * @param {token} controlToken\n   */\n  function reachable(controlToken) {\n    var i = 0, t;\n    if (state.tokens.next.id !== \";\" || controlToken.inBracelessBlock) {\n      return;\n    }\n    for (;;) {\n      do {\n        t = peek(i);\n        i += 1;\n      } while (t.id !== \"(end)\" && t.id === \"(comment)\");\n\n      if (t.reach) {\n        return;\n      }\n      if (t.id !== \"(endline)\") {\n        if (t.id === \"function\") {\n          if (state.option.latedef === true) {\n            warning(\"W026\", t);\n          }\n          break;\n        }\n\n        warning(\"W027\", t, t.value, controlToken.value);\n        break;\n      }\n    }\n  }\n\n  /**\n   * Consume the semicolon that delimits the statement currently being parsed,\n   * emitting relevant warnings/errors as appropriate.\n   *\n   * @param {token} stmt - token describing the statement under consideration\n   */\n  function parseFinalSemicolon(stmt) {\n    if (state.tokens.next.id !== \";\") {\n      // don't complain about unclosed templates / strings\n      if (state.tokens.next.isUnclosed) return advance();\n\n      var isSameLine = sameLine(state.tokens.curr, state.tokens.next) &&\n                       state.tokens.next.id !== \"(end)\";\n      var blockEnd = checkPunctuator(state.tokens.next, \"}\");\n\n      if (isSameLine && !blockEnd && !(stmt.id === \"do\" && state.inES6(true))) {\n        errorAt(\"E058\", state.tokens.curr.line, state.tokens.curr.character);\n      } else if (!state.option.asi) {\n\n        // If this is the last statement in a block that ends on the same line\n        // *and* option lastsemic is on, ignore the warning.  Otherwise, issue\n        // a warning about missing semicolon.\n        if (!(blockEnd && isSameLine && state.option.lastsemic)) {\n          warningAt(\"W033\", state.tokens.curr.line, state.tokens.curr.character);\n        }\n      }\n    } else {\n      advance(\";\");\n    }\n  }\n\n  /**\n   * Consume a statement.\n   *\n   * @param {number} context - the parsing context; see `prod-params.js` for\n   *                           more information\n   *\n   * @returns {token} - the token describing the statement\n   */\n  function statement(context) {\n    var i = indent, r, t = state.tokens.next, hasOwnScope = false;\n\n    context |= prodParams.initial;\n\n    if (t.id === \";\") {\n      advance(\";\");\n      return;\n    }\n\n    // Is this a labelled statement?\n    var res = isReserved(context, t);\n\n    // We're being more tolerant here: if someone uses\n    // a FutureReservedWord (that is not meant to start a statement)\n    // as a label, we warn but proceed anyway.\n\n    if (res && t.meta && t.meta.isFutureReservedWord && !t.fud) {\n      warning(\"W024\", t, t.id);\n      res = false;\n    }\n\n    if (t.identifier && !res && peek().id === \":\") {\n      advance();\n      advance(\":\");\n\n      hasOwnScope = true;\n      state.funct[\"(scope)\"].stack();\n      state.funct[\"(scope)\"].block.addLabel(t.value, { token: state.tokens.curr });\n\n      if (!state.tokens.next.labelled && state.tokens.next.value !== \"{\") {\n        warning(\"W028\", state.tokens.next, t.value, state.tokens.next.value);\n      }\n\n      t = state.tokens.next;\n    }\n\n    // Is it a lonely block?\n\n    if (t.id === \"{\") {\n      // Is it a switch case block?\n      //\n      //  switch (foo) {\n      //    case bar: { <= here.\n      //      ...\n      //    }\n      //  }\n      var iscase = (state.funct[\"(verb)\"] === \"case\" && state.tokens.curr.value === \":\");\n      block(context, true, true, false, false, iscase);\n\n      if (hasOwnScope) {\n        state.funct[\"(scope)\"].unstack();\n      }\n\n      return;\n    }\n\n    // Parse the statement.\n\n    r = expression(context, 0);\n\n    if (r && !(r.identifier && r.value === \"function\") &&\n        !(r.type === \"(punctuator)\" && r.left &&\n          r.left.identifier && r.left.value === \"function\")) {\n      if (!state.isStrict() && state.stmtMissingStrict()) {\n        warning(\"E007\");\n      }\n    }\n\n    // Look for the final semicolon.\n\n    if (!t.block) {\n      if (!state.option.expr && (!r || !r.exps)) {\n        warning(\"W030\", state.tokens.curr);\n      } else if (state.option.nonew && r && r.left && r.id === \"(\" && r.left.id === \"new\") {\n        warning(\"W031\", t);\n      }\n\n      parseFinalSemicolon(t);\n    }\n\n\n    // Restore the indentation.\n\n    indent = i;\n    if (hasOwnScope) {\n      state.funct[\"(scope)\"].unstack();\n    }\n    return r;\n  }\n\n  /**\n   * Consume a series of statements until encountering either the end of the\n   * program or a token that interrupts control flow.\n   *\n   * @param {number} context - the parsing context; see `prod-params.js` for\n   *                           more information\n   *\n   * @returns {Array<token>} - the tokens consumed\n   */\n  function statements(context) {\n    var a = [], p;\n\n    while (!state.tokens.next.reach && state.tokens.next.id !== \"(end)\") {\n      if (state.tokens.next.id === \";\") {\n        p = peek();\n\n        if (!p || (p.id !== \"(\" && p.id !== \"[\")) {\n          warning(\"W032\");\n        }\n\n        advance(\";\");\n      } else {\n        a.push(statement(context));\n      }\n    }\n    return a;\n  }\n\n\n  /**\n   * Parse any directives in a directive prologue.\n   */\n  function directives() {\n    var current = state.tokens.next;\n    while (state.tokens.next.id === \"(string)\") {\n      var next = peekIgnoreEOL();\n      if (!isEndOfExpr(0, current, next)) {\n        break;\n      }\n      current = next;\n\n      advance();\n      var directive = state.tokens.curr.value;\n      if (state.directive[directive] ||\n          (directive === \"use strict\" && state.option.strict === \"implied\")) {\n        warning(\"W034\", state.tokens.curr, directive);\n      }\n\n      // From ECMAScript 2016:\n      //\n      // > 14.1.2 Static Semantics: Early Errors\n      // >\n      // > [...]\n      // > - It is a Syntax Error if ContainsUseStrict of FunctionBody is true\n      // >   and IsSimpleParameterList of FormalParameters is false.\n      if (directive === \"use strict\" && state.inES7() &&\n        !state.funct[\"(global)\"] && state.funct[\"(hasSimpleParams)\"] === false) {\n        error(\"E065\", state.tokens.curr);\n      }\n\n      state.directive[directive] = state.tokens.curr;\n\n      parseFinalSemicolon(current);\n    }\n\n    if (state.isStrict()) {\n      state.option.undef = true;\n    }\n  }\n\n  /**\n   * Parses a single block. A block is a sequence of statements wrapped in\n   * braces.\n   *\n   * @param {number} context - parsing context\n   * @param {boolean} ordinary - `true` for everything but function bodies and\n   *                             try blocks\n   * @param {boolean} [stmt] - `true` if block can be a single statement (e.g.\n   *                           in if/for/while)\n   * @param {boolean} [isfunc] - `true` if block is a function body\n   * @param {boolean} [isfatarrow] - `true` if its a body of a fat arrow\n   *                                 function\n   * @param {boolean} [iscase] - `true` if block is a switch case block\n   *\n   * @returns {token} - the token describing the block\n   */\n  function block(context, ordinary, stmt, isfunc, isfatarrow, iscase) {\n    var a,\n      b = inblock,\n      old_indent = indent,\n      m,\n      t,\n      d;\n\n    inblock = ordinary;\n\n    t = state.tokens.next;\n\n    var metrics = state.funct[\"(metrics)\"];\n    metrics.nestedBlockDepth += 1;\n    metrics.verifyMaxNestedBlockDepthPerFunction();\n\n    if (state.tokens.next.id === \"{\") {\n      advance(\"{\");\n\n      // create a new block scope\n      state.funct[\"(scope)\"].stack();\n\n      if (state.tokens.next.id !== \"}\") {\n        indent += state.option.indent;\n        while (!ordinary && state.tokens.next.from > indent) {\n          indent += state.option.indent;\n        }\n\n        if (isfunc) {\n          m = {};\n          for (d in state.directive) {\n            m[d] = state.directive[d];\n          }\n          directives();\n\n          state.funct[\"(isStrict)\"] = state.isStrict();\n\n          if (state.option.strict && state.funct[\"(context)\"][\"(global)\"]) {\n            if (!m[\"use strict\"] && !state.isStrict()) {\n              warning(\"E007\");\n            }\n          }\n        }\n\n        a = statements(context);\n\n        metrics.statementCount += a.length;\n\n        indent -= state.option.indent;\n      } else if (isfunc) {\n        // Ensure property is set for functions with empty bodies.\n        state.funct[\"(isStrict)\"] = state.isStrict();\n      }\n\n      advance(\"}\", t);\n\n      if (isfunc) {\n        state.funct[\"(scope)\"].validateParams(isfatarrow);\n        if (m) {\n          state.directive = m;\n        }\n      }\n\n      state.funct[\"(scope)\"].unstack();\n\n      indent = old_indent;\n    } else if (!ordinary) {\n      if (isfunc) {\n        state.funct[\"(scope)\"].stack();\n\n        if (stmt && !isfatarrow && !state.inMoz()) {\n          error(\"W118\", state.tokens.curr, \"function closure expressions\");\n        }\n\n        if (isfatarrow) {\n          state.funct[\"(scope)\"].validateParams(true);\n        }\n\n        var expr = expression(context, 10);\n\n        if (state.option.noreturnawait && context & prodParams.async &&\n            expr.identifier && expr.value === \"await\") {\n          warning(\"W146\", expr);\n        }\n\n        if (state.option.strict && state.funct[\"(context)\"][\"(global)\"]) {\n          if (!state.isStrict()) {\n            warning(\"E007\");\n          }\n        }\n\n        state.funct[\"(scope)\"].unstack();\n      } else {\n        error(\"E021\", state.tokens.next, \"{\", state.tokens.next.value);\n      }\n    } else {\n\n      state.funct[\"(scope)\"].stack();\n\n      if (!stmt || state.option.curly) {\n        warning(\"W116\", state.tokens.next, \"{\", state.tokens.next.value);\n      }\n\n      // JSHint observes Annex B of the ECMAScript specification by default,\n      // where function declarations are permitted in the statement positions\n      // of IfStatements.\n      var supportsFnDecl = state.funct[\"(verb)\"] === \"if\" ||\n        state.tokens.curr.id === \"else\";\n\n      state.tokens.next.inBracelessBlock = true;\n      indent += state.option.indent;\n      // test indentation only if statement is in new line\n      a = [statement(context)];\n      indent -= state.option.indent;\n\n      if (a[0] && a[0].declaration &&\n        !(supportsFnDecl && a[0].id === \"function\")) {\n        error(\"E048\", a[0], a[0].id[0].toUpperCase() + a[0].id.slice(1));\n      }\n\n      state.funct[\"(scope)\"].unstack();\n    }\n\n    // Don't clear and let it propagate out if it is \"break\", \"return\" or\n    // similar in switch case\n    switch (state.funct[\"(verb)\"]) {\n    case \"break\":\n    case \"continue\":\n    case \"return\":\n    case \"throw\":\n      if (iscase) {\n        break;\n      }\n\n      /* falls through */\n    default:\n      state.funct[\"(verb)\"] = null;\n    }\n\n    inblock = b;\n    if (ordinary && state.option.noempty && (!a || a.length === 0)) {\n      warning(\"W035\", state.tokens.prev);\n    }\n    metrics.nestedBlockDepth -= 1;\n    return a;\n  }\n\n\n  /**\n   * Update the global state which tracks all statically-identifiable property\n   * names, and emit a warning if the `members` linting directive is in use and\n   * does not include the given name.\n   *\n   * @param {string} m - the property name\n   */\n  function countMember(m) {\n    if (membersOnly && typeof membersOnly[m] !== \"boolean\") {\n      warning(\"W036\", state.tokens.curr, m);\n    }\n    if (typeof member[m] === \"number\") {\n      member[m] += 1;\n    } else {\n      member[m] = 1;\n    }\n  }\n\n  // Build the syntax table by declaring the syntactic elements of the language.\n\n  type(\"(number)\", function() {\n    if (state.tokens.next.id === \".\") {\n      warning(\"W005\", this);\n    }\n\n    return this;\n  });\n\n  type(\"(string)\", function() {\n    return this;\n  });\n\n  state.syntax[\"(identifier)\"] = {\n    type: \"(identifier)\",\n    lbp: 0,\n    identifier: true,\n\n    nud: function(context) {\n      var v = this.value;\n      // If this identifier is the lone parameter to a shorthand \"fat arrow\"\n      // function definition, i.e.\n      //\n      //     x => x;\n      //\n      // ...it should not be considered as a variable in the current scope. It\n      // will be added to the scope of the new function when the next token is\n      // parsed, so it can be safely ignored for now.\n      var isLoneArrowParam = state.tokens.next.id === \"=>\";\n\n      if (isReserved(context, this)) {\n        warning(\"W024\", this, v);\n      } else if (!isLoneArrowParam && !state.funct[\"(comparray)\"].check(v)) {\n        state.funct[\"(scope)\"].block.use(v, state.tokens.curr);\n      }\n\n      return this;\n    },\n\n    led: function() {\n      /* istanbul ignore next */\n      error(\"E033\", state.tokens.next, state.tokens.next.value);\n    }\n  };\n\n  var baseTemplateSyntax = {\n    identifier: false,\n    template: true,\n  };\n  state.syntax[\"(template)\"] = _.extend({\n    lbp: 155,\n    type: \"(template)\",\n    nud: doTemplateLiteral,\n    led: doTemplateLiteral,\n    noSubst: false\n  }, baseTemplateSyntax);\n\n  state.syntax[\"(template middle)\"] = _.extend({\n    lbp: 0,\n    type: \"(template middle)\",\n    noSubst: false\n  }, baseTemplateSyntax);\n\n  state.syntax[\"(template tail)\"] = _.extend({\n    lbp: 0,\n    type: \"(template tail)\",\n    tail: true,\n    noSubst: false\n  }, baseTemplateSyntax);\n\n  state.syntax[\"(no subst template)\"] = _.extend({\n    lbp: 155,\n    type: \"(template)\",\n    nud: doTemplateLiteral,\n    led: doTemplateLiteral,\n    noSubst: true,\n    tail: true // mark as tail, since it's always the last component\n  }, baseTemplateSyntax);\n\n  type(\"(regexp)\", function() {\n    return this;\n  });\n\n  // ECMAScript parser\n\n  delim(\"(endline)\");\n  (function(x) {\n    x.line = x.from = 0;\n  })(delim(\"(begin)\"));\n  delim(\"(end)\").reach = true;\n  delim(\"(error)\").reach = true;\n  delim(\"}\").reach = true;\n  delim(\")\");\n  delim(\"]\");\n  delim(\"\\\"\").reach = true;\n  delim(\"'\").reach = true;\n  delim(\";\");\n  delim(\":\").reach = true;\n  delim(\"#\");\n\n  reserve(\"else\");\n  reserve(\"case\").reach = true;\n  reserve(\"catch\");\n  reserve(\"default\").reach = true;\n  reserve(\"finally\");\n  reserve(\"true\", function() { return this; });\n  reserve(\"false\", function() { return this; });\n  reserve(\"null\", function() { return this; });\n  reserve(\"this\", function() {\n    if (state.isStrict() && !isMethod() &&\n        !state.option.validthis && ((state.funct[\"(statement)\"] &&\n        state.funct[\"(name)\"].charAt(0) > \"Z\") || state.funct[\"(global)\"])) {\n      warning(\"W040\", this);\n    }\n\n    return this;\n  });\n\n  (function(superSymbol) {\n    superSymbol.rbp = 161;\n  })(reserve(\"super\", function() {\n    superNud.call(state.tokens.curr, this);\n\n    return this;\n  }));\n\n  assignop(\"=\", \"assign\");\n  assignop(\"+=\", \"assignadd\");\n  assignop(\"-=\", \"assignsub\");\n  assignop(\"*=\", \"assignmult\");\n  assignop(\"/=\", \"assigndiv\").nud = function() {\n    /* istanbul ignore next */\n    error(\"E014\");\n  };\n  assignop(\"%=\", \"assignmod\");\n  assignop(\"**=\", function(context, left, that) {\n    if (!state.inES7()) {\n      warning(\"W119\", that, \"Exponentiation operator\", \"7\");\n    }\n\n    that.left = left;\n\n    checkLeftSideAssign(context, left, that);\n\n    that.right = expression(context, 10);\n\n    return that;\n  });\n\n  bitwiseassignop(\"&=\");\n  bitwiseassignop(\"|=\");\n  bitwiseassignop(\"^=\");\n  bitwiseassignop(\"<<=\");\n  bitwiseassignop(\">>=\");\n  bitwiseassignop(\">>>=\");\n  infix(\",\", function(context, left, that) {\n    if (state.option.nocomma) {\n      warning(\"W127\", that);\n    }\n\n    that.left = left;\n\n    if (checkComma()) {\n      that.right = expression(context, 10);\n    } else {\n      that.right = null;\n    }\n\n    return that;\n  }, 10, true);\n\n  infix(\"?\", function(context, left, that) {\n    increaseComplexityCount();\n    that.left = left;\n    that.right = expression(context & ~prodParams.noin, 10);\n    advance(\":\");\n    expression(context, 10);\n    return that;\n  }, 30);\n\n  infix(\"||\", function(context, left, that) {\n    increaseComplexityCount();\n    that.left = left;\n    that.right = expression(context, 40);\n    return that;\n  }, 40);\n\n  var andPrecedence = 50;\n  infix(\"&&\", function(context, left, that) {\n    increaseComplexityCount();\n    that.left = left;\n    that.right = expression(context, andPrecedence);\n    return that;\n  }, andPrecedence);\n\n  infix(\"??\", function(context, left, that) {\n    if (!left.paren && (left.id === \"||\" || left.id === \"&&\")) {\n      error(\"E024\", that, \"??\");\n    }\n\n    if (!state.inES11()) {\n      warning(\"W119\", that, \"nullish coalescing\", \"11\");\n    }\n\n    increaseComplexityCount();\n    that.left = left;\n    var right = that.right = expression(context, 39);\n\n    if (!right.paren && (right.id === \"||\" || right.id === \"&&\")) {\n      error(\"E024\", that.right, that.right.id);\n    }\n\n    return that;\n  }, 39);\n\n  // The Exponentiation operator, introduced in ECMAScript 2016\n  //\n  // ExponentiationExpression[Yield] :\n  //   UnaryExpression[?Yield]\n  //   UpdateExpression[?Yield] ** ExponentiationExpression[?Yield]\n  infix(\"**\", function(context, left, that) {\n    if (!state.inES7()) {\n      warning(\"W119\", that, \"Exponentiation operator\", \"7\");\n    }\n\n    // Disallow UnaryExpressions which are not wrapped in parenthesis\n    if (!left.paren && beginsUnaryExpression(left)) {\n      error(\"E024\", that, \"**\");\n    }\n\n    that.left = left;\n    that.right = expression(context, that.rbp);\n    return that;\n  }, 150);\n  state.syntax[\"**\"].rbp = 140;\n  bitwise(\"|\", \"bitor\", 70);\n  bitwise(\"^\", \"bitxor\", 80);\n  bitwise(\"&\", \"bitand\", 90);\n  relation(\"==\", function(context, left, right) {\n    var eqnull = state.option.eqnull &&\n      ((left && left.value) === \"null\" || (right && right.value) === \"null\");\n\n    switch (true) {\n      case !eqnull && state.option.eqeqeq:\n        this.from = this.character;\n        warning(\"W116\", this, \"===\", \"==\");\n        break;\n      /* istanbul ignore next */\n      case isTypoTypeof(right, left, state):\n        warning(\"W122\", this, right.value);\n        break;\n      case isTypoTypeof(left, right, state):\n        warning(\"W122\", this, left.value);\n        break;\n    }\n\n    return this;\n  });\n  relation(\"===\", function(context, left, right) {\n    if (isTypoTypeof(right, left, state)) {\n      warning(\"W122\", this, right.value);\n    } else if (isTypoTypeof(left, right, state)) {\n      /* istanbul ignore next */\n      warning(\"W122\", this, left.value);\n    }\n    return this;\n  });\n  relation(\"!=\", function(context, left, right) {\n    var eqnull = state.option.eqnull &&\n        ((left && left.value) === \"null\" || (right && right.value) === \"null\");\n\n    if (!eqnull && state.option.eqeqeq) {\n      this.from = this.character;\n      warning(\"W116\", this, \"!==\", \"!=\");\n    } else if (isTypoTypeof(right, left, state)) {\n      /* istanbul ignore next */\n      warning(\"W122\", this, right.value);\n    } else if (isTypoTypeof(left, right, state)) {\n      warning(\"W122\", this, left.value);\n    }\n    return this;\n  });\n  relation(\"!==\", function(context, left, right) {\n    if (isTypoTypeof(right, left, state)) {\n      warning(\"W122\", this, right.value);\n    } else if (isTypoTypeof(left, right, state)) {\n      /* istanbul ignore next */\n      warning(\"W122\", this, left.value);\n    }\n    return this;\n  });\n  relation(\"<\");\n  relation(\">\");\n  relation(\"<=\");\n  relation(\">=\");\n  bitwise(\"<<\", \"shiftleft\", 120);\n  bitwise(\">>\", \"shiftright\", 120);\n  bitwise(\">>>\", \"shiftrightunsigned\", 120);\n  infix(\"in\", \"in\", 120);\n  infix(\"instanceof\", function(context, left, token) {\n    var right;\n    var scope = state.funct[\"(scope)\"];\n    token.left = left;\n    token.right = right = expression(context, 120);\n\n    // This condition reflects a syntax error which will be reported by the\n    // `expression` function.\n    if (!right) {\n      return token;\n    }\n\n    if (right.id === \"(number)\" ||\n        right.id === \"(string)\" ||\n        right.value === \"null\" ||\n        (right.value === \"undefined\" && !scope.has(\"undefined\")) ||\n        right.arity === \"unary\" ||\n        right.id === \"{\" ||\n        (right.id === \"[\" && !right.right) ||\n        right.id === \"(regexp)\" ||\n        (right.id === \"(template)\" && !right.tag)) {\n      error(\"E060\");\n    }\n\n    if (right.id === \"function\") {\n      warning(\"W139\");\n    }\n\n    return token;\n  }, 120);\n  infix(\"+\", function(context, left, that) {\n    var next = state.tokens.next;\n    var right;\n    that.left = left;\n    that.right = right = expression(context, 130);\n\n    if (left && right && left.id === \"(string)\" && right.id === \"(string)\") {\n      left.value += right.value;\n      left.character = right.character;\n      if (!state.option.scripturl && reg.javascriptURL.test(left.value)) {\n        warning(\"W050\", left);\n      }\n      return left;\n    }\n\n    if (next.id === \"+\" || next.id === \"++\") {\n      warning(\"W007\", that.right);\n    }\n\n    return that;\n  }, 130);\n  prefix(\"+\", function(context) {\n    var next = state.tokens.next;\n    this.arity = \"unary\";\n    this.right = expression(context, 150);\n\n    if (next.id === \"+\" || next.id === \"++\") {\n      warning(\"W007\", this.right);\n    }\n\n    return this;\n  });\n  infix(\"-\", function(context, left, that) {\n    var next = state.tokens.next;\n    that.left = left;\n    that.right = expression(context, 130);\n\n    if (next.id === \"-\" || next.id === \"--\") {\n      warning(\"W006\", that.right);\n    }\n\n    return that;\n  }, 130);\n  prefix(\"-\", function(context) {\n    var next = state.tokens.next;\n    this.arity = \"unary\";\n    this.right = expression(context, 150);\n\n    if (next.id === \"-\" || next.id === \"--\") {\n      warning(\"W006\", this.right);\n    }\n\n    return this;\n  });\n  infix(\"*\", \"mult\", 140);\n  infix(\"/\", \"div\", 140);\n  infix(\"%\", \"mod\", 140);\n\n  suffix(\"++\");\n  prefix(\"++\", \"preinc\");\n  state.syntax[\"++\"].exps = true;\n\n  suffix(\"--\");\n  prefix(\"--\", \"predec\");\n  state.syntax[\"--\"].exps = true;\n\n  prefix(\"delete\", function(context) {\n    this.arity = \"unary\";\n    var p = expression(context, 150);\n    if (!p) {\n      return this;\n    }\n\n    if (p.id !== \".\" && p.id !== \"[\") {\n      warning(\"W051\");\n    }\n    this.first = p;\n\n    // The `delete` operator accepts unresolvable references when not in strict\n    // mode, so the operand may be undefined.\n    if (p.identifier && !state.isStrict()) {\n      p.forgiveUndef = true;\n    }\n    return this;\n  }).exps = true;\n\n  prefix(\"~\", function(context) {\n    if (state.option.bitwise) {\n      warning(\"W016\", this, \"~\");\n    }\n    this.arity = \"unary\";\n    this.right = expression(context, 150);\n    return this;\n  });\n\n  infix(\"...\");\n\n  prefix(\"!\", function(context) {\n    this.arity = \"unary\";\n    this.right = expression(context, 150);\n\n    if (!this.right) { // '!' followed by nothing? Give up.\n      quit(\"E041\", this);\n    }\n\n    if (bang[this.right.id] === true) {\n      warning(\"W018\", this, \"!\");\n    }\n    return this;\n  });\n\n  prefix(\"typeof\", function(context) {\n    this.arity = \"unary\";\n    var p = expression(context, 150);\n    this.first = this.right = p;\n\n    if (!p) { // 'typeof' followed by nothing? Give up.\n      quit(\"E041\", this);\n    }\n\n    // The `typeof` operator accepts unresolvable references, so the operand\n    // may be undefined.\n    if (p.identifier) {\n      p.forgiveUndef = true;\n    }\n    return this;\n  });\n  prefix(\"new\", function(context) {\n    var mp = metaProperty(context, \"target\", function() {\n      if (!state.inES6(true)) {\n        warning(\"W119\", state.tokens.prev, \"new.target\", \"6\");\n      }\n      var inFunction, c = state.funct;\n      while (c) {\n        inFunction = !c[\"(global)\"];\n        if (!c[\"(arrow)\"]) { break; }\n        c = c[\"(context)\"];\n      }\n      if (!inFunction) {\n        warning(\"W136\", state.tokens.prev, \"new.target\");\n      }\n    });\n    if (mp) { return mp; }\n\n    var opening = state.tokens.next;\n    var c = expression(context, 155), i;\n\n    if (!c) {\n      return this;\n    }\n\n    if (!c.paren && c.rbp > 160) {\n      error(\"E024\", opening, opening.value);\n    }\n\n    if (c.id !== \"function\") {\n      if (c.identifier) {\n        switch (c.value) {\n        case \"Number\":\n        case \"String\":\n        case \"Boolean\":\n        case \"Math\":\n        case \"JSON\":\n          warning(\"W053\", state.tokens.prev, c.value);\n          break;\n        case \"Symbol\":\n          if (state.inES6()) {\n            warning(\"W053\", state.tokens.prev, c.value);\n          }\n          break;\n        case \"Function\":\n          if (!state.option.evil) {\n            warning(\"W054\");\n          }\n          break;\n        case \"Date\":\n        case \"RegExp\":\n        case \"this\":\n          break;\n        default:\n          i = c.value.substr(0, 1);\n          if (state.option.newcap && (i < \"A\" || i > \"Z\") &&\n            !state.funct[\"(scope)\"].isPredefined(c.value)) {\n            warning(\"W055\", state.tokens.curr);\n          }\n        }\n      } else {\n        if (c.id === \"?.\" && !c.paren) {\n          error(\"E024\", c, \"?.\");\n        } else if (c.id !== \".\" && c.id !== \"[\" && c.id !== \"(\") {\n          /* istanbul ignore next */\n          warning(\"W056\", state.tokens.curr);\n        }\n      }\n    } else {\n      if (!state.option.supernew)\n        warning(\"W057\", this);\n    }\n    if (state.tokens.next.id !== \"(\" && !state.option.supernew) {\n      warning(\"W058\", state.tokens.curr, state.tokens.curr.value);\n    }\n    this.first = this.right = c;\n    return this;\n  });\n  state.syntax[\"new\"].exps = true;\n\n\n  var classDeclaration = blockstmt(\"class\", function(context) {\n    var className, classNameToken;\n\n    if (!state.inES6()) {\n      warning(\"W104\", state.tokens.curr, \"class\", \"6\");\n    }\n    state.inClassBody = true;\n\n    // Class Declaration: 'class <Classname>'\n    if (state.tokens.next.identifier && state.tokens.next.value !== \"extends\") {\n      classNameToken = state.tokens.next;\n      className = classNameToken.value;\n      identifier(context);\n      // unintialized, so that the 'extends' clause is parsed while the class is in TDZ\n      state.funct[\"(scope)\"].addbinding(className, {\n        type: \"class\",\n        initialized: false,\n        token: classNameToken\n      });\n    }\n\n    // Class Declaration: 'class <Classname> extends <Superclass>'\n    if (state.tokens.next.value === \"extends\") {\n      advance(\"extends\");\n      expression(context, 0);\n    }\n\n    if (classNameToken) {\n      this.name = classNameToken;\n      state.funct[\"(scope)\"].initialize(className);\n    } else {\n      this.name = null;\n    }\n\n    state.funct[\"(scope)\"].stack();\n    classBody(this, context);\n    return this;\n  });\n  classDeclaration.exps = true;\n  classDeclaration.declaration = true;\n\n  /*\n    Class expression\n\n    The Block- and Expression- handling for \"class\" are almost identical, except for the ordering of steps.\n    In an expression:, the name should not be saved into the calling scope, but is still accessible inside the definition, so we open a new scope first, then save the name. We also mark it as used.\n  */\n  prefix(\"class\", function(context) {\n    var className, classNameToken;\n\n    if (!state.inES6()) {\n      warning(\"W104\", state.tokens.curr, \"class\", \"6\");\n    }\n    state.inClassBody = true;\n\n    // Class Declaration: 'class <Classname>'\n    if (state.tokens.next.identifier && state.tokens.next.value !== \"extends\") {\n      classNameToken = state.tokens.next;\n      className = classNameToken.value;\n      identifier(context);\n    }\n\n    // Class Declaration: 'class <Classname> extends <Superclass>'\n    if (state.tokens.next.value === \"extends\") {\n      advance(\"extends\");\n      expression(context, 0);\n    }\n\n    state.funct[\"(scope)\"].stack();\n    if (classNameToken) {\n      this.name = classNameToken;\n      state.funct[\"(scope)\"].addbinding(className, {\n        type: \"class\",\n        initialized: true,\n        token: classNameToken\n      });\n      state.funct[\"(scope)\"].block.use(className, classNameToken);\n    } else {\n      this.name = null;\n    }\n\n    classBody(this, context);\n    return this;\n  });\n\n  function classBody(classToken, context) {\n    var props = Object.create(null);\n    var name, accessorType, token, isStatic, inGenerator, hasConstructor;\n\n    /* istanbul ignore else */\n    if (state.tokens.next.value === \"{\") {\n      advance(\"{\");\n    } else {\n      warning(\"W116\", state.tokens.curr, \"identifier\", state.tokens.next.type); //?\n      advance();\n    }\n\n    while (state.tokens.next.value !== \"}\") {\n      isStatic = false;\n      inGenerator = false;\n      context &= ~prodParams.preAsync;\n\n      if (state.tokens.next.value === \"static\" &&\n        !checkPunctuator(peek(), \"(\")) {\n        isStatic = true;\n        advance();\n      }\n\n      if (state.tokens.next.value === \"async\") {\n        if (!checkPunctuator(peek(), \"(\")) {\n          context |= prodParams.preAsync;\n          advance();\n\n          nolinebreak(state.tokens.curr);\n\n          if (checkPunctuator(state.tokens.next, \"*\")) {\n            inGenerator = true;\n            advance(\"*\");\n\n            if (!state.inES9()) {\n              warning(\"W119\", state.tokens.next, \"async generators\", \"9\");\n            }\n          }\n\n          if (!state.inES8()) {\n            warning(\"W119\", state.tokens.curr, \"async functions\", \"8\");\n          }\n        }\n      }\n\n      if (state.tokens.next.value === \"*\") {\n        inGenerator = true;\n        advance();\n      }\n\n      token = state.tokens.next;\n\n      if ((token.value === \"set\" || token.value === \"get\") && !checkPunctuator(peek(), \"(\")) {\n        if (inGenerator) {\n          /* istanbul ignore next */\n          error(\"E024\", token, token.value);\n        }\n        accessorType = token.value;\n        advance();\n        token = state.tokens.next;\n\n        if (!isStatic && token.value === \"constructor\") {\n          error(\"E049\", token, \"class \" + accessorType + \"ter method\", token.value);\n        } else if (isStatic && token.value === \"prototype\") {\n          error(\"E049\", token, \"static class \" + accessorType + \"ter method\", token.value);\n        }\n      } else {\n        accessorType = null;\n      }\n\n      switch (token.value) {\n        case \";\":\n          warning(\"W032\", token);\n          advance();\n          break;\n        case \"constructor\":\n          if (isStatic) {\n            // treat like a regular method -- static methods can be called 'constructor'\n            name = propertyName(context);\n            saveProperty(props, name, token, true, isStatic);\n            doMethod(classToken, context, name, inGenerator);\n          } else {\n            if (inGenerator || context & prodParams.preAsync) {\n              error(\"E024\", token, token.value);\n            } else if (hasConstructor) {\n              /* istanbul ignore next */\n              error(\"E024\", token, token.value);\n            } else {\n              hasConstructor = !accessorType && !isStatic;\n            }\n            advance();\n            doMethod(classToken, context, state.nameStack.infer());\n          }\n          break;\n        case \"[\":\n          name = computedPropertyName(context);\n          doMethod(classToken, context, name, inGenerator);\n          // We don't check names (via calling saveProperty()) of computed expressions like [\"Symbol.iterator\"]()\n          break;\n        default:\n          name = propertyName(context);\n          if (name === undefined) {\n            error(\"E024\", token, token.value);\n            advance();\n            break;\n          }\n\n          if (accessorType) {\n            saveAccessor(accessorType, props, name, token, true, isStatic);\n            name = state.nameStack.infer();\n          } else {\n            if (isStatic && name === \"prototype\") {\n              error(\"E049\", token, \"static class method\", name);\n            }\n\n            saveProperty(props, name, token, true, isStatic);\n          }\n\n          doMethod(classToken, context, name, inGenerator);\n          break;\n      }\n    }\n    advance(\"}\");\n    checkProperties(props);\n\n    state.inClassBody = false;\n    state.funct[\"(scope)\"].unstack();\n  }\n\n  function doMethod(classToken, context, name, generator) {\n    if (generator) {\n      if (!state.inES6()) {\n        warning(\"W119\", state.tokens.curr, \"function*\", \"6\");\n      }\n    }\n\n    if (state.tokens.next.value !== \"(\") {\n      error(\"E054\", state.tokens.next, state.tokens.next.value);\n      advance();\n      if (state.tokens.next.value === \"{\") {\n        // manually cheating the test \"invalidClasses\", which asserts this particular behavior when a class is misdefined.\n        advance();\n        if (state.tokens.next.value === \"}\") {\n          warning(\"W116\", state.tokens.next, \"(\", state.tokens.next.value);\n          advance();\n          identifier(context);\n          advance();\n        }\n        /* istanbul ignore next */\n        return;\n      } else {\n        while (state.tokens.next.value !== \"(\") {\n          advance();\n        }\n      }\n    }\n\n    doFunction(context, { name: name,\n        type: generator ? \"generator\" : null,\n        isMethod: true,\n        statement: classToken });\n  }\n\n  prefix(\"void\").exps = true;\n\n  infix(\".\", function(context, left, that) {\n    var m = identifier(context, true);\n\n    if (typeof m === \"string\") {\n      countMember(m);\n    }\n\n    that.left = left;\n    that.right = m;\n\n    if (m && m === \"hasOwnProperty\" && state.tokens.next.value === \"=\") {\n      warning(\"W001\");\n    }\n\n    if (left && left.value === \"arguments\" && (m === \"callee\" || m === \"caller\")) {\n      if (state.option.noarg)\n        warning(\"W059\", left, m);\n      else if (state.isStrict())\n        error(\"E008\");\n    } else if (!state.option.evil && left && left.value === \"document\" &&\n        (m === \"write\" || m === \"writeln\")) {\n      warning(\"W060\", left);\n    }\n\n    if (!state.option.evil && (m === \"eval\" || m === \"execScript\")) {\n      if (isGlobalEval(left, state)) {\n        warning(\"W061\");\n      }\n    }\n\n    return that;\n  }, 160, true);\n\n  infix(\"?.\", function(context, left, that) {\n    if (!state.inES11()) {\n      warning(\"W119\", state.tokens.curr, \"Optional chaining\", \"11\");\n    }\n\n\n    if (checkPunctuator(state.tokens.next, \"[\")) {\n      that.left = left;\n      advance();\n      that.right = state.tokens.curr.led(context, left);\n    } else if (checkPunctuator(state.tokens.next, \"(\")) {\n      that.left = left;\n      advance();\n      that.right = state.tokens.curr.led(context, left);\n      that.exps = true;\n    } else {\n      state.syntax[\".\"].led.call(that, context, left);\n    }\n\n    if (state.tokens.next.type === \"(template)\") {\n      error(\"E024\", state.tokens.next, \"`\");\n    }\n\n    return that;\n  }, 160, true);\n\n\n  /**\n   * Determine if a CallExpression's \"base\" is a type of expression commonly\n   * used in this position.\n   *\n   * @param {token} token - token describing the \"base\" of the CallExpression\n   * @returns {boolean}\n   */\n  function isTypicalCallExpression(token) {\n    return token.identifier || token.id === \".\" || token.id === \"[\" ||\n      token.id === \"=>\" || token.id === \"(\" || token.id === \"&&\" ||\n      token.id === \"||\" || token.id === \"?\" || token.id === \"async\" ||\n      token.id === \"?.\" || (state.inES6() && token[\"(name)\"]);\n  }\n\n  infix(\"(\", function(context, left, that) {\n    if (state.option.immed && left && !left.immed && left.id === \"function\") {\n      warning(\"W062\");\n    }\n\n    if (state.option.asi && checkPunctuators(state.tokens.prev, [\")\", \"]\"]) &&\n      !sameLine(state.tokens.prev, state.tokens.curr)) {\n      warning(\"W014\", state.tokens.curr, state.tokens.curr.id);\n    }\n\n    var n = 0;\n    var p = [];\n\n    if (left) {\n      if (left.type === \"(identifier)\") {\n        var newcapRe = /^[A-Z]([A-Z0-9_$]*[a-z][A-Za-z0-9_$]*)?$/;\n        var newcapIgnore = [\n          \"Array\", \"Boolean\", \"Date\", \"Error\", \"Function\", \"Number\",\n          \"Object\", \"RegExp\", \"String\", \"Symbol\"\n        ];\n        if (newcapRe.test(left.value) && newcapIgnore.indexOf(left.value) === -1) {\n          if (left.value === \"Math\") {\n            /* istanbul ignore next */\n            warning(\"W063\", left);\n          } else if (state.option.newcap) {\n            warning(\"W064\", left);\n          }\n        }\n      }\n    }\n\n    if (state.tokens.next.id !== \")\") {\n      for (;;) {\n        spreadrest(\"spread\");\n\n        p[p.length] = expression(context, 10);\n        n += 1;\n        if (state.tokens.next.id !== \",\") {\n          break;\n        }\n        advance(\",\");\n        checkComma({ allowTrailing: true });\n\n        if (state.tokens.next.id === \")\") {\n          if (!state.inES8()) {\n            warning(\"W119\", state.tokens.curr, \"Trailing comma in arguments lists\", \"8\");\n          }\n\n          break;\n        }\n      }\n    }\n\n    advance(\")\");\n\n    if (typeof left === \"object\") {\n      if (!state.inES5() && left.value === \"parseInt\" && n === 1) {\n        warning(\"W065\", state.tokens.curr);\n      }\n      if (!state.option.evil) {\n        if (left.value === \"eval\" || left.value === \"Function\" ||\n            left.value === \"execScript\") {\n          warning(\"W061\", left);\n\n          // This conditional expression was initially implemented with a typo\n          // which prevented the branch's execution in all cases. While\n          // enabling the code will produce behavior that is consistent with\n          // the other forms of code evaluation that follow, such a change is\n          // also technically incompatable with prior versions of JSHint (due\n          // to the fact that the behavior was never formally documented). This\n          // branch should be enabled as part of a major release.\n          //if (p[0] && p[0].id === \"(string)\") {\n          //  addEvalCode(left, p[0]);\n          //}\n        } else if (p[0] && p[0].id === \"(string)\" &&\n             (left.value === \"setTimeout\" ||\n            left.value === \"setInterval\")) {\n          warning(\"W066\", left);\n          addEvalCode(left, p[0]);\n\n        // window.setTimeout/setInterval\n        } else if (p[0] && p[0].id === \"(string)\" &&\n             left.value === \".\" &&\n             left.left.value === \"window\" &&\n             (left.right === \"setTimeout\" ||\n            left.right === \"setInterval\")) {\n          warning(\"W066\", left);\n          addEvalCode(left, p[0]);\n        }\n      }\n      if (!isTypicalCallExpression(left)) {\n        warning(\"W067\", that);\n      }\n    }\n\n    that.left = left;\n    return that;\n  }, 155, true).exps = true;\n\n  function peekThroughParens(parens) {\n    var pn = state.tokens.next;\n    var i = -1;\n    var pn1;\n\n    do {\n      if (pn.value === \"(\") {\n        parens += 1;\n      } else if (pn.value === \")\") {\n        parens -= 1;\n      }\n\n      i += 1;\n      pn1 = pn;\n      pn = peek(i);\n    } while (!(parens === 0 && pn1.value === \")\") && pn.type !== \"(end)\");\n\n    return pn;\n  }\n\n  prefix(\"(\", function(context, rbp) {\n    var ret, triggerFnExpr, first, last;\n    var opening = state.tokens.curr;\n    var preceeding = state.tokens.prev;\n    var isNecessary = !state.option.singleGroups;\n    var pn = peekThroughParens(1);\n\n    if (state.tokens.next.id === \"function\") {\n      triggerFnExpr = state.tokens.next.immed = true;\n    }\n\n    // If the balanced grouping operator is followed by a \"fat arrow\", the\n    // current token marks the beginning of a \"fat arrow\" function and parsing\n    // should proceed accordingly.\n    if (pn.value === \"=>\") {\n      pn.funct = doFunction(context, { type: \"arrow\", parsedOpening: true });\n      return pn;\n    }\n\n    // The ECMA262 grammar requires an expression between the \"opening\n    // parenthesis\" and \"close parenthesis\" tokens of the grouping operator.\n    // However, the \"ignore\" directive is commonly used to inject values that\n    // are not included in the token stream. For example:\n    //\n    //     return (\n    //       /*jshint ignore:start */\n    //       <div></div>\n    //       /*jshint ignore:end */\n    //     );\n    //\n    // The \"empty\" grouping operator is permitted in order to tolerate this\n    // pattern.\n    if (state.tokens.next.id === \")\") {\n      advance(\")\");\n      return;\n    }\n\n    ret = expression(context, 0);\n\n    advance(\")\", this);\n\n    if (!ret) {\n      return;\n    }\n\n    ret.paren = true;\n\n    if (state.option.immed && ret && ret.id === \"function\") {\n      if (state.tokens.next.id !== \"(\" &&\n        state.tokens.next.id !== \".\" && state.tokens.next.id !== \"[\") {\n        warning(\"W068\", this);\n      }\n    }\n\n    if (ret.id === \",\") {\n      first = ret.left;\n      while (first.id === \",\") {\n        first = first.left;\n      }\n\n      last = ret.right;\n    } else {\n      first = last = ret;\n\n      if (!isNecessary) {\n        // async functions are identified after parsing due to the complexity\n        // of disambiguating the `async` keyword.\n        if (!triggerFnExpr) {\n          triggerFnExpr = ret.id === \"async\";\n        }\n\n        isNecessary =\n          // Used to distinguish from an ExpressionStatement which may not\n          // begin with the `{` and `function` tokens\n          (opening.beginsStmt && (ret.id === \"{\" || triggerFnExpr)) ||\n          // Used to signal that a function expression is being supplied to\n          // some other operator.\n          (triggerFnExpr &&\n            // For parenthesis wrapping a function expression to be considered\n            // necessary, the grouping operator should be the left-hand-side of\n            // some other operator--either within the parenthesis or directly\n            // following them.\n            (!isEndOfExpr() || state.tokens.prev.id !== \"}\")) ||\n          // Used to demarcate an arrow function as the left-hand side of some\n          // operator.\n          (ret.id === \"=>\" && !isEndOfExpr()) ||\n          // Used as the return value of a single-statement arrow function\n          (ret.id === \"{\" && preceeding.id === \"=>\") ||\n          // Used to cover a unary expression as the left-hand side of the\n          // exponentiation operator\n          (beginsUnaryExpression(ret) && state.tokens.next.id === \"**\") ||\n          // Used to cover a logical operator as the right-hand side of the\n          // nullish coalescing operator\n          (preceeding.id === \"??\" && (ret.id === \"&&\" || ret.id === \"||\")) ||\n          // Used to delineate an integer number literal from a dereferencing\n          // punctuator (otherwise interpreted as a decimal point)\n          (ret.type === \"(number)\" &&\n            checkPunctuator(pn, \".\") && /^\\d+$/.test(ret.value)) ||\n          // Used to wrap object destructuring assignment\n          (opening.beginsStmt && ret.id === \"=\" && ret.left.id === \"{\") ||\n          // Used to allow optional chaining with other language features which\n          // are otherwise restricted.\n          (ret.id === \"?.\" &&\n              (preceeding.id === \"new\" || state.tokens.next.type === \"(template)\"));\n      }\n    }\n\n    // The operator may be necessary to override the default binding power of\n    // neighboring operators (whenever there is an operator in use within the\n    // first expression *or* the current group contains multiple expressions)\n    if (!isNecessary && (isOperator(first) || first !== last)) {\n      isNecessary =\n        (rbp > first.lbp) ||\n        (rbp > 0 && rbp === first.lbp) ||\n        (!isEndOfExpr() && last.rbp < state.tokens.next.lbp);\n    }\n\n    if (!isNecessary) {\n      warning(\"W126\", opening);\n    }\n\n    return ret;\n  });\n\n  application(\"=>\").rbp = 161;\n\n  infix(\"[\", function(context, left, that) {\n    var e, s, canUseDot;\n\n    if (state.option.asi && checkPunctuators(state.tokens.prev, [\")\", \"]\"]) &&\n      !sameLine(state.tokens.prev, state.tokens.curr)) {\n      warning(\"W014\", state.tokens.curr, state.tokens.curr.id);\n    }\n\n    e = expression(context & ~prodParams.noin, 0);\n\n    if (e && e.type === \"(string)\") {\n      if (!state.option.evil && (e.value === \"eval\" || e.value === \"execScript\")) {\n        if (isGlobalEval(left, state)) {\n          warning(\"W061\");\n        }\n      }\n\n      countMember(e.value);\n      if (!state.option.sub && reg.identifier.test(e.value)) {\n        s = state.syntax[e.value];\n\n        if (s) {\n          canUseDot = !isReserved(context, s);\n        } else {\n          // This branch exists to preserve legacy behavior with version 2.9.5\n          // and earlier. In those releases, `eval` and `arguments` were\n          // incorrectly interpreted as reserved keywords, so Member\n          // Expressions such as `object[\"eval\"]` did not trigger warning W069.\n          //\n          // TODO: Remove in JSHint 3\n          canUseDot = e.value !== \"eval\" && e.value !== \"arguments\";\n        }\n\n        if (canUseDot) {\n          warning(\"W069\", state.tokens.prev, e.value);\n        }\n      }\n    }\n    advance(\"]\", that);\n\n    if (e && e.value === \"hasOwnProperty\" && state.tokens.next.value === \"=\") {\n      warning(\"W001\");\n    }\n\n    that.left = left;\n    that.right = e;\n    return that;\n  }, 160, true);\n\n  function comprehensiveArrayExpression(context) {\n    var res = {};\n    res.exps = true;\n    state.funct[\"(comparray)\"].stack();\n\n    // Handle reversed for expressions, used in spidermonkey\n    var reversed = false;\n    if (state.tokens.next.value !== \"for\") {\n      reversed = true;\n      if (!state.inMoz()) {\n        warning(\"W116\", state.tokens.next, \"for\", state.tokens.next.value);\n      }\n      state.funct[\"(comparray)\"].setState(\"use\");\n      res.right = expression(context, 10);\n    }\n\n    advance(\"for\");\n    if (state.tokens.next.value === \"each\") {\n      advance(\"each\");\n      if (!state.inMoz()) {\n        warning(\"W118\", state.tokens.curr, \"for each\");\n      }\n    }\n    advance(\"(\");\n    state.funct[\"(comparray)\"].setState(\"define\");\n    res.left = expression(context, 130);\n    if (_.includes([\"in\", \"of\"], state.tokens.next.value)) {\n      advance();\n    } else {\n      /* istanbul ignore next */\n      error(\"E045\", state.tokens.curr);\n    }\n    state.funct[\"(comparray)\"].setState(\"generate\");\n    expression(context, 10);\n\n    advance(\")\");\n    if (state.tokens.next.value === \"if\") {\n      advance(\"if\");\n      advance(\"(\");\n      state.funct[\"(comparray)\"].setState(\"filter\");\n      expression(context, 10);\n      advance(\")\");\n    }\n\n    if (!reversed) {\n      state.funct[\"(comparray)\"].setState(\"use\");\n      res.right = expression(context, 10);\n    }\n\n    advance(\"]\");\n    state.funct[\"(comparray)\"].unstack();\n    return res;\n  }\n\n  prefix(\"[\", function(context) {\n    var blocktype = lookupBlockType();\n    if (blocktype.isCompArray) {\n      if (!state.option.esnext && !state.inMoz()) {\n        warning(\"W118\", state.tokens.curr, \"array comprehension\");\n      }\n      return comprehensiveArrayExpression(context);\n    } else if (blocktype.isDestAssign) {\n      this.destructAssign = destructuringPattern(context, {\n          openingParsed: true,\n          assignment: true\n        });\n      return this;\n    }\n    var b = !sameLine(state.tokens.curr, state.tokens.next);\n    this.first = [];\n    if (b) {\n      indent += state.option.indent;\n      if (state.tokens.next.from === indent + state.option.indent) {\n        /* istanbul ignore next */\n        indent += state.option.indent;\n      }\n    }\n    while (state.tokens.next.id !== \"(end)\") {\n      while (state.tokens.next.id === \",\") {\n        if (!state.option.elision) {\n          if (!state.inES5()) {\n            // Maintain compat with old options --- ES5 mode without\n            // elision=true will warn once per comma\n            warning(\"W070\");\n          } else {\n            warning(\"W128\");\n            do {\n              advance(\",\");\n            } while (state.tokens.next.id === \",\");\n            continue;\n          }\n        }\n        advance(\",\");\n      }\n\n      if (state.tokens.next.id === \"]\") {\n        break;\n      }\n\n      spreadrest(\"spread\");\n\n      this.first.push(expression(context, 10));\n      if (state.tokens.next.id === \",\") {\n        advance(\",\");\n        checkComma({ allowTrailing: true });\n        if (state.tokens.next.id === \"]\" && !state.inES5()) {\n          warning(\"W070\", state.tokens.curr);\n          break;\n        }\n      } else {\n        if (state.option.trailingcomma && state.inES5()) {\n          warningAt(\"W140\", state.tokens.curr.line, state.tokens.curr.character);\n        }\n        break;\n      }\n    }\n    if (b) {\n      indent -= state.option.indent;\n    }\n    advance(\"]\", this);\n    return this;\n  });\n\n\n  function isMethod() {\n    return !!state.funct[\"(method)\"];\n  }\n\n  /**\n   * Retrieve the value of the next token if it is a valid LiteralPropertyName\n   * and optionally advance the parser.\n   *\n   * @param {number} context - the parsing context; see `prod-params.js` for\n   *                           more information\n   *\n   * @returns {string|undefined} - the value of the identifier, if present\n   */\n  function propertyName(context) {\n    var id = optionalidentifier(context, true);\n\n    if (!id) {\n      if (state.tokens.next.id === \"(string)\") {\n        id = state.tokens.next.value;\n        advance();\n      } else if (state.tokens.next.id === \"(number)\") {\n        id = state.tokens.next.value.toString();\n        advance();\n      }\n    }\n\n    if (id === \"hasOwnProperty\") {\n      warning(\"W001\");\n    }\n\n    return id;\n  }\n\n  /**\n   * @param {Number} context The parsing context\n   * @param {Object} [options]\n   * @param {token} [options.loneArg] The argument to the function in cases\n   *                                  where it was defined using the\n   *                                  single-argument shorthand.\n   * @param {bool} [options.parsedOpening] Whether the opening parenthesis has\n   *                                       already been parsed.\n   *\n   * @returns {{ arity: number, params: Array.<string>, isSimple: boolean }}\n   */\n  function functionparams(context, options) {\n    var next;\n    var paramsIds = [];\n    var ident;\n    var tokens = [];\n    var t;\n    var pastDefault = false;\n    var pastRest = false;\n    var arity = 0;\n    var loneArg = options && options.loneArg;\n    var hasDestructuring = false;\n\n    if (loneArg && loneArg.identifier === true) {\n      state.funct[\"(scope)\"].addParam(loneArg.value, loneArg);\n      return { arity: 1, params: [ loneArg.value ], isSimple: true };\n    }\n\n    next = state.tokens.next;\n\n    if (!options || !options.parsedOpening) {\n      advance(\"(\");\n    }\n\n    if (state.tokens.next.id === \")\") {\n      advance(\")\");\n      return;\n    }\n\n    function addParam(addParamArgs) {\n      state.funct[\"(scope)\"].addParam.apply(state.funct[\"(scope)\"], addParamArgs);\n    }\n\n    for (;;) {\n      arity++;\n      // are added to the param scope\n      var currentParams = [];\n\n      pastRest = spreadrest(\"rest\");\n\n      if (_.includes([\"{\", \"[\"], state.tokens.next.id)) {\n        hasDestructuring = true;\n        tokens = destructuringPattern(context);\n        for (t in tokens) {\n          t = tokens[t];\n          if (t.id) {\n            paramsIds.push(t.id);\n            currentParams.push([t.id, t.token]);\n          }\n        }\n      } else {\n        ident = identifier(context);\n\n        if (ident) {\n          paramsIds.push(ident);\n          currentParams.push([ident, state.tokens.curr]);\n        } else {\n          // Skip invalid parameter.\n          while (!checkPunctuators(state.tokens.next, [\",\", \")\"])) advance();\n        }\n      }\n\n      // It is valid to have a regular argument after a default argument\n      // since undefined can be used for missing parameters. Still warn as it is\n      // a possible code smell.\n      if (pastDefault) {\n        if (state.tokens.next.id !== \"=\") {\n          error(\"W138\", state.tokens.curr);\n        }\n      }\n      if (state.tokens.next.id === \"=\") {\n        if (!state.inES6()) {\n          warning(\"W119\", state.tokens.next, \"default parameters\", \"6\");\n        }\n\n        if (pastRest) {\n          error(\"E062\", state.tokens.next);\n        }\n\n        advance(\"=\");\n        pastDefault = true;\n        expression(context, 10);\n      }\n\n      // now we have evaluated the default expression, add the variable to the param scope\n      currentParams.forEach(addParam);\n      if (state.tokens.next.id === \",\") {\n        if (pastRest) {\n          warning(\"W131\", state.tokens.next);\n        }\n        advance(\",\");\n        checkComma({ allowTrailing: true });\n      }\n\n      if (state.tokens.next.id === \")\") {\n        if (state.tokens.curr.id === \",\" && !state.inES8()) {\n          warning(\"W119\", state.tokens.curr, \"Trailing comma in function parameters\", \"8\");\n        }\n\n        advance(\")\", next);\n        return {\n          arity: arity,\n          params: paramsIds,\n          isSimple: !hasDestructuring && !pastRest && !pastDefault\n        };\n      }\n    }\n  }\n\n  /**\n   * Factory function for creating objects used to track statistics of function\n   * literals.\n   *\n   * @param {string} name - the identifier name to associate with the function\n   * @param {object} [token] - token responsible for creating the function\n   *                           object\n   * @param {object} [overwrites] - a collection of properties that should\n   *                                override the corresponding default value of\n   *                                the new \"functor\" object\n   */\n  function functor(name, token, overwrites) {\n    var funct = {\n      \"(name)\"      : name,\n      \"(breakage)\"  : 0,\n      \"(loopage)\"   : 0,\n      // The strictness of the function body is tracked via a dedicated\n      // property (as opposed to via the global `state` object) so that the\n      // value can be referenced after the body has been fully parsed (i.e.\n      // when validating the identifier used in function declarations and\n      // function expressions).\n      \"(isStrict)\"  : \"unknown\",\n\n      \"(global)\"    : false,\n\n      \"(line)\"      : null,\n      \"(character)\" : null,\n      \"(metrics)\"   : null,\n      \"(statement)\" : null,\n      \"(context)\"   : null,\n      \"(scope)\"     : null,\n      \"(comparray)\" : null,\n      \"(yielded)\"   : null,\n      \"(arrow)\"     : null,\n      \"(async)\"     : null,\n      \"(params)\"    : null\n    };\n\n    if (token) {\n      _.extend(funct, {\n        \"(line)\"     : token.line,\n        \"(character)\": token.character,\n        \"(metrics)\"  : createMetrics(token)\n      });\n    }\n\n    _.extend(funct, overwrites);\n\n    if (funct[\"(context)\"]) {\n      funct[\"(scope)\"] = funct[\"(context)\"][\"(scope)\"];\n      funct[\"(comparray)\"]  = funct[\"(context)\"][\"(comparray)\"];\n    }\n\n    return funct;\n  }\n\n  /**\n   * Determine if the parser has begun parsing executable code.\n   *\n   * @param {Token} funct - The current \"functor\" token\n   *\n   * @returns {boolean}\n   */\n  function hasParsedCode(funct) {\n    return funct[\"(global)\"] && !funct[\"(verb)\"];\n  }\n\n  /**\n   * This function is used as both a null-denotation method *and* a\n   * left-denotation method, meaning the first parameter is overloaded.\n   */\n  function doTemplateLiteral(context, leftOrRbp) {\n    // ASSERT: this.type === \"(template)\"\n    // jshint validthis: true\n    var ctx = this.context;\n    var noSubst = this.noSubst;\n    var depth = this.depth;\n    var left = typeof leftOrRbp === \"number\" ? null : leftOrRbp;\n\n    if (!noSubst) {\n      while (!end()) {\n        if (!state.tokens.next.template || state.tokens.next.depth > depth) {\n          expression(context, 0); // should probably have different rbp?\n        } else {\n          // skip template start / middle\n          advance();\n        }\n      }\n    }\n\n    return {\n      id: \"(template)\",\n      type: \"(template)\",\n      tag: left\n    };\n\n    function end() {\n      if (state.tokens.curr.template && state.tokens.curr.tail &&\n          state.tokens.curr.context === ctx) {\n        /* istanbul ignore next */\n        return true;\n      }\n      var complete = (state.tokens.next.template && state.tokens.next.tail &&\n                      state.tokens.next.context === ctx);\n      if (complete) advance();\n      return complete || state.tokens.next.isUnclosed;\n    }\n  }\n\n  /**\n   * Parse a function literal.\n   *\n   * @param {Number} context The parsing context\n   * @param {Object} [options]\n   * @param {string} [options.name] The identifier belonging to the function (if\n   *                                any)\n   * @param {token} [options.statement] The statement that triggered creation\n   *                                    of the current function.\n   * @param {string} [options.type] If specified, either \"generator\" or \"arrow\"\n   * @param {token} [options.loneArg] The argument to the function in cases\n   *                                  where it was defined using the\n   *                                  single-argument shorthand\n   * @param {bool} [options.parsedOpening] Whether the opening parenthesis has\n   *                                       already been parsed\n   * @param {string} [options.classExprBinding] Define a function with this\n   *                                            identifier in the new function's\n   *                                            scope, mimicking the bahavior of\n   *                                            class expression names within\n   *                                            the body of member functions.\n   */\n  function doFunction(context, options) {\n    var f, token, name, statement, classExprBinding, isGenerator, isArrow,\n      isMethod, ignoreLoopFunc;\n    var oldOption = state.option;\n    var oldIgnored = state.ignored;\n    var isAsync = context & prodParams.preAsync;\n\n    if (options) {\n      name = options.name;\n      statement = options.statement;\n      classExprBinding = options.classExprBinding;\n      isGenerator = options.type === \"generator\";\n      isArrow = options.type === \"arrow\";\n      isMethod = options.isMethod;\n      ignoreLoopFunc = options.ignoreLoopFunc;\n    }\n\n    context &= ~prodParams.noin;\n    context &= ~prodParams.tryClause;\n\n    if (isAsync) {\n      context |= prodParams.async;\n    } else {\n      context &= ~prodParams.async;\n    }\n\n    if (isGenerator) {\n      context |= prodParams.yield;\n    } else if (!isArrow) {\n      context &= ~prodParams.yield;\n    }\n    context &= ~prodParams.preAsync;\n\n    state.option = Object.create(state.option);\n    state.ignored = Object.create(state.ignored);\n\n    state.funct = functor(name || state.nameStack.infer(), state.tokens.next, {\n      \"(statement)\": statement,\n      \"(context)\":   state.funct,\n      \"(arrow)\":     isArrow,\n      \"(method)\":    isMethod,\n      \"(async)\":     isAsync\n    });\n\n    f = state.funct;\n    token = state.tokens.curr;\n\n    functions.push(state.funct);\n\n    // So that the function is available to itself and referencing itself is not\n    // seen as a closure, add the function name to a new scope, but do not\n    // test for unused (unused: false)\n    // it is a new block scope so that params can override it, it can be block scoped\n    // but declarations inside the function don't cause already declared error\n    state.funct[\"(scope)\"].stack(\"functionouter\");\n    var internallyAccessibleName = !isMethod && (name || classExprBinding);\n    if (internallyAccessibleName) {\n      state.funct[\"(scope)\"].block.add(internallyAccessibleName,\n        classExprBinding ? \"class\" : \"function\", state.tokens.curr, false);\n    }\n\n    if (!isArrow) {\n      state.funct[\"(scope)\"].funct.add(\"arguments\", \"var\", token, false);\n    }\n\n    // create the param scope (params added in functionparams)\n    state.funct[\"(scope)\"].stack(\"functionparams\");\n\n    var paramsInfo = functionparams(context, options);\n\n    if (paramsInfo) {\n      state.funct[\"(params)\"] = paramsInfo.params;\n      state.funct[\"(hasSimpleParams)\"] = paramsInfo.isSimple;\n      state.funct[\"(metrics)\"].arity = paramsInfo.arity;\n      state.funct[\"(metrics)\"].verifyMaxParametersPerFunction();\n    } else {\n      state.funct[\"(params)\"] = [];\n      state.funct[\"(metrics)\"].arity = 0;\n      state.funct[\"(hasSimpleParams)\"] = true;\n    }\n\n    if (isArrow) {\n      context &= ~prodParams.yield;\n\n      if (!state.inES6(true)) {\n        warning(\"W119\", state.tokens.curr, \"arrow function syntax (=>)\", \"6\");\n      }\n\n      if (!options.loneArg) {\n        advance(\"=>\");\n      }\n    }\n\n    block(context, false, true, true, isArrow);\n\n    if (!state.option.noyield && isGenerator && !state.funct[\"(yielded)\"]) {\n      warning(\"W124\", state.tokens.curr);\n    }\n\n    state.funct[\"(metrics)\"].verifyMaxStatementsPerFunction();\n    state.funct[\"(metrics)\"].verifyMaxComplexityPerFunction();\n    state.funct[\"(unusedOption)\"] = state.option.unused;\n    state.option = oldOption;\n    state.ignored = oldIgnored;\n    state.funct[\"(last)\"] = state.tokens.curr.line;\n    state.funct[\"(lastcharacter)\"] = state.tokens.curr.character;\n\n    // unstack the params scope\n    state.funct[\"(scope)\"].unstack(); // also does usage and label checks\n\n    // unstack the function outer stack\n    state.funct[\"(scope)\"].unstack();\n\n    state.funct = state.funct[\"(context)\"];\n\n    if (!ignoreLoopFunc && !state.option.loopfunc && state.funct[\"(loopage)\"]) {\n      // If the function we just parsed accesses any non-local variables\n      // trigger a warning. Otherwise, the function is safe even within\n      // a loop.\n      if (f[\"(outerMutables)\"]) {\n        warning(\"W083\", token, f[\"(outerMutables)\"].join(\", \"));\n      }\n    }\n\n    return f;\n  }\n\n  function createMetrics(functionStartToken) {\n    return {\n      statementCount: 0,\n      nestedBlockDepth: -1,\n      ComplexityCount: 1,\n      arity: 0,\n\n      verifyMaxStatementsPerFunction: function() {\n        if (state.option.maxstatements &&\n          this.statementCount > state.option.maxstatements) {\n          warning(\"W071\", functionStartToken, this.statementCount);\n        }\n      },\n\n      verifyMaxParametersPerFunction: function() {\n        if (_.isNumber(state.option.maxparams) &&\n          this.arity > state.option.maxparams) {\n          warning(\"W072\", functionStartToken, this.arity);\n        }\n      },\n\n      verifyMaxNestedBlockDepthPerFunction: function() {\n        if (state.option.maxdepth &&\n          this.nestedBlockDepth > 0 &&\n          this.nestedBlockDepth === state.option.maxdepth + 1) {\n          warning(\"W073\", null, this.nestedBlockDepth);\n        }\n      },\n\n      verifyMaxComplexityPerFunction: function() {\n        var max = state.option.maxcomplexity;\n        var cc = this.ComplexityCount;\n        if (max && cc > max) {\n          warning(\"W074\", functionStartToken, cc);\n        }\n      }\n    };\n  }\n\n  function increaseComplexityCount() {\n    state.funct[\"(metrics)\"].ComplexityCount += 1;\n  }\n\n  // Parse assignments that were found instead of conditionals.\n  // For example: if (a = 1) { ... }\n\n  function checkCondAssignment(token) {\n    if (!token || token.paren) {\n      return;\n    }\n\n    if (token.id === \",\") {\n      checkCondAssignment(token.right);\n      return;\n    }\n\n    switch (token.id) {\n    case \"=\":\n    case \"+=\":\n    case \"-=\":\n    case \"*=\":\n    case \"%=\":\n    case \"&=\":\n    case \"|=\":\n    case \"^=\":\n    case \"/=\":\n      if (!state.option.boss) {\n        warning(\"W084\", token);\n      }\n    }\n  }\n\n  /**\n   * Validate the properties defined within an object literal or class body.\n   * See the `saveAccessor` and `saveProperty` functions for more detail.\n   *\n   * @param {object} props - Collection of objects describing the properties\n   *                         encountered\n   */\n  function checkProperties(props) {\n    // Check for lonely setters if in the ES5 mode.\n    if (state.inES5()) {\n      for (var name in props) {\n        if (props[name] && props[name].setterToken && !props[name].getterToken &&\n          !props[name].static) {\n          warning(\"W078\", props[name].setterToken);\n        }\n      }\n    }\n  }\n\n  function metaProperty(context, name, c) {\n    if (checkPunctuator(state.tokens.next, \".\")) {\n      var left = state.tokens.curr.id;\n      advance(\".\");\n      var id = identifier(context);\n      state.tokens.curr.isMetaProperty = true;\n      if (name !== id) {\n        error(\"E057\", state.tokens.prev, left, id);\n      } else {\n        c();\n      }\n      return state.tokens.curr;\n    }\n  }\n\n//object literals\n  (function(x) {\n    x.nud = function(context) {\n      var b, f, i, params, t, isGeneratorMethod = false, nextVal;\n      var props = Object.create(null); // All properties, including accessors\n      var isAsyncMethod = false;\n\n      b = !sameLine(state.tokens.curr, state.tokens.next);\n      if (b) {\n        indent += state.option.indent;\n        if (state.tokens.next.from === indent + state.option.indent) {\n          /* istanbul ignore next */\n          indent += state.option.indent;\n        }\n      }\n\n      var blocktype = lookupBlockType();\n      if (blocktype.isDestAssign) {\n        this.destructAssign = destructuringPattern(context, {\n            openingParsed: true,\n            assignment: true\n          });\n        return this;\n      }\n      state.inObjectBody = true;\n      for (;;) {\n        if (state.tokens.next.id === \"}\") {\n          break;\n        }\n\n        nextVal = state.tokens.next.value;\n        if (state.tokens.next.identifier &&\n            (peekIgnoreEOL().id === \",\" || peekIgnoreEOL().id === \"}\")) {\n          if (!state.inES6()) {\n            warning(\"W104\", state.tokens.next, \"object short notation\", \"6\");\n          }\n          t = expression(context, 10);\n          i = t.value;\n          saveProperty(props, i, t);\n\n        } else if (peek().id !== \":\" && (nextVal === \"get\" || nextVal === \"set\")) {\n          advance(nextVal);\n\n          if (!state.inES5()) {\n            error(\"E034\");\n          }\n\n          if (state.tokens.next.id === \"[\") {\n            i = computedPropertyName(context);\n          } else {\n            i = propertyName(context);\n\n            // ES6 allows for get() {...} and set() {...} method\n            // definition shorthand syntax, so we don't produce an error\n            // if linting ECMAScript 6 code.\n            if (!i && !state.inES6()) {\n              error(\"E035\");\n            }\n          }\n\n          // We don't want to save this getter unless it's an actual getter\n          // and not an ES6 concise method\n          if (i) {\n            saveAccessor(nextVal, props, i, state.tokens.curr);\n          }\n\n          t = state.tokens.next;\n          f = doFunction(context, { isMethod: true });\n          params = f[\"(params)\"];\n\n          // Don't warn about getter/setter pairs if this is an ES6 concise method\n          if (nextVal === \"get\" && i && params.length) {\n            warning(\"W076\", t, params[0], i);\n          } else if (nextVal === \"set\" && i && f[\"(metrics)\"].arity !== 1) {\n            warning(\"W077\", t, i);\n          }\n\n        } else if (spreadrest(\"spread\")) {\n          if (!state.inES9()) {\n            warning(\"W119\", state.tokens.next, \"object spread property\", \"9\");\n          }\n\n          expression(context, 10);\n        } else {\n          if (state.tokens.next.id === \"async\" && !checkPunctuators(peek(), [\"(\", \":\"])) {\n            if (!state.inES8()) {\n              warning(\"W119\", state.tokens.next, \"async functions\", \"8\");\n            }\n\n            isAsyncMethod = true;\n            advance();\n\n            nolinebreak(state.tokens.curr);\n          } else {\n            isAsyncMethod = false;\n          }\n\n          if (state.tokens.next.value === \"*\" && state.tokens.next.type === \"(punctuator)\") {\n            if (isAsyncMethod && !state.inES9()) {\n              warning(\"W119\", state.tokens.next, \"async generators\", \"9\");\n            } else if (!state.inES6()) {\n              warning(\"W104\", state.tokens.next, \"generator functions\", \"6\");\n            }\n\n            advance(\"*\");\n            isGeneratorMethod = true;\n          } else {\n            isGeneratorMethod = false;\n          }\n\n          if (state.tokens.next.id === \"[\") {\n            i = computedPropertyName(context);\n            state.nameStack.set(i);\n          } else {\n            state.nameStack.set(state.tokens.next);\n            i = propertyName(context);\n            saveProperty(props, i, state.tokens.next);\n\n            if (typeof i !== \"string\") {\n              break;\n            }\n          }\n\n          if (state.tokens.next.value === \"(\") {\n            if (!state.inES6()) {\n              warning(\"W104\", state.tokens.curr, \"concise methods\", \"6\");\n            }\n\n            doFunction(isAsyncMethod ? context | prodParams.preAsync : context, {\n              isMethod: true,\n              type: isGeneratorMethod ? \"generator\" : null\n            });\n          } else {\n            advance(\":\");\n            expression(context, 10);\n          }\n        }\n\n        countMember(i);\n\n        if (state.tokens.next.id === \",\") {\n          advance(\",\");\n          checkComma({ allowTrailing: true, property: true });\n          if (state.tokens.next.id === \",\") {\n            /* istanbul ignore next */\n            warning(\"W070\", state.tokens.curr);\n          } else if (state.tokens.next.id === \"}\" && !state.inES5()) {\n            warning(\"W070\", state.tokens.curr);\n          }\n        } else {\n          if (state.option.trailingcomma && state.inES5()) {\n            warningAt(\"W140\", state.tokens.curr.line, state.tokens.curr.character);\n          }\n          break;\n        }\n      }\n      if (b) {\n        indent -= state.option.indent;\n      }\n      advance(\"}\", this);\n\n      checkProperties(props);\n      state.inObjectBody = false;\n\n      return this;\n    };\n    x.fud = function() {\n      /* istanbul ignore next */\n      error(\"E036\", state.tokens.curr);\n    };\n  }(delim(\"{\")));\n\n  function destructuringPattern(context, options) {\n    var isAssignment = options && options.assignment;\n\n    context &= ~prodParams.noin;\n\n    if (!state.inES6()) {\n      warning(\"W104\", state.tokens.curr,\n        isAssignment ? \"destructuring assignment\" : \"destructuring binding\", \"6\");\n    }\n\n    return destructuringPatternRecursive(context, options);\n  }\n\n  function destructuringPatternRecursive(context, options) {\n    var ids, idx;\n    var identifiers = [];\n    var openingParsed = options && options.openingParsed;\n    var isAssignment = options && options.assignment;\n    var recursiveOptions = isAssignment ? { assignment: isAssignment } : null;\n    var firstToken = openingParsed ? state.tokens.curr : state.tokens.next;\n\n    var nextInnerDE = function() {\n      var ident;\n      if (checkPunctuators(state.tokens.next, [\"[\", \"{\"])) {\n        ids = destructuringPatternRecursive(context, recursiveOptions);\n        for (idx = 0; idx < ids.length; idx++) {\n          identifiers.push({ id: ids[idx].id, token: ids[idx].token });\n        }\n      } else if (checkPunctuator(state.tokens.next, \",\")) {\n        identifiers.push({ id: null, token: state.tokens.curr });\n      } else if (checkPunctuator(state.tokens.next, \"(\")) {\n        advance(\"(\");\n        nextInnerDE();\n        advance(\")\");\n      } else {\n        if (isAssignment) {\n          var assignTarget = expression(context, 20);\n          if (assignTarget) {\n            checkLeftSideAssign(context, assignTarget);\n\n            // if the target was a simple identifier, add it to the list to return\n            if (assignTarget.identifier) {\n              ident = assignTarget.value;\n            }\n          }\n        } else {\n          ident = identifier(context);\n        }\n        if (ident) {\n          identifiers.push({ id: ident, token: state.tokens.curr });\n        }\n      }\n    };\n\n    var assignmentProperty = function(context) {\n      var id, expr;\n\n      if (checkPunctuator(state.tokens.next, \"[\")) {\n        advance(\"[\");\n        expression(context, 10);\n        advance(\"]\");\n        advance(\":\");\n        nextInnerDE();\n      } else if (state.tokens.next.id === \"(string)\" ||\n                 state.tokens.next.id === \"(number)\") {\n        advance();\n        advance(\":\");\n        nextInnerDE();\n      } else {\n        // this id will either be the property name or the property name and the assigning identifier\n        var isRest = spreadrest(\"rest\");\n\n        if (isRest) {\n          if (!state.inES9()) {\n            warning(\"W119\", state.tokens.next, \"object rest property\", \"9\");\n          }\n\n          // Due to visual symmetry with the array rest property (and the early\n          // design of the language feature), developers may mistakenly assume\n          // any expression is valid in this position. If the next token is not\n          // an identifier, attempt to parse an expression and issue an error.\n          // order to recover more gracefully from this condition.\n          if (state.tokens.next.type === \"(identifier)\") {\n            id = identifier(context);\n          } else {\n            expr = expression(context, 10);\n            error(\"E030\", expr, expr.value);\n          }\n        } else {\n          id = identifier(context);\n        }\n\n        if (!isRest && checkPunctuator(state.tokens.next, \":\")) {\n          advance(\":\");\n          nextInnerDE();\n        } else if (id) {\n          // in this case we are assigning (not declaring), so check assignment\n          if (isAssignment) {\n            checkLeftSideAssign(context, state.tokens.curr);\n          }\n          identifiers.push({ id: id, token: state.tokens.curr });\n        }\n\n        if (isRest && checkPunctuator(state.tokens.next, \",\")) {\n          warning(\"W130\", state.tokens.next);\n        }\n      }\n    };\n\n    var id, value;\n    if (checkPunctuator(firstToken, \"[\")) {\n      if (!openingParsed) {\n        advance(\"[\");\n      }\n      if (checkPunctuator(state.tokens.next, \"]\")) {\n        warning(\"W137\", state.tokens.curr);\n      }\n      var element_after_rest = false;\n      while (!checkPunctuator(state.tokens.next, \"]\")) {\n        var isRest = spreadrest(\"rest\");\n\n        nextInnerDE();\n\n        if (isRest && !element_after_rest &&\n            checkPunctuator(state.tokens.next, \",\")) {\n          warning(\"W130\", state.tokens.next);\n          element_after_rest = true;\n        }\n        if (!isRest && checkPunctuator(state.tokens.next, \"=\")) {\n          if (checkPunctuator(state.tokens.prev, \"...\")) {\n            /* istanbul ignore next */\n            advance(\"]\");\n          } else {\n            advance(\"=\");\n          }\n          id = state.tokens.prev;\n          value = expression(context, 10);\n          if (value && value.identifier && value.value === \"undefined\") {\n            warning(\"W080\", id, id.value);\n          }\n        }\n        if (!checkPunctuator(state.tokens.next, \"]\")) {\n          advance(\",\");\n        }\n      }\n      advance(\"]\");\n    } else if (checkPunctuator(firstToken, \"{\")) {\n\n      if (!openingParsed) {\n        advance(\"{\");\n      }\n      if (checkPunctuator(state.tokens.next, \"}\")) {\n        warning(\"W137\", state.tokens.curr);\n      }\n      while (!checkPunctuator(state.tokens.next, \"}\")) {\n        assignmentProperty(context);\n        if (checkPunctuator(state.tokens.next, \"=\")) {\n          advance(\"=\");\n          id = state.tokens.prev;\n          value = expression(context, 10);\n          if (value && value.identifier && value.value === \"undefined\") {\n            warning(\"W080\", id, id.value);\n          }\n        }\n        if (!checkPunctuator(state.tokens.next, \"}\")) {\n          advance(\",\");\n          if (checkPunctuator(state.tokens.next, \"}\")) {\n            // Trailing comma\n            // ObjectBindingPattern: { BindingPropertyList , }\n            break;\n          }\n        }\n      }\n      advance(\"}\");\n    }\n    return identifiers;\n  }\n\n  function destructuringPatternMatch(tokens, value) {\n    var first = value.first;\n\n    if (!first)\n      return;\n\n    _.zip(tokens, Array.isArray(first) ? first : [ first ]).forEach(function(val) {\n      var token = val[0];\n      var value = val[1];\n\n      if (token && value)\n        token.first = value;\n      else if (token && token.first && !value)\n        /* istanbul ignore next */\n        warning(\"W080\", token.first, token.first.value);\n    });\n  }\n\n  function blockVariableStatement(type, statement, context) {\n    // used for both let and const statements\n\n    var noin = context & prodParams.noin;\n    var isLet = type === \"let\";\n    var isConst = type === \"const\";\n    var tokens, lone, value, letblock;\n\n    if (!state.inES6()) {\n      warning(\"W104\", state.tokens.curr, type, \"6\");\n    }\n\n    if (isLet && isMozillaLet()) {\n      advance(\"(\");\n      state.funct[\"(scope)\"].stack();\n      letblock = true;\n      statement.declaration = false;\n    }\n\n    statement.first = [];\n    for (;;) {\n      var names = [];\n      if (_.includes([\"{\", \"[\"], state.tokens.next.value)) {\n        tokens = destructuringPattern(context);\n        lone = false;\n      } else {\n        tokens = [ { id: identifier(context), token: state.tokens.curr } ];\n        lone = true;\n      }\n\n      // A `const` declaration without an initializer is permissible within the\n      // head of for-in and for-of statements. If this binding list is being\n      // parsed as part of a `for` statement of any kind, allow the initializer\n      // to be omitted. Although this may erroneously allow such forms from\n      // \"C-style\" `for` statements (i.e. `for (const x;;) {}`, the `for`\n      // statement logic includes dedicated logic to issue the error for such\n      // cases.\n      if (!noin && isConst && state.tokens.next.id !== \"=\") {\n        warning(\"E012\", state.tokens.curr, state.tokens.curr.value);\n      }\n\n      for (var t in tokens) {\n        if (tokens.hasOwnProperty(t)) {\n          t = tokens[t];\n\n          // It is a Syntax Error if the BoundNames of BindingList contains\n          // \"let\".\n          if (t.id === \"let\") {\n            /* istanbul ignore next */\n            warning(\"W024\", t.token, t.id);\n          }\n\n          if (state.funct[\"(scope)\"].block.isGlobal()) {\n            if (predefined[t.id] === false) {\n              warning(\"W079\", t.token, t.id);\n            }\n          }\n          if (t.id) {\n            state.funct[\"(scope)\"].addbinding(t.id, {\n              type: type,\n              token: t.token });\n            names.push(t.token);\n          }\n        }\n      }\n\n      if (state.tokens.next.id === \"=\") {\n        statement.hasInitializer = true;\n\n        advance(\"=\");\n        if (!noin && peek(0).id === \"=\" && state.tokens.next.identifier) {\n          warning(\"W120\", state.tokens.next, state.tokens.next.value);\n        }\n        var id = state.tokens.prev;\n        value = expression(context, 10);\n        if (value) {\n          if (value.identifier && value.value === \"undefined\") {\n            warning(\"W080\", id, id.value);\n          }\n          if (!lone) {\n            destructuringPatternMatch(names, value);\n          }\n        }\n      }\n\n      // Bindings are not immediately initialized in for-in and for-of\n      // statements. As with `const` initializers (described above), the `for`\n      // statement parsing logic includes\n      if (state.tokens.next.value !== \"in\" && state.tokens.next.value !== \"of\") {\n        for (t in tokens) {\n          if (tokens.hasOwnProperty(t)) {\n            t = tokens[t];\n            state.funct[\"(scope)\"].initialize(t.id);\n          }\n        }\n      }\n\n      statement.first = statement.first.concat(names);\n\n      if (state.tokens.next.id !== \",\") {\n        break;\n      }\n\n      statement.hasComma = true;\n      advance(\",\");\n      checkComma();\n    }\n    if (letblock) {\n      advance(\")\");\n      block(context, true, true);\n      statement.block = true;\n      state.funct[\"(scope)\"].unstack();\n    }\n\n    return statement;\n  }\n\n  var conststatement = stmt(\"const\", function(context) {\n    return blockVariableStatement(\"const\", this, context);\n  });\n  conststatement.exps = true;\n  conststatement.declaration = true;\n\n\n  /**\n   * Determine if the current `let` token designates the beginning of a \"let\n   * block\" or \"let expression\" as implemented in the Mozilla SpiderMonkey\n   * engine.\n   *\n   * This function will only return `true` if Mozilla extensions have been\n   * enabled. It would be preferable to detect the language feature regardless\n   * of the parser's state because this would allow JSHint to instruct users to\n   * enable the `moz` option where necessary. This is not possible because the\n   * language extension is not compatible with standard JavaScript. For\n   * example, the following program code may describe a \"let block\" or a\n   * function invocation:\n   *\n   *     let(x)\n   *     {\n   *       typeof x;\n   *     }\n   *\n   * @returns {boolean}\n   */\n  function isMozillaLet() {\n    return state.tokens.next.id === \"(\" && state.inMoz();\n  }\n  var letstatement = stmt(\"let\", function(context) {\n    return blockVariableStatement(\"let\", this, context);\n  });\n  letstatement.nud = function(context, rbp) {\n    if (isMozillaLet()) {\n      // create a new block scope we use only for the current expression\n      state.funct[\"(scope)\"].stack();\n      advance(\"(\");\n      state.tokens.prev.fud(context);\n      advance(\")\");\n      expression(context, rbp);\n      state.funct[\"(scope)\"].unstack();\n    } else {\n      this.exps = false;\n      return state.syntax[\"(identifier)\"].nud.apply(this, arguments);\n    }\n  };\n  letstatement.meta = { es5: true, isFutureReservedWord: false, strictOnly: true };\n  letstatement.exps = true;\n  letstatement.declaration = true;\n  letstatement.useFud = function(context) {\n    var next = state.tokens.next;\n    var nextIsBindingName;\n\n    if (this.line !== next.line && !state.inES6()) {\n      return false;\n    }\n\n    // JSHint generally interprets `let` as a reserved word even though it is\n    // not considered as such by the ECMAScript specification because doing so\n    // simplifies parsing logic. It is special-cased here so that code such as\n    //\n    //     let\n    //     let\n    //\n    // is correctly interpreted as an invalid LexicalBinding. (Without this\n    // consideration, the code above would be parsed as two\n    // IdentifierReferences.)\n    nextIsBindingName = next.identifier && (!isReserved(context, next) ||\n      next.id === \"let\");\n\n    return nextIsBindingName || checkPunctuators(next, [\"{\", \"[\"]) ||\n      isMozillaLet();\n  };\n\n  var varstatement = stmt(\"var\", function(context) {\n    var noin = context & prodParams.noin;\n    var tokens, lone, value, id;\n\n    this.first = [];\n    for (;;) {\n      var names = [];\n      if (_.includes([\"{\", \"[\"], state.tokens.next.value)) {\n        tokens = destructuringPattern(context);\n        lone = false;\n      } else {\n        tokens = [];\n        id = identifier(context);\n\n        if (id) {\n          tokens.push({ id: id, token: state.tokens.curr });\n        }\n\n        lone = true;\n      }\n\n      if (state.option.varstmt) {\n        warning(\"W132\", this);\n      }\n\n\n      for (var t in tokens) {\n        if (tokens.hasOwnProperty(t)) {\n          t = tokens[t];\n          if (state.funct[\"(global)\"] && !state.impliedClosure()) {\n            if (predefined[t.id] === false) {\n              warning(\"W079\", t.token, t.id);\n            } else if (state.option.futurehostile === false) {\n              if ((!state.inES5() && vars.ecmaIdentifiers[5][t.id] === false) ||\n                (!state.inES6() && vars.ecmaIdentifiers[6][t.id] === false)) {\n                warning(\"W129\", t.token, t.id);\n              }\n            }\n          }\n          if (t.id) {\n            state.funct[\"(scope)\"].addbinding(t.id, {\n              type: \"var\",\n              token: t.token });\n\n            names.push(t.token);\n          }\n        }\n      }\n\n      if (state.tokens.next.id === \"=\") {\n        this.hasInitializer = true;\n\n        state.nameStack.set(state.tokens.curr);\n\n        advance(\"=\");\n        if (peek(0).id === \"=\" && state.tokens.next.identifier) {\n          if (!noin &&\n              !state.funct[\"(params)\"] ||\n              state.funct[\"(params)\"].indexOf(state.tokens.next.value) === -1) {\n            warning(\"W120\", state.tokens.next, state.tokens.next.value);\n          }\n        }\n        id = state.tokens.prev;\n        value = expression(context, 10);\n        if (value) {\n          if (!state.funct[\"(loopage)\"] && value.identifier &&\n            value.value === \"undefined\") {\n            warning(\"W080\", id, id.value);\n          }\n          if (!lone) {\n            destructuringPatternMatch(names, value);\n          }\n        }\n      }\n\n      this.first = this.first.concat(names);\n\n      if (state.tokens.next.id !== \",\") {\n        break;\n      }\n      this.hasComma = true;\n      advance(\",\");\n      checkComma();\n    }\n\n    return this;\n  });\n  varstatement.exps = true;\n\n  blockstmt(\"function\", function(context) {\n    var inexport = context & prodParams.export;\n    var generator = false;\n    var isAsync = context & prodParams.preAsync;\n    var labelType = \"\";\n\n    if (isAsync) {\n      labelType = \"async \";\n    }\n\n    if (state.tokens.next.value === \"*\") {\n      if (isAsync && !state.inES9()) {\n        warning(\"W119\", state.tokens.prev, \"async generators\", \"9\");\n      } else if (!isAsync && !state.inES6(true)) {\n        warning(\"W119\", state.tokens.next, \"function*\", \"6\");\n      }\n\n      advance(\"*\");\n      labelType += \"generator \";\n      generator = true;\n    }\n\n    labelType += \"function\";\n\n    if (inblock) {\n      warning(\"W082\", state.tokens.curr);\n    }\n    this.name = optionalidentifier(context) ? state.tokens.curr : null;\n\n    if (!this.name) {\n      if (!inexport) {\n        warning(\"W025\");\n      }\n    } else {\n      state.funct[\"(scope)\"].addbinding(this.name.value, {\n        type: labelType,\n        token: state.tokens.curr,\n        initialized: true });\n    }\n\n    var f = doFunction(context, {\n      name: this.name && this.name.value,\n      statement: this,\n      type: generator ? \"generator\" : null,\n      ignoreLoopFunc: inblock // a declaration may already have warned\n    });\n\n    // If the function declaration is strict because the surrounding code is\n    // strict, the invalid name will trigger E008 when the scope manager\n    // attempts to create a binding in the strict environment record. An error\n    // should only be signaled here when the function itself enables strict\n    // mode (the scope manager will not report an error because a declaration\n    // does not introduce a binding into the function's environment record).\n    var enablesStrictMode = f[\"(isStrict)\"] && !state.isStrict();\n    if (this.name && (f[\"(name)\"] === \"arguments\" || f[\"(name)\"] === \"eval\") &&\n      enablesStrictMode) {\n      error(\"E008\", this.name);\n    }\n\n    // Although the parser correctly recognizes the statement boundary in this\n    // condition, it's support for the invalid \"empty grouping\" expression\n    // makes it tolerant of productions such as `function f() {}();`.\n    if (state.tokens.next.id === \"(\" && peek().id === \")\" && peek(1).id !== \"=>\" &&\n      state.tokens.next.line === state.tokens.curr.line) {\n      error(\"E039\");\n    }\n    return this;\n  }).declaration = true;\n\n  prefix(\"function\", function(context) {\n    var generator = false;\n    var isAsync = context & prodParams.preAsync;\n\n    if (state.tokens.next.value === \"*\") {\n      if (isAsync && !state.inES9()) {\n        warning(\"W119\", state.tokens.prev, \"async generators\", \"9\");\n      } else if (!isAsync && !state.inES6(true)) {\n        warning(\"W119\", state.tokens.curr, \"function*\", \"6\");\n      }\n\n      advance(\"*\");\n      generator = true;\n    }\n\n    // This context modification restricts the use of `await` as the optional\n    // BindingIdentifier in async function expressions.\n    this.name = optionalidentifier(isAsync ? context | prodParams.async : context) ?\n      state.tokens.curr : null;\n\n    var f = doFunction(context, {\n      name: this.name && this.name.value,\n      type: generator ? \"generator\" : null\n    });\n\n    if (generator && this.name && this.name.value === \"yield\") {\n      error(\"E024\", this.name, \"yield\");\n    }\n\n    if (this.name && (f[\"(name)\"] === \"arguments\" || f[\"(name)\"] === \"eval\") &&\n      f[\"(isStrict)\"]) {\n      error(\"E008\", this.name);\n    }\n\n    return this;\n  });\n\n  blockstmt(\"if\", function(context) {\n    var t = state.tokens.next;\n    increaseComplexityCount();\n    advance(\"(\");\n    var expr = expression(context, 0);\n\n    if (!expr) {\n      quit(\"E041\", this);\n    }\n\n    checkCondAssignment(expr);\n\n    // When the if is within a for-in loop, check if the condition\n    // starts with a negation operator\n    var forinifcheck = null;\n    if (state.option.forin && state.forinifcheckneeded) {\n      state.forinifcheckneeded = false; // We only need to analyze the first if inside the loop\n      forinifcheck = state.forinifchecks[state.forinifchecks.length - 1];\n      if (expr.type === \"(punctuator)\" && expr.value === \"!\") {\n        forinifcheck.type = \"(negative)\";\n      } else {\n        forinifcheck.type = \"(positive)\";\n      }\n    }\n\n    advance(\")\", t);\n    var s = block(context, true, true);\n\n    // When the if is within a for-in loop and the condition has a negative form,\n    // check if the body contains nothing but a continue statement\n    if (forinifcheck && forinifcheck.type === \"(negative)\") {\n      if (s && s[0] && s[0].type === \"(identifier)\" && s[0].value === \"continue\") {\n        forinifcheck.type = \"(negative-with-continue)\";\n      }\n    }\n\n    if (state.tokens.next.id === \"else\") {\n      advance(\"else\");\n      if (state.tokens.next.id === \"if\" || state.tokens.next.id === \"switch\") {\n        statement(context);\n      } else {\n        block(context, true, true);\n      }\n    }\n    return this;\n  });\n\n  blockstmt(\"try\", function(context) {\n    var b;\n    var hasParameter = false;\n\n    function catchParameter() {\n      advance(\"(\");\n\n      if (checkPunctuators(state.tokens.next, [\"[\", \"{\"])) {\n        var tokens = destructuringPattern(context);\n        _.each(tokens, function(token) {\n          if (token.id) {\n            state.funct[\"(scope)\"].addParam(token.id, token.token, \"exception\");\n          }\n        });\n      } else if (state.tokens.next.type !== \"(identifier)\") {\n        warning(\"E030\", state.tokens.next, state.tokens.next.value);\n      } else {\n        // only advance if an identifier is present. This allows JSHint to\n        // recover from the case where no value is specified.\n        state.funct[\"(scope)\"].addParam(identifier(context), state.tokens.curr, \"exception\");\n      }\n\n      if (state.tokens.next.value === \"if\") {\n        if (!state.inMoz()) {\n          warning(\"W118\", state.tokens.curr, \"catch filter\");\n        }\n        advance(\"if\");\n        expression(context, 0);\n      }\n\n      advance(\")\");\n    }\n\n    block(context | prodParams.tryClause, true);\n\n    while (state.tokens.next.id === \"catch\") {\n      increaseComplexityCount();\n      if (b && (!state.inMoz())) {\n        warning(\"W118\", state.tokens.next, \"multiple catch blocks\");\n      }\n      advance(\"catch\");\n      if (state.tokens.next.id !== \"{\") {\n        state.funct[\"(scope)\"].stack(\"catchparams\");\n        hasParameter = true;\n        catchParameter();\n      } else if (!state.inES10()) {\n        warning(\"W119\", state.tokens.curr, \"optional catch binding\", \"10\");\n      }\n      block(context, false);\n\n      if (hasParameter) {\n        state.funct[\"(scope)\"].unstack();\n        hasParameter = false;\n      }\n      b = true;\n    }\n\n    if (state.tokens.next.id === \"finally\") {\n      advance(\"finally\");\n      block(context, true);\n      return;\n    }\n\n    if (!b) {\n      error(\"E021\", state.tokens.next, \"catch\", state.tokens.next.value);\n    }\n\n    return this;\n  });\n\n  blockstmt(\"while\", function(context) {\n    var t = state.tokens.next;\n    state.funct[\"(breakage)\"] += 1;\n    state.funct[\"(loopage)\"] += 1;\n    increaseComplexityCount();\n    advance(\"(\");\n    checkCondAssignment(expression(context, 0));\n    advance(\")\", t);\n    block(context, true, true);\n    state.funct[\"(breakage)\"] -= 1;\n    state.funct[\"(loopage)\"] -= 1;\n    return this;\n  }).labelled = true;\n\n  blockstmt(\"with\", function(context) {\n    var t = state.tokens.next;\n    if (state.isStrict()) {\n      error(\"E010\", state.tokens.curr);\n    } else if (!state.option.withstmt) {\n      warning(\"W085\", state.tokens.curr);\n    }\n\n    advance(\"(\");\n    expression(context, 0);\n    advance(\")\", t);\n    block(context, true, true);\n\n    return this;\n  });\n\n  blockstmt(\"switch\", function(context) {\n    var t = state.tokens.next;\n    var g = false;\n    var noindent = false;\n    var seenCase = false;\n\n    state.funct[\"(breakage)\"] += 1;\n    advance(\"(\");\n    checkCondAssignment(expression(context, 0));\n    advance(\")\", t);\n    t = state.tokens.next;\n    advance(\"{\");\n    state.funct[\"(scope)\"].stack();\n\n    if (state.tokens.next.from === indent)\n      noindent = true;\n\n    if (!noindent)\n      indent += state.option.indent;\n\n    for (;;) {\n      switch (state.tokens.next.id) {\n      case \"case\":\n        switch (state.funct[\"(verb)\"]) {\n        case \"yield\":\n        case \"break\":\n        case \"case\":\n        case \"continue\":\n        case \"return\":\n        case \"switch\":\n        case \"throw\":\n          break;\n        case \"default\":\n          if (state.option.leanswitch) {\n            warning(\"W145\", state.tokens.next);\n          }\n\n          break;\n        default:\n          // You can tell JSHint that you don't use break intentionally by\n          // adding a comment /* falls through */ on a line just before\n          // the next `case`.\n          if (!state.tokens.curr.caseFallsThrough) {\n            warning(\"W086\", state.tokens.curr, \"case\");\n          }\n        }\n\n        advance(\"case\");\n        expression(context, 0);\n        seenCase = true;\n        increaseComplexityCount();\n        g = true;\n        advance(\":\");\n        state.funct[\"(verb)\"] = \"case\";\n        break;\n      case \"default\":\n        switch (state.funct[\"(verb)\"]) {\n        case \"yield\":\n        case \"break\":\n        case \"continue\":\n        case \"return\":\n        case \"throw\":\n          break;\n        case \"case\":\n          if (state.option.leanswitch) {\n            warning(\"W145\", state.tokens.curr);\n          }\n\n          break;\n        default:\n          // Do not display a warning if 'default' is the first statement or if\n          // there is a special /* falls through */ comment.\n          if (seenCase && !state.tokens.curr.caseFallsThrough) {\n            warning(\"W086\", state.tokens.curr, \"default\");\n          }\n        }\n\n        advance(\"default\");\n        g = true;\n        advance(\":\");\n        state.funct[\"(verb)\"] = \"default\";\n        break;\n      case \"}\":\n        if (!noindent)\n          indent -= state.option.indent;\n\n        advance(\"}\", t);\n        state.funct[\"(scope)\"].unstack();\n        state.funct[\"(breakage)\"] -= 1;\n        state.funct[\"(verb)\"] = undefined;\n        return;\n      /* istanbul ignore next */\n      case \"(end)\":\n        error(\"E023\", state.tokens.next, \"}\");\n        return;\n      default:\n        indent += state.option.indent;\n        if (g) {\n          switch (state.tokens.curr.id) {\n          /* istanbul ignore next */\n          case \",\":\n            error(\"E040\");\n            return;\n          case \":\":\n            g = false;\n            statements(context);\n            break;\n          /* istanbul ignore next */\n          default:\n            error(\"E025\", state.tokens.curr);\n            return;\n          }\n        } else {\n          /* istanbul ignore else */\n          if (state.tokens.curr.id === \":\") {\n            advance(\":\");\n            error(\"E024\", state.tokens.curr, \":\");\n            statements(context);\n          } else {\n            error(\"E021\", state.tokens.next, \"case\", state.tokens.next.value);\n            return;\n          }\n        }\n        indent -= state.option.indent;\n      }\n    }\n  }).labelled = true;\n\n  stmt(\"debugger\", function() {\n    if (!state.option.debug) {\n      warning(\"W087\", this);\n    }\n    return this;\n  }).exps = true;\n\n  (function() {\n    var x = stmt(\"do\", function(context) {\n      state.funct[\"(breakage)\"] += 1;\n      state.funct[\"(loopage)\"] += 1;\n      increaseComplexityCount();\n\n      this.first = block(context, true, true);\n      advance(\"while\");\n      var t = state.tokens.next;\n      advance(\"(\");\n      checkCondAssignment(expression(context, 0));\n      advance(\")\", t);\n      state.funct[\"(breakage)\"] -= 1;\n      state.funct[\"(loopage)\"] -= 1;\n      return this;\n    });\n    x.labelled = true;\n    x.exps = true;\n  }());\n\n  blockstmt(\"for\", function(context) {\n    var s, t = state.tokens.next;\n    var letscope = false;\n    var isAsync = false;\n    var foreachtok = null;\n\n    if (t.value === \"each\") {\n      foreachtok = t;\n      advance(\"each\");\n      if (!state.inMoz()) {\n        warning(\"W118\", state.tokens.curr, \"for each\");\n      }\n    }\n\n    if (state.tokens.next.identifier && state.tokens.next.value === \"await\") {\n      advance(\"await\");\n      isAsync = true;\n\n      if (!(context & prodParams.async)) {\n        error(\"E024\", state.tokens.curr, \"await\");\n      } else if (!state.inES9()) {\n        warning(\"W119\", state.tokens.curr, \"asynchronous iteration\", \"9\");\n      }\n    }\n\n    increaseComplexityCount();\n    advance(\"(\");\n\n    // what kind of for(…) statement it is? for(…of…)? for(…in…)? for(…;…;…)?\n    var nextop; // contains the token of the \"in\" or \"of\" operator\n    var comma; // First comma punctuator at level 0\n    var initializer; // First initializer at level 0\n    var bindingPower;\n    var targets;\n    var target;\n    var decl;\n    var afterNext = peek();\n\n    var headContext = context | prodParams.noin;\n\n    if (state.tokens.next.id === \"var\") {\n      advance(\"var\");\n      decl = state.tokens.curr.fud(headContext);\n      comma = decl.hasComma ? decl : null;\n      initializer = decl.hasInitializer ? decl : null;\n    } else if (state.tokens.next.id === \"const\" ||\n      // The \"let\" keyword only signals a lexical binding if it is followed by\n      // an identifier, `{`, or `[`. Otherwise, it should be parsed as an\n      // IdentifierReference (i.e. in a subsquent branch).\n      (state.tokens.next.id === \"let\" &&\n        ((afterNext.identifier && afterNext.id !== \"in\") ||\n         checkPunctuators(afterNext, [\"{\", \"[\"])))) {\n      advance(state.tokens.next.id);\n      // create a new block scope\n      letscope = true;\n      state.funct[\"(scope)\"].stack();\n      decl = state.tokens.curr.fud(headContext);\n      comma = decl.hasComma ? decl : null;\n      initializer = decl.hasInitializer ? decl : null;\n    } else if (!checkPunctuator(state.tokens.next, \";\")) {\n      targets = [];\n\n      while (state.tokens.next.value !== \"in\" &&\n        state.tokens.next.value !== \"of\" &&\n        !checkPunctuator(state.tokens.next, \";\")) {\n\n        if (checkPunctuators(state.tokens.next, [\"{\", \"[\"])) {\n          destructuringPattern(headContext, { assignment: true })\n            .forEach(function(elem) {\n              this.push(elem.token);\n            }, targets);\n          if (checkPunctuator(state.tokens.next, \"=\")) {\n            advance(\"=\");\n            initializer = state.tokens.curr;\n            expression(headContext, 10);\n          }\n        } else {\n          target = expression(headContext, 10);\n\n          if (target) {\n            if (target.type === \"(identifier)\") {\n              targets.push(target);\n            } else if (checkPunctuator(target, \"=\")) {\n              initializer = target;\n              targets.push(target);\n            }\n          }\n        }\n\n        if (checkPunctuator(state.tokens.next, \",\")) {\n          advance(\",\");\n\n          if (!comma) {\n            comma = state.tokens.curr;\n          }\n        }\n      }\n\n      //checkLeftSideAssign(target, nextop);\n\n      // In the event of a syntax error, do not issue warnings regarding the\n      // implicit creation of bindings.\n      if (!initializer && !comma) {\n        targets.forEach(function(token) {\n          if (!state.funct[\"(scope)\"].has(token.value)) {\n            warning(\"W088\", token, token.value);\n          }\n        });\n      }\n    }\n\n    nextop = state.tokens.next;\n\n    if (isAsync && nextop.value !== \"of\") {\n      error(\"E066\", nextop);\n    }\n\n    // if we're in a for (… in|of …) statement\n    if (_.includes([\"in\", \"of\"], nextop.value)) {\n      if (nextop.value === \"of\") {\n        bindingPower = 20;\n\n        if (!state.inES6()) {\n          warning(\"W104\", nextop, \"for of\", \"6\");\n        }\n      } else {\n        bindingPower = 0;\n      }\n      if (comma) {\n        error(\"W133\", comma, nextop.value, \"more than one ForBinding\");\n      }\n      if (initializer) {\n        error(\"W133\", initializer, nextop.value, \"initializer is forbidden\");\n      }\n      if (target && !comma && !initializer) {\n        checkLeftSideAssign(context, target, nextop);\n      }\n\n      advance(nextop.value);\n\n      // The binding power is variable because for-in statements accept any\n      // Expression in this position, while for-of statements are limited to\n      // AssignmentExpressions. For example:\n      //\n      //     for ( LeftHandSideExpression in Expression ) Statement\n      //     for ( LeftHandSideExpression of AssignmentExpression ) Statement\n      expression(context, bindingPower);\n      advance(\")\", t);\n\n      if (nextop.value === \"in\" && state.option.forin) {\n        state.forinifcheckneeded = true;\n\n        if (state.forinifchecks === undefined) {\n          state.forinifchecks = [];\n        }\n\n        // Push a new for-in-if check onto the stack. The type will be modified\n        // when the loop's body is parsed and a suitable if statement exists.\n        state.forinifchecks.push({\n          type: \"(none)\"\n        });\n      }\n\n      state.funct[\"(breakage)\"] += 1;\n      state.funct[\"(loopage)\"] += 1;\n\n      s = block(context, true, true);\n\n      if (nextop.value === \"in\" && state.option.forin) {\n        if (state.forinifchecks && state.forinifchecks.length > 0) {\n          var check = state.forinifchecks.pop();\n\n          if (// No if statement or not the first statement in loop body\n              s && s.length > 0 && (typeof s[0] !== \"object\" || s[0].value !== \"if\") ||\n              // Positive if statement is not the only one in loop body\n              check.type === \"(positive)\" && s.length > 1 ||\n              // Negative if statement but no continue\n              check.type === \"(negative)\") {\n            warning(\"W089\", this);\n          }\n        }\n\n        // Reset the flag in case no if statement was contained in the loop body\n        state.forinifcheckneeded = false;\n      }\n\n      state.funct[\"(breakage)\"] -= 1;\n      state.funct[\"(loopage)\"] -= 1;\n\n    } else {\n      if (foreachtok) {\n        error(\"E045\", foreachtok);\n      }\n\n      advance(\";\");\n      if (decl && decl.first && decl.first[0]) {\n        if (decl.value === \"const\"  && !decl.hasInitializer) {\n          warning(\"E012\", decl, decl.first[0].value);\n        }\n\n        decl.first.forEach(function(token) {\n          state.funct[\"(scope)\"].initialize(token.value);\n        });\n      }\n\n      // start loopage after the first ; as the next two expressions are executed\n      // on every loop\n      state.funct[\"(loopage)\"] += 1;\n      if (state.tokens.next.id !== \";\") {\n        checkCondAssignment(expression(context, 0));\n      }\n\n      advance(\";\");\n      if (state.tokens.next.id === \";\") {\n        error(\"E021\", state.tokens.next, \")\", \";\");\n      }\n      if (state.tokens.next.id !== \")\") {\n        for (;;) {\n          expression(context, 0);\n          if (state.tokens.next.id !== \",\") {\n            break;\n          }\n          advance(\",\");\n          checkComma();\n        }\n      }\n      advance(\")\", t);\n      state.funct[\"(breakage)\"] += 1;\n      block(context, true, true);\n      state.funct[\"(breakage)\"] -= 1;\n      state.funct[\"(loopage)\"] -= 1;\n    }\n\n    // unstack loop blockscope\n    if (letscope) {\n      state.funct[\"(scope)\"].unstack();\n    }\n    return this;\n  }).labelled = true;\n\n\n  stmt(\"break\", function() {\n    var v = state.tokens.next.value;\n\n    if (state.tokens.next.identifier &&\n        sameLine(state.tokens.curr, state.tokens.next)) {\n      if (!state.funct[\"(scope)\"].funct.hasLabel(v)) {\n        warning(\"W090\", state.tokens.next, v);\n      }\n      this.first = state.tokens.next;\n      advance();\n    } else {\n      if (state.funct[\"(breakage)\"] === 0)\n        warning(\"W052\", state.tokens.next, this.value);\n    }\n\n    reachable(this);\n\n    return this;\n  }).exps = true;\n\n\n  stmt(\"continue\", function() {\n    var v = state.tokens.next.value;\n\n    if (state.funct[\"(breakage)\"] === 0 || !state.funct[\"(loopage)\"]) {\n      warning(\"W052\", state.tokens.next, this.value);\n    }\n\n    if (state.tokens.next.identifier) {\n      if (sameLine(state.tokens.curr, state.tokens.next)) {\n        if (!state.funct[\"(scope)\"].funct.hasLabel(v)) {\n          warning(\"W090\", state.tokens.next, v);\n        }\n        this.first = state.tokens.next;\n        advance();\n      }\n    }\n\n    reachable(this);\n\n    return this;\n  }).exps = true;\n\n\n  stmt(\"return\", function(context) {\n    if (sameLine(this, state.tokens.next)) {\n      if (state.tokens.next.id !== \";\" && !state.tokens.next.reach) {\n        this.first = expression(context, 0);\n\n        if (this.first &&\n            this.first.type === \"(punctuator)\" && this.first.value === \"=\" &&\n            !this.first.paren && !state.option.boss) {\n          warning(\"W093\", this.first);\n        }\n\n        if (state.option.noreturnawait && context & prodParams.async &&\n            !(context & prodParams.tryClause) &&\n            this.first.identifier && this.first.value === \"await\") {\n          warning(\"W146\", this.first);\n        }\n      }\n    } else {\n      if (state.tokens.next.type === \"(punctuator)\" &&\n        [\"[\", \"{\", \"+\", \"-\"].indexOf(state.tokens.next.value) > -1) {\n        nolinebreak(this); // always warn (Line breaking error)\n      }\n    }\n\n    reachable(this);\n\n    return this;\n  }).exps = true;\n\n  prefix(\"await\", function(context) {\n    if (context & prodParams.async) {\n      // If the parameters of the current function scope have not been defined,\n      // it is because the current expression is contained within the parameter\n      // list.\n      if (!state.funct[\"(params)\"]) {\n        error(\"E024\", this, \"await\");\n      }\n\n      expression(context, 10);\n      return this;\n    } else {\n      this.exps = false;\n      return state.syntax[\"(identifier)\"].nud.apply(this, arguments);\n    }\n  }).exps = true;\n\n  (function(asyncSymbol) {\n    asyncSymbol.meta = { es5: true, isFutureReservedWord: true, strictOnly: true };\n    asyncSymbol.isFunc = function() {\n      var next = state.tokens.next;\n      var afterParens;\n\n      if (this.line !== next.line) {\n        return false;\n      }\n\n      if (next.id === \"function\") {\n        return true;\n      }\n\n      if (next.id === \"(\") {\n        afterParens = peekThroughParens(0);\n\n        return afterParens.id === \"=>\";\n      }\n\n      if (next.identifier) {\n        return peek().id === \"=>\";\n      }\n\n      return false;\n    };\n    asyncSymbol.useFud = asyncSymbol.isFunc;\n    // async function declaration\n    asyncSymbol.fud = function(context) {\n      if (!state.inES8()) {\n        warning(\"W119\", this, \"async functions\", \"8\");\n      }\n      context |= prodParams.preAsync;\n      context |= prodParams.initial;\n      this.func = expression(context, 0);\n      this.block = this.func.block;\n      this.exps = this.func.exps;\n      return this;\n    };\n    asyncSymbol.exps = true;\n    delete asyncSymbol.reserved;\n  }(prefix(\"async\", function(context, rbp) {\n    if (this.isFunc(context)) {\n      if (!state.inES8()) {\n        warning(\"W119\", this, \"async functions\", \"8\");\n      }\n\n      context |= prodParams.preAsync;\n      this.func = expression(context, rbp);\n      this.identifier = false;\n      return this;\n    }\n\n    this.exps = false;\n    return state.syntax[\"(identifier)\"].nud.apply(this, arguments);\n  })));\n\n  (function(yieldSymbol) {\n    yieldSymbol.rbp = yieldSymbol.lbp = 25;\n    yieldSymbol.exps = true;\n  })(prefix(\"yield\", function(context) {\n    if (state.inMoz()) {\n      return mozYield.call(this, context);\n    }\n\n    if (!(context & prodParams.yield)) {\n      this.exps = false;\n      return state.syntax[\"(identifier)\"].nud.apply(this, arguments);\n    }\n\n    var prev = state.tokens.prev;\n\n    // If the parameters of the current function scope have not been defined,\n    // it is because the current expression is contained within the parameter\n    // list.\n    if (!state.funct[\"(params)\"]) {\n      error(\"E024\", this, \"yield\");\n    }\n\n    if (!this.beginsStmt && prev.lbp > 30 && !checkPunctuators(prev, [\"(\"])) {\n      error(\"E061\", this);\n    }\n\n    if (!state.inES6()) {\n      warning(\"W104\", state.tokens.curr, \"yield\", \"6\");\n    }\n    state.funct[\"(yielded)\"] = true;\n\n    if (state.tokens.next.value === \"*\") {\n      advance(\"*\");\n    }\n\n    // Parse operand\n    if (state.tokens.curr.value === \"*\" || sameLine(state.tokens.curr, state.tokens.next)) {\n      if (state.tokens.next.nud) {\n\n        nobreaknonadjacent(state.tokens.curr, state.tokens.next);\n        this.first = expression(context, 10);\n\n        if (this.first.type === \"(punctuator)\" && this.first.value === \"=\" &&\n            !this.first.paren && !state.option.boss) {\n          warning(\"W093\", this.first);\n        }\n      } else if (state.tokens.next.led) {\n        if (state.tokens.next.id !== \",\") {\n          error(\"W017\", state.tokens.next);\n        }\n      }\n    }\n\n    return this;\n  }));\n\n  /**\n   * Parsing logic for non-standard Mozilla implementation of `yield`\n   * expressions.\n   */\n  var mozYield = function(context) {\n    var prev = state.tokens.prev;\n    if (state.inES6(true) && !(context & prodParams.yield)) {\n      error(\"E046\", state.tokens.curr, \"yield\");\n    }\n    state.funct[\"(yielded)\"] = true;\n    var delegatingYield = false;\n\n    if (state.tokens.next.value === \"*\") {\n      delegatingYield = true;\n      advance(\"*\");\n    }\n\n    if (sameLine(this, state.tokens.next)) {\n      if (delegatingYield ||\n          (state.tokens.next.id !== \";\" && !state.option.asi &&\n           !state.tokens.next.reach && state.tokens.next.nud)) {\n\n        nobreaknonadjacent(state.tokens.curr, state.tokens.next);\n        this.first = expression(context, 10);\n\n        if (this.first.type === \"(punctuator)\" && this.first.value === \"=\" &&\n            !this.first.paren && !state.option.boss) {\n          warning(\"W093\", this.first);\n        }\n      }\n      if (state.tokens.next.id !== \")\" &&\n          (prev.lbp > 30 || (!prev.assign && !isEndOfExpr()))) {\n        error(\"E050\", this);\n      }\n    } else if (!state.option.asi) {\n      nolinebreak(this); // always warn (Line breaking error)\n    }\n    return this;\n  };\n\n  stmt(\"throw\", function(context) {\n    nolinebreak(this);\n    this.first = expression(context, 20);\n\n    reachable(this);\n\n    return this;\n  }).exps = true;\n\n  prefix(\"import\", function(context) {\n    var mp = metaProperty(context, \"meta\", function() {\n      if (!state.inES11(true)) {\n        warning(\"W119\", state.tokens.prev, \"import.meta\", \"11\");\n      }\n      if (!state.option.module) {\n        error(\"E070\", state.tokens.prev);\n      }\n    });\n\n    if (mp) {\n      return mp;\n    }\n\n    if (!checkPunctuator(state.tokens.next, \"(\")) {\n      return state.syntax[\"(identifier)\"].nud.call(this, context);\n    }\n\n    if (!state.inES11()) {\n      warning(\"W119\", state.tokens.curr, \"dynamic import\", \"11\");\n    }\n\n    advance(\"(\");\n    expression(context, 10);\n    advance(\")\");\n    return this;\n  });\n\n  var importSymbol = stmt(\"import\", function(context) {\n    if (!state.funct[\"(scope)\"].block.isGlobal()) {\n      error(\"E053\", state.tokens.curr, \"Import\");\n    }\n\n    if (!state.inES6()) {\n      warning(\"W119\", state.tokens.curr, \"import\", \"6\");\n    }\n\n    if (state.tokens.next.type === \"(string)\") {\n      // ModuleSpecifier :: StringLiteral\n      advance(\"(string)\");\n      return this;\n    }\n\n    if (state.tokens.next.identifier) {\n      // ImportClause :: ImportedDefaultBinding\n      this.name = identifier(context);\n      // Import bindings are immutable (see ES6 8.1.1.5.5)\n      state.funct[\"(scope)\"].addbinding(this.name, {\n        type: \"import\",\n        initialized: true,\n        token: state.tokens.curr });\n\n      if (state.tokens.next.value === \",\") {\n        // ImportClause :: ImportedDefaultBinding , NameSpaceImport\n        // ImportClause :: ImportedDefaultBinding , NamedImports\n        advance(\",\");\n        // At this point, we intentionally fall through to continue matching\n        // either NameSpaceImport or NamedImports.\n        // Discussion:\n        // https://github.com/jshint/jshint/pull/2144#discussion_r23978406\n      } else {\n        advance(\"from\");\n        advance(\"(string)\");\n        return this;\n      }\n    }\n\n    if (state.tokens.next.id === \"*\") {\n      // ImportClause :: NameSpaceImport\n      advance(\"*\");\n      advance(\"as\");\n      if (state.tokens.next.identifier) {\n        this.name = identifier(context);\n        // Import bindings are immutable (see ES6 8.1.1.5.5)\n        state.funct[\"(scope)\"].addbinding(this.name, {\n          type: \"import\",\n          initialized: true,\n          token: state.tokens.curr });\n      }\n    } else {\n      // ImportClause :: NamedImports\n      advance(\"{\");\n      for (;;) {\n        if (state.tokens.next.value === \"}\") {\n          advance(\"}\");\n          break;\n        }\n        var importName;\n        if (peek().value === \"as\") {\n          identifier(context, true);\n          advance(\"as\");\n          importName = identifier(context);\n        } else {\n          importName = identifier(context);\n        }\n\n        // Import bindings are immutable (see ES6 8.1.1.5.5)\n        state.funct[\"(scope)\"].addbinding(importName, {\n          type: \"import\",\n          initialized: true,\n          token: state.tokens.curr });\n\n        if (state.tokens.next.value === \",\") {\n          advance(\",\");\n        } else if (state.tokens.next.value === \"}\") {\n          advance(\"}\");\n          break;\n        } else {\n          error(\"E024\", state.tokens.next, state.tokens.next.value);\n          break;\n        }\n      }\n    }\n\n    // FromClause\n    advance(\"from\");\n    advance(\"(string)\");\n\n    // Support for ES2015 modules was released without warning for `import`\n    // declarations that lack bindings. Issuing a warning would therefor\n    // constitute a breaking change.\n    // TODO: enable this warning in JSHint 3\n    // if (hasBindings) {\n    //   warning(\"W142\", this, \"import\", moduleSpecifier);\n    // }\n\n    return this;\n  });\n  importSymbol.exps = true;\n  importSymbol.reserved = true;\n  importSymbol.meta = { isFutureReservedWord: true, es5: true };\n  importSymbol.useFud = function() {\n    return !(checkPunctuators(state.tokens.next, [\".\", \"(\"]));\n  };\n  importSymbol.rbp = 161;\n\n  stmt(\"export\", function(context) {\n    var ok = true;\n    var token;\n    var moduleSpecifier;\n    context = context | prodParams.export;\n\n    if (!state.inES6()) {\n      warning(\"W119\", state.tokens.curr, \"export\", \"6\");\n      ok = false;\n    }\n\n    if (!state.funct[\"(scope)\"].block.isGlobal()) {\n      error(\"E053\", state.tokens.curr, \"Export\");\n      ok = false;\n    }\n\n    if (state.tokens.next.value === \"*\") {\n      // ExportDeclaration :: export * FromClause\n      // ExportDeclaration :: export * as IdentifierName FromClause\n      advance(\"*\");\n\n      if (state.tokens.next.value === \"as\") {\n        if (!state.inES11()) {\n          warning(\"W119\", state.tokens.curr, \"export * as ns from\", \"11\");\n        }\n        advance(\"as\");\n        identifier(context, true);\n        state.funct[\"(scope)\"].setExported(null, state.tokens.curr);\n      }\n\n      advance(\"from\");\n      advance(\"(string)\");\n      return this;\n    }\n\n    if (state.tokens.next.type === \"default\") {\n      // ExportDeclaration ::\n      //      export default [lookahead ∉ { function, class }] AssignmentExpression[In] ;\n      //      export default HoistableDeclaration\n      //      export default ClassDeclaration\n\n      // because the 'name' of a default-exported function is, confusingly, 'default'\n      // see https://bocoup.com/blog/whats-in-a-function-name\n      state.nameStack.set(state.tokens.next);\n\n      advance(\"default\");\n      var def = state.tokens.curr;\n      var exportType = state.tokens.next.id;\n      if (exportType === \"function\") {\n        this.block = true;\n        advance(\"function\");\n        token = state.syntax[\"function\"].fud(context);\n        state.funct[\"(scope)\"].setExported(token.name, def);\n      } else if (exportType === \"async\" && peek().id === \"function\") {\n        this.block = true;\n        advance(\"async\");\n        advance(\"function\");\n        token = state.syntax[\"function\"].fud(context | prodParams.preAsync);\n        state.funct[\"(scope)\"].setExported(token.name, def);\n      } else if (exportType === \"class\") {\n        this.block = true;\n        advance(\"class\");\n        token = state.syntax[\"class\"].fud(context);\n        state.funct[\"(scope)\"].setExported(token.name, def);\n      } else {\n        expression(context, 10);\n        state.funct[\"(scope)\"].setExported(null, def);\n      }\n      return this;\n    }\n    if (state.tokens.next.value === \"{\") {\n      // ExportDeclaration :: export ExportClause\n      advance(\"{\");\n      var exportedTokens = [];\n      while (!checkPunctuator(state.tokens.next, \"}\")) {\n        if (!state.tokens.next.identifier) {\n          /* istanbul ignore next */\n          error(\"E030\", state.tokens.next, state.tokens.next.value);\n        }\n        advance();\n\n        if (state.tokens.next.value === \"as\") {\n          advance(\"as\");\n          if (!state.tokens.next.identifier) {\n            /* istanbul ignore next */\n            error(\"E030\", state.tokens.next, state.tokens.next.value);\n          }\n          exportedTokens.push({\n            local: state.tokens.prev,\n            export: state.tokens.next\n          });\n          advance();\n        } else {\n          exportedTokens.push({\n            local: state.tokens.curr,\n            export: state.tokens.curr\n          });\n        }\n\n        if (!checkPunctuator(state.tokens.next, \"}\")) {\n          advance(\",\");\n        }\n      }\n      advance(\"}\");\n      if (state.tokens.next.value === \"from\") {\n        // ExportDeclaration :: export ExportClause FromClause\n        advance(\"from\");\n        moduleSpecifier = state.tokens.next;\n        advance(\"(string)\");\n      } else if (ok) {\n        exportedTokens.forEach(function(x) {\n          state.funct[\"(scope)\"].setExported(x.local, x.export);\n        });\n      }\n\n      if (exportedTokens.length === 0) {\n        if (moduleSpecifier) {\n          warning(\"W142\", this, \"export\", moduleSpecifier.value);\n        } else {\n          warning(\"W141\", this, \"export\");\n        }\n      }\n\n      return this;\n    } else if (state.tokens.next.id === \"var\") {\n      // ExportDeclaration :: export VariableStatement\n      advance(\"var\");\n      token = state.tokens.curr.fud(context);\n      token.first.forEach(function(binding) {\n        state.funct[\"(scope)\"].setExported(binding, binding);\n      });\n    } else if (state.tokens.next.id === \"let\") {\n      // ExportDeclaration :: export VariableStatement\n      advance(\"let\");\n      token = state.tokens.curr.fud(context);\n      token.first.forEach(function(binding) {\n        state.funct[\"(scope)\"].setExported(binding, binding);\n      });\n    } else if (state.tokens.next.id === \"const\") {\n      // ExportDeclaration :: export VariableStatement\n      advance(\"const\");\n      token = state.tokens.curr.fud(context);\n      token.first.forEach(function(binding) {\n        state.funct[\"(scope)\"].setExported(binding, binding);\n      });\n    } else if (state.tokens.next.id === \"function\") {\n      // ExportDeclaration :: export Declaration\n      this.block = true;\n      advance(\"function\");\n      token = state.syntax[\"function\"].fud(context);\n      state.funct[\"(scope)\"].setExported(token.name, token.name);\n    } else if (state.tokens.next.id === \"async\" && peek().id === \"function\") {\n      // ExportDeclaration :: export Declaration\n      this.block = true;\n      advance(\"async\");\n      advance(\"function\");\n      token = state.syntax[\"function\"].fud(context | prodParams.preAsync);\n      state.funct[\"(scope)\"].setExported(token.name, token.name);\n    } else if (state.tokens.next.id === \"class\") {\n      // ExportDeclaration :: export Declaration\n      this.block = true;\n      advance(\"class\");\n      token = state.syntax[\"class\"].fud(context);\n      state.funct[\"(scope)\"].setExported(token.name, token.name);\n    } else {\n      /* istanbul ignore next */\n      error(\"E024\", state.tokens.next, state.tokens.next.value);\n    }\n\n    return this;\n  }).exps = true;\n\n  /**\n   * Determine if SuperCall or SuperProperty may be used in the current context\n   * (as described by the provided \"functor\" object).\n   *\n   * @param {string} type - one of \"property\" or \"call\"\n   * @param {object} funct - a \"functor\" object describing the current function\n   *                         context\n   *\n   * @returns {boolean}\n   */\n  function supportsSuper(type, funct) {\n    if (type === \"call\" && funct[\"(async)\"]) {\n      return false;\n    }\n\n    if (type === \"property\" && funct[\"(method)\"]) {\n      return true;\n    }\n\n    if (type === \"call\" && funct[\"(statement)\"] &&\n      funct[\"(statement)\"].id === \"class\") {\n      return true;\n    }\n\n    if (funct[\"(arrow)\"]) {\n      return supportsSuper(type, funct[\"(context)\"]);\n    }\n\n    return false;\n  }\n\n  var superNud = function() {\n    var next = state.tokens.next;\n\n    if (checkPunctuators(next, [\"[\", \".\"])) {\n      if (!supportsSuper(\"property\", state.funct)) {\n        error(\"E063\", this);\n      }\n    } else if (checkPunctuator(next, \"(\")) {\n      if (!supportsSuper(\"call\", state.funct)) {\n        error(\"E064\", this);\n      }\n    } else {\n      error(\"E024\", next, next.value || next.id);\n    }\n\n    return this;\n  };\n\n  // Future Reserved Words\n\n  FutureReservedWord(\"abstract\");\n  FutureReservedWord(\"boolean\");\n  FutureReservedWord(\"byte\");\n  FutureReservedWord(\"char\");\n  FutureReservedWord(\"double\");\n  FutureReservedWord(\"enum\", { es5: true });\n  FutureReservedWord(\"export\", { es5: true });\n  FutureReservedWord(\"extends\", { es5: true });\n  FutureReservedWord(\"final\");\n  FutureReservedWord(\"float\");\n  FutureReservedWord(\"goto\");\n  FutureReservedWord(\"implements\", { es5: true, strictOnly: true });\n  FutureReservedWord(\"int\");\n  FutureReservedWord(\"interface\", { es5: true, strictOnly: true });\n  FutureReservedWord(\"long\");\n  FutureReservedWord(\"native\");\n  FutureReservedWord(\"package\", { es5: true, strictOnly: true });\n  FutureReservedWord(\"private\", { es5: true, strictOnly: true });\n  FutureReservedWord(\"protected\", { es5: true, strictOnly: true });\n  FutureReservedWord(\"public\", { es5: true, strictOnly: true });\n  FutureReservedWord(\"short\");\n  FutureReservedWord(\"static\", { es5: true, strictOnly: true });\n  FutureReservedWord(\"synchronized\");\n  FutureReservedWord(\"transient\");\n  FutureReservedWord(\"volatile\");\n\n  // this function is used to determine whether a squarebracket or a curlybracket\n  // expression is a comprehension array, destructuring assignment or a json value.\n\n  var lookupBlockType = function() {\n    var pn, pn1, prev;\n    var i = -1;\n    var bracketStack = 0;\n    var ret = {};\n    if (checkPunctuators(state.tokens.curr, [\"[\", \"{\"])) {\n      bracketStack += 1;\n    }\n    do {\n      prev = i === -1 ? state.tokens.curr : pn;\n      pn = i === -1 ? state.tokens.next : peek(i);\n      pn1 = peek(i + 1);\n      i = i + 1;\n      if (checkPunctuators(pn, [\"[\", \"{\"])) {\n        bracketStack += 1;\n      } else if (checkPunctuators(pn, [\"]\", \"}\"])) {\n        bracketStack -= 1;\n      }\n      if (bracketStack === 1 && pn.identifier && pn.value === \"for\" &&\n          !checkPunctuator(prev, \".\")) {\n        ret.isCompArray = true;\n        ret.notJson = true;\n        break;\n      }\n      if (bracketStack === 0 && checkPunctuators(pn, [\"}\", \"]\"])) {\n        if (pn1.value === \"=\") {\n          ret.isDestAssign = true;\n          ret.notJson = true;\n          break;\n        } else if (pn1.value === \".\") {\n          ret.notJson = true;\n          break;\n        }\n      }\n      if (checkPunctuator(pn, \";\")) {\n        ret.notJson = true;\n      }\n    } while (bracketStack > 0 && pn.id !== \"(end)\");\n    return ret;\n  };\n\n  /**\n   * Update an object used to track property names within object initializers\n   * and class bodies. Produce warnings in response to duplicated names.\n   *\n   * @param {object} props - a collection of all properties of the object or\n   *                         class to which the current property is being\n   *                         assigned\n   * @param {string} name - the property name\n   * @param {object} tkn - the token defining the property\n   * @param {boolean} [isClass] - whether the accessor is part of an ES6 Class\n   *                              definition\n   * @param {boolean} [isStatic] - whether the accessor is a static method\n   * @param {boolean} [isComputed] - whether the property is a computed expression like [Symbol.iterator]\n   */\n  function saveProperty(props, name, tkn, isClass, isStatic, isComputed) {\n    if (tkn.identifier) {\n      name = tkn.value;\n    }\n    var key = name;\n    if (isClass && isStatic) {\n      key = \"static \" + name;\n    }\n\n    if (props[key] && name !== \"__proto__\" && !isComputed) {\n      var msg = [\"key\", \"class method\", \"static class method\"];\n      msg = msg[(isClass || false) + (isStatic || false)];\n      warning(\"W075\", state.tokens.next, msg, name);\n    } else {\n      props[key] = Object.create(null);\n    }\n\n    props[key].basic = true;\n    props[key].basictkn = tkn;\n  }\n\n  /**\n   * Update an object used to track property names within object initializers\n   * and class bodies. Produce warnings in response to duplicated names.\n   *\n   * @param {string} accessorType - Either \"get\" or \"set\"\n   * @param {object} props - a collection of all properties of the object or\n   *                         class to which the current accessor is being\n   *                         assigned\n   * @param {object} tkn - the identifier token representing the accessor name\n   * @param {boolean} [isClass] - whether the accessor is part of an ES6 Class\n   *                              definition\n   * @param {boolean} [isStatic] - whether the accessor is a static method\n   */\n  function saveAccessor(accessorType, props, name, tkn, isClass, isStatic) {\n    var flagName = accessorType === \"get\" ? \"getterToken\" : \"setterToken\";\n    var key = name;\n    state.tokens.curr.accessorType = accessorType;\n    state.nameStack.set(tkn);\n    if (isClass && isStatic) {\n      key = \"static \" + name;\n    }\n\n    if (props[key]) {\n      if ((props[key].basic || props[key][flagName]) && name !== \"__proto__\") {\n        var msg = \"\";\n        if (isClass) {\n          if (isStatic) {\n            msg += \"static \";\n          }\n          msg += accessorType + \"ter method\";\n        } else {\n          msg = \"key\";\n        }\n        warning(\"W075\", state.tokens.next, msg, name);\n      }\n    } else {\n      props[key] = Object.create(null);\n    }\n\n    props[key][flagName] = tkn;\n    if (isStatic) {\n      props[key].static = true;\n    }\n  }\n\n  /**\n   * Parse a computed property name within object initializers and class bodies\n   * as introduced by ES2015. For example:\n   *\n   *     void {\n   *       [object.method()]: null\n   *     };\n   *\n   * @param {number} context - the parsing context\n   *\n   * @returns {object} - the token value that describes the expression which\n   *                     defines the property name\n   */\n  function computedPropertyName(context) {\n    advance(\"[\");\n\n    // Explicitly reclassify token as a delimeter to prevent its later\n    // interpretation as an \"infix\" operator.\n    state.tokens.curr.delim = true;\n    state.tokens.curr.lbp = 0;\n\n    if (!state.inES6()) {\n      warning(\"W119\", state.tokens.curr, \"computed property names\", \"6\");\n    }\n    var value = expression(context & ~prodParams.noin, 10);\n    advance(\"]\");\n    return value;\n  }\n\n  /**\n   * Test whether a given token is a punctuator whose `value` property matches\n   * one of the specified values. This function explicitly verifies the token's\n   * `type` property so that like-valued string literals (e.g. `\";\"`) do not\n   * produce false positives.\n   *\n   * @param {Token} token\n   * @param {Array.<string>} values\n   *\n   * @returns {boolean}\n   */\n  function checkPunctuators(token, values) {\n    if (token.type === \"(punctuator)\") {\n      return _.includes(values, token.value);\n    }\n    return false;\n  }\n\n  /**\n   * Test whether a given token is a punctuator whose `value` property matches\n   * the specified value. This function explicitly verifies the token's `type`\n   * property so that like-valued string literals (e.g. `\";\"`) do not produce\n   * false positives.\n   *\n   * @param {Token} token\n   * @param {string} value\n   *\n   * @returns {boolean}\n   */\n  function checkPunctuator(token, value) {\n    return token.type === \"(punctuator)\" && token.value === value;\n  }\n\n  // Check whether this function has been reached for a destructuring assign with undeclared values\n  function destructuringAssignOrJsonValue(context) {\n    // lookup for the assignment (ECMAScript 6 only)\n    // if it has semicolons, it is a block, so go parse it as a block\n    // or it's not a block, but there are assignments, check for undeclared variables\n\n    var block = lookupBlockType();\n    if (block.notJson) {\n      if (!state.inES6() && block.isDestAssign) {\n        /* istanbul ignore next */\n        warning(\"W104\", state.tokens.curr, \"destructuring assignment\", \"6\");\n      }\n      statements(context);\n    // otherwise parse json value\n    } else {\n      state.option.laxbreak = true;\n      state.jsonMode = true;\n      jsonValue();\n    }\n  }\n\n  /**\n   * Parse and define the three states of a list comprehension in order to\n   * avoid defining global variables, but keeping them to the list\n   * comprehension scope only. The order of the states are as follows:\n   *\n   * - \"use\" - which will be the returned iterative part of the list\n   *   comprehension\n   * - \"define\" - which will define the variables local to the list\n   *   comprehension\n   * - \"filter\" - which will help filter out values\n   */\n  var arrayComprehension = function() {\n    var CompArray = function() {\n      this.mode = \"use\";\n      this.variables = [];\n    };\n    var _carrays = [];\n    var _current;\n    function declare(v) {\n      var l = _current.variables.filter(function(elt) {\n        // if it has, change its undef state\n        if (elt.value === v) {\n          elt.undef = false;\n          return v;\n        }\n      }).length;\n      return l !== 0;\n    }\n    function use(v) {\n      var l = _current.variables.filter(function(elt) {\n        // and if it has been defined\n        if (elt.value === v && !elt.undef) {\n          if (elt.unused === true) {\n            elt.unused = false;\n          }\n          return v;\n        }\n      }).length;\n      // otherwise we warn about it\n      return (l === 0);\n    }\n    return { stack: function() {\n          _current = new CompArray();\n          _carrays.push(_current);\n        },\n        unstack: function() {\n          _current.variables.filter(function(v) {\n            if (v.unused)\n              warning(\"W098\", v.token, v.token.raw_text || v.value);\n            if (v.undef)\n              state.funct[\"(scope)\"].block.use(v.value, v.token);\n          });\n          _carrays.splice(-1, 1);\n          _current = _carrays[_carrays.length - 1];\n        },\n        setState: function(s) {\n          if (_.includes([\"use\", \"define\", \"generate\", \"filter\"], s))\n            _current.mode = s;\n        },\n        check: function(v) {\n          if (!_current) {\n            return;\n          }\n          // When we are in \"use\" state of the list comp, we enqueue that var\n          if (_current && _current.mode === \"use\") {\n            if (use(v)) {\n              _current.variables.push({\n                token: state.tokens.curr,\n                value: v,\n                undef: true,\n                unused: false\n              });\n            }\n            return true;\n          // When we are in \"define\" state of the list comp,\n          } else if (_current && _current.mode === \"define\") {\n            // check if the variable has been used previously\n            if (!declare(v)) {\n              _current.variables.push({\n                token: state.tokens.curr,\n                value: v,\n                undef: false,\n                unused: true\n              });\n            }\n            return true;\n          // When we are in the \"generate\" state of the list comp,\n          } else if (_current && _current.mode === \"generate\") {\n            state.funct[\"(scope)\"].block.use(v, state.tokens.curr);\n            return true;\n          // When we are in \"filter\" state,\n          } else if (_current && _current.mode === \"filter\") {\n            // we check whether current variable has been declared\n            if (use(v)) {\n              // if not we warn about it\n              /* istanbul ignore next */\n              state.funct[\"(scope)\"].block.use(v, state.tokens.curr);\n            }\n            return true;\n          }\n          /* istanbul ignore next */\n          return false;\n        }\n        };\n  };\n\n\n  /**\n   * Parse input according to the JSON format.\n   *\n   * http://json.org/\n   */\n  function jsonValue() {\n    function jsonObject() {\n      var o = {}, t = state.tokens.next;\n      advance(\"{\");\n      if (state.tokens.next.id !== \"}\") {\n        for (;;) {\n          if (state.tokens.next.id === \"(end)\") {\n            error(\"E026\", state.tokens.next, t.line);\n          } else if (state.tokens.next.id === \"}\") {\n            warning(\"W094\", state.tokens.curr);\n            break;\n          } else if (state.tokens.next.id === \",\") {\n            error(\"E028\", state.tokens.next);\n          } else if (state.tokens.next.id !== \"(string)\") {\n            warning(\"W095\", state.tokens.next, state.tokens.next.value);\n          }\n          if (o[state.tokens.next.value] === true) {\n            warning(\"W075\", state.tokens.next, \"key\", state.tokens.next.value);\n          } else if ((state.tokens.next.value === \"__proto__\" &&\n            !state.option.proto) || (state.tokens.next.value === \"__iterator__\" &&\n            !state.option.iterator)) {\n            warning(\"W096\", state.tokens.next, state.tokens.next.value);\n          } else {\n            o[state.tokens.next.value] = true;\n          }\n          advance();\n          advance(\":\");\n          jsonValue();\n          if (state.tokens.next.id !== \",\") {\n            break;\n          }\n          advance(\",\");\n        }\n      }\n      advance(\"}\");\n    }\n\n    function jsonArray() {\n      var t = state.tokens.next;\n      advance(\"[\");\n      if (state.tokens.next.id !== \"]\") {\n        for (;;) {\n          if (state.tokens.next.id === \"(end)\") {\n            error(\"E027\", state.tokens.next, t.line);\n          } else if (state.tokens.next.id === \"]\") {\n            warning(\"W094\", state.tokens.curr);\n            break;\n          } else if (state.tokens.next.id === \",\") {\n            error(\"E028\", state.tokens.next);\n          }\n          jsonValue();\n          if (state.tokens.next.id !== \",\") {\n            break;\n          }\n          advance(\",\");\n        }\n      }\n      advance(\"]\");\n    }\n\n    switch (state.tokens.next.id) {\n    case \"{\":\n      jsonObject();\n      break;\n    case \"[\":\n      jsonArray();\n      break;\n    case \"true\":\n    case \"false\":\n    case \"null\":\n    case \"(number)\":\n    case \"(string)\":\n      advance();\n      break;\n    case \"-\":\n      advance(\"-\");\n      advance(\"(number)\");\n      break;\n    default:\n      error(\"E003\", state.tokens.next);\n    }\n  }\n\n  /**\n   * Lint dynamically-evaluated code, appending any resulting errors/warnings\n   * into the global `errors` array.\n   *\n   * @param {array} internals - collection of \"internals\" objects describing\n   *                            string tokens that contain evaluated code\n   * @param {object} options - linting options to apply\n   * @param {object} globals - globally-defined bindings for the evaluated code\n   */\n  function lintEvalCode(internals, options, globals) {\n    var priorErrorCount, idx, jdx, internal;\n\n    for (idx = 0; idx < internals.length; idx += 1) {\n      internal = internals[idx];\n      options.scope = internal.elem;\n      priorErrorCount = JSHINT.errors.length;\n\n      itself(internal.code, options, globals);\n\n      for (jdx = priorErrorCount; jdx < JSHINT.errors.length; jdx += 1) {\n        JSHINT.errors[jdx].line += internal.token.line - 1;\n      }\n    }\n  }\n\n  var escapeRegex = function(str) {\n    return str.replace(/[-\\/\\\\^$*+?.()|[\\]{}]/g, \"\\\\$&\");\n  };\n\n  // The actual JSHINT function itself.\n  var itself = function(s, o, g) {\n    var x, reIgnoreStr, reIgnore;\n    var optionKeys, newOptionObj, newIgnoredObj;\n\n    o = _.clone(o);\n    state.reset();\n    newOptionObj = state.option;\n    newIgnoredObj = state.ignored;\n\n    if (o && o.scope) {\n      JSHINT.scope = o.scope;\n    } else {\n      JSHINT.errors = [];\n      JSHINT.internals = [];\n      JSHINT.blacklist = {};\n      JSHINT.scope = \"(main)\";\n    }\n\n    predefined = Object.create(null);\n    combine(predefined, vars.ecmaIdentifiers[3]);\n    combine(predefined, vars.reservedVars);\n\n    declared = Object.create(null);\n    var exported = Object.create(null); // Variables that live outside the current file\n\n    function each(obj, cb) {\n      if (!obj)\n        return;\n\n      if (!Array.isArray(obj) && typeof obj === \"object\")\n        obj = Object.keys(obj);\n\n      obj.forEach(cb);\n    }\n\n    if (o) {\n\n      each([o.predef, o.globals], function(dict) {\n        each(dict, function(item) {\n          var slice, prop;\n\n          if (item[0] === \"-\") {\n            slice = item.slice(1);\n            JSHINT.blacklist[slice] = slice;\n            // remove from predefined if there\n            delete predefined[slice];\n          } else {\n            prop = Object.getOwnPropertyDescriptor(dict, item);\n            predefined[item] = prop ? prop.value : false;\n          }\n        });\n      });\n\n      each(o.exported || null, function(item) {\n        exported[item] = true;\n      });\n\n      delete o.predef;\n      delete o.exported;\n\n      optionKeys = Object.keys(o);\n      for (x = 0; x < optionKeys.length; x++) {\n        if (/^-W\\d{3}$/g.test(optionKeys[x])) {\n          newIgnoredObj[optionKeys[x].slice(1)] = true;\n        } else {\n          var optionKey = optionKeys[x];\n          newOptionObj[optionKey] = o[optionKey];\n        }\n      }\n    }\n\n    state.option = newOptionObj;\n    state.ignored = newIgnoredObj;\n\n    state.option.indent = state.option.indent || 4;\n    state.option.maxerr = state.option.maxerr || 50;\n\n    indent = 1;\n\n    var scopeManagerInst = scopeManager(state, predefined, exported, declared);\n    scopeManagerInst.on(\"warning\", function(ev) {\n      warning.apply(null, [ ev.code, ev.token].concat(ev.data));\n    });\n\n    scopeManagerInst.on(\"error\", function(ev) {\n      /* istanbul ignore next */\n      error.apply(null, [ ev.code, ev.token ].concat(ev.data));\n    });\n\n    state.funct = functor(\"(global)\", null, {\n      \"(global)\"    : true,\n      \"(scope)\"     : scopeManagerInst,\n      \"(comparray)\" : arrayComprehension(),\n      \"(metrics)\"   : createMetrics(state.tokens.next)\n    });\n\n    functions = [state.funct];\n    member = {};\n    membersOnly = null;\n    inblock = false;\n    lookahead = [];\n\n    if (!isString(s) && !Array.isArray(s)) {\n      errorAt(\"E004\", 0);\n      return false;\n    }\n\n    api = {\n      get isJSON() {\n        /* istanbul ignore next */\n        return state.jsonMode;\n      },\n\n      getOption: function(name) {\n        return state.option[name] || null;\n      },\n\n      getCache: function(name) {\n        return state.cache[name];\n      },\n\n      setCache: function(name, value) {\n        state.cache[name] = value;\n      },\n\n      warn: function(code, data) {\n        warningAt.apply(null, [ code, data.line, data.char ].concat(data.data));\n      },\n\n      on: function(names, listener) {\n        names.split(\" \").forEach(function(name) {\n          emitter.on(name, listener);\n        }.bind(this));\n      }\n    };\n\n    emitter.removeAllListeners();\n    (extraModules || []).forEach(function(func) {\n      func(api);\n    });\n\n    state.tokens.prev = state.tokens.curr = state.tokens.next = state.syntax[\"(begin)\"];\n    if (o && o.ignoreDelimiters) {\n\n      if (!Array.isArray(o.ignoreDelimiters)) {\n        /* istanbul ignore next */\n        o.ignoreDelimiters = [o.ignoreDelimiters];\n      }\n\n      o.ignoreDelimiters.forEach(function(delimiterPair) {\n        if (!delimiterPair.start || !delimiterPair.end)\n            return;\n\n        reIgnoreStr = escapeRegex(delimiterPair.start) +\n                      \"[\\\\s\\\\S]*?\" +\n                      escapeRegex(delimiterPair.end);\n\n        reIgnore = new RegExp(reIgnoreStr, \"ig\");\n\n        s = s.replace(reIgnore, function(match) {\n          return match.replace(/./g, \" \");\n        });\n      });\n    }\n\n    lex = new Lexer(s);\n\n    lex.on(\"warning\", function(ev) {\n      warningAt.apply(null, [ ev.code, ev.line, ev.character].concat(ev.data));\n    });\n\n    lex.on(\"error\", function(ev) {\n      errorAt.apply(null, [ ev.code, ev.line, ev.character ].concat(ev.data));\n    });\n\n    lex.on(\"fatal\", function(ev) {\n      quit(\"E041\", ev);\n    });\n\n    lex.on(\"Identifier\", function(ev) {\n      emitter.emit(\"Identifier\", ev);\n    });\n\n    lex.on(\"String\", function(ev) {\n      emitter.emit(\"String\", ev);\n    });\n\n    lex.on(\"Number\", function(ev) {\n      emitter.emit(\"Number\", ev);\n    });\n\n    // Check options\n    var name;\n    for (name in o) {\n      if (_.has(o, name)) {\n        checkOption(name, true, state.tokens.curr);\n      }\n    }\n    if (o) {\n      for (name in o.unstable) {\n        if (_.has(o.unstable, name)) {\n          checkOption(name, false, state.tokens.curr);\n        }\n      }\n    }\n\n    try {\n      applyOptions();\n\n      // combine the passed globals after we've assumed all our options\n      combine(predefined, g || {});\n\n      //reset values\n      checkComma.first = true;\n\n      advance();\n      switch (state.tokens.next.id) {\n      case \"{\":\n      case \"[\":\n        destructuringAssignOrJsonValue(0);\n        break;\n      default:\n        directives();\n\n        if (state.directive[\"use strict\"]) {\n          if (!state.allowsGlobalUsd()) {\n            warning(\"W097\", state.directive[\"use strict\"]);\n          }\n        }\n\n        statements(0);\n      }\n\n      if (state.tokens.next.id !== \"(end)\") {\n        quit(\"E041\", state.tokens.curr);\n      }\n\n      state.funct[\"(scope)\"].unstack();\n\n    } catch (err) {\n      if (err && err.name === \"JSHintError\") {\n        var nt = state.tokens.next || {};\n        JSHINT.errors.push({\n          scope     : \"(main)\",\n          raw       : err.raw,\n          code      : err.code,\n          reason    : err.reason,\n          line      : err.line || nt.line,\n          character : err.character || nt.from\n        });\n      } else {\n        /* istanbul ignore next */\n        throw err;\n      }\n    }\n\n    // Loop over the listed \"internals\", and check them as well.\n    if (JSHINT.scope === \"(main)\") {\n      lintEvalCode(JSHINT.internals, o || {}, g);\n    }\n\n    return JSHINT.errors.length === 0;\n  };\n\n  // Modules.\n  itself.addModule = function(func) {\n    extraModules.push(func);\n  };\n\n  itself.addModule(style.register);\n\n  // Data summary.\n  itself.data = function() {\n    var data = {\n      functions: [],\n      options: state.option\n    };\n\n    var fu, f, i, n, globals;\n\n    if (itself.errors.length) {\n      data.errors = itself.errors;\n    }\n\n    if (state.jsonMode) {\n      /* istanbul ignore next */\n      data.json = true;\n    }\n\n    var impliedGlobals = state.funct[\"(scope)\"].getImpliedGlobals();\n    if (impliedGlobals.length > 0) {\n      data.implieds = impliedGlobals;\n    }\n\n    globals = state.funct[\"(scope)\"].getUsedOrDefinedGlobals();\n    if (globals.length > 0) {\n      data.globals = globals;\n    }\n\n    for (i = 1; i < functions.length; i += 1) {\n      f = functions[i];\n      fu = {};\n\n      fu.name = f[\"(name)\"];\n      fu.param = f[\"(params)\"];\n      fu.line = f[\"(line)\"];\n      fu.character = f[\"(character)\"];\n      fu.last = f[\"(last)\"];\n      fu.lastcharacter = f[\"(lastcharacter)\"];\n\n      fu.metrics = {\n        complexity: f[\"(metrics)\"].ComplexityCount,\n        parameters: f[\"(metrics)\"].arity,\n        statements: f[\"(metrics)\"].statementCount\n      };\n\n      data.functions.push(fu);\n    }\n\n    var unuseds = state.funct[\"(scope)\"].getUnuseds();\n    if (unuseds.length > 0) {\n      data.unused = unuseds;\n    }\n\n    for (n in member) {\n      if (typeof member[n] === \"number\") {\n        data.member = member;\n        break;\n      }\n    }\n\n    return data;\n  };\n\n  itself.jshint = itself;\n\n  return itself;\n}());\n\n// Make JSHINT a Node module, if possible.\nif (typeof exports === \"object\" && exports) {\n  exports.JSHINT = JSHINT;\n}\n"]}