do_fhem/fhem/core/www/tablet/lib/powerange.js

;
(function () {

    /**
     * Require the given path.
     *
     * @param {String} path
     * @return {Object} exports
     * @api public
     */

    function require(path, parent, orig) {
        var resolved = require.resolve(path);

        // lookup failed
        if (null == resolved) {
            orig = orig || path;
            parent = parent || 'root';
            var err = new Error('Failed to require "' + orig + '" from "' + parent + '"');
            err.path = orig;
            err.parent = parent;
            err.require = true;
            throw err;
        }

        var module = require.modules[resolved];

        // perform real require()
        // by invoking the module's
        // registered function
        if (!module._resolving && !module.exports) {
            var mod = {};
            mod.exports = {};
            mod.client = mod.component = true;
            module._resolving = true;
            module.call(this, mod.exports, require.relative(resolved), mod);
            delete module._resolving;
            module.exports = mod.exports;
        }

        return module.exports;
    }

    /**
     * Registered modules.
     */

    require.modules = {};

    /**
     * Registered aliases.
     */

    require.aliases = {};

    /**
     * Resolve `path`.
     *
     * Lookup:
     *
     *   - PATH/index.js
     *   - PATH.js
     *   - PATH
     *
     * @param {String} path
     * @return {String} path or null
     * @api private
     */

    require.resolve = function (path) {
        if (path.charAt(0) === '/') path = path.slice(1);

        var paths = [
    path,
    path + '.js',
    path + '.json',
    path + '/index.js',
    path + '/index.json'
  ];

        for (var i = 0; i < paths.length; i++) {
            var path = paths[i];
            if (require.modules.hasOwnProperty(path)) return path;
            if (require.aliases.hasOwnProperty(path)) return require.aliases[path];
        }
    };

    /**
     * Normalize `path` relative to the current path.
     *
     * @param {String} curr
     * @param {String} path
     * @return {String}
     * @api private
     */

    require.normalize = function (curr, path) {
        var segs = [];

        if ('.' != path.charAt(0)) return path;

        curr = curr.split('/');
        path = path.split('/');

        for (var i = 0; i < path.length; ++i) {
            if ('..' == path[i]) {
                curr.pop();
            } else if ('.' != path[i] && '' != path[i]) {
                segs.push(path[i]);
            }
        }

        return curr.concat(segs).join('/');
    };

    /**
     * Register module at `path` with callback `definition`.
     *
     * @param {String} path
     * @param {Function} definition
     * @api private
     */

    require.register = function (path, definition) {
        require.modules[path] = definition;
    };

    /**
     * Alias a module definition.
     *
     * @param {String} from
     * @param {String} to
     * @api private
     */

    require.alias = function (from, to) {
        if (!require.modules.hasOwnProperty(from)) {
            throw new Error('Failed to alias "' + from + '", it does not exist');
        }
        require.aliases[to] = from;
    };

    /**
     * Return a require function relative to the `parent` path.
     *
     * @param {String} parent
     * @return {Function}
     * @api private
     */

    require.relative = function (parent) {
        var p = require.normalize(parent, '..');

        /**
         * lastIndexOf helper.
         */

        function lastIndexOf(arr, obj) {
            var i = arr.length;
            while (i--) {
                if (arr[i] === obj) return i;
            }
            return -1;
        }

        /**
         * The relative require() itself.
         */

        function localRequire(path) {
            var resolved = localRequire.resolve(path);
            return require(resolved, parent, path);
        }

        /**
         * Resolve relative to the parent.
         */

        localRequire.resolve = function (path) {
            var c = path.charAt(0);
            if ('/' == c) return path.slice(1);
            if ('.' == c) return require.normalize(p, path);

            // resolve deps by returning
            // the dep in the nearest "deps"
            // directory
            var segs = parent.split('/');
            var i = lastIndexOf(segs, 'deps') + 1;
            if (!i) i = 0;
            path = segs.slice(0, i + 1).join('/') + '/deps/' + path;
            return path;
        };

        /**
         * Check if module is defined at `path`.
         */

        localRequire.exists = function (path) {
            return require.modules.hasOwnProperty(localRequire.resolve(path));
        };

        return localRequire;
    };
    require.register("component-event/index.js", function (exports, require, module) {
        var bind = window.addEventListener ? 'addEventListener' : 'attachEvent',
            unbind = window.removeEventListener ? 'removeEventListener' : 'detachEvent',
            prefix = bind !== 'addEventListener' ? 'on' : '';

        /**
         * Bind `el` event `type` to `fn`.
         *
         * @param {Element} el
         * @param {String} type
         * @param {Function} fn
         * @param {Boolean} capture
         * @return {Function}
         * @api public
         */

        exports.bind = function (el, type, fn, capture) {
            el[bind](prefix + type, fn, capture || false);
            return fn;
        };

        /**
         * Unbind `el` event `type`'s callback `fn`.
         *
         * @param {Element} el
         * @param {String} type
         * @param {Function} fn
         * @param {Boolean} capture
         * @return {Function}
         * @api public
         */

        exports.unbind = function (el, type, fn, capture) {
            el[unbind](prefix + type, fn, capture || false);
            return fn;
        };
    });
    require.register("component-query/index.js", function (exports, require, module) {
        function one(selector, el) {
            return el.querySelector(selector);
        }

        exports = module.exports = function (selector, el) {
            el = el || document;
            return one(selector, el);
        };

        exports.all = function (selector, el) {
            el = el || document;
            return el.querySelectorAll(selector);
        };

        exports.engine = function (obj) {
            if (!obj.one) throw new Error('.one callback required');
            if (!obj.all) throw new Error('.all callback required');
            one = obj.one;
            exports.all = obj.all;
            return exports;
        };

    });
    require.register("component-matches-selector/index.js", function (exports, require, module) {
        /**
         * Module dependencies.
         */

        var query = require('query');

        /**
         * Element prototype.
         */

        var proto = Element.prototype;

        /**
         * Vendor function.
         */

        var vendor = proto.matches || proto.webkitMatchesSelector || proto.mozMatchesSelector || proto.msMatchesSelector || proto.oMatchesSelector;

        /**
         * Expose `match()`.
         */

        module.exports = match;

        /**
         * Match `el` to `selector`.
         *
         * @param {Element} el
         * @param {String} selector
         * @return {Boolean}
         * @api public
         */

        function match(el, selector) {
            if (vendor) return vendor.call(el, selector);
            var nodes = query.all(selector, el.parentNode);
            for (var i = 0; i < nodes.length; ++i) {
                if (nodes[i] == el) return true;
            }
            return false;
        }

    });
    require.register("discore-closest/index.js", function (exports, require, module) {
        var matches = require('matches-selector')

        module.exports = function (element, selector, checkYoSelf, root) {
            element = checkYoSelf ? {
                parentNode: element
            } : element

            root = root || document

            // Make sure `element !== document` and `element != null`
            // otherwise we get an illegal invocation
            while ((element = element.parentNode) && element !== document) {
                if (matches(element, selector))
                    return element
                        // After `matches` on the edge case that
                        // the selector matches the root
                        // (when the root is not the document)
                if (element === root)
                    return
            }
        }
    });
    require.register("component-delegate/index.js", function (exports, require, module) {
        /**
         * Module dependencies.
         */

        var closest = require('closest'),
            event = require('event');

        /**
         * Delegate event `type` to `selector`
         * and invoke `fn(e)`. A callback function
         * is returned which may be passed to `.unbind()`.
         *
         * @param {Element} el
         * @param {String} selector
         * @param {String} type
         * @param {Function} fn
         * @param {Boolean} capture
         * @return {Function}
         * @api public
         */

        exports.bind = function (el, selector, type, fn, capture) {
            return event.bind(el, type, function (e) {
                var target = e.target || e.srcElement;
                e.delegateTarget = closest(target, selector, true, el);
                if (e.delegateTarget) fn.call(el, e);
            }, capture);
        };

        /**
         * Unbind event `type`'s callback `fn`.
         *
         * @param {Element} el
         * @param {String} type
         * @param {Function} fn
         * @param {Boolean} capture
         * @api public
         */

        exports.unbind = function (el, type, fn, capture) {
            event.unbind(el, type, fn, capture);
        };

    });
    require.register("component-events/index.js", function (exports, require, module) {

        /**
         * Module dependencies.
         */

        var events = require('event');
        var delegate = require('delegate');

        /**
         * Expose `Events`.
         */

        module.exports = Events;

        /**
         * Initialize an `Events` with the given
         * `el` object which events will be bound to,
         * and the `obj` which will receive method calls.
         *
         * @param {Object} el
         * @param {Object} obj
         * @api public
         */

        function Events(el, obj) {
            if (!(this instanceof Events)) return new Events(el, obj);
            if (!el) throw new Error('element required');
            if (!obj) throw new Error('object required');
            this.el = el;
            this.obj = obj;
            this._events = {};
        }

        /**
         * Subscription helper.
         */

        Events.prototype.sub = function (event, method, cb) {
            this._events[event] = this._events[event] || {};
            this._events[event][method] = cb;
        };

        /**
         * Bind to `event` with optional `method` name.
         * When `method` is undefined it becomes `event`
         * with the "on" prefix.
         *
         * Examples:
         *
         *  Direct event handling:
         *
         *    events.bind('click') // implies "onclick"
         *    events.bind('click', 'remove')
         *    events.bind('click', 'sort', 'asc')
         *
         *  Delegated event handling:
         *
         *    events.bind('click li > a')
         *    events.bind('click li > a', 'remove')
         *    events.bind('click a.sort-ascending', 'sort', 'asc')
         *    events.bind('click a.sort-descending', 'sort', 'desc')
         *
         * @param {String} event
         * @param {String|function} [method]
         * @return {Function} callback
         * @api public
         */

        Events.prototype.bind = function (event, method) {
            var e = parse(event);
            var el = this.el;
            var obj = this.obj;
            var name = e.name;
            var method = method || 'on' + name;
            var args = [].slice.call(arguments, 2);

            // callback
            function cb() {
                var a = [].slice.call(arguments).concat(args);
                obj[method].apply(obj, a);
            }

            // bind
            if (e.selector) {
                cb = delegate.bind(el, e.selector, name, cb);
            } else {
                events.bind(el, name, cb);
            }

            // subscription for unbinding
            this.sub(name, method, cb);

            return cb;
        };

        /**
         * Unbind a single binding, all bindings for `event`,
         * or all bindings within the manager.
         *
         * Examples:
         *
         *  Unbind direct handlers:
         *
         *     events.unbind('click', 'remove')
         *     events.unbind('click')
         *     events.unbind()
         *
         * Unbind delegate handlers:
         *
         *     events.unbind('click', 'remove')
         *     events.unbind('click')
         *     events.unbind()
         *
         * @param {String|Function} [event]
         * @param {String|Function} [method]
         * @api public
         */

        Events.prototype.unbind = function (event, method) {
            if (0 == arguments.length) return this.unbindAll();
            if (1 == arguments.length) return this.unbindAllOf(event);

            // no bindings for this event
            var bindings = this._events[event];
            if (!bindings) return;

            // no bindings for this method
            var cb = bindings[method];
            if (!cb) return;

            events.unbind(this.el, event, cb);
        };

        /**
         * Unbind all events.
         *
         * @api private
         */

        Events.prototype.unbindAll = function () {
            for (var event in this._events) {
                this.unbindAllOf(event);
            }
        };

        /**
         * Unbind all events for `event`.
         *
         * @param {String} event
         * @api private
         */

        Events.prototype.unbindAllOf = function (event) {
            var bindings = this._events[event];
            if (!bindings) return;

            for (var method in bindings) {
                this.unbind(event, method);
            }
        };

        /**
         * Parse `event`.
         *
         * @param {String} event
         * @return {Object}
         * @api private
         */

        function parse(event) {
            var parts = event.split(/ +/);
            return {
                name: parts.shift(),
                selector: parts.join(' ')
            }
        }

    });
    require.register("component-indexof/index.js", function (exports, require, module) {
        module.exports = function (arr, obj) {
            if (arr.indexOf) return arr.indexOf(obj);
            for (var i = 0; i < arr.length; ++i) {
                if (arr[i] === obj) return i;
            }
            return -1;
        };

    });
    require.register("component-classes/index.js", function (exports, require, module) {
        /**
         * Module dependencies.
         */

        var index = require('indexof');

        /**
         * Whitespace regexp.
         */

        var re = /\s+/;

        /**
         * toString reference.
         */

        var toString = Object.prototype.toString;

        /**
         * Wrap `el` in a `ClassList`.
         *
         * @param {Element} el
         * @return {ClassList}
         * @api public
         */

        module.exports = function (el) {
            return new ClassList(el);
        };

        /**
         * Initialize a new ClassList for `el`.
         *
         * @param {Element} el
         * @api private
         */

        function ClassList(el) {
            if (!el) throw new Error('A DOM element reference is required');
            this.el = el;
            this.list = el.classList;
        }

        /**
         * Add class `name` if not already present.
         *
         * @param {String} name
         * @return {ClassList}
         * @api public
         */

        ClassList.prototype.add = function (name) {
            // classList
            if (this.list) {
                this.list.add(name);
                return this;
            }

            // fallback
            var arr = this.array();
            var i = index(arr, name);
            if (!~i) arr.push(name);
            this.el.className = arr.join(' ');
            return this;
        };

        /**
         * Remove class `name` when present, or
         * pass a regular expression to remove
         * any which match.
         *
         * @param {String|RegExp} name
         * @return {ClassList}
         * @api public
         */

        ClassList.prototype.remove = function (name) {
            if ('[object RegExp]' == toString.call(name)) {
                return this.removeMatching(name);
            }

            // classList
            if (this.list) {
                this.list.remove(name);
                return this;
            }

            // fallback
            var arr = this.array();
            var i = index(arr, name);
            if (~i) arr.splice(i, 1);
            this.el.className = arr.join(' ');
            return this;
        };

        /**
         * Remove all classes matching `re`.
         *
         * @param {RegExp} re
         * @return {ClassList}
         * @api private
         */

        ClassList.prototype.removeMatching = function (re) {
            var arr = this.array();
            for (var i = 0; i < arr.length; i++) {
                if (re.test(arr[i])) {
                    this.remove(arr[i]);
                }
            }
            return this;
        };

        /**
         * Toggle class `name`, can force state via `force`.
         *
         * For browsers that support classList, but do not support `force` yet,
         * the mistake will be detected and corrected.
         *
         * @param {String} name
         * @param {Boolean} force
         * @return {ClassList}
         * @api public
         */

        ClassList.prototype.toggle = function (name, force) {
            // classList
            if (this.list) {
                if ("undefined" !== typeof force) {
                    if (force !== this.list.toggle(name, force)) {
                        this.list.toggle(name); // toggle again to correct
                    }
                } else {
                    this.list.toggle(name);
                }
                return this;
            }

            // fallback
            if ("undefined" !== typeof force) {
                if (!force) {
                    this.remove(name);
                } else {
                    this.add(name);
                }
            } else {
                if (this.has(name)) {
                    this.remove(name);
                } else {
                    this.add(name);
                }
            }

            return this;
        };

        /**
         * Return an array of classes.
         *
         * @return {Array}
         * @api public
         */

        ClassList.prototype.array = function () {
            var str = this.el.className.replace(/^\s+|\s+$/g, '');
            var arr = str.split(re);
            if ('' === arr[0]) arr.shift();
            return arr;
        };

        /**
         * Check if class `name` is present.
         *
         * @param {String} name
         * @return {ClassList}
         * @api public
         */

        ClassList.prototype.has =
            ClassList.prototype.contains = function (name) {
                return this.list ? this.list.contains(name) : !!~index(this.array(), name);
            };

    });
    require.register("component-emitter/index.js", function (exports, require, module) {

        /**
         * Expose `Emitter`.
         */

        module.exports = Emitter;

        /**
         * Initialize a new `Emitter`.
         *
         * @api public
         */

        function Emitter(obj) {
            if (obj) return mixin(obj);
        };

        /**
         * Mixin the emitter properties.
         *
         * @param {Object} obj
         * @return {Object}
         * @api private
         */

        function mixin(obj) {
            for (var key in Emitter.prototype) {
                obj[key] = Emitter.prototype[key];
            }
            return obj;
        }

        /**
         * Listen on the given `event` with `fn`.
         *
         * @param {String} event
         * @param {Function} fn
         * @return {Emitter}
         * @api public
         */

        Emitter.prototype.on =
            Emitter.prototype.addEventListener = function (event, fn) {
                this._callbacks = this._callbacks || {};
                (this._callbacks[event] = this._callbacks[event] || [])
                .push(fn);
                return this;
            };

        /**
         * Adds an `event` listener that will be invoked a single
         * time then automatically removed.
         *
         * @param {String} event
         * @param {Function} fn
         * @return {Emitter}
         * @api public
         */

        Emitter.prototype.once = function (event, fn) {
            var self = this;
            this._callbacks = this._callbacks || {};

            function on() {
                self.off(event, on);
                fn.apply(this, arguments);
            }

            on.fn = fn;
            this.on(event, on);
            return this;
        };

        /**
         * Remove the given callback for `event` or all
         * registered callbacks.
         *
         * @param {String} event
         * @param {Function} fn
         * @return {Emitter}
         * @api public
         */

        Emitter.prototype.off =
            Emitter.prototype.removeListener =
            Emitter.prototype.removeAllListeners =
            Emitter.prototype.removeEventListener = function (event, fn) {
                this._callbacks = this._callbacks || {};

                // all
                if (0 == arguments.length) {
                    this._callbacks = {};
                    return this;
                }

                // specific event
                var callbacks = this._callbacks[event];
                if (!callbacks) return this;

                // remove all handlers
                if (1 == arguments.length) {
                    delete this._callbacks[event];
                    return this;
                }

                // remove specific handler
                var cb;
                for (var i = 0; i < callbacks.length; i++) {
                    cb = callbacks[i];
                    if (cb === fn || cb.fn === fn) {
                        callbacks.splice(i, 1);
                        break;
                    }
                }
                return this;
            };

        /**
         * Emit `event` with the given args.
         *
         * @param {String} event
         * @param {Mixed} ...
         * @return {Emitter}
         */

        Emitter.prototype.emit = function (event) {
            this._callbacks = this._callbacks || {};
            var args = [].slice.call(arguments, 1),
                callbacks = this._callbacks[event];

            if (callbacks) {
                callbacks = callbacks.slice(0);
                for (var i = 0, len = callbacks.length; i < len; ++i) {
                    callbacks[i].apply(this, args);
                }
            }

            return this;
        };

        /**
         * Return array of callbacks for `event`.
         *
         * @param {String} event
         * @return {Array}
         * @api public
         */

        Emitter.prototype.listeners = function (event) {
            this._callbacks = this._callbacks || {};
            return this._callbacks[event] || [];
        };

        /**
         * Check if this emitter has `event` handlers.
         *
         * @param {String} event
         * @return {Boolean}
         * @api public
         */

        Emitter.prototype.hasListeners = function (event) {
            return !!this.listeners(event).length;
        };

    });
    require.register("ui-component-mouse/index.js", function (exports, require, module) {

        /**
         * dependencies.
         */

        var emitter = require('emitter'),
            event = require('event');

        /**
         * export `Mouse`
         */

        module.exports = function (el, obj) {
            return new Mouse(el, obj);
        };

        /**
         * initialize new `Mouse`.
         * 
         * @param {Element} el
         * @param {Object} obj
         */

        function Mouse(el, obj) {
            this.obj = obj || {};
            this.el = el;
        }

        /**
         * mixin emitter.
         */

        emitter(Mouse.prototype);

        /**
         * bind mouse.
         * 
         * @return {Mouse}
         */

        Mouse.prototype.bind = function () {
            var obj = this.obj,
                self = this;

            // up
            function up(e) {
                obj.onmouseup && obj.onmouseup(e);
                event.unbind(document, 'mousemove', move);
                event.unbind(document, 'mouseup', up);
                self.emit('up', e);
            }

            // move
            function move(e) {
                obj.onmousemove && obj.onmousemove(e);
                self.emit('move', e);
            }

            // down
            self.down = function (e) {
                obj.onmousedown && obj.onmousedown(e);
                event.bind(document, 'mouseup', up);
                event.bind(document, 'mousemove', move);
                self.emit('down', e);
            };

            // bind all.
            event.bind(this.el, 'mousedown', self.down);

            return this;
        };

        /**
         * unbind mouse.
         * 
         * @return {Mouse}
         */

        Mouse.prototype.unbind = function () {
            event.unbind(this.el, 'mousedown', this.down);
            this.down = null;
        };

    });
    require.register("abpetkov-percentage-calc/percentage-calc.js", function (exports, require, module) {

        /**
         * Percentage-Calc 0.0.1
         * https://github.com/abpetkov/percentage-calc
         *
         * Authored by Alexander Petkov
         * https://github.com/abpetkov
         *
         * Copyright 2014, Alexander Petkov
         * License: The MIT License (MIT)
         * http://opensource.org/licenses/MIT
         *
         */

        /**
         * Check if number.
         *
         * @param {Number} num
         * @returns {Boolean}
         * @api public
         */

        exports.isNumber = function (num) {
            return (typeof num === 'number') ? true : false;
        };

        /**
         * Calculate percentage of a number.
         *
         * @param {Number} perc
         * @param {Number} num
         * @returns {Number} result
         * @api public
         */

        exports.of = function (perc, num) {
            if (exports.isNumber(perc) && exports.isNumber(num)) return (perc / 100) * num;
        };

        /**
         * Calculate percentage of a number out ot another number.
         *
         * @param {Number} part
         * @param {Number} target
         * @returns {Number} result
         * @api public
         */

        exports.from = function (part, target) {
            if (exports.isNumber(part) && exports.isNumber(target)) return (part / target) * 100;
        };
    });
    require.register("abpetkov-closest-num/closest-num.js", function (exports, require, module) {
        /**
         * Closest-num 0.0.1
         * https://github.com/abpetkov/closest-num
         *
         * Author: Alexander Petkov
         * https://github.com/abpetkov
         *
         * Copyright 2014, Alexander Petkov
         * License: The MIT License (MIT)
         * http://opensource.org/licenses/MIT
         *
         */

        /**
         * Get closest number in array.
         *
         * @param {Number} target
         * @param {Array} points
         * @returns {Number} closest
         * @api private
         */

        exports.find = function (target, points) {
            var diff = null,
                current = null,
                closest = points[0];

            for (i = 0; i < points.length; i++) {
                diff = Math.abs(target - closest);
                current = Math.abs(target - points[i]);
                if (current < diff) closest = points[i];
            }

            return closest;
        };
    });
    require.register("vesln-super/lib/super.js", function (exports, require, module) {
        /**
         * slice
         */

        var slice = Array.prototype.slice;

        /**
         * Primary export
         */

        var exports = module.exports = super_;

        /**
         * ### _super (dest, orig)
         *
         * Inherits the prototype methods or merges objects.
         * This is the primary export and it is recommended
         * that it be imported as `inherits` in node to match
         * the auto imported browser interface.
         *
         *     var inherits = require('super');
         *
         * @param {Object|Function} destination object
         * @param {Object|Function} source object
         * @name _super
         * @api public
         */

        function super_() {
            var args = slice.call(arguments);
            if (!args.length) return;
            if (typeof args[0] !== 'function') return exports.merge(args);
            exports.inherits.apply(null, args);
        };

        /**
         * ### extend (proto[, klass])
         *
         * Provide `.extend` mechanism to allow extenion without
         * needing to use dependancy.
         *
         *     function Bar () {
         *       this._konstructed = true;
         *     }
         *
         *     Bar.extend = inherits.extend;
         *
         *     var Fu = Bar.extend({
         *       initialize: function () {
         *         this._initialized = true;
         *       }
         *     });
         *
         *     var fu = new Fu();
         *     fu.should.be.instanceof(Fu); // true
         *     fu.should.be.instanceof(Bar); // true
         *
         * @param {Object} properties/methods to add to new prototype
         * @param {Object} properties/methods to add to new class
         * @returns {Object} new constructor
         * @name extend
         * @api public
         */

        exports.extend = function (proto, klass) {
            var self = this,
                child = function () {
                    return self.apply(this, arguments);
                };
            exports.merge([child, this]);
            exports.inherits(child, this);
            if (proto) exports.merge([child.prototype, proto]);
            if (klass) exports.merge([child, klass]);
            child.extend = this.extend; // prevent overwrite
            return child;
        };

        /**
         * ### inherits (ctor, superCtor)
         *
         * Inherit the prototype methods from on contructor
         * to another.
         *
         * @param {Function} destination
         * @param {Function} source
         * @api private
         */

        exports.inherits = function (ctor, superCtor) {
            ctor.super_ = superCtor;
            if (Object.create) {
                ctor.prototype = Object.create(superCtor.prototype, {
                    constructor: {
                        value: ctor,
                        enumerable: false,
                        writable: true,
                        configurable: true
                    }
                });
            } else {
                ctor.prototype = new superCtor();
                ctor.prototype.constructor = ctor;
            }
        }

        /**
         * Extends multiple objects.
         *
         * @param {Array} array of objects
         * @api private
         */

        exports.merge = function (arr) {
            var main = arr.length === 2 ? arr.shift() : {};
            var obj = null;

            for (var i = 0, len = arr.length; i < len; i++) {
                obj = arr[i];
                for (var p in obj) {
                    if (!obj.hasOwnProperty(p)) continue;
                    main[p] = obj[p];
                }
            }

            return main;
        };

    });
    require.register("powerange/lib/powerange.js", function (exports, require, module) {
        /**
         * Require classes.
         */

        var Main = require('./main'),
            Horizontal = require('./horizontal'),
            Vertical = require('./vertical');

        /**
         * Set default values.
         *
         * @api public
         */

        var defaults = {
            callback: function () {},
            decimal: false,
            disable: false,
            disableOpacity: 0.5,
            hideRange: false,
            klass: '',
            min: 0,
            max: 100,
            handleDiameter: 20,
            touchDiameter: 42,
            start: null,
            step: null,
            vertical: false
        };

        /**
         * Expose proper type of `Powerange`.
         */

        module.exports = function (element, options) {
            options = options || {};

            for (var i in defaults) {
                if (options[i] == null) {
                    options[i] = defaults[i];
                }
            }

            if (options.vertical) {
                return new Vertical(element, options);
            } else {
                return new Horizontal(element, options);
            }
        };
    });
    require.register("powerange/lib/main.js", function (exports, require, module) {
        /**
         * External dependencies.
         *
         */

        var mouse = require('mouse'),
            events = require('events'),
            classes = require('classes'),
            percentage = require('percentage-calc');

        /**
         * Expose `Powerange`.
         */

        module.exports = Powerange;

        /**
         * Create Powerange object.
         *
         * @constructor
         * @param {Object} element
         * @param {Object} options
         * @api public
         */

        function Powerange(element, options) {
            if (!(this instanceof Powerange)) return new Powerange(element, options);

            this.element = element;
            this.options = options || {};
            //this.slider = this.create('span', 'range-bar');
            this.slider = this.create('div', 'range-container');

            if (this.element !== null && this.element.type === 'text') this.init();
        }

        /**
         * Bind events on handle element.
         *
         * @api private
         */

        Powerange.prototype.bindEvents = function () {
            this.handle = this.slider.querySelector('.range-handle');
            this.touch = events(this.slider, this);
            this.touch.bind('touchstart', 'onmousedown');
            this.touch.bind('touchmove', 'onmousemove');
            this.touch.bind('touchend', 'onmouseup');
            this.mouse = mouse(this.slider, this);
            this.mouse.bind();
        };

        /**
         * Hide the target element.
         *
         * @api private
         */

        Powerange.prototype.hide = function () {
            this.element.style.display = 'none';
        };

        /**
         * Append the target after the element.
         *
         * @api private
         */

        Powerange.prototype.append = function () {
            var slider = this.generate();
            this.insertAfter(this.element, slider);
        };

        /**
         * Generate the appropriate type of slider.
         *
         * @returns {Object} this.slider
         * @api private
         */

        Powerange.prototype.generate = function () {
            var elems = {
                'handle': {
                    'type': 'span',
                    'selector': 'range-handle'
                },
                'min': {
                    'type': 'span',
                    'selector': 'range-min'
                },
                'max': {
                    'type': 'span',
                    'selector': 'range-max'
                },
                'quantity': {
                    'type': 'span',
                    'selector': 'range-quantity'
                }
            };

            var bar = this.create('span', 'range-bar');
            this.slider.appendChild(bar);

            for (var key in elems) {
                if (elems.hasOwnProperty(key)) {
                    var temp = this.create(elems[key].type, elems[key].selector);
                    bar.appendChild(temp);
                }
            }

            return this.slider;
        };

        /**
         * Create HTML element.
         *
         * @param {String} type
         * @param {String} name
         * @returns {Object} elem
         * @api private
         */

        Powerange.prototype.create = function (type, name) {
            var elem = document.createElement(type);
            elem.className = name;

            return elem;
        };

        /**
         * Insert element after another element.
         *
         * @param {Object} reference
         * @param {Object} target
         * @api private
         */

        Powerange.prototype.insertAfter = function (reference, target) {
            reference.parentNode.insertBefore(target, reference.nextSibling);
        };

        /**
         * Add an additional class for extra customization.
         *
         * @param {String} klass
         * @api private
         */

        Powerange.prototype.extraClass = function (klass) {
            if (this.options.klass) classes(this.slider).add(klass);
        };

        /**
         * Set min and max values.
         *
         * @param {Number} min
         * @param {Number} max
         * @api private
         */

        Powerange.prototype.setRange = function (min, max) {
            if (typeof min === 'number' && typeof max === 'number' && !this.options.hideRange) {
                this.slider.querySelector('.range-min').innerHTML = min;
                this.slider.querySelector('.range-max').innerHTML = max;
            }
        };

        /**
         * Set slider current value.
         *
         * @param {Number} offset
         * @param {Number} size
         * @api private
         */

        Powerange.prototype.setValue = function (offset, size) {
            var part = percentage.from(parseFloat(offset), size),
                value = percentage.of(part, this.options.max - this.options.min) + this.options.min,
                changed = false;

            value = (this.options.decimal) ? (Math.round(value * 100) / 100) : Math.round(value);

            changed = (this.element.value != value) ? true : false;

            this.element.value = value;
            this.options.callback();
            if (changed) this.changeEvent();
        };

        /**
         * Set step.
         *
         * @param {Number} sliderSize
         * @param {Number} handleSize
         * @returns {Array} this.steps
         * @api private
         */

        Powerange.prototype.step = function (sliderSize, handleSize) {

            var dimension = sliderSize - handleSize,
                part = percentage.from(this.checkStep(this.options.step), this.options.max - this.options.min),
                interval = percentage.of(part, dimension),
                steps = [];

            if (interval == 0) interval = 1;

            for (i = 0; i <= dimension; i += interval) {
                steps.push(i);
            }

            this.steps = steps;

            return this.steps;
        };

        /**
         * Check values.
         *
         * @param {Number} start
         * @api private
         */

        Powerange.prototype.checkValues = function (start) {
            if (start < this.options.min) this.options.start = this.options.min;
            if (start > this.options.max) this.options.start = this.options.max;
            if (this.options.min >= this.options.max) this.options.min = this.options.max;
        };

        /**
         * Make sure `step` is positive.
         *
         * @param {Number} value
         * @returns {Number} this.options.step
         * @api private
         */

        Powerange.prototype.checkStep = function (value) {
            if (value < 0) value = Math.abs(value);
            this.options.step = value;
            return this.options.step;
        };

        /**
         * Disable range slider.
         *
         * @api private
         */

        Powerange.prototype.disable = function () {
            if (this.options.min == this.options.max || this.options.min > this.options.max || this.options.disable) {
                this.mouse.unbind();
                this.touch.unbind();
                this.slider.style.opacity = this.options.disableOpacity;
                classes(this.handle).add('range-disabled');
            }
        };

        /**
         * Make element unselectable.
         *
         * @param {Object} element
         * @param {Boolean} set
         * @api private
         */

        Powerange.prototype.unselectable = function (element, set) {
            if (!classes(this.slider).has('unselectable') && set === true) {
                classes(this.slider).add('unselectable');
            } else {
                classes(this.slider).remove('unselectable');
            }
        };

        /**
         * Handle the onchange event.
         *
         * @param {Boolean} state
         * @api private
         */

        Powerange.prototype.changeEvent = function (state) {
            if (typeof Event === 'function' || !document.fireEvent) {
                var event = document.createEvent('HTMLEvents');
                event.initEvent('change', false, true);
                this.element.dispatchEvent(event);
            } else {
                this.element.fireEvent('onchange');
            }
        };

        /**
         * Initialize main class.
         *
         * @api private
         */

        Powerange.prototype.init = function () {
            this.hide();
            this.append();
            this.bindEvents();
            this.extraClass(this.options.klass);
            this.checkValues(this.options.start);
            this.setRange(this.options.min, this.options.max);
            this.disable();
        };
    });
    require.register("powerange/lib/horizontal.js", function (exports, require, module) {
        /**
         * External dependencies.
         *
         */

        var inherits = require('super'),
            closest = require('closest-num'),
            percentage = require('percentage-calc');

        /**
         * Require main class.
         */

        var Powerange = require('./main');

        /**
         * Expose `Horizontal`.
         */

        module.exports = Horizontal;

        /**
         * Create horizontal slider object.
         *
         * @api public
         */

        function Horizontal() {
            Powerange.apply(this, arguments);
            this.handle.style.width = this.options.handleDiameter + "px";
            this.handle.style.height = this.options.handleDiameter + "px";
            this.handle.style.top = - (this.options.handleDiameter)/2 + 2 + "px";
            if (this.options.step) this.step($(this.slider).width(), $(this.handle).width());
            this.setStart(this.options.start);
        }

        /**
         * Inherit the main class.
         */

        inherits(Horizontal, Powerange);

        /**
         * Set horizontal slider position.
         *
         * @param {Number} start
         * @api private
         */

        Horizontal.prototype.setStart = function (start) {
            var begin = (start === null) ? this.options.min : start,
                part = percentage.from(begin - this.options.min, this.options.max - this.options.min) || 0,
                offset = percentage.of(part, $(this.slider).width() - $(this.handle).width()),
                position = (this.options.step) ? closest.find(offset, this.steps) : offset;

            this.setPosition(position);
            this.setValue(this.handle.style.left, $(this.slider).width() - $(this.handle).width());
            if (this.options.step) this.step($(this.slider).width(), $(this.handle).width());
        };

        /**
         * Set horizontal slider current position.
         *
         * @param {Number} val
         * @api private
         */

        Horizontal.prototype.setPosition = function (val) {
            this.handle.style.left = val + 'px';
            this.slider.querySelector('.range-quantity').style.width = val + 'px';
        };

        /**
         * On slider mouse down.
         *
         * @param {Object} e
         * @api private
         */

        Horizontal.prototype.onmousedown = function (e) {
            if (e.touches) e = e.touches[0];
            // snap to the touched position
            if (e.target.className !== 'range-handle') {
                if (!this.options.tap)
                    return;
                var offset = 0;
                var elm = this.handle;
                while (elm !== null) {
                    offset += elm.offsetLeft;
                    elm = elm.offsetParent;
                }
                this.startX = offset - window.scrollX + this.handle.clientWidth / 2;

            } else {
                this.startX = e.clientX;
                this.ht = $(this.handle).css("top");
                this.handle.style.marginLeft = - (this.options.touchDiameter-this.options.handleDiameter)/4 + "px";
                this.handle.style.width = this.options.touchDiameter + "px";
                this.handle.style.height = this.options.touchDiameter + "px";
                this.handle.style.top = parseInt(this.handle.style.top) - (this.options.touchDiameter-this.options.handleDiameter)/2  +'px';
            }
            this.handleOffsetX = this.handle.offsetLeft;
            this.restrictHandleX = $(this.slider).width() - $(this.handle).width();
            this.unselectable(this.slider, true);
            this.onmousemove(e);
        };

        /**
         * On slider mouse move.
         *
         * @param {Object} e
         * @api private
         */

        Horizontal.prototype.onmousemove = function (e) {
            if (e.target.className !== 'range-handle' && !this.options.tap)
                return;
            if (typeof e.preventDefault == 'function') {
                e.preventDefault()
            }
            if (e.touches) e = e.touches[0];

            var leftOffset = this.handleOffsetX + e.clientX - this.startX,
                position = (this.steps) ? closest.find(leftOffset, this.steps) : leftOffset;

            if (leftOffset <= 0) {
                this.setPosition(0);
            } else if (leftOffset >= this.restrictHandleX) {
                this.setPosition(this.restrictHandleX);
            } else {
                this.setPosition(position);
            }

            this.setValue(this.handle.style.left, $(this.slider).width() - this.options.handleDiameter);
        };

        /**
         * On mouse up.
         *
         * @param {Object} e
         * @api private
         */

        Horizontal.prototype.onmouseup = function (e) {
            this.unselectable(this.slider, false);
            this.handle.style.marginLeft = "0px";
            this.handle.style.width = this.options.handleDiameter + "px";
            this.handle.style.height = this.options.handleDiameter + "px";
            this.handle.style.top = this.ht;
            this.setValue(this.handle.style.left, $(this.slider).width() - $(this.handle).width());

        };
    });
    require.register("powerange/lib/vertical.js", function (exports, require, module) {
        /**
         * External dependencies.
         *
         */

        var inherits = require('super'),
            classes = require('classes'),
            closest = require('closest-num'),
            percentage = require('percentage-calc');

        /**
         * Require main class.
         */

        var Powerange = require('./main');

        /**
         * Expose `Vertical`.
         */

        module.exports = Vertical;

        /**
         * Create vertical slider object.
         *
         * @api public
         */

        function Vertical() {
            Powerange.apply(this, arguments);
            this.handle.style.width = this.options.handleDiameter + "px";
            this.handle.style.height = this.options.handleDiameter + "px";
            classes(this.slider).add('vertical');
            if (this.options.step) this.step($(this.slider).height(), $(this.handle).height());
            this.setStart(this.options.start);
        }

        /**
         * Inherit the main class.
         */

        inherits(Vertical, Powerange);

        /**
         * Set vertical slider position.
         *
         * @param {Number} start
         * @api private
         */

        Vertical.prototype.setStart = function (start) {
            var begin = (start === null) ? this.options.min : start,
                part = percentage.from(begin - this.options.min, this.options.max - this.options.min) || 0,
                offset = percentage.of(part, $(this.slider).height() - $(this.handle).height()),
                position = (this.options.step) ? closest.find(offset, this.steps) : offset;

            this.setPosition(position);
            this.setValue(this.handle.style.bottom, $(this.slider).height() - $(this.handle).height());
            if (this.options.step) this.step($(this.slider).height(), $(this.handle).height());
        };

        /**
         * Set vertical slider current position.
         *
         * @param {Number} val
         * @api private
         */

        Vertical.prototype.setPosition = function (val) {
            this.handle.style.bottom = val + 'px';
            this.slider.querySelector('.range-quantity').style.height = val + 'px';
        };

        /**
         * On mouse down.
         *
         * @param {Object} e
         * @api private
         */

        Vertical.prototype.onmousedown = function (e) {
            if (e.touches) e = e.touches[0];
            // snap to the touched position
            if (e.target.className !== 'range-handle') {
                if (!this.options.tap)
                    return;
                var offset = 0;
                var elm = this.handle;
                while (elm !== null) {
                    offset += elm.offsetTop;
                    elm = elm.offsetParent;
                }
                this.startY = offset - window.scrollY + this.handle.clientHeight / 2;
            } else {
                this.startY = e.clientY;
                this.handle.style.marginLeft = - (this.options.touchDiameter-this.options.handleDiameter)/2 + "px";
                this.handle.style.width = this.options.touchDiameter + "px";
                this.handle.style.height = this.options.touchDiameter + "px";
            }
            this.handleOffsetY = $(this.slider).height() - $(this.handle).height() - this.handle.offsetTop;
            this.restrictHandleY = $(this.slider).height() - $(this.handle).height();
            this.unselectable(this.slider, true);
            this.onmousemove(e);
        };

        /**
         * On vertical slider mouse move.
         *
         * @param {Object} e
         * @api private
         */

        Vertical.prototype.onmousemove = function (e) {
            if (e.target.className !== 'range-handle' && !this.options.tap)
                return;
            if (typeof e.preventDefault == 'function') {
                e.preventDefault()
            }
            if (e.touches) e = e.touches[0];

            var bottomOffset = this.handleOffsetY + this.startY - e.clientY,
                position = (this.steps) ? closest.find(bottomOffset, this.steps) : bottomOffset;

            if (bottomOffset <= 0) {
                this.setPosition(0);
            } else if (bottomOffset >= this.restrictHandleY) {
                this.setPosition(this.restrictHandleY);
            } else {
                this.setPosition(position);
            }

            this.setValue(this.handle.style.bottom, $(this.slider).height() - $(this.handle).height());
        };

        /**
         * On mouse up.
         *
         * @param {Object} e
         * @api private
         */

        Vertical.prototype.onmouseup = function (e) {
            this.unselectable(this.slider, false);
            this.handle.style.marginLeft = "0px";
            this.handle.style.width = this.options.handleDiameter + "px";
            this.handle.style.height = this.options.handleDiameter + "px";
            //this.handle.style.top = this.ht;
            this.setValue(this.handle.style.bottom, $(this.slider).height() - $(this.handle).height());
        };
    });









    require.alias("component-events/index.js", "powerange/deps/events/index.js");
    require.alias("component-events/index.js", "events/index.js");
    require.alias("component-event/index.js", "component-events/deps/event/index.js");

    require.alias("component-delegate/index.js", "component-events/deps/delegate/index.js");
    require.alias("discore-closest/index.js", "component-delegate/deps/closest/index.js");
    require.alias("discore-closest/index.js", "component-delegate/deps/closest/index.js");
    require.alias("component-matches-selector/index.js", "discore-closest/deps/matches-selector/index.js");
    require.alias("component-query/index.js", "component-matches-selector/deps/query/index.js");

    require.alias("discore-closest/index.js", "discore-closest/index.js");
    require.alias("component-event/index.js", "component-delegate/deps/event/index.js");

    require.alias("component-classes/index.js", "powerange/deps/classes/index.js");
    require.alias("component-classes/index.js", "classes/index.js");
    require.alias("component-indexof/index.js", "component-classes/deps/indexof/index.js");

    require.alias("ui-component-mouse/index.js", "powerange/deps/mouse/index.js");
    require.alias("ui-component-mouse/index.js", "mouse/index.js");
    require.alias("component-emitter/index.js", "ui-component-mouse/deps/emitter/index.js");

    require.alias("component-event/index.js", "ui-component-mouse/deps/event/index.js");

    require.alias("abpetkov-percentage-calc/percentage-calc.js", "powerange/deps/percentage-calc/percentage-calc.js");
    require.alias("abpetkov-percentage-calc/percentage-calc.js", "powerange/deps/percentage-calc/index.js");
    require.alias("abpetkov-percentage-calc/percentage-calc.js", "percentage-calc/index.js");
    require.alias("abpetkov-percentage-calc/percentage-calc.js", "abpetkov-percentage-calc/index.js");
    require.alias("abpetkov-closest-num/closest-num.js", "powerange/deps/closest-num/closest-num.js");
    require.alias("abpetkov-closest-num/closest-num.js", "powerange/deps/closest-num/index.js");
    require.alias("abpetkov-closest-num/closest-num.js", "closest-num/index.js");
    require.alias("abpetkov-closest-num/closest-num.js", "abpetkov-closest-num/index.js");
    require.alias("vesln-super/lib/super.js", "powerange/deps/super/lib/super.js");
    require.alias("vesln-super/lib/super.js", "powerange/deps/super/index.js");
    require.alias("vesln-super/lib/super.js", "super/index.js");
    require.alias("vesln-super/lib/super.js", "vesln-super/index.js");
    require.alias("powerange/lib/powerange.js", "powerange/index.js");
    if (typeof exports == "object") {
        module.exports = require("powerange");
    } else if (typeof define == "function" && define.amd) {
        define([], function () {
            return require("powerange");
        });
    } else {
        this["Powerange"] = require("powerange");
    }
})();