protected final Options options;

protected final Set<String> keywords;

private final Set<String> reservedWords, reservedWordsStrict, reservedWordsStrictBind;

protected final String input;

private boolean containsEsc;

protected boolean exprAllowed;

protected boolean strict;

private boolean inModule;

protected boolean inFunction;

protected boolean inGenerator;

protected boolean inClass;

protected boolean inAsync;

protected boolean inTemplateElement;

protected int pos;

protected int lineStart;

protected int curLine;

protected int start;

protected int end;

protected TokenType type;

protected Object value;

protected Position startLoc;

protected Position endLoc;

protected Position lastTokEndLoc, lastTokStartLoc;

protected int lastTokStart, lastTokEnd;

protected Stack<TokContext> context;

protected int potentialArrowAt;

private Stack<LabelInfo> labels;

protected int yieldPos, awaitPos;

/**

protected boolean seenUnderscoreNumericSeparator = false;

/**

private static final boolean noDeclareKeyword = false;

/**

protected static final boolean notAbstract = false;

/**

private static final ITypeExpression noTypeAnnotation = null;

protected static class LabelInfo {

String name, kind;

int statementStart;

public LabelInfo(String name, String kind, int statementStart) {

this.name = name;

this.kind = kind;

this.statementStart = statementStart;

}

}

public static void main(String[] args) {

new Parser(new Options(), new WholeIO().strictread(new File(args[0])), 0).parse();

}

/// begin state.js

public Parser(Options options, String input, int startPos) {

this.options = options;

this.keywords =

new LinkedHashSet<String>(

Identifiers.keywords.get(

options.ecmaVersion() >= 6

? Identifiers.Dialect.ECMA_6

: Identifiers.Dialect.ECMA_5));

this.reservedWords = new LinkedHashSet<String>();

if (!options.allowReserved().isTrue()) {

this.reservedWords.addAll(Identifiers.reservedWords.get(options.getDialect()));

if (options.sourceType().equals("module")) this.reservedWords.add("await");

}

this.reservedWordsStrict = new LinkedHashSet<String>(this.reservedWords);

this.reservedWordsStrict.addAll(Identifiers.reservedWords.get(Dialect.STRICT));

this.reservedWordsStrictBind = new LinkedHashSet<String>(this.reservedWordsStrict);

this.reservedWordsStrictBind.addAll(Identifiers.reservedWords.get(Dialect.STRICT_BIND));

this.input = input;

// Used to signal to callers of `readWord1` whether the word

// contained any escape sequences. This is needed because words with

// escape sequences must not be interpreted as keywords.

this.containsEsc = false;

// Set up token state

// The current position of the tokenizer in the input.

if (startPos != 0) {

this.pos = startPos;

this.lineStart = this.input.lastIndexOf("\n", startPos - 1) + 1;

this.curLine = inputSubstring(0, this.lineStart).split(Whitespace.lineBreak).length;

} else {

this.pos = this.lineStart = 0;

this.curLine = 1;

}

// Properties of the current token:

// Its type

this.type = TokenType.eof;

// For tokens that include more information than their type, the value

this.value = null;

// Its start and end offset

this.start = this.end = this.pos;

// And, if locations are used, the {line, column} object

// corresponding to those offsets

this.startLoc = this.endLoc = this.curPosition();

// Position information for the previous token

this.lastTokEndLoc = this.lastTokStartLoc = null;

this.lastTokStart = this.lastTokEnd = this.pos;

// The context stack is used to superficially track syntactic

// context to predict whether a regular expression is allowed in a

// given position.

this.context = this.initialContext();

this.exprAllowed = true;

// Figure out if it's a module code.

this.inModule = options.sourceType().equals("module");

// We don't care to report syntax errors in code that might be using strict mode. In

// the end, we don't know whether that code is put through additional build steps

// causing our alleged syntax errors to disappear. Therefore, we hardcode

// this.strict to false.

this.strict = false;

// Used to signify the start of a potential arrow function

this.potentialArrowAt = -1;

// Flags to track whether we are in a function, a generator, an async function, a class.

this.inFunction = this.inGenerator = this.inAsync = this.inClass = false;

// Positions to delayed-check that yield/await does not exist in default parameters.

this.yieldPos = this.awaitPos = 0;

// Labels in scope.

this.labels = new Stack<LabelInfo>();

// If enabled, skip leading hashbang line.

if (this.pos == 0 && options.allowHashBang() && this.input.startsWith("#!"))

this.skipLineComment(2);

}

public Program parse() {

Position startLoc = this.startLoc;

this.nextToken();

return this.parseTopLevel(startLoc, this.options.program());

}

/// end state.js

/// begin location.js

protected void raise(int pos, String msg, boolean recoverable) {

Position loc = Locutil.getLineInfo(input, pos);

raise(loc, msg, recoverable);

}

protected void raise(int pos, String msg) {

raise(pos, msg, false);

}

@SuppressWarnings("ReturnValueIgnored")

protected void raise(Position loc, String msg, boolean recoverable) {

msg += " (" + loc.getLine() + ":" + loc.getColumn() + ")";

SyntaxError err = new SyntaxError(msg, loc, this.pos);

if (recoverable && options.onRecoverableError() != null)

options.onRecoverableError().apply(err);

else throw err;

}

protected void raise(Position loc, String msg) {

raise(loc, msg, false);

}

protected void raise(INode nd, String msg) {

raise(nd.getLoc().getStart(), msg, false);

}

protected void raiseRecoverable(int pos, String msg) {

raise(pos, msg, true);

}

protected void raiseRecoverable(INode nd, String msg) {

raise(nd.getLoc().getStart(), msg, true);

}

protected Position curPosition() {

return new Position(curLine, pos - lineStart, pos);

}

/// end location.js

/// begin tokenize.js

// Move to the next token

protected void next() {

if (this.options.onToken() != null) this.options.onToken().apply(mkToken());

this.lastTokEnd = this.end;

this.lastTokStart = this.start;

this.lastTokEndLoc = this.endLoc;

this.lastTokStartLoc = this.startLoc;

this.nextToken();

}

// DEPRECATED. When we respected strict mode, this method was used to toggle strict

// mode (and would re-read the next number or string to please pedantic tests (`"use

// strict"; 010;` should fail)).

public void setStrict(boolean strict) {

// always false

return;

}

public TokContext curContext() {

return context.peek();

}

// Read a single token, updating the parser object's token-related

// properties.

public Token nextToken() {

TokContext curContext = this.curContext();

if (curContext == null || !curContext.preserveSpace) this.skipSpace();

this.start = this.pos;

this.startLoc = this.curPosition();

if (this.pos >= this.input.length()) return this.finishToken(TokenType.eof);

if (curContext != null && curContext.override != null) return curContext.override.apply(this);

else return this.readToken(this.fullCharCodeAtPos());

}

protected Token readToken(int code) {

// Identifier or keyword. '\\uXXXX' sequences are allowed in

// identifiers, so '\' also dispatches to that.

if (Identifiers.isIdentifierStart(code, this.options.ecmaVersion() >= 6)

|| code == 92 /* '\' */) return this.readWord();

return this.getTokenFromCode(code);

}

protected int fullCharCodeAtPos() {

int code = charAt(this.pos);

if (code <= 0xd7ff || code >= 0xe000) return code;

int next = charAt(this.pos + 1);

return (code << 10) + next - 0x35fdc00;

}

protected void skipBlockComment() {

Position startLoc = this.options.onComment() != null ? this.curPosition() : null;

int start = this.pos, end = this.input.indexOf("*/", this.pos += 2);

if (end == -1) this.raise(this.pos - 2, "Unterminated comment");

this.pos = end + 2;

Matcher m = Whitespace.lineBreakG.matcher(this.input);

int next = start;

while (m.find(next) && m.start() < this.pos) {

++this.curLine;

lineStart = m.end();

next = lineStart;

}

if (this.options.onComment() != null)

this.options

.onComment()

.call(

true,

this.input,

inputSubstring(start + 2, end),

start,

this.pos,

startLoc,

this.curPosition());

}

protected void skipLineComment(int startSkip) {

int start = this.pos;

Position startLoc = this.options.onComment() != null ? this.curPosition() : null;

this.pos += startSkip;

int ch = charAt(this.pos);

while (this.pos < this.input.length() && ch != 10 && ch != 13 && ch != 8232 && ch != 8233) {

++this.pos;

ch = charAt(this.pos);

}

if (this.options.onComment() != null)

this.options

.onComment()

.call(

false,

this.input,

inputSubstring(start + startSkip, this.pos),

start,

this.pos,

startLoc,

this.curPosition());

}

// Called at the start of the parse and after every token. Skips

// whitespace and comments, and.

protected void skipSpace() {

loop:

while (this.pos < this.input.length()) {

int ch = this.input.charAt(this.pos);

switch (ch) {

case 32:

case 160: // ' '

++this.pos;

break;

case 13:

if (charAt(this.pos + 1) == 10) {

++this.pos;

}

case 10:

case 8232:

case 8233:

++this.pos;

++this.curLine;

this.lineStart = this.pos;

break;

case 47: // '/'

switch (charAt(this.pos + 1)) {

case 42: // '*'

this.skipBlockComment();

break;

case 47:

this.skipLineComment(2);

break;

default:

break loop;

}

break;

default:

if (ch > 8 && ch < 14 || ch >= 5760 && Whitespace.nonASCIIwhitespace.indexOf(ch) > -1) {

++this.pos;

} else {

break loop;

}

}

}

}

// Called at the end of every token. Sets `end`, `val`, and

// maintains `context` and `exprAllowed`, and skips the space after

// the token, so that the next one's `start` will point at the

// right position.

protected Token finishToken(TokenType type, Object val) {

this.end = this.pos;

this.endLoc = this.curPosition();

TokenType prevType = this.type;

this.type = type;

this.value = val;

this.updateContext(prevType);

return mkToken();

}

private Token mkToken() {

String src = inputSubstring(start, end);

SourceLocation loc = new SourceLocation(src, startLoc, endLoc);

String label, keyword;

if (isKeyword(src)) {

label = keyword = src;

} else {

label = type.label;

keyword = type.keyword;

}

return new Token(loc, label, keyword);

}

protected boolean isKeyword(String src) {

if (type.keyword != null) return true;

if (type == TokenType.name) {

if (keywords.contains(src)) return true;

if (options.ecmaVersion() >= 6 && ("let".equals(src) || "yield".equals(src))) return true;

}

return false;

}

protected Token finishToken(TokenType type) {

return finishToken(type, null);

}

// ### Token reading

// This is the function that is called to fetch the next token. It

// is somewhat obscure, because it works in character codes rather

// than characters, and because operator parsing has been inlined

// into it.

//

// All in the name of speed.

//

private Token readToken_dot() {

int next = charAt(this.pos + 1);

if (next >= 48 && next <= 57) return this.readNumber(true);

int next2 = charAt(this.pos + 2);

if (this.options.ecmaVersion() >= 6 && next == 46 && next2 == 46) { // 46 = dot '.'

this.pos += 3;

return this.finishToken(TokenType.ellipsis);

} else {

++this.pos;

return this.finishToken(TokenType.dot);

}

}

private Token readToken_question() { // '?'

int next = charAt(this.pos + 1);

int next2 = charAt(this.pos + 2);

if (this.options.esnext()) {

if (next == '.' && !('0' <= next2 && next2 <= '9')) // '?.', but not '?.X' where X is a digit

return this.finishOp(TokenType.questiondot, 2);

if (next == '?') { // '??'

if (next2 == '=') { // ??=

return this.finishOp(TokenType.assign, 3);

}

return this.finishOp(TokenType.questionquestion, 2);

}

}

return this.finishOp(TokenType.question, 1);

}

private Token readToken_slash() { // '/'

int next = charAt(this.pos + 1);

if (this.exprAllowed) {

++this.pos;

return this.readRegexp();

}

if (next == 61) return this.finishOp(TokenType.assign, 2);

return this.finishOp(TokenType.slash, 1);

}

private Token readToken_mult_modulo_exp(int code) { // '%*'

int next = charAt(this.pos + 1);

int size = 1;

TokenType tokentype = code == 42 ? TokenType.star : TokenType.modulo;

// exponentiation operator ** and **=

if (this.options.ecmaVersion() >= 7 && code == 42 && next == 42) {

++size;

tokentype = TokenType.starstar;

next = charAt(this.pos + 2);

}

if (next == 61) return this.finishOp(TokenType.assign, size + 1);

return this.finishOp(tokentype, size);

}

private Token readToken_pipe_amp(int code) { // '|&'

int next = charAt(this.pos + 1);

int next2 = charAt(this.pos + 2);

if (next == code) { // && ||

if (next2 == 61) return this.finishOp(TokenType.assign, 3); // &&= ||=

return this.finishOp(code == 124 ? TokenType.logicalOR : TokenType.logicalAND, 2);

}

if (next == 61) return this.finishOp(TokenType.assign, 2);

return this.finishOp(code == 124 ? TokenType.bitwiseOR : TokenType.bitwiseAND, 1);

}

private Token readToken_caret() { // '^'

int next = charAt(this.pos + 1);

if (next == 61) return this.finishOp(TokenType.assign, 2);

return this.finishOp(TokenType.bitwiseXOR, 1);

}

private Token readToken_plus_min(int code) { // '+-'

int next = charAt(this.pos + 1);

if (next == code) {

if (next == 45

&& charAt(this.pos + 2) == 62

&& inputSubstring(this.lastTokEnd, this.pos).matches("(?s).*(?:" + lineBreak + ").*")) {

// A `-->` line comment

this.skipLineComment(3);

this.skipSpace();

return this.nextToken();

}

return this.finishOp(TokenType.incDec, 2);

}

if (next == 61) return this.finishOp(TokenType.assign, 2);

return this.finishOp(TokenType.plusMin, 1);

}

private Token readToken_lt_gt(int code) { // '<>'

int next = charAt(this.pos + 1);

int size = 1;

if (next == code) {

size = code == 62 && charAt(this.pos + 2) == 62 ? 3 : 2;

if (charAt(this.pos + size) == 61) return this.finishOp(TokenType.assign, size + 1);

return this.finishOp(TokenType.bitShift, size);

}

if (next == 33 && code == 60 && charAt(this.pos + 2) == 45 && charAt(this.pos + 3) == 45) {

if (this.inModule) this.unexpected();

// `<!--`, an XML-style comment that should be interpreted as a line comment

this.skipLineComment(4);

this.skipSpace();

return this.nextToken();

}

if (next == '%' && code == '<' && this.options.allowGeneratedCodeExprs()) {

// `<%`, the beginning of an EJS-style template tag

size = 2;

int nextNext = charAt(this.pos + 2);

if (nextNext == '=' || nextNext == '-') {

++size;

}

return this.finishOp(TokenType.generatedCodeDelimiterEJS, size);

}

if (next == 61) size = 2;

return this.finishOp(TokenType.relational, size);

}

private Token readToken_eq_excl(int code) { // '=!'

int next = charAt(this.pos + 1);

if (next == 61) return this.finishOp(TokenType.equality, charAt(this.pos + 2) == 61 ? 3 : 2);

if (code == 61 && next == 62 && this.options.ecmaVersion() >= 6) { // '=>'

this.pos += 2;

return this.finishToken(TokenType.arrow);

}

return this.finishOp(code == 61 ? TokenType.eq : TokenType.prefix, 1);

}

protected Token getTokenFromCode(int code) {

switch (code) {

// The interpretation of a dot depends on whether it is followed

// by a digit or another two dots.

case 46: // '.'

return this.readToken_dot();

// Punctuation tokens.

case 40:

++this.pos;

return this.finishToken(TokenType.parenL);

case 41:

++this.pos;

return this.finishToken(TokenType.parenR);

case 59:

++this.pos;

return this.finishToken(TokenType.semi);

case 44:

++this.pos;

return this.finishToken(TokenType.comma);

case 91:

++this.pos;

return this.finishToken(TokenType.bracketL);

case 93:

++this.pos;

return this.finishToken(TokenType.bracketR);

case 123:

++this.pos;

return this.finishToken(TokenType.braceL);

case 125:

++this.pos;

return this.finishToken(TokenType.braceR);

case 58:

++this.pos;

return this.finishToken(TokenType.colon);

case 35:

++this.pos;

return this.finishToken(TokenType.pound);

case 63:

return this.readToken_question();

case 96: // '`'

if (this.options.ecmaVersion() < 6) break;

++this.pos;

return this.finishToken(TokenType.backQuote);

case 48: // '0'

int next = charAt(this.pos + 1);

if (next == 120 || next == 88) return this.readRadixNumber(16); // '0x', '0X' - hex number

if (this.options.ecmaVersion() >= 6) {

if (next == 111 || next == 79)

return this.readRadixNumber(8); // '0o', '0O' - octal number

if (next == 98 || next == 66)

return this.readRadixNumber(2); // '0b', '0B' - binary number

}

// Anything else beginning with a digit is an integer, octal

// number, or float.

case 49:

case 50:

case 51:

case 52:

case 53:

case 54:

case 55:

case 56:

case 57: // 1-9

return this.readNumber(false);

// Quotes produce strings.

case 34:

case 39: // '"', "'"

return this.readString((char) code);

// Operators are parsed inline in tiny state machines. '=' (61) is

// often referred to. `finishOp` simply skips the amount of

// characters it is given as second argument, and returns a token

// of the type given by its first argument.

case 47: // '/'

return this.readToken_slash();

case 37:

case 42: // '%*'

return this.readToken_mult_modulo_exp(code);

case 124: // '|'

case 38: // '&'

return this.readToken_pipe_amp(code);

case 94: // '^'

return this.readToken_caret();

case 43:

case 45: // '+-'

return this.readToken_plus_min(code);

case 60:

case 62: // '<>'

return this.readToken_lt_gt(code);

case 61:

case 33: // '=!'

return this.readToken_eq_excl(code);

case 126: // '~'

return this.finishOp(TokenType.prefix, 1);

}

String msg = String.format("Unexpected character '%s' (U+%04X)", codePointToString(code), code);

this.raise(this.pos, msg);

return null;

}

protected Token finishOp(TokenType type, int size) {

String str = inputSubstring(this.pos, this.pos + size);

this.pos += size;

return this.finishToken(type, str);

}

private Token readRegexp() {

boolean escaped = false, inClass = false;

int start = this.pos;

for (; ; ) {

if (this.pos >= this.input.length()) this.raise(start, "Unterminated regular expression");

int ch = this.input.charAt(this.pos);

if (isNewLine(ch)) this.raise(start, "Unterminated regular expression");

if (!escaped) {

if (ch == '[') inClass = true;

else if (ch == ']' && inClass) inClass = false;

else if (ch == '/' && !inClass) break;

escaped = ch == '\\';

} else {

escaped = false;

}

++this.pos;

}

String content = inputSubstring(start, this.pos);

++this.pos;

// Need to use `readWord1` because '\\uXXXX' sequences are allowed

// here (don't ask).

String mods = this.readWord1();

if (mods != null) {

String validFlags = "gim";

if (this.options.ecmaVersion() >= 6) validFlags = "gimuy";

if (this.options.ecmaVersion() >= 9) validFlags = "gimsuy";

if (this.options.ecmaVersion() >= 15) validFlags = "gimsuyv";

if (!mods.matches("^[" + validFlags + "]*$"))

this.raise(start, "Invalid regular expression flag");

if (mods.indexOf('u') >= 0) {

Matcher m = Pattern.compile("\\\\u\\{([0-9a-fA-F]+)\\}").matcher(content);

while (m.find()) {

try {

int code = Integer.parseInt(m.group(1), 16);

if (code > 0x10FFFF)

this.raiseRecoverable(start + m.start() + 3, "Code point out of bounds");

} catch (NumberFormatException nfe) {

Exceptions.ignore(nfe, "Don't complain about code points we don't understand.");

}

}

}

}

return this.finishToken(TokenType.regexp, content);

}

// Read an integer in the given radix. Return null if zero digits

// were read, the integer value otherwise. When `len` is given, this

// will return `null` unless the integer has exactly `len` digits.

protected Number readInt(int radix, Integer len) {

int start = this.pos;

double total = 0;

for (int i = 0, e = len == null ? Integer.MAX_VALUE : len; i < e; ++i) {

if (this.pos >= this.input.length()) break;

int code = this.input.charAt(this.pos), val;

if (code >= 97) val = code - 97 + 10; // a

else if (code >= 65) val = code - 65 + 10; // A

else if (code >= 48 && code <= 57) val = code - 48; // 0-9

else val = Integer.MAX_VALUE;

if (val >= radix) break;

++this.pos;

total = total * radix + val;

}

if (this.pos == start || len != null && this.pos - start != len) return null;

return total;

}

protected Token readRadixNumber(int radix) {

this.pos += 2; // 0x

Number val = this.readInt(radix, null);

if (val == null) this.raise(this.start + 2, "Expected number in radix " + radix);

// check for bigint literal

if (options.esnext() && this.fullCharCodeAtPos() == 'n') {

++this.pos;

return this.finishToken(TokenType.bigint, val);

}

if (Identifiers.isIdentifierStart(this.fullCharCodeAtPos(), false))

this.raise(this.pos, "Identifier directly after number");

return this.finishToken(TokenType.num, val);

}

// Read an integer, octal integer, or floating-point number.

protected Token readNumber(boolean startsWithDot) {

int start = this.pos;

boolean isFloat = false, octal = charAt(this.pos) == 48, isBigInt = false;

if (!startsWithDot && this.readInt(10, null) == null) this.raise(start, "Invalid number");

if (octal && this.pos == start + 1) octal = false;

if (this.pos < this.input.length()) {

int next = this.input.charAt(this.pos);

if (next == 46 && !octal) { // '.'

++this.pos;

this.readInt(10, null);

isFloat = true;

next = charAt(this.pos);

}

if ((next == 69 || next == 101) && !octal) { // 'eE'

next = charAt(++this.pos);

if (next == 43 || next == 45) ++this.pos; // '+-'

if (this.readInt(10, null) == null) this.raise(start, "Invalid number");

isFloat = true;

}

if (!isFloat && options.esnext() && this.fullCharCodeAtPos() == 'n') isBigInt = true;

else if (Identifiers.isIdentifierStart(this.fullCharCodeAtPos(), false))

this.raise(this.pos, "Identifier directly after number");

}

String str = inputSubstring(start, this.pos);

if (seenUnderscoreNumericSeparator) {

str = str.replace("_", "");

seenUnderscoreNumericSeparator = false;

}

Number val = null;

if (isFloat) val = parseFloat(str);

else if (!octal || str.length() == 1) val = parseInt(str, 10);

else if (str.matches(".*[89].*") || this.strict) this.raise(start, "Invalid number");

else val = parseInt(str, 8);

// handle bigints

if (isBigInt) {

++this.pos;

return this.finishToken(TokenType.bigint, val);

}

return this.finishToken(TokenType.num, val);

}

// Read a string value, interpreting backslash-escapes.

protected int readCodePoint() {

int ch = charAt(this.pos), code;

if (ch == 123) {

if (this.options.ecmaVersion() < 6) this.unexpected();

int codePos = ++this.pos;

code = this.readHexChar(this.input.indexOf('}', this.pos) - this.pos);

++this.pos;

if (code > 0x10FFFF) this.invalidStringToken(codePos, "Code point out of bounds");

} else {

code = this.readHexChar(4);

}

return code;

}

protected String codePointToString(int code) {

// UTF-16 Decoding

if (code <= 0xFFFF) return String.valueOf((char) code);

code -= 0x10000;

return new String(new char[] {(char) ((code >> 10) + 0xD800), (char) ((code & 1023) + 0xDC00)});

}

protected Token readString(char quote) {

StringBuilder out = new StringBuilder();

int chunkStart = ++this.pos;

for (; ; ) {

if (this.pos >= this.input.length()) this.raise(this.start, "Unterminated string constant");

int ch = this.input.charAt(this.pos);

if (ch == quote) break;

if (ch == 92) { // '\'

out.append(inputSubstring(chunkStart, this.pos));

out.append(this.readEscapedChar(false));

chunkStart = this.pos;

} else if (options.ecmaVersion() >= 10 && (ch == 0x2028 || ch == 0x2029)) {

// ECMAScript 2019 allows Unicode newlines in string literals

++this.pos;

} else {

if (Whitespace.isNewLine(ch)) this.raise(this.start, "Unterminated string constant");

++this.pos;

}

}

out.append(inputSubstring(chunkStart, this.pos++));

return this.finishToken(TokenType.string, out.toString());

}

// Reads template string tokens.

private static final RuntimeException INVALID_TEMPLATE_ESCAPE_ERROR = new RuntimeException();

private Token tryReadTemplateToken() {

this.inTemplateElement = true;

try {

return this.readTmplToken();

} catch (RuntimeException err) {

if (err == INVALID_TEMPLATE_ESCAPE_ERROR) {

return this.readInvalidTemplateToken();

} else {

throw err;

}

} finally {

this.inTemplateElement = false;

}

}

private void invalidStringToken(int position, String message) {

if (this.inTemplateElement && this.options.ecmaVersion() >= 9) {

throw INVALID_TEMPLATE_ESCAPE_ERROR;

} else {

this.raise(position, message);

}

}

protected Token readTmplToken() {

StringBuilder out = new StringBuilder();

int chunkStart = this.pos;

for (; ; ) {

if (this.pos >= this.input.length()) this.raise(this.start, "Unterminated template");

int ch = this.input.charAt(this.pos);

if (ch == 96 || ch == 36 && charAt(this.pos + 1) == 123) { // '`', '${'

if (this.pos == this.start

&& (this.type == TokenType.template || this.type == TokenType.invalidTemplate)) {

if (ch == 36) {

this.pos += 2;

return this.finishToken(TokenType.dollarBraceL);

} else {

++this.pos;

return this.finishToken(TokenType.backQuote);

}

}

out.append(inputSubstring(chunkStart, this.pos));

return this.finishToken(TokenType.template, out.toString());

}

if (ch == 92) { // '\'

out.append(inputSubstring(chunkStart, this.pos));

out.append(this.readEscapedChar(true));

chunkStart = this.pos;

} else if (Whitespace.isNewLine(ch)) {

out.append(inputSubstring(chunkStart, this.pos));

++this.pos;

switch (ch) {

case 13:

if (charAt(this.pos) == 10) ++this.pos;

case 10:

out.append('\n');

break;