[Question]
  [
As of ECMAScript 2015, JavaScript has [33 reserved keywords](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords), such as `break`, `const` and `new`, as well as [10 future reserved keywords](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Future_reserved_keywords), such as `let` and `await`.
Your task is to chain together the largest number of consecutive1 distinct reserved keywords2 while writing functional JavaScript code3. 
1. Consecutive reserved keywords - reserved keywords that are separated only by whitespace and/or parentheses and/or curly braces.
2. Reserved keywords - any [reserved or future reserved keywords as of ECMAScript 2015](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords). Reserved keywords from older standards are excluded, a full list of allowed keywords is given below.
3. Functional code - your code should run (state your runtime, if necessary), eventually halt, and not throw any runtime errors.
If your code needs a specific runtime, the used reserved keywords must not be no-ops in the given environment.
## List of reserved keywords
```
await
break
case
catch
class
const
continue
debugger
default
delete
do
else
enum
export
extends
finally
for
function
if
implements
import
in
instanceof
interface
let
new
package
private
protected
public
return
static
super
switch
this
throw
try
typeof
var
void
while
with
yield
```
## Scoring & examples
Your score will be equal to the largest number of consecutive distinct reserved keywords.  
In the case of equal scores, shortest source code in bytes wins. Commented sections and strings don't count towards reserved keywords, but count towards byte count.
```
// score: 3
if (true) 0; else throw function() {}
             ^------------------^
// score: 2
let foo = typeof typeof void typeof void 0;
                             ^---------^
// score: 0
/* typeof default debugger */
// score: 0, doesn't halt or debugger is no-op, depending on the environment
debugger;
```
[Standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) apply.
  
[Answer]
# 43 words, 603 bytes
Uhm, is this a loophole? I have no idea how the hell this is legal JS, but it works and it uses every single keyword.
```
new (class await
{
    break(){}
    case(){}
    catch(){}
    const(){}
    continue(){}
    debugger(){}
    default(){}
    delete(){}
    do(){}
    else(){}
    enum(){}
    export(){}
    extends(){}
    finally(){}
    for(){}
    function(){}
    if(){}
    implements(){}
    import(){}
    in(){}
    instanceof(){}
    interface(){}
    let(){}
    package(){}
    private(){}
    protected(){}
    public(){}
    return(){}
    static(){}
    super(){}
    switch(){}
    this(){}
    throw(){}
    try(){}
    typeof(){}
    var(){}
    void(){}
    while(){}
    with(){}
    yield(){}
})
```
[Answer]
# 37 words
```
if (void this) {
  do {
    with (protected)
      for (public in private)
        typeof static instanceof new (function implements() {
          var let
          try {
            throw (class extends {} {})
          } catch (package) {
            yield
          } finally {
            debugger
          }
          return
        })()
    continue
    break
  } while (interface)
} else {
  switch (delete await) { default : 42 }
}
```
Keywords not used:
* `case` requires `:`
* `const` requires `=`
* `export` requires strict mode
* `import` requires strict mode
* `super` requires `constructor`
[Answer]
# 43 words, ~~302~~ 299 bytes
```
switch(void function(){for(const interface in public)do with(package)try{break}catch(private){if(typeof
this)throw yield static instanceof new class extends await{case(){return}super(){debugger}import(){}export(){}enum(){}}
else continue}finally{delete let}while(protected)var implements}){default:}
```
[Answer]
# ~~21~~ ~~24~~ 26 words, 185 bytes
*+~~1~~ 2 words thanks to Arnauld, and +1 to 12Me21!*
```
void(function(){do{with({})if(typeof true in this)throw{}instanceof new(class extends{}{})
else return delete{}
try{break}finally{yield}
continue
}while(false)})()
switch({}){case{}:{}}
```
Assuming I understood the challenge, this scores 24 words. The words without parentheses, brackets, and whitespace:
```
void function do with if typeof true in this throw instanceof new class extends else return delete try break finally yield continue while false switch case
```
### 24 words, 177 bytes
Without "true" and "false", which are apparently not keywords according to the question.
```
void(function(){do{with({})if(typeof{}in this)throw{}instanceof new(class extends{}{})
else return{}
try{break}finally{yield}
continue
}while(delete{})})()
switch({}){case{}:{}}
```
Words:
```
void function do with if typeof in this throw instanceof new class extends else return try break finally yield continue while delete switch case
```
[Answer]
# ~~38~~ 39
```
class await {}
class g extends await {
 constructor() {
  super()
 }
}
switch ({}) {
 case function(){
  for (let in public)
  do with(package){
   try{break}catch(private){
   if(typeof this)
    throw static instanceof new (class extends await {})
   else{continue}}finally{debugger}
  }while(void protected)
  var implements
  return 
  yield delete interface
  const a=0
 }:
}
```
words from "super" to "const"
Golfed version:
```
class e{}class g extends e{constructor(){super()}}switch({}){case
function(){for(let in public)do with(package)try{break}catch(private){if(typeof
this)throw static instanceof new(class extends await{})
else{continue}}finally{debugger}while(void protected)
var implements
return 
yield delete interface
const a=0}:}
```
[Answer]
# 21 words
(not sure about `let` and `await`)
```
var await=String, let=String;
switch (await) {
    case void typeof new await instanceof let in (function()
{do{try{return this
if((class extends{}{})){}else{break}}finally{(delete {})}}while(false)})():break;
}
```
[Answer]
# ~~14~~ ~~15~~ 16 Words with no brackets or newline
```
!function(){if(0);else do throw yield new public in void typeof this instanceof class await extends function async(){}{};while(0)}
```
Thank Bergi for +1
[Answer]
# 43 words, 300 bytes
```
with(this)try{let protected}catch(package){if(delete yield)for(const interface in typeof public)do{throw implements instanceof private}while(static)else debugger}finally{switch(void new class extends function(){return}{export(){var await}import(){break}super(){continue}enum(){}case(){}}){default:0}}
```
More readably:
```
with(this)
    try {
        let protected
    } catch(package){
        if(delete yield)
            for(const interface in typeof public)
                do {
                    throw implements instanceof private
                } while(static)
        else
            debugger
    } finally {
        switch(
          void new class extends function(){return} {
              export(){var await}
              import(){break}
              super(){continue}
              enum(){}
              case(){}
          }
        ){
            default:0
        }
    }
```
I had to use the "reserved word as method name" to deal with
* `case` (since I had already used `default` with my `swtich`),
* `export` and `import` (since module-mode is always strict, which disqualifies `with`)
* `super` (since it must be followed by a property access or placed in a `constructor` function), and
* `enum` (which can never be used at all, being a reserved word with no grammatically-valid use)
[Answer]
# 28 Words without brackets, 234 Bytes
Putting identifier names as method definition names was too obvious ([for me at least](https://stackoverflow.com/questions/49544859/how-many-reserved-keywords-can-you-put-together-that-could-be-in-production-code#comment86097608_49544859)), so I was looking for the longest consecutive distinct sequence of reserved words and whitespace in a code snippet.
I hope dead code after a `return` doesn't count as a loophole, but the code is still runnable if the used identifiers are declared.
```
function*_(){implements:{
let private
var public
return yield typeof static
delete protected
throw new interface in package
break implements
debugger
void this instanceof class await extends function async(){}{}
do
continue
while(0)}}
```
This exploits the fact that some of the future reserved keywords are only [considered invalid in ES5.1's strict mode](http://ecma-international.org/ecma-262/5.1/#sec-7.6.1.2) (apparently because engines didn't bother to block all of ES3's future reserved words so there was too much code using them out there on the web).
Similarly, the `async` and `await` tokens introduced in ES8 are only considered keywords in strict mode.
]