diff options
Diffstat (limited to 'catapult/third_party/polymer/components/polymer/polymer-micro.html')
-rw-r--r-- | catapult/third_party/polymer/components/polymer/polymer-micro.html | 821 |
1 files changed, 821 insertions, 0 deletions
diff --git a/catapult/third_party/polymer/components/polymer/polymer-micro.html b/catapult/third_party/polymer/components/polymer/polymer-micro.html new file mode 100644 index 00000000..0944f7f6 --- /dev/null +++ b/catapult/third_party/polymer/components/polymer/polymer-micro.html @@ -0,0 +1,821 @@ +<!-- +@license +Copyright (c) 2014 The Polymer Project Authors. All rights reserved. +This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt +The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt +The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt +Code distributed by Google as part of the polymer project is also +subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt +--><script>(function () { +function resolve() { +document.body.removeAttribute('unresolved'); +} +if (window.WebComponents) { +addEventListener('WebComponentsReady', resolve); +} else { +if (document.readyState === 'interactive' || document.readyState === 'complete') { +resolve(); +} else { +addEventListener('DOMContentLoaded', resolve); +} +} +}());window.Polymer = { +Settings: function () { +var settings = window.Polymer || {}; +if (!settings.noUrlSettings) { +var parts = location.search.slice(1).split('&'); +for (var i = 0, o; i < parts.length && (o = parts[i]); i++) { +o = o.split('='); +o[0] && (settings[o[0]] = o[1] || true); +} +} +settings.wantShadow = settings.dom === 'shadow'; +settings.hasShadow = Boolean(Element.prototype.createShadowRoot); +settings.nativeShadow = settings.hasShadow && !window.ShadowDOMPolyfill; +settings.useShadow = settings.wantShadow && settings.hasShadow; +settings.hasNativeImports = Boolean('import' in document.createElement('link')); +settings.useNativeImports = settings.hasNativeImports; +settings.useNativeCustomElements = !window.CustomElements || window.CustomElements.useNative; +settings.useNativeShadow = settings.useShadow && settings.nativeShadow; +settings.usePolyfillProto = !settings.useNativeCustomElements && !Object.__proto__; +settings.hasNativeCSSProperties = !navigator.userAgent.match(/AppleWebKit\/601|Edge\/15/) && window.CSS && CSS.supports && CSS.supports('box-shadow', '0 0 0 var(--foo)'); +settings.useNativeCSSProperties = settings.hasNativeCSSProperties && settings.lazyRegister && settings.useNativeCSSProperties; +settings.isIE = navigator.userAgent.match('Trident'); +settings.passiveTouchGestures = settings.passiveTouchGestures || false; +return settings; +}() +};(function () { +var userPolymer = window.Polymer; +window.Polymer = function (prototype) { +if (typeof prototype === 'function') { +prototype = prototype.prototype; +} +if (!prototype) { +prototype = {}; +} +prototype = desugar(prototype); +var customCtor = prototype === prototype.constructor.prototype ? prototype.constructor : null; +var options = { prototype: prototype }; +if (prototype.extends) { +options.extends = prototype.extends; +} +Polymer.telemetry._registrate(prototype); +var ctor = document.registerElement(prototype.is, options); +return customCtor || ctor; +}; +var desugar = function (prototype) { +var base = Polymer.Base; +if (prototype.extends) { +base = Polymer.Base._getExtendedPrototype(prototype.extends); +} +prototype = Polymer.Base.chainObject(prototype, base); +prototype.registerCallback(); +return prototype; +}; +if (userPolymer) { +for (var i in userPolymer) { +Polymer[i] = userPolymer[i]; +} +} +Polymer.Class = function (prototype) { +if (!prototype.factoryImpl) { +prototype.factoryImpl = function () { +}; +} +return desugar(prototype).constructor; +}; +}()); +Polymer.telemetry = { +registrations: [], +_regLog: function (prototype) { +console.log('[' + prototype.is + ']: registered'); +}, +_registrate: function (prototype) { +this.registrations.push(prototype); +Polymer.log && this._regLog(prototype); +}, +dumpRegistrations: function () { +this.registrations.forEach(this._regLog); +} +};Object.defineProperty(window, 'currentImport', { +enumerable: true, +configurable: true, +get: function () { +return (document._currentScript || document.currentScript || {}).ownerDocument; +} +});Polymer.RenderStatus = { +_ready: false, +_callbacks: [], +whenReady: function (cb) { +if (this._ready) { +cb(); +} else { +this._callbacks.push(cb); +} +}, +_makeReady: function () { +this._ready = true; +for (var i = 0; i < this._callbacks.length; i++) { +this._callbacks[i](); +} +this._callbacks = []; +}, +_catchFirstRender: function () { +requestAnimationFrame(function () { +Polymer.RenderStatus._makeReady(); +}); +}, +_afterNextRenderQueue: [], +_waitingNextRender: false, +afterNextRender: function (element, fn, args) { +this._watchNextRender(); +this._afterNextRenderQueue.push([ +element, +fn, +args +]); +}, +hasRendered: function () { +return this._ready; +}, +_watchNextRender: function () { +if (!this._waitingNextRender) { +this._waitingNextRender = true; +var fn = function () { +Polymer.RenderStatus._flushNextRender(); +}; +if (!this._ready) { +this.whenReady(fn); +} else { +requestAnimationFrame(fn); +} +} +}, +_flushNextRender: function () { +var self = this; +setTimeout(function () { +self._flushRenderCallbacks(self._afterNextRenderQueue); +self._afterNextRenderQueue = []; +self._waitingNextRender = false; +}); +}, +_flushRenderCallbacks: function (callbacks) { +for (var i = 0, h; i < callbacks.length; i++) { +h = callbacks[i]; +h[1].apply(h[0], h[2] || Polymer.nar); +} +} +}; +if (window.HTMLImports) { +HTMLImports.whenReady(function () { +Polymer.RenderStatus._catchFirstRender(); +}); +} else { +Polymer.RenderStatus._catchFirstRender(); +} +Polymer.ImportStatus = Polymer.RenderStatus; +Polymer.ImportStatus.whenLoaded = Polymer.ImportStatus.whenReady;(function () { +'use strict'; +var settings = Polymer.Settings; +Polymer.Base = { +__isPolymerInstance__: true, +_addFeature: function (feature) { +this.mixin(this, feature); +}, +registerCallback: function () { +if (settings.lazyRegister === 'max') { +if (this.beforeRegister) { +this.beforeRegister(); +} +} else { +this._desugarBehaviors(); +for (var i = 0, b; i < this.behaviors.length; i++) { +b = this.behaviors[i]; +if (b.beforeRegister) { +b.beforeRegister.call(this); +} +} +if (this.beforeRegister) { +this.beforeRegister(); +} +} +this._registerFeatures(); +if (!settings.lazyRegister) { +this.ensureRegisterFinished(); +} +}, +createdCallback: function () { +if (settings.disableUpgradeEnabled) { +if (this.hasAttribute('disable-upgrade')) { +this._propertySetter = disableUpgradePropertySetter; +this._configValue = null; +this.__data__ = {}; +return; +} else { +this.__hasInitialized = true; +} +} +this.__initialize(); +}, +__initialize: function () { +if (!this.__hasRegisterFinished) { +this._ensureRegisterFinished(this.__proto__); +} +Polymer.telemetry.instanceCount++; +this.root = this; +for (var i = 0, b; i < this.behaviors.length; i++) { +b = this.behaviors[i]; +if (b.created) { +b.created.call(this); +} +} +if (this.created) { +this.created(); +} +this._initFeatures(); +}, +ensureRegisterFinished: function () { +this._ensureRegisterFinished(this); +}, +_ensureRegisterFinished: function (proto) { +if (proto.__hasRegisterFinished !== proto.is || !proto.is) { +if (settings.lazyRegister === 'max') { +proto._desugarBehaviors(); +for (var i = 0, b; i < proto.behaviors.length; i++) { +b = proto.behaviors[i]; +if (b.beforeRegister) { +b.beforeRegister.call(proto); +} +} +} +proto.__hasRegisterFinished = proto.is; +if (proto._finishRegisterFeatures) { +proto._finishRegisterFeatures(); +} +for (var j = 0, pb; j < proto.behaviors.length; j++) { +pb = proto.behaviors[j]; +if (pb.registered) { +pb.registered.call(proto); +} +} +if (proto.registered) { +proto.registered(); +} +if (settings.usePolyfillProto && proto !== this) { +proto.extend(this, proto); +} +} +}, +attachedCallback: function () { +var self = this; +Polymer.RenderStatus.whenReady(function () { +self.isAttached = true; +for (var i = 0, b; i < self.behaviors.length; i++) { +b = self.behaviors[i]; +if (b.attached) { +b.attached.call(self); +} +} +if (self.attached) { +self.attached(); +} +}); +}, +detachedCallback: function () { +var self = this; +Polymer.RenderStatus.whenReady(function () { +self.isAttached = false; +for (var i = 0, b; i < self.behaviors.length; i++) { +b = self.behaviors[i]; +if (b.detached) { +b.detached.call(self); +} +} +if (self.detached) { +self.detached(); +} +}); +}, +attributeChangedCallback: function (name, oldValue, newValue) { +this._attributeChangedImpl(name); +for (var i = 0, b; i < this.behaviors.length; i++) { +b = this.behaviors[i]; +if (b.attributeChanged) { +b.attributeChanged.call(this, name, oldValue, newValue); +} +} +if (this.attributeChanged) { +this.attributeChanged(name, oldValue, newValue); +} +}, +_attributeChangedImpl: function (name) { +this._setAttributeToProperty(this, name); +}, +extend: function (target, source) { +if (target && source) { +var n$ = Object.getOwnPropertyNames(source); +for (var i = 0, n; i < n$.length && (n = n$[i]); i++) { +this.copyOwnProperty(n, source, target); +} +} +return target || source; +}, +mixin: function (target, source) { +for (var i in source) { +target[i] = source[i]; +} +return target; +}, +copyOwnProperty: function (name, source, target) { +var pd = Object.getOwnPropertyDescriptor(source, name); +if (pd) { +Object.defineProperty(target, name, pd); +} +}, +_logger: function (level, args) { +if (args.length === 1 && Array.isArray(args[0])) { +args = args[0]; +} +switch (level) { +case 'log': +case 'warn': +case 'error': +console[level].apply(console, args); +break; +} +}, +_log: function () { +var args = Array.prototype.slice.call(arguments, 0); +this._logger('log', args); +}, +_warn: function () { +var args = Array.prototype.slice.call(arguments, 0); +this._logger('warn', args); +}, +_error: function () { +var args = Array.prototype.slice.call(arguments, 0); +this._logger('error', args); +}, +_logf: function () { +return this._logPrefix.concat(this.is).concat(Array.prototype.slice.call(arguments, 0)); +} +}; +Polymer.Base._logPrefix = function () { +var color = window.chrome && !/edge/i.test(navigator.userAgent) || /firefox/i.test(navigator.userAgent); +return color ? [ +'%c[%s::%s]:', +'font-weight: bold; background-color:#EEEE00;' +] : ['[%s::%s]:']; +}(); +Polymer.Base.chainObject = function (object, inherited) { +if (object && inherited && object !== inherited) { +if (!Object.__proto__) { +object = Polymer.Base.extend(Object.create(inherited), object); +} +object.__proto__ = inherited; +} +return object; +}; +Polymer.Base = Polymer.Base.chainObject(Polymer.Base, HTMLElement.prototype); +Polymer.BaseDescriptors = {}; +var disableUpgradePropertySetter; +if (settings.disableUpgradeEnabled) { +disableUpgradePropertySetter = function (property, value) { +this.__data__[property] = value; +}; +var origAttributeChangedCallback = Polymer.Base.attributeChangedCallback; +Polymer.Base.attributeChangedCallback = function (name, oldValue, newValue) { +if (!this.__hasInitialized && name === 'disable-upgrade') { +this.__hasInitialized = true; +this._propertySetter = Polymer.Bind._modelApi._propertySetter; +this._configValue = Polymer.Base._configValue; +this.__initialize(); +} +origAttributeChangedCallback.call(this, name, oldValue, newValue); +}; +} +if (window.CustomElements) { +Polymer.instanceof = CustomElements.instanceof; +} else { +Polymer.instanceof = function (obj, ctor) { +return obj instanceof ctor; +}; +} +Polymer.isInstance = function (obj) { +return Boolean(obj && obj.__isPolymerInstance__); +}; +Polymer.telemetry.instanceCount = 0; +}());(function () { +var modules = {}; +var lcModules = {}; +var findModule = function (id) { +return modules[id] || lcModules[id.toLowerCase()]; +}; +var DomModule = function () { +return document.createElement('dom-module'); +}; +DomModule.prototype = Object.create(HTMLElement.prototype); +Polymer.Base.mixin(DomModule.prototype, { +createdCallback: function () { +this.register(); +}, +register: function (id) { +id = id || this.id || this.getAttribute('name') || this.getAttribute('is'); +if (id) { +this.id = id; +modules[id] = this; +lcModules[id.toLowerCase()] = this; +} +}, +import: function (id, selector) { +if (id) { +var m = findModule(id); +if (!m) { +forceDomModulesUpgrade(); +m = findModule(id); +} +if (m && selector) { +m = m.querySelector(selector); +} +return m; +} +} +}); +Object.defineProperty(DomModule.prototype, 'constructor', { +value: DomModule, +configurable: true, +writable: true +}); +var cePolyfill = window.CustomElements && !CustomElements.useNative; +document.registerElement('dom-module', DomModule); +function forceDomModulesUpgrade() { +if (cePolyfill) { +var script = document._currentScript || document.currentScript; +var doc = script && script.ownerDocument || document; +var modules = doc.querySelectorAll('dom-module'); +for (var i = modules.length - 1, m; i >= 0 && (m = modules[i]); i--) { +if (m.__upgraded__) { +return; +} else { +CustomElements.upgrade(m); +} +} +} +} +}());Polymer.Base._addFeature({ +_prepIs: function () { +if (!this.is) { +var module = (document._currentScript || document.currentScript).parentNode; +if (module.localName === 'dom-module') { +var id = module.id || module.getAttribute('name') || module.getAttribute('is'); +this.is = id; +} +} +if (this.is) { +this.is = this.is.toLowerCase(); +} +} +});Polymer.Base._addFeature({ +behaviors: [], +_desugarBehaviors: function () { +if (this.behaviors.length) { +this.behaviors = this._desugarSomeBehaviors(this.behaviors); +} +}, +_desugarSomeBehaviors: function (behaviors) { +var behaviorSet = []; +behaviors = this._flattenBehaviorsList(behaviors); +for (var i = behaviors.length - 1; i >= 0; i--) { +var b = behaviors[i]; +if (behaviorSet.indexOf(b) === -1) { +this._mixinBehavior(b); +behaviorSet.unshift(b); +} +} +return behaviorSet; +}, +_flattenBehaviorsList: function (behaviors) { +var flat = []; +for (var i = 0; i < behaviors.length; i++) { +var b = behaviors[i]; +if (b instanceof Array) { +flat = flat.concat(this._flattenBehaviorsList(b)); +} else if (b) { +flat.push(b); +} else { +this._warn(this._logf('_flattenBehaviorsList', 'behavior is null, check for missing or 404 import')); +} +} +return flat; +}, +_mixinBehavior: function (b) { +var n$ = Object.getOwnPropertyNames(b); +var useAssignment = b._noAccessors; +for (var i = 0, n; i < n$.length && (n = n$[i]); i++) { +if (!Polymer.Base._behaviorProperties[n] && !this.hasOwnProperty(n)) { +if (useAssignment) { +this[n] = b[n]; +} else { +this.copyOwnProperty(n, b, this); +} +} +} +}, +_prepBehaviors: function () { +this._prepFlattenedBehaviors(this.behaviors); +}, +_prepFlattenedBehaviors: function (behaviors) { +for (var i = 0, l = behaviors.length; i < l; i++) { +this._prepBehavior(behaviors[i]); +} +this._prepBehavior(this); +}, +_marshalBehaviors: function () { +for (var i = 0; i < this.behaviors.length; i++) { +this._marshalBehavior(this.behaviors[i]); +} +this._marshalBehavior(this); +} +}); +Polymer.Base._behaviorProperties = { +hostAttributes: true, +beforeRegister: true, +registered: true, +properties: true, +observers: true, +listeners: true, +created: true, +attached: true, +detached: true, +attributeChanged: true, +ready: true, +_noAccessors: true +};Polymer.Base._addFeature({ +_getExtendedPrototype: function (tag) { +return this._getExtendedNativePrototype(tag); +}, +_nativePrototypes: {}, +_getExtendedNativePrototype: function (tag) { +var p = this._nativePrototypes[tag]; +if (!p) { +p = Object.create(this.getNativePrototype(tag)); +var p$ = Object.getOwnPropertyNames(Polymer.Base); +for (var i = 0, n; i < p$.length && (n = p$[i]); i++) { +if (!Polymer.BaseDescriptors[n]) { +p[n] = Polymer.Base[n]; +} +} +Object.defineProperties(p, Polymer.BaseDescriptors); +this._nativePrototypes[tag] = p; +} +return p; +}, +getNativePrototype: function (tag) { +return Object.getPrototypeOf(document.createElement(tag)); +} +});Polymer.Base._addFeature({ +_prepConstructor: function () { +this._factoryArgs = this.extends ? [ +this.extends, +this.is +] : [this.is]; +var ctor = function () { +return this._factory(arguments); +}; +if (this.hasOwnProperty('extends')) { +ctor.extends = this.extends; +} +Object.defineProperty(this, 'constructor', { +value: ctor, +writable: true, +configurable: true +}); +ctor.prototype = this; +}, +_factory: function (args) { +var elt = document.createElement.apply(document, this._factoryArgs); +if (this.factoryImpl) { +this.factoryImpl.apply(elt, args); +} +return elt; +} +});Polymer.nob = Object.create(null); +Polymer.Base._addFeature({ +getPropertyInfo: function (property) { +var info = this._getPropertyInfo(property, this.properties); +if (!info) { +for (var i = 0; i < this.behaviors.length; i++) { +info = this._getPropertyInfo(property, this.behaviors[i].properties); +if (info) { +return info; +} +} +} +return info || Polymer.nob; +}, +_getPropertyInfo: function (property, properties) { +var p = properties && properties[property]; +if (typeof p === 'function') { +p = properties[property] = { type: p }; +} +if (p) { +p.defined = true; +} +return p; +}, +_prepPropertyInfo: function () { +this._propertyInfo = {}; +for (var i = 0; i < this.behaviors.length; i++) { +this._addPropertyInfo(this._propertyInfo, this.behaviors[i].properties); +} +this._addPropertyInfo(this._propertyInfo, this.properties); +this._addPropertyInfo(this._propertyInfo, this._propertyEffects); +}, +_addPropertyInfo: function (target, source) { +if (source) { +var t, s; +for (var i in source) { +t = target[i]; +s = source[i]; +if (i[0] === '_' && !s.readOnly) { +continue; +} +if (!target[i]) { +target[i] = { +type: typeof s === 'function' ? s : s.type, +readOnly: s.readOnly, +attribute: Polymer.CaseMap.camelToDashCase(i) +}; +} else { +if (!t.type) { +t.type = s.type; +} +if (!t.readOnly) { +t.readOnly = s.readOnly; +} +} +} +} +} +}); +(function () { +var propertiesDesc = { +configurable: true, +writable: true, +enumerable: true, +value: {} +}; +Polymer.BaseDescriptors.properties = propertiesDesc; +Object.defineProperty(Polymer.Base, 'properties', propertiesDesc); +}());Polymer.CaseMap = { +_caseMap: {}, +_rx: { +dashToCamel: /-[a-z]/g, +camelToDash: /([A-Z])/g +}, +dashToCamelCase: function (dash) { +return this._caseMap[dash] || (this._caseMap[dash] = dash.indexOf('-') < 0 ? dash : dash.replace(this._rx.dashToCamel, function (m) { +return m[1].toUpperCase(); +})); +}, +camelToDashCase: function (camel) { +return this._caseMap[camel] || (this._caseMap[camel] = camel.replace(this._rx.camelToDash, '-$1').toLowerCase()); +} +};Polymer.Base._addFeature({ +_addHostAttributes: function (attributes) { +if (!this._aggregatedAttributes) { +this._aggregatedAttributes = {}; +} +if (attributes) { +this.mixin(this._aggregatedAttributes, attributes); +} +}, +_marshalHostAttributes: function () { +if (this._aggregatedAttributes) { +this._applyAttributes(this, this._aggregatedAttributes); +} +}, +_applyAttributes: function (node, attr$) { +for (var n in attr$) { +if (!this.hasAttribute(n) && n !== 'class') { +var v = attr$[n]; +this.serializeValueToAttribute(v, n, this); +} +} +}, +_marshalAttributes: function () { +this._takeAttributesToModel(this); +}, +_takeAttributesToModel: function (model) { +if (this.hasAttributes()) { +for (var i in this._propertyInfo) { +var info = this._propertyInfo[i]; +if (this.hasAttribute(info.attribute)) { +this._setAttributeToProperty(model, info.attribute, i, info); +} +} +} +}, +_setAttributeToProperty: function (model, attribute, property, info) { +if (!this._serializing) { +property = property || Polymer.CaseMap.dashToCamelCase(attribute); +info = info || this._propertyInfo && this._propertyInfo[property]; +if (info && !info.readOnly) { +var v = this.getAttribute(attribute); +model[property] = this.deserialize(v, info.type); +} +} +}, +_serializing: false, +reflectPropertyToAttribute: function (property, attribute, value) { +this._serializing = true; +value = value === undefined ? this[property] : value; +this.serializeValueToAttribute(value, attribute || Polymer.CaseMap.camelToDashCase(property)); +this._serializing = false; +}, +serializeValueToAttribute: function (value, attribute, node) { +var str = this.serialize(value); +node = node || this; +if (str === undefined) { +node.removeAttribute(attribute); +} else { +node.setAttribute(attribute, str); +} +}, +deserialize: function (value, type) { +switch (type) { +case Number: +value = Number(value); +break; +case Boolean: +value = value != null; +break; +case Object: +try { +value = JSON.parse(value); +} catch (x) { +} +break; +case Array: +try { +value = JSON.parse(value); +} catch (x) { +value = null; +console.warn('Polymer::Attributes: couldn`t decode Array as JSON'); +} +break; +case Date: +value = new Date(value); +break; +case String: +default: +break; +} +return value; +}, +serialize: function (value) { +switch (typeof value) { +case 'boolean': +return value ? '' : undefined; +case 'object': +if (value instanceof Date) { +return value.toString(); +} else if (value) { +try { +return JSON.stringify(value); +} catch (x) { +return ''; +} +} +default: +return value != null ? value : undefined; +} +} +});Polymer.version = "1.11.3";Polymer.Base._addFeature({ +_registerFeatures: function () { +this._prepIs(); +this._prepBehaviors(); +this._prepConstructor(); +this._prepPropertyInfo(); +}, +_prepBehavior: function (b) { +this._addHostAttributes(b.hostAttributes); +}, +_marshalBehavior: function (b) { +}, +_initFeatures: function () { +this._marshalHostAttributes(); +this._marshalBehaviors(); +} +});</script> + + + + + + + + + + + |