mirror of
https://github.com/SPLURT-Station/S.P.L.U.R.T-Station-13.git
synced 2025-12-09 16:07:40 +00:00
GOONCHAT IS DEAD! LONG LIVE THE KING!
This commit is contained in:
Letter N
@@ -301,6 +301,12 @@ em {
|
||||
font-weight: bold;
|
||||
}
|
||||
|
||||
/* @adminobserver compatability*/
|
||||
.adminobserver {
|
||||
color: #996600;
|
||||
font-weight: bold;
|
||||
}
|
||||
|
||||
.admin {
|
||||
color: #5975da;
|
||||
font-weight: bold;
|
||||
@@ -596,12 +602,155 @@ em {
|
||||
font-size: 185%;
|
||||
}
|
||||
|
||||
.umbra {
|
||||
color: #5000A0;
|
||||
}
|
||||
|
||||
.umbra_emphasis {
|
||||
color: #5000A0;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.umbra_large {
|
||||
color: #5000A0;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
font-size: 3;
|
||||
}
|
||||
|
||||
.deconversion_message {
|
||||
color: #a947ff;
|
||||
color: #5000A0;
|
||||
font-size: 185%;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
/* coggers dosen't exist on tg :( */
|
||||
/* from decon_msg: font-size: 185% == font-size 3*/
|
||||
.brass {
|
||||
color: #BE8700;
|
||||
}
|
||||
|
||||
.heavy_brass {
|
||||
color: #BE8700;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.large_brass {
|
||||
color: #BE8700;
|
||||
font-size: 185%;
|
||||
}
|
||||
|
||||
.big_brass {
|
||||
color: #BE8700;
|
||||
font-size: 185%;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.ratvar {
|
||||
color: #BE8700;
|
||||
font-size: 6;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.alloy {
|
||||
color: #42474D;
|
||||
}
|
||||
|
||||
.heavy_alloy {
|
||||
color: #42474D;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.nezbere_large {
|
||||
color: #42474D;
|
||||
font-size: 185%;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.nezbere {
|
||||
color: #42474D;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.nezbere_small {
|
||||
color: #42474D;
|
||||
}
|
||||
|
||||
.sevtug_large {
|
||||
color: #AF0AAF;
|
||||
font-size: 185%;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.sevtug {
|
||||
color: #AF0AAF;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.sevtug_small {
|
||||
color: #AF0AAF;
|
||||
}
|
||||
|
||||
.inathneq_large {
|
||||
color: #1E8CE1;
|
||||
font-size: 185%;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.inathneq {
|
||||
color: #1E8CE1;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.inathneq_small {
|
||||
color: #1E8CE1;
|
||||
}
|
||||
|
||||
.nzcrentr_large {
|
||||
color: #DAAA18;
|
||||
font-size: 185%;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.nzcrentr {
|
||||
color: #DAAA18;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.nzcrentr_small {
|
||||
color: #DAAA18;
|
||||
}
|
||||
|
||||
.neovgre_large {
|
||||
color: #6E001A;
|
||||
font-size: 185%;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.neovgre {
|
||||
color: #6E001A;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.neovgre_small {
|
||||
color: #6E001A;
|
||||
}
|
||||
|
||||
.ghostalert {
|
||||
color: #6600ff;
|
||||
font-style: italic;
|
||||
@@ -685,6 +834,11 @@ em {
|
||||
font-size: 185%;
|
||||
}
|
||||
|
||||
.yellowtext {
|
||||
color: #FFCC00;
|
||||
font-size: 185%;
|
||||
}
|
||||
|
||||
.clown {
|
||||
color: #ff70c1;
|
||||
font-size: 160%;
|
||||
@@ -732,6 +886,31 @@ em {
|
||||
}
|
||||
}
|
||||
|
||||
.velvet {
|
||||
color: #660015;
|
||||
font-weight: bold;
|
||||
animation: velvet 5000ms infinite;
|
||||
animation-direction: alternate;
|
||||
}
|
||||
|
||||
@keyframes velvet {
|
||||
0% {
|
||||
color: #400020;
|
||||
}
|
||||
40% {
|
||||
color: #FF0000;
|
||||
}
|
||||
50% {
|
||||
color: #FF8888;
|
||||
}
|
||||
60% {
|
||||
color: #FF0000;
|
||||
}
|
||||
100% {
|
||||
color: #400020;
|
||||
}
|
||||
}
|
||||
|
||||
.phobia {
|
||||
color: #dd0000;
|
||||
font-weight: bold;
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
* SPDX-License-Identifier: MIT
|
||||
*/
|
||||
|
||||
html, body {
|
||||
html, body {
|
||||
padding: 0;
|
||||
margin: 0;
|
||||
height: 100%;
|
||||
@@ -297,6 +297,12 @@ em {
|
||||
font-weight: bold;
|
||||
}
|
||||
|
||||
/* @adminobserver compatability*/
|
||||
.adminobserver {
|
||||
color: #996600;
|
||||
font-weight: bold;
|
||||
}
|
||||
|
||||
.admin {
|
||||
color: #4473ff;
|
||||
font-weight: bold;
|
||||
@@ -618,12 +624,155 @@ h1.alert, h2.alert {
|
||||
font-size: 185%;
|
||||
}
|
||||
|
||||
.umbra {
|
||||
color: #5000A0;
|
||||
}
|
||||
|
||||
.umbra_emphasis {
|
||||
color: #5000A0;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.umbra_large {
|
||||
color: #5000A0;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
font-size: 3;
|
||||
}
|
||||
|
||||
.deconversion_message {
|
||||
color: #5000A0;
|
||||
font-size: 185%;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
/* coggers dosen't exist on tg :( */
|
||||
/* from decon_msg: font-size: 185% == font-size 3*/
|
||||
.brass {
|
||||
color: #BE8700;
|
||||
}
|
||||
|
||||
.heavy_brass {
|
||||
color: #BE8700;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.large_brass {
|
||||
color: #BE8700;
|
||||
font-size: 185%;
|
||||
}
|
||||
|
||||
.big_brass {
|
||||
color: #BE8700;
|
||||
font-size: 185%;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.ratvar {
|
||||
color: #BE8700;
|
||||
font-size: 6;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.alloy {
|
||||
color: #42474D;
|
||||
}
|
||||
|
||||
.heavy_alloy {
|
||||
color: #42474D;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.nezbere_large {
|
||||
color: #42474D;
|
||||
font-size: 185%;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.nezbere {
|
||||
color: #42474D;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.nezbere_small {
|
||||
color: #42474D;
|
||||
}
|
||||
|
||||
.sevtug_large {
|
||||
color: #AF0AAF;
|
||||
font-size: 185%;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.sevtug {
|
||||
color: #AF0AAF;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.sevtug_small {
|
||||
color: #AF0AAF;
|
||||
}
|
||||
|
||||
.inathneq_large {
|
||||
color: #1E8CE1;
|
||||
font-size: 185%;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.inathneq {
|
||||
color: #1E8CE1;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.inathneq_small {
|
||||
color: #1E8CE1;
|
||||
}
|
||||
|
||||
.nzcrentr_large {
|
||||
color: #DAAA18;
|
||||
font-size: 185%;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.nzcrentr {
|
||||
color: #DAAA18;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.nzcrentr_small {
|
||||
color: #DAAA18;
|
||||
}
|
||||
|
||||
.neovgre_large {
|
||||
color: #6E001A;
|
||||
font-size: 185%;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.neovgre {
|
||||
color: #6E001A;
|
||||
font-weight: bold;
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
.neovgre_small {
|
||||
color: #6E001A;
|
||||
}
|
||||
|
||||
.ghostalert {
|
||||
color: #5c00e6;
|
||||
font-style: italic;
|
||||
@@ -707,6 +856,11 @@ h1.alert, h2.alert {
|
||||
font-size: 185%;
|
||||
}
|
||||
|
||||
.yellowtext {
|
||||
color: #FFCC00;
|
||||
font-size: 185%;
|
||||
}
|
||||
|
||||
.clown {
|
||||
color: #FF69Bf;
|
||||
font-size: 160%;
|
||||
@@ -754,6 +908,31 @@ h1.alert, h2.alert {
|
||||
}
|
||||
}
|
||||
|
||||
.velvet {
|
||||
color: #660015;
|
||||
font-weight: bold;
|
||||
animation: velvet 5000ms infinite;
|
||||
animation-direction: alternate;
|
||||
}
|
||||
|
||||
@keyframes velvet {
|
||||
0% {
|
||||
color: #400020;
|
||||
}
|
||||
40% {
|
||||
color: #FF0000;
|
||||
}
|
||||
50% {
|
||||
color: #FF8888;
|
||||
}
|
||||
60% {
|
||||
color: #FF0000;
|
||||
}
|
||||
100% {
|
||||
color: #400020;
|
||||
}
|
||||
}
|
||||
|
||||
.phobia {
|
||||
color: #dd0000;
|
||||
font-weight: bold;
|
||||
|
||||
@@ -1,44 +0,0 @@
|
||||
/**
|
||||
* CSS Object Model patches
|
||||
*
|
||||
* Adapted from: https://github.com/shawnbot/aight
|
||||
*
|
||||
* @file
|
||||
* @copyright 2020 Aleksej Komarov
|
||||
* @license MIT
|
||||
*/
|
||||
|
||||
/* eslint-disable */
|
||||
(function(Proto) {
|
||||
'use strict';
|
||||
|
||||
if (typeof Proto.setAttribute !== 'undefined') {
|
||||
function toAttr(prop) {
|
||||
return prop.replace(/-[a-z]/g, function (bit) {
|
||||
return bit[1].toUpperCase();
|
||||
});
|
||||
}
|
||||
|
||||
Proto.setProperty = function (prop, value) {
|
||||
var attr = toAttr(prop);
|
||||
if (!value) {
|
||||
return this.removeAttribute(attr);
|
||||
}
|
||||
var str = String(value);
|
||||
return this.setAttribute(attr, str);
|
||||
};
|
||||
|
||||
Proto.getPropertyValue = function (prop) {
|
||||
var attr = toAttr(prop);
|
||||
return this.getAttribute(attr) || null;
|
||||
};
|
||||
|
||||
Proto.removeProperty = function (prop) {
|
||||
var attr = toAttr(prop);
|
||||
var value = this.getAttribute(attr);
|
||||
this.removeAttribute(attr);
|
||||
return value;
|
||||
};
|
||||
}
|
||||
|
||||
})(CSSStyleDeclaration.prototype);
|
||||
@@ -1,970 +0,0 @@
|
||||
/**
|
||||
* @file
|
||||
* @copyright 2013 Andrea Giammarchi, WebReflection
|
||||
* @license MIT
|
||||
*/
|
||||
|
||||
/* eslint-disable */
|
||||
(function(window){
|
||||
'use strict';
|
||||
/* jshint loopfunc: true, noempty: false*/
|
||||
// http://www.w3.org/TR/dom/#element
|
||||
|
||||
function createDocumentFragment() {
|
||||
return document.createDocumentFragment();
|
||||
}
|
||||
|
||||
function createElement(nodeName) {
|
||||
return document.createElement(nodeName);
|
||||
}
|
||||
|
||||
function enoughArguments(length, name) {
|
||||
if (!length) throw new Error(
|
||||
'Failed to construct ' +
|
||||
name +
|
||||
': 1 argument required, but only 0 present.'
|
||||
);
|
||||
}
|
||||
|
||||
function mutationMacro(nodes) {
|
||||
if (nodes.length === 1) {
|
||||
return textNodeIfPrimitive(nodes[0]);
|
||||
}
|
||||
for (var
|
||||
fragment = createDocumentFragment(),
|
||||
list = slice.call(nodes),
|
||||
i = 0; i < nodes.length; i++
|
||||
) {
|
||||
fragment.appendChild(textNodeIfPrimitive(list[i]));
|
||||
}
|
||||
return fragment;
|
||||
}
|
||||
|
||||
function textNodeIfPrimitive(node) {
|
||||
return typeof node === 'object' ? node : document.createTextNode(node);
|
||||
}
|
||||
|
||||
for(var
|
||||
head,
|
||||
property,
|
||||
TemporaryPrototype,
|
||||
TemporaryTokenList,
|
||||
wrapVerifyToken,
|
||||
document = window.document,
|
||||
hOP = Object.prototype.hasOwnProperty,
|
||||
defineProperty = Object.defineProperty || function (object, property, descriptor) {
|
||||
if (hOP.call(descriptor, 'value')) {
|
||||
object[property] = descriptor.value;
|
||||
} else {
|
||||
if (hOP.call(descriptor, 'get'))
|
||||
object.__defineGetter__(property, descriptor.get);
|
||||
if (hOP.call(descriptor, 'set'))
|
||||
object.__defineSetter__(property, descriptor.set);
|
||||
}
|
||||
return object;
|
||||
},
|
||||
indexOf = [].indexOf || function indexOf(value){
|
||||
var length = this.length;
|
||||
while(length--) {
|
||||
if (this[length] === value) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return length;
|
||||
},
|
||||
// http://www.w3.org/TR/domcore/#domtokenlist
|
||||
verifyToken = function (token) {
|
||||
if (!token) {
|
||||
throw 'SyntaxError';
|
||||
} else if (spaces.test(token)) {
|
||||
throw 'InvalidCharacterError';
|
||||
}
|
||||
return token;
|
||||
},
|
||||
DOMTokenList = function (node) {
|
||||
var
|
||||
noClassName = typeof node.className === 'undefined',
|
||||
className = noClassName ?
|
||||
(node.getAttribute('class') || '') : node.className,
|
||||
isSVG = noClassName || typeof className === 'object',
|
||||
value = (isSVG ?
|
||||
(noClassName ? className : className.baseVal) :
|
||||
className
|
||||
).replace(trim, '')
|
||||
;
|
||||
if (value.length) {
|
||||
properties.push.apply(
|
||||
this,
|
||||
value.split(spaces)
|
||||
);
|
||||
}
|
||||
this._isSVG = isSVG;
|
||||
this._ = node;
|
||||
},
|
||||
classListDescriptor = {
|
||||
get: function get() {
|
||||
return new DOMTokenList(this);
|
||||
},
|
||||
set: function(){}
|
||||
},
|
||||
trim = /^\s+|\s+$/g,
|
||||
spaces = /\s+/,
|
||||
SPACE = '\x20',
|
||||
CLASS_LIST = 'classList',
|
||||
toggle = function toggle(token, force) {
|
||||
if (this.contains(token)) {
|
||||
if (!force) {
|
||||
// force is not true (either false or omitted)
|
||||
this.remove(token);
|
||||
}
|
||||
} else if(force === undefined || force) {
|
||||
force = true;
|
||||
this.add(token);
|
||||
}
|
||||
return !!force;
|
||||
},
|
||||
DocumentFragmentPrototype = window.DocumentFragment && DocumentFragment.prototype,
|
||||
Node = window.Node,
|
||||
NodePrototype = (Node || Element).prototype,
|
||||
CharacterData = window.CharacterData || Node,
|
||||
CharacterDataPrototype = CharacterData && CharacterData.prototype,
|
||||
DocumentType = window.DocumentType,
|
||||
DocumentTypePrototype = DocumentType && DocumentType.prototype,
|
||||
ElementPrototype = (window.Element || Node || window.HTMLElement).prototype,
|
||||
HTMLSelectElement = window.HTMLSelectElement || createElement('select').constructor,
|
||||
selectRemove = HTMLSelectElement.prototype.remove,
|
||||
SVGElement = window.SVGElement,
|
||||
properties = [
|
||||
'matches', (
|
||||
ElementPrototype.matchesSelector ||
|
||||
ElementPrototype.webkitMatchesSelector ||
|
||||
ElementPrototype.khtmlMatchesSelector ||
|
||||
ElementPrototype.mozMatchesSelector ||
|
||||
ElementPrototype.msMatchesSelector ||
|
||||
ElementPrototype.oMatchesSelector ||
|
||||
function matches(selector) {
|
||||
var parentNode = this.parentNode;
|
||||
return !!parentNode && -1 < indexOf.call(
|
||||
parentNode.querySelectorAll(selector),
|
||||
this
|
||||
);
|
||||
}
|
||||
),
|
||||
'closest', function closest(selector) {
|
||||
var parentNode = this, matches;
|
||||
while (
|
||||
// document has no .matches
|
||||
(matches = parentNode && parentNode.matches) &&
|
||||
!parentNode.matches(selector)
|
||||
) {
|
||||
parentNode = parentNode.parentNode;
|
||||
}
|
||||
return matches ? parentNode : null;
|
||||
},
|
||||
'prepend', function prepend() {
|
||||
var firstChild = this.firstChild,
|
||||
node = mutationMacro(arguments);
|
||||
if (firstChild) {
|
||||
this.insertBefore(node, firstChild);
|
||||
} else {
|
||||
this.appendChild(node);
|
||||
}
|
||||
},
|
||||
'append', function append() {
|
||||
this.appendChild(mutationMacro(arguments));
|
||||
},
|
||||
'before', function before() {
|
||||
var parentNode = this.parentNode;
|
||||
if (parentNode) {
|
||||
parentNode.insertBefore(
|
||||
mutationMacro(arguments), this
|
||||
);
|
||||
}
|
||||
},
|
||||
'after', function after() {
|
||||
var parentNode = this.parentNode,
|
||||
nextSibling = this.nextSibling,
|
||||
node = mutationMacro(arguments);
|
||||
if (parentNode) {
|
||||
if (nextSibling) {
|
||||
parentNode.insertBefore(node, nextSibling);
|
||||
} else {
|
||||
parentNode.appendChild(node);
|
||||
}
|
||||
}
|
||||
},
|
||||
// https://dom.spec.whatwg.org/#dom-element-toggleattribute
|
||||
'toggleAttribute', function toggleAttribute(name, force) {
|
||||
var had = this.hasAttribute(name);
|
||||
if (1 < arguments.length) {
|
||||
if (had && !force)
|
||||
this.removeAttribute(name);
|
||||
else if (force && !had)
|
||||
this.setAttribute(name, "");
|
||||
}
|
||||
else if (had)
|
||||
this.removeAttribute(name);
|
||||
else
|
||||
this.setAttribute(name, "");
|
||||
return this.hasAttribute(name);
|
||||
},
|
||||
// WARNING - DEPRECATED - use .replaceWith() instead
|
||||
'replace', function replace() {
|
||||
this.replaceWith.apply(this, arguments);
|
||||
},
|
||||
'replaceWith', function replaceWith() {
|
||||
var parentNode = this.parentNode;
|
||||
if (parentNode) {
|
||||
parentNode.replaceChild(
|
||||
mutationMacro(arguments),
|
||||
this
|
||||
);
|
||||
}
|
||||
},
|
||||
'remove', function remove() {
|
||||
var parentNode = this.parentNode;
|
||||
if (parentNode) {
|
||||
parentNode.removeChild(this);
|
||||
}
|
||||
}
|
||||
],
|
||||
slice = properties.slice,
|
||||
i = properties.length; i; i -= 2
|
||||
) {
|
||||
property = properties[i - 2];
|
||||
if (!(property in ElementPrototype)) {
|
||||
ElementPrototype[property] = properties[i - 1];
|
||||
}
|
||||
// avoid unnecessary re-patch when the script is included
|
||||
// gazillion times without any reason whatsoever
|
||||
// https://github.com/WebReflection/dom4/pull/48
|
||||
if (property === 'remove' && !selectRemove._dom4) {
|
||||
// see https://github.com/WebReflection/dom4/issues/19
|
||||
(HTMLSelectElement.prototype[property] = function () {
|
||||
return 0 < arguments.length ?
|
||||
selectRemove.apply(this, arguments) :
|
||||
ElementPrototype.remove.call(this);
|
||||
})._dom4 = true;
|
||||
}
|
||||
// see https://github.com/WebReflection/dom4/issues/18
|
||||
if (/^(?:before|after|replace|replaceWith|remove)$/.test(property)) {
|
||||
if (CharacterData && !(property in CharacterDataPrototype)) {
|
||||
CharacterDataPrototype[property] = properties[i - 1];
|
||||
}
|
||||
if (DocumentType && !(property in DocumentTypePrototype)) {
|
||||
DocumentTypePrototype[property] = properties[i - 1];
|
||||
}
|
||||
}
|
||||
// see https://github.com/WebReflection/dom4/pull/26
|
||||
if (/^(?:append|prepend)$/.test(property)) {
|
||||
if (DocumentFragmentPrototype) {
|
||||
if (!(property in DocumentFragmentPrototype)) {
|
||||
DocumentFragmentPrototype[property] = properties[i - 1];
|
||||
}
|
||||
} else {
|
||||
try {
|
||||
createDocumentFragment().constructor.prototype[property] = properties[i - 1];
|
||||
} catch(o_O) {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// most likely an IE9 only issue
|
||||
// see https://github.com/WebReflection/dom4/issues/6
|
||||
if (!createElement('a').matches('a')) {
|
||||
ElementPrototype[property] = function(matches){
|
||||
return function (selector) {
|
||||
return matches.call(
|
||||
this.parentNode ?
|
||||
this :
|
||||
createDocumentFragment().appendChild(this),
|
||||
selector
|
||||
);
|
||||
};
|
||||
}(ElementPrototype[property]);
|
||||
}
|
||||
|
||||
// used to fix both old webkit and SVG
|
||||
DOMTokenList.prototype = {
|
||||
length: 0,
|
||||
add: function add() {
|
||||
for(var j = 0, token; j < arguments.length; j++) {
|
||||
token = arguments[j];
|
||||
if(!this.contains(token)) {
|
||||
properties.push.call(this, property);
|
||||
}
|
||||
}
|
||||
if (this._isSVG) {
|
||||
this._.setAttribute('class', '' + this);
|
||||
} else {
|
||||
this._.className = '' + this;
|
||||
}
|
||||
},
|
||||
contains: (function(indexOf){
|
||||
return function contains(token) {
|
||||
i = indexOf.call(this, property = verifyToken(token));
|
||||
return -1 < i;
|
||||
};
|
||||
}([].indexOf || function (token) {
|
||||
i = this.length;
|
||||
while(i-- && this[i] !== token){}
|
||||
return i;
|
||||
})),
|
||||
item: function item(i) {
|
||||
return this[i] || null;
|
||||
},
|
||||
remove: function remove() {
|
||||
for(var j = 0, token; j < arguments.length; j++) {
|
||||
token = arguments[j];
|
||||
if(this.contains(token)) {
|
||||
properties.splice.call(this, i, 1);
|
||||
}
|
||||
}
|
||||
if (this._isSVG) {
|
||||
this._.setAttribute('class', '' + this);
|
||||
} else {
|
||||
this._.className = '' + this;
|
||||
}
|
||||
},
|
||||
toggle: toggle,
|
||||
toString: function toString() {
|
||||
return properties.join.call(this, SPACE);
|
||||
}
|
||||
};
|
||||
|
||||
if (SVGElement && !(CLASS_LIST in SVGElement.prototype)) {
|
||||
defineProperty(SVGElement.prototype, CLASS_LIST, classListDescriptor);
|
||||
}
|
||||
|
||||
// http://www.w3.org/TR/dom/#domtokenlist
|
||||
// iOS 5.1 has completely screwed this property
|
||||
// classList in ElementPrototype is false
|
||||
// but it's actually there as getter
|
||||
if (!(CLASS_LIST in document.documentElement)) {
|
||||
defineProperty(ElementPrototype, CLASS_LIST, classListDescriptor);
|
||||
} else {
|
||||
// iOS 5.1 and Nokia ASHA do not support multiple add or remove
|
||||
// trying to detect and fix that in here
|
||||
TemporaryTokenList = createElement('div')[CLASS_LIST];
|
||||
TemporaryTokenList.add('a', 'b', 'a');
|
||||
if ('a\x20b' != TemporaryTokenList) {
|
||||
// no other way to reach original methods in iOS 5.1
|
||||
TemporaryPrototype = TemporaryTokenList.constructor.prototype;
|
||||
if (!('add' in TemporaryPrototype)) {
|
||||
// ASHA double fails in here
|
||||
TemporaryPrototype = window.TemporaryTokenList.prototype;
|
||||
}
|
||||
wrapVerifyToken = function (original) {
|
||||
return function () {
|
||||
var i = 0;
|
||||
while (i < arguments.length) {
|
||||
original.call(this, arguments[i++]);
|
||||
}
|
||||
};
|
||||
};
|
||||
TemporaryPrototype.add = wrapVerifyToken(TemporaryPrototype.add);
|
||||
TemporaryPrototype.remove = wrapVerifyToken(TemporaryPrototype.remove);
|
||||
// toggle is broken too ^_^ ... let's fix it
|
||||
TemporaryPrototype.toggle = toggle;
|
||||
}
|
||||
}
|
||||
|
||||
if (!('contains' in NodePrototype)) {
|
||||
defineProperty(NodePrototype, 'contains', {
|
||||
value: function (el) {
|
||||
while (el && el !== this) el = el.parentNode;
|
||||
return this === el;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
if (!('head' in document)) {
|
||||
defineProperty(document, 'head', {
|
||||
get: function () {
|
||||
return head || (
|
||||
head = document.getElementsByTagName('head')[0]
|
||||
);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// requestAnimationFrame partial polyfill
|
||||
(function () {
|
||||
for (var
|
||||
raf,
|
||||
rAF = window.requestAnimationFrame,
|
||||
cAF = window.cancelAnimationFrame,
|
||||
prefixes = ['o', 'ms', 'moz', 'webkit'],
|
||||
i = prefixes.length;
|
||||
!cAF && i--;
|
||||
) {
|
||||
rAF = rAF || window[prefixes[i] + 'RequestAnimationFrame'];
|
||||
cAF = window[prefixes[i] + 'CancelAnimationFrame'] ||
|
||||
window[prefixes[i] + 'CancelRequestAnimationFrame'];
|
||||
}
|
||||
if (!cAF) {
|
||||
// some FF apparently implemented rAF but no cAF
|
||||
if (rAF) {
|
||||
raf = rAF;
|
||||
rAF = function (callback) {
|
||||
var goOn = true;
|
||||
raf(function () {
|
||||
if (goOn) callback.apply(this, arguments);
|
||||
});
|
||||
return function () {
|
||||
goOn = false;
|
||||
};
|
||||
};
|
||||
cAF = function (id) {
|
||||
id();
|
||||
};
|
||||
} else {
|
||||
rAF = function (callback) {
|
||||
return setTimeout(callback, 15, 15);
|
||||
};
|
||||
cAF = function (id) {
|
||||
clearTimeout(id);
|
||||
};
|
||||
}
|
||||
}
|
||||
window.requestAnimationFrame = rAF;
|
||||
window.cancelAnimationFrame = cAF;
|
||||
}());
|
||||
|
||||
// http://www.w3.org/TR/dom/#customevent
|
||||
try{new window.CustomEvent('?');}catch(o_O){
|
||||
window.CustomEvent = function(
|
||||
eventName,
|
||||
defaultInitDict
|
||||
){
|
||||
|
||||
// the infamous substitute
|
||||
function CustomEvent(type, eventInitDict) {
|
||||
/*jshint eqnull:true */
|
||||
var event = document.createEvent(eventName);
|
||||
if (typeof type != 'string') {
|
||||
throw new Error('An event name must be provided');
|
||||
}
|
||||
if (eventName == 'Event') {
|
||||
event.initCustomEvent = initCustomEvent;
|
||||
}
|
||||
if (eventInitDict == null) {
|
||||
eventInitDict = defaultInitDict;
|
||||
}
|
||||
event.initCustomEvent(
|
||||
type,
|
||||
eventInitDict.bubbles,
|
||||
eventInitDict.cancelable,
|
||||
eventInitDict.detail
|
||||
);
|
||||
return event;
|
||||
}
|
||||
|
||||
// attached at runtime
|
||||
function initCustomEvent(
|
||||
type, bubbles, cancelable, detail
|
||||
) {
|
||||
/*jshint validthis:true*/
|
||||
this.initEvent(type, bubbles, cancelable);
|
||||
this.detail = detail;
|
||||
}
|
||||
|
||||
// that's it
|
||||
return CustomEvent;
|
||||
}(
|
||||
// is this IE9 or IE10 ?
|
||||
// where CustomEvent is there
|
||||
// but not usable as construtor ?
|
||||
window.CustomEvent ?
|
||||
// use the CustomEvent interface in such case
|
||||
'CustomEvent' : 'Event',
|
||||
// otherwise the common compatible one
|
||||
{
|
||||
bubbles: false,
|
||||
cancelable: false,
|
||||
detail: null
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
// window.Event as constructor
|
||||
try { new Event('_'); } catch (o_O) {
|
||||
/* jshint -W022 */
|
||||
o_O = (function ($Event) {
|
||||
function Event(type, init) {
|
||||
enoughArguments(arguments.length, 'Event');
|
||||
var out = document.createEvent('Event');
|
||||
if (!init) init = {};
|
||||
out.initEvent(
|
||||
type,
|
||||
!!init.bubbles,
|
||||
!!init.cancelable
|
||||
);
|
||||
return out;
|
||||
}
|
||||
Event.prototype = $Event.prototype;
|
||||
return Event;
|
||||
}(window.Event || function Event() {}));
|
||||
defineProperty(window, 'Event', {value: o_O});
|
||||
// Android 4 gotcha
|
||||
if (Event !== o_O) Event = o_O;
|
||||
}
|
||||
|
||||
// window.KeyboardEvent as constructor
|
||||
try { new KeyboardEvent('_', {}); } catch (o_O) {
|
||||
/* jshint -W022 */
|
||||
o_O = (function ($KeyboardEvent) {
|
||||
// code inspired by https://gist.github.com/termi/4654819
|
||||
var
|
||||
initType = 0,
|
||||
defaults = {
|
||||
char: '',
|
||||
key: '',
|
||||
location: 0,
|
||||
ctrlKey: false,
|
||||
shiftKey: false,
|
||||
altKey: false,
|
||||
metaKey: false,
|
||||
altGraphKey: false,
|
||||
repeat: false,
|
||||
locale: navigator.language,
|
||||
detail: 0,
|
||||
bubbles: false,
|
||||
cancelable: false,
|
||||
keyCode: 0,
|
||||
charCode: 0,
|
||||
which: 0
|
||||
},
|
||||
eventType
|
||||
;
|
||||
try {
|
||||
var e = document.createEvent('KeyboardEvent');
|
||||
e.initKeyboardEvent(
|
||||
'keyup', false, false, window, '+', 3,
|
||||
true, false, true, false, false
|
||||
);
|
||||
initType = (
|
||||
(e.keyIdentifier || e.key) == '+' &&
|
||||
(e.keyLocation || e.location) == 3
|
||||
) && (
|
||||
e.ctrlKey ? e.altKey ? 1 : 3 : e.shiftKey ? 2 : 4
|
||||
) || 9;
|
||||
} catch(o_O) {}
|
||||
eventType = 0 < initType ? 'KeyboardEvent' : 'Event';
|
||||
|
||||
function getModifier(init) {
|
||||
for (var
|
||||
out = [],
|
||||
keys = [
|
||||
'ctrlKey',
|
||||
'Control',
|
||||
'shiftKey',
|
||||
'Shift',
|
||||
'altKey',
|
||||
'Alt',
|
||||
'metaKey',
|
||||
'Meta',
|
||||
'altGraphKey',
|
||||
'AltGraph'
|
||||
],
|
||||
i = 0; i < keys.length; i += 2
|
||||
) {
|
||||
if (init[keys[i]])
|
||||
out.push(keys[i + 1]);
|
||||
}
|
||||
return out.join(' ');
|
||||
}
|
||||
|
||||
function withDefaults(target, source) {
|
||||
for (var key in source) {
|
||||
if (
|
||||
source.hasOwnProperty(key) &&
|
||||
!source.hasOwnProperty.call(target, key)
|
||||
) target[key] = source[key];
|
||||
}
|
||||
return target;
|
||||
}
|
||||
|
||||
function withInitValues(key, out, init) {
|
||||
try {
|
||||
out[key] = init[key];
|
||||
} catch(o_O) {}
|
||||
}
|
||||
|
||||
function KeyboardEvent(type, init) {
|
||||
enoughArguments(arguments.length, 'KeyboardEvent');
|
||||
init = withDefaults(init || {}, defaults);
|
||||
var
|
||||
out = document.createEvent(eventType),
|
||||
ctrlKey = init.ctrlKey,
|
||||
shiftKey = init.shiftKey,
|
||||
altKey = init.altKey,
|
||||
metaKey = init.metaKey,
|
||||
altGraphKey = init.altGraphKey,
|
||||
modifiers = initType > 3 ? getModifier(init) : null,
|
||||
key = String(init.key),
|
||||
chr = String(init.char),
|
||||
location = init.location,
|
||||
keyCode = init.keyCode || (
|
||||
(init.keyCode = key) &&
|
||||
key.charCodeAt(0)
|
||||
) || 0,
|
||||
charCode = init.charCode || (
|
||||
(init.charCode = chr) &&
|
||||
chr.charCodeAt(0)
|
||||
) || 0,
|
||||
bubbles = init.bubbles,
|
||||
cancelable = init.cancelable,
|
||||
repeat = init.repeat,
|
||||
locale = init.locale,
|
||||
view = init.view || window,
|
||||
args
|
||||
;
|
||||
if (!init.which) init.which = init.keyCode;
|
||||
if ('initKeyEvent' in out) {
|
||||
out.initKeyEvent(
|
||||
type, bubbles, cancelable, view,
|
||||
ctrlKey, altKey, shiftKey, metaKey, keyCode, charCode
|
||||
);
|
||||
} else if (0 < initType && 'initKeyboardEvent' in out) {
|
||||
args = [type, bubbles, cancelable, view];
|
||||
switch (initType) {
|
||||
case 1:
|
||||
args.push(key, location, ctrlKey, shiftKey, altKey, metaKey, altGraphKey);
|
||||
break;
|
||||
case 2:
|
||||
args.push(ctrlKey, altKey, shiftKey, metaKey, keyCode, charCode);
|
||||
break;
|
||||
case 3:
|
||||
args.push(key, location, ctrlKey, altKey, shiftKey, metaKey, altGraphKey);
|
||||
break;
|
||||
case 4:
|
||||
args.push(key, location, modifiers, repeat, locale);
|
||||
break;
|
||||
default:
|
||||
args.push(char, key, location, modifiers, repeat, locale);
|
||||
}
|
||||
out.initKeyboardEvent.apply(out, args);
|
||||
} else {
|
||||
out.initEvent(type, bubbles, cancelable);
|
||||
}
|
||||
for (key in out) {
|
||||
if (defaults.hasOwnProperty(key) && out[key] !== init[key]) {
|
||||
withInitValues(key, out, init);
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
KeyboardEvent.prototype = $KeyboardEvent.prototype;
|
||||
return KeyboardEvent;
|
||||
}(window.KeyboardEvent || function KeyboardEvent() {}));
|
||||
defineProperty(window, 'KeyboardEvent', {value: o_O});
|
||||
// Android 4 gotcha
|
||||
if (KeyboardEvent !== o_O) KeyboardEvent = o_O;
|
||||
}
|
||||
|
||||
// window.MouseEvent as constructor
|
||||
try { new MouseEvent('_', {}); } catch (o_O) {
|
||||
/* jshint -W022 */
|
||||
o_O = (function ($MouseEvent) {
|
||||
function MouseEvent(type, init) {
|
||||
enoughArguments(arguments.length, 'MouseEvent');
|
||||
var out = document.createEvent('MouseEvent');
|
||||
if (!init) init = {};
|
||||
out.initMouseEvent(
|
||||
type,
|
||||
!!init.bubbles,
|
||||
!!init.cancelable,
|
||||
init.view || window,
|
||||
init.detail || 1,
|
||||
init.screenX || 0,
|
||||
init.screenY || 0,
|
||||
init.clientX || 0,
|
||||
init.clientY || 0,
|
||||
!!init.ctrlKey,
|
||||
!!init.altKey,
|
||||
!!init.shiftKey,
|
||||
!!init.metaKey,
|
||||
init.button || 0,
|
||||
init.relatedTarget || null
|
||||
);
|
||||
return out;
|
||||
}
|
||||
MouseEvent.prototype = $MouseEvent.prototype;
|
||||
return MouseEvent;
|
||||
}(window.MouseEvent || function MouseEvent() {}));
|
||||
defineProperty(window, 'MouseEvent', {value: o_O});
|
||||
// Android 4 gotcha
|
||||
if (MouseEvent !== o_O) MouseEvent = o_O;
|
||||
}
|
||||
|
||||
if (!document.querySelectorAll('*').forEach) {
|
||||
(function () {
|
||||
function patch(what) {
|
||||
var querySelectorAll = what.querySelectorAll;
|
||||
what.querySelectorAll = function qSA(css) {
|
||||
var result = querySelectorAll.call(this, css);
|
||||
result.forEach = Array.prototype.forEach;
|
||||
return result;
|
||||
};
|
||||
}
|
||||
patch(document);
|
||||
patch(Element.prototype);
|
||||
}());
|
||||
}
|
||||
|
||||
try {
|
||||
// https://drafts.csswg.org/selectors-4/#the-scope-pseudo
|
||||
document.querySelector(':scope *');
|
||||
} catch(o_O) {
|
||||
(function () {
|
||||
var dataScope = 'data-scope-' + (Math.random() * 1e9 >>> 0);
|
||||
var proto = Element.prototype;
|
||||
var querySelector = proto.querySelector;
|
||||
var querySelectorAll = proto.querySelectorAll;
|
||||
proto.querySelector = function qS(css) {
|
||||
return find(this, querySelector, css);
|
||||
};
|
||||
proto.querySelectorAll = function qSA(css) {
|
||||
return find(this, querySelectorAll, css);
|
||||
};
|
||||
function find(node, method, css) {
|
||||
node.setAttribute(dataScope, null);
|
||||
var result = method.call(
|
||||
node,
|
||||
String(css).replace(
|
||||
/(^|,\s*)(:scope([ >]|$))/g,
|
||||
function ($0, $1, $2, $3) {
|
||||
return $1 + '[' + dataScope + ']' + ($3 || ' ');
|
||||
}
|
||||
)
|
||||
);
|
||||
node.removeAttribute(dataScope);
|
||||
return result;
|
||||
}
|
||||
}());
|
||||
}
|
||||
}(window));
|
||||
(function (global){'use strict';
|
||||
|
||||
// a WeakMap fallback for DOM nodes only used as key
|
||||
var DOMMap = global.WeakMap || (function () {
|
||||
|
||||
var
|
||||
counter = 0,
|
||||
dispatched = false,
|
||||
drop = false,
|
||||
value
|
||||
;
|
||||
|
||||
function dispatch(key, ce, shouldDrop) {
|
||||
drop = shouldDrop;
|
||||
dispatched = false;
|
||||
value = undefined;
|
||||
key.dispatchEvent(ce);
|
||||
}
|
||||
|
||||
function Handler(value) {
|
||||
this.value = value;
|
||||
}
|
||||
|
||||
Handler.prototype.handleEvent = function handleEvent(e) {
|
||||
dispatched = true;
|
||||
if (drop) {
|
||||
e.currentTarget.removeEventListener(e.type, this, false);
|
||||
} else {
|
||||
value = this.value;
|
||||
}
|
||||
};
|
||||
|
||||
function DOMMap() {
|
||||
counter++; // make id clashing highly improbable
|
||||
this.__ce__ = new Event(('@DOMMap:' + counter) + Math.random());
|
||||
}
|
||||
|
||||
DOMMap.prototype = {
|
||||
'constructor': DOMMap,
|
||||
'delete': function del(key) {
|
||||
return dispatch(key, this.__ce__, true), dispatched;
|
||||
},
|
||||
'get': function get(key) {
|
||||
dispatch(key, this.__ce__, false);
|
||||
var v = value;
|
||||
value = undefined;
|
||||
return v;
|
||||
},
|
||||
'has': function has(key) {
|
||||
return dispatch(key, this.__ce__, false), dispatched;
|
||||
},
|
||||
'set': function set(key, value) {
|
||||
dispatch(key, this.__ce__, true);
|
||||
key.addEventListener(this.__ce__.type, new Handler(value), false);
|
||||
return this;
|
||||
},
|
||||
};
|
||||
|
||||
return DOMMap;
|
||||
|
||||
}());
|
||||
|
||||
function Dict() {}
|
||||
Dict.prototype = (Object.create || Object)(null);
|
||||
|
||||
// https://dom.spec.whatwg.org/#interface-eventtarget
|
||||
|
||||
function createEventListener(type, callback, options) {
|
||||
function eventListener(e) {
|
||||
if (eventListener.once) {
|
||||
e.currentTarget.removeEventListener(
|
||||
e.type,
|
||||
callback,
|
||||
eventListener
|
||||
);
|
||||
eventListener.removed = true;
|
||||
}
|
||||
if (eventListener.passive) {
|
||||
e.preventDefault = createEventListener.preventDefault;
|
||||
}
|
||||
if (typeof eventListener.callback === 'function') {
|
||||
/* jshint validthis: true */
|
||||
eventListener.callback.call(this, e);
|
||||
} else if (eventListener.callback) {
|
||||
eventListener.callback.handleEvent(e);
|
||||
}
|
||||
if (eventListener.passive) {
|
||||
delete e.preventDefault;
|
||||
}
|
||||
}
|
||||
eventListener.type = type;
|
||||
eventListener.callback = callback;
|
||||
eventListener.capture = !!options.capture;
|
||||
eventListener.passive = !!options.passive;
|
||||
eventListener.once = !!options.once;
|
||||
// currently pointless but specs say to use it, so ...
|
||||
eventListener.removed = false;
|
||||
return eventListener;
|
||||
}
|
||||
|
||||
createEventListener.preventDefault = function preventDefault() {};
|
||||
|
||||
var
|
||||
Event = global.CustomEvent,
|
||||
dE = global.dispatchEvent,
|
||||
aEL = global.addEventListener,
|
||||
rEL = global.removeEventListener,
|
||||
counter = 0,
|
||||
increment = function () { counter++; },
|
||||
indexOf = [].indexOf || function indexOf(value){
|
||||
var length = this.length;
|
||||
while(length--) {
|
||||
if (this[length] === value) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return length;
|
||||
},
|
||||
getListenerKey = function (options) {
|
||||
return ''.concat(
|
||||
options.capture ? '1' : '0',
|
||||
options.passive ? '1' : '0',
|
||||
options.once ? '1' : '0'
|
||||
);
|
||||
},
|
||||
augment
|
||||
;
|
||||
|
||||
try {
|
||||
aEL('_', increment, {once: true});
|
||||
dE(new Event('_'));
|
||||
dE(new Event('_'));
|
||||
rEL('_', increment, {once: true});
|
||||
} catch(o_O) {}
|
||||
|
||||
if (counter !== 1) {
|
||||
(function () {
|
||||
var dm = new DOMMap();
|
||||
function createAEL(aEL) {
|
||||
return function addEventListener(type, handler, options) {
|
||||
if (options && typeof options !== 'boolean') {
|
||||
var
|
||||
info = dm.get(this),
|
||||
key = getListenerKey(options),
|
||||
i, tmp, wrap
|
||||
;
|
||||
if (!info) dm.set(this, (info = new Dict()));
|
||||
if (!(type in info)) info[type] = {
|
||||
handler: [],
|
||||
wrap: []
|
||||
};
|
||||
tmp = info[type];
|
||||
i = indexOf.call(tmp.handler, handler);
|
||||
if (i < 0) {
|
||||
i = tmp.handler.push(handler) - 1;
|
||||
tmp.wrap[i] = (wrap = new Dict());
|
||||
} else {
|
||||
wrap = tmp.wrap[i];
|
||||
}
|
||||
if (!(key in wrap)) {
|
||||
wrap[key] = createEventListener(type, handler, options);
|
||||
aEL.call(this, type, wrap[key], wrap[key].capture);
|
||||
}
|
||||
} else {
|
||||
aEL.call(this, type, handler, options);
|
||||
}
|
||||
};
|
||||
}
|
||||
function createREL(rEL) {
|
||||
return function removeEventListener(type, handler, options) {
|
||||
if (options && typeof options !== 'boolean') {
|
||||
var
|
||||
info = dm.get(this),
|
||||
key, i, tmp, wrap
|
||||
;
|
||||
if (info && (type in info)) {
|
||||
tmp = info[type];
|
||||
i = indexOf.call(tmp.handler, handler);
|
||||
if (-1 < i) {
|
||||
key = getListenerKey(options);
|
||||
wrap = tmp.wrap[i];
|
||||
if (key in wrap) {
|
||||
rEL.call(this, type, wrap[key], wrap[key].capture);
|
||||
delete wrap[key];
|
||||
// return if there are other wraps
|
||||
for (key in wrap) return;
|
||||
// otherwise remove all the things
|
||||
tmp.handler.splice(i, 1);
|
||||
tmp.wrap.splice(i, 1);
|
||||
// if there are no other handlers
|
||||
if (tmp.handler.length === 0)
|
||||
// drop the info[type] entirely
|
||||
delete info[type];
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
rEL.call(this, type, handler, options);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
augment = function (Constructor) {
|
||||
if (!Constructor) return;
|
||||
var proto = Constructor.prototype;
|
||||
proto.addEventListener = createAEL(proto.addEventListener);
|
||||
proto.removeEventListener = createREL(proto.removeEventListener);
|
||||
};
|
||||
|
||||
if (global.EventTarget) {
|
||||
augment(EventTarget);
|
||||
} else {
|
||||
augment(global.Text);
|
||||
augment(global.Element || global.HTMLElement);
|
||||
augment(global.HTMLDocument);
|
||||
augment(global.Window || {prototype:global});
|
||||
augment(global.XMLHttpRequest);
|
||||
}
|
||||
|
||||
}());
|
||||
}
|
||||
|
||||
}(window));
|
||||
330
tgui/packages/tgui/polyfills/html5shiv.js
vendored
330
tgui/packages/tgui/polyfills/html5shiv.js
vendored
@@ -1,330 +0,0 @@
|
||||
/**
|
||||
* @file
|
||||
* @copyright 2014 Alexander Farkas
|
||||
* @license MIT
|
||||
*/
|
||||
|
||||
/* eslint-disable */
|
||||
(function(window, document) {
|
||||
/*jshint evil:true */
|
||||
/** version */
|
||||
var version = '3.7.3';
|
||||
|
||||
/** Preset options */
|
||||
var options = window.html5 || {};
|
||||
|
||||
/** Used to skip problem elements */
|
||||
var reSkip = /^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i;
|
||||
|
||||
/** Not all elements can be cloned in IE **/
|
||||
var saveClones = /^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i;
|
||||
|
||||
/** Detect whether the browser supports default html5 styles */
|
||||
var supportsHtml5Styles;
|
||||
|
||||
/** Name of the expando, to work with multiple documents or to re-shiv one document */
|
||||
var expando = '_html5shiv';
|
||||
|
||||
/** The id for the the documents expando */
|
||||
var expanID = 0;
|
||||
|
||||
/** Cached data for each document */
|
||||
var expandoData = {};
|
||||
|
||||
/** Detect whether the browser supports unknown elements */
|
||||
var supportsUnknownElements;
|
||||
|
||||
(function() {
|
||||
try {
|
||||
var a = document.createElement('a');
|
||||
a.innerHTML = '<xyz></xyz>';
|
||||
//if the hidden property is implemented we can assume, that the browser supports basic HTML5 Styles
|
||||
supportsHtml5Styles = ('hidden' in a);
|
||||
|
||||
supportsUnknownElements = a.childNodes.length == 1 || (function() {
|
||||
// assign a false positive if unable to shiv
|
||||
(document.createElement)('a');
|
||||
var frag = document.createDocumentFragment();
|
||||
return (
|
||||
typeof frag.cloneNode == 'undefined' ||
|
||||
typeof frag.createDocumentFragment == 'undefined' ||
|
||||
typeof frag.createElement == 'undefined'
|
||||
);
|
||||
}());
|
||||
} catch(e) {
|
||||
// assign a false positive if detection fails => unable to shiv
|
||||
supportsHtml5Styles = true;
|
||||
supportsUnknownElements = true;
|
||||
}
|
||||
|
||||
}());
|
||||
|
||||
/*--------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Creates a style sheet with the given CSS text and adds it to the document.
|
||||
* @private
|
||||
* @param {Document} ownerDocument The document.
|
||||
* @param {String} cssText The CSS text.
|
||||
* @returns {StyleSheet} The style element.
|
||||
*/
|
||||
function addStyleSheet(ownerDocument, cssText) {
|
||||
var p = ownerDocument.createElement('p'),
|
||||
parent = ownerDocument.getElementsByTagName('head')[0] || ownerDocument.documentElement;
|
||||
|
||||
p.innerHTML = 'x<style>' + cssText + '</style>';
|
||||
return parent.insertBefore(p.lastChild, parent.firstChild);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the value of `html5.elements` as an array.
|
||||
* @private
|
||||
* @returns {Array} An array of shived element node names.
|
||||
*/
|
||||
function getElements() {
|
||||
var elements = html5.elements;
|
||||
return typeof elements == 'string' ? elements.split(' ') : elements;
|
||||
}
|
||||
|
||||
/**
|
||||
* Extends the built-in list of html5 elements
|
||||
* @memberOf html5
|
||||
* @param {String|Array} newElements whitespace separated list or array of new element names to shiv
|
||||
* @param {Document} ownerDocument The context document.
|
||||
*/
|
||||
function addElements(newElements, ownerDocument) {
|
||||
var elements = html5.elements;
|
||||
if(typeof elements != 'string'){
|
||||
elements = elements.join(' ');
|
||||
}
|
||||
if(typeof newElements != 'string'){
|
||||
newElements = newElements.join(' ');
|
||||
}
|
||||
html5.elements = elements +' '+ newElements;
|
||||
shivDocument(ownerDocument);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the data associated to the given document
|
||||
* @private
|
||||
* @param {Document} ownerDocument The document.
|
||||
* @returns {Object} An object of data.
|
||||
*/
|
||||
function getExpandoData(ownerDocument) {
|
||||
var data = expandoData[ownerDocument[expando]];
|
||||
if (!data) {
|
||||
data = {};
|
||||
expanID++;
|
||||
ownerDocument[expando] = expanID;
|
||||
expandoData[expanID] = data;
|
||||
}
|
||||
return data;
|
||||
}
|
||||
|
||||
/**
|
||||
* returns a shived element for the given nodeName and document
|
||||
* @memberOf html5
|
||||
* @param {String} nodeName name of the element
|
||||
* @param {Document|DocumentFragment} ownerDocument The context document.
|
||||
* @returns {Object} The shived element.
|
||||
*/
|
||||
function createElement(nodeName, ownerDocument, data){
|
||||
if (!ownerDocument) {
|
||||
ownerDocument = document;
|
||||
}
|
||||
if(supportsUnknownElements){
|
||||
return ownerDocument.createElement(nodeName);
|
||||
}
|
||||
if (!data) {
|
||||
data = getExpandoData(ownerDocument);
|
||||
}
|
||||
var node;
|
||||
|
||||
if (data.cache[nodeName]) {
|
||||
node = data.cache[nodeName].cloneNode();
|
||||
} else if (saveClones.test(nodeName)) {
|
||||
node = (data.cache[nodeName] = data.createElem(nodeName)).cloneNode();
|
||||
} else {
|
||||
node = data.createElem(nodeName);
|
||||
}
|
||||
|
||||
// Avoid adding some elements to fragments in IE < 9 because
|
||||
// * Attributes like `name` or `type` cannot be set/changed once an element
|
||||
// is inserted into a document/fragment
|
||||
// * Link elements with `src` attributes that are inaccessible, as with
|
||||
// a 403 response, will cause the tab/window to crash
|
||||
// * Script elements appended to fragments will execute when their `src`
|
||||
// or `text` property is set
|
||||
return node.canHaveChildren && !reSkip.test(nodeName) && !node.tagUrn ? data.frag.appendChild(node) : node;
|
||||
}
|
||||
|
||||
/**
|
||||
* returns a shived DocumentFragment for the given document
|
||||
* @memberOf html5
|
||||
* @param {Document} ownerDocument The context document.
|
||||
* @returns {Object} The shived DocumentFragment.
|
||||
*/
|
||||
function createDocumentFragment(ownerDocument, data){
|
||||
if (!ownerDocument) {
|
||||
ownerDocument = document;
|
||||
}
|
||||
if(supportsUnknownElements){
|
||||
return ownerDocument.createDocumentFragment();
|
||||
}
|
||||
data = data || getExpandoData(ownerDocument);
|
||||
var clone = data.frag.cloneNode(),
|
||||
i = 0,
|
||||
elems = getElements(),
|
||||
l = elems.length;
|
||||
for(;i<l;i++){
|
||||
clone.createElement(elems[i]);
|
||||
}
|
||||
return clone;
|
||||
}
|
||||
|
||||
/**
|
||||
* Shivs the `createElement` and `createDocumentFragment` methods of the document.
|
||||
* @private
|
||||
* @param {Document|DocumentFragment} ownerDocument The document.
|
||||
* @param {Object} data of the document.
|
||||
*/
|
||||
function shivMethods(ownerDocument, data) {
|
||||
if (!data.cache) {
|
||||
data.cache = {};
|
||||
data.createElem = ownerDocument.createElement;
|
||||
data.createFrag = ownerDocument.createDocumentFragment;
|
||||
data.frag = data.createFrag();
|
||||
}
|
||||
|
||||
|
||||
ownerDocument.createElement = function(nodeName) {
|
||||
//abort shiv
|
||||
if (!html5.shivMethods) {
|
||||
return data.createElem(nodeName);
|
||||
}
|
||||
return createElement(nodeName, ownerDocument, data);
|
||||
};
|
||||
|
||||
ownerDocument.createDocumentFragment = Function('h,f', 'return function(){' +
|
||||
'var n=f.cloneNode(),c=n.createElement;' +
|
||||
'h.shivMethods&&(' +
|
||||
// unroll the `createElement` calls
|
||||
getElements().join().replace(/[\w\-:]+/g, function(nodeName) {
|
||||
data.createElem(nodeName);
|
||||
data.frag.createElement(nodeName);
|
||||
return 'c("' + nodeName + '")';
|
||||
}) +
|
||||
');return n}'
|
||||
)(html5, data.frag);
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Shivs the given document.
|
||||
* @memberOf html5
|
||||
* @param {Document} ownerDocument The document to shiv.
|
||||
* @returns {Document} The shived document.
|
||||
*/
|
||||
function shivDocument(ownerDocument) {
|
||||
if (!ownerDocument) {
|
||||
ownerDocument = document;
|
||||
}
|
||||
var data = getExpandoData(ownerDocument);
|
||||
|
||||
if (html5.shivCSS && !supportsHtml5Styles && !data.hasCSS) {
|
||||
data.hasCSS = !!addStyleSheet(ownerDocument,
|
||||
// corrects block display not defined in IE6/7/8/9
|
||||
'article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}' +
|
||||
// adds styling not present in IE6/7/8/9
|
||||
'mark{background:#FF0;color:#000}' +
|
||||
// hides non-rendered elements
|
||||
'template{display:none}'
|
||||
);
|
||||
}
|
||||
if (!supportsUnknownElements) {
|
||||
shivMethods(ownerDocument, data);
|
||||
}
|
||||
return ownerDocument;
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* The `html5` object is exposed so that more elements can be shived and
|
||||
* existing shiving can be detected on iframes.
|
||||
* @type Object
|
||||
* @example
|
||||
*
|
||||
* // options can be changed before the script is included
|
||||
* html5 = { 'elements': 'mark section', 'shivCSS': false, 'shivMethods': false };
|
||||
*/
|
||||
var html5 = {
|
||||
|
||||
/**
|
||||
* An array or space separated string of node names of the elements to shiv.
|
||||
* @memberOf html5
|
||||
* @type Array|String
|
||||
*/
|
||||
'elements': options.elements || 'abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output picture progress section summary template time video',
|
||||
|
||||
/**
|
||||
* current version of html5shiv
|
||||
*/
|
||||
'version': version,
|
||||
|
||||
/**
|
||||
* A flag to indicate that the HTML5 style sheet should be inserted.
|
||||
* @memberOf html5
|
||||
* @type Boolean
|
||||
*/
|
||||
'shivCSS': (options.shivCSS !== false),
|
||||
|
||||
/**
|
||||
* Is equal to true if a browser supports creating unknown/HTML5 elements
|
||||
* @memberOf html5
|
||||
* @type boolean
|
||||
*/
|
||||
'supportsUnknownElements': supportsUnknownElements,
|
||||
|
||||
/**
|
||||
* A flag to indicate that the document's `createElement` and `createDocumentFragment`
|
||||
* methods should be overwritten.
|
||||
* @memberOf html5
|
||||
* @type Boolean
|
||||
*/
|
||||
'shivMethods': (options.shivMethods !== false),
|
||||
|
||||
/**
|
||||
* A string to describe the type of `html5` object ("default" or "default print").
|
||||
* @memberOf html5
|
||||
* @type String
|
||||
*/
|
||||
'type': 'default',
|
||||
|
||||
// shivs the document according to the specified `html5` object options
|
||||
'shivDocument': shivDocument,
|
||||
|
||||
//creates a shived element
|
||||
createElement: createElement,
|
||||
|
||||
//creates a shived documentFragment
|
||||
createDocumentFragment: createDocumentFragment,
|
||||
|
||||
//extends list of elements
|
||||
addElements: addElements
|
||||
};
|
||||
|
||||
/*--------------------------------------------------------------------------*/
|
||||
|
||||
// expose html5
|
||||
window.html5 = html5;
|
||||
|
||||
// shiv the document
|
||||
shivDocument(document);
|
||||
|
||||
if(typeof module == 'object' && module.exports){
|
||||
module.exports = html5;
|
||||
}
|
||||
|
||||
}(window, document));
|
||||
@@ -1,836 +0,0 @@
|
||||
/**
|
||||
* @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));
|
||||
@@ -1,10 +0,0 @@
|
||||
/**
|
||||
* @file
|
||||
* @copyright 2020 Aleksej Komarov
|
||||
* @license MIT
|
||||
*/
|
||||
|
||||
// Inferno needs Int32Array, and it is not covered by core-js.
|
||||
if (!window.Int32Array) {
|
||||
window.Int32Array = Array;
|
||||
}
|
||||
Reference in New Issue
Block a user