Initial commit

bower_components/what-input/polyfills/ie8/EventListener.js

@@ -0,0 +1,150 @@
+// EventListener | CC0 | github.com/jonathantneal/EventListener
+
+this.Element && Element.prototype.attachEvent && !Element.prototype.addEventListener && (function () {
+	function addToPrototype(name, method) {
+		Window.prototype[name] = HTMLDocument.prototype[name] = Element.prototype[name] = method;
+	}
+
+	// add
+	addToPrototype("addEventListener", function (type, listener) {
+		var
+		target = this,
+		listeners = target.addEventListener.listeners = target.addEventListener.listeners || {},
+		typeListeners = listeners[type] = listeners[type] || [];
+
+		// if no events exist, attach the listener
+		if (!typeListeners.length) {
+			target.attachEvent("on" + type, typeListeners.event = function (event) {
+				var documentElement = target.document && target.document.documentElement || target.documentElement || { scrollLeft: 0, scrollTop: 0 };
+
+				// polyfill w3c properties and methods
+				event.currentTarget = target;
+				event.pageX = event.clientX + documentElement.scrollLeft;
+				event.pageY = event.clientY + documentElement.scrollTop;
+				event.preventDefault = function () { event.returnValue = false };
+				event.relatedTarget = event.fromElement || null;
+				event.stopImmediatePropagation = function () { immediatePropagation = false; event.cancelBubble = true };
+				event.stopPropagation = function () { event.cancelBubble = true };
+				event.target = event.srcElement || target;
+				event.timeStamp = +new Date;
+
+				var plainEvt = {};
+				for (var i in event) {
+					plainEvt[i] = event[i];
+				}
+
+				// create an cached list of the master events list (to protect this loop from breaking when an event is removed)
+				for (var i = 0, typeListenersCache = [].concat(typeListeners), typeListenerCache, immediatePropagation = true; immediatePropagation && (typeListenerCache = typeListenersCache[i]); ++i) {
+					// check to see if the cached event still exists in the master events list
+					for (var ii = 0, typeListener; typeListener = typeListeners[ii]; ++ii) {
+						if (typeListener == typeListenerCache) {
+							typeListener.call(target, plainEvt);
+
+							break;
+						}
+					}
+				}
+			});
+		}
+
+		// add the event to the master event list
+		typeListeners.push(listener);
+	});
+
+	// remove
+	addToPrototype("removeEventListener", function (type, listener) {
+		var
+		target = this,
+		listeners = target.addEventListener.listeners = target.addEventListener.listeners || {},
+		typeListeners = listeners[type] = listeners[type] || [];
+
+		// remove the newest matching event from the master event list
+		for (var i = typeListeners.length - 1, typeListener; typeListener = typeListeners[i]; --i) {
+			if (typeListener == listener) {
+				typeListeners.splice(i, 1);
+
+				break;
+			}
+		}
+
+		// if no events exist, detach the listener
+		if (!typeListeners.length && typeListeners.event) {
+			target.detachEvent("on" + type, typeListeners.event);
+		}
+	});
+
+	// dispatch
+	addToPrototype("dispatchEvent", function (eventObject) {
+		var
+		target = this,
+		type = eventObject.type,
+		listeners = target.addEventListener.listeners = target.addEventListener.listeners || {},
+		typeListeners = listeners[type] = listeners[type] || [];
+
+		try {
+			return target.fireEvent("on" + type, eventObject);
+		} catch (error) {
+			if (typeListeners.event) {
+				typeListeners.event(eventObject);
+			}
+
+			return;
+		}
+	});
+
+	// CustomEvent
+	Object.defineProperty(Window.prototype, "CustomEvent", {
+		get: function () {
+			var self = this;
+
+			return function CustomEvent(type, eventInitDict) {
+				var event = self.document.createEventObject(), key;
+
+				event.type = type;
+				for (key in eventInitDict) {
+					if (key == 'cancelable'){
+						event.returnValue = !eventInitDict.cancelable;
+					} else if (key == 'bubbles'){
+						event.cancelBubble = !eventInitDict.bubbles;
+					} else if (key == 'detail'){
+						event.detail = eventInitDict.detail;
+					}
+				}
+				return event;
+			};
+		}
+	});
+
+	// ready
+	function ready(event) {
+		if (ready.interval && document.body) {
+			ready.interval = clearInterval(ready.interval);
+
+			document.dispatchEvent(new CustomEvent("DOMContentLoaded"));
+		}
+	}
+
+	ready.interval = setInterval(ready, 1);
+
+	window.addEventListener("load", ready);
+})();
+
+(!this.CustomEvent || typeof this.CustomEvent === "object") && (function() {
+	// CustomEvent for browsers which don't natively support the Constructor method
+	this.CustomEvent = function CustomEvent(type, eventInitDict) {
+		var event;
+		eventInitDict = eventInitDict || {bubbles: false, cancelable: false, detail: undefined};
+
+		try {
+			event = document.createEvent('CustomEvent');
+			event.initCustomEvent(type, eventInitDict.bubbles, eventInitDict.cancelable, eventInitDict.detail);
+		} catch (error) {
+			// for browsers which don't support CustomEvent at all, we use a regular event instead
+			event = document.createEvent('Event');
+			event.initEvent(type, eventInitDict.bubbles, eventInitDict.cancelable);
+			event.detail = eventInitDict.detail;
+		}
+
+		return event;
+	};
+})();

bower_components/what-input/polyfills/ie8/indexOf.js

@@ -0,0 +1,65 @@
+// Production steps of ECMA-262, Edition 5, 15.4.4.14
+// Reference: http://es5.github.io/#x15.4.4.14
+if (!Array.prototype.indexOf) {
+  Array.prototype.indexOf = function(searchElement, fromIndex) {
+
+    var k;
+
+    // 1. Let O be the result of calling ToObject passing
+    //    the this value as the argument.
+    if (this == null) {
+      throw new TypeError('"this" is null or not defined');
+    }
+
+    var O = Object(this);
+
+    // 2. Let lenValue be the result of calling the Get
+    //    internal method of O with the argument "length".
+    // 3. Let len be ToUint32(lenValue).
+    var len = O.length >>> 0;
+
+    // 4. If len is 0, return -1.
+    if (len === 0) {
+      return -1;
+    }
+
+    // 5. If argument fromIndex was passed let n be
+    //    ToInteger(fromIndex); else let n be 0.
+    var n = +fromIndex || 0;
+
+    if (Math.abs(n) === Infinity) {
+      n = 0;
+    }
+
+    // 6. If n >= len, return -1.
+    if (n >= len) {
+      return -1;
+    }
+
+    // 7. If n >= 0, then Let k be n.
+    // 8. Else, n<0, Let k be len - abs(n).
+    //    If k is less than 0, then let k be 0.
+    k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
+
+    // 9. Repeat, while k < len
+    while (k < len) {
+      // a. Let Pk be ToString(k).
+      //   This is implicit for LHS operands of the in operator
+      // b. Let kPresent be the result of calling the
+      //    HasProperty internal method of O with argument Pk.
+      //   This step can be combined with c
+      // c. If kPresent is true, then
+      //    i.  Let elementK be the result of calling the Get
+      //        internal method of O with the argument ToString(k).
+      //   ii.  Let same be the result of applying the
+      //        Strict Equality Comparison Algorithm to
+      //        searchElement and elementK.
+      //  iii.  If same is true, return k.
+      if (k in O && O[k] === searchElement) {
+        return k;
+      }
+      k++;
+    }
+    return -1;
+  };
+}