xiaoz
/
vue-hello
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
vue hello world项目
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 Commit
1 Branch
0 Tags
23 MiB
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
vue-hello/node_modules/es-module-lexer/lexer.js

899 lines
25 KiB
Raw Permalink Blame History

let source, pos, end,
openTokenDepth,
lastTokenPos,
openTokenPosStack,
openClassPosStack,
curDynamicImport,
templateStackDepth,
facade,
lastSlashWasDivision,
nextBraceIsClass,
templateDepth,
templateStack,
imports,
exports,
name;
function addImport (ss, s, e, d) {
const impt = { ss, se: d === -2 ? e : d === -1 ? e + 1 : 0, s, e, d, a: -1, n: undefined };
imports.push(impt);
return impt;
}
function readName (impt) {
let { d, s } = impt;
if (d !== -1)
s++;
impt.n = readString(s, source.charCodeAt(s - 1));
}
// Note: parsing is based on the _assumption_ that the source is already valid
export function parse (_source, _name) {
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 = new Set();
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];
}
function tryParseImportStatement () {
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();
}
}
function tryParseExportStatement () {
const sStartPos = pos;
pos += 6;
const curPos = pos;
let ch = commentWhitespace(true);
if (pos === curPos && !isPunctuator(ch))
return;
switch (ch) {
// export default ...
case 100/*d*/:
exports.add(source.slice(pos, pos + 7));
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);
exports.add(source.slice(startPos, pos));
pos--;
return;
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);
exports.add(source.slice(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;
exports.add(source.slice(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));
}
else {
pos--;
}
}
/*
* Ported from Acorn
*
* MIT License
* Copyright (C) 2012-2020 by various contributors (see AUTHORS)
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
let acornPos;
function readString (start, quote) {
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;
}
// Used to read escaped characters
function readEscapedChar () {
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);
}
}
// Used to read character escape sequences ('\x', '\u', '\U').
function readHexChar (len) {
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;
}
// Read a string value, interpreting backslash-escapes.
function readCodePointToString () {
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);
}
/*
* </ Acorn Port>
*/
function readExportAs (startPos, endPos) {
let ch = source.charCodeAt(pos);
if (ch === 97 /*a*/) {
pos += 2;
ch = commentWhitespace(true);
startPos = pos;
readToWsOrPunctuator(ch);
endPos = pos;
ch = commentWhitespace(true);
}
if (pos !== startPos)
exports.add(source.slice(startPos, endPos));
return ch;
}
function readImportString (ss, 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;
}
function commentWhitespace (br) {
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;
}
function templateString () {
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();
}
function blockComment (br) {
pos++;
while (pos++ < end) {
const ch = source.charCodeAt(pos);
if (!br && isBr(ch))
return;
if (ch === 42/***/ && source.charCodeAt(pos + 1) === 47/*/*/) {
pos++;
return;
}
}
}
function lineComment () {
while (pos++ < end) {
const ch = source.charCodeAt(pos);
if (ch === 10/*\n*/ || ch === 13/*\r*/)
return;
}
}
function stringLiteral (quote) {
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();
}
function regexCharacterClass () {
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();
}
function regularExpression () {
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();
}
function readToWsOrPunctuator (ch) {
do {
if (isBrOrWs(ch) || isPunctuator(ch))
return ch;
} while (ch = source.charCodeAt(++pos));
return ch;
}
// Note: non-asii BR and whitespace checks omitted for perf / footprint
// if there is a significant user need this can be reconsidered
function isBr (c) {
return c === 13/*\r*/ || c === 10/*\n*/;
}
function isWsNotBr (c) {
return c === 9 || c === 11 || c === 12 || c === 32 || c === 160;
}
function isBrOrWs (c) {
return c > 8 && c < 14 || c === 32 || c === 160;
}
function isBrOrWsOrPunctuatorNotDot (c) {
return c > 8 && c < 14 || c === 32 || c === 160 || isPunctuator(c) && c !== 46/*.*/;
}
function keywordStart (pos) {
return pos === 0 || isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos - 1));
}
function readPrecedingKeyword (pos, match) {
if (pos < match.length - 1)
return false;
return source.startsWith(match, pos - match.length + 1) && (pos === 0 || isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos - match.length)));
}
function readPrecedingKeyword1 (pos, ch) {
return source.charCodeAt(pos) === ch && (pos === 0 || isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos - 1)));
}
// Detects one of case, debugger, delete, do, else, in, instanceof, new,
// return, throw, typeof, void, yield, await
function isExpressionKeyword (pos) {
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;
}
function isParenKeyword (curPos) {
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*/;
}
function isPunctuator (ch) {
// 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;
}
function isExpressionPunctuator (ch) {
// 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/*}*/;
}
function isExpressionTerminator (curPos) {
// 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;
}
function syntaxError () {
throw Object.assign(new Error(`Parse error ${name}:${source.slice(0, pos).split('\n').length}:${pos - source.lastIndexOf('\n', pos - 1)}`), { idx: pos });
}