diff --git a/.travis.yml b/.travis.yml
index 9d3a1a947a..0bc7a8487e 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -15,6 +15,7 @@ before_script:
 - npm install -g bower
 - bower install
 script:
+- gulp lint
 - xvfb-run wct
 - "if [ \"${TRAVIS_PULL_REQUEST}\" = \"false\" ]; then wct -s 'default'; fi"
 env:
diff --git a/package.json b/package.json
index 9ce05ebc5b..58036b0e19 100644
--- a/package.json
+++ b/package.json
@@ -23,7 +23,7 @@
   },
   "scripts": {
     "build": "gulp",
-    "test": "wct",
+    "test": "gulp lint && wct",
     "test-build": "gulp switch && wct && gulp restore"
   },
   "repository": {
diff --git a/src/lib/annotations/annotations.html b/src/lib/annotations/annotations.html
index d3762755a4..de871dac3c 100644
--- a/src/lib/annotations/annotations.html
+++ b/src/lib/annotations/annotations.html
@@ -1,389 +1,389 @@
-<!--
-@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
--->
-<link rel="import" href="../case-map.html">
-
-<script>
-/**
- * Scans a template to produce an annotation list that that associates
- * metadata culled from markup with tree locations
- * metadata and information to associate the metadata with nodes in an instance.
- *
- * Supported expressions include:
- *
- * Double-mustache annotations in text content. The annotation must be the only
- * content in the tag, compound expressions are not supported.
- *
- *     <[tag]>{{annotation}}<[tag]>
- *
- * Double-escaped annotations in an attribute, either {{}} or [[]].
- *
- *     <[tag] someAttribute="{{annotation}}" another="[[annotation]]"><[tag]>
- *
- * `on-` style event declarations.
- *
- *     <[tag] on-<event-name>="annotation"><[tag]>
- *
- * Note that the `annotations` feature does not implement any behaviors
- * associated with these expressions, it only captures the data.
- *
- * Generated data-structure:
- *
- *     [
- *       {
- *         id: '<id>',
- *         events: [
- *           {
- *             name: '<name>'
- *             value: '<annotation>'
- *           }, ...
- *         ],
- *         bindings: [
- *           {
- *             kind: ['text'|'attribute'],
- *             mode: ['{'|'['],
- *             name: '<name>'
- *             value: '<annotation>'
- *           }, ...
- *         ],
- *         // TODO(sjmiles): this is annotation-parent, not node-parent
- *         parent: <reference to parent annotation object>,
- *         index: <integer index in parent's childNodes collection>
- *       },
- *       ...
- *     ]
- *
- * @class Template feature
- */
-
-  // null-array (shared empty array to avoid null-checks)
-  Polymer.nar = [];
-
-  Polymer.Annotations = {
-
-    // preprocess-time
-
-    // construct and return a list of annotation records
-    // by scanning `template`'s content
-    //
-    parseAnnotations: function(template) {
-      var list = [];
-      var content = template._content || template.content;
-      this._parseNodeAnnotations(content, list,
-        template.hasAttribute('strip-whitespace'));
-      return list;
-    },
-
-    // add annotations gleaned from subtree at `node` to `list`
-    _parseNodeAnnotations: function(node, list, stripWhiteSpace) {
-      return node.nodeType === Node.TEXT_NODE ?
-        this._parseTextNodeAnnotation(node, list) :
-          // TODO(sjmiles): are there other nodes we may encounter
-          // that are not TEXT_NODE but also not ELEMENT?
-          this._parseElementAnnotations(node, list, stripWhiteSpace);
-    },
-
-    _bindingRegex: (function() {
-      var IDENT  = '(?:' + '[a-zA-Z_$][\\w.:$-*]*' + ')';
-      var NUMBER = '(?:' + '[-+]?[0-9]*\\.?[0-9]+(?:[eE][-+]?[0-9]+)?' + ')';
-      var SQUOTE_STRING = '(?:' + '\'(?:[^\'\\\\]|\\\\.)*\'' + ')';
-      var DQUOTE_STRING = '(?:' + '"(?:[^"\\\\]|\\\\.)*"' + ')';
-      var STRING = '(?:' + SQUOTE_STRING + '|' + DQUOTE_STRING + ')';
-      var ARGUMENT = '(?:' + IDENT + '|' + NUMBER + '|' +  STRING + '\\s*' + ')';
-      var ARGUMENTS = '(?:' + ARGUMENT + '(?:,\\s*' + ARGUMENT + ')*' + ')';
-      var ARGUMENT_LIST = '(?:' + '\\(\\s*' +
-                                    '(?:' + ARGUMENTS + '?' + ')' +
-                                  '\\)\\s*' + ')';
-      var BINDING = '(' + IDENT + '\\s*' + ARGUMENT_LIST + '?' + ')'; // Group 3
-      var OPEN_BRACKET = '(\\[\\[|{{)' + '\\s*';
-      var CLOSE_BRACKET = '(?:]]|}})';
-      var NEGATE = '(?:(!)\\s*)?'; // Group 2
-      var EXPRESSION = OPEN_BRACKET + NEGATE + BINDING + CLOSE_BRACKET;
-      return new RegExp(EXPRESSION, "g");
-    })(),
-
-    // TODO(kschaaf): We could modify this to allow an escape mechanism by
-    // looking for the escape sequence in each of the matches and converting
-    // the part back to a literal type, and then bailing if only literals
-    // were found
-    _parseBindings: function(text) {
-      var re = this._bindingRegex;
-      var parts = [];
-      var lastIndex = 0;
-      var m;
-      // Example: "literal1{{prop}}literal2[[!compute(foo,bar)]]final"
-      // Regex matches:
-      //        Iteration 1:  Iteration 2:
-      // m[1]: '{{'          '[['
-      // m[2]: ''            '!'
-      // m[3]: 'prop'        'compute(foo,bar)'
-      while ((m = re.exec(text)) !== null) {
-        // Add literal part
-        if (m.index > lastIndex) {
-          parts.push({literal: text.slice(lastIndex, m.index)});
-        }
-        // Add binding part
-        // Mode (one-way or two)
-        var mode = m[1][0];
-        var negate = Boolean(m[2]);
-        var value = m[3].trim();
-        var customEvent, notifyEvent, colon;
-        if (mode == '{' && (colon = value.indexOf('::')) > 0) {
-          notifyEvent = value.substring(colon + 2);
-          value = value.substring(0, colon);
-          customEvent = true;
-        }
-        parts.push({
-          compoundIndex: parts.length,
-          value: value,
-          mode: mode,
-          negate: negate,
-          event: notifyEvent,
-          customEvent: customEvent
-        });
-        lastIndex = re.lastIndex;
-      }
-      // Add a final literal part
-      if (lastIndex && lastIndex < text.length) {
-        var literal = text.substring(lastIndex);
-        if (literal) {
-          parts.push({
-            literal: literal
-          });
-        }
-      }
-      if (parts.length) {
-        return parts;
-      }
-    },
-
-    _literalFromParts: function(parts) {
-      var s = '';
-      for (var i=0; i<parts.length; i++) {
-        var literal = parts[i].literal;
-        s += literal || '';
-      }
-      return s;
-    },
-
-    // add annotations gleaned from TextNode `node` to `list`
-    _parseTextNodeAnnotation: function(node, list) {
-      var parts = this._parseBindings(node.textContent);
-      if (parts) {
-        // Initialize the textContent with any literal parts
-        // NOTE: default to a space here so the textNode remains; some browsers
-        // (IE) evacipate an empty textNode following cloneNode/importNode.
-        node.textContent = this._literalFromParts(parts) || ' ';
-        var annote = {
-          bindings: [{
-            kind: 'text',
-            name: 'textContent',
-            parts: parts,
-            isCompound: parts.length !== 1
-          }]
-        };
-        list.push(annote);
-        return annote;
-      }
-    },
-
-    // add annotations gleaned from Element `node` to `list`
-    _parseElementAnnotations: function(element, list, stripWhiteSpace) {
-      var annote = {
-        bindings: [],
-        events: []
-      };
-      if (element.localName === 'content') {
-        list._hasContent = true;
-      }
-      this._parseChildNodesAnnotations(element, annote, list, stripWhiteSpace);
-      // TODO(sjmiles): is this for non-ELEMENT nodes? If so, we should
-      // change the contract of this method, or filter these out above.
-      if (element.attributes) {
-        this._parseNodeAttributeAnnotations(element, annote, list);
-        // TODO(sorvell): ad hoc callback for doing work on elements while
-        // leveraging annotator's tree walk.
-        // Consider adding an node callback registry and moving specific
-        // processing out of this module.
-        if (this.prepElement) {
-          this.prepElement(element);
-        }
-      }
-      if (annote.bindings.length || annote.events.length || annote.id) {
-        list.push(annote);
-      }
-      return annote;
-    },
-
-    // add annotations gleaned from children of `root` to `list`, `root`'s
-    // `annote` is supplied as it is the annote.parent of added annotations
-    _parseChildNodesAnnotations: function(root, annote, list, stripWhiteSpace) {
-      if (root.firstChild) {
-        var node = root.firstChild;
-        var i = 0;
-        while (node) {
-          var next = node.nextSibling;
-          if (node.localName === 'template' &&
-            !node.hasAttribute('preserve-content')) {
-            this._parseTemplate(node, i, list, annote);
-          }
-          // collapse adjacent textNodes: fixes an IE issue that can cause
-          // text nodes to be inexplicably split =(
-          // note that root.normalize() should work but does not so we do this
-          // manually.
-          if (node.nodeType === Node.TEXT_NODE) {
-            var n = next;
-            while (n && (n.nodeType === Node.TEXT_NODE)) {
-              node.textContent += n.textContent;
-              next = n.nextSibling;
-              root.removeChild(n);
-              n = next;
-            }
-            // optionally strip whitespace
-            if (stripWhiteSpace && !node.textContent.trim()) {
-              root.removeChild(node);
-              // decrement index since node is removed
-              i--;
-            }
-          }
-          // if this node didn't get evacipated, parse it.
-          if (node.parentNode) {
-            var childAnnotation = this._parseNodeAnnotations(node, list,
-              stripWhiteSpace);
-            if (childAnnotation) {
-              childAnnotation.parent = annote;
-              childAnnotation.index = i;
-            }
-          }
-          node = next;
-          i++;
-        }
-      }
-    },
-
-    // 1. Parse annotations from the template and memoize them on
-    //    content._notes (recurses into nested templates)
-    // 2. Remove template.content and store it in annotation list, where it
-    //    will be the responsibility of the host to set it back to the template
-    //    (this is both an optimization to avoid re-stamping nested template
-    //    children and avoids a bug in Chrome where nested template children
-    //    upgrade)
-    _parseTemplate: function(node, index, list, parent) {
-      // TODO(sjmiles): simply altering the .content reference didn't
-      // work (there was some confusion, might need verification)
-      var content = document.createDocumentFragment();
-      content._notes = this.parseAnnotations(node);
-      content.appendChild(node.content);
-      // TODO(sjmiles): using `nar` to avoid unnecessary allocation;
-      // in general the handling of these arrays needs some cleanup
-      // in this module
-      list.push({
-        bindings: Polymer.nar,
-        events: Polymer.nar,
-        templateContent: content,
-        parent: parent,
-        index: index
-      });
-    },
-
-    // add annotation data from attributes to the `annotation` for node `node`
-    // TODO(sjmiles): the distinction between an `annotation` and
-    // `annotation data` is not as clear as it could be
-    _parseNodeAttributeAnnotations: function(node, annotation) {
-      // Make copy of original attribute list, since the order may change
-      // as attributes are added and removed
-      var attrs = Array.prototype.slice.call(node.attributes);
-      for (var i=attrs.length-1, a; (a=attrs[i]); i--) {
-        var n = a.name;
-        var v = a.value;
-        var b;
-        // events (on-*)
-        if (n.slice(0, 3) === 'on-') {
-          node.removeAttribute(n);
-          annotation.events.push({
-            name: n.slice(3),
-            value: v
-          });
-        }
-        // bindings (other attributes)
-        else if (b = this._parseNodeAttributeAnnotation(node, n, v)) {
-          annotation.bindings.push(b);
-        }
-        // static id
-        else if (n === 'id') {
-          annotation.id = v;
-        }
-      }
-    },
-
-    // construct annotation data from a generic attribute, or undefined
-    _parseNodeAttributeAnnotation: function(node, name, value) {
-      var parts = this._parseBindings(value);
-      if (parts) {
-        // Attribute or property
-        var origName = name;
-        var kind = 'property';
-        if (name[name.length-1] == '$') {
-          name = name.slice(0, -1);
-          kind = 'attribute';
-        }
-        // Initialize attribute bindings with any literal parts
-        var literal = this._literalFromParts(parts);
-        if (literal && kind == 'attribute') {
-          node.setAttribute(name, literal);
-        }
-        // Clear attribute before removing, since IE won't allow removing
-        // `value` attribute if it previously had a value (can't
-        // unconditionally set '' before removing since attributes with `$`
-        // can't be set using setAttribute)
-        if (node.localName === 'input' && origName === 'value') {
-          node.setAttribute(origName, '');
-        }
-        // Remove annotation
-        node.removeAttribute(origName);
-        // Case hackery: attributes are lower-case, but bind targets
-        // (properties) are case sensitive. Gambit is to map dash-case to
-        // camel-case: `foo-bar` becomes `fooBar`.
-        // Attribute bindings are excepted.
-        if (kind === 'property') {
-          name = Polymer.CaseMap.dashToCamelCase(name);
-        }
-        return {
-          kind: kind,
-          name: name,
-          parts: parts,
-          literal: literal,
-          isCompound: parts.length !== 1
-        };
-      }
-    },
-
-    // instance-time
-
-    findAnnotatedNode: function(root, annote) {
-      // recursively ascend tree until we hit root
-      var parent = annote.parent &&
-        Polymer.Annotations.findAnnotatedNode(root, annote.parent);
-      // unwind the stack, returning the indexed node at each level
-      if (parent) {
-        // note: marginally faster than indexing via childNodes 
-        // (http://jsperf.com/childnodes-lookup)
-        for (var n=parent.firstChild, i=0; n; n=n.nextSibling) {
-          if (annote.index === i++) {
-            return n;
-          }
-        }
-      } else {
-        return root;
-      }
-    }
-
-  };
-
-</script>
+<!--
+@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
+-->
+<link rel="import" href="../case-map.html">
+
+<script>
+/**
+ * Scans a template to produce an annotation list that that associates
+ * metadata culled from markup with tree locations
+ * metadata and information to associate the metadata with nodes in an instance.
+ *
+ * Supported expressions include:
+ *
+ * Double-mustache annotations in text content. The annotation must be the only
+ * content in the tag, compound expressions are not supported.
+ *
+ *     <[tag]>{{annotation}}<[tag]>
+ *
+ * Double-escaped annotations in an attribute, either {{}} or [[]].
+ *
+ *     <[tag] someAttribute="{{annotation}}" another="[[annotation]]"><[tag]>
+ *
+ * `on-` style event declarations.
+ *
+ *     <[tag] on-<event-name>="annotation"><[tag]>
+ *
+ * Note that the `annotations` feature does not implement any behaviors
+ * associated with these expressions, it only captures the data.
+ *
+ * Generated data-structure:
+ *
+ *     [
+ *       {
+ *         id: '<id>',
+ *         events: [
+ *           {
+ *             name: '<name>'
+ *             value: '<annotation>'
+ *           }, ...
+ *         ],
+ *         bindings: [
+ *           {
+ *             kind: ['text'|'attribute'],
+ *             mode: ['{'|'['],
+ *             name: '<name>'
+ *             value: '<annotation>'
+ *           }, ...
+ *         ],
+ *         // TODO(sjmiles): this is annotation-parent, not node-parent
+ *         parent: <reference to parent annotation object>,
+ *         index: <integer index in parent's childNodes collection>
+ *       },
+ *       ...
+ *     ]
+ *
+ * @class Template feature
+ */
+
+  // null-array (shared empty array to avoid null-checks)
+  Polymer.nar = [];
+
+  Polymer.Annotations = {
+
+    // preprocess-time
+
+    // construct and return a list of annotation records
+    // by scanning `template`'s content
+    //
+    parseAnnotations: function(template) {
+      var list = [];
+      var content = template._content || template.content;
+      this._parseNodeAnnotations(content, list,
+        template.hasAttribute('strip-whitespace'));
+      return list;
+    },
+
+    // add annotations gleaned from subtree at `node` to `list`
+    _parseNodeAnnotations: function(node, list, stripWhiteSpace) {
+      return node.nodeType === Node.TEXT_NODE ?
+        this._parseTextNodeAnnotation(node, list) :
+          // TODO(sjmiles): are there other nodes we may encounter
+          // that are not TEXT_NODE but also not ELEMENT?
+          this._parseElementAnnotations(node, list, stripWhiteSpace);
+    },
+
+    _bindingRegex: (function() {
+      var IDENT  = '(?:' + '[a-zA-Z_$][\\w.:$-*]*' + ')';
+      var NUMBER = '(?:' + '[-+]?[0-9]*\\.?[0-9]+(?:[eE][-+]?[0-9]+)?' + ')';
+      var SQUOTE_STRING = '(?:' + '\'(?:[^\'\\\\]|\\\\.)*\'' + ')';
+      var DQUOTE_STRING = '(?:' + '"(?:[^"\\\\]|\\\\.)*"' + ')';
+      var STRING = '(?:' + SQUOTE_STRING + '|' + DQUOTE_STRING + ')';
+      var ARGUMENT = '(?:' + IDENT + '|' + NUMBER + '|' +  STRING + '\\s*' + ')';
+      var ARGUMENTS = '(?:' + ARGUMENT + '(?:,\\s*' + ARGUMENT + ')*' + ')';
+      var ARGUMENT_LIST = '(?:' + '\\(\\s*' +
+                                    '(?:' + ARGUMENTS + '?' + ')' +
+                                  '\\)\\s*' + ')';
+      var BINDING = '(' + IDENT + '\\s*' + ARGUMENT_LIST + '?' + ')'; // Group 3
+      var OPEN_BRACKET = '(\\[\\[|{{)' + '\\s*';
+      var CLOSE_BRACKET = '(?:]]|}})';
+      var NEGATE = '(?:(!)\\s*)?'; // Group 2
+      var EXPRESSION = OPEN_BRACKET + NEGATE + BINDING + CLOSE_BRACKET;
+      return new RegExp(EXPRESSION, "g");
+    })(),
+
+    // TODO(kschaaf): We could modify this to allow an escape mechanism by
+    // looking for the escape sequence in each of the matches and converting
+    // the part back to a literal type, and then bailing if only literals
+    // were found
+    _parseBindings: function(text) {
+      var re = this._bindingRegex;
+      var parts = [];
+      var lastIndex = 0;
+      var m;
+      // Example: "literal1{{prop}}literal2[[!compute(foo,bar)]]final"
+      // Regex matches:
+      //        Iteration 1:  Iteration 2:
+      // m[1]: '{{'          '[['
+      // m[2]: ''            '!'
+      // m[3]: 'prop'        'compute(foo,bar)'
+      while ((m = re.exec(text)) !== null) {
+        // Add literal part
+        if (m.index > lastIndex) {
+          parts.push({literal: text.slice(lastIndex, m.index)});
+        }
+        // Add binding part
+        // Mode (one-way or two)
+        var mode = m[1][0];
+        var negate = Boolean(m[2]);
+        var value = m[3].trim();
+        var customEvent, notifyEvent, colon;
+        if (mode == '{' && (colon = value.indexOf('::')) > 0) {
+          notifyEvent = value.substring(colon + 2);
+          value = value.substring(0, colon);
+          customEvent = true;
+        }
+        parts.push({
+          compoundIndex: parts.length,
+          value: value,
+          mode: mode,
+          negate: negate,
+          event: notifyEvent,
+          customEvent: customEvent
+        });
+        lastIndex = re.lastIndex;
+      }
+      // Add a final literal part
+      if (lastIndex && lastIndex < text.length) {
+        var literal = text.substring(lastIndex);
+        if (literal) {
+          parts.push({
+            literal: literal
+          });
+        }
+      }
+      if (parts.length) {
+        return parts;
+      }
+    },
+
+    _literalFromParts: function(parts) {
+      var s = '';
+      for (var i=0; i<parts.length; i++) {
+        var literal = parts[i].literal;
+        s += literal || '';
+      }
+      return s;
+    },
+
+    // add annotations gleaned from TextNode `node` to `list`
+    _parseTextNodeAnnotation: function(node, list) {
+      var parts = this._parseBindings(node.textContent);
+      if (parts) {
+        // Initialize the textContent with any literal parts
+        // NOTE: default to a space here so the textNode remains; some browsers
+        // (IE) evacipate an empty textNode following cloneNode/importNode.
+        node.textContent = this._literalFromParts(parts) || ' ';
+        var annote = {
+          bindings: [{
+            kind: 'text',
+            name: 'textContent',
+            parts: parts,
+            isCompound: parts.length !== 1
+          }]
+        };
+        list.push(annote);
+        return annote;
+      }
+    },
+
+    // add annotations gleaned from Element `node` to `list`
+    _parseElementAnnotations: function(element, list, stripWhiteSpace) {
+      var annote = {
+        bindings: [],
+        events: []
+      };
+      if (element.localName === 'content') {
+        list._hasContent = true;
+      }
+      this._parseChildNodesAnnotations(element, annote, list, stripWhiteSpace);
+      // TODO(sjmiles): is this for non-ELEMENT nodes? If so, we should
+      // change the contract of this method, or filter these out above.
+      if (element.attributes) {
+        this._parseNodeAttributeAnnotations(element, annote, list);
+        // TODO(sorvell): ad hoc callback for doing work on elements while
+        // leveraging annotator's tree walk.
+        // Consider adding an node callback registry and moving specific
+        // processing out of this module.
+        if (this.prepElement) {
+          this.prepElement(element);
+        }
+      }
+      if (annote.bindings.length || annote.events.length || annote.id) {
+        list.push(annote);
+      }
+      return annote;
+    },
+
+    // add annotations gleaned from children of `root` to `list`, `root`'s
+    // `annote` is supplied as it is the annote.parent of added annotations
+    _parseChildNodesAnnotations: function(root, annote, list, stripWhiteSpace) {
+      if (root.firstChild) {
+        var node = root.firstChild;
+        var i = 0;
+        while (node) {
+          var next = node.nextSibling;
+          if (node.localName === 'template' &&
+            !node.hasAttribute('preserve-content')) {
+            this._parseTemplate(node, i, list, annote);
+          }
+          // collapse adjacent textNodes: fixes an IE issue that can cause
+          // text nodes to be inexplicably split =(
+          // note that root.normalize() should work but does not so we do this
+          // manually.
+          if (node.nodeType === Node.TEXT_NODE) {
+            var n = next;
+            while (n && (n.nodeType === Node.TEXT_NODE)) {
+              node.textContent += n.textContent;
+              next = n.nextSibling;
+              root.removeChild(n);
+              n = next;
+            }
+            // optionally strip whitespace
+            if (stripWhiteSpace && !node.textContent.trim()) {
+              root.removeChild(node);
+              // decrement index since node is removed
+              i--;
+            }
+          }
+          // if this node didn't get evacipated, parse it.
+          if (node.parentNode) {
+            var childAnnotation = this._parseNodeAnnotations(node, list,
+              stripWhiteSpace);
+            if (childAnnotation) {
+              childAnnotation.parent = annote;
+              childAnnotation.index = i;
+            }
+          }
+          node = next;
+          i++;
+        }
+      }
+    },
+
+    // 1. Parse annotations from the template and memoize them on
+    //    content._notes (recurses into nested templates)
+    // 2. Remove template.content and store it in annotation list, where it
+    //    will be the responsibility of the host to set it back to the template
+    //    (this is both an optimization to avoid re-stamping nested template
+    //    children and avoids a bug in Chrome where nested template children
+    //    upgrade)
+    _parseTemplate: function(node, index, list, parent) {
+      // TODO(sjmiles): simply altering the .content reference didn't
+      // work (there was some confusion, might need verification)
+      var content = document.createDocumentFragment();
+      content._notes = this.parseAnnotations(node);
+      content.appendChild(node.content);
+      // TODO(sjmiles): using `nar` to avoid unnecessary allocation;
+      // in general the handling of these arrays needs some cleanup
+      // in this module
+      list.push({
+        bindings: Polymer.nar,
+        events: Polymer.nar,
+        templateContent: content,
+        parent: parent,
+        index: index
+      });
+    },
+
+    // add annotation data from attributes to the `annotation` for node `node`
+    // TODO(sjmiles): the distinction between an `annotation` and
+    // `annotation data` is not as clear as it could be
+    _parseNodeAttributeAnnotations: function(node, annotation) {
+      // Make copy of original attribute list, since the order may change
+      // as attributes are added and removed
+      var attrs = Array.prototype.slice.call(node.attributes);
+      for (var i=attrs.length-1, a; (a=attrs[i]); i--) {
+        var n = a.name;
+        var v = a.value;
+        var b;
+        // events (on-*)
+        if (n.slice(0, 3) === 'on-') {
+          node.removeAttribute(n);
+          annotation.events.push({
+            name: n.slice(3),
+            value: v
+          });
+        }
+        // bindings (other attributes)
+        else if ((b = this._parseNodeAttributeAnnotation(node, n, v))) {
+          annotation.bindings.push(b);
+        }
+        // static id
+        else if (n === 'id') {
+          annotation.id = v;
+        }
+      }
+    },
+
+    // construct annotation data from a generic attribute, or undefined
+    _parseNodeAttributeAnnotation: function(node, name, value) {
+      var parts = this._parseBindings(value);
+      if (parts) {
+        // Attribute or property
+        var origName = name;
+        var kind = 'property';
+        if (name[name.length-1] == '$') {
+          name = name.slice(0, -1);
+          kind = 'attribute';
+        }
+        // Initialize attribute bindings with any literal parts
+        var literal = this._literalFromParts(parts);
+        if (literal && kind == 'attribute') {
+          node.setAttribute(name, literal);
+        }
+        // Clear attribute before removing, since IE won't allow removing
+        // `value` attribute if it previously had a value (can't
+        // unconditionally set '' before removing since attributes with `$`
+        // can't be set using setAttribute)
+        if (node.localName === 'input' && origName === 'value') {
+          node.setAttribute(origName, '');
+        }
+        // Remove annotation
+        node.removeAttribute(origName);
+        // Case hackery: attributes are lower-case, but bind targets
+        // (properties) are case sensitive. Gambit is to map dash-case to
+        // camel-case: `foo-bar` becomes `fooBar`.
+        // Attribute bindings are excepted.
+        if (kind === 'property') {
+          name = Polymer.CaseMap.dashToCamelCase(name);
+        }
+        return {
+          kind: kind,
+          name: name,
+          parts: parts,
+          literal: literal,
+          isCompound: parts.length !== 1
+        };
+      }
+    },
+
+    // instance-time
+
+    findAnnotatedNode: function(root, annote) {
+      // recursively ascend tree until we hit root
+      var parent = annote.parent &&
+        Polymer.Annotations.findAnnotatedNode(root, annote.parent);
+      // unwind the stack, returning the indexed node at each level
+      if (parent) {
+        // note: marginally faster than indexing via childNodes
+        // (http://jsperf.com/childnodes-lookup)
+        for (var n=parent.firstChild, i=0; n; n=n.nextSibling) {
+          if (annote.index === i++) {
+            return n;
+          }
+        }
+      } else {
+        return root;
+      }
+    }
+
+  };
+
+</script>
diff --git a/src/lib/array-splice.html b/src/lib/array-splice.html
index f51279a717..8c4da1546d 100644
--- a/src/lib/array-splice.html
+++ b/src/lib/array-splice.html
@@ -10,7 +10,7 @@
 <script>
 
 Polymer.ArraySplice = (function() {
-  
+
   function newSplice(index, removed, addedCount) {
     return {
       index: index,
@@ -56,8 +56,8 @@
       for (var j = 0; j < columnCount; j++)
         distances[0][j] = j;
 
-      for (var i = 1; i < rowCount; i++) {
-        for (var j = 1; j < columnCount; j++) {
+      for (i = 1; i < rowCount; i++) {
+        for (j = 1; j < columnCount; j++) {
           if (this.equals(current[currentStart + j - 1], old[oldStart + i - 1]))
             distances[i][j] = distances[i - 1][j - 1];
           else {
@@ -181,7 +181,7 @@
           this.calcEditDistances(current, currentStart, currentEnd,
                                  old, oldStart, oldEnd));
 
-      var splice = undefined;
+      splice = undefined;
       var splices = [];
       var index = currentStart;
       var oldIndex = oldStart;
@@ -259,4 +259,4 @@
   return new ArraySplice();
 
 })();
-</script>
\ No newline at end of file
+</script>
diff --git a/src/lib/bind/accessors.html b/src/lib/bind/accessors.html
index 66175deae6..9973981348 100644
--- a/src/lib/bind/accessors.html
+++ b/src/lib/bind/accessors.html
@@ -23,7 +23,7 @@
       _notifyChange: function(source, event, value) {
         value = value === undefined ? this[source] : value;
         event = event || Polymer.CaseMap.camelToDashCase(source) + '-changed';
-        this.fire(event, {value: value}, 
+        this.fire(event, {value: value},
           {bubbles: false, cancelable: false, _useCache: true});
       },
 
@@ -221,8 +221,8 @@
         } else {
           // TODO(sorvell): even though we have a `value` argument, we *must*
           // lookup the current value of the property. Multiple listeners and
-          // queued events during configuration can theoretically lead to 
-          // divergence of the passed value from the current value, but we 
+          // queued events during configuration can theoretically lead to
+          // divergence of the passed value from the current value, but we
           // really need to track down a specific case where this happens.
           value = target[property];
           if (!isStructured) {
@@ -256,7 +256,7 @@
         //if (node._prepParentProperties || !node._propertyInfo || (p && p.notify)) {
           this._addNotifyListener(node, inst, info.event, info.changedFn);
         //}
-      };
+      }
     },
 
     // TODO(sorvell): note, adding these synchronously may impact performance,
diff --git a/src/lib/collection.html b/src/lib/collection.html
index 997b3a5f3a..91d6ca4954 100644
--- a/src/lib/collection.html
+++ b/src/lib/collection.html
@@ -50,7 +50,7 @@
     },
 
     removeKey: function(key) {
-      if (key = this._parseKey(key)) {
+      if ((key = this._parseKey(key))) {
         this._removeFromMap(this.store[key]);
         delete this.store[key];
       }
@@ -95,7 +95,7 @@
     },
 
     setItem: function(key, item) {
-      if (key = this._parseKey(key)) {
+      if ((key = this._parseKey(key))) {
         var old = this.store[key];
         if (old) {
           this._removeFromMap(old);
@@ -110,7 +110,7 @@
     },
 
     getItem: function(key) {
-      if (key = this._parseKey(key)) {
+      if ((key = this._parseKey(key))) {
         return this.store[key];
       }
     },
@@ -140,7 +140,7 @@
           key = this.getKey(s.removed[j]);
           keyMap[key] = keyMap[key] ? null : -1;
         }
-        for (var j=0; j<s.addedCount; j++) {
+        for (j=0; j<s.addedCount; j++) {
           var item = this.userArray[s.index + j];
           key = this.getKey(item);
           key = (key === undefined) ? this.add(item) : key;
@@ -154,7 +154,7 @@
       // Convert added/removed key map to added/removed arrays
       var removed = [];
       var added = [];
-      for (var key in keyMap) {
+      for (key in keyMap) {
         if (keyMap[key] < 0) {
           this.removeKey(key);
           removed.push(key);
diff --git a/src/lib/custom-style.html b/src/lib/custom-style.html
index 2530b885bb..f730d80b60 100644
--- a/src/lib/custom-style.html
+++ b/src/lib/custom-style.html
@@ -71,7 +71,6 @@
 <script>
 (function() {
 
-  var nativeShadow = Polymer.Settings.useNativeShadow;
   var propertyUtils = Polymer.StyleProperties;
   var styleUtil = Polymer.StyleUtil;
   var cssParse = Polymer.CssParse;
diff --git a/src/lib/dom-api-effective-nodes-observer.html b/src/lib/dom-api-effective-nodes-observer.html
index f98de7d456..9eb3fe7ea6 100644
--- a/src/lib/dom-api-effective-nodes-observer.html
+++ b/src/lib/dom-api-effective-nodes-observer.html
@@ -1,268 +1,264 @@
-<!--
-@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
--->
-<link rel="import" href="settings.html">
-<script>
-(function() {
-  'use strict';
-
-    var DomApi = Polymer.DomApi.ctor;
-    var Settings = Polymer.Settings;
-    var hasDomApi = Polymer.DomApi.hasDomApi;
-
-    /**
-     * DomApi.EffectiveNodesObserver tracks changes to an element's 
-     * effective child nodes, the same list returned from 
-     * `Polymer.dom(node).getEffectiveChildNodes()`.
-     * It is not meant to be used directly; it is used by
-     * `Polymer.dom(node).observeNodes(callback)` to observe changes.
-     */
-    DomApi.EffectiveNodesObserver = function(domApi) {
-      this.domApi = domApi;
-      this.node = this.domApi.node;
-      this._listeners = [];
-    };
-
-    DomApi.EffectiveNodesObserver.prototype = {
-
-      addListener: function(callback) {
-        if (!this._isSetup) {
-          this._setup();
-          this._isSetup = true;
-        }
-        var listener = {fn: callback, _nodes: []};
-        this._listeners.push(listener);
-        this._scheduleNotify();
-        return listener;
-      },
-
-      removeListener: function(handle) {
-        var i = this._listeners.indexOf(handle);
-        if (i >= 0) {
-          this._listeners.splice(i, 1);
-          handle._nodes = [];
-        }
-        if (!this._hasListeners()) {
-          this._cleanup();
-          this._isSetup = false;
-        }
-      },
-
-      _setup: function() {
-        this._observeContentElements(this.domApi.childNodes);
-      },
-
-      _cleanup: function() {
-        this._unobserveContentElements(this.domApi.childNodes);
-      },
-
-      _hasListeners: function() {
-        return Boolean(this._listeners.length);
-      },
-
-      _scheduleNotify: function() {
-        if (this._debouncer) {
-          this._debouncer.stop();
-        }
-        this._debouncer = Polymer.Debounce(this._debouncer, 
-          this._notify);
-        this._debouncer.context = this;
-        Polymer.dom.addDebouncer(this._debouncer);
-      },
-
-      notify: function() {
-        if (this._hasListeners()) {
-          this._scheduleNotify();
-        }
-      },
-
-      _notify: function(mxns) {
-        this._beforeCallListeners();
-        this._callListeners();
-      },
-
-      _beforeCallListeners: function() {
-        this._updateContentElements();
-      },
-
-      _updateContentElements: function() {
-        this._observeContentElements(this.domApi.childNodes);
-      },
-
-      _observeContentElements: function(elements) {
-        for (var i=0, n; (i < elements.length) && (n=elements[i]); i++) {
-          if (this._isContent(n)) {
-            n.__observeNodesMap = n.__observeNodesMap || new WeakMap();
-            if (!n.__observeNodesMap.has(this)) {
-              n.__observeNodesMap.set(this, this._observeContent(n));
-            }
-          }
-        }
-      },
-
-      _observeContent: function(content) {
-        var self = this;
-        var h = Polymer.dom(content).observeNodes(function() {
-          self._scheduleNotify();
-        });
-        h._avoidChangeCalculation = true;
-        return h;
-      },
-
-      _unobserveContentElements: function(elements) {
-        for (var i=0, n, h; (i < elements.length) && (n=elements[i]); i++) {
-          if (this._isContent(n)) {
-            h = n.__observeNodesMap.get(this);
-            if (h) {
-              Polymer.dom(n).unobserveNodes(h);
-              n.__observeNodesMap.delete(this);
-            }
-          }
-        }
-      },
-
-      _isContent: function(node) {
-        return (node.localName === 'content');
-      },
-
-      _callListeners: function() {
-        var o$ = this._listeners;
-        var nodes = this._getEffectiveNodes();
-        for (var i=0, o; (i < o$.length) && (o=o$[i]); i++) {
-          var info = this._generateListenerInfo(o, nodes);
-          if (info || o._alwaysNotify) {
-            this._callListener(o, info);
-          }
-        }
-      },
-
-      _getEffectiveNodes: function() {
-        return this.domApi.getEffectiveChildNodes()
-      },
-
-      _generateListenerInfo: function(listener, newNodes) {
-        if (listener._avoidChangeCalculation) {
-          return true;
-        }
-        var oldNodes = listener._nodes;
-        var info = {
-          target: this.node,
-          addedNodes: [],
-          removedNodes: []
-        };
-        var splices = Polymer.ArraySplice.calculateSplices(newNodes, oldNodes);
-        // process removals
-        for (var i=0, s; (i<splices.length) && (s=splices[i]); i++) {
-          for (var j=0, n; (j < s.removed.length) && (n=s.removed[j]); j++) {
-            info.removedNodes.push(n);
-          }
-        }
-        // process adds
-        for (var i=0, s; (i<splices.length) && (s=splices[i]); i++) {
-          for (var j=s.index; j < s.index + s.addedCount; j++) {
-            info.addedNodes.push(newNodes[j]);
-          }
-        }
-        // update cache
-        listener._nodes = newNodes;
-        if (info.addedNodes.length || info.removedNodes.length) {
-          return info;
-        }
-      },
-
-      _callListener: function(listener, info) {
-        return listener.fn.call(this.node, info);
-      },
-
-      enableShadowAttributeTracking: function() {}
-
-    };
-
-    if (Settings.useShadow) {
-
-      var baseSetup = DomApi.EffectiveNodesObserver.prototype._setup;
-      var baseCleanup = DomApi.EffectiveNodesObserver.prototype._cleanup;
-
-      var beforeCallListeners = DomApi.EffectiveNodesObserver
-        .prototype._beforeCallListeners;
-
-      Polymer.Base.extend(DomApi.EffectiveNodesObserver.prototype, {
-        
-        _setup: function() {
-          if (!this._observer) {
-            var self = this;
-            this._mutationHandler = function(mxns) {
-              if (mxns && mxns.length) {
-                self._scheduleNotify();
-              }
-            };
-            this._observer = new MutationObserver(this._mutationHandler);
-            this._boundFlush = function() {
-              self._flush();
-            }
-            Polymer.dom.addStaticFlush(this._boundFlush);
-            // NOTE: subtree true is way too aggressive, but it easily catches
-            // attribute changes on children. These changes otherwise require
-            // attribute observers on every child. Testing has shown this
-            // approach to be more efficient. 
-            // TODO(sorvell): do we still need to include an option to defeat
-            // attribute tracking?
-            this._observer.observe(this.node, { childList: true });
-          }
-          baseSetup.call(this);
-        },
-
-        _cleanup: function() {
-          this._observer.disconnect();
-          this._observer = null;
-          this._mutationHandler = null;
-          Polymer.dom.removeStaticFlush(this._boundFlush);
-          baseCleanup.call(this);
-        },
-
-        _flush: function() {
-          if (this._observer) {
-            this._mutationHandler(this._observer.takeRecords());
-          }
-        },
-
-        enableShadowAttributeTracking: function() {
-          if (this._observer) {
-            // provoke all listeners needed for <content> observation
-            // to always call listeners when no-op changes occur (which may
-            // affect lower distributions.
-            this._makeContentListenersAlwaysNotify();
-            this._observer.disconnect();
-            this._observer.observe(this.node, { 
-              childList: true,
-              attributes: true,
-              subtree: true
-            });
-            var root = this.domApi.getOwnerRoot();
-            var host = root && root.host;
-            if (host && Polymer.dom(host).observer) {
-              Polymer.dom(host).observer.enableShadowAttributeTracking();
-            }
-          }
-        },
-
-        _makeContentListenersAlwaysNotify: function() {
-          for (var i=0, h; i < this._listeners.length ; i++) {
-            h = this._listeners[i];
-            h._alwaysNotify = h._isContentListener;
-          }
-        }
-
-      });
-
-    }
-
-})();
-
-</script>
\ No newline at end of file
+<!--
+@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
+-->
+<link rel="import" href="settings.html">
+<script>
+(function() {
+  'use strict';
+
+    var DomApi = Polymer.DomApi.ctor;
+    var Settings = Polymer.Settings;
+
+    /**
+     * DomApi.EffectiveNodesObserver tracks changes to an element's
+     * effective child nodes, the same list returned from
+     * `Polymer.dom(node).getEffectiveChildNodes()`.
+     * It is not meant to be used directly; it is used by
+     * `Polymer.dom(node).observeNodes(callback)` to observe changes.
+     */
+    DomApi.EffectiveNodesObserver = function(domApi) {
+      this.domApi = domApi;
+      this.node = this.domApi.node;
+      this._listeners = [];
+    };
+
+    DomApi.EffectiveNodesObserver.prototype = {
+
+      addListener: function(callback) {
+        if (!this._isSetup) {
+          this._setup();
+          this._isSetup = true;
+        }
+        var listener = {fn: callback, _nodes: []};
+        this._listeners.push(listener);
+        this._scheduleNotify();
+        return listener;
+      },
+
+      removeListener: function(handle) {
+        var i = this._listeners.indexOf(handle);
+        if (i >= 0) {
+          this._listeners.splice(i, 1);
+          handle._nodes = [];
+        }
+        if (!this._hasListeners()) {
+          this._cleanup();
+          this._isSetup = false;
+        }
+      },
+
+      _setup: function() {
+        this._observeContentElements(this.domApi.childNodes);
+      },
+
+      _cleanup: function() {
+        this._unobserveContentElements(this.domApi.childNodes);
+      },
+
+      _hasListeners: function() {
+        return Boolean(this._listeners.length);
+      },
+
+      _scheduleNotify: function() {
+        if (this._debouncer) {
+          this._debouncer.stop();
+        }
+        this._debouncer = Polymer.Debounce(this._debouncer,
+          this._notify);
+        this._debouncer.context = this;
+        Polymer.dom.addDebouncer(this._debouncer);
+      },
+
+      notify: function() {
+        if (this._hasListeners()) {
+          this._scheduleNotify();
+        }
+      },
+
+      _notify: function() {
+        this._beforeCallListeners();
+        this._callListeners();
+      },
+
+      _beforeCallListeners: function() {
+        this._updateContentElements();
+      },
+
+      _updateContentElements: function() {
+        this._observeContentElements(this.domApi.childNodes);
+      },
+
+      _observeContentElements: function(elements) {
+        for (var i=0, n; (i < elements.length) && (n=elements[i]); i++) {
+          if (this._isContent(n)) {
+            n.__observeNodesMap = n.__observeNodesMap || new WeakMap();
+            if (!n.__observeNodesMap.has(this)) {
+              n.__observeNodesMap.set(this, this._observeContent(n));
+            }
+          }
+        }
+      },
+
+      _observeContent: function(content) {
+        var self = this;
+        var h = Polymer.dom(content).observeNodes(function() {
+          self._scheduleNotify();
+        });
+        h._avoidChangeCalculation = true;
+        return h;
+      },
+
+      _unobserveContentElements: function(elements) {
+        for (var i=0, n, h; (i < elements.length) && (n=elements[i]); i++) {
+          if (this._isContent(n)) {
+            h = n.__observeNodesMap.get(this);
+            if (h) {
+              Polymer.dom(n).unobserveNodes(h);
+              n.__observeNodesMap.delete(this);
+            }
+          }
+        }
+      },
+
+      _isContent: function(node) {
+        return (node.localName === 'content');
+      },
+
+      _callListeners: function() {
+        var o$ = this._listeners;
+        var nodes = this._getEffectiveNodes();
+        for (var i=0, o; (i < o$.length) && (o=o$[i]); i++) {
+          var info = this._generateListenerInfo(o, nodes);
+          if (info || o._alwaysNotify) {
+            this._callListener(o, info);
+          }
+        }
+      },
+
+      _getEffectiveNodes: function() {
+        return this.domApi.getEffectiveChildNodes()
+      },
+
+      _generateListenerInfo: function(listener, newNodes) {
+        if (listener._avoidChangeCalculation) {
+          return true;
+        }
+        var oldNodes = listener._nodes;
+        var info = {
+          target: this.node,
+          addedNodes: [],
+          removedNodes: []
+        };
+        var splices = Polymer.ArraySplice.calculateSplices(newNodes, oldNodes);
+        // process removals
+        for (var i=0, s; (i<splices.length) && (s=splices[i]); i++) {
+          for (var j=0, n; (j < s.removed.length) && (n=s.removed[j]); j++) {
+            info.removedNodes.push(n);
+          }
+        }
+        // process adds
+        for (i=0, s; (i<splices.length) && (s=splices[i]); i++) {
+          for (j=s.index; j < s.index + s.addedCount; j++) {
+            info.addedNodes.push(newNodes[j]);
+          }
+        }
+        // update cache
+        listener._nodes = newNodes;
+        if (info.addedNodes.length || info.removedNodes.length) {
+          return info;
+        }
+      },
+
+      _callListener: function(listener, info) {
+        return listener.fn.call(this.node, info);
+      },
+
+      enableShadowAttributeTracking: function() {}
+
+    };
+
+    if (Settings.useShadow) {
+
+      var baseSetup = DomApi.EffectiveNodesObserver.prototype._setup;
+      var baseCleanup = DomApi.EffectiveNodesObserver.prototype._cleanup;
+
+      Polymer.Base.extend(DomApi.EffectiveNodesObserver.prototype, {
+
+        _setup: function() {
+          if (!this._observer) {
+            var self = this;
+            this._mutationHandler = function(mxns) {
+              if (mxns && mxns.length) {
+                self._scheduleNotify();
+              }
+            };
+            this._observer = new MutationObserver(this._mutationHandler);
+            this._boundFlush = function() {
+              self._flush();
+            }
+            Polymer.dom.addStaticFlush(this._boundFlush);
+            // NOTE: subtree true is way too aggressive, but it easily catches
+            // attribute changes on children. These changes otherwise require
+            // attribute observers on every child. Testing has shown this
+            // approach to be more efficient.
+            // TODO(sorvell): do we still need to include an option to defeat
+            // attribute tracking?
+            this._observer.observe(this.node, { childList: true });
+          }
+          baseSetup.call(this);
+        },
+
+        _cleanup: function() {
+          this._observer.disconnect();
+          this._observer = null;
+          this._mutationHandler = null;
+          Polymer.dom.removeStaticFlush(this._boundFlush);
+          baseCleanup.call(this);
+        },
+
+        _flush: function() {
+          if (this._observer) {
+            this._mutationHandler(this._observer.takeRecords());
+          }
+        },
+
+        enableShadowAttributeTracking: function() {
+          if (this._observer) {
+            // provoke all listeners needed for <content> observation
+            // to always call listeners when no-op changes occur (which may
+            // affect lower distributions.
+            this._makeContentListenersAlwaysNotify();
+            this._observer.disconnect();
+            this._observer.observe(this.node, {
+              childList: true,
+              attributes: true,
+              subtree: true
+            });
+            var root = this.domApi.getOwnerRoot();
+            var host = root && root.host;
+            if (host && Polymer.dom(host).observer) {
+              Polymer.dom(host).observer.enableShadowAttributeTracking();
+            }
+          }
+        },
+
+        _makeContentListenersAlwaysNotify: function() {
+          for (var i=0, h; i < this._listeners.length ; i++) {
+            h = this._listeners[i];
+            h._alwaysNotify = h._isContentListener;
+          }
+        }
+
+      });
+
+    }
+
+})();
+
+</script>
diff --git a/src/lib/dom-api-shady.html b/src/lib/dom-api-shady.html
index b15bfac7cd..7c4da0b23b 100644
--- a/src/lib/dom-api-shady.html
+++ b/src/lib/dom-api-shady.html
@@ -93,7 +93,7 @@
       if (root) {
         // note: we always need to see if an insertion point is added
         // since this saves logical tree info; however, invalidation state
-        // needs 
+        // needs
         var ipAdded = this._maybeAddInsertionPoint(node, this.node);
         // invalidate insertion points IFF not already invalid!
         if (!root._invalidInsertionPoints) {
@@ -107,14 +107,14 @@
       // if not distributing and not adding to host, do a fast path addition
       var handled = this._maybeDistribute(node) ||
         this.node.shadyRoot;
-      // if shady is handling this node, 
+      // if shady is handling this node,
       // the actual dom may not be removed if the node or fragment contents
       // remain undistributed so we ensure removal here.
       // NOTE: we only remove from existing location iff shady dom is involved.
       // This is because a node fragment is passed to the native add method
       // which expects to see fragment children. Regular elements must also
-      // use this check because not doing so causes separation of 
-      // attached/detached and breaks, for example, 
+      // use this check because not doing so causes separation of
+      // attached/detached and breaks, for example,
       // dom-if's attached/detached checks.
       if (handled) {
         if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
@@ -137,7 +137,7 @@
     */
     removeChild: function(node) {
       if (TreeApi.Logical.getParentNode(node) !== this.node) {
-        throw Error('The node to be removed is not a child of this node: ' + 
+        throw Error('The node to be removed is not a child of this node: ' +
           node);
       }
       if (!this._removeNode(node)) {
@@ -154,7 +154,7 @@
       return node;
     },
 
-    // Try to remove node: update logical info and perform distribution iff 
+    // Try to remove node: update logical info and perform distribution iff
     // needed. Return true if the removal has been handled.
     // note that it's possible for both the node's host and its parent
     // to require distribution... both cases are handled here.
@@ -214,7 +214,7 @@
         }
         // memo-ize result for performance but only memo-ize a false-y
         // result if node is in the document. This avoids a problem where a root
-        // can be cached while an element is inside a fragment. 
+        // can be cached while an element is inside a fragment.
         // If this happens and we cache the result, the value can become stale
         // because for perf we avoid processing the subtree of added fragments.
         if (root || document.documentElement.contains(node)) {
@@ -298,7 +298,7 @@
     },
 
     _nodeNeedsDistribution: function(node) {
-      return node && node.shadyRoot && 
+      return node && node.shadyRoot &&
         DomApi.hasInsertionPoint(node.shadyRoot);
     },
 
@@ -587,7 +587,7 @@
           return this.node.textContent;
         } else {
           var tc = [];
-          for (var i = 0, cn = this.childNodes, c; c = cn[i]; i++) {
+          for (var i = 0, cn = this.childNodes, c; (c = cn[i]); i++) {
             if (c.nodeType !== Node.COMMENT_NODE) {
               tc.push(c.textContent);
             }
diff --git a/src/lib/dom-innerHTML.html b/src/lib/dom-innerHTML.html
index 755eb4a388..09c8f3b957 100644
--- a/src/lib/dom-innerHTML.html
+++ b/src/lib/dom-innerHTML.html
@@ -1,131 +1,131 @@
-<!--
-@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>
-
-Polymer.domInnerHTML = (function() {
-
-  // Cribbed from ShadowDOM polyfill
-  // https://github.com/webcomponents/webcomponentsjs/blob/master/src/ShadowDOM/wrappers/HTMLElement.js#L28
-  /////////////////////////////////////////////////////////////////////////////
-  // innerHTML and outerHTML
-
-  // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#escapingString
-  var escapeAttrRegExp = /[&\u00A0"]/g;
-  var escapeDataRegExp = /[&\u00A0<>]/g;
-
-  function escapeReplace(c) {
-    switch (c) {
-      case '&':
-        return '&amp;';
-      case '<':
-        return '&lt;';
-      case '>':
-        return '&gt;';
-      case '"':
-        return '&quot;';
-      case '\u00A0':
-        return '&nbsp;';
-    }
-  }
-
-  function escapeAttr(s) {
-    return s.replace(escapeAttrRegExp, escapeReplace);
-  }
-
-  function escapeData(s) {
-    return s.replace(escapeDataRegExp, escapeReplace);
-  }
-
-  function makeSet(arr) {
-    var set = {};
-    for (var i = 0; i < arr.length; i++) {
-      set[arr[i]] = true;
-    }
-    return set;
-  }
-
-  // http://www.whatwg.org/specs/web-apps/current-work/#void-elements
-  var voidElements = makeSet([
-    'area',
-    'base',
-    'br',
-    'col',
-    'command',
-    'embed',
-    'hr',
-    'img',
-    'input',
-    'keygen',
-    'link',
-    'meta',
-    'param',
-    'source',
-    'track',
-    'wbr'
-  ]);
-
-  var plaintextParents = makeSet([
-    'style',
-    'script',
-    'xmp',
-    'iframe',
-    'noembed',
-    'noframes',
-    'plaintext',
-    'noscript'
-  ]);
-
-  function getOuterHTML(node, parentNode, composed) {
-    switch (node.nodeType) {
-      case Node.ELEMENT_NODE:
-        //var tagName = node.tagName.toLowerCase();
-        var tagName = node.localName;
-        var s = '<' + tagName;
-        var attrs = node.attributes;
-        for (var i = 0, attr; attr = attrs[i]; i++) {
-          s += ' ' + attr.name + '="' + escapeAttr(attr.value) + '"';
-        }
-        s += '>';
-        if (voidElements[tagName]) {
-          return s;
-        }
-        return s + getInnerHTML(node, composed) + '</' + tagName + '>';
-      case Node.TEXT_NODE:
-        var data = node.data;
-        if (parentNode && plaintextParents[parentNode.localName]) {
-          return data;
-        }
-        return escapeData(data);
-      case Node.COMMENT_NODE:
-        return '<!--' + node.data + '-->';
-      default:
-        console.error(node);
-        throw new Error('not implemented');
-    }
-  }
-
-  function getInnerHTML(node, composed) {
-    if (node instanceof HTMLTemplateElement)
-      node = node.content;
-    var s = '';
-    var c$ = Polymer.dom(node).childNodes;
-    for (var i=0, l=c$.length, child; (i<l) && (child=c$[i]); i++) {  
-      s += getOuterHTML(child, node, composed);
-    }
-    return s;
-  }
-
-  return {
-    getInnerHTML: getInnerHTML
-  };
-
-})();
-
-</script>
+<!--
+@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>
+
+Polymer.domInnerHTML = (function() {
+
+  // Cribbed from ShadowDOM polyfill
+  // https://github.com/webcomponents/webcomponentsjs/blob/master/src/ShadowDOM/wrappers/HTMLElement.js#L28
+  /////////////////////////////////////////////////////////////////////////////
+  // innerHTML and outerHTML
+
+  // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#escapingString
+  var escapeAttrRegExp = /[&\u00A0"]/g;
+  var escapeDataRegExp = /[&\u00A0<>]/g;
+
+  function escapeReplace(c) {
+    switch (c) {
+      case '&':
+        return '&amp;';
+      case '<':
+        return '&lt;';
+      case '>':
+        return '&gt;';
+      case '"':
+        return '&quot;';
+      case '\u00A0':
+        return '&nbsp;';
+    }
+  }
+
+  function escapeAttr(s) {
+    return s.replace(escapeAttrRegExp, escapeReplace);
+  }
+
+  function escapeData(s) {
+    return s.replace(escapeDataRegExp, escapeReplace);
+  }
+
+  function makeSet(arr) {
+    var set = {};
+    for (var i = 0; i < arr.length; i++) {
+      set[arr[i]] = true;
+    }
+    return set;
+  }
+
+  // http://www.whatwg.org/specs/web-apps/current-work/#void-elements
+  var voidElements = makeSet([
+    'area',
+    'base',
+    'br',
+    'col',
+    'command',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'keygen',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr'
+  ]);
+
+  var plaintextParents = makeSet([
+    'style',
+    'script',
+    'xmp',
+    'iframe',
+    'noembed',
+    'noframes',
+    'plaintext',
+    'noscript'
+  ]);
+
+  function getOuterHTML(node, parentNode, composed) {
+    switch (node.nodeType) {
+      case Node.ELEMENT_NODE:
+        //var tagName = node.tagName.toLowerCase();
+        var tagName = node.localName;
+        var s = '<' + tagName;
+        var attrs = node.attributes;
+        for (var i = 0, attr; (attr = attrs[i]); i++) {
+          s += ' ' + attr.name + '="' + escapeAttr(attr.value) + '"';
+        }
+        s += '>';
+        if (voidElements[tagName]) {
+          return s;
+        }
+        return s + getInnerHTML(node, composed) + '</' + tagName + '>';
+      case Node.TEXT_NODE:
+        var data = node.data;
+        if (parentNode && plaintextParents[parentNode.localName]) {
+          return data;
+        }
+        return escapeData(data);
+      case Node.COMMENT_NODE:
+        return '<!--' + node.data + '-->';
+      default:
+        console.error(node);
+        throw new Error('not implemented');
+    }
+  }
+
+  function getInnerHTML(node, composed) {
+    if (node instanceof HTMLTemplateElement)
+      node = node.content;
+    var s = '';
+    var c$ = Polymer.dom(node).childNodes;
+    for (var i=0, l=c$.length, child; (i<l) && (child=c$[i]); i++) {
+      s += getOuterHTML(child, node, composed);
+    }
+    return s;
+  }
+
+  return {
+    getInnerHTML: getInnerHTML
+  };
+
+})();
+
+</script>
diff --git a/src/lib/dom-module.html b/src/lib/dom-module.html
index f1f9355a43..468e55bf24 100644
--- a/src/lib/dom-module.html
+++ b/src/lib/dom-module.html
@@ -45,7 +45,7 @@
      * @param {String} id The id at which to register the dom-module.
      */
     register: function(id) {
-      var id = id || this.id ||
+      id = id || this.id ||
         this.getAttribute('name') || this.getAttribute('is');
       if (id) {
         this.id = id;
@@ -103,7 +103,7 @@
       var doc = script && script.ownerDocument || document;
       // find all dom-modules
       var modules = doc.querySelectorAll('dom-module');
-      // minimize work by going backwards and stopping if we find an 
+      // minimize work by going backwards and stopping if we find an
       // upgraded module.
       for (var i= modules.length-1, m; (i >=0) && (m=modules[i]); i--) {
         if (m.__upgraded__) {
diff --git a/src/lib/dom-tree-api.html b/src/lib/dom-tree-api.html
index 3fb61da781..ccf0dea031 100644
--- a/src/lib/dom-tree-api.html
+++ b/src/lib/dom-tree-api.html
@@ -11,20 +11,20 @@
 <link rel="import" href="dom-innerHTML.html">
 <script>
 (function() {
-  
+
   'use strict';
 
   // native add/remove
   var nativeInsertBefore = Element.prototype.insertBefore;
   var nativeAppendChild = Element.prototype.appendChild;
   var nativeRemoveChild = Element.prototype.removeChild;
-  
+
   /**
-   * TreeApi is a dom manipulation library used by Shady/Polymer.dom to 
+   * TreeApi is a dom manipulation library used by Shady/Polymer.dom to
    * manipulate composed and logical trees.
    */
-  var TreeApi = Polymer.TreeApi = {
-    
+  Polymer.TreeApi = {
+
     // sad but faster than slice...
     arrayCopyChildNodes: function(parent) {
       var copy=[], i=0;
@@ -62,7 +62,7 @@
     hasChildNodes: function(node) {
       return Boolean(node.__dom && node.__dom.childNodes !== undefined);
     },
-    
+
     getChildNodes: function(node) {
       // note: we're distinguishing here between undefined and false-y:
       // hasChildNodes uses undefined check to see if this element has logical
@@ -77,7 +77,7 @@
         node.__dom.childNodes = [];
         for (var n=node.__dom.firstChild; n; n=n.__dom.nextSibling) {
           node.__dom.childNodes.push(n);
-        } 
+        }
       }
       return node.__dom.childNodes;
     },
@@ -89,32 +89,32 @@
     // the mere existence of __dom is not enough to know if the requested
     // logical data is available and instead we do an explicit undefined check.
     getParentNode: function(node) {
-      return node.__dom && node.__dom.parentNode !== undefined ? 
+      return node.__dom && node.__dom.parentNode !== undefined ?
         node.__dom.parentNode : node.parentNode;
     },
 
     getFirstChild: function(node) {
-      return node.__dom && node.__dom.firstChild !== undefined ? 
+      return node.__dom && node.__dom.firstChild !== undefined ?
         node.__dom.firstChild : node.firstChild;
     },
 
     getLastChild: function(node) {
-      return node.__dom && node.__dom.lastChild  !== undefined ? 
+      return node.__dom && node.__dom.lastChild  !== undefined ?
         node.__dom.lastChild : node.lastChild;
     },
 
     getNextSibling: function(node) {
-      return node.__dom && node.__dom.nextSibling  !== undefined ? 
+      return node.__dom && node.__dom.nextSibling  !== undefined ?
         node.__dom.nextSibling : node.nextSibling;
     },
 
     getPreviousSibling: function(node) {
-      return node.__dom && node.__dom.previousSibling  !== undefined ? 
+      return node.__dom && node.__dom.previousSibling  !== undefined ?
         node.__dom.previousSibling : node.previousSibling;
     },
 
     getFirstElementChild: function(node) {
-      return node.__dom && node.__dom.firstChild !== undefined ?  
+      return node.__dom && node.__dom.firstChild !== undefined ?
         this._getFirstElementChild(node) : node.firstElementChild;
     },
 
@@ -207,9 +207,9 @@
       container.__dom = container.__dom || {};
       if (ref_node) {
         ref_node.__dom = ref_node.__dom || {};
-      }      
+      }
       // update ref_node.previousSibling <-> node
-      node.__dom.previousSibling = ref_node ? ref_node.__dom.previousSibling : 
+      node.__dom.previousSibling = ref_node ? ref_node.__dom.previousSibling :
         container.__dom.lastChild;
       if (node.__dom.previousSibling) {
         node.__dom.previousSibling.__dom.nextSibling = node;
@@ -255,7 +255,7 @@
       // When an element is removed, logical data is no longer tracked.
       // Explicitly set `undefined` here to indicate this. This is disginguished
       // from `null` which is set if info is null.
-      node.__dom.parentNode = node.__dom.previousSibling = 
+      node.__dom.parentNode = node.__dom.previousSibling =
         node.__dom.nextSibling = undefined;
       // remove caching of childNodes
       container.__dom.childNodes = null;
@@ -277,8 +277,8 @@
     },
 
     // composed tracking needs to reset composed children here in case
-    // they may have already been set (this shouldn't happen but can 
-    // if dependency ordering is incorrect and as a result upgrade order 
+    // they may have already been set (this shouldn't happen but can
+    // if dependency ordering is incorrect and as a result upgrade order
     // is unexpected)
     clearChildNodes: function(node) {
       node.textContent = '';
diff --git a/src/lib/render-status.html b/src/lib/render-status.html
index c4735260cb..c08e7d784a 100644
--- a/src/lib/render-status.html
+++ b/src/lib/render-status.html
@@ -13,11 +13,11 @@
    * Helper for determining when first render occurs.
    * Call `Polymer.RenderStatus.whenReady(callback)` to be notified when
    * first render occurs or immediately if it has already occured.
-   * Note that since HTML Imports are designed to load before rendering, 
+   * Note that since HTML Imports are designed to load before rendering,
    * this call can also be used to guarantee that imports have loaded.
    * This behavior is normalized to function correctly with the HTMLImports
    * polyfill which does not otherwise maintain this rendering guarantee.
-   * Querying style and layout data before first render is currently 
+   * Querying style and layout data before first render is currently
    * problematic on some browsers (Blink/Webkit) so this helper can be used
    * to prevent doing so until a safe time.
    */
@@ -85,7 +85,7 @@
       for (var i=0, h; i < callbacks.length; i++) {
         h = callbacks[i];
         h[1].apply(h[0], h[2] || Polymer.nar);
-      };
+      }
     }
   };
 
@@ -101,4 +101,4 @@
   Polymer.ImportStatus = Polymer.RenderStatus;
   Polymer.ImportStatus.whenLoaded = Polymer.ImportStatus.whenReady;
 
-</script>
\ No newline at end of file
+</script>
diff --git a/src/lib/style-defaults.html b/src/lib/style-defaults.html
index 1ffedc183c..c015da7462 100644
--- a/src/lib/style-defaults.html
+++ b/src/lib/style-defaults.html
@@ -1,91 +1,90 @@
-<!--
-@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
--->
-<link rel="import" href="style-util.html">
-<link rel="import" href="style-cache.html">
-<script>
-
-  Polymer.StyleDefaults = (function() {
-
-    var styleProperties = Polymer.StyleProperties;
-    var styleUtil = Polymer.StyleUtil;
-    var StyleCache = Polymer.StyleCache;
-
-    var api = {
-
-      _styles: [],
-      _properties: null,
-      customStyle: {},
-      _styleCache: new StyleCache(),
-
-      addStyle: function(style) {
-        this._styles.push(style);
-        this._properties = null;
-      },
-
-      // NOTE: this object can be used as a styling scope so it has an api
-      // similar to that of an element wrt style properties
-      get _styleProperties() {
-        if (!this._properties) {
-          // force rules to reparse since they may be out of date
-          styleProperties.decorateStyles(this._styles);
-          // NOTE: reset cache for own properties; it may have been set when
-          // an element in an import applied styles (e.g. custom-style)
-          this._styles._scopeStyleProperties = null;
-          this._properties = styleProperties
-            .scopePropertiesFromStyles(this._styles);
-          // mixin customStyle
-          styleProperties.mixinCustomStyle(this._properties, this.customStyle);
-          styleProperties.reify(this._properties);
-        }
-        return this._properties;
-      },
-
-      _needsStyleProperties: function() {},
-
-      _computeStyleProperties: function() {
-        return this._styleProperties;
-      },
-
-      /**
-       * Re-evaluates and applies custom CSS properties to all elements in the
-       * document based on dynamic changes, such as adding or removing classes.
-       *
-       * For performance reasons, Polymer's custom CSS property shim relies
-       * on this explicit signal from the user to indicate when changes have
-       * been made that affect the values of custom properties.
-       *
-       * @method updateStyles
-       * @param {Object=} properties Properties object which is mixed into 
-       * the document root `customStyle` property. This argument provides a 
-       * shortcut for setting `customStyle` and then calling `updateStyles`.
-      */
-      updateStyles: function(properties) {
-        // force properties update.
-        this._properties = null;
-        if (properties) {
-          Polymer.Base.mixin(this.customStyle, properties);
-        }
-        // invalidate the cache
-        this._styleCache.clear();
-        // update any custom-styles we are tracking
-        for (var i=0, s; i < this._styles.length; i++) {
-          s = this._styles[i];
-          s = s.__importElement || s;
-          s._apply();
-        }
-      }
-
-    };
-
-    // exports
-    return api;
-
-  })();
-</script>
+<!--
+@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
+-->
+<link rel="import" href="style-util.html">
+<link rel="import" href="style-cache.html">
+<script>
+
+  Polymer.StyleDefaults = (function() {
+
+    var styleProperties = Polymer.StyleProperties;
+    var StyleCache = Polymer.StyleCache;
+
+    var api = {
+
+      _styles: [],
+      _properties: null,
+      customStyle: {},
+      _styleCache: new StyleCache(),
+
+      addStyle: function(style) {
+        this._styles.push(style);
+        this._properties = null;
+      },
+
+      // NOTE: this object can be used as a styling scope so it has an api
+      // similar to that of an element wrt style properties
+      get _styleProperties() {
+        if (!this._properties) {
+          // force rules to reparse since they may be out of date
+          styleProperties.decorateStyles(this._styles);
+          // NOTE: reset cache for own properties; it may have been set when
+          // an element in an import applied styles (e.g. custom-style)
+          this._styles._scopeStyleProperties = null;
+          this._properties = styleProperties
+            .scopePropertiesFromStyles(this._styles);
+          // mixin customStyle
+          styleProperties.mixinCustomStyle(this._properties, this.customStyle);
+          styleProperties.reify(this._properties);
+        }
+        return this._properties;
+      },
+
+      _needsStyleProperties: function() {},
+
+      _computeStyleProperties: function() {
+        return this._styleProperties;
+      },
+
+      /**
+       * Re-evaluates and applies custom CSS properties to all elements in the
+       * document based on dynamic changes, such as adding or removing classes.
+       *
+       * For performance reasons, Polymer's custom CSS property shim relies
+       * on this explicit signal from the user to indicate when changes have
+       * been made that affect the values of custom properties.
+       *
+       * @method updateStyles
+       * @param {Object=} properties Properties object which is mixed into
+       * the document root `customStyle` property. This argument provides a
+       * shortcut for setting `customStyle` and then calling `updateStyles`.
+      */
+      updateStyles: function(properties) {
+        // force properties update.
+        this._properties = null;
+        if (properties) {
+          Polymer.Base.mixin(this.customStyle, properties);
+        }
+        // invalidate the cache
+        this._styleCache.clear();
+        // update any custom-styles we are tracking
+        for (var i=0, s; i < this._styles.length; i++) {
+          s = this._styles[i];
+          s = s.__importElement || s;
+          s._apply();
+        }
+      }
+
+    };
+
+    // exports
+    return api;
+
+  })();
+</script>
diff --git a/src/lib/style-extends.html b/src/lib/style-extends.html
index 414f1ba2a0..97d71abc5d 100644
--- a/src/lib/style-extends.html
+++ b/src/lib/style-extends.html
@@ -1,101 +1,101 @@
-<!--
-@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
--->
-<link rel="import" href="style-util.html">
-
-<script>
-
-Polymer.StyleExtends = (function() {
-
-  var styleUtil = Polymer.StyleUtil;
-
-  return {
-
-    hasExtends: function(cssText) {
-      return Boolean(cssText.match(this.rx.EXTEND));
-    },
-
-    transform: function(style) {
-      var rules = styleUtil.rulesForStyle(style);
-      var self = this;
-      styleUtil.forEachRule(rules, function(rule) {
-        var map = self._mapRule(rule);
-        if (rule.parent) {
-          var m;
-          while (m = self.rx.EXTEND.exec(rule.cssText)) {
-            var extend = m[1];
-            var extendor = self._findExtendor(extend, rule);
-            if (extendor) {
-              self._extendRule(rule, extendor);
-            }
-          }
-        }
-        rule.cssText = rule.cssText.replace(self.rx.EXTEND, '');
-      });
-      // strip unused % selectors
-      return styleUtil.toCssText(rules, function(rule) {
-        if (rule.selector.match(self.rx.STRIP)) {
-          rule.cssText = '';
-        }
-      }, true);
-    },
-
-    _mapRule: function(rule) {
-      if (rule.parent) {
-        var map = rule.parent.map || (rule.parent.map = {});
-        var parts = rule.selector.split(',');
-        for (var i=0, p; i < parts.length; i++) {
-          p = parts[i];
-          map[p.trim()] = rule;
-        }
-        return map;
-      }
-    },
-
-    _findExtendor: function(extend, rule) {
-      return rule.parent && rule.parent.map && rule.parent.map[extend] ||
-        this._findExtendor(extend, rule.parent);
-    },
-
-    _extendRule: function(target, source) {
-      if (target.parent !== source.parent) {
-        this._cloneAndAddRuleToParent(source, target.parent);
-      }
-      target.extends = target.extends || [];
-      target.extends.push(source);
-      // TODO: this misses `%foo, .bar` as an unetended selector but
-      // this seems rare and could possibly be unsupported.
-      source.selector = source.selector.replace(this.rx.STRIP, '');
-      source.selector = (source.selector && source.selector + ',\n') +
-        target.selector;
-      if (source.extends) {
-        source.extends.forEach(function(e) {
-          this._extendRule(target, e);
-        }, this);
-      }
-    },
-
-    _cloneAndAddRuleToParent: function(rule, parent) {
-      rule = Object.create(rule);
-      rule.parent = parent;
-      if (rule.extends) {
-        rule.extends = rule.extends.slice();
-      }
-      parent.rules.push(rule);
-    },
-
-    rx: {
-      EXTEND: /@extends\(([^)]*)\)\s*?;/gim,
-      STRIP: /%[^,]*$/
-    }
-
-  };
-
-})();
-</script>
+<!--
+@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
+-->
+<link rel="import" href="style-util.html">
+
+<script>
+
+Polymer.StyleExtends = (function() {
+
+  var styleUtil = Polymer.StyleUtil;
+
+  return {
+
+    hasExtends: function(cssText) {
+      return Boolean(cssText.match(this.rx.EXTEND));
+    },
+
+    transform: function(style) {
+      var rules = styleUtil.rulesForStyle(style);
+      var self = this;
+      styleUtil.forEachRule(rules, function(rule) {
+        self._mapRule(rule);
+        if (rule.parent) {
+          var m;
+          while ((m = self.rx.EXTEND.exec(rule.cssText))) {
+            var extend = m[1];
+            var extendor = self._findExtendor(extend, rule);
+            if (extendor) {
+              self._extendRule(rule, extendor);
+            }
+          }
+        }
+        rule.cssText = rule.cssText.replace(self.rx.EXTEND, '');
+      });
+      // strip unused % selectors
+      return styleUtil.toCssText(rules, function(rule) {
+        if (rule.selector.match(self.rx.STRIP)) {
+          rule.cssText = '';
+        }
+      }, true);
+    },
+
+    _mapRule: function(rule) {
+      if (rule.parent) {
+        var map = rule.parent.map || (rule.parent.map = {});
+        var parts = rule.selector.split(',');
+        for (var i=0, p; i < parts.length; i++) {
+          p = parts[i];
+          map[p.trim()] = rule;
+        }
+        return map;
+      }
+    },
+
+    _findExtendor: function(extend, rule) {
+      return rule.parent && rule.parent.map && rule.parent.map[extend] ||
+        this._findExtendor(extend, rule.parent);
+    },
+
+    _extendRule: function(target, source) {
+      if (target.parent !== source.parent) {
+        this._cloneAndAddRuleToParent(source, target.parent);
+      }
+      target.extends = target.extends || [];
+      target.extends.push(source);
+      // TODO: this misses `%foo, .bar` as an unetended selector but
+      // this seems rare and could possibly be unsupported.
+      source.selector = source.selector.replace(this.rx.STRIP, '');
+      source.selector = (source.selector && source.selector + ',\n') +
+        target.selector;
+      if (source.extends) {
+        source.extends.forEach(function(e) {
+          this._extendRule(target, e);
+        }, this);
+      }
+    },
+
+    _cloneAndAddRuleToParent: function(rule, parent) {
+      rule = Object.create(rule);
+      rule.parent = parent;
+      if (rule.extends) {
+        rule.extends = rule.extends.slice();
+      }
+      parent.rules.push(rule);
+    },
+
+    rx: {
+      EXTEND: /@extends\(([^)]*)\)\s*?;/gim,
+      STRIP: /%[^,]*$/
+    }
+
+  };
+
+})();
+</script>
diff --git a/src/lib/style-properties.html b/src/lib/style-properties.html
index 544a0be984..74436cdc68 100644
--- a/src/lib/style-properties.html
+++ b/src/lib/style-properties.html
@@ -71,7 +71,7 @@
           var m, rx = this.rx.VAR_ASSIGN;
           var cssText = rule.parsedCssText;
           var any;
-          while (m = rx.exec(cssText)) {
+          while ((m = rx.exec(cssText))) {
             // note: group 2 is var, 3 is mixin
             properties[m[1]] = (m[2] || m[3]).trim();
             any = true;
@@ -103,7 +103,7 @@
 
       collectPropertiesInCssText: function(cssText, props) {
         var m;
-        while (m = this.rx.VAR_CAPTURE.exec(cssText)) {
+        while ((m = this.rx.VAR_CAPTURE.exec(cssText))) {
           props[m[1]] = true;
           var def = m[2];
           if (def && def.match(this.rx.IS_VAR)) {
@@ -155,7 +155,7 @@
       valueForProperties: function(property, props) {
         var parts = property.split(';');
         for (var i=0, p, m; i<parts.length; i++) {
-          if (p = parts[i]) {
+          if ((p = parts[i])) {
             m = p.match(this.rx.MIXIN_MATCH);
             if (m) {
               p = this.valueForProperty(props[m[1]], props);
diff --git a/src/lib/template/dom-repeat.html b/src/lib/template/dom-repeat.html
index 04ec5c3788..63c548a328 100644
--- a/src/lib/template/dom-repeat.html
+++ b/src/lib/template/dom-repeat.html
@@ -193,9 +193,9 @@
 
       /**
        * Count of currently rendered items after `filter` (if any) has been applied.
-       * If "chunking mode" is enabled, `renderedItemCount` is updated each time a 
+       * If "chunking mode" is enabled, `renderedItemCount` is updated each time a
        * set of template instances is rendered.
-       * 
+       *
        */
       renderedItemCount: {
         type: Number,
@@ -409,7 +409,6 @@
     },
 
     _render: function() {
-      var c = this.collection;
       // Choose rendering path: full vs. incremental using splices
       if (this._needFullRefresh) {
         // Full refresh when items, sort, or filter change, or when render() called
@@ -456,7 +455,7 @@
       // `item` may not be sufficient if the pooled instance happens to be
       // the same item.
       this._pool.length = 0;
-      // Set rendered item count 
+      // Set rendered item count
       this._setRenderedItemCount(this._instances.length);
       // Notify users
       this.fire('dom-change');
@@ -499,7 +498,7 @@
         });
       }
       // Generate instances and assign items and keys
-      for (var i=0; i<keys.length; i++) {
+      for (i=0; i<keys.length; i++) {
         var key = keys[i];
         var inst = this._instances[i];
         if (inst) {
@@ -529,23 +528,23 @@
     // first, and added rows are insertion-sorted into place using user sort
     _applySplicesUserSort: function(splices) {
       var c = this.collection;
-      var instances = this._instances;
       var keyMap = {};
+      var key;
       // Dedupe added and removed keys to a final added/removed map
       for (var i=0, s; (i<splices.length) && (s=splices[i]); i++) {
         for (var j=0; j<s.removed.length; j++) {
-          var key = s.removed[j];
+          key = s.removed[j];
           keyMap[key] = keyMap[key] ? null : -1;
         }
-        for (var j=0; j<s.added.length; j++) {
-          var key = s.added[j];
+        for (j=0; j<s.added.length; j++) {
+          key = s.added[j];
           keyMap[key] = keyMap[key] ? null : 1;
         }
       }
       // Convert added/removed key map to added/removed arrays
       var removedIdxs = [];
       var addedKeys = [];
-      for (var key in keyMap) {
+      for (key in keyMap) {
         if (keyMap[key] === -1) {
           removedIdxs.push(this._keyToInstIdx[key]);
         }
@@ -559,7 +558,7 @@
         // so we don't invalidate instance index
         // use numeric sort, default .sort is alphabetic
         removedIdxs.sort(this._numericSort);
-        for (var i=removedIdxs.length-1; i>=0 ; i--) {
+        for (i=removedIdxs.length-1; i>=0 ; i--) {
           var idx = removedIdxs[i];
           // Removed idx may be undefined if item was previously filtered out
           if (idx !== undefined) {
@@ -583,7 +582,7 @@
         });
         // Insertion-sort new instances into place (from pool or newly created)
         var start = 0;
-        for (var i=0; i<addedKeys.length; i++) {
+        for (i=0; i<addedKeys.length; i++) {
           start = this._insertRowUserSort(start, addedKeys[i]);
         }
       }
@@ -622,13 +621,12 @@
     // rows are as placeholders, and placeholders are updated to
     // actual rows at the end to take full advantage of removed rows
     _applySplicesArrayOrder: function(splices) {
-      var c = this.collection;
       for (var i=0, s; (i<splices.length) && (s=splices[i]); i++) {
         // Detach & pool removed instances
         for (var j=0; j<s.removed.length; j++) {
           this._detachAndRemoveInstance(s.index);
         }
-        for (var j=0; j<s.addedKeys.length; j++) {
+        for (j=0; j<s.addedKeys.length; j++) {
           this._insertPlaceholder(s.index+j, s.addedKeys[j]);
         }
       }
diff --git a/src/lib/template/templatizer.html b/src/lib/template/templatizer.html
index a6cdf5bf60..e946f07a99 100644
--- a/src/lib/template/templatizer.html
+++ b/src/lib/template/templatizer.html
@@ -181,7 +181,7 @@
       Polymer.dom.addDebouncer(this.debounce('_debounceTemplate', fn));
     },
 
-    _flushTemplates: function(debouncerExpired) {
+    _flushTemplates: function() {
       Polymer.dom.flush();
     },
 
@@ -191,7 +191,7 @@
         archetype._addPropertyEffect(prop, 'function',
           this._createHostPropEffector(prop));
       }
-      for (var prop in this._instanceProps) {
+      for (prop in this._instanceProps) {
         archetype._addPropertyEffect(prop, 'function',
           this._createInstancePropEffector(prop));
       }
@@ -309,12 +309,14 @@
     },
 
     // Extension points for Templatizer sub-classes
+    /* eslint-disable no-unused-vars */
     _showHideChildren: function(hidden) { },
     _forwardInstancePath: function(inst, path, value) { },
     _forwardInstanceProp: function(inst, prop, value) { },
     // Defined-check rather than thunk used to avoid unnecessary work for these:
     // _forwardParentPath: function(path, value) { },
     // _forwardParentProp: function(prop, value) { },
+    /* eslint-enable no-unused-vars */
 
     _notifyPathUpImpl: function(path, value) {
       var dataHost = this.dataHost;
@@ -448,7 +450,7 @@
         // An element with a _templateInstance marks the top boundary
         // of a scope; walk up until we find one, and then ensure that
         // its dataHost matches `this`, meaning this dom-repeat stamped it
-        if (model = el._templateInstance) {
+        if ((model = el._templateInstance)) {
           // Found an element stamped by another template; keep walking up
           // from its dataHost
           if (model.dataHost != this) {
diff --git a/src/micro/attributes.html b/src/micro/attributes.html
index 8622f97e29..d2799f9a51 100644
--- a/src/micro/attributes.html
+++ b/src/micro/attributes.html
@@ -108,7 +108,7 @@
     _setAttributeToProperty: function(model, attribute, property, info) {
       // Don't deserialize back to property if currently reflecting
       if (!this._serializing) {
-        var property = property || Polymer.CaseMap.dashToCamelCase(attribute);
+        property = (property || Polymer.CaseMap.dashToCamelCase(attribute));
         // fallback to property lookup
         // TODO(sorvell): check for _propertyInfo existence because of dom-bind
         info = info || (this._propertyInfo && this._propertyInfo[property]);
@@ -236,6 +236,7 @@
      * @return {string} String serialized from the provided property value.
      */
     serialize: function(value) {
+      /* eslint-disable no-fallthrough */
       switch (typeof value) {
         case 'boolean':
           return value ? '' : undefined;
@@ -255,7 +256,7 @@
           return value != null ? value : undefined;
       }
     }
-
+    /* eslint-enable no-fallthrough */
   });
 
 </script>
diff --git a/src/micro/properties.html b/src/micro/properties.html
index 60257e2c90..bd3b928d9d 100644
--- a/src/micro/properties.html
+++ b/src/micro/properties.html
@@ -116,7 +116,7 @@
           if (info) {
             return info;
           }
-        };
+        }
       }
       return info || Polymer.nob;
     },
@@ -138,7 +138,7 @@
     // union properties, behaviors.properties, and propertyEffects
     _prepPropertyInfo: function() {
       this._propertyInfo = {};
-      for (var i=0, p; i < this.behaviors.length; i++) {
+      for (var i=0; i < this.behaviors.length; i++) {
         this._addPropertyInfo(this._propertyInfo, this.behaviors[i].properties);
       }
       this._addPropertyInfo(this._propertyInfo, this.properties);
@@ -174,7 +174,7 @@
           }
         }
       }
-    },
+    }
 
   });
 
diff --git a/src/mini/shady.html b/src/mini/shady.html
index c06bc2fda4..9bc70164e6 100644
--- a/src/mini/shady.html
+++ b/src/mini/shady.html
@@ -77,12 +77,12 @@
         this.shadyRoot._isShadyRoot = true;
         this.shadyRoot._dirtyRoots = [];
         // capture insertion point list
-        var i$ = this.shadyRoot._insertionPoints = !this._notes || 
+        var i$ = this.shadyRoot._insertionPoints = !this._notes ||
           this._notes._hasContent ?
           this.shadyRoot.querySelectorAll('content') : [];
         // save logical tree info
-        // a. for shadyRoot 
-        // b. for insertion points (fallback) 
+        // a. for shadyRoot
+        // b. for insertion points (fallback)
         // c. for parents of insertion points
         TreeApi.Logical.saveChildNodes(this.shadyRoot);
         for (var i=0, c; i < i$.length; i++) {
@@ -119,7 +119,7 @@
        */
       distributeContent: function(updateInsertionPoints) {
         if (this.shadyRoot) {
-          this.shadyRoot._invalidInsertionPoints = 
+          this.shadyRoot._invalidInsertionPoints =
             this.shadyRoot._invalidInsertionPoints || updateInsertionPoints;
           // Distribute the host that's the top of this element's distribution
           // tree. Distributing that host will *always* distibute this element.
@@ -164,7 +164,7 @@
         // compose self
         if (this._useContent) {
           // note: it's important to mark this clean before distribution
-          // so that attachment that provokes additional distribution (e.g. 
+          // so that attachment that provokes additional distribution (e.g.
           // adding something to your parentNode) works
           this.shadyRoot._distributionClean = true;
           if (DomApi.hasInsertionPoint(this.shadyRoot)) {
@@ -331,7 +331,7 @@
         for (var i=0, d=0, s; (i<splices.length) && (s=splices[i]); i++) {
           for (var j=0, n; (j < s.removed.length) && (n=s.removed[j]); j++) {
             // check if the node is still where we expect it is before trying
-            // to remove it; this can happen if Polymer.dom moves a node and 
+            // to remove it; this can happen if Polymer.dom moves a node and
             // then schedules its previous host for distribution resulting in
             // the node being removed here.
             if (TreeApi.Composed.getParentNode(n) === container) {
@@ -342,9 +342,9 @@
           d -= s.addedCount;
         }
         // process adds
-        for (var i=0, s, next; (i<splices.length) && (s=splices[i]); i++) {
+        for (var i=0, s, next; (i<splices.length) && (s=splices[i]); i++) { //eslint-disable-line no-redeclare
           next = composed[s.index];
-          for (var j=s.index, n; j < s.index + s.addedCount; j++) {
+          for (j=s.index, n; j < s.index + s.addedCount; j++) {
             n = children[j];
             TreeApi.Composed.insertBefore(container, n, next);
             // TODO(sorvell): is this splice strictly needed?
diff --git a/src/standard/annotations.html b/src/standard/annotations.html
index 28ce066420..7c845c679e 100644
--- a/src/standard/annotations.html
+++ b/src/standard/annotations.html
@@ -227,7 +227,7 @@
     },
 
     // push configuration references at configure time
-    _configureAnnotationReferences: function(config) {
+    _configureAnnotationReferences: function() {
       var notes = this._notes;
       var nodes = this._nodes;
       for (var i=0; i<notes.length; i++) {
diff --git a/src/standard/gestures.html b/src/standard/gestures.html
index 48f4404a08..093fc8d9d0 100644
--- a/src/standard/gestures.html
+++ b/src/standard/gestures.html
@@ -255,7 +255,7 @@
         }
       }
       // enforce gesture recognizer order
-      for (var i = 0, r; i < recognizers.length; i++) {
+      for (i = 0, r; i < recognizers.length; i++) {
         r = recognizers[i];
         if (gs[r.name] && !handled[r.name]) {
           handled[r.name] = true;
diff --git a/src/standard/notify-path.html b/src/standard/notify-path.html
index 8751e4e0aa..0174974c44 100644
--- a/src/standard/notify-path.html
+++ b/src/standard/notify-path.html
@@ -1,632 +1,633 @@
-<!--
-@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
--->
-<link rel="import" href="../lib/case-map.html">
-<script>
-
-  /**
-   * Changes to an object sub-field (aka "path") via a binding
-   * (e.g. `<x-foo value="{{item.subfield}}"`) will notify other elements bound to
-   * the same object automatically.
-   *
-   * When modifying a sub-field of an object imperatively
-   * (e.g. `this.item.subfield = 42`), in order to have the new value propagated
-   * to other elements, a special `set(path, value)` API is provided.
-   * `set` sets the object field at the path specified, and then notifies the
-   * binding system so that other elements bound to the same path will update.
-   *
-   * Example:
-   *
-   *     Polymer({
-   *
-   *       is: 'x-date',
-   *
-   *       properties: {
-   *         date: {
-   *           type: Object,
-   *           notify: true
-   *          }
-   *       },
-   *
-   *       attached: function() {
-   *         this.date = {};
-   *         setInterval(function() {
-   *           var d = new Date();
-   *           // Required to notify elements bound to date of changes to sub-fields
-   *           // this.date.seconds = d.getSeconds(); <-- Will not notify
-   *           this.set('date.seconds', d.getSeconds());
-   *           this.set('date.minutes', d.getMinutes());
-   *           this.set('date.hours', d.getHours() % 12);
-   *         }.bind(this), 1000);
-   *       }
-   *
-   *     });
-   *
-   *  Allows bindings to `date` sub-fields to update on changes:
-   *
-   *     <x-date date="{{date}}"></x-date>
-   *
-   *     Hour: <span>{{date.hours}}</span>
-   *     Min:  <span>{{date.minutes}}</span>
-   *     Sec:  <span>{{date.seconds}}</span>
-   *
-   * @class data feature: path notification
-   */
-
-  (function() {
-    // Using strict here to ensure fast argument manipulation in array methods
-    'use strict';
-
-    Polymer.Base._addFeature({
-      /**
-       * Notify that a path has changed.
-       *
-       * Example:
-       *
-       *     this.item.user.name = 'Bob';
-       *     this.notifyPath('item.user.name', this.item.user.name);
-       *
-       * @param {string} path Path that should be notified.
-       * @param {*} value Value of the specified path.
-       * @param {boolean=} fromAbove When true, specifies that the change came
-       *   from above this element and thus upward notification is not
-       *   necessary.
-       * @return {boolean} Returns true if notification actually took place,
-       *   based on a dirty check of whether the new value was already known.
-      */
-      notifyPath: function(path, value, fromAbove) {
-        // Convert any array indices to keys before notifying path
-        var info = {};
-        this._get(path, this, info);
-        // Notify change to key-based path
-        if (info.path) {
-          this._notifyPath(info.path, value, fromAbove);
-        }
-      },
-
-      // Note: this implemetation only accepts key-based array paths
-      _notifyPath: function(path, value, fromAbove) {
-        var old = this._propertySetter(path, value);
-        // manual dirty checking for now...
-        // NaN is always not equal to itself,
-        // if old and value are both NaN we treat them as equal
-        // x === x is 10x faster, and equivalent to !isNaN(x)
-        if (old !== value && (old === old || value === value)) {
-          // console.group((this.localName || this.dataHost.id + '-' + this.dataHost.dataHost.index) + '#' + (this.id || this.index) + ' ' + path, value);
-          // Take path effects at this level for exact path matches,
-          // and notify down for any bindings to a subset of this path
-          this._pathEffector(path, value);
-          // Send event to notify the path change upwards
-          // Optimization: don't notify up if we know the notification
-          // is coming from above already (avoid wasted event dispatch)
-          if (!fromAbove) {
-            // TODO(sorvell): should only notify if notify: true?
-            this._notifyPathUp(path, value);
-          }
-          // console.groupEnd((this.localName || this.dataHost.id + '-' + this.dataHost.dataHost.index) + '#' + (this.id || this.index) + ' ' + path, value);
-          return true;
-        }
-      },
-
-      /**
-        Converts a path to an array of path parts.  A path may be specified
-        as a dotted string or an array of one or more dotted strings (or numbers,
-        for number-valued keys).
-      */
-      _getPathParts: function(path) {
-        if (Array.isArray(path)) {
-          var parts = [];
-          for (var i=0; i<path.length; i++) {
-            var args = path[i].toString().split('.');
-            for (var j=0; j<args.length; j++) {
-              parts.push(args[j]);
-            }
-          }
-          return parts;
-        } else {
-          return path.toString().split('.');
-        }
-      },
-
-      /**
-       * Convienence method for setting a value to a path and notifying any
-       * elements bound to the same path.
-       *
-       * Note, if any part in the path except for the last is undefined,
-       * this method does nothing (this method does not throw when
-       * dereferencing undefined paths).
-       *
-       * @method set
-       * @param {(string|Array<(string|number)>)} path Path to the value
-       *   to write.  The path may be specified as a string (e.g. `foo.bar.baz`)
-       *   or an array of path parts (e.g. `['foo.bar', 'baz']`).  Note that
-       *   bracketed expressions are not supported; string-based path parts
-       *   *must* be separated by dots.  Note that when dereferencing array
-       *   indices, the index may be used as a dotted part directly
-       *   (e.g. `users.12.name` or `['users', 12, 'name']`).
-       * @param {*} value Value to set at the specified path.
-       * @param {Object=} root Root object from which the path is evaluated.
-      */
-      set: function(path, value, root) {
-        var prop = root || this;
-        var parts = this._getPathParts(path);
-        var array;
-        var last = parts[parts.length-1];
-        if (parts.length > 1) {
-          // Loop over path parts[0..n-2] and dereference
-          for (var i=0; i<parts.length-1; i++) {
-            var part = parts[i];
-            if (array && part[0] == '#') {
-              // Part was key; lookup item in collection
-              prop = Polymer.Collection.get(array).getItem(part);
-            } else {
-              // Get item from simple property dereference
-              prop = prop[part];
-              if (array && (parseInt(part, 10) == part)) {
-                // Translate array indices to collection keys for path notificaiton
-                parts[i] = Polymer.Collection.get(array).getKey(prop);
-              }
-            }
-            if (!prop) {
-              return;
-            }
-            // Cache previous part if it is an array
-            array = Array.isArray(prop) ? prop : null;
-          }
-          // Special handling when last part is a array item: need to replace
-          // item in collection associated with key for that item
-          if (array) {
-            var coll = Polymer.Collection.get(array);
-            if (last[0] == '#') {
-              // Part was key; lookup item in collection
-              var key = last;
-              var old = coll.getItem(key);
-              // Update last part from key to index: O(n) lookup unavoidable
-              last = array.indexOf(old);
-              // Replace item associated with key in collection
-              coll.setItem(key, value);
-            } else if (parseInt(last, 10) == last) {
-              // Dereference index & lookup collection key
-              var old = prop[last];
-              var key = coll.getKey(old);
-              // Translate array indices to collection keys for path notificaiton
-              parts[i] = key;
-              // Replace item associated with key in collection
-              coll.setItem(key, value);
-            }
-          }
-          // Set value to object at end of path
-          prop[last] = value;
-          // Notify observers of path change
-          if (!root) {
-            this._notifyPath(parts.join('.'), value);
-          }
-        } else {
-          // Simple property set
-          prop[path] = value;
-        }
-      },
-
-      /**
-       * Convienence method for reading a value from a path.
-       *
-       * Note, if any part in the path is undefined, this method returns
-       * `undefined` (this method does not throw when dereferencing undefined
-       * paths).
-       *
-       * @method get
-       * @param {(string|Array<(string|number)>)} path Path to the value
-       *   to read.  The path may be specified as a string (e.g. `foo.bar.baz`)
-       *   or an array of path parts (e.g. `['foo.bar', 'baz']`).  Note that
-       *   bracketed expressions are not supported; string-based path parts
-       *   *must* be separated by dots.  Note that when dereferencing array
-       *   indices, the index may be used as a dotted part directly
-       *   (e.g. `users.12.name` or `['users', 12, 'name']`).
-       * @param {Object=} root Root object from which the path is evaluated.
-       * @return {*} Value at the path, or `undefined` if any part of the path
-       *   is undefined.
-       */
-      get: function(path, root) {
-        return this._get(path, root);
-      },
-
-      // If `info` object is supplied, a `path` property will be added to it
-      // containing the path with array indices converted to keys, for use
-      // by the private _notifyPath / _notifySplice implementations
-      _get: function(path, root, info) {
-        var prop = root || this;
-        var parts = this._getPathParts(path);
-        var array;
-        // Loop over path parts[0..n-1] and dereference
-        for (var i=0; i<parts.length; i++) {
-          if (!prop) {
-            return;
-          }
-          var part = parts[i];
-          if (array && part[0] == '#') {
-            // Part was key; lookup item in collection
-            prop = Polymer.Collection.get(array).getItem(part);
-          } else {
-            // Get item from simple property dereference
-            prop = prop[part];
-            if (info && array && (parseInt(part, 10) == part)) {
-              // Translate array indices to collection keys for path notificaiton
-              parts[i] = Polymer.Collection.get(array).getKey(prop);
-            }
-          }
-          // Cache previous part if it is an array
-          array = Array.isArray(prop) ? prop : null;
-        }
-        if (info) {
-          info.path = parts.join('.');
-        }
-        return prop;
-      },
-
-      _pathEffector: function(path, value) {
-        // get root property
-        var model = this._modelForPath(path);
-        // search property effects of the root property for 'annotation' effects
-        var fx$ = this._propertyEffects && this._propertyEffects[model];
-        if (fx$) {
-          for (var i=0, fx; (i<fx$.length) && (fx=fx$[i]); i++) {
-            // use memoized path functions
-            var fxFn = fx.pathFn;
-            if (fxFn) {
-              fxFn.call(this, path, value, fx.effect);
-            }
-          }
-        }
-        // notify runtime-bound paths
-        if (this._boundPaths) {
-          this._notifyBoundPaths(path, value);
-        }
-      },
-
-      _annotationPathEffect: function(path, value, effect) {
-        if (effect.value === path || effect.value.indexOf(path + '.') === 0) {
-          // TODO(sorvell): ideally the effect function is on this prototype
-          // so we don't have to call it like this.
-          Polymer.Bind._annotationEffect.call(this, path, value, effect);
-        } else if ((path.indexOf(effect.value + '.') === 0) && !effect.negate) {
-          // locate the bound node
-          var node = this._nodes[effect.index];
-          if (node && node._notifyPath) {
-            var p = this._fixPath(effect.name , effect.value, path);
-            node._notifyPath(p, value, true);
-          }
-        }
-      },
-
-      _complexObserverPathEffect: function(path, value, effect) {
-        if (this._pathMatchesEffect(path, effect)) {
-          Polymer.Bind._complexObserverEffect.call(this, path, value, effect);
-        }
-      },
-
-      _computePathEffect: function(path, value, effect) {
-        if (this._pathMatchesEffect(path, effect)) {
-          Polymer.Bind._computeEffect.call(this, path, value, effect);
-        }
-      },
-
-      _annotatedComputationPathEffect: function(path, value, effect) {
-        if (this._pathMatchesEffect(path, effect)) {
-          Polymer.Bind._annotatedComputationEffect.call(this, path, value, effect);
-        }
-      },
-
-      _pathMatchesEffect: function(path, effect) {
-        var effectArg = effect.trigger.name;
-        return (effectArg == path) ||
-          (effectArg.indexOf(path + '.') === 0) ||
-          (effect.trigger.wildcard && path.indexOf(effectArg) === 0);
-      },
-
-      /**
-       * Aliases one data path as another, such that path notifications from one
-       * are routed to the other.
-       *
-       * @method linkPaths
-       * @param {string} to Target path to link.
-       * @param {string} from Source path to link.
-       */
-      linkPaths: function(to, from) {
-        this._boundPaths = this._boundPaths || {};
-        if (from) {
-          this._boundPaths[to] = from;
-          // this.set(to, this._get(from));
-        } else {
-          this.unlinkPaths(to);
-          // this.set(to, from);
-        }
-      },
-
-      /**
-       * Removes a data path alias previously established with `linkPaths`.
-       *
-       * Note, the path to unlink should be the target (`to`) used when
-       * linking the paths.
-       *
-       * @method unlinkPaths
-       * @param {string} path Target path to unlink.
-       */
-      unlinkPaths: function(path) {
-        if (this._boundPaths) {
-          delete this._boundPaths[path];
-        }
-      },
-
-      _notifyBoundPaths: function(path, value) {
-        for (var a in this._boundPaths) {
-          var b = this._boundPaths[a];
-          if (path.indexOf(a + '.') == 0) {
-            this._notifyPath(this._fixPath(b, a, path), value);
-          } else if (path.indexOf(b + '.') == 0) {
-            this._notifyPath(this._fixPath(a, b, path), value);
-          }
-        }
-      },
-
-      _fixPath: function(property, root, path) {
-        return property + path.slice(root.length);
-      },
-
-      _notifyPathUp: function(path, value) {
-        var rootName = this._modelForPath(path);
-        var dashCaseName = Polymer.CaseMap.camelToDashCase(rootName);
-        var eventName = dashCaseName + this._EVENT_CHANGED;
-        // use a cached event here (_useCache: true) for efficiency
-        this.fire(eventName, {
-          path: path,
-          value: value
-        }, {bubbles: false, _useCache: true});
-      },
-
-      _modelForPath: function(path) {
-        var dot = path.indexOf('.');
-        return (dot < 0) ? path : path.slice(0, dot);
-      },
-
-      _EVENT_CHANGED: '-changed',
-
-      /**
-       * Notify that an array has changed.
-       *
-       * Example:
-       *
-       *     this.items = [ {name: 'Jim'}, {name: 'Todd'}, {name: 'Bill'} ];
-       *     ...
-       *     this.items.splice(1, 1, {name: 'Sam'});
-       *     this.items.push({name: 'Bob'});
-       *     this.notifySplices('items', [
-       *       { index: 1, removed: [{name: 'Todd'}], addedCount: 1, obect: this.items, type: 'splice' },
-       *       { index: 3, removed: [], addedCount: 1, object: this.items, type: 'splice'}
-       *     ]);
-       *
-       * @param {string} path Path that should be notified.
-       * @param {Array} splices Array of splice records indicating ordered
-       *   changes that occurred to the array. Each record should have the
-       *   following fields:
-       *    * index: index at which the change occurred
-       *    * removed: array of items that were removed from this index
-       *    * addedCount: number of new items added at this index
-       *    * object: a reference to the array in question
-       *    * type: the string literal 'splice'
-       *
-       *   Note that splice records _must_ be normalized such that they are
-       *   reported in index order (raw results from `Object.observe` are not
-       *   ordered and must be normalized/merged before notifying).
-      */
-      notifySplices: function(path, splices) {
-        var info = {};
-        var array = this._get(path, this, info);
-        // Notify change to key-based path
-        this._notifySplices(array, info.path, splices);
-      },
-
-      // Note: this implemetation only accepts key-based array paths
-      _notifySplices: function(array, path, splices) {
-        var change = {
-          keySplices: Polymer.Collection.applySplices(array, splices),
-          indexSplices: splices
-        };
-        if (!array.hasOwnProperty('splices')) {
-          Object.defineProperty(array, 'splices',
-            {configurable: true, writable: true});
-        }
-        array.splices = change;
-        this._notifyPath(path + '.splices', change);
-        this._notifyPath(path + '.length', array.length);
-        // Null here to allow potentially large splice records to be GC'ed
-        change.keySplices = null;
-        change.indexSplices = null;
-      },
-
-      _notifySplice: function(array, path, index, added, removed) {
-        this._notifySplices(array, path, [{
-          index: index,
-          addedCount: added,
-          removed: removed,
-          object: array,
-          type: 'splice'
-        }]);
-      },
-
-      /**
-       * Adds items onto the end of the array at the path specified.
-       *
-       * The arguments after `path` and return value match that of
-       * `Array.prototype.push`.
-       *
-       * This method notifies other paths to the same array that a
-       * splice occurred to the array.
-       *
-       * @method push
-       * @param {String} path Path to array.
-       * @param {...any} var_args Items to push onto array
-       * @return {number} New length of the array.
-       */
-      push: function(path) {
-        var info = {};
-        var array = this._get(path, this, info);
-        var args = Array.prototype.slice.call(arguments, 1);
-        var len = array.length;
-        var ret = array.push.apply(array, args);
-        if (args.length) {
-          this._notifySplice(array, info.path, len, args.length, []);
-        }
-        return ret;
-      },
-
-      /**
-       * Removes an item from the end of array at the path specified.
-       *
-       * The arguments after `path` and return value match that of
-       * `Array.prototype.pop`.
-       *
-       * This method notifies other paths to the same array that a
-       * splice occurred to the array.
-       *
-       * @method pop
-       * @param {String} path Path to array.
-       * @return {any} Item that was removed.
-       */
-      pop: function(path) {
-        var info = {};
-        var array = this._get(path, this, info);
-        var hadLength = Boolean(array.length);
-        var args = Array.prototype.slice.call(arguments, 1);
-        var ret = array.pop.apply(array, args);
-        if (hadLength) {
-          this._notifySplice(array, info.path, array.length, 0, [ret]);
-        }
-        return ret;
-      },
-
-      /**
-       * Starting from the start index specified, removes 0 or more items
-       * from the array and inserts 0 or more new itms in their place.
-       *
-       * The arguments after `path` and return value match that of
-       * `Array.prototype.splice`.
-       *
-       * This method notifies other paths to the same array that a
-       * splice occurred to the array.
-       *
-       * @method splice
-       * @param {String} path Path to array.
-       * @param {number} start Index from which to start removing/inserting.
-       * @param {number} deleteCount Number of items to remove.
-       * @param {...any} var_args Items to insert into array.
-       * @return {Array} Array of removed items.
-       */
-      splice: function(path, start, deleteCount) {
-        var info = {};
-        var array = this._get(path, this, info);
-        // Normalize fancy native splice handling of crazy start values
-        if (start < 0) {
-          start = array.length - Math.floor(-start);
-        } else {
-          start = Math.floor(start);
-        }
-        if (!start) {
-          start = 0;
-        }
-        var args = Array.prototype.slice.call(arguments, 1);
-        var ret = array.splice.apply(array, args);
-        var addedCount = Math.max(args.length - 2, 0);
-        if (addedCount || ret.length) {
-          this._notifySplice(array, info.path, start, addedCount, ret);
-        }
-        return ret;
-      },
-
-      /**
-       * Removes an item from the beginning of array at the path specified.
-       *
-       * The arguments after `path` and return value match that of
-       * `Array.prototype.pop`.
-       *
-       * This method notifies other paths to the same array that a
-       * splice occurred to the array.
-       *
-       * @method shift
-       * @param {String} path Path to array.
-       * @return {any} Item that was removed.
-       */
-      shift: function(path) {
-        var info = {};
-        var array = this._get(path, this, info);
-        var hadLength = Boolean(array.length);
-        var args = Array.prototype.slice.call(arguments, 1);
-        var ret = array.shift.apply(array, args);
-        if (hadLength) {
-          this._notifySplice(array, info.path, 0, 0, [ret]);
-        }
-        return ret;
-      },
-
-      /**
-       * Adds items onto the beginning of the array at the path specified.
-       *
-       * The arguments after `path` and return value match that of
-       * `Array.prototype.push`.
-       *
-       * This method notifies other paths to the same array that a
-       * splice occurred to the array.
-       *
-       * @method unshift
-       * @param {String} path Path to array.
-       * @param {...any} var_args Items to insert info array
-       * @return {number} New length of the array.
-       */
-      unshift: function(path) {
-        var info = {};
-        var array = this._get(path, this, info);
-        var args = Array.prototype.slice.call(arguments, 1);
-        var ret = array.unshift.apply(array, args);
-        if (args.length) {
-          this._notifySplice(array, info.path, 0, args.length, []);
-        }
-        return ret;
-      },
-
-      // TODO(kschaaf): This is the path analogue to Polymer.Bind.prepareModel,
-      // which provides API for path-based notification on elements with property
-      // effects; this should be re-factored along with the Bind lib, either all on
-      // Base or all in Bind (see issue https://github.com/Polymer/polymer/issues/2547).
-      prepareModelNotifyPath: function(model) {
-        this.mixin(model, {
-          fire: Polymer.Base.fire,
-          _getEvent: Polymer.Base._getEvent,
-          __eventCache: Polymer.Base.__eventCache,
-          notifyPath: Polymer.Base.notifyPath,
-          _get: Polymer.Base._get,
-          _EVENT_CHANGED: Polymer.Base._EVENT_CHANGED,
-          _notifyPath: Polymer.Base._notifyPath,
-          _notifyPathUp: Polymer.Base._notifyPathUp,
-          _pathEffector: Polymer.Base._pathEffector,
-          _annotationPathEffect: Polymer.Base._annotationPathEffect,
-          _complexObserverPathEffect: Polymer.Base._complexObserverPathEffect,
-          _annotatedComputationPathEffect: Polymer.Base._annotatedComputationPathEffect,
-          _computePathEffect: Polymer.Base._computePathEffect,
-          _modelForPath: Polymer.Base._modelForPath,
-          _pathMatchesEffect: Polymer.Base._pathMatchesEffect,
-          _notifyBoundPaths: Polymer.Base._notifyBoundPaths,
-          _getPathParts: Polymer.Base._getPathParts
-        });
-      }
-
-    });
-
-  })();
-
-
-</script>
+<!--
+@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
+-->
+<link rel="import" href="../lib/case-map.html">
+<script>
+
+  /**
+   * Changes to an object sub-field (aka "path") via a binding
+   * (e.g. `<x-foo value="{{item.subfield}}"`) will notify other elements bound to
+   * the same object automatically.
+   *
+   * When modifying a sub-field of an object imperatively
+   * (e.g. `this.item.subfield = 42`), in order to have the new value propagated
+   * to other elements, a special `set(path, value)` API is provided.
+   * `set` sets the object field at the path specified, and then notifies the
+   * binding system so that other elements bound to the same path will update.
+   *
+   * Example:
+   *
+   *     Polymer({
+   *
+   *       is: 'x-date',
+   *
+   *       properties: {
+   *         date: {
+   *           type: Object,
+   *           notify: true
+   *          }
+   *       },
+   *
+   *       attached: function() {
+   *         this.date = {};
+   *         setInterval(function() {
+   *           var d = new Date();
+   *           // Required to notify elements bound to date of changes to sub-fields
+   *           // this.date.seconds = d.getSeconds(); <-- Will not notify
+   *           this.set('date.seconds', d.getSeconds());
+   *           this.set('date.minutes', d.getMinutes());
+   *           this.set('date.hours', d.getHours() % 12);
+   *         }.bind(this), 1000);
+   *       }
+   *
+   *     });
+   *
+   *  Allows bindings to `date` sub-fields to update on changes:
+   *
+   *     <x-date date="{{date}}"></x-date>
+   *
+   *     Hour: <span>{{date.hours}}</span>
+   *     Min:  <span>{{date.minutes}}</span>
+   *     Sec:  <span>{{date.seconds}}</span>
+   *
+   * @class data feature: path notification
+   */
+
+  (function() {
+    // Using strict here to ensure fast argument manipulation in array methods
+    'use strict';
+
+    Polymer.Base._addFeature({
+      /**
+       * Notify that a path has changed.
+       *
+       * Example:
+       *
+       *     this.item.user.name = 'Bob';
+       *     this.notifyPath('item.user.name', this.item.user.name);
+       *
+       * @param {string} path Path that should be notified.
+       * @param {*} value Value of the specified path.
+       * @param {boolean=} fromAbove When true, specifies that the change came
+       *   from above this element and thus upward notification is not
+       *   necessary.
+       * @return {boolean} Returns true if notification actually took place,
+       *   based on a dirty check of whether the new value was already known.
+      */
+      notifyPath: function(path, value, fromAbove) {
+        // Convert any array indices to keys before notifying path
+        var info = {};
+        this._get(path, this, info);
+        // Notify change to key-based path
+        if (info.path) {
+          this._notifyPath(info.path, value, fromAbove);
+        }
+      },
+
+      // Note: this implemetation only accepts key-based array paths
+      _notifyPath: function(path, value, fromAbove) {
+        var old = this._propertySetter(path, value);
+        // manual dirty checking for now...
+        // NaN is always not equal to itself,
+        // if old and value are both NaN we treat them as equal
+        // x === x is 10x faster, and equivalent to !isNaN(x)
+        if (old !== value && (old === old || value === value)) {
+          // console.group((this.localName || this.dataHost.id + '-' + this.dataHost.dataHost.index) + '#' + (this.id || this.index) + ' ' + path, value);
+          // Take path effects at this level for exact path matches,
+          // and notify down for any bindings to a subset of this path
+          this._pathEffector(path, value);
+          // Send event to notify the path change upwards
+          // Optimization: don't notify up if we know the notification
+          // is coming from above already (avoid wasted event dispatch)
+          if (!fromAbove) {
+            // TODO(sorvell): should only notify if notify: true?
+            this._notifyPathUp(path, value);
+          }
+          // console.groupEnd((this.localName || this.dataHost.id + '-' + this.dataHost.dataHost.index) + '#' + (this.id || this.index) + ' ' + path, value);
+          return true;
+        }
+      },
+
+      /**
+        Converts a path to an array of path parts.  A path may be specified
+        as a dotted string or an array of one or more dotted strings (or numbers,
+        for number-valued keys).
+      */
+      _getPathParts: function(path) {
+        if (Array.isArray(path)) {
+          var parts = [];
+          for (var i=0; i<path.length; i++) {
+            var args = path[i].toString().split('.');
+            for (var j=0; j<args.length; j++) {
+              parts.push(args[j]);
+            }
+          }
+          return parts;
+        } else {
+          return path.toString().split('.');
+        }
+      },
+
+      /**
+       * Convienence method for setting a value to a path and notifying any
+       * elements bound to the same path.
+       *
+       * Note, if any part in the path except for the last is undefined,
+       * this method does nothing (this method does not throw when
+       * dereferencing undefined paths).
+       *
+       * @method set
+       * @param {(string|Array<(string|number)>)} path Path to the value
+       *   to write.  The path may be specified as a string (e.g. `foo.bar.baz`)
+       *   or an array of path parts (e.g. `['foo.bar', 'baz']`).  Note that
+       *   bracketed expressions are not supported; string-based path parts
+       *   *must* be separated by dots.  Note that when dereferencing array
+       *   indices, the index may be used as a dotted part directly
+       *   (e.g. `users.12.name` or `['users', 12, 'name']`).
+       * @param {*} value Value to set at the specified path.
+       * @param {Object=} root Root object from which the path is evaluated.
+      */
+      set: function(path, value, root) {
+        var prop = root || this;
+        var parts = this._getPathParts(path);
+        var array;
+        var last = parts[parts.length-1];
+        if (parts.length > 1) {
+          // Loop over path parts[0..n-2] and dereference
+          for (var i=0; i<parts.length-1; i++) {
+            var part = parts[i];
+            if (array && part[0] == '#') {
+              // Part was key; lookup item in collection
+              prop = Polymer.Collection.get(array).getItem(part);
+            } else {
+              // Get item from simple property dereference
+              prop = prop[part];
+              if (array && (parseInt(part, 10) == part)) {
+                // Translate array indices to collection keys for path notificaiton
+                parts[i] = Polymer.Collection.get(array).getKey(prop);
+              }
+            }
+            if (!prop) {
+              return;
+            }
+            // Cache previous part if it is an array
+            array = Array.isArray(prop) ? prop : null;
+          }
+          // Special handling when last part is a array item: need to replace
+          // item in collection associated with key for that item
+          if (array) {
+            var coll = Polymer.Collection.get(array);
+            var old, key;
+            if (last[0] == '#') {
+              // Part was key; lookup item in collection
+              key = last;
+              old = coll.getItem(key);
+              // Update last part from key to index: O(n) lookup unavoidable
+              last = array.indexOf(old);
+              // Replace item associated with key in collection
+              coll.setItem(key, value);
+            } else if (parseInt(last, 10) == last) {
+              // Dereference index & lookup collection key
+              old = prop[last];
+              key = coll.getKey(old);
+              // Translate array indices to collection keys for path notificaiton
+              parts[i] = key;
+              // Replace item associated with key in collection
+              coll.setItem(key, value);
+            }
+          }
+          // Set value to object at end of path
+          prop[last] = value;
+          // Notify observers of path change
+          if (!root) {
+            this._notifyPath(parts.join('.'), value);
+          }
+        } else {
+          // Simple property set
+          prop[path] = value;
+        }
+      },
+
+      /**
+       * Convienence method for reading a value from a path.
+       *
+       * Note, if any part in the path is undefined, this method returns
+       * `undefined` (this method does not throw when dereferencing undefined
+       * paths).
+       *
+       * @method get
+       * @param {(string|Array<(string|number)>)} path Path to the value
+       *   to read.  The path may be specified as a string (e.g. `foo.bar.baz`)
+       *   or an array of path parts (e.g. `['foo.bar', 'baz']`).  Note that
+       *   bracketed expressions are not supported; string-based path parts
+       *   *must* be separated by dots.  Note that when dereferencing array
+       *   indices, the index may be used as a dotted part directly
+       *   (e.g. `users.12.name` or `['users', 12, 'name']`).
+       * @param {Object=} root Root object from which the path is evaluated.
+       * @return {*} Value at the path, or `undefined` if any part of the path
+       *   is undefined.
+       */
+      get: function(path, root) {
+        return this._get(path, root);
+      },
+
+      // If `info` object is supplied, a `path` property will be added to it
+      // containing the path with array indices converted to keys, for use
+      // by the private _notifyPath / _notifySplice implementations
+      _get: function(path, root, info) {
+        var prop = root || this;
+        var parts = this._getPathParts(path);
+        var array;
+        // Loop over path parts[0..n-1] and dereference
+        for (var i=0; i<parts.length; i++) {
+          if (!prop) {
+            return;
+          }
+          var part = parts[i];
+          if (array && part[0] == '#') {
+            // Part was key; lookup item in collection
+            prop = Polymer.Collection.get(array).getItem(part);
+          } else {
+            // Get item from simple property dereference
+            prop = prop[part];
+            if (info && array && (parseInt(part, 10) == part)) {
+              // Translate array indices to collection keys for path notificaiton
+              parts[i] = Polymer.Collection.get(array).getKey(prop);
+            }
+          }
+          // Cache previous part if it is an array
+          array = Array.isArray(prop) ? prop : null;
+        }
+        if (info) {
+          info.path = parts.join('.');
+        }
+        return prop;
+      },
+
+      _pathEffector: function(path, value) {
+        // get root property
+        var model = this._modelForPath(path);
+        // search property effects of the root property for 'annotation' effects
+        var fx$ = this._propertyEffects && this._propertyEffects[model];
+        if (fx$) {
+          for (var i=0, fx; (i<fx$.length) && (fx=fx$[i]); i++) {
+            // use memoized path functions
+            var fxFn = fx.pathFn;
+            if (fxFn) {
+              fxFn.call(this, path, value, fx.effect);
+            }
+          }
+        }
+        // notify runtime-bound paths
+        if (this._boundPaths) {
+          this._notifyBoundPaths(path, value);
+        }
+      },
+
+      _annotationPathEffect: function(path, value, effect) {
+        if (effect.value === path || effect.value.indexOf(path + '.') === 0) {
+          // TODO(sorvell): ideally the effect function is on this prototype
+          // so we don't have to call it like this.
+          Polymer.Bind._annotationEffect.call(this, path, value, effect);
+        } else if ((path.indexOf(effect.value + '.') === 0) && !effect.negate) {
+          // locate the bound node
+          var node = this._nodes[effect.index];
+          if (node && node._notifyPath) {
+            var p = this._fixPath(effect.name , effect.value, path);
+            node._notifyPath(p, value, true);
+          }
+        }
+      },
+
+      _complexObserverPathEffect: function(path, value, effect) {
+        if (this._pathMatchesEffect(path, effect)) {
+          Polymer.Bind._complexObserverEffect.call(this, path, value, effect);
+        }
+      },
+
+      _computePathEffect: function(path, value, effect) {
+        if (this._pathMatchesEffect(path, effect)) {
+          Polymer.Bind._computeEffect.call(this, path, value, effect);
+        }
+      },
+
+      _annotatedComputationPathEffect: function(path, value, effect) {
+        if (this._pathMatchesEffect(path, effect)) {
+          Polymer.Bind._annotatedComputationEffect.call(this, path, value, effect);
+        }
+      },
+
+      _pathMatchesEffect: function(path, effect) {
+        var effectArg = effect.trigger.name;
+        return (effectArg == path) ||
+          (effectArg.indexOf(path + '.') === 0) ||
+          (effect.trigger.wildcard && path.indexOf(effectArg) === 0);
+      },
+
+      /**
+       * Aliases one data path as another, such that path notifications from one
+       * are routed to the other.
+       *
+       * @method linkPaths
+       * @param {string} to Target path to link.
+       * @param {string} from Source path to link.
+       */
+      linkPaths: function(to, from) {
+        this._boundPaths = this._boundPaths || {};
+        if (from) {
+          this._boundPaths[to] = from;
+          // this.set(to, this._get(from));
+        } else {
+          this.unlinkPaths(to);
+          // this.set(to, from);
+        }
+      },
+
+      /**
+       * Removes a data path alias previously established with `linkPaths`.
+       *
+       * Note, the path to unlink should be the target (`to`) used when
+       * linking the paths.
+       *
+       * @method unlinkPaths
+       * @param {string} path Target path to unlink.
+       */
+      unlinkPaths: function(path) {
+        if (this._boundPaths) {
+          delete this._boundPaths[path];
+        }
+      },
+
+      _notifyBoundPaths: function(path, value) {
+        for (var a in this._boundPaths) {
+          var b = this._boundPaths[a];
+          if (path.indexOf(a + '.') == 0) {
+            this._notifyPath(this._fixPath(b, a, path), value);
+          } else if (path.indexOf(b + '.') == 0) {
+            this._notifyPath(this._fixPath(a, b, path), value);
+          }
+        }
+      },
+
+      _fixPath: function(property, root, path) {
+        return property + path.slice(root.length);
+      },
+
+      _notifyPathUp: function(path, value) {
+        var rootName = this._modelForPath(path);
+        var dashCaseName = Polymer.CaseMap.camelToDashCase(rootName);
+        var eventName = dashCaseName + this._EVENT_CHANGED;
+        // use a cached event here (_useCache: true) for efficiency
+        this.fire(eventName, {
+          path: path,
+          value: value
+        }, {bubbles: false, _useCache: true});
+      },
+
+      _modelForPath: function(path) {
+        var dot = path.indexOf('.');
+        return (dot < 0) ? path : path.slice(0, dot);
+      },
+
+      _EVENT_CHANGED: '-changed',
+
+      /**
+       * Notify that an array has changed.
+       *
+       * Example:
+       *
+       *     this.items = [ {name: 'Jim'}, {name: 'Todd'}, {name: 'Bill'} ];
+       *     ...
+       *     this.items.splice(1, 1, {name: 'Sam'});
+       *     this.items.push({name: 'Bob'});
+       *     this.notifySplices('items', [
+       *       { index: 1, removed: [{name: 'Todd'}], addedCount: 1, obect: this.items, type: 'splice' },
+       *       { index: 3, removed: [], addedCount: 1, object: this.items, type: 'splice'}
+       *     ]);
+       *
+       * @param {string} path Path that should be notified.
+       * @param {Array} splices Array of splice records indicating ordered
+       *   changes that occurred to the array. Each record should have the
+       *   following fields:
+       *    * index: index at which the change occurred
+       *    * removed: array of items that were removed from this index
+       *    * addedCount: number of new items added at this index
+       *    * object: a reference to the array in question
+       *    * type: the string literal 'splice'
+       *
+       *   Note that splice records _must_ be normalized such that they are
+       *   reported in index order (raw results from `Object.observe` are not
+       *   ordered and must be normalized/merged before notifying).
+      */
+      notifySplices: function(path, splices) {
+        var info = {};
+        var array = this._get(path, this, info);
+        // Notify change to key-based path
+        this._notifySplices(array, info.path, splices);
+      },
+
+      // Note: this implemetation only accepts key-based array paths
+      _notifySplices: function(array, path, splices) {
+        var change = {
+          keySplices: Polymer.Collection.applySplices(array, splices),
+          indexSplices: splices
+        };
+        if (!array.hasOwnProperty('splices')) {
+          Object.defineProperty(array, 'splices',
+            {configurable: true, writable: true});
+        }
+        array.splices = change;
+        this._notifyPath(path + '.splices', change);
+        this._notifyPath(path + '.length', array.length);
+        // Null here to allow potentially large splice records to be GC'ed
+        change.keySplices = null;
+        change.indexSplices = null;
+      },
+
+      _notifySplice: function(array, path, index, added, removed) {
+        this._notifySplices(array, path, [{
+          index: index,
+          addedCount: added,
+          removed: removed,
+          object: array,
+          type: 'splice'
+        }]);
+      },
+
+      /**
+       * Adds items onto the end of the array at the path specified.
+       *
+       * The arguments after `path` and return value match that of
+       * `Array.prototype.push`.
+       *
+       * This method notifies other paths to the same array that a
+       * splice occurred to the array.
+       *
+       * @method push
+       * @param {String} path Path to array.
+       * @param {...any} var_args Items to push onto array
+       * @return {number} New length of the array.
+       */
+      push: function(path) {
+        var info = {};
+        var array = this._get(path, this, info);
+        var args = Array.prototype.slice.call(arguments, 1);
+        var len = array.length;
+        var ret = array.push.apply(array, args);
+        if (args.length) {
+          this._notifySplice(array, info.path, len, args.length, []);
+        }
+        return ret;
+      },
+
+      /**
+       * Removes an item from the end of array at the path specified.
+       *
+       * The arguments after `path` and return value match that of
+       * `Array.prototype.pop`.
+       *
+       * This method notifies other paths to the same array that a
+       * splice occurred to the array.
+       *
+       * @method pop
+       * @param {String} path Path to array.
+       * @return {any} Item that was removed.
+       */
+      pop: function(path) {
+        var info = {};
+        var array = this._get(path, this, info);
+        var hadLength = Boolean(array.length);
+        var args = Array.prototype.slice.call(arguments, 1);
+        var ret = array.pop.apply(array, args);
+        if (hadLength) {
+          this._notifySplice(array, info.path, array.length, 0, [ret]);
+        }
+        return ret;
+      },
+
+      /**
+       * Starting from the start index specified, removes 0 or more items
+       * from the array and inserts 0 or more new itms in their place.
+       *
+       * The arguments after `path` and return value match that of
+       * `Array.prototype.splice`.
+       *
+       * This method notifies other paths to the same array that a
+       * splice occurred to the array.
+       *
+       * @method splice
+       * @param {String} path Path to array.
+       * @param {number} start Index from which to start removing/inserting.
+       * @param {number} deleteCount Number of items to remove.
+       * @param {...any} var_args Items to insert into array.
+       * @return {Array} Array of removed items.
+       */
+      splice: function(path, start) {
+        var info = {};
+        var array = this._get(path, this, info);
+        // Normalize fancy native splice handling of crazy start values
+        if (start < 0) {
+          start = array.length - Math.floor(-start);
+        } else {
+          start = Math.floor(start);
+        }
+        if (!start) {
+          start = 0;
+        }
+        var args = Array.prototype.slice.call(arguments, 1);
+        var ret = array.splice.apply(array, args);
+        var addedCount = Math.max(args.length - 2, 0);
+        if (addedCount || ret.length) {
+          this._notifySplice(array, info.path, start, addedCount, ret);
+        }
+        return ret;
+      },
+
+      /**
+       * Removes an item from the beginning of array at the path specified.
+       *
+       * The arguments after `path` and return value match that of
+       * `Array.prototype.pop`.
+       *
+       * This method notifies other paths to the same array that a
+       * splice occurred to the array.
+       *
+       * @method shift
+       * @param {String} path Path to array.
+       * @return {any} Item that was removed.
+       */
+      shift: function(path) {
+        var info = {};
+        var array = this._get(path, this, info);
+        var hadLength = Boolean(array.length);
+        var args = Array.prototype.slice.call(arguments, 1);
+        var ret = array.shift.apply(array, args);
+        if (hadLength) {
+          this._notifySplice(array, info.path, 0, 0, [ret]);
+        }
+        return ret;
+      },
+
+      /**
+       * Adds items onto the beginning of the array at the path specified.
+       *
+       * The arguments after `path` and return value match that of
+       * `Array.prototype.push`.
+       *
+       * This method notifies other paths to the same array that a
+       * splice occurred to the array.
+       *
+       * @method unshift
+       * @param {String} path Path to array.
+       * @param {...any} var_args Items to insert info array
+       * @return {number} New length of the array.
+       */
+      unshift: function(path) {
+        var info = {};
+        var array = this._get(path, this, info);
+        var args = Array.prototype.slice.call(arguments, 1);
+        var ret = array.unshift.apply(array, args);
+        if (args.length) {
+          this._notifySplice(array, info.path, 0, args.length, []);
+        }
+        return ret;
+      },
+
+      // TODO(kschaaf): This is the path analogue to Polymer.Bind.prepareModel,
+      // which provides API for path-based notification on elements with property
+      // effects; this should be re-factored along with the Bind lib, either all on
+      // Base or all in Bind (see issue https://github.com/Polymer/polymer/issues/2547).
+      prepareModelNotifyPath: function(model) {
+        this.mixin(model, {
+          fire: Polymer.Base.fire,
+          _getEvent: Polymer.Base._getEvent,
+          __eventCache: Polymer.Base.__eventCache,
+          notifyPath: Polymer.Base.notifyPath,
+          _get: Polymer.Base._get,
+          _EVENT_CHANGED: Polymer.Base._EVENT_CHANGED,
+          _notifyPath: Polymer.Base._notifyPath,
+          _notifyPathUp: Polymer.Base._notifyPathUp,
+          _pathEffector: Polymer.Base._pathEffector,
+          _annotationPathEffect: Polymer.Base._annotationPathEffect,
+          _complexObserverPathEffect: Polymer.Base._complexObserverPathEffect,
+          _annotatedComputationPathEffect: Polymer.Base._annotatedComputationPathEffect,
+          _computePathEffect: Polymer.Base._computePathEffect,
+          _modelForPath: Polymer.Base._modelForPath,
+          _pathMatchesEffect: Polymer.Base._pathMatchesEffect,
+          _notifyBoundPaths: Polymer.Base._notifyBoundPaths,
+          _getPathParts: Polymer.Base._getPathParts
+        });
+      }
+
+    });
+
+  })();
+
+
+</script>
diff --git a/src/standard/utils.html b/src/standard/utils.html
index 8f8f5fe9a9..f223b558e9 100644
--- a/src/standard/utils.html
+++ b/src/standard/utils.html
@@ -144,7 +144,7 @@
     getEffectiveTextContent: function() {
       var cn = this.getEffectiveChildNodes();
       var tc = [];
-      for (var i=0, c; c = cn[i]; i++) {
+      for (var i=0, c; (c = cn[i]); i++) {
         if (c.nodeType !== Node.COMMENT_NODE) {
           tc.push(Polymer.dom(c).textContent);
         }
@@ -215,7 +215,7 @@
     fire: function(type, detail, options) {
       options = options || Polymer.nob;
       var node = options.node || this;
-      var detail = (detail === null || detail === undefined) ? {} : detail;
+      detail = (detail === null || detail === undefined) ? {} : detail;
       var bubbles = options.bubbles === undefined ? true : options.bubbles;
       var cancelable = Boolean(options.cancelable);
       var useCache = options._useCache;
diff --git a/src/standard/x-styling.html b/src/standard/x-styling.html
index 8e0ef8ba00..e50ff8579e 100644
--- a/src/standard/x-styling.html
+++ b/src/standard/x-styling.html
@@ -19,7 +19,6 @@
 
     var propertyUtils = Polymer.StyleProperties;
     var styleTransformer = Polymer.StyleTransformer;
-    var styleUtil = Polymer.StyleUtil;
     var styleDefaults = Polymer.StyleDefaults;
 
     var nativeShadow = Polymer.Settings.useNativeShadow;
@@ -77,7 +76,7 @@
 
       _findStyleHost: function() {
         var e = this, root;
-        while (root = Polymer.dom(e).getOwnerRoot()) {
+        while ((root = Polymer.dom(e).getOwnerRoot())) {
           if (Polymer.isInstance(root.host)) {
             return root.host;
           }