/******/
(function(modules) { // webpackbootstrap
    /******/ // the module cache
    /******/
    var installedmodules = {};
    /******/
    /******/ // the require function
    /******/
    function __webpack_require__(moduleid) {
        /******/
        /******/ // check if module is in cache
        /******/
        if (installedmodules[moduleid]) {
            /******/
            return installedmodules[moduleid].exports;
            /******/
        }
        /******/ // create a new module (and put it into the cache)
        /******/
        var module = installedmodules[moduleid] = {
            /******/
            i: moduleid,
            /******/
            l: false,
            /******/
            exports: {}
            /******/
        };
        /******/
        /******/ // execute the module function
        /******/
        modules[moduleid].call(module.exports, module, module.exports, __webpack_require__);
        /******/
        /******/ // flag the module as loaded
        /******/
        module.l = true;
        /******/
        /******/ // return the exports of the module
        /******/
        return module.exports;
        /******/
    }
    /******/
    /******/
    /******/ // expose the modules object (__webpack_modules__)
    /******/
    __webpack_require__.m = modules;
    /******/
    /******/ // expose the module cache
    /******/
    __webpack_require__.c = installedmodules;
    /******/
    /******/ // define getter function for harmony exports
    /******/
    __webpack_require__.d = function(exports, name, getter) {
        /******/
        if (!__webpack_require__.o(exports, name)) {
            /******/
            object.defineproperty(exports, name, {
                /******/
                configurable: false,
                /******/
                enumerable: true,
                /******/
                get: getter
                /******/
            });
            /******/
        }
        /******/
    };
    /******/
    /******/ // getdefaultexport function for compatibility with non-harmony modules
    /******/
    __webpack_require__.n = function(module) {
        /******/
        var getter = module && module.__esmodule ?
            /******/
            function getdefault() {
                return module['default'];
            } :
            /******/
            function getmoduleexports() {
                return module;
            };
        /******/
        __webpack_require__.d(getter, 'a', getter);
        /******/
        return getter;
        /******/
    };
    /******/
    /******/ // object.prototype.hasownproperty.call
    /******/
    __webpack_require__.o = function(object, property) {
        return object.prototype.hasownproperty.call(object, property);
    };
    /******/
    /******/ // __webpack_public_path__
    /******/
    __webpack_require__.p = "";
    /******/
    /******/ // load entry module and return exports
    /******/
    return __webpack_require__(__webpack_require__.s = 0);
    /******/
})
/************************************************************************/
/******/
([
    /* 0 */
    /***/
    (function(module, exports, __webpack_require__) {
        "use strict";
        /*
         version: 1.0.0
         author: lemehovskiy
         website: http://lemehovskiy.github.io
         repo: https://github.com/lemehovskiy/lem_counter
         */



        var _typeof = typeof symbol === "function" && typeof symbol.iterator === "symbol" ? function(obj) {
            return typeof obj;
        } : function(obj) {
            return obj && typeof symbol === "function" && obj.constructor === symbol && obj !== symbol.prototype ? "symbol" : typeof obj;
        };

        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;
            };
        }();

        function _classcallcheck(instance, constructor) {
            if (!(instance instanceof constructor)) {
                throw new typeerror("cannot call a class as a function");
            }
        }

        (function($) {
            var lemcounter = function() {
                function lemcounter(element, options) {
                    _classcallcheck(this, lemcounter);

                    var self = this;

                    //extend by function call
                    self.settings = $.extend(true, {
                        value_from: 0,
                        value_to: 0,
                        locale: false,
                        value_to_from_content: false,
                        animate_duration: 2
                    }, options);

                    self.$element = $(element);

                    self.to_fixed_digits = 0;

                    //extend by data options
                    self.data_options = self.$element.data('lem-counter');
                    self.settings = $.extend(true, self.settings, self.data_options);

                    //value to from content
                    if (self.settings.value_to_from_content) {
                        //check if number and remove commas
                        if (!isnan(self.$element.text().replace(/,/g, ''))) {
                            self.settings = $.extend(true, self.settings, {
                                value_to: number(self.$element.text().replace(/,/g, ''))
                            });
                        }
                    }

                    //set start value
                    self.counter_helper = {
                        val: self.settings.value_from
                    };

                    self.init();
                }

                _createclass(lemcounter, [{
                    key: 'init',
                    value: function init() {

                        var self = this;

                        var counter_to = self.settings.value_to;

                        //check if number is float
                        if (isfloat(counter_to)) {
                            var string_counter_val_to = counter_to.tostring();

                            self.to_fixed_digits = string_counter_val_to.substr(string_counter_val_to.indexof('.') + 1).length;
                        }

                        tweenlite.to(self.counter_helper, self.settings.animate_duration, {
                            val: counter_to,
                            onupdate: updatehandler,
                            ease: linear.easenone,
                            oncomplete: function oncomplete() {
                                self.$element.trigger('oncomplete.lc');
                            }
                        });

                        function isfloat(n) {
                            return number(n) === n && n % 1 !== 0;
                        }

                        function updatehandler() {
                            var value = self.counter_helper.val;

                            var num = value.tofixed(self.to_fixed_digits);

                            var num_locale = 0;

                            if (self.to_fixed_digits == 0) {
                                num_locale = parseint(num);
                            } else {
                                num_locale = parsefloat(num);
                            }

                            if (self.settings.locale) {
                                num_locale = num_locale.tolocalestring(self.settings.locale, {
                                    maximumfractiondigits: self.to_fixed_digits
                                });
                            }

                            self.$element.text(num_locale);
                        }
                    }
                }]);

                return lemcounter;
            }();

            $.fn.lemcounter = function() {
                var $this = this,
                    opt = arguments[0],
                    args = array.prototype.slice.call(arguments, 1),
                    length = $this.length,
                    i = void 0,
                    ret = void 0;
                for (i = 0; i < length; i++) {
                    if ((typeof opt === 'undefined' ? 'undefined' : _typeof(opt)) == 'object' || typeof opt == 'undefined') $this[i].lem_counter = new lemcounter($this[i], opt);
                    else ret = $this[i].lem_counter[opt].apply($this[i].lem_counter, args);
                    if (typeof ret != 'undefined') return ret;
                }
                return $this;
            };
        })(jquery);

        /***/
    })
    /******/
]);