bard-legends-framework 0.10.9 → 0.11.0

package/dist/utilities/animator/animating-content/slide-in-content.d.ts

@@ -0,0 +1,37 @@
+import { Vector } from 'helpers-lib';
+import { Container } from '../../../pixi';
+import { AnimatorAnimation } from '../animations';
+export interface ScrollInContentOptions {
+    readonly duration: number;
+    readonly animation: AnimatorAnimation;
+    readonly size: Vector;
+    readonly margin: number;
+    readonly direction: 'horizontal' | 'vertical';
+}
+export declare class SlideInContentByIndex extends Container {
+    private createFunction;
+    private options;
+    private directionProperty;
+    private stateAnimation;
+    private contents;
+    constructor(createFunction: (value: {
+        index: number;
+        container: Container;
+    }) => void, partialOptions?: Partial<ScrollInContentOptions>);
+    setIndex(index: number, options?: {
+        instant?: boolean;
+    }): this;
+    private createMask;
+}
+export declare class SlideInContent<T> extends SlideInContentByIndex {
+    readonly itemToIndex: Map<T, number>;
+    readonly indexToItem: Map<number, T>;
+    constructor(items: T[], createFunction: (value: {
+        index: number;
+        item: T;
+        container: Container;
+    }) => void, partialOptions?: Partial<ScrollInContentOptions>);
+    setItem(item: T, options?: {
+        instant?: boolean;
+    }): this;
+}

package/dist/utilities/animator/animating-content/slide-in-content.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlideInContent = exports.SlideInContentByIndex = void 0;
+const helpers_lib_1 = require("helpers-lib");
+const pixi_1 = require("../../../pixi");
+const animations_1 = require("../animations");
+const slide_state_animation_1 = require("../state-animation/slide-state-animation");
+class SlideInContentByIndex extends pixi_1.Container {
+    constructor(createFunction, partialOptions) {
+        super();
+        this.createFunction = createFunction;
+        this.directionProperty = 'x';
+        this.contents = new Map();
+        this.options = {
+            duration: 300,
+            animation: new animations_1.AnimationEaseInOutCubic(),
+            size: new helpers_lib_1.Vector(500, 500),
+            margin: 20,
+            direction: 'horizontal',
+            ...partialOptions
+        };
+        let fullSize = this.options.direction === 'horizontal'
+            ? new helpers_lib_1.Vector(this.options.size.x + this.options.margin * 2, this.options.size.y)
+            : new helpers_lib_1.Vector(this.options.size.x, this.options.size.y + this.options.margin * 2);
+        let wrapper = new pixi_1.Container()
+            .setPosition(this.options.direction === 'horizontal' ? new helpers_lib_1.Vector(-this.options.margin, 0) : new helpers_lib_1.Vector(0, -this.options.margin), { round: false })
+            .displayParent(this)
+            .attach(this);
+        this.createMask(fullSize, this.options.margin, this.options.direction, wrapper);
+        this.directionProperty = this.options.direction === 'horizontal' ? 'x' : 'y';
+        this.stateAnimation = new slide_state_animation_1.SlideStateAnimation({
+            duration: this.options.duration,
+            animation: this.options.animation
+        })
+            .onStateChange((state, index) => {
+            if (state === slide_state_animation_1.SlideStateAnimationState.appear) {
+                let container = new pixi_1.Container().displayParent(this).attach(this);
+                this.contents.set(index, container);
+                this.createFunction({ index, container });
+            }
+            else {
+                let container = this.contents.get(index);
+                if (container) {
+                    container.destroy();
+                    this.contents.delete(index);
+                }
+            }
+        })
+            .onValueChange((value, index) => {
+            let container = this.contents.get(index);
+            if (container) {
+                let vec = { x: 0, y: 0 };
+                vec[this.directionProperty] = fullSize[this.directionProperty] * value + this.options.margin;
+                container.setPosition(helpers_lib_1.Vector.fromVec2(vec), { round: false });
+            }
+        })
+            .attach(this);
+        this.addChildTo = wrapper;
+    }
+    setIndex(index, options) {
+        this.stateAnimation.setIndex(index, options);
+        return this;
+    }
+    createMask(size, padding, direction, container) {
+        new pixi_1.ScrollMaskUI(container, new helpers_lib_1.Vector(size.x, size.y), padding, direction).attach(this);
+    }
+}
+exports.SlideInContentByIndex = SlideInContentByIndex;
+class SlideInContent extends SlideInContentByIndex {
+    constructor(items, createFunction, partialOptions) {
+        super((value) => {
+            let item = this.indexToItem.get(value.index);
+            if (item) {
+                createFunction({ index: value.index, item, container: value.container });
+            }
+            else {
+                throw new Error(`SlideInContent: The item with index '${value.index}' is not part of the items list`);
+            }
+        }, partialOptions);
+        this.itemToIndex = new Map();
+        this.indexToItem = new Map();
+        items.forEach((item, index) => {
+            this.itemToIndex.set(item, index);
+            this.indexToItem.set(index, item);
+        });
+    }
+    setItem(item, options) {
+        let index = this.itemToIndex.get(item);
+        if (index !== undefined) {
+            this.setIndex(index, options);
+        }
+        else {
+            throw new Error(`SlideInContent: The item '${item}' is not part of the items list`);
+        }
+        return this;
+    }
+}
+exports.SlideInContent = SlideInContent;
+//# sourceMappingURL=slide-in-content.js.map

package/dist/utilities/animator/animations.d.ts

@@ -0,0 +1,37 @@
+export interface AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
+export declare class AnimationInterpolationFunctions {
+    static boomerangTime(time: number): number;
+    static lineer(time: number): number;
+    static easeIn(time: number): number;
+    static easeOut(time: number): number;
+    static easeInOut(time: number): number;
+    static easeInOutCubic(t: number): number;
+}
+export declare class AnimationLineer implements AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
+export declare class AnimationEaseIn implements AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
+export declare class AnimationEaseOut implements AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
+export declare class AnimationEaseInOut implements AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
+export declare class AnimationEaseInOutCubic implements AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
+export declare class AnimationFlicker implements AnimatorAnimation {
+    private timeGrid;
+    start(): void;
+    multiplierFunction(t: number): number;
+}

package/dist/utilities/animator/animations.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnimationFlicker = exports.AnimationEaseInOutCubic = exports.AnimationEaseInOut = exports.AnimationEaseOut = exports.AnimationEaseIn = exports.AnimationLineer = exports.AnimationInterpolationFunctions = void 0;
+const helpers_lib_1 = require("helpers-lib");
+class AnimationInterpolationFunctions {
+    static boomerangTime(time) {
+        return 1 - Math.abs(time - 0.5) * 2;
+    }
+    static lineer(time) {
+        return time;
+    }
+    static easeIn(time) {
+        return Math.pow(time, 2);
+    }
+    static easeOut(time) {
+        return 1 - Math.pow(1 - time, 2);
+    }
+    static easeInOut(time) {
+        if (time < 0.5) {
+            return 2 * time * time;
+        }
+        else {
+            time -= 1;
+            return 1 - 2 * time * time;
+        }
+    }
+    static easeInOutCubic(t) {
+        let a = 2 * t - 2;
+        return t < 0.5 ? 4 * Math.pow(t, 3) : (t - 1) * Math.pow(a, 2) + 1;
+    }
+}
+exports.AnimationInterpolationFunctions = AnimationInterpolationFunctions;
+class AnimationLineer {
+    start() { }
+    multiplierFunction(t) {
+        return AnimationInterpolationFunctions.lineer(t);
+    }
+}
+exports.AnimationLineer = AnimationLineer;
+class AnimationEaseIn {
+    start() { }
+    multiplierFunction(t) {
+        return AnimationInterpolationFunctions.easeIn(t);
+    }
+}
+exports.AnimationEaseIn = AnimationEaseIn;
+class AnimationEaseOut {
+    start() { }
+    multiplierFunction(t) {
+        return AnimationInterpolationFunctions.easeOut(t);
+    }
+}
+exports.AnimationEaseOut = AnimationEaseOut;
+class AnimationEaseInOut {
+    start() { }
+    multiplierFunction(t) {
+        return AnimationInterpolationFunctions.easeInOut(t);
+    }
+}
+exports.AnimationEaseInOut = AnimationEaseInOut;
+class AnimationEaseInOutCubic {
+    start() { }
+    multiplierFunction(t) {
+        return AnimationInterpolationFunctions.easeInOutCubic(t);
+    }
+}
+exports.AnimationEaseInOutCubic = AnimationEaseInOutCubic;
+class AnimationFlicker {
+    start() {
+        this.timeGrid = new Array(10).fill(0);
+        helpers_lib_1.Random.integerBetween(0, 9);
+        this.timeGrid[helpers_lib_1.Random.integerBetween(0, 9)] = Math.random();
+        if (Math.random() < 0.3) {
+            helpers_lib_1.Random.integerBetween(0, 9);
+            this.timeGrid[helpers_lib_1.Random.integerBetween(0, 9)] = Math.random();
+        }
+        if (Math.random() < 0.2) {
+            helpers_lib_1.Random.integerBetween(0, 9);
+            this.timeGrid[helpers_lib_1.Random.integerBetween(0, 9)] = Math.random();
+        }
+    }
+    multiplierFunction(t) {
+        let index = Math.floor(t * 10);
+        return this.timeGrid[index];
+    }
+}
+exports.AnimationFlicker = AnimationFlicker;
+//# sourceMappingURL=animations.js.map

package/dist/utilities/animator/animator.d.ts

@@ -0,0 +1,61 @@
+import { Attachable } from 'actions-lib';
+import { AnimatorAnimation } from './animations';
+export interface AnimationState {
+    duration: number;
+    elapsedTime: number;
+    startingValue: number;
+    targetValue: number;
+    loop: boolean;
+    completeAnimationsHandling: CompleteAnimationsHandlingType;
+}
+export declare enum ReAnimateHandlingType {
+    throwError = "throwError",
+    ignoreNewAnimation = "ignoreNewAnimation",
+    completePrevious = "completePrevious"
+}
+export declare enum CompleteAnimationsHandlingType {
+    returnToOriginal = "returnToOriginal",
+    stayInCurrentState = "stayInCurrentState",
+    jumpToEnd = "jumpToEnd"
+}
+export interface AnimationOptions {
+    duration?: number;
+    animation?: AnimatorAnimation;
+    loop?: boolean;
+    reAnimateHandling?: ReAnimateHandlingType;
+    completeAnimationsHandling?: CompleteAnimationsHandlingType;
+}
+export declare class Animator<T> extends Attachable {
+    private target;
+    private static animatedObjects;
+    private effectOn;
+    private defaultDuration;
+    private defaultAnimation;
+    private defaultLoop;
+    private defaultReAnimateHandling;
+    private defaultCompleteAnimationsHandling;
+    private onChangeCallback?;
+    private onCompleteCallback?;
+    private running;
+    private propertyStates;
+    private updateCycleSubscription;
+    private allResolvers;
+    get isAnimating(): boolean;
+    constructor(target: T, effectOn: string | string[], options?: AnimationOptions);
+    onChange(callback: (target: T) => void): Animator<T>;
+    onComplete(callback: (key: string, value: number) => void): Animator<T>;
+    destroy(): void;
+    getAnimationStateOfKey(key: string): AnimationState | undefined;
+    pauseAnimations(): void;
+    resumeAnimations(): void;
+    completeAnimations(completeAnimationsHandling?: CompleteAnimationsHandlingType): void;
+    set(values: Record<string, any>): void;
+    animate(values: Record<string, any>, options?: AnimationOptions): Promise<void>;
+    private completeAnimationOfProperty;
+    private checkOngoingAnimations;
+    private update;
+    private subscribeUpdateCycle;
+    private unsubscribeUpdateCycle;
+    private checkPropertyValidity;
+    private triggerOnChange;
+}

package/dist/utilities/animator/animator.js

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Animator = exports.CompleteAnimationsHandlingType = exports.ReAnimateHandlingType = void 0;
+const actions_lib_1 = require("actions-lib");
+const helpers_lib_1 = require("helpers-lib");
+const update_cycle_1 = require("../../game-entities/update-cycle");
+const animations_1 = require("./animations");
+var ReAnimateHandlingType;
+(function (ReAnimateHandlingType) {
+    ReAnimateHandlingType["throwError"] = "throwError";
+    ReAnimateHandlingType["ignoreNewAnimation"] = "ignoreNewAnimation";
+    ReAnimateHandlingType["completePrevious"] = "completePrevious";
+})(ReAnimateHandlingType || (exports.ReAnimateHandlingType = ReAnimateHandlingType = {}));
+var CompleteAnimationsHandlingType;
+(function (CompleteAnimationsHandlingType) {
+    CompleteAnimationsHandlingType["returnToOriginal"] = "returnToOriginal";
+    CompleteAnimationsHandlingType["stayInCurrentState"] = "stayInCurrentState";
+    CompleteAnimationsHandlingType["jumpToEnd"] = "jumpToEnd";
+})(CompleteAnimationsHandlingType || (exports.CompleteAnimationsHandlingType = CompleteAnimationsHandlingType = {}));
+const DEFAULT_DURATION = 200;
+const DEFAULT_ANIMATION = new animations_1.AnimationLineer();
+const DEFAULT_LOOP = false;
+const DEFAULT_RE_ANIMATE_HANDLING = ReAnimateHandlingType.throwError;
+const DEFAULT_COMPLETE_ANIMATIONS_HANDLING = CompleteAnimationsHandlingType.stayInCurrentState;
+class Animator extends actions_lib_1.Attachable {
+    static { this.animatedObjects = new Map(); }
+    get isAnimating() {
+        return this.propertyStates.size > 0;
+    }
+    constructor(target, effectOn, options = {}) {
+        super();
+        this.target = target;
+        this.effectOn = new Set();
+        this.running = true;
+        this.propertyStates = new Map();
+        this.allResolvers = new Set();
+        if (!helpers_lib_1.Comparator.isObject(target)) {
+            this.attachToRoot();
+            throw new Error(`Animator: target is not an object! Target: "${target}"`);
+        }
+        this.effectOn = helpers_lib_1.Comparator.isArray(effectOn) ? new Set(effectOn) : new Set([effectOn]);
+        let animatedObjectProperties = Animator.animatedObjects.get(target);
+        if (!animatedObjectProperties) {
+            animatedObjectProperties = new Set();
+            Animator.animatedObjects.set(target, animatedObjectProperties);
+        }
+        this.effectOn.forEach(key => {
+            if (animatedObjectProperties.has(key)) {
+                this.attachToRoot();
+                throw new Error(`Animator: target property is already animated! Target: "${JSON.stringify(target, undefined, 2)}", Property: "${key}"`);
+            }
+            animatedObjectProperties.add(key);
+        });
+        this.defaultDuration = options.duration ?? DEFAULT_DURATION;
+        this.defaultAnimation = options.animation ?? DEFAULT_ANIMATION;
+        this.defaultLoop = options.loop ?? DEFAULT_LOOP;
+        this.defaultReAnimateHandling = options.reAnimateHandling ?? DEFAULT_RE_ANIMATE_HANDLING;
+        this.defaultCompleteAnimationsHandling = options.completeAnimationsHandling ?? DEFAULT_COMPLETE_ANIMATIONS_HANDLING;
+        this.effectOn.forEach(key => {
+            if (!helpers_lib_1.Comparator.hasProperty(target, key)) {
+                this.attachToRoot();
+                throw new Error(`Animator: target does not have property. Target property: "${key}"`);
+            }
+            else if (!helpers_lib_1.Comparator.isNumber(target[key])) {
+                this.attachToRoot();
+                throw new Error(`Animator: target property is not a number. Target property: "${key}"`);
+            }
+        });
+    }
+    onChange(callback) {
+        if (this.onChangeCallback) {
+            this.attachToRoot();
+            throw new Error('Animator: onChangeCallback is already set!');
+        }
+        this.onChangeCallback = callback;
+        return this;
+    }
+    onComplete(callback) {
+        if (this.onCompleteCallback) {
+            this.attachToRoot();
+            throw new Error('Animator: onCompleteCallback is already set!');
+        }
+        this.onCompleteCallback = callback;
+        return this;
+    }
+    destroy() {
+        if (!this.destroyed) {
+            this.onChangeCallback = undefined;
+            this.onCompleteCallback = undefined;
+            this.defaultAnimation = DEFAULT_ANIMATION;
+            this.propertyStates.clear();
+            let animatedObjectProperties = Animator.animatedObjects.get(this.target);
+            this.effectOn.forEach(key => animatedObjectProperties.delete(key));
+            if (animatedObjectProperties.size <= 0) {
+                Animator.animatedObjects.delete(this.target);
+            }
+            this.target = undefined;
+            this.allResolvers.forEach(resolver => resolver());
+            this.allResolvers.clear();
+            super.destroy();
+        }
+    }
+    getAnimationStateOfKey(key) {
+        let propertyState = this.propertyStates.get(key);
+        if (propertyState) {
+            return {
+                duration: propertyState.duration,
+                elapsedTime: propertyState.elapsedTime,
+                startingValue: propertyState.startingValue,
+                targetValue: propertyState.targetValue,
+                loop: propertyState.loop,
+                completeAnimationsHandling: propertyState.completeAnimationsHandling
+            };
+        }
+    }
+    pauseAnimations() {
+        this.running = false;
+    }
+    resumeAnimations() {
+        this.running = true;
+    }
+    completeAnimations(completeAnimationsHandling) {
+        let triggerOnChange = false;
+        this.propertyStates.forEach((value, key) => {
+            let completeAnimationsHandlingFinal = completeAnimationsHandling ?? value.completeAnimationsHandling;
+            if (completeAnimationsHandlingFinal === CompleteAnimationsHandlingType.returnToOriginal) {
+                if (this.target[key] !== value.startingValue) {
+                    triggerOnChange = true;
+                    this.target[key] = value.startingValue;
+                }
+            }
+            else if (completeAnimationsHandlingFinal === CompleteAnimationsHandlingType.jumpToEnd) {
+                if (this.target[key] !== value.targetValue) {
+                    triggerOnChange = true;
+                    this.target[key] = value.targetValue;
+                }
+            }
+            this.completeAnimationOfProperty(value);
+        });
+        triggerOnChange && this.triggerOnChange();
+    }
+    set(values) {
+        Object.keys(values).forEach(key => {
+            this.checkPropertyValidity(key);
+        });
+        this.checkOngoingAnimations(values);
+        let triggerOnChange = false;
+        Object.keys(values).forEach(key => {
+            triggerOnChange = triggerOnChange || this.target[key] !== values[key];
+            this.target[key] = values[key];
+        });
+        triggerOnChange && this.triggerOnChange();
+    }
+    async animate(values, options = {}) {
+        if (this.destroyed) {
+            return;
+        }
+        let valueKeys = Object.keys(values);
+        valueKeys.forEach(key => {
+            this.checkPropertyValidity(key);
+        });
+        this.checkOngoingAnimations(values, options.reAnimateHandling);
+        return new Promise(resolveAll => {
+            this.allResolvers.add(resolveAll);
+            Promise.all(Object.keys(values).map(key => new Promise(resolve => {
+                let duration = options.duration ?? this.defaultDuration;
+                let animation = options.animation ?? this.defaultAnimation;
+                let loop = options.loop ?? this.defaultLoop;
+                let completeAnimationsHandling = options.completeAnimationsHandling ?? this.defaultCompleteAnimationsHandling;
+                let startingValue = this.target[key];
+                let targetValue = values[key];
+                if (startingValue === targetValue && !loop) {
+                    resolve(undefined);
+                    return;
+                }
+                animation.start();
+                try {
+                    this.propertyStates.set(key, {
+                        propertyName: key,
+                        duration,
+                        animation,
+                        elapsedTime: 0,
+                        startingValue,
+                        targetValue,
+                        loop,
+                        completeAnimationsHandling,
+                        completionCallback: () => {
+                            resolve(undefined);
+                        }
+                    });
+                }
+                catch {
+                    resolveAll();
+                    this.allResolvers.delete(resolveAll);
+                }
+            }))).then(() => {
+                resolveAll();
+                this.allResolvers.delete(resolveAll);
+            });
+            this.subscribeUpdateCycle();
+        });
+    }
+    completeAnimationOfProperty(propertyState) {
+        let currentState = this.target[propertyState.propertyName];
+        this.propertyStates.delete(propertyState.propertyName);
+        try {
+            propertyState.completionCallback();
+            this.onCompleteCallback?.(propertyState.propertyName, currentState);
+        }
+        catch (e) {
+            console.error('Animator:', e);
+        }
+    }
+    checkOngoingAnimations(values, reAnimateHandling) {
+        reAnimateHandling = reAnimateHandling ?? this.defaultReAnimateHandling;
+        Object.keys(values).forEach(key => {
+            let previousState = this.propertyStates.get(key);
+            if (previousState) {
+                if (reAnimateHandling === ReAnimateHandlingType.throwError) {
+                    this.attachToRoot();
+                    throw new Error(`Animator: property is already being animated. Property: "${key}"`);
+                }
+                else if (reAnimateHandling === ReAnimateHandlingType.ignoreNewAnimation) {
+                    delete values[key];
+                }
+                else if (reAnimateHandling === ReAnimateHandlingType.completePrevious) {
+                    this.completeAnimationOfProperty(previousState);
+                }
+            }
+        });
+    }
+    update(delta) {
+        if (this.running && !this.destroyed) {
+            let triggerOnChange = this.propertyStates.size;
+            let propertyStatesToComplete = [];
+            this.propertyStates.forEach((value, key) => {
+                value.elapsedTime += delta;
+                let animationIsCompete = value.elapsedTime >= value.duration;
+                if (animationIsCompete) {
+                    if (value.loop) {
+                        value.animation.start();
+                        value.elapsedTime -= value.duration;
+                        animationIsCompete = false;
+                    }
+                    else {
+                        if (value.completeAnimationsHandling === CompleteAnimationsHandlingType.returnToOriginal) {
+                            this.target[key] = value.startingValue;
+                        }
+                        else {
+                            this.target[key] = value.targetValue;
+                        }
+                        // Do not complete inside the forEach loop, completion can start a new animation which will put forEach into infinite loop
+                        propertyStatesToComplete.push(value);
+                    }
+                }
+                if (!animationIsCompete) {
+                    let multiplier = value.animation.multiplierFunction(value.elapsedTime / value.duration);
+                    let relativeTarget = value.targetValue - value.startingValue;
+                    this.target[key] = relativeTarget * multiplier + value.startingValue;
+                }
+            });
+            propertyStatesToComplete.forEach(value => {
+                this.completeAnimationOfProperty(value);
+            });
+            triggerOnChange && this.triggerOnChange();
+            if (this.propertyStates.size <= 0) {
+                this.unsubscribeUpdateCycle();
+            }
+        }
+    }
+    subscribeUpdateCycle() {
+        if (!this.updateCycleSubscription && !this.destroyed) {
+            this.updateCycleSubscription = update_cycle_1.UpdateCycle.beforeSceneUpdateAction
+                .subscribe(update => {
+                try {
+                    this.update(update.delta);
+                }
+                catch (e) {
+                    console.error('Animator:', e);
+                    this.propertyStates.forEach(value => {
+                        try {
+                            value.completionCallback();
+                        }
+                        catch (err) {
+                            console.error('Animator:', err);
+                        }
+                    });
+                    this.propertyStates = new Map();
+                    this.unsubscribeUpdateCycle();
+                }
+            })
+                .attachToRoot();
+        }
+    }
+    unsubscribeUpdateCycle() {
+        this.updateCycleSubscription?.destroy();
+        this.updateCycleSubscription = undefined;
+    }
+    checkPropertyValidity(key) {
+        if (!this.effectOn.has(key)) {
+            this.attachToRoot();
+            throw new Error(`Animator: not effected property is tried to update. Key: "${key}", EffectOn: "${this.effectOn}"`);
+        }
+    }
+    triggerOnChange() {
+        try {
+            this.onChangeCallback?.(this.target);
+        }
+        catch (e) {
+            console.error('Animator:', e);
+        }
+    }
+}
+exports.Animator = Animator;
+//# sourceMappingURL=animator.js.map

package/dist/utilities/animator/animator.test.d.ts

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