qpremake 1.5.1

package/lib/_mods/parserModules/img.d.ts

@@ -0,0 +1,8 @@
+import { DisplayComponent, ParserModule, moduleInputObject, parseOptions } from '../../types/abstract/parser';
+export default class imgModule extends ParserModule {
+    cmdName: string[];
+    requiredAttr: never[][];
+    doCheckRequiredAttr: boolean;
+    private getIconID;
+    evaluate(cmd: string, args: moduleInputObject, option: parseOptions, raw: string): DisplayComponent[];
+}

package/lib/_mods/parserModules/img.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parser_1 = require("../../types/abstract/parser");
+class imgModule extends parser_1.ParserModule {
+    constructor() {
+        super(...arguments);
+        this.cmdName = ['img', 'icon'];
+        this.requiredAttr = [[], []];
+        this.doCheckRequiredAttr = false;
+    }
+    getIconID(key) {
+        let k = key;
+        let x = parser_1.iconID[k];
+        if (!x)
+            return [parser_1.iconID.crash, false];
+        return [x, true];
+    }
+    evaluate(cmd, args, option, raw) {
+        let isInIconMode = false;
+        let str = args.getAttr('id');
+        if (str)
+            isInIconMode = true;
+        else
+            str = args.getAttr('url');
+        if (str)
+            isInIconMode = false;
+        else
+            return [];
+        if (isInIconMode) {
+            let [iconID, isCorrect] = this.getIconID(str);
+            return [
+                new parser_1.IconComponent(iconID, isCorrect ? undefined : `Wrong iconID, received = ${str}`, cmd, raw)
+            ];
+        }
+        else {
+            return [
+                new parser_1.ImageComponent(str, undefined, cmd, raw)
+            ];
+        }
+    }
+}
+exports.default = imgModule;

package/lib/_mods/parserModules/qpOriginal.d.ts

@@ -0,0 +1,5 @@
+import { modPack } from "../../types/abstract/parser";
+declare class qpOriginalPack extends modPack {
+    constructor();
+}
+export default qpOriginalPack;

package/lib/_mods/parserModules/qpOriginal.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const expression_1 = __importDefault(require("./expression"));
+const img_1 = __importDefault(require("./img"));
+const sectionID_1 = __importDefault(require("./sectionID"));
+const tags_1 = __importDefault(require("./tags"));
+const uaddminus_1 = __importDefault(require("./uaddminus"));
+const variantCheck_1 = __importDefault(require("./variantCheck"));
+const parser_1 = require("../../types/abstract/parser");
+class qpOriginalPack extends parser_1.modPack {
+    constructor() {
+        super();
+        this.moduleArr = [
+            new img_1.default(),
+            new sectionID_1.default(),
+            new uaddminus_1.default(),
+            new variantCheck_1.default(),
+            new tags_1.default(),
+            new expression_1.default(),
+        ];
+        this.loadModules();
+    }
+}
+exports.default = qpOriginalPack;

package/lib/_mods/parserModules/sectionID.d.ts

@@ -0,0 +1,13 @@
+import { DisplayComponent, ParserModule, moduleInputObject, parseOptions } from '../../types/abstract/parser';
+import type { nestedTree } from '../../types/misc';
+export default class sectionIDModule extends ParserModule {
+    private quickKeyword;
+    private normalKeyword;
+    private pastKeyword;
+    private colorKeyword;
+    cmdName: string[];
+    requiredAttr: any[];
+    doCheckRequiredAttr: boolean;
+    private recurModify;
+    evaluate(cmd: string, args: moduleInputObject, option: parseOptions, raw: string): nestedTree<DisplayComponent>;
+}

package/lib/_mods/parserModules/sectionID.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parser_1 = require("../../types/abstract/parser");
+class sectionIDModule extends parser_1.ParserModule {
+    constructor() {
+        super(...arguments);
+        this.quickKeyword = ['void', 'decompile', 'pathed', 'exposed', 'exec', 'align', 'cover', 'suspend', 'automate'];
+        this.normalKeyword = ['key', 'physical', 'magic', 'health', 'attack', 'specialbuff'];
+        this.pastKeyword = ['decompiled', 'exec-ed', 'aligned'];
+        this.colorKeyword = ['red', 'green', 'blue', 'white', 'black', 'yellow', 'orange', 'purple'];
+        this.cmdName = [
+            ...this.normalKeyword,
+            ...this.pastKeyword,
+            ...this.quickKeyword,
+            ...this.colorKeyword,
+            'physical2', 'magic2',
+        ];
+        this.requiredAttr = new Array(this.cmdName.length).fill([]);
+        this.doCheckRequiredAttr = false;
+    }
+    recurModify(tree, sectionID, upperCase) {
+        tree.forEach(i => {
+            if (i instanceof parser_1.DisplayComponent) {
+                i.addSectionID(sectionID);
+                if (i.id == parser_1.componentID.text && upperCase) {
+                    i.str = i.str.toUpperCase();
+                }
+            }
+            else {
+                this.recurModify(i, sectionID, upperCase);
+            }
+            ;
+        });
+    }
+    evaluate(cmd, args, option, raw) {
+        let quickFlag = this.quickKeyword.includes(cmd);
+        let addIconFlag = cmd.endsWith('2');
+        let x = cmd;
+        if (addIconFlag)
+            x = x.slice(0, -1);
+        let final = args.getChilren();
+        if (quickFlag && !final.length) {
+            //special behavior
+            // x = x.toLowerCase()
+            return [
+                new parser_1.SymbolComponent("key_" + x, undefined, cmd, raw)
+            ];
+        }
+        this.recurModify(final, x, quickFlag);
+        if (addIconFlag) {
+            final = [final, [new parser_1.IconComponent((x == "physical") ? parser_1.iconID.dmg_phys : parser_1.iconID.dmg_magic, undefined, cmd, raw)]];
+        }
+        return final;
+    }
+}
+exports.default = sectionIDModule;

package/lib/_mods/parserModules/tags.d.ts

@@ -0,0 +1,9 @@
+import { DisplayComponent, ParserModule, moduleInputObject, parseOptions } from '../../types/abstract/parser';
+import type { nestedTree } from '../../types/misc';
+export default class tagsModule extends ParserModule {
+    cmdName: string[];
+    requiredAttr: string[][];
+    doCheckRequiredAttr: boolean;
+    private recurModify;
+    evaluate(cmd: string, args: moduleInputObject, option: parseOptions, raw: string): nestedTree<DisplayComponent>;
+}

package/lib/_mods/parserModules/tags.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parser_1 = require("../../types/abstract/parser");
+class tagsModule extends parser_1.ParserModule {
+    constructor() {
+        super(...arguments);
+        this.cmdName = ["tags"];
+        this.requiredAttr = [["ID"]];
+        this.doCheckRequiredAttr = true;
+    }
+    recurModify(tree, sectionIDs) {
+        tree.forEach(i => {
+            if (i instanceof parser_1.DisplayComponent) {
+                i.addSectionID(sectionIDs);
+            }
+            else {
+                this.recurModify(i, sectionIDs);
+            }
+            ;
+        });
+    }
+    evaluate(cmd, args, option, raw) {
+        let IDs = args.getAttr("ID").split(" ");
+        let final = args.getChilren();
+        this.recurModify(final, IDs);
+        return final;
+    }
+}
+exports.default = tagsModule;

package/lib/_mods/parserModules/uaddminus.d.ts

@@ -0,0 +1,9 @@
+import { DisplayComponent, ParserModule, moduleInputObject, parseOptions } from '../../types/abstract/parser';
+import type { nestedTree } from '../../types/misc';
+export default class uadduminusModule extends ParserModule {
+    cmdName: string[];
+    requiredAttr: never[][];
+    doCheckRequiredAttr: boolean;
+    private recurModify;
+    evaluate(cmd: string, args: moduleInputObject, option: parseOptions, raw: string): nestedTree<DisplayComponent>;
+}

package/lib/_mods/parserModules/uaddminus.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parser_1 = require("../../types/abstract/parser");
+class uadduminusModule extends parser_1.ParserModule {
+    constructor() {
+        super(...arguments);
+        this.cmdName = ['uadd', 'uminus'];
+        this.requiredAttr = [[], []];
+        this.doCheckRequiredAttr = false;
+    }
+    recurModify(tree, sectionID) {
+        tree.forEach(i => {
+            if (i instanceof parser_1.DisplayComponent) {
+                i.addSectionID(sectionID);
+            }
+            else {
+                this.recurModify(i, sectionID);
+            }
+            ;
+        });
+    }
+    evaluate(cmd, args, option, raw) {
+        let k = args.getChilren();
+        if (option.mode == parser_1.mode.debug)
+            return k;
+        //remove bracket by default
+        let upgradeFlag = option.cardData && option.cardData.variants.join(" ").toLowerCase().includes("upgrade");
+        if ((upgradeFlag && cmd == "uminus") || (!upgradeFlag && cmd == "uadd")) {
+            return [];
+        }
+        if (option.mode == parser_1.mode.info) {
+            k = [
+                [new parser_1.TextComponent("[", undefined, cmd, raw)],
+                k,
+                [new parser_1.TextComponent("]", undefined, cmd, raw)]
+            ];
+        }
+        this.recurModify(k, cmd);
+        return k;
+    }
+}
+exports.default = uadduminusModule;

package/lib/_mods/parserModules/variantCheck.d.ts

@@ -0,0 +1,10 @@
+import { DisplayComponent, ParserModule, moduleInputObject, parseOptions } from '../../types/abstract/parser';
+import type { nestedTree } from '../../types/misc';
+export default class variantCheckModule extends ParserModule {
+    cmdName: string[];
+    requiredAttr: any[];
+    doCheckRequiredAttr: boolean;
+    isValidAttr(cmdIndex: number, attrName: string, attr: string): boolean;
+    private recurModify;
+    evaluate(cmd: string, args: moduleInputObject, option: parseOptions, raw: string): nestedTree<DisplayComponent>;
+}

package/lib/_mods/parserModules/variantCheck.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parser_1 = require("../../types/abstract/parser");
+class variantCheckModule extends parser_1.ParserModule {
+    constructor() {
+        super(...arguments);
+        this.cmdName = [
+            'variantInclude', 'variantExclude'
+        ];
+        this.requiredAttr = new Array(2).fill(["variantID"]);
+        this.doCheckRequiredAttr = true;
+    }
+    isValidAttr(cmdIndex, attrName, attr) {
+        const k = attr.split(" ");
+        for (let i = 0; i < k.length; i++) {
+            if (!k[i].length)
+                return false;
+        }
+        return true;
+    }
+    recurModify(tree, sectionID) {
+        tree.forEach(i => {
+            if (i instanceof parser_1.DisplayComponent) {
+                i.addSectionID(sectionID);
+            }
+            else {
+                this.recurModify(i, sectionID);
+            }
+            ;
+        });
+    }
+    evaluate(cmd, args, option, raw) {
+        let k = args.getChilren();
+        if (option.mode == parser_1.mode.debug)
+            return k;
+        //remove bracket by default
+        const checkVariant = args.getAttr("expr").split(' ');
+        let correctVariantFlag = option.cardData && option.cardData.variants.some(i => checkVariant.includes(i));
+        if ((correctVariantFlag && cmd == "variantExclude") || (!correctVariantFlag && cmd == "variantInclude")) {
+            return [];
+        }
+        if (option.mode == parser_1.mode.info) {
+            k = [
+                [new parser_1.TextComponent("[", undefined, cmd, raw)],
+                k,
+                [new parser_1.TextComponent("]", undefined, cmd, raw)]
+            ];
+        }
+        this.recurModify(k, cmd);
+        return k;
+    }
+}
+exports.default = variantCheckModule;