| 1 {"version":3,"file":"polymer.js","sources":["polymer.concat.js"],"names":["windo
w","PolymerGestures","scope","HAS_FULL_PATH","pathTest","document","createElemen
t","createShadowRoot","sr","s","appendChild","addEventListener","ev","path","sto
pPropagation","CustomEvent","bubbles","head","dispatchEvent","parentNode","remov
eChild","target","shadow","inEl","shadowRoot","webkitShadowRoot","canTarget","Bo
olean","elementFromPoint","targetingShadow","this","olderShadow","os","olderShad
owRoot","se","querySelector","allShadows","element","shadows","push","searchRoot
","inRoot","x","y","t","owner","nodeType","Node","DOCUMENT_NODE","DOCUMENT_FRAGM
ENT_NODE","findTarget","inEvent","length","clientX","clientY","findTouchAction",
"n","i","ELEMENT_NODE","hasAttribute","getAttribute","host","LCA","a","b","conta
ins","adepth","depth","bdepth","d","walk","u","deepContains","common","insideNod
e","node","rect","getBoundingClientRect","left","right","top","bottom","event","
p","targetFinding","bind","shadowSelector","v","selector","rule","attrib2css","s
electors","styles","hasTouchAction","style","touchAction","hasShadowRoot","Shado
wDOMPolyfill","forEach","r","String","map","el","textContent","MOUSE_PROPS","MOU
SE_DEFAULTS","NOP_FACTORY","eventFactory","preventTap","makeBaseEvent","inType",
"inDict","e","createEvent","initEvent","cancelable","makeGestureEvent","Object",
"create","k","keys","makePointerEvent","buttons","pressure","pointerId","width",
"height","tiltX","tiltY","pointerType","hwTimestamp","isPrimary","_source","Poin
terMap","USE_MAP","m","Map","pointers","POINTERS_FN","values","prototype","size"
,"set","inId","indexOf","has","delete","splice","get","clear","callback","thisAr
g","call","currentGestures","CLONE_PROPS","CLONE_DEFAULTS","HAS_SVG_INSTANCE","S
VGElementInstance","dispatcher","IS_IOS","pointermap","requiredGestures","eventM
ap","eventSources","eventSourceList","gestures","dependencyMap","down","listener
s","index","up","gestureQueue","registerSource","name","source","newEvents","eve
nts","registerGesture","obj","g","exposes","toLowerCase","register","initial","e
s","l","unregister","fireEvent","move","type","fillGestureQueue","cancel","tapPr
evented","addGestureDependency","gesturesWanted","_pgEvents","ri","gk","eventHan
dler","_handledByPG","nodes","currentTarget","fn","listen","addEvent","unlisten"
,"removeEvent","eventName","boundHandler","removeEventListener","makeEvent","pre
ventDefault","_target","cloneEvent","eventCopy","correspondingUseElement","clone
","gestureTrigger","rg","_requiredGestures","j","requestAnimationFrame","boundGe
stureTrigger","activateGesture","gesture","dep","recognizer","_pgListeners","act
ionNode","defaultActions","setAttribute","handler","capture","deactivateGesture"
,"DEDUP_DIST","WHICH_TO_BUTTONS","HAS_BUTTONS","MouseEvent","mouseEvents","POINT
ER_ID","POINTER_TYPE","lastTouches","isEventSimulatedFromTouch","lts","dx","Math
","abs","dy","prepareEvent","which","mousedown","mouseup","mousemove","cleanupMo
use","relatedTarget","DEDUP_TIMEOUT","Array","CLICK_COUNT_TIMEOUT","HYSTERESIS",
"HAS_TOUCH_ACTION","touchEvents","scrollTypes","EMITTER","XSCROLLER","YSCROLLER"
,"touchActionToScrollType","st","firstTouch","isPrimaryTouch","inTouch","identif
ier","setPrimaryTouch","firstXY","X","Y","scrolling","cancelResetClickCount","re
movePrimaryPointer","inPointer","resetClickCount","clickCount","resetId","setTim
eout","clearTimeout","typeToButtons","ret","touch","id","currentTouchEvent","fas
tPath","touchToPointer","cte","detail","webkitRadiusX","radiusX","webkitRadiusY"
,"radiusY","webkitForce","force","self","processTouches","inFunction","tl","chan
gedTouches","_cancel","cleanUpPointer","shouldScroll","scrollAxis","oa","da","do
a","findTouch","inTL","vacuumTouches","touches","value","key","touchstart","dedu
pSynthMouse","touchmove","dd","sqrt","touchcancel","touchend","lt","HAS_BITMAP_T
YPE","MSPointerEvent","MSPOINTER_TYPE_MOUSE","msEvents","POINTER_TYPES","cleanup
","MSPointerDown","MSPointerMove","MSPointerUp","MSPointerCancel","pointerEvents
","pointerdown","pointermove","pointerup","pointercancel","nav","navigator","Poi
nterEvent","msPointerEnabled","undefined","ontouchstart","ua","userAgent","match
","track","trackx","tracky","WIGGLE_THRESHOLD","clampDir","inDelta","calcPositio
nDelta","inA","inB","pageX","pageY","fireTrack","inTrackingData","downEvent","la
stMoveEvent","xDirection","yDirection","gestureProto","trackInfo","ddx","screenX
","ddy","screenY","downTarget","tracking","hold","HOLD_DELAY","heldPointer","hol
dJob","pulse","Date","now","timeStamp","held","fireHold","clearInterval","setInt
erval","inHoldTime","holdTime","tap","shouldTap","downState","start","altKey","c
trlKey","metaKey","shiftKey","global","assert","condition","message","Error","is
DecimalDigit","ch","isWhiteSpace","fromCharCode","isLineTerminator","isIdentifie
rStart","isIdentifierPart","isKeyword","skipWhitespace","charCodeAt","getIdentif
ier","slice","scanIdentifier","Token","Identifier","Keyword","NullLiteral","Bool
eanLiteral","range","scanPunctuator","code2","ch2","code","ch1","Punctuator","th
rowError","Messages","UnexpectedToken","scanNumericLiteral","number","NumericLit
eral","parseFloat","scanStringLiteral","quote","str","octal","StringLiteral","is
IdentifierName","token","advance","EOF","lex","lookahead","peek","pos","messageF
ormat","error","args","arguments","msg","replace","whole","description","throwUn
expected","expect","matchKeyword","keyword","parseArrayInitialiser","elements","
parseExpression","delegate","createArrayExpression","parseObjectPropertyKey","cr
eateLiteral","createIdentifier","parseObjectProperty","createProperty","parseObj
ectInitialiser","properties","createObjectExpression","parseGroupExpression","ex
pr","parsePrimaryExpression","createThisExpression","parseArguments","parseNonCo
mputedProperty","parseNonComputedMember","parseComputedMember","parseLeftHandSid
eExpression","property","createMemberExpression","createCallExpression","parseUn
aryExpression","parsePostfixExpression","createUnaryExpression","binaryPrecedenc
e","prec","parseBinaryExpression","stack","operator","pop","createBinaryExpressi
on","parseConditionalExpression","consequent","alternate","createConditionalExpr
ession","parseFilter","createFilter","parseFilters","parseTopLevel","Syntax","pa
rseInExpression","parseAsExpression","createTopLevel","createAsExpression","inde
xName","createInExpression","parse","inDelegate","state","labelSet","TokenName",
"ArrayExpression","BinaryExpression","CallExpression","ConditionalExpression","E
mptyStatement","ExpressionStatement","Literal","LabeledStatement","LogicalExpres
sion","MemberExpression","ObjectExpression","Program","Property","ThisExpression
","UnaryExpression","UnknownLabel","Redeclaration","esprima","prepareBinding","e
xpressionText","filterRegistry","expression","getExpression","scopeIdent","tagNa
me","ex","console","model","oneTime","binding","getBinding","polymerExpressionSc
opeIdent_","indexIdent","polymerExpressionIndexIdent_","expressionParseCache","A
STDelegate","Expression","valueFn_","IdentPath","Path","object","accessor","comp
uted","dynamicDeps","simplePath","getFn","Filter","notImplemented","arg","valueF
n","filters","deps","currentPath","ConstantObservable","value_","convertStylePro
pertyName","c","findScope","prop","parentScopeName","hasOwnProperty","isLiteralE
xpression","pathString","isNaN","Number","PolymerExpressions","observer","addPat
h","getValueFrom","setValue","newValue","setValueFrom",{"end":{"file":"polymer.c
oncat.js","comments_before":[],"nlb":false,"endpos":93731,"pos":93723,"col":8,"l
ine":3221,"value":"fullPath","type":"name"},"start":{"file":"polymer.concat.js",
"comments_before":[],"nlb":false,"endpos":93731,"pos":93723,"col":8,"line":3221,
"value":"fullPath","type":"name"},"name":"fullPath"},"fullPath","fullPath_","par
ts","context","propName","transform","toModelDirection","initialArgs","toModel",
"toDOM","apply","unaryOperators","+","-","!","binaryOperators","*","/","%","<","
>","<=",">=","==","!=","===","!==","&&","||","op","argument","test","ident","fil
ter","arr","kind","open","discardChanges","deliver","close","firstTime","firstVa
lue","startReset","getValue","finishReset","setValueFn","CompoundObserver","Obse
rverTransform","count","random","toString","styleObject","join","tokenList","tok
ens","prepareInstancePositionChanged","template","templateInstance","valid","Pat
hObserver","prepareInstanceModel","scopeName","parentScope","createScopeObject",
"__proto__","defineProperty","configurable","writable","Polymer","version","Plat
form","logFlags","flush","CustomElements","useNative","ready","takeRecords","ins
tanceof","base","HTMLImports","wrap","unwrap","whenReady","doc","rootDocument","
whenDocumentReady","watchImportsLoad","isDocumentReady","readyState","requiredRe
adyState","checkReady","READY_EVENT","markTargetLoaded","__loaded","checkDone","
loaded","loadedImport","imports","querySelectorAll","imp","isImportLoaded","link
","import","__importParsed","handleImports","isImport","handleImport","localName
","rel","IMPORT_LINK_TYPE","hasNative","isIE","hasShadowDOMPolyfill","wrapIfNeed
ed","currentScriptDescriptor","script","currentScript","scripts","MutationObserv
er","mxns","addedNodes","observe","childList","readyTime","getTime","withDepende
ncies","task","depends","marshal","module","dependsOrFactory","moduleFactory","m
odules","using","whenImportsReady","modularize","insertBefore","firstChild","det
ectObjectObserve","recs","records","deliverChangeRecords","unobserve","detectEva
l","chrome","app","runtime","getDeviceStorage","f","Function","isIndex","toNumbe
r","isObject","areSameValue","numberIsNaN","getPathCharType","char","noop","pars
ePath","maybeUnescapeQuote","nextChar","mode","newChar","actions","append","tran
sition","action","typeMap","pathStateMachine","isIdent","identRegExp","privateTo
ken","constructorIsPrivate","hasEval","compiledGetValueFromFn","getPath","pathCa
che","invalidPath","formatAccessor","dirtyCheck","cycles","MAX_DIRTY_CHECK_CYCLE
S","check_","testingExposeCycleCount","dirtyCheckCycleCount","objectIsEmpty","di
ffIsEmpty","diff","added","removed","changed","diffObjectFromOldObject","oldObje
ct","isArray","runEOMTasks","eomTasks","newObservedObject","state_","OPENED","di
scardRecords","first","obs","arrayObserve","discard","observedObjectCache","getO
bservedObject","dir","newObservedSet","rootObj","rootObjProps","objects","getPro
totypeOf","allRootObjNonObservedProps","rec","observers","iterateObjects_","obse
rverCount","record","Observer","unobservedCount","observedSetCache","getObserved
Set","lastObservedSet","UNOPENED","callback_","target_","directObserver_","id_",
"nextObserverId","addToAll","_allObserversCount","collectObservers","allObserver
s","removeFromAll","ObjectObserver","oldObject_","ArrayObserver","array","object
_","path_","reportChangesOnOpen","reportChangesOnOpen_","observed_","identFn","o
bservable","getValueFn","dontPassThroughSet","observable_","getValueFn_","setVal
ueFn_","dontPassThroughSet_","diffObjectFromChangeRecords","changeRecords","oldV
alues","expectedRecordTypes","oldValue","newSplice","addedCount","ArraySplice","
calcSplices","current","currentStart","currentEnd","old","oldStart","oldEnd","ar
raySplice","intersect","start1","end1","start2","end2","mergeSplice","splices","
inserted","insertionOffset","intersectCount","deleteCount","prepend","offset","c
reateInitialSplices","JSON","stringify","projectArraySplices","concat","hasObser
ve","createObject","proto","newObject","getOwnPropertyNames","getOwnPropertyDesc
riptor","identStart","identPart","RegExp","beforePath","ws","[","eof","inPath","
.","beforeIdent","inIdent","0","beforeElement","'","\"","afterZero","]","inIndex
","inSingleQuote","else","inDoubleQuote","afterElement","iterateObjects","runEOM
","eomObj","pingPong","eomRunScheduled","CLOSED","RESETTING","connect_","disconn
ect_","report_","changes","_errorThrownDuringCallback","runningMicrotaskCheckpoi
nt","performMicrotaskCheckpoint","anyChanged","toCheck","clearObservers","copyOb
ject","copy","applySplices","previous","spliceArgs","addIndex","skipChanges","ob
serverSentinel","needsDirectObserver","addObserver","observedCallback_","add","u
pdate","EDIT_LEAVE","EDIT_UPDATE","EDIT_ADD","EDIT_DELETE","calcEditDistances","
rowCount","columnCount","distances","equals","north","west","spliceOperationsFro
mEditDistances","edits","min","northWest","reverse","prefixCount","suffixCount",
"minLength","sharedPrefix","sharedSuffix","ops","oldIndex","searchLength","index
1","index2","calculateSplices","currentValue","previousValue","runEOM_","observe
rSentinel_","hasObjectObserve","getTreeScope","getElementById","updateBindings",
"bindings","bindings_","returnBinding","sanitizeValue","updateText","data","text
Binding","updateAttribute","conditional","removeAttribute","attributeBinding","g
etEventForInputType","checkboxEventType","updateInput","input","santizeFn","inpu
tBinding","bindInputEvent","postEventFn","eventType","booleanSanitize","getAssoc
iatedRadioButtons","form","treeScope","radios","checkedPostEvent","radio","check
edBinding","checked","updateOption","option","select","selectBinding","HTMLSelec
tElement","optionBinding","bindFinished","maybeUpdateBindings","enable","Text","
Element","div","checkbox","initMouseEvent","HTMLInputElement","HTMLElement","san
itizeFn","HTMLTextAreaElement","HTMLOptionElement","getFragmentRoot","searchRefI
d","ref","protoContent_","templateCreator_","isSVGTemplate","namespaceURI","isHT
MLTemplate","isAttributeTemplate","semanticTemplateElements","isTemplate","isTem
plate_","forAllTemplatesFrom","subTemplates","allTemplatesSelectors","bootstrapT
emplatesRecursivelyFrom","bootstrap","HTMLTemplateElement","decorate","content",
"mixin","to","from","getOrCreateTemplateContentsOwner","ownerDocument","defaultV
iew","templateContentsOwner_","implementation","createHTMLDocument","lastChild",
"getTemplateStagingDocument","stagingDocument_","isStagingDocument","href","base
URI","extractTemplateFromAttributeTemplate","attribs","attributes","attrib","tem
plateAttributeDirectives","extractTemplateFromSVGTemplate","liftNonNativeTemplat
eChildrenIntoContent","useRoot","child","fixTemplateElementPrototype","hasProto"
,"ensureSetModelScheduled","setModelFn_","setModelFnScheduled_","getBindings","d
elegate_","processBindings","model_","parseMustaches","prepareBindingFn","startI
ndex","lastIndex","endIndex","onlyOneTime","oneTimeStart","terminator","trim","d
elegateFn","hasOnePath","isSimplePath","combinator","processOneTimeBinding","pro
cessSinglePathBinding","processBinding","instanceBindings","iter","processBindin
gDirectives_","parseWithDefault","parseAttributeBindings","attr","substring","IF
","BIND","REPEAT","if","repeat","TEXT_NODE","cloneAndBindInstance","parent","sta
gingDocument","importNode","nextSibling","children","setDelegate_","createInstan
ceBindingMap","getContentUid","contentUidCounter","getInstanceBindingMap","conte
ntId","bindingMaps","bindingMap_","TemplateIterator","templateElement","closed",
"templateElement_","instances","iteratedValue","presentValue","arrayObserver","o
pt_this","Document","documentElement","THEAD","TBODY","TFOOT","TH","TR","TD","CO
LGROUP","COL","CAPTION","OPTION","OPTGROUP","hasTemplateElement","html","TypeErr
or","templateObserver","refChanged_","opt_instanceRef","templateIsDecorated_","i
sNativeHTMLTemplate","bootstrapContents","liftContents","liftRoot","content_","c
reateDocumentFragment","instanceRef_","htmlElement","HTMLUnknownElement","conten
tDescriptor","enumerable","directives","iterator_","closeDeps","updateDependenci
es","attributeFilter","createInstance","bindingDelegate","newDelegate_","refCont
ent_","ref_","emptyInstance","instance","terminator_","instanceRecord","template
Instance_","firstNode","lastNode","collectTerminator","raw","valueChanged","upda
teIteratedValue","getUpdatedValue","instancePositionChangedFn_","instanceModelFn
_","nextRef","ifOneTime","ifValue","hasIf","updateIfValue","updateValue","observ
eValue","handleSplices","getLastInstanceNode","subtemplateIterator","getLastTemp
lateNode","insertInstanceAt","fragment","previousInstanceLast","extractInstanceA
t","getDelegateFn","instanceCache","removeDelta","closeInstanceBindings","report
InstancesMoved","reportInstanceMoved","forAllTemplatesFrom_","endOfMicrotask","t
widdle","iterations","callbacks","atEndOfMicrotask","shift","createTextNode","Js
MutationObserver","characterData","flushing","group","groupEnd","FLUSH_POLL_INTE
RVAL","flushPoll","originalImportNode","deep","imported","upgradeAll","replaceUr
lsInCssText","cssText","baseUrl","keepAbsolute","regexp","pre","url","post","url
Path","resolveRelativeUrl","URL","makeDocumentRelPath","root","port","protocol",
"makeRelPath","sourceUrl","targetUrl","pathname","split","unshift","search","has
h","urlResolver","resolveDom","resolveAttributes","resolveStyles","templates","r
esolveTemplate","resolveStyle","resolveCssText","CSS_URL_REGEXP","CSS_IMPORT_REG
EXP","hasAttributes","resolveElementAttributes","URL_ATTRS_SELECTOR","URL_ATTRS"
,"replacement","URL_TEMPLATE_SEARCH","Loader","regex","cache","requests","extrac
tUrls","text","matched","matches","exec","process","done","fetch","inflight","re
q","xhr","wait","handleXhr","request","response","responseText","resolve","XMLHt
tpRequest","send","onerror","onload","pending","StyleResolver","loader","flatten
","resolveNode","intermediate","loadStyles","loadedStyle","styleResolver","exten
d","api","pd","nom","inObj","copyProperty","inName","inSource","inTarget","getPr
opertyDescriptor","inObject","job","stop","Job","go","inContext","boundComplete"
,"complete","h","handle","cancelAnimationFrame","createDOM","inTagOrNode","inHTM
L","inAttrs","dom","cloneNode","innerHTML","registry","tag","getPrototypeForTag"
,"originalStopPropagation","Event","cancelBubble","DOMTokenList","remove","toggl
e","bool","switch","oldName","newName","ArraySlice","namedNodeMap","NamedNodeMap
","MozNamedAttrMap","NodeList","HTMLCollection","$super","arrayOfArgs","caller",
"_super","nameInThis","warn","memoizeSuper","n$","method","nextSuper","super","n
oopHandler","deserializeValue","inferredType","typeHandlers","string","date","bo
olean","parseInt","function","declaration","publish","apis","utils","async","tim
eout","cancelAsync","fire","onNode","asyncFire","classFollows","anew","className
","classList","injectBoundHTML","instanceTemplate","nop","nob","asyncMethod","lo
g","EVENT_PREFIX","addHostListeners","eventDelegates","methodName","getEventHand
ler","dispatchMethod","handlerFn","copyInstanceAttributes","a$","_instanceAttrib
utes","takeAttributes","_publishLC","attributeToProperty","propertyForAttribute"
,"bindPattern","stringValue","serializeValue","reflectPropertyToAttribute","seri
alizedValue","resolveBindingValue","updateRecord","createPropertyObserver","_obs
erveNames","o","_propertyObserver","registerObserver","observeArrayValue","openP
ropertyObserver","notifyPropertyChanges","newValues","paths","called","ov","nv",
"invokeMethod","deliverChanges","propertyChanged_","reflect","callbackName","clo
seNamedObserver","registerNamedObserver","emitPropertyChangeRecord","notifier","
notifier_","getNotifier","notify","bindToAccessor","resolveFn","privateName","se
tObserveable","privateComputedBoundValue","privateObservable","resolvedValue","c
reateComputedProperties","_computedNames","syntax","bindProperty","_observers","
closeObservers","o$","_namedObservers","closeNamedObservers","mdv","enableBindin
gsReflection","_recordBinding","mixinSuper","makeElementReady","asyncUnbindAll",
"_unbound","unbind","_unbindAllJob","unbindAll","cancelUnbindAll","mustachePatte
rn","isBase","PolymerBase","created","createdCallback","prepareElement","_elemen
tPrepared","shadowRoots","_readied","parseDeclarations","attachedCallback","atta
ched","enteredView","hasBeenAttached","domReady","detachedCallback","preventDisp
ose","detached","leftView","enteredViewCallback","leftViewCallback","enteredDocu
mentCallback","leftDocumentCallback","parseDeclaration","elementElement","fetchT
emplate","shadowFromTemplate","shadowRootReady","lightFromTemplate","refNode","e
ventController","marshalNodeReferences","$","attributeChangedCallback","attribut
eChanged","onMutation","listener","mutations","disconnect","subtree","constructo
r","Base","shimCssText","is","ShadowCSS","makeScopeSelector","STYLE_SCOPE_ATTRIB
UTE","STYLE_CONTROLLER_SCOPE","installControllerStyles","findStyleScope","scopeH
asNamedStyle","cssTextForScope","installScopeCssText","installScopeStyle","cssTe
xtToScopeStyle","applyStyleToScope","styleCacheForScope","polyfillScopeStyleCach
e","_scopeStyles","_currentScript","getRegisteredPrototype","registerPrototype",
"notifyPrototype","waitingForPrototype","client","waitPrototype","registerWhenRe
ady","prototypesByName","instanceOfType","ctor","consumeDeclarations","declarati
ons","resolveElementPaths","addResolvePathApi","assetPath","resolvePath","import
RuleForSheet","sheet","createStyleElement","firstElementChild","s$","nextElement
Sibling","cssTextFromSheet","__resource","matchesSelector","inSelector","STYLE_S
ELECTOR","STYLE_LOADABLE_MATCH","SHEET_SELECTOR","STYLE_GLOBAL_SCOPE","SCOPE_ATT
R","templateContent","convertSheetsToStyles","findLoadableStyles","templateUrl",
"copySheetAttributes","replaceChild","loadables","installSheets","cacheSheets","
cacheStyles","installLocalSheets","installGlobalStyles","sheets","findNodes","ma
tcher","templateNodes","styleForScope","scopeDescriptor","webkitMatchesSelector"
,"mozMatchesSelector","mixedCaseEventTypes","parseHostEvents","delegates","addAt
tributeDelegates","hasEventPrefix","removeEventPrefix","prefixLength","findContr
oller","controller","prepareEventBinding","bindingValue","inferObservers","explo
deObservers","exploded","ni","names","optimizePropertyMaps","_publishNames","pub
lishProperties","requireProperties","lowerCaseMap","propertyInfos","createProper
tyAccessor","ignoreWrites","createPropertyAccessors","ATTRIBUTES_ATTRIBUTE","ATT
RIBUTES_REGEX","inheritAttributesObjects","inheritObject","publishAttributes","a
ccumulateInstanceAttributes","clonable","isInstanceAttribute","blackList","exten
ds","noscript","assetpath","cache-csstext","installBindingDelegate","ensureProto
typeTraversal","ancestor","extendeeName","buildPrototype","publishConstructor","
extension","generateBasePrototype","desugarBeforeChaining","chainPrototypes","de
sugarAfterChaining","inheritMetaData","chained","chainObject","extendee","shimSt
yling","registerCallback","symbol","extnds","findBasePrototype","ensureBaseApi",
"memoizedBases","extended","mixinMethod","info","typeExtension","findTypeExtensi
on","registerElement","inherited","queueForElement","mainQueue","importQueue","n
extQueued","queue","waitToReady","addReadyCallback","check","forceReady","__queu
e","enqueue","shouldAdd","readied","flushable","addToFlushQueue","nextElement","
canReady","isEmpty","flushQueue","polyfillWasReady","upgradeDocumentTree","flush
ReadyCallbacks","readyCallbacks","waitingFor","e$","whenPolymerReady","isRegiste
red","isCustomTag","init","loadResources","registered","waitingForQueue","waitin
gForResources","_register","handleNoScript","_needsResources","body","importElem
ents","elementOrFragment","importUrls","urls","frag","makeSyntax"],"mappings":";
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
AO9f,KAAKjB,KAAK,IAE9BiB,KAAKjB,KAAK2jB,aAAa5C,EAAO2C,KAqBzC7D,EAAiB9X,WACf6b,GA
AIC,YACF,IAAK5iB,KAAK6iB,UAAW,CAEnB,GAAIC,GAAQ9iB,KAAK2gB,iBAAkB/B,GAC/B5e,KAAK2
gB,OAAOiC,SAAS9K,SAAW9X,KAAK2gB,OAAO5X,KAChD+Z;EAAMriB,KAAKT,KAAKkc,mBAAoBuE,GAC
hCzgB,KAAKkc,SAASnT,KAAO/I,KAAKkc,SAASrK,OACvC7R,KAAK6iB,UAAYnC,KAAKpZ,IAAIwb,GA
G5B,MAAO9iB,MAAK6iB,WAGdzB,QAAS,WACP,IAAKphB,KAAKwgB,SAAU,CAClB,GAAIG,GAAS3gB,KA
AK2gB,MAElB,IAAI3gB,KAAK+gB,WAAY,CACnB,GAAIhiB,GAAOiB,KAAK4iB,QAEhB5iB,MAAKwgB,S
AAW,SAASV,EAAOuC,GAI9B,MAHIA,IACFA,EAASC,QAAQxC,EAAO/gB,GAEnBA,EAAKwjB,aAAazC,QA
EtB,IAAK9f,KAAK6gB,SAWV,CAEL,GAAI3E,GAAWlc,KAAKkc,QAEpBlc,MAAKwgB,SAAW,SAASV,EAA
OuC,EAAU9C,GACxC,GAAIwD,GAAUpC,EAAOb,EAAOuC,EAAU9C,GAClCyD,EAAW9G,EAAS4D,EAAOuC,
EAAU9C,EAIzC,OAHI8C,IACFA,EAASC,QAAQS,GAAUC,IAEtBD,EAAUA,EAAQC,GAAYtP,YArBd,CACz
B,GAAI3U,GAAO2hB,KAAKpZ,IAAItH,KAAKkc,SAASnT,KAElC/I,MAAKwgB,SAAW,SAASV,EAAOuC,E
AAU9C,GACxC,GAAIwD,GAAUpC,EAAOb,EAAOuC,EAAU9C,EAKtC,OAHI8C,IACFA,EAASC,QAAQS,EAA
ShkB,GAErBA,EAAKwjB,aAAaQ,KAgB/B,MAAO/iB,MAAKwgB,UAGdgC,SAAU,SAAS1C,EAAO2C,GACxB
,GAAIziB,KAAK+gB,WAEP,MADA/gB,MAAK4iB,SAASF,aAAa5C,EAAO2C,GAC3BA,CAGT,IAAI9B,GAA
S3gB,KAAK2gB,OAAOb,GACrBkD,EAAWhjB,KAAKkc,mBAAoBuE,GAAYzgB,KAAKkc,SAASnT,KAC9D/I
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
AAaA,EAClBxf,KAAK0f,WAAaA,EAClB1f,KAAKmgB,WAAaA,GAGpBzC,eAAgB,SAAS8B,GACvBxf,KAA
Kwf,WAAaA,GAGpB5D,qBAAsBsF,GAOxBM,EAAmB1a,WACjBke,KAAM,WAAa,MAAOhlB,MAAKyhB,QAC/
BwD,eAAgB,WAAa,MAAOjlB,MAAKyhB,QACzCyD,QAAS,aACTC,MAAO,cAiBT5E,EAAWzZ,WACTmZ,WAA
Y,SAASH,EAAOP,EAAgBQ,GAU1C,QAASqB,KAEP,GAAIgE,EAEF,MADAA,IAAY,EACLC,CAGLxU,GAAKi
Q,aACPuB,EAASiD,YAEX,IAAIzT,GAAQhB,EAAK0U,SAASzF,EACAjP,EAAKiQ,YAAcuB,EAAW3O,OAC
9B6L,EAI1B,OAHI1O,GAAKiQ,aACPuB,EAASmD,cAEJ3T,EAGT,QAAS4T,GAAWhD,GAElB,MADA5R,GA
AK2R,SAAS1C,EAAO2C,EAAUlD,GACxBkD,EA9BT,GAAI1C,EACF,MAAO/f,MAAKulB,SAASzF,EAAOpM
,OAAW6L,EAEzC,IAAI8C,GAAW,GAAIqD,kBAEfL,EAAarlB,KAAKulB,SAASzF,EAAOuC,EAAU9C,GAC
5C6F,GAAY,EACZvU,EAAO7Q,IA0BX,OAAO,IAAI2lB,mBAAkBtD,EAAUjB,EAASqE,GAAY,IAG9DF,SA
AU,SAASzF,EAAOuC,EAAU9C,GAElC,IAAK,GADD1N,GAAQmP,EAAMhhB,KAAKwf,YAAYM,EAAOuC,EAA
U9C,GAC3C5d,EAAI,EAAGA,EAAI3B,KAAKqhB,QAAQ/f,OAAQK,IACvCkQ,EAAQ7R,KAAKqhB,QAAQ1f
,GAAGshB,UAAUnD,EAAOuC,EAAU9C,GAC/C,GAAQ1N,GAGd,OAAOA,IAGT2Q,SAAU,SAAS1C,EAAO2C,
EAAUlD,GAElC,IADA,GAAIqG,GAAQ5lB,KAAKqhB,QAAUrhB,KAAKqhB,QAAQ/f,OAAS,EAC1CskB,IA
AU,GACfnD,EAAWziB,KAAKqhB,QAAQuE,GAAO3C,UAAUnD,EAAOpM,OAC5C6L,GAAgB,GAAOkD,GAG7B
,OAAIziB,MAAKwf,WAAWgD,SACXxiB,KAAKwf,WAAWgD,SAAS1C,EAAO2C,GADzC,QAeJ,IAAIX,GAAk
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
AC5B,IAAK,GAAwB1jB,GAApB9E,EAAE,EAAGgI,EAAEwgB,EAAK7oB,OAAgBqI,EAAJhI,IAAW8E,EAA
E0jB,EAAKxoB,IAAKA,IAClD8E,EAAE2jB,YACJhB,EAAc3iB,EAAE2jB,cAGnBC,QAAQ9rB,SAASY,M
AAOmrB,WAAW,IA0BtC,WACE,GAA4B,YAAxB/rB,SAAS6pB,WAEX,IAAK,GAA2BW,GAD5BF,EAAUtqB,S
AASuqB,iBAAiB,oBAC/BnnB,EAAE,EAAGgI,EAAEkf,EAAQvnB,OAAgBqI,EAAFhI,IAASonB,EAAIF,
EAAQlnB,IAAKA,IAC9D2nB,EAAaP,OAWrBjB,EAAU,WACRH,YAAYJ,OAAQ,EACpBI,YAAY4C,WAAY,GA
AI1U,OAAO2U,UACnCxC,EAAa5oB,cACX,GAAIH,aAAY,qBAAsBC,SAAS,OAKnDd,EAAMkpB,UAAYA,EA
ClBlpB,EAAM4qB,eAAiBA,EACvB5qB,EAAM0pB,UAAYA,EAClB1pB,EAAM4pB,aAAeA,EACrB5pB,EAA
MqrB,iBAAmBA,EACzBrrB,EAAMurB,KAAOA,GAEVzrB,OAAOypB,aAUV,SAAUvpB,GAER,QAASqsB,GA
AiBC,EAAMC,GAK9B,MAJAA,GAAUA,MACLA,EAAQpmB,MACXomB,GAAWA,IAEND,EAAKpH,MAAMtjB,KA
AM2qB,EAAQpmB,IAAIqmB,IAGtC,QAASC,GAAO9hB,EAAM+hB,EAAkBC,GACtC,GAAIF,EACJ,QAAQ1Q
,UAAU7Y,QAChB,IAAK,GACH,MACF,KAAK,GACHupB,EAAS,IACT,MACF,KAAK,GAEHA,EAASC,EAAiBx
H,MAAMtjB,KAChC,MACF,SAEE6qB,EAASJ,EAAiBM,EAAeD,GAG7CE,EAAQjiB,GAAQ8hB,EAGlB,QAA
SD,GAAQ7hB,GACf,MAAOiiB,GAAQjiB,GAKjB,QAASkiB,GAAMN,EAASD,GACtB/C,YAAYuD,iBAAiB,
WAC3BT,EAAiBC,EAAMC,KAJ3B,GAAIK,KAUJ5sB,GAAMwsB,QAAUA,EAEhBxsB,EAAM+sB,WAAaN,EAC
nBzsB,EAAM6sB,MAAQA,GAEb/sB,QAWH,WAQE,GAAI8F,GAAQzF,SAASC,cAAc,QACnCwF,GAAMS,YAA
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
skB,IAAU,GAAG,CAClB,GAAIga,GAASF,EAAQ9Z,EACjBia,GAA4BD,EAAO72B,QACjB,aAAhB62B,EA
AO72B,MACTqd,EAAS5Z,aAAaozB,EAAO72B,KAAM62B,EAAO/tB,OAC5CrN,EAAGu2B,gBAAgB6E,EAA
O72B,OAI9B,MAAOqd,GAGT,QAAS0Z,GAA+Bt7B,GACtC,GAAI4hB,GAAW5hB,EAAGs6B,cAActgC,cAA
c,WAC9CgG,GAAGnF,WAAW+rB,aAAahF,EAAU5hB,EAIrC,KAFA,GAAIk7B,GAAUl7B,EAAGm7B,WACb/
Z,EAAQ8Z,EAAQp+B,OACbskB,IAAU,GAAG,CAClB,GAAIga,GAASF,EAAQ9Z,EACrBQ,GAAS5Z,aAAao
zB,EAAO72B,KAAM62B,EAAO/tB,OAC1CrN,EAAGu2B,gBAAgB6E,EAAO72B,MAI5B,MADAvE,GAAGnF,
WAAWC,YAAYkF,GACnB4hB,EAGT,QAAS2Z,GAAyC3Z,EAAU5hB,EAAIw7B,GAC9D,GAAIvB,GAAUrY,EA
ASqY,OACvB,IAAIuB,EAEF,WADAvB,GAAQ7/B,YAAY4F,EAKtB,KADA,GAAIy7B,GACGA,EAAQz7B,EA
AG6mB,YAChBoT,EAAQ7/B,YAAYqhC,GA4FxB,QAASC,GAA4B17B,GAC/B27B,EACF37B,EAAGoiB,UAA
Y2X,oBAAoBz3B,UAEnC43B,EAAMl6B,EAAI+5B,oBAAoBz3B,WAGlC,QAASs5B,GAAwBha,GAC1BA,EA
ASia,cACZja,EAASia,YAAc,WACrBja,EAASka,sBAAuB,CAChC;GAAI/7B,GAAMg8B,EAAYna,EAClB
A,EAASoa,WAAapa,EAASoa,UAAUnhB,eAC7CohB,GAAgBra,EAAU7hB,EAAK6hB,EAASsa,UAIvCta,E
AASka,uBACZla,EAASka,sBAAuB,EAChChQ,SAAS0J,QAAQ5T,EAASia,cAyM9B,QAASM,GAAehiC,EA
AGoK,EAAMlG,EAAM+9B,GACrC,GAAKjiC,GAAMA,EAAE2C,OAAb,CAOA,IAJA,GAAI4kB,GACA5kB,EA
AS3C,EAAE2C,OACXu/B,EAAa,EAAGC,EAAY,EAAGC,EAAW,EAC1CC,GAAc,EACC1/B,EAAZw/B,GAAoB
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
gBqI,EAAJhI,IAAWhD,EAAImF,EAAOnC,IAAKA,IAChE3B,KAAK2rC,aAAahtC,EAAGyrC,IAI3BuB,a
AAc,SAAS3nC,EAAOomC,GAC5BA,EAAMA,GAAOpmC,EAAM86B,cAAcU,QACjCx7B,EAAMS,YAAczE,KAA
K4rC,eAAe5nC,EAAMS,YAAa2lC,IAE7DwB,eAAgB,SAAS7B,EAASC,EAASC,GAEzC,MADAF,GAAUD,EA
AqBC,EAASC,EAASC,EAAc4B,GACxD/B,EAAqBC,EAASC,EAASC,EAAc6B,IAE9DP,kBAAmB,SAASb,EA
AMN,GAC5BM,EAAKqB,eAAiBrB,EAAKqB,iBAC7B/rC,KAAKgsC,yBAAyBtB,EAAMN,EAGtC,IAAI1/B,
GAAQggC,GAAQA,EAAK5hB,iBAAiBmjB,EAC1C,IAAIvhC,EACF,IAAK,GAA6BhJ,GAAzBC,EAAI,EAAG
gI,EAAIe,EAAMpJ,OAAgBqI,EAAJhI,IAAWD,EAAIgJ,EAAM/I,IAAKA,IAC9D3B,KAAKgsC,yBAAyBt
qC,EAAG0oC,IAIvC4B,yBAA0B,SAASnpC,EAAMunC,GACvCA,EAAMA,GAAOvnC,EAAKi8B,cAAcU,QAC
hC0M,EAAU9nC,QAAQ,SAASX,GACzB,GAEI0oC,GAFAnK,EAAOn/B,EAAK88B,WAAWl8B,GACvBoO,EAA
QmwB,GAAQA,EAAKnwB,KAErBA,IAASA,EAAMs5B,OAAOiB,GAAuB,IAE7CD,EADQ,UAAN1oC,EACYqmC
,EAAqBj4B,EAAOu4B,GAAK,EAAOyB,GAExCtB,EAAmBH,EAAKv4B,GAExCmwB,EAAKnwB,MAAQs6B,OA
MjBN,EAAiB,sBACjBC,EAAoB,qCACpBI,GAAa,OAAQ,MAAO,SAAU,QAAS,OAC/CD,EAAqB,IAAMC,EAA
UlmB,KAAK,OAAS,IACnDomB,EAAsB,QA+C1BhuC,GAAMitC,YAAcA,GAEjBrkB,SAWH,SAAU5oB,GAIR
,QAASiuC,GAAOC,GACdtsC,KAAKusC,MAAQhnC,OAAOC,OAAO,MAC3BxF,KAAKuE,IAAMgB,OAAOC,OA
AO,MACzBxF,KAAKwsC,SAAW,EAChBxsC,KAAKssC,MAAQA,EAPf,GAAI1D,GAAiB1hB,SAAS0hB,cAS9
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","s
ourcesContent":["/**\n * @license\n * Copyright (c) 2014 The Polymer Project Aut
hors. All rights reserved.\n * This code may only be used under the BSD style li
cense found at http://polymer.github.io/LICENSE.txt\n * The complete set of auth
ors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of
contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code
distributed by Google as part of the polymer project is also\n * subject to an
additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\nw
indow.PolymerGestures = {};\n\n/*\n * Copyright (c) 2014 The Polymer Project Aut
hors. All rights reserved.\n * This code may only be used under the BSD style li
cense found at http://polymer.github.io/LICENSE.txt\n * The complete set of auth
ors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of
contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code
distributed by Google as part of the polymer project is also\n * subject to an
additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\
n(function(scope) {\n var HAS_FULL_PATH = false;\n\n // test for full event pa
th support\n var pathTest = document.createElement('meta');\n if (pathTest.cre
ateShadowRoot) {\n var sr = pathTest.createShadowRoot();\n var s = documen
t.createElement('span');\n sr.appendChild(s);\n pathTest.addEventListener(
'testpath', function(ev) {\n if (ev.path) {\n // if the span is in t
he event path, then path[0] is the real source for all events\n HAS_FULL_
PATH = ev.path[0] === s;\n }\n ev.stopPropagation();\n });\n var
ev = new CustomEvent('testpath', {bubbles: true});\n // must add node to DOM
to trigger event listener\n document.head.appendChild(pathTest);\n s.disp
atchEvent(ev);\n pathTest.parentNode.removeChild(pathTest);\n sr = s = nul
l;\n }\n pathTest = null;\n\n var target = {\n shadow: function(inEl) {\n
if (inEl) {\n return inEl.shadowRoot || inEl.webkitShadowRoot;\n
}\n },\n canTarget: function(shadow) {\n return shadow && Boolean(s
hadow.elementFromPoint);\n },\n targetingShadow: function(inEl) {\n v
ar s = this.shadow(inEl);\n if (this.canTarget(s)) {\n return s;\n
}\n },\n olderShadow: function(shadow) {\n var os = shadow.olderS
hadowRoot;\n if (!os) {\n var se = shadow.querySelector('shadow');\n
if (se) {\n os = se.olderShadowRoot;\n }\n }\n
return os;\n },\n allShadows: function(element) {\n var shadows = []
, s = this.shadow(element);\n while(s) {\n shadows.push(s);\n
s = this.olderShadow(s);\n }\n return shadows;\n },\n searchRoo
t: function(inRoot, x, y) {\n var t, st, sr, os;\n if (inRoot) {\n
t = inRoot.elementFromPoint(x, y);\n if (t) {\n // found ele
ment, check if it has a ShadowRoot\n sr = this.targetingShadow(t);\n
} else if (inRoot !== document) {\n // check for sibling roots\n
sr = this.olderShadow(inRoot);\n }\n // search other roots
, fall back to light dom element\n return this.searchRoot(sr, x, y) || t;
\n }\n },\n owner: function(element) {\n if (!element) {\n
return document;\n }\n var s = element;\n // walk up until you
hit the shadow root or document\n while (s.parentNode) {\n s = s.par
entNode;\n }\n // the owner element is expected to be a Document or Sh
adowRoot\n if (s.nodeType != Node.DOCUMENT_NODE && s.nodeType != Node.DOCUM
ENT_FRAGMENT_NODE) {\n s = document;\n }\n return s;\n },\n
findTarget: function(inEvent) {\n if (HAS_FULL_PATH && inEvent.path && i
nEvent.path.length) {\n return inEvent.path[0];\n }\n var x = i
nEvent.clientX, y = inEvent.clientY;\n // if the listener is in the shadow
root, it is much faster to start there\n var s = this.owner(inEvent.target)
;\n // if x, y is not in this root, fall back to document search\n if
(!s.elementFromPoint(x, y)) {\n s = document;\n }\n return this
.searchRoot(s, x, y);\n },\n findTouchAction: function(inEvent) {\n v
ar n;\n if (HAS_FULL_PATH && inEvent.path && inEvent.path.length) {\n
var path = inEvent.path;\n for (var i = 0; i < path.length; i++) {\n
n = path[i];\n if (n.nodeType === Node.ELEMENT_NODE && n.hasAttr
ibute('touch-action')) {\n return n.getAttribute('touch-action');\n
}\n }\n } else {\n n = inEvent.target;\n while
(n) {\n if (n.nodeType === Node.ELEMENT_NODE && n.hasAttribute('touch-a
ction')) {\n return n.getAttribute('touch-action');\n }\n
n = n.parentNode || n.host;\n }\n }\n // auto is default
\n return \"auto\";\n },\n LCA: function(a, b) {\n if (a === b)
{\n return a;\n }\n if (a && !b) {\n return a;\n }\
n if (b && !a) {\n return b;\n }\n if (!b && !a) {\n
return document;\n }\n // fast case, a is a direct descendant of b o
r vice versa\n if (a.contains && a.contains(b)) {\n return a;\n
}\n if (b.contains && b.contains(a)) {\n return b;\n }\n
var adepth = this.depth(a);\n var bdepth = this.depth(b);\n var d = ad
epth - bdepth;\n if (d >= 0) {\n a = this.walk(a, d);\n } else
{\n b = this.walk(b, -d);\n }\n while (a && b && a !== b) {\n
a = a.parentNode || a.host;\n b = b.parentNode || b.host;\n }\
n return a;\n },\n walk: function(n, u) {\n for (var i = 0; n &&
(i < u); i++) {\n n = n.parentNode || n.host;\n }\n return n;\
n },\n depth: function(n) {\n var d = 0;\n while(n) {\n d
++;\n n = n.parentNode || n.host;\n }\n return d;\n },\n
deepContains: function(a, b) {\n var common = this.LCA(a, b);\n // if
a is the common ancestor, it must \"deeply\" contain b\n return common ===
a;\n },\n insideNode: function(node, x, y) {\n var rect = node.getBou
ndingClientRect();\n return (rect.left <= x) && (x <= rect.right) && (rect.
top <= y) && (y <= rect.bottom);\n },\n path: function(event) {\n var
p;\n if (HAS_FULL_PATH && event.path && event.path.length) {\n p =
event.path;\n } else {\n p = [];\n var n = this.findTarget(ev
ent);\n while (n) {\n p.push(n);\n n = n.parentNode ||
n.host;\n }\n }\n return p;\n }\n };\n scope.targetFinding
= target;\n /**\n * Given an event, finds the \"deepest\" node that could ha
ve been the original target before ShadowDOM retargetting\n *\n * @param {Ev
ent} Event An event object with clientX and clientY properties\n * @return {El
ement} The probable event origninator\n */\n scope.findTarget = target.findTa
rget.bind(target);\n /**\n * Determines if the \"container\" node deeply cont
ains the \"containee\" node, including situations where the \"containee\" is con
tained by one or more ShadowDOM\n * roots.\n *\n * @param {Node} container
\n * @param {Node} containee\n * @return {Boolean}\n */\n scope.deepConta
ins = target.deepContains.bind(target);\n\n /**\n * Determines if the x/y pos
ition is inside the given node.\n *\n * Example:\n *\n * function up
Handler(event) {\n * var innode = PolymerGestures.insideNode(event.targe
t, event.clientX, event.clientY);\n * if (innode) {\n * // wai
t for tap?\n * } else {\n * // tap will never happen\n *
}\n * }\n *\n * @param {Node} node\n * @param {Number} x Screen X
position\n * @param {Number} y screen Y position\n * @return {Boolean}\n
*/\n scope.insideNode = target.insideNode;\n\n})(window.PolymerGestures);\n\n/*
\n *\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n
* This code may only be used under the BSD style license found at http://polymer
.github.io/LICENSE.txt\n * The complete set of authors may be found at http://po
lymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at
http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as par
t of the polymer project is also\n * subject to an additional IP rights grant fo
und at http://polymer.github.io/PATENTS.txt\n */\n\n(function() {\n function sh
adowSelector(v) {\n return 'html /deep/ ' + selector(v);\n }\n function sel
ector(v) {\n return '[touch-action=\"' + v + '\"]';\n }\n function rule(v)
{\n return '{ -ms-touch-action: ' + v + '; touch-action: ' + v + ';}';\n }\n
var attrib2css = [\n 'none',\n 'auto',\n 'pan-x',\n 'pan-y',\n
{\n rule: 'pan-x pan-y',\n selectors: [\n 'pan-x pan-y',\n
'pan-y pan-x'\n ]\n },\n 'manipulation'\n ];\n var styles = '';\
n // only install stylesheet if the browser has touch action support\n var has
TouchAction = typeof document.head.style.touchAction === 'string';\n // only ad
d shadow selectors if shadowdom is supported\n var hasShadowRoot = !window.Shad
owDOMPolyfill && document.head.createShadowRoot;\n\n if (hasTouchAction) {\n
attrib2css.forEach(function(r) {\n if (String(r) === r) {\n styles
+= selector(r) + rule(r) + '\\n';\n if (hasShadowRoot) {\n style
s += shadowSelector(r) + rule(r) + '\\n';\n }\n } else {\n st
yles += r.selectors.map(selector) + rule(r.rule) + '\\n';\n if (hasShadow
Root) {\n styles += r.selectors.map(shadowSelector) + rule(r.rule) + '\
\n';\n }\n }\n });\n\n var el = document.createElement('style'
);\n el.textContent = styles;\n document.head.appendChild(el);\n }\n})();
\n\n/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\
n * This code may only be used under the BSD style license found at http://polym
er.github.io/LICENSE.txt\n * The complete set of authors may be found at http://
polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found
at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as p
art of the polymer project is also\n * subject to an additional IP rights grant
found at http://polymer.github.io/PATENTS.txt\n */\n\n/**\n * This is the constr
uctor for new PointerEvents.\n *\n * New Pointer Events must be given a type, an
d an optional dictionary of\n * initialization properties.\n *\n * Due to certai
n platform requirements, events returned from the constructor\n * identify as Mo
useEvents.\n *\n * @constructor\n * @param {String} inType The type of the event
to create.\n * @param {Object} [inDict] An optional dictionary of initial event
properties.\n * @return {Event} A new PointerEvent of type `inType` and initial
ized with properties from `inDict`.\n */\n(function(scope) {\n\n var MOUSE_PROP
S = [\n 'bubbles',\n 'cancelable',\n 'view',\n 'detail',\n 'scree
nX',\n 'screenY',\n 'clientX',\n 'clientY',\n 'ctrlKey',\n 'altKe
y',\n 'shiftKey',\n 'metaKey',\n 'button',\n 'relatedTarget',\n '
pageX',\n 'pageY'\n ];\n\n var MOUSE_DEFAULTS = [\n false,\n false,\n
null,\n null,\n 0,\n 0,\n 0,\n 0,\n false,\n false,\n
false,\n false,\n 0,\n null,\n 0,\n 0\n ];\n\n var NOP_FACTOR
Y = function(){ return function(){}; };\n\n var eventFactory = {\n // TODO(d
freedm): this is overridden by tap recognizer, needs review\n preventTap: NOP
_FACTORY,\n makeBaseEvent: function(inType, inDict) {\n var e = document
.createEvent('Event');\n e.initEvent(inType, inDict.bubbles || false, inDic
t.cancelable || false);\n e.preventTap = eventFactory.preventTap(e);\n
return e;\n },\n makeGestureEvent: function(inType, inDict) {\n inDi
ct = inDict || Object.create(null);\n\n var e = this.makeBaseEvent(inType,
inDict);\n for (var i = 0, keys = Object.keys(inDict), k; i < keys.length;
i++) {\n k = keys[i];\n e[k] = inDict[k];\n }\n return e
;\n },\n makePointerEvent: function(inType, inDict) {\n inDict = inDi
ct || Object.create(null);\n\n var e = this.makeBaseEvent(inType, inDict);\
n // define inherited MouseEvent properties\n for(var i = 0, p; i < MO
USE_PROPS.length; i++) {\n p = MOUSE_PROPS[i];\n e[p] = inDict[p]
|| MOUSE_DEFAULTS[i];\n }\n e.buttons = inDict.buttons || 0;\n\n
// Spec requires that pointers without pressure specified use 0.5 for down\n
// state and 0 for up state.\n var pressure = 0;\n if (inDict.pressu
re) {\n pressure = inDict.pressure;\n } else {\n pressure = e
.buttons ? 0.5 : 0;\n }\n\n // add x/y properties aliased to clientX/Y
\n e.x = e.clientX;\n e.y = e.clientY;\n\n // define the properti
es of the PointerEvent interface\n e.pointerId = inDict.pointerId || 0;\n
e.width = inDict.width || 0;\n e.height = inDict.height || 0;\n e.
pressure = pressure;\n e.tiltX = inDict.tiltX || 0;\n e.tiltY = inDict
.tiltY || 0;\n e.pointerType = inDict.pointerType || '';\n e.hwTimesta
mp = inDict.hwTimestamp || 0;\n e.isPrimary = inDict.isPrimary || false;\n
e._source = inDict._source || '';\n return e;\n }\n };\n\n scope.
eventFactory = eventFactory;\n})(window.PolymerGestures);\n\n/*\n * Copyright (c
) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only
be used under the BSD style license found at http://polymer.github.io/LICENSE.tx
t\n * The complete set of authors may be found at http://polymer.github.io/AUTHO
RS.txt\n * The complete set of contributors may be found at http://polymer.githu
b.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer proj
ect is also\n * subject to an additional IP rights grant found at http://polymer
.github.io/PATENTS.txt\n */\n\n/**\n * This module implements an map of pointer
states\n */\n(function(scope) {\n var USE_MAP = window.Map && window.Map.protot
ype.forEach;\n var POINTERS_FN = function(){ return this.size; };\n function P
ointerMap() {\n if (USE_MAP) {\n var m = new Map();\n m.pointers =
POINTERS_FN;\n return m;\n } else {\n this.keys = [];\n this.v
alues = [];\n }\n }\n\n PointerMap.prototype = {\n set: function(inId, i
nEvent) {\n var i = this.keys.indexOf(inId);\n if (i > -1) {\n
this.values[i] = inEvent;\n } else {\n this.keys.push(inId);\n
this.values.push(inEvent);\n }\n },\n has: function(inId) {\n
return this.keys.indexOf(inId) > -1;\n },\n 'delete': function(inId) {\n
var i = this.keys.indexOf(inId);\n if (i > -1) {\n this.keys.spl
ice(i, 1);\n this.values.splice(i, 1);\n }\n },\n get: functio
n(inId) {\n var i = this.keys.indexOf(inId);\n return this.values[i];\
n },\n clear: function() {\n this.keys.length = 0;\n this.values
.length = 0;\n },\n // return value, key, map\n forEach: function(callb
ack, thisArg) {\n this.values.forEach(function(v, i) {\n callback.ca
ll(thisArg, v, this.keys[i], this);\n }, this);\n },\n pointers: func
tion() {\n return this.keys.length;\n }\n };\n\n scope.PointerMap = Po
interMap;\n})(window.PolymerGestures);\n\n/*\n * Copyright (c) 2014 The Polymer
Project Authors. All rights reserved.\n * This code may only be used under the B
SD style license found at http://polymer.github.io/LICENSE.txt\n * The complete
set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The comp
lete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.t
xt\n * Code distributed by Google as part of the polymer project is also\n * sub
ject to an additional IP rights grant found at http://polymer.github.io/PATENTS.
txt\n */\n\n(function(scope) {\n var CLONE_PROPS = [\n // MouseEvent\n 'b
ubbles',\n 'cancelable',\n 'view',\n 'detail',\n 'screenX',\n 'sc
reenY',\n 'clientX',\n 'clientY',\n 'ctrlKey',\n 'altKey',\n 'shi
ftKey',\n 'metaKey',\n 'button',\n 'relatedTarget',\n // DOM Level 3
\n 'buttons',\n // PointerEvent\n 'pointerId',\n 'width',\n 'heig
ht',\n 'pressure',\n 'tiltX',\n 'tiltY',\n 'pointerType',\n 'hwTi
mestamp',\n 'isPrimary',\n // event instance\n 'type',\n 'target',\n
'currentTarget',\n 'which',\n 'pageX',\n 'pageY',\n 'timeStamp',
\n // gesture addons\n 'preventTap',\n 'tapPrevented',\n '_source'\n
];\n\n var CLONE_DEFAULTS = [\n // MouseEvent\n false,\n false,\n
null,\n null,\n 0,\n 0,\n 0,\n 0,\n false,\n false,\n f
alse,\n false,\n 0,\n null,\n // DOM Level 3\n 0,\n // Pointer
Event\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n '',\n 0,\n fals
e,\n // event instance\n '',\n null,\n null,\n 0,\n 0,\n 0,
\n 0,\n function(){},\n false\n ];\n\n var HAS_SVG_INSTANCE = (typeof
SVGElementInstance !== 'undefined');\n\n var eventFactory = scope.eventFactory
;\n\n // set of recognizers to run for the currently handled event\n var curre
ntGestures;\n\n /**\n * This module is for normalizing events. Mouse and Touc
h events will be\n * collected here, and fire PointerEvents that have the same
semantics, no\n * matter the source.\n * Events fired:\n * - pointerdow
n: a pointing is added\n * - pointerup: a pointer is removed\n * - point
ermove: a pointer is moved\n * - pointerover: a pointer crosses into an elem
ent\n * - pointerout: a pointer leaves an element\n * - pointercancel: a
pointer will no longer generate events\n */\n var dispatcher = {\n IS_IOS
: false,\n pointermap: new scope.PointerMap(),\n requiredGestures: new sco
pe.PointerMap(),\n eventMap: Object.create(null),\n // Scope objects for n
ative events.\n // This exists for ease of testing.\n eventSources: Object
.create(null),\n eventSourceList: [],\n gestures: [],\n // map gesture
event -> {listeners: int, index: gestures[int]}\n dependencyMap: {\n //
make sure down and up are in the map to trigger \"register\"\n down: {liste
ners: 0, index: -1},\n up: {listeners: 0, index: -1}\n },\n gestureQu
eue: [],\n /**\n * Add a new event source that will generate pointer even
ts.\n *\n * `inSource` must contain an array of event names named `event
s`, and\n * functions with the names specified in the `events` array.\n
* @param {string} name A name for the event source\n * @param {Object} sourc
e A new source of platform events.\n */\n registerSource: function(name,
source) {\n var s = source;\n var newEvents = s.events;\n if (new
Events) {\n newEvents.forEach(function(e) {\n if (s[e]) {\n
this.eventMap[e] = s[e].bind(s);\n }\n }, this);\n
this.eventSources[name] = s;\n this.eventSourceList.push(s);\n }\n
},\n registerGesture: function(name, source) {\n var obj = Object.cre
ate(null);\n obj.listeners = 0;\n obj.index = this.gestures.length;\n
for (var i = 0, g; i < source.exposes.length; i++) {\n g = source.ex
poses[i].toLowerCase();\n this.dependencyMap[g] = obj;\n }\n th
is.gestures.push(source);\n },\n register: function(element, initial) {\n
var l = this.eventSourceList.length;\n for (var i = 0, es; (i < l) &&
(es = this.eventSourceList[i]); i++) {\n // call eventsource register\n
es.register.call(es, element, initial);\n }\n },\n unregister:
function(element) {\n var l = this.eventSourceList.length;\n for (var
i = 0, es; (i < l) && (es = this.eventSourceList[i]); i++) {\n // call ev
entsource register\n es.unregister.call(es, element);\n }\n },\n
// EVENTS\n down: function(inEvent) {\n this.requiredGestures.set(inE
vent.pointerId, currentGestures);\n this.fireEvent('down', inEvent);\n }
,\n move: function(inEvent) {\n // pipe move events into gesture queue d
irectly\n inEvent.type = 'move';\n this.fillGestureQueue(inEvent);\n
},\n up: function(inEvent) {\n this.fireEvent('up', inEvent);\n t
his.requiredGestures.delete(inEvent.pointerId);\n },\n cancel: function(in
Event) {\n inEvent.tapPrevented = true;\n this.fireEvent('up', inEvent
);\n this.requiredGestures.delete(inEvent.pointerId);\n },\n addGestu
reDependency: function(node, currentGestures) {\n var gesturesWanted = node
._pgEvents;\n if (gesturesWanted) {\n var gk = Object.keys(gesturesW
anted);\n for (var i = 0, r, ri, g; i < gk.length; i++) {\n // g
esture\n g = gk[i];\n if (gesturesWanted[g] > 0) {\n
// lookup gesture recognizer\n r = this.dependencyMap[g];\n
// recognizer index\n ri = r ? r.index : -1;\n current
Gestures[ri] = true;\n }\n }\n }\n },\n // LISTENER L
OGIC\n eventHandler: function(inEvent) {\n // This is used to prevent mu
ltiple dispatch of events from\n // platform events. This can happen when t
wo elements in different scopes\n // are set up to create pointer events, w
hich is relevant to Shadow DOM.\n\n var type = inEvent.type;\n\n // on
ly generate the list of desired events on \"down\"\n if (type === 'touchsta
rt' || type === 'mousedown' || type === 'pointerdown' || type === 'MSPointerDown
') {\n if (!inEvent._handledByPG) {\n currentGestures = {};\n
}\n // in IOS mode, there is only a listener on the document, so thi
s is not re-entrant\n if (this.IS_IOS) {\n var nodes = scope.tar
getFinding.path(inEvent);\n for (var i = 0, n; i < nodes.length; i++) {
\n n = nodes[i];\n this.addGestureDependency(n, currentGes
tures);\n }\n } else {\n this.addGestureDependency(inEv
ent.currentTarget, currentGestures);\n }\n }\n\n if (inEvent._h
andledByPG) {\n return;\n }\n var fn = this.eventMap && this.ev
entMap[type];\n if (fn) {\n fn(inEvent);\n }\n inEvent._ha
ndledByPG = true;\n },\n // set up event listeners\n listen: function(t
arget, events) {\n for (var i = 0, l = events.length, e; (i < l) && (e = ev
ents[i]); i++) {\n this.addEvent(target, e);\n }\n },\n // rem
ove event listeners\n unlisten: function(target, events) {\n for (var i
= 0, l = events.length, e; (i < l) && (e = events[i]); i++) {\n this.remo
veEvent(target, e);\n }\n },\n addEvent: function(target, eventName)
{\n target.addEventListener(eventName, this.boundHandler);\n },\n rem
oveEvent: function(target, eventName) {\n target.removeEventListener(eventN
ame, this.boundHandler);\n },\n // EVENT CREATION AND TRACKING\n /**\n
* Creates a new Event of type `inType`, based on the information in\n *
`inEvent`.\n *\n * @param {string} inType A string representing the type
of event to create\n * @param {Event} inEvent A platform event with a targe
t\n * @return {Event} A PointerEvent of type `inType`\n */\n makeEven
t: function(inType, inEvent) {\n var e = eventFactory.makePointerEvent(inTy
pe, inEvent);\n e.preventDefault = inEvent.preventDefault;\n e.tapPrev
ented = inEvent.tapPrevented;\n e._target = e._target || inEvent.target;\n
return e;\n },\n // make and dispatch an event in one call\n fireE
vent: function(inType, inEvent) {\n var e = this.makeEvent(inType, inEvent)
;\n return this.dispatchEvent(e);\n },\n /**\n * Returns a snapsh
ot of inEvent, with writable properties.\n *\n * @param {Event} inEvent
An event that contains properties to copy.\n * @return {Object} An object co
ntaining shallow copies of `inEvent`'s\n * properties.\n */\n clon
eEvent: function(inEvent) {\n var eventCopy = Object.create(null), p;\n
for (var i = 0; i < CLONE_PROPS.length; i++) {\n p = CLONE_PROPS[i];\n
eventCopy[p] = inEvent[p] || CLONE_DEFAULTS[i];\n // Work around S
VGInstanceElement shadow tree\n // Return the <use> element that is repre
sented by the instance for Safari, Chrome, IE.\n // This is the behavior
implemented by Firefox.\n if (p === 'target' || p === 'relatedTarget') {\
n if (HAS_SVG_INSTANCE && eventCopy[p] instanceof SVGElementInstance) {
\n eventCopy[p] = eventCopy[p].correspondingUseElement;\n }\
n }\n }\n // keep the semantics of preventDefault\n eventC
opy.preventDefault = function() {\n inEvent.preventDefault();\n };\n
return eventCopy;\n },\n /**\n * Dispatches the event to its tar
get.\n *\n * @param {Event} inEvent The event to be dispatched.\n *
@return {Boolean} True if an event handler returns true, false otherwise.\n
*/\n dispatchEvent: function(inEvent) {\n var t = inEvent._target;\n
if (t) {\n t.dispatchEvent(inEvent);\n // clone the event for th
e gesture system to process\n // clone after dispatch to pick up gesture
prevention code\n var clone = this.cloneEvent(inEvent);\n clone.ta
rget = t;\n this.fillGestureQueue(clone);\n }\n },\n gestureTr
igger: function() {\n // process the gesture queue\n for (var i = 0, e
, rg; i < this.gestureQueue.length; i++) {\n e = this.gestureQueue[i];\n
rg = e._requiredGestures;\n for (var j = 0, g, fn; j < this.gestur
es.length; j++) {\n // only run recognizer if an element in the source
event's path is listening for those gestures\n if (rg[j]) {\n
g = this.gestures[j];\n fn = g[e.type];\n if (fn) {\n
fn.call(g, e);\n }\n }\n }\n }\n
this.gestureQueue.length = 0;\n },\n fillGestureQueue: function(ev) {\n
// only trigger the gesture queue once\n if (!this.gestureQueue.length)
{\n requestAnimationFrame(this.boundGestureTrigger);\n }\n ev.
_requiredGestures = this.requiredGestures.get(ev.pointerId);\n this.gesture
Queue.push(ev);\n }\n };\n dispatcher.boundHandler = dispatcher.eventHandle
r.bind(dispatcher);\n dispatcher.boundGestureTrigger = dispatcher.gestureTrigge
r.bind(dispatcher);\n scope.dispatcher = dispatcher;\n\n /**\n * Listen for
`gesture` on `node` with the `handler` function\n *\n * If `handler` is the
first listener for `gesture`, the underlying gesture recognizer is then enabled.
\n *\n * @param {Element} node\n * @param {string} gesture\n * @return B
oolean `gesture` is a valid gesture\n */\n scope.activateGesture = function(n
ode, gesture) {\n var g = gesture.toLowerCase();\n var dep = dispatcher.de
pendencyMap[g];\n if (dep) {\n var recognizer = dispatcher.gestures[dep.
index];\n if (!node._pgListeners) {\n dispatcher.register(node);\n
node._pgListeners = 0;\n }\n // TODO(dfreedm): re-evaluate bookk
eeping to avoid using attributes\n if (recognizer) {\n var touchActi
on = recognizer.defaultActions && recognizer.defaultActions[g];\n var act
ionNode;\n switch(node.nodeType) {\n case Node.ELEMENT_NODE:\n
actionNode = node;\n break;\n case Node.DOCUMENT_FRA
GMENT_NODE:\n actionNode = node.host;\n break;\n de
fault:\n actionNode = null;\n break;\n }\n if
(touchAction && actionNode && !actionNode.hasAttribute('touch-action')) {\n
actionNode.setAttribute('touch-action', touchAction);\n }\n }\n
if (!node._pgEvents) {\n node._pgEvents = {};\n }\n node.
_pgEvents[g] = (node._pgEvents[g] || 0) + 1;\n node._pgListeners++;\n }\
n return Boolean(dep);\n };\n\n /**\n *\n * Listen for `gesture` from `
node` with `handler` function.\n *\n * @param {Element} node\n * @param {s
tring} gesture\n * @param {Function} handler\n * @param {Boolean} capture\n
*/\n scope.addEventListener = function(node, gesture, handler, capture) {\n
if (handler) {\n scope.activateGesture(node, gesture);\n node.addEve
ntListener(gesture, handler, capture);\n }\n };\n\n /**\n * Tears down th
e gesture configuration for `node`\n *\n * If `handler` is the last listener
for `gesture`, the underlying gesture recognizer is disabled.\n *\n * @para
m {Element} node\n * @param {string} gesture\n * @return Boolean `gesture` i
s a valid gesture\n */\n scope.deactivateGesture = function(node, gesture) {\
n var g = gesture.toLowerCase();\n var dep = dispatcher.dependencyMap[g];\
n if (dep) {\n if (node._pgListeners > 0) {\n node._pgListeners--
;\n }\n if (node._pgListeners === 0) {\n dispatcher.unregister(
node);\n }\n if (node._pgEvents) {\n if (node._pgEvents[g] > 0)
{\n node._pgEvents[g]--;\n } else {\n node._pgEvents[g
] = 0;\n }\n }\n }\n return Boolean(dep);\n };\n\n /**\n *
Stop listening for `gesture` from `node` with `handler` function.\n *\n * @
param {Element} node\n * @param {string} gesture\n * @param {Function} handl
er\n * @param {Boolean} capture\n */\n scope.removeEventListener = function
(node, gesture, handler, capture) {\n if (handler) {\n scope.deactivateG
esture(node, gesture);\n node.removeEventListener(gesture, handler, capture
);\n }\n };\n})(window.PolymerGestures);\n\n/*\n * Copyright (c) 2014 The Po
lymer Project Authors. All rights reserved.\n * This code may only be used under
the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The com
plete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * Th
e complete set of contributors may be found at http://polymer.github.io/CONTRIBU
TORS.txt\n * Code distributed by Google as part of the polymer project is also\n
* subject to an additional IP rights grant found at http://polymer.github.io/PA
TENTS.txt\n */\n\n(function (scope) {\n var dispatcher = scope.dispatcher;\n v
ar pointermap = dispatcher.pointermap;\n // radius around touchend that swallow
s mouse events\n var DEDUP_DIST = 25;\n\n var WHICH_TO_BUTTONS = [0, 1, 4, 2];
\n\n var HAS_BUTTONS = false;\n try {\n HAS_BUTTONS = new MouseEvent('test'
, {buttons: 1}).buttons === 1;\n } catch (e) {}\n\n // handler block for nativ
e mouse events\n var mouseEvents = {\n POINTER_ID: 1,\n POINTER_TYPE: 'mo
use',\n events: [\n 'mousedown',\n 'mousemove',\n 'mouseup'\n
],\n exposes: [\n 'down',\n 'up',\n 'move'\n ],\n reg
ister: function(target) {\n dispatcher.listen(target, this.events);\n },
\n unregister: function(target) {\n if (target === document) {\n
return;\n }\n dispatcher.unlisten(target, this.events);\n },\n l
astTouches: [],\n // collide with the global mouse listener\n isEventSimul
atedFromTouch: function(inEvent) {\n var lts = this.lastTouches;\n var
x = inEvent.clientX, y = inEvent.clientY;\n for (var i = 0, l = lts.length
, t; i < l && (t = lts[i]); i++) {\n // simulated mouse events will be sw
allowed near a primary touchend\n var dx = Math.abs(x - t.x), dy = Math.a
bs(y - t.y);\n if (dx <= DEDUP_DIST && dy <= DEDUP_DIST) {\n ret
urn true;\n }\n }\n },\n prepareEvent: function(inEvent) {\n
var e = dispatcher.cloneEvent(inEvent);\n e.pointerId = this.POINTER_ID
;\n e.isPrimary = true;\n e.pointerType = this.POINTER_TYPE;\n e.
_source = 'mouse';\n if (!HAS_BUTTONS) {\n e.buttons = WHICH_TO_BUTT
ONS[e.which] || 0;\n }\n return e;\n },\n mousedown: function(in
Event) {\n if (!this.isEventSimulatedFromTouch(inEvent)) {\n var p =
pointermap.has(this.POINTER_ID);\n // TODO(dfreedman) workaround for som
e elements not sending mouseup\n // http://crbug/149091\n if (p) {
\n this.mouseup(inEvent);\n }\n var e = this.prepareEvent
(inEvent);\n e.target = scope.findTarget(inEvent);\n pointermap.se
t(this.POINTER_ID, e.target);\n dispatcher.down(e);\n }\n },\n
mousemove: function(inEvent) {\n if (!this.isEventSimulatedFromTouch(inEve
nt)) {\n var target = pointermap.get(this.POINTER_ID);\n if (targe
t) {\n var e = this.prepareEvent(inEvent);\n e.target = target
;\n // handle case where we missed a mouseup\n if (e.buttons =
== 0) {\n dispatcher.cancel(e);\n this.cleanupMouse();\n
} else {\n dispatcher.move(e);\n }\n }\n
}\n },\n mouseup: function(inEvent) {\n if (!this.isEventSimulatedFr
omTouch(inEvent)) {\n var e = this.prepareEvent(inEvent);\n e.rela
tedTarget = scope.findTarget(inEvent);\n e.target = pointermap.get(this.P
OINTER_ID);\n dispatcher.up(e);\n this.cleanupMouse();\n }\n
},\n cleanupMouse: function() {\n pointermap['delete'](this.POINTER_I
D);\n }\n };\n\n scope.mouseEvents = mouseEvents;\n})(window.PolymerGesture
s);\n\n/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserve
d.\n * This code may only be used under the BSD style license found at http://po
lymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http
://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be fou
nd at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google a
s part of the polymer project is also\n * subject to an additional IP rights gra
nt found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n v
ar dispatcher = scope.dispatcher;\n var allShadows = scope.targetFinding.allSha
dows.bind(scope.targetFinding);\n var pointermap = dispatcher.pointermap;\n va
r touchMap = Array.prototype.map.call.bind(Array.prototype.map);\n // This shou
ld be long enough to ignore compat mouse events made by touch\n var DEDUP_TIMEO
UT = 2500;\n var CLICK_COUNT_TIMEOUT = 200;\n var HYSTERESIS = 20;\n var ATTR
IB = 'touch-action';\n // TODO(dfreedm): disable until http://crbug.com/399765
is resolved\n // var HAS_TOUCH_ACTION = ATTRIB in document.head.style;\n var H
AS_TOUCH_ACTION = false;\n\n // handler block for native touch events\n var to
uchEvents = {\n IS_IOS: false,\n events: [\n 'touchstart',\n 'to
uchmove',\n 'touchend',\n 'touchcancel'\n ],\n exposes: [\n
'down',\n 'up',\n 'move'\n ],\n register: function(target, init
ial) {\n if (this.IS_IOS ? initial : !initial) {\n dispatcher.listen
(target, this.events);\n }\n },\n unregister: function(target) {\n
if (!this.IS_IOS) {\n dispatcher.unlisten(target, this.events);\n
}\n },\n scrollTypes: {\n EMITTER: 'none',\n XSCROLLER: 'pan-x'
,\n YSCROLLER: 'pan-y',\n },\n touchActionToScrollType: function(touc
hAction) {\n var t = touchAction;\n var st = this.scrollTypes;\n
if (t === st.EMITTER) {\n return 'none';\n } else if (t === st.XSCRO
LLER) {\n return 'X';\n } else if (t === st.YSCROLLER) {\n re
turn 'Y';\n } else {\n return 'XY';\n }\n },\n POINTER_TY
PE: 'touch',\n firstTouch: null,\n isPrimaryTouch: function(inTouch) {\n
return this.firstTouch === inTouch.identifier;\n },\n setPrimaryTouch:
function(inTouch) {\n // set primary touch if there no pointers, or the on
ly pointer is the mouse\n if (pointermap.pointers() === 0 || (pointermap.po
inters() === 1 && pointermap.has(1))) {\n this.firstTouch = inTouch.ident
ifier;\n this.firstXY = {X: inTouch.clientX, Y: inTouch.clientY};\n
this.scrolling = null;\n this.cancelResetClickCount();\n }\n },
\n removePrimaryPointer: function(inPointer) {\n if (inPointer.isPrimary
) {\n this.firstTouch = null;\n this.firstXY = null;\n this
.resetClickCount();\n }\n },\n clickCount: 0,\n resetId: null,\n
resetClickCount: function() {\n var fn = function() {\n this.click
Count = 0;\n this.resetId = null;\n }.bind(this);\n this.resetI
d = setTimeout(fn, CLICK_COUNT_TIMEOUT);\n },\n cancelResetClickCount: fun
ction() {\n if (this.resetId) {\n clearTimeout(this.resetId);\n
}\n },\n typeToButtons: function(type) {\n var ret = 0;\n if (t
ype === 'touchstart' || type === 'touchmove') {\n ret = 1;\n }\n
return ret;\n },\n findTarget: function(touch, id) {\n if (this.cur
rentTouchEvent.type === 'touchstart') {\n if (this.isPrimaryTouch(touch))
{\n var fastPath = {\n clientX: touch.clientX,\n
clientY: touch.clientY,\n path: this.currentTouchEvent.path,\n
target: this.currentTouchEvent.target\n };\n return scop
e.findTarget(fastPath);\n } else {\n return scope.findTarget(tou
ch);\n }\n }\n // reuse target we found in touchstart\n re
turn pointermap.get(id);\n },\n touchToPointer: function(inTouch) {\n
var cte = this.currentTouchEvent;\n var e = dispatcher.cloneEvent(inTouch)
;\n // Spec specifies that pointerId 1 is reserved for Mouse.\n // Tou
ch identifiers can start at 0.\n // Add 2 to the touch identifier for compa
tibility.\n var id = e.pointerId = inTouch.identifier + 2;\n e.target
= this.findTarget(inTouch, id);\n e.bubbles = true;\n e.cancelable = t
rue;\n e.detail = this.clickCount;\n e.buttons = this.typeToButtons(ct
e.type);\n e.width = inTouch.webkitRadiusX || inTouch.radiusX || 0;\n
e.height = inTouch.webkitRadiusY || inTouch.radiusY || 0;\n e.pressure = in
Touch.webkitForce || inTouch.force || 0.5;\n e.isPrimary = this.isPrimaryTo
uch(inTouch);\n e.pointerType = this.POINTER_TYPE;\n e._source = 'touc
h';\n // forward touch preventDefaults\n var self = this;\n e.pre
ventDefault = function() {\n self.scrolling = false;\n self.firstX
Y = null;\n cte.preventDefault();\n };\n return e;\n },\n
processTouches: function(inEvent, inFunction) {\n var tl = inEvent.changed
Touches;\n this.currentTouchEvent = inEvent;\n for (var i = 0, t, p; i
< tl.length; i++) {\n t = tl[i];\n p = this.touchToPointer(t);\n
if (inEvent.type === 'touchstart') {\n pointermap.set(p.pointerI
d, p.target);\n }\n if (pointermap.has(p.pointerId)) {\n
inFunction.call(this, p);\n }\n if (inEvent.type === 'touchend' ||
inEvent._cancel) {\n this.cleanUpPointer(p);\n }\n }\n
},\n // For single axis scrollers, determines whether the element should emit
\n // pointer events or behave as a scroller\n shouldScroll: function(inEv
ent) {\n if (this.firstXY) {\n var ret;\n var touchAction = s
cope.targetFinding.findTouchAction(inEvent);\n var scrollAxis = this.touc
hActionToScrollType(touchAction);\n if (scrollAxis === 'none') {\n
// this element is a touch-action: none, should never scroll\n ret =
false;\n } else if (scrollAxis === 'XY') {\n // this element sh
ould always scroll\n ret = true;\n } else {\n var t = i
nEvent.changedTouches[0];\n // check the intended scroll axis, and othe
r axis\n var a = scrollAxis;\n var oa = scrollAxis === 'Y' ? '
X' : 'Y';\n var da = Math.abs(t['client' + a] - this.firstXY[a]);\n
var doa = Math.abs(t['client' + oa] - this.firstXY[oa]);\n // if
delta in the scroll axis > delta other axis, scroll instead of\n // mak
ing events\n ret = da >= doa;\n }\n return ret;\n }\
n },\n findTouch: function(inTL, inId) {\n for (var i = 0, l = inTL.l
ength, t; i < l && (t = inTL[i]); i++) {\n if (t.identifier === inId) {\n
return true;\n }\n }\n },\n // In some instances, a
touchstart can happen without a touchend. This\n // leaves the pointermap in
a broken state.\n // Therefore, on every touchstart, we remove the touches th
at did not fire a\n // touchend event.\n // To keep state globally consist
ent, we fire a\n // pointercancel for this \"abandoned\" touch\n vacuumTou
ches: function(inEvent) {\n var tl = inEvent.touches;\n // pointermap.
pointers() should be < tl.length here, as the touchstart has not\n // been
processed yet.\n if (pointermap.pointers() >= tl.length) {\n var d =
[];\n pointermap.forEach(function(value, key) {\n // Never remo
ve pointerId == 1, which is mouse.\n // Touch identifiers are 2 smaller
than their pointerId, which is the\n // index in pointermap.\n
if (key !== 1 && !this.findTouch(tl, key - 2)) {\n var p = value;\n
d.push(p);\n }\n }, this);\n d.forEach(functi
on(p) {\n this.cancel(p);\n pointermap.delete(p.pointerId);\n
});\n }\n },\n touchstart: function(inEvent) {\n this.vac
uumTouches(inEvent);\n this.setPrimaryTouch(inEvent.changedTouches[0]);\n
this.dedupSynthMouse(inEvent);\n if (!this.scrolling) {\n this.c
lickCount++;\n this.processTouches(inEvent, this.down);\n }\n },\
n down: function(inPointer) {\n dispatcher.down(inPointer);\n },\n
touchmove: function(inEvent) {\n if (HAS_TOUCH_ACTION) {\n // touch
event.cancelable == false is sent when the page is scrolling under native Touch
Action in Chrome 36\n // https://groups.google.com/a/chromium.org/d/msg/i
nput-dev/wHnyukcYBcA/b9kmtwM1jJQJ\n if (inEvent.cancelable) {\n
this.processTouches(inEvent, this.move);\n }\n } else {\n if
(!this.scrolling) {\n if (this.scrolling === null && this.shouldScroll(
inEvent)) {\n this.scrolling = true;\n } else {\n
this.scrolling = false;\n inEvent.preventDefault();\n thi
s.processTouches(inEvent, this.move);\n }\n } else if (this.firs
tXY) {\n var t = inEvent.changedTouches[0];\n var dx = t.clien
tX - this.firstXY.X;\n var dy = t.clientY - this.firstXY.Y;\n
var dd = Math.sqrt(dx * dx + dy * dy);\n if (dd >= HYSTERESIS) {\n
this.touchcancel(inEvent);\n this.scrolling = true;\n
this.firstXY = null;\n }\n }\n }\n },\n move: func
tion(inPointer) {\n dispatcher.move(inPointer);\n },\n touchend: func
tion(inEvent) {\n this.dedupSynthMouse(inEvent);\n this.processTouches
(inEvent, this.up);\n },\n up: function(inPointer) {\n inPointer.rela
tedTarget = scope.findTarget(inPointer);\n dispatcher.up(inPointer);\n }
,\n cancel: function(inPointer) {\n dispatcher.cancel(inPointer);\n }
,\n touchcancel: function(inEvent) {\n inEvent._cancel = true;\n th
is.processTouches(inEvent, this.cancel);\n },\n cleanUpPointer: function(i
nPointer) {\n pointermap['delete'](inPointer.pointerId);\n this.remove
PrimaryPointer(inPointer);\n },\n // prevent synth mouse events from creat
ing pointer events\n dedupSynthMouse: function(inEvent) {\n var lts = sc
ope.mouseEvents.lastTouches;\n var t = inEvent.changedTouches[0];\n //
only the primary finger will synth mouse events\n if (this.isPrimaryTouch(
t)) {\n // remember x/y of last touch\n var lt = {x: t.clientX, y:
t.clientY};\n lts.push(lt);\n var fn = (function(lts, lt){\n
var i = lts.indexOf(lt);\n if (i > -1) {\n lts.splice(i
, 1);\n }\n }).bind(null, lts, lt);\n setTimeout(fn, DEDU
P_TIMEOUT);\n }\n }\n };\n\n scope.touchEvents = touchEvents;\n})(wind
ow.PolymerGestures);\n\n/*\n * Copyright (c) 2014 The Polymer Project Authors. A
ll rights reserved.\n * This code may only be used under the BSD style license f
ound at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may
be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contri
butors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distri
buted by Google as part of the polymer project is also\n * subject to an additio
nal IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(funct
ion(scope) {\n var dispatcher = scope.dispatcher;\n var pointermap = dispatche
r.pointermap;\n var HAS_BITMAP_TYPE = window.MSPointerEvent && typeof window.MS
PointerEvent.MSPOINTER_TYPE_MOUSE === 'number';\n var msEvents = {\n events:
[\n 'MSPointerDown',\n 'MSPointerMove',\n 'MSPointerUp',\n
'MSPointerCancel',\n ],\n register: function(target) {\n dispatcher.l
isten(target, this.events);\n },\n unregister: function(target) {\n i
f (target === document) {\n return;\n }\n dispatcher.unlisten(t
arget, this.events);\n },\n POINTER_TYPES: [\n '',\n 'unavailabl
e',\n 'touch',\n 'pen',\n 'mouse'\n ],\n prepareEvent: func
tion(inEvent) {\n var e = inEvent;\n e = dispatcher.cloneEvent(inEvent
);\n if (HAS_BITMAP_TYPE) {\n e.pointerType = this.POINTER_TYPES[inE
vent.pointerType];\n }\n e._source = 'ms';\n return e;\n },\n
cleanup: function(id) {\n pointermap['delete'](id);\n },\n MSPoint
erDown: function(inEvent) {\n var e = this.prepareEvent(inEvent);\n e.
target = scope.findTarget(inEvent);\n pointermap.set(inEvent.pointerId, e.t
arget);\n dispatcher.down(e);\n },\n MSPointerMove: function(inEvent)
{\n var target = pointermap.get(inEvent.pointerId);\n if (target) {\n
var e = this.prepareEvent(inEvent);\n e.target = target;\n
dispatcher.move(e);\n }\n },\n MSPointerUp: function(inEvent) {\n
var e = this.prepareEvent(inEvent);\n e.relatedTarget = scope.findTarget
(inEvent);\n e.target = pointermap.get(e.pointerId);\n dispatcher.up(e
);\n this.cleanup(inEvent.pointerId);\n },\n MSPointerCancel: functio
n(inEvent) {\n var e = this.prepareEvent(inEvent);\n e.relatedTarget =
scope.findTarget(inEvent);\n e.target = pointermap.get(e.pointerId);\n
dispatcher.cancel(e);\n this.cleanup(inEvent.pointerId);\n }\n };\n\n
scope.msEvents = msEvents;\n})(window.PolymerGestures);\n\n/*\n * Copyright (c
) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only
be used under the BSD style license found at http://polymer.github.io/LICENSE.tx
t\n * The complete set of authors may be found at http://polymer.github.io/AUTHO
RS.txt\n * The complete set of contributors may be found at http://polymer.githu
b.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer proj
ect is also\n * subject to an additional IP rights grant found at http://polymer
.github.io/PATENTS.txt\n */\n\n(function(scope) {\n var dispatcher = scope.disp
atcher;\n var pointermap = dispatcher.pointermap;\n var pointerEvents = {\n
events: [\n 'pointerdown',\n 'pointermove',\n 'pointerup',\n
'pointercancel'\n ],\n prepareEvent: function(inEvent) {\n var e =
dispatcher.cloneEvent(inEvent);\n e._source = 'pointer';\n return e;\n
},\n register: function(target) {\n dispatcher.listen(target, this.e
vents);\n },\n unregister: function(target) {\n if (target === docume
nt) {\n return;\n }\n dispatcher.unlisten(target, this.events);
\n },\n cleanup: function(id) {\n pointermap['delete'](id);\n },\n
pointerdown: function(inEvent) {\n var e = this.prepareEvent(inEvent);\
n e.target = scope.findTarget(inEvent);\n pointermap.set(e.pointerId,
e.target);\n dispatcher.down(e);\n },\n pointermove: function(inEvent
) {\n var target = pointermap.get(inEvent.pointerId);\n if (target) {\
n var e = this.prepareEvent(inEvent);\n e.target = target;\n
dispatcher.move(e);\n }\n },\n pointerup: function(inEvent) {\n
var e = this.prepareEvent(inEvent);\n e.relatedTarget = scope.findTarget(
inEvent);\n e.target = pointermap.get(e.pointerId);\n dispatcher.up(e)
;\n this.cleanup(inEvent.pointerId);\n },\n pointercancel: function(i
nEvent) {\n var e = this.prepareEvent(inEvent);\n e.relatedTarget = sc
ope.findTarget(inEvent);\n e.target = pointermap.get(e.pointerId);\n d
ispatcher.cancel(e);\n this.cleanup(inEvent.pointerId);\n }\n };\n\n s
cope.pointerEvents = pointerEvents;\n})(window.PolymerGestures);\n\n/*\n * Copyr
ight (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code ma
y only be used under the BSD style license found at http://polymer.github.io/LIC
ENSE.txt\n * The complete set of authors may be found at http://polymer.github.i
o/AUTHORS.txt\n * The complete set of contributors may be found at http://polyme
r.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polym
er project is also\n * subject to an additional IP rights grant found at http://
polymer.github.io/PATENTS.txt\n */\n\n/**\n * This module contains the handlers
for native platform events.\n * From here, the dispatcher is called to create un
ified pointer events.\n * Included are touch events (v1), mouse events, and MSPo
interEvents.\n */\n(function(scope) {\n\n var dispatcher = scope.dispatcher;\n
var nav = window.navigator;\n\n if (window.PointerEvent) {\n dispatcher.reg
isterSource('pointer', scope.pointerEvents);\n } else if (nav.msPointerEnabled)
{\n dispatcher.registerSource('ms', scope.msEvents);\n } else {\n dispat
cher.registerSource('mouse', scope.mouseEvents);\n if (window.ontouchstart !=
= undefined) {\n dispatcher.registerSource('touch', scope.touchEvents);\n
}\n }\n\n // Work around iOS bugs https://bugs.webkit.org/show_bug.cgi?id=13
5628 and https://bugs.webkit.org/show_bug.cgi?id=136506\n var ua = navigator.us
erAgent;\n var IS_IOS = ua.match(/iPad|iPhone|iPod/) && 'ontouchstart' in windo
w;\n\n dispatcher.IS_IOS = IS_IOS;\n scope.touchEvents.IS_IOS = IS_IOS;\n\n d
ispatcher.register(document, true);\n})(window.PolymerGestures);\n\n/*\n * Copyr
ight (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code ma
y only be used under the BSD style license found at http://polymer.github.io/LIC
ENSE.txt\n * The complete set of authors may be found at http://polymer.github.i
o/AUTHORS.txt\n * The complete set of contributors may be found at http://polyme
r.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polym
er project is also\n * subject to an additional IP rights grant found at http://
polymer.github.io/PATENTS.txt\n */\n\n/**\n * This event denotes the beginning o
f a series of tracking events.\n *\n * @module PointerGestures\n * @submodule Ev
ents\n * @class trackstart\n */\n/**\n * Pixels moved in the x direction since t
rackstart.\n * @type Number\n * @property dx\n */\n/**\n * Pixes moved in the y
direction since trackstart.\n * @type Number\n * @property dy\n */\n/**\n * Pixe
ls moved in the x direction since the last track.\n * @type Number\n * @property
ddx\n */\n/**\n * Pixles moved in the y direction since the last track.\n * @ty
pe Number\n * @property ddy\n */\n/**\n * The clientX position of the track gest
ure.\n * @type Number\n * @property clientX\n */\n/**\n * The clientY position o
f the track gesture.\n * @type Number\n * @property clientY\n */\n/**\n * The pa
geX position of the track gesture.\n * @type Number\n * @property pageX\n */\n/*
*\n * The pageY position of the track gesture.\n * @type Number\n * @property pa
geY\n */\n/**\n * The screenX position of the track gesture.\n * @type Number\n
* @property screenX\n */\n/**\n * The screenY position of the track gesture.\n *
@type Number\n * @property screenY\n */\n/**\n * The last x axis direction of t
he pointer.\n * @type Number\n * @property xDirection\n */\n/**\n * The last y a
xis direction of the pointer.\n * @type Number\n * @property yDirection\n */\n/*
*\n * A shared object between all tracking events.\n * @type Object\n * @propert
y trackInfo\n */\n/**\n * The element currently under the pointer.\n * @type Ele
ment\n * @property relatedTarget\n */\n/**\n * The type of pointer that make the
track gesture.\n * @type String\n * @property pointerType\n */\n/**\n *\n * Thi
s event fires for all pointer movement being tracked.\n *\n * @class track\n * @
extends trackstart\n */\n/**\n * This event fires when the pointer is no longer
being tracked.\n *\n * @class trackend\n * @extends trackstart\n */\n\n (functio
n(scope) {\n var dispatcher = scope.dispatcher;\n var eventFactory = scope.e
ventFactory;\n var pointermap = new scope.PointerMap();\n var track = {\n
events: [\n 'down',\n 'move',\n 'up',\n ],\n exposes
: [\n 'trackstart',\n 'track',\n 'trackx',\n 'tracky',\n
'trackend'\n ],\n defaultActions: {\n 'track': 'none',\n '
trackx': 'pan-y',\n 'tracky': 'pan-x'\n },\n WIGGLE_THRESHOLD: 4,\
n clampDir: function(inDelta) {\n return inDelta > 0 ? 1 : -1;\n }
,\n calcPositionDelta: function(inA, inB) {\n var x = 0, y = 0;\n
if (inA && inB) {\n x = inB.pageX - inA.pageX;\n y = inB.pageY
- inA.pageY;\n }\n return {x: x, y: y};\n },\n fireTrack: f
unction(inType, inEvent, inTrackingData) {\n var t = inTrackingData;\n
var d = this.calcPositionDelta(t.downEvent, inEvent);\n var dd = this.c
alcPositionDelta(t.lastMoveEvent, inEvent);\n if (dd.x) {\n t.xDir
ection = this.clampDir(dd.x);\n } else if (inType === 'trackx') {\n
return;\n }\n if (dd.y) {\n t.yDirection = this.clampDir(d
d.y);\n } else if (inType === 'tracky') {\n return;\n }\n
var gestureProto = {\n bubbles: true,\n cancelable: true,\n
trackInfo: t.trackInfo,\n relatedTarget: inEvent.relatedTarget,\
n pointerType: inEvent.pointerType,\n pointerId: inEvent.pointer
Id,\n _source: 'track'\n };\n if (inType !== 'tracky') {\n
gestureProto.x = inEvent.x;\n gestureProto.dx = d.x;\n ge
stureProto.ddx = dd.x;\n gestureProto.clientX = inEvent.clientX;\n
gestureProto.pageX = inEvent.pageX;\n gestureProto.screenX = inEvent.
screenX;\n gestureProto.xDirection = t.xDirection;\n }\n if
(inType !== 'trackx') {\n gestureProto.dy = d.y;\n gestureProto.
ddy = dd.y;\n gestureProto.y = inEvent.y;\n gestureProto.clientY
= inEvent.clientY;\n gestureProto.pageY = inEvent.pageY;\n gest
ureProto.screenY = inEvent.screenY;\n gestureProto.yDirection = t.yDirec
tion;\n }\n var e = eventFactory.makeGestureEvent(inType, gesturePro
to);\n t.downTarget.dispatchEvent(e);\n },\n down: function(inEven
t) {\n if (inEvent.isPrimary && (inEvent.pointerType === 'mouse' ? inEvent
.buttons === 1 : true)) {\n var p = {\n downEvent: inEvent,\n
downTarget: inEvent.target,\n trackInfo: {},\n las
tMoveEvent: null,\n xDirection: 0,\n yDirection: 0,\n
tracking: false\n };\n pointermap.set(inEvent.pointerId, p);
\n }\n },\n move: function(inEvent) {\n var p = pointermap.g
et(inEvent.pointerId);\n if (p) {\n if (!p.tracking) {\n
var d = this.calcPositionDelta(p.downEvent, inEvent);\n var move = d.
x * d.x + d.y * d.y;\n // start tracking only if finger moves more tha
n WIGGLE_THRESHOLD\n if (move > this.WIGGLE_THRESHOLD) {\n
p.tracking = true;\n p.lastMoveEvent = p.downEvent;\n t
his.fireTrack('trackstart', inEvent, p);\n }\n }\n if
(p.tracking) {\n this.fireTrack('track', inEvent, p);\n this
.fireTrack('trackx', inEvent, p);\n this.fireTrack('tracky', inEvent,
p);\n }\n p.lastMoveEvent = inEvent;\n }\n },\n up
: function(inEvent) {\n var p = pointermap.get(inEvent.pointerId);\n
if (p) {\n if (p.tracking) {\n this.fireTrack('trackend', inE
vent, p);\n }\n pointermap.delete(inEvent.pointerId);\n }\
n }\n };\n dispatcher.registerGesture('track', track);\n })(window.Polym
erGestures);\n\n/*\n * Copyright (c) 2014 The Polymer Project Authors. All right
s reserved.\n * This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be foun
d at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors m
ay be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by
Google as part of the polymer project is also\n * subject to an additional IP r
ights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n/**\n * This e
vent is fired when a pointer is held down for 200ms.\n *\n * @module PointerGest
ures\n * @submodule Events\n * @class hold\n */\n/**\n * Type of pointer that ma
de the holding event.\n * @type String\n * @property pointerType\n */\n/**\n * S
creen X axis position of the held pointer\n * @type Number\n * @property clientX
\n */\n/**\n * Screen Y axis position of the held pointer\n * @type Number\n * @
property clientY\n */\n/**\n * Type of pointer that made the holding event.\n *
@type String\n * @property pointerType\n */\n/**\n * This event is fired every 2
00ms while a pointer is held down.\n *\n * @class holdpulse\n * @extends hold\n
*/\n/**\n * Milliseconds pointer has been held down.\n * @type Number\n * @prope
rty holdTime\n */\n/**\n * This event is fired when a held pointer is released o
r moved.\n *\n * @class release\n */\n\n(function(scope) {\n var dispatcher = s
cope.dispatcher;\n var eventFactory = scope.eventFactory;\n var hold = {\n
// wait at least HOLD_DELAY ms between hold and pulse events\n HOLD_DELAY: 20
0,\n // pointer can move WIGGLE_THRESHOLD pixels before not counting as a hol
d\n WIGGLE_THRESHOLD: 16,\n events: [\n 'down',\n 'move',\n
'up',\n ],\n exposes: [\n 'hold',\n 'holdpulse',\n 'releas
e'\n ],\n heldPointer: null,\n holdJob: null,\n pulse: function() {\
n var hold = Date.now() - this.heldPointer.timeStamp;\n var type = thi
s.held ? 'holdpulse' : 'hold';\n this.fireHold(type, hold);\n this.hel
d = true;\n },\n cancel: function() {\n clearInterval(this.holdJob);\
n if (this.held) {\n this.fireHold('release');\n }\n this.
held = false;\n this.heldPointer = null;\n this.target = null;\n
this.holdJob = null;\n },\n down: function(inEvent) {\n if (inEvent.i
sPrimary && !this.heldPointer) {\n this.heldPointer = inEvent;\n t
his.target = inEvent.target;\n this.holdJob = setInterval(this.pulse.bind
(this), this.HOLD_DELAY);\n }\n },\n up: function(inEvent) {\n i
f (this.heldPointer && this.heldPointer.pointerId === inEvent.pointerId) {\n
this.cancel();\n }\n },\n move: function(inEvent) {\n if (th
is.heldPointer && this.heldPointer.pointerId === inEvent.pointerId) {\n v
ar x = inEvent.clientX - this.heldPointer.clientX;\n var y = inEvent.clie
ntY - this.heldPointer.clientY;\n if ((x * x + y * y) > this.WIGGLE_THRES
HOLD) {\n this.cancel();\n }\n }\n },\n fireHold: fun
ction(inType, inHoldTime) {\n var p = {\n bubbles: true,\n ca
ncelable: true,\n pointerType: this.heldPointer.pointerType,\n poi
nterId: this.heldPointer.pointerId,\n x: this.heldPointer.clientX,\n
y: this.heldPointer.clientY,\n _source: 'hold'\n };\n if (in
HoldTime) {\n p.holdTime = inHoldTime;\n }\n var e = eventFacto
ry.makeGestureEvent(inType, p);\n this.target.dispatchEvent(e);\n }\n }
;\n dispatcher.registerGesture('hold', hold);\n})(window.PolymerGestures);\n\n/
*\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * T
his code may only be used under the BSD style license found at http://polymer.gi
thub.io/LICENSE.txt\n * The complete set of authors may be found at http://polym
er.github.io/AUTHORS.txt\n * The complete set of contributors may be found at ht
tp://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part o
f the polymer project is also\n * subject to an additional IP rights grant found
at http://polymer.github.io/PATENTS.txt\n */\n\n/**\n * This event is fired whe
n a pointer quickly goes down and up, and is used to\n * denote activation.\n *\
n * Any gesture event can prevent the tap event from being created by calling\n
* `event.preventTap`.\n *\n * Any pointer event can prevent the tap by setting t
he `tapPrevented` property\n * on itself.\n *\n * @module PointerGestures\n * @s
ubmodule Events\n * @class tap\n */\n/**\n * X axis position of the tap.\n * @pr
operty x\n * @type Number\n */\n/**\n * Y axis position of the tap.\n * @propert
y y\n * @type Number\n */\n/**\n * Type of the pointer that made the tap.\n * @p
roperty pointerType\n * @type String\n */\n(function(scope) {\n var dispatcher
= scope.dispatcher;\n var eventFactory = scope.eventFactory;\n var pointermap
= new scope.PointerMap();\n var tap = {\n events: [\n 'down',\n 'u
p'\n ],\n exposes: [\n 'tap'\n ],\n down: function(inEvent) {\n
if (inEvent.isPrimary && !inEvent.tapPrevented) {\n pointermap.set(
inEvent.pointerId, {\n target: inEvent.target,\n buttons: inEv
ent.buttons,\n x: inEvent.clientX,\n y: inEvent.clientY\n
});\n }\n },\n shouldTap: function(e, downState) {\n if (e.po
interType === 'mouse') {\n // only allow left click to tap for mouse\n
return downState.buttons === 1;\n }\n return !e.tapPrevented;\n
},\n up: function(inEvent) {\n var start = pointermap.get(inEvent.poin
terId);\n if (start && this.shouldTap(inEvent, start)) {\n // up.rel
atedTarget is target currently under finger\n var t = scope.targetFinding
.LCA(start.target, inEvent.relatedTarget);\n if (t) {\n var e =
eventFactory.makeGestureEvent('tap', {\n bubbles: true,\n
cancelable: true,\n x: inEvent.clientX,\n y: inEvent.clien
tY,\n detail: inEvent.detail,\n pointerType: inEvent.point
erType,\n pointerId: inEvent.pointerId,\n altKey: inEvent.
altKey,\n ctrlKey: inEvent.ctrlKey,\n metaKey: inEvent.met
aKey,\n shiftKey: inEvent.shiftKey,\n _source: 'tap'\n
});\n t.dispatchEvent(e);\n }\n }\n pointermap.d
elete(inEvent.pointerId);\n }\n };\n // patch eventFactory to remove id fro
m tap's pointermap for preventTap calls\n eventFactory.preventTap = function(e)
{\n return function() {\n e.tapPrevented = true;\n pointermap.dele
te(e.pointerId);\n };\n };\n dispatcher.registerGesture('tap', tap);\n})(wi
ndow.PolymerGestures);\n\n/*\n Copyright (C) 2013 Ariya Hidayat <ariya.hidayat@
gmail.com>\n Copyright (C) 2013 Thaddee Tyl <thaddee.tyl@gmail.com>\n Copyrigh
t (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>\n Copyright (C) 2012 Mathias
Bynens <mathias@qiwi.be>\n Copyright (C) 2012 Joost-Wim Boekesteijn <joost-wim
@boekesteijn.nl>\n Copyright (C) 2012 Kris Kowal <kris.kowal@cixar.com>\n Copy
right (C) 2012 Yusuke Suzuki <utatane.tea@gmail.com>\n Copyright (C) 2012 Arpad
Borsos <arpad.borsos@googlemail.com>\n Copyright (C) 2011 Ariya Hidayat <ariya
.hidayat@gmail.com>\n\n Redistribution and use in source and binary forms, with
or without\n modification, are permitted provided that the following condition
s are met:\n\n * Redistributions of source code must retain the above copyrig
ht\n notice, this list of conditions and the following disclaimer.\n * R
edistributions in binary form must reproduce the above copyright\n notice,
this list of conditions and the following disclaimer in the\n documentation
and/or other materials provided with the distribution.\n\n THIS SOFTWARE IS PR
OVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n ARE DISCLAIMED. IN NO E
VENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY\n DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n LOSS OF USE, DATA, OR PROFITS;
OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n ON ANY THEORY OF LIABILITY, WHET
HER IN CONTRACT, STRICT LIABILITY, OR TORT\n (INCLUDING NEGLIGENCE OR OTHERWISE
) ARISING IN ANY WAY OUT OF THE USE OF\n THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.\n*/\n\n(function (global) {\n 'use strict';\n\n
var Token,\n TokenName,\n Syntax,\n Messages,\n so
urce,\n index,\n length,\n delegate,\n lookahead,\n
state;\n\n Token = {\n BooleanLiteral: 1,\n EOF: 2,\n
Identifier: 3,\n Keyword: 4,\n NullLiteral: 5,\n Numer
icLiteral: 6,\n Punctuator: 7,\n StringLiteral: 8\n };\n\n T
okenName = {};\n TokenName[Token.BooleanLiteral] = 'Boolean';\n TokenName[
Token.EOF] = '<end>';\n TokenName[Token.Identifier] = 'Identifier';\n Toke
nName[Token.Keyword] = 'Keyword';\n TokenName[Token.NullLiteral] = 'Null';\n
TokenName[Token.NumericLiteral] = 'Numeric';\n TokenName[Token.Punctuator]
= 'Punctuator';\n TokenName[Token.StringLiteral] = 'String';\n\n Syntax =
{\n ArrayExpression: 'ArrayExpression',\n BinaryExpression: 'Bina
ryExpression',\n CallExpression: 'CallExpression',\n ConditionalEx
pression: 'ConditionalExpression',\n EmptyStatement: 'EmptyStatement',\n
ExpressionStatement: 'ExpressionStatement',\n Identifier: 'Identif
ier',\n Literal: 'Literal',\n LabeledStatement: 'LabeledStatement'
,\n LogicalExpression: 'LogicalExpression',\n MemberExpression: 'M
emberExpression',\n ObjectExpression: 'ObjectExpression',\n Progra
m: 'Program',\n Property: 'Property',\n ThisExpression: 'ThisExpre
ssion',\n UnaryExpression: 'UnaryExpression'\n };\n\n // Error mess
ages should be identical to V8.\n Messages = {\n UnexpectedToken: 'Un
expected token %0',\n UnknownLabel: 'Undefined label \\'%0\\'',\n
Redeclaration: '%0 \\'%1\\' has already been declared'\n };\n\n // Ensure
the condition is true, otherwise throw an error.\n // This is only to have a
better contract semantic, i.e. another safety net\n // to catch a logic error
. The condition shall be fulfilled in normal case.\n // Do NOT use this to en
force a certain condition on any user input.\n\n function assert(condition, m
essage) {\n if (!condition) {\n throw new Error('ASSERT: ' + m
essage);\n }\n }\n\n function isDecimalDigit(ch) {\n return
(ch >= 48 && ch <= 57); // 0..9\n }\n\n\n // 7.2 White Space\n\n func
tion isWhiteSpace(ch) {\n return (ch === 32) || // space\n (c
h === 9) || // tab\n (ch === 0xB) ||\n (ch === 0xC) |
|\n (ch === 0xA0) ||\n (ch >= 0x1680 && '\\u1680\\u180E\\u
2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202
F\\u205F\\u3000\\uFEFF'.indexOf(String.fromCharCode(ch)) > 0);\n }\n\n //
7.3 Line Terminators\n\n function isLineTerminator(ch) {\n return (ch
=== 10) || (ch === 13) || (ch === 0x2028) || (ch === 0x2029);\n }\n\n // 7
.6 Identifier Names and Identifiers\n\n function isIdentifierStart(ch) {\n
return (ch === 36) || (ch === 95) || // $ (dollar) and _ (underscore)\n
(ch >= 65 && ch <= 90) || // A..Z\n (ch >= 97 && ch
<= 122); // a..z\n }\n\n function isIdentifierPart(ch) {\n
return (ch === 36) || (ch === 95) || // $ (dollar) and _ (underscore)\n
(ch >= 65 && ch <= 90) || // A..Z\n (ch >= 97 && ch <= 1
22) || // a..z\n (ch >= 48 && ch <= 57); // 0..9\n
}\n\n // 7.6.1.1 Keywords\n\n function isKeyword(id) {\n return (
id === 'this')\n }\n\n // 7.4 Comments\n\n function skipWhitespace() {\
n while (index < length && isWhiteSpace(source.charCodeAt(index))) {\n
++index;\n }\n }\n\n function getIdentifier() {\n va
r start, ch;\n\n start = index++;\n while (index < length) {\n
ch = source.charCodeAt(index);\n if (isIdentifierPart(ch)) {\
n ++index;\n } else {\n break;\n
}\n }\n\n return source.slice(start, index);\n }\n\n fu
nction scanIdentifier() {\n var start, id, type;\n\n start = index
;\n\n id = getIdentifier();\n\n // There is no keyword or literal
with only one character.\n // Thus, it must be an identifier.\n if
(id.length === 1) {\n type = Token.Identifier;\n } else if (i
sKeyword(id)) {\n type = Token.Keyword;\n } else if (id === 'n
ull') {\n type = Token.NullLiteral;\n } else if (id === 'true'
|| id === 'false') {\n type = Token.BooleanLiteral;\n } else
{\n type = Token.Identifier;\n }\n\n return {\n
type: type,\n value: id,\n range: [start, index]\n
};\n }\n\n\n // 7.7 Punctuators\n\n function scanPunctuator() {\n
var start = index,\n code = source.charCodeAt(index),\n
code2,\n ch1 = source[index],\n ch2;\n\n switch
(code) {\n\n // Check for most common single-character punctuators.\n
case 46: // . dot\n case 40: // ( open bracket\n case 41:
// ) close bracket\n case 59: // ; semicolon\n case 44: //
, comma\n case 123: // { open curly brace\n case 125: // } close
curly brace\n case 91: // [\n case 93: // ]\n case 58:
// :\n case 63: // ?\n ++index;\n return {\n
type: Token.Punctuator,\n value: String.fromCharCod
e(code),\n range: [start, index]\n };\n\n defau
lt:\n code2 = source.charCodeAt(index + 1);\n\n // '=' (ch
ar #61) marks an assignment or comparison operator.\n if (code2 === 6
1) {\n switch (code) {\n case 37: // %\n
case 38: // &\n case 42: // *:\n case 43:
// +\n case 45: // -\n case 47: // /\n
case 60: // <\n case 62: // >\n case 124
: // |\n index += 2;\n return {\n
type: Token.Punctuator,\n value: String.fr
omCharCode(code) + String.fromCharCode(code2),\n range: [
start, index]\n };\n\n case 33: // !\n
case 61: // =\n index += 2;\n\n //
!== and ===\n if (source.charCodeAt(index) === 61) {\n
++index;\n }\n return {\
n type: Token.Punctuator,\n value:
source.slice(start, index),\n range: [start, index]\n
};\n default:\n break;\n
}\n }\n break;\n }\n\n // Peek mo
re characters.\n\n ch2 = source[index + 1];\n\n // Other 2-charact
er punctuators: && ||\n\n if (ch1 === ch2 && ('&|'.indexOf(ch1) >= 0)) {\
n index += 2;\n return {\n type: Token.Punc
tuator,\n value: ch1 + ch2,\n range: [start, index
]\n };\n }\n\n if ('<>=!+-*%&|^/'.indexOf(ch1) >= 0) {\
n ++index;\n return {\n type: Token.Punctua
tor,\n value: ch1,\n range: [start, index]\n
};\n }\n\n throwError({}, Messages.UnexpectedToken, 'ILLEGAL
');\n }\n\n // 7.8.3 Numeric Literals\n function scanNumericLiteral() {
\n var number, start, ch;\n\n ch = source[index];\n assert(
isDecimalDigit(ch.charCodeAt(0)) || (ch === '.'),\n 'Numeric literal
must start with a decimal digit or a decimal point');\n\n start = index;\
n number = '';\n if (ch !== '.') {\n number = source[in
dex++];\n ch = source[index];\n\n // Hex number starts wit
h '0x'.\n // Octal number starts with '0'.\n if (number ==
= '0') {\n // decimal number starts with '0' such as '09' is ille
gal.\n if (ch && isDecimalDigit(ch.charCodeAt(0))) {\n
throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n }
\n }\n\n while (isDecimalDigit(source.charCodeAt(index)))
{\n number += source[index++];\n }\n ch = s
ource[index];\n }\n\n if (ch === '.') {\n number += sou
rce[index++];\n while (isDecimalDigit(source.charCodeAt(index))) {\n
number += source[index++];\n }\n ch = sourc
e[index];\n }\n\n if (ch === 'e' || ch === 'E') {\n num
ber += source[index++];\n\n ch = source[index];\n if (ch =
== '+' || ch === '-') {\n number += source[index++];\n
}\n if (isDecimalDigit(source.charCodeAt(index))) {\n
while (isDecimalDigit(source.charCodeAt(index))) {\n number
+= source[index++];\n }\n } else {\n th
rowError({}, Messages.UnexpectedToken, 'ILLEGAL');\n }\n }\n\n
if (isIdentifierStart(source.charCodeAt(index))) {\n throwErr
or({}, Messages.UnexpectedToken, 'ILLEGAL');\n }\n\n return {\n
type: Token.NumericLiteral,\n value: parseFloat(number),\n
range: [start, index]\n };\n }\n\n // 7.8.4 String Litera
ls\n\n function scanStringLiteral() {\n var str = '', quote, start, ch
, octal = false;\n\n quote = source[index];\n assert((quote === '\
\'' || quote === '\"'),\n 'String literal must starts with a quote');
\n\n start = index;\n ++index;\n\n while (index < length) {
\n ch = source[index++];\n\n if (ch === quote) {\n
quote = '';\n break;\n } else if (ch === '\\\\
') {\n ch = source[index++];\n if (!ch || !isLineT
erminator(ch.charCodeAt(0))) {\n switch (ch) {\n
case 'n':\n str += '\\n';\n
break;\n case 'r':\n str += '\\r';\n
break;\n case 't':\n
str += '\\t';\n break;\n case 'b
':\n str += '\\b';\n break;\n
case 'f':\n str += '\\f';\n
break;\n case 'v':\n str += '
\\x0B';\n break;\n\n default:\n
str += ch;\n break;\n
}\n } else {\n if (ch === '\\r' && source[in
dex] === '\\n') {\n ++index;\n }\n
}\n } else if (isLineTerminator(ch.charCodeAt(0))) {\n
break;\n } else {\n str += ch;\n
}\n }\n\n if (quote !== '') {\n throwError({}, Messa
ges.UnexpectedToken, 'ILLEGAL');\n }\n\n return {\n typ
e: Token.StringLiteral,\n value: str,\n octal: octal,\n
range: [start, index]\n };\n }\n\n function isIdentifierNa
me(token) {\n return token.type === Token.Identifier ||\n toke
n.type === Token.Keyword ||\n token.type === Token.BooleanLiteral ||\
n token.type === Token.NullLiteral;\n }\n\n function advance()
{\n var ch;\n\n skipWhitespace();\n\n if (index >= length)
{\n return {\n type: Token.EOF,\n range
: [index, index]\n };\n }\n\n ch = source.charCodeAt(in
dex);\n\n // Very common: ( and ) and ;\n if (ch === 40 || ch ===
41 || ch === 58) {\n return scanPunctuator();\n }\n\n /
/ String literal starts with single quote (#39) or double quote (#34).\n
if (ch === 39 || ch === 34) {\n return scanStringLiteral();\n
}\n\n if (isIdentifierStart(ch)) {\n return scanIdentifier();\
n }\n\n // Dot (.) char #46 can also start a floating-point number
, hence the need\n // to check the next character.\n if (ch === 46
) {\n if (isDecimalDigit(source.charCodeAt(index + 1))) {\n
return scanNumericLiteral();\n }\n return scanPunctu
ator();\n }\n\n if (isDecimalDigit(ch)) {\n return scan
NumericLiteral();\n }\n\n return scanPunctuator();\n }\n\n f
unction lex() {\n var token;\n\n token = lookahead;\n index
= token.range[1];\n\n lookahead = advance();\n\n index = token.ra
nge[1];\n\n return token;\n }\n\n function peek() {\n var po
s;\n\n pos = index;\n lookahead = advance();\n index = pos;
\n }\n\n // Throw an exception\n\n function throwError(token, messageFo
rmat) {\n var error,\n args = Array.prototype.slice.call(argum
ents, 2),\n msg = messageFormat.replace(\n /%(\\d)/g,\
n function (whole, index) {\n assert(index < a
rgs.length, 'Message reference must be in range');\n return a
rgs[index];\n }\n );\n\n error = new Error(msg)
;\n error.index = index;\n error.description = msg;\n throw
error;\n }\n\n // Throw an exception because of the token.\n\n functio
n throwUnexpected(token) {\n throwError(token, Messages.UnexpectedToken,
token.value);\n }\n\n // Expect the next token to match the specified punc
tuator.\n // If not, an exception will be thrown.\n\n function expect(valu
e) {\n var token = lex();\n if (token.type !== Token.Punctuator ||
token.value !== value) {\n throwUnexpected(token);\n }\n }
\n\n // Return true if the next token matches the specified punctuator.\n\n
function match(value) {\n return lookahead.type === Token.Punctuator &&
lookahead.value === value;\n }\n\n // Return true if the next token match
es the specified keyword\n\n function matchKeyword(keyword) {\n return
lookahead.type === Token.Keyword && lookahead.value === keyword;\n }\n\n
function consumeSemicolon() {\n // Catch the very common case first: imme
diately a semicolon (char #59).\n if (source.charCodeAt(index) === 59) {\
n lex();\n return;\n }\n\n skipWhitespace();
\n\n if (match(';')) {\n lex();\n return;\n
}\n\n if (lookahead.type !== Token.EOF && !match('}')) {\n thr
owUnexpected(lookahead);\n }\n }\n\n // 11.1.4 Array Initialiser\n\
n function parseArrayInitialiser() {\n var elements = [];\n\n e
xpect('[');\n\n while (!match(']')) {\n if (match(',')) {\n
lex();\n elements.push(null);\n } else {\
n elements.push(parseExpression());\n\n if (!match
(']')) {\n expect(',');\n }\n }\n
}\n\n expect(']');\n\n return delegate.createArrayExpression
(elements);\n }\n\n // 11.1.5 Object Initialiser\n\n function parseObje
ctPropertyKey() {\n var token;\n\n skipWhitespace();\n toke
n = lex();\n\n // Note: This function is called only from parseObjectProp
erty(), where\n // EOF and Punctuator tokens are already filtered out.\n
if (token.type === Token.StringLiteral || token.type === Token.NumericLit
eral) {\n return delegate.createLiteral(token);\n }\n\n
return delegate.createIdentifier(token.value);\n }\n\n function parseObje
ctProperty() {\n var token, key;\n\n token = lookahead;\n s
kipWhitespace();\n\n if (token.type === Token.EOF || token.type === Token
.Punctuator) {\n throwUnexpected(token);\n }\n\n key =
parseObjectPropertyKey();\n expect(':');\n return delegate.createP
roperty('init', key, parseExpression());\n }\n\n function parseObjectIniti
aliser() {\n var properties = [];\n\n expect('{');\n\n whil
e (!match('}')) {\n properties.push(parseObjectProperty());\n\n
if (!match('}')) {\n expect(',');\n }\n }
\n\n expect('}');\n\n return delegate.createObjectExpression(prope
rties);\n }\n\n // 11.1.6 The Grouping Operator\n\n function parseGroup
Expression() {\n var expr;\n\n expect('(');\n\n expr = pars
eExpression();\n\n expect(')');\n\n return expr;\n }\n\n\n /
/ 11.1 Primary Expressions\n\n function parsePrimaryExpression() {\n v
ar type, token, expr;\n\n if (match('(')) {\n return parseGrou
pExpression();\n }\n\n type = lookahead.type;\n\n if (type
=== Token.Identifier) {\n expr = delegate.createIdentifier(lex().valu
e);\n } else if (type === Token.StringLiteral || type === Token.NumericLi
teral) {\n expr = delegate.createLiteral(lex());\n } else if (
type === Token.Keyword) {\n if (matchKeyword('this')) {\n
lex();\n expr = delegate.createThisExpression();\n
}\n } else if (type === Token.BooleanLiteral) {\n token = lex
();\n token.value = (token.value === 'true');\n expr = del
egate.createLiteral(token);\n } else if (type === Token.NullLiteral) {\n
token = lex();\n token.value = null;\n expr = d
elegate.createLiteral(token);\n } else if (match('[')) {\n exp
r = parseArrayInitialiser();\n } else if (match('{')) {\n expr
= parseObjectInitialiser();\n }\n\n if (expr) {\n retu
rn expr;\n }\n\n throwUnexpected(lex());\n }\n\n // 11.2 Lef
t-Hand-Side Expressions\n\n function parseArguments() {\n var args = [
];\n\n expect('(');\n\n if (!match(')')) {\n while (ind
ex < length) {\n args.push(parseExpression());\n i
f (match(')')) {\n break;\n }\n
expect(',');\n }\n }\n\n expect(')');\n\n retur
n args;\n }\n\n function parseNonComputedProperty() {\n var token;\
n\n token = lex();\n\n if (!isIdentifierName(token)) {\n
throwUnexpected(token);\n }\n\n return delegate.createIdentifier
(token.value);\n }\n\n function parseNonComputedMember() {\n expect
('.');\n\n return parseNonComputedProperty();\n }\n\n function pars
eComputedMember() {\n var expr;\n\n expect('[');\n\n expr =
parseExpression();\n\n expect(']');\n\n return expr;\n }\n\n
function parseLeftHandSideExpression() {\n var expr, args, property;\n\
n expr = parsePrimaryExpression();\n\n while (true) {\n
if (match('[')) {\n property = parseComputedMember();\n
expr = delegate.createMemberExpression('[', expr, property);\n
} else if (match('.')) {\n property = parseNonComputedMember();\
n expr = delegate.createMemberExpression('.', expr, property);\n
} else if (match('(')) {\n args = parseArguments();\n
expr = delegate.createCallExpression(expr, args);\n }
else {\n break;\n }\n }\n\n return expr;
\n }\n\n // 11.3 Postfix Expressions\n\n var parsePostfixExpression = p
arseLeftHandSideExpression;\n\n // 11.4 Unary Operators\n\n function parse
UnaryExpression() {\n var token, expr;\n\n if (lookahead.type !==
Token.Punctuator && lookahead.type !== Token.Keyword) {\n expr = pars
ePostfixExpression();\n } else if (match('+') || match('-') || match('!')
) {\n token = lex();\n expr = parseUnaryExpression();\n
expr = delegate.createUnaryExpression(token.value, expr);\n } el
se if (matchKeyword('delete') || matchKeyword('void') || matchKeyword('typeof'))
{\n throwError({}, Messages.UnexpectedToken);\n } else {\n
expr = parsePostfixExpression();\n }\n\n return expr;\n
}\n\n function binaryPrecedence(token) {\n var prec = 0;\n\n
if (token.type !== Token.Punctuator && token.type !== Token.Keyword) {\n
return 0;\n }\n\n switch (token.value) {\n case '||':\n
prec = 1;\n break;\n\n case '&&':\n pre
c = 2;\n break;\n\n case '==':\n case '!=':\n ca
se '===':\n case '!==':\n prec = 6;\n break;\n\n
case '<':\n case '>':\n case '<=':\n case '>=':\n
case 'instanceof':\n prec = 7;\n break;\n\n case
'in':\n prec = 7;\n break;\n\n case '+':\n
case '-':\n prec = 9;\n break;\n\n case '*':\n
case '/':\n case '%':\n prec = 11;\n break;\n\n
default:\n break;\n }\n\n return prec;\n }\n\
n // 11.5 Multiplicative Operators\n // 11.6 Additive Operators\n // 11
.7 Bitwise Shift Operators\n // 11.8 Relational Operators\n // 11.9 Equali
ty Operators\n // 11.10 Binary Bitwise Operators\n // 11.11 Binary Logical
Operators\n\n function parseBinaryExpression() {\n var expr, token, p
rec, stack, right, operator, left, i;\n\n left = parseUnaryExpression();\
n\n token = lookahead;\n prec = binaryPrecedence(token);\n
if (prec === 0) {\n return left;\n }\n token.prec = pre
c;\n lex();\n\n right = parseUnaryExpression();\n\n stack =
[left, token, right];\n\n while ((prec = binaryPrecedence(lookahead)) >
0) {\n\n // Reduce: make a binary expression from the three topmost e
ntries.\n while ((stack.length > 2) && (prec <= stack[stack.length -
2].prec)) {\n right = stack.pop();\n operator = st
ack.pop().value;\n left = stack.pop();\n expr = de
legate.createBinaryExpression(operator, left, right);\n stack.pus
h(expr);\n }\n\n // Shift.\n token = lex();\n
token.prec = prec;\n stack.push(token);\n expr =
parseUnaryExpression();\n stack.push(expr);\n }\n\n //
Final reduce to clean-up the stack.\n i = stack.length - 1;\n exp
r = stack[i];\n while (i > 1) {\n expr = delegate.createBinary
Expression(stack[i - 1].value, stack[i - 2], expr);\n i -= 2;\n
}\n\n return expr;\n }\n\n\n // 11.12 Conditional Operator\n\n
function parseConditionalExpression() {\n var expr, consequent, alternat
e;\n\n expr = parseBinaryExpression();\n\n if (match('?')) {\n
lex();\n consequent = parseConditionalExpression();\n
expect(':');\n alternate = parseConditionalExpression();\n\n
expr = delegate.createConditionalExpression(expr, consequent, alternate);
\n }\n\n return expr;\n }\n\n // Simplification since we do
not support AssignmentExpression.\n var parseExpression = parseConditionalExp
ression;\n\n // Polymer Syntax extensions\n\n // Filter ::\n // Ident
ifier\n // Identifier \"(\" \")\"\n // Identifier \"(\" FilterArgument
s \")\"\n\n function parseFilter() {\n var identifier, args;\n\n
identifier = lex();\n\n if (identifier.type !== Token.Identifier) {\n
throwUnexpected(identifier);\n }\n\n args = match('(') ?
parseArguments() : [];\n\n return delegate.createFilter(identifier.value
, args);\n }\n\n // Filters ::\n // \"|\" Filter\n // Filters \"
|\" Filter\n\n function parseFilters() {\n while (match('|')) {\n
lex();\n parseFilter();\n }\n }\n\n // TopLevel :
:\n // LabelledExpressions\n // AsExpression\n // InExpression\n
// FilterExpression\n\n // AsExpression ::\n // FilterExpression as
Identifier\n\n // InExpression ::\n // Identifier, Identifier in Filter
Expression\n // Identifier in FilterExpression\n\n // FilterExpression :
:\n // Expression\n // Expression Filters\n\n function parseTopLeve
l() {\n skipWhitespace();\n peek();\n\n var expr = parseExp
ression();\n if (expr) {\n if (lookahead.value === ',' || look
ahead.value == 'in' &&\n expr.type === Syntax.Identifier)
{\n parseInExpression(expr);\n } else {\n
parseFilters();\n if (lookahead.value === 'as') {\n
parseAsExpression(expr);\n } else {\n
delegate.createTopLevel(expr);\n }\n }\n }\n\n
if (lookahead.type !== Token.EOF) {\n throwUnexpected(lookahe
ad);\n }\n }\n\n function parseAsExpression(expr) {\n lex();
// as\n var identifier = lex().value;\n delegate.createAsExpress
ion(expr, identifier);\n }\n\n function parseInExpression(identifier) {\n
var indexName;\n if (lookahead.value === ',') {\n lex()
;\n if (lookahead.type !== Token.Identifier)\n throwUn
expected(lookahead);\n indexName = lex().value;\n }\n\n
lex(); // in\n var expr = parseExpression();\n parseFilters();\n
delegate.createInExpression(identifier.name, indexName, expr);\n }\n\
n function parse(code, inDelegate) {\n delegate = inDelegate;\n
source = code;\n index = 0;\n length = source.length;\n lo
okahead = null;\n state = {\n labelSet: {}\n };\n\n
return parseTopLevel();\n }\n\n global.esprima = {\n parse: par
se\n };\n})(this);\n\n// Copyright (c) 2014 The Polymer Project Authors. All
rights reserved.\n// This code may only be used under the BSD style license foun
d at http://polymer.github.io/LICENSE.txt\n// The complete set of authors may be
found at http://polymer.github.io/AUTHORS.txt\n// The complete set of contribut
ors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n// Code distribut
ed by Google as part of the polymer project is also\n// subject to an additional
IP rights grant found at http://polymer.github.io/PATENTS.txt\n\n(function (glo
bal) {\n 'use strict';\n\n function prepareBinding(expressionText, name, node,
filterRegistry) {\n var expression;\n try {\n expression = getExpres
sion(expressionText);\n if (expression.scopeIdent &&\n (node.nodeT
ype !== Node.ELEMENT_NODE ||\n node.tagName !== 'TEMPLATE' ||\n
(name !== 'bind' && name !== 'repeat'))) {\n throw Error('as and in c
an only be used within <template bind/repeat>');\n }\n } catch (ex) {\n
console.error('Invalid expression syntax: ' + expressionText, ex);\n r
eturn;\n }\n\n return function(model, node, oneTime) {\n var binding
= expression.getBinding(model, filterRegistry, oneTime);\n if (expression.s
copeIdent && binding) {\n node.polymerExpressionScopeIdent_ = expression.
scopeIdent;\n if (expression.indexIdent)\n node.polymerExpressio
nIndexIdent_ = expression.indexIdent;\n }\n\n return binding;\n }\n
}\n\n // TODO(rafaelw): Implement simple LRU.\n var expressionParseCache = O
bject.create(null);\n\n function getExpression(expressionText) {\n var expre
ssion = expressionParseCache[expressionText];\n if (!expression) {\n var
delegate = new ASTDelegate();\n esprima.parse(expressionText, delegate);\n
expression = new Expression(delegate);\n expressionParseCache[express
ionText] = expression;\n }\n return expression;\n }\n\n function Literal
(value) {\n this.value = value;\n this.valueFn_ = undefined;\n }\n\n Lit
eral.prototype = {\n valueFn: function() {\n if (!this.valueFn_) {\n
var value = this.value;\n this.valueFn_ = function() {\n ret
urn value;\n }\n }\n\n return this.valueFn_;\n }\n }\n\n f
unction IdentPath(name) {\n this.name = name;\n this.path = Path.get(name)
;\n }\n\n IdentPath.prototype = {\n valueFn: function() {\n if (!this.
valueFn_) {\n var name = this.name;\n var path = this.path;\n
this.valueFn_ = function(model, observer) {\n if (observer)\n
observer.addPath(model, path);\n\n return path.getValueFrom(model)
;\n }\n }\n\n return this.valueFn_;\n },\n\n setValue: fu
nction(model, newValue) {\n if (this.path.length == 1);\n model = fi
ndScope(model, this.path[0]);\n\n return this.path.setValueFrom(model, newV
alue);\n }\n };\n\n function MemberExpression(object, property, accessor) {
\n this.computed = accessor == '[';\n\n this.dynamicDeps = typeof object =
= 'function' ||\n object.dynamicDeps ||\n
(this.computed && !(property instanceof Literal));\n\n this.simplePath
=\n !this.dynamicDeps &&\n (property instanceof IdentPath || prope
rty instanceof Literal) &&\n (object instanceof MemberExpression || objec
t instanceof IdentPath);\n\n this.object = this.simplePath ? object : getFn(o
bject);\n this.property = !this.computed || this.simplePath ?\n proper
ty : getFn(property);\n }\n\n MemberExpression.prototype = {\n get fullPath
() {\n if (!this.fullPath_) {\n\n var parts = this.object instanceof
MemberExpression ?\n this.object.fullPath.slice() : [this.object.nam
e];\n parts.push(this.property instanceof IdentPath ?\n this.p
roperty.name : this.property.value);\n this.fullPath_ = Path.get(parts);\
n }\n\n return this.fullPath_;\n },\n\n valueFn: function() {\n
if (!this.valueFn_) {\n var object = this.object;\n\n if (thi
s.simplePath) {\n var path = this.fullPath;\n\n this.valueFn_
= function(model, observer) {\n if (observer)\n observer
.addPath(model, path);\n\n return path.getValueFrom(model);\n
};\n } else if (!this.computed) {\n var path = Path.get(this.p
roperty.name);\n\n this.valueFn_ = function(model, observer, filterRegi
stry) {\n var context = object(model, observer, filterRegistry);\n\n
if (observer)\n observer.addPath(context, path);\n\n
return path.getValueFrom(context);\n }\n } else {\n
// Computed property.\n var property = this.property;\n\n
this.valueFn_ = function(model, observer, filterRegistry) {\n var co
ntext = object(model, observer, filterRegistry);\n var propName = pro
perty(model, observer, filterRegistry);\n if (observer)\n
observer.addPath(context, [propName]);\n\n return context ? context
[propName] : undefined;\n };\n }\n }\n return this.val
ueFn_;\n },\n\n setValue: function(model, newValue) {\n if (this.simp
lePath) {\n this.fullPath.setValueFrom(model, newValue);\n return
newValue;\n }\n\n var object = this.object(model);\n var propName
= this.property instanceof IdentPath ? this.property.name :\n this.pro
perty(model);\n return object[propName] = newValue;\n }\n };\n\n funct
ion Filter(name, args) {\n this.name = name;\n this.args = [];\n for (v
ar i = 0; i < args.length; i++) {\n this.args[i] = getFn(args[i]);\n }\n
}\n\n Filter.prototype = {\n transform: function(model, observer, filterRe
gistry, toModelDirection,\n initialArgs) {\n var fn
= filterRegistry[this.name];\n var context = model;\n if (fn) {\n
context = undefined;\n } else {\n fn = context[this.name];\n
if (!fn) {\n console.error('Cannot find function or filter: ' + this
.name);\n return;\n }\n }\n\n // If toModelDirection i
s falsey, then the \"normal\" (dom-bound) direction\n // is used. Otherwise
, it looks for a 'toModel' property function on the\n // object.\n if
(toModelDirection) {\n fn = fn.toModel;\n } else if (typeof fn.toDOM
== 'function') {\n fn = fn.toDOM;\n }\n\n if (typeof fn != 'fu
nction') {\n console.error('Cannot find function or filter: ' + this.name
);\n return;\n }\n\n var args = initialArgs || [];\n for (
var i = 0; i < this.args.length; i++) {\n args.push(getFn(this.args[i])(m
odel, observer, filterRegistry));\n }\n\n return fn.apply(context, arg
s);\n }\n };\n\n function notImplemented() { throw Error('Not Implemented')
; }\n\n var unaryOperators = {\n '+': function(v) { return +v; },\n '-':
function(v) { return -v; },\n '!': function(v) { return !v; }\n };\n\n var
binaryOperators = {\n '+': function(l, r) { return l+r; },\n '-': function
(l, r) { return l-r; },\n '*': function(l, r) { return l*r; },\n '/': func
tion(l, r) { return l/r; },\n '%': function(l, r) { return l%r; },\n '<':
function(l, r) { return l<r; },\n '>': function(l, r) { return l>r; },\n '
<=': function(l, r) { return l<=r; },\n '>=': function(l, r) { return l>=r; }
,\n '==': function(l, r) { return l==r; },\n '!=': function(l, r) { return
l!=r; },\n '===': function(l, r) { return l===r; },\n '!==': function(l,
r) { return l!==r; },\n '&&': function(l, r) { return l&&r; },\n '||': fun
ction(l, r) { return l||r; },\n };\n\n function getFn(arg) {\n return typeo
f arg == 'function' ? arg : arg.valueFn();\n }\n\n function ASTDelegate() {\n
this.expression = null;\n this.filters = [];\n this.deps = {};\n thi
s.currentPath = undefined;\n this.scopeIdent = undefined;\n this.indexIden
t = undefined;\n this.dynamicDeps = false;\n }\n\n ASTDelegate.prototype =
{\n createUnaryExpression: function(op, argument) {\n if (!unaryOperator
s[op])\n throw Error('Disallowed operator: ' + op);\n\n argument = g
etFn(argument);\n\n return function(model, observer, filterRegistry) {\n
return unaryOperators[op](argument(model, observer, filterRegistry));\n
};\n },\n\n createBinaryExpression: function(op, left, right) {\n i
f (!binaryOperators[op])\n throw Error('Disallowed operator: ' + op);\n\n
left = getFn(left);\n right = getFn(right);\n\n switch (op) {\n
case '||':\n this.dynamicDeps = true;\n return function
(model, observer, filterRegistry) {\n return left(model, observer, fi
lterRegistry) ||\n right(model, observer, filterRegistry);\n
};\n case '&&':\n this.dynamicDeps = true;\n retur
n function(model, observer, filterRegistry) {\n return left(model, ob
server, filterRegistry) &&\n right(model, observer, filterRegistr
y);\n };\n }\n\n return function(model, observer, filterRegis
try) {\n return binaryOperators[op](left(model, observer, filterRegistry)
,\n right(model, observer, filterRegistry));\n
};\n },\n\n createConditionalExpression: function(test, consequent,
alternate) {\n test = getFn(test);\n consequent = getFn(consequent);\n
alternate = getFn(alternate);\n\n this.dynamicDeps = true;\n\n r
eturn function(model, observer, filterRegistry) {\n return test(model, ob
server, filterRegistry) ?\n consequent(model, observer, filterRegistr
y) :\n alternate(model, observer, filterRegistry);\n }\n },\n
\n createIdentifier: function(name) {\n var ident = new IdentPath(name);
\n ident.type = 'Identifier';\n return ident;\n },\n\n createMem
berExpression: function(accessor, object, property) {\n var ex = new Member
Expression(object, property, accessor);\n if (ex.dynamicDeps)\n this
.dynamicDeps = true;\n return ex;\n },\n\n createCallExpression: func
tion(expression, args) {\n if (!(expression instanceof IdentPath))\n
throw Error('Only identifier function invocations are allowed');\n\n var f
ilter = new Filter(expression.name, args);\n\n return function(model, obser
ver, filterRegistry) {\n return filter.transform(model, observer, filterR
egistry, false);\n };\n },\n\n createLiteral: function(token) {\n
return new Literal(token.value);\n },\n\n createArrayExpression: functio
n(elements) {\n for (var i = 0; i < elements.length; i++)\n elements
[i] = getFn(elements[i]);\n\n return function(model, observer, filterRegist
ry) {\n var arr = []\n for (var i = 0; i < elements.length; i++)\n
arr.push(elements[i](model, observer, filterRegistry));\n retur
n arr;\n }\n },\n\n createProperty: function(kind, key, value) {\n
return {\n key: key instanceof IdentPath ? key.name : key.value,\n
value: value\n };\n },\n\n createObjectExpression: function(prope
rties) {\n for (var i = 0; i < properties.length; i++)\n properties[
i].value = getFn(properties[i].value);\n\n return function(model, observer,
filterRegistry) {\n var obj = {};\n for (var i = 0; i < propertie
s.length; i++)\n obj[properties[i].key] =\n properties[i].
value(model, observer, filterRegistry);\n return obj;\n }\n },\n\
n createFilter: function(name, args) {\n this.filters.push(new Filter(na
me, args));\n },\n\n createAsExpression: function(expression, scopeIdent)
{\n this.expression = expression;\n this.scopeIdent = scopeIdent;\n
},\n\n createInExpression: function(scopeIdent, indexIdent, expression) {\n
this.expression = expression;\n this.scopeIdent = scopeIdent;\n t
his.indexIdent = indexIdent;\n },\n\n createTopLevel: function(expression)
{\n this.expression = expression;\n },\n\n createThisExpression: not
Implemented\n }\n\n function ConstantObservable(value) {\n this.value_ = va
lue;\n }\n\n ConstantObservable.prototype = {\n open: function() { return t
his.value_; },\n discardChanges: function() { return this.value_; },\n del
iver: function() {},\n close: function() {},\n }\n\n function Expression(de
legate) {\n this.scopeIdent = delegate.scopeIdent;\n this.indexIdent = del
egate.indexIdent;\n\n if (!delegate.expression)\n throw Error('No expres
sion found.');\n\n this.expression = delegate.expression;\n getFn(this.exp
ression); // forces enumeration of path dependencies\n\n this.filters = deleg
ate.filters;\n this.dynamicDeps = delegate.dynamicDeps;\n }\n\n Expression.
prototype = {\n getBinding: function(model, filterRegistry, oneTime) {\n
if (oneTime)\n return this.getValue(model, undefined, filterRegistry);\n
\n var observer = new CompoundObserver();\n // captures deps.\n v
ar firstValue = this.getValue(model, observer, filterRegistry);\n var first
Time = true;\n var self = this;\n\n function valueFn() {\n // d
eps cannot have changed on first value retrieval.\n if (firstTime) {\n
firstTime = false;\n return firstValue;\n }\n\n if
(self.dynamicDeps)\n observer.startReset();\n\n var value = sel
f.getValue(model,\n self.dynamicDeps ? observer
: undefined,\n filterRegistry);\n if (s
elf.dynamicDeps)\n observer.finishReset();\n\n return value;\n
}\n\n function setValueFn(newValue) {\n self.setValue(model, new
Value, filterRegistry);\n return newValue;\n }\n\n return new O
bserverTransform(observer, valueFn, setValueFn, true);\n },\n\n getValue:
function(model, observer, filterRegistry) {\n var value = getFn(this.expres
sion)(model, observer, filterRegistry);\n for (var i = 0; i < this.filters.
length; i++) {\n value = this.filters[i].transform(model, observer, filte
rRegistry,\n false, [value]);\n }\n\n return value;\n },
\n\n setValue: function(model, newValue, filterRegistry) {\n var count =
this.filters ? this.filters.length : 0;\n while (count-- > 0) {\n n
ewValue = this.filters[count].transform(model, undefined,\n filterReg
istry, true, [newValue]);\n }\n\n if (this.expression.setValue)\n
return this.expression.setValue(model, newValue);\n }\n }\n\n /**\n *
Converts a style property name to a css property name. For example:\n * \"Webk
itUserSelect\" to \"-webkit-user-select\"\n */\n function convertStylePropert
yName(name) {\n return String(name).replace(/[A-Z]/g, function(c) {\n re
turn '-' + c.toLowerCase();\n });\n }\n\n var parentScopeName = '@' + Math.
random().toString(36).slice(2);\n\n // Single ident paths must bind directly to
the appropriate scope object.\n // I.e. Pushed values in two-bindings need to
be assigned to the actual model\n // object.\n function findScope(model, prop)
{\n while (model[parentScopeName] &&\n !Object.prototype.hasOwnPro
perty.call(model, prop)) {\n model = model[parentScopeName];\n }\n\n
return model;\n }\n\n function isLiteralExpression(pathString) {\n switch (
pathString) {\n case '':\n return false;\n\n case 'false':\n
case 'null':\n case 'true':\n return true;\n }\n\n if (!isN
aN(Number(pathString)))\n return true;\n\n return false;\n };\n\n func
tion PolymerExpressions() {}\n\n PolymerExpressions.prototype = {\n // \"bui
lt-in\" filters\n styleObject: function(value) {\n var parts = [];\n
for (var key in value) {\n parts.push(convertStylePropertyName(key) + '
: ' + value[key]);\n }\n return parts.join('; ');\n },\n\n token
List: function(value) {\n var tokens = [];\n for (var key in value) {\
n if (value[key])\n tokens.push(key);\n }\n return tok
ens.join(' ');\n },\n\n // binding delegate API\n prepareInstancePositi
onChanged: function(template) {\n var indexIdent = template.polymerExpressi
onIndexIdent_;\n if (!indexIdent)\n return;\n\n return function
(templateInstance, index) {\n templateInstance.model[indexIdent] = index;
\n };\n },\n\n prepareBinding: function(pathString, name, node) {\n
var path = Path.get(pathString);\n\n if (!isLiteralExpression(pathStrin
g) && path.valid) {\n if (path.length == 1) {\n return function(
model, node, oneTime) {\n if (oneTime)\n return path.get
ValueFrom(model);\n\n var scope = findScope(model, path[0]);\n
return new PathObserver(scope, path);\n };\n }\n ret
urn; // bail out early if pathString is simple path.\n }\n\n return pr
epareBinding(pathString, name, node, this);\n },\n\n prepareInstanceModel:
function(template) {\n var scopeName = template.polymerExpressionScopeIden
t_;\n if (!scopeName)\n return;\n\n var parentScope = template.
templateInstance ?\n template.templateInstance.model :\n templ
ate.model;\n\n var indexName = template.polymerExpressionIndexIdent_;\n\n
return function(model) {\n return createScopeObject(parentScope, mode
l, scopeName, indexName);\n };\n }\n };\n\n var createScopeObject = ('
__proto__' in {}) ?\n function(parentScope, model, scopeName, indexName) {\n
var scope = {};\n scope[scopeName] = model;\n scope[indexName] =
undefined;\n scope[parentScopeName] = parentScope;\n scope.__proto__ =
parentScope;\n return scope;\n } :\n function(parentScope, model, sc
opeName, indexName) {\n var scope = Object.create(parentScope);\n Obje
ct.defineProperty(scope, scopeName,\n { value: model, configurable: tru
e, writable: true });\n Object.defineProperty(scope, indexName,\n
{ value: undefined, configurable: true, writable: true });\n Object.defineP
roperty(scope, parentScopeName,\n { value: parentScope, configurable: t
rue, writable: true });\n return scope;\n };\n\n global.PolymerExpressi
ons = PolymerExpressions;\n PolymerExpressions.getExpression = getExpression;\n
})(this);\n\n/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights r
eserved.\n * This code may only be used under the BSD style license found at htt
p://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found a
t http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may
be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Go
ogle as part of the polymer project is also\n * subject to an additional IP righ
ts grant found at http://polymer.github.io/PATENTS.txt\n */\nPolymer = {\n vers
ion: '0.4.2'\n};\n\n/*\n * Copyright (c) 2014 The Polymer Project Authors. All r
ights reserved.\n * This code may only be used under the BSD style license found
at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be
found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributo
rs may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distribute
d by Google as part of the polymer project is also\n * subject to an additional
IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n// TODO(so
rvell): this ensures Polymer is an object and not a function\n// Platform is cur
rently defining it as a function to allow for async loading\n// of polymer; once
we refine the loading process this likely goes away.\nif (typeof window.Polymer
=== 'function') {\n Polymer = {};\n}\n\n\n/*\n * Copyright (c) 2014 The Polyme
r Project Authors. All rights reserved.\n * This code may only be used under the
BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complet
e set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The co
mplete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS
.txt\n * Code distributed by Google as part of the polymer project is also\n * s
ubject to an additional IP rights grant found at http://polymer.github.io/PATENT
S.txt\n */\n\n /*\n\tOn supported platforms, platform.js is not needed. To retai
n compatibility\n\twith the polyfills, we stub out minimal functionality.\n */\n
if (!window.Platform) {\n logFlags = window.logFlags || {};\n\n\n Platform = {
\n \tflush: function() {}\n };\n\n CustomElements = {\n \tuseNative: true,\n
ready: true,\n takeRecords: function() {},\n instanceof: function(obj,
base) {\n return obj instanceof base;\n }\n };\n \n HTMLImports = {\
n \tuseNative: true\n };\n\n \n addEventListener('HTMLImportsLoaded', functi
on() {\n document.dispatchEvent(\n new CustomEvent('WebComponentsReady',
{bubbles: true})\n );\n });\n\n\n // ShadowDOM\n ShadowDOMPolyfill = null
;\n wrap = unwrap = function(n){\n return n;\n };\n\n}\n\n/*\r\n * Copyrigh
t (c) 2014 The Polymer Project Authors. All rights reserved.\r\n * This code may
only be used under the BSD style license found at http://polymer.github.io/LICE
NSE.txt\r\n * The complete set of authors may be found at http://polymer.github.
io/AUTHORS.txt\r\n * The complete set of contributors may be found at http://pol
ymer.github.io/CONTRIBUTORS.txt\r\n * Code distributed by Google as part of the
polymer project is also\r\n * subject to an additional IP rights grant found at
http://polymer.github.io/PATENTS.txt\r\n */\r\n\r\n(function(scope) {\r\n\r\nvar
IMPORT_LINK_TYPE = 'import';\r\nvar hasNative = (IMPORT_LINK_TYPE in document.c
reateElement('link'));\r\nvar useNative = hasNative;\r\nvar isIE = /Trident/.tes
t(navigator.userAgent);\r\n\r\n// TODO(sorvell): SD polyfill intrusion\r\nvar ha
sShadowDOMPolyfill = Boolean(window.ShadowDOMPolyfill);\r\nvar wrap = function(n
ode) {\r\n return hasShadowDOMPolyfill ? ShadowDOMPolyfill.wrapIfNeeded(node) :
node;\r\n};\r\n\r\nvar rootDocument = wrap(document);\r\n \r\n// NOTE: We ca
nnot polyfill document.currentScript because it's not possible\r\n// both to ove
rride and maintain the ability to capture the native value;\r\n// therefore we c
hoose to expose _currentScript both when native imports\r\n// and the polyfill a
re in use.\r\nvar currentScriptDescriptor = {\r\n get: function() {\r\n var
script = HTMLImports.currentScript || document.currentScript ||\r\n // NO
TE: only works when called in synchronously executing code.\r\n // readyS
tate should check if `loading` but IE10 is \r\n // interactive when scrip
ts run so we cheat.\r\n (document.readyState !== 'complete' ? \r\n
document.scripts[document.scripts.length - 1] : null);\r\n return wrap(scrip
t);\r\n },\r\n configurable: true\r\n};\r\n\r\nObject.defineProperty(document,
'_currentScript', currentScriptDescriptor);\r\nObject.defineProperty(rootDocume
nt, '_currentScript', currentScriptDescriptor);\r\n\r\n// call a callback when a
ll HTMLImports in the document at call (or at least\r\n// document ready) time
have loaded.\r\n// 1. ensure the document is in a ready state (has dom), then \r
\n// 2. watch for loading of imports and call callback when done\r\nfunction whe
nReady(callback, doc) {\r\n doc = doc || rootDocument;\r\n // if document is l
oading, wait and try again\r\n whenDocumentReady(function() {\r\n watchImpor
tsLoad(callback, doc);\r\n }, doc);\r\n}\r\n\r\n// call the callback when the d
ocument is in a ready state (has dom)\r\nvar requiredReadyState = isIE ? 'comple
te' : 'interactive';\r\nvar READY_EVENT = 'readystatechange';\r\nfunction isDocu
mentReady(doc) {\r\n return (doc.readyState === 'complete' ||\r\n doc.read
yState === requiredReadyState);\r\n}\r\n\r\n// call <callback> when we ensure th
e document is in a ready state\r\nfunction whenDocumentReady(callback, doc) {\r\
n if (!isDocumentReady(doc)) {\r\n var checkReady = function() {\r\n if
(doc.readyState === 'complete' || \r\n doc.readyState === requiredRead
yState) {\r\n doc.removeEventListener(READY_EVENT, checkReady);\r\n
whenDocumentReady(callback, doc);\r\n }\r\n };\r\n doc.addEventList
ener(READY_EVENT, checkReady);\r\n } else if (callback) {\r\n callback();\r\
n }\r\n}\r\n\r\nfunction markTargetLoaded(event) {\r\n event.target.__loaded =
true;\r\n}\r\n\r\n// call <callback> when we ensure all imports have loaded\r\n
function watchImportsLoad(callback, doc) {\r\n var imports = doc.querySelectorA
ll('link[rel=import]');\r\n var loaded = 0, l = imports.length;\r\n function c
heckDone(d) { \r\n if ((loaded == l) && callback) {\r\n callback();\r\n
}\r\n }\r\n function loadedImport(e) {\r\n markTargetLoaded(e);\r\n
loaded++;\r\n checkDone();\r\n }\r\n if (l) {\r\n for (var i=0, imp; (i<
l) && (imp=imports[i]); i++) {\r\n if (isImportLoaded(imp)) {\r\n lo
adedImport.call(imp, {target: imp});\r\n } else {\r\n imp.addEventLi
stener('load', loadedImport);\r\n imp.addEventListener('error', loadedImp
ort);\r\n }\r\n }\r\n } else {\r\n checkDone();\r\n }\r\n}\r\n\r\n/
/ NOTE: test for native imports loading is based on explicitly watching\r\n// al
l imports (see below).\r\n// We cannot rely on this entirely without watching th
e entire document\r\n// for import links. For perf reasons, currently only head
is watched.\r\n// Instead, we fallback to checking if the import property is ava
ilable \r\n// and the document is not itself loading. \r\nfunction isImportLoade
d(link) {\r\n return useNative ? link.__loaded || \r\n (link.import && lin
k.import.readyState !== 'loading') :\r\n link.__importParsed;\r\n}\r\n\r\n/
/ TODO(sorvell): Workaround for \r\n// https://www.w3.org/Bugs/Public/show_bug.c
gi?id=25007, should be removed when\r\n// this bug is addressed.\r\n// (1) Insta
ll a mutation observer to see when HTMLImports have loaded\r\n// (2) if this scr
ipt is run during document load it will watch any existing\r\n// imports for loa
ding.\r\n//\r\n// NOTE: The workaround has restricted functionality: (1) it's on
ly compatible\r\n// with imports that are added to document.head since the mutat
ion observer \r\n// watches only head for perf reasons, (2) it requires this scr
ipt\r\n// to run before any imports have completed loading.\r\nif (useNative) {\
r\n new MutationObserver(function(mxns) {\r\n for (var i=0, l=mxns.length, m
; (i < l) && (m=mxns[i]); i++) {\r\n if (m.addedNodes) {\r\n handleI
mports(m.addedNodes);\r\n }\r\n }\r\n }).observe(document.head, {childL
ist: true});\r\n\r\n function handleImports(nodes) {\r\n for (var i=0, l=nod
es.length, n; (i<l) && (n=nodes[i]); i++) {\r\n if (isImport(n)) {\r\n
handleImport(n); \r\n }\r\n }\r\n }\r\n\r\n function isImport(elem
ent) {\r\n return element.localName === 'link' && element.rel === 'import';\r
\n }\r\n\r\n function handleImport(element) {\r\n var loaded = element.impo
rt;\r\n if (loaded) {\r\n markTargetLoaded({target: element});\r\n }
else {\r\n element.addEventListener('load', markTargetLoaded);\r\n ele
ment.addEventListener('error', markTargetLoaded);\r\n }\r\n }\r\n\r\n // ma
ke sure to catch any imports that are in the process of loading\r\n // when thi
s script is run.\r\n (function() {\r\n if (document.readyState === 'loading'
) {\r\n var imports = document.querySelectorAll('link[rel=import]');\r\n
for (var i=0, l=imports.length, imp; (i<l) && (imp=imports[i]); i++) {\r\n
handleImport(imp);\r\n }\r\n }\r\n })();\r\n\r\n}\r\n\r\n// Fire t
he 'HTMLImportsLoaded' event when imports in document at load time \r\n// have l
oaded. This event is required to simulate the script blocking \r\n// behavior of
native imports. A main document script that needs to be sure\r\n// imports have
loaded should wait for this event.\r\nwhenReady(function() {\r\n HTMLImports.r
eady = true;\r\n HTMLImports.readyTime = new Date().getTime();\r\n rootDocumen
t.dispatchEvent(\r\n new CustomEvent('HTMLImportsLoaded', {bubbles: true})\r\
n );\r\n});\r\n\r\n// exports\r\nscope.useNative = useNative;\r\nscope.isImport
Loaded = isImportLoaded;\r\nscope.whenReady = whenReady;\r\nscope.rootDocument =
rootDocument;\r\nscope.IMPORT_LINK_TYPE = IMPORT_LINK_TYPE;\r\nscope.isIE = isI
E;\r\n\r\n})(window.HTMLImports);\n/*\n * Copyright (c) 2014 The Polymer Project
Authors. All rights reserved.\n * This code may only be used under the BSD styl
e license found at http://polymer.github.io/LICENSE.txt\n * The complete set of
authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete se
t of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n *
Code distributed by Google as part of the polymer project is also\n * subject to
an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n *
/\n\n(function(scope) {\n\n function withDependencies(task, depends) {\n dep
ends = depends || [];\n if (!depends.map) {\n depends = [depends];\n
}\n return task.apply(this, depends.map(marshal));\n }\n\n function module(
name, dependsOrFactory, moduleFactory) {\n var module;\n switch (arguments
.length) {\n case 0:\n return;\n case 1:\n module = null
;\n break;\n case 2:\n // dependsOrFactory is `factory` in th
is case\n module = dependsOrFactory.apply(this);\n break;\n d
efault:\n // dependsOrFactory is `depends` in this case\n module =
withDependencies(moduleFactory, dependsOrFactory);\n break;\n }\n
modules[name] = module;\n };\n\n function marshal(name) {\n return modules[
name];\n }\n\n var modules = {};\n\n function using(depends, task) {\n HTM
LImports.whenImportsReady(function() {\n withDependencies(task, depends);\n
});\n };\n\n // exports\n\n scope.marshal = marshal;\n // `module` confu
ses commonjs detectors\n scope.modularize = module;\n scope.using = using;\n\n
})(window);\n\n/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights
reserved.\n * This code may only be used under the BSD style license found at h
ttp://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found
at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors ma
y be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by
Google as part of the polymer project is also\n * subject to an additional IP ri
ghts grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope
) {\n\n // TODO(sorvell): It's desireable to provide a default stylesheet \n /
/ that's convenient for styling unresolved elements, but\n // it's cumbersome t
o have to include this manually in every page.\n // It would make sense to put
inside some HTMLImport but \n // the HTMLImports polyfill does not allow loadin
g of stylesheets \n // that block rendering. Therefore this injection is tolera
ted here.\n var style = document.createElement('style');\n style.textContent =
''\n + 'body {'\n + 'transition: opacity ease-in 0.2s;' \n + ' }
\\n'\n + 'body[unresolved] {'\n + 'opacity: 0; display: block; overfl
ow: hidden;' \n + ' } \\n'\n ;\n var head = document.querySelector('h
ead');\n head.insertBefore(style, head.firstChild);\n\n})(Platform);\n\n/*\n *
Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This co
de may only be used under the BSD style license found at http://polymer.github.i
o/LICENSE.txt\n * The complete set of authors may be found at http://polymer.git
hub.io/AUTHORS.txt\n * The complete set of contributors may be found at http://p
olymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the
polymer project is also\n * subject to an additional IP rights grant found at ht
tp://polymer.github.io/PATENTS.txt\n */\n\n(function(global) {\n 'use strict';\
n\n var testingExposeCycleCount = global.testingExposeCycleCount;\n\n // Detec
t and do basic sanity checking on Object/Array.observe.\n function detectObject
Observe() {\n if (typeof Object.observe !== 'function' ||\n typeof Arr
ay.observe !== 'function') {\n return false;\n }\n\n var records = []
;\n\n function callback(recs) {\n records = recs;\n }\n\n var test
= {};\n var arr = [];\n Object.observe(test, callback);\n Array.observ
e(arr, callback);\n test.id = 1;\n test.id = 2;\n delete test.id;\n
arr.push(1, 2);\n arr.length = 0;\n\n Object.deliverChangeRecords(callback
);\n if (records.length !== 5)\n return false;\n\n if (records[0].typ
e != 'add' ||\n records[1].type != 'update' ||\n records[2].type !
= 'delete' ||\n records[3].type != 'splice' ||\n records[4].type !
= 'splice') {\n return false;\n }\n\n Object.unobserve(test, callback
);\n Array.unobserve(arr, callback);\n\n return true;\n }\n\n var hasObs
erve = detectObjectObserve();\n\n function detectEval() {\n // Don't test fo
r eval if we're running in a Chrome App environment.\n // We check for APIs s
et that only exist in a Chrome App context.\n if (typeof chrome !== 'undefine
d' && chrome.app && chrome.app.runtime) {\n return false;\n }\n\n //
Firefox OS Apps do not allow eval. This feature detection is very hacky\n //
but even if some other platform adds support for this function this code\n //
will continue to work.\n if (typeof navigator != 'undefined' && navigator.ge
tDeviceStorage) {\n return false;\n }\n\n try {\n var f = new Fu
nction('', 'return true;');\n return f();\n } catch (ex) {\n return
false;\n }\n }\n\n var hasEval = detectEval();\n\n function isIndex(s) {\
n return +s === s >>> 0 && s !== '';\n }\n\n function toNumber(s) {\n re
turn +s;\n }\n\n function isObject(obj) {\n return obj === Object(obj);\n
}\n\n var numberIsNaN = global.Number.isNaN || function(value) {\n return ty
peof value === 'number' && global.isNaN(value);\n }\n\n function areSameValue(
left, right) {\n if (left === right)\n return left !== 0 || 1 / left ===
1 / right;\n if (numberIsNaN(left) && numberIsNaN(right))\n return true
;\n\n return left !== left && right !== right;\n }\n\n var createObject = (
'__proto__' in {}) ?\n function(obj) { return obj; } :\n function(obj) {\n
var proto = obj.__proto__;\n if (!proto)\n return obj;\n
var newObject = Object.create(proto);\n Object.getOwnPropertyNames(obj).for
Each(function(name) {\n Object.defineProperty(newObject, name,\n
Object.getOwnPropertyDescriptor(obj, name));\n });\n
return newObject;\n };\n\n var identStart = '[\\$_a-zA-Z]';\n var identP
art = '[\\$_a-zA-Z0-9]';\n var identRegExp = new RegExp('^' + identStart + '+'
+ identPart + '*' + '$');\n\n function getPathCharType(char) {\n if (char ==
= undefined)\n return 'eof';\n\n var code = char.charCodeAt(0);\n\n s
witch(code) {\n case 0x5B: // [\n case 0x5D: // ]\n case 0x2E: //
.\n case 0x22: // \"\n case 0x27: // '\n case 0x30: // 0\n
return char;\n\n case 0x5F: // _\n case 0x24: // $\n return '
ident';\n\n case 0x20: // Space\n case 0x09: // Tab\n case 0x0A:
// Newline\n case 0x0D: // Return\n case 0xA0: // No-break space\n
case 0xFEFF: // Byte Order Mark\n case 0x2028: // Line Separator\n
case 0x2029: // Paragraph Separator\n return 'ws';\n }\n\n // a-
z, A-Z\n if ((0x61 <= code && code <= 0x7A) || (0x41 <= code && code <= 0x5A)
)\n return 'ident';\n\n // 1-9\n if (0x31 <= code && code <= 0x39)\n
return 'number';\n\n return 'else';\n }\n\n var pathStateMachine = {\n
'beforePath': {\n 'ws': ['beforePath'],\n 'ident': ['inIdent', 'ap
pend'],\n '[': ['beforeElement'],\n 'eof': ['afterPath']\n },\n\n
'inPath': {\n 'ws': ['inPath'],\n '.': ['beforeIdent'],\n '[':
['beforeElement'],\n 'eof': ['afterPath']\n },\n\n 'beforeIdent': {\n
'ws': ['beforeIdent'],\n 'ident': ['inIdent', 'append']\n },\n\n
'inIdent': {\n 'ident': ['inIdent', 'append'],\n '0': ['inIdent', 'a
ppend'],\n 'number': ['inIdent', 'append'],\n 'ws': ['inPath', 'push']
,\n '.': ['beforeIdent', 'push'],\n '[': ['beforeElement', 'push'],\n
'eof': ['afterPath', 'push']\n },\n\n 'beforeElement': {\n 'ws':
['beforeElement'],\n '0': ['afterZero', 'append'],\n 'number': ['inIn
dex', 'append'],\n \"'\": ['inSingleQuote', 'append', ''],\n '\"': ['i
nDoubleQuote', 'append', '']\n },\n\n 'afterZero': {\n 'ws': ['afterE
lement', 'push'],\n ']': ['inPath', 'push']\n },\n\n 'inIndex': {\n
'0': ['inIndex', 'append'],\n 'number': ['inIndex', 'append'],\n '
ws': ['afterElement'],\n ']': ['inPath', 'push']\n },\n\n 'inSingleQu
ote': {\n \"'\": ['afterElement'],\n 'eof': ['error'],\n 'else':
['inSingleQuote', 'append']\n },\n\n 'inDoubleQuote': {\n '\"': ['aft
erElement'],\n 'eof': ['error'],\n 'else': ['inDoubleQuote', 'append']
\n },\n\n 'afterElement': {\n 'ws': ['afterElement'],\n ']': ['i
nPath', 'push']\n }\n }\n\n function noop() {}\n\n function parsePath(path
) {\n var keys = [];\n var index = -1;\n var c, newChar, key, type, tra
nsition, action, typeMap, mode = 'beforePath';\n\n var actions = {\n pus
h: function() {\n if (key === undefined)\n return;\n\n ke
ys.push(key);\n key = undefined;\n },\n\n append: function() {\
n if (key === undefined)\n key = newChar\n else\n
key += newChar;\n }\n };\n\n function maybeUnescapeQuote() {\n
if (index >= path.length)\n return;\n\n var nextChar = path[index +
1];\n if ((mode == 'inSingleQuote' && nextChar == \"'\") ||\n (mo
de == 'inDoubleQuote' && nextChar == '\"')) {\n index++;\n newChar
= nextChar;\n actions.append();\n return true;\n }\n }\n\
n while (mode) {\n index++;\n c = path[index];\n\n if (c == '\
\\\' && maybeUnescapeQuote(mode))\n continue;\n\n type = getPathChar
Type(c);\n typeMap = pathStateMachine[mode];\n transition = typeMap[ty
pe] || typeMap['else'] || 'error';\n\n if (transition == 'error')\n
return; // parse error;\n\n mode = transition[0];\n action = actions[t
ransition[1]] || noop;\n newChar = transition[2] === undefined ? c : transi
tion[2];\n action();\n\n if (mode === 'afterPath') {\n return k
eys;\n }\n }\n\n return; // parse error\n }\n\n function isIdent(s)
{\n return identRegExp.test(s);\n }\n\n var constructorIsPrivate = {};\n\n
function Path(parts, privateToken) {\n if (privateToken !== constructorIsPr
ivate)\n throw Error('Use Path.get to retrieve path objects');\n\n for (
var i = 0; i < parts.length; i++) {\n this.push(String(parts[i]));\n }\n
\n if (hasEval && this.length) {\n this.getValueFrom = this.compiledGetV
alueFromFn();\n }\n }\n\n // TODO(rafaelw): Make simple LRU cache\n var pa
thCache = {};\n\n function getPath(pathString) {\n if (pathString instanceof
Path)\n return pathString;\n\n if (pathString == null || pathString.len
gth == 0)\n pathString = '';\n\n if (typeof pathString != 'string') {\n
if (isIndex(pathString.length)) {\n // Constructed with array-like (
pre-parsed) keys\n return new Path(pathString, constructorIsPrivate);\n
}\n\n pathString = String(pathString);\n }\n\n var path = pathCac
he[pathString];\n if (path)\n return path;\n\n var parts = parsePath(
pathString);\n if (!parts)\n return invalidPath;\n\n var path = new P
ath(parts, constructorIsPrivate);\n pathCache[pathString] = path;\n return
path;\n }\n\n Path.get = getPath;\n\n function formatAccessor(key) {\n if
(isIndex(key)) {\n return '[' + key + ']';\n } else {\n return '[\
"' + key.replace(/\"/g, '\\\\\"') + '\"]';\n }\n }\n\n Path.prototype = cre
ateObject({\n __proto__: [],\n valid: true,\n\n toString: function() {\
n var pathString = '';\n for (var i = 0; i < this.length; i++) {\n
var key = this[i];\n if (isIdent(key)) {\n pathString += i ?
'.' + key : key;\n } else {\n pathString += formatAccessor(key)
;\n }\n }\n\n return pathString;\n },\n\n getValueFrom: f
unction(obj, directObserver) {\n for (var i = 0; i < this.length; i++) {\n
if (obj == null)\n return;\n obj = obj[this[i]];\n }
\n return obj;\n },\n\n iterateObjects: function(obj, observe) {\n
for (var i = 0; i < this.length; i++) {\n if (i)\n obj = obj[
this[i - 1]];\n if (!isObject(obj))\n return;\n observe(o
bj, this[0]);\n }\n },\n\n compiledGetValueFromFn: function() {\n
var str = '';\n var pathString = 'obj';\n str += 'if (obj != null';\
n var i = 0;\n var key;\n for (; i < (this.length - 1); i++) {\n
key = this[i];\n pathString += isIdent(key) ? '.' + key : formatAc
cessor(key);\n str += ' &&\\n ' + pathString + ' != null';\n }\n
str += ')\\n';\n\n var key = this[i];\n pathString += isIdent(ke
y) ? '.' + key : formatAccessor(key);\n\n str += ' return ' + pathString +
';\\nelse\\n return undefined;';\n return new Function('obj', str);\n
},\n\n setValueFrom: function(obj, value) {\n if (!this.length)\n
return false;\n\n for (var i = 0; i < this.length - 1; i++) {\n if
(!isObject(obj))\n return false;\n obj = obj[this[i]];\n }\
n\n if (!isObject(obj))\n return false;\n\n obj[this[i]] = valu
e;\n return true;\n }\n });\n\n var invalidPath = new Path('', constru
ctorIsPrivate);\n invalidPath.valid = false;\n invalidPath.getValueFrom = inva
lidPath.setValueFrom = function() {};\n\n var MAX_DIRTY_CHECK_CYCLES = 1000;\n\
n function dirtyCheck(observer) {\n var cycles = 0;\n while (cycles < MAX
_DIRTY_CHECK_CYCLES && observer.check_()) {\n cycles++;\n }\n if (tes
tingExposeCycleCount)\n global.dirtyCheckCycleCount = cycles;\n\n return
cycles > 0;\n }\n\n function objectIsEmpty(object) {\n for (var prop in ob
ject)\n return false;\n return true;\n }\n\n function diffIsEmpty(diff
) {\n return objectIsEmpty(diff.added) &&\n objectIsEmpty(diff.remo
ved) &&\n objectIsEmpty(diff.changed);\n }\n\n function diffObjectFr
omOldObject(object, oldObject) {\n var added = {};\n var removed = {};\n
var changed = {};\n\n for (var prop in oldObject) {\n var newValue = o
bject[prop];\n\n if (newValue !== undefined && newValue === oldObject[prop]
)\n continue;\n\n if (!(prop in object)) {\n removed[prop] =
undefined;\n continue;\n }\n\n if (newValue !== oldObject[prop]
)\n changed[prop] = newValue;\n }\n\n for (var prop in object) {\n
if (prop in oldObject)\n continue;\n\n added[prop] = object[pro
p];\n }\n\n if (Array.isArray(object) && object.length !== oldObject.lengt
h)\n changed.length = object.length;\n\n return {\n added: added,\n
removed: removed,\n changed: changed\n };\n }\n\n var eomTasks =
[];\n function runEOMTasks() {\n if (!eomTasks.length)\n return false;
\n\n for (var i = 0; i < eomTasks.length; i++) {\n eomTasks[i]();\n }
\n eomTasks.length = 0;\n return true;\n }\n\n var runEOM = hasObserve ?
(function(){\n var eomObj = { pingPong: true };\n var eomRunScheduled = f
alse;\n\n Object.observe(eomObj, function() {\n runEOMTasks();\n eo
mRunScheduled = false;\n });\n\n return function(fn) {\n eomTasks.pus
h(fn);\n if (!eomRunScheduled) {\n eomRunScheduled = true;\n
eomObj.pingPong = !eomObj.pingPong;\n }\n };\n })() :\n (function() {\
n return function(fn) {\n eomTasks.push(fn);\n };\n })();\n\n var o
bservedObjectCache = [];\n\n function newObservedObject() {\n var observer;\
n var object;\n var discardRecords = false;\n var first = true;\n\n
function callback(records) {\n if (observer && observer.state_ === OPENED &
& !discardRecords)\n observer.check_(records);\n }\n\n return {\n
open: function(obs) {\n if (observer)\n throw Error('Observe
dObject in use');\n\n if (!first)\n Object.deliverChangeRecords(
callback);\n\n observer = obs;\n first = false;\n },\n o
bserve: function(obj, arrayObserve) {\n object = obj;\n if (arrayO
bserve)\n Array.observe(object, callback);\n else\n Obj
ect.observe(object, callback);\n },\n deliver: function(discard) {\n
discardRecords = discard;\n Object.deliverChangeRecords(callback);\
n discardRecords = false;\n },\n close: function() {\n o
bserver = undefined;\n Object.unobserve(object, callback);\n obser
vedObjectCache.push(this);\n }\n };\n }\n\n /*\n * The observedSet a
bstraction is a perf optimization which reduces the total\n * number of Object
.observe observations of a set of objects. The idea is that\n * groups of Obse
rvers will have some object dependencies in common and this\n * observed set e
nsures that each object in the transitive closure of\n * dependencies is only
observed once. The observedSet acts as a write barrier\n * such that whenever
any change comes through, all Observers are checked for\n * changed values.\n
*\n * Note that this optimization is explicitly moving work from setup-time
to\n * change-time.\n *\n * TODO(rafaelw): Implement \"garbage collection\
". In order to move work off\n * the critical path, when Observers are closed,
their observed objects are\n * not Object.unobserve(d). As a result, it's pos
sible that if the observedSet\n * is kept open, but some Observers have been c
losed, it could cause \"leaks\"\n * (prevent otherwise collectable objects fro
m being collected). At some\n * point, we should implement incremental \"gc\"
which keeps a list of\n * observedSets which may need clean-up and does small
amounts of cleanup on a\n * timeout until all is clean.\n */\n\n function g
etObservedObject(observer, object, arrayObserve) {\n var dir = observedObject
Cache.pop() || newObservedObject();\n dir.open(observer);\n dir.observe(ob
ject, arrayObserve);\n return dir;\n }\n\n var observedSetCache = [];\n\n
function newObservedSet() {\n var observerCount = 0;\n var observers = [];
\n var objects = [];\n var rootObj;\n var rootObjProps;\n\n function
observe(obj, prop) {\n if (!obj)\n return;\n\n if (obj === roo
tObj)\n rootObjProps[prop] = true;\n\n if (objects.indexOf(obj) < 0)
{\n objects.push(obj);\n Object.observe(obj, callback);\n }\
n\n observe(Object.getPrototypeOf(obj), prop);\n }\n\n function allRo
otObjNonObservedProps(recs) {\n for (var i = 0; i < recs.length; i++) {\n
var rec = recs[i];\n if (rec.object !== rootObj ||\n roo
tObjProps[rec.name] ||\n rec.type === 'setPrototype') {\n re
turn false;\n }\n }\n return true;\n }\n\n function callb
ack(recs) {\n if (allRootObjNonObservedProps(recs))\n return;\n\n
var observer;\n for (var i = 0; i < observers.length; i++) {\n ob
server = observers[i];\n if (observer.state_ == OPENED) {\n obse
rver.iterateObjects_(observe);\n }\n }\n\n for (var i = 0; i <
observers.length; i++) {\n observer = observers[i];\n if (observer
.state_ == OPENED) {\n observer.check_();\n }\n }\n }\n\
n var record = {\n object: undefined,\n objects: objects,\n op
en: function(obs, object) {\n if (!rootObj) {\n rootObj = object
;\n rootObjProps = {};\n }\n\n observers.push(obs);\n
observerCount++;\n obs.iterateObjects_(observe);\n },\n clo
se: function(obs) {\n observerCount--;\n if (observerCount > 0) {\
n return;\n }\n\n for (var i = 0; i < objects.length; i++
) {\n Object.unobserve(objects[i], callback);\n Observer.unobs
ervedCount++;\n }\n\n observers.length = 0;\n objects.lengt
h = 0;\n rootObj = undefined;\n rootObjProps = undefined;\n
observedSetCache.push(this);\n }\n };\n\n return record;\n }\n\n v
ar lastObservedSet;\n\n function getObservedSet(observer, obj) {\n if (!last
ObservedSet || lastObservedSet.object !== obj) {\n lastObservedSet = observ
edSetCache.pop() || newObservedSet();\n lastObservedSet.object = obj;\n
}\n lastObservedSet.open(observer, obj);\n return lastObservedSet;\n }\n\
n var UNOPENED = 0;\n var OPENED = 1;\n var CLOSED = 2;\n var RESETTING = 3;
\n\n var nextObserverId = 1;\n\n function Observer() {\n this.state_ = UNOP
ENED;\n this.callback_ = undefined;\n this.target_ = undefined; // TODO(ra
faelw): Should be WeakRef\n this.directObserver_ = undefined;\n this.value
_ = undefined;\n this.id_ = nextObserverId++;\n }\n\n Observer.prototype =
{\n open: function(callback, target) {\n if (this.state_ != UNOPENED)\n
throw Error('Observer has already been opened.');\n\n addToAll(this)
;\n this.callback_ = callback;\n this.target_ = target;\n this.co
nnect_();\n this.state_ = OPENED;\n return this.value_;\n },\n\n
close: function() {\n if (this.state_ != OPENED)\n return;\n\n
removeFromAll(this);\n this.disconnect_();\n this.value_ = undefined;
\n this.callback_ = undefined;\n this.target_ = undefined;\n this
.state_ = CLOSED;\n },\n\n deliver: function() {\n if (this.state_ !=
OPENED)\n return;\n\n dirtyCheck(this);\n },\n\n report_: fun
ction(changes) {\n try {\n this.callback_.apply(this.target_, change
s);\n } catch (ex) {\n Observer._errorThrownDuringCallback = true;\n
console.error('Exception caught during observer callback: ' +\n
(ex.stack || ex));\n }\n },\n\n discardChanges: functio
n() {\n this.check_(undefined, true);\n return this.value_;\n }\n
}\n\n var collectObservers = !hasObserve;\n var allObservers;\n Observer._all
ObserversCount = 0;\n\n if (collectObservers) {\n allObservers = [];\n }\n\
n function addToAll(observer) {\n Observer._allObserversCount++;\n if (!c
ollectObservers)\n return;\n\n allObservers.push(observer);\n }\n\n fu
nction removeFromAll(observer) {\n Observer._allObserversCount--;\n }\n\n v
ar runningMicrotaskCheckpoint = false;\n\n global.Platform = global.Platform ||
{};\n\n global.Platform.performMicrotaskCheckpoint = function() {\n if (run
ningMicrotaskCheckpoint)\n return;\n\n if (!collectObservers)\n ret
urn;\n\n runningMicrotaskCheckpoint = true;\n\n var cycles = 0;\n var a
nyChanged, toCheck;\n\n do {\n cycles++;\n toCheck = allObservers;\
n allObservers = [];\n anyChanged = false;\n\n for (var i = 0; i
< toCheck.length; i++) {\n var observer = toCheck[i];\n if (observ
er.state_ != OPENED)\n continue;\n\n if (observer.check_())\n
anyChanged = true;\n\n allObservers.push(observer);\n }\n
if (runEOMTasks())\n anyChanged = true;\n } while (cycles < MAX_DIRT
Y_CHECK_CYCLES && anyChanged);\n\n if (testingExposeCycleCount)\n global
.dirtyCheckCycleCount = cycles;\n\n runningMicrotaskCheckpoint = false;\n };
\n\n if (collectObservers) {\n global.Platform.clearObservers = function() {
\n allObservers = [];\n };\n }\n\n function ObjectObserver(object) {\n
Observer.call(this);\n this.value_ = object;\n this.oldObject_ = undef
ined;\n }\n\n ObjectObserver.prototype = createObject({\n __proto__: Observ
er.prototype,\n\n arrayObserve: false,\n\n connect_: function(callback, ta
rget) {\n if (hasObserve) {\n this.directObserver_ = getObservedObje
ct(this, this.value_,\n this.arr
ayObserve);\n } else {\n this.oldObject_ = this.copyObject(this.valu
e_);\n }\n\n },\n\n copyObject: function(object) {\n var copy =
Array.isArray(object) ? [] : {};\n for (var prop in object) {\n copy
[prop] = object[prop];\n };\n if (Array.isArray(object))\n copy
.length = object.length;\n return copy;\n },\n\n check_: function(cha
ngeRecords, skipChanges) {\n var diff;\n var oldValues;\n if (has
Observe) {\n if (!changeRecords)\n return false;\n\n oldV
alues = {};\n diff = diffObjectFromChangeRecords(this.value_, changeRecor
ds,\n oldValues);\n } else {\n
oldValues = this.oldObject_;\n diff = diffObjectFromOldObject(this.v
alue_, this.oldObject_);\n }\n\n if (diffIsEmpty(diff))\n retur
n false;\n\n if (!hasObserve)\n this.oldObject_ = this.copyObject(th
is.value_);\n\n this.report_([\n diff.added || {},\n diff.rem
oved || {},\n diff.changed || {},\n function(property) {\n
return oldValues[property];\n }\n ]);\n\n return true;\n }
,\n\n disconnect_: function() {\n if (hasObserve) {\n this.direct
Observer_.close();\n this.directObserver_ = undefined;\n } else {\n
this.oldObject_ = undefined;\n }\n },\n\n deliver: function()
{\n if (this.state_ != OPENED)\n return;\n\n if (hasObserve)\n
this.directObserver_.deliver(false);\n else\n dirtyCheck(this
);\n },\n\n discardChanges: function() {\n if (this.directObserver_)\
n this.directObserver_.deliver(true);\n else\n this.oldObject
_ = this.copyObject(this.value_);\n\n return this.value_;\n }\n });\n\n
function ArrayObserver(array) {\n if (!Array.isArray(array))\n throw E
rror('Provided object is not an Array');\n ObjectObserver.call(this, array);\
n }\n\n ArrayObserver.prototype = createObject({\n\n __proto__: ObjectObser
ver.prototype,\n\n arrayObserve: true,\n\n copyObject: function(arr) {\n
return arr.slice();\n },\n\n check_: function(changeRecords) {\n
var splices;\n if (hasObserve) {\n if (!changeRecords)\n re
turn false;\n splices = projectArraySplices(this.value_, changeRecords);\
n } else {\n splices = calcSplices(this.value_, 0, this.value_.lengt
h,\n this.oldObject_, 0, this.oldObject_.length);\n
}\n\n if (!splices || !splices.length)\n return false;\n\n
if (!hasObserve)\n this.oldObject_ = this.copyObject(this.value_);\n\n
this.report_([splices]);\n return true;\n }\n });\n\n ArrayObserv
er.applySplices = function(previous, current, splices) {\n splices.forEach(fu
nction(splice) {\n var spliceArgs = [splice.index, splice.removed.length];\
n var addIndex = splice.index;\n while (addIndex < splice.index + spli
ce.addedCount) {\n spliceArgs.push(current[addIndex]);\n addIndex+
+;\n }\n\n Array.prototype.splice.apply(previous, spliceArgs);\n })
;\n };\n\n function PathObserver(object, path) {\n Observer.call(this);\n\n
this.object_ = object;\n this.path_ = getPath(path);\n this.directObse
rver_ = undefined;\n }\n\n PathObserver.prototype = createObject({\n __prot
o__: Observer.prototype,\n\n get path() {\n return this.path_;\n },\n
\n connect_: function() {\n if (hasObserve)\n this.directObserver
_ = getObservedSet(this, this.object_);\n\n this.check_(undefined, true);\n
},\n\n disconnect_: function() {\n this.value_ = undefined;\n\n
if (this.directObserver_) {\n this.directObserver_.close(this);\n
this.directObserver_ = undefined;\n }\n },\n\n iterateObjects_: func
tion(observe) {\n this.path_.iterateObjects(this.object_, observe);\n },
\n\n check_: function(changeRecords, skipChanges) {\n var oldValue = thi
s.value_;\n this.value_ = this.path_.getValueFrom(this.object_);\n if
(skipChanges || areSameValue(this.value_, oldValue))\n return false;\n\n
this.report_([this.value_, oldValue, this]);\n return true;\n },\n\
n setValue: function(newValue) {\n if (this.path_)\n this.path_.s
etValueFrom(this.object_, newValue);\n }\n });\n\n function CompoundObserve
r(reportChangesOnOpen) {\n Observer.call(this);\n\n this.reportChangesOnOp
en_ = reportChangesOnOpen;\n this.value_ = [];\n this.directObserver_ = un
defined;\n this.observed_ = [];\n }\n\n var observerSentinel = {};\n\n Com
poundObserver.prototype = createObject({\n __proto__: Observer.prototype,\n\n
connect_: function() {\n if (hasObserve) {\n var object;\n
var needsDirectObserver = false;\n for (var i = 0; i < this.observed_.l
ength; i += 2) {\n object = this.observed_[i]\n if (object !==
observerSentinel) {\n needsDirectObserver = true;\n break
;\n }\n }\n\n if (needsDirectObserver)\n this.di
rectObserver_ = getObservedSet(this, object);\n }\n\n this.check_(unde
fined, !this.reportChangesOnOpen_);\n },\n\n disconnect_: function() {\n
for (var i = 0; i < this.observed_.length; i += 2) {\n if (this.obser
ved_[i] === observerSentinel)\n this.observed_[i + 1].close();\n }
\n this.observed_.length = 0;\n this.value_.length = 0;\n\n if (t
his.directObserver_) {\n this.directObserver_.close(this);\n this.
directObserver_ = undefined;\n }\n },\n\n addPath: function(object, p
ath) {\n if (this.state_ != UNOPENED && this.state_ != RESETTING)\n
throw Error('Cannot add paths once started.');\n\n var path = getPath(path)
;\n this.observed_.push(object, path);\n if (!this.reportChangesOnOpen
_)\n return;\n var index = this.observed_.length / 2 - 1;\n thi
s.value_[index] = path.getValueFrom(object);\n },\n\n addObserver: functio
n(observer) {\n if (this.state_ != UNOPENED && this.state_ != RESETTING)\n
throw Error('Cannot add observers once started.');\n\n this.observed
_.push(observerSentinel, observer);\n if (!this.reportChangesOnOpen_)\n
return;\n var index = this.observed_.length / 2 - 1;\n this.value_
[index] = observer.open(this.deliver, this);\n },\n\n startReset: function
() {\n if (this.state_ != OPENED)\n throw Error('Can only reset whil
e open');\n\n this.state_ = RESETTING;\n this.disconnect_();\n },\n
\n finishReset: function() {\n if (this.state_ != RESETTING)\n th
row Error('Can only finishReset after startReset');\n this.state_ = OPENED;
\n this.connect_();\n\n return this.value_;\n },\n\n iterateObje
cts_: function(observe) {\n var object;\n for (var i = 0; i < this.obs
erved_.length; i += 2) {\n object = this.observed_[i]\n if (object
!== observerSentinel)\n this.observed_[i + 1].iterateObjects(object, o
bserve)\n }\n },\n\n check_: function(changeRecords, skipChanges) {\n
var oldValues;\n for (var i = 0; i < this.observed_.length; i += 2) {
\n var object = this.observed_[i];\n var path = this.observed_[i+1
];\n var value;\n if (object === observerSentinel) {\n va
r observable = path;\n value = this.state_ === UNOPENED ?\n
observable.open(this.deliver, this) :\n observable.discardChanges
();\n } else {\n value = path.getValueFrom(object);\n }\n
\n if (skipChanges) {\n this.value_[i / 2] = value;\n c
ontinue;\n }\n\n if (areSameValue(value, this.value_[i / 2]))\n
continue;\n\n oldValues = oldValues || [];\n oldValues[i /
2] = this.value_[i / 2];\n this.value_[i / 2] = value;\n }\n\n
if (!oldValues)\n return false;\n\n // TODO(rafaelw): Having observe
d_ as the third callback arg here is\n // pretty lame API. Fix.\n this
.report_([this.value_, oldValues, this.observed_]);\n return true;\n }\n
});\n\n function identFn(value) { return value; }\n\n function ObserverTrans
form(observable, getValueFn, setValueFn,\n dontPassT
hroughSet) {\n this.callback_ = undefined;\n this.target_ = undefined;\n
this.value_ = undefined;\n this.observable_ = observable;\n this.getValu
eFn_ = getValueFn || identFn;\n this.setValueFn_ = setValueFn || identFn;\n
// TODO(rafaelw): This is a temporary hack. PolymerExpressions needs this\n
// at the moment because of a bug in it's dependency tracking.\n this.dontPa
ssThroughSet_ = dontPassThroughSet;\n }\n\n ObserverTransform.prototype = {\n
open: function(callback, target) {\n this.callback_ = callback;\n t
his.target_ = target;\n this.value_ =\n this.getValueFn_(this.obse
rvable_.open(this.observedCallback_, this));\n return this.value_;\n },\
n\n observedCallback_: function(value) {\n value = this.getValueFn_(valu
e);\n if (areSameValue(value, this.value_))\n return;\n var old
Value = this.value_;\n this.value_ = value;\n this.callback_.call(this
.target_, this.value_, oldValue);\n },\n\n discardChanges: function() {\n
this.value_ = this.getValueFn_(this.observable_.discardChanges());\n r
eturn this.value_;\n },\n\n deliver: function() {\n return this.obser
vable_.deliver();\n },\n\n setValue: function(value) {\n value = this
.setValueFn_(value);\n if (!this.dontPassThroughSet_ && this.observable_.se
tValue)\n return this.observable_.setValue(value);\n },\n\n close:
function() {\n if (this.observable_)\n this.observable_.close();\n
this.callback_ = undefined;\n this.target_ = undefined;\n this.obs
ervable_ = undefined;\n this.value_ = undefined;\n this.getValueFn_ =
undefined;\n this.setValueFn_ = undefined;\n }\n }\n\n var expectedRec
ordTypes = {\n add: true,\n update: true,\n delete: true\n };\n\n fun
ction diffObjectFromChangeRecords(object, changeRecords, oldValues) {\n var a
dded = {};\n var removed = {};\n\n for (var i = 0; i < changeRecords.lengt
h; i++) {\n var record = changeRecords[i];\n if (!expectedRecordTypes[
record.type]) {\n console.error('Unknown changeRecord type: ' + record.ty
pe);\n console.error(record);\n continue;\n }\n\n if (!(
record.name in oldValues))\n oldValues[record.name] = record.oldValue;\n\
n if (record.type == 'update')\n continue;\n\n if (record.type
== 'add') {\n if (record.name in removed)\n delete removed[recor
d.name];\n else\n added[record.name] = true;\n\n continue
;\n }\n\n // type = 'delete'\n if (record.name in added) {\n
delete added[record.name];\n delete oldValues[record.name];\n } e
lse {\n removed[record.name] = true;\n }\n }\n\n for (var prop
in added)\n added[prop] = object[prop];\n\n for (var prop in removed)\n
removed[prop] = undefined;\n\n var changed = {};\n for (var prop in
oldValues) {\n if (prop in added || prop in removed)\n continue;\n\n
var newValue = object[prop];\n if (oldValues[prop] !== newValue)\n
changed[prop] = newValue;\n }\n\n return {\n added: added,\n
removed: removed,\n changed: changed\n };\n }\n\n function newSplice
(index, removed, addedCount) {\n return {\n index: index,\n removed
: removed,\n addedCount: addedCount\n };\n }\n\n var EDIT_LEAVE = 0;\n
var EDIT_UPDATE = 1;\n var EDIT_ADD = 2;\n var EDIT_DELETE = 3;\n\n functio
n ArraySplice() {}\n\n ArraySplice.prototype = {\n\n // Note: This function
is *based* on the computation of the Levenshtein\n // \"edit\" distance. The
one change is that \"updates\" are treated as two\n // edits - not one. With
Array splices, an update is really a delete\n // followed by an add. By retai
ning this, we optimize for \"keeping\" the\n // maximum array items in the or
iginal array. For example:\n //\n // 'xxxx123' -> '123yyyy'\n //\n
// With 1-edit updates, the shortest path would be just to update all seven\n
// characters. With 2-edit updates, we delete 4, leave 3, and add 4. This\n
// leaves the substring '123' intact.\n calcEditDistances: function(current,
currentStart, currentEnd,\n old, oldStart, oldEn
d) {\n // \"Deletion\" columns\n var rowCount = oldEnd - oldStart + 1;
\n var columnCount = currentEnd - currentStart + 1;\n var distances =
new Array(rowCount);\n\n // \"Addition\" rows. Initialize null column.\n
for (var i = 0; i < rowCount; i++) {\n distances[i] = new Array(column
Count);\n distances[i][0] = i;\n }\n\n // Initialize null row\n
for (var j = 0; j < columnCount; j++)\n distances[0][j] = j;\n\n
for (var i = 1; i < rowCount; i++) {\n for (var j = 1; j < columnCount
; j++) {\n if (this.equals(current[currentStart + j - 1], old[oldStart
+ i - 1]))\n distances[i][j] = distances[i - 1][j - 1];\n el
se {\n var north = distances[i - 1][j] + 1;\n var west = d
istances[i][j - 1] + 1;\n distances[i][j] = north < west ? north : we
st;\n }\n }\n }\n\n return distances;\n },\n\n /
/ This starts at the final weight, and walks \"backward\" by finding\n // the
minimum previous weight recursively until the origin of the weight\n // matr
ix.\n spliceOperationsFromEditDistances: function(distances) {\n var i =
distances.length - 1;\n var j = distances[0].length - 1;\n var curren
t = distances[i][j];\n var edits = [];\n while (i > 0 || j > 0) {\n
if (i == 0) {\n edits.push(EDIT_ADD);\n j--;\n c
ontinue;\n }\n if (j == 0) {\n edits.push(EDIT_DELETE);\n
i--;\n continue;\n }\n var northWest = distance
s[i - 1][j - 1];\n var west = distances[i - 1][j];\n var north = d
istances[i][j - 1];\n\n var min;\n if (west < north)\n mi
n = west < northWest ? west : northWest;\n else\n min = north <
northWest ? north : northWest;\n\n if (min == northWest) {\n if
(northWest == current) {\n edits.push(EDIT_LEAVE);\n } else
{\n edits.push(EDIT_UPDATE);\n current = northWest;\n
}\n i--;\n j--;\n } else if (min == west) {\n
edits.push(EDIT_DELETE);\n i--;\n current = west;\n
} else {\n edits.push(EDIT_ADD);\n j--;\n current =
north;\n }\n }\n\n edits.reverse();\n return edits;\n
},\n\n /**\n * Splice Projection functions:\n *\n * A splice map
is a representation of how a previous array of items\n * was transformed int
o a new array of items. Conceptually it is a list of\n * tuples of\n *\n
* <index, removed, addedCount>\n *\n * which are kept in ascendin
g index order of. The tuple represents that at\n * the |index|, |removed| se
quence of items were removed, and counting forward\n * from |index|, |addedC
ount| items were added.\n */\n\n /**\n * Lacking individual splice mu
tation information, the minimal set of\n * splices can be synthesized given
the previous state and final state of an\n * array. The basic approach is to
calculate the edit distance matrix and\n * choose the shortest path through
it.\n *\n * Complexity: O(l * p)\n * l: The length of the current
array\n * p: The length of the old array\n */\n calcSplices: funct
ion(current, currentStart, currentEnd,\n old, oldStart,
oldEnd) {\n var prefixCount = 0;\n var suffixCount = 0;\n\n var
minLength = Math.min(currentEnd - currentStart, oldEnd - oldStart);\n if (c
urrentStart == 0 && oldStart == 0)\n prefixCount = this.sharedPrefix(curr
ent, old, minLength);\n\n if (currentEnd == current.length && oldEnd == old
.length)\n suffixCount = this.sharedSuffix(current, old, minLength - pref
ixCount);\n\n currentStart += prefixCount;\n oldStart += prefixCount;\
n currentEnd -= suffixCount;\n oldEnd -= suffixCount;\n\n if (cur
rentEnd - currentStart == 0 && oldEnd - oldStart == 0)\n return [];\n\n
if (currentStart == currentEnd) {\n var splice = newSplice(currentSta
rt, [], 0);\n while (oldStart < oldEnd)\n splice.removed.push(ol
d[oldStart++]);\n\n return [ splice ];\n } else if (oldStart == oldE
nd)\n return [ newSplice(currentStart, [], currentEnd - currentStart) ];\
n\n var ops = this.spliceOperationsFromEditDistances(\n this.calcE
ditDistances(current, currentStart, currentEnd,\n
old, oldStart, oldEnd));\n\n var splice = undefined;\n var splices =
[];\n var index = currentStart;\n var oldIndex = oldStart;\n for
(var i = 0; i < ops.length; i++) {\n switch(ops[i]) {\n case ED
IT_LEAVE:\n if (splice) {\n splices.push(splice);\n
splice = undefined;\n }\n\n index++;\n
oldIndex++;\n break;\n case EDIT_UPDATE:\n if (!
splice)\n splice = newSplice(index, [], 0);\n\n splice.a
ddedCount++;\n index++;\n\n splice.removed.push(old[oldInd
ex]);\n oldIndex++;\n break;\n case EDIT_ADD:\n
if (!splice)\n splice = newSplice(index, [], 0);\n\n
splice.addedCount++;\n index++;\n break;\n
case EDIT_DELETE:\n if (!splice)\n splice = newSplice(i
ndex, [], 0);\n\n splice.removed.push(old[oldIndex]);\n ol
dIndex++;\n break;\n }\n }\n\n if (splice) {\n
splices.push(splice);\n }\n return splices;\n },\n\n sharedPre
fix: function(current, old, searchLength) {\n for (var i = 0; i < searchLen
gth; i++)\n if (!this.equals(current[i], old[i]))\n return i;\n
return searchLength;\n },\n\n sharedSuffix: function(current, old, se
archLength) {\n var index1 = current.length;\n var index2 = old.length
;\n var count = 0;\n while (count < searchLength && this.equals(curren
t[--index1], old[--index2]))\n count++;\n\n return count;\n },\n\
n calculateSplices: function(current, previous) {\n return this.calcSpli
ces(current, 0, current.length, previous, 0,\n prev
ious.length);\n },\n\n equals: function(currentValue, previousValue) {\n
return currentValue === previousValue;\n }\n };\n\n var arraySplice = n
ew ArraySplice();\n\n function calcSplices(current, currentStart, currentEnd,\n
old, oldStart, oldEnd) {\n return arraySplice.calcSpli
ces(current, currentStart, currentEnd,\n old,
oldStart, oldEnd);\n }\n\n function intersect(start1, end1, start2, end2) {\n
// Disjoint\n if (end1 < start2 || end2 < start1)\n return -1;\n\n
// Adjacent\n if (end1 == start2 || end2 == start1)\n return 0;\n\n
// Non-zero intersect, span1 first\n if (start1 < start2) {\n if (end1 <
end2)\n return end1 - start2; // Overlap\n else\n return end
2 - start2; // Contained\n } else {\n // Non-zero intersect, span2 first
\n if (end2 < end1)\n return end2 - start1; // Overlap\n else\n
return end1 - start1; // Contained\n }\n }\n\n function mergeSplice
(splices, index, removed, addedCount) {\n\n var splice = newSplice(index, rem
oved, addedCount);\n\n var inserted = false;\n var insertionOffset = 0;\n\
n for (var i = 0; i < splices.length; i++) {\n var current = splices[i];
\n current.index += insertionOffset;\n\n if (inserted)\n contin
ue;\n\n var intersectCount = intersect(splice.index,\n
splice.index + splice.removed.length,\n
current.index,\n current.index +
current.addedCount);\n\n if (intersectCount >= 0) {\n // Merge the
two splices\n\n splices.splice(i, 1);\n i--;\n\n insertionO
ffset -= current.addedCount - current.removed.length;\n\n splice.addedCou
nt += current.addedCount - intersectCount;\n var deleteCount = splice.rem
oved.length +\n current.removed.length - intersectCount
;\n\n if (!splice.addedCount && !deleteCount) {\n // merged spli
ce is a noop. discard.\n inserted = true;\n } else {\n
var removed = current.removed;\n\n if (splice.index < current.index) {\
n // some prefix of splice.removed is prepended to current.removed.\n
var prepend = splice.removed.slice(0, current.index - splice.index);
\n Array.prototype.push.apply(prepend, removed);\n removed
= prepend;\n }\n\n if (splice.index + splice.removed.length >
current.index + current.addedCount) {\n // some suffix of splice.rem
oved is appended to current.removed.\n var append = splice.removed.sl
ice(current.index + current.addedCount - splice.index);\n Array.proto
type.push.apply(removed, append);\n }\n\n splice.removed = rem
oved;\n if (current.index < splice.index) {\n splice.index =
current.index;\n }\n }\n } else if (splice.index < current
.index) {\n // Insert splice here.\n\n inserted = true;\n\n
splices.splice(i, 0, splice);\n i++;\n\n var offset = splice.adde
dCount - splice.removed.length\n current.index += offset;\n insert
ionOffset += offset;\n }\n }\n\n if (!inserted)\n splices.push(s
plice);\n }\n\n function createInitialSplices(array, changeRecords) {\n var
splices = [];\n\n for (var i = 0; i < changeRecords.length; i++) {\n va
r record = changeRecords[i];\n switch(record.type) {\n case 'splice'
:\n mergeSplice(splices, record.index, record.removed.slice(), record.a
ddedCount);\n break;\n case 'add':\n case 'update':\n
case 'delete':\n if (!isIndex(record.name))\n continue;\
n var index = toNumber(record.name);\n if (index < 0)\n
continue;\n mergeSplice(splices, index, [record.oldValue], 1);\n
break;\n default:\n console.error('Unexpected record typ
e: ' + JSON.stringify(record));\n break;\n }\n }\n\n return
splices;\n }\n\n function projectArraySplices(array, changeRecords) {\n var
splices = [];\n\n createInitialSplices(array, changeRecords).forEach(functio
n(splice) {\n if (splice.addedCount == 1 && splice.removed.length == 1) {\n
if (splice.removed[0] !== array[splice.index])\n splices.push(s
plice);\n\n return\n };\n\n splices = splices.concat(calcSplice
s(array, splice.index, splice.index + splice.addedCount,\n
splice.removed, 0, splice.removed.length));\n });\n\n
return splices;\n }\n\n global.Observer = Observer;\n global.Observer.runEOM
_ = runEOM;\n global.Observer.observerSentinel_ = observerSentinel; // for test
ing.\n global.Observer.hasObjectObserve = hasObserve;\n global.ArrayObserver =
ArrayObserver;\n global.ArrayObserver.calculateSplices = function(current, pre
vious) {\n return arraySplice.calculateSplices(current, previous);\n };\n\n
global.ArraySplice = ArraySplice;\n global.ObjectObserver = ObjectObserver;\n
global.PathObserver = PathObserver;\n global.CompoundObserver = CompoundObserv
er;\n global.Path = Path;\n global.ObserverTransform = ObserverTransform;\n})(
typeof global !== 'undefined' && global && typeof module !== 'undefined' && modu
le ? global : this || window);\n\n// Copyright (c) 2014 The Polymer Project Auth
ors. All rights reserved.\n// This code may only be used under the BSD style lic
ense found at http://polymer.github.io/LICENSE.txt\n// The complete set of autho
rs may be found at http://polymer.github.io/AUTHORS.txt\n// The complete set of
contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n// Code
distributed by Google as part of the polymer project is also\n// subject to an a
dditional IP rights grant found at http://polymer.github.io/PATENTS.txt\n\n(func
tion(global) {\n 'use strict';\n\n var filter = Array.prototype.filter.call.bi
nd(Array.prototype.filter);\n\n function getTreeScope(node) {\n while (node.
parentNode) {\n node = node.parentNode;\n }\n\n return typeof node.ge
tElementById === 'function' ? node : null;\n }\n\n Node.prototype.bind = funct
ion(name, observable) {\n console.error('Unhandled binding to Node: ', this,
name, observable);\n };\n\n Node.prototype.bindFinished = function() {};\n\n
function updateBindings(node, name, binding) {\n var bindings = node.bindings
_;\n if (!bindings)\n bindings = node.bindings_ = {};\n\n if (binding
s[name])\n binding[name].close();\n\n return bindings[name] = binding;\n
}\n\n function returnBinding(node, name, binding) {\n return binding;\n }
\n\n function sanitizeValue(value) {\n return value == null ? '' : value;\n
}\n\n function updateText(node, value) {\n node.data = sanitizeValue(value)
;\n }\n\n function textBinding(node) {\n return function(value) {\n re
turn updateText(node, value);\n };\n }\n\n var maybeUpdateBindings = return
Binding;\n\n Object.defineProperty(Platform, 'enableBindingsReflection', {\n
get: function() {\n return maybeUpdateBindings === updateBindings;\n },
\n set: function(enable) {\n maybeUpdateBindings = enable ? updateBindin
gs : returnBinding;\n return enable;\n },\n configurable: true\n });
\n\n Text.prototype.bind = function(name, value, oneTime) {\n if (name !== '
textContent')\n return Node.prototype.bind.call(this, name, value, oneTime)
;\n\n if (oneTime)\n return updateText(this, value);\n\n var observab
le = value;\n updateText(this, observable.open(textBinding(this)));\n retu
rn maybeUpdateBindings(this, name, observable);\n }\n\n function updateAttribu
te(el, name, conditional, value) {\n if (conditional) {\n if (value)\n
el.setAttribute(name, '');\n else\n el.removeAttribute(name);\
n return;\n }\n\n el.setAttribute(name, sanitizeValue(value));\n }\n
\n function attributeBinding(el, name, conditional) {\n return function(valu
e) {\n updateAttribute(el, name, conditional, value);\n };\n }\n\n Ele
ment.prototype.bind = function(name, value, oneTime) {\n var conditional = na
me[name.length - 1] == '?';\n if (conditional) {\n this.removeAttribute(
name);\n name = name.slice(0, -1);\n }\n\n if (oneTime)\n return
updateAttribute(this, name, conditional, value);\n\n\n var observable = valu
e;\n updateAttribute(this, name, conditional,\n observable.open(attrib
uteBinding(this, name, conditional)));\n\n return maybeUpdateBindings(this, n
ame, observable);\n };\n\n var checkboxEventType;\n (function() {\n // Att
empt to feature-detect which event (change or click) is fired first\n // for
checkboxes.\n var div = document.createElement('div');\n var checkbox = di
v.appendChild(document.createElement('input'));\n checkbox.setAttribute('type
', 'checkbox');\n var first;\n var count = 0;\n checkbox.addEventListen
er('click', function(e) {\n count++;\n first = first || 'click';\n
});\n checkbox.addEventListener('change', function() {\n count++;\n
first = first || 'change';\n });\n\n var event = document.createEvent('Mo
useEvent');\n event.initMouseEvent(\"click\", true, true, window, 0, 0, 0, 0,
0, false,\n false, false, false, 0, null);\n checkbox.dispatchEvent(e
vent);\n // WebKit/Blink don't fire the change event if the element is outsid
e the\n // document, so assume 'change' for that case.\n checkboxEventType
= count == 1 ? 'change' : first;\n })();\n\n function getEventForInputType(el
ement) {\n switch (element.type) {\n case 'checkbox':\n return ch
eckboxEventType;\n case 'radio':\n case 'select-multiple':\n case
'select-one':\n return 'change';\n case 'range':\n if (/Trid
ent|MSIE/.test(navigator.userAgent))\n return 'change';\n default:
\n return 'input';\n }\n }\n\n function updateInput(input, property,
value, santizeFn) {\n input[property] = (santizeFn || sanitizeValue)(value);
\n }\n\n function inputBinding(input, property, santizeFn) {\n return funct
ion(value) {\n return updateInput(input, property, value, santizeFn);\n
}\n }\n\n function noop() {}\n\n function bindInputEvent(input, property, obs
ervable, postEventFn) {\n var eventType = getEventForInputType(input);\n\n
function eventHandler() {\n observable.setValue(input[property]);\n o
bservable.discardChanges();\n (postEventFn || noop)(input);\n Platform
.performMicrotaskCheckpoint();\n }\n input.addEventListener(eventType, eve
ntHandler);\n\n return {\n close: function() {\n input.removeEven
tListener(eventType, eventHandler);\n observable.close();\n },\n\n
observable_: observable\n }\n }\n\n function booleanSanitize(value) {\n
return Boolean(value);\n }\n\n // |element| is assumed to be an HTMLInputE
lement with |type| == 'radio'.\n // Returns an array containing all radio butto
ns other than |element| that\n // have the same |name|, either in the form that
|element| belongs to or,\n // if no form, in the document tree to which |eleme
nt| belongs.\n //\n // This implementation is based upon the HTML spec definit
ion of a\n // \"radio button group\":\n // http://www.whatwg.org/specs/web-a
pps/current-work/multipage/number-state.html#radio-button-group\n //\n functio
n getAssociatedRadioButtons(element) {\n if (element.form) {\n return fi
lter(element.form.elements, function(el) {\n return el != element &&\n
el.tagName == 'INPUT' &&\n el.type == 'radio' &&\n
el.name == element.name;\n });\n } else {\n var treeScope = getTr
eeScope(element);\n if (!treeScope)\n return [];\n var radios =
treeScope.querySelectorAll(\n 'input[type=\"radio\"][name=\"' + elemen
t.name + '\"]');\n return filter(radios, function(el) {\n return el
!= element && !el.form;\n });\n }\n }\n\n function checkedPostEvent(in
put) {\n // Only the radio button that is getting checked gets an event. We\n
// therefore find all the associated radio buttons and update their\n //
check binding manually.\n if (input.tagName === 'INPUT' &&\n input.typ
e === 'radio') {\n getAssociatedRadioButtons(input).forEach(function(radio)
{\n var checkedBinding = radio.bindings_.checked;\n if (checkedBi
nding) {\n // Set the value directly to avoid an infinite call stack.\n
checkedBinding.observable_.setValue(false);\n }\n });\n
}\n }\n\n HTMLInputElement.prototype.bind = function(name, value, oneTime) {\
n if (name !== 'value' && name !== 'checked')\n return HTMLElement.proto
type.bind.call(this, name, value, oneTime);\n\n this.removeAttribute(name);\n
var sanitizeFn = name == 'checked' ? booleanSanitize : sanitizeValue;\n v
ar postEventFn = name == 'checked' ? checkedPostEvent : noop;\n\n if (oneTime
)\n return updateInput(this, name, value, sanitizeFn);\n\n\n var observa
ble = value;\n var binding = bindInputEvent(this, name, observable, postEvent
Fn);\n updateInput(this, name,\n observable.open(inputBinding(
this, name, sanitizeFn)),\n sanitizeFn);\n\n // Checkboxes may
need to update bindings of other checkboxes.\n return updateBindings(this, n
ame, binding);\n }\n\n HTMLTextAreaElement.prototype.bind = function(name, val
ue, oneTime) {\n if (name !== 'value')\n return HTMLElement.prototype.bi
nd.call(this, name, value, oneTime);\n\n this.removeAttribute('value');\n\n
if (oneTime)\n return updateInput(this, 'value', value);\n\n var obser
vable = value;\n var binding = bindInputEvent(this, 'value', observable);\n
updateInput(this, 'value',\n observable.open(inputBinding(this,
'value', sanitizeValue)));\n return maybeUpdateBindings(this, name, binding)
;\n }\n\n function updateOption(option, value) {\n var parentNode = option.
parentNode;;\n var select;\n var selectBinding;\n var oldValue;\n if
(parentNode instanceof HTMLSelectElement &&\n parentNode.bindings_ &&\n
parentNode.bindings_.value) {\n select = parentNode;\n selectBi
nding = select.bindings_.value;\n oldValue = select.value;\n }\n\n op
tion.value = sanitizeValue(value);\n\n if (select && select.value != oldValue
) {\n selectBinding.observable_.setValue(select.value);\n selectBindin
g.observable_.discardChanges();\n Platform.performMicrotaskCheckpoint();\n
}\n }\n\n function optionBinding(option) {\n return function(value) {\n
updateOption(option, value);\n }\n }\n\n HTMLOptionElement.prototype.b
ind = function(name, value, oneTime) {\n if (name !== 'value')\n return
HTMLElement.prototype.bind.call(this, name, value, oneTime);\n\n this.removeA
ttribute('value');\n\n if (oneTime)\n return updateOption(this, value);\
n\n var observable = value;\n var binding = bindInputEvent(this, 'value',
observable);\n updateOption(this, observable.open(optionBinding(this)));\n
return maybeUpdateBindings(this, name, binding);\n }\n\n HTMLSelectElement.pr
ototype.bind = function(name, value, oneTime) {\n if (name === 'selectedindex
')\n name = 'selectedIndex';\n\n if (name !== 'selectedIndex' && name !=
= 'value')\n return HTMLElement.prototype.bind.call(this, name, value, oneT
ime);\n\n this.removeAttribute(name);\n\n if (oneTime)\n return updat
eInput(this, name, value);\n\n var observable = value;\n var binding = bin
dInputEvent(this, name, observable);\n updateInput(this, name,\n
observable.open(inputBinding(this, name)));\n\n // Option update events ma
y need to access select bindings.\n return updateBindings(this, name, binding
);\n }\n})(this);\n\n// Copyright (c) 2014 The Polymer Project Authors. All rig
hts reserved.\n// This code may only be used under the BSD style license found a
t http://polymer.github.io/LICENSE.txt\n// The complete set of authors may be fo
und at http://polymer.github.io/AUTHORS.txt\n// The complete set of contributors
may be found at http://polymer.github.io/CONTRIBUTORS.txt\n// Code distributed
by Google as part of the polymer project is also\n// subject to an additional IP
rights grant found at http://polymer.github.io/PATENTS.txt\n\n(function(global)
{\n 'use strict';\n\n function assert(v) {\n if (!v)\n throw new Erro
r('Assertion failed');\n }\n\n var forEach = Array.prototype.forEach.call.bind
(Array.prototype.forEach);\n\n function getFragmentRoot(node) {\n var p;\n
while (p = node.parentNode) {\n node = p;\n }\n\n return node;\n }
\n\n function searchRefId(node, id) {\n if (!id)\n return;\n\n var r
ef;\n var selector = '#' + id;\n while (!ref) {\n node = getFragmentR
oot(node);\n\n if (node.protoContent_)\n ref = node.protoContent_.qu
erySelector(selector);\n else if (node.getElementById)\n ref = node.
getElementById(id);\n\n if (ref || !node.templateCreator_)\n break\n
\n node = node.templateCreator_;\n }\n\n return ref;\n }\n\n functi
on getInstanceRoot(node) {\n while (node.parentNode) {\n node = node.par
entNode;\n }\n return node.templateCreator_ ? node : null;\n }\n\n var M
ap;\n if (global.Map && typeof global.Map.prototype.forEach === 'function') {\n
Map = global.Map;\n } else {\n Map = function() {\n this.keys = [];
\n this.values = [];\n };\n\n Map.prototype = {\n set: function(
key, value) {\n var index = this.keys.indexOf(key);\n if (index <
0) {\n this.keys.push(key);\n this.values.push(value);\n
} else {\n this.values[index] = value;\n }\n },\n\n
get: function(key) {\n var index = this.keys.indexOf(key);\n if (i
ndex < 0)\n return;\n\n return this.values[index];\n },\n\n
delete: function(key, value) {\n var index = this.keys.indexOf(key)
;\n if (index < 0)\n return false;\n\n this.keys.splice(i
ndex, 1);\n this.values.splice(index, 1);\n return true;\n },
\n\n forEach: function(f, opt_this) {\n for (var i = 0; i < this.key
s.length; i++)\n f.call(opt_this || this, this.values[i], this.keys[i],
this);\n }\n };\n }\n\n // JScript does not have __proto__. We wrap a
ll object literals with\n // createObject which uses Object.create, Object.defi
neProperty and\n // Object.getOwnPropertyDescriptor to create a new object that
does the exact\n // same thing. The main downside to this solution is that we
have to extract\n // all those property descriptors for IE.\n var createObject
= ('__proto__' in {}) ?\n function(obj) { return obj; } :\n function(
obj) {\n var proto = obj.__proto__;\n if (!proto)\n retur
n obj;\n var newObject = Object.create(proto);\n Object.getOwnProp
ertyNames(obj).forEach(function(name) {\n Object.defineProperty(newObje
ct, name,\n Object.getOwnPropertyDescriptor(obj, n
ame));\n });\n return newObject;\n };\n\n // IE does not sup
port have Document.prototype.contains.\n if (typeof document.contains != 'funct
ion') {\n Document.prototype.contains = function(node) {\n if (node ===
this || node.parentNode === this)\n return true;\n return this.docum
entElement.contains(node);\n }\n }\n\n var BIND = 'bind';\n var REPEAT = '
repeat';\n var IF = 'if';\n\n var templateAttributeDirectives = {\n 'templa
te': true,\n 'repeat': true,\n 'bind': true,\n 'ref': true\n };\n\n v
ar semanticTemplateElements = {\n 'THEAD': true,\n 'TBODY': true,\n 'TF
OOT': true,\n 'TH': true,\n 'TR': true,\n 'TD': true,\n 'COLGROUP':
true,\n 'COL': true,\n 'CAPTION': true,\n 'OPTION': true,\n 'OPTGROU
P': true\n };\n\n var hasTemplateElement = typeof HTMLTemplateElement !== 'und
efined';\n if (hasTemplateElement) {\n // TODO(rafaelw): Remove when fix for
\n // https://codereview.chromium.org/164803002/\n // makes it to Chrome r
elease.\n (function() {\n var t = document.createElement('template');\n
var d = t.content.ownerDocument;\n var html = d.appendChild(d.createEl
ement('html'));\n var head = html.appendChild(d.createElement('head'));\n
var base = d.createElement('base');\n base.href = document.baseURI;\n
head.appendChild(base);\n })();\n }\n\n var allTemplatesSelectors = 'te
mplate, ' +\n Object.keys(semanticTemplateElements).map(function(tagName) {
\n return tagName.toLowerCase() + '[template]';\n }).join(', ');\n\n
function isSVGTemplate(el) {\n return el.tagName == 'template' &&\n
el.namespaceURI == 'http://www.w3.org/2000/svg';\n }\n\n function isHTMLTem
plate(el) {\n return el.tagName == 'TEMPLATE' &&\n el.namespaceURI
== 'http://www.w3.org/1999/xhtml';\n }\n\n function isAttributeTemplate(el) {\
n return Boolean(semanticTemplateElements[el.tagName] &&\n
el.hasAttribute('template'));\n }\n\n function isTemplate(el) {\n if (el.is
Template_ === undefined)\n el.isTemplate_ = el.tagName == 'TEMPLATE' || isA
ttributeTemplate(el);\n\n return el.isTemplate_;\n }\n\n // FIXME: Observe
templates being added/removed from documents\n // FIXME: Expose imperative API
to decorate and observe templates in\n // \"disconnected tress\" (e.g. ShadowRo
ot)\n document.addEventListener('DOMContentLoaded', function(e) {\n bootstra
pTemplatesRecursivelyFrom(document);\n // FIXME: Is this needed? Seems like i
t shouldn't be.\n Platform.performMicrotaskCheckpoint();\n }, false);\n\n f
unction forAllTemplatesFrom(node, fn) {\n var subTemplates = node.querySelect
orAll(allTemplatesSelectors);\n\n if (isTemplate(node))\n fn(node)\n
forEach(subTemplates, fn);\n }\n\n function bootstrapTemplatesRecursivelyFrom(
node) {\n function bootstrap(template) {\n if (!HTMLTemplateElement.deco
rate(template))\n bootstrapTemplatesRecursivelyFrom(template.content);\n
}\n\n forAllTemplatesFrom(node, bootstrap);\n }\n\n if (!hasTemplateElem
ent) {\n /**\n * This represents a <template> element.\n * @construct
or\n * @extends {HTMLElement}\n */\n global.HTMLTemplateElement = fun
ction() {\n throw TypeError('Illegal constructor');\n };\n }\n\n var h
asProto = '__proto__' in {};\n\n function mixin(to, from) {\n Object.getOwnP
ropertyNames(from).forEach(function(name) {\n Object.defineProperty(to, nam
e,\n Object.getOwnPropertyDescriptor(from, name));\n
});\n }\n\n // http://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/templa
tes/index.html#dfn-template-contents-owner\n function getOrCreateTemplateConten
tsOwner(template) {\n var doc = template.ownerDocument\n if (!doc.defaultV
iew)\n return doc;\n var d = doc.templateContentsOwner_;\n if (!d) {\
n // TODO(arv): This should either be a Document or HTMLDocument depending\
n // on doc.\n d = doc.implementation.createHTMLDocument('');\n w
hile (d.lastChild) {\n d.removeChild(d.lastChild);\n }\n doc.te
mplateContentsOwner_ = d;\n }\n return d;\n }\n\n function getTemplateSt
agingDocument(template) {\n if (!template.stagingDocument_) {\n var owne
r = template.ownerDocument;\n if (!owner.stagingDocument_) {\n owner
.stagingDocument_ = owner.implementation.createHTMLDocument('');\n owner.
stagingDocument_.isStagingDocument = true;\n // TODO(rafaelw): Remove whe
n fix for\n // https://codereview.chromium.org/164803002/\n // mak
es it to Chrome release.\n var base = owner.stagingDocument_.createElemen
t('base');\n base.href = document.baseURI;\n owner.stagingDocument
_.head.appendChild(base);\n\n owner.stagingDocument_.stagingDocument_ = o
wner.stagingDocument_;\n }\n\n template.stagingDocument_ = owner.stagi
ngDocument_;\n }\n\n return template.stagingDocument_;\n }\n\n // For no
n-template browsers, the parser will disallow <template> in certain\n // locati
ons, so we allow \"attribute templates\" which combine the template\n // elemen
t with the top-level container node of the content, e.g.\n //\n // <tr templ
ate repeat=\"{{ foo }}\"\" class=\"bar\"><td>Bar</td></tr>\n //\n // becomes\n
//\n // <template repeat=\"{{ foo }}\">\n // + #document-fragment\n //
+ <tr class=\"bar\">\n // + <td>Bar</td>\n //\n function extractTem
plateFromAttributeTemplate(el) {\n var template = el.ownerDocument.createElem
ent('template');\n el.parentNode.insertBefore(template, el);\n\n var attri
bs = el.attributes;\n var count = attribs.length;\n while (count-- > 0) {\
n var attrib = attribs[count];\n if (templateAttributeDirectives[attri
b.name]) {\n if (attrib.name !== 'template')\n template.setAttri
bute(attrib.name, attrib.value);\n el.removeAttribute(attrib.name);\n
}\n }\n\n return template;\n }\n\n function extractTemplateFromSVGTemp
late(el) {\n var template = el.ownerDocument.createElement('template');\n
el.parentNode.insertBefore(template, el);\n\n var attribs = el.attributes;\n
var count = attribs.length;\n while (count-- > 0) {\n var attrib = at
tribs[count];\n template.setAttribute(attrib.name, attrib.value);\n el
.removeAttribute(attrib.name);\n }\n\n el.parentNode.removeChild(el);\n
return template;\n }\n\n function liftNonNativeTemplateChildrenIntoContent(te
mplate, el, useRoot) {\n var content = template.content;\n if (useRoot) {\
n content.appendChild(el);\n return;\n }\n\n var child;\n whi
le (child = el.firstChild) {\n content.appendChild(child);\n }\n }\n\n
var templateObserver;\n if (typeof MutationObserver == 'function') {\n temp
lateObserver = new MutationObserver(function(records) {\n for (var i = 0; i
< records.length; i++) {\n records[i].target.refChanged_();\n }\n
});\n }\n\n /**\n * Ensures proper API and content model for template elem
ents.\n * @param {HTMLTemplateElement} opt_instanceRef The template element wh
ich\n * |el| template element will return as the value of its ref(), and w
hose\n * content will be used as source when createInstance() is invoked.\
n */\n HTMLTemplateElement.decorate = function(el, opt_instanceRef) {\n if
(el.templateIsDecorated_)\n return false;\n\n var templateElement = el;
\n templateElement.templateIsDecorated_ = true;\n\n var isNativeHTMLTempla
te = isHTMLTemplate(templateElement) &&\n hasTempl
ateElement;\n var bootstrapContents = isNativeHTMLTemplate;\n var liftCont
ents = !isNativeHTMLTemplate;\n var liftRoot = false;\n\n if (!isNativeHTM
LTemplate) {\n if (isAttributeTemplate(templateElement)) {\n assert(
!opt_instanceRef);\n templateElement = extractTemplateFromAttributeTempla
te(el);\n templateElement.templateIsDecorated_ = true;\n isNativeH
TMLTemplate = hasTemplateElement;\n liftRoot = true;\n } else if (is
SVGTemplate(templateElement)) {\n templateElement = extractTemplateFromSV
GTemplate(el);\n templateElement.templateIsDecorated_ = true;\n is
NativeHTMLTemplate = hasTemplateElement;\n }\n }\n\n if (!isNativeHTM
LTemplate) {\n fixTemplateElementPrototype(templateElement);\n var doc
= getOrCreateTemplateContentsOwner(templateElement);\n templateElement.con
tent_ = doc.createDocumentFragment();\n }\n\n if (opt_instanceRef) {\n
// template is contained within an instance, its direct content must be\n
// empty\n templateElement.instanceRef_ = opt_instanceRef;\n } else if
(liftContents) {\n liftNonNativeTemplateChildrenIntoContent(templateElement
,\n el,\n
liftRoot);\n } else if (bootstrapContents) {\n boo
tstrapTemplatesRecursivelyFrom(templateElement.content);\n }\n\n return tr
ue;\n };\n\n // TODO(rafaelw): This used to decorate recursively all templates
from a given\n // node. This happens by default on 'DOMContentLoaded', but may
be needed\n // in subtrees not descendent from document (e.g. ShadowRoot).\n
// Review whether this is the right public API.\n HTMLTemplateElement.bootstrap
= bootstrapTemplatesRecursivelyFrom;\n\n var htmlElement = global.HTMLUnknownE
lement || HTMLElement;\n\n var contentDescriptor = {\n get: function() {\n
return this.content_;\n },\n enumerable: true,\n configurable: true
\n };\n\n if (!hasTemplateElement) {\n // Gecko is more picky with the prot
otype than WebKit. Make sure to use the\n // same prototype as created in the
constructor.\n HTMLTemplateElement.prototype = Object.create(htmlElement.pro
totype);\n\n Object.defineProperty(HTMLTemplateElement.prototype, 'content',\
n contentDescriptor);\n }\n\n function fixTemplateEle
mentPrototype(el) {\n if (hasProto)\n el.__proto__ = HTMLTemplateElement
.prototype;\n else\n mixin(el, HTMLTemplateElement.prototype);\n }\n\n
function ensureSetModelScheduled(template) {\n if (!template.setModelFn_) {\
n template.setModelFn_ = function() {\n template.setModelFnScheduled
_ = false;\n var map = getBindings(template,\n template.delega
te_ && template.delegate_.prepareBinding);\n processBindings(template, ma
p, template.model_);\n };\n }\n\n if (!template.setModelFnScheduled_)
{\n template.setModelFnScheduled_ = true;\n Observer.runEOM_(template
.setModelFn_);\n }\n }\n\n mixin(HTMLTemplateElement.prototype, {\n bind
: function(name, value, oneTime) {\n if (name != 'ref')\n return Ele
ment.prototype.bind.call(this, name, value, oneTime);\n\n var self = this;\
n var ref = oneTime ? value : value.open(function(ref) {\n self.setA
ttribute('ref', ref);\n self.refChanged_();\n });\n\n this.setA
ttribute('ref', ref);\n this.refChanged_();\n if (oneTime)\n re
turn;\n\n if (!this.bindings_) {\n this.bindings_ = { ref: value };\
n } else {\n this.bindings_.ref = value;\n }\n\n return va
lue;\n },\n\n processBindingDirectives_: function(directives) {\n if
(this.iterator_)\n this.iterator_.closeDeps();\n\n if (!directives.i
f && !directives.bind && !directives.repeat) {\n if (this.iterator_) {\n
this.iterator_.close();\n this.iterator_ = undefined;\n
}\n\n return;\n }\n\n if (!this.iterator_) {\n this.ite
rator_ = new TemplateIterator(this);\n }\n\n this.iterator_.updateDepe
ndencies(directives, this.model_);\n\n if (templateObserver) {\n tem
plateObserver.observe(this, { attributes: true,\n
attributeFilter: ['ref'] });\n }\n\n return this.iterator_;\
n },\n\n createInstance: function(model, bindingDelegate, delegate_) {\n
if (bindingDelegate)\n delegate_ = this.newDelegate_(bindingDelegate)
;\n else if (!delegate_)\n delegate_ = this.delegate_;\n\n if (
!this.refContent_)\n this.refContent_ = this.ref_.content;\n var con
tent = this.refContent_;\n if (content.firstChild === null)\n return
emptyInstance;\n\n var map = getInstanceBindingMap(content, delegate_);\n
var stagingDocument = getTemplateStagingDocument(this);\n var instance
= stagingDocument.createDocumentFragment();\n instance.templateCreator_ =
this;\n instance.protoContent_ = content;\n instance.bindings_ = [];\n
instance.terminator_ = null;\n var instanceRecord = instance.template
Instance_ = {\n firstNode: null,\n lastNode: null,\n model:
model\n };\n\n var i = 0;\n var collectTerminator = false;\n
for (var child = content.firstChild; child; child = child.nextSibling) {\n
// The terminator of the instance is the clone of the last child of the\n
// content. If the last child is an active template, it may produce\n
// instances as a result of production, so simply collecting the last\n
// child of the instance after it has finished producing may be wrong.\n
if (child.nextSibling === null)\n collectTerminator = true;\n\n
var clone = cloneAndBindInstance(child, instance, stagingDocument,\n
map.children[i++],\n
model,\n delegate_,\n
instance.bindings_);\n clone.templateIns
tance_ = instanceRecord;\n if (collectTerminator)\n instance.ter
minator_ = clone;\n }\n\n instanceRecord.firstNode = instance.firstChi
ld;\n instanceRecord.lastNode = instance.lastChild;\n instance.templat
eCreator_ = undefined;\n instance.protoContent_ = undefined;\n return
instance;\n },\n\n get model() {\n return this.model_;\n },\n\n
set model(model) {\n this.model_ = model;\n ensureSetModelScheduled(t
his);\n },\n\n get bindingDelegate() {\n return this.delegate_ && thi
s.delegate_.raw;\n },\n\n refChanged_: function() {\n if (!this.itera
tor_ || this.refContent_ === this.ref_.content)\n return;\n\n this.r
efContent_ = undefined;\n this.iterator_.valueChanged();\n this.iterat
or_.updateIteratedValue(this.iterator_.getUpdatedValue());\n },\n\n clear:
function() {\n this.model_ = undefined;\n this.delegate_ = undefined;
\n if (this.bindings_ && this.bindings_.ref)\n this.bindings_.ref.cl
ose()\n this.refContent_ = undefined;\n if (!this.iterator_)\n
return;\n this.iterator_.valueChanged();\n this.iterator_.close()\n
this.iterator_ = undefined;\n },\n\n setDelegate_: function(delegate) {
\n this.delegate_ = delegate;\n this.bindingMap_ = undefined;\n i
f (this.iterator_) {\n this.iterator_.instancePositionChangedFn_ = undefi
ned;\n this.iterator_.instanceModelFn_ = undefined;\n }\n },\n\n
newDelegate_: function(bindingDelegate) {\n if (!bindingDelegate)\n
return;\n\n function delegateFn(name) {\n var fn = bindingDelegat
e && bindingDelegate[name];\n if (typeof fn != 'function')\n ret
urn;\n\n return function() {\n return fn.apply(bindingDelegate,
arguments);\n };\n }\n\n return {\n bindingMaps: {},\n
raw: bindingDelegate,\n prepareBinding: delegateFn('prepareBinding'
),\n prepareInstanceModel: delegateFn('prepareInstanceModel'),\n p
repareInstancePositionChanged:\n delegateFn('prepareInstancePositionC
hanged')\n };\n },\n\n set bindingDelegate(bindingDelegate) {\n
if (this.delegate_) {\n throw Error('Template must be cleared before a ne
w bindingDelegate ' +\n 'can be assigned');\n }\n\n
this.setDelegate_(this.newDelegate_(bindingDelegate));\n },\n\n get ref_(
) {\n var ref = searchRefId(this, this.getAttribute('ref'));\n if (!re
f)\n ref = this.instanceRef_;\n\n if (!ref)\n return this;\n\
n var nextRef = ref.ref_;\n return nextRef ? nextRef : ref;\n }\n
});\n\n // Returns\n // a) undefined if there are no mustaches.\n // b) [
TEXT, (ONE_TIME?, PATH, DELEGATE_FN, TEXT)+] if there is at least one mustache.\
n function parseMustaches(s, name, node, prepareBindingFn) {\n if (!s || !s.
length)\n return;\n\n var tokens;\n var length = s.length;\n var s
tartIndex = 0, lastIndex = 0, endIndex = 0;\n var onlyOneTime = true;\n wh
ile (lastIndex < length) {\n var startIndex = s.indexOf('{{', lastIndex);\n
var oneTimeStart = s.indexOf('[[', lastIndex);\n var oneTime = false;
\n var terminator = '}}';\n\n if (oneTimeStart >= 0 &&\n (sta
rtIndex < 0 || oneTimeStart < startIndex)) {\n startIndex = oneTimeStart;
\n oneTime = true;\n terminator = ']]';\n }\n\n endIndex
= startIndex < 0 ? -1 : s.indexOf(terminator, startIndex + 2);\n\n if (end
Index < 0) {\n if (!tokens)\n return;\n\n tokens.push(s.s
lice(lastIndex)); // TEXT\n break;\n }\n\n tokens = tokens || [
];\n tokens.push(s.slice(lastIndex, startIndex)); // TEXT\n var pathSt
ring = s.slice(startIndex + 2, endIndex).trim();\n tokens.push(oneTime); //
ONE_TIME?\n onlyOneTime = onlyOneTime && oneTime;\n var delegateFn =
prepareBindingFn &&\n prepareBindingFn(pathString, name, n
ode);\n // Don't try to parse the expression if there's a prepareBinding fu
nction\n if (delegateFn == null) {\n tokens.push(Path.get(pathString
)); // PATH\n } else {\n tokens.push(null);\n }\n tokens.p
ush(delegateFn); // DELEGATE_FN\n lastIndex = endIndex + 2;\n }\n\n i
f (lastIndex === length)\n tokens.push(''); // TEXT\n\n tokens.hasOnePat
h = tokens.length === 5;\n tokens.isSimplePath = tokens.hasOnePath &&\n
tokens[0] == '' &&\n tokens[4] == '
';\n tokens.onlyOneTime = onlyOneTime;\n\n tokens.combinator = function(va
lues) {\n var newValue = tokens[0];\n\n for (var i = 1; i < tokens.len
gth; i += 4) {\n var value = tokens.hasOnePath ? values : values[(i - 1)
/ 4];\n if (value !== undefined)\n newValue += value;\n n
ewValue += tokens[i + 3];\n }\n\n return newValue;\n }\n\n retur
n tokens;\n };\n\n function processOneTimeBinding(name, tokens, node, model) {
\n if (tokens.hasOnePath) {\n var delegateFn = tokens[3];\n var val
ue = delegateFn ? delegateFn(model, node, true) :\n
tokens[2].getValueFrom(model);\n return tokens.isSimplePath ? value : tok
ens.combinator(value);\n }\n\n var values = [];\n for (var i = 1; i < t
okens.length; i += 4) {\n var delegateFn = tokens[i + 2];\n values[(i
- 1) / 4] = delegateFn ? delegateFn(model, node) :\n tokens[i + 1].getV
alueFrom(model);\n }\n\n return tokens.combinator(values);\n }\n\n funct
ion processSinglePathBinding(name, tokens, node, model) {\n var delegateFn =
tokens[3];\n var observer = delegateFn ? delegateFn(model, node, false) :\n
new PathObserver(model, tokens[2]);\n\n return tokens.isSimplePath ? ob
server :\n new ObserverTransform(observer, tokens.combinator);\n }\n\n
function processBinding(name, tokens, node, model) {\n if (tokens.onlyOneTime
)\n return processOneTimeBinding(name, tokens, node, model);\n\n if (tok
ens.hasOnePath)\n return processSinglePathBinding(name, tokens, node, model
);\n\n var observer = new CompoundObserver();\n\n for (var i = 1; i < toke
ns.length; i += 4) {\n var oneTime = tokens[i];\n var delegateFn = tok
ens[i + 2];\n\n if (delegateFn) {\n var value = delegateFn(model, no
de, oneTime);\n if (oneTime)\n observer.addPath(value)\n
else\n observer.addObserver(value);\n continue;\n }\n\n
var path = tokens[i + 1];\n if (oneTime)\n observer.addPath(path.g
etValueFrom(model))\n else\n observer.addPath(model, path);\n }\n
\n return new ObserverTransform(observer, tokens.combinator);\n }\n\n funct
ion processBindings(node, bindings, model, instanceBindings) {\n for (var i =
0; i < bindings.length; i += 2) {\n var name = bindings[i]\n var toke
ns = bindings[i + 1];\n var value = processBinding(name, tokens, node, mode
l);\n var binding = node.bind(name, value, tokens.onlyOneTime);\n if (
binding && instanceBindings)\n instanceBindings.push(binding);\n }\n\n
node.bindFinished();\n if (!bindings.isTemplate)\n return;\n\n no
de.model_ = model;\n var iter = node.processBindingDirectives_(bindings);\n
if (instanceBindings && iter)\n instanceBindings.push(iter);\n }\n\n fu
nction parseWithDefault(el, name, prepareBindingFn) {\n var v = el.getAttribu
te(name);\n return parseMustaches(v == '' ? '{{}}' : v, name, el, prepareBind
ingFn);\n }\n\n function parseAttributeBindings(element, prepareBindingFn) {\n
assert(element);\n\n var bindings = [];\n var ifFound = false;\n va
r bindFound = false;\n\n for (var i = 0; i < element.attributes.length; i++)
{\n var attr = element.attributes[i];\n var name = attr.name;\n v
ar value = attr.value;\n\n // Allow bindings expressed in attributes to be
prefixed with underbars.\n // We do this to allow correct semantics for bro
wsers that don't implement\n // <template> where certain attributes might t
rigger side-effects -- and\n // for IE which sanitizes certain attributes,
disallowing mustache\n // replacements in their text.\n while (name[0]
=== '_') {\n name = name.substring(1);\n }\n\n if (isTemplate(
element) &&\n (name === IF || name === BIND || name === REPEAT)) {\n
continue;\n }\n\n var tokens = parseMustaches(value, name, elemen
t,\n prepareBindingFn);\n if (!tokens)\n
continue;\n\n bindings.push(name, tokens);\n }\n\n if (isTempla
te(element)) {\n bindings.isTemplate = true;\n bindings.if = parseWith
Default(element, IF, prepareBindingFn);\n bindings.bind = parseWithDefault(
element, BIND, prepareBindingFn);\n bindings.repeat = parseWithDefault(elem
ent, REPEAT, prepareBindingFn);\n\n if (bindings.if && !bindings.bind && !b
indings.repeat)\n bindings.bind = parseMustaches('{{}}', BIND, element, p
repareBindingFn);\n }\n\n return bindings;\n }\n\n function getBindings(
node, prepareBindingFn) {\n if (node.nodeType === Node.ELEMENT_NODE)\n r
eturn parseAttributeBindings(node, prepareBindingFn);\n\n if (node.nodeType =
== Node.TEXT_NODE) {\n var tokens = parseMustaches(node.data, 'textContent'
, node,\n prepareBindingFn);\n if (tokens)
\n return ['textContent', tokens];\n }\n\n return [];\n }\n\n fun
ction cloneAndBindInstance(node, parent, stagingDocument, bindings, model,\n
delegate,\n instanceB
indings,\n instanceRecord) {\n var clone = par
ent.appendChild(stagingDocument.importNode(node, false));\n\n var i = 0;\n
for (var child = node.firstChild; child; child = child.nextSibling) {\n cl
oneAndBindInstance(child, clone, stagingDocument,\n b
indings.children[i++],\n model,\n
delegate,\n instanceBindings);\n }\n\n
if (bindings.isTemplate) {\n HTMLTemplateElement.decorate(clone, node);\n
if (delegate)\n clone.setDelegate_(delegate);\n }\n\n processBi
ndings(clone, bindings, model, instanceBindings);\n return clone;\n }\n\n f
unction createInstanceBindingMap(node, prepareBindingFn) {\n var map = getBin
dings(node, prepareBindingFn);\n map.children = {};\n var index = 0;\n
for (var child = node.firstChild; child; child = child.nextSibling) {\n map
.children[index++] = createInstanceBindingMap(child, prepareBindingFn);\n }\n
\n return map;\n }\n\n var contentUidCounter = 1;\n\n // TODO(rafaelw): Se
tup a MutationObserver on content which clears the id\n // so that bindingMaps
regenerate when the template.content changes.\n function getContentUid(content)
{\n var id = content.id_;\n if (!id)\n id = content.id_ = contentUid
Counter++;\n return id;\n }\n\n // Each delegate is associated with a set o
f bindingMaps, one for each\n // content which may be used by a template. The i
ntent is that each binding\n // delegate gets the opportunity to prepare the in
stance (via the prepare*\n // delegate calls) once across all uses.\n // TODO(
rafaelw): Separate out the parse map from the binding map. In the\n // current
implementation, if two delegates need a binding map for the same\n // content,
the second will have to reparse.\n function getInstanceBindingMap(content, dele
gate_) {\n var contentId = getContentUid(content);\n if (delegate_) {\n
var map = delegate_.bindingMaps[contentId];\n if (!map) {\n map =
delegate_.bindingMaps[contentId] =\n createInstanceBindingMap(conten
t, delegate_.prepareBinding) || [];\n }\n return map;\n }\n\n va
r map = content.bindingMap_;\n if (!map) {\n map = content.bindingMap_ =
\n createInstanceBindingMap(content, undefined) || [];\n }\n retu
rn map;\n }\n\n Object.defineProperty(Node.prototype, 'templateInstance', {\n
get: function() {\n var instance = this.templateInstance_;\n return
instance ? instance :\n (this.parentNode ? this.parentNode.templateIns
tance : undefined);\n }\n });\n\n var emptyInstance = document.createDocume
ntFragment();\n emptyInstance.bindings_ = [];\n emptyInstance.terminator_ = nu
ll;\n\n function TemplateIterator(templateElement) {\n this.closed = false;\
n this.templateElement_ = templateElement;\n this.instances = [];\n thi
s.deps = undefined;\n this.iteratedValue = [];\n this.presentValue = undef
ined;\n this.arrayObserver = undefined;\n }\n\n TemplateIterator.prototype
= {\n closeDeps: function() {\n var deps = this.deps;\n if (deps) {
\n if (deps.ifOneTime === false)\n deps.ifValue.close();\n
if (deps.oneTime === false)\n deps.value.close();\n }\n },\n\
n updateDependencies: function(directives, model) {\n this.closeDeps();\
n\n var deps = this.deps = {};\n var template = this.templateElement_;
\n\n var ifValue = true;\n if (directives.if) {\n deps.hasIf =
true;\n deps.ifOneTime = directives.if.onlyOneTime;\n deps.ifValue
= processBinding(IF, directives.if, template, model);\n\n ifValue = deps
.ifValue;\n\n // oneTime if & predicate is false. nothing else to do.\n
if (deps.ifOneTime && !ifValue) {\n this.valueChanged();\n
return;\n }\n\n if (!deps.ifOneTime)\n ifValue = ifVal
ue.open(this.updateIfValue, this);\n }\n\n if (directives.repeat) {\n
deps.repeat = true;\n deps.oneTime = directives.repeat.onlyOneTime
;\n deps.value = processBinding(REPEAT, directives.repeat, template, mode
l);\n } else {\n deps.repeat = false;\n deps.oneTime = direct
ives.bind.onlyOneTime;\n deps.value = processBinding(BIND, directives.bin
d, template, model);\n }\n\n var value = deps.value;\n if (!deps.
oneTime)\n value = value.open(this.updateIteratedValue, this);\n\n i
f (!ifValue) {\n this.valueChanged();\n return;\n }\n\n
this.updateValue(value);\n },\n\n /**\n * Gets the updated value of th
e bind/repeat. This can potentially call\n * user code (if a bindingDelegate
is set up) so we try to avoid it if we\n * already have the value in hand (
from Observer.open).\n */\n getUpdatedValue: function() {\n var valu
e = this.deps.value;\n if (!this.deps.oneTime)\n value = value.disca
rdChanges();\n return value;\n },\n\n updateIfValue: function(ifValue
) {\n if (!ifValue) {\n this.valueChanged();\n return;\n
}\n\n this.updateValue(this.getUpdatedValue());\n },\n\n updateItera
tedValue: function(value) {\n if (this.deps.hasIf) {\n var ifValue =
this.deps.ifValue;\n if (!this.deps.ifOneTime)\n ifValue = ifVa
lue.discardChanges();\n if (!ifValue) {\n this.valueChanged();\n
return;\n }\n }\n\n this.updateValue(value);\n },\
n\n updateValue: function(value) {\n if (!this.deps.repeat)\n val
ue = [value];\n var observe = this.deps.repeat &&\n !thi
s.deps.oneTime &&\n Array.isArray(value);\n this.valueCh
anged(value, observe);\n },\n\n valueChanged: function(value, observeValue
) {\n if (!Array.isArray(value))\n value = [];\n\n if (value ==
= this.iteratedValue)\n return;\n\n this.unobserve();\n this.pr
esentValue = value;\n if (observeValue) {\n this.arrayObserver = new
ArrayObserver(this.presentValue);\n this.arrayObserver.open(this.handleS
plices, this);\n }\n\n this.handleSplices(ArrayObserver.calculateSplic
es(this.presentValue,\n t
his.iteratedValue));\n },\n\n getLastInstanceNode: function(index) {\n
if (index == -1)\n return this.templateElement_;\n var instance =
this.instances[index];\n var terminator = instance.terminator_;\n if (
!terminator)\n return this.getLastInstanceNode(index - 1);\n\n if (t
erminator.nodeType !== Node.ELEMENT_NODE ||\n this.templateElement_ ===
terminator) {\n return terminator;\n }\n\n var subtemplateIter
ator = terminator.iterator_;\n if (!subtemplateIterator)\n return te
rminator;\n\n return subtemplateIterator.getLastTemplateNode();\n },\n\n
getLastTemplateNode: function() {\n return this.getLastInstanceNode(thi
s.instances.length - 1);\n },\n\n insertInstanceAt: function(index, fragme
nt) {\n var previousInstanceLast = this.getLastInstanceNode(index - 1);\n
var parent = this.templateElement_.parentNode;\n this.instances.splice(
index, 0, fragment);\n\n parent.insertBefore(fragment, previousInstanceLast
.nextSibling);\n },\n\n extractInstanceAt: function(index) {\n var pr
eviousInstanceLast = this.getLastInstanceNode(index - 1);\n var lastNode =
this.getLastInstanceNode(index);\n var parent = this.templateElement_.paren
tNode;\n var instance = this.instances.splice(index, 1)[0];\n\n while
(lastNode !== previousInstanceLast) {\n var node = previousInstanceLast.n
extSibling;\n if (node == lastNode)\n lastNode = previousInstanc
eLast;\n\n instance.appendChild(parent.removeChild(node));\n }\n\n
return instance;\n },\n\n getDelegateFn: function(fn) {\n fn = fn
&& fn(this.templateElement_);\n return typeof fn === 'function' ? fn : nul
l;\n },\n\n handleSplices: function(splices) {\n if (this.closed || !
splices.length)\n return;\n\n var template = this.templateElement_;\
n\n if (!template.parentNode) {\n this.close();\n return;\n
}\n\n ArrayObserver.applySplices(this.iteratedValue, this.presentValue,
\n splices);\n\n var delegate = template.de
legate_;\n if (this.instanceModelFn_ === undefined) {\n this.instanc
eModelFn_ =\n this.getDelegateFn(delegate && delegate.prepareInstance
Model);\n }\n\n if (this.instancePositionChangedFn_ === undefined) {\n
this.instancePositionChangedFn_ =\n this.getDelegateFn(delega
te &&\n delegate.prepareInstancePositionChanged);\
n }\n\n // Instance Removals\n var instanceCache = new Map;\n
var removeDelta = 0;\n for (var i = 0; i < splices.length; i++) {\n
var splice = splices[i];\n var removed = splice.removed;\n for (
var j = 0; j < removed.length; j++) {\n var model = removed[j];\n
var instance = this.extractInstanceAt(splice.index + removeDelta);\n
if (instance !== emptyInstance) {\n instanceCache.set(model, instan
ce);\n }\n }\n\n removeDelta -= splice.addedCount;\n
}\n\n // Instance Insertions\n for (var i = 0; i < splices.length; i+
+) {\n var splice = splices[i];\n var addIndex = splice.index;\n
for (; addIndex < splice.index + splice.addedCount; addIndex++) {\n
var model = this.iteratedValue[addIndex];\n var instance = instanceC
ache.get(model);\n if (instance) {\n instanceCache.delete(mo
del);\n } else {\n if (this.instanceModelFn_) {\n
model = this.instanceModelFn_(model);\n }\n\n if (model
=== undefined) {\n instance = emptyInstance;\n } else {
\n instance = template.createInstance(model, undefined, delegate);\
n }\n }\n\n this.insertInstanceAt(addIndex, instanc
e);\n }\n }\n\n instanceCache.forEach(function(instance) {\n
this.closeInstanceBindings(instance);\n }, this);\n\n if (this.in
stancePositionChangedFn_)\n this.reportInstancesMoved(splices);\n },\n
\n reportInstanceMoved: function(index) {\n var instance = this.instance
s[index];\n if (instance === emptyInstance)\n return;\n\n this.
instancePositionChangedFn_(instance.templateInstance_, index);\n },\n\n re
portInstancesMoved: function(splices) {\n var index = 0;\n var offset
= 0;\n for (var i = 0; i < splices.length; i++) {\n var splice = spl
ices[i];\n if (offset != 0) {\n while (index < splice.index) {\n
this.reportInstanceMoved(index);\n index++;\n }\
n } else {\n index = splice.index;\n }\n\n while (
index < splice.index + splice.addedCount) {\n this.reportInstanceMoved(
index);\n index++;\n }\n\n offset += splice.addedCount -
splice.removed.length;\n }\n\n if (offset == 0)\n return;\n\n
var length = this.instances.length;\n while (index < length) {\n
this.reportInstanceMoved(index);\n index++;\n }\n },\n\n clos
eInstanceBindings: function(instance) {\n var bindings = instance.bindings_
;\n for (var i = 0; i < bindings.length; i++) {\n bindings[i].close(
);\n }\n },\n\n unobserve: function() {\n if (!this.arrayObserve
r)\n return;\n\n this.arrayObserver.close();\n this.arrayObserv
er = undefined;\n },\n\n close: function() {\n if (this.closed)\n
return;\n this.unobserve();\n for (var i = 0; i < this.instances.l
ength; i++) {\n this.closeInstanceBindings(this.instances[i]);\n }\n
\n this.instances.length = 0;\n this.closeDeps();\n this.template
Element_.iterator_ = undefined;\n this.closed = true;\n }\n };\n\n //
Polyfill-specific API.\n HTMLTemplateElement.forAllTemplatesFrom_ = forAllTempl
atesFrom;\n})(this);\n\n/*\n * Copyright (c) 2014 The Polymer Project Authors. A
ll rights reserved.\n * This code may only be used under the BSD style license f
ound at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may
be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contri
butors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distri
buted by Google as part of the polymer project is also\n * subject to an additio
nal IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(funct
ion(scope) {\n\nvar iterations = 0;\nvar callbacks = [];\nvar twiddle = document
.createTextNode('');\n\nfunction endOfMicrotask(callback) {\n twiddle.textConte
nt = iterations++;\n callbacks.push(callback);\n}\n\nfunction atEndOfMicrotask(
) {\n while (callbacks.length) {\n callbacks.shift()();\n }\n}\n\nnew (wind
ow.MutationObserver || JsMutationObserver)(atEndOfMicrotask)\n .observe(twiddle
, {characterData: true})\n ;\n\n// exports\n\nscope.endOfMicrotask = endOfMicro
task;\n\n})(Platform);\n\n\n/*\n * Copyright (c) 2014 The Polymer Project Author
s. All rights reserved.\n * This code may only be used under the BSD style licen
se found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors
may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of co
ntributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code di
stributed by Google as part of the polymer project is also\n * subject to an add
itional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(f
unction(scope) {\n\n// inject style sheet\nvar style = document.createElement('s
tyle');\nstyle.textContent = 'template {display: none !important;} /* injected b
y platform.js */';\nvar head = document.querySelector('head');\nhead.insertBefor
e(style, head.firstChild);\n\n// flush (with logging)\nvar flushing;\nfunction f
lush() {\n if (!flushing) {\n flushing = true;\n scope.endOfMicrotask(fun
ction() {\n flushing = false;\n logFlags.data && console.group('Platfo
rm.flush()');\n scope.performMicrotaskCheckpoint();\n logFlags.data &&
console.groupEnd();\n });\n }\n};\n\n// polling dirty checker\n// flush per
iodically if platform does not have object observe.\nif (!Observer.hasObjectObse
rve) {\n var FLUSH_POLL_INTERVAL = 125;\n window.addEventListener('WebComponen
tsReady', function() {\n flush();\n scope.flushPoll = setInterval(flush, F
LUSH_POLL_INTERVAL);\n });\n} else {\n // make flush a no-op when we have Obje
ct.observe\n flush = function() {};\n}\n\nif (window.CustomElements && !CustomE
lements.useNative) {\n var originalImportNode = Document.prototype.importNode;\
n Document.prototype.importNode = function(node, deep) {\n var imported = or
iginalImportNode.call(this, node, deep);\n CustomElements.upgradeAll(imported
);\n return imported;\n }\n}\n\n// exports\nscope.flush = flush;\n\n})(windo
w.Platform);\n\n\n/*\n * Copyright (c) 2014 The Polymer Project Authors. All rig
hts reserved.\n * This code may only be used under the BSD style license found a
t http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be fo
und at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors
may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed
by Google as part of the polymer project is also\n * subject to an additional IP
rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(sc
ope) {\n\nvar urlResolver = {\n resolveDom: function(root, url) {\n url = ur
l || root.ownerDocument.baseURI;\n this.resolveAttributes(root, url);\n th
is.resolveStyles(root, url);\n // handle template.content\n var templates
= root.querySelectorAll('template');\n if (templates) {\n for (var i = 0
, l = templates.length, t; (i < l) && (t = templates[i]); i++) {\n if (t.
content) {\n this.resolveDom(t.content, url);\n }\n }\n
}\n },\n resolveTemplate: function(template) {\n this.resolveDom(template.c
ontent, template.ownerDocument.baseURI);\n },\n resolveStyles: function(root,
url) {\n var styles = root.querySelectorAll('style');\n if (styles) {\n
for (var i = 0, l = styles.length, s; (i < l) && (s = styles[i]); i++) {\n
this.resolveStyle(s, url);\n }\n }\n },\n resolveStyle: function(
style, url) {\n url = url || style.ownerDocument.baseURI;\n style.textCont
ent = this.resolveCssText(style.textContent, url);\n },\n resolveCssText: func
tion(cssText, baseUrl, keepAbsolute) {\n cssText = replaceUrlsInCssText(cssTe
xt, baseUrl, keepAbsolute, CSS_URL_REGEXP);\n return replaceUrlsInCssText(css
Text, baseUrl, keepAbsolute, CSS_IMPORT_REGEXP);\n },\n resolveAttributes: fun
ction(root, url) {\n if (root.hasAttributes && root.hasAttributes()) {\n
this.resolveElementAttributes(root, url);\n }\n // search for attributes
that host urls\n var nodes = root && root.querySelectorAll(URL_ATTRS_SELECTOR
);\n if (nodes) {\n for (var i = 0, l = nodes.length, n; (i < l) && (n =
nodes[i]); i++) {\n this.resolveElementAttributes(n, url);\n }\n
}\n },\n resolveElementAttributes: function(node, url) {\n url = url || no
de.ownerDocument.baseURI;\n URL_ATTRS.forEach(function(v) {\n var attr =
node.attributes[v];\n var value = attr && attr.value;\n var replaceme
nt;\n if (value && value.search(URL_TEMPLATE_SEARCH) < 0) {\n if (v
=== 'style') {\n replacement = replaceUrlsInCssText(value, url, false,
CSS_URL_REGEXP);\n } else {\n replacement = resolveRelativeUrl(u
rl, value);\n }\n attr.value = replacement;\n }\n });\n }
\n};\n\nvar CSS_URL_REGEXP = /(url\\()([^)]*)(\\))/g;\nvar CSS_IMPORT_REGEXP = /
(@import[\\s]+(?!url\\())([^;]*)(;)/g;\nvar URL_ATTRS = ['href', 'src', 'action'
, 'style', 'url'];\nvar URL_ATTRS_SELECTOR = '[' + URL_ATTRS.join('],[') + ']';\
nvar URL_TEMPLATE_SEARCH = '{{.*}}';\n\nfunction replaceUrlsInCssText(cssText, b
aseUrl, keepAbsolute, regexp) {\n return cssText.replace(regexp, function(m, pr
e, url, post) {\n var urlPath = url.replace(/[\"']/g, '');\n urlPath = res
olveRelativeUrl(baseUrl, urlPath, keepAbsolute);\n return pre + '\\'' + urlPa
th + '\\'' + post;\n });\n}\n\nfunction resolveRelativeUrl(baseUrl, url, keepAb
solute) {\n // do not resolve '/' absolute urls\n if (url && url[0] === '/') {
\n return url;\n }\n var u = new URL(url, baseUrl);\n return keepAbsolute
? u.href : makeDocumentRelPath(u.href);\n}\n\nfunction makeDocumentRelPath(url)
{\n var root = new URL(document.baseURI);\n var u = new URL(url, root);\n if
(u.host === root.host && u.port === root.port &&\n u.protocol === root.prot
ocol) {\n return makeRelPath(root, u);\n } else {\n return url;\n }\n}\n
\n// make a relative path from source to target\nfunction makeRelPath(sourceUrl,
targetUrl) {\n var source = sourceUrl.pathname;\n var target = targetUrl.path
name;\n var s = source.split('/');\n var t = target.split('/');\n while (s.le
ngth && s[0] === t[0]){\n s.shift();\n t.shift();\n }\n for (var i = 0,
l = s.length - 1; i < l; i++) {\n t.unshift('..');\n }\n return t.join('/')
+ targetUrl.search + targetUrl.hash;\n}\n\n// exports\nscope.urlResolver = urlR
esolver;\n\n})(Polymer);\n\n/*\n * Copyright (c) 2014 The Polymer Project Author
s. All rights reserved.\n * This code may only be used under the BSD style licen
se found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors
may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of co
ntributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code di
stributed by Google as part of the polymer project is also\n * subject to an add
itional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(f
unction(scope) {\n var endOfMicrotask = Platform.endOfMicrotask;\n\n // Generi
c url loader\n function Loader(regex) {\n this.cache = Object.create(null);\
n this.map = Object.create(null);\n this.requests = 0;\n this.regex = r
egex;\n }\n Loader.prototype = {\n\n // TODO(dfreedm): there may be a bette
r factoring here\n // extract absolute urls from the text (full of relative u
rls)\n extractUrls: function(text, base) {\n var matches = [];\n va
r matched, u;\n while ((matched = this.regex.exec(text))) {\n u = ne
w URL(matched[1], base);\n matches.push({matched: matched[0], url: u.href
});\n }\n return matches;\n },\n // take a text blob, a root url
, and a callback and load all the urls found within the text\n // returns a m
ap of absolute url to text\n process: function(text, root, callback) {\n
var matches = this.extractUrls(text, root);\n\n // every call to process r
eturns all the text this loader has ever received\n var done = callback.bin
d(null, this.map);\n this.fetch(matches, done);\n },\n // build a map
ping of url -> text from matches\n fetch: function(matches, callback) {\n
var inflight = matches.length;\n\n // return early if there is no fetchin
g to be done\n if (!inflight) {\n return callback();\n }\n\n
// wait for all subrequests to return\n var done = function() {\n
if (--inflight === 0) {\n callback();\n }\n };\n\n //
start fetching all subrequests\n var m, req, url;\n for (var i = 0; i
< inflight; i++) {\n m = matches[i];\n url = m.url;\n req
= this.cache[url];\n // if this url has already been requested, skip requ
esting it again\n if (!req) {\n req = this.xhr(url);\n
req.match = m;\n this.cache[url] = req;\n }\n // wait for
the request to process its subrequests\n req.wait(done);\n }\n }
,\n handleXhr: function(request) {\n var match = request.match;\n v
ar url = match.url;\n\n // handle errors with an empty string\n var re
sponse = request.response || request.responseText || '';\n this.map[url] =
response;\n this.fetch(this.extractUrls(response, url), request.resolve);\n
},\n xhr: function(url) {\n this.requests++;\n var request = ne
w XMLHttpRequest();\n request.open('GET', url, true);\n request.send()
;\n request.onerror = request.onload = this.handleXhr.bind(this, request);\
n\n // queue of tasks to run after XHR returns\n request.pending = [];
\n request.resolve = function() {\n var pending = request.pending;\n
for(var i = 0; i < pending.length; i++) {\n pending[i]();\n
}\n request.pending = null;\n };\n\n // if we have already
resolved, pending is null, async call the callback\n request.wait = functio
n(fn) {\n if (request.pending) {\n request.pending.push(fn);\n
} else {\n endOfMicrotask(fn);\n }\n };\n\n retu
rn request;\n }\n };\n\n scope.Loader = Loader;\n})(Polymer);\n\n/*\n * Cop
yright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code
may only be used under the BSD style license found at http://polymer.github.io/L
ICENSE.txt\n * The complete set of authors may be found at http://polymer.github
.io/AUTHORS.txt\n * The complete set of contributors may be found at http://poly
mer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the pol
ymer project is also\n * subject to an additional IP rights grant found at http:
//polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\nvar urlResolver =
scope.urlResolver;\nvar Loader = scope.Loader;\n\nfunction StyleResolver() {\n
this.loader = new Loader(this.regex);\n}\nStyleResolver.prototype = {\n regex:
/@import\\s+(?:url)?[\"'\\(]*([^'\"\\)]*)['\"\\)]*;/g,\n // Recursively replace
@imports with the text at that url\n resolve: function(text, url, callback) {\
n var done = function(map) {\n callback(this.flatten(text, url, map));\n
}.bind(this);\n this.loader.process(text, url, done);\n },\n // resolve
the textContent of a style node\n resolveNode: function(style, url, callback)
{\n var text = style.textContent;\n var done = function(text) {\n sty
le.textContent = text;\n callback(style);\n };\n this.resolve(text, u
rl, done);\n },\n // flatten all the @imports to text\n flatten: function(tex
t, base, map) {\n var matches = this.loader.extractUrls(text, base);\n var
match, url, intermediate;\n for (var i = 0; i < matches.length; i++) {\n
match = matches[i];\n url = match.url;\n // resolve any css text to
be relative to the importer, keep absolute url\n intermediate = urlResolver
.resolveCssText(map[url], url, true);\n // flatten intermediate @imports\n
intermediate = this.flatten(intermediate, base, map);\n text = text.re
place(match.matched, intermediate);\n }\n return text;\n },\n loadStyles
: function(styles, base, callback) {\n var loaded=0, l = styles.length;\n
// called in the context of the style\n function loadedStyle(style) {\n
loaded++;\n if (loaded === l && callback) {\n callback();\n }\n
}\n for (var i=0, s; (i<l) && (s=styles[i]); i++) {\n this.resolveNo
de(s, base, loadedStyle);\n }\n }\n};\n\nvar styleResolver = new StyleResolv
er();\n\n// exports\nscope.styleResolver = styleResolver;\n\n})(Polymer);\n\n/*\
n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * Thi
s code may only be used under the BSD style license found at http://polymer.gith
ub.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer
.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http
://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of
the polymer project is also\n * subject to an additional IP rights grant found a
t http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n // copy o
wn properties from 'api' to 'prototype, with name hinting for 'super'\n functio
n extend(prototype, api) {\n if (prototype && api) {\n // use only own p
roperties of 'api'\n Object.getOwnPropertyNames(api).forEach(function(n) {\
n // acquire property descriptor\n var pd = Object.getOwnPropertyD
escriptor(api, n);\n if (pd) {\n // clone property via descripto
r\n Object.defineProperty(prototype, n, pd);\n // cache name-o
f-method for 'super' engine\n if (typeof pd.value == 'function') {\n
// hint the 'super' engine\n pd.value.nom = n;\n }\
n }\n });\n }\n return prototype;\n }\n\n\n // mixin\n\n //
copy all properties from inProps (et al) to inObj\n function mixin(inObj/*, in
Props, inMoreProps, ...*/) {\n var obj = inObj || {};\n for (var i = 1; i
< arguments.length; i++) {\n var p = arguments[i];\n try {\n fo
r (var n in p) {\n copyProperty(n, p, obj);\n }\n } catch(x
) {\n }\n }\n return obj;\n }\n\n // copy property inName from inSo
urce object to inTarget object\n function copyProperty(inName, inSource, inTarg
et) {\n var pd = getPropertyDescriptor(inSource, inName);\n Object.defineP
roperty(inTarget, inName, pd);\n }\n\n // get property descriptor for inName o
n inObject, even if\n // inName exists on some link in inObject's prototype cha
in\n function getPropertyDescriptor(inObject, inName) {\n if (inObject) {\n
var pd = Object.getOwnPropertyDescriptor(inObject, inName);\n return p
d || getPropertyDescriptor(Object.getPrototypeOf(inObject), inName);\n }\n }
\n\n // exports\n\n scope.extend = extend;\n scope.mixin = mixin;\n\n // for
bc\n Platform.mixin = mixin;\n\n})(Polymer);\n\n/*\n * Copyright (c) 2014 The
Polymer Project Authors. All rights reserved.\n * This code may only be used und
er the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The c
omplete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n *
The complete set of contributors may be found at http://polymer.github.io/CONTRI
BUTORS.txt\n * Code distributed by Google as part of the polymer project is also
\n * subject to an additional IP rights grant found at http://polymer.github.io/
PATENTS.txt\n */\n\n(function(scope) {\n \n // usage\n \n // invoke cb.call(
this) in 100ms, unless the job is re-registered,\n // which resets the timer\n
// \n // this.myJob = this.job(this.myJob, cb, 100)\n //\n // returns a job
handle which can be used to re-register a job\n\n var Job = function(inContext)
{\n this.context = inContext;\n this.boundComplete = this.complete.bind(t
his)\n };\n Job.prototype = {\n go: function(callback, wait) {\n this.
callback = callback;\n var h;\n if (!wait) {\n h = requestAnima
tionFrame(this.boundComplete);\n this.handle = function() {\n ca
ncelAnimationFrame(h);\n }\n } else {\n h = setTimeout(this.b
oundComplete, 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 co
mplete: function() {\n if (this.handle) {\n this.stop();\n th
is.callback.call(this.context);\n }\n }\n };\n \n function job(job, c
allback, wait) {\n if (job) {\n job.stop();\n } else {\n job = n
ew Job(this);\n }\n job.go(callback, wait);\n return job;\n }\n \n /
/ exports \n\n scope.job = job;\n \n})(Polymer);\n\n/*\n * Copyright (c) 2014
The Polymer Project Authors. All rights reserved.\n * This code may only be used
under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * T
he complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\
n * The complete set of contributors may be found at http://polymer.github.io/CO
NTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is
also\n * subject to an additional IP rights grant found at http://polymer.github
.io/PATENTS.txt\n */\n\n(function(scope) {\n\n var registry = {};\n\n HTMLElem
ent.register = function(tag, prototype) {\n registry[tag] = prototype;\n }\n
\n // get prototype mapped to node <tag>\n HTMLElement.getPrototypeForTag = fu
nction(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 o
riginalStopPropagation = Event.prototype.stopPropagation;\n Event.prototype.sto
pPropagation = function() {\n this.cancelBubble = true;\n originalStopProp
agation.apply(this, arguments);\n };\n \n \n // polyfill DOMTokenList\n //
* add/remove: allow these methods to take multiple classNames\n // * toggle: ad
d a 2nd argument which forces the given state rather\n // than toggling.\n\n
var add = DOMTokenList.prototype.add;\n var remove = DOMTokenList.prototype.rem
ove;\n DOMTokenList.prototype.add = function() {\n for (var i = 0; i < argum
ents.length; i++) {\n add.call(this, arguments[i]);\n }\n };\n DOMToke
nList.prototype.remove = function() {\n for (var i = 0; i < arguments.length;
i++) {\n remove.call(this, arguments[i]);\n }\n };\n DOMTokenList.pro
totype.toggle = function(name, bool) {\n if (arguments.length == 1) {\n
bool = !this.contains(name);\n }\n bool ? this.add(name) : this.remove(nam
e);\n };\n DOMTokenList.prototype.switch = function(oldName, newName) {\n o
ldName && this.remove(oldName);\n newName && this.add(newName);\n };\n\n //
add array() to NodeList, NamedNodeMap, HTMLCollection\n\n var ArraySlice = fun
ction() {\n return Array.prototype.slice.call(this);\n };\n\n var namedNode
Map = (window.NamedNodeMap || window.MozNamedAttrMap || {});\n\n NodeList.proto
type.array = ArraySlice;\n namedNodeMap.prototype.array = ArraySlice;\n HTMLCo
llection.prototype.array = ArraySlice;\n\n // utility\n\n function createDOM(i
nTagOrNode, inHTML, inAttrs) {\n var dom = typeof inTagOrNode == 'string' ?\n
document.createElement(inTagOrNode) : inTagOrNode.cloneNode(true);\n
dom.innerHTML = inHTML;\n if (inAttrs) {\n for (var n in inAttrs) {\n
dom.setAttribute(n, inAttrs[n]);\n }\n }\n return dom;\n }\n\n
// exports\n\n scope.createDOM = createDOM;\n\n})(Polymer);\n\n/*\r\n * Copyri
ght (c) 2014 The Polymer Project Authors. All rights reserved.\r\n * This code m
ay only be used under the BSD style license found at http://polymer.github.io/LI
CENSE.txt\r\n * The complete set of authors may be found at http://polymer.githu
b.io/AUTHORS.txt\r\n * The complete set of contributors may be found at http://p
olymer.github.io/CONTRIBUTORS.txt\r\n * Code distributed by Google as part of th
e polymer project is also\r\n * subject to an additional IP rights grant found a
t http://polymer.github.io/PATENTS.txt\r\n */\r\n\r\n (function(scope) {\r\n
// super\r\n\r\n // `arrayOfArgs` is an optional array of args like one might
pass\r\n // to `Function.apply`\r\n\r\n // TODO(sjmiles):\r\n // $s
uper must be installed on an instance or prototype chain\r\n // as `super`
, and invoked via `this`, e.g.\r\n // `this.super();`\r\n\r\n // w
ill not work if function objects are not unique, for example,\r\n // when
using mixins.\r\n // The memoization strategy assumes each function exists
on only one \r\n // prototype chain i.e. we use the function object for m
emoizing)\r\n // perhaps we can bookkeep on the prototype itself instead\r
\n function $super(arrayOfArgs) {\r\n // since we are thunking a method
call, performance is important here: \r\n // memoize all lookups, once memo
ized the fast path calls no other \r\n // functions\r\n //\r\n //
find the caller (cannot be `strict` because of 'caller')\r\n var caller =
$super.caller;\r\n // memoized 'name of method' \r\n var nom = caller.
nom;\r\n // memoized next implementation prototype\r\n var _super = ca
ller._super;\r\n if (!_super) {\r\n if (!nom) {\r\n nom = c
aller.nom = nameInThis.call(this, caller);\r\n }\r\n if (!nom) {\r
\n console.warn('called super() on a method not installed declaratively
(has no .nom property)');\r\n }\r\n // super prototype is either
cached or we have to find it\r\n // by searching __proto__ (at the 'top')
\r\n // invariant: because we cache _super on fn below, we never reach \r
\n // here from inside a series of calls to super(), so it's ok to \r\n
// start searching from the prototype of 'this' (at the 'top')\r\n
// we must never memoize a null super for this reason\r\n _super = memoiz
eSuper(caller, nom, getPrototypeOf(this));\r\n }\r\n // our super func
tion\r\n var fn = _super[nom];\r\n if (fn) {\r\n // memoize inf
ormation so 'fn' can call 'super'\r\n if (!fn._super) {\r\n // m
ust not memoize null, or we lose our invariant above\r\n memoizeSuper(f
n, nom, _super);\r\n }\r\n // invoke the inherited method\r\n
// if 'fn' is not function valued, this will throw\r\n return fn.apply
(this, arrayOfArgs || []);\r\n }\r\n }\r\n\r\n function nameInThis(va
lue) {\r\n var p = this.__proto__;\r\n while (p && p !== HTMLElement.p
rototype) {\r\n // TODO(sjmiles): getOwnPropertyNames is absurdly expensi
ve\r\n var n$ = Object.getOwnPropertyNames(p);\r\n for (var i=0, l
=n$.length, n; i<l && (n=n$[i]); i++) {\r\n var d = Object.getOwnProper
tyDescriptor(p, n);\r\n if (typeof d.value === 'function' && d.value ==
= value) {\r\n return n;\r\n }\r\n }\r\n p = p
.__proto__;\r\n }\r\n }\r\n\r\n function memoizeSuper(method, name, p
roto) {\r\n // find and cache next prototype containing `name`\r\n //
we need the prototype so we can do another lookup\r\n // from here\r\n
var s = nextSuper(proto, name, method);\r\n if (s[name]) {\r\n // `
s` is a prototype, the actual method is `s[name]`\r\n // tag super method
with it's name for quicker lookups\r\n s[name].nom = name;\r\n }\r\
n return method._super = s;\r\n }\r\n\r\n function nextSuper(proto, n
ame, caller) {\r\n // look for an inherited prototype that implements name\
r\n while (proto) {\r\n if ((proto[name] !== caller) && proto[name])
{\r\n return proto;\r\n }\r\n proto = getPrototypeOf(pro
to);\r\n }\r\n // must not return null, or we lose our invariant above
\r\n // in this case, a super() call was invoked where no superclass\r\n
// method exists\r\n // TODO(sjmiles): thow an exception?\r\n retur
n Object;\r\n }\r\n\r\n // NOTE: In some platforms (IE10) the prototype ch
ain is faked via \r\n // __proto__. Therefore, always get prototype via __pro
to__ instead of\r\n // the more standard Object.getPrototypeOf.\r\n functi
on getPrototypeOf(prototype) {\r\n return prototype.__proto__;\r\n }\r\n
\r\n // utility function to precompute name tags for functions\r\n // in a
(unchained) prototype\r\n function hintSuper(prototype) {\r\n // tag fu
nctions with their prototype name to optimize\r\n // super call invocations
\r\n for (var n in prototype) {\r\n var pd = Object.getOwnPropertyDe
scriptor(prototype, n);\r\n if (pd && typeof pd.value === 'function') {\r
\n pd.value.nom = n;\r\n }\r\n }\r\n }\r\n\r\n // exp
orts\r\n\r\n scope.super = $super;\r\n\r\n})(Polymer);\r\n\n/*\n * Copyright
(c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may onl
y be used under the BSD style license found at http://polymer.github.io/LICENSE.
txt\n * The complete set of authors may be found at http://polymer.github.io/AUT
HORS.txt\n * The complete set of contributors may be found at http://polymer.git
hub.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer pr
oject is also\n * subject to an additional IP rights grant found at http://polym
er.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n function noopHandler(va
lue) {\n return value;\n }\n\n var typeHandlers = {\n string: noopHandle
r,\n 'undefined': noopHandler,\n date: function(value) {\n return new
Date(Date.parse(value) || Date.now());\n },\n boolean: function(value) {\
n if (value === '') {\n return true;\n }\n return value ==
= 'false' ? false : !!value;\n },\n number: function(value) {\n var n
= parseFloat(value);\n // hex values like \"0xFFFF\" parseFloat as 0\n
if (n === 0) {\n n = parseInt(value);\n }\n return isNaN(n) ?
value : n;\n // this code disabled because encoded values (like \"0xFFFF\"
)\n // do not round trip to their original format\n //return (String(f
loatVal) === value) ? floatVal : value;\n },\n object: function(value, cur
rentValue) {\n if (currentValue === null) {\n return value;\n }
\n try {\n // If the string is an object, we can parse is with the J
SON library.\n // include convenience replace for single-quotes. If the a
uthor omits\n // quotes altogether, parse will fail.\n return JSON
.parse(value.replace(/'/g, '\"'));\n } catch(e) {\n // The object is
n't valid JSON, return the raw value\n return value;\n }\n },\n
// avoid deserialization of functions\n 'function': function(value, current
Value) {\n return currentValue;\n }\n };\n\n function deserializeValue
(value, currentValue) {\n // attempt to infer type from default value\n va
r 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[inferred
Type](value, currentValue);\n }\n\n // exports\n\n scope.deserializeValue = d
eserializeValue;\n\n})(Polymer);\n\n/*\n * Copyright (c) 2014 The Polymer Projec
t Authors. All rights reserved.\n * This code may only be used under the BSD sty
le license found at http://polymer.github.io/LICENSE.txt\n * The complete set of
authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete s
et of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n *
Code distributed by Google as part of the polymer project is also\n * subject t
o an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n
*/\n(function(scope) {\n\n // imports\n\n var extend = scope.extend;\n\n // m
odule\n\n var api = {};\n\n api.declaration = {};\n api.instance = {};\n\n a
pi.publish = function(apis, prototype) {\n for (var n in apis) {\n exten
d(prototype, apis[n]);\n }\n };\n\n // exports\n\n scope.api = api;\n\n})(
Polymer);\n\n/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights r
eserved.\n * This code may only be used under the BSD style license found at htt
p://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found a
t http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may
be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Go
ogle as part of the polymer project is also\n * subject to an additional IP righ
ts grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope)
{\n\n var utils = {\n /**\n * Invokes a function asynchronously. The co
ntext of the callback\n * function is bound to 'this' automatically.\n
* @method async\n * @param {Function|String} method\n * @param {any|A
rray} args\n * @param {number} timeout\n */\n async: function(metho
d, 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 inve
rting handle to determine which time is used.\n return timeout ? handle : ~
handle;\n },\n cancelAsync: function(handle) {\n if (handle < 0) {\n
cancelAnimationFrame(~handle);\n } else {\n clearTimeout(hand
le);\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 * @par
am {Boolean} bubbles Set false to prevent bubbling, defaults to true\n * @p
aram {Boolean} cancelable Set false to prevent cancellation, defaults to true\n
*/\n fire: function(type, detail, onNode, bubbles, cancelable) {\n
var node = onNode || this;\n var detail = detail === null || detail === und
efined ? {} : detail;\n var event = new CustomEvent(type, {\n bubble
s: bubbles !== undefined ? bubbles : true,\n cancelable: cancelable !== u
ndefined ? cancelable : true,\n detail: detail\n });\n node.dis
patchEvent(event);\n return event;\n },\n /**\n * Fire an event
asynchronously.\n * @method asyncFire\n * @param {string} type An even
t 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: func
tion(anew, old, className) {\n if (old) {\n old.classList.remove(cla
ssName);\n }\n if (anew) {\n anew.classList.add(className);\n
}\n },\n /**\n * Inject HTML which contains markup bound to this
element into\n * a target element (replacing target element content).\n
* @param String html to inject\n * @param Element target element\n *
/\n injectBoundHTML: function(html, element) {\n var template = document
.createElement('template');\n template.innerHTML = html;\n var fragmen
t = this.instanceTemplate(template);\n if (element) {\n element.text
Content = '';\n element.appendChild(fragment);\n }\n return fra
gment;\n }\n };\n\n // no-operation function for handy stubs\n var nop = f
unction() {};\n\n // null-object for handy stubs\n var nob = {};\n\n // depre
cated\n\n utils.asyncMethod = utils.async;\n\n // exports\n\n scope.api.insta
nce.utils = utils;\n scope.nop = nop;\n scope.nob = nob;\n\n})(Polymer);\n\n/*
\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * Th
is code may only be used under the BSD style license found at http://polymer.git
hub.io/LICENSE.txt\n * The complete set of authors may be found at http://polyme
r.github.io/AUTHORS.txt\n * The complete set of contributors may be found at htt
p://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of
the polymer project is also\n * subject to an additional IP rights grant found
at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n // impor
ts\n\n var log = window.logFlags || {};\n var EVENT_PREFIX = 'on-';\n\n // in
stance events api\n var events = {\n // read-only\n EVENT_PREFIX: EVENT_P
REFIX,\n // event listeners on host\n addHostListeners: function() {\n
var events = this.eventDelegates;\n log.events && (Object.keys(events).le
ngth > 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 supp
orts 1 thing being bound.\n for (var type in events) {\n var methodN
ame = events[type];\n PolymerGestures.addEventListener(this, type, this.e
lement.getEventHandler(this, this, methodName));\n }\n },\n // call '
method' or function method on 'obj' with 'args', if the method exists\n dispa
tchMethod: 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 && con
sole.groupEnd();\n Platform.flush();\n }\n }\n };\n\n // export
s\n\n scope.api.instance.events = events;\n\n // alias PolymerGestures event l
istener logic\n scope.addEventListener = function(node, eventType, handlerFn, c
apture) {\n PolymerGestures.addEventListener(wrap(node), eventType, handlerFn
, capture);\n };\n scope.removeEventListener = function(node, eventType, handl
erFn, capture) {\n PolymerGestures.removeEventListener(wrap(node), eventType,
handlerFn, capture);\n };\n\n})(Polymer);\n\n/*\r\n * Copyright (c) 2014 The P
olymer Project Authors. All rights reserved.\r\n * This code may only be used un
der the BSD style license found at http://polymer.github.io/LICENSE.txt\r\n * Th
e complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\r
\n * The complete set of contributors may be found at http://polymer.github.io/C
ONTRIBUTORS.txt\r\n * Code distributed by Google as part of the polymer project
is also\r\n * subject to an additional IP rights grant found at http://polymer.g
ithub.io/PATENTS.txt\r\n */\r\n\r\n(function(scope) {\r\n\r\n // instance api f
or attributes\r\n\r\n var attributes = {\r\n copyInstanceAttributes: functio
n () {\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, deseri
alize 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.at
tributeToProperty(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 // tr
y to match this attribute to a property (attributes are\r\n // all lower-ca
se, so this is case-insensitive search)\r\n var name = this.propertyForAttr
ibute(name);\r\n if (name) {\r\n // filter out 'mustached' values, t
hese 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 v
alues from attribute\r\n var value = this.deserializeValue(value, current
Value);\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 pu
blished property matching name, or undefined\r\n propertyForAttribute: functi
on(name) {\r\n var match = this._publishLC && this._publishLC[name];\r\n
//console.log('propertyForAttribute:', name, 'matches', match);\r\n retu
rn match;\r\n },\r\n // convert representation of 'stringValue' based on t
ype of 'currentValue'\r\n deserializeValue: function(stringValue, currentValu
e) {\r\n return scope.deserializeValue(stringValue, currentValue);\r\n }
,\r\n serializeValue: function(value, inferredType) {\r\n if (inferredTy
pe === '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 reflectPr
opertyToAttribute: function(name) {\r\n var inferredType = typeof this[name
];\r\n // try to intelligently serialize property value\r\n var serial
izedValue = this.serializeValue(this[name], inferredType);\r\n // boolean p
roperties must reflect as boolean attributes\r\n if (serializedValue !== un
defined) {\r\n this.setAttribute(name, serializedValue);\r\n // TO
DO(sorvell): we should remove attr for all properties\r\n // that have un
defined serialization; however, we will need to\r\n // refine the attr re
flection system to achieve this; pica, for example,\r\n // relies on havi
ng 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.attri
butes = attributes;\r\n\r\n})(Polymer);\r\n\n/*\n * Copyright (c) 2014 The Polym
er Project Authors. All rights reserved.\n * This code may only be used under th
e BSD style license found at http://polymer.github.io/LICENSE.txt\n * The comple
te set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The c
omplete set of contributors may be found at http://polymer.github.io/CONTRIBUTOR
S.txt\n * Code distributed by Google as part of the polymer project is also\n *
subject to an additional IP rights grant found at http://polymer.github.io/PATEN
TS.txt\n */\n\n(function(scope) {\n\n // imports\n\n var log = window.logFlags
|| {};\n\n // magic words\n\n var OBSERVE_SUFFIX = 'Changed';\n\n // element
api\n\n var empty = [];\n\n var updateRecord = {\n object: undefined,\n
type: 'update',\n name: undefined,\n oldValue: undefined\n };\n\n var n
umberIsNaN = Number.isNaN || function(value) {\n return typeof value === 'num
ber' && isNaN(value);\n }\n\n function areSameValue(left, right) {\n if (le
ft === right)\n return left !== 0 || 1 / left === 1 / right;\n if (numbe
rIsNaN(left) && numberIsNaN(right))\n return true;\n\n return left !== l
eft && right !== right;\n }\n\n // capture A's value if B's value is null or u
ndefined,\n // otherwise use B's value\n function resolveBindingValue(oldValue
, value) {\n if (value === undefined && oldValue === null) {\n return va
lue;\n }\n return (value === null || value === undefined) ? oldValue : val
ue;\n }\n\n var properties = {\n createPropertyObserver: function() {\n
var n$ = this._observeNames;\n if (n$ && n$.length) {\n var o = th
is._propertyObserver = new CompoundObserver(true);\n this.registerObserve
r(o);\n // TODO(sorvell): may not be kosher to access the value here (thi
s[n]);\n // previously we looked at the descriptor on the prototype\n
// this doesn't work for inheritance and not for accessors without\n
// a value property\n for (var i=0, l=n$.length, n; (i<l) && (n=n$[i]); i
++) {\n o.addPath(this, n);\n this.observeArrayValue(n, this[n
], null);\n }\n }\n },\n openPropertyObserver: function() {\n
if (this._propertyObserver) {\n this._propertyObserver.open(this.not
ifyPropertyChanges, this);\n }\n },\n notifyPropertyChanges: function
(newValues, oldValues, paths) {\n var name, method, called = {};\n for
(var i in oldValues) {\n // note: paths is of form [object, path, object
, path]\n name = paths[2 * i + 1];\n method = this.observe[name];\
n if (method) {\n var ov = oldValues[i], nv = newValues[i];\n
// observes the value if it is an array\n this.observeArrayValue
(name, nv, ov);\n if (!called[method]) {\n // only invoke ch
ange method if one of ov or nv is not (undefined | null)\n if ((ov !=
= undefined && ov !== null) || (nv !== undefined && nv !== null)) {\n
called[method] = true;\n // TODO(sorvell): call method with the
set of values it's expecting;\n // e.g. 'foo bar': 'invalidate' exp
ects the new and old values for\n // foo and bar. Currently we give
only one of these and then\n // deliver all the arguments.\n
this.invokeMethod(method, [ov, nv, arguments]);\n }\n
}\n }\n }\n },\n deliverChanges: function() {\n if (thi
s._propertyObserver) {\n this._propertyObserver.deliver();\n }\n
},\n propertyChanged_: function(name, value, oldValue) {\n if (this.refl
ect[name]) {\n this.reflectPropertyToAttribute(name);\n }\n },\n
observeArrayValue: function(name, value, old) {\n // we only care if the
re are registered side-effects\n var callbackName = this.observe[name];\n
if (callbackName) {\n // if we are observing the previous value, stop
\n if (Array.isArray(old)) {\n log.observe && console.log('[%s]
observeArrayValue: unregister observer [%s]', this.localName, name);\n
this.closeNamedObserver(name + '__array');\n }\n // if the new val
ue is an array, being observing it\n if (Array.isArray(value)) {\n
log.observe && console.log('[%s] observeArrayValue: register observer [%s]',
this.localName, name, value);\n var observer = new ArrayObserver(value)
;\n observer.open(function(splices) {\n this.invokeMethod(ca
llbackName, [splices]);\n }, this);\n this.registerNamedObserv
er(name + '__array', observer);\n }\n }\n },\n emitPropertyCha
ngeRecord: function(name, value, oldValue) {\n var object = this;\n if
(areSameValue(value, oldValue))\n return;\n\n this.propertyChanged_
(name, value, oldValue);\n\n if (!Observer.hasObjectObserve)\n retur
n;\n\n var notifier = this.notifier_;\n if (!notifier)\n notifi
er = this.notifier_ = Object.getNotifier(this);\n\n updateRecord.object = t
his;\n updateRecord.name = name;\n updateRecord.oldValue = oldValue;\n
\n notifier.notify(updateRecord);\n },\n bindToAccessor: function(nam
e, observable, resolveFn) {\n var privateName = name + '_';\n var priv
ateObservable = name + 'Observable_';\n // Present for properties which ar
e computed and published and have a\n // bound value.\n var privateCom
putedBoundValue = name + 'ComputedBoundObservable_';\n\n this[privateObserv
able] = observable;\n\n var oldValue = this[privateName];\n\n var self
= this;\n function updateValue(value, oldValue) {\n self[privateNam
e] = value;\n\n var setObserveable = self[privateComputedBoundValue];\n
if (setObserveable && typeof setObserveable.setValue == 'function') {\n
setObserveable.setValue(value);\n }\n \n self.emitPropertyC
hangeRecord(name, value, oldValue);\n }\n \n var value = observable.op
en(updateValue);\n\n if (resolveFn && !areSameValue(oldValue, value)) {\n
var resolvedValue = resolveFn(oldValue, value);\n if (!areSameValue
(value, resolvedValue)) {\n value = resolvedValue;\n if (obser
vable.setValue)\n observable.setValue(value);\n }\n }\n\n
updateValue(value, oldValue);\n\n var observer = {\n close: fu
nction() {\n observable.close();\n self[privateObservable] = u
ndefined;\n self[privateComputedBoundValue] = undefined;\n }\n
};\n this.registerObserver(observer);\n return observer;\n },\n
createComputedProperties: function() {\n if (!this._computedNames) {\n
return;\n }\n\n for (var i = 0; i < this._computedNames.length;
i++) {\n var name = this._computedNames[i];\n var expressionText
= this.computed[name];\n try {\n var expression = PolymerExpress
ions.getExpression(expressionText);\n var observable = expression.getBi
nding(this, this.element.syntax);\n this.bindToAccessor(name, observabl
e);\n } catch (ex) {\n console.error('Failed to create computed
property', ex);\n }\n }\n },\n bindProperty: function(property
, observable, oneTime) {\n if (oneTime) {\n this[property] = observa
ble;\n return;\n }\n var computed = this.element.prototype.comp
uted;\n\n // Binding an \"out-only\" value to a computed property. Note tha
t\n // since this observer isn't opened, it doesn't need to be closed on\n
// cleanup.\n if (computed && computed[property]) {\n var priva
teComputedBoundValue = property + 'ComputedBoundObservable_';\n this[priv
ateComputedBoundValue] = observable;\n return;\n }\n\n return t
his.bindToAccessor(property, observable, resolveBindingValue);\n },\n invo
keMethod: function(method, args) {\n var fn = this[method] || method;\n
if (typeof fn === 'function') {\n fn.apply(this, args);\n }\n }
,\n registerObserver: function(observer) {\n if (!this._observers) {\n
this._observers = [observer];\n return;\n }\n\n this._obs
ervers.push(observer);\n },\n // observer array items are arrays of observ
ers.\n closeObservers: function() {\n if (!this._observers) {\n r
eturn;\n }\n\n var observers = this._observers;\n for (var i = 0;
i < observers.length; i++) {\n var observer = observers[i];\n if
(observer && typeof observer.close == 'function') {\n observer.close();
\n }\n }\n\n this._observers = [];\n },\n // bookkeeping
observers for memory management\n registerNamedObserver: function(name, obser
ver) {\n var o$ = this._namedObservers || (this._namedObservers = {});\n
o$[name] = observer;\n },\n closeNamedObserver: function(name) {\n
var o$ = this._namedObservers;\n if (o$ && o$[name]) {\n o$[name].c
lose();\n o$[name] = null;\n return true;\n }\n },\n cl
oseNamedObservers: function() {\n if (this._namedObservers) {\n for
(var i in this._namedObservers) {\n this.closeNamedObserver(i);\n
}\n this._namedObservers = {};\n }\n }\n };\n\n // logging\n
var LOG_OBSERVE = '[%s] watching [%s]';\n var LOG_OBSERVED = '[%s#%s] watch: [
%s] now [%s] was [%s]';\n var LOG_CHANGED = '[%s#%s] propertyChanged: [%s] now
[%s] was [%s]';\n\n // exports\n\n scope.api.instance.properties = properties;
\n\n})(Polymer);\n\n/*\n * Copyright (c) 2014 The Polymer Project Authors. All r
ights reserved.\n * This code may only be used under the BSD style license found
at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be
found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributo
rs may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distribute
d by Google as part of the polymer project is also\n * subject to an additional
IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(
scope) {\n\n // imports\n\n var log = window.logFlags || 0;\n\n // element ap
i supporting mdv\n var mdv = {\n instanceTemplate: function(template) {\n
// ensure template is decorated (lets' things like <tr template ...> work)\n
HTMLTemplateElement.decorate(template);\n // ensure a default bindingD
elegate\n var syntax = this.syntax || (!template.bindingDelegate &&\n
this.element.syntax);\n var dom = template.createInstance(this, syntax)
;\n var observers = dom.bindings_;\n for (var i = 0; i < observers.len
gth; i++) {\n this.registerObserver(observers[i]);\n }\n return
dom;\n },\n bind: function(name, observable, oneTime) {\n var proper
ty = this.propertyForAttribute(name);\n if (!property) {\n // TODO(s
jmiles): this mixin method must use the special form\n // of `super` inst
alled by `mixinMethod` in declaration/prototype.js\n return this.mixinSup
er(arguments);\n } else {\n // use n-way Polymer binding\n va
r observer = this.bindProperty(property, observable, oneTime);\n // NOTE:
reflecting binding information is typically required only for\n // tooli
ng. It has a performance cost so it's opt-in in Node.bind.\n if (Platform
.enableBindingsReflection && observer) {\n observer.path = observable.p
ath_;\n this._recordBinding(property, observer);\n }\n if
(this.reflect[property]) {\n this.reflectPropertyToAttribute(property)
;\n }\n return observer;\n }\n },\n bindFinished: funct
ion() {\n this.makeElementReady();\n },\n _recordBinding: function(na
me, observer) {\n this.bindings_ = this.bindings_ || {};\n this.bindin
gs_[name] = observer;\n },\n // TODO(sorvell): unbind/unbindAll has been r
emoved, as public api, from\n // TemplateBinding. We still need to close/disp
ose of observers but perhaps\n // we should choose a more explicit name.\n
asyncUnbindAll: function() {\n if (!this._unbound) {\n log.unbind &
& console.log('[%s] asyncUnbindAll', this.localName);\n this._unbindAllJo
b = this.job(this._unbindAllJob, this.unbindAll, 0);\n }\n },\n unbin
dAll: function() {\n if (!this._unbound) {\n this.closeObservers();\
n this.closeNamedObservers();\n this._unbound = true;\n }\n
},\n cancelUnbindAll: function() {\n if (this._unbound) {\n log
.unbind && console.warn('[%s] already unbound, cannot cancel unbindAll', this.lo
calName);\n return;\n }\n log.unbind && console.log('[%s] cance
lUnbindAll', this.localName);\n if (this._unbindAllJob) {\n this._un
bindAllJob = this._unbindAllJob.stop();\n }\n }\n };\n\n function unbi
ndNodeTree(node) {\n forNodeTree(node, _nodeUnbindAll);\n }\n\n function _n
odeUnbindAll(node) {\n node.unbindAll();\n }\n\n function forNodeTree(node,
callback) {\n if (node) {\n callback(node);\n for (var child = nod
e.firstChild; child; child = child.nextSibling) {\n forNodeTree(child, ca
llback);\n }\n }\n }\n\n var mustachePattern = /\\{\\{([^{}]*)}}/;\n\n
// exports\n\n scope.bindPattern = mustachePattern;\n scope.api.instance.mdv
= mdv;\n\n})(Polymer);\n\n/*\n * Copyright (c) 2014 The Polymer Project Authors
. All rights reserved.\n * This code may only be used under the BSD style licens
e found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors
may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of con
tributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code dis
tributed by Google as part of the polymer project is also\n * subject to an addi
tional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(fu
nction(scope) {\n\n var base = {\n PolymerBase: true,\n job: function(job
, callback, wait) {\n if (typeof job === 'string') {\n var n = '___'
+ job;\n this[n] = Polymer.job.call(this, this[n], callback, wait);\n
} else {\n return Polymer.job.call(this, job, callback, wait);\n
}\n },\n super: Polymer.super,\n // user entry point for element has ha
d its createdCallback called\n created: function() {\n },\n // user ent
ry point for element has shadowRoot and is ready for\n // api interaction\n
ready: function() {\n },\n createdCallback: function() {\n if (this
.templateInstance && this.templateInstance.model) {\n console.warn('Attri
butes on ' + this.localName + ' were data bound ' +\n 'prior to Polym
er upgrading the element. This may result in ' +\n 'incorrect binding
types.');\n }\n this.created();\n this.prepareElement();\n
if (!this.ownerDocument.isStagingDocument) {\n this.makeElementReady();\n
}\n },\n // system entry point, do not override\n prepareElement:
function() {\n if (this._elementPrepared) {\n console.warn('Element
already prepared', this.localName);\n return;\n }\n this._elem
entPrepared = true;\n // storage for shadowRoots info\n this.shadowRoo
ts = {};\n // install property observers\n this.createPropertyObserver
();\n this.openPropertyObserver();\n // install boilerplate attributes
\n this.copyInstanceAttributes();\n // process input attributes\n
this.takeAttributes();\n // add event listeners\n this.addHostListene
rs();\n },\n makeElementReady: function() {\n if (this._readied) {\n
return;\n }\n this._readied = true;\n this.createComputedP
roperties();\n // TODO(sorvell): We could create an entry point here\n
// for the user to compute property values.\n // process declarative resou
rces\n this.parseDeclarations(this.__proto__);\n // TODO(sorvell): CE
polyfill uses unresolved attribute to simulate\n // :unresolved; remove thi
s attribute to be compatible with native\n // CE.\n this.removeAttribu
te('unresolved');\n // user entry point\n this.ready();\n },\n a
ttachedCallback: function() {\n this.cancelUnbindAll();\n // invoke us
er action\n if (this.attached) {\n this.attached();\n }\n
// TODO(sorvell): bc\n if (this.enteredView) {\n this.enteredView();
\n }\n // NOTE: domReady can be used to access elements in dom (descen
dants,\n // ancestors, siblings) such that the developer is enured to upgra
de\n // ordering. If the element definitions have loaded, domReady\n /
/ can be used to access upgraded elements.\n if (!this.hasBeenAttached) {\n
this.hasBeenAttached = true;\n if (this.domReady) {\n th
is.async('domReady');\n }\n }\n },\n detachedCallback: functio
n() {\n if (!this.preventDispose) {\n this.asyncUnbindAll();\n
}\n // invoke user action\n if (this.detached) {\n this.detache
d();\n }\n // TODO(sorvell): bc\n if (this.leftView) {\n t
his.leftView();\n }\n },\n // TODO(sorvell): bc\n enteredViewCallb
ack: 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 ancestr
al <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 inp
ut <element> as needed, override for custom behavior\n parseDeclaration: func
tion(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 // r
eturn a shadow-root template (if desired), override for custom behavior\n fet
chTemplate: function(elementElement) {\n return elementElement.querySelecto
r('template');\n },\n // utility function that creates a shadow root from
a <template>\n shadowFromTemplate: function(template) {\n if (template)
{\n // make a shadow root\n var root = this.createShadowRoot();\n
// stamp template\n // which includes parsing and applying MDV bin
dings 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 do
m\n root.appendChild(dom);\n // perform post-construction initiali
zation 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 lightFromTemp
late: function(template, refNode) {\n if (template) {\n // TODO(sorv
ell): mark this element as an eventController so that\n // event listener
s on bound nodes inside it will be called on it.\n // Note, the expectati
on here is that events on all descendants\n // should be handled by this
element.\n this.eventController = this;\n // stamp template\n
// which includes parsing and applying MDV bindings before being\n //
inserted (to avoid {{}} in attribute values)\n // e.g. to prevent <img sr
c=\"images/{{icon}}\"> from generating a 404.\n var dom = this.instanceTe
mplate(template);\n // append to shadow dom\n if (refNode) {\n
this.insertBefore(dom, refNode);\n } else {\n this.appendC
hild(dom);\n }\n // perform post-construction initialization tasks
on ahem, light root\n this.shadowRootReady(this);\n // return the
created shadow root\n return dom;\n }\n },\n shadowRootReady:
function(root) {\n // locate nodes with id and store references to them in
this.$ hash\n this.marshalNodeReferences(root);\n },\n // locate nod
es with id and store references to them in this.$ hash\n marshalNodeReference
s: 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, oldValu
e) {\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.appl
y(this, arguments);\n }\n },\n onMutation: function(node, listener) {
\n var observer = new MutationObserver(function(mutations) {\n liste
ner.call(this, observer, mutations);\n observer.disconnect();\n }.bi
nd(this));\n observer.observe(node, {childList: true, subtree: true});\n
}\n };\n\n // true if object has own PolymerBase api\n function isBase(objec
t) {\n return object.hasOwnProperty('PolymerBase')\n }\n\n // name a base c
onstructor for dev tools\n\n function PolymerBase() {};\n PolymerBase.prototyp
e = base;\n base.constructor = PolymerBase;\n\n // exports\n\n scope.Base = P
olymerBase;\n scope.isBase = isBase;\n scope.api.instance.base = base;\n\n})(P
olymer);\n\n/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights re
served.\n * This code may only be used under the BSD style license found at http
://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at
http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may b
e found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Goo
gle as part of the polymer project is also\n * subject to an additional IP right
s grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {
\n\n // imports\n\n var log = window.logFlags || {};\n var hasShadowDOMPolyfi
ll = window.ShadowDOMPolyfill;\n\n // magic words\n \n var STYLE_SCOPE_ATTRIB
UTE = 'element';\n var STYLE_CONTROLLER_SCOPE = 'controller';\n \n var styles
= {\n STYLE_SCOPE_ATTRIBUTE: STYLE_SCOPE_ATTRIBUTE,\n /**\n * Install
s external stylesheets and <style> elements with the attribute \n * polymer-
scope='controller' into the scope of element. This is intended\n * to be a c
alled during custom element construction.\n */\n installControllerStyles:
function() {\n // apply controller styles, but only if they are not yet app
lied\n var scope = this.findStyleScope();\n if (scope && !this.scopeHa
sNamedStyle(scope, this.localName)) {\n // allow inherited controller sty
les\n var proto = getPrototypeOf(this), cssText = '';\n while (pro
to && proto.element) {\n cssText += proto.element.cssTextForScope(STYLE
_CONTROLLER_SCOPE);\n proto = getPrototypeOf(proto);\n }\n
if (cssText) {\n this.installScopeCssText(cssText, scope);\n }
\n }\n },\n installScopeStyle: function(style, name, scope) {\n
var scope = scope || this.findStyleScope(), name = name || '';\n if (scope
&& !this.scopeHasNamedStyle(scope, this.localName + name)) {\n var cssTex
t = '';\n if (style instanceof Array) {\n for (var i=0, l=style.
length, s; (i<l) && (s=style[i]); i++) {\n cssText += s.textContent +
'\\n\\n';\n }\n } else {\n cssText = style.textContent
;\n }\n this.installScopeCssText(cssText, scope, name);\n }\n
},\n installScopeCssText: function(cssText, scope, name) {\n scope =
scope || this.findStyleScope();\n name = name || '';\n if (!scope) {\
n return;\n }\n if (hasShadowDOMPolyfill) {\n cssText =
shimCssText(cssText, scope.host);\n }\n var style = this.element.cssTe
xtToScopeStyle(cssText,\n STYLE_CONTROLLER_SCOPE);\n Polymer.apply
StyleToScope(style, scope);\n // cache that this style has been applied\n
this.styleCacheForScope(scope)[this.localName + name] = true;\n },\n f
indStyleScope: function(node) {\n // find the shadow root that contains thi
s element\n var n = node || this;\n while (n.parentNode) {\n n
= n.parentNode;\n }\n return n;\n },\n scopeHasNamedStyle: funct
ion(scope, name) {\n var cache = this.styleCacheForScope(scope);\n ret
urn cache[name];\n },\n styleCacheForScope: function(scope) {\n if (h
asShadowDOMPolyfill) {\n var scopeName = scope.host ? scope.host.localNam
e : scope.localName;\n return polyfillScopeStyleCache[scopeName] || (poly
fillScopeStyleCache[scopeName] = {});\n } else {\n return scope._sco
peStyles = (scope._scopeStyles || {});\n }\n }\n };\n\n var polyfillSc
opeStyleCache = {};\n \n // NOTE: use raw prototype traversal so that we ensur
e correct traversal\n // on platforms where the protoype chain is simulated via
__proto__ (IE10)\n function getPrototypeOf(prototype) {\n return prototype.
__proto__;\n }\n\n function shimCssText(cssText, host) {\n var name = '', i
s = false;\n if (host) {\n name = host.localName;\n is = host.hasAt
tribute('is');\n }\n var selector = Platform.ShadowCSS.makeScopeSelector(n
ame, is);\n return Platform.ShadowCSS.shimCssText(cssText, selector);\n }\n\
n // exports\n\n scope.api.instance.styles = styles;\n \n})(Polymer);\n\n/*\n
* Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This
code may only be used under the BSD style license found at http://polymer.githu
b.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.
github.io/AUTHORS.txt\n * The complete set of contributors may be found at http:
//polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of t
he polymer project is also\n * subject to an additional IP rights grant found at
http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n // imports
\n\n var extend = scope.extend;\n var api = scope.api;\n\n // imperative impl
ementation: Polymer()\n\n // specify an 'own' prototype for tag `name`\n funct
ion element(name, prototype) {\n if (typeof name !== 'string') {\n var s
cript = prototype || document._currentScript;\n prototype = name;\n na
me = script && script.parentNode && script.parentNode.getAttribute ?\n
script.parentNode.getAttribute('name') : '';\n if (!name) {\n throw
'Element name could not be inferred.';\n }\n }\n if (getRegisteredPro
totype(name)) {\n throw 'Already registered (Polymer) prototype for element
' + name;\n }\n // cache the prototype\n registerPrototype(name, proto
type);\n // notify the registrar waiting for 'name', if any\n notifyProtot
ype(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 // u
sing document.registerElement are available from\n // HTMLElement.getPrototypeF
orTag().\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 getR
egisteredPrototype(name) {\n return prototypesByName[name];\n }\n\n functio
n instanceOfType(element, type) {\n if (typeof type !== 'string') {\n re
turn false;\n }\n var proto = HTMLElement.getPrototypeForTag(type);\n v
ar ctor = proto && proto.constructor;\n if (!ctor) {\n return false;\n
}\n if (CustomElements.instanceof) {\n return CustomElements.instanceo
f(element, ctor);\n }\n return element instanceof ctor;\n }\n\n // expor
ts\n\n scope.getRegisteredPrototype = getRegisteredPrototype;\n scope.waitingF
orPrototype = waitingForPrototype;\n scope.instanceOfType = instanceOfType;\n\n
// namespace shenanigans so we can expose our scope on the registration \n //
function\n\n // make window.Polymer reference `element()`\n\n window.Polymer
= element;\n\n // TODO(sjmiles): find a way to do this that is less terrible\n
// copy window.Polymer properties onto `element()`\n\n extend(Polymer, scope);
\n\n // Under the HTMLImports polyfill, scripts in the main document\n // do n
ot block on imports; we want to allow calls to Polymer in the main\n // documen
t. Platform collects those calls until we can process them, which\n // we do he
re.\n\n if (Platform.consumeDeclarations) {\n Platform.consumeDeclarations(f
unction(declarations) {;\n if (declarations) {\n for (var i=0, l=dec
larations.length, d; (i<l) && (d=declarations[i]); i++) {\n element.app
ly(null, d);\n }\n }\n });\n }\n\n})(Polymer);\n\n/*\n * Copyrig
ht (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may
only be used under the BSD style license found at http://polymer.github.io/LICEN
SE.txt\n * The complete set of authors may be found at http://polymer.github.io/
AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.
github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer
project is also\n * subject to an additional IP rights grant found at http://po
lymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\nvar path = {\n resolv
eElementPaths: function(node) {\n Polymer.urlResolver.resolveDom(node);\n },
\n addResolvePathApi: function() {\n // let assetpath attribute modify the r
esolve path\n var assetPath = this.getAttribute('assetpath') || '';\n var
root = new URL(assetPath, this.ownerDocument.baseURI);\n this.prototype.resol
vePath = function(urlPath, base) {\n var u = new URL(urlPath, base || root)
;\n return u.href;\n };\n }\n};\n\n// exports\nscope.api.declaration.pa
th = path;\n\n})(Polymer);\n\n/*\n * Copyright (c) 2014 The Polymer Project Auth
ors. All rights reserved.\n * This code may only be used under the BSD style lic
ense found at http://polymer.github.io/LICENSE.txt\n * The complete set of autho
rs may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of
contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code
distributed by Google as part of the polymer project is also\n * subject to an a
dditional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n
(function(scope) {\n\n // imports\n\n var log = window.logFlags || {};\n var
api = scope.api.instance.styles;\n var STYLE_SCOPE_ATTRIBUTE = api.STYLE_SCOPE_
ATTRIBUTE;\n\n var hasShadowDOMPolyfill = window.ShadowDOMPolyfill;\n\n // mag
ic words\n\n var STYLE_SELECTOR = 'style';\n var STYLE_LOADABLE_MATCH = '@impo
rt';\n var SHEET_SELECTOR = 'link[rel=stylesheet]';\n var STYLE_GLOBAL_SCOPE =
'global';\n var SCOPE_ATTR = 'polymer-scope';\n\n var styles = {\n // retu
rns true if resources are loading\n loadStyles: function(callback) {\n v
ar template = this.fetchTemplate();\n var content = template && this.templa
teContent();\n if (content) {\n this.convertSheetsToStyles(content);
\n var styles = this.findLoadableStyles(content);\n if (styles.len
gth) {\n var templateUrl = template.ownerDocument.baseURI;\n r
eturn Polymer.styleResolver.loadStyles(styles, templateUrl, callback);\n
}\n }\n if (callback) {\n callback();\n }\n },\n con
vertSheetsToStyles: function(root) {\n var s$ = root.querySelectorAll(SHEET
_SELECTOR);\n for (var i=0, l=s$.length, s, c; (i<l) && (s=s$[i]); i++) {\n
c = createStyleElement(importRuleForSheet(s, this.ownerDocument.baseURI)
,\n this.ownerDocument);\n this.copySheetAttributes(c, s);\n
s.parentNode.replaceChild(c, s);\n }\n },\n copySheetAttributes
: function(style, link) {\n for (var i=0, a$=link.attributes, l=a$.length,
a; (a=a$[i]) && i<l; i++) {\n if (a.name !== 'rel' && a.name !== 'href')
{\n style.setAttribute(a.name, a.value);\n }\n }\n },\n
findLoadableStyles: function(root) {\n var loadables = [];\n if (ro
ot) {\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.ma
tch(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 te
mplate.\n * @param elementElement The <element> element to style.\n */\n
installSheets: function() {\n this.cacheSheets();\n this.cacheStyl
es();\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_SE
LECTOR);\n this.sheets.forEach(function(s) {\n if (s.parentNode) {\n
s.parentNode.removeChild(s);\n }\n });\n },\n cacheS
tyles: function() {\n this.styles = this.findNodes(STYLE_SELECTOR + '[' + S
COPE_ATTR + ']');\n this.styles.forEach(function(s) {\n if (s.parent
Node) {\n s.parentNode.removeChild(s);\n }\n });\n },\n
/**\n * Takes external stylesheets loaded in an <element> element and mov
es\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-scop
e'.\n * @param elementElement The <element> element to style.\n */\n
installLocalSheets: function () {\n var sheets = this.sheets.filter(functio
n(s) {\n return !s.hasAttribute(SCOPE_ATTR);\n });\n var conten
t = this.templateContent();\n if (content) {\n var cssText = '';\n
sheets.forEach(function(sheet) {\n cssText += cssTextFromSheet(sh
eet) + '\\n';\n });\n if (cssText) {\n var style = create
StyleElement(cssText, this.ownerDocument);\n content.insertBefore(style
, content.firstChild);\n }\n }\n },\n findNodes: function(sele
ctor, matcher) {\n var nodes = this.querySelectorAll(selector).array();\n
var content = this.templateContent();\n if (content) {\n var tem
plateNodes = content.querySelectorAll(selector).array();\n nodes = nodes.
concat(templateNodes);\n }\n return matcher ? nodes.filter(matcher) :
nodes;\n },\n /**\n * Promotes external stylesheets and <style> elemen
ts with the attribute \n * polymer-scope='global' into global scope.\n *
This is particularly useful for defining @keyframe rules which \n * current
ly 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 a
pplyStyleToScope(style, document.head);\n },\n cssTextForScope: function(s
copeDescriptor) {\n var cssText = '';\n // handle stylesheets\n v
ar 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 // h
andle 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(sc
opeDescriptor) {\n var cssText = this.cssTextForScope(scopeDescriptor);\n
return this.cssTextToScopeStyle(cssText, scopeDescriptor);\n },\n cssT
extToScopeStyle: 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).h
ref;\n return '@import \\'' + href + '\\';';\n }\n\n function applyStyleToS
cope(style, scope) {\n if (style) {\n if (scope === document) {\n
scope = document.head;\n }\n if (hasShadowDOMPolyfill) {\n sco
pe = document.head;\n }\n // TODO(sorvell): necessary for IE\n //
see https://connect.microsoft.com/IE/feedback/details/790212/\n // cloning
-a-style-element-and-adding-to-document-produces\n // -unexpected-result#de
tails\n // var clone = style.cloneNode(true);\n var clone = createStyl
eElement(style.textContent);\n var attr = style.getAttribute(STYLE_SCOPE_AT
TRIBUTE);\n if (attr) {\n clone.setAttribute(STYLE_SCOPE_ATTRIBUTE,
attr);\n }\n // TODO(sorvell): probably too brittle; try to figure out
\n // where to put the element.\n var refNode = scope.firstElementChi
ld;\n if (scope === document.head) {\n var selector = 'style[' + STY
LE_SCOPE_ATTRIBUTE + ']';\n var s$ = document.head.querySelectorAll(selec
tor);\n if (s$.length) {\n refNode = s$[s$.length-1].nextElement
Sibling;\n }\n }\n scope.insertBefore(clone, refNode);\n }\n
}\n\n function createStyleElement(cssText, scope) {\n scope = scope || doc
ument;\n scope = scope.createElement ? scope : scope.ownerDocument;\n var
style = scope.createElement('style');\n style.textContent = cssText;\n ret
urn style;\n }\n\n function cssTextFromSheet(sheet) {\n return (sheet && sh
eet.__resource) || '';\n }\n\n function matchesSelector(node, inSelector) {\n
if (matches) {\n return matches.call(node, inSelector);\n }\n }\n v
ar 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 = applyStyleT
oScope;\n \n})(Polymer);\n\n/*\n * Copyright (c) 2014 The Polymer Project Autho
rs. All rights reserved.\n * This code may only be used under the BSD style lice
nse found at http://polymer.github.io/LICENSE.txt\n * The complete set of author
s may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of c
ontributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code d
istributed by Google as part of the polymer project is also\n * subject to an ad
ditional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(
function(scope) {\n\n // imports\n\n var log = window.logFlags || {};\n var a
pi = scope.api.instance.events;\n var EVENT_PREFIX = api.EVENT_PREFIX;\n // po
lymer-element declarative api: events feature\n\n var mixedCaseEventTypes = {};
\n [\n 'webkitAnimationStart',\n 'webkitAnimationEnd',\n 'webkitTransi
tionEnd',\n 'DOMFocusOut',\n 'DOMFocusIn',\n 'DOMMouseScroll'\n ].forE
ach(function(e) {\n mixedCaseEventTypes[e.toLowerCase()] = e;\n });\n\n var
events = {\n parseHostEvents: function() {\n // our delegates map\n
var delegates = this.prototype.eventDelegates;\n // extract data from att
ributes 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.n
ame)) {\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 has
EventPrefix: function (n) {\n return n && (n[0] === 'o') && (n[1] === 'n')
&& (n[2] === '-');\n },\n removeEventPrefix: function(n) {\n return n
.slice(prefixLength);\n },\n findController: function(node) {\n while
(node.parentNode) {\n if (node.eventController) {\n return node
.eventController;\n }\n node = node.parentNode;\n }\n re
turn node.host;\n },\n getEventHandler: function(controller, target, metho
d) {\n var events = this;\n return function(e) {\n if (!control
ler || !controller.PolymerBase) {\n controller = events.findController(
target);\n }\n\n var args = [e, e.detail, e.currentTarget];\n
controller.dispatchMethod(controller, method, args);\n };\n },\n p
repareEventBinding: function(pathString, name, node) {\n if (!this.hasEvent
Prefix(name))\n return;\n\n var eventType = this.removeEventPrefix(n
ame);\n eventType = mixedCaseEventTypes[eventType] || eventType;\n\n v
ar events = this;\n\n return function(model, node, oneTime) {\n var
handler = events.getEventHandler(undefined, node, pathString);\n PolymerG
estures.addEventListener(node, eventType, handler);\n\n if (oneTime)\n
return;\n\n // TODO(rafaelw): This is really pointless work. Aside
from the cost\n // of these allocations, NodeBind is going to setAttribu
te back to its\n // current value. Fixing this would mean changing the Te
mplateBinding\n // binding delegate API.\n function bindingValue()
{\n return '{{ ' + pathString + ' }}';\n }\n\n return {\
n open: bindingValue,\n discardChanges: bindingValue,\n
close: function() {\n PolymerGestures.removeEventListener(node, ev
entType, handler);\n }\n };\n };\n }\n };\n\n var pref
ixLength = EVENT_PREFIX.length;\n\n // exports\n scope.api.declaration.events
= events;\n\n})(Polymer);\n\n/*\n * Copyright (c) 2014 The Polymer Project Autho
rs. All rights reserved.\n * This code may only be used under the BSD style lice
nse found at http://polymer.github.io/LICENSE.txt\n * The complete set of author
s may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of c
ontributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code d
istributed by Google as part of the polymer project is also\n * subject to an ad
ditional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(
function(scope) {\n\n // element api\n\n var properties = {\n inferObserver
s: 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 v
ar o = prototype.observe;\n if (o) {\n var exploded = {};\n f
or (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 optimizePropertyM
aps: function(prototype) {\n if (prototype.observe) {\n // construct
name list\n var a = prototype._observeNames = [];\n for (var n in
prototype.observe) {\n var names = n.split(' ');\n for (var i
=0, ni; ni=names[i]; i++) {\n a.push(ni);\n }\n }\n
}\n if (prototype.publish) {\n // construct name list\n v
ar a = prototype._publishNames = [];\n for (var n in prototype.publish) {
\n a.push(n);\n }\n }\n if (prototype.computed) {\n
// construct name list\n var a = prototype._computedNames = [];\n
for (var n in prototype.computed) {\n a.push(n);\n }\n
}\n },\n publishProperties: function(prototype, base) {\n // if we h
ave 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(pub
lish);\n }\n },\n //\n // `name: value` entries in the `publish` o
bject may need to generate \n // matching properties on the prototype.\n /
/\n // Values that are objects may have a `reflect` property, which\n // s
ignals that the value describes property control metadata.\n // In metadata o
bjects, the prototype default value (if any)\n // is encoded in the `value` p
roperty.\n //\n // publish: {\n // foo: 5, \n // bar: {value: tr
ue, reflect: true},\n // zot: {}\n // }\n //\n // `reflect` metada
ta property controls whether changes to the property\n // are reflected back
to the attribute (default false). \n //\n // A value is stored on the prot
otype unless it's === `undefined`,\n // in which case the base chain is check
ed for a value.\n // If the basal value is also undefined, `null` is stored o
n the prototype.\n //\n // The reflection data is stored on another protot
ype object, `reflect`\n // which also can be specified directly.\n //\n
// reflect: {\n // foo: true\n // }\n //\n requireProperties: fun
ction(propertyInfos, prototype, base) {\n // per-prototype storage for refl
ected properties\n prototype.reflect = prototype.reflect || {};\n // e
nsure a prototype value for each property\n // and update the property's re
flect to attribute status\n for (var n in propertyInfos) {\n var val
ue = propertyInfos[n];\n // value has metadata if it has a `reflect` prop
erty\n if (value && value.reflect !== undefined) {\n prototype.r
eflect[n] = Boolean(value.reflect);\n value = value.value;\n }\n
// only set a value if one is specified\n if (value !== undefined
) {\n prototype[n] = value;\n }\n }\n },\n lowerCaseM
ap: function(properties) {\n var map = {};\n for (var n in properties)
{\n map[n.toLowerCase()] = n;\n }\n return map;\n },\n c
reatePropertyAccessor: function(name, ignoreWrites) {\n var proto = this.pr
ototype;\n\n var privateName = name + '_';\n var privateObservable =
name + 'Observable_';\n proto[privateName] = proto[name];\n\n Object.d
efineProperty(proto, name, {\n get: function() {\n var observabl
e = this[privateObservable];\n if (observable)\n observable.
deliver();\n\n return this[privateName];\n },\n set: func
tion(value) {\n if (ignoreWrites) {\n return this[privateNam
e];\n }\n\n var observable = this[privateObservable];\n
if (observable) {\n observable.setValue(value);\n retur
n;\n }\n\n var oldValue = this[privateName];\n this[p
rivateName] = value;\n this.emitPropertyChangeRecord(name, value, oldVa
lue);\n\n return value;\n },\n configurable: true\n
});\n },\n createPropertyAccessors: function(prototype) {\n var n$ =
prototype._computedNames;\n if (n$ && n$.length) {\n for (var i=0, l
=n$.length, n, fn; (i<l) && (n=n$[i]); i++) {\n this.createPropertyAcce
ssor(n, true);\n }\n }\n var n$ = prototype._publishNames;\n
if (n$ && n$.length) {\n for (var i=0, l=n$.length, n, fn; (i<l) && (n
=n$[i]); i++) {\n // If the property is computed and published, the acc
essor is created\n // above.\n if (!prototype.computed || !pro
totype.computed[n]) {\n this.createPropertyAccessor(n);\n }\
n }\n }\n }\n };\n\n // exports\n\n scope.api.declaration.prop
erties = properties;\n\n})(Polymer);\n\n/*\n * Copyright (c) 2014 The Polymer Pr
oject Authors. All rights reserved.\n * This code may only be used under the BSD
style license found at http://polymer.github.io/LICENSE.txt\n * The complete se
t of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The comple
te set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
\n * Code distributed by Google as part of the polymer project is also\n * subje
ct to an additional IP rights grant found at http://polymer.github.io/PATENTS.tx
t\n */\n(function(scope) {\n\n // magic words\n\n var ATTRIBUTES_ATTRIBUTE = '
attributes';\n var ATTRIBUTES_REGEX = /\\s|,/;\n\n // attributes api\n\n var
attributes = {\n \n inheritAttributesObjects: function(prototype) {\n
// chain our lower-cased publish map to the inherited version\n this.inher
itObject(prototype, 'publishLC');\n // chain our instance attributes map to
the inherited version\n this.inheritObject(prototype, '_instanceAttributes
');\n },\n\n publishAttributes: function(prototype, base) {\n // merg
e names from 'attributes' attribute into the 'publish' object\n var attribu
tes = this.getAttribute(ATTRIBUTES_ATTRIBUTE);\n if (attributes) {\n
// create a `publish` object if needed.\n // the `publish` object is onl
y relevant to this prototype, the \n // publishing logic in `declaration/
properties.js` is responsible for\n // managing property values on the pr
ototype chain.\n // TODO(sjmiles): the `publish` object is later chained
to it's \n // ancestor object, presumably this is only for
\n // reflection or other non-library uses. \n var
publish = prototype.publish || (prototype.publish = {}); \n // names='a
b c' or names='a,b,c'\n var names = attributes.split(ATTRIBUTES_REGEX);\n
// record each name for publishing\n for (var i=0, l=names.length
, n; i<l; i++) {\n // remove excess ws\n n = names[i].trim();\
n // looks weird, but causes n to exist on `publish` if it does not;\n
// a more careful test would need expensive `in` operator\n if
(n && publish[n] === undefined) {\n publish[n] = undefined;\n
}\n }\n }\n },\n\n // record clonable attributes from <elem
ent>\n accumulateInstanceAttributes: function() {\n // inherit instance
attributes\n var clonable = this.prototype._instanceAttributes;\n // m
erge 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.isInstanceAttr
ibute(a.name)) {\n clonable[a.name] = a.value;\n }\n }\n
},\n\n isInstanceAttribute: function(name) {\n return !this.blackList[n
ame] && name.slice(0,3) !== 'on-';\n },\n\n // do not clone these attribut
es onto instances\n blackList: {\n name: 1,\n 'extends': 1,\n
constructor: 1,\n noscript: 1,\n assetpath: 1,\n 'cache-csstext':
1\n }\n \n };\n\n // add ATTRIBUTES_ATTRIBUTE to the blacklist\n attri
butes.blackList[ATTRIBUTES_ATTRIBUTE] = 1;\n\n // exports\n\n scope.api.declar
ation.attributes = attributes;\n\n})(Polymer);\n\n/*\n * Copyright (c) 2014 The
Polymer Project Authors. All rights reserved.\n * This code may only be used und
er the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The c
omplete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n *
The complete set of contributors may be found at http://polymer.github.io/CONTRI
BUTORS.txt\n * Code distributed by Google as part of the polymer project is also
\n * subject to an additional IP rights grant found at http://polymer.github.io/
PATENTS.txt\n */\n\n(function(scope) {\n\n // imports\n var events = scope.api
.declaration.events;\n\n var syntax = new PolymerExpressions();\n var prepareB
inding = syntax.prepareBinding;\n\n // Polymer takes a first crack at the bindi
ng to see if it's a declarative\n // event handler.\n syntax.prepareBinding =
function(pathString, name, node) {\n return events.prepareEventBinding(pathSt
ring, name, node) ||\n prepareBinding.call(syntax, pathString, name, n
ode);\n };\n\n // declaration api supporting mdv\n var mdv = {\n syntax: s
yntax,\n fetchTemplate: function() {\n return this.querySelector('templa
te');\n },\n templateContent: function() {\n var template = this.fetc
hTemplate();\n return template && template.content;\n },\n installBin
dingDelegate: function(template) {\n if (template) {\n template.bind
ingDelegate = this.syntax;\n }\n }\n };\n\n // exports\n scope.api.de
claration.mdv = mdv;\n\n})(Polymer);\n\n/*\n * Copyright (c) 2014 The Polymer Pr
oject Authors. All rights reserved.\n * This code may only be used under the BSD
style license found at http://polymer.github.io/LICENSE.txt\n * The complete se
t of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The comple
te set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
\n * Code distributed by Google as part of the polymer project is also\n * subje
ct to an additional IP rights grant found at http://polymer.github.io/PATENTS.tx
t\n */\n\n(function(scope) {\n\n // imports\n \n var api = scope.api;\n var
isBase = scope.isBase;\n var extend = scope.extend;\n\n var hasShadowDOMPolyfi
ll = window.ShadowDOMPolyfill;\n\n // prototype api\n\n var prototype = {\n\n
register: function(name, extendeeName) {\n // build prototype combining
extendee, Polymer base, and named api\n this.buildPrototype(name, extendeeN
ame);\n // register our custom element with the platform\n this.regist
erPrototype(name, extendeeName);\n // reference constructor in a global nam
ed by 'constructor' attribute\n this.publishConstructor();\n },\n\n b
uildPrototype: 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(extende
eName);\n // implement declarative features\n this.desugarBeforeChaini
ng(extension, base);\n // join prototypes\n this.prototype = this.chai
nPrototypes(extension, base);\n // more declarative features\n this.de
sugarAfterChaining(name, extendeeName);\n },\n\n desugarBeforeChaining: fu
nction(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 ow
n prototype's `publish`\n this.publishAttributes(prototype, base);\n /
/ `publish` properties to the prototype and to attribute watch\n this.publi
shProperties(prototype, base);\n // infer observers for `observe` list base
d on method names\n this.inferObservers(prototype);\n // desugar compo
und 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, b
ase);\n // chain custom api to inherited\n var chained = this.chainObj
ect(prototype, base);\n // x-platform fixup\n ensurePrototypeTraversal
(chained);\n return chained;\n },\n\n inheritMetaData: function(proto
type, base) {\n // chain observe object to inherited\n this.inheritObj
ect('observe', prototype, base);\n // chain publish object to inherited\n
this.inheritObject('publish', prototype, base);\n // chain reflect obje
ct to inherited\n this.inheritObject('reflect', prototype, base);\n //
chain our lower-cased publish map to the inherited version\n this.inheritO
bject('_publishLC', prototype, base);\n // chain our instance attributes ma
p to the inherited version\n this.inheritObject('_instanceAttributes', prot
otype, base);\n // chain our event delegates map to the inherited version\n
this.inheritObject('eventDelegates', prototype, base);\n },\n\n // i
mplement various declarative features\n desugarAfterChaining: function(name,
extendee) {\n // build side-chained lists to optimize iterations\n thi
s.optimizePropertyMaps(this.prototype);\n this.createPropertyAccessors(this
.prototype);\n // install mdv delegate on template\n this.installBindi
ngDelegate(this.fetchTemplate());\n // install external stylesheets as if t
hey are inline\n this.installSheets();\n // adjust any paths in dom fr
om imports\n this.resolveElementPaths(this);\n // compile list of attr
ibutes 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('im
ages/foo.png')\n this.addResolvePathApi();\n // under ShadowDOMPolyfil
l, transforms to approximate missing CSS features\n if (hasShadowDOMPolyfil
l) {\n Platform.ShadowCSS.shimStyling(this.templateContent(), name, exten
dee);\n }\n // allow custom element access to the declarative context\
n if (this.prototype.registerCallback) {\n this.prototype.registerCa
llback(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 pub
lishConstructor: 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 ge
nerateBasePrototype: function(extnds) {\n var prototype = this.findBaseProt
otype(extnds);\n if (!prototype) {\n // create a prototype based on
tag-name extension\n var prototype = HTMLElement.getPrototypeForTag(extnd
s);\n // insert base api in inheritance chain (if needed)\n protot
ype = this.ensureBaseApi(prototype);\n // memoize this base\n memo
izedBases[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 ensu
reBaseApi: function(prototype) {\n if (prototype.PolymerBase) {\n re
turn 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, ex
tended);\n // TODO(sjmiles): sharing methods across prototype chains is\n
// not supported by 'super' implementation which optimizes\n // by memo
izing prototype relationships.\n // Probably we should have a version of 'e
xtend' 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 // clos
ures.\n // As of now, there is only one problematic method, so \n // w
e just patch it manually.\n // To avoid re-entrancy problems, the special s
uper method\n // installed is called `mixinSuper` and the mixin method\n
// must use this method instead of the default `super`.\n this.mixinMeth
od(extended, prototype, api.instance.mdv, 'bind');\n // return buffed-up pr
ototype\n return extended;\n },\n\n mixinMethod: function(extended, p
rototype, api, name) {\n var $super = function(args) {\n return prot
otype[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.p
rototype[name]\n inheritObject: function(name, prototype, base) {\n // r
equire an object\n var source = prototype[name] || {};\n // chain inhe
rited properties onto a new object\n prototype[name] = this.chainObject(sou
rce, 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 eleme
nt must be specified in extends\n var typeExtension = this.findTypeExtensio
n(extendee);\n if (typeExtension) {\n info.extends = typeExtension;\
n }\n // register the prototype with HTMLElement for name lookup\n
HTMLElement.register(name, this.prototype);\n // register the custom type
\n this.ctor = document.registerElement(name, info);\n },\n\n findTyp
eExtension: 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.exten
ds);\n }\n }\n }\n\n };\n\n // memoize base prototypes\n var m
emoizedBases = {};\n\n // implementation of 'chainObject' depends on support fo
r __proto__\n if (Object.__proto__) {\n prototype.chainObject = function(obj
ect, inherited) {\n if (object && inherited && object !== inherited) {\n
object.__proto__ = inherited;\n }\n return object;\n }\n } el
se {\n prototype.chainObject = function(object, inherited) {\n if (objec
t && inherited && object !== inherited) {\n var chained = Object.create(i
nherited);\n object = extend(chained, object);\n }\n return obj
ect;\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 installatio
n 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.getProto
typeOf(prototype);\n prototype.__proto__ = ancestor;\n if (isBase(ance
stor)) {\n ancestor.__proto__ = Object.getPrototypeOf(ancestor);\n }
\n }\n }\n\n // exports\n\n api.declaration.prototype = prototype;\n\n})(P
olymer);\n\n/*\n * Copyright (c) 2014 The Polymer Project Authors. All rights re
served.\n * This code may only be used under the BSD style license found at http
://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at
http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may b
e found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Goo
gle as part of the polymer project is also\n * subject to an additional IP right
s grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {
\n\n /*\n\n Elements are added to a registration queue so that they register
in \n the proper order at the appropriate time. We do this for a few reasons
:\n\n * to enable elements to load resources (like stylesheets) \n asynchr
onously. We need to do this until the platform provides an efficient\n altern
ative. One issue is that remote @import stylesheets are \n re-fetched wheneve
r stamped into a shadowRoot.\n\n * to ensure elements loaded 'at the same tim
e' (e.g. via some set of\n imports) are registered as a batch. This allows el
ements to be enured from\n upgrade ordering as long as they query the dom tre
e 1 task after\n upgrade (aka domReady). This is a performance tradeoff. On t
he one hand,\n elements that could register while imports are loading are pre
vented from \n doing so. On the other, grouping upgrades into a single task m
eans less\n incremental work (for example style recalcs), Also, we can ensur
e the \n document is in a known state at the single quantum of time when \n
elements upgrade.\n\n */\n var queue = {\n\n // tell the queue to wait fo
r an element to be ready\n wait: function(element) {\n if (!element.__qu
eue) {\n element.__queue = {};\n elements.push(element);\n }\
n },\n\n // enqueue an element to the next spot in the queue.\n enqueue
: function(element, check, go) {\n var shouldAdd = element.__queue && !elem
ent.__queue.check;\n if (shouldAdd) {\n queueForElement(element).pus
h(element);\n element.__queue.check = check;\n element.__queue.go
= go;\n }\n return (this.indexOf(element) !== 0);\n },\n\n index
Of: function(element) {\n var i = queueForElement(element).indexOf(element)
;\n if (i >= 0 && document.contains(element)) {\n i += (HTMLImports.
useNative || HTMLImports.ready) ? \n importQueue.length : 1e9;\n }
\n return i; \n },\n\n // tell the queue an element is ready to be r
egistered\n go: function(element) {\n var readied = this.remove(element)
;\n if (readied) {\n element.__queue.flushable = true;\n this
.addToFlushQueue(readied);\n this.check();\n }\n },\n\n remove
: function(element) {\n var i = this.indexOf(element);\n if (i !== 0)
{\n //console.warn('queue order wrong', i);\n return;\n }\n
return queueForElement(element).shift();\n },\n\n check: function() {\
n // next\n var element = this.nextElement();\n if (element) {\n
element.__queue.check.call(element);\n }\n if (this.canReady())
{\n this.ready();\n return true;\n }\n },\n\n nextElem
ent: function() {\n return nextQueued();\n },\n\n canReady: function(
) {\n return !this.waitToReady && this.isEmpty();\n },\n\n isEmpty: f
unction() {\n for (var i=0, l=elements.length, e; (i<l) && \n (e=e
lements[i]); i++) {\n if (e.__queue && !e.__queue.flushable) {\n
return;\n }\n }\n return true;\n },\n\n addToFlushQueue:
function(element) {\n flushQueue.push(element); \n },\n\n flush: fu
nction() {\n // prevent re-entrance\n if (this.flushing) {\n re
turn;\n }\n this.flushing = true;\n var element;\n while (fl
ushQueue.length) {\n element = flushQueue.shift();\n element.__que
ue.go.call(element);\n element.__queue = null;\n }\n this.flush
ing = false;\n },\n\n ready: function() {\n // TODO(sorvell): As an o
ptimization, turn off CE polyfill upgrading\n // while registering. This wa
y we avoid having to upgrade each document\n // piecemeal per registration
and can instead register all elements\n // and upgrade once in a batch. Wit
hout this optimization, upgrade time\n // degrades significantly when SD po
lyfill is used. This is mainly because\n // querying the document tree for
elements is slow under the SD polyfill.\n var polyfillWasReady = CustomElem
ents.ready;\n CustomElements.ready = false;\n this.flush();\n if
(!CustomElements.useNative) {\n CustomElements.upgradeDocumentTree(docume
nt);\n }\n CustomElements.ready = polyfillWasReady;\n Platform.fl
ush();\n requestAnimationFrame(this.flushReadyCallbacks);\n },\n\n ad
dReadyCallback: function(callback) {\n if (callback) {\n readyCallba
cks.push(callback);\n }\n },\n\n flushReadyCallbacks: function() {\n
if (readyCallbacks) {\n var fn;\n while (readyCallbacks.lengt
h) {\n fn = readyCallbacks.shift();\n fn();\n }\n
}\n },\n \n /**\n Returns a list of elements that have had polymer-ele
ments created but \n are not yet ready to register. The list is an array of e
lement definitions.\n */\n waitingFor: function() {\n var e$ = [];\n
for (var i=0, l=elements.length, e; (i<l) && \n (e=elements[i]); i
++) {\n if (e.__queue && !e.__queue.flushable) {\n e$.push(e);\n
}\n }\n return e$;\n },\n\n waitToReady: true\n\n };\n\
n var elements = [];\n var flushQueue = [];\n var importQueue = [];\n var ma
inQueue = [];\n var readyCallbacks = [];\n\n function queueForElement(element)
{\n return document.contains(element) ? mainQueue : importQueue;\n }\n\n f
unction nextQueued() {\n return importQueue.length ? importQueue[0] : mainQue
ue[0];\n }\n\n function whenReady(callback) {\n queue.waitToReady = true;\n
Platform.endOfMicrotask(function() {\n HTMLImports.whenReady(function()
{\n queue.addReadyCallback(callback);\n queue.waitToReady = false
;\n queue.check();\n });\n });\n }\n\n /**\n Forces polymer to
register any pending elements. Can be used to abort\n waiting for elements t
hat are partially defined.\n @param timeout {Integer} Optional timeout in mil
liseconds\n */\n function forceReady(timeout) {\n if (timeout === undefined
) {\n queue.ready();\n return;\n }\n var handle = setTimeout(fun
ction() {\n queue.ready();\n }, timeout);\n Polymer.whenReady(functio
n() {\n clearTimeout(handle);\n });\n }\n\n // exports\n scope.elemen
ts = elements;\n scope.waitingFor = queue.waitingFor.bind(queue);\n scope.forc
eReady = forceReady;\n scope.queue = queue;\n scope.whenReady = scope.whenPoly
merReady = whenReady;\n})(Polymer);\n\n/*\n * Copyright (c) 2014 The Polymer Pro
ject Authors. All rights reserved.\n * This code may only be used under the BSD
style license found at http://polymer.github.io/LICENSE.txt\n * The complete set
of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complet
e set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\
n * Code distributed by Google as part of the polymer project is also\n * subjec
t to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
\n */\n\n(function(scope) {\n\n // imports\n\n var extend = scope.extend;\n v
ar api = scope.api;\n var queue = scope.queue;\n var whenReady = scope.whenRea
dy;\n var getRegisteredPrototype = scope.getRegisteredPrototype;\n var waiting
ForPrototype = scope.waitingForPrototype;\n\n // declarative implementation: <p
olymer-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 // fetc
h declared values\n this.name = this.getAttribute('name');\n this.exte
nds = this.getAttribute('extends');\n queue.wait(this);\n // initiate
any async resource fetches\n this.loadResources();\n // register when
all constraints are met\n this.registerWhenReady();\n },\n\n // TODO(
sorvell): we currently queue in the order the prototypes are \n // registered
, but we should queue in the order that polymer-elements\n // are registered.
We are currently blocked from doing this based on \n // crbug.com/395686.\n
registerWhenReady: function() {\n if (this.registered\n || this.wai
tingForPrototype(this.name)\n || this.waitingForQueue()\n || this.wa
itingForResources()) {\n return;\n }\n queue.go(this);\n }
,\n\n _register: function() {\n //console.log('registering', this.name);
\n // warn if extending from a custom element not registered via Polymer\n
if (isCustomTag(this.extends) && !isRegistered(this.extends)) {\n co
nsole.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.r
egistered = true;\n },\n\n waitingForPrototype: function(name) {\n if
(!getRegisteredPrototype(name)) {\n // then wait for a prototype\n
waitingForPrototype(name, this);\n // emulate script if user is not sup
plying one\n this.handleNoScript(name);\n // prototype not ready y
et\n return true;\n }\n },\n\n handleNoScript: function(name)
{\n // if explicitly marked as 'noscript'\n if (this.hasAttribute('nos
cript') && !this.noscript) {\n this.noscript = true;\n // imperati
ve element registration\n Polymer(name);\n }\n },\n\n waitingF
orResources: 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 // a
nd by rule for composition. It's now entirely by rule.\n waitingForQueue: fun
ction() {\n return queue.enqueue(this, this.registerWhenReady, this._regist
er);\n },\n\n loadResources: function() {\n this._needsResources = tr
ue;\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 decou
pled, currently\n // the various plugins are allowed to depend on each other di
rectly)\n api.publish(api.declaration, prototype);\n\n // utility and bookkeep
ing\n\n function isRegistered(name) {\n return Boolean(HTMLElement.getProtot
ypeForTag(name));\n }\n\n function isCustomTag(name) {\n return (name && na
me.indexOf('-') >= 0);\n }\n\n // boot tasks\n\n whenReady(function() {\n
document.body.removeAttribute('unresolved');\n document.dispatchEvent(\n
new CustomEvent('polymer-ready', {bubbles: true})\n );\n });\n\n // regist
er polymer-element with document\n\n document.registerElement('polymer-element'
, {prototype: prototype});\n\n})(Polymer);\n\n/*\n * Copyright (c) 2014 The Poly
mer Project Authors. All rights reserved.\n * This code may only be used under t
he BSD style license found at http://polymer.github.io/LICENSE.txt\n * The compl
ete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The
complete set of contributors may be found at http://polymer.github.io/CONTRIBUTO
RS.txt\n * Code distributed by Google as part of the polymer project is also\n *
subject to an additional IP rights grant found at http://polymer.github.io/PATE
NTS.txt\n */\n\n(function(scope) {\n\n var whenPolymerReady = scope.whenPolymer
Ready;\n\n function importElements(elementOrFragment, callback) {\n if (elem
entOrFragment) {\n document.head.appendChild(elementOrFragment);\n whe
nPolymerReady(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=u
rls.length, url, link; (i<l) && (url=urls[i]); i++) {\n link = document
.createElement('link');\n link.rel = 'import';\n link.href = u
rl;\n frag.appendChild(link);\n }\n importElements(frag,
callback);\n } else if (callback) {\n callback();\n }\n }\n\n // ex
ports\n scope.import = importUrls;\n scope.importElements = importElements;\n\
n})(Polymer);\n\n/*\n * Copyright (c) 2014 The Polymer Project Authors. All righ
ts reserved.\n * This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be fou
nd at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors
may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed b
y Google as part of the polymer project is also\n * subject to an additional IP
rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n/**\n * The `
auto-binding` element extends the template element. It provides a quick \n * and
easy way to do data binding without the need to setup a model. \n * The `auto-b
inding` element itself serves as the model and controller for the \n * elements
it contains. Both data and event handlers can be bound. \n *\n * The `auto-bindi
ng` element acts just like a template that is bound to \n * a model. It stamps i
ts content in the dom adjacent to itself. When the \n * content is stamped, the
`template-bound` event is fired.\n *\n * Example:\n *\n * <template is=\"aut
o-binding\">\n * <div>Say something: <input value=\"{{value}}\"></div>\n *
<div>You said: {{value}}</div>\n * <button on-tap=\"{{buttonTap}}\"
>Tap me!</button>\n * </template>\n * <script>\n * var template =
document.querySelector('template');\n * template.value = 'something';\n *
template.buttonTap = function() {\n * console.log('tap!');\n *
};\n * </script>\n *\n * @module Polymer\n * @status stable\n*/\n\n(funct
ion() {\n\n var element = document.createElement('polymer-element');\n element
.setAttribute('name', 'auto-binding');\n element.setAttribute('extends', 'templ
ate');\n element.init();\n\n Polymer('auto-binding', {\n\n createdCallback:
function() {\n this.syntax = this.bindingDelegate = this.makeSyntax();\n
// delay stamping until polymer-ready so that auto-binding is not\n //
required to load last.\n Polymer.whenPolymerReady(function() {\n thi
s.model = this;\n this.setAttribute('bind', '');\n // we don't bot
her with an explicit signal here, we could ust a MO\n // if necessary\n
this.async(function() {\n // note: this will marshall *all* the e
lements in the parentNode\n // rather than just stamped ones. We'd need
to use createInstance\n // to fix this or something else fancier.\n
this.marshalNodeReferences(this.parentNode);\n // template stamp
ing is asynchronous so stamping isn't complete\n // by polymer-ready; f
ire an event so users can use stamped elements\n this.fire('template-bo
und');\n });\n }.bind(this));\n },\n\n makeSyntax: function()
{\n var events = Object.create(Polymer.api.declaration.events);\n var
self = this;\n events.findController = function() { return self.model; };\n
\n var syntax = new PolymerExpressions();\n var prepareBinding = synta
x.prepareBinding; \n syntax.prepareBinding = function(pathString, name, no
de) {\n return events.prepareEventBinding(pathString, name, node) ||\n
prepareBinding.call(syntax, pathString, name, node);\n };\n
return syntax;\n }\n\n });\n\n})();\n\n//# sourceMappingURL=polymer.concat
.js.map"]} | |
Chromium Code Reviews
Issue 786953007:
npm_modules: Fork bower_components into Polymer 0.4.0 and 0.5.0 versions (Closed)
Base URL: https://chromium.googlesource.com/infra/third_party/npm_modules.git@master