WebUI: Roll Polymer 1.6.1-> 1.8.1

third_party/polymer/v1_0/components-chromium/polymer/polymer-micro-extracted.js

 (function () {
 function resolve() {
 document.body.removeAttribute('unresolved');
 }
 if (window.WebComponents) {
 addEventListener('WebComponentsReady', resolve);
 } else {
 if (document.readyState === 'interactive' || document.readyState === 'complete') {
 resolve();
 } else {
@@ skipping 14 matching lines @@
 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') && 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');
 return settings;
 }()
 };(function () {
 var userPolymer = window.Polymer;
 window.Polymer = function (prototype) {
 if (typeof prototype === 'function') {
 prototype = prototype.prototype;
 }
 if (!prototype) {
 prototype = {};
 }
-var factory = desugar(prototype);
-prototype = factory.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);
-document.registerElement(prototype.is, options);
-return factory;
+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.constructor;
+return prototype;
 };
 if (userPolymer) {
 for (var i in userPolymer) {
 Polymer[i] = userPolymer[i];
 }
 }
-Polymer.Class = desugar;
+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;
+return (document._currentScript || document.currentScript || {}).ownerDocument;
 }
 });Polymer.RenderStatus = {
 _ready: false,
 _callbacks: [],
 whenReady: function (cb) {
 if (this._ready) {
 cb();
 } else {
 this._callbacks.push(cb);
 }
@@ skipping 58 matching lines @@
 } 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.extend(this, feature);
+this.mixin(this, feature);
 },
 registerCallback: function () {
 if (settings.lazyRegister === 'max') {
 if (this.beforeRegister) {
 this.beforeRegister();
 }
 } else {
 this._desugarBehaviors();
-this._doBehavior('beforeRegister');
+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;
-this._doBehavior('created');
+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();
-proto._doBehaviorOnly('beforeRegister');
+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();
 }
-proto._doBehavior('registered');
+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;
-self._doBehavior('attached');
+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;
-self._doBehavior('detached');
+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);
-this._doBehavior('attributeChanged', [
-name,
-oldValue,
-newValue
-]);
+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);
 }
@@ skipping 50 matching lines @@
 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.extend(DomModule.prototype, {
-constructor: DomModule,
+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;
@@ skipping 44 matching lines @@
 } 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);
 },
-_doBehavior: function (name, args) {
-for (var i = 0; i < this.behaviors.length; i++) {
-this._invokeBehavior(this.behaviors[i], name, args);
-}
-this._invokeBehavior(this, name, args);
-},
-_doBehaviorOnly: function (name, args) {
-for (var i = 0; i < this.behaviors.length; i++) {
-this._invokeBehavior(this.behaviors[i], name, args);
-}
-},
-_invokeBehavior: function (b, name, args) {
-var fn = b[name];
-if (fn) {
-fn.apply(this, args || Polymer.nar);
-}
-},
 _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
+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) {
-var np = this.getNativePrototype(tag);
-p = this.extend(Object.create(np), Polymer.Base);
+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 ? [
@@ skipping 15 matching lines @@
 },
 _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) {
 for (var i = 0; i < this.behaviors.length; i++) {
 info = this._getPropertyInfo(property, this.behaviors[i].properties);
 if (info) {
 return info;
 }
 }
 }
@@ skipping 36 matching lines @@
 if (!t.type) {
 t.type = s.type;
 }
 if (!t.readOnly) {
 t.readOnly = s.readOnly;
 }
 }
 }
 }
 }
-});Polymer.CaseMap = {
+});
+(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();
 }));
 },
@@ skipping 103 matching lines @@
 try {
 return JSON.stringify(value);
 } catch (x) {
 return '';
 }
 }
 default:
 return value != null ? value : undefined;
 }
 }
-});Polymer.version = "1.6.1";Polymer.Base._addFeature({
+});Polymer.version = "1.8.1";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();
 }
 });