ok

Mini Shell

Direktori : /home2/selectio/www/thecomponents.in/admin/old/eCart - v5.0.0/plugins/switchery/
Upload File :
Current File : /home2/selectio/www/thecomponents.in/admin/old/eCart - v5.0.0/plugins/switchery/switchery.min.js

(function() {
    function require(name) {
        var module = require.modules[name];
        if (!module) throw new Error('failed to require "' + name + '"');
        if (!("exports" in module) && typeof module.definition === "function") {
            module.client = module.component = true;
            module.definition.call(this, module.exports = {}, module);
            delete module.definition
        }
        return module.exports
    }
    require.loader = "component";
    require.helper = {};
    require.helper.semVerSort = function(a, b) { var aArray = a.version.split("."); var bArray = b.version.split("."); for (var i = 0; i < aArray.length; ++i) { var aInt = parseInt(aArray[i], 10); var bInt = parseInt(bArray[i], 10); if (aInt === bInt) { var aLex = aArray[i].substr(("" + aInt).length); var bLex = bArray[i].substr(("" + bInt).length); if (aLex === "" && bLex !== "") return 1; if (aLex !== "" && bLex === "") return -1; if (aLex !== "" && bLex !== "") return aLex > bLex ? 1 : -1; continue } else if (aInt > bInt) { return 1 } else { return -1 } } return 0 };
    require.latest = function(name, returnPath) {
        function showError(name) { throw new Error('failed to find latest module of "' + name + '"') }
        var versionRegexp = /(.*)~(.*)@v?(\d+\.\d+\.\d+[^\/]*)$/;
        var remoteRegexp = /(.*)~(.*)/;
        if (!remoteRegexp.test(name)) showError(name);
        var moduleNames = Object.keys(require.modules);
        var semVerCandidates = [];
        var otherCandidates = [];
        for (var i = 0; i < moduleNames.length; i++) { var moduleName = moduleNames[i]; if (new RegExp(name + "@").test(moduleName)) { var version = moduleName.substr(name.length + 1); var semVerMatch = versionRegexp.exec(moduleName); if (semVerMatch != null) { semVerCandidates.push({ version: version, name: moduleName }) } else { otherCandidates.push({ version: version, name: moduleName }) } } }
        if (semVerCandidates.concat(otherCandidates).length === 0) { showError(name) }
        if (semVerCandidates.length > 0) { var module = semVerCandidates.sort(require.helper.semVerSort).pop().name; if (returnPath === true) { return module } return require(module) }
        var module = otherCandidates.sort(function(a, b) { return a.name > b.name })[0].name;
        if (returnPath === true) { return module }
        return require(module)
    };
    require.modules = {};
    require.register = function(name, definition) { require.modules[name] = { definition: definition } };
    require.define = function(name, exports) { require.modules[name] = { exports: exports } };
    require.register("abpetkov~transitionize@0.0.3", function(exports, module) {
        module.exports = Transitionize;

        function Transitionize(element, props) {
            if (!(this instanceof Transitionize)) return new Transitionize(element, props);
            this.element = element;
            this.props = props || {};
            this.init()
        }
        Transitionize.prototype.isSafari = function() { return /Safari/.test(navigator.userAgent) && /Apple Computer/.test(navigator.vendor) };
        Transitionize.prototype.init = function() {
            var transitions = [];
            for (var key in this.props) { transitions.push(key + " " + this.props[key]) }
            this.element.style.transition = transitions.join(", ");
            if (this.isSafari()) this.element.style.webkitTransition = transitions.join(", ")
        }
    });
    require.register("ftlabs~fastclick@v0.6.11", function(exports, module) {
        function FastClick(layer) {
            "use strict";
            var oldOnClick, self = this;
            this.trackingClick = false;
            this.trackingClickStart = 0;
            this.targetElement = null;
            this.touchStartX = 0;
            this.touchStartY = 0;
            this.lastTouchIdentifier = 0;
            this.touchBoundary = 10;
            this.layer = layer;
            if (!layer || !layer.nodeType) { throw new TypeError("Layer must be a document node") }
            this.onClick = function() { return FastClick.prototype.onClick.apply(self, arguments) };
            this.onMouse = function() { return FastClick.prototype.onMouse.apply(self, arguments) };
            this.onTouchStart = function() { return FastClick.prototype.onTouchStart.apply(self, arguments) };
            this.onTouchMove = function() { return FastClick.prototype.onTouchMove.apply(self, arguments) };
            this.onTouchEnd = function() { return FastClick.prototype.onTouchEnd.apply(self, arguments) };
            this.onTouchCancel = function() { return FastClick.prototype.onTouchCancel.apply(self, arguments) };
            if (FastClick.notNeeded(layer)) { return }
            if (this.deviceIsAndroid) {
                layer.addEventListener("mouseover", this.onMouse, true);
                layer.addEventListener("mousedown", this.onMouse, true);
                layer.addEventListener("mouseup", this.onMouse, true)
            }
            layer.addEventListener("click", this.onClick, true);
            layer.addEventListener("touchstart", this.onTouchStart, false);
            layer.addEventListener("touchmove", this.onTouchMove, false);
            layer.addEventListener("touchend", this.onTouchEnd, false);
            layer.addEventListener("touchcancel", this.onTouchCancel, false);
            if (!Event.prototype.stopImmediatePropagation) {
                layer.removeEventListener = function(type, callback, capture) { var rmv = Node.prototype.removeEventListener; if (type === "click") { rmv.call(layer, type, callback.hijacked || callback, capture) } else { rmv.call(layer, type, callback, capture) } };
                layer.addEventListener = function(type, callback, capture) { var adv = Node.prototype.addEventListener; if (type === "click") { adv.call(layer, type, callback.hijacked || (callback.hijacked = function(event) { if (!event.propagationStopped) { callback(event) } }), capture) } else { adv.call(layer, type, callback, capture) } }
            }
            if (typeof layer.onclick === "function") {
                oldOnClick = layer.onclick;
                layer.addEventListener("click", function(event) { oldOnClick(event) }, false);
                layer.onclick = null
            }
        }
        FastClick.prototype.deviceIsAndroid = navigator.userAgent.indexOf("Android") > 0;
        FastClick.prototype.deviceIsIOS = /iP(ad|hone|od)/.test(navigator.userAgent);
        FastClick.prototype.deviceIsIOS4 = FastClick.prototype.deviceIsIOS && /OS 4_\d(_\d)?/.test(navigator.userAgent);
        FastClick.prototype.deviceIsIOSWithBadTarget = FastClick.prototype.deviceIsIOS && /OS ([6-9]|\d{2})_\d/.test(navigator.userAgent);
        FastClick.prototype.needsClick = function(target) {
            "use strict";
            switch (target.nodeName.toLowerCase()) {
                case "button":
                case "select":
                case "textarea":
                    if (target.disabled) { return true }
                    break;
                case "input":
                    if (this.deviceIsIOS && target.type === "file" || target.disabled) { return true }
                    break;
                case "label":
                case "video":
                    return true
            }
            return /\bneedsclick\b/.test(target.className)
        };
        FastClick.prototype.needsFocus = function(target) {
            "use strict";
            switch (target.nodeName.toLowerCase()) {
                case "textarea":
                    return true;
                case "select":
                    return !this.deviceIsAndroid;
                case "input":
                    switch (target.type) {
                        case "button":
                        case "checkbox":
                        case "file":
                        case "image":
                        case "radio":
                        case "submit":
                            return false
                    }
                    return !target.disabled && !target.readOnly;
                default:
                    return /\bneedsfocus\b/.test(target.className)
            }
        };
        FastClick.prototype.sendClick = function(targetElement, event) {
            "use strict";
            var clickEvent, touch;
            if (document.activeElement && document.activeElement !== targetElement) { document.activeElement.blur() }
            touch = event.changedTouches[0];
            clickEvent = document.createEvent("MouseEvents");
            clickEvent.initMouseEvent(this.determineEventType(targetElement), true, true, window, 1, touch.screenX, touch.screenY, touch.clientX, touch.clientY, false, false, false, false, 0, null);
            clickEvent.forwardedTouchEvent = true;
            targetElement.dispatchEvent(clickEvent)
        };
        FastClick.prototype.determineEventType = function(targetElement) { "use strict"; if (this.deviceIsAndroid && targetElement.tagName.toLowerCase() === "select") { return "mousedown" } return "click" };
        FastClick.prototype.focus = function(targetElement) {
            "use strict";
            var length;
            if (this.deviceIsIOS && targetElement.setSelectionRange && targetElement.type.indexOf("date") !== 0 && targetElement.type !== "time") {
                length = targetElement.value.length;
                targetElement.setSelectionRange(length, length)
            } else { targetElement.focus() }
        };
        FastClick.prototype.updateScrollParent = function(targetElement) {
            "use strict";
            var scrollParent, parentElement;
            scrollParent = targetElement.fastClickScrollParent;
            if (!scrollParent || !scrollParent.contains(targetElement)) {
                parentElement = targetElement;
                do {
                    if (parentElement.scrollHeight > parentElement.offsetHeight) {
                        scrollParent = parentElement;
                        targetElement.fastClickScrollParent = parentElement;
                        break
                    }
                    parentElement = parentElement.parentElement
                } while (parentElement)
            }
            if (scrollParent) { scrollParent.fastClickLastScrollTop = scrollParent.scrollTop }
        };
        FastClick.prototype.getTargetElementFromEventTarget = function(eventTarget) { "use strict"; if (eventTarget.nodeType === Node.TEXT_NODE) { return eventTarget.parentNode } return eventTarget };
        FastClick.prototype.onTouchStart = function(event) {
            "use strict";
            var targetElement, touch, selection;
            if (event.targetTouches.length > 1) { return true }
            targetElement = this.getTargetElementFromEventTarget(event.target);
            touch = event.targetTouches[0];
            if (this.deviceIsIOS) {
                selection = window.getSelection();
                if (selection.rangeCount && !selection.isCollapsed) { return true }
                if (!this.deviceIsIOS4) {
                    if (touch.identifier === this.lastTouchIdentifier) { event.preventDefault(); return false }
                    this.lastTouchIdentifier = touch.identifier;
                    this.updateScrollParent(targetElement)
                }
            }
            this.trackingClick = true;
            this.trackingClickStart = event.timeStamp;
            this.targetElement = targetElement;
            this.touchStartX = touch.pageX;
            this.touchStartY = touch.pageY;
            if (event.timeStamp - this.lastClickTime < 200) { event.preventDefault() }
            return true
        };
        FastClick.prototype.touchHasMoved = function(event) {
            "use strict";
            var touch = event.changedTouches[0],
                boundary = this.touchBoundary;
            if (Math.abs(touch.pageX - this.touchStartX) > boundary || Math.abs(touch.pageY - this.touchStartY) > boundary) { return true }
            return false
        };
        FastClick.prototype.onTouchMove = function(event) {
            "use strict";
            if (!this.trackingClick) { return true }
            if (this.targetElement !== this.getTargetElementFromEventTarget(event.target) || this.touchHasMoved(event)) {
                this.trackingClick = false;
                this.targetElement = null
            }
            return true
        };
        FastClick.prototype.findControl = function(labelElement) { "use strict"; if (labelElement.control !== undefined) { return labelElement.control } if (labelElement.htmlFor) { return document.getElementById(labelElement.htmlFor) } return labelElement.querySelector("button, input:not([type=hidden]), keygen, meter, output, progress, select, textarea") };
        FastClick.prototype.onTouchEnd = function(event) {
            "use strict";
            var forElement, trackingClickStart, targetTagName, scrollParent, touch, targetElement = this.targetElement;
            if (!this.trackingClick) { return true }
            if (event.timeStamp - this.lastClickTime < 200) { this.cancelNextClick = true; return true }
            this.cancelNextClick = false;
            this.lastClickTime = event.timeStamp;
            trackingClickStart = this.trackingClickStart;
            this.trackingClick = false;
            this.trackingClickStart = 0;
            if (this.deviceIsIOSWithBadTarget) {
                touch = event.changedTouches[0];
                targetElement = document.elementFromPoint(touch.pageX - window.pageXOffset, touch.pageY - window.pageYOffset) || targetElement;
                targetElement.fastClickScrollParent = this.targetElement.fastClickScrollParent
            }
            targetTagName = targetElement.tagName.toLowerCase();
            if (targetTagName === "label") {
                forElement = this.findControl(targetElement);
                if (forElement) {
                    this.focus(targetElement);
                    if (this.deviceIsAndroid) { return false }
                    targetElement = forElement
                }
            } else if (this.needsFocus(targetElement)) {
                if (event.timeStamp - trackingClickStart > 100 || this.deviceIsIOS && window.top !== window && targetTagName === "input") { this.targetElement = null; return false }
                this.focus(targetElement);
                if (!this.deviceIsIOS4 || targetTagName !== "select") {
                    this.targetElement = null;
                    event.preventDefault()
                }
                return false
            }
            if (this.deviceIsIOS && !this.deviceIsIOS4) { scrollParent = targetElement.fastClickScrollParent; if (scrollParent && scrollParent.fastClickLastScrollTop !== scrollParent.scrollTop) { return true } }
            if (!this.needsClick(targetElement)) {
                event.preventDefault();
                this.sendClick(targetElement, event)
            }
            return false
        };
        FastClick.prototype.onTouchCancel = function() {
            "use strict";
            this.trackingClick = false;
            this.targetElement = null
        };
        FastClick.prototype.onMouse = function(event) {
            "use strict";
            if (!this.targetElement) { return true }
            if (event.forwardedTouchEvent) { return true }
            if (!event.cancelable) { return true }
            if (!this.needsClick(this.targetElement) || this.cancelNextClick) {
                if (event.stopImmediatePropagation) { event.stopImmediatePropagation() } else { event.propagationStopped = true }
                event.stopPropagation();
                event.preventDefault();
                return false
            }
            return true
        };
        FastClick.prototype.onClick = function(event) {
            "use strict";
            var permitted;
            if (this.trackingClick) {
                this.targetElement = null;
                this.trackingClick = false;
                return true
            }
            if (event.target.type === "submit" && event.detail === 0) { return true }
            permitted = this.onMouse(event);
            if (!permitted) { this.targetElement = null }
            return permitted
        };
        FastClick.prototype.destroy = function() {
            "use strict";
            var layer = this.layer;
            if (this.deviceIsAndroid) {
                layer.removeEventListener("mouseover", this.onMouse, true);
                layer.removeEventListener("mousedown", this.onMouse, true);
                layer.removeEventListener("mouseup", this.onMouse, true)
            }
            layer.removeEventListener("click", this.onClick, true);
            layer.removeEventListener("touchstart", this.onTouchStart, false);
            layer.removeEventListener("touchmove", this.onTouchMove, false);
            layer.removeEventListener("touchend", this.onTouchEnd, false);
            layer.removeEventListener("touchcancel", this.onTouchCancel, false)
        };
        FastClick.notNeeded = function(layer) {
            "use strict";
            var metaViewport;
            var chromeVersion;
            if (typeof window.ontouchstart === "undefined") { return true }
            chromeVersion = +(/Chrome\/([0-9]+)/.exec(navigator.userAgent) || [, 0])[1];
            if (chromeVersion) { if (FastClick.prototype.deviceIsAndroid) { metaViewport = document.querySelector("meta[name=viewport]"); if (metaViewport) { if (metaViewport.content.indexOf("user-scalable=no") !== -1) { return true } if (chromeVersion > 31 && window.innerWidth <= window.screen.width) { return true } } } else { return true } }
            if (layer.style.msTouchAction === "none") { return true }
            return false
        };
        FastClick.attach = function(layer) { "use strict"; return new FastClick(layer) };
        if (typeof define !== "undefined" && define.amd) { define(function() { "use strict"; return FastClick }) } else if (typeof module !== "undefined" && module.exports) {
            module.exports = FastClick.attach;
            module.exports.FastClick = FastClick
        } else { window.FastClick = FastClick }
    });
    require.register("component~indexof@0.0.3", function(exports, 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@1.2.1", function(exports, module) {
        var index = require("component~indexof@0.0.3");
        var re = /\s+/;
        var toString = Object.prototype.toString;
        module.exports = function(el) { return new ClassList(el) };

        function ClassList(el) {
            if (!el) throw new Error("A DOM element reference is required");
            this.el = el;
            this.list = el.classList
        }
        ClassList.prototype.add = function(name) {
            if (this.list) { this.list.add(name); return this }
            var arr = this.array();
            var i = index(arr, name);
            if (!~i) arr.push(name);
            this.el.className = arr.join(" ");
            return this
        };
        ClassList.prototype.remove = function(name) {
            if ("[object RegExp]" == toString.call(name)) { return this.removeMatching(name) }
            if (this.list) { this.list.remove(name); return this }
            var arr = this.array();
            var i = index(arr, name);
            if (~i) arr.splice(i, 1);
            this.el.className = arr.join(" ");
            return this
        };
        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 };
        ClassList.prototype.toggle = function(name, force) { if (this.list) { if ("undefined" !== typeof force) { if (force !== this.list.toggle(name, force)) { this.list.toggle(name) } } else { this.list.toggle(name) } return this } 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 };
        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 };
        ClassList.prototype.has = ClassList.prototype.contains = function(name) { return this.list ? this.list.contains(name) : !!~index(this.array(), name) }
    });
    require.register("component~event@0.1.4", function(exports, module) {
        var bind = window.addEventListener ? "addEventListener" : "attachEvent",
            unbind = window.removeEventListener ? "removeEventListener" : "detachEvent",
            prefix = bind !== "addEventListener" ? "on" : "";
        exports.bind = function(el, type, fn, capture) { el[bind](prefix + type, fn, capture || false); return fn };
        exports.unbind = function(el, type, fn, capture) { el[unbind](prefix + type, fn, capture || false); return fn }
    });
    require.register("component~query@0.0.3", function(exports, 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@0.1.5", function(exports, module) {
        var query = require("component~query@0.0.3");
        var proto = Element.prototype;
        var vendor = proto.matches || proto.webkitMatchesSelector || proto.mozMatchesSelector || proto.msMatchesSelector || proto.oMatchesSelector;
        module.exports = match;

        function match(el, selector) { if (!el || el.nodeType !== 1) return false; 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("component~closest@0.1.4", function(exports, module) {
        var matches = require("component~matches-selector@0.1.5");
        module.exports = function(element, selector, checkYoSelf, root) {
            element = checkYoSelf ? { parentNode: element } : element;
            root = root || document;
            while ((element = element.parentNode) && element !== document) { if (matches(element, selector)) return element; if (element === root) return }
        }
    });
    require.register("component~delegate@0.2.3", function(exports, module) {
        var closest = require("component~closest@0.1.4"),
            event = require("component~event@0.1.4");
        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)
        };
        exports.unbind = function(el, type, fn, capture) { event.unbind(el, type, fn, capture) }
    });
    require.register("component~events@1.0.9", function(exports, module) {
        var events = require("component~event@0.1.4");
        var delegate = require("component~delegate@0.2.3");
        module.exports = Events;

        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 = {}
        }
        Events.prototype.sub = function(event, method, cb) {
            this._events[event] = this._events[event] || {};
            this._events[event][method] = cb
        };
        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);

            function cb() {
                var a = [].slice.call(arguments).concat(args);
                obj[method].apply(obj, a)
            }
            if (e.selector) { cb = delegate.bind(el, e.selector, name, cb) } else { events.bind(el, name, cb) }
            this.sub(name, method, cb);
            return cb
        };
        Events.prototype.unbind = function(event, method) {
            if (0 == arguments.length) return this.unbindAll();
            if (1 == arguments.length) return this.unbindAllOf(event);
            var bindings = this._events[event];
            if (!bindings) return;
            var cb = bindings[method];
            if (!cb) return;
            events.unbind(this.el, event, cb)
        };
        Events.prototype.unbindAll = function() { for (var event in this._events) { this.unbindAllOf(event) } };
        Events.prototype.unbindAllOf = function(event) { var bindings = this._events[event]; if (!bindings) return; for (var method in bindings) { this.unbind(event, method) } };

        function parse(event) { var parts = event.split(/ +/); return { name: parts.shift(), selector: parts.join(" ") } }
    });
    require.register("switchery", function(exports, module) {
        var transitionize = require("abpetkov~transitionize@0.0.3"),
            fastclick = require("ftlabs~fastclick@v0.6.11"),
            classes = require("component~classes@1.2.1"),
            events = require("component~events@1.0.9");
        module.exports = Switchery;
        var defaults = { color: "#64bd63", secondaryColor: "#dfdfdf", jackColor: "#fff", jackSecondaryColor: null, className: "switchery", disabled: false, disabledOpacity: .5, speed: "0.4s", size: "default" };

        function Switchery(element, options) {
            if (!(this instanceof Switchery)) return new Switchery(element, options);
            this.element = element;
            this.options = options || {};
            for (var i in defaults) { if (this.options[i] == null) { this.options[i] = defaults[i] } }
            if (this.element != null && this.element.type == "checkbox") this.init();
            if (this.isDisabled() === true) this.disable()
        }
        Switchery.prototype.hide = function() { this.element.style.display = "none" };
        Switchery.prototype.show = function() {
            var switcher = this.create();
            this.insertAfter(this.element, switcher)
        };
        Switchery.prototype.create = function() {
            this.switcher = document.createElement("span");
            this.jack = document.createElement("small");
            this.switcher.appendChild(this.jack);
            this.switcher.className = this.options.className;
            this.events = events(this.switcher, this);
            return this.switcher
        };
        Switchery.prototype.insertAfter = function(reference, target) { reference.parentNode.insertBefore(target, reference.nextSibling) };
        Switchery.prototype.setPosition = function(clicked) {
            var checked = this.isChecked(),
                switcher = this.switcher,
                jack = this.jack;
            if (clicked && checked) checked = false;
            else if (clicked && !checked) checked = true;
            if (checked === true) {
                this.element.checked = true;
                if (window.getComputedStyle) jack.style.left = parseInt(window.getComputedStyle(switcher).width) - parseInt(window.getComputedStyle(jack).width) + "px";
                else jack.style.left = parseInt(switcher.currentStyle["width"]) - parseInt(jack.currentStyle["width"]) + "px";
                if (this.options.color) this.colorize();
                this.setSpeed()
            } else {
                jack.style.left = 0;
                this.element.checked = false;
                this.switcher.style.boxShadow = "inset 0 0 0 0 " + this.options.secondaryColor;
                this.switcher.style.borderColor = this.options.secondaryColor;
                this.switcher.style.backgroundColor = this.options.secondaryColor !== defaults.secondaryColor ? this.options.secondaryColor : "#fff";
                this.jack.style.backgroundColor = this.options.jackSecondaryColor !== this.options.jackColor ? this.options.jackSecondaryColor : this.options.jackColor;
                this.setSpeed()
            }
        };
        Switchery.prototype.setSpeed = function() {
            var switcherProp = {},
                jackProp = { "background-color": this.options.speed, left: this.options.speed.replace(/[a-z]/, "") / 2 + "s" };
            if (this.isChecked()) { switcherProp = { border: this.options.speed, "box-shadow": this.options.speed, "background-color": this.options.speed.replace(/[a-z]/, "") * 3 + "s" } } else { switcherProp = { border: this.options.speed, "box-shadow": this.options.speed } }
            transitionize(this.switcher, switcherProp);
            transitionize(this.jack, jackProp)
        };
        Switchery.prototype.setSize = function() {
            var small = "switchery-small",
                normal = "switchery-default",
                large = "switchery-large";
            switch (this.options.size) {
                case "small":
                    classes(this.switcher).add(small);
                    break;
                case "large":
                    classes(this.switcher).add(large);
                    break;
                default:
                    classes(this.switcher).add(normal);
                    break
            }
        };
        Switchery.prototype.colorize = function() {
            var switcherHeight = this.switcher.offsetHeight / 2;
            this.switcher.style.backgroundColor = this.options.color;
            this.switcher.style.borderColor = this.options.color;
            this.switcher.style.boxShadow = "inset 0 0 0 " + switcherHeight + "px " + this.options.color;
            this.jack.style.backgroundColor = this.options.jackColor
        };
        Switchery.prototype.handleOnchange = function(state) {
            if (document.dispatchEvent) {
                var event = document.createEvent("HTMLEvents");
                event.initEvent("change", true, true);
                this.element.dispatchEvent(event)
            } else { this.element.fireEvent("onchange") }
        };
        Switchery.prototype.handleChange = function() {
            var self = this,
                el = this.element;
            if (el.addEventListener) { el.addEventListener("change", function() { self.setPosition() }) } else { el.attachEvent("onchange", function() { self.setPosition() }) }
        };
        Switchery.prototype.handleClick = function() {
            var switcher = this.switcher;
            fastclick(switcher);
            this.events.bind("click", "bindClick")
        };
        Switchery.prototype.bindClick = function() {
            var parent = this.element.parentNode.tagName.toLowerCase(),
                labelParent = parent === "label" ? false : true;
            this.setPosition(labelParent);
            this.handleOnchange(this.element.checked)
        };
        Switchery.prototype.markAsSwitched = function() { this.element.setAttribute("data-switchery", true) };
        Switchery.prototype.markedAsSwitched = function() { return this.element.getAttribute("data-switchery") };
        Switchery.prototype.init = function() {
            this.hide();
            this.show();
            this.setSize();
            this.setPosition();
            this.markAsSwitched();
            this.handleChange();
            this.handleClick()
        };
        Switchery.prototype.isChecked = function() { return this.element.checked };
        Switchery.prototype.isDisabled = function() { return this.options.disabled || this.element.disabled || this.element.readOnly };
        Switchery.prototype.destroy = function() { this.events.unbind() };
        Switchery.prototype.enable = function() {
            if (!this.options.disabled) return;
            if (this.options.disabled) this.options.disabled = false;
            if (this.element.disabled) this.element.disabled = false;
            if (this.element.readOnly) this.element.readOnly = false;
            this.switcher.style.opacity = 1;
            this.events.bind("click", "bindClick")
        };
        Switchery.prototype.disable = function() {
            if (this.options.disabled) return;
            if (!this.options.disabled) this.options.disabled = true;
            if (!this.element.disabled) this.element.disabled = true;
            if (!this.element.readOnly) this.element.readOnly = true;
            this.switcher.style.opacity = this.options.disabledOpacity;
            this.destroy()
        }
    });
    if (typeof exports == "object") { module.exports = require("switchery") } else if (typeof define == "function" && define.amd) { define("Switchery", [], function() { return require("switchery") }) } else {
        (this || window)["Switchery"] = require("switchery")
    }
})();

Zerion Mini Shell 1.0