merve.cpp

/* auto-generated on 2026-03-11 12:53:21 -0400. Do not edit! */
#include "merve.h"

/* begin file src/parser.cpp */
#include <array>
#include <cstdint>
#include <limits>

#ifdef MERVE_USE_SIMDUTF
#include <simdutf.h>
#endif

namespace lexer {

// ============================================================================
// Compile-time lookup tables for character classification
// ============================================================================

// Hex digit lookup table: maps char -> hex value (0-15), or 255 if invalid
static constexpr std::array<uint8_t, 256> kHexTable = []() consteval {
  std::array<uint8_t, 256> table{};
  for (int i = 0; i < 256; ++i) table[i] = 255;
  for (int i = '0'; i <= '9'; ++i) table[i] = static_cast<uint8_t>(i - '0');
  for (int i = 'a'; i <= 'f'; ++i) table[i] = static_cast<uint8_t>(i - 'a' + 10);
  for (int i = 'A'; i <= 'F'; ++i) table[i] = static_cast<uint8_t>(i - 'A' + 10);
  return table;
}();

// Simple escape lookup table: maps escape char -> result char
// Uses 0xFF as "not a simple escape" marker since '\0' is a valid escape result
static constexpr std::array<uint8_t, 256> kSimpleEscapeTable = []() consteval {
  std::array<uint8_t, 256> table{};
  for (int i = 0; i < 256; ++i) table[i] = 0xFF;
  table['n'] = '\n';
  table['r'] = '\r';
  table['t'] = '\t';
  table['b'] = '\b';
  table['f'] = '\f';
  table['v'] = '\v';
  table['0'] = '\0';
  table['\\'] = '\\';
  table['\''] = '\'';
  table['"'] = '"';
  return table;
}();

// Punctuator lookup table
static constexpr std::array<bool, 256> kPunctuatorTable = []() consteval {
  std::array<bool, 256> table{};
  table['!'] = true;
  table['%'] = true;
  table['&'] = true;
  // ch > 39 && ch < 48: '(' ')' '*' '+' ',' '-' '.' '/'
  for (int i = 40; i < 48; ++i) table[i] = true;
  // ch > 57 && ch < 64: ':' ';' '<' '=' '>' '?'
  for (int i = 58; i < 64; ++i) table[i] = true;
  table['['] = true;
  table[']'] = true;
  table['^'] = true;
  // ch > 122 && ch < 127: '{' '|' '}' '~'
  for (int i = 123; i < 127; ++i) table[i] = true;
  return table;
}();

// Expression punctuator lookup table (similar but excludes ')' and '}')
static constexpr std::array<bool, 256> kExpressionPunctuatorTable = []() consteval {
  std::array<bool, 256> table{};
  table['!'] = true;
  table['%'] = true;
  table['&'] = true;
  // ch > 39 && ch < 47 && ch != 41: '(' '*' '+' ',' '-' '.'
  for (int i = 40; i < 47; ++i) {
    if (i != 41) table[i] = true;  // Skip ')'
  }
  // ch > 57 && ch < 64: ':' ';' '<' '=' '>' '?'
  for (int i = 58; i < 64; ++i) table[i] = true;
  table['['] = true;
  table['^'] = true;
  // ch > 122 && ch < 127 && ch != '}': '{' '|' '~'
  for (int i = 123; i < 127; ++i) {
    if (i != 125) table[i] = true;  // Skip '}'
  }
  return table;
}();

// Identifier start lookup table (a-z, A-Z, _, $, >= 0x80)
static constexpr std::array<bool, 256> kIdentifierStartTable = []() consteval {
  std::array<bool, 256> table{};
  for (int i = 'a'; i <= 'z'; ++i) table[i] = true;
  for (int i = 'A'; i <= 'Z'; ++i) table[i] = true;
  table['_'] = true;
  table['$'] = true;
  // UTF-8 continuation bytes and lead bytes (>= 0x80)
  for (int i = 0x80; i < 256; ++i) table[i] = true;
  return table;
}();

// Identifier char lookup table (identifier start + digits)
static constexpr std::array<bool, 256> kIdentifierCharTable = []() consteval {
  std::array<bool, 256> table{};
  for (int i = 'a'; i <= 'z'; ++i) table[i] = true;
  for (int i = 'A'; i <= 'Z'; ++i) table[i] = true;
  table['_'] = true;
  table['$'] = true;
  for (int i = 0x80; i < 256; ++i) table[i] = true;
  for (int i = '0'; i <= '9'; ++i) table[i] = true;
  return table;
}();

// Whitespace/line break lookup table
static constexpr std::array<bool, 256> kBrOrWsTable = []() consteval {
  std::array<bool, 256> table{};
  // c > 8 && c < 14: \t \n \v \f \r
  for (int i = 9; i < 14; ++i) table[i] = true;
  table[32] = true;  // space
  return table;
}();

// ============================================================================
// Inline functions using lookup tables
// ============================================================================

// Parse a hex digit, returns -1 if invalid
inline int hexDigit(unsigned char c) {
  uint8_t val = kHexTable[c];
  return val == 255 ? -1 : static_cast<int>(val);
}

// Encode a Unicode code point as UTF-8 into the output string
inline void encodeUtf8(std::string& out, uint32_t codepoint) {
#ifdef MERVE_USE_SIMDUTF
  // Use simdutf for optimized UTF-32 to UTF-8 conversion
  char buf[4];
  size_t len = simdutf::convert_utf32_to_utf8(
      reinterpret_cast<const char32_t*>(&codepoint), 1, buf);
  out.append(buf, len);
#else
  if (codepoint <= 0x7F) {
    out.push_back(static_cast<char>(codepoint));
  } else if (codepoint <= 0x7FF) {
    out.push_back(static_cast<char>(0xC0 | (codepoint >> 6)));
    out.push_back(static_cast<char>(0x80 | (codepoint & 0x3F)));
  } else if (codepoint <= 0xFFFF) {
    out.push_back(static_cast<char>(0xE0 | (codepoint >> 12)));
    out.push_back(static_cast<char>(0x80 | ((codepoint >> 6) & 0x3F)));
    out.push_back(static_cast<char>(0x80 | (codepoint & 0x3F)));
  } else if (codepoint <= 0x10FFFF) {
    out.push_back(static_cast<char>(0xF0 | (codepoint >> 18)));
    out.push_back(static_cast<char>(0x80 | ((codepoint >> 12) & 0x3F)));
    out.push_back(static_cast<char>(0x80 | ((codepoint >> 6) & 0x3F)));
    out.push_back(static_cast<char>(0x80 | (codepoint & 0x3F)));
  }
#endif
}

// Unescape JavaScript string escape sequences
// Returns empty optional on invalid escape sequences (like lone surrogates)
std::optional<std::string> unescapeJsString(std::string_view str) {
  std::string result;
  result.reserve(str.size());

  for (size_t i = 0; i < str.size(); ++i) {
    if (str[i] != '\\') {
      result.push_back(str[i]);
      continue;
    }

    if (++i >= str.size()) {
      return std::nullopt;  // Trailing backslash
    }

    // Check simple escape table first (single character escapes)
    uint8_t simple = kSimpleEscapeTable[static_cast<unsigned char>(str[i])];
    if (simple != 0xFF) {
      result.push_back(static_cast<char>(simple));
      continue;
    }

    // Handle complex escapes
    switch (str[i]) {
      case 'x': {
        // \xHH - two hex digits
        if (i + 2 >= str.size()) return std::nullopt;
        int h1 = hexDigit(static_cast<unsigned char>(str[i + 1]));
        int h2 = hexDigit(static_cast<unsigned char>(str[i + 2]));
        if (h1 < 0 || h2 < 0) return std::nullopt;
        result.push_back(static_cast<char>((h1 << 4) | h2));
        i += 2;
        break;
      }
      case 'u': {
        if (i + 1 >= str.size()) return std::nullopt;
        if (str[i + 1] == '{') {
          // \u{XXXX} - variable length hex
          size_t start = i + 2;
          size_t end_brace = str.find('}', start);
          if (end_brace == std::string_view::npos || end_brace == start) return std::nullopt;
          uint32_t codepoint = 0;
          for (size_t j = start; j < end_brace; ++j) {
            int digit = hexDigit(static_cast<unsigned char>(str[j]));
            if (digit < 0) return std::nullopt;
            codepoint = (codepoint << 4) | static_cast<uint32_t>(digit);
            if (codepoint > 0x10FFFF) return std::nullopt;  // Invalid codepoint
          }
          // Handle surrogate pairs in \u{XXXX} format
          if (codepoint >= 0xD800 && codepoint <= 0xDBFF) {
            // High surrogate - check for low surrogate \u{XXXX}
            if (end_brace + 3 < str.size() && str[end_brace + 1] == '\\' &&
                str[end_brace + 2] == 'u' && str[end_brace + 3] == '{') {
              size_t low_start = end_brace + 4;
              size_t low_end = str.find('}', low_start);
              if (low_end != std::string_view::npos && low_end > low_start) {
                uint32_t low = 0;
                bool valid_low = true;
                for (size_t j = low_start; j < low_end; ++j) {
                  int digit = hexDigit(static_cast<unsigned char>(str[j]));
                  if (digit < 0) {
                    valid_low = false;
                    break;
                  }
                  low = (low << 4) | static_cast<uint32_t>(digit);
                }
                if (valid_low && low >= 0xDC00 && low <= 0xDFFF) {
                  // Valid surrogate pair - combine into single codepoint
                  codepoint = 0x10000 + ((codepoint - 0xD800) << 10) + (low - 0xDC00);
                  end_brace = low_end;  // Skip past the low surrogate
                } else {
                  // Lone high surrogate
                  return std::nullopt;
                }
              } else {
                // Lone high surrogate
                return std::nullopt;
              }
            } else {
              // Lone high surrogate
              return std::nullopt;
            }
          } else if (codepoint >= 0xDC00 && codepoint <= 0xDFFF) {
            // Lone low surrogate
            return std::nullopt;
          }
          encodeUtf8(result, codepoint);
          i = end_brace;
        } else {
          // \uHHHH - exactly four hex digits
          if (i + 4 >= str.size()) return std::nullopt;
          uint32_t codepoint = 0;
          for (int j = 1; j <= 4; ++j) {
            int digit = hexDigit(static_cast<unsigned char>(str[i + static_cast<size_t>(j)]));
            if (digit < 0) return std::nullopt;
            codepoint = (codepoint << 4) | static_cast<uint32_t>(digit);
          }
          // Handle surrogate pairs
          if (codepoint >= 0xD800 && codepoint <= 0xDBFF) {
            // High surrogate - check for low surrogate
            if (i + 10 < str.size() && str[i + 5] == '\\' && str[i + 6] == 'u') {
              uint32_t low = 0;
              bool valid_low = true;
              for (int j = 7; j <= 10; ++j) {
                int digit = hexDigit(static_cast<unsigned char>(str[i + static_cast<size_t>(j)]));
                if (digit < 0) {
                  valid_low = false;
                  break;
                }
                low = (low << 4) | static_cast<uint32_t>(digit);
              }
              if (valid_low && low >= 0xDC00 && low <= 0xDFFF) {
                // Valid surrogate pair - combine into single codepoint
                codepoint = 0x10000 + ((codepoint - 0xD800) << 10) + (low - 0xDC00);
                i += 6;  // Skip the low surrogate
              } else {
                // Lone high surrogate
                return std::nullopt;
              }
            } else {
              // Lone high surrogate
              return std::nullopt;
            }
          } else if (codepoint >= 0xDC00 && codepoint <= 0xDFFF) {
            // Lone low surrogate
            return std::nullopt;
          }
          encodeUtf8(result, codepoint);
          i += 4;
        }
        break;
      }
      default:
        // Unknown escape - just include the character as-is
        result.push_back(str[i]);
        break;
    }
  }

  return result;
}

// Stack depth limits
constexpr size_t STACK_DEPTH = 2048;
constexpr size_t MAX_STAR_EXPORTS = 256;

// RequireType enum for parsing require statements
enum class RequireType {
  Import,
  ExportAssign,
  ExportStar
};

// StarExportBinding structure for tracking star export bindings
struct StarExportBinding {
  std::string_view specifier;
  std::string_view id;
};

// Thread-local state for error tracking (safe for concurrent parse calls).
thread_local std::optional<lexer_error> last_error;
thread_local std::optional<error_location> last_error_location;

static error_location makeErrorLocation(const char* source, const char* end, const char* at) {
  const char* target = at;
  if (target < source) target = source;
  if (target > end) target = end;

  uint32_t line = 1;
  uint32_t column = 1;
  const char* cur = source;

  while (cur < target) {
    const char ch = *cur++;
    if (ch == '\n') {
      line++;
      column = 1;
      continue;
    }
    if (ch == '\r') {
      line++;
      column = 1;
      if (cur < target && *cur == '\n') {
        cur++;
      }
      continue;
    }
    column++;
  }

  error_location loc{};
  loc.line = line;
  loc.column = column;
  return loc;
}

// Lexer state class
class CJSLexer {
private:
  const char* source;
  const char* pos;
  const char* end;
  const char* lastTokenPos;

  uint16_t templateStackDepth;
  uint16_t openTokenDepth;
  uint16_t templateDepth;

  uint32_t line;

  bool lastSlashWasDivision;
  bool nextBraceIsClass;

  std::array<uint16_t, STACK_DEPTH> templateStack_;
  std::array<const char*, STACK_DEPTH> openTokenPosStack_;
  std::array<char, STACK_DEPTH> openTokenTypeStack_;
  std::array<bool, STACK_DEPTH> openClassPosStack;
  std::array<StarExportBinding, MAX_STAR_EXPORTS> starExportStack_;
  StarExportBinding* starExportStack;
  const StarExportBinding* STAR_EXPORT_STACK_END;

  std::vector<export_entry>& exports;
  std::vector<export_entry>& re_exports;

  // Increments `line` when consuming a line terminator.
  // - Counts '\n' as a newline.
  // - Counts '\r' as a newline only when it is not part of a CRLF sequence.
  //   (i.e., the next character is not '\n' or we're at end-of-input.)
  void countNewline(char ch) {
    line += (ch == '\n') || (ch == '\r' && (pos + 1 >= end || *(pos + 1) != '\n'));
  }

  // Character classification helpers using lookup tables
  static bool isBr(char c) {
    return c == '\r' || c == '\n';
  }

  static bool isBrOrWs(unsigned char c) {
    return kBrOrWsTable[c];
  }

  static bool isBrOrWsOrPunctuatorNotDot(unsigned char c) {
    return kBrOrWsTable[c] || (kPunctuatorTable[c] && c != '.');
  }

  static bool isPunctuator(unsigned char ch) {
    return kPunctuatorTable[ch];
  }

  static bool isExpressionPunctuator(unsigned char ch) {
    return kExpressionPunctuatorTable[ch];
  }

  // String comparison helpers using string_view for cleaner, more maintainable code
  static constexpr bool matchesAt(const char* p, const char* end_pos, std::string_view expected) {
    size_t available = static_cast<size_t>(end_pos - p);
    if (available < expected.size()) return false;
    for (size_t i = 0; i < expected.size(); ++i) {
      if (p[i] != expected[i]) return false;
    }
    return true;
  }

  // Character type detection using lookup tables
  static bool isIdentifierStart(uint8_t ch) {
    return kIdentifierStartTable[ch];
  }

  static bool isIdentifierChar(uint8_t ch) {
    return kIdentifierCharTable[ch];
  }

  constexpr bool keywordStart(const char* p) const {
    return p == source || isBrOrWsOrPunctuatorNotDot(*(p - 1));
  }

  constexpr bool readPrecedingKeyword(const char* p, std::string_view keyword) const {
    if (p - static_cast<ptrdiff_t>(keyword.size()) + 1 < source) return false;
    const char* start = p - keyword.size() + 1;
    return matchesAt(start, end, keyword) && (start == source || isBrOrWsOrPunctuatorNotDot(*(start - 1)));
  }

  // Keyword detection
  constexpr bool isExpressionKeyword(const char* p) const {
    switch (*p) {
      case 'd':
        switch (*(p - 1)) {
          case 'i':
            return readPrecedingKeyword(p - 2, "vo");
          case 'l':
            return readPrecedingKeyword(p - 2, "yie");
          default:
            return false;
        }
      case 'e':
        switch (*(p - 1)) {
          case 's':
            switch (*(p - 2)) {
              case 'l':
                return p - 3 >= source && *(p - 3) == 'e' && keywordStart(p - 3);
              case 'a':
                return p - 3 >= source && *(p - 3) == 'c' && keywordStart(p - 3);
              default:
                return false;
            }
          case 't':
            return readPrecedingKeyword(p - 2, "dele");
          default:
            return false;
        }
      case 'f':
        if (*(p - 1) != 'o' || *(p - 2) != 'e')
          return false;
        switch (*(p - 3)) {
          case 'c':
            return readPrecedingKeyword(p - 4, "instan");
          case 'p':
            return readPrecedingKeyword(p - 4, "ty");
          default:
            return false;
        }
      case 'n':
        return (p - 1 >= source && *(p - 1) == 'i' && keywordStart(p - 1)) ||
               readPrecedingKeyword(p - 1, "retur");
      case 'o':
        return p - 1 >= source && *(p - 1) == 'd' && keywordStart(p - 1);
      case 'r':
        return readPrecedingKeyword(p - 1, "debugge");
      case 't':
        return readPrecedingKeyword(p - 1, "awai");
      case 'w':
        switch (*(p - 1)) {
          case 'e':
            return p - 2 >= source && *(p - 2) == 'n' && keywordStart(p - 2);
          case 'o':
            return readPrecedingKeyword(p - 2, "thr");
          default:
            return false;
        }
    }
    return false;
  }

  constexpr bool isParenKeyword(const char* curPos) const {
    return readPrecedingKeyword(curPos, "while") ||
           readPrecedingKeyword(curPos, "for") ||
           readPrecedingKeyword(curPos, "if");
  }

  constexpr bool isExpressionTerminator(const char* curPos) const {
    switch (*curPos) {
      case '>':
        return *(curPos - 1) == '=';
      case ';':
      case ')':
        return true;
      case 'h':
        return readPrecedingKeyword(curPos - 1, "catc");
      case 'y':
        return readPrecedingKeyword(curPos - 1, "finall");
      case 'e':
        return readPrecedingKeyword(curPos - 1, "els");
    }
    return false;
  }

  // Parsing utilities
  void syntaxError(lexer_error code, const char* at = nullptr) {
    if (!last_error) {
      last_error = code;
      const char* error_pos = at ? at : pos;
      last_error_location = makeErrorLocation(source, end, error_pos);
    }
    pos = end + 1;
  }

  char commentWhitespace() {
    char ch;
    do {
      if (pos >= end) return '\0';
      ch = *pos;
      if (ch == '/') {
        char next_ch = pos + 1 < end ? *(pos + 1) : '\0';
        if (next_ch == '/')
          lineComment();
        else if (next_ch == '*')
          blockComment();
        else
          return ch;
      } else if (!isBrOrWs(ch)) {
        return ch;
      } else {
        countNewline(ch);
      }
    } while (pos++ < end);
    return ch;
  }

  void lineComment() {
    while (pos++ < end) {
      char ch = *pos;
      if (ch == '\n' || ch == '\r') {
        countNewline(ch);
        return;
      }
    }
  }

  void blockComment() {
    pos++;
    while (pos++ < end) {
      char ch = *pos;
      if (ch == '*' && *(pos + 1) == '/') {
        pos++;
        return;
      }
      countNewline(ch);
    }
  }

  void stringLiteral(char quote) {
    while (pos++ < end) {
      char ch = *pos;
      if (ch == quote)
        return;
      if (ch == '\\') {
        if (pos + 1 >= end) break;
        ch = *++pos;
        if (ch == '\r') {
          ++line;
          if (*(pos + 1) == '\n')
            pos++;
        } else if (ch == '\n') {
          ++line;
        }
      } else if (isBr(ch))
        break;
    }
    syntaxError(lexer_error::UNTERMINATED_STRING_LITERAL);
  }

  void regularExpression() {
    while (pos++ < end) {
      char ch = *pos;
      if (ch == '/')
        return;
      if (ch == '[') {
        regexCharacterClass();
      } else if (ch == '\\') {
        if (pos + 1 < end)
          pos++;
      } else if (ch == '\n' || ch == '\r')
        break;
    }
    syntaxError(lexer_error::UNTERMINATED_REGEX);
  }

  void regexCharacterClass() {
    while (pos++ < end) {
      char ch = *pos;
      if (ch == ']')
        return;
      if (ch == '\\') {
        if (pos + 1 < end)
          pos++;
      } else if (ch == '\n' || ch == '\r')
        break;
    }
    syntaxError(lexer_error::UNTERMINATED_REGEX_CHARACTER_CLASS);
  }

  void templateString() {
    while (pos++ < end) {
      char ch = *pos;
      if (ch == '$' && *(pos + 1) == '{') {
        pos++;
        if (templateStackDepth >= STACK_DEPTH) {
          syntaxError(lexer_error::TEMPLATE_NEST_OVERFLOW);
          return;
        }
        templateStack_[templateStackDepth++] = templateDepth;
        templateDepth = ++openTokenDepth;
        return;
      }
      if (ch == '`')
        return;
      if (ch == '\\' && pos + 1 < end) {
        pos++;
        countNewline(*pos);
      } else {
        countNewline(ch);
      }
    }
    syntaxError(lexer_error::UNTERMINATED_TEMPLATE_STRING);
  }

  bool identifier(char startCh) {
    if (!isIdentifierStart(static_cast<uint8_t>(startCh)))
      return false;
    pos++;
    while (pos < end) {
      char ch = *pos;
      if (isIdentifierChar(static_cast<uint8_t>(ch))) {
        pos++;
      } else {
        break;
      }
    }
    return true;
  }

  // Check if string contains escape sequences
  static bool needsUnescaping(std::string_view str) {
#ifdef MERVE_USE_SIMDUTF
    // simdutf provides fast SIMD-based ASCII validation
    // If the string is valid ASCII without high bytes, we can use a faster path
    // But we still need to check for backslash
    const char* ptr = simdutf::find(str.data(), str.data() + str.size(), '\\');
    return ptr != str.data() + str.size();
#else
    return str.find('\\') != std::string_view::npos;
#endif
  }

  void addExport(std::string_view export_name, uint32_t at_line) {
    // Skip surrounding quotes if present
    if (!export_name.empty() && (export_name.front() == '\'' || export_name.front() == '"')) {
      export_name.remove_prefix(1);
      export_name.remove_suffix(1);
    }

    // Fast path: no escaping needed, use string_view directly
    if (!needsUnescaping(export_name)) {
      // Check if this export already exists (avoid duplicates)
      for (const auto& existing : exports) {
        if (get_string_view(existing.name) == export_name) {
          return; // Already exists, skip
        }
      }
      exports.push_back(export_entry{export_name, at_line});
      return;
    }

    // Slow path: unescape the export name (handles \u{XXXX}, \uHHHH, etc.)
    // Returns nullopt for invalid sequences like lone surrogates
    auto unescaped = unescapeJsString(export_name);
    if (!unescaped.has_value()) {
      return;  // Skip invalid escape sequences
    }

    const std::string& name = unescaped.value();

    // Check if this export already exists (avoid duplicates)
    for (const auto& existing : exports) {
      if (get_string_view(existing.name) == name) {
        return; // Already exists, skip
      }
    }
    exports.push_back(export_entry{std::move(unescaped.value()), at_line});
  }

  void addReexport(std::string_view reexport_name, uint32_t at_line) {
    // Skip surrounding quotes if present
    if (!reexport_name.empty() && (reexport_name.front() == '\'' || reexport_name.front() == '"')) {
      reexport_name.remove_prefix(1);
      reexport_name.remove_suffix(1);
    }

    // Fast path: no escaping needed, use string_view directly
    if (!needsUnescaping(reexport_name)) {
      re_exports.push_back(export_entry{reexport_name, at_line});
      return;
    }

    // Slow path: unescape the reexport name
    auto unescaped = unescapeJsString(reexport_name);
    if (!unescaped.has_value()) {
      return;  // Skip invalid escape sequences
    }

    re_exports.push_back(export_entry{std::move(unescaped.value()), at_line});
  }

  bool readExportsOrModuleDotExports(char ch) {
    const char* revertPos = pos;
    if (ch == 'm' && matchesAt(pos + 1, end, "odule")) {
      pos += 6;
      ch = commentWhitespace();
      if (ch != '.') {
        pos = revertPos;
        return false;
      }
      pos++;
      ch = commentWhitespace();
    }
    if (ch == 'e' && matchesAt(pos + 1, end, "xports")) {
      pos += 7;
      return true;
    }
    pos = revertPos;
    return false;
  }

  bool tryParseRequire(RequireType requireType) {
    const char* revertPos = pos;
    if (!matchesAt(pos + 1, end, "equire")) {
      return false;
    }
    pos += 7;
    char ch = commentWhitespace();
    if (ch == '(') {
      pos++;
      ch = commentWhitespace();
      const char* reexportStart = pos;
      if (ch == '\'' || ch == '"') {
        stringLiteral(ch);
        const char* reexportEnd = ++pos;
        ch = commentWhitespace();
        if (ch == ')') {
          switch (requireType) {
            case RequireType::ExportStar:
            case RequireType::ExportAssign:
              addReexport(std::string_view(reexportStart, reexportEnd - reexportStart), line);
              return true;
            default:
              if (starExportStack < STAR_EXPORT_STACK_END) {
                starExportStack->specifier = std::string_view(reexportStart, reexportEnd - reexportStart);
              }
              return true;
          }
        }
      }
    }
    pos = revertPos;
    return false;
  }

  // Helper to parse property value in object literal (identifier or require())
  bool tryParsePropertyValue(char& ch) {
    if (ch == 'r' && tryParseRequire(RequireType::ExportAssign)) {
      ch = *pos;
      return true;
    }
    if (identifier(ch)) {
      ch = *pos;
      return true;
    }
    return false;
  }

  void tryParseLiteralExports() {
    const char* revertPos = pos - 1;
    while (pos++ < end) {
      char ch = commentWhitespace();
      const char* startPos = pos;
      if (identifier(ch)) {
        const char* endPos = pos;
        ch = commentWhitespace();

        // Check if this is a getter syntax: get identifier() { ... }
        if (ch != ':' && endPos - startPos == 3 && matchesAt(startPos, end, "get") && identifier(ch)) {
          ch = commentWhitespace();
          if (ch == '(') {
            // This is a getter, stop parsing here (early termination)
            pos = revertPos;
            return;
          }
        }

        if (ch == ':') {
          pos++;
          ch = commentWhitespace();
          if (!tryParsePropertyValue(ch)) {
            pos = revertPos;
            return;
          }
        }
        addExport(std::string_view(startPos, endPos - startPos), line);
      } else if (ch == '\'' || ch == '"') {
        const char* start = pos;
        stringLiteral(ch);
        const char* end_pos = ++pos;
        ch = commentWhitespace();
        if (ch == ':') {
          pos++;
          ch = commentWhitespace();
          if (!tryParsePropertyValue(ch)) {
            pos = revertPos;
            return;
          }
          addExport(std::string_view(start, end_pos - start), line);
        }
      } else if (ch == '.' && matchesAt(pos + 1, end, "..")) {
        pos += 3;
        if (pos < end && *pos == 'r' && tryParseRequire(RequireType::ExportAssign)) {
          pos++;
        } else if (pos < end && !identifier(*pos)) {
          pos = revertPos;
          return;
        }
        ch = commentWhitespace();
      } else {
        pos = revertPos;
        return;
      }

      if (ch == '}')
        return;

      if (ch != ',') {
        pos = revertPos;
        return;
      }
    }
  }

  void tryParseExportsDotAssign(bool assign) {
    pos += 7;
    const char* revertPos = pos - 1;
    char ch = commentWhitespace();
    switch (ch) {
      case '.': {
        pos++;
        ch = commentWhitespace();
        const char* startPos = pos;
        if (identifier(ch)) {
          const char* endPos = pos;
          ch = commentWhitespace();
          if (ch == '=') {
            addExport(std::string_view(startPos, endPos - startPos), line);
            return;
          }
        }
        break;
      }
      case '[': {
        pos++;
        ch = commentWhitespace();
        if (ch == '\'' || ch == '"') {
          const char* startPos = pos;
          stringLiteral(ch);
          const char* endPos = ++pos;
          ch = commentWhitespace();
          if (ch != ']') break;
          pos++;
          ch = commentWhitespace();
          if (ch != '=') break;
          addExport(std::string_view(startPos, endPos - startPos), line);
        }
        break;
      }
      case '=': {
        if (assign) {
          re_exports.clear();
          pos++;
          ch = commentWhitespace();
          if (ch == '{') {
            tryParseLiteralExports();
            return;
          }
          if (ch == 'r')
            tryParseRequire(RequireType::ExportAssign);
        }
        break;
      }
    }
    pos = revertPos;
  }

  void tryParseModuleExportsDotAssign() {
    pos += 6;
    const char* revertPos = pos - 1;
    char ch = commentWhitespace();
    if (ch == '.') {
      pos++;
      ch = commentWhitespace();
      if (ch == 'e' && matchesAt(pos + 1, end, "xports")) {
        tryParseExportsDotAssign(true);
        return;
      }
    }
    pos = revertPos;
  }

  bool tryParseObjectHasOwnProperty(std::string_view it_id) {
    char ch = commentWhitespace();
    if (ch != 'O' || !matchesAt(pos + 1, end, "bject")) return false;
    pos += 6;
    ch = commentWhitespace();
    if (ch != '.') return false;
    pos++;
    ch = commentWhitespace();
    if (ch == 'p') {
      if (!matchesAt(pos + 1, end, "rototype")) return false;
      pos += 9;
      ch = commentWhitespace();
      if (ch != '.') return false;
      pos++;
      ch = commentWhitespace();
    }
    if (ch != 'h' || !matchesAt(pos + 1, end, "asOwnProperty")) return false;
    pos += 14;
    ch = commentWhitespace();
    if (ch != '.') return false;
    pos++;
    ch = commentWhitespace();
    if (ch != 'c' || !matchesAt(pos + 1, end, "all")) return false;
    pos += 4;
    ch = commentWhitespace();
    if (ch != '(') return false;
    pos++;
    ch = commentWhitespace();
    if (!identifier(ch)) return false;
    ch = commentWhitespace();
    if (ch != ',') return false;
    pos++;
    ch = commentWhitespace();
    if (!matchesAt(pos, end, it_id)) return false;
    pos += it_id.size();
    ch = commentWhitespace();
    if (ch != ')') return false;
    pos++;
    return true;
  }

  void tryParseObjectDefineOrKeys(bool keys) {
    pos += 6;
    const char* revertPos = pos - 1;
    char ch = commentWhitespace();
    if (ch == '.') {
      pos++;
      ch = commentWhitespace();
      if (ch == 'd' && matchesAt(pos + 1, end, "efineProperty")) {
        const char* exportStart = nullptr;
        const char* exportEnd = nullptr;
        while (true) {
          pos += 14;
          revertPos = pos - 1;
          ch = commentWhitespace();
          if (ch != '(') break;
          pos++;
          ch = commentWhitespace();
          if (!readExportsOrModuleDotExports(ch)) break;
          ch = commentWhitespace();
          if (ch != ',') break;
          pos++;
          ch = commentWhitespace();
          if (ch != '\'' && ch != '"') break;
          exportStart = pos;
          stringLiteral(ch);
          exportEnd = ++pos;
          ch = commentWhitespace();
          if (ch != ',') break;
          pos++;
          ch = commentWhitespace();
          if (ch != '{') break;
          pos++;
          ch = commentWhitespace();
          if (ch == 'e') {
            if (!matchesAt(pos + 1, end, "numerable")) break;
            pos += 10;
            ch = commentWhitespace();
            if (ch != ':') break;
            pos++;
            ch = commentWhitespace();
            if (ch != 't' || !matchesAt(pos + 1, end, "rue")) break;
            pos += 4;
            ch = commentWhitespace();
            if (ch != ',') break;
            pos++;
            ch = commentWhitespace();
          }
          if (ch == 'v') {
            if (!matchesAt(pos + 1, end, "alue")) break;
            pos += 5;
            ch = commentWhitespace();
            if (ch != ':') break;
            if (exportStart && exportEnd)
              addExport(std::string_view(exportStart, exportEnd - exportStart), line);
            pos = revertPos;
            return;
          } else if (ch == 'g') {
            if (!matchesAt(pos + 1, end, "et")) break;
            pos += 3;
            ch = commentWhitespace();
            if (ch == ':') {
              pos++;
              ch = commentWhitespace();
              if (ch != 'f') break;
              if (!matchesAt(pos + 1, end, "unction")) break;
              pos += 8;
              const char* lastPos = pos;
              ch = commentWhitespace();
              if (ch != '(' && (lastPos == pos || !identifier(ch))) break;
              ch = commentWhitespace();
            }
            if (ch != '(') break;
            pos++;
            ch = commentWhitespace();
            if (ch != ')') break;
            pos++;
            ch = commentWhitespace();
            if (ch != '{') break;
            pos++;
            ch = commentWhitespace();
            if (ch != 'r') break;
            if (!matchesAt(pos + 1, end, "eturn")) break;
            pos += 6;
            ch = commentWhitespace();
            if (!identifier(ch)) break;
            ch = commentWhitespace();
            if (ch == '.') {
              pos++;
              ch = commentWhitespace();
              if (!identifier(ch)) break;
              ch = commentWhitespace();
            } else if (ch == '[') {
              pos++;
              ch = commentWhitespace();
              if (ch == '\'' || ch == '"') {
                stringLiteral(ch);
              } else {
                break;
              }
              pos++;
              ch = commentWhitespace();
              if (ch != ']') break;
              pos++;
              ch = commentWhitespace();
            }
            if (ch == ';') {
              pos++;
              ch = commentWhitespace();
            }
            if (ch != '}') break;
            pos++;
            ch = commentWhitespace();
            if (ch == ',') {
              pos++;
              ch = commentWhitespace();
            }
            if (ch != '}') break;
            pos++;
            ch = commentWhitespace();
            if (ch != ')') break;
            if (exportStart && exportEnd)
              addExport(std::string_view(exportStart, exportEnd - exportStart), line);
            return;
          }
          break;
        }
      } else if (keys && ch == 'k' && matchesAt(pos + 1, end, "eys")) {
        while (true) {
          pos += 4;
          revertPos = pos - 1;
          ch = commentWhitespace();
          if (ch != '(') break;
          pos++;
          ch = commentWhitespace();
          const char* id_pos = pos;
          if (!identifier(ch)) break;
          std::string_view id(id_pos, static_cast<size_t>(pos - id_pos));
          ch = commentWhitespace();
          if (ch != ')') break;

          revertPos = pos++;
          ch = commentWhitespace();
          if (ch != '.') break;
          pos++;
          ch = commentWhitespace();
          if (ch != 'f' || !matchesAt(pos + 1, end, "orEach")) break;
          pos += 7;
          ch = commentWhitespace();
          revertPos = pos - 1;
          if (ch != '(') break;
          pos++;
          ch = commentWhitespace();
          if (ch != 'f' || !matchesAt(pos + 1, end, "unction")) break;
          pos += 8;
          ch = commentWhitespace();
          if (ch != '(') break;
          pos++;
          ch = commentWhitespace();
          const char* it_id_pos = pos;
          if (!identifier(ch)) break;
          std::string_view it_id(it_id_pos, static_cast<size_t>(pos - it_id_pos));
          ch = commentWhitespace();
          if (ch != ')') break;
          pos++;
          ch = commentWhitespace();
          if (ch != '{') break;
          pos++;
          ch = commentWhitespace();
          if (ch != 'i' || *(pos + 1) != 'f') break;
          pos += 2;
          ch = commentWhitespace();
          if (ch != '(') break;
          pos++;
          ch = commentWhitespace();
          if (!matchesAt(pos, end, it_id)) break;
          pos += it_id.size();
          ch = commentWhitespace();

          if (ch == '=') {
            if (!matchesAt(pos + 1, end, "==")) break;
            pos += 3;
            ch = commentWhitespace();
            if (ch != '"' && ch != '\'') break;
            char quot = ch;
            if (!matchesAt(pos + 1, end, "default")) break;
            pos += 8;
            ch = commentWhitespace();
            if (ch != quot) break;
            pos++;
            ch = commentWhitespace();
            if (ch != '|' || *(pos + 1) != '|') break;
            pos += 2;
            ch = commentWhitespace();
            if (!matchesAt(pos, end, it_id)) break;
            pos += it_id.size();
            ch = commentWhitespace();
            if (ch != '=' || !matchesAt(pos + 1, end, "==")) break;
            pos += 3;
            ch = commentWhitespace();
            if (ch != '"' && ch != '\'') break;
            quot = ch;
            if (!matchesAt(pos + 1, end, "__esModule")) break;
            pos += 11;
            ch = commentWhitespace();
            if (ch != quot) break;
            pos++;
            ch = commentWhitespace();
            if (ch != ')') break;
            pos++;
            ch = commentWhitespace();
            if (ch != 'r' || !matchesAt(pos + 1, end, "eturn")) break;
            pos += 6;
            ch = commentWhitespace();
            if (ch == ';')
              pos++;
            ch = commentWhitespace();

            if (ch == 'i' && *(pos + 1) == 'f') {
              bool inIf = true;
              pos += 2;
              ch = commentWhitespace();
              if (ch != '(') break;
              pos++;
              const char* ifInnerPos = pos;

              if (tryParseObjectHasOwnProperty(it_id)) {
                ch = commentWhitespace();
                if (ch != ')') break;
                pos++;
                ch = commentWhitespace();
                if (ch != 'r' || !matchesAt(pos + 1, end, "eturn")) break;
                pos += 6;
                ch = commentWhitespace();
                if (ch == ';')
                  pos++;
                ch = commentWhitespace();
                if (ch == 'i' && *(pos + 1) == 'f') {
                  pos += 2;
                  ch = commentWhitespace();
                  if (ch != '(') break;
                  pos++;
                } else {
                  inIf = false;
                }
              } else {
                pos = ifInnerPos;
              }

              if (inIf) {
                if (!matchesAt(pos, end, it_id)) break;
                pos += it_id.size();
                ch = commentWhitespace();
                if (ch != 'i' || !matchesAt(pos + 1, end, "n ")) break;
                pos += 3;
                ch = commentWhitespace();
                if (!readExportsOrModuleDotExports(ch)) break;
                ch = commentWhitespace();
                if (ch != '&' || *(pos + 1) != '&') break;
                pos += 2;
                ch = commentWhitespace();
                if (!readExportsOrModuleDotExports(ch)) break;
                ch = commentWhitespace();
                if (ch != '[') break;
                pos++;
                ch = commentWhitespace();
                if (!matchesAt(pos, end, it_id)) break;
                pos += it_id.size();
                ch = commentWhitespace();
                if (ch != ']') break;
                pos++;
                ch = commentWhitespace();
                if (ch != '=' || !matchesAt(pos + 1, end, "==")) break;
                pos += 3;
                ch = commentWhitespace();
                if (!matchesAt(pos, end, id)) break;
                pos += id.size();
                ch = commentWhitespace();
                if (ch != '[') break;
                pos++;
                ch = commentWhitespace();
                if (!matchesAt(pos, end, it_id)) break;
                pos += it_id.size();
                ch = commentWhitespace();
                if (ch != ']') break;
                pos++;
                ch = commentWhitespace();
                if (ch != ')') break;
                pos++;
                ch = commentWhitespace();
                if (ch != 'r' || !matchesAt(pos + 1, end, "eturn")) break;
                pos += 6;
                ch = commentWhitespace();
                if (ch == ';')
                  pos++;
                ch = commentWhitespace();
              }
            }
          } else if (ch == '!') {
            if (!matchesAt(pos + 1, end, "==")) break;
            pos += 3;
            ch = commentWhitespace();
            if (ch != '"' && ch != '\'') break;
            char quot = ch;
            if (!matchesAt(pos + 1, end, "default")) break;
            pos += 8;
            ch = commentWhitespace();
            if (ch != quot) break;
            pos++;
            ch = commentWhitespace();
            if (ch == '&') {
              if (*(pos + 1) != '&') break;
              pos += 2;
              ch = commentWhitespace();
              if (ch != '!') break;
              pos++;
              ch = commentWhitespace();
              if (ch == 'O' && matchesAt(pos + 1, end, "bject.")) {
                if (!tryParseObjectHasOwnProperty(it_id)) break;
              } else if (identifier(ch)) {
                ch = commentWhitespace();
                if (ch != '.') break;
                pos++;
                ch = commentWhitespace();
                if (ch != 'h' || !matchesAt(pos + 1, end, "asOwnProperty")) break;
                pos += 14;
                ch = commentWhitespace();
                if (ch != '(') break;
                pos++;
                ch = commentWhitespace();
                if (!matchesAt(pos, end, it_id)) break;
                pos += it_id.size();
                ch = commentWhitespace();
                if (ch != ')') break;
                pos++;
              }
              ch = commentWhitespace();
            }
            if (ch != ')') break;
            pos++;
            ch = commentWhitespace();
          } else {
            break;
          }

          if (readExportsOrModuleDotExports(ch)) {
            ch = commentWhitespace();
            if (ch != '[') break;
            pos++;
            ch = commentWhitespace();
            if (!matchesAt(pos, end, it_id)) break;
            pos += it_id.size();
            ch = commentWhitespace();
            if (ch != ']') break;
            pos++;
            ch = commentWhitespace();
            if (ch != '=') break;
            pos++;
            ch = commentWhitespace();
            if (!matchesAt(pos, end, id)) break;
            pos += id.size();
            ch = commentWhitespace();
            if (ch != '[') break;
            pos++;
            ch = commentWhitespace();
            if (!matchesAt(pos, end, it_id)) break;
            pos += it_id.size();
            ch = commentWhitespace();
            if (ch != ']') break;
            pos++;
            ch = commentWhitespace();
            if (ch == ';') {
              pos++;
              ch = commentWhitespace();
            }
          } else if (ch == 'O') {
            if (!matchesAt(pos + 1, end, "bject")) break;
            pos += 6;
            ch = commentWhitespace();
            if (ch != '.') break;
            pos++;
            ch = commentWhitespace();
            if (ch != 'd' || !matchesAt(pos + 1, end, "efineProperty")) break;
            pos += 14;
            ch = commentWhitespace();
            if (ch != '(') break;
            pos++;
            ch = commentWhitespace();
            if (!readExportsOrModuleDotExports(ch)) break;
            ch = commentWhitespace();
            if (ch != ',') break;
            pos++;
            ch = commentWhitespace();
            if (!matchesAt(pos, end, it_id)) break;
            pos += it_id.size();
            ch = commentWhitespace();
            if (ch != ',') break;
            pos++;
            ch = commentWhitespace();
            if (ch != '{') break;
            pos++;
            ch = commentWhitespace();
            if (ch != 'e' || !matchesAt(pos + 1, end, "numerable")) break;
            pos += 10;
            ch = commentWhitespace();
            if (ch != ':') break;
            pos++;
            ch = commentWhitespace();
            if (ch != 't' || !matchesAt(pos + 1, end, "rue")) break;
            pos += 4;
            ch = commentWhitespace();
            if (ch != ',') break;
            pos++;
            ch = commentWhitespace();
            if (ch != 'g' || !matchesAt(pos + 1, end, "et")) break;
            pos += 3;
            ch = commentWhitespace();
            if (ch == ':') {
              pos++;
              ch = commentWhitespace();
              if (ch != 'f') break;
              if (!matchesAt(pos + 1, end, "unction")) break;
              pos += 8;
              const char* lastPos = pos;
              ch = commentWhitespace();
              if (ch != '(' && (lastPos == pos || !identifier(ch))) break;
              ch = commentWhitespace();
            }
            if (ch != '(') break;
            pos++;
            ch = commentWhitespace();
            if (ch != ')') break;
            pos++;
            ch = commentWhitespace();
            if (ch != '{') break;
            pos++;
            ch = commentWhitespace();
            if (ch != 'r' || !matchesAt(pos + 1, end, "eturn")) break;
            pos += 6;
            ch = commentWhitespace();
            if (!matchesAt(pos, end, id)) break;
            pos += id.size();
            ch = commentWhitespace();
            if (ch != '[') break;
            pos++;
            ch = commentWhitespace();
            if (!matchesAt(pos, end, it_id)) break;
            pos += it_id.size();
            ch = commentWhitespace();
            if (ch != ']') break;
            pos++;
            ch = commentWhitespace();
            if (ch == ';') {
              pos++;
              ch = commentWhitespace();
            }
            if (ch != '}') break;
            pos++;
            ch = commentWhitespace();
            if (ch == ',') {
              pos++;
              ch = commentWhitespace();
            }
            if (ch != '}') break;
            pos++;
            ch = commentWhitespace();
            if (ch != ')') break;
            pos++;
            ch = commentWhitespace();
            if (ch == ';') {
              pos++;
              ch = commentWhitespace();
            }
          } else {
            break;
          }

          if (ch != '}') break;
          pos++;
          ch = commentWhitespace();
          if (ch != ')') break;

          // Search through export bindings to see if this is a star export
          StarExportBinding* curCheckBinding = &starExportStack_[0];
          while (curCheckBinding != starExportStack) {
            if (curCheckBinding->id == id) {
              addReexport(curCheckBinding->specifier, line);
              pos = revertPos;
              return;
            }
            curCheckBinding++;
          }
          return;
        }
      }
    }
    pos = revertPos;
  }

  void tryBacktrackAddStarExportBinding(const char* bPos) {
    if (bPos < source) return;
    while (bPos > source && *bPos == ' ')
      bPos--;
    if (*bPos == '=') {
      if (bPos <= source) return;
      bPos--;
      while (bPos > source && *bPos == ' ')
        bPos--;
      const char* id_end = bPos;
      bool identifierStart = false;
      while (bPos > source) {
        char ch = *bPos;
        if (!isIdentifierChar(static_cast<uint8_t>(ch)))
          break;
        identifierStart = isIdentifierStart(static_cast<uint8_t>(ch));
        bPos--;
      }
      if (identifierStart && *bPos == ' ') {
        if (starExportStack == STAR_EXPORT_STACK_END)
          return;
        starExportStack->id = std::string_view(bPos + 1, static_cast<size_t>(id_end - bPos));
        while (bPos > source && *bPos == ' ')
          bPos--;
        switch (*bPos) {
          case 'r':
            if (!readPrecedingKeyword(bPos - 1, "va"))
              return;
            break;
          case 't':
            if (!readPrecedingKeyword(bPos - 1, "le") && !readPrecedingKeyword(bPos - 1, "cons"))
              return;
            break;
          default:
            return;
        }
        starExportStack++;
      }
    }
  }

  void throwIfImportStatement() {
    const char* startPos = pos;
    pos += 6;
    char ch = commentWhitespace();
    switch (ch) {
      case '(':
        openTokenTypeStack_[openTokenDepth] = '(';
        openTokenPosStack_[openTokenDepth++] = startPos;
        return;
      case '.':
        // Check if followed by 'meta' (possibly with whitespace)
        pos++;
        ch = commentWhitespace();
        // Use str_eq4 for more efficient comparison
        if (ch == 'm' && pos + 4 <= end && matchesAt(pos + 1, end, "eta")) {
          // Check that 'meta' is not followed by an identifier character
          if (pos + 4 < end && isIdentifierChar(static_cast<uint8_t>(pos[4]))) {
            // It's something like import.metaData, not import.meta
            return;
          }
          syntaxError(lexer_error::UNEXPECTED_ESM_IMPORT_META, startPos);
        }
        return;
      default:
        if (pos == startPos + 6)
          break;
        [[fallthrough]];
      case '"':
      case '\'':
      case '{':
      case '*':
        if (openTokenDepth != 0) {
          pos--;
          return;
        }
        syntaxError(lexer_error::UNEXPECTED_ESM_IMPORT, startPos);
    }
  }

  void throwIfExportStatement() {
    const char* startPos = pos;
    pos += 6;
    const char* curPos = pos;
    char ch = commentWhitespace();
    if (pos == curPos && !isPunctuator(ch))
      return;
    syntaxError(lexer_error::UNEXPECTED_ESM_EXPORT, startPos);
  }

public:
  CJSLexer(std::vector<export_entry>& out_exports, std::vector<export_entry>& out_re_exports)
    : source(nullptr), pos(nullptr), end(nullptr), lastTokenPos(nullptr),
      templateStackDepth(0), openTokenDepth(0), templateDepth(0),
      line(1),
      lastSlashWasDivision(false), nextBraceIsClass(false),
      templateStack_{}, openTokenPosStack_{}, openTokenTypeStack_{}, openClassPosStack{},
      starExportStack_{}, starExportStack(nullptr), STAR_EXPORT_STACK_END(nullptr),
      exports(out_exports), re_exports(out_re_exports) {}

  bool parse(std::string_view file_contents) {
    source = file_contents.data();
    pos = source - 1;
    end = source + file_contents.size();
    // Initialize lastTokenPos to before source to detect start-of-input condition
    // when checking if '/' should be treated as regex vs division operator
    lastTokenPos = source - 1;

    templateStackDepth = 0;
    openTokenDepth = 0;
    templateDepth = std::numeric_limits<uint16_t>::max();
    line = 1;
    lastSlashWasDivision = false;
    starExportStack = &starExportStack_[0];
    STAR_EXPORT_STACK_END = &starExportStack_[MAX_STAR_EXPORTS - 1];
    nextBraceIsClass = false;

    char ch = '\0';

    // Handle shebang
    if (file_contents.size() >= 2 && source[0] == '#' && source[1] == '!') {
      if (file_contents.size() == 2)
        return true;
      pos += 2;
      while (pos < end) {
        ch = *pos;
        if (ch == '\n' || ch == '\r')
          break;
        pos++;
      }
      lastTokenPos = pos;  // Update lastTokenPos after shebang
    }

    while (pos++ < end) {
      ch = *pos;

      if (ch == ' ' || (ch < 14 && ch > 8)) {
        countNewline(ch);
        continue;
      }

      if (openTokenDepth == 0) {
        switch (ch) {
          case 'i':
            if (pos + 6 < end && matchesAt(pos + 1, end, "mport") && keywordStart(pos))
              throwIfImportStatement();
            lastTokenPos = pos;
            continue;
          case 'r': {
            const char* startPos = pos;
            if (tryParseRequire(RequireType::Import) && keywordStart(startPos))
              tryBacktrackAddStarExportBinding(startPos - 1);
            lastTokenPos = pos;
            continue;
          }
          case '_':
            if (pos + 23 < end && matchesAt(pos + 1, end, "interopRequireWildcard") && (keywordStart(pos) || *(pos - 1) == '.')) {
              const char* startPos = pos;
              pos += 23;
              if (*pos == '(') {
                pos++;
                openTokenTypeStack_[openTokenDepth] = '(';
                openTokenPosStack_[openTokenDepth++] = lastTokenPos;
                if (tryParseRequire(RequireType::Import) && keywordStart(startPos))
                  tryBacktrackAddStarExportBinding(startPos - 1);
              }
            } else if (pos + 8 < end && matchesAt(pos + 1, end, "_export") && (keywordStart(pos) || *(pos - 1) == '.')) {
              pos += 8;
              if (pos + 4 < end && matchesAt(pos, end, "Star"))
                pos += 4;
              if (*pos == '(') {
                openTokenTypeStack_[openTokenDepth] = '(';
                openTokenPosStack_[openTokenDepth++] = lastTokenPos;
                if (*(pos + 1) == 'r') {
                  pos++;
                  tryParseRequire(RequireType::ExportStar);
                }
              }
            }
            lastTokenPos = pos;
            continue;
        }
      }

      switch (ch) {
        case 'e':
          if (pos + 6 < end && matchesAt(pos + 1, end, "xport") && keywordStart(pos)) {
            if (pos + 7 < end && *(pos + 6) == 's')
              tryParseExportsDotAssign(false);
            else if (openTokenDepth == 0)
              throwIfExportStatement();
          }
          break;
        case 'c':
          if (keywordStart(pos) && matchesAt(pos + 1, end, "lass") && isBrOrWs(*(pos + 5)))
            nextBraceIsClass = true;
          break;
        case 'm':
          if (pos + 6 < end && matchesAt(pos + 1, end, "odule") && keywordStart(pos))
            tryParseModuleExportsDotAssign();
          break;
        case 'O':
          if (pos + 6 < end && matchesAt(pos + 1, end, "bject") && keywordStart(pos))
            tryParseObjectDefineOrKeys(openTokenDepth == 0);
          break;
        case '(':
          openTokenTypeStack_[openTokenDepth] = '(';
          openTokenPosStack_[openTokenDepth++] = lastTokenPos;
          break;
        case ')':
          if (openTokenDepth == 0) {
            syntaxError(lexer_error::UNEXPECTED_PAREN);
            return false;
          }
          openTokenDepth--;
          break;
        case '{':
          openClassPosStack[openTokenDepth] = nextBraceIsClass;
          nextBraceIsClass = false;
          openTokenTypeStack_[openTokenDepth] = '{';
          openTokenPosStack_[openTokenDepth++] = lastTokenPos;
          break;
        case '}':
          if (openTokenDepth == 0) {
            syntaxError(lexer_error::UNEXPECTED_BRACE);
            return false;
          }
          if (openTokenDepth-- == templateDepth) {
            templateDepth = templateStack_[--templateStackDepth];
            templateString();
          } else {
            if (templateDepth != std::numeric_limits<uint16_t>::max() && openTokenDepth < templateDepth) {
              syntaxError(lexer_error::UNTERMINATED_TEMPLATE_STRING);
              return false;
            }
          }
          break;
        case '\'':
        case '"':
          stringLiteral(ch);
          break;
        case '/': {
          char next_ch = pos + 1 < end ? *(pos + 1) : '\0';
          if (next_ch == '/') {
            lineComment();
            continue;
          } else if (next_ch == '*') {
            blockComment();
            continue;
          } else {
            // Check if lastTokenPos is before the source (start of input)
            bool isStartOfInput = lastTokenPos < source;
            char lastToken = isStartOfInput ? '\0' : *lastTokenPos;

            if ((isExpressionPunctuator(lastToken) &&
                 !(lastToken == '.' && lastTokenPos > source && *(lastTokenPos - 1) >= '0' && *(lastTokenPos - 1) <= '9') &&
                 !(lastToken == '+' && lastTokenPos > source && *(lastTokenPos - 1) == '+') &&
                 !(lastToken == '-' && lastTokenPos > source && *(lastTokenPos - 1) == '-')) ||
                (lastToken == ')' && isParenKeyword(openTokenPosStack_[openTokenDepth])) ||
                (lastToken == '}' && (openTokenPosStack_[openTokenDepth] < source || isExpressionTerminator(openTokenPosStack_[openTokenDepth]) || openClassPosStack[openTokenDepth])) ||
                (lastToken == '/' && lastSlashWasDivision) ||
                (!isStartOfInput && isExpressionKeyword(lastTokenPos)) ||
                !lastToken || isStartOfInput) {
              regularExpression();
              lastSlashWasDivision = false;
            } else {
              lastSlashWasDivision = true;
            }
          }
          break;
        }
        case '`':
          if (templateDepth == std::numeric_limits<uint16_t>::max() - 1) {
            syntaxError(lexer_error::TEMPLATE_NEST_OVERFLOW);
            return false;
          }
          templateString();
          break;
      }
      lastTokenPos = pos;
    }

    if (!last_error) {
      if (templateDepth != std::numeric_limits<uint16_t>::max()) {
        syntaxError(lexer_error::UNTERMINATED_TEMPLATE_STRING, end);
      } else if (openTokenDepth != 0) {
        const char open_ch = openTokenTypeStack_[openTokenDepth - 1];
        if (open_ch == '{') {
          syntaxError(lexer_error::UNTERMINATED_BRACE, end);
        } else {
          syntaxError(lexer_error::UNTERMINATED_PAREN, end);
        }
      }
    }

    if (templateDepth != std::numeric_limits<uint16_t>::max() || openTokenDepth || last_error) {
      return false;
    }

    return true;
  }
};

std::optional<lexer_analysis> parse_commonjs(std::string_view file_contents) {
  last_error.reset();
  last_error_location.reset();

  lexer_analysis result;
  CJSLexer lexer(result.exports, result.re_exports);

  if (lexer.parse(file_contents)) {
    return result;  // NRVO or implicit move applies
  }

  return std::nullopt;
}

const std::optional<lexer_error>& get_last_error() {
  return last_error;
}

const std::optional<error_location>& get_last_error_location() {
  return last_error_location;
}

}  // namespace lexer
/* end file src/parser.cpp */
/* begin file src/merve_c.cpp */
/* begin file include/merve_c.h */
/**
 * @file merve_c.h
 * @brief Includes the C definitions for merve. This is a C file, not C++.
 */
#ifndef MERVE_C_H
#define MERVE_C_H

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

/**
 * @brief Non-owning string reference.
 *
 * The data pointer is NOT null-terminated. Always use the length field.
 *
 * The data is valid as long as:
 * - The merve_analysis handle that produced it has not been freed.
 * - For string_view-backed exports: the original source buffer is alive.
 */
typedef struct {
  const char* data;
  size_t length;
} merve_string;

/**
 * @brief Opaque handle to a CommonJS parse result.
 *
 * Created by merve_parse_commonjs(). Must be freed with merve_free().
 */
typedef void* merve_analysis;

/**
 * @brief Version number components.
 */
typedef struct {
  int major;
  int minor;
  int revision;
} merve_version_components;

/**
 * @brief Source location for a parse error.
 *
 * - line and column are 1-based.
 * - column is byte-oriented.
 *
 * A zeroed location (`{0, 0}`) means the location is unavailable.
 */
typedef struct {
  uint32_t line;
  uint32_t column;
} merve_error_loc;

/* Error codes corresponding to lexer::lexer_error values. */
#define MERVE_ERROR_TODO 0
#define MERVE_ERROR_UNEXPECTED_PAREN 1
#define MERVE_ERROR_UNEXPECTED_BRACE 2
#define MERVE_ERROR_UNTERMINATED_PAREN 3
#define MERVE_ERROR_UNTERMINATED_BRACE 4
#define MERVE_ERROR_UNTERMINATED_TEMPLATE_STRING 5
#define MERVE_ERROR_UNTERMINATED_STRING_LITERAL 6
#define MERVE_ERROR_UNTERMINATED_REGEX_CHARACTER_CLASS 7
#define MERVE_ERROR_UNTERMINATED_REGEX 8
#define MERVE_ERROR_UNEXPECTED_ESM_IMPORT_META 9
#define MERVE_ERROR_UNEXPECTED_ESM_IMPORT 10
#define MERVE_ERROR_UNEXPECTED_ESM_EXPORT 11
#define MERVE_ERROR_TEMPLATE_NEST_OVERFLOW 12

#ifdef __cplusplus
extern "C" {
#endif

/**
 * Parse CommonJS source code and optionally return error location.
 *
 * The source buffer must remain valid while accessing string_view-backed
 * export names from the returned handle.
 *
 * If @p out_err is non-NULL, it is always written:
 * - On success: set to {0, 0}.
 * - On parse failure with known location: set to that location.
 * - On parse failure without available location: set to {0, 0}.
 *
 * You must call merve_free() on the returned handle when done.
 *
 * @param input   Pointer to the JavaScript source (need not be
 *                null-terminated). NULL is treated as an empty string.
 * @param length  Length of the input in bytes.
 * @param out_err Optional output pointer for parse error location.
 * @return A handle to the parse result, or NULL on out-of-memory.
 *         Use merve_is_valid() to check if parsing succeeded.
 */
#ifdef __cplusplus
merve_analysis merve_parse_commonjs(const char* input, size_t length,
                                    merve_error_loc* out_err = nullptr);
#else
merve_analysis merve_parse_commonjs(const char* input, size_t length,
                                    merve_error_loc* out_err);
#endif

/**
 * Check whether the parse result is valid (parsing succeeded).
 *
 * @param result Handle returned by merve_parse_commonjs(). NULL returns false.
 * @return true if parsing succeeded, false otherwise.
 */
bool merve_is_valid(merve_analysis result);

/**
 * Free a parse result and all associated memory.
 *
 * @param result Handle returned by merve_parse_commonjs(). NULL is a no-op.
 */
void merve_free(merve_analysis result);

/**
 * Get the number of named exports found.
 *
 * @param result A parse result handle. NULL returns 0.
 * @return Number of exports, or 0 if result is NULL or invalid.
 */
size_t merve_get_exports_count(merve_analysis result);

/**
 * Get the number of re-export module specifiers found.
 *
 * @param result A parse result handle. NULL returns 0.
 * @return Number of re-exports, or 0 if result is NULL or invalid.
 */
size_t merve_get_reexports_count(merve_analysis result);

/**
 * Get the name of an export at the given index.
 *
 * @param result A valid parse result handle.
 * @param index  Zero-based index (must be < merve_get_exports_count()).
 * @return Non-owning string reference. Returns {NULL, 0} on error.
 */
merve_string merve_get_export_name(merve_analysis result, size_t index);

/**
 * Get the 1-based source line number of an export.
 *
 * @param result A valid parse result handle.
 * @param index  Zero-based index (must be < merve_get_exports_count()).
 * @return 1-based line number, or 0 on error.
 */
uint32_t merve_get_export_line(merve_analysis result, size_t index);

/**
 * Get the module specifier of a re-export at the given index.
 *
 * @param result A valid parse result handle.
 * @param index  Zero-based index (must be < merve_get_reexports_count()).
 * @return Non-owning string reference. Returns {NULL, 0} on error.
 */
merve_string merve_get_reexport_name(merve_analysis result, size_t index);

/**
 * Get the 1-based source line number of a re-export.
 *
 * @param result A valid parse result handle.
 * @param index  Zero-based index (must be < merve_get_reexports_count()).
 * @return 1-based line number, or 0 on error.
 */
uint32_t merve_get_reexport_line(merve_analysis result, size_t index);

/**
 * Get the error code from the last merve_parse_commonjs() call.
 *
 * @return One of the MERVE_ERROR_* constants, or -1 if the last parse
 *         succeeded.
 * @note This is global state, overwritten by each merve_parse_commonjs() call.
 */
int merve_get_last_error(void);

/**
 * Get the merve library version string.
 *
 * @return Null-terminated version string (e.g. "1.0.1"). Never NULL.
 */
const char* merve_get_version(void);

/**
 * Get the merve library version as individual components.
 *
 * @return Struct with major, minor, and revision fields.
 */
merve_version_components merve_get_version_components(void);

#ifdef __cplusplus
} /* extern "C" */
#endif

#endif /* MERVE_C_H */
/* end file include/merve_c.h */

#include <new>

struct merve_analysis_impl {
  std::optional<lexer::lexer_analysis> result{};
};

static merve_string merve_string_create(const char* data, size_t length) {
  merve_string out{};
  out.data = data;
  out.length = length;
  return out;
}

static void merve_error_loc_clear(merve_error_loc* out_err) {
  if (!out_err) return;
  out_err->line = 0;
  out_err->column = 0;
}

static void merve_error_loc_set(merve_error_loc* out_err,
                                const lexer::error_location& loc) {
  if (!out_err) return;
  out_err->line = loc.line;
  out_err->column = loc.column;
}

extern "C" {

merve_analysis merve_parse_commonjs(const char* input, size_t length,
                                    merve_error_loc* out_err) {
  merve_error_loc_clear(out_err);

  merve_analysis_impl* impl = new (std::nothrow) merve_analysis_impl();
  if (!impl) return nullptr;
  if (input != nullptr) {
    impl->result = lexer::parse_commonjs(std::string_view(input, length));
  } else {
    impl->result = lexer::parse_commonjs(std::string_view("", 0));
  }

  if (!impl->result.has_value() && out_err) {
    const std::optional<lexer::error_location>& err_loc =
        lexer::get_last_error_location();
    if (err_loc.has_value()) {
      merve_error_loc_set(out_err, err_loc.value());
    }
  }

  return static_cast<merve_analysis>(impl);
}

bool merve_is_valid(merve_analysis result) {
  if (!result) return false;
  return static_cast<merve_analysis_impl*>(result)->result.has_value();
}

void merve_free(merve_analysis result) {
  if (!result) return;
  delete static_cast<merve_analysis_impl*>(result);
}

size_t merve_get_exports_count(merve_analysis result) {
  if (!result) return 0;
  merve_analysis_impl* impl = static_cast<merve_analysis_impl*>(result);
  if (!impl->result.has_value()) return 0;
  return impl->result->exports.size();
}

size_t merve_get_reexports_count(merve_analysis result) {
  if (!result) return 0;
  merve_analysis_impl* impl = static_cast<merve_analysis_impl*>(result);
  if (!impl->result.has_value()) return 0;
  return impl->result->re_exports.size();
}

merve_string merve_get_export_name(merve_analysis result, size_t index) {
  if (!result) return merve_string_create(nullptr, 0);
  merve_analysis_impl* impl = static_cast<merve_analysis_impl*>(result);
  if (!impl->result.has_value()) return merve_string_create(nullptr, 0);
  if (index >= impl->result->exports.size())
    return merve_string_create(nullptr, 0);
  std::string_view sv =
      lexer::get_string_view(impl->result->exports[index]);
  return merve_string_create(sv.data(), sv.size());
}

uint32_t merve_get_export_line(merve_analysis result, size_t index) {
  if (!result) return 0;
  merve_analysis_impl* impl = static_cast<merve_analysis_impl*>(result);
  if (!impl->result.has_value()) return 0;
  if (index >= impl->result->exports.size()) return 0;
  return impl->result->exports[index].line;
}

merve_string merve_get_reexport_name(merve_analysis result, size_t index) {
  if (!result) return merve_string_create(nullptr, 0);
  merve_analysis_impl* impl = static_cast<merve_analysis_impl*>(result);
  if (!impl->result.has_value()) return merve_string_create(nullptr, 0);
  if (index >= impl->result->re_exports.size())
    return merve_string_create(nullptr, 0);
  std::string_view sv =
      lexer::get_string_view(impl->result->re_exports[index]);
  return merve_string_create(sv.data(), sv.size());
}

uint32_t merve_get_reexport_line(merve_analysis result, size_t index) {
  if (!result) return 0;
  merve_analysis_impl* impl = static_cast<merve_analysis_impl*>(result);
  if (!impl->result.has_value()) return 0;
  if (index >= impl->result->re_exports.size()) return 0;
  return impl->result->re_exports[index].line;
}

int merve_get_last_error(void) {
  const std::optional<lexer::lexer_error>& err = lexer::get_last_error();
  if (!err.has_value()) return -1;
  return static_cast<int>(err.value());
}

const char* merve_get_version(void) { return MERVE_VERSION; }

merve_version_components merve_get_version_components(void) {
  merve_version_components vc{};
  vc.major = lexer::MERVE_VERSION_MAJOR;
  vc.minor = lexer::MERVE_VERSION_MINOR;
  vc.revision = lexer::MERVE_VERSION_REVISION;
  return vc;
}

}  /* extern "C" */
/* end file src/merve_c.cpp */