const impt = { ss, se: d === -2 ? e : d === -1 ? e + 1 : 0, s, e, d, a: -1, n: undefined };

imports.push(impt);

return impt;

exports.push({

s,

e,

ls,

le,

n: s[0] === '"' ? readString(s, '"') : s[0] === "'" ? readString(s, "'") : source.slice(s, e),

ln: ls[0] === '"' ? readString(ls, '"') : ls[0] === "'" ? readString(ls, "'") : source.slice(ls, le)

});

let { d, s } = impt;

if (d !== -1)

s++;

impt.n = readString(s, source.charCodeAt(s - 1));

openTokenDepth = 0;

curDynamicImport = null;

templateDepth = -1;

lastTokenPos = -1;

lastSlashWasDivision = false;

templateStack = Array(1024);

templateStackDepth = 0;

openTokenPosStack = Array(1024);

openClassPosStack = Array(1024);

nextBraceIsClass = false;

facade = true;

name = _name || '@';

imports = [];

exports = [];

source = _source;

pos = -1;

end = source.length - 1;

let ch = 0;

// start with a pure "module-only" parser

m: while (pos++ < end) {

ch = source.charCodeAt(pos);

if (ch === 32 || ch < 14 && ch > 8)

continue;

switch (ch) {

case 101/*e*/:

if (openTokenDepth === 0 && keywordStart(pos) && source.startsWith('xport', pos + 1)) {

tryParseExportStatement();

// export might have been a non-pure declaration

if (!facade) {

lastTokenPos = pos;

break m;

}

}

break;

case 105/*i*/:

if (keywordStart(pos) && source.startsWith('mport', pos + 1))

tryParseImportStatement();

break;

case 59/*;*/:

break;

case 47/*/*/: {

const next_ch = source.charCodeAt(pos + 1);

if (next_ch === 47/*/*/) {

lineComment();

// dont update lastToken

continue;

}

else if (next_ch === 42/***/) {

blockComment(true);

// dont update lastToken

continue;

}

// fallthrough

}

default:

// as soon as we hit a non-module token, we go to main parser

facade = false;

pos--;

break m;

}

lastTokenPos = pos;

}

while (pos++ < end) {

ch = source.charCodeAt(pos);

if (ch === 32 || ch < 14 && ch > 8)

continue;

switch (ch) {

case 101/*e*/:

if (openTokenDepth === 0 && keywordStart(pos) && source.startsWith('xport', pos + 1))

tryParseExportStatement();

break;

case 105/*i*/:

if (keywordStart(pos) && source.startsWith('mport', pos + 1))

tryParseImportStatement();

break;

case 99/*c*/:

if (keywordStart(pos) && source.startsWith('lass', pos + 1) && isBrOrWs(source.charCodeAt(pos + 5)))

nextBraceIsClass = true;

break;

case 40/*(*/:

openTokenPosStack[openTokenDepth++] = lastTokenPos;

break;

case 41/*)*/:

if (openTokenDepth === 0)

syntaxError();

openTokenDepth--;

if (curDynamicImport && curDynamicImport.d === openTokenPosStack[openTokenDepth]) {

if (curDynamicImport.e === 0)

curDynamicImport.e = pos;

curDynamicImport.se = pos;

curDynamicImport = null;

}

break;

case 123/*{*/:

// dynamic import followed by { is not a dynamic import (so remove)

// this is a sneaky way to get around { import () {} } v { import () }

// block / object ambiguity without a parser (assuming source is valid)

if (source.charCodeAt(lastTokenPos) === 41/*)*/ && imports.length && imports[imports.length - 1].e === lastTokenPos) {

imports.pop();

}

openClassPosStack[openTokenDepth] = nextBraceIsClass;

nextBraceIsClass = false;

openTokenPosStack[openTokenDepth++] = lastTokenPos;

break;

case 125/*}*/:

if (openTokenDepth === 0)

syntaxError();

if (openTokenDepth-- === templateDepth) {

templateDepth = templateStack[--templateStackDepth];

templateString();

}

else {

if (templateDepth !== -1 && openTokenDepth < templateDepth)

syntaxError();

}

break;

case 39/*'*/:

case 34/*"*/:

stringLiteral(ch);

break;

case 47/*/*/: {

const next_ch = source.charCodeAt(pos + 1);

if (next_ch === 47/*/*/) {

lineComment();

// dont update lastToken

continue;

}

else if (next_ch === 42/***/) {

blockComment(true);

// dont update lastToken

continue;

}

else {

// Division / regex ambiguity handling based on checking backtrack analysis of:

// - what token came previously (lastToken)

// - if a closing brace or paren, what token came before the corresponding

// opening brace or paren (lastOpenTokenIndex)

const lastToken = source.charCodeAt(lastTokenPos);

if (isExpressionPunctuator(lastToken) &&

!(lastToken === 46/*.*/ && (source.charCodeAt(lastTokenPos - 1) >= 48/*0*/ && source.charCodeAt(lastTokenPos - 1) <= 57/*9*/)) &&

!(lastToken === 43/*+*/ && source.charCodeAt(lastTokenPos - 1) === 43/*+*/) && !(lastToken === 45/*-*/ && source.charCodeAt(lastTokenPos - 1) === 45/*-*/) ||

lastToken === 41/*)*/ && isParenKeyword(openTokenPosStack[openTokenDepth]) ||

lastToken === 125/*}*/ && (isExpressionTerminator(openTokenPosStack[openTokenDepth]) || openClassPosStack[openTokenDepth]) ||

lastToken === 47/*/*/ && lastSlashWasDivision ||

isExpressionKeyword(lastTokenPos) ||

!lastToken) {

regularExpression();

lastSlashWasDivision = false;

}

else {

lastSlashWasDivision = true;

}

}

break;

}

case 96/*`*/:

templateString();

break;

}

lastTokenPos = pos;

}

if (templateDepth !== -1 || openTokenDepth)

syntaxError();

return [imports, exports, facade];

const startPos = pos;

pos += 6;

let ch = commentWhitespace(true);

switch (ch) {

// dynamic import

case 40/*(*/:

openTokenPosStack[openTokenDepth++] = startPos;

if (source.charCodeAt(lastTokenPos) === 46/*.*/)

return;

// dynamic import indicated by positive d

const impt = addImport(startPos, pos + 1, 0, startPos);

curDynamicImport = impt;

// try parse a string, to record a safe dynamic import string

pos++;

ch = commentWhitespace(true);

if (ch === 39/*'*/ || ch === 34/*"*/) {

stringLiteral(ch);

}

else {

pos--;

return;

}

pos++;

ch = commentWhitespace(true);

if (ch === 44/*,*/) {

impt.e = pos;

pos++;

ch = commentWhitespace(true);

impt.a = pos;

readName(impt);

pos--;

}

else if (ch === 41/*)*/) {

openTokenDepth--;

impt.e = pos;

impt.se = pos;

readName(impt);

}

else {

pos--;

}

return;

// import.meta

case 46/*.*/:

pos++;

ch = commentWhitespace(true);

// import.meta indicated by d === -2

if (ch === 109/*m*/ && source.startsWith('eta', pos + 1) && source.charCodeAt(lastTokenPos) !== 46/*.*/)

addImport(startPos, startPos, pos + 4, -2);

return;

default:

// no space after "import" -> not an import keyword

if (pos === startPos + 6)

break;

case 34/*"*/:

case 39/*'*/:

case 123/*{*/:

case 42/***/:

// import statement only permitted at base-level

if (openTokenDepth !== 0) {

pos--;

return;

}

while (pos < end) {

ch = source.charCodeAt(pos);

if (ch === 39/*'*/ || ch === 34/*"*/) {

readImportString(startPos, ch);

return;

}

pos++;

}

syntaxError();

}

const sStartPos = pos;

const prevExport = exports.length;

pos += 6;

const curPos = pos;

let ch = commentWhitespace(true);

if (pos === curPos && !isPunctuator(ch))

return;

switch (ch) {

// export default ...

case 100/*d*/:

addExport(pos, pos + 7, -1, -1);

return;

// export async? function*? name () {

case 97/*a*/:

pos += 5;

commentWhitespace(true);

// fallthrough

case 102/*f*/:

pos += 8;

ch = commentWhitespace(true);

if (ch === 42/***/) {

pos++;

ch = commentWhitespace(true);

}

const startPos = pos;

ch = readToWsOrPunctuator(ch);

addExport(startPos, pos, startPos, pos);

pos--;

return;

// export class name ...

case 99/*c*/:

if (source.startsWith('lass', pos + 1) && isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos + 5))) {

pos += 5;

ch = commentWhitespace(true);

const startPos = pos;

ch = readToWsOrPunctuator(ch);

addExport(startPos, pos, startPos, pos);

pos--;

return;

}

pos += 2;

// fallthrough

// export var/let/const name = ...(, name = ...)+

case 118/*v*/:

case 109/*l*/:

// destructured initializations not currently supported (skipped for { or [)

// also, lexing names after variable equals is skipped (export var p = function () { ... }, q = 5 skips "q")

pos += 2;

facade = false;

do {

pos++;

ch = commentWhitespace(true);

const startPos = pos;

ch = readToWsOrPunctuator(ch);

// dont yet handle [ { destructurings

if (ch === 123/*{*/ || ch === 91/*[*/) {

pos--;

return;

}

if (pos === startPos)

return;

addExport(startPos, pos, startPos, pos);

ch = commentWhitespace(true);

if (ch === 61/*=*/) {

pos--;

return;

}

} while (ch === 44/*,*/);

pos--;

return;

// export {...}

case 123/*{*/:

pos++;

ch = commentWhitespace(true);

while (true) {

const startPos = pos;

readToWsOrPunctuator(ch);

const endPos = pos;

commentWhitespace(true);

ch = readExportAs(startPos, endPos);

// ,

if (ch === 44/*,*/) {

pos++;

ch = commentWhitespace(true);

}

if (ch === 125/*}*/)

break;

if (pos === startPos)

return syntaxError();

if (pos > end)

return syntaxError();

}

pos++;

ch = commentWhitespace(true);

break;

// export *

// export * as X

case 42/***/:

pos++;

commentWhitespace(true);

ch = readExportAs(pos, pos);

ch = commentWhitespace(true);

break;

}

// from ...

if (ch === 102/*f*/ && source.startsWith('rom', pos + 1)) {

pos += 4;

readImportString(sStartPos, commentWhitespace(true));

// There were no local names.

for (let i = prevExport; i < exports.length; ++i) {

exports[i].ls = exports[i].le = -1;

exports[i].ln = undefined;

}

}

else {

pos--;

}

acornPos = start;

let out = '', chunkStart = acornPos;

for (;;) {

if (acornPos >= source.length) syntaxError();

const ch = source.charCodeAt(acornPos);

if (ch === quote) break;

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

out += source.slice(chunkStart, acornPos);

out += readEscapedChar();

chunkStart = acornPos;

}

else if (ch === 0x2028 || ch === 0x2029) {

++acornPos;

}

else {

if (isBr(ch)) syntaxError();

++acornPos;

}

}

out += source.slice(chunkStart, acornPos++);

return out;

let ch = source.charCodeAt(++acornPos);

++acornPos;

switch (ch) {

case 110: return '\n'; // 'n' -> '\n'

case 114: return '\r'; // 'r' -> '\r'

case 120: return String.fromCharCode(readHexChar(2)); // 'x'

case 117: return readCodePointToString(); // 'u'

case 116: return '\t'; // 't' -> '\t'

case 98: return '\b'; // 'b' -> '\b'

case 118: return '\u000b'; // 'v' -> '\u000b'

case 102: return '\f'; // 'f' -> '\f'

case 13: if (source.charCodeAt(acornPos) === 10) ++acornPos; // '\r\n'

case 10: // ' \n'

return '';

case 56:

case 57:

syntaxError();

default:

if (ch >= 48 && ch <= 55) {

let octalStr = source.substr(acornPos - 1, 3).match(/^[0-7]+/)[0];

let octal = parseInt(octalStr, 8);

if (octal > 255) {

octalStr = octalStr.slice(0, -1);

octal = parseInt(octalStr, 8);

}

acornPos += octalStr.length - 1;

ch = source.charCodeAt(acornPos);

if (octalStr !== '0' || ch === 56 || ch === 57)

syntaxError();

return String.fromCharCode(octal);

}

if (isBr(ch)) {

// Unicode new line characters after \ get removed from output in both

// template literals and strings

return '';

}

return String.fromCharCode(ch);

}

const start = acornPos;

let total = 0, lastCode = 0;

for (let i = 0; i < len; ++i, ++acornPos) {

let code = source.charCodeAt(acornPos), val;

if (code === 95) {

if (lastCode === 95 || i === 0) syntaxError();

lastCode = code;

continue;

}

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 break;

if (val >= 16) break;

lastCode = code;

total = total * 16 + val;

}

if (lastCode === 95 || acornPos - start !== len) syntaxError();

return total;

const ch = source.charCodeAt(acornPos);

let code;

if (ch === 123) { // '{'

++acornPos;

code = readHexChar(source.indexOf('}', acornPos) - acornPos);

++acornPos;

if (code > 0x10FFFF) syntaxError();

} else {

code = readHexChar(4);

}

// UTF-16 Decoding

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

code -= 0x10000;

return String.fromCharCode((code >> 10) + 0xD800, (code & 1023) + 0xDC00);

let ch = source.charCodeAt(pos);

let ls = startPos, le = endPos;

if (ch === 97 /*a*/) {

pos += 2;

ch = commentWhitespace(true);

startPos = pos;

readToWsOrPunctuator(ch);

endPos = pos;

ch = commentWhitespace(true);

}

if (pos !== startPos)

addExport(startPos, endPos, ls, le);

return ch;

const startPos = pos + 1;

if (ch === 39/*'*/ || ch === 34/*"*/) {

stringLiteral(ch);

}

else {

syntaxError();

return;

}

const impt = addImport(ss, startPos, pos, -1);

readName(impt);

pos++;

ch = commentWhitespace(false);

if (ch !== 97/*a*/ || !source.startsWith('ssert', pos + 1)) {

pos--;

return;

}

const assertIndex = pos;

pos += 6;

ch = commentWhitespace(true);

if (ch !== 123/*{*/) {

pos = assertIndex;

return;

}

const assertStart = pos;

do {

pos++;

ch = commentWhitespace(true);

if (ch === 39/*'*/ || ch === 34/*"*/) {

stringLiteral(ch);

pos++;

ch = commentWhitespace(true);

}

else {

ch = readToWsOrPunctuator(ch);

}

if (ch !== 58/*:*/) {

pos = assertIndex;

return;

}

pos++;

ch = commentWhitespace(true);

if (ch === 39/*'*/ || ch === 34/*"*/) {

stringLiteral(ch);

}

else {

pos = assertIndex;

return;

}

pos++;

ch = commentWhitespace(true);

if (ch === 44/*,*/) {

pos++;

ch = commentWhitespace(true);

if (ch === 125/*}*/)

break;

continue;

}

if (ch === 125/*}*/)

break;

pos = assertIndex;

return;

} while (true);

impt.a = assertStart;

impt.se = pos + 1;

let ch;

do {

ch = source.charCodeAt(pos);

if (ch === 47/*/*/) {

const next_ch = source.charCodeAt(pos + 1);

if (next_ch === 47/*/*/)

lineComment();

else if (next_ch === 42/***/)

blockComment(br);

else

return ch;

}

else if (br ? !isBrOrWs(ch): !isWsNotBr(ch)) {

return ch;

}

} while (pos++ < end);

return ch;

while (pos++ < end) {

const ch = source.charCodeAt(pos);

if (ch === 36/*$*/ && source.charCodeAt(pos + 1) === 123/*{*/) {

pos++;

templateStack[templateStackDepth++] = templateDepth;

templateDepth = ++openTokenDepth;

return;

}

if (ch === 96/*`*/)

return;

if (ch === 92/*\*/)

pos++;

}

syntaxError();

pos++;

while (pos++ < end) {

const ch = source.charCodeAt(pos);

if (!br && isBr(ch))

return;

if (ch === 42/***/ && source.charCodeAt(pos + 1) === 47/*/*/) {

pos++;

return;

}

}

while (pos++ < end) {

const ch = source.charCodeAt(pos);

if (ch === 10/*\n*/ || ch === 13/*\r*/)

return;

}

while (pos++ < end) {

let ch = source.charCodeAt(pos);

if (ch === quote)

return;

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

ch = source.charCodeAt(++pos);

if (ch === 13/*\r*/ && source.charCodeAt(pos + 1) === 10/*\n*/)

pos++;

}

else if (isBr(ch))

break;

}

syntaxError();

while (pos++ < end) {

let ch = source.charCodeAt(pos);

if (ch === 93/*]*/)

return ch;

if (ch === 92/*\*/)

pos++;

else if (ch === 10/*\n*/ || ch === 13/*\r*/)

break;

}

syntaxError();

while (pos++ < end) {

let ch = source.charCodeAt(pos);

if (ch === 47/*/*/)

return;

if (ch === 91/*[*/)

ch = regexCharacterClass();

else if (ch === 92/*\*/)

pos++;

else if (ch === 10/*\n*/ || ch === 13/*\r*/)

break;

}

syntaxError();

do {

if (isBrOrWs(ch) || isPunctuator(ch))

return ch;

} while (ch = source.charCodeAt(++pos));

return ch;

if (pos < match.length - 1)

return false;

return source.startsWith(match, pos - match.length + 1) && (pos === 0 || isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos - match.length)));

switch (source.charCodeAt(pos)) {

case 100/*d*/:

switch (source.charCodeAt(pos - 1)) {

case 105/*i*/:

// void

return readPrecedingKeyword(pos - 2, 'vo');

case 108/*l*/:

// yield

return readPrecedingKeyword(pos - 2, 'yie');

default:

return false;

}

case 101/*e*/:

switch (source.charCodeAt(pos - 1)) {

case 115/*s*/:

switch (source.charCodeAt(pos - 2)) {

case 108/*l*/:

// else

return readPrecedingKeyword1(pos - 3, 101/*e*/);

case 97/*a*/:

// case

return readPrecedingKeyword1(pos - 3, 99/*c*/);

default:

return false;

}

case 116/*t*/:

// delete

return readPrecedingKeyword(pos - 2, 'dele');

default:

return false;

}

case 102/*f*/:

if (source.charCodeAt(pos - 1) !== 111/*o*/ || source.charCodeAt(pos - 2) !== 101/*e*/)

return false;

switch (source.charCodeAt(pos - 3)) {

case 99/*c*/:

// instanceof

return readPrecedingKeyword(pos - 4, 'instan');

case 112/*p*/:

// typeof

return readPrecedingKeyword(pos - 4, 'ty');

default:

return false;

}

case 110/*n*/:

// in, return

return readPrecedingKeyword1(pos - 1, 105/*i*/) || readPrecedingKeyword(pos - 1, 'retur');

case 111/*o*/:

// do

return readPrecedingKeyword1(pos - 1, 100/*d*/);

case 114/*r*/:

// debugger

return readPrecedingKeyword(pos - 1, 'debugge');

case 116/*t*/:

// await

return readPrecedingKeyword(pos - 1, 'awai');

case 119/*w*/:

switch (source.charCodeAt(pos - 1)) {

case 101/*e*/:

// new

return readPrecedingKeyword1(pos - 2, 110/*n*/);

case 111/*o*/:

// throw

return readPrecedingKeyword(pos - 2, 'thr');

default:

return false;

}

}

return false;

return source.charCodeAt(curPos) === 101/*e*/ && source.startsWith('whil', curPos - 4) ||

source.charCodeAt(curPos) === 114/*r*/ && source.startsWith('fo', curPos - 2) ||

source.charCodeAt(curPos - 1) === 105/*i*/ && source.charCodeAt(curPos) === 102/*f*/;

// 23 possible punctuator endings: !%&()*+,-./:;<=>?[]^{}|~

return ch === 33/*!*/ || ch === 37/*%*/ || ch === 38/*&*/ ||

ch > 39 && ch < 48 || ch > 57 && ch < 64 ||

ch === 91/*[*/ || ch === 93/*]*/ || ch === 94/*^*/ ||

ch > 122 && ch < 127;

// 20 possible expression endings: !%&(*+,-.:;<=>?[^{|~

return ch === 33/*!*/ || ch === 37/*%*/ || ch === 38/*&*/ ||

ch > 39 && ch < 47 && ch !== 41 || ch > 57 && ch < 64 ||

ch === 91/*[*/ || ch === 94/*^*/ || ch > 122 && ch < 127 && ch !== 125/*}*/;

// detects:

// => ; ) finally catch else

// as all of these followed by a { will indicate a statement brace

switch (source.charCodeAt(curPos)) {

case 62/*>*/:

return source.charCodeAt(curPos - 1) === 61/*=*/;

case 59/*;*/:

case 41/*)*/:

return true;

case 104/*h*/:

return source.startsWith('catc', curPos - 4);

case 121/*y*/:

return source.startsWith('finall', curPos - 6);

case 101/*e*/:

return source.startsWith('els', curPos - 3);

}

return false;