lt-script 1.0.0

package/dist/compiler/lexer/Lexer.d.ts

@@ -0,0 +1,31 @@
+import { Token } from './Token.js';
+/**
+ * LT Language Lexer
+ * Converts source code into tokens
+ */
+export declare class Lexer {
+    private source;
+    private tokens;
+    private pos;
+    private line;
+    private column;
+    constructor(source: string);
+    tokenize(): Token[];
+    private scanToken;
+    private readOperator;
+    private readLongString;
+    private readString;
+    private readNumber;
+    private readIdentifier;
+    private skipWhitespace;
+    private skipComment;
+    private addToken;
+    private current;
+    private peek;
+    private peekNext;
+    private advance;
+    private isEOF;
+    private isDigit;
+    private isAlpha;
+    private isAlphaNumeric;
+}

package/dist/compiler/lexer/Lexer.js

@@ -0,0 +1,322 @@
+import { TokenType, KEYWORDS } from './Token.js';
+/**
+ * LT Language Lexer
+ * Converts source code into tokens
+ */
+export class Lexer {
+    source;
+    tokens = [];
+    pos = 0;
+    line = 1;
+    column = 1;
+    constructor(source) {
+        this.source = source;
+    }
+    tokenize() {
+        while (!this.isEOF()) {
+            this.scanToken();
+        }
+        this.addToken(TokenType.EOF, '');
+        return this.tokens;
+    }
+    scanToken() {
+        this.skipWhitespace();
+        if (this.isEOF())
+            return;
+        const ch = this.current();
+        // Comments
+        if ((ch === '-' && this.peek() === '-') || (ch === '/' && this.peek() === '/')) {
+            this.skipComment();
+            return;
+        }
+        // String interpolation / Quotes
+        if (ch === '"' || ch === "'") {
+            this.readString(ch);
+            return;
+        }
+        // Lua Long Strings [[ ... ]]
+        if (ch === '[' && this.peek() === '[') {
+            this.readLongString();
+            return;
+        }
+        // Numbers
+        if (this.isDigit(ch)) {
+            this.readNumber();
+            return;
+        }
+        // Identifiers & Keywords
+        if (this.isAlpha(ch)) {
+            this.readIdentifier();
+            return;
+        }
+        // Operators & Delimiters
+        this.readOperator();
+    }
+    readOperator() {
+        const ch = this.current();
+        const next = this.peek();
+        // Three-char operators
+        if (ch === '.' && next === '.' && this.peekNext() === '=') {
+            this.advance();
+            this.advance();
+            this.advance();
+            this.addToken(TokenType.CONCAT_EQ, '..=');
+            return;
+        }
+        // Spread Operator ...
+        const threeChar = ch + next + this.peekNext();
+        if (threeChar === '...') {
+            this.advance();
+            this.advance();
+            this.advance();
+            this.addToken(TokenType.SPREAD, '...');
+            return;
+        }
+        // Two-char operators
+        const twoChar = ch + next;
+        const twoCharMap = {
+            '=>': TokenType.ARROW,
+            '?.': TokenType.OPT_DOT,
+            '?[': TokenType.OPT_BRACKET,
+            '??': TokenType.NULL_COALESCE,
+            '==': TokenType.EQ,
+            '~=': TokenType.NEQ,
+            '!=': TokenType.NEQ,
+            '<=': TokenType.LTE,
+            '>=': TokenType.GTE,
+            '..': TokenType.CONCAT,
+            '+=': TokenType.PLUS_EQ,
+            '++': TokenType.PLUS_PLUS,
+            '-=': TokenType.MINUS_EQ,
+            '*=': TokenType.STAR_EQ,
+            '/=': TokenType.SLASH_EQ,
+            '%=': TokenType.PERCENT_EQ,
+        };
+        if (twoCharMap[twoChar]) {
+            this.advance();
+            this.advance();
+            this.addToken(twoCharMap[twoChar], twoChar);
+            return;
+        }
+        // Single-char operators
+        const singleCharMap = {
+            '+': TokenType.PLUS,
+            '-': TokenType.MINUS,
+            '*': TokenType.STAR,
+            '/': TokenType.SLASH,
+            '%': TokenType.PERCENT,
+            '^': TokenType.CARET,
+            '#': TokenType.HASH,
+            '=': TokenType.EQUALS,
+            '<': TokenType.LT,
+            '>': TokenType.GT,
+            '(': TokenType.LPAREN,
+            ')': TokenType.RPAREN,
+            '{': TokenType.LBRACE,
+            '}': TokenType.RBRACE,
+            '[': TokenType.LBRACKET,
+            ']': TokenType.RBRACKET,
+            ',': TokenType.COMMA,
+            '.': TokenType.DOT,
+            ':': TokenType.COLON,
+            ';': TokenType.SEMICOLON,
+            '?': TokenType.QUESTION,
+        };
+        if (singleCharMap[ch]) {
+            this.advance();
+            this.addToken(singleCharMap[ch], ch);
+            return;
+        }
+        // Backticks ` (Used in SQL)
+        if (ch === '`') {
+            this.advance();
+            this.addToken(TokenType.IDENTIFIER, '`'); // Treat backtick as identifier for now or new token
+            return;
+        }
+        // Ampersand & and Pipe | (Commonly requested for bitwise or just skipped)
+        if (ch === '&' || ch === '|') {
+            this.advance();
+            this.addToken(TokenType.IDENTIFIER, ch);
+            return;
+        }
+        // Unknown character
+        throw new Error(`Unexpected character '${ch}' at ${this.line}:${this.column}`);
+    }
+    readLongString() {
+        const startLine = this.line;
+        const startCol = this.column;
+        this.advance();
+        this.advance(); // [[
+        let value = '';
+        while (!this.isEOF()) {
+            if (this.current() === ']' && this.peek() === ']') {
+                this.advance();
+                this.advance();
+                this.addToken(TokenType.LONG_STRING, value);
+                return;
+            }
+            if (this.current() === '\n') {
+                value += '\n';
+                this.line++;
+                this.column = 1;
+                this.pos++;
+            }
+            else {
+                value += this.current();
+                this.advance();
+            }
+        }
+        throw new Error(`Unterminated long string starting at ${startLine}:${startCol}`);
+    }
+    readString(quote) {
+        const startCol = this.column;
+        this.advance(); // opening quote
+        let value = '';
+        while (!this.isEOF() && this.current() !== quote) {
+            if (this.current() === '\\') {
+                this.advance();
+                const escaped = this.current();
+                switch (escaped) {
+                    case 'n':
+                        value += '\n';
+                        break;
+                    case 't':
+                        value += '\t';
+                        break;
+                    case 'r':
+                        value += '\r';
+                        break;
+                    case '\\':
+                        value += '\\';
+                        break;
+                    default: value += escaped;
+                }
+            }
+            else {
+                value += this.current();
+            }
+            this.advance();
+        }
+        if (this.isEOF()) {
+            throw new Error(`Unterminated string at ${this.line}:${startCol}`);
+        }
+        this.advance(); // closing quote
+        this.addToken(TokenType.STRING, value, quote);
+    }
+    readNumber() {
+        let value = '';
+        while (!this.isEOF() && (this.isDigit(this.current()) || this.current() === '.')) {
+            if (this.current() === '.' && this.peek() === '.')
+                break; // range operator
+            value += this.current();
+            this.advance();
+        }
+        this.addToken(TokenType.NUMBER, value);
+    }
+    readIdentifier() {
+        let value = '';
+        while (!this.isEOF() && this.isAlphaNumeric(this.current())) {
+            value += this.current();
+            this.advance();
+        }
+        const type = KEYWORDS[value] ?? TokenType.IDENTIFIER;
+        this.addToken(type, value);
+    }
+    skipWhitespace() {
+        while (!this.isEOF()) {
+            const ch = this.current();
+            if (ch === ' ' || ch === '\t' || ch === '\r') {
+                this.advance();
+            }
+            else if (ch === '\n') {
+                this.line++;
+                this.column = 1;
+                this.pos++;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    skipComment() {
+        const ch = this.current();
+        const next = this.peek();
+        // Multiline comment /* ... */
+        if (ch === '/' && next === '*') {
+            this.advance();
+            this.advance();
+            while (!this.isEOF()) {
+                if (this.current() === '*' && this.peek() === '/') {
+                    this.advance();
+                    this.advance();
+                    return;
+                }
+                if (this.current() === '\n') {
+                    this.line++;
+                    this.column = 1;
+                    this.pos++;
+                }
+                else {
+                    this.advance();
+                }
+            }
+            return;
+        }
+        // Lua Multiline comment --[[ ... ]]
+        if (ch === '-' && next === '-' && this.peekNext() === '[' && this.source[this.pos + 3] === '[') {
+            this.advance();
+            this.advance();
+            this.advance();
+            this.advance(); // --[[
+            while (!this.isEOF()) {
+                if (this.current() === ']' && this.peek() === ']') {
+                    this.advance();
+                    this.advance();
+                    return;
+                }
+                if (this.current() === '\n') {
+                    this.line++;
+                    this.column = 1;
+                    this.pos++;
+                }
+                else {
+                    this.advance();
+                }
+            }
+            return;
+        }
+        // Skip until end of line
+        while (!this.isEOF() && this.current() !== '\n') {
+            this.advance();
+        }
+    }
+    addToken(type, value, quote) {
+        this.tokens.push({ type, value, line: this.line, column: this.column, quote });
+    }
+    current() {
+        return this.source[this.pos] ?? '\0';
+    }
+    peek() {
+        return this.source[this.pos + 1] ?? '\0';
+    }
+    peekNext() {
+        return this.source[this.pos + 2] ?? '\0';
+    }
+    advance() {
+        this.pos++;
+        this.column++;
+    }
+    isEOF() {
+        return this.pos >= this.source.length;
+    }
+    isDigit(ch) {
+        return ch >= '0' && ch <= '9';
+    }
+    isAlpha(ch) {
+        const c = ch.toLowerCase();
+        return (c >= 'a' && c <= 'z') || ch === '_';
+    }
+    isAlphaNumeric(ch) {
+        return this.isAlpha(ch) || this.isDigit(ch);
+    }
+}

package/dist/compiler/lexer/Token.d.ts

@@ -0,0 +1,109 @@
+/**
+ * LT Language Token Types
+ * All tokens recognized by the LT compiler
+ */
+export declare enum TokenType {
+    NUMBER = "NUMBER",
+    STRING = "STRING",
+    LONG_STRING = "LONG_STRING",
+    BOOLEAN = "BOOLEAN",
+    NIL = "NIL",
+    IDENTIFIER = "IDENTIFIER",
+    VAR = "VAR",// global
+    LET = "LET",// local
+    LOCAL = "LOCAL",// local (Lua compatibility)
+    CONST = "CONST",// local <const>
+    IF = "IF",
+    THEN = "THEN",
+    ELSE = "ELSE",
+    ELSEIF = "ELSEIF",
+    END = "END",
+    FOR = "FOR",
+    IN = "IN",
+    BY = "BY",
+    WHILE = "WHILE",
+    DO = "DO",
+    RETURN = "RETURN",
+    BREAK = "BREAK",
+    CONTINUE = "CONTINUE",
+    SWITCH = "SWITCH",
+    CASE = "CASE",
+    DEFAULT = "DEFAULT",
+    FUNCTION = "FUNCTION",
+    FUNC = "FUNC",// func alias
+    ARROW = "ARROW",// =>
+    SPREAD = "SPREAD",// ...
+    GUARD = "GUARD",
+    SAFE = "SAFE",
+    THREAD = "THREAD",
+    LOOP = "LOOP",
+    WAIT = "WAIT",
+    TIMEOUT = "TIMEOUT",
+    INTERVAL = "INTERVAL",
+    TRY = "TRY",
+    CATCH = "CATCH",
+    EMIT = "EMIT",
+    EMIT_CLIENT = "EMIT_CLIENT",
+    EMIT_SERVER = "EMIT_SERVER",
+    EVENT = "EVENT",
+    NETEVENT = "NETEVENT",
+    EXPORT = "EXPORT",
+    COMMAND = "COMMAND",
+    AND = "AND",
+    OR = "OR",
+    NOT = "NOT",
+    PLUS = "PLUS",// +
+    MINUS = "MINUS",// -
+    PLUS_PLUS = "PLUS_PLUS",// ++
+    MINUS_MINUS = "MINUS_MINUS",// --
+    STAR = "STAR",// *
+    SLASH = "SLASH",// /
+    PERCENT = "PERCENT",// %
+    CARET = "CARET",// ^
+    HASH = "HASH",// #
+    EQUALS = "EQUALS",// =
+    PLUS_EQ = "PLUS_EQ",// +=
+    MINUS_EQ = "MINUS_EQ",// -=
+    STAR_EQ = "STAR_EQ",// *=
+    SLASH_EQ = "SLASH_EQ",// /=
+    PERCENT_EQ = "PERCENT_EQ",// %=
+    CONCAT_EQ = "CONCAT_EQ",// ..=
+    EQ = "EQ",// ==
+    NEQ = "NEQ",// ~= or !=
+    LT = "LT",// <
+    GT = "GT",// >
+    LTE = "LTE",// <=
+    GTE = "GTE",// >=
+    QUESTION = "QUESTION",// ? (Ternary)
+    OPT_DOT = "OPT_DOT",// ?.
+    OPT_BRACKET = "OPT_BRACKET",// ?[
+    NULL_COALESCE = "NULL_COALESCE",// ??
+    LPAREN = "LPAREN",// (
+    RPAREN = "RPAREN",// )
+    LBRACE = "LBRACE",// {
+    RBRACE = "RBRACE",// }
+    LBRACKET = "LBRACKET",// [
+    RBRACKET = "RBRACKET",// ]
+    LT_ANGLE = "LT_ANGLE",// < (vector)
+    GT_ANGLE = "GT_ANGLE",// > (vector)
+    COMMA = "COMMA",// ,
+    DOT = "DOT",// .
+    COLON = "COLON",// :
+    SEMICOLON = "SEMICOLON",// ;
+    CONCAT = "CONCAT",// ..
+    RANGE = "RANGE",// ..
+    EOF = "EOF",
+    NEWLINE = "NEWLINE",
+    COMMENT = "COMMENT"
+}
+export interface Token {
+    type: TokenType;
+    value: string;
+    line: number;
+    column: number;
+    quote?: string;
+}
+/**
+ * Reserved keywords map
+ */
+export declare const KEYWORDS: Record<string, TokenType>;

package/dist/compiler/lexer/Token.js

@@ -0,0 +1,169 @@
+/**
+ * LT Language Token Types
+ * All tokens recognized by the LT compiler
+ */
+export var TokenType;
+(function (TokenType) {
+    // Literals
+    TokenType["NUMBER"] = "NUMBER";
+    TokenType["STRING"] = "STRING";
+    TokenType["LONG_STRING"] = "LONG_STRING";
+    TokenType["BOOLEAN"] = "BOOLEAN";
+    TokenType["NIL"] = "NIL";
+    TokenType["IDENTIFIER"] = "IDENTIFIER";
+    // Variable Keywords
+    TokenType["VAR"] = "VAR";
+    TokenType["LET"] = "LET";
+    TokenType["LOCAL"] = "LOCAL";
+    TokenType["CONST"] = "CONST";
+    // Control Flow
+    TokenType["IF"] = "IF";
+    TokenType["THEN"] = "THEN";
+    TokenType["ELSE"] = "ELSE";
+    TokenType["ELSEIF"] = "ELSEIF";
+    TokenType["END"] = "END";
+    TokenType["FOR"] = "FOR";
+    TokenType["IN"] = "IN";
+    TokenType["BY"] = "BY";
+    TokenType["WHILE"] = "WHILE";
+    TokenType["DO"] = "DO";
+    TokenType["RETURN"] = "RETURN";
+    TokenType["BREAK"] = "BREAK";
+    TokenType["CONTINUE"] = "CONTINUE";
+    TokenType["SWITCH"] = "SWITCH";
+    TokenType["CASE"] = "CASE";
+    TokenType["DEFAULT"] = "DEFAULT";
+    // Functions
+    TokenType["FUNCTION"] = "FUNCTION";
+    TokenType["FUNC"] = "FUNC";
+    TokenType["ARROW"] = "ARROW";
+    TokenType["SPREAD"] = "SPREAD";
+    // LT Sugar Keywords
+    TokenType["GUARD"] = "GUARD";
+    TokenType["SAFE"] = "SAFE";
+    TokenType["THREAD"] = "THREAD";
+    TokenType["LOOP"] = "LOOP";
+    TokenType["WAIT"] = "WAIT";
+    TokenType["TIMEOUT"] = "TIMEOUT";
+    TokenType["INTERVAL"] = "INTERVAL";
+    TokenType["TRY"] = "TRY";
+    TokenType["CATCH"] = "CATCH";
+    // FiveM Events
+    TokenType["EMIT"] = "EMIT";
+    TokenType["EMIT_CLIENT"] = "EMIT_CLIENT";
+    TokenType["EMIT_SERVER"] = "EMIT_SERVER";
+    TokenType["EVENT"] = "EVENT";
+    TokenType["NETEVENT"] = "NETEVENT";
+    TokenType["EXPORT"] = "EXPORT";
+    TokenType["COMMAND"] = "COMMAND";
+    // Logical
+    TokenType["AND"] = "AND";
+    TokenType["OR"] = "OR";
+    TokenType["NOT"] = "NOT";
+    // Operators
+    TokenType["PLUS"] = "PLUS";
+    TokenType["MINUS"] = "MINUS";
+    TokenType["PLUS_PLUS"] = "PLUS_PLUS";
+    TokenType["MINUS_MINUS"] = "MINUS_MINUS";
+    TokenType["STAR"] = "STAR";
+    TokenType["SLASH"] = "SLASH";
+    TokenType["PERCENT"] = "PERCENT";
+    TokenType["CARET"] = "CARET";
+    TokenType["HASH"] = "HASH";
+    // Assignment
+    TokenType["EQUALS"] = "EQUALS";
+    TokenType["PLUS_EQ"] = "PLUS_EQ";
+    TokenType["MINUS_EQ"] = "MINUS_EQ";
+    TokenType["STAR_EQ"] = "STAR_EQ";
+    TokenType["SLASH_EQ"] = "SLASH_EQ";
+    TokenType["PERCENT_EQ"] = "PERCENT_EQ";
+    TokenType["CONCAT_EQ"] = "CONCAT_EQ";
+    // Comparison
+    TokenType["EQ"] = "EQ";
+    TokenType["NEQ"] = "NEQ";
+    TokenType["LT"] = "LT";
+    TokenType["GT"] = "GT";
+    TokenType["LTE"] = "LTE";
+    TokenType["GTE"] = "GTE";
+    // Optional Chaining, Null Coalesce, Ternary
+    TokenType["QUESTION"] = "QUESTION";
+    TokenType["OPT_DOT"] = "OPT_DOT";
+    TokenType["OPT_BRACKET"] = "OPT_BRACKET";
+    TokenType["NULL_COALESCE"] = "NULL_COALESCE";
+    // Delimiters
+    TokenType["LPAREN"] = "LPAREN";
+    TokenType["RPAREN"] = "RPAREN";
+    TokenType["LBRACE"] = "LBRACE";
+    TokenType["RBRACE"] = "RBRACE";
+    TokenType["LBRACKET"] = "LBRACKET";
+    TokenType["RBRACKET"] = "RBRACKET";
+    TokenType["LT_ANGLE"] = "LT_ANGLE";
+    TokenType["GT_ANGLE"] = "GT_ANGLE";
+    // Punctuation
+    TokenType["COMMA"] = "COMMA";
+    TokenType["DOT"] = "DOT";
+    TokenType["COLON"] = "COLON";
+    TokenType["SEMICOLON"] = "SEMICOLON";
+    TokenType["CONCAT"] = "CONCAT";
+    TokenType["RANGE"] = "RANGE";
+    // Special
+    TokenType["EOF"] = "EOF";
+    TokenType["NEWLINE"] = "NEWLINE";
+    TokenType["COMMENT"] = "COMMENT";
+})(TokenType || (TokenType = {}));
+/**
+ * Reserved keywords map
+ */
+export const KEYWORDS = {
+    // Variables
+    var: TokenType.VAR,
+    let: TokenType.LET,
+    local: TokenType.LOCAL,
+    const: TokenType.CONST,
+    // Control Flow
+    if: TokenType.IF,
+    then: TokenType.THEN,
+    else: TokenType.ELSE,
+    elseif: TokenType.ELSEIF,
+    end: TokenType.END,
+    for: TokenType.FOR,
+    in: TokenType.IN,
+    by: TokenType.BY,
+    while: TokenType.WHILE,
+    do: TokenType.DO,
+    return: TokenType.RETURN,
+    break: TokenType.BREAK,
+    continue: TokenType.CONTINUE,
+    switch: TokenType.SWITCH,
+    case: TokenType.CASE,
+    default: TokenType.DEFAULT,
+    // Functions
+    function: TokenType.FUNCTION,
+    func: TokenType.FUNC,
+    // LT Sugar
+    guard: TokenType.GUARD,
+    safe: TokenType.SAFE,
+    thread: TokenType.THREAD,
+    loop: TokenType.LOOP,
+    wait: TokenType.WAIT,
+    timeout: TokenType.TIMEOUT,
+    interval: TokenType.INTERVAL,
+    try: TokenType.TRY,
+    catch: TokenType.CATCH,
+    // FiveM Events
+    emit: TokenType.EMIT,
+    emitClient: TokenType.EMIT_CLIENT,
+    emitServer: TokenType.EMIT_SERVER,
+    event: TokenType.EVENT,
+    netevent: TokenType.NETEVENT,
+    export: TokenType.EXPORT,
+    command: TokenType.COMMAND,
+    // Logical
+    and: TokenType.AND,
+    or: TokenType.OR,
+    not: TokenType.NOT,
+    // Literals
+    true: TokenType.BOOLEAN,
+    false: TokenType.BOOLEAN,
+    nil: TokenType.NIL,
+};