meaoiu 0.1.0 → 0.1.2

package/dist/core/parser.d.ts

@@ -1,6 +1,6 @@
 import type * as AST from './ast.js';
 import { MeaoiuError } from './error.js';
-import { type Token } from './tokenizer.js';
+import { type Token } from './lexer/tokenizer.js';
 export declare const enum ParseMode {
     STRICT = 0,
     TOLERANT = 1
@@ -9,81 +9,5 @@ export type ParseResult = {
     program: AST.Program;
     errors: MeaoiuError[];
 };
-export declare class Parser {
-    private readonly tokens;
-    private readonly MODE;
-    private readonly MAX_POS;
-    private readonly blockDepth;
-    private readonly errors;
-    private position;
-    private commentBuffer;
-    constructor(tokens: Token[], mode?: ParseMode);
-    private current;
-    private peek;
-    /**
-     * 返回当前位置的「非悄悄话 token」，并将位置推进到下一个 token（非悄悄话或 EOF），
-     * 同时把遇到的悄悄话收集到 commentBuffer
-     * @returns 当前位置的 token（非 COMMENT）
-     */
-    private advance;
-    /**
-     * 推进位置（同时掠取悄悄话）并取得下一 token
-     * @returns 悄悄话之后一个 token 的再下一 token
-     */
-    private next;
-    /**
-     * 返回上一个非悄悄话 token（不动位置）
-     * @returns 上一个非悄悄话 token
-     */
-    private lookBack;
-    /**
-     * 取得当前非悄悄话 token，若当前为悄悄话则连续推进至目标（同时收集悄悄话到 commentBuffer）
-     * @returns 当前 token 或其后第一个非悄悄话 token（或 EOF）
-     */
-    private drainCommentsAhead;
-    /**
-     * 从缓存中拿走所有待分配的 leading 悄悄话（并清空缓存）
-     * @returns 所有待分配的悄悄话
-     */
-    private takeLeadingComments;
-    /**
-     * 把缓存里的悄悄话按是否与 anchorToken 同一行分离：
-     * - 同行的视为 trailing（尾随悄悄话），附给 node
-     * - 不同的保留为未来节点的 leading（放回 commentBuffer）
-     */
-    private collectTrailingComments;
-    private endLoc;
-    private reportError;
-    /**
-     * 虚构尾随词元并报告错误。
-     * @param kind 虚构词元种类，若无预期则可传 TokenKind.ERROR
-     * @returns 虚构 token
-     */
-    private makeErrorTail;
-    private expect;
-    private synchronize;
-    private consumeToRecoveryPoint;
-    parse(): ParseResult;
-    private parseStatement;
-    private parseVariableDeclaration;
-    private parseAssignmentStatement;
-    private parseFunctionDeclaration;
-    private parseReturnOrAmbushStatement;
-    private parseIdentifier;
-    private parseExpression;
-    private parseLogicalExpression;
-    private parseSequenceExpression;
-    private parseComparisonExpression;
-    private parseAdditiveExpression;
-    private parseMultiplicativeExpression;
-    private parseUnaryExpression;
-    private parseMemberAccessExpression;
-    private parsePrimaryExpression;
-    private parseBlockOrIfExpression;
-    private parseBlockExpression;
-    private parseCollectionElement;
-    private parseIfExpression;
-    private parseLoopExpression;
-    private parseCallExpression;
-}
+export declare function parse(tokens: Token[], mode?: ParseMode): ParseResult;
 //# sourceMappingURL=parser.d.ts.map

package/dist/core/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/core/parser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,GAAG,MAAM,UAAU,CAAC;AAErC,OAAO,EAAE,WAAW,EAAoB,MAAM,YAAY,CAAC;AAC3D,OAAO,EAAgC,KAAK,KAAK,EAAa,MAAM,gBAAgB,CAAC;AAErF,0BAAkB,SAAS;IAC1B,MAAM,IAAA;IACN,QAAQ,IAAA;CACR;AAED,MAAM,MAAM,WAAW,GAAG;IACzB,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC;IACrB,MAAM,EAAE,WAAW,EAAE,CAAC;CACtB,CAAC;AAkEF,qBAAa,MAAM;IAClB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAU;IACjC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAY;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAqB;IAChD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAC5C,OAAO,CAAC,QAAQ,CAAK;IAGrB,OAAO,CAAC,aAAa,CAAe;gBAExB,MAAM,EAAE,KAAK,EAAE,EAAE,IAAI,GAAE,SAA4B;IAW/D,OAAO,CAAC,OAAO;IAKf,OAAO,CAAC,IAAI;IAIZ;;;;OAIG;IACH,OAAO,CAAC,OAAO;IAMf;;;OAGG;IACH,OAAO,CAAC,IAAI;IAKZ;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAOhB;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAS1B;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAM3B;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;IAmB/B,OAAO,CAAC,MAAM;IAKd,OAAO,CAAC,WAAW;IAKnB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAWrB,OAAO,CAAC,MAAM;IAQd,OAAO,CAAC,WAAW;IAkBnB,OAAO,CAAC,sBAAsB;IAQvB,KAAK,IAAI,WAAW;IAwB3B,OAAO,CAAC,cAAc;IA2DtB,OAAO,CAAC,wBAAwB;IAahC,OAAO,CAAC,wBAAwB;IAWhC,OAAO,CAAC,wBAAwB;IAQhC,OAAO,CAAC,4BAA4B;IAQpC,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,sBAAsB;IAgD9B,OAAO,CAAC,uBAAuB;IAuC/B,OAAO,CAAC,yBAAyB;IAiBjC,OAAO,CAAC,uBAAuB;IAgB/B,OAAO,CAAC,6BAA6B;IAgBrC,OAAO,CAAC,oBAAoB;IAsB5B,OAAO,CAAC,2BAA2B;IAkBnC,OAAO,CAAC,sBAAsB;IA2C9B,OAAO,CAAC,wBAAwB;IAKhC,OAAO,CAAC,oBAAoB;IA4B5B,OAAO,CAAC,sBAAsB;IAgB9B,OAAO,CAAC,iBAAiB;IAoBzB,OAAO,CAAC,mBAAmB;IAM3B,OAAO,CAAC,mBAAmB;CAM3B"}
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/core/parser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,GAAG,MAAM,UAAU,CAAC;AAErC,OAAO,EAAE,WAAW,EAAoB,MAAM,YAAY,CAAC;AAC3D,OAAO,EAMN,KAAK,KAAK,EACV,MAAM,sBAAsB,CAAC;AAE9B,0BAAkB,SAAS;IAC1B,MAAM,IAAA;IACN,QAAQ,IAAA;CACR;AAED,MAAM,MAAM,WAAW,GAAG;IACzB,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC;IACrB,MAAM,EAAE,WAAW,EAAE,CAAC;CACtB,CAAC;AAkqBF,wBAAgB,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,IAAI,GAAE,SAA4B,GAAG,WAAW,CAEtF"}

package/dist/core/parser.js

@@ -1,11 +1,6 @@
 // src/core/parser.ts
 import { MeaoiuError, errorFrom } from './error.js';
-import { OP_ARITH, OP_COMP, OP_COMP_E } from './tokenizer.js';
-const assignMap = {
-    [2 /* TokenKind.KEYWORD_IS */]: 0 /* AssignmentOperator.REFERENCE */,
-    [3 /* TokenKind.KEYWORD_LIKE */]: 1 /* AssignmentOperator.COPY */,
-    [4 /* TokenKind.KEYWORD_ONLY */]: 2 /* AssignmentOperator.MOVE */,
-};
+import { newToken, } from './lexer/tokenizer.js';
 const blockKindInfo = [
     {
         name: '想法',
@@ -19,18 +14,34 @@ const blockKindInfo = [
         name: '纸箱',
         startKind: 20 /* TokenKind.COLLECTION_START */,
         startValue: '[=',
-        separatorKind: 27 /* TokenKind.COMMA */,
+        separatorKind: 36 /* TokenKind.COMMA */,
         endKind: 21 /* TokenKind.COLLECTION_END */,
         endValue: '=]',
     },
 ]; // 0: 想法, 1: 纸箱
 const syntaxErrorFrom = (ele, message) => errorFrom(ele, message, 3 /* Phase.SYNTACTIC */);
-function tokenTrailing({ line, col: prevCol, value: prevValue }, kind, value = '') {
-    return { kind, value, line, col: prevCol + prevValue.length };
-}
 function errorNodeWith({ message, line, col, endLine, endCol }) {
     return { kind: 0 /* NodeKind.ErrorNode */, message, line, col, endLine, endCol };
 }
+function isAdditiveToken(token) {
+    return token.kind === 26 /* TokenKind.ARITHMETIC_PLUS */ || token.kind === 27 /* TokenKind.ARITHMETIC_MINUS */;
+}
+function isMultiplicativeToken(token) {
+    return token.kind === 28 /* TokenKind.ARITHMETIC_MULTIPLY */ || token.kind === 29 /* TokenKind.ARITHMETIC_DIVIDE */;
+}
+function isComparisonToken(token) {
+    switch (token.kind) {
+        case 32 /* TokenKind.COMPARISON_GREATER */:
+        case 33 /* TokenKind.COMPARISON_LESS */:
+        case 34 /* TokenKind.COMPARISON_GREATER_EQUAL */:
+        case 35 /* TokenKind.COMPARISON_LESS_EQUAL */:
+        case 30 /* TokenKind.COMPARISON_EQUAL */:
+        case 31 /* TokenKind.COMPARISON_NOT_EQUAL */:
+            return true;
+        default:
+            return false;
+    }
+}
 function isStartToken(kind) {
     switch (kind) {
         case 1 /* TokenKind.KEYWORD_USE */:
@@ -47,9 +58,9 @@ function isStartToken(kind) {
     }
 }
 function isAssignmentOperator(kind) {
-    return kind === 2 /* TokenKind.KEYWORD_IS */ || kind === 3 /* TokenKind.KEYWORD_LIKE */ || kind === 4 /* TokenKind.KEYWORD_ONLY */;
+    return kind === 2 /* TokenKind.ASSIGNMENT_IS */ || kind === 3 /* TokenKind.ASSIGNMENT_LIKE */ || kind === 4 /* TokenKind.ASSIGNMENT_ONLY */;
 }
-export class Parser {
+class Parser {
     tokens;
     MODE;
     MAX_POS;
@@ -59,13 +70,14 @@ export class Parser {
     // 悄悄话缓存：advance / drainCommentsAhead 会把遇到的 COMMENT 放进这里
     commentBuffer = [];
     constructor(tokens, mode = 0 /* ParseMode.STRICT */) {
+        this.MODE = mode;
         // 确保有 EOF 哨兵，避免边界问题
-        if (!tokens.length || tokens[tokens.length - 1]?.kind !== 35 /* TokenKind.EOF */) {
-            tokens = tokens.concat([{ kind: 35 /* TokenKind.EOF */, value: 'EndOfFile', line: -1, col: -1 }]);
+        if (!tokens.length || tokens[tokens.length - 1].kind !== 44 /* TokenKind.EOF */) {
+            const EOF = newToken(44 /* TokenKind.EOF */, 'EndOfFile', -1, -1, -1, -1);
+            tokens.push((this.reportError(errorFrom(EOF, '分词器可能坏了喵~', 1 /* Phase.INVARIANT */)), EOF));
         }
         this.tokens = tokens;
         this.MAX_POS = tokens.length - 1;
-        this.MODE = mode;
     }
     // 当前 token（安全！）
     current() {
@@ -73,7 +85,7 @@ export class Parser {
     }
     // 安全前视 n 个 token
     peek(n = 1) {
-        return this.tokens[this.position + n] ?? this.tokens[this.MAX_POS];
+        return this.tokens[Math.min(this.position + n, this.MAX_POS)];
     }
     /**
      * 返回当前位置的「非悄悄话 token」，并将位置推进到下一个 token（非悄悄话或 EOF），
@@ -102,7 +114,7 @@ export class Parser {
         if (this.position < 1)
             return this.current();
         let token;
-        for (let pos = this.position; (token = this.tokens[--pos]).kind === 34 /* TokenKind.COMMENT */ && pos > 0;)
+        for (let pos = this.position; (token = this.tokens[--pos]).kind === 43 /* TokenKind.COMMENT */ && pos > 0;)
             ;
         return token;
     }
@@ -112,7 +124,7 @@ export class Parser {
      */
     drainCommentsAhead() {
         let token = this.current();
-        while (token.kind === 34 /* TokenKind.COMMENT */ && this.position < this.MAX_POS) {
+        while (token.kind === 43 /* TokenKind.COMMENT */ && this.position < this.MAX_POS) {
             this.commentBuffer.push(token);
             token = this.tokens[++this.position];
         }
@@ -138,18 +150,16 @@ export class Parser {
             return;
         const trailing = [];
         const remaining = [];
-        for (const comment of this.commentBuffer) {
-            // 同一行的视为 trailing，不同一行的留作下一节点的 leading
+        // 同一行的视为 trailing，不同一行的留作下一节点的 leading
+        for (const comment of this.commentBuffer)
             (comment.line === anchorToken.line ? trailing : remaining).push(comment);
-        }
         if (trailing.length)
             (node.trailingComments ??= []).push(...trailing);
         // 将非 trailing 的悄悄话保留为新的 commentBuffer
         this.commentBuffer = remaining;
     }
-    endLoc(token) {
-        token ??= this.lookBack();
-        return { endLine: token.line, endCol: token.col + token.value.length };
+    endLoc({ endLine, endCol } = this.lookBack()) {
+        return { endLine, endCol };
     }
     reportError(error) {
         if (this.MODE !== 1 /* ParseMode.TOLERANT */)
@@ -163,9 +173,9 @@ export class Parser {
      */
     makeErrorTail(kind, why, where) {
         // 找到前一个 token 做锚点
-        const prevToken = this.lookBack();
-        const fakeTermToken = tokenTrailing(prevToken, kind);
-        const errMsg = `${where ?? `在「${prevToken.value}」后`}${why}`;
+        const { endLine, endCol, value } = this.lookBack();
+        const fakeTermToken = newToken(kind, '', endLine, endCol, endLine, endCol);
+        const errMsg = `${where ?? `在「${value}」后`}${why}`;
         this.reportError(syntaxErrorFrom(fakeTermToken, errMsg));
         return fakeTermToken;
     }
@@ -177,32 +187,31 @@ export class Parser {
         return this.makeErrorTail(kind, why, where);
     }
     synchronize() {
-        // 首先尝试找到 TERMINATOR 或语句开始
-        for (let tokenKind = this.current().kind; tokenKind !== 35 /* TokenKind.EOF */; tokenKind = this.next().kind) {
+        // 首先尝试找到 TERMINATOR 或语句开始，跳过闭块符，顺便捕获块配对问题
+        for (let tokenKind = this.current().kind; tokenKind !== 44 /* TokenKind.EOF */; tokenKind = this.next().kind) {
             if (tokenKind === 24 /* TokenKind.TERMINATOR */)
                 return void this.advance();
             if (isStartToken(tokenKind))
                 return;
-            if (tokenKind === 23 /* TokenKind.BLOCK_END */ || tokenKind === 21 /* TokenKind.COLLECTION_END */) {
-                const depthIndex = +(tokenKind === 21 /* TokenKind.COLLECTION_END */);
-                if (this.blockDepth[depthIndex] > 0)
-                    return;
-                const token = this.current();
-                this.errors.push(syntaxErrorFrom(token, `这个「${token.value}」被孤立了喵！`));
-                this.blockDepth[depthIndex] = 0; // 龟苓膏之术，对症下药喵
-            }
+            const depthIndex = +(tokenKind === 21 /* TokenKind.COLLECTION_END */);
+            if (!depthIndex && tokenKind !== 23 /* TokenKind.BLOCK_END */)
+                continue;
+            if (this.blockDepth[depthIndex] > 0)
+                return;
+            const token = this.current();
+            this.reportError(syntaxErrorFrom(token, `这个「${token.value}」被孤立了喵！`));
+            this.blockDepth[depthIndex] = 0; // 龟苓膏之术，对症下药喵
         }
     }
     // 用于 parseExpression 内部：跳到 terminator / statement start / EOF
     consumeToRecoveryPoint() {
-        for (let tokenKind = this.current().kind; tokenKind !== 35 /* TokenKind.EOF */ && tokenKind !== 24 /* TokenKind.TERMINATOR */ && !isStartToken(tokenKind); tokenKind = this.next().kind)
+        for (let tokenKind = this.current().kind; tokenKind !== 44 /* TokenKind.EOF */ && tokenKind !== 24 /* TokenKind.TERMINATOR */ && !isStartToken(tokenKind); tokenKind = this.next().kind)
             ;
     }
     parse() {
-        const startToken = this.current();
-        const { kind: startKind, line, col } = startToken;
-        const program = { kind: 1 /* NodeKind.Program */, body: [], line, col, endLine: line, endCol: col };
-        for (let tokenKind = startKind; tokenKind !== 35 /* TokenKind.EOF */; tokenKind = this.current().kind) {
+        const { kind: startKind, line, col, endLine, endCol } = this.current();
+        const program = { kind: 1 /* NodeKind.Program */, body: [], line, col, endLine, endCol };
+        for (let tokenKind = startKind; tokenKind !== 44 /* TokenKind.EOF */; tokenKind = this.current().kind) {
             if (tokenKind === 24 /* TokenKind.TERMINATOR */)
                 this.advance();
             else
@@ -214,9 +223,7 @@ export class Parser {
             (lastStatement.trailingComments ??= []).push(...this.commentBuffer);
             this.commentBuffer = [];
         }
-        const { line: endLine, col: endCol, value: endValue } = this.tokens[this.position - 1] ?? startToken;
-        program.endLine = endLine;
-        program.endCol = endCol + endValue.length;
+        ({ endLine: program.endLine, endCol: program.endCol } = this.tokens[Math.max(0, this.position - 1)]);
         return { program, errors: this.errors };
     }
     parseStatement() {
@@ -268,7 +275,7 @@ export class Parser {
             return node;
         }
         catch (e) {
-            const error = e instanceof MeaoiuError ? e : syntaxErrorFrom(startToken, e instanceof Error ? e.message : String(e));
+            const error = e instanceof MeaoiuError ? e : errorFrom(startToken, String(e), 0 /* Phase.UNKNOWN */);
             this.reportError(error);
             this.synchronize();
             return errorNodeWith(error);
@@ -284,10 +291,9 @@ export class Parser {
             : undefined;
         return { kind: 2 /* NodeKind.VariableDeclaration */, identifier, initialization, line, col, ...this.endLoc() };
     }
-    parseAssignmentStatement(assignee, operatorKind) {
+    parseAssignmentStatement(assignee, operator) {
         this.advance();
         const value = this.parseExpression();
-        const operator = assignMap[operatorKind]; // 调用前已检查词元类型
         const { line, col } = assignee;
         return { kind: 3 /* NodeKind.AssignmentStatement */, assignee, value, operator, line, col, ...this.endLoc() };
     }
@@ -326,34 +332,30 @@ export class Parser {
     parseLogicalExpression() {
         let left = this.parseSequenceExpression();
         // 循环处理连续的逻辑操作：A 和 B 都好 或 C 不坏
-        for (let tokenKind = this.current().kind, isOr; (isOr = tokenKind === 29 /* TokenKind.LOGIC_OR */) || tokenKind === 28 /* TokenKind.LOGIC_AND */; tokenKind = this.current().kind) {
+        for (let tokenKind = this.current().kind, isOr; (isOr = tokenKind === 38 /* TokenKind.LOGIC_OR */) || tokenKind === 37 /* TokenKind.LOGIC_AND */; tokenKind = this.current().kind) {
             this.advance();
             const right = this.parseLogicalExpression();
             const closeToken = this.current();
-            let operator;
-            switch (closeToken.kind) {
-                case 31 /* TokenKind.LOGIC_CLOSE_OR */:
-                    operator = 1 /* LogicalOperator.OR */;
+            const operator = closeToken.kind;
+            switch (operator) {
+                case 40 /* TokenKind.LOGIC_CLOSE_OR */:
                     if (!isOr)
                         this.reportError(syntaxErrorFrom(closeToken, '逻辑「和」不能用「不坏」闭合喵！'));
                     break;
-                case 33 /* TokenKind.LOGIC_CLOSE_NAND */:
-                    operator = 2 /* LogicalOperator.NAND */;
+                case 42 /* TokenKind.LOGIC_CLOSE_NAND */:
                     if (!isOr)
                         this.reportError(syntaxErrorFrom(closeToken, '逻辑「和」不能用「不好」闭合喵！'));
                     break;
-                case 30 /* TokenKind.LOGIC_CLOSE_AND */:
-                    operator = 0 /* LogicalOperator.AND */;
+                case 39 /* TokenKind.LOGIC_CLOSE_AND */:
                     if (isOr)
                         this.reportError(syntaxErrorFrom(closeToken, '逻辑「或」不能用「都好」闭合喵！'));
                     break;
-                case 32 /* TokenKind.LOGIC_CLOSE_NOR */:
-                    operator = 3 /* LogicalOperator.NOR */;
+                case 41 /* TokenKind.LOGIC_CLOSE_NOR */:
                     if (isOr)
                         this.reportError(syntaxErrorFrom(closeToken, '逻辑「或」不能用「都坏」闭合喵！'));
                     break;
-                case 29 /* TokenKind.LOGIC_OR */:
-                case 28 /* TokenKind.LOGIC_AND */:
+                case 38 /* TokenKind.LOGIC_OR */:
+                case 37 /* TokenKind.LOGIC_AND */:
                     throw errorFrom(closeToken, '你不该看到这个喵！', 1 /* Phase.INVARIANT */);
                 default:
                     const [logic, close, nClose] = isOr ? ['或', '不坏', '不好'] : ['和', '都好', '都坏'];
@@ -362,7 +364,7 @@ export class Parser {
             }
             this.advance();
             const { line, col } = left;
-            left = { kind: 20 /* NodeKind.LogicalExpression */, left, right, operator, line, col, ...this.endLoc() };
+            left = { kind: 23 /* NodeKind.LogicalExpression */, left, right, operator, line, col, ...this.endLoc() };
         }
         return left;
     }
@@ -370,43 +372,44 @@ export class Parser {
         const { line, col } = this.current();
         const sections = [this.parseComparisonExpression()];
         const operators = [];
-        let modeMask = 0b0_00; // 000 算术模式 | 100 比较模式
-        for (let token; (token = this.current()).kind === 26 /* TokenKind.OPERATOR */ && this.peek().kind === 27 /* TokenKind.COMMA */;) {
-            const op = token.value;
-            switch (modeMask | (+OP_ARITH.has(op) << 1 || +OP_COMP_E.has(op))) {
-                // 模式对应：
-                case 0b101: // 1 比较模式|0 无算术|1 有比较
-                case 0b010: // 0 算术模式|1 有算术|0 无比较
-                    break;
-                // 模式变换：
-                case 0b001: // 0 算术模式|0 无算术|1 有比较
-                    modeMask = 0b1_00; // 切为比较模式
+        sequence: for (let isArithmeticMode = true; this.peek().kind === 36 /* TokenKind.COMMA */;) {
+            const token = this.current();
+            switch (token.kind) {
+                case 26 /* TokenKind.ARITHMETIC_PLUS */:
+                case 27 /* TokenKind.ARITHMETIC_MINUS */:
+                case 28 /* TokenKind.ARITHMETIC_MULTIPLY */:
+                case 29 /* TokenKind.ARITHMETIC_DIVIDE */:
+                    if (isArithmeticMode)
+                        break; // 模式正确
+                    throw syntaxErrorFrom(token, '比较之后就不能做算术了喵！');
+                case 30 /* TokenKind.COMPARISON_EQUAL */:
+                case 31 /* TokenKind.COMPARISON_NOT_EQUAL */:
+                    isArithmeticMode = false; // 禁用算术模式
                     break;
-                case 0b110: // 1 比较模式|1 有算术|0 无比较
-                    throw syntaxErrorFrom(token, '比较之后就不能做算术了喵!');
-                // 符号非法：
-                case 0b000: // 0 算术模式|0 无算术|0 无比较
-                case 0b100: // 1 比较模式|0 无算术|0 无比较
-                    throw syntaxErrorFrom(token, `'${op}' 不能用在节之间喵!`);
-                // 以下状态理论不可达：
-                case 0b011: // 0 算术模式|1 有算术|1 有比较
-                case 0b111: // 1 比较模式|1 有算术|1 有比较
-                    throw errorFrom(token, '物理学不存在了喵！', 1 /* Phase.INVARIANT */);
+                case 32 /* TokenKind.COMPARISON_GREATER */:
+                case 33 /* TokenKind.COMPARISON_LESS */:
+                case 34 /* TokenKind.COMPARISON_GREATER_EQUAL */:
+                case 35 /* TokenKind.COMPARISON_LESS_EQUAL */:
+                    throw syntaxErrorFrom(token, `'${token.value}' 不能用在节之间喵！`);
+                default:
+                    break sequence;
             }
-            operators.push(this.advance());
+            this.advance(); // 消费操作符
             this.advance(); // 跳过逗号
+            operators.push(token);
             sections.push(this.parseComparisonExpression());
         }
         if (sections.length === 1)
             return sections[0];
-        return { kind: 19 /* NodeKind.SequenceExpression */, sections, operators, line, col, ...this.endLoc() };
+        return { kind: 22 /* NodeKind.SequenceExpression */, sections, operators, line, col, ...this.endLoc() };
     }
     parseComparisonExpression() {
         const { line, col } = this.current();
         const expressions = [this.parseAdditiveExpression()];
         const operators = [];
-        while (OP_COMP.has(this.current().value) && this.peek().kind !== 27 /* TokenKind.COMMA */) {
-            operators.push(this.advance());
+        for (let token; isComparisonToken((token = this.current())) && this.peek().kind !== 36 /* TokenKind.COMMA */;) {
+            this.advance();
+            operators.push(token);
             expressions.push(this.parseAdditiveExpression());
         }
         // 如果没有比较（只有一个操作数），就返回那个操作数本身
@@ -417,21 +420,19 @@ export class Parser {
     }
     parseAdditiveExpression() {
         let left = this.parseMultiplicativeExpression();
-        for (let token = this.current(); (token.value === '+' || token.value === '-') && this.peek().kind !== 27 /* TokenKind.COMMA */; token = this.current()) {
-            this.advance();
+        for (let token; isAdditiveToken((token = this.current())) && this.peek().kind !== 36 /* TokenKind.COMMA */;) {
+            const { line, col } = this.advance();
             const right = this.parseMultiplicativeExpression();
-            const { line, col, value: operator } = token;
-            left = { kind: 17 /* NodeKind.ArithmeticExpression */, left, operator, right, line, col, ...this.endLoc(token) };
+            left = { kind: 20 /* NodeKind.ArithmeticExpression */, left, operator: token, right, line, col, ...this.endLoc(token) };
         }
         return left;
     }
     parseMultiplicativeExpression() {
         let left = this.parseUnaryExpression();
-        for (let token = this.current(); (token.value === '*' || token.value === '/') && this.peek().kind !== 27 /* TokenKind.COMMA */; token = this.current()) {
-            this.advance();
+        for (let token; isMultiplicativeToken((token = this.current())) && this.peek().kind !== 36 /* TokenKind.COMMA */;) {
+            const { line, col } = this.advance();
             const right = this.parseUnaryExpression();
-            const { line, col, value: operator } = token;
-            left = { kind: 17 /* NodeKind.ArithmeticExpression */, left, operator, right, line, col, ...this.endLoc(token) };
+            left = { kind: 20 /* NodeKind.ArithmeticExpression */, left, operator: token, right, line, col, ...this.endLoc(token) };
         }
         return left;
     }
@@ -440,10 +441,10 @@ export class Parser {
         let operator;
         switch (tokenKind) {
             case 5 /* TokenKind.KEYWORD_CLONE */:
-                operator = 1 /* AssignmentOperator.COPY */;
+                operator = 3 /* TokenKind.ASSIGNMENT_LIKE */;
                 break;
             case 6 /* TokenKind.KEYWORD_MOVE */:
-                operator = 2 /* AssignmentOperator.MOVE */;
+                operator = 4 /* TokenKind.ASSIGNMENT_ONLY */;
                 break;
             default:
                 return this.parseMemberAccessExpression();
@@ -451,7 +452,7 @@ export class Parser {
         this.advance();
         // 递归调用，这样就可以处理像“高仿 高仿 a”这样的写法
         const argument = this.parseUnaryExpression();
-        return { kind: 23 /* NodeKind.UnaryExpression */, operator, argument, line, col, ...this.endLoc() };
+        return { kind: 19 /* NodeKind.UnaryExpression */, operator, argument, line, col, ...this.endLoc() };
     }
     parseMemberAccessExpression() {
         let object = this.parsePrimaryExpression();
@@ -464,7 +465,7 @@ export class Parser {
             }
             const property = this.parsePrimaryExpression();
             const { line, col } = startToken;
-            object = { kind: 22 /* NodeKind.MemberAccessExpression */, object, property, line, col, ...this.endLoc() };
+            object = { kind: 18 /* NodeKind.MemberAccessExpression */, object, property, line, col, ...this.endLoc() };
         }
         return object;
     }
@@ -475,7 +476,13 @@ export class Parser {
         let node;
         switch (tokenKind) {
             case 15 /* TokenKind.NUMBER */:
-                node = { kind: 9 /* NodeKind.NumericLiteral */, value: parseFloat(value), line, col, ...this.endLoc(startToken) };
+                node = {
+                    kind: 9 /* NodeKind.NumericLiteral */,
+                    value: Number.parseFloat(value),
+                    line,
+                    col,
+                    ...this.endLoc(startToken),
+                };
                 break;
             case 16 /* TokenKind.STRING */:
                 node = { kind: 10 /* NodeKind.StringLiteral */, value, line, col, ...this.endLoc(startToken) };
@@ -498,10 +505,12 @@ export class Parser {
             case 9 /* TokenKind.KEYWORD_LOOP */:
                 return this.parseLoopExpression();
             case 24 /* TokenKind.TERMINATOR */:
-            case 35 /* TokenKind.EOF */:
+            case 44 /* TokenKind.EOF */:
                 throw syntaxErrorFrom(startToken, '只说半句看不懂喵！');
+            case 0 /* TokenKind.ERROR */:
+                throw errorFrom(startToken, `这个词不对劲喵：${value}`, 2 /* Phase.LEXICAL */);
             default:
-                throw syntaxErrorFrom(startToken, `看不懂的把戏喵: ${value}`);
+                throw syntaxErrorFrom(startToken, `看不懂的把戏喵：${value}`);
         }
         this.advance();
         if (leading.length)
@@ -519,7 +528,7 @@ export class Parser {
         const statementParser = isCollection ? () => this.parseCollectionElement() : () => this.parseStatement();
         const body = [];
         this.blockDepth[modeSwitch]++;
-        for (let tokenKind = this.current().kind; tokenKind !== endKind && tokenKind !== 35 /* TokenKind.EOF */; tokenKind = this.next().kind) {
+        for (let tokenKind = this.current().kind; tokenKind !== endKind && tokenKind !== 44 /* TokenKind.EOF */; tokenKind = this.next().kind) {
             if (tokenKind === separatorKind) {
                 if (isCollection)
                     this.makeErrorTail(0 /* TokenKind.ERROR */, `这个「${this.current().value}」是多余的喵！`);
@@ -572,7 +581,10 @@ export class Parser {
         const { line, col } = this.advance();
         const args = this.parseExpression();
         const callee = this.parseIdentifier();
-        return { kind: 18 /* NodeKind.CallExpression */, args, callee, line, col, ...this.endLoc() };
+        return { kind: 17 /* NodeKind.CallExpression */, args, callee, line, col, ...this.endLoc() };
     }
 }
+export function parse(tokens, mode = 0 /* ParseMode.STRICT */) {
+    return new Parser(tokens, mode).parse();
+}
 //# sourceMappingURL=parser.js.map