mirror of
https://github.com/CHOMPStation2/CHOMPStation2.git
synced 2025-12-15 20:52:41 +00:00
774 lines
24 KiB
JavaScript
774 lines
24 KiB
JavaScript
/**
|
|
* @file
|
|
* @copyright 2013 Andrea Giammarchi, WebReflection
|
|
* @license MIT
|
|
*/
|
|
|
|
/* eslint-disable */
|
|
(function (window) {
|
|
/*! (C) WebReflection Mit Style License */
|
|
if (document.createEvent) return;
|
|
var DUNNOABOUTDOMLOADED = true,
|
|
READYEVENTDISPATCHED = false,
|
|
ONREADYSTATECHANGE = 'onreadystatechange',
|
|
DOMCONTENTLOADED = 'DOMContentLoaded',
|
|
SECRET = '__IE8__' + Math.random(),
|
|
// Object = window.Object,
|
|
defineProperty =
|
|
Object.defineProperty ||
|
|
// just in case ...
|
|
function (object, property, descriptor) {
|
|
object[property] = descriptor.value;
|
|
},
|
|
defineProperties =
|
|
Object.defineProperties ||
|
|
// IE8 implemented defineProperty but not the plural...
|
|
function (object, descriptors) {
|
|
for (var key in descriptors) {
|
|
if (hasOwnProperty.call(descriptors, key)) {
|
|
try {
|
|
defineProperty(object, key, descriptors[key]);
|
|
} catch (o_O) {
|
|
if (window.console) {
|
|
console.log(key + ' failed on object:', object, o_O.message);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor,
|
|
hasOwnProperty = Object.prototype.hasOwnProperty,
|
|
// here IE7 will break like a charm
|
|
ElementPrototype = window.Element.prototype,
|
|
TextPrototype = window.Text.prototype,
|
|
// none of above native constructors exist/are exposed
|
|
possiblyNativeEvent = /^[a-z]+$/,
|
|
// ^ actually could probably be just /^[a-z]+$/
|
|
readyStateOK = /loaded|complete/,
|
|
types = {},
|
|
div = document.createElement('div'),
|
|
html = document.documentElement,
|
|
removeAttribute = html.removeAttribute,
|
|
setAttribute = html.setAttribute,
|
|
valueDesc = function (value) {
|
|
return {
|
|
enumerable: true,
|
|
writable: true,
|
|
configurable: true,
|
|
value: value,
|
|
};
|
|
};
|
|
function commonEventLoop(currentTarget, e, $handlers, synthetic) {
|
|
for (
|
|
var handler,
|
|
continuePropagation,
|
|
handlers = $handlers.slice(),
|
|
evt = enrich(e, currentTarget),
|
|
i = 0,
|
|
length = handlers.length;
|
|
i < length;
|
|
i++
|
|
) {
|
|
handler = handlers[i];
|
|
if (typeof handler === 'object') {
|
|
if (typeof handler.handleEvent === 'function') {
|
|
handler.handleEvent(evt);
|
|
}
|
|
} else {
|
|
handler.call(currentTarget, evt);
|
|
}
|
|
if (evt.stoppedImmediatePropagation) break;
|
|
}
|
|
continuePropagation = !evt.stoppedPropagation;
|
|
/*
|
|
if (continuePropagation && !synthetic && !live(currentTarget)) {
|
|
evt.cancelBubble = true;
|
|
}
|
|
*/
|
|
return synthetic && continuePropagation && currentTarget.parentNode
|
|
? currentTarget.parentNode.dispatchEvent(evt)
|
|
: !evt.defaultPrevented;
|
|
}
|
|
|
|
function commonDescriptor(get, set) {
|
|
return {
|
|
// if you try with enumerable: true
|
|
// IE8 will miserably fail
|
|
configurable: true,
|
|
get: get,
|
|
set: set,
|
|
};
|
|
}
|
|
|
|
function commonTextContent(protoDest, protoSource, property) {
|
|
var descriptor = getOwnPropertyDescriptor(protoSource || protoDest, property);
|
|
defineProperty(
|
|
protoDest,
|
|
'textContent',
|
|
commonDescriptor(
|
|
function () {
|
|
return descriptor.get.call(this);
|
|
},
|
|
function (textContent) {
|
|
descriptor.set.call(this, textContent);
|
|
}
|
|
)
|
|
);
|
|
}
|
|
|
|
function enrich(e, currentTarget) {
|
|
e.currentTarget = currentTarget;
|
|
e.eventPhase =
|
|
// AT_TARGET : BUBBLING_PHASE
|
|
e.target === e.currentTarget ? 2 : 3;
|
|
return e;
|
|
}
|
|
|
|
function find(array, value) {
|
|
var i = array.length;
|
|
while (i-- && array[i] !== value);
|
|
return i;
|
|
}
|
|
|
|
function getTextContent() {
|
|
if (this.tagName === 'BR') return '\n';
|
|
var textNode = this.firstChild,
|
|
arrayContent = [];
|
|
while (textNode) {
|
|
if (textNode.nodeType !== 8 && textNode.nodeType !== 7) {
|
|
arrayContent.push(textNode.textContent);
|
|
}
|
|
textNode = textNode.nextSibling;
|
|
}
|
|
return arrayContent.join('');
|
|
}
|
|
|
|
function live(self) {
|
|
return self.nodeType !== 9 && html.contains(self);
|
|
}
|
|
|
|
function onkeyup(e) {
|
|
var evt = document.createEvent('Event');
|
|
evt.initEvent('input', true, true);
|
|
(e.srcElement || e.fromElement || document).dispatchEvent(evt);
|
|
}
|
|
|
|
function onReadyState(e) {
|
|
if (!READYEVENTDISPATCHED && readyStateOK.test(document.readyState)) {
|
|
READYEVENTDISPATCHED = !READYEVENTDISPATCHED;
|
|
document.detachEvent(ONREADYSTATECHANGE, onReadyState);
|
|
e = document.createEvent('Event');
|
|
e.initEvent(DOMCONTENTLOADED, true, true);
|
|
document.dispatchEvent(e);
|
|
}
|
|
}
|
|
|
|
function getter(attr) {
|
|
return function () {
|
|
return html[attr] || (document.body && document.body[attr]) || 0;
|
|
};
|
|
}
|
|
|
|
function setTextContent(textContent) {
|
|
var node;
|
|
while ((node = this.lastChild)) {
|
|
this.removeChild(node);
|
|
}
|
|
/*jshint eqnull:true */
|
|
if (textContent != null) {
|
|
this.appendChild(document.createTextNode(textContent));
|
|
}
|
|
}
|
|
|
|
function verify(self, e) {
|
|
if (!e) {
|
|
e = window.event;
|
|
}
|
|
if (!e.target) {
|
|
e.target = e.srcElement || e.fromElement || document;
|
|
}
|
|
if (!e.timeStamp) {
|
|
e.timeStamp = new Date().getTime();
|
|
}
|
|
return e;
|
|
}
|
|
|
|
// normalized textContent for:
|
|
// comment, script, style, text, title
|
|
commonTextContent(window.HTMLCommentElement.prototype, ElementPrototype, 'nodeValue');
|
|
|
|
commonTextContent(window.HTMLScriptElement.prototype, null, 'text');
|
|
|
|
commonTextContent(TextPrototype, null, 'nodeValue');
|
|
|
|
commonTextContent(window.HTMLTitleElement.prototype, null, 'text');
|
|
|
|
defineProperty(
|
|
window.HTMLStyleElement.prototype,
|
|
'textContent',
|
|
(function (descriptor) {
|
|
return commonDescriptor(
|
|
function () {
|
|
return descriptor.get.call(this.styleSheet);
|
|
},
|
|
function (textContent) {
|
|
descriptor.set.call(this.styleSheet, textContent);
|
|
}
|
|
);
|
|
})(getOwnPropertyDescriptor(window.CSSStyleSheet.prototype, 'cssText'))
|
|
);
|
|
|
|
var opacityre = /\b\s*alpha\s*\(\s*opacity\s*=\s*(\d+)\s*\)/;
|
|
defineProperty(window.CSSStyleDeclaration.prototype, 'opacity', {
|
|
get: function () {
|
|
var m = this.filter.match(opacityre);
|
|
return m ? (m[1] / 100).toString() : '';
|
|
},
|
|
set: function (value) {
|
|
this.zoom = 1;
|
|
var found = false;
|
|
if (value < 1) {
|
|
value = ' alpha(opacity=' + Math.round(value * 100) + ')';
|
|
} else {
|
|
value = '';
|
|
}
|
|
this.filter = this.filter.replace(opacityre, function () {
|
|
found = true;
|
|
return value;
|
|
});
|
|
if (!found && value) {
|
|
this.filter += value;
|
|
}
|
|
},
|
|
});
|
|
|
|
defineProperties(ElementPrototype, {
|
|
// bonus
|
|
textContent: {
|
|
get: getTextContent,
|
|
set: setTextContent,
|
|
},
|
|
// http://www.w3.org/TR/ElementTraversal/#interface-elementTraversal
|
|
firstElementChild: {
|
|
get: function () {
|
|
for (var childNodes = this.childNodes || [], i = 0, length = childNodes.length; i < length; i++) {
|
|
if (childNodes[i].nodeType == 1) return childNodes[i];
|
|
}
|
|
},
|
|
},
|
|
lastElementChild: {
|
|
get: function () {
|
|
for (var childNodes = this.childNodes || [], i = childNodes.length; i--; ) {
|
|
if (childNodes[i].nodeType == 1) return childNodes[i];
|
|
}
|
|
},
|
|
},
|
|
oninput: {
|
|
get: function () {
|
|
return this._oninput || null;
|
|
},
|
|
set: function (oninput) {
|
|
if (this._oninput) {
|
|
this.removeEventListener('input', this._oninput);
|
|
this._oninput = oninput;
|
|
if (oninput) {
|
|
this.addEventListener('input', oninput);
|
|
}
|
|
}
|
|
},
|
|
},
|
|
previousElementSibling: {
|
|
get: function () {
|
|
var previousElementSibling = this.previousSibling;
|
|
while (previousElementSibling && previousElementSibling.nodeType != 1) {
|
|
previousElementSibling = previousElementSibling.previousSibling;
|
|
}
|
|
return previousElementSibling;
|
|
},
|
|
},
|
|
nextElementSibling: {
|
|
get: function () {
|
|
var nextElementSibling = this.nextSibling;
|
|
while (nextElementSibling && nextElementSibling.nodeType != 1) {
|
|
nextElementSibling = nextElementSibling.nextSibling;
|
|
}
|
|
return nextElementSibling;
|
|
},
|
|
},
|
|
childElementCount: {
|
|
get: function () {
|
|
for (
|
|
var count = 0, childNodes = this.childNodes || [], i = childNodes.length;
|
|
i--;
|
|
count += childNodes[i].nodeType == 1
|
|
);
|
|
return count;
|
|
},
|
|
},
|
|
/*
|
|
// children would be an override
|
|
// IE8 already supports them but with comments too
|
|
// not just nodeType 1
|
|
children: {
|
|
get: function () {
|
|
for(var
|
|
children = [],
|
|
childNodes = this.childNodes || [],
|
|
i = 0, length = childNodes.length;
|
|
i < length; i++
|
|
) {
|
|
if (childNodes[i].nodeType == 1) {
|
|
children.push(childNodes[i]);
|
|
}
|
|
}
|
|
return children;
|
|
}
|
|
},
|
|
*/
|
|
// DOM Level 2 EventTarget methods and events
|
|
addEventListener: valueDesc(function (type, handler, capture) {
|
|
if (typeof handler !== 'function' && typeof handler !== 'object') return;
|
|
var self = this,
|
|
ontype = 'on' + type,
|
|
temple = self[SECRET] || defineProperty(self, SECRET, { value: {} })[SECRET],
|
|
currentType = temple[ontype] || (temple[ontype] = {}),
|
|
handlers = currentType.h || (currentType.h = []),
|
|
e,
|
|
attr;
|
|
if (!hasOwnProperty.call(currentType, 'w')) {
|
|
currentType.w = function (e) {
|
|
// e[SECRET] is a silent notification needed to avoid
|
|
// fired events during live test
|
|
return e[SECRET] || commonEventLoop(self, verify(self, e), handlers, false);
|
|
};
|
|
// if not detected yet
|
|
if (!hasOwnProperty.call(types, ontype)) {
|
|
// and potentially a native event
|
|
if (possiblyNativeEvent.test(type)) {
|
|
// do this heavy thing
|
|
try {
|
|
// TODO: should I consider tagName too so that
|
|
// INPUT[ontype] could be different ?
|
|
e = document.createEventObject();
|
|
// do not clone ever a node
|
|
// specially a document one ...
|
|
// use the secret to ignore them all
|
|
e[SECRET] = true;
|
|
// document a part if a node has never been
|
|
// added to any other node, fireEvent might
|
|
// behave very weirdly (read: trigger unspecified errors)
|
|
if (self.nodeType != 9) {
|
|
/*jshint eqnull:true */
|
|
if (self.parentNode == null) {
|
|
div.appendChild(self);
|
|
}
|
|
if ((attr = self.getAttribute(ontype))) {
|
|
removeAttribute.call(self, ontype);
|
|
}
|
|
}
|
|
self.fireEvent(ontype, e);
|
|
types[ontype] = true;
|
|
} catch (meh) {
|
|
types[ontype] = false;
|
|
while (div.hasChildNodes()) {
|
|
div.removeChild(div.firstChild);
|
|
}
|
|
}
|
|
if (attr != null) {
|
|
setAttribute.call(self, ontype, attr);
|
|
}
|
|
} else {
|
|
// no need to bother since
|
|
// 'x-event' ain't native for sure
|
|
types[ontype] = false;
|
|
}
|
|
}
|
|
if ((currentType.n = types[ontype])) {
|
|
self.attachEvent(ontype, currentType.w);
|
|
}
|
|
}
|
|
if (find(handlers, handler) < 0) {
|
|
handlers[capture ? 'unshift' : 'push'](handler);
|
|
}
|
|
if (type === 'input') {
|
|
self.attachEvent('onkeyup', onkeyup);
|
|
}
|
|
}),
|
|
dispatchEvent: valueDesc(function (e) {
|
|
var self = this,
|
|
ontype = 'on' + e.type,
|
|
temple = self[SECRET],
|
|
currentType = temple && temple[ontype],
|
|
valid = !!currentType,
|
|
parentNode;
|
|
if (!e.target) e.target = self;
|
|
return (
|
|
valid
|
|
? currentType.n /* && live(self) */
|
|
? self.fireEvent(ontype, e)
|
|
: commonEventLoop(self, e, currentType.h, true)
|
|
: (parentNode = self.parentNode) /* && live(self) */
|
|
? parentNode.dispatchEvent(e)
|
|
: true,
|
|
!e.defaultPrevented
|
|
);
|
|
}),
|
|
removeEventListener: valueDesc(function (type, handler, capture) {
|
|
if (typeof handler !== 'function' && typeof handler !== 'object') return;
|
|
var self = this,
|
|
ontype = 'on' + type,
|
|
temple = self[SECRET],
|
|
currentType = temple && temple[ontype],
|
|
handlers = currentType && currentType.h,
|
|
i = handlers ? find(handlers, handler) : -1;
|
|
if (-1 < i) handlers.splice(i, 1);
|
|
}),
|
|
});
|
|
|
|
/* this is not needed in IE8
|
|
defineProperties(window.HTMLSelectElement.prototype, {
|
|
value: {
|
|
get: function () {
|
|
return this.options[this.selectedIndex].value;
|
|
}
|
|
}
|
|
});
|
|
//*/
|
|
|
|
// EventTarget methods for Text nodes too
|
|
defineProperties(TextPrototype, {
|
|
addEventListener: valueDesc(ElementPrototype.addEventListener),
|
|
dispatchEvent: valueDesc(ElementPrototype.dispatchEvent),
|
|
removeEventListener: valueDesc(ElementPrototype.removeEventListener),
|
|
});
|
|
|
|
defineProperties(window.XMLHttpRequest.prototype, {
|
|
addEventListener: valueDesc(function (type, handler, capture) {
|
|
var self = this,
|
|
ontype = 'on' + type,
|
|
temple = self[SECRET] || defineProperty(self, SECRET, { value: {} })[SECRET],
|
|
currentType = temple[ontype] || (temple[ontype] = {}),
|
|
handlers = currentType.h || (currentType.h = []);
|
|
if (find(handlers, handler) < 0) {
|
|
if (!self[ontype]) {
|
|
self[ontype] = function () {
|
|
var e = document.createEvent('Event');
|
|
e.initEvent(type, true, true);
|
|
self.dispatchEvent(e);
|
|
};
|
|
}
|
|
handlers[capture ? 'unshift' : 'push'](handler);
|
|
}
|
|
}),
|
|
dispatchEvent: valueDesc(function (e) {
|
|
var self = this,
|
|
ontype = 'on' + e.type,
|
|
temple = self[SECRET],
|
|
currentType = temple && temple[ontype],
|
|
valid = !!currentType;
|
|
return (
|
|
valid &&
|
|
(currentType.n /* && live(self) */ ? self.fireEvent(ontype, e) : commonEventLoop(self, e, currentType.h, true))
|
|
);
|
|
}),
|
|
removeEventListener: valueDesc(ElementPrototype.removeEventListener),
|
|
});
|
|
|
|
var buttonGetter = getOwnPropertyDescriptor(Event.prototype, 'button').get;
|
|
defineProperties(window.Event.prototype, {
|
|
bubbles: valueDesc(true),
|
|
cancelable: valueDesc(true),
|
|
preventDefault: valueDesc(function () {
|
|
if (this.cancelable) {
|
|
this.returnValue = false;
|
|
}
|
|
}),
|
|
stopPropagation: valueDesc(function () {
|
|
this.stoppedPropagation = true;
|
|
this.cancelBubble = true;
|
|
}),
|
|
stopImmediatePropagation: valueDesc(function () {
|
|
this.stoppedImmediatePropagation = true;
|
|
this.stopPropagation();
|
|
}),
|
|
initEvent: valueDesc(function (type, bubbles, cancelable) {
|
|
this.type = type;
|
|
this.bubbles = !!bubbles;
|
|
this.cancelable = !!cancelable;
|
|
if (!this.bubbles) {
|
|
this.stopPropagation();
|
|
}
|
|
}),
|
|
pageX: {
|
|
get: function () {
|
|
return this._pageX || (this._pageX = this.clientX + window.scrollX - (html.clientLeft || 0));
|
|
},
|
|
},
|
|
pageY: {
|
|
get: function () {
|
|
return this._pageY || (this._pageY = this.clientY + window.scrollY - (html.clientTop || 0));
|
|
},
|
|
},
|
|
which: {
|
|
get: function () {
|
|
return this.keyCode ? this.keyCode : isNaN(this.button) ? undefined : this.button + 1;
|
|
},
|
|
},
|
|
charCode: {
|
|
get: function () {
|
|
return this.keyCode && this.type == 'keypress' ? this.keyCode : 0;
|
|
},
|
|
},
|
|
buttons: {
|
|
get: function () {
|
|
return buttonGetter.call(this);
|
|
},
|
|
},
|
|
button: {
|
|
get: function () {
|
|
var buttons = this.buttons;
|
|
return buttons & 1 ? 0 : buttons & 2 ? 2 : buttons & 4 ? 1 : undefined;
|
|
},
|
|
},
|
|
defaultPrevented: {
|
|
get: function () {
|
|
// if preventDefault() was never called, or returnValue not given a value
|
|
// then returnValue is undefined
|
|
var returnValue = this.returnValue,
|
|
undef;
|
|
return !(returnValue === undef || returnValue);
|
|
},
|
|
},
|
|
relatedTarget: {
|
|
get: function () {
|
|
var type = this.type;
|
|
if (type === 'mouseover') {
|
|
return this.fromElement;
|
|
} else if (type === 'mouseout') {
|
|
return this.toElement;
|
|
} else {
|
|
return null;
|
|
}
|
|
},
|
|
},
|
|
});
|
|
|
|
defineProperties(window.HTMLDocument.prototype, {
|
|
defaultView: {
|
|
get: function () {
|
|
return this.parentWindow;
|
|
},
|
|
},
|
|
textContent: {
|
|
get: function () {
|
|
return this.nodeType === 11 ? getTextContent.call(this) : null;
|
|
},
|
|
set: function (textContent) {
|
|
if (this.nodeType === 11) {
|
|
setTextContent.call(this, textContent);
|
|
}
|
|
},
|
|
},
|
|
addEventListener: valueDesc(function (type, handler, capture) {
|
|
var self = this;
|
|
ElementPrototype.addEventListener.call(self, type, handler, capture);
|
|
// NOTE: it won't fire if already loaded, this is NOT a $.ready() shim!
|
|
// this behaves just like standard browsers
|
|
if (DUNNOABOUTDOMLOADED && type === DOMCONTENTLOADED && !readyStateOK.test(self.readyState)) {
|
|
DUNNOABOUTDOMLOADED = false;
|
|
self.attachEvent(ONREADYSTATECHANGE, onReadyState);
|
|
/* global top */
|
|
if (window == top) {
|
|
(function gonna(e) {
|
|
try {
|
|
self.documentElement.doScroll('left');
|
|
onReadyState();
|
|
} catch (o_O) {
|
|
setTimeout(gonna, 50);
|
|
}
|
|
})();
|
|
}
|
|
}
|
|
}),
|
|
dispatchEvent: valueDesc(ElementPrototype.dispatchEvent),
|
|
removeEventListener: valueDesc(ElementPrototype.removeEventListener),
|
|
createEvent: valueDesc(function (Class) {
|
|
var e;
|
|
if (Class !== 'Event') throw new Error('unsupported ' + Class);
|
|
e = document.createEventObject();
|
|
e.timeStamp = new Date().getTime();
|
|
return e;
|
|
}),
|
|
});
|
|
|
|
defineProperties(window.Window.prototype, {
|
|
getComputedStyle: valueDesc(
|
|
(function () {
|
|
var // partially grabbed from jQuery and Dean's hack
|
|
notpixel = /^(?:[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|))(?!px)[a-z%]+$/,
|
|
position = /^(top|right|bottom|left)$/,
|
|
re = /\-([a-z])/g,
|
|
place = function (match, $1) {
|
|
return $1.toUpperCase();
|
|
};
|
|
function ComputedStyle(_) {
|
|
this._ = _;
|
|
}
|
|
|
|
ComputedStyle.prototype.getPropertyValue = function (name) {
|
|
var el = this._,
|
|
style = el.style,
|
|
currentStyle = el.currentStyle,
|
|
runtimeStyle = el.runtimeStyle,
|
|
result,
|
|
left,
|
|
rtLeft;
|
|
if (name == 'opacity') {
|
|
return style.opacity || '1';
|
|
}
|
|
name = (name === 'float' ? 'style-float' : name).replace(re, place);
|
|
result = currentStyle ? currentStyle[name] : style[name];
|
|
if (notpixel.test(result) && !position.test(name)) {
|
|
left = style.left;
|
|
rtLeft = runtimeStyle && runtimeStyle.left;
|
|
if (rtLeft) {
|
|
runtimeStyle.left = currentStyle.left;
|
|
}
|
|
style.left = name === 'fontSize' ? '1em' : result;
|
|
result = style.pixelLeft + 'px';
|
|
style.left = left;
|
|
if (rtLeft) {
|
|
runtimeStyle.left = rtLeft;
|
|
}
|
|
}
|
|
/*jshint eqnull:true */
|
|
return result == null ? result : result + '' || 'auto';
|
|
};
|
|
|
|
// unsupported
|
|
function PseudoComputedStyle() {}
|
|
PseudoComputedStyle.prototype.getPropertyValue = function () {
|
|
return null;
|
|
};
|
|
|
|
return function (el, pseudo) {
|
|
return pseudo ? new PseudoComputedStyle(el) : new ComputedStyle(el);
|
|
};
|
|
})()
|
|
),
|
|
|
|
addEventListener: valueDesc(function (type, handler, capture) {
|
|
var self = window,
|
|
ontype = 'on' + type,
|
|
handlers;
|
|
if (!self[ontype]) {
|
|
self[ontype] = function (e) {
|
|
return commonEventLoop(self, verify(self, e), handlers, false) && undefined;
|
|
};
|
|
}
|
|
handlers = self[ontype][SECRET] || (self[ontype][SECRET] = []);
|
|
if (find(handlers, handler) < 0) {
|
|
handlers[capture ? 'unshift' : 'push'](handler);
|
|
}
|
|
}),
|
|
dispatchEvent: valueDesc(function (e) {
|
|
var method = window['on' + e.type];
|
|
return method ? method.call(window, e) !== false && !e.defaultPrevented : true;
|
|
}),
|
|
removeEventListener: valueDesc(function (type, handler, capture) {
|
|
var ontype = 'on' + type,
|
|
handlers = (window[ontype] || Object)[SECRET],
|
|
i = handlers ? find(handlers, handler) : -1;
|
|
if (-1 < i) handlers.splice(i, 1);
|
|
}),
|
|
pageXOffset: { get: getter('scrollLeft') },
|
|
pageYOffset: { get: getter('scrollTop') },
|
|
scrollX: { get: getter('scrollLeft') },
|
|
scrollY: { get: getter('scrollTop') },
|
|
innerWidth: { get: getter('clientWidth') },
|
|
innerHeight: { get: getter('clientHeight') },
|
|
});
|
|
|
|
window.HTMLElement = window.Element;
|
|
|
|
(function (styleSheets, HTML5Element, i) {
|
|
for (i = 0; i < HTML5Element.length; i++) document.createElement(HTML5Element[i]);
|
|
if (!styleSheets.length) document.createStyleSheet('');
|
|
styleSheets[0].addRule(HTML5Element.join(','), 'display:block;');
|
|
})(document.styleSheets, ['header', 'nav', 'section', 'article', 'aside', 'footer']);
|
|
|
|
(function () {
|
|
if (document.createRange) return;
|
|
document.createRange = function createRange() {
|
|
return new Range();
|
|
};
|
|
|
|
function getContents(start, end) {
|
|
var nodes = [start];
|
|
while (start !== end) {
|
|
nodes.push((start = start.nextSibling));
|
|
}
|
|
return nodes;
|
|
}
|
|
|
|
function Range() {}
|
|
var proto = Range.prototype;
|
|
proto.cloneContents = function cloneContents() {
|
|
for (
|
|
var fragment = this._start.ownerDocument.createDocumentFragment(),
|
|
nodes = getContents(this._start, this._end),
|
|
i = 0,
|
|
length = nodes.length;
|
|
i < length;
|
|
i++
|
|
) {
|
|
fragment.appendChild(nodes[i].cloneNode(true));
|
|
}
|
|
return fragment;
|
|
};
|
|
proto.cloneRange = function cloneRange() {
|
|
var range = new Range();
|
|
range._start = this._start;
|
|
range._end = this._end;
|
|
return range;
|
|
};
|
|
proto.deleteContents = function deleteContents() {
|
|
for (
|
|
var parentNode = this._start.parentNode,
|
|
nodes = getContents(this._start, this._end),
|
|
i = 0,
|
|
length = nodes.length;
|
|
i < length;
|
|
i++
|
|
) {
|
|
parentNode.removeChild(nodes[i]);
|
|
}
|
|
};
|
|
proto.extractContents = function extractContents() {
|
|
for (
|
|
var fragment = this._start.ownerDocument.createDocumentFragment(),
|
|
nodes = getContents(this._start, this._end),
|
|
i = 0,
|
|
length = nodes.length;
|
|
i < length;
|
|
i++
|
|
) {
|
|
fragment.appendChild(nodes[i]);
|
|
}
|
|
return fragment;
|
|
};
|
|
proto.setEndAfter = function setEndAfter(node) {
|
|
this._end = node;
|
|
};
|
|
proto.setEndBefore = function setEndBefore(node) {
|
|
this._end = node.previousSibling;
|
|
};
|
|
proto.setStartAfter = function setStartAfter(node) {
|
|
this._start = node.nextSibling;
|
|
};
|
|
proto.setStartBefore = function setStartBefore(node) {
|
|
this._start = node;
|
|
};
|
|
})();
|
|
})(window);
|