volleyballsimtypes 0.0.99 → 0.0.101

package/dist/esm/src/service/draft/draft-pick.d.ts

@@ -1,14 +1,14 @@
-import { Team } from '../team';
-import { Player } from '../player';
-interface DraftPickOpts {
-    readonly team: Team;
-    readonly pick: Player;
-    readonly priority: number;
-}
-export declare class DraftPick {
-    readonly team: Team;
-    readonly pick: Player;
-    readonly priority: number;
-    constructor({ team, pick, priority }: DraftPickOpts);
-}
-export {};
+import { Team } from '../team';
+import { Player } from '../player';
+interface DraftPickOpts {
+    readonly team: Team;
+    readonly pick: Player;
+    readonly priority: number;
+}
+export declare class DraftPick {
+    readonly team: Team;
+    readonly pick: Player;
+    readonly priority: number;
+    constructor({ team, pick, priority }: DraftPickOpts);
+}
+export {};

package/dist/esm/src/service/draft/draft-pick.js

@@ -1,7 +1,7 @@
-export class DraftPick {
-    constructor({ team, pick, priority }) {
-        this.team = team;
-        this.pick = pick;
-        this.priority = priority;
-    }
-}
+export class DraftPick {
+    constructor({ team, pick, priority }) {
+        this.team = team;
+        this.pick = pick;
+        this.priority = priority;
+    }
+}

package/dist/esm/src/service/draft/draft.d.ts

@@ -1,15 +1,15 @@
-import { DraftPick } from './draft-pick';
-interface DraftOpts {
-    readonly id: string;
-    readonly start: Date;
-    readonly end: Date;
-    readonly picks: DraftPick[];
-}
-export declare class Draft {
-    readonly id: string;
-    readonly start: Date;
-    readonly end: Date;
-    readonly picks: DraftPick[];
-    constructor({ id, start, end, picks }: DraftOpts);
-}
-export {};
+import { DraftPick } from './draft-pick';
+interface DraftOpts {
+    readonly id: string;
+    readonly start: Date;
+    readonly end: Date;
+    readonly picks: DraftPick[];
+}
+export declare class Draft {
+    readonly id: string;
+    readonly start: Date;
+    readonly end: Date;
+    readonly picks: DraftPick[];
+    constructor({ id, start, end, picks }: DraftOpts);
+}
+export {};

package/dist/esm/src/service/draft/draft.js

@@ -1,8 +1,8 @@
-export class Draft {
-    constructor({ id, start, end, picks }) {
-        this.id = id;
-        this.start = start;
-        this.end = end;
-        this.picks = picks;
-    }
-}
+export class Draft {
+    constructor({ id, start, end, picks }) {
+        this.id = id;
+        this.start = start;
+        this.end = end;
+        this.picks = picks;
+    }
+}

package/dist/esm/src/service/draft/index.d.ts

@@ -1,2 +1,2 @@
-export * from './draft';
-export * from './draft-pick';
+export * from './draft';
+export * from './draft-pick';

package/dist/esm/src/service/draft/index.js

@@ -1,2 +1,2 @@
-export * from './draft';
-export * from './draft-pick';
+export * from './draft';
+export * from './draft-pick';

package/dist/esm/src/service/event/__stubs__/index.d.ts

@@ -1,4 +1,4 @@
-import { Serve } from '../serve';
-import { Score } from '../score';
-export declare const serve: Serve;
-export declare const score: Score;
+import { Serve } from '../serve';
+import { Score } from '../score';
+export declare const serve: Serve;
+export declare const score: Score;

package/dist/esm/src/service/event/__stubs__/index.js

@@ -1,25 +1,25 @@
-import { Serve, ServeFailureEnum, ServeTypeEnum } from '../serve';
-import { player } from '../../player/__stubs__';
-import { CourtTargetEnum } from '../../match';
-import { EventTypeEnum } from '../rally-event';
-import { Score } from '../score';
-import { team } from '../../team/__stubs__';
-export const serve = new Serve({
-    score: 50,
-    order: 0,
-    id: 'e92f4abb-66f4-4b6c-a602-258404d04484',
-    player: player,
-    target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
-    eventType: EventTypeEnum.SERVE,
-    type: ServeTypeEnum.JUMP_FLOAT,
-    failure: ServeFailureEnum.NO_FAILURE,
-    modifier: 1,
-    activeTraits: []
-});
-export const score = new Score({
-    id: 'e92f4abb-66f4-4b6c-a602-258404d04484',
-    order: 0,
-    eventType: EventTypeEnum.SCORE,
-    player,
-    team
-});
+import { Serve, ServeFailureEnum, ServeTypeEnum } from '../serve';
+import { player } from '../../player/__stubs__';
+import { CourtTargetEnum } from '../../match';
+import { EventTypeEnum } from '../rally-event';
+import { Score } from '../score';
+import { team } from '../../team/__stubs__';
+export const serve = new Serve({
+    score: 50,
+    order: 0,
+    id: 'e92f4abb-66f4-4b6c-a602-258404d04484',
+    player: player,
+    target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
+    eventType: EventTypeEnum.SERVE,
+    type: ServeTypeEnum.JUMP_FLOAT,
+    failure: ServeFailureEnum.NO_FAILURE,
+    modifier: 1,
+    activeTraits: []
+});
+export const score = new Score({
+    id: 'e92f4abb-66f4-4b6c-a602-258404d04484',
+    order: 0,
+    eventType: EventTypeEnum.SCORE,
+    player,
+    team
+});

package/dist/esm/src/service/event/block.d.ts

@@ -1,29 +1,29 @@
-import { InPlayEvent, InPlayEventOpts } from './in-play-event';
-import { Player, Trait } from '../player';
-export declare enum BlockFailureEnum {
-    NO_FAILURE = 0,
-    FAULT = 1,
-    MISS = 2,
-    OUT_OF_BOUNDS = 3,
-    WIPE = 4,
-    TOOL = 5
-}
-export declare enum BlockTypeEnum {
-    NO_BLOCKER = 0,
-    SINGLE = 1,
-    DOUBLE = 2,
-    TRIPLE = 3
-}
-interface BlockOpts extends InPlayEventOpts {
-    readonly type: BlockTypeEnum;
-    readonly failure: BlockFailureEnum;
-    readonly blockers: Player[];
-}
-export declare class Block extends InPlayEvent {
-    readonly failure: BlockFailureEnum;
-    readonly type: BlockTypeEnum;
-    readonly blockers: Player[];
-    constructor({ id, order, score, player, target, failure, type, modifier, eventType, blockers, activeTraits }: BlockOpts);
-    static getScore(blockers: Player[], modifier: number, activeTraits: Trait[]): number;
-}
-export {};
+import { InPlayEvent, InPlayEventOpts } from './in-play-event';
+import { Player, Trait } from '../player';
+export declare enum BlockFailureEnum {
+    NO_FAILURE = 0,
+    FAULT = 1,
+    MISS = 2,
+    OUT_OF_BOUNDS = 3,
+    WIPE = 4,
+    TOOL = 5
+}
+export declare enum BlockTypeEnum {
+    NO_BLOCKER = 0,
+    SINGLE = 1,
+    DOUBLE = 2,
+    TRIPLE = 3
+}
+interface BlockOpts extends InPlayEventOpts {
+    readonly type: BlockTypeEnum;
+    readonly failure: BlockFailureEnum;
+    readonly blockers: Player[];
+}
+export declare class Block extends InPlayEvent {
+    readonly failure: BlockFailureEnum;
+    readonly type: BlockTypeEnum;
+    readonly blockers: Player[];
+    constructor({ id, order, score, player, target, failure, type, modifier, eventType, blockers, activeTraits }: BlockOpts);
+    static getScore(blockers: Player[], modifier: number, activeTraits: Trait[]): number;
+}
+export {};

package/dist/esm/src/service/event/block.js

@@ -1,61 +1,61 @@
-import { InPlayEvent } from './in-play-event';
-import { Trait } from '../player';
-export var BlockFailureEnum;
-(function (BlockFailureEnum) {
-    BlockFailureEnum[BlockFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
-    BlockFailureEnum[BlockFailureEnum["FAULT"] = 1] = "FAULT";
-    BlockFailureEnum[BlockFailureEnum["MISS"] = 2] = "MISS";
-    BlockFailureEnum[BlockFailureEnum["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
-    BlockFailureEnum[BlockFailureEnum["WIPE"] = 4] = "WIPE";
-    BlockFailureEnum[BlockFailureEnum["TOOL"] = 5] = "TOOL";
-})(BlockFailureEnum || (BlockFailureEnum = {}));
-export var BlockTypeEnum;
-(function (BlockTypeEnum) {
-    BlockTypeEnum[BlockTypeEnum["NO_BLOCKER"] = 0] = "NO_BLOCKER";
-    BlockTypeEnum[BlockTypeEnum["SINGLE"] = 1] = "SINGLE";
-    BlockTypeEnum[BlockTypeEnum["DOUBLE"] = 2] = "DOUBLE";
-    BlockTypeEnum[BlockTypeEnum["TRIPLE"] = 3] = "TRIPLE";
-})(BlockTypeEnum || (BlockTypeEnum = {}));
-export class Block extends InPlayEvent {
-    constructor({ id, order, score, player, target, failure, type, modifier, eventType, blockers, activeTraits }) {
-        super({ id, order, score, player, target, modifier, eventType, activeTraits });
-        this.type = type;
-        this.failure = failure;
-        this.blockers = blockers;
-    }
-    static getScore(blockers, modifier, activeTraits) {
-        const type = blockers.length;
-        if (blockers.length > 3)
-            throw new Error('UNKNOWN_TYPE');
-        let bmod;
-        switch (type) {
-            case BlockTypeEnum.NO_BLOCKER:
-                return 0;
-            case BlockTypeEnum.SINGLE:
-                bmod = 1;
-                break;
-            case BlockTypeEnum.DOUBLE:
-                bmod = 1.2;
-                break;
-            case BlockTypeEnum.TRIPLE:
-                bmod = 1.4;
-                break;
-            default:
-                throw new Error('UNKNOWN_TYPE');
-        }
-        const total = blockers.reduce((score, player) => {
-            return score + Block.calculateScore(player.stats, 'BLOCK', BlockTypeEnum[type]);
-        }, 0);
-        const avg = total / blockers.length;
-        let score = avg * bmod * modifier;
-        for (const trait of activeTraits) {
-            switch (true) {
-                case trait === Trait.MOVING_WALL: {
-                    score *= Trait.MOVING_WALL.modifier;
-                    break;
-                }
-            }
-        }
-        return score;
-    }
-}
+import { InPlayEvent } from './in-play-event';
+import { Trait } from '../player';
+export var BlockFailureEnum;
+(function (BlockFailureEnum) {
+    BlockFailureEnum[BlockFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+    BlockFailureEnum[BlockFailureEnum["FAULT"] = 1] = "FAULT";
+    BlockFailureEnum[BlockFailureEnum["MISS"] = 2] = "MISS";
+    BlockFailureEnum[BlockFailureEnum["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
+    BlockFailureEnum[BlockFailureEnum["WIPE"] = 4] = "WIPE";
+    BlockFailureEnum[BlockFailureEnum["TOOL"] = 5] = "TOOL";
+})(BlockFailureEnum || (BlockFailureEnum = {}));
+export var BlockTypeEnum;
+(function (BlockTypeEnum) {
+    BlockTypeEnum[BlockTypeEnum["NO_BLOCKER"] = 0] = "NO_BLOCKER";
+    BlockTypeEnum[BlockTypeEnum["SINGLE"] = 1] = "SINGLE";
+    BlockTypeEnum[BlockTypeEnum["DOUBLE"] = 2] = "DOUBLE";
+    BlockTypeEnum[BlockTypeEnum["TRIPLE"] = 3] = "TRIPLE";
+})(BlockTypeEnum || (BlockTypeEnum = {}));
+export class Block extends InPlayEvent {
+    constructor({ id, order, score, player, target, failure, type, modifier, eventType, blockers, activeTraits }) {
+        super({ id, order, score, player, target, modifier, eventType, activeTraits });
+        this.type = type;
+        this.failure = failure;
+        this.blockers = blockers;
+    }
+    static getScore(blockers, modifier, activeTraits) {
+        const type = blockers.length;
+        if (blockers.length > 3)
+            throw new Error('UNKNOWN_TYPE');
+        let bmod;
+        switch (type) {
+            case BlockTypeEnum.NO_BLOCKER:
+                return 0;
+            case BlockTypeEnum.SINGLE:
+                bmod = 1;
+                break;
+            case BlockTypeEnum.DOUBLE:
+                bmod = 1.2;
+                break;
+            case BlockTypeEnum.TRIPLE:
+                bmod = 1.4;
+                break;
+            default:
+                throw new Error('UNKNOWN_TYPE');
+        }
+        const total = blockers.reduce((score, player) => {
+            return score + Block.calculateScore(player.stats, 'BLOCK', BlockTypeEnum[type]);
+        }, 0);
+        const avg = total / blockers.length;
+        let score = avg * bmod * modifier;
+        for (const trait of activeTraits) {
+            switch (true) {
+                case trait === Trait.MOVING_WALL: {
+                    score *= Trait.MOVING_WALL.modifier;
+                    break;
+                }
+            }
+        }
+        return score;
+    }
+}

package/dist/esm/src/service/event/block.test.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/dist/esm/src/service/event/block.test.js

@@ -1,101 +1,101 @@
-import { describe, expect, test } from '@jest/globals';
-import { Block, BlockFailureEnum, BlockTypeEnum } from './block';
-import { player } from '../player/__stubs__';
-import { CourtTargetEnum } from '../match';
-import { EventTypeEnum } from './rally-event';
-import { v4 as uuidv4 } from 'uuid';
-describe('Block Test Module', () => {
-    let none;
-    let block;
-    let double;
-    let triple;
-    let failed;
-    beforeEach(() => {
-        none = new Block({
-            id: uuidv4(),
-            order: 1,
-            player: player,
-            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
-            failure: BlockFailureEnum.NO_FAILURE,
-            type: BlockTypeEnum.NO_BLOCKER,
-            eventType: EventTypeEnum.BLOCK,
-            modifier: 1,
-            blockers: [],
-            score: Block.getScore([], 1, []),
-            activeTraits: []
-        });
-        block = new Block({
-            id: uuidv4(),
-            order: 1,
-            player: player,
-            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
-            failure: BlockFailureEnum.NO_FAILURE,
-            type: BlockTypeEnum.SINGLE,
-            eventType: EventTypeEnum.BLOCK,
-            modifier: 1,
-            blockers: [player],
-            score: Block.getScore([player], 1, []),
-            activeTraits: []
-        });
-        double = new Block({
-            id: uuidv4(),
-            order: 1,
-            player: player,
-            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
-            failure: BlockFailureEnum.NO_FAILURE,
-            type: BlockTypeEnum.DOUBLE,
-            eventType: EventTypeEnum.BLOCK,
-            modifier: 1,
-            blockers: [player, player],
-            score: Block.getScore([player, player], 1, []),
-            activeTraits: []
-        });
-        triple = new Block({
-            id: uuidv4(),
-            order: 1,
-            player: player,
-            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
-            failure: BlockFailureEnum.NO_FAILURE,
-            type: BlockTypeEnum.TRIPLE,
-            eventType: EventTypeEnum.BLOCK,
-            modifier: 1,
-            blockers: [player, player, player],
-            score: Block.getScore([player, player, player], 1, []),
-            activeTraits: []
-        });
-        failed = new Block({
-            id: uuidv4(),
-            order: 1,
-            player: player,
-            target: CourtTargetEnum.NO_TARGET,
-            failure: BlockFailureEnum.FAULT,
-            type: BlockTypeEnum.TRIPLE,
-            eventType: EventTypeEnum.BLOCK,
-            modifier: 1,
-            blockers: [player],
-            score: Block.getScore([player], 1, []),
-            activeTraits: []
-        });
-    });
-    test('Should instantiate object properly', () => {
-        expect(block.target).toBe(CourtTargetEnum.OPPONENT_RIGHT_BACK);
-        expect(block.type).toBe(BlockTypeEnum.SINGLE);
-        expect(block.eventType).toBe(EventTypeEnum.BLOCK);
-        expect(block.player.id).toBe(player.id);
-        expect(block.failure).toBe(BlockFailureEnum.NO_FAILURE);
-        expect(failed.failure).toBe(BlockFailureEnum.FAULT);
-        expect(block.modifier).toBe(1);
-    });
-    // getScore Tests
-    test('Should get the correct score for all Block types', () => {
-        expect(none.score).toBe(0);
-        expect(block.score).toBe(7);
-        expect(double.score).toBe(8.4);
-        expect(triple.score).toBe(9.799999999999999);
-        expect(failed.score).toBe(7);
-    });
-    test('Should throw Error when getting score with invalid amount of blockers', () => {
-        function score() { Block.getScore([player, player, player, player, player], 1, []); }
-        expect(score).toThrow(/^UNKNOWN_TYPE$/);
-    });
-});
+import { describe, expect, test } from '@jest/globals';
+import { Block, BlockFailureEnum, BlockTypeEnum } from './block';
+import { player } from '../player/__stubs__';
+import { CourtTargetEnum } from '../match';
+import { EventTypeEnum } from './rally-event';
+import { v4 as uuidv4 } from 'uuid';
+describe('Block Test Module', () => {
+    let none;
+    let block;
+    let double;
+    let triple;
+    let failed;
+    beforeEach(() => {
+        none = new Block({
+            id: uuidv4(),
+            order: 1,
+            player: player,
+            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
+            failure: BlockFailureEnum.NO_FAILURE,
+            type: BlockTypeEnum.NO_BLOCKER,
+            eventType: EventTypeEnum.BLOCK,
+            modifier: 1,
+            blockers: [],
+            score: Block.getScore([], 1, []),
+            activeTraits: []
+        });
+        block = new Block({
+            id: uuidv4(),
+            order: 1,
+            player: player,
+            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
+            failure: BlockFailureEnum.NO_FAILURE,
+            type: BlockTypeEnum.SINGLE,
+            eventType: EventTypeEnum.BLOCK,
+            modifier: 1,
+            blockers: [player],
+            score: Block.getScore([player], 1, []),
+            activeTraits: []
+        });
+        double = new Block({
+            id: uuidv4(),
+            order: 1,
+            player: player,
+            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
+            failure: BlockFailureEnum.NO_FAILURE,
+            type: BlockTypeEnum.DOUBLE,
+            eventType: EventTypeEnum.BLOCK,
+            modifier: 1,
+            blockers: [player, player],
+            score: Block.getScore([player, player], 1, []),
+            activeTraits: []
+        });
+        triple = new Block({
+            id: uuidv4(),
+            order: 1,
+            player: player,
+            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
+            failure: BlockFailureEnum.NO_FAILURE,
+            type: BlockTypeEnum.TRIPLE,
+            eventType: EventTypeEnum.BLOCK,
+            modifier: 1,
+            blockers: [player, player, player],
+            score: Block.getScore([player, player, player], 1, []),
+            activeTraits: []
+        });
+        failed = new Block({
+            id: uuidv4(),
+            order: 1,
+            player: player,
+            target: CourtTargetEnum.NO_TARGET,
+            failure: BlockFailureEnum.FAULT,
+            type: BlockTypeEnum.TRIPLE,
+            eventType: EventTypeEnum.BLOCK,
+            modifier: 1,
+            blockers: [player],
+            score: Block.getScore([player], 1, []),
+            activeTraits: []
+        });
+    });
+    test('Should instantiate object properly', () => {
+        expect(block.target).toBe(CourtTargetEnum.OPPONENT_RIGHT_BACK);
+        expect(block.type).toBe(BlockTypeEnum.SINGLE);
+        expect(block.eventType).toBe(EventTypeEnum.BLOCK);
+        expect(block.player.id).toBe(player.id);
+        expect(block.failure).toBe(BlockFailureEnum.NO_FAILURE);
+        expect(failed.failure).toBe(BlockFailureEnum.FAULT);
+        expect(block.modifier).toBe(1);
+    });
+    // getScore Tests
+    test('Should get the correct score for all Block types', () => {
+        expect(none.score).toBe(0);
+        expect(block.score).toBe(7);
+        expect(double.score).toBe(8.4);
+        expect(triple.score).toBe(9.799999999999999);
+        expect(failed.score).toBe(7);
+    });
+    test('Should throw Error when getting score with invalid amount of blockers', () => {
+        function score() { Block.getScore([player, player, player, player, player], 1, []); }
+        expect(score).toThrow(/^UNKNOWN_TYPE$/);
+    });
+});

package/dist/esm/src/service/event/in-play-event.d.ts

@@ -1,19 +1,19 @@
-import { RallyEvent, RallyEventOpts } from './rally-event';
-import { CourtTargetEnum } from '../match';
-import { PerformanceStats, Trait } from '../player';
-export interface InPlayEventOpts extends RallyEventOpts {
-    readonly target: CourtTargetEnum;
-    readonly modifier: number;
-    readonly score: number;
-    readonly activeTraits: Trait[];
-}
-export declare abstract class InPlayEvent extends RallyEvent {
-    abstract failure: number;
-    abstract type: number;
-    readonly target: CourtTargetEnum;
-    readonly modifier: number;
-    readonly score: number;
-    readonly activeTraits: Trait[];
-    protected constructor({ id, eventType, player, target, modifier, score, order, activeTraits }: InPlayEventOpts);
-    protected static calculateScore(stats: PerformanceStats, eventType: string, type: string): number;
-}
+import { RallyEvent, RallyEventOpts } from './rally-event';
+import { CourtTargetEnum } from '../match';
+import { PerformanceStats, Trait } from '../player';
+export interface InPlayEventOpts extends RallyEventOpts {
+    readonly target: CourtTargetEnum;
+    readonly modifier: number;
+    readonly score: number;
+    readonly activeTraits: Trait[];
+}
+export declare abstract class InPlayEvent extends RallyEvent {
+    abstract failure: number;
+    abstract type: number;
+    readonly target: CourtTargetEnum;
+    readonly modifier: number;
+    readonly score: number;
+    readonly activeTraits: Trait[];
+    protected constructor({ id, eventType, player, target, modifier, score, order, activeTraits }: InPlayEventOpts);
+    protected static calculateScore(stats: PerformanceStats, eventType: string, type: string): number;
+}

package/dist/esm/src/service/event/in-play-event.js

@@ -1,20 +1,20 @@
-import { RallyEvent } from './rally-event';
-import formula from '../../../data/event.formula.json';
-import { getKeys } from '../utils';
-export class InPlayEvent extends RallyEvent {
-    constructor({ id, eventType, player, target, modifier, score, order, activeTraits }) {
-        super({ id, order, player, eventType });
-        this.target = target;
-        this.score = score;
-        this.modifier = modifier;
-        this.activeTraits = activeTraits;
-    }
-    static calculateScore(stats, eventType, type) {
-        const weight = formula[eventType][type];
-        const penalty = weight.penalty ?? 0;
-        const score = getKeys(weight).reduce((score, key) => {
-            return score + (key === 'penalty' ? 0 : stats[key] * weight[key]);
-        }, 0);
-        return Math.round(score * (1 - penalty));
-    }
-}
+import { RallyEvent } from './rally-event';
+import formula from '../../../data/event.formula.json';
+import { getKeys } from '../utils';
+export class InPlayEvent extends RallyEvent {
+    constructor({ id, eventType, player, target, modifier, score, order, activeTraits }) {
+        super({ id, order, player, eventType });
+        this.target = target;
+        this.score = score;
+        this.modifier = modifier;
+        this.activeTraits = activeTraits;
+    }
+    static calculateScore(stats, eventType, type) {
+        const weight = formula[eventType][type];
+        const penalty = weight.penalty ?? 0;
+        const score = getKeys(weight).reduce((score, key) => {
+            return score + (key === 'penalty' ? 0 : stats[key] * weight[key]);
+        }, 0);
+        return Math.round(score * (1 - penalty));
+    }
+}