{"version":3,"file":"polymer.js","sources":["../../polymer-gestures/src/scope.js","../../polymer-gestures/src/targetfind.js","../../polymer-gestures/src/touch-action.js","../../polymer-gestures/src/eventFactory.js","../../polymer-gestures/src/pointermap.js","../../polymer-gestures/src/dispatcher.js","../../polymer-gestures/src/installer.js","../../polymer-gestures/src/mouse.js","../../polymer-gestures/src/touch.js","../../polymer-gestures/src/ms.js","../../polymer-gestures/src/pointer.js","../../polymer-gestures/src/platform-events.js","../../polymer-gestures/src/track.js","../../polymer-gestures/src/hold.js","../../polymer-gestures/src/tap.js","../../polymer-expressions/third_party/esprima/esprima.js","../../polymer-expressions/src/polymer-expressions.js","polymer-versioned.js","../src/boot.js","../src/lib/lang.js","../src/lib/job.js","../src/lib/dom.js","../src/lib/super.js","../src/lib/deserialize.js","../src/api.js","../src/instance/utils.js","../src/instance/events.js","../src/instance/attributes.js","../src/instance/properties.js","../src/instance/mdv.js","../src/instance/base.js","../src/instance/styles.js","../src/declaration/polymer.js","../src/declaration/path.js","../src/declaration/styles.js","../src/declaration/events.js","../src/declaration/properties.js","../src/declaration/attributes.js","../src/declaration/mdv.js","../src/declaration/prototype.js","../src/declaration/queue.js","../src/declaration/import.js","../src/declaration/polymer-element.js","../src/lib/auto-binding.js"],"names":["window","PolymerGestures","hasSDPolyfill","Boolean","ShadowDOMPolyfill","wrap","wrapIfNeeded","a","scope","HAS_FULL_PATH","pathTest","document","createElement","createShadowRoot","sr","s","appendChild","addEventListener","ev","path","stopPropagation","CustomEvent","bubbles","head","dispatchEvent","parentNode","removeChild","target","shadow","inEl","shadowRoot","webkitShadowRoot","canTarget","elementFromPoint","targetingShadow","this","olderShadow","os","olderShadowRoot","se","querySelector","allShadows","element","shadows","push","searchRoot","inRoot","x","y","t","owner","nodeType","Node","DOCUMENT_NODE","DOCUMENT_FRAGMENT_NODE","findTarget","inEvent","clientX","clientY","LCA","b","contains","adepth","depth","bdepth","d","walk","host","n","u","i","deepContains","common","insideNode","node","rect","getBoundingClientRect","left","right","top","bottom","targetFinding","bind","shadowSelector","v","selector","rule","attrib2css","selectors","styles","hasTouchAction","style","touchAction","hasShadowRoot","forEach","r","String","map","el","textContent","MOUSE_PROPS","MOUSE_DEFAULTS","NOP_FACTORY","eventFactory","preventTap","makeBaseEvent","inType","inDict","e","createEvent","initEvent","cancelable","makeGestureEvent","Object","create","k","keys","length","makePointerEvent","p","buttons","pressure","pointerId","width","height","tiltX","tiltY","pointerType","hwTimestamp","isPrimary","_source","PointerMap","USE_MAP","m","Map","pointers","POINTERS_FN","values","prototype","size","set","inId","indexOf","has","delete","splice","get","clear","callback","thisArg","call","CLONE_PROPS","CLONE_DEFAULTS","HAS_SVG_INSTANCE","SVGElementInstance","dispatcher","pointermap","eventMap","eventSources","eventSourceList","gestures","gestureQueue","registerSource","name","source","newEvents","events","registerGesture","register","es","l","unregister","down","fireEvent","move","type","fillGestureQueue","up","cancel","tapPrevented","eventHandler","_handledByPG","fn","listen","addEvent","unlisten","removeEvent","eventName","addEventListener_","boundHandler","removeEventListener_","removeEventListener","makeEvent","preventDefault","_target","cloneEvent","eventCopy","correspondingUseElement","clone","gestureTrigger","g","j","requestAnimationFrame","boundGestureTrigger","root","Installer","add","remove","changed","binder","addCallback","removeCallback","changedCallback","MO","observer","mutationWatcher","Array","toArray","slice","filter","MutationObserver","WebKitMutationObserver","SELECTOR","OBSERVER_INIT","subtree","childList","attributes","attributeOldValue","attributeFilter","watchSubtree","observe","enableOnSubtree","readyState","installOnLoad","installNewSubtree","findElements","addElement","querySelectorAll","removeElement","elementChanged","oldValue","concatLists","accum","list","concat","isElement","ELEMENT_NODE","flattenMutationTree","inNodes","tree","reduce","mutations","mutationHandler","added","addedNodes","removed","removedNodes","console","warn","DEDUP_DIST","WHICH_TO_BUTTONS","HAS_BUTTONS","MouseEvent","mouseEvents","POINTER_ID","POINTER_TYPE","lastTouches","isEventSimulatedFromTouch","lts","dx","Math","abs","dy","prepareEvent","which","mousedown","mouseup","mousemove","relatedTarget","cleanupMouse","INSTALLER","DEDUP_TIMEOUT","CLICK_COUNT_TIMEOUT","HYSTERESIS","ATTRIB","CAN_USE_GLOBAL","touchEvents","elementAdded","getAttribute","st","touchActionToScrollType","_scrollType","elementRemoved","undefined","oldSt","scrollTypes","EMITTER","XSCROLLER","YSCROLLER","SCROLLER","exec","firstTouch","isPrimaryTouch","inTouch","identifier","setPrimaryTouch","firstXY","X","Y","scrolling","cancelResetClickCount","removePrimaryPointer","inPointer","resetClickCount","clickCount","resetId","setTimeout","clearTimeout","typeToButtons","ret","touch","id","currentTouchEvent","fastPath","touchToPointer","cte","detail","webkitRadiusX","radiusX","webkitRadiusY","radiusY","webkitForce","force","self","processTouches","inFunction","tl","changedTouches","cleanUpPointer","shouldScroll","scrollAxis","currentTarget","oa","da","doa","findTouch","inTL","vacuumTouches","touches","value","key","touchstart","dedupSynthMouse","touchmove","dd","sqrt","touchcancel","touchend","lt","HAS_BITMAP_TYPE","MSPointerEvent","MSPOINTER_TYPE_MOUSE","msEvents","POINTER_TYPES","cleanup","MSPointerDown","MSPointerMove","MSPointerUp","MSPointerCancel","pointerEvents","pointerdown","pointermove","pointerup","pointercancel","PointerEvent","navigator","msPointerEnabled","ontouchstart","track","WIGGLE_THRESHOLD","clampDir","inDelta","calcPositionDelta","inA","inB","pageX","pageY","fireTrack","inTrackingData","downEvent","lastMoveEvent","xDirection","yDirection","ddx","ddy","screenX","screenY","trackInfo","downTarget","tracking","hold","HOLD_DELAY","heldPointer","holdJob","pulse","Date","now","timeStamp","held","fireHold","clearInterval","setInterval","inHoldTime","holdTime","tap","shouldTap","downState","start","altKey","ctrlKey","metaKey","shiftKey","global","assert","condition","message","Error","isDecimalDigit","ch","isWhiteSpace","fromCharCode","isLineTerminator","isIdentifierStart","isIdentifierPart","isKeyword","skipWhitespace","index","charCodeAt","getIdentifier","scanIdentifier","Token","Identifier","Keyword","NullLiteral","BooleanLiteral","range","scanPunctuator","code2","ch2","code","ch1","Punctuator","throwError","Messages","UnexpectedToken","scanNumericLiteral","number","NumericLiteral","parseFloat","scanStringLiteral","quote","str","octal","StringLiteral","isIdentifierName","token","advance","EOF","lex","lookahead","peek","pos","messageFormat","error","args","arguments","msg","replace","whole","description","throwUnexpected","expect","match","matchKeyword","keyword","parseArrayInitialiser","elements","parseExpression","delegate","createArrayExpression","parseObjectPropertyKey","createLiteral","createIdentifier","parseObjectProperty","createProperty","parseObjectInitialiser","properties","createObjectExpression","parseGroupExpression","expr","parsePrimaryExpression","createThisExpression","parseArguments","parseNonComputedProperty","parseNonComputedMember","parseComputedMember","parseLeftHandSideExpression","property","createMemberExpression","createCallExpression","parseUnaryExpression","parsePostfixExpression","createUnaryExpression","binaryPrecedence","prec","parseBinaryExpression","stack","operator","pop","createBinaryExpression","parseConditionalExpression","consequent","alternate","createConditionalExpression","parseFilter","createFilter","parseFilters","parseTopLevel","Syntax","parseInExpression","parseAsExpression","createTopLevel","createAsExpression","indexName","createInExpression","parse","inDelegate","state","labelSet","TokenName","ArrayExpression","BinaryExpression","CallExpression","ConditionalExpression","EmptyStatement","ExpressionStatement","Literal","LabeledStatement","LogicalExpression","MemberExpression","ObjectExpression","Program","Property","ThisExpression","UnaryExpression","UnknownLabel","Redeclaration","esprima","prepareBinding","expressionText","filterRegistry","expression","getExpression","scopeIdent","tagName","ex","model","oneTime","binding","getBinding","polymerExpressionScopeIdent_","indexIdent","polymerExpressionIndexIdent_","expressionParseCache","ASTDelegate","Expression","valueFn_","IdentPath","Path","object","accessor","computed","dynamicDeps","simplePath","getFn","Filter","notImplemented","arg","valueFn","filters","deps","currentPath","ConstantObservable","value_","convertStylePropertyName","c","toLowerCase","findScope","prop","parentScopeName","hasOwnProperty","isLiteralExpression","pathString","isNaN","Number","PolymerExpressions","addPath","getValueFrom","setValue","newValue","setValueFrom",{"end":{"file":"../../polymer-expressions/src/polymer-expressions.js","comments_before":[],"nlb":false,"endpos":3539,"pos":3531,"col":8,"line":117,"value":"fullPath","type":"name"},"start":{"file":"../../polymer-expressions/src/polymer-expressions.js","comments_before":[],"nlb":false,"endpos":3539,"pos":3531,"col":8,"line":117,"value":"fullPath","type":"name"},"name":"fullPath"},"fullPath","fullPath_","parts","context","propName","transform","toModelDirection","initialArgs","toModel","toDOM","apply","unaryOperators","+","-","!","binaryOperators","*","/","%","<",">","<=",">=","==","!=","===","!==","&&","||","op","argument","test","ident","arr","kind","obj","open","discardChanges","deliver","close","firstTime","firstValue","startReset","getValue","finishReset","setValueFn","CompoundObserver","ObserverTransform","count","random","toString","styleObject","join","tokenList","tokens","prepareInstancePositionChanged","template","templateInstance","valid","PathObserver","prepareInstanceModel","scopeName","parentScope","createScopeObject","__proto__","defineProperty","configurable","writable","Polymer","version","extend","api","getOwnPropertyNames","pd","getOwnPropertyDescriptor","nom","job","wait","stop","Job","go","inContext","boundComplete","complete","h","handle","cancelAnimationFrame","registry","HTMLElement","tag","getPrototypeForTag","getPrototypeOf","originalStopPropagation","Event","cancelBubble","$super","arrayOfArgs","caller","_super","nameInThis","memoizeSuper","n$","method","proto","nextSuper","super","deserializeValue","currentValue","inferredType","typeHandlers","string","date","boolean","parseInt","JSON","function","declaration","instance","publish","apis","utils","async","timeout","Platform","flush","cancelAsync","fire","onNode","event","asyncFire","classFollows","anew","old","className","classList","injectBoundHTML","html","innerHTML","fragment","instanceTemplate","nop","nob","asyncMethod","log","logFlags","EVENT_PREFIX","addHostListeners","eventDelegates","localName","methodName","getEventHandler","dispatchMethod","group","groupEnd","copyInstanceAttributes","a$","_instanceAttributes","hasAttribute","setAttribute","takeAttributes","_publishLC","attributeToProperty","propertyForAttribute","search","bindPattern","stringValue","serializeValue","reflectPropertyToAttribute","serializedValue","removeAttribute","areSameValue","numberIsNaN","resolveBindingValue","updateRecord","createPropertyObserver","_observeNames","o","_propertyObserver","registerObserver","observeArrayValue","openPropertyObserver","notifyPropertyChanges","newValues","oldValues","paths","called","ov","nv","invokeMethod","deliverChanges","propertyChanged_","reflect","callbackName","isArray","closeNamedObserver","ArrayObserver","registerNamedObserver","emitPropertyChangeRecord","Observer","hasObjectObserve","notifier","notifier_","getNotifier","notify","bindToAccessor","observable","resolveFn","privateName","privateObservable","resolvedValue","createComputedProperties","_computedNames","syntax","bindProperty","_observers","closeObservers","observers","o$","_namedObservers","closeNamedObservers","mdv","bindingDelegate","dom","createInstance","bindings_","enableBindingsReflection","path_","_recordBinding","mixinSuper","bindFinished","makeElementReady","asyncUnbindAll","_unbound","unbind","_unbindAllJob","unbindAll","cancelUnbindAll","mustachePattern","isBase","PolymerBase","base","created","ready","createdCallback","prepareElement","ownerDocument","isStagingDocument","_elementPrepared","shadowRoots","_readied","parseDeclarations","attachedCallback","attached","enteredView","hasBeenAttached","domReady","detachedCallback","preventDispose","detached","leftView","enteredViewCallback","leftViewCallback","enteredDocumentCallback","leftDocumentCallback","parseDeclaration","elementElement","fetchTemplate","shadowFromTemplate","shadowRootReady","lightFromTemplate","refNode","eventController","insertBefore","marshalNodeReferences","$","attributeChangedCallback","attributeChanged","onMutation","listener","disconnect","constructor","Base","shimCssText","cssText","is","ShadowCSS","makeScopeSelector","STYLE_SCOPE_ATTRIBUTE","STYLE_CONTROLLER_SCOPE","installControllerStyles","findStyleScope","scopeHasNamedStyle","cssTextForScope","installScopeCssText","installScopeStyle","cssTextToScopeStyle","applyStyleToScope","_scopeStyles","script","_currentScript","getRegisteredPrototype","registerPrototype","notifyPrototype","waitingForPrototype","client","waitPrototype","registerWhenReady","prototypesByName","declarations","deliverDeclarations","resolveElementPaths","urlResolver","resolveDom","addResolvePathApi","assetPath","URL","baseURI","resolvePath","urlPath","href","importRuleForSheet","sheet","baseUrl","createStyleElement","attr","firstElementChild","s$","nextElementSibling","cssTextFromSheet","__resource","matchesSelector","inSelector","matches","STYLE_SELECTOR","STYLE_LOADABLE_MATCH","SHEET_SELECTOR","STYLE_GLOBAL_SCOPE","SCOPE_ATTR","loadStyles","content","templateContent","convertSheetsToStyles","findLoadableStyles","templateUrl","styleResolver","copySheetAttributes","replaceChild","link","loadables","installSheets","cacheSheets","cacheStyles","installLocalSheets","installGlobalStyles","sheets","findNodes","firstChild","matcher","nodes","array","templateNodes","styleForScope","scopeDescriptor","webkitMatchesSelector","mozMatchesSelector","mixedCaseEventTypes","parseHostEvents","delegates","addAttributeDelegates","hasEventPrefix","removeEventPrefix","trim","prefixLength","findController","controller","prepareEventBinding","eventType","bindingValue","handler","inferObservers","explodeObservers","exploded","ni","names","split","optimizePropertyMaps","_publishNames","publishProperties","requireProperties","lowerCaseMap","propertyDescriptors","propertyDescriptor","reflects","reflectHintForDescriptor","valueForDescriptor","createPropertyAccessor","createPropertyAccessors","ATTRIBUTES_ATTRIBUTE","ATTRIBUTES_REGEX","inheritAttributesObjects","inheritObject","publishAttributes","hasValue","accumulateInstanceAttributes","clonable","isInstanceAttribute","blackList","extends","noscript","assetpath","cache-csstext","installBindingDelegate","ensurePrototypeTraversal","ancestor","extendeeName","buildPrototype","publishConstructor","extension","generateBasePrototype","desugarBeforeChaining","chainPrototypes","desugarAfterChaining","inheritMetaData","chained","chainObject","extendee","shimStyling","registerCallback","symbol","ctor","extnds","findBasePrototype","ensureBaseApi","memoizedBases","extended","mixinMethod","info","typeExtension","findTypeExtension","registerElement","inherited","queueForElement","mainQueue","importQueue","nextQueued","whenPolymerReady","queue","waitToReady","CustomElements","HTMLImports","whenImportsReady","addReadyCallback","check","shouldAdd","flushQueue","__check","__go","useNative","readied","addToFlushQueue","shift","nextElement","canReady","isEmpty","upgradeDocumentTree","flushReadyCallbacks","readyCallbacks","importElements","elementOrFragment","importUrls","urls","url","frag","createDocumentFragment","rel","import","isRegistered","isCustomTag","init","loadResources","registered","waitingForQueue","waitingForResources","_register","handleNoScript","_needsResources","body","makeSyntax"],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\nwindow.PolymerGestures = {\n  hasSDPolyfill: Boolean(window.ShadowDOMPolyfill)\n};\nPolymerGestures.wrap = PolymerGestures.hasSDPolyfill ? ShadowDOMPolyfill.wrapIfNeeded : function(a){ return a; };\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n  var HAS_FULL_PATH = false;\n\n  // test for full event path support\n  var pathTest = document.createElement('meta');\n  if (pathTest.createShadowRoot) {\n    var sr = pathTest.createShadowRoot();\n    var s = document.createElement('span');\n    sr.appendChild(s);\n    pathTest.addEventListener('testpath', function(ev) {\n      if (ev.path) {\n        // if the span is in the event path, then path[0] is the real source for all events\n        HAS_FULL_PATH = ev.path[0] === s;\n      }\n      ev.stopPropagation();\n    });\n    var ev = new CustomEvent('testpath', {bubbles: true});\n    // must add node to DOM to trigger event listener\n    document.head.appendChild(pathTest);\n    s.dispatchEvent(ev);\n    pathTest.parentNode.removeChild(pathTest);\n    sr = s = null;\n  }\n  pathTest = null;\n\n  var target = {\n    shadow: function(inEl) {\n      if (inEl) {\n        return inEl.shadowRoot || inEl.webkitShadowRoot;\n      }\n    },\n    canTarget: function(shadow) {\n      return shadow && Boolean(shadow.elementFromPoint);\n    },\n    targetingShadow: function(inEl) {\n      var s = this.shadow(inEl);\n      if (this.canTarget(s)) {\n        return s;\n      }\n    },\n    olderShadow: function(shadow) {\n      var os = shadow.olderShadowRoot;\n      if (!os) {\n        var se = shadow.querySelector('shadow');\n        if (se) {\n          os = se.olderShadowRoot;\n        }\n      }\n      return os;\n    },\n    allShadows: function(element) {\n      var shadows = [], s = this.shadow(element);\n      while(s) {\n        shadows.push(s);\n        s = this.olderShadow(s);\n      }\n      return shadows;\n    },\n    searchRoot: function(inRoot, x, y) {\n      var t, st, sr, os;\n      if (inRoot) {\n        t = inRoot.elementFromPoint(x, y);\n        if (t) {\n          // found element, check if it has a ShadowRoot\n          sr = this.targetingShadow(t);\n        } else if (inRoot !== document) {\n          // check for sibling roots\n          sr = this.olderShadow(inRoot);\n        }\n        // search other roots, fall back to light dom element\n        return this.searchRoot(sr, x, y) || t;\n      }\n    },\n    owner: function(element) {\n      if (!element) {\n        return document;\n      }\n      var s = element;\n      // walk up until you hit the shadow root or document\n      while (s.parentNode) {\n        s = s.parentNode;\n      }\n      // the owner element is expected to be a Document or ShadowRoot\n      if (s.nodeType != Node.DOCUMENT_NODE && s.nodeType != Node.DOCUMENT_FRAGMENT_NODE) {\n        s = document;\n      }\n      return s;\n    },\n    findTarget: function(inEvent) {\n      if (HAS_FULL_PATH && inEvent.path) {\n        return inEvent.path[0];\n      }\n      var x = inEvent.clientX, y = inEvent.clientY;\n      // if the listener is in the shadow root, it is much faster to start there\n      var s = this.owner(inEvent.target);\n      // if x, y is not in this root, fall back to document search\n      if (!s.elementFromPoint(x, y)) {\n        s = document;\n      }\n      return this.searchRoot(s, x, y);\n    },\n    LCA: function(a, b) {\n      if (a === b) {\n        return a;\n      }\n      if (a && !b) {\n        return a;\n      }\n      if (b && !a) {\n        return b;\n      }\n      if (!b && !a) {\n        return document;\n      }\n      // fast case, a is a direct descendant of b or vice versa\n      if (a.contains && a.contains(b)) {\n        return a;\n      }\n      if (b.contains && b.contains(a)) {\n        return b;\n      }\n      var adepth = this.depth(a);\n      var bdepth = this.depth(b);\n      var d = adepth - bdepth;\n      if (d >= 0) {\n        a = this.walk(a, d);\n      } else {\n        b = this.walk(b, -d);\n      }\n      while (a && b && a !== b) {\n        a = a.parentNode || a.host;\n        b = b.parentNode || b.host;\n      }\n      return a;\n    },\n    walk: function(n, u) {\n      for (var i = 0; n && (i < u); i++) {\n        n = n.parentNode || n.host;\n      }\n      return n;\n    },\n    depth: function(n) {\n      var d = 0;\n      while(n) {\n        d++;\n        n = n.parentNode || n.host;\n      }\n      return d;\n    },\n    deepContains: function(a, b) {\n      var common = this.LCA(a, b);\n      // if a is the common ancestor, it must \"deeply\" contain b\n      return common === a;\n    },\n    insideNode: function(node, x, y) {\n      var rect = node.getBoundingClientRect();\n      return (rect.left <= x) && (x <= rect.right) && (rect.top <= y) && (y <= rect.bottom);\n    }\n  };\n  scope.targetFinding = target;\n  /**\n   * Given an event, finds the \"deepest\" node that could have been the original target before ShadowDOM retargetting\n   *\n   * @param {Event} Event An event object with clientX and clientY properties\n   * @return {Element} The probable event origninator\n   */\n  scope.findTarget = target.findTarget.bind(target);\n  /**\n   * Determines if the \"container\" node deeply contains the \"containee\" node, including situations where the \"containee\" is contained by one or more ShadowDOM\n   * roots.\n   *\n   * @param {Node} container\n   * @param {Node} containee\n   * @return {Boolean}\n   */\n  scope.deepContains = target.deepContains.bind(target);\n\n  /**\n   * Determines if the x/y position is inside the given node.\n   *\n   * Example:\n   *\n   *     function upHandler(event) {\n   *       var innode = PolymerGestures.insideNode(event.target, event.clientX, event.clientY);\n   *       if (innode) {\n   *         // wait for tap?\n   *       } else {\n   *         // tap will never happen\n   *       }\n   *     }\n   *\n   * @param {Node} node\n   * @param {Number} x Screen X position\n   * @param {Number} y screen Y position\n   * @return {Boolean}\n   */\n  scope.insideNode = target.insideNode;\n\n})(window.PolymerGestures);\n","/*\n *\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function() {\n  function shadowSelector(v) {\n    return 'body /deep/ ' + selector(v);\n  }\n  function selector(v) {\n    return '[touch-action=\"' + v + '\"]';\n  }\n  function rule(v) {\n    return '{ -ms-touch-action: ' + v + '; touch-action: ' + v + ';}';\n  }\n  var attrib2css = [\n    'none',\n    'auto',\n    'pan-x',\n    'pan-y',\n    {\n      rule: 'pan-x pan-y',\n      selectors: [\n        'pan-x pan-y',\n        'pan-y pan-x'\n      ]\n    },\n    'manipulation'\n  ];\n  var styles = '';\n  // only install stylesheet if the browser has touch action support\n  var head = document.head;\n  var hasTouchAction = typeof document.head.style.touchAction === 'string';\n  // only add shadow selectors if shadowdom is supported\n  var hasShadowRoot = !window.ShadowDOMPolyfill && document.head.createShadowRoot;\n\n  if (hasTouchAction) {\n    attrib2css.forEach(function(r) {\n      if (String(r) === r) {\n        styles += selector(r) + rule(r) + '\\n';\n        if (hasShadowRoot) {\n          styles += shadowSelector(r) + rule(r) + '\\n';\n        }\n      } else {\n        styles += r.selectors.map(selector) + rule(r.rule) + '\\n';\n        if (hasShadowRoot) {\n          styles += r.selectors.map(shadowSelector) + rule(r.rule) + '\\n';\n        }\n      }\n    });\n\n    var el = document.createElement('style');\n    el.textContent = styles;\n    document.head.appendChild(el);\n  }\n})();\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n/**\n * This is the constructor for new PointerEvents.\n *\n * New Pointer Events must be given a type, and an optional dictionary of\n * initialization properties.\n *\n * Due to certain platform requirements, events returned from the constructor\n * identify as MouseEvents.\n *\n * @constructor\n * @param {String} inType The type of the event to create.\n * @param {Object} [inDict] An optional dictionary of initial event properties.\n * @return {Event} A new PointerEvent of type `inType` and initialized with properties from `inDict`.\n */\n(function(scope) {\n\n  var MOUSE_PROPS = [\n    'bubbles',\n    'cancelable',\n    'view',\n    'detail',\n    'screenX',\n    'screenY',\n    'clientX',\n    'clientY',\n    'ctrlKey',\n    'altKey',\n    'shiftKey',\n    'metaKey',\n    'button',\n    'relatedTarget',\n    'pageX',\n    'pageY'\n  ];\n\n  var MOUSE_DEFAULTS = [\n    false,\n    false,\n    null,\n    null,\n    0,\n    0,\n    0,\n    0,\n    false,\n    false,\n    false,\n    false,\n    0,\n    null,\n    0,\n    0\n  ];\n\n  var NOP_FACTORY = function(){ return function(){}; };\n\n  var eventFactory = {\n    // TODO(dfreedm): this is overridden by tap recognizer, needs review\n    preventTap: NOP_FACTORY,\n    makeBaseEvent: function(inType, inDict) {\n      var e = document.createEvent('Event');\n      e.initEvent(inType, inDict.bubbles || false, inDict.cancelable || false);\n      e.preventTap = eventFactory.preventTap(e);\n      return e;\n    },\n    makeGestureEvent: function(inType, inDict) {\n      inDict = inDict || Object.create(null);\n\n      var e = this.makeBaseEvent(inType, inDict);\n      for (var i = 0, keys = Object.keys(inDict), k; i < keys.length; i++) {\n        k = keys[i];\n        e[k] = inDict[k];\n      }\n      return e;\n    },\n    makePointerEvent: function(inType, inDict) {\n      inDict = inDict || Object.create(null);\n\n      var e = this.makeBaseEvent(inType, inDict);\n      // define inherited MouseEvent properties\n      for(var i = 0, p; i < MOUSE_PROPS.length; i++) {\n        p = MOUSE_PROPS[i];\n        e[p] = inDict[p] || MOUSE_DEFAULTS[i];\n      }\n      e.buttons = inDict.buttons || 0;\n\n      // Spec requires that pointers without pressure specified use 0.5 for down\n      // state and 0 for up state.\n      var pressure = 0;\n      if (inDict.pressure) {\n        pressure = inDict.pressure;\n      } else {\n        pressure = e.buttons ? 0.5 : 0;\n      }\n\n      // add x/y properties aliased to clientX/Y\n      e.x = e.clientX;\n      e.y = e.clientY;\n\n      // define the properties of the PointerEvent interface\n      e.pointerId = inDict.pointerId || 0;\n      e.width = inDict.width || 0;\n      e.height = inDict.height || 0;\n      e.pressure = pressure;\n      e.tiltX = inDict.tiltX || 0;\n      e.tiltY = inDict.tiltY || 0;\n      e.pointerType = inDict.pointerType || '';\n      e.hwTimestamp = inDict.hwTimestamp || 0;\n      e.isPrimary = inDict.isPrimary || false;\n      e._source = inDict._source || '';\n      return e;\n    }\n  };\n\n  scope.eventFactory = eventFactory;\n})(window.PolymerGestures);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n/**\n * This module implements an map of pointer states\n */\n(function(scope) {\n  var USE_MAP = window.Map && window.Map.prototype.forEach;\n  var POINTERS_FN = function(){ return this.size; };\n  function PointerMap() {\n    if (USE_MAP) {\n      var m = new Map();\n      m.pointers = POINTERS_FN;\n      return m;\n    } else {\n      this.keys = [];\n      this.values = [];\n    }\n  }\n\n  PointerMap.prototype = {\n    set: function(inId, inEvent) {\n      var i = this.keys.indexOf(inId);\n      if (i > -1) {\n        this.values[i] = inEvent;\n      } else {\n        this.keys.push(inId);\n        this.values.push(inEvent);\n      }\n    },\n    has: function(inId) {\n      return this.keys.indexOf(inId) > -1;\n    },\n    'delete': function(inId) {\n      var i = this.keys.indexOf(inId);\n      if (i > -1) {\n        this.keys.splice(i, 1);\n        this.values.splice(i, 1);\n      }\n    },\n    get: function(inId) {\n      var i = this.keys.indexOf(inId);\n      return this.values[i];\n    },\n    clear: function() {\n      this.keys.length = 0;\n      this.values.length = 0;\n    },\n    // return value, key, map\n    forEach: function(callback, thisArg) {\n      this.values.forEach(function(v, i) {\n        callback.call(thisArg, v, this.keys[i], this);\n      }, this);\n    },\n    pointers: function() {\n      return this.keys.length;\n    }\n  };\n\n  scope.PointerMap = PointerMap;\n})(window.PolymerGestures);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n  var CLONE_PROPS = [\n    // MouseEvent\n    'bubbles',\n    'cancelable',\n    'view',\n    'detail',\n    'screenX',\n    'screenY',\n    'clientX',\n    'clientY',\n    'ctrlKey',\n    'altKey',\n    'shiftKey',\n    'metaKey',\n    'button',\n    'relatedTarget',\n    // DOM Level 3\n    'buttons',\n    // PointerEvent\n    'pointerId',\n    'width',\n    'height',\n    'pressure',\n    'tiltX',\n    'tiltY',\n    'pointerType',\n    'hwTimestamp',\n    'isPrimary',\n    // event instance\n    'type',\n    'target',\n    'currentTarget',\n    'which',\n    'pageX',\n    'pageY',\n    'timeStamp',\n    // gesture addons\n    'preventTap',\n    'tapPrevented',\n    '_source'\n  ];\n\n  var CLONE_DEFAULTS = [\n    // MouseEvent\n    false,\n    false,\n    null,\n    null,\n    0,\n    0,\n    0,\n    0,\n    false,\n    false,\n    false,\n    false,\n    0,\n    null,\n    // DOM Level 3\n    0,\n    // PointerEvent\n    0,\n    0,\n    0,\n    0,\n    0,\n    0,\n    '',\n    0,\n    false,\n    // event instance\n    '',\n    null,\n    null,\n    0,\n    0,\n    0,\n    0,\n    function(){},\n    false\n  ];\n\n  var HAS_SVG_INSTANCE = (typeof SVGElementInstance !== 'undefined');\n\n  var eventFactory = scope.eventFactory;\n\n  var hasSDPolyfill = scope.hasSDPolyfill;\n  var wrap = scope.wrap;\n\n  /**\n   * This module is for normalizing events. Mouse and Touch events will be\n   * collected here, and fire PointerEvents that have the same semantics, no\n   * matter the source.\n   * Events fired:\n   *   - pointerdown: a pointing is added\n   *   - pointerup: a pointer is removed\n   *   - pointermove: a pointer is moved\n   *   - pointerover: a pointer crosses into an element\n   *   - pointerout: a pointer leaves an element\n   *   - pointercancel: a pointer will no longer generate events\n   */\n  var dispatcher = {\n    pointermap: new scope.PointerMap(),\n    eventMap: Object.create(null),\n    // Scope objects for native events.\n    // This exists for ease of testing.\n    eventSources: Object.create(null),\n    eventSourceList: [],\n    gestures: [],\n    gestureQueue: [],\n    /**\n     * Add a new event source that will generate pointer events.\n     *\n     * `inSource` must contain an array of event names named `events`, and\n     * functions with the names specified in the `events` array.\n     * @param {string} name A name for the event source\n     * @param {Object} source A new source of platform events.\n     */\n    registerSource: function(name, source) {\n      var s = source;\n      var newEvents = s.events;\n      if (newEvents) {\n        newEvents.forEach(function(e) {\n          if (s[e]) {\n            this.eventMap[e] = s[e].bind(s);\n          }\n        }, this);\n        this.eventSources[name] = s;\n        this.eventSourceList.push(s);\n      }\n    },\n    registerGesture: function(name, source) {\n      this.gestures.push(source);\n    },\n    register: function(element) {\n      var l = this.eventSourceList.length;\n      for (var i = 0, es; (i < l) && (es = this.eventSourceList[i]); i++) {\n        // call eventsource register\n        es.register.call(es, element);\n      }\n    },\n    unregister: function(element) {\n      var l = this.eventSourceList.length;\n      for (var i = 0, es; (i < l) && (es = this.eventSourceList[i]); i++) {\n        // call eventsource register\n        es.unregister.call(es, element);\n      }\n    },\n    // EVENTS\n    down: function(inEvent) {\n      this.fireEvent('down', inEvent);\n    },\n    move: function(inEvent) {\n      // pipe move events into gesture queue directly\n      inEvent.type = 'move';\n      this.fillGestureQueue(inEvent);\n    },\n    up: function(inEvent) {\n      this.fireEvent('up', inEvent);\n    },\n    cancel: function(inEvent) {\n      inEvent.tapPrevented = true;\n      this.fireEvent('up', inEvent);\n    },\n    // LISTENER LOGIC\n    eventHandler: function(inEvent) {\n      // This is used to prevent multiple dispatch of events from\n      // platform events. This can happen when two elements in different scopes\n      // are set up to create pointer events, which is relevant to Shadow DOM.\n      if (inEvent._handledByPG) {\n        return;\n      }\n      var type = inEvent.type;\n      var fn = this.eventMap && this.eventMap[type];\n      if (fn) {\n        fn(inEvent);\n      }\n      inEvent._handledByPG = true;\n    },\n    // set up event listeners\n    listen: function(target, events) {\n      for (var i = 0, l = events.length, e; (i < l) && (e = events[i]); i++) {\n        this.addEvent(target, e);\n      }\n    },\n    // remove event listeners\n    unlisten: function(target, events) {\n      for (var i = 0, l = events.length, e; (i < l) && (e = events[i]); i++) {\n        this.removeEvent(target, e);\n      }\n    },\n    addEvent: function(target, eventName) {\n      // NOTE: Work around for #4, use native event listener in SD Polyfill\n      if (hasSDPolyfill) {\n        target.addEventListener_(eventName, this.boundHandler);\n      } else {\n        target.addEventListener(eventName, this.boundHandler);\n      }\n    },\n    removeEvent: function(target, eventName) {\n      // NOTE: Work around for #4, use native event listener in SD Polyfill\n      if (hasSDPolyfill) {\n        target.removeEventListener_(eventName, this.boundHandler);\n      } else {\n        target.removeEventListener(eventName, this.boundHandler);\n      }\n    },\n    // EVENT CREATION AND TRACKING\n    /**\n     * Creates a new Event of type `inType`, based on the information in\n     * `inEvent`.\n     *\n     * @param {string} inType A string representing the type of event to create\n     * @param {Event} inEvent A platform event with a target\n     * @return {Event} A PointerEvent of type `inType`\n     */\n    makeEvent: function(inType, inEvent) {\n      var e = eventFactory.makePointerEvent(inType, inEvent);\n      e.preventDefault = inEvent.preventDefault;\n      e.tapPrevented = inEvent.tapPrevented;\n      e._target = e._target || inEvent.target;\n      return e;\n    },\n    // make and dispatch an event in one call\n    fireEvent: function(inType, inEvent) {\n      var e = this.makeEvent(inType, inEvent);\n      return this.dispatchEvent(e);\n    },\n    /**\n     * Returns a snapshot of inEvent, with writable properties.\n     *\n     * @param {Event} inEvent An event that contains properties to copy.\n     * @return {Object} An object containing shallow copies of `inEvent`'s\n     *    properties.\n     */\n    cloneEvent: function(inEvent) {\n      var eventCopy = Object.create(null), p;\n      for (var i = 0; i < CLONE_PROPS.length; i++) {\n        p = CLONE_PROPS[i];\n        eventCopy[p] = inEvent[p] || CLONE_DEFAULTS[i];\n        // Work around SVGInstanceElement shadow tree\n        // Return the <use> element that is represented by the instance for Safari, Chrome, IE.\n        // This is the behavior implemented by Firefox.\n        if (p === 'target' || p === 'relatedTarget') {\n          if (HAS_SVG_INSTANCE && eventCopy[p] instanceof SVGElementInstance) {\n            eventCopy[p] = eventCopy[p].correspondingUseElement;\n          }\n          eventCopy[p] = wrap(eventCopy[p]);\n        }\n      }\n      // keep the semantics of preventDefault\n      eventCopy.preventDefault = inEvent.preventDefault;\n      return eventCopy;\n    },\n    /**\n     * Dispatches the event to its target.\n     *\n     * @param {Event} inEvent The event to be dispatched.\n     * @return {Boolean} True if an event handler returns true, false otherwise.\n     */\n    dispatchEvent: function(inEvent) {\n      var t = inEvent._target;\n      if (t) {\n        t.dispatchEvent(inEvent);\n        // clone the event for the gesture system to process\n        // clone after dispatch to pick up gesture prevention code\n        var clone = this.cloneEvent(inEvent);\n        clone.target = t;\n        this.fillGestureQueue(clone);\n      }\n    },\n    gestureTrigger: function() {\n      // process the gesture queue\n      for (var i = 0, e; i < this.gestureQueue.length; i++) {\n        e = this.gestureQueue[i];\n        for (var j = 0, g, fn; j < this.gestures.length; j++) {\n          g = this.gestures[j];\n          fn = g[e.type];\n          if (fn) {\n            fn.call(g, e);\n          }\n        }\n      }\n      this.gestureQueue.length = 0;\n    },\n    fillGestureQueue: function(ev) {\n      // only trigger the gesture queue once\n      if (!this.gestureQueue.length) {\n        requestAnimationFrame(this.boundGestureTrigger);\n      }\n      this.gestureQueue.push(ev);\n    }\n  };\n  dispatcher.boundHandler = dispatcher.eventHandler.bind(dispatcher);\n  dispatcher.boundGestureTrigger = dispatcher.gestureTrigger.bind(dispatcher);\n  scope.dispatcher = dispatcher;\n  scope.register = function(root) {\n    dispatcher.register(root);\n  };\n  scope.unregister = dispatcher.unregister.bind(dispatcher);\n  scope.wrap = wrap;\n})(window.PolymerGestures);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n/**\n * This module uses Mutation Observers to dynamically adjust which nodes will\n * generate Pointer Events.\n *\n * All nodes that wish to generate Pointer Events must have the attribute\n * `touch-action` set to `none`.\n */\n(function(scope) {\n  var forEach = Array.prototype.forEach.call.bind(Array.prototype.forEach);\n  var map = Array.prototype.map.call.bind(Array.prototype.map);\n  var toArray = Array.prototype.slice.call.bind(Array.prototype.slice);\n  var filter = Array.prototype.filter.call.bind(Array.prototype.filter);\n  var MO = window.MutationObserver || window.WebKitMutationObserver;\n  var SELECTOR = '[touch-action]';\n  var OBSERVER_INIT = {\n    subtree: true,\n    childList: true,\n    attributes: true,\n    attributeOldValue: true,\n    attributeFilter: ['touch-action']\n  };\n\n  function Installer(add, remove, changed, binder) {\n    this.addCallback = add.bind(binder);\n    this.removeCallback = remove.bind(binder);\n    this.changedCallback = changed.bind(binder);\n    if (MO) {\n      this.observer = new MO(this.mutationWatcher.bind(this));\n    }\n  }\n\n  Installer.prototype = {\n    watchSubtree: function(target) {\n      // Only watch scopes that can target find, as these are top-level.\n      // Otherwise we can see duplicate additions and removals that add noise.\n      //\n      // TODO(dfreedman): For some instances with ShadowDOMPolyfill, we can see\n      // a removal without an insertion when a node is redistributed among\n      // shadows. Since it all ends up correct in the document, watching only\n      // the document will yield the correct mutations to watch.\n      if (scope.targetFinding.canTarget(target)) {\n        this.observer.observe(target, OBSERVER_INIT);\n      }\n    },\n    enableOnSubtree: function(target) {\n      this.watchSubtree(target);\n      if (target === document && document.readyState !== 'complete') {\n        this.installOnLoad();\n      } else {\n        this.installNewSubtree(target);\n      }\n    },\n    installNewSubtree: function(target) {\n      forEach(this.findElements(target), this.addElement, this);\n    },\n    findElements: function(target) {\n      if (target.querySelectorAll) {\n        return target.querySelectorAll(SELECTOR);\n      }\n      return [];\n    },\n    removeElement: function(el) {\n      this.removeCallback(el);\n    },\n    addElement: function(el) {\n      this.addCallback(el);\n    },\n    elementChanged: function(el, oldValue) {\n      this.changedCallback(el, oldValue);\n    },\n    concatLists: function(accum, list) {\n      return accum.concat(toArray(list));\n    },\n    // register all touch-action = none nodes on document load\n    installOnLoad: function() {\n      document.addEventListener('readystatechange', function() {\n        if (document.readyState === 'complete') {\n          this.installNewSubtree(document);\n        }\n      }.bind(this));\n    },\n    isElement: function(n) {\n      return n.nodeType === Node.ELEMENT_NODE;\n    },\n    flattenMutationTree: function(inNodes) {\n      // find children with touch-action\n      var tree = map(inNodes, this.findElements, this);\n      // make sure the added nodes are accounted for\n      tree.push(filter(inNodes, this.isElement));\n      // flatten the list\n      return tree.reduce(this.concatLists, []);\n    },\n    mutationWatcher: function(mutations) {\n      mutations.forEach(this.mutationHandler, this);\n    },\n    mutationHandler: function(m) {\n      if (m.type === 'childList') {\n        var added = this.flattenMutationTree(m.addedNodes);\n        added.forEach(this.addElement, this);\n        var removed = this.flattenMutationTree(m.removedNodes);\n        removed.forEach(this.removeElement, this);\n      } else if (m.type === 'attributes') {\n        this.elementChanged(m.target, m.oldValue);\n      }\n    }\n  };\n\n  if (!MO) {\n    Installer.prototype.watchSubtree = function(){\n      console.warn('PolymerGestures: MutationObservers not found, touch-action will not be dynamically detected');\n    };\n  }\n\n  scope.Installer = Installer;\n})(window.PolymerGestures);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function (scope) {\n  var dispatcher = scope.dispatcher;\n  var pointermap = dispatcher.pointermap;\n  // radius around touchend that swallows mouse events\n  var DEDUP_DIST = 25;\n\n  var WHICH_TO_BUTTONS = [0, 1, 4, 2];\n\n  var HAS_BUTTONS = false;\n  try {\n    HAS_BUTTONS = new MouseEvent('test', {buttons: 1}).buttons === 1;\n  } catch (e) {}\n\n  // handler block for native mouse events\n  var mouseEvents = {\n    POINTER_ID: 1,\n    POINTER_TYPE: 'mouse',\n    events: [\n      'mousedown',\n      'mousemove',\n      'mouseup'\n    ],\n    register: function(target) {\n      if (target !== document) {\n        return;\n      }\n      dispatcher.listen(target, this.events);\n    },\n    unregister: function(target) {\n      dispatcher.unlisten(target, this.events);\n    },\n    lastTouches: [],\n    // collide with the global mouse listener\n    isEventSimulatedFromTouch: function(inEvent) {\n      var lts = this.lastTouches;\n      var x = inEvent.clientX, y = inEvent.clientY;\n      for (var i = 0, l = lts.length, t; i < l && (t = lts[i]); i++) {\n        // simulated mouse events will be swallowed near a primary touchend\n        var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y);\n        if (dx <= DEDUP_DIST && dy <= DEDUP_DIST) {\n          return true;\n        }\n      }\n    },\n    prepareEvent: function(inEvent) {\n      var e = dispatcher.cloneEvent(inEvent);\n      e.pointerId = this.POINTER_ID;\n      e.isPrimary = true;\n      e.pointerType = this.POINTER_TYPE;\n      e._source = 'mouse';\n      if (!HAS_BUTTONS) {\n        e.buttons = WHICH_TO_BUTTONS[e.which] || 0;\n      }\n      return e;\n    },\n    mousedown: function(inEvent) {\n      if (!this.isEventSimulatedFromTouch(inEvent)) {\n        var p = pointermap.has(this.POINTER_ID);\n        // TODO(dfreedman) workaround for some elements not sending mouseup\n        // http://crbug/149091\n        if (p) {\n          this.mouseup(inEvent);\n        }\n        var e = this.prepareEvent(inEvent);\n        e.target = scope.wrap(scope.findTarget(inEvent));\n        pointermap.set(this.POINTER_ID, e.target);\n        dispatcher.down(e);\n      }\n    },\n    mousemove: function(inEvent) {\n      if (!this.isEventSimulatedFromTouch(inEvent)) {\n        var e = this.prepareEvent(inEvent);\n        e.target = pointermap.get(this.POINTER_ID);\n        dispatcher.move(e);\n      }\n    },\n    mouseup: function(inEvent) {\n      if (!this.isEventSimulatedFromTouch(inEvent)) {\n        var e = this.prepareEvent(inEvent);\n        e.relatedTarget = scope.wrap(scope.findTarget(inEvent));\n        e.target = pointermap.get(this.POINTER_ID);\n        dispatcher.up(e);\n        this.cleanupMouse();\n      }\n    },\n    cleanupMouse: function() {\n      pointermap['delete'](this.POINTER_ID);\n    }\n  };\n\n  scope.mouseEvents = mouseEvents;\n})(window.PolymerGestures);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n  var dispatcher = scope.dispatcher;\n  var allShadows = scope.targetFinding.allShadows.bind(scope.targetFinding);\n  var pointermap = dispatcher.pointermap;\n  var touchMap = Array.prototype.map.call.bind(Array.prototype.map);\n  // This should be long enough to ignore compat mouse events made by touch\n  var DEDUP_TIMEOUT = 2500;\n  var CLICK_COUNT_TIMEOUT = 200;\n  var HYSTERESIS = 20;\n  var ATTRIB = 'touch-action';\n  var INSTALLER;\n  // maybe one day...\n  // var CAN_USE_GLOBAL = ATTRIB in document.head.style;\n  var CAN_USE_GLOBAL = false;\n\n  // handler block for native touch events\n  var touchEvents = {\n    events: [\n      'touchstart',\n      'touchmove',\n      'touchend',\n      'touchcancel'\n    ],\n    register: function(target) {\n      if (CAN_USE_GLOBAL) {\n        dispatcher.listen(target, this.events);\n      } else {\n        INSTALLER.enableOnSubtree(target);\n      }\n    },\n    unregister: function(target) {\n      if (CAN_USE_GLOBAL) {\n        dispatcher.unlisten(target, this.events);\n      } else {\n        // TODO(dfreedman): is it worth it to disconnect the MO?\n      }\n    },\n    elementAdded: function(el) {\n      var a = el.getAttribute(ATTRIB);\n      var st = this.touchActionToScrollType(a);\n      if (st) {\n        el._scrollType = st;\n        dispatcher.listen(el, this.events);\n        // set touch-action on shadows as well\n        allShadows(el).forEach(function(s) {\n          s._scrollType = st;\n          dispatcher.listen(s, this.events);\n        }, this);\n      }\n    },\n    elementRemoved: function(el) {\n      el._scrollType = undefined;\n      dispatcher.unlisten(el, this.events);\n      // remove touch-action from shadow\n      allShadows(el).forEach(function(s) {\n        s._scrollType = undefined;\n        dispatcher.unlisten(s, this.events);\n      }, this);\n    },\n    elementChanged: function(el, oldValue) {\n      var a = el.getAttribute(ATTRIB);\n      var st = this.touchActionToScrollType(a);\n      var oldSt = this.touchActionToScrollType(oldValue);\n      // simply update scrollType if listeners are already established\n      if (st && oldSt) {\n        el._scrollType = st;\n        allShadows(el).forEach(function(s) {\n          s._scrollType = st;\n        }, this);\n      } else if (oldSt) {\n        this.elementRemoved(el);\n      } else if (st) {\n        this.elementAdded(el);\n      }\n    },\n    scrollTypes: {\n      EMITTER: 'none',\n      XSCROLLER: 'pan-x',\n      YSCROLLER: 'pan-y',\n      SCROLLER: /^(?:pan-x pan-y)|(?:pan-y pan-x)|auto|manipulation$/\n    },\n    touchActionToScrollType: function(touchAction) {\n      var t = touchAction;\n      var st = this.scrollTypes;\n      if (t === 'none') {\n        return 'none';\n      } else if (t === st.XSCROLLER) {\n        return 'X';\n      } else if (t === st.YSCROLLER) {\n        return 'Y';\n      } else if (st.SCROLLER.exec(t)) {\n        return 'XY';\n      }\n    },\n    POINTER_TYPE: 'touch',\n    firstTouch: null,\n    isPrimaryTouch: function(inTouch) {\n      return this.firstTouch === inTouch.identifier;\n    },\n    setPrimaryTouch: function(inTouch) {\n      // set primary touch if there no pointers, or the only pointer is the mouse\n      if (pointermap.pointers() === 0 || (pointermap.pointers() === 1 && pointermap.has(1))) {\n        this.firstTouch = inTouch.identifier;\n        this.firstXY = {X: inTouch.clientX, Y: inTouch.clientY};\n        this.scrolling = false;\n        this.cancelResetClickCount();\n      }\n    },\n    removePrimaryPointer: function(inPointer) {\n      if (inPointer.isPrimary) {\n        this.firstTouch = null;\n        this.firstXY = null;\n        this.resetClickCount();\n      }\n    },\n    clickCount: 0,\n    resetId: null,\n    resetClickCount: function() {\n      var fn = function() {\n        this.clickCount = 0;\n        this.resetId = null;\n      }.bind(this);\n      this.resetId = setTimeout(fn, CLICK_COUNT_TIMEOUT);\n    },\n    cancelResetClickCount: function() {\n      if (this.resetId) {\n        clearTimeout(this.resetId);\n      }\n    },\n    typeToButtons: function(type) {\n      var ret = 0;\n      if (type === 'touchstart' || type === 'touchmove') {\n        ret = 1;\n      }\n      return ret;\n    },\n    findTarget: function(touch, id) {\n      if (this.currentTouchEvent.type === 'touchstart') {\n        if (this.isPrimaryTouch(touch)) {\n          var fastPath = {\n            clientX: touch.clientX,\n            clientY: touch.clientY,\n            path: this.currentTouchEvent.path,\n            target: scope.wrap(this.currentTouchEvent.target)\n          };\n          return scope.findTarget(fastPath);\n        } else {\n          return scope.findTarget(touch);\n        }\n      }\n      // reuse target we found in touchstart\n      return pointermap.get(id);\n    },\n    touchToPointer: function(inTouch) {\n      var cte = this.currentTouchEvent;\n      var e = dispatcher.cloneEvent(inTouch);\n      // Spec specifies that pointerId 1 is reserved for Mouse.\n      // Touch identifiers can start at 0.\n      // Add 2 to the touch identifier for compatibility.\n      var id = e.pointerId = inTouch.identifier + 2;\n      e.target = scope.wrap(this.findTarget(inTouch, id));\n      e.bubbles = true;\n      e.cancelable = true;\n      e.detail = this.clickCount;\n      e.buttons = this.typeToButtons(cte.type);\n      e.width = inTouch.webkitRadiusX || inTouch.radiusX || 0;\n      e.height = inTouch.webkitRadiusY || inTouch.radiusY || 0;\n      e.pressure = inTouch.webkitForce || inTouch.force || 0.5;\n      e.isPrimary = this.isPrimaryTouch(inTouch);\n      e.pointerType = this.POINTER_TYPE;\n      e._source = 'touch';\n      // forward touch preventDefaults\n      var self = this;\n      e.preventDefault = function() {\n        self.scrolling = false;\n        self.firstXY = null;\n        cte.preventDefault();\n      };\n      return e;\n    },\n    processTouches: function(inEvent, inFunction) {\n      var tl = inEvent.changedTouches;\n      this.currentTouchEvent = inEvent;\n      for (var i = 0, t, p; i < tl.length; i++) {\n        t = tl[i];\n        p = this.touchToPointer(t);\n        if (inEvent.type === 'touchstart') {\n          pointermap.set(p.pointerId, p.target);\n        }\n        if (pointermap.has(p.pointerId)) {\n          inFunction.call(this, p);\n        }\n        if (inEvent.type === 'touchend') {\n          this.cleanUpPointer(p);\n        }\n      }\n    },\n    // For single axis scrollers, determines whether the element should emit\n    // pointer events or behave as a scroller\n    shouldScroll: function(inEvent) {\n      if (this.firstXY) {\n        var ret;\n        var scrollAxis = scope.wrap(inEvent.currentTarget)._scrollType;\n        if (scrollAxis === 'none') {\n          // this element is a touch-action: none, should never scroll\n          ret = false;\n        } else if (scrollAxis === 'XY') {\n          // this element should always scroll\n          ret = true;\n        } else {\n          var t = inEvent.changedTouches[0];\n          // check the intended scroll axis, and other axis\n          var a = scrollAxis;\n          var oa = scrollAxis === 'Y' ? 'X' : 'Y';\n          var da = Math.abs(t['client' + a] - this.firstXY[a]);\n          var doa = Math.abs(t['client' + oa] - this.firstXY[oa]);\n          // if delta in the scroll axis > delta other axis, scroll instead of\n          // making events\n          ret = da >= doa;\n        }\n        return ret;\n      }\n    },\n    findTouch: function(inTL, inId) {\n      for (var i = 0, l = inTL.length, t; i < l && (t = inTL[i]); i++) {\n        if (t.identifier === inId) {\n          return true;\n        }\n      }\n    },\n    // In some instances, a touchstart can happen without a touchend. This\n    // leaves the pointermap in a broken state.\n    // Therefore, on every touchstart, we remove the touches that did not fire a\n    // touchend event.\n    // To keep state globally consistent, we fire a\n    // pointercancel for this \"abandoned\" touch\n    vacuumTouches: function(inEvent) {\n      var tl = inEvent.touches;\n      // pointermap.pointers() should be < tl.length here, as the touchstart has not\n      // been processed yet.\n      if (pointermap.pointers() >= tl.length) {\n        var d = [];\n        pointermap.forEach(function(value, key) {\n          // Never remove pointerId == 1, which is mouse.\n          // Touch identifiers are 2 smaller than their pointerId, which is the\n          // index in pointermap.\n          if (key !== 1 && !this.findTouch(tl, key - 2)) {\n            var p = value;\n            d.push(p);\n          }\n        }, this);\n        d.forEach(this.cancel, this);\n      }\n    },\n    touchstart: function(inEvent) {\n      this.vacuumTouches(inEvent);\n      this.setPrimaryTouch(inEvent.changedTouches[0]);\n      this.dedupSynthMouse(inEvent);\n      if (!this.scrolling) {\n        this.clickCount++;\n        this.processTouches(inEvent, this.down);\n      }\n    },\n    down: function(inPointer) {\n      dispatcher.down(inPointer);\n    },\n    touchmove: function(inEvent) {\n      if (CAN_USE_GLOBAL) {\n        this.processTouches(inEvent, this.move);\n      } else {\n        if (!this.scrolling) {\n          if (this.shouldScroll(inEvent)) {\n            this.scrolling = true;\n          } else {\n            inEvent.preventDefault();\n            this.processTouches(inEvent, this.move);\n          }\n        } else if (this.firstXY) {\n          var t = inEvent.changedTouches[0];\n          var dx = t.clientX - this.firstXY.X;\n          var dy = t.clientY - this.firstXY.Y;\n          var dd = Math.sqrt(dx * dx + dy * dy);\n          if (dd >= HYSTERESIS) {\n            this.touchcancel(inEvent);\n            this.firstXY = null;\n          }\n        }\n      }\n    },\n    move: function(inPointer) {\n      dispatcher.move(inPointer);\n    },\n    touchend: function(inEvent) {\n      this.dedupSynthMouse(inEvent);\n      this.processTouches(inEvent, this.up);\n    },\n    up: function(inPointer) {\n      inPointer.relatedTarget = scope.wrap(scope.findTarget(inPointer));\n      dispatcher.up(inPointer);\n    },\n    cancel: function(inPointer) {\n      dispatcher.cancel(inPointer);\n    },\n    touchcancel: function(inEvent) {\n      this.processTouches(inEvent, this.cancel);\n    },\n    cleanUpPointer: function(inPointer) {\n      pointermap['delete'](inPointer.pointerId);\n      this.removePrimaryPointer(inPointer);\n    },\n    // prevent synth mouse events from creating pointer events\n    dedupSynthMouse: function(inEvent) {\n      var lts = scope.mouseEvents.lastTouches;\n      var t = inEvent.changedTouches[0];\n      // only the primary finger will synth mouse events\n      if (this.isPrimaryTouch(t)) {\n        // remember x/y of last touch\n        var lt = {x: t.clientX, y: t.clientY};\n        lts.push(lt);\n        var fn = (function(lts, lt){\n          var i = lts.indexOf(lt);\n          if (i > -1) {\n            lts.splice(i, 1);\n          }\n        }).bind(null, lts, lt);\n        setTimeout(fn, DEDUP_TIMEOUT);\n      }\n    }\n  };\n\n  if (!CAN_USE_GLOBAL) {\n    INSTALLER = new scope.Installer(touchEvents.elementAdded, touchEvents.elementRemoved, touchEvents.elementChanged, touchEvents);\n  }\n\n  scope.touchEvents = touchEvents;\n})(window.PolymerGestures);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n  var dispatcher = scope.dispatcher;\n  var pointermap = dispatcher.pointermap;\n  var HAS_BITMAP_TYPE = window.MSPointerEvent && typeof window.MSPointerEvent.MSPOINTER_TYPE_MOUSE === 'number';\n  var msEvents = {\n    events: [\n      'MSPointerDown',\n      'MSPointerMove',\n      'MSPointerUp',\n      'MSPointerCancel',\n    ],\n    register: function(target) {\n      if (target !== document) {\n        return;\n      }\n      dispatcher.listen(target, this.events);\n    },\n    unregister: function(target) {\n      dispatcher.unlisten(target, this.events);\n    },\n    POINTER_TYPES: [\n      '',\n      'unavailable',\n      'touch',\n      'pen',\n      'mouse'\n    ],\n    prepareEvent: function(inEvent) {\n      var e = inEvent;\n      e = dispatcher.cloneEvent(inEvent);\n      if (HAS_BITMAP_TYPE) {\n        e.pointerType = this.POINTER_TYPES[inEvent.pointerType];\n      }\n      e._source = 'ms';\n      return e;\n    },\n    cleanup: function(id) {\n      pointermap['delete'](id);\n    },\n    MSPointerDown: function(inEvent) {\n      var e = this.prepareEvent(inEvent);\n      e.target = scope.wrap(scope.findTarget(inEvent));\n      pointermap.set(inEvent.pointerId, e.target);\n      dispatcher.down(e);\n    },\n    MSPointerMove: function(inEvent) {\n      var e = this.prepareEvent(inEvent);\n      e.target = pointermap.get(e.pointerId);\n      dispatcher.move(e);\n    },\n    MSPointerUp: function(inEvent) {\n      var e = this.prepareEvent(inEvent);\n      e.relatedTarget = scope.wrap(scope.findTarget(inEvent));\n      e.target = pointermap.get(e.pointerId);\n      dispatcher.up(e);\n      this.cleanup(inEvent.pointerId);\n    },\n    MSPointerCancel: function(inEvent) {\n      var e = this.prepareEvent(inEvent);\n      e.relatedTarget = scope.wrap(scope.findTarget(inEvent));\n      e.target = pointermap.get(e.pointerId);\n      dispatcher.cancel(e);\n      this.cleanup(inEvent.pointerId);\n    }\n  };\n\n  scope.msEvents = msEvents;\n})(window.PolymerGestures);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n  var dispatcher = scope.dispatcher;\n  var pointermap = dispatcher.pointermap;\n  var pointerEvents = {\n    events: [\n      'pointerdown',\n      'pointermove',\n      'pointerup',\n      'pointercancel'\n    ],\n    prepareEvent: function(inEvent) {\n      var e = dispatcher.cloneEvent(inEvent);\n      e._source = 'pointer';\n      return e;\n    },\n    register: function(target) {\n      if (target !== document) {\n        return;\n      }\n      dispatcher.listen(target, this.events);\n    },\n    unregister: function(target) {\n      dispatcher.unlisten(target, this.events);\n    },\n    cleanup: function(id) {\n      pointermap['delete'](id);\n    },\n    pointerdown: function(inEvent) {\n      var e = this.prepareEvent(inEvent);\n      e.target = scope.wrap(scope.findTarget(inEvent));\n      pointermap.set(e.pointerId, e.target);\n      dispatcher.down(e);\n    },\n    pointermove: function(inEvent) {\n      var e = this.prepareEvent(inEvent);\n      e.target = pointermap.get(e.pointerId);\n      dispatcher.move(e);\n    },\n    pointerup: function(inEvent) {\n      var e = this.prepareEvent(inEvent);\n      e.relatedTarget = scope.wrap(scope.findTarget(inEvent));\n      e.target = pointermap.get(e.pointerId);\n      dispatcher.up(e);\n      this.cleanup(inEvent.pointerId);\n    },\n    pointercancel: function(inEvent) {\n      var e = this.prepareEvent(inEvent);\n      e.relatedTarget = scope.wrap(scope.findTarget(inEvent));\n      e.target = pointermap.get(e.pointerId);\n      dispatcher.cancel(e);\n      this.cleanup(inEvent.pointerId);\n    }\n  };\n\n  scope.pointerEvents = pointerEvents;\n})(window.PolymerGestures);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n/**\n * This module contains the handlers for native platform events.\n * From here, the dispatcher is called to create unified pointer events.\n * Included are touch events (v1), mouse events, and MSPointerEvents.\n */\n(function(scope) {\n  var dispatcher = scope.dispatcher;\n\n  if (window.PointerEvent) {\n    dispatcher.registerSource('pointer', scope.pointerEvents);\n  } else if (window.navigator.msPointerEnabled) {\n    dispatcher.registerSource('ms', scope.msEvents);\n  } else {\n    dispatcher.registerSource('mouse', scope.mouseEvents);\n    if (window.ontouchstart !== undefined) {\n      dispatcher.registerSource('touch', scope.touchEvents);\n    }\n  }\n\n  dispatcher.register(document);\n})(window.PolymerGestures);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n/**\n * This event denotes the beginning of a series of tracking events.\n *\n * @module PointerGestures\n * @submodule Events\n * @class trackstart\n */\n/**\n * Pixels moved in the x direction since trackstart.\n * @type Number\n * @property dx\n */\n/**\n * Pixes moved in the y direction since trackstart.\n * @type Number\n * @property dy\n */\n/**\n * Pixels moved in the x direction since the last track.\n * @type Number\n * @property ddx\n */\n/**\n * Pixles moved in the y direction since the last track.\n * @type Number\n * @property ddy\n */\n/**\n * The clientX position of the track gesture.\n * @type Number\n * @property clientX\n */\n/**\n * The clientY position of the track gesture.\n * @type Number\n * @property clientY\n */\n/**\n * The pageX position of the track gesture.\n * @type Number\n * @property pageX\n */\n/**\n * The pageY position of the track gesture.\n * @type Number\n * @property pageY\n */\n/**\n * The screenX position of the track gesture.\n * @type Number\n * @property screenX\n */\n/**\n * The screenY position of the track gesture.\n * @type Number\n * @property screenY\n */\n/**\n * The last x axis direction of the pointer.\n * @type Number\n * @property xDirection\n */\n/**\n * The last y axis direction of the pointer.\n * @type Number\n * @property yDirection\n */\n/**\n * A shared object between all tracking events.\n * @type Object\n * @property trackInfo\n */\n/**\n * The element currently under the pointer.\n * @type Element\n * @property relatedTarget\n */\n/**\n * The type of pointer that make the track gesture.\n * @type String\n * @property pointerType\n */\n/**\n *\n * This event fires for all pointer movement being tracked.\n *\n * @class track\n * @extends trackstart\n */\n/**\n * This event fires when the pointer is no longer being tracked.\n *\n * @class trackend\n * @extends trackstart\n */\n\n (function(scope) {\n   var dispatcher = scope.dispatcher;\n   var eventFactory = scope.eventFactory;\n   var pointermap = new scope.PointerMap();\n   var track = {\n     events: [\n       'down',\n       'move',\n       'up',\n     ],\n     WIGGLE_THRESHOLD: 4,\n     clampDir: function(inDelta) {\n       return inDelta > 0 ? 1 : -1;\n     },\n     calcPositionDelta: function(inA, inB) {\n       var x = 0, y = 0;\n       if (inA && inB) {\n         x = inB.pageX - inA.pageX;\n         y = inB.pageY - inA.pageY;\n       }\n       return {x: x, y: y};\n     },\n     fireTrack: function(inType, inEvent, inTrackingData) {\n       var t = inTrackingData;\n       var d = this.calcPositionDelta(t.downEvent, inEvent);\n       var dd = this.calcPositionDelta(t.lastMoveEvent, inEvent);\n       if (dd.x) {\n         t.xDirection = this.clampDir(dd.x);\n       }\n       if (dd.y) {\n         t.yDirection = this.clampDir(dd.y);\n       }\n       var e = eventFactory.makeGestureEvent(inType, {\n         bubbles: true,\n         cancelable: true,\n         dx: d.x,\n         dy: d.y,\n         ddx: dd.x,\n         ddy: dd.y,\n         x: inEvent.x,\n         y: inEvent.y,\n         clientX: inEvent.clientX,\n         clientY: inEvent.clientY,\n         pageX: inEvent.pageX,\n         pageY: inEvent.pageY,\n         screenX: inEvent.screenX,\n         screenY: inEvent.screenY,\n         xDirection: t.xDirection,\n         yDirection: t.yDirection,\n         trackInfo: t.trackInfo,\n         relatedTarget: inEvent.relatedTarget,\n         pointerType: inEvent.pointerType,\n         pointerId: inEvent.pointerId,\n         _source: 'track'\n       });\n       t.downTarget.dispatchEvent(e);\n     },\n     down: function(inEvent) {\n       if (inEvent.isPrimary && (inEvent.pointerType === 'mouse' ? inEvent.buttons === 1 : true)) {\n         var p = {\n           downEvent: inEvent,\n           downTarget: inEvent.target,\n           trackInfo: {},\n           lastMoveEvent: null,\n           xDirection: 0,\n           yDirection: 0,\n           tracking: false\n         };\n         pointermap.set(inEvent.pointerId, p);\n       }\n     },\n     move: function(inEvent) {\n       var p = pointermap.get(inEvent.pointerId);\n       if (p) {\n         if (!p.tracking) {\n           var d = this.calcPositionDelta(p.downEvent, inEvent);\n           var move = d.x * d.x + d.y * d.y;\n           // start tracking only if finger moves more than WIGGLE_THRESHOLD\n           if (move > this.WIGGLE_THRESHOLD) {\n             p.tracking = true;\n             this.fireTrack('trackstart', p.downEvent, p);\n             this.fireTrack('track', inEvent, p);\n           }\n         } else {\n           this.fireTrack('track', inEvent, p);\n         }\n         p.lastMoveEvent = inEvent;\n       }\n     },\n     up: function(inEvent) {\n       var p = pointermap.get(inEvent.pointerId);\n       if (p) {\n         if (p.tracking) {\n           this.fireTrack('trackend', inEvent, p);\n         }\n         pointermap.delete(inEvent.pointerId);\n       }\n     }\n   };\n   dispatcher.registerGesture('track', track);\n })(window.PolymerGestures);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n/**\n * This event is fired when a pointer is held down for 200ms.\n *\n * @module PointerGestures\n * @submodule Events\n * @class hold\n */\n/**\n * Type of pointer that made the holding event.\n * @type String\n * @property pointerType\n */\n/**\n * Screen X axis position of the held pointer\n * @type Number\n * @property clientX\n */\n/**\n * Screen Y axis position of the held pointer\n * @type Number\n * @property clientY\n */\n/**\n * Type of pointer that made the holding event.\n * @type String\n * @property pointerType\n */\n/**\n * This event is fired every 200ms while a pointer is held down.\n *\n * @class holdpulse\n * @extends hold\n */\n/**\n * Milliseconds pointer has been held down.\n * @type Number\n * @property holdTime\n */\n/**\n * This event is fired when a held pointer is released or moved.\n *\n * @class release\n */\n\n(function(scope) {\n  var dispatcher = scope.dispatcher;\n  var eventFactory = scope.eventFactory;\n  var hold = {\n    // wait at least HOLD_DELAY ms between hold and pulse events\n    HOLD_DELAY: 200,\n    // pointer can move WIGGLE_THRESHOLD pixels before not counting as a hold\n    WIGGLE_THRESHOLD: 16,\n    events: [\n      'down',\n      'move',\n      'up',\n    ],\n    heldPointer: null,\n    holdJob: null,\n    pulse: function() {\n      var hold = Date.now() - this.heldPointer.timeStamp;\n      var type = this.held ? 'holdpulse' : 'hold';\n      this.fireHold(type, hold);\n      this.held = true;\n    },\n    cancel: function() {\n      clearInterval(this.holdJob);\n      if (this.held) {\n        this.fireHold('release');\n      }\n      this.held = false;\n      this.heldPointer = null;\n      this.target = null;\n      this.holdJob = null;\n    },\n    down: function(inEvent) {\n      if (inEvent.isPrimary && !this.heldPointer) {\n        this.heldPointer = inEvent;\n        this.target = inEvent.target;\n        this.holdJob = setInterval(this.pulse.bind(this), this.HOLD_DELAY);\n      }\n    },\n    up: function(inEvent) {\n      if (this.heldPointer && this.heldPointer.pointerId === inEvent.pointerId) {\n        this.cancel();\n      }\n    },\n    move: function(inEvent) {\n      if (this.heldPointer && this.heldPointer.pointerId === inEvent.pointerId) {\n        var x = inEvent.clientX - this.heldPointer.clientX;\n        var y = inEvent.clientY - this.heldPointer.clientY;\n        if ((x * x + y * y) > this.WIGGLE_THRESHOLD) {\n          this.cancel();\n        }\n      }\n    },\n    fireHold: function(inType, inHoldTime) {\n      var p = {\n        bubbles: true,\n        cancelable: true,\n        pointerType: this.heldPointer.pointerType,\n        pointerId: this.heldPointer.pointerId,\n        x: this.heldPointer.clientX,\n        y: this.heldPointer.clientY,\n        _source: 'hold'\n      };\n      if (inHoldTime) {\n        p.holdTime = inHoldTime;\n      }\n      var e = eventFactory.makeGestureEvent(inType, p);\n      this.target.dispatchEvent(e);\n    }\n  };\n  dispatcher.registerGesture('hold', hold);\n})(window.PolymerGestures);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n/**\n * This event is fired when a pointer quickly goes down and up, and is used to\n * denote activation.\n *\n * Any gesture event can prevent the tap event from being created by calling\n * `event.preventTap`.\n *\n * Any pointer event can prevent the tap by setting the `tapPrevented` property\n * on itself.\n *\n * @module PointerGestures\n * @submodule Events\n * @class tap\n */\n/**\n * X axis position of the tap.\n * @property x\n * @type Number\n */\n/**\n * Y axis position of the tap.\n * @property y\n * @type Number\n */\n/**\n * Type of the pointer that made the tap.\n * @property pointerType\n * @type String\n */\n(function(scope) {\n  var dispatcher = scope.dispatcher;\n  var eventFactory = scope.eventFactory;\n  var pointermap = new scope.PointerMap();\n  var tap = {\n    events: [\n      'down',\n      'up'\n    ],\n    down: function(inEvent) {\n      if (inEvent.isPrimary && !inEvent.tapPrevented) {\n        pointermap.set(inEvent.pointerId, {\n          target: inEvent.target,\n          buttons: inEvent.buttons,\n          x: inEvent.clientX,\n          y: inEvent.clientY\n        });\n      }\n    },\n    shouldTap: function(e, downState) {\n      if (e.pointerType === 'mouse') {\n        // only allow left click to tap for mouse\n        return downState.buttons === 1;\n      }\n      return !e.tapPrevented;\n    },\n    up: function(inEvent) {\n      var start = pointermap.get(inEvent.pointerId);\n      if (start && this.shouldTap(inEvent, start)) {\n        // up.relatedTarget is target currently under finger\n        var t = scope.targetFinding.LCA(start.target, inEvent.relatedTarget);\n        if (t) {\n          var e = eventFactory.makeGestureEvent('tap', {\n            bubbles: true,\n            cancelable: true,\n            x: inEvent.clientX,\n            y: inEvent.clientY,\n            detail: inEvent.detail,\n            pointerType: inEvent.pointerType,\n            pointerId: inEvent.pointerId,\n            altKey: inEvent.altKey,\n            ctrlKey: inEvent.ctrlKey,\n            metaKey: inEvent.metaKey,\n            shiftKey: inEvent.shiftKey,\n            _source: 'tap'\n          });\n          t.dispatchEvent(e);\n        }\n      }\n      pointermap.delete(inEvent.pointerId);\n    }\n  };\n  // patch eventFactory to remove id from tap's pointermap for preventTap calls\n  eventFactory.preventTap = function(e) {\n    return function() {\n      e.tapPrevented = true;\n      pointermap.delete(e.pointerId);\n    };\n  };\n  dispatcher.registerGesture('tap', tap);\n})(window.PolymerGestures);\n","/*\n  Copyright (C) 2013 Ariya Hidayat <ariya.hidayat@gmail.com>\n  Copyright (C) 2013 Thaddee Tyl <thaddee.tyl@gmail.com>\n  Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>\n  Copyright (C) 2012 Mathias Bynens <mathias@qiwi.be>\n  Copyright (C) 2012 Joost-Wim Boekesteijn <joost-wim@boekesteijn.nl>\n  Copyright (C) 2012 Kris Kowal <kris.kowal@cixar.com>\n  Copyright (C) 2012 Yusuke Suzuki <utatane.tea@gmail.com>\n  Copyright (C) 2012 Arpad Borsos <arpad.borsos@googlemail.com>\n  Copyright (C) 2011 Ariya Hidayat <ariya.hidayat@gmail.com>\n\n  Redistribution and use in source and binary forms, with or without\n  modification, are permitted provided that the following conditions are met:\n\n    * Redistributions of source code must retain the above copyright\n      notice, this list of conditions and the following disclaimer.\n    * Redistributions in binary form must reproduce the above copyright\n      notice, this list of conditions and the following disclaimer in the\n      documentation and/or other materials provided with the distribution.\n\n  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY\n  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n\n(function (global) {\n    'use strict';\n\n    var Token,\n        TokenName,\n        Syntax,\n        Messages,\n        source,\n        index,\n        length,\n        delegate,\n        lookahead,\n        state;\n\n    Token = {\n        BooleanLiteral: 1,\n        EOF: 2,\n        Identifier: 3,\n        Keyword: 4,\n        NullLiteral: 5,\n        NumericLiteral: 6,\n        Punctuator: 7,\n        StringLiteral: 8\n    };\n\n    TokenName = {};\n    TokenName[Token.BooleanLiteral] = 'Boolean';\n    TokenName[Token.EOF] = '<end>';\n    TokenName[Token.Identifier] = 'Identifier';\n    TokenName[Token.Keyword] = 'Keyword';\n    TokenName[Token.NullLiteral] = 'Null';\n    TokenName[Token.NumericLiteral] = 'Numeric';\n    TokenName[Token.Punctuator] = 'Punctuator';\n    TokenName[Token.StringLiteral] = 'String';\n\n    Syntax = {\n        ArrayExpression: 'ArrayExpression',\n        BinaryExpression: 'BinaryExpression',\n        CallExpression: 'CallExpression',\n        ConditionalExpression: 'ConditionalExpression',\n        EmptyStatement: 'EmptyStatement',\n        ExpressionStatement: 'ExpressionStatement',\n        Identifier: 'Identifier',\n        Literal: 'Literal',\n        LabeledStatement: 'LabeledStatement',\n        LogicalExpression: 'LogicalExpression',\n        MemberExpression: 'MemberExpression',\n        ObjectExpression: 'ObjectExpression',\n        Program: 'Program',\n        Property: 'Property',\n        ThisExpression: 'ThisExpression',\n        UnaryExpression: 'UnaryExpression'\n    };\n\n    // Error messages should be identical to V8.\n    Messages = {\n        UnexpectedToken:  'Unexpected token %0',\n        UnknownLabel: 'Undefined label \\'%0\\'',\n        Redeclaration: '%0 \\'%1\\' has already been declared'\n    };\n\n    // Ensure the condition is true, otherwise throw an error.\n    // This is only to have a better contract semantic, i.e. another safety net\n    // to catch a logic error. The condition shall be fulfilled in normal case.\n    // Do NOT use this to enforce a certain condition on any user input.\n\n    function assert(condition, message) {\n        if (!condition) {\n            throw new Error('ASSERT: ' + message);\n        }\n    }\n\n    function isDecimalDigit(ch) {\n        return (ch >= 48 && ch <= 57);   // 0..9\n    }\n\n\n    // 7.2 White Space\n\n    function isWhiteSpace(ch) {\n        return (ch === 32) ||  // space\n            (ch === 9) ||      // tab\n            (ch === 0xB) ||\n            (ch === 0xC) ||\n            (ch === 0xA0) ||\n            (ch >= 0x1680 && '\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\uFEFF'.indexOf(String.fromCharCode(ch)) > 0);\n    }\n\n    // 7.3 Line Terminators\n\n    function isLineTerminator(ch) {\n        return (ch === 10) || (ch === 13) || (ch === 0x2028) || (ch === 0x2029);\n    }\n\n    // 7.6 Identifier Names and Identifiers\n\n    function isIdentifierStart(ch) {\n        return (ch === 36) || (ch === 95) ||  // $ (dollar) and _ (underscore)\n            (ch >= 65 && ch <= 90) ||         // A..Z\n            (ch >= 97 && ch <= 122);          // a..z\n    }\n\n    function isIdentifierPart(ch) {\n        return (ch === 36) || (ch === 95) ||  // $ (dollar) and _ (underscore)\n            (ch >= 65 && ch <= 90) ||         // A..Z\n            (ch >= 97 && ch <= 122) ||        // a..z\n            (ch >= 48 && ch <= 57);           // 0..9\n    }\n\n    // 7.6.1.1 Keywords\n\n    function isKeyword(id) {\n        return (id === 'this')\n    }\n\n    // 7.4 Comments\n\n    function skipWhitespace() {\n        while (index < length && isWhiteSpace(source.charCodeAt(index))) {\n           ++index;\n        }\n    }\n\n    function getIdentifier() {\n        var start, ch;\n\n        start = index++;\n        while (index < length) {\n            ch = source.charCodeAt(index);\n            if (isIdentifierPart(ch)) {\n                ++index;\n            } else {\n                break;\n            }\n        }\n\n        return source.slice(start, index);\n    }\n\n    function scanIdentifier() {\n        var start, id, type;\n\n        start = index;\n\n        id = getIdentifier();\n\n        // There is no keyword or literal with only one character.\n        // Thus, it must be an identifier.\n        if (id.length === 1) {\n            type = Token.Identifier;\n        } else if (isKeyword(id)) {\n            type = Token.Keyword;\n        } else if (id === 'null') {\n            type = Token.NullLiteral;\n        } else if (id === 'true' || id === 'false') {\n            type = Token.BooleanLiteral;\n        } else {\n            type = Token.Identifier;\n        }\n\n        return {\n            type: type,\n            value: id,\n            range: [start, index]\n        };\n    }\n\n\n    // 7.7 Punctuators\n\n    function scanPunctuator() {\n        var start = index,\n            code = source.charCodeAt(index),\n            code2,\n            ch1 = source[index],\n            ch2;\n\n        switch (code) {\n\n        // Check for most common single-character punctuators.\n        case 46:   // . dot\n        case 40:   // ( open bracket\n        case 41:   // ) close bracket\n        case 59:   // ; semicolon\n        case 44:   // , comma\n        case 123:  // { open curly brace\n        case 125:  // } close curly brace\n        case 91:   // [\n        case 93:   // ]\n        case 58:   // :\n        case 63:   // ?\n            ++index;\n            return {\n                type: Token.Punctuator,\n                value: String.fromCharCode(code),\n                range: [start, index]\n            };\n\n        default:\n            code2 = source.charCodeAt(index + 1);\n\n            // '=' (char #61) marks an assignment or comparison operator.\n            if (code2 === 61) {\n                switch (code) {\n                case 37:  // %\n                case 38:  // &\n                case 42:  // *:\n                case 43:  // +\n                case 45:  // -\n                case 47:  // /\n                case 60:  // <\n                case 62:  // >\n                case 124: // |\n                    index += 2;\n                    return {\n                        type: Token.Punctuator,\n                        value: String.fromCharCode(code) + String.fromCharCode(code2),\n                        range: [start, index]\n                    };\n\n                case 33: // !\n                case 61: // =\n                    index += 2;\n\n                    // !== and ===\n                    if (source.charCodeAt(index) === 61) {\n                        ++index;\n                    }\n                    return {\n                        type: Token.Punctuator,\n                        value: source.slice(start, index),\n                        range: [start, index]\n                    };\n                default:\n                    break;\n                }\n            }\n            break;\n        }\n\n        // Peek more characters.\n\n        ch2 = source[index + 1];\n\n        // Other 2-character punctuators: && ||\n\n        if (ch1 === ch2 && ('&|'.indexOf(ch1) >= 0)) {\n            index += 2;\n            return {\n                type: Token.Punctuator,\n                value: ch1 + ch2,\n                range: [start, index]\n            };\n        }\n\n        if ('<>=!+-*%&|^/'.indexOf(ch1) >= 0) {\n            ++index;\n            return {\n                type: Token.Punctuator,\n                value: ch1,\n                range: [start, index]\n            };\n        }\n\n        throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n    }\n\n    // 7.8.3 Numeric Literals\n    function scanNumericLiteral() {\n        var number, start, ch;\n\n        ch = source[index];\n        assert(isDecimalDigit(ch.charCodeAt(0)) || (ch === '.'),\n            'Numeric literal must start with a decimal digit or a decimal point');\n\n        start = index;\n        number = '';\n        if (ch !== '.') {\n            number = source[index++];\n            ch = source[index];\n\n            // Hex number starts with '0x'.\n            // Octal number starts with '0'.\n            if (number === '0') {\n                // decimal number starts with '0' such as '09' is illegal.\n                if (ch && isDecimalDigit(ch.charCodeAt(0))) {\n                    throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n                }\n            }\n\n            while (isDecimalDigit(source.charCodeAt(index))) {\n                number += source[index++];\n            }\n            ch = source[index];\n        }\n\n        if (ch === '.') {\n            number += source[index++];\n            while (isDecimalDigit(source.charCodeAt(index))) {\n                number += source[index++];\n            }\n            ch = source[index];\n        }\n\n        if (ch === 'e' || ch === 'E') {\n            number += source[index++];\n\n            ch = source[index];\n            if (ch === '+' || ch === '-') {\n                number += source[index++];\n            }\n            if (isDecimalDigit(source.charCodeAt(index))) {\n                while (isDecimalDigit(source.charCodeAt(index))) {\n                    number += source[index++];\n                }\n            } else {\n                throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n            }\n        }\n\n        if (isIdentifierStart(source.charCodeAt(index))) {\n            throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n        }\n\n        return {\n            type: Token.NumericLiteral,\n            value: parseFloat(number),\n            range: [start, index]\n        };\n    }\n\n    // 7.8.4 String Literals\n\n    function scanStringLiteral() {\n        var str = '', quote, start, ch, octal = false;\n\n        quote = source[index];\n        assert((quote === '\\'' || quote === '\"'),\n            'String literal must starts with a quote');\n\n        start = index;\n        ++index;\n\n        while (index < length) {\n            ch = source[index++];\n\n            if (ch === quote) {\n                quote = '';\n                break;\n            } else if (ch === '\\\\') {\n                ch = source[index++];\n                if (!ch || !isLineTerminator(ch.charCodeAt(0))) {\n                    switch (ch) {\n                    case 'n':\n                        str += '\\n';\n                        break;\n                    case 'r':\n                        str += '\\r';\n                        break;\n                    case 't':\n                        str += '\\t';\n                        break;\n                    case 'b':\n                        str += '\\b';\n                        break;\n                    case 'f':\n                        str += '\\f';\n                        break;\n                    case 'v':\n                        str += '\\x0B';\n                        break;\n\n                    default:\n                        str += ch;\n                        break;\n                    }\n                } else {\n                    if (ch ===  '\\r' && source[index] === '\\n') {\n                        ++index;\n                    }\n                }\n            } else if (isLineTerminator(ch.charCodeAt(0))) {\n                break;\n            } else {\n                str += ch;\n            }\n        }\n\n        if (quote !== '') {\n            throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n        }\n\n        return {\n            type: Token.StringLiteral,\n            value: str,\n            octal: octal,\n            range: [start, index]\n        };\n    }\n\n    function isIdentifierName(token) {\n        return token.type === Token.Identifier ||\n            token.type === Token.Keyword ||\n            token.type === Token.BooleanLiteral ||\n            token.type === Token.NullLiteral;\n    }\n\n    function advance() {\n        var ch;\n\n        skipWhitespace();\n\n        if (index >= length) {\n            return {\n                type: Token.EOF,\n                range: [index, index]\n            };\n        }\n\n        ch = source.charCodeAt(index);\n\n        // Very common: ( and ) and ;\n        if (ch === 40 || ch === 41 || ch === 58) {\n            return scanPunctuator();\n        }\n\n        // String literal starts with single quote (#39) or double quote (#34).\n        if (ch === 39 || ch === 34) {\n            return scanStringLiteral();\n        }\n\n        if (isIdentifierStart(ch)) {\n            return scanIdentifier();\n        }\n\n        // Dot (.) char #46 can also start a floating-point number, hence the need\n        // to check the next character.\n        if (ch === 46) {\n            if (isDecimalDigit(source.charCodeAt(index + 1))) {\n                return scanNumericLiteral();\n            }\n            return scanPunctuator();\n        }\n\n        if (isDecimalDigit(ch)) {\n            return scanNumericLiteral();\n        }\n\n        return scanPunctuator();\n    }\n\n    function lex() {\n        var token;\n\n        token = lookahead;\n        index = token.range[1];\n\n        lookahead = advance();\n\n        index = token.range[1];\n\n        return token;\n    }\n\n    function peek() {\n        var pos;\n\n        pos = index;\n        lookahead = advance();\n        index = pos;\n    }\n\n    // Throw an exception\n\n    function throwError(token, messageFormat) {\n        var error,\n            args = Array.prototype.slice.call(arguments, 2),\n            msg = messageFormat.replace(\n                /%(\\d)/g,\n                function (whole, index) {\n                    assert(index < args.length, 'Message reference must be in range');\n                    return args[index];\n                }\n            );\n\n        error = new Error(msg);\n        error.index = index;\n        error.description = msg;\n        throw error;\n    }\n\n    // Throw an exception because of the token.\n\n    function throwUnexpected(token) {\n        throwError(token, Messages.UnexpectedToken, token.value);\n    }\n\n    // Expect the next token to match the specified punctuator.\n    // If not, an exception will be thrown.\n\n    function expect(value) {\n        var token = lex();\n        if (token.type !== Token.Punctuator || token.value !== value) {\n            throwUnexpected(token);\n        }\n    }\n\n    // Return true if the next token matches the specified punctuator.\n\n    function match(value) {\n        return lookahead.type === Token.Punctuator && lookahead.value === value;\n    }\n\n    // Return true if the next token matches the specified keyword\n\n    function matchKeyword(keyword) {\n        return lookahead.type === Token.Keyword && lookahead.value === keyword;\n    }\n\n    function consumeSemicolon() {\n        // Catch the very common case first: immediately a semicolon (char #59).\n        if (source.charCodeAt(index) === 59) {\n            lex();\n            return;\n        }\n\n        skipWhitespace();\n\n        if (match(';')) {\n            lex();\n            return;\n        }\n\n        if (lookahead.type !== Token.EOF && !match('}')) {\n            throwUnexpected(lookahead);\n        }\n    }\n\n    // 11.1.4 Array Initialiser\n\n    function parseArrayInitialiser() {\n        var elements = [];\n\n        expect('[');\n\n        while (!match(']')) {\n            if (match(',')) {\n                lex();\n                elements.push(null);\n            } else {\n                elements.push(parseExpression());\n\n                if (!match(']')) {\n                    expect(',');\n                }\n            }\n        }\n\n        expect(']');\n\n        return delegate.createArrayExpression(elements);\n    }\n\n    // 11.1.5 Object Initialiser\n\n    function parseObjectPropertyKey() {\n        var token;\n\n        skipWhitespace();\n        token = lex();\n\n        // Note: This function is called only from parseObjectProperty(), where\n        // EOF and Punctuator tokens are already filtered out.\n        if (token.type === Token.StringLiteral || token.type === Token.NumericLiteral) {\n            return delegate.createLiteral(token);\n        }\n\n        return delegate.createIdentifier(token.value);\n    }\n\n    function parseObjectProperty() {\n        var token, key;\n\n        token = lookahead;\n        skipWhitespace();\n\n        if (token.type === Token.EOF || token.type === Token.Punctuator) {\n            throwUnexpected(token);\n        }\n\n        key = parseObjectPropertyKey();\n        expect(':');\n        return delegate.createProperty('init', key, parseExpression());\n    }\n\n    function parseObjectInitialiser() {\n        var properties = [];\n\n        expect('{');\n\n        while (!match('}')) {\n            properties.push(parseObjectProperty());\n\n            if (!match('}')) {\n                expect(',');\n            }\n        }\n\n        expect('}');\n\n        return delegate.createObjectExpression(properties);\n    }\n\n    // 11.1.6 The Grouping Operator\n\n    function parseGroupExpression() {\n        var expr;\n\n        expect('(');\n\n        expr = parseExpression();\n\n        expect(')');\n\n        return expr;\n    }\n\n\n    // 11.1 Primary Expressions\n\n    function parsePrimaryExpression() {\n        var type, token, expr;\n\n        if (match('(')) {\n            return parseGroupExpression();\n        }\n\n        type = lookahead.type;\n\n        if (type === Token.Identifier) {\n            expr = delegate.createIdentifier(lex().value);\n        } else if (type === Token.StringLiteral || type === Token.NumericLiteral) {\n            expr = delegate.createLiteral(lex());\n        } else if (type === Token.Keyword) {\n            if (matchKeyword('this')) {\n                lex();\n                expr = delegate.createThisExpression();\n            }\n        } else if (type === Token.BooleanLiteral) {\n            token = lex();\n            token.value = (token.value === 'true');\n            expr = delegate.createLiteral(token);\n        } else if (type === Token.NullLiteral) {\n            token = lex();\n            token.value = null;\n            expr = delegate.createLiteral(token);\n        } else if (match('[')) {\n            expr = parseArrayInitialiser();\n        } else if (match('{')) {\n            expr = parseObjectInitialiser();\n        }\n\n        if (expr) {\n            return expr;\n        }\n\n        throwUnexpected(lex());\n    }\n\n    // 11.2 Left-Hand-Side Expressions\n\n    function parseArguments() {\n        var args = [];\n\n        expect('(');\n\n        if (!match(')')) {\n            while (index < length) {\n                args.push(parseExpression());\n                if (match(')')) {\n                    break;\n                }\n                expect(',');\n            }\n        }\n\n        expect(')');\n\n        return args;\n    }\n\n    function parseNonComputedProperty() {\n        var token;\n\n        token = lex();\n\n        if (!isIdentifierName(token)) {\n            throwUnexpected(token);\n        }\n\n        return delegate.createIdentifier(token.value);\n    }\n\n    function parseNonComputedMember() {\n        expect('.');\n\n        return parseNonComputedProperty();\n    }\n\n    function parseComputedMember() {\n        var expr;\n\n        expect('[');\n\n        expr = parseExpression();\n\n        expect(']');\n\n        return expr;\n    }\n\n    function parseLeftHandSideExpression() {\n        var expr, args, property;\n\n        expr = parsePrimaryExpression();\n\n        while (true) {\n            if (match('[')) {\n                property = parseComputedMember();\n                expr = delegate.createMemberExpression('[', expr, property);\n            } else if (match('.')) {\n                property = parseNonComputedMember();\n                expr = delegate.createMemberExpression('.', expr, property);\n            } else if (match('(')) {\n                args = parseArguments();\n                expr = delegate.createCallExpression(expr, args);\n            } else {\n                break;\n            }\n        }\n\n        return expr;\n    }\n\n    // 11.3 Postfix Expressions\n\n    var parsePostfixExpression = parseLeftHandSideExpression;\n\n    // 11.4 Unary Operators\n\n    function parseUnaryExpression() {\n        var token, expr;\n\n        if (lookahead.type !== Token.Punctuator && lookahead.type !== Token.Keyword) {\n            expr = parsePostfixExpression();\n        } else if (match('+') || match('-') || match('!')) {\n            token = lex();\n            expr = parseUnaryExpression();\n            expr = delegate.createUnaryExpression(token.value, expr);\n        } else if (matchKeyword('delete') || matchKeyword('void') || matchKeyword('typeof')) {\n            throwError({}, Messages.UnexpectedToken);\n        } else {\n            expr = parsePostfixExpression();\n        }\n\n        return expr;\n    }\n\n    function binaryPrecedence(token) {\n        var prec = 0;\n\n        if (token.type !== Token.Punctuator && token.type !== Token.Keyword) {\n            return 0;\n        }\n\n        switch (token.value) {\n        case '||':\n            prec = 1;\n            break;\n\n        case '&&':\n            prec = 2;\n            break;\n\n        case '==':\n        case '!=':\n        case '===':\n        case '!==':\n            prec = 6;\n            break;\n\n        case '<':\n        case '>':\n        case '<=':\n        case '>=':\n        case 'instanceof':\n            prec = 7;\n            break;\n\n        case 'in':\n            prec = 7;\n            break;\n\n        case '+':\n        case '-':\n            prec = 9;\n            break;\n\n        case '*':\n        case '/':\n        case '%':\n            prec = 11;\n            break;\n\n        default:\n            break;\n        }\n\n        return prec;\n    }\n\n    // 11.5 Multiplicative Operators\n    // 11.6 Additive Operators\n    // 11.7 Bitwise Shift Operators\n    // 11.8 Relational Operators\n    // 11.9 Equality Operators\n    // 11.10 Binary Bitwise Operators\n    // 11.11 Binary Logical Operators\n\n    function parseBinaryExpression() {\n        var expr, token, prec, stack, right, operator, left, i;\n\n        left = parseUnaryExpression();\n\n        token = lookahead;\n        prec = binaryPrecedence(token);\n        if (prec === 0) {\n            return left;\n        }\n        token.prec = prec;\n        lex();\n\n        right = parseUnaryExpression();\n\n        stack = [left, token, right];\n\n        while ((prec = binaryPrecedence(lookahead)) > 0) {\n\n            // Reduce: make a binary expression from the three topmost entries.\n            while ((stack.length > 2) && (prec <= stack[stack.length - 2].prec)) {\n                right = stack.pop();\n                operator = stack.pop().value;\n                left = stack.pop();\n                expr = delegate.createBinaryExpression(operator, left, right);\n                stack.push(expr);\n            }\n\n            // Shift.\n            token = lex();\n            token.prec = prec;\n            stack.push(token);\n            expr = parseUnaryExpression();\n            stack.push(expr);\n        }\n\n        // Final reduce to clean-up the stack.\n        i = stack.length - 1;\n        expr = stack[i];\n        while (i > 1) {\n            expr = delegate.createBinaryExpression(stack[i - 1].value, stack[i - 2], expr);\n            i -= 2;\n        }\n\n        return expr;\n    }\n\n\n    // 11.12 Conditional Operator\n\n    function parseConditionalExpression() {\n        var expr, consequent, alternate;\n\n        expr = parseBinaryExpression();\n\n        if (match('?')) {\n            lex();\n            consequent = parseConditionalExpression();\n            expect(':');\n            alternate = parseConditionalExpression();\n\n            expr = delegate.createConditionalExpression(expr, consequent, alternate);\n        }\n\n        return expr;\n    }\n\n    // Simplification since we do not support AssignmentExpression.\n    var parseExpression = parseConditionalExpression;\n\n    // Polymer Syntax extensions\n\n    // Filter ::\n    //   Identifier\n    //   Identifier \"(\" \")\"\n    //   Identifier \"(\" FilterArguments \")\"\n\n    function parseFilter() {\n        var identifier, args;\n\n        identifier = lex();\n\n        if (identifier.type !== Token.Identifier) {\n            throwUnexpected(identifier);\n        }\n\n        args = match('(') ? parseArguments() : [];\n\n        return delegate.createFilter(identifier.value, args);\n    }\n\n    // Filters ::\n    //   \"|\" Filter\n    //   Filters \"|\" Filter\n\n    function parseFilters() {\n        while (match('|')) {\n            lex();\n            parseFilter();\n        }\n    }\n\n    // TopLevel ::\n    //   LabelledExpressions\n    //   AsExpression\n    //   InExpression\n    //   FilterExpression\n\n    // AsExpression ::\n    //   FilterExpression as Identifier\n\n    // InExpression ::\n    //   Identifier, Identifier in FilterExpression\n    //   Identifier in FilterExpression\n\n    // FilterExpression ::\n    //   Expression\n    //   Expression Filters\n\n    function parseTopLevel() {\n        skipWhitespace();\n        peek();\n\n        var expr = parseExpression();\n        if (expr) {\n            if (lookahead.value === ',' || lookahead.value == 'in' &&\n                       expr.type === Syntax.Identifier) {\n                parseInExpression(expr);\n            } else {\n                parseFilters();\n                if (lookahead.value === 'as') {\n                    parseAsExpression(expr);\n                } else {\n                    delegate.createTopLevel(expr);\n                }\n            }\n        }\n\n        if (lookahead.type !== Token.EOF) {\n            throwUnexpected(lookahead);\n        }\n    }\n\n    function parseAsExpression(expr) {\n        lex();  // as\n        var identifier = lex().value;\n        delegate.createAsExpression(expr, identifier);\n    }\n\n    function parseInExpression(identifier) {\n        var indexName;\n        if (lookahead.value === ',') {\n            lex();\n            if (lookahead.type !== Token.Identifier)\n                throwUnexpected(lookahead);\n            indexName = lex().value;\n        }\n\n        lex();  // in\n        var expr = parseExpression();\n        parseFilters();\n        delegate.createInExpression(identifier.name, indexName, expr);\n    }\n\n    function parse(code, inDelegate) {\n        delegate = inDelegate;\n        source = code;\n        index = 0;\n        length = source.length;\n        lookahead = null;\n        state = {\n            labelSet: {}\n        };\n\n        return parseTopLevel();\n    }\n\n    global.esprima = {\n        parse: parse\n    };\n})(this);\n","// Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n// This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n// The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n// The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n// Code distributed by Google as part of the polymer project is also\n// subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n\n(function (global) {\n  'use strict';\n\n  function prepareBinding(expressionText, name, node, filterRegistry) {\n    var expression;\n    try {\n      expression = getExpression(expressionText);\n      if (expression.scopeIdent &&\n          (node.nodeType !== Node.ELEMENT_NODE ||\n           node.tagName !== 'TEMPLATE' ||\n           (name !== 'bind' && name !== 'repeat'))) {\n        throw Error('as and in can only be used within <template bind/repeat>');\n      }\n    } catch (ex) {\n      console.error('Invalid expression syntax: ' + expressionText, ex);\n      return;\n    }\n\n    return function(model, node, oneTime) {\n      var binding = expression.getBinding(model, filterRegistry, oneTime);\n      if (expression.scopeIdent && binding) {\n        node.polymerExpressionScopeIdent_ = expression.scopeIdent;\n        if (expression.indexIdent)\n          node.polymerExpressionIndexIdent_ = expression.indexIdent;\n      }\n\n      return binding;\n    }\n  }\n\n  // TODO(rafaelw): Implement simple LRU.\n  var expressionParseCache = Object.create(null);\n\n  function getExpression(expressionText) {\n    var expression = expressionParseCache[expressionText];\n    if (!expression) {\n      var delegate = new ASTDelegate();\n      esprima.parse(expressionText, delegate);\n      expression = new Expression(delegate);\n      expressionParseCache[expressionText] = expression;\n    }\n    return expression;\n  }\n\n  function Literal(value) {\n    this.value = value;\n    this.valueFn_ = undefined;\n  }\n\n  Literal.prototype = {\n    valueFn: function() {\n      if (!this.valueFn_) {\n        var value = this.value;\n        this.valueFn_ = function() {\n          return value;\n        }\n      }\n\n      return this.valueFn_;\n    }\n  }\n\n  function IdentPath(name) {\n    this.name = name;\n    this.path = Path.get(name);\n  }\n\n  IdentPath.prototype = {\n    valueFn: function() {\n      if (!this.valueFn_) {\n        var name = this.name;\n        var path = this.path;\n        this.valueFn_ = function(model, observer) {\n          if (observer)\n            observer.addPath(model, path);\n\n          return path.getValueFrom(model);\n        }\n      }\n\n      return this.valueFn_;\n    },\n\n    setValue: function(model, newValue) {\n      if (this.path.length == 1);\n        model = findScope(model, this.path[0]);\n\n      return this.path.setValueFrom(model, newValue);\n    }\n  };\n\n  function MemberExpression(object, property, accessor) {\n    this.computed = accessor == '[';\n\n    this.dynamicDeps = typeof object == 'function' ||\n                       object.dynamicDeps ||\n                       (this.computed && !(property instanceof Literal));\n\n    this.simplePath =\n        !this.dynamicDeps &&\n        (property instanceof IdentPath || property instanceof Literal) &&\n        (object instanceof MemberExpression || object instanceof IdentPath);\n\n    this.object = this.simplePath ? object : getFn(object);\n    this.property = !this.computed || this.simplePath ?\n        property : getFn(property);\n  }\n\n  MemberExpression.prototype = {\n    get fullPath() {\n      if (!this.fullPath_) {\n\n        var parts = this.object instanceof MemberExpression ?\n            this.object.fullPath.slice() : [this.object.name];\n        parts.push(this.property instanceof IdentPath ?\n            this.property.name : this.property.value);\n        this.fullPath_ = Path.get(parts);\n      }\n\n      return this.fullPath_;\n    },\n\n    valueFn: function() {\n      if (!this.valueFn_) {\n        var object = this.object;\n\n        if (this.simplePath) {\n          var path = this.fullPath;\n\n          this.valueFn_ = function(model, observer) {\n            if (observer)\n              observer.addPath(model, path);\n\n            return path.getValueFrom(model);\n          };\n        } else if (!this.computed) {\n          var path = Path.get(this.property.name);\n\n          this.valueFn_ = function(model, observer, filterRegistry) {\n            var context = object(model, observer, filterRegistry);\n\n            if (observer)\n              observer.addPath(context, path);\n\n            return path.getValueFrom(context);\n          }\n        } else {\n          // Computed property.\n          var property = this.property;\n\n          this.valueFn_ = function(model, observer, filterRegistry) {\n            var context = object(model, observer, filterRegistry);\n            var propName = property(model, observer, filterRegistry);\n            if (observer)\n              observer.addPath(context, [propName]);\n\n            return context ? context[propName] : undefined;\n          };\n        }\n      }\n      return this.valueFn_;\n    },\n\n    setValue: function(model, newValue) {\n      if (this.simplePath) {\n        this.fullPath.setValueFrom(model, newValue);\n        return newValue;\n      }\n\n      var object = this.object(model);\n      var propName = this.property instanceof IdentPath ? this.property.name :\n          this.property(model);\n      return object[propName] = newValue;\n    }\n  };\n\n  function Filter(name, args) {\n    this.name = name;\n    this.args = [];\n    for (var i = 0; i < args.length; i++) {\n      this.args[i] = getFn(args[i]);\n    }\n  }\n\n  Filter.prototype = {\n    transform: function(model, observer, filterRegistry, toModelDirection,\n                        initialArgs) {\n      var fn = filterRegistry[this.name];\n      var context = model;\n      if (fn) {\n        context = undefined;\n      } else {\n        fn = context[this.name];\n        if (!fn) {\n          console.error('Cannot find function or filter: ' + this.name);\n          return;\n        }\n      }\n\n      // If toModelDirection is falsey, then the \"normal\" (dom-bound) direction\n      // is used. Otherwise, it looks for a 'toModel' property function on the\n      // object.\n      if (toModelDirection) {\n        fn = fn.toModel;\n      } else if (typeof fn.toDOM == 'function') {\n        fn = fn.toDOM;\n      }\n\n      if (typeof fn != 'function') {\n        console.error('Cannot find function or filter: ' + this.name);\n        return;\n      }\n\n      var args = initialArgs || [];\n      for (var i = 0; i < this.args.length; i++) {\n        args.push(getFn(this.args[i])(model, observer, filterRegistry));\n      }\n\n      return fn.apply(context, args);\n    }\n  };\n\n  function notImplemented() { throw Error('Not Implemented'); }\n\n  var unaryOperators = {\n    '+': function(v) { return +v; },\n    '-': function(v) { return -v; },\n    '!': function(v) { return !v; }\n  };\n\n  var binaryOperators = {\n    '+': function(l, r) { return l+r; },\n    '-': function(l, r) { return l-r; },\n    '*': function(l, r) { return l*r; },\n    '/': function(l, r) { return l/r; },\n    '%': function(l, r) { return l%r; },\n    '<': function(l, r) { return l<r; },\n    '>': function(l, r) { return l>r; },\n    '<=': function(l, r) { return l<=r; },\n    '>=': function(l, r) { return l>=r; },\n    '==': function(l, r) { return l==r; },\n    '!=': function(l, r) { return l!=r; },\n    '===': function(l, r) { return l===r; },\n    '!==': function(l, r) { return l!==r; },\n    '&&': function(l, r) { return l&&r; },\n    '||': function(l, r) { return l||r; },\n  };\n\n  function getFn(arg) {\n    return typeof arg == 'function' ? arg : arg.valueFn();\n  }\n\n  function ASTDelegate() {\n    this.expression = null;\n    this.filters = [];\n    this.deps = {};\n    this.currentPath = undefined;\n    this.scopeIdent = undefined;\n    this.indexIdent = undefined;\n    this.dynamicDeps = false;\n  }\n\n  ASTDelegate.prototype = {\n    createUnaryExpression: function(op, argument) {\n      if (!unaryOperators[op])\n        throw Error('Disallowed operator: ' + op);\n\n      argument = getFn(argument);\n\n      return function(model, observer, filterRegistry) {\n        return unaryOperators[op](argument(model, observer, filterRegistry));\n      };\n    },\n\n    createBinaryExpression: function(op, left, right) {\n      if (!binaryOperators[op])\n        throw Error('Disallowed operator: ' + op);\n\n      left = getFn(left);\n      right = getFn(right);\n\n      return function(model, observer, filterRegistry) {\n        return binaryOperators[op](left(model, observer, filterRegistry),\n                                   right(model, observer, filterRegistry));\n      };\n    },\n\n    createConditionalExpression: function(test, consequent, alternate) {\n      test = getFn(test);\n      consequent = getFn(consequent);\n      alternate = getFn(alternate);\n\n      return function(model, observer, filterRegistry) {\n        return test(model, observer, filterRegistry) ?\n            consequent(model, observer, filterRegistry) :\n            alternate(model, observer, filterRegistry);\n      }\n    },\n\n    createIdentifier: function(name) {\n      var ident = new IdentPath(name);\n      ident.type = 'Identifier';\n      return ident;\n    },\n\n    createMemberExpression: function(accessor, object, property) {\n      var ex = new MemberExpression(object, property, accessor);\n      if (ex.dynamicDeps)\n        this.dynamicDeps = true;\n      return ex;\n    },\n\n    createCallExpression: function(expression, args) {\n      if (!(expression instanceof IdentPath))\n        throw Error('Only identifier function invocations are allowed');\n\n      var filter = new Filter(expression.name, args);\n\n      return function(model, observer, filterRegistry) {\n        return filter.transform(model, observer, filterRegistry, false);\n      };\n    },\n\n    createLiteral: function(token) {\n      return new Literal(token.value);\n    },\n\n    createArrayExpression: function(elements) {\n      for (var i = 0; i < elements.length; i++)\n        elements[i] = getFn(elements[i]);\n\n      return function(model, observer, filterRegistry) {\n        var arr = []\n        for (var i = 0; i < elements.length; i++)\n          arr.push(elements[i](model, observer, filterRegistry));\n        return arr;\n      }\n    },\n\n    createProperty: function(kind, key, value) {\n      return {\n        key: key instanceof IdentPath ? key.name : key.value,\n        value: value\n      };\n    },\n\n    createObjectExpression: function(properties) {\n      for (var i = 0; i < properties.length; i++)\n        properties[i].value = getFn(properties[i].value);\n\n      return function(model, observer, filterRegistry) {\n        var obj = {};\n        for (var i = 0; i < properties.length; i++)\n          obj[properties[i].key] =\n              properties[i].value(model, observer, filterRegistry);\n        return obj;\n      }\n    },\n\n    createFilter: function(name, args) {\n      this.filters.push(new Filter(name, args));\n    },\n\n    createAsExpression: function(expression, scopeIdent) {\n      this.expression = expression;\n      this.scopeIdent = scopeIdent;\n    },\n\n    createInExpression: function(scopeIdent, indexIdent, expression) {\n      this.expression = expression;\n      this.scopeIdent = scopeIdent;\n      this.indexIdent = indexIdent;\n    },\n\n    createTopLevel: function(expression) {\n      this.expression = expression;\n    },\n\n    createThisExpression: notImplemented\n  }\n\n  function ConstantObservable(value) {\n    this.value_ = value;\n  }\n\n  ConstantObservable.prototype = {\n    open: function() { return this.value_; },\n    discardChanges: function() { return this.value_; },\n    deliver: function() {},\n    close: function() {},\n  }\n\n  function Expression(delegate) {\n    this.scopeIdent = delegate.scopeIdent;\n    this.indexIdent = delegate.indexIdent;\n\n    if (!delegate.expression)\n      throw Error('No expression found.');\n\n    this.expression = delegate.expression;\n    getFn(this.expression); // forces enumeration of path dependencies\n\n    this.filters = delegate.filters;\n    this.dynamicDeps = delegate.dynamicDeps;\n  }\n\n  Expression.prototype = {\n    getBinding: function(model, filterRegistry, oneTime) {\n      if (oneTime)\n        return this.getValue(model, undefined, filterRegistry);\n\n      var observer = new CompoundObserver();\n      // captures deps.\n      var firstValue = this.getValue(model, observer, filterRegistry);\n      var firstTime = true;\n      var self = this;\n\n      function valueFn() {\n        // deps cannot have changed on first value retrieval.\n        if (firstTime) {\n          firstTime = false;\n          return firstValue;\n        }\n\n        if (self.dynamicDeps)\n          observer.startReset();\n\n        var value = self.getValue(model,\n                                  self.dynamicDeps ? observer : undefined,\n                                  filterRegistry);\n        if (self.dynamicDeps)\n          observer.finishReset();\n\n        return value;\n      }\n\n      function setValueFn(newValue) {\n        self.setValue(model, newValue, filterRegistry);\n        return newValue;\n      }\n\n      return new ObserverTransform(observer, valueFn, setValueFn, true);\n    },\n\n    getValue: function(model, observer, filterRegistry) {\n      var value = getFn(this.expression)(model, observer, filterRegistry);\n      for (var i = 0; i < this.filters.length; i++) {\n        value = this.filters[i].transform(model, observer, filterRegistry,\n            false, [value]);\n      }\n\n      return value;\n    },\n\n    setValue: function(model, newValue, filterRegistry) {\n      var count = this.filters ? this.filters.length : 0;\n      while (count-- > 0) {\n        newValue = this.filters[count].transform(model, undefined,\n            filterRegistry, true, [newValue]);\n      }\n\n      if (this.expression.setValue)\n        return this.expression.setValue(model, newValue);\n    }\n  }\n\n  /**\n   * Converts a style property name to a css property name. For example:\n   * \"WebkitUserSelect\" to \"-webkit-user-select\"\n   */\n  function convertStylePropertyName(name) {\n    return String(name).replace(/[A-Z]/g, function(c) {\n      return '-' + c.toLowerCase();\n    });\n  }\n\n  var parentScopeName = '@' + Math.random().toString(36).slice(2);\n\n  // Single ident paths must bind directly to the appropriate scope object.\n  // I.e. Pushed values in two-bindings need to be assigned to the actual model\n  // object.\n  function findScope(model, prop) {\n    while (model[parentScopeName] &&\n           !Object.prototype.hasOwnProperty.call(model, prop)) {\n      model = model[parentScopeName];\n    }\n\n    return model;\n  }\n\n  function isLiteralExpression(pathString) {\n    switch (pathString) {\n      case '':\n        return false;\n\n      case 'false':\n      case 'null':\n      case 'true':\n        return true;\n    }\n\n    if (!isNaN(Number(pathString)))\n      return true;\n\n    return false;\n  };\n\n  function PolymerExpressions() {}\n\n  PolymerExpressions.prototype = {\n    // \"built-in\" filters\n    styleObject: function(value) {\n      var parts = [];\n      for (var key in value) {\n        parts.push(convertStylePropertyName(key) + ': ' + value[key]);\n      }\n      return parts.join('; ');\n    },\n\n    tokenList: function(value) {\n      var tokens = [];\n      for (var key in value) {\n        if (value[key])\n          tokens.push(key);\n      }\n      return tokens.join(' ');\n    },\n\n    // binding delegate API\n    prepareInstancePositionChanged: function(template) {\n      var indexIdent = template.polymerExpressionIndexIdent_;\n      if (!indexIdent)\n        return;\n\n      return function(templateInstance, index) {\n        templateInstance.model[indexIdent] = index;\n      };\n    },\n\n    prepareBinding: function(pathString, name, node) {\n      var path = Path.get(pathString);\n\n      if (!isLiteralExpression(pathString) && path.valid) {\n        if (path.length == 1) {\n          return function(model, node, oneTime) {\n            if (oneTime)\n              return path.getValueFrom(model);\n\n            var scope = findScope(model, path[0]);\n            return new PathObserver(scope, path);\n          };\n        }\n        return; // bail out early if pathString is simple path.\n      }\n\n      return prepareBinding(pathString, name, node, this);\n    },\n\n    prepareInstanceModel: function(template) {\n      var scopeName = template.polymerExpressionScopeIdent_;\n      if (!scopeName)\n        return;\n\n      var parentScope = template.templateInstance ?\n          template.templateInstance.model :\n          template.model;\n\n      var indexName = template.polymerExpressionIndexIdent_;\n\n      return function(model) {\n        return createScopeObject(parentScope, model, scopeName, indexName);\n      };\n    }\n  };\n\n  var createScopeObject = ('__proto__' in {}) ?\n    function(parentScope, model, scopeName, indexName) {\n      var scope = {};\n      scope[scopeName] = model;\n      scope[indexName] = undefined;\n      scope[parentScopeName] = parentScope;\n      scope.__proto__ = parentScope;\n      return scope;\n    } :\n    function(parentScope, model, scopeName, indexName) {\n      var scope = Object.create(parentScope);\n      Object.defineProperty(scope, scopeName,\n          { value: model, configurable: true, writable: true });\n      Object.defineProperty(scope, indexName,\n          { value: undefined, configurable: true, writable: true });\n      Object.defineProperty(scope, parentScopeName,\n          { value: parentScope, configurable: true, writable: true });\n      return scope;\n    };\n\n  global.PolymerExpressions = PolymerExpressions;\n  PolymerExpressions.getExpression = getExpression;\n})(this);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\nPolymer = {\n  version: '0.3.3'\n};\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n// TODO(sorvell): this ensures Polymer is an object and not a function\n// Platform is currently defining it as a function to allow for async loading\n// of polymer; once we refine the loading process this likely goes away.\nif (typeof window.Polymer === 'function') {\n  Polymer = {};\n}\n\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n  // copy own properties from 'api' to 'prototype, with name hinting for 'super'\n  function extend(prototype, api) {\n    if (prototype && api) {\n      // use only own properties of 'api'\n      Object.getOwnPropertyNames(api).forEach(function(n) {\n        // acquire property descriptor\n        var pd = Object.getOwnPropertyDescriptor(api, n);\n        if (pd) {\n          // clone property via descriptor\n          Object.defineProperty(prototype, n, pd);\n          // cache name-of-method for 'super' engine\n          if (typeof pd.value == 'function') {\n            // hint the 'super' engine\n            pd.value.nom = n;\n          }\n        }\n      });\n    }\n    return prototype;\n  }\n  \n  // exports\n\n  scope.extend = extend;\n\n})(Polymer);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n  \n  // usage\n  \n  // invoke cb.call(this) in 100ms, unless the job is re-registered,\n  // which resets the timer\n  // \n  // this.myJob = this.job(this.myJob, cb, 100)\n  //\n  // returns a job handle which can be used to re-register a job\n\n  var Job = function(inContext) {\n    this.context = inContext;\n    this.boundComplete = this.complete.bind(this)\n  };\n  Job.prototype = {\n    go: function(callback, wait) {\n      this.callback = callback;\n      var h;\n      if (!wait) {\n        h = requestAnimationFrame(this.boundComplete);\n        this.handle = function() {\n          cancelAnimationFrame(h);\n        }\n      } else {\n        h = setTimeout(this.boundComplete, wait);\n        this.handle = function() {\n          clearTimeout(h);\n        }\n      }\n    },\n    stop: function() {\n      if (this.handle) {\n        this.handle();\n        this.handle = null;\n      }\n    },\n    complete: function() {\n      if (this.handle) {\n        this.stop();\n        this.callback.call(this.context);\n      }\n    }\n  };\n  \n  function job(job, callback, wait) {\n    if (job) {\n      job.stop();\n    } else {\n      job = new Job(this);\n    }\n    job.go(callback, wait);\n    return job;\n  }\n  \n  // exports \n\n  scope.job = job;\n  \n})(Polymer);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n  var registry = {};\n\n  HTMLElement.register = function(tag, prototype) {\n    registry[tag] = prototype;\n  }\n\n  // get prototype mapped to node <tag>\n  HTMLElement.getPrototypeForTag = function(tag) {\n    var prototype = !tag ? HTMLElement.prototype : registry[tag];\n    // TODO(sjmiles): creating <tag> is likely to have wasteful side-effects\n    return prototype || Object.getPrototypeOf(document.createElement(tag));\n  };\n\n  // we have to flag propagation stoppage for the event dispatcher\n  var originalStopPropagation = Event.prototype.stopPropagation;\n  Event.prototype.stopPropagation = function() {\n    this.cancelBubble = true;\n    originalStopPropagation.apply(this, arguments);\n  };\n  \n  // TODO(sorvell): remove when we're sure imports does not need\n  // to load stylesheets\n  /*\n  HTMLImports.importer.preloadSelectors += \n      ', polymer-element link[rel=stylesheet]';\n  */\n})(Polymer);\n","/*\r\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\r\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\r\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\r\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\r\n * Code distributed by Google as part of the polymer project is also\r\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\r\n */\r\n\r\n (function(scope) {\r\n    // super\r\n\r\n    // `arrayOfArgs` is an optional array of args like one might pass\r\n    // to `Function.apply`\r\n\r\n    // TODO(sjmiles):\r\n    //    $super must be installed on an instance or prototype chain\r\n    //    as `super`, and invoked via `this`, e.g.\r\n    //      `this.super();`\r\n\r\n    //    will not work if function objects are not unique, for example,\r\n    //    when using mixins.\r\n    //    The memoization strategy assumes each function exists on only one \r\n    //    prototype chain i.e. we use the function object for memoizing)\r\n    //    perhaps we can bookkeep on the prototype itself instead\r\n    function $super(arrayOfArgs) {\r\n      // since we are thunking a method call, performance is important here: \r\n      // memoize all lookups, once memoized the fast path calls no other \r\n      // functions\r\n      //\r\n      // find the caller (cannot be `strict` because of 'caller')\r\n      var caller = $super.caller;\r\n      // memoized 'name of method' \r\n      var nom = caller.nom;\r\n      // memoized next implementation prototype\r\n      var _super = caller._super;\r\n      if (!_super) {\r\n        if (!nom) {\r\n          nom = caller.nom = nameInThis.call(this, caller);\r\n        }\r\n        if (!nom) {\r\n          console.warn('called super() on a method not installed declaratively (has no .nom property)');\r\n        }\r\n        // super prototype is either cached or we have to find it\r\n        // by searching __proto__ (at the 'top')\r\n        // invariant: because we cache _super on fn below, we never reach \r\n        // here from inside a series of calls to super(), so it's ok to \r\n        // start searching from the prototype of 'this' (at the 'top')\r\n        // we must never memoize a null super for this reason\r\n        _super = memoizeSuper(caller, nom, getPrototypeOf(this));\r\n      }\r\n      // our super function\r\n      var fn = _super[nom];\r\n      if (fn) {\r\n        // memoize information so 'fn' can call 'super'\r\n        if (!fn._super) {\r\n          // must not memoize null, or we lose our invariant above\r\n          memoizeSuper(fn, nom, _super);\r\n        }\r\n        // invoke the inherited method\r\n        // if 'fn' is not function valued, this will throw\r\n        return fn.apply(this, arrayOfArgs || []);\r\n      }\r\n    }\r\n\r\n    function nameInThis(value) {\r\n      var p = this.__proto__;\r\n      while (p && p !== HTMLElement.prototype) {\r\n        // TODO(sjmiles): getOwnPropertyNames is absurdly expensive\r\n        var n$ = Object.getOwnPropertyNames(p);\r\n        for (var i=0, l=n$.length, n; i<l && (n=n$[i]); i++) {\r\n          var d = Object.getOwnPropertyDescriptor(p, n);\r\n          if (typeof d.value === 'function' && d.value === value) {\r\n            return n;\r\n          }\r\n        }\r\n        p = p.__proto__;\r\n      }\r\n    }\r\n\r\n    function memoizeSuper(method, name, proto) {\r\n      // find and cache next prototype containing `name`\r\n      // we need the prototype so we can do another lookup\r\n      // from here\r\n      var s = nextSuper(proto, name, method);\r\n      if (s[name]) {\r\n        // `s` is a prototype, the actual method is `s[name]`\r\n        // tag super method with it's name for quicker lookups\r\n        s[name].nom = name;\r\n      }\r\n      return method._super = s;\r\n    }\r\n\r\n    function nextSuper(proto, name, caller) {\r\n      // look for an inherited prototype that implements name\r\n      while (proto) {\r\n        if ((proto[name] !== caller) && proto[name]) {\r\n          return proto;\r\n        }\r\n        proto = getPrototypeOf(proto);\r\n      }\r\n      // must not return null, or we lose our invariant above\r\n      // in this case, a super() call was invoked where no superclass\r\n      // method exists\r\n      // TODO(sjmiles): thow an exception?\r\n      return Object;\r\n    }\r\n\r\n    // NOTE: In some platforms (IE10) the prototype chain is faked via \r\n    // __proto__. Therefore, always get prototype via __proto__ instead of\r\n    // the more standard Object.getPrototypeOf.\r\n    function getPrototypeOf(prototype) {\r\n      return prototype.__proto__;\r\n    }\r\n\r\n    // utility function to precompute name tags for functions\r\n    // in a (unchained) prototype\r\n    function hintSuper(prototype) {\r\n      // tag functions with their prototype name to optimize\r\n      // super call invocations\r\n      for (var n in prototype) {\r\n        var pd = Object.getOwnPropertyDescriptor(prototype, n);\r\n        if (pd && typeof pd.value === 'function') {\r\n          pd.value.nom = n;\r\n        }\r\n      }\r\n    }\r\n\r\n    // exports\r\n\r\n    scope.super = $super;\r\n\r\n})(Polymer);\r\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n  var typeHandlers = {\n    string: function(value) {\n      return value;\n    },\n    date: function(value) {\n      return new Date(Date.parse(value) || Date.now());\n    },\n    boolean: function(value) {\n      if (value === '') {\n        return true;\n      }\n      return value === 'false' ? false : !!value;\n    },\n    number: function(value) {\n      var n = parseFloat(value);\n      // hex values like \"0xFFFF\" parseFloat as 0\n      if (n === 0) {\n        n = parseInt(value);\n      }\n      return isNaN(n) ? value : n;\n      // this code disabled because encoded values (like \"0xFFFF\")\n      // do not round trip to their original format\n      //return (String(floatVal) === value) ? floatVal : value;\n    },\n    object: function(value, currentValue) {\n      if (currentValue === null) {\n        return value;\n      }\n      try {\n        // If the string is an object, we can parse is with the JSON library.\n        // include convenience replace for single-quotes. If the author omits\n        // quotes altogether, parse will fail.\n        return JSON.parse(value.replace(/'/g, '\"'));\n      } catch(e) {\n        // The object isn't valid JSON, return the raw value\n        return value;\n      }\n    },\n    // avoid deserialization of functions\n    'function': function(value, currentValue) {\n      return currentValue;\n    }\n  };\n\n  function deserializeValue(value, currentValue) {\n    // attempt to infer type from default value\n    var inferredType = typeof currentValue;\n    // invent 'date' type value for Date\n    if (currentValue instanceof Date) {\n      inferredType = 'date';\n    }\n    // delegate deserialization via type string\n    return typeHandlers[inferredType](value, currentValue);\n  }\n\n  // exports\n\n  scope.deserializeValue = deserializeValue;\n\n})(Polymer);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n(function(scope) {\n\n  // imports\n\n  var extend = scope.extend;\n\n  // module\n\n  var api = {};\n\n  api.declaration = {};\n  api.instance = {};\n\n  api.publish = function(apis, prototype) {\n    for (var n in apis) {\n      extend(prototype, apis[n]);\n    }\n  };\n\n  // exports\n\n  scope.api = api;\n\n})(Polymer);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n  var utils = {\n    /**\n      * Invokes a function asynchronously. The context of the callback\n      * function is bound to 'this' automatically.\n      * @method async\n      * @param {Function|String} method\n      * @param {any|Array} args\n      * @param {number} timeout\n      */\n    async: function(method, args, timeout) {\n      // when polyfilling Object.observe, ensure changes \n      // propagate before executing the async method\n      Platform.flush();\n      // second argument to `apply` must be an array\n      args = (args && args.length) ? args : [args];\n      // function to invoke\n      var fn = function() {\n        (this[method] || method).apply(this, args);\n      }.bind(this);\n      // execute `fn` sooner or later\n      var handle = timeout ? setTimeout(fn, timeout) :\n          requestAnimationFrame(fn);\n      // NOTE: switch on inverting handle to determine which time is used.\n      return timeout ? handle : ~handle;\n    },\n    cancelAsync: function(handle) {\n      if (handle < 0) {\n        cancelAnimationFrame(~handle);\n      } else {\n        clearTimeout(handle);\n      }\n    },\n    /**\n      * Fire an event.\n      * @method fire\n      * @returns {Object} event\n      * @param {string} type An event name.\n      * @param {any} detail\n      * @param {Node} onNode Target node.\n      */\n    fire: function(type, detail, onNode, bubbles, cancelable) {\n      var node = onNode || this;\n      var detail = detail || {};\n      var event = new CustomEvent(type, {\n        bubbles: (bubbles !== undefined ? bubbles : true), \n        cancelable: (cancelable !== undefined ? cancelable : true), \n        detail: detail\n      });\n      node.dispatchEvent(event);\n      return event;\n    },\n    /**\n      * Fire an event asynchronously.\n      * @method asyncFire\n      * @param {string} type An event name.\n      * @param detail\n      * @param {Node} toNode Target node.\n      */\n    asyncFire: function(/*inType, inDetail*/) {\n      this.async(\"fire\", arguments);\n    },\n    /**\n      * Remove class from old, add class to anew, if they exist.\n      * @param classFollows\n      * @param anew A node.\n      * @param old A node\n      * @param className\n      */\n    classFollows: function(anew, old, className) {\n      if (old) {\n        old.classList.remove(className);\n      }\n      if (anew) {\n        anew.classList.add(className);\n      }\n    },\n    /**\n      * Inject HTML which contains markup bound to this element into\n      * a target element (replacing target element content).\n      * @param String html to inject\n      * @param Element target element\n      */\n    injectBoundHTML: function(html, element) {\n      var template = document.createElement('template');\n      template.innerHTML = html;\n      var fragment = this.instanceTemplate(template);\n      if (element) {\n        element.textContent = '';\n        element.appendChild(fragment);\n      }\n      return fragment;\n    }\n  };\n\n  // no-operation function for handy stubs\n  var nop = function() {};\n\n  // null-object for handy stubs\n  var nob = {};\n\n  // deprecated\n\n  utils.asyncMethod = utils.async;\n\n  // exports\n\n  scope.api.instance.utils = utils;\n  scope.nop = nop;\n  scope.nob = nob;\n\n})(Polymer);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n  // imports\n\n  var log = window.logFlags || {};\n  var EVENT_PREFIX = 'on-';\n\n  // instance events api\n  var events = {\n    // read-only\n    EVENT_PREFIX: EVENT_PREFIX,\n    // event listeners on host\n    addHostListeners: function() {\n      var events = this.eventDelegates;\n      log.events && (Object.keys(events).length > 0) && console.log('[%s] addHostListeners:', this.localName, events);\n      // NOTE: host events look like bindings but really are not;\n      // (1) we don't want the attribute to be set and (2) we want to support\n      // multiple event listeners ('host' and 'instance') and Node.bind\n      // by default supports 1 thing being bound.\n      for (var type in events) {\n        var methodName = events[type];\n        this.addEventListener(type, this.element.getEventHandler(this, this,\n                                                                 methodName));\n      }\n    },\n    // call 'method' or function method on 'obj' with 'args', if the method exists\n    dispatchMethod: function(obj, method, args) {\n      if (obj) {\n        log.events && console.group('[%s] dispatch [%s]', obj.localName, method);\n        var fn = typeof method === 'function' ? method : obj[method];\n        if (fn) {\n          fn[args ? 'apply' : 'call'](obj, args);\n        }\n        log.events && console.groupEnd();\n        Platform.flush();\n      }\n    }\n  };\n\n  // exports\n\n  scope.api.instance.events = events;\n\n})(Polymer);\n","/*\r\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\r\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\r\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\r\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\r\n * Code distributed by Google as part of the polymer project is also\r\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\r\n */\r\n\r\n(function(scope) {\r\n\r\n  // instance api for attributes\r\n\r\n  var attributes = {\r\n    copyInstanceAttributes: function () {\r\n      var a$ = this._instanceAttributes;\r\n      for (var k in a$) {\r\n        if (!this.hasAttribute(k)) {\r\n          this.setAttribute(k, a$[k]);\r\n        }\r\n      }\r\n    },\r\n    // for each attribute on this, deserialize value to property as needed\r\n    takeAttributes: function() {\r\n      // if we have no publish lookup table, we have no attributes to take\r\n      // TODO(sjmiles): ad hoc\r\n      if (this._publishLC) {\r\n        for (var i=0, a$=this.attributes, l=a$.length, a; (a=a$[i]) && i<l; i++) {\r\n          this.attributeToProperty(a.name, a.value);\r\n        }\r\n      }\r\n    },\r\n    // if attribute 'name' is mapped to a property, deserialize\r\n    // 'value' into that property\r\n    attributeToProperty: function(name, value) {\r\n      // try to match this attribute to a property (attributes are\r\n      // all lower-case, so this is case-insensitive search)\r\n      var name = this.propertyForAttribute(name);\r\n      if (name) {\r\n        // filter out 'mustached' values, these are to be\r\n        // replaced with bound-data and are not yet values\r\n        // themselves\r\n        if (value && value.search(scope.bindPattern) >= 0) {\r\n          return;\r\n        }\r\n        // get original value\r\n        var currentValue = this[name];\r\n        // deserialize Boolean or Number values from attribute\r\n        var value = this.deserializeValue(value, currentValue);\r\n        // only act if the value has changed\r\n        if (value !== currentValue) {\r\n          // install new value (has side-effects)\r\n          this[name] = value;\r\n        }\r\n      }\r\n    },\r\n    // return the published property matching name, or undefined\r\n    propertyForAttribute: function(name) {\r\n      var match = this._publishLC && this._publishLC[name];\r\n      //console.log('propertyForAttribute:', name, 'matches', match);\r\n      return match;\r\n    },\r\n    // convert representation of 'stringValue' based on type of 'currentValue'\r\n    deserializeValue: function(stringValue, currentValue) {\r\n      return scope.deserializeValue(stringValue, currentValue);\r\n    },\r\n    serializeValue: function(value, inferredType) {\r\n      if (inferredType === 'boolean') {\r\n        return value ? '' : undefined;\r\n      } else if (inferredType !== 'object' && inferredType !== 'function'\r\n          && value !== undefined) {\r\n        return value;\r\n      }\r\n    },\r\n    reflectPropertyToAttribute: function(name) {\r\n      var inferredType = typeof this[name];\r\n      // try to intelligently serialize property value\r\n      var serializedValue = this.serializeValue(this[name], inferredType);\r\n      // boolean properties must reflect as boolean attributes\r\n      if (serializedValue !== undefined) {\r\n        this.setAttribute(name, serializedValue);\r\n        // TODO(sorvell): we should remove attr for all properties\r\n        // that have undefined serialization; however, we will need to\r\n        // refine the attr reflection system to achieve this; pica, for example,\r\n        // relies on having inferredType object properties not removed as\r\n        // attrs.\r\n      } else if (inferredType === 'boolean') {\r\n        this.removeAttribute(name);\r\n      }\r\n    }\r\n  };\r\n\r\n  // exports\r\n\r\n  scope.api.instance.attributes = attributes;\r\n\r\n})(Polymer);\r\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n  // imports\n\n  var log = window.logFlags || {};\n\n  // magic words\n\n  var OBSERVE_SUFFIX = 'Changed';\n\n  // element api\n\n  var empty = [];\n\n  var updateRecord = {\n    object: undefined,\n    type: 'update',\n    name: undefined,\n    oldValue: undefined\n  };\n\n  var numberIsNaN = Number.isNaN || function(value) {\n    return typeof value === 'number' && isNaN(value);\n  }\n\n  function areSameValue(left, right) {\n    if (left === right)\n      return left !== 0 || 1 / left === 1 / right;\n    if (numberIsNaN(left) && numberIsNaN(right))\n      return true;\n\n    return left !== left && right !== right;\n  }\n\n  // capture A's value if B's value is null or undefined,\n  // otherwise use B's value\n  function resolveBindingValue(oldValue, value) {\n    if (value === undefined && oldValue === null) {\n      return value;\n    }\n    return (value === null || value === undefined) ? oldValue : value;\n  }\n\n  var properties = {\n    createPropertyObserver: function() {\n      var n$ = this._observeNames;\n      if (n$ && n$.length) {\n        var o = this._propertyObserver = new CompoundObserver(true);\n        this.registerObserver(o);\n        // TODO(sorvell): may not be kosher to access the value here (this[n]);\n        // previously we looked at the descriptor on the prototype\n        // this doesn't work for inheritance and not for accessors without\n        // a value property\n        for (var i=0, l=n$.length, n; (i<l) && (n=n$[i]); i++) {\n          o.addPath(this, n);\n          this.observeArrayValue(n, this[n], null);\n        }\n      }\n    },\n    openPropertyObserver: function() {\n      if (this._propertyObserver) {\n        this._propertyObserver.open(this.notifyPropertyChanges, this);\n      }\n    },\n    notifyPropertyChanges: function(newValues, oldValues, paths) {\n      var name, method, called = {};\n      for (var i in oldValues) {\n        // note: paths is of form [object, path, object, path]\n        name = paths[2 * i + 1];\n        method = this.observe[name];\n        if (method) {\n          var ov = oldValues[i], nv = newValues[i];\n          // observes the value if it is an array\n          this.observeArrayValue(name, nv, ov);\n          if (!called[method]) {\n            // only invoke change method if one of ov or nv is not (undefined | null)\n            if ((ov !== undefined && ov !== null) || (nv !== undefined && nv !== null)) {\n              called[method] = true;\n              // TODO(sorvell): call method with the set of values it's expecting;\n              // e.g. 'foo bar': 'invalidate' expects the new and old values for\n              // foo and bar. Currently we give only one of these and then\n              // deliver all the arguments.\n              this.invokeMethod(method, [ov, nv, arguments]);\n            }\n          }\n        }\n      }\n    },\n    deliverChanges: function() {\n      if (this._propertyObserver) {\n        this._propertyObserver.deliver();\n      }\n    },\n    propertyChanged_: function(name, value, oldValue) {\n      if (this.reflect[name]) {\n        this.reflectPropertyToAttribute(name);\n      }\n    },\n    observeArrayValue: function(name, value, old) {\n      // we only care if there are registered side-effects\n      var callbackName = this.observe[name];\n      if (callbackName) {\n        // if we are observing the previous value, stop\n        if (Array.isArray(old)) {\n          log.observe && console.log('[%s] observeArrayValue: unregister observer [%s]', this.localName, name);\n          this.closeNamedObserver(name + '__array');\n        }\n        // if the new value is an array, being observing it\n        if (Array.isArray(value)) {\n          log.observe && console.log('[%s] observeArrayValue: register observer [%s]', this.localName, name, value);\n          var observer = new ArrayObserver(value);\n          observer.open(function(value, old) {\n            this.invokeMethod(callbackName, [old]);\n          }, this);\n          this.registerNamedObserver(name + '__array', observer);\n        }\n      }\n    },\n    emitPropertyChangeRecord: function(name, value, oldValue) {\n      var object = this;\n      if (areSameValue(value, oldValue))\n        return;\n\n      this.propertyChanged_(name, value, oldValue);\n\n      if (!Observer.hasObjectObserve)\n        return;\n\n      var notifier = this.notifier_;\n      if (!notifier)\n        notifier = this.notifier_ = Object.getNotifier(this);\n\n      updateRecord.object = this;\n      updateRecord.name = name;\n      updateRecord.oldValue = oldValue;\n\n      notifier.notify(updateRecord);\n    },\n    bindToAccessor: function(name, observable, resolveFn) {\n      var privateName = name + '_';\n      var privateObservable  = name + 'Observable_';\n\n      this[privateObservable] = observable;\n      var oldValue = this[privateName];\n\n      var self = this;\n      var value = observable.open(function(value, oldValue) {\n        self[privateName] = value;\n        self.emitPropertyChangeRecord(name, value, oldValue);\n      });\n\n      if (resolveFn && !areSameValue(oldValue, value)) {\n        var resolvedValue = resolveFn(oldValue, value);\n        if (!areSameValue(value, resolvedValue)) {\n          value = resolvedValue;\n          if (observable.setValue)\n            observable.setValue(value);\n        }\n      }\n\n      this[privateName] = value;\n      this.emitPropertyChangeRecord(name, value, oldValue);\n\n      var observer = {\n        close: function() {\n          observable.close();\n          self[privateObservable] = undefined;\n        }\n      };\n      this.registerObserver(observer);\n      return observer;\n    },\n    createComputedProperties: function() {\n      if (!this._computedNames) {\n        return;\n      }\n\n      for (var i = 0; i < this._computedNames.length; i++) {\n        var name = this._computedNames[i];\n        var expressionText = this.computed[name];\n        try {\n          var expression = PolymerExpressions.getExpression(expressionText);\n          var observable = expression.getBinding(this, this.element.syntax);\n          this.bindToAccessor(name, observable);\n        } catch (ex) {\n          console.error('Failed to create computed property', ex);\n        }\n      }\n    },\n    bindProperty: function(property, observable, oneTime) {\n      if (oneTime) {\n        this[property] = observable;\n        return;\n      }\n      return this.bindToAccessor(property, observable, resolveBindingValue);\n    },\n    invokeMethod: function(method, args) {\n      var fn = this[method] || method;\n      if (typeof fn === 'function') {\n        fn.apply(this, args);\n      }\n    },\n    registerObserver: function(observer) {\n      if (!this._observers) {\n        this._observers = [observer];\n        return;\n      }\n\n      this._observers.push(observer);\n    },\n    // observer array items are arrays of observers.\n    closeObservers: function() {\n      if (!this._observers) {\n        return;\n      }\n\n      var observers = this._observers;\n      for (var i = 0; i < observers.length; i++) {\n        var observer = observers[i];\n        if (observer && typeof observer.close == 'function') {\n          observer.close();\n        }\n      }\n\n      this._observers = [];\n    },\n    // bookkeeping observers for memory management\n    registerNamedObserver: function(name, observer) {\n      var o$ = this._namedObservers || (this._namedObservers = {});\n      o$[name] = observer;\n    },\n    closeNamedObserver: function(name) {\n      var o$ = this._namedObservers;\n      if (o$ && o$[name]) {\n        o$[name].close();\n        o$[name] = null;\n        return true;\n      }\n    },\n    closeNamedObservers: function() {\n      if (this._namedObservers) {\n        for (var i in this._namedObservers) {\n          this.closeNamedObserver(i);\n        }\n        this._namedObservers = {};\n      }\n    }\n  };\n\n  // logging\n  var LOG_OBSERVE = '[%s] watching [%s]';\n  var LOG_OBSERVED = '[%s#%s] watch: [%s] now [%s] was [%s]';\n  var LOG_CHANGED = '[%s#%s] propertyChanged: [%s] now [%s] was [%s]';\n\n  // exports\n\n  scope.api.instance.properties = properties;\n\n})(Polymer);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n  // imports\n\n  var log = window.logFlags || 0;\n\n  // element api supporting mdv\n  var mdv = {\n    instanceTemplate: function(template) {\n      // ensure a default bindingDelegate\n      var syntax = this.syntax || (!template.bindingDelegate &&\n          this.element.syntax);\n      var dom = template.createInstance(this, syntax);\n      var observers = dom.bindings_;\n      for (var i = 0; i < observers.length; i++) {\n        this.registerObserver(observers[i]);\n      }\n      return dom;\n    },\n    bind: function(name, observable, oneTime) {\n      var property = this.propertyForAttribute(name);\n      if (!property) {\n        // TODO(sjmiles): this mixin method must use the special form\n        // of `super` installed by `mixinMethod` in declaration/prototype.js\n        return this.mixinSuper(arguments);\n      } else {\n        // use n-way Polymer binding\n        var observer = this.bindProperty(property, observable, oneTime);\n        // NOTE: reflecting binding information is typically required only for\n        // tooling. It has a performance cost so it's opt-in in Node.bind.\n        if (Platform.enableBindingsReflection && observer) {\n          observer.path = observable.path_;\n          this._recordBinding(property, observer);\n        }\n        if (this.reflect[property]) {\n          this.reflectPropertyToAttribute(property);\n        }\n        return observer;\n      }\n    },\n    bindFinished: function() {\n      this.makeElementReady();\n    },\n    _recordBinding: function(name, observer) {\n      this.bindings_ = this.bindings_ || {};\n      this.bindings_[name] = observer;\n    },\n    // TODO(sorvell): unbind/unbindAll has been removed, as public api, from\n    // TemplateBinding. We still need to close/dispose of observers but perhaps\n    // we should choose a more explicit name.\n    asyncUnbindAll: function() {\n      if (!this._unbound) {\n        log.unbind && console.log('[%s] asyncUnbindAll', this.localName);\n        this._unbindAllJob = this.job(this._unbindAllJob, this.unbindAll, 0);\n      }\n    },\n    unbindAll: function() {\n      if (!this._unbound) {\n        this.closeObservers();\n        this.closeNamedObservers();\n        this._unbound = true;\n      }\n    },\n    cancelUnbindAll: function() {\n      if (this._unbound) {\n        log.unbind && console.warn('[%s] already unbound, cannot cancel unbindAll', this.localName);\n        return;\n      }\n      log.unbind && console.log('[%s] cancelUnbindAll', this.localName);\n      if (this._unbindAllJob) {\n        this._unbindAllJob = this._unbindAllJob.stop();\n      }\n    }\n  };\n\n  function unbindNodeTree(node) {\n    forNodeTree(node, _nodeUnbindAll);\n  }\n\n  function _nodeUnbindAll(node) {\n    node.unbindAll();\n  }\n\n  function forNodeTree(node, callback) {\n    if (node) {\n      callback(node);\n      for (var child = node.firstChild; child; child = child.nextSibling) {\n        forNodeTree(child, callback);\n      }\n    }\n  }\n\n  var mustachePattern = /\\{\\{([^{}]*)}}/;\n\n  // exports\n\n  scope.bindPattern = mustachePattern;\n  scope.api.instance.mdv = mdv;\n\n})(Polymer);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n  var base = {\n    PolymerBase: true,\n    job: function(job, callback, wait) {\n      if (typeof job === 'string') {\n        var n = '___' + job;\n        this[n] = Polymer.job.call(this, this[n], callback, wait);\n      } else {\n        return Polymer.job.call(this, job, callback, wait);\n      }\n    },\n    super: Polymer.super,\n    // user entry point for element has had its createdCallback called\n    created: function() {\n    },\n    // user entry point for element has shadowRoot and is ready for\n    // api interaction\n    ready: function() {\n    },\n    createdCallback: function() {\n      if (this.templateInstance && this.templateInstance.model) {\n        console.warn('Attributes on ' + this.localName + ' were data bound ' +\n            'prior to Polymer upgrading the element. This may result in ' +\n            'incorrect binding types.');\n      }\n      this.created();\n      this.prepareElement();\n      // TODO(sorvell): replace when ShadowDOMPolyfill issue is corrected\n      // https://github.com/Polymer/ShadowDOM/issues/420\n      if (!this.ownerDocument.isStagingDocument || window.ShadowDOMPolyfill) {\n        this.makeElementReady();\n      }\n    },\n    // system entry point, do not override\n    prepareElement: function() {\n      if (this._elementPrepared) {\n        console.warn('Element already prepared', this.localName);\n        return;\n      }\n      this._elementPrepared = true;\n      // storage for shadowRoots info\n      this.shadowRoots = {};\n      // install property observers\n      this.createPropertyObserver();\n      // TODO (sorvell): temporarily open observer when created\n      this.openPropertyObserver();\n      // install boilerplate attributes\n      this.copyInstanceAttributes();\n      // process input attributes\n      this.takeAttributes();\n      // add event listeners\n      this.addHostListeners();\n    },\n    makeElementReady: function() {\n      if (this._readied) {\n        return;\n      }\n      this._readied = true;\n      this.createComputedProperties();\n      // TODO(sorvell): We could create an entry point here\n      // for the user to compute property values.\n      // process declarative resources\n      this.parseDeclarations(this.__proto__);\n      // TODO(sorvell): CE polyfill uses unresolved attribute to simulate\n      // :unresolved; remove this attribute to be compatible with native\n      // CE.\n      this.removeAttribute('unresolved');\n      // user entry point\n      this.ready();\n      // TODO (sorvell): temporarily open observer when created\n      // turn on property observation and take any initial changes\n      //this.openPropertyObserver();\n    },\n    attachedCallback: function() {\n      this.cancelUnbindAll();\n      // invoke user action\n      if (this.attached) {\n        this.attached();\n      }\n      // TODO(sorvell): bc\n      if (this.enteredView) {\n        this.enteredView();\n      }\n      // NOTE: domReady can be used to access elements in dom (descendants,\n      // ancestors, siblings) such that the developer is enured to upgrade\n      // ordering. If the element definitions have loaded, domReady\n      // can be used to access upgraded elements.\n      if (!this.hasBeenAttached) {\n        this.hasBeenAttached = true;\n        if (this.domReady) {\n          this.async('domReady');\n        }\n      }\n    },\n    detachedCallback: function() {\n      if (!this.preventDispose) {\n        this.asyncUnbindAll();\n      }\n      // invoke user action\n      if (this.detached) {\n        this.detached();\n      }\n      // TODO(sorvell): bc\n      if (this.leftView) {\n        this.leftView();\n      }\n    },\n    // TODO(sorvell): bc\n    enteredViewCallback: function() {\n      this.attachedCallback();\n    },\n    // TODO(sorvell): bc\n    leftViewCallback: function() {\n      this.detachedCallback();\n    },\n    // TODO(sorvell): bc\n    enteredDocumentCallback: function() {\n      this.attachedCallback();\n    },\n    // TODO(sorvell): bc\n    leftDocumentCallback: function() {\n      this.detachedCallback();\n    },\n    // recursive ancestral <element> initialization, oldest first\n    parseDeclarations: function(p) {\n      if (p && p.element) {\n        this.parseDeclarations(p.__proto__);\n        p.parseDeclaration.call(this, p.element);\n      }\n    },\n    // parse input <element> as needed, override for custom behavior\n    parseDeclaration: function(elementElement) {\n      var template = this.fetchTemplate(elementElement);\n      if (template) {\n        var root = this.shadowFromTemplate(template);\n        this.shadowRoots[elementElement.name] = root;\n      }\n    },\n    // return a shadow-root template (if desired), override for custom behavior\n    fetchTemplate: function(elementElement) {\n      return elementElement.querySelector('template');\n    },\n    // utility function that creates a shadow root from a <template>\n    shadowFromTemplate: function(template) {\n      if (template) {\n        // make a shadow root\n        var root = this.createShadowRoot();\n        // stamp template\n        // which includes parsing and applying MDV bindings before being\n        // inserted (to avoid {{}} in attribute values)\n        // e.g. to prevent <img src=\"images/{{icon}}\"> from generating a 404.\n        var dom = this.instanceTemplate(template);\n        // append to shadow dom\n        root.appendChild(dom);\n        // perform post-construction initialization tasks on shadow root\n        this.shadowRootReady(root, template);\n        // return the created shadow root\n        return root;\n      }\n    },\n    // utility function that stamps a <template> into light-dom\n    lightFromTemplate: function(template, refNode) {\n      if (template) {\n        // TODO(sorvell): mark this element as an eventController so that\n        // event listeners on bound nodes inside it will be called on it.\n        // Note, the expectation here is that events on all descendants\n        // should be handled by this element.\n        this.eventController = this;\n        // stamp template\n        // which includes parsing and applying MDV bindings before being\n        // inserted (to avoid {{}} in attribute values)\n        // e.g. to prevent <img src=\"images/{{icon}}\"> from generating a 404.\n        var dom = this.instanceTemplate(template);\n        // append to shadow dom\n        if (refNode) {\n          this.insertBefore(dom, refNode);\n        } else {\n          this.appendChild(dom);\n        }\n        // perform post-construction initialization tasks on ahem, light root\n        this.shadowRootReady(this);\n        // return the created shadow root\n        return dom;\n      }\n    },\n    shadowRootReady: function(root) {\n      // locate nodes with id and store references to them in this.$ hash\n      this.marshalNodeReferences(root);\n      // set up polymer gestures\n      PolymerGestures.register(root);\n    },\n    // locate nodes with id and store references to them in this.$ hash\n    marshalNodeReferences: function(root) {\n      // establish $ instance variable\n      var $ = this.$ = this.$ || {};\n      // populate $ from nodes with ID from the LOCAL tree\n      if (root) {\n        var n$ = root.querySelectorAll(\"[id]\");\n        for (var i=0, l=n$.length, n; (i<l) && (n=n$[i]); i++) {\n          $[n.id] = n;\n        };\n      }\n    },\n    attributeChangedCallback: function(name, oldValue) {\n      // TODO(sjmiles): adhoc filter\n      if (name !== 'class' && name !== 'style') {\n        this.attributeToProperty(name, this.getAttribute(name));\n      }\n      if (this.attributeChanged) {\n        this.attributeChanged.apply(this, arguments);\n      }\n    },\n    onMutation: function(node, listener) {\n      var observer = new MutationObserver(function(mutations) {\n        listener.call(this, observer, mutations);\n        observer.disconnect();\n      }.bind(this));\n      observer.observe(node, {childList: true, subtree: true});\n    }\n  };\n\n  // true if object has own PolymerBase api\n  function isBase(object) {\n    return object.hasOwnProperty('PolymerBase')\n  }\n\n  // name a base constructor for dev tools\n\n  function PolymerBase() {};\n  PolymerBase.prototype = base;\n  base.constructor = PolymerBase;\n\n  // exports\n\n  scope.Base = PolymerBase;\n  scope.isBase = isBase;\n  scope.api.instance.base = base;\n\n})(Polymer);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n  // imports\n\n  var log = window.logFlags || {};\n  \n  // magic words\n  \n  var STYLE_SCOPE_ATTRIBUTE = 'element';\n  var STYLE_CONTROLLER_SCOPE = 'controller';\n  \n  var styles = {\n    STYLE_SCOPE_ATTRIBUTE: STYLE_SCOPE_ATTRIBUTE,\n    /**\n     * Installs external stylesheets and <style> elements with the attribute \n     * polymer-scope='controller' into the scope of element. This is intended\n     * to be a called during custom element construction.\n    */\n    installControllerStyles: function() {\n      // apply controller styles, but only if they are not yet applied\n      var scope = this.findStyleScope();\n      if (scope && !this.scopeHasNamedStyle(scope, this.localName)) {\n        // allow inherited controller styles\n        var proto = getPrototypeOf(this), cssText = '';\n        while (proto && proto.element) {\n          cssText += proto.element.cssTextForScope(STYLE_CONTROLLER_SCOPE);\n          proto = getPrototypeOf(proto);\n        }\n        if (cssText) {\n          this.installScopeCssText(cssText, scope);\n        }\n      }\n    },\n    installScopeStyle: function(style, name, scope) {\n      var scope = scope || this.findStyleScope(), name = name || '';\n      if (scope && !this.scopeHasNamedStyle(scope, this.localName + name)) {\n        var cssText = '';\n        if (style instanceof Array) {\n          for (var i=0, l=style.length, s; (i<l) && (s=style[i]); i++) {\n            cssText += s.textContent + '\\n\\n';\n          }\n        } else {\n          cssText = style.textContent;\n        }\n        this.installScopeCssText(cssText, scope, name);\n      }\n    },\n    installScopeCssText: function(cssText, scope, name) {\n      scope = scope || this.findStyleScope();\n      name = name || '';\n      if (!scope) {\n        return;\n      }\n      if (window.ShadowDOMPolyfill) {\n        cssText = shimCssText(cssText, scope.host);\n      }\n      var style = this.element.cssTextToScopeStyle(cssText,\n          STYLE_CONTROLLER_SCOPE);\n      Polymer.applyStyleToScope(style, scope);\n      // cache that this style has been applied\n      scope._scopeStyles[this.localName + name] = true;\n    },\n    findStyleScope: function(node) {\n      // find the shadow root that contains this element\n      var n = node || this;\n      while (n.parentNode) {\n        n = n.parentNode;\n      }\n      return n;\n    },\n    scopeHasNamedStyle: function(scope, name) {\n      scope._scopeStyles = scope._scopeStyles || {};\n      return scope._scopeStyles[name];\n    }\n  };\n  \n  // NOTE: use raw prototype traversal so that we ensure correct traversal\n  // on platforms where the protoype chain is simulated via __proto__ (IE10)\n  function getPrototypeOf(prototype) {\n    return prototype.__proto__;\n  }\n\n  function shimCssText(cssText, host) {\n    var name = '', is = false;\n    if (host) {\n      name = host.localName;\n      is = host.hasAttribute('is');\n    }\n    var selector = Platform.ShadowCSS.makeScopeSelector(name, is);\n    return Platform.ShadowCSS.shimCssText(cssText, selector);\n  }\n\n  // exports\n\n  scope.api.instance.styles = styles;\n  \n})(Polymer);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n  // imports\n\n  var extend = scope.extend;\n  var api = scope.api;\n\n  // imperative implementation: Polymer()\n\n  // specify an 'own' prototype for tag `name`\n  function element(name, prototype) {\n    if (arguments.length === 1 && typeof arguments[0] !== 'string') {\n      prototype = name;\n      var script = document._currentScript;\n      name = script && script.parentNode && script.parentNode.getAttribute ?\n          script.parentNode.getAttribute('name') : '';\n      if (!name) {\n        throw 'Element name could not be inferred.';\n      }\n    }\n    if (getRegisteredPrototype[name]) {\n      throw 'Already registered (Polymer) prototype for element ' + name;\n    }\n    // cache the prototype\n    registerPrototype(name, prototype);\n    // notify the registrar waiting for 'name', if any\n    notifyPrototype(name);\n  }\n\n  // async prototype source\n\n  function waitingForPrototype(name, client) {\n    waitPrototype[name] = client;\n  }\n\n  var waitPrototype = {};\n\n  function notifyPrototype(name) {\n    if (waitPrototype[name]) {\n      waitPrototype[name].registerWhenReady();\n      delete waitPrototype[name];\n    }\n  }\n\n  // utility and bookkeeping\n\n  // maps tag names to prototypes, as registered with\n  // Polymer. Prototypes associated with a tag name\n  // using document.registerElement are available from\n  // HTMLElement.getPrototypeForTag().\n  // If an element was fully registered by Polymer, then\n  // Polymer.getRegisteredPrototype(name) === \n  //   HTMLElement.getPrototypeForTag(name)\n\n  var prototypesByName = {};\n\n  function registerPrototype(name, prototype) {\n    return prototypesByName[name] = prototype || {};\n  }\n\n  function getRegisteredPrototype(name) {\n    return prototypesByName[name];\n  }\n\n  // exports\n\n  scope.getRegisteredPrototype = getRegisteredPrototype;\n  scope.waitingForPrototype = waitingForPrototype;\n\n  // namespace shenanigans so we can expose our scope on the registration \n  // function\n\n  // make window.Polymer reference `element()`\n\n  window.Polymer = element;\n\n  // TODO(sjmiles): find a way to do this that is less terrible\n  // copy window.Polymer properties onto `element()`\n\n  extend(Polymer, scope);\n\n  // Under the HTMLImports polyfill, scripts in the main document\n  // do not block on imports; we want to allow calls to Polymer in the main\n  // document. Platform collects those calls until we can process them, which\n  // we do here.\n\n  var declarations = Platform.deliverDeclarations();\n  if (declarations) {\n    for (var i=0, l=declarations.length, d; (i<l) && (d=declarations[i]); i++) {\n      element.apply(null, d);\n    }\n  }\n\n})(Polymer);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\nvar path = {\n  resolveElementPaths: function(node) {\n    Platform.urlResolver.resolveDom(node);\n  },\n  addResolvePathApi: function() {\n    // let assetpath attribute modify the resolve path\n    var assetPath = this.getAttribute('assetpath') || '';\n    var root = new URL(assetPath, this.ownerDocument.baseURI);\n    this.prototype.resolvePath = function(urlPath, base) {\n      var u = new URL(urlPath, base || root);\n      return u.href;\n    };\n  }\n};\n\n// exports\nscope.api.declaration.path = path;\n\n})(Polymer);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n  // imports\n\n  var log = window.logFlags || {};\n  var api = scope.api.instance.styles;\n  var STYLE_SCOPE_ATTRIBUTE = api.STYLE_SCOPE_ATTRIBUTE;\n\n  // magic words\n\n  var STYLE_SELECTOR = 'style';\n  var STYLE_LOADABLE_MATCH = '@import';\n  var SHEET_SELECTOR = 'link[rel=stylesheet]';\n  var STYLE_GLOBAL_SCOPE = 'global';\n  var SCOPE_ATTR = 'polymer-scope';\n\n  var styles = {\n    // returns true if resources are loading\n    loadStyles: function(callback) {\n      var template = this.fetchTemplate();\n      var content = template && this.templateContent();\n      if (content) {\n        this.convertSheetsToStyles(content);\n        var styles = this.findLoadableStyles(content);\n        if (styles.length) {\n          var templateUrl = template.ownerDocument.baseURI;\n          return Platform.styleResolver.loadStyles(styles, templateUrl, callback);\n        }\n      }\n      if (callback) {\n        callback();\n      }\n    },\n    convertSheetsToStyles: function(root) {\n      var s$ = root.querySelectorAll(SHEET_SELECTOR);\n      for (var i=0, l=s$.length, s, c; (i<l) && (s=s$[i]); i++) {\n        c = createStyleElement(importRuleForSheet(s, this.ownerDocument.baseURI),\n            this.ownerDocument);\n        this.copySheetAttributes(c, s);\n        s.parentNode.replaceChild(c, s);\n      }\n    },\n    copySheetAttributes: function(style, link) {\n      for (var i=0, a$=link.attributes, l=a$.length, a; (a=a$[i]) && i<l; i++) {\n        if (a.name !== 'rel' && a.name !== 'href') {\n          style.setAttribute(a.name, a.value);\n        }\n      }\n    },\n    findLoadableStyles: function(root) {\n      var loadables = [];\n      if (root) {\n        var s$ = root.querySelectorAll(STYLE_SELECTOR);\n        for (var i=0, l=s$.length, s; (i<l) && (s=s$[i]); i++) {\n          if (s.textContent.match(STYLE_LOADABLE_MATCH)) {\n            loadables.push(s);\n          }\n        }\n      }\n      return loadables;\n    },\n    /**\n     * Install external stylesheets loaded in <polymer-element> elements into the \n     * element's template.\n     * @param elementElement The <element> element to style.\n     */\n    installSheets: function() {\n      this.cacheSheets();\n      this.cacheStyles();\n      this.installLocalSheets();\n      this.installGlobalStyles();\n    },\n    /**\n     * Remove all sheets from element and store for later use.\n     */\n    cacheSheets: function() {\n      this.sheets = this.findNodes(SHEET_SELECTOR);\n      this.sheets.forEach(function(s) {\n        if (s.parentNode) {\n          s.parentNode.removeChild(s);\n        }\n      });\n    },\n    cacheStyles: function() {\n      this.styles = this.findNodes(STYLE_SELECTOR + '[' + SCOPE_ATTR + ']');\n      this.styles.forEach(function(s) {\n        if (s.parentNode) {\n          s.parentNode.removeChild(s);\n        }\n      });\n    },\n    /**\n     * Takes external stylesheets loaded in an <element> element and moves\n     * their content into a <style> element inside the <element>'s template.\n     * The sheet is then removed from the <element>. This is done only so \n     * that if the element is loaded in the main document, the sheet does\n     * not become active.\n     * Note, ignores sheets with the attribute 'polymer-scope'.\n     * @param elementElement The <element> element to style.\n     */\n    installLocalSheets: function () {\n      var sheets = this.sheets.filter(function(s) {\n        return !s.hasAttribute(SCOPE_ATTR);\n      });\n      var content = this.templateContent();\n      if (content) {\n        var cssText = '';\n        sheets.forEach(function(sheet) {\n          cssText += cssTextFromSheet(sheet) + '\\n';\n        });\n        if (cssText) {\n          var style = createStyleElement(cssText, this.ownerDocument);\n          content.insertBefore(style, content.firstChild);\n        }\n      }\n    },\n    findNodes: function(selector, matcher) {\n      var nodes = this.querySelectorAll(selector).array();\n      var content = this.templateContent();\n      if (content) {\n        var templateNodes = content.querySelectorAll(selector).array();\n        nodes = nodes.concat(templateNodes);\n      }\n      return matcher ? nodes.filter(matcher) : nodes;\n    },\n    /**\n     * Promotes external stylesheets and <style> elements with the attribute \n     * polymer-scope='global' into global scope.\n     * This is particularly useful for defining @keyframe rules which \n     * currently do not function in scoped or shadow style elements.\n     * (See wkb.ug/72462)\n     * @param elementElement The <element> element to style.\n    */\n    // TODO(sorvell): remove when wkb.ug/72462 is addressed.\n    installGlobalStyles: function() {\n      var style = this.styleForScope(STYLE_GLOBAL_SCOPE);\n      applyStyleToScope(style, document.head);\n    },\n    cssTextForScope: function(scopeDescriptor) {\n      var cssText = '';\n      // handle stylesheets\n      var selector = '[' + SCOPE_ATTR + '=' + scopeDescriptor + ']';\n      var matcher = function(s) {\n        return matchesSelector(s, selector);\n      };\n      var sheets = this.sheets.filter(matcher);\n      sheets.forEach(function(sheet) {\n        cssText += cssTextFromSheet(sheet) + '\\n\\n';\n      });\n      // handle cached style elements\n      var styles = this.styles.filter(matcher);\n      styles.forEach(function(style) {\n        cssText += style.textContent + '\\n\\n';\n      });\n      return cssText;\n    },\n    styleForScope: function(scopeDescriptor) {\n      var cssText = this.cssTextForScope(scopeDescriptor);\n      return this.cssTextToScopeStyle(cssText, scopeDescriptor);\n    },\n    cssTextToScopeStyle: function(cssText, scopeDescriptor) {\n      if (cssText) {\n        var style = createStyleElement(cssText);\n        style.setAttribute(STYLE_SCOPE_ATTRIBUTE, this.getAttribute('name') +\n            '-' + scopeDescriptor);\n        return style;\n      }\n    }\n  };\n\n  function importRuleForSheet(sheet, baseUrl) {\n    var href = new URL(sheet.getAttribute('href'), baseUrl).href;\n    return '@import \\'' + href + '\\';';\n  }\n\n  function applyStyleToScope(style, scope) {\n    if (style) {\n      if (scope === document) {\n        scope = document.head;\n      }\n      if (window.ShadowDOMPolyfill) {\n        scope = document.head;\n      }\n      // TODO(sorvell): necessary for IE\n      // see https://connect.microsoft.com/IE/feedback/details/790212/\n      // cloning-a-style-element-and-adding-to-document-produces\n      // -unexpected-result#details\n      // var clone = style.cloneNode(true);\n      var clone = createStyleElement(style.textContent);\n      var attr = style.getAttribute(STYLE_SCOPE_ATTRIBUTE);\n      if (attr) {\n        clone.setAttribute(STYLE_SCOPE_ATTRIBUTE, attr);\n      }\n      // TODO(sorvell): probably too brittle; try to figure out \n      // where to put the element.\n      var refNode = scope.firstElementChild;\n      if (scope === document.head) {\n        var selector = 'style[' + STYLE_SCOPE_ATTRIBUTE + ']';\n        var s$ = document.head.querySelectorAll(selector);\n        if (s$.length) {\n          refNode = s$[s$.length-1].nextElementSibling;\n        }\n      }\n      scope.insertBefore(clone, refNode);\n    }\n  }\n\n  function createStyleElement(cssText, scope) {\n    scope = scope || document;\n    scope = scope.createElement ? scope : scope.ownerDocument;\n    var style = scope.createElement('style');\n    style.textContent = cssText;\n    return style;\n  }\n\n  function cssTextFromSheet(sheet) {\n    return (sheet && sheet.__resource) || '';\n  }\n\n  function matchesSelector(node, inSelector) {\n    if (matches) {\n      return matches.call(node, inSelector);\n    }\n  }\n  var p = HTMLElement.prototype;\n  var matches = p.matches || p.matchesSelector || p.webkitMatchesSelector \n      || p.mozMatchesSelector;\n  \n  // exports\n\n  scope.api.declaration.styles = styles;\n  scope.applyStyleToScope = applyStyleToScope;\n  \n})(Polymer);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n  // imports\n\n  var log = window.logFlags || {};\n  var api = scope.api.instance.events;\n  var EVENT_PREFIX = api.EVENT_PREFIX;\n  // polymer-element declarative api: events feature\n\n  var mixedCaseEventTypes = {};\n  [\n    'webkitAnimationStart',\n    'webkitAnimationEnd',\n    'webkitTransitionEnd',\n    'DOMFocusOut',\n    'DOMFocusIn',\n    'DOMMouseScroll'\n  ].forEach(function(e) {\n    mixedCaseEventTypes[e.toLowerCase()] = e;\n  });\n\n  var events = {\n    parseHostEvents: function() {\n      // our delegates map\n      var delegates = this.prototype.eventDelegates;\n      // extract data from attributes into delegates\n      this.addAttributeDelegates(delegates);\n    },\n    addAttributeDelegates: function(delegates) {\n      // for each attribute\n      for (var i=0, a; a=this.attributes[i]; i++) {\n        // does it have magic marker identifying it as an event delegate?\n        if (this.hasEventPrefix(a.name)) {\n          // if so, add the info to delegates\n          delegates[this.removeEventPrefix(a.name)] = a.value.replace('{{', '')\n              .replace('}}', '').trim();\n        }\n      }\n    },\n    // starts with 'on-'\n    hasEventPrefix: function (n) {\n      return n && (n[0] === 'o') && (n[1] === 'n') && (n[2] === '-');\n    },\n    removeEventPrefix: function(n) {\n      return n.slice(prefixLength);\n    },\n    findController: function(node) {\n      while (node.parentNode) {\n        if (node.eventController) {\n          return node.eventController;\n        }\n        node = node.parentNode;\n      }\n      return node.host;\n    },\n    getEventHandler: function(controller, target, method) {\n      var events = this;\n      return function(e) {\n        if (!controller || !controller.PolymerBase) {\n          controller = events.findController(target);\n        }\n\n        var args = [e, e.detail, e.currentTarget];\n        controller.dispatchMethod(controller, method, args);\n      };\n    },\n    prepareEventBinding: function(pathString, name, node) {\n      if (!this.hasEventPrefix(name))\n        return;\n\n      var eventType = this.removeEventPrefix(name);\n      eventType = mixedCaseEventTypes[eventType] || eventType;\n\n      var events = this;\n\n      return function(model, node, oneTime) {\n        var handler = events.getEventHandler(undefined, node, pathString);\n        node.addEventListener(eventType, handler);\n\n        if (oneTime)\n          return;\n\n        // TODO(rafaelw): This is really pointless work. Aside from the cost\n        // of these allocations, NodeBind is going to setAttribute back to its\n        // current value. Fixing this would mean changing the TemplateBinding\n        // binding delegate API.\n        function bindingValue() {\n          return '{{ ' + pathString + ' }}';\n        }\n\n        return {\n          open: bindingValue,\n          discardChanges: bindingValue,\n          close: function() {\n            node.removeEventListener(eventType, handler);\n          }\n        };\n      };\n    }\n  };\n\n  var prefixLength = EVENT_PREFIX.length;\n\n  // exports\n  scope.api.declaration.events = events;\n\n})(Polymer);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n  // element api\n\n  var properties = {\n    inferObservers: function(prototype) {\n      // called before prototype.observe is chained to inherited object\n      var observe = prototype.observe, property;\n      for (var n in prototype) {\n        if (n.slice(-7) === 'Changed') {\n          if (!observe) {\n            observe  = (prototype.observe = {});\n          }\n          property = n.slice(0, -7)\n          observe[property] = observe[property] || n;\n        }\n      }\n    },\n    explodeObservers: function(prototype) {\n      // called before prototype.observe is chained to inherited object\n      var o = prototype.observe;\n      if (o) {\n        var exploded = {};\n        for (var n in o) {\n          var names = n.split(' ');\n          for (var i=0, ni; ni=names[i]; i++) {\n            exploded[ni] = o[n];\n          }\n        }\n        prototype.observe = exploded;\n      }\n    },\n    optimizePropertyMaps: function(prototype) {\n      if (prototype.observe) {\n        // construct name list\n        var a = prototype._observeNames = [];\n        for (var n in prototype.observe) {\n          var names = n.split(' ');\n          for (var i=0, ni; ni=names[i]; i++) {\n            a.push(ni);\n          }\n        }\n      }\n      if (prototype.publish) {\n        // construct name list\n        var a = prototype._publishNames = [];\n        for (var n in prototype.publish) {\n          a.push(n);\n        }\n      }\n      if (prototype.computed) {\n        // construct name list\n        var a = prototype._computedNames = [];\n        for (var n in prototype.computed) {\n          a.push(n);\n        }\n      }\n    },\n    publishProperties: function(prototype, base) {\n      // if we have any properties to publish\n      var publish = prototype.publish;\n      if (publish) {\n        // transcribe `publish` entries onto own prototype\n        this.requireProperties(publish, prototype, base);\n        // construct map of lower-cased property names\n        prototype._publishLC = this.lowerCaseMap(publish);\n      }\n    },\n    // sync prototype to property descriptors;\n    // desriptor format contains default value and optionally a\n    // hint for reflecting the property to an attribute.\n    // e.g. {foo: 5, bar: {value: true, reflect: true}}\n    // reflect: {foo: true} is also supported\n    //\n    requireProperties: function(propertyDescriptors, prototype, base) {\n      // reflected properties\n      prototype.reflect = prototype.reflect || {};\n      // ensure a prototype value for each property\n      // and update the property's reflect to attribute status\n      for (var n in propertyDescriptors) {\n        var propertyDescriptor = propertyDescriptors[n];\n        var reflects = this.reflectHintForDescriptor(propertyDescriptor);\n        if (prototype.reflect[n] === undefined && reflects !== undefined) {\n          prototype.reflect[n] = reflects;\n        }\n        if (prototype[n] === undefined) {\n          prototype[n] = this.valueForDescriptor(propertyDescriptor);\n        }\n      }\n    },\n    valueForDescriptor: function(propertyDescriptor) {\n      var value = typeof propertyDescriptor === 'object' &&\n          propertyDescriptor ? propertyDescriptor.value : propertyDescriptor;\n      return value !== undefined ? value : null;\n    },\n    // returns the value of the descriptor's 'reflect' property or undefined\n    reflectHintForDescriptor: function(propertyDescriptor) {\n      if (typeof propertyDescriptor === 'object' &&\n          propertyDescriptor && propertyDescriptor.reflect !== undefined) {\n        return propertyDescriptor.reflect;\n      }\n    },\n    lowerCaseMap: function(properties) {\n      var map = {};\n      for (var n in properties) {\n        map[n.toLowerCase()] = n;\n      }\n      return map;\n    },\n    createPropertyAccessor: function(name) {\n      var proto = this.prototype;\n\n      var privateName = name + '_';\n      var privateObservable  = name + 'Observable_';\n      proto[privateName] = proto[name];\n\n      Object.defineProperty(proto, name, {\n        get: function() {\n          var observable = this[privateObservable];\n          if (observable)\n            observable.deliver();\n\n          return this[privateName];\n        },\n        set: function(value) {\n          var observable = this[privateObservable];\n          if (observable) {\n            observable.setValue(value);\n            return;\n          }\n\n          var oldValue = this[privateName];\n          this[privateName] = value;\n          this.emitPropertyChangeRecord(name, value, oldValue);\n\n          return value;\n        },\n        configurable: true\n      });\n    },\n    createPropertyAccessors: function(prototype) {\n      var n$ = prototype._publishNames;\n      if (n$ && n$.length) {\n        for (var i=0, l=n$.length, n, fn; (i<l) && (n=n$[i]); i++) {\n          this.createPropertyAccessor(n);\n        }\n      }\n\n      var n$ = prototype._computedNames;\n      if (n$ && n$.length) {\n        for (var i=0, l=n$.length, n, fn; (i<l) && (n=n$[i]); i++) {\n          this.createPropertyAccessor(n);\n        }\n      }\n\n    }\n  };\n\n  // exports\n\n  scope.api.declaration.properties = properties;\n\n})(Polymer);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n(function(scope) {\n\n  // magic words\n\n  var ATTRIBUTES_ATTRIBUTE = 'attributes';\n  var ATTRIBUTES_REGEX = /\\s|,/;\n\n  // attributes api\n\n  var attributes = {\n    \n    inheritAttributesObjects: function(prototype) {\n      // chain our lower-cased publish map to the inherited version\n      this.inheritObject(prototype, 'publishLC');\n      // chain our instance attributes map to the inherited version\n      this.inheritObject(prototype, '_instanceAttributes');\n    },\n\n    publishAttributes: function(prototype, base) {\n      // merge names from 'attributes' attribute\n      var attributes = this.getAttribute(ATTRIBUTES_ATTRIBUTE);\n      if (attributes) {\n        // get properties to publish\n        var publish = prototype.publish || (prototype.publish = {});\n        // names='a b c' or names='a,b,c'\n        var names = attributes.split(ATTRIBUTES_REGEX);\n        // record each name for publishing\n        for (var i=0, l=names.length, n; i<l; i++) {\n          // remove excess ws\n          n = names[i].trim();\n          // if the user hasn't specified a value, we want to use the\n          // default, unless a superclass has already chosen one\n          if (n && publish[n] === undefined) {\n            // TODO(sjmiles): querying native properties on IE11 (and possibly\n            // on other browsers) throws an exception because there is no actual\n            // instance.\n            // In fact, trying to publish native properties is known bad for this\n            // and other reasons, and we need to solve this problem writ large.\n            try {\n              var hasValue = (base[n] !== undefined);\n            } catch(x) {\n              hasValue = false;\n            }\n            // supply an empty 'descriptor' object and let the publishProperties\n            // code determine a default\n            if (!hasValue) {\n              publish[n] = Polymer.nob;\n            }\n          }\n        }\n      }\n    },\n\n    // record clonable attributes from <element>\n    accumulateInstanceAttributes: function() {\n      // inherit instance attributes\n      var clonable = this.prototype._instanceAttributes;\n      // merge attributes from element\n      var a$ = this.attributes;\n      for (var i=0, l=a$.length, a; (i<l) && (a=a$[i]); i++) {  \n        if (this.isInstanceAttribute(a.name)) {\n          clonable[a.name] = a.value;\n        }\n      }\n    },\n\n    isInstanceAttribute: function(name) {\n      return !this.blackList[name] && name.slice(0,3) !== 'on-';\n    },\n\n    // do not clone these attributes onto instances\n    blackList: {\n      name: 1,\n      'extends': 1,\n      constructor: 1,\n      noscript: 1,\n      assetpath: 1,\n      'cache-csstext': 1\n    }\n    \n  };\n\n  // add ATTRIBUTES_ATTRIBUTE to the blacklist\n  attributes.blackList[ATTRIBUTES_ATTRIBUTE] = 1;\n\n  // exports\n\n  scope.api.declaration.attributes = attributes;\n\n})(Polymer);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n  // imports\n  var events = scope.api.declaration.events;\n\n  var syntax = new PolymerExpressions();\n  var prepareBinding = syntax.prepareBinding;\n\n  // Polymer takes a first crack at the binding to see if it's a declarative\n  // event handler.\n  syntax.prepareBinding = function(pathString, name, node) {\n    return events.prepareEventBinding(pathString, name, node) ||\n           prepareBinding.call(syntax, pathString, name, node);\n  };\n\n  // declaration api supporting mdv\n  var mdv = {\n    syntax: syntax,\n    fetchTemplate: function() {\n      return this.querySelector('template');\n    },\n    templateContent: function() {\n      var template = this.fetchTemplate();\n      return template && Platform.templateContent(template);\n    },\n    installBindingDelegate: function(template) {\n      if (template) {\n        template.bindingDelegate = this.syntax;\n      }\n    }\n  };\n\n  // exports\n  scope.api.declaration.mdv = mdv;\n\n})(Polymer);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n  // imports\n  \n  var api = scope.api;\n  var isBase = scope.isBase;\n  var extend = scope.extend;\n\n  // prototype api\n\n  var prototype = {\n\n    register: function(name, extendeeName) {\n      // build prototype combining extendee, Polymer base, and named api\n      this.buildPrototype(name, extendeeName);\n      // register our custom element with the platform\n      this.registerPrototype(name, extendeeName);\n      // reference constructor in a global named by 'constructor' attribute\n      this.publishConstructor();\n    },\n\n    buildPrototype: function(name, extendeeName) {\n      // get our custom prototype (before chaining)\n      var extension = scope.getRegisteredPrototype(name);\n      // get basal prototype\n      var base = this.generateBasePrototype(extendeeName);\n      // implement declarative features\n      this.desugarBeforeChaining(extension, base);\n      // join prototypes\n      this.prototype = this.chainPrototypes(extension, base);\n      // more declarative features\n      this.desugarAfterChaining(name, extendeeName);\n    },\n\n    desugarBeforeChaining: function(prototype, base) {\n      // back reference declaration element\n      // TODO(sjmiles): replace `element` with `elementElement` or `declaration`\n      prototype.element = this;\n      // transcribe `attributes` declarations onto own prototype's `publish`\n      this.publishAttributes(prototype, base);\n      // `publish` properties to the prototype and to attribute watch\n      this.publishProperties(prototype, base);\n      // infer observers for `observe` list based on method names\n      this.inferObservers(prototype);\n      // desugar compound observer syntax, e.g. 'a b c' \n      this.explodeObservers(prototype);\n    },\n\n    chainPrototypes: function(prototype, base) {\n      // chain various meta-data objects to inherited versions\n      this.inheritMetaData(prototype, base);\n      // chain custom api to inherited\n      var chained = this.chainObject(prototype, base);\n      // x-platform fixup\n      ensurePrototypeTraversal(chained);\n      return chained;\n    },\n\n    inheritMetaData: function(prototype, base) {\n      // chain observe object to inherited\n      this.inheritObject('observe', prototype, base);\n      // chain publish object to inherited\n      this.inheritObject('publish', prototype, base);\n      // chain reflect object to inherited\n      this.inheritObject('reflect', prototype, base);\n      // chain our lower-cased publish map to the inherited version\n      this.inheritObject('_publishLC', prototype, base);\n      // chain our instance attributes map to the inherited version\n      this.inheritObject('_instanceAttributes', prototype, base);\n      // chain our event delegates map to the inherited version\n      this.inheritObject('eventDelegates', prototype, base);\n    },\n\n    // implement various declarative features\n    desugarAfterChaining: function(name, extendee) {\n      // build side-chained lists to optimize iterations\n      this.optimizePropertyMaps(this.prototype);\n      this.createPropertyAccessors(this.prototype);\n      // install mdv delegate on template\n      this.installBindingDelegate(this.fetchTemplate());\n      // install external stylesheets as if they are inline\n      this.installSheets();\n      // adjust any paths in dom from imports\n      this.resolveElementPaths(this);\n      // compile list of attributes to copy to instances\n      this.accumulateInstanceAttributes();\n      // parse on-* delegates declared on `this` element\n      this.parseHostEvents();\n      //\n      // install a helper method this.resolvePath to aid in \n      // setting resource urls. e.g.\n      // this.$.image.src = this.resolvePath('images/foo.png')\n      this.addResolvePathApi();\n      // under ShadowDOMPolyfill, transforms to approximate missing CSS features\n      if (window.ShadowDOMPolyfill) {\n        Platform.ShadowCSS.shimStyling(this.templateContent(), name, extendee);\n      }\n      // allow custom element access to the declarative context\n      if (this.prototype.registerCallback) {\n        this.prototype.registerCallback(this);\n      }\n    },\n\n    // if a named constructor is requested in element, map a reference\n    // to the constructor to the given symbol\n    publishConstructor: function() {\n      var symbol = this.getAttribute('constructor');\n      if (symbol) {\n        window[symbol] = this.ctor;\n      }\n    },\n\n    // build prototype combining extendee, Polymer base, and named api\n    generateBasePrototype: function(extnds) {\n      var prototype = this.findBasePrototype(extnds);\n      if (!prototype) {\n        // create a prototype based on tag-name extension\n        var prototype = HTMLElement.getPrototypeForTag(extnds);\n        // insert base api in inheritance chain (if needed)\n        prototype = this.ensureBaseApi(prototype);\n        // memoize this base\n        memoizedBases[extnds] = prototype;\n      }\n      return prototype;\n    },\n\n    findBasePrototype: function(name) {\n      return memoizedBases[name];\n    },\n\n    // install Polymer instance api into prototype chain, as needed \n    ensureBaseApi: function(prototype) {\n      if (prototype.PolymerBase) {\n        return prototype;\n      }\n      var extended = Object.create(prototype);\n      // we need a unique copy of base api for each base prototype\n      // therefore we 'extend' here instead of simply chaining\n      api.publish(api.instance, extended);\n      // TODO(sjmiles): sharing methods across prototype chains is\n      // not supported by 'super' implementation which optimizes\n      // by memoizing prototype relationships.\n      // Probably we should have a version of 'extend' that is \n      // share-aware: it could study the text of each function,\n      // look for usage of 'super', and wrap those functions in\n      // closures.\n      // As of now, there is only one problematic method, so \n      // we just patch it manually.\n      // To avoid re-entrancy problems, the special super method\n      // installed is called `mixinSuper` and the mixin method\n      // must use this method instead of the default `super`.\n      this.mixinMethod(extended, prototype, api.instance.mdv, 'bind');\n      // return buffed-up prototype\n      return extended;\n    },\n\n    mixinMethod: function(extended, prototype, api, name) {\n      var $super = function(args) {\n        return prototype[name].apply(this, args);\n      };\n      extended[name] = function() {\n        this.mixinSuper = $super;\n        return api[name].apply(this, arguments);\n      }\n    },\n\n    // ensure prototype[name] inherits from a prototype.prototype[name]\n    inheritObject: function(name, prototype, base) {\n      // require an object\n      var source = prototype[name] || {};\n      // chain inherited properties onto a new object\n      prototype[name] = this.chainObject(source, base[name]);\n    },\n\n    // register 'prototype' to custom element 'name', store constructor \n    registerPrototype: function(name, extendee) { \n      var info = {\n        prototype: this.prototype\n      }\n      // native element must be specified in extends\n      var typeExtension = this.findTypeExtension(extendee);\n      if (typeExtension) {\n        info.extends = typeExtension;\n      }\n      // register the prototype with HTMLElement for name lookup\n      HTMLElement.register(name, this.prototype);\n      // register the custom type\n      this.ctor = document.registerElement(name, info);\n    },\n\n    findTypeExtension: function(name) {\n      if (name && name.indexOf('-') < 0) {\n        return name;\n      } else {\n        var p = this.findBasePrototype(name);\n        if (p.element) {\n          return this.findTypeExtension(p.element.extends);\n        }\n      }\n    }\n\n  };\n\n  // memoize base prototypes\n  var memoizedBases = {};\n\n  // implementation of 'chainObject' depends on support for __proto__\n  if (Object.__proto__) {\n    prototype.chainObject = function(object, inherited) {\n      if (object && inherited && object !== inherited) {\n        object.__proto__ = inherited;\n      }\n      return object;\n    }\n  } else {\n    prototype.chainObject = function(object, inherited) {\n      if (object && inherited && object !== inherited) {\n        var chained = Object.create(inherited);\n        object = extend(chained, object);\n      }\n      return object;\n    }\n  }\n\n  // On platforms that do not support __proto__ (versions of IE), the prototype\n  // chain of a custom element is simulated via installation of __proto__.\n  // Although custom elements manages this, we install it here so it's\n  // available during desugaring.\n  function ensurePrototypeTraversal(prototype) {\n    if (!Object.__proto__) {\n      var ancestor = Object.getPrototypeOf(prototype);\n      prototype.__proto__ = ancestor;\n      if (isBase(ancestor)) {\n        ancestor.__proto__ = Object.getPrototypeOf(ancestor);\n      }\n    }\n  }\n\n  // exports\n\n  api.declaration.prototype = prototype;\n\n})(Polymer);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n  /*\n\n    Elements are added to a registration queue so that they register in \n    the proper order at the appropriate time. We do this for a few reasons:\n\n    * to enable elements to load resources (like stylesheets) \n    asynchronously. We need to do this until the platform provides an efficient\n    alternative. One issue is that remote @import stylesheets are \n    re-fetched whenever stamped into a shadowRoot.\n\n    * to ensure elements loaded 'at the same time' (e.g. via some set of\n    imports) are registered as a batch. This allows elements to be enured from\n    upgrade ordering as long as they query the dom tree 1 task after\n    upgrade (aka domReady). This is a performance tradeoff. On the one hand,\n    elements that could register while imports are loading are prevented from \n    doing so. On the other, grouping upgrades into a single task means less\n    incremental work (for example style recalcs),  Also, we can ensure the \n    document is in a known state at the single quantum of time when \n    elements upgrade.\n\n  */\n  var queue = {\n    // tell the queue to wait for an element to be ready\n    wait: function(element, check, go) {\n      var shouldAdd = (this.indexOf(element) === -1 && \n          flushQueue.indexOf(element) === -1);\n      if (shouldAdd) {\n        this.add(element);\n        element.__check = check;\n        element.__go = go;\n      }\n      return (this.indexOf(element) !== 0);\n    },\n    add: function(element) {\n      //console.log('queueing', element.name);\n      queueForElement(element).push(element);\n    },\n    indexOf: function(element) {\n      var i = queueForElement(element).indexOf(element);\n      if (i >= 0 && document.contains(element)) {\n        i += (HTMLImports.useNative || HTMLImports.ready) ? \n          importQueue.length : 1e9;\n      }\n      return i;  \n    },\n    // tell the queue an element is ready to be registered\n    go: function(element) {\n      var readied = this.remove(element);\n      if (readied) {\n        this.addToFlushQueue(readied);\n        this.check();\n      }\n    },\n    remove: function(element) {\n      var i = this.indexOf(element);\n      if (i !== 0) {\n        //console.warn('queue order wrong', i);\n        return;\n      }\n      return queueForElement(element).shift();\n    },\n    check: function() {\n      // next\n      var element = this.nextElement();\n      if (element) {\n        element.__check.call(element);\n      }\n      if (this.canReady()) {\n        this.ready();\n        return true;\n      }\n    },\n    nextElement: function() {\n      return nextQueued();\n    },\n    canReady: function() {\n      return !this.waitToReady && this.isEmpty();\n    },\n    isEmpty: function() {\n      return !importQueue.length && !mainQueue.length;\n    },\n    addToFlushQueue: function(element) {\n      flushQueue.push(element);  \n    },\n    flush: function() {\n      var element;\n      while (flushQueue.length) {\n        element = flushQueue.shift();\n        element.__go.call(element);\n        element.__check = element.__go = null;\n      }\n    },\n    ready: function() {\n      this.flush();\n      // TODO(sorvell): As an optimization, turn off CE polyfill upgrading\n      // while registering. This way we avoid having to upgrade each document\n      // piecemeal per registration and can instead register all elements\n      // and upgrade once in a batch. Without this optimization, upgrade time\n      // degrades significantly when SD polyfill is used. This is mainly because\n      // querying the document tree for elements is slow under the SD polyfill.\n      if (CustomElements.ready === false) {\n        CustomElements.upgradeDocumentTree(document);\n        CustomElements.ready = true;\n      }\n      Platform.flush();\n      requestAnimationFrame(this.flushReadyCallbacks);\n    },\n    addReadyCallback: function(callback) {\n      if (callback) {\n        readyCallbacks.push(callback);\n      }\n    },\n    flushReadyCallbacks: function() {\n      if (readyCallbacks) {\n        var fn;\n        while (readyCallbacks.length) {\n          fn = readyCallbacks.shift();\n          fn();\n        }\n      }\n    },\n    waitToReady: true\n  };\n\n  var flushQueue = [];\n\n  var importQueue = [];\n  var mainQueue = [];\n  var readyCallbacks = [];\n\n  function queueForElement(element) {\n    return document.contains(element) ? mainQueue : importQueue;\n  }\n\n  function nextQueued() {\n    return importQueue.length ? importQueue[0] : mainQueue[0];\n  }\n\n  var polymerReadied = false; \n\n  document.addEventListener('WebComponentsReady', function() {\n    CustomElements.ready = false;\n  });\n  \n  function whenPolymerReady(callback) {\n    queue.waitToReady = true;\n    CustomElements.ready = false;\n    HTMLImports.whenImportsReady(function() {\n      queue.addReadyCallback(callback);\n      queue.waitToReady = false;\n      queue.check();\n    });\n  }\n\n  // exports\n  scope.queue = queue;\n  scope.whenPolymerReady = whenPolymerReady;\n})(Polymer);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n  var whenPolymerReady = scope.whenPolymerReady;\n\n  function importElements(elementOrFragment, callback) {\n    if (elementOrFragment) {\n      document.head.appendChild(elementOrFragment);\n      whenPolymerReady(callback);\n    } else if (callback) {\n      callback();\n    }\n  }\n\n  function importUrls(urls, callback) {\n    if (urls && urls.length) {\n        var frag = document.createDocumentFragment();\n        for (var i=0, l=urls.length, url, link; (i<l) && (url=urls[i]); i++) {\n          link = document.createElement('link');\n          link.rel = 'import';\n          link.href = url;\n          frag.appendChild(link);\n        }\n        importElements(frag, callback);\n    } else if (callback) {\n      callback();\n    }\n  }\n\n  // exports\n  scope.import = importUrls;\n  scope.importElements = importElements;\n\n})(Polymer);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n  // imports\n\n  var extend = scope.extend;\n  var api = scope.api;\n  var queue = scope.queue;\n  var whenPolymerReady = scope.whenPolymerReady;\n  var getRegisteredPrototype = scope.getRegisteredPrototype;\n  var waitingForPrototype = scope.waitingForPrototype;\n\n  // declarative implementation: <polymer-element>\n\n  var prototype = extend(Object.create(HTMLElement.prototype), {\n\n    createdCallback: function() {\n      if (this.getAttribute('name')) {\n        this.init();\n      }\n    },\n\n    init: function() {\n      // fetch declared values\n      this.name = this.getAttribute('name');\n      this.extends = this.getAttribute('extends');\n      // initiate any async resource fetches\n      this.loadResources();\n      // register when all constraints are met\n      this.registerWhenReady();\n    },\n\n    registerWhenReady: function() {\n     if (this.registered\n       || this.waitingForPrototype(this.name)\n       || this.waitingForQueue()\n       || this.waitingForResources()) {\n          return;\n      }\n      // TODO(sorvell): ends up calling '_register' by virtue\n      // of `waitingForQueue` (see below)\n      queue.go(this);\n    },\n\n    // TODO(sorvell): refactor, this method is private-ish, but it's being\n    // called by the queue object.\n    _register: function() {\n      //console.log('registering', this.name);\n      //console.group('registering', this.name);\n      // warn if extending from a custom element not registered via Polymer\n      if (isCustomTag(this.extends) && !isRegistered(this.extends)) {\n        console.warn('%s is attempting to extend %s, an unregistered element ' +\n            'or one that was not registered with Polymer.', this.name,\n            this.extends);\n      }\n      this.register(this.name, this.extends);\n      this.registered = true;\n      //console.groupEnd();\n    },\n\n    waitingForPrototype: function(name) {\n      if (!getRegisteredPrototype(name)) {\n        // then wait for a prototype\n        waitingForPrototype(name, this);\n        // emulate script if user is not supplying one\n        this.handleNoScript(name);\n        // prototype not ready yet\n        return true;\n      }\n    },\n\n    handleNoScript: function(name) {\n      // if explicitly marked as 'noscript'\n      if (this.hasAttribute('noscript') && !this.noscript) {\n        this.noscript = true;\n        // TODO(sorvell): CustomElements polyfill awareness:\n        // noscript elements should upgrade in logical order\n        // script injection ensures this under native custom elements;\n        // under imports + ce polyfills, scripts run before upgrades.\n        // dependencies should be ready at upgrade time so register\n        // prototype at this time.\n        if (window.CustomElements && !CustomElements.useNative) {\n          Polymer(name);\n        } else {\n          var script = document.createElement('script');\n          script.textContent = 'Polymer(\\'' + name + '\\');';\n          this.appendChild(script);\n        }\n      }\n    },\n\n    waitingForResources: function() {\n      return this._needsResources;\n    },\n\n    // NOTE: Elements must be queued in proper order for inheritance/composition\n    // dependency resolution. Previously this was enforced for inheritance,\n    // and by rule for composition. It's now entirely by rule.\n    waitingForQueue: function() {\n      return queue.wait(this, this.registerWhenReady, this._register);\n    },\n\n    loadResources: function() {\n      this._needsResources = true;\n      this.loadStyles(function() {\n        this._needsResources = false;\n        this.registerWhenReady();\n      }.bind(this));\n    }\n\n  });\n\n  // semi-pluggable APIs \n\n  // TODO(sjmiles): should be fully pluggable (aka decoupled, currently\n  // the various plugins are allowed to depend on each other directly)\n  api.publish(api.declaration, prototype);\n\n  // utility and bookkeeping\n\n  function isRegistered(name) {\n    return Boolean(HTMLElement.getPrototypeForTag(name));\n  }\n\n  function isCustomTag(name) {\n    return (name && name.indexOf('-') >= 0);\n  }\n\n  // boot tasks\n\n  whenPolymerReady(function() {\n    document.body.removeAttribute('unresolved');\n    document.dispatchEvent(\n      new CustomEvent('polymer-ready', {bubbles: true})\n    );\n  });\n\n  // register polymer-element with document\n\n  document.registerElement('polymer-element', {prototype: prototype});\n\n})(Polymer);\n","/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n/**\n * The `auto-binding` element extends the template element. It provides a quick \n * and easy way to do data binding without the need to setup a model. \n * The `auto-binding` element itself serves as the model and controller for the \n * elements it contains. Both data and event handlers can be bound. \n *\n * The `auto-binding` element acts just like a template that is bound to \n * a model. It stamps its content in the dom adjacent to itself. When the \n * content is stamped, the `template-bound` event is fired.\n *\n * Example:\n *\n *     <template is=\"auto-binding\">\n *       <div>Say something: <input value=\"{{value}}\"></div>\n *       <div>You said: {{value}}</div>\n *       <button on-tap=\"{{buttonTap}}\">Tap me!</button>\n *     </template>\n *     <script>\n *       var template = document.querySelector('template');\n *       template.value = 'something';\n *       template.buttonTap = function() {\n *         console.log('tap!');\n *       };\n *     </script>\n *\n * @module Polymer\n * @status stable\n*/\n\n(function() {\n\n  var element = document.createElement('polymer-element');\n  element.setAttribute('name', 'auto-binding');\n  element.setAttribute('extends', 'template');\n  element.init();\n\n  Polymer('auto-binding', {\n\n    createdCallback: function() {\n      this.syntax = this.bindingDelegate = this.makeSyntax();\n      // delay stamping until polymer-ready so that auto-binding is not\n      // required to load last.\n      Polymer.whenPolymerReady(function() {\n        this.model = this;\n        this.setAttribute('bind', '');\n        // we don't bother with an explicit signal here, we could ust a MO\n        // if necessary\n        this.async(function() {\n          // note: this will marshall *all* the elements in the parentNode\n          // rather than just stamped ones. We'd need to use createInstance\n          // to fix this or something else fancier.\n          this.marshalNodeReferences(this.parentNode);\n          // template stamping is asynchronous so stamping isn't complete\n          // by polymer-ready; fire an event so users can use stamped elements\n          this.fire('template-bound');\n        });\n      }.bind(this));\n    },\n\n    makeSyntax: function() {\n      var events = Object.create(Polymer.api.declaration.events);\n      var self = this;\n      events.findController = function() { return self.model; };\n\n      var syntax = new PolymerExpressions();\n      var prepareBinding = syntax.prepareBinding;  \n      syntax.prepareBinding = function(pathString, name, node) {\n        return events.prepareEventBinding(pathString, name, node) ||\n               prepareBinding.call(syntax, pathString, name, node);\n      };\n      return syntax;\n    }\n\n  });\n\n})();\n"]}