[web_components] update web_components and polymer.js

pkg/web_components/lib/platform.concat.js

 /*
  * Copyright 2012 The Polymer Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style
  * license that can be found in the LICENSE file.
  */
 
 if (typeof WeakMap === 'undefined') {
   (function() {
     var defineProperty = Object.defineProperty;
     var counter = Date.now() % 1e9;
@@ skipping 34 matching lines @@
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 (function(global) {
   'use strict';
 
-  var PROP_ADD_TYPE = 'add';
-  var PROP_UPDATE_TYPE = 'update';
-  var PROP_RECONFIGURE_TYPE = 'reconfigure';
-  var PROP_DELETE_TYPE = 'delete';
-  var ARRAY_SPLICE_TYPE = 'splice';
-
   // Detect and do basic sanity checking on Object/Array.observe.
   function detectObjectObserve() {
     if (typeof Object.observe !== 'function' ||
         typeof Array.observe !== 'function') {
       return false;
     }
 
     var records = [];
 
     function callback(recs) {
       records = recs;
     }
 
     var test = {};
+    var arr = [];
     Object.observe(test, callback);
+    Array.observe(arr, callback);
     test.id = 1;
     test.id = 2;
     delete test.id;
+    arr.push(1, 2);
+    arr.length = 0;
+
     Object.deliverChangeRecords(callback);
-    if (records.length !== 3)
+    if (records.length !== 5)
       return false;
 
-    // TODO(rafaelw): Remove this when new change record type names make it to
-    // chrome release.
-    if (records[0].type == 'new' &&
-        records[1].type == 'updated' &&
-        records[2].type == 'deleted') {
-      PROP_ADD_TYPE = 'new';
-      PROP_UPDATE_TYPE = 'updated';
-      PROP_RECONFIGURE_TYPE = 'reconfigured';
-      PROP_DELETE_TYPE = 'deleted';
-    } else if (records[0].type != 'add' ||
-               records[1].type != 'update' ||
-               records[2].type != 'delete') {
-      console.error('Unexpected change record names for Object.observe. ' +
-                    'Using dirty-checking instead');
+    if (records[0].type != 'add' ||
+        records[1].type != 'update' ||
+        records[2].type != 'delete' ||
+        records[3].type != 'splice' ||
+        records[4].type != 'splice') {
       return false;
     }
+
     Object.unobserve(test, callback);
-
-    test = [0];
-    Array.observe(test, callback);
-    test[1] = 1;
-    test.length = 0;
-    Object.deliverChangeRecords(callback);
-    if (records.length != 2)
-      return false;
-    if (records[0].type != ARRAY_SPLICE_TYPE ||
-        records[1].type != ARRAY_SPLICE_TYPE) {
-      return false;
-    }
-    Array.unobserve(test, callback);
+    Array.unobserve(arr, callback);
 
     return true;
   }
 
   var hasObserve = detectObjectObserve();
 
   function detectEval() {
     // don't test for eval if document has CSP securityPolicy object and we can see that
     // eval is not supported. This avoids an error message in console even when the exception
     // is caught
@@ skipping 138 matching lines @@
           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 (!obj)
+        if (!isObject(obj))
           return;
         observe(obj);
       }
     },
 
     compiledGetValueFromFn: function() {
       var accessors = this.map(function(ident) {
         return isIndex(ident) ? '["' + ident + '"]' : '.' + ident;
       });
 
@@ skipping 189 matching lines @@
 
   function newObservedSet() {
     var observers = [];
     var observerCount = 0;
     var objects = [];
     var toRemove = emptyArray;
     var resetNeeded = false;
     var resetScheduled = false;
 
     function observe(obj) {
-      if (!isObject(obj))
+      if (!obj)
         return;
 
       var index = toRemove.indexOf(obj);
       if (index >= 0) {
         toRemove[index] = undefined;
         objects.push(obj);
       } else if (objects.indexOf(obj) < 0) {
         objects.push(obj);
         Object.observe(obj, callback);
       }
@@ skipping 180 matching lines @@
 
     allObservers.push(observer);
   }
 
   function removeFromAll(observer) {
     Observer._allObserversCount--;
   }
 
   var runningMicrotaskCheckpoint = false;
 
-  var hasDebugForceFullDelivery = typeof Object.deliverAllChangeRecords == 'function';
+  var hasDebugForceFullDelivery = hasObserve && (function() {
+    try {
+      eval('%RunMicrotasks()');
+      return true;
+    } catch (ex) {
+      return false;
+    }
+  })();
 
   global.Platform = global.Platform || {};
 
   global.Platform.performMicrotaskCheckpoint = function() {
     if (runningMicrotaskCheckpoint)
       return;
 
     if (hasDebugForceFullDelivery) {
-      Object.deliverAllChangeRecords();
+      eval('%RunMicrotasks()');
       return;
     }
 
     if (!collectObservers)
       return;
 
     runningMicrotaskCheckpoint = true;
 
     var cycles = 0;
     var anyChanged, toCheck;
@@ skipping 409 matching lines @@
         this.observable_.close();
       this.callback_ = undefined;
       this.target_ = undefined;
       this.observable_ = undefined;
       this.value_ = undefined;
       this.getValueFn_ = undefined;
       this.setValueFn_ = undefined;
     }
   }
 
-  var expectedRecordTypes = {};
-  expectedRecordTypes[PROP_ADD_TYPE] = true;
-  expectedRecordTypes[PROP_UPDATE_TYPE] = true;
-  expectedRecordTypes[PROP_DELETE_TYPE] = true;
+  var expectedRecordTypes = {
+    add: true,
+    update: true,
+    delete: true
+  };
 
   function notifyFunction(object, name) {
     if (typeof Object.observe !== 'function')
       return;
 
     var notifier = Object.getNotifier(object);
     return function(type, oldValue) {
       var changeRecord = {
         object: object,
         type: type,
         name: name
       };
       if (arguments.length === 2)
         changeRecord.oldValue = oldValue;
       notifier.notify(changeRecord);
     }
   }
 
   Observer.defineComputedProperty = function(target, name, observable) {
     var notify = notifyFunction(target, name);
     var value = observable.open(function(newValue, oldValue) {
       value = newValue;
       if (notify)
-        notify(PROP_UPDATE_TYPE, oldValue);
+        notify('update', oldValue);
     });
 
     Object.defineProperty(target, name, {
       get: function() {
         observable.deliver();
         return value;
       },
       set: function(newValue) {
         observable.setValue(newValue);
         return newValue;
@@ skipping 21 matching lines @@
       var record = changeRecords[i];
       if (!expectedRecordTypes[record.type]) {
         console.error('Unknown changeRecord type: ' + record.type);
         console.error(record);
         continue;
       }
 
       if (!(record.name in oldValues))
         oldValues[record.name] = record.oldValue;
 
-      if (record.type == PROP_UPDATE_TYPE)
+      if (record.type == 'update')
         continue;
 
-      if (record.type == PROP_ADD_TYPE) {
+      if (record.type == 'add') {
         if (record.name in removed)
           delete removed[record.name];
         else
           added[record.name] = true;
 
         continue;
       }
 
       // type = 'delete'
       if (record.name in added) {
@@ skipping 376 matching lines @@
     if (!inserted)
       splices.push(splice);
   }
 
   function createInitialSplices(array, changeRecords) {
     var splices = [];
 
     for (var i = 0; i < changeRecords.length; i++) {
       var record = changeRecords[i];
       switch(record.type) {
-        case ARRAY_SPLICE_TYPE:
+        case 'splice':
           mergeSplice(splices, record.index, record.removed.slice(), record.addedCount);
           break;
-        case PROP_ADD_TYPE:
-        case PROP_UPDATE_TYPE:
-        case PROP_DELETE_TYPE:
+        case 'add':
+        case 'update':
+        case 'delete':
           if (!isIndex(record.name))
             continue;
           var index = toNumber(record.name);
           if (index < 0)
             continue;
           mergeSplice(splices, index, [record.oldValue], 1);
           break;
         default:
           console.error('Unexpected record type: ' + JSON.stringify(record));
           break;
@@ skipping 28 matching lines @@
   global.ArrayObserver.calculateSplices = function(current, previous) {
     return arraySplice.calculateSplices(current, previous);
   };
 
   global.ArraySplice = ArraySplice;
   global.ObjectObserver = ObjectObserver;
   global.PathObserver = PathObserver;
   global.CompoundObserver = CompoundObserver;
   global.Path = Path;
   global.ObserverTransform = ObserverTransform;
-
-  // TODO(rafaelw): Only needed for testing until new change record names
-  // make it to release.
-  global.Observer.changeRecordTypes = {
-    add: PROP_ADD_TYPE,
-    update: PROP_UPDATE_TYPE,
-    reconfigure: PROP_RECONFIGURE_TYPE,
-    'delete': PROP_DELETE_TYPE,
-    splice: ARRAY_SPLICE_TYPE
-  };
 })(typeof global !== 'undefined' && global && typeof module !== 'undefined' && module ? global : this || window);
 
 // prepoulate window.Platform.flags for default controls
 window.Platform = window.Platform || {};
 // prepopulate window.logFlags if necessary
 window.logFlags = window.logFlags || {};
 // process flags
 (function(scope){
   // import
   var flags = scope.flags || {};
   // populate flags from location
   location.search.slice(1).split('&').forEach(function(o) {
     o = o.split('=');
     o[0] && (flags[o[0]] = o[1] || true);
   });
-  var entryPoint = document.currentScript || document.querySelector('script[src*="platform.js"]');
+  var entryPoint = document.currentScript ||
+      document.querySelector('script[src*="platform.js"]');
   if (entryPoint) {
     var a = entryPoint.attributes;
     for (var i = 0, n; i < a.length; i++) {
       n = a[i];
       if (n.name !== 'src') {
         flags[n.name] = n.value || true;
       }
     }
   }
   if (flags.log) {
     flags.log.split(',').forEach(function(f) {
       window.logFlags[f] = true;
     });
   }
   // If any of these flags match 'native', then force native ShadowDOM; any
   // other truthy value, or failure to detect native
   // ShadowDOM, results in polyfill
-  flags.shadow = (flags.shadow || flags.shadowdom || flags.polyfill);
+  flags.shadow = flags.shadow || flags.shadowdom || flags.polyfill;
   if (flags.shadow === 'native') {
     flags.shadow = false;
   } else {
     flags.shadow = flags.shadow || !HTMLElement.prototype.createShadowRoot;
   }
 
+  if (flags.shadow && document.querySelectorAll('script').length > 1) {
+    console.warn('platform.js is not the first script on the page. ' +
+        'See http://www.polymer-project.org/docs/start/platform.html#setup ' +
+        'for details.');
+  }
+
   // CustomElements polyfill flag
   if (flags.register) {
     window.CustomElements = window.CustomElements || {flags: {}};
     window.CustomElements.flags.register = flags.register;
   }
 
   if (flags.imports) {
     window.HTMLImports = window.HTMLImports || {flags: {}};
     window.HTMLImports.flags.imports = flags.imports;
   }
@@ skipping 859 matching lines @@
         if (treeScope === this)
           return true;
       }
       return false;
     }
   };
 
   function setTreeScope(node, treeScope) {
     if (node.treeScope_ !== treeScope) {
       node.treeScope_ = treeScope;
+      for (var sr = node.shadowRoot; sr; sr = sr.olderShadowRoot) {
+        sr.treeScope_.parent = treeScope;
+      }
       for (var child = node.firstChild; child; child = child.nextSibling) {
         setTreeScope(child, treeScope);
       }
     }
   }
 
   function getTreeScope(node) {
     if (node.treeScope_)
       return node.treeScope_;
     var parent = node.parentNode;
@@ skipping 176 matching lines @@
 
   function inSameTree(a, b) {
     return getTreeScope(a) === getTreeScope(b);
   }
 
   function dispatchOriginalEvent(originalEvent) {
     // Make sure this event is only dispatched once.
     if (handledEventsTable.get(originalEvent))
       return;
     handledEventsTable.set(originalEvent, true);
+    dispatchEvent(wrap(originalEvent), wrap(originalEvent.target));
+  }
 
-    return dispatchEvent(wrap(originalEvent), wrap(originalEvent.target));
+  function isLoadLikeEvent(event) {
+    switch (event.type) {
+      case 'beforeunload':
+      case 'load':
+      case 'unload':
+        return true;
+    }
+    return false;
   }
 
   function dispatchEvent(event, originalWrapperTarget) {
     if (currentlyDispatchingEvents.get(event))
       throw new Error('InvalidStateError')
     currentlyDispatchingEvents.set(event, true);
 
     // Render to ensure that the event path is correct.
     scope.renderAllPending();
     var eventPath = retarget(originalWrapperTarget);
 
-    // For window load events the load event is dispatched at the window but
+    // For window "load" events the "load" event is dispatched at the window but
     // the target is set to the document.
     //
     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#the-end
     //
     // TODO(arv): Find a less hacky way to do this.
-    if (event.type === 'load' &&
-        eventPath.length === 2 &&
-        eventPath[0].target instanceof wrappers.Document) {
+    if (eventPath.length === 2 &&
+        eventPath[0].target instanceof wrappers.Document &&
+        isLoadLikeEvent(event)) {
       eventPath.shift();
     }
 
     eventPathTable.set(event, eventPath);
 
     if (dispatchCapturing(event, eventPath)) {
       if (dispatchAtTarget(event, eventPath)) {
         dispatchBubbling(event, eventPath);
       }
     }
@@ skipping 49 matching lines @@
   function invoke(tuple, event, phase) {
     var target = tuple.target;
     var currentTarget = tuple.currentTarget;
 
     var listeners = listenersTable.get(currentTarget);
     if (!listeners)
       return true;
 
     if ('relatedTarget' in event) {
       var originalEvent = unwrap(event);
+      var unwrappedRelatedTarget = originalEvent.relatedTarget;
+
       // X-Tag sets relatedTarget on a CustomEvent. If they do that there is no
       // way to have relatedTarget return the adjusted target but worse is that
       // the originalEvent might not have a relatedTarget so we hit an assert
       // when we try to wrap it.
-      if (originalEvent.relatedTarget) {
-        var relatedTarget = wrap(originalEvent.relatedTarget);
+      if (unwrappedRelatedTarget) {
+        // In IE we can get objects that are not EventTargets at this point.
+        // Safari does not have an EventTarget interface so revert to checking
+        // for addEventListener as an approximation.
+        if (unwrappedRelatedTarget instanceof Object &&
+            unwrappedRelatedTarget.addEventListener) {
+          var relatedTarget = wrap(unwrappedRelatedTarget);
 
-        var adjusted = adjustRelatedTarget(currentTarget, relatedTarget);
-        if (adjusted === target)
-          return true;
-
+          var adjusted = adjustRelatedTarget(currentTarget, relatedTarget);
+          if (adjusted === target)
+            return true;
+        } else {
+          adjusted = null;
+        }
         relatedTargetTable.set(event, adjusted);
       }
     }
 
     eventPhaseTable.set(event, phase);
     var type = event.type;
 
     var anyRemoved = false;
     targetTable.set(event, target);
     currentTargetTable.set(event, currentTarget);
@@ skipping 66 matching lines @@
     keyLocation: true
   };
 
   /**
    * Creates a new Event wrapper or wraps an existin native Event object.
    * @param {string|Event} type
    * @param {Object=} options
    * @constructor
    */
   function Event(type, options) {
-    if (type instanceof OriginalEvent)
-      this.impl = type;
-    else
+    if (type instanceof OriginalEvent) {
+      var impl = type;
+      if (!OriginalBeforeUnloadEvent && impl.type === 'beforeunload')
+        return new BeforeUnloadEvent(impl);
+      this.impl = impl;
+    } else {
       return wrap(constructEvent(OriginalEvent, 'Event', type, options));
+    }
   }
   Event.prototype = {
     get target() {
       return targetTable.get(this);
     },
     get currentTarget() {
       return currentTargetTable.get(this);
     },
     get eventPhase() {
       return eventPhaseTable.get(this);
@@ skipping 62 matching lines @@
       }
     }
     return GenericEvent;
   }
 
   var UIEvent = registerGenericEvent('UIEvent', Event);
   var CustomEvent = registerGenericEvent('CustomEvent', Event);
 
   var relatedTargetProto = {
     get relatedTarget() {
-      return relatedTargetTable.get(this) || wrap(unwrap(this).relatedTarget);
+      var relatedTarget = relatedTargetTable.get(this);
+      // relatedTarget can be null.
+      if (relatedTarget !== undefined)
+        return relatedTarget;
+      return wrap(unwrap(this).relatedTarget);
     }
   };
 
   function getInitFunction(name, relatedTargetIndex) {
     return function() {
       arguments[relatedTargetIndex] = unwrap(arguments[relatedTargetIndex]);
       var impl = unwrap(this);
       impl[name].apply(impl, arguments);
     };
   }
@@ skipping 68 matching lines @@
       ctrlKey: false,
       altKey: false,
       shiftKey: false,
       metaKey: false,
       button: 0,
       relatedTarget: null
     }, 'UIEvent');
     configureEventConstructor('FocusEvent', {relatedTarget: null}, 'UIEvent');
   }
 
+  // Safari 7 does not yet have BeforeUnloadEvent.
+  // https://bugs.webkit.org/show_bug.cgi?id=120849
+  var OriginalBeforeUnloadEvent = window.BeforeUnloadEvent;
+
   function BeforeUnloadEvent(impl) {
-    Event.call(this);
+    Event.call(this, impl);
   }
   BeforeUnloadEvent.prototype = Object.create(Event.prototype);
   mixin(BeforeUnloadEvent.prototype, {
     get returnValue() {
       return this.impl.returnValue;
     },
     set returnValue(v) {
       this.impl.returnValue = v;
     }
   });
 
+  if (OriginalBeforeUnloadEvent)
+    registerWrapper(OriginalBeforeUnloadEvent, BeforeUnloadEvent);
+
   function isValidListener(fun) {
     if (typeof fun === 'function')
       return true;
     return fun && fun.handleEvent;
   }
 
   function isMutationEvent(type) {
     switch (type) {
       case 'DOMAttrModified':
       case 'DOMAttributeNameChanged':
@@ skipping 308 matching lines @@
   var assert = scope.assert;
   var defineWrapGetter = scope.defineWrapGetter;
   var enqueueMutation = scope.enqueueMutation;
   var getTreeScope = scope.getTreeScope;
   var isWrapper = scope.isWrapper;
   var mixin = scope.mixin;
   var registerTransientObservers = scope.registerTransientObservers;
   var registerWrapper = scope.registerWrapper;
   var setTreeScope = scope.setTreeScope;
   var unwrap = scope.unwrap;
+  var unwrapIfNeeded = scope.unwrapIfNeeded;
   var wrap = scope.wrap;
   var wrapIfNeeded = scope.wrapIfNeeded;
   var wrappers = scope.wrappers;
 
   function assertIsNodeWrapper(node) {
     assert(node instanceof Node);
   }
 
   function createOneElementNodeList(node) {
     var nodes = new NodeList();
@@ skipping 628 matching lines @@
       return cloneNode(this, deep);
     },
 
     contains: function(child) {
       return contains(this, wrapIfNeeded(child));
     },
 
     compareDocumentPosition: function(otherNode) {
       // This only wraps, it therefore only operates on the composed DOM and not
       // the logical DOM.
-      return originalCompareDocumentPosition.call(this.impl, unwrap(otherNode));
+      return originalCompareDocumentPosition.call(this.impl,
+                                                  unwrapIfNeeded(otherNode));
     },
 
     normalize: function() {
       var nodes = snapshotNodeList(this.childNodes);
       var remNodes = [];
       var s = '';
       var modNode;
 
       for (var i = 0, n; i < nodes.length; i++) {
         n = nodes[i];
@@ skipping 166 matching lines @@
     get children() {
       var wrapperList = new NodeList();
       var i = 0;
       for (var child = this.firstElementChild;
            child;
            child = child.nextElementSibling) {
         wrapperList[i++] = child;
       }
       wrapperList.length = i;
       return wrapperList;
+    },
+
+    remove: function() {
+      var p = this.parentNode;
+      if (p)
+        p.removeChild(this);
     }
   };
 
   var ChildNodeInterface = {
     get nextElementSibling() {
       return forwardElement(this.nextSibling);
     },
 
     get previousElementSibling() {
       return backwardsElement(this.previousSibling);
@@ skipping 922 matching lines @@
   mixin(HTMLSelectElement.prototype, {
     add: function(element, before) {
       if (typeof before === 'object')  // also includes null
         before = unwrap(before);
       unwrap(this).add(unwrap(element), before);
     },
 
     remove: function(indexOrNode) {
       // Spec only allows index but implementations allow index or node.
       // remove() is also allowed which is same as remove(undefined)
+      if (indexOrNode === undefined) {
+        HTMLElement.prototype.remove.call(this);
+        return;
+      }
+
       if (typeof indexOrNode === 'object')
         indexOrNode = unwrap(indexOrNode);
+
       unwrap(this).remove(indexOrNode);
     },
 
     get form() {
       return wrap(unwrap(this).form);
     }
   });
 
   registerWrapper(OriginalHTMLSelectElement, HTMLSelectElement,
                   document.createElement('select'));
@@ skipping 1499 matching lines @@
     },
     getSelection: function() {
       renderAllPending();
       return new Selection(originalGetSelection.call(unwrap(this)));
     }
   });
 
   if (document.registerElement) {
     var originalRegisterElement = document.registerElement;
     Document.prototype.registerElement = function(tagName, object) {
-      var prototype = object.prototype;
+      var prototype, extendsOption;
+      if (object !== undefined) {
+        prototype = object.prototype;
+        extendsOption = object.extends;
+      }
+
+      if (!prototype)
+        prototype = Object.create(HTMLElement.prototype);
+
 
       // If we already used the object as a prototype for another custom
       // element.
       if (scope.nativePrototypeTable.get(prototype)) {
         // TODO(arv): DOMException
         throw new Error('NotSupportedError');
       }
 
       // Find first object on the prototype chain that already have a native
       // prototype. Keep track of all the objects before that so we can create
@@ skipping 40 matching lines @@
           // if this element has been wrapped prior to registration,
           // the wrapper is stale; in this case rewrap
           if (!(wrap(this) instanceof CustomElementConstructor)) {
             rewrap(this);
           }
           f.apply(wrap(this), arguments);
         };
       });
 
       var p = {prototype: newPrototype};
-      if (object.extends)
-        p.extends = object.extends;
+      if (extendsOption)
+        p.extends = extendsOption;
 
       function CustomElementConstructor(node) {
         if (!node) {
-          if (object.extends) {
-            return document.createElement(object.extends, tagName);
+          if (extendsOption) {
+            return document.createElement(extendsOption, tagName);
           } else {
             return document.createElement(tagName);
           }
         }
         this.impl = node;
       }
       CustomElementConstructor.prototype = prototype;
       CustomElementConstructor.prototype.constructor = CustomElementConstructor;
 
       scope.constructorTable.set(newPrototype, CustomElementConstructor);
@@ skipping 181 matching lines @@
       return new Selection(originalGetSelection.call(unwrap(this)));
     },
   });
 
   registerWrapper(OriginalWindow, Window);
 
   scope.wrappers.Window = Window;
 
 })(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 unwrap = scope.unwrap;
+
+  // DataTransfer (Clipboard in old Blink/WebKit) has a single method that
+  // requires wrapping. Since it is only a method we do not need a real wrapper,
+  // we can just override the method.
+
+  var OriginalDataTransfer = window.DataTransfer || window.Clipboard;
+  var OriginalDataTransferSetDragImage =
+      OriginalDataTransfer.prototype.setDragImage;
+
+  OriginalDataTransfer.prototype.setDragImage = function(image, x, y) {
+    OriginalDataTransferSetDragImage.call(this, unwrap(image), x, y);
+  };
+
+})(window.ShadowDOMPolyfill);
+
 // Copyright 2013 The Polymer Authors. All rights reserved.
 // Use of this source code is goverened by a BSD-style
 // license that can be found in the LICENSE file.
 
 (function(scope) {
   'use strict';
 
   var isWrapperFor = scope.isWrapperFor;
 
   // This is a list of the elements we currently override the global constructor
@@ skipping 150 matching lines @@
   relatively simply implemented. The goal is to allow users to avoid the 
   most obvious pitfalls and do so without compromising performance significantly. 
   For ShadowDOM styling that's not covered here, a set of best practices
   can be provided that should allow users to accomplish more complex styling.
 
   The following is a list of specific ShadowDOM styling features and a brief
   discussion of the approach used to shim.
 
   Shimmed features:
 
-  * :host, :ancestor: ShadowDOM allows styling of the shadowRoot's host
+  * :host, :host-context: ShadowDOM allows styling of the shadowRoot's host
   element using the :host rule. To shim this feature, the :host styles are 
   reformatted and prefixed with a given scope name and promoted to a 
   document level stylesheet.
   For example, given a scope name of .foo, a rule like this:
   
     :host {
         background: red;
       }
     }
   
@@ skipping 153 matching lines @@
   registerRoot: function(root, name, extendsName) {
     var def = this.registry[name] = {
       root: root,
       name: name,
       extendsName: extendsName
     }
     var styles = this.findStyles(root);
     def.rootStyles = styles;
     def.scopeStyles = def.rootStyles;
     var extendee = this.registry[def.extendsName];
-    if (extendee && (!root || root.querySelector('shadow'))) {
+    if (extendee) {
       def.scopeStyles = extendee.scopeStyles.concat(def.scopeStyles);
     }
     return def;
   },
   findStyles: function(root) {
     if (!root) {
       return [];
     }
     var styles = root.querySelectorAll('style');
     return Array.prototype.filter.call(styles, function(s) {
@@ skipping 74 matching lines @@
    *  .foo {... } 
    *  
    *  and converts this to
    *  
    *  scopeName .foo { ... }
   */
   scopeCssText: function(cssText, scopeSelector) {
     var unscoped = this.extractUnscopedRulesFromCssText(cssText);
     cssText = this.insertPolyfillHostInCssText(cssText);
     cssText = this.convertColonHost(cssText);
-    cssText = this.convertColonAncestor(cssText);
+    cssText = this.convertColonHostContext(cssText);
     cssText = this.convertCombinators(cssText);
     if (scopeSelector) {
       var self = this, cssText;
       withCssRules(cssText, function(rules) {
         cssText = self.scopeRules(rules, scopeSelector);
       });
 
     }
     cssText = cssText + '\n' + unscoped;
     return cssText.trim();
@@ skipping 28 matching lines @@
    *
    * to
    *
    * scopeName.foo > .bar
   */
   convertColonHost: function(cssText) {
     return this.convertColonRule(cssText, cssColonHostRe,
         this.colonHostPartReplacer);
   },
   /*
-   * convert a rule like :ancestor(.foo) > .bar { }
+   * convert a rule like :host-context(.foo) > .bar { }
    *
    * to
    *
    * scopeName.foo > .bar, .foo scopeName > .bar { }
    * 
    * and
    *
-   * :ancestor(.foo:host) .bar { ... }
+   * :host-context(.foo:host) .bar { ... }
    * 
    * to
    * 
    * scopeName.foo .bar { ... }
   */
-  convertColonAncestor: function(cssText) {
-    return this.convertColonRule(cssText, cssColonAncestorRe,
-        this.colonAncestorPartReplacer);
+  convertColonHostContext: function(cssText) {
+    return this.convertColonRule(cssText, cssColonHostContextRe,
+        this.colonHostContextPartReplacer);
   },
   convertColonRule: function(cssText, regExp, partReplacer) {
     // p1 = :host, p2 = contents of (), p3 rest of rule
     return cssText.replace(regExp, function(m, p1, p2, p3) {
       p1 = polyfillHostNoCombinator;
       if (p2) {
         var parts = p2.split(','), r = [];
         for (var i=0, l=parts.length, p; (i<l) && (p=parts[i]); i++) {
           p = p.trim();
           r.push(partReplacer(p1, p, p3));
         }
         return r.join(',');
       } else {
         return p1 + p3;
       }
     });
   },
-  colonAncestorPartReplacer: function(host, part, suffix) {
+  colonHostContextPartReplacer: function(host, part, suffix) {
     if (part.match(polyfillHost)) {
       return this.colonHostPartReplacer(host, part, suffix);
     } else {
       return host + part + suffix + ', ' + part + ' ' + host + suffix;
     }
   },
   colonHostPartReplacer: function(host, part, suffix) {
     return host + part.replace(polyfillHost, '') + suffix;
   },
   /*
    * Convert ^ and ^^ combinators by replacing with space.
   */
   convertCombinators: function(cssText) {
-    return cssText.replace(/\^\^/g, ' ').replace(/\^/g, ' ');
+    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)) {
           cssText += this.scopeSelector(rule.selectorText, scopeSelector, 
             this.strictStyling) + ' {\n\t';
           cssText += this.propertiesFromRule(rule) + '\n}\n\n';
@@ skipping 52 matching lines @@
         var t = p.trim().replace(polyfillHostRe, '');
         if (t && (splits.indexOf(t) < 0) && (t.indexOf(attrName) < 0)) {
           p = t.replace(/([^:]*)(:*)(.*)/, '$1' + attrName + '$2$3')
         }
         return p;
       }).join(sep);
     });
     return scoped;
   },
   insertPolyfillHostInCssText: function(selector) {
-    return selector.replace(hostRe, polyfillHost).replace(colonHostRe,
-        polyfillHost).replace(colonAncestorRe, polyfillAncestor);
+    return selector.replace(colonHostContextRe, polyfillHostContext).replace(
+        colonHostRe, polyfillHost);
   },
   propertiesFromRule: function(rule) {
+    var cssText = rule.style.cssText;
     // TODO(sorvell): Safari cssom incorrectly removes quotes from the content
     // property. (https://bugs.webkit.org/show_bug.cgi?id=118045)
-    if (rule.style.content && !rule.style.content.match(/['"]+/)) {
-      return rule.style.cssText.replace(/content:[^;]*;/g, 'content: \'' + 
+    // don't replace attr rules
+    if (rule.style.content && !rule.style.content.match(/['"]+|attr/)) {
+      cssText = cssText.replace(/content:[^;]*;/g, 'content: \'' + 
           rule.style.content + '\';');
     }
-    return rule.style.cssText;
+    // TODO(sorvell): we can workaround this issue here, but we need a list
+    // of troublesome properties to fix https://github.com/Polymer/platform/issues/53
+    //
+    // inherit rules can be omitted from cssText
+    // TODO(sorvell): remove when Blink bug is fixed:
+    // https://code.google.com/p/chromium/issues/detail?id=358273
+    var style = rule.style;
+    for (var i in style) {
+      if (style[i] === 'initial') {
+        cssText += i + ': initial; ';
+      }
+    }
+    return cssText;
   },
   replaceTextInStyles: function(styles, action) {
     if (styles && action) {
       if (!(styles instanceof Array)) {
         styles = [styles];
       }
       Array.prototype.forEach.call(styles, function(s) {
         s.textContent = action.call(this, s.textContent);
       }, this);
     }
@@ skipping 15 matching lines @@
     // TODO(sorvell): remove either content or comment
     cssCommentRuleRe = /\/\*\s@polyfill-rule([^*]*\*+([^/*][^*]*\*+)*)\//gim,
     cssContentRuleRe = /(polyfill-rule)[^}]*(content\:[\s]*'([^']*)'[^;]*;)[^}]*}/gim,
     // TODO(sorvell): remove either content or comment
     cssCommentUnscopedRuleRe = /\/\*\s@polyfill-unscoped-rule([^*]*\*+([^/*][^*]*\*+)*)\//gim,
     cssContentUnscopedRuleRe = /(polyfill-unscoped-rule)[^}]*(content\:[\s]*'([^']*)'[^;]*;)[^}]*}/gim,
     cssPseudoRe = /::(x-[^\s{,(]*)/gim,
     cssPartRe = /::part\(([^)]*)\)/gim,
     // note: :host pre-processed to -shadowcsshost.
     polyfillHost = '-shadowcsshost',
-    // note: :ancestor pre-processed to -shadowcssancestor.
-    polyfillAncestor = '-shadowcssancestor',
+    // note: :host-context pre-processed to -shadowcsshostcontext.
+    polyfillHostContext = '-shadowcsscontext',
     parenSuffix = ')(?:\\((' +
         '(?:\\([^)(]*\\)|[^)(]*)+?' +
         ')\\))?([^,{]*)';
     cssColonHostRe = new RegExp('(' + polyfillHost + parenSuffix, 'gim'),
-    cssColonAncestorRe = new RegExp('(' + polyfillAncestor + parenSuffix, 'gim'),
+    cssColonHostContextRe = new RegExp('(' + polyfillHostContext + parenSuffix, 'gim'),
     selectorReSuffix = '([>\\s~+\[.,{:][\\s\\S]*)?$',
-    hostRe = /@host/gim,
     colonHostRe = /\:host/gim,
-    colonAncestorRe = /\:ancestor/gim,
+    colonHostContextRe = /\:host-context/gim,
     /* host name without combinator */
     polyfillHostNoCombinator = polyfillHost + '-no-combinator',
     polyfillHostRe = new RegExp(polyfillHost, 'gim'),
-    polyfillAncestorRe = new RegExp(polyfillAncestor, 'gim');
+    polyfillHostContextRe = new RegExp(polyfillHostContext, 'gim'),
+    combinatorsRe = [
+      /\^\^/g,
+      /\^/g,
+      /\/shadow\//g,
+      /\/shadow-deep\//g,
+      /::shadow/g,
+      /\/deep\//g
+    ];
 
 function stylesToCssText(styles, preserveComments) {
   var cssText = '';
   Array.prototype.forEach.call(styles, function(s) {
     cssText += s.textContent + '\n\n';
   });
   // strip comments for easier processing
   if (!preserveComments) {
     cssText = cssText.replace(cssCommentRe, '');
   }
@@ skipping 191 matching lines @@
   // poor man's adapter for template.content on various platform scenarios
   window.templateContent = window.templateContent || function(inTemplate) {
     return inTemplate.content;
   };
 
   // so we can call wrap/unwrap without testing for ShadowDOMPolyfill
 
   window.wrap = window.unwrap = function(n){
     return n;
   }
-
-  var originalCreateShadowRoot = Element.prototype.webkitCreateShadowRoot;
-  Element.prototype.webkitCreateShadowRoot = function() {
-    var elderRoot = this.webkitShadowRoot;
-    var root = originalCreateShadowRoot.call(this);
-    root.olderShadowRoot = elderRoot;
-    root.host = this;
-    CustomElements.watchShadow(this);
-    return root;
-  }
-
-  Object.defineProperties(Element.prototype, {
-    shadowRoot: {
-      get: function() {
-        return this.webkitShadowRoot;
-      }
-    },
-    createShadowRoot: {
-      value: function() {
-        return this.webkitCreateShadowRoot();
-      }
+  
+  addEventListener('DOMContentLoaded', function() {
+    if (CustomElements.useNative === false) {
+      var originalCreateShadowRoot = Element.prototype.createShadowRoot;
+      Element.prototype.createShadowRoot = function() {
+        var root = originalCreateShadowRoot.call(this);
+        CustomElements.watchShadow(this);
+        return root;
+      };
     }
   });
-
+  
   window.templateContent = function(inTemplate) {
     // if MDV exists, it may need to boostrap this template to reveal content
     if (window.HTMLTemplateElement && HTMLTemplateElement.bootstrap) {
       HTMLTemplateElement.bootstrap(inTemplate);
     }
     // fallback when there is no Shadow DOM polyfill, no MDV polyfill, and no
     // native template support
     if (!inTemplate.content && !inTemplate._content) {
       var frag = document.createDocumentFragment();
       while (inTemplate.firstChild) {
@@ skipping 1827 matching lines @@
         // don't need fetch
         return true;
       }
       // first node waiting for inUrl
       this.pending[url] = [elt];
       // need fetch (not a dupe)
       return false;
     },
     fetch: function(url, elt) {
       flags.load && console.log('fetch', url, elt);
-      var receiveXhr = function(err, resource) {
-        this.receive(url, elt, err, resource);
-      }.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);
+      if (url.match(/^data:/)) {
+        // Handle Data URI Scheme
+        var pieces = url.split(',');
+        var header = pieces[0];
+        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);
+        }.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) {
       this.cache[url] = resource;
       var $p = this.pending[url];
       for (var i=0, l=$p.length, p; (i<l) && (p=$p[i]); i++) {
         //if (!err) {
           this.onload(url, p, resource);
         //}
         this.tail();
       }
@@ skipping 1104 matching lines @@
   scope.upgradeElement = nop;
 
   scope.watchShadow = nop;
   scope.upgrade = nop;
   scope.upgradeAll = nop;
   scope.upgradeSubtree = nop;
   scope.observeDocument = nop;
   scope.upgradeDocument = nop;
   scope.upgradeDocumentTree = nop;
   scope.takeRecords = nop;
+  scope.reservedTagList = [];
 
 } else {
 
   /**
    * Registers a custom tag name with the document.
    *
    * When a registered element is created, a `readyCallback` method is called
    * in the scope of the element. The `readyCallback` method can be specified on
    * either `options.prototype` or `options.lifecycle` with the latter taking
    * precedence.
@@ skipping 36 matching lines @@
     if (!name) {
       // TODO(sjmiles): replace with more appropriate error (EricB can probably
       // offer guidance)
       throw new Error('document.registerElement: first argument `name` must not be empty');
     }
     if (name.indexOf('-') < 0) {
       // TODO(sjmiles): replace with more appropriate error (EricB can probably
       // offer guidance)
       throw new Error('document.registerElement: first argument (\'name\') must contain a dash (\'-\'). Argument provided was \'' + String(name) + '\'.');
     }
+    // prevent registering reserved names
+    if (isReservedTag(name)) {
+      throw new Error('Failed to execute \'registerElement\' on \'Document\': Registration failed for type \'' + String(name) + '\'. The type name is invalid.');
+    }
     // elements may only be registered once
     if (getRegisteredDefinition(name)) {
       throw new Error('DuplicateDefinitionError: a type with name \'' + String(name) + '\' is already registered');
     }
     // must have a prototype, default to an extension of HTMLElement
     // TODO(sjmiles): probably should throw if no prototype, check spec
     if (!definition.prototype) {
       // TODO(sjmiles): replace with more appropriate error (EricB can probably
       // offer guidance)
       throw new Error('Options missing required prototype property');
@@ skipping 23 matching lines @@
     // force our .constructor to be our actual constructor
     definition.prototype.constructor = definition.ctor;
     // if initial parsing is complete
     if (scope.ready) {
       // upgrade any pre-existing nodes of this type
       scope.upgradeDocumentTree(document);
     }
     return definition.ctor;
   }
 
+  function isReservedTag(name) {
+    for (var i = 0; i < reservedTagList.length; i++) {
+      if (name === reservedTagList[i]) {
+        return true;
+      }
+    }
+  }
+
+  var reservedTagList = [
+    'annotation-xml', 'color-profile', 'font-face', 'font-face-src',
+    'font-face-uri', 'font-face-format', 'font-face-name', 'missing-glyph'
+  ];
+
   function ancestry(extnds) {
     var extendee = getRegisteredDefinition(extnds);
     if (extendee) {
       return ancestry(extendee.extends).concat([extendee]);
     }
     return [];
   }
 
   function resolveTagName(definition) {
     // if we are explicitly extending something, that thing is our
@@ skipping 276 matching lines @@
     return false;
   }
 } else {
   isInstance = function(obj, base) {
     return obj instanceof base;
   }
 }
 
 // exports
 scope.instanceof = isInstance;
+scope.reservedTagList = reservedTagList;
 
 // bc
 document.register = document.registerElement;
 
 scope.hasNative = hasNative;
 scope.useNative = useNative;
 
 })(window.CustomElements);
 
 /*
@@ skipping 413 matching lines @@
   window.PointerEventsPolyfill = scope;
 })(window.PointerEventsPolyfill);
 
 /*
  * 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() {
   function shadowSelector(v) {
-    return 'body ^^ ' + selector(v);
+    return 'body /shadow-deep/ ' + selector(v);
   }
   function selector(v) {
     return '[touch-action="' + v + '"]';
   }
   function rule(v) {
     return '{ -ms-touch-action: ' + v + '; touch-action: ' + v + '; touch-action-delay: none; }';
   }
   var attrib2css = [
     'none',
     'auto',
     'pan-x',
     'pan-y',
     {
       rule: 'pan-x pan-y',
       selectors: [
         'pan-x pan-y',
         'pan-y pan-x'
       ]
     }
   ];
   var styles = '';
-  attrib2css.forEach(function(r) {
-    if (String(r) === r) {
-      styles += selector(r) + rule(r) + '\n';
-      styles += shadowSelector(r) + rule(r) + '\n';
-    } else {
-      styles += r.selectors.map(selector) + rule(r.rule) + '\n';
-      styles += r.selectors.map(shadowSelector) + rule(r.rule) + '\n';
-    }
-  });
-  var el = document.createElement('style');
-  el.textContent = styles;
-  document.head.appendChild(el);
+  // only install stylesheet if the browser has touch action support
+  var head = document.head;
+  var hasNativePE = window.PointerEvent || window.MSPointerEvent;
+  // only add shadow selectors if shadowdom is supported
+  var hasShadowRoot = !window.ShadowDOMPolyfill && document.head.createShadowRoot;
+
+  if (hasNativePE) {
+    attrib2css.forEach(function(r) {
+      if (String(r) === r) {
+        styles += selector(r) + rule(r) + '\n';
+        if (hasShadowRoot) {
+          styles += shadowSelector(r) + rule(r) + '\n';
+        }
+      } else {
+        styles += r.selectors.map(selector) + rule(r.rule) + '\n';
+        if (hasShadowRoot) {
+          styles += r.selectors.map(shadowSelector) + rule(r.rule) + '\n';
+        }
+      }
+    });
+
+    var el = document.createElement('style');
+    el.textContent = styles;
+    document.head.appendChild(el);
+  }
 })();
 
 /*
  * 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.
  */
 
 /**
  * This is the constructor for new PointerEvents.
  *
  * New Pointer Events must be given a type, and an optional dictionary of
  * initialization properties.
  *
  * Due to certain platform requirements, events returned from the constructor
  * identify as MouseEvents.
  *
  * @constructor
  * @param {String} inType The type of the event to create.
  * @param {Object} [inDict] An optional dictionary of initial event properties.
  * @return {Event} A new PointerEvent of type `inType` and initialized with properties from `inDict`.
  */
 (function(scope) {
-  // test for DOM Level 4 Events
-  var NEW_MOUSE_EVENT = false;
-  var HAS_BUTTONS = false;
-  try {
-    var ev = new MouseEvent('click', {buttons: 1});
-    NEW_MOUSE_EVENT = true;
-    HAS_BUTTONS = ev.buttons === 1;
-    ev = null;
-  } catch(e) {
-  }
 
   var MOUSE_PROPS = [
     'bubbles',
     'cancelable',
     'view',
     'detail',
     'screenX',
     'screenY',
     'clientX',
     'clientY',
     'ctrlKey',
     'altKey',
     'shiftKey',
     'metaKey',
     'button',
     'relatedTarget',
+    'pageX',
+    'pageY'
   ];
 
   var MOUSE_DEFAULTS = [
     false,
     false,
     null,
     null,
     0,
     0,
     0,
     0,
     false,
     false,
     false,
     false,
     0,
-    null
+    null,
+    0,
+    0
   ];
 
   function PointerEvent(inType, inDict) {
-    inDict = inDict || {};
-    // According to the w3c spec,
-    // http://www.w3.org/TR/DOM-Level-3-Events/#events-MouseEvent-button
-    // MouseEvent.button == 0 can mean either no mouse button depressed, or the
-    // left mouse button depressed.
-    //
-    // As of now, the only way to distinguish between the two states of
-    // MouseEvent.button is by using the deprecated MouseEvent.which property, as
-    // this maps mouse buttons to positive integers > 0, and uses 0 to mean that
-    // no mouse button is held.
-    //
-    // MouseEvent.which is derived from MouseEvent.button at MouseEvent creation,
-    // but initMouseEvent does not expose an argument with which to set
-    // MouseEvent.which. Calling initMouseEvent with a buttonArg of 0 will set
-    // MouseEvent.button == 0 and MouseEvent.which == 1, breaking the expectations
-    // of app developers.
-    //
-    // The only way to propagate the correct state of MouseEvent.which and
-    // MouseEvent.button to a new MouseEvent.button == 0 and MouseEvent.which == 0
-    // is to call initMouseEvent with a buttonArg value of -1.
-    //
-    // This is fixed with DOM Level 4's use of buttons
-    var buttons = inDict.buttons;
-    // touch has two possible buttons state: 0 and 1, rely on being told the right one
-    if (!HAS_BUTTONS && !buttons && inType !== 'touch') {
-      switch (inDict.which) {
-        case 1: buttons = 1; break;
-        case 2: buttons = 4; break;
-        case 3: buttons = 2; break;
-        default: buttons = 0;
-      }
+    inDict = inDict || Object.create(null);
+
+    var e = document.createEvent('Event');
+    e.initEvent(inType, inDict.bubbles || false, inDict.cancelable || false);
+
+    // define inherited MouseEvent properties
+    for(var i = 0, p; i < MOUSE_PROPS.length; i++) {
+      p = MOUSE_PROPS[i];
+      e[p] = inDict[p] || MOUSE_DEFAULTS[i];
     }
-
-    var e;
-    if (NEW_MOUSE_EVENT) {
-      e = new MouseEvent(inType, inDict);
-    } else {
-      e = document.createEvent('MouseEvent');
-
-      // import values from the given dictionary
-      var props = {}, p;
-      for(var i = 0; i < MOUSE_PROPS.length; i++) {
-        p = MOUSE_PROPS[i];
-        props[p] = inDict[p] || MOUSE_DEFAULTS[i];
-      }
-
-      // define the properties inherited from MouseEvent
-      e.initMouseEvent(
-        inType, props.bubbles, props.cancelable, props.view, props.detail,
-        props.screenX, props.screenY, props.clientX, props.clientY, props.ctrlKey,
-        props.altKey, props.shiftKey, props.metaKey, props.button, props.relatedTarget
-      );
-    }
-
-    // make the event pass instanceof checks
-    e.__proto__ = PointerEvent.prototype;
-
-    // define the buttons property according to DOM Level 3 spec
-    if (!HAS_BUTTONS) {
-      // IE 10 has buttons on MouseEvent.prototype as a getter w/o any setting
-      // mechanism
-      Object.defineProperty(e, 'buttons', {get: function(){ return buttons; }, enumerable: true});
-    }
+    e.buttons = inDict.buttons || 0;
 
     // Spec requires that pointers without pressure specified use 0.5 for down
     // state and 0 for up state.
     var pressure = 0;
     if (inDict.pressure) {
       pressure = inDict.pressure;
     } else {
-      pressure = buttons ? 0.5 : 0;
+      pressure = e.buttons ? 0.5 : 0;
     }
 
+    // add x/y properties aliased to clientX/Y
+    e.x = e.clientX;
+    e.y = e.clientY;
+
     // define the properties of the PointerEvent interface
-    Object.defineProperties(e, {
-      pointerId: { value: inDict.pointerId || 0, enumerable: true },
-      width: { value: inDict.width || 0, enumerable: true },
-      height: { value: inDict.height || 0, enumerable: true },
-      pressure: { value: pressure, enumerable: true },
-      tiltX: { value: inDict.tiltX || 0, enumerable: true },
-      tiltY: { value: inDict.tiltY || 0, enumerable: true },
-      pointerType: { value: inDict.pointerType || '', enumerable: true },
-      hwTimestamp: { value: inDict.hwTimestamp || 0, enumerable: true },
-      isPrimary: { value: inDict.isPrimary || false, enumerable: true }
-    });
+    e.pointerId = inDict.pointerId || 0;
+    e.width = inDict.width || 0;
+    e.height = inDict.height || 0;
+    e.pressure = pressure;
+    e.tiltX = inDict.tiltX || 0;
+    e.tiltY = inDict.tiltY || 0;
+    e.pointerType = inDict.pointerType || '';
+    e.hwTimestamp = inDict.hwTimestamp || 0;
+    e.isPrimary = inDict.isPrimary || false;
     return e;
   }
 
-  // PointerEvent extends MouseEvent
-  PointerEvent.prototype = Object.create(MouseEvent.prototype);
-
   // attach to window
   if (!scope.PointerEvent) {
     scope.PointerEvent = PointerEvent;
   }
 })(window);
 
 /*
  * 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.
@@ skipping 90 matching lines @@
     'pressure',
     'tiltX',
     'tiltY',
     'pointerType',
     'hwTimestamp',
     'isPrimary',
     // event instance
     'type',
     'target',
     'currentTarget',
-    'which'
+    'which',
+    'pageX',
+    'pageY'
   ];
 
   var CLONE_DEFAULTS = [
     // MouseEvent
     false,
     false,
     null,
     null,
     0,
     0,
@@ skipping 14 matching lines @@
     0,
     0,
     0,
     '',
     0,
     false,
     // event instance
     '',
     null,
     null,
+    0,
+    0,
     0
   ];
 
   var HAS_SVG_INSTANCE = (typeof SVGElementInstance !== 'undefined');
 
   /**
    * This module is for normalizing events. Mouse and Touch events will be
    * collected here, and fire PointerEvents that have the same semantics, no
    * matter the source.
    * Events fired:
    *   - pointerdown: a pointing is added
    *   - pointerup: a pointer is removed
    *   - pointermove: a pointer is moved
    *   - pointerover: a pointer crosses into an element
    *   - pointerout: a pointer leaves an element
    *   - pointercancel: a pointer will no longer generate events
    */
   var dispatcher = {
-    targets: new WeakMap(),
-    handledEvents: new WeakMap(),
     pointermap: new scope.PointerMap(),
-    eventMap: {},
+    eventMap: Object.create(null),
+    captureInfo: Object.create(null),
     // Scope objects for native events.
     // This exists for ease of testing.
-    eventSources: {},
+    eventSources: Object.create(null),
     eventSourceList: [],
     /**
      * Add a new event source that will generate pointer events.
      *
      * `inSource` must contain an array of event names named `events`, and
      * functions with the names specified in the `events` array.
      * @param {string} name A name for the event source
      * @param {Object} source A new source of platform events.
      */
     registerSource: function(name, source) {
@@ skipping 69 matching lines @@
       this.over(event);
       if (!this.contains(event.target, event.relatedTarget)) {
         this.enter(event);
       }
     },
     // LISTENER LOGIC
     eventHandler: function(inEvent) {
       // This is used to prevent multiple dispatch of pointerevents from
       // platform events. This can happen when two elements in different scopes
       // are set up to create pointer events, which is relevant to Shadow DOM.
-      if (this.handledEvents.get(inEvent)) {
+      if (inEvent._handledByPE) {
         return;
       }
       var type = inEvent.type;
       var fn = this.eventMap && this.eventMap[type];
       if (fn) {
         fn(inEvent);
       }
-      this.handledEvents.set(inEvent, true);
+      inEvent._handledByPE = true;
     },
     // set up event listeners
     listen: function(target, events) {
       events.forEach(function(e) {
         this.addEvent(target, e);
       }, this);
     },
     // remove event listeners
     unlisten: function(target, events) {
       events.forEach(function(e) {
@@ skipping 10 matching lines @@
     /**
      * Creates a new Event of type `inType`, based on the information in
      * `inEvent`.
      *
      * @param {string} inType A string representing the type of event to create
      * @param {Event} inEvent A platform event with a target
      * @return {Event} A PointerEvent of type `inType`
      */
     makeEvent: function(inType, inEvent) {
       // relatedTarget must be null if pointer is captured
-      if (this.captureInfo) {
+      if (this.captureInfo[inEvent.pointerId]) {
         inEvent.relatedTarget = null;
       }
       var e = new PointerEvent(inType, inEvent);
       if (inEvent.preventDefault) {
         e.preventDefault = inEvent.preventDefault;
       }
-      this.targets.set(e, this.targets.get(inEvent) || inEvent.target);
+      e._target = e._target || inEvent.target;
       return e;
     },
     // make and dispatch an event in one call
     fireEvent: function(inType, inEvent) {
       var e = this.makeEvent(inType, inEvent);
       return this.dispatchEvent(e);
     },
     /**
      * Returns a snapshot of inEvent, with writable properties.
      *
      * @param {Event} inEvent An event that contains properties to copy.
      * @return {Object} An object containing shallow copies of `inEvent`'s
      *    properties.
      */
     cloneEvent: function(inEvent) {
-      var eventCopy = {}, p;
+      var eventCopy = Object.create(null), p;
       for (var i = 0; i < CLONE_PROPS.length; i++) {
         p = CLONE_PROPS[i];
         eventCopy[p] = inEvent[p] || CLONE_DEFAULTS[i];
         // Work around SVGInstanceElement shadow tree
         // Return the <use> element that is represented by the instance for Safari, Chrome, IE.
         // This is the behavior implemented by Firefox.
         if (HAS_SVG_INSTANCE && (p === 'target' || p === 'relatedTarget')) {
           if (eventCopy[p] instanceof SVGElementInstance) {
             eventCopy[p] = eventCopy[p].correspondingUseElement;
           }
         }
       }
       // keep the semantics of preventDefault
       if (inEvent.preventDefault) {
         eventCopy.preventDefault = function() {
           inEvent.preventDefault();
         };
       }
       return eventCopy;
     },
     getTarget: function(inEvent) {
       // if pointer capture is set, route all events for the specified pointerId
       // to the capture target
-      if (this.captureInfo) {
-        if (this.captureInfo.id === inEvent.pointerId) {
-          return this.captureInfo.target;
-        }
-      }
-      return this.targets.get(inEvent);
+      return this.captureInfo[inEvent.pointerId] || inEvent._target;
     },
     setCapture: function(inPointerId, inTarget) {
-      if (this.captureInfo) {
-        this.releaseCapture(this.captureInfo.id);
+      if (this.captureInfo[inPointerId]) {
+        this.releaseCapture(inPointerId);
       }
-      this.captureInfo = {id: inPointerId, target: inTarget};
-      var e = new PointerEvent('gotpointercapture', { bubbles: true });
+      this.captureInfo[inPointerId] = inTarget;
+      var e = document.createEvent('Event');
+      e.initEvent('gotpointercapture', true, false);
+      e.pointerId = inPointerId;
       this.implicitRelease = this.releaseCapture.bind(this, inPointerId);
       document.addEventListener('pointerup', this.implicitRelease);
       document.addEventListener('pointercancel', this.implicitRelease);
-      this.targets.set(e, inTarget);
+      e._target = inTarget;
       this.asyncDispatchEvent(e);
     },
     releaseCapture: function(inPointerId) {
-      if (this.captureInfo && this.captureInfo.id === inPointerId) {
-        var e = new PointerEvent('lostpointercapture', { bubbles: true });
-        var t = this.captureInfo.target;
-        this.captureInfo = null;
+      var t = this.captureInfo[inPointerId];
+      if (t) {
+        var e = document.createEvent('Event');
+        e.initEvent('lostpointercapture', true, false);
+        e.pointerId = inPointerId;
+        this.captureInfo[inPointerId] = undefined;
         document.removeEventListener('pointerup', this.implicitRelease);
         document.removeEventListener('pointercancel', this.implicitRelease);
-        this.targets.set(e, t);
+        e._target = t;
         this.asyncDispatchEvent(e);
       }
     },
     /**
      * Dispatches the event to its target.
      *
      * @param {Event} inEvent The event to be dispatched.
      * @return {Boolean} True if an event handler returns true, false otherwise.
      */
     dispatchEvent: scope.external.dispatchEvent || function(inEvent) {
       var t = this.getTarget(inEvent);
       if (t) {
         return t.dispatchEvent(inEvent);
       }
     },
     asyncDispatchEvent: function(inEvent) {
-      setTimeout(this.dispatchEvent.bind(this, inEvent), 0);
+      requestAnimationFrame(this.dispatchEvent.bind(this, inEvent));
     }
   };
   dispatcher.boundHandler = dispatcher.eventHandler.bind(dispatcher);
   scope.dispatcher = dispatcher;
   scope.register = dispatcher.register.bind(dispatcher);
   scope.unregister = dispatcher.unregister.bind(dispatcher);
 })(window.PointerEventsPolyfill);
 
 /*
  * Copyright 2013 The Polymer Authors. All rights reserved.
@@ skipping 122 matching lines @@
  * Use of this source code is governed by a BSD-style
  * license that can be found in the LICENSE file.
  */
 
 (function (scope) {
   var dispatcher = scope.dispatcher;
   var pointermap = dispatcher.pointermap;
   // radius around touchend that swallows mouse events
   var DEDUP_DIST = 25;
 
+  var WHICH_TO_BUTTONS = [0, 1, 4, 2];
+
+  var HAS_BUTTONS = false;
+  try {
+    HAS_BUTTONS = new MouseEvent('test', {buttons: 1}).buttons === 1;
+  } catch (e) {}
+
   // handler block for native mouse events
   var mouseEvents = {
     POINTER_ID: 1,
     POINTER_TYPE: 'mouse',
     events: [
       'mousedown',
       'mousemove',
       'mouseup',
       'mouseover',
       'mouseout'
@@ skipping 21 matching lines @@
       var e = dispatcher.cloneEvent(inEvent);
       // forward mouse preventDefault
       var pd = e.preventDefault;
       e.preventDefault = function() {
         inEvent.preventDefault();
         pd();
       };
       e.pointerId = this.POINTER_ID;
       e.isPrimary = true;
       e.pointerType = this.POINTER_TYPE;
+      if (!HAS_BUTTONS) {
+        e.buttons = WHICH_TO_BUTTONS[e.which] || 0;
+      }
       return e;
     },
     mousedown: function(inEvent) {
       if (!this.isEventSimulatedFromTouch(inEvent)) {
         var p = pointermap.has(this.POINTER_ID);
         // TODO(dfreedman) workaround for some elements not sending mouseup
         // http://crbug/149091
         if (p) {
           this.cancel(inEvent);
         }
@@ skipping 44 matching lines @@
 })(window.PointerEventsPolyfill);
 
 /*
  * 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 dispatcher = scope.dispatcher;
+  var captureInfo = dispatcher.captureInfo;
   var findTarget = scope.findTarget;
   var allShadows = scope.targetFinding.allShadows.bind(scope.targetFinding);
   var pointermap = dispatcher.pointermap;
   var touchMap = Array.prototype.map.call.bind(Array.prototype.map);
   // This should be long enough to ignore compat mouse events made by touch
   var DEDUP_TIMEOUT = 2500;
   var CLICK_COUNT_TIMEOUT = 200;
   var ATTRIB = 'touch-action';
   var INSTALLER;
   // The presence of touch event handlers blocks scrolling, and so we must be careful to
   // avoid adding handlers unnecessarily.  Chrome plans to add a touch-action-delay property
   // (crbug.com/329559) to address this, and once we have that we can opt-in to a simpler
   // handler registration mechanism.  Rather than try to predict how exactly to opt-in to
   // that we'll just leave this disabled until there is a build of Chrome to test.
   var HAS_TOUCH_ACTION_DELAY = false;
   
   // handler block for native touch events
   var touchEvents = {
-    scrollType: new WeakMap(),
     events: [
       'touchstart',
       'touchmove',
       'touchend',
       'touchcancel'
     ],
     register: function(target) {
       if (HAS_TOUCH_ACTION_DELAY) {
         dispatcher.listen(target, this.events);
       } else {
         INSTALLER.enableOnSubtree(target);
       }
     },
     unregister: function(target) {
       if (HAS_TOUCH_ACTION_DELAY) {
         dispatcher.unlisten(target, this.events);
       } else {
         // TODO(dfreedman): is it worth it to disconnect the MO?
       }
     },
     elementAdded: function(el) {
       var a = el.getAttribute(ATTRIB);
       var st = this.touchActionToScrollType(a);
       if (st) {
-        this.scrollType.set(el, st);
+        el._scrollType = st;
         dispatcher.listen(el, this.events);
         // set touch-action on shadows as well
         allShadows(el).forEach(function(s) {
-          this.scrollType.set(s, st);
+          s._scrollType = st;
           dispatcher.listen(s, this.events);
         }, this);
       }
     },
     elementRemoved: function(el) {
-      this.scrollType['delete'](el);
+      el._scrollType = undefined;
       dispatcher.unlisten(el, this.events);
       // remove touch-action from shadow
       allShadows(el).forEach(function(s) {
-        this.scrollType['delete'](s);
+        s._scrollType = undefined;
         dispatcher.unlisten(s, this.events);
       }, this);
     },
     elementChanged: function(el, oldValue) {
       var a = el.getAttribute(ATTRIB);
       var st = this.touchActionToScrollType(a);
       var oldSt = this.touchActionToScrollType(oldValue);
       // simply update scrollType if listeners are already established
       if (st && oldSt) {
-        this.scrollType.set(el, st);
+        el._scrollType = st;
         allShadows(el).forEach(function(s) {
-          this.scrollType.set(s, st);
+          s._scrollType = st;
         }, this);
       } else if (oldSt) {
         this.elementRemoved(el);
       } else if (st) {
         this.elementAdded(el);
       }
     },
     scrollTypes: {
       EMITTER: 'none',
       XSCROLLER: 'pan-x',
@@ skipping 49 matching lines @@
       }
     },
     typeToButtons: function(type) {
       var ret = 0;
       if (type === 'touchstart' || type === 'touchmove') {
         ret = 1;
       }
       return ret;
     },
     touchToPointer: function(inTouch) {
+      var cte = this.currentTouchEvent;
       var e = dispatcher.cloneEvent(inTouch);
       // Spec specifies that pointerId 1 is reserved for Mouse.
       // Touch identifiers can start at 0.
       // Add 2 to the touch identifier for compatibility.
-      e.pointerId = inTouch.identifier + 2;
-      e.target = findTarget(e);
+      var id = e.pointerId = inTouch.identifier + 2;
+      e.target = captureInfo[id] || findTarget(e);
       e.bubbles = true;
       e.cancelable = true;
       e.detail = this.clickCount;
       e.button = 0;
-      e.buttons = this.typeToButtons(this.currentTouchEvent);
+      e.buttons = this.typeToButtons(cte.type);
       e.width = inTouch.webkitRadiusX || inTouch.radiusX || 0;
       e.height = inTouch.webkitRadiusY || inTouch.radiusY || 0;
       e.pressure = inTouch.webkitForce || inTouch.force || 0.5;
       e.isPrimary = this.isPrimaryTouch(inTouch);
       e.pointerType = this.POINTER_TYPE;
+      // forward touch preventDefaults
+      var self = this;
+      e.preventDefault = function() {
+        self.scrolling = false;
+        self.firstXY = null;
+        cte.preventDefault();
+      };
       return e;
     },
     processTouches: function(inEvent, inFunction) {
       var tl = inEvent.changedTouches;
-      this.currentTouchEvent = inEvent.type;
-      var pointers = touchMap(tl, this.touchToPointer, this);
-      // forward touch preventDefaults
-      pointers.forEach(function(p) {
-        p.preventDefault = function() {
-          this.scrolling = false;
-          this.firstXY = null;
-          inEvent.preventDefault();
-        };
-      }, this);
-      pointers.forEach(inFunction, this);
+      this.currentTouchEvent = inEvent;
+      for (var i = 0, t; i < tl.length; i++) {
+        t = tl[i];
+        inFunction.call(this, this.touchToPointer(t));
+      }
     },
     // For single axis scrollers, determines whether the element should emit
     // pointer events or behave as a scroller
     shouldScroll: function(inEvent) {
       if (this.firstXY) {
         var ret;
-        var scrollAxis = this.scrollType.get(inEvent.currentTarget);
+        var scrollAxis = inEvent.currentTarget._scrollType;
         if (scrollAxis === 'none') {
           // this element is a touch-action: none, should never scroll
           ret = false;
         } else if (scrollAxis === 'XY') {
           // this element should always scroll
           ret = true;
         } else {
           var t = inEvent.changedTouches[0];
           // check the intended scroll axis, and other axis
           var a = scrollAxis;
@@ skipping 26 matching lines @@
       // pointermap.pointers() should be < tl.length here, as the touchstart has not
       // been processed yet.
       if (pointermap.pointers() >= tl.length) {
         var d = [];
         pointermap.forEach(function(value, key) {
           // Never remove pointerId == 1, which is mouse.
           // Touch identifiers are 2 smaller than their pointerId, which is the
           // index in pointermap.
           if (key !== 1 && !this.findTouch(tl, key - 2)) {
             var p = value.out;
-            d.push(this.touchToPointer(p));
+            d.push(p);
           }
         }, this);
         d.forEach(this.cancelOut, this);
       }
     },
     touchstart: function(inEvent) {
       this.vacuumTouches(inEvent);
       this.setPrimaryTouch(inEvent.changedTouches[0]);
       this.dedupSynthMouse(inEvent);
       if (!this.scrolling) {
@@ skipping 195 matching lines @@
 
 /**
  * This module contains the handlers for native platform events.
  * From here, the dispatcher is called to create unified pointer events.
  * Included are touch events (v1), mouse events, and MSPointerEvents.
  */
 (function(scope) {
   var dispatcher = scope.dispatcher;
 
   // only activate if this platform does not have pointer events
-  if (window.navigator.pointerEnabled === undefined) {
-    Object.defineProperty(window.navigator, 'pointerEnabled', {value: true, enumerable: true});
+  if (window.PointerEvent !== scope.PointerEvent) {
 
     if (window.navigator.msPointerEnabled) {
       var tp = window.navigator.msMaxTouchPoints;
       Object.defineProperty(window.navigator, 'maxTouchPoints', {
         value: tp,
         enumerable: true
       });
       dispatcher.registerSource('ms', scope.msEvents);
     } else {
       dispatcher.registerSource('mouse', scope.mouseEvents);
@@ skipping 359 matching lines @@
       if (fns) {
         this.makeQueue(fns, inEvent);
       }
       this.handledEvents.set(inEvent, true);
     },
     // queue event for async dispatch
     makeQueue: function(inHandlerFns, inEvent) {
       // must clone events to keep the (possibly shadowed) target correct for
       // async dispatching
       var e = this.cloneEvent(inEvent);
-      setTimeout(this.runQueue.bind(this, inHandlerFns, e), 0);
+      requestAnimationFrame(this.runQueue.bind(this, inHandlerFns, e));
     },
     // Dispatch the queued events
     runQueue: function(inHandlers, inEvent) {
       this.currentPointerId = inEvent.pointerId;
       for (var i = 0, f, l = inHandlers.length; (i < l) && (f = inHandlers[i]); i++) {
         f(inEvent);
       }
       this.currentPointerId = 0;
     },
     // set up event listeners
@@ skipping 40 matching lines @@
     dispatchEvent: function(inEvent, inTarget) {
       var t = inTarget || this.targets.get(inEvent);
       if (t) {
         t.dispatchEvent(inEvent);
         if (inEvent.tapPrevented) {
           this.preventTap(this.currentPointerId);
         }
       }
     },
     asyncDispatchEvent: function(inEvent, inTarget) {
-      var fn = function() {
-        this.dispatchEvent(inEvent, inTarget);
-      }.bind(this);
-      setTimeout(fn, 0);
+      requestAnimationFrame(this.dispatchEvent.bind(this, inEvent, inTarget));
     },
     preventTap: function(inPointerId) {
       var t = this.recognizers.tap;
       if (t){
         t.preventTap(inPointerId);
       }
     }
   };
   dispatcher.boundHandler = dispatcher.eventHandler.bind(dispatcher);
   // recognizers call into the dispatcher and load later
@@ skipping 598 matching lines @@
       if (angle != this.reference.angle) {
         this.dispatchRotate(angle, points);
       }
     },
     calcChord: function() {
       var pointers = [];
       pointermap.forEach(function(p) {
         pointers.push(p);
       });
       var dist = 0;
-      var points = {};
+      // start with at least two pointers
+      var points = {a: pointers[0], b: pointers[1]};
       var x, y, d;
       for (var i = 0; i < pointers.length; i++) {
         var a = pointers[i];
         for (var j = i + 1; j < pointers.length; j++) {
           var b = pointers[j];
           x = Math.abs(a.clientX - b.clientX);
           y = Math.abs(a.clientY - b.clientY);
           d = x + y;
           if (d > dist) {
             dist = d;
@@ skipping 157 matching lines @@
     // register scopes after a steadystate is reached
     // less MutationObserver churn
     document.addEventListener('readystatechange', function() {
       if (document.readyState === 'complete') {
         registerScopes();
       }
     });
   }
 })(window.PointerGestures);
 
-// Copyright 2011 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the 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
 
 (function(global) {
   'use strict';
 
   var filter = Array.prototype.filter.call.bind(Array.prototype.filter);
 
   function getTreeScope(node) {
     while (node.parentNode) {
       node = node.parentNode;
     }
 
     return typeof node.getElementById === 'function' ? node : null;
   }
 
-
   Node.prototype.bind = function(name, observable) {
     console.error('Unhandled binding to Node: ', this, name, observable);
   };
 
-  function unbind(node, name) {
-    var bindings = node.bindings;
-    if (!bindings) {
-      node.bindings = {};
-      return;
-    }
+  function updateBindings(node, name, binding) {
+    var bindings = node.bindings_;
+    if (!bindings)
+      bindings = node.bindings_ = {};
 
-    var binding = bindings[name];
-    if (!binding)
-      return;
+    if (bindings[name])
+      binding[name].close();
 
-    binding.close();
-    bindings[name] = undefined;
+    return bindings[name] = binding;
   }
 
-  Node.prototype.unbind = function(name) {
-    unbind(this, name);
-  };
-
-  Node.prototype.unbindAll = function() {
-    if (!this.bindings)
-      return;
-    var names = Object.keys(this.bindings);
-    for (var i = 0; i < names.length; i++) {
-      var binding = this.bindings[names[i]];
-      if (binding)
-        binding.close();
-    }
-
-    this.bindings = {};
-  };
+  function returnBinding(node, name, binding) {
+    return binding;
+  }
 
   function sanitizeValue(value) {
     return value == null ? '' : value;
   }
 
   function updateText(node, value) {
     node.data = sanitizeValue(value);
   }
 
   function textBinding(node) {
     return function(value) {
       return updateText(node, value);
     };
   }
 
+  var maybeUpdateBindings = returnBinding;
+
+  Object.defineProperty(Platform, 'enableBindingsReflection', {
+    get: function() {
+      return maybeUpdateBindings === updateBindings;
+    },
+    set: function(enable) {
+      maybeUpdateBindings = enable ? updateBindings : returnBinding;
+      return enable;
+    },
+    configurable: true
+  });
+
   Text.prototype.bind = function(name, value, oneTime) {
     if (name !== 'textContent')
       return Node.prototype.bind.call(this, name, value, oneTime);
 
     if (oneTime)
       return updateText(this, value);
 
-    unbind(this, 'textContent');
-    updateText(this, value.open(textBinding(this)));
-    return this.bindings.textContent = value;
+    var observable = value;
+    updateText(this, observable.open(textBinding(this)));
+    return maybeUpdateBindings(this, name, observable);
   }
 
   function updateAttribute(el, name, conditional, value) {
     if (conditional) {
       if (value)
         el.setAttribute(name, '');
       else
         el.removeAttribute(name);
       return;
     }
@@ skipping 10 matching lines @@
   Element.prototype.bind = function(name, value, oneTime) {
     var conditional = name[name.length - 1] == '?';
     if (conditional) {
       this.removeAttribute(name);
       name = name.slice(0, -1);
     }
 
     if (oneTime)
       return updateAttribute(this, name, conditional, value);
 
-    unbind(this, name);
+
+    var observable = value;
     updateAttribute(this, name, conditional,
-        value.open(attributeBinding(this, name, conditional)));
+        observable.open(attributeBinding(this, name, conditional)));
 
-    return this.bindings[name] = value;
+    return maybeUpdateBindings(this, name, observable);
   };
 
   var checkboxEventType;
   (function() {
     // Attempt to feature-detect which event (change or click) is fired first
     // for checkboxes.
     var div = document.createElement('div');
     var checkbox = div.appendChild(document.createElement('input'));
     checkbox.setAttribute('type', 'checkbox');
     var first;
@@ skipping 48 matching lines @@
     var eventType = getEventForInputType(input);
 
     function eventHandler() {
       observable.setValue(input[property]);
       observable.discardChanges();
       (postEventFn || noop)(input);
       Platform.performMicrotaskCheckpoint();
     }
     input.addEventListener(eventType, eventHandler);
 
-    var capturedClose = observable.close;
-    observable.close = function() {
-      if (!capturedClose)
-        return;
-      input.removeEventListener(eventType, eventHandler);
+    return {
+      close: function() {
+        input.removeEventListener(eventType, eventHandler);
+        observable.close();
+      },
 
-      observable.close = capturedClose;
-      observable.close();
-      capturedClose = undefined;
+      observable_: observable
     }
   }
 
   function booleanSanitize(value) {
     return Boolean(value);
   }
 
   // |element| is assumed to be an HTMLInputElement with |type| == 'radio'.
   // Returns an array containing all radio buttons other than |element| that
   // have the same |name|, either in the form that |element| belongs to or,
@@ skipping 23 matching lines @@
     }
   }
 
   function checkedPostEvent(input) {
     // Only the radio button that is getting checked gets an event. We
     // therefore find all the associated radio buttons and update their
     // check binding manually.
     if (input.tagName === 'INPUT' &&
         input.type === 'radio') {
       getAssociatedRadioButtons(input).forEach(function(radio) {
-        var checkedBinding = radio.bindings.checked;
+        var checkedBinding = radio.bindings_.checked;
         if (checkedBinding) {
           // Set the value directly to avoid an infinite call stack.
-          checkedBinding.setValue(false);
+          checkedBinding.observable_.setValue(false);
         }
       });
     }
   }
 
   HTMLInputElement.prototype.bind = function(name, value, oneTime) {
     if (name !== 'value' && name !== 'checked')
       return HTMLElement.prototype.bind.call(this, name, value, oneTime);
 
-
     this.removeAttribute(name);
     var sanitizeFn = name == 'checked' ? booleanSanitize : sanitizeValue;
     var postEventFn = name == 'checked' ? checkedPostEvent : noop;
 
     if (oneTime)
       return updateInput(this, name, value, sanitizeFn);
 
-    unbind(this, name);
-    bindInputEvent(this, name, value, postEventFn);
+
+    var observable = value;
+    var binding = bindInputEvent(this, name, observable, postEventFn);
     updateInput(this, name,
-                value.open(inputBinding(this, name, sanitizeFn)),
+                observable.open(inputBinding(this, name, sanitizeFn)),
                 sanitizeFn);
 
-    return this.bindings[name] = value;
+    // Checkboxes may need to update bindings of other checkboxes.
+    return updateBindings(this, name, binding);
   }
 
   HTMLTextAreaElement.prototype.bind = function(name, value, oneTime) {
     if (name !== 'value')
       return HTMLElement.prototype.bind.call(this, name, value, oneTime);
 
     this.removeAttribute('value');
 
     if (oneTime)
       return updateInput(this, 'value', value);
 
-    unbind(this, 'value');
-    bindInputEvent(this, 'value', value);
+    var observable = value;
+    var binding = bindInputEvent(this, 'value', observable);
     updateInput(this, 'value',
-                value.open(inputBinding(this, 'value', sanitizeValue)));
-
-    return this.bindings.value = value;
+                observable.open(inputBinding(this, 'value', sanitizeValue)));
+    return maybeUpdateBindings(this, name, binding);
   }
 
   function updateOption(option, value) {
     var parentNode = option.parentNode;;
     var select;
     var selectBinding;
     var oldValue;
     if (parentNode instanceof HTMLSelectElement &&
-        parentNode.bindings &&
-        parentNode.bindings.value) {
+        parentNode.bindings_ &&
+        parentNode.bindings_.value) {
       select = parentNode;
-      selectBinding = select.bindings.value;
+      selectBinding = select.bindings_.value;
       oldValue = select.value;
     }
 
     option.value = sanitizeValue(value);
 
     if (select && select.value != oldValue) {
-      selectBinding.setValue(select.value);
-      selectBinding.discardChanges();
+      selectBinding.observable_.setValue(select.value);
+      selectBinding.observable_.discardChanges();
       Platform.performMicrotaskCheckpoint();
     }
   }
 
   function optionBinding(option) {
     return function(value) {
       updateOption(option, value);
     }
   }
 
   HTMLOptionElement.prototype.bind = function(name, value, oneTime) {
     if (name !== 'value')
       return HTMLElement.prototype.bind.call(this, name, value, oneTime);
 
     this.removeAttribute('value');
 
     if (oneTime)
       return updateOption(this, value);
 
-    unbind(this, 'value');
-    bindInputEvent(this, 'value', value);
-    updateOption(this, value.open(optionBinding(this)));
-    return this.bindings.value = value;
+    var observable = value;
+    var binding = bindInputEvent(this, 'value', observable);
+    updateOption(this, observable.open(optionBinding(this)));
+    return maybeUpdateBindings(this, name, binding);
   }
 
   HTMLSelectElement.prototype.bind = function(name, value, oneTime) {
     if (name === 'selectedindex')
       name = 'selectedIndex';
 
     if (name !== 'selectedIndex' && name !== 'value')
       return HTMLElement.prototype.bind.call(this, name, value, oneTime);
 
     this.removeAttribute(name);
 
     if (oneTime)
       return updateInput(this, name, value);
 
-    unbind(this, name);
-    bindInputEvent(this, name, value);
+    var observable = value;
+    var binding = bindInputEvent(this, name, observable);
     updateInput(this, name,
-                value.open(inputBinding(this, name)));
-    return this.bindings[name] = value;
+                observable.open(inputBinding(this, name)));
+
+    // Option update events may need to access select bindings.
+    return updateBindings(this, name, binding);
   }
 })(this);
 
-// Copyright 2011 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the 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
 
 (function(global) {
   'use strict';
 
   function assert(v) {
     if (!v)
       throw new Error('Assertion failed');
   }
 
   var forEach = Array.prototype.forEach.call.bind(Array.prototype.forEach);
@@ skipping 444 matching lines @@
       var ref = oneTime ? value : value.open(function(ref) {
         self.setAttribute('ref', ref);
         self.refChanged_();
       });
 
       this.setAttribute('ref', ref);
       this.refChanged_();
       if (oneTime)
         return;
 
-      this.unbind('ref');
-      return this.bindings.ref = value;
+      if (!this.bindings_) {
+        this.bindings_ = { ref: value };
+      } else {
+        this.bindings_.ref = value;
+      }
+
+      return value;
     },
 
     processBindingDirectives_: function(directives) {
       if (this.iterator_)
         this.iterator_.closeDeps();
 
       if (!directives.if && !directives.bind && !directives.repeat) {
         if (this.iterator_) {
           this.iterator_.close();
           this.iterator_ = undefined;
-          this.bindings.iterator = undefined;
         }
 
         return;
       }
 
       if (!this.iterator_) {
         this.iterator_ = new TemplateIterator(this);
-        this.bindings = this.bindings || {};
-        this.bindings.iterator = this.iterator_;
       }
 
       this.iterator_.updateDependencies(directives, this.model_);
 
       if (templateObserver) {
         templateObserver.observe(this, { attributes: true,
                                          attributeFilter: ['ref'] });
       }
 
       return this.iterator_;
     },
 
-    createInstance: function(model, bindingDelegate, delegate_,
-                             instanceBindings_) {
+    createInstance: function(model, bindingDelegate, delegate_) {
       if (bindingDelegate)
         delegate_ = this.newDelegate_(bindingDelegate);
 
       if (!this.refContent_)
         this.refContent_ = this.ref_.content;
       var content = this.refContent_;
+      if (content.firstChild === null)
+        return emptyInstance;
+
       var map = this.bindingMap_;
       if (!map || map.content !== content) {
         // TODO(rafaelw): Setup a MutationObserver on content to detect
         // when the instanceMap is invalid.
         map = createInstanceBindingMap(content,
             delegate_ && delegate_.prepareBinding) || [];
         map.content = content;
         this.bindingMap_ = map;
       }
 
       var stagingDocument = getTemplateStagingDocument(this);
       var instance = stagingDocument.createDocumentFragment();
       instance.templateCreator_ = this;
       instance.protoContent_ = content;
-
-      var instanceRecord = {
+      instance.bindings_ = [];
+      instance.terminator_ = null;
+      var instanceRecord = instance.templateInstance_ = {
         firstNode: null,
         lastNode: null,
         model: model
       };
 
       var i = 0;
+      var collectTerminator = false;
       for (var child = content.firstChild; child; child = child.nextSibling) {
+        // The terminator of the instance is the clone of the last child of the
+        // content. If the last child is an active template, it may produce
+        // instances as a result of production, so simply collecting the last
+        // child of the instance after it has finished producing may be wrong.
+        if (child.nextSibling === null)
+          collectTerminator = true;
+
         var clone = cloneAndBindInstance(child, instance, stagingDocument,
                                          map.children[i++],
                                          model,
                                          delegate_,
-                                         instanceBindings_);
+                                         instance.bindings_);
         clone.templateInstance_ = instanceRecord;
+        if (collectTerminator)
+          instance.terminator_ = clone;
       }
 
       instanceRecord.firstNode = instance.firstChild;
       instanceRecord.lastNode = instance.lastChild;
       instance.templateCreator_ = undefined;
       instance.protoContent_ = undefined;
       return instance;
     },
 
     get model() {
@@ skipping 14 matching lines @@
         return;
 
       this.refContent_ = undefined;
       this.iterator_.valueChanged();
       this.iterator_.updateIteratedValue();
     },
 
     clear: function() {
       this.model_ = undefined;
       this.delegate_ = undefined;
-      this.bindings_ = undefined;
+      if (this.bindings_ && this.bindings_.ref)
+        this.bindings_.ref.close()
       this.refContent_ = undefined;
       if (!this.iterator_)
         return;
       this.iterator_.valueChanged();
       this.iterator_.close()
       this.iterator_ = undefined;
     },
 
     setDelegate_: function(delegate) {
       this.delegate_ = delegate;
@@ skipping 84 matching lines @@
 
         tokens.push(s.slice(lastIndex)); // TEXT
         break;
       }
 
       tokens = tokens || [];
       tokens.push(s.slice(lastIndex, startIndex)); // TEXT
       var pathString = s.slice(startIndex + 2, endIndex).trim();
       tokens.push(oneTime); // ONE_TIME?
       onlyOneTime = onlyOneTime && oneTime;
-      tokens.push(Path.get(pathString)); // PATH
       var delegateFn = prepareBindingFn &&
                        prepareBindingFn(pathString, name, node);
+      // Don't try to parse the expression if there's a prepareBinding function
+      if (delegateFn == null) {
+        tokens.push(Path.get(pathString)); // PATH
+      } else {
+        tokens.push(null);
+      }
       tokens.push(delegateFn); // DELEGATE_FN
       lastIndex = endIndex + 2;
     }
 
     if (lastIndex === length)
       tokens.push(''); // TEXT
 
     tokens.hasOnePath = tokens.length === 5;
     tokens.isSimplePath = tokens.hasOnePath &&
                           tokens[0] == '' &&
@@ skipping 197 matching lines @@
   }
 
   Object.defineProperty(Node.prototype, 'templateInstance', {
     get: function() {
       var instance = this.templateInstance_;
       return instance ? instance :
           (this.parentNode ? this.parentNode.templateInstance : undefined);
     }
   });
 
+  var emptyInstance = document.createDocumentFragment();
+  emptyInstance.bindings_ = [];
+  emptyInstance.terminator_ = null;
+
   function TemplateIterator(templateElement) {
     this.closed = false;
     this.templateElement_ = templateElement;
-
-    // Flattened array of tuples:
-    //   <instanceTerminatorNode, [bindingsSetupByInstance]>
-    this.terminators = [];
-
+    this.instances = [];
     this.deps = undefined;
     this.iteratedValue = [];
     this.presentValue = undefined;
     this.arrayObserver = undefined;
   }
 
   TemplateIterator.prototype = {
     closeDeps: function() {
       var deps = this.deps;
       if (deps) {
@@ skipping 74 matching lines @@
       this.presentValue = value;
       if (observeValue) {
         this.arrayObserver = new ArrayObserver(this.presentValue);
         this.arrayObserver.open(this.handleSplices, this);
       }
 
       this.handleSplices(ArrayObserver.calculateSplices(this.presentValue,
                                                         this.iteratedValue));
     },
 
-    getTerminatorAt: function(index) {
+    getLastInstanceNode: function(index) {
       if (index == -1)
         return this.templateElement_;
-      var terminator = this.terminators[index*2];
+      var instance = this.instances[index];
+      var terminator = instance.terminator_;
+      if (!terminator)
+        return this.getLastInstanceNode(index - 1);
+
       if (terminator.nodeType !== Node.ELEMENT_NODE ||
           this.templateElement_ === terminator) {
         return terminator;
       }
 
-      var subIterator = terminator.iterator_;
-      if (!subIterator)
+      var subtemplateIterator = terminator.iterator_;
+      if (!subtemplateIterator)
         return terminator;
 
-      return subIterator.getTerminatorAt(subIterator.terminators.length/2 - 1);
+      return subtemplateIterator.getLastTemplateNode();
     },
 
-    // TODO(rafaelw): If we inserting sequences of instances we can probably
-    // avoid lots of calls to getTerminatorAt(), or cache its result.
-    insertInstanceAt: function(index, fragment, instanceNodes,
-                               instanceBindings) {
-      var previousTerminator = this.getTerminatorAt(index - 1);
-      var terminator = previousTerminator;
-      if (fragment)
-        terminator = fragment.lastChild || terminator;
-      else if (instanceNodes)
-        terminator = instanceNodes[instanceNodes.length - 1] || terminator;
+    getLastTemplateNode: function() {
+      return this.getLastInstanceNode(this.instances.length - 1);
+    },
 
-      this.terminators.splice(index*2, 0, terminator, instanceBindings);
+    insertInstanceAt: function(index, fragment) {
+      var previousInstanceLast = this.getLastInstanceNode(index - 1);
       var parent = this.templateElement_.parentNode;
-      var insertBeforeNode = previousTerminator.nextSibling;
+      this.instances.splice(index, 0, fragment);
 
-      if (fragment) {
-        parent.insertBefore(fragment, insertBeforeNode);
-      } else if (instanceNodes) {
-        for (var i = 0; i < instanceNodes.length; i++)
-          parent.insertBefore(instanceNodes[i], insertBeforeNode);
-      }
+      parent.insertBefore(fragment, previousInstanceLast.nextSibling);
     },
 
     extractInstanceAt: function(index) {
-      var instanceNodes = [];
-      var previousTerminator = this.getTerminatorAt(index - 1);
-      var terminator = this.getTerminatorAt(index);
-      instanceNodes.instanceBindings = this.terminators[index*2 + 1];
-      this.terminators.splice(index*2, 2);
+      var previousInstanceLast = this.getLastInstanceNode(index - 1);
+      var lastNode = this.getLastInstanceNode(index);
+      var parent = this.templateElement_.parentNode;
+      var instance = this.instances.splice(index, 1)[0];
 
-      var parent = this.templateElement_.parentNode;
-      while (terminator !== previousTerminator) {
-        var node = previousTerminator.nextSibling;
-        if (node == terminator)
-          terminator = previousTerminator;
+      while (lastNode !== previousInstanceLast) {
+        var node = previousInstanceLast.nextSibling;
+        if (node == lastNode)
+          lastNode = previousInstanceLast;
 
-        parent.removeChild(node);
-        instanceNodes.push(node);
+        instance.appendChild(parent.removeChild(node));
       }
 
-      return instanceNodes;
+      return instance;
     },
 
     getDelegateFn: function(fn) {
       fn = fn && fn(this.templateElement_);
       return typeof fn === 'function' ? fn : null;
     },
 
     handleSplices: function(splices) {
       if (this.closed || !splices.length)
         return;
@@ skipping 13 matching lines @@
         this.instanceModelFn_ =
             this.getDelegateFn(delegate && delegate.prepareInstanceModel);
       }
 
       if (this.instancePositionChangedFn_ === undefined) {
         this.instancePositionChangedFn_ =
             this.getDelegateFn(delegate &&
                                delegate.prepareInstancePositionChanged);
       }
 
+      // Instance Removals
       var instanceCache = new Map;
       var removeDelta = 0;
-      splices.forEach(function(splice) {
-        splice.removed.forEach(function(model) {
-          var instanceNodes =
-              this.extractInstanceAt(splice.index + removeDelta);
-          instanceCache.set(model, instanceNodes);
-        }, this);
+      for (var i = 0; i < splices.length; i++) {
+        var splice = splices[i];
+        var removed = splice.removed;
+        for (var j = 0; j < removed.length; j++) {
+          var model = removed[j];
+          var instance = this.extractInstanceAt(splice.index + removeDelta);
+          if (instance !== emptyInstance) {
+            instanceCache.set(model, instance);
+          }
+        }
 
         removeDelta -= splice.addedCount;
-      }, this);
+      }
 
-      splices.forEach(function(splice) {
+      // Instance Insertions
+      for (var i = 0; i < splices.length; i++) {
+        var splice = splices[i];
         var addIndex = splice.index;
         for (; addIndex < splice.index + splice.addedCount; addIndex++) {
           var model = this.iteratedValue[addIndex];
-          var fragment = undefined;
-          var instanceNodes = instanceCache.get(model);
-          var instanceBindings;
-          if (instanceNodes) {
+          var instance = instanceCache.get(model);
+          if (instance) {
             instanceCache.delete(model);
-            instanceBindings = instanceNodes.instanceBindings;
           } else {
-            instanceBindings = [];
-            if (this.instanceModelFn_)
+            if (this.instanceModelFn_) {
               model = this.instanceModelFn_(model);
+            }
 
-            if (model !== undefined) {
-              fragment = template.createInstance(model, undefined, delegate,
-                                                 instanceBindings);
+            if (model === undefined) {
+              instance = emptyInstance;
+            } else {
+              instance = template.createInstance(model, undefined, delegate);
             }
           }
 
-          this.insertInstanceAt(addIndex, fragment, instanceNodes,
-                                instanceBindings);
+          this.insertInstanceAt(addIndex, instance);
         }
-      }, this);
+      }
 
-      instanceCache.forEach(function(instanceNodes) {
-        this.closeInstanceBindings(instanceNodes.instanceBindings);
+      instanceCache.forEach(function(instance) {
+        this.closeInstanceBindings(instance);
       }, this);
 
       if (this.instancePositionChangedFn_)
         this.reportInstancesMoved(splices);
     },
 
     reportInstanceMoved: function(index) {
-      var previousTerminator = this.getTerminatorAt(index - 1);
-      var terminator = this.getTerminatorAt(index);
-      if (previousTerminator === terminator)
-        return; // instance has zero nodes.
+      var instance = this.instances[index];
+      if (instance === emptyInstance)
+        return;
 
-      // We must use the first node of the instance, because any subsequent
-      // nodes may have been generated by sub-templates.
-      // TODO(rafaelw): This is brittle WRT instance mutation -- e.g. if the
-      // first node was removed by script.
-      var templateInstance = previousTerminator.nextSibling.templateInstance;
-      this.instancePositionChangedFn_(templateInstance, index);
+      this.instancePositionChangedFn_(instance.templateInstance_, index);
     },
 
     reportInstancesMoved: function(splices) {
       var index = 0;
       var offset = 0;
       for (var i = 0; i < splices.length; i++) {
         var splice = splices[i];
         if (offset != 0) {
           while (index < splice.index) {
             this.reportInstanceMoved(index);
             index++;
           }
         } else {
           index = splice.index;
         }
 
         while (index < splice.index + splice.addedCount) {
           this.reportInstanceMoved(index);
           index++;
         }
 
         offset += splice.addedCount - splice.removed.length;
       }
 
       if (offset == 0)
         return;
 
-      var length = this.terminators.length / 2;
+      var length = this.instances.length;
       while (index < length) {
         this.reportInstanceMoved(index);
         index++;
       }
     },
 
-    closeInstanceBindings: function(instanceBindings) {
-      for (var i = 0; i < instanceBindings.length; i++) {
-        instanceBindings[i].close();
+    closeInstanceBindings: function(instance) {
+      var bindings = instance.bindings_;
+      for (var i = 0; i < bindings.length; i++) {
+        bindings[i].close();
       }
     },
 
     unobserve: function() {
       if (!this.arrayObserver)
         return;
 
       this.arrayObserver.close();
       this.arrayObserver = undefined;
     },
 
     close: function() {
       if (this.closed)
         return;
       this.unobserve();
-      for (var i = 1; i < this.terminators.length; i += 2) {
-        this.closeInstanceBindings(this.terminators[i]);
+      for (var i = 0; i < this.instances.length; i++) {
+        this.closeInstanceBindings(this.instances[i]);
       }
 
-      this.terminators.length = 0;
+      this.instances.length = 0;
       this.closeDeps();
       this.templateElement_.iterator_ = undefined;
       this.closed = true;
     }
   };
 
   // Polyfill-specific API.
   HTMLTemplateElement.forAllTemplatesFrom_ = forAllTemplatesFrom;
 })(this);
 
@@ skipping 1028 matching lines @@
         };
 
         return parseTopLevel();
     }
 
     global.esprima = {
         parse: parse
     };
 })(this);
 
-// Copyright 2013 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the 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
 
 (function (global) {
   'use strict';
 
   // JScript does not have __proto__. We wrap all object literals with
   // createObject which uses Object.create, Object.defineProperty and
   // Object.getOwnPropertyDescriptor to create a new object that does the exact
   // same thing. The main downside to this solution is that we have to extract
   // all those property descriptors for IE.
   var createObject = ('__proto__' in {}) ?
@@ skipping 406 matching lines @@
     this.filters = delegate.filters;
     this.dynamicDeps = delegate.dynamicDeps;
   }
 
   Expression.prototype = {
     getBinding: function(model, filterRegistry, oneTime) {
       if (oneTime)
         return this.getValue(model, undefined, filterRegistry);
 
       var observer = new CompoundObserver();
-      this.getValue(model, observer, filterRegistry);  // captures deps.
+      // captures deps.
+      var firstValue = this.getValue(model, observer, filterRegistry);
+      var firstTime = true;
       var self = this;
 
       function valueFn() {
+        // deps cannot have changed on first value retrieval.
+        if (firstTime) {
+          firstTime = false;
+          return firstValue;
+        }
+
         if (self.dynamicDeps)
           observer.startReset();
 
         var value = self.getValue(model,
                                   self.dynamicDeps ? observer : undefined,
                                   filterRegistry);
         if (self.dynamicDeps)
           observer.finishReset();
 
         return value;
@@ skipping 123 matching lines @@
       return {
         open: bindingValue,
         discardChanges: bindingValue,
         close: function() {
           node.removeEventListener(eventType, handler);
         }
       };
     }
   }
 
+  function isLiteralExpression(pathString) {
+    switch (pathString) {
+      case '':
+        return false;
+
+      case 'false':
+      case 'null':
+      case 'true':
+        return true;
+    }
+
+    if (!isNaN(Number(pathString)))
+      return true;
+
+    return false;
+  };
+
   function PolymerExpressions() {}
 
   PolymerExpressions.prototype = {
     // "built-in" filters
     styleObject: function(value) {
       var parts = [];
       for (var key in value) {
         parts.push(convertStylePropertyName(key) + ': ' + value[key]);
       }
       return parts.join('; ');
@@ skipping 23 matching lines @@
       var path = Path.get(pathString);
       if (isEventHandler(name)) {
         if (!path.valid) {
           console.error('on-* bindings must be simple path expressions');
           return;
         }
 
         return prepareEventBinding(path, name, this);
       }
 
-      if (path.valid) {
+      if (!isLiteralExpression(pathString) && path.valid) {
         if (path.length == 1) {
           return function(model, node, oneTime) {
             if (oneTime)
               return path.getValueFrom(model);
 
             var scope = findScope(model, path[0]);
             return new PathObserver(scope, path);
-          }
+          };
         }
-
         return; // bail out early if pathString is simple path.
       }
 
       return prepareBinding(pathString, name, node, this);
     },
 
     prepareInstanceModel: function(template) {
       var scopeName = template.polymerExpressionScopeIdent_;
       if (!scopeName)
         return;
@@ skipping 42 matching lines @@
     scope.endOfMicrotask(function() {
       flushing = false;
       logFlags.data && console.group('Platform.flush()');
       scope.performMicrotaskCheckpoint();
       logFlags.data && console.groupEnd();
     });
   }
 };
 
 // polling dirty checker
-var FLUSH_POLL_INTERVAL = 125;
-window.addEventListener('WebComponentsReady', function() {
-  flush();
-  // flush periodically if platform does not have object observe.
-  if (!Observer.hasObjectObserve) {
+// flush periodically if platform does not have object observe.
+if (!Observer.hasObjectObserve) {
+  var FLUSH_POLL_INTERVAL = 125;
+  window.addEventListener('WebComponentsReady', function() {
+    flush();
     scope.flushPoll = setInterval(flush, FLUSH_POLL_INTERVAL);
-  }
-});
+  });
+} else {
+  // make flush a no-op when we have Object.observe
+  flush = function() {};
+}
 
 if (window.CustomElements && !CustomElements.useNative) {
   var originalImportNode = Document.prototype.importNode;
   Document.prototype.importNode = function(node, deep) {
     var imported = originalImportNode.call(this, node, deep);
     CustomElements.upgradeAll(imported);
     return imported;
   }
 }
 
 // exports
 scope.flush = flush;
 
 })(window.Platform);
 
 
 //# sourceMappingURL=platform.concat.js.map