text: (function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
    typeof define === 'function' && define.amd ? define(factory) :
    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.rexfadeplugin = factory());
  })(this, (function () { 'use strict';
  
    function _typeof(obj) {
      "@babel/helpers - typeof";
  
      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
        return typeof obj;
      } : function (obj) {
        return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
      }, _typeof(obj);
    }
  
    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
  
    function _defineProperties(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
      }
    }
  
    function _createClass(Constructor, protoProps, staticProps) {
      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
      if (staticProps) _defineProperties(Constructor, staticProps);
      Object.defineProperty(Constructor, "prototype", {
        writable: false
      });
      return Constructor;
    }
  
    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function");
      }
  
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          writable: true,
          configurable: true
        }
      });
      Object.defineProperty(subClass, "prototype", {
        writable: false
      });
      if (superClass) _setPrototypeOf(subClass, superClass);
    }
  
    function _getPrototypeOf(o) {
      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
        return o.__proto__ || Object.getPrototypeOf(o);
      };
      return _getPrototypeOf(o);
    }
  
    function _setPrototypeOf(o, p) {
      _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
        o.__proto__ = p;
        return o;
      };
      return _setPrototypeOf(o, p);
    }
  
    function _isNativeReflectConstruct() {
      if (typeof Reflect === "undefined" || !Reflect.construct) return false;
      if (Reflect.construct.sham) return false;
      if (typeof Proxy === "function") return true;
  
      try {
        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
        return true;
      } catch (e) {
        return false;
      }
    }
  
    function _assertThisInitialized(self) {
      if (self === void 0) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
  
      return self;
    }
  
    function _possibleConstructorReturn(self, call) {
      if (call && (typeof call === "object" || typeof call === "function")) {
        return call;
      } else if (call !== void 0) {
        throw new TypeError("Derived constructors may only return object or undefined");
      }
  
      return _assertThisInitialized(self);
    }
  
    function _createSuper(Derived) {
      var hasNativeReflectConstruct = _isNativeReflectConstruct();
  
      return function _createSuperInternal() {
        var Super = _getPrototypeOf(Derived),
            result;
  
        if (hasNativeReflectConstruct) {
          var NewTarget = _getPrototypeOf(this).constructor;
  
          result = Reflect.construct(Super, arguments, NewTarget);
        } else {
          result = Super.apply(this, arguments);
        }
  
        return _possibleConstructorReturn(this, result);
      };
    }
  
    function _superPropBase(object, property) {
      while (!Object.prototype.hasOwnProperty.call(object, property)) {
        object = _getPrototypeOf(object);
        if (object === null) break;
      }
  
      return object;
    }
  
    function _get() {
      if (typeof Reflect !== "undefined" && Reflect.get) {
        _get = Reflect.get.bind();
      } else {
        _get = function _get(target, property, receiver) {
          var base = _superPropBase(target, property);
  
          if (!base) return;
          var desc = Object.getOwnPropertyDescriptor(base, property);
  
          if (desc.get) {
            return desc.get.call(arguments.length < 3 ? target : receiver);
          }
  
          return desc.value;
        };
      }
  
      return _get.apply(this, arguments);
    }
  
    var EventEmitterMethods = {
      setEventEmitter: function setEventEmitter(eventEmitter, EventEmitterClass) {
        if (EventEmitterClass === undefined) {
          EventEmitterClass = Phaser.Events.EventEmitter; // Use built-in EventEmitter class by default
        }
  
        this._privateEE = eventEmitter === true || eventEmitter === undefined;
        this._eventEmitter = this._privateEE ? new EventEmitterClass() : eventEmitter;
        return this;
      },
      destroyEventEmitter: function destroyEventEmitter() {
        if (this._eventEmitter && this._privateEE) {
          this._eventEmitter.shutdown();
        }
  
        return this;
      },
      getEventEmitter: function getEventEmitter() {
        return this._eventEmitter;
      },
      on: function on() {
        if (this._eventEmitter) {
          this._eventEmitter.on.apply(this._eventEmitter, arguments);
        }
  
        return this;
      },
      once: function once() {
        if (this._eventEmitter) {
          this._eventEmitter.once.apply(this._eventEmitter, arguments);
        }
  
        return this;
      },
      off: function off() {
        if (this._eventEmitter) {
          this._eventEmitter.off.apply(this._eventEmitter, arguments);
        }
  
        return this;
      },
      emit: function emit(event) {
        if (this._eventEmitter && event) {
          this._eventEmitter.emit.apply(this._eventEmitter, arguments);
        }
  
        return this;
      },
      addListener: function addListener() {
        if (this._eventEmitter) {
          this._eventEmitter.addListener.apply(this._eventEmitter, arguments);
        }
  
        return this;
      },
      removeListener: function removeListener() {
        if (this._eventEmitter) {
          this._eventEmitter.removeListener.apply(this._eventEmitter, arguments);
        }
  
        return this;
      },
      removeAllListeners: function removeAllListeners() {
        if (this._eventEmitter) {
          this._eventEmitter.removeAllListeners.apply(this._eventEmitter, arguments);
        }
  
        return this;
      },
      listenerCount: function listenerCount() {
        if (this._eventEmitter) {
          return this._eventEmitter.listenerCount.apply(this._eventEmitter, arguments);
        }
  
        return 0;
      },
      listeners: function listeners() {
        if (this._eventEmitter) {
          return this._eventEmitter.listeners.apply(this._eventEmitter, arguments);
        }
  
        return [];
      },
      eventNames: function eventNames() {
        if (this._eventEmitter) {
          return this._eventEmitter.eventNames.apply(this._eventEmitter, arguments);
        }
  
        return [];
      }
    };
  
    var SceneClass = Phaser.Scene;
  
    var IsSceneObject = function IsSceneObject(object) {
      return object instanceof SceneClass;
    };
  
    var GetSceneObject = function GetSceneObject(object) {
      if (object == null || _typeof(object) !== 'object') {
        return null;
      } else if (IsSceneObject(object)) {
        // object = scene
        return object;
      } else if (object.scene && IsSceneObject(object.scene)) {
        // object = game object
        return object.scene;
      } else if (object.parent && object.parent.scene && IsSceneObject(object.parent.scene)) {
        // parent = bob object
        return object.parent.scene;
      }
    };
  
    var GetValue$4 = Phaser.Utils.Objects.GetValue;
  
    var ComponentBase = /*#__PURE__*/function () {
      function ComponentBase(parent, config) {
        _classCallCheck(this, ComponentBase);
  
        this.parent = parent; // gameObject or scene
  
        this.scene = GetSceneObject(parent);
        this.isShutdown = false; // Event emitter, default is private event emitter
  
        this.setEventEmitter(GetValue$4(config, 'eventEmitter', true)); // Register callback of parent destroy event, also see `shutdown` method
  
        if (this.parent && this.parent === this.scene) {
          // parent is a scene
          this.scene.sys.events.once('shutdown', this.onSceneDestroy, this);
        } else if (this.parent && this.parent.once) {
          // bob object does not have event emitter
          this.parent.once('destroy', this.onParentDestroy, this);
        }
      }
  
      _createClass(ComponentBase, [{
        key: "shutdown",
        value: function shutdown(fromScene) {
          // Already shutdown
          if (this.isShutdown) {
            return;
          } // parent might not be shutdown yet
  
  
          if (this.parent && this.parent === this.scene) {
            // parent is a scene
            this.scene.sys.events.off('shutdown', this.onSceneDestroy, this);
          } else if (this.parent && this.parent.once) {
            // bob object does not have event emitter
            this.parent.off('destroy', this.onParentDestroy, this);
          }
  
          this.destroyEventEmitter();
          this.parent = undefined;
          this.scene = undefined;
          this.isShutdown = true;
        }
      }, {
        key: "destroy",
        value: function destroy(fromScene) {
          this.shutdown(fromScene);
        }
      }, {
        key: "onSceneDestroy",
        value: function onSceneDestroy() {
          this.destroy(true);
        }
      }, {
        key: "onParentDestroy",
        value: function onParentDestroy(parent, fromScene) {
          this.destroy(fromScene);
        }
      }]);
  
      return ComponentBase;
    }();
    Object.assign(ComponentBase.prototype, EventEmitterMethods);
  
    var GetValue$3 = Phaser.Utils.Objects.GetValue;
  
    var TickTask = /*#__PURE__*/function (_ComponentBase) {
      _inherits(TickTask, _ComponentBase);
  
      var _super = _createSuper(TickTask);
  
      function TickTask(parent, config) {
        var _this;
  
        _classCallCheck(this, TickTask);
  
        _this = _super.call(this, parent, config);
        _this._isRunning = false;
        _this.isPaused = false;
        _this.tickingState = false;
  
        _this.setTickingMode(GetValue$3(config, 'tickingMode', 1)); // boot() later
  
  
        return _this;
      } // override
  
  
      _createClass(TickTask, [{
        key: "boot",
        value: function boot() {
          if (this.tickingMode === 2 && !this.tickingState) {
            this.startTicking();
          }
        } // override
  
      }, {
        key: "shutdown",
        value: function shutdown(fromScene) {
          // Already shutdown
          if (this.isShutdown) {
            return;
          }
  
          this.stop();
  
          if (this.tickingState) {
            this.stopTicking();
          }
  
          _get(_getPrototypeOf(TickTask.prototype), "shutdown", this).call(this, fromScene);
        }
      }, {
        key: "setTickingMode",
        value: function setTickingMode(mode) {
          if (typeof mode === 'string') {
            mode = TICKINGMODE[mode];
          }
  
          this.tickingMode = mode;
        } // override
  
      }, {
        key: "startTicking",
        value: function startTicking() {
          this.tickingState = true;
        } // override
  
      }, {
        key: "stopTicking",
        value: function stopTicking() {
          this.tickingState = false;
        }
      }, {
        key: "isRunning",
        get: function get() {
          return this._isRunning;
        },
        set: function set(value) {
          if (this._isRunning === value) {
            return;
          }
  
          this._isRunning = value;
  
          if (this.tickingMode === 1 && value != this.tickingState) {
            if (value) {
              this.startTicking();
            } else {
              this.stopTicking();
            }
          }
        }
      }, {
        key: "start",
        value: function start() {
          this.isPaused = false;
          this.isRunning = true;
          return this;
        }
      }, {
        key: "pause",
        value: function pause() {
          // Only can ba paused in running state
          if (this.isRunning) {
            this.isPaused = true;
            this.isRunning = false;
          }
  
          return this;
        }
      }, {
        key: "resume",
        value: function resume() {
          // Only can ba resumed in paused state (paused from running state)
          if (this.isPaused) {
            this.isRunning = true;
          }
  
          return this;
        }
      }, {
        key: "stop",
        value: function stop() {
          this.isPaused = false;
          this.isRunning = false;
          return this;
        }
      }, {
        key: "complete",
        value: function complete() {
          this.isPaused = false;
          this.isRunning = false;
          this.emit('complete', this.parent, this);
        }
      }]);
  
      return TickTask;
    }(ComponentBase);
  
    var TICKINGMODE = {
      'no': 0,
      'lazy': 1,
      'always': 2
    };
  
    var SceneUpdateTickTask = /*#__PURE__*/function (_TickTask) {
      _inherits(SceneUpdateTickTask, _TickTask);
  
      var _super = _createSuper(SceneUpdateTickTask);
  
      function SceneUpdateTickTask() {
        _classCallCheck(this, SceneUpdateTickTask);
  
        return _super.apply(this, arguments);
      }
  
      _createClass(SceneUpdateTickTask, [{
        key: "startTicking",
        value: function startTicking() {
          _get(_getPrototypeOf(SceneUpdateTickTask.prototype), "startTicking", this).call(this);
  
          this.scene.sys.events.on('update', this.update, this);
        }
      }, {
        key: "stopTicking",
        value: function stopTicking() {
          _get(_getPrototypeOf(SceneUpdateTickTask.prototype), "stopTicking", this).call(this);
  
          if (this.scene) {
            // Scene might be destoryed
            this.scene.sys.events.off('update', this.update, this);
          }
        } // update(time, delta) {
        //     
        // }
  
      }]);
  
      return SceneUpdateTickTask;
    }(TickTask);
  
    var GetValue$2 = Phaser.Utils.Objects.GetValue;
    var Clamp = Phaser.Math.Clamp;
  
    var Timer = /*#__PURE__*/function () {
      function Timer(config) {
        _classCallCheck(this, Timer);
  
        this.resetFromJSON(config);
      }
  
      _createClass(Timer, [{
        key: "resetFromJSON",
        value: function resetFromJSON(o) {
          this.state = GetValue$2(o, 'state', IDLE);
          this.timeScale = GetValue$2(o, 'timeScale', 1);
          this.delay = GetValue$2(o, 'delay', 0);
          this.repeat = GetValue$2(o, 'repeat', 0);
          this.repeatCounter = GetValue$2(o, 'repeatCounter', 0);
          this.duration = GetValue$2(o, 'duration', 0);
          this.nowTime = GetValue$2(o, 'nowTime', 0);
          this.justRestart = GetValue$2(o, 'justRestart', false);
        }
      }, {
        key: "toJSON",
        value: function toJSON() {
          return {
            state: this.state,
            timeScale: this.timeScale,
            delay: this.delay,
            repeat: this.repeat,
            repeatCounter: this.repeatCounter,
            duration: this.duration,
            nowTime: this.nowTime,
            justRestart: this.justRestart
          };
        }
      }, {
        key: "destroy",
        value: function destroy() {}
      }, {
        key: "setTimeScale",
        value: function setTimeScale(timeScale) {
          this.timeScale = timeScale;
          return this;
        }
      }, {
        key: "setDelay",
        value: function setDelay(delay) {
          if (delay === undefined) {
            delay = 0;
          }
  
          this.delay = delay;
          return this;
        }
      }, {
        key: "setDuration",
        value: function setDuration(duration) {
          this.duration = duration;
          return this;
        }
      }, {
        key: "setRepeat",
        value: function setRepeat(repeat) {
          this.repeat = repeat;
          return this;
        }
      }, {
        key: "setRepeatInfinity",
        value: function setRepeatInfinity() {
          this.repeat = -1;
          return this;
        }
      }, {
        key: "start",
        value: function start() {
          this.nowTime = this.delay > 0 ? -this.delay : 0;
          this.state = this.nowTime >= 0 ? COUNTDOWN : DELAY;
          this.repeatCounter = 0;
          return this;
        }
      }, {
        key: "stop",
        value: function stop() {
          this.state = IDLE;
          return this;
        }
      }, {
        key: "update",
        value: function update(time, delta) {
          if (this.state === IDLE || this.state === DONE || delta === 0 || this.timeScale === 0) {
            return;
          }
  
          this.nowTime += delta * this.timeScale;
          this.state = this.nowTime >= 0 ? COUNTDOWN : DELAY;
          this.justRestart = false;
  
          if (this.nowTime >= this.duration) {
            if (this.repeat === -1 || this.repeatCounter < this.repeat) {
              this.repeatCounter++;
              this.justRestart = true;
              this.nowTime -= this.duration;
            } else {
              this.nowTime = this.duration;
              this.state = DONE;
            }
          }
        }
      }, {
        key: "t",
        get: function get() {
          var t;
  
          switch (this.state) {
            case IDLE:
            case DELAY:
              t = 0;
              break;
  
            case COUNTDOWN:
              t = this.nowTime / this.duration;
              break;
  
            case DONE:
              t = 1;
              break;
          }
  
          return Clamp(t, 0, 1);
        },
        set: function set(value) {
          value = Clamp(value, -1, 1);
  
          if (value < 0) {
            this.state = DELAY;
            this.nowTime = -this.delay * value;
          } else {
            this.state = COUNTDOWN;
            this.nowTime = this.duration * value;
  
            if (value === 1 && this.repeat !== 0) {
              this.repeatCounter++;
            }
          }
        }
      }, {
        key: "setT",
        value: function setT(t) {
          this.t = t;
          return this;
        }
      }, {
        key: "isIdle",
        get: function get() {
          return this.state === IDLE;
        }
      }, {
        key: "isDelay",
        get: function get() {
          return this.state === DELAY;
        }
      }, {
        key: "isCountDown",
        get: function get() {
          return this.state === COUNTDOWN;
        }
      }, {
        key: "isRunning",
        get: function get() {
          return this.state === DELAY || this.state === COUNTDOWN;
        }
      }, {
        key: "isDone",
        get: function get() {
          return this.state === DONE;
        }
      }, {
        key: "isOddIteration",
        get: function get() {
          return (this.repeatCounter & 1) === 1;
        }
      }, {
        key: "isEvenIteration",
        get: function get() {
          return (this.repeatCounter & 1) === 0;
        }
      }]);
  
      return Timer;
    }();
  
    var IDLE = 0;
    var DELAY = 1;
    var COUNTDOWN = 2;
    var DONE = -1;
  
    var TimerTickTask = /*#__PURE__*/function (_TickTask) {
      _inherits(TimerTickTask, _TickTask);
  
      var _super = _createSuper(TimerTickTask);
  
      function TimerTickTask(parent, config) {
        var _this;
  
        _classCallCheck(this, TimerTickTask);
  
        _this = _super.call(this, parent, config);
        _this.timer = new Timer(); // boot() later 
  
        return _this;
      } // override
  
  
      _createClass(TimerTickTask, [{
        key: "shutdown",
        value: function shutdown(fromScene) {
          // Already shutdown
          if (this.isShutdown) {
            return;
          }
  
          _get(_getPrototypeOf(TimerTickTask.prototype), "shutdown", this).call(this, fromScene);
  
          this.timer.destroy();
          this.timer = undefined;
        }
      }, {
        key: "start",
        value: function start() {
          this.timer.start();
  
          _get(_getPrototypeOf(TimerTickTask.prototype), "start", this).call(this);
  
          return this;
        }
      }, {
        key: "stop",
        value: function stop() {
          this.timer.stop();
  
          _get(_getPrototypeOf(TimerTickTask.prototype), "stop", this).call(this);
  
          return this;
        }
      }, {
        key: "complete",
        value: function complete() {
          this.timer.stop();
  
          _get(_getPrototypeOf(TimerTickTask.prototype), "complete", this).call(this);
  
          return this;
        }
      }]);
  
      return TimerTickTask;
    }(SceneUpdateTickTask);
  
    var GetValue$1 = Phaser.Utils.Objects.GetValue;
    var GetAdvancedValue$1 = Phaser.Utils.Objects.GetAdvancedValue;
    var GetEaseFunction = Phaser.Tweens.Builders.GetEaseFunction;
  
    var EaseValueTaskBase = /*#__PURE__*/function (_TickTask) {
      _inherits(EaseValueTaskBase, _TickTask);
  
      var _super = _createSuper(EaseValueTaskBase);
  
      function EaseValueTaskBase() {
        _classCallCheck(this, EaseValueTaskBase);
  
        return _super.apply(this, arguments);
      }
  
      _createClass(EaseValueTaskBase, [{
        key: "resetFromJSON",
        value: function resetFromJSON(o) {
          this.timer.resetFromJSON(GetValue$1(o, 'timer'));
          this.setEnable(GetValue$1(o, 'enable', true));
          this.setTarget(GetValue$1(o, 'target', this.parent));
          this.setDelay(GetAdvancedValue$1(o, 'delay', 0));
          this.setDuration(GetAdvancedValue$1(o, 'duration', 1000));
          this.setEase(GetValue$1(o, 'ease', 'Linear'));
          this.setRepeat(GetValue$1(o, 'repeat', 0));
          return this;
        }
      }, {
        key: "setEnable",
        value: function setEnable(e) {
          if (e == undefined) {
            e = true;
          }
  
          this.enable = e;
          return this;
        }
      }, {
        key: "setTarget",
        value: function setTarget(target) {
          if (target === undefined) {
            target = this.parent;
          }
  
          this.target = target;
          return this;
        }
      }, {
        key: "setDelay",
        value: function setDelay(time) {
          this.delay = time;
          return this;
        }
      }, {
        key: "setDuration",
        value: function setDuration(time) {
          this.duration = time;
          return this;
        }
      }, {
        key: "setEase",
        value: function setEase(ease) {
          if (ease === undefined) {
            ease = 'Linear';
          }
  
          this.ease = ease;
          this.easeFn = GetEaseFunction(ease);
          return this;
        }
      }, {
        key: "setRepeat",
        value: function setRepeat(repeat) {
          this.repeat = repeat;
          return this;
        } // Override
  
      }, {
        key: "start",
        value: function start() {
          // Ignore start if timer is running, i.e. in DELAY, o RUN state
          if (this.timer.isRunning) {
            return this;
          }
  
          _get(_getPrototypeOf(EaseValueTaskBase.prototype), "start", this).call(this);
  
          return this;
        }
      }, {
        key: "restart",
        value: function restart() {
          this.timer.stop();
          this.start.apply(this, arguments);
          return this;
        }
      }, {
        key: "stop",
        value: function stop(toEnd) {
          if (toEnd === undefined) {
            toEnd = false;
          }
  
          _get(_getPrototypeOf(EaseValueTaskBase.prototype), "stop", this).call(this);
  
          if (toEnd) {
            this.timer.setT(1);
            this.updateGameObject(this.target, this.timer);
            this.complete();
          }
  
          return this;
        }
      }, {
        key: "update",
        value: function update(time, delta) {
          if (!this.isRunning || !this.enable || !this.parent.active) {
            return this;
          }
  
          var target = this.target,
              timer = this.timer;
          timer.update(time, delta); // isDelay, isCountDown, isDone
  
          if (!timer.isDelay) {
            this.updateGameObject(target, timer);
          }
  
          this.emit('update', target, this);
  
          if (timer.isDone) {
            this.complete();
          }
  
          return this;
        } // Override
  
      }, {
        key: "updateGameObject",
        value: function updateGameObject(target, timer) {}
      }]);
  
      return EaseValueTaskBase;
    }(TimerTickTask);
  
    var GetValue = Phaser.Utils.Objects.GetValue;
    var GetAdvancedValue = Phaser.Utils.Objects.GetAdvancedValue;
    var Linear = Phaser.Math.Linear;
  
    var Fade = /*#__PURE__*/function (_EaseValueTaskBase) {
      _inherits(Fade, _EaseValueTaskBase);
  
      var _super = _createSuper(Fade);
  
      function Fade(gameObject, config) {
        var _this;
  
        _classCallCheck(this, Fade);
  
        _this = _super.call(this, gameObject, config); // this.parent = gameObject;
        // this.timer
  
        _this.resetFromJSON(config);
  
        _this.boot();
  
        return _this;
      }
  
      _createClass(Fade, [{
        key: "resetFromJSON",
        value: function resetFromJSON(o) {
          _get(_getPrototypeOf(Fade.prototype), "resetFromJSON", this).call(this, o);
  
          this.setMode(GetValue(o, 'mode', 0));
          this.setAlphaRange(GetAdvancedValue(o, 'start', this.parent.alpha), GetAdvancedValue(o, 'end', 0));
          return this;
        }
      }, {
        key: "setMode",
        value: function setMode(m) {
          if (typeof m === 'string') {
            m = MODE[m];
          }
  
          this.mode = m;
          return this;
        }
      }, {
        key: "setAlphaRange",
        value: function setAlphaRange(start, end) {
          this.alphaStart = start;
          this.alphaEnd = end;
          return this;
        }
      }, {
        key: "start",
        value: function start() {
          if (this.timer.isRunning) {
            return this;
          }
  
          var gameObject = this.parent;
          gameObject.setAlpha(this.alphaStart);
          this.timer.setDelay(this.delay).setDuration(this.duration).setRepeat(this.mode === 2 ? -1 : 0);
  
          _get(_getPrototypeOf(Fade.prototype), "start", this).call(this);
  
          return this;
        }
      }, {
        key: "updateGameObject",
        value: function updateGameObject(gameObject, timer) {
          var t = timer.t;
  
          if (timer.isOddIteration) {
            // Yoyo
            t = 1 - t;
          }
  
          gameObject.alpha = Linear(this.alphaStart, this.alphaEnd, t);
        }
      }, {
        key: "complete",
        value: function complete() {
          _get(_getPrototypeOf(Fade.prototype), "complete", this).call(this);
  
          if (this.mode === 1) {
            this.parent.destroy(); // Will also destroy this behavior
          }
  
          return this;
        }
      }]);
  
      return Fade;
    }(EaseValueTaskBase);
  
    var MODE = {
      stop: 0,
      destroy: 1,
      yoyo: 2
    };
  
    var FadeOutDestroy = function FadeOutDestroy(gameObject, duration, destroyMode, fade) {
      if (destroyMode instanceof Fade) {
        fade = destroyMode;
        destroyMode = undefined;
      }
  
      if (destroyMode === undefined) {
        destroyMode = true;
      }
  
      var config = {
        mode: destroyMode ? 1 : 0,
        end: 0,
        duration: duration
      };
  
      if (fade === undefined) {
        fade = new Fade(gameObject, config);
      } else {
        fade.resetFromJSON(config);
      }
  
      fade.restart();
      return fade;
    };
  
    var FadePlugin = /*#__PURE__*/function (_Phaser$Plugins$BaseP) {
      _inherits(FadePlugin, _Phaser$Plugins$BaseP);
  
      var _super = _createSuper(FadePlugin);
  
      function FadePlugin(pluginManager) {
        _classCallCheck(this, FadePlugin);
  
        return _super.call(this, pluginManager);
      }
  
      _createClass(FadePlugin, [{
        key: "start",
        value: function start() {
          var eventEmitter = this.game.events;
          eventEmitter.on('destroy', this.destroy, this);
        }
      }, {
        key: "add",
        value: function add(gameObject, config) {
          return new Fade(gameObject, config);
        }
      }]);
  
      return FadePlugin;
    }(Phaser.Plugins.BasePlugin); // mixin
  
  
    var methods = {
      fadeOutDestroy: FadeOutDestroy
    };
    Object.assign(FadePlugin.prototype, methods);
  
    return FadePlugin;
  
  }));
  