From 196f86e97a86354cd599016d88a77e12914421c7 Mon Sep 17 00:00:00 2001 From: Alan Pierce Date: Sun, 25 Nov 2018 11:21:03 -0800 Subject: [PATCH] Rework readWord, switch identifier and whitespace to use lookup tables (#358) Rather than generating a big tree of nested switches in the code, I generate a tree as a lookup table with pointers to other values in the table. Theoretically the two aren't so different, but this seems to perform a lot better in practice, maybe because of better branch prediction. I also changed whitespace and character detection to use a lookup table of size 64K (one for each UTF-16 code unit), which seems to actually work out fine especially since we'd only expect the first page to be in cache anyway. Still, I may want to explore an ASCII-only mode in the future. In the benchmark, this reduces readWord time from about 50ms to about 20ms, or about a 6% improvement overall. When running on a realistic codebase, this seems to improve overall performance by about 40%. --- benchmark/microbenchmark.ts | 24 - generator/generate.ts | 6 +- generator/generateReadWord.ts | 208 ----- generator/generateReadWordTree.ts | 151 ++++ src/CJSImportProcessor.ts | 3 +- src/TokenProcessor.ts | 3 +- src/parser/plugins/flow.ts | 2 +- src/parser/plugins/jsx/index.ts | 6 +- src/parser/plugins/typescript.ts | 2 +- src/parser/tokenizer/index.ts | 47 +- src/parser/tokenizer/keywords.ts | 35 + src/parser/tokenizer/readWord.ts | 991 +---------------------- src/parser/tokenizer/readWordTree.ts | 595 ++++++++++++++ src/parser/tokenizer/state.ts | 3 +- src/parser/traverser/expression.ts | 2 +- src/parser/traverser/lval.ts | 2 +- src/parser/traverser/statement.ts | 2 +- src/parser/traverser/util.ts | 9 +- src/parser/util/identifier.ts | 43 +- src/parser/util/whitespace.ts | 63 +- src/transformers/CJSImportTransformer.ts | 3 +- src/transformers/ESMImportTransformer.ts | 2 +- src/util/getClassInfo.ts | 3 +- src/util/getTSImportedNames.ts | 2 +- src/util/isIdentifier.ts | 6 +- 25 files changed, 908 insertions(+), 1305 deletions(-) delete mode 100644 generator/generateReadWord.ts create mode 100644 generator/generateReadWordTree.ts create mode 100644 src/parser/tokenizer/keywords.ts create mode 100644 src/parser/tokenizer/readWordTree.ts diff --git a/benchmark/microbenchmark.ts b/benchmark/microbenchmark.ts index 433faf2b..52e7eef4 100644 --- a/benchmark/microbenchmark.ts +++ b/benchmark/microbenchmark.ts @@ -1,37 +1,13 @@ #!./node_modules/.bin/sucrase-node /* eslint-disable no-console */ -import * as fs from "fs"; import {next} from "../src/parser/tokenizer"; import {initParser} from "../src/parser/traverser/base"; import {hasPrecedingLineBreak} from "../src/parser/traverser/util"; -import {isWhitespace} from "../src/parser/util/whitespace"; import runBenchmark from "./runBenchmark"; function main(): void { const benchmark = process.argv[2] || "all"; console.log(`Running microbenchmark ${benchmark}`); - const code = fs.readFileSync(`./benchmark/sample/sample.tsx`).toString(); - if (benchmark === "all" || benchmark === "isWhitespace") { - runBenchmark( - "isWhitespace", - () => { - for (let i = 0; i < code.length; i++) { - const char = code.charCodeAt(i); - isWhitespace(char); - isWhitespace(char); - isWhitespace(char); - isWhitespace(char); - isWhitespace(char); - isWhitespace(char); - isWhitespace(char); - isWhitespace(char); - isWhitespace(char); - isWhitespace(char); - } - }, - 1000, - ); - } if (benchmark === "all" || benchmark === "hasPredecingLineBreak") { initParser("let x\nx++;", false, false, false); next(); diff --git a/generator/generate.ts b/generator/generate.ts index d22469b5..70abc505 100644 --- a/generator/generate.ts +++ b/generator/generate.ts @@ -2,7 +2,7 @@ /* eslint-disable no-console */ import {writeFile} from "mz/fs"; import run from "../script/run"; -import generateReadWord from "./generateReadWord"; +import generateReadWordTree from "./generateReadWordTree"; import generateTokenTypes from "./generateTokenTypes"; /** @@ -11,8 +11,8 @@ import generateTokenTypes from "./generateTokenTypes"; async function generate(): Promise { await writeFile("./src/parser/tokenizer/types.ts", generateTokenTypes()); await run("./node_modules/.bin/prettier --write ./src/parser/tokenizer/types.ts"); - await writeFile("./src/parser/tokenizer/readWord.ts", generateReadWord()); - await run("./node_modules/.bin/prettier --write ./src/parser/tokenizer/readWord.ts"); + await writeFile("./src/parser/tokenizer/readWordTree.ts", generateReadWordTree()); + await run("./node_modules/.bin/prettier --write ./src/parser/tokenizer/readWordTree.ts"); console.log("Done with code generation."); } diff --git a/generator/generateReadWord.ts b/generator/generateReadWord.ts deleted file mode 100644 index d32191da..00000000 --- a/generator/generateReadWord.ts +++ /dev/null @@ -1,208 +0,0 @@ -const KEYWORDS = [ - "break", - "case", - "catch", - "continue", - "debugger", - "default", - "do", - "else", - "finally", - "for", - "function", - "if", - "return", - "switch", - "throw", - "try", - "var", - "while", - "with", - "null", - "true", - "false", - "instanceof", - "typeof", - "void", - "delete", - "new", - "in", - "this", - "let", - "const", - "class", - "extends", - "export", - "import", - "yield", - "super", -]; - -const CONTEXTUAL_KEYWORDS = [ - "abstract", - "as", - "async", - "await", - "checks", - "constructor", - "declare", - "enum", - "exports", - "from", - "get", - "global", - "implements", - "infer", - "interface", - "is", - "keyof", - "mixins", - "module", - "namespace", - "of", - "opaque", - "private", - "protected", - "proto", - "public", - "readonly", - "require", - "set", - "static", - "type", - "unique", -]; - -const CODE = `\ -// Generated file, do not edit! Run "yarn generate" to re-generate this file. -/* eslint-disable default-case */ -import {input, state} from "../traverser/base"; -import {charCodes} from "../util/charcodes"; -import {isIdentifierChar} from "../util/identifier"; -import {ContextualKeyword, finishToken} from "./index"; -import {TokenType as tt} from "./types"; - -/** - * Read an identifier, producing either a name token or matching on one of the existing keywords. - * For performance, we generate a big nested switch statement that can recognize all language - * keywords, so that we don't need to do any string allocations or hash table lookups to tell when - * a name token is a keyword. - */ -export default function readWord(): void { - SWITCH_POSITION - state.pos--; - while (state.pos < input.length) { - const ch = input.charCodeAt(state.pos); - if (isIdentifierChar(ch)) { - state.pos++; - } else if (ch === charCodes.backslash) { - // \\u - state.pos += 2; - if (input.charCodeAt(state.pos) === charCodes.leftCurlyBrace) { - while ( - state.pos < input.length && - input.charCodeAt(state.pos) !== charCodes.rightCurlyBrace - ) { - state.pos++; - } - state.pos++; - } - } else if (ch === charCodes.atSign && input.charCodeAt(state.pos + 1) === charCodes.atSign) { - state.pos += 2; - } else { - break; - } - } - finishToken(tt.name); -} -`; - -interface Keyword { - name: string; - remainingName: string; - isContextual: boolean; -} - -const ALL_KEYWORDS: Array = [ - ...KEYWORDS.map((name) => ({name, remainingName: name, isContextual: false})), - ...CONTEXTUAL_KEYWORDS.map((name) => ({name, remainingName: name, isContextual: true})), -]; - -const AT_END_CODE = `\ -!isIdentifierChar(input.charCodeAt(state.pos)) && -input.charCodeAt(state.pos) !== charCodes.backslash`; - -export default function generateReadWord(): string { - return CODE.replace("SWITCH_POSITION", generateMatcher(ALL_KEYWORDS)); -} - -/** - * Generate a matcher, usually a switch, that distinguishes all of the - */ -function generateMatcher(keywords: Array): string { - const initialLetters: Set = new Set(); - let emptyNameKeyword: Keyword | null = null; - for (const keyword of keywords) { - if (keyword.remainingName.length === 0) { - emptyNameKeyword = keyword; - } else { - initialLetters.add(keyword.remainingName[0]); - } - } - - let code = ""; - if (emptyNameKeyword) { - code += `if (${AT_END_CODE}) { ${returnKeywordCode(emptyNameKeyword)} }\n`; - keywords = keywords.filter((keyword) => keyword !== emptyNameKeyword); - } - - if (initialLetters.size > 1) { - code += "switch (input.charCodeAt(state.pos++)) {\n"; - for (const letter of Array.from(initialLetters).sort()) { - code += `case ${formatLetterCode(letter)}:\n`; - const remainingKeywords = keywords - .filter(({remainingName}) => remainingName.startsWith(letter)) - .map((keyword) => ({...keyword, remainingName: keyword.remainingName.slice(1)})); - code += generateMatcher(remainingKeywords); - code += `break\n`; - } - code += "}\n"; - } else if (initialLetters.size === 1) { - if (keywords.length === 1) { - const keyword = keywords[0]; - const conditions = keyword.remainingName - .split("") - .map((letter) => `input.charCodeAt(state.pos++) === ${formatLetterCode(letter)} && `); - code += `if (${conditions.join("")} ${AT_END_CODE}) { ${returnKeywordCode(keyword)} }`; - } else { - const letter = Array.from(initialLetters)[0]; - const remainingKeywords = keywords.map((keyword) => ({ - ...keyword, - remainingName: keyword.remainingName.slice(1), - })); - code += `\ -if (input.charCodeAt(state.pos++) === ${formatLetterCode(letter)}) { - ${generateMatcher(remainingKeywords)} -} -`; - } - } - - return code; -} - -function formatLetterCode(letter: string): string { - if (letter === letter.toLowerCase()) { - return `charCodes.lowercase${letter.toUpperCase()}`; - } else { - return `charCodes.uppercase${letter}`; - } -} - -function returnKeywordCode(keyword: Keyword): string { - if (keyword.isContextual) { - return `finishToken(tt.name, ContextualKeyword._${keyword.name}); return;`; - } else { - return `finishToken(tt._${keyword.name}); return;`; - } -} diff --git a/generator/generateReadWordTree.ts b/generator/generateReadWordTree.ts new file mode 100644 index 00000000..6ddea6bf --- /dev/null +++ b/generator/generateReadWordTree.ts @@ -0,0 +1,151 @@ +import {charCodes} from "../src/parser/util/charcodes"; + +const KEYWORDS = [ + "break", + "case", + "catch", + "continue", + "debugger", + "default", + "do", + "else", + "finally", + "for", + "function", + "if", + "return", + "switch", + "throw", + "try", + "var", + "while", + "with", + "null", + "true", + "false", + "instanceof", + "typeof", + "void", + "delete", + "new", + "in", + "this", + "let", + "const", + "class", + "extends", + "export", + "import", + "yield", + "super", +]; + +const CONTEXTUAL_KEYWORDS = [ + "abstract", + "as", + "async", + "await", + "checks", + "constructor", + "declare", + "enum", + "exports", + "from", + "get", + "global", + "implements", + "infer", + "interface", + "is", + "keyof", + "mixins", + "module", + "namespace", + "of", + "opaque", + "private", + "protected", + "proto", + "public", + "readonly", + "require", + "set", + "static", + "type", + "unique", +]; + +const CODE = `\ +// Generated file, do not edit! Run "yarn generate" to re-generate this file. +import {ContextualKeyword} from "./keywords"; +import {TokenType as tt} from "./types"; + +// prettier-ignore +export const READ_WORD_TREE = new Int32Array([ +$CONTENTS +]); +`; + +interface Keyword { + name: string; + isContextual: boolean; +} + +interface Node { + prefix: string; + data: Array; + start: number; +} + +const ALL_KEYWORDS: Array = [ + ...KEYWORDS.map((name) => ({name, isContextual: false})), + ...CONTEXTUAL_KEYWORDS.map((name) => ({name, isContextual: true})), +]; + +export default function generateReadWordTree(): string { + const prefixes = new Set(); + for (const {name} of ALL_KEYWORDS) { + for (let i = 0; i < name.length + 1; i++) { + prefixes.add(name.slice(0, i)); + } + } + + const nodesByPrefix: {[prefix: string]: Node} = {}; + const nodes = [...prefixes].sort().map((prefix, i) => { + const data = []; + for (let j = 0; j < 27; j++) { + data.push(-1); + } + const node = {prefix, data, start: i * 27}; + nodesByPrefix[prefix] = node; + return node; + }); + + for (const {name, isContextual} of ALL_KEYWORDS) { + // Fill in first index. + const keywordNode = nodesByPrefix[name]; + if (isContextual) { + keywordNode.data[0] = `ContextualKeyword._${name} << 1`; + } else { + keywordNode.data[0] = `(tt._${name} << 1) + 1`; + } + + // The later indices are transitions by lowercase letter. + for (let i = 0; i < name.length; i++) { + const node = nodesByPrefix[name.slice(0, i)]; + const nextNode = nodesByPrefix[name.slice(0, i + 1)]; + node.data[name.charCodeAt(i) - charCodes.lowercaseA + 1] = nextNode.start; + } + } + + return CODE.replace( + "$CONTENTS", + nodes + .map( + ({prefix, data}) => `\ + // "${prefix}" + ${data.map((datum) => `${datum},`).join(" ")}`, + ) + .join("\n"), + ); +} diff --git a/src/CJSImportProcessor.ts b/src/CJSImportProcessor.ts index abb6f7b6..7ba5ddb5 100644 --- a/src/CJSImportProcessor.ts +++ b/src/CJSImportProcessor.ts @@ -1,5 +1,6 @@ import NameManager from "./NameManager"; -import {ContextualKeyword, isDeclaration} from "./parser/tokenizer"; +import {isDeclaration} from "./parser/tokenizer"; +import {ContextualKeyword} from "./parser/tokenizer/keywords"; import {TokenType as tt} from "./parser/tokenizer/types"; import TokenProcessor from "./TokenProcessor"; import {getNonTypeIdentifiers} from "./util/getNonTypeIdentifiers"; diff --git a/src/TokenProcessor.ts b/src/TokenProcessor.ts index 0acf0fdb..15b2a221 100644 --- a/src/TokenProcessor.ts +++ b/src/TokenProcessor.ts @@ -1,4 +1,5 @@ -import {ContextualKeyword, Token} from "./parser/tokenizer"; +import {Token} from "./parser/tokenizer"; +import {ContextualKeyword} from "./parser/tokenizer/keywords"; import {TokenType, TokenType as tt} from "./parser/tokenizer/types"; export interface TokenProcessorSnapshot { diff --git a/src/parser/plugins/flow.ts b/src/parser/plugins/flow.ts index 361f9237..03570e2e 100644 --- a/src/parser/plugins/flow.ts +++ b/src/parser/plugins/flow.ts @@ -1,7 +1,6 @@ /* eslint max-len: 0 */ import { - ContextualKeyword, eat, lookaheadType, lookaheadTypeAndKeyword, @@ -11,6 +10,7 @@ import { pushTypeContext, TypeAndKeyword, } from "../tokenizer/index"; +import {ContextualKeyword} from "../tokenizer/keywords"; import {TokenType, TokenType as tt} from "../tokenizer/types"; import {input, state} from "../traverser/base"; import { diff --git a/src/parser/plugins/jsx/index.ts b/src/parser/plugins/jsx/index.ts index 74e97e34..0ee5a3af 100644 --- a/src/parser/plugins/jsx/index.ts +++ b/src/parser/plugins/jsx/index.ts @@ -14,7 +14,7 @@ import {input, isTypeScriptEnabled, state} from "../../traverser/base"; import {parseExpression, parseMaybeAssign} from "../../traverser/expression"; import {expect, unexpected} from "../../traverser/util"; import {charCodes} from "../../util/charcodes"; -import {isIdentifierChar, isIdentifierStart} from "../../util/identifier"; +import {IS_IDENTIFIER_CHAR, IS_IDENTIFIER_START} from "../../util/identifier"; import {tsTryParseJSXTypeArgument} from "../typescript"; // Reads inline JSX contents token. @@ -81,7 +81,7 @@ function jsxReadWord(): void { return; } ch = input.charCodeAt(++state.pos); - } while (isIdentifierChar(ch) || ch === charCodes.dash); + } while (IS_IDENTIFIER_CHAR[ch] || ch === charCodes.dash); finishToken(tt.jsxName); } @@ -266,7 +266,7 @@ export function nextJSXTagToken(): void { state.start = state.pos; const code = input.charCodeAt(state.pos); - if (isIdentifierStart(code)) { + if (IS_IDENTIFIER_START[code]) { jsxReadWord(); } else if (code === charCodes.quotationMark || code === charCodes.apostrophe) { jsxReadString(code); diff --git a/src/parser/plugins/typescript.ts b/src/parser/plugins/typescript.ts index ddbd5f44..8f0a1e4f 100644 --- a/src/parser/plugins/typescript.ts +++ b/src/parser/plugins/typescript.ts @@ -1,5 +1,4 @@ import { - ContextualKeyword, eat, lookaheadType, lookaheadTypeAndKeyword, @@ -8,6 +7,7 @@ import { popTypeContext, pushTypeContext, } from "../tokenizer/index"; +import {ContextualKeyword} from "../tokenizer/keywords"; import {TokenType, TokenType as tt} from "../tokenizer/types"; import {isJSXEnabled, state} from "../traverser/base"; import { diff --git a/src/parser/tokenizer/index.ts b/src/parser/tokenizer/index.ts index 26d86d34..483731ab 100644 --- a/src/parser/tokenizer/index.ts +++ b/src/parser/tokenizer/index.ts @@ -3,8 +3,9 @@ import {input, isFlowEnabled, state} from "../traverser/base"; import {unexpected} from "../traverser/util"; import {charCodes} from "../util/charcodes"; -import {isIdentifierChar, isIdentifierStart} from "../util/identifier"; -import {isWhitespace} from "../util/whitespace"; +import {IS_IDENTIFIER_CHAR, IS_IDENTIFIER_START} from "../util/identifier"; +import {IS_WHITESPACE} from "../util/whitespace"; +import {ContextualKeyword} from "./keywords"; import readWord from "./readWord"; import {TokenType, TokenType as tt} from "./types"; @@ -45,42 +46,6 @@ export function isFunctionScopedDeclaration(token: Token): boolean { ); } -export const enum ContextualKeyword { - NONE, - _abstract, - _as, - _async, - _await, - _checks, - _constructor, - _declare, - _enum, - _exports, - _from, - _get, - _global, - _implements, - _infer, - _interface, - _is, - _keyof, - _mixins, - _module, - _namespace, - _of, - _opaque, - _private, - _protected, - _proto, - _public, - _readonly, - _require, - _set, - _static, - _type, - _unique, -} - // Object type used to represent tokens. Note that normally, tokens // simply exist as properties on the parser object. This is only // used for the onToken callback and the external tokenizer. @@ -216,7 +181,7 @@ function readToken(code: number): void { // Identifier or keyword. '\uXXXX' sequences are allowed in // identifiers, so '\' also dispatches to that. if ( - isIdentifierStart(code) || + IS_IDENTIFIER_START[code] || code === charCodes.backslash || (code === charCodes.atSign && input.charCodeAt(state.pos + 1) === charCodes.atSign) ) { @@ -288,7 +253,7 @@ export function skipSpace(): void { break; default: - if (isWhitespace(ch)) { + if (IS_WHITESPACE[ch]) { ++state.pos; } else { return; @@ -830,7 +795,7 @@ function readTmplToken(): void { export function skipWord(): void { while (state.pos < input.length) { const ch = input.charCodeAt(state.pos); - if (isIdentifierChar(ch)) { + if (IS_IDENTIFIER_CHAR[ch]) { state.pos++; } else if (ch === charCodes.backslash) { // \u diff --git a/src/parser/tokenizer/keywords.ts b/src/parser/tokenizer/keywords.ts new file mode 100644 index 00000000..467697c5 --- /dev/null +++ b/src/parser/tokenizer/keywords.ts @@ -0,0 +1,35 @@ +export const enum ContextualKeyword { + NONE, + _abstract, + _as, + _async, + _await, + _checks, + _constructor, + _declare, + _enum, + _exports, + _from, + _get, + _global, + _implements, + _infer, + _interface, + _is, + _keyof, + _mixins, + _module, + _namespace, + _of, + _opaque, + _private, + _protected, + _proto, + _public, + _readonly, + _require, + _set, + _static, + _type, + _unique, +} diff --git a/src/parser/tokenizer/readWord.ts b/src/parser/tokenizer/readWord.ts index 4dd68874..0132b1cd 100644 --- a/src/parser/tokenizer/readWord.ts +++ b/src/parser/tokenizer/readWord.ts @@ -1,971 +1,64 @@ -// Generated file, do not edit! Run "yarn generate" to re-generate this file. -/* eslint-disable default-case */ import {input, state} from "../traverser/base"; import {charCodes} from "../util/charcodes"; -import {isIdentifierChar} from "../util/identifier"; -import {ContextualKeyword, finishToken} from "./index"; +import {IS_IDENTIFIER_CHAR} from "../util/identifier"; +import {finishToken} from "./index"; +import {READ_WORD_TREE} from "./readWordTree"; import {TokenType as tt} from "./types"; /** * Read an identifier, producing either a name token or matching on one of the existing keywords. - * For performance, we generate a big nested switch statement that can recognize all language - * keywords, so that we don't need to do any string allocations or hash table lookups to tell when - * a name token is a keyword. + * For performance, we pre-generate big decision tree that we traverse. Each node represents a + * prefix and has 27 values, where the first value is the token or contextual token, if any (-1 if + * not), and the other 26 values are the transitions to other nodes, or -1 to stop. */ export default function readWord(): void { - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseA: - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseB: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseS && - input.charCodeAt(state.pos++) === charCodes.lowercaseT && - input.charCodeAt(state.pos++) === charCodes.lowercaseR && - input.charCodeAt(state.pos++) === charCodes.lowercaseA && - input.charCodeAt(state.pos++) === charCodes.lowercaseC && - input.charCodeAt(state.pos++) === charCodes.lowercaseT && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._abstract); - return; - } - break; - case charCodes.lowercaseS: - if ( - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._as); - return; - } - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseY && - input.charCodeAt(state.pos++) === charCodes.lowercaseN && - input.charCodeAt(state.pos++) === charCodes.lowercaseC && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._async); - return; - } - break; - case charCodes.lowercaseW: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseA && - input.charCodeAt(state.pos++) === charCodes.lowercaseI && - input.charCodeAt(state.pos++) === charCodes.lowercaseT && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._await); - return; - } - break; - } - break; - case charCodes.lowercaseB: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseR && - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - input.charCodeAt(state.pos++) === charCodes.lowercaseA && - input.charCodeAt(state.pos++) === charCodes.lowercaseK && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._break); - return; - } - break; - case charCodes.lowercaseC: - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseA: - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseS: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._case); - return; - } - break; - case charCodes.lowercaseT: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseC && - input.charCodeAt(state.pos++) === charCodes.lowercaseH && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._catch); - return; - } - break; - } - break; - case charCodes.lowercaseH: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - input.charCodeAt(state.pos++) === charCodes.lowercaseC && - input.charCodeAt(state.pos++) === charCodes.lowercaseK && - input.charCodeAt(state.pos++) === charCodes.lowercaseS && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._checks); - return; - } - break; - case charCodes.lowercaseL: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseA && - input.charCodeAt(state.pos++) === charCodes.lowercaseS && - input.charCodeAt(state.pos++) === charCodes.lowercaseS && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._class); - return; - } - break; - case charCodes.lowercaseO: - if (input.charCodeAt(state.pos++) === charCodes.lowercaseN) { - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseS: - if (input.charCodeAt(state.pos++) === charCodes.lowercaseT) { - if ( - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._const); - return; - } - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseR && - input.charCodeAt(state.pos++) === charCodes.lowercaseU && - input.charCodeAt(state.pos++) === charCodes.lowercaseC && - input.charCodeAt(state.pos++) === charCodes.lowercaseT && - input.charCodeAt(state.pos++) === charCodes.lowercaseO && - input.charCodeAt(state.pos++) === charCodes.lowercaseR && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._constructor); - return; - } - } - break; - case charCodes.lowercaseT: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseI && - input.charCodeAt(state.pos++) === charCodes.lowercaseN && - input.charCodeAt(state.pos++) === charCodes.lowercaseU && - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._continue); - return; - } - break; - } - } - break; - } - break; - case charCodes.lowercaseD: - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseE: - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseB: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseU && - input.charCodeAt(state.pos++) === charCodes.lowercaseG && - input.charCodeAt(state.pos++) === charCodes.lowercaseG && - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - input.charCodeAt(state.pos++) === charCodes.lowercaseR && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._debugger); - return; - } - break; - case charCodes.lowercaseC: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseL && - input.charCodeAt(state.pos++) === charCodes.lowercaseA && - input.charCodeAt(state.pos++) === charCodes.lowercaseR && - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._declare); - return; - } - break; - case charCodes.lowercaseF: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseA && - input.charCodeAt(state.pos++) === charCodes.lowercaseU && - input.charCodeAt(state.pos++) === charCodes.lowercaseL && - input.charCodeAt(state.pos++) === charCodes.lowercaseT && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._default); - return; - } - break; - case charCodes.lowercaseL: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - input.charCodeAt(state.pos++) === charCodes.lowercaseT && - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._delete); - return; - } - break; - } - break; - case charCodes.lowercaseO: - if ( - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._do); - return; - } - break; - } - break; - case charCodes.lowercaseE: - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseL: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseS && - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._else); - return; - } - break; - case charCodes.lowercaseN: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseU && - input.charCodeAt(state.pos++) === charCodes.lowercaseM && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._enum); - return; - } - break; - case charCodes.lowercaseX: - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseP: - if (input.charCodeAt(state.pos++) === charCodes.lowercaseO) { - if (input.charCodeAt(state.pos++) === charCodes.lowercaseR) { - if (input.charCodeAt(state.pos++) === charCodes.lowercaseT) { - if ( - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._export); - return; - } - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseS && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._exports); - return; - } - } - } - } - break; - case charCodes.lowercaseT: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - input.charCodeAt(state.pos++) === charCodes.lowercaseN && - input.charCodeAt(state.pos++) === charCodes.lowercaseD && - input.charCodeAt(state.pos++) === charCodes.lowercaseS && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._extends); - return; - } - break; - } - break; - } - break; - case charCodes.lowercaseF: - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseA: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseL && - input.charCodeAt(state.pos++) === charCodes.lowercaseS && - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._false); - return; - } - break; - case charCodes.lowercaseI: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseN && - input.charCodeAt(state.pos++) === charCodes.lowercaseA && - input.charCodeAt(state.pos++) === charCodes.lowercaseL && - input.charCodeAt(state.pos++) === charCodes.lowercaseL && - input.charCodeAt(state.pos++) === charCodes.lowercaseY && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._finally); - return; - } - break; - case charCodes.lowercaseO: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseR && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._for); - return; - } - break; - case charCodes.lowercaseR: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseO && - input.charCodeAt(state.pos++) === charCodes.lowercaseM && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._from); - return; - } - break; - case charCodes.lowercaseU: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseN && - input.charCodeAt(state.pos++) === charCodes.lowercaseC && - input.charCodeAt(state.pos++) === charCodes.lowercaseT && - input.charCodeAt(state.pos++) === charCodes.lowercaseI && - input.charCodeAt(state.pos++) === charCodes.lowercaseO && - input.charCodeAt(state.pos++) === charCodes.lowercaseN && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._function); - return; - } - break; - } - break; - case charCodes.lowercaseG: - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseE: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseT && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._get); - return; - } - break; - case charCodes.lowercaseL: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseO && - input.charCodeAt(state.pos++) === charCodes.lowercaseB && - input.charCodeAt(state.pos++) === charCodes.lowercaseA && - input.charCodeAt(state.pos++) === charCodes.lowercaseL && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._global); - return; - } - break; - } - break; - case charCodes.lowercaseI: - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseF: - if ( - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._if); - return; - } - break; - case charCodes.lowercaseM: - if (input.charCodeAt(state.pos++) === charCodes.lowercaseP) { - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseL: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - input.charCodeAt(state.pos++) === charCodes.lowercaseM && - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - input.charCodeAt(state.pos++) === charCodes.lowercaseN && - input.charCodeAt(state.pos++) === charCodes.lowercaseT && - input.charCodeAt(state.pos++) === charCodes.lowercaseS && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._implements); - return; - } - break; - case charCodes.lowercaseO: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseR && - input.charCodeAt(state.pos++) === charCodes.lowercaseT && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._import); - return; - } - break; - } - } - break; - case charCodes.lowercaseN: - if ( - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._in); - return; - } - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseF: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - input.charCodeAt(state.pos++) === charCodes.lowercaseR && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._infer); - return; - } - break; - case charCodes.lowercaseS: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseT && - input.charCodeAt(state.pos++) === charCodes.lowercaseA && - input.charCodeAt(state.pos++) === charCodes.lowercaseN && - input.charCodeAt(state.pos++) === charCodes.lowercaseC && - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - input.charCodeAt(state.pos++) === charCodes.lowercaseO && - input.charCodeAt(state.pos++) === charCodes.lowercaseF && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._instanceof); - return; - } - break; - case charCodes.lowercaseT: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - input.charCodeAt(state.pos++) === charCodes.lowercaseR && - input.charCodeAt(state.pos++) === charCodes.lowercaseF && - input.charCodeAt(state.pos++) === charCodes.lowercaseA && - input.charCodeAt(state.pos++) === charCodes.lowercaseC && - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._interface); - return; - } - break; - } - break; - case charCodes.lowercaseS: - if ( - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._is); - return; - } - break; - } - break; - case charCodes.lowercaseK: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - input.charCodeAt(state.pos++) === charCodes.lowercaseY && - input.charCodeAt(state.pos++) === charCodes.lowercaseO && - input.charCodeAt(state.pos++) === charCodes.lowercaseF && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._keyof); - return; - } - break; - case charCodes.lowercaseL: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - input.charCodeAt(state.pos++) === charCodes.lowercaseT && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._let); - return; - } - break; - case charCodes.lowercaseM: - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseI: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseX && - input.charCodeAt(state.pos++) === charCodes.lowercaseI && - input.charCodeAt(state.pos++) === charCodes.lowercaseN && - input.charCodeAt(state.pos++) === charCodes.lowercaseS && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._mixins); - return; - } - break; - case charCodes.lowercaseO: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseD && - input.charCodeAt(state.pos++) === charCodes.lowercaseU && - input.charCodeAt(state.pos++) === charCodes.lowercaseL && - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._module); - return; - } - break; - } - break; - case charCodes.lowercaseN: - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseA: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseM && - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - input.charCodeAt(state.pos++) === charCodes.lowercaseS && - input.charCodeAt(state.pos++) === charCodes.lowercaseP && - input.charCodeAt(state.pos++) === charCodes.lowercaseA && - input.charCodeAt(state.pos++) === charCodes.lowercaseC && - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._namespace); - return; - } - break; - case charCodes.lowercaseE: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseW && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._new); - return; - } - break; - case charCodes.lowercaseU: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseL && - input.charCodeAt(state.pos++) === charCodes.lowercaseL && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._null); - return; - } - break; - } - break; - case charCodes.lowercaseO: - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseF: - if ( - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._of); - return; - } - break; - case charCodes.lowercaseP: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseA && - input.charCodeAt(state.pos++) === charCodes.lowercaseQ && - input.charCodeAt(state.pos++) === charCodes.lowercaseU && - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._opaque); - return; - } - break; - } - break; - case charCodes.lowercaseP: - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseR: - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseI: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseV && - input.charCodeAt(state.pos++) === charCodes.lowercaseA && - input.charCodeAt(state.pos++) === charCodes.lowercaseT && - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._private); - return; - } - break; - case charCodes.lowercaseO: - if (input.charCodeAt(state.pos++) === charCodes.lowercaseT) { - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseE: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseC && - input.charCodeAt(state.pos++) === charCodes.lowercaseT && - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - input.charCodeAt(state.pos++) === charCodes.lowercaseD && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._protected); - return; - } - break; - case charCodes.lowercaseO: - if ( - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._proto); - return; - } - break; - } - } - break; - } - break; - case charCodes.lowercaseU: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseB && - input.charCodeAt(state.pos++) === charCodes.lowercaseL && - input.charCodeAt(state.pos++) === charCodes.lowercaseI && - input.charCodeAt(state.pos++) === charCodes.lowercaseC && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._public); - return; - } - break; - } - break; - case charCodes.lowercaseR: - if (input.charCodeAt(state.pos++) === charCodes.lowercaseE) { - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseA: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseD && - input.charCodeAt(state.pos++) === charCodes.lowercaseO && - input.charCodeAt(state.pos++) === charCodes.lowercaseN && - input.charCodeAt(state.pos++) === charCodes.lowercaseL && - input.charCodeAt(state.pos++) === charCodes.lowercaseY && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._readonly); - return; - } - break; - case charCodes.lowercaseQ: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseU && - input.charCodeAt(state.pos++) === charCodes.lowercaseI && - input.charCodeAt(state.pos++) === charCodes.lowercaseR && - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._require); - return; - } - break; - case charCodes.lowercaseT: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseU && - input.charCodeAt(state.pos++) === charCodes.lowercaseR && - input.charCodeAt(state.pos++) === charCodes.lowercaseN && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._return); - return; - } - break; - } - } - break; - case charCodes.lowercaseS: - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseE: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseT && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._set); - return; - } - break; - case charCodes.lowercaseT: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseA && - input.charCodeAt(state.pos++) === charCodes.lowercaseT && - input.charCodeAt(state.pos++) === charCodes.lowercaseI && - input.charCodeAt(state.pos++) === charCodes.lowercaseC && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._static); - return; - } - break; - case charCodes.lowercaseU: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseP && - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - input.charCodeAt(state.pos++) === charCodes.lowercaseR && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._super); - return; - } - break; - case charCodes.lowercaseW: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseI && - input.charCodeAt(state.pos++) === charCodes.lowercaseT && - input.charCodeAt(state.pos++) === charCodes.lowercaseC && - input.charCodeAt(state.pos++) === charCodes.lowercaseH && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._switch); - return; - } - break; - } - break; - case charCodes.lowercaseT: - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseH: - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseI: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseS && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._this); - return; - } - break; - case charCodes.lowercaseR: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseO && - input.charCodeAt(state.pos++) === charCodes.lowercaseW && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._throw); - return; - } - break; - } - break; - case charCodes.lowercaseR: - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseU: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._true); - return; - } - break; - case charCodes.lowercaseY: - if ( - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._try); - return; - } - break; - } - break; - case charCodes.lowercaseY: - if (input.charCodeAt(state.pos++) === charCodes.lowercaseP) { - if (input.charCodeAt(state.pos++) === charCodes.lowercaseE) { - if ( - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._type); - return; - } - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseO && - input.charCodeAt(state.pos++) === charCodes.lowercaseF && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._typeof); - return; - } - } - } - break; - } - break; - case charCodes.lowercaseU: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseN && - input.charCodeAt(state.pos++) === charCodes.lowercaseI && - input.charCodeAt(state.pos++) === charCodes.lowercaseQ && - input.charCodeAt(state.pos++) === charCodes.lowercaseU && - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt.name, ContextualKeyword._unique); - return; - } + let treePos = 0; + let code; + let pos = state.pos; + while (true) { + code = input.charCodeAt(pos); + if (code < charCodes.lowercaseA || code > charCodes.lowercaseZ) { break; - case charCodes.lowercaseV: - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseA: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseR && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._var); - return; - } - break; - case charCodes.lowercaseO: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseI && - input.charCodeAt(state.pos++) === charCodes.lowercaseD && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._void); - return; - } - break; - } - break; - case charCodes.lowercaseW: - switch (input.charCodeAt(state.pos++)) { - case charCodes.lowercaseH: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseI && - input.charCodeAt(state.pos++) === charCodes.lowercaseL && - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._while); - return; - } - break; - case charCodes.lowercaseI: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseT && - input.charCodeAt(state.pos++) === charCodes.lowercaseH && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._with); - return; - } - break; - } - break; - case charCodes.lowercaseY: - if ( - input.charCodeAt(state.pos++) === charCodes.lowercaseI && - input.charCodeAt(state.pos++) === charCodes.lowercaseE && - input.charCodeAt(state.pos++) === charCodes.lowercaseL && - input.charCodeAt(state.pos++) === charCodes.lowercaseD && - !isIdentifierChar(input.charCodeAt(state.pos)) && - input.charCodeAt(state.pos) !== charCodes.backslash - ) { - finishToken(tt._yield); - return; - } + } + const next = READ_WORD_TREE[treePos + (code - charCodes.lowercaseA) + 1]; + if (next === -1) { break; + } else { + treePos = next; + pos++; + } + } + + const keywordValue = READ_WORD_TREE[treePos]; + if (keywordValue > -1 && !IS_IDENTIFIER_CHAR[code]) { + state.pos = pos; + if (keywordValue & 1) { + finishToken(keywordValue >>> 1); + } else { + finishToken(tt.name, keywordValue >>> 1); + } + return; } - state.pos--; - while (state.pos < input.length) { - const ch = input.charCodeAt(state.pos); - if (isIdentifierChar(ch)) { - state.pos++; + while (pos < input.length) { + const ch = input.charCodeAt(pos); + if (IS_IDENTIFIER_CHAR[ch]) { + pos++; } else if (ch === charCodes.backslash) { // \u - state.pos += 2; - if (input.charCodeAt(state.pos) === charCodes.leftCurlyBrace) { - while ( - state.pos < input.length && - input.charCodeAt(state.pos) !== charCodes.rightCurlyBrace - ) { - state.pos++; + pos += 2; + if (input.charCodeAt(pos) === charCodes.leftCurlyBrace) { + while (pos < input.length && input.charCodeAt(pos) !== charCodes.rightCurlyBrace) { + pos++; } - state.pos++; + pos++; } - } else if (ch === charCodes.atSign && input.charCodeAt(state.pos + 1) === charCodes.atSign) { - state.pos += 2; + } else if (ch === charCodes.atSign && input.charCodeAt(pos + 1) === charCodes.atSign) { + pos += 2; } else { break; } } + state.pos = pos; finishToken(tt.name); } diff --git a/src/parser/tokenizer/readWordTree.ts b/src/parser/tokenizer/readWordTree.ts new file mode 100644 index 00000000..699c6290 --- /dev/null +++ b/src/parser/tokenizer/readWordTree.ts @@ -0,0 +1,595 @@ +// Generated file, do not edit! Run "yarn generate" to re-generate this file. +import {ContextualKeyword} from "./keywords"; +import {TokenType as tt} from "./types"; + +// prettier-ignore +export const READ_WORD_TREE = new Int32Array([ + // "" + -1, 27, 459, 594, 1431, 2052, 2538, 3159, -1, 3375, -1, 4293, 4428, 4509, 4806, 5184, 5373, -1, 5913, 6372, 6831, 7263, 7425, 7587, -1, 7803, -1, + // "a" + -1, -1, 54, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 243, -1, -1, -1, 351, -1, -1, -1, + // "ab" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 81, -1, -1, -1, -1, -1, -1, -1, + // "abs" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 108, -1, -1, -1, -1, -1, -1, + // "abst" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 135, -1, -1, -1, -1, -1, -1, -1, -1, + // "abstr" + -1, 162, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "abstra" + -1, -1, -1, 189, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "abstrac" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 216, -1, -1, -1, -1, -1, -1, + // "abstract" + ContextualKeyword._abstract << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "as" + ContextualKeyword._as << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 270, -1, + // "asy" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 297, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "asyn" + -1, -1, -1, 324, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "async" + ContextualKeyword._async << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "aw" + -1, 378, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "awa" + -1, -1, -1, -1, -1, -1, -1, -1, -1, 405, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "awai" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 432, -1, -1, -1, -1, -1, -1, + // "await" + ContextualKeyword._await << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "b" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 486, -1, -1, -1, -1, -1, -1, -1, -1, + // "br" + -1, -1, -1, -1, -1, 513, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "bre" + -1, 540, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "brea" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 567, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "break" + (tt._break << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "c" + -1, 621, -1, -1, -1, -1, -1, -1, 783, -1, -1, -1, 918, -1, -1, 1026, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "ca" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 648, 702, -1, -1, -1, -1, -1, -1, + // "cas" + -1, -1, -1, -1, -1, 675, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "case" + (tt._case << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "cat" + -1, -1, -1, 729, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "catc" + -1, -1, -1, -1, -1, -1, -1, -1, 756, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "catch" + (tt._catch << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "ch" + -1, -1, -1, -1, -1, 810, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "che" + -1, -1, -1, 837, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "chec" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 864, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "check" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 891, -1, -1, -1, -1, -1, -1, -1, + // "checks" + ContextualKeyword._checks << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "cl" + -1, 945, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "cla" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 972, -1, -1, -1, -1, -1, -1, -1, + // "clas" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 999, -1, -1, -1, -1, -1, -1, -1, + // "class" + (tt._class << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "co" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1053, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "con" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1080, 1296, -1, -1, -1, -1, -1, -1, + // "cons" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1107, -1, -1, -1, -1, -1, -1, + // "const" + (tt._const << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1134, -1, -1, -1, -1, -1, -1, -1, -1, + // "constr" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1161, -1, -1, -1, -1, -1, + // "constru" + -1, -1, -1, 1188, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "construc" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1215, -1, -1, -1, -1, -1, -1, + // "construct" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1242, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "constructo" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1269, -1, -1, -1, -1, -1, -1, -1, -1, + // "constructor" + ContextualKeyword._constructor << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "cont" + -1, -1, -1, -1, -1, -1, -1, -1, -1, 1323, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "conti" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1350, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "contin" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1377, -1, -1, -1, -1, -1, + // "continu" + -1, -1, -1, -1, -1, 1404, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "continue" + (tt._continue << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "d" + -1, -1, -1, -1, -1, 1458, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2025, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "de" + -1, -1, 1485, 1647, -1, -1, 1782, -1, -1, -1, -1, -1, 1917, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "deb" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1512, -1, -1, -1, -1, -1, + // "debu" + -1, -1, -1, -1, -1, -1, -1, 1539, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "debug" + -1, -1, -1, -1, -1, -1, -1, 1566, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "debugg" + -1, -1, -1, -1, -1, 1593, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "debugge" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1620, -1, -1, -1, -1, -1, -1, -1, -1, + // "debugger" + (tt._debugger << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "dec" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1674, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "decl" + -1, 1701, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "decla" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1728, -1, -1, -1, -1, -1, -1, -1, -1, + // "declar" + -1, -1, -1, -1, -1, 1755, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "declare" + ContextualKeyword._declare << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "def" + -1, 1809, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "defa" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1836, -1, -1, -1, -1, -1, + // "defau" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1863, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "defaul" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1890, -1, -1, -1, -1, -1, -1, + // "default" + (tt._default << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "del" + -1, -1, -1, -1, -1, 1944, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "dele" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1971, -1, -1, -1, -1, -1, -1, + // "delet" + -1, -1, -1, -1, -1, 1998, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "delete" + (tt._delete << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "do" + (tt._do << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "e" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2079, -1, 2160, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2241, -1, -1, + // "el" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2106, -1, -1, -1, -1, -1, -1, -1, + // "els" + -1, -1, -1, -1, -1, 2133, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "else" + (tt._else << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "en" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2187, -1, -1, -1, -1, -1, + // "enu" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2214, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "enum" + ContextualKeyword._enum << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "ex" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2268, -1, -1, -1, 2403, -1, -1, -1, -1, -1, -1, + // "exp" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2295, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "expo" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2322, -1, -1, -1, -1, -1, -1, -1, -1, + // "expor" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2349, -1, -1, -1, -1, -1, -1, + // "export" + (tt._export << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2376, -1, -1, -1, -1, -1, -1, -1, + // "exports" + ContextualKeyword._exports << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "ext" + -1, -1, -1, -1, -1, 2430, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "exte" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2457, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "exten" + -1, -1, -1, -1, 2484, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "extend" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2511, -1, -1, -1, -1, -1, -1, -1, + // "extends" + (tt._extends << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "f" + -1, 2565, -1, -1, -1, -1, -1, -1, -1, 2673, -1, -1, -1, -1, -1, 2835, -1, -1, 2889, -1, -1, 2970, -1, -1, -1, -1, -1, + // "fa" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2592, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "fal" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2619, -1, -1, -1, -1, -1, -1, -1, + // "fals" + -1, -1, -1, -1, -1, 2646, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "false" + (tt._false << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "fi" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2700, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "fin" + -1, 2727, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "fina" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2754, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "final" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2781, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "finall" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2808, -1, + // "finally" + (tt._finally << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "fo" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2862, -1, -1, -1, -1, -1, -1, -1, -1, + // "for" + (tt._for << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "fr" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2916, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "fro" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2943, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "from" + ContextualKeyword._from << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "fu" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2997, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "fun" + -1, -1, -1, 3024, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "func" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3051, -1, -1, -1, -1, -1, -1, + // "funct" + -1, -1, -1, -1, -1, -1, -1, -1, -1, 3078, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "functi" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3105, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "functio" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3132, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "function" + (tt._function << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "g" + -1, -1, -1, -1, -1, 3186, -1, -1, -1, -1, -1, -1, 3240, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "ge" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3213, -1, -1, -1, -1, -1, -1, + // "get" + ContextualKeyword._get << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "gl" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3267, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "glo" + -1, -1, 3294, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "glob" + -1, 3321, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "globa" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3348, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "global" + ContextualKeyword._global << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "i" + -1, -1, -1, -1, -1, -1, 3402, -1, -1, -1, -1, -1, -1, 3429, 3753, -1, -1, -1, -1, 4266, -1, -1, -1, -1, -1, -1, -1, + // "if" + (tt._if << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "im" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3456, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "imp" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3483, -1, -1, 3672, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "impl" + -1, -1, -1, -1, -1, 3510, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "imple" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3537, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "implem" + -1, -1, -1, -1, -1, 3564, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "impleme" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3591, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "implemen" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3618, -1, -1, -1, -1, -1, -1, + // "implement" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3645, -1, -1, -1, -1, -1, -1, -1, + // "implements" + ContextualKeyword._implements << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "impo" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3699, -1, -1, -1, -1, -1, -1, -1, -1, + // "impor" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3726, -1, -1, -1, -1, -1, -1, + // "import" + (tt._import << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "in" + (tt._in << 1) + 1, -1, -1, -1, -1, -1, 3780, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3861, 4077, -1, -1, -1, -1, -1, -1, + // "inf" + -1, -1, -1, -1, -1, 3807, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "infe" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3834, -1, -1, -1, -1, -1, -1, -1, -1, + // "infer" + ContextualKeyword._infer << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "ins" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3888, -1, -1, -1, -1, -1, -1, + // "inst" + -1, 3915, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "insta" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3942, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "instan" + -1, -1, -1, 3969, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "instanc" + -1, -1, -1, -1, -1, 3996, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "instance" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4023, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "instanceo" + -1, -1, -1, -1, -1, -1, 4050, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "instanceof" + (tt._instanceof << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "int" + -1, -1, -1, -1, -1, 4104, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "inte" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4131, -1, -1, -1, -1, -1, -1, -1, -1, + // "inter" + -1, -1, -1, -1, -1, -1, 4158, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "interf" + -1, 4185, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "interfa" + -1, -1, -1, 4212, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "interfac" + -1, -1, -1, -1, -1, 4239, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "interface" + ContextualKeyword._interface << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "is" + ContextualKeyword._is << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "k" + -1, -1, -1, -1, -1, 4320, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "ke" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4347, -1, + // "key" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4374, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "keyo" + -1, -1, -1, -1, -1, -1, 4401, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "keyof" + ContextualKeyword._keyof << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "l" + -1, -1, -1, -1, -1, 4455, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "le" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4482, -1, -1, -1, -1, -1, -1, + // "let" + (tt._let << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "m" + -1, -1, -1, -1, -1, -1, -1, -1, -1, 4536, -1, -1, -1, -1, -1, 4671, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "mi" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4563, -1, -1, + // "mix" + -1, -1, -1, -1, -1, -1, -1, -1, -1, 4590, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "mixi" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4617, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "mixin" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4644, -1, -1, -1, -1, -1, -1, -1, + // "mixins" + ContextualKeyword._mixins << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "mo" + -1, -1, -1, -1, 4698, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "mod" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4725, -1, -1, -1, -1, -1, + // "modu" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4752, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "modul" + -1, -1, -1, -1, -1, 4779, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "module" + ContextualKeyword._module << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "n" + -1, 4833, -1, -1, -1, 5049, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5103, -1, -1, -1, -1, -1, + // "na" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4860, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "nam" + -1, -1, -1, -1, -1, 4887, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "name" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4914, -1, -1, -1, -1, -1, -1, -1, + // "names" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4941, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "namesp" + -1, 4968, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "namespa" + -1, -1, -1, 4995, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "namespac" + -1, -1, -1, -1, -1, 5022, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "namespace" + ContextualKeyword._namespace << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "ne" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5076, -1, -1, -1, + // "new" + (tt._new << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "nu" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5130, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "nul" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5157, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "null" + (tt._null << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "o" + -1, -1, -1, -1, -1, -1, 5211, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5238, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "of" + ContextualKeyword._of << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "op" + -1, 5265, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "opa" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5292, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "opaq" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5319, -1, -1, -1, -1, -1, + // "opaqu" + -1, -1, -1, -1, -1, 5346, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "opaque" + ContextualKeyword._opaque << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "p" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5400, -1, -1, 5778, -1, -1, -1, -1, -1, + // "pr" + -1, -1, -1, -1, -1, -1, -1, -1, -1, 5427, -1, -1, -1, -1, -1, 5562, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "pri" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5454, -1, -1, -1, -1, + // "priv" + -1, 5481, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "priva" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5508, -1, -1, -1, -1, -1, -1, + // "privat" + -1, -1, -1, -1, -1, 5535, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "private" + ContextualKeyword._private << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "pro" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5589, -1, -1, -1, -1, -1, -1, + // "prot" + -1, -1, -1, -1, -1, 5616, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5751, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "prote" + -1, -1, -1, 5643, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "protec" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5670, -1, -1, -1, -1, -1, -1, + // "protect" + -1, -1, -1, -1, -1, 5697, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "protecte" + -1, -1, -1, -1, 5724, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "protected" + ContextualKeyword._protected << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "proto" + ContextualKeyword._proto << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "pu" + -1, -1, 5805, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "pub" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5832, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "publ" + -1, -1, -1, -1, -1, -1, -1, -1, -1, 5859, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "publi" + -1, -1, -1, 5886, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "public" + ContextualKeyword._public << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "r" + -1, -1, -1, -1, -1, 5940, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "re" + -1, 5967, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6129, -1, -1, 6264, -1, -1, -1, -1, -1, -1, + // "rea" + -1, -1, -1, -1, 5994, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "read" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6021, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "reado" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6048, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "readon" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6075, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "readonl" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6102, -1, + // "readonly" + ContextualKeyword._readonly << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "req" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6156, -1, -1, -1, -1, -1, + // "requ" + -1, -1, -1, -1, -1, -1, -1, -1, -1, 6183, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "requi" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6210, -1, -1, -1, -1, -1, -1, -1, -1, + // "requir" + -1, -1, -1, -1, -1, 6237, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "require" + ContextualKeyword._require << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "ret" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6291, -1, -1, -1, -1, -1, + // "retu" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6318, -1, -1, -1, -1, -1, -1, -1, -1, + // "retur" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6345, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "return" + (tt._return << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "s" + -1, -1, -1, -1, -1, 6399, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6453, 6588, -1, 6696, -1, -1, -1, + // "se" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6426, -1, -1, -1, -1, -1, -1, + // "set" + ContextualKeyword._set << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "st" + -1, 6480, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "sta" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6507, -1, -1, -1, -1, -1, -1, + // "stat" + -1, -1, -1, -1, -1, -1, -1, -1, -1, 6534, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "stati" + -1, -1, -1, 6561, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "static" + ContextualKeyword._static << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "su" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6615, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "sup" + -1, -1, -1, -1, -1, 6642, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "supe" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6669, -1, -1, -1, -1, -1, -1, -1, -1, + // "super" + (tt._super << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "sw" + -1, -1, -1, -1, -1, -1, -1, -1, -1, 6723, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "swi" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6750, -1, -1, -1, -1, -1, -1, + // "swit" + -1, -1, -1, 6777, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "switc" + -1, -1, -1, -1, -1, -1, -1, -1, 6804, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "switch" + (tt._switch << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "t" + -1, -1, -1, -1, -1, -1, -1, -1, 6858, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7020, -1, -1, -1, -1, -1, -1, 7128, -1, + // "th" + -1, -1, -1, -1, -1, -1, -1, -1, -1, 6885, -1, -1, -1, -1, -1, -1, -1, -1, 6939, -1, -1, -1, -1, -1, -1, -1, -1, + // "thi" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6912, -1, -1, -1, -1, -1, -1, -1, + // "this" + (tt._this << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "thr" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6966, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "thro" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6993, -1, -1, -1, + // "throw" + (tt._throw << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "tr" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7047, -1, -1, -1, 7101, -1, + // "tru" + -1, -1, -1, -1, -1, 7074, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "true" + (tt._true << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "try" + (tt._try << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "ty" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7155, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "typ" + -1, -1, -1, -1, -1, 7182, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "type" + ContextualKeyword._type << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7209, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "typeo" + -1, -1, -1, -1, -1, -1, 7236, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "typeof" + (tt._typeof << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "u" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7290, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "un" + -1, -1, -1, -1, -1, -1, -1, -1, -1, 7317, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "uni" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7344, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "uniq" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7371, -1, -1, -1, -1, -1, + // "uniqu" + -1, -1, -1, -1, -1, 7398, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "unique" + ContextualKeyword._unique << 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "v" + -1, 7452, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7506, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "va" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7479, -1, -1, -1, -1, -1, -1, -1, -1, + // "var" + (tt._var << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "vo" + -1, -1, -1, -1, -1, -1, -1, -1, -1, 7533, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "voi" + -1, -1, -1, -1, 7560, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "void" + (tt._void << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "w" + -1, -1, -1, -1, -1, -1, -1, -1, 7614, 7722, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "wh" + -1, -1, -1, -1, -1, -1, -1, -1, -1, 7641, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "whi" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7668, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "whil" + -1, -1, -1, -1, -1, 7695, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "while" + (tt._while << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "wi" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7749, -1, -1, -1, -1, -1, -1, + // "wit" + -1, -1, -1, -1, -1, -1, -1, -1, 7776, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "with" + (tt._with << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "y" + -1, -1, -1, -1, -1, -1, -1, -1, -1, 7830, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "yi" + -1, -1, -1, -1, -1, 7857, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "yie" + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7884, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "yiel" + -1, -1, -1, -1, 7911, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + // "yield" + (tt._yield << 1) + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +]); diff --git a/src/parser/tokenizer/state.ts b/src/parser/tokenizer/state.ts index 4eee0be5..106c1f09 100644 --- a/src/parser/tokenizer/state.ts +++ b/src/parser/tokenizer/state.ts @@ -1,4 +1,5 @@ -import {ContextualKeyword, Token} from "./index"; +import {Token} from "./index"; +import {ContextualKeyword} from "./keywords"; import {TokenType, TokenType as tt} from "./types"; export class Scope { diff --git a/src/parser/traverser/expression.ts b/src/parser/traverser/expression.ts index 13495717..9ec20f68 100644 --- a/src/parser/traverser/expression.ts +++ b/src/parser/traverser/expression.ts @@ -43,7 +43,6 @@ import { tsStartParseObjPropValue, } from "../plugins/typescript"; import { - ContextualKeyword, eat, IdentifierRole, lookaheadType, @@ -54,6 +53,7 @@ import { pushTypeContext, retokenizeSlashAsRegex, } from "../tokenizer/index"; +import {ContextualKeyword} from "../tokenizer/keywords"; import {Scope} from "../tokenizer/state"; import {TokenType, TokenType as tt} from "../tokenizer/types"; import {getNextContextId, isFlowEnabled, isJSXEnabled, isTypeScriptEnabled, state} from "./base"; diff --git a/src/parser/traverser/lval.ts b/src/parser/traverser/lval.ts index 2f10a690..9302146f 100644 --- a/src/parser/traverser/lval.ts +++ b/src/parser/traverser/lval.ts @@ -5,7 +5,6 @@ import { tsParseModifier, } from "../plugins/typescript"; import { - ContextualKeyword, eat, IdentifierRole, match, @@ -13,6 +12,7 @@ import { popTypeContext, pushTypeContext, } from "../tokenizer/index"; +import {ContextualKeyword} from "../tokenizer/keywords"; import {TokenType, TokenType as tt} from "../tokenizer/types"; import {isFlowEnabled, isTypeScriptEnabled, state} from "./base"; import {parseIdentifier, parseMaybeAssign, parseObj} from "./expression"; diff --git a/src/parser/traverser/statement.ts b/src/parser/traverser/statement.ts index 4b9ba1e9..b1c95fda 100644 --- a/src/parser/traverser/statement.ts +++ b/src/parser/traverser/statement.ts @@ -35,7 +35,6 @@ import { tsTryParseTypeParameters, } from "../plugins/typescript"; import { - ContextualKeyword, eat, IdentifierRole, lookaheadType, @@ -45,6 +44,7 @@ import { popTypeContext, pushTypeContext, } from "../tokenizer"; +import {ContextualKeyword} from "../tokenizer/keywords"; import {Scope} from "../tokenizer/state"; import {TokenType, TokenType as tt} from "../tokenizer/types"; import {getNextContextId, isFlowEnabled, isTypeScriptEnabled, state} from "./base"; diff --git a/src/parser/traverser/util.ts b/src/parser/traverser/util.ts index 02216c09..18e18ce9 100644 --- a/src/parser/traverser/util.ts +++ b/src/parser/traverser/util.ts @@ -1,10 +1,5 @@ -import { - ContextualKeyword, - eat, - finishToken, - lookaheadTypeAndKeyword, - match, -} from "../tokenizer/index"; +import {eat, finishToken, lookaheadTypeAndKeyword, match} from "../tokenizer/index"; +import {ContextualKeyword} from "../tokenizer/keywords"; import {formatTokenType, TokenType, TokenType as tt} from "../tokenizer/types"; import {charCodes} from "../util/charcodes"; import {input, state} from "./base"; diff --git a/src/parser/util/identifier.ts b/src/parser/util/identifier.ts index 8000a932..684d8d4e 100644 --- a/src/parser/util/identifier.ts +++ b/src/parser/util/identifier.ts @@ -1,20 +1,7 @@ -import {isWhitespace} from "./whitespace"; +import {charCodes} from "./charcodes"; +import {WHITESPACE_CHARS} from "./whitespace"; -// Test whether a given character code starts an identifier. -export function isIdentifierStart(code: number): boolean { - if (code < 65) return code === 36; - if (code < 91) return true; - if (code < 97) return code === 95; - if (code < 123) return true; - if (code < 128) return false; - // Aside from whitespace and newlines, all characters outside the ASCII space are either - // identifier characters or invalid. Since we're not performing code validation, we can just - // treat all invalid characters as identifier characters. - return !isWhitespace(code) && code !== 0x2028 && code !== 0x2029; -} - -// Test whether a given character is part of an identifier. -export function isIdentifierChar(code: number): boolean { +function computeIsIdentifierChar(code: number): boolean { if (code < 48) return code === 36; if (code < 58) return true; if (code < 65) return false; @@ -22,6 +9,26 @@ export function isIdentifierChar(code: number): boolean { if (code < 97) return code === 95; if (code < 123) return true; if (code < 128) return false; - // False positives are ok for the same reason as in isIdentifierStart. - return !isWhitespace(code) && code !== 0x2028 && code !== 0x2029; + throw new Error("Should not be called with non-ASCII char code."); +} + +export const IS_IDENTIFIER_CHAR = new Uint8Array(65536); +for (let i = 0; i < 128; i++) { + IS_IDENTIFIER_CHAR[i] = computeIsIdentifierChar(i) ? 1 : 0; +} +for (let i = 128; i < 65536; i++) { + IS_IDENTIFIER_CHAR[i] = 1; +} +// Aside from whitespace and newlines, all characters outside the ASCII space are either +// identifier characters or invalid. Since we're not performing code validation, we can just +// treat all invalid characters as identifier characters. +for (const whitespaceChar of WHITESPACE_CHARS) { + IS_IDENTIFIER_CHAR[whitespaceChar] = 0; +} +IS_IDENTIFIER_CHAR[0x2028] = 0; +IS_IDENTIFIER_CHAR[0x2029] = 0; + +export const IS_IDENTIFIER_START = IS_IDENTIFIER_CHAR.slice(); +for (let numChar = charCodes.digit0; numChar <= charCodes.digit9; numChar++) { + IS_IDENTIFIER_START[numChar] = 0; } diff --git a/src/parser/util/whitespace.ts b/src/parser/util/whitespace.ts index eacf143f..18c2239b 100644 --- a/src/parser/util/whitespace.ts +++ b/src/parser/util/whitespace.ts @@ -1,42 +1,31 @@ import {charCodes} from "./charcodes"; -const WHITESPACE_TABLE = new Uint8Array(128); -WHITESPACE_TABLE[0x0009] = 1; -WHITESPACE_TABLE[0x000b] = 1; -WHITESPACE_TABLE[0x000c] = 1; -WHITESPACE_TABLE[charCodes.space] = 1; - // https://tc39.github.io/ecma262/#sec-white-space -export function isWhitespace(code: number): number { - // Fast path for ASCII using a pre-computed table. - if (!(code >>> 7)) { - return WHITESPACE_TABLE[code]; - } - switch (code) { - case 0x0009: // CHARACTER TABULATION - case 0x000b: // LINE TABULATION - case 0x000c: // FORM FEED - case charCodes.space: - case charCodes.nonBreakingSpace: - case charCodes.oghamSpaceMark: - case 0x2000: // EN QUAD - case 0x2001: // EM QUAD - case 0x2002: // EN SPACE - case 0x2003: // EM SPACE - case 0x2004: // THREE-PER-EM SPACE - case 0x2005: // FOUR-PER-EM SPACE - case 0x2006: // SIX-PER-EM SPACE - case 0x2007: // FIGURE SPACE - case 0x2008: // PUNCTUATION SPACE - case 0x2009: // THIN SPACE - case 0x200a: // HAIR SPACE - case 0x202f: // NARROW NO-BREAK SPACE - case 0x205f: // MEDIUM MATHEMATICAL SPACE - case 0x3000: // IDEOGRAPHIC SPACE - case 0xfeff: // ZERO WIDTH NO-BREAK SPACE - return 1; +export const WHITESPACE_CHARS: Array = [ + 0x0009, + 0x000b, + 0x000c, + charCodes.space, + charCodes.nonBreakingSpace, + charCodes.oghamSpaceMark, + 0x2000, // EN QUAD + 0x2001, // EM QUAD + 0x2002, // EN SPACE + 0x2003, // EM SPACE + 0x2004, // THREE-PER-EM SPACE + 0x2005, // FOUR-PER-EM SPACE + 0x2006, // SIX-PER-EM SPACE + 0x2007, // FIGURE SPACE + 0x2008, // PUNCTUATION SPACE + 0x2009, // THIN SPACE + 0x200a, // HAIR SPACE + 0x202f, // NARROW NO-BREAK SPACE + 0x205f, // MEDIUM MATHEMATICAL SPACE + 0x3000, // IDEOGRAPHIC SPACE + 0xfeff, // ZERO WIDTH NO-BREAK SPACE +]; - default: - return 0; - } +export const IS_WHITESPACE = new Uint8Array(65536); +for (const char of WHITESPACE_CHARS) { + IS_WHITESPACE[char] = 1; } diff --git a/src/transformers/CJSImportTransformer.ts b/src/transformers/CJSImportTransformer.ts index fa461a8b..610f8476 100644 --- a/src/transformers/CJSImportTransformer.ts +++ b/src/transformers/CJSImportTransformer.ts @@ -1,5 +1,6 @@ import CJSImportProcessor from "../CJSImportProcessor"; -import {ContextualKeyword, IdentifierRole, isDeclaration} from "../parser/tokenizer"; +import {IdentifierRole, isDeclaration} from "../parser/tokenizer"; +import {ContextualKeyword} from "../parser/tokenizer/keywords"; import {TokenType as tt} from "../parser/tokenizer/types"; import TokenProcessor from "../TokenProcessor"; import RootTransformer from "./RootTransformer"; diff --git a/src/transformers/ESMImportTransformer.ts b/src/transformers/ESMImportTransformer.ts index 7174402f..8b2ad837 100644 --- a/src/transformers/ESMImportTransformer.ts +++ b/src/transformers/ESMImportTransformer.ts @@ -1,4 +1,4 @@ -import {ContextualKeyword} from "../parser/tokenizer"; +import {ContextualKeyword} from "../parser/tokenizer/keywords"; import {TokenType as tt} from "../parser/tokenizer/types"; import TokenProcessor from "../TokenProcessor"; import {getNonTypeIdentifiers} from "../util/getNonTypeIdentifiers"; diff --git a/src/util/getClassInfo.ts b/src/util/getClassInfo.ts index c8673050..abe3a3dd 100644 --- a/src/util/getClassInfo.ts +++ b/src/util/getClassInfo.ts @@ -1,5 +1,6 @@ import NameManager from "../NameManager"; -import {ContextualKeyword, Token} from "../parser/tokenizer"; +import {Token} from "../parser/tokenizer"; +import {ContextualKeyword} from "../parser/tokenizer/keywords"; import {TokenType as tt} from "../parser/tokenizer/types"; import TokenProcessor from "../TokenProcessor"; import RootTransformer from "../transformers/RootTransformer"; diff --git a/src/util/getTSImportedNames.ts b/src/util/getTSImportedNames.ts index 0d9e50a8..69ad3218 100644 --- a/src/util/getTSImportedNames.ts +++ b/src/util/getTSImportedNames.ts @@ -1,4 +1,4 @@ -import {ContextualKeyword} from "../parser/tokenizer"; +import {ContextualKeyword} from "../parser/tokenizer/keywords"; import {TokenType as tt} from "../parser/tokenizer/types"; import TokenProcessor from "../TokenProcessor"; diff --git a/src/util/isIdentifier.ts b/src/util/isIdentifier.ts index ae974ee2..e193759e 100644 --- a/src/util/isIdentifier.ts +++ b/src/util/isIdentifier.ts @@ -1,14 +1,14 @@ -import {isIdentifierChar, isIdentifierStart} from "../parser/util/identifier"; +import {IS_IDENTIFIER_CHAR, IS_IDENTIFIER_START} from "../parser/util/identifier"; export default function isIdentifier(name: string): boolean { if (name.length === 0) { return false; } - if (!isIdentifierStart(name.charCodeAt(0))) { + if (!IS_IDENTIFIER_START[name.charCodeAt(0)]) { return false; } for (let i = 1; i < name.length; i++) { - if (!isIdentifierChar(name.charCodeAt(i))) { + if (!IS_IDENTIFIER_CHAR[name.charCodeAt(i)]) { return false; } }