initial commit

public/css/vendor/plugins/asprogress/jquery-asProgress.es.js

@@ -0,0 +1,401 @@
+/**
+* jQuery asProgress v0.2.4
+* https://github.com/amazingSurge/jquery-asProgress
+*
+* Copyright (c) amazingSurge
+* Released under the LGPL-3.0 license
+*/
+import $ from 'jquery';
+
+var DEFAULTS = {
+  namespace: 'progress',
+  bootstrap: false,
+  min: 0,
+  max: 100,
+  goal: 100,
+  speed: 20, // speed of 1/100
+  easing: 'ease',
+  labelCallback(n) {
+    const percentage = this.getPercentage(n);
+    return `${percentage}%`;
+  }
+};
+
+let easingBezier = (mX1, mY1, mX2, mY2) => {
+  'use strict';
+
+  let a = (aA1, aA2) => {
+    return 1.0 - 3.0 * aA2 + 3.0 * aA1;
+  };
+
+  let b = (aA1, aA2) => {
+    return 3.0 * aA2 - 6.0 * aA1;
+  };
+
+  let c = (aA1) => {
+    return 3.0 * aA1;
+  };
+
+  // Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.
+  let calcBezier = (aT, aA1, aA2) => {
+    return ((a(aA1, aA2) * aT + b(aA1, aA2)) * aT + c(aA1)) * aT;
+  };
+
+  // Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.
+  let getSlope = (aT, aA1, aA2) => {
+    return 3.0 * a(aA1, aA2) * aT * aT + 2.0 * b(aA1, aA2) * aT + c(aA1);
+  };
+
+  let getTForX = (aX) => {
+    // Newton raphson iteration
+    let aGuessT = aX;
+    for (let i = 0; i < 4; ++i) {
+      let currentSlope = getSlope(aGuessT, mX1, mX2);
+      if (currentSlope === 0.0) {
+        return aGuessT;
+      }
+      let currentX = calcBezier(aGuessT, mX1, mX2) - aX;
+      aGuessT -= currentX / currentSlope;
+    }
+    return aGuessT;
+  };
+
+  if (mX1 === mY1 && mX2 === mY2) {
+    return {
+      css: 'linear',
+      fn(aX) {
+        return aX;
+      }
+    };
+  }
+
+  return {
+    css: `cubic-bezier(${mX1},${mY1},${mX2},${mY2})`,
+    fn(aX) {
+      return calcBezier(getTForX(aX), mY1, mY2);
+    }
+  };
+};
+
+var EASING = {
+  ease: easingBezier(0.25, 0.1, 0.25, 1.0),
+  linear: easingBezier(0.00, 0.0, 1.00, 1.0),
+  'ease-in': easingBezier(0.42, 0.0, 1.00, 1.0),
+  'ease-out': easingBezier(0.00, 0.0, 0.58, 1.0),
+  'ease-in-out': easingBezier(0.42, 0.0, 0.58, 1.0)
+};
+
+if (!Date.now){
+  Date.now = () => new Date().getTime();
+}
+
+const vendors = ['webkit', 'moz'];
+for (let i = 0; i < vendors.length && !window.requestAnimationFrame; ++i) {
+  const vp = vendors[i];
+  window.requestAnimationFrame = window[`${vp}RequestAnimationFrame`];
+  window.cancelAnimationFrame = (window[`${vp}CancelAnimationFrame`]
+                 || window[`${vp}CancelRequestAnimationFrame`]);
+}
+
+if (/iP(ad|hone|od).*OS (6|7)/.test(window.navigator.userAgent) // iOS6 is buggy
+  || !window.requestAnimationFrame || !window.cancelAnimationFrame) {
+  let lastTime = 0;
+  window.requestAnimationFrame = callback => {
+    const now = Date.now();
+    const nextTime = Math.max(lastTime + 16, now);
+    return setTimeout(() => {
+        callback(lastTime = nextTime);
+      },
+      nextTime - now);
+  };
+  window.cancelAnimationFrame = clearTimeout;
+}
+
+function isPercentage(n) {
+  return typeof n === 'string' && n.includes('%');
+}
+
+function getTime(){
+  if (typeof window.performance !== 'undefined' && window.performance.now) {
+    return window.performance.now();
+  }
+  return Date.now();
+}
+
+const NAMESPACE$1 = 'asProgress';
+
+/**
+ * Plugin constructor
+ **/
+class asProgress {
+  constructor(element, options) {
+    this.element = element;
+    this.$element = $(element);
+
+    this.options = $.extend({}, DEFAULTS, options, this.$element.data());
+
+    if(this.options.bootstrap){
+      this.namespace = 'progress';
+
+      this.$target = this.$element.find('.progress-bar');
+
+      this.classes = {
+        label: `${this.namespace}-label`,
+        bar: `${this.namespace}-bar`,
+        disabled: 'is-disabled'
+      };
+    } else {
+      this.namespace = this.options.namespace;
+
+      this.classes = {
+        label: `${this.namespace}__label`,
+        bar: `${this.namespace}__bar`,
+        disabled: 'is-disabled'
+      };
+
+      this.$target = this.$element;
+
+      this.$element.addClass(this.namespace);
+    }
+
+    this.easing = EASING[this.options.easing] || EASING.ease;
+
+    this.min = this.$target.attr('aria-valuemin');
+    this.max = this.$target.attr('aria-valuemax');
+    this.min = this.min? parseInt(this.min, 10): this.options.min;
+    this.max = this.max? parseInt(this.max, 10): this.options.max;
+    this.first = this.$target.attr('aria-valuenow');
+    this.first = this.first? parseInt(this.first, 10): this.min;
+
+    this.now = this.first;
+    this.goal = this.options.goal;
+    this._frameId = null;
+
+    // Current state information.
+    this._states = {};
+
+    this.initialized = false;
+    this._trigger('init');
+    this.init();
+  }
+
+  init() {
+    this.$bar = this.$element.find(`.${this.classes.bar}`);
+    this.$label = this.$element.find(`.${this.classes.label}`);
+
+    this.reset();
+    this.initialized = true;
+    this._trigger('ready');
+  }
+
+  _trigger(eventType, ...params) {
+    let data = [this].concat(params);
+
+    // event
+    this.$element.trigger(`${NAMESPACE$1}::${eventType}`, data);
+
+    // callback
+    eventType = eventType.replace(/\b\w+\b/g, (word) => {
+      return word.substring(0, 1).toUpperCase() + word.substring(1);
+    });
+    let onFunction = `on${eventType}`;
+
+    if (typeof this.options[onFunction] === 'function') {
+      this.options[onFunction].apply(this, params);
+    }
+  }
+
+  /**
+   * Checks whether the carousel is in a specific state or not.
+   */
+  is(state) {
+    return this._states[state] && this._states[state] > 0;
+  }
+
+  getPercentage(n) {
+    return Math.round(100 * (n - this.min) / (this.max - this.min));
+  }
+
+  go(goal) {
+    if(!this.is('disabled')) {
+      const that = this;
+      this._clear();
+
+      if (isPercentage(goal)) {
+        goal = parseInt(goal.replace('%', ''), 10);
+        goal = Math.round(this.min + (goal / 100) * (this.max - this.min));
+      }
+      if (typeof goal === 'undefined') {
+        goal = this.goal;
+      }
+
+      if (goal > this.max) {
+        goal = this.max;
+      } else if (goal < this.min) {
+        goal = this.min;
+      }
+
+      const start = that.now;
+      const startTime = getTime();
+      const animation = time => {
+        const distance = (time - startTime)/that.options.speed;
+        let next = Math.round(that.easing.fn(distance/100) * (that.max - that.min));
+
+        if(goal > start){
+          next = start + next;
+          if(next > goal){
+            next = goal;
+          }
+        } else{
+          next = start - next;
+          if(next < goal){
+            next = goal;
+          }
+        }
+
+        that._update(next);
+        if (next === goal) {
+          window.cancelAnimationFrame(that._frameId);
+          that._frameId = null;
+
+          if (that.now === that.goal) {
+            that._trigger('finish');
+          }
+        } else {
+          that._frameId =  window.requestAnimationFrame(animation);
+        }
+      };
+
+      that._frameId =  window.requestAnimationFrame(animation);
+    }
+  }
+
+  _update(n) {
+    this.now = n;
+
+    const percenage = this.getPercentage(this.now);
+    this.$bar.css('width', `${percenage}%`);
+    this.$target.attr('aria-valuenow', this.now);
+    if (this.$label.length > 0 && typeof this.options.labelCallback === 'function') {
+      this.$label.html(this.options.labelCallback.call(this, [this.now]));
+    }
+
+    this._trigger('update', n);
+  }
+
+  _clear() {
+    if (this._frameId) {
+      window.cancelAnimationFrame(this._frameId);
+      this._frameId = null;
+    }
+  }
+
+  get() {
+    return this.now;
+  }
+
+  start() {
+    if(!this.is('disabled')) {
+      this._clear();
+      this._trigger('start');
+      this.go(this.goal);
+    }
+  }
+
+  reset() {
+    if(!this.is('disabled')) {
+      this._clear();
+      this._update(this.first);
+      this._trigger('reset');
+    }
+  }
+
+  stop() {
+    this._clear();
+    this._trigger('stop');
+  }
+
+  finish() {
+    if(!this.is('disabled')) {
+      this._clear();
+      this._update(this.goal);
+      this._trigger('finish');
+    }
+  }
+
+  destroy() {
+    this.$element.data(NAMESPACE$1, null);
+    this._trigger('destroy');
+  }
+
+  enable() {
+    this._states.disabled = 0;
+
+    this.$element.removeClass(this.classes.disabled);
+  }
+
+  disable() {
+    this._states.disabled = 1;
+
+    this.$element.addClass(this.classes.disabled);
+  }
+
+  static registerEasing(name, ...args) {
+    EASING[name] = easingBezier(...args);
+  }
+
+  static getEasing(name) {
+    return EASING[name];
+  }
+
+  static setDefaults(options) {
+    $.extend(DEFAULTS, $.isPlainObject(options) && options);
+  }
+}
+
+var info = {
+  version:'0.2.4'
+};
+
+const NAMESPACE = 'asProgress';
+const OtherAsProgress = $.fn.asProgress;
+
+const jQueryAsProgress = function(options, ...args) {
+  if (typeof options === 'string') {
+    const method = options;
+
+    if (/^_/.test(method)) {
+      return false;
+    } else if ((/^(get)/.test(method))) {
+      const instance = this.first().data(NAMESPACE);
+      if (instance && typeof instance[method] === 'function') {
+        return instance[method](...args);
+      }
+    } else {
+      return this.each(function() {
+        const instance = $.data(this, NAMESPACE);
+        if (instance && typeof instance[method] === 'function') {
+          instance[method](...args);
+        }
+      });
+    }
+  }
+
+  return this.each(function() {
+    if (!$(this).data(NAMESPACE)) {
+      $(this).data(NAMESPACE, new asProgress(this, options));
+    }
+  });
+};
+
+$.fn.asProgress = jQueryAsProgress;
+
+$.asProgress = $.extend({
+  setDefaults: asProgress.setDefaults,
+  registerEasing: asProgress.registerEasing,
+  getEasing: asProgress.getEasing,
+  noConflict: function() {
+    $.fn.asProgress = OtherAsProgress;
+    return jQueryAsProgress;
+  }
+}, info);

public/css/vendor/plugins/asprogress/jquery-asProgress.js

@@ -0,0 +1,553 @@
+/**
+* jQuery asProgress v0.2.4
+* https://github.com/amazingSurge/jquery-asProgress
+*
+* Copyright (c) amazingSurge
+* Released under the LGPL-3.0 license
+*/
+(function(global, factory) {
+  if (typeof define === 'function' && define.amd) {
+    define(['jquery'], factory);
+  } else if (typeof exports !== 'undefined') {
+    factory(require('jquery'));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(global.jQuery);
+    global.jqueryAsProgressEs = mod.exports;
+  }
+})(this, function(_jquery) {
+  'use strict';
+
+  var _jquery2 = _interopRequireDefault(_jquery);
+
+  function _interopRequireDefault(obj) {
+    return obj && obj.__esModule
+      ? obj
+      : {
+          default: obj
+        };
+  }
+
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError('Cannot call a class as a function');
+    }
+  }
+
+  var _createClass = (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);
+      }
+    }
+
+    return function(Constructor, protoProps, staticProps) {
+      if (protoProps) defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) defineProperties(Constructor, staticProps);
+      return Constructor;
+    };
+  })();
+
+  var DEFAULTS = {
+    namespace: 'progress',
+    bootstrap: false,
+    min: 0,
+    max: 100,
+    goal: 100,
+    speed: 20, // speed of 1/100
+    easing: 'ease',
+    labelCallback: function labelCallback(n) {
+      var percentage = this.getPercentage(n);
+      return percentage + '%';
+    }
+  };
+
+  var easingBezier = function easingBezier(mX1, mY1, mX2, mY2) {
+    'use strict';
+
+    var a = function a(aA1, aA2) {
+      return 1.0 - 3.0 * aA2 + 3.0 * aA1;
+    };
+
+    var b = function b(aA1, aA2) {
+      return 3.0 * aA2 - 6.0 * aA1;
+    };
+
+    var c = function c(aA1) {
+      return 3.0 * aA1;
+    };
+
+    // Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.
+    var calcBezier = function calcBezier(aT, aA1, aA2) {
+      return ((a(aA1, aA2) * aT + b(aA1, aA2)) * aT + c(aA1)) * aT;
+    };
+
+    // Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.
+    var getSlope = function getSlope(aT, aA1, aA2) {
+      return 3.0 * a(aA1, aA2) * aT * aT + 2.0 * b(aA1, aA2) * aT + c(aA1);
+    };
+
+    var getTForX = function getTForX(aX) {
+      // Newton raphson iteration
+      var aGuessT = aX;
+      for (var i = 0; i < 4; ++i) {
+        var currentSlope = getSlope(aGuessT, mX1, mX2);
+        if (currentSlope === 0.0) {
+          return aGuessT;
+        }
+        var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
+        aGuessT -= currentX / currentSlope;
+      }
+      return aGuessT;
+    };
+
+    if (mX1 === mY1 && mX2 === mY2) {
+      return {
+        css: 'linear',
+        fn: function fn(aX) {
+          return aX;
+        }
+      };
+    }
+
+    return {
+      css: 'cubic-bezier(' + mX1 + ',' + mY1 + ',' + mX2 + ',' + mY2 + ')',
+      fn: function fn(aX) {
+        return calcBezier(getTForX(aX), mY1, mY2);
+      }
+    };
+  };
+
+  var EASING = {
+    ease: easingBezier(0.25, 0.1, 0.25, 1.0),
+    linear: easingBezier(0.0, 0.0, 1.0, 1.0),
+    'ease-in': easingBezier(0.42, 0.0, 1.0, 1.0),
+    'ease-out': easingBezier(0.0, 0.0, 0.58, 1.0),
+    'ease-in-out': easingBezier(0.42, 0.0, 0.58, 1.0)
+  };
+
+  if (!Date.now) {
+    Date.now = function() {
+      return new Date().getTime();
+    };
+  }
+
+  var vendors = ['webkit', 'moz'];
+  for (var i = 0; i < vendors.length && !window.requestAnimationFrame; ++i) {
+    var vp = vendors[i];
+    window.requestAnimationFrame = window[vp + 'RequestAnimationFrame'];
+    window.cancelAnimationFrame =
+      window[vp + 'CancelAnimationFrame'] ||
+      window[vp + 'CancelRequestAnimationFrame'];
+  }
+
+  if (
+    /iP(ad|hone|od).*OS (6|7)/.test(window.navigator.userAgent) || // iOS6 is buggy
+    !window.requestAnimationFrame ||
+    !window.cancelAnimationFrame
+  ) {
+    var lastTime = 0;
+    window.requestAnimationFrame = function(callback) {
+      var now = Date.now();
+      var nextTime = Math.max(lastTime + 16, now);
+      return setTimeout(function() {
+        callback((lastTime = nextTime));
+      }, nextTime - now);
+    };
+    window.cancelAnimationFrame = clearTimeout;
+  }
+
+  function isPercentage(n) {
+    return typeof n === 'string' && n.includes('%');
+  }
+
+  function getTime() {
+    if (typeof window.performance !== 'undefined' && window.performance.now) {
+      return window.performance.now();
+    }
+    return Date.now();
+  }
+
+  var NAMESPACE$1 = 'asProgress';
+
+  /**
+   * Plugin constructor
+   **/
+
+  var asProgress = (function() {
+    function asProgress(element, options) {
+      _classCallCheck(this, asProgress);
+
+      this.element = element;
+      this.$element = (0, _jquery2.default)(element);
+
+      this.options = _jquery2.default.extend(
+        {},
+        DEFAULTS,
+        options,
+        this.$element.data()
+      );
+
+      if (this.options.bootstrap) {
+        this.namespace = 'progress';
+
+        this.$target = this.$element.find('.progress-bar');
+
+        this.classes = {
+          label: this.namespace + '-label',
+          bar: this.namespace + '-bar',
+          disabled: 'is-disabled'
+        };
+      } else {
+        this.namespace = this.options.namespace;
+
+        this.classes = {
+          label: this.namespace + '__label',
+          bar: this.namespace + '__bar',
+          disabled: 'is-disabled'
+        };
+
+        this.$target = this.$element;
+
+        this.$element.addClass(this.namespace);
+      }
+
+      this.easing = EASING[this.options.easing] || EASING.ease;
+
+      this.min = this.$target.attr('aria-valuemin');
+      this.max = this.$target.attr('aria-valuemax');
+      this.min = this.min ? parseInt(this.min, 10) : this.options.min;
+      this.max = this.max ? parseInt(this.max, 10) : this.options.max;
+      this.first = this.$target.attr('aria-valuenow');
+      this.first = this.first ? parseInt(this.first, 10) : this.min;
+
+      this.now = this.first;
+      this.goal = this.options.goal;
+      this._frameId = null;
+
+      // Current state information.
+      this._states = {};
+
+      this.initialized = false;
+      this._trigger('init');
+      this.init();
+    }
+
+    _createClass(
+      asProgress,
+      [
+        {
+          key: 'init',
+          value: function init() {
+            this.$bar = this.$element.find('.' + this.classes.bar);
+            this.$label = this.$element.find('.' + this.classes.label);
+
+            this.reset();
+            this.initialized = true;
+            this._trigger('ready');
+          }
+        },
+        {
+          key: '_trigger',
+          value: function _trigger(eventType) {
+            for (
+              var _len = arguments.length,
+                params = Array(_len > 1 ? _len - 1 : 0),
+                _key = 1;
+              _key < _len;
+              _key++
+            ) {
+              params[_key - 1] = arguments[_key];
+            }
+
+            var data = [this].concat(params);
+
+            // event
+            this.$element.trigger(NAMESPACE$1 + '::' + eventType, data);
+
+            // callback
+            eventType = eventType.replace(/\b\w+\b/g, function(word) {
+              return word.substring(0, 1).toUpperCase() + word.substring(1);
+            });
+            var onFunction = 'on' + eventType;
+
+            if (typeof this.options[onFunction] === 'function') {
+              this.options[onFunction].apply(this, params);
+            }
+          }
+        },
+        {
+          key: 'is',
+          value: function is(state) {
+            return this._states[state] && this._states[state] > 0;
+          }
+        },
+        {
+          key: 'getPercentage',
+          value: function getPercentage(n) {
+            return Math.round(100 * (n - this.min) / (this.max - this.min));
+          }
+        },
+        {
+          key: 'go',
+          value: function go(goal) {
+            if (!this.is('disabled')) {
+              var that = this;
+              this._clear();
+
+              if (isPercentage(goal)) {
+                goal = parseInt(goal.replace('%', ''), 10);
+                goal = Math.round(
+                  this.min + goal / 100 * (this.max - this.min)
+                );
+              }
+              if (typeof goal === 'undefined') {
+                goal = this.goal;
+              }
+
+              if (goal > this.max) {
+                goal = this.max;
+              } else if (goal < this.min) {
+                goal = this.min;
+              }
+
+              var start = that.now;
+              var startTime = getTime();
+              var animation = function animation(time) {
+                var distance = (time - startTime) / that.options.speed;
+                var next = Math.round(
+                  that.easing.fn(distance / 100) * (that.max - that.min)
+                );
+
+                if (goal > start) {
+                  next = start + next;
+                  if (next > goal) {
+                    next = goal;
+                  }
+                } else {
+                  next = start - next;
+                  if (next < goal) {
+                    next = goal;
+                  }
+                }
+
+                that._update(next);
+                if (next === goal) {
+                  window.cancelAnimationFrame(that._frameId);
+                  that._frameId = null;
+
+                  if (that.now === that.goal) {
+                    that._trigger('finish');
+                  }
+                } else {
+                  that._frameId = window.requestAnimationFrame(animation);
+                }
+              };
+
+              that._frameId = window.requestAnimationFrame(animation);
+            }
+          }
+        },
+        {
+          key: '_update',
+          value: function _update(n) {
+            this.now = n;
+
+            var percenage = this.getPercentage(this.now);
+            this.$bar.css('width', percenage + '%');
+            this.$target.attr('aria-valuenow', this.now);
+            if (
+              this.$label.length > 0 &&
+              typeof this.options.labelCallback === 'function'
+            ) {
+              this.$label.html(
+                this.options.labelCallback.call(this, [this.now])
+              );
+            }
+
+            this._trigger('update', n);
+          }
+        },
+        {
+          key: '_clear',
+          value: function _clear() {
+            if (this._frameId) {
+              window.cancelAnimationFrame(this._frameId);
+              this._frameId = null;
+            }
+          }
+        },
+        {
+          key: 'get',
+          value: function get() {
+            return this.now;
+          }
+        },
+        {
+          key: 'start',
+          value: function start() {
+            if (!this.is('disabled')) {
+              this._clear();
+              this._trigger('start');
+              this.go(this.goal);
+            }
+          }
+        },
+        {
+          key: 'reset',
+          value: function reset() {
+            if (!this.is('disabled')) {
+              this._clear();
+              this._update(this.first);
+              this._trigger('reset');
+            }
+          }
+        },
+        {
+          key: 'stop',
+          value: function stop() {
+            this._clear();
+            this._trigger('stop');
+          }
+        },
+        {
+          key: 'finish',
+          value: function finish() {
+            if (!this.is('disabled')) {
+              this._clear();
+              this._update(this.goal);
+              this._trigger('finish');
+            }
+          }
+        },
+        {
+          key: 'destroy',
+          value: function destroy() {
+            this.$element.data(NAMESPACE$1, null);
+            this._trigger('destroy');
+          }
+        },
+        {
+          key: 'enable',
+          value: function enable() {
+            this._states.disabled = 0;
+
+            this.$element.removeClass(this.classes.disabled);
+          }
+        },
+        {
+          key: 'disable',
+          value: function disable() {
+            this._states.disabled = 1;
+
+            this.$element.addClass(this.classes.disabled);
+          }
+        }
+      ],
+      [
+        {
+          key: 'registerEasing',
+          value: function registerEasing(name) {
+            for (
+              var _len2 = arguments.length,
+                args = Array(_len2 > 1 ? _len2 - 1 : 0),
+                _key2 = 1;
+              _key2 < _len2;
+              _key2++
+            ) {
+              args[_key2 - 1] = arguments[_key2];
+            }
+
+            EASING[name] = easingBezier.apply(undefined, args);
+          }
+        },
+        {
+          key: 'getEasing',
+          value: function getEasing(name) {
+            return EASING[name];
+          }
+        },
+        {
+          key: 'setDefaults',
+          value: function setDefaults(options) {
+            _jquery2.default.extend(
+              DEFAULTS,
+              _jquery2.default.isPlainObject(options) && options
+            );
+          }
+        }
+      ]
+    );
+
+    return asProgress;
+  })();
+
+  var info = {
+    version: '0.2.4'
+  };
+
+  var NAMESPACE = 'asProgress';
+  var OtherAsProgress = _jquery2.default.fn.asProgress;
+
+  var jQueryAsProgress = function jQueryAsProgress(options) {
+    for (
+      var _len3 = arguments.length,
+        args = Array(_len3 > 1 ? _len3 - 1 : 0),
+        _key3 = 1;
+      _key3 < _len3;
+      _key3++
+    ) {
+      args[_key3 - 1] = arguments[_key3];
+    }
+
+    if (typeof options === 'string') {
+      var method = options;
+
+      if (/^_/.test(method)) {
+        return false;
+      } else if (/^(get)/.test(method)) {
+        var instance = this.first().data(NAMESPACE);
+        if (instance && typeof instance[method] === 'function') {
+          return instance[method].apply(instance, args);
+        }
+      } else {
+        return this.each(function() {
+          var instance = _jquery2.default.data(this, NAMESPACE);
+          if (instance && typeof instance[method] === 'function') {
+            instance[method].apply(instance, args);
+          }
+        });
+      }
+    }
+
+    return this.each(function() {
+      if (!(0, _jquery2.default)(this).data(NAMESPACE)) {
+        (0, _jquery2.default)(this).data(
+          NAMESPACE,
+          new asProgress(this, options)
+        );
+      }
+    });
+  };
+
+  _jquery2.default.fn.asProgress = jQueryAsProgress;
+
+  _jquery2.default.asProgress = _jquery2.default.extend(
+    {
+      setDefaults: asProgress.setDefaults,
+      registerEasing: asProgress.registerEasing,
+      getEasing: asProgress.getEasing,
+      noConflict: function noConflict() {
+        _jquery2.default.fn.asProgress = OtherAsProgress;
+        return jQueryAsProgress;
+      }
+    },
+    info
+  );
+});