update web_components

pkg/web_components/lib/platform.concat.js

 /*
  * Copyright 2012 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.
  */
 
 if (typeof WeakMap === 'undefined') {
   (function() {
     var defineProperty = Object.defineProperty;
     var counter = Date.now() % 1e9;
@@ skipping 6889 matching lines @@
 
 /*
  * Copyright 2012 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.
  */
 
 /*
   This is a limited shim for ShadowDOM css styling.
   https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#styles
-
-  The intention here is to support only the styling features which can be
-  relatively simply implemented. The goal is to allow users to avoid the
-  most obvious pitfalls and do so without compromising performance significantly.
+  
+  The intention here is to support only the styling features which can be 
+  relatively simply implemented. The goal is to allow users to avoid the 
+  most obvious pitfalls and do so without compromising performance significantly. 
   For ShadowDOM styling that's not covered here, a set of best practices
   can be provided that should allow users to accomplish more complex styling.
 
   The following is a list of specific ShadowDOM styling features and a brief
   discussion of the approach used to shim.
 
   Shimmed features:
 
   * :host, :ancestor: ShadowDOM allows styling of the shadowRoot's host
-  element using the :host rule. To shim this feature, the :host styles are
-  reformatted and prefixed with a given scope name and promoted to a
+  element using the :host rule. To shim this feature, the :host styles are 
+  reformatted and prefixed with a given scope name and promoted to a 
   document level stylesheet.
   For example, given a scope name of .foo, a rule like this:
-
+  
     :host {
         background: red;
       }
     }
-
+  
   becomes:
-
+  
     .foo {
       background: red;
     }
-
-  * encapsultion: Styles defined within ShadowDOM, apply only to
+  
+  * encapsultion: Styles defined within ShadowDOM, apply only to 
   dom inside the ShadowDOM. Polymer uses one of two techniques to imlement
   this feature.
-
-  By default, rules are prefixed with the host element tag name
+  
+  By default, rules are prefixed with the host element tag name 
   as a descendant selector. This ensures styling does not leak out of the 'top'
   of the element's ShadowDOM. For example,
 
   div {
       font-weight: bold;
     }
-
+  
   becomes:
 
   x-foo div {
       font-weight: bold;
     }
-
+  
   becomes:
 
 
-  Alternatively, if Platform.ShadowCSS.strictStyling is set to true then
+  Alternatively, if Platform.ShadowCSS.strictStyling is set to true then 
   selectors are scoped by adding an attribute selector suffix to each
-  simple selector that contains the host element tag name. Each element
-  in the element's ShadowDOM template is also given the scope attribute.
+  simple selector that contains the host element tag name. Each element 
+  in the element's ShadowDOM template is also given the scope attribute. 
   Thus, these rules match only elements that have the scope attribute.
   For example, given a scope name of x-foo, a rule like this:
-
+  
     div {
       font-weight: bold;
     }
-
+  
   becomes:
-
+  
     div[x-foo] {
       font-weight: bold;
     }
 
   Note that elements that are dynamically added to a scope must have the scope
   selector added to them manually.
 
   * upper/lower bound encapsulation: Styles which are defined outside a
   shadowRoot should not cross the ShadowDOM boundary and should not apply
   inside a shadowRoot.
 
-  This styling behavior is not emulated. Some possible ways to do this that
+  This styling behavior is not emulated. Some possible ways to do this that 
   were rejected due to complexity and/or performance concerns include: (1) reset
   every possible property for every possible selector for a given scope name;
   (2) re-implement css in javascript.
-
+  
   As an alternative, users should make sure to use selectors
   specific to the scope in which they are working.
-
+  
   * ::distributed: This behavior is not emulated. It's often not necessary
   to style the contents of a specific insertion point and instead, descendants
-  of the host element can be styled selectively. Users can also create an
+  of the host element can be styled selectively. Users can also create an 
   extra node around an insertion point and style that node's contents
   via descendent selectors. For example, with a shadowRoot like this:
-
+  
     <style>
       ::content(div) {
         background: red;
       }
     </style>
     <content></content>
-
+  
   could become:
-
+  
     <style>
-      / *@polyfill .content-container div * /
+      / *@polyfill .content-container div * / 
       ::content(div) {
         background: red;
       }
     </style>
     <div class="content-container">
       <content></content>
     </div>
-
+  
   Note the use of @polyfill in the comment above a ShadowDOM specific style
-  declaration. This is a directive to the styling shim to use the selector
+  declaration. This is a directive to the styling shim to use the selector 
   in comments in lieu of the next selector when running under polyfill.
 */
 (function(scope) {
 
 var ShadowCSS = {
   strictStyling: false,
   registry: {},
   // Shim styles for a given root associated with a name and extendsName
   // 1. cache root styles by name
   // 2. optionally tag root nodes with scope name
   // 3. shim polyfill directives /* @polyfill */ and /* @polyfill-rule */
   // 4. shim :host and scoping
   shimStyling: function(root, name, extendsName) {
     var typeExtension = this.isTypeExtension(extendsName);
     // use caching to make working with styles nodes easier and to facilitate
     // lookup of extendee
     var def = this.registerDefinition(root, name, extendsName);
     // find styles and apply shimming...
     if (this.strictStyling) {
       this.applyScopeToContent(root, name);
     }
     var cssText = this.stylesToShimmedCssText(def.rootStyles, def.scopeStyles,
         name, typeExtension);
     // provide shimmedStyle for user extensibility
     def.shimmedStyle = cssTextToStyle(cssText);
     if (root) {
       root.shimmedStyle = def.shimmedStyle;
     }
     // remove existing style elements
-    for (var i=0, l=def.rootStyles.length, s; (i<l) && (s=def.rootStyles[i]);
+    for (var i=0, l=def.rootStyles.length, s; (i<l) && (s=def.rootStyles[i]); 
         i++) {
       s.parentNode.removeChild(s);
     }
     // add style to document
     addCssToDocument(cssText);
   },
   // apply @polyfill rules + :host and scope shimming
   stylesToShimmedCssText: function(rootStyles, scopeStyles, name,
       typeExtension) {
     name = name || '';
     // insert @polyfill and @polyfill-rule rules into style elements
     // scoping process takes care of shimming these
     this.insertPolyfillDirectives(rootStyles);
     this.insertPolyfillRules(rootStyles);
     var cssText = this.shimScoping(scopeStyles, name, typeExtension);
     // note: we only need to do rootStyles since these are unscoped.
     cssText += this.extractPolyfillUnscopedRules(rootStyles);
-    return cssText;
+    return cssText.trim();
   },
   registerDefinition: function(root, name, extendsName) {
     var def = this.registry[name] = {
       root: root,
       name: name,
       extendsName: extendsName
     }
     var styles = root ? root.querySelectorAll('style') : [];
     styles = styles ? Array.prototype.slice.call(styles, 0) : [];
     def.rootStyles = styles;
@@ skipping 18 matching lines @@
       Array.prototype.forEach.call(root.querySelectorAll('template'),
           function(template) {
             this.applyScopeToContent(template.content, name);
           },
           this);
     }
   },
   /*
    * Process styles to convert native ShadowDOM rules that will trip
    * up the css parser; we rely on decorating the stylesheet with comments.
-   *
+   * 
    * For example, we convert this rule:
-   *
+   * 
    * (comment start) @polyfill :host menu-item (comment end)
    * shadow::-webkit-distributed(menu-item) {
-   *
+   * 
    * to this:
-   *
+   * 
    * scopeName menu-item {
    *
   **/
   insertPolyfillDirectives: function(styles) {
     if (styles) {
       Array.prototype.forEach.call(styles, function(s) {
         s.textContent = this.insertPolyfillDirectivesInCssText(s.textContent);
       }, this);
     }
   },
   insertPolyfillDirectivesInCssText: function(cssText) {
     return cssText.replace(cssPolyfillCommentRe, function(match, p1) {
       // remove end comment delimiter and add block start
       return p1.slice(0, -2) + '{';
     });
   },
   /*
    * Process styles to add rules which will only apply under the polyfill
-   *
+   * 
    * For example, we convert this rule:
-   *
-   * (comment start) @polyfill-rule :host menu-item {
+   * 
+   * (comment start) @polyfill-rule :host menu-item { 
    * ... } (comment end)
-   *
+   * 
    * to this:
-   *
+   * 
    * scopeName menu-item {...}
    *
   **/
   insertPolyfillRules: function(styles) {
     if (styles) {
       Array.prototype.forEach.call(styles, function(s) {
         s.textContent = this.insertPolyfillRulesInCssText(s.textContent);
       }, this);
     }
   },
   insertPolyfillRulesInCssText: function(cssText) {
     return cssText.replace(cssPolyfillRuleCommentRe, function(match, p1) {
       // remove end comment delimiter
       return p1.slice(0, -1);
     });
   },
   /*
    * Process styles to add rules which will only apply under the polyfill
-   * and do not process via CSSOM. (CSSOM is destructive to rules on rare
+   * and do not process via CSSOM. (CSSOM is destructive to rules on rare 
    * occasions, e.g. -webkit-calc on Safari.)
    * For example, we convert this rule:
-   *
-   * (comment start) @polyfill-unscoped-rule menu-item {
+   * 
+   * (comment start) @polyfill-unscoped-rule menu-item { 
    * ... } (comment end)
-   *
+   * 
    * to this:
-   *
+   * 
    * menu-item {...}
    *
   **/
   extractPolyfillUnscopedRules: function(styles) {
     var cssText = '';
     if (styles) {
       Array.prototype.forEach.call(styles, function(s) {
         cssText += this.extractPolyfillUnscopedRulesFromCssText(
             s.textContent) + '\n\n';
       }, this);
     }
     return cssText;
   },
   extractPolyfillUnscopedRulesFromCssText: function(cssText) {
     var r = '', matches;
     while (matches = cssPolyfillUnscopedRuleCommentRe.exec(cssText)) {
       r += matches[1].slice(0, -1) + '\n\n';
     }
     return r;
   },
   /* Ensure styles are scoped. Pseudo-scoping takes a rule like:
-   *
-   *  .foo {... }
-   *
+   * 
+   *  .foo {... } 
+   *  
    *  and converts this to
-   *
+   *  
    *  scopeName .foo { ... }
   */
   shimScoping: function(styles, name, typeExtension) {
     if (styles) {
       return this.convertScopedStyles(styles, name, typeExtension);
     }
   },
   convertScopedStyles: function(styles, name, typeExtension) {
     var cssText = stylesToCssText(styles);
     cssText = this.insertPolyfillHostInCssText(cssText);
     cssText = this.convertColonHost(cssText);
     cssText = this.convertColonAncestor(cssText);
     cssText = this.convertCombinators(cssText);
-    var rules = cssToRules(cssText);
     if (name) {
+      var rules = cssToRules(cssText);
       cssText = this.scopeRules(rules, name, typeExtension);
     }
     return cssText;
   },
   /*
    * convert a rule like :host(.foo) > .bar { }
    *
    * to
    *
    * scopeName.foo > .bar
   */
   convertColonHost: function(cssText) {
     return this.convertColonRule(cssText, cssColonHostRe,
         this.colonHostPartReplacer);
   },
   /*
    * convert a rule like :ancestor(.foo) > .bar { }
    *
    * to
    *
    * scopeName.foo > .bar, .foo scopeName > .bar { }
-   *
+   * 
    * and
    *
    * :ancestor(.foo:host) .bar { ... }
-   *
+   * 
    * to
-   *
+   * 
    * scopeName.foo .bar { ... }
   */
   convertColonAncestor: function(cssText) {
     return this.convertColonRule(cssText, cssColonAncestorRe,
         this.colonAncestorPartReplacer);
   },
   convertColonRule: function(cssText, regExp, partReplacer) {
     // p1 = :host, p2 = contents of (), p3 rest of rule
     return cssText.replace(regExp, function(m, p1, p2, p3) {
       p1 = polyfillHostNoCombinator;
@@ skipping 23 matching lines @@
    * Convert ^ and ^^ combinators by replacing with space.
   */
   convertCombinators: function(cssText) {
     return cssText.replace(/\^\^/g, ' ').replace(/\^/g, ' ');
   },
   // change a selector like 'div' to 'name div'
   scopeRules: function(cssRules, name, typeExtension) {
     var cssText = '';
     Array.prototype.forEach.call(cssRules, function(rule) {
       if (rule.selectorText && (rule.style && rule.style.cssText)) {
-        cssText += this.scopeSelector(rule.selectorText, name, typeExtension,
+        cssText += this.scopeSelector(rule.selectorText, name, typeExtension, 
           this.strictStyling) + ' {\n\t';
         cssText += this.propertiesFromRule(rule) + '\n}\n\n';
       } else if (rule.media) {
         cssText += '@media ' + rule.media.mediaText + ' {\n';
         cssText += this.scopeRules(rule.cssRules, name, typeExtension);
         cssText += '\n}\n\n';
       } else if (rule.cssText) {
         cssText += rule.cssText + '\n\n';
       }
     }, this);
     return cssText;
   },
   scopeSelector: function(selector, name, typeExtension, strict) {
     var r = [], parts = selector.split(',');
     parts.forEach(function(p) {
       p = p.trim();
       if (this.selectorNeedsScoping(p, name, typeExtension)) {
-        p = (strict && !p.match(polyfillHostNoCombinator)) ?
+        p = (strict && !p.match(polyfillHostNoCombinator)) ? 
             this.applyStrictSelectorScope(p, name) :
             this.applySimpleSelectorScope(p, name, typeExtension);
       }
       r.push(p);
     }, this);
     return r.join(', ');
   },
   selectorNeedsScoping: function(selector, name, typeExtension) {
     var re = this.makeScopeMatcher(name, typeExtension);
     return !selector.match(re);
@@ skipping 32 matching lines @@
     return scoped;
   },
   insertPolyfillHostInCssText: function(selector) {
     return selector.replace(hostRe, polyfillHost).replace(colonHostRe,
         polyfillHost).replace(colonAncestorRe, polyfillAncestor);
   },
   propertiesFromRule: function(rule) {
     // TODO(sorvell): Safari cssom incorrectly removes quotes from the content
     // property. (https://bugs.webkit.org/show_bug.cgi?id=118045)
     if (rule.style.content && !rule.style.content.match(/['"]+/)) {
-      return rule.style.cssText.replace(/content:[^;]*;/g, 'content: \'' +
+      return rule.style.cssText.replace(/content:[^;]*;/g, 'content: \'' + 
           rule.style.content + '\';');
     }
     return rule.style.cssText;
   }
 };
 
 var selectorRe = /([^{]*)({[\s\S]*?})/gim,
     cssCommentRe = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//gim,
     cssPolyfillCommentRe = /\/\*\s*@polyfill ([^*]*\*+([^/*][^*]*\*+)*\/)([^{]*?){/gim,
     cssPolyfillRuleCommentRe = /\/\*\s@polyfill-rule([^*]*\*+([^/*][^*]*\*+)*)\//gim,
@@ skipping 74 matching lines @@
 if (window.ShadowDOMPolyfill) {
   addCssToDocument('style { display: none !important; }\n');
   var doc = wrap(document);
   var head = doc.querySelector('head');
   head.insertBefore(getSheet(), head.childNodes[0]);
 
   // TODO(sorvell): monkey-patching HTMLImports is abusive;
   // consider a better solution.
   document.addEventListener('DOMContentLoaded', function() {
     var urlResolver = scope.urlResolver;
-
+    
     if (window.HTMLImports && !HTMLImports.useNative) {
       var SHIM_SHEET_SELECTOR = 'link[rel=stylesheet]' +
           '[' + SHIM_ATTRIBUTE + ']';
       var SHIM_STYLE_SELECTOR = 'style[' + SHIM_ATTRIBUTE + ']';
       HTMLImports.importer.documentPreloadSelectors += ',' + SHIM_SHEET_SELECTOR;
       HTMLImports.importer.importsPreloadSelectors += ',' + SHIM_SHEET_SELECTOR;
 
       HTMLImports.parser.documentSelectors = [
         HTMLImports.parser.documentSelectors,
         SHIM_SHEET_SELECTOR,
         SHIM_STYLE_SELECTOR
       ].join(',');
+  
+      var originalParseGeneric = HTMLImports.parser.parseGeneric;
 
       HTMLImports.parser.parseGeneric = function(elt) {
         if (elt[SHIMMED_ATTRIBUTE]) {
           return;
         }
         var style = elt.__importElement || elt;
+        if (!style.hasAttribute(SHIM_ATTRIBUTE)) {
+          originalParseGeneric.call(this, elt);
+          return;
+        }
         if (elt.__resource) {
           style = elt.ownerDocument.createElement('style');
           style.textContent = urlResolver.resolveCssText(
               elt.__resource, elt.href);
         } else {
-          urlResolver.resolveStyles(style);
+          urlResolver.resolveStyle(style);  
         }
         var styles = [style];
         style.textContent = ShadowCSS.stylesToShimmedCssText(styles, styles);
         style.removeAttribute(SHIM_ATTRIBUTE, '');
         style.setAttribute(SHIMMED_ATTRIBUTE, '');
         style[SHIMMED_ATTRIBUTE] = true;
         // place in document
         if (style.parentNode !== head) {
           // replace links in head
           if (elt.parentNode === head) {
             head.replaceChild(style, elt);
           } else {
             head.appendChild(style);
           }
         }
-        style.__importParsed = true
+        style.__importParsed = true;
         this.markParsingComplete(elt);
       }
 
       var hasResource = HTMLImports.parser.hasResource;
       HTMLImports.parser.hasResource = function(node) {
         if (node.localName === 'link' && node.rel === 'stylesheet' &&
             node.hasAttribute(SHIM_ATTRIBUTE)) {
           return (node.__resource);
         } else {
           return hasResource.call(this, node);
@@ skipping 791 matching lines @@
 
   // TODO(sorvell): workaround for bug:
   // https://code.google.com/p/chromium/issues/detail?id=229142
   // remove when this bug is addressed
   // give main document templates a base that allows them to fetch eagerly
   // resolved paths relative to the main document
   var template = document.createElement('template');
   var base = document.createElement('base');
   base.href = document.baseURI;
   template.content.ownerDocument.appendChild(base);
-
+  
 
   // utility
 
   function createDOM(inTagOrNode, inHTML, inAttrs) {
     var dom = typeof inTagOrNode == 'string' ?
         document.createElement(inTagOrNode) : inTagOrNode.cloneNode(true);
     dom.innerHTML = inHTML;
     if (inAttrs) {
       for (var n in inAttrs) {
         dom.setAttribute(n, inAttrs[n]);
@@ skipping 20 matching lines @@
     return elementDeclarations;
   }
 
   // Once DOMContent has loaded, any main document scripts that depend on
   // Polymer() should have run. Calling Polymer() now is an error until
   // polymer is imported.
   window.addEventListener('DOMContentLoaded', function() {
     if (window.Polymer === polymerStub) {
       window.Polymer = function() {
         console.error('You tried to use polymer without loading it first. To ' +
-          'load polymer, <link rel="import" href="' +
+          'load polymer, <link rel="import" href="' + 
           'components/polymer/polymer.html">');
       };
     }
   });
 
   // exports
   scope.createDOM = createDOM;
 
 })(window.Platform);
 
 /*
  * 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.
  */
 
 // poor man's adapter for template.content on various platform scenarios
 window.templateContent = window.templateContent || function(inTemplate) {
   return inTemplate.content;
 };
 (function(scope) {
-
+  
   scope = scope || (window.Inspector = {});
-
+  
   var inspector;
 
   window.sinspect = function(inNode, inProxy) {
     if (!inspector) {
       inspector = window.open('', 'ShadowDOM Inspector', null, true);
       inspector.document.write(inspectorHTML);
       //inspector.document.close();
       inspector.api = {
         shadowize: shadowize
       };
@@ skipping 30 matching lines @@
     '      }',
     '    </style>',
     '  </head>',
     '  <body>',
     '    <ul id="crumbs">',
     '    </ul>',
     '    <div id="tree"></div>',
     '  </body>',
     '</html>'
   ].join('\n');
-
+  
   var crumbs = [];
 
   var displayCrumbs = function() {
     // alias our document
     var d = inspector.document;
     // get crumbbar
     var cb = d.querySelector('#crumbs');
     // clear crumbs
     cb.textContent = '';
     // build new crumbs
@@ skipping 107 matching lines @@
     var idx = Number(this.attributes.idx.value);
     //alert(idx);
     var node = drillable[idx];
     if (node) {
       inspect(node.webkitShadowRoot || node.shadowRoot, node)
     } else {
       console.log("bad shadowize node");
       console.dir(this);
     }
   };
-
+  
   // export
-
+  
   scope.output = output;
-
+  
 })(window.Inspector);
 
 
 
 /*
  * 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) {
 
-  // TODO(sorvell): It's desireable to provide a default stylesheet
+  // TODO(sorvell): It's desireable to provide a default stylesheet 
   // that's convenient for styling unresolved elements, but
   // it's cumbersome to have to include this manually in every page.
-  // It would make sense to put inside some HTMLImport but
-  // the HTMLImports polyfill does not allow loading of stylesheets
+  // It would make sense to put inside some HTMLImport but 
+  // the HTMLImports polyfill does not allow loading of stylesheets 
   // that block rendering. Therefore this injection is tolerated here.
 
   var style = document.createElement('style');
   style.textContent = ''
       + 'body {'
-      + 'transition: opacity ease-in 0.2s;'
+      + 'transition: opacity ease-in 0.2s;' 
       + ' } \n'
       + 'body[unresolved] {'
-      + 'opacity: 0; display: block; overflow: hidden;'
+      + 'opacity: 0; display: block; overflow: hidden;' 
       + ' } \n'
       ;
   var head = document.querySelector('head');
   head.insertBefore(style, head.firstChild);
 
 })(Platform);
 
 (function(scope) {
 
   function withDependencies(task, depends) {
@@ skipping 896 matching lines @@
  * Use of this source code is governed by a BSD-style
  * license that can be found in the LICENSE file.
  */
 
 (function(scope) {
 
 var IMPORT_LINK_TYPE = 'import';
 var flags = scope.flags;
 var isIe = /Trident/.test(navigator.userAgent);
 // TODO(sorvell): SD polyfill intrusion
-var mainDoc = window.ShadowDOMPolyfill ?
+var mainDoc = window.ShadowDOMPolyfill ? 
     window.ShadowDOMPolyfill.wrapIfNeeded(document) : document;
 
 // importParser
 // highlander object to manage parsing of imports
 // parses import related elements
 // and ensures proper parse order
 // parse order is enforced by crawling the tree and monitoring which elements
 // have been parsed; async parsing is also supported.
 
 // highlander object for parsing a document tree
@@ skipping 50 matching lines @@
   parseImport: function(elt) {
     elt.import.__importParsed = true;
     // TODO(sorvell): consider if there's a better way to do this;
     // expose an imports parsing hook; this is needed, for example, by the
     // CustomElements polyfill.
     if (HTMLImports.__importsParsingHook) {
       HTMLImports.__importsParsingHook(elt);
     }
     // fire load event
     if (elt.__resource) {
-      elt.dispatchEvent(new CustomEvent('load', {bubbles: false}));
+      elt.dispatchEvent(new CustomEvent('load', {bubbles: false}));    
     } else {
       elt.dispatchEvent(new CustomEvent('error', {bubbles: false}));
     }
     // TODO(sorvell): workaround for Safari addEventListener not working
     // for elements not in the main document.
     if (elt.__pending) {
       var fn;
       while (elt.__pending.length) {
         fn = elt.__pending.shift();
         if (fn) {
@@ skipping 61 matching lines @@
   parseScript: function(scriptElt) {
     // acquire code to execute
     var code = (scriptElt.__resource || scriptElt.textContent).trim();
     if (code) {
       // calculate source map hint
       var moniker = scriptElt.__nodeUrl;
       if (!moniker) {
         moniker = scriptElt.ownerDocument.baseURI;
         // there could be more than one script this url
         var tag = '[' + Math.floor((Math.random()+1)*1000) + ']';
-        // TODO(sjmiles): Polymer hack, should be pluggable if we need to allow
+        // TODO(sjmiles): Polymer hack, should be pluggable if we need to allow 
         // this sort of thing
         var matches = code.match(/Polymer\(['"]([^'"]*)/);
         tag = matches && matches[1] || tag;
         // tag the moniker
         moniker += '/' + tag + '.js';
       }
       // source map hint
       code += "\n//# sourceURL=" + moniker + "\n";
       // evaluate the code
       scope.currentScript = scriptElt;
@@ skipping 47 matching lines @@
 
 // clone style with proper path resolution for main document
 // NOTE: styles are the only elements that require direct path fixup.
 function cloneStyle(style) {
   var clone = style.ownerDocument.createElement('style');
   clone.textContent = style.textContent;
   path.resolveUrlsInStyle(clone);
   return clone;
 }
 
-// path fixup: style elements in imports must be made relative to the main
+// path fixup: style elements in imports must be made relative to the main 
 // document. We fixup url's in url() and @import.
 var CSS_URL_REGEXP = /(url\()([^)]*)(\))/g;
 var CSS_IMPORT_REGEXP = /(@import[\s]+(?!url\())([^;]*)(;)/g;
 
 var path = {
   resolveUrlsInStyle: function(style) {
     var doc = style.ownerDocument;
     var resolver = doc.createElement('a');
     style.textContent = this.resolveUrlsInCssText(style.textContent, resolver);
-    return style;
+    return style;  
   },
   resolveUrlsInCssText: function(cssText, urlObj) {
     var r = this.replaceUrls(cssText, urlObj, CSS_URL_REGEXP);
     r = this.replaceUrls(r, urlObj, CSS_IMPORT_REGEXP);
     return r;
   },
   replaceUrls: function(text, urlObj, regexp) {
     return text.replace(regexp, function(m, pre, url, post) {
       var urlPath = url.replace(/["']/g, '');
       urlObj.href = urlPath;
       urlPath = urlObj.href;
       return pre + '\'' + urlPath + '\'' + post;
-    });
+    });    
   }
 }
 
 // exports
 scope.parser = importParser;
 scope.path = path;
 scope.isIE = isIe;
 
 })(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) {
 
 var hasNative = ('import' in document.createElement('link'));
 var useNative = hasNative;
 var flags = scope.flags;
 var IMPORT_LINK_TYPE = 'import';
 
 // TODO(sorvell): SD polyfill intrusion
-var mainDoc = window.ShadowDOMPolyfill ?
+var mainDoc = window.ShadowDOMPolyfill ? 
     ShadowDOMPolyfill.wrapIfNeeded(document) : document;
 
 if (!useNative) {
 
   // imports
   var xhr = scope.xhr;
   var Loader = scope.Loader;
   var parser = scope.parser;
 
   // importer
@@ skipping 62 matching lines @@
       this.loadSubtree(doc);
       this.observe(doc);
       parser.parseNext();
     },
     loadedAll: function() {
       parser.parseNext();
     }
   };
 
   // loader singleton
-  var importLoader = new Loader(importer.loaded.bind(importer),
+  var importLoader = new Loader(importer.loaded.bind(importer), 
       importer.loadedAll.bind(importer));
 
   function isDocumentLink(elt) {
     return isLinkRel(elt, IMPORT_LINK_TYPE);
   }
 
   function isLinkRel(elt, rel) {
     return elt.localName === 'link' && elt.getAttribute('rel') === rel;
   }
 
@@ skipping 60 matching lines @@
     },
     configurable: true
   };
 
   Object.defineProperty(document, 'baseURI', baseURIDescriptor);
   Object.defineProperty(mainDoc, 'baseURI', baseURIDescriptor);
 }
 
 // call a callback when all HTMLImports in the document at call (or at least
 //  document ready) time have loaded.
-// 1. ensure the document is in a ready state (has dom), then
+// 1. ensure the document is in a ready state (has dom), then 
 // 2. watch for loading of imports and call callback when done
 function whenImportsReady(callback, doc) {
   doc = doc || mainDoc;
   // if document is loading, wait and try again
   whenDocumentReady(function() {
     watchImportsLoad(callback, doc);
   }, doc);
 }
 
 // call the callback when the document is in a ready state (has dom)
 var requiredReadyState = HTMLImports.isIE ? 'complete' : 'interactive';
 var READY_EVENT = 'readystatechange';
 function isDocumentReady(doc) {
   return (doc.readyState === 'complete' ||
       doc.readyState === requiredReadyState);
 }
 
 // call <callback> when we ensure the document is in a ready state
 function whenDocumentReady(callback, doc) {
   if (!isDocumentReady(doc)) {
     var checkReady = function() {
-      if (doc.readyState === 'complete' ||
+      if (doc.readyState === 'complete' || 
           doc.readyState === requiredReadyState) {
         doc.removeEventListener(READY_EVENT, checkReady);
         whenDocumentReady(callback, doc);
       }
     }
     doc.addEventListener(READY_EVENT, checkReady);
   } else if (callback) {
     callback();
   }
 }
 
 // call <callback> when we ensure all imports have loaded
 function watchImportsLoad(callback, doc) {
   var imports = doc.querySelectorAll('link[rel=import]');
   var loaded = 0, l = imports.length;
-  function checkDone(d) {
+  function checkDone(d) { 
     if (loaded == l) {
       // go async to ensure parser isn't stuck on a script tag
       requestAnimationFrame(callback);
     }
   }
   function loadedImport(e) {
     loaded++;
     checkDone();
   }
   if (l) {
@@ skipping 58 matching lines @@
     }
   }
 }
 
 function shouldLoadNode(node) {
   return (node.nodeType === 1) && matches.call(node,
       importer.loadSelectorsForNode(node));
 }
 
 // x-plat matches
-var matches = HTMLElement.prototype.matches ||
-    HTMLElement.prototype.matchesSelector ||
+var matches = HTMLElement.prototype.matches || 
+    HTMLElement.prototype.matchesSelector || 
     HTMLElement.prototype.webkitMatchesSelector ||
     HTMLElement.prototype.mozMatchesSelector ||
     HTMLElement.prototype.msMatchesSelector;
 
 var observer = new MutationObserver(handler);
 
 // observe the given root for loadable elements
 function observe(root) {
   observer.observe(root, {childList: true, subtree: true});
 }
@@ skipping 20 matching lines @@
      var e = document.createEvent('HTMLEvents');
      e.initEvent(inType,
         dictionary.bubbles === false ? false : true,
         dictionary.cancelable === false ? false : true,
         dictionary.detail);
      return e;
   };
 }
 
 // TODO(sorvell): SD polyfill intrusion
-var doc = window.ShadowDOMPolyfill ?
+var doc = window.ShadowDOMPolyfill ? 
     window.ShadowDOMPolyfill.wrapIfNeeded(document) : document;
 
-// Fire the 'HTMLImportsLoaded' event when imports in document at load time
-// have loaded. This event is required to simulate the script blocking
+// Fire the 'HTMLImportsLoaded' event when imports in document at load time 
+// have loaded. This event is required to simulate the script blocking 
 // behavior of native imports. A main document script that needs to be sure
 // imports have loaded should wait for this event.
 HTMLImports.whenImportsReady(function() {
   HTMLImports.ready = true;
   HTMLImports.readyTime = new Date().getTime();
   doc.dispatchEvent(
     new CustomEvent('HTMLImportsLoaded', {bubbles: true})
   );
 });
 
 
 // no need to bootstrap the polyfill when native imports is available.
 if (!HTMLImports.useNative) {
   function bootstrap() {
     HTMLImports.importer.bootDocument(doc);
   }
-
+    
   // TODO(sorvell): SD polyfill does *not* generate mutations for nodes added
-  // by the parser. For this reason, we must wait until the dom exists to
+  // by the parser. For this reason, we must wait until the dom exists to 
   // bootstrap.
   if (document.readyState === 'complete' ||
       (document.readyState === 'interactive' && !window.attachEvent)) {
     bootstrap();
   } else {
     document.addEventListener('DOMContentLoaded', bootstrap);
   }
 }
 
 })();
@@ skipping 97 matching lines @@
 
 function insertedNode(node) {
   inserted(node);
   if (inDocument(node)) {
     forSubtree(node, function(e) {
       inserted(e);
     });
   }
 }
 
-
 // TODO(sorvell): on platforms without MutationObserver, mutations may not be
 // reliable and therefore attached/detached are not reliable.
 // To make these callbacks less likely to fail, we defer all inserts and removes
 // to give a chance for elements to be inserted into dom.
 // This ensures attachedCallback fires for elements that are created and
 // immediately added to dom.
 var hasPolyfillMutations = (!window.MutationObserver ||
     (window.MutationObserver === window.JsMutationObserver));
 scope.hasPolyfillMutations = hasPolyfillMutations;
 
@@ skipping 216 matching lines @@
     }
   }
 }
 
 // exports
 scope.IMPORT_LINK_TYPE = IMPORT_LINK_TYPE;
 scope.watchShadow = watchShadow;
 scope.upgradeDocumentTree = upgradeDocumentTree;
 scope.upgradeAll = addedNode;
 scope.upgradeSubtree = addedSubtree;
+scope.insertedNode = insertedNode;
 
 scope.observeDocument = observeDocument;
 scope.upgradeDocument = upgradeDocument;
 
 scope.takeRecords = takeRecords;
 
 })(window.CustomElements);
 
 /*
  * Copyright 2013 The Polymer Authors. All rights reserved.
@@ skipping 216 matching lines @@
       element.setAttribute('is', definition.is);
     }
     // remove 'unresolved' attr, which is a standin for :unresolved.
     element.removeAttribute('unresolved');
     // make 'element' implement definition.prototype
     implement(element, definition);
     // flag as upgraded
     element.__upgraded__ = true;
     // lifecycle management
     created(element);
+    // attachedCallback fires in tree order, call before recursing
+    scope.insertedNode(element);
     // there should never be a shadow root on element at this point
-    // we require child nodes be upgraded before `created`
     scope.upgradeSubtree(element);
     // OUTPUT
     return element;
   }
 
   function implement(element, definition) {
     // prototype swizzling is best
     if (Object.__proto__) {
       element.__proto__ = definition.prototype;
     } else {
@@ skipping 72 matching lines @@
 
   var registry = {};
 
   function getRegisteredDefinition(name) {
     if (name) {
       return registry[name.toLowerCase()];
     }
   }
 
   function registerDefinition(name, definition) {
-    if (registry[name]) {
-      throw new Error('a type with that name is already registered.');
-    }
     registry[name] = definition;
   }
 
   function generateConstructor(definition) {
     return function() {
       return instantiate(definition);
     };
   }
 
   function createElement(tag, typeExtension) {
@@ skipping 154 matching lines @@
  */
 (function(scope){
 
 // bootstrap parsing
 function bootstrap() {
   // parse document
   CustomElements.parser.parse(document);
   // one more pass before register is 'live'
   CustomElements.upgradeDocument(document);
   // choose async
-  var async = window.Platform && Platform.endOfMicrotask ?
+  var async = window.Platform && Platform.endOfMicrotask ? 
     Platform.endOfMicrotask :
     setTimeout;
   async(function() {
-    // set internal 'ready' flag, now document.registerElement will trigger
+    // set internal 'ready' flag, now document.registerElement will trigger 
     // synchronous upgrades
     CustomElements.ready = true;
     // capture blunt profiling data
     CustomElements.readyTime = Date.now();
     if (window.HTMLImports) {
       CustomElements.elapsed = CustomElements.readyTime - HTMLImports.readyTime;
     }
     // notify the system that we are bootstrapped
     document.dispatchEvent(
       new CustomEvent('WebComponentsReady', {bubbles: true})
@@ skipping 20 matching lines @@
 // When loading at readyState complete time (or via flag), boot custom elements
 // immediately.
 // If relevant, HTMLImports must already be loaded.
 if (document.readyState === 'complete' || scope.flags.eager) {
   bootstrap();
 // When loading at readyState interactive time, bootstrap only if HTMLImports
 // are not pending. Also avoid IE as the semantics of this state are unreliable.
 } else if (document.readyState === 'interactive' && !window.attachEvent &&
     (!window.HTMLImports || window.HTMLImports.ready)) {
   bootstrap();
-// When loading at other readyStates, wait for the appropriate DOM event to
+// When loading at other readyStates, wait for the appropriate DOM event to 
 // bootstrap.
 } else {
   var loadEvent = window.HTMLImports && !HTMLImports.ready ?
       'HTMLImportsLoaded' : 'DOMContentLoaded';
   window.addEventListener(loadEvent, bootstrap);
 }
 
 })(window.CustomElements);
 
 /*
@@ skipping 84 matching lines @@
 
 function createStyleElement(cssText, scope) {
   scope = scope || document;
   scope = scope.createElement ? scope : scope.ownerDocument;
   var style = scope.createElement('style');
   style.textContent = cssText;
   return style;
 }
 
 // TODO(sorvell): use a common loader shared with HTMLImports polyfill
-// currently, this just loads the first @import per style element
-// and does not recurse into loaded elements; we'll address this with a
+// currently, this just loads the first @import per style element 
+// and does not recurse into loaded elements; we'll address this with a 
 // generalized loader that's built out of the one in the HTMLImports polyfill.
 // polyfill the loading of a style element's @import via xhr
 function xhrLoadStyle(style, callback) {
   HTMLImports.xhr.load(atImportUrlFromStyle(style), function (err, resource,
       url) {
     replaceAtImportWithCssText(this, url, resource);
     this.textContent = urlResolver.resolveCssText(this.textContent, url);
     callback && callback(this);
   }, style);
 }
@@ skipping 946 matching lines @@
   var DEDUP_TIMEOUT = 2500;
   var CLICK_COUNT_TIMEOUT = 200;
   var ATTRIB = 'touch-action';
   var INSTALLER;
   // The presence of touch event handlers blocks scrolling, and so we must be careful to
   // avoid adding handlers unnecessarily.  Chrome plans to add a touch-action-delay property
   // (crbug.com/329559) to address this, and once we have that we can opt-in to a simpler
   // handler registration mechanism.  Rather than try to predict how exactly to opt-in to
   // that we'll just leave this disabled until there is a build of Chrome to test.
   var HAS_TOUCH_ACTION_DELAY = false;
-
+  
   // handler block for native touch events
   var touchEvents = {
     scrollType: new WeakMap(),
     events: [
       'touchstart',
       'touchmove',
       'touchend',
       'touchcancel'
     ],
     register: function(target) {
@@ skipping 2291 matching lines @@
       content.appendChild(el);
       return;
     }
 
     var child;
     while (child = el.firstChild) {
       content.appendChild(child);
     }
   }
 
+  var templateObserver;
+  if (typeof MutationObserver == 'function') {
+    templateObserver = new MutationObserver(function(records) {
+      for (var i = 0; i < records.length; i++) {
+        records[i].target.refChanged_();
+      }
+    });
+  }
+
   /**
    * Ensures proper API and content model for template elements.
    * @param {HTMLTemplateElement} opt_instanceRef The template element which
    *     |el| template element will return as the value of its ref(), and whose
    *     content will be used as source when createInstance() is invoked.
    */
   HTMLTemplateElement.decorate = function(el, opt_instanceRef) {
     if (el.templateIsDecorated_)
       return false;
 
@@ skipping 83 matching lines @@
       };
     }
 
     if (!template.setModelFnScheduled_) {
       template.setModelFnScheduled_ = true;
       Observer.runEOM_(template.setModelFn_);
     }
   }
 
   mixin(HTMLTemplateElement.prototype, {
+    bind: function(name, value, oneTime) {
+      if (name != 'ref')
+        return Element.prototype.bind.call(this, name, value, oneTime);
+
+      var self = this;
+      var ref = oneTime ? value : value.open(function(ref) {
+        self.setAttribute('ref', ref);
+        self.refChanged_();
+      });
+
+      this.setAttribute('ref', ref);
+      this.refChanged_();
+      if (oneTime)
+        return;
+
+      this.unbind('ref');
+      return this.bindings.ref = value;
+    },
+
     processBindingDirectives_: function(directives) {
       if (this.iterator_)
         this.iterator_.closeDeps();
 
       if (!directives.if && !directives.bind && !directives.repeat) {
         if (this.iterator_) {
           this.iterator_.close();
           this.iterator_ = undefined;
           this.bindings.iterator = undefined;
         }
 
         return;
       }
 
       if (!this.iterator_) {
         this.iterator_ = new TemplateIterator(this);
         this.bindings = this.bindings || {};
         this.bindings.iterator = this.iterator_;
       }
 
       this.iterator_.updateDependencies(directives, this.model_);
+
+      if (templateObserver) {
+        templateObserver.observe(this, { attributes: true,
+                                         attributeFilter: ['ref'] });
+      }
+
       return this.iterator_;
     },
 
     createInstance: function(model, bindingDelegate, delegate_,
                              instanceBindings_) {
       if (bindingDelegate)
         delegate_ = this.newDelegate_(bindingDelegate);
 
-      var content = this.ref.content;
+      if (!this.refContent_)
+        this.refContent_ = this.ref_.content;
+      var content = this.refContent_;
       var map = this.bindingMap_;
       if (!map || map.content !== content) {
         // TODO(rafaelw): Setup a MutationObserver on content to detect
         // when the instanceMap is invalid.
         map = createInstanceBindingMap(content,
             delegate_ && delegate_.prepareBinding) || [];
         map.content = content;
         this.bindingMap_ = map;
       }
 
@@ skipping 31 matching lines @@
 
     set model(model) {
       this.model_ = model;
       ensureSetModelScheduled(this);
     },
 
     get bindingDelegate() {
       return this.delegate_ && this.delegate_.raw;
     },
 
+    refChanged_: function() {
+      if (!this.iterator_ || this.refContent_ === this.ref_.content)
+        return;
+
+      this.refContent_ = undefined;
+      this.iterator_.valueChanged();
+      this.iterator_.updateIteratedValue();
+    },
+
+    clear: function() {
+      this.model_ = undefined;
+      this.delegate_ = undefined;
+      this.bindings_ = undefined;
+      this.refContent_ = undefined;
+      if (!this.iterator_)
+        return;
+      this.iterator_.valueChanged();
+      this.iterator_.close()
+      this.iterator_ = undefined;
+    },
+
     setDelegate_: function(delegate) {
       this.delegate_ = delegate;
       this.bindingMap_ = undefined;
       if (this.iterator_) {
         this.iterator_.instancePositionChangedFn_ = undefined;
         this.iterator_.instanceModelFn_ = undefined;
       }
     },
 
     newDelegate_: function(bindingDelegate) {
@@ skipping 16 matching lines @@
         prepareInstanceModel: delegateFn('prepareInstanceModel'),
         prepareInstancePositionChanged:
             delegateFn('prepareInstancePositionChanged')
       };
     },
 
     // TODO(rafaelw): Assigning .bindingDelegate always succeeds. It may
     // make sense to issue a warning or even throw if the template is already
     // "activated", since this would be a strange thing to do.
     set bindingDelegate(bindingDelegate) {
+      if (this.delegate_) {
+        throw Error('Template must be cleared before a new bindingDelegate ' +
+                    'can be assigned');
+      }
+
       this.setDelegate_(this.newDelegate_(bindingDelegate));
     },
 
-    get ref() {
+    get ref_() {
       var ref = searchRefId(this, this.getAttribute('ref'));
       if (!ref)
         ref = this.instanceRef_;
 
       if (!ref)
         return this;
 
-      var nextRef = ref.ref;
+      var nextRef = ref.ref_;
       return nextRef ? nextRef : ref;
     }
   });
 
   // Returns
   //   a) undefined if there are no mustaches.
   //   b) [TEXT, (ONE_TIME?, PATH, DELEGATE_FN, TEXT)+] if there is at least one mustache.
   function parseMustaches(s, name, node, prepareBindingFn) {
     if (!s || !s.length)
       return;
@@ skipping 1715 matching lines @@
             observer.addPath(model, path);
 
           return path.getValueFrom(model);
         }
       }
 
       return this.valueFn_;
     },
 
     setValue: function(model, newValue) {
+      if (this.path.length == 1);
+        model = findScope(model, this.path[0]);
+
       return this.path.setValueFrom(model, newValue);
     }
   };
 
   function MemberExpression(object, property, accessor) {
     // convert literal computed property access where literal value is a value
     // path to ident dot-access.
     if (accessor == '[' &&
         property instanceof Literal &&
         Path.get(property.value).valid) {
@@ skipping 373 matching lines @@
     'webkitAnimationStart',
     'webkitAnimationEnd',
     'webkitTransitionEnd',
     'DOMFocusOut',
     'DOMFocusIn',
     'DOMMouseScroll'
   ].forEach(function(e) {
     mixedCaseEventTypes[e.toLowerCase()] = e;
   });
 
-  function prepareEventBinding(path, name) {
+  var parentScopeName = '@' + Math.random().toString(36).slice(2);
+
+  // Single ident paths must bind directly to the appropriate scope object.
+  // I.e. Pushed values in two-bindings need to be assigned to the actual model
+  // object.
+  function findScope(model, prop) {
+    while (model[parentScopeName] &&
+           !Object.prototype.hasOwnProperty.call(model, prop)) {
+      model = model[parentScopeName];
+    }
+
+    return model;
+  }
+
+  function resolveEventReceiver(model, path, node) {
+    if (path.length == 0)
+      return undefined;
+
+    if (path.length == 1)
+      return findScope(model, path[0]);
+
+    for (var i = 0; model != null && i < path.length - 1; i++) {
+      model = model[path[i]];
+    }
+
+    return model;
+  }
+
+  function prepareEventBinding(path, name, polymerExpressions) {
     var eventType = name.substring(3);
     eventType = mixedCaseEventTypes[eventType] || eventType;
 
     return function(model, node, oneTime) {
-      var fn = path.getValueFrom(model);
+      var fn, receiver, handler;
+      if (typeof polymerExpressions.resolveEventHandler == 'function') {
+        handler = function(e) {
+          fn = fn || polymerExpressions.resolveEventHandler(model, path, node);
+          fn(e, e.detail, e.currentTarget);
 
-      function handler(e) {
-        if (!oneTime)
-          fn = path.getValueFrom(model);
+          if (Platform && typeof Platform.flush == 'function')
+            Platform.flush();
+        };
+      } else {
+        handler = function(e) {
+          fn = fn || path.getValueFrom(model);
+          receiver = receiver || resolveEventReceiver(model, path, node);
 
-        fn.apply(model, [e, e.detail, e.currentTarget]);
+          fn.apply(receiver, [e, e.detail, e.currentTarget]);
 
-        if (Platform && typeof Platform.flush == 'function')
-          Platform.flush();
+          if (Platform && typeof Platform.flush == 'function')
+            Platform.flush();
+        };
       }
 
       node.addEventListener(eventType, handler);
 
       if (oneTime)
         return;
 
       function bindingValue() {
         return '{{ ' + path + ' }}';
       }
@@ skipping 34 matching lines @@
       var indexIdent = template.polymerExpressionIndexIdent_;
       if (!indexIdent)
         return;
 
       return function(templateInstance, index) {
         templateInstance.model[indexIdent] = index;
       };
     },
 
     prepareBinding: function(pathString, name, node) {
+      var path = Path.get(pathString);
       if (isEventHandler(name)) {
-        var path = Path.get(pathString);
         if (!path.valid) {
           console.error('on-* bindings must be simple path expressions');
           return;
         }
 
-        return prepareEventBinding(path, name);
+        return prepareEventBinding(path, name, this);
       }
 
-      if (Path.get(pathString).valid)
+      if (path.valid) {
+        if (path.length == 1) {
+          return function(model, node, oneTime) {
+            if (oneTime)
+              return path.getValueFrom(model);
+
+            var scope = findScope(model, path[0]);
+            return new PathObserver(scope, path);
+          }
+        }
+
         return; // bail out early if pathString is simple path.
+      }
 
       return prepareBinding(pathString, name, node, this);
     },
 
     prepareInstanceModel: function(template) {
       var scopeName = template.polymerExpressionScopeIdent_;
       if (!scopeName)
         return;
 
       var parentScope = template.templateInstance ?
           template.templateInstance.model :
           template.model;
 
+      var indexName = template.polymerExpressionIndexIdent_;
+
       return function(model) {
         var scope = Object.create(parentScope);
         scope[scopeName] = model;
+        scope[indexName] = undefined;
+        scope[parentScopeName] = parentScope;
         return scope;
       };
     }
   };
 
   global.PolymerExpressions = PolymerExpressions;
   if (global.exposeGetExpression)
     global.getExpression_ = getExpression;
 
   global.PolymerExpressions.prepareEventBinding = prepareEventBinding;
@@ skipping 45 matching lines @@
   }
 }
 
 // exports
 scope.flush = flush;
 
 })(window.Platform);
 
 
 //# sourceMappingURL=platform.concat.js.map