| <!-- |
| @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> |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |