1/** 2 * @license 3 * Copyright (c) 2014 The Polymer Project Authors. All rights reserved. 4 * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt 5 * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt 6 * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt 7 * Code distributed by Google as part of the polymer project is also 8 * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt 9 */ 10// @version 0.5.5 11window.WebComponents = window.WebComponents || {}; 12 13(function(scope) { 14 var flags = scope.flags || {}; 15 var file = "webcomponents.js"; 16 var script = document.querySelector('script[src*="' + file + '"]'); 17 if (!flags.noOpts) { 18 location.search.slice(1).split("&").forEach(function(o) { 19 o = o.split("="); 20 o[0] && (flags[o[0]] = o[1] || true); 21 }); 22 if (script) { 23 for (var i = 0, a; a = script.attributes[i]; i++) { 24 if (a.name !== "src") { 25 flags[a.name] = a.value || true; 26 } 27 } 28 } 29 if (flags.log) { 30 var parts = flags.log.split(","); 31 flags.log = {}; 32 parts.forEach(function(f) { 33 flags.log[f] = true; 34 }); 35 } else { 36 flags.log = {}; 37 } 38 } 39 flags.shadow = flags.shadow || flags.shadowdom || flags.polyfill; 40 if (flags.shadow === "native") { 41 flags.shadow = false; 42 } else { 43 flags.shadow = flags.shadow || !HTMLElement.prototype.createShadowRoot; 44 } 45 if (flags.register) { 46 window.CustomElements = window.CustomElements || { 47 flags: {} 48 }; 49 window.CustomElements.flags.register = flags.register; 50 } 51 scope.flags = flags; 52})(WebComponents); 53 54if (WebComponents.flags.shadow) { 55 if (typeof WeakMap === "undefined") { 56 (function() { 57 var defineProperty = Object.defineProperty; 58 var counter = Date.now() % 1e9; 59 var WeakMap = function() { 60 this.name = "__st" + (Math.random() * 1e9 >>> 0) + (counter++ + "__"); 61 }; 62 WeakMap.prototype = { 63 set: function(key, value) { 64 var entry = key[this.name]; 65 if (entry && entry[0] === key) entry[1] = value; else defineProperty(key, this.name, { 66 value: [ key, value ], 67 writable: true 68 }); 69 return this; 70 }, 71 get: function(key) { 72 var entry; 73 return (entry = key[this.name]) && entry[0] === key ? entry[1] : undefined; 74 }, 75 "delete": function(key) { 76 var entry = key[this.name]; 77 if (!entry || entry[0] !== key) return false; 78 entry[0] = entry[1] = undefined; 79 return true; 80 }, 81 has: function(key) { 82 var entry = key[this.name]; 83 if (!entry) return false; 84 return entry[0] === key; 85 } 86 }; 87 window.WeakMap = WeakMap; 88 })(); 89 } 90 window.ShadowDOMPolyfill = {}; 91 (function(scope) { 92 "use strict"; 93 var constructorTable = new WeakMap(); 94 var nativePrototypeTable = new WeakMap(); 95 var wrappers = Object.create(null); 96 function detectEval() { 97 if (typeof chrome !== "undefined" && chrome.app && chrome.app.runtime) { 98 return false; 99 } 100 if (navigator.getDeviceStorage) { 101 return false; 102 } 103 try { 104 var f = new Function("return true;"); 105 return f(); 106 } catch (ex) { 107 return false; 108 } 109 } 110 var hasEval = detectEval(); 111 function assert(b) { 112 if (!b) throw new Error("Assertion failed"); 113 } 114 var defineProperty = Object.defineProperty; 115 var getOwnPropertyNames = Object.getOwnPropertyNames; 116 var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; 117 function mixin(to, from) { 118 var names = getOwnPropertyNames(from); 119 for (var i = 0; i < names.length; i++) { 120 var name = names[i]; 121 defineProperty(to, name, getOwnPropertyDescriptor(from, name)); 122 } 123 return to; 124 } 125 function mixinStatics(to, from) { 126 var names = getOwnPropertyNames(from); 127 for (var i = 0; i < names.length; i++) { 128 var name = names[i]; 129 switch (name) { 130 case "arguments": 131 case "caller": 132 case "length": 133 case "name": 134 case "prototype": 135 case "toString": 136 continue; 137 } 138 defineProperty(to, name, getOwnPropertyDescriptor(from, name)); 139 } 140 return to; 141 } 142 function oneOf(object, propertyNames) { 143 for (var i = 0; i < propertyNames.length; i++) { 144 if (propertyNames[i] in object) return propertyNames[i]; 145 } 146 } 147 var nonEnumerableDataDescriptor = { 148 value: undefined, 149 configurable: true, 150 enumerable: false, 151 writable: true 152 }; 153 function defineNonEnumerableDataProperty(object, name, value) { 154 nonEnumerableDataDescriptor.value = value; 155 defineProperty(object, name, nonEnumerableDataDescriptor); 156 } 157 getOwnPropertyNames(window); 158 function getWrapperConstructor(node) { 159 var nativePrototype = node.__proto__ || Object.getPrototypeOf(node); 160 if (isFirefox) { 161 try { 162 getOwnPropertyNames(nativePrototype); 163 } catch (error) { 164 nativePrototype = nativePrototype.__proto__; 165 } 166 } 167 var wrapperConstructor = constructorTable.get(nativePrototype); 168 if (wrapperConstructor) return wrapperConstructor; 169 var parentWrapperConstructor = getWrapperConstructor(nativePrototype); 170 var GeneratedWrapper = createWrapperConstructor(parentWrapperConstructor); 171 registerInternal(nativePrototype, GeneratedWrapper, node); 172 return GeneratedWrapper; 173 } 174 function addForwardingProperties(nativePrototype, wrapperPrototype) { 175 installProperty(nativePrototype, wrapperPrototype, true); 176 } 177 function registerInstanceProperties(wrapperPrototype, instanceObject) { 178 installProperty(instanceObject, wrapperPrototype, false); 179 } 180 var isFirefox = /Firefox/.test(navigator.userAgent); 181 var dummyDescriptor = { 182 get: function() {}, 183 set: function(v) {}, 184 configurable: true, 185 enumerable: true 186 }; 187 function isEventHandlerName(name) { 188 return /^on[a-z]+$/.test(name); 189 } 190 function isIdentifierName(name) { 191 return /^\w[a-zA-Z_0-9]*$/.test(name); 192 } 193 function getGetter(name) { 194 return hasEval && isIdentifierName(name) ? new Function("return this.__impl4cf1e782hg__." + name) : function() { 195 return this.__impl4cf1e782hg__[name]; 196 }; 197 } 198 function getSetter(name) { 199 return hasEval && isIdentifierName(name) ? new Function("v", "this.__impl4cf1e782hg__." + name + " = v") : function(v) { 200 this.__impl4cf1e782hg__[name] = v; 201 }; 202 } 203 function getMethod(name) { 204 return hasEval && isIdentifierName(name) ? new Function("return this.__impl4cf1e782hg__." + name + ".apply(this.__impl4cf1e782hg__, arguments)") : function() { 205 return this.__impl4cf1e782hg__[name].apply(this.__impl4cf1e782hg__, arguments); 206 }; 207 } 208 function getDescriptor(source, name) { 209 try { 210 return Object.getOwnPropertyDescriptor(source, name); 211 } catch (ex) { 212 return dummyDescriptor; 213 } 214 } 215 var isBrokenSafari = function() { 216 var descr = Object.getOwnPropertyDescriptor(Node.prototype, "nodeType"); 217 return descr && !descr.get && !descr.set; 218 }(); 219 function installProperty(source, target, allowMethod, opt_blacklist) { 220 var names = getOwnPropertyNames(source); 221 for (var i = 0; i < names.length; i++) { 222 var name = names[i]; 223 if (name === "polymerBlackList_") continue; 224 if (name in target) continue; 225 if (source.polymerBlackList_ && source.polymerBlackList_[name]) continue; 226 if (isFirefox) { 227 source.__lookupGetter__(name); 228 } 229 var descriptor = getDescriptor(source, name); 230 var getter, setter; 231 if (allowMethod && typeof descriptor.value === "function") { 232 target[name] = getMethod(name); 233 continue; 234 } 235 var isEvent = isEventHandlerName(name); 236 if (isEvent) getter = scope.getEventHandlerGetter(name); else getter = getGetter(name); 237 if (descriptor.writable || descriptor.set || isBrokenSafari) { 238 if (isEvent) setter = scope.getEventHandlerSetter(name); else setter = getSetter(name); 239 } 240 var configurable = isBrokenSafari || descriptor.configurable; 241 defineProperty(target, name, { 242 get: getter, 243 set: setter, 244 configurable: configurable, 245 enumerable: descriptor.enumerable 246 }); 247 } 248 } 249 function register(nativeConstructor, wrapperConstructor, opt_instance) { 250 var nativePrototype = nativeConstructor.prototype; 251 registerInternal(nativePrototype, wrapperConstructor, opt_instance); 252 mixinStatics(wrapperConstructor, nativeConstructor); 253 } 254 function registerInternal(nativePrototype, wrapperConstructor, opt_instance) { 255 var wrapperPrototype = wrapperConstructor.prototype; 256 assert(constructorTable.get(nativePrototype) === undefined); 257 constructorTable.set(nativePrototype, wrapperConstructor); 258 nativePrototypeTable.set(wrapperPrototype, nativePrototype); 259 addForwardingProperties(nativePrototype, wrapperPrototype); 260 if (opt_instance) registerInstanceProperties(wrapperPrototype, opt_instance); 261 defineNonEnumerableDataProperty(wrapperPrototype, "constructor", wrapperConstructor); 262 wrapperConstructor.prototype = wrapperPrototype; 263 } 264 function isWrapperFor(wrapperConstructor, nativeConstructor) { 265 return constructorTable.get(nativeConstructor.prototype) === wrapperConstructor; 266 } 267 function registerObject(object) { 268 var nativePrototype = Object.getPrototypeOf(object); 269 var superWrapperConstructor = getWrapperConstructor(nativePrototype); 270 var GeneratedWrapper = createWrapperConstructor(superWrapperConstructor); 271 registerInternal(nativePrototype, GeneratedWrapper, object); 272 return GeneratedWrapper; 273 } 274 function createWrapperConstructor(superWrapperConstructor) { 275 function GeneratedWrapper(node) { 276 superWrapperConstructor.call(this, node); 277 } 278 var p = Object.create(superWrapperConstructor.prototype); 279 p.constructor = GeneratedWrapper; 280 GeneratedWrapper.prototype = p; 281 return GeneratedWrapper; 282 } 283 function isWrapper(object) { 284 return object && object.__impl4cf1e782hg__; 285 } 286 function isNative(object) { 287 return !isWrapper(object); 288 } 289 function wrap(impl) { 290 if (impl === null) return null; 291 assert(isNative(impl)); 292 return impl.__wrapper8e3dd93a60__ || (impl.__wrapper8e3dd93a60__ = new (getWrapperConstructor(impl))(impl)); 293 } 294 function unwrap(wrapper) { 295 if (wrapper === null) return null; 296 assert(isWrapper(wrapper)); 297 return wrapper.__impl4cf1e782hg__; 298 } 299 function unsafeUnwrap(wrapper) { 300 return wrapper.__impl4cf1e782hg__; 301 } 302 function setWrapper(impl, wrapper) { 303 wrapper.__impl4cf1e782hg__ = impl; 304 impl.__wrapper8e3dd93a60__ = wrapper; 305 } 306 function unwrapIfNeeded(object) { 307 return object && isWrapper(object) ? unwrap(object) : object; 308 } 309 function wrapIfNeeded(object) { 310 return object && !isWrapper(object) ? wrap(object) : object; 311 } 312 function rewrap(node, wrapper) { 313 if (wrapper === null) return; 314 assert(isNative(node)); 315 assert(wrapper === undefined || isWrapper(wrapper)); 316 node.__wrapper8e3dd93a60__ = wrapper; 317 } 318 var getterDescriptor = { 319 get: undefined, 320 configurable: true, 321 enumerable: true 322 }; 323 function defineGetter(constructor, name, getter) { 324 getterDescriptor.get = getter; 325 defineProperty(constructor.prototype, name, getterDescriptor); 326 } 327 function defineWrapGetter(constructor, name) { 328 defineGetter(constructor, name, function() { 329 return wrap(this.__impl4cf1e782hg__[name]); 330 }); 331 } 332 function forwardMethodsToWrapper(constructors, names) { 333 constructors.forEach(function(constructor) { 334 names.forEach(function(name) { 335 constructor.prototype[name] = function() { 336 var w = wrapIfNeeded(this); 337 return w[name].apply(w, arguments); 338 }; 339 }); 340 }); 341 } 342 scope.assert = assert; 343 scope.constructorTable = constructorTable; 344 scope.defineGetter = defineGetter; 345 scope.defineWrapGetter = defineWrapGetter; 346 scope.forwardMethodsToWrapper = forwardMethodsToWrapper; 347 scope.isWrapper = isWrapper; 348 scope.isWrapperFor = isWrapperFor; 349 scope.mixin = mixin; 350 scope.nativePrototypeTable = nativePrototypeTable; 351 scope.oneOf = oneOf; 352 scope.registerObject = registerObject; 353 scope.registerWrapper = register; 354 scope.rewrap = rewrap; 355 scope.setWrapper = setWrapper; 356 scope.unsafeUnwrap = unsafeUnwrap; 357 scope.unwrap = unwrap; 358 scope.unwrapIfNeeded = unwrapIfNeeded; 359 scope.wrap = wrap; 360 scope.wrapIfNeeded = wrapIfNeeded; 361 scope.wrappers = wrappers; 362 })(window.ShadowDOMPolyfill); 363 (function(scope) { 364 "use strict"; 365 function newSplice(index, removed, addedCount) { 366 return { 367 index: index, 368 removed: removed, 369 addedCount: addedCount 370 }; 371 } 372 var EDIT_LEAVE = 0; 373 var EDIT_UPDATE = 1; 374 var EDIT_ADD = 2; 375 var EDIT_DELETE = 3; 376 function ArraySplice() {} 377 ArraySplice.prototype = { 378 calcEditDistances: function(current, currentStart, currentEnd, old, oldStart, oldEnd) { 379 var rowCount = oldEnd - oldStart + 1; 380 var columnCount = currentEnd - currentStart + 1; 381 var distances = new Array(rowCount); 382 for (var i = 0; i < rowCount; i++) { 383 distances[i] = new Array(columnCount); 384 distances[i][0] = i; 385 } 386 for (var j = 0; j < columnCount; j++) distances[0][j] = j; 387 for (var i = 1; i < rowCount; i++) { 388 for (var j = 1; j < columnCount; j++) { 389 if (this.equals(current[currentStart + j - 1], old[oldStart + i - 1])) distances[i][j] = distances[i - 1][j - 1]; else { 390 var north = distances[i - 1][j] + 1; 391 var west = distances[i][j - 1] + 1; 392 distances[i][j] = north < west ? north : west; 393 } 394 } 395 } 396 return distances; 397 }, 398 spliceOperationsFromEditDistances: function(distances) { 399 var i = distances.length - 1; 400 var j = distances[0].length - 1; 401 var current = distances[i][j]; 402 var edits = []; 403 while (i > 0 || j > 0) { 404 if (i == 0) { 405 edits.push(EDIT_ADD); 406 j--; 407 continue; 408 } 409 if (j == 0) { 410 edits.push(EDIT_DELETE); 411 i--; 412 continue; 413 } 414 var northWest = distances[i - 1][j - 1]; 415 var west = distances[i - 1][j]; 416 var north = distances[i][j - 1]; 417 var min; 418 if (west < north) min = west < northWest ? west : northWest; else min = north < northWest ? north : northWest; 419 if (min == northWest) { 420 if (northWest == current) { 421 edits.push(EDIT_LEAVE); 422 } else { 423 edits.push(EDIT_UPDATE); 424 current = northWest; 425 } 426 i--; 427 j--; 428 } else if (min == west) { 429 edits.push(EDIT_DELETE); 430 i--; 431 current = west; 432 } else { 433 edits.push(EDIT_ADD); 434 j--; 435 current = north; 436 } 437 } 438 edits.reverse(); 439 return edits; 440 }, 441 calcSplices: function(current, currentStart, currentEnd, old, oldStart, oldEnd) { 442 var prefixCount = 0; 443 var suffixCount = 0; 444 var minLength = Math.min(currentEnd - currentStart, oldEnd - oldStart); 445 if (currentStart == 0 && oldStart == 0) prefixCount = this.sharedPrefix(current, old, minLength); 446 if (currentEnd == current.length && oldEnd == old.length) suffixCount = this.sharedSuffix(current, old, minLength - prefixCount); 447 currentStart += prefixCount; 448 oldStart += prefixCount; 449 currentEnd -= suffixCount; 450 oldEnd -= suffixCount; 451 if (currentEnd - currentStart == 0 && oldEnd - oldStart == 0) return []; 452 if (currentStart == currentEnd) { 453 var splice = newSplice(currentStart, [], 0); 454 while (oldStart < oldEnd) splice.removed.push(old[oldStart++]); 455 return [ splice ]; 456 } else if (oldStart == oldEnd) return [ newSplice(currentStart, [], currentEnd - currentStart) ]; 457 var ops = this.spliceOperationsFromEditDistances(this.calcEditDistances(current, currentStart, currentEnd, old, oldStart, oldEnd)); 458 var splice = undefined; 459 var splices = []; 460 var index = currentStart; 461 var oldIndex = oldStart; 462 for (var i = 0; i < ops.length; i++) { 463 switch (ops[i]) { 464 case EDIT_LEAVE: 465 if (splice) { 466 splices.push(splice); 467 splice = undefined; 468 } 469 index++; 470 oldIndex++; 471 break; 472 473 case EDIT_UPDATE: 474 if (!splice) splice = newSplice(index, [], 0); 475 splice.addedCount++; 476 index++; 477 splice.removed.push(old[oldIndex]); 478 oldIndex++; 479 break; 480 481 case EDIT_ADD: 482 if (!splice) splice = newSplice(index, [], 0); 483 splice.addedCount++; 484 index++; 485 break; 486 487 case EDIT_DELETE: 488 if (!splice) splice = newSplice(index, [], 0); 489 splice.removed.push(old[oldIndex]); 490 oldIndex++; 491 break; 492 } 493 } 494 if (splice) { 495 splices.push(splice); 496 } 497 return splices; 498 }, 499 sharedPrefix: function(current, old, searchLength) { 500 for (var i = 0; i < searchLength; i++) if (!this.equals(current[i], old[i])) return i; 501 return searchLength; 502 }, 503 sharedSuffix: function(current, old, searchLength) { 504 var index1 = current.length; 505 var index2 = old.length; 506 var count = 0; 507 while (count < searchLength && this.equals(current[--index1], old[--index2])) count++; 508 return count; 509 }, 510 calculateSplices: function(current, previous) { 511 return this.calcSplices(current, 0, current.length, previous, 0, previous.length); 512 }, 513 equals: function(currentValue, previousValue) { 514 return currentValue === previousValue; 515 } 516 }; 517 scope.ArraySplice = ArraySplice; 518 })(window.ShadowDOMPolyfill); 519 (function(context) { 520 "use strict"; 521 var OriginalMutationObserver = window.MutationObserver; 522 var callbacks = []; 523 var pending = false; 524 var timerFunc; 525 function handle() { 526 pending = false; 527 var copies = callbacks.slice(0); 528 callbacks = []; 529 for (var i = 0; i < copies.length; i++) { 530 (0, copies[i])(); 531 } 532 } 533 if (OriginalMutationObserver) { 534 var counter = 1; 535 var observer = new OriginalMutationObserver(handle); 536 var textNode = document.createTextNode(counter); 537 observer.observe(textNode, { 538 characterData: true 539 }); 540 timerFunc = function() { 541 counter = (counter + 1) % 2; 542 textNode.data = counter; 543 }; 544 } else { 545 timerFunc = window.setTimeout; 546 } 547 function setEndOfMicrotask(func) { 548 callbacks.push(func); 549 if (pending) return; 550 pending = true; 551 timerFunc(handle, 0); 552 } 553 context.setEndOfMicrotask = setEndOfMicrotask; 554 })(window.ShadowDOMPolyfill); 555 (function(scope) { 556 "use strict"; 557 var setEndOfMicrotask = scope.setEndOfMicrotask; 558 var wrapIfNeeded = scope.wrapIfNeeded; 559 var wrappers = scope.wrappers; 560 var registrationsTable = new WeakMap(); 561 var globalMutationObservers = []; 562 var isScheduled = false; 563 function scheduleCallback(observer) { 564 if (observer.scheduled_) return; 565 observer.scheduled_ = true; 566 globalMutationObservers.push(observer); 567 if (isScheduled) return; 568 setEndOfMicrotask(notifyObservers); 569 isScheduled = true; 570 } 571 function notifyObservers() { 572 isScheduled = false; 573 while (globalMutationObservers.length) { 574 var notifyList = globalMutationObservers; 575 globalMutationObservers = []; 576 notifyList.sort(function(x, y) { 577 return x.uid_ - y.uid_; 578 }); 579 for (var i = 0; i < notifyList.length; i++) { 580 var mo = notifyList[i]; 581 mo.scheduled_ = false; 582 var queue = mo.takeRecords(); 583 removeTransientObserversFor(mo); 584 if (queue.length) { 585 mo.callback_(queue, mo); 586 } 587 } 588 } 589 } 590 function MutationRecord(type, target) { 591 this.type = type; 592 this.target = target; 593 this.addedNodes = new wrappers.NodeList(); 594 this.removedNodes = new wrappers.NodeList(); 595 this.previousSibling = null; 596 this.nextSibling = null; 597 this.attributeName = null; 598 this.attributeNamespace = null; 599 this.oldValue = null; 600 } 601 function registerTransientObservers(ancestor, node) { 602 for (;ancestor; ancestor = ancestor.parentNode) { 603 var registrations = registrationsTable.get(ancestor); 604 if (!registrations) continue; 605 for (var i = 0; i < registrations.length; i++) { 606 var registration = registrations[i]; 607 if (registration.options.subtree) registration.addTransientObserver(node); 608 } 609 } 610 } 611 function removeTransientObserversFor(observer) { 612 for (var i = 0; i < observer.nodes_.length; i++) { 613 var node = observer.nodes_[i]; 614 var registrations = registrationsTable.get(node); 615 if (!registrations) return; 616 for (var j = 0; j < registrations.length; j++) { 617 var registration = registrations[j]; 618 if (registration.observer === observer) registration.removeTransientObservers(); 619 } 620 } 621 } 622 function enqueueMutation(target, type, data) { 623 var interestedObservers = Object.create(null); 624 var associatedStrings = Object.create(null); 625 for (var node = target; node; node = node.parentNode) { 626 var registrations = registrationsTable.get(node); 627 if (!registrations) continue; 628 for (var j = 0; j < registrations.length; j++) { 629 var registration = registrations[j]; 630 var options = registration.options; 631 if (node !== target && !options.subtree) continue; 632 if (type === "attributes" && !options.attributes) continue; 633 if (type === "attributes" && options.attributeFilter && (data.namespace !== null || options.attributeFilter.indexOf(data.name) === -1)) { 634 continue; 635 } 636 if (type === "characterData" && !options.characterData) continue; 637 if (type === "childList" && !options.childList) continue; 638 var observer = registration.observer; 639 interestedObservers[observer.uid_] = observer; 640 if (type === "attributes" && options.attributeOldValue || type === "characterData" && options.characterDataOldValue) { 641 associatedStrings[observer.uid_] = data.oldValue; 642 } 643 } 644 } 645 for (var uid in interestedObservers) { 646 var observer = interestedObservers[uid]; 647 var record = new MutationRecord(type, target); 648 if ("name" in data && "namespace" in data) { 649 record.attributeName = data.name; 650 record.attributeNamespace = data.namespace; 651 } 652 if (data.addedNodes) record.addedNodes = data.addedNodes; 653 if (data.removedNodes) record.removedNodes = data.removedNodes; 654 if (data.previousSibling) record.previousSibling = data.previousSibling; 655 if (data.nextSibling) record.nextSibling = data.nextSibling; 656 if (associatedStrings[uid] !== undefined) record.oldValue = associatedStrings[uid]; 657 scheduleCallback(observer); 658 observer.records_.push(record); 659 } 660 } 661 var slice = Array.prototype.slice; 662 function MutationObserverOptions(options) { 663 this.childList = !!options.childList; 664 this.subtree = !!options.subtree; 665 if (!("attributes" in options) && ("attributeOldValue" in options || "attributeFilter" in options)) { 666 this.attributes = true; 667 } else { 668 this.attributes = !!options.attributes; 669 } 670 if ("characterDataOldValue" in options && !("characterData" in options)) this.characterData = true; else this.characterData = !!options.characterData; 671 if (!this.attributes && (options.attributeOldValue || "attributeFilter" in options) || !this.characterData && options.characterDataOldValue) { 672 throw new TypeError(); 673 } 674 this.characterData = !!options.characterData; 675 this.attributeOldValue = !!options.attributeOldValue; 676 this.characterDataOldValue = !!options.characterDataOldValue; 677 if ("attributeFilter" in options) { 678 if (options.attributeFilter == null || typeof options.attributeFilter !== "object") { 679 throw new TypeError(); 680 } 681 this.attributeFilter = slice.call(options.attributeFilter); 682 } else { 683 this.attributeFilter = null; 684 } 685 } 686 var uidCounter = 0; 687 function MutationObserver(callback) { 688 this.callback_ = callback; 689 this.nodes_ = []; 690 this.records_ = []; 691 this.uid_ = ++uidCounter; 692 this.scheduled_ = false; 693 } 694 MutationObserver.prototype = { 695 constructor: MutationObserver, 696 observe: function(target, options) { 697 target = wrapIfNeeded(target); 698 var newOptions = new MutationObserverOptions(options); 699 var registration; 700 var registrations = registrationsTable.get(target); 701 if (!registrations) registrationsTable.set(target, registrations = []); 702 for (var i = 0; i < registrations.length; i++) { 703 if (registrations[i].observer === this) { 704 registration = registrations[i]; 705 registration.removeTransientObservers(); 706 registration.options = newOptions; 707 } 708 } 709 if (!registration) { 710 registration = new Registration(this, target, newOptions); 711 registrations.push(registration); 712 this.nodes_.push(target); 713 } 714 }, 715 disconnect: function() { 716 this.nodes_.forEach(function(node) { 717 var registrations = registrationsTable.get(node); 718 for (var i = 0; i < registrations.length; i++) { 719 var registration = registrations[i]; 720 if (registration.observer === this) { 721 registrations.splice(i, 1); 722 break; 723 } 724 } 725 }, this); 726 this.records_ = []; 727 }, 728 takeRecords: function() { 729 var copyOfRecords = this.records_; 730 this.records_ = []; 731 return copyOfRecords; 732 } 733 }; 734 function Registration(observer, target, options) { 735 this.observer = observer; 736 this.target = target; 737 this.options = options; 738 this.transientObservedNodes = []; 739 } 740 Registration.prototype = { 741 addTransientObserver: function(node) { 742 if (node === this.target) return; 743 scheduleCallback(this.observer); 744 this.transientObservedNodes.push(node); 745 var registrations = registrationsTable.get(node); 746 if (!registrations) registrationsTable.set(node, registrations = []); 747 registrations.push(this); 748 }, 749 removeTransientObservers: function() { 750 var transientObservedNodes = this.transientObservedNodes; 751 this.transientObservedNodes = []; 752 for (var i = 0; i < transientObservedNodes.length; i++) { 753 var node = transientObservedNodes[i]; 754 var registrations = registrationsTable.get(node); 755 for (var j = 0; j < registrations.length; j++) { 756 if (registrations[j] === this) { 757 registrations.splice(j, 1); 758 break; 759 } 760 } 761 } 762 } 763 }; 764 scope.enqueueMutation = enqueueMutation; 765 scope.registerTransientObservers = registerTransientObservers; 766 scope.wrappers.MutationObserver = MutationObserver; 767 scope.wrappers.MutationRecord = MutationRecord; 768 })(window.ShadowDOMPolyfill); 769 (function(scope) { 770 "use strict"; 771 function TreeScope(root, parent) { 772 this.root = root; 773 this.parent = parent; 774 } 775 TreeScope.prototype = { 776 get renderer() { 777 if (this.root instanceof scope.wrappers.ShadowRoot) { 778 return scope.getRendererForHost(this.root.host); 779 } 780 return null; 781 }, 782 contains: function(treeScope) { 783 for (;treeScope; treeScope = treeScope.parent) { 784 if (treeScope === this) return true; 785 } 786 return false; 787 } 788 }; 789 function setTreeScope(node, treeScope) { 790 if (node.treeScope_ !== treeScope) { 791 node.treeScope_ = treeScope; 792 for (var sr = node.shadowRoot; sr; sr = sr.olderShadowRoot) { 793 sr.treeScope_.parent = treeScope; 794 } 795 for (var child = node.firstChild; child; child = child.nextSibling) { 796 setTreeScope(child, treeScope); 797 } 798 } 799 } 800 function getTreeScope(node) { 801 if (node instanceof scope.wrappers.Window) { 802 debugger; 803 } 804 if (node.treeScope_) return node.treeScope_; 805 var parent = node.parentNode; 806 var treeScope; 807 if (parent) treeScope = getTreeScope(parent); else treeScope = new TreeScope(node, null); 808 return node.treeScope_ = treeScope; 809 } 810 scope.TreeScope = TreeScope; 811 scope.getTreeScope = getTreeScope; 812 scope.setTreeScope = setTreeScope; 813 })(window.ShadowDOMPolyfill); 814 (function(scope) { 815 "use strict"; 816 var forwardMethodsToWrapper = scope.forwardMethodsToWrapper; 817 var getTreeScope = scope.getTreeScope; 818 var mixin = scope.mixin; 819 var registerWrapper = scope.registerWrapper; 820 var setWrapper = scope.setWrapper; 821 var unsafeUnwrap = scope.unsafeUnwrap; 822 var unwrap = scope.unwrap; 823 var wrap = scope.wrap; 824 var wrappers = scope.wrappers; 825 var wrappedFuns = new WeakMap(); 826 var listenersTable = new WeakMap(); 827 var handledEventsTable = new WeakMap(); 828 var currentlyDispatchingEvents = new WeakMap(); 829 var targetTable = new WeakMap(); 830 var currentTargetTable = new WeakMap(); 831 var relatedTargetTable = new WeakMap(); 832 var eventPhaseTable = new WeakMap(); 833 var stopPropagationTable = new WeakMap(); 834 var stopImmediatePropagationTable = new WeakMap(); 835 var eventHandlersTable = new WeakMap(); 836 var eventPathTable = new WeakMap(); 837 function isShadowRoot(node) { 838 return node instanceof wrappers.ShadowRoot; 839 } 840 function rootOfNode(node) { 841 return getTreeScope(node).root; 842 } 843 function getEventPath(node, event) { 844 var path = []; 845 var current = node; 846 path.push(current); 847 while (current) { 848 var destinationInsertionPoints = getDestinationInsertionPoints(current); 849 if (destinationInsertionPoints && destinationInsertionPoints.length > 0) { 850 for (var i = 0; i < destinationInsertionPoints.length; i++) { 851 var insertionPoint = destinationInsertionPoints[i]; 852 if (isShadowInsertionPoint(insertionPoint)) { 853 var shadowRoot = rootOfNode(insertionPoint); 854 var olderShadowRoot = shadowRoot.olderShadowRoot; 855 if (olderShadowRoot) path.push(olderShadowRoot); 856 } 857 path.push(insertionPoint); 858 } 859 current = destinationInsertionPoints[destinationInsertionPoints.length - 1]; 860 } else { 861 if (isShadowRoot(current)) { 862 if (inSameTree(node, current) && eventMustBeStopped(event)) { 863 break; 864 } 865 current = current.host; 866 path.push(current); 867 } else { 868 current = current.parentNode; 869 if (current) path.push(current); 870 } 871 } 872 } 873 return path; 874 } 875 function eventMustBeStopped(event) { 876 if (!event) return false; 877 switch (event.type) { 878 case "abort": 879 case "error": 880 case "select": 881 case "change": 882 case "load": 883 case "reset": 884 case "resize": 885 case "scroll": 886 case "selectstart": 887 return true; 888 } 889 return false; 890 } 891 function isShadowInsertionPoint(node) { 892 return node instanceof HTMLShadowElement; 893 } 894 function getDestinationInsertionPoints(node) { 895 return scope.getDestinationInsertionPoints(node); 896 } 897 function eventRetargetting(path, currentTarget) { 898 if (path.length === 0) return currentTarget; 899 if (currentTarget instanceof wrappers.Window) currentTarget = currentTarget.document; 900 var currentTargetTree = getTreeScope(currentTarget); 901 var originalTarget = path[0]; 902 var originalTargetTree = getTreeScope(originalTarget); 903 var relativeTargetTree = lowestCommonInclusiveAncestor(currentTargetTree, originalTargetTree); 904 for (var i = 0; i < path.length; i++) { 905 var node = path[i]; 906 if (getTreeScope(node) === relativeTargetTree) return node; 907 } 908 return path[path.length - 1]; 909 } 910 function getTreeScopeAncestors(treeScope) { 911 var ancestors = []; 912 for (;treeScope; treeScope = treeScope.parent) { 913 ancestors.push(treeScope); 914 } 915 return ancestors; 916 } 917 function lowestCommonInclusiveAncestor(tsA, tsB) { 918 var ancestorsA = getTreeScopeAncestors(tsA); 919 var ancestorsB = getTreeScopeAncestors(tsB); 920 var result = null; 921 while (ancestorsA.length > 0 && ancestorsB.length > 0) { 922 var a = ancestorsA.pop(); 923 var b = ancestorsB.pop(); 924 if (a === b) result = a; else break; 925 } 926 return result; 927 } 928 function getTreeScopeRoot(ts) { 929 if (!ts.parent) return ts; 930 return getTreeScopeRoot(ts.parent); 931 } 932 function relatedTargetResolution(event, currentTarget, relatedTarget) { 933 if (currentTarget instanceof wrappers.Window) currentTarget = currentTarget.document; 934 var currentTargetTree = getTreeScope(currentTarget); 935 var relatedTargetTree = getTreeScope(relatedTarget); 936 var relatedTargetEventPath = getEventPath(relatedTarget, event); 937 var lowestCommonAncestorTree; 938 var lowestCommonAncestorTree = lowestCommonInclusiveAncestor(currentTargetTree, relatedTargetTree); 939 if (!lowestCommonAncestorTree) lowestCommonAncestorTree = relatedTargetTree.root; 940 for (var commonAncestorTree = lowestCommonAncestorTree; commonAncestorTree; commonAncestorTree = commonAncestorTree.parent) { 941 var adjustedRelatedTarget; 942 for (var i = 0; i < relatedTargetEventPath.length; i++) { 943 var node = relatedTargetEventPath[i]; 944 if (getTreeScope(node) === commonAncestorTree) return node; 945 } 946 } 947 return null; 948 } 949 function inSameTree(a, b) { 950 return getTreeScope(a) === getTreeScope(b); 951 } 952 var NONE = 0; 953 var CAPTURING_PHASE = 1; 954 var AT_TARGET = 2; 955 var BUBBLING_PHASE = 3; 956 var pendingError; 957 function dispatchOriginalEvent(originalEvent) { 958 if (handledEventsTable.get(originalEvent)) return; 959 handledEventsTable.set(originalEvent, true); 960 dispatchEvent(wrap(originalEvent), wrap(originalEvent.target)); 961 if (pendingError) { 962 var err = pendingError; 963 pendingError = null; 964 throw err; 965 } 966 } 967 function isLoadLikeEvent(event) { 968 switch (event.type) { 969 case "load": 970 case "beforeunload": 971 case "unload": 972 return true; 973 } 974 return false; 975 } 976 function dispatchEvent(event, originalWrapperTarget) { 977 if (currentlyDispatchingEvents.get(event)) throw new Error("InvalidStateError"); 978 currentlyDispatchingEvents.set(event, true); 979 scope.renderAllPending(); 980 var eventPath; 981 var overrideTarget; 982 var win; 983 if (isLoadLikeEvent(event) && !event.bubbles) { 984 var doc = originalWrapperTarget; 985 if (doc instanceof wrappers.Document && (win = doc.defaultView)) { 986 overrideTarget = doc; 987 eventPath = []; 988 } 989 } 990 if (!eventPath) { 991 if (originalWrapperTarget instanceof wrappers.Window) { 992 win = originalWrapperTarget; 993 eventPath = []; 994 } else { 995 eventPath = getEventPath(originalWrapperTarget, event); 996 if (!isLoadLikeEvent(event)) { 997 var doc = eventPath[eventPath.length - 1]; 998 if (doc instanceof wrappers.Document) win = doc.defaultView; 999 } 1000 } 1001 } 1002 eventPathTable.set(event, eventPath); 1003 if (dispatchCapturing(event, eventPath, win, overrideTarget)) { 1004 if (dispatchAtTarget(event, eventPath, win, overrideTarget)) { 1005 dispatchBubbling(event, eventPath, win, overrideTarget); 1006 } 1007 } 1008 eventPhaseTable.set(event, NONE); 1009 currentTargetTable.delete(event, null); 1010 currentlyDispatchingEvents.delete(event); 1011 return event.defaultPrevented; 1012 } 1013 function dispatchCapturing(event, eventPath, win, overrideTarget) { 1014 var phase = CAPTURING_PHASE; 1015 if (win) { 1016 if (!invoke(win, event, phase, eventPath, overrideTarget)) return false; 1017 } 1018 for (var i = eventPath.length - 1; i > 0; i--) { 1019 if (!invoke(eventPath[i], event, phase, eventPath, overrideTarget)) return false; 1020 } 1021 return true; 1022 } 1023 function dispatchAtTarget(event, eventPath, win, overrideTarget) { 1024 var phase = AT_TARGET; 1025 var currentTarget = eventPath[0] || win; 1026 return invoke(currentTarget, event, phase, eventPath, overrideTarget); 1027 } 1028 function dispatchBubbling(event, eventPath, win, overrideTarget) { 1029 var phase = BUBBLING_PHASE; 1030 for (var i = 1; i < eventPath.length; i++) { 1031 if (!invoke(eventPath[i], event, phase, eventPath, overrideTarget)) return; 1032 } 1033 if (win && eventPath.length > 0) { 1034 invoke(win, event, phase, eventPath, overrideTarget); 1035 } 1036 } 1037 function invoke(currentTarget, event, phase, eventPath, overrideTarget) { 1038 var listeners = listenersTable.get(currentTarget); 1039 if (!listeners) return true; 1040 var target = overrideTarget || eventRetargetting(eventPath, currentTarget); 1041 if (target === currentTarget) { 1042 if (phase === CAPTURING_PHASE) return true; 1043 if (phase === BUBBLING_PHASE) phase = AT_TARGET; 1044 } else if (phase === BUBBLING_PHASE && !event.bubbles) { 1045 return true; 1046 } 1047 if ("relatedTarget" in event) { 1048 var originalEvent = unwrap(event); 1049 var unwrappedRelatedTarget = originalEvent.relatedTarget; 1050 if (unwrappedRelatedTarget) { 1051 if (unwrappedRelatedTarget instanceof Object && unwrappedRelatedTarget.addEventListener) { 1052 var relatedTarget = wrap(unwrappedRelatedTarget); 1053 var adjusted = relatedTargetResolution(event, currentTarget, relatedTarget); 1054 if (adjusted === target) return true; 1055 } else { 1056 adjusted = null; 1057 } 1058 relatedTargetTable.set(event, adjusted); 1059 } 1060 } 1061 eventPhaseTable.set(event, phase); 1062 var type = event.type; 1063 var anyRemoved = false; 1064 targetTable.set(event, target); 1065 currentTargetTable.set(event, currentTarget); 1066 listeners.depth++; 1067 for (var i = 0, len = listeners.length; i < len; i++) { 1068 var listener = listeners[i]; 1069 if (listener.removed) { 1070 anyRemoved = true; 1071 continue; 1072 } 1073 if (listener.type !== type || !listener.capture && phase === CAPTURING_PHASE || listener.capture && phase === BUBBLING_PHASE) { 1074 continue; 1075 } 1076 try { 1077 if (typeof listener.handler === "function") listener.handler.call(currentTarget, event); else listener.handler.handleEvent(event); 1078 if (stopImmediatePropagationTable.get(event)) return false; 1079 } catch (ex) { 1080 if (!pendingError) pendingError = ex; 1081 } 1082 } 1083 listeners.depth--; 1084 if (anyRemoved && listeners.depth === 0) { 1085 var copy = listeners.slice(); 1086 listeners.length = 0; 1087 for (var i = 0; i < copy.length; i++) { 1088 if (!copy[i].removed) listeners.push(copy[i]); 1089 } 1090 } 1091 return !stopPropagationTable.get(event); 1092 } 1093 function Listener(type, handler, capture) { 1094 this.type = type; 1095 this.handler = handler; 1096 this.capture = Boolean(capture); 1097 } 1098 Listener.prototype = { 1099 equals: function(that) { 1100 return this.handler === that.handler && this.type === that.type && this.capture === that.capture; 1101 }, 1102 get removed() { 1103 return this.handler === null; 1104 }, 1105 remove: function() { 1106 this.handler = null; 1107 } 1108 }; 1109 var OriginalEvent = window.Event; 1110 OriginalEvent.prototype.polymerBlackList_ = { 1111 returnValue: true, 1112 keyLocation: true 1113 }; 1114 function Event(type, options) { 1115 if (type instanceof OriginalEvent) { 1116 var impl = type; 1117 if (!OriginalBeforeUnloadEvent && impl.type === "beforeunload" && !(this instanceof BeforeUnloadEvent)) { 1118 return new BeforeUnloadEvent(impl); 1119 } 1120 setWrapper(impl, this); 1121 } else { 1122 return wrap(constructEvent(OriginalEvent, "Event", type, options)); 1123 } 1124 } 1125 Event.prototype = { 1126 get target() { 1127 return targetTable.get(this); 1128 }, 1129 get currentTarget() { 1130 return currentTargetTable.get(this); 1131 }, 1132 get eventPhase() { 1133 return eventPhaseTable.get(this); 1134 }, 1135 get path() { 1136 var eventPath = eventPathTable.get(this); 1137 if (!eventPath) return []; 1138 return eventPath.slice(); 1139 }, 1140 stopPropagation: function() { 1141 stopPropagationTable.set(this, true); 1142 }, 1143 stopImmediatePropagation: function() { 1144 stopPropagationTable.set(this, true); 1145 stopImmediatePropagationTable.set(this, true); 1146 } 1147 }; 1148 registerWrapper(OriginalEvent, Event, document.createEvent("Event")); 1149 function unwrapOptions(options) { 1150 if (!options || !options.relatedTarget) return options; 1151 return Object.create(options, { 1152 relatedTarget: { 1153 value: unwrap(options.relatedTarget) 1154 } 1155 }); 1156 } 1157 function registerGenericEvent(name, SuperEvent, prototype) { 1158 var OriginalEvent = window[name]; 1159 var GenericEvent = function(type, options) { 1160 if (type instanceof OriginalEvent) setWrapper(type, this); else return wrap(constructEvent(OriginalEvent, name, type, options)); 1161 }; 1162 GenericEvent.prototype = Object.create(SuperEvent.prototype); 1163 if (prototype) mixin(GenericEvent.prototype, prototype); 1164 if (OriginalEvent) { 1165 try { 1166 registerWrapper(OriginalEvent, GenericEvent, new OriginalEvent("temp")); 1167 } catch (ex) { 1168 registerWrapper(OriginalEvent, GenericEvent, document.createEvent(name)); 1169 } 1170 } 1171 return GenericEvent; 1172 } 1173 var UIEvent = registerGenericEvent("UIEvent", Event); 1174 var CustomEvent = registerGenericEvent("CustomEvent", Event); 1175 var relatedTargetProto = { 1176 get relatedTarget() { 1177 var relatedTarget = relatedTargetTable.get(this); 1178 if (relatedTarget !== undefined) return relatedTarget; 1179 return wrap(unwrap(this).relatedTarget); 1180 } 1181 }; 1182 function getInitFunction(name, relatedTargetIndex) { 1183 return function() { 1184 arguments[relatedTargetIndex] = unwrap(arguments[relatedTargetIndex]); 1185 var impl = unwrap(this); 1186 impl[name].apply(impl, arguments); 1187 }; 1188 } 1189 var mouseEventProto = mixin({ 1190 initMouseEvent: getInitFunction("initMouseEvent", 14) 1191 }, relatedTargetProto); 1192 var focusEventProto = mixin({ 1193 initFocusEvent: getInitFunction("initFocusEvent", 5) 1194 }, relatedTargetProto); 1195 var MouseEvent = registerGenericEvent("MouseEvent", UIEvent, mouseEventProto); 1196 var FocusEvent = registerGenericEvent("FocusEvent", UIEvent, focusEventProto); 1197 var defaultInitDicts = Object.create(null); 1198 var supportsEventConstructors = function() { 1199 try { 1200 new window.FocusEvent("focus"); 1201 } catch (ex) { 1202 return false; 1203 } 1204 return true; 1205 }(); 1206 function constructEvent(OriginalEvent, name, type, options) { 1207 if (supportsEventConstructors) return new OriginalEvent(type, unwrapOptions(options)); 1208 var event = unwrap(document.createEvent(name)); 1209 var defaultDict = defaultInitDicts[name]; 1210 var args = [ type ]; 1211 Object.keys(defaultDict).forEach(function(key) { 1212 var v = options != null && key in options ? options[key] : defaultDict[key]; 1213 if (key === "relatedTarget") v = unwrap(v); 1214 args.push(v); 1215 }); 1216 event["init" + name].apply(event, args); 1217 return event; 1218 } 1219 if (!supportsEventConstructors) { 1220 var configureEventConstructor = function(name, initDict, superName) { 1221 if (superName) { 1222 var superDict = defaultInitDicts[superName]; 1223 initDict = mixin(mixin({}, superDict), initDict); 1224 } 1225 defaultInitDicts[name] = initDict; 1226 }; 1227 configureEventConstructor("Event", { 1228 bubbles: false, 1229 cancelable: false 1230 }); 1231 configureEventConstructor("CustomEvent", { 1232 detail: null 1233 }, "Event"); 1234 configureEventConstructor("UIEvent", { 1235 view: null, 1236 detail: 0 1237 }, "Event"); 1238 configureEventConstructor("MouseEvent", { 1239 screenX: 0, 1240 screenY: 0, 1241 clientX: 0, 1242 clientY: 0, 1243 ctrlKey: false, 1244 altKey: false, 1245 shiftKey: false, 1246 metaKey: false, 1247 button: 0, 1248 relatedTarget: null 1249 }, "UIEvent"); 1250 configureEventConstructor("FocusEvent", { 1251 relatedTarget: null 1252 }, "UIEvent"); 1253 } 1254 var OriginalBeforeUnloadEvent = window.BeforeUnloadEvent; 1255 function BeforeUnloadEvent(impl) { 1256 Event.call(this, impl); 1257 } 1258 BeforeUnloadEvent.prototype = Object.create(Event.prototype); 1259 mixin(BeforeUnloadEvent.prototype, { 1260 get returnValue() { 1261 return unsafeUnwrap(this).returnValue; 1262 }, 1263 set returnValue(v) { 1264 unsafeUnwrap(this).returnValue = v; 1265 } 1266 }); 1267 if (OriginalBeforeUnloadEvent) registerWrapper(OriginalBeforeUnloadEvent, BeforeUnloadEvent); 1268 function isValidListener(fun) { 1269 if (typeof fun === "function") return true; 1270 return fun && fun.handleEvent; 1271 } 1272 function isMutationEvent(type) { 1273 switch (type) { 1274 case "DOMAttrModified": 1275 case "DOMAttributeNameChanged": 1276 case "DOMCharacterDataModified": 1277 case "DOMElementNameChanged": 1278 case "DOMNodeInserted": 1279 case "DOMNodeInsertedIntoDocument": 1280 case "DOMNodeRemoved": 1281 case "DOMNodeRemovedFromDocument": 1282 case "DOMSubtreeModified": 1283 return true; 1284 } 1285 return false; 1286 } 1287 var OriginalEventTarget = window.EventTarget; 1288 function EventTarget(impl) { 1289 setWrapper(impl, this); 1290 } 1291 var methodNames = [ "addEventListener", "removeEventListener", "dispatchEvent" ]; 1292 [ Node, Window ].forEach(function(constructor) { 1293 var p = constructor.prototype; 1294 methodNames.forEach(function(name) { 1295 Object.defineProperty(p, name + "_", { 1296 value: p[name] 1297 }); 1298 }); 1299 }); 1300 function getTargetToListenAt(wrapper) { 1301 if (wrapper instanceof wrappers.ShadowRoot) wrapper = wrapper.host; 1302 return unwrap(wrapper); 1303 } 1304 EventTarget.prototype = { 1305 addEventListener: function(type, fun, capture) { 1306 if (!isValidListener(fun) || isMutationEvent(type)) return; 1307 var listener = new Listener(type, fun, capture); 1308 var listeners = listenersTable.get(this); 1309 if (!listeners) { 1310 listeners = []; 1311 listeners.depth = 0; 1312 listenersTable.set(this, listeners); 1313 } else { 1314 for (var i = 0; i < listeners.length; i++) { 1315 if (listener.equals(listeners[i])) return; 1316 } 1317 } 1318 listeners.push(listener); 1319 var target = getTargetToListenAt(this); 1320 target.addEventListener_(type, dispatchOriginalEvent, true); 1321 }, 1322 removeEventListener: function(type, fun, capture) { 1323 capture = Boolean(capture); 1324 var listeners = listenersTable.get(this); 1325 if (!listeners) return; 1326 var count = 0, found = false; 1327 for (var i = 0; i < listeners.length; i++) { 1328 if (listeners[i].type === type && listeners[i].capture === capture) { 1329 count++; 1330 if (listeners[i].handler === fun) { 1331 found = true; 1332 listeners[i].remove(); 1333 } 1334 } 1335 } 1336 if (found && count === 1) { 1337 var target = getTargetToListenAt(this); 1338 target.removeEventListener_(type, dispatchOriginalEvent, true); 1339 } 1340 }, 1341 dispatchEvent: function(event) { 1342 var nativeEvent = unwrap(event); 1343 var eventType = nativeEvent.type; 1344 handledEventsTable.set(nativeEvent, false); 1345 scope.renderAllPending(); 1346 var tempListener; 1347 if (!hasListenerInAncestors(this, eventType)) { 1348 tempListener = function() {}; 1349 this.addEventListener(eventType, tempListener, true); 1350 } 1351 try { 1352 return unwrap(this).dispatchEvent_(nativeEvent); 1353 } finally { 1354 if (tempListener) this.removeEventListener(eventType, tempListener, true); 1355 } 1356 } 1357 }; 1358 function hasListener(node, type) { 1359 var listeners = listenersTable.get(node); 1360 if (listeners) { 1361 for (var i = 0; i < listeners.length; i++) { 1362 if (!listeners[i].removed && listeners[i].type === type) return true; 1363 } 1364 } 1365 return false; 1366 } 1367 function hasListenerInAncestors(target, type) { 1368 for (var node = unwrap(target); node; node = node.parentNode) { 1369 if (hasListener(wrap(node), type)) return true; 1370 } 1371 return false; 1372 } 1373 if (OriginalEventTarget) registerWrapper(OriginalEventTarget, EventTarget); 1374 function wrapEventTargetMethods(constructors) { 1375 forwardMethodsToWrapper(constructors, methodNames); 1376 } 1377 var originalElementFromPoint = document.elementFromPoint; 1378 function elementFromPoint(self, document, x, y) { 1379 scope.renderAllPending(); 1380 var element = wrap(originalElementFromPoint.call(unsafeUnwrap(document), x, y)); 1381 if (!element) return null; 1382 var path = getEventPath(element, null); 1383 var idx = path.lastIndexOf(self); 1384 if (idx == -1) return null; else path = path.slice(0, idx); 1385 return eventRetargetting(path, self); 1386 } 1387 function getEventHandlerGetter(name) { 1388 return function() { 1389 var inlineEventHandlers = eventHandlersTable.get(this); 1390 return inlineEventHandlers && inlineEventHandlers[name] && inlineEventHandlers[name].value || null; 1391 }; 1392 } 1393 function getEventHandlerSetter(name) { 1394 var eventType = name.slice(2); 1395 return function(value) { 1396 var inlineEventHandlers = eventHandlersTable.get(this); 1397 if (!inlineEventHandlers) { 1398 inlineEventHandlers = Object.create(null); 1399 eventHandlersTable.set(this, inlineEventHandlers); 1400 } 1401 var old = inlineEventHandlers[name]; 1402 if (old) this.removeEventListener(eventType, old.wrapped, false); 1403 if (typeof value === "function") { 1404 var wrapped = function(e) { 1405 var rv = value.call(this, e); 1406 if (rv === false) e.preventDefault(); else if (name === "onbeforeunload" && typeof rv === "string") e.returnValue = rv; 1407 }; 1408 this.addEventListener(eventType, wrapped, false); 1409 inlineEventHandlers[name] = { 1410 value: value, 1411 wrapped: wrapped 1412 }; 1413 } 1414 }; 1415 } 1416 scope.elementFromPoint = elementFromPoint; 1417 scope.getEventHandlerGetter = getEventHandlerGetter; 1418 scope.getEventHandlerSetter = getEventHandlerSetter; 1419 scope.wrapEventTargetMethods = wrapEventTargetMethods; 1420 scope.wrappers.BeforeUnloadEvent = BeforeUnloadEvent; 1421 scope.wrappers.CustomEvent = CustomEvent; 1422 scope.wrappers.Event = Event; 1423 scope.wrappers.EventTarget = EventTarget; 1424 scope.wrappers.FocusEvent = FocusEvent; 1425 scope.wrappers.MouseEvent = MouseEvent; 1426 scope.wrappers.UIEvent = UIEvent; 1427 })(window.ShadowDOMPolyfill); 1428 (function(scope) { 1429 "use strict"; 1430 var UIEvent = scope.wrappers.UIEvent; 1431 var mixin = scope.mixin; 1432 var registerWrapper = scope.registerWrapper; 1433 var setWrapper = scope.setWrapper; 1434 var unsafeUnwrap = scope.unsafeUnwrap; 1435 var wrap = scope.wrap; 1436 var OriginalTouchEvent = window.TouchEvent; 1437 if (!OriginalTouchEvent) return; 1438 var nativeEvent; 1439 try { 1440 nativeEvent = document.createEvent("TouchEvent"); 1441 } catch (ex) { 1442 return; 1443 } 1444 var nonEnumDescriptor = { 1445 enumerable: false 1446 }; 1447 function nonEnum(obj, prop) { 1448 Object.defineProperty(obj, prop, nonEnumDescriptor); 1449 } 1450 function Touch(impl) { 1451 setWrapper(impl, this); 1452 } 1453 Touch.prototype = { 1454 get target() { 1455 return wrap(unsafeUnwrap(this).target); 1456 } 1457 }; 1458 var descr = { 1459 configurable: true, 1460 enumerable: true, 1461 get: null 1462 }; 1463 [ "clientX", "clientY", "screenX", "screenY", "pageX", "pageY", "identifier", "webkitRadiusX", "webkitRadiusY", "webkitRotationAngle", "webkitForce" ].forEach(function(name) { 1464 descr.get = function() { 1465 return unsafeUnwrap(this)[name]; 1466 }; 1467 Object.defineProperty(Touch.prototype, name, descr); 1468 }); 1469 function TouchList() { 1470 this.length = 0; 1471 nonEnum(this, "length"); 1472 } 1473 TouchList.prototype = { 1474 item: function(index) { 1475 return this[index]; 1476 } 1477 }; 1478 function wrapTouchList(nativeTouchList) { 1479 var list = new TouchList(); 1480 for (var i = 0; i < nativeTouchList.length; i++) { 1481 list[i] = new Touch(nativeTouchList[i]); 1482 } 1483 list.length = i; 1484 return list; 1485 } 1486 function TouchEvent(impl) { 1487 UIEvent.call(this, impl); 1488 } 1489 TouchEvent.prototype = Object.create(UIEvent.prototype); 1490 mixin(TouchEvent.prototype, { 1491 get touches() { 1492 return wrapTouchList(unsafeUnwrap(this).touches); 1493 }, 1494 get targetTouches() { 1495 return wrapTouchList(unsafeUnwrap(this).targetTouches); 1496 }, 1497 get changedTouches() { 1498 return wrapTouchList(unsafeUnwrap(this).changedTouches); 1499 }, 1500 initTouchEvent: function() { 1501 throw new Error("Not implemented"); 1502 } 1503 }); 1504 registerWrapper(OriginalTouchEvent, TouchEvent, nativeEvent); 1505 scope.wrappers.Touch = Touch; 1506 scope.wrappers.TouchEvent = TouchEvent; 1507 scope.wrappers.TouchList = TouchList; 1508 })(window.ShadowDOMPolyfill); 1509 (function(scope) { 1510 "use strict"; 1511 var unsafeUnwrap = scope.unsafeUnwrap; 1512 var wrap = scope.wrap; 1513 var nonEnumDescriptor = { 1514 enumerable: false 1515 }; 1516 function nonEnum(obj, prop) { 1517 Object.defineProperty(obj, prop, nonEnumDescriptor); 1518 } 1519 function NodeList() { 1520 this.length = 0; 1521 nonEnum(this, "length"); 1522 } 1523 NodeList.prototype = { 1524 item: function(index) { 1525 return this[index]; 1526 } 1527 }; 1528 nonEnum(NodeList.prototype, "item"); 1529 function wrapNodeList(list) { 1530 if (list == null) return list; 1531 var wrapperList = new NodeList(); 1532 for (var i = 0, length = list.length; i < length; i++) { 1533 wrapperList[i] = wrap(list[i]); 1534 } 1535 wrapperList.length = length; 1536 return wrapperList; 1537 } 1538 function addWrapNodeListMethod(wrapperConstructor, name) { 1539 wrapperConstructor.prototype[name] = function() { 1540 return wrapNodeList(unsafeUnwrap(this)[name].apply(unsafeUnwrap(this), arguments)); 1541 }; 1542 } 1543 scope.wrappers.NodeList = NodeList; 1544 scope.addWrapNodeListMethod = addWrapNodeListMethod; 1545 scope.wrapNodeList = wrapNodeList; 1546 })(window.ShadowDOMPolyfill); 1547 (function(scope) { 1548 "use strict"; 1549 scope.wrapHTMLCollection = scope.wrapNodeList; 1550 scope.wrappers.HTMLCollection = scope.wrappers.NodeList; 1551 })(window.ShadowDOMPolyfill); 1552 (function(scope) { 1553 "use strict"; 1554 var EventTarget = scope.wrappers.EventTarget; 1555 var NodeList = scope.wrappers.NodeList; 1556 var TreeScope = scope.TreeScope; 1557 var assert = scope.assert; 1558 var defineWrapGetter = scope.defineWrapGetter; 1559 var enqueueMutation = scope.enqueueMutation; 1560 var getTreeScope = scope.getTreeScope; 1561 var isWrapper = scope.isWrapper; 1562 var mixin = scope.mixin; 1563 var registerTransientObservers = scope.registerTransientObservers; 1564 var registerWrapper = scope.registerWrapper; 1565 var setTreeScope = scope.setTreeScope; 1566 var unsafeUnwrap = scope.unsafeUnwrap; 1567 var unwrap = scope.unwrap; 1568 var unwrapIfNeeded = scope.unwrapIfNeeded; 1569 var wrap = scope.wrap; 1570 var wrapIfNeeded = scope.wrapIfNeeded; 1571 var wrappers = scope.wrappers; 1572 function assertIsNodeWrapper(node) { 1573 assert(node instanceof Node); 1574 } 1575 function createOneElementNodeList(node) { 1576 var nodes = new NodeList(); 1577 nodes[0] = node; 1578 nodes.length = 1; 1579 return nodes; 1580 } 1581 var surpressMutations = false; 1582 function enqueueRemovalForInsertedNodes(node, parent, nodes) { 1583 enqueueMutation(parent, "childList", { 1584 removedNodes: nodes, 1585 previousSibling: node.previousSibling, 1586 nextSibling: node.nextSibling 1587 }); 1588 } 1589 function enqueueRemovalForInsertedDocumentFragment(df, nodes) { 1590 enqueueMutation(df, "childList", { 1591 removedNodes: nodes 1592 }); 1593 } 1594 function collectNodes(node, parentNode, previousNode, nextNode) { 1595 if (node instanceof DocumentFragment) { 1596 var nodes = collectNodesForDocumentFragment(node); 1597 surpressMutations = true; 1598 for (var i = nodes.length - 1; i >= 0; i--) { 1599 node.removeChild(nodes[i]); 1600 nodes[i].parentNode_ = parentNode; 1601 } 1602 surpressMutations = false; 1603 for (var i = 0; i < nodes.length; i++) { 1604 nodes[i].previousSibling_ = nodes[i - 1] || previousNode; 1605 nodes[i].nextSibling_ = nodes[i + 1] || nextNode; 1606 } 1607 if (previousNode) previousNode.nextSibling_ = nodes[0]; 1608 if (nextNode) nextNode.previousSibling_ = nodes[nodes.length - 1]; 1609 return nodes; 1610 } 1611 var nodes = createOneElementNodeList(node); 1612 var oldParent = node.parentNode; 1613 if (oldParent) { 1614 oldParent.removeChild(node); 1615 } 1616 node.parentNode_ = parentNode; 1617 node.previousSibling_ = previousNode; 1618 node.nextSibling_ = nextNode; 1619 if (previousNode) previousNode.nextSibling_ = node; 1620 if (nextNode) nextNode.previousSibling_ = node; 1621 return nodes; 1622 } 1623 function collectNodesNative(node) { 1624 if (node instanceof DocumentFragment) return collectNodesForDocumentFragment(node); 1625 var nodes = createOneElementNodeList(node); 1626 var oldParent = node.parentNode; 1627 if (oldParent) enqueueRemovalForInsertedNodes(node, oldParent, nodes); 1628 return nodes; 1629 } 1630 function collectNodesForDocumentFragment(node) { 1631 var nodes = new NodeList(); 1632 var i = 0; 1633 for (var child = node.firstChild; child; child = child.nextSibling) { 1634 nodes[i++] = child; 1635 } 1636 nodes.length = i; 1637 enqueueRemovalForInsertedDocumentFragment(node, nodes); 1638 return nodes; 1639 } 1640 function snapshotNodeList(nodeList) { 1641 return nodeList; 1642 } 1643 function nodeWasAdded(node, treeScope) { 1644 setTreeScope(node, treeScope); 1645 node.nodeIsInserted_(); 1646 } 1647 function nodesWereAdded(nodes, parent) { 1648 var treeScope = getTreeScope(parent); 1649 for (var i = 0; i < nodes.length; i++) { 1650 nodeWasAdded(nodes[i], treeScope); 1651 } 1652 } 1653 function nodeWasRemoved(node) { 1654 setTreeScope(node, new TreeScope(node, null)); 1655 } 1656 function nodesWereRemoved(nodes) { 1657 for (var i = 0; i < nodes.length; i++) { 1658 nodeWasRemoved(nodes[i]); 1659 } 1660 } 1661 function ensureSameOwnerDocument(parent, child) { 1662 var ownerDoc = parent.nodeType === Node.DOCUMENT_NODE ? parent : parent.ownerDocument; 1663 if (ownerDoc !== child.ownerDocument) ownerDoc.adoptNode(child); 1664 } 1665 function adoptNodesIfNeeded(owner, nodes) { 1666 if (!nodes.length) return; 1667 var ownerDoc = owner.ownerDocument; 1668 if (ownerDoc === nodes[0].ownerDocument) return; 1669 for (var i = 0; i < nodes.length; i++) { 1670 scope.adoptNodeNoRemove(nodes[i], ownerDoc); 1671 } 1672 } 1673 function unwrapNodesForInsertion(owner, nodes) { 1674 adoptNodesIfNeeded(owner, nodes); 1675 var length = nodes.length; 1676 if (length === 1) return unwrap(nodes[0]); 1677 var df = unwrap(owner.ownerDocument.createDocumentFragment()); 1678 for (var i = 0; i < length; i++) { 1679 df.appendChild(unwrap(nodes[i])); 1680 } 1681 return df; 1682 } 1683 function clearChildNodes(wrapper) { 1684 if (wrapper.firstChild_ !== undefined) { 1685 var child = wrapper.firstChild_; 1686 while (child) { 1687 var tmp = child; 1688 child = child.nextSibling_; 1689 tmp.parentNode_ = tmp.previousSibling_ = tmp.nextSibling_ = undefined; 1690 } 1691 } 1692 wrapper.firstChild_ = wrapper.lastChild_ = undefined; 1693 } 1694 function removeAllChildNodes(wrapper) { 1695 if (wrapper.invalidateShadowRenderer()) { 1696 var childWrapper = wrapper.firstChild; 1697 while (childWrapper) { 1698 assert(childWrapper.parentNode === wrapper); 1699 var nextSibling = childWrapper.nextSibling; 1700 var childNode = unwrap(childWrapper); 1701 var parentNode = childNode.parentNode; 1702 if (parentNode) originalRemoveChild.call(parentNode, childNode); 1703 childWrapper.previousSibling_ = childWrapper.nextSibling_ = childWrapper.parentNode_ = null; 1704 childWrapper = nextSibling; 1705 } 1706 wrapper.firstChild_ = wrapper.lastChild_ = null; 1707 } else { 1708 var node = unwrap(wrapper); 1709 var child = node.firstChild; 1710 var nextSibling; 1711 while (child) { 1712 nextSibling = child.nextSibling; 1713 originalRemoveChild.call(node, child); 1714 child = nextSibling; 1715 } 1716 } 1717 } 1718 function invalidateParent(node) { 1719 var p = node.parentNode; 1720 return p && p.invalidateShadowRenderer(); 1721 } 1722 function cleanupNodes(nodes) { 1723 for (var i = 0, n; i < nodes.length; i++) { 1724 n = nodes[i]; 1725 n.parentNode.removeChild(n); 1726 } 1727 } 1728 var originalImportNode = document.importNode; 1729 var originalCloneNode = window.Node.prototype.cloneNode; 1730 function cloneNode(node, deep, opt_doc) { 1731 var clone; 1732 if (opt_doc) clone = wrap(originalImportNode.call(opt_doc, unsafeUnwrap(node), false)); else clone = wrap(originalCloneNode.call(unsafeUnwrap(node), false)); 1733 if (deep) { 1734 for (var child = node.firstChild; child; child = child.nextSibling) { 1735 clone.appendChild(cloneNode(child, true, opt_doc)); 1736 } 1737 if (node instanceof wrappers.HTMLTemplateElement) { 1738 var cloneContent = clone.content; 1739 for (var child = node.content.firstChild; child; child = child.nextSibling) { 1740 cloneContent.appendChild(cloneNode(child, true, opt_doc)); 1741 } 1742 } 1743 } 1744 return clone; 1745 } 1746 function contains(self, child) { 1747 if (!child || getTreeScope(self) !== getTreeScope(child)) return false; 1748 for (var node = child; node; node = node.parentNode) { 1749 if (node === self) return true; 1750 } 1751 return false; 1752 } 1753 var OriginalNode = window.Node; 1754 function Node(original) { 1755 assert(original instanceof OriginalNode); 1756 EventTarget.call(this, original); 1757 this.parentNode_ = undefined; 1758 this.firstChild_ = undefined; 1759 this.lastChild_ = undefined; 1760 this.nextSibling_ = undefined; 1761 this.previousSibling_ = undefined; 1762 this.treeScope_ = undefined; 1763 } 1764 var OriginalDocumentFragment = window.DocumentFragment; 1765 var originalAppendChild = OriginalNode.prototype.appendChild; 1766 var originalCompareDocumentPosition = OriginalNode.prototype.compareDocumentPosition; 1767 var originalInsertBefore = OriginalNode.prototype.insertBefore; 1768 var originalRemoveChild = OriginalNode.prototype.removeChild; 1769 var originalReplaceChild = OriginalNode.prototype.replaceChild; 1770 var isIe = /Trident|Edge/.test(navigator.userAgent); 1771 var removeChildOriginalHelper = isIe ? function(parent, child) { 1772 try { 1773 originalRemoveChild.call(parent, child); 1774 } catch (ex) { 1775 if (!(parent instanceof OriginalDocumentFragment)) throw ex; 1776 } 1777 } : function(parent, child) { 1778 originalRemoveChild.call(parent, child); 1779 }; 1780 Node.prototype = Object.create(EventTarget.prototype); 1781 mixin(Node.prototype, { 1782 appendChild: function(childWrapper) { 1783 return this.insertBefore(childWrapper, null); 1784 }, 1785 insertBefore: function(childWrapper, refWrapper) { 1786 assertIsNodeWrapper(childWrapper); 1787 var refNode; 1788 if (refWrapper) { 1789 if (isWrapper(refWrapper)) { 1790 refNode = unwrap(refWrapper); 1791 } else { 1792 refNode = refWrapper; 1793 refWrapper = wrap(refNode); 1794 } 1795 } else { 1796 refWrapper = null; 1797 refNode = null; 1798 } 1799 refWrapper && assert(refWrapper.parentNode === this); 1800 var nodes; 1801 var previousNode = refWrapper ? refWrapper.previousSibling : this.lastChild; 1802 var useNative = !this.invalidateShadowRenderer() && !invalidateParent(childWrapper); 1803 if (useNative) nodes = collectNodesNative(childWrapper); else nodes = collectNodes(childWrapper, this, previousNode, refWrapper); 1804 if (useNative) { 1805 ensureSameOwnerDocument(this, childWrapper); 1806 clearChildNodes(this); 1807 originalInsertBefore.call(unsafeUnwrap(this), unwrap(childWrapper), refNode); 1808 } else { 1809 if (!previousNode) this.firstChild_ = nodes[0]; 1810 if (!refWrapper) { 1811 this.lastChild_ = nodes[nodes.length - 1]; 1812 if (this.firstChild_ === undefined) this.firstChild_ = this.firstChild; 1813 } 1814 var parentNode = refNode ? refNode.parentNode : unsafeUnwrap(this); 1815 if (parentNode) { 1816 originalInsertBefore.call(parentNode, unwrapNodesForInsertion(this, nodes), refNode); 1817 } else { 1818 adoptNodesIfNeeded(this, nodes); 1819 } 1820 } 1821 enqueueMutation(this, "childList", { 1822 addedNodes: nodes, 1823 nextSibling: refWrapper, 1824 previousSibling: previousNode 1825 }); 1826 nodesWereAdded(nodes, this); 1827 return childWrapper; 1828 }, 1829 removeChild: function(childWrapper) { 1830 assertIsNodeWrapper(childWrapper); 1831 if (childWrapper.parentNode !== this) { 1832 var found = false; 1833 var childNodes = this.childNodes; 1834 for (var ieChild = this.firstChild; ieChild; ieChild = ieChild.nextSibling) { 1835 if (ieChild === childWrapper) { 1836 found = true; 1837 break; 1838 } 1839 } 1840 if (!found) { 1841 throw new Error("NotFoundError"); 1842 } 1843 } 1844 var childNode = unwrap(childWrapper); 1845 var childWrapperNextSibling = childWrapper.nextSibling; 1846 var childWrapperPreviousSibling = childWrapper.previousSibling; 1847 if (this.invalidateShadowRenderer()) { 1848 var thisFirstChild = this.firstChild; 1849 var thisLastChild = this.lastChild; 1850 var parentNode = childNode.parentNode; 1851 if (parentNode) removeChildOriginalHelper(parentNode, childNode); 1852 if (thisFirstChild === childWrapper) this.firstChild_ = childWrapperNextSibling; 1853 if (thisLastChild === childWrapper) this.lastChild_ = childWrapperPreviousSibling; 1854 if (childWrapperPreviousSibling) childWrapperPreviousSibling.nextSibling_ = childWrapperNextSibling; 1855 if (childWrapperNextSibling) { 1856 childWrapperNextSibling.previousSibling_ = childWrapperPreviousSibling; 1857 } 1858 childWrapper.previousSibling_ = childWrapper.nextSibling_ = childWrapper.parentNode_ = undefined; 1859 } else { 1860 clearChildNodes(this); 1861 removeChildOriginalHelper(unsafeUnwrap(this), childNode); 1862 } 1863 if (!surpressMutations) { 1864 enqueueMutation(this, "childList", { 1865 removedNodes: createOneElementNodeList(childWrapper), 1866 nextSibling: childWrapperNextSibling, 1867 previousSibling: childWrapperPreviousSibling 1868 }); 1869 } 1870 registerTransientObservers(this, childWrapper); 1871 return childWrapper; 1872 }, 1873 replaceChild: function(newChildWrapper, oldChildWrapper) { 1874 assertIsNodeWrapper(newChildWrapper); 1875 var oldChildNode; 1876 if (isWrapper(oldChildWrapper)) { 1877 oldChildNode = unwrap(oldChildWrapper); 1878 } else { 1879 oldChildNode = oldChildWrapper; 1880 oldChildWrapper = wrap(oldChildNode); 1881 } 1882 if (oldChildWrapper.parentNode !== this) { 1883 throw new Error("NotFoundError"); 1884 } 1885 var nextNode = oldChildWrapper.nextSibling; 1886 var previousNode = oldChildWrapper.previousSibling; 1887 var nodes; 1888 var useNative = !this.invalidateShadowRenderer() && !invalidateParent(newChildWrapper); 1889 if (useNative) { 1890 nodes = collectNodesNative(newChildWrapper); 1891 } else { 1892 if (nextNode === newChildWrapper) nextNode = newChildWrapper.nextSibling; 1893 nodes = collectNodes(newChildWrapper, this, previousNode, nextNode); 1894 } 1895 if (!useNative) { 1896 if (this.firstChild === oldChildWrapper) this.firstChild_ = nodes[0]; 1897 if (this.lastChild === oldChildWrapper) this.lastChild_ = nodes[nodes.length - 1]; 1898 oldChildWrapper.previousSibling_ = oldChildWrapper.nextSibling_ = oldChildWrapper.parentNode_ = undefined; 1899 if (oldChildNode.parentNode) { 1900 originalReplaceChild.call(oldChildNode.parentNode, unwrapNodesForInsertion(this, nodes), oldChildNode); 1901 } 1902 } else { 1903 ensureSameOwnerDocument(this, newChildWrapper); 1904 clearChildNodes(this); 1905 originalReplaceChild.call(unsafeUnwrap(this), unwrap(newChildWrapper), oldChildNode); 1906 } 1907 enqueueMutation(this, "childList", { 1908 addedNodes: nodes, 1909 removedNodes: createOneElementNodeList(oldChildWrapper), 1910 nextSibling: nextNode, 1911 previousSibling: previousNode 1912 }); 1913 nodeWasRemoved(oldChildWrapper); 1914 nodesWereAdded(nodes, this); 1915 return oldChildWrapper; 1916 }, 1917 nodeIsInserted_: function() { 1918 for (var child = this.firstChild; child; child = child.nextSibling) { 1919 child.nodeIsInserted_(); 1920 } 1921 }, 1922 hasChildNodes: function() { 1923 return this.firstChild !== null; 1924 }, 1925 get parentNode() { 1926 return this.parentNode_ !== undefined ? this.parentNode_ : wrap(unsafeUnwrap(this).parentNode); 1927 }, 1928 get firstChild() { 1929 return this.firstChild_ !== undefined ? this.firstChild_ : wrap(unsafeUnwrap(this).firstChild); 1930 }, 1931 get lastChild() { 1932 return this.lastChild_ !== undefined ? this.lastChild_ : wrap(unsafeUnwrap(this).lastChild); 1933 }, 1934 get nextSibling() { 1935 return this.nextSibling_ !== undefined ? this.nextSibling_ : wrap(unsafeUnwrap(this).nextSibling); 1936 }, 1937 get previousSibling() { 1938 return this.previousSibling_ !== undefined ? this.previousSibling_ : wrap(unsafeUnwrap(this).previousSibling); 1939 }, 1940 get parentElement() { 1941 var p = this.parentNode; 1942 while (p && p.nodeType !== Node.ELEMENT_NODE) { 1943 p = p.parentNode; 1944 } 1945 return p; 1946 }, 1947 get textContent() { 1948 var s = ""; 1949 for (var child = this.firstChild; child; child = child.nextSibling) { 1950 if (child.nodeType != Node.COMMENT_NODE) { 1951 s += child.textContent; 1952 } 1953 } 1954 return s; 1955 }, 1956 set textContent(textContent) { 1957 if (textContent == null) textContent = ""; 1958 var removedNodes = snapshotNodeList(this.childNodes); 1959 if (this.invalidateShadowRenderer()) { 1960 removeAllChildNodes(this); 1961 if (textContent !== "") { 1962 var textNode = unsafeUnwrap(this).ownerDocument.createTextNode(textContent); 1963 this.appendChild(textNode); 1964 } 1965 } else { 1966 clearChildNodes(this); 1967 unsafeUnwrap(this).textContent = textContent; 1968 } 1969 var addedNodes = snapshotNodeList(this.childNodes); 1970 enqueueMutation(this, "childList", { 1971 addedNodes: addedNodes, 1972 removedNodes: removedNodes 1973 }); 1974 nodesWereRemoved(removedNodes); 1975 nodesWereAdded(addedNodes, this); 1976 }, 1977 get childNodes() { 1978 var wrapperList = new NodeList(); 1979 var i = 0; 1980 for (var child = this.firstChild; child; child = child.nextSibling) { 1981 wrapperList[i++] = child; 1982 } 1983 wrapperList.length = i; 1984 return wrapperList; 1985 }, 1986 cloneNode: function(deep) { 1987 return cloneNode(this, deep); 1988 }, 1989 contains: function(child) { 1990 return contains(this, wrapIfNeeded(child)); 1991 }, 1992 compareDocumentPosition: function(otherNode) { 1993 return originalCompareDocumentPosition.call(unsafeUnwrap(this), unwrapIfNeeded(otherNode)); 1994 }, 1995 normalize: function() { 1996 var nodes = snapshotNodeList(this.childNodes); 1997 var remNodes = []; 1998 var s = ""; 1999 var modNode; 2000 for (var i = 0, n; i < nodes.length; i++) { 2001 n = nodes[i]; 2002 if (n.nodeType === Node.TEXT_NODE) { 2003 if (!modNode && !n.data.length) this.removeChild(n); else if (!modNode) modNode = n; else { 2004 s += n.data; 2005 remNodes.push(n); 2006 } 2007 } else { 2008 if (modNode && remNodes.length) { 2009 modNode.data += s; 2010 cleanupNodes(remNodes); 2011 } 2012 remNodes = []; 2013 s = ""; 2014 modNode = null; 2015 if (n.childNodes.length) n.normalize(); 2016 } 2017 } 2018 if (modNode && remNodes.length) { 2019 modNode.data += s; 2020 cleanupNodes(remNodes); 2021 } 2022 } 2023 }); 2024 defineWrapGetter(Node, "ownerDocument"); 2025 registerWrapper(OriginalNode, Node, document.createDocumentFragment()); 2026 delete Node.prototype.querySelector; 2027 delete Node.prototype.querySelectorAll; 2028 Node.prototype = mixin(Object.create(EventTarget.prototype), Node.prototype); 2029 scope.cloneNode = cloneNode; 2030 scope.nodeWasAdded = nodeWasAdded; 2031 scope.nodeWasRemoved = nodeWasRemoved; 2032 scope.nodesWereAdded = nodesWereAdded; 2033 scope.nodesWereRemoved = nodesWereRemoved; 2034 scope.originalInsertBefore = originalInsertBefore; 2035 scope.originalRemoveChild = originalRemoveChild; 2036 scope.snapshotNodeList = snapshotNodeList; 2037 scope.wrappers.Node = Node; 2038 })(window.ShadowDOMPolyfill); 2039 (function(scope) { 2040 "use strict"; 2041 var HTMLCollection = scope.wrappers.HTMLCollection; 2042 var NodeList = scope.wrappers.NodeList; 2043 var getTreeScope = scope.getTreeScope; 2044 var unsafeUnwrap = scope.unsafeUnwrap; 2045 var wrap = scope.wrap; 2046 var originalDocumentQuerySelector = document.querySelector; 2047 var originalElementQuerySelector = document.documentElement.querySelector; 2048 var originalDocumentQuerySelectorAll = document.querySelectorAll; 2049 var originalElementQuerySelectorAll = document.documentElement.querySelectorAll; 2050 var originalDocumentGetElementsByTagName = document.getElementsByTagName; 2051 var originalElementGetElementsByTagName = document.documentElement.getElementsByTagName; 2052 var originalDocumentGetElementsByTagNameNS = document.getElementsByTagNameNS; 2053 var originalElementGetElementsByTagNameNS = document.documentElement.getElementsByTagNameNS; 2054 var OriginalElement = window.Element; 2055 var OriginalDocument = window.HTMLDocument || window.Document; 2056 function filterNodeList(list, index, result, deep) { 2057 var wrappedItem = null; 2058 var root = null; 2059 for (var i = 0, length = list.length; i < length; i++) { 2060 wrappedItem = wrap(list[i]); 2061 if (!deep && (root = getTreeScope(wrappedItem).root)) { 2062 if (root instanceof scope.wrappers.ShadowRoot) { 2063 continue; 2064 } 2065 } 2066 result[index++] = wrappedItem; 2067 } 2068 return index; 2069 } 2070 function shimSelector(selector) { 2071 return String(selector).replace(/\/deep\/|::shadow/g, " "); 2072 } 2073 function shimMatchesSelector(selector) { 2074 return String(selector).replace(/:host\(([^\s]+)\)/g, "$1").replace(/([^\s]):host/g, "$1").replace(":host", "*").replace(/\^|\/shadow\/|\/shadow-deep\/|::shadow|\/deep\/|::content/g, " "); 2075 } 2076 function findOne(node, selector) { 2077 var m, el = node.firstElementChild; 2078 while (el) { 2079 if (el.matches(selector)) return el; 2080 m = findOne(el, selector); 2081 if (m) return m; 2082 el = el.nextElementSibling; 2083 } 2084 return null; 2085 } 2086 function matchesSelector(el, selector) { 2087 return el.matches(selector); 2088 } 2089 var XHTML_NS = "http://www.w3.org/1999/xhtml"; 2090 function matchesTagName(el, localName, localNameLowerCase) { 2091 var ln = el.localName; 2092 return ln === localName || ln === localNameLowerCase && el.namespaceURI === XHTML_NS; 2093 } 2094 function matchesEveryThing() { 2095 return true; 2096 } 2097 function matchesLocalNameOnly(el, ns, localName) { 2098 return el.localName === localName; 2099 } 2100 function matchesNameSpace(el, ns) { 2101 return el.namespaceURI === ns; 2102 } 2103 function matchesLocalNameNS(el, ns, localName) { 2104 return el.namespaceURI === ns && el.localName === localName; 2105 } 2106 function findElements(node, index, result, p, arg0, arg1) { 2107 var el = node.firstElementChild; 2108 while (el) { 2109 if (p(el, arg0, arg1)) result[index++] = el; 2110 index = findElements(el, index, result, p, arg0, arg1); 2111 el = el.nextElementSibling; 2112 } 2113 return index; 2114 } 2115 function querySelectorAllFiltered(p, index, result, selector, deep) { 2116 var target = unsafeUnwrap(this); 2117 var list; 2118 var root = getTreeScope(this).root; 2119 if (root instanceof scope.wrappers.ShadowRoot) { 2120 return findElements(this, index, result, p, selector, null); 2121 } else if (target instanceof OriginalElement) { 2122 list = originalElementQuerySelectorAll.call(target, selector); 2123 } else if (target instanceof OriginalDocument) { 2124 list = originalDocumentQuerySelectorAll.call(target, selector); 2125 } else { 2126 return findElements(this, index, result, p, selector, null); 2127 } 2128 return filterNodeList(list, index, result, deep); 2129 } 2130 var SelectorsInterface = { 2131 querySelector: function(selector) { 2132 var shimmed = shimSelector(selector); 2133 var deep = shimmed !== selector; 2134 selector = shimmed; 2135 var target = unsafeUnwrap(this); 2136 var wrappedItem; 2137 var root = getTreeScope(this).root; 2138 if (root instanceof scope.wrappers.ShadowRoot) { 2139 return findOne(this, selector); 2140 } else if (target instanceof OriginalElement) { 2141 wrappedItem = wrap(originalElementQuerySelector.call(target, selector)); 2142 } else if (target instanceof OriginalDocument) { 2143 wrappedItem = wrap(originalDocumentQuerySelector.call(target, selector)); 2144 } else { 2145 return findOne(this, selector); 2146 } 2147 if (!wrappedItem) { 2148 return wrappedItem; 2149 } else if (!deep && (root = getTreeScope(wrappedItem).root)) { 2150 if (root instanceof scope.wrappers.ShadowRoot) { 2151 return findOne(this, selector); 2152 } 2153 } 2154 return wrappedItem; 2155 }, 2156 querySelectorAll: function(selector) { 2157 var shimmed = shimSelector(selector); 2158 var deep = shimmed !== selector; 2159 selector = shimmed; 2160 var result = new NodeList(); 2161 result.length = querySelectorAllFiltered.call(this, matchesSelector, 0, result, selector, deep); 2162 return result; 2163 } 2164 }; 2165 var MatchesInterface = { 2166 matches: function(selector) { 2167 selector = shimMatchesSelector(selector); 2168 return scope.originalMatches.call(unsafeUnwrap(this), selector); 2169 } 2170 }; 2171 function getElementsByTagNameFiltered(p, index, result, localName, lowercase) { 2172 var target = unsafeUnwrap(this); 2173 var list; 2174 var root = getTreeScope(this).root; 2175 if (root instanceof scope.wrappers.ShadowRoot) { 2176 return findElements(this, index, result, p, localName, lowercase); 2177 } else if (target instanceof OriginalElement) { 2178 list = originalElementGetElementsByTagName.call(target, localName, lowercase); 2179 } else if (target instanceof OriginalDocument) { 2180 list = originalDocumentGetElementsByTagName.call(target, localName, lowercase); 2181 } else { 2182 return findElements(this, index, result, p, localName, lowercase); 2183 } 2184 return filterNodeList(list, index, result, false); 2185 } 2186 function getElementsByTagNameNSFiltered(p, index, result, ns, localName) { 2187 var target = unsafeUnwrap(this); 2188 var list; 2189 var root = getTreeScope(this).root; 2190 if (root instanceof scope.wrappers.ShadowRoot) { 2191 return findElements(this, index, result, p, ns, localName); 2192 } else if (target instanceof OriginalElement) { 2193 list = originalElementGetElementsByTagNameNS.call(target, ns, localName); 2194 } else if (target instanceof OriginalDocument) { 2195 list = originalDocumentGetElementsByTagNameNS.call(target, ns, localName); 2196 } else { 2197 return findElements(this, index, result, p, ns, localName); 2198 } 2199 return filterNodeList(list, index, result, false); 2200 } 2201 var GetElementsByInterface = { 2202 getElementsByTagName: function(localName) { 2203 var result = new HTMLCollection(); 2204 var match = localName === "*" ? matchesEveryThing : matchesTagName; 2205 result.length = getElementsByTagNameFiltered.call(this, match, 0, result, localName, localName.toLowerCase()); 2206 return result; 2207 }, 2208 getElementsByClassName: function(className) { 2209 return this.querySelectorAll("." + className); 2210 }, 2211 getElementsByTagNameNS: function(ns, localName) { 2212 var result = new HTMLCollection(); 2213 var match = null; 2214 if (ns === "*") { 2215 match = localName === "*" ? matchesEveryThing : matchesLocalNameOnly; 2216 } else { 2217 match = localName === "*" ? matchesNameSpace : matchesLocalNameNS; 2218 } 2219 result.length = getElementsByTagNameNSFiltered.call(this, match, 0, result, ns || null, localName); 2220 return result; 2221 } 2222 }; 2223 scope.GetElementsByInterface = GetElementsByInterface; 2224 scope.SelectorsInterface = SelectorsInterface; 2225 scope.MatchesInterface = MatchesInterface; 2226 })(window.ShadowDOMPolyfill); 2227 (function(scope) { 2228 "use strict"; 2229 var NodeList = scope.wrappers.NodeList; 2230 function forwardElement(node) { 2231 while (node && node.nodeType !== Node.ELEMENT_NODE) { 2232 node = node.nextSibling; 2233 } 2234 return node; 2235 } 2236 function backwardsElement(node) { 2237 while (node && node.nodeType !== Node.ELEMENT_NODE) { 2238 node = node.previousSibling; 2239 } 2240 return node; 2241 } 2242 var ParentNodeInterface = { 2243 get firstElementChild() { 2244 return forwardElement(this.firstChild); 2245 }, 2246 get lastElementChild() { 2247 return backwardsElement(this.lastChild); 2248 }, 2249 get childElementCount() { 2250 var count = 0; 2251 for (var child = this.firstElementChild; child; child = child.nextElementSibling) { 2252 count++; 2253 } 2254 return count; 2255 }, 2256 get children() { 2257 var wrapperList = new NodeList(); 2258 var i = 0; 2259 for (var child = this.firstElementChild; child; child = child.nextElementSibling) { 2260 wrapperList[i++] = child; 2261 } 2262 wrapperList.length = i; 2263 return wrapperList; 2264 }, 2265 remove: function() { 2266 var p = this.parentNode; 2267 if (p) p.removeChild(this); 2268 } 2269 }; 2270 var ChildNodeInterface = { 2271 get nextElementSibling() { 2272 return forwardElement(this.nextSibling); 2273 }, 2274 get previousElementSibling() { 2275 return backwardsElement(this.previousSibling); 2276 } 2277 }; 2278 scope.ChildNodeInterface = ChildNodeInterface; 2279 scope.ParentNodeInterface = ParentNodeInterface; 2280 })(window.ShadowDOMPolyfill); 2281 (function(scope) { 2282 "use strict"; 2283 var ChildNodeInterface = scope.ChildNodeInterface; 2284 var Node = scope.wrappers.Node; 2285 var enqueueMutation = scope.enqueueMutation; 2286 var mixin = scope.mixin; 2287 var registerWrapper = scope.registerWrapper; 2288 var unsafeUnwrap = scope.unsafeUnwrap; 2289 var OriginalCharacterData = window.CharacterData; 2290 function CharacterData(node) { 2291 Node.call(this, node); 2292 } 2293 CharacterData.prototype = Object.create(Node.prototype); 2294 mixin(CharacterData.prototype, { 2295 get textContent() { 2296 return this.data; 2297 }, 2298 set textContent(value) { 2299 this.data = value; 2300 }, 2301 get data() { 2302 return unsafeUnwrap(this).data; 2303 }, 2304 set data(value) { 2305 var oldValue = unsafeUnwrap(this).data; 2306 enqueueMutation(this, "characterData", { 2307 oldValue: oldValue 2308 }); 2309 unsafeUnwrap(this).data = value; 2310 } 2311 }); 2312 mixin(CharacterData.prototype, ChildNodeInterface); 2313 registerWrapper(OriginalCharacterData, CharacterData, document.createTextNode("")); 2314 scope.wrappers.CharacterData = CharacterData; 2315 })(window.ShadowDOMPolyfill); 2316 (function(scope) { 2317 "use strict"; 2318 var CharacterData = scope.wrappers.CharacterData; 2319 var enqueueMutation = scope.enqueueMutation; 2320 var mixin = scope.mixin; 2321 var registerWrapper = scope.registerWrapper; 2322 function toUInt32(x) { 2323 return x >>> 0; 2324 } 2325 var OriginalText = window.Text; 2326 function Text(node) { 2327 CharacterData.call(this, node); 2328 } 2329 Text.prototype = Object.create(CharacterData.prototype); 2330 mixin(Text.prototype, { 2331 splitText: function(offset) { 2332 offset = toUInt32(offset); 2333 var s = this.data; 2334 if (offset > s.length) throw new Error("IndexSizeError"); 2335 var head = s.slice(0, offset); 2336 var tail = s.slice(offset); 2337 this.data = head; 2338 var newTextNode = this.ownerDocument.createTextNode(tail); 2339 if (this.parentNode) this.parentNode.insertBefore(newTextNode, this.nextSibling); 2340 return newTextNode; 2341 } 2342 }); 2343 registerWrapper(OriginalText, Text, document.createTextNode("")); 2344 scope.wrappers.Text = Text; 2345 })(window.ShadowDOMPolyfill); 2346 (function(scope) { 2347 "use strict"; 2348 if (!window.DOMTokenList) { 2349 console.warn("Missing DOMTokenList prototype, please include a " + "compatible classList polyfill such as http://goo.gl/uTcepH."); 2350 return; 2351 } 2352 var unsafeUnwrap = scope.unsafeUnwrap; 2353 var enqueueMutation = scope.enqueueMutation; 2354 function getClass(el) { 2355 return unsafeUnwrap(el).getAttribute("class"); 2356 } 2357 function enqueueClassAttributeChange(el, oldValue) { 2358 enqueueMutation(el, "attributes", { 2359 name: "class", 2360 namespace: null, 2361 oldValue: oldValue 2362 }); 2363 } 2364 function invalidateClass(el) { 2365 scope.invalidateRendererBasedOnAttribute(el, "class"); 2366 } 2367 function changeClass(tokenList, method, args) { 2368 var ownerElement = tokenList.ownerElement_; 2369 if (ownerElement == null) { 2370 return method.apply(tokenList, args); 2371 } 2372 var oldValue = getClass(ownerElement); 2373 var retv = method.apply(tokenList, args); 2374 if (getClass(ownerElement) !== oldValue) { 2375 enqueueClassAttributeChange(ownerElement, oldValue); 2376 invalidateClass(ownerElement); 2377 } 2378 return retv; 2379 } 2380 var oldAdd = DOMTokenList.prototype.add; 2381 DOMTokenList.prototype.add = function() { 2382 changeClass(this, oldAdd, arguments); 2383 }; 2384 var oldRemove = DOMTokenList.prototype.remove; 2385 DOMTokenList.prototype.remove = function() { 2386 changeClass(this, oldRemove, arguments); 2387 }; 2388 var oldToggle = DOMTokenList.prototype.toggle; 2389 DOMTokenList.prototype.toggle = function() { 2390 return changeClass(this, oldToggle, arguments); 2391 }; 2392 })(window.ShadowDOMPolyfill); 2393 (function(scope) { 2394 "use strict"; 2395 var ChildNodeInterface = scope.ChildNodeInterface; 2396 var GetElementsByInterface = scope.GetElementsByInterface; 2397 var Node = scope.wrappers.Node; 2398 var ParentNodeInterface = scope.ParentNodeInterface; 2399 var SelectorsInterface = scope.SelectorsInterface; 2400 var MatchesInterface = scope.MatchesInterface; 2401 var addWrapNodeListMethod = scope.addWrapNodeListMethod; 2402 var enqueueMutation = scope.enqueueMutation; 2403 var mixin = scope.mixin; 2404 var oneOf = scope.oneOf; 2405 var registerWrapper = scope.registerWrapper; 2406 var unsafeUnwrap = scope.unsafeUnwrap; 2407 var wrappers = scope.wrappers; 2408 var OriginalElement = window.Element; 2409 var matchesNames = [ "matches", "mozMatchesSelector", "msMatchesSelector", "webkitMatchesSelector" ].filter(function(name) { 2410 return OriginalElement.prototype[name]; 2411 }); 2412 var matchesName = matchesNames[0]; 2413 var originalMatches = OriginalElement.prototype[matchesName]; 2414 function invalidateRendererBasedOnAttribute(element, name) { 2415 var p = element.parentNode; 2416 if (!p || !p.shadowRoot) return; 2417 var renderer = scope.getRendererForHost(p); 2418 if (renderer.dependsOnAttribute(name)) renderer.invalidate(); 2419 } 2420 function enqueAttributeChange(element, name, oldValue) { 2421 enqueueMutation(element, "attributes", { 2422 name: name, 2423 namespace: null, 2424 oldValue: oldValue 2425 }); 2426 } 2427 var classListTable = new WeakMap(); 2428 function Element(node) { 2429 Node.call(this, node); 2430 } 2431 Element.prototype = Object.create(Node.prototype); 2432 mixin(Element.prototype, { 2433 createShadowRoot: function() { 2434 var newShadowRoot = new wrappers.ShadowRoot(this); 2435 unsafeUnwrap(this).polymerShadowRoot_ = newShadowRoot; 2436 var renderer = scope.getRendererForHost(this); 2437 renderer.invalidate(); 2438 return newShadowRoot; 2439 }, 2440 get shadowRoot() { 2441 return unsafeUnwrap(this).polymerShadowRoot_ || null; 2442 }, 2443 setAttribute: function(name, value) { 2444 var oldValue = unsafeUnwrap(this).getAttribute(name); 2445 unsafeUnwrap(this).setAttribute(name, value); 2446 enqueAttributeChange(this, name, oldValue); 2447 invalidateRendererBasedOnAttribute(this, name); 2448 }, 2449 removeAttribute: function(name) { 2450 var oldValue = unsafeUnwrap(this).getAttribute(name); 2451 unsafeUnwrap(this).removeAttribute(name); 2452 enqueAttributeChange(this, name, oldValue); 2453 invalidateRendererBasedOnAttribute(this, name); 2454 }, 2455 get classList() { 2456 var list = classListTable.get(this); 2457 if (!list) { 2458 list = unsafeUnwrap(this).classList; 2459 if (!list) return; 2460 list.ownerElement_ = this; 2461 classListTable.set(this, list); 2462 } 2463 return list; 2464 }, 2465 get className() { 2466 return unsafeUnwrap(this).className; 2467 }, 2468 set className(v) { 2469 this.setAttribute("class", v); 2470 }, 2471 get id() { 2472 return unsafeUnwrap(this).id; 2473 }, 2474 set id(v) { 2475 this.setAttribute("id", v); 2476 } 2477 }); 2478 matchesNames.forEach(function(name) { 2479 if (name !== "matches") { 2480 Element.prototype[name] = function(selector) { 2481 return this.matches(selector); 2482 }; 2483 } 2484 }); 2485 if (OriginalElement.prototype.webkitCreateShadowRoot) { 2486 Element.prototype.webkitCreateShadowRoot = Element.prototype.createShadowRoot; 2487 } 2488 mixin(Element.prototype, ChildNodeInterface); 2489 mixin(Element.prototype, GetElementsByInterface); 2490 mixin(Element.prototype, ParentNodeInterface); 2491 mixin(Element.prototype, SelectorsInterface); 2492 mixin(Element.prototype, MatchesInterface); 2493 registerWrapper(OriginalElement, Element, document.createElementNS(null, "x")); 2494 scope.invalidateRendererBasedOnAttribute = invalidateRendererBasedOnAttribute; 2495 scope.matchesNames = matchesNames; 2496 scope.originalMatches = originalMatches; 2497 scope.wrappers.Element = Element; 2498 })(window.ShadowDOMPolyfill); 2499 (function(scope) { 2500 "use strict"; 2501 var Element = scope.wrappers.Element; 2502 var defineGetter = scope.defineGetter; 2503 var enqueueMutation = scope.enqueueMutation; 2504 var mixin = scope.mixin; 2505 var nodesWereAdded = scope.nodesWereAdded; 2506 var nodesWereRemoved = scope.nodesWereRemoved; 2507 var registerWrapper = scope.registerWrapper; 2508 var snapshotNodeList = scope.snapshotNodeList; 2509 var unsafeUnwrap = scope.unsafeUnwrap; 2510 var unwrap = scope.unwrap; 2511 var wrap = scope.wrap; 2512 var wrappers = scope.wrappers; 2513 var escapeAttrRegExp = /[&\u00A0"]/g; 2514 var escapeDataRegExp = /[&\u00A0<>]/g; 2515 function escapeReplace(c) { 2516 switch (c) { 2517 case "&": 2518 return "&"; 2519 2520 case "<": 2521 return "<"; 2522 2523 case ">": 2524 return ">"; 2525 2526 case '"': 2527 return """; 2528 2529 case " ": 2530 return " "; 2531 } 2532 } 2533 function escapeAttr(s) { 2534 return s.replace(escapeAttrRegExp, escapeReplace); 2535 } 2536 function escapeData(s) { 2537 return s.replace(escapeDataRegExp, escapeReplace); 2538 } 2539 function makeSet(arr) { 2540 var set = {}; 2541 for (var i = 0; i < arr.length; i++) { 2542 set[arr[i]] = true; 2543 } 2544 return set; 2545 } 2546 var voidElements = makeSet([ "area", "base", "br", "col", "command", "embed", "hr", "img", "input", "keygen", "link", "meta", "param", "source", "track", "wbr" ]); 2547 var plaintextParents = makeSet([ "style", "script", "xmp", "iframe", "noembed", "noframes", "plaintext", "noscript" ]); 2548 function getOuterHTML(node, parentNode) { 2549 switch (node.nodeType) { 2550 case Node.ELEMENT_NODE: 2551 var tagName = node.tagName.toLowerCase(); 2552 var s = "<" + tagName; 2553 var attrs = node.attributes; 2554 for (var i = 0, attr; attr = attrs[i]; i++) { 2555 s += " " + attr.name + '="' + escapeAttr(attr.value) + '"'; 2556 } 2557 s += ">"; 2558 if (voidElements[tagName]) return s; 2559 return s + getInnerHTML(node) + "</" + tagName + ">"; 2560 2561 case Node.TEXT_NODE: 2562 var data = node.data; 2563 if (parentNode && plaintextParents[parentNode.localName]) return data; 2564 return escapeData(data); 2565 2566 case Node.COMMENT_NODE: 2567 return "<!--" + node.data + "-->"; 2568 2569 default: 2570 console.error(node); 2571 throw new Error("not implemented"); 2572 } 2573 } 2574 function getInnerHTML(node) { 2575 if (node instanceof wrappers.HTMLTemplateElement) node = node.content; 2576 var s = ""; 2577 for (var child = node.firstChild; child; child = child.nextSibling) { 2578 s += getOuterHTML(child, node); 2579 } 2580 return s; 2581 } 2582 function setInnerHTML(node, value, opt_tagName) { 2583 var tagName = opt_tagName || "div"; 2584 node.textContent = ""; 2585 var tempElement = unwrap(node.ownerDocument.createElement(tagName)); 2586 tempElement.innerHTML = value; 2587 var firstChild; 2588 while (firstChild = tempElement.firstChild) { 2589 node.appendChild(wrap(firstChild)); 2590 } 2591 } 2592 var oldIe = /MSIE/.test(navigator.userAgent); 2593 var OriginalHTMLElement = window.HTMLElement; 2594 var OriginalHTMLTemplateElement = window.HTMLTemplateElement; 2595 function HTMLElement(node) { 2596 Element.call(this, node); 2597 } 2598 HTMLElement.prototype = Object.create(Element.prototype); 2599 mixin(HTMLElement.prototype, { 2600 get innerHTML() { 2601 return getInnerHTML(this); 2602 }, 2603 set innerHTML(value) { 2604 if (oldIe && plaintextParents[this.localName]) { 2605 this.textContent = value; 2606 return; 2607 } 2608 var removedNodes = snapshotNodeList(this.childNodes); 2609 if (this.invalidateShadowRenderer()) { 2610 if (this instanceof wrappers.HTMLTemplateElement) setInnerHTML(this.content, value); else setInnerHTML(this, value, this.tagName); 2611 } else if (!OriginalHTMLTemplateElement && this instanceof wrappers.HTMLTemplateElement) { 2612 setInnerHTML(this.content, value); 2613 } else { 2614 unsafeUnwrap(this).innerHTML = value; 2615 } 2616 var addedNodes = snapshotNodeList(this.childNodes); 2617 enqueueMutation(this, "childList", { 2618 addedNodes: addedNodes, 2619 removedNodes: removedNodes 2620 }); 2621 nodesWereRemoved(removedNodes); 2622 nodesWereAdded(addedNodes, this); 2623 }, 2624 get outerHTML() { 2625 return getOuterHTML(this, this.parentNode); 2626 }, 2627 set outerHTML(value) { 2628 var p = this.parentNode; 2629 if (p) { 2630 p.invalidateShadowRenderer(); 2631 var df = frag(p, value); 2632 p.replaceChild(df, this); 2633 } 2634 }, 2635 insertAdjacentHTML: function(position, text) { 2636 var contextElement, refNode; 2637 switch (String(position).toLowerCase()) { 2638 case "beforebegin": 2639 contextElement = this.parentNode; 2640 refNode = this; 2641 break; 2642 2643 case "afterend": 2644 contextElement = this.parentNode; 2645 refNode = this.nextSibling; 2646 break; 2647 2648 case "afterbegin": 2649 contextElement = this; 2650 refNode = this.firstChild; 2651 break; 2652 2653 case "beforeend": 2654 contextElement = this; 2655 refNode = null; 2656 break; 2657 2658 default: 2659 return; 2660 } 2661 var df = frag(contextElement, text); 2662 contextElement.insertBefore(df, refNode); 2663 }, 2664 get hidden() { 2665 return this.hasAttribute("hidden"); 2666 }, 2667 set hidden(v) { 2668 if (v) { 2669 this.setAttribute("hidden", ""); 2670 } else { 2671 this.removeAttribute("hidden"); 2672 } 2673 } 2674 }); 2675 function frag(contextElement, html) { 2676 var p = unwrap(contextElement.cloneNode(false)); 2677 p.innerHTML = html; 2678 var df = unwrap(document.createDocumentFragment()); 2679 var c; 2680 while (c = p.firstChild) { 2681 df.appendChild(c); 2682 } 2683 return wrap(df); 2684 } 2685 function getter(name) { 2686 return function() { 2687 scope.renderAllPending(); 2688 return unsafeUnwrap(this)[name]; 2689 }; 2690 } 2691 function getterRequiresRendering(name) { 2692 defineGetter(HTMLElement, name, getter(name)); 2693 } 2694 [ "clientHeight", "clientLeft", "clientTop", "clientWidth", "offsetHeight", "offsetLeft", "offsetTop", "offsetWidth", "scrollHeight", "scrollWidth" ].forEach(getterRequiresRendering); 2695 function getterAndSetterRequiresRendering(name) { 2696 Object.defineProperty(HTMLElement.prototype, name, { 2697 get: getter(name), 2698 set: function(v) { 2699 scope.renderAllPending(); 2700 unsafeUnwrap(this)[name] = v; 2701 }, 2702 configurable: true, 2703 enumerable: true 2704 }); 2705 } 2706 [ "scrollLeft", "scrollTop" ].forEach(getterAndSetterRequiresRendering); 2707 function methodRequiresRendering(name) { 2708 Object.defineProperty(HTMLElement.prototype, name, { 2709 value: function() { 2710 scope.renderAllPending(); 2711 return unsafeUnwrap(this)[name].apply(unsafeUnwrap(this), arguments); 2712 }, 2713 configurable: true, 2714 enumerable: true 2715 }); 2716 } 2717 [ "getBoundingClientRect", "getClientRects", "scrollIntoView" ].forEach(methodRequiresRendering); 2718 registerWrapper(OriginalHTMLElement, HTMLElement, document.createElement("b")); 2719 scope.wrappers.HTMLElement = HTMLElement; 2720 scope.getInnerHTML = getInnerHTML; 2721 scope.setInnerHTML = setInnerHTML; 2722 })(window.ShadowDOMPolyfill); 2723 (function(scope) { 2724 "use strict"; 2725 var HTMLElement = scope.wrappers.HTMLElement; 2726 var mixin = scope.mixin; 2727 var registerWrapper = scope.registerWrapper; 2728 var unsafeUnwrap = scope.unsafeUnwrap; 2729 var wrap = scope.wrap; 2730 var OriginalHTMLCanvasElement = window.HTMLCanvasElement; 2731 function HTMLCanvasElement(node) { 2732 HTMLElement.call(this, node); 2733 } 2734 HTMLCanvasElement.prototype = Object.create(HTMLElement.prototype); 2735 mixin(HTMLCanvasElement.prototype, { 2736 getContext: function() { 2737 var context = unsafeUnwrap(this).getContext.apply(unsafeUnwrap(this), arguments); 2738 return context && wrap(context); 2739 } 2740 }); 2741 registerWrapper(OriginalHTMLCanvasElement, HTMLCanvasElement, document.createElement("canvas")); 2742 scope.wrappers.HTMLCanvasElement = HTMLCanvasElement; 2743 })(window.ShadowDOMPolyfill); 2744 (function(scope) { 2745 "use strict"; 2746 var HTMLElement = scope.wrappers.HTMLElement; 2747 var mixin = scope.mixin; 2748 var registerWrapper = scope.registerWrapper; 2749 var OriginalHTMLContentElement = window.HTMLContentElement; 2750 function HTMLContentElement(node) { 2751 HTMLElement.call(this, node); 2752 } 2753 HTMLContentElement.prototype = Object.create(HTMLElement.prototype); 2754 mixin(HTMLContentElement.prototype, { 2755 constructor: HTMLContentElement, 2756 get select() { 2757 return this.getAttribute("select"); 2758 }, 2759 set select(value) { 2760 this.setAttribute("select", value); 2761 }, 2762 setAttribute: function(n, v) { 2763 HTMLElement.prototype.setAttribute.call(this, n, v); 2764 if (String(n).toLowerCase() === "select") this.invalidateShadowRenderer(true); 2765 } 2766 }); 2767 if (OriginalHTMLContentElement) registerWrapper(OriginalHTMLContentElement, HTMLContentElement); 2768 scope.wrappers.HTMLContentElement = HTMLContentElement; 2769 })(window.ShadowDOMPolyfill); 2770 (function(scope) { 2771 "use strict"; 2772 var HTMLElement = scope.wrappers.HTMLElement; 2773 var mixin = scope.mixin; 2774 var registerWrapper = scope.registerWrapper; 2775 var wrapHTMLCollection = scope.wrapHTMLCollection; 2776 var unwrap = scope.unwrap; 2777 var OriginalHTMLFormElement = window.HTMLFormElement; 2778 function HTMLFormElement(node) { 2779 HTMLElement.call(this, node); 2780 } 2781 HTMLFormElement.prototype = Object.create(HTMLElement.prototype); 2782 mixin(HTMLFormElement.prototype, { 2783 get elements() { 2784 return wrapHTMLCollection(unwrap(this).elements); 2785 } 2786 }); 2787 registerWrapper(OriginalHTMLFormElement, HTMLFormElement, document.createElement("form")); 2788 scope.wrappers.HTMLFormElement = HTMLFormElement; 2789 })(window.ShadowDOMPolyfill); 2790 (function(scope) { 2791 "use strict"; 2792 var HTMLElement = scope.wrappers.HTMLElement; 2793 var registerWrapper = scope.registerWrapper; 2794 var unwrap = scope.unwrap; 2795 var rewrap = scope.rewrap; 2796 var OriginalHTMLImageElement = window.HTMLImageElement; 2797 function HTMLImageElement(node) { 2798 HTMLElement.call(this, node); 2799 } 2800 HTMLImageElement.prototype = Object.create(HTMLElement.prototype); 2801 registerWrapper(OriginalHTMLImageElement, HTMLImageElement, document.createElement("img")); 2802 function Image(width, height) { 2803 if (!(this instanceof Image)) { 2804 throw new TypeError("DOM object constructor cannot be called as a function."); 2805 } 2806 var node = unwrap(document.createElement("img")); 2807 HTMLElement.call(this, node); 2808 rewrap(node, this); 2809 if (width !== undefined) node.width = width; 2810 if (height !== undefined) node.height = height; 2811 } 2812 Image.prototype = HTMLImageElement.prototype; 2813 scope.wrappers.HTMLImageElement = HTMLImageElement; 2814 scope.wrappers.Image = Image; 2815 })(window.ShadowDOMPolyfill); 2816 (function(scope) { 2817 "use strict"; 2818 var HTMLElement = scope.wrappers.HTMLElement; 2819 var mixin = scope.mixin; 2820 var NodeList = scope.wrappers.NodeList; 2821 var registerWrapper = scope.registerWrapper; 2822 var OriginalHTMLShadowElement = window.HTMLShadowElement; 2823 function HTMLShadowElement(node) { 2824 HTMLElement.call(this, node); 2825 } 2826 HTMLShadowElement.prototype = Object.create(HTMLElement.prototype); 2827 HTMLShadowElement.prototype.constructor = HTMLShadowElement; 2828 if (OriginalHTMLShadowElement) registerWrapper(OriginalHTMLShadowElement, HTMLShadowElement); 2829 scope.wrappers.HTMLShadowElement = HTMLShadowElement; 2830 })(window.ShadowDOMPolyfill); 2831 (function(scope) { 2832 "use strict"; 2833 var HTMLElement = scope.wrappers.HTMLElement; 2834 var mixin = scope.mixin; 2835 var registerWrapper = scope.registerWrapper; 2836 var unsafeUnwrap = scope.unsafeUnwrap; 2837 var unwrap = scope.unwrap; 2838 var wrap = scope.wrap; 2839 var contentTable = new WeakMap(); 2840 var templateContentsOwnerTable = new WeakMap(); 2841 function getTemplateContentsOwner(doc) { 2842 if (!doc.defaultView) return doc; 2843 var d = templateContentsOwnerTable.get(doc); 2844 if (!d) { 2845 d = doc.implementation.createHTMLDocument(""); 2846 while (d.lastChild) { 2847 d.removeChild(d.lastChild); 2848 } 2849 templateContentsOwnerTable.set(doc, d); 2850 } 2851 return d; 2852 } 2853 function extractContent(templateElement) { 2854 var doc = getTemplateContentsOwner(templateElement.ownerDocument); 2855 var df = unwrap(doc.createDocumentFragment()); 2856 var child; 2857 while (child = templateElement.firstChild) { 2858 df.appendChild(child); 2859 } 2860 return df; 2861 } 2862 var OriginalHTMLTemplateElement = window.HTMLTemplateElement; 2863 function HTMLTemplateElement(node) { 2864 HTMLElement.call(this, node); 2865 if (!OriginalHTMLTemplateElement) { 2866 var content = extractContent(node); 2867 contentTable.set(this, wrap(content)); 2868 } 2869 } 2870 HTMLTemplateElement.prototype = Object.create(HTMLElement.prototype); 2871 mixin(HTMLTemplateElement.prototype, { 2872 constructor: HTMLTemplateElement, 2873 get content() { 2874 if (OriginalHTMLTemplateElement) return wrap(unsafeUnwrap(this).content); 2875 return contentTable.get(this); 2876 } 2877 }); 2878 if (OriginalHTMLTemplateElement) registerWrapper(OriginalHTMLTemplateElement, HTMLTemplateElement); 2879 scope.wrappers.HTMLTemplateElement = HTMLTemplateElement; 2880 })(window.ShadowDOMPolyfill); 2881 (function(scope) { 2882 "use strict"; 2883 var HTMLElement = scope.wrappers.HTMLElement; 2884 var registerWrapper = scope.registerWrapper; 2885 var OriginalHTMLMediaElement = window.HTMLMediaElement; 2886 if (!OriginalHTMLMediaElement) return; 2887 function HTMLMediaElement(node) { 2888 HTMLElement.call(this, node); 2889 } 2890 HTMLMediaElement.prototype = Object.create(HTMLElement.prototype); 2891 registerWrapper(OriginalHTMLMediaElement, HTMLMediaElement, document.createElement("audio")); 2892 scope.wrappers.HTMLMediaElement = HTMLMediaElement; 2893 })(window.ShadowDOMPolyfill); 2894 (function(scope) { 2895 "use strict"; 2896 var HTMLMediaElement = scope.wrappers.HTMLMediaElement; 2897 var registerWrapper = scope.registerWrapper; 2898 var unwrap = scope.unwrap; 2899 var rewrap = scope.rewrap; 2900 var OriginalHTMLAudioElement = window.HTMLAudioElement; 2901 if (!OriginalHTMLAudioElement) return; 2902 function HTMLAudioElement(node) { 2903 HTMLMediaElement.call(this, node); 2904 } 2905 HTMLAudioElement.prototype = Object.create(HTMLMediaElement.prototype); 2906 registerWrapper(OriginalHTMLAudioElement, HTMLAudioElement, document.createElement("audio")); 2907 function Audio(src) { 2908 if (!(this instanceof Audio)) { 2909 throw new TypeError("DOM object constructor cannot be called as a function."); 2910 } 2911 var node = unwrap(document.createElement("audio")); 2912 HTMLMediaElement.call(this, node); 2913 rewrap(node, this); 2914 node.setAttribute("preload", "auto"); 2915 if (src !== undefined) node.setAttribute("src", src); 2916 } 2917 Audio.prototype = HTMLAudioElement.prototype; 2918 scope.wrappers.HTMLAudioElement = HTMLAudioElement; 2919 scope.wrappers.Audio = Audio; 2920 })(window.ShadowDOMPolyfill); 2921 (function(scope) { 2922 "use strict"; 2923 var HTMLElement = scope.wrappers.HTMLElement; 2924 var mixin = scope.mixin; 2925 var registerWrapper = scope.registerWrapper; 2926 var rewrap = scope.rewrap; 2927 var unwrap = scope.unwrap; 2928 var wrap = scope.wrap; 2929 var OriginalHTMLOptionElement = window.HTMLOptionElement; 2930 function trimText(s) { 2931 return s.replace(/\s+/g, " ").trim(); 2932 } 2933 function HTMLOptionElement(node) { 2934 HTMLElement.call(this, node); 2935 } 2936 HTMLOptionElement.prototype = Object.create(HTMLElement.prototype); 2937 mixin(HTMLOptionElement.prototype, { 2938 get text() { 2939 return trimText(this.textContent); 2940 }, 2941 set text(value) { 2942 this.textContent = trimText(String(value)); 2943 }, 2944 get form() { 2945 return wrap(unwrap(this).form); 2946 } 2947 }); 2948 registerWrapper(OriginalHTMLOptionElement, HTMLOptionElement, document.createElement("option")); 2949 function Option(text, value, defaultSelected, selected) { 2950 if (!(this instanceof Option)) { 2951 throw new TypeError("DOM object constructor cannot be called as a function."); 2952 } 2953 var node = unwrap(document.createElement("option")); 2954 HTMLElement.call(this, node); 2955 rewrap(node, this); 2956 if (text !== undefined) node.text = text; 2957 if (value !== undefined) node.setAttribute("value", value); 2958 if (defaultSelected === true) node.setAttribute("selected", ""); 2959 node.selected = selected === true; 2960 } 2961 Option.prototype = HTMLOptionElement.prototype; 2962 scope.wrappers.HTMLOptionElement = HTMLOptionElement; 2963 scope.wrappers.Option = Option; 2964 })(window.ShadowDOMPolyfill); 2965 (function(scope) { 2966 "use strict"; 2967 var HTMLElement = scope.wrappers.HTMLElement; 2968 var mixin = scope.mixin; 2969 var registerWrapper = scope.registerWrapper; 2970 var unwrap = scope.unwrap; 2971 var wrap = scope.wrap; 2972 var OriginalHTMLSelectElement = window.HTMLSelectElement; 2973 function HTMLSelectElement(node) { 2974 HTMLElement.call(this, node); 2975 } 2976 HTMLSelectElement.prototype = Object.create(HTMLElement.prototype); 2977 mixin(HTMLSelectElement.prototype, { 2978 add: function(element, before) { 2979 if (typeof before === "object") before = unwrap(before); 2980 unwrap(this).add(unwrap(element), before); 2981 }, 2982 remove: function(indexOrNode) { 2983 if (indexOrNode === undefined) { 2984 HTMLElement.prototype.remove.call(this); 2985 return; 2986 } 2987 if (typeof indexOrNode === "object") indexOrNode = unwrap(indexOrNode); 2988 unwrap(this).remove(indexOrNode); 2989 }, 2990 get form() { 2991 return wrap(unwrap(this).form); 2992 } 2993 }); 2994 registerWrapper(OriginalHTMLSelectElement, HTMLSelectElement, document.createElement("select")); 2995 scope.wrappers.HTMLSelectElement = HTMLSelectElement; 2996 })(window.ShadowDOMPolyfill); 2997 (function(scope) { 2998 "use strict"; 2999 var HTMLElement = scope.wrappers.HTMLElement; 3000 var mixin = scope.mixin; 3001 var registerWrapper = scope.registerWrapper; 3002 var unwrap = scope.unwrap; 3003 var wrap = scope.wrap; 3004 var wrapHTMLCollection = scope.wrapHTMLCollection; 3005 var OriginalHTMLTableElement = window.HTMLTableElement; 3006 function HTMLTableElement(node) { 3007 HTMLElement.call(this, node); 3008 } 3009 HTMLTableElement.prototype = Object.create(HTMLElement.prototype); 3010 mixin(HTMLTableElement.prototype, { 3011 get caption() { 3012 return wrap(unwrap(this).caption); 3013 }, 3014 createCaption: function() { 3015 return wrap(unwrap(this).createCaption()); 3016 }, 3017 get tHead() { 3018 return wrap(unwrap(this).tHead); 3019 }, 3020 createTHead: function() { 3021 return wrap(unwrap(this).createTHead()); 3022 }, 3023 createTFoot: function() { 3024 return wrap(unwrap(this).createTFoot()); 3025 }, 3026 get tFoot() { 3027 return wrap(unwrap(this).tFoot); 3028 }, 3029 get tBodies() { 3030 return wrapHTMLCollection(unwrap(this).tBodies); 3031 }, 3032 createTBody: function() { 3033 return wrap(unwrap(this).createTBody()); 3034 }, 3035 get rows() { 3036 return wrapHTMLCollection(unwrap(this).rows); 3037 }, 3038 insertRow: function(index) { 3039 return wrap(unwrap(this).insertRow(index)); 3040 } 3041 }); 3042 registerWrapper(OriginalHTMLTableElement, HTMLTableElement, document.createElement("table")); 3043 scope.wrappers.HTMLTableElement = HTMLTableElement; 3044 })(window.ShadowDOMPolyfill); 3045 (function(scope) { 3046 "use strict"; 3047 var HTMLElement = scope.wrappers.HTMLElement; 3048 var mixin = scope.mixin; 3049 var registerWrapper = scope.registerWrapper; 3050 var wrapHTMLCollection = scope.wrapHTMLCollection; 3051 var unwrap = scope.unwrap; 3052 var wrap = scope.wrap; 3053 var OriginalHTMLTableSectionElement = window.HTMLTableSectionElement; 3054 function HTMLTableSectionElement(node) { 3055 HTMLElement.call(this, node); 3056 } 3057 HTMLTableSectionElement.prototype = Object.create(HTMLElement.prototype); 3058 mixin(HTMLTableSectionElement.prototype, { 3059 constructor: HTMLTableSectionElement, 3060 get rows() { 3061 return wrapHTMLCollection(unwrap(this).rows); 3062 }, 3063 insertRow: function(index) { 3064 return wrap(unwrap(this).insertRow(index)); 3065 } 3066 }); 3067 registerWrapper(OriginalHTMLTableSectionElement, HTMLTableSectionElement, document.createElement("thead")); 3068 scope.wrappers.HTMLTableSectionElement = HTMLTableSectionElement; 3069 })(window.ShadowDOMPolyfill); 3070 (function(scope) { 3071 "use strict"; 3072 var HTMLElement = scope.wrappers.HTMLElement; 3073 var mixin = scope.mixin; 3074 var registerWrapper = scope.registerWrapper; 3075 var wrapHTMLCollection = scope.wrapHTMLCollection; 3076 var unwrap = scope.unwrap; 3077 var wrap = scope.wrap; 3078 var OriginalHTMLTableRowElement = window.HTMLTableRowElement; 3079 function HTMLTableRowElement(node) { 3080 HTMLElement.call(this, node); 3081 } 3082 HTMLTableRowElement.prototype = Object.create(HTMLElement.prototype); 3083 mixin(HTMLTableRowElement.prototype, { 3084 get cells() { 3085 return wrapHTMLCollection(unwrap(this).cells); 3086 }, 3087 insertCell: function(index) { 3088 return wrap(unwrap(this).insertCell(index)); 3089 } 3090 }); 3091 registerWrapper(OriginalHTMLTableRowElement, HTMLTableRowElement, document.createElement("tr")); 3092 scope.wrappers.HTMLTableRowElement = HTMLTableRowElement; 3093 })(window.ShadowDOMPolyfill); 3094 (function(scope) { 3095 "use strict"; 3096 var HTMLContentElement = scope.wrappers.HTMLContentElement; 3097 var HTMLElement = scope.wrappers.HTMLElement; 3098 var HTMLShadowElement = scope.wrappers.HTMLShadowElement; 3099 var HTMLTemplateElement = scope.wrappers.HTMLTemplateElement; 3100 var mixin = scope.mixin; 3101 var registerWrapper = scope.registerWrapper; 3102 var OriginalHTMLUnknownElement = window.HTMLUnknownElement; 3103 function HTMLUnknownElement(node) { 3104 switch (node.localName) { 3105 case "content": 3106 return new HTMLContentElement(node); 3107 3108 case "shadow": 3109 return new HTMLShadowElement(node); 3110 3111 case "template": 3112 return new HTMLTemplateElement(node); 3113 } 3114 HTMLElement.call(this, node); 3115 } 3116 HTMLUnknownElement.prototype = Object.create(HTMLElement.prototype); 3117 registerWrapper(OriginalHTMLUnknownElement, HTMLUnknownElement); 3118 scope.wrappers.HTMLUnknownElement = HTMLUnknownElement; 3119 })(window.ShadowDOMPolyfill); 3120 (function(scope) { 3121 "use strict"; 3122 var Element = scope.wrappers.Element; 3123 var HTMLElement = scope.wrappers.HTMLElement; 3124 var registerObject = scope.registerObject; 3125 var defineWrapGetter = scope.defineWrapGetter; 3126 var SVG_NS = "http://www.w3.org/2000/svg"; 3127 var svgTitleElement = document.createElementNS(SVG_NS, "title"); 3128 var SVGTitleElement = registerObject(svgTitleElement); 3129 var SVGElement = Object.getPrototypeOf(SVGTitleElement.prototype).constructor; 3130 if (!("classList" in svgTitleElement)) { 3131 var descr = Object.getOwnPropertyDescriptor(Element.prototype, "classList"); 3132 Object.defineProperty(HTMLElement.prototype, "classList", descr); 3133 delete Element.prototype.classList; 3134 } 3135 defineWrapGetter(SVGElement, "ownerSVGElement"); 3136 scope.wrappers.SVGElement = SVGElement; 3137 })(window.ShadowDOMPolyfill); 3138 (function(scope) { 3139 "use strict"; 3140 var mixin = scope.mixin; 3141 var registerWrapper = scope.registerWrapper; 3142 var unwrap = scope.unwrap; 3143 var wrap = scope.wrap; 3144 var OriginalSVGUseElement = window.SVGUseElement; 3145 var SVG_NS = "http://www.w3.org/2000/svg"; 3146 var gWrapper = wrap(document.createElementNS(SVG_NS, "g")); 3147 var useElement = document.createElementNS(SVG_NS, "use"); 3148 var SVGGElement = gWrapper.constructor; 3149 var parentInterfacePrototype = Object.getPrototypeOf(SVGGElement.prototype); 3150 var parentInterface = parentInterfacePrototype.constructor; 3151 function SVGUseElement(impl) { 3152 parentInterface.call(this, impl); 3153 } 3154 SVGUseElement.prototype = Object.create(parentInterfacePrototype); 3155 if ("instanceRoot" in useElement) { 3156 mixin(SVGUseElement.prototype, { 3157 get instanceRoot() { 3158 return wrap(unwrap(this).instanceRoot); 3159 }, 3160 get animatedInstanceRoot() { 3161 return wrap(unwrap(this).animatedInstanceRoot); 3162 } 3163 }); 3164 } 3165 registerWrapper(OriginalSVGUseElement, SVGUseElement, useElement); 3166 scope.wrappers.SVGUseElement = SVGUseElement; 3167 })(window.ShadowDOMPolyfill); 3168 (function(scope) { 3169 "use strict"; 3170 var EventTarget = scope.wrappers.EventTarget; 3171 var mixin = scope.mixin; 3172 var registerWrapper = scope.registerWrapper; 3173 var unsafeUnwrap = scope.unsafeUnwrap; 3174 var wrap = scope.wrap; 3175 var OriginalSVGElementInstance = window.SVGElementInstance; 3176 if (!OriginalSVGElementInstance) return; 3177 function SVGElementInstance(impl) { 3178 EventTarget.call(this, impl); 3179 } 3180 SVGElementInstance.prototype = Object.create(EventTarget.prototype); 3181 mixin(SVGElementInstance.prototype, { 3182 get correspondingElement() { 3183 return wrap(unsafeUnwrap(this).correspondingElement); 3184 }, 3185 get correspondingUseElement() { 3186 return wrap(unsafeUnwrap(this).correspondingUseElement); 3187 }, 3188 get parentNode() { 3189 return wrap(unsafeUnwrap(this).parentNode); 3190 }, 3191 get childNodes() { 3192 throw new Error("Not implemented"); 3193 }, 3194 get firstChild() { 3195 return wrap(unsafeUnwrap(this).firstChild); 3196 }, 3197 get lastChild() { 3198 return wrap(unsafeUnwrap(this).lastChild); 3199 }, 3200 get previousSibling() { 3201 return wrap(unsafeUnwrap(this).previousSibling); 3202 }, 3203 get nextSibling() { 3204 return wrap(unsafeUnwrap(this).nextSibling); 3205 } 3206 }); 3207 registerWrapper(OriginalSVGElementInstance, SVGElementInstance); 3208 scope.wrappers.SVGElementInstance = SVGElementInstance; 3209 })(window.ShadowDOMPolyfill); 3210 (function(scope) { 3211 "use strict"; 3212 var mixin = scope.mixin; 3213 var registerWrapper = scope.registerWrapper; 3214 var setWrapper = scope.setWrapper; 3215 var unsafeUnwrap = scope.unsafeUnwrap; 3216 var unwrap = scope.unwrap; 3217 var unwrapIfNeeded = scope.unwrapIfNeeded; 3218 var wrap = scope.wrap; 3219 var OriginalCanvasRenderingContext2D = window.CanvasRenderingContext2D; 3220 function CanvasRenderingContext2D(impl) { 3221 setWrapper(impl, this); 3222 } 3223 mixin(CanvasRenderingContext2D.prototype, { 3224 get canvas() { 3225 return wrap(unsafeUnwrap(this).canvas); 3226 }, 3227 drawImage: function() { 3228 arguments[0] = unwrapIfNeeded(arguments[0]); 3229 unsafeUnwrap(this).drawImage.apply(unsafeUnwrap(this), arguments); 3230 }, 3231 createPattern: function() { 3232 arguments[0] = unwrap(arguments[0]); 3233 return unsafeUnwrap(this).createPattern.apply(unsafeUnwrap(this), arguments); 3234 } 3235 }); 3236 registerWrapper(OriginalCanvasRenderingContext2D, CanvasRenderingContext2D, document.createElement("canvas").getContext("2d")); 3237 scope.wrappers.CanvasRenderingContext2D = CanvasRenderingContext2D; 3238 })(window.ShadowDOMPolyfill); 3239 (function(scope) { 3240 "use strict"; 3241 var mixin = scope.mixin; 3242 var registerWrapper = scope.registerWrapper; 3243 var setWrapper = scope.setWrapper; 3244 var unsafeUnwrap = scope.unsafeUnwrap; 3245 var unwrapIfNeeded = scope.unwrapIfNeeded; 3246 var wrap = scope.wrap; 3247 var OriginalWebGLRenderingContext = window.WebGLRenderingContext; 3248 if (!OriginalWebGLRenderingContext) return; 3249 function WebGLRenderingContext(impl) { 3250 setWrapper(impl, this); 3251 } 3252 mixin(WebGLRenderingContext.prototype, { 3253 get canvas() { 3254 return wrap(unsafeUnwrap(this).canvas); 3255 }, 3256 texImage2D: function() { 3257 arguments[5] = unwrapIfNeeded(arguments[5]); 3258 unsafeUnwrap(this).texImage2D.apply(unsafeUnwrap(this), arguments); 3259 }, 3260 texSubImage2D: function() { 3261 arguments[6] = unwrapIfNeeded(arguments[6]); 3262 unsafeUnwrap(this).texSubImage2D.apply(unsafeUnwrap(this), arguments); 3263 } 3264 }); 3265 var instanceProperties = /WebKit/.test(navigator.userAgent) ? { 3266 drawingBufferHeight: null, 3267 drawingBufferWidth: null 3268 } : {}; 3269 registerWrapper(OriginalWebGLRenderingContext, WebGLRenderingContext, instanceProperties); 3270 scope.wrappers.WebGLRenderingContext = WebGLRenderingContext; 3271 })(window.ShadowDOMPolyfill); 3272 (function(scope) { 3273 "use strict"; 3274 var registerWrapper = scope.registerWrapper; 3275 var setWrapper = scope.setWrapper; 3276 var unsafeUnwrap = scope.unsafeUnwrap; 3277 var unwrap = scope.unwrap; 3278 var unwrapIfNeeded = scope.unwrapIfNeeded; 3279 var wrap = scope.wrap; 3280 var OriginalRange = window.Range; 3281 function Range(impl) { 3282 setWrapper(impl, this); 3283 } 3284 Range.prototype = { 3285 get startContainer() { 3286 return wrap(unsafeUnwrap(this).startContainer); 3287 }, 3288 get endContainer() { 3289 return wrap(unsafeUnwrap(this).endContainer); 3290 }, 3291 get commonAncestorContainer() { 3292 return wrap(unsafeUnwrap(this).commonAncestorContainer); 3293 }, 3294 setStart: function(refNode, offset) { 3295 unsafeUnwrap(this).setStart(unwrapIfNeeded(refNode), offset); 3296 }, 3297 setEnd: function(refNode, offset) { 3298 unsafeUnwrap(this).setEnd(unwrapIfNeeded(refNode), offset); 3299 }, 3300 setStartBefore: function(refNode) { 3301 unsafeUnwrap(this).setStartBefore(unwrapIfNeeded(refNode)); 3302 }, 3303 setStartAfter: function(refNode) { 3304 unsafeUnwrap(this).setStartAfter(unwrapIfNeeded(refNode)); 3305 }, 3306 setEndBefore: function(refNode) { 3307 unsafeUnwrap(this).setEndBefore(unwrapIfNeeded(refNode)); 3308 }, 3309 setEndAfter: function(refNode) { 3310 unsafeUnwrap(this).setEndAfter(unwrapIfNeeded(refNode)); 3311 }, 3312 selectNode: function(refNode) { 3313 unsafeUnwrap(this).selectNode(unwrapIfNeeded(refNode)); 3314 }, 3315 selectNodeContents: function(refNode) { 3316 unsafeUnwrap(this).selectNodeContents(unwrapIfNeeded(refNode)); 3317 }, 3318 compareBoundaryPoints: function(how, sourceRange) { 3319 return unsafeUnwrap(this).compareBoundaryPoints(how, unwrap(sourceRange)); 3320 }, 3321 extractContents: function() { 3322 return wrap(unsafeUnwrap(this).extractContents()); 3323 }, 3324 cloneContents: function() { 3325 return wrap(unsafeUnwrap(this).cloneContents()); 3326 }, 3327 insertNode: function(node) { 3328 unsafeUnwrap(this).insertNode(unwrapIfNeeded(node)); 3329 }, 3330 surroundContents: function(newParent) { 3331 unsafeUnwrap(this).surroundContents(unwrapIfNeeded(newParent)); 3332 }, 3333 cloneRange: function() { 3334 return wrap(unsafeUnwrap(this).cloneRange()); 3335 }, 3336 isPointInRange: function(node, offset) { 3337 return unsafeUnwrap(this).isPointInRange(unwrapIfNeeded(node), offset); 3338 }, 3339 comparePoint: function(node, offset) { 3340 return unsafeUnwrap(this).comparePoint(unwrapIfNeeded(node), offset); 3341 }, 3342 intersectsNode: function(node) { 3343 return unsafeUnwrap(this).intersectsNode(unwrapIfNeeded(node)); 3344 }, 3345 toString: function() { 3346 return unsafeUnwrap(this).toString(); 3347 } 3348 }; 3349 if (OriginalRange.prototype.createContextualFragment) { 3350 Range.prototype.createContextualFragment = function(html) { 3351 return wrap(unsafeUnwrap(this).createContextualFragment(html)); 3352 }; 3353 } 3354 registerWrapper(window.Range, Range, document.createRange()); 3355 scope.wrappers.Range = Range; 3356 })(window.ShadowDOMPolyfill); 3357 (function(scope) { 3358 "use strict"; 3359 var GetElementsByInterface = scope.GetElementsByInterface; 3360 var ParentNodeInterface = scope.ParentNodeInterface; 3361 var SelectorsInterface = scope.SelectorsInterface; 3362 var mixin = scope.mixin; 3363 var registerObject = scope.registerObject; 3364 var DocumentFragment = registerObject(document.createDocumentFragment()); 3365 mixin(DocumentFragment.prototype, ParentNodeInterface); 3366 mixin(DocumentFragment.prototype, SelectorsInterface); 3367 mixin(DocumentFragment.prototype, GetElementsByInterface); 3368 var Comment = registerObject(document.createComment("")); 3369 scope.wrappers.Comment = Comment; 3370 scope.wrappers.DocumentFragment = DocumentFragment; 3371 })(window.ShadowDOMPolyfill); 3372 (function(scope) { 3373 "use strict"; 3374 var DocumentFragment = scope.wrappers.DocumentFragment; 3375 var TreeScope = scope.TreeScope; 3376 var elementFromPoint = scope.elementFromPoint; 3377 var getInnerHTML = scope.getInnerHTML; 3378 var getTreeScope = scope.getTreeScope; 3379 var mixin = scope.mixin; 3380 var rewrap = scope.rewrap; 3381 var setInnerHTML = scope.setInnerHTML; 3382 var unsafeUnwrap = scope.unsafeUnwrap; 3383 var unwrap = scope.unwrap; 3384 var shadowHostTable = new WeakMap(); 3385 var nextOlderShadowTreeTable = new WeakMap(); 3386 var spaceCharRe = /[ \t\n\r\f]/; 3387 function ShadowRoot(hostWrapper) { 3388 var node = unwrap(unsafeUnwrap(hostWrapper).ownerDocument.createDocumentFragment()); 3389 DocumentFragment.call(this, node); 3390 rewrap(node, this); 3391 var oldShadowRoot = hostWrapper.shadowRoot; 3392 nextOlderShadowTreeTable.set(this, oldShadowRoot); 3393 this.treeScope_ = new TreeScope(this, getTreeScope(oldShadowRoot || hostWrapper)); 3394 shadowHostTable.set(this, hostWrapper); 3395 } 3396 ShadowRoot.prototype = Object.create(DocumentFragment.prototype); 3397 mixin(ShadowRoot.prototype, { 3398 constructor: ShadowRoot, 3399 get innerHTML() { 3400 return getInnerHTML(this); 3401 }, 3402 set innerHTML(value) { 3403 setInnerHTML(this, value); 3404 this.invalidateShadowRenderer(); 3405 }, 3406 get olderShadowRoot() { 3407 return nextOlderShadowTreeTable.get(this) || null; 3408 }, 3409 get host() { 3410 return shadowHostTable.get(this) || null; 3411 }, 3412 invalidateShadowRenderer: function() { 3413 return shadowHostTable.get(this).invalidateShadowRenderer(); 3414 }, 3415 elementFromPoint: function(x, y) { 3416 return elementFromPoint(this, this.ownerDocument, x, y); 3417 }, 3418 getElementById: function(id) { 3419 if (spaceCharRe.test(id)) return null; 3420 return this.querySelector('[id="' + id + '"]'); 3421 } 3422 }); 3423 scope.wrappers.ShadowRoot = ShadowRoot; 3424 })(window.ShadowDOMPolyfill); 3425 (function(scope) { 3426 "use strict"; 3427 var Element = scope.wrappers.Element; 3428 var HTMLContentElement = scope.wrappers.HTMLContentElement; 3429 var HTMLShadowElement = scope.wrappers.HTMLShadowElement; 3430 var Node = scope.wrappers.Node; 3431 var ShadowRoot = scope.wrappers.ShadowRoot; 3432 var assert = scope.assert; 3433 var getTreeScope = scope.getTreeScope; 3434 var mixin = scope.mixin; 3435 var oneOf = scope.oneOf; 3436 var unsafeUnwrap = scope.unsafeUnwrap; 3437 var unwrap = scope.unwrap; 3438 var wrap = scope.wrap; 3439 var ArraySplice = scope.ArraySplice; 3440 function updateWrapperUpAndSideways(wrapper) { 3441 wrapper.previousSibling_ = wrapper.previousSibling; 3442 wrapper.nextSibling_ = wrapper.nextSibling; 3443 wrapper.parentNode_ = wrapper.parentNode; 3444 } 3445 function updateWrapperDown(wrapper) { 3446 wrapper.firstChild_ = wrapper.firstChild; 3447 wrapper.lastChild_ = wrapper.lastChild; 3448 } 3449 function updateAllChildNodes(parentNodeWrapper) { 3450 assert(parentNodeWrapper instanceof Node); 3451 for (var childWrapper = parentNodeWrapper.firstChild; childWrapper; childWrapper = childWrapper.nextSibling) { 3452 updateWrapperUpAndSideways(childWrapper); 3453 } 3454 updateWrapperDown(parentNodeWrapper); 3455 } 3456 function insertBefore(parentNodeWrapper, newChildWrapper, refChildWrapper) { 3457 var parentNode = unwrap(parentNodeWrapper); 3458 var newChild = unwrap(newChildWrapper); 3459 var refChild = refChildWrapper ? unwrap(refChildWrapper) : null; 3460 remove(newChildWrapper); 3461 updateWrapperUpAndSideways(newChildWrapper); 3462 if (!refChildWrapper) { 3463 parentNodeWrapper.lastChild_ = parentNodeWrapper.lastChild; 3464 if (parentNodeWrapper.lastChild === parentNodeWrapper.firstChild) parentNodeWrapper.firstChild_ = parentNodeWrapper.firstChild; 3465 var lastChildWrapper = wrap(parentNode.lastChild); 3466 if (lastChildWrapper) lastChildWrapper.nextSibling_ = lastChildWrapper.nextSibling; 3467 } else { 3468 if (parentNodeWrapper.firstChild === refChildWrapper) parentNodeWrapper.firstChild_ = refChildWrapper; 3469 refChildWrapper.previousSibling_ = refChildWrapper.previousSibling; 3470 } 3471 scope.originalInsertBefore.call(parentNode, newChild, refChild); 3472 } 3473 function remove(nodeWrapper) { 3474 var node = unwrap(nodeWrapper); 3475 var parentNode = node.parentNode; 3476 if (!parentNode) return; 3477 var parentNodeWrapper = wrap(parentNode); 3478 updateWrapperUpAndSideways(nodeWrapper); 3479 if (nodeWrapper.previousSibling) nodeWrapper.previousSibling.nextSibling_ = nodeWrapper; 3480 if (nodeWrapper.nextSibling) nodeWrapper.nextSibling.previousSibling_ = nodeWrapper; 3481 if (parentNodeWrapper.lastChild === nodeWrapper) parentNodeWrapper.lastChild_ = nodeWrapper; 3482 if (parentNodeWrapper.firstChild === nodeWrapper) parentNodeWrapper.firstChild_ = nodeWrapper; 3483 scope.originalRemoveChild.call(parentNode, node); 3484 } 3485 var distributedNodesTable = new WeakMap(); 3486 var destinationInsertionPointsTable = new WeakMap(); 3487 var rendererForHostTable = new WeakMap(); 3488 function resetDistributedNodes(insertionPoint) { 3489 distributedNodesTable.set(insertionPoint, []); 3490 } 3491 function getDistributedNodes(insertionPoint) { 3492 var rv = distributedNodesTable.get(insertionPoint); 3493 if (!rv) distributedNodesTable.set(insertionPoint, rv = []); 3494 return rv; 3495 } 3496 function getChildNodesSnapshot(node) { 3497 var result = [], i = 0; 3498 for (var child = node.firstChild; child; child = child.nextSibling) { 3499 result[i++] = child; 3500 } 3501 return result; 3502 } 3503 var request = oneOf(window, [ "requestAnimationFrame", "mozRequestAnimationFrame", "webkitRequestAnimationFrame", "setTimeout" ]); 3504 var pendingDirtyRenderers = []; 3505 var renderTimer; 3506 function renderAllPending() { 3507 for (var i = 0; i < pendingDirtyRenderers.length; i++) { 3508 var renderer = pendingDirtyRenderers[i]; 3509 var parentRenderer = renderer.parentRenderer; 3510 if (parentRenderer && parentRenderer.dirty) continue; 3511 renderer.render(); 3512 } 3513 pendingDirtyRenderers = []; 3514 } 3515 function handleRequestAnimationFrame() { 3516 renderTimer = null; 3517 renderAllPending(); 3518 } 3519 function getRendererForHost(host) { 3520 var renderer = rendererForHostTable.get(host); 3521 if (!renderer) { 3522 renderer = new ShadowRenderer(host); 3523 rendererForHostTable.set(host, renderer); 3524 } 3525 return renderer; 3526 } 3527 function getShadowRootAncestor(node) { 3528 var root = getTreeScope(node).root; 3529 if (root instanceof ShadowRoot) return root; 3530 return null; 3531 } 3532 function getRendererForShadowRoot(shadowRoot) { 3533 return getRendererForHost(shadowRoot.host); 3534 } 3535 var spliceDiff = new ArraySplice(); 3536 spliceDiff.equals = function(renderNode, rawNode) { 3537 return unwrap(renderNode.node) === rawNode; 3538 }; 3539 function RenderNode(node) { 3540 this.skip = false; 3541 this.node = node; 3542 this.childNodes = []; 3543 } 3544 RenderNode.prototype = { 3545 append: function(node) { 3546 var rv = new RenderNode(node); 3547 this.childNodes.push(rv); 3548 return rv; 3549 }, 3550 sync: function(opt_added) { 3551 if (this.skip) return; 3552 var nodeWrapper = this.node; 3553 var newChildren = this.childNodes; 3554 var oldChildren = getChildNodesSnapshot(unwrap(nodeWrapper)); 3555 var added = opt_added || new WeakMap(); 3556 var splices = spliceDiff.calculateSplices(newChildren, oldChildren); 3557 var newIndex = 0, oldIndex = 0; 3558 var lastIndex = 0; 3559 for (var i = 0; i < splices.length; i++) { 3560 var splice = splices[i]; 3561 for (;lastIndex < splice.index; lastIndex++) { 3562 oldIndex++; 3563 newChildren[newIndex++].sync(added); 3564 } 3565 var removedCount = splice.removed.length; 3566 for (var j = 0; j < removedCount; j++) { 3567 var wrapper = wrap(oldChildren[oldIndex++]); 3568 if (!added.get(wrapper)) remove(wrapper); 3569 } 3570 var addedCount = splice.addedCount; 3571 var refNode = oldChildren[oldIndex] && wrap(oldChildren[oldIndex]); 3572 for (var j = 0; j < addedCount; j++) { 3573 var newChildRenderNode = newChildren[newIndex++]; 3574 var newChildWrapper = newChildRenderNode.node; 3575 insertBefore(nodeWrapper, newChildWrapper, refNode); 3576 added.set(newChildWrapper, true); 3577 newChildRenderNode.sync(added); 3578 } 3579 lastIndex += addedCount; 3580 } 3581 for (var i = lastIndex; i < newChildren.length; i++) { 3582 newChildren[i].sync(added); 3583 } 3584 } 3585 }; 3586 function ShadowRenderer(host) { 3587 this.host = host; 3588 this.dirty = false; 3589 this.invalidateAttributes(); 3590 this.associateNode(host); 3591 } 3592 ShadowRenderer.prototype = { 3593 render: function(opt_renderNode) { 3594 if (!this.dirty) return; 3595 this.invalidateAttributes(); 3596 var host = this.host; 3597 this.distribution(host); 3598 var renderNode = opt_renderNode || new RenderNode(host); 3599 this.buildRenderTree(renderNode, host); 3600 var topMostRenderer = !opt_renderNode; 3601 if (topMostRenderer) renderNode.sync(); 3602 this.dirty = false; 3603 }, 3604 get parentRenderer() { 3605 return getTreeScope(this.host).renderer; 3606 }, 3607 invalidate: function() { 3608 if (!this.dirty) { 3609 this.dirty = true; 3610 var parentRenderer = this.parentRenderer; 3611 if (parentRenderer) parentRenderer.invalidate(); 3612 pendingDirtyRenderers.push(this); 3613 if (renderTimer) return; 3614 renderTimer = window[request](handleRequestAnimationFrame, 0); 3615 } 3616 }, 3617 distribution: function(root) { 3618 this.resetAllSubtrees(root); 3619 this.distributionResolution(root); 3620 }, 3621 resetAll: function(node) { 3622 if (isInsertionPoint(node)) resetDistributedNodes(node); else resetDestinationInsertionPoints(node); 3623 this.resetAllSubtrees(node); 3624 }, 3625 resetAllSubtrees: function(node) { 3626 for (var child = node.firstChild; child; child = child.nextSibling) { 3627 this.resetAll(child); 3628 } 3629 if (node.shadowRoot) this.resetAll(node.shadowRoot); 3630 if (node.olderShadowRoot) this.resetAll(node.olderShadowRoot); 3631 }, 3632 distributionResolution: function(node) { 3633 if (isShadowHost(node)) { 3634 var shadowHost = node; 3635 var pool = poolPopulation(shadowHost); 3636 var shadowTrees = getShadowTrees(shadowHost); 3637 for (var i = 0; i < shadowTrees.length; i++) { 3638 this.poolDistribution(shadowTrees[i], pool); 3639 } 3640 for (var i = shadowTrees.length - 1; i >= 0; i--) { 3641 var shadowTree = shadowTrees[i]; 3642 var shadow = getShadowInsertionPoint(shadowTree); 3643 if (shadow) { 3644 var olderShadowRoot = shadowTree.olderShadowRoot; 3645 if (olderShadowRoot) { 3646 pool = poolPopulation(olderShadowRoot); 3647 } 3648 for (var j = 0; j < pool.length; j++) { 3649 destributeNodeInto(pool[j], shadow); 3650 } 3651 } 3652 this.distributionResolution(shadowTree); 3653 } 3654 } 3655 for (var child = node.firstChild; child; child = child.nextSibling) { 3656 this.distributionResolution(child); 3657 } 3658 }, 3659 poolDistribution: function(node, pool) { 3660 if (node instanceof HTMLShadowElement) return; 3661 if (node instanceof HTMLContentElement) { 3662 var content = node; 3663 this.updateDependentAttributes(content.getAttribute("select")); 3664 var anyDistributed = false; 3665 for (var i = 0; i < pool.length; i++) { 3666 var node = pool[i]; 3667 if (!node) continue; 3668 if (matches(node, content)) { 3669 destributeNodeInto(node, content); 3670 pool[i] = undefined; 3671 anyDistributed = true; 3672 } 3673 } 3674 if (!anyDistributed) { 3675 for (var child = content.firstChild; child; child = child.nextSibling) { 3676 destributeNodeInto(child, content); 3677 } 3678 } 3679 return; 3680 } 3681 for (var child = node.firstChild; child; child = child.nextSibling) { 3682 this.poolDistribution(child, pool); 3683 } 3684 }, 3685 buildRenderTree: function(renderNode, node) { 3686 var children = this.compose(node); 3687 for (var i = 0; i < children.length; i++) { 3688 var child = children[i]; 3689 var childRenderNode = renderNode.append(child); 3690 this.buildRenderTree(childRenderNode, child); 3691 } 3692 if (isShadowHost(node)) { 3693 var renderer = getRendererForHost(node); 3694 renderer.dirty = false; 3695 } 3696 }, 3697 compose: function(node) { 3698 var children = []; 3699 var p = node.shadowRoot || node; 3700 for (var child = p.firstChild; child; child = child.nextSibling) { 3701 if (isInsertionPoint(child)) { 3702 this.associateNode(p); 3703 var distributedNodes = getDistributedNodes(child); 3704 for (var j = 0; j < distributedNodes.length; j++) { 3705 var distributedNode = distributedNodes[j]; 3706 if (isFinalDestination(child, distributedNode)) children.push(distributedNode); 3707 } 3708 } else { 3709 children.push(child); 3710 } 3711 } 3712 return children; 3713 }, 3714 invalidateAttributes: function() { 3715 this.attributes = Object.create(null); 3716 }, 3717 updateDependentAttributes: function(selector) { 3718 if (!selector) return; 3719 var attributes = this.attributes; 3720 if (/\.\w+/.test(selector)) attributes["class"] = true; 3721 if (/#\w+/.test(selector)) attributes["id"] = true; 3722 selector.replace(/\[\s*([^\s=\|~\]]+)/g, function(_, name) { 3723 attributes[name] = true; 3724 }); 3725 }, 3726 dependsOnAttribute: function(name) { 3727 return this.attributes[name]; 3728 }, 3729 associateNode: function(node) { 3730 unsafeUnwrap(node).polymerShadowRenderer_ = this; 3731 } 3732 }; 3733 function poolPopulation(node) { 3734 var pool = []; 3735 for (var child = node.firstChild; child; child = child.nextSibling) { 3736 if (isInsertionPoint(child)) { 3737 pool.push.apply(pool, getDistributedNodes(child)); 3738 } else { 3739 pool.push(child); 3740 } 3741 } 3742 return pool; 3743 } 3744 function getShadowInsertionPoint(node) { 3745 if (node instanceof HTMLShadowElement) return node; 3746 if (node instanceof HTMLContentElement) return null; 3747 for (var child = node.firstChild; child; child = child.nextSibling) { 3748 var res = getShadowInsertionPoint(child); 3749 if (res) return res; 3750 } 3751 return null; 3752 } 3753 function destributeNodeInto(child, insertionPoint) { 3754 getDistributedNodes(insertionPoint).push(child); 3755 var points = destinationInsertionPointsTable.get(child); 3756 if (!points) destinationInsertionPointsTable.set(child, [ insertionPoint ]); else points.push(insertionPoint); 3757 } 3758 function getDestinationInsertionPoints(node) { 3759 return destinationInsertionPointsTable.get(node); 3760 } 3761 function resetDestinationInsertionPoints(node) { 3762 destinationInsertionPointsTable.set(node, undefined); 3763 } 3764 var selectorStartCharRe = /^(:not\()?[*.#[a-zA-Z_|]/; 3765 function matches(node, contentElement) { 3766 var select = contentElement.getAttribute("select"); 3767 if (!select) return true; 3768 select = select.trim(); 3769 if (!select) return true; 3770 if (!(node instanceof Element)) return false; 3771 if (!selectorStartCharRe.test(select)) return false; 3772 try { 3773 return node.matches(select); 3774 } catch (ex) { 3775 return false; 3776 } 3777 } 3778 function isFinalDestination(insertionPoint, node) { 3779 var points = getDestinationInsertionPoints(node); 3780 return points && points[points.length - 1] === insertionPoint; 3781 } 3782 function isInsertionPoint(node) { 3783 return node instanceof HTMLContentElement || node instanceof HTMLShadowElement; 3784 } 3785 function isShadowHost(shadowHost) { 3786 return shadowHost.shadowRoot; 3787 } 3788 function getShadowTrees(host) { 3789 var trees = []; 3790 for (var tree = host.shadowRoot; tree; tree = tree.olderShadowRoot) { 3791 trees.push(tree); 3792 } 3793 return trees; 3794 } 3795 function render(host) { 3796 new ShadowRenderer(host).render(); 3797 } 3798 Node.prototype.invalidateShadowRenderer = function(force) { 3799 var renderer = unsafeUnwrap(this).polymerShadowRenderer_; 3800 if (renderer) { 3801 renderer.invalidate(); 3802 return true; 3803 } 3804 return false; 3805 }; 3806 HTMLContentElement.prototype.getDistributedNodes = HTMLShadowElement.prototype.getDistributedNodes = function() { 3807 renderAllPending(); 3808 return getDistributedNodes(this); 3809 }; 3810 Element.prototype.getDestinationInsertionPoints = function() { 3811 renderAllPending(); 3812 return getDestinationInsertionPoints(this) || []; 3813 }; 3814 HTMLContentElement.prototype.nodeIsInserted_ = HTMLShadowElement.prototype.nodeIsInserted_ = function() { 3815 this.invalidateShadowRenderer(); 3816 var shadowRoot = getShadowRootAncestor(this); 3817 var renderer; 3818 if (shadowRoot) renderer = getRendererForShadowRoot(shadowRoot); 3819 unsafeUnwrap(this).polymerShadowRenderer_ = renderer; 3820 if (renderer) renderer.invalidate(); 3821 }; 3822 scope.getRendererForHost = getRendererForHost; 3823 scope.getShadowTrees = getShadowTrees; 3824 scope.renderAllPending = renderAllPending; 3825 scope.getDestinationInsertionPoints = getDestinationInsertionPoints; 3826 scope.visual = { 3827 insertBefore: insertBefore, 3828 remove: remove 3829 }; 3830 })(window.ShadowDOMPolyfill); 3831 (function(scope) { 3832 "use strict"; 3833 var HTMLElement = scope.wrappers.HTMLElement; 3834 var assert = scope.assert; 3835 var mixin = scope.mixin; 3836 var registerWrapper = scope.registerWrapper; 3837 var unwrap = scope.unwrap; 3838 var wrap = scope.wrap; 3839 var elementsWithFormProperty = [ "HTMLButtonElement", "HTMLFieldSetElement", "HTMLInputElement", "HTMLKeygenElement", "HTMLLabelElement", "HTMLLegendElement", "HTMLObjectElement", "HTMLOutputElement", "HTMLTextAreaElement" ]; 3840 function createWrapperConstructor(name) { 3841 if (!window[name]) return; 3842 assert(!scope.wrappers[name]); 3843 var GeneratedWrapper = function(node) { 3844 HTMLElement.call(this, node); 3845 }; 3846 GeneratedWrapper.prototype = Object.create(HTMLElement.prototype); 3847 mixin(GeneratedWrapper.prototype, { 3848 get form() { 3849 return wrap(unwrap(this).form); 3850 } 3851 }); 3852 registerWrapper(window[name], GeneratedWrapper, document.createElement(name.slice(4, -7))); 3853 scope.wrappers[name] = GeneratedWrapper; 3854 } 3855 elementsWithFormProperty.forEach(createWrapperConstructor); 3856 })(window.ShadowDOMPolyfill); 3857 (function(scope) { 3858 "use strict"; 3859 var registerWrapper = scope.registerWrapper; 3860 var setWrapper = scope.setWrapper; 3861 var unsafeUnwrap = scope.unsafeUnwrap; 3862 var unwrap = scope.unwrap; 3863 var unwrapIfNeeded = scope.unwrapIfNeeded; 3864 var wrap = scope.wrap; 3865 var OriginalSelection = window.Selection; 3866 function Selection(impl) { 3867 setWrapper(impl, this); 3868 } 3869 Selection.prototype = { 3870 get anchorNode() { 3871 return wrap(unsafeUnwrap(this).anchorNode); 3872 }, 3873 get focusNode() { 3874 return wrap(unsafeUnwrap(this).focusNode); 3875 }, 3876 addRange: function(range) { 3877 unsafeUnwrap(this).addRange(unwrap(range)); 3878 }, 3879 collapse: function(node, index) { 3880 unsafeUnwrap(this).collapse(unwrapIfNeeded(node), index); 3881 }, 3882 containsNode: function(node, allowPartial) { 3883 return unsafeUnwrap(this).containsNode(unwrapIfNeeded(node), allowPartial); 3884 }, 3885 extend: function(node, offset) { 3886 unsafeUnwrap(this).extend(unwrapIfNeeded(node), offset); 3887 }, 3888 getRangeAt: function(index) { 3889 return wrap(unsafeUnwrap(this).getRangeAt(index)); 3890 }, 3891 removeRange: function(range) { 3892 unsafeUnwrap(this).removeRange(unwrap(range)); 3893 }, 3894 selectAllChildren: function(node) { 3895 unsafeUnwrap(this).selectAllChildren(unwrapIfNeeded(node)); 3896 }, 3897 toString: function() { 3898 return unsafeUnwrap(this).toString(); 3899 } 3900 }; 3901 registerWrapper(window.Selection, Selection, window.getSelection()); 3902 scope.wrappers.Selection = Selection; 3903 })(window.ShadowDOMPolyfill); 3904 (function(scope) { 3905 "use strict"; 3906 var GetElementsByInterface = scope.GetElementsByInterface; 3907 var Node = scope.wrappers.Node; 3908 var ParentNodeInterface = scope.ParentNodeInterface; 3909 var Selection = scope.wrappers.Selection; 3910 var SelectorsInterface = scope.SelectorsInterface; 3911 var ShadowRoot = scope.wrappers.ShadowRoot; 3912 var TreeScope = scope.TreeScope; 3913 var cloneNode = scope.cloneNode; 3914 var defineWrapGetter = scope.defineWrapGetter; 3915 var elementFromPoint = scope.elementFromPoint; 3916 var forwardMethodsToWrapper = scope.forwardMethodsToWrapper; 3917 var matchesNames = scope.matchesNames; 3918 var mixin = scope.mixin; 3919 var registerWrapper = scope.registerWrapper; 3920 var renderAllPending = scope.renderAllPending; 3921 var rewrap = scope.rewrap; 3922 var setWrapper = scope.setWrapper; 3923 var unsafeUnwrap = scope.unsafeUnwrap; 3924 var unwrap = scope.unwrap; 3925 var wrap = scope.wrap; 3926 var wrapEventTargetMethods = scope.wrapEventTargetMethods; 3927 var wrapNodeList = scope.wrapNodeList; 3928 var implementationTable = new WeakMap(); 3929 function Document(node) { 3930 Node.call(this, node); 3931 this.treeScope_ = new TreeScope(this, null); 3932 } 3933 Document.prototype = Object.create(Node.prototype); 3934 defineWrapGetter(Document, "documentElement"); 3935 defineWrapGetter(Document, "body"); 3936 defineWrapGetter(Document, "head"); 3937 function wrapMethod(name) { 3938 var original = document[name]; 3939 Document.prototype[name] = function() { 3940 return wrap(original.apply(unsafeUnwrap(this), arguments)); 3941 }; 3942 } 3943 [ "createComment", "createDocumentFragment", "createElement", "createElementNS", "createEvent", "createEventNS", "createRange", "createTextNode", "getElementById" ].forEach(wrapMethod); 3944 var originalAdoptNode = document.adoptNode; 3945 function adoptNodeNoRemove(node, doc) { 3946 originalAdoptNode.call(unsafeUnwrap(doc), unwrap(node)); 3947 adoptSubtree(node, doc); 3948 } 3949 function adoptSubtree(node, doc) { 3950 if (node.shadowRoot) doc.adoptNode(node.shadowRoot); 3951 if (node instanceof ShadowRoot) adoptOlderShadowRoots(node, doc); 3952 for (var child = node.firstChild; child; child = child.nextSibling) { 3953 adoptSubtree(child, doc); 3954 } 3955 } 3956 function adoptOlderShadowRoots(shadowRoot, doc) { 3957 var oldShadowRoot = shadowRoot.olderShadowRoot; 3958 if (oldShadowRoot) doc.adoptNode(oldShadowRoot); 3959 } 3960 var originalGetSelection = document.getSelection; 3961 mixin(Document.prototype, { 3962 adoptNode: function(node) { 3963 if (node.parentNode) node.parentNode.removeChild(node); 3964 adoptNodeNoRemove(node, this); 3965 return node; 3966 }, 3967 elementFromPoint: function(x, y) { 3968 return elementFromPoint(this, this, x, y); 3969 }, 3970 importNode: function(node, deep) { 3971 return cloneNode(node, deep, unsafeUnwrap(this)); 3972 }, 3973 getSelection: function() { 3974 renderAllPending(); 3975 return new Selection(originalGetSelection.call(unwrap(this))); 3976 }, 3977 getElementsByName: function(name) { 3978 return SelectorsInterface.querySelectorAll.call(this, "[name=" + JSON.stringify(String(name)) + "]"); 3979 } 3980 }); 3981 if (document.registerElement) { 3982 var originalRegisterElement = document.registerElement; 3983 Document.prototype.registerElement = function(tagName, object) { 3984 var prototype, extendsOption; 3985 if (object !== undefined) { 3986 prototype = object.prototype; 3987 extendsOption = object.extends; 3988 } 3989 if (!prototype) prototype = Object.create(HTMLElement.prototype); 3990 if (scope.nativePrototypeTable.get(prototype)) { 3991 throw new Error("NotSupportedError"); 3992 } 3993 var proto = Object.getPrototypeOf(prototype); 3994 var nativePrototype; 3995 var prototypes = []; 3996 while (proto) { 3997 nativePrototype = scope.nativePrototypeTable.get(proto); 3998 if (nativePrototype) break; 3999 prototypes.push(proto); 4000 proto = Object.getPrototypeOf(proto); 4001 } 4002 if (!nativePrototype) { 4003 throw new Error("NotSupportedError"); 4004 } 4005 var newPrototype = Object.create(nativePrototype); 4006 for (var i = prototypes.length - 1; i >= 0; i--) { 4007 newPrototype = Object.create(newPrototype); 4008 } 4009 [ "createdCallback", "attachedCallback", "detachedCallback", "attributeChangedCallback" ].forEach(function(name) { 4010 var f = prototype[name]; 4011 if (!f) return; 4012 newPrototype[name] = function() { 4013 if (!(wrap(this) instanceof CustomElementConstructor)) { 4014 rewrap(this); 4015 } 4016 f.apply(wrap(this), arguments); 4017 }; 4018 }); 4019 var p = { 4020 prototype: newPrototype 4021 }; 4022 if (extendsOption) p.extends = extendsOption; 4023 function CustomElementConstructor(node) { 4024 if (!node) { 4025 if (extendsOption) { 4026 return document.createElement(extendsOption, tagName); 4027 } else { 4028 return document.createElement(tagName); 4029 } 4030 } 4031 setWrapper(node, this); 4032 } 4033 CustomElementConstructor.prototype = prototype; 4034 CustomElementConstructor.prototype.constructor = CustomElementConstructor; 4035 scope.constructorTable.set(newPrototype, CustomElementConstructor); 4036 scope.nativePrototypeTable.set(prototype, newPrototype); 4037 var nativeConstructor = originalRegisterElement.call(unwrap(this), tagName, p); 4038 return CustomElementConstructor; 4039 }; 4040 forwardMethodsToWrapper([ window.HTMLDocument || window.Document ], [ "registerElement" ]); 4041 } 4042 forwardMethodsToWrapper([ window.HTMLBodyElement, window.HTMLDocument || window.Document, window.HTMLHeadElement, window.HTMLHtmlElement ], [ "appendChild", "compareDocumentPosition", "contains", "getElementsByClassName", "getElementsByTagName", "getElementsByTagNameNS", "insertBefore", "querySelector", "querySelectorAll", "removeChild", "replaceChild" ]); 4043 forwardMethodsToWrapper([ window.HTMLBodyElement, window.HTMLHeadElement, window.HTMLHtmlElement ], matchesNames); 4044 forwardMethodsToWrapper([ window.HTMLDocument || window.Document ], [ "adoptNode", "importNode", "contains", "createComment", "createDocumentFragment", "createElement", "createElementNS", "createEvent", "createEventNS", "createRange", "createTextNode", "elementFromPoint", "getElementById", "getElementsByName", "getSelection" ]); 4045 mixin(Document.prototype, GetElementsByInterface); 4046 mixin(Document.prototype, ParentNodeInterface); 4047 mixin(Document.prototype, SelectorsInterface); 4048 mixin(Document.prototype, { 4049 get implementation() { 4050 var implementation = implementationTable.get(this); 4051 if (implementation) return implementation; 4052 implementation = new DOMImplementation(unwrap(this).implementation); 4053 implementationTable.set(this, implementation); 4054 return implementation; 4055 }, 4056 get defaultView() { 4057 return wrap(unwrap(this).defaultView); 4058 } 4059 }); 4060 registerWrapper(window.Document, Document, document.implementation.createHTMLDocument("")); 4061 if (window.HTMLDocument) registerWrapper(window.HTMLDocument, Document); 4062 wrapEventTargetMethods([ window.HTMLBodyElement, window.HTMLDocument || window.Document, window.HTMLHeadElement ]); 4063 function DOMImplementation(impl) { 4064 setWrapper(impl, this); 4065 } 4066 function wrapImplMethod(constructor, name) { 4067 var original = document.implementation[name]; 4068 constructor.prototype[name] = function() { 4069 return wrap(original.apply(unsafeUnwrap(this), arguments)); 4070 }; 4071 } 4072 function forwardImplMethod(constructor, name) { 4073 var original = document.implementation[name]; 4074 constructor.prototype[name] = function() { 4075 return original.apply(unsafeUnwrap(this), arguments); 4076 }; 4077 } 4078 wrapImplMethod(DOMImplementation, "createDocumentType"); 4079 wrapImplMethod(DOMImplementation, "createDocument"); 4080 wrapImplMethod(DOMImplementation, "createHTMLDocument"); 4081 forwardImplMethod(DOMImplementation, "hasFeature"); 4082 registerWrapper(window.DOMImplementation, DOMImplementation); 4083 forwardMethodsToWrapper([ window.DOMImplementation ], [ "createDocumentType", "createDocument", "createHTMLDocument", "hasFeature" ]); 4084 scope.adoptNodeNoRemove = adoptNodeNoRemove; 4085 scope.wrappers.DOMImplementation = DOMImplementation; 4086 scope.wrappers.Document = Document; 4087 })(window.ShadowDOMPolyfill); 4088 (function(scope) { 4089 "use strict"; 4090 var EventTarget = scope.wrappers.EventTarget; 4091 var Selection = scope.wrappers.Selection; 4092 var mixin = scope.mixin; 4093 var registerWrapper = scope.registerWrapper; 4094 var renderAllPending = scope.renderAllPending; 4095 var unwrap = scope.unwrap; 4096 var unwrapIfNeeded = scope.unwrapIfNeeded; 4097 var wrap = scope.wrap; 4098 var OriginalWindow = window.Window; 4099 var originalGetComputedStyle = window.getComputedStyle; 4100 var originalGetDefaultComputedStyle = window.getDefaultComputedStyle; 4101 var originalGetSelection = window.getSelection; 4102 function Window(impl) { 4103 EventTarget.call(this, impl); 4104 } 4105 Window.prototype = Object.create(EventTarget.prototype); 4106 OriginalWindow.prototype.getComputedStyle = function(el, pseudo) { 4107 return wrap(this || window).getComputedStyle(unwrapIfNeeded(el), pseudo); 4108 }; 4109 if (originalGetDefaultComputedStyle) { 4110 OriginalWindow.prototype.getDefaultComputedStyle = function(el, pseudo) { 4111 return wrap(this || window).getDefaultComputedStyle(unwrapIfNeeded(el), pseudo); 4112 }; 4113 } 4114 OriginalWindow.prototype.getSelection = function() { 4115 return wrap(this || window).getSelection(); 4116 }; 4117 delete window.getComputedStyle; 4118 delete window.getDefaultComputedStyle; 4119 delete window.getSelection; 4120 [ "addEventListener", "removeEventListener", "dispatchEvent" ].forEach(function(name) { 4121 OriginalWindow.prototype[name] = function() { 4122 var w = wrap(this || window); 4123 return w[name].apply(w, arguments); 4124 }; 4125 delete window[name]; 4126 }); 4127 mixin(Window.prototype, { 4128 getComputedStyle: function(el, pseudo) { 4129 renderAllPending(); 4130 return originalGetComputedStyle.call(unwrap(this), unwrapIfNeeded(el), pseudo); 4131 }, 4132 getSelection: function() { 4133 renderAllPending(); 4134 return new Selection(originalGetSelection.call(unwrap(this))); 4135 }, 4136 get document() { 4137 return wrap(unwrap(this).document); 4138 } 4139 }); 4140 if (originalGetDefaultComputedStyle) { 4141 Window.prototype.getDefaultComputedStyle = function(el, pseudo) { 4142 renderAllPending(); 4143 return originalGetDefaultComputedStyle.call(unwrap(this), unwrapIfNeeded(el), pseudo); 4144 }; 4145 } 4146 registerWrapper(OriginalWindow, Window, window); 4147 scope.wrappers.Window = Window; 4148 })(window.ShadowDOMPolyfill); 4149 (function(scope) { 4150 "use strict"; 4151 var unwrap = scope.unwrap; 4152 var OriginalDataTransfer = window.DataTransfer || window.Clipboard; 4153 var OriginalDataTransferSetDragImage = OriginalDataTransfer.prototype.setDragImage; 4154 if (OriginalDataTransferSetDragImage) { 4155 OriginalDataTransfer.prototype.setDragImage = function(image, x, y) { 4156 OriginalDataTransferSetDragImage.call(this, unwrap(image), x, y); 4157 }; 4158 } 4159 })(window.ShadowDOMPolyfill); 4160 (function(scope) { 4161 "use strict"; 4162 var registerWrapper = scope.registerWrapper; 4163 var setWrapper = scope.setWrapper; 4164 var unwrap = scope.unwrap; 4165 var OriginalFormData = window.FormData; 4166 if (!OriginalFormData) return; 4167 function FormData(formElement) { 4168 var impl; 4169 if (formElement instanceof OriginalFormData) { 4170 impl = formElement; 4171 } else { 4172 impl = new OriginalFormData(formElement && unwrap(formElement)); 4173 } 4174 setWrapper(impl, this); 4175 } 4176 registerWrapper(OriginalFormData, FormData, new OriginalFormData()); 4177 scope.wrappers.FormData = FormData; 4178 })(window.ShadowDOMPolyfill); 4179 (function(scope) { 4180 "use strict"; 4181 var unwrapIfNeeded = scope.unwrapIfNeeded; 4182 var originalSend = XMLHttpRequest.prototype.send; 4183 XMLHttpRequest.prototype.send = function(obj) { 4184 return originalSend.call(this, unwrapIfNeeded(obj)); 4185 }; 4186 })(window.ShadowDOMPolyfill); 4187 (function(scope) { 4188 "use strict"; 4189 var isWrapperFor = scope.isWrapperFor; 4190 var elements = { 4191 a: "HTMLAnchorElement", 4192 area: "HTMLAreaElement", 4193 audio: "HTMLAudioElement", 4194 base: "HTMLBaseElement", 4195 body: "HTMLBodyElement", 4196 br: "HTMLBRElement", 4197 button: "HTMLButtonElement", 4198 canvas: "HTMLCanvasElement", 4199 caption: "HTMLTableCaptionElement", 4200 col: "HTMLTableColElement", 4201 content: "HTMLContentElement", 4202 data: "HTMLDataElement", 4203 datalist: "HTMLDataListElement", 4204 del: "HTMLModElement", 4205 dir: "HTMLDirectoryElement", 4206 div: "HTMLDivElement", 4207 dl: "HTMLDListElement", 4208 embed: "HTMLEmbedElement", 4209 fieldset: "HTMLFieldSetElement", 4210 font: "HTMLFontElement", 4211 form: "HTMLFormElement", 4212 frame: "HTMLFrameElement", 4213 frameset: "HTMLFrameSetElement", 4214 h1: "HTMLHeadingElement", 4215 head: "HTMLHeadElement", 4216 hr: "HTMLHRElement", 4217 html: "HTMLHtmlElement", 4218 iframe: "HTMLIFrameElement", 4219 img: "HTMLImageElement", 4220 input: "HTMLInputElement", 4221 keygen: "HTMLKeygenElement", 4222 label: "HTMLLabelElement", 4223 legend: "HTMLLegendElement", 4224 li: "HTMLLIElement", 4225 link: "HTMLLinkElement", 4226 map: "HTMLMapElement", 4227 marquee: "HTMLMarqueeElement", 4228 menu: "HTMLMenuElement", 4229 menuitem: "HTMLMenuItemElement", 4230 meta: "HTMLMetaElement", 4231 meter: "HTMLMeterElement", 4232 object: "HTMLObjectElement", 4233 ol: "HTMLOListElement", 4234 optgroup: "HTMLOptGroupElement", 4235 option: "HTMLOptionElement", 4236 output: "HTMLOutputElement", 4237 p: "HTMLParagraphElement", 4238 param: "HTMLParamElement", 4239 pre: "HTMLPreElement", 4240 progress: "HTMLProgressElement", 4241 q: "HTMLQuoteElement", 4242 script: "HTMLScriptElement", 4243 select: "HTMLSelectElement", 4244 shadow: "HTMLShadowElement", 4245 source: "HTMLSourceElement", 4246 span: "HTMLSpanElement", 4247 style: "HTMLStyleElement", 4248 table: "HTMLTableElement", 4249 tbody: "HTMLTableSectionElement", 4250 template: "HTMLTemplateElement", 4251 textarea: "HTMLTextAreaElement", 4252 thead: "HTMLTableSectionElement", 4253 time: "HTMLTimeElement", 4254 title: "HTMLTitleElement", 4255 tr: "HTMLTableRowElement", 4256 track: "HTMLTrackElement", 4257 ul: "HTMLUListElement", 4258 video: "HTMLVideoElement" 4259 }; 4260 function overrideConstructor(tagName) { 4261 var nativeConstructorName = elements[tagName]; 4262 var nativeConstructor = window[nativeConstructorName]; 4263 if (!nativeConstructor) return; 4264 var element = document.createElement(tagName); 4265 var wrapperConstructor = element.constructor; 4266 window[nativeConstructorName] = wrapperConstructor; 4267 } 4268 Object.keys(elements).forEach(overrideConstructor); 4269 Object.getOwnPropertyNames(scope.wrappers).forEach(function(name) { 4270 window[name] = scope.wrappers[name]; 4271 }); 4272 })(window.ShadowDOMPolyfill); 4273 (function(scope) { 4274 var ShadowCSS = { 4275 strictStyling: false, 4276 registry: {}, 4277 shimStyling: function(root, name, extendsName) { 4278 var scopeStyles = this.prepareRoot(root, name, extendsName); 4279 var typeExtension = this.isTypeExtension(extendsName); 4280 var scopeSelector = this.makeScopeSelector(name, typeExtension); 4281 var cssText = stylesToCssText(scopeStyles, true); 4282 cssText = this.scopeCssText(cssText, scopeSelector); 4283 if (root) { 4284 root.shimmedStyle = cssText; 4285 } 4286 this.addCssToDocument(cssText, name); 4287 }, 4288 shimStyle: function(style, selector) { 4289 return this.shimCssText(style.textContent, selector); 4290 }, 4291 shimCssText: function(cssText, selector) { 4292 cssText = this.insertDirectives(cssText); 4293 return this.scopeCssText(cssText, selector); 4294 }, 4295 makeScopeSelector: function(name, typeExtension) { 4296 if (name) { 4297 return typeExtension ? "[is=" + name + "]" : name; 4298 } 4299 return ""; 4300 }, 4301 isTypeExtension: function(extendsName) { 4302 return extendsName && extendsName.indexOf("-") < 0; 4303 }, 4304 prepareRoot: function(root, name, extendsName) { 4305 var def = this.registerRoot(root, name, extendsName); 4306 this.replaceTextInStyles(def.rootStyles, this.insertDirectives); 4307 this.removeStyles(root, def.rootStyles); 4308 if (this.strictStyling) { 4309 this.applyScopeToContent(root, name); 4310 } 4311 return def.scopeStyles; 4312 }, 4313 removeStyles: function(root, styles) { 4314 for (var i = 0, l = styles.length, s; i < l && (s = styles[i]); i++) { 4315 s.parentNode.removeChild(s); 4316 } 4317 }, 4318 registerRoot: function(root, name, extendsName) { 4319 var def = this.registry[name] = { 4320 root: root, 4321 name: name, 4322 extendsName: extendsName 4323 }; 4324 var styles = this.findStyles(root); 4325 def.rootStyles = styles; 4326 def.scopeStyles = def.rootStyles; 4327 var extendee = this.registry[def.extendsName]; 4328 if (extendee) { 4329 def.scopeStyles = extendee.scopeStyles.concat(def.scopeStyles); 4330 } 4331 return def; 4332 }, 4333 findStyles: function(root) { 4334 if (!root) { 4335 return []; 4336 } 4337 var styles = root.querySelectorAll("style"); 4338 return Array.prototype.filter.call(styles, function(s) { 4339 return !s.hasAttribute(NO_SHIM_ATTRIBUTE); 4340 }); 4341 }, 4342 applyScopeToContent: function(root, name) { 4343 if (root) { 4344 Array.prototype.forEach.call(root.querySelectorAll("*"), function(node) { 4345 node.setAttribute(name, ""); 4346 }); 4347 Array.prototype.forEach.call(root.querySelectorAll("template"), function(template) { 4348 this.applyScopeToContent(template.content, name); 4349 }, this); 4350 } 4351 }, 4352 insertDirectives: function(cssText) { 4353 cssText = this.insertPolyfillDirectivesInCssText(cssText); 4354 return this.insertPolyfillRulesInCssText(cssText); 4355 }, 4356 insertPolyfillDirectivesInCssText: function(cssText) { 4357 cssText = cssText.replace(cssCommentNextSelectorRe, function(match, p1) { 4358 return p1.slice(0, -2) + "{"; 4359 }); 4360 return cssText.replace(cssContentNextSelectorRe, function(match, p1) { 4361 return p1 + " {"; 4362 }); 4363 }, 4364 insertPolyfillRulesInCssText: function(cssText) { 4365 cssText = cssText.replace(cssCommentRuleRe, function(match, p1) { 4366 return p1.slice(0, -1); 4367 }); 4368 return cssText.replace(cssContentRuleRe, function(match, p1, p2, p3) { 4369 var rule = match.replace(p1, "").replace(p2, ""); 4370 return p3 + rule; 4371 }); 4372 }, 4373 scopeCssText: function(cssText, scopeSelector) { 4374 var unscoped = this.extractUnscopedRulesFromCssText(cssText); 4375 cssText = this.insertPolyfillHostInCssText(cssText); 4376 cssText = this.convertColonHost(cssText); 4377 cssText = this.convertColonHostContext(cssText); 4378 cssText = this.convertShadowDOMSelectors(cssText); 4379 if (scopeSelector) { 4380 var self = this, cssText; 4381 withCssRules(cssText, function(rules) { 4382 cssText = self.scopeRules(rules, scopeSelector); 4383 }); 4384 } 4385 cssText = cssText + "\n" + unscoped; 4386 return cssText.trim(); 4387 }, 4388 extractUnscopedRulesFromCssText: function(cssText) { 4389 var r = "", m; 4390 while (m = cssCommentUnscopedRuleRe.exec(cssText)) { 4391 r += m[1].slice(0, -1) + "\n\n"; 4392 } 4393 while (m = cssContentUnscopedRuleRe.exec(cssText)) { 4394 r += m[0].replace(m[2], "").replace(m[1], m[3]) + "\n\n"; 4395 } 4396 return r; 4397 }, 4398 convertColonHost: function(cssText) { 4399 return this.convertColonRule(cssText, cssColonHostRe, this.colonHostPartReplacer); 4400 }, 4401 convertColonHostContext: function(cssText) { 4402 return this.convertColonRule(cssText, cssColonHostContextRe, this.colonHostContextPartReplacer); 4403 }, 4404 convertColonRule: function(cssText, regExp, partReplacer) { 4405 return cssText.replace(regExp, function(m, p1, p2, p3) { 4406 p1 = polyfillHostNoCombinator; 4407 if (p2) { 4408 var parts = p2.split(","), r = []; 4409 for (var i = 0, l = parts.length, p; i < l && (p = parts[i]); i++) { 4410 p = p.trim(); 4411 r.push(partReplacer(p1, p, p3)); 4412 } 4413 return r.join(","); 4414 } else { 4415 return p1 + p3; 4416 } 4417 }); 4418 }, 4419 colonHostContextPartReplacer: function(host, part, suffix) { 4420 if (part.match(polyfillHost)) { 4421 return this.colonHostPartReplacer(host, part, suffix); 4422 } else { 4423 return host + part + suffix + ", " + part + " " + host + suffix; 4424 } 4425 }, 4426 colonHostPartReplacer: function(host, part, suffix) { 4427 return host + part.replace(polyfillHost, "") + suffix; 4428 }, 4429 convertShadowDOMSelectors: function(cssText) { 4430 for (var i = 0; i < shadowDOMSelectorsRe.length; i++) { 4431 cssText = cssText.replace(shadowDOMSelectorsRe[i], " "); 4432 } 4433 return cssText; 4434 }, 4435 scopeRules: function(cssRules, scopeSelector) { 4436 var cssText = ""; 4437 if (cssRules) { 4438 Array.prototype.forEach.call(cssRules, function(rule) { 4439 if (rule.selectorText && (rule.style && rule.style.cssText !== undefined)) { 4440 cssText += this.scopeSelector(rule.selectorText, scopeSelector, this.strictStyling) + " {\n "; 4441 cssText += this.propertiesFromRule(rule) + "\n}\n\n"; 4442 } else if (rule.type === CSSRule.MEDIA_RULE) { 4443 cssText += "@media " + rule.media.mediaText + " {\n"; 4444 cssText += this.scopeRules(rule.cssRules, scopeSelector); 4445 cssText += "\n}\n\n"; 4446 } else { 4447 try { 4448 if (rule.cssText) { 4449 cssText += rule.cssText + "\n\n"; 4450 } 4451 } catch (x) { 4452 if (rule.type === CSSRule.KEYFRAMES_RULE && rule.cssRules) { 4453 cssText += this.ieSafeCssTextFromKeyFrameRule(rule); 4454 } 4455 } 4456 } 4457 }, this); 4458 } 4459 return cssText; 4460 }, 4461 ieSafeCssTextFromKeyFrameRule: function(rule) { 4462 var cssText = "@keyframes " + rule.name + " {"; 4463 Array.prototype.forEach.call(rule.cssRules, function(rule) { 4464 cssText += " " + rule.keyText + " {" + rule.style.cssText + "}"; 4465 }); 4466 cssText += " }"; 4467 return cssText; 4468 }, 4469 scopeSelector: function(selector, scopeSelector, strict) { 4470 var r = [], parts = selector.split(","); 4471 parts.forEach(function(p) { 4472 p = p.trim(); 4473 if (this.selectorNeedsScoping(p, scopeSelector)) { 4474 p = strict && !p.match(polyfillHostNoCombinator) ? this.applyStrictSelectorScope(p, scopeSelector) : this.applySelectorScope(p, scopeSelector); 4475 } 4476 r.push(p); 4477 }, this); 4478 return r.join(", "); 4479 }, 4480 selectorNeedsScoping: function(selector, scopeSelector) { 4481 if (Array.isArray(scopeSelector)) { 4482 return true; 4483 } 4484 var re = this.makeScopeMatcher(scopeSelector); 4485 return !selector.match(re); 4486 }, 4487 makeScopeMatcher: function(scopeSelector) { 4488 scopeSelector = scopeSelector.replace(/\[/g, "\\[").replace(/\]/g, "\\]"); 4489 return new RegExp("^(" + scopeSelector + ")" + selectorReSuffix, "m"); 4490 }, 4491 applySelectorScope: function(selector, selectorScope) { 4492 return Array.isArray(selectorScope) ? this.applySelectorScopeList(selector, selectorScope) : this.applySimpleSelectorScope(selector, selectorScope); 4493 }, 4494 applySelectorScopeList: function(selector, scopeSelectorList) { 4495 var r = []; 4496 for (var i = 0, s; s = scopeSelectorList[i]; i++) { 4497 r.push(this.applySimpleSelectorScope(selector, s)); 4498 } 4499 return r.join(", "); 4500 }, 4501 applySimpleSelectorScope: function(selector, scopeSelector) { 4502 if (selector.match(polyfillHostRe)) { 4503 selector = selector.replace(polyfillHostNoCombinator, scopeSelector); 4504 return selector.replace(polyfillHostRe, scopeSelector + " "); 4505 } else { 4506 return scopeSelector + " " + selector; 4507 } 4508 }, 4509 applyStrictSelectorScope: function(selector, scopeSelector) { 4510 scopeSelector = scopeSelector.replace(/\[is=([^\]]*)\]/g, "$1"); 4511 var splits = [ " ", ">", "+", "~" ], scoped = selector, attrName = "[" + scopeSelector + "]"; 4512 splits.forEach(function(sep) { 4513 var parts = scoped.split(sep); 4514 scoped = parts.map(function(p) { 4515 var t = p.trim().replace(polyfillHostRe, ""); 4516 if (t && splits.indexOf(t) < 0 && t.indexOf(attrName) < 0) { 4517 p = t.replace(/([^:]*)(:*)(.*)/, "$1" + attrName + "$2$3"); 4518 } 4519 return p; 4520 }).join(sep); 4521 }); 4522 return scoped; 4523 }, 4524 insertPolyfillHostInCssText: function(selector) { 4525 return selector.replace(colonHostContextRe, polyfillHostContext).replace(colonHostRe, polyfillHost); 4526 }, 4527 propertiesFromRule: function(rule) { 4528 var cssText = rule.style.cssText; 4529 if (rule.style.content && !rule.style.content.match(/['"]+|attr/)) { 4530 cssText = cssText.replace(/content:[^;]*;/g, "content: '" + rule.style.content + "';"); 4531 } 4532 var style = rule.style; 4533 for (var i in style) { 4534 if (style[i] === "initial") { 4535 cssText += i + ": initial; "; 4536 } 4537 } 4538 return cssText; 4539 }, 4540 replaceTextInStyles: function(styles, action) { 4541 if (styles && action) { 4542 if (!(styles instanceof Array)) { 4543 styles = [ styles ]; 4544 } 4545 Array.prototype.forEach.call(styles, function(s) { 4546 s.textContent = action.call(this, s.textContent); 4547 }, this); 4548 } 4549 }, 4550 addCssToDocument: function(cssText, name) { 4551 if (cssText.match("@import")) { 4552 addOwnSheet(cssText, name); 4553 } else { 4554 addCssToDocument(cssText); 4555 } 4556 } 4557 }; 4558 var selectorRe = /([^{]*)({[\s\S]*?})/gim, cssCommentRe = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//gim, cssCommentNextSelectorRe = /\/\*\s*@polyfill ([^*]*\*+([^/*][^*]*\*+)*\/)([^{]*?){/gim, cssContentNextSelectorRe = /polyfill-next-selector[^}]*content\:[\s]*?['"](.*?)['"][;\s]*}([^{]*?){/gim, cssCommentRuleRe = /\/\*\s@polyfill-rule([^*]*\*+([^/*][^*]*\*+)*)\//gim, cssContentRuleRe = /(polyfill-rule)[^}]*(content\:[\s]*['"](.*?)['"])[;\s]*[^}]*}/gim, cssCommentUnscopedRuleRe = /\/\*\s@polyfill-unscoped-rule([^*]*\*+([^/*][^*]*\*+)*)\//gim, cssContentUnscopedRuleRe = /(polyfill-unscoped-rule)[^}]*(content\:[\s]*['"](.*?)['"])[;\s]*[^}]*}/gim, cssPseudoRe = /::(x-[^\s{,(]*)/gim, cssPartRe = /::part\(([^)]*)\)/gim, polyfillHost = "-shadowcsshost", polyfillHostContext = "-shadowcsscontext", parenSuffix = ")(?:\\((" + "(?:\\([^)(]*\\)|[^)(]*)+?" + ")\\))?([^,{]*)"; 4559 var cssColonHostRe = new RegExp("(" + polyfillHost + parenSuffix, "gim"), cssColonHostContextRe = new RegExp("(" + polyfillHostContext + parenSuffix, "gim"), selectorReSuffix = "([>\\s~+[.,{:][\\s\\S]*)?$", colonHostRe = /\:host/gim, colonHostContextRe = /\:host-context/gim, polyfillHostNoCombinator = polyfillHost + "-no-combinator", polyfillHostRe = new RegExp(polyfillHost, "gim"), polyfillHostContextRe = new RegExp(polyfillHostContext, "gim"), shadowDOMSelectorsRe = [ /\^\^/g, /\^/g, /\/shadow\//g, /\/shadow-deep\//g, /::shadow/g, /\/deep\//g, /::content/g ]; 4560 function stylesToCssText(styles, preserveComments) { 4561 var cssText = ""; 4562 Array.prototype.forEach.call(styles, function(s) { 4563 cssText += s.textContent + "\n\n"; 4564 }); 4565 if (!preserveComments) { 4566 cssText = cssText.replace(cssCommentRe, ""); 4567 } 4568 return cssText; 4569 } 4570 function cssTextToStyle(cssText) { 4571 var style = document.createElement("style"); 4572 style.textContent = cssText; 4573 return style; 4574 } 4575 function cssToRules(cssText) { 4576 var style = cssTextToStyle(cssText); 4577 document.head.appendChild(style); 4578 var rules = []; 4579 if (style.sheet) { 4580 try { 4581 rules = style.sheet.cssRules; 4582 } catch (e) {} 4583 } else { 4584 console.warn("sheet not found", style); 4585 } 4586 style.parentNode.removeChild(style); 4587 return rules; 4588 } 4589 var frame = document.createElement("iframe"); 4590 frame.style.display = "none"; 4591 function initFrame() { 4592 frame.initialized = true; 4593 document.body.appendChild(frame); 4594 var doc = frame.contentDocument; 4595 var base = doc.createElement("base"); 4596 base.href = document.baseURI; 4597 doc.head.appendChild(base); 4598 } 4599 function inFrame(fn) { 4600 if (!frame.initialized) { 4601 initFrame(); 4602 } 4603 document.body.appendChild(frame); 4604 fn(frame.contentDocument); 4605 document.body.removeChild(frame); 4606 } 4607 var isChrome = navigator.userAgent.match("Chrome"); 4608 function withCssRules(cssText, callback) { 4609 if (!callback) { 4610 return; 4611 } 4612 var rules; 4613 if (cssText.match("@import") && isChrome) { 4614 var style = cssTextToStyle(cssText); 4615 inFrame(function(doc) { 4616 doc.head.appendChild(style.impl); 4617 rules = Array.prototype.slice.call(style.sheet.cssRules, 0); 4618 callback(rules); 4619 }); 4620 } else { 4621 rules = cssToRules(cssText); 4622 callback(rules); 4623 } 4624 } 4625 function rulesToCss(cssRules) { 4626 for (var i = 0, css = []; i < cssRules.length; i++) { 4627 css.push(cssRules[i].cssText); 4628 } 4629 return css.join("\n\n"); 4630 } 4631 function addCssToDocument(cssText) { 4632 if (cssText) { 4633 getSheet().appendChild(document.createTextNode(cssText)); 4634 } 4635 } 4636 function addOwnSheet(cssText, name) { 4637 var style = cssTextToStyle(cssText); 4638 style.setAttribute(name, ""); 4639 style.setAttribute(SHIMMED_ATTRIBUTE, ""); 4640 document.head.appendChild(style); 4641 } 4642 var SHIM_ATTRIBUTE = "shim-shadowdom"; 4643 var SHIMMED_ATTRIBUTE = "shim-shadowdom-css"; 4644 var NO_SHIM_ATTRIBUTE = "no-shim"; 4645 var sheet; 4646 function getSheet() { 4647 if (!sheet) { 4648 sheet = document.createElement("style"); 4649 sheet.setAttribute(SHIMMED_ATTRIBUTE, ""); 4650 sheet[SHIMMED_ATTRIBUTE] = true; 4651 } 4652 return sheet; 4653 } 4654 if (window.ShadowDOMPolyfill) { 4655 addCssToDocument("style { display: none !important; }\n"); 4656 var doc = ShadowDOMPolyfill.wrap(document); 4657 var head = doc.querySelector("head"); 4658 head.insertBefore(getSheet(), head.childNodes[0]); 4659 document.addEventListener("DOMContentLoaded", function() { 4660 var urlResolver = scope.urlResolver; 4661 if (window.HTMLImports && !HTMLImports.useNative) { 4662 var SHIM_SHEET_SELECTOR = "link[rel=stylesheet]" + "[" + SHIM_ATTRIBUTE + "]"; 4663 var SHIM_STYLE_SELECTOR = "style[" + SHIM_ATTRIBUTE + "]"; 4664 HTMLImports.importer.documentPreloadSelectors += "," + SHIM_SHEET_SELECTOR; 4665 HTMLImports.importer.importsPreloadSelectors += "," + SHIM_SHEET_SELECTOR; 4666 HTMLImports.parser.documentSelectors = [ HTMLImports.parser.documentSelectors, SHIM_SHEET_SELECTOR, SHIM_STYLE_SELECTOR ].join(","); 4667 var originalParseGeneric = HTMLImports.parser.parseGeneric; 4668 HTMLImports.parser.parseGeneric = function(elt) { 4669 if (elt[SHIMMED_ATTRIBUTE]) { 4670 return; 4671 } 4672 var style = elt.__importElement || elt; 4673 if (!style.hasAttribute(SHIM_ATTRIBUTE)) { 4674 originalParseGeneric.call(this, elt); 4675 return; 4676 } 4677 if (elt.__resource) { 4678 style = elt.ownerDocument.createElement("style"); 4679 style.textContent = elt.__resource; 4680 } 4681 HTMLImports.path.resolveUrlsInStyle(style); 4682 style.textContent = ShadowCSS.shimStyle(style); 4683 style.removeAttribute(SHIM_ATTRIBUTE, ""); 4684 style.setAttribute(SHIMMED_ATTRIBUTE, ""); 4685 style[SHIMMED_ATTRIBUTE] = true; 4686 if (style.parentNode !== head) { 4687 if (elt.parentNode === head) { 4688 head.replaceChild(style, elt); 4689 } else { 4690 this.addElementToDocument(style); 4691 } 4692 } 4693 style.__importParsed = true; 4694 this.markParsingComplete(elt); 4695 this.parseNext(); 4696 }; 4697 var hasResource = HTMLImports.parser.hasResource; 4698 HTMLImports.parser.hasResource = function(node) { 4699 if (node.localName === "link" && node.rel === "stylesheet" && node.hasAttribute(SHIM_ATTRIBUTE)) { 4700 return node.__resource; 4701 } else { 4702 return hasResource.call(this, node); 4703 } 4704 }; 4705 } 4706 }); 4707 } 4708 scope.ShadowCSS = ShadowCSS; 4709 })(window.WebComponents); 4710} 4711 4712(function(scope) { 4713 if (window.ShadowDOMPolyfill) { 4714 window.wrap = ShadowDOMPolyfill.wrapIfNeeded; 4715 window.unwrap = ShadowDOMPolyfill.unwrapIfNeeded; 4716 } else { 4717 window.wrap = window.unwrap = function(n) { 4718 return n; 4719 }; 4720 } 4721})(window.WebComponents); 4722 4723window.HTMLImports = window.HTMLImports || { 4724 flags: {} 4725}; 4726 4727(function(scope) { 4728 var IMPORT_LINK_TYPE = "import"; 4729 var useNative = Boolean(IMPORT_LINK_TYPE in document.createElement("link")); 4730 var hasShadowDOMPolyfill = Boolean(window.ShadowDOMPolyfill); 4731 var wrap = function(node) { 4732 return hasShadowDOMPolyfill ? ShadowDOMPolyfill.wrapIfNeeded(node) : node; 4733 }; 4734 var rootDocument = wrap(document); 4735 var currentScriptDescriptor = { 4736 get: function() { 4737 var script = HTMLImports.currentScript || document.currentScript || (document.readyState !== "complete" ? document.scripts[document.scripts.length - 1] : null); 4738 return wrap(script); 4739 }, 4740 configurable: true 4741 }; 4742 Object.defineProperty(document, "_currentScript", currentScriptDescriptor); 4743 Object.defineProperty(rootDocument, "_currentScript", currentScriptDescriptor); 4744 var isIE = /Trident|Edge/.test(navigator.userAgent); 4745 function whenReady(callback, doc) { 4746 doc = doc || rootDocument; 4747 whenDocumentReady(function() { 4748 watchImportsLoad(callback, doc); 4749 }, doc); 4750 } 4751 var requiredReadyState = isIE ? "complete" : "interactive"; 4752 var READY_EVENT = "readystatechange"; 4753 function isDocumentReady(doc) { 4754 return doc.readyState === "complete" || doc.readyState === requiredReadyState; 4755 } 4756 function whenDocumentReady(callback, doc) { 4757 if (!isDocumentReady(doc)) { 4758 var checkReady = function() { 4759 if (doc.readyState === "complete" || doc.readyState === requiredReadyState) { 4760 doc.removeEventListener(READY_EVENT, checkReady); 4761 whenDocumentReady(callback, doc); 4762 } 4763 }; 4764 doc.addEventListener(READY_EVENT, checkReady); 4765 } else if (callback) { 4766 callback(); 4767 } 4768 } 4769 function markTargetLoaded(event) { 4770 event.target.__loaded = true; 4771 } 4772 function watchImportsLoad(callback, doc) { 4773 var imports = doc.querySelectorAll("link[rel=import]"); 4774 var loaded = 0, l = imports.length; 4775 function checkDone(d) { 4776 if (loaded == l && callback) { 4777 callback(); 4778 } 4779 } 4780 function loadedImport(e) { 4781 markTargetLoaded(e); 4782 loaded++; 4783 checkDone(); 4784 } 4785 if (l) { 4786 for (var i = 0, imp; i < l && (imp = imports[i]); i++) { 4787 if (isImportLoaded(imp)) { 4788 loadedImport.call(imp, { 4789 target: imp 4790 }); 4791 } else { 4792 imp.addEventListener("load", loadedImport); 4793 imp.addEventListener("error", loadedImport); 4794 } 4795 } 4796 } else { 4797 checkDone(); 4798 } 4799 } 4800 function isImportLoaded(link) { 4801 return useNative ? link.__loaded || link.import && link.import.readyState !== "loading" : link.__importParsed; 4802 } 4803 if (useNative) { 4804 new MutationObserver(function(mxns) { 4805 for (var i = 0, l = mxns.length, m; i < l && (m = mxns[i]); i++) { 4806 if (m.addedNodes) { 4807 handleImports(m.addedNodes); 4808 } 4809 } 4810 }).observe(document.head, { 4811 childList: true 4812 }); 4813 function handleImports(nodes) { 4814 for (var i = 0, l = nodes.length, n; i < l && (n = nodes[i]); i++) { 4815 if (isImport(n)) { 4816 handleImport(n); 4817 } 4818 } 4819 } 4820 function isImport(element) { 4821 return element.localName === "link" && element.rel === "import"; 4822 } 4823 function handleImport(element) { 4824 var loaded = element.import; 4825 if (loaded) { 4826 markTargetLoaded({ 4827 target: element 4828 }); 4829 } else { 4830 element.addEventListener("load", markTargetLoaded); 4831 element.addEventListener("error", markTargetLoaded); 4832 } 4833 } 4834 (function() { 4835 if (document.readyState === "loading") { 4836 var imports = document.querySelectorAll("link[rel=import]"); 4837 for (var i = 0, l = imports.length, imp; i < l && (imp = imports[i]); i++) { 4838 handleImport(imp); 4839 } 4840 } 4841 })(); 4842 } 4843 whenReady(function() { 4844 HTMLImports.ready = true; 4845 HTMLImports.readyTime = new Date().getTime(); 4846 var evt = rootDocument.createEvent("CustomEvent"); 4847 evt.initCustomEvent("HTMLImportsLoaded", true, true, {}); 4848 rootDocument.dispatchEvent(evt); 4849 }); 4850 scope.IMPORT_LINK_TYPE = IMPORT_LINK_TYPE; 4851 scope.useNative = useNative; 4852 scope.rootDocument = rootDocument; 4853 scope.whenReady = whenReady; 4854 scope.isIE = isIE; 4855})(HTMLImports); 4856 4857(function(scope) { 4858 var modules = []; 4859 var addModule = function(module) { 4860 modules.push(module); 4861 }; 4862 var initializeModules = function() { 4863 modules.forEach(function(module) { 4864 module(scope); 4865 }); 4866 }; 4867 scope.addModule = addModule; 4868 scope.initializeModules = initializeModules; 4869})(HTMLImports); 4870 4871HTMLImports.addModule(function(scope) { 4872 var CSS_URL_REGEXP = /(url\()([^)]*)(\))/g; 4873 var CSS_IMPORT_REGEXP = /(@import[\s]+(?!url\())([^;]*)(;)/g; 4874 var path = { 4875 resolveUrlsInStyle: function(style) { 4876 var doc = style.ownerDocument; 4877 var resolver = doc.createElement("a"); 4878 style.textContent = this.resolveUrlsInCssText(style.textContent, resolver); 4879 return style; 4880 }, 4881 resolveUrlsInCssText: function(cssText, urlObj) { 4882 var r = this.replaceUrls(cssText, urlObj, CSS_URL_REGEXP); 4883 r = this.replaceUrls(r, urlObj, CSS_IMPORT_REGEXP); 4884 return r; 4885 }, 4886 replaceUrls: function(text, urlObj, regexp) { 4887 return text.replace(regexp, function(m, pre, url, post) { 4888 var urlPath = url.replace(/["']/g, ""); 4889 urlObj.href = urlPath; 4890 urlPath = urlObj.href; 4891 return pre + "'" + urlPath + "'" + post; 4892 }); 4893 } 4894 }; 4895 scope.path = path; 4896}); 4897 4898HTMLImports.addModule(function(scope) { 4899 var xhr = { 4900 async: true, 4901 ok: function(request) { 4902 return request.status >= 200 && request.status < 300 || request.status === 304 || request.status === 0; 4903 }, 4904 load: function(url, next, nextContext) { 4905 var request = new XMLHttpRequest(); 4906 if (scope.flags.debug || scope.flags.bust) { 4907 url += "?" + Math.random(); 4908 } 4909 request.open("GET", url, xhr.async); 4910 request.addEventListener("readystatechange", function(e) { 4911 if (request.readyState === 4) { 4912 var locationHeader = request.getResponseHeader("Location"); 4913 var redirectedUrl = null; 4914 if (locationHeader) { 4915 var redirectedUrl = locationHeader.substr(0, 1) === "/" ? location.origin + locationHeader : locationHeader; 4916 } 4917 next.call(nextContext, !xhr.ok(request) && request, request.response || request.responseText, redirectedUrl); 4918 } 4919 }); 4920 request.send(); 4921 return request; 4922 }, 4923 loadDocument: function(url, next, nextContext) { 4924 this.load(url, next, nextContext).responseType = "document"; 4925 } 4926 }; 4927 scope.xhr = xhr; 4928}); 4929 4930HTMLImports.addModule(function(scope) { 4931 var xhr = scope.xhr; 4932 var flags = scope.flags; 4933 var Loader = function(onLoad, onComplete) { 4934 this.cache = {}; 4935 this.onload = onLoad; 4936 this.oncomplete = onComplete; 4937 this.inflight = 0; 4938 this.pending = {}; 4939 }; 4940 Loader.prototype = { 4941 addNodes: function(nodes) { 4942 this.inflight += nodes.length; 4943 for (var i = 0, l = nodes.length, n; i < l && (n = nodes[i]); i++) { 4944 this.require(n); 4945 } 4946 this.checkDone(); 4947 }, 4948 addNode: function(node) { 4949 this.inflight++; 4950 this.require(node); 4951 this.checkDone(); 4952 }, 4953 require: function(elt) { 4954 var url = elt.src || elt.href; 4955 elt.__nodeUrl = url; 4956 if (!this.dedupe(url, elt)) { 4957 this.fetch(url, elt); 4958 } 4959 }, 4960 dedupe: function(url, elt) { 4961 if (this.pending[url]) { 4962 this.pending[url].push(elt); 4963 return true; 4964 } 4965 var resource; 4966 if (this.cache[url]) { 4967 this.onload(url, elt, this.cache[url]); 4968 this.tail(); 4969 return true; 4970 } 4971 this.pending[url] = [ elt ]; 4972 return false; 4973 }, 4974 fetch: function(url, elt) { 4975 flags.load && console.log("fetch", url, elt); 4976 if (!url) { 4977 setTimeout(function() { 4978 this.receive(url, elt, { 4979 error: "href must be specified" 4980 }, null); 4981 }.bind(this), 0); 4982 } else if (url.match(/^data:/)) { 4983 var pieces = url.split(","); 4984 var header = pieces[0]; 4985 var body = pieces[1]; 4986 if (header.indexOf(";base64") > -1) { 4987 body = atob(body); 4988 } else { 4989 body = decodeURIComponent(body); 4990 } 4991 setTimeout(function() { 4992 this.receive(url, elt, null, body); 4993 }.bind(this), 0); 4994 } else { 4995 var receiveXhr = function(err, resource, redirectedUrl) { 4996 this.receive(url, elt, err, resource, redirectedUrl); 4997 }.bind(this); 4998 xhr.load(url, receiveXhr); 4999 } 5000 }, 5001 receive: function(url, elt, err, resource, redirectedUrl) { 5002 this.cache[url] = resource; 5003 var $p = this.pending[url]; 5004 for (var i = 0, l = $p.length, p; i < l && (p = $p[i]); i++) { 5005 this.onload(url, p, resource, err, redirectedUrl); 5006 this.tail(); 5007 } 5008 this.pending[url] = null; 5009 }, 5010 tail: function() { 5011 --this.inflight; 5012 this.checkDone(); 5013 }, 5014 checkDone: function() { 5015 if (!this.inflight) { 5016 this.oncomplete(); 5017 } 5018 } 5019 }; 5020 scope.Loader = Loader; 5021}); 5022 5023HTMLImports.addModule(function(scope) { 5024 var Observer = function(addCallback) { 5025 this.addCallback = addCallback; 5026 this.mo = new MutationObserver(this.handler.bind(this)); 5027 }; 5028 Observer.prototype = { 5029 handler: function(mutations) { 5030 for (var i = 0, l = mutations.length, m; i < l && (m = mutations[i]); i++) { 5031 if (m.type === "childList" && m.addedNodes.length) { 5032 this.addedNodes(m.addedNodes); 5033 } 5034 } 5035 }, 5036 addedNodes: function(nodes) { 5037 if (this.addCallback) { 5038 this.addCallback(nodes); 5039 } 5040 for (var i = 0, l = nodes.length, n, loading; i < l && (n = nodes[i]); i++) { 5041 if (n.children && n.children.length) { 5042 this.addedNodes(n.children); 5043 } 5044 } 5045 }, 5046 observe: function(root) { 5047 this.mo.observe(root, { 5048 childList: true, 5049 subtree: true 5050 }); 5051 } 5052 }; 5053 scope.Observer = Observer; 5054}); 5055 5056HTMLImports.addModule(function(scope) { 5057 var path = scope.path; 5058 var rootDocument = scope.rootDocument; 5059 var flags = scope.flags; 5060 var isIE = scope.isIE; 5061 var IMPORT_LINK_TYPE = scope.IMPORT_LINK_TYPE; 5062 var IMPORT_SELECTOR = "link[rel=" + IMPORT_LINK_TYPE + "]"; 5063 var importParser = { 5064 documentSelectors: IMPORT_SELECTOR, 5065 importsSelectors: [ IMPORT_SELECTOR, "link[rel=stylesheet]", "style", "script:not([type])", 'script[type="text/javascript"]' ].join(","), 5066 map: { 5067 link: "parseLink", 5068 script: "parseScript", 5069 style: "parseStyle" 5070 }, 5071 dynamicElements: [], 5072 parseNext: function() { 5073 var next = this.nextToParse(); 5074 if (next) { 5075 this.parse(next); 5076 } 5077 }, 5078 parse: function(elt) { 5079 if (this.isParsed(elt)) { 5080 flags.parse && console.log("[%s] is already parsed", elt.localName); 5081 return; 5082 } 5083 var fn = this[this.map[elt.localName]]; 5084 if (fn) { 5085 this.markParsing(elt); 5086 fn.call(this, elt); 5087 } 5088 }, 5089 parseDynamic: function(elt, quiet) { 5090 this.dynamicElements.push(elt); 5091 if (!quiet) { 5092 this.parseNext(); 5093 } 5094 }, 5095 markParsing: function(elt) { 5096 flags.parse && console.log("parsing", elt); 5097 this.parsingElement = elt; 5098 }, 5099 markParsingComplete: function(elt) { 5100 elt.__importParsed = true; 5101 this.markDynamicParsingComplete(elt); 5102 if (elt.__importElement) { 5103 elt.__importElement.__importParsed = true; 5104 this.markDynamicParsingComplete(elt.__importElement); 5105 } 5106 this.parsingElement = null; 5107 flags.parse && console.log("completed", elt); 5108 }, 5109 markDynamicParsingComplete: function(elt) { 5110 var i = this.dynamicElements.indexOf(elt); 5111 if (i >= 0) { 5112 this.dynamicElements.splice(i, 1); 5113 } 5114 }, 5115 parseImport: function(elt) { 5116 if (HTMLImports.__importsParsingHook) { 5117 HTMLImports.__importsParsingHook(elt); 5118 } 5119 if (elt.import) { 5120 elt.import.__importParsed = true; 5121 } 5122 this.markParsingComplete(elt); 5123 if (elt.__resource && !elt.__error) { 5124 elt.dispatchEvent(new CustomEvent("load", { 5125 bubbles: false 5126 })); 5127 } else { 5128 elt.dispatchEvent(new CustomEvent("error", { 5129 bubbles: false 5130 })); 5131 } 5132 if (elt.__pending) { 5133 var fn; 5134 while (elt.__pending.length) { 5135 fn = elt.__pending.shift(); 5136 if (fn) { 5137 fn({ 5138 target: elt 5139 }); 5140 } 5141 } 5142 } 5143 this.parseNext(); 5144 }, 5145 parseLink: function(linkElt) { 5146 if (nodeIsImport(linkElt)) { 5147 this.parseImport(linkElt); 5148 } else { 5149 linkElt.href = linkElt.href; 5150 this.parseGeneric(linkElt); 5151 } 5152 }, 5153 parseStyle: function(elt) { 5154 var src = elt; 5155 elt = cloneStyle(elt); 5156 elt.__importElement = src; 5157 this.parseGeneric(elt); 5158 }, 5159 parseGeneric: function(elt) { 5160 this.trackElement(elt); 5161 this.addElementToDocument(elt); 5162 }, 5163 rootImportForElement: function(elt) { 5164 var n = elt; 5165 while (n.ownerDocument.__importLink) { 5166 n = n.ownerDocument.__importLink; 5167 } 5168 return n; 5169 }, 5170 addElementToDocument: function(elt) { 5171 var port = this.rootImportForElement(elt.__importElement || elt); 5172 port.parentNode.insertBefore(elt, port); 5173 }, 5174 trackElement: function(elt, callback) { 5175 var self = this; 5176 var done = function(e) { 5177 if (callback) { 5178 callback(e); 5179 } 5180 self.markParsingComplete(elt); 5181 self.parseNext(); 5182 }; 5183 elt.addEventListener("load", done); 5184 elt.addEventListener("error", done); 5185 if (isIE && elt.localName === "style") { 5186 var fakeLoad = false; 5187 if (elt.textContent.indexOf("@import") == -1) { 5188 fakeLoad = true; 5189 } else if (elt.sheet) { 5190 fakeLoad = true; 5191 var csr = elt.sheet.cssRules; 5192 var len = csr ? csr.length : 0; 5193 for (var i = 0, r; i < len && (r = csr[i]); i++) { 5194 if (r.type === CSSRule.IMPORT_RULE) { 5195 fakeLoad = fakeLoad && Boolean(r.styleSheet); 5196 } 5197 } 5198 } 5199 if (fakeLoad) { 5200 elt.dispatchEvent(new CustomEvent("load", { 5201 bubbles: false 5202 })); 5203 } 5204 } 5205 }, 5206 parseScript: function(scriptElt) { 5207 var script = document.createElement("script"); 5208 script.__importElement = scriptElt; 5209 script.src = scriptElt.src ? scriptElt.src : generateScriptDataUrl(scriptElt); 5210 scope.currentScript = scriptElt; 5211 this.trackElement(script, function(e) { 5212 script.parentNode.removeChild(script); 5213 scope.currentScript = null; 5214 }); 5215 this.addElementToDocument(script); 5216 }, 5217 nextToParse: function() { 5218 this._mayParse = []; 5219 return !this.parsingElement && (this.nextToParseInDoc(rootDocument) || this.nextToParseDynamic()); 5220 }, 5221 nextToParseInDoc: function(doc, link) { 5222 if (doc && this._mayParse.indexOf(doc) < 0) { 5223 this._mayParse.push(doc); 5224 var nodes = doc.querySelectorAll(this.parseSelectorsForNode(doc)); 5225 for (var i = 0, l = nodes.length, p = 0, n; i < l && (n = nodes[i]); i++) { 5226 if (!this.isParsed(n)) { 5227 if (this.hasResource(n)) { 5228 return nodeIsImport(n) ? this.nextToParseInDoc(n.import, n) : n; 5229 } else { 5230 return; 5231 } 5232 } 5233 } 5234 } 5235 return link; 5236 }, 5237 nextToParseDynamic: function() { 5238 return this.dynamicElements[0]; 5239 }, 5240 parseSelectorsForNode: function(node) { 5241 var doc = node.ownerDocument || node; 5242 return doc === rootDocument ? this.documentSelectors : this.importsSelectors; 5243 }, 5244 isParsed: function(node) { 5245 return node.__importParsed; 5246 }, 5247 needsDynamicParsing: function(elt) { 5248 return this.dynamicElements.indexOf(elt) >= 0; 5249 }, 5250 hasResource: function(node) { 5251 if (nodeIsImport(node) && node.import === undefined) { 5252 return false; 5253 } 5254 return true; 5255 } 5256 }; 5257 function nodeIsImport(elt) { 5258 return elt.localName === "link" && elt.rel === IMPORT_LINK_TYPE; 5259 } 5260 function generateScriptDataUrl(script) { 5261 var scriptContent = generateScriptContent(script); 5262 return "data:text/javascript;charset=utf-8," + encodeURIComponent(scriptContent); 5263 } 5264 function generateScriptContent(script) { 5265 return script.textContent + generateSourceMapHint(script); 5266 } 5267 function generateSourceMapHint(script) { 5268 var owner = script.ownerDocument; 5269 owner.__importedScripts = owner.__importedScripts || 0; 5270 var moniker = script.ownerDocument.baseURI; 5271 var num = owner.__importedScripts ? "-" + owner.__importedScripts : ""; 5272 owner.__importedScripts++; 5273 return "\n//# sourceURL=" + moniker + num + ".js\n"; 5274 } 5275 function cloneStyle(style) { 5276 var clone = style.ownerDocument.createElement("style"); 5277 clone.textContent = style.textContent; 5278 path.resolveUrlsInStyle(clone); 5279 return clone; 5280 } 5281 scope.parser = importParser; 5282 scope.IMPORT_SELECTOR = IMPORT_SELECTOR; 5283}); 5284 5285HTMLImports.addModule(function(scope) { 5286 var flags = scope.flags; 5287 var IMPORT_LINK_TYPE = scope.IMPORT_LINK_TYPE; 5288 var IMPORT_SELECTOR = scope.IMPORT_SELECTOR; 5289 var rootDocument = scope.rootDocument; 5290 var Loader = scope.Loader; 5291 var Observer = scope.Observer; 5292 var parser = scope.parser; 5293 var importer = { 5294 documents: {}, 5295 documentPreloadSelectors: IMPORT_SELECTOR, 5296 importsPreloadSelectors: [ IMPORT_SELECTOR ].join(","), 5297 loadNode: function(node) { 5298 importLoader.addNode(node); 5299 }, 5300 loadSubtree: function(parent) { 5301 var nodes = this.marshalNodes(parent); 5302 importLoader.addNodes(nodes); 5303 }, 5304 marshalNodes: function(parent) { 5305 return parent.querySelectorAll(this.loadSelectorsForNode(parent)); 5306 }, 5307 loadSelectorsForNode: function(node) { 5308 var doc = node.ownerDocument || node; 5309 return doc === rootDocument ? this.documentPreloadSelectors : this.importsPreloadSelectors; 5310 }, 5311 loaded: function(url, elt, resource, err, redirectedUrl) { 5312 flags.load && console.log("loaded", url, elt); 5313 elt.__resource = resource; 5314 elt.__error = err; 5315 if (isImportLink(elt)) { 5316 var doc = this.documents[url]; 5317 if (doc === undefined) { 5318 doc = err ? null : makeDocument(resource, redirectedUrl || url); 5319 if (doc) { 5320 doc.__importLink = elt; 5321 this.bootDocument(doc); 5322 } 5323 this.documents[url] = doc; 5324 } 5325 elt.import = doc; 5326 } 5327 parser.parseNext(); 5328 }, 5329 bootDocument: function(doc) { 5330 this.loadSubtree(doc); 5331 this.observer.observe(doc); 5332 parser.parseNext(); 5333 }, 5334 loadedAll: function() { 5335 parser.parseNext(); 5336 } 5337 }; 5338 var importLoader = new Loader(importer.loaded.bind(importer), importer.loadedAll.bind(importer)); 5339 importer.observer = new Observer(); 5340 function isImportLink(elt) { 5341 return isLinkRel(elt, IMPORT_LINK_TYPE); 5342 } 5343 function isLinkRel(elt, rel) { 5344 return elt.localName === "link" && elt.getAttribute("rel") === rel; 5345 } 5346 function hasBaseURIAccessor(doc) { 5347 return !!Object.getOwnPropertyDescriptor(doc, "baseURI"); 5348 } 5349 function makeDocument(resource, url) { 5350 var doc = document.implementation.createHTMLDocument(IMPORT_LINK_TYPE); 5351 doc._URL = url; 5352 var base = doc.createElement("base"); 5353 base.setAttribute("href", url); 5354 if (!doc.baseURI && !hasBaseURIAccessor(doc)) { 5355 Object.defineProperty(doc, "baseURI", { 5356 value: url 5357 }); 5358 } 5359 var meta = doc.createElement("meta"); 5360 meta.setAttribute("charset", "utf-8"); 5361 doc.head.appendChild(meta); 5362 doc.head.appendChild(base); 5363 doc.body.innerHTML = resource; 5364 if (window.HTMLTemplateElement && HTMLTemplateElement.bootstrap) { 5365 HTMLTemplateElement.bootstrap(doc); 5366 } 5367 return doc; 5368 } 5369 if (!document.baseURI) { 5370 var baseURIDescriptor = { 5371 get: function() { 5372 var base = document.querySelector("base"); 5373 return base ? base.href : window.location.href; 5374 }, 5375 configurable: true 5376 }; 5377 Object.defineProperty(document, "baseURI", baseURIDescriptor); 5378 Object.defineProperty(rootDocument, "baseURI", baseURIDescriptor); 5379 } 5380 scope.importer = importer; 5381 scope.importLoader = importLoader; 5382}); 5383 5384HTMLImports.addModule(function(scope) { 5385 var parser = scope.parser; 5386 var importer = scope.importer; 5387 var dynamic = { 5388 added: function(nodes) { 5389 var owner, parsed, loading; 5390 for (var i = 0, l = nodes.length, n; i < l && (n = nodes[i]); i++) { 5391 if (!owner) { 5392 owner = n.ownerDocument; 5393 parsed = parser.isParsed(owner); 5394 } 5395 loading = this.shouldLoadNode(n); 5396 if (loading) { 5397 importer.loadNode(n); 5398 } 5399 if (this.shouldParseNode(n) && parsed) { 5400 parser.parseDynamic(n, loading); 5401 } 5402 } 5403 }, 5404 shouldLoadNode: function(node) { 5405 return node.nodeType === 1 && matches.call(node, importer.loadSelectorsForNode(node)); 5406 }, 5407 shouldParseNode: function(node) { 5408 return node.nodeType === 1 && matches.call(node, parser.parseSelectorsForNode(node)); 5409 } 5410 }; 5411 importer.observer.addCallback = dynamic.added.bind(dynamic); 5412 var matches = HTMLElement.prototype.matches || HTMLElement.prototype.matchesSelector || HTMLElement.prototype.webkitMatchesSelector || HTMLElement.prototype.mozMatchesSelector || HTMLElement.prototype.msMatchesSelector; 5413}); 5414 5415(function(scope) { 5416 var initializeModules = scope.initializeModules; 5417 var isIE = scope.isIE; 5418 if (scope.useNative) { 5419 return; 5420 } 5421 if (isIE && typeof window.CustomEvent !== "function") { 5422 window.CustomEvent = function(inType, params) { 5423 params = params || {}; 5424 var e = document.createEvent("CustomEvent"); 5425 e.initCustomEvent(inType, Boolean(params.bubbles), Boolean(params.cancelable), params.detail); 5426 return e; 5427 }; 5428 window.CustomEvent.prototype = window.Event.prototype; 5429 } 5430 initializeModules(); 5431 var rootDocument = scope.rootDocument; 5432 function bootstrap() { 5433 HTMLImports.importer.bootDocument(rootDocument); 5434 } 5435 if (document.readyState === "complete" || document.readyState === "interactive" && !window.attachEvent) { 5436 bootstrap(); 5437 } else { 5438 document.addEventListener("DOMContentLoaded", bootstrap); 5439 } 5440})(HTMLImports); 5441 5442window.CustomElements = window.CustomElements || { 5443 flags: {} 5444}; 5445 5446(function(scope) { 5447 var flags = scope.flags; 5448 var modules = []; 5449 var addModule = function(module) { 5450 modules.push(module); 5451 }; 5452 var initializeModules = function() { 5453 modules.forEach(function(module) { 5454 module(scope); 5455 }); 5456 }; 5457 scope.addModule = addModule; 5458 scope.initializeModules = initializeModules; 5459 scope.hasNative = Boolean(document.registerElement); 5460 scope.useNative = !flags.register && scope.hasNative && !window.ShadowDOMPolyfill && (!window.HTMLImports || HTMLImports.useNative); 5461})(CustomElements); 5462 5463CustomElements.addModule(function(scope) { 5464 var IMPORT_LINK_TYPE = window.HTMLImports ? HTMLImports.IMPORT_LINK_TYPE : "none"; 5465 function forSubtree(node, cb) { 5466 findAllElements(node, function(e) { 5467 if (cb(e)) { 5468 return true; 5469 } 5470 forRoots(e, cb); 5471 }); 5472 forRoots(node, cb); 5473 } 5474 function findAllElements(node, find, data) { 5475 var e = node.firstElementChild; 5476 if (!e) { 5477 e = node.firstChild; 5478 while (e && e.nodeType !== Node.ELEMENT_NODE) { 5479 e = e.nextSibling; 5480 } 5481 } 5482 while (e) { 5483 if (find(e, data) !== true) { 5484 findAllElements(e, find, data); 5485 } 5486 e = e.nextElementSibling; 5487 } 5488 return null; 5489 } 5490 function forRoots(node, cb) { 5491 var root = node.shadowRoot; 5492 while (root) { 5493 forSubtree(root, cb); 5494 root = root.olderShadowRoot; 5495 } 5496 } 5497 var processingDocuments; 5498 function forDocumentTree(doc, cb) { 5499 processingDocuments = []; 5500 _forDocumentTree(doc, cb); 5501 processingDocuments = null; 5502 } 5503 function _forDocumentTree(doc, cb) { 5504 doc = wrap(doc); 5505 if (processingDocuments.indexOf(doc) >= 0) { 5506 return; 5507 } 5508 processingDocuments.push(doc); 5509 var imports = doc.querySelectorAll("link[rel=" + IMPORT_LINK_TYPE + "]"); 5510 for (var i = 0, l = imports.length, n; i < l && (n = imports[i]); i++) { 5511 if (n.import) { 5512 _forDocumentTree(n.import, cb); 5513 } 5514 } 5515 cb(doc); 5516 } 5517 scope.forDocumentTree = forDocumentTree; 5518 scope.forSubtree = forSubtree; 5519}); 5520 5521CustomElements.addModule(function(scope) { 5522 var flags = scope.flags; 5523 var forSubtree = scope.forSubtree; 5524 var forDocumentTree = scope.forDocumentTree; 5525 function addedNode(node) { 5526 return added(node) || addedSubtree(node); 5527 } 5528 function added(node) { 5529 if (scope.upgrade(node)) { 5530 return true; 5531 } 5532 attached(node); 5533 } 5534 function addedSubtree(node) { 5535 forSubtree(node, function(e) { 5536 if (added(e)) { 5537 return true; 5538 } 5539 }); 5540 } 5541 function attachedNode(node) { 5542 attached(node); 5543 if (inDocument(node)) { 5544 forSubtree(node, function(e) { 5545 attached(e); 5546 }); 5547 } 5548 } 5549 var hasPolyfillMutations = !window.MutationObserver || window.MutationObserver === window.JsMutationObserver; 5550 scope.hasPolyfillMutations = hasPolyfillMutations; 5551 var isPendingMutations = false; 5552 var pendingMutations = []; 5553 function deferMutation(fn) { 5554 pendingMutations.push(fn); 5555 if (!isPendingMutations) { 5556 isPendingMutations = true; 5557 setTimeout(takeMutations); 5558 } 5559 } 5560 function takeMutations() { 5561 isPendingMutations = false; 5562 var $p = pendingMutations; 5563 for (var i = 0, l = $p.length, p; i < l && (p = $p[i]); i++) { 5564 p(); 5565 } 5566 pendingMutations = []; 5567 } 5568 function attached(element) { 5569 if (hasPolyfillMutations) { 5570 deferMutation(function() { 5571 _attached(element); 5572 }); 5573 } else { 5574 _attached(element); 5575 } 5576 } 5577 function _attached(element) { 5578 if (element.__upgraded__ && (element.attachedCallback || element.detachedCallback)) { 5579 if (!element.__attached && inDocument(element)) { 5580 element.__attached = true; 5581 if (element.attachedCallback) { 5582 element.attachedCallback(); 5583 } 5584 } 5585 } 5586 } 5587 function detachedNode(node) { 5588 detached(node); 5589 forSubtree(node, function(e) { 5590 detached(e); 5591 }); 5592 } 5593 function detached(element) { 5594 if (hasPolyfillMutations) { 5595 deferMutation(function() { 5596 _detached(element); 5597 }); 5598 } else { 5599 _detached(element); 5600 } 5601 } 5602 function _detached(element) { 5603 if (element.__upgraded__ && (element.attachedCallback || element.detachedCallback)) { 5604 if (element.__attached && !inDocument(element)) { 5605 element.__attached = false; 5606 if (element.detachedCallback) { 5607 element.detachedCallback(); 5608 } 5609 } 5610 } 5611 } 5612 function inDocument(element) { 5613 var p = element; 5614 var doc = wrap(document); 5615 while (p) { 5616 if (p == doc) { 5617 return true; 5618 } 5619 p = p.parentNode || p.host; 5620 } 5621 } 5622 function watchShadow(node) { 5623 if (node.shadowRoot && !node.shadowRoot.__watched) { 5624 flags.dom && console.log("watching shadow-root for: ", node.localName); 5625 var root = node.shadowRoot; 5626 while (root) { 5627 observe(root); 5628 root = root.olderShadowRoot; 5629 } 5630 } 5631 } 5632 function handler(mutations) { 5633 if (flags.dom) { 5634 var mx = mutations[0]; 5635 if (mx && mx.type === "childList" && mx.addedNodes) { 5636 if (mx.addedNodes) { 5637 var d = mx.addedNodes[0]; 5638 while (d && d !== document && !d.host) { 5639 d = d.parentNode; 5640 } 5641 var u = d && (d.URL || d._URL || d.host && d.host.localName) || ""; 5642 u = u.split("/?").shift().split("/").pop(); 5643 } 5644 } 5645 console.group("mutations (%d) [%s]", mutations.length, u || ""); 5646 } 5647 mutations.forEach(function(mx) { 5648 if (mx.type === "childList") { 5649 forEach(mx.addedNodes, function(n) { 5650 if (!n.localName) { 5651 return; 5652 } 5653 addedNode(n); 5654 }); 5655 forEach(mx.removedNodes, function(n) { 5656 if (!n.localName) { 5657 return; 5658 } 5659 detachedNode(n); 5660 }); 5661 } 5662 }); 5663 flags.dom && console.groupEnd(); 5664 } 5665 function takeRecords(node) { 5666 node = wrap(node); 5667 if (!node) { 5668 node = wrap(document); 5669 } 5670 while (node.parentNode) { 5671 node = node.parentNode; 5672 } 5673 var observer = node.__observer; 5674 if (observer) { 5675 handler(observer.takeRecords()); 5676 takeMutations(); 5677 } 5678 } 5679 var forEach = Array.prototype.forEach.call.bind(Array.prototype.forEach); 5680 function observe(inRoot) { 5681 if (inRoot.__observer) { 5682 return; 5683 } 5684 var observer = new MutationObserver(handler); 5685 observer.observe(inRoot, { 5686 childList: true, 5687 subtree: true 5688 }); 5689 inRoot.__observer = observer; 5690 } 5691 function upgradeDocument(doc) { 5692 doc = wrap(doc); 5693 flags.dom && console.group("upgradeDocument: ", doc.baseURI.split("/").pop()); 5694 addedNode(doc); 5695 observe(doc); 5696 flags.dom && console.groupEnd(); 5697 } 5698 function upgradeDocumentTree(doc) { 5699 forDocumentTree(doc, upgradeDocument); 5700 } 5701 var originalCreateShadowRoot = Element.prototype.createShadowRoot; 5702 if (originalCreateShadowRoot) { 5703 Element.prototype.createShadowRoot = function() { 5704 var root = originalCreateShadowRoot.call(this); 5705 CustomElements.watchShadow(this); 5706 return root; 5707 }; 5708 } 5709 scope.watchShadow = watchShadow; 5710 scope.upgradeDocumentTree = upgradeDocumentTree; 5711 scope.upgradeSubtree = addedSubtree; 5712 scope.upgradeAll = addedNode; 5713 scope.attachedNode = attachedNode; 5714 scope.takeRecords = takeRecords; 5715}); 5716 5717CustomElements.addModule(function(scope) { 5718 var flags = scope.flags; 5719 function upgrade(node) { 5720 if (!node.__upgraded__ && node.nodeType === Node.ELEMENT_NODE) { 5721 var is = node.getAttribute("is"); 5722 var definition = scope.getRegisteredDefinition(is || node.localName); 5723 if (definition) { 5724 if (is && definition.tag == node.localName) { 5725 return upgradeWithDefinition(node, definition); 5726 } else if (!is && !definition.extends) { 5727 return upgradeWithDefinition(node, definition); 5728 } 5729 } 5730 } 5731 } 5732 function upgradeWithDefinition(element, definition) { 5733 flags.upgrade && console.group("upgrade:", element.localName); 5734 if (definition.is) { 5735 element.setAttribute("is", definition.is); 5736 } 5737 implementPrototype(element, definition); 5738 element.__upgraded__ = true; 5739 created(element); 5740 scope.attachedNode(element); 5741 scope.upgradeSubtree(element); 5742 flags.upgrade && console.groupEnd(); 5743 return element; 5744 } 5745 function implementPrototype(element, definition) { 5746 if (Object.__proto__) { 5747 element.__proto__ = definition.prototype; 5748 } else { 5749 customMixin(element, definition.prototype, definition.native); 5750 element.__proto__ = definition.prototype; 5751 } 5752 } 5753 function customMixin(inTarget, inSrc, inNative) { 5754 var used = {}; 5755 var p = inSrc; 5756 while (p !== inNative && p !== HTMLElement.prototype) { 5757 var keys = Object.getOwnPropertyNames(p); 5758 for (var i = 0, k; k = keys[i]; i++) { 5759 if (!used[k]) { 5760 Object.defineProperty(inTarget, k, Object.getOwnPropertyDescriptor(p, k)); 5761 used[k] = 1; 5762 } 5763 } 5764 p = Object.getPrototypeOf(p); 5765 } 5766 } 5767 function created(element) { 5768 if (element.createdCallback) { 5769 element.createdCallback(); 5770 } 5771 } 5772 scope.upgrade = upgrade; 5773 scope.upgradeWithDefinition = upgradeWithDefinition; 5774 scope.implementPrototype = implementPrototype; 5775}); 5776 5777CustomElements.addModule(function(scope) { 5778 var upgradeDocumentTree = scope.upgradeDocumentTree; 5779 var upgrade = scope.upgrade; 5780 var upgradeWithDefinition = scope.upgradeWithDefinition; 5781 var implementPrototype = scope.implementPrototype; 5782 var useNative = scope.useNative; 5783 function register(name, options) { 5784 var definition = options || {}; 5785 if (!name) { 5786 throw new Error("document.registerElement: first argument `name` must not be empty"); 5787 } 5788 if (name.indexOf("-") < 0) { 5789 throw new Error("document.registerElement: first argument ('name') must contain a dash ('-'). Argument provided was '" + String(name) + "'."); 5790 } 5791 if (isReservedTag(name)) { 5792 throw new Error("Failed to execute 'registerElement' on 'Document': Registration failed for type '" + String(name) + "'. The type name is invalid."); 5793 } 5794 if (getRegisteredDefinition(name)) { 5795 throw new Error("DuplicateDefinitionError: a type with name '" + String(name) + "' is already registered"); 5796 } 5797 if (!definition.prototype) { 5798 definition.prototype = Object.create(HTMLElement.prototype); 5799 } 5800 definition.__name = name.toLowerCase(); 5801 definition.lifecycle = definition.lifecycle || {}; 5802 definition.ancestry = ancestry(definition.extends); 5803 resolveTagName(definition); 5804 resolvePrototypeChain(definition); 5805 overrideAttributeApi(definition.prototype); 5806 registerDefinition(definition.__name, definition); 5807 definition.ctor = generateConstructor(definition); 5808 definition.ctor.prototype = definition.prototype; 5809 definition.prototype.constructor = definition.ctor; 5810 if (scope.ready) { 5811 upgradeDocumentTree(document); 5812 } 5813 return definition.ctor; 5814 } 5815 function overrideAttributeApi(prototype) { 5816 if (prototype.setAttribute._polyfilled) { 5817 return; 5818 } 5819 var setAttribute = prototype.setAttribute; 5820 prototype.setAttribute = function(name, value) { 5821 changeAttribute.call(this, name, value, setAttribute); 5822 }; 5823 var removeAttribute = prototype.removeAttribute; 5824 prototype.removeAttribute = function(name) { 5825 changeAttribute.call(this, name, null, removeAttribute); 5826 }; 5827 prototype.setAttribute._polyfilled = true; 5828 } 5829 function changeAttribute(name, value, operation) { 5830 name = name.toLowerCase(); 5831 var oldValue = this.getAttribute(name); 5832 operation.apply(this, arguments); 5833 var newValue = this.getAttribute(name); 5834 if (this.attributeChangedCallback && newValue !== oldValue) { 5835 this.attributeChangedCallback(name, oldValue, newValue); 5836 } 5837 } 5838 function isReservedTag(name) { 5839 for (var i = 0; i < reservedTagList.length; i++) { 5840 if (name === reservedTagList[i]) { 5841 return true; 5842 } 5843 } 5844 } 5845 var reservedTagList = [ "annotation-xml", "color-profile", "font-face", "font-face-src", "font-face-uri", "font-face-format", "font-face-name", "missing-glyph" ]; 5846 function ancestry(extnds) { 5847 var extendee = getRegisteredDefinition(extnds); 5848 if (extendee) { 5849 return ancestry(extendee.extends).concat([ extendee ]); 5850 } 5851 return []; 5852 } 5853 function resolveTagName(definition) { 5854 var baseTag = definition.extends; 5855 for (var i = 0, a; a = definition.ancestry[i]; i++) { 5856 baseTag = a.is && a.tag; 5857 } 5858 definition.tag = baseTag || definition.__name; 5859 if (baseTag) { 5860 definition.is = definition.__name; 5861 } 5862 } 5863 function resolvePrototypeChain(definition) { 5864 if (!Object.__proto__) { 5865 var nativePrototype = HTMLElement.prototype; 5866 if (definition.is) { 5867 var inst = document.createElement(definition.tag); 5868 var expectedPrototype = Object.getPrototypeOf(inst); 5869 if (expectedPrototype === definition.prototype) { 5870 nativePrototype = expectedPrototype; 5871 } 5872 } 5873 var proto = definition.prototype, ancestor; 5874 while (proto && proto !== nativePrototype) { 5875 ancestor = Object.getPrototypeOf(proto); 5876 proto.__proto__ = ancestor; 5877 proto = ancestor; 5878 } 5879 definition.native = nativePrototype; 5880 } 5881 } 5882 function instantiate(definition) { 5883 return upgradeWithDefinition(domCreateElement(definition.tag), definition); 5884 } 5885 var registry = {}; 5886 function getRegisteredDefinition(name) { 5887 if (name) { 5888 return registry[name.toLowerCase()]; 5889 } 5890 } 5891 function registerDefinition(name, definition) { 5892 registry[name] = definition; 5893 } 5894 function generateConstructor(definition) { 5895 return function() { 5896 return instantiate(definition); 5897 }; 5898 } 5899 var HTML_NAMESPACE = "http://www.w3.org/1999/xhtml"; 5900 function createElementNS(namespace, tag, typeExtension) { 5901 if (namespace === HTML_NAMESPACE) { 5902 return createElement(tag, typeExtension); 5903 } else { 5904 return domCreateElementNS(namespace, tag); 5905 } 5906 } 5907 function createElement(tag, typeExtension) { 5908 var definition = getRegisteredDefinition(typeExtension || tag); 5909 if (definition) { 5910 if (tag == definition.tag && typeExtension == definition.is) { 5911 return new definition.ctor(); 5912 } 5913 if (!typeExtension && !definition.is) { 5914 return new definition.ctor(); 5915 } 5916 } 5917 var element; 5918 if (typeExtension) { 5919 element = createElement(tag); 5920 element.setAttribute("is", typeExtension); 5921 return element; 5922 } 5923 element = domCreateElement(tag); 5924 if (tag.indexOf("-") >= 0) { 5925 implementPrototype(element, HTMLElement); 5926 } 5927 return element; 5928 } 5929 function cloneNode(deep) { 5930 var n = domCloneNode.call(this, deep); 5931 upgrade(n); 5932 return n; 5933 } 5934 var domCreateElement = document.createElement.bind(document); 5935 var domCreateElementNS = document.createElementNS.bind(document); 5936 var domCloneNode = Node.prototype.cloneNode; 5937 var isInstance; 5938 if (!Object.__proto__ && !useNative) { 5939 isInstance = function(obj, ctor) { 5940 var p = obj; 5941 while (p) { 5942 if (p === ctor.prototype) { 5943 return true; 5944 } 5945 p = p.__proto__; 5946 } 5947 return false; 5948 }; 5949 } else { 5950 isInstance = function(obj, base) { 5951 return obj instanceof base; 5952 }; 5953 } 5954 document.registerElement = register; 5955 document.createElement = createElement; 5956 document.createElementNS = createElementNS; 5957 Node.prototype.cloneNode = cloneNode; 5958 scope.registry = registry; 5959 scope.instanceof = isInstance; 5960 scope.reservedTagList = reservedTagList; 5961 scope.getRegisteredDefinition = getRegisteredDefinition; 5962 document.register = document.registerElement; 5963}); 5964 5965(function(scope) { 5966 var useNative = scope.useNative; 5967 var initializeModules = scope.initializeModules; 5968 var isIE11OrOlder = /Trident/.test(navigator.userAgent); 5969 if (useNative) { 5970 var nop = function() {}; 5971 scope.watchShadow = nop; 5972 scope.upgrade = nop; 5973 scope.upgradeAll = nop; 5974 scope.upgradeDocumentTree = nop; 5975 scope.upgradeSubtree = nop; 5976 scope.takeRecords = nop; 5977 scope.instanceof = function(obj, base) { 5978 return obj instanceof base; 5979 }; 5980 } else { 5981 initializeModules(); 5982 } 5983 var upgradeDocumentTree = scope.upgradeDocumentTree; 5984 if (!window.wrap) { 5985 if (window.ShadowDOMPolyfill) { 5986 window.wrap = ShadowDOMPolyfill.wrapIfNeeded; 5987 window.unwrap = ShadowDOMPolyfill.unwrapIfNeeded; 5988 } else { 5989 window.wrap = window.unwrap = function(node) { 5990 return node; 5991 }; 5992 } 5993 } 5994 function bootstrap() { 5995 upgradeDocumentTree(wrap(document)); 5996 if (window.HTMLImports) { 5997 HTMLImports.__importsParsingHook = function(elt) { 5998 upgradeDocumentTree(wrap(elt.import)); 5999 }; 6000 } 6001 CustomElements.ready = true; 6002 setTimeout(function() { 6003 CustomElements.readyTime = Date.now(); 6004 if (window.HTMLImports) { 6005 CustomElements.elapsed = CustomElements.readyTime - HTMLImports.readyTime; 6006 } 6007 document.dispatchEvent(new CustomEvent("WebComponentsReady", { 6008 bubbles: true 6009 })); 6010 }); 6011 } 6012 if (isIE11OrOlder && typeof window.CustomEvent !== "function") { 6013 window.CustomEvent = function(inType, params) { 6014 params = params || {}; 6015 var e = document.createEvent("CustomEvent"); 6016 e.initCustomEvent(inType, Boolean(params.bubbles), Boolean(params.cancelable), params.detail); 6017 return e; 6018 }; 6019 window.CustomEvent.prototype = window.Event.prototype; 6020 } 6021 if (document.readyState === "complete" || scope.flags.eager) { 6022 bootstrap(); 6023 } else if (document.readyState === "interactive" && !window.attachEvent && (!window.HTMLImports || window.HTMLImports.ready)) { 6024 bootstrap(); 6025 } else { 6026 var loadEvent = window.HTMLImports && !HTMLImports.ready ? "HTMLImportsLoaded" : "DOMContentLoaded"; 6027 window.addEventListener(loadEvent, bootstrap); 6028 } 6029})(window.CustomElements); 6030 6031(function(scope) { 6032 if (!Function.prototype.bind) { 6033 Function.prototype.bind = function(scope) { 6034 var self = this; 6035 var args = Array.prototype.slice.call(arguments, 1); 6036 return function() { 6037 var args2 = args.slice(); 6038 args2.push.apply(args2, arguments); 6039 return self.apply(scope, args2); 6040 }; 6041 }; 6042 } 6043})(window.WebComponents); 6044 6045(function(scope) { 6046 "use strict"; 6047 if (!window.performance) { 6048 var start = Date.now(); 6049 window.performance = { 6050 now: function() { 6051 return Date.now() - start; 6052 } 6053 }; 6054 } 6055 if (!window.requestAnimationFrame) { 6056 window.requestAnimationFrame = function() { 6057 var nativeRaf = window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame; 6058 return nativeRaf ? function(callback) { 6059 return nativeRaf(function() { 6060 callback(performance.now()); 6061 }); 6062 } : function(callback) { 6063 return window.setTimeout(callback, 1e3 / 60); 6064 }; 6065 }(); 6066 } 6067 if (!window.cancelAnimationFrame) { 6068 window.cancelAnimationFrame = function() { 6069 return window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || function(id) { 6070 clearTimeout(id); 6071 }; 6072 }(); 6073 } 6074 var elementDeclarations = []; 6075 var polymerStub = function(name, dictionary) { 6076 if (typeof name !== "string" && arguments.length === 1) { 6077 Array.prototype.push.call(arguments, document._currentScript); 6078 } 6079 elementDeclarations.push(arguments); 6080 }; 6081 window.Polymer = polymerStub; 6082 scope.consumeDeclarations = function(callback) { 6083 scope.consumeDeclarations = function() { 6084 throw "Possible attempt to load Polymer twice"; 6085 }; 6086 if (callback) { 6087 callback(elementDeclarations); 6088 } 6089 elementDeclarations = null; 6090 }; 6091 function installPolymerWarning() { 6092 if (window.Polymer === polymerStub) { 6093 window.Polymer = function() { 6094 throw new Error("You tried to use polymer without loading it first. To " + 'load polymer, <link rel="import" href="' + 'components/polymer/polymer.html">'); 6095 }; 6096 } 6097 } 6098 if (HTMLImports.useNative) { 6099 installPolymerWarning(); 6100 } else { 6101 addEventListener("DOMContentLoaded", installPolymerWarning); 6102 } 6103})(window.WebComponents); 6104 6105(function(scope) { 6106 var style = document.createElement("style"); 6107 style.textContent = "" + "body {" + "transition: opacity ease-in 0.2s;" + " } \n" + "body[unresolved] {" + "opacity: 0; display: block; overflow: hidden; position: relative;" + " } \n"; 6108 var head = document.querySelector("head"); 6109 head.insertBefore(style, head.firstChild); 6110})(window.WebComponents); 6111 6112(function(scope) { 6113 window.Platform = scope; 6114})(window.WebComponents);