qpremake 1.5.2 → 1.6.3

package/lib/data/deckRegistry.d.ts

@@ -1,19 +0,0 @@
-import { operatorID } from "./operatorRegistry";
-import type { cardDataRegistry } from "./cardRegistry";
-export declare enum deckRegistry {
-    "d_all_lemons" = 0,
-    "d_all_apples" = 1,
-    "d_natural" = 2
-}
-export declare class DeckData {
-    readonly deckID: deckRegistry;
-    readonly cards: (keyof typeof cardDataRegistry)[];
-    readonly operator: operatorID;
-    readonly img: (keyof typeof cardDataRegistry);
-    constructor(deckID: deckRegistry, cards: (keyof typeof cardDataRegistry)[], operator: operatorID, img: (keyof typeof cardDataRegistry));
-}
-export declare const deckDataRegistry: {
-    readonly 0: DeckData;
-    readonly 1: DeckData;
-    readonly 2: DeckData;
-};

package/lib/data/deckRegistry.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deckDataRegistry = exports.DeckData = exports.deckRegistry = void 0;
-const operatorRegistry_1 = require("./operatorRegistry");
-var deckRegistry;
-(function (deckRegistry) {
-    deckRegistry[deckRegistry["d_all_lemons"] = 0] = "d_all_lemons";
-    deckRegistry[deckRegistry["d_all_apples"] = 1] = "d_all_apples";
-    deckRegistry[deckRegistry["d_natural"] = 2] = "d_natural";
-})(deckRegistry || (exports.deckRegistry = deckRegistry = {}));
-//class solely for type checking purposes
-class DeckData {
-    constructor(deckID, cards, operator, img) {
-        this.deckID = deckID;
-        this.cards = cards;
-        this.operator = operator;
-        this.img = img;
-    }
-}
-exports.DeckData = DeckData;
-exports.deckDataRegistry //: Record<deckRegistry, deckData> 
- = {
-    0: new DeckData(deckRegistry.d_all_lemons, new Array(10).fill("c_lemon"), operatorRegistry_1.operatorRegistry.o_esper, "c_lemon"),
-    1: new DeckData(deckRegistry.d_all_apples, new Array(10).fill("c_apple"), operatorRegistry_1.operatorRegistry.o_esper, "c_apple"),
-    2: new DeckData(deckRegistry.d_natural, [
-        "c_apple",
-        "c_banana",
-        "c_cherry",
-        "c_lemon",
-        "c_pomegranate",
-        "c_pumpkin",
-        "c_greenhouse",
-        "c_pollinate",
-        "c_growth",
-        "c_spring",
-        "c_summer",
-        "c_autumn",
-        "c_winter",
-        "c_demeter",
-    ], operatorRegistry_1.operatorRegistry.o_esper, "c_spring")
-};

package/lib/data/effectRegistry.d.ts

@@ -1,465 +0,0 @@
-import { damageType, isUnion } from "../types/misc";
-import type { effectData } from "./cardRegistry";
-export declare class quickEffect<K extends effectData = {
-    typeID: "e_t_none";
-    subTypeIDs: [];
-}> extends Function {
-    private constructor();
-    data: effectData;
-    type<T extends effectData["typeID"]>(type: T): quickEffect<{
-        [key in keyof K]: key extends "typeID" ? T : K[key];
-    }>["T_this"];
-    sub<T extends effectData["subTypeIDs"][0]>(subType: T): quickEffect<{
-        [key in keyof K]: key extends "subTypeIDs" ? [...K[key], T] : K[key];
-    }>["T_this"];
-    num<T1 extends string>(key: T1, def?: number): quickEffect<K & {
-        [k in T1]: number;
-    }>["T_this"];
-    bool<T1 extends string>(key: T1, def?: 0 | 1): quickEffect<K & {
-        [k in T1]: 0 | 1;
-    }>["T_this"];
-    tri<T1 extends string>(key: T1, def?: 0 | 1 | 2): quickEffect<K & {
-        [k in T1]: 0 | 1 | 2;
-    }>["T_this"];
-    optional<T2 extends number, T1 extends string>(key: T1, def?: T2 | undefined): quickEffect<K & {
-        [k in T1]: T2 | undefined;
-    }>["T_this"];
-    param<T2 extends number, T1 extends string>(key: T1, def: T2): quickEffect<K & {
-        [k in T1]: T2;
-    }>["T_this"];
-    count(def?: number): (() => K & {
-        count: number;
-    }) & quickEffect<K & {
-        count: number;
-    }>;
-    private T_this;
-    private toFunc;
-    static get init(): (() => {
-        typeID: "e_t_init";
-        subTypeIDs: [];
-    }) & quickEffect<{
-        typeID: "e_t_init";
-        subTypeIDs: [];
-    }>;
-    static get manual(): (() => {
-        typeID: "e_t_manual";
-        subTypeIDs: [];
-    }) & (() => {
-        typeID: "e_t_manual";
-        subTypeIDs: [];
-    }) & quickEffect<{
-        typeID: "e_t_manual";
-        subTypeIDs: [];
-    }>;
-    static get trigger(): (() => {
-        typeID: "e_t_trigger";
-        subTypeIDs: [];
-    }) & (() => {
-        typeID: "e_t_trigger";
-        subTypeIDs: [];
-    }) & quickEffect<{
-        typeID: "e_t_trigger";
-        subTypeIDs: [];
-    }>;
-    static get passive(): (() => {
-        typeID: "e_t_passive";
-        subTypeIDs: [];
-    }) & (() => {
-        typeID: "e_t_passive";
-        subTypeIDs: [];
-    }) & quickEffect<{
-        typeID: "e_t_passive";
-        subTypeIDs: [];
-    }>;
-    static get status(): (() => {
-        typeID: "e_t_status";
-        subTypeIDs: [];
-    }) & (() => {
-        typeID: "e_t_status";
-        subTypeIDs: [];
-    }) & quickEffect<{
-        typeID: "e_t_status";
-        subTypeIDs: [];
-    }>;
-    static get counter(): (() => {
-        typeID: "e_t_counter";
-        subTypeIDs: [];
-    }) & (() => {
-        typeID: "e_t_counter";
-        subTypeIDs: [];
-    }) & quickEffect<{
-        typeID: "e_t_counter";
-        subTypeIDs: [];
-    }>;
-    static get lock(): (() => {
-        typeID: "e_t_lock";
-        subTypeIDs: [];
-    }) & (() => {
-        typeID: "e_t_lock";
-        subTypeIDs: [];
-    }) & quickEffect<{
-        typeID: "e_t_lock";
-        subTypeIDs: [];
-    }>;
-    static get def(): {
-        typeID: "e_t_none";
-        subTypeIDs: never[];
-    };
-    get chained(): (() => { [key in keyof K]: key extends "subTypeIDs" ? [...K[key], "e_st_chained"] : K[key]; }) & quickEffect<{ [key in keyof K]: key extends "subTypeIDs" ? [...K[key], "e_st_chained"] : K[key]; }>;
-    get once(): (() => { [key in keyof K]: key extends "subTypeIDs" ? [...K[key], "e_st_once"] : K[key]; }) & quickEffect<{ [key in keyof K]: key extends "subTypeIDs" ? [...K[key], "e_st_once"] : K[key]; }>;
-    get unique(): (() => { [key in keyof K]: key extends "subTypeIDs" ? [...K[key], "e_st_unique"] : K[key]; }) & quickEffect<{ [key in keyof K]: key extends "subTypeIDs" ? [...K[key], "e_st_unique"] : K[key]; }>;
-    get instant(): (() => { [key in keyof K]: key extends "subTypeIDs" ? [...K[key], "e_st_instant"] : K[key]; }) & quickEffect<{ [key in keyof K]: key extends "subTypeIDs" ? [...K[key], "e_st_instant"] : K[key]; }>;
-    get fieldLock(): (() => { [key in keyof K]: key extends "subTypeIDs" ? [...K[key], "e_st_fieldLock"] : K[key]; }) & quickEffect<{ [key in keyof K]: key extends "subTypeIDs" ? [...K[key], "e_st_fieldLock"] : K[key]; }>;
-    get graveLock(): (() => { [key in keyof K]: key extends "subTypeIDs" ? [...K[key], "e_st_graveLock"] : K[key]; }) & quickEffect<{ [key in keyof K]: key extends "subTypeIDs" ? [...K[key], "e_st_graveLock"] : K[key]; }>;
-    get delayed(): (() => { [key in keyof K]: key extends "subTypeIDs" ? [...K[key], "e_st_delayed"] : K[key]; }) & quickEffect<{ [key in keyof K]: key extends "subTypeIDs" ? [...K[key], "e_st_delayed"] : K[key]; }>;
-}
-declare const effectDataRegistry: {
-    readonly e_apple: {
-        typeID: "e_t_init";
-        subTypeIDs: [];
-    } & {
-        count: number;
-    };
-    readonly e_banana: {
-        typeID: "e_t_init";
-        subTypeIDs: [];
-    } & {
-        doArchtypeCheck: 0 | 1;
-    };
-    readonly e_lemon: {
-        typeID: "e_t_init";
-        subTypeIDs: [];
-    };
-    readonly e_pumpkin: {
-        typeID: "e_t_init";
-        subTypeIDs: [];
-    } & {
-        maxAtk: number;
-    } & {
-        maxHp: number;
-    } & {
-        level: number;
-    };
-    readonly e_pomegranate: {
-        typeID: "e_t_trigger";
-        subTypeIDs: [];
-    } & {
-        exposedDmg: number;
-    } & {
-        coveredDmg: number;
-    };
-    readonly e_pollinate: {
-        typeID: "e_t_init";
-        subTypeIDs: [];
-    } & {
-        doArchtypeCheck: 0 | 1;
-    };
-    readonly e_greenhouse: {
-        typeID: "e_t_trigger";
-        subTypeIDs: ["e_st_unique"];
-    } & {
-        checkLevel: number;
-    };
-    readonly e_growth: {
-        typeID: "e_t_init";
-        subTypeIDs: [];
-    } & {
-        doArchtypeCheck: 0 | 1;
-    };
-    readonly e_spring: {
-        typeID: "e_t_init";
-        subTypeIDs: [];
-    } & {
-        checkLevel: number;
-    };
-    readonly e_summer: {
-        typeID: "e_t_init";
-        subTypeIDs: [];
-    } & {
-        checkLevel: number;
-    };
-    readonly e_autumn: {
-        typeID: "e_t_init";
-        subTypeIDs: [];
-    };
-    readonly e_winter_1: {
-        typeID: "e_t_init";
-        subTypeIDs: [];
-    } & {
-        mult: number;
-    };
-    readonly e_winter_2: {
-        typeID: "e_t_none";
-        subTypeIDs: never[];
-    };
-    readonly e_persephone_1: {
-        typeID: "e_t_init";
-        subTypeIDs: [];
-    };
-    readonly e_persephone_2: {
-        typeID: "e_t_passive";
-        subTypeIDs: ["e_st_delayed"];
-    };
-    readonly e_persephone_3: {
-        typeID: "e_t_lock";
-        subTypeIDs: [];
-    };
-    readonly e_demeter_1: {
-        typeID: "e_t_init";
-        subTypeIDs: [];
-    };
-    readonly e_demeter_2: {
-        typeID: "e_t_trigger";
-        subTypeIDs: ["e_st_unique"];
-    };
-    readonly e_demeter_3: {
-        typeID: "e_t_lock";
-        subTypeIDs: [];
-    };
-    readonly e_capacitor_1: {
-        typeID: "e_t_trigger";
-        subTypeIDs: ["e_st_once"];
-    } & {
-        maxCount: number;
-    };
-    readonly e_capacitor_2: {
-        typeID: "e_t_trigger";
-        subTypeIDs: ["e_st_once"];
-    };
-    readonly e_avarice_1: {
-        typeID: "e_t_init";
-        subTypeIDs: [];
-    } & {
-        count: number;
-    };
-    readonly e_clawtrap: {
-        typeID: "e_t_manual";
-        subTypeIDs: [];
-    } & {
-        delayCount: number;
-    } & {
-        dmg: number;
-    };
-    readonly e_dmg_reduction: {
-        typeID: "e_t_passive";
-        subTypeIDs: [];
-    } & {
-        reductionAmmount: number;
-    } & {
-        minDmg: number;
-    } & {
-        reductionDmgType: damageType.physical | undefined;
-    };
-    readonly e_delay: {
-        typeID: "e_t_manual";
-        subTypeIDs: [];
-    } & {
-        count: number;
-    } & {
-        delayCount: number;
-    };
-    readonly e_bounce: {
-        typeID: "e_t_manual";
-        subTypeIDs: [];
-    } & {
-        count: number;
-    } & {
-        target_zone: number;
-    };
-    readonly e_delay_all: {
-        typeID: "e_t_manual";
-        subTypeIDs: [];
-    } & {
-        delayCount: number;
-    };
-    readonly e_add_to_hand: {
-        typeID: "e_t_manual";
-        subTypeIDs: [];
-    } & {
-        count: number;
-    };
-    readonly e_remove_all_effects: {
-        typeID: "e_t_manual";
-        subTypeIDs: [];
-    } & {
-        count: number;
-    };
-    readonly e_add_all_to_hand: {
-        typeID: "e_t_none";
-        subTypeIDs: never[];
-    };
-    readonly e_add_all_to_grave: {
-        typeID: "e_t_none";
-        subTypeIDs: never[];
-    };
-    readonly e_attack: {
-        typeID: "e_t_manual";
-        subTypeIDs: [];
-    } & {
-        count: number;
-    } & {
-        dmg: number;
-    } & {
-        dmgType: damageType.physical;
-    };
-    readonly e_deal_dmg_card: {
-        typeID: "e_t_manual";
-        subTypeIDs: [];
-    } & {
-        count: number;
-    } & {
-        dmg: number;
-    } & {
-        dmgType: damageType.physical;
-    };
-    readonly e_deal_dmg_ahead: {
-        typeID: "e_t_manual";
-        subTypeIDs: [];
-    } & {
-        count: number;
-    } & {
-        dmg: number;
-    } & {
-        dmgType: damageType.physical;
-    };
-    readonly e_destroy_this: {
-        typeID: "e_t_manual";
-        subTypeIDs: ["e_st_fieldLock"];
-    };
-    readonly e_clear_all_status_this: {
-        typeID: "e_t_manual";
-        subTypeIDs: ["e_st_fieldLock"];
-    };
-    readonly e_reactivate_this: {
-        typeID: "e_t_manual";
-        subTypeIDs: ["e_st_fieldLock"];
-    };
-    readonly e_deactivate_this: {
-        typeID: "e_t_manual";
-        subTypeIDs: ["e_st_fieldLock"];
-    };
-    readonly e_decompile_this: {
-        typeID: "e_t_manual";
-        subTypeIDs: ["e_st_fieldLock"];
-    };
-    readonly e_execute_this: {
-        typeID: "e_t_manual";
-        subTypeIDs: ["e_st_fieldLock"];
-    };
-    readonly e_void_this: {
-        typeID: "e_t_manual";
-        subTypeIDs: ["e_st_fieldLock"];
-    };
-    readonly e_reset_all_once_this: {
-        typeID: "e_t_manual";
-        subTypeIDs: ["e_st_fieldLock"];
-    };
-    readonly e_reset_all_once: {
-        typeID: "e_t_manual";
-        subTypeIDs: [];
-    };
-    readonly e_add_counter: {
-        typeID: "e_t_manual";
-        subTypeIDs: [];
-    };
-    readonly e_add_stat_change_diff: {
-        typeID: "e_t_manual";
-        subTypeIDs: [];
-    } & {
-        maxAtk: number;
-    } & {
-        maxHp: number;
-    } & {
-        level: number;
-    };
-    readonly e_add_stat_change_override: {
-        typeID: "e_t_manual";
-        subTypeIDs: [];
-    } & {
-        maxAtk: number;
-    } & {
-        maxHp: number;
-    } & {
-        level: number;
-    };
-    readonly e_quick: {
-        typeID: "e_t_init";
-        subTypeIDs: ["e_st_chained"];
-    };
-    readonly e_reflect: {
-        typeID: "e_t_trigger";
-        subTypeIDs: [];
-    };
-    readonly e_revenge: {
-        typeID: "e_t_trigger";
-        subTypeIDs: [];
-    };
-    readonly e_volatile: {
-        typeID: "e_t_passive";
-        subTypeIDs: [];
-    };
-    readonly e_fragile: {
-        typeID: "e_t_trigger";
-        subTypeIDs: [];
-    };
-    readonly e_draw: {
-        typeID: "e_t_manual";
-        subTypeIDs: [];
-    } & {
-        count: number;
-    } & {
-        cooldown: number;
-    } & {
-        doTurnDraw: 0 | 1;
-    };
-    readonly e_draw_until: {
-        typeID: "e_t_manual";
-        subTypeIDs: [];
-    } & {
-        count: number;
-    };
-    readonly e_revive: {
-        typeID: "e_t_manual";
-        subTypeIDs: [];
-    };
-    readonly e_generic_counter: {
-        typeID: "e_t_counter";
-        subTypeIDs: [];
-    } & {
-        count: number;
-    };
-    readonly e_generic_stat_change_diff: {
-        typeID: "e_t_status";
-        subTypeIDs: [];
-    } & {
-        maxAtk: number;
-    } & {
-        maxHp: number;
-    } & {
-        level: number;
-    };
-    readonly e_generic_stat_change_override: {
-        typeID: "e_t_status";
-        subTypeIDs: [];
-    } & {
-        maxAtk: number;
-    } & {
-        maxHp: number;
-    } & {
-        level: number;
-    };
-    readonly e_any_extension: {
-        typeID: "e_t_status";
-        subTypeIDs: [];
-    };
-    readonly e_lock: {
-        typeID: "e_t_lock";
-        subTypeIDs: [];
-    };
-};
-type effectName = keyof typeof effectDataRegistry;
-type effectData_specific<T extends effectName, U = (typeof effectDataRegistry[T])> = {
-    [K in keyof U]: K extends "typeID" | "subTypeIDs" ? U[K] : (isUnion<U[K]> extends true ? U[K] : number);
-};
-export default effectDataRegistry;
-export type { effectName, effectData_specific };

package/lib/data/effectRegistry.js

@@ -1,151 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.quickEffect = void 0;
-//use for loading effects
-// import { effectData } from "./cardRegistry"
-const misc_1 = require("../types/misc");
-const zoneRegistry_1 = require("./zoneRegistry");
-//Super stupid implementation btw
-// 1. this must extends fron Fucntion to work
-// 2. toFunc overwrites the function call to returning the internal data
-class quickEffect extends Function {
-    constructor() {
-        super();
-        this.data = {
-            typeID: "e_t_none",
-            subTypeIDs: []
-        };
-        this.T_this = 0;
-    }
-    type(type) {
-        this.data.typeID = type;
-        return this;
-    }
-    sub(subType) {
-        this.data.subTypeIDs.push(subType);
-        return this;
-    }
-    num(key, def = 0) {
-        this.data[key] = def;
-        return this;
-    }
-    bool(key, def = 0) {
-        this.data[key] = def;
-        return this;
-    }
-    tri(key, def = 0) {
-        this.data[key] = def;
-        return this;
-    }
-    optional(key, def = undefined) {
-        if (def !== undefined)
-            this.data[key] = def;
-        return this;
-    }
-    param(key, def) {
-        this.data[key] = def;
-        return this;
-    }
-    count(def = 0) { return this.num("count", def); }
-    toFunc() {
-        return new Proxy(this, {
-            apply(target) {
-                return target.data;
-            }
-        });
-    }
-    static get init() { return new quickEffect().toFunc().type("e_t_init"); }
-    static get manual() { return new quickEffect().type("e_t_manual").toFunc(); }
-    static get trigger() { return new quickEffect().type("e_t_trigger").toFunc(); }
-    static get passive() { return new quickEffect().type("e_t_passive").toFunc(); }
-    static get status() { return new quickEffect().type("e_t_status").toFunc(); }
-    static get counter() { return new quickEffect().type("e_t_counter").toFunc(); }
-    static get lock() { return new quickEffect().type("e_t_lock").toFunc(); }
-    static get def() {
-        return {
-            typeID: "e_t_none",
-            subTypeIDs: []
-        };
-    }
-    get chained() { return this.sub("e_st_chained"); }
-    get once() { return this.sub("e_st_once"); }
-    get unique() { return this.sub("e_st_unique"); }
-    get instant() { return this.sub("e_st_instant"); }
-    get fieldLock() { return this.sub("e_st_fieldLock"); }
-    get graveLock() { return this.sub("e_st_graveLock"); }
-    get delayed() { return this.sub("e_st_delayed"); }
-}
-exports.quickEffect = quickEffect;
-const effectDataRegistry //: { [K in string] : effectData} 
- = {
-    //actual effects - specifics
-    //fruits - white
-    e_apple: quickEffect.init.count(1)(),
-    e_banana: quickEffect.init.bool("doArchtypeCheck", 1)(),
-    e_lemon: quickEffect.init(),
-    e_pumpkin: quickEffect.init.num("maxAtk").num("maxHp").num("level")(),
-    e_pomegranate: quickEffect.trigger.num("exposedDmg", 1).num("coveredDmg", 2)(),
-    //fruit - green
-    e_pollinate: quickEffect.init.bool("doArchtypeCheck", 1)(),
-    e_greenhouse: quickEffect.trigger.unique.num("checkLevel", 1)(),
-    //fruit - blue
-    e_growth: quickEffect.init.bool("doArchtypeCheck", 1)(),
-    e_spring: quickEffect.init.num("checkLevel", 1)(),
-    e_summer: quickEffect.init.num("checkLevel", 1)(),
-    e_autumn: quickEffect.init(),
-    e_winter_1: quickEffect.init.num("mult")(),
-    e_winter_2: quickEffect.def,
-    //fruit - red
-    e_persephone_1: quickEffect.init(),
-    e_persephone_2: quickEffect.passive.delayed(),
-    e_persephone_3: quickEffect.lock(),
-    e_demeter_1: quickEffect.init(),
-    e_demeter_2: quickEffect.trigger.unique(),
-    e_demeter_3: quickEffect.lock(),
-    //generic, specific
-    e_capacitor_1: quickEffect.trigger.once.num("maxCount")(),
-    e_capacitor_2: quickEffect.trigger.once(),
-    e_avarice_1: quickEffect.init.count()(),
-    e_clawtrap: quickEffect.manual.num("delayCount", 4).num("dmg", 1)(),
-    //generic - generics
-    e_dmg_reduction: quickEffect.passive.num("reductionAmmount").num("minDmg").optional("reductionDmgType", misc_1.damageType.physical)(),
-    e_delay: quickEffect.manual.count().num("delayCount")(),
-    e_bounce: quickEffect.manual.count().num("target_zone", zoneRegistry_1.zoneRegistry.z_field)(),
-    e_delay_all: quickEffect.manual.num("delayCount")(),
-    e_add_to_hand: quickEffect.manual.count()(),
-    e_remove_all_effects: quickEffect.manual.count()(),
-    e_add_all_to_hand: quickEffect.def,
-    e_add_all_to_grave: quickEffect.def,
-    e_attack: quickEffect.manual.count().num("dmg").param("dmgType", misc_1.damageType.physical)(),
-    e_deal_dmg_card: quickEffect.manual.count().num("dmg").param("dmgType", misc_1.damageType.physical)(),
-    e_deal_dmg_ahead: quickEffect.manual.count().num("dmg").param("dmgType", misc_1.damageType.physical)(),
-    // e_reactivate : quickEffect.manual.fieldLock(),
-    e_destroy_this: quickEffect.manual.fieldLock(),
-    e_clear_all_status_this: quickEffect.manual.fieldLock(),
-    e_reactivate_this: quickEffect.manual.fieldLock(),
-    e_deactivate_this: quickEffect.manual.fieldLock(),
-    e_decompile_this: quickEffect.manual.fieldLock(),
-    e_execute_this: quickEffect.manual.fieldLock(),
-    e_void_this: quickEffect.manual.fieldLock(),
-    e_reset_all_once_this: quickEffect.manual.fieldLock(),
-    e_reset_all_once: quickEffect.manual(),
-    e_add_counter: quickEffect.manual(),
-    e_add_stat_change_diff: quickEffect.manual.num("maxAtk").num("maxHp").num("level")(),
-    e_add_stat_change_override: quickEffect.manual.num("maxAtk").num("maxHp").num("level")(),
-    e_quick: quickEffect.init.chained(),
-    e_reflect: quickEffect.trigger(),
-    e_revenge: quickEffect.trigger(),
-    e_volatile: quickEffect.passive(),
-    e_fragile: quickEffect.trigger(),
-    e_draw: quickEffect.manual.count().num("cooldown").bool("doTurnDraw")(),
-    e_draw_until: quickEffect.manual.count()(),
-    e_revive: quickEffect.manual(),
-    //status effects
-    e_generic_counter: quickEffect.counter.count(1)(),
-    e_generic_stat_change_diff: quickEffect.status.num("maxAtk").num("maxHp").num("level")(),
-    e_generic_stat_change_override: quickEffect.status.num("maxAtk").num("maxHp").num("level")(),
-    e_any_extension: quickEffect.status(),
-    //lock effects
-    e_lock: quickEffect.lock(),
-};
-exports.default = effectDataRegistry;

package/lib/data/effectTypeRegistry.d.ts

@@ -1,14 +0,0 @@
-declare enum effectTypeRegistry {
-    e_t_none = -1,
-    e_t_manual = 0,
-    e_t_passive = 1,
-    e_t_trigger = 2,
-    e_t_init = 3,
-    e_t_lock = 4,
-    e_t_counter = 5,
-    e_t_status = 6
-}
-type effectTypeName = keyof typeof effectTypeRegistry;
-type effectTypeID = (typeof effectTypeRegistry)[effectTypeName];
-export default effectTypeRegistry;
-export type { effectTypeName, effectTypeID };