{"version":3,"file":"polymer.js","sources":["polymer.concat.js"],"names":["window","PolymerGestures","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","Boolean","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","length","clientX","clientY","findTouchAction","n","i","ELEMENT_NODE","hasAttribute","getAttribute","host","LCA","a","b","contains","adepth","depth","bdepth","d","walk","u","deepContains","common","insideNode","node","rect","getBoundingClientRect","left","right","top","bottom","event","p","targetFinding","bind","shadowSelector","v","selector","rule","attrib2css","selectors","styles","hasTouchAction","style","touchAction","hasShadowRoot","ShadowDOMPolyfill","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","makePointerEvent","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","currentGestures","CLONE_PROPS","CLONE_DEFAULTS","HAS_SVG_INSTANCE","SVGElementInstance","dispatcher","IS_IOS","pointermap","requiredGestures","eventMap","eventSources","eventSourceList","gestures","dependencyMap","down","listeners","index","up","gestureQueue","registerSource","name","source","newEvents","events","registerGesture","obj","g","exposes","toLowerCase","register","initial","es","l","unregister","fireEvent","move","type","fillGestureQueue","cancel","tapPrevented","addGestureDependency","gesturesWanted","_pgEvents","ri","gk","eventHandler","_handledByPG","nodes","currentTarget","fn","listen","addEvent","unlisten","removeEvent","eventName","boundHandler","removeEventListener","makeEvent","preventDefault","_target","cloneEvent","eventCopy","correspondingUseElement","clone","gestureTrigger","rg","_requiredGestures","j","requestAnimationFrame","boundGestureTrigger","activateGesture","gesture","dep","recognizer","_pgListeners","actionNode","defaultActions","setAttribute","handler","capture","deactivateGesture","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","cleanupMouse","relatedTarget","DEDUP_TIMEOUT","Array","CLICK_COUNT_TIMEOUT","HYSTERESIS","HAS_TOUCH_ACTION","touchEvents","scrollTypes","EMITTER","XSCROLLER","YSCROLLER","touchActionToScrollType","st","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","_cancel","cleanUpPointer","shouldScroll","scrollAxis","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","nav","navigator","PointerEvent","msPointerEnabled","undefined","ontouchstart","ua","userAgent","match","track","trackx","tracky","WIGGLE_THRESHOLD","clampDir","inDelta","calcPositionDelta","inA","inB","pageX","pageY","fireTrack","inTrackingData","downEvent","lastMoveEvent","xDirection","yDirection","gestureProto","trackInfo","ddx","screenX","ddy","screenY","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","charCodeAt","getIdentifier","slice","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","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","console","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","findScope","prop","parentScopeName","hasOwnProperty","isLiteralExpression","pathString","isNaN","Number","PolymerExpressions","observer","addPath","getValueFrom","setValue","newValue","setValueFrom",{"end":{"file":"polymer.concat.js","comments_before":[],"nlb":false,"endpos":93731,"pos":93723,"col":8,"line":3221,"value":"fullPath","type":"name"},"start":{"file":"polymer.concat.js","comments_before":[],"nlb":false,"endpos":93731,"pos":93723,"col":8,"line":3221,"value":"fullPath","type":"name"},"name":"fullPath"},"fullPath","fullPath_","parts","context","propName","transform","toModelDirection","initialArgs","toModel","toDOM","apply","unaryOperators","+","-","!","binaryOperators","*","/","%","<",">","<=",">=","==","!=","===","!==","&&","||","op","argument","test","ident","filter","arr","kind","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","Platform","logFlags","flush","CustomElements","useNative","ready","takeRecords","instanceof","base","HTMLImports","wrap","unwrap","whenImportsReady","doc","mainDoc","whenDocumentReady","watchImportsLoad","isDocumentReady","readyState","requiredReadyState","checkReady","READY_EVENT","markTargetLoaded","__loaded","checkDone","loaded","loadedImport","imports","querySelectorAll","imp","isImportLoaded","link","import","__importParsed","handleImports","isImport","handleImport","localName","rel","hasNative","isIE","hasShadowDOMPolyfill","wrapIfNeeded","currentScriptDescriptor","script","currentScript","scripts","MutationObserver","mxns","addedNodes","observe","childList","readyTime","getTime","whenReady","withDependencies","task","depends","marshal","module","dependsOrFactory","moduleFactory","modules","using","modularize","insertBefore","firstChild","detectObjectObserve","recs","records","deliverChangeRecords","unobserve","detectEval","chrome","app","runtime","getDeviceStorage","f","Function","isIndex","toNumber","isObject","areSameValue","numberIsNaN","getPathCharType","char","noop","parsePath","maybeUnescapeQuote","nextChar","mode","newChar","actions","append","transition","action","typeMap","pathStateMachine","isIdent","identRegExp","privateToken","constructorIsPrivate","hasEval","compiledGetValueFromFn","getPath","pathCache","invalidPath","formatAccessor","dirtyCheck","cycles","MAX_DIRTY_CHECK_CYCLES","check_","testingExposeCycleCount","dirtyCheckCycleCount","objectIsEmpty","diffIsEmpty","diff","added","removed","changed","diffObjectFromOldObject","oldObject","isArray","runEOMTasks","eomTasks","newObservedObject","state_","OPENED","discardRecords","first","obs","arrayObserve","discard","observedObjectCache","getObservedObject","dir","newObservedSet","rootObj","rootObjProps","objects","getPrototypeOf","allRootObjNonObservedProps","rec","observers","iterateObjects_","observerCount","record","Observer","unobservedCount","observedSetCache","getObservedSet","lastObservedSet","UNOPENED","callback_","target_","directObserver_","id_","nextObserverId","addToAll","_allObserversCount","collectObservers","allObservers","removeFromAll","ObjectObserver","oldObject_","ArrayObserver","array","object_","path_","reportChangesOnOpen","reportChangesOnOpen_","observed_","identFn","observable","getValueFn","dontPassThroughSet","observable_","getValueFn_","setValueFn_","dontPassThroughSet_","diffObjectFromChangeRecords","changeRecords","oldValues","expectedRecordTypes","oldValue","newSplice","addedCount","ArraySplice","calcSplices","current","currentStart","currentEnd","old","oldStart","oldEnd","arraySplice","intersect","start1","end1","start2","end2","mergeSplice","splices","inserted","insertionOffset","intersectCount","deleteCount","prepend","offset","createInitialSplices","JSON","stringify","projectArraySplices","concat","hasObserve","createObject","proto","newObject","getOwnPropertyNames","getOwnPropertyDescriptor","identStart","identPart","RegExp","beforePath","ws","[","eof","inPath",".","beforeIdent","inIdent","0","beforeElement","'","\"","afterZero","]","inIndex","inSingleQuote","else","inDoubleQuote","afterElement","iterateObjects","runEOM","eomObj","pingPong","eomRunScheduled","CLOSED","RESETTING","connect_","disconnect_","report_","changes","_errorThrownDuringCallback","runningMicrotaskCheckpoint","performMicrotaskCheckpoint","anyChanged","toCheck","clearObservers","copyObject","copy","applySplices","previous","spliceArgs","addIndex","skipChanges","observerSentinel","needsDirectObserver","addObserver","observedCallback_","add","update","EDIT_LEAVE","EDIT_UPDATE","EDIT_ADD","EDIT_DELETE","calcEditDistances","rowCount","columnCount","distances","equals","north","west","spliceOperationsFromEditDistances","edits","min","northWest","reverse","prefixCount","suffixCount","minLength","sharedPrefix","sharedSuffix","ops","oldIndex","searchLength","index1","index2","calculateSplices","currentValue","previousValue","runEOM_","observerSentinel_","hasObjectObserve","getTreeScope","getElementById","updateBindings","bindings","bindings_","returnBinding","sanitizeValue","updateText","data","textBinding","updateAttribute","conditional","removeAttribute","attributeBinding","getEventForInputType","checkboxEventType","updateInput","input","santizeFn","inputBinding","bindInputEvent","postEventFn","eventType","booleanSanitize","getAssociatedRadioButtons","form","treeScope","radios","checkedPostEvent","radio","checkedBinding","checked","updateOption","option","select","selectBinding","HTMLSelectElement","optionBinding","bindFinished","maybeUpdateBindings","enable","Text","Element","div","checkbox","initMouseEvent","HTMLInputElement","HTMLElement","sanitizeFn","HTMLTextAreaElement","HTMLOptionElement","getFragmentRoot","searchRefId","ref","protoContent_","templateCreator_","isSVGTemplate","namespaceURI","isHTMLTemplate","isAttributeTemplate","semanticTemplateElements","isTemplate","isTemplate_","forAllTemplatesFrom","subTemplates","allTemplatesSelectors","bootstrapTemplatesRecursivelyFrom","bootstrap","HTMLTemplateElement","decorate","content","mixin","to","from","getOrCreateTemplateContentsOwner","ownerDocument","defaultView","templateContentsOwner_","implementation","createHTMLDocument","lastChild","getTemplateStagingDocument","stagingDocument_","isStagingDocument","href","baseURI","extractTemplateFromAttributeTemplate","attribs","attributes","attrib","templateAttributeDirectives","extractTemplateFromSVGTemplate","liftNonNativeTemplateChildrenIntoContent","useRoot","child","fixTemplateElementPrototype","hasProto","ensureSetModelScheduled","setModelFn_","setModelFnScheduled_","getBindings","delegate_","processBindings","model_","parseMustaches","prepareBindingFn","startIndex","lastIndex","endIndex","onlyOneTime","oneTimeStart","terminator","trim","delegateFn","hasOnePath","isSimplePath","combinator","processOneTimeBinding","processSinglePathBinding","processBinding","instanceBindings","iter","processBindingDirectives_","parseWithDefault","parseAttributeBindings","attr","substring","IF","BIND","REPEAT","if","repeat","TEXT_NODE","cloneAndBindInstance","parent","stagingDocument","importNode","nextSibling","children","setDelegate_","createInstanceBindingMap","getContentUid","contentUidCounter","getInstanceBindingMap","contentId","bindingMaps","bindingMap_","TemplateIterator","templateElement","closed","templateElement_","instances","iteratedValue","presentValue","arrayObserver","opt_this","Document","documentElement","THEAD","TBODY","TFOOT","TH","TR","TD","COLGROUP","COL","CAPTION","OPTION","OPTGROUP","hasTemplateElement","html","TypeError","templateObserver","refChanged_","opt_instanceRef","templateIsDecorated_","isNativeHTMLTemplate","bootstrapContents","liftContents","liftRoot","content_","createDocumentFragment","instanceRef_","htmlElement","HTMLUnknownElement","contentDescriptor","enumerable","directives","iterator_","closeDeps","updateDependencies","attributeFilter","createInstance","bindingDelegate","newDelegate_","refContent_","ref_","emptyInstance","instance","terminator_","instanceRecord","templateInstance_","firstNode","lastNode","collectTerminator","raw","valueChanged","updateIteratedValue","getUpdatedValue","instancePositionChangedFn_","instanceModelFn_","nextRef","ifOneTime","ifValue","hasIf","updateIfValue","updateValue","observeValue","handleSplices","getLastInstanceNode","subtemplateIterator","getLastTemplateNode","insertInstanceAt","fragment","previousInstanceLast","extractInstanceAt","getDelegateFn","instanceCache","removeDelta","closeInstanceBindings","reportInstancesMoved","reportInstanceMoved","forAllTemplatesFrom_","endOfMicrotask","twiddle","iterations","callbacks","atEndOfMicrotask","shift","createTextNode","JsMutationObserver","characterData","flushing","group","groupEnd","FLUSH_POLL_INTERVAL","flushPoll","originalImportNode","deep","imported","upgradeAll","replaceUrlsInCssText","cssText","baseUrl","keepAbsolute","regexp","pre","url","post","urlPath","resolveRelativeUrl","URL","makeDocumentRelPath","root","port","protocol","makeRelPath","sourceUrl","targetUrl","pathname","split","unshift","search","hash","urlResolver","resolveDom","resolveAttributes","resolveStyles","templates","resolveTemplate","resolveStyle","resolveCssText","CSS_URL_REGEXP","CSS_IMPORT_REGEXP","hasAttributes","resolveElementAttributes","URL_ATTRS_SELECTOR","URL_ATTRS","replacement","URL_TEMPLATE_SEARCH","Loader","regex","cache","requests","extractUrls","text","matched","matches","exec","process","done","fetch","inflight","req","xhr","wait","handleXhr","request","response","responseText","resolve","XMLHttpRequest","send","onerror","onload","pending","StyleResolver","loader","flatten","resolveNode","intermediate","loadStyles","loadedStyle","styleResolver","extend","api","pd","nom","inObj","copyProperty","inName","inSource","inTarget","getPropertyDescriptor","inObject","job","stop","Job","go","inContext","boundComplete","complete","h","handle","cancelAnimationFrame","createDOM","inTagOrNode","inHTML","inAttrs","dom","cloneNode","innerHTML","registry","tag","getPrototypeForTag","originalStopPropagation","Event","cancelBubble","DOMTokenList","remove","toggle","bool","switch","oldName","newName","ArraySlice","namedNodeMap","NamedNodeMap","MozNamedAttrMap","NodeList","HTMLCollection","$super","arrayOfArgs","caller","_super","nameInThis","warn","memoizeSuper","n$","method","nextSuper","super","noopHandler","deserializeValue","inferredType","typeHandlers","string","date","boolean","parseInt","function","declaration","publish","apis","utils","async","timeout","cancelAsync","fire","onNode","asyncFire","classFollows","anew","className","classList","injectBoundHTML","instanceTemplate","nop","nob","asyncMethod","log","EVENT_PREFIX","addHostListeners","eventDelegates","methodName","getEventHandler","dispatchMethod","handlerFn","copyInstanceAttributes","a$","_instanceAttributes","takeAttributes","_publishLC","attributeToProperty","propertyForAttribute","bindPattern","stringValue","serializeValue","reflectPropertyToAttribute","serializedValue","resolveBindingValue","updateRecord","createPropertyObserver","_observeNames","o","_propertyObserver","registerObserver","observeArrayValue","openPropertyObserver","notifyPropertyChanges","newValues","paths","called","ov","nv","invokeMethod","deliverChanges","propertyChanged_","reflect","callbackName","closeNamedObserver","registerNamedObserver","emitPropertyChangeRecord","notifier","notifier_","getNotifier","notify","bindToAccessor","resolveFn","privateName","setObserveable","privateComputedBoundValue","privateObservable","resolvedValue","createComputedProperties","_computedNames","syntax","bindProperty","_observers","closeObservers","o$","_namedObservers","closeNamedObservers","mdv","enableBindingsReflection","_recordBinding","mixinSuper","makeElementReady","asyncUnbindAll","_unbound","unbind","_unbindAllJob","unbindAll","cancelUnbindAll","mustachePattern","isBase","PolymerBase","created","createdCallback","prepareElement","_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","marshalNodeReferences","$","attributeChangedCallback","attributeChanged","onMutation","listener","mutations","disconnect","subtree","constructor","Base","shimCssText","is","ShadowCSS","makeScopeSelector","STYLE_SCOPE_ATTRIBUTE","STYLE_CONTROLLER_SCOPE","installControllerStyles","findStyleScope","scopeHasNamedStyle","cssTextForScope","installScopeCssText","installScopeStyle","cssTextToScopeStyle","applyStyleToScope","styleCacheForScope","polyfillScopeStyleCache","_scopeStyles","_currentScript","getRegisteredPrototype","registerPrototype","notifyPrototype","waitingForPrototype","client","waitPrototype","registerWhenReady","prototypesByName","instanceOfType","ctor","consumeDeclarations","declarations","resolveElementPaths","addResolvePathApi","assetPath","resolvePath","importRuleForSheet","sheet","createStyleElement","firstElementChild","s$","nextElementSibling","cssTextFromSheet","__resource","matchesSelector","inSelector","STYLE_SELECTOR","STYLE_LOADABLE_MATCH","SHEET_SELECTOR","STYLE_GLOBAL_SCOPE","SCOPE_ATTR","templateContent","convertSheetsToStyles","findLoadableStyles","templateUrl","copySheetAttributes","replaceChild","loadables","installSheets","cacheSheets","cacheStyles","installLocalSheets","installGlobalStyles","sheets","findNodes","matcher","templateNodes","styleForScope","scopeDescriptor","webkitMatchesSelector","mozMatchesSelector","mixedCaseEventTypes","parseHostEvents","delegates","addAttributeDelegates","hasEventPrefix","removeEventPrefix","prefixLength","findController","controller","prepareEventBinding","bindingValue","inferObservers","explodeObservers","exploded","ni","names","optimizePropertyMaps","_publishNames","publishProperties","requireProperties","lowerCaseMap","propertyInfos","createPropertyAccessor","ignoreWrites","createPropertyAccessors","ATTRIBUTES_ATTRIBUTE","ATTRIBUTES_REGEX","inheritAttributesObjects","inheritObject","publishAttributes","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","extnds","findBasePrototype","ensureBaseApi","memoizedBases","extended","mixinMethod","info","typeExtension","findTypeExtension","registerElement","inherited","queueForElement","mainQueue","importQueue","nextQueued","queue","waitToReady","addReadyCallback","check","forceReady","__queue","enqueue","shouldAdd","readied","flushable","addToFlushQueue","nextElement","canReady","isEmpty","flushQueue","polyfillWasReady","upgradeDocumentTree","flushReadyCallbacks","readyCallbacks","waitingFor","e$","whenPolymerReady","isRegistered","isCustomTag","init","loadResources","registered","waitingForQueue","waitingForResources","_register","handleNoScript","_needsResources","body","importElements","elementOrFragment","importUrls","urls","frag","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\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 && inEvent.path.length) {\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    findTouchAction: function(inEvent) {\n      var n;\n      if (HAS_FULL_PATH && inEvent.path && inEvent.path.length) {\n        var path = inEvent.path;\n        for (var i = 0; i < path.length; i++) {\n          n = path[i];\n          if (n.nodeType === Node.ELEMENT_NODE && n.hasAttribute('touch-action')) {\n            return n.getAttribute('touch-action');\n          }\n        }\n      } else {\n        n = inEvent.target;\n        while(n) {\n          if (n.nodeType === Node.ELEMENT_NODE && n.hasAttribute('touch-action')) {\n            return n.getAttribute('touch-action');\n          }\n          n = n.parentNode || n.host;\n        }\n      }\n      // auto is default\n      return \"auto\";\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    path: function(event) {\n      var p;\n      if (HAS_FULL_PATH && event.path && event.path.length) {\n        p = event.path;\n      } else {\n        p = [];\n        var n = this.findTarget(event);\n        while (n) {\n          p.push(n);\n          n = n.parentNode || n.host;\n        }\n      }\n      return p;\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 *\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 'html /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 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/*\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/*\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/*\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  // set of recognizers to run for the currently handled event\n  var currentGestures;\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    IS_IOS: false,\n    pointermap: new scope.PointerMap(),\n    requiredGestures: 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    // map gesture event -> {listeners: int, index: gestures[int]}\n    dependencyMap: {\n      // make sure down and up are in the map to trigger \"register\"\n      down: {listeners: 0, index: -1},\n      up: {listeners: 0, index: -1}\n    },\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      var obj = Object.create(null);\n      obj.listeners = 0;\n      obj.index = this.gestures.length;\n      for (var i = 0, g; i < source.exposes.length; i++) {\n        g = source.exposes[i].toLowerCase();\n        this.dependencyMap[g] = obj;\n      }\n      this.gestures.push(source);\n    },\n    register: function(element, initial) {\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, initial);\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.requiredGestures.set(inEvent.pointerId, currentGestures);\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      this.requiredGestures.delete(inEvent.pointerId);\n    },\n    cancel: function(inEvent) {\n      inEvent.tapPrevented = true;\n      this.fireEvent('up', inEvent);\n      this.requiredGestures.delete(inEvent.pointerId);\n    },\n    addGestureDependency: function(node, currentGestures) {\n      var gesturesWanted = node._pgEvents;\n      if (gesturesWanted) {\n        var gk = Object.keys(gesturesWanted);\n        for (var i = 0, r, ri, g; i < gk.length; i++) {\n          // gesture\n          g = gk[i];\n          if (gesturesWanted[g] > 0) {\n            // lookup gesture recognizer\n            r = this.dependencyMap[g];\n            // recognizer index\n            ri = r ? r.index : -1;\n            currentGestures[ri] = true;\n          }\n        }\n      }\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\n      var type = inEvent.type;\n\n      // only generate the list of desired events on \"down\"\n      if (type === 'touchstart' || type === 'mousedown' || type === 'pointerdown' || type === 'MSPointerDown') {\n        if (!inEvent._handledByPG) {\n          currentGestures = {};\n        }\n        // in IOS mode, there is only a listener on the document, so this is not re-entrant\n        if (this.IS_IOS) {\n          var nodes = scope.targetFinding.path(inEvent);\n          for (var i = 0, n; i < nodes.length; i++) {\n            n = nodes[i];\n            this.addGestureDependency(n, currentGestures);\n          }\n        } else {\n          this.addGestureDependency(inEvent.currentTarget, currentGestures);\n        }\n      }\n\n      if (inEvent._handledByPG) {\n        return;\n      }\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      target.addEventListener(eventName, this.boundHandler);\n    },\n    removeEvent: function(target, eventName) {\n      target.removeEventListener(eventName, this.boundHandler);\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        }\n      }\n      // keep the semantics of preventDefault\n      eventCopy.preventDefault = function() {\n        inEvent.preventDefault();\n      };\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, rg; i < this.gestureQueue.length; i++) {\n        e = this.gestureQueue[i];\n        rg = e._requiredGestures;\n        for (var j = 0, g, fn; j < this.gestures.length; j++) {\n          // only run recognizer if an element in the source event's path is listening for those gestures\n          if (rg[j]) {\n            g = this.gestures[j];\n            fn = g[e.type];\n            if (fn) {\n              fn.call(g, e);\n            }\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      ev._requiredGestures = this.requiredGestures.get(ev.pointerId);\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\n  /**\n   * Listen for `gesture` on `node` with the `handler` function\n   *\n   * If `handler` is the first listener for `gesture`, the underlying gesture recognizer is then enabled.\n   *\n   * @param {Element} node\n   * @param {string} gesture\n   * @return Boolean `gesture` is a valid gesture\n   */\n  scope.activateGesture = function(node, gesture) {\n    var g = gesture.toLowerCase();\n    var dep = dispatcher.dependencyMap[g];\n    if (dep) {\n      var recognizer = dispatcher.gestures[dep.index];\n      if (!node._pgListeners) {\n        dispatcher.register(node);\n        node._pgListeners = 0;\n      }\n      // TODO(dfreedm): re-evaluate bookkeeping to avoid using attributes\n      if (recognizer) {\n        var touchAction = recognizer.defaultActions && recognizer.defaultActions[g];\n        var actionNode;\n        switch(node.nodeType) {\n          case Node.ELEMENT_NODE:\n            actionNode = node;\n          break;\n          case Node.DOCUMENT_FRAGMENT_NODE:\n            actionNode = node.host;\n          break;\n          default:\n            actionNode = null;\n          break;\n        }\n        if (touchAction && actionNode && !actionNode.hasAttribute('touch-action')) {\n          actionNode.setAttribute('touch-action', touchAction);\n        }\n      }\n      if (!node._pgEvents) {\n        node._pgEvents = {};\n      }\n      node._pgEvents[g] = (node._pgEvents[g] || 0) + 1;\n      node._pgListeners++;\n    }\n    return Boolean(dep);\n  };\n\n  /**\n   *\n   * Listen for `gesture` from `node` with `handler` function.\n   *\n   * @param {Element} node\n   * @param {string} gesture\n   * @param {Function} handler\n   * @param {Boolean} capture\n   */\n  scope.addEventListener = function(node, gesture, handler, capture) {\n    if (handler) {\n      scope.activateGesture(node, gesture);\n      node.addEventListener(gesture, handler, capture);\n    }\n  };\n\n  /**\n   * Tears down the gesture configuration for `node`\n   *\n   * If `handler` is the last listener for `gesture`, the underlying gesture recognizer is disabled.\n   *\n   * @param {Element} node\n   * @param {string} gesture\n   * @return Boolean `gesture` is a valid gesture\n   */\n  scope.deactivateGesture = function(node, gesture) {\n    var g = gesture.toLowerCase();\n    var dep = dispatcher.dependencyMap[g];\n    if (dep) {\n      if (node._pgListeners > 0) {\n        node._pgListeners--;\n      }\n      if (node._pgListeners === 0) {\n        dispatcher.unregister(node);\n      }\n      if (node._pgEvents) {\n        if (node._pgEvents[g] > 0) {\n          node._pgEvents[g]--;\n        } else {\n          node._pgEvents[g] = 0;\n        }\n      }\n    }\n    return Boolean(dep);\n  };\n\n  /**\n   * Stop listening for `gesture` from `node` with `handler` function.\n   *\n   * @param {Element} node\n   * @param {string} gesture\n   * @param {Function} handler\n   * @param {Boolean} capture\n   */\n  scope.removeEventListener = function(node, gesture, handler, capture) {\n    if (handler) {\n      scope.deactivateGesture(node, gesture);\n      node.removeEventListener(gesture, handler, capture);\n    }\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 (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    exposes: [\n      'down',\n      'up',\n      'move'\n    ],\n    register: function(target) {\n      dispatcher.listen(target, this.events);\n    },\n    unregister: function(target) {\n      if (target === document) {\n        return;\n      }\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.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 target = pointermap.get(this.POINTER_ID);\n        if (target) {\n          var e = this.prepareEvent(inEvent);\n          e.target = target;\n          // handle case where we missed a mouseup\n          if (e.buttons === 0) {\n            dispatcher.cancel(e);\n            this.cleanupMouse();\n          } else {\n            dispatcher.move(e);\n          }\n        }\n      }\n    },\n    mouseup: function(inEvent) {\n      if (!this.isEventSimulatedFromTouch(inEvent)) {\n        var e = this.prepareEvent(inEvent);\n        e.relatedTarget = 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/*\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  // TODO(dfreedm): disable until http://crbug.com/399765 is resolved\n  // var HAS_TOUCH_ACTION = ATTRIB in document.head.style;\n  var HAS_TOUCH_ACTION = false;\n\n  // handler block for native touch events\n  var touchEvents = {\n    IS_IOS: false,\n    events: [\n      'touchstart',\n      'touchmove',\n      'touchend',\n      'touchcancel'\n    ],\n    exposes: [\n      'down',\n      'up',\n      'move'\n    ],\n    register: function(target, initial) {\n      if (this.IS_IOS ? initial : !initial) {\n        dispatcher.listen(target, this.events);\n      }\n    },\n    unregister: function(target) {\n      if (!this.IS_IOS) {\n        dispatcher.unlisten(target, this.events);\n      }\n    },\n    scrollTypes: {\n      EMITTER: 'none',\n      XSCROLLER: 'pan-x',\n      YSCROLLER: 'pan-y',\n    },\n    touchActionToScrollType: function(touchAction) {\n      var t = touchAction;\n      var st = this.scrollTypes;\n      if (t === st.EMITTER) {\n        return 'none';\n      } else if (t === st.XSCROLLER) {\n        return 'X';\n      } else if (t === st.YSCROLLER) {\n        return 'Y';\n      } else {\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 = null;\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: 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 = 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' || inEvent._cancel) {\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 touchAction = scope.targetFinding.findTouchAction(inEvent);\n        var scrollAxis = this.touchActionToScrollType(touchAction);\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(function(p) {\n          this.cancel(p);\n          pointermap.delete(p.pointerId);\n        });\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 (HAS_TOUCH_ACTION) {\n        // touchevent.cancelable == false is sent when the page is scrolling under native Touch Action in Chrome 36\n        // https://groups.google.com/a/chromium.org/d/msg/input-dev/wHnyukcYBcA/b9kmtwM1jJQJ\n        if (inEvent.cancelable) {\n          this.processTouches(inEvent, this.move);\n        }\n      } else {\n        if (!this.scrolling) {\n          if (this.scrolling === null && this.shouldScroll(inEvent)) {\n            this.scrolling = true;\n          } else {\n            this.scrolling = false;\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.scrolling = true;\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.findTarget(inPointer);\n      dispatcher.up(inPointer);\n    },\n    cancel: function(inPointer) {\n      dispatcher.cancel(inPointer);\n    },\n    touchcancel: function(inEvent) {\n      inEvent._cancel = true;\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  scope.touchEvents = touchEvents;\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(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      dispatcher.listen(target, this.events);\n    },\n    unregister: function(target) {\n      if (target === document) {\n        return;\n      }\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.findTarget(inEvent);\n      pointermap.set(inEvent.pointerId, e.target);\n      dispatcher.down(e);\n    },\n    MSPointerMove: function(inEvent) {\n      var target = pointermap.get(inEvent.pointerId);\n      if (target) {\n        var e = this.prepareEvent(inEvent);\n        e.target = target;\n        dispatcher.move(e);\n      }\n    },\n    MSPointerUp: function(inEvent) {\n      var e = this.prepareEvent(inEvent);\n      e.relatedTarget = 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.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/*\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      dispatcher.listen(target, this.events);\n    },\n    unregister: function(target) {\n      if (target === document) {\n        return;\n      }\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.findTarget(inEvent);\n      pointermap.set(e.pointerId, e.target);\n      dispatcher.down(e);\n    },\n    pointermove: function(inEvent) {\n      var target = pointermap.get(inEvent.pointerId);\n      if (target) {\n        var e = this.prepareEvent(inEvent);\n        e.target = target;\n        dispatcher.move(e);\n      }\n    },\n    pointerup: function(inEvent) {\n      var e = this.prepareEvent(inEvent);\n      e.relatedTarget = 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.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/*\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\n  var dispatcher = scope.dispatcher;\n  var nav = window.navigator;\n\n  if (window.PointerEvent) {\n    dispatcher.registerSource('pointer', scope.pointerEvents);\n  } else if (nav.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  // Work around iOS bugs https://bugs.webkit.org/show_bug.cgi?id=135628 and https://bugs.webkit.org/show_bug.cgi?id=136506\n  var ua = navigator.userAgent;\n  var IS_IOS = ua.match(/iPad|iPhone|iPod/) && 'ontouchstart' in window;\n\n  dispatcher.IS_IOS = IS_IOS;\n  scope.touchEvents.IS_IOS = IS_IOS;\n\n  dispatcher.register(document, true);\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/**\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     exposes: [\n      'trackstart',\n      'track',\n      'trackx',\n      'tracky',\n      'trackend'\n     ],\n     defaultActions: {\n       'track': 'none',\n       'trackx': 'pan-y',\n       'tracky': 'pan-x'\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       } else if (inType === 'trackx') {\n         return;\n       }\n       if (dd.y) {\n         t.yDirection = this.clampDir(dd.y);\n       } else if (inType === 'tracky') {\n         return;\n       }\n       var gestureProto = {\n         bubbles: true,\n         cancelable: true,\n         trackInfo: t.trackInfo,\n         relatedTarget: inEvent.relatedTarget,\n         pointerType: inEvent.pointerType,\n         pointerId: inEvent.pointerId,\n         _source: 'track'\n       };\n       if (inType !== 'tracky') {\n         gestureProto.x = inEvent.x;\n         gestureProto.dx = d.x;\n         gestureProto.ddx = dd.x;\n         gestureProto.clientX = inEvent.clientX;\n         gestureProto.pageX = inEvent.pageX;\n         gestureProto.screenX = inEvent.screenX;\n         gestureProto.xDirection = t.xDirection;\n       }\n       if (inType !== 'trackx') {\n         gestureProto.dy = d.y;\n         gestureProto.ddy = dd.y;\n         gestureProto.y = inEvent.y;\n         gestureProto.clientY = inEvent.clientY;\n         gestureProto.pageY = inEvent.pageY;\n         gestureProto.screenY = inEvent.screenY;\n         gestureProto.yDirection = t.yDirection;\n       }\n       var e = eventFactory.makeGestureEvent(inType, gestureProto);\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             p.lastMoveEvent = p.downEvent;\n             this.fireTrack('trackstart', inEvent, p);\n           }\n         }\n         if (p.tracking) {\n           this.fireTrack('track', inEvent, p);\n           this.fireTrack('trackx', inEvent, p);\n           this.fireTrack('tracky', 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/*\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    exposes: [\n      'hold',\n      'holdpulse',\n      'release'\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/*\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    exposes: [\n      'tap'\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/*\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\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      switch (op) {\n        case '||':\n          this.dynamicDeps = true;\n          return function(model, observer, filterRegistry) {\n            return left(model, observer, filterRegistry) ||\n                right(model, observer, filterRegistry);\n          };\n        case '&&':\n          this.dynamicDeps = true;\n          return function(model, observer, filterRegistry) {\n            return left(model, observer, filterRegistry) &&\n                right(model, observer, filterRegistry);\n          };\n      }\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      this.dynamicDeps = true;\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/*\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.4.0-d62a0e4'\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// 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/*\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\tOn supported platforms, platform.js is not needed. To retain compatibility\n\twith the polyfills, we stub out minimal functionality.\n */\nif (!window.Platform) {\n  logFlags = window.logFlags || {};\n\n\n  Platform = {\n  \tflush: function() {}\n  };\n\n  CustomElements = {\n  \tuseNative: true,\n    ready: true,\n    takeRecords: function() {},\n    instanceof: function(obj, base) {\n      return obj instanceof base;\n    }\n  };\n  \n  HTMLImports = {\n  \tuseNative: true\n  };\n\n  \n  addEventListener('HTMLImportsLoaded', function() {\n    document.dispatchEvent(\n      new CustomEvent('WebComponentsReady', {bubbles: true})\n    );\n  });\n\n\n  // ShadowDOM\n  ShadowDOMPolyfill = null;\n  wrap = unwrap = function(n){\n    return n;\n  };\n\n}\n\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\nvar hasNative = ('import' in document.createElement('link'));\r\nvar useNative = hasNative;\r\n\r\nisIE = /Trident/.test(navigator.userAgent);\r\n\r\n// TODO(sorvell): SD polyfill intrusion\r\nvar hasShadowDOMPolyfill = Boolean(window.ShadowDOMPolyfill);\r\nvar wrap = function(node) {\r\n  return hasShadowDOMPolyfill ? ShadowDOMPolyfill.wrapIfNeeded(node) : node;\r\n};\r\nvar mainDoc = wrap(document);\r\n    \r\n// NOTE: We cannot polyfill document.currentScript because it's not possible\r\n// both to override and maintain the ability to capture the native value;\r\n// therefore we choose to expose _currentScript both when native imports\r\n// and the polyfill are in use.\r\nvar currentScriptDescriptor = {\r\n  get: function() {\r\n    var script = HTMLImports.currentScript || document.currentScript ||\r\n        // NOTE: only works when called in synchronously executing code.\r\n        // readyState should check if `loading` but IE10 is \r\n        // interactive when scripts run so we cheat.\r\n        (document.readyState !== 'complete' ? \r\n        document.scripts[document.scripts.length - 1] : null);\r\n    return wrap(script);\r\n  },\r\n  configurable: true\r\n};\r\n\r\nObject.defineProperty(document, '_currentScript', currentScriptDescriptor);\r\nObject.defineProperty(mainDoc, '_currentScript', currentScriptDescriptor);\r\n\r\n// call a callback when all HTMLImports in the document at call (or at least\r\n//  document ready) time have loaded.\r\n// 1. ensure the document is in a ready state (has dom), then \r\n// 2. watch for loading of imports and call callback when done\r\nfunction whenImportsReady(callback, doc) {\r\n  doc = doc || mainDoc;\r\n  // if document is loading, wait and try again\r\n  whenDocumentReady(function() {\r\n    watchImportsLoad(callback, doc);\r\n  }, doc);\r\n}\r\n\r\n// call the callback when the document is in a ready state (has dom)\r\nvar requiredReadyState = isIE ? 'complete' : 'interactive';\r\nvar READY_EVENT = 'readystatechange';\r\nfunction isDocumentReady(doc) {\r\n  return (doc.readyState === 'complete' ||\r\n      doc.readyState === requiredReadyState);\r\n}\r\n\r\n// call <callback> when we ensure the document is in a ready state\r\nfunction whenDocumentReady(callback, doc) {\r\n  if (!isDocumentReady(doc)) {\r\n    var checkReady = function() {\r\n      if (doc.readyState === 'complete' || \r\n          doc.readyState === requiredReadyState) {\r\n        doc.removeEventListener(READY_EVENT, checkReady);\r\n        whenDocumentReady(callback, doc);\r\n      }\r\n    };\r\n    doc.addEventListener(READY_EVENT, checkReady);\r\n  } else if (callback) {\r\n    callback();\r\n  }\r\n}\r\n\r\nfunction markTargetLoaded(event) {\r\n  event.target.__loaded = true;\r\n}\r\n\r\n// call <callback> when we ensure all imports have loaded\r\nfunction watchImportsLoad(callback, doc) {\r\n  var imports = doc.querySelectorAll('link[rel=import]');\r\n  var loaded = 0, l = imports.length;\r\n  function checkDone(d) { \r\n    if (loaded == l) {\r\n      callback && callback();\r\n    }\r\n  }\r\n  function loadedImport(e) {\r\n    markTargetLoaded(e);\r\n    loaded++;\r\n    checkDone();\r\n  }\r\n  if (l) {\r\n    for (var i=0, imp; (i<l) && (imp=imports[i]); i++) {\r\n      if (isImportLoaded(imp)) {\r\n        loadedImport.call(imp, {target: imp});\r\n      } else {\r\n        imp.addEventListener('load', loadedImport);\r\n        imp.addEventListener('error', loadedImport);\r\n      }\r\n    }\r\n  } else {\r\n    checkDone();\r\n  }\r\n}\r\n\r\n// NOTE: test for native imports loading is based on explicitly watching\r\n// all imports (see below).\r\n// We cannot rely on this entirely without watching the entire document\r\n// for import links. For perf reasons, currently only head is watched.\r\n// Instead, we fallback to checking if the import property is available \r\n// and the document is not itself loading. \r\nfunction isImportLoaded(link) {\r\n  return useNative ? link.__loaded || \r\n      (link.import && link.import.readyState !== 'loading') :\r\n      link.__importParsed;\r\n}\r\n\r\n// TODO(sorvell): Workaround for \r\n// https://www.w3.org/Bugs/Public/show_bug.cgi?id=25007, should be removed when\r\n// this bug is addressed.\r\n// (1) Install a mutation observer to see when HTMLImports have loaded\r\n// (2) if this script is run during document load it will watch any existing\r\n// imports for loading.\r\n//\r\n// NOTE: The workaround has restricted functionality: (1) it's only compatible\r\n// with imports that are added to document.head since the mutation observer \r\n// watches only head for perf reasons, (2) it requires this script\r\n// to run before any imports have completed loading.\r\nif (useNative) {\r\n  new MutationObserver(function(mxns) {\r\n    for (var i=0, l=mxns.length, m; (i < l) && (m=mxns[i]); i++) {\r\n      if (m.addedNodes) {\r\n        handleImports(m.addedNodes);\r\n      }\r\n    }\r\n  }).observe(document.head, {childList: true});\r\n\r\n  function handleImports(nodes) {\r\n    for (var i=0, l=nodes.length, n; (i<l) && (n=nodes[i]); i++) {\r\n      if (isImport(n)) {\r\n        handleImport(n);  \r\n      }\r\n    }\r\n  }\r\n\r\n  function isImport(element) {\r\n    return element.localName === 'link' && element.rel === 'import';\r\n  }\r\n\r\n  function handleImport(element) {\r\n    var loaded = element.import;\r\n    if (loaded) {\r\n      markTargetLoaded({target: element});\r\n    } else {\r\n      element.addEventListener('load', markTargetLoaded);\r\n      element.addEventListener('error', markTargetLoaded);\r\n    }\r\n  }\r\n\r\n  // make sure to catch any imports that are in the process of loading\r\n  // when this script is run.\r\n  (function() {\r\n    if (document.readyState === 'loading') {\r\n      var imports = document.querySelectorAll('link[rel=import]');\r\n      for (var i=0, l=imports.length, imp; (i<l) && (imp=imports[i]); i++) {\r\n        handleImport(imp);\r\n      }\r\n    }\r\n  })();\r\n\r\n}\r\n\r\n// Fire the 'HTMLImportsLoaded' event when imports in document at load time \r\n// have loaded. This event is required to simulate the script blocking \r\n// behavior of native imports. A main document script that needs to be sure\r\n// imports have loaded should wait for this event.\r\nwhenImportsReady(function() {\r\n  HTMLImports.ready = true;\r\n  HTMLImports.readyTime = new Date().getTime();\r\n  mainDoc.dispatchEvent(\r\n    new CustomEvent('HTMLImportsLoaded', {bubbles: true})\r\n  );\r\n});\r\n\r\n// exports\r\nscope.useNative = useNative;\r\nscope.isImportLoaded = isImportLoaded;\r\nscope.whenReady = whenImportsReady;\r\nscope.isIE = isIE;\r\n\r\n// deprecated\r\nscope.whenImportsReady = whenImportsReady;\r\n\r\n})(window.HTMLImports);\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  function withDependencies(task, depends) {\n    depends = depends || [];\n    if (!depends.map) {\n      depends = [depends];\n    }\n    return task.apply(this, depends.map(marshal));\n  }\n\n  function module(name, dependsOrFactory, moduleFactory) {\n    var module;\n    switch (arguments.length) {\n      case 0:\n        return;\n      case 1:\n        module = null;\n        break;\n      case 2:\n        // dependsOrFactory is `factory` in this case\n        module = dependsOrFactory.apply(this);\n        break;\n      default:\n        // dependsOrFactory is `depends` in this case\n        module = withDependencies(moduleFactory, dependsOrFactory);\n        break;\n    }\n    modules[name] = module;\n  };\n\n  function marshal(name) {\n    return modules[name];\n  }\n\n  var modules = {};\n\n  function using(depends, task) {\n    HTMLImports.whenImportsReady(function() {\n      withDependencies(task, depends);\n    });\n  };\n\n  // exports\n\n  scope.marshal = marshal;\n  // `module` confuses commonjs detectors\n  scope.modularize = module;\n  scope.using = using;\n\n})(window);\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  // TODO(sorvell): It's desireable to provide a default stylesheet \n  // that's convenient for styling unresolved elements, but\n  // it's cumbersome to have to include this manually in every page.\n  // It would make sense to put inside some HTMLImport but \n  // the HTMLImports polyfill does not allow loading of stylesheets \n  // that block rendering. Therefore this injection is tolerated here.\n  var style = document.createElement('style');\n  style.textContent = ''\n      + 'body {'\n      + 'transition: opacity ease-in 0.2s;' \n      + ' } \\n'\n      + 'body[unresolved] {'\n      + 'opacity: 0; display: block; overflow: hidden;' \n      + ' } \\n'\n      ;\n  var head = document.querySelector('head');\n  head.insertBefore(style, head.firstChild);\n\n})(Platform);\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(global) {\n  'use strict';\n\n  var testingExposeCycleCount = global.testingExposeCycleCount;\n\n  // Detect and do basic sanity checking on Object/Array.observe.\n  function detectObjectObserve() {\n    if (typeof Object.observe !== 'function' ||\n        typeof Array.observe !== 'function') {\n      return false;\n    }\n\n    var records = [];\n\n    function callback(recs) {\n      records = recs;\n    }\n\n    var test = {};\n    var arr = [];\n    Object.observe(test, callback);\n    Array.observe(arr, callback);\n    test.id = 1;\n    test.id = 2;\n    delete test.id;\n    arr.push(1, 2);\n    arr.length = 0;\n\n    Object.deliverChangeRecords(callback);\n    if (records.length !== 5)\n      return false;\n\n    if (records[0].type != 'add' ||\n        records[1].type != 'update' ||\n        records[2].type != 'delete' ||\n        records[3].type != 'splice' ||\n        records[4].type != 'splice') {\n      return false;\n    }\n\n    Object.unobserve(test, callback);\n    Array.unobserve(arr, callback);\n\n    return true;\n  }\n\n  var hasObserve = detectObjectObserve();\n\n  function detectEval() {\n    // Don't test for eval if we're running in a Chrome App environment.\n    // We check for APIs set that only exist in a Chrome App context.\n    if (typeof chrome !== 'undefined' && chrome.app && chrome.app.runtime) {\n      return false;\n    }\n\n    // Firefox OS Apps do not allow eval. This feature detection is very hacky\n    // but even if some other platform adds support for this function this code\n    // will continue to work.\n    if (typeof navigator != 'undefined' && navigator.getDeviceStorage) {\n      return false;\n    }\n\n    try {\n      var f = new Function('', 'return true;');\n      return f();\n    } catch (ex) {\n      return false;\n    }\n  }\n\n  var hasEval = detectEval();\n\n  function isIndex(s) {\n    return +s === s >>> 0 && s !== '';\n  }\n\n  function toNumber(s) {\n    return +s;\n  }\n\n  function isObject(obj) {\n    return obj === Object(obj);\n  }\n\n  var numberIsNaN = global.Number.isNaN || function(value) {\n    return typeof value === 'number' && global.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  var createObject = ('__proto__' in {}) ?\n    function(obj) { return obj; } :\n    function(obj) {\n      var proto = obj.__proto__;\n      if (!proto)\n        return obj;\n      var newObject = Object.create(proto);\n      Object.getOwnPropertyNames(obj).forEach(function(name) {\n        Object.defineProperty(newObject, name,\n                             Object.getOwnPropertyDescriptor(obj, name));\n      });\n      return newObject;\n    };\n\n  var identStart = '[\\$_a-zA-Z]';\n  var identPart = '[\\$_a-zA-Z0-9]';\n  var identRegExp = new RegExp('^' + identStart + '+' + identPart + '*' + '$');\n\n  function getPathCharType(char) {\n    if (char === undefined)\n      return 'eof';\n\n    var code = char.charCodeAt(0);\n\n    switch(code) {\n      case 0x5B: // [\n      case 0x5D: // ]\n      case 0x2E: // .\n      case 0x22: // \"\n      case 0x27: // '\n      case 0x30: // 0\n        return char;\n\n      case 0x5F: // _\n      case 0x24: // $\n        return 'ident';\n\n      case 0x20: // Space\n      case 0x09: // Tab\n      case 0x0A: // Newline\n      case 0x0D: // Return\n      case 0xA0:  // No-break space\n      case 0xFEFF:  // Byte Order Mark\n      case 0x2028:  // Line Separator\n      case 0x2029:  // Paragraph Separator\n        return 'ws';\n    }\n\n    // a-z, A-Z\n    if ((0x61 <= code && code <= 0x7A) || (0x41 <= code && code <= 0x5A))\n      return 'ident';\n\n    // 1-9\n    if (0x31 <= code && code <= 0x39)\n      return 'number';\n\n    return 'else';\n  }\n\n  var pathStateMachine = {\n    'beforePath': {\n      'ws': ['beforePath'],\n      'ident': ['inIdent', 'append'],\n      '[': ['beforeElement'],\n      'eof': ['afterPath']\n    },\n\n    'inPath': {\n      'ws': ['inPath'],\n      '.': ['beforeIdent'],\n      '[': ['beforeElement'],\n      'eof': ['afterPath']\n    },\n\n    'beforeIdent': {\n      'ws': ['beforeIdent'],\n      'ident': ['inIdent', 'append']\n    },\n\n    'inIdent': {\n      'ident': ['inIdent', 'append'],\n      '0': ['inIdent', 'append'],\n      'number': ['inIdent', 'append'],\n      'ws': ['inPath', 'push'],\n      '.': ['beforeIdent', 'push'],\n      '[': ['beforeElement', 'push'],\n      'eof': ['afterPath', 'push']\n    },\n\n    'beforeElement': {\n      'ws': ['beforeElement'],\n      '0': ['afterZero', 'append'],\n      'number': ['inIndex', 'append'],\n      \"'\": ['inSingleQuote', 'append', ''],\n      '\"': ['inDoubleQuote', 'append', '']\n    },\n\n    'afterZero': {\n      'ws': ['afterElement', 'push'],\n      ']': ['inPath', 'push']\n    },\n\n    'inIndex': {\n      '0': ['inIndex', 'append'],\n      'number': ['inIndex', 'append'],\n      'ws': ['afterElement'],\n      ']': ['inPath', 'push']\n    },\n\n    'inSingleQuote': {\n      \"'\": ['afterElement'],\n      'eof': ['error'],\n      'else': ['inSingleQuote', 'append']\n    },\n\n    'inDoubleQuote': {\n      '\"': ['afterElement'],\n      'eof': ['error'],\n      'else': ['inDoubleQuote', 'append']\n    },\n\n    'afterElement': {\n      'ws': ['afterElement'],\n      ']': ['inPath', 'push']\n    }\n  }\n\n  function noop() {}\n\n  function parsePath(path) {\n    var keys = [];\n    var index = -1;\n    var c, newChar, key, type, transition, action, typeMap, mode = 'beforePath';\n\n    var actions = {\n      push: function() {\n        if (key === undefined)\n          return;\n\n        keys.push(key);\n        key = undefined;\n      },\n\n      append: function() {\n        if (key === undefined)\n          key = newChar\n        else\n          key += newChar;\n      }\n    };\n\n    function maybeUnescapeQuote() {\n      if (index >= path.length)\n        return;\n\n      var nextChar = path[index + 1];\n      if ((mode == 'inSingleQuote' && nextChar == \"'\") ||\n          (mode == 'inDoubleQuote' && nextChar == '\"')) {\n        index++;\n        newChar = nextChar;\n        actions.append();\n        return true;\n      }\n    }\n\n    while (mode) {\n      index++;\n      c = path[index];\n\n      if (c == '\\\\' && maybeUnescapeQuote(mode))\n        continue;\n\n      type = getPathCharType(c);\n      typeMap = pathStateMachine[mode];\n      transition = typeMap[type] || typeMap['else'] || 'error';\n\n      if (transition == 'error')\n        return; // parse error;\n\n      mode = transition[0];\n      action = actions[transition[1]] || noop;\n      newChar = transition[2] === undefined ? c : transition[2];\n      action();\n\n      if (mode === 'afterPath') {\n        return keys;\n      }\n    }\n\n    return; // parse error\n  }\n\n  function isIdent(s) {\n    return identRegExp.test(s);\n  }\n\n  var constructorIsPrivate = {};\n\n  function Path(parts, privateToken) {\n    if (privateToken !== constructorIsPrivate)\n      throw Error('Use Path.get to retrieve path objects');\n\n    for (var i = 0; i < parts.length; i++) {\n      this.push(String(parts[i]));\n    }\n\n    if (hasEval && this.length) {\n      this.getValueFrom = this.compiledGetValueFromFn();\n    }\n  }\n\n  // TODO(rafaelw): Make simple LRU cache\n  var pathCache = {};\n\n  function getPath(pathString) {\n    if (pathString instanceof Path)\n      return pathString;\n\n    if (pathString == null || pathString.length == 0)\n      pathString = '';\n\n    if (typeof pathString != 'string') {\n      if (isIndex(pathString.length)) {\n        // Constructed with array-like (pre-parsed) keys\n        return new Path(pathString, constructorIsPrivate);\n      }\n\n      pathString = String(pathString);\n    }\n\n    var path = pathCache[pathString];\n    if (path)\n      return path;\n\n    var parts = parsePath(pathString);\n    if (!parts)\n      return invalidPath;\n\n    var path = new Path(parts, constructorIsPrivate);\n    pathCache[pathString] = path;\n    return path;\n  }\n\n  Path.get = getPath;\n\n  function formatAccessor(key) {\n    if (isIndex(key)) {\n      return '[' + key + ']';\n    } else {\n      return '[\"' + key.replace(/\"/g, '\\\\\"') + '\"]';\n    }\n  }\n\n  Path.prototype = createObject({\n    __proto__: [],\n    valid: true,\n\n    toString: function() {\n      var pathString = '';\n      for (var i = 0; i < this.length; i++) {\n        var key = this[i];\n        if (isIdent(key)) {\n          pathString += i ? '.' + key : key;\n        } else {\n          pathString += formatAccessor(key);\n        }\n      }\n\n      return pathString;\n    },\n\n    getValueFrom: function(obj, directObserver) {\n      for (var i = 0; i < this.length; i++) {\n        if (obj == null)\n          return;\n        obj = obj[this[i]];\n      }\n      return obj;\n    },\n\n    iterateObjects: function(obj, observe) {\n      for (var i = 0; i < this.length; i++) {\n        if (i)\n          obj = obj[this[i - 1]];\n        if (!isObject(obj))\n          return;\n        observe(obj, this[0]);\n      }\n    },\n\n    compiledGetValueFromFn: function() {\n      var str = '';\n      var pathString = 'obj';\n      str += 'if (obj != null';\n      var i = 0;\n      var key;\n      for (; i < (this.length - 1); i++) {\n        key = this[i];\n        pathString += isIdent(key) ? '.' + key : formatAccessor(key);\n        str += ' &&\\n     ' + pathString + ' != null';\n      }\n      str += ')\\n';\n\n      var key = this[i];\n      pathString += isIdent(key) ? '.' + key : formatAccessor(key);\n\n      str += '  return ' + pathString + ';\\nelse\\n  return undefined;';\n      return new Function('obj', str);\n    },\n\n    setValueFrom: function(obj, value) {\n      if (!this.length)\n        return false;\n\n      for (var i = 0; i < this.length - 1; i++) {\n        if (!isObject(obj))\n          return false;\n        obj = obj[this[i]];\n      }\n\n      if (!isObject(obj))\n        return false;\n\n      obj[this[i]] = value;\n      return true;\n    }\n  });\n\n  var invalidPath = new Path('', constructorIsPrivate);\n  invalidPath.valid = false;\n  invalidPath.getValueFrom = invalidPath.setValueFrom = function() {};\n\n  var MAX_DIRTY_CHECK_CYCLES = 1000;\n\n  function dirtyCheck(observer) {\n    var cycles = 0;\n    while (cycles < MAX_DIRTY_CHECK_CYCLES && observer.check_()) {\n      cycles++;\n    }\n    if (testingExposeCycleCount)\n      global.dirtyCheckCycleCount = cycles;\n\n    return cycles > 0;\n  }\n\n  function objectIsEmpty(object) {\n    for (var prop in object)\n      return false;\n    return true;\n  }\n\n  function diffIsEmpty(diff) {\n    return objectIsEmpty(diff.added) &&\n           objectIsEmpty(diff.removed) &&\n           objectIsEmpty(diff.changed);\n  }\n\n  function diffObjectFromOldObject(object, oldObject) {\n    var added = {};\n    var removed = {};\n    var changed = {};\n\n    for (var prop in oldObject) {\n      var newValue = object[prop];\n\n      if (newValue !== undefined && newValue === oldObject[prop])\n        continue;\n\n      if (!(prop in object)) {\n        removed[prop] = undefined;\n        continue;\n      }\n\n      if (newValue !== oldObject[prop])\n        changed[prop] = newValue;\n    }\n\n    for (var prop in object) {\n      if (prop in oldObject)\n        continue;\n\n      added[prop] = object[prop];\n    }\n\n    if (Array.isArray(object) && object.length !== oldObject.length)\n      changed.length = object.length;\n\n    return {\n      added: added,\n      removed: removed,\n      changed: changed\n    };\n  }\n\n  var eomTasks = [];\n  function runEOMTasks() {\n    if (!eomTasks.length)\n      return false;\n\n    for (var i = 0; i < eomTasks.length; i++) {\n      eomTasks[i]();\n    }\n    eomTasks.length = 0;\n    return true;\n  }\n\n  var runEOM = hasObserve ? (function(){\n    var eomObj = { pingPong: true };\n    var eomRunScheduled = false;\n\n    Object.observe(eomObj, function() {\n      runEOMTasks();\n      eomRunScheduled = false;\n    });\n\n    return function(fn) {\n      eomTasks.push(fn);\n      if (!eomRunScheduled) {\n        eomRunScheduled = true;\n        eomObj.pingPong = !eomObj.pingPong;\n      }\n    };\n  })() :\n  (function() {\n    return function(fn) {\n      eomTasks.push(fn);\n    };\n  })();\n\n  var observedObjectCache = [];\n\n  function newObservedObject() {\n    var observer;\n    var object;\n    var discardRecords = false;\n    var first = true;\n\n    function callback(records) {\n      if (observer && observer.state_ === OPENED && !discardRecords)\n        observer.check_(records);\n    }\n\n    return {\n      open: function(obs) {\n        if (observer)\n          throw Error('ObservedObject in use');\n\n        if (!first)\n          Object.deliverChangeRecords(callback);\n\n        observer = obs;\n        first = false;\n      },\n      observe: function(obj, arrayObserve) {\n        object = obj;\n        if (arrayObserve)\n          Array.observe(object, callback);\n        else\n          Object.observe(object, callback);\n      },\n      deliver: function(discard) {\n        discardRecords = discard;\n        Object.deliverChangeRecords(callback);\n        discardRecords = false;\n      },\n      close: function() {\n        observer = undefined;\n        Object.unobserve(object, callback);\n        observedObjectCache.push(this);\n      }\n    };\n  }\n\n  /*\n   * The observedSet abstraction is a perf optimization which reduces the total\n   * number of Object.observe observations of a set of objects. The idea is that\n   * groups of Observers will have some object dependencies in common and this\n   * observed set ensures that each object in the transitive closure of\n   * dependencies is only observed once. The observedSet acts as a write barrier\n   * such that whenever any change comes through, all Observers are checked for\n   * changed values.\n   *\n   * Note that this optimization is explicitly moving work from setup-time to\n   * change-time.\n   *\n   * TODO(rafaelw): Implement \"garbage collection\". In order to move work off\n   * the critical path, when Observers are closed, their observed objects are\n   * not Object.unobserve(d). As a result, it's possible that if the observedSet\n   * is kept open, but some Observers have been closed, it could cause \"leaks\"\n   * (prevent otherwise collectable objects from being collected). At some\n   * point, we should implement incremental \"gc\" which keeps a list of\n   * observedSets which may need clean-up and does small amounts of cleanup on a\n   * timeout until all is clean.\n   */\n\n  function getObservedObject(observer, object, arrayObserve) {\n    var dir = observedObjectCache.pop() || newObservedObject();\n    dir.open(observer);\n    dir.observe(object, arrayObserve);\n    return dir;\n  }\n\n  var observedSetCache = [];\n\n  function newObservedSet() {\n    var observerCount = 0;\n    var observers = [];\n    var objects = [];\n    var rootObj;\n    var rootObjProps;\n\n    function observe(obj, prop) {\n      if (!obj)\n        return;\n\n      if (obj === rootObj)\n        rootObjProps[prop] = true;\n\n      if (objects.indexOf(obj) < 0) {\n        objects.push(obj);\n        Object.observe(obj, callback);\n      }\n\n      observe(Object.getPrototypeOf(obj), prop);\n    }\n\n    function allRootObjNonObservedProps(recs) {\n      for (var i = 0; i < recs.length; i++) {\n        var rec = recs[i];\n        if (rec.object !== rootObj ||\n            rootObjProps[rec.name] ||\n            rec.type === 'setPrototype') {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    function callback(recs) {\n      if (allRootObjNonObservedProps(recs))\n        return;\n\n      var observer;\n      for (var i = 0; i < observers.length; i++) {\n        observer = observers[i];\n        if (observer.state_ == OPENED) {\n          observer.iterateObjects_(observe);\n        }\n      }\n\n      for (var i = 0; i < observers.length; i++) {\n        observer = observers[i];\n        if (observer.state_ == OPENED) {\n          observer.check_();\n        }\n      }\n    }\n\n    var record = {\n      object: undefined,\n      objects: objects,\n      open: function(obs, object) {\n        if (!rootObj) {\n          rootObj = object;\n          rootObjProps = {};\n        }\n\n        observers.push(obs);\n        observerCount++;\n        obs.iterateObjects_(observe);\n      },\n      close: function(obs) {\n        observerCount--;\n        if (observerCount > 0) {\n          return;\n        }\n\n        for (var i = 0; i < objects.length; i++) {\n          Object.unobserve(objects[i], callback);\n          Observer.unobservedCount++;\n        }\n\n        observers.length = 0;\n        objects.length = 0;\n        rootObj = undefined;\n        rootObjProps = undefined;\n        observedSetCache.push(this);\n      }\n    };\n\n    return record;\n  }\n\n  var lastObservedSet;\n\n  function getObservedSet(observer, obj) {\n    if (!lastObservedSet || lastObservedSet.object !== obj) {\n      lastObservedSet = observedSetCache.pop() || newObservedSet();\n      lastObservedSet.object = obj;\n    }\n    lastObservedSet.open(observer, obj);\n    return lastObservedSet;\n  }\n\n  var UNOPENED = 0;\n  var OPENED = 1;\n  var CLOSED = 2;\n  var RESETTING = 3;\n\n  var nextObserverId = 1;\n\n  function Observer() {\n    this.state_ = UNOPENED;\n    this.callback_ = undefined;\n    this.target_ = undefined; // TODO(rafaelw): Should be WeakRef\n    this.directObserver_ = undefined;\n    this.value_ = undefined;\n    this.id_ = nextObserverId++;\n  }\n\n  Observer.prototype = {\n    open: function(callback, target) {\n      if (this.state_ != UNOPENED)\n        throw Error('Observer has already been opened.');\n\n      addToAll(this);\n      this.callback_ = callback;\n      this.target_ = target;\n      this.connect_();\n      this.state_ = OPENED;\n      return this.value_;\n    },\n\n    close: function() {\n      if (this.state_ != OPENED)\n        return;\n\n      removeFromAll(this);\n      this.disconnect_();\n      this.value_ = undefined;\n      this.callback_ = undefined;\n      this.target_ = undefined;\n      this.state_ = CLOSED;\n    },\n\n    deliver: function() {\n      if (this.state_ != OPENED)\n        return;\n\n      dirtyCheck(this);\n    },\n\n    report_: function(changes) {\n      try {\n        this.callback_.apply(this.target_, changes);\n      } catch (ex) {\n        Observer._errorThrownDuringCallback = true;\n        console.error('Exception caught during observer callback: ' +\n                       (ex.stack || ex));\n      }\n    },\n\n    discardChanges: function() {\n      this.check_(undefined, true);\n      return this.value_;\n    }\n  }\n\n  var collectObservers = !hasObserve;\n  var allObservers;\n  Observer._allObserversCount = 0;\n\n  if (collectObservers) {\n    allObservers = [];\n  }\n\n  function addToAll(observer) {\n    Observer._allObserversCount++;\n    if (!collectObservers)\n      return;\n\n    allObservers.push(observer);\n  }\n\n  function removeFromAll(observer) {\n    Observer._allObserversCount--;\n  }\n\n  var runningMicrotaskCheckpoint = false;\n\n  global.Platform = global.Platform || {};\n\n  global.Platform.performMicrotaskCheckpoint = function() {\n    if (runningMicrotaskCheckpoint)\n      return;\n\n    if (!collectObservers)\n      return;\n\n    runningMicrotaskCheckpoint = true;\n\n    var cycles = 0;\n    var anyChanged, toCheck;\n\n    do {\n      cycles++;\n      toCheck = allObservers;\n      allObservers = [];\n      anyChanged = false;\n\n      for (var i = 0; i < toCheck.length; i++) {\n        var observer = toCheck[i];\n        if (observer.state_ != OPENED)\n          continue;\n\n        if (observer.check_())\n          anyChanged = true;\n\n        allObservers.push(observer);\n      }\n      if (runEOMTasks())\n        anyChanged = true;\n    } while (cycles < MAX_DIRTY_CHECK_CYCLES && anyChanged);\n\n    if (testingExposeCycleCount)\n      global.dirtyCheckCycleCount = cycles;\n\n    runningMicrotaskCheckpoint = false;\n  };\n\n  if (collectObservers) {\n    global.Platform.clearObservers = function() {\n      allObservers = [];\n    };\n  }\n\n  function ObjectObserver(object) {\n    Observer.call(this);\n    this.value_ = object;\n    this.oldObject_ = undefined;\n  }\n\n  ObjectObserver.prototype = createObject({\n    __proto__: Observer.prototype,\n\n    arrayObserve: false,\n\n    connect_: function(callback, target) {\n      if (hasObserve) {\n        this.directObserver_ = getObservedObject(this, this.value_,\n                                                 this.arrayObserve);\n      } else {\n        this.oldObject_ = this.copyObject(this.value_);\n      }\n\n    },\n\n    copyObject: function(object) {\n      var copy = Array.isArray(object) ? [] : {};\n      for (var prop in object) {\n        copy[prop] = object[prop];\n      };\n      if (Array.isArray(object))\n        copy.length = object.length;\n      return copy;\n    },\n\n    check_: function(changeRecords, skipChanges) {\n      var diff;\n      var oldValues;\n      if (hasObserve) {\n        if (!changeRecords)\n          return false;\n\n        oldValues = {};\n        diff = diffObjectFromChangeRecords(this.value_, changeRecords,\n                                           oldValues);\n      } else {\n        oldValues = this.oldObject_;\n        diff = diffObjectFromOldObject(this.value_, this.oldObject_);\n      }\n\n      if (diffIsEmpty(diff))\n        return false;\n\n      if (!hasObserve)\n        this.oldObject_ = this.copyObject(this.value_);\n\n      this.report_([\n        diff.added || {},\n        diff.removed || {},\n        diff.changed || {},\n        function(property) {\n          return oldValues[property];\n        }\n      ]);\n\n      return true;\n    },\n\n    disconnect_: function() {\n      if (hasObserve) {\n        this.directObserver_.close();\n        this.directObserver_ = undefined;\n      } else {\n        this.oldObject_ = undefined;\n      }\n    },\n\n    deliver: function() {\n      if (this.state_ != OPENED)\n        return;\n\n      if (hasObserve)\n        this.directObserver_.deliver(false);\n      else\n        dirtyCheck(this);\n    },\n\n    discardChanges: function() {\n      if (this.directObserver_)\n        this.directObserver_.deliver(true);\n      else\n        this.oldObject_ = this.copyObject(this.value_);\n\n      return this.value_;\n    }\n  });\n\n  function ArrayObserver(array) {\n    if (!Array.isArray(array))\n      throw Error('Provided object is not an Array');\n    ObjectObserver.call(this, array);\n  }\n\n  ArrayObserver.prototype = createObject({\n\n    __proto__: ObjectObserver.prototype,\n\n    arrayObserve: true,\n\n    copyObject: function(arr) {\n      return arr.slice();\n    },\n\n    check_: function(changeRecords) {\n      var splices;\n      if (hasObserve) {\n        if (!changeRecords)\n          return false;\n        splices = projectArraySplices(this.value_, changeRecords);\n      } else {\n        splices = calcSplices(this.value_, 0, this.value_.length,\n                              this.oldObject_, 0, this.oldObject_.length);\n      }\n\n      if (!splices || !splices.length)\n        return false;\n\n      if (!hasObserve)\n        this.oldObject_ = this.copyObject(this.value_);\n\n      this.report_([splices]);\n      return true;\n    }\n  });\n\n  ArrayObserver.applySplices = function(previous, current, splices) {\n    splices.forEach(function(splice) {\n      var spliceArgs = [splice.index, splice.removed.length];\n      var addIndex = splice.index;\n      while (addIndex < splice.index + splice.addedCount) {\n        spliceArgs.push(current[addIndex]);\n        addIndex++;\n      }\n\n      Array.prototype.splice.apply(previous, spliceArgs);\n    });\n  };\n\n  function PathObserver(object, path) {\n    Observer.call(this);\n\n    this.object_ = object;\n    this.path_ = getPath(path);\n    this.directObserver_ = undefined;\n  }\n\n  PathObserver.prototype = createObject({\n    __proto__: Observer.prototype,\n\n    get path() {\n      return this.path_;\n    },\n\n    connect_: function() {\n      if (hasObserve)\n        this.directObserver_ = getObservedSet(this, this.object_);\n\n      this.check_(undefined, true);\n    },\n\n    disconnect_: function() {\n      this.value_ = undefined;\n\n      if (this.directObserver_) {\n        this.directObserver_.close(this);\n        this.directObserver_ = undefined;\n      }\n    },\n\n    iterateObjects_: function(observe) {\n      this.path_.iterateObjects(this.object_, observe);\n    },\n\n    check_: function(changeRecords, skipChanges) {\n      var oldValue = this.value_;\n      this.value_ = this.path_.getValueFrom(this.object_);\n      if (skipChanges || areSameValue(this.value_, oldValue))\n        return false;\n\n      this.report_([this.value_, oldValue, this]);\n      return true;\n    },\n\n    setValue: function(newValue) {\n      if (this.path_)\n        this.path_.setValueFrom(this.object_, newValue);\n    }\n  });\n\n  function CompoundObserver(reportChangesOnOpen) {\n    Observer.call(this);\n\n    this.reportChangesOnOpen_ = reportChangesOnOpen;\n    this.value_ = [];\n    this.directObserver_ = undefined;\n    this.observed_ = [];\n  }\n\n  var observerSentinel = {};\n\n  CompoundObserver.prototype = createObject({\n    __proto__: Observer.prototype,\n\n    connect_: function() {\n      if (hasObserve) {\n        var object;\n        var needsDirectObserver = false;\n        for (var i = 0; i < this.observed_.length; i += 2) {\n          object = this.observed_[i]\n          if (object !== observerSentinel) {\n            needsDirectObserver = true;\n            break;\n          }\n        }\n\n        if (needsDirectObserver)\n          this.directObserver_ = getObservedSet(this, object);\n      }\n\n      this.check_(undefined, !this.reportChangesOnOpen_);\n    },\n\n    disconnect_: function() {\n      for (var i = 0; i < this.observed_.length; i += 2) {\n        if (this.observed_[i] === observerSentinel)\n          this.observed_[i + 1].close();\n      }\n      this.observed_.length = 0;\n      this.value_.length = 0;\n\n      if (this.directObserver_) {\n        this.directObserver_.close(this);\n        this.directObserver_ = undefined;\n      }\n    },\n\n    addPath: function(object, path) {\n      if (this.state_ != UNOPENED && this.state_ != RESETTING)\n        throw Error('Cannot add paths once started.');\n\n      var path = getPath(path);\n      this.observed_.push(object, path);\n      if (!this.reportChangesOnOpen_)\n        return;\n      var index = this.observed_.length / 2 - 1;\n      this.value_[index] = path.getValueFrom(object);\n    },\n\n    addObserver: function(observer) {\n      if (this.state_ != UNOPENED && this.state_ != RESETTING)\n        throw Error('Cannot add observers once started.');\n\n      this.observed_.push(observerSentinel, observer);\n      if (!this.reportChangesOnOpen_)\n        return;\n      var index = this.observed_.length / 2 - 1;\n      this.value_[index] = observer.open(this.deliver, this);\n    },\n\n    startReset: function() {\n      if (this.state_ != OPENED)\n        throw Error('Can only reset while open');\n\n      this.state_ = RESETTING;\n      this.disconnect_();\n    },\n\n    finishReset: function() {\n      if (this.state_ != RESETTING)\n        throw Error('Can only finishReset after startReset');\n      this.state_ = OPENED;\n      this.connect_();\n\n      return this.value_;\n    },\n\n    iterateObjects_: function(observe) {\n      var object;\n      for (var i = 0; i < this.observed_.length; i += 2) {\n        object = this.observed_[i]\n        if (object !== observerSentinel)\n          this.observed_[i + 1].iterateObjects(object, observe)\n      }\n    },\n\n    check_: function(changeRecords, skipChanges) {\n      var oldValues;\n      for (var i = 0; i < this.observed_.length; i += 2) {\n        var object = this.observed_[i];\n        var path = this.observed_[i+1];\n        var value;\n        if (object === observerSentinel) {\n          var observable = path;\n          value = this.state_ === UNOPENED ?\n              observable.open(this.deliver, this) :\n              observable.discardChanges();\n        } else {\n          value = path.getValueFrom(object);\n        }\n\n        if (skipChanges) {\n          this.value_[i / 2] = value;\n          continue;\n        }\n\n        if (areSameValue(value, this.value_[i / 2]))\n          continue;\n\n        oldValues = oldValues || [];\n        oldValues[i / 2] = this.value_[i / 2];\n        this.value_[i / 2] = value;\n      }\n\n      if (!oldValues)\n        return false;\n\n      // TODO(rafaelw): Having observed_ as the third callback arg here is\n      // pretty lame API. Fix.\n      this.report_([this.value_, oldValues, this.observed_]);\n      return true;\n    }\n  });\n\n  function identFn(value) { return value; }\n\n  function ObserverTransform(observable, getValueFn, setValueFn,\n                             dontPassThroughSet) {\n    this.callback_ = undefined;\n    this.target_ = undefined;\n    this.value_ = undefined;\n    this.observable_ = observable;\n    this.getValueFn_ = getValueFn || identFn;\n    this.setValueFn_ = setValueFn || identFn;\n    // TODO(rafaelw): This is a temporary hack. PolymerExpressions needs this\n    // at the moment because of a bug in it's dependency tracking.\n    this.dontPassThroughSet_ = dontPassThroughSet;\n  }\n\n  ObserverTransform.prototype = {\n    open: function(callback, target) {\n      this.callback_ = callback;\n      this.target_ = target;\n      this.value_ =\n          this.getValueFn_(this.observable_.open(this.observedCallback_, this));\n      return this.value_;\n    },\n\n    observedCallback_: function(value) {\n      value = this.getValueFn_(value);\n      if (areSameValue(value, this.value_))\n        return;\n      var oldValue = this.value_;\n      this.value_ = value;\n      this.callback_.call(this.target_, this.value_, oldValue);\n    },\n\n    discardChanges: function() {\n      this.value_ = this.getValueFn_(this.observable_.discardChanges());\n      return this.value_;\n    },\n\n    deliver: function() {\n      return this.observable_.deliver();\n    },\n\n    setValue: function(value) {\n      value = this.setValueFn_(value);\n      if (!this.dontPassThroughSet_ && this.observable_.setValue)\n        return this.observable_.setValue(value);\n    },\n\n    close: function() {\n      if (this.observable_)\n        this.observable_.close();\n      this.callback_ = undefined;\n      this.target_ = undefined;\n      this.observable_ = undefined;\n      this.value_ = undefined;\n      this.getValueFn_ = undefined;\n      this.setValueFn_ = undefined;\n    }\n  }\n\n  var expectedRecordTypes = {\n    add: true,\n    update: true,\n    delete: true\n  };\n\n  function diffObjectFromChangeRecords(object, changeRecords, oldValues) {\n    var added = {};\n    var removed = {};\n\n    for (var i = 0; i < changeRecords.length; i++) {\n      var record = changeRecords[i];\n      if (!expectedRecordTypes[record.type]) {\n        console.error('Unknown changeRecord type: ' + record.type);\n        console.error(record);\n        continue;\n      }\n\n      if (!(record.name in oldValues))\n        oldValues[record.name] = record.oldValue;\n\n      if (record.type == 'update')\n        continue;\n\n      if (record.type == 'add') {\n        if (record.name in removed)\n          delete removed[record.name];\n        else\n          added[record.name] = true;\n\n        continue;\n      }\n\n      // type = 'delete'\n      if (record.name in added) {\n        delete added[record.name];\n        delete oldValues[record.name];\n      } else {\n        removed[record.name] = true;\n      }\n    }\n\n    for (var prop in added)\n      added[prop] = object[prop];\n\n    for (var prop in removed)\n      removed[prop] = undefined;\n\n    var changed = {};\n    for (var prop in oldValues) {\n      if (prop in added || prop in removed)\n        continue;\n\n      var newValue = object[prop];\n      if (oldValues[prop] !== newValue)\n        changed[prop] = newValue;\n    }\n\n    return {\n      added: added,\n      removed: removed,\n      changed: changed\n    };\n  }\n\n  function newSplice(index, removed, addedCount) {\n    return {\n      index: index,\n      removed: removed,\n      addedCount: addedCount\n    };\n  }\n\n  var EDIT_LEAVE = 0;\n  var EDIT_UPDATE = 1;\n  var EDIT_ADD = 2;\n  var EDIT_DELETE = 3;\n\n  function ArraySplice() {}\n\n  ArraySplice.prototype = {\n\n    // Note: This function is *based* on the computation of the Levenshtein\n    // \"edit\" distance. The one change is that \"updates\" are treated as two\n    // edits - not one. With Array splices, an update is really a delete\n    // followed by an add. By retaining this, we optimize for \"keeping\" the\n    // maximum array items in the original array. For example:\n    //\n    //   'xxxx123' -> '123yyyy'\n    //\n    // With 1-edit updates, the shortest path would be just to update all seven\n    // characters. With 2-edit updates, we delete 4, leave 3, and add 4. This\n    // leaves the substring '123' intact.\n    calcEditDistances: function(current, currentStart, currentEnd,\n                                old, oldStart, oldEnd) {\n      // \"Deletion\" columns\n      var rowCount = oldEnd - oldStart + 1;\n      var columnCount = currentEnd - currentStart + 1;\n      var distances = new Array(rowCount);\n\n      // \"Addition\" rows. Initialize null column.\n      for (var i = 0; i < rowCount; i++) {\n        distances[i] = new Array(columnCount);\n        distances[i][0] = i;\n      }\n\n      // Initialize null row\n      for (var j = 0; j < columnCount; j++)\n        distances[0][j] = j;\n\n      for (var i = 1; i < rowCount; i++) {\n        for (var j = 1; j < columnCount; j++) {\n          if (this.equals(current[currentStart + j - 1], old[oldStart + i - 1]))\n            distances[i][j] = distances[i - 1][j - 1];\n          else {\n            var north = distances[i - 1][j] + 1;\n            var west = distances[i][j - 1] + 1;\n            distances[i][j] = north < west ? north : west;\n          }\n        }\n      }\n\n      return distances;\n    },\n\n    // This starts at the final weight, and walks \"backward\" by finding\n    // the minimum previous weight recursively until the origin of the weight\n    // matrix.\n    spliceOperationsFromEditDistances: function(distances) {\n      var i = distances.length - 1;\n      var j = distances[0].length - 1;\n      var current = distances[i][j];\n      var edits = [];\n      while (i > 0 || j > 0) {\n        if (i == 0) {\n          edits.push(EDIT_ADD);\n          j--;\n          continue;\n        }\n        if (j == 0) {\n          edits.push(EDIT_DELETE);\n          i--;\n          continue;\n        }\n        var northWest = distances[i - 1][j - 1];\n        var west = distances[i - 1][j];\n        var north = distances[i][j - 1];\n\n        var min;\n        if (west < north)\n          min = west < northWest ? west : northWest;\n        else\n          min = north < northWest ? north : northWest;\n\n        if (min == northWest) {\n          if (northWest == current) {\n            edits.push(EDIT_LEAVE);\n          } else {\n            edits.push(EDIT_UPDATE);\n            current = northWest;\n          }\n          i--;\n          j--;\n        } else if (min == west) {\n          edits.push(EDIT_DELETE);\n          i--;\n          current = west;\n        } else {\n          edits.push(EDIT_ADD);\n          j--;\n          current = north;\n        }\n      }\n\n      edits.reverse();\n      return edits;\n    },\n\n    /**\n     * Splice Projection functions:\n     *\n     * A splice map is a representation of how a previous array of items\n     * was transformed into a new array of items. Conceptually it is a list of\n     * tuples of\n     *\n     *   <index, removed, addedCount>\n     *\n     * which are kept in ascending index order of. The tuple represents that at\n     * the |index|, |removed| sequence of items were removed, and counting forward\n     * from |index|, |addedCount| items were added.\n     */\n\n    /**\n     * Lacking individual splice mutation information, the minimal set of\n     * splices can be synthesized given the previous state and final state of an\n     * array. The basic approach is to calculate the edit distance matrix and\n     * choose the shortest path through it.\n     *\n     * Complexity: O(l * p)\n     *   l: The length of the current array\n     *   p: The length of the old array\n     */\n    calcSplices: function(current, currentStart, currentEnd,\n                          old, oldStart, oldEnd) {\n      var prefixCount = 0;\n      var suffixCount = 0;\n\n      var minLength = Math.min(currentEnd - currentStart, oldEnd - oldStart);\n      if (currentStart == 0 && oldStart == 0)\n        prefixCount = this.sharedPrefix(current, old, minLength);\n\n      if (currentEnd == current.length && oldEnd == old.length)\n        suffixCount = this.sharedSuffix(current, old, minLength - prefixCount);\n\n      currentStart += prefixCount;\n      oldStart += prefixCount;\n      currentEnd -= suffixCount;\n      oldEnd -= suffixCount;\n\n      if (currentEnd - currentStart == 0 && oldEnd - oldStart == 0)\n        return [];\n\n      if (currentStart == currentEnd) {\n        var splice = newSplice(currentStart, [], 0);\n        while (oldStart < oldEnd)\n          splice.removed.push(old[oldStart++]);\n\n        return [ splice ];\n      } else if (oldStart == oldEnd)\n        return [ newSplice(currentStart, [], currentEnd - currentStart) ];\n\n      var ops = this.spliceOperationsFromEditDistances(\n          this.calcEditDistances(current, currentStart, currentEnd,\n                                 old, oldStart, oldEnd));\n\n      var splice = undefined;\n      var splices = [];\n      var index = currentStart;\n      var oldIndex = oldStart;\n      for (var i = 0; i < ops.length; i++) {\n        switch(ops[i]) {\n          case EDIT_LEAVE:\n            if (splice) {\n              splices.push(splice);\n              splice = undefined;\n            }\n\n            index++;\n            oldIndex++;\n            break;\n          case EDIT_UPDATE:\n            if (!splice)\n              splice = newSplice(index, [], 0);\n\n            splice.addedCount++;\n            index++;\n\n            splice.removed.push(old[oldIndex]);\n            oldIndex++;\n            break;\n          case EDIT_ADD:\n            if (!splice)\n              splice = newSplice(index, [], 0);\n\n            splice.addedCount++;\n            index++;\n            break;\n          case EDIT_DELETE:\n            if (!splice)\n              splice = newSplice(index, [], 0);\n\n            splice.removed.push(old[oldIndex]);\n            oldIndex++;\n            break;\n        }\n      }\n\n      if (splice) {\n        splices.push(splice);\n      }\n      return splices;\n    },\n\n    sharedPrefix: function(current, old, searchLength) {\n      for (var i = 0; i < searchLength; i++)\n        if (!this.equals(current[i], old[i]))\n          return i;\n      return searchLength;\n    },\n\n    sharedSuffix: function(current, old, searchLength) {\n      var index1 = current.length;\n      var index2 = old.length;\n      var count = 0;\n      while (count < searchLength && this.equals(current[--index1], old[--index2]))\n        count++;\n\n      return count;\n    },\n\n    calculateSplices: function(current, previous) {\n      return this.calcSplices(current, 0, current.length, previous, 0,\n                              previous.length);\n    },\n\n    equals: function(currentValue, previousValue) {\n      return currentValue === previousValue;\n    }\n  };\n\n  var arraySplice = new ArraySplice();\n\n  function calcSplices(current, currentStart, currentEnd,\n                       old, oldStart, oldEnd) {\n    return arraySplice.calcSplices(current, currentStart, currentEnd,\n                                   old, oldStart, oldEnd);\n  }\n\n  function intersect(start1, end1, start2, end2) {\n    // Disjoint\n    if (end1 < start2 || end2 < start1)\n      return -1;\n\n    // Adjacent\n    if (end1 == start2 || end2 == start1)\n      return 0;\n\n    // Non-zero intersect, span1 first\n    if (start1 < start2) {\n      if (end1 < end2)\n        return end1 - start2; // Overlap\n      else\n        return end2 - start2; // Contained\n    } else {\n      // Non-zero intersect, span2 first\n      if (end2 < end1)\n        return end2 - start1; // Overlap\n      else\n        return end1 - start1; // Contained\n    }\n  }\n\n  function mergeSplice(splices, index, removed, addedCount) {\n\n    var splice = newSplice(index, removed, addedCount);\n\n    var inserted = false;\n    var insertionOffset = 0;\n\n    for (var i = 0; i < splices.length; i++) {\n      var current = splices[i];\n      current.index += insertionOffset;\n\n      if (inserted)\n        continue;\n\n      var intersectCount = intersect(splice.index,\n                                     splice.index + splice.removed.length,\n                                     current.index,\n                                     current.index + current.addedCount);\n\n      if (intersectCount >= 0) {\n        // Merge the two splices\n\n        splices.splice(i, 1);\n        i--;\n\n        insertionOffset -= current.addedCount - current.removed.length;\n\n        splice.addedCount += current.addedCount - intersectCount;\n        var deleteCount = splice.removed.length +\n                          current.removed.length - intersectCount;\n\n        if (!splice.addedCount && !deleteCount) {\n          // merged splice is a noop. discard.\n          inserted = true;\n        } else {\n          var removed = current.removed;\n\n          if (splice.index < current.index) {\n            // some prefix of splice.removed is prepended to current.removed.\n            var prepend = splice.removed.slice(0, current.index - splice.index);\n            Array.prototype.push.apply(prepend, removed);\n            removed = prepend;\n          }\n\n          if (splice.index + splice.removed.length > current.index + current.addedCount) {\n            // some suffix of splice.removed is appended to current.removed.\n            var append = splice.removed.slice(current.index + current.addedCount - splice.index);\n            Array.prototype.push.apply(removed, append);\n          }\n\n          splice.removed = removed;\n          if (current.index < splice.index) {\n            splice.index = current.index;\n          }\n        }\n      } else if (splice.index < current.index) {\n        // Insert splice here.\n\n        inserted = true;\n\n        splices.splice(i, 0, splice);\n        i++;\n\n        var offset = splice.addedCount - splice.removed.length\n        current.index += offset;\n        insertionOffset += offset;\n      }\n    }\n\n    if (!inserted)\n      splices.push(splice);\n  }\n\n  function createInitialSplices(array, changeRecords) {\n    var splices = [];\n\n    for (var i = 0; i < changeRecords.length; i++) {\n      var record = changeRecords[i];\n      switch(record.type) {\n        case 'splice':\n          mergeSplice(splices, record.index, record.removed.slice(), record.addedCount);\n          break;\n        case 'add':\n        case 'update':\n        case 'delete':\n          if (!isIndex(record.name))\n            continue;\n          var index = toNumber(record.name);\n          if (index < 0)\n            continue;\n          mergeSplice(splices, index, [record.oldValue], 1);\n          break;\n        default:\n          console.error('Unexpected record type: ' + JSON.stringify(record));\n          break;\n      }\n    }\n\n    return splices;\n  }\n\n  function projectArraySplices(array, changeRecords) {\n    var splices = [];\n\n    createInitialSplices(array, changeRecords).forEach(function(splice) {\n      if (splice.addedCount == 1 && splice.removed.length == 1) {\n        if (splice.removed[0] !== array[splice.index])\n          splices.push(splice);\n\n        return\n      };\n\n      splices = splices.concat(calcSplices(array, splice.index, splice.index + splice.addedCount,\n                                           splice.removed, 0, splice.removed.length));\n    });\n\n    return splices;\n  }\n\n  global.Observer = Observer;\n  global.Observer.runEOM_ = runEOM;\n  global.Observer.observerSentinel_ = observerSentinel; // for testing.\n  global.Observer.hasObjectObserve = hasObserve;\n  global.ArrayObserver = ArrayObserver;\n  global.ArrayObserver.calculateSplices = function(current, previous) {\n    return arraySplice.calculateSplices(current, previous);\n  };\n\n  global.ArraySplice = ArraySplice;\n  global.ObjectObserver = ObjectObserver;\n  global.PathObserver = PathObserver;\n  global.CompoundObserver = CompoundObserver;\n  global.Path = Path;\n  global.ObserverTransform = ObserverTransform;\n})(typeof global !== 'undefined' && global && typeof module !== 'undefined' && module ? global : this || window);\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(global) {\n  'use strict';\n\n  var filter = Array.prototype.filter.call.bind(Array.prototype.filter);\n\n  function getTreeScope(node) {\n    while (node.parentNode) {\n      node = node.parentNode;\n    }\n\n    return typeof node.getElementById === 'function' ? node : null;\n  }\n\n  Node.prototype.bind = function(name, observable) {\n    console.error('Unhandled binding to Node: ', this, name, observable);\n  };\n\n  Node.prototype.bindFinished = function() {};\n\n  function updateBindings(node, name, binding) {\n    var bindings = node.bindings_;\n    if (!bindings)\n      bindings = node.bindings_ = {};\n\n    if (bindings[name])\n      binding[name].close();\n\n    return bindings[name] = binding;\n  }\n\n  function returnBinding(node, name, binding) {\n    return binding;\n  }\n\n  function sanitizeValue(value) {\n    return value == null ? '' : value;\n  }\n\n  function updateText(node, value) {\n    node.data = sanitizeValue(value);\n  }\n\n  function textBinding(node) {\n    return function(value) {\n      return updateText(node, value);\n    };\n  }\n\n  var maybeUpdateBindings = returnBinding;\n\n  Object.defineProperty(Platform, 'enableBindingsReflection', {\n    get: function() {\n      return maybeUpdateBindings === updateBindings;\n    },\n    set: function(enable) {\n      maybeUpdateBindings = enable ? updateBindings : returnBinding;\n      return enable;\n    },\n    configurable: true\n  });\n\n  Text.prototype.bind = function(name, value, oneTime) {\n    if (name !== 'textContent')\n      return Node.prototype.bind.call(this, name, value, oneTime);\n\n    if (oneTime)\n      return updateText(this, value);\n\n    var observable = value;\n    updateText(this, observable.open(textBinding(this)));\n    return maybeUpdateBindings(this, name, observable);\n  }\n\n  function updateAttribute(el, name, conditional, value) {\n    if (conditional) {\n      if (value)\n        el.setAttribute(name, '');\n      else\n        el.removeAttribute(name);\n      return;\n    }\n\n    el.setAttribute(name, sanitizeValue(value));\n  }\n\n  function attributeBinding(el, name, conditional) {\n    return function(value) {\n      updateAttribute(el, name, conditional, value);\n    };\n  }\n\n  Element.prototype.bind = function(name, value, oneTime) {\n    var conditional = name[name.length - 1] == '?';\n    if (conditional) {\n      this.removeAttribute(name);\n      name = name.slice(0, -1);\n    }\n\n    if (oneTime)\n      return updateAttribute(this, name, conditional, value);\n\n\n    var observable = value;\n    updateAttribute(this, name, conditional,\n        observable.open(attributeBinding(this, name, conditional)));\n\n    return maybeUpdateBindings(this, name, observable);\n  };\n\n  var checkboxEventType;\n  (function() {\n    // Attempt to feature-detect which event (change or click) is fired first\n    // for checkboxes.\n    var div = document.createElement('div');\n    var checkbox = div.appendChild(document.createElement('input'));\n    checkbox.setAttribute('type', 'checkbox');\n    var first;\n    var count = 0;\n    checkbox.addEventListener('click', function(e) {\n      count++;\n      first = first || 'click';\n    });\n    checkbox.addEventListener('change', function() {\n      count++;\n      first = first || 'change';\n    });\n\n    var event = document.createEvent('MouseEvent');\n    event.initMouseEvent(\"click\", true, true, window, 0, 0, 0, 0, 0, false,\n        false, false, false, 0, null);\n    checkbox.dispatchEvent(event);\n    // WebKit/Blink don't fire the change event if the element is outside the\n    // document, so assume 'change' for that case.\n    checkboxEventType = count == 1 ? 'change' : first;\n  })();\n\n  function getEventForInputType(element) {\n    switch (element.type) {\n      case 'checkbox':\n        return checkboxEventType;\n      case 'radio':\n      case 'select-multiple':\n      case 'select-one':\n        return 'change';\n      case 'range':\n        if (/Trident|MSIE/.test(navigator.userAgent))\n          return 'change';\n      default:\n        return 'input';\n    }\n  }\n\n  function updateInput(input, property, value, santizeFn) {\n    input[property] = (santizeFn || sanitizeValue)(value);\n  }\n\n  function inputBinding(input, property, santizeFn) {\n    return function(value) {\n      return updateInput(input, property, value, santizeFn);\n    }\n  }\n\n  function noop() {}\n\n  function bindInputEvent(input, property, observable, postEventFn) {\n    var eventType = getEventForInputType(input);\n\n    function eventHandler() {\n      observable.setValue(input[property]);\n      observable.discardChanges();\n      (postEventFn || noop)(input);\n      Platform.performMicrotaskCheckpoint();\n    }\n    input.addEventListener(eventType, eventHandler);\n\n    return {\n      close: function() {\n        input.removeEventListener(eventType, eventHandler);\n        observable.close();\n      },\n\n      observable_: observable\n    }\n  }\n\n  function booleanSanitize(value) {\n    return Boolean(value);\n  }\n\n  // |element| is assumed to be an HTMLInputElement with |type| == 'radio'.\n  // Returns an array containing all radio buttons other than |element| that\n  // have the same |name|, either in the form that |element| belongs to or,\n  // if no form, in the document tree to which |element| belongs.\n  //\n  // This implementation is based upon the HTML spec definition of a\n  // \"radio button group\":\n  //   http://www.whatwg.org/specs/web-apps/current-work/multipage/number-state.html#radio-button-group\n  //\n  function getAssociatedRadioButtons(element) {\n    if (element.form) {\n      return filter(element.form.elements, function(el) {\n        return el != element &&\n            el.tagName == 'INPUT' &&\n            el.type == 'radio' &&\n            el.name == element.name;\n      });\n    } else {\n      var treeScope = getTreeScope(element);\n      if (!treeScope)\n        return [];\n      var radios = treeScope.querySelectorAll(\n          'input[type=\"radio\"][name=\"' + element.name + '\"]');\n      return filter(radios, function(el) {\n        return el != element && !el.form;\n      });\n    }\n  }\n\n  function checkedPostEvent(input) {\n    // Only the radio button that is getting checked gets an event. We\n    // therefore find all the associated radio buttons and update their\n    // check binding manually.\n    if (input.tagName === 'INPUT' &&\n        input.type === 'radio') {\n      getAssociatedRadioButtons(input).forEach(function(radio) {\n        var checkedBinding = radio.bindings_.checked;\n        if (checkedBinding) {\n          // Set the value directly to avoid an infinite call stack.\n          checkedBinding.observable_.setValue(false);\n        }\n      });\n    }\n  }\n\n  HTMLInputElement.prototype.bind = function(name, value, oneTime) {\n    if (name !== 'value' && name !== 'checked')\n      return HTMLElement.prototype.bind.call(this, name, value, oneTime);\n\n    this.removeAttribute(name);\n    var sanitizeFn = name == 'checked' ? booleanSanitize : sanitizeValue;\n    var postEventFn = name == 'checked' ? checkedPostEvent : noop;\n\n    if (oneTime)\n      return updateInput(this, name, value, sanitizeFn);\n\n\n    var observable = value;\n    var binding = bindInputEvent(this, name, observable, postEventFn);\n    updateInput(this, name,\n                observable.open(inputBinding(this, name, sanitizeFn)),\n                sanitizeFn);\n\n    // Checkboxes may need to update bindings of other checkboxes.\n    return updateBindings(this, name, binding);\n  }\n\n  HTMLTextAreaElement.prototype.bind = function(name, value, oneTime) {\n    if (name !== 'value')\n      return HTMLElement.prototype.bind.call(this, name, value, oneTime);\n\n    this.removeAttribute('value');\n\n    if (oneTime)\n      return updateInput(this, 'value', value);\n\n    var observable = value;\n    var binding = bindInputEvent(this, 'value', observable);\n    updateInput(this, 'value',\n                observable.open(inputBinding(this, 'value', sanitizeValue)));\n    return maybeUpdateBindings(this, name, binding);\n  }\n\n  function updateOption(option, value) {\n    var parentNode = option.parentNode;;\n    var select;\n    var selectBinding;\n    var oldValue;\n    if (parentNode instanceof HTMLSelectElement &&\n        parentNode.bindings_ &&\n        parentNode.bindings_.value) {\n      select = parentNode;\n      selectBinding = select.bindings_.value;\n      oldValue = select.value;\n    }\n\n    option.value = sanitizeValue(value);\n\n    if (select && select.value != oldValue) {\n      selectBinding.observable_.setValue(select.value);\n      selectBinding.observable_.discardChanges();\n      Platform.performMicrotaskCheckpoint();\n    }\n  }\n\n  function optionBinding(option) {\n    return function(value) {\n      updateOption(option, value);\n    }\n  }\n\n  HTMLOptionElement.prototype.bind = function(name, value, oneTime) {\n    if (name !== 'value')\n      return HTMLElement.prototype.bind.call(this, name, value, oneTime);\n\n    this.removeAttribute('value');\n\n    if (oneTime)\n      return updateOption(this, value);\n\n    var observable = value;\n    var binding = bindInputEvent(this, 'value', observable);\n    updateOption(this, observable.open(optionBinding(this)));\n    return maybeUpdateBindings(this, name, binding);\n  }\n\n  HTMLSelectElement.prototype.bind = function(name, value, oneTime) {\n    if (name === 'selectedindex')\n      name = 'selectedIndex';\n\n    if (name !== 'selectedIndex' && name !== 'value')\n      return HTMLElement.prototype.bind.call(this, name, value, oneTime);\n\n    this.removeAttribute(name);\n\n    if (oneTime)\n      return updateInput(this, name, value);\n\n    var observable = value;\n    var binding = bindInputEvent(this, name, observable);\n    updateInput(this, name,\n                observable.open(inputBinding(this, name)));\n\n    // Option update events may need to access select bindings.\n    return updateBindings(this, name, binding);\n  }\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\n(function(global) {\n  'use strict';\n\n  function assert(v) {\n    if (!v)\n      throw new Error('Assertion failed');\n  }\n\n  var forEach = Array.prototype.forEach.call.bind(Array.prototype.forEach);\n\n  function getFragmentRoot(node) {\n    var p;\n    while (p = node.parentNode) {\n      node = p;\n    }\n\n    return node;\n  }\n\n  function searchRefId(node, id) {\n    if (!id)\n      return;\n\n    var ref;\n    var selector = '#' + id;\n    while (!ref) {\n      node = getFragmentRoot(node);\n\n      if (node.protoContent_)\n        ref = node.protoContent_.querySelector(selector);\n      else if (node.getElementById)\n        ref = node.getElementById(id);\n\n      if (ref || !node.templateCreator_)\n        break\n\n      node = node.templateCreator_;\n    }\n\n    return ref;\n  }\n\n  function getInstanceRoot(node) {\n    while (node.parentNode) {\n      node = node.parentNode;\n    }\n    return node.templateCreator_ ? node : null;\n  }\n\n  var Map;\n  if (global.Map && typeof global.Map.prototype.forEach === 'function') {\n    Map = global.Map;\n  } else {\n    Map = function() {\n      this.keys = [];\n      this.values = [];\n    };\n\n    Map.prototype = {\n      set: function(key, value) {\n        var index = this.keys.indexOf(key);\n        if (index < 0) {\n          this.keys.push(key);\n          this.values.push(value);\n        } else {\n          this.values[index] = value;\n        }\n      },\n\n      get: function(key) {\n        var index = this.keys.indexOf(key);\n        if (index < 0)\n          return;\n\n        return this.values[index];\n      },\n\n      delete: function(key, value) {\n        var index = this.keys.indexOf(key);\n        if (index < 0)\n          return false;\n\n        this.keys.splice(index, 1);\n        this.values.splice(index, 1);\n        return true;\n      },\n\n      forEach: function(f, opt_this) {\n        for (var i = 0; i < this.keys.length; i++)\n          f.call(opt_this || this, this.values[i], this.keys[i], this);\n      }\n    };\n  }\n\n  // JScript does not have __proto__. We wrap all object literals with\n  // createObject which uses Object.create, Object.defineProperty and\n  // Object.getOwnPropertyDescriptor to create a new object that does the exact\n  // same thing. The main downside to this solution is that we have to extract\n  // all those property descriptors for IE.\n  var createObject = ('__proto__' in {}) ?\n      function(obj) { return obj; } :\n      function(obj) {\n        var proto = obj.__proto__;\n        if (!proto)\n          return obj;\n        var newObject = Object.create(proto);\n        Object.getOwnPropertyNames(obj).forEach(function(name) {\n          Object.defineProperty(newObject, name,\n                               Object.getOwnPropertyDescriptor(obj, name));\n        });\n        return newObject;\n      };\n\n  // IE does not support have Document.prototype.contains.\n  if (typeof document.contains != 'function') {\n    Document.prototype.contains = function(node) {\n      if (node === this || node.parentNode === this)\n        return true;\n      return this.documentElement.contains(node);\n    }\n  }\n\n  var BIND = 'bind';\n  var REPEAT = 'repeat';\n  var IF = 'if';\n\n  var templateAttributeDirectives = {\n    'template': true,\n    'repeat': true,\n    'bind': true,\n    'ref': true\n  };\n\n  var semanticTemplateElements = {\n    'THEAD': true,\n    'TBODY': true,\n    'TFOOT': true,\n    'TH': true,\n    'TR': true,\n    'TD': true,\n    'COLGROUP': true,\n    'COL': true,\n    'CAPTION': true,\n    'OPTION': true,\n    'OPTGROUP': true\n  };\n\n  var hasTemplateElement = typeof HTMLTemplateElement !== 'undefined';\n  if (hasTemplateElement) {\n    // TODO(rafaelw): Remove when fix for\n    // https://codereview.chromium.org/164803002/\n    // makes it to Chrome release.\n    (function() {\n      var t = document.createElement('template');\n      var d = t.content.ownerDocument;\n      var html = d.appendChild(d.createElement('html'));\n      var head = html.appendChild(d.createElement('head'));\n      var base = d.createElement('base');\n      base.href = document.baseURI;\n      head.appendChild(base);\n    })();\n  }\n\n  var allTemplatesSelectors = 'template, ' +\n      Object.keys(semanticTemplateElements).map(function(tagName) {\n        return tagName.toLowerCase() + '[template]';\n      }).join(', ');\n\n  function isSVGTemplate(el) {\n    return el.tagName == 'template' &&\n           el.namespaceURI == 'http://www.w3.org/2000/svg';\n  }\n\n  function isHTMLTemplate(el) {\n    return el.tagName == 'TEMPLATE' &&\n           el.namespaceURI == 'http://www.w3.org/1999/xhtml';\n  }\n\n  function isAttributeTemplate(el) {\n    return Boolean(semanticTemplateElements[el.tagName] &&\n                   el.hasAttribute('template'));\n  }\n\n  function isTemplate(el) {\n    if (el.isTemplate_ === undefined)\n      el.isTemplate_ = el.tagName == 'TEMPLATE' || isAttributeTemplate(el);\n\n    return el.isTemplate_;\n  }\n\n  // FIXME: Observe templates being added/removed from documents\n  // FIXME: Expose imperative API to decorate and observe templates in\n  // \"disconnected tress\" (e.g. ShadowRoot)\n  document.addEventListener('DOMContentLoaded', function(e) {\n    bootstrapTemplatesRecursivelyFrom(document);\n    // FIXME: Is this needed? Seems like it shouldn't be.\n    Platform.performMicrotaskCheckpoint();\n  }, false);\n\n  function forAllTemplatesFrom(node, fn) {\n    var subTemplates = node.querySelectorAll(allTemplatesSelectors);\n\n    if (isTemplate(node))\n      fn(node)\n    forEach(subTemplates, fn);\n  }\n\n  function bootstrapTemplatesRecursivelyFrom(node) {\n    function bootstrap(template) {\n      if (!HTMLTemplateElement.decorate(template))\n        bootstrapTemplatesRecursivelyFrom(template.content);\n    }\n\n    forAllTemplatesFrom(node, bootstrap);\n  }\n\n  if (!hasTemplateElement) {\n    /**\n     * This represents a <template> element.\n     * @constructor\n     * @extends {HTMLElement}\n     */\n    global.HTMLTemplateElement = function() {\n      throw TypeError('Illegal constructor');\n    };\n  }\n\n  var hasProto = '__proto__' in {};\n\n  function mixin(to, from) {\n    Object.getOwnPropertyNames(from).forEach(function(name) {\n      Object.defineProperty(to, name,\n                            Object.getOwnPropertyDescriptor(from, name));\n    });\n  }\n\n  // http://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/templates/index.html#dfn-template-contents-owner\n  function getOrCreateTemplateContentsOwner(template) {\n    var doc = template.ownerDocument\n    if (!doc.defaultView)\n      return doc;\n    var d = doc.templateContentsOwner_;\n    if (!d) {\n      // TODO(arv): This should either be a Document or HTMLDocument depending\n      // on doc.\n      d = doc.implementation.createHTMLDocument('');\n      while (d.lastChild) {\n        d.removeChild(d.lastChild);\n      }\n      doc.templateContentsOwner_ = d;\n    }\n    return d;\n  }\n\n  function getTemplateStagingDocument(template) {\n    if (!template.stagingDocument_) {\n      var owner = template.ownerDocument;\n      if (!owner.stagingDocument_) {\n        owner.stagingDocument_ = owner.implementation.createHTMLDocument('');\n        owner.stagingDocument_.isStagingDocument = true;\n        // TODO(rafaelw): Remove when fix for\n        // https://codereview.chromium.org/164803002/\n        // makes it to Chrome release.\n        var base = owner.stagingDocument_.createElement('base');\n        base.href = document.baseURI;\n        owner.stagingDocument_.head.appendChild(base);\n\n        owner.stagingDocument_.stagingDocument_ = owner.stagingDocument_;\n      }\n\n      template.stagingDocument_ = owner.stagingDocument_;\n    }\n\n    return template.stagingDocument_;\n  }\n\n  // For non-template browsers, the parser will disallow <template> in certain\n  // locations, so we allow \"attribute templates\" which combine the template\n  // element with the top-level container node of the content, e.g.\n  //\n  //   <tr template repeat=\"{{ foo }}\"\" class=\"bar\"><td>Bar</td></tr>\n  //\n  // becomes\n  //\n  //   <template repeat=\"{{ foo }}\">\n  //   + #document-fragment\n  //     + <tr class=\"bar\">\n  //       + <td>Bar</td>\n  //\n  function extractTemplateFromAttributeTemplate(el) {\n    var template = el.ownerDocument.createElement('template');\n    el.parentNode.insertBefore(template, el);\n\n    var attribs = el.attributes;\n    var count = attribs.length;\n    while (count-- > 0) {\n      var attrib = attribs[count];\n      if (templateAttributeDirectives[attrib.name]) {\n        if (attrib.name !== 'template')\n          template.setAttribute(attrib.name, attrib.value);\n        el.removeAttribute(attrib.name);\n      }\n    }\n\n    return template;\n  }\n\n  function extractTemplateFromSVGTemplate(el) {\n    var template = el.ownerDocument.createElement('template');\n    el.parentNode.insertBefore(template, el);\n\n    var attribs = el.attributes;\n    var count = attribs.length;\n    while (count-- > 0) {\n      var attrib = attribs[count];\n      template.setAttribute(attrib.name, attrib.value);\n      el.removeAttribute(attrib.name);\n    }\n\n    el.parentNode.removeChild(el);\n    return template;\n  }\n\n  function liftNonNativeTemplateChildrenIntoContent(template, el, useRoot) {\n    var content = template.content;\n    if (useRoot) {\n      content.appendChild(el);\n      return;\n    }\n\n    var child;\n    while (child = el.firstChild) {\n      content.appendChild(child);\n    }\n  }\n\n  var templateObserver;\n  if (typeof MutationObserver == 'function') {\n    templateObserver = new MutationObserver(function(records) {\n      for (var i = 0; i < records.length; i++) {\n        records[i].target.refChanged_();\n      }\n    });\n  }\n\n  /**\n   * Ensures proper API and content model for template elements.\n   * @param {HTMLTemplateElement} opt_instanceRef The template element which\n   *     |el| template element will return as the value of its ref(), and whose\n   *     content will be used as source when createInstance() is invoked.\n   */\n  HTMLTemplateElement.decorate = function(el, opt_instanceRef) {\n    if (el.templateIsDecorated_)\n      return false;\n\n    var templateElement = el;\n    templateElement.templateIsDecorated_ = true;\n\n    var isNativeHTMLTemplate = isHTMLTemplate(templateElement) &&\n                               hasTemplateElement;\n    var bootstrapContents = isNativeHTMLTemplate;\n    var liftContents = !isNativeHTMLTemplate;\n    var liftRoot = false;\n\n    if (!isNativeHTMLTemplate) {\n      if (isAttributeTemplate(templateElement)) {\n        assert(!opt_instanceRef);\n        templateElement = extractTemplateFromAttributeTemplate(el);\n        templateElement.templateIsDecorated_ = true;\n        isNativeHTMLTemplate = hasTemplateElement;\n        liftRoot = true;\n      } else if (isSVGTemplate(templateElement)) {\n        templateElement = extractTemplateFromSVGTemplate(el);\n        templateElement.templateIsDecorated_ = true;\n        isNativeHTMLTemplate = hasTemplateElement;\n      }\n    }\n\n    if (!isNativeHTMLTemplate) {\n      fixTemplateElementPrototype(templateElement);\n      var doc = getOrCreateTemplateContentsOwner(templateElement);\n      templateElement.content_ = doc.createDocumentFragment();\n    }\n\n    if (opt_instanceRef) {\n      // template is contained within an instance, its direct content must be\n      // empty\n      templateElement.instanceRef_ = opt_instanceRef;\n    } else if (liftContents) {\n      liftNonNativeTemplateChildrenIntoContent(templateElement,\n                                               el,\n                                               liftRoot);\n    } else if (bootstrapContents) {\n      bootstrapTemplatesRecursivelyFrom(templateElement.content);\n    }\n\n    return true;\n  };\n\n  // TODO(rafaelw): This used to decorate recursively all templates from a given\n  // node. This happens by default on 'DOMContentLoaded', but may be needed\n  // in subtrees not descendent from document (e.g. ShadowRoot).\n  // Review whether this is the right public API.\n  HTMLTemplateElement.bootstrap = bootstrapTemplatesRecursivelyFrom;\n\n  var htmlElement = global.HTMLUnknownElement || HTMLElement;\n\n  var contentDescriptor = {\n    get: function() {\n      return this.content_;\n    },\n    enumerable: true,\n    configurable: true\n  };\n\n  if (!hasTemplateElement) {\n    // Gecko is more picky with the prototype than WebKit. Make sure to use the\n    // same prototype as created in the constructor.\n    HTMLTemplateElement.prototype = Object.create(htmlElement.prototype);\n\n    Object.defineProperty(HTMLTemplateElement.prototype, 'content',\n                          contentDescriptor);\n  }\n\n  function fixTemplateElementPrototype(el) {\n    if (hasProto)\n      el.__proto__ = HTMLTemplateElement.prototype;\n    else\n      mixin(el, HTMLTemplateElement.prototype);\n  }\n\n  function ensureSetModelScheduled(template) {\n    if (!template.setModelFn_) {\n      template.setModelFn_ = function() {\n        template.setModelFnScheduled_ = false;\n        var map = getBindings(template,\n            template.delegate_ && template.delegate_.prepareBinding);\n        processBindings(template, map, template.model_);\n      };\n    }\n\n    if (!template.setModelFnScheduled_) {\n      template.setModelFnScheduled_ = true;\n      Observer.runEOM_(template.setModelFn_);\n    }\n  }\n\n  mixin(HTMLTemplateElement.prototype, {\n    bind: function(name, value, oneTime) {\n      if (name != 'ref')\n        return Element.prototype.bind.call(this, name, value, oneTime);\n\n      var self = this;\n      var ref = oneTime ? value : value.open(function(ref) {\n        self.setAttribute('ref', ref);\n        self.refChanged_();\n      });\n\n      this.setAttribute('ref', ref);\n      this.refChanged_();\n      if (oneTime)\n        return;\n\n      if (!this.bindings_) {\n        this.bindings_ = { ref: value };\n      } else {\n        this.bindings_.ref = value;\n      }\n\n      return value;\n    },\n\n    processBindingDirectives_: function(directives) {\n      if (this.iterator_)\n        this.iterator_.closeDeps();\n\n      if (!directives.if && !directives.bind && !directives.repeat) {\n        if (this.iterator_) {\n          this.iterator_.close();\n          this.iterator_ = undefined;\n        }\n\n        return;\n      }\n\n      if (!this.iterator_) {\n        this.iterator_ = new TemplateIterator(this);\n      }\n\n      this.iterator_.updateDependencies(directives, this.model_);\n\n      if (templateObserver) {\n        templateObserver.observe(this, { attributes: true,\n                                         attributeFilter: ['ref'] });\n      }\n\n      return this.iterator_;\n    },\n\n    createInstance: function(model, bindingDelegate, delegate_) {\n      if (bindingDelegate)\n        delegate_ = this.newDelegate_(bindingDelegate);\n      else if (!delegate_)\n        delegate_ = this.delegate_;\n\n      if (!this.refContent_)\n        this.refContent_ = this.ref_.content;\n      var content = this.refContent_;\n      if (content.firstChild === null)\n        return emptyInstance;\n\n      var map = getInstanceBindingMap(content, delegate_);\n      var stagingDocument = getTemplateStagingDocument(this);\n      var instance = stagingDocument.createDocumentFragment();\n      instance.templateCreator_ = this;\n      instance.protoContent_ = content;\n      instance.bindings_ = [];\n      instance.terminator_ = null;\n      var instanceRecord = instance.templateInstance_ = {\n        firstNode: null,\n        lastNode: null,\n        model: model\n      };\n\n      var i = 0;\n      var collectTerminator = false;\n      for (var child = content.firstChild; child; child = child.nextSibling) {\n        // The terminator of the instance is the clone of the last child of the\n        // content. If the last child is an active template, it may produce\n        // instances as a result of production, so simply collecting the last\n        // child of the instance after it has finished producing may be wrong.\n        if (child.nextSibling === null)\n          collectTerminator = true;\n\n        var clone = cloneAndBindInstance(child, instance, stagingDocument,\n                                         map.children[i++],\n                                         model,\n                                         delegate_,\n                                         instance.bindings_);\n        clone.templateInstance_ = instanceRecord;\n        if (collectTerminator)\n          instance.terminator_ = clone;\n      }\n\n      instanceRecord.firstNode = instance.firstChild;\n      instanceRecord.lastNode = instance.lastChild;\n      instance.templateCreator_ = undefined;\n      instance.protoContent_ = undefined;\n      return instance;\n    },\n\n    get model() {\n      return this.model_;\n    },\n\n    set model(model) {\n      this.model_ = model;\n      ensureSetModelScheduled(this);\n    },\n\n    get bindingDelegate() {\n      return this.delegate_ && this.delegate_.raw;\n    },\n\n    refChanged_: function() {\n      if (!this.iterator_ || this.refContent_ === this.ref_.content)\n        return;\n\n      this.refContent_ = undefined;\n      this.iterator_.valueChanged();\n      this.iterator_.updateIteratedValue(this.iterator_.getUpdatedValue());\n    },\n\n    clear: function() {\n      this.model_ = undefined;\n      this.delegate_ = undefined;\n      if (this.bindings_ && this.bindings_.ref)\n        this.bindings_.ref.close()\n      this.refContent_ = undefined;\n      if (!this.iterator_)\n        return;\n      this.iterator_.valueChanged();\n      this.iterator_.close()\n      this.iterator_ = undefined;\n    },\n\n    setDelegate_: function(delegate) {\n      this.delegate_ = delegate;\n      this.bindingMap_ = undefined;\n      if (this.iterator_) {\n        this.iterator_.instancePositionChangedFn_ = undefined;\n        this.iterator_.instanceModelFn_ = undefined;\n      }\n    },\n\n    newDelegate_: function(bindingDelegate) {\n      if (!bindingDelegate)\n        return;\n\n      function delegateFn(name) {\n        var fn = bindingDelegate && bindingDelegate[name];\n        if (typeof fn != 'function')\n          return;\n\n        return function() {\n          return fn.apply(bindingDelegate, arguments);\n        };\n      }\n\n      return {\n        bindingMaps: {},\n        raw: bindingDelegate,\n        prepareBinding: delegateFn('prepareBinding'),\n        prepareInstanceModel: delegateFn('prepareInstanceModel'),\n        prepareInstancePositionChanged:\n            delegateFn('prepareInstancePositionChanged')\n      };\n    },\n\n    set bindingDelegate(bindingDelegate) {\n      if (this.delegate_) {\n        throw Error('Template must be cleared before a new bindingDelegate ' +\n                    'can be assigned');\n      }\n\n      this.setDelegate_(this.newDelegate_(bindingDelegate));\n    },\n\n    get ref_() {\n      var ref = searchRefId(this, this.getAttribute('ref'));\n      if (!ref)\n        ref = this.instanceRef_;\n\n      if (!ref)\n        return this;\n\n      var nextRef = ref.ref_;\n      return nextRef ? nextRef : ref;\n    }\n  });\n\n  // Returns\n  //   a) undefined if there are no mustaches.\n  //   b) [TEXT, (ONE_TIME?, PATH, DELEGATE_FN, TEXT)+] if there is at least one mustache.\n  function parseMustaches(s, name, node, prepareBindingFn) {\n    if (!s || !s.length)\n      return;\n\n    var tokens;\n    var length = s.length;\n    var startIndex = 0, lastIndex = 0, endIndex = 0;\n    var onlyOneTime = true;\n    while (lastIndex < length) {\n      var startIndex = s.indexOf('{{', lastIndex);\n      var oneTimeStart = s.indexOf('[[', lastIndex);\n      var oneTime = false;\n      var terminator = '}}';\n\n      if (oneTimeStart >= 0 &&\n          (startIndex < 0 || oneTimeStart < startIndex)) {\n        startIndex = oneTimeStart;\n        oneTime = true;\n        terminator = ']]';\n      }\n\n      endIndex = startIndex < 0 ? -1 : s.indexOf(terminator, startIndex + 2);\n\n      if (endIndex < 0) {\n        if (!tokens)\n          return;\n\n        tokens.push(s.slice(lastIndex)); // TEXT\n        break;\n      }\n\n      tokens = tokens || [];\n      tokens.push(s.slice(lastIndex, startIndex)); // TEXT\n      var pathString = s.slice(startIndex + 2, endIndex).trim();\n      tokens.push(oneTime); // ONE_TIME?\n      onlyOneTime = onlyOneTime && oneTime;\n      var delegateFn = prepareBindingFn &&\n                       prepareBindingFn(pathString, name, node);\n      // Don't try to parse the expression if there's a prepareBinding function\n      if (delegateFn == null) {\n        tokens.push(Path.get(pathString)); // PATH\n      } else {\n        tokens.push(null);\n      }\n      tokens.push(delegateFn); // DELEGATE_FN\n      lastIndex = endIndex + 2;\n    }\n\n    if (lastIndex === length)\n      tokens.push(''); // TEXT\n\n    tokens.hasOnePath = tokens.length === 5;\n    tokens.isSimplePath = tokens.hasOnePath &&\n                          tokens[0] == '' &&\n                          tokens[4] == '';\n    tokens.onlyOneTime = onlyOneTime;\n\n    tokens.combinator = function(values) {\n      var newValue = tokens[0];\n\n      for (var i = 1; i < tokens.length; i += 4) {\n        var value = tokens.hasOnePath ? values : values[(i - 1) / 4];\n        if (value !== undefined)\n          newValue += value;\n        newValue += tokens[i + 3];\n      }\n\n      return newValue;\n    }\n\n    return tokens;\n  };\n\n  function processOneTimeBinding(name, tokens, node, model) {\n    if (tokens.hasOnePath) {\n      var delegateFn = tokens[3];\n      var value = delegateFn ? delegateFn(model, node, true) :\n                               tokens[2].getValueFrom(model);\n      return tokens.isSimplePath ? value : tokens.combinator(value);\n    }\n\n    var values = [];\n    for (var i = 1; i < tokens.length; i += 4) {\n      var delegateFn = tokens[i + 2];\n      values[(i - 1) / 4] = delegateFn ? delegateFn(model, node) :\n          tokens[i + 1].getValueFrom(model);\n    }\n\n    return tokens.combinator(values);\n  }\n\n  function processSinglePathBinding(name, tokens, node, model) {\n    var delegateFn = tokens[3];\n    var observer = delegateFn ? delegateFn(model, node, false) :\n        new PathObserver(model, tokens[2]);\n\n    return tokens.isSimplePath ? observer :\n        new ObserverTransform(observer, tokens.combinator);\n  }\n\n  function processBinding(name, tokens, node, model) {\n    if (tokens.onlyOneTime)\n      return processOneTimeBinding(name, tokens, node, model);\n\n    if (tokens.hasOnePath)\n      return processSinglePathBinding(name, tokens, node, model);\n\n    var observer = new CompoundObserver();\n\n    for (var i = 1; i < tokens.length; i += 4) {\n      var oneTime = tokens[i];\n      var delegateFn = tokens[i + 2];\n\n      if (delegateFn) {\n        var value = delegateFn(model, node, oneTime);\n        if (oneTime)\n          observer.addPath(value)\n        else\n          observer.addObserver(value);\n        continue;\n      }\n\n      var path = tokens[i + 1];\n      if (oneTime)\n        observer.addPath(path.getValueFrom(model))\n      else\n        observer.addPath(model, path);\n    }\n\n    return new ObserverTransform(observer, tokens.combinator);\n  }\n\n  function processBindings(node, bindings, model, instanceBindings) {\n    for (var i = 0; i < bindings.length; i += 2) {\n      var name = bindings[i]\n      var tokens = bindings[i + 1];\n      var value = processBinding(name, tokens, node, model);\n      var binding = node.bind(name, value, tokens.onlyOneTime);\n      if (binding && instanceBindings)\n        instanceBindings.push(binding);\n    }\n\n    node.bindFinished();\n    if (!bindings.isTemplate)\n      return;\n\n    node.model_ = model;\n    var iter = node.processBindingDirectives_(bindings);\n    if (instanceBindings && iter)\n      instanceBindings.push(iter);\n  }\n\n  function parseWithDefault(el, name, prepareBindingFn) {\n    var v = el.getAttribute(name);\n    return parseMustaches(v == '' ? '{{}}' : v, name, el, prepareBindingFn);\n  }\n\n  function parseAttributeBindings(element, prepareBindingFn) {\n    assert(element);\n\n    var bindings = [];\n    var ifFound = false;\n    var bindFound = false;\n\n    for (var i = 0; i < element.attributes.length; i++) {\n      var attr = element.attributes[i];\n      var name = attr.name;\n      var value = attr.value;\n\n      // Allow bindings expressed in attributes to be prefixed with underbars.\n      // We do this to allow correct semantics for browsers that don't implement\n      // <template> where certain attributes might trigger side-effects -- and\n      // for IE which sanitizes certain attributes, disallowing mustache\n      // replacements in their text.\n      while (name[0] === '_') {\n        name = name.substring(1);\n      }\n\n      if (isTemplate(element) &&\n          (name === IF || name === BIND || name === REPEAT)) {\n        continue;\n      }\n\n      var tokens = parseMustaches(value, name, element,\n                                  prepareBindingFn);\n      if (!tokens)\n        continue;\n\n      bindings.push(name, tokens);\n    }\n\n    if (isTemplate(element)) {\n      bindings.isTemplate = true;\n      bindings.if = parseWithDefault(element, IF, prepareBindingFn);\n      bindings.bind = parseWithDefault(element, BIND, prepareBindingFn);\n      bindings.repeat = parseWithDefault(element, REPEAT, prepareBindingFn);\n\n      if (bindings.if && !bindings.bind && !bindings.repeat)\n        bindings.bind = parseMustaches('{{}}', BIND, element, prepareBindingFn);\n    }\n\n    return bindings;\n  }\n\n  function getBindings(node, prepareBindingFn) {\n    if (node.nodeType === Node.ELEMENT_NODE)\n      return parseAttributeBindings(node, prepareBindingFn);\n\n    if (node.nodeType === Node.TEXT_NODE) {\n      var tokens = parseMustaches(node.data, 'textContent', node,\n                                  prepareBindingFn);\n      if (tokens)\n        return ['textContent', tokens];\n    }\n\n    return [];\n  }\n\n  function cloneAndBindInstance(node, parent, stagingDocument, bindings, model,\n                                delegate,\n                                instanceBindings,\n                                instanceRecord) {\n    var clone = parent.appendChild(stagingDocument.importNode(node, false));\n\n    var i = 0;\n    for (var child = node.firstChild; child; child = child.nextSibling) {\n      cloneAndBindInstance(child, clone, stagingDocument,\n                            bindings.children[i++],\n                            model,\n                            delegate,\n                            instanceBindings);\n    }\n\n    if (bindings.isTemplate) {\n      HTMLTemplateElement.decorate(clone, node);\n      if (delegate)\n        clone.setDelegate_(delegate);\n    }\n\n    processBindings(clone, bindings, model, instanceBindings);\n    return clone;\n  }\n\n  function createInstanceBindingMap(node, prepareBindingFn) {\n    var map = getBindings(node, prepareBindingFn);\n    map.children = {};\n    var index = 0;\n    for (var child = node.firstChild; child; child = child.nextSibling) {\n      map.children[index++] = createInstanceBindingMap(child, prepareBindingFn);\n    }\n\n    return map;\n  }\n\n  var contentUidCounter = 1;\n\n  // TODO(rafaelw): Setup a MutationObserver on content which clears the id\n  // so that bindingMaps regenerate when the template.content changes.\n  function getContentUid(content) {\n    var id = content.id_;\n    if (!id)\n      id = content.id_ = contentUidCounter++;\n    return id;\n  }\n\n  // Each delegate is associated with a set of bindingMaps, one for each\n  // content which may be used by a template. The intent is that each binding\n  // delegate gets the opportunity to prepare the instance (via the prepare*\n  // delegate calls) once across all uses.\n  // TODO(rafaelw): Separate out the parse map from the binding map. In the\n  // current implementation, if two delegates need a binding map for the same\n  // content, the second will have to reparse.\n  function getInstanceBindingMap(content, delegate_) {\n    var contentId = getContentUid(content);\n    if (delegate_) {\n      var map = delegate_.bindingMaps[contentId];\n      if (!map) {\n        map = delegate_.bindingMaps[contentId] =\n            createInstanceBindingMap(content, delegate_.prepareBinding) || [];\n      }\n      return map;\n    }\n\n    var map = content.bindingMap_;\n    if (!map) {\n      map = content.bindingMap_ =\n          createInstanceBindingMap(content, undefined) || [];\n    }\n    return map;\n  }\n\n  Object.defineProperty(Node.prototype, 'templateInstance', {\n    get: function() {\n      var instance = this.templateInstance_;\n      return instance ? instance :\n          (this.parentNode ? this.parentNode.templateInstance : undefined);\n    }\n  });\n\n  var emptyInstance = document.createDocumentFragment();\n  emptyInstance.bindings_ = [];\n  emptyInstance.terminator_ = null;\n\n  function TemplateIterator(templateElement) {\n    this.closed = false;\n    this.templateElement_ = templateElement;\n    this.instances = [];\n    this.deps = undefined;\n    this.iteratedValue = [];\n    this.presentValue = undefined;\n    this.arrayObserver = undefined;\n  }\n\n  TemplateIterator.prototype = {\n    closeDeps: function() {\n      var deps = this.deps;\n      if (deps) {\n        if (deps.ifOneTime === false)\n          deps.ifValue.close();\n        if (deps.oneTime === false)\n          deps.value.close();\n      }\n    },\n\n    updateDependencies: function(directives, model) {\n      this.closeDeps();\n\n      var deps = this.deps = {};\n      var template = this.templateElement_;\n\n      var ifValue = true;\n      if (directives.if) {\n        deps.hasIf = true;\n        deps.ifOneTime = directives.if.onlyOneTime;\n        deps.ifValue = processBinding(IF, directives.if, template, model);\n\n        ifValue = deps.ifValue;\n\n        // oneTime if & predicate is false. nothing else to do.\n        if (deps.ifOneTime && !ifValue) {\n          this.valueChanged();\n          return;\n        }\n\n        if (!deps.ifOneTime)\n          ifValue = ifValue.open(this.updateIfValue, this);\n      }\n\n      if (directives.repeat) {\n        deps.repeat = true;\n        deps.oneTime = directives.repeat.onlyOneTime;\n        deps.value = processBinding(REPEAT, directives.repeat, template, model);\n      } else {\n        deps.repeat = false;\n        deps.oneTime = directives.bind.onlyOneTime;\n        deps.value = processBinding(BIND, directives.bind, template, model);\n      }\n\n      var value = deps.value;\n      if (!deps.oneTime)\n        value = value.open(this.updateIteratedValue, this);\n\n      if (!ifValue) {\n        this.valueChanged();\n        return;\n      }\n\n      this.updateValue(value);\n    },\n\n    /**\n     * Gets the updated value of the bind/repeat. This can potentially call\n     * user code (if a bindingDelegate is set up) so we try to avoid it if we\n     * already have the value in hand (from Observer.open).\n     */\n    getUpdatedValue: function() {\n      var value = this.deps.value;\n      if (!this.deps.oneTime)\n        value = value.discardChanges();\n      return value;\n    },\n\n    updateIfValue: function(ifValue) {\n      if (!ifValue) {\n        this.valueChanged();\n        return;\n      }\n\n      this.updateValue(this.getUpdatedValue());\n    },\n\n    updateIteratedValue: function(value) {\n      if (this.deps.hasIf) {\n        var ifValue = this.deps.ifValue;\n        if (!this.deps.ifOneTime)\n          ifValue = ifValue.discardChanges();\n        if (!ifValue) {\n          this.valueChanged();\n          return;\n        }\n      }\n\n      this.updateValue(value);\n    },\n\n    updateValue: function(value) {\n      if (!this.deps.repeat)\n        value = [value];\n      var observe = this.deps.repeat &&\n                    !this.deps.oneTime &&\n                    Array.isArray(value);\n      this.valueChanged(value, observe);\n    },\n\n    valueChanged: function(value, observeValue) {\n      if (!Array.isArray(value))\n        value = [];\n\n      if (value === this.iteratedValue)\n        return;\n\n      this.unobserve();\n      this.presentValue = value;\n      if (observeValue) {\n        this.arrayObserver = new ArrayObserver(this.presentValue);\n        this.arrayObserver.open(this.handleSplices, this);\n      }\n\n      this.handleSplices(ArrayObserver.calculateSplices(this.presentValue,\n                                                        this.iteratedValue));\n    },\n\n    getLastInstanceNode: function(index) {\n      if (index == -1)\n        return this.templateElement_;\n      var instance = this.instances[index];\n      var terminator = instance.terminator_;\n      if (!terminator)\n        return this.getLastInstanceNode(index - 1);\n\n      if (terminator.nodeType !== Node.ELEMENT_NODE ||\n          this.templateElement_ === terminator) {\n        return terminator;\n      }\n\n      var subtemplateIterator = terminator.iterator_;\n      if (!subtemplateIterator)\n        return terminator;\n\n      return subtemplateIterator.getLastTemplateNode();\n    },\n\n    getLastTemplateNode: function() {\n      return this.getLastInstanceNode(this.instances.length - 1);\n    },\n\n    insertInstanceAt: function(index, fragment) {\n      var previousInstanceLast = this.getLastInstanceNode(index - 1);\n      var parent = this.templateElement_.parentNode;\n      this.instances.splice(index, 0, fragment);\n\n      parent.insertBefore(fragment, previousInstanceLast.nextSibling);\n    },\n\n    extractInstanceAt: function(index) {\n      var previousInstanceLast = this.getLastInstanceNode(index - 1);\n      var lastNode = this.getLastInstanceNode(index);\n      var parent = this.templateElement_.parentNode;\n      var instance = this.instances.splice(index, 1)[0];\n\n      while (lastNode !== previousInstanceLast) {\n        var node = previousInstanceLast.nextSibling;\n        if (node == lastNode)\n          lastNode = previousInstanceLast;\n\n        instance.appendChild(parent.removeChild(node));\n      }\n\n      return instance;\n    },\n\n    getDelegateFn: function(fn) {\n      fn = fn && fn(this.templateElement_);\n      return typeof fn === 'function' ? fn : null;\n    },\n\n    handleSplices: function(splices) {\n      if (this.closed || !splices.length)\n        return;\n\n      var template = this.templateElement_;\n\n      if (!template.parentNode) {\n        this.close();\n        return;\n      }\n\n      ArrayObserver.applySplices(this.iteratedValue, this.presentValue,\n                                 splices);\n\n      var delegate = template.delegate_;\n      if (this.instanceModelFn_ === undefined) {\n        this.instanceModelFn_ =\n            this.getDelegateFn(delegate && delegate.prepareInstanceModel);\n      }\n\n      if (this.instancePositionChangedFn_ === undefined) {\n        this.instancePositionChangedFn_ =\n            this.getDelegateFn(delegate &&\n                               delegate.prepareInstancePositionChanged);\n      }\n\n      // Instance Removals\n      var instanceCache = new Map;\n      var removeDelta = 0;\n      for (var i = 0; i < splices.length; i++) {\n        var splice = splices[i];\n        var removed = splice.removed;\n        for (var j = 0; j < removed.length; j++) {\n          var model = removed[j];\n          var instance = this.extractInstanceAt(splice.index + removeDelta);\n          if (instance !== emptyInstance) {\n            instanceCache.set(model, instance);\n          }\n        }\n\n        removeDelta -= splice.addedCount;\n      }\n\n      // Instance Insertions\n      for (var i = 0; i < splices.length; i++) {\n        var splice = splices[i];\n        var addIndex = splice.index;\n        for (; addIndex < splice.index + splice.addedCount; addIndex++) {\n          var model = this.iteratedValue[addIndex];\n          var instance = instanceCache.get(model);\n          if (instance) {\n            instanceCache.delete(model);\n          } else {\n            if (this.instanceModelFn_) {\n              model = this.instanceModelFn_(model);\n            }\n\n            if (model === undefined) {\n              instance = emptyInstance;\n            } else {\n              instance = template.createInstance(model, undefined, delegate);\n            }\n          }\n\n          this.insertInstanceAt(addIndex, instance);\n        }\n      }\n\n      instanceCache.forEach(function(instance) {\n        this.closeInstanceBindings(instance);\n      }, this);\n\n      if (this.instancePositionChangedFn_)\n        this.reportInstancesMoved(splices);\n    },\n\n    reportInstanceMoved: function(index) {\n      var instance = this.instances[index];\n      if (instance === emptyInstance)\n        return;\n\n      this.instancePositionChangedFn_(instance.templateInstance_, index);\n    },\n\n    reportInstancesMoved: function(splices) {\n      var index = 0;\n      var offset = 0;\n      for (var i = 0; i < splices.length; i++) {\n        var splice = splices[i];\n        if (offset != 0) {\n          while (index < splice.index) {\n            this.reportInstanceMoved(index);\n            index++;\n          }\n        } else {\n          index = splice.index;\n        }\n\n        while (index < splice.index + splice.addedCount) {\n          this.reportInstanceMoved(index);\n          index++;\n        }\n\n        offset += splice.addedCount - splice.removed.length;\n      }\n\n      if (offset == 0)\n        return;\n\n      var length = this.instances.length;\n      while (index < length) {\n        this.reportInstanceMoved(index);\n        index++;\n      }\n    },\n\n    closeInstanceBindings: function(instance) {\n      var bindings = instance.bindings_;\n      for (var i = 0; i < bindings.length; i++) {\n        bindings[i].close();\n      }\n    },\n\n    unobserve: function() {\n      if (!this.arrayObserver)\n        return;\n\n      this.arrayObserver.close();\n      this.arrayObserver = undefined;\n    },\n\n    close: function() {\n      if (this.closed)\n        return;\n      this.unobserve();\n      for (var i = 0; i < this.instances.length; i++) {\n        this.closeInstanceBindings(this.instances[i]);\n      }\n\n      this.instances.length = 0;\n      this.closeDeps();\n      this.templateElement_.iterator_ = undefined;\n      this.closed = true;\n    }\n  };\n\n  // Polyfill-specific API.\n  HTMLTemplateElement.forAllTemplatesFrom_ = forAllTemplatesFrom;\n})(this);\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\nvar iterations = 0;\nvar callbacks = [];\nvar twiddle = document.createTextNode('');\n\nfunction endOfMicrotask(callback) {\n  twiddle.textContent = iterations++;\n  callbacks.push(callback);\n}\n\nfunction atEndOfMicrotask() {\n  while (callbacks.length) {\n    callbacks.shift()();\n  }\n}\n\nnew (window.MutationObserver || JsMutationObserver)(atEndOfMicrotask)\n  .observe(twiddle, {characterData: true})\n  ;\n\n// exports\n\nscope.endOfMicrotask = endOfMicrotask;\n\n})(Platform);\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// inject style sheet\nvar style = document.createElement('style');\nstyle.textContent = 'template {display: none !important;} /* injected by platform.js */';\nvar head = document.querySelector('head');\nhead.insertBefore(style, head.firstChild);\n\n// flush (with logging)\nvar flushing;\nfunction flush() {\n  if (!flushing) {\n    flushing = true;\n    scope.endOfMicrotask(function() {\n      flushing = false;\n      logFlags.data && console.group('Platform.flush()');\n      scope.performMicrotaskCheckpoint();\n      logFlags.data && console.groupEnd();\n    });\n  }\n};\n\n// polling dirty checker\n// flush periodically if platform does not have object observe.\nif (!Observer.hasObjectObserve) {\n  var FLUSH_POLL_INTERVAL = 125;\n  window.addEventListener('WebComponentsReady', function() {\n    flush();\n    scope.flushPoll = setInterval(flush, FLUSH_POLL_INTERVAL);\n  });\n} else {\n  // make flush a no-op when we have Object.observe\n  flush = function() {};\n}\n\nif (window.CustomElements && !CustomElements.useNative) {\n  var originalImportNode = Document.prototype.importNode;\n  Document.prototype.importNode = function(node, deep) {\n    var imported = originalImportNode.call(this, node, deep);\n    CustomElements.upgradeAll(imported);\n    return imported;\n  }\n}\n\n// exports\nscope.flush = flush;\n\n})(window.Platform);\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\nvar urlResolver = {\n  resolveDom: function(root, url) {\n    url = url || root.ownerDocument.baseURI;\n    this.resolveAttributes(root, url);\n    this.resolveStyles(root, url);\n    // handle template.content\n    var templates = root.querySelectorAll('template');\n    if (templates) {\n      for (var i = 0, l = templates.length, t; (i < l) && (t = templates[i]); i++) {\n        if (t.content) {\n          this.resolveDom(t.content, url);\n        }\n      }\n    }\n  },\n  resolveTemplate: function(template) {\n    this.resolveDom(template.content, template.ownerDocument.baseURI);\n  },\n  resolveStyles: function(root, url) {\n    var styles = root.querySelectorAll('style');\n    if (styles) {\n      for (var i = 0, l = styles.length, s; (i < l) && (s = styles[i]); i++) {\n        this.resolveStyle(s, url);\n      }\n    }\n  },\n  resolveStyle: function(style, url) {\n    url = url || style.ownerDocument.baseURI;\n    style.textContent = this.resolveCssText(style.textContent, url);\n  },\n  resolveCssText: function(cssText, baseUrl, keepAbsolute) {\n    cssText = replaceUrlsInCssText(cssText, baseUrl, keepAbsolute, CSS_URL_REGEXP);\n    return replaceUrlsInCssText(cssText, baseUrl, keepAbsolute, CSS_IMPORT_REGEXP);\n  },\n  resolveAttributes: function(root, url) {\n    if (root.hasAttributes && root.hasAttributes()) {\n      this.resolveElementAttributes(root, url);\n    }\n    // search for attributes that host urls\n    var nodes = root && root.querySelectorAll(URL_ATTRS_SELECTOR);\n    if (nodes) {\n      for (var i = 0, l = nodes.length, n; (i < l) && (n = nodes[i]); i++) {\n        this.resolveElementAttributes(n, url);\n      }\n    }\n  },\n  resolveElementAttributes: function(node, url) {\n    url = url || node.ownerDocument.baseURI;\n    URL_ATTRS.forEach(function(v) {\n      var attr = node.attributes[v];\n      var value = attr && attr.value;\n      var replacement;\n      if (value && value.search(URL_TEMPLATE_SEARCH) < 0) {\n        if (v === 'style') {\n          replacement = replaceUrlsInCssText(value, url, false, CSS_URL_REGEXP);\n        } else {\n          replacement = resolveRelativeUrl(url, value);\n        }\n        attr.value = replacement;\n      }\n    });\n  }\n};\n\nvar CSS_URL_REGEXP = /(url\\()([^)]*)(\\))/g;\nvar CSS_IMPORT_REGEXP = /(@import[\\s]+(?!url\\())([^;]*)(;)/g;\nvar URL_ATTRS = ['href', 'src', 'action', 'style', 'url'];\nvar URL_ATTRS_SELECTOR = '[' + URL_ATTRS.join('],[') + ']';\nvar URL_TEMPLATE_SEARCH = '{{.*}}';\n\nfunction replaceUrlsInCssText(cssText, baseUrl, keepAbsolute, regexp) {\n  return cssText.replace(regexp, function(m, pre, url, post) {\n    var urlPath = url.replace(/[\"']/g, '');\n    urlPath = resolveRelativeUrl(baseUrl, urlPath, keepAbsolute);\n    return pre + '\\'' + urlPath + '\\'' + post;\n  });\n}\n\nfunction resolveRelativeUrl(baseUrl, url, keepAbsolute) {\n  // do not resolve '/' absolute urls\n  if (url && url[0] === '/') {\n    return url;\n  }\n  var u = new URL(url, baseUrl);\n  return keepAbsolute ? u.href : makeDocumentRelPath(u.href);\n}\n\nfunction makeDocumentRelPath(url) {\n  var root = new URL(document.baseURI);\n  var u = new URL(url, root);\n  if (u.host === root.host && u.port === root.port &&\n      u.protocol === root.protocol) {\n    return makeRelPath(root, u);\n  } else {\n    return url;\n  }\n}\n\n// make a relative path from source to target\nfunction makeRelPath(sourceUrl, targetUrl) {\n  var source = sourceUrl.pathname;\n  var target = targetUrl.pathname;\n  var s = source.split('/');\n  var t = target.split('/');\n  while (s.length && s[0] === t[0]){\n    s.shift();\n    t.shift();\n  }\n  for (var i = 0, l = s.length - 1; i < l; i++) {\n    t.unshift('..');\n  }\n  return t.join('/') + targetUrl.search + targetUrl.hash;\n}\n\n// exports\nscope.urlResolver = urlResolver;\n\n})(Polymer);\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  var endOfMicrotask = Platform.endOfMicrotask;\n\n  // Generic url loader\n  function Loader(regex) {\n    this.cache = Object.create(null);\n    this.map = Object.create(null);\n    this.requests = 0;\n    this.regex = regex;\n  }\n  Loader.prototype = {\n\n    // TODO(dfreedm): there may be a better factoring here\n    // extract absolute urls from the text (full of relative urls)\n    extractUrls: function(text, base) {\n      var matches = [];\n      var matched, u;\n      while ((matched = this.regex.exec(text))) {\n        u = new URL(matched[1], base);\n        matches.push({matched: matched[0], url: u.href});\n      }\n      return matches;\n    },\n    // take a text blob, a root url, and a callback and load all the urls found within the text\n    // returns a map of absolute url to text\n    process: function(text, root, callback) {\n      var matches = this.extractUrls(text, root);\n\n      // every call to process returns all the text this loader has ever received\n      var done = callback.bind(null, this.map);\n      this.fetch(matches, done);\n    },\n    // build a mapping of url -> text from matches\n    fetch: function(matches, callback) {\n      var inflight = matches.length;\n\n      // return early if there is no fetching to be done\n      if (!inflight) {\n        return callback();\n      }\n\n      // wait for all subrequests to return\n      var done = function() {\n        if (--inflight === 0) {\n          callback();\n        }\n      };\n\n      // start fetching all subrequests\n      var m, req, url;\n      for (var i = 0; i < inflight; i++) {\n        m = matches[i];\n        url = m.url;\n        req = this.cache[url];\n        // if this url has already been requested, skip requesting it again\n        if (!req) {\n          req = this.xhr(url);\n          req.match = m;\n          this.cache[url] = req;\n        }\n        // wait for the request to process its subrequests\n        req.wait(done);\n      }\n    },\n    handleXhr: function(request) {\n      var match = request.match;\n      var url = match.url;\n\n      // handle errors with an empty string\n      var response = request.response || request.responseText || '';\n      this.map[url] = response;\n      this.fetch(this.extractUrls(response, url), request.resolve);\n    },\n    xhr: function(url) {\n      this.requests++;\n      var request = new XMLHttpRequest();\n      request.open('GET', url, true);\n      request.send();\n      request.onerror = request.onload = this.handleXhr.bind(this, request);\n\n      // queue of tasks to run after XHR returns\n      request.pending = [];\n      request.resolve = function() {\n        var pending = request.pending;\n        for(var i = 0; i < pending.length; i++) {\n          pending[i]();\n        }\n        request.pending = null;\n      };\n\n      // if we have already resolved, pending is null, async call the callback\n      request.wait = function(fn) {\n        if (request.pending) {\n          request.pending.push(fn);\n        } else {\n          endOfMicrotask(fn);\n        }\n      };\n\n      return request;\n    }\n  };\n\n  scope.Loader = Loader;\n})(Polymer);\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\nvar urlResolver = scope.urlResolver;\nvar Loader = scope.Loader;\n\nfunction StyleResolver() {\n  this.loader = new Loader(this.regex);\n}\nStyleResolver.prototype = {\n  regex: /@import\\s+(?:url)?[\"'\\(]*([^'\"\\)]*)['\"\\)]*;/g,\n  // Recursively replace @imports with the text at that url\n  resolve: function(text, url, callback) {\n    var done = function(map) {\n      callback(this.flatten(text, url, map));\n    }.bind(this);\n    this.loader.process(text, url, done);\n  },\n  // resolve the textContent of a style node\n  resolveNode: function(style, url, callback) {\n    var text = style.textContent;\n    var done = function(text) {\n      style.textContent = text;\n      callback(style);\n    };\n    this.resolve(text, url, done);\n  },\n  // flatten all the @imports to text\n  flatten: function(text, base, map) {\n    var matches = this.loader.extractUrls(text, base);\n    var match, url, intermediate;\n    for (var i = 0; i < matches.length; i++) {\n      match = matches[i];\n      url = match.url;\n      // resolve any css text to be relative to the importer, keep absolute url\n      intermediate = urlResolver.resolveCssText(map[url], url, true);\n      // flatten intermediate @imports\n      intermediate = this.flatten(intermediate, base, map);\n      text = text.replace(match.matched, intermediate);\n    }\n    return text;\n  },\n  loadStyles: function(styles, base, callback) {\n    var loaded=0, l = styles.length;\n    // called in the context of the style\n    function loadedStyle(style) {\n      loaded++;\n      if (loaded === l && callback) {\n        callback();\n      }\n    }\n    for (var i=0, s; (i<l) && (s=styles[i]); i++) {\n      this.resolveNode(s, base, loadedStyle);\n    }\n  }\n};\n\nvar styleResolver = new StyleResolver();\n\n// exports\nscope.styleResolver = styleResolver;\n\n})(Polymer);\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\n  // mixin\n\n  // copy all properties from inProps (et al) to inObj\n  function mixin(inObj/*, inProps, inMoreProps, ...*/) {\n    var obj = inObj || {};\n    for (var i = 1; i < arguments.length; i++) {\n      var p = arguments[i];\n      try {\n        for (var n in p) {\n          copyProperty(n, p, obj);\n        }\n      } catch(x) {\n      }\n    }\n    return obj;\n  }\n\n  // copy property inName from inSource object to inTarget object\n  function copyProperty(inName, inSource, inTarget) {\n    var pd = getPropertyDescriptor(inSource, inName);\n    Object.defineProperty(inTarget, inName, pd);\n  }\n\n  // get property descriptor for inName on inObject, even if\n  // inName exists on some link in inObject's prototype chain\n  function getPropertyDescriptor(inObject, inName) {\n    if (inObject) {\n      var pd = Object.getOwnPropertyDescriptor(inObject, inName);\n      return pd || getPropertyDescriptor(Object.getPrototypeOf(inObject), inName);\n    }\n  }\n\n  // exports\n\n  scope.extend = extend;\n  scope.mixin = mixin;\n\n  // for bc\n  Platform.mixin = mixin;\n\n})(Polymer);\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  // 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/*\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  \n  // polyfill DOMTokenList\n  // * add/remove: allow these methods to take multiple classNames\n  // * toggle: add a 2nd argument which forces the given state rather\n  //  than toggling.\n\n  var add = DOMTokenList.prototype.add;\n  var remove = DOMTokenList.prototype.remove;\n  DOMTokenList.prototype.add = function() {\n    for (var i = 0; i < arguments.length; i++) {\n      add.call(this, arguments[i]);\n    }\n  };\n  DOMTokenList.prototype.remove = function() {\n    for (var i = 0; i < arguments.length; i++) {\n      remove.call(this, arguments[i]);\n    }\n  };\n  DOMTokenList.prototype.toggle = function(name, bool) {\n    if (arguments.length == 1) {\n      bool = !this.contains(name);\n    }\n    bool ? this.add(name) : this.remove(name);\n  };\n  DOMTokenList.prototype.switch = function(oldName, newName) {\n    oldName && this.remove(oldName);\n    newName && this.add(newName);\n  };\n\n  // add array() to NodeList, NamedNodeMap, HTMLCollection\n\n  var ArraySlice = function() {\n    return Array.prototype.slice.call(this);\n  };\n\n  var namedNodeMap = (window.NamedNodeMap || window.MozNamedAttrMap || {});\n\n  NodeList.prototype.array = ArraySlice;\n  namedNodeMap.prototype.array = ArraySlice;\n  HTMLCollection.prototype.array = ArraySlice;\n\n  // utility\n\n  function createDOM(inTagOrNode, inHTML, inAttrs) {\n    var dom = typeof inTagOrNode == 'string' ?\n        document.createElement(inTagOrNode) : inTagOrNode.cloneNode(true);\n    dom.innerHTML = inHTML;\n    if (inAttrs) {\n      for (var n in inAttrs) {\n        dom.setAttribute(n, inAttrs[n]);\n      }\n    }\n    return dom;\n  }\n\n  // exports\n\n  scope.createDOM = createDOM;\n\n})(Polymer);\n\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/*\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  function noopHandler(value) {\n    return value;\n  }\n\n  var typeHandlers = {\n    string: noopHandler,\n    'undefined': noopHandler,\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/*\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/*\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      * @param {Boolean} bubbles Set false to prevent bubbling, defaults to true\n      * @param {Boolean} cancelable Set false to prevent cancellation, defaults to true\n      */\n    fire: function(type, detail, onNode, bubbles, cancelable) {\n      var node = onNode || this;\n      var detail = detail === null || detail === undefined ? {} : 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/*\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        PolymerGestures.addEventListener(this, type, this.element.getEventHandler(this, this, 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  // alias PolymerGestures event listener logic\n  scope.addEventListener = function(node, eventType, handlerFn, capture) {\n    PolymerGestures.addEventListener(wrap(node), eventType, handlerFn, capture);\n  };\n  scope.removeEventListener = function(node, eventType, handlerFn, capture) {\n    PolymerGestures.removeEventListener(wrap(node), eventType, handlerFn, capture);\n  };\n\n})(Polymer);\n\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/*\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(splices) {\n            this.invokeMethod(callbackName, [splices]);\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      // Present for properties which are computed and published and have a\n      // bound value.\n      var privateComputedBoundValue = name + 'ComputedBoundObservable_';\n\n      this[privateObservable] = observable;\n\n      var oldValue = this[privateName];\n\n      var self = this;\n      function updateValue(value, oldValue) {\n        self[privateName] = value;\n\n        var setObserveable = self[privateComputedBoundValue];\n        if (setObserveable && typeof setObserveable.setValue == 'function') {\n          setObserveable.setValue(value);\n        }\n \n        self.emitPropertyChangeRecord(name, value, oldValue);\n      }\n \n      var value = observable.open(updateValue);\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      updateValue(value, oldValue);\n\n      var observer = {\n        close: function() {\n          observable.close();\n          self[privateObservable] = undefined;\n          self[privateComputedBoundValue] = 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      var computed = this.element.prototype.computed;\n\n      // Binding an \"out-only\" value to a computed property. Note that\n      // since this observer isn't opened, it doesn't need to be closed on\n      // cleanup.\n      if (computed && computed[property]) {\n        var privateComputedBoundValue = property + 'ComputedBoundObservable_';\n        this[privateComputedBoundValue] = observable;\n        return;\n      }\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/*\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 template is decorated (lets' things like <tr template ...> work)\n      HTMLTemplateElement.decorate(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/*\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      if (!this.ownerDocument.isStagingDocument) {\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      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    },\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    },\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/*\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 hasShadowDOMPolyfill = window.ShadowDOMPolyfill;\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 (hasShadowDOMPolyfill) {\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      this.styleCacheForScope(scope)[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      var cache = this.styleCacheForScope(scope);\n      return cache[name];\n    },\n    styleCacheForScope: function(scope) {\n      if (hasShadowDOMPolyfill) {\n        var scopeName = scope.host ? scope.host.localName : scope.localName;\n        return polyfillScopeStyleCache[scopeName] || (polyfillScopeStyleCache[scopeName] = {});\n      } else {\n        return scope._scopeStyles = (scope._scopeStyles || {});\n      }\n    }\n  };\n\n  var polyfillScopeStyleCache = {};\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/*\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 (typeof name !== 'string') {\n      var script = prototype || document._currentScript;\n      prototype = name;\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  function instanceOfType(element, type) {\n    if (typeof type !== 'string') {\n      return false;\n    }\n    var proto = HTMLElement.getPrototypeForTag(type);\n    var ctor = proto && proto.constructor;\n    if (!ctor) {\n      return false;\n    }\n    if (CustomElements.instanceof) {\n      return CustomElements.instanceof(element, ctor);\n    }\n    return element instanceof ctor;\n  }\n\n  // exports\n\n  scope.getRegisteredPrototype = getRegisteredPrototype;\n  scope.waitingForPrototype = waitingForPrototype;\n  scope.instanceOfType = instanceOfType;\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  if (Platform.consumeDeclarations) {\n    Platform.consumeDeclarations(function(declarations) {;\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  }\n\n})(Polymer);\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\nvar path = {\n  resolveElementPaths: function(node) {\n    Polymer.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/*\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  var hasShadowDOMPolyfill = window.ShadowDOMPolyfill;\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 Polymer.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 (hasShadowDOMPolyfill) {\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/*\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        PolymerGestures.addEventListener(node, 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            PolymerGestures.removeEventListener(node, 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/*\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    //\n    // `name: value` entries in the `publish` object may need to generate \n    // matching properties on the prototype.\n    //\n    // Values that are objects may have a `reflect` property, which\n    // signals that the value describes property control metadata.\n    // In metadata objects, the prototype default value (if any)\n    // is encoded in the `value` property.\n    //\n    // publish: {\n    //   foo: 5, \n    //   bar: {value: true, reflect: true},\n    //   zot: {}\n    // }\n    //\n    // `reflect` metadata property controls whether changes to the property\n    // are reflected back to the attribute (default false). \n    //\n    // A value is stored on the prototype unless it's === `undefined`,\n    // in which case the base chain is checked for a value.\n    // If the basal value is also undefined, `null` is stored on the prototype.\n    //\n    // The reflection data is stored on another prototype object, `reflect`\n    // which also can be specified directly.\n    //\n    // reflect: {\n    //   foo: true\n    // }\n    //\n    requireProperties: function(propertyInfos, prototype, base) {\n      // per-prototype storage for 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 propertyInfos) {\n        var value = propertyInfos[n];\n        // value has metadata if it has a `reflect` property\n        if (value && value.reflect !== undefined) {\n          prototype.reflect[n] = Boolean(value.reflect);\n          value = value.value;\n        }\n        // only set a value if one is specified\n        if (value !== undefined) {\n          prototype[n] = value;\n        }\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, ignoreWrites) {\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          if (ignoreWrites) {\n            return this[privateName];\n          }\n\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._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, true);\n        }\n      }\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          // If the property is computed and published, the accessor is created\n          // above.\n          if (!prototype.computed || !prototype.computed[n]) {\n            this.createPropertyAccessor(n);\n          }\n        }\n      }\n    }\n  };\n\n  // exports\n\n  scope.api.declaration.properties = properties;\n\n})(Polymer);\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(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 into the 'publish' object\n      var attributes = this.getAttribute(ATTRIBUTES_ATTRIBUTE);\n      if (attributes) {\n        // create a `publish` object if needed.\n        // the `publish` object is only relevant to this prototype, the \n        // publishing logic in `declaration/properties.js` is responsible for\n        // managing property values on the prototype chain.\n        // TODO(sjmiles): the `publish` object is later chained to it's \n        //                ancestor object, presumably this is only for \n        //                reflection or other non-library uses. \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          // looks weird, but causes n to exist on `publish` if it does not;\n          // a more careful test would need expensive `in` operator\n          if (n && publish[n] === undefined) {\n            publish[n] = undefined;\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/*\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 && template.content;\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/*\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  var hasShadowDOMPolyfill = window.ShadowDOMPolyfill;\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 (hasShadowDOMPolyfill) {\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/*\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\n    // tell the queue to wait for an element to be ready\n    wait: function(element) {\n      if (!element.__queue) {\n        element.__queue = {};\n        elements.push(element);\n      }\n    },\n\n    // enqueue an element to the next spot in the queue.\n    enqueue: function(element, check, go) {\n      var shouldAdd = element.__queue && !element.__queue.check;\n      if (shouldAdd) {\n        queueForElement(element).push(element);\n        element.__queue.check = check;\n        element.__queue.go = go;\n      }\n      return (this.indexOf(element) !== 0);\n    },\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\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        element.__queue.flushable = true;\n        this.addToFlushQueue(readied);\n        this.check();\n      }\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\n    check: function() {\n      // next\n      var element = this.nextElement();\n      if (element) {\n        element.__queue.check.call(element);\n      }\n      if (this.canReady()) {\n        this.ready();\n        return true;\n      }\n    },\n\n    nextElement: function() {\n      return nextQueued();\n    },\n\n    canReady: function() {\n      return !this.waitToReady && this.isEmpty();\n    },\n\n    isEmpty: function() {\n      for (var i=0, l=elements.length, e; (i<l) && \n          (e=elements[i]); i++) {\n        if (e.__queue && !e.__queue.flushable) {\n          return;\n        }\n      }\n      return true;\n    },\n\n    addToFlushQueue: function(element) {\n      flushQueue.push(element);  \n    },\n\n    flush: function() {\n      // prevent re-entrance\n      if (this.flushing) {\n        return;\n      }\n      this.flushing = true;\n      var element;\n      while (flushQueue.length) {\n        element = flushQueue.shift();\n        element.__queue.go.call(element);\n        element.__queue = null;\n      }\n      this.flushing = false;\n    },\n\n    ready: function() {\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      var polyfillWasReady = CustomElements.ready;\n      CustomElements.ready = false;\n      this.flush();\n      if (!CustomElements.useNative) {\n        CustomElements.upgradeDocumentTree(document);\n      }\n      CustomElements.ready = polyfillWasReady;\n      Platform.flush();\n      requestAnimationFrame(this.flushReadyCallbacks);\n    },\n\n    addReadyCallback: function(callback) {\n      if (callback) {\n        readyCallbacks.push(callback);\n      }\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  \n    /**\n    Returns a list of elements that have had polymer-elements created but \n    are not yet ready to register. The list is an array of element definitions.\n    */\n    waitingFor: function() {\n      var e$ = [];\n      for (var i=0, l=elements.length, e; (i<l) && \n          (e=elements[i]); i++) {\n        if (e.__queue && !e.__queue.flushable) {\n          e$.push(e);\n        }\n      }\n      return e$;\n    },\n\n    waitToReady: true\n\n  };\n\n  var elements = [];\n  var flushQueue = [];\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  function whenReady(callback) {\n    queue.waitToReady = true;\n    Platform.endOfMicrotask(function() {\n      HTMLImports.whenImportsReady(function() {\n        queue.addReadyCallback(callback);\n        queue.waitToReady = false;\n        queue.check();\n    });\n    });\n  }\n\n  /**\n    Forces polymer to register any pending elements. Can be used to abort\n    waiting for elements that are partially defined.\n    @param timeout {Integer} Optional timeout in milliseconds\n  */\n  function forceReady(timeout) {\n    if (timeout === undefined) {\n      queue.ready();\n      return;\n    }\n    var handle = setTimeout(function() {\n      queue.ready();\n    }, timeout);\n    Polymer.whenReady(function() {\n      clearTimeout(handle);\n    });\n  }\n\n  // exports\n  scope.elements = elements;\n  scope.waitingFor = queue.waitingFor.bind(queue);\n  scope.forceReady = forceReady;\n  scope.queue = queue;\n  scope.whenReady = scope.whenPolymerReady = whenReady;\n})(Polymer);\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  // imports\n\n  var extend = scope.extend;\n  var api = scope.api;\n  var queue = scope.queue;\n  var whenReady = scope.whenReady;\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      queue.wait(this);\n      // initiate any async resource fetches\n      this.loadResources();\n      // register when all constraints are met\n      this.registerWhenReady();\n    },\n\n    // TODO(sorvell): we currently queue in the order the prototypes are \n    // registered, but we should queue in the order that polymer-elements\n    // are registered. We are currently blocked from doing this based on \n    // crbug.com/395686.\n    registerWhenReady: function() {\n     if (this.registered\n       || this.waitingForPrototype(this.name)\n       || this.waitingForQueue()\n       || this.waitingForResources()) {\n          return;\n      }\n      queue.go(this);\n    },\n\n    _register: function() {\n      //console.log('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    },\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        // imperative element registration\n        Polymer(name);\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.enqueue(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  whenReady(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/*\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/*\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\n//# sourceMappingURL=polymer.concat.js.map"]}