@openclaw/diagnostics-otel 2026.7.2-beta.2 → 2026.7.2-beta.4

package/node_modules/es-module-lexer/lexer.js

@@ -0,0 +1,1009 @@
+let source, pos, end,
+  openTokenDepth,
+  lastTokenPos,
+  openTokenPosStack,
+  openClassPosStack,
+  curDynamicImport,
+  templateStackDepth,
+  facade,
+  lastSlashWasDivision,
+  nextBraceIsClass,
+  templateDepth,
+  templateStack,
+  imports,
+  exports,
+  exportStatementStart,
+  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, at: null };
+  imports.push(impt);
+  return impt;
+}
+
+function addExport (s, e, ls, le) {
+  exports.push({
+    s,
+    e,
+    ls,
+    le,
+    ss: exportStatementStart,
+    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)
+  });
+}
+
+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 = [];
+
+  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 91/*[*/:
+        openTokenPosStack[openTokenDepth++] = lastTokenPos;
+        break;
+      case 93/*]*/:
+        if (openTokenDepth === 0)
+          syntaxError();
+        openTokenDepth--;
+        break;
+      case 44/*,*/:
+        if (curDynamicImport && curDynamicImport.e === 0 && curDynamicImport.d === openTokenPosStack[openTokenDepth - 1]) {
+          curDynamicImport.e = lastTokenPos + 1;
+          pos++;
+          commentWhitespace(true);
+          curDynamicImport.a = pos;
+          pos--;
+        }
+        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)
+        // se marks the closing paren; e is moved before the first comma for import(a, b)
+        if (source.charCodeAt(lastTokenPos) === 41/*)*/ && imports.length && imports[imports.length - 1].se === 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);
+          const lastExport = exports[exports.length - 1];
+          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]) ||
+              openTokenDepth > 0 && lastToken === 102/*f*/ && source.charCodeAt(lastTokenPos - 1) === 111/*o*/ && isForOfBinding(lastTokenPos - 2) && isForParen(openTokenPosStack[openTokenDepth - 1]) ||
+              lastToken === 125/*}*/ && (isExpressionTerminator(openTokenPosStack[openTokenDepth]) || openClassPosStack[openTokenDepth]) ||
+              lastToken === 47/*/*/ && lastSlashWasDivision ||
+              isExpressionKeyword(lastTokenPos) ||
+              !lastToken) {
+            regularExpression();
+            lastSlashWasDivision = false;
+          }
+          else if (lastExport && lastTokenPos >= lastExport.s && lastTokenPos <= lastExport.e) {
+            // export default /some-regexp/
+            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
+      // try parse a string, to record a safe dynamic import string
+      pos++;
+      ch = commentWhitespace(true);
+      // The specifier start is recorded after leading whitespace/comments so it
+      // points at the literal, matching the C lexer (src/lexer.c).
+      const impt = addImport(startPos, pos, 0, startPos);
+      curDynamicImport = impt;
+      if (ch === 39/*'*/ || ch === 34/*"*/) {
+        stringLiteral(ch);
+      }
+      else if (ch === 96/*`*/ && noSubstitutionTemplate()) {
+        // A no-substitution template literal is a constant string, so it is a
+        // safe specifier exactly like a quoted one. An interpolated template
+        // leaves noSubstitutionTemplate() false and falls through to the open-
+        // token machinery, which records the import as unsafe (n stays unset).
+      }
+      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;
+  const prevExport = exports.length;
+
+  pos += 6;
+
+  const curPos = pos;
+
+  let ch = commentWhitespace(true);
+
+  // Only commit the statement start once this is a real export: skipExpression
+  // re-enters here for an `export`-prefixed identifier (e.g. `exports`) in an
+  // initializer, which would otherwise clobber the start for later bindings.
+  if (pos === curPos && !isPunctuator(ch))
+    return;
+
+  exportStatementStart = sStartPos;
+
+  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--;
+  }
+}
+
+/*
+ * 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 {
+      // Template literals (backtick quote) permit raw line breaks; string
+      // literals do not.
+      if (isBr(ch) && quote !== 96/*`*/) 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);
+  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;
+}
+
+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 !== 119/*w*/ || !source.startsWith('ith', pos + 1)) {
+    pos--;
+    return;
+  }
+  const attrIndex = pos;
+
+  pos += 4;
+  ch = commentWhitespace(true);
+  if (ch !== 123/*{*/) {
+    pos = attrIndex;
+    return;
+  }
+  const attrStart = pos;
+  const attrs = [];
+  do {
+    pos++;
+    ch = commentWhitespace(true);
+    let key, keyStart, keyEnd;
+    if (ch === 39/*'*/ || ch === 34/*"*/) {
+      keyStart = pos;
+      stringLiteral(ch);
+      keyEnd = pos + 1;
+      key = readString(keyStart, ch);
+      pos++;
+      ch = commentWhitespace(true);
+    }
+    else {
+      keyStart = pos;
+      ch = readToWsOrPunctuator(ch);
+      keyEnd = pos;
+      key = source.slice(keyStart, keyEnd);
+    }
+    if (ch !== 58/*:*/) {
+      pos = attrIndex;
+      return;
+    }
+    pos++;
+    ch = commentWhitespace(true);
+    let value, valueStart;
+    if (ch === 39/*'*/ || ch === 34/*"*/) {
+      valueStart = pos;
+      stringLiteral(ch);
+      value = readString(valueStart, ch);
+    }
+    else {
+      pos = attrIndex;
+      return;
+    }
+    attrs.push([key, value]);
+    pos++;
+    ch = commentWhitespace(true);
+    if (ch === 44/*,*/) {
+      pos++;
+      continue;
+    }
+    if (ch === 125/*}*/)
+      break;
+    pos = attrIndex;
+    return;
+  } while (true);
+  impt.a = attrStart;
+  impt.at = attrs;
+  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();
+}
+
+// pos AT the opening backtick. A no-substitution template literal (no ${...})
+// is a constant string, so a dynamic import can record it as a safe specifier.
+// On success consumes it, leaves pos AT the closing backtick and returns true.
+// On a substitution or EOF restores pos and returns false, leaving the literal
+// to the main loop's template handling.
+function noSubstitutionTemplate () {
+  const startPos = pos;
+  while (pos++ < end) {
+    const ch = source.charCodeAt(pos);
+    if (ch === 96/*`*/)
+      return true;
+    if (ch === 92/*\*/) {
+      pos++;
+      continue;
+    }
+    if (ch === 36/*$*/ && source.charCodeAt(pos + 1) === 123/*{*/)
+      break;
+  }
+  pos = startPos;
+  return false;
+}
+
+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 isForParen (curPos) {
+  return source.charCodeAt(curPos) === 114/*r*/ && source.startsWith('fo', curPos - 2);
+}
+
+// In valid JS, the for-of `of` keyword always follows a binding,
+// which ends with an identifier-tail char, ']', '}', or ')'.
+function isForOfBinding (pos) {
+  const ch = source.charCodeAt(pos);
+  if (!isBrOrWs(ch) && ch !== 93/*]*/ && ch !== 125/*}*/ && ch !== 41/*)*/)
+    return false;
+  while (pos > 0 && isBrOrWs(source.charCodeAt(pos)))
+    pos--;
+  const c = source.charCodeAt(pos);
+  return c === 93/*]*/ || c === 125/*}*/ || c === 41/*)*/ || !isPunctuator(c);
+}
+
+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 });
+}