Brunobkr/llama.cpp_AlgMor24_github

1let source, pos, end,
2  openTokenDepth,
3  lastTokenPos,
4  openTokenPosStack,
5  openClassPosStack,
6  curDynamicImport,
7  templateStackDepth,
8  facade,
9  lastSlashWasDivision,
10  nextBraceIsClass,
11  templateDepth,
12  templateStack,
13  imports,
14  exports,
15  name;
16
17function addImport (ss, s, e, d) {
18  const impt = { ss, se: d === -2 ? e : d === -1 ? e + 1 : 0, s, e, d, a: -1, n: undefined, at: null };
19  imports.push(impt);
20  return impt;
21}
22
23function addExport (s, e, ls, le) {
24  exports.push({
25    s,
26    e,
27    ls,
28    le,
29    n: s[0] === '"' ? readString(s, '"') : s[0] === "'" ? readString(s, "'") : source.slice(s, e),
30    ln: ls[0] === '"' ? readString(ls, '"') : ls[0] === "'" ? readString(ls, "'") : source.slice(ls, le)
31  });
32}
33
34function readName (impt) {
35  let { d, s } = impt;
36  if (d !== -1)
37    s++;
38  impt.n = readString(s, source.charCodeAt(s - 1));
39}
40
41// Note: parsing is based on the _assumption_ that the source is already valid
42export function parse (_source, _name) {
43  openTokenDepth = 0;
44  curDynamicImport = null;
45  templateDepth = -1;
46  lastTokenPos = -1;
47  lastSlashWasDivision = false;
48  templateStack = Array(1024);
49  templateStackDepth = 0;
50  openTokenPosStack = Array(1024);
51  openClassPosStack = Array(1024);
52  nextBraceIsClass = false;
53  facade = true;
54  name = _name || '@';
55
56  imports = [];
57  exports = [];
58
59  source = _source;
60  pos = -1;
61  end = source.length - 1;
62  let ch = 0;
63
64  // start with a pure "module-only" parser
65  m: while (pos++ < end) {
66    ch = source.charCodeAt(pos);
67
68    if (ch === 32 || ch < 14 && ch > 8)
69      continue;
70
71    switch (ch) {
72      case 101/*e*/:
73        if (openTokenDepth === 0 && keywordStart(pos) && source.startsWith('xport', pos + 1)) {
74          tryParseExportStatement();
75          // export might have been a non-pure declaration
76          if (!facade) {
77            lastTokenPos = pos;
78            break m;
79          }
80        }
81        break;
82      case 105/*i*/:
83        if (keywordStart(pos) && source.startsWith('mport', pos + 1))
84          tryParseImportStatement();
85        break;
86      case 59/*;*/:
87        break;
88      case 47/*/*/: {
89        const next_ch = source.charCodeAt(pos + 1);
90        if (next_ch === 47/*/*/) {
91          lineComment();
92          // dont update lastToken
93          continue;
94        }
95        else if (next_ch === 42/***/) {
96          blockComment(true);
97          // dont update lastToken
98          continue;
99        }
100        // fallthrough
101      }
102      default:
103        // as soon as we hit a non-module token, we go to main parser
104        facade = false;
105        pos--;
106        break m;
107    }
108    lastTokenPos = pos;
109  }
110
111  while (pos++ < end) {
112    ch = source.charCodeAt(pos);
113
114    if (ch === 32 || ch < 14 && ch > 8)
115      continue;
116
117    switch (ch) {
118      case 101/*e*/:
119        if (openTokenDepth === 0 && keywordStart(pos) && source.startsWith('xport', pos + 1))
120          tryParseExportStatement();
121        break;
122      case 105/*i*/:
123        if (keywordStart(pos) && source.startsWith('mport', pos + 1))
124          tryParseImportStatement();
125        break;
126      case 99/*c*/:
127        if (keywordStart(pos) && source.startsWith('lass', pos + 1) && isBrOrWs(source.charCodeAt(pos + 5)))
128          nextBraceIsClass = true;
129        break;
130      case 40/*(*/:
131        openTokenPosStack[openTokenDepth++] = lastTokenPos;
132        break;
133      case 41/*)*/:
134        if (openTokenDepth === 0)
135          syntaxError();
136        openTokenDepth--;
137        if (curDynamicImport && curDynamicImport.d === openTokenPosStack[openTokenDepth]) {
138          if (curDynamicImport.e === 0)
139            curDynamicImport.e = pos;
140          curDynamicImport.se = pos;
141          curDynamicImport = null;
142        }
143        break;
144      case 91/*[*/:
145        openTokenPosStack[openTokenDepth++] = lastTokenPos;
146        break;
147      case 93/*]*/:
148        if (openTokenDepth === 0)
149          syntaxError();
150        openTokenDepth--;
151        break;
152      case 44/*,*/:
153        if (curDynamicImport && curDynamicImport.e === 0 && curDynamicImport.d === openTokenPosStack[openTokenDepth - 1]) {
154          curDynamicImport.e = lastTokenPos + 1;
155          pos++;
156          commentWhitespace(true);
157          curDynamicImport.a = pos;
158          pos--;
159        }
160        break;
161      case 123/*{*/:
162        // dynamic import followed by { is not a dynamic import (so remove)
163        // this is a sneaky way to get around { import () {} } v { import () }
164        // block / object ambiguity without a parser (assuming source is valid)
165        if (source.charCodeAt(lastTokenPos) === 41/*)*/ && imports.length && imports[imports.length - 1].e === lastTokenPos) {
166          imports.pop();
167        }
168        openClassPosStack[openTokenDepth] = nextBraceIsClass;
169        nextBraceIsClass = false;
170        openTokenPosStack[openTokenDepth++] = lastTokenPos;
171        break;
172      case 125/*}*/:
173        if (openTokenDepth === 0)
174          syntaxError();
175        if (openTokenDepth-- === templateDepth) {
176          templateDepth = templateStack[--templateStackDepth];
177          templateString();
178        }
179        else {
180          if (templateDepth !== -1 && openTokenDepth < templateDepth)
181            syntaxError();
182        }
183        break;
184      case 39/*'*/:
185      case 34/*"*/:
186        stringLiteral(ch);
187        break;
188      case 47/*/*/: {
189        const next_ch = source.charCodeAt(pos + 1);
190        if (next_ch === 47/*/*/) {
191          lineComment();
192          // dont update lastToken
193          continue;
194        }
195        else if (next_ch === 42/***/) {
196          blockComment(true);
197          // dont update lastToken
198          continue;
199        }
200        else {
201          // Division / regex ambiguity handling based on checking backtrack analysis of:
202          // - what token came previously (lastToken)
203          // - if a closing brace or paren, what token came before the corresponding
204          //   opening brace or paren (lastOpenTokenIndex)
205          const lastToken = source.charCodeAt(lastTokenPos);
206          const lastExport = exports[exports.length - 1];
207          if (isExpressionPunctuator(lastToken) &&
208              !(lastToken === 46/*.*/ && (source.charCodeAt(lastTokenPos - 1) >= 48/*0*/ && source.charCodeAt(lastTokenPos - 1) <= 57/*9*/)) &&
209              !(lastToken === 43/*+*/ && source.charCodeAt(lastTokenPos - 1) === 43/*+*/) && !(lastToken === 45/*-*/ && source.charCodeAt(lastTokenPos - 1) === 45/*-*/) ||
210              lastToken === 41/*)*/ && isParenKeyword(openTokenPosStack[openTokenDepth]) ||
211              openTokenDepth > 0 && lastToken === 102/*f*/ && source.charCodeAt(lastTokenPos - 1) === 111/*o*/ && isForOfBinding(lastTokenPos - 2) && isForParen(openTokenPosStack[openTokenDepth - 1]) ||
212              lastToken === 125/*}*/ && (isExpressionTerminator(openTokenPosStack[openTokenDepth]) || openClassPosStack[openTokenDepth]) ||
213              lastToken === 47/*/*/ && lastSlashWasDivision ||
214              isExpressionKeyword(lastTokenPos) ||
215              !lastToken) {
216            regularExpression();
217            lastSlashWasDivision = false;
218          }
219          else if (lastExport && lastTokenPos >= lastExport.s && lastTokenPos <= lastExport.e) {
220            // export default /some-regexp/
221            regularExpression();
222            lastSlashWasDivision = false;
223          }
224          else {
225            lastSlashWasDivision = true;
226          }
227        }
228        break;
229      }
230      case 96/*`*/:
231        templateString();
232        break;
233    }
234    lastTokenPos = pos;
235  }
236
237  if (templateDepth !== -1 || openTokenDepth)
238    syntaxError();
239
240  return [imports, exports, facade];
241}
242
243function tryParseImportStatement () {
244  const startPos = pos;
245
246  pos += 6;
247
248  let ch = commentWhitespace(true);
249  
250  switch (ch) {
251    // dynamic import
252    case 40/*(*/:
253      openTokenPosStack[openTokenDepth++] = startPos;
254      if (source.charCodeAt(lastTokenPos) === 46/*.*/)
255        return;
256      // dynamic import indicated by positive d
257      const impt = addImport(startPos, pos + 1, 0, startPos);
258      curDynamicImport = impt;
259      // try parse a string, to record a safe dynamic import string
260      pos++;
261      ch = commentWhitespace(true);
262      if (ch === 39/*'*/ || ch === 34/*"*/) {
263        stringLiteral(ch);
264      }
265      else {
266        pos--;
267        return;
268      }
269      pos++;
270      ch = commentWhitespace(true);
271      if (ch === 44/*,*/) {
272        impt.e = pos;
273        pos++;
274        ch = commentWhitespace(true);
275        impt.a = pos;
276        readName(impt);
277        pos--;
278      }
279      else if (ch === 41/*)*/) {
280        openTokenDepth--;
281        impt.e = pos;
282        impt.se = pos;
283        readName(impt);
284      }
285      else {
286        pos--;
287      }
288      return;
289    // import.meta
290    case 46/*.*/:
291      pos++;
292      ch = commentWhitespace(true);
293      // import.meta indicated by d === -2
294      if (ch === 109/*m*/ && source.startsWith('eta', pos + 1) && source.charCodeAt(lastTokenPos) !== 46/*.*/)
295        addImport(startPos, startPos, pos + 4, -2);
296      return;
297    
298    default:
299      // no space after "import" -> not an import keyword
300      if (pos === startPos + 6)
301        break;
302    case 34/*"*/:
303    case 39/*'*/:
304    case 123/*{*/:
305    case 42/***/:
306      // import statement only permitted at base-level
307      if (openTokenDepth !== 0) {
308        pos--;
309        return;
310      }
311      while (pos < end) {
312        ch = source.charCodeAt(pos);
313        if (ch === 39/*'*/ || ch === 34/*"*/) {
314          readImportString(startPos, ch);
315          return;
316        }
317        pos++;
318      }
319      syntaxError();
320  }
321}
322
323function tryParseExportStatement () {
324  const sStartPos = pos;
325  const prevExport = exports.length;
326
327  pos += 6;
328
329  const curPos = pos;
330
331  let ch = commentWhitespace(true);
332
333  if (pos === curPos && !isPunctuator(ch))
334    return;
335
336  switch (ch) {
337    // export default ...
338    case 100/*d*/:
339      addExport(pos, pos + 7, -1, -1);
340      return;
341
342    // export async? function*? name () {
343    case 97/*a*/:
344      pos += 5;
345      commentWhitespace(true);
346    // fallthrough
347    case 102/*f*/:
348      pos += 8;
349      ch = commentWhitespace(true);
350      if (ch === 42/***/) {
351        pos++;
352        ch = commentWhitespace(true);
353      }
354      const startPos = pos;
355      ch = readToWsOrPunctuator(ch);
356      addExport(startPos, pos, startPos, pos);
357      pos--;
358      return;
359
360    // export class name ...
361    case 99/*c*/:
362      if (source.startsWith('lass', pos + 1) && isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos + 5))) {
363        pos += 5;
364        ch = commentWhitespace(true);
365        const startPos = pos;
366        ch = readToWsOrPunctuator(ch);
367        addExport(startPos, pos, startPos, pos);
368        pos--;
369        return;
370      }
371      pos += 2;
372    // fallthrough
373
374    // export var/let/const name = ...(, name = ...)+
375    case 118/*v*/:
376    case 109/*l*/:
377      // destructured initializations not currently supported (skipped for { or [)
378      // also, lexing names after variable equals is skipped (export var p = function () { ... }, q = 5 skips "q")
379      pos += 2;
380      facade = false;
381      do {
382        pos++;
383        ch = commentWhitespace(true);
384        const startPos = pos;
385        ch = readToWsOrPunctuator(ch);
386        // dont yet handle [ { destructurings
387        if (ch === 123/*{*/ || ch === 91/*[*/) {
388          pos--;
389          return;
390        }
391        if (pos === startPos)
392          return;
393        addExport(startPos, pos, startPos, pos);
394        ch = commentWhitespace(true);
395        if (ch === 61/*=*/) {
396          pos--;
397          return;
398        }
399      } while (ch === 44/*,*/);
400      pos--;
401      return;
402
403
404    // export {...}
405    case 123/*{*/:
406      pos++;
407      ch = commentWhitespace(true);
408      while (true) {
409        const startPos = pos;
410        readToWsOrPunctuator(ch);
411        const endPos = pos;
412        commentWhitespace(true);
413        ch = readExportAs(startPos, endPos);
414        // ,
415        if (ch === 44/*,*/) {
416          pos++;
417          ch = commentWhitespace(true);
418        }
419        if (ch === 125/*}*/)
420          break;
421        if (pos === startPos)
422          return syntaxError(); 
423        if (pos > end)
424          return syntaxError();
425      }
426      pos++;
427      ch = commentWhitespace(true);
428    break;
429    
430    // export *
431    // export * as X
432    case 42/***/:
433      pos++;
434      commentWhitespace(true);
435      ch = readExportAs(pos, pos);
436      ch = commentWhitespace(true);
437    break;
438  }
439
440  // from ...
441  if (ch === 102/*f*/ && source.startsWith('rom', pos + 1)) {
442    pos += 4;
443    readImportString(sStartPos, commentWhitespace(true));
444
445    // There were no local names.
446    for (let i = prevExport; i < exports.length; ++i) {
447      exports[i].ls = exports[i].le = -1;
448      exports[i].ln = undefined;
449    }
450  }
451  else {
452    pos--;
453  }
454}
455
456/*
457 * Ported from Acorn
458 *   
459 * MIT License
460
461 * Copyright (C) 2012-2020 by various contributors (see AUTHORS)
462
463 * Permission is hereby granted, free of charge, to any person obtaining a copy
464 * of this software and associated documentation files (the "Software"), to deal
465 * in the Software without restriction, including without limitation the rights
466 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
467 * copies of the Software, and to permit persons to whom the Software is
468 * furnished to do so, subject to the following conditions:
469
470 * The above copyright notice and this permission notice shall be included in
471 * all copies or substantial portions of the Software.
472
473 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
474 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
475 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
476 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
477 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
478 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
479 * THE SOFTWARE.
480 */
481let acornPos;
482function readString (start, quote) {
483  acornPos = start;
484  let out = '', chunkStart = acornPos;
485  for (;;) {
486    if (acornPos >= source.length) syntaxError();
487    const ch = source.charCodeAt(acornPos);
488    if (ch === quote) break;
489    if (ch === 92) { // '\'
490      out += source.slice(chunkStart, acornPos);
491      out += readEscapedChar();
492      chunkStart = acornPos;
493    }
494    else if (ch === 0x2028 || ch === 0x2029) {
495      ++acornPos;
496    }
497    else {
498      if (isBr(ch)) syntaxError();
499      ++acornPos;
500    }
501  }
502  out += source.slice(chunkStart, acornPos++);
503  return out;
504}
505
506// Used to read escaped characters
507
508function readEscapedChar () {
509  let ch = source.charCodeAt(++acornPos);
510  ++acornPos;
511  switch (ch) {
512    case 110: return '\n'; // 'n' -> '\n'
513    case 114: return '\r'; // 'r' -> '\r'
514    case 120: return String.fromCharCode(readHexChar(2)); // 'x'
515    case 117: return readCodePointToString(); // 'u'
516    case 116: return '\t'; // 't' -> '\t'
517    case 98: return '\b'; // 'b' -> '\b'
518    case 118: return '\u000b'; // 'v' -> '\u000b'
519    case 102: return '\f'; // 'f' -> '\f'
520    case 13: if (source.charCodeAt(acornPos) === 10) ++acornPos; // '\r\n'
521    case 10: // ' \n'
522      return '';
523    case 56:
524    case 57:
525      syntaxError();
526    default:
527      if (ch >= 48 && ch <= 55) {
528        let octalStr = source.substr(acornPos - 1, 3).match(/^[0-7]+/)[0];
529        let octal = parseInt(octalStr, 8);
530        if (octal > 255) {
531          octalStr = octalStr.slice(0, -1);
532          octal = parseInt(octalStr, 8);
533        }
534        acornPos += octalStr.length - 1;
535        ch = source.charCodeAt(acornPos);
536        if (octalStr !== '0' || ch === 56 || ch === 57)
537          syntaxError();
538        return String.fromCharCode(octal);
539      }
540      if (isBr(ch)) {
541        // Unicode new line characters after \ get removed from output in both
542        // template literals and strings
543        return '';
544      }
545      return String.fromCharCode(ch);
546  }
547}
548
549// Used to read character escape sequences ('\x', '\u', '\U').
550
551function readHexChar (len) {
552  const start = acornPos;
553  let total = 0, lastCode = 0;
554  for (let i = 0; i < len; ++i, ++acornPos) {
555    let code = source.charCodeAt(acornPos), val;
556
557    if (code === 95) {
558      if (lastCode === 95 || i === 0) syntaxError();
559      lastCode = code;
560      continue;
561    }
562
563    if (code >= 97) val = code - 97 + 10; // a
564    else if (code >= 65) val = code - 65 + 10; // A
565    else if (code >= 48 && code <= 57) val = code - 48; // 0-9
566    else break;
567    if (val >= 16) break;
568    lastCode = code;
569    total = total * 16 + val;
570  }
571
572  if (lastCode === 95 || acornPos - start !== len) syntaxError();
573
574  return total;
575}
576
577// Read a string value, interpreting backslash-escapes.
578
579function readCodePointToString () {
580  const ch = source.charCodeAt(acornPos);
581  let code;
582  if (ch === 123) { // '{'
583    ++acornPos;
584    code = readHexChar(source.indexOf('}', acornPos) - acornPos);
585    ++acornPos;
586    if (code > 0x10FFFF) syntaxError();
587  } else {
588    code = readHexChar(4);
589  }
590  // UTF-16 Decoding
591  if (code <= 0xFFFF) return String.fromCharCode(code);
592  code -= 0x10000;
593  return String.fromCharCode((code >> 10) + 0xD800, (code & 1023) + 0xDC00);
594}
595
596/*
597 * </ Acorn Port>
598 */
599
600function readExportAs (startPos, endPos) {
601  let ch = source.charCodeAt(pos);
602  let ls = startPos, le = endPos;
603  if (ch === 97 /*a*/) {
604    pos += 2;
605    ch = commentWhitespace(true);
606    startPos = pos;
607    readToWsOrPunctuator(ch);
608    endPos = pos;
609    ch = commentWhitespace(true);
610  }
611  if (pos !== startPos)
612    addExport(startPos, endPos, ls, le);
613  return ch;
614}
615
616function readImportString (ss, ch) {
617  const startPos = pos + 1;
618  if (ch === 39/*'*/ || ch === 34/*"*/) {
619    stringLiteral(ch);
620  }
621  else {
622    syntaxError();
623    return;
624  }
625  const impt = addImport(ss, startPos, pos, -1);
626  readName(impt);
627  pos++;
628  ch = commentWhitespace(false);
629  if (ch !== 119/*w*/ || !source.startsWith('ith', pos + 1)) {
630    pos--;
631    return;
632  }
633  const attrIndex = pos;
634
635  pos += 4;
636  ch = commentWhitespace(true);
637  if (ch !== 123/*{*/) {
638    pos = attrIndex;
639    return;
640  }
641  const attrStart = pos;
642  const attrs = [];
643  do {
644    pos++;
645    ch = commentWhitespace(true);
646    let key, keyStart, keyEnd;
647    if (ch === 39/*'*/ || ch === 34/*"*/) {
648      keyStart = pos;
649      stringLiteral(ch);
650      keyEnd = pos + 1;
651      key = readString(keyStart, ch);
652      pos++;
653      ch = commentWhitespace(true);
654    }
655    else {
656      keyStart = pos;
657      ch = readToWsOrPunctuator(ch);
658      keyEnd = pos;
659      key = source.slice(keyStart, keyEnd);
660    }
661    if (ch !== 58/*:*/) {
662      pos = attrIndex;
663      return;
664    }
665    pos++;
666    ch = commentWhitespace(true);
667    let value, valueStart;
668    if (ch === 39/*'*/ || ch === 34/*"*/) {
669      valueStart = pos;
670      stringLiteral(ch);
671      value = readString(valueStart, ch);
672    }
673    else {
674      pos = attrIndex;
675      return;
676    }
677    attrs.push([key, value]);
678    pos++;
679    ch = commentWhitespace(true);
680    if (ch === 44/*,*/) {
681      pos++;
682      continue;
683    }
684    if (ch === 125/*}*/)
685      break;
686    pos = attrIndex;
687    return;
688  } while (true);
689  impt.a = attrStart;
690  impt.at = attrs;
691  impt.se = pos + 1;
692}
693
694function commentWhitespace (br) {
695  let ch;
696  do {
697    ch = source.charCodeAt(pos);
698    if (ch === 47/*/*/) {
699      const next_ch = source.charCodeAt(pos + 1);
700      if (next_ch === 47/*/*/)
701        lineComment();
702      else if (next_ch === 42/***/)
703        blockComment(br);
704      else
705        return ch;
706    }
707    else if (br ? !isBrOrWs(ch): !isWsNotBr(ch)) {
708      return ch;
709    }
710  } while (pos++ < end);
711  return ch;
712}
713
714function templateString () {
715  while (pos++ < end) {
716    const ch = source.charCodeAt(pos);
717    if (ch === 36/*$*/ && source.charCodeAt(pos + 1) === 123/*{*/) {
718      pos++;
719      templateStack[templateStackDepth++] = templateDepth;
720      templateDepth = ++openTokenDepth;
721      return;
722    }
723    if (ch === 96/*`*/)
724      return;
725    if (ch === 92/*\*/)
726      pos++;
727  }
728  syntaxError();
729}
730
731function blockComment (br) {
732  pos++;
733  while (pos++ < end) {
734    const ch = source.charCodeAt(pos);
735    if (!br && isBr(ch))
736      return;
737    if (ch === 42/***/ && source.charCodeAt(pos + 1) === 47/*/*/) {
738      pos++;
739      return;
740    }
741  }
742}
743
744function lineComment () {
745  while (pos++ < end) {
746    const ch = source.charCodeAt(pos);
747    if (ch === 10/*\n*/ || ch === 13/*\r*/)
748      return;
749  }
750}
751
752function stringLiteral (quote) {
753  while (pos++ < end) {
754    let ch = source.charCodeAt(pos);
755    if (ch === quote)
756      return;
757    if (ch === 92/*\*/) {
758      ch = source.charCodeAt(++pos);
759      if (ch === 13/*\r*/ && source.charCodeAt(pos + 1) === 10/*\n*/)
760        pos++;
761    }
762    else if (isBr(ch))
763      break;
764  }
765  syntaxError();
766}
767
768function regexCharacterClass () {
769  while (pos++ < end) {
770    let ch = source.charCodeAt(pos);
771    if (ch === 93/*]*/)
772      return ch;
773    if (ch === 92/*\*/)
774      pos++;
775    else if (ch === 10/*\n*/ || ch === 13/*\r*/)
776      break;
777  }
778  syntaxError();
779}
780
781function regularExpression () {
782  while (pos++ < end) {
783    let ch = source.charCodeAt(pos);
784    if (ch === 47/*/*/)
785      return;
786    if (ch === 91/*[*/)
787      ch = regexCharacterClass();
788    else if (ch === 92/*\*/)
789      pos++;
790    else if (ch === 10/*\n*/ || ch === 13/*\r*/)
791      break;
792  }
793  syntaxError();
794}
795
796function readToWsOrPunctuator (ch) {
797  do {
798    if (isBrOrWs(ch) || isPunctuator(ch))
799      return ch;
800  } while (ch = source.charCodeAt(++pos));
801  return ch;
802}
803
804// Note: non-asii BR and whitespace checks omitted for perf / footprint
805// if there is a significant user need this can be reconsidered
806function isBr (c) {
807  return c === 13/*\r*/ || c === 10/*\n*/;
808}
809
810function isWsNotBr (c) {
811  return c === 9 || c === 11 || c === 12 || c === 32 || c === 160;
812}
813
814function isBrOrWs (c) {
815  return c > 8 && c < 14 || c === 32 || c === 160;
816}
817
818function isBrOrWsOrPunctuatorNotDot (c) {
819  return c > 8 && c < 14 || c === 32 || c === 160 || isPunctuator(c) && c !== 46/*.*/;
820}
821
822function keywordStart (pos) {
823  return pos === 0 || isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos - 1));
824}
825
826function readPrecedingKeyword (pos, match) {
827  if (pos < match.length - 1)
828    return false;
829  return source.startsWith(match, pos - match.length + 1) && (pos === 0 || isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos - match.length)));
830}
831
832function readPrecedingKeyword1 (pos, ch) {
833  return source.charCodeAt(pos) === ch && (pos === 0 || isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos - 1)));
834}
835
836// Detects one of case, debugger, delete, do, else, in, instanceof, new,
837//   return, throw, typeof, void, yield, await
838function isExpressionKeyword (pos) {
839  switch (source.charCodeAt(pos)) {
840    case 100/*d*/:
841      switch (source.charCodeAt(pos - 1)) {
842        case 105/*i*/:
843          // void
844          return readPrecedingKeyword(pos - 2, 'vo');
845        case 108/*l*/:
846          // yield
847          return readPrecedingKeyword(pos - 2, 'yie');
848        default:
849          return false;
850      }
851    case 101/*e*/:
852      switch (source.charCodeAt(pos - 1)) {
853        case 115/*s*/:
854          switch (source.charCodeAt(pos - 2)) {
855            case 108/*l*/:
856              // else
857              return readPrecedingKeyword1(pos - 3, 101/*e*/);
858            case 97/*a*/:
859              // case
860              return readPrecedingKeyword1(pos - 3, 99/*c*/);
861            default:
862              return false;
863          }
864        case 116/*t*/:
865          // delete
866          return readPrecedingKeyword(pos - 2, 'dele');
867        default:
868          return false;
869      }
870    case 102/*f*/:
871      if (source.charCodeAt(pos - 1) !== 111/*o*/ || source.charCodeAt(pos - 2) !== 101/*e*/)
872        return false;
873      switch (source.charCodeAt(pos - 3)) {
874        case 99/*c*/:
875          // instanceof
876          return readPrecedingKeyword(pos - 4, 'instan');
877        case 112/*p*/:
878          // typeof
879          return readPrecedingKeyword(pos - 4, 'ty');
880        default:
881          return false;
882      }
883    case 110/*n*/:
884      // in, return
885      return readPrecedingKeyword1(pos - 1, 105/*i*/) || readPrecedingKeyword(pos - 1, 'retur');
886    case 111/*o*/:
887      // do
888      return readPrecedingKeyword1(pos - 1, 100/*d*/);
889    case 114/*r*/:
890      // debugger
891      return readPrecedingKeyword(pos - 1, 'debugge');
892    case 116/*t*/:
893      // await
894      return readPrecedingKeyword(pos - 1, 'awai');
895    case 119/*w*/:
896      switch (source.charCodeAt(pos - 1)) {
897        case 101/*e*/:
898          // new
899          return readPrecedingKeyword1(pos - 2, 110/*n*/);
900        case 111/*o*/:
901          // throw
902          return readPrecedingKeyword(pos - 2, 'thr');
903        default:
904          return false;
905      }
906  }
907  return false;
908}
909
910function isParenKeyword (curPos) {
911  return source.charCodeAt(curPos) === 101/*e*/ && source.startsWith('whil', curPos - 4) ||
912      source.charCodeAt(curPos) === 114/*r*/ && source.startsWith('fo', curPos - 2) ||
913      source.charCodeAt(curPos - 1) === 105/*i*/ && source.charCodeAt(curPos) === 102/*f*/;
914}
915
916function isForParen (curPos) {
917  return source.charCodeAt(curPos) === 114/*r*/ && source.startsWith('fo', curPos - 2);
918}
919
920// In valid JS, the for-of `of` keyword always follows a binding,
921// which ends with an identifier-tail char, ']', '}', or ')'.
922function isForOfBinding (pos) {
923  const ch = source.charCodeAt(pos);
924  if (!isBrOrWs(ch) && ch !== 93/*]*/ && ch !== 125/*}*/ && ch !== 41/*)*/)
925    return false;
926  while (pos > 0 && isBrOrWs(source.charCodeAt(pos)))
927    pos--;
928  const c = source.charCodeAt(pos);
929  return c === 93/*]*/ || c === 125/*}*/ || c === 41/*)*/ || !isPunctuator(c);
930}
931
932function isPunctuator (ch) {
933  // 23 possible punctuator endings: !%&()*+,-./:;<=>?[]^{}|~
934  return ch === 33/*!*/ || ch === 37/*%*/ || ch === 38/*&*/ ||
935    ch > 39 && ch < 48 || ch > 57 && ch < 64 ||
936    ch === 91/*[*/ || ch === 93/*]*/ || ch === 94/*^*/ ||
937    ch > 122 && ch < 127;
938}
939
940function isExpressionPunctuator (ch) {
941  // 20 possible expression endings: !%&(*+,-.:;<=>?[^{|~
942  return ch === 33/*!*/ || ch === 37/*%*/ || ch === 38/*&*/ ||
943    ch > 39 && ch < 47 && ch !== 41 || ch > 57 && ch < 64 ||
944    ch === 91/*[*/ || ch === 94/*^*/ || ch > 122 && ch < 127 && ch !== 125/*}*/;
945}
946
947function isExpressionTerminator (curPos) {
948  // detects:
949  // => ; ) finally catch else
950  // as all of these followed by a { will indicate a statement brace
951  switch (source.charCodeAt(curPos)) {
952    case 62/*>*/:
953      return source.charCodeAt(curPos - 1) === 61/*=*/;
954    case 59/*;*/:
955    case 41/*)*/:
956      return true;
957    case 104/*h*/:
958      return source.startsWith('catc', curPos - 4);
959    case 121/*y*/:
960      return source.startsWith('finall', curPos - 6);
961    case 101/*e*/:
962      return source.startsWith('els', curPos - 3);
963  }
964  return false;
965}
966
967function syntaxError () {
968  throw Object.assign(new Error(`Parse error ${name}:${source.slice(0, pos).split('\n').length}:${pos - source.lastIndexOf('\n', pos - 1)}`), { idx: pos });
969}