mirror of
https://github.com/jellyfin/jellyfin-web
synced 2025-03-30 19:56:21 +00:00
extract scripts
This commit is contained in:
Luke Pulverenti
parent
d84e09e501
commit
6c97b11f21
41 changed files with 8363 additions and 204 deletions
956
dashboard-ui/thirdparty/webcomponentsjs/CustomElements.js
vendored
Normal file
956
dashboard-ui/thirdparty/webcomponentsjs/CustomElements.js
vendored
Normal file
|
|
@ -0,0 +1,956 @@
|
|||
/**
|
||||
* @license
|
||||
* Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
|
||||
* This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
|
||||
* The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
|
||||
* The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
|
||||
* Code distributed by Google as part of the polymer project is also
|
||||
* subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
|
||||
*/
|
||||
// @version 0.7.3
|
||||
if (typeof WeakMap === "undefined") {
|
||||
(function() {
|
||||
var defineProperty = Object.defineProperty;
|
||||
var counter = Date.now() % 1e9;
|
||||
var WeakMap = function() {
|
||||
this.name = "__st" + (Math.random() * 1e9 >>> 0) + (counter++ + "__");
|
||||
};
|
||||
WeakMap.prototype = {
|
||||
set: function(key, value) {
|
||||
var entry = key[this.name];
|
||||
if (entry && entry[0] === key) entry[1] = value; else defineProperty(key, this.name, {
|
||||
value: [ key, value ],
|
||||
writable: true
|
||||
});
|
||||
return this;
|
||||
},
|
||||
get: function(key) {
|
||||
var entry;
|
||||
return (entry = key[this.name]) && entry[0] === key ? entry[1] : undefined;
|
||||
},
|
||||
"delete": function(key) {
|
||||
var entry = key[this.name];
|
||||
if (!entry || entry[0] !== key) return false;
|
||||
entry[0] = entry[1] = undefined;
|
||||
return true;
|
||||
},
|
||||
has: function(key) {
|
||||
var entry = key[this.name];
|
||||
if (!entry) return false;
|
||||
return entry[0] === key;
|
||||
}
|
||||
};
|
||||
window.WeakMap = WeakMap;
|
||||
})();
|
||||
}
|
||||
|
||||
(function(global) {
|
||||
var registrationsTable = new WeakMap();
|
||||
var setImmediate;
|
||||
if (/Trident|Edge/.test(navigator.userAgent)) {
|
||||
setImmediate = setTimeout;
|
||||
} else if (window.setImmediate) {
|
||||
setImmediate = window.setImmediate;
|
||||
} else {
|
||||
var setImmediateQueue = [];
|
||||
var sentinel = String(Math.random());
|
||||
window.addEventListener("message", function(e) {
|
||||
if (e.data === sentinel) {
|
||||
var queue = setImmediateQueue;
|
||||
setImmediateQueue = [];
|
||||
queue.forEach(function(func) {
|
||||
func();
|
||||
});
|
||||
}
|
||||
});
|
||||
setImmediate = function(func) {
|
||||
setImmediateQueue.push(func);
|
||||
window.postMessage(sentinel, "*");
|
||||
};
|
||||
}
|
||||
var isScheduled = false;
|
||||
var scheduledObservers = [];
|
||||
function scheduleCallback(observer) {
|
||||
scheduledObservers.push(observer);
|
||||
if (!isScheduled) {
|
||||
isScheduled = true;
|
||||
setImmediate(dispatchCallbacks);
|
||||
}
|
||||
}
|
||||
function wrapIfNeeded(node) {
|
||||
return window.ShadowDOMPolyfill && window.ShadowDOMPolyfill.wrapIfNeeded(node) || node;
|
||||
}
|
||||
function dispatchCallbacks() {
|
||||
isScheduled = false;
|
||||
var observers = scheduledObservers;
|
||||
scheduledObservers = [];
|
||||
observers.sort(function(o1, o2) {
|
||||
return o1.uid_ - o2.uid_;
|
||||
});
|
||||
var anyNonEmpty = false;
|
||||
observers.forEach(function(observer) {
|
||||
var queue = observer.takeRecords();
|
||||
removeTransientObserversFor(observer);
|
||||
if (queue.length) {
|
||||
observer.callback_(queue, observer);
|
||||
anyNonEmpty = true;
|
||||
}
|
||||
});
|
||||
if (anyNonEmpty) dispatchCallbacks();
|
||||
}
|
||||
function removeTransientObserversFor(observer) {
|
||||
observer.nodes_.forEach(function(node) {
|
||||
var registrations = registrationsTable.get(node);
|
||||
if (!registrations) return;
|
||||
registrations.forEach(function(registration) {
|
||||
if (registration.observer === observer) registration.removeTransientObservers();
|
||||
});
|
||||
});
|
||||
}
|
||||
function forEachAncestorAndObserverEnqueueRecord(target, callback) {
|
||||
for (var node = target; node; node = node.parentNode) {
|
||||
var registrations = registrationsTable.get(node);
|
||||
if (registrations) {
|
||||
for (var j = 0; j < registrations.length; j++) {
|
||||
var registration = registrations[j];
|
||||
var options = registration.options;
|
||||
if (node !== target && !options.subtree) continue;
|
||||
var record = callback(options);
|
||||
if (record) registration.enqueue(record);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
var uidCounter = 0;
|
||||
function JsMutationObserver(callback) {
|
||||
this.callback_ = callback;
|
||||
this.nodes_ = [];
|
||||
this.records_ = [];
|
||||
this.uid_ = ++uidCounter;
|
||||
}
|
||||
JsMutationObserver.prototype = {
|
||||
observe: function(target, options) {
|
||||
target = wrapIfNeeded(target);
|
||||
if (!options.childList && !options.attributes && !options.characterData || options.attributeOldValue && !options.attributes || options.attributeFilter && options.attributeFilter.length && !options.attributes || options.characterDataOldValue && !options.characterData) {
|
||||
throw new SyntaxError();
|
||||
}
|
||||
var registrations = registrationsTable.get(target);
|
||||
if (!registrations) registrationsTable.set(target, registrations = []);
|
||||
var registration;
|
||||
for (var i = 0; i < registrations.length; i++) {
|
||||
if (registrations[i].observer === this) {
|
||||
registration = registrations[i];
|
||||
registration.removeListeners();
|
||||
registration.options = options;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!registration) {
|
||||
registration = new Registration(this, target, options);
|
||||
registrations.push(registration);
|
||||
this.nodes_.push(target);
|
||||
}
|
||||
registration.addListeners();
|
||||
},
|
||||
disconnect: function() {
|
||||
this.nodes_.forEach(function(node) {
|
||||
var registrations = registrationsTable.get(node);
|
||||
for (var i = 0; i < registrations.length; i++) {
|
||||
var registration = registrations[i];
|
||||
if (registration.observer === this) {
|
||||
registration.removeListeners();
|
||||
registrations.splice(i, 1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}, this);
|
||||
this.records_ = [];
|
||||
},
|
||||
takeRecords: function() {
|
||||
var copyOfRecords = this.records_;
|
||||
this.records_ = [];
|
||||
return copyOfRecords;
|
||||
}
|
||||
};
|
||||
function MutationRecord(type, target) {
|
||||
this.type = type;
|
||||
this.target = target;
|
||||
this.addedNodes = [];
|
||||
this.removedNodes = [];
|
||||
this.previousSibling = null;
|
||||
this.nextSibling = null;
|
||||
this.attributeName = null;
|
||||
this.attributeNamespace = null;
|
||||
this.oldValue = null;
|
||||
}
|
||||
function copyMutationRecord(original) {
|
||||
var record = new MutationRecord(original.type, original.target);
|
||||
record.addedNodes = original.addedNodes.slice();
|
||||
record.removedNodes = original.removedNodes.slice();
|
||||
record.previousSibling = original.previousSibling;
|
||||
record.nextSibling = original.nextSibling;
|
||||
record.attributeName = original.attributeName;
|
||||
record.attributeNamespace = original.attributeNamespace;
|
||||
record.oldValue = original.oldValue;
|
||||
return record;
|
||||
}
|
||||
var currentRecord, recordWithOldValue;
|
||||
function getRecord(type, target) {
|
||||
return currentRecord = new MutationRecord(type, target);
|
||||
}
|
||||
function getRecordWithOldValue(oldValue) {
|
||||
if (recordWithOldValue) return recordWithOldValue;
|
||||
recordWithOldValue = copyMutationRecord(currentRecord);
|
||||
recordWithOldValue.oldValue = oldValue;
|
||||
return recordWithOldValue;
|
||||
}
|
||||
function clearRecords() {
|
||||
currentRecord = recordWithOldValue = undefined;
|
||||
}
|
||||
function recordRepresentsCurrentMutation(record) {
|
||||
return record === recordWithOldValue || record === currentRecord;
|
||||
}
|
||||
function selectRecord(lastRecord, newRecord) {
|
||||
if (lastRecord === newRecord) return lastRecord;
|
||||
if (recordWithOldValue && recordRepresentsCurrentMutation(lastRecord)) return recordWithOldValue;
|
||||
return null;
|
||||
}
|
||||
function Registration(observer, target, options) {
|
||||
this.observer = observer;
|
||||
this.target = target;
|
||||
this.options = options;
|
||||
this.transientObservedNodes = [];
|
||||
}
|
||||
Registration.prototype = {
|
||||
enqueue: function(record) {
|
||||
var records = this.observer.records_;
|
||||
var length = records.length;
|
||||
if (records.length > 0) {
|
||||
var lastRecord = records[length - 1];
|
||||
var recordToReplaceLast = selectRecord(lastRecord, record);
|
||||
if (recordToReplaceLast) {
|
||||
records[length - 1] = recordToReplaceLast;
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
scheduleCallback(this.observer);
|
||||
}
|
||||
records[length] = record;
|
||||
},
|
||||
addListeners: function() {
|
||||
this.addListeners_(this.target);
|
||||
},
|
||||
addListeners_: function(node) {
|
||||
var options = this.options;
|
||||
if (options.attributes) node.addEventListener("DOMAttrModified", this, true);
|
||||
if (options.characterData) node.addEventListener("DOMCharacterDataModified", this, true);
|
||||
if (options.childList) node.addEventListener("DOMNodeInserted", this, true);
|
||||
if (options.childList || options.subtree) node.addEventListener("DOMNodeRemoved", this, true);
|
||||
},
|
||||
removeListeners: function() {
|
||||
this.removeListeners_(this.target);
|
||||
},
|
||||
removeListeners_: function(node) {
|
||||
var options = this.options;
|
||||
if (options.attributes) node.removeEventListener("DOMAttrModified", this, true);
|
||||
if (options.characterData) node.removeEventListener("DOMCharacterDataModified", this, true);
|
||||
if (options.childList) node.removeEventListener("DOMNodeInserted", this, true);
|
||||
if (options.childList || options.subtree) node.removeEventListener("DOMNodeRemoved", this, true);
|
||||
},
|
||||
addTransientObserver: function(node) {
|
||||
if (node === this.target) return;
|
||||
this.addListeners_(node);
|
||||
this.transientObservedNodes.push(node);
|
||||
var registrations = registrationsTable.get(node);
|
||||
if (!registrations) registrationsTable.set(node, registrations = []);
|
||||
registrations.push(this);
|
||||
},
|
||||
removeTransientObservers: function() {
|
||||
var transientObservedNodes = this.transientObservedNodes;
|
||||
this.transientObservedNodes = [];
|
||||
transientObservedNodes.forEach(function(node) {
|
||||
this.removeListeners_(node);
|
||||
var registrations = registrationsTable.get(node);
|
||||
for (var i = 0; i < registrations.length; i++) {
|
||||
if (registrations[i] === this) {
|
||||
registrations.splice(i, 1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}, this);
|
||||
},
|
||||
handleEvent: function(e) {
|
||||
e.stopImmediatePropagation();
|
||||
switch (e.type) {
|
||||
case "DOMAttrModified":
|
||||
var name = e.attrName;
|
||||
var namespace = e.relatedNode.namespaceURI;
|
||||
var target = e.target;
|
||||
var record = new getRecord("attributes", target);
|
||||
record.attributeName = name;
|
||||
record.attributeNamespace = namespace;
|
||||
var oldValue = e.attrChange === MutationEvent.ADDITION ? null : e.prevValue;
|
||||
forEachAncestorAndObserverEnqueueRecord(target, function(options) {
|
||||
if (!options.attributes) return;
|
||||
if (options.attributeFilter && options.attributeFilter.length && options.attributeFilter.indexOf(name) === -1 && options.attributeFilter.indexOf(namespace) === -1) {
|
||||
return;
|
||||
}
|
||||
if (options.attributeOldValue) return getRecordWithOldValue(oldValue);
|
||||
return record;
|
||||
});
|
||||
break;
|
||||
|
||||
case "DOMCharacterDataModified":
|
||||
var target = e.target;
|
||||
var record = getRecord("characterData", target);
|
||||
var oldValue = e.prevValue;
|
||||
forEachAncestorAndObserverEnqueueRecord(target, function(options) {
|
||||
if (!options.characterData) return;
|
||||
if (options.characterDataOldValue) return getRecordWithOldValue(oldValue);
|
||||
return record;
|
||||
});
|
||||
break;
|
||||
|
||||
case "DOMNodeRemoved":
|
||||
this.addTransientObserver(e.target);
|
||||
|
||||
case "DOMNodeInserted":
|
||||
var changedNode = e.target;
|
||||
var addedNodes, removedNodes;
|
||||
if (e.type === "DOMNodeInserted") {
|
||||
addedNodes = [ changedNode ];
|
||||
removedNodes = [];
|
||||
} else {
|
||||
addedNodes = [];
|
||||
removedNodes = [ changedNode ];
|
||||
}
|
||||
var previousSibling = changedNode.previousSibling;
|
||||
var nextSibling = changedNode.nextSibling;
|
||||
var record = getRecord("childList", e.target.parentNode);
|
||||
record.addedNodes = addedNodes;
|
||||
record.removedNodes = removedNodes;
|
||||
record.previousSibling = previousSibling;
|
||||
record.nextSibling = nextSibling;
|
||||
forEachAncestorAndObserverEnqueueRecord(e.relatedNode, function(options) {
|
||||
if (!options.childList) return;
|
||||
return record;
|
||||
});
|
||||
}
|
||||
clearRecords();
|
||||
}
|
||||
};
|
||||
global.JsMutationObserver = JsMutationObserver;
|
||||
if (!global.MutationObserver) global.MutationObserver = JsMutationObserver;
|
||||
})(this);
|
||||
|
||||
window.CustomElements = window.CustomElements || {
|
||||
flags: {}
|
||||
};
|
||||
|
||||
(function(scope) {
|
||||
var flags = scope.flags;
|
||||
var modules = [];
|
||||
var addModule = function(module) {
|
||||
modules.push(module);
|
||||
};
|
||||
var initializeModules = function() {
|
||||
modules.forEach(function(module) {
|
||||
module(scope);
|
||||
});
|
||||
};
|
||||
scope.addModule = addModule;
|
||||
scope.initializeModules = initializeModules;
|
||||
scope.hasNative = Boolean(document.registerElement);
|
||||
scope.useNative = !flags.register && scope.hasNative && !window.ShadowDOMPolyfill && (!window.HTMLImports || HTMLImports.useNative);
|
||||
})(window.CustomElements);
|
||||
|
||||
window.CustomElements.addModule(function(scope) {
|
||||
var IMPORT_LINK_TYPE = window.HTMLImports ? HTMLImports.IMPORT_LINK_TYPE : "none";
|
||||
function forSubtree(node, cb) {
|
||||
findAllElements(node, function(e) {
|
||||
if (cb(e)) {
|
||||
return true;
|
||||
}
|
||||
forRoots(e, cb);
|
||||
});
|
||||
forRoots(node, cb);
|
||||
}
|
||||
function findAllElements(node, find, data) {
|
||||
var e = node.firstElementChild;
|
||||
if (!e) {
|
||||
e = node.firstChild;
|
||||
while (e && e.nodeType !== Node.ELEMENT_NODE) {
|
||||
e = e.nextSibling;
|
||||
}
|
||||
}
|
||||
while (e) {
|
||||
if (find(e, data) !== true) {
|
||||
findAllElements(e, find, data);
|
||||
}
|
||||
e = e.nextElementSibling;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
function forRoots(node, cb) {
|
||||
var root = node.shadowRoot;
|
||||
while (root) {
|
||||
forSubtree(root, cb);
|
||||
root = root.olderShadowRoot;
|
||||
}
|
||||
}
|
||||
function forDocumentTree(doc, cb) {
|
||||
_forDocumentTree(doc, cb, []);
|
||||
}
|
||||
function _forDocumentTree(doc, cb, processingDocuments) {
|
||||
doc = wrap(doc);
|
||||
if (processingDocuments.indexOf(doc) >= 0) {
|
||||
return;
|
||||
}
|
||||
processingDocuments.push(doc);
|
||||
var imports = doc.querySelectorAll("link[rel=" + IMPORT_LINK_TYPE + "]");
|
||||
for (var i = 0, l = imports.length, n; i < l && (n = imports[i]); i++) {
|
||||
if (n.import) {
|
||||
_forDocumentTree(n.import, cb, processingDocuments);
|
||||
}
|
||||
}
|
||||
cb(doc);
|
||||
}
|
||||
scope.forDocumentTree = forDocumentTree;
|
||||
scope.forSubtree = forSubtree;
|
||||
});
|
||||
|
||||
window.CustomElements.addModule(function(scope) {
|
||||
var flags = scope.flags;
|
||||
var forSubtree = scope.forSubtree;
|
||||
var forDocumentTree = scope.forDocumentTree;
|
||||
function addedNode(node) {
|
||||
return added(node) || addedSubtree(node);
|
||||
}
|
||||
function added(node) {
|
||||
if (scope.upgrade(node)) {
|
||||
return true;
|
||||
}
|
||||
attached(node);
|
||||
}
|
||||
function addedSubtree(node) {
|
||||
forSubtree(node, function(e) {
|
||||
if (added(e)) {
|
||||
return true;
|
||||
}
|
||||
});
|
||||
}
|
||||
function attachedNode(node) {
|
||||
attached(node);
|
||||
if (inDocument(node)) {
|
||||
forSubtree(node, function(e) {
|
||||
attached(e);
|
||||
});
|
||||
}
|
||||
}
|
||||
var hasPolyfillMutations = !window.MutationObserver || window.MutationObserver === window.JsMutationObserver;
|
||||
scope.hasPolyfillMutations = hasPolyfillMutations;
|
||||
var isPendingMutations = false;
|
||||
var pendingMutations = [];
|
||||
function deferMutation(fn) {
|
||||
pendingMutations.push(fn);
|
||||
if (!isPendingMutations) {
|
||||
isPendingMutations = true;
|
||||
setTimeout(takeMutations);
|
||||
}
|
||||
}
|
||||
function takeMutations() {
|
||||
isPendingMutations = false;
|
||||
var $p = pendingMutations;
|
||||
for (var i = 0, l = $p.length, p; i < l && (p = $p[i]); i++) {
|
||||
p();
|
||||
}
|
||||
pendingMutations = [];
|
||||
}
|
||||
function attached(element) {
|
||||
if (hasPolyfillMutations) {
|
||||
deferMutation(function() {
|
||||
_attached(element);
|
||||
});
|
||||
} else {
|
||||
_attached(element);
|
||||
}
|
||||
}
|
||||
function _attached(element) {
|
||||
if (element.__upgraded__ && (element.attachedCallback || element.detachedCallback)) {
|
||||
if (!element.__attached && inDocument(element)) {
|
||||
element.__attached = true;
|
||||
if (element.attachedCallback) {
|
||||
element.attachedCallback();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
function detachedNode(node) {
|
||||
detached(node);
|
||||
forSubtree(node, function(e) {
|
||||
detached(e);
|
||||
});
|
||||
}
|
||||
function detached(element) {
|
||||
if (hasPolyfillMutations) {
|
||||
deferMutation(function() {
|
||||
_detached(element);
|
||||
});
|
||||
} else {
|
||||
_detached(element);
|
||||
}
|
||||
}
|
||||
function _detached(element) {
|
||||
if (element.__upgraded__ && (element.attachedCallback || element.detachedCallback)) {
|
||||
if (element.__attached && !inDocument(element)) {
|
||||
element.__attached = false;
|
||||
if (element.detachedCallback) {
|
||||
element.detachedCallback();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
function inDocument(element) {
|
||||
var p = element;
|
||||
var doc = wrap(document);
|
||||
while (p) {
|
||||
if (p == doc) {
|
||||
return true;
|
||||
}
|
||||
p = p.parentNode || p.nodeType === Node.DOCUMENT_FRAGMENT_NODE && p.host;
|
||||
}
|
||||
}
|
||||
function watchShadow(node) {
|
||||
if (node.shadowRoot && !node.shadowRoot.__watched) {
|
||||
flags.dom && console.log("watching shadow-root for: ", node.localName);
|
||||
var root = node.shadowRoot;
|
||||
while (root) {
|
||||
observe(root);
|
||||
root = root.olderShadowRoot;
|
||||
}
|
||||
}
|
||||
}
|
||||
function handler(mutations) {
|
||||
if (flags.dom) {
|
||||
var mx = mutations[0];
|
||||
if (mx && mx.type === "childList" && mx.addedNodes) {
|
||||
if (mx.addedNodes) {
|
||||
var d = mx.addedNodes[0];
|
||||
while (d && d !== document && !d.host) {
|
||||
d = d.parentNode;
|
||||
}
|
||||
var u = d && (d.URL || d._URL || d.host && d.host.localName) || "";
|
||||
u = u.split("/?").shift().split("/").pop();
|
||||
}
|
||||
}
|
||||
console.group("mutations (%d) [%s]", mutations.length, u || "");
|
||||
}
|
||||
mutations.forEach(function(mx) {
|
||||
if (mx.type === "childList") {
|
||||
forEach(mx.addedNodes, function(n) {
|
||||
if (!n.localName) {
|
||||
return;
|
||||
}
|
||||
addedNode(n);
|
||||
});
|
||||
forEach(mx.removedNodes, function(n) {
|
||||
if (!n.localName) {
|
||||
return;
|
||||
}
|
||||
detachedNode(n);
|
||||
});
|
||||
}
|
||||
});
|
||||
flags.dom && console.groupEnd();
|
||||
}
|
||||
function takeRecords(node) {
|
||||
node = wrap(node);
|
||||
if (!node) {
|
||||
node = wrap(document);
|
||||
}
|
||||
while (node.parentNode) {
|
||||
node = node.parentNode;
|
||||
}
|
||||
var observer = node.__observer;
|
||||
if (observer) {
|
||||
handler(observer.takeRecords());
|
||||
takeMutations();
|
||||
}
|
||||
}
|
||||
var forEach = Array.prototype.forEach.call.bind(Array.prototype.forEach);
|
||||
function observe(inRoot) {
|
||||
if (inRoot.__observer) {
|
||||
return;
|
||||
}
|
||||
var observer = new MutationObserver(handler);
|
||||
observer.observe(inRoot, {
|
||||
childList: true,
|
||||
subtree: true
|
||||
});
|
||||
inRoot.__observer = observer;
|
||||
}
|
||||
function upgradeDocument(doc) {
|
||||
doc = wrap(doc);
|
||||
flags.dom && console.group("upgradeDocument: ", doc.baseURI.split("/").pop());
|
||||
addedNode(doc);
|
||||
observe(doc);
|
||||
flags.dom && console.groupEnd();
|
||||
}
|
||||
function upgradeDocumentTree(doc) {
|
||||
forDocumentTree(doc, upgradeDocument);
|
||||
}
|
||||
var originalCreateShadowRoot = Element.prototype.createShadowRoot;
|
||||
if (originalCreateShadowRoot) {
|
||||
Element.prototype.createShadowRoot = function() {
|
||||
var root = originalCreateShadowRoot.call(this);
|
||||
CustomElements.watchShadow(this);
|
||||
return root;
|
||||
};
|
||||
}
|
||||
scope.watchShadow = watchShadow;
|
||||
scope.upgradeDocumentTree = upgradeDocumentTree;
|
||||
scope.upgradeSubtree = addedSubtree;
|
||||
scope.upgradeAll = addedNode;
|
||||
scope.attachedNode = attachedNode;
|
||||
scope.takeRecords = takeRecords;
|
||||
});
|
||||
|
||||
window.CustomElements.addModule(function(scope) {
|
||||
var flags = scope.flags;
|
||||
function upgrade(node) {
|
||||
if (!node.__upgraded__ && node.nodeType === Node.ELEMENT_NODE) {
|
||||
var is = node.getAttribute("is");
|
||||
var definition = scope.getRegisteredDefinition(is || node.localName);
|
||||
if (definition) {
|
||||
if (is && definition.tag == node.localName) {
|
||||
return upgradeWithDefinition(node, definition);
|
||||
} else if (!is && !definition.extends) {
|
||||
return upgradeWithDefinition(node, definition);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
function upgradeWithDefinition(element, definition) {
|
||||
flags.upgrade && console.group("upgrade:", element.localName);
|
||||
if (definition.is) {
|
||||
element.setAttribute("is", definition.is);
|
||||
}
|
||||
implementPrototype(element, definition);
|
||||
element.__upgraded__ = true;
|
||||
created(element);
|
||||
scope.attachedNode(element);
|
||||
scope.upgradeSubtree(element);
|
||||
flags.upgrade && console.groupEnd();
|
||||
return element;
|
||||
}
|
||||
function implementPrototype(element, definition) {
|
||||
if (Object.__proto__) {
|
||||
element.__proto__ = definition.prototype;
|
||||
} else {
|
||||
customMixin(element, definition.prototype, definition.native);
|
||||
element.__proto__ = definition.prototype;
|
||||
}
|
||||
}
|
||||
function customMixin(inTarget, inSrc, inNative) {
|
||||
var used = {};
|
||||
var p = inSrc;
|
||||
while (p !== inNative && p !== HTMLElement.prototype) {
|
||||
var keys = Object.getOwnPropertyNames(p);
|
||||
for (var i = 0, k; k = keys[i]; i++) {
|
||||
if (!used[k]) {
|
||||
Object.defineProperty(inTarget, k, Object.getOwnPropertyDescriptor(p, k));
|
||||
used[k] = 1;
|
||||
}
|
||||
}
|
||||
p = Object.getPrototypeOf(p);
|
||||
}
|
||||
}
|
||||
function created(element) {
|
||||
if (element.createdCallback) {
|
||||
element.createdCallback();
|
||||
}
|
||||
}
|
||||
scope.upgrade = upgrade;
|
||||
scope.upgradeWithDefinition = upgradeWithDefinition;
|
||||
scope.implementPrototype = implementPrototype;
|
||||
});
|
||||
|
||||
window.CustomElements.addModule(function(scope) {
|
||||
var isIE11OrOlder = scope.isIE11OrOlder;
|
||||
var upgradeDocumentTree = scope.upgradeDocumentTree;
|
||||
var upgradeAll = scope.upgradeAll;
|
||||
var upgradeWithDefinition = scope.upgradeWithDefinition;
|
||||
var implementPrototype = scope.implementPrototype;
|
||||
var useNative = scope.useNative;
|
||||
function register(name, options) {
|
||||
var definition = options || {};
|
||||
if (!name) {
|
||||
throw new Error("document.registerElement: first argument `name` must not be empty");
|
||||
}
|
||||
if (name.indexOf("-") < 0) {
|
||||
throw new Error("document.registerElement: first argument ('name') must contain a dash ('-'). Argument provided was '" + String(name) + "'.");
|
||||
}
|
||||
if (isReservedTag(name)) {
|
||||
throw new Error("Failed to execute 'registerElement' on 'Document': Registration failed for type '" + String(name) + "'. The type name is invalid.");
|
||||
}
|
||||
if (getRegisteredDefinition(name)) {
|
||||
throw new Error("DuplicateDefinitionError: a type with name '" + String(name) + "' is already registered");
|
||||
}
|
||||
if (!definition.prototype) {
|
||||
definition.prototype = Object.create(HTMLElement.prototype);
|
||||
}
|
||||
definition.__name = name.toLowerCase();
|
||||
definition.lifecycle = definition.lifecycle || {};
|
||||
definition.ancestry = ancestry(definition.extends);
|
||||
resolveTagName(definition);
|
||||
resolvePrototypeChain(definition);
|
||||
overrideAttributeApi(definition.prototype);
|
||||
registerDefinition(definition.__name, definition);
|
||||
definition.ctor = generateConstructor(definition);
|
||||
definition.ctor.prototype = definition.prototype;
|
||||
definition.prototype.constructor = definition.ctor;
|
||||
if (scope.ready) {
|
||||
upgradeDocumentTree(document);
|
||||
}
|
||||
return definition.ctor;
|
||||
}
|
||||
function overrideAttributeApi(prototype) {
|
||||
if (prototype.setAttribute._polyfilled) {
|
||||
return;
|
||||
}
|
||||
var setAttribute = prototype.setAttribute;
|
||||
prototype.setAttribute = function(name, value) {
|
||||
changeAttribute.call(this, name, value, setAttribute);
|
||||
};
|
||||
var removeAttribute = prototype.removeAttribute;
|
||||
prototype.removeAttribute = function(name) {
|
||||
changeAttribute.call(this, name, null, removeAttribute);
|
||||
};
|
||||
prototype.setAttribute._polyfilled = true;
|
||||
}
|
||||
function changeAttribute(name, value, operation) {
|
||||
name = name.toLowerCase();
|
||||
var oldValue = this.getAttribute(name);
|
||||
operation.apply(this, arguments);
|
||||
var newValue = this.getAttribute(name);
|
||||
if (this.attributeChangedCallback && newValue !== oldValue) {
|
||||
this.attributeChangedCallback(name, oldValue, newValue);
|
||||
}
|
||||
}
|
||||
function isReservedTag(name) {
|
||||
for (var i = 0; i < reservedTagList.length; i++) {
|
||||
if (name === reservedTagList[i]) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
var reservedTagList = [ "annotation-xml", "color-profile", "font-face", "font-face-src", "font-face-uri", "font-face-format", "font-face-name", "missing-glyph" ];
|
||||
function ancestry(extnds) {
|
||||
var extendee = getRegisteredDefinition(extnds);
|
||||
if (extendee) {
|
||||
return ancestry(extendee.extends).concat([ extendee ]);
|
||||
}
|
||||
return [];
|
||||
}
|
||||
function resolveTagName(definition) {
|
||||
var baseTag = definition.extends;
|
||||
for (var i = 0, a; a = definition.ancestry[i]; i++) {
|
||||
baseTag = a.is && a.tag;
|
||||
}
|
||||
definition.tag = baseTag || definition.__name;
|
||||
if (baseTag) {
|
||||
definition.is = definition.__name;
|
||||
}
|
||||
}
|
||||
function resolvePrototypeChain(definition) {
|
||||
if (!Object.__proto__) {
|
||||
var nativePrototype = HTMLElement.prototype;
|
||||
if (definition.is) {
|
||||
var inst = document.createElement(definition.tag);
|
||||
var expectedPrototype = Object.getPrototypeOf(inst);
|
||||
if (expectedPrototype === definition.prototype) {
|
||||
nativePrototype = expectedPrototype;
|
||||
}
|
||||
}
|
||||
var proto = definition.prototype, ancestor;
|
||||
while (proto && proto !== nativePrototype) {
|
||||
ancestor = Object.getPrototypeOf(proto);
|
||||
proto.__proto__ = ancestor;
|
||||
proto = ancestor;
|
||||
}
|
||||
definition.native = nativePrototype;
|
||||
}
|
||||
}
|
||||
function instantiate(definition) {
|
||||
return upgradeWithDefinition(domCreateElement(definition.tag), definition);
|
||||
}
|
||||
var registry = {};
|
||||
function getRegisteredDefinition(name) {
|
||||
if (name) {
|
||||
return registry[name.toLowerCase()];
|
||||
}
|
||||
}
|
||||
function registerDefinition(name, definition) {
|
||||
registry[name] = definition;
|
||||
}
|
||||
function generateConstructor(definition) {
|
||||
return function() {
|
||||
return instantiate(definition);
|
||||
};
|
||||
}
|
||||
var HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
|
||||
function createElementNS(namespace, tag, typeExtension) {
|
||||
if (namespace === HTML_NAMESPACE) {
|
||||
return createElement(tag, typeExtension);
|
||||
} else {
|
||||
return domCreateElementNS(namespace, tag);
|
||||
}
|
||||
}
|
||||
function createElement(tag, typeExtension) {
|
||||
if (tag) {
|
||||
tag = tag.toLowerCase();
|
||||
}
|
||||
if (typeExtension) {
|
||||
typeExtension = typeExtension.toLowerCase();
|
||||
}
|
||||
var definition = getRegisteredDefinition(typeExtension || tag);
|
||||
if (definition) {
|
||||
if (tag == definition.tag && typeExtension == definition.is) {
|
||||
return new definition.ctor();
|
||||
}
|
||||
if (!typeExtension && !definition.is) {
|
||||
return new definition.ctor();
|
||||
}
|
||||
}
|
||||
var element;
|
||||
if (typeExtension) {
|
||||
element = createElement(tag);
|
||||
element.setAttribute("is", typeExtension);
|
||||
return element;
|
||||
}
|
||||
element = domCreateElement(tag);
|
||||
if (tag.indexOf("-") >= 0) {
|
||||
implementPrototype(element, HTMLElement);
|
||||
}
|
||||
return element;
|
||||
}
|
||||
var domCreateElement = document.createElement.bind(document);
|
||||
var domCreateElementNS = document.createElementNS.bind(document);
|
||||
var isInstance;
|
||||
if (!Object.__proto__ && !useNative) {
|
||||
isInstance = function(obj, ctor) {
|
||||
var p = obj;
|
||||
while (p) {
|
||||
if (p === ctor.prototype) {
|
||||
return true;
|
||||
}
|
||||
p = p.__proto__;
|
||||
}
|
||||
return false;
|
||||
};
|
||||
} else {
|
||||
isInstance = function(obj, base) {
|
||||
return obj instanceof base;
|
||||
};
|
||||
}
|
||||
function wrapDomMethodToForceUpgrade(obj, methodName) {
|
||||
var orig = obj[methodName];
|
||||
obj[methodName] = function() {
|
||||
var n = orig.apply(this, arguments);
|
||||
upgradeAll(n);
|
||||
return n;
|
||||
};
|
||||
}
|
||||
wrapDomMethodToForceUpgrade(Node.prototype, "cloneNode");
|
||||
wrapDomMethodToForceUpgrade(document, "importNode");
|
||||
if (isIE11OrOlder) {
|
||||
(function() {
|
||||
var importNode = document.importNode;
|
||||
document.importNode = function() {
|
||||
var n = importNode.apply(document, arguments);
|
||||
if (n.nodeType == n.DOCUMENT_FRAGMENT_NODE) {
|
||||
var f = document.createDocumentFragment();
|
||||
f.appendChild(n);
|
||||
return f;
|
||||
} else {
|
||||
return n;
|
||||
}
|
||||
};
|
||||
})();
|
||||
}
|
||||
document.registerElement = register;
|
||||
document.createElement = createElement;
|
||||
document.createElementNS = createElementNS;
|
||||
scope.registry = registry;
|
||||
scope.instanceof = isInstance;
|
||||
scope.reservedTagList = reservedTagList;
|
||||
scope.getRegisteredDefinition = getRegisteredDefinition;
|
||||
document.register = document.registerElement;
|
||||
});
|
||||
|
||||
(function(scope) {
|
||||
var useNative = scope.useNative;
|
||||
var initializeModules = scope.initializeModules;
|
||||
var isIE11OrOlder = /Trident/.test(navigator.userAgent);
|
||||
if (useNative) {
|
||||
var nop = function() {};
|
||||
scope.watchShadow = nop;
|
||||
scope.upgrade = nop;
|
||||
scope.upgradeAll = nop;
|
||||
scope.upgradeDocumentTree = nop;
|
||||
scope.upgradeSubtree = nop;
|
||||
scope.takeRecords = nop;
|
||||
scope.instanceof = function(obj, base) {
|
||||
return obj instanceof base;
|
||||
};
|
||||
} else {
|
||||
initializeModules();
|
||||
}
|
||||
var upgradeDocumentTree = scope.upgradeDocumentTree;
|
||||
if (!window.wrap) {
|
||||
if (window.ShadowDOMPolyfill) {
|
||||
window.wrap = ShadowDOMPolyfill.wrapIfNeeded;
|
||||
window.unwrap = ShadowDOMPolyfill.unwrapIfNeeded;
|
||||
} else {
|
||||
window.wrap = window.unwrap = function(node) {
|
||||
return node;
|
||||
};
|
||||
}
|
||||
}
|
||||
function bootstrap() {
|
||||
upgradeDocumentTree(wrap(document));
|
||||
if (window.HTMLImports) {
|
||||
HTMLImports.__importsParsingHook = function(elt) {
|
||||
upgradeDocumentTree(wrap(elt.import));
|
||||
};
|
||||
}
|
||||
CustomElements.ready = true;
|
||||
setTimeout(function() {
|
||||
CustomElements.readyTime = Date.now();
|
||||
if (window.HTMLImports) {
|
||||
CustomElements.elapsed = CustomElements.readyTime - HTMLImports.readyTime;
|
||||
}
|
||||
document.dispatchEvent(new CustomEvent("WebComponentsReady", {
|
||||
bubbles: true
|
||||
}));
|
||||
});
|
||||
}
|
||||
if (isIE11OrOlder && typeof window.CustomEvent !== "function") {
|
||||
window.CustomEvent = function(inType, params) {
|
||||
params = params || {};
|
||||
var e = document.createEvent("CustomEvent");
|
||||
e.initCustomEvent(inType, Boolean(params.bubbles), Boolean(params.cancelable), params.detail);
|
||||
return e;
|
||||
};
|
||||
window.CustomEvent.prototype = window.Event.prototype;
|
||||
}
|
||||
if (document.readyState === "complete" || scope.flags.eager) {
|
||||
bootstrap();
|
||||
} else if (document.readyState === "interactive" && !window.attachEvent && (!window.HTMLImports || window.HTMLImports.ready)) {
|
||||
bootstrap();
|
||||
} else {
|
||||
var loadEvent = window.HTMLImports && !HTMLImports.ready ? "HTMLImportsLoaded" : "DOMContentLoaded";
|
||||
window.addEventListener(loadEvent, bootstrap);
|
||||
}
|
||||
scope.isIE11OrOlder = isIE11OrOlder;
|
||||
})(window.CustomElements);
|
||||
Loading…
Add table
Add a link
Reference in a new issue