Roll polymer packages to version 0.3.4

pkg/web_components/lib/platform.concat.js

 /**
  * 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
  */
 
 window.Platform = window.Platform || {};
@@ skipping 389 matching lines @@
   function isIdent(s) {
     return identRegExp.test(s);
   }
 
   var constructorIsPrivate = {};
 
   function Path(parts, privateToken) {
     if (privateToken !== constructorIsPrivate)
       throw Error('Use Path.get to retrieve path objects');
 
-    if (parts.length)
-      Array.prototype.push.apply(this, parts.slice());
+    for (var i = 0; i < parts.length; i++) {
+      this.push(String(parts[i]));
+    }
 
     if (hasEval && this.length) {
       this.getValueFrom = this.compiledGetValueFromFn();
     }
   }
 
   // TODO(rafaelw): Make simple LRU cache
   var pathCache = {};
 
   function getPath(pathString) {
@@ skipping 465 matching lines @@
 
     allObservers.push(observer);
   }
 
   function removeFromAll(observer) {
     Observer._allObserversCount--;
   }
 
   var runningMicrotaskCheckpoint = false;
 
-  var hasDebugForceFullDelivery = hasObserve && (function() {
+  var hasDebugForceFullDelivery = hasObserve && hasEval && (function() {
     try {
       eval('%RunMicrotasks()');
       return true;
     } catch (ex) {
       return false;
     }
   })();
 
   global.Platform = global.Platform || {};
 
@@ skipping 4539 matching lines @@
  */
 
 (function(scope) {
   'use strict';
 
   var HTMLElement = scope.wrappers.HTMLElement;
   var mixin = scope.mixin;
   var registerWrapper = scope.registerWrapper;
   var wrapHTMLCollection = scope.wrapHTMLCollection;
   var unwrap = scope.unwrap;
-  var wrap = scope.wrap;
 
   var OriginalHTMLFormElement = window.HTMLFormElement;
 
   function HTMLFormElement(node) {
     HTMLElement.call(this, node);
   }
   HTMLFormElement.prototype = Object.create(HTMLElement.prototype);
   mixin(HTMLFormElement.prototype, {
     get elements() {
       // Note: technically this should be an HTMLFormControlsCollection, but
@@ skipping 1217 matching lines @@
       this.dirty = false;
     },
 
     get parentRenderer() {
       return getTreeScope(this.host).renderer;
     },
 
     invalidate: function() {
       if (!this.dirty) {
         this.dirty = true;
+        var parentRenderer = this.parentRenderer;
+        if (parentRenderer)
+          parentRenderer.invalidate();
         pendingDirtyRenderers.push(this);
         if (renderTimer)
           return;
         renderTimer = window[request](handleRequestAnimationFrame, 0);
       }
     },
 
     // http://w3c.github.io/webcomponents/spec/shadow/#distribution-algorithms
     distribution: function(root) {
       this.resetAll(root);
@@ skipping 893 matching lines @@
   var unwrap = scope.unwrap;
 
   // DataTransfer (Clipboard in old Blink/WebKit) has a single method that
   // requires wrapping. Since it is only a method we do not need a real wrapper,
   // we can just override the method.
 
   var OriginalDataTransfer = window.DataTransfer || window.Clipboard;
   var OriginalDataTransferSetDragImage =
       OriginalDataTransfer.prototype.setDragImage;
 
-  OriginalDataTransfer.prototype.setDragImage = function(image, x, y) {
-    OriginalDataTransferSetDragImage.call(this, unwrap(image), x, y);
-  };
+  if (OriginalDataTransferSetDragImage) {
+    OriginalDataTransfer.prototype.setDragImage = function(image, x, y) {
+      OriginalDataTransferSetDragImage.call(this, unwrap(image), x, y);
+    };
+  }
 
 })(window.ShadowDOMPolyfill);
 
+/**
+ * Copyright 2014 The Polymer Authors. All rights reserved.
+ * Use of this source code is goverened by a BSD-style
+ * license that can be found in the LICENSE file.
+ */
+
+(function(scope) {
+  'use strict';
+
+  var registerWrapper = scope.registerWrapper;
+  var unwrap = scope.unwrap;
+
+  var OriginalFormData = window.FormData;
+
+  function FormData(formElement) {
+    this.impl = new OriginalFormData(formElement && unwrap(formElement));
+  }
+
+  registerWrapper(OriginalFormData, FormData, new OriginalFormData());
+
+  scope.wrappers.FormData = FormData;
+
+})(window.ShadowDOMPolyfill);
+
 // Copyright 2013 The Polymer Authors. All rights reserved.
 // Use of this source code is goverened by a BSD-style
 // license that can be found in the LICENSE file.
 
 (function(scope) {
   'use strict';
 
   var isWrapperFor = scope.isWrapperFor;
 
   // This is a list of the elements we currently override the global constructor
@@ skipping 482 matching lines @@
    *  
    *  and converts this to
    *  
    *  scopeName .foo { ... }
   */
   scopeCssText: function(cssText, scopeSelector) {
     var unscoped = this.extractUnscopedRulesFromCssText(cssText);
     cssText = this.insertPolyfillHostInCssText(cssText);
     cssText = this.convertColonHost(cssText);
     cssText = this.convertColonHostContext(cssText);
-    cssText = this.convertCombinators(cssText);
+    cssText = this.convertShadowDOMSelectors(cssText);
     if (scopeSelector) {
       var self = this, cssText;
       withCssRules(cssText, function(rules) {
         cssText = self.scopeRules(rules, scopeSelector);
       });
 
     }
     cssText = cssText + '\n' + unscoped;
     return cssText.trim();
   },
@@ skipping 72 matching lines @@
     if (part.match(polyfillHost)) {
       return this.colonHostPartReplacer(host, part, suffix);
     } else {
       return host + part + suffix + ', ' + part + ' ' + host + suffix;
     }
   },
   colonHostPartReplacer: function(host, part, suffix) {
     return host + part.replace(polyfillHost, '') + suffix;
   },
   /*
-   * Convert ^ and ^^ combinators by replacing with space.
+   * Convert combinators like ::shadow and pseudo-elements like ::content
+   * by replacing with space.
   */
-  convertCombinators: function(cssText) {
-    for (var i=0; i < combinatorsRe.length; i++) {
-      cssText = cssText.replace(combinatorsRe[i], ' ');
+  convertShadowDOMSelectors: function(cssText) {
+    for (var i=0; i < shadowDOMSelectorsRe.length; i++) {
+      cssText = cssText.replace(shadowDOMSelectorsRe[i], ' ');
     }
     return cssText;
   },
   // change a selector like 'div' to 'name div'
   scopeRules: function(cssRules, scopeSelector) {
     var cssText = '';
     if (cssRules) {
       Array.prototype.forEach.call(cssRules, function(rule) {
         if (rule.selectorText && (rule.style && rule.style.cssText !== undefined)) {
           cssText += this.scopeSelector(rule.selectorText, scopeSelector, 
@@ skipping 134 matching lines @@
     } else {
       addCssToDocument(cssText);
     }
   }
 };
 
 var selectorRe = /([^{]*)({[\s\S]*?})/gim,
     cssCommentRe = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//gim,
     // TODO(sorvell): remove either content or comment
     cssCommentNextSelectorRe = /\/\*\s*@polyfill ([^*]*\*+([^/*][^*]*\*+)*\/)([^{]*?){/gim,
-    cssContentNextSelectorRe = /polyfill-next-selector[^}]*content\:[\s]*'([^']*)'[^}]*}([^{]*?){/gim,
+    cssContentNextSelectorRe = /polyfill-next-selector[^}]*content\:[\s]*['|"]([^'"]*)['|"][^}]*}([^{]*?){/gim,
     // TODO(sorvell): remove either content or comment
     cssCommentRuleRe = /\/\*\s@polyfill-rule([^*]*\*+([^/*][^*]*\*+)*)\//gim,
-    cssContentRuleRe = /(polyfill-rule)[^}]*(content\:[\s]*'([^']*)'[^;]*;)[^}]*}/gim,
+    cssContentRuleRe = /(polyfill-rule)[^}]*(content\:[\s]*['|"]([^'"]*)['|"][^;]*;)[^}]*}/gim,
     // TODO(sorvell): remove either content or comment
     cssCommentUnscopedRuleRe = /\/\*\s@polyfill-unscoped-rule([^*]*\*+([^/*][^*]*\*+)*)\//gim,
-    cssContentUnscopedRuleRe = /(polyfill-unscoped-rule)[^}]*(content\:[\s]*'([^']*)'[^;]*;)[^}]*}/gim,
+    cssContentUnscopedRuleRe = /(polyfill-unscoped-rule)[^}]*(content\:[\s]*['|"]([^'"]*)['|"][^;]*;)[^}]*}/gim,
     cssPseudoRe = /::(x-[^\s{,(]*)/gim,
     cssPartRe = /::part\(([^)]*)\)/gim,
     // note: :host pre-processed to -shadowcsshost.
     polyfillHost = '-shadowcsshost',
     // note: :host-context pre-processed to -shadowcsshostcontext.
     polyfillHostContext = '-shadowcsscontext',
     parenSuffix = ')(?:\\((' +
         '(?:\\([^)(]*\\)|[^)(]*)+?' +
         ')\\))?([^,{]*)';
     cssColonHostRe = new RegExp('(' + polyfillHost + parenSuffix, 'gim'),
     cssColonHostContextRe = new RegExp('(' + polyfillHostContext + parenSuffix, 'gim'),
     selectorReSuffix = '([>\\s~+\[.,{:][\\s\\S]*)?$',
     colonHostRe = /\:host/gim,
     colonHostContextRe = /\:host-context/gim,
     /* host name without combinator */
     polyfillHostNoCombinator = polyfillHost + '-no-combinator',
     polyfillHostRe = new RegExp(polyfillHost, 'gim'),
     polyfillHostContextRe = new RegExp(polyfillHostContext, 'gim'),
-    combinatorsRe = [
+    shadowDOMSelectorsRe = [
       /\^\^/g,
       /\^/g,
       /\/shadow\//g,
       /\/shadow-deep\//g,
       /::shadow/g,
-      /\/deep\//g
+      /\/deep\//g,
+      /::content/g
     ];
 
 function stylesToCssText(styles, preserveComments) {
   var cssText = '';
   Array.prototype.forEach.call(styles, function(s) {
     cssText += s.textContent + '\n\n';
   });
   // strip comments for easier processing
   if (!preserveComments) {
     cssText = cssText.replace(cssCommentRe, '');
@@ skipping 2441 matching lines @@
     }
     return true;
   }
 };
 
 function nodeIsImport(elt) {
   return (elt.localName === 'link') && (elt.rel === IMPORT_LINK_TYPE);
 }
 
 function generateScriptDataUrl(script) {
-  var scriptContent = generateScriptContent(script), b64;
+  var scriptContent = generateScriptContent(script);
+  var b64 = 'data:text/javascript';
+  // base64 may be smaller, but does not handle unicode characters
+  // attempt base64 first, fall back to escaped text
   try {
-    b64 = btoa(scriptContent);
+    b64 += (';base64,' + btoa(scriptContent));
   } catch(e) {
-    b64 = btoa(unescape(encodeURIComponent(scriptContent)));
-    console.warn('Script contained non-latin characters that were forced ' +
-      'to latin. Some characters may be wrong.', script);
+    b64 += (';charset=utf-8,' + encodeURIComponent(scriptContent));
   }
-  return 'data:text/javascript;base64,' + b64;
+  return b64;
 }
 
 function generateScriptContent(script) {
   return script.textContent + generateSourceMapHint(script);
 }
 
 // calculate source map hint
 function generateSourceMapHint(script) {
   var moniker = script.__nodeUrl;
   if (!moniker) {
@@ skipping 337 matching lines @@
   function markTargetLoaded(event) {
     event.target.__loaded = true;
   }
 
 }
 
 // exports
 scope.hasNative = hasNative;
 scope.useNative = useNative;
 scope.importer = importer;
-scope.whenImportsReady = whenImportsReady;
 scope.IMPORT_LINK_TYPE = IMPORT_LINK_TYPE;
 scope.isImportLoaded = isImportLoaded;
 scope.importLoader = importLoader;
+scope.whenReady = whenImportsReady;
+
+// deprecated
+scope.whenImportsReady = whenImportsReady;
 
 })(window.HTMLImports);
 
  /*
 Copyright 2013 The Polymer Authors. All rights reserved.
 Use of this source code is governed by a BSD-style
 license that can be found in the LICENSE file.
 */
 
 (function(scope){
@@ skipping 2952 matching lines @@
   }
 }
 
 // exports
 scope.flush = flush;
 
 })(window.Platform);
 
 
 //# sourceMappingURL=platform.concat.js.map