@minduscript/parser 1.0.0

package/.npmignore

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

package/dist/exe.d.ts

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

package/dist/exe.js

@@ -0,0 +1,75 @@
+#!/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 lexer_1 = require("@minduscript/lexer");
+const lexer_2 = require("@minduscript/lexer/dist/lexer");
+const chlamydomonos_parser_1 = require("chlamydomonos-parser");
+const commander_1 = require("commander");
+const fs_1 = __importDefault(require("fs"));
+const nodes_1 = require("./nodes");
+const parser_1 = require("./parser");
+commander_1.program
+    .option('-o, --output <string>', '输出文件，若不存在则输出到标准输出')
+    .option('-r, --raw', '输出可被编译器使用的原始语法树')
+    .option('-i, --input-raw', '输入包含原始Token流的Json文件')
+    .argument('[inputFile]', '输入文件，若不存在则则读取标准输入')
+    .action(function (input) {
+    const options = this.opts();
+    const output = options.output;
+    const raw = options.raw ?? false;
+    const inputRaw = options.inputRaw ?? false;
+    let inputData;
+    if (input) {
+        inputData = fs_1.default.readFileSync(input, { encoding: 'utf-8' });
+    }
+    else {
+        inputData = process.stdin.read();
+    }
+    try {
+        let tokens;
+        if (inputRaw) {
+            tokens = JSON.parse(inputData);
+        }
+        else {
+            tokens = lexer_1.lexer.lexString(inputData);
+        }
+        const ast = parser_1.parser.parse(tokens);
+        let outputData;
+        if (raw) {
+            outputData = JSON.stringify(ast);
+        }
+        else {
+            outputData = JSON.stringify(ast, (key, value) => {
+                if (key == 'tokens') {
+                    return undefined;
+                }
+                if (key == 'type') {
+                    return nodes_1.NodeType[value];
+                }
+                return value;
+            }, 4);
+        }
+        if (output) {
+            fs_1.default.writeFileSync(output, outputData, { encoding: 'utf-8' });
+        }
+        else {
+            console.log(outputData);
+        }
+    }
+    catch (e) {
+        if (e instanceof lexer_2.LexError) {
+            console.error(e.message);
+            process.exit(1);
+        }
+        else if (e instanceof chlamydomonos_parser_1.ParserError) {
+            console.error(e.message);
+            process.exit(1);
+        }
+        throw e;
+    }
+})
+    .parse();
+//# sourceMappingURL=exe.js.map

package/dist/expression-parser.d.ts

@@ -0,0 +1,25 @@
+import { type Token } from '@minduscript/lexer';
+import type { ExpressionNode } from './nodes';
+declare class ExpressionParser {
+    private readonly L_PAREN;
+    private readonly R_PAREN;
+    private readonly COMMA;
+    private readonly unaryOperators;
+    private readonly binaryOperators;
+    private readonly functions;
+    private readonly literals;
+    private readonly identifiers;
+    private buildUnaryOp;
+    private buildBinaryOp;
+    private buildFunction;
+    private buildMacro;
+    private buildLiteral;
+    private buildIdentifier;
+    private buildDefinedIdentifier;
+    parse(tokens: Token[], from: number): {
+        node: Omit<ExpressionNode, 'type'>;
+        next: number;
+    };
+}
+export declare const expressionParser: ExpressionParser['parse'];
+export {};

package/dist/expression-parser.js

@@ -0,0 +1,349 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expressionParser = void 0;
+const lexer_1 = require("@minduscript/lexer");
+const nodes_1 = require("./nodes");
+var Associativity;
+(function (Associativity) {
+    Associativity[Associativity["LEFT"] = 0] = "LEFT";
+    Associativity[Associativity["RIGHT"] = 1] = "RIGHT";
+})(Associativity || (Associativity = {}));
+const MIN_NODE_TYPE = nodes_1.NodeType.DOCUMENT;
+class ExpressionParser {
+    L_PAREN = lexer_1.TokenType.L_PAREN;
+    R_PAREN = lexer_1.TokenType.R_PAREN;
+    COMMA = lexer_1.TokenType.COMMA;
+    // 一元运算符，对应的值为运算符优先级
+    unaryOperators = {
+        [lexer_1.TokenType.NOT]: 3,
+        [lexer_1.TokenType.FLIP]: 11,
+    };
+    // 二元运算符
+    binaryOperators = {
+        [lexer_1.TokenType.OR]: { priority: 1, associativity: Associativity.LEFT },
+        [lexer_1.TokenType.AND]: { priority: 2, associativity: Associativity.LEFT },
+        [lexer_1.TokenType.EQ]: { priority: 4, associativity: Associativity.LEFT },
+        [lexer_1.TokenType.NE]: { priority: 4, associativity: Associativity.LEFT },
+        [lexer_1.TokenType.LESS]: { priority: 4, associativity: Associativity.LEFT },
+        [lexer_1.TokenType.LE]: { priority: 4, associativity: Associativity.LEFT },
+        [lexer_1.TokenType.GREATER]: { priority: 4, associativity: Associativity.LEFT },
+        [lexer_1.TokenType.GE]: { priority: 4, associativity: Associativity.LEFT },
+        [lexer_1.TokenType.STRICT_EQ]: { priority: 4, associativity: Associativity.LEFT },
+        [lexer_1.TokenType.BITOR]: { priority: 5, associativity: Associativity.LEFT },
+        [lexer_1.TokenType.XOR]: { priority: 6, associativity: Associativity.LEFT },
+        [lexer_1.TokenType.BITAND]: { priority: 7, associativity: Associativity.LEFT },
+        [lexer_1.TokenType.SHL]: { priority: 8, associativity: Associativity.LEFT },
+        [lexer_1.TokenType.SHR]: { priority: 8, associativity: Associativity.LEFT },
+        [lexer_1.TokenType.ADD]: { priority: 9, associativity: Associativity.LEFT },
+        [lexer_1.TokenType.SUB]: { priority: 9, associativity: Associativity.LEFT },
+        [lexer_1.TokenType.MUL]: { priority: 10, associativity: Associativity.LEFT },
+        [lexer_1.TokenType.DIV]: { priority: 10, associativity: Associativity.LEFT },
+        [lexer_1.TokenType.IDIV]: { priority: 10, associativity: Associativity.LEFT },
+        [lexer_1.TokenType.MOD]: { priority: 10, associativity: Associativity.LEFT },
+        [lexer_1.TokenType.POW]: { priority: 12, associativity: Associativity.RIGHT },
+    };
+    // 函数，对应的值为参数个数
+    functions = {
+        [lexer_1.TokenType.MAX]: 2,
+        [lexer_1.TokenType.MIN]: 2,
+        [lexer_1.TokenType.ANGLE]: 2,
+        [lexer_1.TokenType.ANGLE_DIFF]: 2,
+        [lexer_1.TokenType.LEN]: 2,
+        [lexer_1.TokenType.NOISE]: 2,
+        [lexer_1.TokenType.ABS]: 1,
+        [lexer_1.TokenType.LOG]: 1,
+        [lexer_1.TokenType.LOG10]: 1,
+        [lexer_1.TokenType.FLOOR]: 1,
+        [lexer_1.TokenType.CEIL]: 1,
+        [lexer_1.TokenType.SQRT]: 1,
+        [lexer_1.TokenType.RAND]: 1,
+        [lexer_1.TokenType.SIN]: 1,
+        [lexer_1.TokenType.COS]: 1,
+        [lexer_1.TokenType.TAN]: 1,
+        [lexer_1.TokenType.ASIN]: 1,
+        [lexer_1.TokenType.ACOS]: 1,
+        [lexer_1.TokenType.ATAN]: 1,
+    };
+    // 字面量
+    literals = {
+        [lexer_1.TokenType.NUMBER]: (token) => parseFloat(token.raw),
+        [lexer_1.TokenType.STRING]: (token) => JSON.parse(token.raw),
+        [lexer_1.TokenType.TRUE]: (_) => true,
+        [lexer_1.TokenType.FALSE]: (_) => false,
+        [lexer_1.TokenType.NULL]: (_) => null,
+    };
+    identifiers = {
+        [lexer_1.TokenType.IDENTIFIER]: (token) => ({
+            type: nodes_1.NodeType.IDENTIFIER_EXPRESSION,
+            tokens: [token],
+            value: token.raw,
+            identifierType: nodes_1.IdentifierType.SIMPLE,
+            isMindustry: false,
+        }),
+        [lexer_1.TokenType.MINDUSTRY_IDENTIFIER]: (token) => ({
+            type: nodes_1.NodeType.IDENTIFIER_EXPRESSION,
+            tokens: [token],
+            value: token.raw,
+            isMindustry: true,
+        }),
+    };
+    buildUnaryOp = (token, child) => ({
+        type: nodes_1.NodeType.UNARY_OP_EXPRESSION,
+        tokens: [token, ...child.tokens],
+        opType: token.type,
+        child,
+    });
+    buildBinaryOp = (token, lChild, rChild) => ({
+        type: nodes_1.NodeType.BINARY_OP_EXPRESSION,
+        tokens: [...lChild.tokens, token, ...rChild.tokens],
+        opType: token.type,
+        lChild,
+        rChild,
+    });
+    buildFunction = (token, children, // 包含所有成分，如解析`max(a + b, c)`时，传入['(', 'a + b', ',', 'c', ')']
+    args) => ({
+        type: nodes_1.NodeType.FUNCTION_CALL_EXPRESSION,
+        tokens: children.flatMap((c) => {
+            if (c.type < MIN_NODE_TYPE) {
+                return [c];
+            }
+            else {
+                return c.tokens;
+            }
+        }),
+        function: token.type,
+        args,
+    });
+    buildMacro = (token, children, inputArgs, outputArgs) => ({
+        type: nodes_1.NodeType.MACRO_CALL_EXPRESSION,
+        tokens: children.flatMap((c) => {
+            if (c.type < MIN_NODE_TYPE) {
+                return [c];
+            }
+            else {
+                return c.tokens;
+            }
+        }),
+        name: token.raw,
+        inputArgs,
+        outputArgs,
+    });
+    buildLiteral = (token) => {
+        const factory = this.literals[token.type];
+        if (!factory) {
+            throw Error();
+        }
+        return {
+            type: nodes_1.NodeType.LITERAL_EXPRESSION,
+            tokens: [token],
+            value: factory(token),
+        };
+    };
+    buildIdentifier = (token) => {
+        const factory = this.identifiers[token.type];
+        if (!factory) {
+            throw Error();
+        }
+        return factory(token);
+    };
+    buildDefinedIdentifier = (definitionToken, identifierToken) => ({
+        type: nodes_1.NodeType.IDENTIFIER_EXPRESSION,
+        tokens: [definitionToken, identifierToken],
+        value: identifierToken.raw,
+        identifierType: definitionToken.type === lexer_1.TokenType.LET ? nodes_1.IdentifierType.LET : nodes_1.IdentifierType.CONST,
+        isMindustry: false,
+    });
+    parse(tokens, from) {
+        const isTerminator = (tokenType) => {
+            return (tokenType === this.COMMA ||
+                tokenType === this.R_PAREN ||
+                tokenType === lexer_1.TokenType.SEMICOLON ||
+                tokenType === lexer_1.TokenType.R_BRACE);
+        };
+        const error = (message, index) => {
+            const token = tokens[index];
+            if (!token) {
+                return new Error(`${message} at end of input`);
+            }
+            return new Error(`${message} at ${token.row}:${token.col}`);
+        };
+        const parseIdentifierList = (startIndex, lParenToken) => {
+            const children = [lParenToken];
+            const identifiers = [];
+            let index = startIndex;
+            if (index >= tokens.length) {
+                throw error('Unclosed parenthesized identifier list', startIndex - 1);
+            }
+            if (tokens[index].type === this.R_PAREN) {
+                children.push(tokens[index]);
+                return { children, identifiers, next: index + 1 };
+            }
+            while (index < tokens.length) {
+                const token = tokens[index];
+                let identifierNode;
+                if (token.type === lexer_1.TokenType.LET || token.type === lexer_1.TokenType.CONST) {
+                    const identifierToken = tokens[index + 1];
+                    if (!identifierToken || identifierToken.type !== lexer_1.TokenType.IDENTIFIER) {
+                        throw error('Expected identifier after "let" or "const" in macro output arguments', index + 1);
+                    }
+                    identifierNode = this.buildDefinedIdentifier(token, identifierToken);
+                    index += 2;
+                }
+                else if (token.type === lexer_1.TokenType.IDENTIFIER || token.type === lexer_1.TokenType.MINDUSTRY_IDENTIFIER) {
+                    identifierNode = this.buildIdentifier(token);
+                    index += 1;
+                }
+                else {
+                    throw error('Expected identifier or "let"/"const" definition in macro output arguments', index);
+                }
+                identifiers.push(identifierNode);
+                children.push(identifierNode);
+                if (index >= tokens.length) {
+                    throw error('Unclosed parenthesized identifier list', index - 1);
+                }
+                const separator = tokens[index];
+                if (separator.type === this.COMMA) {
+                    children.push(separator);
+                    index += 1;
+                    continue;
+                }
+                if (separator.type === this.R_PAREN) {
+                    children.push(separator);
+                    return { children, identifiers, next: index + 1 };
+                }
+                throw error('Expected "," or ")" in macro output arguments', index);
+            }
+            throw error('Unclosed parenthesized identifier list', index - 1);
+        };
+        const parseExpressionList = (startIndex, lParenToken) => {
+            const children = [lParenToken];
+            const args = [];
+            let index = startIndex;
+            if (index >= tokens.length) {
+                throw error('Unclosed parenthesized expression list', startIndex - 1);
+            }
+            if (tokens[index].type === this.R_PAREN) {
+                children.push(tokens[index]);
+                return { children, args, next: index + 1 };
+            }
+            while (index < tokens.length) {
+                const parsed = parseExpression(index, 0);
+                args.push(parsed.node);
+                children.push(parsed.node);
+                index = parsed.next;
+                if (index >= tokens.length) {
+                    throw error('Unclosed parenthesized expression list', index - 1);
+                }
+                const separator = tokens[index];
+                if (separator.type === this.COMMA) {
+                    children.push(separator);
+                    index += 1;
+                    continue;
+                }
+                if (separator.type === this.R_PAREN) {
+                    children.push(separator);
+                    return { children, args, next: index + 1 };
+                }
+                throw error('Expected "," or ")" in argument list', index);
+            }
+            throw error('Unclosed parenthesized expression list', index - 1);
+        };
+        const parsePrimary = (startIndex) => {
+            const token = tokens[startIndex];
+            if (!token) {
+                throw error('Expected expression', startIndex);
+            }
+            const literalFactory = this.literals[token.type];
+            if (literalFactory) {
+                return { node: this.buildLiteral(token), next: startIndex + 1 };
+            }
+            const functionArgCount = this.functions[token.type];
+            if (functionArgCount !== undefined) {
+                const lParenIndex = startIndex + 1;
+                const lParen = tokens[lParenIndex];
+                if (!lParen || lParen.type !== this.L_PAREN) {
+                    throw error('Expected "(" after function name', lParenIndex);
+                }
+                const parsedArgs = parseExpressionList(lParenIndex + 1, lParen);
+                if (parsedArgs.args.length !== functionArgCount) {
+                    throw error(`Function \"${token.raw}\" expects ${functionArgCount} argument(s), but got ${parsedArgs.args.length}`, lParenIndex);
+                }
+                return {
+                    node: this.buildFunction(token, [token, ...parsedArgs.children], parsedArgs.args),
+                    next: parsedArgs.next,
+                };
+            }
+            const identifierFactory = this.identifiers[token.type];
+            if (identifierFactory) {
+                if (token.type === lexer_1.TokenType.IDENTIFIER) {
+                    const lParen1 = tokens[startIndex + 1];
+                    if (lParen1 && lParen1.type === this.L_PAREN) {
+                        const parsedInputArgs = parseExpressionList(startIndex + 2, lParen1);
+                        const lParen2 = tokens[parsedInputArgs.next];
+                        if (!lParen2 || lParen2.type !== this.L_PAREN) {
+                            throw error('Expected second "(" for macro output arguments', parsedInputArgs.next);
+                        }
+                        const parsedOutputArgs = parseIdentifierList(parsedInputArgs.next + 1, lParen2);
+                        return {
+                            node: this.buildMacro(token, [token, ...parsedInputArgs.children, ...parsedOutputArgs.children], parsedInputArgs.args, parsedOutputArgs.identifiers),
+                            next: parsedOutputArgs.next,
+                        };
+                    }
+                }
+                return { node: this.buildIdentifier(token), next: startIndex + 1 };
+            }
+            if (token.type === this.L_PAREN) {
+                const parsed = parseExpression(startIndex + 1, 0);
+                const rParen = tokens[parsed.next];
+                if (!rParen || rParen.type !== this.R_PAREN) {
+                    throw error('Expected ")" to close parenthesized expression', parsed.next);
+                }
+                return {
+                    node: {
+                        ...parsed.node,
+                        tokens: [token, ...parsed.node.tokens, rParen],
+                    },
+                    next: parsed.next + 1,
+                };
+            }
+            throw error('Expected expression', startIndex);
+        };
+        const parseExpression = (startIndex, minPriority) => {
+            let index = startIndex;
+            const unaryToken = tokens[index];
+            const unaryPriority = unaryToken ? this.unaryOperators[unaryToken.type] : undefined;
+            let left;
+            if (unaryToken && unaryPriority !== undefined) {
+                const parsedChild = parseExpression(index + 1, unaryPriority);
+                left = this.buildUnaryOp(unaryToken, parsedChild.node);
+                index = parsedChild.next;
+            }
+            else {
+                const primary = parsePrimary(index);
+                left = primary.node;
+                index = primary.next;
+            }
+            while (index < tokens.length) {
+                const operatorToken = tokens[index];
+                if (isTerminator(operatorToken.type)) {
+                    break;
+                }
+                const operator = this.binaryOperators[operatorToken.type];
+                if (!operator || operator.priority < minPriority) {
+                    break;
+                }
+                const nextMinPriority = operator.associativity === Associativity.LEFT ? operator.priority + 1 : operator.priority;
+                const right = parseExpression(index + 1, nextMinPriority);
+                left = this.buildBinaryOp(operatorToken, left, right.node);
+                index = right.next;
+            }
+            return { node: left, next: index };
+        };
+        const parsed = parseExpression(from, 0);
+        return { node: { child: parsed.node, tokens: parsed.node.tokens }, next: parsed.next };
+    }
+}
+const parserInstance = new ExpressionParser();
+const expressionParser = (tokens, from) => parserInstance.parse(tokens, from);
+exports.expressionParser = expressionParser;
+//# sourceMappingURL=expression-parser.js.map

package/dist/index.d.ts

@@ -0,0 +1,76 @@
+export { parser } from './parser';
+export { NodeType, AssignType, ControlType, RadarCondition, RadarSortConfig, UnitLocateCategory, UnitLocateBuildingGroup, LoopControlType, IdentifierType, StatementType, } from './nodes';
+export type { ASTNode, ASTNodeTypes, DocumentNode, ImportStatementNode, StatementNode, ExpressionNode, UnaryOpType, UnaryOpExpressionNode, BinaryOpType, BinaryOpExpressionNode, Functions, FunctionCallExpressionNode, MacroCallExpressionNode, LiteralExpressionNode, MindustryIdentifierExpressionNode, MinduscriptIdentifierExpressionNode, IdentifierExpressionNode, ExpressionChildNode, } from './nodes';
+import type { NodeType } from './nodes';
+import type * as Nodes from './nodes';
+type StatementNodeReExport<T extends {
+    type: NodeType.SINGLE_STATEMENT | NodeType.BLOCK_STATEMENT;
+}> = T extends any ? Omit<T, 'type'> & {
+    type: NodeType.STATEMENT;
+} : never;
+export type EmptyStatementNode = StatementNodeReExport<Nodes.EmptyStatementNode>;
+export type VariableDefineStatementNode = StatementNodeReExport<Nodes.VariableDefineStatementNode>;
+export type AssignStatementNode = StatementNodeReExport<Nodes.AssignStatementNode>;
+export type StatementNodeRead = StatementNodeReExport<Nodes.StatementNodeRead>;
+export type StatementNodeWrite = StatementNodeReExport<Nodes.StatementNodeWrite>;
+export type StatementNodeDrawClear = StatementNodeReExport<Nodes.StatementNodeDrawClear>;
+export type StatementNodeDrawColor = StatementNodeReExport<Nodes.StatementNodeDrawColor>;
+export type StatementNodeDrawCol = StatementNodeReExport<Nodes.StatementNodeDrawCol>;
+export type StatementNodeDrawStroke = StatementNodeReExport<Nodes.StatementNodeDrawStroke>;
+export type StatementNodeDrawLine = StatementNodeReExport<Nodes.StatementNodeDrawLine>;
+export type StatementNodeDrawRect = StatementNodeReExport<Nodes.StatementNodeDrawRect>;
+export type StatementNodeDrawLineRect = StatementNodeReExport<Nodes.StatementNodeDrawLineRect>;
+export type StatementNodeDrawPoly = StatementNodeReExport<Nodes.StatementNodeDrawPoly>;
+export type StatementNodeDrawLinePoly = StatementNodeReExport<Nodes.StatementNodeDrawLinePoly>;
+export type StatementNodeDrawTriangle = StatementNodeReExport<Nodes.StatementNodeDrawTriangle>;
+export type StatementNodeDrawImage = StatementNodeReExport<Nodes.StatementNodeDrawImage>;
+export type StatementNodePrint = StatementNodeReExport<Nodes.StatementNodePrint>;
+export type StatementNodeDrawFlush = StatementNodeReExport<Nodes.StatementNodeDrawFlush>;
+export type StatementNodePrintFlush = StatementNodeReExport<Nodes.StatementNodePrintFlush>;
+export type StatementNodeGetLink = StatementNodeReExport<Nodes.StatementNodeGetLink>;
+export type StatementNodeSetEnabled = StatementNodeReExport<Nodes.StatementNodeSetEnabled>;
+export type StatementNodeSetShoot = StatementNodeReExport<Nodes.StatementNodeSetShoot>;
+export type StatementNodeSetShootP = StatementNodeReExport<Nodes.StatementNodeSetShootP>;
+export type StatementNodeSetConfig = StatementNodeReExport<Nodes.StatementNodeSetConfig>;
+export type StatementNodeSetColor = StatementNodeReExport<Nodes.StatementNodeSetColor>;
+export type StatementNodeRadar = StatementNodeReExport<Nodes.StatementNodeRadar>;
+export type StatementNodeSensor = StatementNodeReExport<Nodes.StatementNodeSensor>;
+export type StatementNodePackColor = StatementNodeReExport<Nodes.StatementNodePackColor>;
+export type StatementNodeWait = StatementNodeReExport<Nodes.StatementNodeWait>;
+export type StatementNodeCpuStop = StatementNodeReExport<Nodes.StatementNodeCpuStop>;
+export type StatementNodeUnitBind = StatementNodeReExport<Nodes.StatementNodeUnitBind>;
+export type StatementNodeUnitRadar = StatementNodeReExport<Nodes.StatementNodeUnitRadar>;
+export type StatementNodeUnitLocateOre = StatementNodeReExport<Nodes.StatementNodeUnitLocateOre>;
+export type StatementNodeUnitLocateBuilding = StatementNodeReExport<Nodes.StatementNodeUnitLocateBuilding>;
+export type StatementNodeUnitLocateSpawn = StatementNodeReExport<Nodes.StatementNodeUnitLocateSpawn>;
+export type StatementNodeUnitLocateDamaged = StatementNodeReExport<Nodes.StatementNodeUnitLocateDamaged>;
+export type StatementNodeIdle = StatementNodeReExport<Nodes.StatementNodeIdle>;
+export type StatementNodeStop = StatementNodeReExport<Nodes.StatementNodeStop>;
+export type StatementNodeMove = StatementNodeReExport<Nodes.StatementNodeMove>;
+export type StatementNodeApproach = StatementNodeReExport<Nodes.StatementNodeApproach>;
+export type StatementNodePathFind = StatementNodeReExport<Nodes.StatementNodePathFind>;
+export type StatementNodeAutoPathFind = StatementNodeReExport<Nodes.StatementNodeAutoPathFind>;
+export type StatementNodeBoost = StatementNodeReExport<Nodes.StatementNodeBoost>;
+export type StatementNodeTarget = StatementNodeReExport<Nodes.StatementNodeTarget>;
+export type StatementNodeTargetP = StatementNodeReExport<Nodes.StatementNodeTargetP>;
+export type StatementNodeItemDrop = StatementNodeReExport<Nodes.StatementNodeItemDrop>;
+export type StatementNodeItemTake = StatementNodeReExport<Nodes.StatementNodeItemTake>;
+export type StatementNodePayDrop = StatementNodeReExport<Nodes.StatementNodePayDrop>;
+export type StatementNodePayTake = StatementNodeReExport<Nodes.StatementNodePayTake>;
+export type StatementNodePayEnter = StatementNodeReExport<Nodes.StatementNodePayEnter>;
+export type StatementNodeMine = StatementNodeReExport<Nodes.StatementNodeMine>;
+export type StatementNodeFlag = StatementNodeReExport<Nodes.StatementNodeFlag>;
+export type StatementNodeBuild = StatementNodeReExport<Nodes.StatementNodeBuild>;
+export type StatementNodeGetBlock = StatementNodeReExport<Nodes.StatementNodeGetBlock>;
+export type StatementNodeWithin = StatementNodeReExport<Nodes.StatementNodeWithin>;
+export type StatementNodeUnbind = StatementNodeReExport<Nodes.StatementNodeUnbind>;
+export type ControlStatementNode = StatementNodeReExport<Nodes.ControlStatementNode>;
+export type MacroDefineStatementNode = StatementNodeReExport<Nodes.MacroDefineStatementNode>;
+export type MacroCallStatementNode = StatementNodeReExport<Nodes.MacroCallStatementNode>;
+export type IfElseStatementNode = StatementNodeReExport<Nodes.IfElseStatementNode>;
+export type IfStatementNode = StatementNodeReExport<Nodes.IfStatementNode>;
+export type ForStatementNode = StatementNodeReExport<Nodes.ForStatementNode>;
+export type WhileStatementNode = StatementNodeReExport<Nodes.WhileStatementNode>;
+export type LoopControlStatementNode = StatementNodeReExport<Nodes.LoopControlStatementNode>;
+export type ReturnStatementNode = StatementNodeReExport<Nodes.ReturnStatementNode>;
+export type BindStatementNode = StatementNodeReExport<Nodes.BindStatementNode>;

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatementType = exports.IdentifierType = exports.LoopControlType = exports.UnitLocateBuildingGroup = exports.UnitLocateCategory = exports.RadarSortConfig = exports.RadarCondition = exports.ControlType = exports.AssignType = exports.NodeType = exports.parser = void 0;
+var parser_1 = require("./parser");
+Object.defineProperty(exports, "parser", { enumerable: true, get: function () { return parser_1.parser; } });
+var nodes_1 = require("./nodes");
+Object.defineProperty(exports, "NodeType", { enumerable: true, get: function () { return nodes_1.NodeType; } });
+Object.defineProperty(exports, "AssignType", { enumerable: true, get: function () { return nodes_1.AssignType; } });
+Object.defineProperty(exports, "ControlType", { enumerable: true, get: function () { return nodes_1.ControlType; } });
+Object.defineProperty(exports, "RadarCondition", { enumerable: true, get: function () { return nodes_1.RadarCondition; } });
+Object.defineProperty(exports, "RadarSortConfig", { enumerable: true, get: function () { return nodes_1.RadarSortConfig; } });
+Object.defineProperty(exports, "UnitLocateCategory", { enumerable: true, get: function () { return nodes_1.UnitLocateCategory; } });
+Object.defineProperty(exports, "UnitLocateBuildingGroup", { enumerable: true, get: function () { return nodes_1.UnitLocateBuildingGroup; } });
+Object.defineProperty(exports, "LoopControlType", { enumerable: true, get: function () { return nodes_1.LoopControlType; } });
+Object.defineProperty(exports, "IdentifierType", { enumerable: true, get: function () { return nodes_1.IdentifierType; } });
+Object.defineProperty(exports, "StatementType", { enumerable: true, get: function () { return nodes_1.StatementType; } });
+//# sourceMappingURL=index.js.map