diff options
Diffstat (limited to 'static/bower_components/polymer/polymer-micro.html')
| -rw-r--r-- | static/bower_components/polymer/polymer-micro.html | 529 |
1 files changed, 529 insertions, 0 deletions
diff --git a/static/bower_components/polymer/polymer-micro.html b/static/bower_components/polymer/polymer-micro.html new file mode 100644 index 0000000..4bf4234 --- /dev/null +++ b/static/bower_components/polymer/polymer-micro.html @@ -0,0 +1,529 @@ +<!-- +@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); +} +} +}()); +Polymer = { +Settings: function () { +var user = window.Polymer || {}; +location.search.slice(1).split('&').forEach(function (o) { +o = o.split('='); +o[0] && (user[o[0]] = o[1] || true); +}); +var wantShadow = user.dom === 'shadow'; +var hasShadow = Boolean(Element.prototype.createShadowRoot); +var nativeShadow = hasShadow && !window.ShadowDOMPolyfill; +var useShadow = wantShadow && hasShadow; +var hasNativeImports = Boolean('import' in document.createElement('link')); +var useNativeImports = hasNativeImports; +var useNativeCustomElements = !window.CustomElements || window.CustomElements.useNative; +return { +wantShadow: wantShadow, +hasShadow: hasShadow, +nativeShadow: nativeShadow, +useShadow: useShadow, +useNativeShadow: useShadow && nativeShadow, +useNativeImports: useNativeImports, +useNativeCustomElements: useNativeCustomElements +}; +}() +}; +(function () { +var userPolymer = window.Polymer; +window.Polymer = function (prototype) { +var ctor = desugar(prototype); +prototype = ctor.prototype; +var options = { prototype: prototype }; +if (prototype.extends) { +options.extends = prototype.extends; +} +Polymer.telemetry._registrate(prototype); +document.registerElement(prototype.is, options); +return ctor; +}; +var desugar = function (prototype) { +prototype = Polymer.Base.chainObject(prototype, Polymer.Base); +prototype.registerCallback(); +return prototype.constructor; +}; +window.Polymer = Polymer; +if (userPolymer) { +for (var i in userPolymer) { +Polymer[i] = userPolymer[i]; +} +} +Polymer.Class = desugar; +}()); +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.Base = { +_addFeature: function (feature) { +this.extend(this, feature); +}, +registerCallback: function () { +this._registerFeatures(); +this._doBehavior('registered'); +}, +createdCallback: function () { +Polymer.telemetry.instanceCount++; +this.root = this; +this._doBehavior('created'); +this._initFeatures(); +}, +attachedCallback: function () { +this.isAttached = true; +this._doBehavior('attached'); +}, +detachedCallback: function () { +this.isAttached = false; +this._doBehavior('detached'); +}, +attributeChangedCallback: function (name) { +this._setAttributeToProperty(this, name); +this._doBehavior('attributeChanged', arguments); +}, +extend: function (prototype, api) { +if (prototype && api) { +Object.getOwnPropertyNames(api).forEach(function (n) { +this.copyOwnProperty(n, api, prototype); +}, this); +} +return prototype || api; +}, +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); +} +}, +_log: console.log.apply.bind(console.log, console), +_warn: console.warn.apply.bind(console.warn, console), +_error: console.error.apply.bind(console.error, console), +_logf: function () { +return this._logPrefix.concat([this.is]).concat(Array.prototype.slice.call(arguments, 0)); +} +}; +Polymer.Base._logPrefix = function () { +var color = window.chrome || /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.telemetry.instanceCount = 0; +(function () { +var modules = {}; +var DomModule = function () { +return document.createElement('dom-module'); +}; +DomModule.prototype = Object.create(HTMLElement.prototype); +DomModule.prototype.constructor = DomModule; +DomModule.prototype.createdCallback = function () { +var id = this.id || this.getAttribute('name') || this.getAttribute('is'); +if (id) { +this.id = id; +modules[id] = this; +} +}; +DomModule.prototype.import = function (id, slctr) { +var m = modules[id]; +if (!m) { +forceDocumentUpgrade(); +m = modules[id]; +} +if (m && slctr) { +m = m.querySelector(slctr); +} +return m; +}; +var cePolyfill = window.CustomElements && !CustomElements.useNative; +if (cePolyfill) { +var ready = CustomElements.ready; +CustomElements.ready = true; +} +document.registerElement('dom-module', DomModule); +if (cePolyfill) { +CustomElements.ready = ready; +} +function forceDocumentUpgrade() { +if (cePolyfill) { +var script = document._currentScript || document.currentScript; +if (script) { +CustomElements.upgradeAll(script.ownerDocument); +} +} +} +}()); +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; +} +} +} +}); +Polymer.Base._addFeature({ +behaviors: [], +_prepBehaviors: function () { +if (this.behaviors.length) { +this.behaviors = this._flattenBehaviorsList(this.behaviors); +} +this._prepAllBehaviors(this.behaviors); +}, +_flattenBehaviorsList: function (behaviors) { +var flat = []; +behaviors.forEach(function (b) { +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')); +} +}, this); +return flat; +}, +_prepAllBehaviors: function (behaviors) { +for (var i = behaviors.length - 1; i >= 0; i--) { +this._mixinBehavior(behaviors[i]); +} +for (var i = 0, l = behaviors.length; i < l; i++) { +this._prepBehavior(behaviors[i]); +} +this._prepBehavior(this); +}, +_mixinBehavior: function (b) { +Object.getOwnPropertyNames(b).forEach(function (n) { +switch (n) { +case 'hostAttributes': +case 'registered': +case 'properties': +case 'observers': +case 'listeners': +case 'created': +case 'attached': +case 'detached': +case 'attributeChanged': +case 'configure': +case 'ready': +break; +default: +if (!this.hasOwnProperty(n)) { +this.copyOwnProperty(n, b, this); +} +break; +} +}, this); +}, +_doBehavior: function (name, args) { +this.behaviors.forEach(function (b) { +this._invokeBehavior(b, name, args); +}, this); +this._invokeBehavior(this, name, args); +}, +_invokeBehavior: function (b, name, args) { +var fn = b[name]; +if (fn) { +fn.apply(this, args || Polymer.nar); +} +}, +_marshalBehaviors: function () { +this.behaviors.forEach(function (b) { +this._marshalBehavior(b); +}, this); +this._marshalBehavior(this); +} +}); +Polymer.Base._addFeature({ +_prepExtends: function () { +if (this.extends) { +this.__proto__ = this._getExtendedPrototype(this.extends); +} +}, +_getExtendedPrototype: function (tag) { +return this._getExtendedNativePrototype(tag); +}, +_nativePrototypes: {}, +_getExtendedNativePrototype: function (tag) { +var p = this._nativePrototypes[tag]; +if (!p) { +var np = this.getNativePrototype(tag); +p = this.extend(Object.create(np), Polymer.Base); +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({ +properties: {}, +getPropertyInfo: function (property) { +var info = this._getPropertyInfo(property, this.properties); +if (!info) { +this.behaviors.some(function (b) { +return info = this._getPropertyInfo(property, b.properties); +}, this); +} +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; +} +}); +Polymer.CaseMap = { +_caseMap: {}, +dashToCamelCase: function (dash) { +var mapped = Polymer.CaseMap._caseMap[dash]; +if (mapped) { +return mapped; +} +if (dash.indexOf('-') < 0) { +return Polymer.CaseMap._caseMap[dash] = dash; +} +return Polymer.CaseMap._caseMap[dash] = dash.replace(/-([a-z])/g, function (m) { +return m[1].toUpperCase(); +}); +}, +camelToDashCase: function (camel) { +var mapped = Polymer.CaseMap._caseMap[camel]; +if (mapped) { +return mapped; +} +return Polymer.CaseMap._caseMap[camel] = camel.replace(/([a-z][A-Z])/g, function (g) { +return g[0] + '-' + g[1].toLowerCase(); +}); +} +}; +Polymer.Base._addFeature({ +_prepAttributes: function () { +this._aggregatedAttributes = {}; +}, +_addHostAttributes: function (attributes) { +if (attributes) { +this.mixin(this._aggregatedAttributes, attributes); +} +}, +_marshalHostAttributes: function () { +this._applyAttributes(this, this._aggregatedAttributes); +}, +_applyAttributes: function (node, attr$) { +for (var n in attr$) { +if (!this.hasAttribute(n) && n !== 'class') { +this.serializeValueToAttribute(attr$[n], n, this); +} +} +}, +_marshalAttributes: function () { +this._takeAttributesToModel(this); +}, +_takeAttributesToModel: function (model) { +for (var i = 0, l = this.attributes.length; i < l; i++) { +this._setAttributeToProperty(model, this.attributes[i].name); +} +}, +_setAttributeToProperty: function (model, attrName) { +if (!this._serializing) { +var propName = Polymer.CaseMap.dashToCamelCase(attrName); +var info = this.getPropertyInfo(propName); +if (info.defined || this._propertyEffects && this._propertyEffects[propName]) { +var val = this.getAttribute(attrName); +model[propName] = this.deserialize(val, info.type); +} +} +}, +_serializing: false, +reflectPropertyToAttribute: function (name) { +this._serializing = true; +this.serializeValueToAttribute(this[name], Polymer.CaseMap.camelToDashCase(name)); +this._serializing = false; +}, +serializeValueToAttribute: function (value, attribute, node) { +var str = this.serialize(value); +(node || this)[str === undefined ? 'removeAttribute' : '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; +} else if (value) { +try { +return JSON.stringify(value); +} catch (x) { +return ''; +} +} +default: +return value != null ? value : undefined; +} +} +}); +Polymer.Base._addFeature({ +_setupDebouncers: function () { +this._debouncers = {}; +}, +debounce: function (jobName, callback, wait) { +this._debouncers[jobName] = Polymer.Debounce.call(this, this._debouncers[jobName], callback, wait); +}, +isDebouncerActive: function (jobName) { +var debouncer = this._debouncers[jobName]; +return debouncer && debouncer.finish; +}, +flushDebouncer: function (jobName) { +var debouncer = this._debouncers[jobName]; +if (debouncer) { +debouncer.complete(); +} +}, +cancelDebouncer: function (jobName) { +var debouncer = this._debouncers[jobName]; +if (debouncer) { +debouncer.stop(); +} +} +}); +Polymer.version = '1.0.5'; +Polymer.Base._addFeature({ +_registerFeatures: function () { +this._prepIs(); +this._prepAttributes(); +this._prepBehaviors(); +this._prepExtends(); +this._prepConstructor(); +}, +_prepBehavior: function (b) { +this._addHostAttributes(b.hostAttributes); +}, +_marshalBehavior: function (b) { +}, +_initFeatures: function () { +this._marshalHostAttributes(); +this._setupDebouncers(); +this._marshalBehaviors(); +} +});</script> + |