update polymer and platform.js

pkg/web_components/lib/platform.concat.js

 /**
  * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
  * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
  * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
  * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
  * Code distributed by Google as part of the polymer project is also
  * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
  */
 
 window.Platform = window.Platform || {};
@@ skipping 174 matching lines @@
   }
 
   function toNumber(s) {
     return +s;
   }
 
   function isObject(obj) {
     return obj === Object(obj);
   }
 
-  var numberIsNaN = global.Number.isNaN || function isNaN(value) {
+  var numberIsNaN = global.Number.isNaN || function(value) {
     return typeof value === 'number' && global.isNaN(value);
   }
 
   function areSameValue(left, right) {
     if (left === right)
       return left !== 0 || 1 / left === 1 / right;
     if (numberIsNaN(left) && numberIsNaN(right))
       return true;
 
     return left !== left && right !== right;
   }
 
   var createObject = ('__proto__' in {}) ?
     function(obj) { return obj; } :
     function(obj) {
       var proto = obj.__proto__;
       if (!proto)
         return obj;
       var newObject = Object.create(proto);
       Object.getOwnPropertyNames(obj).forEach(function(name) {
         Object.defineProperty(newObject, name,
                              Object.getOwnPropertyDescriptor(obj, name));
       });
       return newObject;
     };
 
   var identStart = '[\$_a-zA-Z]';
   var identPart = '[\$_a-zA-Z0-9]';
-  var ident = identStart + '+' + identPart + '*';
-  var elementIndex = '(?:[0-9]|[1-9]+[0-9]+)';
-  var identOrElementIndex = '(?:' + ident + '|' + elementIndex + ')';
-  var path = '(?:' + identOrElementIndex + ')(?:\\s*\\.\\s*' + identOrElementIndex + ')*';
-  var pathRegExp = new RegExp('^' + path + '$');
+  var identRegExp = new RegExp('^' + identStart + '+' + identPart + '*' + '$');
 
-  function isPathValid(s) {
-    if (typeof s != 'string')
-      return false;
-    s = s.trim();
+  function getPathCharType(char) {
+    if (char === undefined)
+      return 'eof';
 
-    if (s == '')
-      return true;
+    var code = char.charCodeAt(0);
 
-    if (s[0] == '.')
-      return false;
+    switch(code) {
+      case 0x5B: // [
+      case 0x5D: // ]
+      case 0x2E: // .
+      case 0x22: // "
+      case 0x27: // '
+      case 0x30: // 0
+        return char;
 
-    return pathRegExp.test(s);
+      case 0x5F: // _
+      case 0x24: // $
+        return 'ident';
+
+      case 0x20: // Space
+      case 0x09: // Tab
+      case 0x0A: // Newline
+      case 0x0D: // Return
+      case 0xA0:  // No-break space
+      case 0xFEFF:  // Byte Order Mark
+      case 0x2028:  // Line Separator
+      case 0x2029:  // Paragraph Separator
+        return 'ws';
+    }
+
+    // a-z, A-Z
+    if ((0x61 <= code && code <= 0x7A) || (0x41 <= code && code <= 0x5A))
+      return 'ident';
+
+    // 1-9
+    if (0x31 <= code && code <= 0x39)
+      return 'number';
+
+    return 'else';
+  }
+
+  var pathStateMachine = {
+    'beforePath': {
+      'ws': ['beforePath'],
+      'ident': ['inIdent', 'append'],
+      '[': ['beforeElement'],
+      'eof': ['afterPath']
+    },
+
+    'inPath': {
+      'ws': ['inPath'],
+      '.': ['beforeIdent'],
+      '[': ['beforeElement'],
+      'eof': ['afterPath']
+    },
+
+    'beforeIdent': {
+      'ws': ['beforeIdent'],
+      'ident': ['inIdent', 'append']
+    },
+
+    'inIdent': {
+      'ident': ['inIdent', 'append'],
+      '0': ['inIdent', 'append'],
+      'number': ['inIdent', 'append'],
+      'ws': ['inPath', 'push'],
+      '.': ['beforeIdent', 'push'],
+      '[': ['beforeElement', 'push'],
+      'eof': ['afterPath', 'push']
+    },
+
+    'beforeElement': {
+      'ws': ['beforeElement'],
+      '0': ['afterZero', 'append'],
+      'number': ['inIndex', 'append'],
+      "'": ['inSingleQuote', 'append', ''],
+      '"': ['inDoubleQuote', 'append', '']
+    },
+
+    'afterZero': {
+      'ws': ['afterElement', 'push'],
+      ']': ['inPath', 'push']
+    },
+
+    'inIndex': {
+      '0': ['inIndex', 'append'],
+      'number': ['inIndex', 'append'],
+      'ws': ['afterElement'],
+      ']': ['inPath', 'push']
+    },
+
+    'inSingleQuote': {
+      "'": ['afterElement'],
+      'eof': ['error'],
+      'else': ['inSingleQuote', 'append']
+    },
+
+    'inDoubleQuote': {
+      '"': ['afterElement'],
+      'eof': ['error'],
+      'else': ['inDoubleQuote', 'append']
+    },
+
+    'afterElement': {
+      'ws': ['afterElement'],
+      ']': ['inPath', 'push']
+    }
+  }
+
+  function noop() {}
+
+  function parsePath(path) {
+    var keys = [];
+    var index = -1;
+    var c, newChar, key, type, transition, action, typeMap, mode = 'beforePath';
+
+    var actions = {
+      push: function() {
+        if (key === undefined)
+          return;
+
+        keys.push(key);
+        key = undefined;
+      },
+
+      append: function() {
+        if (key === undefined)
+          key = newChar
+        else
+          key += newChar;
+      }
+    };
+
+    function maybeUnescapeQuote() {
+      if (index >= path.length)
+        return;
+
+      var nextChar = path[index + 1];
+      if ((mode == 'inSingleQuote' && nextChar == "'") ||
+          (mode == 'inDoubleQuote' && nextChar == '"')) {
+        index++;
+        newChar = nextChar;
+        actions.append();
+        return true;
+      }
+    }
+
+    while (mode) {
+      index++;
+      c = path[index];
+
+      if (c == '\\' && maybeUnescapeQuote(mode))
+        continue;
+
+      type = getPathCharType(c);
+      typeMap = pathStateMachine[mode];
+      transition = typeMap[type] || typeMap['else'] || 'error';
+
+      if (transition == 'error')
+        return; // parse error;
+
+      mode = transition[0];
+      action = actions[transition[1]] || noop;
+      newChar = transition[2] === undefined ? c : transition[2];
+      action();
+
+      if (mode === 'afterPath') {
+        return keys;
+      }
+    }
+
+    return; // parse error
+  }
+
+  function isIdent(s) {
+    return identRegExp.test(s);
   }
 
   var constructorIsPrivate = {};
 
-  function Path(s, privateToken) {
+  function Path(parts, privateToken) {
     if (privateToken !== constructorIsPrivate)
       throw Error('Use Path.get to retrieve path objects');
 
-    if (s.trim() == '')
-      return this;
-
-    if (isIndex(s)) {
-      this.push(s);
-      return this;
-    }
-
-    s.split(/\s*\.\s*/).filter(function(part) {
-      return part;
-    }).forEach(function(part) {
-      this.push(part);
-    }, this);
+    if (parts.length)
+      Array.prototype.push.apply(this, parts.slice());
 
     if (hasEval && this.length) {
       this.getValueFrom = this.compiledGetValueFromFn();
     }
   }
 
   // TODO(rafaelw): Make simple LRU cache
   var pathCache = {};
 
   function getPath(pathString) {
     if (pathString instanceof Path)
       return pathString;
 
-    if (pathString == null)
+    if (pathString == null || pathString.length == 0)
       pathString = '';
 
-    if (typeof pathString !== 'string')
+    if (typeof pathString != 'string') {
+      if (isIndex(pathString.length)) {
+        // Constructed with array-like (pre-parsed) keys
+        return new Path(pathString, constructorIsPrivate);
+      }
+
       pathString = String(pathString);
+    }
 
     var path = pathCache[pathString];
     if (path)
       return path;
-    if (!isPathValid(pathString))
+
+    var parts = parsePath(pathString);
+    if (!parts)
       return invalidPath;
-    var path = new Path(pathString, constructorIsPrivate);
+
+    var path = new Path(parts, constructorIsPrivate);
     pathCache[pathString] = path;
     return path;
   }
 
   Path.get = getPath;
 
+  function formatAccessor(key) {
+    if (isIndex(key)) {
+      return '[' + key + ']';
+    } else {
+      return '["' + key.replace(/"/g, '\\"') + '"]';
+    }
+  }
+
   Path.prototype = createObject({
     __proto__: [],
     valid: true,
 
     toString: function() {
-      return this.join('.');
+      var pathString = '';
+      for (var i = 0; i < this.length; i++) {
+        var key = this[i];
+        if (isIdent(key)) {
+          pathString += i ? '.' + key : key;
+        } else {
+          pathString += formatAccessor(key);
+        }
+      }
+
+      return pathString;
     },
 
     getValueFrom: function(obj, directObserver) {
       for (var i = 0; i < this.length; i++) {
         if (obj == null)
           return;
         obj = obj[this[i]];
       }
       return obj;
     },
 
     iterateObjects: function(obj, observe) {
       for (var i = 0; i < this.length; i++) {
         if (i)
           obj = obj[this[i - 1]];
         if (!isObject(obj))
           return;
         observe(obj, this[0]);
       }
     },
 
     compiledGetValueFromFn: function() {
-      var accessors = this.map(function(ident) {
-        return isIndex(ident) ? '["' + ident + '"]' : '.' + ident;
-      });
-
       var str = '';
       var pathString = 'obj';
       str += 'if (obj != null';
       var i = 0;
+      var key;
       for (; i < (this.length - 1); i++) {
-        var ident = this[i];
-        pathString += accessors[i];
+        key = this[i];
+        pathString += isIdent(key) ? '.' + key : formatAccessor(key);
         str += ' &&\n     ' + pathString + ' != null';
       }
       str += ')\n';
 
-      pathString += accessors[i];
+      var key = this[i];
+      pathString += isIdent(key) ? '.' + key : formatAccessor(key);
 
       str += '  return ' + pathString + ';\nelse\n  return undefined;';
       return new Function('obj', str);
     },
 
     setValueFrom: function(obj, value) {
       if (!this.length)
         return false;
 
       for (var i = 0; i < this.length - 1; i++) {
@@ skipping 580 matching lines @@
     Observer.call(this);
 
     this.object_ = object;
     this.path_ = getPath(path);
     this.directObserver_ = undefined;
   }
 
   PathObserver.prototype = createObject({
     __proto__: Observer.prototype,
 
+    get path() {
+      return this.path_;
+    },
+
     connect_: function() {
       if (hasObserve)
         this.directObserver_ = getObservedSet(this, this.object_);
 
       this.check_(undefined, true);
     },
 
     disconnect_: function() {
       this.value_ = undefined;
 
       if (this.directObserver_) {
         this.directObserver_.close(this);
         this.directObserver_ = undefined;
       }
     },
 
     iterateObjects_: function(observe) {
       this.path_.iterateObjects(this.object_, observe);
     },
 
     check_: function(changeRecords, skipChanges) {
       var oldValue = this.value_;
       this.value_ = this.path_.getValueFrom(this.object_);
       if (skipChanges || areSameValue(this.value_, oldValue))
         return false;
 
-      this.report_([this.value_, oldValue]);
+      this.report_([this.value_, oldValue, this]);
       return true;
     },
 
     setValue: function(newValue) {
       if (this.path_)
         this.path_.setValueFrom(this.object_, newValue);
     }
   });
 
   function CompoundObserver(reportChangesOnOpen) {
@@ skipping 189 matching lines @@
       this.setValueFn_ = undefined;
     }
   }
 
   var expectedRecordTypes = {
     add: true,
     update: true,
     delete: true
   };
 
- var updateRecord = {
-    object: undefined,
-    type: 'update',
-    name: undefined,
-    oldValue: undefined
-  };
-
-  function notify(object, name, value, oldValue) {
-    if (areSameValue(value, oldValue))
-      return;
-
-    // TODO(rafaelw): Hack hack hack. This entire code really needs to move
-    // out of observe-js into polymer.
-    if (typeof object.propertyChanged_ == 'function')
-      object.propertyChanged_(name, value, oldValue);
-
-    if (!hasObserve)
-      return;
-
-    var notifier = object.notifier_;
-    if (!notifier)
-      notifier = object.notifier_ = Object.getNotifier(object);
-
-    updateRecord.object = object;
-    updateRecord.name = name;
-    updateRecord.oldValue = oldValue;
-
-    notifier.notify(updateRecord);
-  }
-
-  Observer.createBindablePrototypeAccessor = function(proto, name) {
-    var privateName = name + '_';
-    var privateObservable  = name + 'Observable_';
-
-    proto[privateName] = proto[name];
-
-    Object.defineProperty(proto, name, {
-      get: function() {
-        var observable = this[privateObservable];
-        if (observable)
-          observable.deliver();
-
-        return this[privateName];
-      },
-      set: function(value) {
-        var observable = this[privateObservable];
-        if (observable) {
-          observable.setValue(value);
-          return;
-        }
-
-        var oldValue = this[privateName];
-        this[privateName] = value;
-        notify(this, name, value, oldValue);
-
-        return value;
-      },
-      configurable: true
-    });
-  }
-
-  Observer.bindToInstance = function(instance, name, observable, resolveFn) {
-    var privateName = name + '_';
-    var privateObservable  = name + 'Observable_';
-
-    instance[privateObservable] = observable;
-    var oldValue = instance[privateName];
-    var value = observable.open(function(value, oldValue) {
-      instance[privateName] = value;
-      notify(instance, name, value, oldValue);
-    });
-
-    if (resolveFn && !areSameValue(oldValue, value)) {
-      var resolvedValue = resolveFn(oldValue, value);
-      if (!areSameValue(value, resolvedValue)) {
-        value = resolvedValue;
-        if (observable.setValue)
-          observable.setValue(value);
-      }
-    }
-
-    instance[privateName] = value;
-    notify(instance, name, value, oldValue);
-
-    return {
-      close: function() {
-        observable.close();
-        instance[privateObservable] = undefined;
-      }
-    };
-  }
-
   function diffObjectFromChangeRecords(object, changeRecords, oldValues) {
     var added = {};
     var removed = {};
 
     for (var i = 0; i < changeRecords.length; i++) {
       var record = changeRecords[i];
       if (!expectedRecordTypes[record.type]) {
         console.error('Unknown changeRecord type: ' + record.type);
         console.error(record);
         continue;
@@ skipping 1761 matching lines @@
     }
 
     eventPhaseTable.set(event, phase);
     var type = event.type;
 
     var anyRemoved = false;
     // targetTable.set(event, target);
     targetTable.set(event, target);
     currentTargetTable.set(event, currentTarget);
 
-    for (var i = 0; i < listeners.length; i++) {
+    // Keep track of the invoke depth so that we only clean up the removed
+    // listeners if we are in the outermost invoke.
+    listeners.depth++;
+
+    for (var i = 0, len = listeners.length; i < len; i++) {
       var listener = listeners[i];
       if (listener.removed) {
         anyRemoved = true;
         continue;
       }
 
       if (listener.type !== type ||
           !listener.capture && phase === CAPTURING_PHASE ||
           listener.capture && phase === BUBBLING_PHASE) {
         continue;
       }
 
       try {
         if (typeof listener.handler === 'function')
           listener.handler.call(currentTarget, event);
         else
           listener.handler.handleEvent(event);
 
         if (stopImmediatePropagationTable.get(event))
           return false;
 
       } catch (ex) {
         if (!pendingError)
           pendingError = ex;
       }
     }
 
-    if (anyRemoved) {
+    listeners.depth--;
+
+    if (anyRemoved && listeners.depth === 0) {
       var copy = listeners.slice();
       listeners.length = 0;
       for (var i = 0; i < copy.length; i++) {
         if (!copy[i].removed)
           listeners.push(copy[i]);
       }
     }
 
     return !stopPropagationTable.get(event);
   }
@@ skipping 44 matching lines @@
     get target() {
       return targetTable.get(this);
     },
     get currentTarget() {
       return currentTargetTable.get(this);
     },
     get eventPhase() {
       return eventPhaseTable.get(this);
     },
     get path() {
-      var nodeList = new wrappers.NodeList();
       var eventPath = eventPathTable.get(this);
-      if (eventPath) {
-        var index = 0;
-        var lastIndex = eventPath.length - 1;
-        var baseRoot = getTreeScope(currentTargetTable.get(this));
-
-        for (var i = 0; i <= lastIndex; i++) {
-          var currentTarget = eventPath[i];
-          var currentRoot = getTreeScope(currentTarget);
-          if (currentRoot.contains(baseRoot) &&
-              // Make sure we do not add Window to the path.
-              (i !== lastIndex || currentTarget instanceof wrappers.Node)) {
-            nodeList[index++] = currentTarget;
-          }
-        }
-        nodeList.length = index;
-      }
-      return nodeList;
+      if (!eventPath)
+        return [];
+      // TODO(arv): Event path should contain window.
+      return eventPath.slice();
     },
     stopPropagation: function() {
       stopPropagationTable.set(this, true);
     },
     stopImmediatePropagation: function() {
       stopPropagationTable.set(this, true);
       stopImmediatePropagationTable.set(this, true);
     }
   };
   registerWrapper(OriginalEvent, Event, document.createEvent('Event'));
@@ skipping 207 matching lines @@
 
   EventTarget.prototype = {
     addEventListener: function(type, fun, capture) {
       if (!isValidListener(fun) || isMutationEvent(type))
         return;
 
       var listener = new Listener(type, fun, capture);
       var listeners = listenersTable.get(this);
       if (!listeners) {
         listeners = [];
+        listeners.depth = 0;
         listenersTable.set(this, listeners);
       } else {
         // Might have a duplicate.
         for (var i = 0; i < listeners.length; i++) {
           if (listener.equals(listeners[i]))
             return;
         }
       }
 
       listeners.push(listener);
@@ skipping 88 matching lines @@
 
   var originalElementFromPoint = document.elementFromPoint;
 
   function elementFromPoint(self, document, x, y) {
     scope.renderAllPending();
 
     var element = wrap(originalElementFromPoint.call(document.impl, x, y));
     if (!element)
       return null;
     var path = getEventPath(element, null);
+
+    // scope the path to this TreeScope
+    var idx = path.lastIndexOf(self);
+    if (idx == -1)
+      return null;
+    else
+      path = path.slice(0, idx);
+
+    // TODO(dfreedm): pass idx to eventRetargetting to avoid array copy
     return eventRetargetting(path, self);
   }
 
   /**
    * Returns a function that is to be used as a getter for `onfoo` properties.
    * @param {string} name
    * @return {Function}
    */
   function getEventHandlerGetter(name) {
     return function() {
@@ skipping 937 matching lines @@
             this.removeNode(n);
           else if (!modNode)
             modNode = n;
           else {
             s += n.data;
             remNodes.push(n);
           }
         } else {
           if (modNode && remNodes.length) {
             modNode.data += s;
-            cleanUpNodes(remNodes);
+            cleanupNodes(remNodes);
           }
           remNodes = [];
           s = '';
           modNode = null;
           if (n.childNodes.length)
             n.normalize();
         }
       }
 
       // handle case where >1 text nodes are the last children
@@ skipping 297 matching lines @@
         this.parentNode.insertBefore(newTextNode, this.nextSibling);
       return newTextNode;
     }
   });
 
   registerWrapper(OriginalText, Text, document.createTextNode(''));
 
   scope.wrappers.Text = Text;
 })(window.ShadowDOMPolyfill);
 
+// Copyright 2014 The Polymer Authors. All rights reserved.
+// Use of this source code is goverened by a BSD-style
+// license that can be found in the LICENSE file.
+
+(function(scope) {
+  'use strict';
+
+  function invalidateClass(el) {
+    scope.invalidateRendererBasedOnAttribute(el, 'class');
+  }
+
+  function DOMTokenList(impl, ownerElement) {
+    this.impl = impl;
+    this.ownerElement_ = ownerElement;
+  }
+
+  DOMTokenList.prototype = {
+    get length() {
+      return this.impl.length;
+    },
+    item: function(index) {
+      return this.impl.item(index);
+    },
+    contains: function(token) {
+      return this.impl.contains(token);
+    },
+    add: function() {
+      this.impl.add.apply(this.impl, arguments);
+      invalidateClass(this.ownerElement_);
+    },
+    remove: function() {
+      this.impl.remove.apply(this.impl, arguments);
+      invalidateClass(this.ownerElement_);
+    },
+    toggle: function(token) {
+      var rv = this.impl.toggle.apply(this.impl, arguments);
+      invalidateClass(this.ownerElement_);
+      return rv;
+    },
+    toString: function() {
+      return this.impl.toString();
+    }
+  };
+
+  scope.wrappers.DOMTokenList = DOMTokenList;
+})(window.ShadowDOMPolyfill);
+
 // Copyright 2013 The Polymer Authors. All rights reserved.
 // Use of this source code is goverened by a BSD-style
 // license that can be found in the LICENSE file.
 
 (function(scope) {
   'use strict';
 
   var ChildNodeInterface = scope.ChildNodeInterface;
   var GetElementsByInterface = scope.GetElementsByInterface;
   var Node = scope.wrappers.Node;
+  var DOMTokenList = scope.wrappers.DOMTokenList;
   var ParentNodeInterface = scope.ParentNodeInterface;
   var SelectorsInterface = scope.SelectorsInterface;
   var addWrapNodeListMethod = scope.addWrapNodeListMethod;
   var enqueueMutation = scope.enqueueMutation;
   var mixin = scope.mixin;
   var oneOf = scope.oneOf;
   var registerWrapper = scope.registerWrapper;
+  var unwrap = scope.unwrap;
   var wrappers = scope.wrappers;
 
   var OriginalElement = window.Element;
 
   var matchesNames = [
     'matches',  // needs to come first.
     'mozMatchesSelector',
     'msMatchesSelector',
     'webkitMatchesSelector',
   ].filter(function(name) {
@@ skipping 19 matching lines @@
     // This is not fully spec compliant. We should use localName (which might
     // have a different case than name) and the namespace (which requires us
     // to get the Attr object).
     enqueueMutation(element, 'attributes', {
       name: name,
       namespace: null,
       oldValue: oldValue
     });
   }
 
+  var classListTable = new WeakMap();
+
   function Element(node) {
     Node.call(this, node);
   }
   Element.prototype = Object.create(Node.prototype);
   mixin(Element.prototype, {
     createShadowRoot: function() {
       var newShadowRoot = new wrappers.ShadowRoot(this);
       this.impl.polymerShadowRoot_ = newShadowRoot;
 
       var renderer = scope.getRendererForHost(this);
@@ skipping 17 matching lines @@
 
     removeAttribute: function(name) {
       var oldValue = this.impl.getAttribute(name);
       this.impl.removeAttribute(name);
       enqueAttributeChange(this, name, oldValue);
       invalidateRendererBasedOnAttribute(this, name);
     },
 
     matches: function(selector) {
       return originalMatches.call(this.impl, selector);
+    },
+
+    get classList() {
+      var list = classListTable.get(this);
+      if (!list) {
+        classListTable.set(this,
+            list = new DOMTokenList(unwrap(this).classList, this));
+      }
+      return list;
+    },
+
+    get className() {
+      return unwrap(this).className;
+    },
+
+    set className(v) {
+      this.setAttribute('class', v);
+    },
+
+    get id() {
+      return unwrap(this).id;
+    },
+
+    set id(v) {
+      this.setAttribute('id', v);
     }
   });
 
   matchesNames.forEach(function(name) {
     if (name !== 'matches') {
       Element.prototype[name] = function(selector) {
         return this.matches(selector);
       };
     }
   });
 
   if (OriginalElement.prototype.webkitCreateShadowRoot) {
     Element.prototype.webkitCreateShadowRoot =
         Element.prototype.createShadowRoot;
   }
 
-  /**
-   * Useful for generating the accessor pair for a property that reflects an
-   * attribute.
-   */
-  function setterDirtiesAttribute(prototype, propertyName, opt_attrName) {
-    var attrName = opt_attrName || propertyName;
-    Object.defineProperty(prototype, propertyName, {
-      get: function() {
-        return this.impl[propertyName];
-      },
-      set: function(v) {
-        this.impl[propertyName] = v;
-        invalidateRendererBasedOnAttribute(this, attrName);
-      },
-      configurable: true,
-      enumerable: true
-    });
-  }
-
-  setterDirtiesAttribute(Element.prototype, 'id');
-  setterDirtiesAttribute(Element.prototype, 'className', 'class');
-
   mixin(Element.prototype, ChildNodeInterface);
   mixin(Element.prototype, GetElementsByInterface);
   mixin(Element.prototype, ParentNodeInterface);
   mixin(Element.prototype, SelectorsInterface);
 
   registerWrapper(OriginalElement, Element,
                   document.createElementNS(null, 'x'));
 
-  // TODO(arv): Export setterDirtiesAttribute and apply it to more bindings
-  // that reflect attributes.
+  scope.invalidateRendererBasedOnAttribute = invalidateRendererBasedOnAttribute;
   scope.matchesNames = matchesNames;
   scope.wrappers.Element = Element;
 })(window.ShadowDOMPolyfill);
 
 // Copyright 2013 The Polymer Authors. All rights reserved.
 // Use of this source code is goverened by a BSD-style
 // license that can be found in the LICENSE file.
 
 (function(scope) {
   'use strict';
@@ skipping 875 matching lines @@
   scope.wrappers.HTMLUnknownElement = HTMLUnknownElement;
 })(window.ShadowDOMPolyfill);
 
 // Copyright 2014 The Polymer Authors. All rights reserved.
 // Use of this source code is goverened by a BSD-style
 // license that can be found in the LICENSE file.
 
 (function(scope) {
   'use strict';
 
+  var Element = scope.wrappers.Element;
+  var HTMLElement = scope.wrappers.HTMLElement;
   var registerObject = scope.registerObject;
 
   var SVG_NS = 'http://www.w3.org/2000/svg';
   var svgTitleElement = document.createElementNS(SVG_NS, 'title');
   var SVGTitleElement = registerObject(svgTitleElement);
   var SVGElement = Object.getPrototypeOf(SVGTitleElement.prototype).constructor;
 
+  // IE11 does not have classList for SVG elements. The spec says that classList
+  // is an accessor on Element, but IE11 puts classList on HTMLElement, leaving
+  // SVGElement without a classList property. We therefore move the accessor for
+  // IE11.
+  if (!('classList' in svgTitleElement)) {
+    var descr = Object.getOwnPropertyDescriptor(Element.prototype, 'classList');
+    Object.defineProperty(HTMLElement.prototype, 'classList', descr);
+    delete Element.prototype.classList;
+  }
+
   scope.wrappers.SVGElement = SVGElement;
 })(window.ShadowDOMPolyfill);
 
 // Copyright 2014 The Polymer Authors. All rights reserved.
 // Use of this source code is goverened by a BSD-style
 // license that can be found in the LICENSE file.
 
 (function(scope) {
   'use strict';
 
@@ skipping 1271 matching lines @@
     },
     elementFromPoint: function(x, y) {
       return elementFromPoint(this, this, x, y);
     },
     importNode: function(node, deep) {
       return cloneNode(node, deep, this.impl);
     },
     getSelection: function() {
       renderAllPending();
       return new Selection(originalGetSelection.call(unwrap(this)));
+    },
+    getElementsByName: function(name) {
+      return SelectorsInterface.querySelectorAll.call(this,
+          '[name=' + JSON.stringify(String(name)) + ']');
     }
   });
 
   if (document.registerElement) {
     var originalRegisterElement = document.registerElement;
     Document.prototype.registerElement = function(tagName, object) {
       var prototype, extendsOption;
       if (object !== undefined) {
         prototype = object.prototype;
         extendsOption = object.extends;
@@ skipping 124 matching lines @@
     'createComment',
     'createDocumentFragment',
     'createElement',
     'createElementNS',
     'createEvent',
     'createEventNS',
     'createRange',
     'createTextNode',
     'elementFromPoint',
     'getElementById',
+    'getElementsByName',
     'getSelection',
   ]);
 
   mixin(Document.prototype, GetElementsByInterface);
   mixin(Document.prototype, ParentNodeInterface);
   mixin(Document.prototype, SelectorsInterface);
 
   mixin(Document.prototype, {
     get implementation() {
       var implementation = implementationTable.get(this);
@@ skipping 270 matching lines @@
 
 /*
  * 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
  */
 
-(function() {
+(function(scope) {
 
   // convenient global
   window.wrap = ShadowDOMPolyfill.wrapIfNeeded;
   window.unwrap = ShadowDOMPolyfill.unwrapIfNeeded;
 
   // users may want to customize other types
   // TODO(sjmiles): 'button' is now supported by ShadowDOMPolyfill, but
   // I've left this code here in case we need to temporarily patch another
   // type
   /*
@@ skipping 12 matching lines @@
       Object.getOwnPropertyDescriptor(Element.prototype, 'shadowRoot'));
 
   var originalCreateShadowRoot = Element.prototype.createShadowRoot;
   Element.prototype.createShadowRoot = function() {
     var root = originalCreateShadowRoot.call(this);
     CustomElements.watchShadow(this);
     return root;
   };
 
   Element.prototype.webkitCreateShadowRoot = Element.prototype.createShadowRoot;
-})();
+
+  function queryShadow(node, selector) {
+    var m, el = node.firstElementChild;
+    var shadows, sr, i;
+    shadows = [];
+    sr = node.shadowRoot;
+    while(sr) {
+      shadows.push(sr);
+      sr = sr.olderShadowRoot;
+    }
+    for(i = shadows.length - 1; i >= 0; i--) {
+      m = shadows[i].querySelector(selector);
+      if (m) {
+        return m;
+      }
+    }
+    while(el) {
+      m = queryShadow(el, selector);
+      if (m) {
+        return m;
+      }
+      el = el.nextElementSibling;
+    }
+    return null;
+  }
+
+  function queryAllShadows(node, selector, results) {
+    var el = node.firstElementChild;
+    var temp, sr, shadows, i, j;
+    shadows = [];
+    sr = node.shadowRoot;
+    while(sr) {
+      shadows.push(sr);
+      sr = sr.olderShadowRoot;
+    }
+    for (i = shadows.length - 1; i >= 0; i--) {
+      temp = shadows[i].querySelectorAll(selector);
+      for(j = 0; j < temp.length; j++) {
+        results.push(temp[j]);
+      }
+    }
+    while (el) {
+      queryAllShadows(el, selector, results);
+      el = el.nextElementSibling;
+    }
+    return results;
+  }
+
+  scope.queryAllShadows = function(node, selector, all) {
+    if (all) {
+      return queryAllShadows(node, selector, []);
+    } else {
+      return queryShadow(node, selector);
+    }
+  };
+})(window.Platform);
 
 /*
  * 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
  */
 
@@ skipping 381 matching lines @@
     for (var i=0; i < combinatorsRe.length; i++) {
       cssText = cssText.replace(combinatorsRe[i], ' ');
     }
     return cssText;
   },
   // change a selector like 'div' to 'name div'
   scopeRules: function(cssRules, scopeSelector) {
     var cssText = '';
     if (cssRules) {
       Array.prototype.forEach.call(cssRules, function(rule) {
-        if (rule.selectorText && (rule.style && rule.style.cssText)) {
+        if (rule.selectorText && (rule.style && rule.style.cssText !== undefined)) {
           cssText += this.scopeSelector(rule.selectorText, scopeSelector, 
             this.strictStyling) + ' {\n\t';
           cssText += this.propertiesFromRule(rule) + '\n}\n\n';
         } else if (rule.type === CSSRule.MEDIA_RULE) {
           cssText += '@media ' + rule.media.mediaText + ' {\n';
           cssText += this.scopeRules(rule.cssRules, scopeSelector);
           cssText += '\n}\n\n';
-        } else if (rule.cssText) {
-          cssText += rule.cssText + '\n\n';
+        } else {
+          // TODO(sjmiles): KEYFRAMES_RULE in IE11 throws when we query cssText
+          // 'cssText' in rule returns true, but rule.cssText throws anyway
+          // We can test the rule type, e.g.
+          //   else if (rule.type !== CSSRule.KEYFRAMES_RULE && rule.cssText) {
+          // but this will prevent cssText propagation in other browsers which
+          // support it.
+          // KEYFRAMES_RULE has a CSSRuleSet, so the text can probably be reconstructed
+          // from that collection; this would be a proper fix.
+          // For now, I'm trapping the exception so IE11 is unblocked in other areas.
+          try {
+            if (rule.cssText) {
+              cssText += rule.cssText + '\n\n';
+            }
+          } catch(x) {
+            // squelch
+          }
         }
       }, this);
     }
     return cssText;
   },
   scopeSelector: function(selector, scopeSelector, strict) {
     var r = [], parts = selector.split(',');
     parts.forEach(function(p) {
       p = p.trim();
       if (this.selectorNeedsScoping(p, scopeSelector)) {
@@ skipping 307 matching lines @@
         if (style.parentNode !== head) {
           // replace links in head
           if (elt.parentNode === head) {
             head.replaceChild(style, elt);
           } else {
             head.appendChild(style);
           }
         }
         style.__importParsed = true;
         this.markParsingComplete(elt);
+        this.parseNext();
       }
 
       var hasResource = HTMLImports.parser.hasResource;
       HTMLImports.parser.hasResource = function(node) {
         if (node.localName === 'link' && node.rel === 'stylesheet' &&
             node.hasAttribute(SHIM_ATTRIBUTE)) {
           return (node.__resource);
         } else {
           return hasResource.call(this, node);
         }
@@ skipping 1094 matching lines @@
 
   function module(name, dependsOrFactory, moduleFactory) {
     var module;
     switch (arguments.length) {
       case 0:
         return;
       case 1:
         module = null;
         break;
       case 2:
+        // dependsOrFactory is `factory` in this case
         module = dependsOrFactory.apply(this);
         break;
       default:
+        // dependsOrFactory is `depends` in this case
         module = withDependencies(moduleFactory, dependsOrFactory);
         break;
     }
     modules[name] = module;
   };
 
   function marshal(name) {
     return modules[name];
   }
 
   var modules = {};
 
   function using(depends, task) {
     HTMLImports.whenImportsReady(function() {
       withDependencies(task, depends);
     });
   };
 
   // exports
 
   scope.marshal = marshal;
-  scope.module = module;
+  // `module` confuses commonjs detectors
+  scope.modularize = module;
   scope.using = using;
 
 })(window);
 
 /*
  * 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
@@ skipping 86 matching lines @@
     }
   },
   resolveElementAttributes: function(node, url) {
     url = url || node.ownerDocument.baseURI;
     URL_ATTRS.forEach(function(v) {
       var attr = node.attributes[v];
       var value = attr && attr.value;
       var replacement;
       if (value && value.search(URL_TEMPLATE_SEARCH) < 0) {
         if (v === 'style') {
-          replacement = replaceUrlsInCssText(value, url, CSS_URL_REGEXP);
+          replacement = replaceUrlsInCssText(value, url, false, CSS_URL_REGEXP);
         } else {
           replacement = resolveRelativeUrl(url, value);
         }
         attr.value = replacement;
       }
     });
   }
 };
 
 var CSS_URL_REGEXP = /(url\()([^)]*)(\))/g;
 var CSS_IMPORT_REGEXP = /(@import[\s]+(?!url\())([^;]*)(;)/g;
-var URL_ATTRS = ['href', 'src', 'action', 'style'];
+var URL_ATTRS = ['href', 'src', 'action', 'style', 'url'];
 var URL_ATTRS_SELECTOR = '[' + URL_ATTRS.join('],[') + ']';
 var URL_TEMPLATE_SEARCH = '{{.*}}';
 
 function replaceUrlsInCssText(cssText, baseUrl, keepAbsolute, regexp) {
   return cssText.replace(regexp, function(m, pre, url, post) {
     var urlPath = url.replace(/["']/g, '');
     urlPath = resolveRelativeUrl(baseUrl, urlPath, keepAbsolute);
     return pre + '\'' + urlPath + '\'' + post;
   });
 }
@@ skipping 677 matching lines @@
         var body = pieces[1];
         if(header.indexOf(';base64') > -1) {
           body = atob(body);
         } else {
           body = decodeURIComponent(body);
         }
         setTimeout(function() {
             this.receive(url, elt, null, body);
         }.bind(this), 0);
       } else {
-        var receiveXhr = function(err, resource) {
-          this.receive(url, elt, err, resource);
+        var receiveXhr = function(err, resource, redirectedUrl) {
+          this.receive(url, elt, err, resource, redirectedUrl);
         }.bind(this);
         xhr.load(url, receiveXhr);
         // TODO(sorvell): blocked on)
         // https://code.google.com/p/chromium/issues/detail?id=257221
         // xhr'ing for a document makes scripts in imports runnable; otherwise
         // they are not; however, it requires that we have doctype=html in
         // the import which is unacceptable. This is only needed on Chrome
         // to avoid the bug above.
         /*
         if (isDocumentLink(elt)) {
           xhr.loadDocument(url, receiveXhr);
         } else {
           xhr.load(url, receiveXhr);
         }
         */
       }
     },
-    receive: function(url, elt, err, resource) {
+    receive: function(url, elt, err, resource, redirectedUrl) {
       this.cache[url] = resource;
       var $p = this.pending[url];
+      if ( redirectedUrl && redirectedUrl !== url ) {
+        this.cache[redirectedUrl] = resource;
+        $p = $p.concat(this.pending[redirectedUrl]);
+      }
       for (var i=0, l=$p.length, p; (i<l) && (p=$p[i]); i++) {
         //if (!err) {
-          this.onload(url, p, resource);
+          // If url was redirected, use the redirected location so paths are
+          // calculated relative to that.
+          this.onload(redirectedUrl || url, p, resource);
         //}
         this.tail();
       }
       this.pending[url] = null;
+      if ( redirectedUrl && redirectedUrl !== url ) {
+        this.pending[redirectedUrl] = null;
+      }
     },
     tail: function() {
       --this.inflight;
       this.checkDone();
     },
     checkDone: function() {
       if (!this.inflight) {
         this.oncomplete();
       }
     }
   };
 
   xhr = xhr || {
     async: true,
     ok: function(request) {
       return (request.status >= 200 && request.status < 300)
           || (request.status === 304)
           || (request.status === 0);
     },
     load: function(url, next, nextContext) {
       var request = new XMLHttpRequest();
       if (scope.flags.debug || scope.flags.bust) {
         url += '?' + Math.random();
       }
       request.open('GET', url, xhr.async);
       request.addEventListener('readystatechange', function(e) {
         if (request.readyState === 4) {
+          // Servers redirecting an import can add a Location header to help us
+          // polyfill correctly.
+          var locationHeader = request.getResponseHeader("Location");
+          var redirectedUrl = null;
+          if (locationHeader) {
+            var redirectedUrl = (locationHeader.substr( 0, 1 ) === "/")
+              ? location.origin + locationHeader  // Location is a relative path
+              : redirectedUrl;                    // Full path
+          }
           next.call(nextContext, !xhr.ok(request) && request,
-              request.response || request.responseText, url);
+              request.response || request.responseText, redirectedUrl);
         }
       });
       request.send();
       return request;
     },
     loadDocument: function(url, next, nextContext) {
       this.load(url, next, nextContext).responseType = 'document';
     }
   };
 
@@ skipping 53 matching lines @@
     if (this.isParsed(elt)) {
       flags.parse && console.log('[%s] is already parsed', elt.localName);
       return;
     }
     var fn = this[this.map[elt.localName]];
     if (fn) {
       this.markParsing(elt);
       fn.call(this, elt);
     }
   },
-  // only 1 element may be parsed at a time; parsing is async so, each
+  // only 1 element may be parsed at a time; parsing is async so each
   // parsing implementation must inform the system that parsing is complete
   // via markParsingComplete.
+  // To prompt the system to parse the next element, parseNext should then be
+  // called.
+  // Note, parseNext used to be included at the end of markParsingComplete, but
+  // we must not do this so that, for example, we can (1) mark parsing complete 
+  // then (2) fire an import load event, and then (3) parse the next resource.
   markParsing: function(elt) {
     flags.parse && console.log('parsing', elt);
     this.parsingElement = elt;
   },
   markParsingComplete: function(elt) {
     elt.__importParsed = true;
     if (elt.__importElement) {
       elt.__importElement.__importParsed = true;
     }
     this.parsingElement = null;
     flags.parse && console.log('completed', elt);
-    this.parseNext();
+  },
+  invalidateParse: function(doc) {
+    if (doc && doc.__importLink) {
+      doc.__importParsed = doc.__importLink.__importParsed = false;
+      this.parseSoon();
+    }
+  },
+  parseSoon: function() {
+    if (this._parseSoon) {
+      cancelAnimationFrame(this._parseDelay);
+    }
+    var parser = this;
+    this._parseSoon = requestAnimationFrame(function() {
+      parser.parseNext();
+    });
   },
   parseImport: function(elt) {
-    elt.import.__importParsed = true;
     // TODO(sorvell): consider if there's a better way to do this;
     // expose an imports parsing hook; this is needed, for example, by the
     // CustomElements polyfill.
     if (HTMLImports.__importsParsingHook) {
       HTMLImports.__importsParsingHook(elt);
     }
+    elt.import.__importParsed = true;
+    this.markParsingComplete(elt);
     // fire load event
     if (elt.__resource) {
       elt.dispatchEvent(new CustomEvent('load', {bubbles: false}));    
     } else {
       elt.dispatchEvent(new CustomEvent('error', {bubbles: false}));
     }
     // TODO(sorvell): workaround for Safari addEventListener not working
     // for elements not in the main document.
     if (elt.__pending) {
       var fn;
       while (elt.__pending.length) {
         fn = elt.__pending.shift();
         if (fn) {
           fn({target: elt});
         }
       }
     }
-    this.markParsingComplete(elt);
+    this.parseNext();
   },
   parseLink: function(linkElt) {
     if (nodeIsImport(linkElt)) {
       this.parseImport(linkElt);
     } else {
       // make href absolute
       linkElt.href = linkElt.href;
       this.parseGeneric(linkElt);
     }
   },
   parseStyle: function(elt) {
     // TODO(sorvell): style element load event can just not fire so clone styles
     var src = elt;
     elt = cloneStyle(elt);
     elt.__importElement = src;
     this.parseGeneric(elt);
   },
   parseGeneric: function(elt) {
     this.trackElement(elt);
     document.head.appendChild(elt);
   },
   // tracks when a loadable element has loaded
   trackElement: function(elt, callback) {
     var self = this;
     var done = function(e) {
       if (callback) {
         callback(e);
       }
       self.markParsingComplete(elt);
+      self.parseNext();
     };
     elt.addEventListener('load', done);
     elt.addEventListener('error', done);
 
     // NOTE: IE does not fire "load" event for styles that have already loaded
     // This is in violation of the spec, so we try our hardest to work around it
     if (isIe && elt.localName === 'style') {
       var fakeLoad = false;
       // If there's not @import in the textContent, assume it has loaded
       if (elt.textContent.indexOf('@import') == -1) {
@@ skipping 451 matching lines @@
 Copyright 2013 The Polymer Authors. All rights reserved.
 Use of this source code is governed by a BSD-style
 license that can be found in the LICENSE file.
 */
 
 (function(scope){
 
 var IMPORT_LINK_TYPE = scope.IMPORT_LINK_TYPE;
 var importSelector = 'link[rel=' + IMPORT_LINK_TYPE + ']';
 var importer = scope.importer;
+var parser = scope.parser;
 
 // we track mutations for addedNodes, looking for imports
 function handler(mutations) {
   for (var i=0, l=mutations.length, m; (i<l) && (m=mutations[i]); i++) {
     if (m.type === 'childList' && m.addedNodes.length) {
       addedNodes(m.addedNodes);
     }
   }
 }
 
 // find loadable elements and add them to the importer
 function addedNodes(nodes) {
+  var owner;
   for (var i=0, l=nodes.length, n; (i<l) && (n=nodes[i]); i++) {
+    owner = owner || n.ownerDocument;
     if (shouldLoadNode(n)) {
       importer.loadNode(n);
     }
     if (n.children && n.children.length) {
       addedNodes(n.children);
     }
   }
+  // TODO(sorvell): This is not the right approach here. We shouldn't need to
+  // invalidate parsing when an element is added. Disabling this code 
+  // until a better approach is found.
+  /*
+  if (owner) {
+    parser.invalidateParse(owner);
+  }
+  */
 }
 
 function shouldLoadNode(node) {
   return (node.nodeType === 1) && matches.call(node,
       importer.loadSelectorsForNode(node));
 }
 
 // x-plat matches
 var matches = HTMLElement.prototype.matches || 
     HTMLElement.prototype.matchesSelector || 
@@ skipping 444 matching lines @@
 // imports
 
 if (!scope) {
   scope = window.CustomElements = {flags:{}};
 }
 var flags = scope.flags;
 
 // native document.registerElement?
 
 var hasNative = Boolean(document.registerElement);
-// TODO(sorvell): See https://github.com/Polymer/polymer/issues/399
-// we'll address this by defaulting to CE polyfill in the presence of the SD
-// polyfill. This will avoid spamming excess attached/detached callbacks.
-// If there is a compelling need to run CE native with SD polyfill,
-// we'll need to fix this issue.
-var useNative = !flags.register && hasNative && !window.ShadowDOMPolyfill;
+// For consistent timing, use native custom elements only when not polyfilling
+// other key related web components features.
+var useNative = !flags.register && hasNative && !window.ShadowDOMPolyfill && (!window.HTMLImports || HTMLImports.useNative);
 
 if (useNative) {
 
   // stub
   var nop = function() {};
 
   // exports
   scope.registry = {};
   scope.upgradeElement = nop;
 
@@ skipping 269 matching lines @@
     var removeAttribute = prototype.removeAttribute;
     prototype.removeAttribute = function(name) {
       changeAttribute.call(this, name, null, removeAttribute);
     }
     prototype.setAttribute._polyfilled = true;
   }
 
   // https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/custom/
   // index.html#dfn-attribute-changed-callback
   function changeAttribute(name, value, operation) {
+    name = name.toLowerCase();
     var oldValue = this.getAttribute(name);
     operation.apply(this, arguments);
     var newValue = this.getAttribute(name);
     if (this.attributeChangedCallback
         && (newValue !== oldValue)) {
       this.attributeChangedCallback(name, oldValue, newValue);
     }
   }
 
   // element registry (maps tag names to definitions)
@@ skipping 1460 matching lines @@
       return {
         bindingMaps: {},
         raw: bindingDelegate,
         prepareBinding: delegateFn('prepareBinding'),
         prepareInstanceModel: delegateFn('prepareInstanceModel'),
         prepareInstancePositionChanged:
             delegateFn('prepareInstancePositionChanged')
       };
     },
 
-    // TODO(rafaelw): Assigning .bindingDelegate always succeeds. It may
-    // make sense to issue a warning or even throw if the template is already
-    // "activated", since this would be a strange thing to do.
     set bindingDelegate(bindingDelegate) {
       if (this.delegate_) {
         throw Error('Template must be cleared before a new bindingDelegate ' +
                     'can be assigned');
       }
 
       this.setDelegate_(this.newDelegate_(bindingDelegate));
     },
 
     get ref_() {
@@ skipping 670 matching lines @@
   }
 }
 
 // exports
 scope.flush = flush;
 
 })(window.Platform);
 
 
 //# sourceMappingURL=platform.concat.js.map