@xnoxs/flux-lang 3.2.0 → 3.2.2

package/src/lexer.js

@@ -1,518 +0,0 @@
-'use strict';
-
-// ── Token type constants ──────────────────────────────────────────────────────
-const T = {
-  // Literals
-  NUMBER: 'NUMBER', STRING: 'STRING', BOOL: 'BOOL', NULL: 'NULL', IDENT: 'IDENT',
-
-  // Keywords — declarations
-  VAR: 'VAR', VAL: 'VAL', FN: 'FN', RETURN: 'RETURN',
-
-  // Keywords — control flow
-  IF: 'IF', ELSE: 'ELSE', FOR: 'FOR', IN: 'IN',
-  WHILE: 'WHILE', BREAK: 'BREAK', CONTINUE: 'CONTINUE',
-  DO: 'DO',
-
-  // Keywords — OOP
-  CLASS: 'CLASS', EXTENDS: 'EXTENDS', SELF: 'SELF', NEW: 'NEW',
-  INTERFACE: 'INTERFACE', IMPLEMENTS: 'IMPLEMENTS',
-  PRIVATE: 'PRIVATE', PUBLIC: 'PUBLIC', PROTECTED: 'PROTECTED',
-  READONLY: 'READONLY', STATIC: 'STATIC', ABSTRACT: 'ABSTRACT',
-  OVERRIDE: 'OVERRIDE',
-
-  // Keywords — pattern matching
-  MATCH: 'MATCH', WHEN: 'WHEN',
-
-  // Keywords — modules
-  IMPORT: 'IMPORT', EXPORT: 'EXPORT', FROM: 'FROM', AS: 'AS', DEFAULT: 'DEFAULT',
-
-  // Keywords — logic
-  AND: 'AND', OR: 'OR', NOT: 'NOT',
-
-  // Keywords — async
-  ASYNC: 'ASYNC', AWAIT: 'AWAIT',
-
-  // Keywords — error handling
-  TRY: 'TRY', CATCH: 'CATCH', FINALLY: 'FINALLY', THROW: 'THROW',
-
-  // Keywords — type declarations
-  TYPEOF: 'TYPEOF', INSTANCEOF: 'INSTANCEOF', TYPE: 'TYPE',
-  ENUM: 'ENUM', SATISFIES: 'SATISFIES', IS: 'IS', CONST: 'CONST',
-
-  // Operators
-  PLUS: 'PLUS', MINUS: 'MINUS', STAR: 'STAR', SLASH: 'SLASH', PERCENT: 'PERCENT',
-  REGEX: 'REGEX',
-  STARSTAR: 'STARSTAR',
-  EQ: 'EQ', EQEQ: 'EQEQ', NEQ: 'NEQ', EQEQEQ: 'EQEQEQ', NEQEQ: 'NEQEQ',
-  LT: 'LT', LTE: 'LTE', GT: 'GT', GTE: 'GTE',
-  PLUSEQ: 'PLUSEQ', MINUSEQ: 'MINUSEQ', STAREQ: 'STAREQ', SLASHEQ: 'SLASHEQ',
-  PERCENTEQ: 'PERCENTEQ',
-  PLUSPLUS: 'PLUSPLUS',   // ++
-  MINUSMINUS: 'MINUSMINUS', // --
-  AMPERSAND: 'AMPERSAND', // &   (bitwise AND / intersection type)
-  ANDAND: 'ANDAND',       // &&  (logical AND symbol)
-  PIPEB: 'PIPEB',         // |   (bitwise OR / union type annotation)
-  OROR:  'OROR',          // ||  (logical OR symbol)
-  CARET: 'CARET',         // ^   (bitwise XOR)
-  TILDE: 'TILDE',         // ~   (bitwise NOT, unary)
-  LSHIFT: 'LSHIFT',       // <<  (left shift)
-  RSHIFT: 'RSHIFT',       // >>  (right shift)
-  ARROW: 'ARROW',         // ->   (inline fn body / lambda)
-  FATARROW: 'FATARROW',   // =>   (match arm / legacy lambda)
-  PIPE: 'PIPE',           // |>   (pipe)
-  DOTDOT: 'DOTDOT',       // ..   (range)
-  DOTDOTDOT: 'DOTDOTDOT', // ...  (spread / rest)
-  WILDCARD: 'WILDCARD',   // _
-  NULLISH: 'NULLISH',     // ??   (nullish coalescing)
-  QUESTIONDOT: 'QUESTIONDOT', // ?.  (optional chaining)
-  BANG: 'BANG',           // !   (non-null assertion postfix)
-  AT: 'AT',               // @   (decorator)
-
-  // Punctuation
-  LPAREN: 'LPAREN', RPAREN: 'RPAREN',
-  LBRACKET: 'LBRACKET', RBRACKET: 'RBRACKET',
-  LBRACE: 'LBRACE', RBRACE: 'RBRACE',
-  COMMA: 'COMMA', DOT: 'DOT', COLON: 'COLON', QUESTION: 'QUESTION',
-
-  // Structural
-  NEWLINE: 'NEWLINE', INDENT: 'INDENT', DEDENT: 'DEDENT', EOF: 'EOF',
-};
-
-// Backward compat alias used by other modules
-const TokenType = T;
-
-const KEYWORDS = {
-  var: T.VAR, val: T.VAL, fn: T.FN, return: T.RETURN,
-  if: T.IF, else: T.ELSE, for: T.FOR, in: T.IN,
-  while: T.WHILE, break: T.BREAK, continue: T.CONTINUE, do: T.DO,
-  class: T.CLASS, extends: T.EXTENDS, self: T.SELF, new: T.NEW,
-  interface: T.INTERFACE, implements: T.IMPLEMENTS,
-  private: T.PRIVATE, public: T.PUBLIC, protected: T.PROTECTED,
-  readonly: T.READONLY, static: T.STATIC, abstract: T.ABSTRACT,
-  override: T.OVERRIDE,
-  match: T.MATCH, when: T.WHEN,
-  import: T.IMPORT, export: T.EXPORT, from: T.FROM, as: T.AS, default: T.DEFAULT,
-  and: T.AND, or: T.OR, not: T.NOT,
-  async: T.ASYNC, await: T.AWAIT,
-  try: T.TRY, catch: T.CATCH, finally: T.FINALLY, throw: T.THROW,
-  typeof: T.TYPEOF, instanceof: T.INSTANCEOF, type: T.TYPE,
-  enum: T.ENUM, satisfies: T.SATISFIES, is: T.IS, const: T.CONST,
-  true: '__TRUE__', false: '__FALSE__', null: '__NULL__',
-};
-
-// ── LexerError ────────────────────────────────────────────────────────────────
-class LexerError extends Error {
-  constructor(msg, line, col) {
-    super(msg);
-    this.name = 'LexerError';
-    this.line = line;
-    this.col  = col;
-  }
-}
-
-// ── Lexer ─────────────────────────────────────────────────────────────────────
-class Lexer {
-  constructor(source) {
-    this.src         = source.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
-    this.pos         = 0;
-    this.line        = 1;
-    this.col         = 1;
-    this.tokens      = [];
-    this.indentStack = [0];
-    this.nestDepth   = 0; // inside ()[]{}  → skip NEWLINE/INDENT/DEDENT
-  }
-
-  err(msg)   { throw new LexerError(msg, this.line, this.col); }
-  ch(n = 0)  { return this.src[this.pos + n] || ''; }
-  adv() {
-    const c = this.src[this.pos++];
-    c === '\n' ? (this.line++, this.col = 1) : this.col++;
-    return c;
-  }
-  tok(type, value, l, c) {
-    this.tokens.push({ type, value: value !== undefined ? value : type,
-                       line: l || this.line, col: c || this.col });
-  }
-
-  // ── Indentation ────────────────────────────────────────────────
-  applyIndent(indent) {
-    if (this.nestDepth > 0) return;
-    const top = this.indentStack[this.indentStack.length - 1];
-    if (indent > top) {
-      this.indentStack.push(indent);
-      this.tok(T.INDENT, indent, this.line, 1);
-    } else if (indent < top) {
-      while (this.indentStack.length > 1 &&
-             this.indentStack[this.indentStack.length - 1] > indent) {
-        this.indentStack.pop();
-        this.tok(T.DEDENT, null, this.line, 1);
-      }
-      if (this.indentStack[this.indentStack.length - 1] !== indent)
-        this.err(`Inconsistent indentation (${indent} spaces)`);
-    }
-  }
-
-  // ── Backtick string: `raw multiline, no interpolation` ───────
-  // Kurung kurawal { } tidak di-interpolasi — aman untuk CSS/HTML
-  scanBacktick(l, c) {
-    this.adv(); // consume opening `
-    let s = '';
-    while (this.pos < this.src.length && this.ch() !== '`') {
-      if (this.ch() === '\\') {
-        this.adv();
-        const e = this.adv();
-        s += ({ n:'\n', t:'\t', '`':'`', '\\':'\\' }[e] || ('\\'+e));
-      } else {
-        s += this.adv();
-      }
-    }
-    if (this.ch() !== '`') this.err('Unterminated backtick string');
-    this.adv(); // consume closing `
-    // Trim leading/trailing newlines & normalize indentation
-    const lines = s.split('\n');
-    const trimmed = lines.map(ln => ln.trimEnd());
-    // Remove leading/trailing empty lines
-    while (trimmed.length && !trimmed[0].trim()) trimmed.shift();
-    while (trimmed.length && !trimmed[trimmed.length - 1].trim()) trimmed.pop();
-    // Find minimum indent of non-empty lines
-    const minIndent = trimmed.filter(ln => ln.trim()).reduce((m, ln) => {
-      const ind = ln.match(/^(\s*)/)[1].length;
-      return Math.min(m, ind);
-    }, Infinity);
-    const dedented = trimmed.map(ln => ln.slice(minIndent === Infinity ? 0 : minIndent));
-    this.tok(T.STRING, dedented.join('\n'), l, c);
-  }
-
-  // ── String: "text {expr} text" ────────────────────────────────
-  scanStr(l, c) {
-    this.adv(); // consume opening "
-    const parts = [];
-    let text = '';
-
-    while (this.pos < this.src.length && this.ch() !== '"') {
-      if (this.ch() === '\\') {
-        this.adv();
-        const e = this.adv();
-        text += ({ n:'\n', t:'\t', '"':'"', "'":"'", '\\':'\\', '{':'{', '}':'}' }[e] || ('\\'+e));
-      } else if (this.ch() === '{') {
-        parts.push({ type:'text', value:text }); text = '';
-        this.adv(); // {
-        let depth = 1, expr = '';
-        while (this.pos < this.src.length) {
-          if (this.ch() === '{') depth++;
-          if (this.ch() === '}') { depth--; if (depth === 0) break; }
-          // Unescape \" and \' inside expression (they are escapes from outer string)
-          if (this.ch() === '\\' && (this.src[this.pos+1] === '"' || this.src[this.pos+1] === "'")) {
-            this.adv(); // skip backslash
-            expr += this.adv(); // keep the quote char
-          } else {
-            expr += this.adv();
-          }
-        }
-        if (this.ch() !== '}') this.err('Unclosed string interpolation');
-        this.adv(); // }
-        parts.push({ type:'expr', value:expr.trim() });
-      } else {
-        text += this.adv();
-      }
-    }
-    if (this.ch() !== '"') this.err('Unterminated string');
-    this.adv(); // closing "
-    parts.push({ type:'text', value:text });
-
-    if (parts.some(p => p.type === 'expr'))
-      this.tok(T.STRING, { template:true, parts }, l, c);
-    else
-      this.tok(T.STRING, parts.map(p => p.value).join(''), l, c);
-  }
-
-  // ── Regex literal: /pattern/flags ─────────────────────────────
-  // Opening '/' has already been consumed by the main tokenize loop.
-  scanRegexBody(l, c) {
-    let pattern = '';
-    let inClass = false;
-    while (this.pos < this.src.length) {
-      const ch = this.ch();
-      if (ch === '\n') this.err('Unterminated regex literal');
-      if (ch === '\\') {
-        pattern += this.adv();
-        if (this.pos < this.src.length) pattern += this.adv();
-        continue;
-      }
-      if (ch === '[')  { inClass = true;  pattern += this.adv(); continue; }
-      if (ch === ']')  { inClass = false; pattern += this.adv(); continue; }
-      if (ch === '/' && !inClass) break;
-      pattern += this.adv();
-    }
-    if (this.ch() !== '/') this.err('Unterminated regex literal');
-    this.adv(); // consume closing /
-    let flags = '';
-    while (/[gimsuy]/.test(this.ch())) flags += this.adv();
-    this.tok(T.REGEX, { pattern, flags }, l, c);
-  }
-
-  // ── Block comment /* ... */ ────────────────────────────────────
-  scanBlockComment() {
-    this.adv(); this.adv(); // consume /*
-    while (this.pos < this.src.length) {
-      if (this.ch() === '*' && this.ch(1) === '/') { this.adv(); this.adv(); return; }
-      this.adv();
-    }
-    this.err('Unterminated block comment');
-  }
-
-  // ── Main scan ─────────────────────────────────────────────────
-  tokenize() {
-    let bol = true; // beginning of line
-
-    while (this.pos < this.src.length) {
-      // ─ Measure indentation at line start ──────────────────────
-      if (bol) {
-        bol = false;
-        let indent = 0;
-        while (this.ch() === ' ' || this.ch() === '\t') {
-          indent += this.ch() === '\t' ? 4 : 1;
-          this.adv();
-        }
-        // Skip blank / comment-only lines
-        if (this.ch() === '\n' || !this.ch()) {
-          if (this.ch() === '\n') { this.adv(); bol = true; }
-          continue;
-        }
-        if (this.ch() === '/' && this.ch(1) === '/') {
-          while (this.pos < this.src.length && this.ch() !== '\n') this.adv();
-          if (this.ch() === '\n') { this.adv(); bol = true; }
-          continue;
-        }
-        if (this.ch() === '/' && this.ch(1) === '*') {
-          this.scanBlockComment();
-          continue;
-        }
-        // Continuation lines: starting with |>, . or ?. — these are
-        // method-chain / pipe continuations, NOT new statements.
-        // Skip INDENT/DEDENT tracking and remove the preceding NEWLINE so
-        // the expression parser sees them as part of the same expression.
-        const isContinuation = (this.ch() === '|' && this.ch(1) === '>')
-          || this.ch() === '.'
-          || (this.ch() === '?' && this.ch(1) === '.');
-        if (isContinuation) {
-          // Remove the NEWLINE emitted at the end of the previous line
-          const last = this.tokens[this.tokens.length - 1];
-          if (last && last.type === T.NEWLINE) this.tokens.pop();
-          // Do NOT call applyIndent — no INDENT/DEDENT for continuation lines
-        } else {
-          this.applyIndent(indent);
-        }
-      }
-
-      const l = this.line, c = this.col, cur = this.ch();
-
-      // ─ Newline ────────────────────────────────────────────────
-      if (cur === '\n') {
-        this.adv(); bol = true;
-        if (this.nestDepth === 0) {
-          const last = this.tokens[this.tokens.length - 1];
-          if (last && last.type !== T.NEWLINE &&
-              last.type !== T.INDENT && last.type !== T.DEDENT)
-            this.tok(T.NEWLINE, null, l, c);
-        }
-        continue;
-      }
-
-      // ─ Whitespace ─────────────────────────────────────────────
-      if (cur === ' ' || cur === '\t') { this.adv(); continue; }
-
-      // ─ Line comment ───────────────────────────────────────────
-      if (cur === '/' && this.ch(1) === '/') {
-        while (this.pos < this.src.length && this.ch() !== '\n') this.adv();
-        continue;
-      }
-
-      // ─ Block comment ──────────────────────────────────────────
-      if (cur === '/' && this.ch(1) === '*') {
-        this.scanBlockComment();
-        continue;
-      }
-
-      // ─ Number ─────────────────────────────────────────────────
-      // Note: cur = this.ch() does NOT advance pos; this.ch() still points to cur.
-      // this.ch(1) is the character AFTER cur.
-      if (cur >= '0' && cur <= '9') {
-        // Hex: 0xFF  — cur='0', next char is 'x'
-        if (cur === '0' && (this.ch(1) === 'x' || this.ch(1) === 'X')) {
-          this.adv(); // skip '0'
-          this.adv(); // skip 'x'
-          let h = '';
-          while (/[0-9a-fA-F_]/.test(this.ch())) {
-            const c2 = this.adv();
-            if (c2 !== '_') h += c2;
-          }
-          this.tok(T.NUMBER, parseInt(h || '0', 16), l, c);
-          continue;
-        }
-        // Binary: 0b1010  — cur='0', next char is 'b'
-        if (cur === '0' && (this.ch(1) === 'b' || this.ch(1) === 'B')) {
-          this.adv(); // skip '0'
-          this.adv(); // skip 'b'
-          let b = '';
-          while (/[01_]/.test(this.ch())) {
-            const c2 = this.adv();
-            if (c2 !== '_') b += c2;
-          }
-          this.tok(T.NUMBER, parseInt(b || '0', 2), l, c);
-          continue;
-        }
-        // Decimal with optional _ separators: 1_000_000
-        // Also handles scientific notation: 1e9, 1e-9, 1.5E+10
-        // this.ch() still points to cur (first digit) — start n empty,
-        // let the while loop consume it via this.adv()
-        let n = '';
-        while (this.pos < this.src.length) {
-          if (this.ch() === '.' && this.ch(1) === '.') break;
-          if ((this.ch() >= '0' && this.ch() <= '9') || this.ch() === '.') n += this.adv();
-          else if (this.ch() === '_') { this.adv(); } // numeric separator — skip
-          else if ((this.ch() === 'e' || this.ch() === 'E') && n.length > 0) {
-            // Scientific notation exponent
-            n += this.adv(); // consume 'e' or 'E'
-            if (this.ch() === '+' || this.ch() === '-') n += this.adv(); // optional sign
-            while (this.ch() >= '0' && this.ch() <= '9') n += this.adv(); // exponent digits
-            break;
-          }
-          else break;
-        }
-        this.tok(T.NUMBER, parseFloat(n), l, c);
-        continue;
-      }
-
-      // ─ String ─────────────────────────────────────────────────
-      if (cur === '"') { this.scanStr(l, c); continue; }
-      if (cur === '`') { this.scanBacktick(l, c); continue; }
-      if (cur === "'") {
-        this.adv();
-        let s = '';
-        while (this.pos < this.src.length && this.ch() !== "'") {
-          if (this.ch() === '\\') {
-            this.adv();
-            const e = this.adv();
-            s += ({ n:'\n', t:'\t', r:'\r', "'":"'", '\\':'\\' }[e] || ('\\'+e));
-          } else {
-            s += this.adv();
-          }
-        }
-        if (this.ch() !== "'") this.err('Unterminated string');
-        this.adv(); this.tok(T.STRING, s, l, c);
-        continue;
-      }
-
-      // ─ Identifiers / keywords ─────────────────────────────────
-      if ((cur >= 'a' && cur <= 'z') || (cur >= 'A' && cur <= 'Z') || cur === '_') {
-        let word = '';
-        while (/[a-zA-Z0-9_]/.test(this.ch())) word += this.adv();
-
-        if (word === '_' && !/[a-zA-Z0-9_]/.test(this.ch())) {
-          this.tok(T.WILDCARD, '_', l, c); continue;
-        }
-        const kw = Object.prototype.hasOwnProperty.call(KEYWORDS, word) ? KEYWORDS[word] : undefined;
-        if      (kw === '__TRUE__')  this.tok(T.BOOL, true,  l, c);
-        else if (kw === '__FALSE__') this.tok(T.BOOL, false, l, c);
-        else if (kw === '__NULL__')  this.tok(T.NULL, null,  l, c);
-        else if (kw)                 this.tok(kw, word, l, c);
-        else                         this.tok(T.IDENT, word, l, c);
-        continue;
-      }
-
-      // ─ Operators & punctuation ────────────────────────────────
-      this.adv();
-      switch (cur) {
-        case '+': this.ch()==='+' ? (this.adv(), this.tok(T.PLUSPLUS,  '++',l,c))
-                : this.ch()==='=' ? (this.adv(), this.tok(T.PLUSEQ,   '+=',l,c)) : this.tok(T.PLUS,  '+',l,c); break;
-        case '-': this.ch()==='-' ? (this.adv(), this.tok(T.MINUSMINUS,'--',l,c))
-                : this.ch()==='>' ? (this.adv(), this.tok(T.ARROW,    '->',l,c))
-                : this.ch()==='=' ? (this.adv(), this.tok(T.MINUSEQ,  '-=',l,c)) : this.tok(T.MINUS,'-',l,c); break;
-        case '*': this.ch()==='*' ? (this.adv(), this.tok(T.STARSTAR, '**',l,c))
-                : this.ch()==='=' ? (this.adv(), this.tok(T.STAREQ,   '*=',l,c)) : this.tok(T.STAR, '*',l,c); break;
-        case '/':
-          if (this.ch() === '=') { this.adv(); this.tok(T.SLASHEQ, '/=', l, c); }
-          else {
-            // Context heuristic: '/' is division after a value-producing token,
-            // otherwise it starts a regex literal.
-            const _last = this.tokens[this.tokens.length - 1];
-            const _afterVal = _last && (
-              _last.type === T.IDENT  || _last.type === T.NUMBER || _last.type === T.STRING ||
-              _last.type === T.BOOL   || _last.type === T.NULL   || _last.type === T.REGEX  ||
-              _last.type === T.RPAREN || _last.type === T.RBRACKET ||
-              _last.type === T.PLUSPLUS || _last.type === T.MINUSMINUS || _last.type === T.BANG
-            );
-            if (_afterVal) this.tok(T.SLASH, '/', l, c);
-            else           this.scanRegexBody(l, c);
-          }
-          break;
-        case '%': this.ch()==='=' ? (this.adv(), this.tok(T.PERCENTEQ,'%=',l,c)) : this.tok(T.PERCENT,'%',l,c); break;
-        case '=':
-          if (this.ch()==='=' && this.ch(1)==='=') { this.adv(); this.adv(); this.tok(T.EQEQEQ,'===',l,c); }
-          else if (this.ch()==='=') { this.adv(); this.tok(T.EQEQ,'==',l,c); }
-          else if (this.ch()==='>') { this.adv(); this.tok(T.FATARROW,'=>',l,c); }
-          else { this.tok(T.EQ,'=',l,c); }
-          break;
-        case '!':
-          if (this.ch()==='=' && this.ch(1)==='=') { this.adv(); this.adv(); this.tok(T.NEQEQ,'!==',l,c); }
-          else if (this.ch()==='=') { this.adv(); this.tok(T.NEQ,'!=',l,c); }
-          else { this.tok(T.BANG,'!',l,c); }
-          break;
-        case '<': this.ch()==='<' ? (this.adv(), this.tok(T.LSHIFT,  '<<',l,c))
-                : this.ch()==='=' ? (this.adv(), this.tok(T.LTE,     '<=',l,c)) : this.tok(T.LT, '<',l,c); break;
-        case '>': this.ch()==='>' ? (this.adv(), this.tok(T.RSHIFT,  '>>',l,c))
-                : this.ch()==='=' ? (this.adv(), this.tok(T.GTE,     '>=',l,c)) : this.tok(T.GT, '>',l,c); break;
-        case '.':
-          if (this.ch() === '.' && this.ch(1) === '.') {
-            this.adv(); this.adv(); this.tok(T.DOTDOTDOT, '...', l, c);
-          } else if (this.ch() === '.') {
-            this.adv(); this.tok(T.DOTDOT, '..', l, c);
-          } else {
-            this.tok(T.DOT, '.', l, c);
-          }
-          break;
-        case '?':
-          if (this.ch() === '.') { this.adv(); this.tok(T.QUESTIONDOT, '?.', l, c); }
-          else if (this.ch() === '?') { this.adv(); this.tok(T.NULLISH, '??', l, c); }
-          else this.tok(T.QUESTION, '?', l, c);
-          break;
-        case '|':
-          if (this.ch() === '>') { this.adv(); this.tok(T.PIPE,  '|>', l, c); }
-          else if (this.ch() === '|') { this.adv(); this.tok(T.OROR, '||', l, c); }
-          else { this.tok(T.PIPEB, '|', l, c); }
-          break;
-        case '&':
-          if (this.ch() === '&') { this.adv(); this.tok(T.ANDAND,'&&',l,c); }
-          else { this.tok(T.AMPERSAND,'&',l,c); }
-          break;
-        case '^': this.tok(T.CARET,   '^',l,c); break;
-        case '~': this.tok(T.TILDE,   '~',l,c); break;
-        case '@': this.tok(T.AT,      '@',l,c); break;
-        case ';': /* optional statement separator — ignored */ break;
-        case '(': this.nestDepth++; this.tok(T.LPAREN,   '(',l,c); break;
-        case ')': this.nestDepth--; this.tok(T.RPAREN,   ')',l,c); break;
-        case '[': this.nestDepth++; this.tok(T.LBRACKET, '[',l,c); break;
-        case ']': this.nestDepth--; this.tok(T.RBRACKET, ']',l,c); break;
-        case '{': this.nestDepth++; this.tok(T.LBRACE,   '{',l,c); break;
-        case '}': this.nestDepth--; this.tok(T.RBRACE,   '}',l,c); break;
-        case ',': this.tok(T.COMMA,',',l,c);    break;
-        case ':': this.tok(T.COLON,':',l,c);    break;
-        default:  this.err(`Unknown character: '${cur}'`);
-      }
-    }
-
-    // Close any remaining open blocks
-    while (this.indentStack.length > 1) {
-      this.indentStack.pop();
-      this.tok(T.DEDENT, null, this.line, 1);
-    }
-    const last = this.tokens[this.tokens.length - 1];
-    if (last && last.type !== T.NEWLINE && last.type !== T.DEDENT)
-      this.tok(T.NEWLINE, null, this.line, this.col);
-    this.tok(T.EOF, null, this.line, this.col);
-    return this.tokens;
-  }
-}
-
-module.exports = { Lexer, T, TokenType: T };