@gamepark/zenith 0.0.2 → 0.1.0

package/dist/rules/PlayCardRule.js

@@ -1,147 +1,81 @@
-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlayCardRule = void 0;
-var rules_api_1 = require("@gamepark/rules-api");
-var Agents_1 = require("../material/Agents");
-var LocationType_1 = require("../material/LocationType");
-var MaterialType_1 = require("../material/MaterialType");
-var TeamColor_1 = require("../TeamColor");
-var CreditHelper_1 = require("./helper/CreditHelper");
-var EffectHelper_1 = require("./helper/EffectHelper");
-var InfluenceHelper_1 = require("./helper/InfluenceHelper");
-var PlayerHelper_1 = require("./helper/PlayerHelper");
-var Memory_1 = require("./Memory");
-var RuleId_1 = require("./RuleId");
-var PlayCardRule = (function (_super) {
-    __extends(PlayCardRule, _super);
-    function PlayCardRule() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    PlayCardRule.prototype.onRuleStart = function () {
-        this.forget(Memory_1.Memory.DiscardFaction);
-        this.forget(Memory_1.Memory.LastPlanetsMoved);
+import { isMoveItemType, isStartPlayerTurn, isStartRule, PlayerTurnRule } from '@gamepark/rules-api';
+import { Agents } from '../material/Agents';
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { getTeamColor } from '../TeamColor';
+import { CreditHelper } from './helper/CreditHelper';
+import { EffectHelper } from './helper/EffectHelper';
+import { InfluenceHelper } from './helper/InfluenceHelper';
+import { PlayerHelper } from './helper/PlayerHelper';
+import { Memory } from './Memory';
+import { RuleId } from './RuleId';
+export class PlayCardRule extends PlayerTurnRule {
+    onRuleStart() {
+        this.forget(Memory.DiscardFaction);
+        this.forget(Memory.LastPlanetsMoved);
         return [];
-    };
-    PlayCardRule.prototype.getPlayerMoves = function () {
-        var moves = [];
-        var hand = this.hand;
-        moves.push.apply(moves, __spreadArray([], __read(this.discardAgents(hand)), false));
-        moves.push.apply(moves, __spreadArray([], __read(this.placeInInfluence(hand)), false));
+    }
+    getPlayerMoves() {
+        const moves = [];
+        const hand = this.hand;
+        moves.push(...this.discardAgents(hand));
+        moves.push(...this.placeInInfluence(hand));
         return moves;
-    };
-    PlayCardRule.prototype.placeInInfluence = function (cards) {
-        var _this = this;
-        var influenceHelper = this.influenceHelper;
-        var playerHelper = this.playerHelper;
+    }
+    placeInInfluence(cards) {
+        const influenceHelper = this.influenceHelper;
+        const playerHelper = this.playerHelper;
         return cards
-            .filter(function (item) { return influenceHelper.getCost(item) <= playerHelper.credits; })
-            .moveItems(function (item) { return ({
-            type: LocationType_1.LocationType.Influence,
-            id: Agents_1.Agents[item.id].influence,
-            player: (0, TeamColor_1.getTeamColor)(_this.player)
-        }); });
-    };
-    PlayCardRule.prototype.discardAgents = function (cards) {
+            .filter((item) => influenceHelper.getCost(item) <= playerHelper.credits)
+            .moveItems((item) => ({
+            type: LocationType.Influence,
+            id: Agents[item.id].influence,
+            player: getTeamColor(this.player)
+        }));
+    }
+    discardAgents(cards) {
         return cards.moveItems({
-            type: LocationType_1.LocationType.AgentDiscard
+            type: LocationType.AgentDiscard
         });
-    };
-    Object.defineProperty(PlayCardRule.prototype, "creditHelper", {
-        get: function () {
-            return new CreditHelper_1.CreditHelper(this.game, this.player);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    PlayCardRule.prototype.afterItemMove = function (move) {
-        if (!(0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.AgentCard)(move))
+    }
+    get creditHelper() {
+        return new CreditHelper(this.game, this.player);
+    }
+    afterItemMove(move) {
+        if (!isMoveItemType(MaterialType.AgentCard)(move))
             return [];
-        if (move.location.type === LocationType_1.LocationType.AgentDiscard) {
-            var item = this.material(MaterialType_1.MaterialType.AgentCard).getItem(move.itemIndex);
-            var agent = Agents_1.Agents[item.id];
-            this.memorize(Memory_1.Memory.DiscardFaction, agent.faction);
-            return [this.startRule(RuleId_1.RuleId.DiscardAction)];
+        if (move.location.type === LocationType.AgentDiscard) {
+            const item = this.material(MaterialType.AgentCard).getItem(move.itemIndex);
+            const agent = Agents[item.id];
+            this.memorize(Memory.DiscardFaction, agent.faction);
+            return [this.startRule(RuleId.DiscardAction)];
         }
-        var moves = [];
-        if (move.location.type === LocationType_1.LocationType.Influence) {
-            var influenceHelper = this.influenceHelper;
-            var item = this.material(MaterialType_1.MaterialType.AgentCard).getItem(move.itemIndex);
-            this.memorize(Memory_1.Memory.CardPlayed, item.id);
-            var cost = influenceHelper.getCost(item, 1);
+        const moves = [];
+        if (move.location.type === LocationType.Influence) {
+            const influenceHelper = this.influenceHelper;
+            const item = this.material(MaterialType.AgentCard).getItem(move.itemIndex);
+            this.memorize(Memory.CardPlayed, item.id);
+            const cost = influenceHelper.getCost(item, 1);
             if (cost > 0) {
-                moves.push.apply(moves, __spreadArray([], __read(this.creditHelper.spendCredit(cost)), false));
+                moves.push(...this.creditHelper.spendCredit(cost));
             }
-            var helper = new EffectHelper_1.EffectHelper(this.game, this.player);
-            var effectMoves = helper.applyCard(item);
-            if (effectMoves.some(function (move) { return (0, rules_api_1.isStartRule)(move) || (0, rules_api_1.isStartPlayerTurn)(move); })) {
-                moves.push.apply(moves, __spreadArray([], __read(effectMoves), false));
+            const helper = new EffectHelper(this.game, this.player);
+            const effectMoves = helper.applyCard(item);
+            if (effectMoves.some((move) => isStartRule(move) || isStartPlayerTurn(move))) {
+                moves.push(...effectMoves);
                 return moves;
             }
-            moves.push(this.startRule(RuleId_1.RuleId.Refill));
+            moves.push(this.startRule(RuleId.Refill));
         }
         return moves;
-    };
-    Object.defineProperty(PlayCardRule.prototype, "influenceHelper", {
-        get: function () {
-            return new InfluenceHelper_1.InfluenceHelper(this.game, (0, TeamColor_1.getTeamColor)(this.player));
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(PlayCardRule.prototype, "playerHelper", {
-        get: function () {
-            return new PlayerHelper_1.PlayerHelper(this.game, this.player);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(PlayCardRule.prototype, "hand", {
-        get: function () {
-            return this.material(MaterialType_1.MaterialType.AgentCard).location(LocationType_1.LocationType.PlayerHand).player(this.player);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return PlayCardRule;
-}(rules_api_1.PlayerTurnRule));
-exports.PlayCardRule = PlayCardRule;
+    }
+    get influenceHelper() {
+        return new InfluenceHelper(this.game, getTeamColor(this.player));
+    }
+    get playerHelper() {
+        return new PlayerHelper(this.game, this.player);
+    }
+    get hand() {
+        return this.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(this.player);
+    }
+}

package/dist/rules/RefillRule.js

@@ -1,211 +1,104 @@
-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
+import { isMoveItemTypeAtOnce, isShuffleItemType, PlayerTurnRule } from '@gamepark/rules-api';
+import { influences } from '../material/Influence';
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { PlayerHelper } from './helper/PlayerHelper';
+import { Memory } from './Memory';
+import { RuleId } from './RuleId';
+export class RefillRule extends PlayerTurnRule {
+    onRuleStart() {
+        this.memorize(Memory.AlreadyPlayedPlayers, (p = []) => p.concat(this.player));
+        const moves = [];
+        for (const influence of influences) {
+            const planet = this.material(MaterialType.InfluenceDisc).location(LocationType.PlanetBoardInfluenceDiscSpace).locationId(influence);
+            if (planet.length)
+                continue;
+            moves.push(this.getNewInfluenceDisc(influence).moveItem({
+                type: LocationType.PlanetBoardInfluenceDiscSpace,
+                id: influence,
+                x: 0
+            }));
         }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
+        const maxSize = this.handSize;
+        moves.push(...this.refillHand(maxSize));
+        if (moves.some((move) => isMoveItemTypeAtOnce(MaterialType.AgentCard)(move) && move.location.type === LocationType.AgentDeck)) {
+            return moves;
         }
-        finally { if (e) throw e.error; }
+        moves.push(...this.endRuleMoves);
+        return moves;
     }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
+    getNewInfluenceDisc(influence) {
+        return this.material(MaterialType.InfluenceDisc)
+            .location(LocationType.InfluenceDiscStock)
+            .locationId(influence)
+            .maxBy((item) => item.location.x);
+    }
+    get endRuleMoves() {
+        const isTurnEnded = this.remind(Memory.AlreadyPlayedPlayers).length === this.game.players.length;
+        if (isTurnEnded) {
+            this.forget(Memory.AlreadyPlayedPlayers);
+            return [this.startPlayerTurn(RuleId.PlayCard, this.turnOrder[0])];
+        }
+        else {
+            return [this.startPlayerTurn(RuleId.PlayCard, this.nextPlayer)];
         }
     }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RefillRule = void 0;
-var rules_api_1 = require("@gamepark/rules-api");
-var Influence_1 = require("../material/Influence");
-var LocationType_1 = require("../material/LocationType");
-var MaterialType_1 = require("../material/MaterialType");
-var PlayerHelper_1 = require("./helper/PlayerHelper");
-var Memory_1 = require("./Memory");
-var RuleId_1 = require("./RuleId");
-var RefillRule = (function (_super) {
-    __extends(RefillRule, _super);
-    function RefillRule() {
-        return _super !== null && _super.apply(this, arguments) || this;
+    get turnOrder() {
+        return this.remind(Memory.TurnOrder);
     }
-    RefillRule.prototype.onRuleStart = function () {
-        var e_1, _a;
-        var _this = this;
-        this.memorize(Memory_1.Memory.AlreadyPlayedPlayers, function (p) {
-            if (p === void 0) { p = []; }
-            return p.concat(_this.player);
-        });
-        var moves = [];
-        try {
-            for (var influences_1 = __values(Influence_1.influences), influences_1_1 = influences_1.next(); !influences_1_1.done; influences_1_1 = influences_1.next()) {
-                var influence = influences_1_1.value;
-                var planet = this.material(MaterialType_1.MaterialType.InfluenceDisc).location(LocationType_1.LocationType.PlanetBoardInfluenceDiscSpace).locationId(influence);
-                if (planet.length)
-                    continue;
-                moves.push(this.getNewInfluenceDisc(influence).moveItem({
-                    type: LocationType_1.LocationType.PlanetBoardInfluenceDiscSpace,
-                    id: influence,
-                    x: 0
-                }));
-            }
+    get nextPlayer() {
+        const players = this.turnOrder;
+        return players[(players.indexOf(this.player) + 1) % players.length];
+    }
+    get handSize() {
+        const leaderBadge = this.leaderBadge;
+        if (!leaderBadge.length) {
+            return 4;
         }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (influences_1_1 && !influences_1_1.done && (_a = influences_1.return)) _a.call(influences_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        var maxSize = this.handSize;
-        moves.push.apply(moves, __spreadArray([], __read(this.refillHand(maxSize)), false));
-        if (moves.some(function (move) { return (0, rules_api_1.isMoveItemTypeAtOnce)(MaterialType_1.MaterialType.AgentCard)(move) && move.location.type === LocationType_1.LocationType.AgentDeck; })) {
-            return moves;
-        }
-        moves.push.apply(moves, __spreadArray([], __read(this.endRuleMoves), false));
-        return moves;
-    };
-    RefillRule.prototype.getNewInfluenceDisc = function (influence) {
-        return this.material(MaterialType_1.MaterialType.InfluenceDisc)
-            .location(LocationType_1.LocationType.InfluenceDiscStock)
-            .locationId(influence)
-            .maxBy(function (item) { return item.location.x; });
-    };
-    Object.defineProperty(RefillRule.prototype, "endRuleMoves", {
-        get: function () {
-            var isTurnEnded = this.remind(Memory_1.Memory.AlreadyPlayedPlayers).length === this.game.players.length;
-            if (isTurnEnded) {
-                this.forget(Memory_1.Memory.AlreadyPlayedPlayers);
-                return [this.startPlayerTurn(RuleId_1.RuleId.PlayCard, this.turnOrder[0])];
-            }
-            else {
-                return [this.startPlayerTurn(RuleId_1.RuleId.PlayCard, this.nextPlayer)];
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RefillRule.prototype, "turnOrder", {
-        get: function () {
-            return this.remind(Memory_1.Memory.TurnOrder);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RefillRule.prototype, "nextPlayer", {
-        get: function () {
-            var players = this.turnOrder;
-            return players[(players.indexOf(this.player) + 1) % players.length];
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RefillRule.prototype, "handSize", {
-        get: function () {
-            var leaderBadge = this.leaderBadge;
-            if (!leaderBadge.length) {
-                return 4;
+        else {
+            const item = leaderBadge.getItem();
+            if (!item.location.rotation) {
+                return 5;
             }
             else {
-                var item = leaderBadge.getItem();
-                if (!item.location.rotation) {
-                    return 5;
-                }
-                else {
-                    return 6;
-                }
+                return 6;
             }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    RefillRule.prototype.refillHand = function (maxCount) {
-        var deck = this.deck;
-        var quantity = Math.max(0, maxCount - this.hand.length);
+        }
+    }
+    refillHand(maxCount) {
+        const deck = this.deck;
+        const quantity = Math.max(0, maxCount - this.hand.length);
         if (!quantity)
             return [];
-        var moves = deck.deal({
-            type: LocationType_1.LocationType.PlayerHand,
+        const moves = deck.deal({
+            type: LocationType.PlayerHand,
             player: this.player
         }, quantity);
-        var remaining = quantity - moves.length;
+        const remaining = quantity - moves.length;
         if (!remaining)
             return moves;
-        moves.push(this.discard.moveItemsAtOnce({ type: LocationType_1.LocationType.AgentDeck }));
+        moves.push(this.discard.moveItemsAtOnce({ type: LocationType.AgentDeck }));
         return moves;
-    };
-    Object.defineProperty(RefillRule.prototype, "discard", {
-        get: function () {
-            return this.material(MaterialType_1.MaterialType.AgentCard).location(LocationType_1.LocationType.AgentDiscard);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    RefillRule.prototype.afterItemMove = function (move) {
-        if ((0, rules_api_1.isShuffleItemType)(MaterialType_1.MaterialType.AgentCard)(move)) {
-            return __spreadArray(__spreadArray([], __read(this.refillHand(this.handSize)), false), __read(this.endRuleMoves), false);
+    }
+    get discard() {
+        return this.material(MaterialType.AgentCard).location(LocationType.AgentDiscard);
+    }
+    afterItemMove(move) {
+        if (isShuffleItemType(MaterialType.AgentCard)(move)) {
+            return [...this.refillHand(this.handSize), ...this.endRuleMoves];
         }
-        if ((0, rules_api_1.isMoveItemTypeAtOnce)(MaterialType_1.MaterialType.AgentCard)(move) && move.location.type === LocationType_1.LocationType.AgentDeck) {
+        if (isMoveItemTypeAtOnce(MaterialType.AgentCard)(move) && move.location.type === LocationType.AgentDeck) {
             return [this.deck.shuffle()];
         }
         return [];
-    };
-    Object.defineProperty(RefillRule.prototype, "hand", {
-        get: function () {
-            return this.material(MaterialType_1.MaterialType.AgentCard).location(LocationType_1.LocationType.PlayerHand).player(this.player);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RefillRule.prototype, "deck", {
-        get: function () {
-            return this.material(MaterialType_1.MaterialType.AgentCard).location(LocationType_1.LocationType.AgentDeck).deck();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RefillRule.prototype, "leaderBadge", {
-        get: function () {
-            return this.material(MaterialType_1.MaterialType.LeaderBadgeToken).player(new PlayerHelper_1.PlayerHelper(this.game, this.player).team);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return RefillRule;
-}(rules_api_1.PlayerTurnRule));
-exports.RefillRule = RefillRule;
+    }
+    get hand() {
+        return this.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(this.player);
+    }
+    get deck() {
+        return this.material(MaterialType.AgentCard).location(LocationType.AgentDeck).deck();
+    }
+    get leaderBadge() {
+        return this.material(MaterialType.LeaderBadgeToken).player(new PlayerHelper(this.game, this.player).team);
+    }
+}

package/dist/rules/RuleId.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RuleId = void 0;
-var RuleId;
+export var RuleId;
 (function (RuleId) {
     RuleId[RuleId["Muligan"] = 1] = "Muligan";
     RuleId[RuleId["PlayCard"] = 2] = "PlayCard";
@@ -28,4 +25,4 @@ var RuleId;
     RuleId[RuleId["StealCredit"] = 23] = "StealCredit";
     RuleId[RuleId["SpendZenithium"] = 24] = "SpendZenithium";
     RuleId[RuleId["TakeTechnologyBonusToken"] = 25] = "TakeTechnologyBonusToken";
-})(RuleId || (exports.RuleId = RuleId = {}));
+})(RuleId || (RuleId = {}));

package/dist/rules/discard-action/DiplomacyActions.js

@@ -1,39 +1,34 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDiplomacyActions = void 0;
-var EffectType_1 = require("../../material/effect/EffectType");
-var Faction_1 = require("../../material/Faction");
-var getDiplomacyActions = function (_players) {
+import { EffectType } from '../../material/effect/EffectType';
+import { Faction } from '../../material/Faction';
+export const getDiplomacyActions = (_players) => {
     return TwoPlayerDiplomacyActions;
 };
-exports.getDiplomacyActions = getDiplomacyActions;
-var TwoPlayerDiplomacyActions = (_a = {},
-    _a[Faction_1.Faction.Robot] = [
+const TwoPlayerDiplomacyActions = {
+    [Faction.Robot]: [
         {
-            type: EffectType_1.EffectType.TakeLeaderBadge
+            type: EffectType.TakeLeaderBadge
         },
         {
-            type: EffectType_1.EffectType.WinZenithium,
+            type: EffectType.WinZenithium,
             quantity: 1
         }
     ],
-    _a[Faction_1.Faction.Human] = [
+    [Faction.Human]: [
         {
-            type: EffectType_1.EffectType.TakeLeaderBadge
+            type: EffectType.TakeLeaderBadge
         },
         {
-            type: EffectType_1.EffectType.WinCredit,
+            type: EffectType.WinCredit,
             quantity: 3
         }
     ],
-    _a[Faction_1.Faction.Animod] = [
+    [Faction.Animod]: [
         {
-            type: EffectType_1.EffectType.TakeLeaderBadge
+            type: EffectType.TakeLeaderBadge
         },
         {
-            type: EffectType_1.EffectType.Mobilize,
+            type: EffectType.Mobilize,
             quantity: 2
         }
-    ],
-    _a);
+    ]
+};