MASTER

SAVING...

BERHASIL DIUBAH!

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