{"commit":{"authorEmail":"jsfb@github","shortRevision":"12059299f3","authoredAt":"2015-02-17T16:32:18-08:00","subject":"Added webcomponents.js and a simple unit test verifying a document fragment as a valid React container.","authorName":"Jim","revision":"12059299f32d6f8c1cfc359597e95939e5b7948f"},"body":"","parents":["73f4dc59d854fa6420b701868a31a4449de6f9f2"],"patch":"diff --git a\/src\/browser\/ui\/__tests__\/ReactMount-test.js b\/src\/browser\/ui\/__tests__\/ReactMount-test.js\nindex 3af0b535aa..fa4e3989df 100644\n--- a\/src\/browser\/ui\/__tests__\/ReactMount-test.js\n+++ b\/src\/browser\/ui\/__tests__\/ReactMount-test.js\n@@ -17,6 +17,13 @@ describe('ReactMount', function() {\n var React = require('React');\n var ReactMount = require('ReactMount');\n var ReactTestUtils = require('ReactTestUtils');\n+ var WebComponents = undefined;\n+\n+ try {\n+ WebComponents = require('WebComponents');\n+ } catch(e) {\n+ \/* leave WebComponents undefined *\/\n+ }\n \n describe('constructAndRenderComponentByID', function() {\n it('throws if given an id for a component that doesn\\'t exist', function() {\n@@ -157,4 +164,28 @@ describe('ReactMount', function() {\n 'Rendering components directly into document.body is discouraged'\n );\n });\n+\n+ (WebComponents === undefined ? xit : it)\n+ ('should allow mounting\/unmounting to document fragment container', function() {\n+ var shadowRoot;\n+ var proto = Object.create(HTMLElement.prototype, {\n+ createdCallback: {\n+ value: function() {\n+ var query = encodeURIComponent(this.innerHTML);\n+ var url = \"https:\/\/www.google.com\/search?q=\" + query + \"&btnI\";\n+ shadowRoot = this.createShadowRoot();\n+ React.render(

Hi, from within a WC!<\/div>, shadowRoot);\n+ expect(shadowRoot.firstChild.tagName).toBe('DIV')\n+ React.render(Hi, from within a WC!<\/span>, shadowRoot);\n+ expect(shadowRoot.firstChild.tagName).toBe('SPAN')\n+ }\n+ }\n+ });\n+ proto.unmount = function() {\n+ React.unmountComponentAtNode(shadowRoot);\n+ }\n+ document.registerElement('x-foo', {prototype: proto});\n+ var element = document.createElement('x-foo');\n+ element.unmount();\n+ });\n });\ndiff --git a\/src\/vendor\/third_party\/webcomponents.js b\/src\/vendor\/third_party\/webcomponents.js\nnew file mode 100755\nindex 0000000000..d114073e2d\n--- \/dev\/null\n+++ b\/src\/vendor\/third_party\/webcomponents.js\n@@ -0,0 +1,6377 @@\n+\/**\n+ * @license\n+ * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n+ * This code may only be used under the BSD style license found at http:\/\/polymer.github.io\/LICENSE.txt\n+ * The complete set of authors may be found at http:\/\/polymer.github.io\/AUTHORS.txt\n+ * The complete set of contributors may be found at http:\/\/polymer.github.io\/CONTRIBUTORS.txt\n+ * Code distributed by Google as part of the polymer project is also\n+ * subject to an additional IP rights grant found at http:\/\/polymer.github.io\/PATENTS.txt\n+ * @providesModule WebComponents\n+ *\/\n+\/\/ @version 0.5.1\n+window.WebComponents = window.WebComponents || {};\n+\n+(function(scope) {\n+ var flags = scope.flags || {};\n+ var file = \"webcomponents.js\";\n+ var script = document.querySelector('script[src*=\"' + file + '\"]');\n+ var flags = {};\n+ if (!flags.noOpts) {\n+ location.search.slice(1).split(\"&\").forEach(function(o) {\n+ o = o.split(\"=\");\n+ o[0] && (flags[o[0]] = o[1] || true);\n+ });\n+ if (script) {\n+ for (var i = 0, a; a = script.attributes[i]; i++) {\n+ if (a.name !== \"src\") {\n+ flags[a.name] = a.value || true;\n+ }\n+ }\n+ }\n+ if (flags.log) {\n+ var parts = flags.log.split(\",\");\n+ flags.log = {};\n+ parts.forEach(function(f) {\n+ flags.log[f] = true;\n+ });\n+ } else {\n+ flags.log = {};\n+ }\n+ }\n+ flags.shadow = flags.shadow || flags.shadowdom || flags.polyfill;\n+ if (flags.shadow === \"native\") {\n+ flags.shadow = false;\n+ } else {\n+ flags.shadow = flags.shadow || !HTMLElement.prototype.createShadowRoot;\n+ }\n+ if (flags.register) {\n+ window.CustomElements = window.CustomElements || {\n+ flags: {}\n+ };\n+ window.CustomElements.flags.register = flags.register;\n+ }\n+ scope.flags = flags;\n+})(WebComponents);\n+\n+if (WebComponents.flags.shadow) {\n+ if (typeof WeakMap === \"undefined\") {\n+ (function() {\n+ var defineProperty = Object.defineProperty;\n+ var counter = Date.now() % 1e9;\n+ var WeakMap = function() {\n+ this.name = \"__st\" + (Math.random() * 1e9 >>> 0) + (counter++ + \"__\");\n+ };\n+ WeakMap.prototype = {\n+ set: function(key, value) {\n+ var entry = key[this.name];\n+ if (entry && entry[0] === key) entry[1] = value; else defineProperty(key, this.name, {\n+ value: [ key, value ],\n+ writable: true\n+ });\n+ return this;\n+ },\n+ get: function(key) {\n+ var entry;\n+ return (entry = key[this.name]) && entry[0] === key ? entry[1] : undefined;\n+ },\n+ \"delete\": function(key) {\n+ var entry = key[this.name];\n+ if (!entry || entry[0] !== key) return false;\n+ entry[0] = entry[1] = undefined;\n+ return true;\n+ },\n+ has: function(key) {\n+ var entry = key[this.name];\n+ if (!entry) return false;\n+ return entry[0] === key;\n+ }\n+ };\n+ window.WeakMap = WeakMap;\n+ })();\n+ }\n+ window.ShadowDOMPolyfill = {};\n+ (function(scope) {\n+ \"use strict\";\n+ var constructorTable = new WeakMap();\n+ var nativePrototypeTable = new WeakMap();\n+ var wrappers = Object.create(null);\n+ function detectEval() {\n+ if (typeof chrome !== \"undefined\" && chrome.app && chrome.app.runtime) {\n+ return false;\n+ }\n+ if (navigator.getDeviceStorage) {\n+ return false;\n+ }\n+ try {\n+ var f = new Function(\"return true;\");\n+ return f();\n+ } catch (ex) {\n+ return false;\n+ }\n+ }\n+ var hasEval = detectEval();\n+ function assert(b) {\n+ if (!b) throw new Error(\"Assertion failed\");\n+ }\n+ var defineProperty = Object.defineProperty;\n+ var getOwnPropertyNames = Object.getOwnPropertyNames;\n+ var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n+ function mixin(to, from) {\n+ var names = getOwnPropertyNames(from);\n+ for (var i = 0; i < names.length; i++) {\n+ var name = names[i];\n+ defineProperty(to, name, getOwnPropertyDescriptor(from, name));\n+ }\n+ return to;\n+ }\n+ function mixinStatics(to, from) {\n+ var names = getOwnPropertyNames(from);\n+ for (var i = 0; i < names.length; i++) {\n+ var name = names[i];\n+ switch (name) {\n+ case \"arguments\":\n+ case \"caller\":\n+ case \"length\":\n+ case \"name\":\n+ case \"prototype\":\n+ case \"toString\":\n+ continue;\n+ }\n+ defineProperty(to, name, getOwnPropertyDescriptor(from, name));\n+ }\n+ return to;\n+ }\n+ function oneOf(object, propertyNames) {\n+ for (var i = 0; i < propertyNames.length; i++) {\n+ if (propertyNames[i] in object) return propertyNames[i];\n+ }\n+ }\n+ var nonEnumerableDataDescriptor = {\n+ value: undefined,\n+ configurable: true,\n+ enumerable: false,\n+ writable: true\n+ };\n+ function defineNonEnumerableDataProperty(object, name, value) {\n+ nonEnumerableDataDescriptor.value = value;\n+ defineProperty(object, name, nonEnumerableDataDescriptor);\n+ }\n+ getOwnPropertyNames(window);\n+ function getWrapperConstructor(node) {\n+ var nativePrototype = node.__proto__ || Object.getPrototypeOf(node);\n+ var wrapperConstructor = constructorTable.get(nativePrototype);\n+ if (wrapperConstructor) return wrapperConstructor;\n+ var parentWrapperConstructor = getWrapperConstructor(nativePrototype);\n+ var GeneratedWrapper = createWrapperConstructor(parentWrapperConstructor);\n+ registerInternal(nativePrototype, GeneratedWrapper, node);\n+ return GeneratedWrapper;\n+ }\n+ function addForwardingProperties(nativePrototype, wrapperPrototype) {\n+ installProperty(nativePrototype, wrapperPrototype, true);\n+ }\n+ function registerInstanceProperties(wrapperPrototype, instanceObject) {\n+ installProperty(instanceObject, wrapperPrototype, false);\n+ }\n+ var isFirefox = \/Firefox\/.test(navigator.userAgent);\n+ var dummyDescriptor = {\n+ get: function() {},\n+ set: function(v) {},\n+ configurable: true,\n+ enumerable: true\n+ };\n+ function isEventHandlerName(name) {\n+ return \/^on[a-z]+$\/.test(name);\n+ }\n+ function isIdentifierName(name) {\n+ return \/^\\w[a-zA-Z_0-9]*$\/.test(name);\n+ }\n+ function getGetter(name) {\n+ return hasEval && isIdentifierName(name) ? new Function(\"return this.__impl4cf1e782hg__.\" + name) : function() {\n+ return this.__impl4cf1e782hg__[name];\n+ };\n+ }\n+ function getSetter(name) {\n+ return hasEval && isIdentifierName(name) ? new Function(\"v\", \"this.__impl4cf1e782hg__.\" + name + \" = v\") : function(v) {\n+ this.__impl4cf1e782hg__[name] = v;\n+ };\n+ }\n+ function getMethod(name) {\n+ return hasEval && isIdentifierName(name) ? new Function(\"return this.__impl4cf1e782hg__.\" + name + \".apply(this.__impl4cf1e782hg__, arguments)\") : function() {\n+ return this.__impl4cf1e782hg__[name].apply(this.__impl4cf1e782hg__, arguments);\n+ };\n+ }\n+ function getDescriptor(source, name) {\n+ try {\n+ return Object.getOwnPropertyDescriptor(source, name);\n+ } catch (ex) {\n+ return dummyDescriptor;\n+ }\n+ }\n+ var isBrokenSafari = function() {\n+ var descr = Object.getOwnPropertyDescriptor(Node.prototype, \"nodeType\");\n+ return descr && !descr.get && !descr.set;\n+ }();\n+ function installProperty(source, target, allowMethod, opt_blacklist) {\n+ var names = getOwnPropertyNames(source);\n+ for (var i = 0; i < names.length; i++) {\n+ var name = names[i];\n+ if (name === \"polymerBlackList_\") continue;\n+ if (name in target) continue;\n+ if (source.polymerBlackList_ && source.polymerBlackList_[name]) continue;\n+ if (isFirefox) {\n+ source.__lookupGetter__(name);\n+ }\n+ var descriptor = getDescriptor(source, name);\n+ var getter, setter;\n+ if (allowMethod && typeof descriptor.value === \"function\") {\n+ target[name] = getMethod(name);\n+ continue;\n+ }\n+ var isEvent = isEventHandlerName(name);\n+ if (isEvent) getter = scope.getEventHandlerGetter(name); else getter = getGetter(name);\n+ if (descriptor.writable || descriptor.set || isBrokenSafari) {\n+ if (isEvent) setter = scope.getEventHandlerSetter(name); else setter = getSetter(name);\n+ }\n+ defineProperty(target, name, {\n+ get: getter,\n+ set: setter,\n+ configurable: descriptor.configurable,\n+ enumerable: descriptor.enumerable\n+ });\n+ }\n+ }\n+ function register(nativeConstructor, wrapperConstructor, opt_instance) {\n+ var nativePrototype = nativeConstructor.prototype;\n+ registerInternal(nativePrototype, wrapperConstructor, opt_instance);\n+ mixinStatics(wrapperConstructor, nativeConstructor);\n+ }\n+ function registerInternal(nativePrototype, wrapperConstructor, opt_instance) {\n+ var wrapperPrototype = wrapperConstructor.prototype;\n+ assert(constructorTable.get(nativePrototype) === undefined);\n+ constructorTable.set(nativePrototype, wrapperConstructor);\n+ nativePrototypeTable.set(wrapperPrototype, nativePrototype);\n+ addForwardingProperties(nativePrototype, wrapperPrototype);\n+ if (opt_instance) registerInstanceProperties(wrapperPrototype, opt_instance);\n+ defineNonEnumerableDataProperty(wrapperPrototype, \"constructor\", wrapperConstructor);\n+ wrapperConstructor.prototype = wrapperPrototype;\n+ }\n+ function isWrapperFor(wrapperConstructor, nativeConstructor) {\n+ return constructorTable.get(nativeConstructor.prototype) === wrapperConstructor;\n+ }\n+ function registerObject(object) {\n+ var nativePrototype = Object.getPrototypeOf(object);\n+ var superWrapperConstructor = getWrapperConstructor(nativePrototype);\n+ var GeneratedWrapper = createWrapperConstructor(superWrapperConstructor);\n+ registerInternal(nativePrototype, GeneratedWrapper, object);\n+ return GeneratedWrapper;\n+ }\n+ function createWrapperConstructor(superWrapperConstructor) {\n+ function GeneratedWrapper(node) {\n+ superWrapperConstructor.call(this, node);\n+ }\n+ var p = Object.create(superWrapperConstructor.prototype);\n+ p.constructor = GeneratedWrapper;\n+ GeneratedWrapper.prototype = p;\n+ return GeneratedWrapper;\n+ }\n+ function isWrapper(object) {\n+ return object && object.__impl4cf1e782hg__;\n+ }\n+ function isNative(object) {\n+ return !isWrapper(object);\n+ }\n+ function wrap(impl) {\n+ if (impl === null) return null;\n+ assert(isNative(impl));\n+ return impl.__wrapper8e3dd93a60__ || (impl.__wrapper8e3dd93a60__ = new (getWrapperConstructor(impl))(impl));\n+ }\n+ function unwrap(wrapper) {\n+ if (wrapper === null) return null;\n+ assert(isWrapper(wrapper));\n+ return wrapper.__impl4cf1e782hg__;\n+ }\n+ function unsafeUnwrap(wrapper) {\n+ return wrapper.__impl4cf1e782hg__;\n+ }\n+ function setWrapper(impl, wrapper) {\n+ wrapper.__impl4cf1e782hg__ = impl;\n+ impl.__wrapper8e3dd93a60__ = wrapper;\n+ }\n+ function unwrapIfNeeded(object) {\n+ return object && isWrapper(object) ? unwrap(object) : object;\n+ }\n+ function wrapIfNeeded(object) {\n+ return object && !isWrapper(object) ? wrap(object) : object;\n+ }\n+ function rewrap(node, wrapper) {\n+ if (wrapper === null) return;\n+ assert(isNative(node));\n+ assert(wrapper === undefined || isWrapper(wrapper));\n+ node.__wrapper8e3dd93a60__ = wrapper;\n+ }\n+ var getterDescriptor = {\n+ get: undefined,\n+ configurable: true,\n+ enumerable: true\n+ };\n+ function defineGetter(constructor, name, getter) {\n+ getterDescriptor.get = getter;\n+ defineProperty(constructor.prototype, name, getterDescriptor);\n+ }\n+ function defineWrapGetter(constructor, name) {\n+ defineGetter(constructor, name, function() {\n+ return wrap(this.__impl4cf1e782hg__[name]);\n+ });\n+ }\n+ function forwardMethodsToWrapper(constructors, names) {\n+ constructors.forEach(function(constructor) {\n+ names.forEach(function(name) {\n+ constructor.prototype[name] = function() {\n+ var w = wrapIfNeeded(this);\n+ return w[name].apply(w, arguments);\n+ };\n+ });\n+ });\n+ }\n+ scope.assert = assert;\n+ scope.constructorTable = constructorTable;\n+ scope.defineGetter = defineGetter;\n+ scope.defineWrapGetter = defineWrapGetter;\n+ scope.forwardMethodsToWrapper = forwardMethodsToWrapper;\n+ scope.isWrapper = isWrapper;\n+ scope.isWrapperFor = isWrapperFor;\n+ scope.mixin = mixin;\n+ scope.nativePrototypeTable = nativePrototypeTable;\n+ scope.oneOf = oneOf;\n+ scope.registerObject = registerObject;\n+ scope.registerWrapper = register;\n+ scope.rewrap = rewrap;\n+ scope.setWrapper = setWrapper;\n+ scope.unsafeUnwrap = unsafeUnwrap;\n+ scope.unwrap = unwrap;\n+ scope.unwrapIfNeeded = unwrapIfNeeded;\n+ scope.wrap = wrap;\n+ scope.wrapIfNeeded = wrapIfNeeded;\n+ scope.wrappers = wrappers;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ function newSplice(index, removed, addedCount) {\n+ return {\n+ index: index,\n+ removed: removed,\n+ addedCount: addedCount\n+ };\n+ }\n+ var EDIT_LEAVE = 0;\n+ var EDIT_UPDATE = 1;\n+ var EDIT_ADD = 2;\n+ var EDIT_DELETE = 3;\n+ function ArraySplice() {}\n+ ArraySplice.prototype = {\n+ calcEditDistances: function(current, currentStart, currentEnd, old, oldStart, oldEnd) {\n+ var rowCount = oldEnd - oldStart + 1;\n+ var columnCount = currentEnd - currentStart + 1;\n+ var distances = new Array(rowCount);\n+ for (var i = 0; i < rowCount; i++) {\n+ distances[i] = new Array(columnCount);\n+ distances[i][0] = i;\n+ }\n+ for (var j = 0; j < columnCount; j++) distances[0][j] = j;\n+ for (var i = 1; i < rowCount; i++) {\n+ for (var j = 1; j < columnCount; j++) {\n+ if (this.equals(current[currentStart + j - 1], old[oldStart + i - 1])) distances[i][j] = distances[i - 1][j - 1]; else {\n+ var north = distances[i - 1][j] + 1;\n+ var west = distances[i][j - 1] + 1;\n+ distances[i][j] = north < west ? north : west;\n+ }\n+ }\n+ }\n+ return distances;\n+ },\n+ spliceOperationsFromEditDistances: function(distances) {\n+ var i = distances.length - 1;\n+ var j = distances[0].length - 1;\n+ var current = distances[i][j];\n+ var edits = [];\n+ while (i > 0 || j > 0) {\n+ if (i == 0) {\n+ edits.push(EDIT_ADD);\n+ j--;\n+ continue;\n+ }\n+ if (j == 0) {\n+ edits.push(EDIT_DELETE);\n+ i--;\n+ continue;\n+ }\n+ var northWest = distances[i - 1][j - 1];\n+ var west = distances[i - 1][j];\n+ var north = distances[i][j - 1];\n+ var min;\n+ if (west < north) min = west < northWest ? west : northWest; else min = north < northWest ? north : northWest;\n+ if (min == northWest) {\n+ if (northWest == current) {\n+ edits.push(EDIT_LEAVE);\n+ } else {\n+ edits.push(EDIT_UPDATE);\n+ current = northWest;\n+ }\n+ i--;\n+ j--;\n+ } else if (min == west) {\n+ edits.push(EDIT_DELETE);\n+ i--;\n+ current = west;\n+ } else {\n+ edits.push(EDIT_ADD);\n+ j--;\n+ current = north;\n+ }\n+ }\n+ edits.reverse();\n+ return edits;\n+ },\n+ calcSplices: function(current, currentStart, currentEnd, old, oldStart, oldEnd) {\n+ var prefixCount = 0;\n+ var suffixCount = 0;\n+ var minLength = Math.min(currentEnd - currentStart, oldEnd - oldStart);\n+ if (currentStart == 0 && oldStart == 0) prefixCount = this.sharedPrefix(current, old, minLength);\n+ if (currentEnd == current.length && oldEnd == old.length) suffixCount = this.sharedSuffix(current, old, minLength - prefixCount);\n+ currentStart += prefixCount;\n+ oldStart += prefixCount;\n+ currentEnd -= suffixCount;\n+ oldEnd -= suffixCount;\n+ if (currentEnd - currentStart == 0 && oldEnd - oldStart == 0) return [];\n+ if (currentStart == currentEnd) {\n+ var splice = newSplice(currentStart, [], 0);\n+ while (oldStart < oldEnd) splice.removed.push(old[oldStart++]);\n+ return [ splice ];\n+ } else if (oldStart == oldEnd) return [ newSplice(currentStart, [], currentEnd - currentStart) ];\n+ var ops = this.spliceOperationsFromEditDistances(this.calcEditDistances(current, currentStart, currentEnd, old, oldStart, oldEnd));\n+ var splice = undefined;\n+ var splices = [];\n+ var index = currentStart;\n+ var oldIndex = oldStart;\n+ for (var i = 0; i < ops.length; i++) {\n+ switch (ops[i]) {\n+ case EDIT_LEAVE:\n+ if (splice) {\n+ splices.push(splice);\n+ splice = undefined;\n+ }\n+ index++;\n+ oldIndex++;\n+ break;\n+\n+ case EDIT_UPDATE:\n+ if (!splice) splice = newSplice(index, [], 0);\n+ splice.addedCount++;\n+ index++;\n+ splice.removed.push(old[oldIndex]);\n+ oldIndex++;\n+ break;\n+\n+ case EDIT_ADD:\n+ if (!splice) splice = newSplice(index, [], 0);\n+ splice.addedCount++;\n+ index++;\n+ break;\n+\n+ case EDIT_DELETE:\n+ if (!splice) splice = newSplice(index, [], 0);\n+ splice.removed.push(old[oldIndex]);\n+ oldIndex++;\n+ break;\n+ }\n+ }\n+ if (splice) {\n+ splices.push(splice);\n+ }\n+ return splices;\n+ },\n+ sharedPrefix: function(current, old, searchLength) {\n+ for (var i = 0; i < searchLength; i++) if (!this.equals(current[i], old[i])) return i;\n+ return searchLength;\n+ },\n+ sharedSuffix: function(current, old, searchLength) {\n+ var index1 = current.length;\n+ var index2 = old.length;\n+ var count = 0;\n+ while (count < searchLength && this.equals(current[--index1], old[--index2])) count++;\n+ return count;\n+ },\n+ calculateSplices: function(current, previous) {\n+ return this.calcSplices(current, 0, current.length, previous, 0, previous.length);\n+ },\n+ equals: function(currentValue, previousValue) {\n+ return currentValue === previousValue;\n+ }\n+ };\n+ scope.ArraySplice = ArraySplice;\n+ })(window.ShadowDOMPolyfill);\n+ (function(context) {\n+ \"use strict\";\n+ var OriginalMutationObserver = window.MutationObserver;\n+ var callbacks = [];\n+ var pending = false;\n+ var timerFunc;\n+ function handle() {\n+ pending = false;\n+ var copies = callbacks.slice(0);\n+ callbacks = [];\n+ for (var i = 0; i < copies.length; i++) {\n+ (0, copies[i])();\n+ }\n+ }\n+ if (OriginalMutationObserver) {\n+ var counter = 1;\n+ var observer = new OriginalMutationObserver(handle);\n+ var textNode = document.createTextNode(counter);\n+ observer.observe(textNode, {\n+ characterData: true\n+ });\n+ timerFunc = function() {\n+ counter = (counter + 1) % 2;\n+ textNode.data = counter;\n+ };\n+ } else {\n+ timerFunc = window.setTimeout;\n+ }\n+ function setEndOfMicrotask(func) {\n+ callbacks.push(func);\n+ if (pending) return;\n+ pending = true;\n+ timerFunc(handle, 0);\n+ }\n+ context.setEndOfMicrotask = setEndOfMicrotask;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var setEndOfMicrotask = scope.setEndOfMicrotask;\n+ var wrapIfNeeded = scope.wrapIfNeeded;\n+ var wrappers = scope.wrappers;\n+ var registrationsTable = new WeakMap();\n+ var globalMutationObservers = [];\n+ var isScheduled = false;\n+ function scheduleCallback(observer) {\n+ if (observer.scheduled_) return;\n+ observer.scheduled_ = true;\n+ globalMutationObservers.push(observer);\n+ if (isScheduled) return;\n+ setEndOfMicrotask(notifyObservers);\n+ isScheduled = true;\n+ }\n+ function notifyObservers() {\n+ isScheduled = false;\n+ while (globalMutationObservers.length) {\n+ var notifyList = globalMutationObservers;\n+ globalMutationObservers = [];\n+ notifyList.sort(function(x, y) {\n+ return x.uid_ - y.uid_;\n+ });\n+ for (var i = 0; i < notifyList.length; i++) {\n+ var mo = notifyList[i];\n+ mo.scheduled_ = false;\n+ var queue = mo.takeRecords();\n+ removeTransientObserversFor(mo);\n+ if (queue.length) {\n+ mo.callback_(queue, mo);\n+ }\n+ }\n+ }\n+ }\n+ function MutationRecord(type, target) {\n+ this.type = type;\n+ this.target = target;\n+ this.addedNodes = new wrappers.NodeList();\n+ this.removedNodes = new wrappers.NodeList();\n+ this.previousSibling = null;\n+ this.nextSibling = null;\n+ this.attributeName = null;\n+ this.attributeNamespace = null;\n+ this.oldValue = null;\n+ }\n+ function registerTransientObservers(ancestor, node) {\n+ for (;ancestor; ancestor = ancestor.parentNode) {\n+ var registrations = registrationsTable.get(ancestor);\n+ if (!registrations) continue;\n+ for (var i = 0; i < registrations.length; i++) {\n+ var registration = registrations[i];\n+ if (registration.options.subtree) registration.addTransientObserver(node);\n+ }\n+ }\n+ }\n+ function removeTransientObserversFor(observer) {\n+ for (var i = 0; i < observer.nodes_.length; i++) {\n+ var node = observer.nodes_[i];\n+ var registrations = registrationsTable.get(node);\n+ if (!registrations) return;\n+ for (var j = 0; j < registrations.length; j++) {\n+ var registration = registrations[j];\n+ if (registration.observer === observer) registration.removeTransientObservers();\n+ }\n+ }\n+ }\n+ function enqueueMutation(target, type, data) {\n+ var interestedObservers = Object.create(null);\n+ var associatedStrings = Object.create(null);\n+ for (var node = target; node; node = node.parentNode) {\n+ var registrations = registrationsTable.get(node);\n+ if (!registrations) continue;\n+ for (var j = 0; j < registrations.length; j++) {\n+ var registration = registrations[j];\n+ var options = registration.options;\n+ if (node !== target && !options.subtree) continue;\n+ if (type === \"attributes\" && !options.attributes) continue;\n+ if (type === \"attributes\" && options.attributeFilter && (data.namespace !== null || options.attributeFilter.indexOf(data.name) === -1)) {\n+ continue;\n+ }\n+ if (type === \"characterData\" && !options.characterData) continue;\n+ if (type === \"childList\" && !options.childList) continue;\n+ var observer = registration.observer;\n+ interestedObservers[observer.uid_] = observer;\n+ if (type === \"attributes\" && options.attributeOldValue || type === \"characterData\" && options.characterDataOldValue) {\n+ associatedStrings[observer.uid_] = data.oldValue;\n+ }\n+ }\n+ }\n+ for (var uid in interestedObservers) {\n+ var observer = interestedObservers[uid];\n+ var record = new MutationRecord(type, target);\n+ if (\"name\" in data && \"namespace\" in data) {\n+ record.attributeName = data.name;\n+ record.attributeNamespace = data.namespace;\n+ }\n+ if (data.addedNodes) record.addedNodes = data.addedNodes;\n+ if (data.removedNodes) record.removedNodes = data.removedNodes;\n+ if (data.previousSibling) record.previousSibling = data.previousSibling;\n+ if (data.nextSibling) record.nextSibling = data.nextSibling;\n+ if (associatedStrings[uid] !== undefined) record.oldValue = associatedStrings[uid];\n+ scheduleCallback(observer);\n+ observer.records_.push(record);\n+ }\n+ }\n+ var slice = Array.prototype.slice;\n+ function MutationObserverOptions(options) {\n+ this.childList = !!options.childList;\n+ this.subtree = !!options.subtree;\n+ if (!(\"attributes\" in options) && (\"attributeOldValue\" in options || \"attributeFilter\" in options)) {\n+ this.attributes = true;\n+ } else {\n+ this.attributes = !!options.attributes;\n+ }\n+ if (\"characterDataOldValue\" in options && !(\"characterData\" in options)) this.characterData = true; else this.characterData = !!options.characterData;\n+ if (!this.attributes && (options.attributeOldValue || \"attributeFilter\" in options) || !this.characterData && options.characterDataOldValue) {\n+ throw new TypeError();\n+ }\n+ this.characterData = !!options.characterData;\n+ this.attributeOldValue = !!options.attributeOldValue;\n+ this.characterDataOldValue = !!options.characterDataOldValue;\n+ if (\"attributeFilter\" in options) {\n+ if (options.attributeFilter == null || typeof options.attributeFilter !== \"object\") {\n+ throw new TypeError();\n+ }\n+ this.attributeFilter = slice.call(options.attributeFilter);\n+ } else {\n+ this.attributeFilter = null;\n+ }\n+ }\n+ var uidCounter = 0;\n+ function MutationObserver(callback) {\n+ this.callback_ = callback;\n+ this.nodes_ = [];\n+ this.records_ = [];\n+ this.uid_ = ++uidCounter;\n+ this.scheduled_ = false;\n+ }\n+ MutationObserver.prototype = {\n+ constructor: MutationObserver,\n+ observe: function(target, options) {\n+ target = wrapIfNeeded(target);\n+ var newOptions = new MutationObserverOptions(options);\n+ var registration;\n+ var registrations = registrationsTable.get(target);\n+ if (!registrations) registrationsTable.set(target, registrations = []);\n+ for (var i = 0; i < registrations.length; i++) {\n+ if (registrations[i].observer === this) {\n+ registration = registrations[i];\n+ registration.removeTransientObservers();\n+ registration.options = newOptions;\n+ }\n+ }\n+ if (!registration) {\n+ registration = new Registration(this, target, newOptions);\n+ registrations.push(registration);\n+ this.nodes_.push(target);\n+ }\n+ },\n+ disconnect: function() {\n+ this.nodes_.forEach(function(node) {\n+ var registrations = registrationsTable.get(node);\n+ for (var i = 0; i < registrations.length; i++) {\n+ var registration = registrations[i];\n+ if (registration.observer === this) {\n+ registrations.splice(i, 1);\n+ break;\n+ }\n+ }\n+ }, this);\n+ this.records_ = [];\n+ },\n+ takeRecords: function() {\n+ var copyOfRecords = this.records_;\n+ this.records_ = [];\n+ return copyOfRecords;\n+ }\n+ };\n+ function Registration(observer, target, options) {\n+ this.observer = observer;\n+ this.target = target;\n+ this.options = options;\n+ this.transientObservedNodes = [];\n+ }\n+ Registration.prototype = {\n+ addTransientObserver: function(node) {\n+ if (node === this.target) return;\n+ scheduleCallback(this.observer);\n+ this.transientObservedNodes.push(node);\n+ var registrations = registrationsTable.get(node);\n+ if (!registrations) registrationsTable.set(node, registrations = []);\n+ registrations.push(this);\n+ },\n+ removeTransientObservers: function() {\n+ var transientObservedNodes = this.transientObservedNodes;\n+ this.transientObservedNodes = [];\n+ for (var i = 0; i < transientObservedNodes.length; i++) {\n+ var node = transientObservedNodes[i];\n+ var registrations = registrationsTable.get(node);\n+ for (var j = 0; j < registrations.length; j++) {\n+ if (registrations[j] === this) {\n+ registrations.splice(j, 1);\n+ break;\n+ }\n+ }\n+ }\n+ }\n+ };\n+ scope.enqueueMutation = enqueueMutation;\n+ scope.registerTransientObservers = registerTransientObservers;\n+ scope.wrappers.MutationObserver = MutationObserver;\n+ scope.wrappers.MutationRecord = MutationRecord;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ function TreeScope(root, parent) {\n+ this.root = root;\n+ this.parent = parent;\n+ }\n+ TreeScope.prototype = {\n+ get renderer() {\n+ if (this.root instanceof scope.wrappers.ShadowRoot) {\n+ return scope.getRendererForHost(this.root.host);\n+ }\n+ return null;\n+ },\n+ contains: function(treeScope) {\n+ for (;treeScope; treeScope = treeScope.parent) {\n+ if (treeScope === this) return true;\n+ }\n+ return false;\n+ }\n+ };\n+ function setTreeScope(node, treeScope) {\n+ if (node.treeScope_ !== treeScope) {\n+ node.treeScope_ = treeScope;\n+ for (var sr = node.shadowRoot; sr; sr = sr.olderShadowRoot) {\n+ sr.treeScope_.parent = treeScope;\n+ }\n+ for (var child = node.firstChild; child; child = child.nextSibling) {\n+ setTreeScope(child, treeScope);\n+ }\n+ }\n+ }\n+ function getTreeScope(node) {\n+ if (node instanceof scope.wrappers.Window) {\n+ debugger;\n+ }\n+ if (node.treeScope_) return node.treeScope_;\n+ var parent = node.parentNode;\n+ var treeScope;\n+ if (parent) treeScope = getTreeScope(parent); else treeScope = new TreeScope(node, null);\n+ return node.treeScope_ = treeScope;\n+ }\n+ scope.TreeScope = TreeScope;\n+ scope.getTreeScope = getTreeScope;\n+ scope.setTreeScope = setTreeScope;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var forwardMethodsToWrapper = scope.forwardMethodsToWrapper;\n+ var getTreeScope = scope.getTreeScope;\n+ var mixin = scope.mixin;\n+ var registerWrapper = scope.registerWrapper;\n+ var setWrapper = scope.setWrapper;\n+ var unsafeUnwrap = scope.unsafeUnwrap;\n+ var unwrap = scope.unwrap;\n+ var wrap = scope.wrap;\n+ var wrappers = scope.wrappers;\n+ var wrappedFuns = new WeakMap();\n+ var listenersTable = new WeakMap();\n+ var handledEventsTable = new WeakMap();\n+ var currentlyDispatchingEvents = new WeakMap();\n+ var targetTable = new WeakMap();\n+ var currentTargetTable = new WeakMap();\n+ var relatedTargetTable = new WeakMap();\n+ var eventPhaseTable = new WeakMap();\n+ var stopPropagationTable = new WeakMap();\n+ var stopImmediatePropagationTable = new WeakMap();\n+ var eventHandlersTable = new WeakMap();\n+ var eventPathTable = new WeakMap();\n+ function isShadowRoot(node) {\n+ return node instanceof wrappers.ShadowRoot;\n+ }\n+ function rootOfNode(node) {\n+ return getTreeScope(node).root;\n+ }\n+ function getEventPath(node, event) {\n+ var path = [];\n+ var current = node;\n+ path.push(current);\n+ while (current) {\n+ var destinationInsertionPoints = getDestinationInsertionPoints(current);\n+ if (destinationInsertionPoints && destinationInsertionPoints.length > 0) {\n+ for (var i = 0; i < destinationInsertionPoints.length; i++) {\n+ var insertionPoint = destinationInsertionPoints[i];\n+ if (isShadowInsertionPoint(insertionPoint)) {\n+ var shadowRoot = rootOfNode(insertionPoint);\n+ var olderShadowRoot = shadowRoot.olderShadowRoot;\n+ if (olderShadowRoot) path.push(olderShadowRoot);\n+ }\n+ path.push(insertionPoint);\n+ }\n+ current = destinationInsertionPoints[destinationInsertionPoints.length - 1];\n+ } else {\n+ if (isShadowRoot(current)) {\n+ if (inSameTree(node, current) && eventMustBeStopped(event)) {\n+ break;\n+ }\n+ current = current.host;\n+ path.push(current);\n+ } else {\n+ current = current.parentNode;\n+ if (current) path.push(current);\n+ }\n+ }\n+ }\n+ return path;\n+ }\n+ function eventMustBeStopped(event) {\n+ if (!event) return false;\n+ switch (event.type) {\n+ case \"abort\":\n+ case \"error\":\n+ case \"select\":\n+ case \"change\":\n+ case \"load\":\n+ case \"reset\":\n+ case \"resize\":\n+ case \"scroll\":\n+ case \"selectstart\":\n+ return true;\n+ }\n+ return false;\n+ }\n+ function isShadowInsertionPoint(node) {\n+ return node instanceof HTMLShadowElement;\n+ }\n+ function getDestinationInsertionPoints(node) {\n+ return scope.getDestinationInsertionPoints(node);\n+ }\n+ function eventRetargetting(path, currentTarget) {\n+ if (path.length === 0) return currentTarget;\n+ if (currentTarget instanceof wrappers.Window) currentTarget = currentTarget.document;\n+ var currentTargetTree = getTreeScope(currentTarget);\n+ var originalTarget = path[0];\n+ var originalTargetTree = getTreeScope(originalTarget);\n+ var relativeTargetTree = lowestCommonInclusiveAncestor(currentTargetTree, originalTargetTree);\n+ for (var i = 0; i < path.length; i++) {\n+ var node = path[i];\n+ if (getTreeScope(node) === relativeTargetTree) return node;\n+ }\n+ return path[path.length - 1];\n+ }\n+ function getTreeScopeAncestors(treeScope) {\n+ var ancestors = [];\n+ for (;treeScope; treeScope = treeScope.parent) {\n+ ancestors.push(treeScope);\n+ }\n+ return ancestors;\n+ }\n+ function lowestCommonInclusiveAncestor(tsA, tsB) {\n+ var ancestorsA = getTreeScopeAncestors(tsA);\n+ var ancestorsB = getTreeScopeAncestors(tsB);\n+ var result = null;\n+ while (ancestorsA.length > 0 && ancestorsB.length > 0) {\n+ var a = ancestorsA.pop();\n+ var b = ancestorsB.pop();\n+ if (a === b) result = a; else break;\n+ }\n+ return result;\n+ }\n+ function getTreeScopeRoot(ts) {\n+ if (!ts.parent) return ts;\n+ return getTreeScopeRoot(ts.parent);\n+ }\n+ function relatedTargetResolution(event, currentTarget, relatedTarget) {\n+ if (currentTarget instanceof wrappers.Window) currentTarget = currentTarget.document;\n+ var currentTargetTree = getTreeScope(currentTarget);\n+ var relatedTargetTree = getTreeScope(relatedTarget);\n+ var relatedTargetEventPath = getEventPath(relatedTarget, event);\n+ var lowestCommonAncestorTree;\n+ var lowestCommonAncestorTree = lowestCommonInclusiveAncestor(currentTargetTree, relatedTargetTree);\n+ if (!lowestCommonAncestorTree) lowestCommonAncestorTree = relatedTargetTree.root;\n+ for (var commonAncestorTree = lowestCommonAncestorTree; commonAncestorTree; commonAncestorTree = commonAncestorTree.parent) {\n+ var adjustedRelatedTarget;\n+ for (var i = 0; i < relatedTargetEventPath.length; i++) {\n+ var node = relatedTargetEventPath[i];\n+ if (getTreeScope(node) === commonAncestorTree) return node;\n+ }\n+ }\n+ return null;\n+ }\n+ function inSameTree(a, b) {\n+ return getTreeScope(a) === getTreeScope(b);\n+ }\n+ var NONE = 0;\n+ var CAPTURING_PHASE = 1;\n+ var AT_TARGET = 2;\n+ var BUBBLING_PHASE = 3;\n+ var pendingError;\n+ function dispatchOriginalEvent(originalEvent) {\n+ if (handledEventsTable.get(originalEvent)) return;\n+ handledEventsTable.set(originalEvent, true);\n+ dispatchEvent(wrap(originalEvent), wrap(originalEvent.target));\n+ if (pendingError) {\n+ var err = pendingError;\n+ pendingError = null;\n+ throw err;\n+ }\n+ }\n+ function isLoadLikeEvent(event) {\n+ switch (event.type) {\n+ case \"load\":\n+ case \"beforeunload\":\n+ case \"unload\":\n+ return true;\n+ }\n+ return false;\n+ }\n+ function dispatchEvent(event, originalWrapperTarget) {\n+ if (currentlyDispatchingEvents.get(event)) throw new Error(\"InvalidStateError\");\n+ currentlyDispatchingEvents.set(event, true);\n+ scope.renderAllPending();\n+ var eventPath;\n+ var overrideTarget;\n+ var win;\n+ if (isLoadLikeEvent(event) && !event.bubbles) {\n+ var doc = originalWrapperTarget;\n+ if (doc instanceof wrappers.Document && (win = doc.defaultView)) {\n+ overrideTarget = doc;\n+ eventPath = [];\n+ }\n+ }\n+ if (!eventPath) {\n+ if (originalWrapperTarget instanceof wrappers.Window) {\n+ win = originalWrapperTarget;\n+ eventPath = [];\n+ } else {\n+ eventPath = getEventPath(originalWrapperTarget, event);\n+ if (!isLoadLikeEvent(event)) {\n+ var doc = eventPath[eventPath.length - 1];\n+ if (doc instanceof wrappers.Document) win = doc.defaultView;\n+ }\n+ }\n+ }\n+ eventPathTable.set(event, eventPath);\n+ if (dispatchCapturing(event, eventPath, win, overrideTarget)) {\n+ if (dispatchAtTarget(event, eventPath, win, overrideTarget)) {\n+ dispatchBubbling(event, eventPath, win, overrideTarget);\n+ }\n+ }\n+ eventPhaseTable.set(event, NONE);\n+ currentTargetTable.delete(event, null);\n+ currentlyDispatchingEvents.delete(event);\n+ return event.defaultPrevented;\n+ }\n+ function dispatchCapturing(event, eventPath, win, overrideTarget) {\n+ var phase = CAPTURING_PHASE;\n+ if (win) {\n+ if (!invoke(win, event, phase, eventPath, overrideTarget)) return false;\n+ }\n+ for (var i = eventPath.length - 1; i > 0; i--) {\n+ if (!invoke(eventPath[i], event, phase, eventPath, overrideTarget)) return false;\n+ }\n+ return true;\n+ }\n+ function dispatchAtTarget(event, eventPath, win, overrideTarget) {\n+ var phase = AT_TARGET;\n+ var currentTarget = eventPath[0] || win;\n+ return invoke(currentTarget, event, phase, eventPath, overrideTarget);\n+ }\n+ function dispatchBubbling(event, eventPath, win, overrideTarget) {\n+ var phase = BUBBLING_PHASE;\n+ for (var i = 1; i < eventPath.length; i++) {\n+ if (!invoke(eventPath[i], event, phase, eventPath, overrideTarget)) return;\n+ }\n+ if (win && eventPath.length > 0) {\n+ invoke(win, event, phase, eventPath, overrideTarget);\n+ }\n+ }\n+ function invoke(currentTarget, event, phase, eventPath, overrideTarget) {\n+ var listeners = listenersTable.get(currentTarget);\n+ if (!listeners) return true;\n+ var target = overrideTarget || eventRetargetting(eventPath, currentTarget);\n+ if (target === currentTarget) {\n+ if (phase === CAPTURING_PHASE) return true;\n+ if (phase === BUBBLING_PHASE) phase = AT_TARGET;\n+ } else if (phase === BUBBLING_PHASE && !event.bubbles) {\n+ return true;\n+ }\n+ if (\"relatedTarget\" in event) {\n+ var originalEvent = unwrap(event);\n+ var unwrappedRelatedTarget = originalEvent.relatedTarget;\n+ if (unwrappedRelatedTarget) {\n+ if (unwrappedRelatedTarget instanceof Object && unwrappedRelatedTarget.addEventListener) {\n+ var relatedTarget = wrap(unwrappedRelatedTarget);\n+ var adjusted = relatedTargetResolution(event, currentTarget, relatedTarget);\n+ if (adjusted === target) return true;\n+ } else {\n+ adjusted = null;\n+ }\n+ relatedTargetTable.set(event, adjusted);\n+ }\n+ }\n+ eventPhaseTable.set(event, phase);\n+ var type = event.type;\n+ var anyRemoved = false;\n+ targetTable.set(event, target);\n+ currentTargetTable.set(event, currentTarget);\n+ listeners.depth++;\n+ for (var i = 0, len = listeners.length; i < len; i++) {\n+ var listener = listeners[i];\n+ if (listener.removed) {\n+ anyRemoved = true;\n+ continue;\n+ }\n+ if (listener.type !== type || !listener.capture && phase === CAPTURING_PHASE || listener.capture && phase === BUBBLING_PHASE) {\n+ continue;\n+ }\n+ try {\n+ if (typeof listener.handler === \"function\") listener.handler.call(currentTarget, event); else listener.handler.handleEvent(event);\n+ if (stopImmediatePropagationTable.get(event)) return false;\n+ } catch (ex) {\n+ if (!pendingError) pendingError = ex;\n+ }\n+ }\n+ listeners.depth--;\n+ if (anyRemoved && listeners.depth === 0) {\n+ var copy = listeners.slice();\n+ listeners.length = 0;\n+ for (var i = 0; i < copy.length; i++) {\n+ if (!copy[i].removed) listeners.push(copy[i]);\n+ }\n+ }\n+ return !stopPropagationTable.get(event);\n+ }\n+ function Listener(type, handler, capture) {\n+ this.type = type;\n+ this.handler = handler;\n+ this.capture = Boolean(capture);\n+ }\n+ Listener.prototype = {\n+ equals: function(that) {\n+ return this.handler === that.handler && this.type === that.type && this.capture === that.capture;\n+ },\n+ get removed() {\n+ return this.handler === null;\n+ },\n+ remove: function() {\n+ this.handler = null;\n+ }\n+ };\n+ var OriginalEvent = window.Event;\n+ OriginalEvent.prototype.polymerBlackList_ = {\n+ returnValue: true,\n+ keyLocation: true\n+ };\n+ function Event(type, options) {\n+ if (type instanceof OriginalEvent) {\n+ var impl = type;\n+ if (!OriginalBeforeUnloadEvent && impl.type === \"beforeunload\" && !(this instanceof BeforeUnloadEvent)) {\n+ return new BeforeUnloadEvent(impl);\n+ }\n+ setWrapper(impl, this);\n+ } else {\n+ return wrap(constructEvent(OriginalEvent, \"Event\", type, options));\n+ }\n+ }\n+ Event.prototype = {\n+ get target() {\n+ return targetTable.get(this);\n+ },\n+ get currentTarget() {\n+ return currentTargetTable.get(this);\n+ },\n+ get eventPhase() {\n+ return eventPhaseTable.get(this);\n+ },\n+ get path() {\n+ var eventPath = eventPathTable.get(this);\n+ if (!eventPath) return [];\n+ return eventPath.slice();\n+ },\n+ stopPropagation: function() {\n+ stopPropagationTable.set(this, true);\n+ },\n+ stopImmediatePropagation: function() {\n+ stopPropagationTable.set(this, true);\n+ stopImmediatePropagationTable.set(this, true);\n+ }\n+ };\n+ registerWrapper(OriginalEvent, Event, document.createEvent(\"Event\"));\n+ function unwrapOptions(options) {\n+ if (!options || !options.relatedTarget) return options;\n+ return Object.create(options, {\n+ relatedTarget: {\n+ value: unwrap(options.relatedTarget)\n+ }\n+ });\n+ }\n+ function registerGenericEvent(name, SuperEvent, prototype) {\n+ var OriginalEvent = window[name];\n+ var GenericEvent = function(type, options) {\n+ if (type instanceof OriginalEvent) setWrapper(type, this); else return wrap(constructEvent(OriginalEvent, name, type, options));\n+ };\n+ GenericEvent.prototype = Object.create(SuperEvent.prototype);\n+ if (prototype) mixin(GenericEvent.prototype, prototype);\n+ if (OriginalEvent) {\n+ try {\n+ registerWrapper(OriginalEvent, GenericEvent, new OriginalEvent(\"temp\"));\n+ } catch (ex) {\n+ registerWrapper(OriginalEvent, GenericEvent, document.createEvent(name));\n+ }\n+ }\n+ return GenericEvent;\n+ }\n+ var UIEvent = registerGenericEvent(\"UIEvent\", Event);\n+ var CustomEvent = registerGenericEvent(\"CustomEvent\", Event);\n+ var relatedTargetProto = {\n+ get relatedTarget() {\n+ var relatedTarget = relatedTargetTable.get(this);\n+ if (relatedTarget !== undefined) return relatedTarget;\n+ return wrap(unwrap(this).relatedTarget);\n+ }\n+ };\n+ function getInitFunction(name, relatedTargetIndex) {\n+ return function() {\n+ arguments[relatedTargetIndex] = unwrap(arguments[relatedTargetIndex]);\n+ var impl = unwrap(this);\n+ impl[name].apply(impl, arguments);\n+ };\n+ }\n+ var mouseEventProto = mixin({\n+ initMouseEvent: getInitFunction(\"initMouseEvent\", 14)\n+ }, relatedTargetProto);\n+ var focusEventProto = mixin({\n+ initFocusEvent: getInitFunction(\"initFocusEvent\", 5)\n+ }, relatedTargetProto);\n+ var MouseEvent = registerGenericEvent(\"MouseEvent\", UIEvent, mouseEventProto);\n+ var FocusEvent = registerGenericEvent(\"FocusEvent\", UIEvent, focusEventProto);\n+ var defaultInitDicts = Object.create(null);\n+ var supportsEventConstructors = function() {\n+ try {\n+ new window.FocusEvent(\"focus\");\n+ } catch (ex) {\n+ return false;\n+ }\n+ return true;\n+ }();\n+ function constructEvent(OriginalEvent, name, type, options) {\n+ if (supportsEventConstructors) return new OriginalEvent(type, unwrapOptions(options));\n+ var event = unwrap(document.createEvent(name));\n+ var defaultDict = defaultInitDicts[name];\n+ var args = [ type ];\n+ Object.keys(defaultDict).forEach(function(key) {\n+ var v = options != null && key in options ? options[key] : defaultDict[key];\n+ if (key === \"relatedTarget\") v = unwrap(v);\n+ args.push(v);\n+ });\n+ event[\"init\" + name].apply(event, args);\n+ return event;\n+ }\n+ if (!supportsEventConstructors) {\n+ var configureEventConstructor = function(name, initDict, superName) {\n+ if (superName) {\n+ var superDict = defaultInitDicts[superName];\n+ initDict = mixin(mixin({}, superDict), initDict);\n+ }\n+ defaultInitDicts[name] = initDict;\n+ };\n+ configureEventConstructor(\"Event\", {\n+ bubbles: false,\n+ cancelable: false\n+ });\n+ configureEventConstructor(\"CustomEvent\", {\n+ detail: null\n+ }, \"Event\");\n+ configureEventConstructor(\"UIEvent\", {\n+ view: null,\n+ detail: 0\n+ }, \"Event\");\n+ configureEventConstructor(\"MouseEvent\", {\n+ screenX: 0,\n+ screenY: 0,\n+ clientX: 0,\n+ clientY: 0,\n+ ctrlKey: false,\n+ altKey: false,\n+ shiftKey: false,\n+ metaKey: false,\n+ button: 0,\n+ relatedTarget: null\n+ }, \"UIEvent\");\n+ configureEventConstructor(\"FocusEvent\", {\n+ relatedTarget: null\n+ }, \"UIEvent\");\n+ }\n+ var OriginalBeforeUnloadEvent = window.BeforeUnloadEvent;\n+ function BeforeUnloadEvent(impl) {\n+ Event.call(this, impl);\n+ }\n+ BeforeUnloadEvent.prototype = Object.create(Event.prototype);\n+ mixin(BeforeUnloadEvent.prototype, {\n+ get returnValue() {\n+ return unsafeUnwrap(this).returnValue;\n+ },\n+ set returnValue(v) {\n+ unsafeUnwrap(this).returnValue = v;\n+ }\n+ });\n+ if (OriginalBeforeUnloadEvent) registerWrapper(OriginalBeforeUnloadEvent, BeforeUnloadEvent);\n+ function isValidListener(fun) {\n+ if (typeof fun === \"function\") return true;\n+ return fun && fun.handleEvent;\n+ }\n+ function isMutationEvent(type) {\n+ switch (type) {\n+ case \"DOMAttrModified\":\n+ case \"DOMAttributeNameChanged\":\n+ case \"DOMCharacterDataModified\":\n+ case \"DOMElementNameChanged\":\n+ case \"DOMNodeInserted\":\n+ case \"DOMNodeInsertedIntoDocument\":\n+ case \"DOMNodeRemoved\":\n+ case \"DOMNodeRemovedFromDocument\":\n+ case \"DOMSubtreeModified\":\n+ return true;\n+ }\n+ return false;\n+ }\n+ var OriginalEventTarget = window.EventTarget;\n+ function EventTarget(impl) {\n+ setWrapper(impl, this);\n+ }\n+ var methodNames = [ \"addEventListener\", \"removeEventListener\", \"dispatchEvent\" ];\n+ [ Node, Window ].forEach(function(constructor) {\n+ var p = constructor.prototype;\n+ methodNames.forEach(function(name) {\n+ Object.defineProperty(p, name + \"_\", {\n+ value: p[name]\n+ });\n+ });\n+ });\n+ function getTargetToListenAt(wrapper) {\n+ if (wrapper instanceof wrappers.ShadowRoot) wrapper = wrapper.host;\n+ return unwrap(wrapper);\n+ }\n+ EventTarget.prototype = {\n+ addEventListener: function(type, fun, capture) {\n+ if (!isValidListener(fun) || isMutationEvent(type)) return;\n+ var listener = new Listener(type, fun, capture);\n+ var listeners = listenersTable.get(this);\n+ if (!listeners) {\n+ listeners = [];\n+ listeners.depth = 0;\n+ listenersTable.set(this, listeners);\n+ } else {\n+ for (var i = 0; i < listeners.length; i++) {\n+ if (listener.equals(listeners[i])) return;\n+ }\n+ }\n+ listeners.push(listener);\n+ var target = getTargetToListenAt(this);\n+ target.addEventListener_(type, dispatchOriginalEvent, true);\n+ },\n+ removeEventListener: function(type, fun, capture) {\n+ capture = Boolean(capture);\n+ var listeners = listenersTable.get(this);\n+ if (!listeners) return;\n+ var count = 0, found = false;\n+ for (var i = 0; i < listeners.length; i++) {\n+ if (listeners[i].type === type && listeners[i].capture === capture) {\n+ count++;\n+ if (listeners[i].handler === fun) {\n+ found = true;\n+ listeners[i].remove();\n+ }\n+ }\n+ }\n+ if (found && count === 1) {\n+ var target = getTargetToListenAt(this);\n+ target.removeEventListener_(type, dispatchOriginalEvent, true);\n+ }\n+ },\n+ dispatchEvent: function(event) {\n+ var nativeEvent = unwrap(event);\n+ var eventType = nativeEvent.type;\n+ handledEventsTable.set(nativeEvent, false);\n+ scope.renderAllPending();\n+ var tempListener;\n+ if (!hasListenerInAncestors(this, eventType)) {\n+ tempListener = function() {};\n+ this.addEventListener(eventType, tempListener, true);\n+ }\n+ try {\n+ return unwrap(this).dispatchEvent_(nativeEvent);\n+ } finally {\n+ if (tempListener) this.removeEventListener(eventType, tempListener, true);\n+ }\n+ }\n+ };\n+ function hasListener(node, type) {\n+ var listeners = listenersTable.get(node);\n+ if (listeners) {\n+ for (var i = 0; i < listeners.length; i++) {\n+ if (!listeners[i].removed && listeners[i].type === type) return true;\n+ }\n+ }\n+ return false;\n+ }\n+ function hasListenerInAncestors(target, type) {\n+ for (var node = unwrap(target); node; node = node.parentNode) {\n+ if (hasListener(wrap(node), type)) return true;\n+ }\n+ return false;\n+ }\n+ if (OriginalEventTarget) registerWrapper(OriginalEventTarget, EventTarget);\n+ function wrapEventTargetMethods(constructors) {\n+ forwardMethodsToWrapper(constructors, methodNames);\n+ }\n+ var originalElementFromPoint = document.elementFromPoint;\n+ function elementFromPoint(self, document, x, y) {\n+ scope.renderAllPending();\n+ var element = wrap(originalElementFromPoint.call(unsafeUnwrap(document), x, y));\n+ if (!element) return null;\n+ var path = getEventPath(element, null);\n+ var idx = path.lastIndexOf(self);\n+ if (idx == -1) return null; else path = path.slice(0, idx);\n+ return eventRetargetting(path, self);\n+ }\n+ function getEventHandlerGetter(name) {\n+ return function() {\n+ var inlineEventHandlers = eventHandlersTable.get(this);\n+ return inlineEventHandlers && inlineEventHandlers[name] && inlineEventHandlers[name].value || null;\n+ };\n+ }\n+ function getEventHandlerSetter(name) {\n+ var eventType = name.slice(2);\n+ return function(value) {\n+ var inlineEventHandlers = eventHandlersTable.get(this);\n+ if (!inlineEventHandlers) {\n+ inlineEventHandlers = Object.create(null);\n+ eventHandlersTable.set(this, inlineEventHandlers);\n+ }\n+ var old = inlineEventHandlers[name];\n+ if (old) this.removeEventListener(eventType, old.wrapped, false);\n+ if (typeof value === \"function\") {\n+ var wrapped = function(e) {\n+ var rv = value.call(this, e);\n+ if (rv === false) e.preventDefault(); else if (name === \"onbeforeunload\" && typeof rv === \"string\") e.returnValue = rv;\n+ };\n+ this.addEventListener(eventType, wrapped, false);\n+ inlineEventHandlers[name] = {\n+ value: value,\n+ wrapped: wrapped\n+ };\n+ }\n+ };\n+ }\n+ scope.elementFromPoint = elementFromPoint;\n+ scope.getEventHandlerGetter = getEventHandlerGetter;\n+ scope.getEventHandlerSetter = getEventHandlerSetter;\n+ scope.wrapEventTargetMethods = wrapEventTargetMethods;\n+ scope.wrappers.BeforeUnloadEvent = BeforeUnloadEvent;\n+ scope.wrappers.CustomEvent = CustomEvent;\n+ scope.wrappers.Event = Event;\n+ scope.wrappers.EventTarget = EventTarget;\n+ scope.wrappers.FocusEvent = FocusEvent;\n+ scope.wrappers.MouseEvent = MouseEvent;\n+ scope.wrappers.UIEvent = UIEvent;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var UIEvent = scope.wrappers.UIEvent;\n+ var mixin = scope.mixin;\n+ var registerWrapper = scope.registerWrapper;\n+ var setWrapper = scope.setWrapper;\n+ var unsafeUnwrap = scope.unsafeUnwrap;\n+ var wrap = scope.wrap;\n+ var OriginalTouchEvent = window.TouchEvent;\n+ if (!OriginalTouchEvent) return;\n+ var nativeEvent;\n+ try {\n+ nativeEvent = document.createEvent(\"TouchEvent\");\n+ } catch (ex) {\n+ return;\n+ }\n+ var nonEnumDescriptor = {\n+ enumerable: false\n+ };\n+ function nonEnum(obj, prop) {\n+ Object.defineProperty(obj, prop, nonEnumDescriptor);\n+ }\n+ function Touch(impl) {\n+ setWrapper(impl, this);\n+ }\n+ Touch.prototype = {\n+ get target() {\n+ return wrap(unsafeUnwrap(this).target);\n+ }\n+ };\n+ var descr = {\n+ configurable: true,\n+ enumerable: true,\n+ get: null\n+ };\n+ [ \"clientX\", \"clientY\", \"screenX\", \"screenY\", \"pageX\", \"pageY\", \"identifier\", \"webkitRadiusX\", \"webkitRadiusY\", \"webkitRotationAngle\", \"webkitForce\" ].forEach(function(name) {\n+ descr.get = function() {\n+ return unsafeUnwrap(this)[name];\n+ };\n+ Object.defineProperty(Touch.prototype, name, descr);\n+ });\n+ function TouchList() {\n+ this.length = 0;\n+ nonEnum(this, \"length\");\n+ }\n+ TouchList.prototype = {\n+ item: function(index) {\n+ return this[index];\n+ }\n+ };\n+ function wrapTouchList(nativeTouchList) {\n+ var list = new TouchList();\n+ for (var i = 0; i < nativeTouchList.length; i++) {\n+ list[i] = new Touch(nativeTouchList[i]);\n+ }\n+ list.length = i;\n+ return list;\n+ }\n+ function TouchEvent(impl) {\n+ UIEvent.call(this, impl);\n+ }\n+ TouchEvent.prototype = Object.create(UIEvent.prototype);\n+ mixin(TouchEvent.prototype, {\n+ get touches() {\n+ return wrapTouchList(unsafeUnwrap(this).touches);\n+ },\n+ get targetTouches() {\n+ return wrapTouchList(unsafeUnwrap(this).targetTouches);\n+ },\n+ get changedTouches() {\n+ return wrapTouchList(unsafeUnwrap(this).changedTouches);\n+ },\n+ initTouchEvent: function() {\n+ throw new Error(\"Not implemented\");\n+ }\n+ });\n+ registerWrapper(OriginalTouchEvent, TouchEvent, nativeEvent);\n+ scope.wrappers.Touch = Touch;\n+ scope.wrappers.TouchEvent = TouchEvent;\n+ scope.wrappers.TouchList = TouchList;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var unsafeUnwrap = scope.unsafeUnwrap;\n+ var wrap = scope.wrap;\n+ var nonEnumDescriptor = {\n+ enumerable: false\n+ };\n+ function nonEnum(obj, prop) {\n+ Object.defineProperty(obj, prop, nonEnumDescriptor);\n+ }\n+ function NodeList() {\n+ this.length = 0;\n+ nonEnum(this, \"length\");\n+ }\n+ NodeList.prototype = {\n+ item: function(index) {\n+ return this[index];\n+ }\n+ };\n+ nonEnum(NodeList.prototype, \"item\");\n+ function wrapNodeList(list) {\n+ if (list == null) return list;\n+ var wrapperList = new NodeList();\n+ for (var i = 0, length = list.length; i < length; i++) {\n+ wrapperList[i] = wrap(list[i]);\n+ }\n+ wrapperList.length = length;\n+ return wrapperList;\n+ }\n+ function addWrapNodeListMethod(wrapperConstructor, name) {\n+ wrapperConstructor.prototype[name] = function() {\n+ return wrapNodeList(unsafeUnwrap(this)[name].apply(unsafeUnwrap(this), arguments));\n+ };\n+ }\n+ scope.wrappers.NodeList = NodeList;\n+ scope.addWrapNodeListMethod = addWrapNodeListMethod;\n+ scope.wrapNodeList = wrapNodeList;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ scope.wrapHTMLCollection = scope.wrapNodeList;\n+ scope.wrappers.HTMLCollection = scope.wrappers.NodeList;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var EventTarget = scope.wrappers.EventTarget;\n+ var NodeList = scope.wrappers.NodeList;\n+ var TreeScope = scope.TreeScope;\n+ var assert = scope.assert;\n+ var defineWrapGetter = scope.defineWrapGetter;\n+ var enqueueMutation = scope.enqueueMutation;\n+ var getTreeScope = scope.getTreeScope;\n+ var isWrapper = scope.isWrapper;\n+ var mixin = scope.mixin;\n+ var registerTransientObservers = scope.registerTransientObservers;\n+ var registerWrapper = scope.registerWrapper;\n+ var setTreeScope = scope.setTreeScope;\n+ var unsafeUnwrap = scope.unsafeUnwrap;\n+ var unwrap = scope.unwrap;\n+ var unwrapIfNeeded = scope.unwrapIfNeeded;\n+ var wrap = scope.wrap;\n+ var wrapIfNeeded = scope.wrapIfNeeded;\n+ var wrappers = scope.wrappers;\n+ function assertIsNodeWrapper(node) {\n+ assert(node instanceof Node);\n+ }\n+ function createOneElementNodeList(node) {\n+ var nodes = new NodeList();\n+ nodes[0] = node;\n+ nodes.length = 1;\n+ return nodes;\n+ }\n+ var surpressMutations = false;\n+ function enqueueRemovalForInsertedNodes(node, parent, nodes) {\n+ enqueueMutation(parent, \"childList\", {\n+ removedNodes: nodes,\n+ previousSibling: node.previousSibling,\n+ nextSibling: node.nextSibling\n+ });\n+ }\n+ function enqueueRemovalForInsertedDocumentFragment(df, nodes) {\n+ enqueueMutation(df, \"childList\", {\n+ removedNodes: nodes\n+ });\n+ }\n+ function collectNodes(node, parentNode, previousNode, nextNode) {\n+ if (node instanceof DocumentFragment) {\n+ var nodes = collectNodesForDocumentFragment(node);\n+ surpressMutations = true;\n+ for (var i = nodes.length - 1; i >= 0; i--) {\n+ node.removeChild(nodes[i]);\n+ nodes[i].parentNode_ = parentNode;\n+ }\n+ surpressMutations = false;\n+ for (var i = 0; i < nodes.length; i++) {\n+ nodes[i].previousSibling_ = nodes[i - 1] || previousNode;\n+ nodes[i].nextSibling_ = nodes[i + 1] || nextNode;\n+ }\n+ if (previousNode) previousNode.nextSibling_ = nodes[0];\n+ if (nextNode) nextNode.previousSibling_ = nodes[nodes.length - 1];\n+ return nodes;\n+ }\n+ var nodes = createOneElementNodeList(node);\n+ var oldParent = node.parentNode;\n+ if (oldParent) {\n+ oldParent.removeChild(node);\n+ }\n+ node.parentNode_ = parentNode;\n+ node.previousSibling_ = previousNode;\n+ node.nextSibling_ = nextNode;\n+ if (previousNode) previousNode.nextSibling_ = node;\n+ if (nextNode) nextNode.previousSibling_ = node;\n+ return nodes;\n+ }\n+ function collectNodesNative(node) {\n+ if (node instanceof DocumentFragment) return collectNodesForDocumentFragment(node);\n+ var nodes = createOneElementNodeList(node);\n+ var oldParent = node.parentNode;\n+ if (oldParent) enqueueRemovalForInsertedNodes(node, oldParent, nodes);\n+ return nodes;\n+ }\n+ function collectNodesForDocumentFragment(node) {\n+ var nodes = new NodeList();\n+ var i = 0;\n+ for (var child = node.firstChild; child; child = child.nextSibling) {\n+ nodes[i++] = child;\n+ }\n+ nodes.length = i;\n+ enqueueRemovalForInsertedDocumentFragment(node, nodes);\n+ return nodes;\n+ }\n+ function snapshotNodeList(nodeList) {\n+ return nodeList;\n+ }\n+ function nodeWasAdded(node, treeScope) {\n+ setTreeScope(node, treeScope);\n+ node.nodeIsInserted_();\n+ }\n+ function nodesWereAdded(nodes, parent) {\n+ var treeScope = getTreeScope(parent);\n+ for (var i = 0; i < nodes.length; i++) {\n+ nodeWasAdded(nodes[i], treeScope);\n+ }\n+ }\n+ function nodeWasRemoved(node) {\n+ setTreeScope(node, new TreeScope(node, null));\n+ }\n+ function nodesWereRemoved(nodes) {\n+ for (var i = 0; i < nodes.length; i++) {\n+ nodeWasRemoved(nodes[i]);\n+ }\n+ }\n+ function ensureSameOwnerDocument(parent, child) {\n+ var ownerDoc = parent.nodeType === Node.DOCUMENT_NODE ? parent : parent.ownerDocument;\n+ if (ownerDoc !== child.ownerDocument) ownerDoc.adoptNode(child);\n+ }\n+ function adoptNodesIfNeeded(owner, nodes) {\n+ if (!nodes.length) return;\n+ var ownerDoc = owner.ownerDocument;\n+ if (ownerDoc === nodes[0].ownerDocument) return;\n+ for (var i = 0; i < nodes.length; i++) {\n+ scope.adoptNodeNoRemove(nodes[i], ownerDoc);\n+ }\n+ }\n+ function unwrapNodesForInsertion(owner, nodes) {\n+ adoptNodesIfNeeded(owner, nodes);\n+ var length = nodes.length;\n+ if (length === 1) return unwrap(nodes[0]);\n+ var df = unwrap(owner.ownerDocument.createDocumentFragment());\n+ for (var i = 0; i < length; i++) {\n+ df.appendChild(unwrap(nodes[i]));\n+ }\n+ return df;\n+ }\n+ function clearChildNodes(wrapper) {\n+ if (wrapper.firstChild_ !== undefined) {\n+ var child = wrapper.firstChild_;\n+ while (child) {\n+ var tmp = child;\n+ child = child.nextSibling_;\n+ tmp.parentNode_ = tmp.previousSibling_ = tmp.nextSibling_ = undefined;\n+ }\n+ }\n+ wrapper.firstChild_ = wrapper.lastChild_ = undefined;\n+ }\n+ function removeAllChildNodes(wrapper) {\n+ if (wrapper.invalidateShadowRenderer()) {\n+ var childWrapper = wrapper.firstChild;\n+ while (childWrapper) {\n+ assert(childWrapper.parentNode === wrapper);\n+ var nextSibling = childWrapper.nextSibling;\n+ var childNode = unwrap(childWrapper);\n+ var parentNode = childNode.parentNode;\n+ if (parentNode) originalRemoveChild.call(parentNode, childNode);\n+ childWrapper.previousSibling_ = childWrapper.nextSibling_ = childWrapper.parentNode_ = null;\n+ childWrapper = nextSibling;\n+ }\n+ wrapper.firstChild_ = wrapper.lastChild_ = null;\n+ } else {\n+ var node = unwrap(wrapper);\n+ var child = node.firstChild;\n+ var nextSibling;\n+ while (child) {\n+ nextSibling = child.nextSibling;\n+ originalRemoveChild.call(node, child);\n+ child = nextSibling;\n+ }\n+ }\n+ }\n+ function invalidateParent(node) {\n+ var p = node.parentNode;\n+ return p && p.invalidateShadowRenderer();\n+ }\n+ function cleanupNodes(nodes) {\n+ for (var i = 0, n; i < nodes.length; i++) {\n+ n = nodes[i];\n+ n.parentNode.removeChild(n);\n+ }\n+ }\n+ var originalImportNode = document.importNode;\n+ var originalCloneNode = window.Node.prototype.cloneNode;\n+ function cloneNode(node, deep, opt_doc) {\n+ var clone;\n+ if (opt_doc) clone = wrap(originalImportNode.call(opt_doc, unsafeUnwrap(node), false)); else clone = wrap(originalCloneNode.call(unsafeUnwrap(node), false));\n+ if (deep) {\n+ for (var child = node.firstChild; child; child = child.nextSibling) {\n+ clone.appendChild(cloneNode(child, true, opt_doc));\n+ }\n+ if (node instanceof wrappers.HTMLTemplateElement) {\n+ var cloneContent = clone.content;\n+ for (var child = node.content.firstChild; child; child = child.nextSibling) {\n+ cloneContent.appendChild(cloneNode(child, true, opt_doc));\n+ }\n+ }\n+ }\n+ return clone;\n+ }\n+ function contains(self, child) {\n+ if (!child || getTreeScope(self) !== getTreeScope(child)) return false;\n+ for (var node = child; node; node = node.parentNode) {\n+ if (node === self) return true;\n+ }\n+ return false;\n+ }\n+ var OriginalNode = window.Node;\n+ function Node(original) {\n+ assert(original instanceof OriginalNode);\n+ EventTarget.call(this, original);\n+ this.parentNode_ = undefined;\n+ this.firstChild_ = undefined;\n+ this.lastChild_ = undefined;\n+ this.nextSibling_ = undefined;\n+ this.previousSibling_ = undefined;\n+ this.treeScope_ = undefined;\n+ }\n+ var OriginalDocumentFragment = window.DocumentFragment;\n+ var originalAppendChild = OriginalNode.prototype.appendChild;\n+ var originalCompareDocumentPosition = OriginalNode.prototype.compareDocumentPosition;\n+ var originalInsertBefore = OriginalNode.prototype.insertBefore;\n+ var originalRemoveChild = OriginalNode.prototype.removeChild;\n+ var originalReplaceChild = OriginalNode.prototype.replaceChild;\n+ var isIe = \/Trident\/.test(navigator.userAgent);\n+ var removeChildOriginalHelper = isIe ? function(parent, child) {\n+ try {\n+ originalRemoveChild.call(parent, child);\n+ } catch (ex) {\n+ if (!(parent instanceof OriginalDocumentFragment)) throw ex;\n+ }\n+ } : function(parent, child) {\n+ originalRemoveChild.call(parent, child);\n+ };\n+ Node.prototype = Object.create(EventTarget.prototype);\n+ mixin(Node.prototype, {\n+ appendChild: function(childWrapper) {\n+ return this.insertBefore(childWrapper, null);\n+ },\n+ insertBefore: function(childWrapper, refWrapper) {\n+ assertIsNodeWrapper(childWrapper);\n+ var refNode;\n+ if (refWrapper) {\n+ if (isWrapper(refWrapper)) {\n+ refNode = unwrap(refWrapper);\n+ } else {\n+ refNode = refWrapper;\n+ refWrapper = wrap(refNode);\n+ }\n+ } else {\n+ refWrapper = null;\n+ refNode = null;\n+ }\n+ refWrapper && assert(refWrapper.parentNode === this);\n+ var nodes;\n+ var previousNode = refWrapper ? refWrapper.previousSibling : this.lastChild;\n+ var useNative = !this.invalidateShadowRenderer() && !invalidateParent(childWrapper);\n+ if (useNative) nodes = collectNodesNative(childWrapper); else nodes = collectNodes(childWrapper, this, previousNode, refWrapper);\n+ if (useNative) {\n+ ensureSameOwnerDocument(this, childWrapper);\n+ clearChildNodes(this);\n+ originalInsertBefore.call(unsafeUnwrap(this), unwrap(childWrapper), refNode);\n+ } else {\n+ if (!previousNode) this.firstChild_ = nodes[0];\n+ if (!refWrapper) {\n+ this.lastChild_ = nodes[nodes.length - 1];\n+ if (this.firstChild_ === undefined) this.firstChild_ = this.firstChild;\n+ }\n+ var parentNode = refNode ? refNode.parentNode : unsafeUnwrap(this);\n+ if (parentNode) {\n+ originalInsertBefore.call(parentNode, unwrapNodesForInsertion(this, nodes), refNode);\n+ } else {\n+ adoptNodesIfNeeded(this, nodes);\n+ }\n+ }\n+ enqueueMutation(this, \"childList\", {\n+ addedNodes: nodes,\n+ nextSibling: refWrapper,\n+ previousSibling: previousNode\n+ });\n+ nodesWereAdded(nodes, this);\n+ return childWrapper;\n+ },\n+ removeChild: function(childWrapper) {\n+ assertIsNodeWrapper(childWrapper);\n+ if (childWrapper.parentNode !== this) {\n+ var found = false;\n+ var childNodes = this.childNodes;\n+ for (var ieChild = this.firstChild; ieChild; ieChild = ieChild.nextSibling) {\n+ if (ieChild === childWrapper) {\n+ found = true;\n+ break;\n+ }\n+ }\n+ if (!found) {\n+ throw new Error(\"NotFoundError\");\n+ }\n+ }\n+ var childNode = unwrap(childWrapper);\n+ var childWrapperNextSibling = childWrapper.nextSibling;\n+ var childWrapperPreviousSibling = childWrapper.previousSibling;\n+ if (this.invalidateShadowRenderer()) {\n+ var thisFirstChild = this.firstChild;\n+ var thisLastChild = this.lastChild;\n+ var parentNode = childNode.parentNode;\n+ if (parentNode) removeChildOriginalHelper(parentNode, childNode);\n+ if (thisFirstChild === childWrapper) this.firstChild_ = childWrapperNextSibling;\n+ if (thisLastChild === childWrapper) this.lastChild_ = childWrapperPreviousSibling;\n+ if (childWrapperPreviousSibling) childWrapperPreviousSibling.nextSibling_ = childWrapperNextSibling;\n+ if (childWrapperNextSibling) {\n+ childWrapperNextSibling.previousSibling_ = childWrapperPreviousSibling;\n+ }\n+ childWrapper.previousSibling_ = childWrapper.nextSibling_ = childWrapper.parentNode_ = undefined;\n+ } else {\n+ clearChildNodes(this);\n+ removeChildOriginalHelper(unsafeUnwrap(this), childNode);\n+ }\n+ if (!surpressMutations) {\n+ enqueueMutation(this, \"childList\", {\n+ removedNodes: createOneElementNodeList(childWrapper),\n+ nextSibling: childWrapperNextSibling,\n+ previousSibling: childWrapperPreviousSibling\n+ });\n+ }\n+ registerTransientObservers(this, childWrapper);\n+ return childWrapper;\n+ },\n+ replaceChild: function(newChildWrapper, oldChildWrapper) {\n+ assertIsNodeWrapper(newChildWrapper);\n+ var oldChildNode;\n+ if (isWrapper(oldChildWrapper)) {\n+ oldChildNode = unwrap(oldChildWrapper);\n+ } else {\n+ oldChildNode = oldChildWrapper;\n+ oldChildWrapper = wrap(oldChildNode);\n+ }\n+ if (oldChildWrapper.parentNode !== this) {\n+ throw new Error(\"NotFoundError\");\n+ }\n+ var nextNode = oldChildWrapper.nextSibling;\n+ var previousNode = oldChildWrapper.previousSibling;\n+ var nodes;\n+ var useNative = !this.invalidateShadowRenderer() && !invalidateParent(newChildWrapper);\n+ if (useNative) {\n+ nodes = collectNodesNative(newChildWrapper);\n+ } else {\n+ if (nextNode === newChildWrapper) nextNode = newChildWrapper.nextSibling;\n+ nodes = collectNodes(newChildWrapper, this, previousNode, nextNode);\n+ }\n+ if (!useNative) {\n+ if (this.firstChild === oldChildWrapper) this.firstChild_ = nodes[0];\n+ if (this.lastChild === oldChildWrapper) this.lastChild_ = nodes[nodes.length - 1];\n+ oldChildWrapper.previousSibling_ = oldChildWrapper.nextSibling_ = oldChildWrapper.parentNode_ = undefined;\n+ if (oldChildNode.parentNode) {\n+ originalReplaceChild.call(oldChildNode.parentNode, unwrapNodesForInsertion(this, nodes), oldChildNode);\n+ }\n+ } else {\n+ ensureSameOwnerDocument(this, newChildWrapper);\n+ clearChildNodes(this);\n+ originalReplaceChild.call(unsafeUnwrap(this), unwrap(newChildWrapper), oldChildNode);\n+ }\n+ enqueueMutation(this, \"childList\", {\n+ addedNodes: nodes,\n+ removedNodes: createOneElementNodeList(oldChildWrapper),\n+ nextSibling: nextNode,\n+ previousSibling: previousNode\n+ });\n+ nodeWasRemoved(oldChildWrapper);\n+ nodesWereAdded(nodes, this);\n+ return oldChildWrapper;\n+ },\n+ nodeIsInserted_: function() {\n+ for (var child = this.firstChild; child; child = child.nextSibling) {\n+ child.nodeIsInserted_();\n+ }\n+ },\n+ hasChildNodes: function() {\n+ return this.firstChild !== null;\n+ },\n+ get parentNode() {\n+ return this.parentNode_ !== undefined ? this.parentNode_ : wrap(unsafeUnwrap(this).parentNode);\n+ },\n+ get firstChild() {\n+ return this.firstChild_ !== undefined ? this.firstChild_ : wrap(unsafeUnwrap(this).firstChild);\n+ },\n+ get lastChild() {\n+ return this.lastChild_ !== undefined ? this.lastChild_ : wrap(unsafeUnwrap(this).lastChild);\n+ },\n+ get nextSibling() {\n+ return this.nextSibling_ !== undefined ? this.nextSibling_ : wrap(unsafeUnwrap(this).nextSibling);\n+ },\n+ get previousSibling() {\n+ return this.previousSibling_ !== undefined ? this.previousSibling_ : wrap(unsafeUnwrap(this).previousSibling);\n+ },\n+ get parentElement() {\n+ var p = this.parentNode;\n+ while (p && p.nodeType !== Node.ELEMENT_NODE) {\n+ p = p.parentNode;\n+ }\n+ return p;\n+ },\n+ get textContent() {\n+ var s = \"\";\n+ for (var child = this.firstChild; child; child = child.nextSibling) {\n+ if (child.nodeType != Node.COMMENT_NODE) {\n+ s += child.textContent;\n+ }\n+ }\n+ return s;\n+ },\n+ set textContent(textContent) {\n+ if (textContent == null) textContent = \"\";\n+ var removedNodes = snapshotNodeList(this.childNodes);\n+ if (this.invalidateShadowRenderer()) {\n+ removeAllChildNodes(this);\n+ if (textContent !== \"\") {\n+ var textNode = unsafeUnwrap(this).ownerDocument.createTextNode(textContent);\n+ this.appendChild(textNode);\n+ }\n+ } else {\n+ clearChildNodes(this);\n+ unsafeUnwrap(this).textContent = textContent;\n+ }\n+ var addedNodes = snapshotNodeList(this.childNodes);\n+ enqueueMutation(this, \"childList\", {\n+ addedNodes: addedNodes,\n+ removedNodes: removedNodes\n+ });\n+ nodesWereRemoved(removedNodes);\n+ nodesWereAdded(addedNodes, this);\n+ },\n+ get childNodes() {\n+ var wrapperList = new NodeList();\n+ var i = 0;\n+ for (var child = this.firstChild; child; child = child.nextSibling) {\n+ wrapperList[i++] = child;\n+ }\n+ wrapperList.length = i;\n+ return wrapperList;\n+ },\n+ cloneNode: function(deep) {\n+ return cloneNode(this, deep);\n+ },\n+ contains: function(child) {\n+ return contains(this, wrapIfNeeded(child));\n+ },\n+ compareDocumentPosition: function(otherNode) {\n+ return originalCompareDocumentPosition.call(unsafeUnwrap(this), unwrapIfNeeded(otherNode));\n+ },\n+ normalize: function() {\n+ var nodes = snapshotNodeList(this.childNodes);\n+ var remNodes = [];\n+ var s = \"\";\n+ var modNode;\n+ for (var i = 0, n; i < nodes.length; i++) {\n+ n = nodes[i];\n+ if (n.nodeType === Node.TEXT_NODE) {\n+ if (!modNode && !n.data.length) this.removeNode(n); else if (!modNode) modNode = n; else {\n+ s += n.data;\n+ remNodes.push(n);\n+ }\n+ } else {\n+ if (modNode && remNodes.length) {\n+ modNode.data += s;\n+ cleanupNodes(remNodes);\n+ }\n+ remNodes = [];\n+ s = \"\";\n+ modNode = null;\n+ if (n.childNodes.length) n.normalize();\n+ }\n+ }\n+ if (modNode && remNodes.length) {\n+ modNode.data += s;\n+ cleanupNodes(remNodes);\n+ }\n+ }\n+ });\n+ defineWrapGetter(Node, \"ownerDocument\");\n+ registerWrapper(OriginalNode, Node, document.createDocumentFragment());\n+ delete Node.prototype.querySelector;\n+ delete Node.prototype.querySelectorAll;\n+ Node.prototype = mixin(Object.create(EventTarget.prototype), Node.prototype);\n+ scope.cloneNode = cloneNode;\n+ scope.nodeWasAdded = nodeWasAdded;\n+ scope.nodeWasRemoved = nodeWasRemoved;\n+ scope.nodesWereAdded = nodesWereAdded;\n+ scope.nodesWereRemoved = nodesWereRemoved;\n+ scope.originalInsertBefore = originalInsertBefore;\n+ scope.originalRemoveChild = originalRemoveChild;\n+ scope.snapshotNodeList = snapshotNodeList;\n+ scope.wrappers.Node = Node;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var HTMLCollection = scope.wrappers.HTMLCollection;\n+ var NodeList = scope.wrappers.NodeList;\n+ var getTreeScope = scope.getTreeScope;\n+ var unsafeUnwrap = scope.unsafeUnwrap;\n+ var wrap = scope.wrap;\n+ var originalDocumentQuerySelector = document.querySelector;\n+ var originalElementQuerySelector = document.documentElement.querySelector;\n+ var originalDocumentQuerySelectorAll = document.querySelectorAll;\n+ var originalElementQuerySelectorAll = document.documentElement.querySelectorAll;\n+ var originalDocumentGetElementsByTagName = document.getElementsByTagName;\n+ var originalElementGetElementsByTagName = document.documentElement.getElementsByTagName;\n+ var originalDocumentGetElementsByTagNameNS = document.getElementsByTagNameNS;\n+ var originalElementGetElementsByTagNameNS = document.documentElement.getElementsByTagNameNS;\n+ var OriginalElement = window.Element;\n+ var OriginalDocument = window.HTMLDocument || window.Document;\n+ function filterNodeList(list, index, result, deep) {\n+ var wrappedItem = null;\n+ var root = null;\n+ for (var i = 0, length = list.length; i < length; i++) {\n+ wrappedItem = wrap(list[i]);\n+ if (!deep && (root = getTreeScope(wrappedItem).root)) {\n+ if (root instanceof scope.wrappers.ShadowRoot) {\n+ continue;\n+ }\n+ }\n+ result[index++] = wrappedItem;\n+ }\n+ return index;\n+ }\n+ function shimSelector(selector) {\n+ return String(selector).replace(\/\\\/deep\\\/\/g, \" \");\n+ }\n+ function findOne(node, selector) {\n+ var m, el = node.firstElementChild;\n+ while (el) {\n+ if (el.matches(selector)) return el;\n+ m = findOne(el, selector);\n+ if (m) return m;\n+ el = el.nextElementSibling;\n+ }\n+ return null;\n+ }\n+ function matchesSelector(el, selector) {\n+ return el.matches(selector);\n+ }\n+ var XHTML_NS = \"http:\/\/www.w3.org\/1999\/xhtml\";\n+ function matchesTagName(el, localName, localNameLowerCase) {\n+ var ln = el.localName;\n+ return ln === localName || ln === localNameLowerCase && el.namespaceURI === XHTML_NS;\n+ }\n+ function matchesEveryThing() {\n+ return true;\n+ }\n+ function matchesLocalNameOnly(el, ns, localName) {\n+ return el.localName === localName;\n+ }\n+ function matchesNameSpace(el, ns) {\n+ return el.namespaceURI === ns;\n+ }\n+ function matchesLocalNameNS(el, ns, localName) {\n+ return el.namespaceURI === ns && el.localName === localName;\n+ }\n+ function findElements(node, index, result, p, arg0, arg1) {\n+ var el = node.firstElementChild;\n+ while (el) {\n+ if (p(el, arg0, arg1)) result[index++] = el;\n+ index = findElements(el, index, result, p, arg0, arg1);\n+ el = el.nextElementSibling;\n+ }\n+ return index;\n+ }\n+ function querySelectorAllFiltered(p, index, result, selector, deep) {\n+ var target = unsafeUnwrap(this);\n+ var list;\n+ var root = getTreeScope(this).root;\n+ if (root instanceof scope.wrappers.ShadowRoot) {\n+ return findElements(this, index, result, p, selector, null);\n+ } else if (target instanceof OriginalElement) {\n+ list = originalElementQuerySelectorAll.call(target, selector);\n+ } else if (target instanceof OriginalDocument) {\n+ list = originalDocumentQuerySelectorAll.call(target, selector);\n+ } else {\n+ return findElements(this, index, result, p, selector, null);\n+ }\n+ return filterNodeList(list, index, result, deep);\n+ }\n+ var SelectorsInterface = {\n+ querySelector: function(selector) {\n+ var shimmed = shimSelector(selector);\n+ var deep = shimmed !== selector;\n+ selector = shimmed;\n+ var target = unsafeUnwrap(this);\n+ var wrappedItem;\n+ var root = getTreeScope(this).root;\n+ if (root instanceof scope.wrappers.ShadowRoot) {\n+ return findOne(this, selector);\n+ } else if (target instanceof OriginalElement) {\n+ wrappedItem = wrap(originalElementQuerySelector.call(target, selector));\n+ } else if (target instanceof OriginalDocument) {\n+ wrappedItem = wrap(originalDocumentQuerySelector.call(target, selector));\n+ } else {\n+ return findOne(this, selector);\n+ }\n+ if (!wrappedItem) {\n+ return wrappedItem;\n+ } else if (!deep && (root = getTreeScope(wrappedItem).root)) {\n+ if (root instanceof scope.wrappers.ShadowRoot) {\n+ return findOne(this, selector);\n+ }\n+ }\n+ return wrappedItem;\n+ },\n+ querySelectorAll: function(selector) {\n+ var shimmed = shimSelector(selector);\n+ var deep = shimmed !== selector;\n+ selector = shimmed;\n+ var result = new NodeList();\n+ result.length = querySelectorAllFiltered.call(this, matchesSelector, 0, result, selector, deep);\n+ return result;\n+ }\n+ };\n+ function getElementsByTagNameFiltered(p, index, result, localName, lowercase) {\n+ var target = unsafeUnwrap(this);\n+ var list;\n+ var root = getTreeScope(this).root;\n+ if (root instanceof scope.wrappers.ShadowRoot) {\n+ return findElements(this, index, result, p, localName, lowercase);\n+ } else if (target instanceof OriginalElement) {\n+ list = originalElementGetElementsByTagName.call(target, localName, lowercase);\n+ } else if (target instanceof OriginalDocument) {\n+ list = originalDocumentGetElementsByTagName.call(target, localName, lowercase);\n+ } else {\n+ return findElements(this, index, result, p, localName, lowercase);\n+ }\n+ return filterNodeList(list, index, result, false);\n+ }\n+ function getElementsByTagNameNSFiltered(p, index, result, ns, localName) {\n+ var target = unsafeUnwrap(this);\n+ var list;\n+ var root = getTreeScope(this).root;\n+ if (root instanceof scope.wrappers.ShadowRoot) {\n+ return findElements(this, index, result, p, ns, localName);\n+ } else if (target instanceof OriginalElement) {\n+ list = originalElementGetElementsByTagNameNS.call(target, ns, localName);\n+ } else if (target instanceof OriginalDocument) {\n+ list = originalDocumentGetElementsByTagNameNS.call(target, ns, localName);\n+ } else {\n+ return findElements(this, index, result, p, ns, localName);\n+ }\n+ return filterNodeList(list, index, result, false);\n+ }\n+ var GetElementsByInterface = {\n+ getElementsByTagName: function(localName) {\n+ var result = new HTMLCollection();\n+ var match = localName === \"*\" ? matchesEveryThing : matchesTagName;\n+ result.length = getElementsByTagNameFiltered.call(this, match, 0, result, localName, localName.toLowerCase());\n+ return result;\n+ },\n+ getElementsByClassName: function(className) {\n+ return this.querySelectorAll(\".\" + className);\n+ },\n+ getElementsByTagNameNS: function(ns, localName) {\n+ var result = new HTMLCollection();\n+ var match = null;\n+ if (ns === \"*\") {\n+ match = localName === \"*\" ? matchesEveryThing : matchesLocalNameOnly;\n+ } else {\n+ match = localName === \"*\" ? matchesNameSpace : matchesLocalNameNS;\n+ }\n+ result.length = getElementsByTagNameNSFiltered.call(this, match, 0, result, ns || null, localName);\n+ return result;\n+ }\n+ };\n+ scope.GetElementsByInterface = GetElementsByInterface;\n+ scope.SelectorsInterface = SelectorsInterface;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var NodeList = scope.wrappers.NodeList;\n+ function forwardElement(node) {\n+ while (node && node.nodeType !== Node.ELEMENT_NODE) {\n+ node = node.nextSibling;\n+ }\n+ return node;\n+ }\n+ function backwardsElement(node) {\n+ while (node && node.nodeType !== Node.ELEMENT_NODE) {\n+ node = node.previousSibling;\n+ }\n+ return node;\n+ }\n+ var ParentNodeInterface = {\n+ get firstElementChild() {\n+ return forwardElement(this.firstChild);\n+ },\n+ get lastElementChild() {\n+ return backwardsElement(this.lastChild);\n+ },\n+ get childElementCount() {\n+ var count = 0;\n+ for (var child = this.firstElementChild; child; child = child.nextElementSibling) {\n+ count++;\n+ }\n+ return count;\n+ },\n+ get children() {\n+ var wrapperList = new NodeList();\n+ var i = 0;\n+ for (var child = this.firstElementChild; child; child = child.nextElementSibling) {\n+ wrapperList[i++] = child;\n+ }\n+ wrapperList.length = i;\n+ return wrapperList;\n+ },\n+ remove: function() {\n+ var p = this.parentNode;\n+ if (p) p.removeChild(this);\n+ }\n+ };\n+ var ChildNodeInterface = {\n+ get nextElementSibling() {\n+ return forwardElement(this.nextSibling);\n+ },\n+ get previousElementSibling() {\n+ return backwardsElement(this.previousSibling);\n+ }\n+ };\n+ scope.ChildNodeInterface = ChildNodeInterface;\n+ scope.ParentNodeInterface = ParentNodeInterface;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var ChildNodeInterface = scope.ChildNodeInterface;\n+ var Node = scope.wrappers.Node;\n+ var enqueueMutation = scope.enqueueMutation;\n+ var mixin = scope.mixin;\n+ var registerWrapper = scope.registerWrapper;\n+ var unsafeUnwrap = scope.unsafeUnwrap;\n+ var OriginalCharacterData = window.CharacterData;\n+ function CharacterData(node) {\n+ Node.call(this, node);\n+ }\n+ CharacterData.prototype = Object.create(Node.prototype);\n+ mixin(CharacterData.prototype, {\n+ get textContent() {\n+ return this.data;\n+ },\n+ set textContent(value) {\n+ this.data = value;\n+ },\n+ get data() {\n+ return unsafeUnwrap(this).data;\n+ },\n+ set data(value) {\n+ var oldValue = unsafeUnwrap(this).data;\n+ enqueueMutation(this, \"characterData\", {\n+ oldValue: oldValue\n+ });\n+ unsafeUnwrap(this).data = value;\n+ }\n+ });\n+ mixin(CharacterData.prototype, ChildNodeInterface);\n+ registerWrapper(OriginalCharacterData, CharacterData, document.createTextNode(\"\"));\n+ scope.wrappers.CharacterData = CharacterData;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var CharacterData = scope.wrappers.CharacterData;\n+ var enqueueMutation = scope.enqueueMutation;\n+ var mixin = scope.mixin;\n+ var registerWrapper = scope.registerWrapper;\n+ function toUInt32(x) {\n+ return x >>> 0;\n+ }\n+ var OriginalText = window.Text;\n+ function Text(node) {\n+ CharacterData.call(this, node);\n+ }\n+ Text.prototype = Object.create(CharacterData.prototype);\n+ mixin(Text.prototype, {\n+ splitText: function(offset) {\n+ offset = toUInt32(offset);\n+ var s = this.data;\n+ if (offset > s.length) throw new Error(\"IndexSizeError\");\n+ var head = s.slice(0, offset);\n+ var tail = s.slice(offset);\n+ this.data = head;\n+ var newTextNode = this.ownerDocument.createTextNode(tail);\n+ if (this.parentNode) this.parentNode.insertBefore(newTextNode, this.nextSibling);\n+ return newTextNode;\n+ }\n+ });\n+ registerWrapper(OriginalText, Text, document.createTextNode(\"\"));\n+ scope.wrappers.Text = Text;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var setWrapper = scope.setWrapper;\n+ var unsafeUnwrap = scope.unsafeUnwrap;\n+ function invalidateClass(el) {\n+ scope.invalidateRendererBasedOnAttribute(el, \"class\");\n+ }\n+ function DOMTokenList(impl, ownerElement) {\n+ setWrapper(impl, this);\n+ this.ownerElement_ = ownerElement;\n+ }\n+ DOMTokenList.prototype = {\n+ constructor: DOMTokenList,\n+ get length() {\n+ return unsafeUnwrap(this).length;\n+ },\n+ item: function(index) {\n+ return unsafeUnwrap(this).item(index);\n+ },\n+ contains: function(token) {\n+ return unsafeUnwrap(this).contains(token);\n+ },\n+ add: function() {\n+ unsafeUnwrap(this).add.apply(unsafeUnwrap(this), arguments);\n+ invalidateClass(this.ownerElement_);\n+ },\n+ remove: function() {\n+ unsafeUnwrap(this).remove.apply(unsafeUnwrap(this), arguments);\n+ invalidateClass(this.ownerElement_);\n+ },\n+ toggle: function(token) {\n+ var rv = unsafeUnwrap(this).toggle.apply(unsafeUnwrap(this), arguments);\n+ invalidateClass(this.ownerElement_);\n+ return rv;\n+ },\n+ toString: function() {\n+ return unsafeUnwrap(this).toString();\n+ }\n+ };\n+ scope.wrappers.DOMTokenList = DOMTokenList;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var ChildNodeInterface = scope.ChildNodeInterface;\n+ var GetElementsByInterface = scope.GetElementsByInterface;\n+ var Node = scope.wrappers.Node;\n+ var DOMTokenList = scope.wrappers.DOMTokenList;\n+ var ParentNodeInterface = scope.ParentNodeInterface;\n+ var SelectorsInterface = scope.SelectorsInterface;\n+ var addWrapNodeListMethod = scope.addWrapNodeListMethod;\n+ var enqueueMutation = scope.enqueueMutation;\n+ var mixin = scope.mixin;\n+ var oneOf = scope.oneOf;\n+ var registerWrapper = scope.registerWrapper;\n+ var unsafeUnwrap = scope.unsafeUnwrap;\n+ var wrappers = scope.wrappers;\n+ var OriginalElement = window.Element;\n+ var matchesNames = [ \"matches\", \"mozMatchesSelector\", \"msMatchesSelector\", \"webkitMatchesSelector\" ].filter(function(name) {\n+ return OriginalElement.prototype[name];\n+ });\n+ var matchesName = matchesNames[0];\n+ var originalMatches = OriginalElement.prototype[matchesName];\n+ function invalidateRendererBasedOnAttribute(element, name) {\n+ var p = element.parentNode;\n+ if (!p || !p.shadowRoot) return;\n+ var renderer = scope.getRendererForHost(p);\n+ if (renderer.dependsOnAttribute(name)) renderer.invalidate();\n+ }\n+ function enqueAttributeChange(element, name, oldValue) {\n+ enqueueMutation(element, \"attributes\", {\n+ name: name,\n+ namespace: null,\n+ oldValue: oldValue\n+ });\n+ }\n+ var classListTable = new WeakMap();\n+ function Element(node) {\n+ Node.call(this, node);\n+ }\n+ Element.prototype = Object.create(Node.prototype);\n+ mixin(Element.prototype, {\n+ createShadowRoot: function() {\n+ var newShadowRoot = new wrappers.ShadowRoot(this);\n+ unsafeUnwrap(this).polymerShadowRoot_ = newShadowRoot;\n+ var renderer = scope.getRendererForHost(this);\n+ renderer.invalidate();\n+ return newShadowRoot;\n+ },\n+ get shadowRoot() {\n+ return unsafeUnwrap(this).polymerShadowRoot_ || null;\n+ },\n+ setAttribute: function(name, value) {\n+ var oldValue = unsafeUnwrap(this).getAttribute(name);\n+ unsafeUnwrap(this).setAttribute(name, value);\n+ enqueAttributeChange(this, name, oldValue);\n+ invalidateRendererBasedOnAttribute(this, name);\n+ },\n+ removeAttribute: function(name) {\n+ var oldValue = unsafeUnwrap(this).getAttribute(name);\n+ unsafeUnwrap(this).removeAttribute(name);\n+ enqueAttributeChange(this, name, oldValue);\n+ invalidateRendererBasedOnAttribute(this, name);\n+ },\n+ matches: function(selector) {\n+ return originalMatches.call(unsafeUnwrap(this), selector);\n+ },\n+ get classList() {\n+ var list = classListTable.get(this);\n+ if (!list) {\n+ classListTable.set(this, list = new DOMTokenList(unsafeUnwrap(this).classList, this));\n+ }\n+ return list;\n+ },\n+ get className() {\n+ return unsafeUnwrap(this).className;\n+ },\n+ set className(v) {\n+ this.setAttribute(\"class\", v);\n+ },\n+ get id() {\n+ return unsafeUnwrap(this).id;\n+ },\n+ set id(v) {\n+ this.setAttribute(\"id\", v);\n+ }\n+ });\n+ matchesNames.forEach(function(name) {\n+ if (name !== \"matches\") {\n+ Element.prototype[name] = function(selector) {\n+ return this.matches(selector);\n+ };\n+ }\n+ });\n+ if (OriginalElement.prototype.webkitCreateShadowRoot) {\n+ Element.prototype.webkitCreateShadowRoot = Element.prototype.createShadowRoot;\n+ }\n+ mixin(Element.prototype, ChildNodeInterface);\n+ mixin(Element.prototype, GetElementsByInterface);\n+ mixin(Element.prototype, ParentNodeInterface);\n+ mixin(Element.prototype, SelectorsInterface);\n+ registerWrapper(OriginalElement, Element, document.createElementNS(null, \"x\"));\n+ scope.invalidateRendererBasedOnAttribute = invalidateRendererBasedOnAttribute;\n+ scope.matchesNames = matchesNames;\n+ scope.wrappers.Element = Element;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var Element = scope.wrappers.Element;\n+ var defineGetter = scope.defineGetter;\n+ var enqueueMutation = scope.enqueueMutation;\n+ var mixin = scope.mixin;\n+ var nodesWereAdded = scope.nodesWereAdded;\n+ var nodesWereRemoved = scope.nodesWereRemoved;\n+ var registerWrapper = scope.registerWrapper;\n+ var snapshotNodeList = scope.snapshotNodeList;\n+ var unsafeUnwrap = scope.unsafeUnwrap;\n+ var unwrap = scope.unwrap;\n+ var wrap = scope.wrap;\n+ var wrappers = scope.wrappers;\n+ var escapeAttrRegExp = \/[&\\u00A0\"]\/g;\n+ var escapeDataRegExp = \/[&\\u00A0<>]\/g;\n+ function escapeReplace(c) {\n+ switch (c) {\n+ case \"&\":\n+ return \"&\";\n+\n+ case \"<\":\n+ return \"<\";\n+\n+ case \">\":\n+ return \">\";\n+\n+ case '\"':\n+ return \""\";\n+\n+ case \" \":\n+ return \" \";\n+ }\n+ }\n+ function escapeAttr(s) {\n+ return s.replace(escapeAttrRegExp, escapeReplace);\n+ }\n+ function escapeData(s) {\n+ return s.replace(escapeDataRegExp, escapeReplace);\n+ }\n+ function makeSet(arr) {\n+ var set = {};\n+ for (var i = 0; i < arr.length; i++) {\n+ set[arr[i]] = true;\n+ }\n+ return set;\n+ }\n+ var voidElements = makeSet([ \"area\", \"base\", \"br\", \"col\", \"command\", \"embed\", \"hr\", \"img\", \"input\", \"keygen\", \"link\", \"meta\", \"param\", \"source\", \"track\", \"wbr\" ]);\n+ var plaintextParents = makeSet([ \"style\", \"script\", \"xmp\", \"iframe\", \"noembed\", \"noframes\", \"plaintext\", \"noscript\" ]);\n+ function getOuterHTML(node, parentNode) {\n+ switch (node.nodeType) {\n+ case Node.ELEMENT_NODE:\n+ var tagName = node.tagName.toLowerCase();\n+ var s = \"<\" + tagName;\n+ var attrs = node.attributes;\n+ for (var i = 0, attr; attr = attrs[i]; i++) {\n+ s += \" \" + attr.name + '=\"' + escapeAttr(attr.value) + '\"';\n+ }\n+ s += \">\";\n+ if (voidElements[tagName]) return s;\n+ return s + getInnerHTML(node) + \"<\/\" + tagName + \">\";\n+\n+ case Node.TEXT_NODE:\n+ var data = node.data;\n+ if (parentNode && plaintextParents[parentNode.localName]) return data;\n+ return escapeData(data);\n+\n+ case Node.COMMENT_NODE:\n+ return \"\";\n+\n+ default:\n+ console.error(node);\n+ throw new Error(\"not implemented\");\n+ }\n+ }\n+ function getInnerHTML(node) {\n+ if (node instanceof wrappers.HTMLTemplateElement) node = node.content;\n+ var s = \"\";\n+ for (var child = node.firstChild; child; child = child.nextSibling) {\n+ s += getOuterHTML(child, node);\n+ }\n+ return s;\n+ }\n+ function setInnerHTML(node, value, opt_tagName) {\n+ var tagName = opt_tagName || \"div\";\n+ node.textContent = \"\";\n+ var tempElement = unwrap(node.ownerDocument.createElement(tagName));\n+ tempElement.innerHTML = value;\n+ var firstChild;\n+ while (firstChild = tempElement.firstChild) {\n+ node.appendChild(wrap(firstChild));\n+ }\n+ }\n+ var oldIe = \/MSIE\/.test(navigator.userAgent);\n+ var OriginalHTMLElement = window.HTMLElement;\n+ var OriginalHTMLTemplateElement = window.HTMLTemplateElement;\n+ function HTMLElement(node) {\n+ Element.call(this, node);\n+ }\n+ HTMLElement.prototype = Object.create(Element.prototype);\n+ mixin(HTMLElement.prototype, {\n+ get innerHTML() {\n+ return getInnerHTML(this);\n+ },\n+ set innerHTML(value) {\n+ if (oldIe && plaintextParents[this.localName]) {\n+ this.textContent = value;\n+ return;\n+ }\n+ var removedNodes = snapshotNodeList(this.childNodes);\n+ if (this.invalidateShadowRenderer()) {\n+ if (this instanceof wrappers.HTMLTemplateElement) setInnerHTML(this.content, value); else setInnerHTML(this, value, this.tagName);\n+ } else if (!OriginalHTMLTemplateElement && this instanceof wrappers.HTMLTemplateElement) {\n+ setInnerHTML(this.content, value);\n+ } else {\n+ unsafeUnwrap(this).innerHTML = value;\n+ }\n+ var addedNodes = snapshotNodeList(this.childNodes);\n+ enqueueMutation(this, \"childList\", {\n+ addedNodes: addedNodes,\n+ removedNodes: removedNodes\n+ });\n+ nodesWereRemoved(removedNodes);\n+ nodesWereAdded(addedNodes, this);\n+ },\n+ get outerHTML() {\n+ return getOuterHTML(this, this.parentNode);\n+ },\n+ set outerHTML(value) {\n+ var p = this.parentNode;\n+ if (p) {\n+ p.invalidateShadowRenderer();\n+ var df = frag(p, value);\n+ p.replaceChild(df, this);\n+ }\n+ },\n+ insertAdjacentHTML: function(position, text) {\n+ var contextElement, refNode;\n+ switch (String(position).toLowerCase()) {\n+ case \"beforebegin\":\n+ contextElement = this.parentNode;\n+ refNode = this;\n+ break;\n+\n+ case \"afterend\":\n+ contextElement = this.parentNode;\n+ refNode = this.nextSibling;\n+ break;\n+\n+ case \"afterbegin\":\n+ contextElement = this;\n+ refNode = this.firstChild;\n+ break;\n+\n+ case \"beforeend\":\n+ contextElement = this;\n+ refNode = null;\n+ break;\n+\n+ default:\n+ return;\n+ }\n+ var df = frag(contextElement, text);\n+ contextElement.insertBefore(df, refNode);\n+ },\n+ get hidden() {\n+ return this.hasAttribute(\"hidden\");\n+ },\n+ set hidden(v) {\n+ if (v) {\n+ this.setAttribute(\"hidden\", \"\");\n+ } else {\n+ this.removeAttribute(\"hidden\");\n+ }\n+ }\n+ });\n+ function frag(contextElement, html) {\n+ var p = unwrap(contextElement.cloneNode(false));\n+ p.innerHTML = html;\n+ var df = unwrap(document.createDocumentFragment());\n+ var c;\n+ while (c = p.firstChild) {\n+ df.appendChild(c);\n+ }\n+ return wrap(df);\n+ }\n+ function getter(name) {\n+ return function() {\n+ scope.renderAllPending();\n+ return unsafeUnwrap(this)[name];\n+ };\n+ }\n+ function getterRequiresRendering(name) {\n+ defineGetter(HTMLElement, name, getter(name));\n+ }\n+ [ \"clientHeight\", \"clientLeft\", \"clientTop\", \"clientWidth\", \"offsetHeight\", \"offsetLeft\", \"offsetTop\", \"offsetWidth\", \"scrollHeight\", \"scrollWidth\" ].forEach(getterRequiresRendering);\n+ function getterAndSetterRequiresRendering(name) {\n+ Object.defineProperty(HTMLElement.prototype, name, {\n+ get: getter(name),\n+ set: function(v) {\n+ scope.renderAllPending();\n+ unsafeUnwrap(this)[name] = v;\n+ },\n+ configurable: true,\n+ enumerable: true\n+ });\n+ }\n+ [ \"scrollLeft\", \"scrollTop\" ].forEach(getterAndSetterRequiresRendering);\n+ function methodRequiresRendering(name) {\n+ Object.defineProperty(HTMLElement.prototype, name, {\n+ value: function() {\n+ scope.renderAllPending();\n+ return unsafeUnwrap(this)[name].apply(unsafeUnwrap(this), arguments);\n+ },\n+ configurable: true,\n+ enumerable: true\n+ });\n+ }\n+ [ \"getBoundingClientRect\", \"getClientRects\", \"scrollIntoView\" ].forEach(methodRequiresRendering);\n+ registerWrapper(OriginalHTMLElement, HTMLElement, document.createElement(\"b\"));\n+ scope.wrappers.HTMLElement = HTMLElement;\n+ scope.getInnerHTML = getInnerHTML;\n+ scope.setInnerHTML = setInnerHTML;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var HTMLElement = scope.wrappers.HTMLElement;\n+ var mixin = scope.mixin;\n+ var registerWrapper = scope.registerWrapper;\n+ var unsafeUnwrap = scope.unsafeUnwrap;\n+ var wrap = scope.wrap;\n+ var OriginalHTMLCanvasElement = window.HTMLCanvasElement;\n+ function HTMLCanvasElement(node) {\n+ HTMLElement.call(this, node);\n+ }\n+ HTMLCanvasElement.prototype = Object.create(HTMLElement.prototype);\n+ mixin(HTMLCanvasElement.prototype, {\n+ getContext: function() {\n+ var context = unsafeUnwrap(this).getContext.apply(unsafeUnwrap(this), arguments);\n+ return context && wrap(context);\n+ }\n+ });\n+ registerWrapper(OriginalHTMLCanvasElement, HTMLCanvasElement, document.createElement(\"canvas\"));\n+ scope.wrappers.HTMLCanvasElement = HTMLCanvasElement;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var HTMLElement = scope.wrappers.HTMLElement;\n+ var mixin = scope.mixin;\n+ var registerWrapper = scope.registerWrapper;\n+ var OriginalHTMLContentElement = window.HTMLContentElement;\n+ function HTMLContentElement(node) {\n+ HTMLElement.call(this, node);\n+ }\n+ HTMLContentElement.prototype = Object.create(HTMLElement.prototype);\n+ mixin(HTMLContentElement.prototype, {\n+ constructor: HTMLContentElement,\n+ get select() {\n+ return this.getAttribute(\"select\");\n+ },\n+ set select(value) {\n+ this.setAttribute(\"select\", value);\n+ },\n+ setAttribute: function(n, v) {\n+ HTMLElement.prototype.setAttribute.call(this, n, v);\n+ if (String(n).toLowerCase() === \"select\") this.invalidateShadowRenderer(true);\n+ }\n+ });\n+ if (OriginalHTMLContentElement) registerWrapper(OriginalHTMLContentElement, HTMLContentElement);\n+ scope.wrappers.HTMLContentElement = HTMLContentElement;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var HTMLElement = scope.wrappers.HTMLElement;\n+ var mixin = scope.mixin;\n+ var registerWrapper = scope.registerWrapper;\n+ var wrapHTMLCollection = scope.wrapHTMLCollection;\n+ var unwrap = scope.unwrap;\n+ var OriginalHTMLFormElement = window.HTMLFormElement;\n+ function HTMLFormElement(node) {\n+ HTMLElement.call(this, node);\n+ }\n+ HTMLFormElement.prototype = Object.create(HTMLElement.prototype);\n+ mixin(HTMLFormElement.prototype, {\n+ get elements() {\n+ return wrapHTMLCollection(unwrap(this).elements);\n+ }\n+ });\n+ registerWrapper(OriginalHTMLFormElement, HTMLFormElement, document.createElement(\"form\"));\n+ scope.wrappers.HTMLFormElement = HTMLFormElement;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var HTMLElement = scope.wrappers.HTMLElement;\n+ var registerWrapper = scope.registerWrapper;\n+ var unwrap = scope.unwrap;\n+ var rewrap = scope.rewrap;\n+ var OriginalHTMLImageElement = window.HTMLImageElement;\n+ function HTMLImageElement(node) {\n+ HTMLElement.call(this, node);\n+ }\n+ HTMLImageElement.prototype = Object.create(HTMLElement.prototype);\n+ registerWrapper(OriginalHTMLImageElement, HTMLImageElement, document.createElement(\"img\"));\n+ function Image(width, height) {\n+ if (!(this instanceof Image)) {\n+ throw new TypeError(\"DOM object constructor cannot be called as a function.\");\n+ }\n+ var node = unwrap(document.createElement(\"img\"));\n+ HTMLElement.call(this, node);\n+ rewrap(node, this);\n+ if (width !== undefined) node.width = width;\n+ if (height !== undefined) node.height = height;\n+ }\n+ Image.prototype = HTMLImageElement.prototype;\n+ scope.wrappers.HTMLImageElement = HTMLImageElement;\n+ scope.wrappers.Image = Image;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var HTMLElement = scope.wrappers.HTMLElement;\n+ var mixin = scope.mixin;\n+ var NodeList = scope.wrappers.NodeList;\n+ var registerWrapper = scope.registerWrapper;\n+ var OriginalHTMLShadowElement = window.HTMLShadowElement;\n+ function HTMLShadowElement(node) {\n+ HTMLElement.call(this, node);\n+ }\n+ HTMLShadowElement.prototype = Object.create(HTMLElement.prototype);\n+ HTMLShadowElement.prototype.constructor = HTMLShadowElement;\n+ if (OriginalHTMLShadowElement) registerWrapper(OriginalHTMLShadowElement, HTMLShadowElement);\n+ scope.wrappers.HTMLShadowElement = HTMLShadowElement;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var HTMLElement = scope.wrappers.HTMLElement;\n+ var mixin = scope.mixin;\n+ var registerWrapper = scope.registerWrapper;\n+ var unsafeUnwrap = scope.unsafeUnwrap;\n+ var unwrap = scope.unwrap;\n+ var wrap = scope.wrap;\n+ var contentTable = new WeakMap();\n+ var templateContentsOwnerTable = new WeakMap();\n+ function getTemplateContentsOwner(doc) {\n+ if (!doc.defaultView) return doc;\n+ var d = templateContentsOwnerTable.get(doc);\n+ if (!d) {\n+ d = doc.implementation.createHTMLDocument(\"\");\n+ while (d.lastChild) {\n+ d.removeChild(d.lastChild);\n+ }\n+ templateContentsOwnerTable.set(doc, d);\n+ }\n+ return d;\n+ }\n+ function extractContent(templateElement) {\n+ var doc = getTemplateContentsOwner(templateElement.ownerDocument);\n+ var df = unwrap(doc.createDocumentFragment());\n+ var child;\n+ while (child = templateElement.firstChild) {\n+ df.appendChild(child);\n+ }\n+ return df;\n+ }\n+ var OriginalHTMLTemplateElement = window.HTMLTemplateElement;\n+ function HTMLTemplateElement(node) {\n+ HTMLElement.call(this, node);\n+ if (!OriginalHTMLTemplateElement) {\n+ var content = extractContent(node);\n+ contentTable.set(this, wrap(content));\n+ }\n+ }\n+ HTMLTemplateElement.prototype = Object.create(HTMLElement.prototype);\n+ mixin(HTMLTemplateElement.prototype, {\n+ constructor: HTMLTemplateElement,\n+ get content() {\n+ if (OriginalHTMLTemplateElement) return wrap(unsafeUnwrap(this).content);\n+ return contentTable.get(this);\n+ }\n+ });\n+ if (OriginalHTMLTemplateElement) registerWrapper(OriginalHTMLTemplateElement, HTMLTemplateElement);\n+ scope.wrappers.HTMLTemplateElement = HTMLTemplateElement;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var HTMLElement = scope.wrappers.HTMLElement;\n+ var registerWrapper = scope.registerWrapper;\n+ var OriginalHTMLMediaElement = window.HTMLMediaElement;\n+ if (!OriginalHTMLMediaElement) return;\n+ function HTMLMediaElement(node) {\n+ HTMLElement.call(this, node);\n+ }\n+ HTMLMediaElement.prototype = Object.create(HTMLElement.prototype);\n+ registerWrapper(OriginalHTMLMediaElement, HTMLMediaElement, document.createElement(\"audio\"));\n+ scope.wrappers.HTMLMediaElement = HTMLMediaElement;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var HTMLMediaElement = scope.wrappers.HTMLMediaElement;\n+ var registerWrapper = scope.registerWrapper;\n+ var unwrap = scope.unwrap;\n+ var rewrap = scope.rewrap;\n+ var OriginalHTMLAudioElement = window.HTMLAudioElement;\n+ if (!OriginalHTMLAudioElement) return;\n+ function HTMLAudioElement(node) {\n+ HTMLMediaElement.call(this, node);\n+ }\n+ HTMLAudioElement.prototype = Object.create(HTMLMediaElement.prototype);\n+ registerWrapper(OriginalHTMLAudioElement, HTMLAudioElement, document.createElement(\"audio\"));\n+ function Audio(src) {\n+ if (!(this instanceof Audio)) {\n+ throw new TypeError(\"DOM object constructor cannot be called as a function.\");\n+ }\n+ var node = unwrap(document.createElement(\"audio\"));\n+ HTMLMediaElement.call(this, node);\n+ rewrap(node, this);\n+ node.setAttribute(\"preload\", \"auto\");\n+ if (src !== undefined) node.setAttribute(\"src\", src);\n+ }\n+ Audio.prototype = HTMLAudioElement.prototype;\n+ scope.wrappers.HTMLAudioElement = HTMLAudioElement;\n+ scope.wrappers.Audio = Audio;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var HTMLElement = scope.wrappers.HTMLElement;\n+ var mixin = scope.mixin;\n+ var registerWrapper = scope.registerWrapper;\n+ var rewrap = scope.rewrap;\n+ var unwrap = scope.unwrap;\n+ var wrap = scope.wrap;\n+ var OriginalHTMLOptionElement = window.HTMLOptionElement;\n+ function trimText(s) {\n+ return s.replace(\/\\s+\/g, \" \").trim();\n+ }\n+ function HTMLOptionElement(node) {\n+ HTMLElement.call(this, node);\n+ }\n+ HTMLOptionElement.prototype = Object.create(HTMLElement.prototype);\n+ mixin(HTMLOptionElement.prototype, {\n+ get text() {\n+ return trimText(this.textContent);\n+ },\n+ set text(value) {\n+ this.textContent = trimText(String(value));\n+ },\n+ get form() {\n+ return wrap(unwrap(this).form);\n+ }\n+ });\n+ registerWrapper(OriginalHTMLOptionElement, HTMLOptionElement, document.createElement(\"option\"));\n+ function Option(text, value, defaultSelected, selected) {\n+ if (!(this instanceof Option)) {\n+ throw new TypeError(\"DOM object constructor cannot be called as a function.\");\n+ }\n+ var node = unwrap(document.createElement(\"option\"));\n+ HTMLElement.call(this, node);\n+ rewrap(node, this);\n+ if (text !== undefined) node.text = text;\n+ if (value !== undefined) node.setAttribute(\"value\", value);\n+ if (defaultSelected === true) node.setAttribute(\"selected\", \"\");\n+ node.selected = selected === true;\n+ }\n+ Option.prototype = HTMLOptionElement.prototype;\n+ scope.wrappers.HTMLOptionElement = HTMLOptionElement;\n+ scope.wrappers.Option = Option;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var HTMLElement = scope.wrappers.HTMLElement;\n+ var mixin = scope.mixin;\n+ var registerWrapper = scope.registerWrapper;\n+ var unwrap = scope.unwrap;\n+ var wrap = scope.wrap;\n+ var OriginalHTMLSelectElement = window.HTMLSelectElement;\n+ function HTMLSelectElement(node) {\n+ HTMLElement.call(this, node);\n+ }\n+ HTMLSelectElement.prototype = Object.create(HTMLElement.prototype);\n+ mixin(HTMLSelectElement.prototype, {\n+ add: function(element, before) {\n+ if (typeof before === \"object\") before = unwrap(before);\n+ unwrap(this).add(unwrap(element), before);\n+ },\n+ remove: function(indexOrNode) {\n+ if (indexOrNode === undefined) {\n+ HTMLElement.prototype.remove.call(this);\n+ return;\n+ }\n+ if (typeof indexOrNode === \"object\") indexOrNode = unwrap(indexOrNode);\n+ unwrap(this).remove(indexOrNode);\n+ },\n+ get form() {\n+ return wrap(unwrap(this).form);\n+ }\n+ });\n+ registerWrapper(OriginalHTMLSelectElement, HTMLSelectElement, document.createElement(\"select\"));\n+ scope.wrappers.HTMLSelectElement = HTMLSelectElement;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var HTMLElement = scope.wrappers.HTMLElement;\n+ var mixin = scope.mixin;\n+ var registerWrapper = scope.registerWrapper;\n+ var unwrap = scope.unwrap;\n+ var wrap = scope.wrap;\n+ var wrapHTMLCollection = scope.wrapHTMLCollection;\n+ var OriginalHTMLTableElement = window.HTMLTableElement;\n+ function HTMLTableElement(node) {\n+ HTMLElement.call(this, node);\n+ }\n+ HTMLTableElement.prototype = Object.create(HTMLElement.prototype);\n+ mixin(HTMLTableElement.prototype, {\n+ get caption() {\n+ return wrap(unwrap(this).caption);\n+ },\n+ createCaption: function() {\n+ return wrap(unwrap(this).createCaption());\n+ },\n+ get tHead() {\n+ return wrap(unwrap(this).tHead);\n+ },\n+ createTHead: function() {\n+ return wrap(unwrap(this).createTHead());\n+ },\n+ createTFoot: function() {\n+ return wrap(unwrap(this).createTFoot());\n+ },\n+ get tFoot() {\n+ return wrap(unwrap(this).tFoot);\n+ },\n+ get tBodies() {\n+ return wrapHTMLCollection(unwrap(this).tBodies);\n+ },\n+ createTBody: function() {\n+ return wrap(unwrap(this).createTBody());\n+ },\n+ get rows() {\n+ return wrapHTMLCollection(unwrap(this).rows);\n+ },\n+ insertRow: function(index) {\n+ return wrap(unwrap(this).insertRow(index));\n+ }\n+ });\n+ registerWrapper(OriginalHTMLTableElement, HTMLTableElement, document.createElement(\"table\"));\n+ scope.wrappers.HTMLTableElement = HTMLTableElement;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var HTMLElement = scope.wrappers.HTMLElement;\n+ var mixin = scope.mixin;\n+ var registerWrapper = scope.registerWrapper;\n+ var wrapHTMLCollection = scope.wrapHTMLCollection;\n+ var unwrap = scope.unwrap;\n+ var wrap = scope.wrap;\n+ var OriginalHTMLTableSectionElement = window.HTMLTableSectionElement;\n+ function HTMLTableSectionElement(node) {\n+ HTMLElement.call(this, node);\n+ }\n+ HTMLTableSectionElement.prototype = Object.create(HTMLElement.prototype);\n+ mixin(HTMLTableSectionElement.prototype, {\n+ constructor: HTMLTableSectionElement,\n+ get rows() {\n+ return wrapHTMLCollection(unwrap(this).rows);\n+ },\n+ insertRow: function(index) {\n+ return wrap(unwrap(this).insertRow(index));\n+ }\n+ });\n+ registerWrapper(OriginalHTMLTableSectionElement, HTMLTableSectionElement, document.createElement(\"thead\"));\n+ scope.wrappers.HTMLTableSectionElement = HTMLTableSectionElement;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var HTMLElement = scope.wrappers.HTMLElement;\n+ var mixin = scope.mixin;\n+ var registerWrapper = scope.registerWrapper;\n+ var wrapHTMLCollection = scope.wrapHTMLCollection;\n+ var unwrap = scope.unwrap;\n+ var wrap = scope.wrap;\n+ var OriginalHTMLTableRowElement = window.HTMLTableRowElement;\n+ function HTMLTableRowElement(node) {\n+ HTMLElement.call(this, node);\n+ }\n+ HTMLTableRowElement.prototype = Object.create(HTMLElement.prototype);\n+ mixin(HTMLTableRowElement.prototype, {\n+ get cells() {\n+ return wrapHTMLCollection(unwrap(this).cells);\n+ },\n+ insertCell: function(index) {\n+ return wrap(unwrap(this).insertCell(index));\n+ }\n+ });\n+ registerWrapper(OriginalHTMLTableRowElement, HTMLTableRowElement, document.createElement(\"tr\"));\n+ scope.wrappers.HTMLTableRowElement = HTMLTableRowElement;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var HTMLContentElement = scope.wrappers.HTMLContentElement;\n+ var HTMLElement = scope.wrappers.HTMLElement;\n+ var HTMLShadowElement = scope.wrappers.HTMLShadowElement;\n+ var HTMLTemplateElement = scope.wrappers.HTMLTemplateElement;\n+ var mixin = scope.mixin;\n+ var registerWrapper = scope.registerWrapper;\n+ var OriginalHTMLUnknownElement = window.HTMLUnknownElement;\n+ function HTMLUnknownElement(node) {\n+ switch (node.localName) {\n+ case \"content\":\n+ return new HTMLContentElement(node);\n+\n+ case \"shadow\":\n+ return new HTMLShadowElement(node);\n+\n+ case \"template\":\n+ return new HTMLTemplateElement(node);\n+ }\n+ HTMLElement.call(this, node);\n+ }\n+ HTMLUnknownElement.prototype = Object.create(HTMLElement.prototype);\n+ registerWrapper(OriginalHTMLUnknownElement, HTMLUnknownElement);\n+ scope.wrappers.HTMLUnknownElement = HTMLUnknownElement;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var Element = scope.wrappers.Element;\n+ var HTMLElement = scope.wrappers.HTMLElement;\n+ var registerObject = scope.registerObject;\n+ var SVG_NS = \"http:\/\/www.w3.org\/2000\/svg\";\n+ var svgTitleElement = document.createElementNS(SVG_NS, \"title\");\n+ var SVGTitleElement = registerObject(svgTitleElement);\n+ var SVGElement = Object.getPrototypeOf(SVGTitleElement.prototype).constructor;\n+ if (!(\"classList\" in svgTitleElement)) {\n+ var descr = Object.getOwnPropertyDescriptor(Element.prototype, \"classList\");\n+ Object.defineProperty(HTMLElement.prototype, \"classList\", descr);\n+ delete Element.prototype.classList;\n+ }\n+ scope.wrappers.SVGElement = SVGElement;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var mixin = scope.mixin;\n+ var registerWrapper = scope.registerWrapper;\n+ var unwrap = scope.unwrap;\n+ var wrap = scope.wrap;\n+ var OriginalSVGUseElement = window.SVGUseElement;\n+ var SVG_NS = \"http:\/\/www.w3.org\/2000\/svg\";\n+ var gWrapper = wrap(document.createElementNS(SVG_NS, \"g\"));\n+ var useElement = document.createElementNS(SVG_NS, \"use\");\n+ var SVGGElement = gWrapper.constructor;\n+ var parentInterfacePrototype = Object.getPrototypeOf(SVGGElement.prototype);\n+ var parentInterface = parentInterfacePrototype.constructor;\n+ function SVGUseElement(impl) {\n+ parentInterface.call(this, impl);\n+ }\n+ SVGUseElement.prototype = Object.create(parentInterfacePrototype);\n+ if (\"instanceRoot\" in useElement) {\n+ mixin(SVGUseElement.prototype, {\n+ get instanceRoot() {\n+ return wrap(unwrap(this).instanceRoot);\n+ },\n+ get animatedInstanceRoot() {\n+ return wrap(unwrap(this).animatedInstanceRoot);\n+ }\n+ });\n+ }\n+ registerWrapper(OriginalSVGUseElement, SVGUseElement, useElement);\n+ scope.wrappers.SVGUseElement = SVGUseElement;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var EventTarget = scope.wrappers.EventTarget;\n+ var mixin = scope.mixin;\n+ var registerWrapper = scope.registerWrapper;\n+ var unsafeUnwrap = scope.unsafeUnwrap;\n+ var wrap = scope.wrap;\n+ var OriginalSVGElementInstance = window.SVGElementInstance;\n+ if (!OriginalSVGElementInstance) return;\n+ function SVGElementInstance(impl) {\n+ EventTarget.call(this, impl);\n+ }\n+ SVGElementInstance.prototype = Object.create(EventTarget.prototype);\n+ mixin(SVGElementInstance.prototype, {\n+ get correspondingElement() {\n+ return wrap(unsafeUnwrap(this).correspondingElement);\n+ },\n+ get correspondingUseElement() {\n+ return wrap(unsafeUnwrap(this).correspondingUseElement);\n+ },\n+ get parentNode() {\n+ return wrap(unsafeUnwrap(this).parentNode);\n+ },\n+ get childNodes() {\n+ throw new Error(\"Not implemented\");\n+ },\n+ get firstChild() {\n+ return wrap(unsafeUnwrap(this).firstChild);\n+ },\n+ get lastChild() {\n+ return wrap(unsafeUnwrap(this).lastChild);\n+ },\n+ get previousSibling() {\n+ return wrap(unsafeUnwrap(this).previousSibling);\n+ },\n+ get nextSibling() {\n+ return wrap(unsafeUnwrap(this).nextSibling);\n+ }\n+ });\n+ registerWrapper(OriginalSVGElementInstance, SVGElementInstance);\n+ scope.wrappers.SVGElementInstance = SVGElementInstance;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var mixin = scope.mixin;\n+ var registerWrapper = scope.registerWrapper;\n+ var setWrapper = scope.setWrapper;\n+ var unsafeUnwrap = scope.unsafeUnwrap;\n+ var unwrap = scope.unwrap;\n+ var unwrapIfNeeded = scope.unwrapIfNeeded;\n+ var wrap = scope.wrap;\n+ var OriginalCanvasRenderingContext2D = window.CanvasRenderingContext2D;\n+ function CanvasRenderingContext2D(impl) {\n+ setWrapper(impl, this);\n+ }\n+ mixin(CanvasRenderingContext2D.prototype, {\n+ get canvas() {\n+ return wrap(unsafeUnwrap(this).canvas);\n+ },\n+ drawImage: function() {\n+ arguments[0] = unwrapIfNeeded(arguments[0]);\n+ unsafeUnwrap(this).drawImage.apply(unsafeUnwrap(this), arguments);\n+ },\n+ createPattern: function() {\n+ arguments[0] = unwrap(arguments[0]);\n+ return unsafeUnwrap(this).createPattern.apply(unsafeUnwrap(this), arguments);\n+ }\n+ });\n+ registerWrapper(OriginalCanvasRenderingContext2D, CanvasRenderingContext2D, document.createElement(\"canvas\").getContext(\"2d\"));\n+ scope.wrappers.CanvasRenderingContext2D = CanvasRenderingContext2D;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var mixin = scope.mixin;\n+ var registerWrapper = scope.registerWrapper;\n+ var setWrapper = scope.setWrapper;\n+ var unsafeUnwrap = scope.unsafeUnwrap;\n+ var unwrapIfNeeded = scope.unwrapIfNeeded;\n+ var wrap = scope.wrap;\n+ var OriginalWebGLRenderingContext = window.WebGLRenderingContext;\n+ if (!OriginalWebGLRenderingContext) return;\n+ function WebGLRenderingContext(impl) {\n+ setWrapper(impl, this);\n+ }\n+ mixin(WebGLRenderingContext.prototype, {\n+ get canvas() {\n+ return wrap(unsafeUnwrap(this).canvas);\n+ },\n+ texImage2D: function() {\n+ arguments[5] = unwrapIfNeeded(arguments[5]);\n+ unsafeUnwrap(this).texImage2D.apply(unsafeUnwrap(this), arguments);\n+ },\n+ texSubImage2D: function() {\n+ arguments[6] = unwrapIfNeeded(arguments[6]);\n+ unsafeUnwrap(this).texSubImage2D.apply(unsafeUnwrap(this), arguments);\n+ }\n+ });\n+ var instanceProperties = \/WebKit\/.test(navigator.userAgent) ? {\n+ drawingBufferHeight: null,\n+ drawingBufferWidth: null\n+ } : {};\n+ registerWrapper(OriginalWebGLRenderingContext, WebGLRenderingContext, instanceProperties);\n+ scope.wrappers.WebGLRenderingContext = WebGLRenderingContext;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var registerWrapper = scope.registerWrapper;\n+ var setWrapper = scope.setWrapper;\n+ var unsafeUnwrap = scope.unsafeUnwrap;\n+ var unwrap = scope.unwrap;\n+ var unwrapIfNeeded = scope.unwrapIfNeeded;\n+ var wrap = scope.wrap;\n+ var OriginalRange = window.Range;\n+ function Range(impl) {\n+ setWrapper(impl, this);\n+ }\n+ Range.prototype = {\n+ get startContainer() {\n+ return wrap(unsafeUnwrap(this).startContainer);\n+ },\n+ get endContainer() {\n+ return wrap(unsafeUnwrap(this).endContainer);\n+ },\n+ get commonAncestorContainer() {\n+ return wrap(unsafeUnwrap(this).commonAncestorContainer);\n+ },\n+ setStart: function(refNode, offset) {\n+ unsafeUnwrap(this).setStart(unwrapIfNeeded(refNode), offset);\n+ },\n+ setEnd: function(refNode, offset) {\n+ unsafeUnwrap(this).setEnd(unwrapIfNeeded(refNode), offset);\n+ },\n+ setStartBefore: function(refNode) {\n+ unsafeUnwrap(this).setStartBefore(unwrapIfNeeded(refNode));\n+ },\n+ setStartAfter: function(refNode) {\n+ unsafeUnwrap(this).setStartAfter(unwrapIfNeeded(refNode));\n+ },\n+ setEndBefore: function(refNode) {\n+ unsafeUnwrap(this).setEndBefore(unwrapIfNeeded(refNode));\n+ },\n+ setEndAfter: function(refNode) {\n+ unsafeUnwrap(this).setEndAfter(unwrapIfNeeded(refNode));\n+ },\n+ selectNode: function(refNode) {\n+ unsafeUnwrap(this).selectNode(unwrapIfNeeded(refNode));\n+ },\n+ selectNodeContents: function(refNode) {\n+ unsafeUnwrap(this).selectNodeContents(unwrapIfNeeded(refNode));\n+ },\n+ compareBoundaryPoints: function(how, sourceRange) {\n+ return unsafeUnwrap(this).compareBoundaryPoints(how, unwrap(sourceRange));\n+ },\n+ extractContents: function() {\n+ return wrap(unsafeUnwrap(this).extractContents());\n+ },\n+ cloneContents: function() {\n+ return wrap(unsafeUnwrap(this).cloneContents());\n+ },\n+ insertNode: function(node) {\n+ unsafeUnwrap(this).insertNode(unwrapIfNeeded(node));\n+ },\n+ surroundContents: function(newParent) {\n+ unsafeUnwrap(this).surroundContents(unwrapIfNeeded(newParent));\n+ },\n+ cloneRange: function() {\n+ return wrap(unsafeUnwrap(this).cloneRange());\n+ },\n+ isPointInRange: function(node, offset) {\n+ return unsafeUnwrap(this).isPointInRange(unwrapIfNeeded(node), offset);\n+ },\n+ comparePoint: function(node, offset) {\n+ return unsafeUnwrap(this).comparePoint(unwrapIfNeeded(node), offset);\n+ },\n+ intersectsNode: function(node) {\n+ return unsafeUnwrap(this).intersectsNode(unwrapIfNeeded(node));\n+ },\n+ toString: function() {\n+ return unsafeUnwrap(this).toString();\n+ }\n+ };\n+ if (OriginalRange.prototype.createContextualFragment) {\n+ Range.prototype.createContextualFragment = function(html) {\n+ return wrap(unsafeUnwrap(this).createContextualFragment(html));\n+ };\n+ }\n+ registerWrapper(window.Range, Range, document.createRange());\n+ scope.wrappers.Range = Range;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var GetElementsByInterface = scope.GetElementsByInterface;\n+ var ParentNodeInterface = scope.ParentNodeInterface;\n+ var SelectorsInterface = scope.SelectorsInterface;\n+ var mixin = scope.mixin;\n+ var registerObject = scope.registerObject;\n+ var DocumentFragment = registerObject(document.createDocumentFragment());\n+ mixin(DocumentFragment.prototype, ParentNodeInterface);\n+ mixin(DocumentFragment.prototype, SelectorsInterface);\n+ mixin(DocumentFragment.prototype, GetElementsByInterface);\n+ var Comment = registerObject(document.createComment(\"\"));\n+ scope.wrappers.Comment = Comment;\n+ scope.wrappers.DocumentFragment = DocumentFragment;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var DocumentFragment = scope.wrappers.DocumentFragment;\n+ var TreeScope = scope.TreeScope;\n+ var elementFromPoint = scope.elementFromPoint;\n+ var getInnerHTML = scope.getInnerHTML;\n+ var getTreeScope = scope.getTreeScope;\n+ var mixin = scope.mixin;\n+ var rewrap = scope.rewrap;\n+ var setInnerHTML = scope.setInnerHTML;\n+ var unsafeUnwrap = scope.unsafeUnwrap;\n+ var unwrap = scope.unwrap;\n+ var shadowHostTable = new WeakMap();\n+ var nextOlderShadowTreeTable = new WeakMap();\n+ var spaceCharRe = \/[ \\t\\n\\r\\f]\/;\n+ function ShadowRoot(hostWrapper) {\n+ var node = unwrap(unsafeUnwrap(hostWrapper).ownerDocument.createDocumentFragment());\n+ DocumentFragment.call(this, node);\n+ rewrap(node, this);\n+ var oldShadowRoot = hostWrapper.shadowRoot;\n+ nextOlderShadowTreeTable.set(this, oldShadowRoot);\n+ this.treeScope_ = new TreeScope(this, getTreeScope(oldShadowRoot || hostWrapper));\n+ shadowHostTable.set(this, hostWrapper);\n+ }\n+ ShadowRoot.prototype = Object.create(DocumentFragment.prototype);\n+ mixin(ShadowRoot.prototype, {\n+ constructor: ShadowRoot,\n+ get innerHTML() {\n+ return getInnerHTML(this);\n+ },\n+ set innerHTML(value) {\n+ setInnerHTML(this, value);\n+ this.invalidateShadowRenderer();\n+ },\n+ get olderShadowRoot() {\n+ return nextOlderShadowTreeTable.get(this) || null;\n+ },\n+ get host() {\n+ return shadowHostTable.get(this) || null;\n+ },\n+ invalidateShadowRenderer: function() {\n+ return shadowHostTable.get(this).invalidateShadowRenderer();\n+ },\n+ elementFromPoint: function(x, y) {\n+ return elementFromPoint(this, this.ownerDocument, x, y);\n+ },\n+ getElementById: function(id) {\n+ if (spaceCharRe.test(id)) return null;\n+ return this.querySelector('[id=\"' + id + '\"]');\n+ }\n+ });\n+ scope.wrappers.ShadowRoot = ShadowRoot;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var Element = scope.wrappers.Element;\n+ var HTMLContentElement = scope.wrappers.HTMLContentElement;\n+ var HTMLShadowElement = scope.wrappers.HTMLShadowElement;\n+ var Node = scope.wrappers.Node;\n+ var ShadowRoot = scope.wrappers.ShadowRoot;\n+ var assert = scope.assert;\n+ var getTreeScope = scope.getTreeScope;\n+ var mixin = scope.mixin;\n+ var oneOf = scope.oneOf;\n+ var unsafeUnwrap = scope.unsafeUnwrap;\n+ var unwrap = scope.unwrap;\n+ var wrap = scope.wrap;\n+ var ArraySplice = scope.ArraySplice;\n+ function updateWrapperUpAndSideways(wrapper) {\n+ wrapper.previousSibling_ = wrapper.previousSibling;\n+ wrapper.nextSibling_ = wrapper.nextSibling;\n+ wrapper.parentNode_ = wrapper.parentNode;\n+ }\n+ function updateWrapperDown(wrapper) {\n+ wrapper.firstChild_ = wrapper.firstChild;\n+ wrapper.lastChild_ = wrapper.lastChild;\n+ }\n+ function updateAllChildNodes(parentNodeWrapper) {\n+ assert(parentNodeWrapper instanceof Node);\n+ for (var childWrapper = parentNodeWrapper.firstChild; childWrapper; childWrapper = childWrapper.nextSibling) {\n+ updateWrapperUpAndSideways(childWrapper);\n+ }\n+ updateWrapperDown(parentNodeWrapper);\n+ }\n+ function insertBefore(parentNodeWrapper, newChildWrapper, refChildWrapper) {\n+ var parentNode = unwrap(parentNodeWrapper);\n+ var newChild = unwrap(newChildWrapper);\n+ var refChild = refChildWrapper ? unwrap(refChildWrapper) : null;\n+ remove(newChildWrapper);\n+ updateWrapperUpAndSideways(newChildWrapper);\n+ if (!refChildWrapper) {\n+ parentNodeWrapper.lastChild_ = parentNodeWrapper.lastChild;\n+ if (parentNodeWrapper.lastChild === parentNodeWrapper.firstChild) parentNodeWrapper.firstChild_ = parentNodeWrapper.firstChild;\n+ var lastChildWrapper = wrap(parentNode.lastChild);\n+ if (lastChildWrapper) lastChildWrapper.nextSibling_ = lastChildWrapper.nextSibling;\n+ } else {\n+ if (parentNodeWrapper.firstChild === refChildWrapper) parentNodeWrapper.firstChild_ = refChildWrapper;\n+ refChildWrapper.previousSibling_ = refChildWrapper.previousSibling;\n+ }\n+ scope.originalInsertBefore.call(parentNode, newChild, refChild);\n+ }\n+ function remove(nodeWrapper) {\n+ var node = unwrap(nodeWrapper);\n+ var parentNode = node.parentNode;\n+ if (!parentNode) return;\n+ var parentNodeWrapper = wrap(parentNode);\n+ updateWrapperUpAndSideways(nodeWrapper);\n+ if (nodeWrapper.previousSibling) nodeWrapper.previousSibling.nextSibling_ = nodeWrapper;\n+ if (nodeWrapper.nextSibling) nodeWrapper.nextSibling.previousSibling_ = nodeWrapper;\n+ if (parentNodeWrapper.lastChild === nodeWrapper) parentNodeWrapper.lastChild_ = nodeWrapper;\n+ if (parentNodeWrapper.firstChild === nodeWrapper) parentNodeWrapper.firstChild_ = nodeWrapper;\n+ scope.originalRemoveChild.call(parentNode, node);\n+ }\n+ var distributedNodesTable = new WeakMap();\n+ var destinationInsertionPointsTable = new WeakMap();\n+ var rendererForHostTable = new WeakMap();\n+ function resetDistributedNodes(insertionPoint) {\n+ distributedNodesTable.set(insertionPoint, []);\n+ }\n+ function getDistributedNodes(insertionPoint) {\n+ var rv = distributedNodesTable.get(insertionPoint);\n+ if (!rv) distributedNodesTable.set(insertionPoint, rv = []);\n+ return rv;\n+ }\n+ function getChildNodesSnapshot(node) {\n+ var result = [], i = 0;\n+ for (var child = node.firstChild; child; child = child.nextSibling) {\n+ result[i++] = child;\n+ }\n+ return result;\n+ }\n+ var request = oneOf(window, [ \"requestAnimationFrame\", \"mozRequestAnimationFrame\", \"webkitRequestAnimationFrame\", \"setTimeout\" ]);\n+ var pendingDirtyRenderers = [];\n+ var renderTimer;\n+ function renderAllPending() {\n+ for (var i = 0; i < pendingDirtyRenderers.length; i++) {\n+ var renderer = pendingDirtyRenderers[i];\n+ var parentRenderer = renderer.parentRenderer;\n+ if (parentRenderer && parentRenderer.dirty) continue;\n+ renderer.render();\n+ }\n+ pendingDirtyRenderers = [];\n+ }\n+ function handleRequestAnimationFrame() {\n+ renderTimer = null;\n+ renderAllPending();\n+ }\n+ function getRendererForHost(host) {\n+ var renderer = rendererForHostTable.get(host);\n+ if (!renderer) {\n+ renderer = new ShadowRenderer(host);\n+ rendererForHostTable.set(host, renderer);\n+ }\n+ return renderer;\n+ }\n+ function getShadowRootAncestor(node) {\n+ var root = getTreeScope(node).root;\n+ if (root instanceof ShadowRoot) return root;\n+ return null;\n+ }\n+ function getRendererForShadowRoot(shadowRoot) {\n+ return getRendererForHost(shadowRoot.host);\n+ }\n+ var spliceDiff = new ArraySplice();\n+ spliceDiff.equals = function(renderNode, rawNode) {\n+ return unwrap(renderNode.node) === rawNode;\n+ };\n+ function RenderNode(node) {\n+ this.skip = false;\n+ this.node = node;\n+ this.childNodes = [];\n+ }\n+ RenderNode.prototype = {\n+ append: function(node) {\n+ var rv = new RenderNode(node);\n+ this.childNodes.push(rv);\n+ return rv;\n+ },\n+ sync: function(opt_added) {\n+ if (this.skip) return;\n+ var nodeWrapper = this.node;\n+ var newChildren = this.childNodes;\n+ var oldChildren = getChildNodesSnapshot(unwrap(nodeWrapper));\n+ var added = opt_added || new WeakMap();\n+ var splices = spliceDiff.calculateSplices(newChildren, oldChildren);\n+ var newIndex = 0, oldIndex = 0;\n+ var lastIndex = 0;\n+ for (var i = 0; i < splices.length; i++) {\n+ var splice = splices[i];\n+ for (;lastIndex < splice.index; lastIndex++) {\n+ oldIndex++;\n+ newChildren[newIndex++].sync(added);\n+ }\n+ var removedCount = splice.removed.length;\n+ for (var j = 0; j < removedCount; j++) {\n+ var wrapper = wrap(oldChildren[oldIndex++]);\n+ if (!added.get(wrapper)) remove(wrapper);\n+ }\n+ var addedCount = splice.addedCount;\n+ var refNode = oldChildren[oldIndex] && wrap(oldChildren[oldIndex]);\n+ for (var j = 0; j < addedCount; j++) {\n+ var newChildRenderNode = newChildren[newIndex++];\n+ var newChildWrapper = newChildRenderNode.node;\n+ insertBefore(nodeWrapper, newChildWrapper, refNode);\n+ added.set(newChildWrapper, true);\n+ newChildRenderNode.sync(added);\n+ }\n+ lastIndex += addedCount;\n+ }\n+ for (var i = lastIndex; i < newChildren.length; i++) {\n+ newChildren[i].sync(added);\n+ }\n+ }\n+ };\n+ function ShadowRenderer(host) {\n+ this.host = host;\n+ this.dirty = false;\n+ this.invalidateAttributes();\n+ this.associateNode(host);\n+ }\n+ ShadowRenderer.prototype = {\n+ render: function(opt_renderNode) {\n+ if (!this.dirty) return;\n+ this.invalidateAttributes();\n+ var host = this.host;\n+ this.distribution(host);\n+ var renderNode = opt_renderNode || new RenderNode(host);\n+ this.buildRenderTree(renderNode, host);\n+ var topMostRenderer = !opt_renderNode;\n+ if (topMostRenderer) renderNode.sync();\n+ this.dirty = false;\n+ },\n+ get parentRenderer() {\n+ return getTreeScope(this.host).renderer;\n+ },\n+ invalidate: function() {\n+ if (!this.dirty) {\n+ this.dirty = true;\n+ var parentRenderer = this.parentRenderer;\n+ if (parentRenderer) parentRenderer.invalidate();\n+ pendingDirtyRenderers.push(this);\n+ if (renderTimer) return;\n+ renderTimer = window[request](handleRequestAnimationFrame, 0);\n+ }\n+ },\n+ distribution: function(root) {\n+ this.resetAllSubtrees(root);\n+ this.distributionResolution(root);\n+ },\n+ resetAll: function(node) {\n+ if (isInsertionPoint(node)) resetDistributedNodes(node); else resetDestinationInsertionPoints(node);\n+ this.resetAllSubtrees(node);\n+ },\n+ resetAllSubtrees: function(node) {\n+ for (var child = node.firstChild; child; child = child.nextSibling) {\n+ this.resetAll(child);\n+ }\n+ if (node.shadowRoot) this.resetAll(node.shadowRoot);\n+ if (node.olderShadowRoot) this.resetAll(node.olderShadowRoot);\n+ },\n+ distributionResolution: function(node) {\n+ if (isShadowHost(node)) {\n+ var shadowHost = node;\n+ var pool = poolPopulation(shadowHost);\n+ var shadowTrees = getShadowTrees(shadowHost);\n+ for (var i = 0; i < shadowTrees.length; i++) {\n+ this.poolDistribution(shadowTrees[i], pool);\n+ }\n+ for (var i = shadowTrees.length - 1; i >= 0; i--) {\n+ var shadowTree = shadowTrees[i];\n+ var shadow = getShadowInsertionPoint(shadowTree);\n+ if (shadow) {\n+ var olderShadowRoot = shadowTree.olderShadowRoot;\n+ if (olderShadowRoot) {\n+ pool = poolPopulation(olderShadowRoot);\n+ }\n+ for (var j = 0; j < pool.length; j++) {\n+ destributeNodeInto(pool[j], shadow);\n+ }\n+ }\n+ this.distributionResolution(shadowTree);\n+ }\n+ }\n+ for (var child = node.firstChild; child; child = child.nextSibling) {\n+ this.distributionResolution(child);\n+ }\n+ },\n+ poolDistribution: function(node, pool) {\n+ if (node instanceof HTMLShadowElement) return;\n+ if (node instanceof HTMLContentElement) {\n+ var content = node;\n+ this.updateDependentAttributes(content.getAttribute(\"select\"));\n+ var anyDistributed = false;\n+ for (var i = 0; i < pool.length; i++) {\n+ var node = pool[i];\n+ if (!node) continue;\n+ if (matches(node, content)) {\n+ destributeNodeInto(node, content);\n+ pool[i] = undefined;\n+ anyDistributed = true;\n+ }\n+ }\n+ if (!anyDistributed) {\n+ for (var child = content.firstChild; child; child = child.nextSibling) {\n+ destributeNodeInto(child, content);\n+ }\n+ }\n+ return;\n+ }\n+ for (var child = node.firstChild; child; child = child.nextSibling) {\n+ this.poolDistribution(child, pool);\n+ }\n+ },\n+ buildRenderTree: function(renderNode, node) {\n+ var children = this.compose(node);\n+ for (var i = 0; i < children.length; i++) {\n+ var child = children[i];\n+ var childRenderNode = renderNode.append(child);\n+ this.buildRenderTree(childRenderNode, child);\n+ }\n+ if (isShadowHost(node)) {\n+ var renderer = getRendererForHost(node);\n+ renderer.dirty = false;\n+ }\n+ },\n+ compose: function(node) {\n+ var children = [];\n+ var p = node.shadowRoot || node;\n+ for (var child = p.firstChild; child; child = child.nextSibling) {\n+ if (isInsertionPoint(child)) {\n+ this.associateNode(p);\n+ var distributedNodes = getDistributedNodes(child);\n+ for (var j = 0; j < distributedNodes.length; j++) {\n+ var distributedNode = distributedNodes[j];\n+ if (isFinalDestination(child, distributedNode)) children.push(distributedNode);\n+ }\n+ } else {\n+ children.push(child);\n+ }\n+ }\n+ return children;\n+ },\n+ invalidateAttributes: function() {\n+ this.attributes = Object.create(null);\n+ },\n+ updateDependentAttributes: function(selector) {\n+ if (!selector) return;\n+ var attributes = this.attributes;\n+ if (\/\\.\\w+\/.test(selector)) attributes[\"class\"] = true;\n+ if (\/#\\w+\/.test(selector)) attributes[\"id\"] = true;\n+ selector.replace(\/\\[\\s*([^\\s=\\|~\\]]+)\/g, function(_, name) {\n+ attributes[name] = true;\n+ });\n+ },\n+ dependsOnAttribute: function(name) {\n+ return this.attributes[name];\n+ },\n+ associateNode: function(node) {\n+ unsafeUnwrap(node).polymerShadowRenderer_ = this;\n+ }\n+ };\n+ function poolPopulation(node) {\n+ var pool = [];\n+ for (var child = node.firstChild; child; child = child.nextSibling) {\n+ if (isInsertionPoint(child)) {\n+ pool.push.apply(pool, getDistributedNodes(child));\n+ } else {\n+ pool.push(child);\n+ }\n+ }\n+ return pool;\n+ }\n+ function getShadowInsertionPoint(node) {\n+ if (node instanceof HTMLShadowElement) return node;\n+ if (node instanceof HTMLContentElement) return null;\n+ for (var child = node.firstChild; child; child = child.nextSibling) {\n+ var res = getShadowInsertionPoint(child);\n+ if (res) return res;\n+ }\n+ return null;\n+ }\n+ function destributeNodeInto(child, insertionPoint) {\n+ getDistributedNodes(insertionPoint).push(child);\n+ var points = destinationInsertionPointsTable.get(child);\n+ if (!points) destinationInsertionPointsTable.set(child, [ insertionPoint ]); else points.push(insertionPoint);\n+ }\n+ function getDestinationInsertionPoints(node) {\n+ return destinationInsertionPointsTable.get(node);\n+ }\n+ function resetDestinationInsertionPoints(node) {\n+ destinationInsertionPointsTable.set(node, undefined);\n+ }\n+ var selectorStartCharRe = \/^(:not\\()?[*.#[a-zA-Z_|]\/;\n+ function matches(node, contentElement) {\n+ var select = contentElement.getAttribute(\"select\");\n+ if (!select) return true;\n+ select = select.trim();\n+ if (!select) return true;\n+ if (!(node instanceof Element)) return false;\n+ if (!selectorStartCharRe.test(select)) return false;\n+ try {\n+ return node.matches(select);\n+ } catch (ex) {\n+ return false;\n+ }\n+ }\n+ function isFinalDestination(insertionPoint, node) {\n+ var points = getDestinationInsertionPoints(node);\n+ return points && points[points.length - 1] === insertionPoint;\n+ }\n+ function isInsertionPoint(node) {\n+ return node instanceof HTMLContentElement || node instanceof HTMLShadowElement;\n+ }\n+ function isShadowHost(shadowHost) {\n+ return shadowHost.shadowRoot;\n+ }\n+ function getShadowTrees(host) {\n+ var trees = [];\n+ for (var tree = host.shadowRoot; tree; tree = tree.olderShadowRoot) {\n+ trees.push(tree);\n+ }\n+ return trees;\n+ }\n+ function render(host) {\n+ new ShadowRenderer(host).render();\n+ }\n+ Node.prototype.invalidateShadowRenderer = function(force) {\n+ var renderer = unsafeUnwrap(this).polymerShadowRenderer_;\n+ if (renderer) {\n+ renderer.invalidate();\n+ return true;\n+ }\n+ return false;\n+ };\n+ HTMLContentElement.prototype.getDistributedNodes = HTMLShadowElement.prototype.getDistributedNodes = function() {\n+ renderAllPending();\n+ return getDistributedNodes(this);\n+ };\n+ Element.prototype.getDestinationInsertionPoints = function() {\n+ renderAllPending();\n+ return getDestinationInsertionPoints(this) || [];\n+ };\n+ HTMLContentElement.prototype.nodeIsInserted_ = HTMLShadowElement.prototype.nodeIsInserted_ = function() {\n+ this.invalidateShadowRenderer();\n+ var shadowRoot = getShadowRootAncestor(this);\n+ var renderer;\n+ if (shadowRoot) renderer = getRendererForShadowRoot(shadowRoot);\n+ unsafeUnwrap(this).polymerShadowRenderer_ = renderer;\n+ if (renderer) renderer.invalidate();\n+ };\n+ scope.getRendererForHost = getRendererForHost;\n+ scope.getShadowTrees = getShadowTrees;\n+ scope.renderAllPending = renderAllPending;\n+ scope.getDestinationInsertionPoints = getDestinationInsertionPoints;\n+ scope.visual = {\n+ insertBefore: insertBefore,\n+ remove: remove\n+ };\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var HTMLElement = scope.wrappers.HTMLElement;\n+ var assert = scope.assert;\n+ var mixin = scope.mixin;\n+ var registerWrapper = scope.registerWrapper;\n+ var unwrap = scope.unwrap;\n+ var wrap = scope.wrap;\n+ var elementsWithFormProperty = [ \"HTMLButtonElement\", \"HTMLFieldSetElement\", \"HTMLInputElement\", \"HTMLKeygenElement\", \"HTMLLabelElement\", \"HTMLLegendElement\", \"HTMLObjectElement\", \"HTMLOutputElement\", \"HTMLTextAreaElement\" ];\n+ function createWrapperConstructor(name) {\n+ if (!window[name]) return;\n+ assert(!scope.wrappers[name]);\n+ var GeneratedWrapper = function(node) {\n+ HTMLElement.call(this, node);\n+ };\n+ GeneratedWrapper.prototype = Object.create(HTMLElement.prototype);\n+ mixin(GeneratedWrapper.prototype, {\n+ get form() {\n+ return wrap(unwrap(this).form);\n+ }\n+ });\n+ registerWrapper(window[name], GeneratedWrapper, document.createElement(name.slice(4, -7)));\n+ scope.wrappers[name] = GeneratedWrapper;\n+ }\n+ elementsWithFormProperty.forEach(createWrapperConstructor);\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var registerWrapper = scope.registerWrapper;\n+ var setWrapper = scope.setWrapper;\n+ var unsafeUnwrap = scope.unsafeUnwrap;\n+ var unwrap = scope.unwrap;\n+ var unwrapIfNeeded = scope.unwrapIfNeeded;\n+ var wrap = scope.wrap;\n+ var OriginalSelection = window.Selection;\n+ function Selection(impl) {\n+ setWrapper(impl, this);\n+ }\n+ Selection.prototype = {\n+ get anchorNode() {\n+ return wrap(unsafeUnwrap(this).anchorNode);\n+ },\n+ get focusNode() {\n+ return wrap(unsafeUnwrap(this).focusNode);\n+ },\n+ addRange: function(range) {\n+ unsafeUnwrap(this).addRange(unwrap(range));\n+ },\n+ collapse: function(node, index) {\n+ unsafeUnwrap(this).collapse(unwrapIfNeeded(node), index);\n+ },\n+ containsNode: function(node, allowPartial) {\n+ return unsafeUnwrap(this).containsNode(unwrapIfNeeded(node), allowPartial);\n+ },\n+ extend: function(node, offset) {\n+ unsafeUnwrap(this).extend(unwrapIfNeeded(node), offset);\n+ },\n+ getRangeAt: function(index) {\n+ return wrap(unsafeUnwrap(this).getRangeAt(index));\n+ },\n+ removeRange: function(range) {\n+ unsafeUnwrap(this).removeRange(unwrap(range));\n+ },\n+ selectAllChildren: function(node) {\n+ unsafeUnwrap(this).selectAllChildren(unwrapIfNeeded(node));\n+ },\n+ toString: function() {\n+ return unsafeUnwrap(this).toString();\n+ }\n+ };\n+ registerWrapper(window.Selection, Selection, window.getSelection());\n+ scope.wrappers.Selection = Selection;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var GetElementsByInterface = scope.GetElementsByInterface;\n+ var Node = scope.wrappers.Node;\n+ var ParentNodeInterface = scope.ParentNodeInterface;\n+ var Selection = scope.wrappers.Selection;\n+ var SelectorsInterface = scope.SelectorsInterface;\n+ var ShadowRoot = scope.wrappers.ShadowRoot;\n+ var TreeScope = scope.TreeScope;\n+ var cloneNode = scope.cloneNode;\n+ var defineWrapGetter = scope.defineWrapGetter;\n+ var elementFromPoint = scope.elementFromPoint;\n+ var forwardMethodsToWrapper = scope.forwardMethodsToWrapper;\n+ var matchesNames = scope.matchesNames;\n+ var mixin = scope.mixin;\n+ var registerWrapper = scope.registerWrapper;\n+ var renderAllPending = scope.renderAllPending;\n+ var rewrap = scope.rewrap;\n+ var setWrapper = scope.setWrapper;\n+ var unsafeUnwrap = scope.unsafeUnwrap;\n+ var unwrap = scope.unwrap;\n+ var wrap = scope.wrap;\n+ var wrapEventTargetMethods = scope.wrapEventTargetMethods;\n+ var wrapNodeList = scope.wrapNodeList;\n+ var implementationTable = new WeakMap();\n+ function Document(node) {\n+ Node.call(this, node);\n+ this.treeScope_ = new TreeScope(this, null);\n+ }\n+ Document.prototype = Object.create(Node.prototype);\n+ defineWrapGetter(Document, \"documentElement\");\n+ defineWrapGetter(Document, \"body\");\n+ defineWrapGetter(Document, \"head\");\n+ function wrapMethod(name) {\n+ var original = document[name];\n+ Document.prototype[name] = function() {\n+ return wrap(original.apply(unsafeUnwrap(this), arguments));\n+ };\n+ }\n+ [ \"createComment\", \"createDocumentFragment\", \"createElement\", \"createElementNS\", \"createEvent\", \"createEventNS\", \"createRange\", \"createTextNode\", \"getElementById\" ].forEach(wrapMethod);\n+ var originalAdoptNode = document.adoptNode;\n+ function adoptNodeNoRemove(node, doc) {\n+ originalAdoptNode.call(unsafeUnwrap(doc), unwrap(node));\n+ adoptSubtree(node, doc);\n+ }\n+ function adoptSubtree(node, doc) {\n+ if (node.shadowRoot) doc.adoptNode(node.shadowRoot);\n+ if (node instanceof ShadowRoot) adoptOlderShadowRoots(node, doc);\n+ for (var child = node.firstChild; child; child = child.nextSibling) {\n+ adoptSubtree(child, doc);\n+ }\n+ }\n+ function adoptOlderShadowRoots(shadowRoot, doc) {\n+ var oldShadowRoot = shadowRoot.olderShadowRoot;\n+ if (oldShadowRoot) doc.adoptNode(oldShadowRoot);\n+ }\n+ var originalGetSelection = document.getSelection;\n+ mixin(Document.prototype, {\n+ adoptNode: function(node) {\n+ if (node.parentNode) node.parentNode.removeChild(node);\n+ adoptNodeNoRemove(node, this);\n+ return node;\n+ },\n+ elementFromPoint: function(x, y) {\n+ return elementFromPoint(this, this, x, y);\n+ },\n+ importNode: function(node, deep) {\n+ return cloneNode(node, deep, unsafeUnwrap(this));\n+ },\n+ getSelection: function() {\n+ renderAllPending();\n+ return new Selection(originalGetSelection.call(unwrap(this)));\n+ },\n+ getElementsByName: function(name) {\n+ return SelectorsInterface.querySelectorAll.call(this, \"[name=\" + JSON.stringify(String(name)) + \"]\");\n+ }\n+ });\n+ if (document.registerElement) {\n+ var originalRegisterElement = document.registerElement;\n+ Document.prototype.registerElement = function(tagName, object) {\n+ var prototype, extendsOption;\n+ if (object !== undefined) {\n+ prototype = object.prototype;\n+ extendsOption = object.extends;\n+ }\n+ if (!prototype) prototype = Object.create(HTMLElement.prototype);\n+ if (scope.nativePrototypeTable.get(prototype)) {\n+ throw new Error(\"NotSupportedError\");\n+ }\n+ var proto = Object.getPrototypeOf(prototype);\n+ var nativePrototype;\n+ var prototypes = [];\n+ while (proto) {\n+ nativePrototype = scope.nativePrototypeTable.get(proto);\n+ if (nativePrototype) break;\n+ prototypes.push(proto);\n+ proto = Object.getPrototypeOf(proto);\n+ }\n+ if (!nativePrototype) {\n+ throw new Error(\"NotSupportedError\");\n+ }\n+ var newPrototype = Object.create(nativePrototype);\n+ for (var i = prototypes.length - 1; i >= 0; i--) {\n+ newPrototype = Object.create(newPrototype);\n+ }\n+ [ \"createdCallback\", \"attachedCallback\", \"detachedCallback\", \"attributeChangedCallback\" ].forEach(function(name) {\n+ var f = prototype[name];\n+ if (!f) return;\n+ newPrototype[name] = function() {\n+ if (!(wrap(this) instanceof CustomElementConstructor)) {\n+ rewrap(this);\n+ }\n+ f.apply(wrap(this), arguments);\n+ };\n+ });\n+ var p = {\n+ prototype: newPrototype\n+ };\n+ if (extendsOption) p.extends = extendsOption;\n+ function CustomElementConstructor(node) {\n+ if (!node) {\n+ if (extendsOption) {\n+ return document.createElement(extendsOption, tagName);\n+ } else {\n+ return document.createElement(tagName);\n+ }\n+ }\n+ setWrapper(node, this);\n+ }\n+ CustomElementConstructor.prototype = prototype;\n+ CustomElementConstructor.prototype.constructor = CustomElementConstructor;\n+ scope.constructorTable.set(newPrototype, CustomElementConstructor);\n+ scope.nativePrototypeTable.set(prototype, newPrototype);\n+ var nativeConstructor = originalRegisterElement.call(unwrap(this), tagName, p);\n+ return CustomElementConstructor;\n+ };\n+ forwardMethodsToWrapper([ window.HTMLDocument || window.Document ], [ \"registerElement\" ]);\n+ }\n+ forwardMethodsToWrapper([ window.HTMLBodyElement, window.HTMLDocument || window.Document, window.HTMLHeadElement, window.HTMLHtmlElement ], [ \"appendChild\", \"compareDocumentPosition\", \"contains\", \"getElementsByClassName\", \"getElementsByTagName\", \"getElementsByTagNameNS\", \"insertBefore\", \"querySelector\", \"querySelectorAll\", \"removeChild\", \"replaceChild\" ].concat(matchesNames));\n+ forwardMethodsToWrapper([ window.HTMLDocument || window.Document ], [ \"adoptNode\", \"importNode\", \"contains\", \"createComment\", \"createDocumentFragment\", \"createElement\", \"createElementNS\", \"createEvent\", \"createEventNS\", \"createRange\", \"createTextNode\", \"elementFromPoint\", \"getElementById\", \"getElementsByName\", \"getSelection\" ]);\n+ mixin(Document.prototype, GetElementsByInterface);\n+ mixin(Document.prototype, ParentNodeInterface);\n+ mixin(Document.prototype, SelectorsInterface);\n+ mixin(Document.prototype, {\n+ get implementation() {\n+ var implementation = implementationTable.get(this);\n+ if (implementation) return implementation;\n+ implementation = new DOMImplementation(unwrap(this).implementation);\n+ implementationTable.set(this, implementation);\n+ return implementation;\n+ },\n+ get defaultView() {\n+ return wrap(unwrap(this).defaultView);\n+ }\n+ });\n+ registerWrapper(window.Document, Document, document.implementation.createHTMLDocument(\"\"));\n+ if (window.HTMLDocument) registerWrapper(window.HTMLDocument, Document);\n+ wrapEventTargetMethods([ window.HTMLBodyElement, window.HTMLDocument || window.Document, window.HTMLHeadElement ]);\n+ function DOMImplementation(impl) {\n+ setWrapper(impl, this);\n+ }\n+ function wrapImplMethod(constructor, name) {\n+ var original = document.implementation[name];\n+ constructor.prototype[name] = function() {\n+ return wrap(original.apply(unsafeUnwrap(this), arguments));\n+ };\n+ }\n+ function forwardImplMethod(constructor, name) {\n+ var original = document.implementation[name];\n+ constructor.prototype[name] = function() {\n+ return original.apply(unsafeUnwrap(this), arguments);\n+ };\n+ }\n+ wrapImplMethod(DOMImplementation, \"createDocumentType\");\n+ wrapImplMethod(DOMImplementation, \"createDocument\");\n+ wrapImplMethod(DOMImplementation, \"createHTMLDocument\");\n+ forwardImplMethod(DOMImplementation, \"hasFeature\");\n+ registerWrapper(window.DOMImplementation, DOMImplementation);\n+ forwardMethodsToWrapper([ window.DOMImplementation ], [ \"createDocumentType\", \"createDocument\", \"createHTMLDocument\", \"hasFeature\" ]);\n+ scope.adoptNodeNoRemove = adoptNodeNoRemove;\n+ scope.wrappers.DOMImplementation = DOMImplementation;\n+ scope.wrappers.Document = Document;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var EventTarget = scope.wrappers.EventTarget;\n+ var Selection = scope.wrappers.Selection;\n+ var mixin = scope.mixin;\n+ var registerWrapper = scope.registerWrapper;\n+ var renderAllPending = scope.renderAllPending;\n+ var unwrap = scope.unwrap;\n+ var unwrapIfNeeded = scope.unwrapIfNeeded;\n+ var wrap = scope.wrap;\n+ var OriginalWindow = window.Window;\n+ var originalGetComputedStyle = window.getComputedStyle;\n+ var originalGetDefaultComputedStyle = window.getDefaultComputedStyle;\n+ var originalGetSelection = window.getSelection;\n+ function Window(impl) {\n+ EventTarget.call(this, impl);\n+ }\n+ Window.prototype = Object.create(EventTarget.prototype);\n+ OriginalWindow.prototype.getComputedStyle = function(el, pseudo) {\n+ return wrap(this || window).getComputedStyle(unwrapIfNeeded(el), pseudo);\n+ };\n+ if (originalGetDefaultComputedStyle) {\n+ OriginalWindow.prototype.getDefaultComputedStyle = function(el, pseudo) {\n+ return wrap(this || window).getDefaultComputedStyle(unwrapIfNeeded(el), pseudo);\n+ };\n+ }\n+ OriginalWindow.prototype.getSelection = function() {\n+ return wrap(this || window).getSelection();\n+ };\n+ delete window.getComputedStyle;\n+ delete window.getDefaultComputedStyle;\n+ delete window.getSelection;\n+ [ \"addEventListener\", \"removeEventListener\", \"dispatchEvent\" ].forEach(function(name) {\n+ OriginalWindow.prototype[name] = function() {\n+ var w = wrap(this || window);\n+ return w[name].apply(w, arguments);\n+ };\n+ delete window[name];\n+ });\n+ mixin(Window.prototype, {\n+ getComputedStyle: function(el, pseudo) {\n+ renderAllPending();\n+ return originalGetComputedStyle.call(unwrap(this), unwrapIfNeeded(el), pseudo);\n+ },\n+ getSelection: function() {\n+ renderAllPending();\n+ return new Selection(originalGetSelection.call(unwrap(this)));\n+ },\n+ get document() {\n+ return wrap(unwrap(this).document);\n+ }\n+ });\n+ if (originalGetDefaultComputedStyle) {\n+ Window.prototype.getDefaultComputedStyle = function(el, pseudo) {\n+ renderAllPending();\n+ return originalGetDefaultComputedStyle.call(unwrap(this), unwrapIfNeeded(el), pseudo);\n+ };\n+ }\n+ registerWrapper(OriginalWindow, Window, window);\n+ scope.wrappers.Window = Window;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var unwrap = scope.unwrap;\n+ var OriginalDataTransfer = window.DataTransfer || window.Clipboard;\n+ var OriginalDataTransferSetDragImage = OriginalDataTransfer.prototype.setDragImage;\n+ if (OriginalDataTransferSetDragImage) {\n+ OriginalDataTransfer.prototype.setDragImage = function(image, x, y) {\n+ OriginalDataTransferSetDragImage.call(this, unwrap(image), x, y);\n+ };\n+ }\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var registerWrapper = scope.registerWrapper;\n+ var setWrapper = scope.setWrapper;\n+ var unwrap = scope.unwrap;\n+ var OriginalFormData = window.FormData;\n+ if (!OriginalFormData) return;\n+ function FormData(formElement) {\n+ var impl;\n+ if (formElement instanceof OriginalFormData) {\n+ impl = formElement;\n+ } else {\n+ impl = new OriginalFormData(formElement && unwrap(formElement));\n+ }\n+ setWrapper(impl, this);\n+ }\n+ registerWrapper(OriginalFormData, FormData, new OriginalFormData());\n+ scope.wrappers.FormData = FormData;\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var unwrapIfNeeded = scope.unwrapIfNeeded;\n+ var originalSend = XMLHttpRequest.prototype.send;\n+ XMLHttpRequest.prototype.send = function(obj) {\n+ return originalSend.call(this, unwrapIfNeeded(obj));\n+ };\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ \"use strict\";\n+ var isWrapperFor = scope.isWrapperFor;\n+ var elements = {\n+ a: \"HTMLAnchorElement\",\n+ area: \"HTMLAreaElement\",\n+ audio: \"HTMLAudioElement\",\n+ base: \"HTMLBaseElement\",\n+ body: \"HTMLBodyElement\",\n+ br: \"HTMLBRElement\",\n+ button: \"HTMLButtonElement\",\n+ canvas: \"HTMLCanvasElement\",\n+ caption: \"HTMLTableCaptionElement\",\n+ col: \"HTMLTableColElement\",\n+ content: \"HTMLContentElement\",\n+ data: \"HTMLDataElement\",\n+ datalist: \"HTMLDataListElement\",\n+ del: \"HTMLModElement\",\n+ dir: \"HTMLDirectoryElement\",\n+ div: \"HTMLDivElement\",\n+ dl: \"HTMLDListElement\",\n+ embed: \"HTMLEmbedElement\",\n+ fieldset: \"HTMLFieldSetElement\",\n+ font: \"HTMLFontElement\",\n+ form: \"HTMLFormElement\",\n+ frame: \"HTMLFrameElement\",\n+ frameset: \"HTMLFrameSetElement\",\n+ h1: \"HTMLHeadingElement\",\n+ head: \"HTMLHeadElement\",\n+ hr: \"HTMLHRElement\",\n+ html: \"HTMLHtmlElement\",\n+ iframe: \"HTMLIFrameElement\",\n+ img: \"HTMLImageElement\",\n+ input: \"HTMLInputElement\",\n+ keygen: \"HTMLKeygenElement\",\n+ label: \"HTMLLabelElement\",\n+ legend: \"HTMLLegendElement\",\n+ li: \"HTMLLIElement\",\n+ link: \"HTMLLinkElement\",\n+ map: \"HTMLMapElement\",\n+ marquee: \"HTMLMarqueeElement\",\n+ menu: \"HTMLMenuElement\",\n+ menuitem: \"HTMLMenuItemElement\",\n+ meta: \"HTMLMetaElement\",\n+ meter: \"HTMLMeterElement\",\n+ object: \"HTMLObjectElement\",\n+ ol: \"HTMLOListElement\",\n+ optgroup: \"HTMLOptGroupElement\",\n+ option: \"HTMLOptionElement\",\n+ output: \"HTMLOutputElement\",\n+ p: \"HTMLParagraphElement\",\n+ param: \"HTMLParamElement\",\n+ pre: \"HTMLPreElement\",\n+ progress: \"HTMLProgressElement\",\n+ q: \"HTMLQuoteElement\",\n+ script: \"HTMLScriptElement\",\n+ select: \"HTMLSelectElement\",\n+ shadow: \"HTMLShadowElement\",\n+ source: \"HTMLSourceElement\",\n+ span: \"HTMLSpanElement\",\n+ style: \"HTMLStyleElement\",\n+ table: \"HTMLTableElement\",\n+ tbody: \"HTMLTableSectionElement\",\n+ template: \"HTMLTemplateElement\",\n+ textarea: \"HTMLTextAreaElement\",\n+ thead: \"HTMLTableSectionElement\",\n+ time: \"HTMLTimeElement\",\n+ title: \"HTMLTitleElement\",\n+ tr: \"HTMLTableRowElement\",\n+ track: \"HTMLTrackElement\",\n+ ul: \"HTMLUListElement\",\n+ video: \"HTMLVideoElement\"\n+ };\n+ function overrideConstructor(tagName) {\n+ var nativeConstructorName = elements[tagName];\n+ var nativeConstructor = window[nativeConstructorName];\n+ if (!nativeConstructor) return;\n+ var element = document.createElement(tagName);\n+ var wrapperConstructor = element.constructor;\n+ window[nativeConstructorName] = wrapperConstructor;\n+ }\n+ Object.keys(elements).forEach(overrideConstructor);\n+ Object.getOwnPropertyNames(scope.wrappers).forEach(function(name) {\n+ window[name] = scope.wrappers[name];\n+ });\n+ })(window.ShadowDOMPolyfill);\n+ (function(scope) {\n+ var ShadowCSS = {\n+ strictStyling: false,\n+ registry: {},\n+ shimStyling: function(root, name, extendsName) {\n+ var scopeStyles = this.prepareRoot(root, name, extendsName);\n+ var typeExtension = this.isTypeExtension(extendsName);\n+ var scopeSelector = this.makeScopeSelector(name, typeExtension);\n+ var cssText = stylesToCssText(scopeStyles, true);\n+ cssText = this.scopeCssText(cssText, scopeSelector);\n+ if (root) {\n+ root.shimmedStyle = cssText;\n+ }\n+ this.addCssToDocument(cssText, name);\n+ },\n+ shimStyle: function(style, selector) {\n+ return this.shimCssText(style.textContent, selector);\n+ },\n+ shimCssText: function(cssText, selector) {\n+ cssText = this.insertDirectives(cssText);\n+ return this.scopeCssText(cssText, selector);\n+ },\n+ makeScopeSelector: function(name, typeExtension) {\n+ if (name) {\n+ return typeExtension ? \"[is=\" + name + \"]\" : name;\n+ }\n+ return \"\";\n+ },\n+ isTypeExtension: function(extendsName) {\n+ return extendsName && extendsName.indexOf(\"-\") < 0;\n+ },\n+ prepareRoot: function(root, name, extendsName) {\n+ var def = this.registerRoot(root, name, extendsName);\n+ this.replaceTextInStyles(def.rootStyles, this.insertDirectives);\n+ this.removeStyles(root, def.rootStyles);\n+ if (this.strictStyling) {\n+ this.applyScopeToContent(root, name);\n+ }\n+ return def.scopeStyles;\n+ },\n+ removeStyles: function(root, styles) {\n+ for (var i = 0, l = styles.length, s; i < l && (s = styles[i]); i++) {\n+ s.parentNode.removeChild(s);\n+ }\n+ },\n+ registerRoot: function(root, name, extendsName) {\n+ var def = this.registry[name] = {\n+ root: root,\n+ name: name,\n+ extendsName: extendsName\n+ };\n+ var styles = this.findStyles(root);\n+ def.rootStyles = styles;\n+ def.scopeStyles = def.rootStyles;\n+ var extendee = this.registry[def.extendsName];\n+ if (extendee) {\n+ def.scopeStyles = extendee.scopeStyles.concat(def.scopeStyles);\n+ }\n+ return def;\n+ },\n+ findStyles: function(root) {\n+ if (!root) {\n+ return [];\n+ }\n+ var styles = root.querySelectorAll(\"style\");\n+ return Array.prototype.filter.call(styles, function(s) {\n+ return !s.hasAttribute(NO_SHIM_ATTRIBUTE);\n+ });\n+ },\n+ applyScopeToContent: function(root, name) {\n+ if (root) {\n+ Array.prototype.forEach.call(root.querySelectorAll(\"*\"), function(node) {\n+ node.setAttribute(name, \"\");\n+ });\n+ Array.prototype.forEach.call(root.querySelectorAll(\"template\"), function(template) {\n+ this.applyScopeToContent(template.content, name);\n+ }, this);\n+ }\n+ },\n+ insertDirectives: function(cssText) {\n+ cssText = this.insertPolyfillDirectivesInCssText(cssText);\n+ return this.insertPolyfillRulesInCssText(cssText);\n+ },\n+ insertPolyfillDirectivesInCssText: function(cssText) {\n+ cssText = cssText.replace(cssCommentNextSelectorRe, function(match, p1) {\n+ return p1.slice(0, -2) + \"{\";\n+ });\n+ return cssText.replace(cssContentNextSelectorRe, function(match, p1) {\n+ return p1 + \" {\";\n+ });\n+ },\n+ insertPolyfillRulesInCssText: function(cssText) {\n+ cssText = cssText.replace(cssCommentRuleRe, function(match, p1) {\n+ return p1.slice(0, -1);\n+ });\n+ return cssText.replace(cssContentRuleRe, function(match, p1, p2, p3) {\n+ var rule = match.replace(p1, \"\").replace(p2, \"\");\n+ return p3 + rule;\n+ });\n+ },\n+ scopeCssText: function(cssText, scopeSelector) {\n+ var unscoped = this.extractUnscopedRulesFromCssText(cssText);\n+ cssText = this.insertPolyfillHostInCssText(cssText);\n+ cssText = this.convertColonHost(cssText);\n+ cssText = this.convertColonHostContext(cssText);\n+ cssText = this.convertShadowDOMSelectors(cssText);\n+ if (scopeSelector) {\n+ var self = this, cssText;\n+ withCssRules(cssText, function(rules) {\n+ cssText = self.scopeRules(rules, scopeSelector);\n+ });\n+ }\n+ cssText = cssText + \"\\n\" + unscoped;\n+ return cssText.trim();\n+ },\n+ extractUnscopedRulesFromCssText: function(cssText) {\n+ var r = \"\", m;\n+ while (m = cssCommentUnscopedRuleRe.exec(cssText)) {\n+ r += m[1].slice(0, -1) + \"\\n\\n\";\n+ }\n+ while (m = cssContentUnscopedRuleRe.exec(cssText)) {\n+ r += m[0].replace(m[2], \"\").replace(m[1], m[3]) + \"\\n\\n\";\n+ }\n+ return r;\n+ },\n+ convertColonHost: function(cssText) {\n+ return this.convertColonRule(cssText, cssColonHostRe, this.colonHostPartReplacer);\n+ },\n+ convertColonHostContext: function(cssText) {\n+ return this.convertColonRule(cssText, cssColonHostContextRe, this.colonHostContextPartReplacer);\n+ },\n+ convertColonRule: function(cssText, regExp, partReplacer) {\n+ return cssText.replace(regExp, function(m, p1, p2, p3) {\n+ p1 = polyfillHostNoCombinator;\n+ if (p2) {\n+ var parts = p2.split(\",\"), r = [];\n+ for (var i = 0, l = parts.length, p; i < l && (p = parts[i]); i++) {\n+ p = p.trim();\n+ r.push(partReplacer(p1, p, p3));\n+ }\n+ return r.join(\",\");\n+ } else {\n+ return p1 + p3;\n+ }\n+ });\n+ },\n+ colonHostContextPartReplacer: function(host, part, suffix) {\n+ if (part.match(polyfillHost)) {\n+ return this.colonHostPartReplacer(host, part, suffix);\n+ } else {\n+ return host + part + suffix + \", \" + part + \" \" + host + suffix;\n+ }\n+ },\n+ colonHostPartReplacer: function(host, part, suffix) {\n+ return host + part.replace(polyfillHost, \"\") + suffix;\n+ },\n+ convertShadowDOMSelectors: function(cssText) {\n+ for (var i = 0; i < shadowDOMSelectorsRe.length; i++) {\n+ cssText = cssText.replace(shadowDOMSelectorsRe[i], \" \");\n+ }\n+ return cssText;\n+ },\n+ scopeRules: function(cssRules, scopeSelector) {\n+ var cssText = \"\";\n+ if (cssRules) {\n+ Array.prototype.forEach.call(cssRules, function(rule) {\n+ if (rule.selectorText && (rule.style && rule.style.cssText !== undefined)) {\n+ cssText += this.scopeSelector(rule.selectorText, scopeSelector, this.strictStyling) + \" {\\n\t\";\n+ cssText += this.propertiesFromRule(rule) + \"\\n}\\n\\n\";\n+ } else if (rule.type === CSSRule.MEDIA_RULE) {\n+ cssText += \"@media \" + rule.media.mediaText + \" {\\n\";\n+ cssText += this.scopeRules(rule.cssRules, scopeSelector);\n+ cssText += \"\\n}\\n\\n\";\n+ } else {\n+ try {\n+ if (rule.cssText) {\n+ cssText += rule.cssText + \"\\n\\n\";\n+ }\n+ } catch (x) {\n+ if (rule.type === CSSRule.KEYFRAMES_RULE && rule.cssRules) {\n+ cssText += this.ieSafeCssTextFromKeyFrameRule(rule);\n+ }\n+ }\n+ }\n+ }, this);\n+ }\n+ return cssText;\n+ },\n+ ieSafeCssTextFromKeyFrameRule: function(rule) {\n+ var cssText = \"@keyframes \" + rule.name + \" {\";\n+ Array.prototype.forEach.call(rule.cssRules, function(rule) {\n+ cssText += \" \" + rule.keyText + \" {\" + rule.style.cssText + \"}\";\n+ });\n+ cssText += \" }\";\n+ return cssText;\n+ },\n+ scopeSelector: function(selector, scopeSelector, strict) {\n+ var r = [], parts = selector.split(\",\");\n+ parts.forEach(function(p) {\n+ p = p.trim();\n+ if (this.selectorNeedsScoping(p, scopeSelector)) {\n+ p = strict && !p.match(polyfillHostNoCombinator) ? this.applyStrictSelectorScope(p, scopeSelector) : this.applySelectorScope(p, scopeSelector);\n+ }\n+ r.push(p);\n+ }, this);\n+ return r.join(\", \");\n+ },\n+ selectorNeedsScoping: function(selector, scopeSelector) {\n+ if (Array.isArray(scopeSelector)) {\n+ return true;\n+ }\n+ var re = this.makeScopeMatcher(scopeSelector);\n+ return !selector.match(re);\n+ },\n+ makeScopeMatcher: function(scopeSelector) {\n+ scopeSelector = scopeSelector.replace(\/\\[\/g, \"\\\\[\").replace(\/\\[\/g, \"\\\\]\");\n+ return new RegExp(\"^(\" + scopeSelector + \")\" + selectorReSuffix, \"m\");\n+ },\n+ applySelectorScope: function(selector, selectorScope) {\n+ return Array.isArray(selectorScope) ? this.applySelectorScopeList(selector, selectorScope) : this.applySimpleSelectorScope(selector, selectorScope);\n+ },\n+ applySelectorScopeList: function(selector, scopeSelectorList) {\n+ var r = [];\n+ for (var i = 0, s; s = scopeSelectorList[i]; i++) {\n+ r.push(this.applySimpleSelectorScope(selector, s));\n+ }\n+ return r.join(\", \");\n+ },\n+ applySimpleSelectorScope: function(selector, scopeSelector) {\n+ if (selector.match(polyfillHostRe)) {\n+ selector = selector.replace(polyfillHostNoCombinator, scopeSelector);\n+ return selector.replace(polyfillHostRe, scopeSelector + \" \");\n+ } else {\n+ return scopeSelector + \" \" + selector;\n+ }\n+ },\n+ applyStrictSelectorScope: function(selector, scopeSelector) {\n+ scopeSelector = scopeSelector.replace(\/\\[is=([^\\]]*)\\]\/g, \"$1\");\n+ var splits = [ \" \", \">\", \"+\", \"~\" ], scoped = selector, attrName = \"[\" + scopeSelector + \"]\";\n+ splits.forEach(function(sep) {\n+ var parts = scoped.split(sep);\n+ scoped = parts.map(function(p) {\n+ var t = p.trim().replace(polyfillHostRe, \"\");\n+ if (t && splits.indexOf(t) < 0 && t.indexOf(attrName) < 0) {\n+ p = t.replace(\/([^:]*)(:*)(.*)\/, \"$1\" + attrName + \"$2$3\");\n+ }\n+ return p;\n+ }).join(sep);\n+ });\n+ return scoped;\n+ },\n+ insertPolyfillHostInCssText: function(selector) {\n+ return selector.replace(colonHostContextRe, polyfillHostContext).replace(colonHostRe, polyfillHost);\n+ },\n+ propertiesFromRule: function(rule) {\n+ var cssText = rule.style.cssText;\n+ if (rule.style.content && !rule.style.content.match(\/['\"]+|attr\/)) {\n+ cssText = cssText.replace(\/content:[^;]*;\/g, \"content: '\" + rule.style.content + \"';\");\n+ }\n+ var style = rule.style;\n+ for (var i in style) {\n+ if (style[i] === \"initial\") {\n+ cssText += i + \": initial; \";\n+ }\n+ }\n+ return cssText;\n+ },\n+ replaceTextInStyles: function(styles, action) {\n+ if (styles && action) {\n+ if (!(styles instanceof Array)) {\n+ styles = [ styles ];\n+ }\n+ Array.prototype.forEach.call(styles, function(s) {\n+ s.textContent = action.call(this, s.textContent);\n+ }, this);\n+ }\n+ },\n+ addCssToDocument: function(cssText, name) {\n+ if (cssText.match(\"@import\")) {\n+ addOwnSheet(cssText, name);\n+ } else {\n+ addCssToDocument(cssText);\n+ }\n+ }\n+ };\n+ 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 = \")(?:\\\$(\" + \"(?:\\\\([^)(]*\\\$|[^)(]*)+?\" + \")\\\\))?([^,{]*)\";\n+ 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 ];\n+ function stylesToCssText(styles, preserveComments) {\n+ var cssText = \"\";\n+ Array.prototype.forEach.call(styles, function(s) {\n+ cssText += s.textContent + \"\\n\\n\";\n+ });\n+ if (!preserveComments) {\n+ cssText = cssText.replace(cssCommentRe, \"\");\n+ }\n+ return cssText;\n+ }\n+ function cssTextToStyle(cssText) {\n+ var style = document.createElement(\"style\");\n+ style.textContent = cssText;\n+ return style;\n+ }\n+ function cssToRules(cssText) {\n+ var style = cssTextToStyle(cssText);\n+ document.head.appendChild(style);\n+ var rules = [];\n+ if (style.sheet) {\n+ try {\n+ rules = style.sheet.cssRules;\n+ } catch (e) {}\n+ } else {\n+ console.warn(\"sheet not found\", style);\n+ }\n+ style.parentNode.removeChild(style);\n+ return rules;\n+ }\n+ var frame = document.createElement(\"iframe\");\n+ frame.style.display = \"none\";\n+ function initFrame() {\n+ frame.initialized = true;\n+ document.body.appendChild(frame);\n+ var doc = frame.contentDocument;\n+ var base = doc.createElement(\"base\");\n+ base.href = document.baseURI;\n+ doc.head.appendChild(base);\n+ }\n+ function inFrame(fn) {\n+ if (!frame.initialized) {\n+ initFrame();\n+ }\n+ document.body.appendChild(frame);\n+ fn(frame.contentDocument);\n+ document.body.removeChild(frame);\n+ }\n+ var isChrome = navigator.userAgent.match(\"Chrome\");\n+ function withCssRules(cssText, callback) {\n+ if (!callback) {\n+ return;\n+ }\n+ var rules;\n+ if (cssText.match(\"@import\") && isChrome) {\n+ var style = cssTextToStyle(cssText);\n+ inFrame(function(doc) {\n+ doc.head.appendChild(style.impl);\n+ rules = Array.prototype.slice.call(style.sheet.cssRules, 0);\n+ callback(rules);\n+ });\n+ } else {\n+ rules = cssToRules(cssText);\n+ callback(rules);\n+ }\n+ }\n+ function rulesToCss(cssRules) {\n+ for (var i = 0, css = []; i < cssRules.length; i++) {\n+ css.push(cssRules[i].cssText);\n+ }\n+ return css.join(\"\\n\\n\");\n+ }\n+ function addCssToDocument(cssText) {\n+ if (cssText) {\n+ getSheet().appendChild(document.createTextNode(cssText));\n+ }\n+ }\n+ function addOwnSheet(cssText, name) {\n+ var style = cssTextToStyle(cssText);\n+ style.setAttribute(name, \"\");\n+ style.setAttribute(SHIMMED_ATTRIBUTE, \"\");\n+ document.head.appendChild(style);\n+ }\n+ var SHIM_ATTRIBUTE = \"shim-shadowdom\";\n+ var SHIMMED_ATTRIBUTE = \"shim-shadowdom-css\";\n+ var NO_SHIM_ATTRIBUTE = \"no-shim\";\n+ var sheet;\n+ function getSheet() {\n+ if (!sheet) {\n+ sheet = document.createElement(\"style\");\n+ sheet.setAttribute(SHIMMED_ATTRIBUTE, \"\");\n+ sheet[SHIMMED_ATTRIBUTE] = true;\n+ }\n+ return sheet;\n+ }\n+ if (window.ShadowDOMPolyfill) {\n+ addCssToDocument(\"style { display: none !important; }\\n\");\n+ var doc = ShadowDOMPolyfill.wrap(document);\n+ var head = doc.querySelector(\"head\");\n+ head.insertBefore(getSheet(), head.childNodes[0]);\n+ document.addEventListener(\"DOMContentLoaded\", function() {\n+ var urlResolver = scope.urlResolver;\n+ if (window.HTMLImports && !HTMLImports.useNative) {\n+ var SHIM_SHEET_SELECTOR = \"link[rel=stylesheet]\" + \"[\" + SHIM_ATTRIBUTE + \"]\";\n+ var SHIM_STYLE_SELECTOR = \"style[\" + SHIM_ATTRIBUTE + \"]\";\n+ HTMLImports.importer.documentPreloadSelectors += \",\" + SHIM_SHEET_SELECTOR;\n+ HTMLImports.importer.importsPreloadSelectors += \",\" + SHIM_SHEET_SELECTOR;\n+ HTMLImports.parser.documentSelectors = [ HTMLImports.parser.documentSelectors, SHIM_SHEET_SELECTOR, SHIM_STYLE_SELECTOR ].join(\",\");\n+ var originalParseGeneric = HTMLImports.parser.parseGeneric;\n+ HTMLImports.parser.parseGeneric = function(elt) {\n+ if (elt[SHIMMED_ATTRIBUTE]) {\n+ return;\n+ }\n+ var style = elt.__importElement || elt;\n+ if (!style.hasAttribute(SHIM_ATTRIBUTE)) {\n+ originalParseGeneric.call(this, elt);\n+ return;\n+ }\n+ if (elt.__resource) {\n+ style = elt.ownerDocument.createElement(\"style\");\n+ style.textContent = elt.__resource;\n+ }\n+ HTMLImports.path.resolveUrlsInStyle(style);\n+ style.textContent = ShadowCSS.shimStyle(style);\n+ style.removeAttribute(SHIM_ATTRIBUTE, \"\");\n+ style.setAttribute(SHIMMED_ATTRIBUTE, \"\");\n+ style[SHIMMED_ATTRIBUTE] = true;\n+ if (style.parentNode !== head) {\n+ if (elt.parentNode === head) {\n+ head.replaceChild(style, elt);\n+ } else {\n+ this.addElementToDocument(style);\n+ }\n+ }\n+ style.__importParsed = true;\n+ this.markParsingComplete(elt);\n+ this.parseNext();\n+ };\n+ var hasResource = HTMLImports.parser.hasResource;\n+ HTMLImports.parser.hasResource = function(node) {\n+ if (node.localName === \"link\" && node.rel === \"stylesheet\" && node.hasAttribute(SHIM_ATTRIBUTE)) {\n+ return node.__resource;\n+ } else {\n+ return hasResource.call(this, node);\n+ }\n+ };\n+ }\n+ });\n+ }\n+ scope.ShadowCSS = ShadowCSS;\n+ })(window.WebComponents);\n+}\n+\n+(function(scope) {\n+ if (window.ShadowDOMPolyfill) {\n+ window.wrap = ShadowDOMPolyfill.wrapIfNeeded;\n+ window.unwrap = ShadowDOMPolyfill.unwrapIfNeeded;\n+ } else {\n+ window.wrap = window.unwrap = function(n) {\n+ return n;\n+ };\n+ }\n+})(window.WebComponents);\n+\n+(function(global) {\n+ var registrationsTable = new WeakMap();\n+ var setImmediate;\n+ if (\/Trident\/.test(navigator.userAgent)) {\n+ setImmediate = setTimeout;\n+ } else if (window.setImmediate) {\n+ setImmediate = window.setImmediate;\n+ } else {\n+ var setImmediateQueue = [];\n+ var sentinel = String(Math.random());\n+ window.addEventListener(\"message\", function(e) {\n+ if (e.data === sentinel) {\n+ var queue = setImmediateQueue;\n+ setImmediateQueue = [];\n+ queue.forEach(function(func) {\n+ func();\n+ });\n+ }\n+ });\n+ setImmediate = function(func) {\n+ setImmediateQueue.push(func);\n+ window.postMessage(sentinel, \"*\");\n+ };\n+ }\n+ var isScheduled = false;\n+ var scheduledObservers = [];\n+ function scheduleCallback(observer) {\n+ scheduledObservers.push(observer);\n+ if (!isScheduled) {\n+ isScheduled = true;\n+ setImmediate(dispatchCallbacks);\n+ }\n+ }\n+ function wrapIfNeeded(node) {\n+ return window.ShadowDOMPolyfill && window.ShadowDOMPolyfill.wrapIfNeeded(node) || node;\n+ }\n+ function dispatchCallbacks() {\n+ isScheduled = false;\n+ var observers = scheduledObservers;\n+ scheduledObservers = [];\n+ observers.sort(function(o1, o2) {\n+ return o1.uid_ - o2.uid_;\n+ });\n+ var anyNonEmpty = false;\n+ observers.forEach(function(observer) {\n+ var queue = observer.takeRecords();\n+ removeTransientObserversFor(observer);\n+ if (queue.length) {\n+ observer.callback_(queue, observer);\n+ anyNonEmpty = true;\n+ }\n+ });\n+ if (anyNonEmpty) dispatchCallbacks();\n+ }\n+ function removeTransientObserversFor(observer) {\n+ observer.nodes_.forEach(function(node) {\n+ var registrations = registrationsTable.get(node);\n+ if (!registrations) return;\n+ registrations.forEach(function(registration) {\n+ if (registration.observer === observer) registration.removeTransientObservers();\n+ });\n+ });\n+ }\n+ function forEachAncestorAndObserverEnqueueRecord(target, callback) {\n+ for (var node = target; node; node = node.parentNode) {\n+ var registrations = registrationsTable.get(node);\n+ if (registrations) {\n+ for (var j = 0; j < registrations.length; j++) {\n+ var registration = registrations[j];\n+ var options = registration.options;\n+ if (node !== target && !options.subtree) continue;\n+ var record = callback(options);\n+ if (record) registration.enqueue(record);\n+ }\n+ }\n+ }\n+ }\n+ var uidCounter = 0;\n+ function JsMutationObserver(callback) {\n+ this.callback_ = callback;\n+ this.nodes_ = [];\n+ this.records_ = [];\n+ this.uid_ = ++uidCounter;\n+ }\n+ JsMutationObserver.prototype = {\n+ observe: function(target, options) {\n+ target = wrapIfNeeded(target);\n+ if (!options.childList && !options.attributes && !options.characterData || options.attributeOldValue && !options.attributes || options.attributeFilter && options.attributeFilter.length && !options.attributes || options.characterDataOldValue && !options.characterData) {\n+ throw new SyntaxError();\n+ }\n+ var registrations = registrationsTable.get(target);\n+ if (!registrations) registrationsTable.set(target, registrations = []);\n+ var registration;\n+ for (var i = 0; i < registrations.length; i++) {\n+ if (registrations[i].observer === this) {\n+ registration = registrations[i];\n+ registration.removeListeners();\n+ registration.options = options;\n+ break;\n+ }\n+ }\n+ if (!registration) {\n+ registration = new Registration(this, target, options);\n+ registrations.push(registration);\n+ this.nodes_.push(target);\n+ }\n+ registration.addListeners();\n+ },\n+ disconnect: function() {\n+ this.nodes_.forEach(function(node) {\n+ var registrations = registrationsTable.get(node);\n+ for (var i = 0; i < registrations.length; i++) {\n+ var registration = registrations[i];\n+ if (registration.observer === this) {\n+ registration.removeListeners();\n+ registrations.splice(i, 1);\n+ break;\n+ }\n+ }\n+ }, this);\n+ this.records_ = [];\n+ },\n+ takeRecords: function() {\n+ var copyOfRecords = this.records_;\n+ this.records_ = [];\n+ return copyOfRecords;\n+ }\n+ };\n+ function MutationRecord(type, target) {\n+ this.type = type;\n+ this.target = target;\n+ this.addedNodes = [];\n+ this.removedNodes = [];\n+ this.previousSibling = null;\n+ this.nextSibling = null;\n+ this.attributeName = null;\n+ this.attributeNamespace = null;\n+ this.oldValue = null;\n+ }\n+ function copyMutationRecord(original) {\n+ var record = new MutationRecord(original.type, original.target);\n+ record.addedNodes = original.addedNodes.slice();\n+ record.removedNodes = original.removedNodes.slice();\n+ record.previousSibling = original.previousSibling;\n+ record.nextSibling = original.nextSibling;\n+ record.attributeName = original.attributeName;\n+ record.attributeNamespace = original.attributeNamespace;\n+ record.oldValue = original.oldValue;\n+ return record;\n+ }\n+ var currentRecord, recordWithOldValue;\n+ function getRecord(type, target) {\n+ return currentRecord = new MutationRecord(type, target);\n+ }\n+ function getRecordWithOldValue(oldValue) {\n+ if (recordWithOldValue) return recordWithOldValue;\n+ recordWithOldValue = copyMutationRecord(currentRecord);\n+ recordWithOldValue.oldValue = oldValue;\n+ return recordWithOldValue;\n+ }\n+ function clearRecords() {\n+ currentRecord = recordWithOldValue = undefined;\n+ }\n+ function recordRepresentsCurrentMutation(record) {\n+ return record === recordWithOldValue || record === currentRecord;\n+ }\n+ function selectRecord(lastRecord, newRecord) {\n+ if (lastRecord === newRecord) return lastRecord;\n+ if (recordWithOldValue && recordRepresentsCurrentMutation(lastRecord)) return recordWithOldValue;\n+ return null;\n+ }\n+ function Registration(observer, target, options) {\n+ this.observer = observer;\n+ this.target = target;\n+ this.options = options;\n+ this.transientObservedNodes = [];\n+ }\n+ Registration.prototype = {\n+ enqueue: function(record) {\n+ var records = this.observer.records_;\n+ var length = records.length;\n+ if (records.length > 0) {\n+ var lastRecord = records[length - 1];\n+ var recordToReplaceLast = selectRecord(lastRecord, record);\n+ if (recordToReplaceLast) {\n+ records[length - 1] = recordToReplaceLast;\n+ return;\n+ }\n+ } else {\n+ scheduleCallback(this.observer);\n+ }\n+ records[length] = record;\n+ },\n+ addListeners: function() {\n+ this.addListeners_(this.target);\n+ },\n+ addListeners_: function(node) {\n+ var options = this.options;\n+ if (options.attributes) node.addEventListener(\"DOMAttrModified\", this, true);\n+ if (options.characterData) node.addEventListener(\"DOMCharacterDataModified\", this, true);\n+ if (options.childList) node.addEventListener(\"DOMNodeInserted\", this, true);\n+ if (options.childList || options.subtree) node.addEventListener(\"DOMNodeRemoved\", this, true);\n+ },\n+ removeListeners: function() {\n+ this.removeListeners_(this.target);\n+ },\n+ removeListeners_: function(node) {\n+ var options = this.options;\n+ if (options.attributes) node.removeEventListener(\"DOMAttrModified\", this, true);\n+ if (options.characterData) node.removeEventListener(\"DOMCharacterDataModified\", this, true);\n+ if (options.childList) node.removeEventListener(\"DOMNodeInserted\", this, true);\n+ if (options.childList || options.subtree) node.removeEventListener(\"DOMNodeRemoved\", this, true);\n+ },\n+ addTransientObserver: function(node) {\n+ if (node === this.target) return;\n+ this.addListeners_(node);\n+ this.transientObservedNodes.push(node);\n+ var registrations = registrationsTable.get(node);\n+ if (!registrations) registrationsTable.set(node, registrations = []);\n+ registrations.push(this);\n+ },\n+ removeTransientObservers: function() {\n+ var transientObservedNodes = this.transientObservedNodes;\n+ this.transientObservedNodes = [];\n+ transientObservedNodes.forEach(function(node) {\n+ this.removeListeners_(node);\n+ var registrations = registrationsTable.get(node);\n+ for (var i = 0; i < registrations.length; i++) {\n+ if (registrations[i] === this) {\n+ registrations.splice(i, 1);\n+ break;\n+ }\n+ }\n+ }, this);\n+ },\n+ handleEvent: function(e) {\n+ e.stopImmediatePropagation();\n+ switch (e.type) {\n+ case \"DOMAttrModified\":\n+ var name = e.attrName;\n+ var namespace = e.relatedNode.namespaceURI;\n+ var target = e.target;\n+ var record = new getRecord(\"attributes\", target);\n+ record.attributeName = name;\n+ record.attributeNamespace = namespace;\n+ var oldValue = e.attrChange === MutationEvent.ADDITION ? null : e.prevValue;\n+ forEachAncestorAndObserverEnqueueRecord(target, function(options) {\n+ if (!options.attributes) return;\n+ if (options.attributeFilter && options.attributeFilter.length && options.attributeFilter.indexOf(name) === -1 && options.attributeFilter.indexOf(namespace) === -1) {\n+ return;\n+ }\n+ if (options.attributeOldValue) return getRecordWithOldValue(oldValue);\n+ return record;\n+ });\n+ break;\n+\n+ case \"DOMCharacterDataModified\":\n+ var target = e.target;\n+ var record = getRecord(\"characterData\", target);\n+ var oldValue = e.prevValue;\n+ forEachAncestorAndObserverEnqueueRecord(target, function(options) {\n+ if (!options.characterData) return;\n+ if (options.characterDataOldValue) return getRecordWithOldValue(oldValue);\n+ return record;\n+ });\n+ break;\n+\n+ case \"DOMNodeRemoved\":\n+ this.addTransientObserver(e.target);\n+\n+ case \"DOMNodeInserted\":\n+ var target = e.relatedNode;\n+ var changedNode = e.target;\n+ var addedNodes, removedNodes;\n+ if (e.type === \"DOMNodeInserted\") {\n+ addedNodes = [ changedNode ];\n+ removedNodes = [];\n+ } else {\n+ addedNodes = [];\n+ removedNodes = [ changedNode ];\n+ }\n+ var previousSibling = changedNode.previousSibling;\n+ var nextSibling = changedNode.nextSibling;\n+ var record = getRecord(\"childList\", target);\n+ record.addedNodes = addedNodes;\n+ record.removedNodes = removedNodes;\n+ record.previousSibling = previousSibling;\n+ record.nextSibling = nextSibling;\n+ forEachAncestorAndObserverEnqueueRecord(target, function(options) {\n+ if (!options.childList) return;\n+ return record;\n+ });\n+ }\n+ clearRecords();\n+ }\n+ };\n+ global.JsMutationObserver = JsMutationObserver;\n+ if (!global.MutationObserver) global.MutationObserver = JsMutationObserver;\n+})(this);\n+\n+window.HTMLImports = window.HTMLImports || {\n+ flags: {}\n+};\n+\n+(function(scope) {\n+ var IMPORT_LINK_TYPE = \"import\";\n+ var useNative = Boolean(IMPORT_LINK_TYPE in document.createElement(\"link\"));\n+ var hasShadowDOMPolyfill = Boolean(window.ShadowDOMPolyfill);\n+ var wrap = function(node) {\n+ return hasShadowDOMPolyfill ? ShadowDOMPolyfill.wrapIfNeeded(node) : node;\n+ };\n+ var rootDocument = wrap(document);\n+ var currentScriptDescriptor = {\n+ get: function() {\n+ var script = HTMLImports.currentScript || document.currentScript || (document.readyState !== \"complete\" ? document.scripts[document.scripts.length - 1] : null);\n+ return wrap(script);\n+ },\n+ configurable: true\n+ };\n+ Object.defineProperty(document, \"_currentScript\", currentScriptDescriptor);\n+ Object.defineProperty(rootDocument, \"_currentScript\", currentScriptDescriptor);\n+ var isIE = \/Trident\/.test(navigator.userAgent);\n+ function whenReady(callback, doc) {\n+ doc = doc || rootDocument;\n+ whenDocumentReady(function() {\n+ watchImportsLoad(callback, doc);\n+ }, doc);\n+ }\n+ var requiredReadyState = isIE ? \"complete\" : \"interactive\";\n+ var READY_EVENT = \"readystatechange\";\n+ function isDocumentReady(doc) {\n+ return doc.readyState === \"complete\" || doc.readyState === requiredReadyState;\n+ }\n+ function whenDocumentReady(callback, doc) {\n+ if (!isDocumentReady(doc)) {\n+ var checkReady = function() {\n+ if (doc.readyState === \"complete\" || doc.readyState === requiredReadyState) {\n+ doc.removeEventListener(READY_EVENT, checkReady);\n+ whenDocumentReady(callback, doc);\n+ }\n+ };\n+ doc.addEventListener(READY_EVENT, checkReady);\n+ } else if (callback) {\n+ callback();\n+ }\n+ }\n+ function markTargetLoaded(event) {\n+ event.target.__loaded = true;\n+ }\n+ function watchImportsLoad(callback, doc) {\n+ var imports = doc.querySelectorAll(\"link[rel=import]\");\n+ var loaded = 0, l = imports.length;\n+ function checkDone(d) {\n+ if (loaded == l && callback) {\n+ callback();\n+ }\n+ }\n+ function loadedImport(e) {\n+ markTargetLoaded(e);\n+ loaded++;\n+ checkDone();\n+ }\n+ if (l) {\n+ for (var i = 0, imp; i < l && (imp = imports[i]); i++) {\n+ if (isImportLoaded(imp)) {\n+ loadedImport.call(imp, {\n+ target: imp\n+ });\n+ } else {\n+ imp.addEventListener(\"load\", loadedImport);\n+ imp.addEventListener(\"error\", loadedImport);\n+ }\n+ }\n+ } else {\n+ checkDone();\n+ }\n+ }\n+ function isImportLoaded(link) {\n+ return useNative ? link.__loaded || link.import && link.import.readyState !== \"loading\" : link.__importParsed;\n+ }\n+ if (useNative) {\n+ new MutationObserver(function(mxns) {\n+ for (var i = 0, l = mxns.length, m; i < l && (m = mxns[i]); i++) {\n+ if (m.addedNodes) {\n+ handleImports(m.addedNodes);\n+ }\n+ }\n+ }).observe(document.head, {\n+ childList: true\n+ });\n+ function handleImports(nodes) {\n+ for (var i = 0, l = nodes.length, n; i < l && (n = nodes[i]); i++) {\n+ if (isImport(n)) {\n+ handleImport(n);\n+ }\n+ }\n+ }\n+ function isImport(element) {\n+ return element.localName === \"link\" && element.rel === \"import\";\n+ }\n+ function handleImport(element) {\n+ var loaded = element.import;\n+ if (loaded) {\n+ markTargetLoaded({\n+ target: element\n+ });\n+ } else {\n+ element.addEventListener(\"load\", markTargetLoaded);\n+ element.addEventListener(\"error\", markTargetLoaded);\n+ }\n+ }\n+ (function() {\n+ if (document.readyState === \"loading\") {\n+ var imports = document.querySelectorAll(\"link[rel=import]\");\n+ for (var i = 0, l = imports.length, imp; i < l && (imp = imports[i]); i++) {\n+ handleImport(imp);\n+ }\n+ }\n+ })();\n+ }\n+ whenReady(function() {\n+ HTMLImports.ready = true;\n+ HTMLImports.readyTime = new Date().getTime();\n+ rootDocument.dispatchEvent(new CustomEvent(\"HTMLImportsLoaded\", {\n+ bubbles: true\n+ }));\n+ });\n+ scope.IMPORT_LINK_TYPE = IMPORT_LINK_TYPE;\n+ scope.useNative = useNative;\n+ scope.rootDocument = rootDocument;\n+ scope.whenReady = whenReady;\n+ scope.isIE = isIE;\n+})(HTMLImports);\n+\n+(function(scope) {\n+ var modules = [];\n+ var addModule = function(module) {\n+ modules.push(module);\n+ };\n+ var initializeModules = function() {\n+ modules.forEach(function(module) {\n+ module(scope);\n+ });\n+ };\n+ scope.addModule = addModule;\n+ scope.initializeModules = initializeModules;\n+})(HTMLImports);\n+\n+HTMLImports.addModule(function(scope) {\n+ var CSS_URL_REGEXP = \/(url\$)([^)]*)(\$)\/g;\n+ var CSS_IMPORT_REGEXP = \/(@import[\\s]+(?!url\\())([^;]*)(;)\/g;\n+ var path = {\n+ resolveUrlsInStyle: function(style) {\n+ var doc = style.ownerDocument;\n+ var resolver = doc.createElement(\"a\");\n+ style.textContent = this.resolveUrlsInCssText(style.textContent, resolver);\n+ return style;\n+ },\n+ resolveUrlsInCssText: function(cssText, urlObj) {\n+ var r = this.replaceUrls(cssText, urlObj, CSS_URL_REGEXP);\n+ r = this.replaceUrls(r, urlObj, CSS_IMPORT_REGEXP);\n+ return r;\n+ },\n+ replaceUrls: function(text, urlObj, regexp) {\n+ return text.replace(regexp, function(m, pre, url, post) {\n+ var urlPath = url.replace(\/[\"']\/g, \"\");\n+ urlObj.href = urlPath;\n+ urlPath = urlObj.href;\n+ return pre + \"'\" + urlPath + \"'\" + post;\n+ });\n+ }\n+ };\n+ scope.path = path;\n+});\n+\n+HTMLImports.addModule(function(scope) {\n+ xhr = {\n+ async: true,\n+ ok: function(request) {\n+ return request.status >= 200 && request.status < 300 || request.status === 304 || request.status === 0;\n+ },\n+ load: function(url, next, nextContext) {\n+ var request = new XMLHttpRequest();\n+ if (scope.flags.debug || scope.flags.bust) {\n+ url += \"?\" + Math.random();\n+ }\n+ request.open(\"GET\", url, xhr.async);\n+ request.addEventListener(\"readystatechange\", function(e) {\n+ if (request.readyState === 4) {\n+ var locationHeader = request.getResponseHeader(\"Location\");\n+ var redirectedUrl = null;\n+ if (locationHeader) {\n+ var redirectedUrl = locationHeader.substr(0, 1) === \"\/\" ? location.origin + locationHeader : locationHeader;\n+ }\n+ next.call(nextContext, !xhr.ok(request) && request, request.response || request.responseText, redirectedUrl);\n+ }\n+ });\n+ request.send();\n+ return request;\n+ },\n+ loadDocument: function(url, next, nextContext) {\n+ this.load(url, next, nextContext).responseType = \"document\";\n+ }\n+ };\n+ scope.xhr = xhr;\n+});\n+\n+HTMLImports.addModule(function(scope) {\n+ var xhr = scope.xhr;\n+ var flags = scope.flags;\n+ var Loader = function(onLoad, onComplete) {\n+ this.cache = {};\n+ this.onload = onLoad;\n+ this.oncomplete = onComplete;\n+ this.inflight = 0;\n+ this.pending = {};\n+ };\n+ Loader.prototype = {\n+ addNodes: function(nodes) {\n+ this.inflight += nodes.length;\n+ for (var i = 0, l = nodes.length, n; i < l && (n = nodes[i]); i++) {\n+ this.require(n);\n+ }\n+ this.checkDone();\n+ },\n+ addNode: function(node) {\n+ this.inflight++;\n+ this.require(node);\n+ this.checkDone();\n+ },\n+ require: function(elt) {\n+ var url = elt.src || elt.href;\n+ elt.__nodeUrl = url;\n+ if (!this.dedupe(url, elt)) {\n+ this.fetch(url, elt);\n+ }\n+ },\n+ dedupe: function(url, elt) {\n+ if (this.pending[url]) {\n+ this.pending[url].push(elt);\n+ return true;\n+ }\n+ var resource;\n+ if (this.cache[url]) {\n+ this.onload(url, elt, this.cache[url]);\n+ this.tail();\n+ return true;\n+ }\n+ this.pending[url] = [ elt ];\n+ return false;\n+ },\n+ fetch: function(url, elt) {\n+ flags.load && console.log(\"fetch\", url, elt);\n+ if (url.match(\/^data:\/)) {\n+ var pieces = url.split(\",\");\n+ var header = pieces[0];\n+ var body = pieces[1];\n+ if (header.indexOf(\";base64\") > -1) {\n+ body = atob(body);\n+ } else {\n+ body = decodeURIComponent(body);\n+ }\n+ setTimeout(function() {\n+ this.receive(url, elt, null, body);\n+ }.bind(this), 0);\n+ } else {\n+ var receiveXhr = function(err, resource, redirectedUrl) {\n+ this.receive(url, elt, err, resource, redirectedUrl);\n+ }.bind(this);\n+ xhr.load(url, receiveXhr);\n+ }\n+ },\n+ receive: function(url, elt, err, resource, redirectedUrl) {\n+ this.cache[url] = resource;\n+ var $p = this.pending[url];\n+ for (var i = 0, l = $p.length, p; i < l && (p = $p[i]); i++) {\n+ this.onload(url, p, resource, err, redirectedUrl);\n+ this.tail();\n+ }\n+ this.pending[url] = null;\n+ },\n+ tail: function() {\n+ --this.inflight;\n+ this.checkDone();\n+ },\n+ checkDone: function() {\n+ if (!this.inflight) {\n+ this.oncomplete();\n+ }\n+ }\n+ };\n+ scope.Loader = Loader;\n+});\n+\n+HTMLImports.addModule(function(scope) {\n+ var Observer = function(addCallback) {\n+ this.addCallback = addCallback;\n+ this.mo = new MutationObserver(this.handler.bind(this));\n+ };\n+ Observer.prototype = {\n+ handler: function(mutations) {\n+ for (var i = 0, l = mutations.length, m; i < l && (m = mutations[i]); i++) {\n+ if (m.type === \"childList\" && m.addedNodes.length) {\n+ this.addedNodes(m.addedNodes);\n+ }\n+ }\n+ },\n+ addedNodes: function(nodes) {\n+ if (this.addCallback) {\n+ this.addCallback(nodes);\n+ }\n+ for (var i = 0, l = nodes.length, n, loading; i < l && (n = nodes[i]); i++) {\n+ if (n.children && n.children.length) {\n+ this.addedNodes(n.children);\n+ }\n+ }\n+ },\n+ observe: function(root) {\n+ this.mo.observe(root, {\n+ childList: true,\n+ subtree: true\n+ });\n+ }\n+ };\n+ scope.Observer = Observer;\n+});\n+\n+HTMLImports.addModule(function(scope) {\n+ var path = scope.path;\n+ var rootDocument = scope.rootDocument;\n+ var flags = scope.flags;\n+ var isIE = scope.isIE;\n+ var IMPORT_LINK_TYPE = scope.IMPORT_LINK_TYPE;\n+ var IMPORT_SELECTOR = \"link[rel=\" + IMPORT_LINK_TYPE + \"]\";\n+ var importParser = {\n+ documentSelectors: IMPORT_SELECTOR,\n+ importsSelectors: [ IMPORT_SELECTOR, \"link[rel=stylesheet]\", \"style\", \"script:not([type])\", 'script[type=\"text\/javascript\"]' ].join(\",\"),\n+ map: {\n+ link: \"parseLink\",\n+ script: \"parseScript\",\n+ style: \"parseStyle\"\n+ },\n+ dynamicElements: [],\n+ parseNext: function() {\n+ var next = this.nextToParse();\n+ if (next) {\n+ this.parse(next);\n+ }\n+ },\n+ parse: function(elt) {\n+ if (this.isParsed(elt)) {\n+ flags.parse && console.log(\"[%s] is already parsed\", elt.localName);\n+ return;\n+ }\n+ var fn = this[this.map[elt.localName]];\n+ if (fn) {\n+ this.markParsing(elt);\n+ fn.call(this, elt);\n+ }\n+ },\n+ parseDynamic: function(elt, quiet) {\n+ this.dynamicElements.push(elt);\n+ if (!quiet) {\n+ this.parseNext();\n+ }\n+ },\n+ markParsing: function(elt) {\n+ flags.parse && console.log(\"parsing\", elt);\n+ this.parsingElement = elt;\n+ },\n+ markParsingComplete: function(elt) {\n+ elt.__importParsed = true;\n+ this.markDynamicParsingComplete(elt);\n+ if (elt.__importElement) {\n+ elt.__importElement.__importParsed = true;\n+ this.markDynamicParsingComplete(elt.__importElement);\n+ }\n+ this.parsingElement = null;\n+ flags.parse && console.log(\"completed\", elt);\n+ },\n+ markDynamicParsingComplete: function(elt) {\n+ var i = this.dynamicElements.indexOf(elt);\n+ if (i >= 0) {\n+ this.dynamicElements.splice(i, 1);\n+ }\n+ },\n+ parseImport: function(elt) {\n+ if (HTMLImports.__importsParsingHook) {\n+ HTMLImports.__importsParsingHook(elt);\n+ }\n+ if (elt.import) {\n+ elt.import.__importParsed = true;\n+ }\n+ this.markParsingComplete(elt);\n+ if (elt.__resource && !elt.__error) {\n+ elt.dispatchEvent(new CustomEvent(\"load\", {\n+ bubbles: false\n+ }));\n+ } else {\n+ elt.dispatchEvent(new CustomEvent(\"error\", {\n+ bubbles: false\n+ }));\n+ }\n+ if (elt.__pending) {\n+ var fn;\n+ while (elt.__pending.length) {\n+ fn = elt.__pending.shift();\n+ if (fn) {\n+ fn({\n+ target: elt\n+ });\n+ }\n+ }\n+ }\n+ this.parseNext();\n+ },\n+ parseLink: function(linkElt) {\n+ if (nodeIsImport(linkElt)) {\n+ this.parseImport(linkElt);\n+ } else {\n+ linkElt.href = linkElt.href;\n+ this.parseGeneric(linkElt);\n+ }\n+ },\n+ parseStyle: function(elt) {\n+ var src = elt;\n+ elt = cloneStyle(elt);\n+ elt.__importElement = src;\n+ this.parseGeneric(elt);\n+ },\n+ parseGeneric: function(elt) {\n+ this.trackElement(elt);\n+ this.addElementToDocument(elt);\n+ },\n+ rootImportForElement: function(elt) {\n+ var n = elt;\n+ while (n.ownerDocument.__importLink) {\n+ n = n.ownerDocument.__importLink;\n+ }\n+ return n;\n+ },\n+ addElementToDocument: function(elt) {\n+ var port = this.rootImportForElement(elt.__importElement || elt);\n+ var l = port.__insertedElements = port.__insertedElements || 0;\n+ var refNode = port.nextElementSibling;\n+ for (var i = 0; i < l; i++) {\n+ refNode = refNode && refNode.nextElementSibling;\n+ }\n+ port.parentNode.insertBefore(elt, refNode);\n+ },\n+ trackElement: function(elt, callback) {\n+ var self = this;\n+ var done = function(e) {\n+ if (callback) {\n+ callback(e);\n+ }\n+ self.markParsingComplete(elt);\n+ self.parseNext();\n+ };\n+ elt.addEventListener(\"load\", done);\n+ elt.addEventListener(\"error\", done);\n+ if (isIE && elt.localName === \"style\") {\n+ var fakeLoad = false;\n+ if (elt.textContent.indexOf(\"@import\") == -1) {\n+ fakeLoad = true;\n+ } else if (elt.sheet) {\n+ fakeLoad = true;\n+ var csr = elt.sheet.cssRules;\n+ var len = csr ? csr.length : 0;\n+ for (var i = 0, r; i < len && (r = csr[i]); i++) {\n+ if (r.type === CSSRule.IMPORT_RULE) {\n+ fakeLoad = fakeLoad && Boolean(r.styleSheet);\n+ }\n+ }\n+ }\n+ if (fakeLoad) {\n+ elt.dispatchEvent(new CustomEvent(\"load\", {\n+ bubbles: false\n+ }));\n+ }\n+ }\n+ },\n+ parseScript: function(scriptElt) {\n+ var script = document.createElement(\"script\");\n+ script.__importElement = scriptElt;\n+ script.src = scriptElt.src ? scriptElt.src : generateScriptDataUrl(scriptElt);\n+ scope.currentScript = scriptElt;\n+ this.trackElement(script, function(e) {\n+ script.parentNode.removeChild(script);\n+ scope.currentScript = null;\n+ });\n+ this.addElementToDocument(script);\n+ },\n+ nextToParse: function() {\n+ this._mayParse = [];\n+ return !this.parsingElement && (this.nextToParseInDoc(rootDocument) || this.nextToParseDynamic());\n+ },\n+ nextToParseInDoc: function(doc, link) {\n+ if (doc && this._mayParse.indexOf(doc) < 0) {\n+ this._mayParse.push(doc);\n+ var nodes = doc.querySelectorAll(this.parseSelectorsForNode(doc));\n+ for (var i = 0, l = nodes.length, p = 0, n; i < l && (n = nodes[i]); i++) {\n+ if (!this.isParsed(n)) {\n+ if (this.hasResource(n)) {\n+ return nodeIsImport(n) ? this.nextToParseInDoc(n.import, n) : n;\n+ } else {\n+ return;\n+ }\n+ }\n+ }\n+ }\n+ return link;\n+ },\n+ nextToParseDynamic: function() {\n+ return this.dynamicElements[0];\n+ },\n+ parseSelectorsForNode: function(node) {\n+ var doc = node.ownerDocument || node;\n+ return doc === rootDocument ? this.documentSelectors : this.importsSelectors;\n+ },\n+ isParsed: function(node) {\n+ return node.__importParsed;\n+ },\n+ needsDynamicParsing: function(elt) {\n+ return this.dynamicElements.indexOf(elt) >= 0;\n+ },\n+ hasResource: function(node) {\n+ if (nodeIsImport(node) && node.import === undefined) {\n+ return false;\n+ }\n+ return true;\n+ }\n+ };\n+ function nodeIsImport(elt) {\n+ return elt.localName === \"link\" && elt.rel === IMPORT_LINK_TYPE;\n+ }\n+ function generateScriptDataUrl(script) {\n+ var scriptContent = generateScriptContent(script);\n+ return \"data:text\/javascript;charset=utf-8,\" + encodeURIComponent(scriptContent);\n+ }\n+ function generateScriptContent(script) {\n+ return script.textContent + generateSourceMapHint(script);\n+ }\n+ function generateSourceMapHint(script) {\n+ var owner = script.ownerDocument;\n+ owner.__importedScripts = owner.__importedScripts || 0;\n+ var moniker = script.ownerDocument.baseURI;\n+ var num = owner.__importedScripts ? \"-\" + owner.__importedScripts : \"\";\n+ owner.__importedScripts++;\n+ return \"\\n\/\/# sourceURL=\" + moniker + num + \".js\\n\";\n+ }\n+ function cloneStyle(style) {\n+ var clone = style.ownerDocument.createElement(\"style\");\n+ clone.textContent = style.textContent;\n+ path.resolveUrlsInStyle(clone);\n+ return clone;\n+ }\n+ scope.parser = importParser;\n+ scope.IMPORT_SELECTOR = IMPORT_SELECTOR;\n+});\n+\n+HTMLImports.addModule(function(scope) {\n+ var flags = scope.flags;\n+ var IMPORT_LINK_TYPE = scope.IMPORT_LINK_TYPE;\n+ var IMPORT_SELECTOR = scope.IMPORT_SELECTOR;\n+ var rootDocument = scope.rootDocument;\n+ var Loader = scope.Loader;\n+ var Observer = scope.Observer;\n+ var parser = scope.parser;\n+ var importer = {\n+ documents: {},\n+ documentPreloadSelectors: IMPORT_SELECTOR,\n+ importsPreloadSelectors: [ IMPORT_SELECTOR ].join(\",\"),\n+ loadNode: function(node) {\n+ importLoader.addNode(node);\n+ },\n+ loadSubtree: function(parent) {\n+ var nodes = this.marshalNodes(parent);\n+ importLoader.addNodes(nodes);\n+ },\n+ marshalNodes: function(parent) {\n+ return parent.querySelectorAll(this.loadSelectorsForNode(parent));\n+ },\n+ loadSelectorsForNode: function(node) {\n+ var doc = node.ownerDocument || node;\n+ return doc === rootDocument ? this.documentPreloadSelectors : this.importsPreloadSelectors;\n+ },\n+ loaded: function(url, elt, resource, err, redirectedUrl) {\n+ flags.load && console.log(\"loaded\", url, elt);\n+ elt.__resource = resource;\n+ elt.__error = err;\n+ if (isImportLink(elt)) {\n+ var doc = this.documents[url];\n+ if (doc === undefined) {\n+ doc = err ? null : makeDocument(resource, redirectedUrl || url);\n+ if (doc) {\n+ doc.__importLink = elt;\n+ this.bootDocument(doc);\n+ }\n+ this.documents[url] = doc;\n+ }\n+ elt.import = doc;\n+ }\n+ parser.parseNext();\n+ },\n+ bootDocument: function(doc) {\n+ this.loadSubtree(doc);\n+ this.observer.observe(doc);\n+ parser.parseNext();\n+ },\n+ loadedAll: function() {\n+ parser.parseNext();\n+ }\n+ };\n+ var importLoader = new Loader(importer.loaded.bind(importer), importer.loadedAll.bind(importer));\n+ importer.observer = new Observer();\n+ function isImportLink(elt) {\n+ return isLinkRel(elt, IMPORT_LINK_TYPE);\n+ }\n+ function isLinkRel(elt, rel) {\n+ return elt.localName === \"link\" && elt.getAttribute(\"rel\") === rel;\n+ }\n+ function makeDocument(resource, url) {\n+ var doc = document.implementation.createHTMLDocument(IMPORT_LINK_TYPE);\n+ doc._URL = url;\n+ var base = doc.createElement(\"base\");\n+ base.setAttribute(\"href\", url);\n+ if (!doc.baseURI) {\n+ doc.baseURI = url;\n+ }\n+ var meta = doc.createElement(\"meta\");\n+ meta.setAttribute(\"charset\", \"utf-8\");\n+ doc.head.appendChild(meta);\n+ doc.head.appendChild(base);\n+ doc.body.innerHTML = resource;\n+ if (window.HTMLTemplateElement && HTMLTemplateElement.bootstrap) {\n+ HTMLTemplateElement.bootstrap(doc);\n+ }\n+ return doc;\n+ }\n+ if (!document.baseURI) {\n+ var baseURIDescriptor = {\n+ get: function() {\n+ var base = document.querySelector(\"base\");\n+ return base ? base.href : window.location.href;\n+ },\n+ configurable: true\n+ };\n+ Object.defineProperty(document, \"baseURI\", baseURIDescriptor);\n+ Object.defineProperty(rootDocument, \"baseURI\", baseURIDescriptor);\n+ }\n+ scope.importer = importer;\n+ scope.importLoader = importLoader;\n+});\n+\n+HTMLImports.addModule(function(scope) {\n+ var parser = scope.parser;\n+ var importer = scope.importer;\n+ var dynamic = {\n+ added: function(nodes) {\n+ var owner, parsed;\n+ for (var i = 0, l = nodes.length, n; i < l && (n = nodes[i]); i++) {\n+ if (!owner) {\n+ owner = n.ownerDocument;\n+ parsed = parser.isParsed(owner);\n+ }\n+ loading = this.shouldLoadNode(n);\n+ if (loading) {\n+ importer.loadNode(n);\n+ }\n+ if (this.shouldParseNode(n) && parsed) {\n+ parser.parseDynamic(n, loading);\n+ }\n+ }\n+ },\n+ shouldLoadNode: function(node) {\n+ return node.nodeType === 1 && matches.call(node, importer.loadSelectorsForNode(node));\n+ },\n+ shouldParseNode: function(node) {\n+ return node.nodeType === 1 && matches.call(node, parser.parseSelectorsForNode(node));\n+ }\n+ };\n+ importer.observer.addCallback = dynamic.added.bind(dynamic);\n+ var matches = HTMLElement.prototype.matches || HTMLElement.prototype.matchesSelector || HTMLElement.prototype.webkitMatchesSelector || HTMLElement.prototype.mozMatchesSelector || HTMLElement.prototype.msMatchesSelector;\n+});\n+\n+(function(scope) {\n+ initializeModules = scope.initializeModules;\n+ if (scope.useNative) {\n+ return;\n+ }\n+ if (typeof window.CustomEvent !== \"function\") {\n+ window.CustomEvent = function(inType, dictionary) {\n+ var e = document.createEvent(\"HTMLEvents\");\n+ e.initEvent(inType, dictionary.bubbles === false ? false : true, dictionary.cancelable === false ? false : true, dictionary.detail);\n+ return e;\n+ };\n+ }\n+ initializeModules();\n+ var rootDocument = scope.rootDocument;\n+ function bootstrap() {\n+ HTMLImports.importer.bootDocument(rootDocument);\n+ }\n+ if (document.readyState === \"complete\" || document.readyState === \"interactive\" && !window.attachEvent) {\n+ bootstrap();\n+ } else {\n+ document.addEventListener(\"DOMContentLoaded\", bootstrap);\n+ }\n+})(HTMLImports);\n+\n+window.CustomElements = window.CustomElements || {\n+ flags: {}\n+};\n+\n+(function(scope) {\n+ var flags = scope.flags;\n+ var modules = [];\n+ var addModule = function(module) {\n+ modules.push(module);\n+ };\n+ var initializeModules = function() {\n+ modules.forEach(function(module) {\n+ module(scope);\n+ });\n+ };\n+ scope.addModule = addModule;\n+ scope.initializeModules = initializeModules;\n+ scope.hasNative = Boolean(document.registerElement);\n+ scope.useNative = !flags.register && scope.hasNative && !window.ShadowDOMPolyfill && (!window.HTMLImports || HTMLImports.useNative);\n+})(CustomElements);\n+\n+CustomElements.addModule(function(scope) {\n+ var IMPORT_LINK_TYPE = window.HTMLImports ? HTMLImports.IMPORT_LINK_TYPE : \"none\";\n+ function forSubtree(node, cb) {\n+ findAllElements(node, function(e) {\n+ if (cb(e)) {\n+ return true;\n+ }\n+ forRoots(e, cb);\n+ });\n+ forRoots(node, cb);\n+ }\n+ function findAllElements(node, find, data) {\n+ var e = node.firstElementChild;\n+ if (!e) {\n+ e = node.firstChild;\n+ while (e && e.nodeType !== Node.ELEMENT_NODE) {\n+ e = e.nextSibling;\n+ }\n+ }\n+ while (e) {\n+ if (find(e, data) !== true) {\n+ findAllElements(e, find, data);\n+ }\n+ e = e.nextElementSibling;\n+ }\n+ return null;\n+ }\n+ function forRoots(node, cb) {\n+ var root = node.shadowRoot;\n+ while (root) {\n+ forSubtree(root, cb);\n+ root = root.olderShadowRoot;\n+ }\n+ }\n+ var processingDocuments;\n+ function forDocumentTree(doc, cb) {\n+ processingDocuments = [];\n+ _forDocumentTree(doc, cb);\n+ processingDocuments = null;\n+ }\n+ function _forDocumentTree(doc, cb) {\n+ doc = wrap(doc);\n+ if (processingDocuments.indexOf(doc) >= 0) {\n+ return;\n+ }\n+ processingDocuments.push(doc);\n+ var imports = doc.querySelectorAll(\"link[rel=\" + IMPORT_LINK_TYPE + \"]\");\n+ for (var i = 0, l = imports.length, n; i < l && (n = imports[i]); i++) {\n+ if (n.import) {\n+ _forDocumentTree(n.import, cb);\n+ }\n+ }\n+ cb(doc);\n+ }\n+ scope.forDocumentTree = forDocumentTree;\n+ scope.forSubtree = forSubtree;\n+});\n+\n+CustomElements.addModule(function(scope) {\n+ var flags = scope.flags;\n+ var forSubtree = scope.forSubtree;\n+ var forDocumentTree = scope.forDocumentTree;\n+ function addedNode(node) {\n+ return added(node) || addedSubtree(node);\n+ }\n+ function added(node) {\n+ if (scope.upgrade(node)) {\n+ return true;\n+ }\n+ attached(node);\n+ }\n+ function addedSubtree(node) {\n+ forSubtree(node, function(e) {\n+ if (added(e)) {\n+ return true;\n+ }\n+ });\n+ }\n+ function attachedNode(node) {\n+ attached(node);\n+ if (inDocument(node)) {\n+ forSubtree(node, function(e) {\n+ attached(e);\n+ });\n+ }\n+ }\n+ var hasPolyfillMutations = !window.MutationObserver || window.MutationObserver === window.JsMutationObserver;\n+ scope.hasPolyfillMutations = hasPolyfillMutations;\n+ var isPendingMutations = false;\n+ var pendingMutations = [];\n+ function deferMutation(fn) {\n+ pendingMutations.push(fn);\n+ if (!isPendingMutations) {\n+ isPendingMutations = true;\n+ setTimeout(takeMutations);\n+ }\n+ }\n+ function takeMutations() {\n+ isPendingMutations = false;\n+ var $p = pendingMutations;\n+ for (var i = 0, l = $p.length, p; i < l && (p = $p[i]); i++) {\n+ p();\n+ }\n+ pendingMutations = [];\n+ }\n+ function attached(element) {\n+ if (hasPolyfillMutations) {\n+ deferMutation(function() {\n+ _attached(element);\n+ });\n+ } else {\n+ _attached(element);\n+ }\n+ }\n+ function _attached(element) {\n+ if (element.__upgraded__ && (element.attachedCallback || element.detachedCallback)) {\n+ if (!element.__attached && inDocument(element)) {\n+ element.__attached = true;\n+ if (element.attachedCallback) {\n+ element.attachedCallback();\n+ }\n+ }\n+ }\n+ }\n+ function detachedNode(node) {\n+ detached(node);\n+ forSubtree(node, function(e) {\n+ detached(e);\n+ });\n+ }\n+ function detached(element) {\n+ if (hasPolyfillMutations) {\n+ deferMutation(function() {\n+ _detached(element);\n+ });\n+ } else {\n+ _detached(element);\n+ }\n+ }\n+ function _detached(element) {\n+ if (element.__upgraded__ && (element.attachedCallback || element.detachedCallback)) {\n+ if (element.__attached && !inDocument(element)) {\n+ element.__attached = false;\n+ if (element.detachedCallback) {\n+ element.detachedCallback();\n+ }\n+ }\n+ }\n+ }\n+ function inDocument(element) {\n+ var p = element;\n+ var doc = wrap(document);\n+ while (p) {\n+ if (p == doc) {\n+ return true;\n+ }\n+ p = p.parentNode || p.host;\n+ }\n+ }\n+ function watchShadow(node) {\n+ if (node.shadowRoot && !node.shadowRoot.__watched) {\n+ flags.dom && console.log(\"watching shadow-root for: \", node.localName);\n+ var root = node.shadowRoot;\n+ while (root) {\n+ observe(root);\n+ root = root.olderShadowRoot;\n+ }\n+ }\n+ }\n+ function handler(mutations) {\n+ if (flags.dom) {\n+ var mx = mutations[0];\n+ if (mx && mx.type === \"childList\" && mx.addedNodes) {\n+ if (mx.addedNodes) {\n+ var d = mx.addedNodes[0];\n+ while (d && d !== document && !d.host) {\n+ d = d.parentNode;\n+ }\n+ var u = d && (d.URL || d._URL || d.host && d.host.localName) || \"\";\n+ u = u.split(\"\/?\").shift().split(\"\/\").pop();\n+ }\n+ }\n+ console.group(\"mutations (%d) [%s]\", mutations.length, u || \"\");\n+ }\n+ mutations.forEach(function(mx) {\n+ if (mx.type === \"childList\") {\n+ forEach(mx.addedNodes, function(n) {\n+ if (!n.localName) {\n+ return;\n+ }\n+ addedNode(n);\n+ });\n+ forEach(mx.removedNodes, function(n) {\n+ if (!n.localName) {\n+ return;\n+ }\n+ detachedNode(n);\n+ });\n+ }\n+ });\n+ flags.dom && console.groupEnd();\n+ }\n+ function takeRecords(node) {\n+ node = wrap(node);\n+ if (!node) {\n+ node = wrap(document);\n+ }\n+ while (node.parentNode) {\n+ node = node.parentNode;\n+ }\n+ var observer = node.__observer;\n+ if (observer) {\n+ handler(observer.takeRecords());\n+ takeMutations();\n+ }\n+ }\n+ var forEach = Array.prototype.forEach.call.bind(Array.prototype.forEach);\n+ function observe(inRoot) {\n+ if (inRoot.__observer) {\n+ return;\n+ }\n+ var observer = new MutationObserver(handler);\n+ observer.observe(inRoot, {\n+ childList: true,\n+ subtree: true\n+ });\n+ inRoot.__observer = observer;\n+ }\n+ function upgradeDocument(doc) {\n+ doc = wrap(doc);\n+ flags.dom && console.group(\"upgradeDocument: \", doc.baseURI.split(\"\/\").pop());\n+ addedNode(doc);\n+ observe(doc);\n+ flags.dom && console.groupEnd();\n+ }\n+ function upgradeDocumentTree(doc) {\n+ forDocumentTree(doc, upgradeDocument);\n+ }\n+ var originalCreateShadowRoot = Element.prototype.createShadowRoot;\n+ Element.prototype.createShadowRoot = function() {\n+ var root = originalCreateShadowRoot.call(this);\n+ CustomElements.watchShadow(this);\n+ return root;\n+ };\n+ scope.watchShadow = watchShadow;\n+ scope.upgradeDocumentTree = upgradeDocumentTree;\n+ scope.upgradeSubtree = addedSubtree;\n+ scope.upgradeAll = addedNode;\n+ scope.attachedNode = attachedNode;\n+ scope.takeRecords = takeRecords;\n+});\n+\n+CustomElements.addModule(function(scope) {\n+ var flags = scope.flags;\n+ function upgrade(node) {\n+ if (!node.__upgraded__ && node.nodeType === Node.ELEMENT_NODE) {\n+ var is = node.getAttribute(\"is\");\n+ var definition = scope.getRegisteredDefinition(is || node.localName);\n+ if (definition) {\n+ if (is && definition.tag == node.localName) {\n+ return upgradeWithDefinition(node, definition);\n+ } else if (!is && !definition.extends) {\n+ return upgradeWithDefinition(node, definition);\n+ }\n+ }\n+ }\n+ }\n+ function upgradeWithDefinition(element, definition) {\n+ flags.upgrade && console.group(\"upgrade:\", element.localName);\n+ if (definition.is) {\n+ element.setAttribute(\"is\", definition.is);\n+ }\n+ implementPrototype(element, definition);\n+ element.__upgraded__ = true;\n+ created(element);\n+ scope.attachedNode(element);\n+ scope.upgradeSubtree(element);\n+ flags.upgrade && console.groupEnd();\n+ return element;\n+ }\n+ function implementPrototype(element, definition) {\n+ if (Object.__proto__) {\n+ element.__proto__ = definition.prototype;\n+ } else {\n+ customMixin(element, definition.prototype, definition.native);\n+ element.__proto__ = definition.prototype;\n+ }\n+ }\n+ function customMixin(inTarget, inSrc, inNative) {\n+ var used = {};\n+ var p = inSrc;\n+ while (p !== inNative && p !== HTMLElement.prototype) {\n+ var keys = Object.getOwnPropertyNames(p);\n+ for (var i = 0, k; k = keys[i]; i++) {\n+ if (!used[k]) {\n+ Object.defineProperty(inTarget, k, Object.getOwnPropertyDescriptor(p, k));\n+ used[k] = 1;\n+ }\n+ }\n+ p = Object.getPrototypeOf(p);\n+ }\n+ }\n+ function created(element) {\n+ if (element.createdCallback) {\n+ element.createdCallback();\n+ }\n+ }\n+ scope.upgrade = upgrade;\n+ scope.upgradeWithDefinition = upgradeWithDefinition;\n+ scope.implementPrototype = implementPrototype;\n+});\n+\n+CustomElements.addModule(function(scope) {\n+ var upgradeDocumentTree = scope.upgradeDocumentTree;\n+ var upgrade = scope.upgrade;\n+ var upgradeWithDefinition = scope.upgradeWithDefinition;\n+ var implementPrototype = scope.implementPrototype;\n+ var useNative = scope.useNative;\n+ function register(name, options) {\n+ var definition = options || {};\n+ if (!name) {\n+ throw new Error(\"document.registerElement: first argument `name` must not be empty\");\n+ }\n+ if (name.indexOf(\"-\") < 0) {\n+ throw new Error(\"document.registerElement: first argument ('name') must contain a dash ('-'). Argument provided was '\" + String(name) + \"'.\");\n+ }\n+ if (isReservedTag(name)) {\n+ throw new Error(\"Failed to execute 'registerElement' on 'Document': Registration failed for type '\" + String(name) + \"'. The type name is invalid.\");\n+ }\n+ if (getRegisteredDefinition(name)) {\n+ throw new Error(\"DuplicateDefinitionError: a type with name '\" + String(name) + \"' is already registered\");\n+ }\n+ if (!definition.prototype) {\n+ definition.prototype = Object.create(HTMLElement.prototype);\n+ }\n+ definition.__name = name.toLowerCase();\n+ definition.lifecycle = definition.lifecycle || {};\n+ definition.ancestry = ancestry(definition.extends);\n+ resolveTagName(definition);\n+ resolvePrototypeChain(definition);\n+ overrideAttributeApi(definition.prototype);\n+ registerDefinition(definition.__name, definition);\n+ definition.ctor = generateConstructor(definition);\n+ definition.ctor.prototype = definition.prototype;\n+ definition.prototype.constructor = definition.ctor;\n+ if (scope.ready) {\n+ upgradeDocumentTree(document);\n+ }\n+ return definition.ctor;\n+ }\n+ function overrideAttributeApi(prototype) {\n+ if (prototype.setAttribute._polyfilled) {\n+ return;\n+ }\n+ var setAttribute = prototype.setAttribute;\n+ prototype.setAttribute = function(name, value) {\n+ changeAttribute.call(this, name, value, setAttribute);\n+ };\n+ var removeAttribute = prototype.removeAttribute;\n+ prototype.removeAttribute = function(name) {\n+ changeAttribute.call(this, name, null, removeAttribute);\n+ };\n+ prototype.setAttribute._polyfilled = true;\n+ }\n+ function changeAttribute(name, value, operation) {\n+ name = name.toLowerCase();\n+ var oldValue = this.getAttribute(name);\n+ operation.apply(this, arguments);\n+ var newValue = this.getAttribute(name);\n+ if (this.attributeChangedCallback && newValue !== oldValue) {\n+ this.attributeChangedCallback(name, oldValue, newValue);\n+ }\n+ }\n+ function isReservedTag(name) {\n+ for (var i = 0; i < reservedTagList.length; i++) {\n+ if (name === reservedTagList[i]) {\n+ return true;\n+ }\n+ }\n+ }\n+ var reservedTagList = [ \"annotation-xml\", \"color-profile\", \"font-face\", \"font-face-src\", \"font-face-uri\", \"font-face-format\", \"font-face-name\", \"missing-glyph\" ];\n+ function ancestry(extnds) {\n+ var extendee = getRegisteredDefinition(extnds);\n+ if (extendee) {\n+ return ancestry(extendee.extends).concat([ extendee ]);\n+ }\n+ return [];\n+ }\n+ function resolveTagName(definition) {\n+ var baseTag = definition.extends;\n+ for (var i = 0, a; a = definition.ancestry[i]; i++) {\n+ baseTag = a.is && a.tag;\n+ }\n+ definition.tag = baseTag || definition.__name;\n+ if (baseTag) {\n+ definition.is = definition.__name;\n+ }\n+ }\n+ function resolvePrototypeChain(definition) {\n+ if (!Object.__proto__) {\n+ var nativePrototype = HTMLElement.prototype;\n+ if (definition.is) {\n+ var inst = document.createElement(definition.tag);\n+ var expectedPrototype = Object.getPrototypeOf(inst);\n+ if (expectedPrototype === definition.prototype) {\n+ nativePrototype = expectedPrototype;\n+ }\n+ }\n+ var proto = definition.prototype, ancestor;\n+ while (proto && proto !== nativePrototype) {\n+ ancestor = Object.getPrototypeOf(proto);\n+ proto.__proto__ = ancestor;\n+ proto = ancestor;\n+ }\n+ definition.native = nativePrototype;\n+ }\n+ }\n+ function instantiate(definition) {\n+ return upgradeWithDefinition(domCreateElement(definition.tag), definition);\n+ }\n+ var registry = {};\n+ function getRegisteredDefinition(name) {\n+ if (name) {\n+ return registry[name.toLowerCase()];\n+ }\n+ }\n+ function registerDefinition(name, definition) {\n+ registry[name] = definition;\n+ }\n+ function generateConstructor(definition) {\n+ return function() {\n+ return instantiate(definition);\n+ };\n+ }\n+ var HTML_NAMESPACE = \"http:\/\/www.w3.org\/1999\/xhtml\";\n+ function createElementNS(namespace, tag, typeExtension) {\n+ if (namespace === HTML_NAMESPACE) {\n+ return createElement(tag, typeExtension);\n+ } else {\n+ return domCreateElementNS(namespace, tag);\n+ }\n+ }\n+ function createElement(tag, typeExtension) {\n+ var definition = getRegisteredDefinition(typeExtension || tag);\n+ if (definition) {\n+ if (tag == definition.tag && typeExtension == definition.is) {\n+ return new definition.ctor();\n+ }\n+ if (!typeExtension && !definition.is) {\n+ return new definition.ctor();\n+ }\n+ }\n+ var element;\n+ if (typeExtension) {\n+ element = createElement(tag);\n+ element.setAttribute(\"is\", typeExtension);\n+ return element;\n+ }\n+ element = domCreateElement(tag);\n+ if (tag.indexOf(\"-\") >= 0) {\n+ implementPrototype(element, HTMLElement);\n+ }\n+ return element;\n+ }\n+ function cloneNode(deep) {\n+ var n = domCloneNode.call(this, deep);\n+ upgrade(n);\n+ return n;\n+ }\n+ var domCreateElement = document.createElement.bind(document);\n+ var domCreateElementNS = document.createElementNS.bind(document);\n+ var domCloneNode = Node.prototype.cloneNode;\n+ var isInstance;\n+ if (!Object.__proto__ && !useNative) {\n+ isInstance = function(obj, ctor) {\n+ var p = obj;\n+ while (p) {\n+ if (p === ctor.prototype) {\n+ return true;\n+ }\n+ p = p.__proto__;\n+ }\n+ return false;\n+ };\n+ } else {\n+ isInstance = function(obj, base) {\n+ return obj instanceof base;\n+ };\n+ }\n+ document.registerElement = register;\n+ document.createElement = createElement;\n+ document.createElementNS = createElementNS;\n+ Node.prototype.cloneNode = cloneNode;\n+ scope.registry = registry;\n+ scope.instanceof = isInstance;\n+ scope.reservedTagList = reservedTagList;\n+ scope.getRegisteredDefinition = getRegisteredDefinition;\n+ document.register = document.registerElement;\n+});\n+\n+(function(scope) {\n+ var useNative = scope.useNative;\n+ var initializeModules = scope.initializeModules;\n+ if (useNative) {\n+ var nop = function() {};\n+ scope.watchShadow = nop;\n+ scope.upgrade = nop;\n+ scope.upgradeAll = nop;\n+ scope.upgradeDocumentTree = nop;\n+ scope.upgradeSubtree = nop;\n+ scope.takeRecords = nop;\n+ scope.instanceof = function(obj, base) {\n+ return obj instanceof base;\n+ };\n+ } else {\n+ initializeModules();\n+ }\n+ var upgradeDocumentTree = scope.upgradeDocumentTree;\n+ if (!window.wrap) {\n+ if (window.ShadowDOMPolyfill) {\n+ window.wrap = ShadowDOMPolyfill.wrapIfNeeded;\n+ window.unwrap = ShadowDOMPolyfill.unwrapIfNeeded;\n+ } else {\n+ window.wrap = window.unwrap = function(node) {\n+ return node;\n+ };\n+ }\n+ }\n+ function bootstrap() {\n+ upgradeDocumentTree(wrap(document));\n+ if (window.HTMLImports) {\n+ HTMLImports.__importsParsingHook = function(elt) {\n+ upgradeDocumentTree(wrap(elt.import));\n+ };\n+ }\n+ CustomElements.ready = true;\n+ setTimeout(function() {\n+ CustomElements.readyTime = Date.now();\n+ if (window.HTMLImports) {\n+ CustomElements.elapsed = CustomElements.readyTime - HTMLImports.readyTime;\n+ }\n+ document.dispatchEvent(new CustomEvent(\"WebComponentsReady\", {\n+ bubbles: true\n+ }));\n+ });\n+ }\n+ if (typeof window.CustomEvent !== \"function\") {\n+ window.CustomEvent = function(inType, params) {\n+ params = params || {};\n+ var e = document.createEvent(\"CustomEvent\");\n+ e.initCustomEvent(inType, Boolean(params.bubbles), Boolean(params.cancelable), params.detail);\n+ return e;\n+ };\n+ window.CustomEvent.prototype = window.Event.prototype;\n+ }\n+ if (document.readyState === \"complete\" || scope.flags.eager) {\n+ bootstrap();\n+ } else if (document.readyState === \"interactive\" && !window.attachEvent && (!window.HTMLImports || window.HTMLImports.ready)) {\n+ bootstrap();\n+ } else {\n+ var loadEvent = window.HTMLImports && !HTMLImports.ready ? \"HTMLImportsLoaded\" : \"DOMContentLoaded\";\n+ window.addEventListener(loadEvent, bootstrap);\n+ }\n+})(window.CustomElements);\n+\n+(function(scope) {\n+ if (!Function.prototype.bind) {\n+ Function.prototype.bind = function(scope) {\n+ var self = this;\n+ var args = Array.prototype.slice.call(arguments, 1);\n+ return function() {\n+ var args2 = args.slice();\n+ args2.push.apply(args2, arguments);\n+ return self.apply(scope, args2);\n+ };\n+ };\n+ }\n+})(window.WebComponents);\n+\n+(function(scope) {\n+ \"use strict\";\n+ if (!window.performance) {\n+ var start = Date.now();\n+ window.performance = {\n+ now: function() {\n+ return Date.now() - start;\n+ }\n+ };\n+ }\n+ if (!window.requestAnimationFrame) {\n+ window.requestAnimationFrame = function() {\n+ var nativeRaf = window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame;\n+ return nativeRaf ? function(callback) {\n+ return nativeRaf(function() {\n+ callback(performance.now());\n+ });\n+ } : function(callback) {\n+ return window.setTimeout(callback, 1e3 \/ 60);\n+ };\n+ }();\n+ }\n+ if (!window.cancelAnimationFrame) {\n+ window.cancelAnimationFrame = function() {\n+ return window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || function(id) {\n+ clearTimeout(id);\n+ };\n+ }();\n+ }\n+ var elementDeclarations = [];\n+ var polymerStub = function(name, dictionary) {\n+ if (typeof name !== \"string\" && arguments.length === 1) {\n+ Array.prototype.push.call(arguments, document._currentScript);\n+ }\n+ elementDeclarations.push(arguments);\n+ };\n+ window.Polymer = polymerStub;\n+ scope.consumeDeclarations = function(callback) {\n+ scope.consumeDeclarations = function() {\n+ throw \"Possible attempt to load Polymer twice\";\n+ };\n+ if (callback) {\n+ callback(elementDeclarations);\n+ }\n+ elementDeclarations = null;\n+ };\n+ function installPolymerWarning() {\n+ if (window.Polymer === polymerStub) {\n+ window.Polymer = function() {\n+ throw new Error(\"You tried to use polymer without loading it first. To \" + 'load polymer, ');\n+ };\n+ }\n+ }\n+ if (HTMLImports.useNative) {\n+ installPolymerWarning();\n+ } else {\n+ addEventListener(\"DOMContentLoaded\", installPolymerWarning);\n+ }\n+})(window.WebComponents);\n+\n+(function(scope) {\n+ var style = document.createElement(\"style\");\n+ style.textContent = \"\" + \"body {\" + \"transition: opacity ease-in 0.2s;\" + \" } \\n\" + \"body[unresolved] {\" + \"opacity: 0; display: block; overflow: hidden; position: relative;\" + \" } \\n\";\n+ var head = document.querySelector(\"head\");\n+ head.insertBefore(style, head.firstChild);\n+})(window.WebComponents);\n+\n+(function(scope) {\n+ window.Platform = scope;\n+})(window.WebComponents);\n+\n+module.exports = window.WebComponents;\n","files":[{"status":"M","path":"src\/browser\/ui\/__tests__\/ReactMount-test.js"},{"status":"A","path":"src\/vendor\/third_party\/webcomponents.js"}]}

dillon1000/react

Files changed