@minduscript/lexer 1.0.0

package/.npmignore

@@ -0,0 +1,2 @@
+.tsbuildinfo
+*.map

package/binding.gyp

@@ -0,0 +1,36 @@
+{
+    "targets": [
+        {
+            "target_name": "addon",
+            "sources": [
+                "cpp/lexer.cc",
+                "build/lex.yy.cc"
+            ],
+            "include_dirs": [
+                "<!@(node -p \"require('node-addon-api').include\")",
+                "<!(node -p \"process.env.LEX_HOME || 'D:/win_flex_bison'\")",
+                "cpp"
+            ],
+            "dependencies": ["<!(node -p \"require('node-addon-api').gyp\")"],
+            "cflags!": ["-fno-exceptions"],
+            "cflags_cc!": ["-fno-exceptions"],
+            "defines": ["NAPI_DISABLE_CPP_EXCEPTIONS"],
+            "xcode_settings": {
+                "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
+                "CLANG_CXX_LIBRARY": "libc++",
+                "MACOSX_DEPLOYMENT_TARGET": "10.7"
+            },
+            "msvs_settings": {
+                "VCCLCompilerTool": { "ExceptionHandling": 1 }
+            },
+            "actions": [
+                {
+                    "action_name": "flex",
+                    "inputs": ["cpp/lexer.l"],
+                    "outputs": ["build/lex.yy.cc"],
+                    "action": ["flex", "-+", "-o", "<@(_outputs)", "<@(_inputs)"]
+                },
+            ]
+        }
+    ]
+}

package/cpp/lexer.cc

@@ -0,0 +1,72 @@
+#include <FlexLexer.h>
+#include "lexer.hh"
+
+#include <fstream>
+#include <sstream>
+
+using namespace Napi;
+
+External<Lexer> lexer::initLexer(const CallbackInfo &info) {
+    Env env = info.Env();
+    if (info.Length() == 1) {
+        if (!info[0].IsString())
+            TypeError::New(env, "Invalid parameter").ThrowAsJavaScriptException();
+
+        auto file = info[0].As<String>().Utf8Value();
+        auto f = new std::ifstream(file);
+        if (!f->is_open())
+            Error::New(env, std::string("Cannot open file ") + file).ThrowAsJavaScriptException();
+        auto lexer = new Lexer(f);
+        return External<Lexer>::New(env, lexer);
+    }
+
+    if (info.Length() == 2) {
+        if (!info[0].IsString())
+            TypeError::New(env, "Invalid parameter").ThrowAsJavaScriptException();
+        auto source = info[0].As<String>().Utf8Value();
+        auto s = new std::stringstream(source);
+        auto lexer = new Lexer(s);
+        return External<Lexer>::New(env, lexer);
+    }
+
+    auto lexer = new Lexer();
+    return External<Lexer>::New(env, lexer);
+}
+
+void lexer::deleteLexer(const CallbackInfo &info) {
+    Env env = info.Env();
+    if (info.Length() < 1 || !info[0].IsExternal())
+        TypeError::New(env, "Invalid parameter").ThrowAsJavaScriptException();
+
+    auto lexer = info[0].As<External<Lexer>>().Data();
+    delete lexer;
+}
+
+Object lexer::lex(const CallbackInfo &info) {
+    Env env = info.Env();
+    if (info.Length() < 1 || !info[0].IsExternal())
+        TypeError::New(env, "Invalid parameter").ThrowAsJavaScriptException();
+
+    auto lexer = info[0].As<External<Lexer>>().Data();
+    auto out = Object::New(env);
+    auto result = lexer->yylex();
+    auto leng = lexer->YYLeng();
+    auto text = lexer->YYText();
+    auto row = lexer->getRow();
+    auto col = lexer->getCol() - lexer->YYLeng();
+    out.Set("type", Value::From<int>(env, result));
+    out.Set("leng", Value::From<int>(env, leng));
+    out.Set("raw", Value::From<const char *>(env, text));
+    out.Set("row", Value::From<int>(env, row));
+    out.Set("col", Value::From<int>(env, col));
+    return out;
+}
+
+Object init(Env env, Object exports) {
+    exports.Set("initLexer", Function::New(env, lexer::initLexer));
+    exports.Set("deleteLexer", Function::New(env, lexer::deleteLexer));
+    exports.Set("lex", Function::New(env, lexer::lex));
+    return exports;
+}
+
+NODE_API_MODULE(addon, init)

package/cpp/lexer.hh

@@ -0,0 +1,34 @@
+#pragma once
+
+#define YY_NO_UNISTD_H
+
+#include <napi.h>
+
+#ifndef __FLEX_LEXER_H
+class yyFlexLexer {
+public:
+    yyFlexLexer(std::istream *in);
+};
+#endif
+
+class Lexer : public yyFlexLexer {
+private:
+    int row;
+    int col;
+
+public:
+    Lexer(std::istream *in = nullptr) : yyFlexLexer(in), row(0), col(0) {}
+    int getRow() {
+        return row;
+    }
+    int getCol() {
+        return col;
+    }
+    int yylex();
+};
+
+namespace lexer {
+    Napi::External<Lexer> initLexer(const Napi::CallbackInfo &info);
+    void deleteLexer(const Napi::CallbackInfo &info);
+    Napi::Object lex(const Napi::CallbackInfo &info);
+}

package/cpp/lexer.l

@@ -0,0 +1,180 @@
+%{
+#include "lexer.hh"
+%}
+
+%option noyywrap
+%option c++
+%option yyclass="Lexer"
+
+%%
+"macro" { col += YYLeng(); return 1; } // Minduscript关键字
+"return" { col += YYLeng(); return 2; }
+"if" { col += YYLeng(); return 3; }
+"else" { col += YYLeng(); return 4; }
+"for" { col += YYLeng(); return 5; }
+"while" { col += YYLeng(); return 6; }
+"continue" { col += YYLeng(); return 7; }
+"break" { col += YYLeng(); return 8; }
+"import" { col += YYLeng(); return 9; }
+"as" { col += YYLeng(); return 10; }
+"from" { col += YYLeng(); return 11; }
+"let" { col += YYLeng(); return 12; }
+"const" { col += YYLeng(); return 13; }
+"bind" { col += YYLeng(); return 14; }
+
+"=" { col += YYLeng(); return 15; } // Minduscript运算符
+"+=" { col += YYLeng(); return 16; }
+"-=" { col += YYLeng(); return 17; }
+"*=" { col += YYLeng(); return 18; }
+"/=" { col += YYLeng(); return 19; }
+"//=" { col += YYLeng(); return 20; }
+"%=" { col += YYLeng(); return 21; }
+"**=" { col += YYLeng(); return 22; }
+"&&=" { col += YYLeng(); return 23; }
+"<<=" { col += YYLeng(); return 24; }
+">>=" { col += YYLeng(); return 25; }
+"&=" { col += YYLeng(); return 26; }
+"|=" { col += YYLeng(); return 27; }
+"^=" { col += YYLeng(); return 28; }
+"||" { col += YYLeng(); return 29; }
+"||=" { col += YYLeng(); return 30; }
+"!" { col += YYLeng(); return 31; }
+
+"max" { col += YYLeng(); return 32; } // Mindustry关键字
+"min" { col += YYLeng(); return 33; }
+"angle" { col += YYLeng(); return 34; }
+"angleDiff" { col += YYLeng(); return 35; }
+"len" { col += YYLeng(); return 36; }
+"noise" { col += YYLeng(); return 37; }
+"abs" { col += YYLeng(); return 38; }
+"log" { col += YYLeng(); return 39; }
+"log10" { col += YYLeng(); return 40; }
+"floor" { col += YYLeng(); return 41; }
+"ceil" { col += YYLeng(); return 42; }
+"sqrt" { col += YYLeng(); return 43; }
+"rand" { col += YYLeng(); return 44; }
+"sin" { col += YYLeng(); return 45; }
+"cos" { col += YYLeng(); return 46; }
+"tan" { col += YYLeng(); return 47; }
+"asin" { col += YYLeng(); return 48; }
+"acos" { col += YYLeng(); return 49; }
+"atan" { col += YYLeng(); return 50; }
+"read" { col += YYLeng(); return 51; }
+"write" { col += YYLeng(); return 52; }
+"drawClear" { col += YYLeng(); return 53; }
+"drawColor" { col += YYLeng(); return 54; }
+"drawCol" { col += YYLeng(); return 55; }
+"drawStroke" { col += YYLeng(); return 56; }
+"drawLine" { col += YYLeng(); return 57; }
+"drawRect" { col += YYLeng(); return 58; }
+"drawLineRect" { col += YYLeng(); return 59; }
+"drawPoly" { col += YYLeng(); return 60; }
+"drawLinePoly" { col += YYLeng(); return 61; }
+"drawTriangle" { col += YYLeng(); return 62; }
+"drawImage" { col += YYLeng(); return 63; }
+"print" { col += YYLeng(); return 64; }
+"drawFlush" { col += YYLeng(); return 65; }
+"printFlush" { col += YYLeng(); return 66; }
+"getLink" { col += YYLeng(); return 67; }
+"setEnabled" { col += YYLeng(); return 68; }
+"setShoot" { col += YYLeng(); return 69; }
+"setShootP" { col += YYLeng(); return 70; }
+"setConfig" { col += YYLeng(); return 71; }
+"setColor" { col += YYLeng(); return 72; }
+"radar" { col += YYLeng(); return 73; }
+"sensor" { col += YYLeng(); return 74; }
+"packColor" { col += YYLeng(); return 75; }
+"wait" { col += YYLeng(); return 76; }
+"cpuStop" { col += YYLeng(); return 77; }
+"unitBind" { col += YYLeng(); return 78; }
+"unitRadar" { col += YYLeng(); return 79; }
+"unitLocate" { col += YYLeng(); return 80; }
+"idle" { col += YYLeng(); return 81; }
+"stop" { col += YYLeng(); return 82; }
+"move" { col += YYLeng(); return 83; }
+"approach" { col += YYLeng(); return 84; }
+"pathFind" { col += YYLeng(); return 85; }
+"autoPathFind" { col += YYLeng(); return 86; }
+"boost" { col += YYLeng(); return 87; }
+"target" { col += YYLeng(); return 88; }
+"targetP" { col += YYLeng(); return 89; }
+"itemDrop" { col += YYLeng(); return 90; }
+"itemTake" { col += YYLeng(); return 91; }
+"payDrop" { col += YYLeng(); return 92; }
+"payTake" { col += YYLeng(); return 93; }
+"payEnter" { col += YYLeng(); return 94; }
+"mine" { col += YYLeng(); return 95; }
+"flag" { col += YYLeng(); return 96; }
+"build" { col += YYLeng(); return 97; }
+"getBlock" { col += YYLeng(); return 98; }
+"within" { col += YYLeng(); return 99; }
+"unbind" { col += YYLeng(); return 100; }
+"null" { col += YYLeng(); return 101; }
+"true" { col += YYLeng(); return 102; }
+"false" { col += YYLeng(); return 103; }
+"Any" { col += YYLeng(); return 104; }
+"Enemy" { col += YYLeng(); return 105; }
+"Ally" { col += YYLeng(); return 106; }
+"Player" { col += YYLeng(); return 107; }
+"Attacker" { col += YYLeng(); return 108; }
+"Flying" { col += YYLeng(); return 109; }
+"Boss" { col += YYLeng(); return 110; }
+"Ground" { col += YYLeng(); return 111; }
+"Distance" { col += YYLeng(); return 112; }
+"Health" { col += YYLeng(); return 113; }
+"Shield" { col += YYLeng(); return 114; }
+"Armor" { col += YYLeng(); return 115; }
+"MaxHealth" { col += YYLeng(); return 116; }
+"Ore" { col += YYLeng(); return 117; }
+"Building" { col += YYLeng(); return 118; }
+"Spawn" { col += YYLeng(); return 119; }
+"Damaged" { col += YYLeng(); return 120; }
+"Core" { col += YYLeng(); return 121; }
+"Storage" { col += YYLeng(); return 122; }
+"Generator" { col += YYLeng(); return 123; }
+"Turret" { col += YYLeng(); return 124; }
+"Factory" { col += YYLeng(); return 125; }
+"Repair" { col += YYLeng(); return 126; }
+"Battery" { col += YYLeng(); return 127; }
+"Reactor" { col += YYLeng(); return 128; }
+
+"+" { col += YYLeng(); return 129; } // Mindustry运算符
+"-" { col += YYLeng(); return 130; }
+"*" { col += YYLeng(); return 131; }
+"/" { col += YYLeng(); return 132; }
+"//" { col += YYLeng(); return 133; }
+"%" { col += YYLeng(); return 134; }
+"**" { col += YYLeng(); return 135; }
+"==" { col += YYLeng(); return 136; }
+"!=" { col += YYLeng(); return 137; }
+"&&" { col += YYLeng(); return 138; }
+"<" { col += YYLeng(); return 139; }
+"<=" { col += YYLeng(); return 140; }
+">" { col += YYLeng(); return 141; }
+">=" { col += YYLeng(); return 142; }
+"===" { col += YYLeng(); return 143; }
+"<<" { col += YYLeng(); return 144; }
+">>" { col += YYLeng(); return 145; }
+"|" { col += YYLeng(); return 146; }
+"&" { col += YYLeng(); return 147; }
+"^" { col += YYLeng(); return 148; }
+"~" { col += YYLeng(); return 149; }
+
+[A-Za-z][A-Za-z0-9]* { col += YYLeng(); return 150; } // 标识符
+"@"[A-Za-z][A-Za-z0-9]* { col += YYLeng(); return 151; } // Mindustry标识符
+-?[0-9]+("."[0-9]+)? { col += YYLeng(); return 152; } // 数字字面量
+\"[^\"]*\" { col += YYLeng(); return 153; } // 字符串字面量
+"%"[a-f0-9]{6} { col += YYLeng(); return 154; } // 颜色
+
+"{" { col += YYLeng(); return 155; } // 其他符号
+"}" { col += YYLeng(); return 156; }
+"(" { col += YYLeng(); return 157; }
+")" { col += YYLeng(); return 158; }
+"," { col += YYLeng(); return 159; }
+";" { col += YYLeng(); return 160; }
+
+#[^\n]* { col += YYLeng(); } // 空白
+\r?\n { col = 0; row++; }
+[\x20\t] { col += YYLeng(); }
+. { col += YYLeng(); return -1; }
+%%

package/dist/exe.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/exe.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const fs_1 = __importDefault(require("fs"));
+const _1 = require(".");
+const lexer_1 = require("./lexer");
+commander_1.program
+    .option('-o, --output <string>', '输出文件，若不存在则输出到标准输出')
+    .option('-r, --raw', '输出可被语法分析器使用的原始Token流')
+    .argument('[inputFile]', '输入文件名，若不存在则读取标准输入')
+    .action(function (input) {
+    const options = this.opts();
+    const output = options.output;
+    const raw = options.raw ?? false;
+    let inputData;
+    if (input) {
+        inputData = fs_1.default.readFileSync(input, { encoding: 'utf-8' });
+    }
+    else {
+        inputData = process.stdin.read();
+    }
+    try {
+        const tokens = _1.lexer.lexString(inputData);
+        let outputData;
+        if (raw) {
+            outputData = JSON.stringify(tokens);
+        }
+        else {
+            outputData = JSON.stringify(tokens.map((token) => `${_1.TokenType[token.type]}(${token.raw})`));
+        }
+        if (output) {
+            fs_1.default.writeFileSync(output, outputData, { encoding: 'utf-8' });
+        }
+        else {
+            console.log(outputData);
+        }
+    }
+    catch (e) {
+        if (e instanceof lexer_1.LexError) {
+            console.error(e.message);
+            process.exit(1);
+        }
+        else {
+            throw e;
+        }
+    }
+})
+    .parse();
+//# sourceMappingURL=exe.js.map

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { Lexer } from './lexer';
+export declare const lexer: Lexer;
+export { TokenType } from './token';
+export type { Token } from './token';

package/dist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenType = exports.lexer = void 0;
+const lexer_1 = require("./lexer");
+exports.lexer = new lexer_1.Lexer();
+var token_1 = require("./token");
+Object.defineProperty(exports, "TokenType", { enumerable: true, get: function () { return token_1.TokenType; } });
+//# sourceMappingURL=index.js.map

package/dist/lexer.d.ts

@@ -0,0 +1,13 @@
+import type { Token } from './token';
+export declare class LexError extends Error {
+    readonly row: number;
+    readonly col: number;
+    readonly raw: string;
+    constructor(row: number, col: number, raw: string);
+}
+export declare class Lexer {
+    private lex;
+    lexInput(): Token[];
+    lexFile(fileName: string): Token[];
+    lexString(str: string): Token[];
+}

package/dist/lexer.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lexer = exports.LexError = void 0;
+const cppLib = require('../build/Release/addon.node');
+class LexError extends Error {
+    row;
+    col;
+    raw;
+    constructor(row, col, raw) {
+        super(`Unexpected char "${JSON.stringify(raw)}" at (${row}, ${col})`);
+        this.row = row;
+        this.col = col;
+        this.raw = raw;
+    }
+}
+exports.LexError = LexError;
+class Lexer {
+    lex(lexer) {
+        const tokenStream = [];
+        let token;
+        while ((token = cppLib.lex(lexer)).type != 0) {
+            if (token.type == -1) {
+                cppLib.deleteLexer(lexer);
+                throw new LexError(token.row, token.col, token.raw);
+            }
+            tokenStream.push(token);
+        }
+        cppLib.deleteLexer(lexer);
+        return tokenStream;
+    }
+    lexInput() {
+        return this.lex(cppLib.initLexer());
+    }
+    lexFile(fileName) {
+        return this.lex(cppLib.initLexer(fileName));
+    }
+    lexString(str) {
+        return this.lex(cppLib.initLexer(str, true));
+    }
+}
+exports.Lexer = Lexer;
+//# sourceMappingURL=lexer.js.map

package/dist/token.d.ts

@@ -0,0 +1,168 @@
+export declare enum TokenType {
+    MACRO = 1,// macro
+    RETURN = 2,
+    IF = 3,// if
+    ELSE = 4,// else
+    FOR = 5,// for
+    WHILE = 6,// while
+    CONTINUE = 7,// continue
+    BREAK = 8,// break
+    IMPORT = 9,// import
+    AS = 10,// as
+    FROM = 11,// from
+    LET = 12,// let
+    CONST = 13,// const
+    BIND = 14,// bind
+    ASSIGN = 15,// =
+    ADD_ASSIGN = 16,// +=
+    SUB_ASSIGN = 17,// -=
+    MUL_ASSIGN = 18,// *=
+    DIV_ASSIGN = 19,// /=
+    IDIV_ASSIGN = 20,// //=
+    MOD_ASSIGN = 21,// %=
+    POW_ASSIGN = 22,// **=
+    AND_ASSIGN = 23,// &&=
+    SHL_ASSIGN = 24,// <<=
+    SHR_ASSIGN = 25,// >>=
+    BITAND_ASSIGN = 26,// &=
+    BITOR_ASSIGN = 27,// |=
+    XOR_ASSIGN = 28,// ^=
+    OR = 29,// ||
+    OR_ASSIGN = 30,// ||=
+    NOT = 31,// !
+    MAX = 32,// max
+    MIN = 33,// min
+    ANGLE = 34,// angle
+    ANGLE_DIFF = 35,// angleDiff
+    LEN = 36,// len
+    NOISE = 37,// noise
+    ABS = 38,// abs
+    LOG = 39,// log
+    LOG10 = 40,// log10
+    FLOOR = 41,// floor
+    CEIL = 42,// ceil
+    SQRT = 43,// sqrt
+    RAND = 44,// rand
+    SIN = 45,// sin
+    COS = 46,// cos
+    TAN = 47,// tan
+    ASIN = 48,// asin
+    ACOS = 49,// acos,
+    ATAN = 50,// atan
+    READ = 51,// read
+    WRITE = 52,// write
+    DRAW_CLEAR = 53,// drawClear
+    DRAW_COLOR = 54,// drawColor
+    DRAW_COL = 55,// drawCol
+    DRAW_STROKE = 56,// drawStroke
+    DRAW_LINE = 57,// drawLine
+    DRAW_RECT = 58,// drawRect
+    DRAW_LINE_RECT = 59,// drawLineRect
+    DRAW_POLY = 60,// drawPoly
+    DRAW_LINE_POLY = 61,// drawLinePoly
+    DRAW_TRIANGLE = 62,// drawTriangle
+    DRAW_IMAGE = 63,// drawImage
+    PRINT = 64,// print
+    DRAW_FLUSH = 65,// drawFlush
+    PRINT_FLUSH = 66,// printFlush
+    GET_LINK = 67,// getLink
+    SET_ENABLED = 68,// setEnabled
+    SET_SHOOT = 69,// setShoot
+    SET_SHOOT_P = 70,// setShootP
+    SET_CONFIG = 71,// setConfig
+    SET_COLOR = 72,// setColor
+    RADAR = 73,// radar
+    SENSOR = 74,// sensor
+    PACK_COLOR = 75,// packColor
+    WAIT = 76,// wait
+    CPU_STOP = 77,// cpuStop
+    UNIT_BIND = 78,// unitBind
+    UNIT_RADAR = 79,// unitRadar
+    UNIT_LOCATE = 80,// unitLocate
+    IDLE = 81,// idle
+    STOP = 82,// stop
+    MOVE = 83,// move
+    APPROACH = 84,// approach
+    PATH_FIND = 85,// pathFind
+    AUTO_PATH_FIND = 86,// autoPathFind
+    BOOST = 87,// boost
+    TARGET = 88,// target
+    TARGET_P = 89,// targetP
+    ITEM_DROP = 90,// itemDrop
+    ITEM_TAKE = 91,// itemTake
+    PAY_DROP = 92,// payDrop
+    PAY_TAKE = 93,// payTake
+    PAY_ENTER = 94,// payEnter
+    MINE = 95,// mine
+    FLAG = 96,// flag
+    BUILD = 97,// build
+    GET_BLOCK = 98,// getBlock
+    WITHIN = 99,// within
+    UNBIND = 100,// unbind
+    NULL = 101,// null
+    TRUE = 102,// true
+    FALSE = 103,// false
+    ANY = 104,// Any
+    ENEMY = 105,// Enemy
+    ALLY = 106,// Ally
+    PLAYER = 107,// Player
+    ATTACKER = 108,// Attacker
+    FLYING = 109,// Flying
+    BOSS = 110,// Boss
+    GROUND = 111,// Ground
+    DISTANCE = 112,// Distance
+    HEALTH = 113,// Health
+    SHIELD = 114,// Shield
+    ARMOR = 115,// Armor
+    MAX_HEALTH = 116,// MaxHealth
+    ORE = 117,// Ore
+    BUILDING = 118,// Building
+    SPAWN = 119,// Spawn
+    DAMAGED = 120,// Damaged
+    CORE = 121,// Core
+    STORAGE = 122,// Storage
+    GENERATOR = 123,// Generator
+    TURRET = 124,// Turret
+    FACTORY = 125,// Factory
+    REPAIR = 126,// Repair
+    BATTERY = 127,// Battery
+    REACTOR = 128,// Reactor
+    ADD = 129,// +
+    SUB = 130,// -
+    MUL = 131,// *
+    DIV = 132,// /
+    IDIV = 133,// //
+    MOD = 134,// %
+    POW = 135,// **
+    EQ = 136,// ==
+    NE = 137,// !=
+    AND = 138,// &&
+    LESS = 139,// <
+    LE = 140,// <=
+    GREATER = 141,// >
+    GE = 142,// >=
+    STRICT_EQ = 143,// ===
+    SHL = 144,// <<
+    SHR = 145,// >>
+    BITOR = 146,// |
+    BITAND = 147,// &
+    XOR = 148,// ^
+    FLIP = 149,// ~
+    IDENTIFIER = 150,// 标识符
+    MINDUSTRY_IDENTIFIER = 151,// Mindustry标识符
+    NUMBER = 152,// 数字字面量
+    STRING = 153,// 字符串字面量
+    COLOR = 154,// 颜色
+    L_BRACE = 155,// {
+    R_BRACE = 156,// }
+    L_PAREN = 157,// (
+    R_PAREN = 158,// )
+    COMMA = 159,// ,
+    SEMICOLON = 160
+}
+export type Token = {
+    type: TokenType;
+    raw: string;
+    row: number;
+    col: number;
+};

package/dist/token.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenType = void 0;
+var TokenType;
+(function (TokenType) {
+    // Minduscript关键字
+    TokenType[TokenType["MACRO"] = 1] = "MACRO";
+    TokenType[TokenType["RETURN"] = 2] = "RETURN";
+    TokenType[TokenType["IF"] = 3] = "IF";
+    TokenType[TokenType["ELSE"] = 4] = "ELSE";
+    TokenType[TokenType["FOR"] = 5] = "FOR";
+    TokenType[TokenType["WHILE"] = 6] = "WHILE";
+    TokenType[TokenType["CONTINUE"] = 7] = "CONTINUE";
+    TokenType[TokenType["BREAK"] = 8] = "BREAK";
+    TokenType[TokenType["IMPORT"] = 9] = "IMPORT";
+    TokenType[TokenType["AS"] = 10] = "AS";
+    TokenType[TokenType["FROM"] = 11] = "FROM";
+    TokenType[TokenType["LET"] = 12] = "LET";
+    TokenType[TokenType["CONST"] = 13] = "CONST";
+    TokenType[TokenType["BIND"] = 14] = "BIND";
+    // Minduscript运算符
+    TokenType[TokenType["ASSIGN"] = 15] = "ASSIGN";
+    TokenType[TokenType["ADD_ASSIGN"] = 16] = "ADD_ASSIGN";
+    TokenType[TokenType["SUB_ASSIGN"] = 17] = "SUB_ASSIGN";
+    TokenType[TokenType["MUL_ASSIGN"] = 18] = "MUL_ASSIGN";
+    TokenType[TokenType["DIV_ASSIGN"] = 19] = "DIV_ASSIGN";
+    TokenType[TokenType["IDIV_ASSIGN"] = 20] = "IDIV_ASSIGN";
+    TokenType[TokenType["MOD_ASSIGN"] = 21] = "MOD_ASSIGN";
+    TokenType[TokenType["POW_ASSIGN"] = 22] = "POW_ASSIGN";
+    TokenType[TokenType["AND_ASSIGN"] = 23] = "AND_ASSIGN";
+    TokenType[TokenType["SHL_ASSIGN"] = 24] = "SHL_ASSIGN";
+    TokenType[TokenType["SHR_ASSIGN"] = 25] = "SHR_ASSIGN";
+    TokenType[TokenType["BITAND_ASSIGN"] = 26] = "BITAND_ASSIGN";
+    TokenType[TokenType["BITOR_ASSIGN"] = 27] = "BITOR_ASSIGN";
+    TokenType[TokenType["XOR_ASSIGN"] = 28] = "XOR_ASSIGN";
+    TokenType[TokenType["OR"] = 29] = "OR";
+    TokenType[TokenType["OR_ASSIGN"] = 30] = "OR_ASSIGN";
+    TokenType[TokenType["NOT"] = 31] = "NOT";
+    // Mindustry关键字
+    TokenType[TokenType["MAX"] = 32] = "MAX";
+    TokenType[TokenType["MIN"] = 33] = "MIN";
+    TokenType[TokenType["ANGLE"] = 34] = "ANGLE";
+    TokenType[TokenType["ANGLE_DIFF"] = 35] = "ANGLE_DIFF";
+    TokenType[TokenType["LEN"] = 36] = "LEN";
+    TokenType[TokenType["NOISE"] = 37] = "NOISE";
+    TokenType[TokenType["ABS"] = 38] = "ABS";
+    TokenType[TokenType["LOG"] = 39] = "LOG";
+    TokenType[TokenType["LOG10"] = 40] = "LOG10";
+    TokenType[TokenType["FLOOR"] = 41] = "FLOOR";
+    TokenType[TokenType["CEIL"] = 42] = "CEIL";
+    TokenType[TokenType["SQRT"] = 43] = "SQRT";
+    TokenType[TokenType["RAND"] = 44] = "RAND";
+    TokenType[TokenType["SIN"] = 45] = "SIN";
+    TokenType[TokenType["COS"] = 46] = "COS";
+    TokenType[TokenType["TAN"] = 47] = "TAN";
+    TokenType[TokenType["ASIN"] = 48] = "ASIN";
+    TokenType[TokenType["ACOS"] = 49] = "ACOS";
+    TokenType[TokenType["ATAN"] = 50] = "ATAN";
+    TokenType[TokenType["READ"] = 51] = "READ";
+    TokenType[TokenType["WRITE"] = 52] = "WRITE";
+    TokenType[TokenType["DRAW_CLEAR"] = 53] = "DRAW_CLEAR";
+    TokenType[TokenType["DRAW_COLOR"] = 54] = "DRAW_COLOR";
+    TokenType[TokenType["DRAW_COL"] = 55] = "DRAW_COL";
+    TokenType[TokenType["DRAW_STROKE"] = 56] = "DRAW_STROKE";
+    TokenType[TokenType["DRAW_LINE"] = 57] = "DRAW_LINE";
+    TokenType[TokenType["DRAW_RECT"] = 58] = "DRAW_RECT";
+    TokenType[TokenType["DRAW_LINE_RECT"] = 59] = "DRAW_LINE_RECT";
+    TokenType[TokenType["DRAW_POLY"] = 60] = "DRAW_POLY";
+    TokenType[TokenType["DRAW_LINE_POLY"] = 61] = "DRAW_LINE_POLY";
+    TokenType[TokenType["DRAW_TRIANGLE"] = 62] = "DRAW_TRIANGLE";
+    TokenType[TokenType["DRAW_IMAGE"] = 63] = "DRAW_IMAGE";
+    TokenType[TokenType["PRINT"] = 64] = "PRINT";
+    TokenType[TokenType["DRAW_FLUSH"] = 65] = "DRAW_FLUSH";
+    TokenType[TokenType["PRINT_FLUSH"] = 66] = "PRINT_FLUSH";
+    TokenType[TokenType["GET_LINK"] = 67] = "GET_LINK";
+    TokenType[TokenType["SET_ENABLED"] = 68] = "SET_ENABLED";
+    TokenType[TokenType["SET_SHOOT"] = 69] = "SET_SHOOT";
+    TokenType[TokenType["SET_SHOOT_P"] = 70] = "SET_SHOOT_P";
+    TokenType[TokenType["SET_CONFIG"] = 71] = "SET_CONFIG";
+    TokenType[TokenType["SET_COLOR"] = 72] = "SET_COLOR";
+    TokenType[TokenType["RADAR"] = 73] = "RADAR";
+    TokenType[TokenType["SENSOR"] = 74] = "SENSOR";
+    TokenType[TokenType["PACK_COLOR"] = 75] = "PACK_COLOR";
+    TokenType[TokenType["WAIT"] = 76] = "WAIT";
+    TokenType[TokenType["CPU_STOP"] = 77] = "CPU_STOP";
+    TokenType[TokenType["UNIT_BIND"] = 78] = "UNIT_BIND";
+    TokenType[TokenType["UNIT_RADAR"] = 79] = "UNIT_RADAR";
+    TokenType[TokenType["UNIT_LOCATE"] = 80] = "UNIT_LOCATE";
+    TokenType[TokenType["IDLE"] = 81] = "IDLE";
+    TokenType[TokenType["STOP"] = 82] = "STOP";
+    TokenType[TokenType["MOVE"] = 83] = "MOVE";
+    TokenType[TokenType["APPROACH"] = 84] = "APPROACH";
+    TokenType[TokenType["PATH_FIND"] = 85] = "PATH_FIND";
+    TokenType[TokenType["AUTO_PATH_FIND"] = 86] = "AUTO_PATH_FIND";
+    TokenType[TokenType["BOOST"] = 87] = "BOOST";
+    TokenType[TokenType["TARGET"] = 88] = "TARGET";
+    TokenType[TokenType["TARGET_P"] = 89] = "TARGET_P";
+    TokenType[TokenType["ITEM_DROP"] = 90] = "ITEM_DROP";
+    TokenType[TokenType["ITEM_TAKE"] = 91] = "ITEM_TAKE";
+    TokenType[TokenType["PAY_DROP"] = 92] = "PAY_DROP";
+    TokenType[TokenType["PAY_TAKE"] = 93] = "PAY_TAKE";
+    TokenType[TokenType["PAY_ENTER"] = 94] = "PAY_ENTER";
+    TokenType[TokenType["MINE"] = 95] = "MINE";
+    TokenType[TokenType["FLAG"] = 96] = "FLAG";
+    TokenType[TokenType["BUILD"] = 97] = "BUILD";
+    TokenType[TokenType["GET_BLOCK"] = 98] = "GET_BLOCK";
+    TokenType[TokenType["WITHIN"] = 99] = "WITHIN";
+    TokenType[TokenType["UNBIND"] = 100] = "UNBIND";
+    TokenType[TokenType["NULL"] = 101] = "NULL";
+    TokenType[TokenType["TRUE"] = 102] = "TRUE";
+    TokenType[TokenType["FALSE"] = 103] = "FALSE";
+    TokenType[TokenType["ANY"] = 104] = "ANY";
+    TokenType[TokenType["ENEMY"] = 105] = "ENEMY";
+    TokenType[TokenType["ALLY"] = 106] = "ALLY";
+    TokenType[TokenType["PLAYER"] = 107] = "PLAYER";
+    TokenType[TokenType["ATTACKER"] = 108] = "ATTACKER";
+    TokenType[TokenType["FLYING"] = 109] = "FLYING";
+    TokenType[TokenType["BOSS"] = 110] = "BOSS";
+    TokenType[TokenType["GROUND"] = 111] = "GROUND";
+    TokenType[TokenType["DISTANCE"] = 112] = "DISTANCE";
+    TokenType[TokenType["HEALTH"] = 113] = "HEALTH";
+    TokenType[TokenType["SHIELD"] = 114] = "SHIELD";
+    TokenType[TokenType["ARMOR"] = 115] = "ARMOR";
+    TokenType[TokenType["MAX_HEALTH"] = 116] = "MAX_HEALTH";
+    TokenType[TokenType["ORE"] = 117] = "ORE";
+    TokenType[TokenType["BUILDING"] = 118] = "BUILDING";
+    TokenType[TokenType["SPAWN"] = 119] = "SPAWN";
+    TokenType[TokenType["DAMAGED"] = 120] = "DAMAGED";
+    TokenType[TokenType["CORE"] = 121] = "CORE";
+    TokenType[TokenType["STORAGE"] = 122] = "STORAGE";
+    TokenType[TokenType["GENERATOR"] = 123] = "GENERATOR";
+    TokenType[TokenType["TURRET"] = 124] = "TURRET";
+    TokenType[TokenType["FACTORY"] = 125] = "FACTORY";
+    TokenType[TokenType["REPAIR"] = 126] = "REPAIR";
+    TokenType[TokenType["BATTERY"] = 127] = "BATTERY";
+    TokenType[TokenType["REACTOR"] = 128] = "REACTOR";
+    // Mindustry运算符
+    TokenType[TokenType["ADD"] = 129] = "ADD";
+    TokenType[TokenType["SUB"] = 130] = "SUB";
+    TokenType[TokenType["MUL"] = 131] = "MUL";
+    TokenType[TokenType["DIV"] = 132] = "DIV";
+    TokenType[TokenType["IDIV"] = 133] = "IDIV";
+    TokenType[TokenType["MOD"] = 134] = "MOD";
+    TokenType[TokenType["POW"] = 135] = "POW";
+    TokenType[TokenType["EQ"] = 136] = "EQ";
+    TokenType[TokenType["NE"] = 137] = "NE";
+    TokenType[TokenType["AND"] = 138] = "AND";
+    TokenType[TokenType["LESS"] = 139] = "LESS";
+    TokenType[TokenType["LE"] = 140] = "LE";
+    TokenType[TokenType["GREATER"] = 141] = "GREATER";
+    TokenType[TokenType["GE"] = 142] = "GE";
+    TokenType[TokenType["STRICT_EQ"] = 143] = "STRICT_EQ";
+    TokenType[TokenType["SHL"] = 144] = "SHL";
+    TokenType[TokenType["SHR"] = 145] = "SHR";
+    TokenType[TokenType["BITOR"] = 146] = "BITOR";
+    TokenType[TokenType["BITAND"] = 147] = "BITAND";
+    TokenType[TokenType["XOR"] = 148] = "XOR";
+    TokenType[TokenType["FLIP"] = 149] = "FLIP";
+    // 其他
+    TokenType[TokenType["IDENTIFIER"] = 150] = "IDENTIFIER";
+    TokenType[TokenType["MINDUSTRY_IDENTIFIER"] = 151] = "MINDUSTRY_IDENTIFIER";
+    TokenType[TokenType["NUMBER"] = 152] = "NUMBER";
+    TokenType[TokenType["STRING"] = 153] = "STRING";
+    TokenType[TokenType["COLOR"] = 154] = "COLOR";
+    TokenType[TokenType["L_BRACE"] = 155] = "L_BRACE";
+    TokenType[TokenType["R_BRACE"] = 156] = "R_BRACE";
+    TokenType[TokenType["L_PAREN"] = 157] = "L_PAREN";
+    TokenType[TokenType["R_PAREN"] = 158] = "R_PAREN";
+    TokenType[TokenType["COMMA"] = 159] = "COMMA";
+    TokenType[TokenType["SEMICOLON"] = 160] = "SEMICOLON";
+})(TokenType || (exports.TokenType = TokenType = {}));
+//# sourceMappingURL=token.js.map

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@minduscript/lexer",
+  "version": "1.0.0",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "lex-minduscript": "dist/exe.js"
+  },
+  "files": [
+    "dist",
+    "cpp",
+    ".npmignore",
+    "binding.gyp"
+  ],
+  "dependencies": {
+    "bindings": "^1.5.0",
+    "commander": "^14.0.3",
+    "node-addon-api": "^8.6.0"
+  },
+  "devDependencies": {
+    "@types/bindings": "^1.5.5",
+    "@types/node": "^25.5.0",
+    "node-gyp": "^12.2.0",
+    "rimraf": "^6.1.3",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "init:cpp": "node-gyp configure",
+    "build:cpp": "node-gyp rebuild",
+    "build:ts": "rimraf dist && tsc",
+    "build": "pnpm build:cpp && pnpm build:ts"
+  }
+}