polymer.js.map

{"version":3,"file":"polymer.js","sources":["../src/polymer.js","../src/boot.js","../src/lib/lang.js","../src/lib/job.js","../src/lib/dom.js","../src/lib/super.js","../src/lib/deserialize.js","../src/api.js","../src/instance/utils.js","../src/instance/events.js","../src/instance/attributes.js","../src/instance/properties.js","../src/instance/mdv.js","../src/instance/base.js","../src/instance/styles.js","../src/declaration/polymer.js","../src/declaration/path.js","../src/declaration/styles.js","../src/declaration/events.js","../src/declaration/properties.js","../src/declaration/attributes.js","../src/declaration/prototype.js","../src/declaration/queue.js","../src/declaration/import.js","../src/declaration/polymer-element.js"],"names":["Polymer","window","scope","extend","prototype","api","Object","getOwnPropertyNames","forEach","n","pd","getOwnPropertyDescriptor","defineProperty","value","nom","job","callback","wait","stop","Job","this","go","inContext","context","boundComplete","complete","bind","h","setTimeout","handle","clearTimeout","requestAnimationFrame","cancelAnimationFrame","call","registry","HTMLElement","register","tag","getPrototypeForTag","getPrototypeOf","document","createElement","originalStopPropagation","Event","stopPropagation","cancelBubble","apply","arguments","$super","arrayOfArgs","caller","_super","nameInThis","console","warn","memoizeSuper","fn","nextSuper","proto","name","method","p","__proto__","n$","i","l","length","d","super","deserializeValue","currentValue","inferredType","Date","typeHandlers","string","date","parse","now","boolean","number","parseFloat","parseInt","isNaN","object","JSON","replace","e","function","declaration","instance","publish","apis","utils","async","args","timeout","Platform","flush","cancelAsync","Math","round","fire","type","detail","onNode","bubbles","cancelable","node","event","CustomEvent","undefined","dispatchEvent","asyncFire","classFollows","anew","old","className","classList","remove","add","nop","nob","asyncMethod","log","logFlags","EVENT_PREFIX","events","addHostListeners","eventDelegates","keys","localName","bindable","eventName","self","PolymerExpressions","prepareEventBinding","Path","get","resolveEventHandler","model","path","getValueFrom","dispatchMethod","obj","group","groupEnd","attributes","copyInstanceAttributes","a$","_instanceAttributes","k","hasAttribute","setAttribute","takeAttributes","_publishLC","a","attributeToProperty","propertyForAttribute","search","bindPattern","match","stringValue","serializeValue","reflectPropertyToAttribute","serializedValue","removeAttribute","bindProperties","inA","inProperty","observable","LOG_BIND_PROPS","inB","inPath","v","discardChanges","setValue","Observer","defineComputedProperty","properties","observeProperties","_observeNames","pn$","_publishNames","o","_propertyObserver","CompoundObserver","addPath","observeArrayValue","observe","open","notifyPropertyChanges","newValues","oldValues","paths","called","invokeMethod","callbackName","Array","isArray","unregisterObserver","observer","ArrayObserver","registerObserver","bindProperty","property","unbindAllProperties","close","unregisterObservers","unbindProperty","o$","_observers","findEventController","parentNode","lightDomController","host","unbindNodeTree","forNodeTree","_nodeUnbindAll","unbindAll","child","firstChild","nextSibling","syntax","ctlr","mdv","instanceTemplate","template","createInstance","_elementPrepared","prepareElement","unbind","path_","bindings","mixinSuper","asyncUnbindAll","_unbound","_unbindAllJob","root","shadowRoot","olderShadowRoot","cancelUnbindAll","preventCascade","mustachePattern","isBase","hasOwnProperty","PolymerBase","preparingElements","base","created","ready","createdCallback","ownerDocument","defaultView","alwaysPrepare","shadowRoots","parseDeclarations","attachedCallback","attached","enteredView","detachedCallback","preventDispose","detached","leftView","enteredViewCallback","leftViewCallback","enteredDocumentCallback","leftDocumentCallback","element","parseDeclaration","elementElement","fetchTemplate","shadowFromTemplate","querySelector","createShadowRoot","resetStyleInheritance","dom","appendChild","shadowRootReady","lightFromTemplate","marshalNodeReferences","PointerGestures","$","querySelectorAll","id","attributeChangedCallback","getAttribute","attributeChanged","onMutation","listener","MutationObserver","mutations","disconnect","childList","subtree","constructor","Base","STYLE_SCOPE_ATTRIBUTE","STYLE_CONTROLLER_SCOPE","styles","installControllerStyles","findStyleController","scopeHasElementStyle","cssText","cssTextForScope","style","cssTextToScopeStyle","applyStyleToScope","ShadowDOMPolyfill","wrap","head","descriptor","rule","getRegisteredPrototype","registerPrototype","notifyPrototype","waitingForPrototype","client","waitPrototype","registerWhenReady","prototypesByName","declarations","deliverDeclarations","resolveElementPaths","urlResolver","resolveDom","addResolvePathApi","assetPath","URL","baseURI","resolvePath","urlPath","u","href","importRuleForSheet","sheet","baseUrl","clone","createStyleElement","textContent","attr","cssTextFromSheet","__resource","matchesSelector","inSelector","matches","STYLE_SELECTOR","STYLE_LOADABLE_MATCH","SHEET_SELECTOR","STYLE_GLOBAL_SCOPE","SCOPE_ATTR","loadStyles","content","templateContent","convertSheetsToStyles","findLoadableStyles","styleResolver","s","c","s$","replaceChild","loadables","push","installSheets","cacheSheets","cacheStyles","installLocalSheets","installGlobalStyles","sheets","findNodes","removeChild","filter","insertBefore","selector","matcher","nodes","array","templateNodes","concat","styleForScope","scopeDescriptor","webkitMatchesSelector","mozMatchesSelector","parseHostEvents","delegates","addAttributeDelegates","hasEventPrefix","removeEventPrefix","trim","slice","prefixLength","inferObservers","explodeObservers","exploded","ni","names","split","optimizePropertyMaps","publishProperties","requireProperties","lowerCaseMap","map","toLowerCase","ATTRIBUTES_ATTRIBUTE","ATTRIBUTES_REGEX","inheritAttributesObjects","inheritObject","publishAttributes","accumulateInstanceAttributes","clonable","isInstanceAttribute","blackList","extends","noscript","assetpath","cache-csstext","ensurePrototypeTraversal","ancestor","extendeeName","buildPrototype","publishConstructor","extension","generateBasePrototype","desugarBeforeChaining","chainPrototypes","desugarAfterChaining","inheritMetaData","chained","chainObject","extendee","ShadowCSS","shimStyling","registerCallback","symbol","ctor","extnds","findBasePrototype","ensureBaseApi","memoizedBases","extended","create","mixinMethod","source","info","typeExtension","findTypeExtension","registerElement","indexOf","inherited","queueForElement","contains","mainQueue","importQueue","nextQueued","whenPolymerReady","queue","waitToFlush","HTMLImports","whenImportsReady","addReadyCallback","check","flushQueue","useNative","readied","shift","nextElement","canFlush","isEmpty","CustomElements","_register","upgradeDocumentTree","flushReadyCallbacks","readyCallbacks","importElements","elementOrFragment","importUrls","urls","url","link","frag","createDocumentFragment","rel","import","isRegistered","Boolean","isCustomTag","init","loadResources","registered","waitingForQueue","waitingForResources","handleNoScript","script","_needsResources","body"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKAA,WCI8B,kBAAnBC,QAAOD,UAChBA,YCLF,SAAUE,GAGR,QAASC,GAAOC,EAAWC,GAiBzB,MAhBID,IAAaC,GAEfC,OAAOC,oBAAoBF,GAAKG,QAAQ,SAASC,GAE/C,GAAIC,GAAKJ,OAAOK,yBAAyBN,EAAKI,EAC1CC,KAEFJ,OAAOM,eAAeR,EAAWK,EAAGC,GAEb,kBAAZA,GAAGG,QAEZH,EAAGG,MAAMC,IAAML,MAKhBL,EAKTF,EAAMC,OAASA,GAEdH,SC1BH,SAAUE,GA6CR,QAASa,GAAIA,EAAKC,EAAUC,GAO1B,MANIF,GACFA,EAAIG,OAEJH,EAAM,GAAII,GAAIC,MAEhBL,EAAIM,GAAGL,EAAUC,GACVF,EAzCT,GAAII,GAAM,SAASG,GACjBF,KAAKG,QAAUD,EACfF,KAAKI,cAAgBJ,KAAKK,SAASC,KAAKN,MAE1CD,GAAIf,WACFiB,GAAI,SAASL,EAAUC,GACrBG,KAAKJ,SAAWA,CAChB,IAAIW,EACCV,IAMHU,EAAIC,WAAWR,KAAKI,cAAeP,GACnCG,KAAKS,OAAS,WACZC,aAAaH,MAPfA,EAAII,sBAAsBX,KAAKI,eAC/BJ,KAAKS,OAAS,WACZG,qBAAqBL,MAS3BT,KAAM,WACAE,KAAKS,SACPT,KAAKS,SACLT,KAAKS,OAAS,OAGlBJ,SAAU,WACJL,KAAKS,SACPT,KAAKF,OACLE,KAAKJ,SAASiB,KAAKb,KAAKG,YAiB9BrB,EAAMa,IAAMA,GAEXf,SC5DH,WAEE,GAAIkC,KAEJC,aAAYC,SAAW,SAASC,EAAKjC,GACnC8B,EAASG,GAAOjC,GAIlB+B,YAAYG,mBAAqB,SAASD,GACxC,GAAIjC,GAAaiC,EAA8BH,EAASG,GAAjCF,YAAY/B,SAEnC,OAAOA,IAAaE,OAAOiC,eAAeC,SAASC,cAAcJ,IAInE,IAAIK,GAA0BC,MAAMvC,UAAUwC,eAC9CD,OAAMvC,UAAUwC,gBAAkB,WAChCxB,KAAKyB,cAAe,EACpBH,EAAwBI,MAAM1B,KAAM2B,aASrC/C,SC5BF,SAAUE,GAgBP,QAAS8C,GAAOC,GAMd,GAAIC,GAASF,EAAOE,OAEhBpC,EAAMoC,EAAOpC,IAEbqC,EAASD,EAAOC,MAYpB,IAXKA,IACErC,IACHA,EAAMoC,EAAOpC,IAAMsC,EAAWnB,KAAKb,KAAM8B,IAEtCpC,GACHuC,QAAQC,KAAK,iFAIfH,EAASI,EAAaL,EAAQpC,EAAKyB,EAAenB,QAE/C+B,EAGE,CAEL,GAAIK,GAAKL,EAAOrC,EAOhB,OALK0C,GAAGL,QACNI,EAAaC,EAAI1C,EAAKqC,GAIjBK,EAAGV,MAAM1B,KAAM6B,QAI1B,QAASQ,GAAUC,EAAOC,EAAMT,GAE9B,KAAOQ,GAAO,CACZ,GAAKA,EAAMC,KAAUT,GAAWQ,EAAMC,GACpC,MAAOD,EAETA,GAAQnB,EAAemB,IAI3B,QAASH,GAAaK,EAAQD,EAAMD,GAUlC,MANAE,GAAOT,OAASM,EAAUC,EAAOC,EAAMC,GACnCA,EAAOT,SAGTS,EAAOT,OAAOQ,GAAM7C,IAAM6C,GAErBC,EAAOT,OAGhB,QAASC,GAAWvC,GAElB,IADA,GAAIgD,GAAIzC,KAAK0C,UACND,GAAKA,IAAM1B,YAAY/B,WAAW,CAGvC,IAAK,GAAsBK,GADvBsD,EAAKzD,OAAOC,oBAAoBsD,GAC3BG,EAAE,EAAGC,EAAEF,EAAGG,OAAaD,EAAFD,IAAQvD,EAAEsD,EAAGC,IAAKA,IAAK,CACnD,GAAIG,GAAI7D,OAAOK,yBAAyBkD,EAAGpD,EAC3C,IAAuB,kBAAZ0D,GAAEtD,OAAwBsD,EAAEtD,QAAUA,EAC/C,MAAOJ,GAGXoD,EAAIA,EAAEC,WAOV,QAASvB,GAAenC,GACtB,MAAOA,GAAU0D,UAkBnB5D,EAAMkE,MAAQpB,GAEfhD,SCnHH,SAAUE,GA8CR,QAASmE,GAAiBxD,EAAOyD,GAE/B,GAAIC,SAAsBD,EAM1B,OAJIA,aAAwBE,QAC1BD,EAAe,QAGVE,EAAaF,GAAc1D,EAAOyD,GApD3C,GAAIG,IACFC,OAAQ,SAAS7D,GACf,MAAOA,IAET8D,KAAM,SAAS9D,GACb,MAAO,IAAI2D,MAAKA,KAAKI,MAAM/D,IAAU2D,KAAKK,QAE5CC,UAAS,SAASjE,GAChB,MAAc,KAAVA,GACK,EAEQ,UAAVA,GAAoB,IAAUA,GAEvCkE,OAAQ,SAASlE,GACf,GAAIJ,GAAIuE,WAAWnE,EAKnB,OAHU,KAANJ,IACFA,EAAIwE,SAASpE,IAERqE,MAAMzE,GAAKI,EAAQJ,GAK5B0E,OAAQ,SAAStE,EAAOyD,GACtB,GAAqB,OAAjBA,EACF,MAAOzD,EAET,KAIE,MAAOuE,MAAKR,MAAM/D,EAAMwE,QAAQ,KAAM,MACtC,MAAMC,GAEN,MAAOzE,KAIX0E,WAAY,SAAS1E,EAAOyD,GAC1B,MAAOA,IAiBXpE,GAAMmE,iBAAmBA,GAExBrE,SC9DH,SAAUE,GAIR,GAAIC,GAASD,EAAMC,OAIfE,IAEJA,GAAImF,eACJnF,EAAIoF,YAEJpF,EAAIqF,QAAU,SAASC,EAAMvF,GAC3B,IAAK,GAAIK,KAAKkF,GACZxF,EAAOC,EAAWuF,EAAKlF,KAM3BP,EAAMG,IAAMA,GAEXL,SCvBH,SAAUE,GAER,GAAI0F,IASFC,MAAO,SAASjC,EAAQkC,EAAMC,GAG5BC,SAASC,QAETH,EAAQA,GAAQA,EAAK5B,OAAU4B,GAAQA,EAEvC,IAAItC,GAAK,YACNpC,KAAKwC,IAAWA,GAAQd,MAAM1B,KAAM0E,IACrCpE,KAAKN,MAEHS,EAASkE,EAAUnE,WAAW4B,EAAIuC,GAClChE,sBAAsByB,EAE1B,OAAOuC,GAAUlE,EAAS,EAAIA,GAEhCqE,YAAa,SAASrE,GACP,EAATA,EACFG,qBAAqBmE,KAAKC,MAAM,EAAIvE,IAEpCC,aAAaD,IAWjBwE,KAAM,SAASC,EAAMC,EAAQC,EAAQC,EAASC,GAC5C,GAAIC,GAAOH,GAAUpF,KACjBmF,EAASA,MACTK,EAAQ,GAAIC,aAAYP,GAC1BG,QAAsBK,SAAZL,EAAwBA,GAAU,EAC5CC,WAA4BI,SAAfJ,EAA2BA,GAAa,EACrDH,OAAQA,GAGV,OADAI,GAAKI,cAAcH,GACZA,GASTI,UAAW,WACT5F,KAAKyE,MAAM,OAAQ9C,YASrBkE,aAAc,SAASC,EAAMC,EAAKC,GAC5BD,GACFA,EAAIE,UAAUC,OAAOF,GAEnBF,GACFA,EAAKG,UAAUE,IAAIH,KAMrBI,EAAM,aAGNC,IAIJ7B,GAAM8B,YAAc9B,EAAMC,MAI1B3F,EAAMG,IAAIoF,SAASG,MAAQA,EAC3B1F,EAAMsH,IAAMA,EACZtH,EAAMuH,IAAMA,GAEXzH,SC/FH,SAAUE,GAIR,GAAIyH,GAAM1H,OAAO2H,aACbC,EAAe,MAGfC,GAEFD,aAAcA,EAEdE,iBAAkB,WAChB,GAAID,GAAS1G,KAAK4G,cAClBL,GAAIG,QAAWxH,OAAO2H,KAAKH,GAAQ5D,OAAS,GAAMb,QAAQsE,IAAI,yBAA0BvG,KAAK8G,UAAWJ,EAOxG,IAAiBK,GAAUC,EAAvBC,EAAOjH,IACX,KAAK,GAAIX,KAAKqH,GACZM,EAAYP,EAAepH,GAC3B0H,EAAWG,mBAAmBC,oBAAoBC,KAAKC,IAAIX,EAAOrH,IAC9D2H,GACFM,oBAAqB,SAASC,EAAOC,GACnC,GAAIpF,GAAKoF,EAAKC,aAAaR,EAC3B,OAAI7E,GACKA,EAAG9B,KAAK2G,GADjB,WAKKjH,KAAMA,MAAM,IAIzB0H,eAAgB,SAASC,EAAKnF,EAAQkC,GACpC,GAAIiD,EAAK,CACPpB,EAAIG,QAAUzE,QAAQ2F,MAAM,qBAAsBD,EAAIb,UAAWtE,EACjE,IAAIJ,GAAuB,kBAAXI,GAAwBA,EAASmF,EAAInF,EACjDJ,IACFA,EAAGsC,EAAO,QAAU,QAAQiD,EAAKjD,GAEnC6B,EAAIG,QAAUzE,QAAQ4F,WACtBjD,SAASC,UAOf/F,GAAMG,IAAIoF,SAASqC,OAASA,GAE3B9H,SCvDH,SAAUE,GAIR,GAAIgJ,IACFC,uBAAwB,WACtB,GAAIC,GAAKhI,KAAKiI,mBACd,KAAK,GAAIC,KAAKF,GACPhI,KAAKmI,aAAaD,IACrBlI,KAAKoI,aAAaF,EAAGF,EAAGE,KAK9BG,eAAgB,WAGd,GAAIrI,KAAKsI,WACP,IAAK,GAA0CC,GAAtC3F,EAAE,EAAGoF,EAAGhI,KAAK8H,WAAYjF,EAAEmF,EAAGlF,QAAYyF,EAAEP,EAAGpF,KAASC,EAAFD,EAAKA,IAClE5C,KAAKwI,oBAAoBD,EAAEhG,KAAMgG,EAAE9I,QAMzC+I,oBAAqB,SAASjG,EAAM9C,GAGlC,GAAI8C,GAAOvC,KAAKyI,qBAAqBlG,EACrC,IAAIA,EAAM,CAIR,GAAI9C,GAASA,EAAMiJ,OAAO5J,EAAM6J,cAAgB,EAC9C,MAGF,IAAIzF,GAAelD,KAAKuC,GAEpB9C,EAAQO,KAAKiD,iBAAiBxD,EAAOyD,EAErCzD,KAAUyD,IAEZlD,KAAKuC,GAAQ9C,KAKnBgJ,qBAAsB,SAASlG,GAC7B,GAAIqG,GAAQ5I,KAAKsI,YAActI,KAAKsI,WAAW/F,EAE/C,OAAOqG,IAGT3F,iBAAkB,SAAS4F,EAAa3F,GACtC,MAAOpE,GAAMmE,iBAAiB4F,EAAa3F,IAE7C4F,eAAgB,SAASrJ,EAAO0D,GAC9B,MAAqB,YAAjBA,EACK1D,EAAQ,GAAKiG,OACM,WAAjBvC,GAA8C,aAAjBA,GACvBuC,SAAVjG,EACEA,EAFF,QAKTsJ,2BAA4B,SAASxG,GACnC,GAAIY,SAAsBnD,MAAKuC,GAE3ByG,EAAkBhJ,KAAK8I,eAAe9I,KAAKuC,GAAOY,EAE9BuC,UAApBsD,EACFhJ,KAAKoI,aAAa7F,EAAMyG,GAME,YAAjB7F,GACTnD,KAAKiJ,gBAAgB1G,IAO3BzD,GAAMG,IAAIoF,SAASyD,WAAaA,GAE/BlJ,SCvFH,SAAUE,GA0HR,QAASoK,GAAeC,EAAKC,EAAYC,GACvC9C,EAAIjG,MAAQ2B,QAAQsE,IAAI+C,EAAgBC,IAAIzC,WAAa,SAAU0C,OAAQL,EAAIrC,UAAWsC,EAI1F,IAAIK,GAAIJ,EAAWK,gBAInB,QAHU,OAAND,GAAoB/D,SAAN+D,IAChBJ,EAAWM,SAASR,EAAIC,IAEnBQ,SAASC,uBAAuBV,EAAKC,EAAYC,GA/H1D,GAAI9C,GAAM1H,OAAO2H,aAUbsD,GACFC,kBAAmB,WACjB,GAAIpH,GAAK3C,KAAKgK,cAAeC,EAAMjK,KAAKkK,aACxC,IAAKvH,GAAMA,EAAGG,QAAYmH,GAAOA,EAAInH,OAAS,CAG5C,IAAK,GAAsBzD,GADvB8K,EAAInK,KAAKoK,kBAAoB,GAAIC,kBAC5BzH,EAAE,EAAGC,EAAEF,EAAGG,OAAcD,EAAFD,IAASvD,EAAEsD,EAAGC,IAAKA,IAAK,CACrDuH,EAAEG,QAAQtK,KAAMX,EAEhB,IAAIC,GAAKJ,OAAOK,yBAAyBS,KAAK0C,UAAWrD,EACrDC,IAAMA,EAAGG,OACXO,KAAKuK,kBAAkBlL,EAAGC,EAAGG,MAAO,MAGxC,IAAK,GAAuBJ,GAAnBuD,EAAE,EAAGC,EAAEoH,EAAInH,OAAcD,EAAFD,IAASvD,EAAE4K,EAAIrH,IAAKA,IAC7C5C,KAAKwK,SAAgC9E,SAApB1F,KAAKwK,QAAQnL,IACjC8K,EAAEG,QAAQtK,KAAMX,EAGpB8K,GAAEM,KAAKzK,KAAK0K,sBAAuB1K,QAGvC0K,sBAAuB,SAASC,EAAWC,EAAWC,GACpD,GAAItI,GAAMC,EAAQsI,IAClB,KAAK,GAAIlI,KAAKgI,GAEZrI,EAAOsI,EAAM,EAAIjI,EAAI,GACM8C,SAAvB1F,KAAKsE,QAAQ/B,IACfvC,KAAK+I,2BAA2BxG,GAElCC,EAASxC,KAAKwK,QAAQjI,GAClBC,IACFxC,KAAKuK,kBAAkBhI,EAAMoI,EAAU/H,GAAIgI,EAAUhI,IAChDkI,EAAOtI,KACVsI,EAAOtI,IAAU,EAEjBxC,KAAK+K,aAAavI,GAASoI,EAAUhI,GAAI+H,EAAU/H,GAAIjB,eAK/D4I,kBAAmB,SAAShI,EAAM9C,EAAOsG,GAEvC,GAAIiF,GAAehL,KAAKwK,QAAQjI,EAChC,IAAIyI,IAEEC,MAAMC,QAAQnF,KAChBQ,EAAIiE,SAAWvI,QAAQsE,IAAI,mDAAoDvG,KAAK8G,UAAWvE,GAC/FvC,KAAKmL,mBAAmB5I,EAAO,YAG7B0I,MAAMC,QAAQzL,IAAQ,CACxB8G,EAAIiE,SAAWvI,QAAQsE,IAAI,iDAAkDvG,KAAK8G,UAAWvE,EAAM9C,EACnG,IAAI2L,GAAW,GAAIC,eAAc5L,EACjC2L,GAASX,KAAK,SAAShL,EAAOsG,GAC5B/F,KAAK+K,aAAaC,GAAejF,KAChC/F,MACHA,KAAKsL,iBAAiB/I,EAAO,UAAW6I,KAI9CG,aAAc,SAASC,EAAUnC,GAE/B,MAAOH,GAAelJ,KAAMwL,EAAUnC,IAExCoC,oBAAqB,WACfzL,KAAKoK,mBACPpK,KAAKoK,kBAAkBsB,QAEzB1L,KAAK2L,uBAEPC,eAAgB,SAASrJ,GACvB,MAAOvC,MAAKmL,mBAAmB5I,IAEjCwI,aAAc,SAASvI,EAAQkC,GAC7B,GAAItC,GAAKpC,KAAKwC,IAAWA,CACP,mBAAPJ,IACTA,EAAGV,MAAM1B,KAAM0E,IAInB4G,iBAAkB,SAAS/I,EAAM6I,GAC/B,GAAIS,GAAK7L,KAAK8L,aAAe9L,KAAK8L,cAClCD,GAAGtJ,GAAQ6I,GAEbD,mBAAoB,SAAS5I,GAC3B,GAAIsJ,GAAK7L,KAAK8L,UACd,OAAID,IAAMA,EAAGtJ,IACXsJ,EAAGtJ,GAAMmJ,QACTG,EAAGtJ,GAAQ,MACJ,GAHT,QAMFoJ,oBAAqB,WACnB,GAAI3L,KAAK8L,WAAY,CAEnB,IAAK,GAAwB5D,GAAGiC,EAD5BtD,EAAK3H,OAAO2H,KAAK7G,KAAK8L,YACjBlJ,EAAE,EAAGC,EAAEgE,EAAK/D,OAAmBD,EAAJD,IAAWsF,EAAErB,EAAKjE,IAAKA,IACzDuH,EAAInK,KAAK8L,WAAW5D,GACpBiC,EAAEuB,OAEJ1L,MAAK8L,iBAwBPxC,EAAiB,yCAIrBxK,GAAMG,IAAIoF,SAASyF,WAAaA,GAE/BlL,SChJH,SAAUE,GAqBR,QAASiN,GAAoBxG,GAC3B,KAAOA,EAAKyG,YAAY,CACtB,GAAIzG,EAAK0G,mBACP,MAAO1G,EAETA,GAAOA,EAAKyG,WAEd,MAAOzG,GAAK2G,KA2Ed,QAASC,GAAe5G,GACtB6G,EAAY7G,EAAM8G,GAGpB,QAASA,GAAe9G,GACtBA,EAAK+G,YAGP,QAASF,GAAY7G,EAAM3F,GACzB,GAAI2F,EAAM,CACR3F,EAAS2F,EACT,KAAK,GAAIgH,GAAQhH,EAAKiH,WAAYD,EAAOA,EAAQA,EAAME,YACrDL,EAAYG,EAAO3M,IA/GzB,GAAI2G,GAAM1H,OAAO2H,UAAY,EAGzBkG,GAFS5N,EAAMG,IAAIoF,SAASqC,OAEnB,GAAIQ,oBACjBwF,GAAOpF,oBAAsB,SAASC,EAAOC,EAAMjC,GACjD,GAAIoH,GAAOZ,EAAoBxG,EAC/B,IAAIoH,EAAM,CACR,GAAIvK,GAAKoF,EAAKC,aAAakF,EAC3B,IAAIvK,EACF,MAAOA,GAAG9B,KAAKqM,IAoBrB,IAAIC,IACFF,OAAQA,EACRG,iBAAkB,SAASC,GACzB,MAAOA,GAASC,eAAe/M,KAAMA,KAAK0M,SAE5CpM,KAAM,SAASiC,EAAM8G,GAGdrJ,KAAKgN,kBACRhN,KAAKiN,gBAEP,IAAIzB,GAAWxL,KAAKyI,qBAAqBlG,EACzC,IAAKiJ,EAIE,CAELxL,KAAKkN,OAAO3K,EAEZ,IAAI6I,GAAWpL,KAAKuL,aAAaC,EAAUnC,EAO3C,OALA+B,GAAS5D,KAAO6B,EAAW8D,MAI3BnN,KAAK+I,2BAA2ByC,GACzBxL,KAAKoN,SAAS7K,GAAQ6I,EAZ7B,MAAOpL,MAAKqN,WAAW1L,YAe3B2L,eAAgB,WACTtN,KAAKuN,WACRhH,EAAI2G,QAAUjL,QAAQsE,IAAI,sBAAuBvG,KAAK8G,WACtD9G,KAAKwN,cAAgBxN,KAAKL,IAAIK,KAAKwN,cAAexN,KAAKsM,UAAW,KAGtEA,UAAW,WACT,IAAKtM,KAAKuN,SAAU,CAClBvN,KAAKyL,sBACLzL,KAAKgD,OAGL,KADA,GAAIyK,GAAOzN,KAAK0N,WACTD,GACLtB,EAAesB,GACfA,EAAOA,EAAKE,eAEd3N,MAAKuN,UAAW,IAGpBK,gBAAiB,SAASC,GACxB,MAAI7N,MAAKuN,cACPhH,EAAI2G,QAAUjL,QAAQC,KAAK,gDAAiDlC,KAAK8G,aAGnFP,EAAI2G,QAAUjL,QAAQsE,IAAI,uBAAwBvG,KAAK8G,WACnD9G,KAAKwN,gBACPxN,KAAKwN,cAAgBxN,KAAKwN,cAAc1N,aAIrC+N,GACHzB,EAAYpM,KAAK0N,WAAY,SAASrO,GAChCA,EAAEuO,iBACJvO,EAAEuO,wBAwBRE,EAAkB,gBAItBhP,GAAM6J,YAAcmF,EACpBhP,EAAMG,IAAIoF,SAASuI,IAAMA,GAExBhO,SC/HH,SAAUE,GA4LR,QAASiP,GAAOhK,GACd,MAAOA,GAAOiK,eAAe,eAK/B,QAASC,MAjMT,GAAIC,GAAoB,EAEpBC,GACFF,aAAa,EACbtO,IAAKf,QAAQe,IACbqD,QAAOpE,QAAQoE,MAEfoL,QAAS,aAITC,MAAO,aAEPC,gBAAiB,WACftO,KAAKoO,WACDpO,KAAKuO,cAAcC,aAAexO,KAAKyO,eACvCP,EAAoB,IACtBlO,KAAKiN,kBAITA,eAAgB,WACdjN,KAAKgN,kBAAmB,EAExBhN,KAAK0O,eAEL1O,KAAK+J,oBAEL/J,KAAK+H,yBAEL/H,KAAKqI,iBAELrI,KAAK2G,mBAGLuH,IAEAlO,KAAK2O,kBAAkB3O,KAAK0C,WAE5BwL,IAIAlO,KAAKiJ,gBAAgB,cAErBjJ,KAAKqO,SAEPO,iBAAkB,WACX5O,KAAKgN,kBACRhN,KAAKiN,iBAEPjN,KAAK4N,iBAAgB,GAEjB5N,KAAK6O,UACP7O,KAAK6O,WAGH7O,KAAK8O,aACP9O,KAAK8O,eAGTC,iBAAkB,WACX/O,KAAKgP,gBACRhP,KAAKsN,iBAGHtN,KAAKiP,UACPjP,KAAKiP,WAGHjP,KAAKkP,UACPlP,KAAKkP,YAITC,oBAAqB,WACnBnP,KAAK4O,oBAGPQ,iBAAkB,WAChBpP,KAAK+O,oBAGPM,wBAAyB,WACvBrP,KAAK4O,oBAGPU,qBAAsB,WACpBtP,KAAK+O,oBAGPJ,kBAAmB,SAASlM,GACtBA,GAAKA,EAAE8M,UACTvP,KAAK2O,kBAAkBlM,EAAEC,WACzBD,EAAE+M,iBAAiB3O,KAAKb,KAAMyC,EAAE8M,WAIpCC,iBAAkB,SAASC,GACzB,GAAI3C,GAAW9M,KAAK0P,cAAcD,EAClC,IAAI3C,EAAU,CACZ,GAAIW,GAAOzN,KAAK2P,mBAAmB7C,EACnC9M,MAAK0O,YAAYe,EAAelN,MAAQkL,IAI5CiC,cAAe,SAASD,GACtB,MAAOA,GAAeG,cAAc,aAGtCD,mBAAoB,SAAS7C,GAC3B,GAAIA,EAAU,CAEZ,GAAIW,GAAOzN,KAAK6P,kBAEhBpC,GAAKqC,sBAAwB9P,KAAK8P,qBAKlC,IAAIC,GAAM/P,KAAK6M,iBAAiBC,EAMhC,OAJAW,GAAKuC,YAAYD,GAEjB/P,KAAKiQ,gBAAgBxC,EAAMX,GAEpBW,IAIXyC,kBAAmB,SAASpD,GAC1B,GAAIA,EAAU,CAKZ9M,KAAKiM,oBAAqB,CAK1B,IAAI8D,GAAM/P,KAAK6M,iBAAiBC,EAMhC,OAJA9M,MAAKgQ,YAAYD,GAEjB/P,KAAKiQ,gBAAgBjQ,KAAM8M,GAEpBiD,IAGXE,gBAAiB,SAASxC,GAExBzN,KAAKmQ,sBAAsB1C,GAE3B2C,gBAAgBpP,SAASyM,IAG3B0C,sBAAuB,SAAS1C,GAE9B,GAAI4C,GAAIrQ,KAAKqQ,EAAIrQ,KAAKqQ,KAEtB,IAAI5C,EAEF,IAAK,GAAsBpO,GADvBsD,EAAK8K,EAAK6C,iBAAiB,QACtB1N,EAAE,EAAGC,EAAEF,EAAGG,OAAcD,EAAFD,IAASvD,EAAEsD,EAAGC,IAAKA,IAChDyN,EAAEhR,EAAEkR,IAAMlR,GAIhBmR,yBAA0B,SAASjO,GAEpB,UAATA,GAA6B,UAATA,GACtBvC,KAAKwI,oBAAoBjG,EAAMvC,KAAKyQ,aAAalO,IAE/CvC,KAAK0Q,kBACP1Q,KAAK0Q,iBAAiBhP,MAAM1B,KAAM2B,YAGtCgP,WAAY,SAASpL,EAAMqL,GACzB,GAAIxF,GAAW,GAAIyF,kBAAiB,SAASC,GAC3CF,EAAS/P,KAAKb,KAAMoL,EAAU0F,GAC9B1F,EAAS2F,cACTzQ,KAAKN,MACPoL,GAASZ,QAAQjF,GAAOyL,WAAW,EAAMC,SAAS,KAYtDhD,GAAYjP,UAAYmP,EACxBA,EAAK+C,YAAcjD,EAInBnP,EAAMqS,KAAOlD,EACbnP,EAAMiP,OAASA,EACfjP,EAAMG,IAAIoF,SAAS8J,KAAOA,GAEzBvP,SC5MH,SAAUE,GAsER,QAASqC,GAAenC,GACtB,MAAOA,GAAU0D,UAnEnB,GAII0O,IAJMvS,OAAO2H,aAIW,WACxB6K,EAAyB,aAEzBC,GACFF,sBAAuBA,EAmBvBG,wBAAyB,WAEvB,GAAIzS,GAAQkB,KAAKwR,qBACjB,IAAI1S,IAAUkB,KAAKyR,qBAAqB3S,EAAOuS,GAAyB,CAGtE,IADA,GAAI/O,GAAQnB,EAAenB,MAAO0R,EAAU,GACrCpP,GAASA,EAAMiN,SACpBmC,GAAWpP,EAAMiN,QAAQoC,gBAAgBN,GACzC/O,EAAQnB,EAAemB,EAEzB,IAAIoP,EAAS,CACX,GAAIE,GAAQ5R,KAAKuP,QAAQsC,oBAAoBH,EACzCL,EAGJzS,SAAQkT,kBAAkBF,EAAO9S,MAIvC0S,oBAAqB,WACnB,GAAI3S,OAAOkT,kBACT,MAAOC,MAAK5Q,SAAS6Q,KAIrB,KADA,GAAI5S,GAAIW,KACDX,EAAE2M,YACP3M,EAAIA,EAAE2M,UAER,OAAO3M,KAAM+B,SAAWA,SAAS6Q,KAAO5S,GAG5CoS,qBAAsB,SAAS3S,EAAOoT,GACpC,GAAIC,GAAOf,EAAwB,IAAMpR,KAAK8G,UAAY,IAAMoL,CAChE,OAAOpT,GAAM8Q,cAAc,SAAWuC,EAAO,MAYjDrT,GAAMG,IAAIoF,SAASiN,OAASA,GAE3B1S,SC9EH,SAAUE,GAUR,QAASyQ,GAAQhN,EAAMvD,GACrB,GAAIoT,EAAuB7P,GACzB,KAAM,sDAAwDA,CAGhE8P,GAAkB9P,EAAMvD,GAExBsT,EAAgB/P,GAKlB,QAASgQ,GAAoBhQ,EAAMiQ,GACjCC,EAAclQ,GAAQiQ,EAKxB,QAASF,GAAgB/P,GACnBkQ,EAAclQ,KAChBkQ,EAAclQ,GAAMmQ,0BACbD,GAAclQ,IAgBzB,QAAS8P,GAAkB9P,EAAMvD,GAC/B,MAAO2T,GAAiBpQ,GAAQvD,MAGlC,QAASoT,GAAuB7P,GAC9B,MAAOoQ,GAAiBpQ,GAhD1B,GAAIxD,GAASD,EAAMC,OAsBf0T,GArBM3T,EAAMG,QAwCZ0T,IAYJ7T,GAAMsT,uBAAyBA,EAC/BtT,EAAMyT,oBAAsBA,EAO5B1T,OAAOD,QAAU2Q,EAKjBxQ,EAAOH,QAASE,EAOhB,IAAI8T,GAAehO,SAASiO,qBAC5B,IAAID,EACF,IAAK,GAAgC7P,GAA5BH,EAAE,EAAGC,EAAE+P,EAAa9P,OAAcD,EAAFD,IAASG,EAAE6P,EAAahQ,IAAKA,IACpE2M,EAAQ7N,MAAM,KAAMqB,IAIvBnE,SCnFH,SAAUE,GAEV,GAAI0I,IACFsL,oBAAqB,SAASvN,GAC5BX,SAASmO,YAAYC,WAAWzN,IAElC0N,kBAAmB,WAEjB,GAAIC,GAAYlT,KAAKyQ,aAAa,cAAgB,GAC9ChD,EAAO,GAAI0F,KAAID,EAAWlT,KAAKuO,cAAc6E,QACjDpT,MAAKhB,UAAUqU,YAAc,SAASC,EAASnF,GAC7C,GAAIoF,GAAI,GAAIJ,KAAIG,EAASnF,GAAQV,EACjC,OAAO8F,GAAEC,OAMf1U,GAAMG,IAAImF,YAAYoD,KAAOA,GAE1B5I,SCrBH,SAAUE,GA+KR,QAAS2U,GAAmBC,EAAOC,GACjC,GAAIH,GAAO,GAAIL,KAAIO,EAAMjD,aAAa,QAASkD,GAASH,IACxD,OAAO,YAAeA,EAAO,KAG/B,QAAS1B,GAAkBF,EAAO9S,GAChC,GAAI8S,EAAO,CAMT,GAAIgC,GAAQC,EAAmBjC,EAAMkC,aACjCC,EAAOnC,EAAMnB,aAAaW,EAC1B2C,IACFH,EAAMxL,aAAagJ,EAAuB2C,GAE5CjV,EAAMkR,YAAY4D,IAItB,QAASC,GAAmBnC,EAAS5S,GACnCA,EAAQA,GAASsC,SACjBtC,EAAQA,EAAMuC,cAAgBvC,EAAQA,EAAMyP,aAC5C,IAAIqD,GAAQ9S,EAAMuC,cAAc,QAEhC,OADAuQ,GAAMkC,YAAcpC,EACbE,EAGT,QAASoC,GAAiBN,GACxB,MAAQA,IAASA,EAAMO,YAAe,GAGxC,QAASC,GAAgB3O,EAAM4O,GAC7B,MAAIC,GACKA,EAAQvT,KAAK0E,EAAM4O,GAD5B,OA7MF,GACIlV,IADMJ,OAAO2H,aACP1H,EAAMG,IAAIoF,SAASiN,QACzBF,EAAwBnS,EAAImS,sBAI5BiD,EAAiB,QACjBC,EAAuB,UACvBC,EAAiB,uBACjBC,EAAqB,SACrBC,EAAa,gBAEbnD,GAEFoD,WAAY,SAAS9U,GACnB,GAAI+U,GAAU3U,KAAK4U,iBACfD,IACF3U,KAAK6U,sBAAsBF,EAE7B,IAAIrD,GAAStR,KAAK8U,mBAAmBH,EACjCrD,GAAOxO,OACT8B,SAASmQ,cAAcL,WAAWpD,EAAQ1R,GACjCA,GACTA,KAGJiV,sBAAuB,SAASpH,GAE9B,IAAK,GAAsBuH,GAAGC,EAD1BC,EAAKzH,EAAK6C,iBAAiBiE,GACtB3R,EAAE,EAAGC,EAAEqS,EAAGpS,OAAiBD,EAAFD,IAASoS,EAAEE,EAAGtS,IAAKA,IAAK,CACxDqS,EAAIpB,EAAmBJ,EAAmBuB,EAAGhV,KAAKuO,cAAc6E,SAC5DpT,KAAKuO,cACT,IAAIzP,GAAQkW,EAAEvE,aAAagE,EACvB3V,IACFmW,EAAE7M,aAAaqM,EAAY3V,GAE7BkW,EAAEhJ,WAAWmJ,aAAaF,EAAGD,KAGjCF,mBAAoB,SAASrH,GAC3B,GAAI2H,KACJ,IAAI3H,EAEF,IAAK,GAAsBuH,GADvBE,EAAKzH,EAAK6C,iBAAiB+D,GACtBzR,EAAE,EAAGC,EAAEqS,EAAGpS,OAAcD,EAAFD,IAASoS,EAAEE,EAAGtS,IAAKA,IAC5CoS,EAAElB,YAAYlL,MAAM0L,IACtBc,EAAUC,KAAKL,EAIrB,OAAOI,IAeTE,cAAe,WACbtV,KAAKuV,cACLvV,KAAKwV,cACLxV,KAAKyV,qBACLzV,KAAK0V,uBAKPH,YAAa,WACXvV,KAAK2V,OAAS3V,KAAK4V,UAAUrB,GAC7BvU,KAAK2V,OAAOvW,QAAQ,SAAS4V,GACvBA,EAAEhJ,YACJgJ,EAAEhJ,WAAW6J,YAAYb,MAI/BQ,YAAa,WACXxV,KAAKsR,OAAStR,KAAK4V,UAAUvB,EAAiB,IAAMI,EAAa,KACjEzU,KAAKsR,OAAOlS,QAAQ,SAAS4V,GACvBA,EAAEhJ,YACJgJ,EAAEhJ,WAAW6J,YAAYb,MAa/BS,mBAAoB,WAClB,GAAIE,GAAS3V,KAAK2V,OAAOG,OAAO,SAASd,GACvC,OAAQA,EAAE7M,aAAasM,KAErBE,EAAU3U,KAAK4U,iBACnB,IAAID,EAAS,CACX,GAAIjD,GAAU,EAId,IAHAiE,EAAOvW,QAAQ,SAASsU,GACtBhC,GAAWsC,EAAiBN,GAAS,OAEnChC,EAAS,CACX,GAAIE,GAAQiC,EAAmBnC,EAAS1R,KAAKuO,cAC7CoG,GAAQoB,aAAanE,EAAO+C,EAAQnI,eAI1CoJ,UAAW,SAASI,EAAUC,GAC5B,GAAIC,GAAQlW,KAAKsQ,iBAAiB0F,GAAUG,QACxCxB,EAAU3U,KAAK4U,iBACnB,IAAID,EAAS,CACX,GAAIyB,GAAgBzB,EAAQrE,iBAAiB0F,GAAUG,OACvDD,GAAQA,EAAMG,OAAOD,GAEvB,MAAOH,GAAUC,EAAMJ,OAAOG,GAAWC,GAE3CtB,gBAAiB,WACf,GAAI9H,GAAW9M,KAAK4P,cAAc,WAClC,OAAO9C,IAAY8H,gBAAgB9H,IAWrC4I,oBAAqB,WACnB,GAAI9D,GAAQ5R,KAAKsW,cAAc9B,EAC/B1C,GAAkBF,EAAOxQ,SAAS6Q,OAEpCN,gBAAiB,SAAS4E,GACxB,GAAI7E,GAAU,GAEVsE,EAAW,IAAMvB,EAAa,IAAM8B,EAAkB,IACtDN,EAAU,SAASjB,GACrB,MAAOd,GAAgBc,EAAGgB,IAExBL,EAAS3V,KAAK2V,OAAOG,OAAOG,EAChCN,GAAOvW,QAAQ,SAASsU,GACtBhC,GAAWsC,EAAiBN,GAAS,QAGvC,IAAIpC,GAAStR,KAAKsR,OAAOwE,OAAOG,EAIhC,OAHA3E,GAAOlS,QAAQ,SAASwS,GACtBF,GAAWE,EAAMkC,YAAc,SAE1BpC,GAET4E,cAAe,SAASC,GACtB,GAAI7E,GAAU1R,KAAK2R,gBAAgB4E,EACnC,OAAOvW,MAAK6R,oBAAoBH,EAAS6E,IAE3C1E,oBAAqB,SAASH,EAAS6E,GACrC,GAAI7E,EAAS,CACX,GAAIE,GAAQiC,EAAmBnC,EAG/B,OAFAE,GAAMxJ,aAAagJ,EAAuBpR,KAAKyQ,aAAa,QACxD,IAAM8F,GACH3E,KA2CTnP,EAAI1B,YAAY/B,UAChBoV,EAAU3R,EAAE2R,SAAW3R,EAAEyR,iBAAmBzR,EAAE+T,uBAC3C/T,EAAEgU,kBAIT3X,GAAMG,IAAImF,YAAYkN,OAASA,EAC/BxS,EAAMgT,kBAAoBA,GAEzBlT,SC7NH,SAAUE,GAIR,GACIG,IADMJ,OAAO2H,aACP1H,EAAMG,IAAIoF,SAASqC,QACzBD,EAAexH,EAAIwH,aAGnBC,GACFgQ,gBAAiB,WAEf,GAAIC,GAAY3W,KAAKhB,UAAU4H,cAE/B5G,MAAK4W,sBAAsBD,IAE7BC,sBAAuB,SAASD,GAE9B,IAAK,GAASpO,GAAL3F,EAAE,EAAM2F,EAAEvI,KAAK8H,WAAWlF,GAAIA,IAEjC5C,KAAK6W,eAAetO,EAAEhG,QAExBoU,EAAU3W,KAAK8W,kBAAkBvO,EAAEhG,OAASgG,EAAE9I,MAAMwE,QAAQ,KAAM,IAC7DA,QAAQ,KAAM,IAAI8S,SAK7BF,eAAgB,SAAUxX,GACxB,MAAOA,IAAe,MAATA,EAAE,IAAyB,MAATA,EAAE,IAAyB,MAATA,EAAE,IAErDyX,kBAAmB,SAASzX,GAC1B,MAAOA,GAAE2X,MAAMC,KAIfA,EAAexQ,EAAa3D,MAGhChE,GAAMG,IAAImF,YAAYsC,OAASA,GAE9B9H,SC1CH,SAAUE,GAIR,GAAIgL,IACFoN,eAAgB,SAASlY,GAEvB,GAAiCwM,GAA7BhB,EAAUxL,EAAUwL,OACxB,KAAK,GAAInL,KAAKL,GACQ,YAAhBK,EAAE2X,MAAM,MACLxM,IACHA,EAAYxL,EAAUwL,YAExBgB,EAAWnM,EAAE2X,MAAM,EAAG,IACtBxM,EAAQgB,GAAYhB,EAAQgB,IAAanM,IAI/C8X,iBAAkB,SAASnY,GAEzB,GAAImL,GAAInL,EAAUwL,OAClB,IAAIL,EAAG,CACL,GAAIiN,KACJ,KAAK,GAAI/X,KAAK8K,GAEZ,IAAK,GAASkN,GADVC,EAAQjY,EAAEkY,MAAM,KACX3U,EAAE,EAAOyU,EAAGC,EAAM1U,GAAIA,IAC7BwU,EAASC,GAAMlN,EAAE9K,EAGrBL,GAAUwL,QAAU4M,IAGxBI,qBAAsB,SAASxY,GAC7B,GAAIA,EAAUwL,QAAS,CAErB,GAAIjC,GAAIvJ,EAAUgL,gBAClB,KAAK,GAAI3K,KAAKL,GAAUwL,QAEtB,IAAK,GAAS6M,GADVC,EAAQjY,EAAEkY,MAAM,KACX3U,EAAE,EAAOyU,EAAGC,EAAM1U,GAAIA,IAC7B2F,EAAE8M,KAAKgC,GAKb,GAAIrY,EAAUsF,QAAS,CAErB,GAAIiE,GAAIvJ,EAAUkL,gBAClB,KAAK,GAAI7K,KAAKL,GAAUsF,QACtBiE,EAAE8M,KAAKhW,KAIboY,kBAAmB,SAASzY,EAAWmP,GAErC,GAAI7J,GAAUtF,EAAUsF,OACpBA,KAEFtE,KAAK0X,kBAAkBpT,EAAStF,EAAWmP,GAE3CnP,EAAUsJ,WAAatI,KAAK2X,aAAarT,KAG7CoT,kBAAmB,SAAS5N,EAAY9K,EAAWmP,GAEjD,IAAK,GAAI9O,KAAKyK,GACSpE,SAAjB1G,EAAUK,IAAgCqG,SAAZyI,EAAK9O,KACrCL,EAAUK,GAAKyK,EAAWzK,KAIhCsY,aAAc,SAAS7N,GACrB,GAAI8N,KACJ,KAAK,GAAIvY,KAAKyK,GACZ8N,EAAIvY,EAAEwY,eAAiBxY,CAEzB,OAAOuY,IAMX9Y,GAAMG,IAAImF,YAAY0F,WAAaA,GAElClL,SCnFH,SAAUE,GAIR,GAAIgZ,GAAuB,aACvBC,EAAmB,OAInBjQ,GACFkQ,yBAA0B,SAAShZ,GAEjCgB,KAAKiY,cAAcjZ,EAAW,aAE9BgB,KAAKiY,cAAcjZ,EAAW,wBAEhCkZ,kBAAmB,SAASlZ,EAAWmP,GAErC,GAAIrG,GAAa9H,KAAKyQ,aAAaqH,EACnC,IAAIhQ,EAMF,IAAK,GAAyBzI,GAJ1BiF,EAAUtF,EAAUsF,UAAYtF,EAAUsF,YAE1CgT,EAAQxP,EAAWyP,MAAMQ,GAEpBnV,EAAE,EAAGC,EAAEyU,EAAMxU,OAAaD,EAAFD,EAAKA,IAEpCvD,EAAIiY,EAAM1U,GAAGmU,OAET1X,GAAoBqG,SAAfpB,EAAQjF,IAAgCqG,SAAZyI,EAAK9O,KACxCiF,EAAQjF,GAAK,OAMrB8Y,6BAA8B,WAK5B,IAAK,GAAsB5P,GAHvB6P,EAAWpY,KAAKhB,UAAUiJ,oBAE1BD,EAAKhI,KAAK8H,WACLlF,EAAE,EAAGC,EAAEmF,EAAGlF,OAAcD,EAAFD,IAAS2F,EAAEP,EAAGpF,IAAKA,IAC5C5C,KAAKqY,oBAAoB9P,EAAEhG,QAC7B6V,EAAS7P,EAAEhG,MAAQgG,EAAE9I,QAI3B4Y,oBAAqB,SAAS9V,GAC5B,OAAQvC,KAAKsY,UAAU/V,IAA6B,QAApBA,EAAKyU,MAAM,EAAE,IAG/CsB,WACE/V,KAAM,EACNgW,UAAW,EACXrH,YAAa,EACbsH,SAAU,EACVC,UAAW,EACXC,gBAAiB,GAKrB5Q,GAAWwQ,UAAUR,GAAwB,EAI7ChZ,EAAMG,IAAImF,YAAY0D,WAAaA,GAElClJ,SCpEH,SAAUE,GAiOR,QAAS6Z,GAAyB3Z,GAChC,IAAKE,OAAOwD,UAAW,CACrB,GAAIkW,GAAW1Z,OAAOiC,eAAenC,EACrCA,GAAU0D,UAAYkW,EAClB7K,EAAO6K,KACTA,EAASlW,UAAYxD,OAAOiC,eAAeyX,KAlOjD,GAAI3Z,GAAMH,EAAMG,IACZ8O,EAASjP,EAAMiP,OACfhP,EAASD,EAAMC,OAIfC,GAEFgC,SAAU,SAASuB,EAAMsW,GAEvB7Y,KAAK8Y,eAAevW,EAAMsW,GAE1B7Y,KAAKqS,kBAAkB9P,EAAMsW,GAE7B7Y,KAAK+Y,sBAGPD,eAAgB,SAASvW,EAAMsW,GAE7B,GAAIG,GAAYla,EAAMsT,uBAAuB7P,GAEzC4L,EAAOnO,KAAKiZ,sBAAsBJ,EAEtC7Y,MAAKkZ,sBAAsBF,EAAW7K,GAEtCnO,KAAKhB,UAAYgB,KAAKmZ,gBAAgBH,EAAW7K,GAEjDnO,KAAKoZ,qBAAqB7W,EAAMsW,IAGlCK,sBAAuB,SAASla,EAAWmP,GAGzCnP,EAAUuQ,QAAUvP,KAEpBA,KAAKkY,kBAAkBlZ,EAAWmP,GAElCnO,KAAKyX,kBAAkBzY,EAAWmP,GAElCnO,KAAKkX,eAAelY,GAEpBgB,KAAKmX,iBAAiBnY,IAGxBma,gBAAiB,SAASna,EAAWmP,GAEnCnO,KAAKqZ,gBAAgBra,EAAWmP,EAEhC,IAAImL,GAAUtZ,KAAKuZ,YAAYva,EAAWmP,EAG1C,OADAwK,GAAyBW,GAClBA,GAGTD,gBAAiB,SAASra,EAAWmP,GAEnCnO,KAAKiY,cAAc,UAAWjZ,EAAWmP,GAEzCnO,KAAKiY,cAAc,UAAWjZ,EAAWmP,GAEzCnO,KAAKiY,cAAc,aAAcjZ,EAAWmP,GAE5CnO,KAAKiY,cAAc,sBAAuBjZ,EAAWmP,GAErDnO,KAAKiY,cAAc,iBAAkBjZ,EAAWmP,IAIlDiL,qBAAsB,SAAS7W,EAAMiX,GAEnCxZ,KAAKwX,qBAAqBxX,KAAKhB,WAE/BgB,KAAKsV,gBAELtV,KAAK8S,oBAAoB9S,MAEzBA,KAAKmY,+BAELnY,KAAK0W,kBAKL1W,KAAKiT,oBAEDpU,OAAOkT,mBACTnN,SAAS6U,UAAUC,YAAY1Z,KAAK4U,kBAAmBrS,EAAMiX,GAG3DxZ,KAAKhB,UAAU2a,kBACjB3Z,KAAKhB,UAAU2a,iBAAiB3Z,OAMpC+Y,mBAAoB,WAClB,GAAIa,GAAS5Z,KAAKyQ,aAAa,cAC3BmJ,KACF/a,OAAO+a,GAAU5Z,KAAK6Z,OAK1BZ,sBAAuB,SAASa,GAC9B,GAAI9a,GAAYgB,KAAK+Z,kBAAkBD,EACvC,KAAK9a,EAAW,CAEd,GAAIA,GAAY+B,YAAYG,mBAAmB4Y,EAE/C9a,GAAYgB,KAAKga,cAAchb,GAE/Bib,EAAcH,GAAU9a,EAE1B,MAAOA,IAGT+a,kBAAmB,SAASxX,GAC1B,MAAO0X,GAAc1X,IAIvByX,cAAe,SAAShb,GACtB,GAAIA,EAAUiP,YACZ,MAAOjP,EAET,IAAIkb,GAAWhb,OAAOib,OAAOnb,EAkB7B,OAfAC,GAAIqF,QAAQrF,EAAIoF,SAAU6V,GAa1Bla,KAAKoa,YAAYF,EAAUlb,EAAWC,EAAIoF,SAASuI,IAAK,QAEjDsN,GAGTE,YAAa,SAASF,EAAUlb,EAAWC,EAAKsD,GAC9C,GAAIX,GAAS,SAAS8C,GACpB,MAAO1F,GAAUuD,GAAMb,MAAM1B,KAAM0E,GAErCwV,GAAS3X,GAAQ,WAEf,MADAvC,MAAKqN,WAAazL,EACX3C,EAAIsD,GAAMb,MAAM1B,KAAM2B,aAKjCsW,cAAe,SAAS1V,EAAMvD,EAAWmP,GAEvC,GAAIkM,GAASrb,EAAUuD,MAEvBvD,GAAUuD,GAAQvC,KAAKuZ,YAAYc,EAAQlM,EAAK5L,KAIlD8P,kBAAmB,SAAS9P,EAAMiX,GAChC,GAAIc,IACFtb,UAAWgB,KAAKhB,WAGdub,EAAgBva,KAAKwa,kBAAkBhB,EACvCe,KACFD,EAAK/B,QAAUgC,GAGjBxZ,YAAYC,SAASuB,EAAMvC,KAAKhB,WAEhCgB,KAAK6Z,KAAOzY,SAASqZ,gBAAgBlY,EAAM+X,GAE3Cta,KAAKhB,UAAUkS,YAAclR,KAAK6Z,MAGpCW,kBAAmB,SAASjY,GAC1B,GAAIA,GAAQA,EAAKmY,QAAQ,KAAO,EAC9B,MAAOnY,EAEP,IAAIE,GAAIzC,KAAK+Z,kBAAkBxX,EAC/B,OAAIE,GAAE8M,QACGvP,KAAKwa,kBAAkB/X,EAAE8M,QAAQgJ,SAD1C,SASF0B,IAIFjb,GAAUua,YADRra,OAAOwD,UACe,SAASqB,EAAQ4W,GAIvC,MAHI5W,IAAU4W,GAAa5W,IAAW4W,IACpC5W,EAAOrB,UAAYiY,GAEd5W,GAGe,SAASA,EAAQ4W,GACvC,GAAI5W,GAAU4W,GAAa5W,IAAW4W,EAAW,CAC/C,GAAIrB,GAAUpa,OAAOib,OAAOQ,EAC5B5W,GAAShF,EAAOua,EAASvV,GAE3B,MAAOA,IAoBX9E,EAAImF,YAAYpF,UAAYA,GAE3BJ,SC/OH,SAAUE,GAkGR,QAAS8b,GAAgBrL,GACvB,MAAOnO,UAASyZ,SAAStL,GAAWuL,EAAYC,EAGlD,QAASC,KACP,MAAOD,GAAYjY,OAASiY,EAAY,GAAKD,EAAU,GAKzD,QAASG,GAAiBrb,GACxBsb,EAAMC,aAAc,EACpBC,YAAYC,iBAAiB,WAC3BH,EAAMI,iBAAiB1b,GACvBsb,EAAMC,aAAc,EACpBD,EAAMK,UA/GV,GAAIL,IAEFrb,KAAM,SAAS0P,GAKb,MAJ8B,KAA1BvP,KAAK0a,QAAQnL,IACoB,KAAhCiM,EAAWd,QAAQnL,IACtBvP,KAAKmG,IAAIoJ,GAEuB,IAA1BvP,KAAK0a,QAAQnL,IAEvBpJ,IAAK,SAASoJ,GAEZqL,EAAgBrL,GAAS8F,KAAK9F,IAEhCmL,QAAS,SAASnL,GAChB,GAAI3M,GAAIgY,EAAgBrL,GAASmL,QAAQnL,EAKzC,OAJI3M,IAAK,GAAKxB,SAASyZ,SAAStL,KAC9B3M,GAAMwY,YAAYK,WAAaL,YAAY/M,MAAS0M,EAAYjY,OAC5D,KAECF,GAGT5B,SAAU,SAASuO,GACjB,GAAImM,GAAU1b,KAAKkG,OAAOqJ,EACtBmM,KACFF,EAAWnG,KAAKqG,GAChB1b,KAAKub,UAGTrV,OAAQ,SAASqJ,GACf,GAAI3M,GAAI5C,KAAK0a,QAAQnL,EACrB,IAAU,IAAN3M,EAIJ,MAAOgY,GAAgBrL,GAASoM,SAElCJ,MAAO,WAEL,GAAIhM,GAAUvP,KAAK4b,aAInB,OAHIrM,IACFA,EAAQmD,oBAEN1S,KAAK6b,YACP7b,KAAK6E,SACE,GAFT,QAKF+W,YAAa,WACX,MAAOZ,MAETa,SAAU,WACR,OAAQ7b,KAAKmb,aAAenb,KAAK8b,WAEnCA,QAAS,WACP,OAAQf,EAAYjY,SAAWgY,EAAUhY,QAE3C+B,MAAO,WAOLkX,eAAe1N,OAAQ,CAEvB,KADA,GAAIkB,GACGiM,EAAW1Y,QAChByM,EAAUiM,EAAWG,QACrBpM,EAAQyM,WAEVD,gBAAeE,oBAAoB7a,UACnC2a,eAAe1N,OAAQ,EACvBrO,KAAKkc,uBAEPA,oBAAqB,WACnB,GAAIC,EAEF,IADA,GAAI/Z,GACG+Z,EAAerZ,SACpBV,EAAK+Z,EAAeR,YAK1BL,iBAAkB,SAAS1b,GACrBA,GACFuc,EAAe9G,KAAKzV,IAGxBub,aAAa,GAGXJ,KACAD,KACAU,KACAW,IAsBJrd,GAAMoc,MAAQA,EACdpc,EAAMmc,iBAAmBA,GACxBrc,SCxHH,SAAUE,GAIR,QAASsd,GAAeC,EAAmBzc,GACrCyc,GACFjb,SAAS6Q,KAAKjC,YAAYqM,GAC1BpB,EAAiBrb,IACRA,GACTA,IAIJ,QAAS0c,GAAWC,EAAM3c,GACxB,GAAI2c,GAAQA,EAAKzZ,OAAQ,CAErB,IAAK,GAAwB0Z,GAAKC,EAD9BC,EAAOtb,SAASub,yBACX/Z,EAAE,EAAGC,EAAE0Z,EAAKzZ,OAAsBD,EAAFD,IAAS4Z,EAAID,EAAK3Z,IAAKA,IAC9D6Z,EAAOrb,SAASC,cAAc,QAC9Bob,EAAKG,IAAM,SACXH,EAAKjJ,KAAOgJ,EACZE,EAAK1M,YAAYyM,EAEnBL,GAAeM,EAAM9c,OACdA,IACTA,IAtBJ,GAAIqb,GAAmBnc,EAAMmc,gBA2B7Bnc,GAAM+d,OAASP,EACfxd,EAAMsd,eAAiBA,GAEtBxd,SChCH,SAAUE,GAsHR,QAASge,GAAava,GACpB,MAAOwa,SAAQhc,YAAYG,mBAAmBqB,IAGhD,QAASya,GAAYza,GACnB,MAAQA,IAAQA,EAAKmY,QAAQ,MAAQ,EAvHvC,GAAI3b,GAASD,EAAMC,OACfE,EAAMH,EAAMG,IACZic,EAAQpc,EAAMoc,MACdD,EAAmBnc,EAAMmc,iBACzB7I,EAAyBtT,EAAMsT,uBAC/BG,EAAsBzT,EAAMyT,oBAI5BvT,EAAYD,EAAOG,OAAOib,OAAOpZ,YAAY/B,YAE/CsP,gBAAiB,WACXtO,KAAKyQ,aAAa,SACpBzQ,KAAKid,QAITA,KAAM,WAEJjd,KAAKuC,KAAOvC,KAAKyQ,aAAa,QAC9BzQ,KAAKuY,QAAUvY,KAAKyQ,aAAa,WAEjCzQ,KAAKkd,gBAELld,KAAK0S,qBAGPA,kBAAmB,WACd1S,KAAKmd,YACJnd,KAAKuS,oBAAoBvS,KAAKuC,OAC9BvC,KAAKod,mBACLpd,KAAKqd,uBAGTnC,EAAMla,SAAShB,OAMjBgc,UAAW,WAILgB,EAAYhd,KAAKuY,WAAauE,EAAa9c,KAAKuY,UAClDtW,QAAQC,KAAK,sGACuClC,KAAKuC,KACrDvC,KAAKuY,SAEXvY,KAAKgB,SAAShB,KAAKuC,KAAMvC,KAAKuY,SAC9BvY,KAAKmd,YAAa,GAIpB5K,oBAAqB,SAAShQ,GAC5B,MAAK6P,GAAuB7P,GAA5B,QAEEgQ,EAAoBhQ,EAAMvC,MAE1BA,KAAKsd,eAAe/a,IAEb,IAIX+a,eAAgB,SAAS/a,GAEvB,GAAIvC,KAAKmI,aAAa,cAAgBnI,KAAKwY,SAQzC,GAPAxY,KAAKwY,UAAW,EAOZ3Z,OAAOkd,iBAAmBA,eAAeN,UAC3C7c,QAAQ2D,OACH,CACL,GAAIgb,GAASnc,SAASC,cAAc,SACpCkc,GAAOzJ,YAAc,YAAevR,EAAO,MAC3CvC,KAAKgQ,YAAYuN,KAKvBF,oBAAqB,WACnB,MAAOrd,MAAKwd,iBAMdJ,gBAAiB,WACf,MAAOlC,GAAMrb,KAAKG,OAGpBkd,cAAe,WACbld,KAAKwd,iBAAkB,EACvBxd,KAAK0U,WAAW,WACd1U,KAAKwd,iBAAkB,EACvBxd,KAAK0S,qBACLpS,KAAKN,SASXf,GAAIqF,QAAQrF,EAAImF,YAAapF,GAc7BF,EAAMsT,uBAAyBA,EAI/B6I,EAAiB,WACf7Z,SAASqc,KAAKxU,gBAAgB,cAC9B7H,SAASuE,cACP,GAAIF,aAAY,iBAAkBJ,SAAS,OAM/CjE,SAASqZ,gBAAgB,mBAAoBzb,UAAWA,KAEvDJ","sourcesContent":["/*\n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\n */\nPolymer = {};\n","/*\n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\n */\n\n// TODO(sorvell): this ensures Polymer is an object and not a function\n// Platform is currently defining it as a function to allow for async loading\n// of polymer; once we refine the loading process this likely goes away.\nif (typeof window.Polymer === 'function') {\n  Polymer = {};\n}\n\n","/*\n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\n */\n(function(scope) {\n\n  // copy own properties from 'api' to 'prototype, with name hinting for 'super'\n  function extend(prototype, api) {\n    if (prototype && api) {\n      // use only own properties of 'api'\n      Object.getOwnPropertyNames(api).forEach(function(n) {\n        // acquire property descriptor\n        var pd = Object.getOwnPropertyDescriptor(api, n);\n        if (pd) {\n          // clone property via descriptor\n          Object.defineProperty(prototype, n, pd);\n          // cache name-of-method for 'super' engine\n          if (typeof pd.value == 'function') {\n            // hint the 'super' engine\n            pd.value.nom = n;\n          }\n        }\n      });\n    }\n    return prototype;\n  }\n  \n  // exports\n\n  scope.extend = extend;\n\n})(Polymer);\n","/* \n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\n */\n\n(function(scope) {\n  \n  // usage\n  \n  // invoke cb.call(this) in 100ms, unless the job is re-registered,\n  // which resets the timer\n  // \n  // this.myJob = this.job(this.myJob, cb, 100)\n  //\n  // returns a job handle which can be used to re-register a job\n\n  var Job = function(inContext) {\n    this.context = inContext;\n    this.boundComplete = this.complete.bind(this)\n  };\n  Job.prototype = {\n    go: function(callback, wait) {\n      this.callback = callback;\n      var h;\n      if (!wait) {\n        h = requestAnimationFrame(this.boundComplete);\n        this.handle = function() {\n          cancelAnimationFrame(h);\n        }\n      } else {\n        h = setTimeout(this.boundComplete, wait);\n        this.handle = function() {\n          clearTimeout(h);\n        }\n      }\n    },\n    stop: function() {\n      if (this.handle) {\n        this.handle();\n        this.handle = null;\n      }\n    },\n    complete: function() {\n      if (this.handle) {\n        this.stop();\n        this.callback.call(this.context);\n      }\n    }\n  };\n  \n  function job(job, callback, wait) {\n    if (job) {\n      job.stop();\n    } else {\n      job = new Job(this);\n    }\n    job.go(callback, wait);\n    return job;\n  }\n  \n  // exports \n\n  scope.job = job;\n  \n})(Polymer);\n","/*\n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\n */\n(function(scope) {\n\n  var registry = {};\n\n  HTMLElement.register = function(tag, prototype) {\n    registry[tag] = prototype;\n  }\n\n  // get prototype mapped to node <tag>\n  HTMLElement.getPrototypeForTag = function(tag) {\n    var prototype = !tag ? HTMLElement.prototype : registry[tag];\n    // TODO(sjmiles): creating <tag> is likely to have wasteful side-effects\n    return prototype || Object.getPrototypeOf(document.createElement(tag));\n  };\n\n  // we have to flag propagation stoppage for the event dispatcher\n  var originalStopPropagation = Event.prototype.stopPropagation;\n  Event.prototype.stopPropagation = function() {\n    this.cancelBubble = true;\n    originalStopPropagation.apply(this, arguments);\n  };\n  \n  // TODO(sorvell): remove when we're sure imports does not need\n  // to load stylesheets\n  /*\n  HTMLImports.importer.preloadSelectors += \n      ', polymer-element link[rel=stylesheet]';\n  */\n})(Polymer);\n","/*\n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\n */\n (function(scope) {\n    // super\n\n    // `arrayOfArgs` is an optional array of args like one might pass\n    // to `Function.apply`\n\n    // TODO(sjmiles):\n    //    $super must be installed on an instance or prototype chain\n    //    as `super`, and invoked via `this`, e.g.\n    //      `this.super();`\n\n    //    will not work if function objects are not unique, for example,\n    //    when using mixins.\n    //    The memoization strategy assumes each function exists on only one \n    //    prototype chain i.e. we use the function object for memoizing)\n    //    perhaps we can bookkeep on the prototype itself instead\n    function $super(arrayOfArgs) {\n      // since we are thunking a method call, performance is important here: \n      // memoize all lookups, once memoized the fast path calls no other \n      // functions\n      //\n      // find the caller (cannot be `strict` because of 'caller')\n      var caller = $super.caller;\n      // memoized 'name of method' \n      var nom = caller.nom;\n      // memoized next implementation prototype\n      var _super = caller._super;\n      if (!_super) {\n        if (!nom) {\n          nom = caller.nom = nameInThis.call(this, caller);\n        }\n        if (!nom) {\n          console.warn('called super() on a method not installed declaratively (has no .nom property)');\n        }\n        // super prototype is either cached or we have to find it\n        // by searching __proto__ (at the 'top')\n        _super = memoizeSuper(caller, nom, getPrototypeOf(this));\n      }\n      if (!_super) {\n        // if _super is falsey, there is no super implementation\n        //console.warn('called $super(' + nom + ') where there is no super implementation');\n      } else {\n        // our super function\n        var fn = _super[nom];\n        // memoize information so 'fn' can call 'super'\n        if (!fn._super) {\n          memoizeSuper(fn, nom, _super);\n        }\n        // invoke the inherited method\n        // if 'fn' is not function valued, this will throw\n        return fn.apply(this, arrayOfArgs || []);\n      }\n    }\n\n    function nextSuper(proto, name, caller) {\n      // look for an inherited prototype that implements name\n      while (proto) {\n        if ((proto[name] !== caller) && proto[name]) {\n          return proto;\n        }\n        proto = getPrototypeOf(proto);\n      }\n    }\n\n    function memoizeSuper(method, name, proto) {\n      // find and cache next prototype containing `name`\n      // we need the prototype so we can do another lookup\n      // from here\n      method._super = nextSuper(proto, name, method);\n      if (method._super) {\n        // _super is a prototype, the actual method is _super[name]\n        // tag super method with it's name for further lookups\n        method._super[name].nom = name;\n      }\n      return method._super;\n    }\n\n    function nameInThis(value) {\n      var p = this.__proto__;\n      while (p && p !== HTMLElement.prototype) {\n        // TODO(sjmiles): getOwnPropertyNames is absurdly expensive\n        var n$ = Object.getOwnPropertyNames(p);\n        for (var i=0, l=n$.length, n; i<l && (n=n$[i]); i++) {\n          var d = Object.getOwnPropertyDescriptor(p, n);\n          if (typeof d.value === 'function' && d.value === value) {\n            return n;\n          }\n        }\n        p = p.__proto__;\n      }\n    }\n\n    // NOTE: In some platforms (IE10) the prototype chain is faked via \n    // __proto__. Therefore, always get prototype via __proto__ instead of\n    // the more standard Object.getPrototypeOf.\n    function getPrototypeOf(prototype) {\n      return prototype.__proto__;\n    }\n\n    // utility function to precompute name tags for functions\n    // in a (unchained) prototype\n    function hintSuper(prototype) {\n      // tag functions with their prototype name to optimize\n      // super call invocations\n      for (var n in prototype) {\n        var pd = Object.getOwnPropertyDescriptor(prototype, n);\n        if (pd && typeof pd.value === 'function') {\n          pd.value.nom = n;\n        }\n      }\n    }\n\n    // exports\n\n    scope.super = $super;\n\n})(Polymer);\n","/* \n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\n */\n\n(function(scope) {\n\n  var typeHandlers = {\n    string: function(value) {\n      return value;\n    },\n    date: function(value) {\n      return new Date(Date.parse(value) || Date.now());\n    },\n    boolean: function(value) {\n      if (value === '') {\n        return true;\n      }\n      return value === 'false' ? false : !!value;\n    },\n    number: function(value) {\n      var n = parseFloat(value);\n      // hex values like \"0xFFFF\" parseFloat as 0\n      if (n === 0) {\n        n = parseInt(value);\n      }\n      return isNaN(n) ? value : n;\n      // this code disabled because encoded values (like \"0xFFFF\")\n      // do not round trip to their original format\n      //return (String(floatVal) === value) ? floatVal : value;\n    },\n    object: function(value, currentValue) {\n      if (currentValue === null) {\n        return value;\n      }\n      try {\n        // If the string is an object, we can parse is with the JSON library.\n        // include convenience replace for single-quotes. If the author omits\n        // quotes altogether, parse will fail.\n        return JSON.parse(value.replace(/'/g, '\"'));\n      } catch(e) {\n        // The object isn't valid JSON, return the raw value\n        return value;\n      }\n    },\n    // avoid deserialization of functions\n    'function': function(value, currentValue) {\n      return currentValue;\n    }\n  };\n\n  function deserializeValue(value, currentValue) {\n    // attempt to infer type from default value\n    var inferredType = typeof currentValue;\n    // invent 'date' type value for Date\n    if (currentValue instanceof Date) {\n      inferredType = 'date';\n    }\n    // delegate deserialization via type string\n    return typeHandlers[inferredType](value, currentValue);\n  }\n\n  // exports\n\n  scope.deserializeValue = deserializeValue;\n\n})(Polymer);\n","/*\n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\n */\n(function(scope) {\n\n  // imports\n\n  var extend = scope.extend;\n\n  // module\n\n  var api = {};\n\n  api.declaration = {};\n  api.instance = {};\n\n  api.publish = function(apis, prototype) {\n    for (var n in apis) {\n      extend(prototype, apis[n]);\n    }\n  }\n\n  // exports\n\n  scope.api = api;\n\n})(Polymer);\n","/*\n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\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 : 1 / handle;\n    },\n    cancelAsync: function(handle) {\n      if (handle < 1) {\n        cancelAnimationFrame(Math.round(1 / handle));\n      } else {\n        clearTimeout(handle);\n      }\n    },\n    /**\n      * Fire an event.\n      * @method fire\n      * @returns {Object} event\n      * @param {string} type An event name.\n      * @param {any} detail\n      * @param {Node} onNode Target node.\n      */\n    fire: function(type, detail, onNode, bubbles, cancelable) {\n      var node = onNode || this;\n      var detail = detail || {};\n      var event = new CustomEvent(type, {\n        bubbles: (bubbles !== undefined ? bubbles : true), \n        cancelable: (cancelable !== undefined ? cancelable : true), \n        detail: detail\n      });\n      node.dispatchEvent(event);\n      return event;\n    },\n    /**\n      * Fire an event asynchronously.\n      * @method asyncFire\n      * @param {string} type An event name.\n      * @param detail\n      * @param {Node} toNode Target node.\n      */\n    asyncFire: function(/*inType, inDetail*/) {\n      this.async(\"fire\", arguments);\n    },\n    /**\n      * Remove class from old, add class to anew, if they exist\n      * @param classFollows\n      * @param anew A node.\n      * @param old A node\n      * @param className\n      */\n    classFollows: function(anew, old, className) {\n      if (old) {\n        old.classList.remove(className);\n      }\n      if (anew) {\n        anew.classList.add(className);\n      }\n    }\n  };\n\n  // no-operation function for handy stubs\n  var nop = function() {};\n\n  // null-object for handy stubs\n  var nob = {};\n\n  // deprecated\n\n  utils.asyncMethod = utils.async;\n\n  // exports\n\n  scope.api.instance.utils = utils;\n  scope.nop = nop;\n  scope.nob = nob;\n\n})(Polymer);\n","/*\n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\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      // We do, however, leverage the event hookup code in PolymerExpressions\n      // so that we have a common code path for handling declarative events.\n      var self = this, bindable, eventName;\n      for (var n in events) {\n        eventName = EVENT_PREFIX + n;\n        bindable = PolymerExpressions.prepareEventBinding(Path.get(events[n]),\n            eventName, {\n          resolveEventHandler: function(model, path, node) {\n            var fn = path.getValueFrom(self);\n            if (fn) {\n              return fn.bind(self);\n            }\n          }\n        });\n        bindable(this, this, false);\n      }\n    },\n    // call 'method' or function method on 'obj' with 'args', if the method exists\n    dispatchMethod: function(obj, method, args) {\n      if (obj) {\n        log.events && console.group('[%s] dispatch [%s]', obj.localName, method);\n        var fn = typeof method === 'function' ? method : obj[method];\n        if (fn) {\n          fn[args ? 'apply' : 'call'](obj, args);\n        }\n        log.events && console.groupEnd();\n        Platform.flush();\n      }\n    }\n  };\n\n  // exports\n\n  scope.api.instance.events = events;\n\n})(Polymer);\n","/*\r\n * Copyright 2013 The Polymer Authors. All rights reserved.\r\n * Use of this source code is governed by a BSD-style\r\n * license that can be found in the LICENSE file.\r\n */\r\n(function(scope) {\r\n\r\n  // instance api for attributes\r\n\r\n  var attributes = {\r\n    copyInstanceAttributes: function () {\r\n      var a$ = this._instanceAttributes;\r\n      for (var k in a$) {\r\n        if (!this.hasAttribute(k)) {\r\n          this.setAttribute(k, a$[k]);\r\n        }\r\n      }\r\n    },\r\n    // for each attribute on this, deserialize value to property as needed\r\n    takeAttributes: function() {\r\n      // if we have no publish lookup table, we have no attributes to take\r\n      // TODO(sjmiles): ad hoc\r\n      if (this._publishLC) {\r\n        for (var i=0, a$=this.attributes, l=a$.length, a; (a=a$[i]) && i<l; i++) {\r\n          this.attributeToProperty(a.name, a.value);\r\n        }\r\n      }\r\n    },\r\n    // if attribute 'name' is mapped to a property, deserialize\r\n    // 'value' into that property\r\n    attributeToProperty: function(name, value) {\r\n      // try to match this attribute to a property (attributes are\r\n      // all lower-case, so this is case-insensitive search)\r\n      var name = this.propertyForAttribute(name);\r\n      if (name) {\r\n        // filter out 'mustached' values, these are to be\r\n        // replaced with bound-data and are not yet values\r\n        // themselves\r\n        if (value && value.search(scope.bindPattern) >= 0) {\r\n          return;\r\n        }\r\n        // get original value\r\n        var currentValue = this[name];\r\n        // deserialize Boolean or Number values from attribute\r\n        var value = this.deserializeValue(value, currentValue);\r\n        // only act if the value has changed\r\n        if (value !== currentValue) {\r\n          // install new value (has side-effects)\r\n          this[name] = value;\r\n        }\r\n      }\r\n    },\r\n    // return the published property matching name, or undefined\r\n    propertyForAttribute: function(name) {\r\n      var match = this._publishLC && this._publishLC[name];\r\n      //console.log('propertyForAttribute:', name, 'matches', match);\r\n      return match;\r\n    },\r\n    // convert representation of 'stringValue' based on type of 'currentValue'\r\n    deserializeValue: function(stringValue, currentValue) {\r\n      return scope.deserializeValue(stringValue, currentValue);\r\n    },\r\n    serializeValue: function(value, inferredType) {\r\n      if (inferredType === 'boolean') {\r\n        return value ? '' : undefined;\r\n      } else if (inferredType !== 'object' && inferredType !== 'function'\r\n          && value !== undefined) {\r\n        return value;\r\n      }\r\n    },\r\n    reflectPropertyToAttribute: function(name) {\r\n      var inferredType = typeof this[name];\r\n      // try to intelligently serialize property value\r\n      var serializedValue = this.serializeValue(this[name], inferredType);\r\n      // boolean properties must reflect as boolean attributes\r\n      if (serializedValue !== undefined) {\r\n        this.setAttribute(name, serializedValue);\r\n        // TODO(sorvell): we should remove attr for all properties\r\n        // that have undefined serialization; however, we will need to\r\n        // refine the attr reflection system to achieve this; pica, for example,\r\n        // relies on having inferredType object properties not removed as\r\n        // attrs.\r\n      } else if (inferredType === 'boolean') {\r\n        this.removeAttribute(name);\r\n      }\r\n    }\r\n  };\r\n\r\n  // exports\r\n\r\n  scope.api.instance.attributes = attributes;\r\n\r\n})(Polymer);\r\n","/*\n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\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 properties = {\n    observeProperties: function() {\n      var n$ = this._observeNames, pn$ = this._publishNames;\n      if ((n$ && n$.length) || (pn$ && pn$.length)) {\n        var self = this;\n        var o = this._propertyObserver = new CompoundObserver();\n        for (var i=0, l=n$.length, n; (i<l) && (n=n$[i]); i++) {\n          o.addPath(this, n);\n          // observer array properties\n          var pd = Object.getOwnPropertyDescriptor(this.__proto__, n);\n          if (pd && pd.value) {\n            this.observeArrayValue(n, pd.value, null);\n          }\n        }\n        for (var i=0, l=pn$.length, n; (i<l) && (n=pn$[i]); i++) {\n          if (!this.observe || (this.observe[n] === undefined)) {\n            o.addPath(this, n);\n          }\n        }\n        o.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        if (this.publish[name] !== undefined) {\n          this.reflectPropertyToAttribute(name);\n        }\n        method = this.observe[name];\n        if (method) {\n          this.observeArrayValue(name, newValues[i], oldValues[i]);\n          if (!called[method]) {\n            called[method] = true;\n            // observes the value if it is an array\n            this.invokeMethod(method, [oldValues[i], newValues[i], arguments]);\n          }\n        }\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.unregisterObserver(name + '__array');\n        }\n        // if the new value is an array, being observing it\n        if (Array.isArray(value)) {\n          log.observe && console.log('[%s] observeArrayValue: register observer [%s]', this.localName, name, value);\n          var observer = new ArrayObserver(value);\n          observer.open(function(value, old) {\n            this.invokeMethod(callbackName, [old]);\n          }, this);\n          this.registerObserver(name + '__array', observer);\n        }\n      }\n    },\n    bindProperty: function(property, observable) {\n      // apply Polymer two-way reference binding\n      return bindProperties(this, property, observable);\n    },\n    unbindAllProperties: function() {\n      if (this._propertyObserver) {\n        this._propertyObserver.close();\n      }\n      this.unregisterObservers();\n    },\n    unbindProperty: function(name) {\n      return this.unregisterObserver(name);\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    // bookkeeping observers for memory management\n    registerObserver: function(name, observer) {\n      var o$ = this._observers || (this._observers = {});\n      o$[name] = observer;\n    },\n    unregisterObserver: function(name) {\n      var o$ = this._observers;\n      if (o$ && o$[name]) {\n        o$[name].close();\n        o$[name] = null;\n        return true;\n      }\n    },\n    unregisterObservers: function() {\n      if (this._observers) {\n        var keys=Object.keys(this._observers);\n        for (var i=0, l=keys.length, k, o; (i < l) && (k=keys[i]); i++) {\n          o = this._observers[k];\n          o.close();\n        }\n        this._observers = {};\n      }\n    }\n  };\n\n  // property binding\n  // bind a property in A to a path in B by converting A[property] to a\n  // getter/setter pair that accesses B[...path...]\n  function bindProperties(inA, inProperty, observable) {\n    log.bind && console.log(LOG_BIND_PROPS, inB.localName || 'object', inPath, inA.localName, inProperty);\n    // capture A's value if B's value is null or undefined,\n    // otherwise use B's value\n    // TODO(sorvell): need to review, can do with ObserverTransform\n    var v = observable.discardChanges();\n    if (v === null || v === undefined) {\n      observable.setValue(inA[inProperty]);\n    }\n    return Observer.defineComputedProperty(inA, inProperty, observable);\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  var LOG_BIND_PROPS = \"[%s]: bindProperties: [%s] to [%s].[%s]\";\n\n  // exports\n\n  scope.api.instance.properties = properties;\n\n})(Polymer);\n","/*\n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\n */\n(function(scope) {\n\n  // imports\n\n  var log = window.logFlags || 0;\n  var events = scope.api.instance.events;\n\n  var syntax = new PolymerExpressions();\n  syntax.resolveEventHandler = function(model, path, node) {\n    var ctlr = findEventController(node);\n    if (ctlr) {\n      var fn = path.getValueFrom(ctlr);\n      if (fn) {\n        return fn.bind(ctlr);\n      }\n    }\n  }\n\n  // An event controller is the host element for the shadowRoot in which \n  // the node exists, or the first ancestor with a 'lightDomController'\n  // property.\n  function findEventController(node) {\n    while (node.parentNode) {\n      if (node.lightDomController) {\n        return node;\n      }\n      node = node.parentNode;\n    }\n    return node.host;\n  };\n\n  // element api supporting mdv\n\n  var mdv = {\n    syntax: syntax,\n    instanceTemplate: function(template) {\n      return template.createInstance(this, this.syntax);\n    },\n    bind: function(name, observable, oneTime) {\n      // note: binding is a prepare signal. This allows us to be sure that any\n      // property changes that occur as a result of binding will be observed.\n      if (!this._elementPrepared) {\n        this.prepareElement();\n      }\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        // clean out the closets\n        this.unbind(name);\n        // use n-way Polymer binding\n        var observer = this.bindProperty(property, observable);\n        // stick path on observer so it's available via this.bindings\n        observer.path = observable.path_;\n        // reflect bound property to attribute when binding\n        // to ensure binding is not left on attribute if property\n        // does not update due to not changing.\n        this.reflectPropertyToAttribute(property);\n        return this.bindings[name] = observer;\n      }\n    },\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.unbindAllProperties();\n        this.super();\n        // unbind shadowRoot\n        var root = this.shadowRoot;\n        while (root) {\n          unbindNodeTree(root);\n          root = root.olderShadowRoot;\n        }\n        this._unbound = true;\n      }\n    },\n    cancelUnbindAll: function(preventCascade) {\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      // cancel unbinding our shadow tree iff we're not in the process of\n      // cascading our tree (as we do, for example, when the element is inserted).\n      if (!preventCascade) {\n        forNodeTree(this.shadowRoot, function(n) {\n          if (n.cancelUnbindAll) {\n            n.cancelUnbindAll();\n          }\n        });\n      }\n    }\n  };\n\n  function unbindNodeTree(node) {\n    forNodeTree(node, _nodeUnbindAll);\n  }\n\n  function _nodeUnbindAll(node) {\n    node.unbindAll();\n  }\n\n  function forNodeTree(node, callback) {\n    if (node) {\n      callback(node);\n      for (var child = node.firstChild; child; child = child.nextSibling) {\n        forNodeTree(child, callback);\n      }\n    }\n  }\n\n  var mustachePattern = /\\{\\{([^{}]*)}}/;\n\n  // exports\n\n  scope.bindPattern = mustachePattern;\n  scope.api.instance.mdv = mdv;\n\n})(Polymer);\n","/*\n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\n */\n(function(scope) {\n  var preparingElements = 0;\n\n  var base = {\n    PolymerBase: true,\n    job: Polymer.job,\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      this.created();\n      if (this.ownerDocument.defaultView || this.alwaysPrepare ||\n          preparingElements > 0) {\n        this.prepareElement();\n      }\n    },\n    // system entry point, do not override\n    prepareElement: function() {\n      this._elementPrepared = true;\n      // install shadowRoots storage\n      this.shadowRoots = {};\n      // install property observers\n      this.observeProperties();\n      // install boilerplate attributes\n      this.copyInstanceAttributes();\n      // process input attributes\n      this.takeAttributes();\n      // add event listeners\n      this.addHostListeners();\n      // guarantees that while preparing, any\n      // sub-elements are also prepared\n      preparingElements++;\n      // process declarative resources\n      this.parseDeclarations(this.__proto__);\n      // decrement semaphore\n      preparingElements--;\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      if (!this._elementPrepared) {\n        this.prepareElement();\n      }\n      this.cancelUnbindAll(true);\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    },\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        // migrate flag(s)\n        root.resetStyleInheritance = this.resetStyleInheritance;\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) {\n      if (template) {\n        // TODO(sorvell): mark this element as a lightDOMController 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.lightDomController = true;\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        this.appendChild(dom);\n        // perform post-construction initialization tasks on ahem, light root\n        this.shadowRootReady(this, template);\n        // return the created shadow root\n        return dom;\n      }\n    },\n    shadowRootReady: function(root, template) {\n      // locate nodes with id and store references to them in this.$ hash\n      this.marshalNodeReferences(root);\n      // set up pointer gestures\n      PointerGestures.register(root);\n    },\n    // locate nodes with id and store references to them in this.$ hash\n    marshalNodeReferences: function(root) {\n      // establish $ instance variable\n      var $ = this.$ = this.$ || {};\n      // populate $ from nodes with ID from the LOCAL tree\n      if (root) {\n        var n$ = root.querySelectorAll(\"[id]\");\n        for (var i=0, l=n$.length, n; (i<l) && (n=n$[i]); i++) {\n          $[n.id] = n;\n        };\n      }\n    },\n    attributeChangedCallback: function(name, oldValue) {\n      // TODO(sjmiles): adhoc filter\n      if (name !== 'class' && name !== 'style') {\n        this.attributeToProperty(name, this.getAttribute(name));\n      }\n      if (this.attributeChanged) {\n        this.attributeChanged.apply(this, arguments);\n      }\n    },\n    onMutation: function(node, listener) {\n      var observer = new MutationObserver(function(mutations) {\n        listener.call(this, observer, mutations);\n        observer.disconnect();\n      }.bind(this));\n      observer.observe(node, {childList: true, subtree: true});\n    }\n  };\n\n  // true if object has own PolymerBase api\n  function isBase(object) {\n    return object.hasOwnProperty('PolymerBase') \n  }\n\n  // name a base constructor for dev tools\n\n  function PolymerBase() {};\n  PolymerBase.prototype = base;\n  base.constructor = PolymerBase;\n  \n  // exports\n\n  scope.Base = PolymerBase;\n  scope.isBase = isBase;\n  scope.api.instance.base = base;\n  \n})(Polymer);\n","/*\n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\n */\n(function(scope) {\n\n  // imports\n\n  var log = window.logFlags || {};\n  \n  // magic words\n  \n  var STYLE_SCOPE_ATTRIBUTE = 'element';\n  var STYLE_CONTROLLER_SCOPE = 'controller';\n  \n  var styles = {\n    STYLE_SCOPE_ATTRIBUTE: STYLE_SCOPE_ATTRIBUTE,\n    /**\n     * Installs external stylesheets and <style> elements with the attribute \n     * polymer-scope='controller' into the scope of element. This is intended\n     * to be a called during custom element construction. Note, this incurs a \n     * per instance cost and should be used sparingly.\n     *\n     * The need for this type of styling should go away when the shadowDOM spec\n     * addresses these issues:\n     * \n     * https://www.w3.org/Bugs/Public/show_bug.cgi?id=21391\n     * https://www.w3.org/Bugs/Public/show_bug.cgi?id=21390\n     * https://www.w3.org/Bugs/Public/show_bug.cgi?id=21389\n     * \n     * @param element The custom element instance into whose controller (parent)\n     * scope styles will be installed.\n     * @param elementElement The <element> containing controller styles.\n    */\n    // TODO(sorvell): remove when spec issues are addressed\n    installControllerStyles: function() {\n      // apply controller styles, but only if they are not yet applied\n      var scope = this.findStyleController();\n      if (scope && !this.scopeHasElementStyle(scope, STYLE_CONTROLLER_SCOPE)) {\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          var style = this.element.cssTextToScopeStyle(cssText,\n              STYLE_CONTROLLER_SCOPE);\n          // TODO(sorvell): for now these styles are not shimmed\n          // but we may need to shim them\n          Polymer.applyStyleToScope(style, scope);\n        }\n      }\n    },\n    findStyleController: function() {\n      if (window.ShadowDOMPolyfill) {\n        return wrap(document.head);\n      } else {\n        // find the shadow root that contains this element\n        var n = this;\n        while (n.parentNode) {\n          n = n.parentNode;\n        }\n        return n === document ? document.head : n;\n      }\n    },\n    scopeHasElementStyle: function(scope, descriptor) {\n      var rule = STYLE_SCOPE_ATTRIBUTE + '=' + this.localName + '-' + descriptor;\n      return scope.querySelector('style[' + rule + ']');\n    }\n  };\n  \n  // NOTE: use raw prototype traversal so that we ensure correct traversal\n  // on platforms where the protoype chain is simulated via __proto__ (IE10)\n  function getPrototypeOf(prototype) {\n    return prototype.__proto__;\n  }\n\n  // exports\n\n  scope.api.instance.styles = styles;\n  \n})(Polymer);\n","/*\n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\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 (getRegisteredPrototype[name]) {\n      throw 'Already registered (Polymer) prototype for element ' + name;\n    }\n    // cache the prototype\n    registerPrototype(name, prototype);\n    // notify the registrar waiting for 'name', if any\n    notifyPrototype(name);\n  }\n\n  // async prototype source\n\n  function waitingForPrototype(name, client) {\n    waitPrototype[name] = client;\n  }\n\n  var waitPrototype = {};\n\n  function notifyPrototype(name) {\n    if (waitPrototype[name]) {\n      waitPrototype[name].registerWhenReady();\n      delete waitPrototype[name];\n    }\n  }\n\n  // utility and bookkeeping\n\n  // maps tag names to prototypes, as registered with\n  // Polymer. Prototypes associated with a tag name\n  // using document.registerElement are available from\n  // HTMLElement.getPrototypeForTag().\n  // If an element was fully registered by Polymer, then\n  // Polymer.getRegisteredPrototype(name) === \n  //   HTMLElement.getPrototypeForTag(name)\n\n  var prototypesByName = {};\n\n  function registerPrototype(name, prototype) {\n    return prototypesByName[name] = prototype || {};\n  }\n\n  function getRegisteredPrototype(name) {\n    return prototypesByName[name];\n  }\n\n  // exports\n\n  scope.getRegisteredPrototype = getRegisteredPrototype;\n  scope.waitingForPrototype = waitingForPrototype;\n\n  // namespace shenanigans so we can expose our scope on the registration \n  // function\n\n  // make window.Polymer reference `element()`\n\n  window.Polymer = element;\n\n  // TODO(sjmiles): find a way to do this that is less terrible\n  // copy window.Polymer properties onto `element()`\n\n  extend(Polymer, scope);\n\n  // Under the HTMLImports polyfill, scripts in the main document\n  // do not block on imports; we want to allow calls to Polymer in the main\n  // document. Platform collects those calls until we can process them, which\n  // we do here.\n\n  var declarations = Platform.deliverDeclarations();\n  if (declarations) {\n    for (var i=0, l=declarations.length, d; (i<l) && (d=declarations[i]); i++) {\n      element.apply(null, d);\n    }\n  }\n\n})(Polymer);\n","/* \n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\n */\n\n(function(scope) {\n\nvar path = {\n  resolveElementPaths: function(node) {\n    Platform.urlResolver.resolveDom(node);\n  },\n  addResolvePathApi: function() {\n    // let assetpath attribute modify the resolve path\n    var assetPath = this.getAttribute('assetpath') || '';\n    var root = new URL(assetPath, this.ownerDocument.baseURI);\n    this.prototype.resolvePath = function(urlPath, base) {\n      var u = new URL(urlPath, base || root);\n      return u.href;\n    };\n  }\n};\n\n// exports\nscope.api.declaration.path = path;\n\n})(Polymer);\n","/*\n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\n */\n(function(scope) {\n\n  // imports\n\n  var log = window.logFlags || {};\n  var api = scope.api.instance.styles;\n  var STYLE_SCOPE_ATTRIBUTE = api.STYLE_SCOPE_ATTRIBUTE;\n\n  // magic words\n\n  var STYLE_SELECTOR = 'style';\n  var STYLE_LOADABLE_MATCH = '@import';\n  var SHEET_SELECTOR = 'link[rel=stylesheet]';\n  var STYLE_GLOBAL_SCOPE = 'global';\n  var SCOPE_ATTR = 'polymer-scope';\n\n  var styles = {\n    // returns true if resources are loading\n    loadStyles: function(callback) {\n      var content = this.templateContent();\n      if (content) {\n        this.convertSheetsToStyles(content);\n      }\n      var styles = this.findLoadableStyles(content);\n      if (styles.length) {\n        Platform.styleResolver.loadStyles(styles, callback);\n      } else 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        var scope = s.getAttribute(SCOPE_ATTR);\n        if (scope) {\n          c.setAttribute(SCOPE_ATTR, scope);\n        }\n        s.parentNode.replaceChild(c, s);\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    // TODO(sorvell): wip... caching and styles handling can probably be removed\n    // We need a scheme to ensure stylesheets are eagerly loaded without \n    // the creation of an element instance. Here are 2 options for handling this:\n    // 1. create a dummy element with ShadowDOM in dom that includes ALL styles\n    // processed here.\n    // 2. place stylesheets outside the element template. This will allow \n    // imports to naturally load the sheets. Then at load time, we can remove\n    // the stylesheet from dom.\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    templateContent: function() {\n      var template = this.querySelector('template');\n      return template && templateContent(template);\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      // 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      scope.appendChild(clone);\n    }\n  }\n\n  function createStyleElement(cssText, scope) {\n    scope = scope || document;\n    scope = scope.createElement ? scope : scope.ownerDocument;\n    var style = scope.createElement('style');\n    style.textContent = cssText;\n    return style;\n  }\n\n  function cssTextFromSheet(sheet) {\n    return (sheet && sheet.__resource) || '';\n  }\n\n  function matchesSelector(node, inSelector) {\n    if (matches) {\n      return matches.call(node, inSelector);\n    }\n  }\n  var p = HTMLElement.prototype;\n  var matches = p.matches || p.matchesSelector || p.webkitMatchesSelector \n      || p.mozMatchesSelector;\n  \n  // exports\n\n  scope.api.declaration.styles = styles;\n  scope.applyStyleToScope = applyStyleToScope;\n  \n})(Polymer);\n","/*\n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\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 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  };\n\n  var prefixLength = EVENT_PREFIX.length;\n\n  // exports\n  scope.api.declaration.events = events;\n\n})(Polymer);","/*\n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\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          //a.push(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    },\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    requireProperties: function(properties, prototype, base) {\n      // ensure a prototype value for each property\n      for (var n in properties) {\n        if (prototype[n] === undefined && base[n] === undefined) {\n          prototype[n] = properties[n];\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  };\n\n  // exports\n\n  scope.api.declaration.properties = properties;\n\n})(Polymer);\n","/*\n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\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    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    publishAttributes: function(prototype, base) {\n      // merge names from 'attributes' attribute\n      var attributes = this.getAttribute(ATTRIBUTES_ATTRIBUTE);\n      if (attributes) {\n        // get properties to publish\n        var publish = prototype.publish || (prototype.publish = {});\n        // names='a b c' or names='a,b,c'\n        var names = attributes.split(ATTRIBUTES_REGEX);\n        // record each name for publishing\n        for (var i=0, l=names.length, n; i<l; i++) {\n          // remove excess ws\n          n = names[i].trim();\n          // do not override explicit entries\n          if (n && publish[n] === undefined && base[n] === undefined) {\n            publish[n] = null;\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    isInstanceAttribute: function(name) {\n      return !this.blackList[name] && name.slice(0,3) !== 'on-';\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  // add ATTRIBUTES_ATTRIBUTE to the blacklist\n  attributes.blackList[ATTRIBUTES_ATTRIBUTE] = 1;\n\n  // exports\n\n  scope.api.declaration.attributes = attributes;\n\n})(Polymer);\n","/*\n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\n */\n(function(scope) {\n\n  // imports\n  \n  var api = scope.api;\n  var isBase = scope.isBase;\n  var extend = scope.extend;\n\n  // prototype api\n\n  var prototype = {\n\n    register: function(name, extendeeName) {\n      // build prototype combining extendee, Polymer base, and named api\n      this.buildPrototype(name, extendeeName);\n      // register our custom element with the platform\n      this.registerPrototype(name, extendeeName);\n      // reference constructor in a global named by 'constructor' attribute\n      this.publishConstructor();\n    },\n\n    buildPrototype: function(name, extendeeName) {\n      // get our custom prototype (before chaining)\n      var extension = scope.getRegisteredPrototype(name);\n      // get basal prototype\n      var base = this.generateBasePrototype(extendeeName);\n      // implement declarative features\n      this.desugarBeforeChaining(extension, base);\n      // join prototypes\n      this.prototype = this.chainPrototypes(extension, base);\n      // more declarative features\n      this.desugarAfterChaining(name, extendeeName);\n    },\n\n    desugarBeforeChaining: function(prototype, base) {\n      // back reference declaration element\n      // TODO(sjmiles): replace `element` with `elementElement` or `declaration`\n      prototype.element = this;\n      // transcribe `attributes` declarations onto own prototype's `publish`\n      this.publishAttributes(prototype, base);\n      // `publish` properties to the prototype and to attribute watch\n      this.publishProperties(prototype, base);\n      // infer observers for `observe` list based on method names\n      this.inferObservers(prototype);\n      // desugar compound observer syntax, e.g. 'a b c' \n      this.explodeObservers(prototype);\n    },\n\n    chainPrototypes: function(prototype, base) {\n      // chain various meta-data objects to inherited versions\n      this.inheritMetaData(prototype, base);\n      // chain custom api to inherited\n      var chained = this.chainObject(prototype, base);\n      // x-platform fixup\n      ensurePrototypeTraversal(chained);\n      return chained;\n    },\n\n    inheritMetaData: function(prototype, base) {\n      // chain observe object to inherited\n      this.inheritObject('observe', prototype, base);\n      // chain publish object to inherited\n      this.inheritObject('publish', prototype, base);\n      // chain 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      // install external stylesheets as if they are inline\n      this.installSheets();\n      // adjust any paths in dom from imports\n      this.resolveElementPaths(this);\n      // compile list of attributes to copy to instances\n      this.accumulateInstanceAttributes();\n      // parse on-* delegates declared on `this` element\n      this.parseHostEvents();\n      //\n      // install a helper method this.resolvePath to aid in \n      // setting resource urls. e.g.\n      // this.$.image.src = this.resolvePath('images/foo.png')\n      this.addResolvePathApi();\n      // under ShadowDOMPolyfill, transforms to approximate missing CSS features\n      if (window.ShadowDOMPolyfill) {\n        Platform.ShadowCSS.shimStyling(this.templateContent(), name, extendee);\n      }\n      // allow custom element access to the declarative context\n      if (this.prototype.registerCallback) {\n        this.prototype.registerCallback(this);\n      }\n    },\n\n    // if a named constructor is requested in element, map a reference\n    // to the constructor to the given symbol\n    publishConstructor: function() {\n      var symbol = this.getAttribute('constructor');\n      if (symbol) {\n        window[symbol] = this.ctor;\n      }\n    },\n\n    // build prototype combining extendee, Polymer base, and named api\n    generateBasePrototype: function(extnds) {\n      var prototype = this.findBasePrototype(extnds);\n      if (!prototype) {\n        // create a prototype based on tag-name extension\n        var prototype = HTMLElement.getPrototypeForTag(extnds);\n        // insert base api in inheritance chain (if needed)\n        prototype = this.ensureBaseApi(prototype);\n        // memoize this base\n        memoizedBases[extnds] = prototype;\n      }\n      return prototype;\n    },\n\n    findBasePrototype: function(name) {\n      return memoizedBases[name];\n    },\n\n    // install Polymer instance api into prototype chain, as needed \n    ensureBaseApi: function(prototype) {\n      if (prototype.PolymerBase) {\n        return prototype;\n      }\n      var extended = Object.create(prototype);\n      // we need a unique copy of base api for each base prototype\n      // therefore we 'extend' here instead of simply chaining\n      api.publish(api.instance, extended);\n      // TODO(sjmiles): sharing methods across prototype chains is\n      // not supported by 'super' implementation which optimizes\n      // by memoizing prototype relationships.\n      // Probably we should have a version of 'extend' that is \n      // share-aware: it could study the text of each function,\n      // look for usage of 'super', and wrap those functions in\n      // closures.\n      // As of now, there is only one problematic method, so \n      // we just patch it manually.\n      // To avoid re-entrancy problems, the special super method\n      // installed is called `mixinSuper` and the mixin method\n      // must use this method instead of the default `super`.\n      this.mixinMethod(extended, prototype, api.instance.mdv, 'bind');\n      // return buffed-up prototype\n      return extended;\n    },\n\n    mixinMethod: function(extended, prototype, api, name) {\n      var $super = function(args) {\n        return prototype[name].apply(this, args);\n      };\n      extended[name] = function() {\n        this.mixinSuper = $super;\n        return api[name].apply(this, arguments);\n      }\n    },\n\n    // ensure prototype[name] inherits from a prototype.prototype[name]\n    inheritObject: function(name, prototype, base) {\n      // require an object\n      var source = prototype[name] || {};\n      // chain inherited properties onto a new object\n      prototype[name] = this.chainObject(source, base[name]);\n    },\n\n    // register 'prototype' to custom element 'name', store constructor \n    registerPrototype: function(name, extendee) { \n      var info = {\n        prototype: this.prototype\n      }\n      // native element must be specified in extends\n      var typeExtension = this.findTypeExtension(extendee);\n      if (typeExtension) {\n        info.extends = typeExtension;\n      }\n      // register the prototype with HTMLElement for name lookup\n      HTMLElement.register(name, this.prototype);\n      // register the custom type\n      this.ctor = document.registerElement(name, info);\n      // constructor shenanigans\n      this.prototype.constructor = this.ctor;\n    },\n\n    findTypeExtension: function(name) {\n      if (name && name.indexOf('-') < 0) {\n        return name;\n      } else {\n        var p = this.findBasePrototype(name);\n        if (p.element) {\n          return this.findTypeExtension(p.element.extends);\n        }\n      }\n    }\n\n  };\n\n  // memoize base prototypes\n  var memoizedBases = {};\n\n  // implementation of 'chainObject' depends on support for __proto__\n  if (Object.__proto__) {\n    prototype.chainObject = function(object, inherited) {\n      if (object && inherited && object !== inherited) {\n        object.__proto__ = inherited;\n      }\n      return object;\n    }\n  } else {\n    prototype.chainObject = function(object, inherited) {\n      if (object && inherited && object !== inherited) {\n        var chained = Object.create(inherited);\n        object = extend(chained, object);\n      }\n      return object;\n    }\n  }\n\n  // On platforms that do not support __proto__ (versions of IE), the prototype\n  // chain of a custom element is simulated via installation of __proto__.\n  // Although custom elements manages this, we install it here so it's\n  // available during desugaring.\n  function ensurePrototypeTraversal(prototype) {\n    if (!Object.__proto__) {\n      var ancestor = Object.getPrototypeOf(prototype);\n      prototype.__proto__ = ancestor;\n      if (isBase(ancestor)) {\n        ancestor.__proto__ = Object.getPrototypeOf(ancestor);\n      }\n    }\n  }\n\n  // exports\n\n  api.declaration.prototype = prototype;\n\n})(Polymer);\n","/*\n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\n */\n(function(scope) {\n\n  var queue = {\n    // tell the queue to wait for an element to be ready\n    wait: function(element) {\n      if (this.indexOf(element) === -1 && \n          (flushQueue.indexOf(element) === -1)) {\n        this.add(element);\n      }\n      return (this.indexOf(element) !== 0);\n    },\n    add: function(element) {\n      //console.log('queueing', element.name);\n      queueForElement(element).push(element);\n    },\n    indexOf: function(element) {\n      var i = queueForElement(element).indexOf(element);\n      if (i >= 0 && document.contains(element)) {\n        i += (HTMLImports.useNative || HTMLImports.ready) ? importQueue.length :\n            1e9;\n      }\n      return i;  \n    },\n    // tell the queue an element is ready to be registered\n    register: function(element) {\n      var readied = this.remove(element);\n      if (readied) {\n        flushQueue.push(readied);\n        this.check();\n      }\n    },\n    remove: function(element) {\n      var i = this.indexOf(element);\n      if (i !== 0) {\n        //console.warn('queue order wrong', i);\n        return;\n      }\n      return queueForElement(element).shift();  \n    },\n    check: function() {\n      // next\n      var element = this.nextElement();\n      if (element) {\n        element.registerWhenReady();\n      }\n      if (this.canFlush()) {\n        this.flush();\n        return true;\n      }\n    },\n    nextElement: function() {\n      return nextQueued();\n    },\n    canFlush: function() {\n      return !this.waitToFlush && this.isEmpty();\n    },\n    isEmpty: function() {\n      return !importQueue.length && !mainQueue.length;\n    },\n    flush: 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      CustomElements.ready = false;\n      var element;\n      while (flushQueue.length) {\n        element = flushQueue.shift();\n        element._register();\n      }\n      CustomElements.upgradeDocumentTree(document);\n      CustomElements.ready = true;\n      this.flushReadyCallbacks();\n    },\n    flushReadyCallbacks: function() {\n      if (readyCallbacks) {\n        var fn;\n        while (readyCallbacks.length) {\n          fn = readyCallbacks.shift();\n          fn();\n        }\n      }\n    },\n    addReadyCallback: function(callback) {\n      if (callback) {\n        readyCallbacks.push(callback);\n      }\n    },\n    waitToFlush: true\n  };\n\n  var importQueue = [];\n  var mainQueue = [];\n  var flushQueue = [];\n  var readyCallbacks = [];\n\n  function queueForElement(element) {\n    return document.contains(element) ? mainQueue : importQueue;\n  }\n\n  function nextQueued() {\n    return importQueue.length ? importQueue[0] : mainQueue[0];\n  }\n\n  var polymerReadied = false; \n  \n  function whenPolymerReady(callback) {\n    queue.waitToFlush = true;\n    HTMLImports.whenImportsReady(function() {\n      queue.addReadyCallback(callback);\n      queue.waitToFlush = false;\n      queue.check();\n    });\n  }\n\n  // exports\n  scope.queue = queue;\n  scope.whenPolymerReady = whenPolymerReady;\n})(Polymer);\n","/*\n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\n */\n(function(scope) {\n\n  var whenPolymerReady = scope.whenPolymerReady;\n\n  function importElements(elementOrFragment, callback) {\n    if (elementOrFragment) {\n      document.head.appendChild(elementOrFragment);\n      whenPolymerReady(callback);\n    } else if (callback) {\n      callback();\n    }\n  }\n\n  function importUrls(urls, callback) {\n    if (urls && urls.length) {\n        var frag = document.createDocumentFragment();\n        for (var i=0, l=urls.length, url, link; (i<l) && (url=urls[i]); i++) {\n          link = document.createElement('link');\n          link.rel = 'import';\n          link.href = url;\n          frag.appendChild(link);\n        }\n        importElements(frag, callback);\n    } else if (callback) {\n      callback();\n    }\n  }\n\n  // exports\n  scope.import = importUrls;\n  scope.importElements = importElements;\n\n})(Polymer);\n","/*\n * Copyright 2013 The Polymer Authors. All rights reserved.\n * Use of this source code is governed by a BSD-style\n * license that can be found in the LICENSE file.\n */\n(function(scope) {\n\n  // imports\n\n  var extend = scope.extend;\n  var api = scope.api;\n  var queue = scope.queue;\n  var whenPolymerReady = scope.whenPolymerReady;\n  var getRegisteredPrototype = scope.getRegisteredPrototype;\n  var waitingForPrototype = scope.waitingForPrototype;\n\n  // declarative implementation: <polymer-element>\n\n  var prototype = extend(Object.create(HTMLElement.prototype), {\n\n    createdCallback: function() {\n      if (this.getAttribute('name')) {\n        this.init();\n      }\n    },\n\n    init: function() {\n      // fetch declared values\n      this.name = this.getAttribute('name');\n      this.extends = this.getAttribute('extends');\n      // initiate any async resource fetches\n      this.loadResources();\n      // register when all constraints are met\n      this.registerWhenReady();\n    },\n\n    registerWhenReady: function() {\n     if (this.registered\n       || this.waitingForPrototype(this.name)\n       || this.waitingForQueue()\n       || this.waitingForResources()) {\n          return;\n      }\n      queue.register(this);\n    },\n\n\n    // TODO(sorvell): refactor, this method is private-ish, but it's being\n    // called by the queue object.\n    _register: function() {\n      //console.log('registering', this.name);\n      //console.group('registering', this.name);\n      // warn if extending from a custom element not registered via Polymer\n      if (isCustomTag(this.extends) && !isRegistered(this.extends)) {\n        console.warn('%s is attempting to extend %s, an unregistered element ' +\n            'or one that was not registered with Polymer.', this.name,\n            this.extends);\n      }\n      this.register(this.name, this.extends);\n      this.registered = true;\n      //console.groupEnd();\n    },\n\n    waitingForPrototype: function(name) {\n      if (!getRegisteredPrototype(name)) {\n        // then wait for a prototype\n        waitingForPrototype(name, this);\n        // emulate script if user is not supplying one\n        this.handleNoScript(name);\n        // prototype not ready yet\n        return true;\n      }\n    },\n\n    handleNoScript: function(name) {\n      // if explicitly marked as 'noscript'\n      if (this.hasAttribute('noscript') && !this.noscript) {\n        this.noscript = true;\n        // TODO(sorvell): CustomElements polyfill awareness:\n        // noscript elements should upgrade in logical order\n        // script injection ensures this under native custom elements;\n        // under imports + ce polyfills, scripts run before upgrades.\n        // dependencies should be ready at upgrade time so register\n        // prototype at this time.\n        if (window.CustomElements && !CustomElements.useNative) {\n          Polymer(name);\n        } else {\n          var script = document.createElement('script');\n          script.textContent = 'Polymer(\\'' + name + '\\');';\n          this.appendChild(script);\n        }\n      }\n    },\n\n    waitingForResources: function() {\n      return this._needsResources;\n    },\n\n    // NOTE: Elements must be queued in proper order for inheritance/composition\n    // dependency resolution. Previously this was enforced for inheritance,\n    // and by rule for composition. It's now entirely by rule.\n    waitingForQueue: function() {\n      return queue.wait(this);\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  // exports\n\n  scope.getRegisteredPrototype = getRegisteredPrototype;\n  \n  // boot tasks\n\n  whenPolymerReady(function() {\n    document.body.removeAttribute('unresolved');\n    document.dispatchEvent(\n      new CustomEvent('polymer-ready', {bubbles: true})\n    );\n  });\n\n  // register polymer-element with document\n\n  document.registerElement('polymer-element', {prototype: prototype});\n\n})(Polymer);\n"]}