@jalvin/compiler 1.0.0

package/dist/lexer.js

@@ -0,0 +1,677 @@
+"use strict";
+// ─────────────────────────────────────────────────────────────────────────────
+// Jalvin Lexer
+//
+// Tokenises a .jalvin source file. Key behaviours:
+//   • Automatic semicolon insertion (like Go) after certain tokens
+//     when a newline is encountered.
+//   • String templates: `"Hello $name"` and `"Hello ${expr}"`.
+//   • Triple-quoted raw strings: `"""..."""`.
+//   • Coroutine keywords: launch, async, suspend, await.
+//   • `component` keyword for UI declarations.
+//   • `Bibi` is just an identifier — treated normally by the lexer.
+// ─────────────────────────────────────────────────────────────────────────────
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lexer = void 0;
+exports.lex = lex;
+const diagnostics_js_1 = require("./diagnostics.js");
+// ---------------------------------------------------------------------------
+// Keyword map
+// ---------------------------------------------------------------------------
+const KEYWORDS = {
+    fun: "KwFun" /* TokenKind.KwFun */,
+    component: "KwComponent" /* TokenKind.KwComponent */,
+    val: "KwVal" /* TokenKind.KwVal */,
+    var: "KwVar" /* TokenKind.KwVar */,
+    class: "KwClass" /* TokenKind.KwClass */,
+    data: "KwData" /* TokenKind.KwData */,
+    sealed: "KwSealed" /* TokenKind.KwSealed */,
+    object: "KwObject" /* TokenKind.KwObject */,
+    interface: "KwInterface" /* TokenKind.KwInterface */,
+    enum: "KwEnum" /* TokenKind.KwEnum */,
+    when: "KwWhen" /* TokenKind.KwWhen */,
+    if: "KwIf" /* TokenKind.KwIf */,
+    else: "KwElse" /* TokenKind.KwElse */,
+    for: "KwFor" /* TokenKind.KwFor */,
+    while: "KwWhile" /* TokenKind.KwWhile */,
+    do: "KwDo" /* TokenKind.KwDo */,
+    return: "KwReturn" /* TokenKind.KwReturn */,
+    break: "KwBreak" /* TokenKind.KwBreak */,
+    continue: "KwContinue" /* TokenKind.KwContinue */,
+    import: "KwImport" /* TokenKind.KwImport */,
+    package: "KwPackage" /* TokenKind.KwPackage */,
+    is: "KwIs" /* TokenKind.KwIs */,
+    as: "KwAs" /* TokenKind.KwAs */,
+    in: "KwIn" /* TokenKind.KwIn */,
+    by: "KwBy" /* TokenKind.KwBy */,
+    override: "KwOverride" /* TokenKind.KwOverride */,
+    open: "KwOpen" /* TokenKind.KwOpen */,
+    abstract: "KwAbstract" /* TokenKind.KwAbstract */,
+    companion: "KwCompanion" /* TokenKind.KwCompanion */,
+    init: "KwInit" /* TokenKind.KwInit */,
+    constructor: "KwConstructor" /* TokenKind.KwConstructor */,
+    this: "KwThis" /* TokenKind.KwThis */,
+    super: "KwSuper" /* TokenKind.KwSuper */,
+    launch: "KwLaunch" /* TokenKind.KwLaunch */,
+    async: "KwAsync" /* TokenKind.KwAsync */,
+    suspend: "KwSuspend" /* TokenKind.KwSuspend */,
+    await: "KwAwait" /* TokenKind.KwAwait */,
+    throw: "KwThrow" /* TokenKind.KwThrow */,
+    try: "KwTry" /* TokenKind.KwTry */,
+    catch: "KwCatch" /* TokenKind.KwCatch */,
+    finally: "KwFinally" /* TokenKind.KwFinally */,
+    typealias: "KwTypealias" /* TokenKind.KwTypealias */,
+    operator: "KwOperator" /* TokenKind.KwOperator */,
+    infix: "KwInfix" /* TokenKind.KwInfix */,
+    inline: "KwInline" /* TokenKind.KwInline */,
+    reified: "KwReified" /* TokenKind.KwReified */,
+    external: "KwExternal" /* TokenKind.KwExternal */,
+    internal: "KwInternal" /* TokenKind.KwInternal */,
+    private: "KwPrivate" /* TokenKind.KwPrivate */,
+    protected: "KwProtected" /* TokenKind.KwProtected */,
+    public: "KwPublic" /* TokenKind.KwPublic */,
+    tailrec: "KwTailrec" /* TokenKind.KwTailrec */,
+    const: "KwConst" /* TokenKind.KwConst */,
+    lateinit: "KwLateinit" /* TokenKind.KwLateinit */,
+    final: "KwFinal" /* TokenKind.KwFinal */,
+    true: "BooleanLiteral" /* TokenKind.BooleanLiteral */,
+    false: "BooleanLiteral" /* TokenKind.BooleanLiteral */,
+    null: "NullLiteral" /* TokenKind.NullLiteral */,
+};
+/** Tokens after which a newline triggers automatic semicolon insertion */
+const ASI_SET = new Set([
+    "Identifier" /* TokenKind.Identifier */,
+    "IntLiteral" /* TokenKind.IntLiteral */,
+    "LongLiteral" /* TokenKind.LongLiteral */,
+    "FloatLiteral" /* TokenKind.FloatLiteral */,
+    "DoubleLiteral" /* TokenKind.DoubleLiteral */,
+    "BooleanLiteral" /* TokenKind.BooleanLiteral */,
+    "NullLiteral" /* TokenKind.NullLiteral */,
+    "StringLiteral" /* TokenKind.StringLiteral */,
+    "RawStringLiteral" /* TokenKind.RawStringLiteral */,
+    "StringTemplateEnd" /* TokenKind.StringTemplateEnd */,
+    "RParen" /* TokenKind.RParen */,
+    "RBrace" /* TokenKind.RBrace */,
+    "RBracket" /* TokenKind.RBracket */,
+    "KwReturn" /* TokenKind.KwReturn */,
+    "KwBreak" /* TokenKind.KwBreak */,
+    "KwContinue" /* TokenKind.KwContinue */,
+    "KwThis" /* TokenKind.KwThis */,
+    "KwSuper" /* TokenKind.KwSuper */,
+    "BangBang" /* TokenKind.BangBang */,
+]);
+// ---------------------------------------------------------------------------
+// Lexer
+// ---------------------------------------------------------------------------
+class Lexer {
+    pos = 0;
+    line = 0;
+    col = 0;
+    src;
+    file;
+    diag;
+    constructor(src, file, diag) {
+        this.src = src;
+        this.file = file;
+        this.diag = diag;
+    }
+    tokenize() {
+        const tokens = [];
+        let prevKind = null;
+        while (this.pos < this.src.length) {
+            const ch = this.src[this.pos];
+            // ── Whitespace ───────────────────────────────────────────────────────
+            if (ch === " " || ch === "\t" || ch === "\r") {
+                this.advance();
+                continue;
+            }
+            // ── Newline → potential semicolon ────────────────────────────────────
+            if (ch === "\n") {
+                if (prevKind !== null && ASI_SET.has(prevKind)) {
+                    const span = this.spanAt(this.pos, this.pos);
+                    tokens.push({ kind: "Semicolon" /* TokenKind.Semicolon */, span, text: "\n" });
+                    prevKind = "Semicolon" /* TokenKind.Semicolon */;
+                }
+                this.advance();
+                continue;
+            }
+            // ── Comments ─────────────────────────────────────────────────────────
+            if (ch === "/" && this.peek(1) === "/") {
+                this.skipLineComment();
+                continue;
+            }
+            if (ch === "/" && this.peek(1) === "*") {
+                this.skipBlockComment();
+                continue;
+            }
+            const tok = this.nextToken();
+            if (tok) {
+                tokens.push(tok);
+                prevKind = tok.kind;
+            }
+        }
+        // EOF
+        tokens.push({
+            kind: "EOF" /* TokenKind.EOF */,
+            span: this.spanAt(this.pos, this.pos),
+            text: "",
+        });
+        return tokens;
+    }
+    // ── Token dispatch ─────────────────────────────────────────────────────────
+    nextToken() {
+        const start = this.pos;
+        const ch = this.src[start];
+        if (ch === undefined)
+            return null;
+        // Identifiers & keywords
+        if (isIdentStart(ch))
+            return this.lexIdentOrKeyword();
+        // Numbers
+        if (isDigit(ch))
+            return this.lexNumber();
+        // Strings
+        if (ch === '"') {
+            if (this.peek(1) === '"' && this.peek(2) === '"') {
+                return this.lexRawString();
+            }
+            return this.lexString();
+        }
+        // Operators & punctuation
+        return this.lexSymbol();
+    }
+    // ── Identifier / keyword ───────────────────────────────────────────────────
+    lexIdentOrKeyword() {
+        const start = this.pos;
+        const startLine = this.line;
+        const startCol = this.col;
+        while (this.pos < this.src.length && isIdentContinue(this.src[this.pos])) {
+            this.advance();
+        }
+        const text = this.src.slice(start, this.pos);
+        const span = this.makeSpan(start, startLine, startCol);
+        if (text === "_") {
+            return { kind: "Underscore" /* TokenKind.Underscore */, span, text };
+        }
+        const kwKind = KEYWORDS[text];
+        if (kwKind !== undefined) {
+            switch (kwKind) {
+                case "BooleanLiteral" /* TokenKind.BooleanLiteral */:
+                    return { kind: kwKind, span, text, value: text === "true" };
+                case "NullLiteral" /* TokenKind.NullLiteral */:
+                    return { kind: kwKind, span, text, value: null };
+                default:
+                    return { kind: kwKind, span, text };
+            }
+        }
+        return { kind: "Identifier" /* TokenKind.Identifier */, span, text };
+    }
+    // ── Number literals ────────────────────────────────────────────────────────
+    lexNumber() {
+        const start = this.pos;
+        const startLine = this.line;
+        const startCol = this.col;
+        let isHex = false;
+        let isBinary = false;
+        if (this.src[this.pos] === "0") {
+            const next = this.peek(1);
+            if (next === "x" || next === "X") {
+                this.advance();
+                this.advance();
+                isHex = true;
+            }
+            else if (next === "b" || next === "B") {
+                this.advance();
+                this.advance();
+                isBinary = true;
+            }
+        }
+        if (isHex) {
+            while (this.pos < this.src.length && isHexDigit(this.src[this.pos])) {
+                this.advance();
+            }
+        }
+        else if (isBinary) {
+            while (this.pos < this.src.length && (this.src[this.pos] === "0" || this.src[this.pos] === "1")) {
+                this.advance();
+            }
+        }
+        else {
+            while (this.pos < this.src.length && (isDigit(this.src[this.pos]) || this.src[this.pos] === "_")) {
+                this.advance();
+            }
+        }
+        let isFloat = false;
+        let isDouble = false;
+        if (!isHex && !isBinary) {
+            if (this.src[this.pos] === "." && isDigit(this.peek(1) ?? "")) {
+                isDouble = true;
+                this.advance(); // consume '.'
+                while (this.pos < this.src.length && (isDigit(this.src[this.pos]) || this.src[this.pos] === "_")) {
+                    this.advance();
+                }
+            }
+            // Exponent
+            if (this.src[this.pos] === "e" || this.src[this.pos] === "E") {
+                isDouble = true;
+                this.advance();
+                if (this.src[this.pos] === "+" || this.src[this.pos] === "-")
+                    this.advance();
+                while (this.pos < this.src.length && isDigit(this.src[this.pos]))
+                    this.advance();
+            }
+        }
+        let suffix = "";
+        const sc = this.src[this.pos];
+        if (sc === "L" || sc === "l") {
+            suffix = "L";
+            this.advance();
+        }
+        else if (sc === "f" || sc === "F") {
+            suffix = "f";
+            isFloat = true;
+            this.advance();
+        }
+        else if (sc === "d" || sc === "D") {
+            suffix = "d";
+            isDouble = true;
+            this.advance();
+        }
+        const text = this.src.slice(start, this.pos);
+        const span = this.makeSpan(start, startLine, startCol);
+        const clean = text.replace(/_/g, "").replace(/[LlfFdD]$/, "");
+        if (suffix === "L") {
+            let val;
+            try {
+                val = BigInt(clean);
+            }
+            catch {
+                this.diag.error(span, diagnostics_js_1.E_INVALID_NUMBER_LITERAL, `Invalid long literal: ${text}`);
+                val = 0n;
+            }
+            return { kind: "LongLiteral" /* TokenKind.LongLiteral */, span, text, value: val };
+        }
+        if (isFloat) {
+            return { kind: "FloatLiteral" /* TokenKind.FloatLiteral */, span, text, value: parseFloat(clean) };
+        }
+        if (isDouble || text.includes(".") || text.toLowerCase().includes("e")) {
+            return { kind: "DoubleLiteral" /* TokenKind.DoubleLiteral */, span, text, value: parseFloat(clean) };
+        }
+        const intVal = isHex
+            ? parseInt(clean.slice(2), 16)
+            : isBinary
+                ? parseInt(clean.slice(2), 2)
+                : parseInt(clean, 10);
+        if (isNaN(intVal)) {
+            this.diag.error(span, diagnostics_js_1.E_INVALID_NUMBER_LITERAL, `Invalid integer literal: ${text}`);
+            return { kind: "IntLiteral" /* TokenKind.IntLiteral */, span, text, value: 0 };
+        }
+        return { kind: "IntLiteral" /* TokenKind.IntLiteral */, span, text, value: intVal };
+    }
+    // ── String literals ────────────────────────────────────────────────────────
+    lexString() {
+        const start = this.pos;
+        const startLine = this.line;
+        const startCol = this.col;
+        this.advance(); // consume opening "
+        let value = "";
+        let isTemplate = false;
+        let closed = false;
+        const templateParts = [];
+        while (this.pos < this.src.length) {
+            const ch = this.src[this.pos];
+            if (ch === "\"") {
+                this.advance();
+                closed = true;
+                break;
+            }
+            if (ch === "\n") {
+                break;
+            }
+            if (ch === "$") {
+                if (this.peek(1) === "{") {
+                    isTemplate = true;
+                    templateParts.push(value);
+                    value = "";
+                    // We just return the string fragment; the parser handles interpolation
+                    // by re-lexing nested expressions. For simplicity we encode templates
+                    // into a single StringTemplateExpr token with the raw text.
+                    // Consume ${ block
+                    this.advance();
+                    this.advance();
+                    let depth = 1;
+                    let exprText = "";
+                    while (this.pos < this.src.length && depth > 0) {
+                        const ec = this.src[this.pos];
+                        if (ec === "{")
+                            depth++;
+                        else if (ec === "}") {
+                            depth--;
+                            if (depth === 0) {
+                                this.advance();
+                                break;
+                            }
+                        }
+                        exprText += ec;
+                        this.advance();
+                    }
+                    templateParts.push(`\${${exprText}}`);
+                }
+                else if (isIdentStart(this.peek(1) ?? "")) {
+                    isTemplate = true;
+                    templateParts.push(value);
+                    value = "";
+                    this.advance(); // $
+                    const identStart = this.pos;
+                    while (this.pos < this.src.length && isIdentContinue(this.src[this.pos]))
+                        this.advance();
+                    const ident = this.src.slice(identStart, this.pos);
+                    templateParts.push(`\${${ident}}`);
+                }
+                else {
+                    value += ch;
+                    this.advance();
+                }
+                continue;
+            }
+            if (ch === "\\") {
+                const span = this.makeSpan(this.pos, this.line, this.col);
+                value += this.parseEscape(span);
+                continue;
+            }
+            value += ch;
+            this.advance();
+        }
+        if (!closed) {
+            const span = this.makeSpan(start, startLine, startCol);
+            this.diag.error(span, diagnostics_js_1.E_UNTERMINATED_STRING, "Unterminated string literal");
+        }
+        const text = this.src.slice(start, this.pos);
+        const span = this.makeSpan(start, startLine, startCol);
+        if (isTemplate) {
+            const raw = templateParts.join("") + value;
+            return { kind: "StringLiteral" /* TokenKind.StringLiteral */, span, text, value: raw };
+        }
+        return { kind: "StringLiteral" /* TokenKind.StringLiteral */, span, text, value };
+    }
+    lexRawString() {
+        const start = this.pos;
+        const startLine = this.line;
+        const startCol = this.col;
+        this.advance();
+        this.advance();
+        this.advance(); // consume """
+        let value = "";
+        let closed = false;
+        while (this.pos < this.src.length) {
+            if (this.src[this.pos] === '"' && this.peek(1) === '"' && this.peek(2) === '"') {
+                this.advance();
+                this.advance();
+                this.advance();
+                closed = true;
+                break;
+            }
+            const c = this.src[this.pos];
+            if (c === "\n")
+                this.line++; // no col tracking in raw strings
+            value += c;
+            this.advance();
+        }
+        if (!closed) {
+            const span = this.makeSpan(start, startLine, startCol);
+            this.diag.error(span, diagnostics_js_1.E_UNTERMINATED_STRING, "Unterminated triple-quoted string");
+        }
+        const text = this.src.slice(start, this.pos);
+        const span = this.makeSpan(start, startLine, startCol);
+        return { kind: "RawStringLiteral" /* TokenKind.RawStringLiteral */, span, text, value };
+    }
+    parseEscape(span) {
+        this.advance(); // consume backslash
+        const ec = this.src[this.pos];
+        this.advance();
+        switch (ec) {
+            case "n": return "\n";
+            case "t": return "\t";
+            case "r": return "\r";
+            case "\\": return "\\";
+            case '"': return '"';
+            case "'": return "'";
+            case "0": return "\0";
+            case "$": return "$";
+            case "u": {
+                if (this.src[this.pos] === "{") {
+                    this.advance(); // {
+                    let hex = "";
+                    while (this.pos < this.src.length && this.src[this.pos] !== "}") {
+                        hex += this.src[this.pos];
+                        this.advance();
+                    }
+                    this.advance(); // }
+                    const cp = parseInt(hex, 16);
+                    if (isNaN(cp)) {
+                        this.diag.error(span, diagnostics_js_1.E_INVALID_ESCAPE, `Invalid unicode escape: \\u{${hex}}`);
+                        return "";
+                    }
+                    return String.fromCodePoint(cp);
+                }
+                // \uXXXX
+                let hex = "";
+                for (let i = 0; i < 4; i++) {
+                    hex += this.src[this.pos] ?? "";
+                    this.advance();
+                }
+                const cp = parseInt(hex, 16);
+                if (isNaN(cp)) {
+                    this.diag.error(span, diagnostics_js_1.E_INVALID_ESCAPE, `Invalid unicode escape: \\u${hex}`);
+                    return "";
+                }
+                return String.fromCharCode(cp);
+            }
+            default:
+                this.diag.error(span, diagnostics_js_1.E_INVALID_ESCAPE, `Unknown escape sequence: \\${ec ?? ""}`);
+                return ec ?? "";
+        }
+    }
+    // ── Symbols & operators ────────────────────────────────────────────────────
+    lexSymbol() {
+        const start = this.pos;
+        const startLine = this.line;
+        const startCol = this.col;
+        const ch = this.src[this.pos];
+        const next = this.peek(1);
+        const next2 = this.peek(2);
+        const mk = (kind, len) => {
+            const text = this.src.slice(start, start + len);
+            for (let i = 0; i < len; i++)
+                this.advance();
+            return { kind, span: this.makeSpan(start, startLine, startCol), text };
+        };
+        switch (ch) {
+            case "+":
+                if (next === "+")
+                    return mk("PlusPlus" /* TokenKind.PlusPlus */, 2);
+                if (next === "=")
+                    return mk("PlusEq" /* TokenKind.PlusEq */, 2);
+                return mk("Plus" /* TokenKind.Plus */, 1);
+            case "-":
+                if (next === "-")
+                    return mk("MinusMinus" /* TokenKind.MinusMinus */, 2);
+                if (next === "=")
+                    return mk("MinusEq" /* TokenKind.MinusEq */, 2);
+                if (next === ">")
+                    return mk("Arrow" /* TokenKind.Arrow */, 2);
+                return mk("Minus" /* TokenKind.Minus */, 1);
+            case "*":
+                if (next === "=")
+                    return mk("StarEq" /* TokenKind.StarEq */, 2);
+                return mk("Star" /* TokenKind.Star */, 1);
+            case "/":
+                if (next === "=")
+                    return mk("SlashEq" /* TokenKind.SlashEq */, 2);
+                return mk("Slash" /* TokenKind.Slash */, 1);
+            case "%":
+                if (next === "=")
+                    return mk("PercentEq" /* TokenKind.PercentEq */, 2);
+                return mk("Percent" /* TokenKind.Percent */, 1);
+            case "=":
+                if (next === "=" && next2 === "=")
+                    return mk("EqEqEq" /* TokenKind.EqEqEq */, 3);
+                if (next === "=")
+                    return mk("EqEq" /* TokenKind.EqEq */, 2);
+                if (next === ">")
+                    return mk("FatArrow" /* TokenKind.FatArrow */, 2);
+                return mk("Eq" /* TokenKind.Eq */, 1);
+            case "!":
+                if (next === "=" && next2 === "=")
+                    return mk("BangEqEq" /* TokenKind.BangEqEq */, 3);
+                if (next === "=")
+                    return mk("BangEq" /* TokenKind.BangEq */, 2);
+                if (next === "!")
+                    return mk("BangBang" /* TokenKind.BangBang */, 2);
+                return mk("Bang" /* TokenKind.Bang */, 1);
+            case "<":
+                if (next === "=")
+                    return mk("LtEq" /* TokenKind.LtEq */, 2);
+                return mk("Lt" /* TokenKind.Lt */, 1);
+            case ">":
+                if (next === "=")
+                    return mk("GtEq" /* TokenKind.GtEq */, 2);
+                return mk("Gt" /* TokenKind.Gt */, 1);
+            case "&":
+                if (next === "&")
+                    return mk("AmpAmp" /* TokenKind.AmpAmp */, 2);
+                return mk("Amp" /* TokenKind.Amp */, 1);
+            case "|":
+                if (next === "|")
+                    return mk("PipePipe" /* TokenKind.PipePipe */, 2);
+                return mk("Pipe" /* TokenKind.Pipe */, 1);
+            case "?":
+                if (next === ":")
+                    return mk("QuestionColon" /* TokenKind.QuestionColon */, 2);
+                if (next === ".")
+                    return mk("QuestionDot" /* TokenKind.QuestionDot */, 2);
+                return mk("Question" /* TokenKind.Question */, 1);
+            case ".":
+                if (next === "." && next2 === "<")
+                    return mk("DotDotLt" /* TokenKind.DotDotLt */, 3);
+                if (next === ".")
+                    return mk("DotDot" /* TokenKind.DotDot */, 2);
+                return mk("Dot" /* TokenKind.Dot */, 1);
+            case ":":
+                if (next === ":")
+                    return mk("ColonColon" /* TokenKind.ColonColon */, 2);
+                return mk("Colon" /* TokenKind.Colon */, 1);
+            case "{": return mk("LBrace" /* TokenKind.LBrace */, 1);
+            case "}": return mk("RBrace" /* TokenKind.RBrace */, 1);
+            case "(": return mk("LParen" /* TokenKind.LParen */, 1);
+            case ")": return mk("RParen" /* TokenKind.RParen */, 1);
+            case "[": return mk("LBracket" /* TokenKind.LBracket */, 1);
+            case "]": return mk("RBracket" /* TokenKind.RBracket */, 1);
+            case ",": return mk("Comma" /* TokenKind.Comma */, 1);
+            case ";": return mk("Semicolon" /* TokenKind.Semicolon */, 1);
+            case "@": return mk("At" /* TokenKind.At */, 1);
+            case "#": return mk("Hash" /* TokenKind.Hash */, 1);
+            case "^": return mk("Caret" /* TokenKind.Caret */, 1);
+            case "~": return mk("Tilde" /* TokenKind.Tilde */, 1);
+            default: {
+                const span = this.makeSpan(start, startLine, startCol);
+                this.diag.error(span, diagnostics_js_1.E_UNEXPECTED_CHAR, `Unexpected character: '${ch}'`);
+                this.advance();
+                return null;
+            }
+        }
+    }
+    // ── Comment skipping ───────────────────────────────────────────────────────
+    skipLineComment() {
+        while (this.pos < this.src.length && this.src[this.pos] !== "\n") {
+            this.advance();
+        }
+    }
+    skipBlockComment() {
+        const start = this.pos;
+        const startLine = this.line;
+        const startCol = this.col;
+        this.advance();
+        this.advance(); // /*
+        let depth = 1;
+        while (this.pos < this.src.length) {
+            const c = this.src[this.pos];
+            if (c === "/" && this.peek(1) === "*") {
+                depth++;
+                this.advance();
+                this.advance();
+                continue;
+            }
+            if (c === "*" && this.peek(1) === "/") {
+                depth--;
+                this.advance();
+                this.advance();
+                if (depth === 0)
+                    return;
+                continue;
+            }
+            this.advance();
+        }
+        const span = this.makeSpan(start, startLine, startCol);
+        this.diag.error(span, diagnostics_js_1.E_UNTERMINATED_BLOCK_COMMENT, "Unterminated block comment");
+    }
+    // ── Utilities ──────────────────────────────────────────────────────────────
+    advance() {
+        if (this.src[this.pos] === "\n") {
+            this.line++;
+            this.col = 0;
+        }
+        else {
+            this.col++;
+        }
+        this.pos++;
+    }
+    peek(offset) {
+        return this.src[this.pos + offset];
+    }
+    spanAt(startPos, endPos) {
+        return {
+            file: this.file,
+            startLine: this.line,
+            startCol: this.col,
+            endLine: this.line,
+            endCol: this.col,
+            startOffset: startPos,
+            endOffset: endPos,
+        };
+    }
+    makeSpan(startOffset, startLine, startCol) {
+        return {
+            file: this.file,
+            startLine,
+            startCol,
+            endLine: this.line,
+            endCol: this.col,
+            startOffset,
+            endOffset: this.pos,
+        };
+    }
+}
+exports.Lexer = Lexer;
+// ---------------------------------------------------------------------------
+// Character classification helpers
+// ---------------------------------------------------------------------------
+function isIdentStart(ch) {
+    return /[a-zA-Z_]/.test(ch);
+}
+function isIdentContinue(ch) {
+    return /[a-zA-Z0-9_]/.test(ch);
+}
+function isDigit(ch) {
+    return ch >= "0" && ch <= "9";
+}
+function isHexDigit(ch) {
+    return (ch >= "0" && ch <= "9") || (ch >= "a" && ch <= "f") || (ch >= "A" && ch <= "F");
+}
+// ---------------------------------------------------------------------------
+// Public helper: lex a source file
+// ---------------------------------------------------------------------------
+function lex(src, file, diag) {
+    return new Lexer(src, file, diag).tokenize();
+}
+//# sourceMappingURL=lexer.js.map