You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 lines
2.0 MiB
1 lines
2.0 MiB
{"version":3,"sources":["webpack:///static/js/vendor.969602d126b5ff83a532.js","webpack:///./~/core-js/library/modules/_wks.js","webpack:///./~/core-js/library/modules/_global.js","webpack:///./~/vue-loader/lib/component-normalizer.js","webpack:///./~/core-js/library/modules/_an-object.js","webpack:///./~/core-js/library/modules/_descriptors.js","webpack:///./~/core-js/library/modules/_has.js","webpack:///./~/core-js/library/modules/_hide.js","webpack:///./~/core-js/library/modules/_object-dp.js","webpack:///./~/core-js/library/modules/_core.js","webpack:///./~/core-js/library/modules/_defined.js","webpack:///./~/core-js/library/modules/_is-object.js","webpack:///./~/core-js/library/modules/_iterators.js","webpack:///./~/core-js/library/modules/_property-desc.js","webpack:///./~/core-js/library/modules/_shared-key.js","webpack:///./~/core-js/library/modules/_to-integer.js","webpack:///./~/vue/dist/vue.common.js","webpack:///./~/core-js/library/modules/_cof.js","webpack:///./~/core-js/library/modules/_ctx.js","webpack:///./~/core-js/library/modules/_dom-create.js","webpack:///./~/core-js/library/modules/_enum-bug-keys.js","webpack:///./~/core-js/library/modules/_export.js","webpack:///./~/core-js/library/modules/_fails.js","webpack:///./~/core-js/library/modules/_set-to-string-tag.js","webpack:///./~/core-js/library/modules/_shared.js","webpack:///./~/core-js/library/modules/_to-iobject.js","webpack:///./~/core-js/library/modules/_to-length.js","webpack:///./~/core-js/library/modules/_to-object.js","webpack:///./~/core-js/library/modules/_uid.js","webpack:///./~/d3/build/d3.js","webpack:///./~/babel-runtime/core-js/array/from.js","webpack:///./~/babel-runtime/helpers/toConsumableArray.js","webpack:///./~/core-js/library/fn/array/from.js","webpack:///./~/core-js/library/modules/_a-function.js","webpack:///./~/core-js/library/modules/_array-includes.js","webpack:///./~/core-js/library/modules/_classof.js","webpack:///./~/core-js/library/modules/_create-property.js","webpack:///./~/core-js/library/modules/_html.js","webpack:///./~/core-js/library/modules/_ie8-dom-define.js","webpack:///./~/core-js/library/modules/_iobject.js","webpack:///./~/core-js/library/modules/_is-array-iter.js","webpack:///./~/core-js/library/modules/_iter-call.js","webpack:///./~/core-js/library/modules/_iter-create.js","webpack:///./~/core-js/library/modules/_iter-define.js","webpack:///./~/core-js/library/modules/_iter-detect.js","webpack:///./~/core-js/library/modules/_library.js","webpack:///./~/core-js/library/modules/_object-create.js","webpack:///./~/core-js/library/modules/_object-dps.js","webpack:///./~/core-js/library/modules/_object-gpo.js","webpack:///./~/core-js/library/modules/_object-keys-internal.js","webpack:///./~/core-js/library/modules/_object-keys.js","webpack:///./~/core-js/library/modules/_redefine.js","webpack:///./~/core-js/library/modules/_string-at.js","webpack:///./~/core-js/library/modules/_to-index.js","webpack:///./~/core-js/library/modules/_to-primitive.js","webpack:///./~/core-js/library/modules/core.get-iterator-method.js","webpack:///./~/core-js/library/modules/es6.array.from.js","webpack:///./~/core-js/library/modules/es6.string.iterator.js","webpack:///./~/vue-router/dist/vue-router.common.js","webpack:///./~/vue-style-loader/lib/listToStyles.js","webpack:///(webpack)/buildin/global.js","webpack:///./~/css-loader/lib/css-base.js","webpack:///./~/vue-style-loader/lib/addStylesClient.js"],"names":["webpackJsonp","module","exports","__webpack_require__","store","uid","Symbol","USE_SYMBOL","$exports","name","global","window","Math","self","Function","__g","rawScriptExports","compiledTemplate","scopeId","cssModules","esModule","scriptExports","type","default","options","render","staticRenderFns","_scopeId","computed","Object","keys","forEach","key","isObject","it","TypeError","defineProperty","get","a","hasOwnProperty","call","dP","createDesc","object","value","f","anObject","IE8_DOM_DEFINE","toPrimitive","O","P","Attributes","e","core","version","__e","undefined","bitmap","enumerable","configurable","writable","shared","ceil","floor","isNaN","_toString","val","JSON","stringify","String","toNumber","n","parseFloat","makeMap","str","expectsLowerCase","map","create","list","split","i","length","toLowerCase","remove$1","arr","item","index","indexOf","splice","hasOwn","obj","isPrimitive","cached","fn","cache","hit","bind$1","ctx","boundFn","l","arguments","apply","_length","toArray","start","ret","Array","extend","to","_from","isPlainObject","toString","OBJECT_STRING","toObject","res","noop","genStaticKeys","modules","reduce","m","concat","staticKeys","join","looseEqual","b","isObjectA","isObjectB","looseIndexOf","isReserved","c","charCodeAt","def","parsePath","path","bailRE","test","segments","isNative","Ctor","pushTarget","_target","Dep","target","targetStack","push","popTarget","pop","protoAugment","src","__proto__","copyAugment","observe","asRootData","ob","__ob__","Observer","observerState","shouldConvert","isServerRendering","isArray","isExtensible","_isVue","vmCount","defineReactive$$1","customSetter","dep","property","getOwnPropertyDescriptor","getter","setter","set","childOb","depend","dependArray","newVal","notify","set$1","max","del","mergeData","from","toVal","fromVal","mergeHook","parentVal","childVal","mergeAssets","normalizeProps","props","camelize","normalizeDirectives","dirs","directives","bind","update","mergeOptions","parent","child","vm","mergeField","strat","strats","defaultStrat","extendsFrom","extends","mixins","mixin","prototype","Vue$3","resolveAsset","id","warnMissing","assets","camelizedId","PascalCaseId","capitalize","validateProp","propOptions","propsData","prop","absent","isType","Boolean","hyphenate","getPropDefaultValue","prevShouldConvert","$options","getType","match","len","createTextVNode","VNode","cloneVNode","vnode","cloned","tag","data","children","text","elm","context","componentOptions","ns","isStatic","isCloned","cloneVNodes","vnodes","createComponent","baseCtor","_base","cid","resolved","resolveAsyncComponent","$forceUpdate","resolveConstructorOptions","extractProps","functional","createFunctionalComponent","listeners","on","nativeOn","abstract","mergeHooks","_context","h","d","createElement","slots","resolveSlots","functionalContext","slot","createComponentInstanceForVnode","parentElm","refElm","vnodeComponentOptions","_isComponent","_componentTag","_parentVnode","_parentListeners","_renderChildren","_parentElm","_refElm","inlineTemplate","init","hydrating","componentInstance","_isDestroyed","activeInstance","$mount","keepAlive","mountedNode","prepatch","oldVnode","_updateFromParent","insert","_isMounted","callHook","_inactive","destroy$1","$destroy","factory","cb","requested","cbs","pendingCallbacks","sync","resolve","reject","reason","then","attrs","domProps","altKey","checkProp","hash","preserve","hook","hooksToMerge","fromParent","ours","hooks","mergeHook$1","one","two","mergeVNodeHook","hookKey","injectedHash","__injected","oldHook","this","createEventHandle","handle","invoker","arguments$1","updateListeners","oldOn","add","remove$$1","cur","old","event","normalizeEvent","once","capture","simpleNormalizeChildren","normalizeChildren","normalizeArrayChildren","nestedIndex","last","getFirstComponentChild","filter","normalizationType","alwaysNormalize","ALWAYS_NORMALIZE","_createElement","createEmptyVNode","scopedSlots","SIMPLE_NORMALIZE","config","getTagNamespace","isReservedTag","parsePlatformTagName","applyNS","initRender","$vnode","_vnode","_staticTrees","parentVnode","renderContext","$slots","$scopedSlots","_c","$createElement","renderMixin","Vue","markStatic","tree","isOnce","markStaticNode","node","$nextTick","nextTick","_render","ref","_renderProxy","errorHandler","_s","_v","_n","_e","_q","_i","_m","isInFor","_o","_f","identity","_l","_t","fallback","bindObject","scopedSlotFn","slotNodes","_b","asProp","mustUseProp","_k","eventKeyCode","builtInAlias","keyCodes","defaultSlot","isComment","initEvents","_events","_hasHookEvent","updateComponentListeners","add$1","$once","$on","remove$2","$off","oldListeners","eventsMixin","hookRE","$emit","args","initLifecycle","$parent","$children","$root","$refs","_watcher","_isBeingDestroyed","lifecycleMixin","_mount","el","$el","Watcher","_update","prevEl","prevVnode","prevActiveInstance","__patch__","__vue__","renderChildren","hasChildren","propKeys","_propKeys","teardown","_watchers","_data","handlers","j","resetSchedulerState","queue","has$1","waiting","flushing","flushSchedulerQueue","watcher","sort","run","devtools","emit","queueWatcher","traverse","seenObjects","clear","_traverse","seen","isA","depId","has","initState","opts","initProps","methods","initMethods","initData","initComputed","watch","initWatch","isRoot","loop","proxy","userDef","computedSharedDefinition","makeComputedGetter","owner","lazy","dirty","evaluate","handler","createWatcher","$watch","stateMixin","dataDef","$set","$delete","expOrFn","user","immediate","initMixin","_init","_uid","initInternalComponent","constructor","_self","super","superOptions","cachedSuperOptions","extendOptions","components","initUse","use","plugin","installed","unshift","install","initMixin$1","initExtend","Super","SuperId","cachedCtors","_Ctor","Sub","_assetTypes","initAssetRegisters","definition","getComponentName","matches","pattern","pruneCache","cachedNode","pruneCacheEntry","initGlobalAPI","configDef","util","delete","builtInComponents","genClassForVnode","parentNode","childNode","mergeClassData","genClassFromData","staticClass","class","dynamicClass","stringifyClass","stringified","slice","isSVG","isUnknownElement","inBrowser","unknownElementCache","document","HTMLUnknownElement","HTMLElement","query","querySelector","createElement$1","tagName","setAttribute","createElementNS","namespace","namespaceMap","createTextNode","createComment","insertBefore","newNode","referenceNode","removeChild","appendChild","nextSibling","setTextContent","textContent","registerRef","isRemoval","refs","refInFor","isUndef","s","isDef","sameVnode","vnode1","vnode2","createKeyToOldIdx","beginIdx","endIdx","createPatchFunction","backend","emptyNodeAt","nodeOps","createRmCb","childElm","removeNode","createElm","insertedVnodeQueue","nested","isRootInsert","setScope","createChildren","invokeCreateHooks","isReactivated","initComponent","reactivateComponent","pendingInsert","isPatchable","innerNode","transition","activate","emptyNode","i$1","addVnodes","startIdx","invokeDestroyHook","destroy","removeVnodes","ch","removeAndInvokeRemoveHook","rm","remove","updateChildren","oldCh","newCh","removeOnly","oldKeyToIdx","idxInOld","elmToMove","oldStartIdx","newStartIdx","oldEndIdx","oldStartVnode","oldEndVnode","newEndIdx","newStartVnode","newEndVnode","canMove","patchVnode","hasData","postpatch","invokeInsertHook","initial","hydrate","hasChildNodes","childrenMatch","firstChild","isRenderedModule","hooks$1","isInitialPatch","isRealElement","nodeType","hasAttribute","removeAttribute","oldElm","parentElm$1","_leaveCb","ancestor","updateDirectives","oldDir","dir","isCreate","isDestroy","oldDirs","normalizeDirectives$1","newDirs","dirsWithInsert","dirsWithPostpatch","oldValue","callHook$1","componentUpdated","inserted","callInsert","modifiers","emptyModifiers","getRawDirName","rawName","updateAttrs","oldAttrs","setAttr","isIE9","isXlink","removeAttributeNS","xlinkNS","getXlinkProp","isEnumeratedAttr","isBooleanAttr","isFalsyAttrValue","setAttributeNS","updateClass","oldData","cls","transitionClass","_transitionClasses","_prevClass","add$2","oldHandler","target$1","ev","remove$3","addEventListener","removeEventListener","updateDOMListeners","updateDOMProps","oldProps","_value","strCur","shouldUpdateValue","checkVal","composing","isDirty","isInputChanged","activeElement","_vModifiers","number","trim","normalizeStyleData","style","normalizeStyleBinding","staticStyle","bindingStyle","parseStyleText","getStyle","checkChild","styleData","updateStyle","oldStaticStyle","oldStyleBinding","oldStyle","newStyle","setProp","addClass","classList","getAttribute","removeClass","tar","replace","nextFrame","raf","addTransitionClass","removeTransitionClass","whenTransitionEnds","expectedType","getTransitionInfo","timeout","propCount","TRANSITION","transitionEndEvent","animationEndEvent","ended","end","onEnd","setTimeout","styles","getComputedStyle","transitioneDelays","transitionProp","transitionDurations","transitionTimeout","getTimeout","animationDelays","animationProp","animationDurations","animationTimeout","ANIMATION","hasTransform","transformRE","delays","durations","toMs","Number","enter","toggleDisplay","cancelled","resolveTransition","_enterCb","css","enterClass","enterToClass","enterActiveClass","appearClass","appearToClass","appearActiveClass","beforeEnter","afterEnter","enterCancelled","beforeAppear","appear","afterAppear","appearCancelled","transitionNode","isAppear","startClass","activeClass","toClass","beforeEnterHook","enterHook","afterEnterHook","enterCancelledHook","expectsCSS","userWantsControl","show","pendingNode","_pending","leave","performLeave","beforeLeave","leaveClass","leaveActiveClass","leaveToClass","afterLeave","leaveCancelled","delayLeave","def$$1","autoCssTransition","called","_enter","_","setSelected","binding","isMultiple","multiple","selected","option","getValue","selectedIndex","hasNoMatchingOption","onCompositionStart","onCompositionEnd","trigger","createEvent","initEvent","dispatchEvent","locateNode","getRealChild","compOptions","extractTransitionData","comp","key$1","placeholder","rawChild","hasParentTransition","isSameChild","oldChild","callPendingCbs","_moveCb","recordPosition","newPos","getBoundingClientRect","applyTranslation","oldPos","pos","dx","left","dy","top","moved","transform","WebkitTransform","transitionDuration","shouldDecode","content","encoded","div","innerHTML","decode","html","decoder","decodeAttr","shouldDecodeNewlines","nlRE","ltRE","gtRE","ampRE","quoteRE","parseHTML","advance","substring","parseStartTag","startTagOpen","attr","startTagClose","attribute","unarySlash","handleStartTag","expectHTML","lastTag","isNonPhrasingTag","parseEndTag","canBeLeftOpenTag","unary","isUnaryTag$$1","IS_REGEX_CAPTURING_BROKEN","stack","lowerCasedTag","lowerCasedTagName","isUnaryTag","no","isScriptOrStyle","stackedTag","reStackedTag","reCache","RegExp","endTagLength","rest","all","endTag","chars","textEnd","comment","commentEnd","conditionalComment","conditionalEnd","doctypeMatch","doctype","endTagMatch","curIndex","startTagMatch","rest$1","next","parseFilters","exp","pushFilter","filters","lastFilterIndex","prev","expression","inSingle","inDouble","inTemplateString","inRegex","curly","square","paren","p","charAt","wrapFilter","parseText","delimiters","tagRE","buildRegex","defaultTagRE","tokens","lastIndex","exec","baseWarn","msg","console","error","pluckModuleFunction","addProp","addAttr","addDirective","arg","addHandler","important","events","native","nativeEvents","newHandler","getBindingAttr","getStatic","dynamicValue","getAndRemoveAttr","staticValue","attrsMap","attrsList","parseModel","index$1","expressionPos","expressionEndPos","lastIndexOf","idx","eof","chr","isStringStart","parseString","parseBracket","inBracket","stringQuote","parse","template","warn$1","warn","platformGetTagNamespace","platformMustUseProp","platformIsPreTag","isPreTag","preTransforms","transforms","postTransforms","root","currentParent","preserveWhitespace","inVPre","inPre","checkRootConstraints","isIE","guardIESVGBug","element","makeAttrsMap","isForbiddenTag","forbidden","processPre","pre","processRawAttrs","processFor","processIf","processOnce","processKey","plain","processRef","processSlot","processComponent","processAttrs","if","elseif","else","addIfCondition","block","processIfConditions","slotScope","slotTarget","i$2","lastNode","decodeHTMLCached","checkInFor","inMatch","forAliasRE","for","alias","iteratorMatch","forIteratorRE","iterator1","iterator2","findPrevElement","condition","ifConditions","slotName","component","isProp","dirRE","hasBindings","parseModifiers","modifierRE","bindRE","camel","onRE","argMatch","argRE","ieNSBug","ieNSPrefix","optimize","isStaticKey","genStaticKeysCached","isPlatformReservedTag","markStaticRoots","genStaticKeys$1","static","staticInFor","staticRoot","walkThroughConditionsBlocks","conditionBlocks","isBuiltInTag","isDirectChildOfTemplateFor","every","genHandlers","genHandler","code","modifierCode","genKeyFilter","handlerCode","simplePathRE","fnExpRE","genFilterCode","keyVal","parseInt","bind$2","wrapData","generate","ast","prevStaticRenderFns","currentStaticRenderFns","prevOnceCount","onceCount","currentOptions","warn$2","transforms$1","dataGenFns","platformDirectives$1","isPlatformReservedTag$1","genElement","staticProcessed","genStatic","onceProcessed","genOnce","forProcessed","genFor","ifProcessed","genIf","genSlot","genComponent","genData","genChildren","genIfConditions","conditions","genTernaryExp","shift","genDirectives","genProps","genScopedSlots","genInlineTemplate","needRuntime","hasRuntime","gen","baseDirectives","inlineRenderFns","genScopedSlot","scope","checkSkip","el$1","getNormalizationType","genNode","needsNormalization","some","maybeComponent","genText","transformSpecialNewlines","bind$$1","componentName","compile$1","transformNode","classBinding","genData$1","transformNode$1","styleBinding","genData$2","model$1","_warn","warn$3","genSelect","genCheckboxModel","genRadioModel","genDefaultModel","valueBinding","trueValueBinding","falseValueBinding","genAssignmentCode","needCompositionGuard","valueExpression","assignment","modelRs","compile$$1","baseOptions","compileToFunctions","compiled","makeFunction","getOuterHTML","outerHTML","container","cloneNode","_isServer","_Set","camelizeRE","toUpperCase","hyphenateRE","optionMergeStrategies","silent","ignoredElements","_lifecycleHooks","_maxUpdateCount","hasProto","UA","navigator","userAgent","isEdge","isAndroid","isIOS","env","VUE_ENV","__VUE_DEVTOOLS_GLOBAL_HOOK__","nextTickHandler","pending","copies","callbacks","timerFunc","Promise","logError","err","catch","MutationObserver","counter","observer","textNode","characterData","_resolve","Set","formatComponentName","uid$1","subs","addSub","sub","removeSub","addDep","arrayProto","arrayMethods","method","original","result","observeArray","arrayKeys","getOwnPropertyNames","isSettingProps","augment","walk","items","instanceData","defaultData","freeze","defineReactive","raw","prototypeAccessors","defineProperties","uid$2","deep","active","deps","newDeps","depIds","newDepIds","cleanupDeps","this$1","tmp","patternTypes","KeepAlive","include","exclude","created","destroyed","testEl","acceptValue","svg","math","isHTMLTag","baseModules","klass","cssText","listDelimiter","propertyDelimiter","cssVarRE","importantRE","setProperty","normalize","prefixes","upper","prefixed","hasTransition","ontransitionend","onwebkittransitionend","onanimationend","onwebkitanimationend","requestAnimationFrame","platformModules","patch$1","vmodel","model","needReset","v","originalDisplay","__vOriginalDisplay","display","unbind","platformDirectives","transitionProps","mode","Transition","_leaving","oldRawChild","delayedLeave","moveClass","TransitionGroup","prevChildren","rawChildren","transitionData","kept","removed","c$1","beforeUpdate","updated","hasMove","body","offsetHeight","propertyName","_hasMove","info","platformComponents","singleAttrIdentifier","singleAttrAssign","singleAttrValues","source","ncname","qnameCapture","g","regexEscapeRE","open","close","esc","tab","space","up","right","down","stop","prevent","ctrl","alt","meta","cloak","klass$1","style$1","modules$1","directives$1","idToTemplate","mount","documentElement","compile","aFunction","that","is","hide","PROTOTYPE","$export","own","out","IS_FORCED","F","IS_GLOBAL","G","IS_STATIC","S","IS_PROTO","IS_BIND","B","IS_WRAP","W","expProto","C","virtual","R","U","TAG","stat","SHARED","IObject","defined","toInteger","min","px","random","ascendingComparator","x","ascending","tickStep","count","step0","abs","step1","pow","log","LN10","e10","e5","e2","translateX","scale0","scale1","isFinite","translateY","y","center","scale","offset","bandwidth","round","entering","__axis","axis","orient","values","tickValues","ticks","tickArguments","domain","format","tickFormat","identity$1","spacing","tickSizeInner","tickPadding","bottom","range","range0","range1","position","copy","selection","selectAll","tick","order","tickExit","exit","tickEnter","append","line","select","k","merge","epsilon","tickSizeOuter","each","slice$1","tickSize","axisTop","axisRight","axisBottom","axisLeft","dispatch","t","Error","Dispatch","parseTypenames","typenames","types","callback","creatorInherit","ownerDocument","uri","namespaceURI","xhtml","creatorFixed","fullname","local","local$1","Local","nextId","filterContextListener","listener","group","contextListener","related","relatedTarget","compareDocumentPosition","event1","event0","__data__","parseTypenames$1","onRemove","typename","__on","o","onAdd","wrap","filterEvents","customEvent","sourceEvent","none","empty$1","EnterNode","datum","_next","_parent","bindIndex","groupLength","dataLength","bindKey","keyValue","nodeByKeyValue","keyValues","keyPrefix","ascending$1","NaN","attrRemove","attrRemoveNS","attrConstant","attrConstantNS","attrFunction","attrFunctionNS","styleRemove","removeProperty","styleConstant","priority","styleFunction","propertyRemove","propertyConstant","propertyFunction","classArray","string","ClassList","_node","_names","classedAdd","names","classedRemove","classedTrue","classedFalse","classedFunction","textRemove","textConstant","textFunction","htmlRemove","htmlConstant","htmlFunction","raise","lower","previousSibling","constantNull","params","window$$1","CustomEvent","bubbles","cancelable","detail","dispatchConstant","dispatchFunction","Selection","groups","parents","_groups","_parents","nopropagation","stopImmediatePropagation","yesdrag","view","noclick","selection$$1","noevent","MozUserSelect","__noselect","DragEvent","subject","identifier","defaultFilter$1","button","defaultContainer","defaultSubject","Color","color","reHex3","Rgb","reHex6","rgbn","reRgbInteger","reRgbPercent","reRgbaInteger","rgba","reRgbaPercent","reHslPercent","hsla","reHslaPercent","named","r","rgbConvert","rgb","opacity","Hsl","hslConvert","hsl","hsl2rgb","m1","m2","labConvert","Lab","Hcl","deg2rad","cos","sin","rgb2xyz","xyz2lab","Xn","Yn","z","Zn","lab","t3","t2","t0","lab2xyz","t1","xyz2rgb","hclConvert","atan2","rad2deg","sqrt","hcl","cubehelixConvert","Cubehelix","BC_DA","ED","EB","bl","E","D","cubehelix","basis","v0","v1","v2","v3","linear","exponential","hue","constant$3","gamma","nogamma","rgbSpline","spline","colors","color$$1","zero","parseCss","identity$2","cssNode","cssRoot","cssView","defaultView","getPropertyValue","decompose","parseSvg","svgNode","baseVal","consolidate","matrix","interpolateTransform","pxComma","pxParen","degParen","translate","xa","ya","xb","yb","q","reinterpolate","rotate","skewX","scaleX","scaleY","cosh","sinh","tanh","hsl$1","hue$$1","lab$1","hcl$1","cubehelix$1","cubehelixGamma","cubehelix$$1","now","clockNow","setFrame","clearNow","clock","clockSkew","Timer","_call","_time","timer","delay","time","restart","timerFlush","frame","taskHead","wake","clockLast","nap","poke","pokeDelay","Infinity","taskTail","sleep","clearTimeout","interval","clearInterval","setInterval","schedule","__transition","state","CREATED","STARTING","get$1","elapsed","SCHEDULED","schedules","STARTED","timeout$1","RUNNING","ENDED","tween","duration","ease","ENDING","tweenRemove","tween0","tween1","tweenFunction","tweenValue","_id","attrRemove$1","attrRemoveNS$1","attrConstant$1","interpolate$$1","value1","value00","interpolate0","value0","attrConstantNS$1","getAttributeNS","attrFunction$1","value10","attrFunctionNS$1","attrTweenNS","attrTween","delayFunction","delayConstant","durationFunction","durationConstant","easeConstant","onFunction","on0","on1","sit","removeFunction","styleRemove$1","interpolate$$2","styleRemoveEnd","styleConstant$1","styleFunction$1","styleTween","textConstant$1","textFunction$1","_name","newId","linear$1","quadIn","quadOut","quadInOut","cubicIn","cubicOut","cubicInOut","sinIn","halfPi","sinOut","sinInOut","pi","expIn","expOut","expInOut","circleIn","circleOut","circleInOut","bounceIn","bounceOut","b1","b0","b3","b2","b4","b6","b5","b7","b8","b9","bounceInOut","inherit","timing","defaultTiming","nopropagation$1","defaultFilter","defaultExtent","ownerSVGElement","width","height","local$$1","__brush","empty","extent","brushSelection","dim","output","brushX","brush$1","X","brushY","Y","brush","overlay","initialize","cursors","handles","redraw","started","handleSize","emitter","Emitter","point1","mouse","shifting","lockX","lockY","point","moving","noevent$1","move","point0","MODE_SPACE","MODE_DRAG","signX","w0","e0","w1","e1","signY","N","n0","s0","n1","s1","MODE_HANDLE","MODE_CENTER","flipX","flipY","touches","touchending","keydowned","keyCode","keyupped","changedTouches","metaKey","signsX","signsY","shiftKey","beforestart","dragDisable","interrupt","selection1","selection0","input","interpolateValue","starting","BrushEvent","constant$4","compareValue","compare","Path","_x0","_y0","_x1","_y1","defaultSource","defaultTarget","defaultRadius","radius","defaultStartAngle","startAngle","defaultEndAngle","endAngle","Map","map$1","createObject","setObject","createMap","setMap","set$2","objectConverter","columns","customConverter","row","inferColumns","rows","columnSet","column","xm","ym","xp","yp","_root","leaf","x0","y0","x1","y1","_x","_y","addAll","xz","yz","cover","removeAll","defaultX","defaultY","quadtree","nodes","Quadtree","leaf_copy","vx","vy","find","nodeById","nodeId","x$1","y$1","FormatSpecifier","specifier","re","fill","align","sign","symbol","comma","precision","formatTypes","identity$3","defaultLocale","locale$1","formatLocale","formatPrefix","Adder","reset","adder","bv","av","acos","pi$3","asin","halfPi$2","haversin","sin$1","noop$1","streamGeometry","geometry","stream","streamGeometryType","streamLine","coordinates","closed","coordinate","lineStart","lineEnd","streamPolygon","polygonStart","polygonEnd","areaRingStart","areaStream","areaPointFirst","areaRingEnd","areaPoint","lambda00","phi00","lambda","phi","radians","lambda0","cosPhi0","cos$1","quarterPi","sinPhi0","dLambda","sdLambda","adLambda","cosPhi","sinPhi","u","areaRingSum","spherical","cartesian","cartesianDot","cartesianCross","cartesianAddInPlace","cartesianScale","vector","cartesianNormalizeInPlace","boundsPoint","ranges","lambda0$1","lambda1","phi0","phi1","linePoint","p0","normal","equatorial","inflection","phii","delta","lambda2","sign$$1","lambdai","degrees$1","antimeridian","angle","boundsLineStart","boundsStream","boundsLineEnd","boundsRingPoint","deltaSum","lambda00$1","phi00$1","boundsRingStart","boundsRingEnd","epsilon$2","rangeCompare","rangeContains","centroidPoint","centroidPointCartesian","W0","X0","Y0","Z0","centroidLineStart","centroidStream","centroidLinePointFirst","z0","centroidLinePoint","w","W1","X1","Y1","Z1","centroidLineEnd","centroidRingStart","centroidRingPointFirst","centroidRingEnd","centroidRingPoint","lambda00$2","phi00$2","cx","cy","cz","X2","Y2","Z2","rotationIdentity","tau$3","rotateRadians","deltaLambda","deltaPhi","deltaGamma","compose","rotationLambda","rotationPhiGamma","forwardRotationLambda","rotation","invert","cosDeltaPhi","sinDeltaPhi","cosDeltaGamma","sinDeltaGamma","circleStream","direction","cosRadius","sinRadius","step","circleRadius","Intersection","points","other","entry","link$1","array","clipExtent","visible","interpolate","a1","corner","comparePoint","compareIntersection","ca","activeStream","polygonInside","winding","polygon","a0","ring","bufferStream","clean","startInside","cleanInside","clipPolygon","clipStream","first","v_","x_","y_","x__","y__","v__","rejoin","clipMin","clipMax","clipLine","clipBuffer","lengthLineStart","lengthStream","lengthPointFirst","lengthLineEnd","lambda0$2","sinPhi0$1","cosPhi0$1","lengthPoint","cosDelta","sinDelta","lengthSum","graticuleX","sequence","graticuleY","graticule","lines","DX","DY","outline","reverse","extentMajor","extentMinor","stepMajor","stepMinor","graticule10","areaRingStart$1","areaStream$1","areaPointFirst$1","areaPoint$1","x00","x0$1","y00","y0$1","areaRingSum$1","areaRingEnd$1","boundsPoint$1","x0$2","y0$2","centroidPoint$1","X0$1","Y0$1","Z0$1","centroidLineStart$1","centroidStream$1","centroidPointFirstLine","centroidPointLine","x0$3","y0$3","X1$1","Y1$1","Z1$1","centroidLineEnd$1","centroidRingStart$1","centroidPointFirstRing","centroidRingEnd$1","centroidPointRing","x00$1","y00$1","X2$1","Y2$1","Z2$1","PathContext","lengthPointFirst$1","lengthStream$1","lengthPoint$1","x00$2","x0$4","y00$2","y0$4","lengthSum$1","PathString","_string","circle$1","validSegment","segment","clipAntimeridianLine","sign0","sign1","clipAntimeridianIntersect","cosPhi1","sinLambda0Lambda1","atan","clipAntimeridianInterpolate","transformer","TransformStream","fitExtent","projection","clip","geoStream","boundsStream$1","fitSize","size","resampleNone","project","resample$1","delta2","resampleLineTo","c0","c1","depth","d2","phi2","x2","y2","dx2","dy2","dz","cosMinDistance","resampleStream","maxDepth","ringStart","ringPoint","ringEnd","a00","b00","c00","projectionMutator","projectAt","projectRotate","projectTransform","recenter","cacheStream","theta","preclip","clipAntimeridian","postclip","identity$4","projectResample","resample","transformRadians","clipAngle","clipCircle","conicProjection","parallels","cylindricalEqualAreaRaw","forward","conicEqualAreaRaw","r0","sy0","r0y","multiplex","streams","sphere","azimuthalRaw","azimuthalInvert","sc","cc","mercatorRaw","tan","mercatorProjection","clipAuto","tany","conicConformalRaw","cy0","fy","equirectangularRaw","conicEquidistantRaw","gy","nx","gnomonicRaw","scaleTranslate","kx","ky","tx","ty","orthographicRaw","stereographicRaw","transverseMercatorRaw","defaultSeparation","meanX","meanXReduce","maxY","maxYReduce","leafLeft","leafRight","sum","leastCommonAncestor","aNodes","ancestors","bNodes","hierarchy","childs","Node","valued","defaultChildren","eachBefore","computeHeight","node_copy","copyData","Node$2","encloses","dr","encloseN","L","circle","l2","p1","l0","l1","head","enclose1","enclose2","enclose3","tail","r1","r2","x21","y21","r21","x3","y3","r3","a2","c2","a3","c3","d3","ab","A","place","ax","ay","da","db","dc","intersects","distance1","distance2","Node$1","previous","packEnclose","circles","sj","sk","aa","ba","oa","ox","oy","pack","enclose","optional","required","constantZero","defaultRadius$1","radiusLeaf","packChildren","padding","translateChild","defaultId","defaultParentId","parentId","defaultSeparation$1","nextLeft","nextRight","moveSubtree","wm","wp","change","executeShifts","nextAncestor","vim","TreeNode","treeRoot","squarifyRatio","ratio","nodeValue","sumValue","minValue","maxValue","newRatio","minRatio","alpha","beta","i0","i1","dice","treemapDice","treemapSlice","lexicographicOrder","computeUpperHullIndexes","indexes","cross","Queue","_size","_error","_tasks","_waiting","_active","_ended","_start","poke$1","start$1","abort","noabort","maybeNotify","concurrency","fixCallback","xhr","hasResponse","responseType","response","responseText","responseOf","request$$1","ordinal","unknown","implicit","slice$4","band","rescale","range$$1","paddingInner","paddingOuter","ordinalRange","rangeRound","pointish","point$1","deinterpolateLinear","constant$9","deinterpolateClamp","deinterpolate","reinterpolateClamp","bimap","d0","d1","polymap","bisectRight","clamp","continuous","piecewise","unit","map$3","number$1","interpolateRound","linearish","nice","linear$2","identity$6","reinterpolate$1","pow10","powp","base","logp","log10","log2","reflect","log$1","logs","pows","raise$1","exponent","pow$1","sqrt$1","quantile$$1","thresholds","threshold","invertExtent","quantiles","quantize$1","threshold$1","newInterval","floori","offseti","field","date","Date","setTime","t0$1","t1$1","weekday","setDate","getDate","getDay","setHours","getTimezoneOffset","durationMinute$1","durationWeek$1","utcWeekday","setUTCDate","getUTCDate","getUTCDay","setUTCHours","localDate","H","M","setFullYear","utcDate","UTC","setUTCFullYear","newYear","formatLocale$1","locale","newFormat","formats","pad","pads","newParse","newDate","parseSpecifier","day$$1","Z","parses","parsePeriod","periodRe","periodLookup","parseShortWeekday","shortWeekdayRe","shortWeekdayLookup","parseWeekday","weekdayRe","weekdayLookup","parseShortMonth","shortMonthRe","shortMonthLookup","parseMonth","monthRe","monthLookup","parseLocaleDateTime","locale_dateTime","parseLocaleDate","locale_date","parseLocaleTime","locale_time","formatShortWeekday","locale_shortWeekdays","formatWeekday","locale_weekdays","formatShortMonth","locale_shortMonths","getMonth","formatMonth","locale_months","formatPeriod","locale_periods","getHours","formatUTCShortWeekday","formatUTCWeekday","formatUTCShortMonth","getUTCMonth","formatUTCMonth","formatUTCPeriod","getUTCHours","dateTime","periods","days","shortDays","months","shortMonths","formatRe","formatLookup","formatDayOfMonth","formatHour24","I","formatHour12","formatDayOfYear","formatMilliseconds","formatMonthNumber","formatMinutes","formatSeconds","formatWeekNumberSunday","formatWeekdayNumber","formatWeekNumberMonday","formatYear","formatFullYear","formatZone","%","formatLiteralPercent","utcFormats","formatUTCDayOfMonth","formatUTCHour24","formatUTCHour12","formatUTCDayOfYear","formatUTCMilliseconds","formatUTCMonthNumber","formatUTCMinutes","formatUTCSeconds","formatUTCWeekNumberSunday","formatUTCWeekdayNumber","formatUTCWeekNumberMonday","formatUTCYear","formatUTCFullYear","formatUTCZone","parseDayOfMonth","parseHour24","parseDayOfYear","parseMilliseconds","parseMonthNumber","parseMinutes","parseSeconds","parseWeekNumberSunday","parseWeekdayNumber","parseWeekNumberMonday","parseYear","parseFullYear","parseZone","parseLiteralPercent","utcFormat","utcParse","requote","requoteRe","numberRe","percentRe","day","year","getMilliseconds","getMinutes","getSeconds","sunday","monday","getFullYear","utcDay","utcYear","getUTCMilliseconds","getUTCMinutes","getUTCSeconds","utcSunday","utcMonday","getUTCFullYear","defaultLocale$1","locale$2","timeFormat","timeParse","formatIsoNative","toISOString","parseIsoNative","date$1","number$2","calendar","year$$1","month$$1","week","hour$$1","minute$$1","second$$1","millisecond$$1","formatMillisecond","formatSecond","formatMinute","formatHour","formatDay","formatWeek","tickInterval","bisector","tickIntervals","durationYear","durationSecond","durationMinute","durationHour","durationDay","durationWeek","durationMonth","ramp","sequential","interpolator","arcInnerRadius","innerRadius","arcOuterRadius","outerRadius","arcStartAngle","arcEndAngle","arcPadAngle","padAngle","asin$1","halfPi$3","intersect","x10","y10","x32","y32","cornerTangents","rc","cw","x01","y01","lo","x11","y11","cx0","cx1","cy1","dx0","dy0","dx1","dy1","Linear","x$3","y$3","Radial","curve","_curve","curveRadial","radial","radialLine","point$2","bezierCurveTo","Basis","BasisClosed","BasisOpen","Bundle","_basis","_beta","point$3","_x2","_y2","Cardinal","tension","CardinalClosed","CardinalOpen","point$4","_l01_a","epsilon$3","_l01_2a","_l12_a","_l12_2a","_l23_a","_l23_2a","CatmullRom","_alpha","CatmullRomClosed","CatmullRomOpen","LinearClosed","sign$1","slope3","h0","h1","slope2","point$5","MonotoneX","MonotoneY","ReflectContext","monotoneX","monotoneY","Natural","controlPoints","Step","stepBefore","stepAfter","stackValue","sum$2","series","x$4","y$4","RedBlackTree","RedBlackNode","RedBlackRotateLeft","RedBlackRotateRight","RedBlackFirst","createEdge","edge","edges","setEdgeEnd","cells","halfedges","createBorderEdge","vertex","clipEdge","bx","by","connectEdge","fm","fb","lx","ly","rx","ry","fx","clipEdges","epsilon$4","createCell","site","cellHalfedgeAngle","cell","va","vb","cellHalfedgeStart","cellHalfedgeEnd","sortCellHalfedges","clipCells","iCell","iHalfedge","nHalfedges","startX","startY","endX","endY","nCells","v00","v01","v11","v10","Circle","arc","attachCircle","lArc","rArc","lSite","cSite","rSite","epsilon2$2","ha","hc","circlePool","before","firstCircle","detachCircle","Beach","createBeach","beach","beachPool","detachBeach","beaches","removeBeach","disappearing","iArc","nArcs","addBeach","dxl","dxr","directrix","leftBreakPoint","rightBreakPoint","newArc","hb","rfocx","rfocy","pby2","lfocx","lfocy","plby2","hl","aby2","triangleArea","lexicographic","Diagram","sites","ZoomEvent","Transform","transform$1","__zoom","identity$8","nopropagation$2","defaultFilter$2","defaultExtent$1","SVGElement","clientWidth","clientHeight","defaultTransform","hi","mid","ascendingBisect","bisectLeft","descending","variance","deviation","constant","sturges","LN2","histogram","tz","bin","bins","freedmanDiaconis","scott","mean","median","numbers","arrays","merged","pairs","permute","permutes","scan","xi","xj","shuffle","transpose","zip","T","namespaces","xlink","xml","xmlns","prefix","creator","matcher","selector","vendorMatches","webkitMatchesSelector","msMatchesSelector","mozMatchesSelector","oMatchesSelector","matcher$1","element$1","mouseenter","mouseleave","selection_on","current","createSVGPoint","clientX","clientY","matrixTransform","getScreenCTM","inverse","rect","clientLeft","clientTop","selection_select","subgroups","subnode","subgroup","selectorAll","querySelectorAll","selection_selectAll","selection_filter","sparse","selection_enter","constant$1","selection_data","enterGroup","updateGroup","exitGroup","_exit","selection_exit","selection_merge","groups0","groups1","m0","merges","group0","group1","selection_order","selection_sort","compareNode","sortgroups","sortgroup","selection_call","selection_nodes","selection_node","selection_size","selection_empty","selection_each","selection_attr","selection_style","selection_property","contains","selection_classed","selection_text","selection_html","selection_raise","selection_lower","selection_append","selection_insert","selection_remove","selection_datum","selection_dispatch","classed","touch","preventDefault","constant$2","drag","mousedowned","touchstarted","touchmoved","touchended","gesture","mousemoved","mouseupped","mousemoving","gestures","touches$$1","sublisteners","define","darker","brighter","reI","reN","reP","aliceblue","antiquewhite","aqua","aquamarine","azure","beige","bisque","black","blanchedalmond","blue","blueviolet","brown","burlywood","cadetblue","chartreuse","chocolate","coral","cornflowerblue","cornsilk","crimson","cyan","darkblue","darkcyan","darkgoldenrod","darkgray","darkgreen","darkgrey","darkkhaki","darkmagenta","darkolivegreen","darkorange","darkorchid","darkred","darksalmon","darkseagreen","darkslateblue","darkslategray","darkslategrey","darkturquoise","darkviolet","deeppink","deepskyblue","dimgray","dimgrey","dodgerblue","firebrick","floralwhite","forestgreen","fuchsia","gainsboro","ghostwhite","gold","goldenrod","gray","green","greenyellow","grey","honeydew","hotpink","indianred","indigo","ivory","khaki","lavender","lavenderblush","lawngreen","lemonchiffon","lightblue","lightcoral","lightcyan","lightgoldenrodyellow","lightgray","lightgreen","lightgrey","lightpink","lightsalmon","lightseagreen","lightskyblue","lightslategray","lightslategrey","lightsteelblue","lightyellow","lime","limegreen","linen","magenta","maroon","mediumaquamarine","mediumblue","mediumorchid","mediumpurple","mediumseagreen","mediumslateblue","mediumspringgreen","mediumturquoise","mediumvioletred","midnightblue","mintcream","mistyrose","moccasin","navajowhite","navy","oldlace","olive","olivedrab","orange","orangered","orchid","palegoldenrod","palegreen","paleturquoise","palevioletred","papayawhip","peachpuff","peru","pink","plum","powderblue","purple","rebeccapurple","red","rosybrown","royalblue","saddlebrown","salmon","sandybrown","seagreen","seashell","sienna","silver","skyblue","slateblue","slategray","slategrey","snow","springgreen","steelblue","teal","thistle","tomato","turquoise","violet","wheat","white","whitesmoke","yellow","yellowgreen","displayable","PI","Kn","basis$1","basisClosed","interpolateRgb","rgbGamma","rgb$$1","rgbBasis","rgbBasisClosed","array$1","nb","na","reA","reB","interpolateString","am","bm","bs","bi","degrees","interpolateTransformCss","interpolateTransformSvg","rho","SQRT2","rho2","rho4","epsilon2","interpolateZoom","ux0","uy0","ux1","uy1","coshr0","hsl$2","hslLong","hcl$2","hclLong","cubehelix$2","cubehelixLong","quantize","samples","performance","interval$1","total","emptyOn","emptyTween","selection_interrupt","transition_tween","transition_attr","transition_attrTween","transition_delay","transition_duration","transition_ease","transition_filter","transition_merge","transition_on","transition_remove","transition_select","select$$1","transition_selectAll","Selection$1","transition_selection","transition_style","transition_styleTween","transition_text","transition_transition","id0","id1","selection_prototype","polyIn","custom","polyOut","polyInOut","overshoot","backIn","backOut","backInOut","tau","amplitude","period","elasticIn","elasticOut","elasticInOut","selection_transition","root$1","xy","XY","nw","ne","se","sw","pi$1","halfPi$1","tau$1","max$1","chord","groupSums","groupIndex","subgroupIndex","chords","sortGroups","sortSubgroups","di","dj","subindex","sortChords","slice$2","constant$5","pi$2","tau$2","epsilon$1","tauEpsilon","moveTo","closePath","lineTo","quadraticCurveTo","arcTo","l01_2","x20","y20","l21_2","l20_2","l21","l01","t01","t21","ccw","ribbon","buffer","argv","sr","sa0","sa1","sx0","tr","ta0","ta1","entries","nest","createResult","setResult","rollup","sortValues","valuesByKey","sortKey","sortKeys","proto","dsv","delimiter","convert","parseRows","token","EOF","eol","EOL","delimiterCode","formatValue","formatRows","formatRow","reFormat","csv","csvParse","csvParseRows","csvFormat","csvFormatRows","tsv","tsvParse","tsvParseRows","tsvFormat","tsvFormatRows","center$1","force","sx","sy","constant$6","jiggle","tree_add","tree_cover","tree_data","visit","tree_extent","Quad","tree_find","quads","tree_remove","retainer","tree_root","tree_size","tree_visit","tree_visitAfter","tree_x","tree_y","treeProto","visitAfter","prefixExponent","collide","quad","rj","ri","yi","strength","ri2","iterations","prepare","radii","link","links","defaultStrength","distances","strengths","bias","initializeStrength","initializeDistance","distance","initialRadius","initialAngle","simulation","alphaMin","stepper","alphaTarget","alphaDecay","forces","velocityDecay","initializeNodes","initializeForce","closest","manyBody","accumulate","x$$1","y$$1","theta2","distanceMax2","distanceMin2","distanceMin","distanceMax","x$2","y$2","formatDecimal","toExponential","coefficient","exponent$1","formatGroup","grouping","thousands","formatDefault","toPrecision","formatPrefixAuto","formatRounded","","toFixed","formatSpecifier","valuePrefix","valueSuffix","suffix","formatType","valueNegative","maybeSuffix","decimal","currency","precisionFixed","precisionPrefix","precisionRound","temp","valueOf","epsilon2$1","streamObjectType","Feature","feature","FeatureCollection","features","Sphere","Point","MultiPoint","LineString","MultiLineString","Polygon","MultiPolygon","GeometryCollection","geometries","areaSum","areaRing","area","bounds","deltaMax","centroid","constant$7","pointEqual","isSubject","extent$1","length$1","object$1","interpolate$1","sy1","kx0","ky0","kx1","ky1","areaSum$1","_radius","pointRadius","_line","_point","lengthRing","_circle","contextStream","projectionStream","measure","sum$1","polygonContains","sinPhi1","absDelta","intersection","phiArc","pointVisible","sink","pointLine","pointRing","ringSink","ringSegments","ringBuffer","polygonStarted","rotatedStart","cr","point2","smallRadius","notHemisphere","pa","pb","n2","n2n2","n1n2","determinant","n1xn2","uu","polar","meridian","q1","conicEqualArea","albers","albersUsa","lower48Point","alaskaPoint","hawaiiPoint","lower48","alaska","hawaii","pointStream","azimuthalEqualAreaRaw","cxcy","azimuthalEqualArea","azimuthalEquidistantRaw","azimuthalEquidistant","mercator","conicConformal","equirectangular","conicEquidistant","gnomonic","identity$5","reflectX","reflectY","orthographic","stereographic","transverseMercator","cluster","previousNode","eachAfter","separation","nodeSize","node_count","node_each","node_eachBefore","node_eachAfter","node_sum","node_sort","node_path","node_ancestors","node_descendants","node_leaves","leaves","node_links","descendants","shuffle$1","siblings","constant$8","index$2","roundNode","partition","positionNode","keyPrefix$1","preroot","ambiguous","stratify","nodeKey","nodeByKey","firstWalk","secondWalk","sizeNode","midpoint","apportion","vip","vop","vom","sip","sop","sim","som","squarify","index$3","treemap","paddingStack","paddingLeft","paddingTop","paddingRight","paddingBottom","tile","binary","valueOffset","sums","valueTarget","valueLeft","valueRight","yk","xk","sliceDice","resquarify","_squarify","area$1","centroid$1","hull","sortedPoints","flippedPoints","upperIndexes","lowerIndexes","skipLeft","skipRight","inside","length$2","perimeter","slice$3","defer","await","results","awaitAll","uniform","mu","sigma","logNormal","randomNormal","irwinHall","bates","randomIrwinHall","exponential$1","request","url","respond","status","mimeType","headers","XMLHttpRequest","password","XDomainRequest","onload","onerror","ontimeout","onreadystatechange","readyState","onprogress","header","send","post","setRequestHeader","overrideMimeType","type$1","defaultMimeType","createRange","createContextualFragment","json","responseXML","dsv$1","csv$1","tsv$1","array$2","millisecond","milliseconds","durationSecond$1","durationHour$1","durationDay$1","second","seconds","minute","minutes","hour","hours","tuesday","wednesday","thursday","friday","saturday","sundays","mondays","tuesdays","wednesdays","thursdays","fridays","saturdays","month","setMonth","years","utcMinute","setUTCSeconds","utcMinutes","utcHour","setUTCMinutes","utcHours","utcDays","utcTuesday","utcWednesday","utcThursday","utcFriday","utcSaturday","utcSundays","utcMondays","utcTuesdays","utcWednesdays","utcThursdays","utcFridays","utcSaturdays","utcMonth","setUTCMonth","utcMonths","utcYears","-","0","isoSpecifier","formatIso","parseIso","utcTime","category10","category20b","category20c","category20","cubehelix$3","warm","cool","rainbow","rainbow$1","ts","viridis","magma","inferno","plasma","constant$10","pi$4","tau$4","a01","a11","a10","da0","da1","ap","rp","padRadius","cornerRadius","rc0","rc1","oc","kc","lc","areaStart","areaEnd","curveLinear","defined0","area$2","x0z","y0z","arealine","lineX0","lineY0","lineY1","lineX1","descending$1","identity$7","pie","arcs","curveRadialLinear","radialLine$1","radialArea","lineStartAngle","lineEndAngle","lineInnerRadius","lineOuterRadius","circle$2","draw","cross$1","tan30","tan30_2","diamond","ka","kr","star","sqrt3","triangle","wye","symbols","noop$2","basis$2","_x3","_x4","_y3","_y4","basisClosed$1","basisOpen","bundle","cardinal","_x5","_y5","cardinalClosed","cardinalOpen","x23","y23","catmullRom","catmullRomClosed","catmullRomOpen","linearClosed","_t0","py","natural","slice$5","none$1","none$2","oz","kz","sz","sij","ki","si","expand","silhouette","wiggle","s2","sij0","sij1","s3","skj0","skj1","ascending$2","descending$2","insideOut","tops","bottoms","constant$11","after","grandpa","uncle","sibling","polygons","triangles","_found","voronoi","constant$12","applyX","applyY","location","invertX","invertY","rescaleX","rescaleY","noevent$2","zoom","wheeled","dblclicked","k0","k1","constrain","transition$$1","Gesture","wheelidled","wheel","deltaY","deltaMode","wheelDelay","touch0","touch1","touchstarting","touchDelay","dp","dl","collection","scaleBy","scaleTo","translateBy","scaleExtent","translateExtent","bisect","thresholdFreedmanDiaconis","thresholdScott","thresholdSturges","quantile","dragEnable","dsvFormat","easeLinear","easeQuad","easeQuadIn","easeQuadOut","easeQuadInOut","easeCubic","easeCubicIn","easeCubicOut","easeCubicInOut","easePoly","easePolyIn","easePolyOut","easePolyInOut","easeSin","easeSinIn","easeSinOut","easeSinInOut","easeExp","easeExpIn","easeExpOut","easeExpInOut","easeCircle","easeCircleIn","easeCircleOut","easeCircleInOut","easeBounce","easeBounceIn","easeBounceOut","easeBounceInOut","easeBack","easeBackIn","easeBackOut","easeBackInOut","easeElastic","easeElasticIn","easeElasticOut","easeElasticInOut","forceCenter","forceCollide","forceLink","forceManyBody","forceSimulation","forceX","forceY","formatDefaultLocale","geoArea","geoBounds","geoCentroid","geoCircle","geoClipExtent","geoDistance","geoGraticule","geoGraticule10","geoInterpolate","geoLength","geoPath","geoAlbers","geoAlbersUsa","geoAzimuthalEqualArea","geoAzimuthalEqualAreaRaw","geoAzimuthalEquidistant","geoAzimuthalEquidistantRaw","geoConicConformal","geoConicConformalRaw","geoConicEqualArea","geoConicEqualAreaRaw","geoConicEquidistant","geoConicEquidistantRaw","geoEquirectangular","geoEquirectangularRaw","geoGnomonic","geoGnomonicRaw","geoIdentity","geoProjection","geoProjectionMutator","geoMercator","geoMercatorRaw","geoOrthographic","geoOrthographicRaw","geoStereographic","geoStereographicRaw","geoTransverseMercator","geoTransverseMercatorRaw","geoRotation","geoTransform","packSiblings","treemapBinary","treemapSliceDice","treemapSquarify","treemapResquarify","interpolateArray","interpolateBasis","interpolateBasisClosed","interpolateDate","interpolateNumber","interpolateObject","interpolateRgbBasis","interpolateRgbBasisClosed","interpolateHsl","interpolateHslLong","interpolateLab","interpolateHcl","interpolateHclLong","interpolateCubehelix","interpolateCubehelixLong","polygonArea","polygonCentroid","polygonHull","polygonLength","randomUniform","randomLogNormal","randomBates","randomExponential","scaleBand","scalePoint","scaleIdentity","scaleLinear","scaleLog","scaleOrdinal","scaleImplicit","scalePow","scaleSqrt","scaleQuantile","scaleQuantize","scaleThreshold","scaleTime","scaleUtc","schemeCategory10","schemeCategory20b","schemeCategory20c","schemeCategory20","interpolateCubehelixDefault","interpolateRainbow","interpolateWarm","interpolateCool","interpolateViridis","interpolateMagma","interpolateInferno","interpolatePlasma","scaleSequential","symbolCircle","symbolCross","symbolDiamond","symbolSquare","symbolStar","symbolTriangle","symbolWye","curveBasisClosed","curveBasisOpen","curveBasis","curveBundle","curveCardinalClosed","curveCardinalOpen","curveCardinal","curveCatmullRomClosed","curveCatmullRomOpen","curveCatmullRom","curveLinearClosed","curveMonotoneX","curveMonotoneY","curveNatural","curveStep","curveStepAfter","curveStepBefore","stackOffsetExpand","stackOffsetNone","stackOffsetSilhouette","stackOffsetWiggle","stackOrderAscending","stackOrderDescending","stackOrderInsideOut","stackOrderNone","stackOrderReverse","timeInterval","timeMillisecond","timeMilliseconds","utcMillisecond","utcMilliseconds","timeSecond","timeSeconds","utcSecond","utcSeconds","timeMinute","timeMinutes","timeHour","timeHours","timeDay","timeDays","timeWeek","timeWeeks","timeSunday","timeSundays","timeMonday","timeMondays","timeTuesday","timeTuesdays","timeWednesday","timeWednesdays","timeThursday","timeThursdays","timeFriday","timeFridays","timeSaturday","timeSaturdays","timeMonth","timeMonths","timeYear","timeYears","utcWeek","utcWeeks","timeFormatDefaultLocale","timeFormatLocale","isoFormat","isoParse","zoomTransform","zoomIdentity","__esModule","_interopRequireDefault","_from2","arr2","toIObject","toLength","toIndex","IS_INCLUDES","$this","fromIndex","cof","ARG","tryGet","callee","$defineProperty","propertyIsEnumerable","Iterators","ITERATOR","ArrayProto","iterator","descriptor","setToStringTag","IteratorPrototype","Constructor","NAME","LIBRARY","redefine","$iterCreate","getPrototypeOf","BUGGY","FF_ITERATOR","KEYS","VALUES","returnThis","Base","DEFAULT","IS_SET","FORCED","getMethod","kind","DEF_VALUES","VALUES_BUG","$native","$default","$entries","$anyNative","SAFE_CLOSING","riter","skipClosing","safe","iter","done","dPs","enumBugKeys","IE_PROTO","Empty","createDict","iframeDocument","iframe","lt","gt","contentWindow","write","Properties","getKeys","ObjectProto","arrayIndexOf","$keys","TO_STRING","classof","getIteratorMethod","isArrayIter","createProperty","getIterFn","arrayLike","aLen","mapfn","mapping","iterFn","$at","iterated","message","resolveProps","route","resolveQuery","extraQuery","parsedQuery","parseQuery","param","parts","stringifyQuery","encode","val2","createRoute","record","redirectedFrom","fullPath","getFullPath","matched","formatMatch","isSameRoute","START","trailingSlashRE","isObjectEqual","aKeys","bKeys","isIncludedRoute","queryIncludes","guardEvent","ctrlKey","defaultPrevented","findAnchor","_Vue","_router","_route","beforeCreate","router","history","View","Link","beforeRouteEnter","beforeRouteLeave","resolvePath","relative","hashIndex","queryIndex","cleanPath","createRouteMap","routes","oldPathMap","oldNameMap","pathMap","nameMap","addRouteRecord","matchAs","normalizePath","instances","redirect","childMatchAs","aliasRoute","defaultDelimiter","PATH_REGEXP","escaped","modifier","asterisk","partial","repeat","escapeGroup","escapeString","substr","tokensToFunction","encodeURIComponentPretty","encodeURI","encodeAsterisk","pretty","encodeURIComponent","isarray","attachKeys","flags","sensitive","regexpToRegexp","arrayToRegexp","pathToRegexp","regexp","stringToRegexp","tokensToRegExp","strict","endsWithDelimiter","getRouteRegex","regexpCache","fillParams","routeMsg","filler","regexpCompileCache","normalizeLocation","_normalized","assign","rawPath","parsedPath","basePath","createMatcher","addRoutes","currentRoute","paramNames","_createRoute","matchRoute","originalRedirect","resolveRecordPath","resolvedPath","aliasedPath","aliasedMatch","aliasedRecord","pathname","decodeURIComponent","setupScroll","saveScrollPosition","setStateKey","handleScroll","isPop","app","behavior","scrollBehavior","getScrollPosition","shouldScroll","getElementPosition","isValidPosition","normalizePosition","scrollTo","getStateKey","positionStore","pageXOffset","pageYOffset","docRect","elRect","isNumber","genKey","Time","_key","pushState","replaceState","runQueue","normalizeBase","baseEl","resolveQueue","activated","deactivated","extractGuards","records","guards","flatMapComponents","instance","guard","extractGuard","flatten","extractLeaveGuards","bindGuard","extractUpdateHooks","extractEnterGuards","isValid","bindEnterGuard","poll","resolveAsyncComponents","resolvedDef","getLocation","search","checkFallback","ensureSlash","getHash","replaceHash","href","pushHash","createHref","routerView","$route","_routerViewCache","inactive","routerViewDepth","encodeReserveRE","encodeReserveReplacer","commaRE","toTypes","eventTypes","exact","$router","classes","linkActiveClass","compareTarget","click","aData","aAttrs","parse_1","compile_1","tokensToFunction_1","tokensToRegExp_1","supportsPushState","ua","History","ready","readyCbs","listen","onReady","transitionTo","onComplete","onAbort","confirmTransition","updateRoute","ensureURL","beforeHooks","postEnterCbs","enterGuards","afterHooks","HTML5History","History$$1","expectScroll","go","getCurrentLocation","HashHistory","setupListeners","AbstractHistory","targetIndex","VueRouter","apps","setupHashListener","beforeEach","afterEach","back","getMatchedComponents","normalizedTo","newStyles","media","sourceMap","part","eval","mediaQuery","alreadyImportedModules","addStylesToDom","domStyle","stylesInDom","addStyle","listToStyles","createStyleElement","styleElement","hasSSR","isProduction","isOldIE","styleIndex","singletonCounter","singletonElement","applyToSingletonTag","applyToTag","newObj","styleSheet","replaceText","childNodes","sources","btoa","unescape","hasDocument","DEBUG","getElementsByTagName","_isProduction","newList","mayRemove","textStore","replacement"],"mappings":"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","file":"static/js/vendor.969602d126b5ff83a532.js","sourcesContent":["webpackJsonp([0,2],[\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar store = __webpack_require__(24)('wks')\n , uid = __webpack_require__(28)\n , Symbol = __webpack_require__(1).Symbol\n , USE_SYMBOL = typeof Symbol == 'function';\n\nvar $exports = module.exports = function(name){\n return store[name] || (store[name] =\n USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));\n};\n\n$exports.store = store;\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports) {\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nvar global = module.exports = typeof window != 'undefined' && window.Math == Math\n ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();\nif(typeof __g == 'number')__g = global; // eslint-disable-line no-undef\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports) {\n\nmodule.exports = function normalizeComponent (\n rawScriptExports,\n compiledTemplate,\n scopeId,\n cssModules\n) {\n var esModule\n var scriptExports = rawScriptExports = rawScriptExports || {}\n\n // ES6 modules interop\n var type = typeof rawScriptExports.default\n if (type === 'object' || type === 'function') {\n esModule = rawScriptExports\n scriptExports = rawScriptExports.default\n }\n\n // Vue.extend constructor export interop\n var options = typeof scriptExports === 'function'\n ? scriptExports.options\n : scriptExports\n\n // render functions\n if (compiledTemplate) {\n options.render = compiledTemplate.render\n options.staticRenderFns = compiledTemplate.staticRenderFns\n }\n\n // scopedId\n if (scopeId) {\n options._scopeId = scopeId\n }\n\n // inject cssModules\n if (cssModules) {\n var computed = options.computed || (options.computed = {})\n Object.keys(cssModules).forEach(function (key) {\n var module = cssModules[key]\n computed[key] = function () { return module }\n })\n }\n\n return {\n esModule: esModule,\n exports: scriptExports,\n options: options\n }\n}\n\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar isObject = __webpack_require__(11);\nmodule.exports = function(it){\n if(!isObject(it))throw TypeError(it + ' is not an object!');\n return it;\n};\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// Thank's IE8 for his funny defineProperty\nmodule.exports = !__webpack_require__(22)(function(){\n return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;\n});\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports) {\n\nvar hasOwnProperty = {}.hasOwnProperty;\nmodule.exports = function(it, key){\n return hasOwnProperty.call(it, key);\n};\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar dP = __webpack_require__(7)\n , createDesc = __webpack_require__(13);\nmodule.exports = __webpack_require__(4) ? function(object, key, value){\n return dP.f(object, key, createDesc(1, value));\n} : function(object, key, value){\n object[key] = value;\n return object;\n};\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar anObject = __webpack_require__(3)\n , IE8_DOM_DEFINE = __webpack_require__(46)\n , toPrimitive = __webpack_require__(62)\n , dP = Object.defineProperty;\n\nexports.f = __webpack_require__(4) ? Object.defineProperty : function defineProperty(O, P, Attributes){\n anObject(O);\n P = toPrimitive(P, true);\n anObject(Attributes);\n if(IE8_DOM_DEFINE)try {\n return dP(O, P, Attributes);\n } catch(e){ /* empty */ }\n if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');\n if('value' in Attributes)O[P] = Attributes.value;\n return O;\n};\n\n/***/ }),\n/* 8 */,\n/* 9 */\n/***/ (function(module, exports) {\n\nvar core = module.exports = {version: '2.4.0'};\nif(typeof __e == 'number')__e = core; // eslint-disable-line no-undef\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports) {\n\n// 7.2.1 RequireObjectCoercible(argument)\nmodule.exports = function(it){\n if(it == undefined)throw TypeError(\"Can't call method on \" + it);\n return it;\n};\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports) {\n\nmodule.exports = function(it){\n return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports) {\n\nmodule.exports = {};\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports) {\n\nmodule.exports = function(bitmap, value){\n return {\n enumerable : !(bitmap & 1),\n configurable: !(bitmap & 2),\n writable : !(bitmap & 4),\n value : value\n };\n};\n\n/***/ }),\n/* 14 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar shared = __webpack_require__(24)('keys')\n , uid = __webpack_require__(28);\nmodule.exports = function(key){\n return shared[key] || (shared[key] = uid(key));\n};\n\n/***/ }),\n/* 15 */\n/***/ (function(module, exports) {\n\n// 7.1.4 ToInteger\nvar ceil = Math.ceil\n , floor = Math.floor;\nmodule.exports = function(it){\n return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);\n};\n\n/***/ }),\n/* 16 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/*!\n * Vue.js v2.1.10\n * (c) 2014-2017 Evan You\n * Released under the MIT License.\n */\n\n\n/* */\n\n/**\n * Convert a value to a string that is actually rendered.\n */\nfunction _toString (val) {\n return val == null\n ? ''\n : typeof val === 'object'\n ? JSON.stringify(val, null, 2)\n : String(val)\n}\n\n/**\n * Convert a input value to a number for persistence.\n * If the conversion fails, return original string.\n */\nfunction toNumber (val) {\n var n = parseFloat(val);\n return isNaN(n) ? val : n\n}\n\n/**\n * Make a map and return a function for checking if a key\n * is in that map.\n */\nfunction makeMap (\n str,\n expectsLowerCase\n) {\n var map = Object.create(null);\n var list = str.split(',');\n for (var i = 0; i < list.length; i++) {\n map[list[i]] = true;\n }\n return expectsLowerCase\n ? function (val) { return map[val.toLowerCase()]; }\n : function (val) { return map[val]; }\n}\n\n/**\n * Check if a tag is a built-in tag.\n */\nvar isBuiltInTag = makeMap('slot,component', true);\n\n/**\n * Remove an item from an array\n */\nfunction remove$1 (arr, item) {\n if (arr.length) {\n var index = arr.indexOf(item);\n if (index > -1) {\n return arr.splice(index, 1)\n }\n }\n}\n\n/**\n * Check whether the object has the property.\n */\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction hasOwn (obj, key) {\n return hasOwnProperty.call(obj, key)\n}\n\n/**\n * Check if value is primitive\n */\nfunction isPrimitive (value) {\n return typeof value === 'string' || typeof value === 'number'\n}\n\n/**\n * Create a cached version of a pure function.\n */\nfunction cached (fn) {\n var cache = Object.create(null);\n return (function cachedFn (str) {\n var hit = cache[str];\n return hit || (cache[str] = fn(str))\n })\n}\n\n/**\n * Camelize a hyphen-delimited string.\n */\nvar camelizeRE = /-(\\w)/g;\nvar camelize = cached(function (str) {\n return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })\n});\n\n/**\n * Capitalize a string.\n */\nvar capitalize = cached(function (str) {\n return str.charAt(0).toUpperCase() + str.slice(1)\n});\n\n/**\n * Hyphenate a camelCase string.\n */\nvar hyphenateRE = /([^-])([A-Z])/g;\nvar hyphenate = cached(function (str) {\n return str\n .replace(hyphenateRE, '$1-$2')\n .replace(hyphenateRE, '$1-$2')\n .toLowerCase()\n});\n\n/**\n * Simple bind, faster than native\n */\nfunction bind$1 (fn, ctx) {\n function boundFn (a) {\n var l = arguments.length;\n return l\n ? l > 1\n ? fn.apply(ctx, arguments)\n : fn.call(ctx, a)\n : fn.call(ctx)\n }\n // record original fn length\n boundFn._length = fn.length;\n return boundFn\n}\n\n/**\n * Convert an Array-like object to a real Array.\n */\nfunction toArray (list, start) {\n start = start || 0;\n var i = list.length - start;\n var ret = new Array(i);\n while (i--) {\n ret[i] = list[i + start];\n }\n return ret\n}\n\n/**\n * Mix properties into target object.\n */\nfunction extend (to, _from) {\n for (var key in _from) {\n to[key] = _from[key];\n }\n return to\n}\n\n/**\n * Quick object check - this is primarily used to tell\n * Objects from primitive values when we know the value\n * is a JSON-compliant type.\n */\nfunction isObject (obj) {\n return obj !== null && typeof obj === 'object'\n}\n\n/**\n * Strict object type check. Only returns true\n * for plain JavaScript objects.\n */\nvar toString = Object.prototype.toString;\nvar OBJECT_STRING = '[object Object]';\nfunction isPlainObject (obj) {\n return toString.call(obj) === OBJECT_STRING\n}\n\n/**\n * Merge an Array of Objects into a single Object.\n */\nfunction toObject (arr) {\n var res = {};\n for (var i = 0; i < arr.length; i++) {\n if (arr[i]) {\n extend(res, arr[i]);\n }\n }\n return res\n}\n\n/**\n * Perform no operation.\n */\nfunction noop () {}\n\n/**\n * Always return false.\n */\nvar no = function () { return false; };\n\n/**\n * Return same value\n */\nvar identity = function (_) { return _; };\n\n/**\n * Generate a static keys string from compiler modules.\n */\nfunction genStaticKeys (modules) {\n return modules.reduce(function (keys, m) {\n return keys.concat(m.staticKeys || [])\n }, []).join(',')\n}\n\n/**\n * Check if two values are loosely equal - that is,\n * if they are plain objects, do they have the same shape?\n */\nfunction looseEqual (a, b) {\n var isObjectA = isObject(a);\n var isObjectB = isObject(b);\n if (isObjectA && isObjectB) {\n return JSON.stringify(a) === JSON.stringify(b)\n } else if (!isObjectA && !isObjectB) {\n return String(a) === String(b)\n } else {\n return false\n }\n}\n\nfunction looseIndexOf (arr, val) {\n for (var i = 0; i < arr.length; i++) {\n if (looseEqual(arr[i], val)) { return i }\n }\n return -1\n}\n\n/* */\n\nvar config = {\n /**\n * Option merge strategies (used in core/util/options)\n */\n optionMergeStrategies: Object.create(null),\n\n /**\n * Whether to suppress warnings.\n */\n silent: false,\n\n /**\n * Whether to enable devtools\n */\n devtools: \"production\" !== 'production',\n\n /**\n * Error handler for watcher errors\n */\n errorHandler: null,\n\n /**\n * Ignore certain custom elements\n */\n ignoredElements: [],\n\n /**\n * Custom user key aliases for v-on\n */\n keyCodes: Object.create(null),\n\n /**\n * Check if a tag is reserved so that it cannot be registered as a\n * component. This is platform-dependent and may be overwritten.\n */\n isReservedTag: no,\n\n /**\n * Check if a tag is an unknown element.\n * Platform-dependent.\n */\n isUnknownElement: no,\n\n /**\n * Get the namespace of an element\n */\n getTagNamespace: noop,\n\n /**\n * Parse the real tag name for the specific platform.\n */\n parsePlatformTagName: identity,\n\n /**\n * Check if an attribute must be bound using property, e.g. value\n * Platform-dependent.\n */\n mustUseProp: no,\n\n /**\n * List of asset types that a component can own.\n */\n _assetTypes: [\n 'component',\n 'directive',\n 'filter'\n ],\n\n /**\n * List of lifecycle hooks.\n */\n _lifecycleHooks: [\n 'beforeCreate',\n 'created',\n 'beforeMount',\n 'mounted',\n 'beforeUpdate',\n 'updated',\n 'beforeDestroy',\n 'destroyed',\n 'activated',\n 'deactivated'\n ],\n\n /**\n * Max circular updates allowed in a scheduler flush cycle.\n */\n _maxUpdateCount: 100\n};\n\n/* */\n\n/**\n * Check if a string starts with $ or _\n */\nfunction isReserved (str) {\n var c = (str + '').charCodeAt(0);\n return c === 0x24 || c === 0x5F\n}\n\n/**\n * Define a property.\n */\nfunction def (obj, key, val, enumerable) {\n Object.defineProperty(obj, key, {\n value: val,\n enumerable: !!enumerable,\n writable: true,\n configurable: true\n });\n}\n\n/**\n * Parse simple path.\n */\nvar bailRE = /[^\\w.$]/;\nfunction parsePath (path) {\n if (bailRE.test(path)) {\n return\n } else {\n var segments = path.split('.');\n return function (obj) {\n for (var i = 0; i < segments.length; i++) {\n if (!obj) { return }\n obj = obj[segments[i]];\n }\n return obj\n }\n }\n}\n\n/* */\n/* globals MutationObserver */\n\n// can we use __proto__?\nvar hasProto = '__proto__' in {};\n\n// Browser environment sniffing\nvar inBrowser = typeof window !== 'undefined';\nvar UA = inBrowser && window.navigator.userAgent.toLowerCase();\nvar isIE = UA && /msie|trident/.test(UA);\nvar isIE9 = UA && UA.indexOf('msie 9.0') > 0;\nvar isEdge = UA && UA.indexOf('edge/') > 0;\nvar isAndroid = UA && UA.indexOf('android') > 0;\nvar isIOS = UA && /iphone|ipad|ipod|ios/.test(UA);\n\n// this needs to be lazy-evaled because vue may be required before\n// vue-server-renderer can set VUE_ENV\nvar _isServer;\nvar isServerRendering = function () {\n if (_isServer === undefined) {\n /* istanbul ignore if */\n if (!inBrowser && typeof global !== 'undefined') {\n // detect presence of vue-server-renderer and avoid\n // Webpack shimming the process\n _isServer = global['process'].env.VUE_ENV === 'server';\n } else {\n _isServer = false;\n }\n }\n return _isServer\n};\n\n// detect devtools\nvar devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;\n\n/* istanbul ignore next */\nfunction isNative (Ctor) {\n return /native code/.test(Ctor.toString())\n}\n\n/**\n * Defer a task to execute it asynchronously.\n */\nvar nextTick = (function () {\n var callbacks = [];\n var pending = false;\n var timerFunc;\n\n function nextTickHandler () {\n pending = false;\n var copies = callbacks.slice(0);\n callbacks.length = 0;\n for (var i = 0; i < copies.length; i++) {\n copies[i]();\n }\n }\n\n // the nextTick behavior leverages the microtask queue, which can be accessed\n // via either native Promise.then or MutationObserver.\n // MutationObserver has wider support, however it is seriously bugged in\n // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It\n // completely stops working after triggering a few times... so, if native\n // Promise is available, we will use it:\n /* istanbul ignore if */\n if (typeof Promise !== 'undefined' && isNative(Promise)) {\n var p = Promise.resolve();\n var logError = function (err) { console.error(err); };\n timerFunc = function () {\n p.then(nextTickHandler).catch(logError);\n // in problematic UIWebViews, Promise.then doesn't completely break, but\n // it can get stuck in a weird state where callbacks are pushed into the\n // microtask queue but the queue isn't being flushed, until the browser\n // needs to do some other work, e.g. handle a timer. Therefore we can\n // \"force\" the microtask queue to be flushed by adding an empty timer.\n if (isIOS) { setTimeout(noop); }\n };\n } else if (typeof MutationObserver !== 'undefined' && (\n isNative(MutationObserver) ||\n // PhantomJS and iOS 7.x\n MutationObserver.toString() === '[object MutationObserverConstructor]'\n )) {\n // use MutationObserver where native Promise is not available,\n // e.g. PhantomJS IE11, iOS7, Android 4.4\n var counter = 1;\n var observer = new MutationObserver(nextTickHandler);\n var textNode = document.createTextNode(String(counter));\n observer.observe(textNode, {\n characterData: true\n });\n timerFunc = function () {\n counter = (counter + 1) % 2;\n textNode.data = String(counter);\n };\n } else {\n // fallback to setTimeout\n /* istanbul ignore next */\n timerFunc = function () {\n setTimeout(nextTickHandler, 0);\n };\n }\n\n return function queueNextTick (cb, ctx) {\n var _resolve;\n callbacks.push(function () {\n if (cb) { cb.call(ctx); }\n if (_resolve) { _resolve(ctx); }\n });\n if (!pending) {\n pending = true;\n timerFunc();\n }\n if (!cb && typeof Promise !== 'undefined') {\n return new Promise(function (resolve) {\n _resolve = resolve;\n })\n }\n }\n})();\n\nvar _Set;\n/* istanbul ignore if */\nif (typeof Set !== 'undefined' && isNative(Set)) {\n // use native Set when available.\n _Set = Set;\n} else {\n // a non-standard Set polyfill that only works with primitive keys.\n _Set = (function () {\n function Set () {\n this.set = Object.create(null);\n }\n Set.prototype.has = function has (key) {\n return this.set[key] === true\n };\n Set.prototype.add = function add (key) {\n this.set[key] = true;\n };\n Set.prototype.clear = function clear () {\n this.set = Object.create(null);\n };\n\n return Set;\n }());\n}\n\nvar warn = noop;\nvar formatComponentName;\n\nif (false) {\n var hasConsole = typeof console !== 'undefined';\n\n warn = function (msg, vm) {\n if (hasConsole && (!config.silent)) {\n console.error(\"[Vue warn]: \" + msg + \" \" + (\n vm ? formatLocation(formatComponentName(vm)) : ''\n ));\n }\n };\n\n formatComponentName = function (vm) {\n if (vm.$root === vm) {\n return 'root instance'\n }\n var name = vm._isVue\n ? vm.$options.name || vm.$options._componentTag\n : vm.name;\n return (\n (name ? (\"component <\" + name + \">\") : \"anonymous component\") +\n (vm._isVue && vm.$options.__file ? (\" at \" + (vm.$options.__file)) : '')\n )\n };\n\n var formatLocation = function (str) {\n if (str === 'anonymous component') {\n str += \" - use the \\\"name\\\" option for better debugging messages.\";\n }\n return (\"\\n(found in \" + str + \")\")\n };\n}\n\n/* */\n\n\nvar uid$1 = 0;\n\n/**\n * A dep is an observable that can have multiple\n * directives subscribing to it.\n */\nvar Dep = function Dep () {\n this.id = uid$1++;\n this.subs = [];\n};\n\nDep.prototype.addSub = function addSub (sub) {\n this.subs.push(sub);\n};\n\nDep.prototype.removeSub = function removeSub (sub) {\n remove$1(this.subs, sub);\n};\n\nDep.prototype.depend = function depend () {\n if (Dep.target) {\n Dep.target.addDep(this);\n }\n};\n\nDep.prototype.notify = function notify () {\n // stablize the subscriber list first\n var subs = this.subs.slice();\n for (var i = 0, l = subs.length; i < l; i++) {\n subs[i].update();\n }\n};\n\n// the current target watcher being evaluated.\n// this is globally unique because there could be only one\n// watcher being evaluated at any time.\nDep.target = null;\nvar targetStack = [];\n\nfunction pushTarget (_target) {\n if (Dep.target) { targetStack.push(Dep.target); }\n Dep.target = _target;\n}\n\nfunction popTarget () {\n Dep.target = targetStack.pop();\n}\n\n/*\n * not type checking this file because flow doesn't play well with\n * dynamically accessing methods on Array prototype\n */\n\nvar arrayProto = Array.prototype;\nvar arrayMethods = Object.create(arrayProto);[\n 'push',\n 'pop',\n 'shift',\n 'unshift',\n 'splice',\n 'sort',\n 'reverse'\n]\n.forEach(function (method) {\n // cache original method\n var original = arrayProto[method];\n def(arrayMethods, method, function mutator () {\n var arguments$1 = arguments;\n\n // avoid leaking arguments:\n // http://jsperf.com/closure-with-arguments\n var i = arguments.length;\n var args = new Array(i);\n while (i--) {\n args[i] = arguments$1[i];\n }\n var result = original.apply(this, args);\n var ob = this.__ob__;\n var inserted;\n switch (method) {\n case 'push':\n inserted = args;\n break\n case 'unshift':\n inserted = args;\n break\n case 'splice':\n inserted = args.slice(2);\n break\n }\n if (inserted) { ob.observeArray(inserted); }\n // notify change\n ob.dep.notify();\n return result\n });\n});\n\n/* */\n\nvar arrayKeys = Object.getOwnPropertyNames(arrayMethods);\n\n/**\n * By default, when a reactive property is set, the new value is\n * also converted to become reactive. However when passing down props,\n * we don't want to force conversion because the value may be a nested value\n * under a frozen data structure. Converting it would defeat the optimization.\n */\nvar observerState = {\n shouldConvert: true,\n isSettingProps: false\n};\n\n/**\n * Observer class that are attached to each observed\n * object. Once attached, the observer converts target\n * object's property keys into getter/setters that\n * collect dependencies and dispatches updates.\n */\nvar Observer = function Observer (value) {\n this.value = value;\n this.dep = new Dep();\n this.vmCount = 0;\n def(value, '__ob__', this);\n if (Array.isArray(value)) {\n var augment = hasProto\n ? protoAugment\n : copyAugment;\n augment(value, arrayMethods, arrayKeys);\n this.observeArray(value);\n } else {\n this.walk(value);\n }\n};\n\n/**\n * Walk through each property and convert them into\n * getter/setters. This method should only be called when\n * value type is Object.\n */\nObserver.prototype.walk = function walk (obj) {\n var keys = Object.keys(obj);\n for (var i = 0; i < keys.length; i++) {\n defineReactive$$1(obj, keys[i], obj[keys[i]]);\n }\n};\n\n/**\n * Observe a list of Array items.\n */\nObserver.prototype.observeArray = function observeArray (items) {\n for (var i = 0, l = items.length; i < l; i++) {\n observe(items[i]);\n }\n};\n\n// helpers\n\n/**\n * Augment an target Object or Array by intercepting\n * the prototype chain using __proto__\n */\nfunction protoAugment (target, src) {\n /* eslint-disable no-proto */\n target.__proto__ = src;\n /* eslint-enable no-proto */\n}\n\n/**\n * Augment an target Object or Array by defining\n * hidden properties.\n */\n/* istanbul ignore next */\nfunction copyAugment (target, src, keys) {\n for (var i = 0, l = keys.length; i < l; i++) {\n var key = keys[i];\n def(target, key, src[key]);\n }\n}\n\n/**\n * Attempt to create an observer instance for a value,\n * returns the new observer if successfully observed,\n * or the existing observer if the value already has one.\n */\nfunction observe (value, asRootData) {\n if (!isObject(value)) {\n return\n }\n var ob;\n if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {\n ob = value.__ob__;\n } else if (\n observerState.shouldConvert &&\n !isServerRendering() &&\n (Array.isArray(value) || isPlainObject(value)) &&\n Object.isExtensible(value) &&\n !value._isVue\n ) {\n ob = new Observer(value);\n }\n if (asRootData && ob) {\n ob.vmCount++;\n }\n return ob\n}\n\n/**\n * Define a reactive property on an Object.\n */\nfunction defineReactive$$1 (\n obj,\n key,\n val,\n customSetter\n) {\n var dep = new Dep();\n\n var property = Object.getOwnPropertyDescriptor(obj, key);\n if (property && property.configurable === false) {\n return\n }\n\n // cater for pre-defined getter/setters\n var getter = property && property.get;\n var setter = property && property.set;\n\n var childOb = observe(val);\n Object.defineProperty(obj, key, {\n enumerable: true,\n configurable: true,\n get: function reactiveGetter () {\n var value = getter ? getter.call(obj) : val;\n if (Dep.target) {\n dep.depend();\n if (childOb) {\n childOb.dep.depend();\n }\n if (Array.isArray(value)) {\n dependArray(value);\n }\n }\n return value\n },\n set: function reactiveSetter (newVal) {\n var value = getter ? getter.call(obj) : val;\n /* eslint-disable no-self-compare */\n if (newVal === value || (newVal !== newVal && value !== value)) {\n return\n }\n /* eslint-enable no-self-compare */\n if (false) {\n customSetter();\n }\n if (setter) {\n setter.call(obj, newVal);\n } else {\n val = newVal;\n }\n childOb = observe(newVal);\n dep.notify();\n }\n });\n}\n\n/**\n * Set a property on an object. Adds the new property and\n * triggers change notification if the property doesn't\n * already exist.\n */\nfunction set$1 (obj, key, val) {\n if (Array.isArray(obj)) {\n obj.length = Math.max(obj.length, key);\n obj.splice(key, 1, val);\n return val\n }\n if (hasOwn(obj, key)) {\n obj[key] = val;\n return\n }\n var ob = obj.__ob__;\n if (obj._isVue || (ob && ob.vmCount)) {\n \"production\" !== 'production' && warn(\n 'Avoid adding reactive properties to a Vue instance or its root $data ' +\n 'at runtime - declare it upfront in the data option.'\n );\n return\n }\n if (!ob) {\n obj[key] = val;\n return\n }\n defineReactive$$1(ob.value, key, val);\n ob.dep.notify();\n return val\n}\n\n/**\n * Delete a property and trigger change if necessary.\n */\nfunction del (obj, key) {\n var ob = obj.__ob__;\n if (obj._isVue || (ob && ob.vmCount)) {\n \"production\" !== 'production' && warn(\n 'Avoid deleting properties on a Vue instance or its root $data ' +\n '- just set it to null.'\n );\n return\n }\n if (!hasOwn(obj, key)) {\n return\n }\n delete obj[key];\n if (!ob) {\n return\n }\n ob.dep.notify();\n}\n\n/**\n * Collect dependencies on array elements when the array is touched, since\n * we cannot intercept array element access like property getters.\n */\nfunction dependArray (value) {\n for (var e = (void 0), i = 0, l = value.length; i < l; i++) {\n e = value[i];\n e && e.__ob__ && e.__ob__.dep.depend();\n if (Array.isArray(e)) {\n dependArray(e);\n }\n }\n}\n\n/* */\n\n/**\n * Option overwriting strategies are functions that handle\n * how to merge a parent option value and a child option\n * value into the final value.\n */\nvar strats = config.optionMergeStrategies;\n\n/**\n * Options with restrictions\n */\nif (false) {\n strats.el = strats.propsData = function (parent, child, vm, key) {\n if (!vm) {\n warn(\n \"option \\\"\" + key + \"\\\" can only be used during instance \" +\n 'creation with the `new` keyword.'\n );\n }\n return defaultStrat(parent, child)\n };\n}\n\n/**\n * Helper that recursively merges two data objects together.\n */\nfunction mergeData (to, from) {\n if (!from) { return to }\n var key, toVal, fromVal;\n var keys = Object.keys(from);\n for (var i = 0; i < keys.length; i++) {\n key = keys[i];\n toVal = to[key];\n fromVal = from[key];\n if (!hasOwn(to, key)) {\n set$1(to, key, fromVal);\n } else if (isPlainObject(toVal) && isPlainObject(fromVal)) {\n mergeData(toVal, fromVal);\n }\n }\n return to\n}\n\n/**\n * Data\n */\nstrats.data = function (\n parentVal,\n childVal,\n vm\n) {\n if (!vm) {\n // in a Vue.extend merge, both should be functions\n if (!childVal) {\n return parentVal\n }\n if (typeof childVal !== 'function') {\n \"production\" !== 'production' && warn(\n 'The \"data\" option should be a function ' +\n 'that returns a per-instance value in component ' +\n 'definitions.',\n vm\n );\n return parentVal\n }\n if (!parentVal) {\n return childVal\n }\n // when parentVal & childVal are both present,\n // we need to return a function that returns the\n // merged result of both functions... no need to\n // check if parentVal is a function here because\n // it has to be a function to pass previous merges.\n return function mergedDataFn () {\n return mergeData(\n childVal.call(this),\n parentVal.call(this)\n )\n }\n } else if (parentVal || childVal) {\n return function mergedInstanceDataFn () {\n // instance merge\n var instanceData = typeof childVal === 'function'\n ? childVal.call(vm)\n : childVal;\n var defaultData = typeof parentVal === 'function'\n ? parentVal.call(vm)\n : undefined;\n if (instanceData) {\n return mergeData(instanceData, defaultData)\n } else {\n return defaultData\n }\n }\n }\n};\n\n/**\n * Hooks and param attributes are merged as arrays.\n */\nfunction mergeHook (\n parentVal,\n childVal\n) {\n return childVal\n ? parentVal\n ? parentVal.concat(childVal)\n : Array.isArray(childVal)\n ? childVal\n : [childVal]\n : parentVal\n}\n\nconfig._lifecycleHooks.forEach(function (hook) {\n strats[hook] = mergeHook;\n});\n\n/**\n * Assets\n *\n * When a vm is present (instance creation), we need to do\n * a three-way merge between constructor options, instance\n * options and parent options.\n */\nfunction mergeAssets (parentVal, childVal) {\n var res = Object.create(parentVal || null);\n return childVal\n ? extend(res, childVal)\n : res\n}\n\nconfig._assetTypes.forEach(function (type) {\n strats[type + 's'] = mergeAssets;\n});\n\n/**\n * Watchers.\n *\n * Watchers hashes should not overwrite one\n * another, so we merge them as arrays.\n */\nstrats.watch = function (parentVal, childVal) {\n /* istanbul ignore if */\n if (!childVal) { return parentVal }\n if (!parentVal) { return childVal }\n var ret = {};\n extend(ret, parentVal);\n for (var key in childVal) {\n var parent = ret[key];\n var child = childVal[key];\n if (parent && !Array.isArray(parent)) {\n parent = [parent];\n }\n ret[key] = parent\n ? parent.concat(child)\n : [child];\n }\n return ret\n};\n\n/**\n * Other object hashes.\n */\nstrats.props =\nstrats.methods =\nstrats.computed = function (parentVal, childVal) {\n if (!childVal) { return parentVal }\n if (!parentVal) { return childVal }\n var ret = Object.create(null);\n extend(ret, parentVal);\n extend(ret, childVal);\n return ret\n};\n\n/**\n * Default strategy.\n */\nvar defaultStrat = function (parentVal, childVal) {\n return childVal === undefined\n ? parentVal\n : childVal\n};\n\n/**\n * Validate component names\n */\nfunction checkComponents (options) {\n for (var key in options.components) {\n var lower = key.toLowerCase();\n if (isBuiltInTag(lower) || config.isReservedTag(lower)) {\n warn(\n 'Do not use built-in or reserved HTML elements as component ' +\n 'id: ' + key\n );\n }\n }\n}\n\n/**\n * Ensure all props option syntax are normalized into the\n * Object-based format.\n */\nfunction normalizeProps (options) {\n var props = options.props;\n if (!props) { return }\n var res = {};\n var i, val, name;\n if (Array.isArray(props)) {\n i = props.length;\n while (i--) {\n val = props[i];\n if (typeof val === 'string') {\n name = camelize(val);\n res[name] = { type: null };\n } else if (false) {\n warn('props must be strings when using array syntax.');\n }\n }\n } else if (isPlainObject(props)) {\n for (var key in props) {\n val = props[key];\n name = camelize(key);\n res[name] = isPlainObject(val)\n ? val\n : { type: val };\n }\n }\n options.props = res;\n}\n\n/**\n * Normalize raw function directives into object format.\n */\nfunction normalizeDirectives (options) {\n var dirs = options.directives;\n if (dirs) {\n for (var key in dirs) {\n var def = dirs[key];\n if (typeof def === 'function') {\n dirs[key] = { bind: def, update: def };\n }\n }\n }\n}\n\n/**\n * Merge two option objects into a new one.\n * Core utility used in both instantiation and inheritance.\n */\nfunction mergeOptions (\n parent,\n child,\n vm\n) {\n if (false) {\n checkComponents(child);\n }\n normalizeProps(child);\n normalizeDirectives(child);\n var extendsFrom = child.extends;\n if (extendsFrom) {\n parent = typeof extendsFrom === 'function'\n ? mergeOptions(parent, extendsFrom.options, vm)\n : mergeOptions(parent, extendsFrom, vm);\n }\n if (child.mixins) {\n for (var i = 0, l = child.mixins.length; i < l; i++) {\n var mixin = child.mixins[i];\n if (mixin.prototype instanceof Vue$3) {\n mixin = mixin.options;\n }\n parent = mergeOptions(parent, mixin, vm);\n }\n }\n var options = {};\n var key;\n for (key in parent) {\n mergeField(key);\n }\n for (key in child) {\n if (!hasOwn(parent, key)) {\n mergeField(key);\n }\n }\n function mergeField (key) {\n var strat = strats[key] || defaultStrat;\n options[key] = strat(parent[key], child[key], vm, key);\n }\n return options\n}\n\n/**\n * Resolve an asset.\n * This function is used because child instances need access\n * to assets defined in its ancestor chain.\n */\nfunction resolveAsset (\n options,\n type,\n id,\n warnMissing\n) {\n /* istanbul ignore if */\n if (typeof id !== 'string') {\n return\n }\n var assets = options[type];\n // check local registration variations first\n if (hasOwn(assets, id)) { return assets[id] }\n var camelizedId = camelize(id);\n if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }\n var PascalCaseId = capitalize(camelizedId);\n if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }\n // fallback to prototype chain\n var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];\n if (false) {\n warn(\n 'Failed to resolve ' + type.slice(0, -1) + ': ' + id,\n options\n );\n }\n return res\n}\n\n/* */\n\nfunction validateProp (\n key,\n propOptions,\n propsData,\n vm\n) {\n var prop = propOptions[key];\n var absent = !hasOwn(propsData, key);\n var value = propsData[key];\n // handle boolean props\n if (isType(Boolean, prop.type)) {\n if (absent && !hasOwn(prop, 'default')) {\n value = false;\n } else if (!isType(String, prop.type) && (value === '' || value === hyphenate(key))) {\n value = true;\n }\n }\n // check default value\n if (value === undefined) {\n value = getPropDefaultValue(vm, prop, key);\n // since the default value is a fresh copy,\n // make sure to observe it.\n var prevShouldConvert = observerState.shouldConvert;\n observerState.shouldConvert = true;\n observe(value);\n observerState.shouldConvert = prevShouldConvert;\n }\n if (false) {\n assertProp(prop, key, value, vm, absent);\n }\n return value\n}\n\n/**\n * Get the default value of a prop.\n */\nfunction getPropDefaultValue (vm, prop, key) {\n // no default, return undefined\n if (!hasOwn(prop, 'default')) {\n return undefined\n }\n var def = prop.default;\n // warn against non-factory defaults for Object & Array\n if (isObject(def)) {\n \"production\" !== 'production' && warn(\n 'Invalid default value for prop \"' + key + '\": ' +\n 'Props with type Object/Array must use a factory function ' +\n 'to return the default value.',\n vm\n );\n }\n // the raw prop value was also undefined from previous render,\n // return previous default value to avoid unnecessary watcher trigger\n if (vm && vm.$options.propsData &&\n vm.$options.propsData[key] === undefined &&\n vm[key] !== undefined) {\n return vm[key]\n }\n // call factory function for non-Function types\n return typeof def === 'function' && prop.type !== Function\n ? def.call(vm)\n : def\n}\n\n/**\n * Assert whether a prop is valid.\n */\nfunction assertProp (\n prop,\n name,\n value,\n vm,\n absent\n) {\n if (prop.required && absent) {\n warn(\n 'Missing required prop: \"' + name + '\"',\n vm\n );\n return\n }\n if (value == null && !prop.required) {\n return\n }\n var type = prop.type;\n var valid = !type || type === true;\n var expectedTypes = [];\n if (type) {\n if (!Array.isArray(type)) {\n type = [type];\n }\n for (var i = 0; i < type.length && !valid; i++) {\n var assertedType = assertType(value, type[i]);\n expectedTypes.push(assertedType.expectedType || '');\n valid = assertedType.valid;\n }\n }\n if (!valid) {\n warn(\n 'Invalid prop: type check failed for prop \"' + name + '\".' +\n ' Expected ' + expectedTypes.map(capitalize).join(', ') +\n ', got ' + Object.prototype.toString.call(value).slice(8, -1) + '.',\n vm\n );\n return\n }\n var validator = prop.validator;\n if (validator) {\n if (!validator(value)) {\n warn(\n 'Invalid prop: custom validator check failed for prop \"' + name + '\".',\n vm\n );\n }\n }\n}\n\n/**\n * Assert the type of a value\n */\nfunction assertType (value, type) {\n var valid;\n var expectedType = getType(type);\n if (expectedType === 'String') {\n valid = typeof value === (expectedType = 'string');\n } else if (expectedType === 'Number') {\n valid = typeof value === (expectedType = 'number');\n } else if (expectedType === 'Boolean') {\n valid = typeof value === (expectedType = 'boolean');\n } else if (expectedType === 'Function') {\n valid = typeof value === (expectedType = 'function');\n } else if (expectedType === 'Object') {\n valid = isPlainObject(value);\n } else if (expectedType === 'Array') {\n valid = Array.isArray(value);\n } else {\n valid = value instanceof type;\n }\n return {\n valid: valid,\n expectedType: expectedType\n }\n}\n\n/**\n * Use function string name to check built-in types,\n * because a simple equality check will fail when running\n * across different vms / iframes.\n */\nfunction getType (fn) {\n var match = fn && fn.toString().match(/^\\s*function (\\w+)/);\n return match && match[1]\n}\n\nfunction isType (type, fn) {\n if (!Array.isArray(fn)) {\n return getType(fn) === getType(type)\n }\n for (var i = 0, len = fn.length; i < len; i++) {\n if (getType(fn[i]) === getType(type)) {\n return true\n }\n }\n /* istanbul ignore next */\n return false\n}\n\n\n\nvar util = Object.freeze({\n\tdefineReactive: defineReactive$$1,\n\t_toString: _toString,\n\ttoNumber: toNumber,\n\tmakeMap: makeMap,\n\tisBuiltInTag: isBuiltInTag,\n\tremove: remove$1,\n\thasOwn: hasOwn,\n\tisPrimitive: isPrimitive,\n\tcached: cached,\n\tcamelize: camelize,\n\tcapitalize: capitalize,\n\thyphenate: hyphenate,\n\tbind: bind$1,\n\ttoArray: toArray,\n\textend: extend,\n\tisObject: isObject,\n\tisPlainObject: isPlainObject,\n\ttoObject: toObject,\n\tnoop: noop,\n\tno: no,\n\tidentity: identity,\n\tgenStaticKeys: genStaticKeys,\n\tlooseEqual: looseEqual,\n\tlooseIndexOf: looseIndexOf,\n\tisReserved: isReserved,\n\tdef: def,\n\tparsePath: parsePath,\n\thasProto: hasProto,\n\tinBrowser: inBrowser,\n\tUA: UA,\n\tisIE: isIE,\n\tisIE9: isIE9,\n\tisEdge: isEdge,\n\tisAndroid: isAndroid,\n\tisIOS: isIOS,\n\tisServerRendering: isServerRendering,\n\tdevtools: devtools,\n\tnextTick: nextTick,\n\tget _Set () { return _Set; },\n\tmergeOptions: mergeOptions,\n\tresolveAsset: resolveAsset,\n\tget warn () { return warn; },\n\tget formatComponentName () { return formatComponentName; },\n\tvalidateProp: validateProp\n});\n\n/* not type checking this file because flow doesn't play well with Proxy */\n\nvar initProxy;\n\nif (false) {\n var allowedGlobals = makeMap(\n 'Infinity,undefined,NaN,isFinite,isNaN,' +\n 'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +\n 'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +\n 'require' // for Webpack/Browserify\n );\n\n var warnNonPresent = function (target, key) {\n warn(\n \"Property or method \\\"\" + key + \"\\\" is not defined on the instance but \" +\n \"referenced during render. Make sure to declare reactive data \" +\n \"properties in the data option.\",\n target\n );\n };\n\n var hasProxy =\n typeof Proxy !== 'undefined' &&\n Proxy.toString().match(/native code/);\n\n if (hasProxy) {\n var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta');\n config.keyCodes = new Proxy(config.keyCodes, {\n set: function set (target, key, value) {\n if (isBuiltInModifier(key)) {\n warn((\"Avoid overwriting built-in modifier in config.keyCodes: .\" + key));\n return false\n } else {\n target[key] = value;\n return true\n }\n }\n });\n }\n\n var hasHandler = {\n has: function has (target, key) {\n var has = key in target;\n var isAllowed = allowedGlobals(key) || key.charAt(0) === '_';\n if (!has && !isAllowed) {\n warnNonPresent(target, key);\n }\n return has || !isAllowed\n }\n };\n\n var getHandler = {\n get: function get (target, key) {\n if (typeof key === 'string' && !(key in target)) {\n warnNonPresent(target, key);\n }\n return target[key]\n }\n };\n\n initProxy = function initProxy (vm) {\n if (hasProxy) {\n // determine which proxy handler to use\n var options = vm.$options;\n var handlers = options.render && options.render._withStripped\n ? getHandler\n : hasHandler;\n vm._renderProxy = new Proxy(vm, handlers);\n } else {\n vm._renderProxy = vm;\n }\n };\n}\n\n/* */\n\nvar VNode = function VNode (\n tag,\n data,\n children,\n text,\n elm,\n context,\n componentOptions\n) {\n this.tag = tag;\n this.data = data;\n this.children = children;\n this.text = text;\n this.elm = elm;\n this.ns = undefined;\n this.context = context;\n this.functionalContext = undefined;\n this.key = data && data.key;\n this.componentOptions = componentOptions;\n this.componentInstance = undefined;\n this.parent = undefined;\n this.raw = false;\n this.isStatic = false;\n this.isRootInsert = true;\n this.isComment = false;\n this.isCloned = false;\n this.isOnce = false;\n};\n\nvar prototypeAccessors = { child: {} };\n\n// DEPRECATED: alias for componentInstance for backwards compat.\n/* istanbul ignore next */\nprototypeAccessors.child.get = function () {\n return this.componentInstance\n};\n\nObject.defineProperties( VNode.prototype, prototypeAccessors );\n\nvar createEmptyVNode = function () {\n var node = new VNode();\n node.text = '';\n node.isComment = true;\n return node\n};\n\nfunction createTextVNode (val) {\n return new VNode(undefined, undefined, undefined, String(val))\n}\n\n// optimized shallow clone\n// used for static nodes and slot nodes because they may be reused across\n// multiple renders, cloning them avoids errors when DOM manipulations rely\n// on their elm reference.\nfunction cloneVNode (vnode) {\n var cloned = new VNode(\n vnode.tag,\n vnode.data,\n vnode.children,\n vnode.text,\n vnode.elm,\n vnode.context,\n vnode.componentOptions\n );\n cloned.ns = vnode.ns;\n cloned.isStatic = vnode.isStatic;\n cloned.key = vnode.key;\n cloned.isCloned = true;\n return cloned\n}\n\nfunction cloneVNodes (vnodes) {\n var res = new Array(vnodes.length);\n for (var i = 0; i < vnodes.length; i++) {\n res[i] = cloneVNode(vnodes[i]);\n }\n return res\n}\n\n/* */\n\nvar hooks = { init: init, prepatch: prepatch, insert: insert, destroy: destroy$1 };\nvar hooksToMerge = Object.keys(hooks);\n\nfunction createComponent (\n Ctor,\n data,\n context,\n children,\n tag\n) {\n if (!Ctor) {\n return\n }\n\n var baseCtor = context.$options._base;\n if (isObject(Ctor)) {\n Ctor = baseCtor.extend(Ctor);\n }\n\n if (typeof Ctor !== 'function') {\n if (false) {\n warn((\"Invalid Component definition: \" + (String(Ctor))), context);\n }\n return\n }\n\n // async component\n if (!Ctor.cid) {\n if (Ctor.resolved) {\n Ctor = Ctor.resolved;\n } else {\n Ctor = resolveAsyncComponent(Ctor, baseCtor, function () {\n // it's ok to queue this on every render because\n // $forceUpdate is buffered by the scheduler.\n context.$forceUpdate();\n });\n if (!Ctor) {\n // return nothing if this is indeed an async component\n // wait for the callback to trigger parent update.\n return\n }\n }\n }\n\n // resolve constructor options in case global mixins are applied after\n // component constructor creation\n resolveConstructorOptions(Ctor);\n\n data = data || {};\n\n // extract props\n var propsData = extractProps(data, Ctor);\n\n // functional component\n if (Ctor.options.functional) {\n return createFunctionalComponent(Ctor, propsData, data, context, children)\n }\n\n // extract listeners, since these needs to be treated as\n // child component listeners instead of DOM listeners\n var listeners = data.on;\n // replace with listeners with .native modifier\n data.on = data.nativeOn;\n\n if (Ctor.options.abstract) {\n // abstract components do not keep anything\n // other than props & listeners\n data = {};\n }\n\n // merge component management hooks onto the placeholder node\n mergeHooks(data);\n\n // return a placeholder vnode\n var name = Ctor.options.name || tag;\n var vnode = new VNode(\n (\"vue-component-\" + (Ctor.cid) + (name ? (\"-\" + name) : '')),\n data, undefined, undefined, undefined, context,\n { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }\n );\n return vnode\n}\n\nfunction createFunctionalComponent (\n Ctor,\n propsData,\n data,\n context,\n children\n) {\n var props = {};\n var propOptions = Ctor.options.props;\n if (propOptions) {\n for (var key in propOptions) {\n props[key] = validateProp(key, propOptions, propsData);\n }\n }\n // ensure the createElement function in functional components\n // gets a unique context - this is necessary for correct named slot check\n var _context = Object.create(context);\n var h = function (a, b, c, d) { return createElement(_context, a, b, c, d, true); };\n var vnode = Ctor.options.render.call(null, h, {\n props: props,\n data: data,\n parent: context,\n children: children,\n slots: function () { return resolveSlots(children, context); }\n });\n if (vnode instanceof VNode) {\n vnode.functionalContext = context;\n if (data.slot) {\n (vnode.data || (vnode.data = {})).slot = data.slot;\n }\n }\n return vnode\n}\n\nfunction createComponentInstanceForVnode (\n vnode, // we know it's MountedComponentVNode but flow doesn't\n parent, // activeInstance in lifecycle state\n parentElm,\n refElm\n) {\n var vnodeComponentOptions = vnode.componentOptions;\n var options = {\n _isComponent: true,\n parent: parent,\n propsData: vnodeComponentOptions.propsData,\n _componentTag: vnodeComponentOptions.tag,\n _parentVnode: vnode,\n _parentListeners: vnodeComponentOptions.listeners,\n _renderChildren: vnodeComponentOptions.children,\n _parentElm: parentElm || null,\n _refElm: refElm || null\n };\n // check inline-template render functions\n var inlineTemplate = vnode.data.inlineTemplate;\n if (inlineTemplate) {\n options.render = inlineTemplate.render;\n options.staticRenderFns = inlineTemplate.staticRenderFns;\n }\n return new vnodeComponentOptions.Ctor(options)\n}\n\nfunction init (\n vnode,\n hydrating,\n parentElm,\n refElm\n) {\n if (!vnode.componentInstance || vnode.componentInstance._isDestroyed) {\n var child = vnode.componentInstance = createComponentInstanceForVnode(\n vnode,\n activeInstance,\n parentElm,\n refElm\n );\n child.$mount(hydrating ? vnode.elm : undefined, hydrating);\n } else if (vnode.data.keepAlive) {\n // kept-alive components, treat as a patch\n var mountedNode = vnode; // work around flow\n prepatch(mountedNode, mountedNode);\n }\n}\n\nfunction prepatch (\n oldVnode,\n vnode\n) {\n var options = vnode.componentOptions;\n var child = vnode.componentInstance = oldVnode.componentInstance;\n child._updateFromParent(\n options.propsData, // updated props\n options.listeners, // updated listeners\n vnode, // new parent vnode\n options.children // new children\n );\n}\n\nfunction insert (vnode) {\n if (!vnode.componentInstance._isMounted) {\n vnode.componentInstance._isMounted = true;\n callHook(vnode.componentInstance, 'mounted');\n }\n if (vnode.data.keepAlive) {\n vnode.componentInstance._inactive = false;\n callHook(vnode.componentInstance, 'activated');\n }\n}\n\nfunction destroy$1 (vnode) {\n if (!vnode.componentInstance._isDestroyed) {\n if (!vnode.data.keepAlive) {\n vnode.componentInstance.$destroy();\n } else {\n vnode.componentInstance._inactive = true;\n callHook(vnode.componentInstance, 'deactivated');\n }\n }\n}\n\nfunction resolveAsyncComponent (\n factory,\n baseCtor,\n cb\n) {\n if (factory.requested) {\n // pool callbacks\n factory.pendingCallbacks.push(cb);\n } else {\n factory.requested = true;\n var cbs = factory.pendingCallbacks = [cb];\n var sync = true;\n\n var resolve = function (res) {\n if (isObject(res)) {\n res = baseCtor.extend(res);\n }\n // cache resolved\n factory.resolved = res;\n // invoke callbacks only if this is not a synchronous resolve\n // (async resolves are shimmed as synchronous during SSR)\n if (!sync) {\n for (var i = 0, l = cbs.length; i < l; i++) {\n cbs[i](res);\n }\n }\n };\n\n var reject = function (reason) {\n \"production\" !== 'production' && warn(\n \"Failed to resolve async component: \" + (String(factory)) +\n (reason ? (\"\\nReason: \" + reason) : '')\n );\n };\n\n var res = factory(resolve, reject);\n\n // handle promise\n if (res && typeof res.then === 'function' && !factory.resolved) {\n res.then(resolve, reject);\n }\n\n sync = false;\n // return in case resolved synchronously\n return factory.resolved\n }\n}\n\nfunction extractProps (data, Ctor) {\n // we are only extracting raw values here.\n // validation and default values are handled in the child\n // component itself.\n var propOptions = Ctor.options.props;\n if (!propOptions) {\n return\n }\n var res = {};\n var attrs = data.attrs;\n var props = data.props;\n var domProps = data.domProps;\n if (attrs || props || domProps) {\n for (var key in propOptions) {\n var altKey = hyphenate(key);\n checkProp(res, props, key, altKey, true) ||\n checkProp(res, attrs, key, altKey) ||\n checkProp(res, domProps, key, altKey);\n }\n }\n return res\n}\n\nfunction checkProp (\n res,\n hash,\n key,\n altKey,\n preserve\n) {\n if (hash) {\n if (hasOwn(hash, key)) {\n res[key] = hash[key];\n if (!preserve) {\n delete hash[key];\n }\n return true\n } else if (hasOwn(hash, altKey)) {\n res[key] = hash[altKey];\n if (!preserve) {\n delete hash[altKey];\n }\n return true\n }\n }\n return false\n}\n\nfunction mergeHooks (data) {\n if (!data.hook) {\n data.hook = {};\n }\n for (var i = 0; i < hooksToMerge.length; i++) {\n var key = hooksToMerge[i];\n var fromParent = data.hook[key];\n var ours = hooks[key];\n data.hook[key] = fromParent ? mergeHook$1(ours, fromParent) : ours;\n }\n}\n\nfunction mergeHook$1 (one, two) {\n return function (a, b, c, d) {\n one(a, b, c, d);\n two(a, b, c, d);\n }\n}\n\n/* */\n\nfunction mergeVNodeHook (def, hookKey, hook, key) {\n key = key + hookKey;\n var injectedHash = def.__injected || (def.__injected = {});\n if (!injectedHash[key]) {\n injectedHash[key] = true;\n var oldHook = def[hookKey];\n if (oldHook) {\n def[hookKey] = function () {\n oldHook.apply(this, arguments);\n hook.apply(this, arguments);\n };\n } else {\n def[hookKey] = hook;\n }\n }\n}\n\n/* */\n\nvar normalizeEvent = cached(function (name) {\n var once = name.charAt(0) === '~'; // Prefixed last, checked first\n name = once ? name.slice(1) : name;\n var capture = name.charAt(0) === '!';\n name = capture ? name.slice(1) : name;\n return {\n name: name,\n once: once,\n capture: capture\n }\n});\n\nfunction createEventHandle (fn) {\n var handle = {\n fn: fn,\n invoker: function () {\n var arguments$1 = arguments;\n\n var fn = handle.fn;\n if (Array.isArray(fn)) {\n for (var i = 0; i < fn.length; i++) {\n fn[i].apply(null, arguments$1);\n }\n } else {\n fn.apply(null, arguments);\n }\n }\n };\n return handle\n}\n\nfunction updateListeners (\n on,\n oldOn,\n add,\n remove$$1,\n vm\n) {\n var name, cur, old, event;\n for (name in on) {\n cur = on[name];\n old = oldOn[name];\n event = normalizeEvent(name);\n if (!cur) {\n \"production\" !== 'production' && warn(\n \"Invalid handler for event \\\"\" + (event.name) + \"\\\": got \" + String(cur),\n vm\n );\n } else if (!old) {\n if (!cur.invoker) {\n cur = on[name] = createEventHandle(cur);\n }\n add(event.name, cur.invoker, event.once, event.capture);\n } else if (cur !== old) {\n old.fn = cur;\n on[name] = old;\n }\n }\n for (name in oldOn) {\n if (!on[name]) {\n event = normalizeEvent(name);\n remove$$1(event.name, oldOn[name].invoker, event.capture);\n }\n }\n}\n\n/* */\n\n// The template compiler attempts to minimize the need for normalization by\n// statically analyzing the template at compile time.\n//\n// For plain HTML markup, normalization can be completely skipped because the\n// generated render function is guaranteed to return Array<VNode>. There are\n// two cases where extra normalization is needed:\n\n// 1. When the children contains components - because a functional component\n// may return an Array instead of a single root. In this case, just a simple\n// nomralization is needed - if any child is an Array, we flatten the whole\n// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep\n// because functional components already normalize their own children.\nfunction simpleNormalizeChildren (children) {\n for (var i = 0; i < children.length; i++) {\n if (Array.isArray(children[i])) {\n return Array.prototype.concat.apply([], children)\n }\n }\n return children\n}\n\n// 2. When the children contains constrcuts that always generated nested Arrays,\n// e.g. <template>, <slot>, v-for, or when the children is provided by user\n// with hand-written render functions / JSX. In such cases a full normalization\n// is needed to cater to all possible types of children values.\nfunction normalizeChildren (children) {\n return isPrimitive(children)\n ? [createTextVNode(children)]\n : Array.isArray(children)\n ? normalizeArrayChildren(children)\n : undefined\n}\n\nfunction normalizeArrayChildren (children, nestedIndex) {\n var res = [];\n var i, c, last;\n for (i = 0; i < children.length; i++) {\n c = children[i];\n if (c == null || typeof c === 'boolean') { continue }\n last = res[res.length - 1];\n // nested\n if (Array.isArray(c)) {\n res.push.apply(res, normalizeArrayChildren(c, ((nestedIndex || '') + \"_\" + i)));\n } else if (isPrimitive(c)) {\n if (last && last.text) {\n last.text += String(c);\n } else if (c !== '') {\n // convert primitive to vnode\n res.push(createTextVNode(c));\n }\n } else {\n if (c.text && last && last.text) {\n res[res.length - 1] = createTextVNode(last.text + c.text);\n } else {\n // default key for nested array children (likely generated by v-for)\n if (c.tag && c.key == null && nestedIndex != null) {\n c.key = \"__vlist\" + nestedIndex + \"_\" + i + \"__\";\n }\n res.push(c);\n }\n }\n }\n return res\n}\n\n/* */\n\nfunction getFirstComponentChild (children) {\n return children && children.filter(function (c) { return c && c.componentOptions; })[0]\n}\n\n/* */\n\nvar SIMPLE_NORMALIZE = 1;\nvar ALWAYS_NORMALIZE = 2;\n\n// wrapper function for providing a more flexible interface\n// without getting yelled at by flow\nfunction createElement (\n context,\n tag,\n data,\n children,\n normalizationType,\n alwaysNormalize\n) {\n if (Array.isArray(data) || isPrimitive(data)) {\n normalizationType = children;\n children = data;\n data = undefined;\n }\n if (alwaysNormalize) { normalizationType = ALWAYS_NORMALIZE; }\n return _createElement(context, tag, data, children, normalizationType)\n}\n\nfunction _createElement (\n context,\n tag,\n data,\n children,\n normalizationType\n) {\n if (data && data.__ob__) {\n \"production\" !== 'production' && warn(\n \"Avoid using observed data object as vnode data: \" + (JSON.stringify(data)) + \"\\n\" +\n 'Always create fresh vnode data objects in each render!',\n context\n );\n return createEmptyVNode()\n }\n if (!tag) {\n // in case of component :is set to falsy value\n return createEmptyVNode()\n }\n // support single function children as default scoped slot\n if (Array.isArray(children) &&\n typeof children[0] === 'function') {\n data = data || {};\n data.scopedSlots = { default: children[0] };\n children.length = 0;\n }\n if (normalizationType === ALWAYS_NORMALIZE) {\n children = normalizeChildren(children);\n } else if (normalizationType === SIMPLE_NORMALIZE) {\n children = simpleNormalizeChildren(children);\n }\n var vnode, ns;\n if (typeof tag === 'string') {\n var Ctor;\n ns = config.getTagNamespace(tag);\n if (config.isReservedTag(tag)) {\n // platform built-in elements\n vnode = new VNode(\n config.parsePlatformTagName(tag), data, children,\n undefined, undefined, context\n );\n } else if ((Ctor = resolveAsset(context.$options, 'components', tag))) {\n // component\n vnode = createComponent(Ctor, data, context, children, tag);\n } else {\n // unknown or unlisted namespaced elements\n // check at runtime because it may get assigned a namespace when its\n // parent normalizes children\n vnode = new VNode(\n tag, data, children,\n undefined, undefined, context\n );\n }\n } else {\n // direct component options / constructor\n vnode = createComponent(tag, data, context, children);\n }\n if (vnode) {\n if (ns) { applyNS(vnode, ns); }\n return vnode\n } else {\n return createEmptyVNode()\n }\n}\n\nfunction applyNS (vnode, ns) {\n vnode.ns = ns;\n if (vnode.tag === 'foreignObject') {\n // use default namespace inside foreignObject\n return\n }\n if (vnode.children) {\n for (var i = 0, l = vnode.children.length; i < l; i++) {\n var child = vnode.children[i];\n if (child.tag && !child.ns) {\n applyNS(child, ns);\n }\n }\n }\n}\n\n/* */\n\nfunction initRender (vm) {\n vm.$vnode = null; // the placeholder node in parent tree\n vm._vnode = null; // the root of the child tree\n vm._staticTrees = null;\n var parentVnode = vm.$options._parentVnode;\n var renderContext = parentVnode && parentVnode.context;\n vm.$slots = resolveSlots(vm.$options._renderChildren, renderContext);\n vm.$scopedSlots = {};\n // bind the createElement fn to this instance\n // so that we get proper render context inside it.\n // args order: tag, data, children, normalizationType, alwaysNormalize\n // internal version is used by render functions compiled from templates\n vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };\n // normalization is always applied for the public version, used in\n // user-written render functions.\n vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };\n}\n\nfunction renderMixin (Vue) {\n Vue.prototype.$nextTick = function (fn) {\n return nextTick(fn, this)\n };\n\n Vue.prototype._render = function () {\n var vm = this;\n var ref = vm.$options;\n var render = ref.render;\n var staticRenderFns = ref.staticRenderFns;\n var _parentVnode = ref._parentVnode;\n\n if (vm._isMounted) {\n // clone slot nodes on re-renders\n for (var key in vm.$slots) {\n vm.$slots[key] = cloneVNodes(vm.$slots[key]);\n }\n }\n\n if (_parentVnode && _parentVnode.data.scopedSlots) {\n vm.$scopedSlots = _parentVnode.data.scopedSlots;\n }\n\n if (staticRenderFns && !vm._staticTrees) {\n vm._staticTrees = [];\n }\n // set parent vnode. this allows render functions to have access\n // to the data on the placeholder node.\n vm.$vnode = _parentVnode;\n // render self\n var vnode;\n try {\n vnode = render.call(vm._renderProxy, vm.$createElement);\n } catch (e) {\n /* istanbul ignore else */\n if (config.errorHandler) {\n config.errorHandler.call(null, e, vm);\n } else {\n if (false) {\n warn((\"Error when rendering \" + (formatComponentName(vm)) + \":\"));\n }\n throw e\n }\n // return previous vnode to prevent render error causing blank component\n vnode = vm._vnode;\n }\n // return empty vnode in case the render function errored out\n if (!(vnode instanceof VNode)) {\n if (false) {\n warn(\n 'Multiple root nodes returned from render function. Render function ' +\n 'should return a single root node.',\n vm\n );\n }\n vnode = createEmptyVNode();\n }\n // set parent\n vnode.parent = _parentVnode;\n return vnode\n };\n\n // toString for mustaches\n Vue.prototype._s = _toString;\n // convert text to vnode\n Vue.prototype._v = createTextVNode;\n // number conversion\n Vue.prototype._n = toNumber;\n // empty vnode\n Vue.prototype._e = createEmptyVNode;\n // loose equal\n Vue.prototype._q = looseEqual;\n // loose indexOf\n Vue.prototype._i = looseIndexOf;\n\n // render static tree by index\n Vue.prototype._m = function renderStatic (\n index,\n isInFor\n ) {\n var tree = this._staticTrees[index];\n // if has already-rendered static tree and not inside v-for,\n // we can reuse the same tree by doing a shallow clone.\n if (tree && !isInFor) {\n return Array.isArray(tree)\n ? cloneVNodes(tree)\n : cloneVNode(tree)\n }\n // otherwise, render a fresh tree.\n tree = this._staticTrees[index] = this.$options.staticRenderFns[index].call(this._renderProxy);\n markStatic(tree, (\"__static__\" + index), false);\n return tree\n };\n\n // mark node as static (v-once)\n Vue.prototype._o = function markOnce (\n tree,\n index,\n key\n ) {\n markStatic(tree, (\"__once__\" + index + (key ? (\"_\" + key) : \"\")), true);\n return tree\n };\n\n function markStatic (tree, key, isOnce) {\n if (Array.isArray(tree)) {\n for (var i = 0; i < tree.length; i++) {\n if (tree[i] && typeof tree[i] !== 'string') {\n markStaticNode(tree[i], (key + \"_\" + i), isOnce);\n }\n }\n } else {\n markStaticNode(tree, key, isOnce);\n }\n }\n\n function markStaticNode (node, key, isOnce) {\n node.isStatic = true;\n node.key = key;\n node.isOnce = isOnce;\n }\n\n // filter resolution helper\n Vue.prototype._f = function resolveFilter (id) {\n return resolveAsset(this.$options, 'filters', id, true) || identity\n };\n\n // render v-for\n Vue.prototype._l = function renderList (\n val,\n render\n ) {\n var ret, i, l, keys, key;\n if (Array.isArray(val) || typeof val === 'string') {\n ret = new Array(val.length);\n for (i = 0, l = val.length; i < l; i++) {\n ret[i] = render(val[i], i);\n }\n } else if (typeof val === 'number') {\n ret = new Array(val);\n for (i = 0; i < val; i++) {\n ret[i] = render(i + 1, i);\n }\n } else if (isObject(val)) {\n keys = Object.keys(val);\n ret = new Array(keys.length);\n for (i = 0, l = keys.length; i < l; i++) {\n key = keys[i];\n ret[i] = render(val[key], key, i);\n }\n }\n return ret\n };\n\n // renderSlot\n Vue.prototype._t = function (\n name,\n fallback,\n props,\n bindObject\n ) {\n var scopedSlotFn = this.$scopedSlots[name];\n if (scopedSlotFn) { // scoped slot\n props = props || {};\n if (bindObject) {\n extend(props, bindObject);\n }\n return scopedSlotFn(props) || fallback\n } else {\n var slotNodes = this.$slots[name];\n // warn duplicate slot usage\n if (slotNodes && \"production\" !== 'production') {\n slotNodes._rendered && warn(\n \"Duplicate presence of slot \\\"\" + name + \"\\\" found in the same render tree \" +\n \"- this will likely cause render errors.\",\n this\n );\n slotNodes._rendered = true;\n }\n return slotNodes || fallback\n }\n };\n\n // apply v-bind object\n Vue.prototype._b = function bindProps (\n data,\n tag,\n value,\n asProp\n ) {\n if (value) {\n if (!isObject(value)) {\n \"production\" !== 'production' && warn(\n 'v-bind without argument expects an Object or Array value',\n this\n );\n } else {\n if (Array.isArray(value)) {\n value = toObject(value);\n }\n for (var key in value) {\n if (key === 'class' || key === 'style') {\n data[key] = value[key];\n } else {\n var type = data.attrs && data.attrs.type;\n var hash = asProp || config.mustUseProp(tag, type, key)\n ? data.domProps || (data.domProps = {})\n : data.attrs || (data.attrs = {});\n hash[key] = value[key];\n }\n }\n }\n }\n return data\n };\n\n // check v-on keyCodes\n Vue.prototype._k = function checkKeyCodes (\n eventKeyCode,\n key,\n builtInAlias\n ) {\n var keyCodes = config.keyCodes[key] || builtInAlias;\n if (Array.isArray(keyCodes)) {\n return keyCodes.indexOf(eventKeyCode) === -1\n } else {\n return keyCodes !== eventKeyCode\n }\n };\n}\n\nfunction resolveSlots (\n children,\n context\n) {\n var slots = {};\n if (!children) {\n return slots\n }\n var defaultSlot = [];\n var name, child;\n for (var i = 0, l = children.length; i < l; i++) {\n child = children[i];\n // named slots should only be respected if the vnode was rendered in the\n // same context.\n if ((child.context === context || child.functionalContext === context) &&\n child.data && (name = child.data.slot)) {\n var slot = (slots[name] || (slots[name] = []));\n if (child.tag === 'template') {\n slot.push.apply(slot, child.children);\n } else {\n slot.push(child);\n }\n } else {\n defaultSlot.push(child);\n }\n }\n // ignore single whitespace\n if (defaultSlot.length && !(\n defaultSlot.length === 1 &&\n (defaultSlot[0].text === ' ' || defaultSlot[0].isComment)\n )) {\n slots.default = defaultSlot;\n }\n return slots\n}\n\n/* */\n\nfunction initEvents (vm) {\n vm._events = Object.create(null);\n vm._hasHookEvent = false;\n // init parent attached events\n var listeners = vm.$options._parentListeners;\n if (listeners) {\n updateComponentListeners(vm, listeners);\n }\n}\n\nvar target;\n\nfunction add$1 (event, fn, once) {\n if (once) {\n target.$once(event, fn);\n } else {\n target.$on(event, fn);\n }\n}\n\nfunction remove$2 (event, fn) {\n target.$off(event, fn);\n}\n\nfunction updateComponentListeners (\n vm,\n listeners,\n oldListeners\n) {\n target = vm;\n updateListeners(listeners, oldListeners || {}, add$1, remove$2, vm);\n}\n\nfunction eventsMixin (Vue) {\n var hookRE = /^hook:/;\n Vue.prototype.$on = function (event, fn) {\n var vm = this;(vm._events[event] || (vm._events[event] = [])).push(fn);\n // optimize hook:event cost by using a boolean flag marked at registration\n // instead of a hash lookup\n if (hookRE.test(event)) {\n vm._hasHookEvent = true;\n }\n return vm\n };\n\n Vue.prototype.$once = function (event, fn) {\n var vm = this;\n function on () {\n vm.$off(event, on);\n fn.apply(vm, arguments);\n }\n on.fn = fn;\n vm.$on(event, on);\n return vm\n };\n\n Vue.prototype.$off = function (event, fn) {\n var vm = this;\n // all\n if (!arguments.length) {\n vm._events = Object.create(null);\n return vm\n }\n // specific event\n var cbs = vm._events[event];\n if (!cbs) {\n return vm\n }\n if (arguments.length === 1) {\n vm._events[event] = null;\n return vm\n }\n // specific handler\n var cb;\n var i = cbs.length;\n while (i--) {\n cb = cbs[i];\n if (cb === fn || cb.fn === fn) {\n cbs.splice(i, 1);\n break\n }\n }\n return vm\n };\n\n Vue.prototype.$emit = function (event) {\n var vm = this;\n var cbs = vm._events[event];\n if (cbs) {\n cbs = cbs.length > 1 ? toArray(cbs) : cbs;\n var args = toArray(arguments, 1);\n for (var i = 0, l = cbs.length; i < l; i++) {\n cbs[i].apply(vm, args);\n }\n }\n return vm\n };\n}\n\n/* */\n\nvar activeInstance = null;\n\nfunction initLifecycle (vm) {\n var options = vm.$options;\n\n // locate first non-abstract parent\n var parent = options.parent;\n if (parent && !options.abstract) {\n while (parent.$options.abstract && parent.$parent) {\n parent = parent.$parent;\n }\n parent.$children.push(vm);\n }\n\n vm.$parent = parent;\n vm.$root = parent ? parent.$root : vm;\n\n vm.$children = [];\n vm.$refs = {};\n\n vm._watcher = null;\n vm._inactive = false;\n vm._isMounted = false;\n vm._isDestroyed = false;\n vm._isBeingDestroyed = false;\n}\n\nfunction lifecycleMixin (Vue) {\n Vue.prototype._mount = function (\n el,\n hydrating\n ) {\n var vm = this;\n vm.$el = el;\n if (!vm.$options.render) {\n vm.$options.render = createEmptyVNode;\n if (false) {\n /* istanbul ignore if */\n if (vm.$options.template && vm.$options.template.charAt(0) !== '#') {\n warn(\n 'You are using the runtime-only build of Vue where the template ' +\n 'option is not available. Either pre-compile the templates into ' +\n 'render functions, or use the compiler-included build.',\n vm\n );\n } else {\n warn(\n 'Failed to mount component: template or render function not defined.',\n vm\n );\n }\n }\n }\n callHook(vm, 'beforeMount');\n vm._watcher = new Watcher(vm, function updateComponent () {\n vm._update(vm._render(), hydrating);\n }, noop);\n hydrating = false;\n // manually mounted instance, call mounted on self\n // mounted is called for render-created child components in its inserted hook\n if (vm.$vnode == null) {\n vm._isMounted = true;\n callHook(vm, 'mounted');\n }\n return vm\n };\n\n Vue.prototype._update = function (vnode, hydrating) {\n var vm = this;\n if (vm._isMounted) {\n callHook(vm, 'beforeUpdate');\n }\n var prevEl = vm.$el;\n var prevVnode = vm._vnode;\n var prevActiveInstance = activeInstance;\n activeInstance = vm;\n vm._vnode = vnode;\n // Vue.prototype.__patch__ is injected in entry points\n // based on the rendering backend used.\n if (!prevVnode) {\n // initial render\n vm.$el = vm.__patch__(\n vm.$el, vnode, hydrating, false /* removeOnly */,\n vm.$options._parentElm,\n vm.$options._refElm\n );\n } else {\n // updates\n vm.$el = vm.__patch__(prevVnode, vnode);\n }\n activeInstance = prevActiveInstance;\n // update __vue__ reference\n if (prevEl) {\n prevEl.__vue__ = null;\n }\n if (vm.$el) {\n vm.$el.__vue__ = vm;\n }\n // if parent is an HOC, update its $el as well\n if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {\n vm.$parent.$el = vm.$el;\n }\n // updated hook is called by the scheduler to ensure that children are\n // updated in a parent's updated hook.\n };\n\n Vue.prototype._updateFromParent = function (\n propsData,\n listeners,\n parentVnode,\n renderChildren\n ) {\n var vm = this;\n var hasChildren = !!(vm.$options._renderChildren || renderChildren);\n vm.$options._parentVnode = parentVnode;\n vm.$vnode = parentVnode; // update vm's placeholder node without re-render\n if (vm._vnode) { // update child tree's parent\n vm._vnode.parent = parentVnode;\n }\n vm.$options._renderChildren = renderChildren;\n // update props\n if (propsData && vm.$options.props) {\n observerState.shouldConvert = false;\n if (false) {\n observerState.isSettingProps = true;\n }\n var propKeys = vm.$options._propKeys || [];\n for (var i = 0; i < propKeys.length; i++) {\n var key = propKeys[i];\n vm[key] = validateProp(key, vm.$options.props, propsData, vm);\n }\n observerState.shouldConvert = true;\n if (false) {\n observerState.isSettingProps = false;\n }\n vm.$options.propsData = propsData;\n }\n // update listeners\n if (listeners) {\n var oldListeners = vm.$options._parentListeners;\n vm.$options._parentListeners = listeners;\n updateComponentListeners(vm, listeners, oldListeners);\n }\n // resolve slots + force update if has children\n if (hasChildren) {\n vm.$slots = resolveSlots(renderChildren, parentVnode.context);\n vm.$forceUpdate();\n }\n };\n\n Vue.prototype.$forceUpdate = function () {\n var vm = this;\n if (vm._watcher) {\n vm._watcher.update();\n }\n };\n\n Vue.prototype.$destroy = function () {\n var vm = this;\n if (vm._isBeingDestroyed) {\n return\n }\n callHook(vm, 'beforeDestroy');\n vm._isBeingDestroyed = true;\n // remove self from parent\n var parent = vm.$parent;\n if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {\n remove$1(parent.$children, vm);\n }\n // teardown watchers\n if (vm._watcher) {\n vm._watcher.teardown();\n }\n var i = vm._watchers.length;\n while (i--) {\n vm._watchers[i].teardown();\n }\n // remove reference from data ob\n // frozen object may not have observer.\n if (vm._data.__ob__) {\n vm._data.__ob__.vmCount--;\n }\n // call the last hook...\n vm._isDestroyed = true;\n callHook(vm, 'destroyed');\n // turn off all instance listeners.\n vm.$off();\n // remove __vue__ reference\n if (vm.$el) {\n vm.$el.__vue__ = null;\n }\n // invoke destroy hooks on current rendered tree\n vm.__patch__(vm._vnode, null);\n };\n}\n\nfunction callHook (vm, hook) {\n var handlers = vm.$options[hook];\n if (handlers) {\n for (var i = 0, j = handlers.length; i < j; i++) {\n handlers[i].call(vm);\n }\n }\n if (vm._hasHookEvent) {\n vm.$emit('hook:' + hook);\n }\n}\n\n/* */\n\n\nvar queue = [];\nvar has$1 = {};\nvar circular = {};\nvar waiting = false;\nvar flushing = false;\nvar index = 0;\n\n/**\n * Reset the scheduler's state.\n */\nfunction resetSchedulerState () {\n queue.length = 0;\n has$1 = {};\n if (false) {\n circular = {};\n }\n waiting = flushing = false;\n}\n\n/**\n * Flush both queues and run the watchers.\n */\nfunction flushSchedulerQueue () {\n flushing = true;\n var watcher, id, vm;\n\n // Sort queue before flush.\n // This ensures that:\n // 1. Components are updated from parent to child. (because parent is always\n // created before the child)\n // 2. A component's user watchers are run before its render watcher (because\n // user watchers are created before the render watcher)\n // 3. If a component is destroyed during a parent component's watcher run,\n // its watchers can be skipped.\n queue.sort(function (a, b) { return a.id - b.id; });\n\n // do not cache length because more watchers might be pushed\n // as we run existing watchers\n for (index = 0; index < queue.length; index++) {\n watcher = queue[index];\n id = watcher.id;\n has$1[id] = null;\n watcher.run();\n // in dev build, check and stop circular updates.\n if (false) {\n circular[id] = (circular[id] || 0) + 1;\n if (circular[id] > config._maxUpdateCount) {\n warn(\n 'You may have an infinite update loop ' + (\n watcher.user\n ? (\"in watcher with expression \\\"\" + (watcher.expression) + \"\\\"\")\n : \"in a component render function.\"\n ),\n watcher.vm\n );\n break\n }\n }\n }\n\n // call updated hooks\n index = queue.length;\n while (index--) {\n watcher = queue[index];\n vm = watcher.vm;\n if (vm._watcher === watcher && vm._isMounted) {\n callHook(vm, 'updated');\n }\n }\n\n // devtool hook\n /* istanbul ignore if */\n if (devtools && config.devtools) {\n devtools.emit('flush');\n }\n\n resetSchedulerState();\n}\n\n/**\n * Push a watcher into the watcher queue.\n * Jobs with duplicate IDs will be skipped unless it's\n * pushed when the queue is being flushed.\n */\nfunction queueWatcher (watcher) {\n var id = watcher.id;\n if (has$1[id] == null) {\n has$1[id] = true;\n if (!flushing) {\n queue.push(watcher);\n } else {\n // if already flushing, splice the watcher based on its id\n // if already past its id, it will be run next immediately.\n var i = queue.length - 1;\n while (i >= 0 && queue[i].id > watcher.id) {\n i--;\n }\n queue.splice(Math.max(i, index) + 1, 0, watcher);\n }\n // queue the flush\n if (!waiting) {\n waiting = true;\n nextTick(flushSchedulerQueue);\n }\n }\n}\n\n/* */\n\nvar uid$2 = 0;\n\n/**\n * A watcher parses an expression, collects dependencies,\n * and fires callback when the expression value changes.\n * This is used for both the $watch() api and directives.\n */\nvar Watcher = function Watcher (\n vm,\n expOrFn,\n cb,\n options\n) {\n this.vm = vm;\n vm._watchers.push(this);\n // options\n if (options) {\n this.deep = !!options.deep;\n this.user = !!options.user;\n this.lazy = !!options.lazy;\n this.sync = !!options.sync;\n } else {\n this.deep = this.user = this.lazy = this.sync = false;\n }\n this.cb = cb;\n this.id = ++uid$2; // uid for batching\n this.active = true;\n this.dirty = this.lazy; // for lazy watchers\n this.deps = [];\n this.newDeps = [];\n this.depIds = new _Set();\n this.newDepIds = new _Set();\n this.expression = false\n ? expOrFn.toString()\n : '';\n // parse expression for getter\n if (typeof expOrFn === 'function') {\n this.getter = expOrFn;\n } else {\n this.getter = parsePath(expOrFn);\n if (!this.getter) {\n this.getter = function () {};\n \"production\" !== 'production' && warn(\n \"Failed watching path: \\\"\" + expOrFn + \"\\\" \" +\n 'Watcher only accepts simple dot-delimited paths. ' +\n 'For full control, use a function instead.',\n vm\n );\n }\n }\n this.value = this.lazy\n ? undefined\n : this.get();\n};\n\n/**\n * Evaluate the getter, and re-collect dependencies.\n */\nWatcher.prototype.get = function get () {\n pushTarget(this);\n var value = this.getter.call(this.vm, this.vm);\n // \"touch\" every property so they are all tracked as\n // dependencies for deep watching\n if (this.deep) {\n traverse(value);\n }\n popTarget();\n this.cleanupDeps();\n return value\n};\n\n/**\n * Add a dependency to this directive.\n */\nWatcher.prototype.addDep = function addDep (dep) {\n var id = dep.id;\n if (!this.newDepIds.has(id)) {\n this.newDepIds.add(id);\n this.newDeps.push(dep);\n if (!this.depIds.has(id)) {\n dep.addSub(this);\n }\n }\n};\n\n/**\n * Clean up for dependency collection.\n */\nWatcher.prototype.cleanupDeps = function cleanupDeps () {\n var this$1 = this;\n\n var i = this.deps.length;\n while (i--) {\n var dep = this$1.deps[i];\n if (!this$1.newDepIds.has(dep.id)) {\n dep.removeSub(this$1);\n }\n }\n var tmp = this.depIds;\n this.depIds = this.newDepIds;\n this.newDepIds = tmp;\n this.newDepIds.clear();\n tmp = this.deps;\n this.deps = this.newDeps;\n this.newDeps = tmp;\n this.newDeps.length = 0;\n};\n\n/**\n * Subscriber interface.\n * Will be called when a dependency changes.\n */\nWatcher.prototype.update = function update () {\n /* istanbul ignore else */\n if (this.lazy) {\n this.dirty = true;\n } else if (this.sync) {\n this.run();\n } else {\n queueWatcher(this);\n }\n};\n\n/**\n * Scheduler job interface.\n * Will be called by the scheduler.\n */\nWatcher.prototype.run = function run () {\n if (this.active) {\n var value = this.get();\n if (\n value !== this.value ||\n // Deep watchers and watchers on Object/Arrays should fire even\n // when the value is the same, because the value may\n // have mutated.\n isObject(value) ||\n this.deep\n ) {\n // set new value\n var oldValue = this.value;\n this.value = value;\n if (this.user) {\n try {\n this.cb.call(this.vm, value, oldValue);\n } catch (e) {\n /* istanbul ignore else */\n if (config.errorHandler) {\n config.errorHandler.call(null, e, this.vm);\n } else {\n \"production\" !== 'production' && warn(\n (\"Error in watcher \\\"\" + (this.expression) + \"\\\"\"),\n this.vm\n );\n throw e\n }\n }\n } else {\n this.cb.call(this.vm, value, oldValue);\n }\n }\n }\n};\n\n/**\n * Evaluate the value of the watcher.\n * This only gets called for lazy watchers.\n */\nWatcher.prototype.evaluate = function evaluate () {\n this.value = this.get();\n this.dirty = false;\n};\n\n/**\n * Depend on all deps collected by this watcher.\n */\nWatcher.prototype.depend = function depend () {\n var this$1 = this;\n\n var i = this.deps.length;\n while (i--) {\n this$1.deps[i].depend();\n }\n};\n\n/**\n * Remove self from all dependencies' subscriber list.\n */\nWatcher.prototype.teardown = function teardown () {\n var this$1 = this;\n\n if (this.active) {\n // remove self from vm's watcher list\n // this is a somewhat expensive operation so we skip it\n // if the vm is being destroyed.\n if (!this.vm._isBeingDestroyed) {\n remove$1(this.vm._watchers, this);\n }\n var i = this.deps.length;\n while (i--) {\n this$1.deps[i].removeSub(this$1);\n }\n this.active = false;\n }\n};\n\n/**\n * Recursively traverse an object to evoke all converted\n * getters, so that every nested property inside the object\n * is collected as a \"deep\" dependency.\n */\nvar seenObjects = new _Set();\nfunction traverse (val) {\n seenObjects.clear();\n _traverse(val, seenObjects);\n}\n\nfunction _traverse (val, seen) {\n var i, keys;\n var isA = Array.isArray(val);\n if ((!isA && !isObject(val)) || !Object.isExtensible(val)) {\n return\n }\n if (val.__ob__) {\n var depId = val.__ob__.dep.id;\n if (seen.has(depId)) {\n return\n }\n seen.add(depId);\n }\n if (isA) {\n i = val.length;\n while (i--) { _traverse(val[i], seen); }\n } else {\n keys = Object.keys(val);\n i = keys.length;\n while (i--) { _traverse(val[keys[i]], seen); }\n }\n}\n\n/* */\n\nfunction initState (vm) {\n vm._watchers = [];\n var opts = vm.$options;\n if (opts.props) { initProps(vm, opts.props); }\n if (opts.methods) { initMethods(vm, opts.methods); }\n if (opts.data) {\n initData(vm);\n } else {\n observe(vm._data = {}, true /* asRootData */);\n }\n if (opts.computed) { initComputed(vm, opts.computed); }\n if (opts.watch) { initWatch(vm, opts.watch); }\n}\n\nvar isReservedProp = { key: 1, ref: 1, slot: 1 };\n\nfunction initProps (vm, props) {\n var propsData = vm.$options.propsData || {};\n var keys = vm.$options._propKeys = Object.keys(props);\n var isRoot = !vm.$parent;\n // root instance props should be converted\n observerState.shouldConvert = isRoot;\n var loop = function ( i ) {\n var key = keys[i];\n /* istanbul ignore else */\n if (false) {\n if (isReservedProp[key]) {\n warn(\n (\"\\\"\" + key + \"\\\" is a reserved attribute and cannot be used as component prop.\"),\n vm\n );\n }\n defineReactive$$1(vm, key, validateProp(key, props, propsData, vm), function () {\n if (vm.$parent && !observerState.isSettingProps) {\n warn(\n \"Avoid mutating a prop directly since the value will be \" +\n \"overwritten whenever the parent component re-renders. \" +\n \"Instead, use a data or computed property based on the prop's \" +\n \"value. Prop being mutated: \\\"\" + key + \"\\\"\",\n vm\n );\n }\n });\n } else {\n defineReactive$$1(vm, key, validateProp(key, props, propsData, vm));\n }\n };\n\n for (var i = 0; i < keys.length; i++) loop( i );\n observerState.shouldConvert = true;\n}\n\nfunction initData (vm) {\n var data = vm.$options.data;\n data = vm._data = typeof data === 'function'\n ? data.call(vm)\n : data || {};\n if (!isPlainObject(data)) {\n data = {};\n \"production\" !== 'production' && warn(\n 'data functions should return an object:\\n' +\n 'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',\n vm\n );\n }\n // proxy data on instance\n var keys = Object.keys(data);\n var props = vm.$options.props;\n var i = keys.length;\n while (i--) {\n if (props && hasOwn(props, keys[i])) {\n \"production\" !== 'production' && warn(\n \"The data property \\\"\" + (keys[i]) + \"\\\" is already declared as a prop. \" +\n \"Use prop default value instead.\",\n vm\n );\n } else {\n proxy(vm, keys[i]);\n }\n }\n // observe data\n observe(data, true /* asRootData */);\n}\n\nvar computedSharedDefinition = {\n enumerable: true,\n configurable: true,\n get: noop,\n set: noop\n};\n\nfunction initComputed (vm, computed) {\n for (var key in computed) {\n /* istanbul ignore if */\n if (false) {\n warn(\n \"existing instance property \\\"\" + key + \"\\\" will be \" +\n \"overwritten by a computed property with the same name.\",\n vm\n );\n }\n var userDef = computed[key];\n if (typeof userDef === 'function') {\n computedSharedDefinition.get = makeComputedGetter(userDef, vm);\n computedSharedDefinition.set = noop;\n } else {\n computedSharedDefinition.get = userDef.get\n ? userDef.cache !== false\n ? makeComputedGetter(userDef.get, vm)\n : bind$1(userDef.get, vm)\n : noop;\n computedSharedDefinition.set = userDef.set\n ? bind$1(userDef.set, vm)\n : noop;\n }\n Object.defineProperty(vm, key, computedSharedDefinition);\n }\n}\n\nfunction makeComputedGetter (getter, owner) {\n var watcher = new Watcher(owner, getter, noop, {\n lazy: true\n });\n return function computedGetter () {\n if (watcher.dirty) {\n watcher.evaluate();\n }\n if (Dep.target) {\n watcher.depend();\n }\n return watcher.value\n }\n}\n\nfunction initMethods (vm, methods) {\n for (var key in methods) {\n vm[key] = methods[key] == null ? noop : bind$1(methods[key], vm);\n if (false) {\n warn(\n \"method \\\"\" + key + \"\\\" has an undefined value in the component definition. \" +\n \"Did you reference the function correctly?\",\n vm\n );\n }\n }\n}\n\nfunction initWatch (vm, watch) {\n for (var key in watch) {\n var handler = watch[key];\n if (Array.isArray(handler)) {\n for (var i = 0; i < handler.length; i++) {\n createWatcher(vm, key, handler[i]);\n }\n } else {\n createWatcher(vm, key, handler);\n }\n }\n}\n\nfunction createWatcher (vm, key, handler) {\n var options;\n if (isPlainObject(handler)) {\n options = handler;\n handler = handler.handler;\n }\n if (typeof handler === 'string') {\n handler = vm[handler];\n }\n vm.$watch(key, handler, options);\n}\n\nfunction stateMixin (Vue) {\n // flow somehow has problems with directly declared definition object\n // when using Object.defineProperty, so we have to procedurally build up\n // the object here.\n var dataDef = {};\n dataDef.get = function () {\n return this._data\n };\n if (false) {\n dataDef.set = function (newData) {\n warn(\n 'Avoid replacing instance root $data. ' +\n 'Use nested data properties instead.',\n this\n );\n };\n }\n Object.defineProperty(Vue.prototype, '$data', dataDef);\n\n Vue.prototype.$set = set$1;\n Vue.prototype.$delete = del;\n\n Vue.prototype.$watch = function (\n expOrFn,\n cb,\n options\n ) {\n var vm = this;\n options = options || {};\n options.user = true;\n var watcher = new Watcher(vm, expOrFn, cb, options);\n if (options.immediate) {\n cb.call(vm, watcher.value);\n }\n return function unwatchFn () {\n watcher.teardown();\n }\n };\n}\n\nfunction proxy (vm, key) {\n if (!isReserved(key)) {\n Object.defineProperty(vm, key, {\n configurable: true,\n enumerable: true,\n get: function proxyGetter () {\n return vm._data[key]\n },\n set: function proxySetter (val) {\n vm._data[key] = val;\n }\n });\n }\n}\n\n/* */\n\nvar uid = 0;\n\nfunction initMixin (Vue) {\n Vue.prototype._init = function (options) {\n var vm = this;\n // a uid\n vm._uid = uid++;\n // a flag to avoid this being observed\n vm._isVue = true;\n // merge options\n if (options && options._isComponent) {\n // optimize internal component instantiation\n // since dynamic options merging is pretty slow, and none of the\n // internal component options needs special treatment.\n initInternalComponent(vm, options);\n } else {\n vm.$options = mergeOptions(\n resolveConstructorOptions(vm.constructor),\n options || {},\n vm\n );\n }\n /* istanbul ignore else */\n if (false) {\n initProxy(vm);\n } else {\n vm._renderProxy = vm;\n }\n // expose real self\n vm._self = vm;\n initLifecycle(vm);\n initEvents(vm);\n initRender(vm);\n callHook(vm, 'beforeCreate');\n initState(vm);\n callHook(vm, 'created');\n if (vm.$options.el) {\n vm.$mount(vm.$options.el);\n }\n };\n}\n\nfunction initInternalComponent (vm, options) {\n var opts = vm.$options = Object.create(vm.constructor.options);\n // doing this because it's faster than dynamic enumeration.\n opts.parent = options.parent;\n opts.propsData = options.propsData;\n opts._parentVnode = options._parentVnode;\n opts._parentListeners = options._parentListeners;\n opts._renderChildren = options._renderChildren;\n opts._componentTag = options._componentTag;\n opts._parentElm = options._parentElm;\n opts._refElm = options._refElm;\n if (options.render) {\n opts.render = options.render;\n opts.staticRenderFns = options.staticRenderFns;\n }\n}\n\nfunction resolveConstructorOptions (Ctor) {\n var options = Ctor.options;\n if (Ctor.super) {\n var superOptions = Ctor.super.options;\n var cachedSuperOptions = Ctor.superOptions;\n var extendOptions = Ctor.extendOptions;\n if (superOptions !== cachedSuperOptions) {\n // super option changed\n Ctor.superOptions = superOptions;\n extendOptions.render = options.render;\n extendOptions.staticRenderFns = options.staticRenderFns;\n extendOptions._scopeId = options._scopeId;\n options = Ctor.options = mergeOptions(superOptions, extendOptions);\n if (options.name) {\n options.components[options.name] = Ctor;\n }\n }\n }\n return options\n}\n\nfunction Vue$3 (options) {\n if (false) {\n warn('Vue is a constructor and should be called with the `new` keyword');\n }\n this._init(options);\n}\n\ninitMixin(Vue$3);\nstateMixin(Vue$3);\neventsMixin(Vue$3);\nlifecycleMixin(Vue$3);\nrenderMixin(Vue$3);\n\n/* */\n\nfunction initUse (Vue) {\n Vue.use = function (plugin) {\n /* istanbul ignore if */\n if (plugin.installed) {\n return\n }\n // additional parameters\n var args = toArray(arguments, 1);\n args.unshift(this);\n if (typeof plugin.install === 'function') {\n plugin.install.apply(plugin, args);\n } else {\n plugin.apply(null, args);\n }\n plugin.installed = true;\n return this\n };\n}\n\n/* */\n\nfunction initMixin$1 (Vue) {\n Vue.mixin = function (mixin) {\n this.options = mergeOptions(this.options, mixin);\n };\n}\n\n/* */\n\nfunction initExtend (Vue) {\n /**\n * Each instance constructor, including Vue, has a unique\n * cid. This enables us to create wrapped \"child\n * constructors\" for prototypal inheritance and cache them.\n */\n Vue.cid = 0;\n var cid = 1;\n\n /**\n * Class inheritance\n */\n Vue.extend = function (extendOptions) {\n extendOptions = extendOptions || {};\n var Super = this;\n var SuperId = Super.cid;\n var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});\n if (cachedCtors[SuperId]) {\n return cachedCtors[SuperId]\n }\n var name = extendOptions.name || Super.options.name;\n if (false) {\n if (!/^[a-zA-Z][\\w-]*$/.test(name)) {\n warn(\n 'Invalid component name: \"' + name + '\". Component names ' +\n 'can only contain alphanumeric characters and the hyphen, ' +\n 'and must start with a letter.'\n );\n }\n }\n var Sub = function VueComponent (options) {\n this._init(options);\n };\n Sub.prototype = Object.create(Super.prototype);\n Sub.prototype.constructor = Sub;\n Sub.cid = cid++;\n Sub.options = mergeOptions(\n Super.options,\n extendOptions\n );\n Sub['super'] = Super;\n // allow further extension/mixin/plugin usage\n Sub.extend = Super.extend;\n Sub.mixin = Super.mixin;\n Sub.use = Super.use;\n // create asset registers, so extended classes\n // can have their private assets too.\n config._assetTypes.forEach(function (type) {\n Sub[type] = Super[type];\n });\n // enable recursive self-lookup\n if (name) {\n Sub.options.components[name] = Sub;\n }\n // keep a reference to the super options at extension time.\n // later at instantiation we can check if Super's options have\n // been updated.\n Sub.superOptions = Super.options;\n Sub.extendOptions = extendOptions;\n // cache constructor\n cachedCtors[SuperId] = Sub;\n return Sub\n };\n}\n\n/* */\n\nfunction initAssetRegisters (Vue) {\n /**\n * Create asset registration methods.\n */\n config._assetTypes.forEach(function (type) {\n Vue[type] = function (\n id,\n definition\n ) {\n if (!definition) {\n return this.options[type + 's'][id]\n } else {\n /* istanbul ignore if */\n if (false) {\n if (type === 'component' && config.isReservedTag(id)) {\n warn(\n 'Do not use built-in or reserved HTML elements as component ' +\n 'id: ' + id\n );\n }\n }\n if (type === 'component' && isPlainObject(definition)) {\n definition.name = definition.name || id;\n definition = this.options._base.extend(definition);\n }\n if (type === 'directive' && typeof definition === 'function') {\n definition = { bind: definition, update: definition };\n }\n this.options[type + 's'][id] = definition;\n return definition\n }\n };\n });\n}\n\n/* */\n\nvar patternTypes = [String, RegExp];\n\nfunction getComponentName (opts) {\n return opts && (opts.Ctor.options.name || opts.tag)\n}\n\nfunction matches (pattern, name) {\n if (typeof pattern === 'string') {\n return pattern.split(',').indexOf(name) > -1\n } else {\n return pattern.test(name)\n }\n}\n\nfunction pruneCache (cache, filter) {\n for (var key in cache) {\n var cachedNode = cache[key];\n if (cachedNode) {\n var name = getComponentName(cachedNode.componentOptions);\n if (name && !filter(name)) {\n pruneCacheEntry(cachedNode);\n cache[key] = null;\n }\n }\n }\n}\n\nfunction pruneCacheEntry (vnode) {\n if (vnode) {\n if (!vnode.componentInstance._inactive) {\n callHook(vnode.componentInstance, 'deactivated');\n }\n vnode.componentInstance.$destroy();\n }\n}\n\nvar KeepAlive = {\n name: 'keep-alive',\n abstract: true,\n\n props: {\n include: patternTypes,\n exclude: patternTypes\n },\n\n created: function created () {\n this.cache = Object.create(null);\n },\n\n destroyed: function destroyed () {\n var this$1 = this;\n\n for (var key in this.cache) {\n pruneCacheEntry(this$1.cache[key]);\n }\n },\n\n watch: {\n include: function include (val) {\n pruneCache(this.cache, function (name) { return matches(val, name); });\n },\n exclude: function exclude (val) {\n pruneCache(this.cache, function (name) { return !matches(val, name); });\n }\n },\n\n render: function render () {\n var vnode = getFirstComponentChild(this.$slots.default);\n var componentOptions = vnode && vnode.componentOptions;\n if (componentOptions) {\n // check pattern\n var name = getComponentName(componentOptions);\n if (name && (\n (this.include && !matches(this.include, name)) ||\n (this.exclude && matches(this.exclude, name))\n )) {\n return vnode\n }\n var key = vnode.key == null\n // same constructor may get registered as different local components\n // so cid alone is not enough (#3269)\n ? componentOptions.Ctor.cid + (componentOptions.tag ? (\"::\" + (componentOptions.tag)) : '')\n : vnode.key;\n if (this.cache[key]) {\n vnode.componentInstance = this.cache[key].componentInstance;\n } else {\n this.cache[key] = vnode;\n }\n vnode.data.keepAlive = true;\n }\n return vnode\n }\n};\n\nvar builtInComponents = {\n KeepAlive: KeepAlive\n};\n\n/* */\n\nfunction initGlobalAPI (Vue) {\n // config\n var configDef = {};\n configDef.get = function () { return config; };\n if (false) {\n configDef.set = function () {\n warn(\n 'Do not replace the Vue.config object, set individual fields instead.'\n );\n };\n }\n Object.defineProperty(Vue, 'config', configDef);\n Vue.util = util;\n Vue.set = set$1;\n Vue.delete = del;\n Vue.nextTick = nextTick;\n\n Vue.options = Object.create(null);\n config._assetTypes.forEach(function (type) {\n Vue.options[type + 's'] = Object.create(null);\n });\n\n // this is used to identify the \"base\" constructor to extend all plain-object\n // components with in Weex's multi-instance scenarios.\n Vue.options._base = Vue;\n\n extend(Vue.options.components, builtInComponents);\n\n initUse(Vue);\n initMixin$1(Vue);\n initExtend(Vue);\n initAssetRegisters(Vue);\n}\n\ninitGlobalAPI(Vue$3);\n\nObject.defineProperty(Vue$3.prototype, '$isServer', {\n get: isServerRendering\n});\n\nVue$3.version = '2.1.10';\n\n/* */\n\n// attributes that should be using props for binding\nvar acceptValue = makeMap('input,textarea,option,select');\nvar mustUseProp = function (tag, type, attr) {\n return (\n (attr === 'value' && acceptValue(tag)) && type !== 'button' ||\n (attr === 'selected' && tag === 'option') ||\n (attr === 'checked' && tag === 'input') ||\n (attr === 'muted' && tag === 'video')\n )\n};\n\nvar isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');\n\nvar isBooleanAttr = makeMap(\n 'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +\n 'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +\n 'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +\n 'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +\n 'required,reversed,scoped,seamless,selected,sortable,translate,' +\n 'truespeed,typemustmatch,visible'\n);\n\nvar xlinkNS = 'http://www.w3.org/1999/xlink';\n\nvar isXlink = function (name) {\n return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'\n};\n\nvar getXlinkProp = function (name) {\n return isXlink(name) ? name.slice(6, name.length) : ''\n};\n\nvar isFalsyAttrValue = function (val) {\n return val == null || val === false\n};\n\n/* */\n\nfunction genClassForVnode (vnode) {\n var data = vnode.data;\n var parentNode = vnode;\n var childNode = vnode;\n while (childNode.componentInstance) {\n childNode = childNode.componentInstance._vnode;\n if (childNode.data) {\n data = mergeClassData(childNode.data, data);\n }\n }\n while ((parentNode = parentNode.parent)) {\n if (parentNode.data) {\n data = mergeClassData(data, parentNode.data);\n }\n }\n return genClassFromData(data)\n}\n\nfunction mergeClassData (child, parent) {\n return {\n staticClass: concat(child.staticClass, parent.staticClass),\n class: child.class\n ? [child.class, parent.class]\n : parent.class\n }\n}\n\nfunction genClassFromData (data) {\n var dynamicClass = data.class;\n var staticClass = data.staticClass;\n if (staticClass || dynamicClass) {\n return concat(staticClass, stringifyClass(dynamicClass))\n }\n /* istanbul ignore next */\n return ''\n}\n\nfunction concat (a, b) {\n return a ? b ? (a + ' ' + b) : a : (b || '')\n}\n\nfunction stringifyClass (value) {\n var res = '';\n if (!value) {\n return res\n }\n if (typeof value === 'string') {\n return value\n }\n if (Array.isArray(value)) {\n var stringified;\n for (var i = 0, l = value.length; i < l; i++) {\n if (value[i]) {\n if ((stringified = stringifyClass(value[i]))) {\n res += stringified + ' ';\n }\n }\n }\n return res.slice(0, -1)\n }\n if (isObject(value)) {\n for (var key in value) {\n if (value[key]) { res += key + ' '; }\n }\n return res.slice(0, -1)\n }\n /* istanbul ignore next */\n return res\n}\n\n/* */\n\nvar namespaceMap = {\n svg: 'http://www.w3.org/2000/svg',\n math: 'http://www.w3.org/1998/Math/MathML'\n};\n\nvar isHTMLTag = makeMap(\n 'html,body,base,head,link,meta,style,title,' +\n 'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +\n 'div,dd,dl,dt,figcaption,figure,hr,img,li,main,ol,p,pre,ul,' +\n 'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +\n 's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +\n 'embed,object,param,source,canvas,script,noscript,del,ins,' +\n 'caption,col,colgroup,table,thead,tbody,td,th,tr,' +\n 'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +\n 'output,progress,select,textarea,' +\n 'details,dialog,menu,menuitem,summary,' +\n 'content,element,shadow,template'\n);\n\n// this map is intentionally selective, only covering SVG elements that may\n// contain child elements.\nvar isSVG = makeMap(\n 'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,' +\n 'font-face,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +\n 'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',\n true\n);\n\nvar isPreTag = function (tag) { return tag === 'pre'; };\n\nvar isReservedTag = function (tag) {\n return isHTMLTag(tag) || isSVG(tag)\n};\n\nfunction getTagNamespace (tag) {\n if (isSVG(tag)) {\n return 'svg'\n }\n // basic support for MathML\n // note it doesn't support other MathML elements being component roots\n if (tag === 'math') {\n return 'math'\n }\n}\n\nvar unknownElementCache = Object.create(null);\nfunction isUnknownElement (tag) {\n /* istanbul ignore if */\n if (!inBrowser) {\n return true\n }\n if (isReservedTag(tag)) {\n return false\n }\n tag = tag.toLowerCase();\n /* istanbul ignore if */\n if (unknownElementCache[tag] != null) {\n return unknownElementCache[tag]\n }\n var el = document.createElement(tag);\n if (tag.indexOf('-') > -1) {\n // http://stackoverflow.com/a/28210364/1070244\n return (unknownElementCache[tag] = (\n el.constructor === window.HTMLUnknownElement ||\n el.constructor === window.HTMLElement\n ))\n } else {\n return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))\n }\n}\n\n/* */\n\n/**\n * Query an element selector if it's not an element already.\n */\nfunction query (el) {\n if (typeof el === 'string') {\n var selector = el;\n el = document.querySelector(el);\n if (!el) {\n \"production\" !== 'production' && warn(\n 'Cannot find element: ' + selector\n );\n return document.createElement('div')\n }\n }\n return el\n}\n\n/* */\n\nfunction createElement$1 (tagName, vnode) {\n var elm = document.createElement(tagName);\n if (tagName !== 'select') {\n return elm\n }\n if (vnode.data && vnode.data.attrs && 'multiple' in vnode.data.attrs) {\n elm.setAttribute('multiple', 'multiple');\n }\n return elm\n}\n\nfunction createElementNS (namespace, tagName) {\n return document.createElementNS(namespaceMap[namespace], tagName)\n}\n\nfunction createTextNode (text) {\n return document.createTextNode(text)\n}\n\nfunction createComment (text) {\n return document.createComment(text)\n}\n\nfunction insertBefore (parentNode, newNode, referenceNode) {\n parentNode.insertBefore(newNode, referenceNode);\n}\n\nfunction removeChild (node, child) {\n node.removeChild(child);\n}\n\nfunction appendChild (node, child) {\n node.appendChild(child);\n}\n\nfunction parentNode (node) {\n return node.parentNode\n}\n\nfunction nextSibling (node) {\n return node.nextSibling\n}\n\nfunction tagName (node) {\n return node.tagName\n}\n\nfunction setTextContent (node, text) {\n node.textContent = text;\n}\n\nfunction setAttribute (node, key, val) {\n node.setAttribute(key, val);\n}\n\n\nvar nodeOps = Object.freeze({\n\tcreateElement: createElement$1,\n\tcreateElementNS: createElementNS,\n\tcreateTextNode: createTextNode,\n\tcreateComment: createComment,\n\tinsertBefore: insertBefore,\n\tremoveChild: removeChild,\n\tappendChild: appendChild,\n\tparentNode: parentNode,\n\tnextSibling: nextSibling,\n\ttagName: tagName,\n\tsetTextContent: setTextContent,\n\tsetAttribute: setAttribute\n});\n\n/* */\n\nvar ref = {\n create: function create (_, vnode) {\n registerRef(vnode);\n },\n update: function update (oldVnode, vnode) {\n if (oldVnode.data.ref !== vnode.data.ref) {\n registerRef(oldVnode, true);\n registerRef(vnode);\n }\n },\n destroy: function destroy (vnode) {\n registerRef(vnode, true);\n }\n};\n\nfunction registerRef (vnode, isRemoval) {\n var key = vnode.data.ref;\n if (!key) { return }\n\n var vm = vnode.context;\n var ref = vnode.componentInstance || vnode.elm;\n var refs = vm.$refs;\n if (isRemoval) {\n if (Array.isArray(refs[key])) {\n remove$1(refs[key], ref);\n } else if (refs[key] === ref) {\n refs[key] = undefined;\n }\n } else {\n if (vnode.data.refInFor) {\n if (Array.isArray(refs[key]) && refs[key].indexOf(ref) < 0) {\n refs[key].push(ref);\n } else {\n refs[key] = [ref];\n }\n } else {\n refs[key] = ref;\n }\n }\n}\n\n/**\n * Virtual DOM patching algorithm based on Snabbdom by\n * Simon Friis Vindum (@paldepind)\n * Licensed under the MIT License\n * https://github.com/paldepind/snabbdom/blob/master/LICENSE\n *\n * modified by Evan You (@yyx990803)\n *\n\n/*\n * Not type-checking this because this file is perf-critical and the cost\n * of making flow understand it is not worth it.\n */\n\nvar emptyNode = new VNode('', {}, []);\n\nvar hooks$1 = ['create', 'activate', 'update', 'remove', 'destroy'];\n\nfunction isUndef (s) {\n return s == null\n}\n\nfunction isDef (s) {\n return s != null\n}\n\nfunction sameVnode (vnode1, vnode2) {\n return (\n vnode1.key === vnode2.key &&\n vnode1.tag === vnode2.tag &&\n vnode1.isComment === vnode2.isComment &&\n !vnode1.data === !vnode2.data\n )\n}\n\nfunction createKeyToOldIdx (children, beginIdx, endIdx) {\n var i, key;\n var map = {};\n for (i = beginIdx; i <= endIdx; ++i) {\n key = children[i].key;\n if (isDef(key)) { map[key] = i; }\n }\n return map\n}\n\nfunction createPatchFunction (backend) {\n var i, j;\n var cbs = {};\n\n var modules = backend.modules;\n var nodeOps = backend.nodeOps;\n\n for (i = 0; i < hooks$1.length; ++i) {\n cbs[hooks$1[i]] = [];\n for (j = 0; j < modules.length; ++j) {\n if (modules[j][hooks$1[i]] !== undefined) { cbs[hooks$1[i]].push(modules[j][hooks$1[i]]); }\n }\n }\n\n function emptyNodeAt (elm) {\n return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)\n }\n\n function createRmCb (childElm, listeners) {\n function remove$$1 () {\n if (--remove$$1.listeners === 0) {\n removeNode(childElm);\n }\n }\n remove$$1.listeners = listeners;\n return remove$$1\n }\n\n function removeNode (el) {\n var parent = nodeOps.parentNode(el);\n // element may have already been removed due to v-html / v-text\n if (parent) {\n nodeOps.removeChild(parent, el);\n }\n }\n\n var inPre = 0;\n function createElm (vnode, insertedVnodeQueue, parentElm, refElm, nested) {\n vnode.isRootInsert = !nested; // for transition enter check\n if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {\n return\n }\n\n var data = vnode.data;\n var children = vnode.children;\n var tag = vnode.tag;\n if (isDef(tag)) {\n if (false) {\n if (data && data.pre) {\n inPre++;\n }\n if (\n !inPre &&\n !vnode.ns &&\n !(config.ignoredElements.length && config.ignoredElements.indexOf(tag) > -1) &&\n config.isUnknownElement(tag)\n ) {\n warn(\n 'Unknown custom element: <' + tag + '> - did you ' +\n 'register the component correctly? For recursive components, ' +\n 'make sure to provide the \"name\" option.',\n vnode.context\n );\n }\n }\n vnode.elm = vnode.ns\n ? nodeOps.createElementNS(vnode.ns, tag)\n : nodeOps.createElement(tag, vnode);\n setScope(vnode);\n\n /* istanbul ignore if */\n {\n createChildren(vnode, children, insertedVnodeQueue);\n if (isDef(data)) {\n invokeCreateHooks(vnode, insertedVnodeQueue);\n }\n insert(parentElm, vnode.elm, refElm);\n }\n\n if (false) {\n inPre--;\n }\n } else if (vnode.isComment) {\n vnode.elm = nodeOps.createComment(vnode.text);\n insert(parentElm, vnode.elm, refElm);\n } else {\n vnode.elm = nodeOps.createTextNode(vnode.text);\n insert(parentElm, vnode.elm, refElm);\n }\n }\n\n function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {\n var i = vnode.data;\n if (isDef(i)) {\n var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;\n if (isDef(i = i.hook) && isDef(i = i.init)) {\n i(vnode, false /* hydrating */, parentElm, refElm);\n }\n // after calling the init hook, if the vnode is a child component\n // it should've created a child instance and mounted it. the child\n // component also has set the placeholder vnode's elm.\n // in that case we can just return the element and be done.\n if (isDef(vnode.componentInstance)) {\n initComponent(vnode, insertedVnodeQueue);\n if (isReactivated) {\n reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);\n }\n return true\n }\n }\n }\n\n function initComponent (vnode, insertedVnodeQueue) {\n if (vnode.data.pendingInsert) {\n insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);\n }\n vnode.elm = vnode.componentInstance.$el;\n if (isPatchable(vnode)) {\n invokeCreateHooks(vnode, insertedVnodeQueue);\n setScope(vnode);\n } else {\n // empty component root.\n // skip all element-related modules except for ref (#3455)\n registerRef(vnode);\n // make sure to invoke the insert hook\n insertedVnodeQueue.push(vnode);\n }\n }\n\n function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {\n var i;\n // hack for #4339: a reactivated component with inner transition\n // does not trigger because the inner node's created hooks are not called\n // again. It's not ideal to involve module-specific logic in here but\n // there doesn't seem to be a better way to do it.\n var innerNode = vnode;\n while (innerNode.componentInstance) {\n innerNode = innerNode.componentInstance._vnode;\n if (isDef(i = innerNode.data) && isDef(i = i.transition)) {\n for (i = 0; i < cbs.activate.length; ++i) {\n cbs.activate[i](emptyNode, innerNode);\n }\n insertedVnodeQueue.push(innerNode);\n break\n }\n }\n // unlike a newly created component,\n // a reactivated keep-alive component doesn't insert itself\n insert(parentElm, vnode.elm, refElm);\n }\n\n function insert (parent, elm, ref) {\n if (parent) {\n if (ref) {\n nodeOps.insertBefore(parent, elm, ref);\n } else {\n nodeOps.appendChild(parent, elm);\n }\n }\n }\n\n function createChildren (vnode, children, insertedVnodeQueue) {\n if (Array.isArray(children)) {\n for (var i = 0; i < children.length; ++i) {\n createElm(children[i], insertedVnodeQueue, vnode.elm, null, true);\n }\n } else if (isPrimitive(vnode.text)) {\n nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(vnode.text));\n }\n }\n\n function isPatchable (vnode) {\n while (vnode.componentInstance) {\n vnode = vnode.componentInstance._vnode;\n }\n return isDef(vnode.tag)\n }\n\n function invokeCreateHooks (vnode, insertedVnodeQueue) {\n for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {\n cbs.create[i$1](emptyNode, vnode);\n }\n i = vnode.data.hook; // Reuse variable\n if (isDef(i)) {\n if (i.create) { i.create(emptyNode, vnode); }\n if (i.insert) { insertedVnodeQueue.push(vnode); }\n }\n }\n\n // set scope id attribute for scoped CSS.\n // this is implemented as a special case to avoid the overhead\n // of going through the normal attribute patching process.\n function setScope (vnode) {\n var i;\n if (isDef(i = vnode.context) && isDef(i = i.$options._scopeId)) {\n nodeOps.setAttribute(vnode.elm, i, '');\n }\n if (isDef(i = activeInstance) &&\n i !== vnode.context &&\n isDef(i = i.$options._scopeId)) {\n nodeOps.setAttribute(vnode.elm, i, '');\n }\n }\n\n function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {\n for (; startIdx <= endIdx; ++startIdx) {\n createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm);\n }\n }\n\n function invokeDestroyHook (vnode) {\n var i, j;\n var data = vnode.data;\n if (isDef(data)) {\n if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }\n for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); }\n }\n if (isDef(i = vnode.children)) {\n for (j = 0; j < vnode.children.length; ++j) {\n invokeDestroyHook(vnode.children[j]);\n }\n }\n }\n\n function removeVnodes (parentElm, vnodes, startIdx, endIdx) {\n for (; startIdx <= endIdx; ++startIdx) {\n var ch = vnodes[startIdx];\n if (isDef(ch)) {\n if (isDef(ch.tag)) {\n removeAndInvokeRemoveHook(ch);\n invokeDestroyHook(ch);\n } else { // Text node\n removeNode(ch.elm);\n }\n }\n }\n }\n\n function removeAndInvokeRemoveHook (vnode, rm) {\n if (rm || isDef(vnode.data)) {\n var listeners = cbs.remove.length + 1;\n if (!rm) {\n // directly removing\n rm = createRmCb(vnode.elm, listeners);\n } else {\n // we have a recursively passed down rm callback\n // increase the listeners count\n rm.listeners += listeners;\n }\n // recursively invoke hooks on child component root node\n if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {\n removeAndInvokeRemoveHook(i, rm);\n }\n for (i = 0; i < cbs.remove.length; ++i) {\n cbs.remove[i](vnode, rm);\n }\n if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {\n i(vnode, rm);\n } else {\n rm();\n }\n } else {\n removeNode(vnode.elm);\n }\n }\n\n function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {\n var oldStartIdx = 0;\n var newStartIdx = 0;\n var oldEndIdx = oldCh.length - 1;\n var oldStartVnode = oldCh[0];\n var oldEndVnode = oldCh[oldEndIdx];\n var newEndIdx = newCh.length - 1;\n var newStartVnode = newCh[0];\n var newEndVnode = newCh[newEndIdx];\n var oldKeyToIdx, idxInOld, elmToMove, refElm;\n\n // removeOnly is a special flag used only by <transition-group>\n // to ensure removed elements stay in correct relative positions\n // during leaving transitions\n var canMove = !removeOnly;\n\n while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n if (isUndef(oldStartVnode)) {\n oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n } else if (isUndef(oldEndVnode)) {\n oldEndVnode = oldCh[--oldEndIdx];\n } else if (sameVnode(oldStartVnode, newStartVnode)) {\n patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);\n oldStartVnode = oldCh[++oldStartIdx];\n newStartVnode = newCh[++newStartIdx];\n } else if (sameVnode(oldEndVnode, newEndVnode)) {\n patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);\n oldEndVnode = oldCh[--oldEndIdx];\n newEndVnode = newCh[--newEndIdx];\n } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);\n canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));\n oldStartVnode = oldCh[++oldStartIdx];\n newEndVnode = newCh[--newEndIdx];\n } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);\n canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);\n oldEndVnode = oldCh[--oldEndIdx];\n newStartVnode = newCh[++newStartIdx];\n } else {\n if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }\n idxInOld = isDef(newStartVnode.key) ? oldKeyToIdx[newStartVnode.key] : null;\n if (isUndef(idxInOld)) { // New element\n createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);\n newStartVnode = newCh[++newStartIdx];\n } else {\n elmToMove = oldCh[idxInOld];\n /* istanbul ignore if */\n if (false) {\n warn(\n 'It seems there are duplicate keys that is causing an update error. ' +\n 'Make sure each v-for item has a unique key.'\n );\n }\n if (sameVnode(elmToMove, newStartVnode)) {\n patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);\n oldCh[idxInOld] = undefined;\n canMove && nodeOps.insertBefore(parentElm, newStartVnode.elm, oldStartVnode.elm);\n newStartVnode = newCh[++newStartIdx];\n } else {\n // same key but different element. treat as new element\n createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);\n newStartVnode = newCh[++newStartIdx];\n }\n }\n }\n }\n if (oldStartIdx > oldEndIdx) {\n refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;\n addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);\n } else if (newStartIdx > newEndIdx) {\n removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n }\n }\n\n function patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly) {\n if (oldVnode === vnode) {\n return\n }\n // reuse element for static trees.\n // note we only do this if the vnode is cloned -\n // if the new node is not cloned it means the render functions have been\n // reset by the hot-reload-api and we need to do a proper re-render.\n if (vnode.isStatic &&\n oldVnode.isStatic &&\n vnode.key === oldVnode.key &&\n (vnode.isCloned || vnode.isOnce)) {\n vnode.elm = oldVnode.elm;\n vnode.componentInstance = oldVnode.componentInstance;\n return\n }\n var i;\n var data = vnode.data;\n var hasData = isDef(data);\n if (hasData && isDef(i = data.hook) && isDef(i = i.prepatch)) {\n i(oldVnode, vnode);\n }\n var elm = vnode.elm = oldVnode.elm;\n var oldCh = oldVnode.children;\n var ch = vnode.children;\n if (hasData && isPatchable(vnode)) {\n for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); }\n if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }\n }\n if (isUndef(vnode.text)) {\n if (isDef(oldCh) && isDef(ch)) {\n if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }\n } else if (isDef(ch)) {\n if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }\n addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);\n } else if (isDef(oldCh)) {\n removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n } else if (isDef(oldVnode.text)) {\n nodeOps.setTextContent(elm, '');\n }\n } else if (oldVnode.text !== vnode.text) {\n nodeOps.setTextContent(elm, vnode.text);\n }\n if (hasData) {\n if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); }\n }\n }\n\n function invokeInsertHook (vnode, queue, initial) {\n // delay insert hooks for component root nodes, invoke them after the\n // element is really inserted\n if (initial && vnode.parent) {\n vnode.parent.data.pendingInsert = queue;\n } else {\n for (var i = 0; i < queue.length; ++i) {\n queue[i].data.hook.insert(queue[i]);\n }\n }\n }\n\n var bailed = false;\n // list of modules that can skip create hook during hydration because they\n // are already rendered on the client or has no need for initialization\n var isRenderedModule = makeMap('attrs,style,class,staticClass,staticStyle,key');\n\n // Note: this is a browser-only function so we can assume elms are DOM nodes.\n function hydrate (elm, vnode, insertedVnodeQueue) {\n if (false) {\n if (!assertNodeMatch(elm, vnode)) {\n return false\n }\n }\n vnode.elm = elm;\n var tag = vnode.tag;\n var data = vnode.data;\n var children = vnode.children;\n if (isDef(data)) {\n if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }\n if (isDef(i = vnode.componentInstance)) {\n // child component. it should have hydrated its own tree.\n initComponent(vnode, insertedVnodeQueue);\n return true\n }\n }\n if (isDef(tag)) {\n if (isDef(children)) {\n // empty element, allow client to pick up and populate children\n if (!elm.hasChildNodes()) {\n createChildren(vnode, children, insertedVnodeQueue);\n } else {\n var childrenMatch = true;\n var childNode = elm.firstChild;\n for (var i$1 = 0; i$1 < children.length; i$1++) {\n if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue)) {\n childrenMatch = false;\n break\n }\n childNode = childNode.nextSibling;\n }\n // if childNode is not null, it means the actual childNodes list is\n // longer than the virtual children list.\n if (!childrenMatch || childNode) {\n if (false) {\n bailed = true;\n console.warn('Parent: ', elm);\n console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);\n }\n return false\n }\n }\n }\n if (isDef(data)) {\n for (var key in data) {\n if (!isRenderedModule(key)) {\n invokeCreateHooks(vnode, insertedVnodeQueue);\n break\n }\n }\n }\n } else if (elm.data !== vnode.text) {\n elm.data = vnode.text;\n }\n return true\n }\n\n function assertNodeMatch (node, vnode) {\n if (vnode.tag) {\n return (\n vnode.tag.indexOf('vue-component') === 0 ||\n vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())\n )\n } else {\n return node.nodeType === (vnode.isComment ? 8 : 3)\n }\n }\n\n return function patch (oldVnode, vnode, hydrating, removeOnly, parentElm, refElm) {\n if (!vnode) {\n if (oldVnode) { invokeDestroyHook(oldVnode); }\n return\n }\n\n var isInitialPatch = false;\n var insertedVnodeQueue = [];\n\n if (!oldVnode) {\n // empty mount (likely as component), create new root element\n isInitialPatch = true;\n createElm(vnode, insertedVnodeQueue, parentElm, refElm);\n } else {\n var isRealElement = isDef(oldVnode.nodeType);\n if (!isRealElement && sameVnode(oldVnode, vnode)) {\n // patch existing root node\n patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly);\n } else {\n if (isRealElement) {\n // mounting to a real element\n // check if this is server-rendered content and if we can perform\n // a successful hydration.\n if (oldVnode.nodeType === 1 && oldVnode.hasAttribute('server-rendered')) {\n oldVnode.removeAttribute('server-rendered');\n hydrating = true;\n }\n if (hydrating) {\n if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {\n invokeInsertHook(vnode, insertedVnodeQueue, true);\n return oldVnode\n } else if (false) {\n warn(\n 'The client-side rendered virtual DOM tree is not matching ' +\n 'server-rendered content. This is likely caused by incorrect ' +\n 'HTML markup, for example nesting block-level elements inside ' +\n '<p>, or missing <tbody>. Bailing hydration and performing ' +\n 'full client-side render.'\n );\n }\n }\n // either not server-rendered, or hydration failed.\n // create an empty node and replace it\n oldVnode = emptyNodeAt(oldVnode);\n }\n // replacing existing element\n var oldElm = oldVnode.elm;\n var parentElm$1 = nodeOps.parentNode(oldElm);\n createElm(\n vnode,\n insertedVnodeQueue,\n // extremely rare edge case: do not insert if old element is in a\n // leaving transition. Only happens when combining transition +\n // keep-alive + HOCs. (#4590)\n oldElm._leaveCb ? null : parentElm$1,\n nodeOps.nextSibling(oldElm)\n );\n\n if (vnode.parent) {\n // component root element replaced.\n // update parent placeholder node element, recursively\n var ancestor = vnode.parent;\n while (ancestor) {\n ancestor.elm = vnode.elm;\n ancestor = ancestor.parent;\n }\n if (isPatchable(vnode)) {\n for (var i = 0; i < cbs.create.length; ++i) {\n cbs.create[i](emptyNode, vnode.parent);\n }\n }\n }\n\n if (parentElm$1 !== null) {\n removeVnodes(parentElm$1, [oldVnode], 0, 0);\n } else if (isDef(oldVnode.tag)) {\n invokeDestroyHook(oldVnode);\n }\n }\n }\n\n invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);\n return vnode.elm\n }\n}\n\n/* */\n\nvar directives = {\n create: updateDirectives,\n update: updateDirectives,\n destroy: function unbindDirectives (vnode) {\n updateDirectives(vnode, emptyNode);\n }\n};\n\nfunction updateDirectives (oldVnode, vnode) {\n if (oldVnode.data.directives || vnode.data.directives) {\n _update(oldVnode, vnode);\n }\n}\n\nfunction _update (oldVnode, vnode) {\n var isCreate = oldVnode === emptyNode;\n var isDestroy = vnode === emptyNode;\n var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);\n var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);\n\n var dirsWithInsert = [];\n var dirsWithPostpatch = [];\n\n var key, oldDir, dir;\n for (key in newDirs) {\n oldDir = oldDirs[key];\n dir = newDirs[key];\n if (!oldDir) {\n // new directive, bind\n callHook$1(dir, 'bind', vnode, oldVnode);\n if (dir.def && dir.def.inserted) {\n dirsWithInsert.push(dir);\n }\n } else {\n // existing directive, update\n dir.oldValue = oldDir.value;\n callHook$1(dir, 'update', vnode, oldVnode);\n if (dir.def && dir.def.componentUpdated) {\n dirsWithPostpatch.push(dir);\n }\n }\n }\n\n if (dirsWithInsert.length) {\n var callInsert = function () {\n for (var i = 0; i < dirsWithInsert.length; i++) {\n callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);\n }\n };\n if (isCreate) {\n mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', callInsert, 'dir-insert');\n } else {\n callInsert();\n }\n }\n\n if (dirsWithPostpatch.length) {\n mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'postpatch', function () {\n for (var i = 0; i < dirsWithPostpatch.length; i++) {\n callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);\n }\n }, 'dir-postpatch');\n }\n\n if (!isCreate) {\n for (key in oldDirs) {\n if (!newDirs[key]) {\n // no longer present, unbind\n callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);\n }\n }\n }\n}\n\nvar emptyModifiers = Object.create(null);\n\nfunction normalizeDirectives$1 (\n dirs,\n vm\n) {\n var res = Object.create(null);\n if (!dirs) {\n return res\n }\n var i, dir;\n for (i = 0; i < dirs.length; i++) {\n dir = dirs[i];\n if (!dir.modifiers) {\n dir.modifiers = emptyModifiers;\n }\n res[getRawDirName(dir)] = dir;\n dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);\n }\n return res\n}\n\nfunction getRawDirName (dir) {\n return dir.rawName || ((dir.name) + \".\" + (Object.keys(dir.modifiers || {}).join('.')))\n}\n\nfunction callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {\n var fn = dir.def && dir.def[hook];\n if (fn) {\n fn(vnode.elm, dir, vnode, oldVnode, isDestroy);\n }\n}\n\nvar baseModules = [\n ref,\n directives\n];\n\n/* */\n\nfunction updateAttrs (oldVnode, vnode) {\n if (!oldVnode.data.attrs && !vnode.data.attrs) {\n return\n }\n var key, cur, old;\n var elm = vnode.elm;\n var oldAttrs = oldVnode.data.attrs || {};\n var attrs = vnode.data.attrs || {};\n // clone observed objects, as the user probably wants to mutate it\n if (attrs.__ob__) {\n attrs = vnode.data.attrs = extend({}, attrs);\n }\n\n for (key in attrs) {\n cur = attrs[key];\n old = oldAttrs[key];\n if (old !== cur) {\n setAttr(elm, key, cur);\n }\n }\n // #4391: in IE9, setting type can reset value for input[type=radio]\n /* istanbul ignore if */\n if (isIE9 && attrs.value !== oldAttrs.value) {\n setAttr(elm, 'value', attrs.value);\n }\n for (key in oldAttrs) {\n if (attrs[key] == null) {\n if (isXlink(key)) {\n elm.removeAttributeNS(xlinkNS, getXlinkProp(key));\n } else if (!isEnumeratedAttr(key)) {\n elm.removeAttribute(key);\n }\n }\n }\n}\n\nfunction setAttr (el, key, value) {\n if (isBooleanAttr(key)) {\n // set attribute for blank value\n // e.g. <option disabled>Select one</option>\n if (isFalsyAttrValue(value)) {\n el.removeAttribute(key);\n } else {\n el.setAttribute(key, key);\n }\n } else if (isEnumeratedAttr(key)) {\n el.setAttribute(key, isFalsyAttrValue(value) || value === 'false' ? 'false' : 'true');\n } else if (isXlink(key)) {\n if (isFalsyAttrValue(value)) {\n el.removeAttributeNS(xlinkNS, getXlinkProp(key));\n } else {\n el.setAttributeNS(xlinkNS, key, value);\n }\n } else {\n if (isFalsyAttrValue(value)) {\n el.removeAttribute(key);\n } else {\n el.setAttribute(key, value);\n }\n }\n}\n\nvar attrs = {\n create: updateAttrs,\n update: updateAttrs\n};\n\n/* */\n\nfunction updateClass (oldVnode, vnode) {\n var el = vnode.elm;\n var data = vnode.data;\n var oldData = oldVnode.data;\n if (!data.staticClass && !data.class &&\n (!oldData || (!oldData.staticClass && !oldData.class))) {\n return\n }\n\n var cls = genClassForVnode(vnode);\n\n // handle transition classes\n var transitionClass = el._transitionClasses;\n if (transitionClass) {\n cls = concat(cls, stringifyClass(transitionClass));\n }\n\n // set the class\n if (cls !== el._prevClass) {\n el.setAttribute('class', cls);\n el._prevClass = cls;\n }\n}\n\nvar klass = {\n create: updateClass,\n update: updateClass\n};\n\n/* */\n\nvar target$1;\n\nfunction add$2 (\n event,\n handler,\n once,\n capture\n) {\n if (once) {\n var oldHandler = handler;\n var _target = target$1; // save current target element in closure\n handler = function (ev) {\n remove$3(event, handler, capture, _target);\n arguments.length === 1\n ? oldHandler(ev)\n : oldHandler.apply(null, arguments);\n };\n }\n target$1.addEventListener(event, handler, capture);\n}\n\nfunction remove$3 (\n event,\n handler,\n capture,\n _target\n) {\n (_target || target$1).removeEventListener(event, handler, capture);\n}\n\nfunction updateDOMListeners (oldVnode, vnode) {\n if (!oldVnode.data.on && !vnode.data.on) {\n return\n }\n var on = vnode.data.on || {};\n var oldOn = oldVnode.data.on || {};\n target$1 = vnode.elm;\n updateListeners(on, oldOn, add$2, remove$3, vnode.context);\n}\n\nvar events = {\n create: updateDOMListeners,\n update: updateDOMListeners\n};\n\n/* */\n\nfunction updateDOMProps (oldVnode, vnode) {\n if (!oldVnode.data.domProps && !vnode.data.domProps) {\n return\n }\n var key, cur;\n var elm = vnode.elm;\n var oldProps = oldVnode.data.domProps || {};\n var props = vnode.data.domProps || {};\n // clone observed objects, as the user probably wants to mutate it\n if (props.__ob__) {\n props = vnode.data.domProps = extend({}, props);\n }\n\n for (key in oldProps) {\n if (props[key] == null) {\n elm[key] = '';\n }\n }\n for (key in props) {\n cur = props[key];\n // ignore children if the node has textContent or innerHTML,\n // as these will throw away existing DOM nodes and cause removal errors\n // on subsequent patches (#3360)\n if (key === 'textContent' || key === 'innerHTML') {\n if (vnode.children) { vnode.children.length = 0; }\n if (cur === oldProps[key]) { continue }\n }\n\n if (key === 'value') {\n // store value as _value as well since\n // non-string values will be stringified\n elm._value = cur;\n // avoid resetting cursor position when value is the same\n var strCur = cur == null ? '' : String(cur);\n if (shouldUpdateValue(elm, vnode, strCur)) {\n elm.value = strCur;\n }\n } else {\n elm[key] = cur;\n }\n }\n}\n\n// check platforms/web/util/attrs.js acceptValue\n\n\nfunction shouldUpdateValue (\n elm,\n vnode,\n checkVal\n) {\n return (!elm.composing && (\n vnode.tag === 'option' ||\n isDirty(elm, checkVal) ||\n isInputChanged(vnode, checkVal)\n ))\n}\n\nfunction isDirty (elm, checkVal) {\n // return true when textbox (.number and .trim) loses focus and its value is not equal to the updated value\n return document.activeElement !== elm && elm.value !== checkVal\n}\n\nfunction isInputChanged (vnode, newVal) {\n var value = vnode.elm.value;\n var modifiers = vnode.elm._vModifiers; // injected by v-model runtime\n if ((modifiers && modifiers.number) || vnode.elm.type === 'number') {\n return toNumber(value) !== toNumber(newVal)\n }\n if (modifiers && modifiers.trim) {\n return value.trim() !== newVal.trim()\n }\n return value !== newVal\n}\n\nvar domProps = {\n create: updateDOMProps,\n update: updateDOMProps\n};\n\n/* */\n\nvar parseStyleText = cached(function (cssText) {\n var res = {};\n var listDelimiter = /;(?![^(]*\\))/g;\n var propertyDelimiter = /:(.+)/;\n cssText.split(listDelimiter).forEach(function (item) {\n if (item) {\n var tmp = item.split(propertyDelimiter);\n tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());\n }\n });\n return res\n});\n\n// merge static and dynamic style data on the same vnode\nfunction normalizeStyleData (data) {\n var style = normalizeStyleBinding(data.style);\n // static style is pre-processed into an object during compilation\n // and is always a fresh object, so it's safe to merge into it\n return data.staticStyle\n ? extend(data.staticStyle, style)\n : style\n}\n\n// normalize possible array / string values into Object\nfunction normalizeStyleBinding (bindingStyle) {\n if (Array.isArray(bindingStyle)) {\n return toObject(bindingStyle)\n }\n if (typeof bindingStyle === 'string') {\n return parseStyleText(bindingStyle)\n }\n return bindingStyle\n}\n\n/**\n * parent component style should be after child's\n * so that parent component's style could override it\n */\nfunction getStyle (vnode, checkChild) {\n var res = {};\n var styleData;\n\n if (checkChild) {\n var childNode = vnode;\n while (childNode.componentInstance) {\n childNode = childNode.componentInstance._vnode;\n if (childNode.data && (styleData = normalizeStyleData(childNode.data))) {\n extend(res, styleData);\n }\n }\n }\n\n if ((styleData = normalizeStyleData(vnode.data))) {\n extend(res, styleData);\n }\n\n var parentNode = vnode;\n while ((parentNode = parentNode.parent)) {\n if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {\n extend(res, styleData);\n }\n }\n return res\n}\n\n/* */\n\nvar cssVarRE = /^--/;\nvar importantRE = /\\s*!important$/;\nvar setProp = function (el, name, val) {\n /* istanbul ignore if */\n if (cssVarRE.test(name)) {\n el.style.setProperty(name, val);\n } else if (importantRE.test(val)) {\n el.style.setProperty(name, val.replace(importantRE, ''), 'important');\n } else {\n el.style[normalize(name)] = val;\n }\n};\n\nvar prefixes = ['Webkit', 'Moz', 'ms'];\n\nvar testEl;\nvar normalize = cached(function (prop) {\n testEl = testEl || document.createElement('div');\n prop = camelize(prop);\n if (prop !== 'filter' && (prop in testEl.style)) {\n return prop\n }\n var upper = prop.charAt(0).toUpperCase() + prop.slice(1);\n for (var i = 0; i < prefixes.length; i++) {\n var prefixed = prefixes[i] + upper;\n if (prefixed in testEl.style) {\n return prefixed\n }\n }\n});\n\nfunction updateStyle (oldVnode, vnode) {\n var data = vnode.data;\n var oldData = oldVnode.data;\n\n if (!data.staticStyle && !data.style &&\n !oldData.staticStyle && !oldData.style) {\n return\n }\n\n var cur, name;\n var el = vnode.elm;\n var oldStaticStyle = oldVnode.data.staticStyle;\n var oldStyleBinding = oldVnode.data.style || {};\n\n // if static style exists, stylebinding already merged into it when doing normalizeStyleData\n var oldStyle = oldStaticStyle || oldStyleBinding;\n\n var style = normalizeStyleBinding(vnode.data.style) || {};\n\n vnode.data.style = style.__ob__ ? extend({}, style) : style;\n\n var newStyle = getStyle(vnode, true);\n\n for (name in oldStyle) {\n if (newStyle[name] == null) {\n setProp(el, name, '');\n }\n }\n for (name in newStyle) {\n cur = newStyle[name];\n if (cur !== oldStyle[name]) {\n // ie9 setting to null has no effect, must use empty string\n setProp(el, name, cur == null ? '' : cur);\n }\n }\n}\n\nvar style = {\n create: updateStyle,\n update: updateStyle\n};\n\n/* */\n\n/**\n * Add class with compatibility for SVG since classList is not supported on\n * SVG elements in IE\n */\nfunction addClass (el, cls) {\n /* istanbul ignore if */\n if (!cls || !cls.trim()) {\n return\n }\n\n /* istanbul ignore else */\n if (el.classList) {\n if (cls.indexOf(' ') > -1) {\n cls.split(/\\s+/).forEach(function (c) { return el.classList.add(c); });\n } else {\n el.classList.add(cls);\n }\n } else {\n var cur = ' ' + el.getAttribute('class') + ' ';\n if (cur.indexOf(' ' + cls + ' ') < 0) {\n el.setAttribute('class', (cur + cls).trim());\n }\n }\n}\n\n/**\n * Remove class with compatibility for SVG since classList is not supported on\n * SVG elements in IE\n */\nfunction removeClass (el, cls) {\n /* istanbul ignore if */\n if (!cls || !cls.trim()) {\n return\n }\n\n /* istanbul ignore else */\n if (el.classList) {\n if (cls.indexOf(' ') > -1) {\n cls.split(/\\s+/).forEach(function (c) { return el.classList.remove(c); });\n } else {\n el.classList.remove(cls);\n }\n } else {\n var cur = ' ' + el.getAttribute('class') + ' ';\n var tar = ' ' + cls + ' ';\n while (cur.indexOf(tar) >= 0) {\n cur = cur.replace(tar, ' ');\n }\n el.setAttribute('class', cur.trim());\n }\n}\n\n/* */\n\nvar hasTransition = inBrowser && !isIE9;\nvar TRANSITION = 'transition';\nvar ANIMATION = 'animation';\n\n// Transition property/event sniffing\nvar transitionProp = 'transition';\nvar transitionEndEvent = 'transitionend';\nvar animationProp = 'animation';\nvar animationEndEvent = 'animationend';\nif (hasTransition) {\n /* istanbul ignore if */\n if (window.ontransitionend === undefined &&\n window.onwebkittransitionend !== undefined) {\n transitionProp = 'WebkitTransition';\n transitionEndEvent = 'webkitTransitionEnd';\n }\n if (window.onanimationend === undefined &&\n window.onwebkitanimationend !== undefined) {\n animationProp = 'WebkitAnimation';\n animationEndEvent = 'webkitAnimationEnd';\n }\n}\n\n// binding to window is necessary to make hot reload work in IE in strict mode\nvar raf = inBrowser && window.requestAnimationFrame\n ? window.requestAnimationFrame.bind(window)\n : setTimeout;\n\nfunction nextFrame (fn) {\n raf(function () {\n raf(fn);\n });\n}\n\nfunction addTransitionClass (el, cls) {\n (el._transitionClasses || (el._transitionClasses = [])).push(cls);\n addClass(el, cls);\n}\n\nfunction removeTransitionClass (el, cls) {\n if (el._transitionClasses) {\n remove$1(el._transitionClasses, cls);\n }\n removeClass(el, cls);\n}\n\nfunction whenTransitionEnds (\n el,\n expectedType,\n cb\n) {\n var ref = getTransitionInfo(el, expectedType);\n var type = ref.type;\n var timeout = ref.timeout;\n var propCount = ref.propCount;\n if (!type) { return cb() }\n var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;\n var ended = 0;\n var end = function () {\n el.removeEventListener(event, onEnd);\n cb();\n };\n var onEnd = function (e) {\n if (e.target === el) {\n if (++ended >= propCount) {\n end();\n }\n }\n };\n setTimeout(function () {\n if (ended < propCount) {\n end();\n }\n }, timeout + 1);\n el.addEventListener(event, onEnd);\n}\n\nvar transformRE = /\\b(transform|all)(,|$)/;\n\nfunction getTransitionInfo (el, expectedType) {\n var styles = window.getComputedStyle(el);\n var transitioneDelays = styles[transitionProp + 'Delay'].split(', ');\n var transitionDurations = styles[transitionProp + 'Duration'].split(', ');\n var transitionTimeout = getTimeout(transitioneDelays, transitionDurations);\n var animationDelays = styles[animationProp + 'Delay'].split(', ');\n var animationDurations = styles[animationProp + 'Duration'].split(', ');\n var animationTimeout = getTimeout(animationDelays, animationDurations);\n\n var type;\n var timeout = 0;\n var propCount = 0;\n /* istanbul ignore if */\n if (expectedType === TRANSITION) {\n if (transitionTimeout > 0) {\n type = TRANSITION;\n timeout = transitionTimeout;\n propCount = transitionDurations.length;\n }\n } else if (expectedType === ANIMATION) {\n if (animationTimeout > 0) {\n type = ANIMATION;\n timeout = animationTimeout;\n propCount = animationDurations.length;\n }\n } else {\n timeout = Math.max(transitionTimeout, animationTimeout);\n type = timeout > 0\n ? transitionTimeout > animationTimeout\n ? TRANSITION\n : ANIMATION\n : null;\n propCount = type\n ? type === TRANSITION\n ? transitionDurations.length\n : animationDurations.length\n : 0;\n }\n var hasTransform =\n type === TRANSITION &&\n transformRE.test(styles[transitionProp + 'Property']);\n return {\n type: type,\n timeout: timeout,\n propCount: propCount,\n hasTransform: hasTransform\n }\n}\n\nfunction getTimeout (delays, durations) {\n /* istanbul ignore next */\n while (delays.length < durations.length) {\n delays = delays.concat(delays);\n }\n\n return Math.max.apply(null, durations.map(function (d, i) {\n return toMs(d) + toMs(delays[i])\n }))\n}\n\nfunction toMs (s) {\n return Number(s.slice(0, -1)) * 1000\n}\n\n/* */\n\nfunction enter (vnode, toggleDisplay) {\n var el = vnode.elm;\n\n // call leave callback now\n if (el._leaveCb) {\n el._leaveCb.cancelled = true;\n el._leaveCb();\n }\n\n var data = resolveTransition(vnode.data.transition);\n if (!data) {\n return\n }\n\n /* istanbul ignore if */\n if (el._enterCb || el.nodeType !== 1) {\n return\n }\n\n var css = data.css;\n var type = data.type;\n var enterClass = data.enterClass;\n var enterToClass = data.enterToClass;\n var enterActiveClass = data.enterActiveClass;\n var appearClass = data.appearClass;\n var appearToClass = data.appearToClass;\n var appearActiveClass = data.appearActiveClass;\n var beforeEnter = data.beforeEnter;\n var enter = data.enter;\n var afterEnter = data.afterEnter;\n var enterCancelled = data.enterCancelled;\n var beforeAppear = data.beforeAppear;\n var appear = data.appear;\n var afterAppear = data.afterAppear;\n var appearCancelled = data.appearCancelled;\n\n // activeInstance will always be the <transition> component managing this\n // transition. One edge case to check is when the <transition> is placed\n // as the root node of a child component. In that case we need to check\n // <transition>'s parent for appear check.\n var context = activeInstance;\n var transitionNode = activeInstance.$vnode;\n while (transitionNode && transitionNode.parent) {\n transitionNode = transitionNode.parent;\n context = transitionNode.context;\n }\n\n var isAppear = !context._isMounted || !vnode.isRootInsert;\n\n if (isAppear && !appear && appear !== '') {\n return\n }\n\n var startClass = isAppear ? appearClass : enterClass;\n var activeClass = isAppear ? appearActiveClass : enterActiveClass;\n var toClass = isAppear ? appearToClass : enterToClass;\n var beforeEnterHook = isAppear ? (beforeAppear || beforeEnter) : beforeEnter;\n var enterHook = isAppear ? (typeof appear === 'function' ? appear : enter) : enter;\n var afterEnterHook = isAppear ? (afterAppear || afterEnter) : afterEnter;\n var enterCancelledHook = isAppear ? (appearCancelled || enterCancelled) : enterCancelled;\n\n var expectsCSS = css !== false && !isIE9;\n var userWantsControl =\n enterHook &&\n // enterHook may be a bound method which exposes\n // the length of original fn as _length\n (enterHook._length || enterHook.length) > 1;\n\n var cb = el._enterCb = once(function () {\n if (expectsCSS) {\n removeTransitionClass(el, toClass);\n removeTransitionClass(el, activeClass);\n }\n if (cb.cancelled) {\n if (expectsCSS) {\n removeTransitionClass(el, startClass);\n }\n enterCancelledHook && enterCancelledHook(el);\n } else {\n afterEnterHook && afterEnterHook(el);\n }\n el._enterCb = null;\n });\n\n if (!vnode.data.show) {\n // remove pending leave element on enter by injecting an insert hook\n mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', function () {\n var parent = el.parentNode;\n var pendingNode = parent && parent._pending && parent._pending[vnode.key];\n if (pendingNode &&\n pendingNode.tag === vnode.tag &&\n pendingNode.elm._leaveCb) {\n pendingNode.elm._leaveCb();\n }\n enterHook && enterHook(el, cb);\n }, 'transition-insert');\n }\n\n // start enter transition\n beforeEnterHook && beforeEnterHook(el);\n if (expectsCSS) {\n addTransitionClass(el, startClass);\n addTransitionClass(el, activeClass);\n nextFrame(function () {\n addTransitionClass(el, toClass);\n removeTransitionClass(el, startClass);\n if (!cb.cancelled && !userWantsControl) {\n whenTransitionEnds(el, type, cb);\n }\n });\n }\n\n if (vnode.data.show) {\n toggleDisplay && toggleDisplay();\n enterHook && enterHook(el, cb);\n }\n\n if (!expectsCSS && !userWantsControl) {\n cb();\n }\n}\n\nfunction leave (vnode, rm) {\n var el = vnode.elm;\n\n // call enter callback now\n if (el._enterCb) {\n el._enterCb.cancelled = true;\n el._enterCb();\n }\n\n var data = resolveTransition(vnode.data.transition);\n if (!data) {\n return rm()\n }\n\n /* istanbul ignore if */\n if (el._leaveCb || el.nodeType !== 1) {\n return\n }\n\n var css = data.css;\n var type = data.type;\n var leaveClass = data.leaveClass;\n var leaveToClass = data.leaveToClass;\n var leaveActiveClass = data.leaveActiveClass;\n var beforeLeave = data.beforeLeave;\n var leave = data.leave;\n var afterLeave = data.afterLeave;\n var leaveCancelled = data.leaveCancelled;\n var delayLeave = data.delayLeave;\n\n var expectsCSS = css !== false && !isIE9;\n var userWantsControl =\n leave &&\n // leave hook may be a bound method which exposes\n // the length of original fn as _length\n (leave._length || leave.length) > 1;\n\n var cb = el._leaveCb = once(function () {\n if (el.parentNode && el.parentNode._pending) {\n el.parentNode._pending[vnode.key] = null;\n }\n if (expectsCSS) {\n removeTransitionClass(el, leaveToClass);\n removeTransitionClass(el, leaveActiveClass);\n }\n if (cb.cancelled) {\n if (expectsCSS) {\n removeTransitionClass(el, leaveClass);\n }\n leaveCancelled && leaveCancelled(el);\n } else {\n rm();\n afterLeave && afterLeave(el);\n }\n el._leaveCb = null;\n });\n\n if (delayLeave) {\n delayLeave(performLeave);\n } else {\n performLeave();\n }\n\n function performLeave () {\n // the delayed leave may have already been cancelled\n if (cb.cancelled) {\n return\n }\n // record leaving element\n if (!vnode.data.show) {\n (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;\n }\n beforeLeave && beforeLeave(el);\n if (expectsCSS) {\n addTransitionClass(el, leaveClass);\n addTransitionClass(el, leaveActiveClass);\n nextFrame(function () {\n addTransitionClass(el, leaveToClass);\n removeTransitionClass(el, leaveClass);\n if (!cb.cancelled && !userWantsControl) {\n whenTransitionEnds(el, type, cb);\n }\n });\n }\n leave && leave(el, cb);\n if (!expectsCSS && !userWantsControl) {\n cb();\n }\n }\n}\n\nfunction resolveTransition (def$$1) {\n if (!def$$1) {\n return\n }\n /* istanbul ignore else */\n if (typeof def$$1 === 'object') {\n var res = {};\n if (def$$1.css !== false) {\n extend(res, autoCssTransition(def$$1.name || 'v'));\n }\n extend(res, def$$1);\n return res\n } else if (typeof def$$1 === 'string') {\n return autoCssTransition(def$$1)\n }\n}\n\nvar autoCssTransition = cached(function (name) {\n return {\n enterClass: (name + \"-enter\"),\n leaveClass: (name + \"-leave\"),\n appearClass: (name + \"-enter\"),\n enterToClass: (name + \"-enter-to\"),\n leaveToClass: (name + \"-leave-to\"),\n appearToClass: (name + \"-enter-to\"),\n enterActiveClass: (name + \"-enter-active\"),\n leaveActiveClass: (name + \"-leave-active\"),\n appearActiveClass: (name + \"-enter-active\")\n }\n});\n\nfunction once (fn) {\n var called = false;\n return function () {\n if (!called) {\n called = true;\n fn();\n }\n }\n}\n\nfunction _enter (_, vnode) {\n if (!vnode.data.show) {\n enter(vnode);\n }\n}\n\nvar transition = inBrowser ? {\n create: _enter,\n activate: _enter,\n remove: function remove (vnode, rm) {\n /* istanbul ignore else */\n if (!vnode.data.show) {\n leave(vnode, rm);\n } else {\n rm();\n }\n }\n} : {};\n\nvar platformModules = [\n attrs,\n klass,\n events,\n domProps,\n style,\n transition\n];\n\n/* */\n\n// the directive module should be applied last, after all\n// built-in modules have been applied.\nvar modules = platformModules.concat(baseModules);\n\nvar patch$1 = createPatchFunction({ nodeOps: nodeOps, modules: modules });\n\n/**\n * Not type checking this file because flow doesn't like attaching\n * properties to Elements.\n */\n\nvar modelableTagRE = /^input|select|textarea|vue-component-[0-9]+(-[0-9a-zA-Z_-]*)?$/;\n\n/* istanbul ignore if */\nif (isIE9) {\n // http://www.matts411.com/post/internet-explorer-9-oninput/\n document.addEventListener('selectionchange', function () {\n var el = document.activeElement;\n if (el && el.vmodel) {\n trigger(el, 'input');\n }\n });\n}\n\nvar model = {\n inserted: function inserted (el, binding, vnode) {\n if (false) {\n if (!modelableTagRE.test(vnode.tag)) {\n warn(\n \"v-model is not supported on element type: <\" + (vnode.tag) + \">. \" +\n 'If you are working with contenteditable, it\\'s recommended to ' +\n 'wrap a library dedicated for that purpose inside a custom component.',\n vnode.context\n );\n }\n }\n if (vnode.tag === 'select') {\n var cb = function () {\n setSelected(el, binding, vnode.context);\n };\n cb();\n /* istanbul ignore if */\n if (isIE || isEdge) {\n setTimeout(cb, 0);\n }\n } else if (vnode.tag === 'textarea' || el.type === 'text') {\n el._vModifiers = binding.modifiers;\n if (!binding.modifiers.lazy) {\n if (!isAndroid) {\n el.addEventListener('compositionstart', onCompositionStart);\n el.addEventListener('compositionend', onCompositionEnd);\n }\n /* istanbul ignore if */\n if (isIE9) {\n el.vmodel = true;\n }\n }\n }\n },\n componentUpdated: function componentUpdated (el, binding, vnode) {\n if (vnode.tag === 'select') {\n setSelected(el, binding, vnode.context);\n // in case the options rendered by v-for have changed,\n // it's possible that the value is out-of-sync with the rendered options.\n // detect such cases and filter out values that no longer has a matching\n // option in the DOM.\n var needReset = el.multiple\n ? binding.value.some(function (v) { return hasNoMatchingOption(v, el.options); })\n : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, el.options);\n if (needReset) {\n trigger(el, 'change');\n }\n }\n }\n};\n\nfunction setSelected (el, binding, vm) {\n var value = binding.value;\n var isMultiple = el.multiple;\n if (isMultiple && !Array.isArray(value)) {\n \"production\" !== 'production' && warn(\n \"<select multiple v-model=\\\"\" + (binding.expression) + \"\\\"> \" +\n \"expects an Array value for its binding, but got \" + (Object.prototype.toString.call(value).slice(8, -1)),\n vm\n );\n return\n }\n var selected, option;\n for (var i = 0, l = el.options.length; i < l; i++) {\n option = el.options[i];\n if (isMultiple) {\n selected = looseIndexOf(value, getValue(option)) > -1;\n if (option.selected !== selected) {\n option.selected = selected;\n }\n } else {\n if (looseEqual(getValue(option), value)) {\n if (el.selectedIndex !== i) {\n el.selectedIndex = i;\n }\n return\n }\n }\n }\n if (!isMultiple) {\n el.selectedIndex = -1;\n }\n}\n\nfunction hasNoMatchingOption (value, options) {\n for (var i = 0, l = options.length; i < l; i++) {\n if (looseEqual(getValue(options[i]), value)) {\n return false\n }\n }\n return true\n}\n\nfunction getValue (option) {\n return '_value' in option\n ? option._value\n : option.value\n}\n\nfunction onCompositionStart (e) {\n e.target.composing = true;\n}\n\nfunction onCompositionEnd (e) {\n e.target.composing = false;\n trigger(e.target, 'input');\n}\n\nfunction trigger (el, type) {\n var e = document.createEvent('HTMLEvents');\n e.initEvent(type, true, true);\n el.dispatchEvent(e);\n}\n\n/* */\n\n// recursively search for possible transition defined inside the component root\nfunction locateNode (vnode) {\n return vnode.componentInstance && (!vnode.data || !vnode.data.transition)\n ? locateNode(vnode.componentInstance._vnode)\n : vnode\n}\n\nvar show = {\n bind: function bind (el, ref, vnode) {\n var value = ref.value;\n\n vnode = locateNode(vnode);\n var transition = vnode.data && vnode.data.transition;\n var originalDisplay = el.__vOriginalDisplay =\n el.style.display === 'none' ? '' : el.style.display;\n if (value && transition && !isIE9) {\n vnode.data.show = true;\n enter(vnode, function () {\n el.style.display = originalDisplay;\n });\n } else {\n el.style.display = value ? originalDisplay : 'none';\n }\n },\n\n update: function update (el, ref, vnode) {\n var value = ref.value;\n var oldValue = ref.oldValue;\n\n /* istanbul ignore if */\n if (value === oldValue) { return }\n vnode = locateNode(vnode);\n var transition = vnode.data && vnode.data.transition;\n if (transition && !isIE9) {\n vnode.data.show = true;\n if (value) {\n enter(vnode, function () {\n el.style.display = el.__vOriginalDisplay;\n });\n } else {\n leave(vnode, function () {\n el.style.display = 'none';\n });\n }\n } else {\n el.style.display = value ? el.__vOriginalDisplay : 'none';\n }\n },\n\n unbind: function unbind (\n el,\n binding,\n vnode,\n oldVnode,\n isDestroy\n ) {\n if (!isDestroy) {\n el.style.display = el.__vOriginalDisplay;\n }\n }\n};\n\nvar platformDirectives = {\n model: model,\n show: show\n};\n\n/* */\n\n// Provides transition support for a single element/component.\n// supports transition mode (out-in / in-out)\n\nvar transitionProps = {\n name: String,\n appear: Boolean,\n css: Boolean,\n mode: String,\n type: String,\n enterClass: String,\n leaveClass: String,\n enterToClass: String,\n leaveToClass: String,\n enterActiveClass: String,\n leaveActiveClass: String,\n appearClass: String,\n appearActiveClass: String,\n appearToClass: String\n};\n\n// in case the child is also an abstract component, e.g. <keep-alive>\n// we want to recursively retrieve the real component to be rendered\nfunction getRealChild (vnode) {\n var compOptions = vnode && vnode.componentOptions;\n if (compOptions && compOptions.Ctor.options.abstract) {\n return getRealChild(getFirstComponentChild(compOptions.children))\n } else {\n return vnode\n }\n}\n\nfunction extractTransitionData (comp) {\n var data = {};\n var options = comp.$options;\n // props\n for (var key in options.propsData) {\n data[key] = comp[key];\n }\n // events.\n // extract listeners and pass them directly to the transition methods\n var listeners = options._parentListeners;\n for (var key$1 in listeners) {\n data[camelize(key$1)] = listeners[key$1].fn;\n }\n return data\n}\n\nfunction placeholder (h, rawChild) {\n return /\\d-keep-alive$/.test(rawChild.tag)\n ? h('keep-alive')\n : null\n}\n\nfunction hasParentTransition (vnode) {\n while ((vnode = vnode.parent)) {\n if (vnode.data.transition) {\n return true\n }\n }\n}\n\nfunction isSameChild (child, oldChild) {\n return oldChild.key === child.key && oldChild.tag === child.tag\n}\n\nvar Transition = {\n name: 'transition',\n props: transitionProps,\n abstract: true,\n\n render: function render (h) {\n var this$1 = this;\n\n var children = this.$slots.default;\n if (!children) {\n return\n }\n\n // filter out text nodes (possible whitespaces)\n children = children.filter(function (c) { return c.tag; });\n /* istanbul ignore if */\n if (!children.length) {\n return\n }\n\n // warn multiple elements\n if (false) {\n warn(\n '<transition> can only be used on a single element. Use ' +\n '<transition-group> for lists.',\n this.$parent\n );\n }\n\n var mode = this.mode;\n\n // warn invalid mode\n if (false) {\n warn(\n 'invalid <transition> mode: ' + mode,\n this.$parent\n );\n }\n\n var rawChild = children[0];\n\n // if this is a component root node and the component's\n // parent container node also has transition, skip.\n if (hasParentTransition(this.$vnode)) {\n return rawChild\n }\n\n // apply transition data to child\n // use getRealChild() to ignore abstract components e.g. keep-alive\n var child = getRealChild(rawChild);\n /* istanbul ignore if */\n if (!child) {\n return rawChild\n }\n\n if (this._leaving) {\n return placeholder(h, rawChild)\n }\n\n // ensure a key that is unique to the vnode type and to this transition\n // component instance. This key will be used to remove pending leaving nodes\n // during entering.\n var id = \"__transition-\" + (this._uid) + \"-\";\n var key = child.key = child.key == null\n ? id + child.tag\n : isPrimitive(child.key)\n ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)\n : child.key;\n var data = (child.data || (child.data = {})).transition = extractTransitionData(this);\n var oldRawChild = this._vnode;\n var oldChild = getRealChild(oldRawChild);\n\n // mark v-show\n // so that the transition module can hand over the control to the directive\n if (child.data.directives && child.data.directives.some(function (d) { return d.name === 'show'; })) {\n child.data.show = true;\n }\n\n if (oldChild && oldChild.data && !isSameChild(child, oldChild)) {\n // replace old child transition data with fresh one\n // important for dynamic transitions!\n var oldData = oldChild && (oldChild.data.transition = extend({}, data));\n // handle transition mode\n if (mode === 'out-in') {\n // return placeholder node and queue update when leave finishes\n this._leaving = true;\n mergeVNodeHook(oldData, 'afterLeave', function () {\n this$1._leaving = false;\n this$1.$forceUpdate();\n }, key);\n return placeholder(h, rawChild)\n } else if (mode === 'in-out') {\n var delayedLeave;\n var performLeave = function () { delayedLeave(); };\n mergeVNodeHook(data, 'afterEnter', performLeave, key);\n mergeVNodeHook(data, 'enterCancelled', performLeave, key);\n mergeVNodeHook(oldData, 'delayLeave', function (leave) {\n delayedLeave = leave;\n }, key);\n }\n }\n\n return rawChild\n }\n};\n\n/* */\n\n// Provides transition support for list items.\n// supports move transitions using the FLIP technique.\n\n// Because the vdom's children update algorithm is \"unstable\" - i.e.\n// it doesn't guarantee the relative positioning of removed elements,\n// we force transition-group to update its children into two passes:\n// in the first pass, we remove all nodes that need to be removed,\n// triggering their leaving transition; in the second pass, we insert/move\n// into the final disired state. This way in the second pass removed\n// nodes will remain where they should be.\n\nvar props = extend({\n tag: String,\n moveClass: String\n}, transitionProps);\n\ndelete props.mode;\n\nvar TransitionGroup = {\n props: props,\n\n render: function render (h) {\n var tag = this.tag || this.$vnode.data.tag || 'span';\n var map = Object.create(null);\n var prevChildren = this.prevChildren = this.children;\n var rawChildren = this.$slots.default || [];\n var children = this.children = [];\n var transitionData = extractTransitionData(this);\n\n for (var i = 0; i < rawChildren.length; i++) {\n var c = rawChildren[i];\n if (c.tag) {\n if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {\n children.push(c);\n map[c.key] = c\n ;(c.data || (c.data = {})).transition = transitionData;\n } else if (false) {\n var opts = c.componentOptions;\n var name = opts\n ? (opts.Ctor.options.name || opts.tag)\n : c.tag;\n warn((\"<transition-group> children must be keyed: <\" + name + \">\"));\n }\n }\n }\n\n if (prevChildren) {\n var kept = [];\n var removed = [];\n for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {\n var c$1 = prevChildren[i$1];\n c$1.data.transition = transitionData;\n c$1.data.pos = c$1.elm.getBoundingClientRect();\n if (map[c$1.key]) {\n kept.push(c$1);\n } else {\n removed.push(c$1);\n }\n }\n this.kept = h(tag, null, kept);\n this.removed = removed;\n }\n\n return h(tag, null, children)\n },\n\n beforeUpdate: function beforeUpdate () {\n // force removing pass\n this.__patch__(\n this._vnode,\n this.kept,\n false, // hydrating\n true // removeOnly (!important, avoids unnecessary moves)\n );\n this._vnode = this.kept;\n },\n\n updated: function updated () {\n var children = this.prevChildren;\n var moveClass = this.moveClass || ((this.name || 'v') + '-move');\n if (!children.length || !this.hasMove(children[0].elm, moveClass)) {\n return\n }\n\n // we divide the work into three loops to avoid mixing DOM reads and writes\n // in each iteration - which helps prevent layout thrashing.\n children.forEach(callPendingCbs);\n children.forEach(recordPosition);\n children.forEach(applyTranslation);\n\n // force reflow to put everything in position\n var f = document.body.offsetHeight; // eslint-disable-line\n\n children.forEach(function (c) {\n if (c.data.moved) {\n var el = c.elm;\n var s = el.style;\n addTransitionClass(el, moveClass);\n s.transform = s.WebkitTransform = s.transitionDuration = '';\n el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {\n if (!e || /transform$/.test(e.propertyName)) {\n el.removeEventListener(transitionEndEvent, cb);\n el._moveCb = null;\n removeTransitionClass(el, moveClass);\n }\n });\n }\n });\n },\n\n methods: {\n hasMove: function hasMove (el, moveClass) {\n /* istanbul ignore if */\n if (!hasTransition) {\n return false\n }\n if (this._hasMove != null) {\n return this._hasMove\n }\n addTransitionClass(el, moveClass);\n var info = getTransitionInfo(el);\n removeTransitionClass(el, moveClass);\n return (this._hasMove = info.hasTransform)\n }\n }\n};\n\nfunction callPendingCbs (c) {\n /* istanbul ignore if */\n if (c.elm._moveCb) {\n c.elm._moveCb();\n }\n /* istanbul ignore if */\n if (c.elm._enterCb) {\n c.elm._enterCb();\n }\n}\n\nfunction recordPosition (c) {\n c.data.newPos = c.elm.getBoundingClientRect();\n}\n\nfunction applyTranslation (c) {\n var oldPos = c.data.pos;\n var newPos = c.data.newPos;\n var dx = oldPos.left - newPos.left;\n var dy = oldPos.top - newPos.top;\n if (dx || dy) {\n c.data.moved = true;\n var s = c.elm.style;\n s.transform = s.WebkitTransform = \"translate(\" + dx + \"px,\" + dy + \"px)\";\n s.transitionDuration = '0s';\n }\n}\n\nvar platformComponents = {\n Transition: Transition,\n TransitionGroup: TransitionGroup\n};\n\n/* */\n\n// install platform specific utils\nVue$3.config.isUnknownElement = isUnknownElement;\nVue$3.config.isReservedTag = isReservedTag;\nVue$3.config.getTagNamespace = getTagNamespace;\nVue$3.config.mustUseProp = mustUseProp;\n\n// install platform runtime directives & components\nextend(Vue$3.options.directives, platformDirectives);\nextend(Vue$3.options.components, platformComponents);\n\n// install platform patch function\nVue$3.prototype.__patch__ = inBrowser ? patch$1 : noop;\n\n// wrap mount\nVue$3.prototype.$mount = function (\n el,\n hydrating\n) {\n el = el && inBrowser ? query(el) : undefined;\n return this._mount(el, hydrating)\n};\n\nif (false) {\n console[console.info ? 'info' : 'log'](\n \"You are running Vue in development mode.\\n\" +\n \"Make sure to turn on production mode when deploying for production.\\n\" +\n \"See more tips at https://vuejs.org/guide/deployment.html\"\n );\n}\n\n// devtools global hook\n/* istanbul ignore next */\nsetTimeout(function () {\n if (config.devtools) {\n if (devtools) {\n devtools.emit('init', Vue$3);\n } else if (\n false\n ) {\n console[console.info ? 'info' : 'log'](\n 'Download the Vue Devtools extension for a better development experience:\\n' +\n 'https://github.com/vuejs/vue-devtools'\n );\n }\n }\n}, 0);\n\n/* */\n\n// check whether current browser encodes a char inside attribute values\nfunction shouldDecode (content, encoded) {\n var div = document.createElement('div');\n div.innerHTML = \"<div a=\\\"\" + content + \"\\\">\";\n return div.innerHTML.indexOf(encoded) > 0\n}\n\n// #3663\n// IE encodes newlines inside attribute values while other browsers don't\nvar shouldDecodeNewlines = inBrowser ? shouldDecode('\\n', ' ') : false;\n\n/* */\n\nvar decoder;\n\nfunction decode (html) {\n decoder = decoder || document.createElement('div');\n decoder.innerHTML = html;\n return decoder.textContent\n}\n\n/* */\n\nvar isUnaryTag = makeMap(\n 'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +\n 'link,meta,param,source,track,wbr',\n true\n);\n\n// Elements that you can, intentionally, leave open\n// (and which close themselves)\nvar canBeLeftOpenTag = makeMap(\n 'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source',\n true\n);\n\n// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3\n// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content\nvar isNonPhrasingTag = makeMap(\n 'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +\n 'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +\n 'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +\n 'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +\n 'title,tr,track',\n true\n);\n\n/**\n * Not type-checking this file because it's mostly vendor code.\n */\n\n/*!\n * HTML Parser By John Resig (ejohn.org)\n * Modified by Juriy \"kangax\" Zaytsev\n * Original code by Erik Arvidsson, Mozilla Public License\n * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js\n */\n\n// Regular Expressions for parsing tags and attributes\nvar singleAttrIdentifier = /([^\\s\"'<>/=]+)/;\nvar singleAttrAssign = /(?:=)/;\nvar singleAttrValues = [\n // attr value double quotes\n /\"([^\"]*)\"+/.source,\n // attr value, single quotes\n /'([^']*)'+/.source,\n // attr value, no quotes\n /([^\\s\"'=<>`]+)/.source\n];\nvar attribute = new RegExp(\n '^\\\\s*' + singleAttrIdentifier.source +\n '(?:\\\\s*(' + singleAttrAssign.source + ')' +\n '\\\\s*(?:' + singleAttrValues.join('|') + '))?'\n);\n\n// could use https://www.w3.org/TR/1999/REC-xml-names-19990114/#NT-QName\n// but for Vue templates we can enforce a simple charset\nvar ncname = '[a-zA-Z_][\\\\w\\\\-\\\\.]*';\nvar qnameCapture = '((?:' + ncname + '\\\\:)?' + ncname + ')';\nvar startTagOpen = new RegExp('^<' + qnameCapture);\nvar startTagClose = /^\\s*(\\/?)>/;\nvar endTag = new RegExp('^<\\\\/' + qnameCapture + '[^>]*>');\nvar doctype = /^<!DOCTYPE [^>]+>/i;\nvar comment = /^<!--/;\nvar conditionalComment = /^<!\\[/;\n\nvar IS_REGEX_CAPTURING_BROKEN = false;\n'x'.replace(/x(.)?/g, function (m, g) {\n IS_REGEX_CAPTURING_BROKEN = g === '';\n});\n\n// Special Elements (can contain anything)\nvar isScriptOrStyle = makeMap('script,style', true);\nvar reCache = {};\n\nvar ltRE = /</g;\nvar gtRE = />/g;\nvar nlRE = / /g;\nvar ampRE = /&/g;\nvar quoteRE = /"/g;\n\nfunction decodeAttr (value, shouldDecodeNewlines) {\n if (shouldDecodeNewlines) {\n value = value.replace(nlRE, '\\n');\n }\n return value\n .replace(ltRE, '<')\n .replace(gtRE, '>')\n .replace(ampRE, '&')\n .replace(quoteRE, '\"')\n}\n\nfunction parseHTML (html, options) {\n var stack = [];\n var expectHTML = options.expectHTML;\n var isUnaryTag$$1 = options.isUnaryTag || no;\n var index = 0;\n var last, lastTag;\n while (html) {\n last = html;\n // Make sure we're not in a script or style element\n if (!lastTag || !isScriptOrStyle(lastTag)) {\n var textEnd = html.indexOf('<');\n if (textEnd === 0) {\n // Comment:\n if (comment.test(html)) {\n var commentEnd = html.indexOf('-->');\n\n if (commentEnd >= 0) {\n advance(commentEnd + 3);\n continue\n }\n }\n\n // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment\n if (conditionalComment.test(html)) {\n var conditionalEnd = html.indexOf(']>');\n\n if (conditionalEnd >= 0) {\n advance(conditionalEnd + 2);\n continue\n }\n }\n\n // Doctype:\n var doctypeMatch = html.match(doctype);\n if (doctypeMatch) {\n advance(doctypeMatch[0].length);\n continue\n }\n\n // End tag:\n var endTagMatch = html.match(endTag);\n if (endTagMatch) {\n var curIndex = index;\n advance(endTagMatch[0].length);\n parseEndTag(endTagMatch[1], curIndex, index);\n continue\n }\n\n // Start tag:\n var startTagMatch = parseStartTag();\n if (startTagMatch) {\n handleStartTag(startTagMatch);\n continue\n }\n }\n\n var text = (void 0), rest$1 = (void 0), next = (void 0);\n if (textEnd > 0) {\n rest$1 = html.slice(textEnd);\n while (\n !endTag.test(rest$1) &&\n !startTagOpen.test(rest$1) &&\n !comment.test(rest$1) &&\n !conditionalComment.test(rest$1)\n ) {\n // < in plain text, be forgiving and treat it as text\n next = rest$1.indexOf('<', 1);\n if (next < 0) { break }\n textEnd += next;\n rest$1 = html.slice(textEnd);\n }\n text = html.substring(0, textEnd);\n advance(textEnd);\n }\n\n if (textEnd < 0) {\n text = html;\n html = '';\n }\n\n if (options.chars && text) {\n options.chars(text);\n }\n } else {\n var stackedTag = lastTag.toLowerCase();\n var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\\\s\\\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));\n var endTagLength = 0;\n var rest = html.replace(reStackedTag, function (all, text, endTag) {\n endTagLength = endTag.length;\n if (stackedTag !== 'script' && stackedTag !== 'style' && stackedTag !== 'noscript') {\n text = text\n .replace(/<!--([\\s\\S]*?)-->/g, '$1')\n .replace(/<!\\[CDATA\\[([\\s\\S]*?)]]>/g, '$1');\n }\n if (options.chars) {\n options.chars(text);\n }\n return ''\n });\n index += html.length - rest.length;\n html = rest;\n parseEndTag(stackedTag, index - endTagLength, index);\n }\n\n if (html === last && options.chars) {\n options.chars(html);\n break\n }\n }\n\n // Clean up any remaining tags\n parseEndTag();\n\n function advance (n) {\n index += n;\n html = html.substring(n);\n }\n\n function parseStartTag () {\n var start = html.match(startTagOpen);\n if (start) {\n var match = {\n tagName: start[1],\n attrs: [],\n start: index\n };\n advance(start[0].length);\n var end, attr;\n while (!(end = html.match(startTagClose)) && (attr = html.match(attribute))) {\n advance(attr[0].length);\n match.attrs.push(attr);\n }\n if (end) {\n match.unarySlash = end[1];\n advance(end[0].length);\n match.end = index;\n return match\n }\n }\n }\n\n function handleStartTag (match) {\n var tagName = match.tagName;\n var unarySlash = match.unarySlash;\n\n if (expectHTML) {\n if (lastTag === 'p' && isNonPhrasingTag(tagName)) {\n parseEndTag(lastTag);\n }\n if (canBeLeftOpenTag(tagName) && lastTag === tagName) {\n parseEndTag(tagName);\n }\n }\n\n var unary = isUnaryTag$$1(tagName) || tagName === 'html' && lastTag === 'head' || !!unarySlash;\n\n var l = match.attrs.length;\n var attrs = new Array(l);\n for (var i = 0; i < l; i++) {\n var args = match.attrs[i];\n // hackish work around FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778\n if (IS_REGEX_CAPTURING_BROKEN && args[0].indexOf('\"\"') === -1) {\n if (args[3] === '') { delete args[3]; }\n if (args[4] === '') { delete args[4]; }\n if (args[5] === '') { delete args[5]; }\n }\n var value = args[3] || args[4] || args[5] || '';\n attrs[i] = {\n name: args[1],\n value: decodeAttr(\n value,\n options.shouldDecodeNewlines\n )\n };\n }\n\n if (!unary) {\n stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs });\n lastTag = tagName;\n unarySlash = '';\n }\n\n if (options.start) {\n options.start(tagName, attrs, unary, match.start, match.end);\n }\n }\n\n function parseEndTag (tagName, start, end) {\n var pos, lowerCasedTagName;\n if (start == null) { start = index; }\n if (end == null) { end = index; }\n\n if (tagName) {\n lowerCasedTagName = tagName.toLowerCase();\n }\n\n // Find the closest opened tag of the same type\n if (tagName) {\n for (pos = stack.length - 1; pos >= 0; pos--) {\n if (stack[pos].lowerCasedTag === lowerCasedTagName) {\n break\n }\n }\n } else {\n // If no tag name is provided, clean shop\n pos = 0;\n }\n\n if (pos >= 0) {\n // Close all the open elements, up the stack\n for (var i = stack.length - 1; i >= pos; i--) {\n if (options.end) {\n options.end(stack[i].tag, start, end);\n }\n }\n\n // Remove the open elements from the stack\n stack.length = pos;\n lastTag = pos && stack[pos - 1].tag;\n } else if (lowerCasedTagName === 'br') {\n if (options.start) {\n options.start(tagName, [], true, start, end);\n }\n } else if (lowerCasedTagName === 'p') {\n if (options.start) {\n options.start(tagName, [], false, start, end);\n }\n if (options.end) {\n options.end(tagName, start, end);\n }\n }\n }\n}\n\n/* */\n\nfunction parseFilters (exp) {\n var inSingle = false;\n var inDouble = false;\n var inTemplateString = false;\n var inRegex = false;\n var curly = 0;\n var square = 0;\n var paren = 0;\n var lastFilterIndex = 0;\n var c, prev, i, expression, filters;\n\n for (i = 0; i < exp.length; i++) {\n prev = c;\n c = exp.charCodeAt(i);\n if (inSingle) {\n if (c === 0x27 && prev !== 0x5C) { inSingle = false; }\n } else if (inDouble) {\n if (c === 0x22 && prev !== 0x5C) { inDouble = false; }\n } else if (inTemplateString) {\n if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }\n } else if (inRegex) {\n if (c === 0x2f && prev !== 0x5C) { inRegex = false; }\n } else if (\n c === 0x7C && // pipe\n exp.charCodeAt(i + 1) !== 0x7C &&\n exp.charCodeAt(i - 1) !== 0x7C &&\n !curly && !square && !paren\n ) {\n if (expression === undefined) {\n // first filter, end of expression\n lastFilterIndex = i + 1;\n expression = exp.slice(0, i).trim();\n } else {\n pushFilter();\n }\n } else {\n switch (c) {\n case 0x22: inDouble = true; break // \"\n case 0x27: inSingle = true; break // '\n case 0x60: inTemplateString = true; break // `\n case 0x28: paren++; break // (\n case 0x29: paren--; break // )\n case 0x5B: square++; break // [\n case 0x5D: square--; break // ]\n case 0x7B: curly++; break // {\n case 0x7D: curly--; break // }\n }\n if (c === 0x2f) { // /\n var j = i - 1;\n var p = (void 0);\n // find first non-whitespace prev char\n for (; j >= 0; j--) {\n p = exp.charAt(j);\n if (p !== ' ') { break }\n }\n if (!p || !/[\\w$]/.test(p)) {\n inRegex = true;\n }\n }\n }\n }\n\n if (expression === undefined) {\n expression = exp.slice(0, i).trim();\n } else if (lastFilterIndex !== 0) {\n pushFilter();\n }\n\n function pushFilter () {\n (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());\n lastFilterIndex = i + 1;\n }\n\n if (filters) {\n for (i = 0; i < filters.length; i++) {\n expression = wrapFilter(expression, filters[i]);\n }\n }\n\n return expression\n}\n\nfunction wrapFilter (exp, filter) {\n var i = filter.indexOf('(');\n if (i < 0) {\n // _f: resolveFilter\n return (\"_f(\\\"\" + filter + \"\\\")(\" + exp + \")\")\n } else {\n var name = filter.slice(0, i);\n var args = filter.slice(i + 1);\n return (\"_f(\\\"\" + name + \"\\\")(\" + exp + \",\" + args)\n }\n}\n\n/* */\n\nvar defaultTagRE = /\\{\\{((?:.|\\n)+?)\\}\\}/g;\nvar regexEscapeRE = /[-.*+?^${}()|[\\]\\/\\\\]/g;\n\nvar buildRegex = cached(function (delimiters) {\n var open = delimiters[0].replace(regexEscapeRE, '\\\\$&');\n var close = delimiters[1].replace(regexEscapeRE, '\\\\$&');\n return new RegExp(open + '((?:.|\\\\n)+?)' + close, 'g')\n});\n\nfunction parseText (\n text,\n delimiters\n) {\n var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;\n if (!tagRE.test(text)) {\n return\n }\n var tokens = [];\n var lastIndex = tagRE.lastIndex = 0;\n var match, index;\n while ((match = tagRE.exec(text))) {\n index = match.index;\n // push text token\n if (index > lastIndex) {\n tokens.push(JSON.stringify(text.slice(lastIndex, index)));\n }\n // tag token\n var exp = parseFilters(match[1].trim());\n tokens.push((\"_s(\" + exp + \")\"));\n lastIndex = index + match[0].length;\n }\n if (lastIndex < text.length) {\n tokens.push(JSON.stringify(text.slice(lastIndex)));\n }\n return tokens.join('+')\n}\n\n/* */\n\nfunction baseWarn (msg) {\n console.error((\"[Vue parser]: \" + msg));\n}\n\nfunction pluckModuleFunction (\n modules,\n key\n) {\n return modules\n ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })\n : []\n}\n\nfunction addProp (el, name, value) {\n (el.props || (el.props = [])).push({ name: name, value: value });\n}\n\nfunction addAttr (el, name, value) {\n (el.attrs || (el.attrs = [])).push({ name: name, value: value });\n}\n\nfunction addDirective (\n el,\n name,\n rawName,\n value,\n arg,\n modifiers\n) {\n (el.directives || (el.directives = [])).push({ name: name, rawName: rawName, value: value, arg: arg, modifiers: modifiers });\n}\n\nfunction addHandler (\n el,\n name,\n value,\n modifiers,\n important\n) {\n // check capture modifier\n if (modifiers && modifiers.capture) {\n delete modifiers.capture;\n name = '!' + name; // mark the event as captured\n }\n if (modifiers && modifiers.once) {\n delete modifiers.once;\n name = '~' + name; // mark the event as once\n }\n var events;\n if (modifiers && modifiers.native) {\n delete modifiers.native;\n events = el.nativeEvents || (el.nativeEvents = {});\n } else {\n events = el.events || (el.events = {});\n }\n var newHandler = { value: value, modifiers: modifiers };\n var handlers = events[name];\n /* istanbul ignore if */\n if (Array.isArray(handlers)) {\n important ? handlers.unshift(newHandler) : handlers.push(newHandler);\n } else if (handlers) {\n events[name] = important ? [newHandler, handlers] : [handlers, newHandler];\n } else {\n events[name] = newHandler;\n }\n}\n\nfunction getBindingAttr (\n el,\n name,\n getStatic\n) {\n var dynamicValue =\n getAndRemoveAttr(el, ':' + name) ||\n getAndRemoveAttr(el, 'v-bind:' + name);\n if (dynamicValue != null) {\n return parseFilters(dynamicValue)\n } else if (getStatic !== false) {\n var staticValue = getAndRemoveAttr(el, name);\n if (staticValue != null) {\n return JSON.stringify(staticValue)\n }\n }\n}\n\nfunction getAndRemoveAttr (el, name) {\n var val;\n if ((val = el.attrsMap[name]) != null) {\n var list = el.attrsList;\n for (var i = 0, l = list.length; i < l; i++) {\n if (list[i].name === name) {\n list.splice(i, 1);\n break\n }\n }\n }\n return val\n}\n\nvar len;\nvar str;\nvar chr;\nvar index$1;\nvar expressionPos;\nvar expressionEndPos;\n\n/**\n * parse directive model to do the array update transform. a[idx] = val => $$a.splice($$idx, 1, val)\n *\n * for loop possible cases:\n *\n * - test\n * - test[idx]\n * - test[test1[idx]]\n * - test[\"a\"][idx]\n * - xxx.test[a[a].test1[idx]]\n * - test.xxx.a[\"asa\"][test1[idx]]\n *\n */\n\nfunction parseModel (val) {\n str = val;\n len = str.length;\n index$1 = expressionPos = expressionEndPos = 0;\n\n if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {\n return {\n exp: val,\n idx: null\n }\n }\n\n while (!eof()) {\n chr = next();\n /* istanbul ignore if */\n if (isStringStart(chr)) {\n parseString(chr);\n } else if (chr === 0x5B) {\n parseBracket(chr);\n }\n }\n\n return {\n exp: val.substring(0, expressionPos),\n idx: val.substring(expressionPos + 1, expressionEndPos)\n }\n}\n\nfunction next () {\n return str.charCodeAt(++index$1)\n}\n\nfunction eof () {\n return index$1 >= len\n}\n\nfunction isStringStart (chr) {\n return chr === 0x22 || chr === 0x27\n}\n\nfunction parseBracket (chr) {\n var inBracket = 1;\n expressionPos = index$1;\n while (!eof()) {\n chr = next();\n if (isStringStart(chr)) {\n parseString(chr);\n continue\n }\n if (chr === 0x5B) { inBracket++; }\n if (chr === 0x5D) { inBracket--; }\n if (inBracket === 0) {\n expressionEndPos = index$1;\n break\n }\n }\n}\n\nfunction parseString (chr) {\n var stringQuote = chr;\n while (!eof()) {\n chr = next();\n if (chr === stringQuote) {\n break\n }\n }\n}\n\n/* */\n\nvar dirRE = /^v-|^@|^:/;\nvar forAliasRE = /(.*?)\\s+(?:in|of)\\s+(.*)/;\nvar forIteratorRE = /\\((\\{[^}]*\\}|[^,]*),([^,]*)(?:,([^,]*))?\\)/;\nvar bindRE = /^:|^v-bind:/;\nvar onRE = /^@|^v-on:/;\nvar argRE = /:(.*)$/;\nvar modifierRE = /\\.[^.]+/g;\n\nvar decodeHTMLCached = cached(decode);\n\n// configurable state\nvar warn$1;\nvar platformGetTagNamespace;\nvar platformMustUseProp;\nvar platformIsPreTag;\nvar preTransforms;\nvar transforms;\nvar postTransforms;\nvar delimiters;\n\n/**\n * Convert HTML string to AST.\n */\nfunction parse (\n template,\n options\n) {\n warn$1 = options.warn || baseWarn;\n platformGetTagNamespace = options.getTagNamespace || no;\n platformMustUseProp = options.mustUseProp || no;\n platformIsPreTag = options.isPreTag || no;\n preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');\n transforms = pluckModuleFunction(options.modules, 'transformNode');\n postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');\n delimiters = options.delimiters;\n var stack = [];\n var preserveWhitespace = options.preserveWhitespace !== false;\n var root;\n var currentParent;\n var inVPre = false;\n var inPre = false;\n var warned = false;\n parseHTML(template, {\n expectHTML: options.expectHTML,\n isUnaryTag: options.isUnaryTag,\n shouldDecodeNewlines: options.shouldDecodeNewlines,\n start: function start (tag, attrs, unary) {\n // check namespace.\n // inherit parent ns if there is one\n var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);\n\n // handle IE svg bug\n /* istanbul ignore if */\n if (isIE && ns === 'svg') {\n attrs = guardIESVGBug(attrs);\n }\n\n var element = {\n type: 1,\n tag: tag,\n attrsList: attrs,\n attrsMap: makeAttrsMap(attrs),\n parent: currentParent,\n children: []\n };\n if (ns) {\n element.ns = ns;\n }\n\n if (isForbiddenTag(element) && !isServerRendering()) {\n element.forbidden = true;\n \"production\" !== 'production' && warn$1(\n 'Templates should only be responsible for mapping the state to the ' +\n 'UI. Avoid placing tags with side-effects in your templates, such as ' +\n \"<\" + tag + \">\" + ', as they will not be parsed.'\n );\n }\n\n // apply pre-transforms\n for (var i = 0; i < preTransforms.length; i++) {\n preTransforms[i](element, options);\n }\n\n if (!inVPre) {\n processPre(element);\n if (element.pre) {\n inVPre = true;\n }\n }\n if (platformIsPreTag(element.tag)) {\n inPre = true;\n }\n if (inVPre) {\n processRawAttrs(element);\n } else {\n processFor(element);\n processIf(element);\n processOnce(element);\n processKey(element);\n\n // determine whether this is a plain element after\n // removing structural attributes\n element.plain = !element.key && !attrs.length;\n\n processRef(element);\n processSlot(element);\n processComponent(element);\n for (var i$1 = 0; i$1 < transforms.length; i$1++) {\n transforms[i$1](element, options);\n }\n processAttrs(element);\n }\n\n function checkRootConstraints (el) {\n if (false) {\n if (el.tag === 'slot' || el.tag === 'template') {\n warned = true;\n warn$1(\n \"Cannot use <\" + (el.tag) + \"> as component root element because it may \" +\n 'contain multiple nodes:\\n' + template\n );\n }\n if (el.attrsMap.hasOwnProperty('v-for')) {\n warned = true;\n warn$1(\n 'Cannot use v-for on stateful component root element because ' +\n 'it renders multiple elements:\\n' + template\n );\n }\n }\n }\n\n // tree management\n if (!root) {\n root = element;\n checkRootConstraints(root);\n } else if (!stack.length) {\n // allow root elements with v-if, v-else-if and v-else\n if (root.if && (element.elseif || element.else)) {\n checkRootConstraints(element);\n addIfCondition(root, {\n exp: element.elseif,\n block: element\n });\n } else if (false) {\n warned = true;\n warn$1(\n \"Component template should contain exactly one root element:\" +\n \"\\n\\n\" + template + \"\\n\\n\" +\n \"If you are using v-if on multiple elements, \" +\n \"use v-else-if to chain them instead.\"\n );\n }\n }\n if (currentParent && !element.forbidden) {\n if (element.elseif || element.else) {\n processIfConditions(element, currentParent);\n } else if (element.slotScope) { // scoped slot\n currentParent.plain = false;\n var name = element.slotTarget || 'default';(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;\n } else {\n currentParent.children.push(element);\n element.parent = currentParent;\n }\n }\n if (!unary) {\n currentParent = element;\n stack.push(element);\n }\n // apply post-transforms\n for (var i$2 = 0; i$2 < postTransforms.length; i$2++) {\n postTransforms[i$2](element, options);\n }\n },\n\n end: function end () {\n // remove trailing whitespace\n var element = stack[stack.length - 1];\n var lastNode = element.children[element.children.length - 1];\n if (lastNode && lastNode.type === 3 && lastNode.text === ' ') {\n element.children.pop();\n }\n // pop stack\n stack.length -= 1;\n currentParent = stack[stack.length - 1];\n // check pre state\n if (element.pre) {\n inVPre = false;\n }\n if (platformIsPreTag(element.tag)) {\n inPre = false;\n }\n },\n\n chars: function chars (text) {\n if (!currentParent) {\n if (false) {\n warned = true;\n warn$1(\n 'Component template requires a root element, rather than just text:\\n\\n' + template\n );\n }\n return\n }\n // IE textarea placeholder bug\n /* istanbul ignore if */\n if (isIE &&\n currentParent.tag === 'textarea' &&\n currentParent.attrsMap.placeholder === text) {\n return\n }\n var children = currentParent.children;\n text = inPre || text.trim()\n ? decodeHTMLCached(text)\n // only preserve whitespace if its not right after a starting tag\n : preserveWhitespace && children.length ? ' ' : '';\n if (text) {\n var expression;\n if (!inVPre && text !== ' ' && (expression = parseText(text, delimiters))) {\n children.push({\n type: 2,\n expression: expression,\n text: text\n });\n } else if (text !== ' ' || children[children.length - 1].text !== ' ') {\n currentParent.children.push({\n type: 3,\n text: text\n });\n }\n }\n }\n });\n return root\n}\n\nfunction processPre (el) {\n if (getAndRemoveAttr(el, 'v-pre') != null) {\n el.pre = true;\n }\n}\n\nfunction processRawAttrs (el) {\n var l = el.attrsList.length;\n if (l) {\n var attrs = el.attrs = new Array(l);\n for (var i = 0; i < l; i++) {\n attrs[i] = {\n name: el.attrsList[i].name,\n value: JSON.stringify(el.attrsList[i].value)\n };\n }\n } else if (!el.pre) {\n // non root node in pre blocks with no attributes\n el.plain = true;\n }\n}\n\nfunction processKey (el) {\n var exp = getBindingAttr(el, 'key');\n if (exp) {\n if (false) {\n warn$1(\"<template> cannot be keyed. Place the key on real elements instead.\");\n }\n el.key = exp;\n }\n}\n\nfunction processRef (el) {\n var ref = getBindingAttr(el, 'ref');\n if (ref) {\n el.ref = ref;\n el.refInFor = checkInFor(el);\n }\n}\n\nfunction processFor (el) {\n var exp;\n if ((exp = getAndRemoveAttr(el, 'v-for'))) {\n var inMatch = exp.match(forAliasRE);\n if (!inMatch) {\n \"production\" !== 'production' && warn$1(\n (\"Invalid v-for expression: \" + exp)\n );\n return\n }\n el.for = inMatch[2].trim();\n var alias = inMatch[1].trim();\n var iteratorMatch = alias.match(forIteratorRE);\n if (iteratorMatch) {\n el.alias = iteratorMatch[1].trim();\n el.iterator1 = iteratorMatch[2].trim();\n if (iteratorMatch[3]) {\n el.iterator2 = iteratorMatch[3].trim();\n }\n } else {\n el.alias = alias;\n }\n }\n}\n\nfunction processIf (el) {\n var exp = getAndRemoveAttr(el, 'v-if');\n if (exp) {\n el.if = exp;\n addIfCondition(el, {\n exp: exp,\n block: el\n });\n } else {\n if (getAndRemoveAttr(el, 'v-else') != null) {\n el.else = true;\n }\n var elseif = getAndRemoveAttr(el, 'v-else-if');\n if (elseif) {\n el.elseif = elseif;\n }\n }\n}\n\nfunction processIfConditions (el, parent) {\n var prev = findPrevElement(parent.children);\n if (prev && prev.if) {\n addIfCondition(prev, {\n exp: el.elseif,\n block: el\n });\n } else if (false) {\n warn$1(\n \"v-\" + (el.elseif ? ('else-if=\"' + el.elseif + '\"') : 'else') + \" \" +\n \"used on element <\" + (el.tag) + \"> without corresponding v-if.\"\n );\n }\n}\n\nfunction findPrevElement (children) {\n var i = children.length;\n while (i--) {\n if (children[i].type === 1) {\n return children[i]\n } else {\n if (false) {\n warn$1(\n \"text \\\"\" + (children[i].text.trim()) + \"\\\" between v-if and v-else(-if) \" +\n \"will be ignored.\"\n );\n }\n children.pop();\n }\n }\n}\n\nfunction addIfCondition (el, condition) {\n if (!el.ifConditions) {\n el.ifConditions = [];\n }\n el.ifConditions.push(condition);\n}\n\nfunction processOnce (el) {\n var once = getAndRemoveAttr(el, 'v-once');\n if (once != null) {\n el.once = true;\n }\n}\n\nfunction processSlot (el) {\n if (el.tag === 'slot') {\n el.slotName = getBindingAttr(el, 'name');\n if (false) {\n warn$1(\n \"`key` does not work on <slot> because slots are abstract outlets \" +\n \"and can possibly expand into multiple elements. \" +\n \"Use the key on a wrapping element instead.\"\n );\n }\n } else {\n var slotTarget = getBindingAttr(el, 'slot');\n if (slotTarget) {\n el.slotTarget = slotTarget === '\"\"' ? '\"default\"' : slotTarget;\n }\n if (el.tag === 'template') {\n el.slotScope = getAndRemoveAttr(el, 'scope');\n }\n }\n}\n\nfunction processComponent (el) {\n var binding;\n if ((binding = getBindingAttr(el, 'is'))) {\n el.component = binding;\n }\n if (getAndRemoveAttr(el, 'inline-template') != null) {\n el.inlineTemplate = true;\n }\n}\n\nfunction processAttrs (el) {\n var list = el.attrsList;\n var i, l, name, rawName, value, arg, modifiers, isProp;\n for (i = 0, l = list.length; i < l; i++) {\n name = rawName = list[i].name;\n value = list[i].value;\n if (dirRE.test(name)) {\n // mark element as dynamic\n el.hasBindings = true;\n // modifiers\n modifiers = parseModifiers(name);\n if (modifiers) {\n name = name.replace(modifierRE, '');\n }\n if (bindRE.test(name)) { // v-bind\n name = name.replace(bindRE, '');\n value = parseFilters(value);\n isProp = false;\n if (modifiers) {\n if (modifiers.prop) {\n isProp = true;\n name = camelize(name);\n if (name === 'innerHtml') { name = 'innerHTML'; }\n }\n if (modifiers.camel) {\n name = camelize(name);\n }\n }\n if (isProp || platformMustUseProp(el.tag, el.attrsMap.type, name)) {\n addProp(el, name, value);\n } else {\n addAttr(el, name, value);\n }\n } else if (onRE.test(name)) { // v-on\n name = name.replace(onRE, '');\n addHandler(el, name, value, modifiers);\n } else { // normal directives\n name = name.replace(dirRE, '');\n // parse arg\n var argMatch = name.match(argRE);\n if (argMatch && (arg = argMatch[1])) {\n name = name.slice(0, -(arg.length + 1));\n }\n addDirective(el, name, rawName, value, arg, modifiers);\n if (false) {\n checkForAliasModel(el, value);\n }\n }\n } else {\n // literal attribute\n if (false) {\n var expression = parseText(value, delimiters);\n if (expression) {\n warn$1(\n name + \"=\\\"\" + value + \"\\\": \" +\n 'Interpolation inside attributes has been removed. ' +\n 'Use v-bind or the colon shorthand instead. For example, ' +\n 'instead of <div id=\"{{ val }}\">, use <div :id=\"val\">.'\n );\n }\n }\n addAttr(el, name, JSON.stringify(value));\n }\n }\n}\n\nfunction checkInFor (el) {\n var parent = el;\n while (parent) {\n if (parent.for !== undefined) {\n return true\n }\n parent = parent.parent;\n }\n return false\n}\n\nfunction parseModifiers (name) {\n var match = name.match(modifierRE);\n if (match) {\n var ret = {};\n match.forEach(function (m) { ret[m.slice(1)] = true; });\n return ret\n }\n}\n\nfunction makeAttrsMap (attrs) {\n var map = {};\n for (var i = 0, l = attrs.length; i < l; i++) {\n if (false) {\n warn$1('duplicate attribute: ' + attrs[i].name);\n }\n map[attrs[i].name] = attrs[i].value;\n }\n return map\n}\n\nfunction isForbiddenTag (el) {\n return (\n el.tag === 'style' ||\n (el.tag === 'script' && (\n !el.attrsMap.type ||\n el.attrsMap.type === 'text/javascript'\n ))\n )\n}\n\nvar ieNSBug = /^xmlns:NS\\d+/;\nvar ieNSPrefix = /^NS\\d+:/;\n\n/* istanbul ignore next */\nfunction guardIESVGBug (attrs) {\n var res = [];\n for (var i = 0; i < attrs.length; i++) {\n var attr = attrs[i];\n if (!ieNSBug.test(attr.name)) {\n attr.name = attr.name.replace(ieNSPrefix, '');\n res.push(attr);\n }\n }\n return res\n}\n\nfunction checkForAliasModel (el, value) {\n var _el = el;\n while (_el) {\n if (_el.for && _el.alias === value) {\n warn$1(\n \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\">: \" +\n \"You are binding v-model directly to a v-for iteration alias. \" +\n \"This will not be able to modify the v-for source array because \" +\n \"writing to the alias is like modifying a function local variable. \" +\n \"Consider using an array of objects and use v-model on an object property instead.\"\n );\n }\n _el = _el.parent;\n }\n}\n\n/* */\n\nvar isStaticKey;\nvar isPlatformReservedTag;\n\nvar genStaticKeysCached = cached(genStaticKeys$1);\n\n/**\n * Goal of the optimizer: walk the generated template AST tree\n * and detect sub-trees that are purely static, i.e. parts of\n * the DOM that never needs to change.\n *\n * Once we detect these sub-trees, we can:\n *\n * 1. Hoist them into constants, so that we no longer need to\n * create fresh nodes for them on each re-render;\n * 2. Completely skip them in the patching process.\n */\nfunction optimize (root, options) {\n if (!root) { return }\n isStaticKey = genStaticKeysCached(options.staticKeys || '');\n isPlatformReservedTag = options.isReservedTag || no;\n // first pass: mark all non-static nodes.\n markStatic(root);\n // second pass: mark static roots.\n markStaticRoots(root, false);\n}\n\nfunction genStaticKeys$1 (keys) {\n return makeMap(\n 'type,tag,attrsList,attrsMap,plain,parent,children,attrs' +\n (keys ? ',' + keys : '')\n )\n}\n\nfunction markStatic (node) {\n node.static = isStatic(node);\n if (node.type === 1) {\n // do not make component slot content static. this avoids\n // 1. components not able to mutate slot nodes\n // 2. static slot content fails for hot-reloading\n if (\n !isPlatformReservedTag(node.tag) &&\n node.tag !== 'slot' &&\n node.attrsMap['inline-template'] == null\n ) {\n return\n }\n for (var i = 0, l = node.children.length; i < l; i++) {\n var child = node.children[i];\n markStatic(child);\n if (!child.static) {\n node.static = false;\n }\n }\n }\n}\n\nfunction markStaticRoots (node, isInFor) {\n if (node.type === 1) {\n if (node.static || node.once) {\n node.staticInFor = isInFor;\n }\n // For a node to qualify as a static root, it should have children that\n // are not just static text. Otherwise the cost of hoisting out will\n // outweigh the benefits and it's better off to just always render it fresh.\n if (node.static && node.children.length && !(\n node.children.length === 1 &&\n node.children[0].type === 3\n )) {\n node.staticRoot = true;\n return\n } else {\n node.staticRoot = false;\n }\n if (node.children) {\n for (var i = 0, l = node.children.length; i < l; i++) {\n markStaticRoots(node.children[i], isInFor || !!node.for);\n }\n }\n if (node.ifConditions) {\n walkThroughConditionsBlocks(node.ifConditions, isInFor);\n }\n }\n}\n\nfunction walkThroughConditionsBlocks (conditionBlocks, isInFor) {\n for (var i = 1, len = conditionBlocks.length; i < len; i++) {\n markStaticRoots(conditionBlocks[i].block, isInFor);\n }\n}\n\nfunction isStatic (node) {\n if (node.type === 2) { // expression\n return false\n }\n if (node.type === 3) { // text\n return true\n }\n return !!(node.pre || (\n !node.hasBindings && // no dynamic bindings\n !node.if && !node.for && // not v-if or v-for or v-else\n !isBuiltInTag(node.tag) && // not a built-in\n isPlatformReservedTag(node.tag) && // not a component\n !isDirectChildOfTemplateFor(node) &&\n Object.keys(node).every(isStaticKey)\n ))\n}\n\nfunction isDirectChildOfTemplateFor (node) {\n while (node.parent) {\n node = node.parent;\n if (node.tag !== 'template') {\n return false\n }\n if (node.for) {\n return true\n }\n }\n return false\n}\n\n/* */\n\nvar fnExpRE = /^\\s*([\\w$_]+|\\([^)]*?\\))\\s*=>|^function\\s*\\(/;\nvar simplePathRE = /^\\s*[A-Za-z_$][\\w$]*(?:\\.[A-Za-z_$][\\w$]*|\\['.*?']|\\[\".*?\"]|\\[\\d+]|\\[[A-Za-z_$][\\w$]*])*\\s*$/;\n\n// keyCode aliases\nvar keyCodes = {\n esc: 27,\n tab: 9,\n enter: 13,\n space: 32,\n up: 38,\n left: 37,\n right: 39,\n down: 40,\n 'delete': [8, 46]\n};\n\nvar modifierCode = {\n stop: '$event.stopPropagation();',\n prevent: '$event.preventDefault();',\n self: 'if($event.target !== $event.currentTarget)return;',\n ctrl: 'if(!$event.ctrlKey)return;',\n shift: 'if(!$event.shiftKey)return;',\n alt: 'if(!$event.altKey)return;',\n meta: 'if(!$event.metaKey)return;'\n};\n\nfunction genHandlers (events, native) {\n var res = native ? 'nativeOn:{' : 'on:{';\n for (var name in events) {\n res += \"\\\"\" + name + \"\\\":\" + (genHandler(name, events[name])) + \",\";\n }\n return res.slice(0, -1) + '}'\n}\n\nfunction genHandler (\n name,\n handler\n) {\n if (!handler) {\n return 'function(){}'\n } else if (Array.isArray(handler)) {\n return (\"[\" + (handler.map(function (handler) { return genHandler(name, handler); }).join(',')) + \"]\")\n } else if (!handler.modifiers) {\n return fnExpRE.test(handler.value) || simplePathRE.test(handler.value)\n ? handler.value\n : (\"function($event){\" + (handler.value) + \"}\")\n } else {\n var code = '';\n var keys = [];\n for (var key in handler.modifiers) {\n if (modifierCode[key]) {\n code += modifierCode[key];\n } else {\n keys.push(key);\n }\n }\n if (keys.length) {\n code = genKeyFilter(keys) + code;\n }\n var handlerCode = simplePathRE.test(handler.value)\n ? handler.value + '($event)'\n : handler.value;\n return 'function($event){' + code + handlerCode + '}'\n }\n}\n\nfunction genKeyFilter (keys) {\n return (\"if(\" + (keys.map(genFilterCode).join('&&')) + \")return;\")\n}\n\nfunction genFilterCode (key) {\n var keyVal = parseInt(key, 10);\n if (keyVal) {\n return (\"$event.keyCode!==\" + keyVal)\n }\n var alias = keyCodes[key];\n return (\"_k($event.keyCode,\" + (JSON.stringify(key)) + (alias ? ',' + JSON.stringify(alias) : '') + \")\")\n}\n\n/* */\n\nfunction bind$2 (el, dir) {\n el.wrapData = function (code) {\n return (\"_b(\" + code + \",'\" + (el.tag) + \"',\" + (dir.value) + (dir.modifiers && dir.modifiers.prop ? ',true' : '') + \")\")\n };\n}\n\n/* */\n\nvar baseDirectives = {\n bind: bind$2,\n cloak: noop\n};\n\n/* */\n\n// configurable state\nvar warn$2;\nvar transforms$1;\nvar dataGenFns;\nvar platformDirectives$1;\nvar isPlatformReservedTag$1;\nvar staticRenderFns;\nvar onceCount;\nvar currentOptions;\n\nfunction generate (\n ast,\n options\n) {\n // save previous staticRenderFns so generate calls can be nested\n var prevStaticRenderFns = staticRenderFns;\n var currentStaticRenderFns = staticRenderFns = [];\n var prevOnceCount = onceCount;\n onceCount = 0;\n currentOptions = options;\n warn$2 = options.warn || baseWarn;\n transforms$1 = pluckModuleFunction(options.modules, 'transformCode');\n dataGenFns = pluckModuleFunction(options.modules, 'genData');\n platformDirectives$1 = options.directives || {};\n isPlatformReservedTag$1 = options.isReservedTag || no;\n var code = ast ? genElement(ast) : '_c(\"div\")';\n staticRenderFns = prevStaticRenderFns;\n onceCount = prevOnceCount;\n return {\n render: (\"with(this){return \" + code + \"}\"),\n staticRenderFns: currentStaticRenderFns\n }\n}\n\nfunction genElement (el) {\n if (el.staticRoot && !el.staticProcessed) {\n return genStatic(el)\n } else if (el.once && !el.onceProcessed) {\n return genOnce(el)\n } else if (el.for && !el.forProcessed) {\n return genFor(el)\n } else if (el.if && !el.ifProcessed) {\n return genIf(el)\n } else if (el.tag === 'template' && !el.slotTarget) {\n return genChildren(el) || 'void 0'\n } else if (el.tag === 'slot') {\n return genSlot(el)\n } else {\n // component or element\n var code;\n if (el.component) {\n code = genComponent(el.component, el);\n } else {\n var data = el.plain ? undefined : genData(el);\n\n var children = el.inlineTemplate ? null : genChildren(el, true);\n code = \"_c('\" + (el.tag) + \"'\" + (data ? (\",\" + data) : '') + (children ? (\",\" + children) : '') + \")\";\n }\n // module transforms\n for (var i = 0; i < transforms$1.length; i++) {\n code = transforms$1[i](el, code);\n }\n return code\n }\n}\n\n// hoist static sub-trees out\nfunction genStatic (el) {\n el.staticProcessed = true;\n staticRenderFns.push((\"with(this){return \" + (genElement(el)) + \"}\"));\n return (\"_m(\" + (staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + \")\")\n}\n\n// v-once\nfunction genOnce (el) {\n el.onceProcessed = true;\n if (el.if && !el.ifProcessed) {\n return genIf(el)\n } else if (el.staticInFor) {\n var key = '';\n var parent = el.parent;\n while (parent) {\n if (parent.for) {\n key = parent.key;\n break\n }\n parent = parent.parent;\n }\n if (!key) {\n \"production\" !== 'production' && warn$2(\n \"v-once can only be used inside v-for that is keyed. \"\n );\n return genElement(el)\n }\n return (\"_o(\" + (genElement(el)) + \",\" + (onceCount++) + (key ? (\",\" + key) : \"\") + \")\")\n } else {\n return genStatic(el)\n }\n}\n\nfunction genIf (el) {\n el.ifProcessed = true; // avoid recursion\n return genIfConditions(el.ifConditions.slice())\n}\n\nfunction genIfConditions (conditions) {\n if (!conditions.length) {\n return '_e()'\n }\n\n var condition = conditions.shift();\n if (condition.exp) {\n return (\"(\" + (condition.exp) + \")?\" + (genTernaryExp(condition.block)) + \":\" + (genIfConditions(conditions)))\n } else {\n return (\"\" + (genTernaryExp(condition.block)))\n }\n\n // v-if with v-once should generate code like (a)?_m(0):_m(1)\n function genTernaryExp (el) {\n return el.once ? genOnce(el) : genElement(el)\n }\n}\n\nfunction genFor (el) {\n var exp = el.for;\n var alias = el.alias;\n var iterator1 = el.iterator1 ? (\",\" + (el.iterator1)) : '';\n var iterator2 = el.iterator2 ? (\",\" + (el.iterator2)) : '';\n el.forProcessed = true; // avoid recursion\n return \"_l((\" + exp + \"),\" +\n \"function(\" + alias + iterator1 + iterator2 + \"){\" +\n \"return \" + (genElement(el)) +\n '})'\n}\n\nfunction genData (el) {\n var data = '{';\n\n // directives first.\n // directives may mutate the el's other properties before they are generated.\n var dirs = genDirectives(el);\n if (dirs) { data += dirs + ','; }\n\n // key\n if (el.key) {\n data += \"key:\" + (el.key) + \",\";\n }\n // ref\n if (el.ref) {\n data += \"ref:\" + (el.ref) + \",\";\n }\n if (el.refInFor) {\n data += \"refInFor:true,\";\n }\n // pre\n if (el.pre) {\n data += \"pre:true,\";\n }\n // record original tag name for components using \"is\" attribute\n if (el.component) {\n data += \"tag:\\\"\" + (el.tag) + \"\\\",\";\n }\n // module data generation functions\n for (var i = 0; i < dataGenFns.length; i++) {\n data += dataGenFns[i](el);\n }\n // attributes\n if (el.attrs) {\n data += \"attrs:{\" + (genProps(el.attrs)) + \"},\";\n }\n // DOM props\n if (el.props) {\n data += \"domProps:{\" + (genProps(el.props)) + \"},\";\n }\n // event handlers\n if (el.events) {\n data += (genHandlers(el.events)) + \",\";\n }\n if (el.nativeEvents) {\n data += (genHandlers(el.nativeEvents, true)) + \",\";\n }\n // slot target\n if (el.slotTarget) {\n data += \"slot:\" + (el.slotTarget) + \",\";\n }\n // scoped slots\n if (el.scopedSlots) {\n data += (genScopedSlots(el.scopedSlots)) + \",\";\n }\n // inline-template\n if (el.inlineTemplate) {\n var inlineTemplate = genInlineTemplate(el);\n if (inlineTemplate) {\n data += inlineTemplate + \",\";\n }\n }\n data = data.replace(/,$/, '') + '}';\n // v-bind data wrap\n if (el.wrapData) {\n data = el.wrapData(data);\n }\n return data\n}\n\nfunction genDirectives (el) {\n var dirs = el.directives;\n if (!dirs) { return }\n var res = 'directives:[';\n var hasRuntime = false;\n var i, l, dir, needRuntime;\n for (i = 0, l = dirs.length; i < l; i++) {\n dir = dirs[i];\n needRuntime = true;\n var gen = platformDirectives$1[dir.name] || baseDirectives[dir.name];\n if (gen) {\n // compile-time directive that manipulates AST.\n // returns true if it also needs a runtime counterpart.\n needRuntime = !!gen(el, dir, warn$2);\n }\n if (needRuntime) {\n hasRuntime = true;\n res += \"{name:\\\"\" + (dir.name) + \"\\\",rawName:\\\"\" + (dir.rawName) + \"\\\"\" + (dir.value ? (\",value:(\" + (dir.value) + \"),expression:\" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (\",arg:\\\"\" + (dir.arg) + \"\\\"\") : '') + (dir.modifiers ? (\",modifiers:\" + (JSON.stringify(dir.modifiers))) : '') + \"},\";\n }\n }\n if (hasRuntime) {\n return res.slice(0, -1) + ']'\n }\n}\n\nfunction genInlineTemplate (el) {\n var ast = el.children[0];\n if (false) {\n warn$2('Inline-template components must have exactly one child element.');\n }\n if (ast.type === 1) {\n var inlineRenderFns = generate(ast, currentOptions);\n return (\"inlineTemplate:{render:function(){\" + (inlineRenderFns.render) + \"},staticRenderFns:[\" + (inlineRenderFns.staticRenderFns.map(function (code) { return (\"function(){\" + code + \"}\"); }).join(',')) + \"]}\")\n }\n}\n\nfunction genScopedSlots (slots) {\n return (\"scopedSlots:{\" + (Object.keys(slots).map(function (key) { return genScopedSlot(key, slots[key]); }).join(',')) + \"}\")\n}\n\nfunction genScopedSlot (key, el) {\n return key + \":function(\" + (String(el.attrsMap.scope)) + \"){\" +\n \"return \" + (el.tag === 'template'\n ? genChildren(el) || 'void 0'\n : genElement(el)) + \"}\"\n}\n\nfunction genChildren (el, checkSkip) {\n var children = el.children;\n if (children.length) {\n var el$1 = children[0];\n // optimize single v-for\n if (children.length === 1 &&\n el$1.for &&\n el$1.tag !== 'template' &&\n el$1.tag !== 'slot') {\n return genElement(el$1)\n }\n var normalizationType = getNormalizationType(children);\n return (\"[\" + (children.map(genNode).join(',')) + \"]\" + (checkSkip\n ? normalizationType ? (\",\" + normalizationType) : ''\n : ''))\n }\n}\n\n// determine the normalization needed for the children array.\n// 0: no normalization needed\n// 1: simple normalization needed (possible 1-level deep nested array)\n// 2: full normalization needed\nfunction getNormalizationType (children) {\n var res = 0;\n for (var i = 0; i < children.length; i++) {\n var el = children[i];\n if (el.type !== 1) {\n continue\n }\n if (needsNormalization(el) ||\n (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {\n res = 2;\n break\n }\n if (maybeComponent(el) ||\n (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {\n res = 1;\n }\n }\n return res\n}\n\nfunction needsNormalization (el) {\n return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'\n}\n\nfunction maybeComponent (el) {\n return !isPlatformReservedTag$1(el.tag)\n}\n\nfunction genNode (node) {\n if (node.type === 1) {\n return genElement(node)\n } else {\n return genText(node)\n }\n}\n\nfunction genText (text) {\n return (\"_v(\" + (text.type === 2\n ? text.expression // no need for () because already wrapped in _s()\n : transformSpecialNewlines(JSON.stringify(text.text))) + \")\")\n}\n\nfunction genSlot (el) {\n var slotName = el.slotName || '\"default\"';\n var children = genChildren(el);\n var res = \"_t(\" + slotName + (children ? (\",\" + children) : '');\n var attrs = el.attrs && (\"{\" + (el.attrs.map(function (a) { return ((camelize(a.name)) + \":\" + (a.value)); }).join(',')) + \"}\");\n var bind$$1 = el.attrsMap['v-bind'];\n if ((attrs || bind$$1) && !children) {\n res += \",null\";\n }\n if (attrs) {\n res += \",\" + attrs;\n }\n if (bind$$1) {\n res += (attrs ? '' : ',null') + \",\" + bind$$1;\n }\n return res + ')'\n}\n\n// componentName is el.component, take it as argument to shun flow's pessimistic refinement\nfunction genComponent (componentName, el) {\n var children = el.inlineTemplate ? null : genChildren(el, true);\n return (\"_c(\" + componentName + \",\" + (genData(el)) + (children ? (\",\" + children) : '') + \")\")\n}\n\nfunction genProps (props) {\n var res = '';\n for (var i = 0; i < props.length; i++) {\n var prop = props[i];\n res += \"\\\"\" + (prop.name) + \"\\\":\" + (transformSpecialNewlines(prop.value)) + \",\";\n }\n return res.slice(0, -1)\n}\n\n// #3895, #4268\nfunction transformSpecialNewlines (text) {\n return text\n .replace(/\\u2028/g, '\\\\u2028')\n .replace(/\\u2029/g, '\\\\u2029')\n}\n\n/* */\n\n/**\n * Compile a template.\n */\nfunction compile$1 (\n template,\n options\n) {\n var ast = parse(template.trim(), options);\n optimize(ast, options);\n var code = generate(ast, options);\n return {\n ast: ast,\n render: code.render,\n staticRenderFns: code.staticRenderFns\n }\n}\n\n/* */\n\n// operators like typeof, instanceof and in are allowed\nvar prohibitedKeywordRE = new RegExp('\\\\b' + (\n 'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +\n 'super,throw,while,yield,delete,export,import,return,switch,default,' +\n 'extends,finally,continue,debugger,function,arguments'\n).split(',').join('\\\\b|\\\\b') + '\\\\b');\n// check valid identifier for v-for\nvar identRE = /[A-Za-z_$][\\w$]*/;\n// strip strings in expressions\nvar stripStringRE = /'(?:[^'\\\\]|\\\\.)*'|\"(?:[^\"\\\\]|\\\\.)*\"|`(?:[^`\\\\]|\\\\.)*\\$\\{|\\}(?:[^`\\\\]|\\\\.)*`|`(?:[^`\\\\]|\\\\.)*`/g;\n\n// detect problematic expressions in a template\nfunction detectErrors (ast) {\n var errors = [];\n if (ast) {\n checkNode(ast, errors);\n }\n return errors\n}\n\nfunction checkNode (node, errors) {\n if (node.type === 1) {\n for (var name in node.attrsMap) {\n if (dirRE.test(name)) {\n var value = node.attrsMap[name];\n if (value) {\n if (name === 'v-for') {\n checkFor(node, (\"v-for=\\\"\" + value + \"\\\"\"), errors);\n } else {\n checkExpression(value, (name + \"=\\\"\" + value + \"\\\"\"), errors);\n }\n }\n }\n }\n if (node.children) {\n for (var i = 0; i < node.children.length; i++) {\n checkNode(node.children[i], errors);\n }\n }\n } else if (node.type === 2) {\n checkExpression(node.expression, node.text, errors);\n }\n}\n\nfunction checkFor (node, text, errors) {\n checkExpression(node.for || '', text, errors);\n checkIdentifier(node.alias, 'v-for alias', text, errors);\n checkIdentifier(node.iterator1, 'v-for iterator', text, errors);\n checkIdentifier(node.iterator2, 'v-for iterator', text, errors);\n}\n\nfunction checkIdentifier (ident, type, text, errors) {\n if (typeof ident === 'string' && !identRE.test(ident)) {\n errors.push((\"- invalid \" + type + \" \\\"\" + ident + \"\\\" in expression: \" + text));\n }\n}\n\nfunction checkExpression (exp, text, errors) {\n try {\n new Function((\"return \" + exp));\n } catch (e) {\n var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);\n if (keywordMatch) {\n errors.push(\n \"- avoid using JavaScript keyword as property name: \" +\n \"\\\"\" + (keywordMatch[0]) + \"\\\" in expression \" + text\n );\n } else {\n errors.push((\"- invalid expression: \" + text));\n }\n }\n}\n\n/* */\n\nfunction transformNode (el, options) {\n var warn = options.warn || baseWarn;\n var staticClass = getAndRemoveAttr(el, 'class');\n if (false) {\n var expression = parseText(staticClass, options.delimiters);\n if (expression) {\n warn(\n \"class=\\\"\" + staticClass + \"\\\": \" +\n 'Interpolation inside attributes has been removed. ' +\n 'Use v-bind or the colon shorthand instead. For example, ' +\n 'instead of <div class=\"{{ val }}\">, use <div :class=\"val\">.'\n );\n }\n }\n if (staticClass) {\n el.staticClass = JSON.stringify(staticClass);\n }\n var classBinding = getBindingAttr(el, 'class', false /* getStatic */);\n if (classBinding) {\n el.classBinding = classBinding;\n }\n}\n\nfunction genData$1 (el) {\n var data = '';\n if (el.staticClass) {\n data += \"staticClass:\" + (el.staticClass) + \",\";\n }\n if (el.classBinding) {\n data += \"class:\" + (el.classBinding) + \",\";\n }\n return data\n}\n\nvar klass$1 = {\n staticKeys: ['staticClass'],\n transformNode: transformNode,\n genData: genData$1\n};\n\n/* */\n\nfunction transformNode$1 (el, options) {\n var warn = options.warn || baseWarn;\n var staticStyle = getAndRemoveAttr(el, 'style');\n if (staticStyle) {\n /* istanbul ignore if */\n if (false) {\n var expression = parseText(staticStyle, options.delimiters);\n if (expression) {\n warn(\n \"style=\\\"\" + staticStyle + \"\\\": \" +\n 'Interpolation inside attributes has been removed. ' +\n 'Use v-bind or the colon shorthand instead. For example, ' +\n 'instead of <div style=\"{{ val }}\">, use <div :style=\"val\">.'\n );\n }\n }\n el.staticStyle = JSON.stringify(parseStyleText(staticStyle));\n }\n\n var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);\n if (styleBinding) {\n el.styleBinding = styleBinding;\n }\n}\n\nfunction genData$2 (el) {\n var data = '';\n if (el.staticStyle) {\n data += \"staticStyle:\" + (el.staticStyle) + \",\";\n }\n if (el.styleBinding) {\n data += \"style:(\" + (el.styleBinding) + \"),\";\n }\n return data\n}\n\nvar style$1 = {\n staticKeys: ['staticStyle'],\n transformNode: transformNode$1,\n genData: genData$2\n};\n\nvar modules$1 = [\n klass$1,\n style$1\n];\n\n/* */\n\nvar warn$3;\n\nfunction model$1 (\n el,\n dir,\n _warn\n) {\n warn$3 = _warn;\n var value = dir.value;\n var modifiers = dir.modifiers;\n var tag = el.tag;\n var type = el.attrsMap.type;\n if (false) {\n var dynamicType = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];\n if (tag === 'input' && dynamicType) {\n warn$3(\n \"<input :type=\\\"\" + dynamicType + \"\\\" v-model=\\\"\" + value + \"\\\">:\\n\" +\n \"v-model does not support dynamic input types. Use v-if branches instead.\"\n );\n }\n }\n if (tag === 'select') {\n genSelect(el, value, modifiers);\n } else if (tag === 'input' && type === 'checkbox') {\n genCheckboxModel(el, value, modifiers);\n } else if (tag === 'input' && type === 'radio') {\n genRadioModel(el, value, modifiers);\n } else {\n genDefaultModel(el, value, modifiers);\n }\n // ensure runtime directive metadata\n return true\n}\n\nfunction genCheckboxModel (\n el,\n value,\n modifiers\n) {\n if (false) {\n warn$3(\n \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" checked>:\\n\" +\n \"inline checked attributes will be ignored when using v-model. \" +\n 'Declare initial values in the component\\'s data option instead.'\n );\n }\n var number = modifiers && modifiers.number;\n var valueBinding = getBindingAttr(el, 'value') || 'null';\n var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';\n var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';\n addProp(el, 'checked',\n \"Array.isArray(\" + value + \")\" +\n \"?_i(\" + value + \",\" + valueBinding + \")>-1\" + (\n trueValueBinding === 'true'\n ? (\":(\" + value + \")\")\n : (\":_q(\" + value + \",\" + trueValueBinding + \")\")\n )\n );\n addHandler(el, 'click',\n \"var $$a=\" + value + \",\" +\n '$$el=$event.target,' +\n \"$$c=$$el.checked?(\" + trueValueBinding + \"):(\" + falseValueBinding + \");\" +\n 'if(Array.isArray($$a)){' +\n \"var $$v=\" + (number ? '_n(' + valueBinding + ')' : valueBinding) + \",\" +\n '$$i=_i($$a,$$v);' +\n \"if($$c){$$i<0&&(\" + value + \"=$$a.concat($$v))}\" +\n \"else{$$i>-1&&(\" + value + \"=$$a.slice(0,$$i).concat($$a.slice($$i+1)))}\" +\n \"}else{\" + value + \"=$$c}\",\n null, true\n );\n}\n\nfunction genRadioModel (\n el,\n value,\n modifiers\n) {\n if (false) {\n warn$3(\n \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" checked>:\\n\" +\n \"inline checked attributes will be ignored when using v-model. \" +\n 'Declare initial values in the component\\'s data option instead.'\n );\n }\n var number = modifiers && modifiers.number;\n var valueBinding = getBindingAttr(el, 'value') || 'null';\n valueBinding = number ? (\"_n(\" + valueBinding + \")\") : valueBinding;\n addProp(el, 'checked', (\"_q(\" + value + \",\" + valueBinding + \")\"));\n addHandler(el, 'click', genAssignmentCode(value, valueBinding), null, true);\n}\n\nfunction genDefaultModel (\n el,\n value,\n modifiers\n) {\n if (false) {\n if (el.tag === 'input' && el.attrsMap.value) {\n warn$3(\n \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" value=\\\"\" + (el.attrsMap.value) + \"\\\">:\\n\" +\n 'inline value attributes will be ignored when using v-model. ' +\n 'Declare initial values in the component\\'s data option instead.'\n );\n }\n if (el.tag === 'textarea' && el.children.length) {\n warn$3(\n \"<textarea v-model=\\\"\" + value + \"\\\">:\\n\" +\n 'inline content inside <textarea> will be ignored when using v-model. ' +\n 'Declare initial values in the component\\'s data option instead.'\n );\n }\n }\n\n var type = el.attrsMap.type;\n var ref = modifiers || {};\n var lazy = ref.lazy;\n var number = ref.number;\n var trim = ref.trim;\n var event = lazy || (isIE && type === 'range') ? 'change' : 'input';\n var needCompositionGuard = !lazy && type !== 'range';\n var isNative = el.tag === 'input' || el.tag === 'textarea';\n\n var valueExpression = isNative\n ? (\"$event.target.value\" + (trim ? '.trim()' : ''))\n : trim ? \"(typeof $event === 'string' ? $event.trim() : $event)\" : \"$event\";\n valueExpression = number || type === 'number'\n ? (\"_n(\" + valueExpression + \")\")\n : valueExpression;\n\n var code = genAssignmentCode(value, valueExpression);\n if (isNative && needCompositionGuard) {\n code = \"if($event.target.composing)return;\" + code;\n }\n\n // inputs with type=\"file\" are read only and setting the input's\n // value will throw an error.\n if (false) {\n warn$3(\n \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" type=\\\"file\\\">:\\n\" +\n \"File inputs are read only. Use a v-on:change listener instead.\"\n );\n }\n\n addProp(el, 'value', isNative ? (\"_s(\" + value + \")\") : (\"(\" + value + \")\"));\n addHandler(el, event, code, null, true);\n if (trim || number || type === 'number') {\n addHandler(el, 'blur', '$forceUpdate()');\n }\n}\n\nfunction genSelect (\n el,\n value,\n modifiers\n) {\n if (false) {\n el.children.some(checkOptionWarning);\n }\n\n var number = modifiers && modifiers.number;\n var assignment = \"Array.prototype.filter\" +\n \".call($event.target.options,function(o){return o.selected})\" +\n \".map(function(o){var val = \\\"_value\\\" in o ? o._value : o.value;\" +\n \"return \" + (number ? '_n(val)' : 'val') + \"})\" +\n (el.attrsMap.multiple == null ? '[0]' : '');\n\n var code = genAssignmentCode(value, assignment);\n addHandler(el, 'change', code, null, true);\n}\n\nfunction checkOptionWarning (option) {\n if (option.type === 1 &&\n option.tag === 'option' &&\n option.attrsMap.selected != null) {\n warn$3(\n \"<select v-model=\\\"\" + (option.parent.attrsMap['v-model']) + \"\\\">:\\n\" +\n 'inline selected attributes on <option> will be ignored when using v-model. ' +\n 'Declare initial values in the component\\'s data option instead.'\n );\n return true\n }\n return false\n}\n\nfunction genAssignmentCode (value, assignment) {\n var modelRs = parseModel(value);\n if (modelRs.idx === null) {\n return (value + \"=\" + assignment)\n } else {\n return \"var $$exp = \" + (modelRs.exp) + \", $$idx = \" + (modelRs.idx) + \";\" +\n \"if (!Array.isArray($$exp)){\" +\n value + \"=\" + assignment + \"}\" +\n \"else{$$exp.splice($$idx, 1, \" + assignment + \")}\"\n }\n}\n\n/* */\n\nfunction text (el, dir) {\n if (dir.value) {\n addProp(el, 'textContent', (\"_s(\" + (dir.value) + \")\"));\n }\n}\n\n/* */\n\nfunction html (el, dir) {\n if (dir.value) {\n addProp(el, 'innerHTML', (\"_s(\" + (dir.value) + \")\"));\n }\n}\n\nvar directives$1 = {\n model: model$1,\n text: text,\n html: html\n};\n\n/* */\n\nvar cache = Object.create(null);\n\nvar baseOptions = {\n expectHTML: true,\n modules: modules$1,\n staticKeys: genStaticKeys(modules$1),\n directives: directives$1,\n isReservedTag: isReservedTag,\n isUnaryTag: isUnaryTag,\n mustUseProp: mustUseProp,\n getTagNamespace: getTagNamespace,\n isPreTag: isPreTag\n};\n\nfunction compile$$1 (\n template,\n options\n) {\n options = options\n ? extend(extend({}, baseOptions), options)\n : baseOptions;\n return compile$1(template, options)\n}\n\nfunction compileToFunctions (\n template,\n options,\n vm\n) {\n var _warn = (options && options.warn) || warn;\n // detect possible CSP restriction\n /* istanbul ignore if */\n if (false) {\n try {\n new Function('return 1');\n } catch (e) {\n if (e.toString().match(/unsafe-eval|CSP/)) {\n _warn(\n 'It seems you are using the standalone build of Vue.js in an ' +\n 'environment with Content Security Policy that prohibits unsafe-eval. ' +\n 'The template compiler cannot work in this environment. Consider ' +\n 'relaxing the policy to allow unsafe-eval or pre-compiling your ' +\n 'templates into render functions.'\n );\n }\n }\n }\n var key = options && options.delimiters\n ? String(options.delimiters) + template\n : template;\n if (cache[key]) {\n return cache[key]\n }\n var res = {};\n var compiled = compile$$1(template, options);\n res.render = makeFunction(compiled.render);\n var l = compiled.staticRenderFns.length;\n res.staticRenderFns = new Array(l);\n for (var i = 0; i < l; i++) {\n res.staticRenderFns[i] = makeFunction(compiled.staticRenderFns[i]);\n }\n if (false) {\n if (res.render === noop || res.staticRenderFns.some(function (fn) { return fn === noop; })) {\n _warn(\n \"failed to compile template:\\n\\n\" + template + \"\\n\\n\" +\n detectErrors(compiled.ast).join('\\n') +\n '\\n\\n',\n vm\n );\n }\n }\n return (cache[key] = res)\n}\n\nfunction makeFunction (code) {\n try {\n return new Function(code)\n } catch (e) {\n return noop\n }\n}\n\n/* */\n\nvar idToTemplate = cached(function (id) {\n var el = query(id);\n return el && el.innerHTML\n});\n\nvar mount = Vue$3.prototype.$mount;\nVue$3.prototype.$mount = function (\n el,\n hydrating\n) {\n el = el && query(el);\n\n /* istanbul ignore if */\n if (el === document.body || el === document.documentElement) {\n \"production\" !== 'production' && warn(\n \"Do not mount Vue to <html> or <body> - mount to normal elements instead.\"\n );\n return this\n }\n\n var options = this.$options;\n // resolve template/el and convert to render function\n if (!options.render) {\n var template = options.template;\n if (template) {\n if (typeof template === 'string') {\n if (template.charAt(0) === '#') {\n template = idToTemplate(template);\n /* istanbul ignore if */\n if (false) {\n warn(\n (\"Template element not found or is empty: \" + (options.template)),\n this\n );\n }\n }\n } else if (template.nodeType) {\n template = template.innerHTML;\n } else {\n if (false) {\n warn('invalid template option:' + template, this);\n }\n return this\n }\n } else if (el) {\n template = getOuterHTML(el);\n }\n if (template) {\n var ref = compileToFunctions(template, {\n warn: warn,\n shouldDecodeNewlines: shouldDecodeNewlines,\n delimiters: options.delimiters\n }, this);\n var render = ref.render;\n var staticRenderFns = ref.staticRenderFns;\n options.render = render;\n options.staticRenderFns = staticRenderFns;\n }\n }\n return mount.call(this, el, hydrating)\n};\n\n/**\n * Get outerHTML of elements, taking care\n * of SVG elements in IE as well.\n */\nfunction getOuterHTML (el) {\n if (el.outerHTML) {\n return el.outerHTML\n } else {\n var container = document.createElement('div');\n container.appendChild(el.cloneNode(true));\n return container.innerHTML\n }\n}\n\nVue$3.compile = compileToFunctions;\n\nmodule.exports = Vue$3;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(82)))\n\n/***/ }),\n/* 17 */\n/***/ (function(module, exports) {\n\nvar toString = {}.toString;\n\nmodule.exports = function(it){\n return toString.call(it).slice(8, -1);\n};\n\n/***/ }),\n/* 18 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// optional / simple context binding\nvar aFunction = __webpack_require__(41);\nmodule.exports = function(fn, that, length){\n aFunction(fn);\n if(that === undefined)return fn;\n switch(length){\n case 1: return function(a){\n return fn.call(that, a);\n };\n case 2: return function(a, b){\n return fn.call(that, a, b);\n };\n case 3: return function(a, b, c){\n return fn.call(that, a, b, c);\n };\n }\n return function(/* ...args */){\n return fn.apply(that, arguments);\n };\n};\n\n/***/ }),\n/* 19 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar isObject = __webpack_require__(11)\n , document = __webpack_require__(1).document\n // in old IE typeof document.createElement is 'object'\n , is = isObject(document) && isObject(document.createElement);\nmodule.exports = function(it){\n return is ? document.createElement(it) : {};\n};\n\n/***/ }),\n/* 20 */\n/***/ (function(module, exports) {\n\n// IE 8- don't enum bug keys\nmodule.exports = (\n 'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'\n).split(',');\n\n/***/ }),\n/* 21 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar global = __webpack_require__(1)\n , core = __webpack_require__(9)\n , ctx = __webpack_require__(18)\n , hide = __webpack_require__(6)\n , PROTOTYPE = 'prototype';\n\nvar $export = function(type, name, source){\n var IS_FORCED = type & $export.F\n , IS_GLOBAL = type & $export.G\n , IS_STATIC = type & $export.S\n , IS_PROTO = type & $export.P\n , IS_BIND = type & $export.B\n , IS_WRAP = type & $export.W\n , exports = IS_GLOBAL ? core : core[name] || (core[name] = {})\n , expProto = exports[PROTOTYPE]\n , target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]\n , key, own, out;\n if(IS_GLOBAL)source = name;\n for(key in source){\n // contains in native\n own = !IS_FORCED && target && target[key] !== undefined;\n if(own && key in exports)continue;\n // export native or passed\n out = own ? target[key] : source[key];\n // prevent global pollution for namespaces\n exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]\n // bind timers to global for call from export context\n : IS_BIND && own ? ctx(out, global)\n // wrap global constructors for prevent change them in library\n : IS_WRAP && target[key] == out ? (function(C){\n var F = function(a, b, c){\n if(this instanceof C){\n switch(arguments.length){\n case 0: return new C;\n case 1: return new C(a);\n case 2: return new C(a, b);\n } return new C(a, b, c);\n } return C.apply(this, arguments);\n };\n F[PROTOTYPE] = C[PROTOTYPE];\n return F;\n // make static versions for prototype methods\n })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;\n // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%\n if(IS_PROTO){\n (exports.virtual || (exports.virtual = {}))[key] = out;\n // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%\n if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out);\n }\n }\n};\n// type bitmap\n$export.F = 1; // forced\n$export.G = 2; // global\n$export.S = 4; // static\n$export.P = 8; // proto\n$export.B = 16; // bind\n$export.W = 32; // wrap\n$export.U = 64; // safe\n$export.R = 128; // real proto method for `library` \nmodule.exports = $export;\n\n/***/ }),\n/* 22 */\n/***/ (function(module, exports) {\n\nmodule.exports = function(exec){\n try {\n return !!exec();\n } catch(e){\n return true;\n }\n};\n\n/***/ }),\n/* 23 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar def = __webpack_require__(7).f\n , has = __webpack_require__(5)\n , TAG = __webpack_require__(0)('toStringTag');\n\nmodule.exports = function(it, tag, stat){\n if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});\n};\n\n/***/ }),\n/* 24 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar global = __webpack_require__(1)\n , SHARED = '__core-js_shared__'\n , store = global[SHARED] || (global[SHARED] = {});\nmodule.exports = function(key){\n return store[key] || (store[key] = {});\n};\n\n/***/ }),\n/* 25 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// to indexed object, toObject with fallback for non-array-like ES3 strings\nvar IObject = __webpack_require__(47)\n , defined = __webpack_require__(10);\nmodule.exports = function(it){\n return IObject(defined(it));\n};\n\n/***/ }),\n/* 26 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// 7.1.15 ToLength\nvar toInteger = __webpack_require__(15)\n , min = Math.min;\nmodule.exports = function(it){\n return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991\n};\n\n/***/ }),\n/* 27 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// 7.1.13 ToObject(argument)\nvar defined = __webpack_require__(10);\nmodule.exports = function(it){\n return Object(defined(it));\n};\n\n/***/ }),\n/* 28 */\n/***/ (function(module, exports) {\n\nvar id = 0\n , px = Math.random();\nmodule.exports = function(key){\n return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));\n};\n\n/***/ }),\n/* 29 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// https://d3js.org Version 4.6.0. Copyright 2017 Mike Bostock.\n(function (global, factory) {\n\t true ? factory(exports) :\n\ttypeof define === 'function' && define.amd ? define(['exports'], factory) :\n\t(factory((global.d3 = global.d3 || {})));\n}(this, (function (exports) { 'use strict';\n\nvar version = \"4.6.0\";\n\nvar ascending = function(a, b) {\n return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;\n};\n\nvar bisector = function(compare) {\n if (compare.length === 1) compare = ascendingComparator(compare);\n return {\n left: function(a, x, lo, hi) {\n if (lo == null) lo = 0;\n if (hi == null) hi = a.length;\n while (lo < hi) {\n var mid = lo + hi >>> 1;\n if (compare(a[mid], x) < 0) lo = mid + 1;\n else hi = mid;\n }\n return lo;\n },\n right: function(a, x, lo, hi) {\n if (lo == null) lo = 0;\n if (hi == null) hi = a.length;\n while (lo < hi) {\n var mid = lo + hi >>> 1;\n if (compare(a[mid], x) > 0) hi = mid;\n else lo = mid + 1;\n }\n return lo;\n }\n };\n};\n\nfunction ascendingComparator(f) {\n return function(d, x) {\n return ascending(f(d), x);\n };\n}\n\nvar ascendingBisect = bisector(ascending);\nvar bisectRight = ascendingBisect.right;\nvar bisectLeft = ascendingBisect.left;\n\nvar descending = function(a, b) {\n return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;\n};\n\nvar number = function(x) {\n return x === null ? NaN : +x;\n};\n\nvar variance = function(array, f) {\n var n = array.length,\n m = 0,\n a,\n d,\n s = 0,\n i = -1,\n j = 0;\n\n if (f == null) {\n while (++i < n) {\n if (!isNaN(a = number(array[i]))) {\n d = a - m;\n m += d / ++j;\n s += d * (a - m);\n }\n }\n }\n\n else {\n while (++i < n) {\n if (!isNaN(a = number(f(array[i], i, array)))) {\n d = a - m;\n m += d / ++j;\n s += d * (a - m);\n }\n }\n }\n\n if (j > 1) return s / (j - 1);\n};\n\nvar deviation = function(array, f) {\n var v = variance(array, f);\n return v ? Math.sqrt(v) : v;\n};\n\nvar extent = function(array, f) {\n var i = -1,\n n = array.length,\n a,\n b,\n c;\n\n if (f == null) {\n while (++i < n) if ((b = array[i]) != null && b >= b) { a = c = b; break; }\n while (++i < n) if ((b = array[i]) != null) {\n if (a > b) a = b;\n if (c < b) c = b;\n }\n }\n\n else {\n while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = c = b; break; }\n while (++i < n) if ((b = f(array[i], i, array)) != null) {\n if (a > b) a = b;\n if (c < b) c = b;\n }\n }\n\n return [a, c];\n};\n\nvar array = Array.prototype;\n\nvar slice = array.slice;\nvar map = array.map;\n\nvar constant = function(x) {\n return function() {\n return x;\n };\n};\n\nvar identity = function(x) {\n return x;\n};\n\nvar sequence = function(start, stop, step) {\n start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;\n\n var i = -1,\n n = Math.max(0, Math.ceil((stop - start) / step)) | 0,\n range = new Array(n);\n\n while (++i < n) {\n range[i] = start + i * step;\n }\n\n return range;\n};\n\nvar e10 = Math.sqrt(50);\nvar e5 = Math.sqrt(10);\nvar e2 = Math.sqrt(2);\n\nvar ticks = function(start, stop, count) {\n var step = tickStep(start, stop, count);\n return sequence(\n Math.ceil(start / step) * step,\n Math.floor(stop / step) * step + step / 2, // inclusive\n step\n );\n};\n\nfunction tickStep(start, stop, count) {\n var step0 = Math.abs(stop - start) / Math.max(0, count),\n step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)),\n error = step0 / step1;\n if (error >= e10) step1 *= 10;\n else if (error >= e5) step1 *= 5;\n else if (error >= e2) step1 *= 2;\n return stop < start ? -step1 : step1;\n}\n\nvar sturges = function(values) {\n return Math.ceil(Math.log(values.length) / Math.LN2) + 1;\n};\n\nvar histogram = function() {\n var value = identity,\n domain = extent,\n threshold = sturges;\n\n function histogram(data) {\n var i,\n n = data.length,\n x,\n values = new Array(n);\n\n for (i = 0; i < n; ++i) {\n values[i] = value(data[i], i, data);\n }\n\n var xz = domain(values),\n x0 = xz[0],\n x1 = xz[1],\n tz = threshold(values, x0, x1);\n\n // Convert number of thresholds into uniform thresholds.\n if (!Array.isArray(tz)) tz = ticks(x0, x1, tz);\n\n // Remove any thresholds outside the domain.\n var m = tz.length;\n while (tz[0] <= x0) tz.shift(), --m;\n while (tz[m - 1] >= x1) tz.pop(), --m;\n\n var bins = new Array(m + 1),\n bin;\n\n // Initialize bins.\n for (i = 0; i <= m; ++i) {\n bin = bins[i] = [];\n bin.x0 = i > 0 ? tz[i - 1] : x0;\n bin.x1 = i < m ? tz[i] : x1;\n }\n\n // Assign data to bins by value, ignoring any outside the domain.\n for (i = 0; i < n; ++i) {\n x = values[i];\n if (x0 <= x && x <= x1) {\n bins[bisectRight(tz, x, 0, m)].push(data[i]);\n }\n }\n\n return bins;\n }\n\n histogram.value = function(_) {\n return arguments.length ? (value = typeof _ === \"function\" ? _ : constant(_), histogram) : value;\n };\n\n histogram.domain = function(_) {\n return arguments.length ? (domain = typeof _ === \"function\" ? _ : constant([_[0], _[1]]), histogram) : domain;\n };\n\n histogram.thresholds = function(_) {\n return arguments.length ? (threshold = typeof _ === \"function\" ? _ : Array.isArray(_) ? constant(slice.call(_)) : constant(_), histogram) : threshold;\n };\n\n return histogram;\n};\n\nvar threshold = function(array, p, f) {\n if (f == null) f = number;\n if (!(n = array.length)) return;\n if ((p = +p) <= 0 || n < 2) return +f(array[0], 0, array);\n if (p >= 1) return +f(array[n - 1], n - 1, array);\n var n,\n h = (n - 1) * p,\n i = Math.floor(h),\n a = +f(array[i], i, array),\n b = +f(array[i + 1], i + 1, array);\n return a + (b - a) * (h - i);\n};\n\nvar freedmanDiaconis = function(values, min, max) {\n values = map.call(values, number).sort(ascending);\n return Math.ceil((max - min) / (2 * (threshold(values, 0.75) - threshold(values, 0.25)) * Math.pow(values.length, -1 / 3)));\n};\n\nvar scott = function(values, min, max) {\n return Math.ceil((max - min) / (3.5 * deviation(values) * Math.pow(values.length, -1 / 3)));\n};\n\nvar max = function(array, f) {\n var i = -1,\n n = array.length,\n a,\n b;\n\n if (f == null) {\n while (++i < n) if ((b = array[i]) != null && b >= b) { a = b; break; }\n while (++i < n) if ((b = array[i]) != null && b > a) a = b;\n }\n\n else {\n while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = b; break; }\n while (++i < n) if ((b = f(array[i], i, array)) != null && b > a) a = b;\n }\n\n return a;\n};\n\nvar mean = function(array, f) {\n var s = 0,\n n = array.length,\n a,\n i = -1,\n j = n;\n\n if (f == null) {\n while (++i < n) if (!isNaN(a = number(array[i]))) s += a; else --j;\n }\n\n else {\n while (++i < n) if (!isNaN(a = number(f(array[i], i, array)))) s += a; else --j;\n }\n\n if (j) return s / j;\n};\n\nvar median = function(array, f) {\n var numbers = [],\n n = array.length,\n a,\n i = -1;\n\n if (f == null) {\n while (++i < n) if (!isNaN(a = number(array[i]))) numbers.push(a);\n }\n\n else {\n while (++i < n) if (!isNaN(a = number(f(array[i], i, array)))) numbers.push(a);\n }\n\n return threshold(numbers.sort(ascending), 0.5);\n};\n\nvar merge = function(arrays) {\n var n = arrays.length,\n m,\n i = -1,\n j = 0,\n merged,\n array;\n\n while (++i < n) j += arrays[i].length;\n merged = new Array(j);\n\n while (--n >= 0) {\n array = arrays[n];\n m = array.length;\n while (--m >= 0) {\n merged[--j] = array[m];\n }\n }\n\n return merged;\n};\n\nvar min = function(array, f) {\n var i = -1,\n n = array.length,\n a,\n b;\n\n if (f == null) {\n while (++i < n) if ((b = array[i]) != null && b >= b) { a = b; break; }\n while (++i < n) if ((b = array[i]) != null && a > b) a = b;\n }\n\n else {\n while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = b; break; }\n while (++i < n) if ((b = f(array[i], i, array)) != null && a > b) a = b;\n }\n\n return a;\n};\n\nvar pairs = function(array) {\n var i = 0, n = array.length - 1, p = array[0], pairs = new Array(n < 0 ? 0 : n);\n while (i < n) pairs[i] = [p, p = array[++i]];\n return pairs;\n};\n\nvar permute = function(array, indexes) {\n var i = indexes.length, permutes = new Array(i);\n while (i--) permutes[i] = array[indexes[i]];\n return permutes;\n};\n\nvar scan = function(array, compare) {\n if (!(n = array.length)) return;\n var i = 0,\n n,\n j = 0,\n xi,\n xj = array[j];\n\n if (!compare) compare = ascending;\n\n while (++i < n) if (compare(xi = array[i], xj) < 0 || compare(xj, xj) !== 0) xj = xi, j = i;\n\n if (compare(xj, xj) === 0) return j;\n};\n\nvar shuffle = function(array, i0, i1) {\n var m = (i1 == null ? array.length : i1) - (i0 = i0 == null ? 0 : +i0),\n t,\n i;\n\n while (m) {\n i = Math.random() * m-- | 0;\n t = array[m + i0];\n array[m + i0] = array[i + i0];\n array[i + i0] = t;\n }\n\n return array;\n};\n\nvar sum = function(array, f) {\n var s = 0,\n n = array.length,\n a,\n i = -1;\n\n if (f == null) {\n while (++i < n) if (a = +array[i]) s += a; // Note: zero and null are equivalent.\n }\n\n else {\n while (++i < n) if (a = +f(array[i], i, array)) s += a;\n }\n\n return s;\n};\n\nvar transpose = function(matrix) {\n if (!(n = matrix.length)) return [];\n for (var i = -1, m = min(matrix, length), transpose = new Array(m); ++i < m;) {\n for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n;) {\n row[j] = matrix[j][i];\n }\n }\n return transpose;\n};\n\nfunction length(d) {\n return d.length;\n}\n\nvar zip = function() {\n return transpose(arguments);\n};\n\nvar slice$1 = Array.prototype.slice;\n\nvar identity$1 = function(x) {\n return x;\n};\n\nvar top = 1;\nvar right = 2;\nvar bottom = 3;\nvar left = 4;\nvar epsilon = 1e-6;\n\nfunction translateX(scale0, scale1, d) {\n var x = scale0(d);\n return \"translate(\" + (isFinite(x) ? x : scale1(d)) + \",0)\";\n}\n\nfunction translateY(scale0, scale1, d) {\n var y = scale0(d);\n return \"translate(0,\" + (isFinite(y) ? y : scale1(d)) + \")\";\n}\n\nfunction center(scale) {\n var offset = scale.bandwidth() / 2;\n if (scale.round()) offset = Math.round(offset);\n return function(d) {\n return scale(d) + offset;\n };\n}\n\nfunction entering() {\n return !this.__axis;\n}\n\nfunction axis(orient, scale) {\n var tickArguments = [],\n tickValues = null,\n tickFormat = null,\n tickSizeInner = 6,\n tickSizeOuter = 6,\n tickPadding = 3;\n\n function axis(context) {\n var values = tickValues == null ? (scale.ticks ? scale.ticks.apply(scale, tickArguments) : scale.domain()) : tickValues,\n format = tickFormat == null ? (scale.tickFormat ? scale.tickFormat.apply(scale, tickArguments) : identity$1) : tickFormat,\n spacing = Math.max(tickSizeInner, 0) + tickPadding,\n transform = orient === top || orient === bottom ? translateX : translateY,\n range = scale.range(),\n range0 = range[0] + 0.5,\n range1 = range[range.length - 1] + 0.5,\n position = (scale.bandwidth ? center : identity$1)(scale.copy()),\n selection = context.selection ? context.selection() : context,\n path = selection.selectAll(\".domain\").data([null]),\n tick = selection.selectAll(\".tick\").data(values, scale).order(),\n tickExit = tick.exit(),\n tickEnter = tick.enter().append(\"g\").attr(\"class\", \"tick\"),\n line = tick.select(\"line\"),\n text = tick.select(\"text\"),\n k = orient === top || orient === left ? -1 : 1,\n x, y = orient === left || orient === right ? (x = \"x\", \"y\") : (x = \"y\", \"x\");\n\n path = path.merge(path.enter().insert(\"path\", \".tick\")\n .attr(\"class\", \"domain\")\n .attr(\"stroke\", \"#000\"));\n\n tick = tick.merge(tickEnter);\n\n line = line.merge(tickEnter.append(\"line\")\n .attr(\"stroke\", \"#000\")\n .attr(x + \"2\", k * tickSizeInner)\n .attr(y + \"1\", 0.5)\n .attr(y + \"2\", 0.5));\n\n text = text.merge(tickEnter.append(\"text\")\n .attr(\"fill\", \"#000\")\n .attr(x, k * spacing)\n .attr(y, 0.5)\n .attr(\"dy\", orient === top ? \"0em\" : orient === bottom ? \"0.71em\" : \"0.32em\"));\n\n if (context !== selection) {\n path = path.transition(context);\n tick = tick.transition(context);\n line = line.transition(context);\n text = text.transition(context);\n\n tickExit = tickExit.transition(context)\n .attr(\"opacity\", epsilon)\n .attr(\"transform\", function(d) { return transform(position, this.parentNode.__axis || position, d); });\n\n tickEnter\n .attr(\"opacity\", epsilon)\n .attr(\"transform\", function(d) { return transform(this.parentNode.__axis || position, position, d); });\n }\n\n tickExit.remove();\n\n path\n .attr(\"d\", orient === left || orient == right\n ? \"M\" + k * tickSizeOuter + \",\" + range0 + \"H0.5V\" + range1 + \"H\" + k * tickSizeOuter\n : \"M\" + range0 + \",\" + k * tickSizeOuter + \"V0.5H\" + range1 + \"V\" + k * tickSizeOuter);\n\n tick\n .attr(\"opacity\", 1)\n .attr(\"transform\", function(d) { return transform(position, position, d); });\n\n line\n .attr(x + \"2\", k * tickSizeInner);\n\n text\n .attr(x, k * spacing)\n .text(format);\n\n selection.filter(entering)\n .attr(\"fill\", \"none\")\n .attr(\"font-size\", 10)\n .attr(\"font-family\", \"sans-serif\")\n .attr(\"text-anchor\", orient === right ? \"start\" : orient === left ? \"end\" : \"middle\");\n\n selection\n .each(function() { this.__axis = position; });\n }\n\n axis.scale = function(_) {\n return arguments.length ? (scale = _, axis) : scale;\n };\n\n axis.ticks = function() {\n return tickArguments = slice$1.call(arguments), axis;\n };\n\n axis.tickArguments = function(_) {\n return arguments.length ? (tickArguments = _ == null ? [] : slice$1.call(_), axis) : tickArguments.slice();\n };\n\n axis.tickValues = function(_) {\n return arguments.length ? (tickValues = _ == null ? null : slice$1.call(_), axis) : tickValues && tickValues.slice();\n };\n\n axis.tickFormat = function(_) {\n return arguments.length ? (tickFormat = _, axis) : tickFormat;\n };\n\n axis.tickSize = function(_) {\n return arguments.length ? (tickSizeInner = tickSizeOuter = +_, axis) : tickSizeInner;\n };\n\n axis.tickSizeInner = function(_) {\n return arguments.length ? (tickSizeInner = +_, axis) : tickSizeInner;\n };\n\n axis.tickSizeOuter = function(_) {\n return arguments.length ? (tickSizeOuter = +_, axis) : tickSizeOuter;\n };\n\n axis.tickPadding = function(_) {\n return arguments.length ? (tickPadding = +_, axis) : tickPadding;\n };\n\n return axis;\n}\n\nfunction axisTop(scale) {\n return axis(top, scale);\n}\n\nfunction axisRight(scale) {\n return axis(right, scale);\n}\n\nfunction axisBottom(scale) {\n return axis(bottom, scale);\n}\n\nfunction axisLeft(scale) {\n return axis(left, scale);\n}\n\nvar noop = {value: function() {}};\n\nfunction dispatch() {\n for (var i = 0, n = arguments.length, _ = {}, t; i < n; ++i) {\n if (!(t = arguments[i] + \"\") || (t in _)) throw new Error(\"illegal type: \" + t);\n _[t] = [];\n }\n return new Dispatch(_);\n}\n\nfunction Dispatch(_) {\n this._ = _;\n}\n\nfunction parseTypenames(typenames, types) {\n return typenames.trim().split(/^|\\s+/).map(function(t) {\n var name = \"\", i = t.indexOf(\".\");\n if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);\n if (t && !types.hasOwnProperty(t)) throw new Error(\"unknown type: \" + t);\n return {type: t, name: name};\n });\n}\n\nDispatch.prototype = dispatch.prototype = {\n constructor: Dispatch,\n on: function(typename, callback) {\n var _ = this._,\n T = parseTypenames(typename + \"\", _),\n t,\n i = -1,\n n = T.length;\n\n // If no callback was specified, return the callback of the given type and name.\n if (arguments.length < 2) {\n while (++i < n) if ((t = (typename = T[i]).type) && (t = get(_[t], typename.name))) return t;\n return;\n }\n\n // If a type was specified, set the callback for the given type and name.\n // Otherwise, if a null callback was specified, remove callbacks of the given name.\n if (callback != null && typeof callback !== \"function\") throw new Error(\"invalid callback: \" + callback);\n while (++i < n) {\n if (t = (typename = T[i]).type) _[t] = set(_[t], typename.name, callback);\n else if (callback == null) for (t in _) _[t] = set(_[t], typename.name, null);\n }\n\n return this;\n },\n copy: function() {\n var copy = {}, _ = this._;\n for (var t in _) copy[t] = _[t].slice();\n return new Dispatch(copy);\n },\n call: function(type, that) {\n if ((n = arguments.length - 2) > 0) for (var args = new Array(n), i = 0, n, t; i < n; ++i) args[i] = arguments[i + 2];\n if (!this._.hasOwnProperty(type)) throw new Error(\"unknown type: \" + type);\n for (t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);\n },\n apply: function(type, that, args) {\n if (!this._.hasOwnProperty(type)) throw new Error(\"unknown type: \" + type);\n for (var t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);\n }\n};\n\nfunction get(type, name) {\n for (var i = 0, n = type.length, c; i < n; ++i) {\n if ((c = type[i]).name === name) {\n return c.value;\n }\n }\n}\n\nfunction set(type, name, callback) {\n for (var i = 0, n = type.length; i < n; ++i) {\n if (type[i].name === name) {\n type[i] = noop, type = type.slice(0, i).concat(type.slice(i + 1));\n break;\n }\n }\n if (callback != null) type.push({name: name, value: callback});\n return type;\n}\n\nvar xhtml = \"http://www.w3.org/1999/xhtml\";\n\nvar namespaces = {\n svg: \"http://www.w3.org/2000/svg\",\n xhtml: xhtml,\n xlink: \"http://www.w3.org/1999/xlink\",\n xml: \"http://www.w3.org/XML/1998/namespace\",\n xmlns: \"http://www.w3.org/2000/xmlns/\"\n};\n\nvar namespace = function(name) {\n var prefix = name += \"\", i = prefix.indexOf(\":\");\n if (i >= 0 && (prefix = name.slice(0, i)) !== \"xmlns\") name = name.slice(i + 1);\n return namespaces.hasOwnProperty(prefix) ? {space: namespaces[prefix], local: name} : name;\n};\n\nfunction creatorInherit(name) {\n return function() {\n var document = this.ownerDocument,\n uri = this.namespaceURI;\n return uri === xhtml && document.documentElement.namespaceURI === xhtml\n ? document.createElement(name)\n : document.createElementNS(uri, name);\n };\n}\n\nfunction creatorFixed(fullname) {\n return function() {\n return this.ownerDocument.createElementNS(fullname.space, fullname.local);\n };\n}\n\nvar creator = function(name) {\n var fullname = namespace(name);\n return (fullname.local\n ? creatorFixed\n : creatorInherit)(fullname);\n};\n\nvar nextId = 0;\n\nfunction local$1() {\n return new Local;\n}\n\nfunction Local() {\n this._ = \"@\" + (++nextId).toString(36);\n}\n\nLocal.prototype = local$1.prototype = {\n constructor: Local,\n get: function(node) {\n var id = this._;\n while (!(id in node)) if (!(node = node.parentNode)) return;\n return node[id];\n },\n set: function(node, value) {\n return node[this._] = value;\n },\n remove: function(node) {\n return this._ in node && delete node[this._];\n },\n toString: function() {\n return this._;\n }\n};\n\nvar matcher = function(selector) {\n return function() {\n return this.matches(selector);\n };\n};\n\nif (typeof document !== \"undefined\") {\n var element = document.documentElement;\n if (!element.matches) {\n var vendorMatches = element.webkitMatchesSelector\n || element.msMatchesSelector\n || element.mozMatchesSelector\n || element.oMatchesSelector;\n matcher = function(selector) {\n return function() {\n return vendorMatches.call(this, selector);\n };\n };\n }\n}\n\nvar matcher$1 = matcher;\n\nvar filterEvents = {};\n\nexports.event = null;\n\nif (typeof document !== \"undefined\") {\n var element$1 = document.documentElement;\n if (!(\"onmouseenter\" in element$1)) {\n filterEvents = {mouseenter: \"mouseover\", mouseleave: \"mouseout\"};\n }\n}\n\nfunction filterContextListener(listener, index, group) {\n listener = contextListener(listener, index, group);\n return function(event) {\n var related = event.relatedTarget;\n if (!related || (related !== this && !(related.compareDocumentPosition(this) & 8))) {\n listener.call(this, event);\n }\n };\n}\n\nfunction contextListener(listener, index, group) {\n return function(event1) {\n var event0 = exports.event; // Events can be reentrant (e.g., focus).\n exports.event = event1;\n try {\n listener.call(this, this.__data__, index, group);\n } finally {\n exports.event = event0;\n }\n };\n}\n\nfunction parseTypenames$1(typenames) {\n return typenames.trim().split(/^|\\s+/).map(function(t) {\n var name = \"\", i = t.indexOf(\".\");\n if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);\n return {type: t, name: name};\n });\n}\n\nfunction onRemove(typename) {\n return function() {\n var on = this.__on;\n if (!on) return;\n for (var j = 0, i = -1, m = on.length, o; j < m; ++j) {\n if (o = on[j], (!typename.type || o.type === typename.type) && o.name === typename.name) {\n this.removeEventListener(o.type, o.listener, o.capture);\n } else {\n on[++i] = o;\n }\n }\n if (++i) on.length = i;\n else delete this.__on;\n };\n}\n\nfunction onAdd(typename, value, capture) {\n var wrap = filterEvents.hasOwnProperty(typename.type) ? filterContextListener : contextListener;\n return function(d, i, group) {\n var on = this.__on, o, listener = wrap(value, i, group);\n if (on) for (var j = 0, m = on.length; j < m; ++j) {\n if ((o = on[j]).type === typename.type && o.name === typename.name) {\n this.removeEventListener(o.type, o.listener, o.capture);\n this.addEventListener(o.type, o.listener = listener, o.capture = capture);\n o.value = value;\n return;\n }\n }\n this.addEventListener(typename.type, listener, capture);\n o = {type: typename.type, name: typename.name, value: value, listener: listener, capture: capture};\n if (!on) this.__on = [o];\n else on.push(o);\n };\n}\n\nvar selection_on = function(typename, value, capture) {\n var typenames = parseTypenames$1(typename + \"\"), i, n = typenames.length, t;\n\n if (arguments.length < 2) {\n var on = this.node().__on;\n if (on) for (var j = 0, m = on.length, o; j < m; ++j) {\n for (i = 0, o = on[j]; i < n; ++i) {\n if ((t = typenames[i]).type === o.type && t.name === o.name) {\n return o.value;\n }\n }\n }\n return;\n }\n\n on = value ? onAdd : onRemove;\n if (capture == null) capture = false;\n for (i = 0; i < n; ++i) this.each(on(typenames[i], value, capture));\n return this;\n};\n\nfunction customEvent(event1, listener, that, args) {\n var event0 = exports.event;\n event1.sourceEvent = exports.event;\n exports.event = event1;\n try {\n return listener.apply(that, args);\n } finally {\n exports.event = event0;\n }\n}\n\nvar sourceEvent = function() {\n var current = exports.event, source;\n while (source = current.sourceEvent) current = source;\n return current;\n};\n\nvar point = function(node, event) {\n var svg = node.ownerSVGElement || node;\n\n if (svg.createSVGPoint) {\n var point = svg.createSVGPoint();\n point.x = event.clientX, point.y = event.clientY;\n point = point.matrixTransform(node.getScreenCTM().inverse());\n return [point.x, point.y];\n }\n\n var rect = node.getBoundingClientRect();\n return [event.clientX - rect.left - node.clientLeft, event.clientY - rect.top - node.clientTop];\n};\n\nvar mouse = function(node) {\n var event = sourceEvent();\n if (event.changedTouches) event = event.changedTouches[0];\n return point(node, event);\n};\n\nfunction none() {}\n\nvar selector = function(selector) {\n return selector == null ? none : function() {\n return this.querySelector(selector);\n };\n};\n\nvar selection_select = function(select) {\n if (typeof select !== \"function\") select = selector(select);\n\n for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {\n for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) {\n if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) {\n if (\"__data__\" in node) subnode.__data__ = node.__data__;\n subgroup[i] = subnode;\n }\n }\n }\n\n return new Selection(subgroups, this._parents);\n};\n\nfunction empty$1() {\n return [];\n}\n\nvar selectorAll = function(selector) {\n return selector == null ? empty$1 : function() {\n return this.querySelectorAll(selector);\n };\n};\n\nvar selection_selectAll = function(select) {\n if (typeof select !== \"function\") select = selectorAll(select);\n\n for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) {\n for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {\n if (node = group[i]) {\n subgroups.push(select.call(node, node.__data__, i, group));\n parents.push(node);\n }\n }\n }\n\n return new Selection(subgroups, parents);\n};\n\nvar selection_filter = function(match) {\n if (typeof match !== \"function\") match = matcher$1(match);\n\n for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {\n for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) {\n if ((node = group[i]) && match.call(node, node.__data__, i, group)) {\n subgroup.push(node);\n }\n }\n }\n\n return new Selection(subgroups, this._parents);\n};\n\nvar sparse = function(update) {\n return new Array(update.length);\n};\n\nvar selection_enter = function() {\n return new Selection(this._enter || this._groups.map(sparse), this._parents);\n};\n\nfunction EnterNode(parent, datum) {\n this.ownerDocument = parent.ownerDocument;\n this.namespaceURI = parent.namespaceURI;\n this._next = null;\n this._parent = parent;\n this.__data__ = datum;\n}\n\nEnterNode.prototype = {\n constructor: EnterNode,\n appendChild: function(child) { return this._parent.insertBefore(child, this._next); },\n insertBefore: function(child, next) { return this._parent.insertBefore(child, next); },\n querySelector: function(selector) { return this._parent.querySelector(selector); },\n querySelectorAll: function(selector) { return this._parent.querySelectorAll(selector); }\n};\n\nvar constant$1 = function(x) {\n return function() {\n return x;\n };\n};\n\nvar keyPrefix = \"$\"; // Protect against keys like “__proto__”.\n\nfunction bindIndex(parent, group, enter, update, exit, data) {\n var i = 0,\n node,\n groupLength = group.length,\n dataLength = data.length;\n\n // Put any non-null nodes that fit into update.\n // Put any null nodes into enter.\n // Put any remaining data into enter.\n for (; i < dataLength; ++i) {\n if (node = group[i]) {\n node.__data__ = data[i];\n update[i] = node;\n } else {\n enter[i] = new EnterNode(parent, data[i]);\n }\n }\n\n // Put any non-null nodes that don’t fit into exit.\n for (; i < groupLength; ++i) {\n if (node = group[i]) {\n exit[i] = node;\n }\n }\n}\n\nfunction bindKey(parent, group, enter, update, exit, data, key) {\n var i,\n node,\n nodeByKeyValue = {},\n groupLength = group.length,\n dataLength = data.length,\n keyValues = new Array(groupLength),\n keyValue;\n\n // Compute the key for each node.\n // If multiple nodes have the same key, the duplicates are added to exit.\n for (i = 0; i < groupLength; ++i) {\n if (node = group[i]) {\n keyValues[i] = keyValue = keyPrefix + key.call(node, node.__data__, i, group);\n if (keyValue in nodeByKeyValue) {\n exit[i] = node;\n } else {\n nodeByKeyValue[keyValue] = node;\n }\n }\n }\n\n // Compute the key for each datum.\n // If there a node associated with this key, join and add it to update.\n // If there is not (or the key is a duplicate), add it to enter.\n for (i = 0; i < dataLength; ++i) {\n keyValue = keyPrefix + key.call(parent, data[i], i, data);\n if (node = nodeByKeyValue[keyValue]) {\n update[i] = node;\n node.__data__ = data[i];\n nodeByKeyValue[keyValue] = null;\n } else {\n enter[i] = new EnterNode(parent, data[i]);\n }\n }\n\n // Add any remaining nodes that were not bound to data to exit.\n for (i = 0; i < groupLength; ++i) {\n if ((node = group[i]) && (nodeByKeyValue[keyValues[i]] === node)) {\n exit[i] = node;\n }\n }\n}\n\nvar selection_data = function(value, key) {\n if (!value) {\n data = new Array(this.size()), j = -1;\n this.each(function(d) { data[++j] = d; });\n return data;\n }\n\n var bind = key ? bindKey : bindIndex,\n parents = this._parents,\n groups = this._groups;\n\n if (typeof value !== \"function\") value = constant$1(value);\n\n for (var m = groups.length, update = new Array(m), enter = new Array(m), exit = new Array(m), j = 0; j < m; ++j) {\n var parent = parents[j],\n group = groups[j],\n groupLength = group.length,\n data = value.call(parent, parent && parent.__data__, j, parents),\n dataLength = data.length,\n enterGroup = enter[j] = new Array(dataLength),\n updateGroup = update[j] = new Array(dataLength),\n exitGroup = exit[j] = new Array(groupLength);\n\n bind(parent, group, enterGroup, updateGroup, exitGroup, data, key);\n\n // Now connect the enter nodes to their following update node, such that\n // appendChild can insert the materialized enter node before this node,\n // rather than at the end of the parent node.\n for (var i0 = 0, i1 = 0, previous, next; i0 < dataLength; ++i0) {\n if (previous = enterGroup[i0]) {\n if (i0 >= i1) i1 = i0 + 1;\n while (!(next = updateGroup[i1]) && ++i1 < dataLength);\n previous._next = next || null;\n }\n }\n }\n\n update = new Selection(update, parents);\n update._enter = enter;\n update._exit = exit;\n return update;\n};\n\nvar selection_exit = function() {\n return new Selection(this._exit || this._groups.map(sparse), this._parents);\n};\n\nvar selection_merge = function(selection) {\n\n for (var groups0 = this._groups, groups1 = selection._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) {\n for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) {\n if (node = group0[i] || group1[i]) {\n merge[i] = node;\n }\n }\n }\n\n for (; j < m0; ++j) {\n merges[j] = groups0[j];\n }\n\n return new Selection(merges, this._parents);\n};\n\nvar selection_order = function() {\n\n for (var groups = this._groups, j = -1, m = groups.length; ++j < m;) {\n for (var group = groups[j], i = group.length - 1, next = group[i], node; --i >= 0;) {\n if (node = group[i]) {\n if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next);\n next = node;\n }\n }\n }\n\n return this;\n};\n\nvar selection_sort = function(compare) {\n if (!compare) compare = ascending$1;\n\n function compareNode(a, b) {\n return a && b ? compare(a.__data__, b.__data__) : !a - !b;\n }\n\n for (var groups = this._groups, m = groups.length, sortgroups = new Array(m), j = 0; j < m; ++j) {\n for (var group = groups[j], n = group.length, sortgroup = sortgroups[j] = new Array(n), node, i = 0; i < n; ++i) {\n if (node = group[i]) {\n sortgroup[i] = node;\n }\n }\n sortgroup.sort(compareNode);\n }\n\n return new Selection(sortgroups, this._parents).order();\n};\n\nfunction ascending$1(a, b) {\n return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;\n}\n\nvar selection_call = function() {\n var callback = arguments[0];\n arguments[0] = this;\n callback.apply(null, arguments);\n return this;\n};\n\nvar selection_nodes = function() {\n var nodes = new Array(this.size()), i = -1;\n this.each(function() { nodes[++i] = this; });\n return nodes;\n};\n\nvar selection_node = function() {\n\n for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {\n for (var group = groups[j], i = 0, n = group.length; i < n; ++i) {\n var node = group[i];\n if (node) return node;\n }\n }\n\n return null;\n};\n\nvar selection_size = function() {\n var size = 0;\n this.each(function() { ++size; });\n return size;\n};\n\nvar selection_empty = function() {\n return !this.node();\n};\n\nvar selection_each = function(callback) {\n\n for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {\n for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) {\n if (node = group[i]) callback.call(node, node.__data__, i, group);\n }\n }\n\n return this;\n};\n\nfunction attrRemove(name) {\n return function() {\n this.removeAttribute(name);\n };\n}\n\nfunction attrRemoveNS(fullname) {\n return function() {\n this.removeAttributeNS(fullname.space, fullname.local);\n };\n}\n\nfunction attrConstant(name, value) {\n return function() {\n this.setAttribute(name, value);\n };\n}\n\nfunction attrConstantNS(fullname, value) {\n return function() {\n this.setAttributeNS(fullname.space, fullname.local, value);\n };\n}\n\nfunction attrFunction(name, value) {\n return function() {\n var v = value.apply(this, arguments);\n if (v == null) this.removeAttribute(name);\n else this.setAttribute(name, v);\n };\n}\n\nfunction attrFunctionNS(fullname, value) {\n return function() {\n var v = value.apply(this, arguments);\n if (v == null) this.removeAttributeNS(fullname.space, fullname.local);\n else this.setAttributeNS(fullname.space, fullname.local, v);\n };\n}\n\nvar selection_attr = function(name, value) {\n var fullname = namespace(name);\n\n if (arguments.length < 2) {\n var node = this.node();\n return fullname.local\n ? node.getAttributeNS(fullname.space, fullname.local)\n : node.getAttribute(fullname);\n }\n\n return this.each((value == null\n ? (fullname.local ? attrRemoveNS : attrRemove) : (typeof value === \"function\"\n ? (fullname.local ? attrFunctionNS : attrFunction)\n : (fullname.local ? attrConstantNS : attrConstant)))(fullname, value));\n};\n\nvar window = function(node) {\n return (node.ownerDocument && node.ownerDocument.defaultView) // node is a Node\n || (node.document && node) // node is a Window\n || node.defaultView; // node is a Document\n};\n\nfunction styleRemove(name) {\n return function() {\n this.style.removeProperty(name);\n };\n}\n\nfunction styleConstant(name, value, priority) {\n return function() {\n this.style.setProperty(name, value, priority);\n };\n}\n\nfunction styleFunction(name, value, priority) {\n return function() {\n var v = value.apply(this, arguments);\n if (v == null) this.style.removeProperty(name);\n else this.style.setProperty(name, v, priority);\n };\n}\n\nvar selection_style = function(name, value, priority) {\n var node;\n return arguments.length > 1\n ? this.each((value == null\n ? styleRemove : typeof value === \"function\"\n ? styleFunction\n : styleConstant)(name, value, priority == null ? \"\" : priority))\n : window(node = this.node())\n .getComputedStyle(node, null)\n .getPropertyValue(name);\n};\n\nfunction propertyRemove(name) {\n return function() {\n delete this[name];\n };\n}\n\nfunction propertyConstant(name, value) {\n return function() {\n this[name] = value;\n };\n}\n\nfunction propertyFunction(name, value) {\n return function() {\n var v = value.apply(this, arguments);\n if (v == null) delete this[name];\n else this[name] = v;\n };\n}\n\nvar selection_property = function(name, value) {\n return arguments.length > 1\n ? this.each((value == null\n ? propertyRemove : typeof value === \"function\"\n ? propertyFunction\n : propertyConstant)(name, value))\n : this.node()[name];\n};\n\nfunction classArray(string) {\n return string.trim().split(/^|\\s+/);\n}\n\nfunction classList(node) {\n return node.classList || new ClassList(node);\n}\n\nfunction ClassList(node) {\n this._node = node;\n this._names = classArray(node.getAttribute(\"class\") || \"\");\n}\n\nClassList.prototype = {\n add: function(name) {\n var i = this._names.indexOf(name);\n if (i < 0) {\n this._names.push(name);\n this._node.setAttribute(\"class\", this._names.join(\" \"));\n }\n },\n remove: function(name) {\n var i = this._names.indexOf(name);\n if (i >= 0) {\n this._names.splice(i, 1);\n this._node.setAttribute(\"class\", this._names.join(\" \"));\n }\n },\n contains: function(name) {\n return this._names.indexOf(name) >= 0;\n }\n};\n\nfunction classedAdd(node, names) {\n var list = classList(node), i = -1, n = names.length;\n while (++i < n) list.add(names[i]);\n}\n\nfunction classedRemove(node, names) {\n var list = classList(node), i = -1, n = names.length;\n while (++i < n) list.remove(names[i]);\n}\n\nfunction classedTrue(names) {\n return function() {\n classedAdd(this, names);\n };\n}\n\nfunction classedFalse(names) {\n return function() {\n classedRemove(this, names);\n };\n}\n\nfunction classedFunction(names, value) {\n return function() {\n (value.apply(this, arguments) ? classedAdd : classedRemove)(this, names);\n };\n}\n\nvar selection_classed = function(name, value) {\n var names = classArray(name + \"\");\n\n if (arguments.length < 2) {\n var list = classList(this.node()), i = -1, n = names.length;\n while (++i < n) if (!list.contains(names[i])) return false;\n return true;\n }\n\n return this.each((typeof value === \"function\"\n ? classedFunction : value\n ? classedTrue\n : classedFalse)(names, value));\n};\n\nfunction textRemove() {\n this.textContent = \"\";\n}\n\nfunction textConstant(value) {\n return function() {\n this.textContent = value;\n };\n}\n\nfunction textFunction(value) {\n return function() {\n var v = value.apply(this, arguments);\n this.textContent = v == null ? \"\" : v;\n };\n}\n\nvar selection_text = function(value) {\n return arguments.length\n ? this.each(value == null\n ? textRemove : (typeof value === \"function\"\n ? textFunction\n : textConstant)(value))\n : this.node().textContent;\n};\n\nfunction htmlRemove() {\n this.innerHTML = \"\";\n}\n\nfunction htmlConstant(value) {\n return function() {\n this.innerHTML = value;\n };\n}\n\nfunction htmlFunction(value) {\n return function() {\n var v = value.apply(this, arguments);\n this.innerHTML = v == null ? \"\" : v;\n };\n}\n\nvar selection_html = function(value) {\n return arguments.length\n ? this.each(value == null\n ? htmlRemove : (typeof value === \"function\"\n ? htmlFunction\n : htmlConstant)(value))\n : this.node().innerHTML;\n};\n\nfunction raise() {\n if (this.nextSibling) this.parentNode.appendChild(this);\n}\n\nvar selection_raise = function() {\n return this.each(raise);\n};\n\nfunction lower() {\n if (this.previousSibling) this.parentNode.insertBefore(this, this.parentNode.firstChild);\n}\n\nvar selection_lower = function() {\n return this.each(lower);\n};\n\nvar selection_append = function(name) {\n var create = typeof name === \"function\" ? name : creator(name);\n return this.select(function() {\n return this.appendChild(create.apply(this, arguments));\n });\n};\n\nfunction constantNull() {\n return null;\n}\n\nvar selection_insert = function(name, before) {\n var create = typeof name === \"function\" ? name : creator(name),\n select = before == null ? constantNull : typeof before === \"function\" ? before : selector(before);\n return this.select(function() {\n return this.insertBefore(create.apply(this, arguments), select.apply(this, arguments) || null);\n });\n};\n\nfunction remove() {\n var parent = this.parentNode;\n if (parent) parent.removeChild(this);\n}\n\nvar selection_remove = function() {\n return this.each(remove);\n};\n\nvar selection_datum = function(value) {\n return arguments.length\n ? this.property(\"__data__\", value)\n : this.node().__data__;\n};\n\nfunction dispatchEvent(node, type, params) {\n var window$$1 = window(node),\n event = window$$1.CustomEvent;\n\n if (event) {\n event = new event(type, params);\n } else {\n event = window$$1.document.createEvent(\"Event\");\n if (params) event.initEvent(type, params.bubbles, params.cancelable), event.detail = params.detail;\n else event.initEvent(type, false, false);\n }\n\n node.dispatchEvent(event);\n}\n\nfunction dispatchConstant(type, params) {\n return function() {\n return dispatchEvent(this, type, params);\n };\n}\n\nfunction dispatchFunction(type, params) {\n return function() {\n return dispatchEvent(this, type, params.apply(this, arguments));\n };\n}\n\nvar selection_dispatch = function(type, params) {\n return this.each((typeof params === \"function\"\n ? dispatchFunction\n : dispatchConstant)(type, params));\n};\n\nvar root = [null];\n\nfunction Selection(groups, parents) {\n this._groups = groups;\n this._parents = parents;\n}\n\nfunction selection() {\n return new Selection([[document.documentElement]], root);\n}\n\nSelection.prototype = selection.prototype = {\n constructor: Selection,\n select: selection_select,\n selectAll: selection_selectAll,\n filter: selection_filter,\n data: selection_data,\n enter: selection_enter,\n exit: selection_exit,\n merge: selection_merge,\n order: selection_order,\n sort: selection_sort,\n call: selection_call,\n nodes: selection_nodes,\n node: selection_node,\n size: selection_size,\n empty: selection_empty,\n each: selection_each,\n attr: selection_attr,\n style: selection_style,\n property: selection_property,\n classed: selection_classed,\n text: selection_text,\n html: selection_html,\n raise: selection_raise,\n lower: selection_lower,\n append: selection_append,\n insert: selection_insert,\n remove: selection_remove,\n datum: selection_datum,\n on: selection_on,\n dispatch: selection_dispatch\n};\n\nvar select = function(selector) {\n return typeof selector === \"string\"\n ? new Selection([[document.querySelector(selector)]], [document.documentElement])\n : new Selection([[selector]], root);\n};\n\nvar selectAll = function(selector) {\n return typeof selector === \"string\"\n ? new Selection([document.querySelectorAll(selector)], [document.documentElement])\n : new Selection([selector == null ? [] : selector], root);\n};\n\nvar touch = function(node, touches, identifier) {\n if (arguments.length < 3) identifier = touches, touches = sourceEvent().changedTouches;\n\n for (var i = 0, n = touches ? touches.length : 0, touch; i < n; ++i) {\n if ((touch = touches[i]).identifier === identifier) {\n return point(node, touch);\n }\n }\n\n return null;\n};\n\nvar touches = function(node, touches) {\n if (touches == null) touches = sourceEvent().touches;\n\n for (var i = 0, n = touches ? touches.length : 0, points = new Array(n); i < n; ++i) {\n points[i] = point(node, touches[i]);\n }\n\n return points;\n};\n\nfunction nopropagation() {\n exports.event.stopImmediatePropagation();\n}\n\nvar noevent = function() {\n exports.event.preventDefault();\n exports.event.stopImmediatePropagation();\n};\n\nvar dragDisable = function(view) {\n var root = view.document.documentElement,\n selection$$1 = select(view).on(\"dragstart.drag\", noevent, true);\n if (\"onselectstart\" in root) {\n selection$$1.on(\"selectstart.drag\", noevent, true);\n } else {\n root.__noselect = root.style.MozUserSelect;\n root.style.MozUserSelect = \"none\";\n }\n};\n\nfunction yesdrag(view, noclick) {\n var root = view.document.documentElement,\n selection$$1 = select(view).on(\"dragstart.drag\", null);\n if (noclick) {\n selection$$1.on(\"click.drag\", noevent, true);\n setTimeout(function() { selection$$1.on(\"click.drag\", null); }, 0);\n }\n if (\"onselectstart\" in root) {\n selection$$1.on(\"selectstart.drag\", null);\n } else {\n root.style.MozUserSelect = root.__noselect;\n delete root.__noselect;\n }\n}\n\nvar constant$2 = function(x) {\n return function() {\n return x;\n };\n};\n\nfunction DragEvent(target, type, subject, id, active, x, y, dx, dy, dispatch) {\n this.target = target;\n this.type = type;\n this.subject = subject;\n this.identifier = id;\n this.active = active;\n this.x = x;\n this.y = y;\n this.dx = dx;\n this.dy = dy;\n this._ = dispatch;\n}\n\nDragEvent.prototype.on = function() {\n var value = this._.on.apply(this._, arguments);\n return value === this._ ? this : value;\n};\n\n// Ignore right-click, since that should open the context menu.\nfunction defaultFilter$1() {\n return !exports.event.button;\n}\n\nfunction defaultContainer() {\n return this.parentNode;\n}\n\nfunction defaultSubject(d) {\n return d == null ? {x: exports.event.x, y: exports.event.y} : d;\n}\n\nvar drag = function() {\n var filter = defaultFilter$1,\n container = defaultContainer,\n subject = defaultSubject,\n gestures = {},\n listeners = dispatch(\"start\", \"drag\", \"end\"),\n active = 0,\n mousemoving,\n touchending;\n\n function drag(selection$$1) {\n selection$$1\n .on(\"mousedown.drag\", mousedowned)\n .on(\"touchstart.drag\", touchstarted)\n .on(\"touchmove.drag\", touchmoved)\n .on(\"touchend.drag touchcancel.drag\", touchended)\n .style(\"-webkit-tap-highlight-color\", \"rgba(0,0,0,0)\");\n }\n\n function mousedowned() {\n if (touchending || !filter.apply(this, arguments)) return;\n var gesture = beforestart(\"mouse\", container.apply(this, arguments), mouse, this, arguments);\n if (!gesture) return;\n select(exports.event.view).on(\"mousemove.drag\", mousemoved, true).on(\"mouseup.drag\", mouseupped, true);\n dragDisable(exports.event.view);\n nopropagation();\n mousemoving = false;\n gesture(\"start\");\n }\n\n function mousemoved() {\n noevent();\n mousemoving = true;\n gestures.mouse(\"drag\");\n }\n\n function mouseupped() {\n select(exports.event.view).on(\"mousemove.drag mouseup.drag\", null);\n yesdrag(exports.event.view, mousemoving);\n noevent();\n gestures.mouse(\"end\");\n }\n\n function touchstarted() {\n if (!filter.apply(this, arguments)) return;\n var touches$$1 = exports.event.changedTouches,\n c = container.apply(this, arguments),\n n = touches$$1.length, i, gesture;\n\n for (i = 0; i < n; ++i) {\n if (gesture = beforestart(touches$$1[i].identifier, c, touch, this, arguments)) {\n nopropagation();\n gesture(\"start\");\n }\n }\n }\n\n function touchmoved() {\n var touches$$1 = exports.event.changedTouches,\n n = touches$$1.length, i, gesture;\n\n for (i = 0; i < n; ++i) {\n if (gesture = gestures[touches$$1[i].identifier]) {\n noevent();\n gesture(\"drag\");\n }\n }\n }\n\n function touchended() {\n var touches$$1 = exports.event.changedTouches,\n n = touches$$1.length, i, gesture;\n\n if (touchending) clearTimeout(touchending);\n touchending = setTimeout(function() { touchending = null; }, 500); // Ghost clicks are delayed!\n for (i = 0; i < n; ++i) {\n if (gesture = gestures[touches$$1[i].identifier]) {\n nopropagation();\n gesture(\"end\");\n }\n }\n }\n\n function beforestart(id, container, point, that, args) {\n var p = point(container, id), s, dx, dy,\n sublisteners = listeners.copy();\n\n if (!customEvent(new DragEvent(drag, \"beforestart\", s, id, active, p[0], p[1], 0, 0, sublisteners), function() {\n if ((exports.event.subject = s = subject.apply(that, args)) == null) return false;\n dx = s.x - p[0] || 0;\n dy = s.y - p[1] || 0;\n return true;\n })) return;\n\n return function gesture(type) {\n var p0 = p, n;\n switch (type) {\n case \"start\": gestures[id] = gesture, n = active++; break;\n case \"end\": delete gestures[id], --active; // nobreak\n case \"drag\": p = point(container, id), n = active; break;\n }\n customEvent(new DragEvent(drag, type, s, id, n, p[0] + dx, p[1] + dy, p[0] - p0[0], p[1] - p0[1], sublisteners), sublisteners.apply, sublisteners, [type, that, args]);\n };\n }\n\n drag.filter = function(_) {\n return arguments.length ? (filter = typeof _ === \"function\" ? _ : constant$2(!!_), drag) : filter;\n };\n\n drag.container = function(_) {\n return arguments.length ? (container = typeof _ === \"function\" ? _ : constant$2(_), drag) : container;\n };\n\n drag.subject = function(_) {\n return arguments.length ? (subject = typeof _ === \"function\" ? _ : constant$2(_), drag) : subject;\n };\n\n drag.on = function() {\n var value = listeners.on.apply(listeners, arguments);\n return value === listeners ? drag : value;\n };\n\n return drag;\n};\n\nvar define = function(constructor, factory, prototype) {\n constructor.prototype = factory.prototype = prototype;\n prototype.constructor = constructor;\n};\n\nfunction extend(parent, definition) {\n var prototype = Object.create(parent.prototype);\n for (var key in definition) prototype[key] = definition[key];\n return prototype;\n}\n\nfunction Color() {}\n\nvar darker = 0.7;\nvar brighter = 1 / darker;\n\nvar reI = \"\\\\s*([+-]?\\\\d+)\\\\s*\";\nvar reN = \"\\\\s*([+-]?\\\\d*\\\\.?\\\\d+(?:[eE][+-]?\\\\d+)?)\\\\s*\";\nvar reP = \"\\\\s*([+-]?\\\\d*\\\\.?\\\\d+(?:[eE][+-]?\\\\d+)?)%\\\\s*\";\nvar reHex3 = /^#([0-9a-f]{3})$/;\nvar reHex6 = /^#([0-9a-f]{6})$/;\nvar reRgbInteger = new RegExp(\"^rgb\\\\(\" + [reI, reI, reI] + \"\\\\)$\");\nvar reRgbPercent = new RegExp(\"^rgb\\\\(\" + [reP, reP, reP] + \"\\\\)$\");\nvar reRgbaInteger = new RegExp(\"^rgba\\\\(\" + [reI, reI, reI, reN] + \"\\\\)$\");\nvar reRgbaPercent = new RegExp(\"^rgba\\\\(\" + [reP, reP, reP, reN] + \"\\\\)$\");\nvar reHslPercent = new RegExp(\"^hsl\\\\(\" + [reN, reP, reP] + \"\\\\)$\");\nvar reHslaPercent = new RegExp(\"^hsla\\\\(\" + [reN, reP, reP, reN] + \"\\\\)$\");\n\nvar named = {\n aliceblue: 0xf0f8ff,\n antiquewhite: 0xfaebd7,\n aqua: 0x00ffff,\n aquamarine: 0x7fffd4,\n azure: 0xf0ffff,\n beige: 0xf5f5dc,\n bisque: 0xffe4c4,\n black: 0x000000,\n blanchedalmond: 0xffebcd,\n blue: 0x0000ff,\n blueviolet: 0x8a2be2,\n brown: 0xa52a2a,\n burlywood: 0xdeb887,\n cadetblue: 0x5f9ea0,\n chartreuse: 0x7fff00,\n chocolate: 0xd2691e,\n coral: 0xff7f50,\n cornflowerblue: 0x6495ed,\n cornsilk: 0xfff8dc,\n crimson: 0xdc143c,\n cyan: 0x00ffff,\n darkblue: 0x00008b,\n darkcyan: 0x008b8b,\n darkgoldenrod: 0xb8860b,\n darkgray: 0xa9a9a9,\n darkgreen: 0x006400,\n darkgrey: 0xa9a9a9,\n darkkhaki: 0xbdb76b,\n darkmagenta: 0x8b008b,\n darkolivegreen: 0x556b2f,\n darkorange: 0xff8c00,\n darkorchid: 0x9932cc,\n darkred: 0x8b0000,\n darksalmon: 0xe9967a,\n darkseagreen: 0x8fbc8f,\n darkslateblue: 0x483d8b,\n darkslategray: 0x2f4f4f,\n darkslategrey: 0x2f4f4f,\n darkturquoise: 0x00ced1,\n darkviolet: 0x9400d3,\n deeppink: 0xff1493,\n deepskyblue: 0x00bfff,\n dimgray: 0x696969,\n dimgrey: 0x696969,\n dodgerblue: 0x1e90ff,\n firebrick: 0xb22222,\n floralwhite: 0xfffaf0,\n forestgreen: 0x228b22,\n fuchsia: 0xff00ff,\n gainsboro: 0xdcdcdc,\n ghostwhite: 0xf8f8ff,\n gold: 0xffd700,\n goldenrod: 0xdaa520,\n gray: 0x808080,\n green: 0x008000,\n greenyellow: 0xadff2f,\n grey: 0x808080,\n honeydew: 0xf0fff0,\n hotpink: 0xff69b4,\n indianred: 0xcd5c5c,\n indigo: 0x4b0082,\n ivory: 0xfffff0,\n khaki: 0xf0e68c,\n lavender: 0xe6e6fa,\n lavenderblush: 0xfff0f5,\n lawngreen: 0x7cfc00,\n lemonchiffon: 0xfffacd,\n lightblue: 0xadd8e6,\n lightcoral: 0xf08080,\n lightcyan: 0xe0ffff,\n lightgoldenrodyellow: 0xfafad2,\n lightgray: 0xd3d3d3,\n lightgreen: 0x90ee90,\n lightgrey: 0xd3d3d3,\n lightpink: 0xffb6c1,\n lightsalmon: 0xffa07a,\n lightseagreen: 0x20b2aa,\n lightskyblue: 0x87cefa,\n lightslategray: 0x778899,\n lightslategrey: 0x778899,\n lightsteelblue: 0xb0c4de,\n lightyellow: 0xffffe0,\n lime: 0x00ff00,\n limegreen: 0x32cd32,\n linen: 0xfaf0e6,\n magenta: 0xff00ff,\n maroon: 0x800000,\n mediumaquamarine: 0x66cdaa,\n mediumblue: 0x0000cd,\n mediumorchid: 0xba55d3,\n mediumpurple: 0x9370db,\n mediumseagreen: 0x3cb371,\n mediumslateblue: 0x7b68ee,\n mediumspringgreen: 0x00fa9a,\n mediumturquoise: 0x48d1cc,\n mediumvioletred: 0xc71585,\n midnightblue: 0x191970,\n mintcream: 0xf5fffa,\n mistyrose: 0xffe4e1,\n moccasin: 0xffe4b5,\n navajowhite: 0xffdead,\n navy: 0x000080,\n oldlace: 0xfdf5e6,\n olive: 0x808000,\n olivedrab: 0x6b8e23,\n orange: 0xffa500,\n orangered: 0xff4500,\n orchid: 0xda70d6,\n palegoldenrod: 0xeee8aa,\n palegreen: 0x98fb98,\n paleturquoise: 0xafeeee,\n palevioletred: 0xdb7093,\n papayawhip: 0xffefd5,\n peachpuff: 0xffdab9,\n peru: 0xcd853f,\n pink: 0xffc0cb,\n plum: 0xdda0dd,\n powderblue: 0xb0e0e6,\n purple: 0x800080,\n rebeccapurple: 0x663399,\n red: 0xff0000,\n rosybrown: 0xbc8f8f,\n royalblue: 0x4169e1,\n saddlebrown: 0x8b4513,\n salmon: 0xfa8072,\n sandybrown: 0xf4a460,\n seagreen: 0x2e8b57,\n seashell: 0xfff5ee,\n sienna: 0xa0522d,\n silver: 0xc0c0c0,\n skyblue: 0x87ceeb,\n slateblue: 0x6a5acd,\n slategray: 0x708090,\n slategrey: 0x708090,\n snow: 0xfffafa,\n springgreen: 0x00ff7f,\n steelblue: 0x4682b4,\n tan: 0xd2b48c,\n teal: 0x008080,\n thistle: 0xd8bfd8,\n tomato: 0xff6347,\n turquoise: 0x40e0d0,\n violet: 0xee82ee,\n wheat: 0xf5deb3,\n white: 0xffffff,\n whitesmoke: 0xf5f5f5,\n yellow: 0xffff00,\n yellowgreen: 0x9acd32\n};\n\ndefine(Color, color, {\n displayable: function() {\n return this.rgb().displayable();\n },\n toString: function() {\n return this.rgb() + \"\";\n }\n});\n\nfunction color(format) {\n var m;\n format = (format + \"\").trim().toLowerCase();\n return (m = reHex3.exec(format)) ? (m = parseInt(m[1], 16), new Rgb((m >> 8 & 0xf) | (m >> 4 & 0x0f0), (m >> 4 & 0xf) | (m & 0xf0), ((m & 0xf) << 4) | (m & 0xf), 1)) // #f00\n : (m = reHex6.exec(format)) ? rgbn(parseInt(m[1], 16)) // #ff0000\n : (m = reRgbInteger.exec(format)) ? new Rgb(m[1], m[2], m[3], 1) // rgb(255, 0, 0)\n : (m = reRgbPercent.exec(format)) ? new Rgb(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) // rgb(100%, 0%, 0%)\n : (m = reRgbaInteger.exec(format)) ? rgba(m[1], m[2], m[3], m[4]) // rgba(255, 0, 0, 1)\n : (m = reRgbaPercent.exec(format)) ? rgba(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) // rgb(100%, 0%, 0%, 1)\n : (m = reHslPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) // hsl(120, 50%, 50%)\n : (m = reHslaPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) // hsla(120, 50%, 50%, 1)\n : named.hasOwnProperty(format) ? rgbn(named[format])\n : format === \"transparent\" ? new Rgb(NaN, NaN, NaN, 0)\n : null;\n}\n\nfunction rgbn(n) {\n return new Rgb(n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff, 1);\n}\n\nfunction rgba(r, g, b, a) {\n if (a <= 0) r = g = b = NaN;\n return new Rgb(r, g, b, a);\n}\n\nfunction rgbConvert(o) {\n if (!(o instanceof Color)) o = color(o);\n if (!o) return new Rgb;\n o = o.rgb();\n return new Rgb(o.r, o.g, o.b, o.opacity);\n}\n\nfunction rgb(r, g, b, opacity) {\n return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity);\n}\n\nfunction Rgb(r, g, b, opacity) {\n this.r = +r;\n this.g = +g;\n this.b = +b;\n this.opacity = +opacity;\n}\n\ndefine(Rgb, rgb, extend(Color, {\n brighter: function(k) {\n k = k == null ? brighter : Math.pow(brighter, k);\n return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);\n },\n darker: function(k) {\n k = k == null ? darker : Math.pow(darker, k);\n return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);\n },\n rgb: function() {\n return this;\n },\n displayable: function() {\n return (0 <= this.r && this.r <= 255)\n && (0 <= this.g && this.g <= 255)\n && (0 <= this.b && this.b <= 255)\n && (0 <= this.opacity && this.opacity <= 1);\n },\n toString: function() {\n var a = this.opacity; a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a));\n return (a === 1 ? \"rgb(\" : \"rgba(\")\n + Math.max(0, Math.min(255, Math.round(this.r) || 0)) + \", \"\n + Math.max(0, Math.min(255, Math.round(this.g) || 0)) + \", \"\n + Math.max(0, Math.min(255, Math.round(this.b) || 0))\n + (a === 1 ? \")\" : \", \" + a + \")\");\n }\n}));\n\nfunction hsla(h, s, l, a) {\n if (a <= 0) h = s = l = NaN;\n else if (l <= 0 || l >= 1) h = s = NaN;\n else if (s <= 0) h = NaN;\n return new Hsl(h, s, l, a);\n}\n\nfunction hslConvert(o) {\n if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity);\n if (!(o instanceof Color)) o = color(o);\n if (!o) return new Hsl;\n if (o instanceof Hsl) return o;\n o = o.rgb();\n var r = o.r / 255,\n g = o.g / 255,\n b = o.b / 255,\n min = Math.min(r, g, b),\n max = Math.max(r, g, b),\n h = NaN,\n s = max - min,\n l = (max + min) / 2;\n if (s) {\n if (r === max) h = (g - b) / s + (g < b) * 6;\n else if (g === max) h = (b - r) / s + 2;\n else h = (r - g) / s + 4;\n s /= l < 0.5 ? max + min : 2 - max - min;\n h *= 60;\n } else {\n s = l > 0 && l < 1 ? 0 : h;\n }\n return new Hsl(h, s, l, o.opacity);\n}\n\nfunction hsl(h, s, l, opacity) {\n return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity);\n}\n\nfunction Hsl(h, s, l, opacity) {\n this.h = +h;\n this.s = +s;\n this.l = +l;\n this.opacity = +opacity;\n}\n\ndefine(Hsl, hsl, extend(Color, {\n brighter: function(k) {\n k = k == null ? brighter : Math.pow(brighter, k);\n return new Hsl(this.h, this.s, this.l * k, this.opacity);\n },\n darker: function(k) {\n k = k == null ? darker : Math.pow(darker, k);\n return new Hsl(this.h, this.s, this.l * k, this.opacity);\n },\n rgb: function() {\n var h = this.h % 360 + (this.h < 0) * 360,\n s = isNaN(h) || isNaN(this.s) ? 0 : this.s,\n l = this.l,\n m2 = l + (l < 0.5 ? l : 1 - l) * s,\n m1 = 2 * l - m2;\n return new Rgb(\n hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2),\n hsl2rgb(h, m1, m2),\n hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2),\n this.opacity\n );\n },\n displayable: function() {\n return (0 <= this.s && this.s <= 1 || isNaN(this.s))\n && (0 <= this.l && this.l <= 1)\n && (0 <= this.opacity && this.opacity <= 1);\n }\n}));\n\n/* From FvD 13.37, CSS Color Module Level 3 */\nfunction hsl2rgb(h, m1, m2) {\n return (h < 60 ? m1 + (m2 - m1) * h / 60\n : h < 180 ? m2\n : h < 240 ? m1 + (m2 - m1) * (240 - h) / 60\n : m1) * 255;\n}\n\nvar deg2rad = Math.PI / 180;\nvar rad2deg = 180 / Math.PI;\n\nvar Kn = 18;\nvar Xn = 0.950470;\nvar Yn = 1;\nvar Zn = 1.088830;\nvar t0 = 4 / 29;\nvar t1 = 6 / 29;\nvar t2 = 3 * t1 * t1;\nvar t3 = t1 * t1 * t1;\n\nfunction labConvert(o) {\n if (o instanceof Lab) return new Lab(o.l, o.a, o.b, o.opacity);\n if (o instanceof Hcl) {\n var h = o.h * deg2rad;\n return new Lab(o.l, Math.cos(h) * o.c, Math.sin(h) * o.c, o.opacity);\n }\n if (!(o instanceof Rgb)) o = rgbConvert(o);\n var b = rgb2xyz(o.r),\n a = rgb2xyz(o.g),\n l = rgb2xyz(o.b),\n x = xyz2lab((0.4124564 * b + 0.3575761 * a + 0.1804375 * l) / Xn),\n y = xyz2lab((0.2126729 * b + 0.7151522 * a + 0.0721750 * l) / Yn),\n z = xyz2lab((0.0193339 * b + 0.1191920 * a + 0.9503041 * l) / Zn);\n return new Lab(116 * y - 16, 500 * (x - y), 200 * (y - z), o.opacity);\n}\n\nfunction lab(l, a, b, opacity) {\n return arguments.length === 1 ? labConvert(l) : new Lab(l, a, b, opacity == null ? 1 : opacity);\n}\n\nfunction Lab(l, a, b, opacity) {\n this.l = +l;\n this.a = +a;\n this.b = +b;\n this.opacity = +opacity;\n}\n\ndefine(Lab, lab, extend(Color, {\n brighter: function(k) {\n return new Lab(this.l + Kn * (k == null ? 1 : k), this.a, this.b, this.opacity);\n },\n darker: function(k) {\n return new Lab(this.l - Kn * (k == null ? 1 : k), this.a, this.b, this.opacity);\n },\n rgb: function() {\n var y = (this.l + 16) / 116,\n x = isNaN(this.a) ? y : y + this.a / 500,\n z = isNaN(this.b) ? y : y - this.b / 200;\n y = Yn * lab2xyz(y);\n x = Xn * lab2xyz(x);\n z = Zn * lab2xyz(z);\n return new Rgb(\n xyz2rgb( 3.2404542 * x - 1.5371385 * y - 0.4985314 * z), // D65 -> sRGB\n xyz2rgb(-0.9692660 * x + 1.8760108 * y + 0.0415560 * z),\n xyz2rgb( 0.0556434 * x - 0.2040259 * y + 1.0572252 * z),\n this.opacity\n );\n }\n}));\n\nfunction xyz2lab(t) {\n return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0;\n}\n\nfunction lab2xyz(t) {\n return t > t1 ? t * t * t : t2 * (t - t0);\n}\n\nfunction xyz2rgb(x) {\n return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055);\n}\n\nfunction rgb2xyz(x) {\n return (x /= 255) <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4);\n}\n\nfunction hclConvert(o) {\n if (o instanceof Hcl) return new Hcl(o.h, o.c, o.l, o.opacity);\n if (!(o instanceof Lab)) o = labConvert(o);\n var h = Math.atan2(o.b, o.a) * rad2deg;\n return new Hcl(h < 0 ? h + 360 : h, Math.sqrt(o.a * o.a + o.b * o.b), o.l, o.opacity);\n}\n\nfunction hcl(h, c, l, opacity) {\n return arguments.length === 1 ? hclConvert(h) : new Hcl(h, c, l, opacity == null ? 1 : opacity);\n}\n\nfunction Hcl(h, c, l, opacity) {\n this.h = +h;\n this.c = +c;\n this.l = +l;\n this.opacity = +opacity;\n}\n\ndefine(Hcl, hcl, extend(Color, {\n brighter: function(k) {\n return new Hcl(this.h, this.c, this.l + Kn * (k == null ? 1 : k), this.opacity);\n },\n darker: function(k) {\n return new Hcl(this.h, this.c, this.l - Kn * (k == null ? 1 : k), this.opacity);\n },\n rgb: function() {\n return labConvert(this).rgb();\n }\n}));\n\nvar A = -0.14861;\nvar B = +1.78277;\nvar C = -0.29227;\nvar D = -0.90649;\nvar E = +1.97294;\nvar ED = E * D;\nvar EB = E * B;\nvar BC_DA = B * C - D * A;\n\nfunction cubehelixConvert(o) {\n if (o instanceof Cubehelix) return new Cubehelix(o.h, o.s, o.l, o.opacity);\n if (!(o instanceof Rgb)) o = rgbConvert(o);\n var r = o.r / 255,\n g = o.g / 255,\n b = o.b / 255,\n l = (BC_DA * b + ED * r - EB * g) / (BC_DA + ED - EB),\n bl = b - l,\n k = (E * (g - l) - C * bl) / D,\n s = Math.sqrt(k * k + bl * bl) / (E * l * (1 - l)), // NaN if l=0 or l=1\n h = s ? Math.atan2(k, bl) * rad2deg - 120 : NaN;\n return new Cubehelix(h < 0 ? h + 360 : h, s, l, o.opacity);\n}\n\nfunction cubehelix(h, s, l, opacity) {\n return arguments.length === 1 ? cubehelixConvert(h) : new Cubehelix(h, s, l, opacity == null ? 1 : opacity);\n}\n\nfunction Cubehelix(h, s, l, opacity) {\n this.h = +h;\n this.s = +s;\n this.l = +l;\n this.opacity = +opacity;\n}\n\ndefine(Cubehelix, cubehelix, extend(Color, {\n brighter: function(k) {\n k = k == null ? brighter : Math.pow(brighter, k);\n return new Cubehelix(this.h, this.s, this.l * k, this.opacity);\n },\n darker: function(k) {\n k = k == null ? darker : Math.pow(darker, k);\n return new Cubehelix(this.h, this.s, this.l * k, this.opacity);\n },\n rgb: function() {\n var h = isNaN(this.h) ? 0 : (this.h + 120) * deg2rad,\n l = +this.l,\n a = isNaN(this.s) ? 0 : this.s * l * (1 - l),\n cosh = Math.cos(h),\n sinh = Math.sin(h);\n return new Rgb(\n 255 * (l + a * (A * cosh + B * sinh)),\n 255 * (l + a * (C * cosh + D * sinh)),\n 255 * (l + a * (E * cosh)),\n this.opacity\n );\n }\n}));\n\nfunction basis(t1, v0, v1, v2, v3) {\n var t2 = t1 * t1, t3 = t2 * t1;\n return ((1 - 3 * t1 + 3 * t2 - t3) * v0\n + (4 - 6 * t2 + 3 * t3) * v1\n + (1 + 3 * t1 + 3 * t2 - 3 * t3) * v2\n + t3 * v3) / 6;\n}\n\nvar basis$1 = function(values) {\n var n = values.length - 1;\n return function(t) {\n var i = t <= 0 ? (t = 0) : t >= 1 ? (t = 1, n - 1) : Math.floor(t * n),\n v1 = values[i],\n v2 = values[i + 1],\n v0 = i > 0 ? values[i - 1] : 2 * v1 - v2,\n v3 = i < n - 1 ? values[i + 2] : 2 * v2 - v1;\n return basis((t - i / n) * n, v0, v1, v2, v3);\n };\n};\n\nvar basisClosed = function(values) {\n var n = values.length;\n return function(t) {\n var i = Math.floor(((t %= 1) < 0 ? ++t : t) * n),\n v0 = values[(i + n - 1) % n],\n v1 = values[i % n],\n v2 = values[(i + 1) % n],\n v3 = values[(i + 2) % n];\n return basis((t - i / n) * n, v0, v1, v2, v3);\n };\n};\n\nvar constant$3 = function(x) {\n return function() {\n return x;\n };\n};\n\nfunction linear(a, d) {\n return function(t) {\n return a + t * d;\n };\n}\n\nfunction exponential(a, b, y) {\n return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function(t) {\n return Math.pow(a + t * b, y);\n };\n}\n\nfunction hue(a, b) {\n var d = b - a;\n return d ? linear(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : constant$3(isNaN(a) ? b : a);\n}\n\nfunction gamma(y) {\n return (y = +y) === 1 ? nogamma : function(a, b) {\n return b - a ? exponential(a, b, y) : constant$3(isNaN(a) ? b : a);\n };\n}\n\nfunction nogamma(a, b) {\n var d = b - a;\n return d ? linear(a, d) : constant$3(isNaN(a) ? b : a);\n}\n\nvar interpolateRgb = ((function rgbGamma(y) {\n var color$$1 = gamma(y);\n\n function rgb$$1(start, end) {\n var r = color$$1((start = rgb(start)).r, (end = rgb(end)).r),\n g = color$$1(start.g, end.g),\n b = color$$1(start.b, end.b),\n opacity = nogamma(start.opacity, end.opacity);\n return function(t) {\n start.r = r(t);\n start.g = g(t);\n start.b = b(t);\n start.opacity = opacity(t);\n return start + \"\";\n };\n }\n\n rgb$$1.gamma = rgbGamma;\n\n return rgb$$1;\n}))(1);\n\nfunction rgbSpline(spline) {\n return function(colors) {\n var n = colors.length,\n r = new Array(n),\n g = new Array(n),\n b = new Array(n),\n i, color$$1;\n for (i = 0; i < n; ++i) {\n color$$1 = rgb(colors[i]);\n r[i] = color$$1.r || 0;\n g[i] = color$$1.g || 0;\n b[i] = color$$1.b || 0;\n }\n r = spline(r);\n g = spline(g);\n b = spline(b);\n color$$1.opacity = 1;\n return function(t) {\n color$$1.r = r(t);\n color$$1.g = g(t);\n color$$1.b = b(t);\n return color$$1 + \"\";\n };\n };\n}\n\nvar rgbBasis = rgbSpline(basis$1);\nvar rgbBasisClosed = rgbSpline(basisClosed);\n\nvar array$1 = function(a, b) {\n var nb = b ? b.length : 0,\n na = a ? Math.min(nb, a.length) : 0,\n x = new Array(nb),\n c = new Array(nb),\n i;\n\n for (i = 0; i < na; ++i) x[i] = interpolateValue(a[i], b[i]);\n for (; i < nb; ++i) c[i] = b[i];\n\n return function(t) {\n for (i = 0; i < na; ++i) c[i] = x[i](t);\n return c;\n };\n};\n\nvar date = function(a, b) {\n var d = new Date;\n return a = +a, b -= a, function(t) {\n return d.setTime(a + b * t), d;\n };\n};\n\nvar reinterpolate = function(a, b) {\n return a = +a, b -= a, function(t) {\n return a + b * t;\n };\n};\n\nvar object = function(a, b) {\n var i = {},\n c = {},\n k;\n\n if (a === null || typeof a !== \"object\") a = {};\n if (b === null || typeof b !== \"object\") b = {};\n\n for (k in b) {\n if (k in a) {\n i[k] = interpolateValue(a[k], b[k]);\n } else {\n c[k] = b[k];\n }\n }\n\n return function(t) {\n for (k in i) c[k] = i[k](t);\n return c;\n };\n};\n\nvar reA = /[-+]?(?:\\d+\\.?\\d*|\\.?\\d+)(?:[eE][-+]?\\d+)?/g;\nvar reB = new RegExp(reA.source, \"g\");\n\nfunction zero(b) {\n return function() {\n return b;\n };\n}\n\nfunction one(b) {\n return function(t) {\n return b(t) + \"\";\n };\n}\n\nvar interpolateString = function(a, b) {\n var bi = reA.lastIndex = reB.lastIndex = 0, // scan index for next number in b\n am, // current match in a\n bm, // current match in b\n bs, // string preceding current number in b, if any\n i = -1, // index in s\n s = [], // string constants and placeholders\n q = []; // number interpolators\n\n // Coerce inputs to strings.\n a = a + \"\", b = b + \"\";\n\n // Interpolate pairs of numbers in a & b.\n while ((am = reA.exec(a))\n && (bm = reB.exec(b))) {\n if ((bs = bm.index) > bi) { // a string precedes the next number in b\n bs = b.slice(bi, bs);\n if (s[i]) s[i] += bs; // coalesce with previous string\n else s[++i] = bs;\n }\n if ((am = am[0]) === (bm = bm[0])) { // numbers in a & b match\n if (s[i]) s[i] += bm; // coalesce with previous string\n else s[++i] = bm;\n } else { // interpolate non-matching numbers\n s[++i] = null;\n q.push({i: i, x: reinterpolate(am, bm)});\n }\n bi = reB.lastIndex;\n }\n\n // Add remains of b.\n if (bi < b.length) {\n bs = b.slice(bi);\n if (s[i]) s[i] += bs; // coalesce with previous string\n else s[++i] = bs;\n }\n\n // Special optimization for only a single match.\n // Otherwise, interpolate each of the numbers and rejoin the string.\n return s.length < 2 ? (q[0]\n ? one(q[0].x)\n : zero(b))\n : (b = q.length, function(t) {\n for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t);\n return s.join(\"\");\n });\n};\n\nvar interpolateValue = function(a, b) {\n var t = typeof b, c;\n return b == null || t === \"boolean\" ? constant$3(b)\n : (t === \"number\" ? reinterpolate\n : t === \"string\" ? ((c = color(b)) ? (b = c, interpolateRgb) : interpolateString)\n : b instanceof color ? interpolateRgb\n : b instanceof Date ? date\n : Array.isArray(b) ? array$1\n : isNaN(b) ? object\n : reinterpolate)(a, b);\n};\n\nvar interpolateRound = function(a, b) {\n return a = +a, b -= a, function(t) {\n return Math.round(a + b * t);\n };\n};\n\nvar degrees = 180 / Math.PI;\n\nvar identity$2 = {\n translateX: 0,\n translateY: 0,\n rotate: 0,\n skewX: 0,\n scaleX: 1,\n scaleY: 1\n};\n\nvar decompose = function(a, b, c, d, e, f) {\n var scaleX, scaleY, skewX;\n if (scaleX = Math.sqrt(a * a + b * b)) a /= scaleX, b /= scaleX;\n if (skewX = a * c + b * d) c -= a * skewX, d -= b * skewX;\n if (scaleY = Math.sqrt(c * c + d * d)) c /= scaleY, d /= scaleY, skewX /= scaleY;\n if (a * d < b * c) a = -a, b = -b, skewX = -skewX, scaleX = -scaleX;\n return {\n translateX: e,\n translateY: f,\n rotate: Math.atan2(b, a) * degrees,\n skewX: Math.atan(skewX) * degrees,\n scaleX: scaleX,\n scaleY: scaleY\n };\n};\n\nvar cssNode;\nvar cssRoot;\nvar cssView;\nvar svgNode;\n\nfunction parseCss(value) {\n if (value === \"none\") return identity$2;\n if (!cssNode) cssNode = document.createElement(\"DIV\"), cssRoot = document.documentElement, cssView = document.defaultView;\n cssNode.style.transform = value;\n value = cssView.getComputedStyle(cssRoot.appendChild(cssNode), null).getPropertyValue(\"transform\");\n cssRoot.removeChild(cssNode);\n value = value.slice(7, -1).split(\",\");\n return decompose(+value[0], +value[1], +value[2], +value[3], +value[4], +value[5]);\n}\n\nfunction parseSvg(value) {\n if (value == null) return identity$2;\n if (!svgNode) svgNode = document.createElementNS(\"http://www.w3.org/2000/svg\", \"g\");\n svgNode.setAttribute(\"transform\", value);\n if (!(value = svgNode.transform.baseVal.consolidate())) return identity$2;\n value = value.matrix;\n return decompose(value.a, value.b, value.c, value.d, value.e, value.f);\n}\n\nfunction interpolateTransform(parse, pxComma, pxParen, degParen) {\n\n function pop(s) {\n return s.length ? s.pop() + \" \" : \"\";\n }\n\n function translate(xa, ya, xb, yb, s, q) {\n if (xa !== xb || ya !== yb) {\n var i = s.push(\"translate(\", null, pxComma, null, pxParen);\n q.push({i: i - 4, x: reinterpolate(xa, xb)}, {i: i - 2, x: reinterpolate(ya, yb)});\n } else if (xb || yb) {\n s.push(\"translate(\" + xb + pxComma + yb + pxParen);\n }\n }\n\n function rotate(a, b, s, q) {\n if (a !== b) {\n if (a - b > 180) b += 360; else if (b - a > 180) a += 360; // shortest path\n q.push({i: s.push(pop(s) + \"rotate(\", null, degParen) - 2, x: reinterpolate(a, b)});\n } else if (b) {\n s.push(pop(s) + \"rotate(\" + b + degParen);\n }\n }\n\n function skewX(a, b, s, q) {\n if (a !== b) {\n q.push({i: s.push(pop(s) + \"skewX(\", null, degParen) - 2, x: reinterpolate(a, b)});\n } else if (b) {\n s.push(pop(s) + \"skewX(\" + b + degParen);\n }\n }\n\n function scale(xa, ya, xb, yb, s, q) {\n if (xa !== xb || ya !== yb) {\n var i = s.push(pop(s) + \"scale(\", null, \",\", null, \")\");\n q.push({i: i - 4, x: reinterpolate(xa, xb)}, {i: i - 2, x: reinterpolate(ya, yb)});\n } else if (xb !== 1 || yb !== 1) {\n s.push(pop(s) + \"scale(\" + xb + \",\" + yb + \")\");\n }\n }\n\n return function(a, b) {\n var s = [], // string constants and placeholders\n q = []; // number interpolators\n a = parse(a), b = parse(b);\n translate(a.translateX, a.translateY, b.translateX, b.translateY, s, q);\n rotate(a.rotate, b.rotate, s, q);\n skewX(a.skewX, b.skewX, s, q);\n scale(a.scaleX, a.scaleY, b.scaleX, b.scaleY, s, q);\n a = b = null; // gc\n return function(t) {\n var i = -1, n = q.length, o;\n while (++i < n) s[(o = q[i]).i] = o.x(t);\n return s.join(\"\");\n };\n };\n}\n\nvar interpolateTransformCss = interpolateTransform(parseCss, \"px, \", \"px)\", \"deg)\");\nvar interpolateTransformSvg = interpolateTransform(parseSvg, \", \", \")\", \")\");\n\nvar rho = Math.SQRT2;\nvar rho2 = 2;\nvar rho4 = 4;\nvar epsilon2 = 1e-12;\n\nfunction cosh(x) {\n return ((x = Math.exp(x)) + 1 / x) / 2;\n}\n\nfunction sinh(x) {\n return ((x = Math.exp(x)) - 1 / x) / 2;\n}\n\nfunction tanh(x) {\n return ((x = Math.exp(2 * x)) - 1) / (x + 1);\n}\n\n// p0 = [ux0, uy0, w0]\n// p1 = [ux1, uy1, w1]\nvar interpolateZoom = function(p0, p1) {\n var ux0 = p0[0], uy0 = p0[1], w0 = p0[2],\n ux1 = p1[0], uy1 = p1[1], w1 = p1[2],\n dx = ux1 - ux0,\n dy = uy1 - uy0,\n d2 = dx * dx + dy * dy,\n i,\n S;\n\n // Special case for u0 ≅ u1.\n if (d2 < epsilon2) {\n S = Math.log(w1 / w0) / rho;\n i = function(t) {\n return [\n ux0 + t * dx,\n uy0 + t * dy,\n w0 * Math.exp(rho * t * S)\n ];\n };\n }\n\n // General case.\n else {\n var d1 = Math.sqrt(d2),\n b0 = (w1 * w1 - w0 * w0 + rho4 * d2) / (2 * w0 * rho2 * d1),\n b1 = (w1 * w1 - w0 * w0 - rho4 * d2) / (2 * w1 * rho2 * d1),\n r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0),\n r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1);\n S = (r1 - r0) / rho;\n i = function(t) {\n var s = t * S,\n coshr0 = cosh(r0),\n u = w0 / (rho2 * d1) * (coshr0 * tanh(rho * s + r0) - sinh(r0));\n return [\n ux0 + u * dx,\n uy0 + u * dy,\n w0 * coshr0 / cosh(rho * s + r0)\n ];\n };\n }\n\n i.duration = S * 1000;\n\n return i;\n};\n\nfunction hsl$1(hue$$1) {\n return function(start, end) {\n var h = hue$$1((start = hsl(start)).h, (end = hsl(end)).h),\n s = nogamma(start.s, end.s),\n l = nogamma(start.l, end.l),\n opacity = nogamma(start.opacity, end.opacity);\n return function(t) {\n start.h = h(t);\n start.s = s(t);\n start.l = l(t);\n start.opacity = opacity(t);\n return start + \"\";\n };\n }\n}\n\nvar hsl$2 = hsl$1(hue);\nvar hslLong = hsl$1(nogamma);\n\nfunction lab$1(start, end) {\n var l = nogamma((start = lab(start)).l, (end = lab(end)).l),\n a = nogamma(start.a, end.a),\n b = nogamma(start.b, end.b),\n opacity = nogamma(start.opacity, end.opacity);\n return function(t) {\n start.l = l(t);\n start.a = a(t);\n start.b = b(t);\n start.opacity = opacity(t);\n return start + \"\";\n };\n}\n\nfunction hcl$1(hue$$1) {\n return function(start, end) {\n var h = hue$$1((start = hcl(start)).h, (end = hcl(end)).h),\n c = nogamma(start.c, end.c),\n l = nogamma(start.l, end.l),\n opacity = nogamma(start.opacity, end.opacity);\n return function(t) {\n start.h = h(t);\n start.c = c(t);\n start.l = l(t);\n start.opacity = opacity(t);\n return start + \"\";\n };\n }\n}\n\nvar hcl$2 = hcl$1(hue);\nvar hclLong = hcl$1(nogamma);\n\nfunction cubehelix$1(hue$$1) {\n return (function cubehelixGamma(y) {\n y = +y;\n\n function cubehelix$$1(start, end) {\n var h = hue$$1((start = cubehelix(start)).h, (end = cubehelix(end)).h),\n s = nogamma(start.s, end.s),\n l = nogamma(start.l, end.l),\n opacity = nogamma(start.opacity, end.opacity);\n return function(t) {\n start.h = h(t);\n start.s = s(t);\n start.l = l(Math.pow(t, y));\n start.opacity = opacity(t);\n return start + \"\";\n };\n }\n\n cubehelix$$1.gamma = cubehelixGamma;\n\n return cubehelix$$1;\n })(1);\n}\n\nvar cubehelix$2 = cubehelix$1(hue);\nvar cubehelixLong = cubehelix$1(nogamma);\n\nvar quantize = function(interpolator, n) {\n var samples = new Array(n);\n for (var i = 0; i < n; ++i) samples[i] = interpolator(i / (n - 1));\n return samples;\n};\n\nvar frame = 0;\nvar timeout = 0;\nvar interval = 0;\nvar pokeDelay = 1000;\nvar taskHead;\nvar taskTail;\nvar clockLast = 0;\nvar clockNow = 0;\nvar clockSkew = 0;\nvar clock = typeof performance === \"object\" && performance.now ? performance : Date;\nvar setFrame = typeof requestAnimationFrame === \"function\" ? requestAnimationFrame : function(f) { setTimeout(f, 17); };\n\nfunction now() {\n return clockNow || (setFrame(clearNow), clockNow = clock.now() + clockSkew);\n}\n\nfunction clearNow() {\n clockNow = 0;\n}\n\nfunction Timer() {\n this._call =\n this._time =\n this._next = null;\n}\n\nTimer.prototype = timer.prototype = {\n constructor: Timer,\n restart: function(callback, delay, time) {\n if (typeof callback !== \"function\") throw new TypeError(\"callback is not a function\");\n time = (time == null ? now() : +time) + (delay == null ? 0 : +delay);\n if (!this._next && taskTail !== this) {\n if (taskTail) taskTail._next = this;\n else taskHead = this;\n taskTail = this;\n }\n this._call = callback;\n this._time = time;\n sleep();\n },\n stop: function() {\n if (this._call) {\n this._call = null;\n this._time = Infinity;\n sleep();\n }\n }\n};\n\nfunction timer(callback, delay, time) {\n var t = new Timer;\n t.restart(callback, delay, time);\n return t;\n}\n\nfunction timerFlush() {\n now(); // Get the current time, if not already set.\n ++frame; // Pretend we’ve set an alarm, if we haven’t already.\n var t = taskHead, e;\n while (t) {\n if ((e = clockNow - t._time) >= 0) t._call.call(null, e);\n t = t._next;\n }\n --frame;\n}\n\nfunction wake() {\n clockNow = (clockLast = clock.now()) + clockSkew;\n frame = timeout = 0;\n try {\n timerFlush();\n } finally {\n frame = 0;\n nap();\n clockNow = 0;\n }\n}\n\nfunction poke() {\n var now = clock.now(), delay = now - clockLast;\n if (delay > pokeDelay) clockSkew -= delay, clockLast = now;\n}\n\nfunction nap() {\n var t0, t1 = taskHead, t2, time = Infinity;\n while (t1) {\n if (t1._call) {\n if (time > t1._time) time = t1._time;\n t0 = t1, t1 = t1._next;\n } else {\n t2 = t1._next, t1._next = null;\n t1 = t0 ? t0._next = t2 : taskHead = t2;\n }\n }\n taskTail = t0;\n sleep(time);\n}\n\nfunction sleep(time) {\n if (frame) return; // Soonest alarm already set, or will be.\n if (timeout) timeout = clearTimeout(timeout);\n var delay = time - clockNow;\n if (delay > 24) {\n if (time < Infinity) timeout = setTimeout(wake, delay);\n if (interval) interval = clearInterval(interval);\n } else {\n if (!interval) clockLast = clockNow, interval = setInterval(poke, pokeDelay);\n frame = 1, setFrame(wake);\n }\n}\n\nvar timeout$1 = function(callback, delay, time) {\n var t = new Timer;\n delay = delay == null ? 0 : +delay;\n t.restart(function(elapsed) {\n t.stop();\n callback(elapsed + delay);\n }, delay, time);\n return t;\n};\n\nvar interval$1 = function(callback, delay, time) {\n var t = new Timer, total = delay;\n if (delay == null) return t.restart(callback, delay, time), t;\n delay = +delay, time = time == null ? now() : +time;\n t.restart(function tick(elapsed) {\n elapsed += total;\n t.restart(tick, total += delay, time);\n callback(elapsed);\n }, delay, time);\n return t;\n};\n\nvar emptyOn = dispatch(\"start\", \"end\", \"interrupt\");\nvar emptyTween = [];\n\nvar CREATED = 0;\nvar SCHEDULED = 1;\nvar STARTING = 2;\nvar STARTED = 3;\nvar RUNNING = 4;\nvar ENDING = 5;\nvar ENDED = 6;\n\nvar schedule = function(node, name, id, index, group, timing) {\n var schedules = node.__transition;\n if (!schedules) node.__transition = {};\n else if (id in schedules) return;\n create(node, id, {\n name: name,\n index: index, // For context during callback.\n group: group, // For context during callback.\n on: emptyOn,\n tween: emptyTween,\n time: timing.time,\n delay: timing.delay,\n duration: timing.duration,\n ease: timing.ease,\n timer: null,\n state: CREATED\n });\n};\n\nfunction init(node, id) {\n var schedule = node.__transition;\n if (!schedule || !(schedule = schedule[id]) || schedule.state > CREATED) throw new Error(\"too late\");\n return schedule;\n}\n\nfunction set$1(node, id) {\n var schedule = node.__transition;\n if (!schedule || !(schedule = schedule[id]) || schedule.state > STARTING) throw new Error(\"too late\");\n return schedule;\n}\n\nfunction get$1(node, id) {\n var schedule = node.__transition;\n if (!schedule || !(schedule = schedule[id])) throw new Error(\"too late\");\n return schedule;\n}\n\nfunction create(node, id, self) {\n var schedules = node.__transition,\n tween;\n\n // Initialize the self timer when the transition is created.\n // Note the actual delay is not known until the first callback!\n schedules[id] = self;\n self.timer = timer(schedule, 0, self.time);\n\n function schedule(elapsed) {\n self.state = SCHEDULED;\n self.timer.restart(start, self.delay, self.time);\n\n // If the elapsed delay is less than our first sleep, start immediately.\n if (self.delay <= elapsed) start(elapsed - self.delay);\n }\n\n function start(elapsed) {\n var i, j, n, o;\n\n // If the state is not SCHEDULED, then we previously errored on start.\n if (self.state !== SCHEDULED) return stop();\n\n for (i in schedules) {\n o = schedules[i];\n if (o.name !== self.name) continue;\n\n // While this element already has a starting transition during this frame,\n // defer starting an interrupting transition until that transition has a\n // chance to tick (and possibly end); see d3/d3-transition#54!\n if (o.state === STARTED) return timeout$1(start);\n\n // Interrupt the active transition, if any.\n // Dispatch the interrupt event.\n if (o.state === RUNNING) {\n o.state = ENDED;\n o.timer.stop();\n o.on.call(\"interrupt\", node, node.__data__, o.index, o.group);\n delete schedules[i];\n }\n\n // Cancel any pre-empted transitions. No interrupt event is dispatched\n // because the cancelled transitions never started. Note that this also\n // removes this transition from the pending list!\n else if (+i < id) {\n o.state = ENDED;\n o.timer.stop();\n delete schedules[i];\n }\n }\n\n // Defer the first tick to end of the current frame; see d3/d3#1576.\n // Note the transition may be canceled after start and before the first tick!\n // Note this must be scheduled before the start event; see d3/d3-transition#16!\n // Assuming this is successful, subsequent callbacks go straight to tick.\n timeout$1(function() {\n if (self.state === STARTED) {\n self.state = RUNNING;\n self.timer.restart(tick, self.delay, self.time);\n tick(elapsed);\n }\n });\n\n // Dispatch the start event.\n // Note this must be done before the tween are initialized.\n self.state = STARTING;\n self.on.call(\"start\", node, node.__data__, self.index, self.group);\n if (self.state !== STARTING) return; // interrupted\n self.state = STARTED;\n\n // Initialize the tween, deleting null tween.\n tween = new Array(n = self.tween.length);\n for (i = 0, j = -1; i < n; ++i) {\n if (o = self.tween[i].value.call(node, node.__data__, self.index, self.group)) {\n tween[++j] = o;\n }\n }\n tween.length = j + 1;\n }\n\n function tick(elapsed) {\n var t = elapsed < self.duration ? self.ease.call(null, elapsed / self.duration) : (self.timer.restart(stop), self.state = ENDING, 1),\n i = -1,\n n = tween.length;\n\n while (++i < n) {\n tween[i].call(null, t);\n }\n\n // Dispatch the end event.\n if (self.state === ENDING) {\n self.on.call(\"end\", node, node.__data__, self.index, self.group);\n stop();\n }\n }\n\n function stop() {\n self.state = ENDED;\n self.timer.stop();\n delete schedules[id];\n for (var i in schedules) return; // eslint-disable-line no-unused-vars\n delete node.__transition;\n }\n}\n\nvar interrupt = function(node, name) {\n var schedules = node.__transition,\n schedule,\n active,\n empty = true,\n i;\n\n if (!schedules) return;\n\n name = name == null ? null : name + \"\";\n\n for (i in schedules) {\n if ((schedule = schedules[i]).name !== name) { empty = false; continue; }\n active = schedule.state > STARTING && schedule.state < ENDING;\n schedule.state = ENDED;\n schedule.timer.stop();\n if (active) schedule.on.call(\"interrupt\", node, node.__data__, schedule.index, schedule.group);\n delete schedules[i];\n }\n\n if (empty) delete node.__transition;\n};\n\nvar selection_interrupt = function(name) {\n return this.each(function() {\n interrupt(this, name);\n });\n};\n\nfunction tweenRemove(id, name) {\n var tween0, tween1;\n return function() {\n var schedule = set$1(this, id),\n tween = schedule.tween;\n\n // If this node shared tween with the previous node,\n // just assign the updated shared tween and we’re done!\n // Otherwise, copy-on-write.\n if (tween !== tween0) {\n tween1 = tween0 = tween;\n for (var i = 0, n = tween1.length; i < n; ++i) {\n if (tween1[i].name === name) {\n tween1 = tween1.slice();\n tween1.splice(i, 1);\n break;\n }\n }\n }\n\n schedule.tween = tween1;\n };\n}\n\nfunction tweenFunction(id, name, value) {\n var tween0, tween1;\n if (typeof value !== \"function\") throw new Error;\n return function() {\n var schedule = set$1(this, id),\n tween = schedule.tween;\n\n // If this node shared tween with the previous node,\n // just assign the updated shared tween and we’re done!\n // Otherwise, copy-on-write.\n if (tween !== tween0) {\n tween1 = (tween0 = tween).slice();\n for (var t = {name: name, value: value}, i = 0, n = tween1.length; i < n; ++i) {\n if (tween1[i].name === name) {\n tween1[i] = t;\n break;\n }\n }\n if (i === n) tween1.push(t);\n }\n\n schedule.tween = tween1;\n };\n}\n\nvar transition_tween = function(name, value) {\n var id = this._id;\n\n name += \"\";\n\n if (arguments.length < 2) {\n var tween = get$1(this.node(), id).tween;\n for (var i = 0, n = tween.length, t; i < n; ++i) {\n if ((t = tween[i]).name === name) {\n return t.value;\n }\n }\n return null;\n }\n\n return this.each((value == null ? tweenRemove : tweenFunction)(id, name, value));\n};\n\nfunction tweenValue(transition, name, value) {\n var id = transition._id;\n\n transition.each(function() {\n var schedule = set$1(this, id);\n (schedule.value || (schedule.value = {}))[name] = value.apply(this, arguments);\n });\n\n return function(node) {\n return get$1(node, id).value[name];\n };\n}\n\nvar interpolate$$1 = function(a, b) {\n var c;\n return (typeof b === \"number\" ? reinterpolate\n : b instanceof color ? interpolateRgb\n : (c = color(b)) ? (b = c, interpolateRgb)\n : interpolateString)(a, b);\n};\n\nfunction attrRemove$1(name) {\n return function() {\n this.removeAttribute(name);\n };\n}\n\nfunction attrRemoveNS$1(fullname) {\n return function() {\n this.removeAttributeNS(fullname.space, fullname.local);\n };\n}\n\nfunction attrConstant$1(name, interpolate$$1, value1) {\n var value00,\n interpolate0;\n return function() {\n var value0 = this.getAttribute(name);\n return value0 === value1 ? null\n : value0 === value00 ? interpolate0\n : interpolate0 = interpolate$$1(value00 = value0, value1);\n };\n}\n\nfunction attrConstantNS$1(fullname, interpolate$$1, value1) {\n var value00,\n interpolate0;\n return function() {\n var value0 = this.getAttributeNS(fullname.space, fullname.local);\n return value0 === value1 ? null\n : value0 === value00 ? interpolate0\n : interpolate0 = interpolate$$1(value00 = value0, value1);\n };\n}\n\nfunction attrFunction$1(name, interpolate$$1, value) {\n var value00,\n value10,\n interpolate0;\n return function() {\n var value0, value1 = value(this);\n if (value1 == null) return void this.removeAttribute(name);\n value0 = this.getAttribute(name);\n return value0 === value1 ? null\n : value0 === value00 && value1 === value10 ? interpolate0\n : interpolate0 = interpolate$$1(value00 = value0, value10 = value1);\n };\n}\n\nfunction attrFunctionNS$1(fullname, interpolate$$1, value) {\n var value00,\n value10,\n interpolate0;\n return function() {\n var value0, value1 = value(this);\n if (value1 == null) return void this.removeAttributeNS(fullname.space, fullname.local);\n value0 = this.getAttributeNS(fullname.space, fullname.local);\n return value0 === value1 ? null\n : value0 === value00 && value1 === value10 ? interpolate0\n : interpolate0 = interpolate$$1(value00 = value0, value10 = value1);\n };\n}\n\nvar transition_attr = function(name, value) {\n var fullname = namespace(name), i = fullname === \"transform\" ? interpolateTransformSvg : interpolate$$1;\n return this.attrTween(name, typeof value === \"function\"\n ? (fullname.local ? attrFunctionNS$1 : attrFunction$1)(fullname, i, tweenValue(this, \"attr.\" + name, value))\n : value == null ? (fullname.local ? attrRemoveNS$1 : attrRemove$1)(fullname)\n : (fullname.local ? attrConstantNS$1 : attrConstant$1)(fullname, i, value));\n};\n\nfunction attrTweenNS(fullname, value) {\n function tween() {\n var node = this, i = value.apply(node, arguments);\n return i && function(t) {\n node.setAttributeNS(fullname.space, fullname.local, i(t));\n };\n }\n tween._value = value;\n return tween;\n}\n\nfunction attrTween(name, value) {\n function tween() {\n var node = this, i = value.apply(node, arguments);\n return i && function(t) {\n node.setAttribute(name, i(t));\n };\n }\n tween._value = value;\n return tween;\n}\n\nvar transition_attrTween = function(name, value) {\n var key = \"attr.\" + name;\n if (arguments.length < 2) return (key = this.tween(key)) && key._value;\n if (value == null) return this.tween(key, null);\n if (typeof value !== \"function\") throw new Error;\n var fullname = namespace(name);\n return this.tween(key, (fullname.local ? attrTweenNS : attrTween)(fullname, value));\n};\n\nfunction delayFunction(id, value) {\n return function() {\n init(this, id).delay = +value.apply(this, arguments);\n };\n}\n\nfunction delayConstant(id, value) {\n return value = +value, function() {\n init(this, id).delay = value;\n };\n}\n\nvar transition_delay = function(value) {\n var id = this._id;\n\n return arguments.length\n ? this.each((typeof value === \"function\"\n ? delayFunction\n : delayConstant)(id, value))\n : get$1(this.node(), id).delay;\n};\n\nfunction durationFunction(id, value) {\n return function() {\n set$1(this, id).duration = +value.apply(this, arguments);\n };\n}\n\nfunction durationConstant(id, value) {\n return value = +value, function() {\n set$1(this, id).duration = value;\n };\n}\n\nvar transition_duration = function(value) {\n var id = this._id;\n\n return arguments.length\n ? this.each((typeof value === \"function\"\n ? durationFunction\n : durationConstant)(id, value))\n : get$1(this.node(), id).duration;\n};\n\nfunction easeConstant(id, value) {\n if (typeof value !== \"function\") throw new Error;\n return function() {\n set$1(this, id).ease = value;\n };\n}\n\nvar transition_ease = function(value) {\n var id = this._id;\n\n return arguments.length\n ? this.each(easeConstant(id, value))\n : get$1(this.node(), id).ease;\n};\n\nvar transition_filter = function(match) {\n if (typeof match !== \"function\") match = matcher$1(match);\n\n for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {\n for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) {\n if ((node = group[i]) && match.call(node, node.__data__, i, group)) {\n subgroup.push(node);\n }\n }\n }\n\n return new Transition(subgroups, this._parents, this._name, this._id);\n};\n\nvar transition_merge = function(transition) {\n if (transition._id !== this._id) throw new Error;\n\n for (var groups0 = this._groups, groups1 = transition._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) {\n for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) {\n if (node = group0[i] || group1[i]) {\n merge[i] = node;\n }\n }\n }\n\n for (; j < m0; ++j) {\n merges[j] = groups0[j];\n }\n\n return new Transition(merges, this._parents, this._name, this._id);\n};\n\nfunction start(name) {\n return (name + \"\").trim().split(/^|\\s+/).every(function(t) {\n var i = t.indexOf(\".\");\n if (i >= 0) t = t.slice(0, i);\n return !t || t === \"start\";\n });\n}\n\nfunction onFunction(id, name, listener) {\n var on0, on1, sit = start(name) ? init : set$1;\n return function() {\n var schedule = sit(this, id),\n on = schedule.on;\n\n // If this node shared a dispatch with the previous node,\n // just assign the updated shared dispatch and we’re done!\n // Otherwise, copy-on-write.\n if (on !== on0) (on1 = (on0 = on).copy()).on(name, listener);\n\n schedule.on = on1;\n };\n}\n\nvar transition_on = function(name, listener) {\n var id = this._id;\n\n return arguments.length < 2\n ? get$1(this.node(), id).on.on(name)\n : this.each(onFunction(id, name, listener));\n};\n\nfunction removeFunction(id) {\n return function() {\n var parent = this.parentNode;\n for (var i in this.__transition) if (+i !== id) return;\n if (parent) parent.removeChild(this);\n };\n}\n\nvar transition_remove = function() {\n return this.on(\"end.remove\", removeFunction(this._id));\n};\n\nvar transition_select = function(select$$1) {\n var name = this._name,\n id = this._id;\n\n if (typeof select$$1 !== \"function\") select$$1 = selector(select$$1);\n\n for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {\n for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) {\n if ((node = group[i]) && (subnode = select$$1.call(node, node.__data__, i, group))) {\n if (\"__data__\" in node) subnode.__data__ = node.__data__;\n subgroup[i] = subnode;\n schedule(subgroup[i], name, id, i, subgroup, get$1(node, id));\n }\n }\n }\n\n return new Transition(subgroups, this._parents, name, id);\n};\n\nvar transition_selectAll = function(select$$1) {\n var name = this._name,\n id = this._id;\n\n if (typeof select$$1 !== \"function\") select$$1 = selectorAll(select$$1);\n\n for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) {\n for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {\n if (node = group[i]) {\n for (var children = select$$1.call(node, node.__data__, i, group), child, inherit = get$1(node, id), k = 0, l = children.length; k < l; ++k) {\n if (child = children[k]) {\n schedule(child, name, id, k, children, inherit);\n }\n }\n subgroups.push(children);\n parents.push(node);\n }\n }\n }\n\n return new Transition(subgroups, parents, name, id);\n};\n\nvar Selection$1 = selection.prototype.constructor;\n\nvar transition_selection = function() {\n return new Selection$1(this._groups, this._parents);\n};\n\nfunction styleRemove$1(name, interpolate$$2) {\n var value00,\n value10,\n interpolate0;\n return function() {\n var style = window(this).getComputedStyle(this, null),\n value0 = style.getPropertyValue(name),\n value1 = (this.style.removeProperty(name), style.getPropertyValue(name));\n return value0 === value1 ? null\n : value0 === value00 && value1 === value10 ? interpolate0\n : interpolate0 = interpolate$$2(value00 = value0, value10 = value1);\n };\n}\n\nfunction styleRemoveEnd(name) {\n return function() {\n this.style.removeProperty(name);\n };\n}\n\nfunction styleConstant$1(name, interpolate$$2, value1) {\n var value00,\n interpolate0;\n return function() {\n var value0 = window(this).getComputedStyle(this, null).getPropertyValue(name);\n return value0 === value1 ? null\n : value0 === value00 ? interpolate0\n : interpolate0 = interpolate$$2(value00 = value0, value1);\n };\n}\n\nfunction styleFunction$1(name, interpolate$$2, value) {\n var value00,\n value10,\n interpolate0;\n return function() {\n var style = window(this).getComputedStyle(this, null),\n value0 = style.getPropertyValue(name),\n value1 = value(this);\n if (value1 == null) value1 = (this.style.removeProperty(name), style.getPropertyValue(name));\n return value0 === value1 ? null\n : value0 === value00 && value1 === value10 ? interpolate0\n : interpolate0 = interpolate$$2(value00 = value0, value10 = value1);\n };\n}\n\nvar transition_style = function(name, value, priority) {\n var i = (name += \"\") === \"transform\" ? interpolateTransformCss : interpolate$$1;\n return value == null ? this\n .styleTween(name, styleRemove$1(name, i))\n .on(\"end.style.\" + name, styleRemoveEnd(name))\n : this.styleTween(name, typeof value === \"function\"\n ? styleFunction$1(name, i, tweenValue(this, \"style.\" + name, value))\n : styleConstant$1(name, i, value), priority);\n};\n\nfunction styleTween(name, value, priority) {\n function tween() {\n var node = this, i = value.apply(node, arguments);\n return i && function(t) {\n node.style.setProperty(name, i(t), priority);\n };\n }\n tween._value = value;\n return tween;\n}\n\nvar transition_styleTween = function(name, value, priority) {\n var key = \"style.\" + (name += \"\");\n if (arguments.length < 2) return (key = this.tween(key)) && key._value;\n if (value == null) return this.tween(key, null);\n if (typeof value !== \"function\") throw new Error;\n return this.tween(key, styleTween(name, value, priority == null ? \"\" : priority));\n};\n\nfunction textConstant$1(value) {\n return function() {\n this.textContent = value;\n };\n}\n\nfunction textFunction$1(value) {\n return function() {\n var value1 = value(this);\n this.textContent = value1 == null ? \"\" : value1;\n };\n}\n\nvar transition_text = function(value) {\n return this.tween(\"text\", typeof value === \"function\"\n ? textFunction$1(tweenValue(this, \"text\", value))\n : textConstant$1(value == null ? \"\" : value + \"\"));\n};\n\nvar transition_transition = function() {\n var name = this._name,\n id0 = this._id,\n id1 = newId();\n\n for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) {\n for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {\n if (node = group[i]) {\n var inherit = get$1(node, id0);\n schedule(node, name, id1, i, group, {\n time: inherit.time + inherit.delay + inherit.duration,\n delay: 0,\n duration: inherit.duration,\n ease: inherit.ease\n });\n }\n }\n }\n\n return new Transition(groups, this._parents, name, id1);\n};\n\nvar id = 0;\n\nfunction Transition(groups, parents, name, id) {\n this._groups = groups;\n this._parents = parents;\n this._name = name;\n this._id = id;\n}\n\nfunction transition(name) {\n return selection().transition(name);\n}\n\nfunction newId() {\n return ++id;\n}\n\nvar selection_prototype = selection.prototype;\n\nTransition.prototype = transition.prototype = {\n constructor: Transition,\n select: transition_select,\n selectAll: transition_selectAll,\n filter: transition_filter,\n merge: transition_merge,\n selection: transition_selection,\n transition: transition_transition,\n call: selection_prototype.call,\n nodes: selection_prototype.nodes,\n node: selection_prototype.node,\n size: selection_prototype.size,\n empty: selection_prototype.empty,\n each: selection_prototype.each,\n on: transition_on,\n attr: transition_attr,\n attrTween: transition_attrTween,\n style: transition_style,\n styleTween: transition_styleTween,\n text: transition_text,\n remove: transition_remove,\n tween: transition_tween,\n delay: transition_delay,\n duration: transition_duration,\n ease: transition_ease\n};\n\nfunction linear$1(t) {\n return +t;\n}\n\nfunction quadIn(t) {\n return t * t;\n}\n\nfunction quadOut(t) {\n return t * (2 - t);\n}\n\nfunction quadInOut(t) {\n return ((t *= 2) <= 1 ? t * t : --t * (2 - t) + 1) / 2;\n}\n\nfunction cubicIn(t) {\n return t * t * t;\n}\n\nfunction cubicOut(t) {\n return --t * t * t + 1;\n}\n\nfunction cubicInOut(t) {\n return ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2;\n}\n\nvar exponent = 3;\n\nvar polyIn = (function custom(e) {\n e = +e;\n\n function polyIn(t) {\n return Math.pow(t, e);\n }\n\n polyIn.exponent = custom;\n\n return polyIn;\n})(exponent);\n\nvar polyOut = (function custom(e) {\n e = +e;\n\n function polyOut(t) {\n return 1 - Math.pow(1 - t, e);\n }\n\n polyOut.exponent = custom;\n\n return polyOut;\n})(exponent);\n\nvar polyInOut = (function custom(e) {\n e = +e;\n\n function polyInOut(t) {\n return ((t *= 2) <= 1 ? Math.pow(t, e) : 2 - Math.pow(2 - t, e)) / 2;\n }\n\n polyInOut.exponent = custom;\n\n return polyInOut;\n})(exponent);\n\nvar pi = Math.PI;\nvar halfPi = pi / 2;\n\nfunction sinIn(t) {\n return 1 - Math.cos(t * halfPi);\n}\n\nfunction sinOut(t) {\n return Math.sin(t * halfPi);\n}\n\nfunction sinInOut(t) {\n return (1 - Math.cos(pi * t)) / 2;\n}\n\nfunction expIn(t) {\n return Math.pow(2, 10 * t - 10);\n}\n\nfunction expOut(t) {\n return 1 - Math.pow(2, -10 * t);\n}\n\nfunction expInOut(t) {\n return ((t *= 2) <= 1 ? Math.pow(2, 10 * t - 10) : 2 - Math.pow(2, 10 - 10 * t)) / 2;\n}\n\nfunction circleIn(t) {\n return 1 - Math.sqrt(1 - t * t);\n}\n\nfunction circleOut(t) {\n return Math.sqrt(1 - --t * t);\n}\n\nfunction circleInOut(t) {\n return ((t *= 2) <= 1 ? 1 - Math.sqrt(1 - t * t) : Math.sqrt(1 - (t -= 2) * t) + 1) / 2;\n}\n\nvar b1 = 4 / 11;\nvar b2 = 6 / 11;\nvar b3 = 8 / 11;\nvar b4 = 3 / 4;\nvar b5 = 9 / 11;\nvar b6 = 10 / 11;\nvar b7 = 15 / 16;\nvar b8 = 21 / 22;\nvar b9 = 63 / 64;\nvar b0 = 1 / b1 / b1;\n\nfunction bounceIn(t) {\n return 1 - bounceOut(1 - t);\n}\n\nfunction bounceOut(t) {\n return (t = +t) < b1 ? b0 * t * t : t < b3 ? b0 * (t -= b2) * t + b4 : t < b6 ? b0 * (t -= b5) * t + b7 : b0 * (t -= b8) * t + b9;\n}\n\nfunction bounceInOut(t) {\n return ((t *= 2) <= 1 ? 1 - bounceOut(1 - t) : bounceOut(t - 1) + 1) / 2;\n}\n\nvar overshoot = 1.70158;\n\nvar backIn = (function custom(s) {\n s = +s;\n\n function backIn(t) {\n return t * t * ((s + 1) * t - s);\n }\n\n backIn.overshoot = custom;\n\n return backIn;\n})(overshoot);\n\nvar backOut = (function custom(s) {\n s = +s;\n\n function backOut(t) {\n return --t * t * ((s + 1) * t + s) + 1;\n }\n\n backOut.overshoot = custom;\n\n return backOut;\n})(overshoot);\n\nvar backInOut = (function custom(s) {\n s = +s;\n\n function backInOut(t) {\n return ((t *= 2) < 1 ? t * t * ((s + 1) * t - s) : (t -= 2) * t * ((s + 1) * t + s) + 2) / 2;\n }\n\n backInOut.overshoot = custom;\n\n return backInOut;\n})(overshoot);\n\nvar tau = 2 * Math.PI;\nvar amplitude = 1;\nvar period = 0.3;\n\nvar elasticIn = (function custom(a, p) {\n var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau);\n\n function elasticIn(t) {\n return a * Math.pow(2, 10 * --t) * Math.sin((s - t) / p);\n }\n\n elasticIn.amplitude = function(a) { return custom(a, p * tau); };\n elasticIn.period = function(p) { return custom(a, p); };\n\n return elasticIn;\n})(amplitude, period);\n\nvar elasticOut = (function custom(a, p) {\n var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau);\n\n function elasticOut(t) {\n return 1 - a * Math.pow(2, -10 * (t = +t)) * Math.sin((t + s) / p);\n }\n\n elasticOut.amplitude = function(a) { return custom(a, p * tau); };\n elasticOut.period = function(p) { return custom(a, p); };\n\n return elasticOut;\n})(amplitude, period);\n\nvar elasticInOut = (function custom(a, p) {\n var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau);\n\n function elasticInOut(t) {\n return ((t = t * 2 - 1) < 0\n ? a * Math.pow(2, 10 * t) * Math.sin((s - t) / p)\n : 2 - a * Math.pow(2, -10 * t) * Math.sin((s + t) / p)) / 2;\n }\n\n elasticInOut.amplitude = function(a) { return custom(a, p * tau); };\n elasticInOut.period = function(p) { return custom(a, p); };\n\n return elasticInOut;\n})(amplitude, period);\n\nvar defaultTiming = {\n time: null, // Set on use.\n delay: 0,\n duration: 250,\n ease: cubicInOut\n};\n\nfunction inherit(node, id) {\n var timing;\n while (!(timing = node.__transition) || !(timing = timing[id])) {\n if (!(node = node.parentNode)) {\n return defaultTiming.time = now(), defaultTiming;\n }\n }\n return timing;\n}\n\nvar selection_transition = function(name) {\n var id,\n timing;\n\n if (name instanceof Transition) {\n id = name._id, name = name._name;\n } else {\n id = newId(), (timing = defaultTiming).time = now(), name = name == null ? null : name + \"\";\n }\n\n for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) {\n for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {\n if (node = group[i]) {\n schedule(node, name, id, i, group, timing || inherit(node, id));\n }\n }\n }\n\n return new Transition(groups, this._parents, name, id);\n};\n\nselection.prototype.interrupt = selection_interrupt;\nselection.prototype.transition = selection_transition;\n\nvar root$1 = [null];\n\nvar active = function(node, name) {\n var schedules = node.__transition,\n schedule,\n i;\n\n if (schedules) {\n name = name == null ? null : name + \"\";\n for (i in schedules) {\n if ((schedule = schedules[i]).state > SCHEDULED && schedule.name === name) {\n return new Transition([[node]], root$1, name, +i);\n }\n }\n }\n\n return null;\n};\n\nvar constant$4 = function(x) {\n return function() {\n return x;\n };\n};\n\nvar BrushEvent = function(target, type, selection) {\n this.target = target;\n this.type = type;\n this.selection = selection;\n};\n\nfunction nopropagation$1() {\n exports.event.stopImmediatePropagation();\n}\n\nvar noevent$1 = function() {\n exports.event.preventDefault();\n exports.event.stopImmediatePropagation();\n};\n\nvar MODE_DRAG = {name: \"drag\"};\nvar MODE_SPACE = {name: \"space\"};\nvar MODE_HANDLE = {name: \"handle\"};\nvar MODE_CENTER = {name: \"center\"};\n\nvar X = {\n name: \"x\",\n handles: [\"e\", \"w\"].map(type),\n input: function(x, e) { return x && [[x[0], e[0][1]], [x[1], e[1][1]]]; },\n output: function(xy) { return xy && [xy[0][0], xy[1][0]]; }\n};\n\nvar Y = {\n name: \"y\",\n handles: [\"n\", \"s\"].map(type),\n input: function(y, e) { return y && [[e[0][0], y[0]], [e[1][0], y[1]]]; },\n output: function(xy) { return xy && [xy[0][1], xy[1][1]]; }\n};\n\nvar XY = {\n name: \"xy\",\n handles: [\"n\", \"e\", \"s\", \"w\", \"nw\", \"ne\", \"se\", \"sw\"].map(type),\n input: function(xy) { return xy; },\n output: function(xy) { return xy; }\n};\n\nvar cursors = {\n overlay: \"crosshair\",\n selection: \"move\",\n n: \"ns-resize\",\n e: \"ew-resize\",\n s: \"ns-resize\",\n w: \"ew-resize\",\n nw: \"nwse-resize\",\n ne: \"nesw-resize\",\n se: \"nwse-resize\",\n sw: \"nesw-resize\"\n};\n\nvar flipX = {\n e: \"w\",\n w: \"e\",\n nw: \"ne\",\n ne: \"nw\",\n se: \"sw\",\n sw: \"se\"\n};\n\nvar flipY = {\n n: \"s\",\n s: \"n\",\n nw: \"sw\",\n ne: \"se\",\n se: \"ne\",\n sw: \"nw\"\n};\n\nvar signsX = {\n overlay: +1,\n selection: +1,\n n: null,\n e: +1,\n s: null,\n w: -1,\n nw: -1,\n ne: +1,\n se: +1,\n sw: -1\n};\n\nvar signsY = {\n overlay: +1,\n selection: +1,\n n: -1,\n e: null,\n s: +1,\n w: null,\n nw: -1,\n ne: -1,\n se: +1,\n sw: +1\n};\n\nfunction type(t) {\n return {type: t};\n}\n\n// Ignore right-click, since that should open the context menu.\nfunction defaultFilter() {\n return !exports.event.button;\n}\n\nfunction defaultExtent() {\n var svg = this.ownerSVGElement || this;\n return [[0, 0], [svg.width.baseVal.value, svg.height.baseVal.value]];\n}\n\n// Like d3.local, but with the name “__brush” rather than auto-generated.\nfunction local$$1(node) {\n while (!node.__brush) if (!(node = node.parentNode)) return;\n return node.__brush;\n}\n\nfunction empty(extent) {\n return extent[0][0] === extent[1][0]\n || extent[0][1] === extent[1][1];\n}\n\nfunction brushSelection(node) {\n var state = node.__brush;\n return state ? state.dim.output(state.selection) : null;\n}\n\nfunction brushX() {\n return brush$1(X);\n}\n\nfunction brushY() {\n return brush$1(Y);\n}\n\nvar brush = function() {\n return brush$1(XY);\n};\n\nfunction brush$1(dim) {\n var extent = defaultExtent,\n filter = defaultFilter,\n listeners = dispatch(brush, \"start\", \"brush\", \"end\"),\n handleSize = 6,\n touchending;\n\n function brush(group) {\n var overlay = group\n .property(\"__brush\", initialize)\n .selectAll(\".overlay\")\n .data([type(\"overlay\")]);\n\n overlay.enter().append(\"rect\")\n .attr(\"class\", \"overlay\")\n .attr(\"pointer-events\", \"all\")\n .attr(\"cursor\", cursors.overlay)\n .merge(overlay)\n .each(function() {\n var extent = local$$1(this).extent;\n select(this)\n .attr(\"x\", extent[0][0])\n .attr(\"y\", extent[0][1])\n .attr(\"width\", extent[1][0] - extent[0][0])\n .attr(\"height\", extent[1][1] - extent[0][1]);\n });\n\n group.selectAll(\".selection\")\n .data([type(\"selection\")])\n .enter().append(\"rect\")\n .attr(\"class\", \"selection\")\n .attr(\"cursor\", cursors.selection)\n .attr(\"fill\", \"#777\")\n .attr(\"fill-opacity\", 0.3)\n .attr(\"stroke\", \"#fff\")\n .attr(\"shape-rendering\", \"crispEdges\");\n\n var handle = group.selectAll(\".handle\")\n .data(dim.handles, function(d) { return d.type; });\n\n handle.exit().remove();\n\n handle.enter().append(\"rect\")\n .attr(\"class\", function(d) { return \"handle handle--\" + d.type; })\n .attr(\"cursor\", function(d) { return cursors[d.type]; });\n\n group\n .each(redraw)\n .attr(\"fill\", \"none\")\n .attr(\"pointer-events\", \"all\")\n .style(\"-webkit-tap-highlight-color\", \"rgba(0,0,0,0)\")\n .on(\"mousedown.brush touchstart.brush\", started);\n }\n\n brush.move = function(group, selection$$1) {\n if (group.selection) {\n group\n .on(\"start.brush\", function() { emitter(this, arguments).beforestart().start(); })\n .on(\"interrupt.brush end.brush\", function() { emitter(this, arguments).end(); })\n .tween(\"brush\", function() {\n var that = this,\n state = that.__brush,\n emit = emitter(that, arguments),\n selection0 = state.selection,\n selection1 = dim.input(typeof selection$$1 === \"function\" ? selection$$1.apply(this, arguments) : selection$$1, state.extent),\n i = interpolateValue(selection0, selection1);\n\n function tween(t) {\n state.selection = t === 1 && empty(selection1) ? null : i(t);\n redraw.call(that);\n emit.brush();\n }\n\n return selection0 && selection1 ? tween : tween(1);\n });\n } else {\n group\n .each(function() {\n var that = this,\n args = arguments,\n state = that.__brush,\n selection1 = dim.input(typeof selection$$1 === \"function\" ? selection$$1.apply(that, args) : selection$$1, state.extent),\n emit = emitter(that, args).beforestart();\n\n interrupt(that);\n state.selection = selection1 == null || empty(selection1) ? null : selection1;\n redraw.call(that);\n emit.start().brush().end();\n });\n }\n };\n\n function redraw() {\n var group = select(this),\n selection$$1 = local$$1(this).selection;\n\n if (selection$$1) {\n group.selectAll(\".selection\")\n .style(\"display\", null)\n .attr(\"x\", selection$$1[0][0])\n .attr(\"y\", selection$$1[0][1])\n .attr(\"width\", selection$$1[1][0] - selection$$1[0][0])\n .attr(\"height\", selection$$1[1][1] - selection$$1[0][1]);\n\n group.selectAll(\".handle\")\n .style(\"display\", null)\n .attr(\"x\", function(d) { return d.type[d.type.length - 1] === \"e\" ? selection$$1[1][0] - handleSize / 2 : selection$$1[0][0] - handleSize / 2; })\n .attr(\"y\", function(d) { return d.type[0] === \"s\" ? selection$$1[1][1] - handleSize / 2 : selection$$1[0][1] - handleSize / 2; })\n .attr(\"width\", function(d) { return d.type === \"n\" || d.type === \"s\" ? selection$$1[1][0] - selection$$1[0][0] + handleSize : handleSize; })\n .attr(\"height\", function(d) { return d.type === \"e\" || d.type === \"w\" ? selection$$1[1][1] - selection$$1[0][1] + handleSize : handleSize; });\n }\n\n else {\n group.selectAll(\".selection,.handle\")\n .style(\"display\", \"none\")\n .attr(\"x\", null)\n .attr(\"y\", null)\n .attr(\"width\", null)\n .attr(\"height\", null);\n }\n }\n\n function emitter(that, args) {\n return that.__brush.emitter || new Emitter(that, args);\n }\n\n function Emitter(that, args) {\n this.that = that;\n this.args = args;\n this.state = that.__brush;\n this.active = 0;\n }\n\n Emitter.prototype = {\n beforestart: function() {\n if (++this.active === 1) this.state.emitter = this, this.starting = true;\n return this;\n },\n start: function() {\n if (this.starting) this.starting = false, this.emit(\"start\");\n return this;\n },\n brush: function() {\n this.emit(\"brush\");\n return this;\n },\n end: function() {\n if (--this.active === 0) delete this.state.emitter, this.emit(\"end\");\n return this;\n },\n emit: function(type) {\n customEvent(new BrushEvent(brush, type, dim.output(this.state.selection)), listeners.apply, listeners, [type, this.that, this.args]);\n }\n };\n\n function started() {\n if (exports.event.touches) { if (exports.event.changedTouches.length < exports.event.touches.length) return noevent$1(); }\n else if (touchending) return;\n if (!filter.apply(this, arguments)) return;\n\n var that = this,\n type = exports.event.target.__data__.type,\n mode = (exports.event.metaKey ? type = \"overlay\" : type) === \"selection\" ? MODE_DRAG : (exports.event.altKey ? MODE_CENTER : MODE_HANDLE),\n signX = dim === Y ? null : signsX[type],\n signY = dim === X ? null : signsY[type],\n state = local$$1(that),\n extent = state.extent,\n selection$$1 = state.selection,\n W = extent[0][0], w0, w1,\n N = extent[0][1], n0, n1,\n E = extent[1][0], e0, e1,\n S = extent[1][1], s0, s1,\n dx,\n dy,\n moving,\n shifting = signX && signY && exports.event.shiftKey,\n lockX,\n lockY,\n point0 = mouse(that),\n point = point0,\n emit = emitter(that, arguments).beforestart();\n\n if (type === \"overlay\") {\n state.selection = selection$$1 = [\n [w0 = dim === Y ? W : point0[0], n0 = dim === X ? N : point0[1]],\n [e0 = dim === Y ? E : w0, s0 = dim === X ? S : n0]\n ];\n } else {\n w0 = selection$$1[0][0];\n n0 = selection$$1[0][1];\n e0 = selection$$1[1][0];\n s0 = selection$$1[1][1];\n }\n\n w1 = w0;\n n1 = n0;\n e1 = e0;\n s1 = s0;\n\n var group = select(that)\n .attr(\"pointer-events\", \"none\");\n\n var overlay = group.selectAll(\".overlay\")\n .attr(\"cursor\", cursors[type]);\n\n if (exports.event.touches) {\n group\n .on(\"touchmove.brush\", moved, true)\n .on(\"touchend.brush touchcancel.brush\", ended, true);\n } else {\n var view = select(exports.event.view)\n .on(\"keydown.brush\", keydowned, true)\n .on(\"keyup.brush\", keyupped, true)\n .on(\"mousemove.brush\", moved, true)\n .on(\"mouseup.brush\", ended, true);\n\n dragDisable(exports.event.view);\n }\n\n nopropagation$1();\n interrupt(that);\n redraw.call(that);\n emit.start();\n\n function moved() {\n var point1 = mouse(that);\n if (shifting && !lockX && !lockY) {\n if (Math.abs(point1[0] - point[0]) > Math.abs(point1[1] - point[1])) lockY = true;\n else lockX = true;\n }\n point = point1;\n moving = true;\n noevent$1();\n move();\n }\n\n function move() {\n var t;\n\n dx = point[0] - point0[0];\n dy = point[1] - point0[1];\n\n switch (mode) {\n case MODE_SPACE:\n case MODE_DRAG: {\n if (signX) dx = Math.max(W - w0, Math.min(E - e0, dx)), w1 = w0 + dx, e1 = e0 + dx;\n if (signY) dy = Math.max(N - n0, Math.min(S - s0, dy)), n1 = n0 + dy, s1 = s0 + dy;\n break;\n }\n case MODE_HANDLE: {\n if (signX < 0) dx = Math.max(W - w0, Math.min(E - w0, dx)), w1 = w0 + dx, e1 = e0;\n else if (signX > 0) dx = Math.max(W - e0, Math.min(E - e0, dx)), w1 = w0, e1 = e0 + dx;\n if (signY < 0) dy = Math.max(N - n0, Math.min(S - n0, dy)), n1 = n0 + dy, s1 = s0;\n else if (signY > 0) dy = Math.max(N - s0, Math.min(S - s0, dy)), n1 = n0, s1 = s0 + dy;\n break;\n }\n case MODE_CENTER: {\n if (signX) w1 = Math.max(W, Math.min(E, w0 - dx * signX)), e1 = Math.max(W, Math.min(E, e0 + dx * signX));\n if (signY) n1 = Math.max(N, Math.min(S, n0 - dy * signY)), s1 = Math.max(N, Math.min(S, s0 + dy * signY));\n break;\n }\n }\n\n if (e1 < w1) {\n signX *= -1;\n t = w0, w0 = e0, e0 = t;\n t = w1, w1 = e1, e1 = t;\n if (type in flipX) overlay.attr(\"cursor\", cursors[type = flipX[type]]);\n }\n\n if (s1 < n1) {\n signY *= -1;\n t = n0, n0 = s0, s0 = t;\n t = n1, n1 = s1, s1 = t;\n if (type in flipY) overlay.attr(\"cursor\", cursors[type = flipY[type]]);\n }\n\n if (state.selection) selection$$1 = state.selection; // May be set by brush.move!\n if (lockX) w1 = selection$$1[0][0], e1 = selection$$1[1][0];\n if (lockY) n1 = selection$$1[0][1], s1 = selection$$1[1][1];\n\n if (selection$$1[0][0] !== w1\n || selection$$1[0][1] !== n1\n || selection$$1[1][0] !== e1\n || selection$$1[1][1] !== s1) {\n state.selection = [[w1, n1], [e1, s1]];\n redraw.call(that);\n emit.brush();\n }\n }\n\n function ended() {\n nopropagation$1();\n if (exports.event.touches) {\n if (exports.event.touches.length) return;\n if (touchending) clearTimeout(touchending);\n touchending = setTimeout(function() { touchending = null; }, 500); // Ghost clicks are delayed!\n group.on(\"touchmove.brush touchend.brush touchcancel.brush\", null);\n } else {\n yesdrag(exports.event.view, moving);\n view.on(\"keydown.brush keyup.brush mousemove.brush mouseup.brush\", null);\n }\n group.attr(\"pointer-events\", \"all\");\n overlay.attr(\"cursor\", cursors.overlay);\n if (state.selection) selection$$1 = state.selection; // May be set by brush.move (on start)!\n if (empty(selection$$1)) state.selection = null, redraw.call(that);\n emit.end();\n }\n\n function keydowned() {\n switch (exports.event.keyCode) {\n case 16: { // SHIFT\n shifting = signX && signY;\n break;\n }\n case 18: { // ALT\n if (mode === MODE_HANDLE) {\n if (signX) e0 = e1 - dx * signX, w0 = w1 + dx * signX;\n if (signY) s0 = s1 - dy * signY, n0 = n1 + dy * signY;\n mode = MODE_CENTER;\n move();\n }\n break;\n }\n case 32: { // SPACE; takes priority over ALT\n if (mode === MODE_HANDLE || mode === MODE_CENTER) {\n if (signX < 0) e0 = e1 - dx; else if (signX > 0) w0 = w1 - dx;\n if (signY < 0) s0 = s1 - dy; else if (signY > 0) n0 = n1 - dy;\n mode = MODE_SPACE;\n overlay.attr(\"cursor\", cursors.selection);\n move();\n }\n break;\n }\n default: return;\n }\n noevent$1();\n }\n\n function keyupped() {\n switch (exports.event.keyCode) {\n case 16: { // SHIFT\n if (shifting) {\n lockX = lockY = shifting = false;\n move();\n }\n break;\n }\n case 18: { // ALT\n if (mode === MODE_CENTER) {\n if (signX < 0) e0 = e1; else if (signX > 0) w0 = w1;\n if (signY < 0) s0 = s1; else if (signY > 0) n0 = n1;\n mode = MODE_HANDLE;\n move();\n }\n break;\n }\n case 32: { // SPACE\n if (mode === MODE_SPACE) {\n if (exports.event.altKey) {\n if (signX) e0 = e1 - dx * signX, w0 = w1 + dx * signX;\n if (signY) s0 = s1 - dy * signY, n0 = n1 + dy * signY;\n mode = MODE_CENTER;\n } else {\n if (signX < 0) e0 = e1; else if (signX > 0) w0 = w1;\n if (signY < 0) s0 = s1; else if (signY > 0) n0 = n1;\n mode = MODE_HANDLE;\n }\n overlay.attr(\"cursor\", cursors[type]);\n move();\n }\n break;\n }\n default: return;\n }\n noevent$1();\n }\n }\n\n function initialize() {\n var state = this.__brush || {selection: null};\n state.extent = extent.apply(this, arguments);\n state.dim = dim;\n return state;\n }\n\n brush.extent = function(_) {\n return arguments.length ? (extent = typeof _ === \"function\" ? _ : constant$4([[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]]), brush) : extent;\n };\n\n brush.filter = function(_) {\n return arguments.length ? (filter = typeof _ === \"function\" ? _ : constant$4(!!_), brush) : filter;\n };\n\n brush.handleSize = function(_) {\n return arguments.length ? (handleSize = +_, brush) : handleSize;\n };\n\n brush.on = function() {\n var value = listeners.on.apply(listeners, arguments);\n return value === listeners ? brush : value;\n };\n\n return brush;\n}\n\nvar cos = Math.cos;\nvar sin = Math.sin;\nvar pi$1 = Math.PI;\nvar halfPi$1 = pi$1 / 2;\nvar tau$1 = pi$1 * 2;\nvar max$1 = Math.max;\n\nfunction compareValue(compare) {\n return function(a, b) {\n return compare(\n a.source.value + a.target.value,\n b.source.value + b.target.value\n );\n };\n}\n\nvar chord = function() {\n var padAngle = 0,\n sortGroups = null,\n sortSubgroups = null,\n sortChords = null;\n\n function chord(matrix) {\n var n = matrix.length,\n groupSums = [],\n groupIndex = sequence(n),\n subgroupIndex = [],\n chords = [],\n groups = chords.groups = new Array(n),\n subgroups = new Array(n * n),\n k,\n x,\n x0,\n dx,\n i,\n j;\n\n // Compute the sum.\n k = 0, i = -1; while (++i < n) {\n x = 0, j = -1; while (++j < n) {\n x += matrix[i][j];\n }\n groupSums.push(x);\n subgroupIndex.push(sequence(n));\n k += x;\n }\n\n // Sort groups…\n if (sortGroups) groupIndex.sort(function(a, b) {\n return sortGroups(groupSums[a], groupSums[b]);\n });\n\n // Sort subgroups…\n if (sortSubgroups) subgroupIndex.forEach(function(d, i) {\n d.sort(function(a, b) {\n return sortSubgroups(matrix[i][a], matrix[i][b]);\n });\n });\n\n // Convert the sum to scaling factor for [0, 2pi].\n // TODO Allow start and end angle to be specified?\n // TODO Allow padding to be specified as percentage?\n k = max$1(0, tau$1 - padAngle * n) / k;\n dx = k ? padAngle : tau$1 / n;\n\n // Compute the start and end angle for each group and subgroup.\n // Note: Opera has a bug reordering object literal properties!\n x = 0, i = -1; while (++i < n) {\n x0 = x, j = -1; while (++j < n) {\n var di = groupIndex[i],\n dj = subgroupIndex[di][j],\n v = matrix[di][dj],\n a0 = x,\n a1 = x += v * k;\n subgroups[dj * n + di] = {\n index: di,\n subindex: dj,\n startAngle: a0,\n endAngle: a1,\n value: v\n };\n }\n groups[di] = {\n index: di,\n startAngle: x0,\n endAngle: x,\n value: groupSums[di]\n };\n x += dx;\n }\n\n // Generate chords for each (non-empty) subgroup-subgroup link.\n i = -1; while (++i < n) {\n j = i - 1; while (++j < n) {\n var source = subgroups[j * n + i],\n target = subgroups[i * n + j];\n if (source.value || target.value) {\n chords.push(source.value < target.value\n ? {source: target, target: source}\n : {source: source, target: target});\n }\n }\n }\n\n return sortChords ? chords.sort(sortChords) : chords;\n }\n\n chord.padAngle = function(_) {\n return arguments.length ? (padAngle = max$1(0, _), chord) : padAngle;\n };\n\n chord.sortGroups = function(_) {\n return arguments.length ? (sortGroups = _, chord) : sortGroups;\n };\n\n chord.sortSubgroups = function(_) {\n return arguments.length ? (sortSubgroups = _, chord) : sortSubgroups;\n };\n\n chord.sortChords = function(_) {\n return arguments.length ? (_ == null ? sortChords = null : (sortChords = compareValue(_))._ = _, chord) : sortChords && sortChords._;\n };\n\n return chord;\n};\n\nvar slice$2 = Array.prototype.slice;\n\nvar constant$5 = function(x) {\n return function() {\n return x;\n };\n};\n\nvar pi$2 = Math.PI;\nvar tau$2 = 2 * pi$2;\nvar epsilon$1 = 1e-6;\nvar tauEpsilon = tau$2 - epsilon$1;\n\nfunction Path() {\n this._x0 = this._y0 = // start of current subpath\n this._x1 = this._y1 = null; // end of current subpath\n this._ = \"\";\n}\n\nfunction path() {\n return new Path;\n}\n\nPath.prototype = path.prototype = {\n constructor: Path,\n moveTo: function(x, y) {\n this._ += \"M\" + (this._x0 = this._x1 = +x) + \",\" + (this._y0 = this._y1 = +y);\n },\n closePath: function() {\n if (this._x1 !== null) {\n this._x1 = this._x0, this._y1 = this._y0;\n this._ += \"Z\";\n }\n },\n lineTo: function(x, y) {\n this._ += \"L\" + (this._x1 = +x) + \",\" + (this._y1 = +y);\n },\n quadraticCurveTo: function(x1, y1, x, y) {\n this._ += \"Q\" + (+x1) + \",\" + (+y1) + \",\" + (this._x1 = +x) + \",\" + (this._y1 = +y);\n },\n bezierCurveTo: function(x1, y1, x2, y2, x, y) {\n this._ += \"C\" + (+x1) + \",\" + (+y1) + \",\" + (+x2) + \",\" + (+y2) + \",\" + (this._x1 = +x) + \",\" + (this._y1 = +y);\n },\n arcTo: function(x1, y1, x2, y2, r) {\n x1 = +x1, y1 = +y1, x2 = +x2, y2 = +y2, r = +r;\n var x0 = this._x1,\n y0 = this._y1,\n x21 = x2 - x1,\n y21 = y2 - y1,\n x01 = x0 - x1,\n y01 = y0 - y1,\n l01_2 = x01 * x01 + y01 * y01;\n\n // Is the radius negative? Error.\n if (r < 0) throw new Error(\"negative radius: \" + r);\n\n // Is this path empty? Move to (x1,y1).\n if (this._x1 === null) {\n this._ += \"M\" + (this._x1 = x1) + \",\" + (this._y1 = y1);\n }\n\n // Or, is (x1,y1) coincident with (x0,y0)? Do nothing.\n else if (!(l01_2 > epsilon$1)) {}\n\n // Or, are (x0,y0), (x1,y1) and (x2,y2) collinear?\n // Equivalently, is (x1,y1) coincident with (x2,y2)?\n // Or, is the radius zero? Line to (x1,y1).\n else if (!(Math.abs(y01 * x21 - y21 * x01) > epsilon$1) || !r) {\n this._ += \"L\" + (this._x1 = x1) + \",\" + (this._y1 = y1);\n }\n\n // Otherwise, draw an arc!\n else {\n var x20 = x2 - x0,\n y20 = y2 - y0,\n l21_2 = x21 * x21 + y21 * y21,\n l20_2 = x20 * x20 + y20 * y20,\n l21 = Math.sqrt(l21_2),\n l01 = Math.sqrt(l01_2),\n l = r * Math.tan((pi$2 - Math.acos((l21_2 + l01_2 - l20_2) / (2 * l21 * l01))) / 2),\n t01 = l / l01,\n t21 = l / l21;\n\n // If the start tangent is not coincident with (x0,y0), line to.\n if (Math.abs(t01 - 1) > epsilon$1) {\n this._ += \"L\" + (x1 + t01 * x01) + \",\" + (y1 + t01 * y01);\n }\n\n this._ += \"A\" + r + \",\" + r + \",0,0,\" + (+(y01 * x20 > x01 * y20)) + \",\" + (this._x1 = x1 + t21 * x21) + \",\" + (this._y1 = y1 + t21 * y21);\n }\n },\n arc: function(x, y, r, a0, a1, ccw) {\n x = +x, y = +y, r = +r;\n var dx = r * Math.cos(a0),\n dy = r * Math.sin(a0),\n x0 = x + dx,\n y0 = y + dy,\n cw = 1 ^ ccw,\n da = ccw ? a0 - a1 : a1 - a0;\n\n // Is the radius negative? Error.\n if (r < 0) throw new Error(\"negative radius: \" + r);\n\n // Is this path empty? Move to (x0,y0).\n if (this._x1 === null) {\n this._ += \"M\" + x0 + \",\" + y0;\n }\n\n // Or, is (x0,y0) not coincident with the previous point? Line to (x0,y0).\n else if (Math.abs(this._x1 - x0) > epsilon$1 || Math.abs(this._y1 - y0) > epsilon$1) {\n this._ += \"L\" + x0 + \",\" + y0;\n }\n\n // Is this arc empty? We’re done.\n if (!r) return;\n\n // Is this a complete circle? Draw two arcs to complete the circle.\n if (da > tauEpsilon) {\n this._ += \"A\" + r + \",\" + r + \",0,1,\" + cw + \",\" + (x - dx) + \",\" + (y - dy) + \"A\" + r + \",\" + r + \",0,1,\" + cw + \",\" + (this._x1 = x0) + \",\" + (this._y1 = y0);\n }\n\n // Otherwise, draw an arc!\n else {\n if (da < 0) da = da % tau$2 + tau$2;\n this._ += \"A\" + r + \",\" + r + \",0,\" + (+(da >= pi$2)) + \",\" + cw + \",\" + (this._x1 = x + r * Math.cos(a1)) + \",\" + (this._y1 = y + r * Math.sin(a1));\n }\n },\n rect: function(x, y, w, h) {\n this._ += \"M\" + (this._x0 = this._x1 = +x) + \",\" + (this._y0 = this._y1 = +y) + \"h\" + (+w) + \"v\" + (+h) + \"h\" + (-w) + \"Z\";\n },\n toString: function() {\n return this._;\n }\n};\n\nfunction defaultSource(d) {\n return d.source;\n}\n\nfunction defaultTarget(d) {\n return d.target;\n}\n\nfunction defaultRadius(d) {\n return d.radius;\n}\n\nfunction defaultStartAngle(d) {\n return d.startAngle;\n}\n\nfunction defaultEndAngle(d) {\n return d.endAngle;\n}\n\nvar ribbon = function() {\n var source = defaultSource,\n target = defaultTarget,\n radius = defaultRadius,\n startAngle = defaultStartAngle,\n endAngle = defaultEndAngle,\n context = null;\n\n function ribbon() {\n var buffer,\n argv = slice$2.call(arguments),\n s = source.apply(this, argv),\n t = target.apply(this, argv),\n sr = +radius.apply(this, (argv[0] = s, argv)),\n sa0 = startAngle.apply(this, argv) - halfPi$1,\n sa1 = endAngle.apply(this, argv) - halfPi$1,\n sx0 = sr * cos(sa0),\n sy0 = sr * sin(sa0),\n tr = +radius.apply(this, (argv[0] = t, argv)),\n ta0 = startAngle.apply(this, argv) - halfPi$1,\n ta1 = endAngle.apply(this, argv) - halfPi$1;\n\n if (!context) context = buffer = path();\n\n context.moveTo(sx0, sy0);\n context.arc(0, 0, sr, sa0, sa1);\n if (sa0 !== ta0 || sa1 !== ta1) { // TODO sr !== tr?\n context.quadraticCurveTo(0, 0, tr * cos(ta0), tr * sin(ta0));\n context.arc(0, 0, tr, ta0, ta1);\n }\n context.quadraticCurveTo(0, 0, sx0, sy0);\n context.closePath();\n\n if (buffer) return context = null, buffer + \"\" || null;\n }\n\n ribbon.radius = function(_) {\n return arguments.length ? (radius = typeof _ === \"function\" ? _ : constant$5(+_), ribbon) : radius;\n };\n\n ribbon.startAngle = function(_) {\n return arguments.length ? (startAngle = typeof _ === \"function\" ? _ : constant$5(+_), ribbon) : startAngle;\n };\n\n ribbon.endAngle = function(_) {\n return arguments.length ? (endAngle = typeof _ === \"function\" ? _ : constant$5(+_), ribbon) : endAngle;\n };\n\n ribbon.source = function(_) {\n return arguments.length ? (source = _, ribbon) : source;\n };\n\n ribbon.target = function(_) {\n return arguments.length ? (target = _, ribbon) : target;\n };\n\n ribbon.context = function(_) {\n return arguments.length ? ((context = _ == null ? null : _), ribbon) : context;\n };\n\n return ribbon;\n};\n\nvar prefix = \"$\";\n\nfunction Map() {}\n\nMap.prototype = map$1.prototype = {\n constructor: Map,\n has: function(key) {\n return (prefix + key) in this;\n },\n get: function(key) {\n return this[prefix + key];\n },\n set: function(key, value) {\n this[prefix + key] = value;\n return this;\n },\n remove: function(key) {\n var property = prefix + key;\n return property in this && delete this[property];\n },\n clear: function() {\n for (var property in this) if (property[0] === prefix) delete this[property];\n },\n keys: function() {\n var keys = [];\n for (var property in this) if (property[0] === prefix) keys.push(property.slice(1));\n return keys;\n },\n values: function() {\n var values = [];\n for (var property in this) if (property[0] === prefix) values.push(this[property]);\n return values;\n },\n entries: function() {\n var entries = [];\n for (var property in this) if (property[0] === prefix) entries.push({key: property.slice(1), value: this[property]});\n return entries;\n },\n size: function() {\n var size = 0;\n for (var property in this) if (property[0] === prefix) ++size;\n return size;\n },\n empty: function() {\n for (var property in this) if (property[0] === prefix) return false;\n return true;\n },\n each: function(f) {\n for (var property in this) if (property[0] === prefix) f(this[property], property.slice(1), this);\n }\n};\n\nfunction map$1(object, f) {\n var map = new Map;\n\n // Copy constructor.\n if (object instanceof Map) object.each(function(value, key) { map.set(key, value); });\n\n // Index array by numeric index or specified key function.\n else if (Array.isArray(object)) {\n var i = -1,\n n = object.length,\n o;\n\n if (f == null) while (++i < n) map.set(i, object[i]);\n else while (++i < n) map.set(f(o = object[i], i, object), o);\n }\n\n // Convert object to map.\n else if (object) for (var key in object) map.set(key, object[key]);\n\n return map;\n}\n\nvar nest = function() {\n var keys = [],\n sortKeys = [],\n sortValues,\n rollup,\n nest;\n\n function apply(array, depth, createResult, setResult) {\n if (depth >= keys.length) return rollup != null\n ? rollup(array) : (sortValues != null\n ? array.sort(sortValues)\n : array);\n\n var i = -1,\n n = array.length,\n key = keys[depth++],\n keyValue,\n value,\n valuesByKey = map$1(),\n values,\n result = createResult();\n\n while (++i < n) {\n if (values = valuesByKey.get(keyValue = key(value = array[i]) + \"\")) {\n values.push(value);\n } else {\n valuesByKey.set(keyValue, [value]);\n }\n }\n\n valuesByKey.each(function(values, key) {\n setResult(result, key, apply(values, depth, createResult, setResult));\n });\n\n return result;\n }\n\n function entries(map, depth) {\n if (++depth > keys.length) return map;\n var array, sortKey = sortKeys[depth - 1];\n if (rollup != null && depth >= keys.length) array = map.entries();\n else array = [], map.each(function(v, k) { array.push({key: k, values: entries(v, depth)}); });\n return sortKey != null ? array.sort(function(a, b) { return sortKey(a.key, b.key); }) : array;\n }\n\n return nest = {\n object: function(array) { return apply(array, 0, createObject, setObject); },\n map: function(array) { return apply(array, 0, createMap, setMap); },\n entries: function(array) { return entries(apply(array, 0, createMap, setMap), 0); },\n key: function(d) { keys.push(d); return nest; },\n sortKeys: function(order) { sortKeys[keys.length - 1] = order; return nest; },\n sortValues: function(order) { sortValues = order; return nest; },\n rollup: function(f) { rollup = f; return nest; }\n };\n};\n\nfunction createObject() {\n return {};\n}\n\nfunction setObject(object, key, value) {\n object[key] = value;\n}\n\nfunction createMap() {\n return map$1();\n}\n\nfunction setMap(map, key, value) {\n map.set(key, value);\n}\n\nfunction Set() {}\n\nvar proto = map$1.prototype;\n\nSet.prototype = set$2.prototype = {\n constructor: Set,\n has: proto.has,\n add: function(value) {\n value += \"\";\n this[prefix + value] = value;\n return this;\n },\n remove: proto.remove,\n clear: proto.clear,\n values: proto.keys,\n size: proto.size,\n empty: proto.empty,\n each: proto.each\n};\n\nfunction set$2(object, f) {\n var set = new Set;\n\n // Copy constructor.\n if (object instanceof Set) object.each(function(value) { set.add(value); });\n\n // Otherwise, assume it’s an array.\n else if (object) {\n var i = -1, n = object.length;\n if (f == null) while (++i < n) set.add(object[i]);\n else while (++i < n) set.add(f(object[i], i, object));\n }\n\n return set;\n}\n\nvar keys = function(map) {\n var keys = [];\n for (var key in map) keys.push(key);\n return keys;\n};\n\nvar values = function(map) {\n var values = [];\n for (var key in map) values.push(map[key]);\n return values;\n};\n\nvar entries = function(map) {\n var entries = [];\n for (var key in map) entries.push({key: key, value: map[key]});\n return entries;\n};\n\nfunction objectConverter(columns) {\n return new Function(\"d\", \"return {\" + columns.map(function(name, i) {\n return JSON.stringify(name) + \": d[\" + i + \"]\";\n }).join(\",\") + \"}\");\n}\n\nfunction customConverter(columns, f) {\n var object = objectConverter(columns);\n return function(row, i) {\n return f(object(row), i, columns);\n };\n}\n\n// Compute unique columns in order of discovery.\nfunction inferColumns(rows) {\n var columnSet = Object.create(null),\n columns = [];\n\n rows.forEach(function(row) {\n for (var column in row) {\n if (!(column in columnSet)) {\n columns.push(columnSet[column] = column);\n }\n }\n });\n\n return columns;\n}\n\nvar dsv = function(delimiter) {\n var reFormat = new RegExp(\"[\\\"\" + delimiter + \"\\n]\"),\n delimiterCode = delimiter.charCodeAt(0);\n\n function parse(text, f) {\n var convert, columns, rows = parseRows(text, function(row, i) {\n if (convert) return convert(row, i - 1);\n columns = row, convert = f ? customConverter(row, f) : objectConverter(row);\n });\n rows.columns = columns;\n return rows;\n }\n\n function parseRows(text, f) {\n var EOL = {}, // sentinel value for end-of-line\n EOF = {}, // sentinel value for end-of-file\n rows = [], // output rows\n N = text.length,\n I = 0, // current character index\n n = 0, // the current line number\n t, // the current token\n eol; // is the current token followed by EOL?\n\n function token() {\n if (I >= N) return EOF; // special case: end of file\n if (eol) return eol = false, EOL; // special case: end of line\n\n // special case: quotes\n var j = I, c;\n if (text.charCodeAt(j) === 34) {\n var i = j;\n while (i++ < N) {\n if (text.charCodeAt(i) === 34) {\n if (text.charCodeAt(i + 1) !== 34) break;\n ++i;\n }\n }\n I = i + 2;\n c = text.charCodeAt(i + 1);\n if (c === 13) {\n eol = true;\n if (text.charCodeAt(i + 2) === 10) ++I;\n } else if (c === 10) {\n eol = true;\n }\n return text.slice(j + 1, i).replace(/\"\"/g, \"\\\"\");\n }\n\n // common case: find next delimiter or newline\n while (I < N) {\n var k = 1;\n c = text.charCodeAt(I++);\n if (c === 10) eol = true; // \\n\n else if (c === 13) { eol = true; if (text.charCodeAt(I) === 10) ++I, ++k; } // \\r|\\r\\n\n else if (c !== delimiterCode) continue;\n return text.slice(j, I - k);\n }\n\n // special case: last token before EOF\n return text.slice(j);\n }\n\n while ((t = token()) !== EOF) {\n var a = [];\n while (t !== EOL && t !== EOF) {\n a.push(t);\n t = token();\n }\n if (f && (a = f(a, n++)) == null) continue;\n rows.push(a);\n }\n\n return rows;\n }\n\n function format(rows, columns) {\n if (columns == null) columns = inferColumns(rows);\n return [columns.map(formatValue).join(delimiter)].concat(rows.map(function(row) {\n return columns.map(function(column) {\n return formatValue(row[column]);\n }).join(delimiter);\n })).join(\"\\n\");\n }\n\n function formatRows(rows) {\n return rows.map(formatRow).join(\"\\n\");\n }\n\n function formatRow(row) {\n return row.map(formatValue).join(delimiter);\n }\n\n function formatValue(text) {\n return text == null ? \"\"\n : reFormat.test(text += \"\") ? \"\\\"\" + text.replace(/\\\"/g, \"\\\"\\\"\") + \"\\\"\"\n : text;\n }\n\n return {\n parse: parse,\n parseRows: parseRows,\n format: format,\n formatRows: formatRows\n };\n};\n\nvar csv = dsv(\",\");\n\nvar csvParse = csv.parse;\nvar csvParseRows = csv.parseRows;\nvar csvFormat = csv.format;\nvar csvFormatRows = csv.formatRows;\n\nvar tsv = dsv(\"\\t\");\n\nvar tsvParse = tsv.parse;\nvar tsvParseRows = tsv.parseRows;\nvar tsvFormat = tsv.format;\nvar tsvFormatRows = tsv.formatRows;\n\nvar center$1 = function(x, y) {\n var nodes;\n\n if (x == null) x = 0;\n if (y == null) y = 0;\n\n function force() {\n var i,\n n = nodes.length,\n node,\n sx = 0,\n sy = 0;\n\n for (i = 0; i < n; ++i) {\n node = nodes[i], sx += node.x, sy += node.y;\n }\n\n for (sx = sx / n - x, sy = sy / n - y, i = 0; i < n; ++i) {\n node = nodes[i], node.x -= sx, node.y -= sy;\n }\n }\n\n force.initialize = function(_) {\n nodes = _;\n };\n\n force.x = function(_) {\n return arguments.length ? (x = +_, force) : x;\n };\n\n force.y = function(_) {\n return arguments.length ? (y = +_, force) : y;\n };\n\n return force;\n};\n\nvar constant$6 = function(x) {\n return function() {\n return x;\n };\n};\n\nvar jiggle = function() {\n return (Math.random() - 0.5) * 1e-6;\n};\n\nvar tree_add = function(d) {\n var x = +this._x.call(null, d),\n y = +this._y.call(null, d);\n return add(this.cover(x, y), x, y, d);\n};\n\nfunction add(tree, x, y, d) {\n if (isNaN(x) || isNaN(y)) return tree; // ignore invalid points\n\n var parent,\n node = tree._root,\n leaf = {data: d},\n x0 = tree._x0,\n y0 = tree._y0,\n x1 = tree._x1,\n y1 = tree._y1,\n xm,\n ym,\n xp,\n yp,\n right,\n bottom,\n i,\n j;\n\n // If the tree is empty, initialize the root as a leaf.\n if (!node) return tree._root = leaf, tree;\n\n // Find the existing leaf for the new point, or add it.\n while (node.length) {\n if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm;\n if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym;\n if (parent = node, !(node = node[i = bottom << 1 | right])) return parent[i] = leaf, tree;\n }\n\n // Is the new point is exactly coincident with the existing point?\n xp = +tree._x.call(null, node.data);\n yp = +tree._y.call(null, node.data);\n if (x === xp && y === yp) return leaf.next = node, parent ? parent[i] = leaf : tree._root = leaf, tree;\n\n // Otherwise, split the leaf node until the old and new point are separated.\n do {\n parent = parent ? parent[i] = new Array(4) : tree._root = new Array(4);\n if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm;\n if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym;\n } while ((i = bottom << 1 | right) === (j = (yp >= ym) << 1 | (xp >= xm)));\n return parent[j] = node, parent[i] = leaf, tree;\n}\n\nfunction addAll(data) {\n var d, i, n = data.length,\n x,\n y,\n xz = new Array(n),\n yz = new Array(n),\n x0 = Infinity,\n y0 = Infinity,\n x1 = -Infinity,\n y1 = -Infinity;\n\n // Compute the points and their extent.\n for (i = 0; i < n; ++i) {\n if (isNaN(x = +this._x.call(null, d = data[i])) || isNaN(y = +this._y.call(null, d))) continue;\n xz[i] = x;\n yz[i] = y;\n if (x < x0) x0 = x;\n if (x > x1) x1 = x;\n if (y < y0) y0 = y;\n if (y > y1) y1 = y;\n }\n\n // If there were no (valid) points, inherit the existing extent.\n if (x1 < x0) x0 = this._x0, x1 = this._x1;\n if (y1 < y0) y0 = this._y0, y1 = this._y1;\n\n // Expand the tree to cover the new points.\n this.cover(x0, y0).cover(x1, y1);\n\n // Add the new points.\n for (i = 0; i < n; ++i) {\n add(this, xz[i], yz[i], data[i]);\n }\n\n return this;\n}\n\nvar tree_cover = function(x, y) {\n if (isNaN(x = +x) || isNaN(y = +y)) return this; // ignore invalid points\n\n var x0 = this._x0,\n y0 = this._y0,\n x1 = this._x1,\n y1 = this._y1;\n\n // If the quadtree has no extent, initialize them.\n // Integer extent are necessary so that if we later double the extent,\n // the existing quadrant boundaries don’t change due to floating point error!\n if (isNaN(x0)) {\n x1 = (x0 = Math.floor(x)) + 1;\n y1 = (y0 = Math.floor(y)) + 1;\n }\n\n // Otherwise, double repeatedly to cover.\n else if (x0 > x || x > x1 || y0 > y || y > y1) {\n var z = x1 - x0,\n node = this._root,\n parent,\n i;\n\n switch (i = (y < (y0 + y1) / 2) << 1 | (x < (x0 + x1) / 2)) {\n case 0: {\n do parent = new Array(4), parent[i] = node, node = parent;\n while (z *= 2, x1 = x0 + z, y1 = y0 + z, x > x1 || y > y1);\n break;\n }\n case 1: {\n do parent = new Array(4), parent[i] = node, node = parent;\n while (z *= 2, x0 = x1 - z, y1 = y0 + z, x0 > x || y > y1);\n break;\n }\n case 2: {\n do parent = new Array(4), parent[i] = node, node = parent;\n while (z *= 2, x1 = x0 + z, y0 = y1 - z, x > x1 || y0 > y);\n break;\n }\n case 3: {\n do parent = new Array(4), parent[i] = node, node = parent;\n while (z *= 2, x0 = x1 - z, y0 = y1 - z, x0 > x || y0 > y);\n break;\n }\n }\n\n if (this._root && this._root.length) this._root = node;\n }\n\n // If the quadtree covers the point already, just return.\n else return this;\n\n this._x0 = x0;\n this._y0 = y0;\n this._x1 = x1;\n this._y1 = y1;\n return this;\n};\n\nvar tree_data = function() {\n var data = [];\n this.visit(function(node) {\n if (!node.length) do data.push(node.data); while (node = node.next)\n });\n return data;\n};\n\nvar tree_extent = function(_) {\n return arguments.length\n ? this.cover(+_[0][0], +_[0][1]).cover(+_[1][0], +_[1][1])\n : isNaN(this._x0) ? undefined : [[this._x0, this._y0], [this._x1, this._y1]];\n};\n\nvar Quad = function(node, x0, y0, x1, y1) {\n this.node = node;\n this.x0 = x0;\n this.y0 = y0;\n this.x1 = x1;\n this.y1 = y1;\n};\n\nvar tree_find = function(x, y, radius) {\n var data,\n x0 = this._x0,\n y0 = this._y0,\n x1,\n y1,\n x2,\n y2,\n x3 = this._x1,\n y3 = this._y1,\n quads = [],\n node = this._root,\n q,\n i;\n\n if (node) quads.push(new Quad(node, x0, y0, x3, y3));\n if (radius == null) radius = Infinity;\n else {\n x0 = x - radius, y0 = y - radius;\n x3 = x + radius, y3 = y + radius;\n radius *= radius;\n }\n\n while (q = quads.pop()) {\n\n // Stop searching if this quadrant can’t contain a closer node.\n if (!(node = q.node)\n || (x1 = q.x0) > x3\n || (y1 = q.y0) > y3\n || (x2 = q.x1) < x0\n || (y2 = q.y1) < y0) continue;\n\n // Bisect the current quadrant.\n if (node.length) {\n var xm = (x1 + x2) / 2,\n ym = (y1 + y2) / 2;\n\n quads.push(\n new Quad(node[3], xm, ym, x2, y2),\n new Quad(node[2], x1, ym, xm, y2),\n new Quad(node[1], xm, y1, x2, ym),\n new Quad(node[0], x1, y1, xm, ym)\n );\n\n // Visit the closest quadrant first.\n if (i = (y >= ym) << 1 | (x >= xm)) {\n q = quads[quads.length - 1];\n quads[quads.length - 1] = quads[quads.length - 1 - i];\n quads[quads.length - 1 - i] = q;\n }\n }\n\n // Visit this point. (Visiting coincident points isn’t necessary!)\n else {\n var dx = x - +this._x.call(null, node.data),\n dy = y - +this._y.call(null, node.data),\n d2 = dx * dx + dy * dy;\n if (d2 < radius) {\n var d = Math.sqrt(radius = d2);\n x0 = x - d, y0 = y - d;\n x3 = x + d, y3 = y + d;\n data = node.data;\n }\n }\n }\n\n return data;\n};\n\nvar tree_remove = function(d) {\n if (isNaN(x = +this._x.call(null, d)) || isNaN(y = +this._y.call(null, d))) return this; // ignore invalid points\n\n var parent,\n node = this._root,\n retainer,\n previous,\n next,\n x0 = this._x0,\n y0 = this._y0,\n x1 = this._x1,\n y1 = this._y1,\n x,\n y,\n xm,\n ym,\n right,\n bottom,\n i,\n j;\n\n // If the tree is empty, initialize the root as a leaf.\n if (!node) return this;\n\n // Find the leaf node for the point.\n // While descending, also retain the deepest parent with a non-removed sibling.\n if (node.length) while (true) {\n if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm;\n if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym;\n if (!(parent = node, node = node[i = bottom << 1 | right])) return this;\n if (!node.length) break;\n if (parent[(i + 1) & 3] || parent[(i + 2) & 3] || parent[(i + 3) & 3]) retainer = parent, j = i;\n }\n\n // Find the point to remove.\n while (node.data !== d) if (!(previous = node, node = node.next)) return this;\n if (next = node.next) delete node.next;\n\n // If there are multiple coincident points, remove just the point.\n if (previous) return (next ? previous.next = next : delete previous.next), this;\n\n // If this is the root point, remove it.\n if (!parent) return this._root = next, this;\n\n // Remove this leaf.\n next ? parent[i] = next : delete parent[i];\n\n // If the parent now contains exactly one leaf, collapse superfluous parents.\n if ((node = parent[0] || parent[1] || parent[2] || parent[3])\n && node === (parent[3] || parent[2] || parent[1] || parent[0])\n && !node.length) {\n if (retainer) retainer[j] = node;\n else this._root = node;\n }\n\n return this;\n};\n\nfunction removeAll(data) {\n for (var i = 0, n = data.length; i < n; ++i) this.remove(data[i]);\n return this;\n}\n\nvar tree_root = function() {\n return this._root;\n};\n\nvar tree_size = function() {\n var size = 0;\n this.visit(function(node) {\n if (!node.length) do ++size; while (node = node.next)\n });\n return size;\n};\n\nvar tree_visit = function(callback) {\n var quads = [], q, node = this._root, child, x0, y0, x1, y1;\n if (node) quads.push(new Quad(node, this._x0, this._y0, this._x1, this._y1));\n while (q = quads.pop()) {\n if (!callback(node = q.node, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1) && node.length) {\n var xm = (x0 + x1) / 2, ym = (y0 + y1) / 2;\n if (child = node[3]) quads.push(new Quad(child, xm, ym, x1, y1));\n if (child = node[2]) quads.push(new Quad(child, x0, ym, xm, y1));\n if (child = node[1]) quads.push(new Quad(child, xm, y0, x1, ym));\n if (child = node[0]) quads.push(new Quad(child, x0, y0, xm, ym));\n }\n }\n return this;\n};\n\nvar tree_visitAfter = function(callback) {\n var quads = [], next = [], q;\n if (this._root) quads.push(new Quad(this._root, this._x0, this._y0, this._x1, this._y1));\n while (q = quads.pop()) {\n var node = q.node;\n if (node.length) {\n var child, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1, xm = (x0 + x1) / 2, ym = (y0 + y1) / 2;\n if (child = node[0]) quads.push(new Quad(child, x0, y0, xm, ym));\n if (child = node[1]) quads.push(new Quad(child, xm, y0, x1, ym));\n if (child = node[2]) quads.push(new Quad(child, x0, ym, xm, y1));\n if (child = node[3]) quads.push(new Quad(child, xm, ym, x1, y1));\n }\n next.push(q);\n }\n while (q = next.pop()) {\n callback(q.node, q.x0, q.y0, q.x1, q.y1);\n }\n return this;\n};\n\nfunction defaultX(d) {\n return d[0];\n}\n\nvar tree_x = function(_) {\n return arguments.length ? (this._x = _, this) : this._x;\n};\n\nfunction defaultY(d) {\n return d[1];\n}\n\nvar tree_y = function(_) {\n return arguments.length ? (this._y = _, this) : this._y;\n};\n\nfunction quadtree(nodes, x, y) {\n var tree = new Quadtree(x == null ? defaultX : x, y == null ? defaultY : y, NaN, NaN, NaN, NaN);\n return nodes == null ? tree : tree.addAll(nodes);\n}\n\nfunction Quadtree(x, y, x0, y0, x1, y1) {\n this._x = x;\n this._y = y;\n this._x0 = x0;\n this._y0 = y0;\n this._x1 = x1;\n this._y1 = y1;\n this._root = undefined;\n}\n\nfunction leaf_copy(leaf) {\n var copy = {data: leaf.data}, next = copy;\n while (leaf = leaf.next) next = next.next = {data: leaf.data};\n return copy;\n}\n\nvar treeProto = quadtree.prototype = Quadtree.prototype;\n\ntreeProto.copy = function() {\n var copy = new Quadtree(this._x, this._y, this._x0, this._y0, this._x1, this._y1),\n node = this._root,\n nodes,\n child;\n\n if (!node) return copy;\n\n if (!node.length) return copy._root = leaf_copy(node), copy;\n\n nodes = [{source: node, target: copy._root = new Array(4)}];\n while (node = nodes.pop()) {\n for (var i = 0; i < 4; ++i) {\n if (child = node.source[i]) {\n if (child.length) nodes.push({source: child, target: node.target[i] = new Array(4)});\n else node.target[i] = leaf_copy(child);\n }\n }\n }\n\n return copy;\n};\n\ntreeProto.add = tree_add;\ntreeProto.addAll = addAll;\ntreeProto.cover = tree_cover;\ntreeProto.data = tree_data;\ntreeProto.extent = tree_extent;\ntreeProto.find = tree_find;\ntreeProto.remove = tree_remove;\ntreeProto.removeAll = removeAll;\ntreeProto.root = tree_root;\ntreeProto.size = tree_size;\ntreeProto.visit = tree_visit;\ntreeProto.visitAfter = tree_visitAfter;\ntreeProto.x = tree_x;\ntreeProto.y = tree_y;\n\nfunction x(d) {\n return d.x + d.vx;\n}\n\nfunction y(d) {\n return d.y + d.vy;\n}\n\nvar collide = function(radius) {\n var nodes,\n radii,\n strength = 1,\n iterations = 1;\n\n if (typeof radius !== \"function\") radius = constant$6(radius == null ? 1 : +radius);\n\n function force() {\n var i, n = nodes.length,\n tree,\n node,\n xi,\n yi,\n ri,\n ri2;\n\n for (var k = 0; k < iterations; ++k) {\n tree = quadtree(nodes, x, y).visitAfter(prepare);\n for (i = 0; i < n; ++i) {\n node = nodes[i];\n ri = radii[node.index], ri2 = ri * ri;\n xi = node.x + node.vx;\n yi = node.y + node.vy;\n tree.visit(apply);\n }\n }\n\n function apply(quad, x0, y0, x1, y1) {\n var data = quad.data, rj = quad.r, r = ri + rj;\n if (data) {\n if (data.index > node.index) {\n var x = xi - data.x - data.vx,\n y = yi - data.y - data.vy,\n l = x * x + y * y;\n if (l < r * r) {\n if (x === 0) x = jiggle(), l += x * x;\n if (y === 0) y = jiggle(), l += y * y;\n l = (r - (l = Math.sqrt(l))) / l * strength;\n node.vx += (x *= l) * (r = (rj *= rj) / (ri2 + rj));\n node.vy += (y *= l) * r;\n data.vx -= x * (r = 1 - r);\n data.vy -= y * r;\n }\n }\n return;\n }\n return x0 > xi + r || x1 < xi - r || y0 > yi + r || y1 < yi - r;\n }\n }\n\n function prepare(quad) {\n if (quad.data) return quad.r = radii[quad.data.index];\n for (var i = quad.r = 0; i < 4; ++i) {\n if (quad[i] && quad[i].r > quad.r) {\n quad.r = quad[i].r;\n }\n }\n }\n\n function initialize() {\n if (!nodes) return;\n var i, n = nodes.length, node;\n radii = new Array(n);\n for (i = 0; i < n; ++i) node = nodes[i], radii[node.index] = +radius(node, i, nodes);\n }\n\n force.initialize = function(_) {\n nodes = _;\n initialize();\n };\n\n force.iterations = function(_) {\n return arguments.length ? (iterations = +_, force) : iterations;\n };\n\n force.strength = function(_) {\n return arguments.length ? (strength = +_, force) : strength;\n };\n\n force.radius = function(_) {\n return arguments.length ? (radius = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : radius;\n };\n\n return force;\n};\n\nfunction index(d) {\n return d.index;\n}\n\nfunction find(nodeById, nodeId) {\n var node = nodeById.get(nodeId);\n if (!node) throw new Error(\"missing: \" + nodeId);\n return node;\n}\n\nvar link = function(links) {\n var id = index,\n strength = defaultStrength,\n strengths,\n distance = constant$6(30),\n distances,\n nodes,\n count,\n bias,\n iterations = 1;\n\n if (links == null) links = [];\n\n function defaultStrength(link) {\n return 1 / Math.min(count[link.source.index], count[link.target.index]);\n }\n\n function force(alpha) {\n for (var k = 0, n = links.length; k < iterations; ++k) {\n for (var i = 0, link, source, target, x, y, l, b; i < n; ++i) {\n link = links[i], source = link.source, target = link.target;\n x = target.x + target.vx - source.x - source.vx || jiggle();\n y = target.y + target.vy - source.y - source.vy || jiggle();\n l = Math.sqrt(x * x + y * y);\n l = (l - distances[i]) / l * alpha * strengths[i];\n x *= l, y *= l;\n target.vx -= x * (b = bias[i]);\n target.vy -= y * b;\n source.vx += x * (b = 1 - b);\n source.vy += y * b;\n }\n }\n }\n\n function initialize() {\n if (!nodes) return;\n\n var i,\n n = nodes.length,\n m = links.length,\n nodeById = map$1(nodes, id),\n link;\n\n for (i = 0, count = new Array(n); i < m; ++i) {\n link = links[i], link.index = i;\n if (typeof link.source !== \"object\") link.source = find(nodeById, link.source);\n if (typeof link.target !== \"object\") link.target = find(nodeById, link.target);\n count[link.source.index] = (count[link.source.index] || 0) + 1;\n count[link.target.index] = (count[link.target.index] || 0) + 1;\n }\n\n for (i = 0, bias = new Array(m); i < m; ++i) {\n link = links[i], bias[i] = count[link.source.index] / (count[link.source.index] + count[link.target.index]);\n }\n\n strengths = new Array(m), initializeStrength();\n distances = new Array(m), initializeDistance();\n }\n\n function initializeStrength() {\n if (!nodes) return;\n\n for (var i = 0, n = links.length; i < n; ++i) {\n strengths[i] = +strength(links[i], i, links);\n }\n }\n\n function initializeDistance() {\n if (!nodes) return;\n\n for (var i = 0, n = links.length; i < n; ++i) {\n distances[i] = +distance(links[i], i, links);\n }\n }\n\n force.initialize = function(_) {\n nodes = _;\n initialize();\n };\n\n force.links = function(_) {\n return arguments.length ? (links = _, initialize(), force) : links;\n };\n\n force.id = function(_) {\n return arguments.length ? (id = _, force) : id;\n };\n\n force.iterations = function(_) {\n return arguments.length ? (iterations = +_, force) : iterations;\n };\n\n force.strength = function(_) {\n return arguments.length ? (strength = typeof _ === \"function\" ? _ : constant$6(+_), initializeStrength(), force) : strength;\n };\n\n force.distance = function(_) {\n return arguments.length ? (distance = typeof _ === \"function\" ? _ : constant$6(+_), initializeDistance(), force) : distance;\n };\n\n return force;\n};\n\nfunction x$1(d) {\n return d.x;\n}\n\nfunction y$1(d) {\n return d.y;\n}\n\nvar initialRadius = 10;\nvar initialAngle = Math.PI * (3 - Math.sqrt(5));\n\nvar simulation = function(nodes) {\n var simulation,\n alpha = 1,\n alphaMin = 0.001,\n alphaDecay = 1 - Math.pow(alphaMin, 1 / 300),\n alphaTarget = 0,\n velocityDecay = 0.6,\n forces = map$1(),\n stepper = timer(step),\n event = dispatch(\"tick\", \"end\");\n\n if (nodes == null) nodes = [];\n\n function step() {\n tick();\n event.call(\"tick\", simulation);\n if (alpha < alphaMin) {\n stepper.stop();\n event.call(\"end\", simulation);\n }\n }\n\n function tick() {\n var i, n = nodes.length, node;\n\n alpha += (alphaTarget - alpha) * alphaDecay;\n\n forces.each(function(force) {\n force(alpha);\n });\n\n for (i = 0; i < n; ++i) {\n node = nodes[i];\n if (node.fx == null) node.x += node.vx *= velocityDecay;\n else node.x = node.fx, node.vx = 0;\n if (node.fy == null) node.y += node.vy *= velocityDecay;\n else node.y = node.fy, node.vy = 0;\n }\n }\n\n function initializeNodes() {\n for (var i = 0, n = nodes.length, node; i < n; ++i) {\n node = nodes[i], node.index = i;\n if (isNaN(node.x) || isNaN(node.y)) {\n var radius = initialRadius * Math.sqrt(i), angle = i * initialAngle;\n node.x = radius * Math.cos(angle);\n node.y = radius * Math.sin(angle);\n }\n if (isNaN(node.vx) || isNaN(node.vy)) {\n node.vx = node.vy = 0;\n }\n }\n }\n\n function initializeForce(force) {\n if (force.initialize) force.initialize(nodes);\n return force;\n }\n\n initializeNodes();\n\n return simulation = {\n tick: tick,\n\n restart: function() {\n return stepper.restart(step), simulation;\n },\n\n stop: function() {\n return stepper.stop(), simulation;\n },\n\n nodes: function(_) {\n return arguments.length ? (nodes = _, initializeNodes(), forces.each(initializeForce), simulation) : nodes;\n },\n\n alpha: function(_) {\n return arguments.length ? (alpha = +_, simulation) : alpha;\n },\n\n alphaMin: function(_) {\n return arguments.length ? (alphaMin = +_, simulation) : alphaMin;\n },\n\n alphaDecay: function(_) {\n return arguments.length ? (alphaDecay = +_, simulation) : +alphaDecay;\n },\n\n alphaTarget: function(_) {\n return arguments.length ? (alphaTarget = +_, simulation) : alphaTarget;\n },\n\n velocityDecay: function(_) {\n return arguments.length ? (velocityDecay = 1 - _, simulation) : 1 - velocityDecay;\n },\n\n force: function(name, _) {\n return arguments.length > 1 ? ((_ == null ? forces.remove(name) : forces.set(name, initializeForce(_))), simulation) : forces.get(name);\n },\n\n find: function(x, y, radius) {\n var i = 0,\n n = nodes.length,\n dx,\n dy,\n d2,\n node,\n closest;\n\n if (radius == null) radius = Infinity;\n else radius *= radius;\n\n for (i = 0; i < n; ++i) {\n node = nodes[i];\n dx = x - node.x;\n dy = y - node.y;\n d2 = dx * dx + dy * dy;\n if (d2 < radius) closest = node, radius = d2;\n }\n\n return closest;\n },\n\n on: function(name, _) {\n return arguments.length > 1 ? (event.on(name, _), simulation) : event.on(name);\n }\n };\n};\n\nvar manyBody = function() {\n var nodes,\n node,\n alpha,\n strength = constant$6(-30),\n strengths,\n distanceMin2 = 1,\n distanceMax2 = Infinity,\n theta2 = 0.81;\n\n function force(_) {\n var i, n = nodes.length, tree = quadtree(nodes, x$1, y$1).visitAfter(accumulate);\n for (alpha = _, i = 0; i < n; ++i) node = nodes[i], tree.visit(apply);\n }\n\n function initialize() {\n if (!nodes) return;\n var i, n = nodes.length, node;\n strengths = new Array(n);\n for (i = 0; i < n; ++i) node = nodes[i], strengths[node.index] = +strength(node, i, nodes);\n }\n\n function accumulate(quad) {\n var strength = 0, q, c, x$$1, y$$1, i;\n\n // For internal nodes, accumulate forces from child quadrants.\n if (quad.length) {\n for (x$$1 = y$$1 = i = 0; i < 4; ++i) {\n if ((q = quad[i]) && (c = q.value)) {\n strength += c, x$$1 += c * q.x, y$$1 += c * q.y;\n }\n }\n quad.x = x$$1 / strength;\n quad.y = y$$1 / strength;\n }\n\n // For leaf nodes, accumulate forces from coincident quadrants.\n else {\n q = quad;\n q.x = q.data.x;\n q.y = q.data.y;\n do strength += strengths[q.data.index];\n while (q = q.next);\n }\n\n quad.value = strength;\n }\n\n function apply(quad, x1, _, x2) {\n if (!quad.value) return true;\n\n var x$$1 = quad.x - node.x,\n y$$1 = quad.y - node.y,\n w = x2 - x1,\n l = x$$1 * x$$1 + y$$1 * y$$1;\n\n // Apply the Barnes-Hut approximation if possible.\n // Limit forces for very close nodes; randomize direction if coincident.\n if (w * w / theta2 < l) {\n if (l < distanceMax2) {\n if (x$$1 === 0) x$$1 = jiggle(), l += x$$1 * x$$1;\n if (y$$1 === 0) y$$1 = jiggle(), l += y$$1 * y$$1;\n if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l);\n node.vx += x$$1 * quad.value * alpha / l;\n node.vy += y$$1 * quad.value * alpha / l;\n }\n return true;\n }\n\n // Otherwise, process points directly.\n else if (quad.length || l >= distanceMax2) return;\n\n // Limit forces for very close nodes; randomize direction if coincident.\n if (quad.data !== node || quad.next) {\n if (x$$1 === 0) x$$1 = jiggle(), l += x$$1 * x$$1;\n if (y$$1 === 0) y$$1 = jiggle(), l += y$$1 * y$$1;\n if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l);\n }\n\n do if (quad.data !== node) {\n w = strengths[quad.data.index] * alpha / l;\n node.vx += x$$1 * w;\n node.vy += y$$1 * w;\n } while (quad = quad.next);\n }\n\n force.initialize = function(_) {\n nodes = _;\n initialize();\n };\n\n force.strength = function(_) {\n return arguments.length ? (strength = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : strength;\n };\n\n force.distanceMin = function(_) {\n return arguments.length ? (distanceMin2 = _ * _, force) : Math.sqrt(distanceMin2);\n };\n\n force.distanceMax = function(_) {\n return arguments.length ? (distanceMax2 = _ * _, force) : Math.sqrt(distanceMax2);\n };\n\n force.theta = function(_) {\n return arguments.length ? (theta2 = _ * _, force) : Math.sqrt(theta2);\n };\n\n return force;\n};\n\nvar x$2 = function(x) {\n var strength = constant$6(0.1),\n nodes,\n strengths,\n xz;\n\n if (typeof x !== \"function\") x = constant$6(x == null ? 0 : +x);\n\n function force(alpha) {\n for (var i = 0, n = nodes.length, node; i < n; ++i) {\n node = nodes[i], node.vx += (xz[i] - node.x) * strengths[i] * alpha;\n }\n }\n\n function initialize() {\n if (!nodes) return;\n var i, n = nodes.length;\n strengths = new Array(n);\n xz = new Array(n);\n for (i = 0; i < n; ++i) {\n strengths[i] = isNaN(xz[i] = +x(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes);\n }\n }\n\n force.initialize = function(_) {\n nodes = _;\n initialize();\n };\n\n force.strength = function(_) {\n return arguments.length ? (strength = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : strength;\n };\n\n force.x = function(_) {\n return arguments.length ? (x = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : x;\n };\n\n return force;\n};\n\nvar y$2 = function(y) {\n var strength = constant$6(0.1),\n nodes,\n strengths,\n yz;\n\n if (typeof y !== \"function\") y = constant$6(y == null ? 0 : +y);\n\n function force(alpha) {\n for (var i = 0, n = nodes.length, node; i < n; ++i) {\n node = nodes[i], node.vy += (yz[i] - node.y) * strengths[i] * alpha;\n }\n }\n\n function initialize() {\n if (!nodes) return;\n var i, n = nodes.length;\n strengths = new Array(n);\n yz = new Array(n);\n for (i = 0; i < n; ++i) {\n strengths[i] = isNaN(yz[i] = +y(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes);\n }\n }\n\n force.initialize = function(_) {\n nodes = _;\n initialize();\n };\n\n force.strength = function(_) {\n return arguments.length ? (strength = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : strength;\n };\n\n force.y = function(_) {\n return arguments.length ? (y = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : y;\n };\n\n return force;\n};\n\n// Computes the decimal coefficient and exponent of the specified number x with\n// significant digits p, where x is positive and p is in [1, 21] or undefined.\n// For example, formatDecimal(1.23) returns [\"123\", 0].\nvar formatDecimal = function(x, p) {\n if ((i = (x = p ? x.toExponential(p - 1) : x.toExponential()).indexOf(\"e\")) < 0) return null; // NaN, ±Infinity\n var i, coefficient = x.slice(0, i);\n\n // The string returned by toExponential either has the form \\d\\.\\d+e[-+]\\d+\n // (e.g., 1.2e+3) or the form \\de[-+]\\d+ (e.g., 1e+3).\n return [\n coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient,\n +x.slice(i + 1)\n ];\n};\n\nvar exponent$1 = function(x) {\n return x = formatDecimal(Math.abs(x)), x ? x[1] : NaN;\n};\n\nvar formatGroup = function(grouping, thousands) {\n return function(value, width) {\n var i = value.length,\n t = [],\n j = 0,\n g = grouping[0],\n length = 0;\n\n while (i > 0 && g > 0) {\n if (length + g + 1 > width) g = Math.max(1, width - length);\n t.push(value.substring(i -= g, i + g));\n if ((length += g + 1) > width) break;\n g = grouping[j = (j + 1) % grouping.length];\n }\n\n return t.reverse().join(thousands);\n };\n};\n\nvar formatDefault = function(x, p) {\n x = x.toPrecision(p);\n\n out: for (var n = x.length, i = 1, i0 = -1, i1; i < n; ++i) {\n switch (x[i]) {\n case \".\": i0 = i1 = i; break;\n case \"0\": if (i0 === 0) i0 = i; i1 = i; break;\n case \"e\": break out;\n default: if (i0 > 0) i0 = 0; break;\n }\n }\n\n return i0 > 0 ? x.slice(0, i0) + x.slice(i1 + 1) : x;\n};\n\nvar prefixExponent;\n\nvar formatPrefixAuto = function(x, p) {\n var d = formatDecimal(x, p);\n if (!d) return x + \"\";\n var coefficient = d[0],\n exponent = d[1],\n i = exponent - (prefixExponent = Math.max(-8, Math.min(8, Math.floor(exponent / 3))) * 3) + 1,\n n = coefficient.length;\n return i === n ? coefficient\n : i > n ? coefficient + new Array(i - n + 1).join(\"0\")\n : i > 0 ? coefficient.slice(0, i) + \".\" + coefficient.slice(i)\n : \"0.\" + new Array(1 - i).join(\"0\") + formatDecimal(x, Math.max(0, p + i - 1))[0]; // less than 1y!\n};\n\nvar formatRounded = function(x, p) {\n var d = formatDecimal(x, p);\n if (!d) return x + \"\";\n var coefficient = d[0],\n exponent = d[1];\n return exponent < 0 ? \"0.\" + new Array(-exponent).join(\"0\") + coefficient\n : coefficient.length > exponent + 1 ? coefficient.slice(0, exponent + 1) + \".\" + coefficient.slice(exponent + 1)\n : coefficient + new Array(exponent - coefficient.length + 2).join(\"0\");\n};\n\nvar formatTypes = {\n \"\": formatDefault,\n \"%\": function(x, p) { return (x * 100).toFixed(p); },\n \"b\": function(x) { return Math.round(x).toString(2); },\n \"c\": function(x) { return x + \"\"; },\n \"d\": function(x) { return Math.round(x).toString(10); },\n \"e\": function(x, p) { return x.toExponential(p); },\n \"f\": function(x, p) { return x.toFixed(p); },\n \"g\": function(x, p) { return x.toPrecision(p); },\n \"o\": function(x) { return Math.round(x).toString(8); },\n \"p\": function(x, p) { return formatRounded(x * 100, p); },\n \"r\": formatRounded,\n \"s\": formatPrefixAuto,\n \"X\": function(x) { return Math.round(x).toString(16).toUpperCase(); },\n \"x\": function(x) { return Math.round(x).toString(16); }\n};\n\n// [[fill]align][sign][symbol][0][width][,][.precision][type]\nvar re = /^(?:(.)?([<>=^]))?([+\\-\\( ])?([$#])?(0)?(\\d+)?(,)?(\\.\\d+)?([a-z%])?$/i;\n\nvar formatSpecifier = function(specifier) {\n return new FormatSpecifier(specifier);\n};\n\nfunction FormatSpecifier(specifier) {\n if (!(match = re.exec(specifier))) throw new Error(\"invalid format: \" + specifier);\n\n var match,\n fill = match[1] || \" \",\n align = match[2] || \">\",\n sign = match[3] || \"-\",\n symbol = match[4] || \"\",\n zero = !!match[5],\n width = match[6] && +match[6],\n comma = !!match[7],\n precision = match[8] && +match[8].slice(1),\n type = match[9] || \"\";\n\n // The \"n\" type is an alias for \",g\".\n if (type === \"n\") comma = true, type = \"g\";\n\n // Map invalid types to the default format.\n else if (!formatTypes[type]) type = \"\";\n\n // If zero fill is specified, padding goes after sign and before digits.\n if (zero || (fill === \"0\" && align === \"=\")) zero = true, fill = \"0\", align = \"=\";\n\n this.fill = fill;\n this.align = align;\n this.sign = sign;\n this.symbol = symbol;\n this.zero = zero;\n this.width = width;\n this.comma = comma;\n this.precision = precision;\n this.type = type;\n}\n\nFormatSpecifier.prototype.toString = function() {\n return this.fill\n + this.align\n + this.sign\n + this.symbol\n + (this.zero ? \"0\" : \"\")\n + (this.width == null ? \"\" : Math.max(1, this.width | 0))\n + (this.comma ? \",\" : \"\")\n + (this.precision == null ? \"\" : \".\" + Math.max(0, this.precision | 0))\n + this.type;\n};\n\nvar prefixes = [\"y\",\"z\",\"a\",\"f\",\"p\",\"n\",\"\\xB5\",\"m\",\"\",\"k\",\"M\",\"G\",\"T\",\"P\",\"E\",\"Z\",\"Y\"];\n\nfunction identity$3(x) {\n return x;\n}\n\nvar formatLocale = function(locale) {\n var group = locale.grouping && locale.thousands ? formatGroup(locale.grouping, locale.thousands) : identity$3,\n currency = locale.currency,\n decimal = locale.decimal;\n\n function newFormat(specifier) {\n specifier = formatSpecifier(specifier);\n\n var fill = specifier.fill,\n align = specifier.align,\n sign = specifier.sign,\n symbol = specifier.symbol,\n zero = specifier.zero,\n width = specifier.width,\n comma = specifier.comma,\n precision = specifier.precision,\n type = specifier.type;\n\n // Compute the prefix and suffix.\n // For SI-prefix, the suffix is lazily computed.\n var prefix = symbol === \"$\" ? currency[0] : symbol === \"#\" && /[boxX]/.test(type) ? \"0\" + type.toLowerCase() : \"\",\n suffix = symbol === \"$\" ? currency[1] : /[%p]/.test(type) ? \"%\" : \"\";\n\n // What format function should we use?\n // Is this an integer type?\n // Can this type generate exponential notation?\n var formatType = formatTypes[type],\n maybeSuffix = !type || /[defgprs%]/.test(type);\n\n // Set the default precision if not specified,\n // or clamp the specified precision to the supported range.\n // For significant precision, it must be in [1, 21].\n // For fixed precision, it must be in [0, 20].\n precision = precision == null ? (type ? 6 : 12)\n : /[gprs]/.test(type) ? Math.max(1, Math.min(21, precision))\n : Math.max(0, Math.min(20, precision));\n\n function format(value) {\n var valuePrefix = prefix,\n valueSuffix = suffix,\n i, n, c;\n\n if (type === \"c\") {\n valueSuffix = formatType(value) + valueSuffix;\n value = \"\";\n } else {\n value = +value;\n\n // Convert negative to positive, and compute the prefix.\n // Note that -0 is not less than 0, but 1 / -0 is!\n var valueNegative = (value < 0 || 1 / value < 0) && (value *= -1, true);\n\n // Perform the initial formatting.\n value = formatType(value, precision);\n\n // If the original value was negative, it may be rounded to zero during\n // formatting; treat this as (positive) zero.\n if (valueNegative) {\n i = -1, n = value.length;\n valueNegative = false;\n while (++i < n) {\n if (c = value.charCodeAt(i), (48 < c && c < 58)\n || (type === \"x\" && 96 < c && c < 103)\n || (type === \"X\" && 64 < c && c < 71)) {\n valueNegative = true;\n break;\n }\n }\n }\n\n // Compute the prefix and suffix.\n valuePrefix = (valueNegative ? (sign === \"(\" ? sign : \"-\") : sign === \"-\" || sign === \"(\" ? \"\" : sign) + valuePrefix;\n valueSuffix = valueSuffix + (type === \"s\" ? prefixes[8 + prefixExponent / 3] : \"\") + (valueNegative && sign === \"(\" ? \")\" : \"\");\n\n // Break the formatted value into the integer “value” part that can be\n // grouped, and fractional or exponential “suffix” part that is not.\n if (maybeSuffix) {\n i = -1, n = value.length;\n while (++i < n) {\n if (c = value.charCodeAt(i), 48 > c || c > 57) {\n valueSuffix = (c === 46 ? decimal + value.slice(i + 1) : value.slice(i)) + valueSuffix;\n value = value.slice(0, i);\n break;\n }\n }\n }\n }\n\n // If the fill character is not \"0\", grouping is applied before padding.\n if (comma && !zero) value = group(value, Infinity);\n\n // Compute the padding.\n var length = valuePrefix.length + value.length + valueSuffix.length,\n padding = length < width ? new Array(width - length + 1).join(fill) : \"\";\n\n // If the fill character is \"0\", grouping is applied after padding.\n if (comma && zero) value = group(padding + value, padding.length ? width - valueSuffix.length : Infinity), padding = \"\";\n\n // Reconstruct the final output based on the desired alignment.\n switch (align) {\n case \"<\": return valuePrefix + value + valueSuffix + padding;\n case \"=\": return valuePrefix + padding + value + valueSuffix;\n case \"^\": return padding.slice(0, length = padding.length >> 1) + valuePrefix + value + valueSuffix + padding.slice(length);\n }\n return padding + valuePrefix + value + valueSuffix;\n }\n\n format.toString = function() {\n return specifier + \"\";\n };\n\n return format;\n }\n\n function formatPrefix(specifier, value) {\n var f = newFormat((specifier = formatSpecifier(specifier), specifier.type = \"f\", specifier)),\n e = Math.max(-8, Math.min(8, Math.floor(exponent$1(value) / 3))) * 3,\n k = Math.pow(10, -e),\n prefix = prefixes[8 + e / 3];\n return function(value) {\n return f(k * value) + prefix;\n };\n }\n\n return {\n format: newFormat,\n formatPrefix: formatPrefix\n };\n};\n\nvar locale$1;\n\n\n\ndefaultLocale({\n decimal: \".\",\n thousands: \",\",\n grouping: [3],\n currency: [\"$\", \"\"]\n});\n\nfunction defaultLocale(definition) {\n locale$1 = formatLocale(definition);\n exports.format = locale$1.format;\n exports.formatPrefix = locale$1.formatPrefix;\n return locale$1;\n}\n\nvar precisionFixed = function(step) {\n return Math.max(0, -exponent$1(Math.abs(step)));\n};\n\nvar precisionPrefix = function(step, value) {\n return Math.max(0, Math.max(-8, Math.min(8, Math.floor(exponent$1(value) / 3))) * 3 - exponent$1(Math.abs(step)));\n};\n\nvar precisionRound = function(step, max) {\n step = Math.abs(step), max = Math.abs(max) - step;\n return Math.max(0, exponent$1(max) - exponent$1(step)) + 1;\n};\n\n// Adds floating point numbers with twice the normal precision.\n// Reference: J. R. Shewchuk, Adaptive Precision Floating-Point Arithmetic and\n// Fast Robust Geometric Predicates, Discrete & Computational Geometry 18(3)\n// 305–363 (1997).\n// Code adapted from GeographicLib by Charles F. F. Karney,\n// http://geographiclib.sourceforge.net/\n\nvar adder = function() {\n return new Adder;\n};\n\nfunction Adder() {\n this.reset();\n}\n\nAdder.prototype = {\n constructor: Adder,\n reset: function() {\n this.s = // rounded value\n this.t = 0; // exact error\n },\n add: function(y) {\n add$1(temp, y, this.t);\n add$1(this, temp.s, this.s);\n if (this.s) this.t += temp.t;\n else this.s = temp.t;\n },\n valueOf: function() {\n return this.s;\n }\n};\n\nvar temp = new Adder;\n\nfunction add$1(adder, a, b) {\n var x = adder.s = a + b,\n bv = x - a,\n av = x - bv;\n adder.t = (a - av) + (b - bv);\n}\n\nvar epsilon$2 = 1e-6;\nvar epsilon2$1 = 1e-12;\nvar pi$3 = Math.PI;\nvar halfPi$2 = pi$3 / 2;\nvar quarterPi = pi$3 / 4;\nvar tau$3 = pi$3 * 2;\n\nvar degrees$1 = 180 / pi$3;\nvar radians = pi$3 / 180;\n\nvar abs = Math.abs;\nvar atan = Math.atan;\nvar atan2 = Math.atan2;\nvar cos$1 = Math.cos;\nvar ceil = Math.ceil;\nvar exp = Math.exp;\n\nvar log = Math.log;\nvar pow = Math.pow;\nvar sin$1 = Math.sin;\nvar sign = Math.sign || function(x) { return x > 0 ? 1 : x < 0 ? -1 : 0; };\nvar sqrt = Math.sqrt;\nvar tan = Math.tan;\n\nfunction acos(x) {\n return x > 1 ? 0 : x < -1 ? pi$3 : Math.acos(x);\n}\n\nfunction asin(x) {\n return x > 1 ? halfPi$2 : x < -1 ? -halfPi$2 : Math.asin(x);\n}\n\nfunction haversin(x) {\n return (x = sin$1(x / 2)) * x;\n}\n\nfunction noop$1() {}\n\nfunction streamGeometry(geometry, stream) {\n if (geometry && streamGeometryType.hasOwnProperty(geometry.type)) {\n streamGeometryType[geometry.type](geometry, stream);\n }\n}\n\nvar streamObjectType = {\n Feature: function(feature, stream) {\n streamGeometry(feature.geometry, stream);\n },\n FeatureCollection: function(object, stream) {\n var features = object.features, i = -1, n = features.length;\n while (++i < n) streamGeometry(features[i].geometry, stream);\n }\n};\n\nvar streamGeometryType = {\n Sphere: function(object, stream) {\n stream.sphere();\n },\n Point: function(object, stream) {\n object = object.coordinates;\n stream.point(object[0], object[1], object[2]);\n },\n MultiPoint: function(object, stream) {\n var coordinates = object.coordinates, i = -1, n = coordinates.length;\n while (++i < n) object = coordinates[i], stream.point(object[0], object[1], object[2]);\n },\n LineString: function(object, stream) {\n streamLine(object.coordinates, stream, 0);\n },\n MultiLineString: function(object, stream) {\n var coordinates = object.coordinates, i = -1, n = coordinates.length;\n while (++i < n) streamLine(coordinates[i], stream, 0);\n },\n Polygon: function(object, stream) {\n streamPolygon(object.coordinates, stream);\n },\n MultiPolygon: function(object, stream) {\n var coordinates = object.coordinates, i = -1, n = coordinates.length;\n while (++i < n) streamPolygon(coordinates[i], stream);\n },\n GeometryCollection: function(object, stream) {\n var geometries = object.geometries, i = -1, n = geometries.length;\n while (++i < n) streamGeometry(geometries[i], stream);\n }\n};\n\nfunction streamLine(coordinates, stream, closed) {\n var i = -1, n = coordinates.length - closed, coordinate;\n stream.lineStart();\n while (++i < n) coordinate = coordinates[i], stream.point(coordinate[0], coordinate[1], coordinate[2]);\n stream.lineEnd();\n}\n\nfunction streamPolygon(coordinates, stream) {\n var i = -1, n = coordinates.length;\n stream.polygonStart();\n while (++i < n) streamLine(coordinates[i], stream, 1);\n stream.polygonEnd();\n}\n\nvar geoStream = function(object, stream) {\n if (object && streamObjectType.hasOwnProperty(object.type)) {\n streamObjectType[object.type](object, stream);\n } else {\n streamGeometry(object, stream);\n }\n};\n\nvar areaRingSum = adder();\n\nvar areaSum = adder();\nvar lambda00;\nvar phi00;\nvar lambda0;\nvar cosPhi0;\nvar sinPhi0;\n\nvar areaStream = {\n point: noop$1,\n lineStart: noop$1,\n lineEnd: noop$1,\n polygonStart: function() {\n areaRingSum.reset();\n areaStream.lineStart = areaRingStart;\n areaStream.lineEnd = areaRingEnd;\n },\n polygonEnd: function() {\n var areaRing = +areaRingSum;\n areaSum.add(areaRing < 0 ? tau$3 + areaRing : areaRing);\n this.lineStart = this.lineEnd = this.point = noop$1;\n },\n sphere: function() {\n areaSum.add(tau$3);\n }\n};\n\nfunction areaRingStart() {\n areaStream.point = areaPointFirst;\n}\n\nfunction areaRingEnd() {\n areaPoint(lambda00, phi00);\n}\n\nfunction areaPointFirst(lambda, phi) {\n areaStream.point = areaPoint;\n lambda00 = lambda, phi00 = phi;\n lambda *= radians, phi *= radians;\n lambda0 = lambda, cosPhi0 = cos$1(phi = phi / 2 + quarterPi), sinPhi0 = sin$1(phi);\n}\n\nfunction areaPoint(lambda, phi) {\n lambda *= radians, phi *= radians;\n phi = phi / 2 + quarterPi; // half the angular distance from south pole\n\n // Spherical excess E for a spherical triangle with vertices: south pole,\n // previous point, current point. Uses a formula derived from Cagnoli’s\n // theorem. See Todhunter, Spherical Trig. (1871), Sec. 103, Eq. (2).\n var dLambda = lambda - lambda0,\n sdLambda = dLambda >= 0 ? 1 : -1,\n adLambda = sdLambda * dLambda,\n cosPhi = cos$1(phi),\n sinPhi = sin$1(phi),\n k = sinPhi0 * sinPhi,\n u = cosPhi0 * cosPhi + k * cos$1(adLambda),\n v = k * sdLambda * sin$1(adLambda);\n areaRingSum.add(atan2(v, u));\n\n // Advance the previous points.\n lambda0 = lambda, cosPhi0 = cosPhi, sinPhi0 = sinPhi;\n}\n\nvar area = function(object) {\n areaSum.reset();\n geoStream(object, areaStream);\n return areaSum * 2;\n};\n\nfunction spherical(cartesian) {\n return [atan2(cartesian[1], cartesian[0]), asin(cartesian[2])];\n}\n\nfunction cartesian(spherical) {\n var lambda = spherical[0], phi = spherical[1], cosPhi = cos$1(phi);\n return [cosPhi * cos$1(lambda), cosPhi * sin$1(lambda), sin$1(phi)];\n}\n\nfunction cartesianDot(a, b) {\n return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];\n}\n\nfunction cartesianCross(a, b) {\n return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];\n}\n\n// TODO return a\nfunction cartesianAddInPlace(a, b) {\n a[0] += b[0], a[1] += b[1], a[2] += b[2];\n}\n\nfunction cartesianScale(vector, k) {\n return [vector[0] * k, vector[1] * k, vector[2] * k];\n}\n\n// TODO return d\nfunction cartesianNormalizeInPlace(d) {\n var l = sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);\n d[0] /= l, d[1] /= l, d[2] /= l;\n}\n\nvar lambda0$1;\nvar phi0;\nvar lambda1;\nvar phi1;\nvar lambda2;\nvar lambda00$1;\nvar phi00$1;\nvar p0;\nvar deltaSum = adder();\nvar ranges;\nvar range;\n\nvar boundsStream = {\n point: boundsPoint,\n lineStart: boundsLineStart,\n lineEnd: boundsLineEnd,\n polygonStart: function() {\n boundsStream.point = boundsRingPoint;\n boundsStream.lineStart = boundsRingStart;\n boundsStream.lineEnd = boundsRingEnd;\n deltaSum.reset();\n areaStream.polygonStart();\n },\n polygonEnd: function() {\n areaStream.polygonEnd();\n boundsStream.point = boundsPoint;\n boundsStream.lineStart = boundsLineStart;\n boundsStream.lineEnd = boundsLineEnd;\n if (areaRingSum < 0) lambda0$1 = -(lambda1 = 180), phi0 = -(phi1 = 90);\n else if (deltaSum > epsilon$2) phi1 = 90;\n else if (deltaSum < -epsilon$2) phi0 = -90;\n range[0] = lambda0$1, range[1] = lambda1;\n }\n};\n\nfunction boundsPoint(lambda, phi) {\n ranges.push(range = [lambda0$1 = lambda, lambda1 = lambda]);\n if (phi < phi0) phi0 = phi;\n if (phi > phi1) phi1 = phi;\n}\n\nfunction linePoint(lambda, phi) {\n var p = cartesian([lambda * radians, phi * radians]);\n if (p0) {\n var normal = cartesianCross(p0, p),\n equatorial = [normal[1], -normal[0], 0],\n inflection = cartesianCross(equatorial, normal);\n cartesianNormalizeInPlace(inflection);\n inflection = spherical(inflection);\n var delta = lambda - lambda2,\n sign$$1 = delta > 0 ? 1 : -1,\n lambdai = inflection[0] * degrees$1 * sign$$1,\n phii,\n antimeridian = abs(delta) > 180;\n if (antimeridian ^ (sign$$1 * lambda2 < lambdai && lambdai < sign$$1 * lambda)) {\n phii = inflection[1] * degrees$1;\n if (phii > phi1) phi1 = phii;\n } else if (lambdai = (lambdai + 360) % 360 - 180, antimeridian ^ (sign$$1 * lambda2 < lambdai && lambdai < sign$$1 * lambda)) {\n phii = -inflection[1] * degrees$1;\n if (phii < phi0) phi0 = phii;\n } else {\n if (phi < phi0) phi0 = phi;\n if (phi > phi1) phi1 = phi;\n }\n if (antimeridian) {\n if (lambda < lambda2) {\n if (angle(lambda0$1, lambda) > angle(lambda0$1, lambda1)) lambda1 = lambda;\n } else {\n if (angle(lambda, lambda1) > angle(lambda0$1, lambda1)) lambda0$1 = lambda;\n }\n } else {\n if (lambda1 >= lambda0$1) {\n if (lambda < lambda0$1) lambda0$1 = lambda;\n if (lambda > lambda1) lambda1 = lambda;\n } else {\n if (lambda > lambda2) {\n if (angle(lambda0$1, lambda) > angle(lambda0$1, lambda1)) lambda1 = lambda;\n } else {\n if (angle(lambda, lambda1) > angle(lambda0$1, lambda1)) lambda0$1 = lambda;\n }\n }\n }\n } else {\n ranges.push(range = [lambda0$1 = lambda, lambda1 = lambda]);\n }\n if (phi < phi0) phi0 = phi;\n if (phi > phi1) phi1 = phi;\n p0 = p, lambda2 = lambda;\n}\n\nfunction boundsLineStart() {\n boundsStream.point = linePoint;\n}\n\nfunction boundsLineEnd() {\n range[0] = lambda0$1, range[1] = lambda1;\n boundsStream.point = boundsPoint;\n p0 = null;\n}\n\nfunction boundsRingPoint(lambda, phi) {\n if (p0) {\n var delta = lambda - lambda2;\n deltaSum.add(abs(delta) > 180 ? delta + (delta > 0 ? 360 : -360) : delta);\n } else {\n lambda00$1 = lambda, phi00$1 = phi;\n }\n areaStream.point(lambda, phi);\n linePoint(lambda, phi);\n}\n\nfunction boundsRingStart() {\n areaStream.lineStart();\n}\n\nfunction boundsRingEnd() {\n boundsRingPoint(lambda00$1, phi00$1);\n areaStream.lineEnd();\n if (abs(deltaSum) > epsilon$2) lambda0$1 = -(lambda1 = 180);\n range[0] = lambda0$1, range[1] = lambda1;\n p0 = null;\n}\n\n// Finds the left-right distance between two longitudes.\n// This is almost the same as (lambda1 - lambda0 + 360°) % 360°, except that we want\n// the distance between ±180° to be 360°.\nfunction angle(lambda0, lambda1) {\n return (lambda1 -= lambda0) < 0 ? lambda1 + 360 : lambda1;\n}\n\nfunction rangeCompare(a, b) {\n return a[0] - b[0];\n}\n\nfunction rangeContains(range, x) {\n return range[0] <= range[1] ? range[0] <= x && x <= range[1] : x < range[0] || range[1] < x;\n}\n\nvar bounds = function(feature) {\n var i, n, a, b, merged, deltaMax, delta;\n\n phi1 = lambda1 = -(lambda0$1 = phi0 = Infinity);\n ranges = [];\n geoStream(feature, boundsStream);\n\n // First, sort ranges by their minimum longitudes.\n if (n = ranges.length) {\n ranges.sort(rangeCompare);\n\n // Then, merge any ranges that overlap.\n for (i = 1, a = ranges[0], merged = [a]; i < n; ++i) {\n b = ranges[i];\n if (rangeContains(a, b[0]) || rangeContains(a, b[1])) {\n if (angle(a[0], b[1]) > angle(a[0], a[1])) a[1] = b[1];\n if (angle(b[0], a[1]) > angle(a[0], a[1])) a[0] = b[0];\n } else {\n merged.push(a = b);\n }\n }\n\n // Finally, find the largest gap between the merged ranges.\n // The final bounding box will be the inverse of this gap.\n for (deltaMax = -Infinity, n = merged.length - 1, i = 0, a = merged[n]; i <= n; a = b, ++i) {\n b = merged[i];\n if ((delta = angle(a[1], b[0])) > deltaMax) deltaMax = delta, lambda0$1 = b[0], lambda1 = a[1];\n }\n }\n\n ranges = range = null;\n\n return lambda0$1 === Infinity || phi0 === Infinity\n ? [[NaN, NaN], [NaN, NaN]]\n : [[lambda0$1, phi0], [lambda1, phi1]];\n};\n\nvar W0;\nvar W1;\nvar X0;\nvar Y0;\nvar Z0;\nvar X1;\nvar Y1;\nvar Z1;\nvar X2;\nvar Y2;\nvar Z2;\nvar lambda00$2;\nvar phi00$2;\nvar x0;\nvar y0;\nvar z0; // previous point\n\nvar centroidStream = {\n sphere: noop$1,\n point: centroidPoint,\n lineStart: centroidLineStart,\n lineEnd: centroidLineEnd,\n polygonStart: function() {\n centroidStream.lineStart = centroidRingStart;\n centroidStream.lineEnd = centroidRingEnd;\n },\n polygonEnd: function() {\n centroidStream.lineStart = centroidLineStart;\n centroidStream.lineEnd = centroidLineEnd;\n }\n};\n\n// Arithmetic mean of Cartesian vectors.\nfunction centroidPoint(lambda, phi) {\n lambda *= radians, phi *= radians;\n var cosPhi = cos$1(phi);\n centroidPointCartesian(cosPhi * cos$1(lambda), cosPhi * sin$1(lambda), sin$1(phi));\n}\n\nfunction centroidPointCartesian(x, y, z) {\n ++W0;\n X0 += (x - X0) / W0;\n Y0 += (y - Y0) / W0;\n Z0 += (z - Z0) / W0;\n}\n\nfunction centroidLineStart() {\n centroidStream.point = centroidLinePointFirst;\n}\n\nfunction centroidLinePointFirst(lambda, phi) {\n lambda *= radians, phi *= radians;\n var cosPhi = cos$1(phi);\n x0 = cosPhi * cos$1(lambda);\n y0 = cosPhi * sin$1(lambda);\n z0 = sin$1(phi);\n centroidStream.point = centroidLinePoint;\n centroidPointCartesian(x0, y0, z0);\n}\n\nfunction centroidLinePoint(lambda, phi) {\n lambda *= radians, phi *= radians;\n var cosPhi = cos$1(phi),\n x = cosPhi * cos$1(lambda),\n y = cosPhi * sin$1(lambda),\n z = sin$1(phi),\n w = atan2(sqrt((w = y0 * z - z0 * y) * w + (w = z0 * x - x0 * z) * w + (w = x0 * y - y0 * x) * w), x0 * x + y0 * y + z0 * z);\n W1 += w;\n X1 += w * (x0 + (x0 = x));\n Y1 += w * (y0 + (y0 = y));\n Z1 += w * (z0 + (z0 = z));\n centroidPointCartesian(x0, y0, z0);\n}\n\nfunction centroidLineEnd() {\n centroidStream.point = centroidPoint;\n}\n\n// See J. E. Brock, The Inertia Tensor for a Spherical Triangle,\n// J. Applied Mechanics 42, 239 (1975).\nfunction centroidRingStart() {\n centroidStream.point = centroidRingPointFirst;\n}\n\nfunction centroidRingEnd() {\n centroidRingPoint(lambda00$2, phi00$2);\n centroidStream.point = centroidPoint;\n}\n\nfunction centroidRingPointFirst(lambda, phi) {\n lambda00$2 = lambda, phi00$2 = phi;\n lambda *= radians, phi *= radians;\n centroidStream.point = centroidRingPoint;\n var cosPhi = cos$1(phi);\n x0 = cosPhi * cos$1(lambda);\n y0 = cosPhi * sin$1(lambda);\n z0 = sin$1(phi);\n centroidPointCartesian(x0, y0, z0);\n}\n\nfunction centroidRingPoint(lambda, phi) {\n lambda *= radians, phi *= radians;\n var cosPhi = cos$1(phi),\n x = cosPhi * cos$1(lambda),\n y = cosPhi * sin$1(lambda),\n z = sin$1(phi),\n cx = y0 * z - z0 * y,\n cy = z0 * x - x0 * z,\n cz = x0 * y - y0 * x,\n m = sqrt(cx * cx + cy * cy + cz * cz),\n u = x0 * x + y0 * y + z0 * z,\n v = m && -asin(m) / m, // area weight\n w = atan2(m, u); // line weight\n X2 += v * cx;\n Y2 += v * cy;\n Z2 += v * cz;\n W1 += w;\n X1 += w * (x0 + (x0 = x));\n Y1 += w * (y0 + (y0 = y));\n Z1 += w * (z0 + (z0 = z));\n centroidPointCartesian(x0, y0, z0);\n}\n\nvar centroid = function(object) {\n W0 = W1 =\n X0 = Y0 = Z0 =\n X1 = Y1 = Z1 =\n X2 = Y2 = Z2 = 0;\n geoStream(object, centroidStream);\n\n var x = X2,\n y = Y2,\n z = Z2,\n m = x * x + y * y + z * z;\n\n // If the area-weighted ccentroid is undefined, fall back to length-weighted ccentroid.\n if (m < epsilon2$1) {\n x = X1, y = Y1, z = Z1;\n // If the feature has zero length, fall back to arithmetic mean of point vectors.\n if (W1 < epsilon$2) x = X0, y = Y0, z = Z0;\n m = x * x + y * y + z * z;\n // If the feature still has an undefined ccentroid, then return.\n if (m < epsilon2$1) return [NaN, NaN];\n }\n\n return [atan2(y, x) * degrees$1, asin(z / sqrt(m)) * degrees$1];\n};\n\nvar constant$7 = function(x) {\n return function() {\n return x;\n };\n};\n\nvar compose = function(a, b) {\n\n function compose(x, y) {\n return x = a(x, y), b(x[0], x[1]);\n }\n\n if (a.invert && b.invert) compose.invert = function(x, y) {\n return x = b.invert(x, y), x && a.invert(x[0], x[1]);\n };\n\n return compose;\n};\n\nfunction rotationIdentity(lambda, phi) {\n return [lambda > pi$3 ? lambda - tau$3 : lambda < -pi$3 ? lambda + tau$3 : lambda, phi];\n}\n\nrotationIdentity.invert = rotationIdentity;\n\nfunction rotateRadians(deltaLambda, deltaPhi, deltaGamma) {\n return (deltaLambda %= tau$3) ? (deltaPhi || deltaGamma ? compose(rotationLambda(deltaLambda), rotationPhiGamma(deltaPhi, deltaGamma))\n : rotationLambda(deltaLambda))\n : (deltaPhi || deltaGamma ? rotationPhiGamma(deltaPhi, deltaGamma)\n : rotationIdentity);\n}\n\nfunction forwardRotationLambda(deltaLambda) {\n return function(lambda, phi) {\n return lambda += deltaLambda, [lambda > pi$3 ? lambda - tau$3 : lambda < -pi$3 ? lambda + tau$3 : lambda, phi];\n };\n}\n\nfunction rotationLambda(deltaLambda) {\n var rotation = forwardRotationLambda(deltaLambda);\n rotation.invert = forwardRotationLambda(-deltaLambda);\n return rotation;\n}\n\nfunction rotationPhiGamma(deltaPhi, deltaGamma) {\n var cosDeltaPhi = cos$1(deltaPhi),\n sinDeltaPhi = sin$1(deltaPhi),\n cosDeltaGamma = cos$1(deltaGamma),\n sinDeltaGamma = sin$1(deltaGamma);\n\n function rotation(lambda, phi) {\n var cosPhi = cos$1(phi),\n x = cos$1(lambda) * cosPhi,\n y = sin$1(lambda) * cosPhi,\n z = sin$1(phi),\n k = z * cosDeltaPhi + x * sinDeltaPhi;\n return [\n atan2(y * cosDeltaGamma - k * sinDeltaGamma, x * cosDeltaPhi - z * sinDeltaPhi),\n asin(k * cosDeltaGamma + y * sinDeltaGamma)\n ];\n }\n\n rotation.invert = function(lambda, phi) {\n var cosPhi = cos$1(phi),\n x = cos$1(lambda) * cosPhi,\n y = sin$1(lambda) * cosPhi,\n z = sin$1(phi),\n k = z * cosDeltaGamma - y * sinDeltaGamma;\n return [\n atan2(y * cosDeltaGamma + z * sinDeltaGamma, x * cosDeltaPhi + k * sinDeltaPhi),\n asin(k * cosDeltaPhi - x * sinDeltaPhi)\n ];\n };\n\n return rotation;\n}\n\nvar rotation = function(rotate) {\n rotate = rotateRadians(rotate[0] * radians, rotate[1] * radians, rotate.length > 2 ? rotate[2] * radians : 0);\n\n function forward(coordinates) {\n coordinates = rotate(coordinates[0] * radians, coordinates[1] * radians);\n return coordinates[0] *= degrees$1, coordinates[1] *= degrees$1, coordinates;\n }\n\n forward.invert = function(coordinates) {\n coordinates = rotate.invert(coordinates[0] * radians, coordinates[1] * radians);\n return coordinates[0] *= degrees$1, coordinates[1] *= degrees$1, coordinates;\n };\n\n return forward;\n};\n\n// Generates a circle centered at [0°, 0°], with a given radius and precision.\nfunction circleStream(stream, radius, delta, direction, t0, t1) {\n if (!delta) return;\n var cosRadius = cos$1(radius),\n sinRadius = sin$1(radius),\n step = direction * delta;\n if (t0 == null) {\n t0 = radius + direction * tau$3;\n t1 = radius - step / 2;\n } else {\n t0 = circleRadius(cosRadius, t0);\n t1 = circleRadius(cosRadius, t1);\n if (direction > 0 ? t0 < t1 : t0 > t1) t0 += direction * tau$3;\n }\n for (var point, t = t0; direction > 0 ? t > t1 : t < t1; t -= step) {\n point = spherical([cosRadius, -sinRadius * cos$1(t), -sinRadius * sin$1(t)]);\n stream.point(point[0], point[1]);\n }\n}\n\n// Returns the signed angle of a cartesian point relative to [cosRadius, 0, 0].\nfunction circleRadius(cosRadius, point) {\n point = cartesian(point), point[0] -= cosRadius;\n cartesianNormalizeInPlace(point);\n var radius = acos(-point[1]);\n return ((-point[2] < 0 ? -radius : radius) + tau$3 - epsilon$2) % tau$3;\n}\n\nvar circle = function() {\n var center = constant$7([0, 0]),\n radius = constant$7(90),\n precision = constant$7(6),\n ring,\n rotate,\n stream = {point: point};\n\n function point(x, y) {\n ring.push(x = rotate(x, y));\n x[0] *= degrees$1, x[1] *= degrees$1;\n }\n\n function circle() {\n var c = center.apply(this, arguments),\n r = radius.apply(this, arguments) * radians,\n p = precision.apply(this, arguments) * radians;\n ring = [];\n rotate = rotateRadians(-c[0] * radians, -c[1] * radians, 0).invert;\n circleStream(stream, r, p, 1);\n c = {type: \"Polygon\", coordinates: [ring]};\n ring = rotate = null;\n return c;\n }\n\n circle.center = function(_) {\n return arguments.length ? (center = typeof _ === \"function\" ? _ : constant$7([+_[0], +_[1]]), circle) : center;\n };\n\n circle.radius = function(_) {\n return arguments.length ? (radius = typeof _ === \"function\" ? _ : constant$7(+_), circle) : radius;\n };\n\n circle.precision = function(_) {\n return arguments.length ? (precision = typeof _ === \"function\" ? _ : constant$7(+_), circle) : precision;\n };\n\n return circle;\n};\n\nvar clipBuffer = function() {\n var lines = [],\n line;\n return {\n point: function(x, y) {\n line.push([x, y]);\n },\n lineStart: function() {\n lines.push(line = []);\n },\n lineEnd: noop$1,\n rejoin: function() {\n if (lines.length > 1) lines.push(lines.pop().concat(lines.shift()));\n },\n result: function() {\n var result = lines;\n lines = [];\n line = null;\n return result;\n }\n };\n};\n\nvar clipLine = function(a, b, x0, y0, x1, y1) {\n var ax = a[0],\n ay = a[1],\n bx = b[0],\n by = b[1],\n t0 = 0,\n t1 = 1,\n dx = bx - ax,\n dy = by - ay,\n r;\n\n r = x0 - ax;\n if (!dx && r > 0) return;\n r /= dx;\n if (dx < 0) {\n if (r < t0) return;\n if (r < t1) t1 = r;\n } else if (dx > 0) {\n if (r > t1) return;\n if (r > t0) t0 = r;\n }\n\n r = x1 - ax;\n if (!dx && r < 0) return;\n r /= dx;\n if (dx < 0) {\n if (r > t1) return;\n if (r > t0) t0 = r;\n } else if (dx > 0) {\n if (r < t0) return;\n if (r < t1) t1 = r;\n }\n\n r = y0 - ay;\n if (!dy && r > 0) return;\n r /= dy;\n if (dy < 0) {\n if (r < t0) return;\n if (r < t1) t1 = r;\n } else if (dy > 0) {\n if (r > t1) return;\n if (r > t0) t0 = r;\n }\n\n r = y1 - ay;\n if (!dy && r < 0) return;\n r /= dy;\n if (dy < 0) {\n if (r > t1) return;\n if (r > t0) t0 = r;\n } else if (dy > 0) {\n if (r < t0) return;\n if (r < t1) t1 = r;\n }\n\n if (t0 > 0) a[0] = ax + t0 * dx, a[1] = ay + t0 * dy;\n if (t1 < 1) b[0] = ax + t1 * dx, b[1] = ay + t1 * dy;\n return true;\n};\n\nvar pointEqual = function(a, b) {\n return abs(a[0] - b[0]) < epsilon$2 && abs(a[1] - b[1]) < epsilon$2;\n};\n\nfunction Intersection(point, points, other, entry) {\n this.x = point;\n this.z = points;\n this.o = other; // another intersection\n this.e = entry; // is an entry?\n this.v = false; // visited\n this.n = this.p = null; // next & previous\n}\n\n// A generalized polygon clipping algorithm: given a polygon that has been cut\n// into its visible line segments, and rejoins the segments by interpolating\n// along the clip edge.\nvar clipPolygon = function(segments, compareIntersection, startInside, interpolate, stream) {\n var subject = [],\n clip = [],\n i,\n n;\n\n segments.forEach(function(segment) {\n if ((n = segment.length - 1) <= 0) return;\n var n, p0 = segment[0], p1 = segment[n], x;\n\n // If the first and last points of a segment are coincident, then treat as a\n // closed ring. TODO if all rings are closed, then the winding order of the\n // exterior ring should be checked.\n if (pointEqual(p0, p1)) {\n stream.lineStart();\n for (i = 0; i < n; ++i) stream.point((p0 = segment[i])[0], p0[1]);\n stream.lineEnd();\n return;\n }\n\n subject.push(x = new Intersection(p0, segment, null, true));\n clip.push(x.o = new Intersection(p0, null, x, false));\n subject.push(x = new Intersection(p1, segment, null, false));\n clip.push(x.o = new Intersection(p1, null, x, true));\n });\n\n if (!subject.length) return;\n\n clip.sort(compareIntersection);\n link$1(subject);\n link$1(clip);\n\n for (i = 0, n = clip.length; i < n; ++i) {\n clip[i].e = startInside = !startInside;\n }\n\n var start = subject[0],\n points,\n point;\n\n while (1) {\n // Find first unvisited intersection.\n var current = start,\n isSubject = true;\n while (current.v) if ((current = current.n) === start) return;\n points = current.z;\n stream.lineStart();\n do {\n current.v = current.o.v = true;\n if (current.e) {\n if (isSubject) {\n for (i = 0, n = points.length; i < n; ++i) stream.point((point = points[i])[0], point[1]);\n } else {\n interpolate(current.x, current.n.x, 1, stream);\n }\n current = current.n;\n } else {\n if (isSubject) {\n points = current.p.z;\n for (i = points.length - 1; i >= 0; --i) stream.point((point = points[i])[0], point[1]);\n } else {\n interpolate(current.x, current.p.x, -1, stream);\n }\n current = current.p;\n }\n current = current.o;\n points = current.z;\n isSubject = !isSubject;\n } while (!current.v);\n stream.lineEnd();\n }\n};\n\nfunction link$1(array) {\n if (!(n = array.length)) return;\n var n,\n i = 0,\n a = array[0],\n b;\n while (++i < n) {\n a.n = b = array[i];\n b.p = a;\n a = b;\n }\n a.n = b = array[0];\n b.p = a;\n}\n\nvar clipMax = 1e9;\nvar clipMin = -clipMax;\n\n// TODO Use d3-polygon’s polygonContains here for the ring check?\n// TODO Eliminate duplicate buffering in clipBuffer and polygon.push?\n\nfunction clipExtent(x0, y0, x1, y1) {\n\n function visible(x, y) {\n return x0 <= x && x <= x1 && y0 <= y && y <= y1;\n }\n\n function interpolate(from, to, direction, stream) {\n var a = 0, a1 = 0;\n if (from == null\n || (a = corner(from, direction)) !== (a1 = corner(to, direction))\n || comparePoint(from, to) < 0 ^ direction > 0) {\n do stream.point(a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0);\n while ((a = (a + direction + 4) % 4) !== a1);\n } else {\n stream.point(to[0], to[1]);\n }\n }\n\n function corner(p, direction) {\n return abs(p[0] - x0) < epsilon$2 ? direction > 0 ? 0 : 3\n : abs(p[0] - x1) < epsilon$2 ? direction > 0 ? 2 : 1\n : abs(p[1] - y0) < epsilon$2 ? direction > 0 ? 1 : 0\n : direction > 0 ? 3 : 2; // abs(p[1] - y1) < epsilon\n }\n\n function compareIntersection(a, b) {\n return comparePoint(a.x, b.x);\n }\n\n function comparePoint(a, b) {\n var ca = corner(a, 1),\n cb = corner(b, 1);\n return ca !== cb ? ca - cb\n : ca === 0 ? b[1] - a[1]\n : ca === 1 ? a[0] - b[0]\n : ca === 2 ? a[1] - b[1]\n : b[0] - a[0];\n }\n\n return function(stream) {\n var activeStream = stream,\n bufferStream = clipBuffer(),\n segments,\n polygon,\n ring,\n x__, y__, v__, // first point\n x_, y_, v_, // previous point\n first,\n clean;\n\n var clipStream = {\n point: point,\n lineStart: lineStart,\n lineEnd: lineEnd,\n polygonStart: polygonStart,\n polygonEnd: polygonEnd\n };\n\n function point(x, y) {\n if (visible(x, y)) activeStream.point(x, y);\n }\n\n function polygonInside() {\n var winding = 0;\n\n for (var i = 0, n = polygon.length; i < n; ++i) {\n for (var ring = polygon[i], j = 1, m = ring.length, point = ring[0], a0, a1, b0 = point[0], b1 = point[1]; j < m; ++j) {\n a0 = b0, a1 = b1, point = ring[j], b0 = point[0], b1 = point[1];\n if (a1 <= y1) { if (b1 > y1 && (b0 - a0) * (y1 - a1) > (b1 - a1) * (x0 - a0)) ++winding; }\n else { if (b1 <= y1 && (b0 - a0) * (y1 - a1) < (b1 - a1) * (x0 - a0)) --winding; }\n }\n }\n\n return winding;\n }\n\n // Buffer geometry within a polygon and then clip it en masse.\n function polygonStart() {\n activeStream = bufferStream, segments = [], polygon = [], clean = true;\n }\n\n function polygonEnd() {\n var startInside = polygonInside(),\n cleanInside = clean && startInside,\n visible = (segments = merge(segments)).length;\n if (cleanInside || visible) {\n stream.polygonStart();\n if (cleanInside) {\n stream.lineStart();\n interpolate(null, null, 1, stream);\n stream.lineEnd();\n }\n if (visible) {\n clipPolygon(segments, compareIntersection, startInside, interpolate, stream);\n }\n stream.polygonEnd();\n }\n activeStream = stream, segments = polygon = ring = null;\n }\n\n function lineStart() {\n clipStream.point = linePoint;\n if (polygon) polygon.push(ring = []);\n first = true;\n v_ = false;\n x_ = y_ = NaN;\n }\n\n // TODO rather than special-case polygons, simply handle them separately.\n // Ideally, coincident intersection points should be jittered to avoid\n // clipping issues.\n function lineEnd() {\n if (segments) {\n linePoint(x__, y__);\n if (v__ && v_) bufferStream.rejoin();\n segments.push(bufferStream.result());\n }\n clipStream.point = point;\n if (v_) activeStream.lineEnd();\n }\n\n function linePoint(x, y) {\n var v = visible(x, y);\n if (polygon) ring.push([x, y]);\n if (first) {\n x__ = x, y__ = y, v__ = v;\n first = false;\n if (v) {\n activeStream.lineStart();\n activeStream.point(x, y);\n }\n } else {\n if (v && v_) activeStream.point(x, y);\n else {\n var a = [x_ = Math.max(clipMin, Math.min(clipMax, x_)), y_ = Math.max(clipMin, Math.min(clipMax, y_))],\n b = [x = Math.max(clipMin, Math.min(clipMax, x)), y = Math.max(clipMin, Math.min(clipMax, y))];\n if (clipLine(a, b, x0, y0, x1, y1)) {\n if (!v_) {\n activeStream.lineStart();\n activeStream.point(a[0], a[1]);\n }\n activeStream.point(b[0], b[1]);\n if (!v) activeStream.lineEnd();\n clean = false;\n } else if (v) {\n activeStream.lineStart();\n activeStream.point(x, y);\n clean = false;\n }\n }\n }\n x_ = x, y_ = y, v_ = v;\n }\n\n return clipStream;\n };\n}\n\nvar extent$1 = function() {\n var x0 = 0,\n y0 = 0,\n x1 = 960,\n y1 = 500,\n cache,\n cacheStream,\n clip;\n\n return clip = {\n stream: function(stream) {\n return cache && cacheStream === stream ? cache : cache = clipExtent(x0, y0, x1, y1)(cacheStream = stream);\n },\n extent: function(_) {\n return arguments.length ? (x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1], cache = cacheStream = null, clip) : [[x0, y0], [x1, y1]];\n }\n };\n};\n\nvar lengthSum = adder();\nvar lambda0$2;\nvar sinPhi0$1;\nvar cosPhi0$1;\n\nvar lengthStream = {\n sphere: noop$1,\n point: noop$1,\n lineStart: lengthLineStart,\n lineEnd: noop$1,\n polygonStart: noop$1,\n polygonEnd: noop$1\n};\n\nfunction lengthLineStart() {\n lengthStream.point = lengthPointFirst;\n lengthStream.lineEnd = lengthLineEnd;\n}\n\nfunction lengthLineEnd() {\n lengthStream.point = lengthStream.lineEnd = noop$1;\n}\n\nfunction lengthPointFirst(lambda, phi) {\n lambda *= radians, phi *= radians;\n lambda0$2 = lambda, sinPhi0$1 = sin$1(phi), cosPhi0$1 = cos$1(phi);\n lengthStream.point = lengthPoint;\n}\n\nfunction lengthPoint(lambda, phi) {\n lambda *= radians, phi *= radians;\n var sinPhi = sin$1(phi),\n cosPhi = cos$1(phi),\n delta = abs(lambda - lambda0$2),\n cosDelta = cos$1(delta),\n sinDelta = sin$1(delta),\n x = cosPhi * sinDelta,\n y = cosPhi0$1 * sinPhi - sinPhi0$1 * cosPhi * cosDelta,\n z = sinPhi0$1 * sinPhi + cosPhi0$1 * cosPhi * cosDelta;\n lengthSum.add(atan2(sqrt(x * x + y * y), z));\n lambda0$2 = lambda, sinPhi0$1 = sinPhi, cosPhi0$1 = cosPhi;\n}\n\nvar length$1 = function(object) {\n lengthSum.reset();\n geoStream(object, lengthStream);\n return +lengthSum;\n};\n\nvar coordinates = [null, null];\nvar object$1 = {type: \"LineString\", coordinates: coordinates};\n\nvar distance = function(a, b) {\n coordinates[0] = a;\n coordinates[1] = b;\n return length$1(object$1);\n};\n\nfunction graticuleX(y0, y1, dy) {\n var y = sequence(y0, y1 - epsilon$2, dy).concat(y1);\n return function(x) { return y.map(function(y) { return [x, y]; }); };\n}\n\nfunction graticuleY(x0, x1, dx) {\n var x = sequence(x0, x1 - epsilon$2, dx).concat(x1);\n return function(y) { return x.map(function(x) { return [x, y]; }); };\n}\n\nfunction graticule() {\n var x1, x0, X1, X0,\n y1, y0, Y1, Y0,\n dx = 10, dy = dx, DX = 90, DY = 360,\n x, y, X, Y,\n precision = 2.5;\n\n function graticule() {\n return {type: \"MultiLineString\", coordinates: lines()};\n }\n\n function lines() {\n return sequence(ceil(X0 / DX) * DX, X1, DX).map(X)\n .concat(sequence(ceil(Y0 / DY) * DY, Y1, DY).map(Y))\n .concat(sequence(ceil(x0 / dx) * dx, x1, dx).filter(function(x) { return abs(x % DX) > epsilon$2; }).map(x))\n .concat(sequence(ceil(y0 / dy) * dy, y1, dy).filter(function(y) { return abs(y % DY) > epsilon$2; }).map(y));\n }\n\n graticule.lines = function() {\n return lines().map(function(coordinates) { return {type: \"LineString\", coordinates: coordinates}; });\n };\n\n graticule.outline = function() {\n return {\n type: \"Polygon\",\n coordinates: [\n X(X0).concat(\n Y(Y1).slice(1),\n X(X1).reverse().slice(1),\n Y(Y0).reverse().slice(1))\n ]\n };\n };\n\n graticule.extent = function(_) {\n if (!arguments.length) return graticule.extentMinor();\n return graticule.extentMajor(_).extentMinor(_);\n };\n\n graticule.extentMajor = function(_) {\n if (!arguments.length) return [[X0, Y0], [X1, Y1]];\n X0 = +_[0][0], X1 = +_[1][0];\n Y0 = +_[0][1], Y1 = +_[1][1];\n if (X0 > X1) _ = X0, X0 = X1, X1 = _;\n if (Y0 > Y1) _ = Y0, Y0 = Y1, Y1 = _;\n return graticule.precision(precision);\n };\n\n graticule.extentMinor = function(_) {\n if (!arguments.length) return [[x0, y0], [x1, y1]];\n x0 = +_[0][0], x1 = +_[1][0];\n y0 = +_[0][1], y1 = +_[1][1];\n if (x0 > x1) _ = x0, x0 = x1, x1 = _;\n if (y0 > y1) _ = y0, y0 = y1, y1 = _;\n return graticule.precision(precision);\n };\n\n graticule.step = function(_) {\n if (!arguments.length) return graticule.stepMinor();\n return graticule.stepMajor(_).stepMinor(_);\n };\n\n graticule.stepMajor = function(_) {\n if (!arguments.length) return [DX, DY];\n DX = +_[0], DY = +_[1];\n return graticule;\n };\n\n graticule.stepMinor = function(_) {\n if (!arguments.length) return [dx, dy];\n dx = +_[0], dy = +_[1];\n return graticule;\n };\n\n graticule.precision = function(_) {\n if (!arguments.length) return precision;\n precision = +_;\n x = graticuleX(y0, y1, 90);\n y = graticuleY(x0, x1, precision);\n X = graticuleX(Y0, Y1, 90);\n Y = graticuleY(X0, X1, precision);\n return graticule;\n };\n\n return graticule\n .extentMajor([[-180, -90 + epsilon$2], [180, 90 - epsilon$2]])\n .extentMinor([[-180, -80 - epsilon$2], [180, 80 + epsilon$2]]);\n}\n\nfunction graticule10() {\n return graticule()();\n}\n\nvar interpolate$1 = function(a, b) {\n var x0 = a[0] * radians,\n y0 = a[1] * radians,\n x1 = b[0] * radians,\n y1 = b[1] * radians,\n cy0 = cos$1(y0),\n sy0 = sin$1(y0),\n cy1 = cos$1(y1),\n sy1 = sin$1(y1),\n kx0 = cy0 * cos$1(x0),\n ky0 = cy0 * sin$1(x0),\n kx1 = cy1 * cos$1(x1),\n ky1 = cy1 * sin$1(x1),\n d = 2 * asin(sqrt(haversin(y1 - y0) + cy0 * cy1 * haversin(x1 - x0))),\n k = sin$1(d);\n\n var interpolate = d ? function(t) {\n var B = sin$1(t *= d) / k,\n A = sin$1(d - t) / k,\n x = A * kx0 + B * kx1,\n y = A * ky0 + B * ky1,\n z = A * sy0 + B * sy1;\n return [\n atan2(y, x) * degrees$1,\n atan2(z, sqrt(x * x + y * y)) * degrees$1\n ];\n } : function() {\n return [x0 * degrees$1, y0 * degrees$1];\n };\n\n interpolate.distance = d;\n\n return interpolate;\n};\n\nvar identity$4 = function(x) {\n return x;\n};\n\nvar areaSum$1 = adder();\nvar areaRingSum$1 = adder();\nvar x00;\nvar y00;\nvar x0$1;\nvar y0$1;\n\nvar areaStream$1 = {\n point: noop$1,\n lineStart: noop$1,\n lineEnd: noop$1,\n polygonStart: function() {\n areaStream$1.lineStart = areaRingStart$1;\n areaStream$1.lineEnd = areaRingEnd$1;\n },\n polygonEnd: function() {\n areaStream$1.lineStart = areaStream$1.lineEnd = areaStream$1.point = noop$1;\n areaSum$1.add(abs(areaRingSum$1));\n areaRingSum$1.reset();\n },\n result: function() {\n var area = areaSum$1 / 2;\n areaSum$1.reset();\n return area;\n }\n};\n\nfunction areaRingStart$1() {\n areaStream$1.point = areaPointFirst$1;\n}\n\nfunction areaPointFirst$1(x, y) {\n areaStream$1.point = areaPoint$1;\n x00 = x0$1 = x, y00 = y0$1 = y;\n}\n\nfunction areaPoint$1(x, y) {\n areaRingSum$1.add(y0$1 * x - x0$1 * y);\n x0$1 = x, y0$1 = y;\n}\n\nfunction areaRingEnd$1() {\n areaPoint$1(x00, y00);\n}\n\nvar x0$2 = Infinity;\nvar y0$2 = x0$2;\nvar x1 = -x0$2;\nvar y1 = x1;\n\nvar boundsStream$1 = {\n point: boundsPoint$1,\n lineStart: noop$1,\n lineEnd: noop$1,\n polygonStart: noop$1,\n polygonEnd: noop$1,\n result: function() {\n var bounds = [[x0$2, y0$2], [x1, y1]];\n x1 = y1 = -(y0$2 = x0$2 = Infinity);\n return bounds;\n }\n};\n\nfunction boundsPoint$1(x, y) {\n if (x < x0$2) x0$2 = x;\n if (x > x1) x1 = x;\n if (y < y0$2) y0$2 = y;\n if (y > y1) y1 = y;\n}\n\n// TODO Enforce positive area for exterior, negative area for interior?\n\nvar X0$1 = 0;\nvar Y0$1 = 0;\nvar Z0$1 = 0;\nvar X1$1 = 0;\nvar Y1$1 = 0;\nvar Z1$1 = 0;\nvar X2$1 = 0;\nvar Y2$1 = 0;\nvar Z2$1 = 0;\nvar x00$1;\nvar y00$1;\nvar x0$3;\nvar y0$3;\n\nvar centroidStream$1 = {\n point: centroidPoint$1,\n lineStart: centroidLineStart$1,\n lineEnd: centroidLineEnd$1,\n polygonStart: function() {\n centroidStream$1.lineStart = centroidRingStart$1;\n centroidStream$1.lineEnd = centroidRingEnd$1;\n },\n polygonEnd: function() {\n centroidStream$1.point = centroidPoint$1;\n centroidStream$1.lineStart = centroidLineStart$1;\n centroidStream$1.lineEnd = centroidLineEnd$1;\n },\n result: function() {\n var centroid = Z2$1 ? [X2$1 / Z2$1, Y2$1 / Z2$1]\n : Z1$1 ? [X1$1 / Z1$1, Y1$1 / Z1$1]\n : Z0$1 ? [X0$1 / Z0$1, Y0$1 / Z0$1]\n : [NaN, NaN];\n X0$1 = Y0$1 = Z0$1 =\n X1$1 = Y1$1 = Z1$1 =\n X2$1 = Y2$1 = Z2$1 = 0;\n return centroid;\n }\n};\n\nfunction centroidPoint$1(x, y) {\n X0$1 += x;\n Y0$1 += y;\n ++Z0$1;\n}\n\nfunction centroidLineStart$1() {\n centroidStream$1.point = centroidPointFirstLine;\n}\n\nfunction centroidPointFirstLine(x, y) {\n centroidStream$1.point = centroidPointLine;\n centroidPoint$1(x0$3 = x, y0$3 = y);\n}\n\nfunction centroidPointLine(x, y) {\n var dx = x - x0$3, dy = y - y0$3, z = sqrt(dx * dx + dy * dy);\n X1$1 += z * (x0$3 + x) / 2;\n Y1$1 += z * (y0$3 + y) / 2;\n Z1$1 += z;\n centroidPoint$1(x0$3 = x, y0$3 = y);\n}\n\nfunction centroidLineEnd$1() {\n centroidStream$1.point = centroidPoint$1;\n}\n\nfunction centroidRingStart$1() {\n centroidStream$1.point = centroidPointFirstRing;\n}\n\nfunction centroidRingEnd$1() {\n centroidPointRing(x00$1, y00$1);\n}\n\nfunction centroidPointFirstRing(x, y) {\n centroidStream$1.point = centroidPointRing;\n centroidPoint$1(x00$1 = x0$3 = x, y00$1 = y0$3 = y);\n}\n\nfunction centroidPointRing(x, y) {\n var dx = x - x0$3,\n dy = y - y0$3,\n z = sqrt(dx * dx + dy * dy);\n\n X1$1 += z * (x0$3 + x) / 2;\n Y1$1 += z * (y0$3 + y) / 2;\n Z1$1 += z;\n\n z = y0$3 * x - x0$3 * y;\n X2$1 += z * (x0$3 + x);\n Y2$1 += z * (y0$3 + y);\n Z2$1 += z * 3;\n centroidPoint$1(x0$3 = x, y0$3 = y);\n}\n\nfunction PathContext(context) {\n this._context = context;\n}\n\nPathContext.prototype = {\n _radius: 4.5,\n pointRadius: function(_) {\n return this._radius = _, this;\n },\n polygonStart: function() {\n this._line = 0;\n },\n polygonEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._point = 0;\n },\n lineEnd: function() {\n if (this._line === 0) this._context.closePath();\n this._point = NaN;\n },\n point: function(x, y) {\n switch (this._point) {\n case 0: {\n this._context.moveTo(x, y);\n this._point = 1;\n break;\n }\n case 1: {\n this._context.lineTo(x, y);\n break;\n }\n default: {\n this._context.moveTo(x + this._radius, y);\n this._context.arc(x, y, this._radius, 0, tau$3);\n break;\n }\n }\n },\n result: noop$1\n};\n\nvar lengthSum$1 = adder();\nvar lengthRing;\nvar x00$2;\nvar y00$2;\nvar x0$4;\nvar y0$4;\n\nvar lengthStream$1 = {\n point: noop$1,\n lineStart: function() {\n lengthStream$1.point = lengthPointFirst$1;\n },\n lineEnd: function() {\n if (lengthRing) lengthPoint$1(x00$2, y00$2);\n lengthStream$1.point = noop$1;\n },\n polygonStart: function() {\n lengthRing = true;\n },\n polygonEnd: function() {\n lengthRing = null;\n },\n result: function() {\n var length = +lengthSum$1;\n lengthSum$1.reset();\n return length;\n }\n};\n\nfunction lengthPointFirst$1(x, y) {\n lengthStream$1.point = lengthPoint$1;\n x00$2 = x0$4 = x, y00$2 = y0$4 = y;\n}\n\nfunction lengthPoint$1(x, y) {\n x0$4 -= x, y0$4 -= y;\n lengthSum$1.add(sqrt(x0$4 * x0$4 + y0$4 * y0$4));\n x0$4 = x, y0$4 = y;\n}\n\nfunction PathString() {\n this._string = [];\n}\n\nPathString.prototype = {\n _circle: circle$1(4.5),\n pointRadius: function(_) {\n return this._circle = circle$1(_), this;\n },\n polygonStart: function() {\n this._line = 0;\n },\n polygonEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._point = 0;\n },\n lineEnd: function() {\n if (this._line === 0) this._string.push(\"Z\");\n this._point = NaN;\n },\n point: function(x, y) {\n switch (this._point) {\n case 0: {\n this._string.push(\"M\", x, \",\", y);\n this._point = 1;\n break;\n }\n case 1: {\n this._string.push(\"L\", x, \",\", y);\n break;\n }\n default: {\n this._string.push(\"M\", x, \",\", y, this._circle);\n break;\n }\n }\n },\n result: function() {\n if (this._string.length) {\n var result = this._string.join(\"\");\n this._string = [];\n return result;\n }\n }\n};\n\nfunction circle$1(radius) {\n return \"m0,\" + radius\n + \"a\" + radius + \",\" + radius + \" 0 1,1 0,\" + -2 * radius\n + \"a\" + radius + \",\" + radius + \" 0 1,1 0,\" + 2 * radius\n + \"z\";\n}\n\nvar index$1 = function(projection, context) {\n var pointRadius = 4.5,\n projectionStream,\n contextStream;\n\n function path(object) {\n if (object) {\n if (typeof pointRadius === \"function\") contextStream.pointRadius(+pointRadius.apply(this, arguments));\n geoStream(object, projectionStream(contextStream));\n }\n return contextStream.result();\n }\n\n path.area = function(object) {\n geoStream(object, projectionStream(areaStream$1));\n return areaStream$1.result();\n };\n\n path.measure = function(object) {\n geoStream(object, projectionStream(lengthStream$1));\n return lengthStream$1.result();\n };\n\n path.bounds = function(object) {\n geoStream(object, projectionStream(boundsStream$1));\n return boundsStream$1.result();\n };\n\n path.centroid = function(object) {\n geoStream(object, projectionStream(centroidStream$1));\n return centroidStream$1.result();\n };\n\n path.projection = function(_) {\n return arguments.length ? (projectionStream = _ == null ? (projection = null, identity$4) : (projection = _).stream, path) : projection;\n };\n\n path.context = function(_) {\n if (!arguments.length) return context;\n contextStream = _ == null ? (context = null, new PathString) : new PathContext(context = _);\n if (typeof pointRadius !== \"function\") contextStream.pointRadius(pointRadius);\n return path;\n };\n\n path.pointRadius = function(_) {\n if (!arguments.length) return pointRadius;\n pointRadius = typeof _ === \"function\" ? _ : (contextStream.pointRadius(+_), +_);\n return path;\n };\n\n return path.projection(projection).context(context);\n};\n\nvar sum$1 = adder();\n\nvar polygonContains = function(polygon, point) {\n var lambda = point[0],\n phi = point[1],\n normal = [sin$1(lambda), -cos$1(lambda), 0],\n angle = 0,\n winding = 0;\n\n sum$1.reset();\n\n for (var i = 0, n = polygon.length; i < n; ++i) {\n if (!(m = (ring = polygon[i]).length)) continue;\n var ring,\n m,\n point0 = ring[m - 1],\n lambda0 = point0[0],\n phi0 = point0[1] / 2 + quarterPi,\n sinPhi0 = sin$1(phi0),\n cosPhi0 = cos$1(phi0);\n\n for (var j = 0; j < m; ++j, lambda0 = lambda1, sinPhi0 = sinPhi1, cosPhi0 = cosPhi1, point0 = point1) {\n var point1 = ring[j],\n lambda1 = point1[0],\n phi1 = point1[1] / 2 + quarterPi,\n sinPhi1 = sin$1(phi1),\n cosPhi1 = cos$1(phi1),\n delta = lambda1 - lambda0,\n sign$$1 = delta >= 0 ? 1 : -1,\n absDelta = sign$$1 * delta,\n antimeridian = absDelta > pi$3,\n k = sinPhi0 * sinPhi1;\n\n sum$1.add(atan2(k * sign$$1 * sin$1(absDelta), cosPhi0 * cosPhi1 + k * cos$1(absDelta)));\n angle += antimeridian ? delta + sign$$1 * tau$3 : delta;\n\n // Are the longitudes either side of the point’s meridian (lambda),\n // and are the latitudes smaller than the parallel (phi)?\n if (antimeridian ^ lambda0 >= lambda ^ lambda1 >= lambda) {\n var arc = cartesianCross(cartesian(point0), cartesian(point1));\n cartesianNormalizeInPlace(arc);\n var intersection = cartesianCross(normal, arc);\n cartesianNormalizeInPlace(intersection);\n var phiArc = (antimeridian ^ delta >= 0 ? -1 : 1) * asin(intersection[2]);\n if (phi > phiArc || phi === phiArc && (arc[0] || arc[1])) {\n winding += antimeridian ^ delta >= 0 ? 1 : -1;\n }\n }\n }\n }\n\n // First, determine whether the South pole is inside or outside:\n //\n // It is inside if:\n // * the polygon winds around it in a clockwise direction.\n // * the polygon does not (cumulatively) wind around it, but has a negative\n // (counter-clockwise) area.\n //\n // Second, count the (signed) number of times a segment crosses a lambda\n // from the point to the South pole. If it is zero, then the point is the\n // same side as the South pole.\n\n return (angle < -epsilon$2 || angle < epsilon$2 && sum$1 < -epsilon$2) ^ (winding & 1);\n};\n\nvar clip = function(pointVisible, clipLine, interpolate, start) {\n return function(rotate, sink) {\n var line = clipLine(sink),\n rotatedStart = rotate.invert(start[0], start[1]),\n ringBuffer = clipBuffer(),\n ringSink = clipLine(ringBuffer),\n polygonStarted = false,\n polygon,\n segments,\n ring;\n\n var clip = {\n point: point,\n lineStart: lineStart,\n lineEnd: lineEnd,\n polygonStart: function() {\n clip.point = pointRing;\n clip.lineStart = ringStart;\n clip.lineEnd = ringEnd;\n segments = [];\n polygon = [];\n },\n polygonEnd: function() {\n clip.point = point;\n clip.lineStart = lineStart;\n clip.lineEnd = lineEnd;\n segments = merge(segments);\n var startInside = polygonContains(polygon, rotatedStart);\n if (segments.length) {\n if (!polygonStarted) sink.polygonStart(), polygonStarted = true;\n clipPolygon(segments, compareIntersection, startInside, interpolate, sink);\n } else if (startInside) {\n if (!polygonStarted) sink.polygonStart(), polygonStarted = true;\n sink.lineStart();\n interpolate(null, null, 1, sink);\n sink.lineEnd();\n }\n if (polygonStarted) sink.polygonEnd(), polygonStarted = false;\n segments = polygon = null;\n },\n sphere: function() {\n sink.polygonStart();\n sink.lineStart();\n interpolate(null, null, 1, sink);\n sink.lineEnd();\n sink.polygonEnd();\n }\n };\n\n function point(lambda, phi) {\n var point = rotate(lambda, phi);\n if (pointVisible(lambda = point[0], phi = point[1])) sink.point(lambda, phi);\n }\n\n function pointLine(lambda, phi) {\n var point = rotate(lambda, phi);\n line.point(point[0], point[1]);\n }\n\n function lineStart() {\n clip.point = pointLine;\n line.lineStart();\n }\n\n function lineEnd() {\n clip.point = point;\n line.lineEnd();\n }\n\n function pointRing(lambda, phi) {\n ring.push([lambda, phi]);\n var point = rotate(lambda, phi);\n ringSink.point(point[0], point[1]);\n }\n\n function ringStart() {\n ringSink.lineStart();\n ring = [];\n }\n\n function ringEnd() {\n pointRing(ring[0][0], ring[0][1]);\n ringSink.lineEnd();\n\n var clean = ringSink.clean(),\n ringSegments = ringBuffer.result(),\n i, n = ringSegments.length, m,\n segment,\n point;\n\n ring.pop();\n polygon.push(ring);\n ring = null;\n\n if (!n) return;\n\n // No intersections.\n if (clean & 1) {\n segment = ringSegments[0];\n if ((m = segment.length - 1) > 0) {\n if (!polygonStarted) sink.polygonStart(), polygonStarted = true;\n sink.lineStart();\n for (i = 0; i < m; ++i) sink.point((point = segment[i])[0], point[1]);\n sink.lineEnd();\n }\n return;\n }\n\n // Rejoin connected segments.\n // TODO reuse ringBuffer.rejoin()?\n if (n > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift()));\n\n segments.push(ringSegments.filter(validSegment));\n }\n\n return clip;\n };\n};\n\nfunction validSegment(segment) {\n return segment.length > 1;\n}\n\n// Intersections are sorted along the clip edge. For both antimeridian cutting\n// and circle clipping, the same comparison is used.\nfunction compareIntersection(a, b) {\n return ((a = a.x)[0] < 0 ? a[1] - halfPi$2 - epsilon$2 : halfPi$2 - a[1])\n - ((b = b.x)[0] < 0 ? b[1] - halfPi$2 - epsilon$2 : halfPi$2 - b[1]);\n}\n\nvar clipAntimeridian = clip(\n function() { return true; },\n clipAntimeridianLine,\n clipAntimeridianInterpolate,\n [-pi$3, -halfPi$2]\n);\n\n// Takes a line and cuts into visible segments. Return values: 0 - there were\n// intersections or the line was empty; 1 - no intersections; 2 - there were\n// intersections, and the first and last segments should be rejoined.\nfunction clipAntimeridianLine(stream) {\n var lambda0 = NaN,\n phi0 = NaN,\n sign0 = NaN,\n clean; // no intersections\n\n return {\n lineStart: function() {\n stream.lineStart();\n clean = 1;\n },\n point: function(lambda1, phi1) {\n var sign1 = lambda1 > 0 ? pi$3 : -pi$3,\n delta = abs(lambda1 - lambda0);\n if (abs(delta - pi$3) < epsilon$2) { // line crosses a pole\n stream.point(lambda0, phi0 = (phi0 + phi1) / 2 > 0 ? halfPi$2 : -halfPi$2);\n stream.point(sign0, phi0);\n stream.lineEnd();\n stream.lineStart();\n stream.point(sign1, phi0);\n stream.point(lambda1, phi0);\n clean = 0;\n } else if (sign0 !== sign1 && delta >= pi$3) { // line crosses antimeridian\n if (abs(lambda0 - sign0) < epsilon$2) lambda0 -= sign0 * epsilon$2; // handle degeneracies\n if (abs(lambda1 - sign1) < epsilon$2) lambda1 -= sign1 * epsilon$2;\n phi0 = clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1);\n stream.point(sign0, phi0);\n stream.lineEnd();\n stream.lineStart();\n stream.point(sign1, phi0);\n clean = 0;\n }\n stream.point(lambda0 = lambda1, phi0 = phi1);\n sign0 = sign1;\n },\n lineEnd: function() {\n stream.lineEnd();\n lambda0 = phi0 = NaN;\n },\n clean: function() {\n return 2 - clean; // if intersections, rejoin first and last segments\n }\n };\n}\n\nfunction clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1) {\n var cosPhi0,\n cosPhi1,\n sinLambda0Lambda1 = sin$1(lambda0 - lambda1);\n return abs(sinLambda0Lambda1) > epsilon$2\n ? atan((sin$1(phi0) * (cosPhi1 = cos$1(phi1)) * sin$1(lambda1)\n - sin$1(phi1) * (cosPhi0 = cos$1(phi0)) * sin$1(lambda0))\n / (cosPhi0 * cosPhi1 * sinLambda0Lambda1))\n : (phi0 + phi1) / 2;\n}\n\nfunction clipAntimeridianInterpolate(from, to, direction, stream) {\n var phi;\n if (from == null) {\n phi = direction * halfPi$2;\n stream.point(-pi$3, phi);\n stream.point(0, phi);\n stream.point(pi$3, phi);\n stream.point(pi$3, 0);\n stream.point(pi$3, -phi);\n stream.point(0, -phi);\n stream.point(-pi$3, -phi);\n stream.point(-pi$3, 0);\n stream.point(-pi$3, phi);\n } else if (abs(from[0] - to[0]) > epsilon$2) {\n var lambda = from[0] < to[0] ? pi$3 : -pi$3;\n phi = direction * lambda / 2;\n stream.point(-lambda, phi);\n stream.point(0, phi);\n stream.point(lambda, phi);\n } else {\n stream.point(to[0], to[1]);\n }\n}\n\nvar clipCircle = function(radius, delta) {\n var cr = cos$1(radius),\n smallRadius = cr > 0,\n notHemisphere = abs(cr) > epsilon$2; // TODO optimise for this common case\n\n function interpolate(from, to, direction, stream) {\n circleStream(stream, radius, delta, direction, from, to);\n }\n\n function visible(lambda, phi) {\n return cos$1(lambda) * cos$1(phi) > cr;\n }\n\n // Takes a line and cuts into visible segments. Return values used for polygon\n // clipping: 0 - there were intersections or the line was empty; 1 - no\n // intersections 2 - there were intersections, and the first and last segments\n // should be rejoined.\n function clipLine(stream) {\n var point0, // previous point\n c0, // code for previous point\n v0, // visibility of previous point\n v00, // visibility of first point\n clean; // no intersections\n return {\n lineStart: function() {\n v00 = v0 = false;\n clean = 1;\n },\n point: function(lambda, phi) {\n var point1 = [lambda, phi],\n point2,\n v = visible(lambda, phi),\n c = smallRadius\n ? v ? 0 : code(lambda, phi)\n : v ? code(lambda + (lambda < 0 ? pi$3 : -pi$3), phi) : 0;\n if (!point0 && (v00 = v0 = v)) stream.lineStart();\n // Handle degeneracies.\n // TODO ignore if not clipping polygons.\n if (v !== v0) {\n point2 = intersect(point0, point1);\n if (pointEqual(point0, point2) || pointEqual(point1, point2)) {\n point1[0] += epsilon$2;\n point1[1] += epsilon$2;\n v = visible(point1[0], point1[1]);\n }\n }\n if (v !== v0) {\n clean = 0;\n if (v) {\n // outside going in\n stream.lineStart();\n point2 = intersect(point1, point0);\n stream.point(point2[0], point2[1]);\n } else {\n // inside going out\n point2 = intersect(point0, point1);\n stream.point(point2[0], point2[1]);\n stream.lineEnd();\n }\n point0 = point2;\n } else if (notHemisphere && point0 && smallRadius ^ v) {\n var t;\n // If the codes for two points are different, or are both zero,\n // and there this segment intersects with the small circle.\n if (!(c & c0) && (t = intersect(point1, point0, true))) {\n clean = 0;\n if (smallRadius) {\n stream.lineStart();\n stream.point(t[0][0], t[0][1]);\n stream.point(t[1][0], t[1][1]);\n stream.lineEnd();\n } else {\n stream.point(t[1][0], t[1][1]);\n stream.lineEnd();\n stream.lineStart();\n stream.point(t[0][0], t[0][1]);\n }\n }\n }\n if (v && (!point0 || !pointEqual(point0, point1))) {\n stream.point(point1[0], point1[1]);\n }\n point0 = point1, v0 = v, c0 = c;\n },\n lineEnd: function() {\n if (v0) stream.lineEnd();\n point0 = null;\n },\n // Rejoin first and last segments if there were intersections and the first\n // and last points were visible.\n clean: function() {\n return clean | ((v00 && v0) << 1);\n }\n };\n }\n\n // Intersects the great circle between a and b with the clip circle.\n function intersect(a, b, two) {\n var pa = cartesian(a),\n pb = cartesian(b);\n\n // We have two planes, n1.p = d1 and n2.p = d2.\n // Find intersection line p(t) = c1 n1 + c2 n2 + t (n1 ⨯ n2).\n var n1 = [1, 0, 0], // normal\n n2 = cartesianCross(pa, pb),\n n2n2 = cartesianDot(n2, n2),\n n1n2 = n2[0], // cartesianDot(n1, n2),\n determinant = n2n2 - n1n2 * n1n2;\n\n // Two polar points.\n if (!determinant) return !two && a;\n\n var c1 = cr * n2n2 / determinant,\n c2 = -cr * n1n2 / determinant,\n n1xn2 = cartesianCross(n1, n2),\n A = cartesianScale(n1, c1),\n B = cartesianScale(n2, c2);\n cartesianAddInPlace(A, B);\n\n // Solve |p(t)|^2 = 1.\n var u = n1xn2,\n w = cartesianDot(A, u),\n uu = cartesianDot(u, u),\n t2 = w * w - uu * (cartesianDot(A, A) - 1);\n\n if (t2 < 0) return;\n\n var t = sqrt(t2),\n q = cartesianScale(u, (-w - t) / uu);\n cartesianAddInPlace(q, A);\n q = spherical(q);\n\n if (!two) return q;\n\n // Two intersection points.\n var lambda0 = a[0],\n lambda1 = b[0],\n phi0 = a[1],\n phi1 = b[1],\n z;\n\n if (lambda1 < lambda0) z = lambda0, lambda0 = lambda1, lambda1 = z;\n\n var delta = lambda1 - lambda0,\n polar = abs(delta - pi$3) < epsilon$2,\n meridian = polar || delta < epsilon$2;\n\n if (!polar && phi1 < phi0) z = phi0, phi0 = phi1, phi1 = z;\n\n // Check that the first point is between a and b.\n if (meridian\n ? polar\n ? phi0 + phi1 > 0 ^ q[1] < (abs(q[0] - lambda0) < epsilon$2 ? phi0 : phi1)\n : phi0 <= q[1] && q[1] <= phi1\n : delta > pi$3 ^ (lambda0 <= q[0] && q[0] <= lambda1)) {\n var q1 = cartesianScale(u, (-w + t) / uu);\n cartesianAddInPlace(q1, A);\n return [q, spherical(q1)];\n }\n }\n\n // Generates a 4-bit vector representing the location of a point relative to\n // the small circle's bounding box.\n function code(lambda, phi) {\n var r = smallRadius ? radius : pi$3 - radius,\n code = 0;\n if (lambda < -r) code |= 1; // left\n else if (lambda > r) code |= 2; // right\n if (phi < -r) code |= 4; // below\n else if (phi > r) code |= 8; // above\n return code;\n }\n\n return clip(visible, clipLine, interpolate, smallRadius ? [0, -radius] : [-pi$3, radius - pi$3]);\n};\n\nvar transform = function(methods) {\n return {\n stream: transformer(methods)\n };\n};\n\nfunction transformer(methods) {\n return function(stream) {\n var s = new TransformStream;\n for (var key in methods) s[key] = methods[key];\n s.stream = stream;\n return s;\n };\n}\n\nfunction TransformStream() {}\n\nTransformStream.prototype = {\n constructor: TransformStream,\n point: function(x, y) { this.stream.point(x, y); },\n sphere: function() { this.stream.sphere(); },\n lineStart: function() { this.stream.lineStart(); },\n lineEnd: function() { this.stream.lineEnd(); },\n polygonStart: function() { this.stream.polygonStart(); },\n polygonEnd: function() { this.stream.polygonEnd(); }\n};\n\nfunction fitExtent(projection, extent, object) {\n var w = extent[1][0] - extent[0][0],\n h = extent[1][1] - extent[0][1],\n clip = projection.clipExtent && projection.clipExtent();\n\n projection\n .scale(150)\n .translate([0, 0]);\n\n if (clip != null) projection.clipExtent(null);\n\n geoStream(object, projection.stream(boundsStream$1));\n\n var b = boundsStream$1.result(),\n k = Math.min(w / (b[1][0] - b[0][0]), h / (b[1][1] - b[0][1])),\n x = +extent[0][0] + (w - k * (b[1][0] + b[0][0])) / 2,\n y = +extent[0][1] + (h - k * (b[1][1] + b[0][1])) / 2;\n\n if (clip != null) projection.clipExtent(clip);\n\n return projection\n .scale(k * 150)\n .translate([x, y]);\n}\n\nfunction fitSize(projection, size, object) {\n return fitExtent(projection, [[0, 0], size], object);\n}\n\nvar maxDepth = 16;\nvar cosMinDistance = cos$1(30 * radians); // cos(minimum angular distance)\n\nvar resample = function(project, delta2) {\n return +delta2 ? resample$1(project, delta2) : resampleNone(project);\n};\n\nfunction resampleNone(project) {\n return transformer({\n point: function(x, y) {\n x = project(x, y);\n this.stream.point(x[0], x[1]);\n }\n });\n}\n\nfunction resample$1(project, delta2) {\n\n function resampleLineTo(x0, y0, lambda0, a0, b0, c0, x1, y1, lambda1, a1, b1, c1, depth, stream) {\n var dx = x1 - x0,\n dy = y1 - y0,\n d2 = dx * dx + dy * dy;\n if (d2 > 4 * delta2 && depth--) {\n var a = a0 + a1,\n b = b0 + b1,\n c = c0 + c1,\n m = sqrt(a * a + b * b + c * c),\n phi2 = asin(c /= m),\n lambda2 = abs(abs(c) - 1) < epsilon$2 || abs(lambda0 - lambda1) < epsilon$2 ? (lambda0 + lambda1) / 2 : atan2(b, a),\n p = project(lambda2, phi2),\n x2 = p[0],\n y2 = p[1],\n dx2 = x2 - x0,\n dy2 = y2 - y0,\n dz = dy * dx2 - dx * dy2;\n if (dz * dz / d2 > delta2 // perpendicular projected distance\n || abs((dx * dx2 + dy * dy2) / d2 - 0.5) > 0.3 // midpoint close to an end\n || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) { // angular distance\n resampleLineTo(x0, y0, lambda0, a0, b0, c0, x2, y2, lambda2, a /= m, b /= m, c, depth, stream);\n stream.point(x2, y2);\n resampleLineTo(x2, y2, lambda2, a, b, c, x1, y1, lambda1, a1, b1, c1, depth, stream);\n }\n }\n }\n return function(stream) {\n var lambda00, x00, y00, a00, b00, c00, // first point\n lambda0, x0, y0, a0, b0, c0; // previous point\n\n var resampleStream = {\n point: point,\n lineStart: lineStart,\n lineEnd: lineEnd,\n polygonStart: function() { stream.polygonStart(); resampleStream.lineStart = ringStart; },\n polygonEnd: function() { stream.polygonEnd(); resampleStream.lineStart = lineStart; }\n };\n\n function point(x, y) {\n x = project(x, y);\n stream.point(x[0], x[1]);\n }\n\n function lineStart() {\n x0 = NaN;\n resampleStream.point = linePoint;\n stream.lineStart();\n }\n\n function linePoint(lambda, phi) {\n var c = cartesian([lambda, phi]), p = project(lambda, phi);\n resampleLineTo(x0, y0, lambda0, a0, b0, c0, x0 = p[0], y0 = p[1], lambda0 = lambda, a0 = c[0], b0 = c[1], c0 = c[2], maxDepth, stream);\n stream.point(x0, y0);\n }\n\n function lineEnd() {\n resampleStream.point = point;\n stream.lineEnd();\n }\n\n function ringStart() {\n lineStart();\n resampleStream.point = ringPoint;\n resampleStream.lineEnd = ringEnd;\n }\n\n function ringPoint(lambda, phi) {\n linePoint(lambda00 = lambda, phi), x00 = x0, y00 = y0, a00 = a0, b00 = b0, c00 = c0;\n resampleStream.point = linePoint;\n }\n\n function ringEnd() {\n resampleLineTo(x0, y0, lambda0, a0, b0, c0, x00, y00, lambda00, a00, b00, c00, maxDepth, stream);\n resampleStream.lineEnd = lineEnd;\n lineEnd();\n }\n\n return resampleStream;\n };\n}\n\nvar transformRadians = transformer({\n point: function(x, y) {\n this.stream.point(x * radians, y * radians);\n }\n});\n\nfunction projection(project) {\n return projectionMutator(function() { return project; })();\n}\n\nfunction projectionMutator(projectAt) {\n var project,\n k = 150, // scale\n x = 480, y = 250, // translate\n dx, dy, lambda = 0, phi = 0, // center\n deltaLambda = 0, deltaPhi = 0, deltaGamma = 0, rotate, projectRotate, // rotate\n theta = null, preclip = clipAntimeridian, // clip angle\n x0 = null, y0, x1, y1, postclip = identity$4, // clip extent\n delta2 = 0.5, projectResample = resample(projectTransform, delta2), // precision\n cache,\n cacheStream;\n\n function projection(point) {\n point = projectRotate(point[0] * radians, point[1] * radians);\n return [point[0] * k + dx, dy - point[1] * k];\n }\n\n function invert(point) {\n point = projectRotate.invert((point[0] - dx) / k, (dy - point[1]) / k);\n return point && [point[0] * degrees$1, point[1] * degrees$1];\n }\n\n function projectTransform(x, y) {\n return x = project(x, y), [x[0] * k + dx, dy - x[1] * k];\n }\n\n projection.stream = function(stream) {\n return cache && cacheStream === stream ? cache : cache = transformRadians(preclip(rotate, projectResample(postclip(cacheStream = stream))));\n };\n\n projection.clipAngle = function(_) {\n return arguments.length ? (preclip = +_ ? clipCircle(theta = _ * radians, 6 * radians) : (theta = null, clipAntimeridian), reset()) : theta * degrees$1;\n };\n\n projection.clipExtent = function(_) {\n return arguments.length ? (postclip = _ == null ? (x0 = y0 = x1 = y1 = null, identity$4) : clipExtent(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]), reset()) : x0 == null ? null : [[x0, y0], [x1, y1]];\n };\n\n projection.scale = function(_) {\n return arguments.length ? (k = +_, recenter()) : k;\n };\n\n projection.translate = function(_) {\n return arguments.length ? (x = +_[0], y = +_[1], recenter()) : [x, y];\n };\n\n projection.center = function(_) {\n return arguments.length ? (lambda = _[0] % 360 * radians, phi = _[1] % 360 * radians, recenter()) : [lambda * degrees$1, phi * degrees$1];\n };\n\n projection.rotate = function(_) {\n return arguments.length ? (deltaLambda = _[0] % 360 * radians, deltaPhi = _[1] % 360 * radians, deltaGamma = _.length > 2 ? _[2] % 360 * radians : 0, recenter()) : [deltaLambda * degrees$1, deltaPhi * degrees$1, deltaGamma * degrees$1];\n };\n\n projection.precision = function(_) {\n return arguments.length ? (projectResample = resample(projectTransform, delta2 = _ * _), reset()) : sqrt(delta2);\n };\n\n projection.fitExtent = function(extent, object) {\n return fitExtent(projection, extent, object);\n };\n\n projection.fitSize = function(size, object) {\n return fitSize(projection, size, object);\n };\n\n function recenter() {\n projectRotate = compose(rotate = rotateRadians(deltaLambda, deltaPhi, deltaGamma), project);\n var center = project(lambda, phi);\n dx = x - center[0] * k;\n dy = y + center[1] * k;\n return reset();\n }\n\n function reset() {\n cache = cacheStream = null;\n return projection;\n }\n\n return function() {\n project = projectAt.apply(this, arguments);\n projection.invert = project.invert && invert;\n return recenter();\n };\n}\n\nfunction conicProjection(projectAt) {\n var phi0 = 0,\n phi1 = pi$3 / 3,\n m = projectionMutator(projectAt),\n p = m(phi0, phi1);\n\n p.parallels = function(_) {\n return arguments.length ? m(phi0 = _[0] * radians, phi1 = _[1] * radians) : [phi0 * degrees$1, phi1 * degrees$1];\n };\n\n return p;\n}\n\nfunction cylindricalEqualAreaRaw(phi0) {\n var cosPhi0 = cos$1(phi0);\n\n function forward(lambda, phi) {\n return [lambda * cosPhi0, sin$1(phi) / cosPhi0];\n }\n\n forward.invert = function(x, y) {\n return [x / cosPhi0, asin(y * cosPhi0)];\n };\n\n return forward;\n}\n\nfunction conicEqualAreaRaw(y0, y1) {\n var sy0 = sin$1(y0), n = (sy0 + sin$1(y1)) / 2;\n\n // Are the parallels symmetrical around the Equator?\n if (abs(n) < epsilon$2) return cylindricalEqualAreaRaw(y0);\n\n var c = 1 + sy0 * (2 * n - sy0), r0 = sqrt(c) / n;\n\n function project(x, y) {\n var r = sqrt(c - 2 * n * sin$1(y)) / n;\n return [r * sin$1(x *= n), r0 - r * cos$1(x)];\n }\n\n project.invert = function(x, y) {\n var r0y = r0 - y;\n return [atan2(x, abs(r0y)) / n * sign(r0y), asin((c - (x * x + r0y * r0y) * n * n) / (2 * n))];\n };\n\n return project;\n}\n\nvar conicEqualArea = function() {\n return conicProjection(conicEqualAreaRaw)\n .scale(155.424)\n .center([0, 33.6442]);\n};\n\nvar albers = function() {\n return conicEqualArea()\n .parallels([29.5, 45.5])\n .scale(1070)\n .translate([480, 250])\n .rotate([96, 0])\n .center([-0.6, 38.7]);\n};\n\n// The projections must have mutually exclusive clip regions on the sphere,\n// as this will avoid emitting interleaving lines and polygons.\nfunction multiplex(streams) {\n var n = streams.length;\n return {\n point: function(x, y) { var i = -1; while (++i < n) streams[i].point(x, y); },\n sphere: function() { var i = -1; while (++i < n) streams[i].sphere(); },\n lineStart: function() { var i = -1; while (++i < n) streams[i].lineStart(); },\n lineEnd: function() { var i = -1; while (++i < n) streams[i].lineEnd(); },\n polygonStart: function() { var i = -1; while (++i < n) streams[i].polygonStart(); },\n polygonEnd: function() { var i = -1; while (++i < n) streams[i].polygonEnd(); }\n };\n}\n\n// A composite projection for the United States, configured by default for\n// 960×500. The projection also works quite well at 960×600 if you change the\n// scale to 1285 and adjust the translate accordingly. The set of standard\n// parallels for each region comes from USGS, which is published here:\n// http://egsc.usgs.gov/isb/pubs/MapProjections/projections.html#albers\nvar albersUsa = function() {\n var cache,\n cacheStream,\n lower48 = albers(), lower48Point,\n alaska = conicEqualArea().rotate([154, 0]).center([-2, 58.5]).parallels([55, 65]), alaskaPoint, // EPSG:3338\n hawaii = conicEqualArea().rotate([157, 0]).center([-3, 19.9]).parallels([8, 18]), hawaiiPoint, // ESRI:102007\n point, pointStream = {point: function(x, y) { point = [x, y]; }};\n\n function albersUsa(coordinates) {\n var x = coordinates[0], y = coordinates[1];\n return point = null,\n (lower48Point.point(x, y), point)\n || (alaskaPoint.point(x, y), point)\n || (hawaiiPoint.point(x, y), point);\n }\n\n albersUsa.invert = function(coordinates) {\n var k = lower48.scale(),\n t = lower48.translate(),\n x = (coordinates[0] - t[0]) / k,\n y = (coordinates[1] - t[1]) / k;\n return (y >= 0.120 && y < 0.234 && x >= -0.425 && x < -0.214 ? alaska\n : y >= 0.166 && y < 0.234 && x >= -0.214 && x < -0.115 ? hawaii\n : lower48).invert(coordinates);\n };\n\n albersUsa.stream = function(stream) {\n return cache && cacheStream === stream ? cache : cache = multiplex([lower48.stream(cacheStream = stream), alaska.stream(stream), hawaii.stream(stream)]);\n };\n\n albersUsa.precision = function(_) {\n if (!arguments.length) return lower48.precision();\n lower48.precision(_), alaska.precision(_), hawaii.precision(_);\n return reset();\n };\n\n albersUsa.scale = function(_) {\n if (!arguments.length) return lower48.scale();\n lower48.scale(_), alaska.scale(_ * 0.35), hawaii.scale(_);\n return albersUsa.translate(lower48.translate());\n };\n\n albersUsa.translate = function(_) {\n if (!arguments.length) return lower48.translate();\n var k = lower48.scale(), x = +_[0], y = +_[1];\n\n lower48Point = lower48\n .translate(_)\n .clipExtent([[x - 0.455 * k, y - 0.238 * k], [x + 0.455 * k, y + 0.238 * k]])\n .stream(pointStream);\n\n alaskaPoint = alaska\n .translate([x - 0.307 * k, y + 0.201 * k])\n .clipExtent([[x - 0.425 * k + epsilon$2, y + 0.120 * k + epsilon$2], [x - 0.214 * k - epsilon$2, y + 0.234 * k - epsilon$2]])\n .stream(pointStream);\n\n hawaiiPoint = hawaii\n .translate([x - 0.205 * k, y + 0.212 * k])\n .clipExtent([[x - 0.214 * k + epsilon$2, y + 0.166 * k + epsilon$2], [x - 0.115 * k - epsilon$2, y + 0.234 * k - epsilon$2]])\n .stream(pointStream);\n\n return reset();\n };\n\n albersUsa.fitExtent = function(extent, object) {\n return fitExtent(albersUsa, extent, object);\n };\n\n albersUsa.fitSize = function(size, object) {\n return fitSize(albersUsa, size, object);\n };\n\n function reset() {\n cache = cacheStream = null;\n return albersUsa;\n }\n\n return albersUsa.scale(1070);\n};\n\nfunction azimuthalRaw(scale) {\n return function(x, y) {\n var cx = cos$1(x),\n cy = cos$1(y),\n k = scale(cx * cy);\n return [\n k * cy * sin$1(x),\n k * sin$1(y)\n ];\n }\n}\n\nfunction azimuthalInvert(angle) {\n return function(x, y) {\n var z = sqrt(x * x + y * y),\n c = angle(z),\n sc = sin$1(c),\n cc = cos$1(c);\n return [\n atan2(x * sc, z * cc),\n asin(z && y * sc / z)\n ];\n }\n}\n\nvar azimuthalEqualAreaRaw = azimuthalRaw(function(cxcy) {\n return sqrt(2 / (1 + cxcy));\n});\n\nazimuthalEqualAreaRaw.invert = azimuthalInvert(function(z) {\n return 2 * asin(z / 2);\n});\n\nvar azimuthalEqualArea = function() {\n return projection(azimuthalEqualAreaRaw)\n .scale(124.75)\n .clipAngle(180 - 1e-3);\n};\n\nvar azimuthalEquidistantRaw = azimuthalRaw(function(c) {\n return (c = acos(c)) && c / sin$1(c);\n});\n\nazimuthalEquidistantRaw.invert = azimuthalInvert(function(z) {\n return z;\n});\n\nvar azimuthalEquidistant = function() {\n return projection(azimuthalEquidistantRaw)\n .scale(79.4188)\n .clipAngle(180 - 1e-3);\n};\n\nfunction mercatorRaw(lambda, phi) {\n return [lambda, log(tan((halfPi$2 + phi) / 2))];\n}\n\nmercatorRaw.invert = function(x, y) {\n return [x, 2 * atan(exp(y)) - halfPi$2];\n};\n\nvar mercator = function() {\n return mercatorProjection(mercatorRaw)\n .scale(961 / tau$3);\n};\n\nfunction mercatorProjection(project) {\n var m = projection(project),\n scale = m.scale,\n translate = m.translate,\n clipExtent = m.clipExtent,\n clipAuto;\n\n m.scale = function(_) {\n return arguments.length ? (scale(_), clipAuto && m.clipExtent(null), m) : scale();\n };\n\n m.translate = function(_) {\n return arguments.length ? (translate(_), clipAuto && m.clipExtent(null), m) : translate();\n };\n\n m.clipExtent = function(_) {\n if (!arguments.length) return clipAuto ? null : clipExtent();\n if (clipAuto = _ == null) {\n var k = pi$3 * scale(),\n t = translate();\n _ = [[t[0] - k, t[1] - k], [t[0] + k, t[1] + k]];\n }\n clipExtent(_);\n return m;\n };\n\n return m.clipExtent(null);\n}\n\nfunction tany(y) {\n return tan((halfPi$2 + y) / 2);\n}\n\nfunction conicConformalRaw(y0, y1) {\n var cy0 = cos$1(y0),\n n = y0 === y1 ? sin$1(y0) : log(cy0 / cos$1(y1)) / log(tany(y1) / tany(y0)),\n f = cy0 * pow(tany(y0), n) / n;\n\n if (!n) return mercatorRaw;\n\n function project(x, y) {\n if (f > 0) { if (y < -halfPi$2 + epsilon$2) y = -halfPi$2 + epsilon$2; }\n else { if (y > halfPi$2 - epsilon$2) y = halfPi$2 - epsilon$2; }\n var r = f / pow(tany(y), n);\n return [r * sin$1(n * x), f - r * cos$1(n * x)];\n }\n\n project.invert = function(x, y) {\n var fy = f - y, r = sign(n) * sqrt(x * x + fy * fy);\n return [atan2(x, abs(fy)) / n * sign(fy), 2 * atan(pow(f / r, 1 / n)) - halfPi$2];\n };\n\n return project;\n}\n\nvar conicConformal = function() {\n return conicProjection(conicConformalRaw)\n .scale(109.5)\n .parallels([30, 30]);\n};\n\nfunction equirectangularRaw(lambda, phi) {\n return [lambda, phi];\n}\n\nequirectangularRaw.invert = equirectangularRaw;\n\nvar equirectangular = function() {\n return projection(equirectangularRaw)\n .scale(152.63);\n};\n\nfunction conicEquidistantRaw(y0, y1) {\n var cy0 = cos$1(y0),\n n = y0 === y1 ? sin$1(y0) : (cy0 - cos$1(y1)) / (y1 - y0),\n g = cy0 / n + y0;\n\n if (abs(n) < epsilon$2) return equirectangularRaw;\n\n function project(x, y) {\n var gy = g - y, nx = n * x;\n return [gy * sin$1(nx), g - gy * cos$1(nx)];\n }\n\n project.invert = function(x, y) {\n var gy = g - y;\n return [atan2(x, abs(gy)) / n * sign(gy), g - sign(n) * sqrt(x * x + gy * gy)];\n };\n\n return project;\n}\n\nvar conicEquidistant = function() {\n return conicProjection(conicEquidistantRaw)\n .scale(131.154)\n .center([0, 13.9389]);\n};\n\nfunction gnomonicRaw(x, y) {\n var cy = cos$1(y), k = cos$1(x) * cy;\n return [cy * sin$1(x) / k, sin$1(y) / k];\n}\n\ngnomonicRaw.invert = azimuthalInvert(atan);\n\nvar gnomonic = function() {\n return projection(gnomonicRaw)\n .scale(144.049)\n .clipAngle(60);\n};\n\nfunction scaleTranslate(kx, ky, tx, ty) {\n return kx === 1 && ky === 1 && tx === 0 && ty === 0 ? identity$4 : transformer({\n point: function(x, y) {\n this.stream.point(x * kx + tx, y * ky + ty);\n }\n });\n}\n\nvar identity$5 = function() {\n var k = 1, tx = 0, ty = 0, sx = 1, sy = 1, transform = identity$4, // scale, translate and reflect\n x0 = null, y0, x1, y1, clip = identity$4, // clip extent\n cache,\n cacheStream,\n projection;\n\n function reset() {\n cache = cacheStream = null;\n return projection;\n }\n\n return projection = {\n stream: function(stream) {\n return cache && cacheStream === stream ? cache : cache = transform(clip(cacheStream = stream));\n },\n clipExtent: function(_) {\n return arguments.length ? (clip = _ == null ? (x0 = y0 = x1 = y1 = null, identity$4) : clipExtent(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]), reset()) : x0 == null ? null : [[x0, y0], [x1, y1]];\n },\n scale: function(_) {\n return arguments.length ? (transform = scaleTranslate((k = +_) * sx, k * sy, tx, ty), reset()) : k;\n },\n translate: function(_) {\n return arguments.length ? (transform = scaleTranslate(k * sx, k * sy, tx = +_[0], ty = +_[1]), reset()) : [tx, ty];\n },\n reflectX: function(_) {\n return arguments.length ? (transform = scaleTranslate(k * (sx = _ ? -1 : 1), k * sy, tx, ty), reset()) : sx < 0;\n },\n reflectY: function(_) {\n return arguments.length ? (transform = scaleTranslate(k * sx, k * (sy = _ ? -1 : 1), tx, ty), reset()) : sy < 0;\n },\n fitExtent: function(extent, object) {\n return fitExtent(projection, extent, object);\n },\n fitSize: function(size, object) {\n return fitSize(projection, size, object);\n }\n };\n};\n\nfunction orthographicRaw(x, y) {\n return [cos$1(y) * sin$1(x), sin$1(y)];\n}\n\northographicRaw.invert = azimuthalInvert(asin);\n\nvar orthographic = function() {\n return projection(orthographicRaw)\n .scale(249.5)\n .clipAngle(90 + epsilon$2);\n};\n\nfunction stereographicRaw(x, y) {\n var cy = cos$1(y), k = 1 + cos$1(x) * cy;\n return [cy * sin$1(x) / k, sin$1(y) / k];\n}\n\nstereographicRaw.invert = azimuthalInvert(function(z) {\n return 2 * atan(z);\n});\n\nvar stereographic = function() {\n return projection(stereographicRaw)\n .scale(250)\n .clipAngle(142);\n};\n\nfunction transverseMercatorRaw(lambda, phi) {\n return [log(tan((halfPi$2 + phi) / 2)), -lambda];\n}\n\ntransverseMercatorRaw.invert = function(x, y) {\n return [-y, 2 * atan(exp(x)) - halfPi$2];\n};\n\nvar transverseMercator = function() {\n var m = mercatorProjection(transverseMercatorRaw),\n center = m.center,\n rotate = m.rotate;\n\n m.center = function(_) {\n return arguments.length ? center([-_[1], _[0]]) : (_ = center(), [_[1], -_[0]]);\n };\n\n m.rotate = function(_) {\n return arguments.length ? rotate([_[0], _[1], _.length > 2 ? _[2] + 90 : 90]) : (_ = rotate(), [_[0], _[1], _[2] - 90]);\n };\n\n return rotate([0, 0, 90])\n .scale(159.155);\n};\n\nfunction defaultSeparation(a, b) {\n return a.parent === b.parent ? 1 : 2;\n}\n\nfunction meanX(children) {\n return children.reduce(meanXReduce, 0) / children.length;\n}\n\nfunction meanXReduce(x, c) {\n return x + c.x;\n}\n\nfunction maxY(children) {\n return 1 + children.reduce(maxYReduce, 0);\n}\n\nfunction maxYReduce(y, c) {\n return Math.max(y, c.y);\n}\n\nfunction leafLeft(node) {\n var children;\n while (children = node.children) node = children[0];\n return node;\n}\n\nfunction leafRight(node) {\n var children;\n while (children = node.children) node = children[children.length - 1];\n return node;\n}\n\nvar cluster = function() {\n var separation = defaultSeparation,\n dx = 1,\n dy = 1,\n nodeSize = false;\n\n function cluster(root) {\n var previousNode,\n x = 0;\n\n // First walk, computing the initial x & y values.\n root.eachAfter(function(node) {\n var children = node.children;\n if (children) {\n node.x = meanX(children);\n node.y = maxY(children);\n } else {\n node.x = previousNode ? x += separation(node, previousNode) : 0;\n node.y = 0;\n previousNode = node;\n }\n });\n\n var left = leafLeft(root),\n right = leafRight(root),\n x0 = left.x - separation(left, right) / 2,\n x1 = right.x + separation(right, left) / 2;\n\n // Second walk, normalizing x & y to the desired size.\n return root.eachAfter(nodeSize ? function(node) {\n node.x = (node.x - root.x) * dx;\n node.y = (root.y - node.y) * dy;\n } : function(node) {\n node.x = (node.x - x0) / (x1 - x0) * dx;\n node.y = (1 - (root.y ? node.y / root.y : 1)) * dy;\n });\n }\n\n cluster.separation = function(x) {\n return arguments.length ? (separation = x, cluster) : separation;\n };\n\n cluster.size = function(x) {\n return arguments.length ? (nodeSize = false, dx = +x[0], dy = +x[1], cluster) : (nodeSize ? null : [dx, dy]);\n };\n\n cluster.nodeSize = function(x) {\n return arguments.length ? (nodeSize = true, dx = +x[0], dy = +x[1], cluster) : (nodeSize ? [dx, dy] : null);\n };\n\n return cluster;\n};\n\nfunction count(node) {\n var sum = 0,\n children = node.children,\n i = children && children.length;\n if (!i) sum = 1;\n else while (--i >= 0) sum += children[i].value;\n node.value = sum;\n}\n\nvar node_count = function() {\n return this.eachAfter(count);\n};\n\nvar node_each = function(callback) {\n var node = this, current, next = [node], children, i, n;\n do {\n current = next.reverse(), next = [];\n while (node = current.pop()) {\n callback(node), children = node.children;\n if (children) for (i = 0, n = children.length; i < n; ++i) {\n next.push(children[i]);\n }\n }\n } while (next.length);\n return this;\n};\n\nvar node_eachBefore = function(callback) {\n var node = this, nodes = [node], children, i;\n while (node = nodes.pop()) {\n callback(node), children = node.children;\n if (children) for (i = children.length - 1; i >= 0; --i) {\n nodes.push(children[i]);\n }\n }\n return this;\n};\n\nvar node_eachAfter = function(callback) {\n var node = this, nodes = [node], next = [], children, i, n;\n while (node = nodes.pop()) {\n next.push(node), children = node.children;\n if (children) for (i = 0, n = children.length; i < n; ++i) {\n nodes.push(children[i]);\n }\n }\n while (node = next.pop()) {\n callback(node);\n }\n return this;\n};\n\nvar node_sum = function(value) {\n return this.eachAfter(function(node) {\n var sum = +value(node.data) || 0,\n children = node.children,\n i = children && children.length;\n while (--i >= 0) sum += children[i].value;\n node.value = sum;\n });\n};\n\nvar node_sort = function(compare) {\n return this.eachBefore(function(node) {\n if (node.children) {\n node.children.sort(compare);\n }\n });\n};\n\nvar node_path = function(end) {\n var start = this,\n ancestor = leastCommonAncestor(start, end),\n nodes = [start];\n while (start !== ancestor) {\n start = start.parent;\n nodes.push(start);\n }\n var k = nodes.length;\n while (end !== ancestor) {\n nodes.splice(k, 0, end);\n end = end.parent;\n }\n return nodes;\n};\n\nfunction leastCommonAncestor(a, b) {\n if (a === b) return a;\n var aNodes = a.ancestors(),\n bNodes = b.ancestors(),\n c = null;\n a = aNodes.pop();\n b = bNodes.pop();\n while (a === b) {\n c = a;\n a = aNodes.pop();\n b = bNodes.pop();\n }\n return c;\n}\n\nvar node_ancestors = function() {\n var node = this, nodes = [node];\n while (node = node.parent) {\n nodes.push(node);\n }\n return nodes;\n};\n\nvar node_descendants = function() {\n var nodes = [];\n this.each(function(node) {\n nodes.push(node);\n });\n return nodes;\n};\n\nvar node_leaves = function() {\n var leaves = [];\n this.eachBefore(function(node) {\n if (!node.children) {\n leaves.push(node);\n }\n });\n return leaves;\n};\n\nvar node_links = function() {\n var root = this, links = [];\n root.each(function(node) {\n if (node !== root) { // Don’t include the root’s parent, if any.\n links.push({source: node.parent, target: node});\n }\n });\n return links;\n};\n\nfunction hierarchy(data, children) {\n var root = new Node(data),\n valued = +data.value && (root.value = data.value),\n node,\n nodes = [root],\n child,\n childs,\n i,\n n;\n\n if (children == null) children = defaultChildren;\n\n while (node = nodes.pop()) {\n if (valued) node.value = +node.data.value;\n if ((childs = children(node.data)) && (n = childs.length)) {\n node.children = new Array(n);\n for (i = n - 1; i >= 0; --i) {\n nodes.push(child = node.children[i] = new Node(childs[i]));\n child.parent = node;\n child.depth = node.depth + 1;\n }\n }\n }\n\n return root.eachBefore(computeHeight);\n}\n\nfunction node_copy() {\n return hierarchy(this).eachBefore(copyData);\n}\n\nfunction defaultChildren(d) {\n return d.children;\n}\n\nfunction copyData(node) {\n node.data = node.data.data;\n}\n\nfunction computeHeight(node) {\n var height = 0;\n do node.height = height;\n while ((node = node.parent) && (node.height < ++height));\n}\n\nfunction Node(data) {\n this.data = data;\n this.depth =\n this.height = 0;\n this.parent = null;\n}\n\nNode.prototype = hierarchy.prototype = {\n constructor: Node,\n count: node_count,\n each: node_each,\n eachAfter: node_eachAfter,\n eachBefore: node_eachBefore,\n sum: node_sum,\n sort: node_sort,\n path: node_path,\n ancestors: node_ancestors,\n descendants: node_descendants,\n leaves: node_leaves,\n links: node_links,\n copy: node_copy\n};\n\nfunction Node$2(value) {\n this._ = value;\n this.next = null;\n}\n\nvar shuffle$1 = function(array) {\n var i,\n n = (array = array.slice()).length,\n head = null,\n node = head;\n\n while (n) {\n var next = new Node$2(array[n - 1]);\n if (node) node = node.next = next;\n else node = head = next;\n array[i] = array[--n];\n }\n\n return {\n head: head,\n tail: node\n };\n};\n\nvar enclose = function(circles) {\n return encloseN(shuffle$1(circles), []);\n};\n\nfunction encloses(a, b) {\n var dx = b.x - a.x,\n dy = b.y - a.y,\n dr = a.r - b.r;\n return dr * dr + 1e-6 > dx * dx + dy * dy;\n}\n\n// Returns the smallest circle that contains circles L and intersects circles B.\nfunction encloseN(L, B) {\n var circle,\n l0 = null,\n l1 = L.head,\n l2,\n p1;\n\n switch (B.length) {\n case 1: circle = enclose1(B[0]); break;\n case 2: circle = enclose2(B[0], B[1]); break;\n case 3: circle = enclose3(B[0], B[1], B[2]); break;\n }\n\n while (l1) {\n p1 = l1._, l2 = l1.next;\n if (!circle || !encloses(circle, p1)) {\n\n // Temporarily truncate L before l1.\n if (l0) L.tail = l0, l0.next = null;\n else L.head = L.tail = null;\n\n B.push(p1);\n circle = encloseN(L, B); // Note: reorders L!\n B.pop();\n\n // Move l1 to the front of L and reconnect the truncated list L.\n if (L.head) l1.next = L.head, L.head = l1;\n else l1.next = null, L.head = L.tail = l1;\n l0 = L.tail, l0.next = l2;\n\n } else {\n l0 = l1;\n }\n l1 = l2;\n }\n\n L.tail = l0;\n return circle;\n}\n\nfunction enclose1(a) {\n return {\n x: a.x,\n y: a.y,\n r: a.r\n };\n}\n\nfunction enclose2(a, b) {\n var x1 = a.x, y1 = a.y, r1 = a.r,\n x2 = b.x, y2 = b.y, r2 = b.r,\n x21 = x2 - x1, y21 = y2 - y1, r21 = r2 - r1,\n l = Math.sqrt(x21 * x21 + y21 * y21);\n return {\n x: (x1 + x2 + x21 / l * r21) / 2,\n y: (y1 + y2 + y21 / l * r21) / 2,\n r: (l + r1 + r2) / 2\n };\n}\n\nfunction enclose3(a, b, c) {\n var x1 = a.x, y1 = a.y, r1 = a.r,\n x2 = b.x, y2 = b.y, r2 = b.r,\n x3 = c.x, y3 = c.y, r3 = c.r,\n a2 = 2 * (x1 - x2),\n b2 = 2 * (y1 - y2),\n c2 = 2 * (r2 - r1),\n d2 = x1 * x1 + y1 * y1 - r1 * r1 - x2 * x2 - y2 * y2 + r2 * r2,\n a3 = 2 * (x1 - x3),\n b3 = 2 * (y1 - y3),\n c3 = 2 * (r3 - r1),\n d3 = x1 * x1 + y1 * y1 - r1 * r1 - x3 * x3 - y3 * y3 + r3 * r3,\n ab = a3 * b2 - a2 * b3,\n xa = (b2 * d3 - b3 * d2) / ab - x1,\n xb = (b3 * c2 - b2 * c3) / ab,\n ya = (a3 * d2 - a2 * d3) / ab - y1,\n yb = (a2 * c3 - a3 * c2) / ab,\n A = xb * xb + yb * yb - 1,\n B = 2 * (xa * xb + ya * yb + r1),\n C = xa * xa + ya * ya - r1 * r1,\n r = (-B - Math.sqrt(B * B - 4 * A * C)) / (2 * A);\n return {\n x: xa + xb * r + x1,\n y: ya + yb * r + y1,\n r: r\n };\n}\n\nfunction place(a, b, c) {\n var ax = a.x,\n ay = a.y,\n da = b.r + c.r,\n db = a.r + c.r,\n dx = b.x - ax,\n dy = b.y - ay,\n dc = dx * dx + dy * dy;\n if (dc) {\n var x = 0.5 + ((db *= db) - (da *= da)) / (2 * dc),\n y = Math.sqrt(Math.max(0, 2 * da * (db + dc) - (db -= dc) * db - da * da)) / (2 * dc);\n c.x = ax + x * dx + y * dy;\n c.y = ay + x * dy - y * dx;\n } else {\n c.x = ax + db;\n c.y = ay;\n }\n}\n\nfunction intersects(a, b) {\n var dx = b.x - a.x,\n dy = b.y - a.y,\n dr = a.r + b.r;\n return dr * dr - 1e-6 > dx * dx + dy * dy;\n}\n\nfunction distance1(a, b) {\n var l = a._.r;\n while (a !== b) l += 2 * (a = a.next)._.r;\n return l - b._.r;\n}\n\nfunction distance2(node, x, y) {\n var a = node._,\n b = node.next._,\n ab = a.r + b.r,\n dx = (a.x * b.r + b.x * a.r) / ab - x,\n dy = (a.y * b.r + b.y * a.r) / ab - y;\n return dx * dx + dy * dy;\n}\n\nfunction Node$1(circle) {\n this._ = circle;\n this.next = null;\n this.previous = null;\n}\n\nfunction packEnclose(circles) {\n if (!(n = circles.length)) return 0;\n\n var a, b, c, n;\n\n // Place the first circle.\n a = circles[0], a.x = 0, a.y = 0;\n if (!(n > 1)) return a.r;\n\n // Place the second circle.\n b = circles[1], a.x = -b.r, b.x = a.r, b.y = 0;\n if (!(n > 2)) return a.r + b.r;\n\n // Place the third circle.\n place(b, a, c = circles[2]);\n\n // Initialize the weighted centroid.\n var aa = a.r * a.r,\n ba = b.r * b.r,\n ca = c.r * c.r,\n oa = aa + ba + ca,\n ox = aa * a.x + ba * b.x + ca * c.x,\n oy = aa * a.y + ba * b.y + ca * c.y,\n cx, cy, i, j, k, sj, sk;\n\n // Initialize the front-chain using the first three circles a, b and c.\n a = new Node$1(a), b = new Node$1(b), c = new Node$1(c);\n a.next = c.previous = b;\n b.next = a.previous = c;\n c.next = b.previous = a;\n\n // Attempt to place each remaining circle…\n pack: for (i = 3; i < n; ++i) {\n place(a._, b._, c = circles[i]), c = new Node$1(c);\n\n // Find the closest intersecting circle on the front-chain, if any.\n // “Closeness” is determined by linear distance along the front-chain.\n // “Ahead” or “behind” is likewise determined by linear distance.\n j = b.next, k = a.previous, sj = b._.r, sk = a._.r;\n do {\n if (sj <= sk) {\n if (intersects(j._, c._)) {\n if (sj + a._.r + b._.r > distance1(j, b)) a = j; else b = j;\n a.next = b, b.previous = a, --i;\n continue pack;\n }\n sj += j._.r, j = j.next;\n } else {\n if (intersects(k._, c._)) {\n if (distance1(a, k) > sk + a._.r + b._.r) a = k; else b = k;\n a.next = b, b.previous = a, --i;\n continue pack;\n }\n sk += k._.r, k = k.previous;\n }\n } while (j !== k.next);\n\n // Success! Insert the new circle c between a and b.\n c.previous = a, c.next = b, a.next = b.previous = b = c;\n\n // Update the weighted centroid.\n oa += ca = c._.r * c._.r;\n ox += ca * c._.x;\n oy += ca * c._.y;\n\n // Compute the new closest circle pair to the centroid.\n aa = distance2(a, cx = ox / oa, cy = oy / oa);\n while ((c = c.next) !== b) {\n if ((ca = distance2(c, cx, cy)) < aa) {\n a = c, aa = ca;\n }\n }\n b = a.next;\n }\n\n // Compute the enclosing circle of the front chain.\n a = [b._], c = b; while ((c = c.next) !== b) a.push(c._); c = enclose(a);\n\n // Translate the circles to put the enclosing circle around the origin.\n for (i = 0; i < n; ++i) a = circles[i], a.x -= c.x, a.y -= c.y;\n\n return c.r;\n}\n\nvar siblings = function(circles) {\n packEnclose(circles);\n return circles;\n};\n\nfunction optional(f) {\n return f == null ? null : required(f);\n}\n\nfunction required(f) {\n if (typeof f !== \"function\") throw new Error;\n return f;\n}\n\nfunction constantZero() {\n return 0;\n}\n\nvar constant$8 = function(x) {\n return function() {\n return x;\n };\n};\n\nfunction defaultRadius$1(d) {\n return Math.sqrt(d.value);\n}\n\nvar index$2 = function() {\n var radius = null,\n dx = 1,\n dy = 1,\n padding = constantZero;\n\n function pack(root) {\n root.x = dx / 2, root.y = dy / 2;\n if (radius) {\n root.eachBefore(radiusLeaf(radius))\n .eachAfter(packChildren(padding, 0.5))\n .eachBefore(translateChild(1));\n } else {\n root.eachBefore(radiusLeaf(defaultRadius$1))\n .eachAfter(packChildren(constantZero, 1))\n .eachAfter(packChildren(padding, root.r / Math.min(dx, dy)))\n .eachBefore(translateChild(Math.min(dx, dy) / (2 * root.r)));\n }\n return root;\n }\n\n pack.radius = function(x) {\n return arguments.length ? (radius = optional(x), pack) : radius;\n };\n\n pack.size = function(x) {\n return arguments.length ? (dx = +x[0], dy = +x[1], pack) : [dx, dy];\n };\n\n pack.padding = function(x) {\n return arguments.length ? (padding = typeof x === \"function\" ? x : constant$8(+x), pack) : padding;\n };\n\n return pack;\n};\n\nfunction radiusLeaf(radius) {\n return function(node) {\n if (!node.children) {\n node.r = Math.max(0, +radius(node) || 0);\n }\n };\n}\n\nfunction packChildren(padding, k) {\n return function(node) {\n if (children = node.children) {\n var children,\n i,\n n = children.length,\n r = padding(node) * k || 0,\n e;\n\n if (r) for (i = 0; i < n; ++i) children[i].r += r;\n e = packEnclose(children);\n if (r) for (i = 0; i < n; ++i) children[i].r -= r;\n node.r = e + r;\n }\n };\n}\n\nfunction translateChild(k) {\n return function(node) {\n var parent = node.parent;\n node.r *= k;\n if (parent) {\n node.x = parent.x + k * node.x;\n node.y = parent.y + k * node.y;\n }\n };\n}\n\nvar roundNode = function(node) {\n node.x0 = Math.round(node.x0);\n node.y0 = Math.round(node.y0);\n node.x1 = Math.round(node.x1);\n node.y1 = Math.round(node.y1);\n};\n\nvar treemapDice = function(parent, x0, y0, x1, y1) {\n var nodes = parent.children,\n node,\n i = -1,\n n = nodes.length,\n k = parent.value && (x1 - x0) / parent.value;\n\n while (++i < n) {\n node = nodes[i], node.y0 = y0, node.y1 = y1;\n node.x0 = x0, node.x1 = x0 += node.value * k;\n }\n};\n\nvar partition = function() {\n var dx = 1,\n dy = 1,\n padding = 0,\n round = false;\n\n function partition(root) {\n var n = root.height + 1;\n root.x0 =\n root.y0 = padding;\n root.x1 = dx;\n root.y1 = dy / n;\n root.eachBefore(positionNode(dy, n));\n if (round) root.eachBefore(roundNode);\n return root;\n }\n\n function positionNode(dy, n) {\n return function(node) {\n if (node.children) {\n treemapDice(node, node.x0, dy * (node.depth + 1) / n, node.x1, dy * (node.depth + 2) / n);\n }\n var x0 = node.x0,\n y0 = node.y0,\n x1 = node.x1 - padding,\n y1 = node.y1 - padding;\n if (x1 < x0) x0 = x1 = (x0 + x1) / 2;\n if (y1 < y0) y0 = y1 = (y0 + y1) / 2;\n node.x0 = x0;\n node.y0 = y0;\n node.x1 = x1;\n node.y1 = y1;\n };\n }\n\n partition.round = function(x) {\n return arguments.length ? (round = !!x, partition) : round;\n };\n\n partition.size = function(x) {\n return arguments.length ? (dx = +x[0], dy = +x[1], partition) : [dx, dy];\n };\n\n partition.padding = function(x) {\n return arguments.length ? (padding = +x, partition) : padding;\n };\n\n return partition;\n};\n\nvar keyPrefix$1 = \"$\";\nvar preroot = {depth: -1};\nvar ambiguous = {};\n\nfunction defaultId(d) {\n return d.id;\n}\n\nfunction defaultParentId(d) {\n return d.parentId;\n}\n\nvar stratify = function() {\n var id = defaultId,\n parentId = defaultParentId;\n\n function stratify(data) {\n var d,\n i,\n n = data.length,\n root,\n parent,\n node,\n nodes = new Array(n),\n nodeId,\n nodeKey,\n nodeByKey = {};\n\n for (i = 0; i < n; ++i) {\n d = data[i], node = nodes[i] = new Node(d);\n if ((nodeId = id(d, i, data)) != null && (nodeId += \"\")) {\n nodeKey = keyPrefix$1 + (node.id = nodeId);\n nodeByKey[nodeKey] = nodeKey in nodeByKey ? ambiguous : node;\n }\n }\n\n for (i = 0; i < n; ++i) {\n node = nodes[i], nodeId = parentId(data[i], i, data);\n if (nodeId == null || !(nodeId += \"\")) {\n if (root) throw new Error(\"multiple roots\");\n root = node;\n } else {\n parent = nodeByKey[keyPrefix$1 + nodeId];\n if (!parent) throw new Error(\"missing: \" + nodeId);\n if (parent === ambiguous) throw new Error(\"ambiguous: \" + nodeId);\n if (parent.children) parent.children.push(node);\n else parent.children = [node];\n node.parent = parent;\n }\n }\n\n if (!root) throw new Error(\"no root\");\n root.parent = preroot;\n root.eachBefore(function(node) { node.depth = node.parent.depth + 1; --n; }).eachBefore(computeHeight);\n root.parent = null;\n if (n > 0) throw new Error(\"cycle\");\n\n return root;\n }\n\n stratify.id = function(x) {\n return arguments.length ? (id = required(x), stratify) : id;\n };\n\n stratify.parentId = function(x) {\n return arguments.length ? (parentId = required(x), stratify) : parentId;\n };\n\n return stratify;\n};\n\nfunction defaultSeparation$1(a, b) {\n return a.parent === b.parent ? 1 : 2;\n}\n\n// function radialSeparation(a, b) {\n// return (a.parent === b.parent ? 1 : 2) / a.depth;\n// }\n\n// This function is used to traverse the left contour of a subtree (or\n// subforest). It returns the successor of v on this contour. This successor is\n// either given by the leftmost child of v or by the thread of v. The function\n// returns null if and only if v is on the highest level of its subtree.\nfunction nextLeft(v) {\n var children = v.children;\n return children ? children[0] : v.t;\n}\n\n// This function works analogously to nextLeft.\nfunction nextRight(v) {\n var children = v.children;\n return children ? children[children.length - 1] : v.t;\n}\n\n// Shifts the current subtree rooted at w+. This is done by increasing\n// prelim(w+) and mod(w+) by shift.\nfunction moveSubtree(wm, wp, shift) {\n var change = shift / (wp.i - wm.i);\n wp.c -= change;\n wp.s += shift;\n wm.c += change;\n wp.z += shift;\n wp.m += shift;\n}\n\n// All other shifts, applied to the smaller subtrees between w- and w+, are\n// performed by this function. To prepare the shifts, we have to adjust\n// change(w+), shift(w+), and change(w-).\nfunction executeShifts(v) {\n var shift = 0,\n change = 0,\n children = v.children,\n i = children.length,\n w;\n while (--i >= 0) {\n w = children[i];\n w.z += shift;\n w.m += shift;\n shift += w.s + (change += w.c);\n }\n}\n\n// If vi-’s ancestor is a sibling of v, returns vi-’s ancestor. Otherwise,\n// returns the specified (default) ancestor.\nfunction nextAncestor(vim, v, ancestor) {\n return vim.a.parent === v.parent ? vim.a : ancestor;\n}\n\nfunction TreeNode(node, i) {\n this._ = node;\n this.parent = null;\n this.children = null;\n this.A = null; // default ancestor\n this.a = this; // ancestor\n this.z = 0; // prelim\n this.m = 0; // mod\n this.c = 0; // change\n this.s = 0; // shift\n this.t = null; // thread\n this.i = i; // number\n}\n\nTreeNode.prototype = Object.create(Node.prototype);\n\nfunction treeRoot(root) {\n var tree = new TreeNode(root, 0),\n node,\n nodes = [tree],\n child,\n children,\n i,\n n;\n\n while (node = nodes.pop()) {\n if (children = node._.children) {\n node.children = new Array(n = children.length);\n for (i = n - 1; i >= 0; --i) {\n nodes.push(child = node.children[i] = new TreeNode(children[i], i));\n child.parent = node;\n }\n }\n }\n\n (tree.parent = new TreeNode(null, 0)).children = [tree];\n return tree;\n}\n\n// Node-link tree diagram using the Reingold-Tilford \"tidy\" algorithm\nvar tree = function() {\n var separation = defaultSeparation$1,\n dx = 1,\n dy = 1,\n nodeSize = null;\n\n function tree(root) {\n var t = treeRoot(root);\n\n // Compute the layout using Buchheim et al.’s algorithm.\n t.eachAfter(firstWalk), t.parent.m = -t.z;\n t.eachBefore(secondWalk);\n\n // If a fixed node size is specified, scale x and y.\n if (nodeSize) root.eachBefore(sizeNode);\n\n // If a fixed tree size is specified, scale x and y based on the extent.\n // Compute the left-most, right-most, and depth-most nodes for extents.\n else {\n var left = root,\n right = root,\n bottom = root;\n root.eachBefore(function(node) {\n if (node.x < left.x) left = node;\n if (node.x > right.x) right = node;\n if (node.depth > bottom.depth) bottom = node;\n });\n var s = left === right ? 1 : separation(left, right) / 2,\n tx = s - left.x,\n kx = dx / (right.x + s + tx),\n ky = dy / (bottom.depth || 1);\n root.eachBefore(function(node) {\n node.x = (node.x + tx) * kx;\n node.y = node.depth * ky;\n });\n }\n\n return root;\n }\n\n // Computes a preliminary x-coordinate for v. Before that, FIRST WALK is\n // applied recursively to the children of v, as well as the function\n // APPORTION. After spacing out the children by calling EXECUTE SHIFTS, the\n // node v is placed to the midpoint of its outermost children.\n function firstWalk(v) {\n var children = v.children,\n siblings = v.parent.children,\n w = v.i ? siblings[v.i - 1] : null;\n if (children) {\n executeShifts(v);\n var midpoint = (children[0].z + children[children.length - 1].z) / 2;\n if (w) {\n v.z = w.z + separation(v._, w._);\n v.m = v.z - midpoint;\n } else {\n v.z = midpoint;\n }\n } else if (w) {\n v.z = w.z + separation(v._, w._);\n }\n v.parent.A = apportion(v, w, v.parent.A || siblings[0]);\n }\n\n // Computes all real x-coordinates by summing up the modifiers recursively.\n function secondWalk(v) {\n v._.x = v.z + v.parent.m;\n v.m += v.parent.m;\n }\n\n // The core of the algorithm. Here, a new subtree is combined with the\n // previous subtrees. Threads are used to traverse the inside and outside\n // contours of the left and right subtree up to the highest common level. The\n // vertices used for the traversals are vi+, vi-, vo-, and vo+, where the\n // superscript o means outside and i means inside, the subscript - means left\n // subtree and + means right subtree. For summing up the modifiers along the\n // contour, we use respective variables si+, si-, so-, and so+. Whenever two\n // nodes of the inside contours conflict, we compute the left one of the\n // greatest uncommon ancestors using the function ANCESTOR and call MOVE\n // SUBTREE to shift the subtree and prepare the shifts of smaller subtrees.\n // Finally, we add a new thread (if necessary).\n function apportion(v, w, ancestor) {\n if (w) {\n var vip = v,\n vop = v,\n vim = w,\n vom = vip.parent.children[0],\n sip = vip.m,\n sop = vop.m,\n sim = vim.m,\n som = vom.m,\n shift;\n while (vim = nextRight(vim), vip = nextLeft(vip), vim && vip) {\n vom = nextLeft(vom);\n vop = nextRight(vop);\n vop.a = v;\n shift = vim.z + sim - vip.z - sip + separation(vim._, vip._);\n if (shift > 0) {\n moveSubtree(nextAncestor(vim, v, ancestor), v, shift);\n sip += shift;\n sop += shift;\n }\n sim += vim.m;\n sip += vip.m;\n som += vom.m;\n sop += vop.m;\n }\n if (vim && !nextRight(vop)) {\n vop.t = vim;\n vop.m += sim - sop;\n }\n if (vip && !nextLeft(vom)) {\n vom.t = vip;\n vom.m += sip - som;\n ancestor = v;\n }\n }\n return ancestor;\n }\n\n function sizeNode(node) {\n node.x *= dx;\n node.y = node.depth * dy;\n }\n\n tree.separation = function(x) {\n return arguments.length ? (separation = x, tree) : separation;\n };\n\n tree.size = function(x) {\n return arguments.length ? (nodeSize = false, dx = +x[0], dy = +x[1], tree) : (nodeSize ? null : [dx, dy]);\n };\n\n tree.nodeSize = function(x) {\n return arguments.length ? (nodeSize = true, dx = +x[0], dy = +x[1], tree) : (nodeSize ? [dx, dy] : null);\n };\n\n return tree;\n};\n\nvar treemapSlice = function(parent, x0, y0, x1, y1) {\n var nodes = parent.children,\n node,\n i = -1,\n n = nodes.length,\n k = parent.value && (y1 - y0) / parent.value;\n\n while (++i < n) {\n node = nodes[i], node.x0 = x0, node.x1 = x1;\n node.y0 = y0, node.y1 = y0 += node.value * k;\n }\n};\n\nvar phi = (1 + Math.sqrt(5)) / 2;\n\nfunction squarifyRatio(ratio, parent, x0, y0, x1, y1) {\n var rows = [],\n nodes = parent.children,\n row,\n nodeValue,\n i0 = 0,\n i1 = 0,\n n = nodes.length,\n dx, dy,\n value = parent.value,\n sumValue,\n minValue,\n maxValue,\n newRatio,\n minRatio,\n alpha,\n beta;\n\n while (i0 < n) {\n dx = x1 - x0, dy = y1 - y0;\n\n // Find the next non-empty node.\n do sumValue = nodes[i1++].value; while (!sumValue && i1 < n);\n minValue = maxValue = sumValue;\n alpha = Math.max(dy / dx, dx / dy) / (value * ratio);\n beta = sumValue * sumValue * alpha;\n minRatio = Math.max(maxValue / beta, beta / minValue);\n\n // Keep adding nodes while the aspect ratio maintains or improves.\n for (; i1 < n; ++i1) {\n sumValue += nodeValue = nodes[i1].value;\n if (nodeValue < minValue) minValue = nodeValue;\n if (nodeValue > maxValue) maxValue = nodeValue;\n beta = sumValue * sumValue * alpha;\n newRatio = Math.max(maxValue / beta, beta / minValue);\n if (newRatio > minRatio) { sumValue -= nodeValue; break; }\n minRatio = newRatio;\n }\n\n // Position and record the row orientation.\n rows.push(row = {value: sumValue, dice: dx < dy, children: nodes.slice(i0, i1)});\n if (row.dice) treemapDice(row, x0, y0, x1, value ? y0 += dy * sumValue / value : y1);\n else treemapSlice(row, x0, y0, value ? x0 += dx * sumValue / value : x1, y1);\n value -= sumValue, i0 = i1;\n }\n\n return rows;\n}\n\nvar squarify = ((function custom(ratio) {\n\n function squarify(parent, x0, y0, x1, y1) {\n squarifyRatio(ratio, parent, x0, y0, x1, y1);\n }\n\n squarify.ratio = function(x) {\n return custom((x = +x) > 1 ? x : 1);\n };\n\n return squarify;\n}))(phi);\n\nvar index$3 = function() {\n var tile = squarify,\n round = false,\n dx = 1,\n dy = 1,\n paddingStack = [0],\n paddingInner = constantZero,\n paddingTop = constantZero,\n paddingRight = constantZero,\n paddingBottom = constantZero,\n paddingLeft = constantZero;\n\n function treemap(root) {\n root.x0 =\n root.y0 = 0;\n root.x1 = dx;\n root.y1 = dy;\n root.eachBefore(positionNode);\n paddingStack = [0];\n if (round) root.eachBefore(roundNode);\n return root;\n }\n\n function positionNode(node) {\n var p = paddingStack[node.depth],\n x0 = node.x0 + p,\n y0 = node.y0 + p,\n x1 = node.x1 - p,\n y1 = node.y1 - p;\n if (x1 < x0) x0 = x1 = (x0 + x1) / 2;\n if (y1 < y0) y0 = y1 = (y0 + y1) / 2;\n node.x0 = x0;\n node.y0 = y0;\n node.x1 = x1;\n node.y1 = y1;\n if (node.children) {\n p = paddingStack[node.depth + 1] = paddingInner(node) / 2;\n x0 += paddingLeft(node) - p;\n y0 += paddingTop(node) - p;\n x1 -= paddingRight(node) - p;\n y1 -= paddingBottom(node) - p;\n if (x1 < x0) x0 = x1 = (x0 + x1) / 2;\n if (y1 < y0) y0 = y1 = (y0 + y1) / 2;\n tile(node, x0, y0, x1, y1);\n }\n }\n\n treemap.round = function(x) {\n return arguments.length ? (round = !!x, treemap) : round;\n };\n\n treemap.size = function(x) {\n return arguments.length ? (dx = +x[0], dy = +x[1], treemap) : [dx, dy];\n };\n\n treemap.tile = function(x) {\n return arguments.length ? (tile = required(x), treemap) : tile;\n };\n\n treemap.padding = function(x) {\n return arguments.length ? treemap.paddingInner(x).paddingOuter(x) : treemap.paddingInner();\n };\n\n treemap.paddingInner = function(x) {\n return arguments.length ? (paddingInner = typeof x === \"function\" ? x : constant$8(+x), treemap) : paddingInner;\n };\n\n treemap.paddingOuter = function(x) {\n return arguments.length ? treemap.paddingTop(x).paddingRight(x).paddingBottom(x).paddingLeft(x) : treemap.paddingTop();\n };\n\n treemap.paddingTop = function(x) {\n return arguments.length ? (paddingTop = typeof x === \"function\" ? x : constant$8(+x), treemap) : paddingTop;\n };\n\n treemap.paddingRight = function(x) {\n return arguments.length ? (paddingRight = typeof x === \"function\" ? x : constant$8(+x), treemap) : paddingRight;\n };\n\n treemap.paddingBottom = function(x) {\n return arguments.length ? (paddingBottom = typeof x === \"function\" ? x : constant$8(+x), treemap) : paddingBottom;\n };\n\n treemap.paddingLeft = function(x) {\n return arguments.length ? (paddingLeft = typeof x === \"function\" ? x : constant$8(+x), treemap) : paddingLeft;\n };\n\n return treemap;\n};\n\nvar binary = function(parent, x0, y0, x1, y1) {\n var nodes = parent.children,\n i, n = nodes.length,\n sum, sums = new Array(n + 1);\n\n for (sums[0] = sum = i = 0; i < n; ++i) {\n sums[i + 1] = sum += nodes[i].value;\n }\n\n partition(0, n, parent.value, x0, y0, x1, y1);\n\n function partition(i, j, value, x0, y0, x1, y1) {\n if (i >= j - 1) {\n var node = nodes[i];\n node.x0 = x0, node.y0 = y0;\n node.x1 = x1, node.y1 = y1;\n return;\n }\n\n var valueOffset = sums[i],\n valueTarget = (value / 2) + valueOffset,\n k = i + 1,\n hi = j - 1;\n\n while (k < hi) {\n var mid = k + hi >>> 1;\n if (sums[mid] < valueTarget) k = mid + 1;\n else hi = mid;\n }\n\n var valueLeft = sums[k] - valueOffset,\n valueRight = value - valueLeft;\n\n if ((y1 - y0) > (x1 - x0)) {\n var yk = (y0 * valueRight + y1 * valueLeft) / value;\n partition(i, k, valueLeft, x0, y0, x1, yk);\n partition(k, j, valueRight, x0, yk, x1, y1);\n } else {\n var xk = (x0 * valueRight + x1 * valueLeft) / value;\n partition(i, k, valueLeft, x0, y0, xk, y1);\n partition(k, j, valueRight, xk, y0, x1, y1);\n }\n }\n};\n\nvar sliceDice = function(parent, x0, y0, x1, y1) {\n (parent.depth & 1 ? treemapSlice : treemapDice)(parent, x0, y0, x1, y1);\n};\n\nvar resquarify = ((function custom(ratio) {\n\n function resquarify(parent, x0, y0, x1, y1) {\n if ((rows = parent._squarify) && (rows.ratio === ratio)) {\n var rows,\n row,\n nodes,\n i,\n j = -1,\n n,\n m = rows.length,\n value = parent.value;\n\n while (++j < m) {\n row = rows[j], nodes = row.children;\n for (i = row.value = 0, n = nodes.length; i < n; ++i) row.value += nodes[i].value;\n if (row.dice) treemapDice(row, x0, y0, x1, y0 += (y1 - y0) * row.value / value);\n else treemapSlice(row, x0, y0, x0 += (x1 - x0) * row.value / value, y1);\n value -= row.value;\n }\n } else {\n parent._squarify = rows = squarifyRatio(ratio, parent, x0, y0, x1, y1);\n rows.ratio = ratio;\n }\n }\n\n resquarify.ratio = function(x) {\n return custom((x = +x) > 1 ? x : 1);\n };\n\n return resquarify;\n}))(phi);\n\nvar area$1 = function(polygon) {\n var i = -1,\n n = polygon.length,\n a,\n b = polygon[n - 1],\n area = 0;\n\n while (++i < n) {\n a = b;\n b = polygon[i];\n area += a[1] * b[0] - a[0] * b[1];\n }\n\n return area / 2;\n};\n\nvar centroid$1 = function(polygon) {\n var i = -1,\n n = polygon.length,\n x = 0,\n y = 0,\n a,\n b = polygon[n - 1],\n c,\n k = 0;\n\n while (++i < n) {\n a = b;\n b = polygon[i];\n k += c = a[0] * b[1] - b[0] * a[1];\n x += (a[0] + b[0]) * c;\n y += (a[1] + b[1]) * c;\n }\n\n return k *= 3, [x / k, y / k];\n};\n\n// Returns the 2D cross product of AB and AC vectors, i.e., the z-component of\n// the 3D cross product in a quadrant I Cartesian coordinate system (+x is\n// right, +y is up). Returns a positive value if ABC is counter-clockwise,\n// negative if clockwise, and zero if the points are collinear.\nvar cross = function(a, b, c) {\n return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);\n};\n\nfunction lexicographicOrder(a, b) {\n return a[0] - b[0] || a[1] - b[1];\n}\n\n// Computes the upper convex hull per the monotone chain algorithm.\n// Assumes points.length >= 3, is sorted by x, unique in y.\n// Returns an array of indices into points in left-to-right order.\nfunction computeUpperHullIndexes(points) {\n var n = points.length,\n indexes = [0, 1],\n size = 2;\n\n for (var i = 2; i < n; ++i) {\n while (size > 1 && cross(points[indexes[size - 2]], points[indexes[size - 1]], points[i]) <= 0) --size;\n indexes[size++] = i;\n }\n\n return indexes.slice(0, size); // remove popped points\n}\n\nvar hull = function(points) {\n if ((n = points.length) < 3) return null;\n\n var i,\n n,\n sortedPoints = new Array(n),\n flippedPoints = new Array(n);\n\n for (i = 0; i < n; ++i) sortedPoints[i] = [+points[i][0], +points[i][1], i];\n sortedPoints.sort(lexicographicOrder);\n for (i = 0; i < n; ++i) flippedPoints[i] = [sortedPoints[i][0], -sortedPoints[i][1]];\n\n var upperIndexes = computeUpperHullIndexes(sortedPoints),\n lowerIndexes = computeUpperHullIndexes(flippedPoints);\n\n // Construct the hull polygon, removing possible duplicate endpoints.\n var skipLeft = lowerIndexes[0] === upperIndexes[0],\n skipRight = lowerIndexes[lowerIndexes.length - 1] === upperIndexes[upperIndexes.length - 1],\n hull = [];\n\n // Add upper hull in right-to-l order.\n // Then add lower hull in left-to-right order.\n for (i = upperIndexes.length - 1; i >= 0; --i) hull.push(points[sortedPoints[upperIndexes[i]][2]]);\n for (i = +skipLeft; i < lowerIndexes.length - skipRight; ++i) hull.push(points[sortedPoints[lowerIndexes[i]][2]]);\n\n return hull;\n};\n\nvar contains = function(polygon, point) {\n var n = polygon.length,\n p = polygon[n - 1],\n x = point[0], y = point[1],\n x0 = p[0], y0 = p[1],\n x1, y1,\n inside = false;\n\n for (var i = 0; i < n; ++i) {\n p = polygon[i], x1 = p[0], y1 = p[1];\n if (((y1 > y) !== (y0 > y)) && (x < (x0 - x1) * (y - y1) / (y0 - y1) + x1)) inside = !inside;\n x0 = x1, y0 = y1;\n }\n\n return inside;\n};\n\nvar length$2 = function(polygon) {\n var i = -1,\n n = polygon.length,\n b = polygon[n - 1],\n xa,\n ya,\n xb = b[0],\n yb = b[1],\n perimeter = 0;\n\n while (++i < n) {\n xa = xb;\n ya = yb;\n b = polygon[i];\n xb = b[0];\n yb = b[1];\n xa -= xb;\n ya -= yb;\n perimeter += Math.sqrt(xa * xa + ya * ya);\n }\n\n return perimeter;\n};\n\nvar slice$3 = [].slice;\n\nvar noabort = {};\n\nfunction Queue(size) {\n if (!(size >= 1)) throw new Error;\n this._size = size;\n this._call =\n this._error = null;\n this._tasks = [];\n this._data = [];\n this._waiting =\n this._active =\n this._ended =\n this._start = 0; // inside a synchronous task callback?\n}\n\nQueue.prototype = queue.prototype = {\n constructor: Queue,\n defer: function(callback) {\n if (typeof callback !== \"function\" || this._call) throw new Error;\n if (this._error != null) return this;\n var t = slice$3.call(arguments, 1);\n t.push(callback);\n ++this._waiting, this._tasks.push(t);\n poke$1(this);\n return this;\n },\n abort: function() {\n if (this._error == null) abort(this, new Error(\"abort\"));\n return this;\n },\n await: function(callback) {\n if (typeof callback !== \"function\" || this._call) throw new Error;\n this._call = function(error, results) { callback.apply(null, [error].concat(results)); };\n maybeNotify(this);\n return this;\n },\n awaitAll: function(callback) {\n if (typeof callback !== \"function\" || this._call) throw new Error;\n this._call = callback;\n maybeNotify(this);\n return this;\n }\n};\n\nfunction poke$1(q) {\n if (!q._start) {\n try { start$1(q); } // let the current task complete\n catch (e) {\n if (q._tasks[q._ended + q._active - 1]) abort(q, e); // task errored synchronously\n else if (!q._data) throw e; // await callback errored synchronously\n }\n }\n}\n\nfunction start$1(q) {\n while (q._start = q._waiting && q._active < q._size) {\n var i = q._ended + q._active,\n t = q._tasks[i],\n j = t.length - 1,\n c = t[j];\n t[j] = end(q, i);\n --q._waiting, ++q._active;\n t = c.apply(null, t);\n if (!q._tasks[i]) continue; // task finished synchronously\n q._tasks[i] = t || noabort;\n }\n}\n\nfunction end(q, i) {\n return function(e, r) {\n if (!q._tasks[i]) return; // ignore multiple callbacks\n --q._active, ++q._ended;\n q._tasks[i] = null;\n if (q._error != null) return; // ignore secondary errors\n if (e != null) {\n abort(q, e);\n } else {\n q._data[i] = r;\n if (q._waiting) poke$1(q);\n else maybeNotify(q);\n }\n };\n}\n\nfunction abort(q, e) {\n var i = q._tasks.length, t;\n q._error = e; // ignore active callbacks\n q._data = undefined; // allow gc\n q._waiting = NaN; // prevent starting\n\n while (--i >= 0) {\n if (t = q._tasks[i]) {\n q._tasks[i] = null;\n if (t.abort) {\n try { t.abort(); }\n catch (e) { /* ignore */ }\n }\n }\n }\n\n q._active = NaN; // allow notification\n maybeNotify(q);\n}\n\nfunction maybeNotify(q) {\n if (!q._active && q._call) {\n var d = q._data;\n q._data = undefined; // allow gc\n q._call(q._error, d);\n }\n}\n\nfunction queue(concurrency) {\n return new Queue(arguments.length ? +concurrency : Infinity);\n}\n\nvar uniform = function(min, max) {\n min = min == null ? 0 : +min;\n max = max == null ? 1 : +max;\n if (arguments.length === 1) max = min, min = 0;\n else max -= min;\n return function() {\n return Math.random() * max + min;\n };\n};\n\nvar normal = function(mu, sigma) {\n var x, r;\n mu = mu == null ? 0 : +mu;\n sigma = sigma == null ? 1 : +sigma;\n return function() {\n var y;\n\n // If available, use the second previously-generated uniform random.\n if (x != null) y = x, x = null;\n\n // Otherwise, generate a new x and y.\n else do {\n x = Math.random() * 2 - 1;\n y = Math.random() * 2 - 1;\n r = x * x + y * y;\n } while (!r || r > 1);\n\n return mu + sigma * y * Math.sqrt(-2 * Math.log(r) / r);\n };\n};\n\nvar logNormal = function() {\n var randomNormal = normal.apply(this, arguments);\n return function() {\n return Math.exp(randomNormal());\n };\n};\n\nvar irwinHall = function(n) {\n return function() {\n for (var sum = 0, i = 0; i < n; ++i) sum += Math.random();\n return sum;\n };\n};\n\nvar bates = function(n) {\n var randomIrwinHall = irwinHall(n);\n return function() {\n return randomIrwinHall() / n;\n };\n};\n\nvar exponential$1 = function(lambda) {\n return function() {\n return -Math.log(1 - Math.random()) / lambda;\n };\n};\n\nvar request = function(url, callback) {\n var request,\n event = dispatch(\"beforesend\", \"progress\", \"load\", \"error\"),\n mimeType,\n headers = map$1(),\n xhr = new XMLHttpRequest,\n user = null,\n password = null,\n response,\n responseType,\n timeout = 0;\n\n // If IE does not support CORS, use XDomainRequest.\n if (typeof XDomainRequest !== \"undefined\"\n && !(\"withCredentials\" in xhr)\n && /^(http(s)?:)?\\/\\//.test(url)) xhr = new XDomainRequest;\n\n \"onload\" in xhr\n ? xhr.onload = xhr.onerror = xhr.ontimeout = respond\n : xhr.onreadystatechange = function(o) { xhr.readyState > 3 && respond(o); };\n\n function respond(o) {\n var status = xhr.status, result;\n if (!status && hasResponse(xhr)\n || status >= 200 && status < 300\n || status === 304) {\n if (response) {\n try {\n result = response.call(request, xhr);\n } catch (e) {\n event.call(\"error\", request, e);\n return;\n }\n } else {\n result = xhr;\n }\n event.call(\"load\", request, result);\n } else {\n event.call(\"error\", request, o);\n }\n }\n\n xhr.onprogress = function(e) {\n event.call(\"progress\", request, e);\n };\n\n request = {\n header: function(name, value) {\n name = (name + \"\").toLowerCase();\n if (arguments.length < 2) return headers.get(name);\n if (value == null) headers.remove(name);\n else headers.set(name, value + \"\");\n return request;\n },\n\n // If mimeType is non-null and no Accept header is set, a default is used.\n mimeType: function(value) {\n if (!arguments.length) return mimeType;\n mimeType = value == null ? null : value + \"\";\n return request;\n },\n\n // Specifies what type the response value should take;\n // for instance, arraybuffer, blob, document, or text.\n responseType: function(value) {\n if (!arguments.length) return responseType;\n responseType = value;\n return request;\n },\n\n timeout: function(value) {\n if (!arguments.length) return timeout;\n timeout = +value;\n return request;\n },\n\n user: function(value) {\n return arguments.length < 1 ? user : (user = value == null ? null : value + \"\", request);\n },\n\n password: function(value) {\n return arguments.length < 1 ? password : (password = value == null ? null : value + \"\", request);\n },\n\n // Specify how to convert the response content to a specific type;\n // changes the callback value on \"load\" events.\n response: function(value) {\n response = value;\n return request;\n },\n\n // Alias for send(\"GET\", …).\n get: function(data, callback) {\n return request.send(\"GET\", data, callback);\n },\n\n // Alias for send(\"POST\", …).\n post: function(data, callback) {\n return request.send(\"POST\", data, callback);\n },\n\n // If callback is non-null, it will be used for error and load events.\n send: function(method, data, callback) {\n xhr.open(method, url, true, user, password);\n if (mimeType != null && !headers.has(\"accept\")) headers.set(\"accept\", mimeType + \",*/*\");\n if (xhr.setRequestHeader) headers.each(function(value, name) { xhr.setRequestHeader(name, value); });\n if (mimeType != null && xhr.overrideMimeType) xhr.overrideMimeType(mimeType);\n if (responseType != null) xhr.responseType = responseType;\n if (timeout > 0) xhr.timeout = timeout;\n if (callback == null && typeof data === \"function\") callback = data, data = null;\n if (callback != null && callback.length === 1) callback = fixCallback(callback);\n if (callback != null) request.on(\"error\", callback).on(\"load\", function(xhr) { callback(null, xhr); });\n event.call(\"beforesend\", request, xhr);\n xhr.send(data == null ? null : data);\n return request;\n },\n\n abort: function() {\n xhr.abort();\n return request;\n },\n\n on: function() {\n var value = event.on.apply(event, arguments);\n return value === event ? request : value;\n }\n };\n\n if (callback != null) {\n if (typeof callback !== \"function\") throw new Error(\"invalid callback: \" + callback);\n return request.get(callback);\n }\n\n return request;\n};\n\nfunction fixCallback(callback) {\n return function(error, xhr) {\n callback(error == null ? xhr : null);\n };\n}\n\nfunction hasResponse(xhr) {\n var type = xhr.responseType;\n return type && type !== \"text\"\n ? xhr.response // null on error\n : xhr.responseText; // \"\" on error\n}\n\nvar type$1 = function(defaultMimeType, response) {\n return function(url, callback) {\n var r = request(url).mimeType(defaultMimeType).response(response);\n if (callback != null) {\n if (typeof callback !== \"function\") throw new Error(\"invalid callback: \" + callback);\n return r.get(callback);\n }\n return r;\n };\n};\n\nvar html = type$1(\"text/html\", function(xhr) {\n return document.createRange().createContextualFragment(xhr.responseText);\n});\n\nvar json = type$1(\"application/json\", function(xhr) {\n return JSON.parse(xhr.responseText);\n});\n\nvar text = type$1(\"text/plain\", function(xhr) {\n return xhr.responseText;\n});\n\nvar xml = type$1(\"application/xml\", function(xhr) {\n var xml = xhr.responseXML;\n if (!xml) throw new Error(\"parse error\");\n return xml;\n});\n\nvar dsv$1 = function(defaultMimeType, parse) {\n return function(url, row, callback) {\n if (arguments.length < 3) callback = row, row = null;\n var r = request(url).mimeType(defaultMimeType);\n r.row = function(_) { return arguments.length ? r.response(responseOf(parse, row = _)) : row; };\n r.row(row);\n return callback ? r.get(callback) : r;\n };\n};\n\nfunction responseOf(parse, row) {\n return function(request$$1) {\n return parse(request$$1.responseText, row);\n };\n}\n\nvar csv$1 = dsv$1(\"text/csv\", csvParse);\n\nvar tsv$1 = dsv$1(\"text/tab-separated-values\", tsvParse);\n\nvar array$2 = Array.prototype;\n\nvar map$3 = array$2.map;\nvar slice$4 = array$2.slice;\n\nvar implicit = {name: \"implicit\"};\n\nfunction ordinal(range) {\n var index = map$1(),\n domain = [],\n unknown = implicit;\n\n range = range == null ? [] : slice$4.call(range);\n\n function scale(d) {\n var key = d + \"\", i = index.get(key);\n if (!i) {\n if (unknown !== implicit) return unknown;\n index.set(key, i = domain.push(d));\n }\n return range[(i - 1) % range.length];\n }\n\n scale.domain = function(_) {\n if (!arguments.length) return domain.slice();\n domain = [], index = map$1();\n var i = -1, n = _.length, d, key;\n while (++i < n) if (!index.has(key = (d = _[i]) + \"\")) index.set(key, domain.push(d));\n return scale;\n };\n\n scale.range = function(_) {\n return arguments.length ? (range = slice$4.call(_), scale) : range.slice();\n };\n\n scale.unknown = function(_) {\n return arguments.length ? (unknown = _, scale) : unknown;\n };\n\n scale.copy = function() {\n return ordinal()\n .domain(domain)\n .range(range)\n .unknown(unknown);\n };\n\n return scale;\n}\n\nfunction band() {\n var scale = ordinal().unknown(undefined),\n domain = scale.domain,\n ordinalRange = scale.range,\n range$$1 = [0, 1],\n step,\n bandwidth,\n round = false,\n paddingInner = 0,\n paddingOuter = 0,\n align = 0.5;\n\n delete scale.unknown;\n\n function rescale() {\n var n = domain().length,\n reverse = range$$1[1] < range$$1[0],\n start = range$$1[reverse - 0],\n stop = range$$1[1 - reverse];\n step = (stop - start) / Math.max(1, n - paddingInner + paddingOuter * 2);\n if (round) step = Math.floor(step);\n start += (stop - start - step * (n - paddingInner)) * align;\n bandwidth = step * (1 - paddingInner);\n if (round) start = Math.round(start), bandwidth = Math.round(bandwidth);\n var values = sequence(n).map(function(i) { return start + step * i; });\n return ordinalRange(reverse ? values.reverse() : values);\n }\n\n scale.domain = function(_) {\n return arguments.length ? (domain(_), rescale()) : domain();\n };\n\n scale.range = function(_) {\n return arguments.length ? (range$$1 = [+_[0], +_[1]], rescale()) : range$$1.slice();\n };\n\n scale.rangeRound = function(_) {\n return range$$1 = [+_[0], +_[1]], round = true, rescale();\n };\n\n scale.bandwidth = function() {\n return bandwidth;\n };\n\n scale.step = function() {\n return step;\n };\n\n scale.round = function(_) {\n return arguments.length ? (round = !!_, rescale()) : round;\n };\n\n scale.padding = function(_) {\n return arguments.length ? (paddingInner = paddingOuter = Math.max(0, Math.min(1, _)), rescale()) : paddingInner;\n };\n\n scale.paddingInner = function(_) {\n return arguments.length ? (paddingInner = Math.max(0, Math.min(1, _)), rescale()) : paddingInner;\n };\n\n scale.paddingOuter = function(_) {\n return arguments.length ? (paddingOuter = Math.max(0, Math.min(1, _)), rescale()) : paddingOuter;\n };\n\n scale.align = function(_) {\n return arguments.length ? (align = Math.max(0, Math.min(1, _)), rescale()) : align;\n };\n\n scale.copy = function() {\n return band()\n .domain(domain())\n .range(range$$1)\n .round(round)\n .paddingInner(paddingInner)\n .paddingOuter(paddingOuter)\n .align(align);\n };\n\n return rescale();\n}\n\nfunction pointish(scale) {\n var copy = scale.copy;\n\n scale.padding = scale.paddingOuter;\n delete scale.paddingInner;\n delete scale.paddingOuter;\n\n scale.copy = function() {\n return pointish(copy());\n };\n\n return scale;\n}\n\nfunction point$1() {\n return pointish(band().paddingInner(1));\n}\n\nvar constant$9 = function(x) {\n return function() {\n return x;\n };\n};\n\nvar number$1 = function(x) {\n return +x;\n};\n\nvar unit = [0, 1];\n\nfunction deinterpolateLinear(a, b) {\n return (b -= (a = +a))\n ? function(x) { return (x - a) / b; }\n : constant$9(b);\n}\n\nfunction deinterpolateClamp(deinterpolate) {\n return function(a, b) {\n var d = deinterpolate(a = +a, b = +b);\n return function(x) { return x <= a ? 0 : x >= b ? 1 : d(x); };\n };\n}\n\nfunction reinterpolateClamp(reinterpolate) {\n return function(a, b) {\n var r = reinterpolate(a = +a, b = +b);\n return function(t) { return t <= 0 ? a : t >= 1 ? b : r(t); };\n };\n}\n\nfunction bimap(domain, range$$1, deinterpolate, reinterpolate) {\n var d0 = domain[0], d1 = domain[1], r0 = range$$1[0], r1 = range$$1[1];\n if (d1 < d0) d0 = deinterpolate(d1, d0), r0 = reinterpolate(r1, r0);\n else d0 = deinterpolate(d0, d1), r0 = reinterpolate(r0, r1);\n return function(x) { return r0(d0(x)); };\n}\n\nfunction polymap(domain, range$$1, deinterpolate, reinterpolate) {\n var j = Math.min(domain.length, range$$1.length) - 1,\n d = new Array(j),\n r = new Array(j),\n i = -1;\n\n // Reverse descending domains.\n if (domain[j] < domain[0]) {\n domain = domain.slice().reverse();\n range$$1 = range$$1.slice().reverse();\n }\n\n while (++i < j) {\n d[i] = deinterpolate(domain[i], domain[i + 1]);\n r[i] = reinterpolate(range$$1[i], range$$1[i + 1]);\n }\n\n return function(x) {\n var i = bisectRight(domain, x, 1, j) - 1;\n return r[i](d[i](x));\n };\n}\n\nfunction copy(source, target) {\n return target\n .domain(source.domain())\n .range(source.range())\n .interpolate(source.interpolate())\n .clamp(source.clamp());\n}\n\n// deinterpolate(a, b)(x) takes a domain value x in [a,b] and returns the corresponding parameter t in [0,1].\n// reinterpolate(a, b)(t) takes a parameter t in [0,1] and returns the corresponding domain value x in [a,b].\nfunction continuous(deinterpolate, reinterpolate) {\n var domain = unit,\n range$$1 = unit,\n interpolate$$1 = interpolateValue,\n clamp = false,\n piecewise,\n output,\n input;\n\n function rescale() {\n piecewise = Math.min(domain.length, range$$1.length) > 2 ? polymap : bimap;\n output = input = null;\n return scale;\n }\n\n function scale(x) {\n return (output || (output = piecewise(domain, range$$1, clamp ? deinterpolateClamp(deinterpolate) : deinterpolate, interpolate$$1)))(+x);\n }\n\n scale.invert = function(y) {\n return (input || (input = piecewise(range$$1, domain, deinterpolateLinear, clamp ? reinterpolateClamp(reinterpolate) : reinterpolate)))(+y);\n };\n\n scale.domain = function(_) {\n return arguments.length ? (domain = map$3.call(_, number$1), rescale()) : domain.slice();\n };\n\n scale.range = function(_) {\n return arguments.length ? (range$$1 = slice$4.call(_), rescale()) : range$$1.slice();\n };\n\n scale.rangeRound = function(_) {\n return range$$1 = slice$4.call(_), interpolate$$1 = interpolateRound, rescale();\n };\n\n scale.clamp = function(_) {\n return arguments.length ? (clamp = !!_, rescale()) : clamp;\n };\n\n scale.interpolate = function(_) {\n return arguments.length ? (interpolate$$1 = _, rescale()) : interpolate$$1;\n };\n\n return rescale();\n}\n\nvar tickFormat = function(domain, count, specifier) {\n var start = domain[0],\n stop = domain[domain.length - 1],\n step = tickStep(start, stop, count == null ? 10 : count),\n precision;\n specifier = formatSpecifier(specifier == null ? \",f\" : specifier);\n switch (specifier.type) {\n case \"s\": {\n var value = Math.max(Math.abs(start), Math.abs(stop));\n if (specifier.precision == null && !isNaN(precision = precisionPrefix(step, value))) specifier.precision = precision;\n return exports.formatPrefix(specifier, value);\n }\n case \"\":\n case \"e\":\n case \"g\":\n case \"p\":\n case \"r\": {\n if (specifier.precision == null && !isNaN(precision = precisionRound(step, Math.max(Math.abs(start), Math.abs(stop))))) specifier.precision = precision - (specifier.type === \"e\");\n break;\n }\n case \"f\":\n case \"%\": {\n if (specifier.precision == null && !isNaN(precision = precisionFixed(step))) specifier.precision = precision - (specifier.type === \"%\") * 2;\n break;\n }\n }\n return exports.format(specifier);\n};\n\nfunction linearish(scale) {\n var domain = scale.domain;\n\n scale.ticks = function(count) {\n var d = domain();\n return ticks(d[0], d[d.length - 1], count == null ? 10 : count);\n };\n\n scale.tickFormat = function(count, specifier) {\n return tickFormat(domain(), count, specifier);\n };\n\n scale.nice = function(count) {\n var d = domain(),\n i = d.length - 1,\n n = count == null ? 10 : count,\n start = d[0],\n stop = d[i],\n step = tickStep(start, stop, n);\n\n if (step) {\n step = tickStep(Math.floor(start / step) * step, Math.ceil(stop / step) * step, n);\n d[0] = Math.floor(start / step) * step;\n d[i] = Math.ceil(stop / step) * step;\n domain(d);\n }\n\n return scale;\n };\n\n return scale;\n}\n\nfunction linear$2() {\n var scale = continuous(deinterpolateLinear, reinterpolate);\n\n scale.copy = function() {\n return copy(scale, linear$2());\n };\n\n return linearish(scale);\n}\n\nfunction identity$6() {\n var domain = [0, 1];\n\n function scale(x) {\n return +x;\n }\n\n scale.invert = scale;\n\n scale.domain = scale.range = function(_) {\n return arguments.length ? (domain = map$3.call(_, number$1), scale) : domain.slice();\n };\n\n scale.copy = function() {\n return identity$6().domain(domain);\n };\n\n return linearish(scale);\n}\n\nvar nice = function(domain, interval) {\n domain = domain.slice();\n\n var i0 = 0,\n i1 = domain.length - 1,\n x0 = domain[i0],\n x1 = domain[i1],\n t;\n\n if (x1 < x0) {\n t = i0, i0 = i1, i1 = t;\n t = x0, x0 = x1, x1 = t;\n }\n\n domain[i0] = interval.floor(x0);\n domain[i1] = interval.ceil(x1);\n return domain;\n};\n\nfunction deinterpolate(a, b) {\n return (b = Math.log(b / a))\n ? function(x) { return Math.log(x / a) / b; }\n : constant$9(b);\n}\n\nfunction reinterpolate$1(a, b) {\n return a < 0\n ? function(t) { return -Math.pow(-b, t) * Math.pow(-a, 1 - t); }\n : function(t) { return Math.pow(b, t) * Math.pow(a, 1 - t); };\n}\n\nfunction pow10(x) {\n return isFinite(x) ? +(\"1e\" + x) : x < 0 ? 0 : x;\n}\n\nfunction powp(base) {\n return base === 10 ? pow10\n : base === Math.E ? Math.exp\n : function(x) { return Math.pow(base, x); };\n}\n\nfunction logp(base) {\n return base === Math.E ? Math.log\n : base === 10 && Math.log10\n || base === 2 && Math.log2\n || (base = Math.log(base), function(x) { return Math.log(x) / base; });\n}\n\nfunction reflect(f) {\n return function(x) {\n return -f(-x);\n };\n}\n\nfunction log$1() {\n var scale = continuous(deinterpolate, reinterpolate$1).domain([1, 10]),\n domain = scale.domain,\n base = 10,\n logs = logp(10),\n pows = powp(10);\n\n function rescale() {\n logs = logp(base), pows = powp(base);\n if (domain()[0] < 0) logs = reflect(logs), pows = reflect(pows);\n return scale;\n }\n\n scale.base = function(_) {\n return arguments.length ? (base = +_, rescale()) : base;\n };\n\n scale.domain = function(_) {\n return arguments.length ? (domain(_), rescale()) : domain();\n };\n\n scale.ticks = function(count) {\n var d = domain(),\n u = d[0],\n v = d[d.length - 1],\n r;\n\n if (r = v < u) i = u, u = v, v = i;\n\n var i = logs(u),\n j = logs(v),\n p,\n k,\n t,\n n = count == null ? 10 : +count,\n z = [];\n\n if (!(base % 1) && j - i < n) {\n i = Math.round(i) - 1, j = Math.round(j) + 1;\n if (u > 0) for (; i < j; ++i) {\n for (k = 1, p = pows(i); k < base; ++k) {\n t = p * k;\n if (t < u) continue;\n if (t > v) break;\n z.push(t);\n }\n } else for (; i < j; ++i) {\n for (k = base - 1, p = pows(i); k >= 1; --k) {\n t = p * k;\n if (t < u) continue;\n if (t > v) break;\n z.push(t);\n }\n }\n } else {\n z = ticks(i, j, Math.min(j - i, n)).map(pows);\n }\n\n return r ? z.reverse() : z;\n };\n\n scale.tickFormat = function(count, specifier) {\n if (specifier == null) specifier = base === 10 ? \".0e\" : \",\";\n if (typeof specifier !== \"function\") specifier = exports.format(specifier);\n if (count === Infinity) return specifier;\n if (count == null) count = 10;\n var k = Math.max(1, base * count / scale.ticks().length); // TODO fast estimate?\n return function(d) {\n var i = d / pows(Math.round(logs(d)));\n if (i * base < base - 0.5) i *= base;\n return i <= k ? specifier(d) : \"\";\n };\n };\n\n scale.nice = function() {\n return domain(nice(domain(), {\n floor: function(x) { return pows(Math.floor(logs(x))); },\n ceil: function(x) { return pows(Math.ceil(logs(x))); }\n }));\n };\n\n scale.copy = function() {\n return copy(scale, log$1().base(base));\n };\n\n return scale;\n}\n\nfunction raise$1(x, exponent) {\n return x < 0 ? -Math.pow(-x, exponent) : Math.pow(x, exponent);\n}\n\nfunction pow$1() {\n var exponent = 1,\n scale = continuous(deinterpolate, reinterpolate),\n domain = scale.domain;\n\n function deinterpolate(a, b) {\n return (b = raise$1(b, exponent) - (a = raise$1(a, exponent)))\n ? function(x) { return (raise$1(x, exponent) - a) / b; }\n : constant$9(b);\n }\n\n function reinterpolate(a, b) {\n b = raise$1(b, exponent) - (a = raise$1(a, exponent));\n return function(t) { return raise$1(a + b * t, 1 / exponent); };\n }\n\n scale.exponent = function(_) {\n return arguments.length ? (exponent = +_, domain(domain())) : exponent;\n };\n\n scale.copy = function() {\n return copy(scale, pow$1().exponent(exponent));\n };\n\n return linearish(scale);\n}\n\nfunction sqrt$1() {\n return pow$1().exponent(0.5);\n}\n\nfunction quantile$$1() {\n var domain = [],\n range$$1 = [],\n thresholds = [];\n\n function rescale() {\n var i = 0, n = Math.max(1, range$$1.length);\n thresholds = new Array(n - 1);\n while (++i < n) thresholds[i - 1] = threshold(domain, i / n);\n return scale;\n }\n\n function scale(x) {\n if (!isNaN(x = +x)) return range$$1[bisectRight(thresholds, x)];\n }\n\n scale.invertExtent = function(y) {\n var i = range$$1.indexOf(y);\n return i < 0 ? [NaN, NaN] : [\n i > 0 ? thresholds[i - 1] : domain[0],\n i < thresholds.length ? thresholds[i] : domain[domain.length - 1]\n ];\n };\n\n scale.domain = function(_) {\n if (!arguments.length) return domain.slice();\n domain = [];\n for (var i = 0, n = _.length, d; i < n; ++i) if (d = _[i], d != null && !isNaN(d = +d)) domain.push(d);\n domain.sort(ascending);\n return rescale();\n };\n\n scale.range = function(_) {\n return arguments.length ? (range$$1 = slice$4.call(_), rescale()) : range$$1.slice();\n };\n\n scale.quantiles = function() {\n return thresholds.slice();\n };\n\n scale.copy = function() {\n return quantile$$1()\n .domain(domain)\n .range(range$$1);\n };\n\n return scale;\n}\n\nfunction quantize$1() {\n var x0 = 0,\n x1 = 1,\n n = 1,\n domain = [0.5],\n range$$1 = [0, 1];\n\n function scale(x) {\n if (x <= x) return range$$1[bisectRight(domain, x, 0, n)];\n }\n\n function rescale() {\n var i = -1;\n domain = new Array(n);\n while (++i < n) domain[i] = ((i + 1) * x1 - (i - n) * x0) / (n + 1);\n return scale;\n }\n\n scale.domain = function(_) {\n return arguments.length ? (x0 = +_[0], x1 = +_[1], rescale()) : [x0, x1];\n };\n\n scale.range = function(_) {\n return arguments.length ? (n = (range$$1 = slice$4.call(_)).length - 1, rescale()) : range$$1.slice();\n };\n\n scale.invertExtent = function(y) {\n var i = range$$1.indexOf(y);\n return i < 0 ? [NaN, NaN]\n : i < 1 ? [x0, domain[0]]\n : i >= n ? [domain[n - 1], x1]\n : [domain[i - 1], domain[i]];\n };\n\n scale.copy = function() {\n return quantize$1()\n .domain([x0, x1])\n .range(range$$1);\n };\n\n return linearish(scale);\n}\n\nfunction threshold$1() {\n var domain = [0.5],\n range$$1 = [0, 1],\n n = 1;\n\n function scale(x) {\n if (x <= x) return range$$1[bisectRight(domain, x, 0, n)];\n }\n\n scale.domain = function(_) {\n return arguments.length ? (domain = slice$4.call(_), n = Math.min(domain.length, range$$1.length - 1), scale) : domain.slice();\n };\n\n scale.range = function(_) {\n return arguments.length ? (range$$1 = slice$4.call(_), n = Math.min(domain.length, range$$1.length - 1), scale) : range$$1.slice();\n };\n\n scale.invertExtent = function(y) {\n var i = range$$1.indexOf(y);\n return [domain[i - 1], domain[i]];\n };\n\n scale.copy = function() {\n return threshold$1()\n .domain(domain)\n .range(range$$1);\n };\n\n return scale;\n}\n\nvar t0$1 = new Date;\nvar t1$1 = new Date;\n\nfunction newInterval(floori, offseti, count, field) {\n\n function interval(date) {\n return floori(date = new Date(+date)), date;\n }\n\n interval.floor = interval;\n\n interval.ceil = function(date) {\n return floori(date = new Date(date - 1)), offseti(date, 1), floori(date), date;\n };\n\n interval.round = function(date) {\n var d0 = interval(date),\n d1 = interval.ceil(date);\n return date - d0 < d1 - date ? d0 : d1;\n };\n\n interval.offset = function(date, step) {\n return offseti(date = new Date(+date), step == null ? 1 : Math.floor(step)), date;\n };\n\n interval.range = function(start, stop, step) {\n var range = [];\n start = interval.ceil(start);\n step = step == null ? 1 : Math.floor(step);\n if (!(start < stop) || !(step > 0)) return range; // also handles Invalid Date\n do range.push(new Date(+start)); while (offseti(start, step), floori(start), start < stop)\n return range;\n };\n\n interval.filter = function(test) {\n return newInterval(function(date) {\n if (date >= date) while (floori(date), !test(date)) date.setTime(date - 1);\n }, function(date, step) {\n if (date >= date) while (--step >= 0) while (offseti(date, 1), !test(date)) {} // eslint-disable-line no-empty\n });\n };\n\n if (count) {\n interval.count = function(start, end) {\n t0$1.setTime(+start), t1$1.setTime(+end);\n floori(t0$1), floori(t1$1);\n return Math.floor(count(t0$1, t1$1));\n };\n\n interval.every = function(step) {\n step = Math.floor(step);\n return !isFinite(step) || !(step > 0) ? null\n : !(step > 1) ? interval\n : interval.filter(field\n ? function(d) { return field(d) % step === 0; }\n : function(d) { return interval.count(0, d) % step === 0; });\n };\n }\n\n return interval;\n}\n\nvar millisecond = newInterval(function() {\n // noop\n}, function(date, step) {\n date.setTime(+date + step);\n}, function(start, end) {\n return end - start;\n});\n\n// An optimized implementation for this simple case.\nmillisecond.every = function(k) {\n k = Math.floor(k);\n if (!isFinite(k) || !(k > 0)) return null;\n if (!(k > 1)) return millisecond;\n return newInterval(function(date) {\n date.setTime(Math.floor(date / k) * k);\n }, function(date, step) {\n date.setTime(+date + step * k);\n }, function(start, end) {\n return (end - start) / k;\n });\n};\n\nvar milliseconds = millisecond.range;\n\nvar durationSecond$1 = 1e3;\nvar durationMinute$1 = 6e4;\nvar durationHour$1 = 36e5;\nvar durationDay$1 = 864e5;\nvar durationWeek$1 = 6048e5;\n\nvar second = newInterval(function(date) {\n date.setTime(Math.floor(date / durationSecond$1) * durationSecond$1);\n}, function(date, step) {\n date.setTime(+date + step * durationSecond$1);\n}, function(start, end) {\n return (end - start) / durationSecond$1;\n}, function(date) {\n return date.getUTCSeconds();\n});\n\nvar seconds = second.range;\n\nvar minute = newInterval(function(date) {\n date.setTime(Math.floor(date / durationMinute$1) * durationMinute$1);\n}, function(date, step) {\n date.setTime(+date + step * durationMinute$1);\n}, function(start, end) {\n return (end - start) / durationMinute$1;\n}, function(date) {\n return date.getMinutes();\n});\n\nvar minutes = minute.range;\n\nvar hour = newInterval(function(date) {\n var offset = date.getTimezoneOffset() * durationMinute$1 % durationHour$1;\n if (offset < 0) offset += durationHour$1;\n date.setTime(Math.floor((+date - offset) / durationHour$1) * durationHour$1 + offset);\n}, function(date, step) {\n date.setTime(+date + step * durationHour$1);\n}, function(start, end) {\n return (end - start) / durationHour$1;\n}, function(date) {\n return date.getHours();\n});\n\nvar hours = hour.range;\n\nvar day = newInterval(function(date) {\n date.setHours(0, 0, 0, 0);\n}, function(date, step) {\n date.setDate(date.getDate() + step);\n}, function(start, end) {\n return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute$1) / durationDay$1;\n}, function(date) {\n return date.getDate() - 1;\n});\n\nvar days = day.range;\n\nfunction weekday(i) {\n return newInterval(function(date) {\n date.setDate(date.getDate() - (date.getDay() + 7 - i) % 7);\n date.setHours(0, 0, 0, 0);\n }, function(date, step) {\n date.setDate(date.getDate() + step * 7);\n }, function(start, end) {\n return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute$1) / durationWeek$1;\n });\n}\n\nvar sunday = weekday(0);\nvar monday = weekday(1);\nvar tuesday = weekday(2);\nvar wednesday = weekday(3);\nvar thursday = weekday(4);\nvar friday = weekday(5);\nvar saturday = weekday(6);\n\nvar sundays = sunday.range;\nvar mondays = monday.range;\nvar tuesdays = tuesday.range;\nvar wednesdays = wednesday.range;\nvar thursdays = thursday.range;\nvar fridays = friday.range;\nvar saturdays = saturday.range;\n\nvar month = newInterval(function(date) {\n date.setDate(1);\n date.setHours(0, 0, 0, 0);\n}, function(date, step) {\n date.setMonth(date.getMonth() + step);\n}, function(start, end) {\n return end.getMonth() - start.getMonth() + (end.getFullYear() - start.getFullYear()) * 12;\n}, function(date) {\n return date.getMonth();\n});\n\nvar months = month.range;\n\nvar year = newInterval(function(date) {\n date.setMonth(0, 1);\n date.setHours(0, 0, 0, 0);\n}, function(date, step) {\n date.setFullYear(date.getFullYear() + step);\n}, function(start, end) {\n return end.getFullYear() - start.getFullYear();\n}, function(date) {\n return date.getFullYear();\n});\n\n// An optimized implementation for this simple case.\nyear.every = function(k) {\n return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : newInterval(function(date) {\n date.setFullYear(Math.floor(date.getFullYear() / k) * k);\n date.setMonth(0, 1);\n date.setHours(0, 0, 0, 0);\n }, function(date, step) {\n date.setFullYear(date.getFullYear() + step * k);\n });\n};\n\nvar years = year.range;\n\nvar utcMinute = newInterval(function(date) {\n date.setUTCSeconds(0, 0);\n}, function(date, step) {\n date.setTime(+date + step * durationMinute$1);\n}, function(start, end) {\n return (end - start) / durationMinute$1;\n}, function(date) {\n return date.getUTCMinutes();\n});\n\nvar utcMinutes = utcMinute.range;\n\nvar utcHour = newInterval(function(date) {\n date.setUTCMinutes(0, 0, 0);\n}, function(date, step) {\n date.setTime(+date + step * durationHour$1);\n}, function(start, end) {\n return (end - start) / durationHour$1;\n}, function(date) {\n return date.getUTCHours();\n});\n\nvar utcHours = utcHour.range;\n\nvar utcDay = newInterval(function(date) {\n date.setUTCHours(0, 0, 0, 0);\n}, function(date, step) {\n date.setUTCDate(date.getUTCDate() + step);\n}, function(start, end) {\n return (end - start) / durationDay$1;\n}, function(date) {\n return date.getUTCDate() - 1;\n});\n\nvar utcDays = utcDay.range;\n\nfunction utcWeekday(i) {\n return newInterval(function(date) {\n date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 7 - i) % 7);\n date.setUTCHours(0, 0, 0, 0);\n }, function(date, step) {\n date.setUTCDate(date.getUTCDate() + step * 7);\n }, function(start, end) {\n return (end - start) / durationWeek$1;\n });\n}\n\nvar utcSunday = utcWeekday(0);\nvar utcMonday = utcWeekday(1);\nvar utcTuesday = utcWeekday(2);\nvar utcWednesday = utcWeekday(3);\nvar utcThursday = utcWeekday(4);\nvar utcFriday = utcWeekday(5);\nvar utcSaturday = utcWeekday(6);\n\nvar utcSundays = utcSunday.range;\nvar utcMondays = utcMonday.range;\nvar utcTuesdays = utcTuesday.range;\nvar utcWednesdays = utcWednesday.range;\nvar utcThursdays = utcThursday.range;\nvar utcFridays = utcFriday.range;\nvar utcSaturdays = utcSaturday.range;\n\nvar utcMonth = newInterval(function(date) {\n date.setUTCDate(1);\n date.setUTCHours(0, 0, 0, 0);\n}, function(date, step) {\n date.setUTCMonth(date.getUTCMonth() + step);\n}, function(start, end) {\n return end.getUTCMonth() - start.getUTCMonth() + (end.getUTCFullYear() - start.getUTCFullYear()) * 12;\n}, function(date) {\n return date.getUTCMonth();\n});\n\nvar utcMonths = utcMonth.range;\n\nvar utcYear = newInterval(function(date) {\n date.setUTCMonth(0, 1);\n date.setUTCHours(0, 0, 0, 0);\n}, function(date, step) {\n date.setUTCFullYear(date.getUTCFullYear() + step);\n}, function(start, end) {\n return end.getUTCFullYear() - start.getUTCFullYear();\n}, function(date) {\n return date.getUTCFullYear();\n});\n\n// An optimized implementation for this simple case.\nutcYear.every = function(k) {\n return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : newInterval(function(date) {\n date.setUTCFullYear(Math.floor(date.getUTCFullYear() / k) * k);\n date.setUTCMonth(0, 1);\n date.setUTCHours(0, 0, 0, 0);\n }, function(date, step) {\n date.setUTCFullYear(date.getUTCFullYear() + step * k);\n });\n};\n\nvar utcYears = utcYear.range;\n\nfunction localDate(d) {\n if (0 <= d.y && d.y < 100) {\n var date = new Date(-1, d.m, d.d, d.H, d.M, d.S, d.L);\n date.setFullYear(d.y);\n return date;\n }\n return new Date(d.y, d.m, d.d, d.H, d.M, d.S, d.L);\n}\n\nfunction utcDate(d) {\n if (0 <= d.y && d.y < 100) {\n var date = new Date(Date.UTC(-1, d.m, d.d, d.H, d.M, d.S, d.L));\n date.setUTCFullYear(d.y);\n return date;\n }\n return new Date(Date.UTC(d.y, d.m, d.d, d.H, d.M, d.S, d.L));\n}\n\nfunction newYear(y) {\n return {y: y, m: 0, d: 1, H: 0, M: 0, S: 0, L: 0};\n}\n\nfunction formatLocale$1(locale) {\n var locale_dateTime = locale.dateTime,\n locale_date = locale.date,\n locale_time = locale.time,\n locale_periods = locale.periods,\n locale_weekdays = locale.days,\n locale_shortWeekdays = locale.shortDays,\n locale_months = locale.months,\n locale_shortMonths = locale.shortMonths;\n\n var periodRe = formatRe(locale_periods),\n periodLookup = formatLookup(locale_periods),\n weekdayRe = formatRe(locale_weekdays),\n weekdayLookup = formatLookup(locale_weekdays),\n shortWeekdayRe = formatRe(locale_shortWeekdays),\n shortWeekdayLookup = formatLookup(locale_shortWeekdays),\n monthRe = formatRe(locale_months),\n monthLookup = formatLookup(locale_months),\n shortMonthRe = formatRe(locale_shortMonths),\n shortMonthLookup = formatLookup(locale_shortMonths);\n\n var formats = {\n \"a\": formatShortWeekday,\n \"A\": formatWeekday,\n \"b\": formatShortMonth,\n \"B\": formatMonth,\n \"c\": null,\n \"d\": formatDayOfMonth,\n \"e\": formatDayOfMonth,\n \"H\": formatHour24,\n \"I\": formatHour12,\n \"j\": formatDayOfYear,\n \"L\": formatMilliseconds,\n \"m\": formatMonthNumber,\n \"M\": formatMinutes,\n \"p\": formatPeriod,\n \"S\": formatSeconds,\n \"U\": formatWeekNumberSunday,\n \"w\": formatWeekdayNumber,\n \"W\": formatWeekNumberMonday,\n \"x\": null,\n \"X\": null,\n \"y\": formatYear,\n \"Y\": formatFullYear,\n \"Z\": formatZone,\n \"%\": formatLiteralPercent\n };\n\n var utcFormats = {\n \"a\": formatUTCShortWeekday,\n \"A\": formatUTCWeekday,\n \"b\": formatUTCShortMonth,\n \"B\": formatUTCMonth,\n \"c\": null,\n \"d\": formatUTCDayOfMonth,\n \"e\": formatUTCDayOfMonth,\n \"H\": formatUTCHour24,\n \"I\": formatUTCHour12,\n \"j\": formatUTCDayOfYear,\n \"L\": formatUTCMilliseconds,\n \"m\": formatUTCMonthNumber,\n \"M\": formatUTCMinutes,\n \"p\": formatUTCPeriod,\n \"S\": formatUTCSeconds,\n \"U\": formatUTCWeekNumberSunday,\n \"w\": formatUTCWeekdayNumber,\n \"W\": formatUTCWeekNumberMonday,\n \"x\": null,\n \"X\": null,\n \"y\": formatUTCYear,\n \"Y\": formatUTCFullYear,\n \"Z\": formatUTCZone,\n \"%\": formatLiteralPercent\n };\n\n var parses = {\n \"a\": parseShortWeekday,\n \"A\": parseWeekday,\n \"b\": parseShortMonth,\n \"B\": parseMonth,\n \"c\": parseLocaleDateTime,\n \"d\": parseDayOfMonth,\n \"e\": parseDayOfMonth,\n \"H\": parseHour24,\n \"I\": parseHour24,\n \"j\": parseDayOfYear,\n \"L\": parseMilliseconds,\n \"m\": parseMonthNumber,\n \"M\": parseMinutes,\n \"p\": parsePeriod,\n \"S\": parseSeconds,\n \"U\": parseWeekNumberSunday,\n \"w\": parseWeekdayNumber,\n \"W\": parseWeekNumberMonday,\n \"x\": parseLocaleDate,\n \"X\": parseLocaleTime,\n \"y\": parseYear,\n \"Y\": parseFullYear,\n \"Z\": parseZone,\n \"%\": parseLiteralPercent\n };\n\n // These recursive directive definitions must be deferred.\n formats.x = newFormat(locale_date, formats);\n formats.X = newFormat(locale_time, formats);\n formats.c = newFormat(locale_dateTime, formats);\n utcFormats.x = newFormat(locale_date, utcFormats);\n utcFormats.X = newFormat(locale_time, utcFormats);\n utcFormats.c = newFormat(locale_dateTime, utcFormats);\n\n function newFormat(specifier, formats) {\n return function(date) {\n var string = [],\n i = -1,\n j = 0,\n n = specifier.length,\n c,\n pad,\n format;\n\n if (!(date instanceof Date)) date = new Date(+date);\n\n while (++i < n) {\n if (specifier.charCodeAt(i) === 37) {\n string.push(specifier.slice(j, i));\n if ((pad = pads[c = specifier.charAt(++i)]) != null) c = specifier.charAt(++i);\n else pad = c === \"e\" ? \" \" : \"0\";\n if (format = formats[c]) c = format(date, pad);\n string.push(c);\n j = i + 1;\n }\n }\n\n string.push(specifier.slice(j, i));\n return string.join(\"\");\n };\n }\n\n function newParse(specifier, newDate) {\n return function(string) {\n var d = newYear(1900),\n i = parseSpecifier(d, specifier, string += \"\", 0);\n if (i != string.length) return null;\n\n // The am-pm flag is 0 for AM, and 1 for PM.\n if (\"p\" in d) d.H = d.H % 12 + d.p * 12;\n\n // Convert day-of-week and week-of-year to day-of-year.\n if (\"W\" in d || \"U\" in d) {\n if (!(\"w\" in d)) d.w = \"W\" in d ? 1 : 0;\n var day$$1 = \"Z\" in d ? utcDate(newYear(d.y)).getUTCDay() : newDate(newYear(d.y)).getDay();\n d.m = 0;\n d.d = \"W\" in d ? (d.w + 6) % 7 + d.W * 7 - (day$$1 + 5) % 7 : d.w + d.U * 7 - (day$$1 + 6) % 7;\n }\n\n // If a time zone is specified, all fields are interpreted as UTC and then\n // offset according to the specified time zone.\n if (\"Z\" in d) {\n d.H += d.Z / 100 | 0;\n d.M += d.Z % 100;\n return utcDate(d);\n }\n\n // Otherwise, all fields are in local time.\n return newDate(d);\n };\n }\n\n function parseSpecifier(d, specifier, string, j) {\n var i = 0,\n n = specifier.length,\n m = string.length,\n c,\n parse;\n\n while (i < n) {\n if (j >= m) return -1;\n c = specifier.charCodeAt(i++);\n if (c === 37) {\n c = specifier.charAt(i++);\n parse = parses[c in pads ? specifier.charAt(i++) : c];\n if (!parse || ((j = parse(d, string, j)) < 0)) return -1;\n } else if (c != string.charCodeAt(j++)) {\n return -1;\n }\n }\n\n return j;\n }\n\n function parsePeriod(d, string, i) {\n var n = periodRe.exec(string.slice(i));\n return n ? (d.p = periodLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n }\n\n function parseShortWeekday(d, string, i) {\n var n = shortWeekdayRe.exec(string.slice(i));\n return n ? (d.w = shortWeekdayLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n }\n\n function parseWeekday(d, string, i) {\n var n = weekdayRe.exec(string.slice(i));\n return n ? (d.w = weekdayLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n }\n\n function parseShortMonth(d, string, i) {\n var n = shortMonthRe.exec(string.slice(i));\n return n ? (d.m = shortMonthLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n }\n\n function parseMonth(d, string, i) {\n var n = monthRe.exec(string.slice(i));\n return n ? (d.m = monthLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n }\n\n function parseLocaleDateTime(d, string, i) {\n return parseSpecifier(d, locale_dateTime, string, i);\n }\n\n function parseLocaleDate(d, string, i) {\n return parseSpecifier(d, locale_date, string, i);\n }\n\n function parseLocaleTime(d, string, i) {\n return parseSpecifier(d, locale_time, string, i);\n }\n\n function formatShortWeekday(d) {\n return locale_shortWeekdays[d.getDay()];\n }\n\n function formatWeekday(d) {\n return locale_weekdays[d.getDay()];\n }\n\n function formatShortMonth(d) {\n return locale_shortMonths[d.getMonth()];\n }\n\n function formatMonth(d) {\n return locale_months[d.getMonth()];\n }\n\n function formatPeriod(d) {\n return locale_periods[+(d.getHours() >= 12)];\n }\n\n function formatUTCShortWeekday(d) {\n return locale_shortWeekdays[d.getUTCDay()];\n }\n\n function formatUTCWeekday(d) {\n return locale_weekdays[d.getUTCDay()];\n }\n\n function formatUTCShortMonth(d) {\n return locale_shortMonths[d.getUTCMonth()];\n }\n\n function formatUTCMonth(d) {\n return locale_months[d.getUTCMonth()];\n }\n\n function formatUTCPeriod(d) {\n return locale_periods[+(d.getUTCHours() >= 12)];\n }\n\n return {\n format: function(specifier) {\n var f = newFormat(specifier += \"\", formats);\n f.toString = function() { return specifier; };\n return f;\n },\n parse: function(specifier) {\n var p = newParse(specifier += \"\", localDate);\n p.toString = function() { return specifier; };\n return p;\n },\n utcFormat: function(specifier) {\n var f = newFormat(specifier += \"\", utcFormats);\n f.toString = function() { return specifier; };\n return f;\n },\n utcParse: function(specifier) {\n var p = newParse(specifier, utcDate);\n p.toString = function() { return specifier; };\n return p;\n }\n };\n}\n\nvar pads = {\"-\": \"\", \"_\": \" \", \"0\": \"0\"};\nvar numberRe = /^\\s*\\d+/;\nvar percentRe = /^%/;\nvar requoteRe = /[\\\\\\^\\$\\*\\+\\?\\|\\[\\]\\(\\)\\.\\{\\}]/g;\n\nfunction pad(value, fill, width) {\n var sign = value < 0 ? \"-\" : \"\",\n string = (sign ? -value : value) + \"\",\n length = string.length;\n return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string);\n}\n\nfunction requote(s) {\n return s.replace(requoteRe, \"\\\\$&\");\n}\n\nfunction formatRe(names) {\n return new RegExp(\"^(?:\" + names.map(requote).join(\"|\") + \")\", \"i\");\n}\n\nfunction formatLookup(names) {\n var map = {}, i = -1, n = names.length;\n while (++i < n) map[names[i].toLowerCase()] = i;\n return map;\n}\n\nfunction parseWeekdayNumber(d, string, i) {\n var n = numberRe.exec(string.slice(i, i + 1));\n return n ? (d.w = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseWeekNumberSunday(d, string, i) {\n var n = numberRe.exec(string.slice(i));\n return n ? (d.U = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseWeekNumberMonday(d, string, i) {\n var n = numberRe.exec(string.slice(i));\n return n ? (d.W = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseFullYear(d, string, i) {\n var n = numberRe.exec(string.slice(i, i + 4));\n return n ? (d.y = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseYear(d, string, i) {\n var n = numberRe.exec(string.slice(i, i + 2));\n return n ? (d.y = +n[0] + (+n[0] > 68 ? 1900 : 2000), i + n[0].length) : -1;\n}\n\nfunction parseZone(d, string, i) {\n var n = /^(Z)|([+-]\\d\\d)(?:\\:?(\\d\\d))?/.exec(string.slice(i, i + 6));\n return n ? (d.Z = n[1] ? 0 : -(n[2] + (n[3] || \"00\")), i + n[0].length) : -1;\n}\n\nfunction parseMonthNumber(d, string, i) {\n var n = numberRe.exec(string.slice(i, i + 2));\n return n ? (d.m = n[0] - 1, i + n[0].length) : -1;\n}\n\nfunction parseDayOfMonth(d, string, i) {\n var n = numberRe.exec(string.slice(i, i + 2));\n return n ? (d.d = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseDayOfYear(d, string, i) {\n var n = numberRe.exec(string.slice(i, i + 3));\n return n ? (d.m = 0, d.d = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseHour24(d, string, i) {\n var n = numberRe.exec(string.slice(i, i + 2));\n return n ? (d.H = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseMinutes(d, string, i) {\n var n = numberRe.exec(string.slice(i, i + 2));\n return n ? (d.M = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseSeconds(d, string, i) {\n var n = numberRe.exec(string.slice(i, i + 2));\n return n ? (d.S = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseMilliseconds(d, string, i) {\n var n = numberRe.exec(string.slice(i, i + 3));\n return n ? (d.L = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseLiteralPercent(d, string, i) {\n var n = percentRe.exec(string.slice(i, i + 1));\n return n ? i + n[0].length : -1;\n}\n\nfunction formatDayOfMonth(d, p) {\n return pad(d.getDate(), p, 2);\n}\n\nfunction formatHour24(d, p) {\n return pad(d.getHours(), p, 2);\n}\n\nfunction formatHour12(d, p) {\n return pad(d.getHours() % 12 || 12, p, 2);\n}\n\nfunction formatDayOfYear(d, p) {\n return pad(1 + day.count(year(d), d), p, 3);\n}\n\nfunction formatMilliseconds(d, p) {\n return pad(d.getMilliseconds(), p, 3);\n}\n\nfunction formatMonthNumber(d, p) {\n return pad(d.getMonth() + 1, p, 2);\n}\n\nfunction formatMinutes(d, p) {\n return pad(d.getMinutes(), p, 2);\n}\n\nfunction formatSeconds(d, p) {\n return pad(d.getSeconds(), p, 2);\n}\n\nfunction formatWeekNumberSunday(d, p) {\n return pad(sunday.count(year(d), d), p, 2);\n}\n\nfunction formatWeekdayNumber(d) {\n return d.getDay();\n}\n\nfunction formatWeekNumberMonday(d, p) {\n return pad(monday.count(year(d), d), p, 2);\n}\n\nfunction formatYear(d, p) {\n return pad(d.getFullYear() % 100, p, 2);\n}\n\nfunction formatFullYear(d, p) {\n return pad(d.getFullYear() % 10000, p, 4);\n}\n\nfunction formatZone(d) {\n var z = d.getTimezoneOffset();\n return (z > 0 ? \"-\" : (z *= -1, \"+\"))\n + pad(z / 60 | 0, \"0\", 2)\n + pad(z % 60, \"0\", 2);\n}\n\nfunction formatUTCDayOfMonth(d, p) {\n return pad(d.getUTCDate(), p, 2);\n}\n\nfunction formatUTCHour24(d, p) {\n return pad(d.getUTCHours(), p, 2);\n}\n\nfunction formatUTCHour12(d, p) {\n return pad(d.getUTCHours() % 12 || 12, p, 2);\n}\n\nfunction formatUTCDayOfYear(d, p) {\n return pad(1 + utcDay.count(utcYear(d), d), p, 3);\n}\n\nfunction formatUTCMilliseconds(d, p) {\n return pad(d.getUTCMilliseconds(), p, 3);\n}\n\nfunction formatUTCMonthNumber(d, p) {\n return pad(d.getUTCMonth() + 1, p, 2);\n}\n\nfunction formatUTCMinutes(d, p) {\n return pad(d.getUTCMinutes(), p, 2);\n}\n\nfunction formatUTCSeconds(d, p) {\n return pad(d.getUTCSeconds(), p, 2);\n}\n\nfunction formatUTCWeekNumberSunday(d, p) {\n return pad(utcSunday.count(utcYear(d), d), p, 2);\n}\n\nfunction formatUTCWeekdayNumber(d) {\n return d.getUTCDay();\n}\n\nfunction formatUTCWeekNumberMonday(d, p) {\n return pad(utcMonday.count(utcYear(d), d), p, 2);\n}\n\nfunction formatUTCYear(d, p) {\n return pad(d.getUTCFullYear() % 100, p, 2);\n}\n\nfunction formatUTCFullYear(d, p) {\n return pad(d.getUTCFullYear() % 10000, p, 4);\n}\n\nfunction formatUTCZone() {\n return \"+0000\";\n}\n\nfunction formatLiteralPercent() {\n return \"%\";\n}\n\nvar locale$2;\n\n\n\n\n\ndefaultLocale$1({\n dateTime: \"%x, %X\",\n date: \"%-m/%-d/%Y\",\n time: \"%-I:%M:%S %p\",\n periods: [\"AM\", \"PM\"],\n days: [\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"],\n shortDays: [\"Sun\", \"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\"],\n months: [\"January\", \"February\", \"March\", \"April\", \"May\", \"June\", \"July\", \"August\", \"September\", \"October\", \"November\", \"December\"],\n shortMonths: [\"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"Jun\", \"Jul\", \"Aug\", \"Sep\", \"Oct\", \"Nov\", \"Dec\"]\n});\n\nfunction defaultLocale$1(definition) {\n locale$2 = formatLocale$1(definition);\n exports.timeFormat = locale$2.format;\n exports.timeParse = locale$2.parse;\n exports.utcFormat = locale$2.utcFormat;\n exports.utcParse = locale$2.utcParse;\n return locale$2;\n}\n\nvar isoSpecifier = \"%Y-%m-%dT%H:%M:%S.%LZ\";\n\nfunction formatIsoNative(date) {\n return date.toISOString();\n}\n\nvar formatIso = Date.prototype.toISOString\n ? formatIsoNative\n : exports.utcFormat(isoSpecifier);\n\nfunction parseIsoNative(string) {\n var date = new Date(string);\n return isNaN(date) ? null : date;\n}\n\nvar parseIso = +new Date(\"2000-01-01T00:00:00.000Z\")\n ? parseIsoNative\n : exports.utcParse(isoSpecifier);\n\nvar durationSecond = 1000;\nvar durationMinute = durationSecond * 60;\nvar durationHour = durationMinute * 60;\nvar durationDay = durationHour * 24;\nvar durationWeek = durationDay * 7;\nvar durationMonth = durationDay * 30;\nvar durationYear = durationDay * 365;\n\nfunction date$1(t) {\n return new Date(t);\n}\n\nfunction number$2(t) {\n return t instanceof Date ? +t : +new Date(+t);\n}\n\nfunction calendar(year$$1, month$$1, week, day$$1, hour$$1, minute$$1, second$$1, millisecond$$1, format) {\n var scale = continuous(deinterpolateLinear, reinterpolate),\n invert = scale.invert,\n domain = scale.domain;\n\n var formatMillisecond = format(\".%L\"),\n formatSecond = format(\":%S\"),\n formatMinute = format(\"%I:%M\"),\n formatHour = format(\"%I %p\"),\n formatDay = format(\"%a %d\"),\n formatWeek = format(\"%b %d\"),\n formatMonth = format(\"%B\"),\n formatYear = format(\"%Y\");\n\n var tickIntervals = [\n [second$$1, 1, durationSecond],\n [second$$1, 5, 5 * durationSecond],\n [second$$1, 15, 15 * durationSecond],\n [second$$1, 30, 30 * durationSecond],\n [minute$$1, 1, durationMinute],\n [minute$$1, 5, 5 * durationMinute],\n [minute$$1, 15, 15 * durationMinute],\n [minute$$1, 30, 30 * durationMinute],\n [ hour$$1, 1, durationHour ],\n [ hour$$1, 3, 3 * durationHour ],\n [ hour$$1, 6, 6 * durationHour ],\n [ hour$$1, 12, 12 * durationHour ],\n [ day$$1, 1, durationDay ],\n [ day$$1, 2, 2 * durationDay ],\n [ week, 1, durationWeek ],\n [ month$$1, 1, durationMonth ],\n [ month$$1, 3, 3 * durationMonth ],\n [ year$$1, 1, durationYear ]\n ];\n\n function tickFormat(date) {\n return (second$$1(date) < date ? formatMillisecond\n : minute$$1(date) < date ? formatSecond\n : hour$$1(date) < date ? formatMinute\n : day$$1(date) < date ? formatHour\n : month$$1(date) < date ? (week(date) < date ? formatDay : formatWeek)\n : year$$1(date) < date ? formatMonth\n : formatYear)(date);\n }\n\n function tickInterval(interval, start, stop, step) {\n if (interval == null) interval = 10;\n\n // If a desired tick count is specified, pick a reasonable tick interval\n // based on the extent of the domain and a rough estimate of tick size.\n // Otherwise, assume interval is already a time interval and use it.\n if (typeof interval === \"number\") {\n var target = Math.abs(stop - start) / interval,\n i = bisector(function(i) { return i[2]; }).right(tickIntervals, target);\n if (i === tickIntervals.length) {\n step = tickStep(start / durationYear, stop / durationYear, interval);\n interval = year$$1;\n } else if (i) {\n i = tickIntervals[target / tickIntervals[i - 1][2] < tickIntervals[i][2] / target ? i - 1 : i];\n step = i[1];\n interval = i[0];\n } else {\n step = tickStep(start, stop, interval);\n interval = millisecond$$1;\n }\n }\n\n return step == null ? interval : interval.every(step);\n }\n\n scale.invert = function(y) {\n return new Date(invert(y));\n };\n\n scale.domain = function(_) {\n return arguments.length ? domain(map$3.call(_, number$2)) : domain().map(date$1);\n };\n\n scale.ticks = function(interval, step) {\n var d = domain(),\n t0 = d[0],\n t1 = d[d.length - 1],\n r = t1 < t0,\n t;\n if (r) t = t0, t0 = t1, t1 = t;\n t = tickInterval(interval, t0, t1, step);\n t = t ? t.range(t0, t1 + 1) : []; // inclusive stop\n return r ? t.reverse() : t;\n };\n\n scale.tickFormat = function(count, specifier) {\n return specifier == null ? tickFormat : format(specifier);\n };\n\n scale.nice = function(interval, step) {\n var d = domain();\n return (interval = tickInterval(interval, d[0], d[d.length - 1], step))\n ? domain(nice(d, interval))\n : scale;\n };\n\n scale.copy = function() {\n return copy(scale, calendar(year$$1, month$$1, week, day$$1, hour$$1, minute$$1, second$$1, millisecond$$1, format));\n };\n\n return scale;\n}\n\nvar time = function() {\n return calendar(year, month, sunday, day, hour, minute, second, millisecond, exports.timeFormat).domain([new Date(2000, 0, 1), new Date(2000, 0, 2)]);\n};\n\nvar utcTime = function() {\n return calendar(utcYear, utcMonth, utcSunday, utcDay, utcHour, utcMinute, second, millisecond, exports.utcFormat).domain([Date.UTC(2000, 0, 1), Date.UTC(2000, 0, 2)]);\n};\n\nvar colors = function(s) {\n return s.match(/.{6}/g).map(function(x) {\n return \"#\" + x;\n });\n};\n\nvar category10 = colors(\"1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf\");\n\nvar category20b = colors(\"393b795254a36b6ecf9c9ede6379398ca252b5cf6bcedb9c8c6d31bd9e39e7ba52e7cb94843c39ad494ad6616be7969c7b4173a55194ce6dbdde9ed6\");\n\nvar category20c = colors(\"3182bd6baed69ecae1c6dbefe6550dfd8d3cfdae6bfdd0a231a35474c476a1d99bc7e9c0756bb19e9ac8bcbddcdadaeb636363969696bdbdbdd9d9d9\");\n\nvar category20 = colors(\"1f77b4aec7e8ff7f0effbb782ca02c98df8ad62728ff98969467bdc5b0d58c564bc49c94e377c2f7b6d27f7f7fc7c7c7bcbd22dbdb8d17becf9edae5\");\n\nvar cubehelix$3 = cubehelixLong(cubehelix(300, 0.5, 0.0), cubehelix(-240, 0.5, 1.0));\n\nvar warm = cubehelixLong(cubehelix(-100, 0.75, 0.35), cubehelix(80, 1.50, 0.8));\n\nvar cool = cubehelixLong(cubehelix(260, 0.75, 0.35), cubehelix(80, 1.50, 0.8));\n\nvar rainbow = cubehelix();\n\nvar rainbow$1 = function(t) {\n if (t < 0 || t > 1) t -= Math.floor(t);\n var ts = Math.abs(t - 0.5);\n rainbow.h = 360 * t - 100;\n rainbow.s = 1.5 - 1.5 * ts;\n rainbow.l = 0.8 - 0.9 * ts;\n return rainbow + \"\";\n};\n\nfunction ramp(range) {\n var n = range.length;\n return function(t) {\n return range[Math.max(0, Math.min(n - 1, Math.floor(t * n)))];\n };\n}\n\nvar viridis = ramp(colors(\"44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725\"));\n\nvar magma = ramp(colors(\"00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf\"));\n\nvar inferno = ramp(colors(\"00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4\"));\n\nvar plasma = ramp(colors(\"0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921\"));\n\nfunction sequential(interpolator) {\n var x0 = 0,\n x1 = 1,\n clamp = false;\n\n function scale(x) {\n var t = (x - x0) / (x1 - x0);\n return interpolator(clamp ? Math.max(0, Math.min(1, t)) : t);\n }\n\n scale.domain = function(_) {\n return arguments.length ? (x0 = +_[0], x1 = +_[1], scale) : [x0, x1];\n };\n\n scale.clamp = function(_) {\n return arguments.length ? (clamp = !!_, scale) : clamp;\n };\n\n scale.interpolator = function(_) {\n return arguments.length ? (interpolator = _, scale) : interpolator;\n };\n\n scale.copy = function() {\n return sequential(interpolator).domain([x0, x1]).clamp(clamp);\n };\n\n return linearish(scale);\n}\n\nvar constant$10 = function(x) {\n return function constant() {\n return x;\n };\n};\n\nvar epsilon$3 = 1e-12;\nvar pi$4 = Math.PI;\nvar halfPi$3 = pi$4 / 2;\nvar tau$4 = 2 * pi$4;\n\nfunction arcInnerRadius(d) {\n return d.innerRadius;\n}\n\nfunction arcOuterRadius(d) {\n return d.outerRadius;\n}\n\nfunction arcStartAngle(d) {\n return d.startAngle;\n}\n\nfunction arcEndAngle(d) {\n return d.endAngle;\n}\n\nfunction arcPadAngle(d) {\n return d && d.padAngle; // Note: optional!\n}\n\nfunction asin$1(x) {\n return x >= 1 ? halfPi$3 : x <= -1 ? -halfPi$3 : Math.asin(x);\n}\n\nfunction intersect(x0, y0, x1, y1, x2, y2, x3, y3) {\n var x10 = x1 - x0, y10 = y1 - y0,\n x32 = x3 - x2, y32 = y3 - y2,\n t = (x32 * (y0 - y2) - y32 * (x0 - x2)) / (y32 * x10 - x32 * y10);\n return [x0 + t * x10, y0 + t * y10];\n}\n\n// Compute perpendicular offset line of length rc.\n// http://mathworld.wolfram.com/Circle-LineIntersection.html\nfunction cornerTangents(x0, y0, x1, y1, r1, rc, cw) {\n var x01 = x0 - x1,\n y01 = y0 - y1,\n lo = (cw ? rc : -rc) / Math.sqrt(x01 * x01 + y01 * y01),\n ox = lo * y01,\n oy = -lo * x01,\n x11 = x0 + ox,\n y11 = y0 + oy,\n x10 = x1 + ox,\n y10 = y1 + oy,\n x00 = (x11 + x10) / 2,\n y00 = (y11 + y10) / 2,\n dx = x10 - x11,\n dy = y10 - y11,\n d2 = dx * dx + dy * dy,\n r = r1 - rc,\n D = x11 * y10 - x10 * y11,\n d = (dy < 0 ? -1 : 1) * Math.sqrt(Math.max(0, r * r * d2 - D * D)),\n cx0 = (D * dy - dx * d) / d2,\n cy0 = (-D * dx - dy * d) / d2,\n cx1 = (D * dy + dx * d) / d2,\n cy1 = (-D * dx + dy * d) / d2,\n dx0 = cx0 - x00,\n dy0 = cy0 - y00,\n dx1 = cx1 - x00,\n dy1 = cy1 - y00;\n\n // Pick the closer of the two intersection points.\n // TODO Is there a faster way to determine which intersection to use?\n if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) cx0 = cx1, cy0 = cy1;\n\n return {\n cx: cx0,\n cy: cy0,\n x01: -ox,\n y01: -oy,\n x11: cx0 * (r1 / r - 1),\n y11: cy0 * (r1 / r - 1)\n };\n}\n\nvar arc = function() {\n var innerRadius = arcInnerRadius,\n outerRadius = arcOuterRadius,\n cornerRadius = constant$10(0),\n padRadius = null,\n startAngle = arcStartAngle,\n endAngle = arcEndAngle,\n padAngle = arcPadAngle,\n context = null;\n\n function arc() {\n var buffer,\n r,\n r0 = +innerRadius.apply(this, arguments),\n r1 = +outerRadius.apply(this, arguments),\n a0 = startAngle.apply(this, arguments) - halfPi$3,\n a1 = endAngle.apply(this, arguments) - halfPi$3,\n da = Math.abs(a1 - a0),\n cw = a1 > a0;\n\n if (!context) context = buffer = path();\n\n // Ensure that the outer radius is always larger than the inner radius.\n if (r1 < r0) r = r1, r1 = r0, r0 = r;\n\n // Is it a point?\n if (!(r1 > epsilon$3)) context.moveTo(0, 0);\n\n // Or is it a circle or annulus?\n else if (da > tau$4 - epsilon$3) {\n context.moveTo(r1 * Math.cos(a0), r1 * Math.sin(a0));\n context.arc(0, 0, r1, a0, a1, !cw);\n if (r0 > epsilon$3) {\n context.moveTo(r0 * Math.cos(a1), r0 * Math.sin(a1));\n context.arc(0, 0, r0, a1, a0, cw);\n }\n }\n\n // Or is it a circular or annular sector?\n else {\n var a01 = a0,\n a11 = a1,\n a00 = a0,\n a10 = a1,\n da0 = da,\n da1 = da,\n ap = padAngle.apply(this, arguments) / 2,\n rp = (ap > epsilon$3) && (padRadius ? +padRadius.apply(this, arguments) : Math.sqrt(r0 * r0 + r1 * r1)),\n rc = Math.min(Math.abs(r1 - r0) / 2, +cornerRadius.apply(this, arguments)),\n rc0 = rc,\n rc1 = rc,\n t0,\n t1;\n\n // Apply padding? Note that since r1 ≥ r0, da1 ≥ da0.\n if (rp > epsilon$3) {\n var p0 = asin$1(rp / r0 * Math.sin(ap)),\n p1 = asin$1(rp / r1 * Math.sin(ap));\n if ((da0 -= p0 * 2) > epsilon$3) p0 *= (cw ? 1 : -1), a00 += p0, a10 -= p0;\n else da0 = 0, a00 = a10 = (a0 + a1) / 2;\n if ((da1 -= p1 * 2) > epsilon$3) p1 *= (cw ? 1 : -1), a01 += p1, a11 -= p1;\n else da1 = 0, a01 = a11 = (a0 + a1) / 2;\n }\n\n var x01 = r1 * Math.cos(a01),\n y01 = r1 * Math.sin(a01),\n x10 = r0 * Math.cos(a10),\n y10 = r0 * Math.sin(a10);\n\n // Apply rounded corners?\n if (rc > epsilon$3) {\n var x11 = r1 * Math.cos(a11),\n y11 = r1 * Math.sin(a11),\n x00 = r0 * Math.cos(a00),\n y00 = r0 * Math.sin(a00);\n\n // Restrict the corner radius according to the sector angle.\n if (da < pi$4) {\n var oc = da0 > epsilon$3 ? intersect(x01, y01, x00, y00, x11, y11, x10, y10) : [x10, y10],\n ax = x01 - oc[0],\n ay = y01 - oc[1],\n bx = x11 - oc[0],\n by = y11 - oc[1],\n kc = 1 / Math.sin(Math.acos((ax * bx + ay * by) / (Math.sqrt(ax * ax + ay * ay) * Math.sqrt(bx * bx + by * by))) / 2),\n lc = Math.sqrt(oc[0] * oc[0] + oc[1] * oc[1]);\n rc0 = Math.min(rc, (r0 - lc) / (kc - 1));\n rc1 = Math.min(rc, (r1 - lc) / (kc + 1));\n }\n }\n\n // Is the sector collapsed to a line?\n if (!(da1 > epsilon$3)) context.moveTo(x01, y01);\n\n // Does the sector’s outer ring have rounded corners?\n else if (rc1 > epsilon$3) {\n t0 = cornerTangents(x00, y00, x01, y01, r1, rc1, cw);\n t1 = cornerTangents(x11, y11, x10, y10, r1, rc1, cw);\n\n context.moveTo(t0.cx + t0.x01, t0.cy + t0.y01);\n\n // Have the corners merged?\n if (rc1 < rc) context.arc(t0.cx, t0.cy, rc1, Math.atan2(t0.y01, t0.x01), Math.atan2(t1.y01, t1.x01), !cw);\n\n // Otherwise, draw the two corners and the ring.\n else {\n context.arc(t0.cx, t0.cy, rc1, Math.atan2(t0.y01, t0.x01), Math.atan2(t0.y11, t0.x11), !cw);\n context.arc(0, 0, r1, Math.atan2(t0.cy + t0.y11, t0.cx + t0.x11), Math.atan2(t1.cy + t1.y11, t1.cx + t1.x11), !cw);\n context.arc(t1.cx, t1.cy, rc1, Math.atan2(t1.y11, t1.x11), Math.atan2(t1.y01, t1.x01), !cw);\n }\n }\n\n // Or is the outer ring just a circular arc?\n else context.moveTo(x01, y01), context.arc(0, 0, r1, a01, a11, !cw);\n\n // Is there no inner ring, and it’s a circular sector?\n // Or perhaps it’s an annular sector collapsed due to padding?\n if (!(r0 > epsilon$3) || !(da0 > epsilon$3)) context.lineTo(x10, y10);\n\n // Does the sector’s inner ring (or point) have rounded corners?\n else if (rc0 > epsilon$3) {\n t0 = cornerTangents(x10, y10, x11, y11, r0, -rc0, cw);\n t1 = cornerTangents(x01, y01, x00, y00, r0, -rc0, cw);\n\n context.lineTo(t0.cx + t0.x01, t0.cy + t0.y01);\n\n // Have the corners merged?\n if (rc0 < rc) context.arc(t0.cx, t0.cy, rc0, Math.atan2(t0.y01, t0.x01), Math.atan2(t1.y01, t1.x01), !cw);\n\n // Otherwise, draw the two corners and the ring.\n else {\n context.arc(t0.cx, t0.cy, rc0, Math.atan2(t0.y01, t0.x01), Math.atan2(t0.y11, t0.x11), !cw);\n context.arc(0, 0, r0, Math.atan2(t0.cy + t0.y11, t0.cx + t0.x11), Math.atan2(t1.cy + t1.y11, t1.cx + t1.x11), cw);\n context.arc(t1.cx, t1.cy, rc0, Math.atan2(t1.y11, t1.x11), Math.atan2(t1.y01, t1.x01), !cw);\n }\n }\n\n // Or is the inner ring just a circular arc?\n else context.arc(0, 0, r0, a10, a00, cw);\n }\n\n context.closePath();\n\n if (buffer) return context = null, buffer + \"\" || null;\n }\n\n arc.centroid = function() {\n var r = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2,\n a = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - pi$4 / 2;\n return [Math.cos(a) * r, Math.sin(a) * r];\n };\n\n arc.innerRadius = function(_) {\n return arguments.length ? (innerRadius = typeof _ === \"function\" ? _ : constant$10(+_), arc) : innerRadius;\n };\n\n arc.outerRadius = function(_) {\n return arguments.length ? (outerRadius = typeof _ === \"function\" ? _ : constant$10(+_), arc) : outerRadius;\n };\n\n arc.cornerRadius = function(_) {\n return arguments.length ? (cornerRadius = typeof _ === \"function\" ? _ : constant$10(+_), arc) : cornerRadius;\n };\n\n arc.padRadius = function(_) {\n return arguments.length ? (padRadius = _ == null ? null : typeof _ === \"function\" ? _ : constant$10(+_), arc) : padRadius;\n };\n\n arc.startAngle = function(_) {\n return arguments.length ? (startAngle = typeof _ === \"function\" ? _ : constant$10(+_), arc) : startAngle;\n };\n\n arc.endAngle = function(_) {\n return arguments.length ? (endAngle = typeof _ === \"function\" ? _ : constant$10(+_), arc) : endAngle;\n };\n\n arc.padAngle = function(_) {\n return arguments.length ? (padAngle = typeof _ === \"function\" ? _ : constant$10(+_), arc) : padAngle;\n };\n\n arc.context = function(_) {\n return arguments.length ? ((context = _ == null ? null : _), arc) : context;\n };\n\n return arc;\n};\n\nfunction Linear(context) {\n this._context = context;\n}\n\nLinear.prototype = {\n areaStart: function() {\n this._line = 0;\n },\n areaEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._point = 0;\n },\n lineEnd: function() {\n if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n this._line = 1 - this._line;\n },\n point: function(x, y) {\n x = +x, y = +y;\n switch (this._point) {\n case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n case 1: this._point = 2; // proceed\n default: this._context.lineTo(x, y); break;\n }\n }\n};\n\nvar curveLinear = function(context) {\n return new Linear(context);\n};\n\nfunction x$3(p) {\n return p[0];\n}\n\nfunction y$3(p) {\n return p[1];\n}\n\nvar line = function() {\n var x$$1 = x$3,\n y$$1 = y$3,\n defined = constant$10(true),\n context = null,\n curve = curveLinear,\n output = null;\n\n function line(data) {\n var i,\n n = data.length,\n d,\n defined0 = false,\n buffer;\n\n if (context == null) output = curve(buffer = path());\n\n for (i = 0; i <= n; ++i) {\n if (!(i < n && defined(d = data[i], i, data)) === defined0) {\n if (defined0 = !defined0) output.lineStart();\n else output.lineEnd();\n }\n if (defined0) output.point(+x$$1(d, i, data), +y$$1(d, i, data));\n }\n\n if (buffer) return output = null, buffer + \"\" || null;\n }\n\n line.x = function(_) {\n return arguments.length ? (x$$1 = typeof _ === \"function\" ? _ : constant$10(+_), line) : x$$1;\n };\n\n line.y = function(_) {\n return arguments.length ? (y$$1 = typeof _ === \"function\" ? _ : constant$10(+_), line) : y$$1;\n };\n\n line.defined = function(_) {\n return arguments.length ? (defined = typeof _ === \"function\" ? _ : constant$10(!!_), line) : defined;\n };\n\n line.curve = function(_) {\n return arguments.length ? (curve = _, context != null && (output = curve(context)), line) : curve;\n };\n\n line.context = function(_) {\n return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), line) : context;\n };\n\n return line;\n};\n\nvar area$2 = function() {\n var x0 = x$3,\n x1 = null,\n y0 = constant$10(0),\n y1 = y$3,\n defined = constant$10(true),\n context = null,\n curve = curveLinear,\n output = null;\n\n function area(data) {\n var i,\n j,\n k,\n n = data.length,\n d,\n defined0 = false,\n buffer,\n x0z = new Array(n),\n y0z = new Array(n);\n\n if (context == null) output = curve(buffer = path());\n\n for (i = 0; i <= n; ++i) {\n if (!(i < n && defined(d = data[i], i, data)) === defined0) {\n if (defined0 = !defined0) {\n j = i;\n output.areaStart();\n output.lineStart();\n } else {\n output.lineEnd();\n output.lineStart();\n for (k = i - 1; k >= j; --k) {\n output.point(x0z[k], y0z[k]);\n }\n output.lineEnd();\n output.areaEnd();\n }\n }\n if (defined0) {\n x0z[i] = +x0(d, i, data), y0z[i] = +y0(d, i, data);\n output.point(x1 ? +x1(d, i, data) : x0z[i], y1 ? +y1(d, i, data) : y0z[i]);\n }\n }\n\n if (buffer) return output = null, buffer + \"\" || null;\n }\n\n function arealine() {\n return line().defined(defined).curve(curve).context(context);\n }\n\n area.x = function(_) {\n return arguments.length ? (x0 = typeof _ === \"function\" ? _ : constant$10(+_), x1 = null, area) : x0;\n };\n\n area.x0 = function(_) {\n return arguments.length ? (x0 = typeof _ === \"function\" ? _ : constant$10(+_), area) : x0;\n };\n\n area.x1 = function(_) {\n return arguments.length ? (x1 = _ == null ? null : typeof _ === \"function\" ? _ : constant$10(+_), area) : x1;\n };\n\n area.y = function(_) {\n return arguments.length ? (y0 = typeof _ === \"function\" ? _ : constant$10(+_), y1 = null, area) : y0;\n };\n\n area.y0 = function(_) {\n return arguments.length ? (y0 = typeof _ === \"function\" ? _ : constant$10(+_), area) : y0;\n };\n\n area.y1 = function(_) {\n return arguments.length ? (y1 = _ == null ? null : typeof _ === \"function\" ? _ : constant$10(+_), area) : y1;\n };\n\n area.lineX0 =\n area.lineY0 = function() {\n return arealine().x(x0).y(y0);\n };\n\n area.lineY1 = function() {\n return arealine().x(x0).y(y1);\n };\n\n area.lineX1 = function() {\n return arealine().x(x1).y(y0);\n };\n\n area.defined = function(_) {\n return arguments.length ? (defined = typeof _ === \"function\" ? _ : constant$10(!!_), area) : defined;\n };\n\n area.curve = function(_) {\n return arguments.length ? (curve = _, context != null && (output = curve(context)), area) : curve;\n };\n\n area.context = function(_) {\n return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), area) : context;\n };\n\n return area;\n};\n\nvar descending$1 = function(a, b) {\n return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;\n};\n\nvar identity$7 = function(d) {\n return d;\n};\n\nvar pie = function() {\n var value = identity$7,\n sortValues = descending$1,\n sort = null,\n startAngle = constant$10(0),\n endAngle = constant$10(tau$4),\n padAngle = constant$10(0);\n\n function pie(data) {\n var i,\n n = data.length,\n j,\n k,\n sum = 0,\n index = new Array(n),\n arcs = new Array(n),\n a0 = +startAngle.apply(this, arguments),\n da = Math.min(tau$4, Math.max(-tau$4, endAngle.apply(this, arguments) - a0)),\n a1,\n p = Math.min(Math.abs(da) / n, padAngle.apply(this, arguments)),\n pa = p * (da < 0 ? -1 : 1),\n v;\n\n for (i = 0; i < n; ++i) {\n if ((v = arcs[index[i] = i] = +value(data[i], i, data)) > 0) {\n sum += v;\n }\n }\n\n // Optionally sort the arcs by previously-computed values or by data.\n if (sortValues != null) index.sort(function(i, j) { return sortValues(arcs[i], arcs[j]); });\n else if (sort != null) index.sort(function(i, j) { return sort(data[i], data[j]); });\n\n // Compute the arcs! They are stored in the original data's order.\n for (i = 0, k = sum ? (da - n * pa) / sum : 0; i < n; ++i, a0 = a1) {\n j = index[i], v = arcs[j], a1 = a0 + (v > 0 ? v * k : 0) + pa, arcs[j] = {\n data: data[j],\n index: i,\n value: v,\n startAngle: a0,\n endAngle: a1,\n padAngle: p\n };\n }\n\n return arcs;\n }\n\n pie.value = function(_) {\n return arguments.length ? (value = typeof _ === \"function\" ? _ : constant$10(+_), pie) : value;\n };\n\n pie.sortValues = function(_) {\n return arguments.length ? (sortValues = _, sort = null, pie) : sortValues;\n };\n\n pie.sort = function(_) {\n return arguments.length ? (sort = _, sortValues = null, pie) : sort;\n };\n\n pie.startAngle = function(_) {\n return arguments.length ? (startAngle = typeof _ === \"function\" ? _ : constant$10(+_), pie) : startAngle;\n };\n\n pie.endAngle = function(_) {\n return arguments.length ? (endAngle = typeof _ === \"function\" ? _ : constant$10(+_), pie) : endAngle;\n };\n\n pie.padAngle = function(_) {\n return arguments.length ? (padAngle = typeof _ === \"function\" ? _ : constant$10(+_), pie) : padAngle;\n };\n\n return pie;\n};\n\nvar curveRadialLinear = curveRadial(curveLinear);\n\nfunction Radial(curve) {\n this._curve = curve;\n}\n\nRadial.prototype = {\n areaStart: function() {\n this._curve.areaStart();\n },\n areaEnd: function() {\n this._curve.areaEnd();\n },\n lineStart: function() {\n this._curve.lineStart();\n },\n lineEnd: function() {\n this._curve.lineEnd();\n },\n point: function(a, r) {\n this._curve.point(r * Math.sin(a), r * -Math.cos(a));\n }\n};\n\nfunction curveRadial(curve) {\n\n function radial(context) {\n return new Radial(curve(context));\n }\n\n radial._curve = curve;\n\n return radial;\n}\n\nfunction radialLine(l) {\n var c = l.curve;\n\n l.angle = l.x, delete l.x;\n l.radius = l.y, delete l.y;\n\n l.curve = function(_) {\n return arguments.length ? c(curveRadial(_)) : c()._curve;\n };\n\n return l;\n}\n\nvar radialLine$1 = function() {\n return radialLine(line().curve(curveRadialLinear));\n};\n\nvar radialArea = function() {\n var a = area$2().curve(curveRadialLinear),\n c = a.curve,\n x0 = a.lineX0,\n x1 = a.lineX1,\n y0 = a.lineY0,\n y1 = a.lineY1;\n\n a.angle = a.x, delete a.x;\n a.startAngle = a.x0, delete a.x0;\n a.endAngle = a.x1, delete a.x1;\n a.radius = a.y, delete a.y;\n a.innerRadius = a.y0, delete a.y0;\n a.outerRadius = a.y1, delete a.y1;\n a.lineStartAngle = function() { return radialLine(x0()); }, delete a.lineX0;\n a.lineEndAngle = function() { return radialLine(x1()); }, delete a.lineX1;\n a.lineInnerRadius = function() { return radialLine(y0()); }, delete a.lineY0;\n a.lineOuterRadius = function() { return radialLine(y1()); }, delete a.lineY1;\n\n a.curve = function(_) {\n return arguments.length ? c(curveRadial(_)) : c()._curve;\n };\n\n return a;\n};\n\nvar circle$2 = {\n draw: function(context, size) {\n var r = Math.sqrt(size / pi$4);\n context.moveTo(r, 0);\n context.arc(0, 0, r, 0, tau$4);\n }\n};\n\nvar cross$1 = {\n draw: function(context, size) {\n var r = Math.sqrt(size / 5) / 2;\n context.moveTo(-3 * r, -r);\n context.lineTo(-r, -r);\n context.lineTo(-r, -3 * r);\n context.lineTo(r, -3 * r);\n context.lineTo(r, -r);\n context.lineTo(3 * r, -r);\n context.lineTo(3 * r, r);\n context.lineTo(r, r);\n context.lineTo(r, 3 * r);\n context.lineTo(-r, 3 * r);\n context.lineTo(-r, r);\n context.lineTo(-3 * r, r);\n context.closePath();\n }\n};\n\nvar tan30 = Math.sqrt(1 / 3);\nvar tan30_2 = tan30 * 2;\n\nvar diamond = {\n draw: function(context, size) {\n var y = Math.sqrt(size / tan30_2),\n x = y * tan30;\n context.moveTo(0, -y);\n context.lineTo(x, 0);\n context.lineTo(0, y);\n context.lineTo(-x, 0);\n context.closePath();\n }\n};\n\nvar ka = 0.89081309152928522810;\nvar kr = Math.sin(pi$4 / 10) / Math.sin(7 * pi$4 / 10);\nvar kx = Math.sin(tau$4 / 10) * kr;\nvar ky = -Math.cos(tau$4 / 10) * kr;\n\nvar star = {\n draw: function(context, size) {\n var r = Math.sqrt(size * ka),\n x = kx * r,\n y = ky * r;\n context.moveTo(0, -r);\n context.lineTo(x, y);\n for (var i = 1; i < 5; ++i) {\n var a = tau$4 * i / 5,\n c = Math.cos(a),\n s = Math.sin(a);\n context.lineTo(s * r, -c * r);\n context.lineTo(c * x - s * y, s * x + c * y);\n }\n context.closePath();\n }\n};\n\nvar square = {\n draw: function(context, size) {\n var w = Math.sqrt(size),\n x = -w / 2;\n context.rect(x, x, w, w);\n }\n};\n\nvar sqrt3 = Math.sqrt(3);\n\nvar triangle = {\n draw: function(context, size) {\n var y = -Math.sqrt(size / (sqrt3 * 3));\n context.moveTo(0, y * 2);\n context.lineTo(-sqrt3 * y, -y);\n context.lineTo(sqrt3 * y, -y);\n context.closePath();\n }\n};\n\nvar c = -0.5;\nvar s = Math.sqrt(3) / 2;\nvar k = 1 / Math.sqrt(12);\nvar a = (k / 2 + 1) * 3;\n\nvar wye = {\n draw: function(context, size) {\n var r = Math.sqrt(size / a),\n x0 = r / 2,\n y0 = r * k,\n x1 = x0,\n y1 = r * k + r,\n x2 = -x1,\n y2 = y1;\n context.moveTo(x0, y0);\n context.lineTo(x1, y1);\n context.lineTo(x2, y2);\n context.lineTo(c * x0 - s * y0, s * x0 + c * y0);\n context.lineTo(c * x1 - s * y1, s * x1 + c * y1);\n context.lineTo(c * x2 - s * y2, s * x2 + c * y2);\n context.lineTo(c * x0 + s * y0, c * y0 - s * x0);\n context.lineTo(c * x1 + s * y1, c * y1 - s * x1);\n context.lineTo(c * x2 + s * y2, c * y2 - s * x2);\n context.closePath();\n }\n};\n\nvar symbols = [\n circle$2,\n cross$1,\n diamond,\n square,\n star,\n triangle,\n wye\n];\n\nvar symbol = function() {\n var type = constant$10(circle$2),\n size = constant$10(64),\n context = null;\n\n function symbol() {\n var buffer;\n if (!context) context = buffer = path();\n type.apply(this, arguments).draw(context, +size.apply(this, arguments));\n if (buffer) return context = null, buffer + \"\" || null;\n }\n\n symbol.type = function(_) {\n return arguments.length ? (type = typeof _ === \"function\" ? _ : constant$10(_), symbol) : type;\n };\n\n symbol.size = function(_) {\n return arguments.length ? (size = typeof _ === \"function\" ? _ : constant$10(+_), symbol) : size;\n };\n\n symbol.context = function(_) {\n return arguments.length ? (context = _ == null ? null : _, symbol) : context;\n };\n\n return symbol;\n};\n\nvar noop$2 = function() {};\n\nfunction point$2(that, x, y) {\n that._context.bezierCurveTo(\n (2 * that._x0 + that._x1) / 3,\n (2 * that._y0 + that._y1) / 3,\n (that._x0 + 2 * that._x1) / 3,\n (that._y0 + 2 * that._y1) / 3,\n (that._x0 + 4 * that._x1 + x) / 6,\n (that._y0 + 4 * that._y1 + y) / 6\n );\n}\n\nfunction Basis(context) {\n this._context = context;\n}\n\nBasis.prototype = {\n areaStart: function() {\n this._line = 0;\n },\n areaEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._x0 = this._x1 =\n this._y0 = this._y1 = NaN;\n this._point = 0;\n },\n lineEnd: function() {\n switch (this._point) {\n case 3: point$2(this, this._x1, this._y1); // proceed\n case 2: this._context.lineTo(this._x1, this._y1); break;\n }\n if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n this._line = 1 - this._line;\n },\n point: function(x, y) {\n x = +x, y = +y;\n switch (this._point) {\n case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n case 1: this._point = 2; break;\n case 2: this._point = 3; this._context.lineTo((5 * this._x0 + this._x1) / 6, (5 * this._y0 + this._y1) / 6); // proceed\n default: point$2(this, x, y); break;\n }\n this._x0 = this._x1, this._x1 = x;\n this._y0 = this._y1, this._y1 = y;\n }\n};\n\nvar basis$2 = function(context) {\n return new Basis(context);\n};\n\nfunction BasisClosed(context) {\n this._context = context;\n}\n\nBasisClosed.prototype = {\n areaStart: noop$2,\n areaEnd: noop$2,\n lineStart: function() {\n this._x0 = this._x1 = this._x2 = this._x3 = this._x4 =\n this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = NaN;\n this._point = 0;\n },\n lineEnd: function() {\n switch (this._point) {\n case 1: {\n this._context.moveTo(this._x2, this._y2);\n this._context.closePath();\n break;\n }\n case 2: {\n this._context.moveTo((this._x2 + 2 * this._x3) / 3, (this._y2 + 2 * this._y3) / 3);\n this._context.lineTo((this._x3 + 2 * this._x2) / 3, (this._y3 + 2 * this._y2) / 3);\n this._context.closePath();\n break;\n }\n case 3: {\n this.point(this._x2, this._y2);\n this.point(this._x3, this._y3);\n this.point(this._x4, this._y4);\n break;\n }\n }\n },\n point: function(x, y) {\n x = +x, y = +y;\n switch (this._point) {\n case 0: this._point = 1; this._x2 = x, this._y2 = y; break;\n case 1: this._point = 2; this._x3 = x, this._y3 = y; break;\n case 2: this._point = 3; this._x4 = x, this._y4 = y; this._context.moveTo((this._x0 + 4 * this._x1 + x) / 6, (this._y0 + 4 * this._y1 + y) / 6); break;\n default: point$2(this, x, y); break;\n }\n this._x0 = this._x1, this._x1 = x;\n this._y0 = this._y1, this._y1 = y;\n }\n};\n\nvar basisClosed$1 = function(context) {\n return new BasisClosed(context);\n};\n\nfunction BasisOpen(context) {\n this._context = context;\n}\n\nBasisOpen.prototype = {\n areaStart: function() {\n this._line = 0;\n },\n areaEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._x0 = this._x1 =\n this._y0 = this._y1 = NaN;\n this._point = 0;\n },\n lineEnd: function() {\n if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath();\n this._line = 1 - this._line;\n },\n point: function(x, y) {\n x = +x, y = +y;\n switch (this._point) {\n case 0: this._point = 1; break;\n case 1: this._point = 2; break;\n case 2: this._point = 3; var x0 = (this._x0 + 4 * this._x1 + x) / 6, y0 = (this._y0 + 4 * this._y1 + y) / 6; this._line ? this._context.lineTo(x0, y0) : this._context.moveTo(x0, y0); break;\n case 3: this._point = 4; // proceed\n default: point$2(this, x, y); break;\n }\n this._x0 = this._x1, this._x1 = x;\n this._y0 = this._y1, this._y1 = y;\n }\n};\n\nvar basisOpen = function(context) {\n return new BasisOpen(context);\n};\n\nfunction Bundle(context, beta) {\n this._basis = new Basis(context);\n this._beta = beta;\n}\n\nBundle.prototype = {\n lineStart: function() {\n this._x = [];\n this._y = [];\n this._basis.lineStart();\n },\n lineEnd: function() {\n var x = this._x,\n y = this._y,\n j = x.length - 1;\n\n if (j > 0) {\n var x0 = x[0],\n y0 = y[0],\n dx = x[j] - x0,\n dy = y[j] - y0,\n i = -1,\n t;\n\n while (++i <= j) {\n t = i / j;\n this._basis.point(\n this._beta * x[i] + (1 - this._beta) * (x0 + t * dx),\n this._beta * y[i] + (1 - this._beta) * (y0 + t * dy)\n );\n }\n }\n\n this._x = this._y = null;\n this._basis.lineEnd();\n },\n point: function(x, y) {\n this._x.push(+x);\n this._y.push(+y);\n }\n};\n\nvar bundle = ((function custom(beta) {\n\n function bundle(context) {\n return beta === 1 ? new Basis(context) : new Bundle(context, beta);\n }\n\n bundle.beta = function(beta) {\n return custom(+beta);\n };\n\n return bundle;\n}))(0.85);\n\nfunction point$3(that, x, y) {\n that._context.bezierCurveTo(\n that._x1 + that._k * (that._x2 - that._x0),\n that._y1 + that._k * (that._y2 - that._y0),\n that._x2 + that._k * (that._x1 - x),\n that._y2 + that._k * (that._y1 - y),\n that._x2,\n that._y2\n );\n}\n\nfunction Cardinal(context, tension) {\n this._context = context;\n this._k = (1 - tension) / 6;\n}\n\nCardinal.prototype = {\n areaStart: function() {\n this._line = 0;\n },\n areaEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._x0 = this._x1 = this._x2 =\n this._y0 = this._y1 = this._y2 = NaN;\n this._point = 0;\n },\n lineEnd: function() {\n switch (this._point) {\n case 2: this._context.lineTo(this._x2, this._y2); break;\n case 3: point$3(this, this._x1, this._y1); break;\n }\n if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n this._line = 1 - this._line;\n },\n point: function(x, y) {\n x = +x, y = +y;\n switch (this._point) {\n case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n case 1: this._point = 2; this._x1 = x, this._y1 = y; break;\n case 2: this._point = 3; // proceed\n default: point$3(this, x, y); break;\n }\n this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n }\n};\n\nvar cardinal = ((function custom(tension) {\n\n function cardinal(context) {\n return new Cardinal(context, tension);\n }\n\n cardinal.tension = function(tension) {\n return custom(+tension);\n };\n\n return cardinal;\n}))(0);\n\nfunction CardinalClosed(context, tension) {\n this._context = context;\n this._k = (1 - tension) / 6;\n}\n\nCardinalClosed.prototype = {\n areaStart: noop$2,\n areaEnd: noop$2,\n lineStart: function() {\n this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 =\n this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN;\n this._point = 0;\n },\n lineEnd: function() {\n switch (this._point) {\n case 1: {\n this._context.moveTo(this._x3, this._y3);\n this._context.closePath();\n break;\n }\n case 2: {\n this._context.lineTo(this._x3, this._y3);\n this._context.closePath();\n break;\n }\n case 3: {\n this.point(this._x3, this._y3);\n this.point(this._x4, this._y4);\n this.point(this._x5, this._y5);\n break;\n }\n }\n },\n point: function(x, y) {\n x = +x, y = +y;\n switch (this._point) {\n case 0: this._point = 1; this._x3 = x, this._y3 = y; break;\n case 1: this._point = 2; this._context.moveTo(this._x4 = x, this._y4 = y); break;\n case 2: this._point = 3; this._x5 = x, this._y5 = y; break;\n default: point$3(this, x, y); break;\n }\n this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n }\n};\n\nvar cardinalClosed = ((function custom(tension) {\n\n function cardinal(context) {\n return new CardinalClosed(context, tension);\n }\n\n cardinal.tension = function(tension) {\n return custom(+tension);\n };\n\n return cardinal;\n}))(0);\n\nfunction CardinalOpen(context, tension) {\n this._context = context;\n this._k = (1 - tension) / 6;\n}\n\nCardinalOpen.prototype = {\n areaStart: function() {\n this._line = 0;\n },\n areaEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._x0 = this._x1 = this._x2 =\n this._y0 = this._y1 = this._y2 = NaN;\n this._point = 0;\n },\n lineEnd: function() {\n if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath();\n this._line = 1 - this._line;\n },\n point: function(x, y) {\n x = +x, y = +y;\n switch (this._point) {\n case 0: this._point = 1; break;\n case 1: this._point = 2; break;\n case 2: this._point = 3; this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2); break;\n case 3: this._point = 4; // proceed\n default: point$3(this, x, y); break;\n }\n this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n }\n};\n\nvar cardinalOpen = ((function custom(tension) {\n\n function cardinal(context) {\n return new CardinalOpen(context, tension);\n }\n\n cardinal.tension = function(tension) {\n return custom(+tension);\n };\n\n return cardinal;\n}))(0);\n\nfunction point$4(that, x, y) {\n var x1 = that._x1,\n y1 = that._y1,\n x2 = that._x2,\n y2 = that._y2;\n\n if (that._l01_a > epsilon$3) {\n var a = 2 * that._l01_2a + 3 * that._l01_a * that._l12_a + that._l12_2a,\n n = 3 * that._l01_a * (that._l01_a + that._l12_a);\n x1 = (x1 * a - that._x0 * that._l12_2a + that._x2 * that._l01_2a) / n;\n y1 = (y1 * a - that._y0 * that._l12_2a + that._y2 * that._l01_2a) / n;\n }\n\n if (that._l23_a > epsilon$3) {\n var b = 2 * that._l23_2a + 3 * that._l23_a * that._l12_a + that._l12_2a,\n m = 3 * that._l23_a * (that._l23_a + that._l12_a);\n x2 = (x2 * b + that._x1 * that._l23_2a - x * that._l12_2a) / m;\n y2 = (y2 * b + that._y1 * that._l23_2a - y * that._l12_2a) / m;\n }\n\n that._context.bezierCurveTo(x1, y1, x2, y2, that._x2, that._y2);\n}\n\nfunction CatmullRom(context, alpha) {\n this._context = context;\n this._alpha = alpha;\n}\n\nCatmullRom.prototype = {\n areaStart: function() {\n this._line = 0;\n },\n areaEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._x0 = this._x1 = this._x2 =\n this._y0 = this._y1 = this._y2 = NaN;\n this._l01_a = this._l12_a = this._l23_a =\n this._l01_2a = this._l12_2a = this._l23_2a =\n this._point = 0;\n },\n lineEnd: function() {\n switch (this._point) {\n case 2: this._context.lineTo(this._x2, this._y2); break;\n case 3: this.point(this._x2, this._y2); break;\n }\n if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n this._line = 1 - this._line;\n },\n point: function(x, y) {\n x = +x, y = +y;\n\n if (this._point) {\n var x23 = this._x2 - x,\n y23 = this._y2 - y;\n this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));\n }\n\n switch (this._point) {\n case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n case 1: this._point = 2; break;\n case 2: this._point = 3; // proceed\n default: point$4(this, x, y); break;\n }\n\n this._l01_a = this._l12_a, this._l12_a = this._l23_a;\n this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;\n this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n }\n};\n\nvar catmullRom = ((function custom(alpha) {\n\n function catmullRom(context) {\n return alpha ? new CatmullRom(context, alpha) : new Cardinal(context, 0);\n }\n\n catmullRom.alpha = function(alpha) {\n return custom(+alpha);\n };\n\n return catmullRom;\n}))(0.5);\n\nfunction CatmullRomClosed(context, alpha) {\n this._context = context;\n this._alpha = alpha;\n}\n\nCatmullRomClosed.prototype = {\n areaStart: noop$2,\n areaEnd: noop$2,\n lineStart: function() {\n this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 =\n this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN;\n this._l01_a = this._l12_a = this._l23_a =\n this._l01_2a = this._l12_2a = this._l23_2a =\n this._point = 0;\n },\n lineEnd: function() {\n switch (this._point) {\n case 1: {\n this._context.moveTo(this._x3, this._y3);\n this._context.closePath();\n break;\n }\n case 2: {\n this._context.lineTo(this._x3, this._y3);\n this._context.closePath();\n break;\n }\n case 3: {\n this.point(this._x3, this._y3);\n this.point(this._x4, this._y4);\n this.point(this._x5, this._y5);\n break;\n }\n }\n },\n point: function(x, y) {\n x = +x, y = +y;\n\n if (this._point) {\n var x23 = this._x2 - x,\n y23 = this._y2 - y;\n this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));\n }\n\n switch (this._point) {\n case 0: this._point = 1; this._x3 = x, this._y3 = y; break;\n case 1: this._point = 2; this._context.moveTo(this._x4 = x, this._y4 = y); break;\n case 2: this._point = 3; this._x5 = x, this._y5 = y; break;\n default: point$4(this, x, y); break;\n }\n\n this._l01_a = this._l12_a, this._l12_a = this._l23_a;\n this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;\n this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n }\n};\n\nvar catmullRomClosed = ((function custom(alpha) {\n\n function catmullRom(context) {\n return alpha ? new CatmullRomClosed(context, alpha) : new CardinalClosed(context, 0);\n }\n\n catmullRom.alpha = function(alpha) {\n return custom(+alpha);\n };\n\n return catmullRom;\n}))(0.5);\n\nfunction CatmullRomOpen(context, alpha) {\n this._context = context;\n this._alpha = alpha;\n}\n\nCatmullRomOpen.prototype = {\n areaStart: function() {\n this._line = 0;\n },\n areaEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._x0 = this._x1 = this._x2 =\n this._y0 = this._y1 = this._y2 = NaN;\n this._l01_a = this._l12_a = this._l23_a =\n this._l01_2a = this._l12_2a = this._l23_2a =\n this._point = 0;\n },\n lineEnd: function() {\n if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath();\n this._line = 1 - this._line;\n },\n point: function(x, y) {\n x = +x, y = +y;\n\n if (this._point) {\n var x23 = this._x2 - x,\n y23 = this._y2 - y;\n this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));\n }\n\n switch (this._point) {\n case 0: this._point = 1; break;\n case 1: this._point = 2; break;\n case 2: this._point = 3; this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2); break;\n case 3: this._point = 4; // proceed\n default: point$4(this, x, y); break;\n }\n\n this._l01_a = this._l12_a, this._l12_a = this._l23_a;\n this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;\n this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n }\n};\n\nvar catmullRomOpen = ((function custom(alpha) {\n\n function catmullRom(context) {\n return alpha ? new CatmullRomOpen(context, alpha) : new CardinalOpen(context, 0);\n }\n\n catmullRom.alpha = function(alpha) {\n return custom(+alpha);\n };\n\n return catmullRom;\n}))(0.5);\n\nfunction LinearClosed(context) {\n this._context = context;\n}\n\nLinearClosed.prototype = {\n areaStart: noop$2,\n areaEnd: noop$2,\n lineStart: function() {\n this._point = 0;\n },\n lineEnd: function() {\n if (this._point) this._context.closePath();\n },\n point: function(x, y) {\n x = +x, y = +y;\n if (this._point) this._context.lineTo(x, y);\n else this._point = 1, this._context.moveTo(x, y);\n }\n};\n\nvar linearClosed = function(context) {\n return new LinearClosed(context);\n};\n\nfunction sign$1(x) {\n return x < 0 ? -1 : 1;\n}\n\n// Calculate the slopes of the tangents (Hermite-type interpolation) based on\n// the following paper: Steffen, M. 1990. A Simple Method for Monotonic\n// Interpolation in One Dimension. Astronomy and Astrophysics, Vol. 239, NO.\n// NOV(II), P. 443, 1990.\nfunction slope3(that, x2, y2) {\n var h0 = that._x1 - that._x0,\n h1 = x2 - that._x1,\n s0 = (that._y1 - that._y0) / (h0 || h1 < 0 && -0),\n s1 = (y2 - that._y1) / (h1 || h0 < 0 && -0),\n p = (s0 * h1 + s1 * h0) / (h0 + h1);\n return (sign$1(s0) + sign$1(s1)) * Math.min(Math.abs(s0), Math.abs(s1), 0.5 * Math.abs(p)) || 0;\n}\n\n// Calculate a one-sided slope.\nfunction slope2(that, t) {\n var h = that._x1 - that._x0;\n return h ? (3 * (that._y1 - that._y0) / h - t) / 2 : t;\n}\n\n// According to https://en.wikipedia.org/wiki/Cubic_Hermite_spline#Representations\n// \"you can express cubic Hermite interpolation in terms of cubic Bézier curves\n// with respect to the four values p0, p0 + m0 / 3, p1 - m1 / 3, p1\".\nfunction point$5(that, t0, t1) {\n var x0 = that._x0,\n y0 = that._y0,\n x1 = that._x1,\n y1 = that._y1,\n dx = (x1 - x0) / 3;\n that._context.bezierCurveTo(x0 + dx, y0 + dx * t0, x1 - dx, y1 - dx * t1, x1, y1);\n}\n\nfunction MonotoneX(context) {\n this._context = context;\n}\n\nMonotoneX.prototype = {\n areaStart: function() {\n this._line = 0;\n },\n areaEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._x0 = this._x1 =\n this._y0 = this._y1 =\n this._t0 = NaN;\n this._point = 0;\n },\n lineEnd: function() {\n switch (this._point) {\n case 2: this._context.lineTo(this._x1, this._y1); break;\n case 3: point$5(this, this._t0, slope2(this, this._t0)); break;\n }\n if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n this._line = 1 - this._line;\n },\n point: function(x, y) {\n var t1 = NaN;\n\n x = +x, y = +y;\n if (x === this._x1 && y === this._y1) return; // Ignore coincident points.\n switch (this._point) {\n case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n case 1: this._point = 2; break;\n case 2: this._point = 3; point$5(this, slope2(this, t1 = slope3(this, x, y)), t1); break;\n default: point$5(this, this._t0, t1 = slope3(this, x, y)); break;\n }\n\n this._x0 = this._x1, this._x1 = x;\n this._y0 = this._y1, this._y1 = y;\n this._t0 = t1;\n }\n};\n\nfunction MonotoneY(context) {\n this._context = new ReflectContext(context);\n}\n\n(MonotoneY.prototype = Object.create(MonotoneX.prototype)).point = function(x, y) {\n MonotoneX.prototype.point.call(this, y, x);\n};\n\nfunction ReflectContext(context) {\n this._context = context;\n}\n\nReflectContext.prototype = {\n moveTo: function(x, y) { this._context.moveTo(y, x); },\n closePath: function() { this._context.closePath(); },\n lineTo: function(x, y) { this._context.lineTo(y, x); },\n bezierCurveTo: function(x1, y1, x2, y2, x, y) { this._context.bezierCurveTo(y1, x1, y2, x2, y, x); }\n};\n\nfunction monotoneX(context) {\n return new MonotoneX(context);\n}\n\nfunction monotoneY(context) {\n return new MonotoneY(context);\n}\n\nfunction Natural(context) {\n this._context = context;\n}\n\nNatural.prototype = {\n areaStart: function() {\n this._line = 0;\n },\n areaEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._x = [];\n this._y = [];\n },\n lineEnd: function() {\n var x = this._x,\n y = this._y,\n n = x.length;\n\n if (n) {\n this._line ? this._context.lineTo(x[0], y[0]) : this._context.moveTo(x[0], y[0]);\n if (n === 2) {\n this._context.lineTo(x[1], y[1]);\n } else {\n var px = controlPoints(x),\n py = controlPoints(y);\n for (var i0 = 0, i1 = 1; i1 < n; ++i0, ++i1) {\n this._context.bezierCurveTo(px[0][i0], py[0][i0], px[1][i0], py[1][i0], x[i1], y[i1]);\n }\n }\n }\n\n if (this._line || (this._line !== 0 && n === 1)) this._context.closePath();\n this._line = 1 - this._line;\n this._x = this._y = null;\n },\n point: function(x, y) {\n this._x.push(+x);\n this._y.push(+y);\n }\n};\n\n// See https://www.particleincell.com/2012/bezier-splines/ for derivation.\nfunction controlPoints(x) {\n var i,\n n = x.length - 1,\n m,\n a = new Array(n),\n b = new Array(n),\n r = new Array(n);\n a[0] = 0, b[0] = 2, r[0] = x[0] + 2 * x[1];\n for (i = 1; i < n - 1; ++i) a[i] = 1, b[i] = 4, r[i] = 4 * x[i] + 2 * x[i + 1];\n a[n - 1] = 2, b[n - 1] = 7, r[n - 1] = 8 * x[n - 1] + x[n];\n for (i = 1; i < n; ++i) m = a[i] / b[i - 1], b[i] -= m, r[i] -= m * r[i - 1];\n a[n - 1] = r[n - 1] / b[n - 1];\n for (i = n - 2; i >= 0; --i) a[i] = (r[i] - a[i + 1]) / b[i];\n b[n - 1] = (x[n] + a[n - 1]) / 2;\n for (i = 0; i < n - 1; ++i) b[i] = 2 * x[i + 1] - a[i + 1];\n return [a, b];\n}\n\nvar natural = function(context) {\n return new Natural(context);\n};\n\nfunction Step(context, t) {\n this._context = context;\n this._t = t;\n}\n\nStep.prototype = {\n areaStart: function() {\n this._line = 0;\n },\n areaEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._x = this._y = NaN;\n this._point = 0;\n },\n lineEnd: function() {\n if (0 < this._t && this._t < 1 && this._point === 2) this._context.lineTo(this._x, this._y);\n if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n if (this._line >= 0) this._t = 1 - this._t, this._line = 1 - this._line;\n },\n point: function(x, y) {\n x = +x, y = +y;\n switch (this._point) {\n case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n case 1: this._point = 2; // proceed\n default: {\n if (this._t <= 0) {\n this._context.lineTo(this._x, y);\n this._context.lineTo(x, y);\n } else {\n var x1 = this._x * (1 - this._t) + x * this._t;\n this._context.lineTo(x1, this._y);\n this._context.lineTo(x1, y);\n }\n break;\n }\n }\n this._x = x, this._y = y;\n }\n};\n\nvar step = function(context) {\n return new Step(context, 0.5);\n};\n\nfunction stepBefore(context) {\n return new Step(context, 0);\n}\n\nfunction stepAfter(context) {\n return new Step(context, 1);\n}\n\nvar slice$5 = Array.prototype.slice;\n\nvar none$1 = function(series, order) {\n if (!((n = series.length) > 1)) return;\n for (var i = 1, s0, s1 = series[order[0]], n, m = s1.length; i < n; ++i) {\n s0 = s1, s1 = series[order[i]];\n for (var j = 0; j < m; ++j) {\n s1[j][1] += s1[j][0] = isNaN(s0[j][1]) ? s0[j][0] : s0[j][1];\n }\n }\n};\n\nvar none$2 = function(series) {\n var n = series.length, o = new Array(n);\n while (--n >= 0) o[n] = n;\n return o;\n};\n\nfunction stackValue(d, key) {\n return d[key];\n}\n\nvar stack = function() {\n var keys = constant$10([]),\n order = none$2,\n offset = none$1,\n value = stackValue;\n\n function stack(data) {\n var kz = keys.apply(this, arguments),\n i,\n m = data.length,\n n = kz.length,\n sz = new Array(n),\n oz;\n\n for (i = 0; i < n; ++i) {\n for (var ki = kz[i], si = sz[i] = new Array(m), j = 0, sij; j < m; ++j) {\n si[j] = sij = [0, +value(data[j], ki, j, data)];\n sij.data = data[j];\n }\n si.key = ki;\n }\n\n for (i = 0, oz = order(sz); i < n; ++i) {\n sz[oz[i]].index = i;\n }\n\n offset(sz, oz);\n return sz;\n }\n\n stack.keys = function(_) {\n return arguments.length ? (keys = typeof _ === \"function\" ? _ : constant$10(slice$5.call(_)), stack) : keys;\n };\n\n stack.value = function(_) {\n return arguments.length ? (value = typeof _ === \"function\" ? _ : constant$10(+_), stack) : value;\n };\n\n stack.order = function(_) {\n return arguments.length ? (order = _ == null ? none$2 : typeof _ === \"function\" ? _ : constant$10(slice$5.call(_)), stack) : order;\n };\n\n stack.offset = function(_) {\n return arguments.length ? (offset = _ == null ? none$1 : _, stack) : offset;\n };\n\n return stack;\n};\n\nvar expand = function(series, order) {\n if (!((n = series.length) > 0)) return;\n for (var i, n, j = 0, m = series[0].length, y; j < m; ++j) {\n for (y = i = 0; i < n; ++i) y += series[i][j][1] || 0;\n if (y) for (i = 0; i < n; ++i) series[i][j][1] /= y;\n }\n none$1(series, order);\n};\n\nvar silhouette = function(series, order) {\n if (!((n = series.length) > 0)) return;\n for (var j = 0, s0 = series[order[0]], n, m = s0.length; j < m; ++j) {\n for (var i = 0, y = 0; i < n; ++i) y += series[i][j][1] || 0;\n s0[j][1] += s0[j][0] = -y / 2;\n }\n none$1(series, order);\n};\n\nvar wiggle = function(series, order) {\n if (!((n = series.length) > 0) || !((m = (s0 = series[order[0]]).length) > 0)) return;\n for (var y = 0, j = 1, s0, m, n; j < m; ++j) {\n for (var i = 0, s1 = 0, s2 = 0; i < n; ++i) {\n var si = series[order[i]],\n sij0 = si[j][1] || 0,\n sij1 = si[j - 1][1] || 0,\n s3 = (sij0 - sij1) / 2;\n for (var k = 0; k < i; ++k) {\n var sk = series[order[k]],\n skj0 = sk[j][1] || 0,\n skj1 = sk[j - 1][1] || 0;\n s3 += skj0 - skj1;\n }\n s1 += sij0, s2 += s3 * sij0;\n }\n s0[j - 1][1] += s0[j - 1][0] = y;\n if (s1) y -= s2 / s1;\n }\n s0[j - 1][1] += s0[j - 1][0] = y;\n none$1(series, order);\n};\n\nvar ascending$2 = function(series) {\n var sums = series.map(sum$2);\n return none$2(series).sort(function(a, b) { return sums[a] - sums[b]; });\n};\n\nfunction sum$2(series) {\n var s = 0, i = -1, n = series.length, v;\n while (++i < n) if (v = +series[i][1]) s += v;\n return s;\n}\n\nvar descending$2 = function(series) {\n return ascending$2(series).reverse();\n};\n\nvar insideOut = function(series) {\n var n = series.length,\n i,\n j,\n sums = series.map(sum$2),\n order = none$2(series).sort(function(a, b) { return sums[b] - sums[a]; }),\n top = 0,\n bottom = 0,\n tops = [],\n bottoms = [];\n\n for (i = 0; i < n; ++i) {\n j = order[i];\n if (top < bottom) {\n top += sums[j];\n tops.push(j);\n } else {\n bottom += sums[j];\n bottoms.push(j);\n }\n }\n\n return bottoms.reverse().concat(tops);\n};\n\nvar reverse = function(series) {\n return none$2(series).reverse();\n};\n\nvar constant$11 = function(x) {\n return function() {\n return x;\n };\n};\n\nfunction x$4(d) {\n return d[0];\n}\n\nfunction y$4(d) {\n return d[1];\n}\n\nfunction RedBlackTree() {\n this._ = null; // root node\n}\n\nfunction RedBlackNode(node) {\n node.U = // parent node\n node.C = // color - true for red, false for black\n node.L = // left node\n node.R = // right node\n node.P = // previous node\n node.N = null; // next node\n}\n\nRedBlackTree.prototype = {\n constructor: RedBlackTree,\n\n insert: function(after, node) {\n var parent, grandpa, uncle;\n\n if (after) {\n node.P = after;\n node.N = after.N;\n if (after.N) after.N.P = node;\n after.N = node;\n if (after.R) {\n after = after.R;\n while (after.L) after = after.L;\n after.L = node;\n } else {\n after.R = node;\n }\n parent = after;\n } else if (this._) {\n after = RedBlackFirst(this._);\n node.P = null;\n node.N = after;\n after.P = after.L = node;\n parent = after;\n } else {\n node.P = node.N = null;\n this._ = node;\n parent = null;\n }\n node.L = node.R = null;\n node.U = parent;\n node.C = true;\n\n after = node;\n while (parent && parent.C) {\n grandpa = parent.U;\n if (parent === grandpa.L) {\n uncle = grandpa.R;\n if (uncle && uncle.C) {\n parent.C = uncle.C = false;\n grandpa.C = true;\n after = grandpa;\n } else {\n if (after === parent.R) {\n RedBlackRotateLeft(this, parent);\n after = parent;\n parent = after.U;\n }\n parent.C = false;\n grandpa.C = true;\n RedBlackRotateRight(this, grandpa);\n }\n } else {\n uncle = grandpa.L;\n if (uncle && uncle.C) {\n parent.C = uncle.C = false;\n grandpa.C = true;\n after = grandpa;\n } else {\n if (after === parent.L) {\n RedBlackRotateRight(this, parent);\n after = parent;\n parent = after.U;\n }\n parent.C = false;\n grandpa.C = true;\n RedBlackRotateLeft(this, grandpa);\n }\n }\n parent = after.U;\n }\n this._.C = false;\n },\n\n remove: function(node) {\n if (node.N) node.N.P = node.P;\n if (node.P) node.P.N = node.N;\n node.N = node.P = null;\n\n var parent = node.U,\n sibling,\n left = node.L,\n right = node.R,\n next,\n red;\n\n if (!left) next = right;\n else if (!right) next = left;\n else next = RedBlackFirst(right);\n\n if (parent) {\n if (parent.L === node) parent.L = next;\n else parent.R = next;\n } else {\n this._ = next;\n }\n\n if (left && right) {\n red = next.C;\n next.C = node.C;\n next.L = left;\n left.U = next;\n if (next !== right) {\n parent = next.U;\n next.U = node.U;\n node = next.R;\n parent.L = node;\n next.R = right;\n right.U = next;\n } else {\n next.U = parent;\n parent = next;\n node = next.R;\n }\n } else {\n red = node.C;\n node = next;\n }\n\n if (node) node.U = parent;\n if (red) return;\n if (node && node.C) { node.C = false; return; }\n\n do {\n if (node === this._) break;\n if (node === parent.L) {\n sibling = parent.R;\n if (sibling.C) {\n sibling.C = false;\n parent.C = true;\n RedBlackRotateLeft(this, parent);\n sibling = parent.R;\n }\n if ((sibling.L && sibling.L.C)\n || (sibling.R && sibling.R.C)) {\n if (!sibling.R || !sibling.R.C) {\n sibling.L.C = false;\n sibling.C = true;\n RedBlackRotateRight(this, sibling);\n sibling = parent.R;\n }\n sibling.C = parent.C;\n parent.C = sibling.R.C = false;\n RedBlackRotateLeft(this, parent);\n node = this._;\n break;\n }\n } else {\n sibling = parent.L;\n if (sibling.C) {\n sibling.C = false;\n parent.C = true;\n RedBlackRotateRight(this, parent);\n sibling = parent.L;\n }\n if ((sibling.L && sibling.L.C)\n || (sibling.R && sibling.R.C)) {\n if (!sibling.L || !sibling.L.C) {\n sibling.R.C = false;\n sibling.C = true;\n RedBlackRotateLeft(this, sibling);\n sibling = parent.L;\n }\n sibling.C = parent.C;\n parent.C = sibling.L.C = false;\n RedBlackRotateRight(this, parent);\n node = this._;\n break;\n }\n }\n sibling.C = true;\n node = parent;\n parent = parent.U;\n } while (!node.C);\n\n if (node) node.C = false;\n }\n};\n\nfunction RedBlackRotateLeft(tree, node) {\n var p = node,\n q = node.R,\n parent = p.U;\n\n if (parent) {\n if (parent.L === p) parent.L = q;\n else parent.R = q;\n } else {\n tree._ = q;\n }\n\n q.U = parent;\n p.U = q;\n p.R = q.L;\n if (p.R) p.R.U = p;\n q.L = p;\n}\n\nfunction RedBlackRotateRight(tree, node) {\n var p = node,\n q = node.L,\n parent = p.U;\n\n if (parent) {\n if (parent.L === p) parent.L = q;\n else parent.R = q;\n } else {\n tree._ = q;\n }\n\n q.U = parent;\n p.U = q;\n p.L = q.R;\n if (p.L) p.L.U = p;\n q.R = p;\n}\n\nfunction RedBlackFirst(node) {\n while (node.L) node = node.L;\n return node;\n}\n\nfunction createEdge(left, right, v0, v1) {\n var edge = [null, null],\n index = edges.push(edge) - 1;\n edge.left = left;\n edge.right = right;\n if (v0) setEdgeEnd(edge, left, right, v0);\n if (v1) setEdgeEnd(edge, right, left, v1);\n cells[left.index].halfedges.push(index);\n cells[right.index].halfedges.push(index);\n return edge;\n}\n\nfunction createBorderEdge(left, v0, v1) {\n var edge = [v0, v1];\n edge.left = left;\n return edge;\n}\n\nfunction setEdgeEnd(edge, left, right, vertex) {\n if (!edge[0] && !edge[1]) {\n edge[0] = vertex;\n edge.left = left;\n edge.right = right;\n } else if (edge.left === right) {\n edge[1] = vertex;\n } else {\n edge[0] = vertex;\n }\n}\n\n// Liang–Barsky line clipping.\nfunction clipEdge(edge, x0, y0, x1, y1) {\n var a = edge[0],\n b = edge[1],\n ax = a[0],\n ay = a[1],\n bx = b[0],\n by = b[1],\n t0 = 0,\n t1 = 1,\n dx = bx - ax,\n dy = by - ay,\n r;\n\n r = x0 - ax;\n if (!dx && r > 0) return;\n r /= dx;\n if (dx < 0) {\n if (r < t0) return;\n if (r < t1) t1 = r;\n } else if (dx > 0) {\n if (r > t1) return;\n if (r > t0) t0 = r;\n }\n\n r = x1 - ax;\n if (!dx && r < 0) return;\n r /= dx;\n if (dx < 0) {\n if (r > t1) return;\n if (r > t0) t0 = r;\n } else if (dx > 0) {\n if (r < t0) return;\n if (r < t1) t1 = r;\n }\n\n r = y0 - ay;\n if (!dy && r > 0) return;\n r /= dy;\n if (dy < 0) {\n if (r < t0) return;\n if (r < t1) t1 = r;\n } else if (dy > 0) {\n if (r > t1) return;\n if (r > t0) t0 = r;\n }\n\n r = y1 - ay;\n if (!dy && r < 0) return;\n r /= dy;\n if (dy < 0) {\n if (r > t1) return;\n if (r > t0) t0 = r;\n } else if (dy > 0) {\n if (r < t0) return;\n if (r < t1) t1 = r;\n }\n\n if (!(t0 > 0) && !(t1 < 1)) return true; // TODO Better check?\n\n if (t0 > 0) edge[0] = [ax + t0 * dx, ay + t0 * dy];\n if (t1 < 1) edge[1] = [ax + t1 * dx, ay + t1 * dy];\n return true;\n}\n\nfunction connectEdge(edge, x0, y0, x1, y1) {\n var v1 = edge[1];\n if (v1) return true;\n\n var v0 = edge[0],\n left = edge.left,\n right = edge.right,\n lx = left[0],\n ly = left[1],\n rx = right[0],\n ry = right[1],\n fx = (lx + rx) / 2,\n fy = (ly + ry) / 2,\n fm,\n fb;\n\n if (ry === ly) {\n if (fx < x0 || fx >= x1) return;\n if (lx > rx) {\n if (!v0) v0 = [fx, y0];\n else if (v0[1] >= y1) return;\n v1 = [fx, y1];\n } else {\n if (!v0) v0 = [fx, y1];\n else if (v0[1] < y0) return;\n v1 = [fx, y0];\n }\n } else {\n fm = (lx - rx) / (ry - ly);\n fb = fy - fm * fx;\n if (fm < -1 || fm > 1) {\n if (lx > rx) {\n if (!v0) v0 = [(y0 - fb) / fm, y0];\n else if (v0[1] >= y1) return;\n v1 = [(y1 - fb) / fm, y1];\n } else {\n if (!v0) v0 = [(y1 - fb) / fm, y1];\n else if (v0[1] < y0) return;\n v1 = [(y0 - fb) / fm, y0];\n }\n } else {\n if (ly < ry) {\n if (!v0) v0 = [x0, fm * x0 + fb];\n else if (v0[0] >= x1) return;\n v1 = [x1, fm * x1 + fb];\n } else {\n if (!v0) v0 = [x1, fm * x1 + fb];\n else if (v0[0] < x0) return;\n v1 = [x0, fm * x0 + fb];\n }\n }\n }\n\n edge[0] = v0;\n edge[1] = v1;\n return true;\n}\n\nfunction clipEdges(x0, y0, x1, y1) {\n var i = edges.length,\n edge;\n\n while (i--) {\n if (!connectEdge(edge = edges[i], x0, y0, x1, y1)\n || !clipEdge(edge, x0, y0, x1, y1)\n || !(Math.abs(edge[0][0] - edge[1][0]) > epsilon$4\n || Math.abs(edge[0][1] - edge[1][1]) > epsilon$4)) {\n delete edges[i];\n }\n }\n}\n\nfunction createCell(site) {\n return cells[site.index] = {\n site: site,\n halfedges: []\n };\n}\n\nfunction cellHalfedgeAngle(cell, edge) {\n var site = cell.site,\n va = edge.left,\n vb = edge.right;\n if (site === vb) vb = va, va = site;\n if (vb) return Math.atan2(vb[1] - va[1], vb[0] - va[0]);\n if (site === va) va = edge[1], vb = edge[0];\n else va = edge[0], vb = edge[1];\n return Math.atan2(va[0] - vb[0], vb[1] - va[1]);\n}\n\nfunction cellHalfedgeStart(cell, edge) {\n return edge[+(edge.left !== cell.site)];\n}\n\nfunction cellHalfedgeEnd(cell, edge) {\n return edge[+(edge.left === cell.site)];\n}\n\nfunction sortCellHalfedges() {\n for (var i = 0, n = cells.length, cell, halfedges, j, m; i < n; ++i) {\n if ((cell = cells[i]) && (m = (halfedges = cell.halfedges).length)) {\n var index = new Array(m),\n array = new Array(m);\n for (j = 0; j < m; ++j) index[j] = j, array[j] = cellHalfedgeAngle(cell, edges[halfedges[j]]);\n index.sort(function(i, j) { return array[j] - array[i]; });\n for (j = 0; j < m; ++j) array[j] = halfedges[index[j]];\n for (j = 0; j < m; ++j) halfedges[j] = array[j];\n }\n }\n}\n\nfunction clipCells(x0, y0, x1, y1) {\n var nCells = cells.length,\n iCell,\n cell,\n site,\n iHalfedge,\n halfedges,\n nHalfedges,\n start,\n startX,\n startY,\n end,\n endX,\n endY,\n cover = true;\n\n for (iCell = 0; iCell < nCells; ++iCell) {\n if (cell = cells[iCell]) {\n site = cell.site;\n halfedges = cell.halfedges;\n iHalfedge = halfedges.length;\n\n // Remove any dangling clipped edges.\n while (iHalfedge--) {\n if (!edges[halfedges[iHalfedge]]) {\n halfedges.splice(iHalfedge, 1);\n }\n }\n\n // Insert any border edges as necessary.\n iHalfedge = 0, nHalfedges = halfedges.length;\n while (iHalfedge < nHalfedges) {\n end = cellHalfedgeEnd(cell, edges[halfedges[iHalfedge]]), endX = end[0], endY = end[1];\n start = cellHalfedgeStart(cell, edges[halfedges[++iHalfedge % nHalfedges]]), startX = start[0], startY = start[1];\n if (Math.abs(endX - startX) > epsilon$4 || Math.abs(endY - startY) > epsilon$4) {\n halfedges.splice(iHalfedge, 0, edges.push(createBorderEdge(site, end,\n Math.abs(endX - x0) < epsilon$4 && y1 - endY > epsilon$4 ? [x0, Math.abs(startX - x0) < epsilon$4 ? startY : y1]\n : Math.abs(endY - y1) < epsilon$4 && x1 - endX > epsilon$4 ? [Math.abs(startY - y1) < epsilon$4 ? startX : x1, y1]\n : Math.abs(endX - x1) < epsilon$4 && endY - y0 > epsilon$4 ? [x1, Math.abs(startX - x1) < epsilon$4 ? startY : y0]\n : Math.abs(endY - y0) < epsilon$4 && endX - x0 > epsilon$4 ? [Math.abs(startY - y0) < epsilon$4 ? startX : x0, y0]\n : null)) - 1);\n ++nHalfedges;\n }\n }\n\n if (nHalfedges) cover = false;\n }\n }\n\n // If there weren’t any edges, have the closest site cover the extent.\n // It doesn’t matter which corner of the extent we measure!\n if (cover) {\n var dx, dy, d2, dc = Infinity;\n\n for (iCell = 0, cover = null; iCell < nCells; ++iCell) {\n if (cell = cells[iCell]) {\n site = cell.site;\n dx = site[0] - x0;\n dy = site[1] - y0;\n d2 = dx * dx + dy * dy;\n if (d2 < dc) dc = d2, cover = cell;\n }\n }\n\n if (cover) {\n var v00 = [x0, y0], v01 = [x0, y1], v11 = [x1, y1], v10 = [x1, y0];\n cover.halfedges.push(\n edges.push(createBorderEdge(site = cover.site, v00, v01)) - 1,\n edges.push(createBorderEdge(site, v01, v11)) - 1,\n edges.push(createBorderEdge(site, v11, v10)) - 1,\n edges.push(createBorderEdge(site, v10, v00)) - 1\n );\n }\n }\n\n // Lastly delete any cells with no edges; these were entirely clipped.\n for (iCell = 0; iCell < nCells; ++iCell) {\n if (cell = cells[iCell]) {\n if (!cell.halfedges.length) {\n delete cells[iCell];\n }\n }\n }\n}\n\nvar circlePool = [];\n\nvar firstCircle;\n\nfunction Circle() {\n RedBlackNode(this);\n this.x =\n this.y =\n this.arc =\n this.site =\n this.cy = null;\n}\n\nfunction attachCircle(arc) {\n var lArc = arc.P,\n rArc = arc.N;\n\n if (!lArc || !rArc) return;\n\n var lSite = lArc.site,\n cSite = arc.site,\n rSite = rArc.site;\n\n if (lSite === rSite) return;\n\n var bx = cSite[0],\n by = cSite[1],\n ax = lSite[0] - bx,\n ay = lSite[1] - by,\n cx = rSite[0] - bx,\n cy = rSite[1] - by;\n\n var d = 2 * (ax * cy - ay * cx);\n if (d >= -epsilon2$2) return;\n\n var ha = ax * ax + ay * ay,\n hc = cx * cx + cy * cy,\n x = (cy * ha - ay * hc) / d,\n y = (ax * hc - cx * ha) / d;\n\n var circle = circlePool.pop() || new Circle;\n circle.arc = arc;\n circle.site = cSite;\n circle.x = x + bx;\n circle.y = (circle.cy = y + by) + Math.sqrt(x * x + y * y); // y bottom\n\n arc.circle = circle;\n\n var before = null,\n node = circles._;\n\n while (node) {\n if (circle.y < node.y || (circle.y === node.y && circle.x <= node.x)) {\n if (node.L) node = node.L;\n else { before = node.P; break; }\n } else {\n if (node.R) node = node.R;\n else { before = node; break; }\n }\n }\n\n circles.insert(before, circle);\n if (!before) firstCircle = circle;\n}\n\nfunction detachCircle(arc) {\n var circle = arc.circle;\n if (circle) {\n if (!circle.P) firstCircle = circle.N;\n circles.remove(circle);\n circlePool.push(circle);\n RedBlackNode(circle);\n arc.circle = null;\n }\n}\n\nvar beachPool = [];\n\nfunction Beach() {\n RedBlackNode(this);\n this.edge =\n this.site =\n this.circle = null;\n}\n\nfunction createBeach(site) {\n var beach = beachPool.pop() || new Beach;\n beach.site = site;\n return beach;\n}\n\nfunction detachBeach(beach) {\n detachCircle(beach);\n beaches.remove(beach);\n beachPool.push(beach);\n RedBlackNode(beach);\n}\n\nfunction removeBeach(beach) {\n var circle = beach.circle,\n x = circle.x,\n y = circle.cy,\n vertex = [x, y],\n previous = beach.P,\n next = beach.N,\n disappearing = [beach];\n\n detachBeach(beach);\n\n var lArc = previous;\n while (lArc.circle\n && Math.abs(x - lArc.circle.x) < epsilon$4\n && Math.abs(y - lArc.circle.cy) < epsilon$4) {\n previous = lArc.P;\n disappearing.unshift(lArc);\n detachBeach(lArc);\n lArc = previous;\n }\n\n disappearing.unshift(lArc);\n detachCircle(lArc);\n\n var rArc = next;\n while (rArc.circle\n && Math.abs(x - rArc.circle.x) < epsilon$4\n && Math.abs(y - rArc.circle.cy) < epsilon$4) {\n next = rArc.N;\n disappearing.push(rArc);\n detachBeach(rArc);\n rArc = next;\n }\n\n disappearing.push(rArc);\n detachCircle(rArc);\n\n var nArcs = disappearing.length,\n iArc;\n for (iArc = 1; iArc < nArcs; ++iArc) {\n rArc = disappearing[iArc];\n lArc = disappearing[iArc - 1];\n setEdgeEnd(rArc.edge, lArc.site, rArc.site, vertex);\n }\n\n lArc = disappearing[0];\n rArc = disappearing[nArcs - 1];\n rArc.edge = createEdge(lArc.site, rArc.site, null, vertex);\n\n attachCircle(lArc);\n attachCircle(rArc);\n}\n\nfunction addBeach(site) {\n var x = site[0],\n directrix = site[1],\n lArc,\n rArc,\n dxl,\n dxr,\n node = beaches._;\n\n while (node) {\n dxl = leftBreakPoint(node, directrix) - x;\n if (dxl > epsilon$4) node = node.L; else {\n dxr = x - rightBreakPoint(node, directrix);\n if (dxr > epsilon$4) {\n if (!node.R) {\n lArc = node;\n break;\n }\n node = node.R;\n } else {\n if (dxl > -epsilon$4) {\n lArc = node.P;\n rArc = node;\n } else if (dxr > -epsilon$4) {\n lArc = node;\n rArc = node.N;\n } else {\n lArc = rArc = node;\n }\n break;\n }\n }\n }\n\n createCell(site);\n var newArc = createBeach(site);\n beaches.insert(lArc, newArc);\n\n if (!lArc && !rArc) return;\n\n if (lArc === rArc) {\n detachCircle(lArc);\n rArc = createBeach(lArc.site);\n beaches.insert(newArc, rArc);\n newArc.edge = rArc.edge = createEdge(lArc.site, newArc.site);\n attachCircle(lArc);\n attachCircle(rArc);\n return;\n }\n\n if (!rArc) { // && lArc\n newArc.edge = createEdge(lArc.site, newArc.site);\n return;\n }\n\n // else lArc !== rArc\n detachCircle(lArc);\n detachCircle(rArc);\n\n var lSite = lArc.site,\n ax = lSite[0],\n ay = lSite[1],\n bx = site[0] - ax,\n by = site[1] - ay,\n rSite = rArc.site,\n cx = rSite[0] - ax,\n cy = rSite[1] - ay,\n d = 2 * (bx * cy - by * cx),\n hb = bx * bx + by * by,\n hc = cx * cx + cy * cy,\n vertex = [(cy * hb - by * hc) / d + ax, (bx * hc - cx * hb) / d + ay];\n\n setEdgeEnd(rArc.edge, lSite, rSite, vertex);\n newArc.edge = createEdge(lSite, site, null, vertex);\n rArc.edge = createEdge(site, rSite, null, vertex);\n attachCircle(lArc);\n attachCircle(rArc);\n}\n\nfunction leftBreakPoint(arc, directrix) {\n var site = arc.site,\n rfocx = site[0],\n rfocy = site[1],\n pby2 = rfocy - directrix;\n\n if (!pby2) return rfocx;\n\n var lArc = arc.P;\n if (!lArc) return -Infinity;\n\n site = lArc.site;\n var lfocx = site[0],\n lfocy = site[1],\n plby2 = lfocy - directrix;\n\n if (!plby2) return lfocx;\n\n var hl = lfocx - rfocx,\n aby2 = 1 / pby2 - 1 / plby2,\n b = hl / plby2;\n\n if (aby2) return (-b + Math.sqrt(b * b - 2 * aby2 * (hl * hl / (-2 * plby2) - lfocy + plby2 / 2 + rfocy - pby2 / 2))) / aby2 + rfocx;\n\n return (rfocx + lfocx) / 2;\n}\n\nfunction rightBreakPoint(arc, directrix) {\n var rArc = arc.N;\n if (rArc) return leftBreakPoint(rArc, directrix);\n var site = arc.site;\n return site[1] === directrix ? site[0] : Infinity;\n}\n\nvar epsilon$4 = 1e-6;\nvar epsilon2$2 = 1e-12;\nvar beaches;\nvar cells;\nvar circles;\nvar edges;\n\nfunction triangleArea(a, b, c) {\n return (a[0] - c[0]) * (b[1] - a[1]) - (a[0] - b[0]) * (c[1] - a[1]);\n}\n\nfunction lexicographic(a, b) {\n return b[1] - a[1]\n || b[0] - a[0];\n}\n\nfunction Diagram(sites, extent) {\n var site = sites.sort(lexicographic).pop(),\n x,\n y,\n circle;\n\n edges = [];\n cells = new Array(sites.length);\n beaches = new RedBlackTree;\n circles = new RedBlackTree;\n\n while (true) {\n circle = firstCircle;\n if (site && (!circle || site[1] < circle.y || (site[1] === circle.y && site[0] < circle.x))) {\n if (site[0] !== x || site[1] !== y) {\n addBeach(site);\n x = site[0], y = site[1];\n }\n site = sites.pop();\n } else if (circle) {\n removeBeach(circle.arc);\n } else {\n break;\n }\n }\n\n sortCellHalfedges();\n\n if (extent) {\n var x0 = +extent[0][0],\n y0 = +extent[0][1],\n x1 = +extent[1][0],\n y1 = +extent[1][1];\n clipEdges(x0, y0, x1, y1);\n clipCells(x0, y0, x1, y1);\n }\n\n this.edges = edges;\n this.cells = cells;\n\n beaches =\n circles =\n edges =\n cells = null;\n}\n\nDiagram.prototype = {\n constructor: Diagram,\n\n polygons: function() {\n var edges = this.edges;\n\n return this.cells.map(function(cell) {\n var polygon = cell.halfedges.map(function(i) { return cellHalfedgeStart(cell, edges[i]); });\n polygon.data = cell.site.data;\n return polygon;\n });\n },\n\n triangles: function() {\n var triangles = [],\n edges = this.edges;\n\n this.cells.forEach(function(cell, i) {\n if (!(m = (halfedges = cell.halfedges).length)) return;\n var site = cell.site,\n halfedges,\n j = -1,\n m,\n s0,\n e1 = edges[halfedges[m - 1]],\n s1 = e1.left === site ? e1.right : e1.left;\n\n while (++j < m) {\n s0 = s1;\n e1 = edges[halfedges[j]];\n s1 = e1.left === site ? e1.right : e1.left;\n if (s0 && s1 && i < s0.index && i < s1.index && triangleArea(site, s0, s1) < 0) {\n triangles.push([site.data, s0.data, s1.data]);\n }\n }\n });\n\n return triangles;\n },\n\n links: function() {\n return this.edges.filter(function(edge) {\n return edge.right;\n }).map(function(edge) {\n return {\n source: edge.left.data,\n target: edge.right.data\n };\n });\n },\n\n find: function(x, y, radius) {\n var that = this, i0, i1 = that._found || 0, n = that.cells.length, cell;\n\n // Use the previously-found cell, or start with an arbitrary one.\n while (!(cell = that.cells[i1])) if (++i1 >= n) return null;\n var dx = x - cell.site[0], dy = y - cell.site[1], d2 = dx * dx + dy * dy;\n\n // Traverse the half-edges to find a closer cell, if any.\n do {\n cell = that.cells[i0 = i1], i1 = null;\n cell.halfedges.forEach(function(e) {\n var edge = that.edges[e], v = edge.left;\n if ((v === cell.site || !v) && !(v = edge.right)) return;\n var vx = x - v[0], vy = y - v[1], v2 = vx * vx + vy * vy;\n if (v2 < d2) d2 = v2, i1 = v.index;\n });\n } while (i1 !== null);\n\n that._found = i0;\n\n return radius == null || d2 <= radius * radius ? cell.site : null;\n }\n};\n\nvar voronoi = function() {\n var x$$1 = x$4,\n y$$1 = y$4,\n extent = null;\n\n function voronoi(data) {\n return new Diagram(data.map(function(d, i) {\n var s = [Math.round(x$$1(d, i, data) / epsilon$4) * epsilon$4, Math.round(y$$1(d, i, data) / epsilon$4) * epsilon$4];\n s.index = i;\n s.data = d;\n return s;\n }), extent);\n }\n\n voronoi.polygons = function(data) {\n return voronoi(data).polygons();\n };\n\n voronoi.links = function(data) {\n return voronoi(data).links();\n };\n\n voronoi.triangles = function(data) {\n return voronoi(data).triangles();\n };\n\n voronoi.x = function(_) {\n return arguments.length ? (x$$1 = typeof _ === \"function\" ? _ : constant$11(+_), voronoi) : x$$1;\n };\n\n voronoi.y = function(_) {\n return arguments.length ? (y$$1 = typeof _ === \"function\" ? _ : constant$11(+_), voronoi) : y$$1;\n };\n\n voronoi.extent = function(_) {\n return arguments.length ? (extent = _ == null ? null : [[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]], voronoi) : extent && [[extent[0][0], extent[0][1]], [extent[1][0], extent[1][1]]];\n };\n\n voronoi.size = function(_) {\n return arguments.length ? (extent = _ == null ? null : [[0, 0], [+_[0], +_[1]]], voronoi) : extent && [extent[1][0] - extent[0][0], extent[1][1] - extent[0][1]];\n };\n\n return voronoi;\n};\n\nvar constant$12 = function(x) {\n return function() {\n return x;\n };\n};\n\nfunction ZoomEvent(target, type, transform) {\n this.target = target;\n this.type = type;\n this.transform = transform;\n}\n\nfunction Transform(k, x, y) {\n this.k = k;\n this.x = x;\n this.y = y;\n}\n\nTransform.prototype = {\n constructor: Transform,\n scale: function(k) {\n return k === 1 ? this : new Transform(this.k * k, this.x, this.y);\n },\n translate: function(x, y) {\n return x === 0 & y === 0 ? this : new Transform(this.k, this.x + this.k * x, this.y + this.k * y);\n },\n apply: function(point) {\n return [point[0] * this.k + this.x, point[1] * this.k + this.y];\n },\n applyX: function(x) {\n return x * this.k + this.x;\n },\n applyY: function(y) {\n return y * this.k + this.y;\n },\n invert: function(location) {\n return [(location[0] - this.x) / this.k, (location[1] - this.y) / this.k];\n },\n invertX: function(x) {\n return (x - this.x) / this.k;\n },\n invertY: function(y) {\n return (y - this.y) / this.k;\n },\n rescaleX: function(x) {\n return x.copy().domain(x.range().map(this.invertX, this).map(x.invert, x));\n },\n rescaleY: function(y) {\n return y.copy().domain(y.range().map(this.invertY, this).map(y.invert, y));\n },\n toString: function() {\n return \"translate(\" + this.x + \",\" + this.y + \") scale(\" + this.k + \")\";\n }\n};\n\nvar identity$8 = new Transform(1, 0, 0);\n\ntransform$1.prototype = Transform.prototype;\n\nfunction transform$1(node) {\n return node.__zoom || identity$8;\n}\n\nfunction nopropagation$2() {\n exports.event.stopImmediatePropagation();\n}\n\nvar noevent$2 = function() {\n exports.event.preventDefault();\n exports.event.stopImmediatePropagation();\n};\n\n// Ignore right-click, since that should open the context menu.\nfunction defaultFilter$2() {\n return !exports.event.button;\n}\n\nfunction defaultExtent$1() {\n var e = this, w, h;\n if (e instanceof SVGElement) {\n e = e.ownerSVGElement || e;\n w = e.width.baseVal.value;\n h = e.height.baseVal.value;\n } else {\n w = e.clientWidth;\n h = e.clientHeight;\n }\n return [[0, 0], [w, h]];\n}\n\nfunction defaultTransform() {\n return this.__zoom || identity$8;\n}\n\nvar zoom = function() {\n var filter = defaultFilter$2,\n extent = defaultExtent$1,\n k0 = 0,\n k1 = Infinity,\n x0 = -k1,\n x1 = k1,\n y0 = x0,\n y1 = x1,\n duration = 250,\n interpolate$$1 = interpolateZoom,\n gestures = [],\n listeners = dispatch(\"start\", \"zoom\", \"end\"),\n touchstarting,\n touchending,\n touchDelay = 500,\n wheelDelay = 150;\n\n function zoom(selection$$1) {\n selection$$1\n .on(\"wheel.zoom\", wheeled)\n .on(\"mousedown.zoom\", mousedowned)\n .on(\"dblclick.zoom\", dblclicked)\n .on(\"touchstart.zoom\", touchstarted)\n .on(\"touchmove.zoom\", touchmoved)\n .on(\"touchend.zoom touchcancel.zoom\", touchended)\n .style(\"-webkit-tap-highlight-color\", \"rgba(0,0,0,0)\")\n .property(\"__zoom\", defaultTransform);\n }\n\n zoom.transform = function(collection, transform) {\n var selection$$1 = collection.selection ? collection.selection() : collection;\n selection$$1.property(\"__zoom\", defaultTransform);\n if (collection !== selection$$1) {\n schedule(collection, transform);\n } else {\n selection$$1.interrupt().each(function() {\n gesture(this, arguments)\n .start()\n .zoom(null, typeof transform === \"function\" ? transform.apply(this, arguments) : transform)\n .end();\n });\n }\n };\n\n zoom.scaleBy = function(selection$$1, k) {\n zoom.scaleTo(selection$$1, function() {\n var k0 = this.__zoom.k,\n k1 = typeof k === \"function\" ? k.apply(this, arguments) : k;\n return k0 * k1;\n });\n };\n\n zoom.scaleTo = function(selection$$1, k) {\n zoom.transform(selection$$1, function() {\n var e = extent.apply(this, arguments),\n t0 = this.__zoom,\n p0 = centroid(e),\n p1 = t0.invert(p0),\n k1 = typeof k === \"function\" ? k.apply(this, arguments) : k;\n return constrain(translate(scale(t0, k1), p0, p1), e);\n });\n };\n\n zoom.translateBy = function(selection$$1, x, y) {\n zoom.transform(selection$$1, function() {\n return constrain(this.__zoom.translate(\n typeof x === \"function\" ? x.apply(this, arguments) : x,\n typeof y === \"function\" ? y.apply(this, arguments) : y\n ), extent.apply(this, arguments));\n });\n };\n\n function scale(transform, k) {\n k = Math.max(k0, Math.min(k1, k));\n return k === transform.k ? transform : new Transform(k, transform.x, transform.y);\n }\n\n function translate(transform, p0, p1) {\n var x = p0[0] - p1[0] * transform.k, y = p0[1] - p1[1] * transform.k;\n return x === transform.x && y === transform.y ? transform : new Transform(transform.k, x, y);\n }\n\n function constrain(transform, extent) {\n var dx0 = transform.invertX(extent[0][0]) - x0,\n dx1 = transform.invertX(extent[1][0]) - x1,\n dy0 = transform.invertY(extent[0][1]) - y0,\n dy1 = transform.invertY(extent[1][1]) - y1;\n return transform.translate(\n dx1 > dx0 ? (dx0 + dx1) / 2 : Math.min(0, dx0) || Math.max(0, dx1),\n dy1 > dy0 ? (dy0 + dy1) / 2 : Math.min(0, dy0) || Math.max(0, dy1)\n );\n }\n\n function centroid(extent) {\n return [(+extent[0][0] + +extent[1][0]) / 2, (+extent[0][1] + +extent[1][1]) / 2];\n }\n\n function schedule(transition$$1, transform, center) {\n transition$$1\n .on(\"start.zoom\", function() { gesture(this, arguments).start(); })\n .on(\"interrupt.zoom end.zoom\", function() { gesture(this, arguments).end(); })\n .tween(\"zoom\", function() {\n var that = this,\n args = arguments,\n g = gesture(that, args),\n e = extent.apply(that, args),\n p = center || centroid(e),\n w = Math.max(e[1][0] - e[0][0], e[1][1] - e[0][1]),\n a = that.__zoom,\n b = typeof transform === \"function\" ? transform.apply(that, args) : transform,\n i = interpolate$$1(a.invert(p).concat(w / a.k), b.invert(p).concat(w / b.k));\n return function(t) {\n if (t === 1) t = b; // Avoid rounding error on end.\n else { var l = i(t), k = w / l[2]; t = new Transform(k, p[0] - l[0] * k, p[1] - l[1] * k); }\n g.zoom(null, t);\n };\n });\n }\n\n function gesture(that, args) {\n for (var i = 0, n = gestures.length, g; i < n; ++i) {\n if ((g = gestures[i]).that === that) {\n return g;\n }\n }\n return new Gesture(that, args);\n }\n\n function Gesture(that, args) {\n this.that = that;\n this.args = args;\n this.index = -1;\n this.active = 0;\n this.extent = extent.apply(that, args);\n }\n\n Gesture.prototype = {\n start: function() {\n if (++this.active === 1) {\n this.index = gestures.push(this) - 1;\n this.emit(\"start\");\n }\n return this;\n },\n zoom: function(key, transform) {\n if (this.mouse && key !== \"mouse\") this.mouse[1] = transform.invert(this.mouse[0]);\n if (this.touch0 && key !== \"touch\") this.touch0[1] = transform.invert(this.touch0[0]);\n if (this.touch1 && key !== \"touch\") this.touch1[1] = transform.invert(this.touch1[0]);\n this.that.__zoom = transform;\n this.emit(\"zoom\");\n return this;\n },\n end: function() {\n if (--this.active === 0) {\n gestures.splice(this.index, 1);\n this.index = -1;\n this.emit(\"end\");\n }\n return this;\n },\n emit: function(type) {\n customEvent(new ZoomEvent(zoom, type, this.that.__zoom), listeners.apply, listeners, [type, this.that, this.args]);\n }\n };\n\n function wheeled() {\n if (!filter.apply(this, arguments)) return;\n var g = gesture(this, arguments),\n t = this.__zoom,\n k = Math.max(k0, Math.min(k1, t.k * Math.pow(2, -exports.event.deltaY * (exports.event.deltaMode ? 120 : 1) / 500))),\n p = mouse(this);\n\n // If the mouse is in the same location as before, reuse it.\n // If there were recent wheel events, reset the wheel idle timeout.\n if (g.wheel) {\n if (g.mouse[0][0] !== p[0] || g.mouse[0][1] !== p[1]) {\n g.mouse[1] = t.invert(g.mouse[0] = p);\n }\n clearTimeout(g.wheel);\n }\n\n // If this wheel event won’t trigger a transform change, ignore it.\n else if (t.k === k) return;\n\n // Otherwise, capture the mouse point and location at the start.\n else {\n g.mouse = [p, t.invert(p)];\n interrupt(this);\n g.start();\n }\n\n noevent$2();\n g.wheel = setTimeout(wheelidled, wheelDelay);\n g.zoom(\"mouse\", constrain(translate(scale(t, k), g.mouse[0], g.mouse[1]), g.extent));\n\n function wheelidled() {\n g.wheel = null;\n g.end();\n }\n }\n\n function mousedowned() {\n if (touchending || !filter.apply(this, arguments)) return;\n var g = gesture(this, arguments),\n v = select(exports.event.view).on(\"mousemove.zoom\", mousemoved, true).on(\"mouseup.zoom\", mouseupped, true),\n p = mouse(this);\n\n dragDisable(exports.event.view);\n nopropagation$2();\n g.mouse = [p, this.__zoom.invert(p)];\n interrupt(this);\n g.start();\n\n function mousemoved() {\n noevent$2();\n g.moved = true;\n g.zoom(\"mouse\", constrain(translate(g.that.__zoom, g.mouse[0] = mouse(g.that), g.mouse[1]), g.extent));\n }\n\n function mouseupped() {\n v.on(\"mousemove.zoom mouseup.zoom\", null);\n yesdrag(exports.event.view, g.moved);\n noevent$2();\n g.end();\n }\n }\n\n function dblclicked() {\n if (!filter.apply(this, arguments)) return;\n var t0 = this.__zoom,\n p0 = mouse(this),\n p1 = t0.invert(p0),\n k1 = t0.k * (exports.event.shiftKey ? 0.5 : 2),\n t1 = constrain(translate(scale(t0, k1), p0, p1), extent.apply(this, arguments));\n\n noevent$2();\n if (duration > 0) select(this).transition().duration(duration).call(schedule, t1, p0);\n else select(this).call(zoom.transform, t1);\n }\n\n function touchstarted() {\n if (!filter.apply(this, arguments)) return;\n var g = gesture(this, arguments),\n touches$$1 = exports.event.changedTouches,\n started,\n n = touches$$1.length, i, t, p;\n\n nopropagation$2();\n for (i = 0; i < n; ++i) {\n t = touches$$1[i], p = touch(this, touches$$1, t.identifier);\n p = [p, this.__zoom.invert(p), t.identifier];\n if (!g.touch0) g.touch0 = p, started = true;\n else if (!g.touch1) g.touch1 = p;\n }\n\n // If this is a dbltap, reroute to the (optional) dblclick.zoom handler.\n if (touchstarting) {\n touchstarting = clearTimeout(touchstarting);\n if (!g.touch1) {\n g.end();\n p = select(this).on(\"dblclick.zoom\");\n if (p) p.apply(this, arguments);\n return;\n }\n }\n\n if (started) {\n touchstarting = setTimeout(function() { touchstarting = null; }, touchDelay);\n interrupt(this);\n g.start();\n }\n }\n\n function touchmoved() {\n var g = gesture(this, arguments),\n touches$$1 = exports.event.changedTouches,\n n = touches$$1.length, i, t, p, l;\n\n noevent$2();\n if (touchstarting) touchstarting = clearTimeout(touchstarting);\n for (i = 0; i < n; ++i) {\n t = touches$$1[i], p = touch(this, touches$$1, t.identifier);\n if (g.touch0 && g.touch0[2] === t.identifier) g.touch0[0] = p;\n else if (g.touch1 && g.touch1[2] === t.identifier) g.touch1[0] = p;\n }\n t = g.that.__zoom;\n if (g.touch1) {\n var p0 = g.touch0[0], l0 = g.touch0[1],\n p1 = g.touch1[0], l1 = g.touch1[1],\n dp = (dp = p1[0] - p0[0]) * dp + (dp = p1[1] - p0[1]) * dp,\n dl = (dl = l1[0] - l0[0]) * dl + (dl = l1[1] - l0[1]) * dl;\n t = scale(t, Math.sqrt(dp / dl));\n p = [(p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2];\n l = [(l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2];\n }\n else if (g.touch0) p = g.touch0[0], l = g.touch0[1];\n else return;\n g.zoom(\"touch\", constrain(translate(t, p, l), g.extent));\n }\n\n function touchended() {\n var g = gesture(this, arguments),\n touches$$1 = exports.event.changedTouches,\n n = touches$$1.length, i, t;\n\n nopropagation$2();\n if (touchending) clearTimeout(touchending);\n touchending = setTimeout(function() { touchending = null; }, touchDelay);\n for (i = 0; i < n; ++i) {\n t = touches$$1[i];\n if (g.touch0 && g.touch0[2] === t.identifier) delete g.touch0;\n else if (g.touch1 && g.touch1[2] === t.identifier) delete g.touch1;\n }\n if (g.touch1 && !g.touch0) g.touch0 = g.touch1, delete g.touch1;\n if (!g.touch0) g.end();\n }\n\n zoom.filter = function(_) {\n return arguments.length ? (filter = typeof _ === \"function\" ? _ : constant$12(!!_), zoom) : filter;\n };\n\n zoom.extent = function(_) {\n return arguments.length ? (extent = typeof _ === \"function\" ? _ : constant$12([[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]]), zoom) : extent;\n };\n\n zoom.scaleExtent = function(_) {\n return arguments.length ? (k0 = +_[0], k1 = +_[1], zoom) : [k0, k1];\n };\n\n zoom.translateExtent = function(_) {\n return arguments.length ? (x0 = +_[0][0], x1 = +_[1][0], y0 = +_[0][1], y1 = +_[1][1], zoom) : [[x0, y0], [x1, y1]];\n };\n\n zoom.duration = function(_) {\n return arguments.length ? (duration = +_, zoom) : duration;\n };\n\n zoom.interpolate = function(_) {\n return arguments.length ? (interpolate$$1 = _, zoom) : interpolate$$1;\n };\n\n zoom.on = function() {\n var value = listeners.on.apply(listeners, arguments);\n return value === listeners ? zoom : value;\n };\n\n return zoom;\n};\n\nexports.version = version;\nexports.bisect = bisectRight;\nexports.bisectRight = bisectRight;\nexports.bisectLeft = bisectLeft;\nexports.ascending = ascending;\nexports.bisector = bisector;\nexports.descending = descending;\nexports.deviation = deviation;\nexports.extent = extent;\nexports.histogram = histogram;\nexports.thresholdFreedmanDiaconis = freedmanDiaconis;\nexports.thresholdScott = scott;\nexports.thresholdSturges = sturges;\nexports.max = max;\nexports.mean = mean;\nexports.median = median;\nexports.merge = merge;\nexports.min = min;\nexports.pairs = pairs;\nexports.permute = permute;\nexports.quantile = threshold;\nexports.range = sequence;\nexports.scan = scan;\nexports.shuffle = shuffle;\nexports.sum = sum;\nexports.ticks = ticks;\nexports.tickStep = tickStep;\nexports.transpose = transpose;\nexports.variance = variance;\nexports.zip = zip;\nexports.axisTop = axisTop;\nexports.axisRight = axisRight;\nexports.axisBottom = axisBottom;\nexports.axisLeft = axisLeft;\nexports.brush = brush;\nexports.brushX = brushX;\nexports.brushY = brushY;\nexports.brushSelection = brushSelection;\nexports.chord = chord;\nexports.ribbon = ribbon;\nexports.nest = nest;\nexports.set = set$2;\nexports.map = map$1;\nexports.keys = keys;\nexports.values = values;\nexports.entries = entries;\nexports.color = color;\nexports.rgb = rgb;\nexports.hsl = hsl;\nexports.lab = lab;\nexports.hcl = hcl;\nexports.cubehelix = cubehelix;\nexports.dispatch = dispatch;\nexports.drag = drag;\nexports.dragDisable = dragDisable;\nexports.dragEnable = yesdrag;\nexports.dsvFormat = dsv;\nexports.csvParse = csvParse;\nexports.csvParseRows = csvParseRows;\nexports.csvFormat = csvFormat;\nexports.csvFormatRows = csvFormatRows;\nexports.tsvParse = tsvParse;\nexports.tsvParseRows = tsvParseRows;\nexports.tsvFormat = tsvFormat;\nexports.tsvFormatRows = tsvFormatRows;\nexports.easeLinear = linear$1;\nexports.easeQuad = quadInOut;\nexports.easeQuadIn = quadIn;\nexports.easeQuadOut = quadOut;\nexports.easeQuadInOut = quadInOut;\nexports.easeCubic = cubicInOut;\nexports.easeCubicIn = cubicIn;\nexports.easeCubicOut = cubicOut;\nexports.easeCubicInOut = cubicInOut;\nexports.easePoly = polyInOut;\nexports.easePolyIn = polyIn;\nexports.easePolyOut = polyOut;\nexports.easePolyInOut = polyInOut;\nexports.easeSin = sinInOut;\nexports.easeSinIn = sinIn;\nexports.easeSinOut = sinOut;\nexports.easeSinInOut = sinInOut;\nexports.easeExp = expInOut;\nexports.easeExpIn = expIn;\nexports.easeExpOut = expOut;\nexports.easeExpInOut = expInOut;\nexports.easeCircle = circleInOut;\nexports.easeCircleIn = circleIn;\nexports.easeCircleOut = circleOut;\nexports.easeCircleInOut = circleInOut;\nexports.easeBounce = bounceOut;\nexports.easeBounceIn = bounceIn;\nexports.easeBounceOut = bounceOut;\nexports.easeBounceInOut = bounceInOut;\nexports.easeBack = backInOut;\nexports.easeBackIn = backIn;\nexports.easeBackOut = backOut;\nexports.easeBackInOut = backInOut;\nexports.easeElastic = elasticOut;\nexports.easeElasticIn = elasticIn;\nexports.easeElasticOut = elasticOut;\nexports.easeElasticInOut = elasticInOut;\nexports.forceCenter = center$1;\nexports.forceCollide = collide;\nexports.forceLink = link;\nexports.forceManyBody = manyBody;\nexports.forceSimulation = simulation;\nexports.forceX = x$2;\nexports.forceY = y$2;\nexports.formatDefaultLocale = defaultLocale;\nexports.formatLocale = formatLocale;\nexports.formatSpecifier = formatSpecifier;\nexports.precisionFixed = precisionFixed;\nexports.precisionPrefix = precisionPrefix;\nexports.precisionRound = precisionRound;\nexports.geoArea = area;\nexports.geoBounds = bounds;\nexports.geoCentroid = centroid;\nexports.geoCircle = circle;\nexports.geoClipExtent = extent$1;\nexports.geoDistance = distance;\nexports.geoGraticule = graticule;\nexports.geoGraticule10 = graticule10;\nexports.geoInterpolate = interpolate$1;\nexports.geoLength = length$1;\nexports.geoPath = index$1;\nexports.geoAlbers = albers;\nexports.geoAlbersUsa = albersUsa;\nexports.geoAzimuthalEqualArea = azimuthalEqualArea;\nexports.geoAzimuthalEqualAreaRaw = azimuthalEqualAreaRaw;\nexports.geoAzimuthalEquidistant = azimuthalEquidistant;\nexports.geoAzimuthalEquidistantRaw = azimuthalEquidistantRaw;\nexports.geoConicConformal = conicConformal;\nexports.geoConicConformalRaw = conicConformalRaw;\nexports.geoConicEqualArea = conicEqualArea;\nexports.geoConicEqualAreaRaw = conicEqualAreaRaw;\nexports.geoConicEquidistant = conicEquidistant;\nexports.geoConicEquidistantRaw = conicEquidistantRaw;\nexports.geoEquirectangular = equirectangular;\nexports.geoEquirectangularRaw = equirectangularRaw;\nexports.geoGnomonic = gnomonic;\nexports.geoGnomonicRaw = gnomonicRaw;\nexports.geoIdentity = identity$5;\nexports.geoProjection = projection;\nexports.geoProjectionMutator = projectionMutator;\nexports.geoMercator = mercator;\nexports.geoMercatorRaw = mercatorRaw;\nexports.geoOrthographic = orthographic;\nexports.geoOrthographicRaw = orthographicRaw;\nexports.geoStereographic = stereographic;\nexports.geoStereographicRaw = stereographicRaw;\nexports.geoTransverseMercator = transverseMercator;\nexports.geoTransverseMercatorRaw = transverseMercatorRaw;\nexports.geoRotation = rotation;\nexports.geoStream = geoStream;\nexports.geoTransform = transform;\nexports.cluster = cluster;\nexports.hierarchy = hierarchy;\nexports.pack = index$2;\nexports.packSiblings = siblings;\nexports.packEnclose = enclose;\nexports.partition = partition;\nexports.stratify = stratify;\nexports.tree = tree;\nexports.treemap = index$3;\nexports.treemapBinary = binary;\nexports.treemapDice = treemapDice;\nexports.treemapSlice = treemapSlice;\nexports.treemapSliceDice = sliceDice;\nexports.treemapSquarify = squarify;\nexports.treemapResquarify = resquarify;\nexports.interpolate = interpolateValue;\nexports.interpolateArray = array$1;\nexports.interpolateBasis = basis$1;\nexports.interpolateBasisClosed = basisClosed;\nexports.interpolateDate = date;\nexports.interpolateNumber = reinterpolate;\nexports.interpolateObject = object;\nexports.interpolateRound = interpolateRound;\nexports.interpolateString = interpolateString;\nexports.interpolateTransformCss = interpolateTransformCss;\nexports.interpolateTransformSvg = interpolateTransformSvg;\nexports.interpolateZoom = interpolateZoom;\nexports.interpolateRgb = interpolateRgb;\nexports.interpolateRgbBasis = rgbBasis;\nexports.interpolateRgbBasisClosed = rgbBasisClosed;\nexports.interpolateHsl = hsl$2;\nexports.interpolateHslLong = hslLong;\nexports.interpolateLab = lab$1;\nexports.interpolateHcl = hcl$2;\nexports.interpolateHclLong = hclLong;\nexports.interpolateCubehelix = cubehelix$2;\nexports.interpolateCubehelixLong = cubehelixLong;\nexports.quantize = quantize;\nexports.path = path;\nexports.polygonArea = area$1;\nexports.polygonCentroid = centroid$1;\nexports.polygonHull = hull;\nexports.polygonContains = contains;\nexports.polygonLength = length$2;\nexports.quadtree = quadtree;\nexports.queue = queue;\nexports.randomUniform = uniform;\nexports.randomNormal = normal;\nexports.randomLogNormal = logNormal;\nexports.randomBates = bates;\nexports.randomIrwinHall = irwinHall;\nexports.randomExponential = exponential$1;\nexports.request = request;\nexports.html = html;\nexports.json = json;\nexports.text = text;\nexports.xml = xml;\nexports.csv = csv$1;\nexports.tsv = tsv$1;\nexports.scaleBand = band;\nexports.scalePoint = point$1;\nexports.scaleIdentity = identity$6;\nexports.scaleLinear = linear$2;\nexports.scaleLog = log$1;\nexports.scaleOrdinal = ordinal;\nexports.scaleImplicit = implicit;\nexports.scalePow = pow$1;\nexports.scaleSqrt = sqrt$1;\nexports.scaleQuantile = quantile$$1;\nexports.scaleQuantize = quantize$1;\nexports.scaleThreshold = threshold$1;\nexports.scaleTime = time;\nexports.scaleUtc = utcTime;\nexports.schemeCategory10 = category10;\nexports.schemeCategory20b = category20b;\nexports.schemeCategory20c = category20c;\nexports.schemeCategory20 = category20;\nexports.interpolateCubehelixDefault = cubehelix$3;\nexports.interpolateRainbow = rainbow$1;\nexports.interpolateWarm = warm;\nexports.interpolateCool = cool;\nexports.interpolateViridis = viridis;\nexports.interpolateMagma = magma;\nexports.interpolateInferno = inferno;\nexports.interpolatePlasma = plasma;\nexports.scaleSequential = sequential;\nexports.creator = creator;\nexports.local = local$1;\nexports.matcher = matcher$1;\nexports.mouse = mouse;\nexports.namespace = namespace;\nexports.namespaces = namespaces;\nexports.select = select;\nexports.selectAll = selectAll;\nexports.selection = selection;\nexports.selector = selector;\nexports.selectorAll = selectorAll;\nexports.touch = touch;\nexports.touches = touches;\nexports.window = window;\nexports.customEvent = customEvent;\nexports.arc = arc;\nexports.area = area$2;\nexports.line = line;\nexports.pie = pie;\nexports.radialArea = radialArea;\nexports.radialLine = radialLine$1;\nexports.symbol = symbol;\nexports.symbols = symbols;\nexports.symbolCircle = circle$2;\nexports.symbolCross = cross$1;\nexports.symbolDiamond = diamond;\nexports.symbolSquare = square;\nexports.symbolStar = star;\nexports.symbolTriangle = triangle;\nexports.symbolWye = wye;\nexports.curveBasisClosed = basisClosed$1;\nexports.curveBasisOpen = basisOpen;\nexports.curveBasis = basis$2;\nexports.curveBundle = bundle;\nexports.curveCardinalClosed = cardinalClosed;\nexports.curveCardinalOpen = cardinalOpen;\nexports.curveCardinal = cardinal;\nexports.curveCatmullRomClosed = catmullRomClosed;\nexports.curveCatmullRomOpen = catmullRomOpen;\nexports.curveCatmullRom = catmullRom;\nexports.curveLinearClosed = linearClosed;\nexports.curveLinear = curveLinear;\nexports.curveMonotoneX = monotoneX;\nexports.curveMonotoneY = monotoneY;\nexports.curveNatural = natural;\nexports.curveStep = step;\nexports.curveStepAfter = stepAfter;\nexports.curveStepBefore = stepBefore;\nexports.stack = stack;\nexports.stackOffsetExpand = expand;\nexports.stackOffsetNone = none$1;\nexports.stackOffsetSilhouette = silhouette;\nexports.stackOffsetWiggle = wiggle;\nexports.stackOrderAscending = ascending$2;\nexports.stackOrderDescending = descending$2;\nexports.stackOrderInsideOut = insideOut;\nexports.stackOrderNone = none$2;\nexports.stackOrderReverse = reverse;\nexports.timeInterval = newInterval;\nexports.timeMillisecond = millisecond;\nexports.timeMilliseconds = milliseconds;\nexports.utcMillisecond = millisecond;\nexports.utcMilliseconds = milliseconds;\nexports.timeSecond = second;\nexports.timeSeconds = seconds;\nexports.utcSecond = second;\nexports.utcSeconds = seconds;\nexports.timeMinute = minute;\nexports.timeMinutes = minutes;\nexports.timeHour = hour;\nexports.timeHours = hours;\nexports.timeDay = day;\nexports.timeDays = days;\nexports.timeWeek = sunday;\nexports.timeWeeks = sundays;\nexports.timeSunday = sunday;\nexports.timeSundays = sundays;\nexports.timeMonday = monday;\nexports.timeMondays = mondays;\nexports.timeTuesday = tuesday;\nexports.timeTuesdays = tuesdays;\nexports.timeWednesday = wednesday;\nexports.timeWednesdays = wednesdays;\nexports.timeThursday = thursday;\nexports.timeThursdays = thursdays;\nexports.timeFriday = friday;\nexports.timeFridays = fridays;\nexports.timeSaturday = saturday;\nexports.timeSaturdays = saturdays;\nexports.timeMonth = month;\nexports.timeMonths = months;\nexports.timeYear = year;\nexports.timeYears = years;\nexports.utcMinute = utcMinute;\nexports.utcMinutes = utcMinutes;\nexports.utcHour = utcHour;\nexports.utcHours = utcHours;\nexports.utcDay = utcDay;\nexports.utcDays = utcDays;\nexports.utcWeek = utcSunday;\nexports.utcWeeks = utcSundays;\nexports.utcSunday = utcSunday;\nexports.utcSundays = utcSundays;\nexports.utcMonday = utcMonday;\nexports.utcMondays = utcMondays;\nexports.utcTuesday = utcTuesday;\nexports.utcTuesdays = utcTuesdays;\nexports.utcWednesday = utcWednesday;\nexports.utcWednesdays = utcWednesdays;\nexports.utcThursday = utcThursday;\nexports.utcThursdays = utcThursdays;\nexports.utcFriday = utcFriday;\nexports.utcFridays = utcFridays;\nexports.utcSaturday = utcSaturday;\nexports.utcSaturdays = utcSaturdays;\nexports.utcMonth = utcMonth;\nexports.utcMonths = utcMonths;\nexports.utcYear = utcYear;\nexports.utcYears = utcYears;\nexports.timeFormatDefaultLocale = defaultLocale$1;\nexports.timeFormatLocale = formatLocale$1;\nexports.isoFormat = formatIso;\nexports.isoParse = parseIso;\nexports.now = now;\nexports.timer = timer;\nexports.timerFlush = timerFlush;\nexports.timeout = timeout$1;\nexports.interval = interval$1;\nexports.transition = transition;\nexports.active = active;\nexports.interrupt = interrupt;\nexports.voronoi = voronoi;\nexports.zoom = zoom;\nexports.zoomTransform = transform$1;\nexports.zoomIdentity = identity$8;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n/***/ }),\n/* 30 */,\n/* 31 */,\n/* 32 */,\n/* 33 */,\n/* 34 */,\n/* 35 */,\n/* 36 */,\n/* 37 */,\n/* 38 */\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = { \"default\": __webpack_require__(40), __esModule: true };\n\n/***/ }),\n/* 39 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nexports.__esModule = true;\n\nvar _from = __webpack_require__(38);\n\nvar _from2 = _interopRequireDefault(_from);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function (arr) {\n if (Array.isArray(arr)) {\n for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {\n arr2[i] = arr[i];\n }\n\n return arr2;\n } else {\n return (0, _from2.default)(arr);\n }\n};\n\n/***/ }),\n/* 40 */\n/***/ (function(module, exports, __webpack_require__) {\n\n__webpack_require__(65);\n__webpack_require__(64);\nmodule.exports = __webpack_require__(9).Array.from;\n\n/***/ }),\n/* 41 */\n/***/ (function(module, exports) {\n\nmodule.exports = function(it){\n if(typeof it != 'function')throw TypeError(it + ' is not a function!');\n return it;\n};\n\n/***/ }),\n/* 42 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// false -> Array#indexOf\n// true -> Array#includes\nvar toIObject = __webpack_require__(25)\n , toLength = __webpack_require__(26)\n , toIndex = __webpack_require__(61);\nmodule.exports = function(IS_INCLUDES){\n return function($this, el, fromIndex){\n var O = toIObject($this)\n , length = toLength(O.length)\n , index = toIndex(fromIndex, length)\n , value;\n // Array#includes uses SameValueZero equality algorithm\n if(IS_INCLUDES && el != el)while(length > index){\n value = O[index++];\n if(value != value)return true;\n // Array#toIndex ignores holes, Array#includes - not\n } else for(;length > index; index++)if(IS_INCLUDES || index in O){\n if(O[index] === el)return IS_INCLUDES || index || 0;\n } return !IS_INCLUDES && -1;\n };\n};\n\n/***/ }),\n/* 43 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// getting tag from 19.1.3.6 Object.prototype.toString()\nvar cof = __webpack_require__(17)\n , TAG = __webpack_require__(0)('toStringTag')\n // ES3 wrong here\n , ARG = cof(function(){ return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function(it, key){\n try {\n return it[key];\n } catch(e){ /* empty */ }\n};\n\nmodule.exports = function(it){\n var O, T, B;\n return it === undefined ? 'Undefined' : it === null ? 'Null'\n // @@toStringTag case\n : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T\n // builtinTag case\n : ARG ? cof(O)\n // ES3 arguments fallback\n : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;\n};\n\n/***/ }),\n/* 44 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar $defineProperty = __webpack_require__(7)\n , createDesc = __webpack_require__(13);\n\nmodule.exports = function(object, index, value){\n if(index in object)$defineProperty.f(object, index, createDesc(0, value));\n else object[index] = value;\n};\n\n/***/ }),\n/* 45 */\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = __webpack_require__(1).document && document.documentElement;\n\n/***/ }),\n/* 46 */\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = !__webpack_require__(4) && !__webpack_require__(22)(function(){\n return Object.defineProperty(__webpack_require__(19)('div'), 'a', {get: function(){ return 7; }}).a != 7;\n});\n\n/***/ }),\n/* 47 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nvar cof = __webpack_require__(17);\nmodule.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){\n return cof(it) == 'String' ? it.split('') : Object(it);\n};\n\n/***/ }),\n/* 48 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// check on default Array iterator\nvar Iterators = __webpack_require__(12)\n , ITERATOR = __webpack_require__(0)('iterator')\n , ArrayProto = Array.prototype;\n\nmodule.exports = function(it){\n return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);\n};\n\n/***/ }),\n/* 49 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// call something on iterator step with safe closing on error\nvar anObject = __webpack_require__(3);\nmodule.exports = function(iterator, fn, value, entries){\n try {\n return entries ? fn(anObject(value)[0], value[1]) : fn(value);\n // 7.4.6 IteratorClose(iterator, completion)\n } catch(e){\n var ret = iterator['return'];\n if(ret !== undefined)anObject(ret.call(iterator));\n throw e;\n }\n};\n\n/***/ }),\n/* 50 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar create = __webpack_require__(54)\n , descriptor = __webpack_require__(13)\n , setToStringTag = __webpack_require__(23)\n , IteratorPrototype = {};\n\n// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()\n__webpack_require__(6)(IteratorPrototype, __webpack_require__(0)('iterator'), function(){ return this; });\n\nmodule.exports = function(Constructor, NAME, next){\n Constructor.prototype = create(IteratorPrototype, {next: descriptor(1, next)});\n setToStringTag(Constructor, NAME + ' Iterator');\n};\n\n/***/ }),\n/* 51 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar LIBRARY = __webpack_require__(53)\n , $export = __webpack_require__(21)\n , redefine = __webpack_require__(59)\n , hide = __webpack_require__(6)\n , has = __webpack_require__(5)\n , Iterators = __webpack_require__(12)\n , $iterCreate = __webpack_require__(50)\n , setToStringTag = __webpack_require__(23)\n , getPrototypeOf = __webpack_require__(56)\n , ITERATOR = __webpack_require__(0)('iterator')\n , BUGGY = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`\n , FF_ITERATOR = '@@iterator'\n , KEYS = 'keys'\n , VALUES = 'values';\n\nvar returnThis = function(){ return this; };\n\nmodule.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){\n $iterCreate(Constructor, NAME, next);\n var getMethod = function(kind){\n if(!BUGGY && kind in proto)return proto[kind];\n switch(kind){\n case KEYS: return function keys(){ return new Constructor(this, kind); };\n case VALUES: return function values(){ return new Constructor(this, kind); };\n } return function entries(){ return new Constructor(this, kind); };\n };\n var TAG = NAME + ' Iterator'\n , DEF_VALUES = DEFAULT == VALUES\n , VALUES_BUG = false\n , proto = Base.prototype\n , $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]\n , $default = $native || getMethod(DEFAULT)\n , $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined\n , $anyNative = NAME == 'Array' ? proto.entries || $native : $native\n , methods, key, IteratorPrototype;\n // Fix native\n if($anyNative){\n IteratorPrototype = getPrototypeOf($anyNative.call(new Base));\n if(IteratorPrototype !== Object.prototype){\n // Set @@toStringTag to native iterators\n setToStringTag(IteratorPrototype, TAG, true);\n // fix for some old engines\n if(!LIBRARY && !has(IteratorPrototype, ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis);\n }\n }\n // fix Array#{values, @@iterator}.name in V8 / FF\n if(DEF_VALUES && $native && $native.name !== VALUES){\n VALUES_BUG = true;\n $default = function values(){ return $native.call(this); };\n }\n // Define iterator\n if((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])){\n hide(proto, ITERATOR, $default);\n }\n // Plug for library\n Iterators[NAME] = $default;\n Iterators[TAG] = returnThis;\n if(DEFAULT){\n methods = {\n values: DEF_VALUES ? $default : getMethod(VALUES),\n keys: IS_SET ? $default : getMethod(KEYS),\n entries: $entries\n };\n if(FORCED)for(key in methods){\n if(!(key in proto))redefine(proto, key, methods[key]);\n } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);\n }\n return methods;\n};\n\n/***/ }),\n/* 52 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar ITERATOR = __webpack_require__(0)('iterator')\n , SAFE_CLOSING = false;\n\ntry {\n var riter = [7][ITERATOR]();\n riter['return'] = function(){ SAFE_CLOSING = true; };\n Array.from(riter, function(){ throw 2; });\n} catch(e){ /* empty */ }\n\nmodule.exports = function(exec, skipClosing){\n if(!skipClosing && !SAFE_CLOSING)return false;\n var safe = false;\n try {\n var arr = [7]\n , iter = arr[ITERATOR]();\n iter.next = function(){ return {done: safe = true}; };\n arr[ITERATOR] = function(){ return iter; };\n exec(arr);\n } catch(e){ /* empty */ }\n return safe;\n};\n\n/***/ }),\n/* 53 */\n/***/ (function(module, exports) {\n\nmodule.exports = true;\n\n/***/ }),\n/* 54 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])\nvar anObject = __webpack_require__(3)\n , dPs = __webpack_require__(55)\n , enumBugKeys = __webpack_require__(20)\n , IE_PROTO = __webpack_require__(14)('IE_PROTO')\n , Empty = function(){ /* empty */ }\n , PROTOTYPE = 'prototype';\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar createDict = function(){\n // Thrash, waste and sodomy: IE GC bug\n var iframe = __webpack_require__(19)('iframe')\n , i = enumBugKeys.length\n , lt = '<'\n , gt = '>'\n , iframeDocument;\n iframe.style.display = 'none';\n __webpack_require__(45).appendChild(iframe);\n iframe.src = 'javascript:'; // eslint-disable-line no-script-url\n // createDict = iframe.contentWindow.Object;\n // html.removeChild(iframe);\n iframeDocument = iframe.contentWindow.document;\n iframeDocument.open();\n iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);\n iframeDocument.close();\n createDict = iframeDocument.F;\n while(i--)delete createDict[PROTOTYPE][enumBugKeys[i]];\n return createDict();\n};\n\nmodule.exports = Object.create || function create(O, Properties){\n var result;\n if(O !== null){\n Empty[PROTOTYPE] = anObject(O);\n result = new Empty;\n Empty[PROTOTYPE] = null;\n // add \"__proto__\" for Object.getPrototypeOf polyfill\n result[IE_PROTO] = O;\n } else result = createDict();\n return Properties === undefined ? result : dPs(result, Properties);\n};\n\n\n/***/ }),\n/* 55 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar dP = __webpack_require__(7)\n , anObject = __webpack_require__(3)\n , getKeys = __webpack_require__(58);\n\nmodule.exports = __webpack_require__(4) ? Object.defineProperties : function defineProperties(O, Properties){\n anObject(O);\n var keys = getKeys(Properties)\n , length = keys.length\n , i = 0\n , P;\n while(length > i)dP.f(O, P = keys[i++], Properties[P]);\n return O;\n};\n\n/***/ }),\n/* 56 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)\nvar has = __webpack_require__(5)\n , toObject = __webpack_require__(27)\n , IE_PROTO = __webpack_require__(14)('IE_PROTO')\n , ObjectProto = Object.prototype;\n\nmodule.exports = Object.getPrototypeOf || function(O){\n O = toObject(O);\n if(has(O, IE_PROTO))return O[IE_PROTO];\n if(typeof O.constructor == 'function' && O instanceof O.constructor){\n return O.constructor.prototype;\n } return O instanceof Object ? ObjectProto : null;\n};\n\n/***/ }),\n/* 57 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar has = __webpack_require__(5)\n , toIObject = __webpack_require__(25)\n , arrayIndexOf = __webpack_require__(42)(false)\n , IE_PROTO = __webpack_require__(14)('IE_PROTO');\n\nmodule.exports = function(object, names){\n var O = toIObject(object)\n , i = 0\n , result = []\n , key;\n for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);\n // Don't enum bug & hidden keys\n while(names.length > i)if(has(O, key = names[i++])){\n ~arrayIndexOf(result, key) || result.push(key);\n }\n return result;\n};\n\n/***/ }),\n/* 58 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// 19.1.2.14 / 15.2.3.14 Object.keys(O)\nvar $keys = __webpack_require__(57)\n , enumBugKeys = __webpack_require__(20);\n\nmodule.exports = Object.keys || function keys(O){\n return $keys(O, enumBugKeys);\n};\n\n/***/ }),\n/* 59 */\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = __webpack_require__(6);\n\n/***/ }),\n/* 60 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar toInteger = __webpack_require__(15)\n , defined = __webpack_require__(10);\n// true -> String#at\n// false -> String#codePointAt\nmodule.exports = function(TO_STRING){\n return function(that, pos){\n var s = String(defined(that))\n , i = toInteger(pos)\n , l = s.length\n , a, b;\n if(i < 0 || i >= l)return TO_STRING ? '' : undefined;\n a = s.charCodeAt(i);\n return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff\n ? TO_STRING ? s.charAt(i) : a\n : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;\n };\n};\n\n/***/ }),\n/* 61 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar toInteger = __webpack_require__(15)\n , max = Math.max\n , min = Math.min;\nmodule.exports = function(index, length){\n index = toInteger(index);\n return index < 0 ? max(index + length, 0) : min(index, length);\n};\n\n/***/ }),\n/* 62 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// 7.1.1 ToPrimitive(input [, PreferredType])\nvar isObject = __webpack_require__(11);\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function(it, S){\n if(!isObject(it))return it;\n var fn, val;\n if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;\n if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n throw TypeError(\"Can't convert object to primitive value\");\n};\n\n/***/ }),\n/* 63 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar classof = __webpack_require__(43)\n , ITERATOR = __webpack_require__(0)('iterator')\n , Iterators = __webpack_require__(12);\nmodule.exports = __webpack_require__(9).getIteratorMethod = function(it){\n if(it != undefined)return it[ITERATOR]\n || it['@@iterator']\n || Iterators[classof(it)];\n};\n\n/***/ }),\n/* 64 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar ctx = __webpack_require__(18)\n , $export = __webpack_require__(21)\n , toObject = __webpack_require__(27)\n , call = __webpack_require__(49)\n , isArrayIter = __webpack_require__(48)\n , toLength = __webpack_require__(26)\n , createProperty = __webpack_require__(44)\n , getIterFn = __webpack_require__(63);\n\n$export($export.S + $export.F * !__webpack_require__(52)(function(iter){ Array.from(iter); }), 'Array', {\n // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)\n from: function from(arrayLike/*, mapfn = undefined, thisArg = undefined*/){\n var O = toObject(arrayLike)\n , C = typeof this == 'function' ? this : Array\n , aLen = arguments.length\n , mapfn = aLen > 1 ? arguments[1] : undefined\n , mapping = mapfn !== undefined\n , index = 0\n , iterFn = getIterFn(O)\n , length, result, step, iterator;\n if(mapping)mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);\n // if object isn't iterable or it's array with default iterator - use simple case\n if(iterFn != undefined && !(C == Array && isArrayIter(iterFn))){\n for(iterator = iterFn.call(O), result = new C; !(step = iterator.next()).done; index++){\n createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value);\n }\n } else {\n length = toLength(O.length);\n for(result = new C(length); length > index; index++){\n createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);\n }\n }\n result.length = index;\n return result;\n }\n});\n\n\n/***/ }),\n/* 65 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar $at = __webpack_require__(60)(true);\n\n// 21.1.3.27 String.prototype[@@iterator]()\n__webpack_require__(51)(String, 'String', function(iterated){\n this._t = String(iterated); // target\n this._i = 0; // next index\n// 21.1.5.2.1 %StringIteratorPrototype%.next()\n}, function(){\n var O = this._t\n , index = this._i\n , point;\n if(index >= O.length)return {value: undefined, done: true};\n point = $at(O, index);\n this._i += point.length;\n return {value: point, done: false};\n});\n\n/***/ }),\n/* 66 */,\n/* 67 */,\n/* 68 */,\n/* 69 */,\n/* 70 */,\n/* 71 */,\n/* 72 */,\n/* 73 */,\n/* 74 */,\n/* 75 */,\n/* 76 */,\n/* 77 */,\n/* 78 */,\n/* 79 */,\n/* 80 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * vue-router v2.2.1\n * (c) 2017 Evan You\n * @license MIT\n */\n\n\n/* */\n\nfunction assert (condition, message) {\n if (!condition) {\n throw new Error((\"[vue-router] \" + message))\n }\n}\n\nfunction warn (condition, message) {\n if (!condition) {\n typeof console !== 'undefined' && console.warn((\"[vue-router] \" + message));\n }\n}\n\nvar View = {\n name: 'router-view',\n functional: true,\n props: {\n name: {\n type: String,\n default: 'default'\n }\n },\n render: function render (h, ref) {\n var props = ref.props;\n var children = ref.children;\n var parent = ref.parent;\n var data = ref.data;\n\n data.routerView = true;\n\n var name = props.name;\n var route = parent.$route;\n var cache = parent._routerViewCache || (parent._routerViewCache = {});\n\n // determine current view depth, also check to see if the tree\n // has been toggled inactive but kept-alive.\n var depth = 0;\n var inactive = false;\n while (parent) {\n if (parent.$vnode && parent.$vnode.data.routerView) {\n depth++;\n }\n if (parent._inactive) {\n inactive = true;\n }\n parent = parent.$parent;\n }\n data.routerViewDepth = depth;\n\n // render previous view if the tree is inactive and kept-alive\n if (inactive) {\n return h(cache[name], data, children)\n }\n\n var matched = route.matched[depth];\n // render empty node if no matched route\n if (!matched) {\n cache[name] = null;\n return h()\n }\n\n var component = cache[name] = matched.components[name];\n\n // inject instance registration hooks\n var hooks = data.hook || (data.hook = {});\n hooks.init = function (vnode) {\n matched.instances[name] = vnode.child;\n };\n hooks.prepatch = function (oldVnode, vnode) {\n matched.instances[name] = vnode.child;\n };\n hooks.destroy = function (vnode) {\n if (matched.instances[name] === vnode.child) {\n matched.instances[name] = undefined;\n }\n };\n\n // resolve props\n data.props = resolveProps(route, matched.props && matched.props[name]);\n\n return h(component, data, children)\n }\n};\n\nfunction resolveProps (route, config) {\n switch (typeof config) {\n case 'undefined':\n return\n case 'object':\n return config\n case 'function':\n return config(route)\n case 'boolean':\n return config ? route.params : undefined\n default:\n warn(false, (\"props in \\\"\" + (route.path) + \"\\\" is a \" + (typeof config) + \", expecting an object, function or boolean.\"));\n }\n}\n\n/* */\n\nvar encodeReserveRE = /[!'()*]/g;\nvar encodeReserveReplacer = function (c) { return '%' + c.charCodeAt(0).toString(16); };\nvar commaRE = /%2C/g;\n\n// fixed encodeURIComponent which is more comformant to RFC3986:\n// - escapes [!'()*]\n// - preserve commas\nvar encode = function (str) { return encodeURIComponent(str)\n .replace(encodeReserveRE, encodeReserveReplacer)\n .replace(commaRE, ','); };\n\nvar decode = decodeURIComponent;\n\nfunction resolveQuery (\n query,\n extraQuery\n) {\n if ( extraQuery === void 0 ) extraQuery = {};\n\n if (query) {\n var parsedQuery;\n try {\n parsedQuery = parseQuery(query);\n } catch (e) {\n \"production\" !== 'production' && warn(false, e.message);\n parsedQuery = {};\n }\n for (var key in extraQuery) {\n parsedQuery[key] = extraQuery[key];\n }\n return parsedQuery\n } else {\n return extraQuery\n }\n}\n\nfunction parseQuery (query) {\n var res = {};\n\n query = query.trim().replace(/^(\\?|#|&)/, '');\n\n if (!query) {\n return res\n }\n\n query.split('&').forEach(function (param) {\n var parts = param.replace(/\\+/g, ' ').split('=');\n var key = decode(parts.shift());\n var val = parts.length > 0\n ? decode(parts.join('='))\n : null;\n\n if (res[key] === undefined) {\n res[key] = val;\n } else if (Array.isArray(res[key])) {\n res[key].push(val);\n } else {\n res[key] = [res[key], val];\n }\n });\n\n return res\n}\n\nfunction stringifyQuery (obj) {\n var res = obj ? Object.keys(obj).map(function (key) {\n var val = obj[key];\n\n if (val === undefined) {\n return ''\n }\n\n if (val === null) {\n return encode(key)\n }\n\n if (Array.isArray(val)) {\n var result = [];\n val.slice().forEach(function (val2) {\n if (val2 === undefined) {\n return\n }\n if (val2 === null) {\n result.push(encode(key));\n } else {\n result.push(encode(key) + '=' + encode(val2));\n }\n });\n return result.join('&')\n }\n\n return encode(key) + '=' + encode(val)\n }).filter(function (x) { return x.length > 0; }).join('&') : null;\n return res ? (\"?\" + res) : ''\n}\n\n/* */\n\nvar trailingSlashRE = /\\/?$/;\n\nfunction createRoute (\n record,\n location,\n redirectedFrom\n) {\n var route = {\n name: location.name || (record && record.name),\n meta: (record && record.meta) || {},\n path: location.path || '/',\n hash: location.hash || '',\n query: location.query || {},\n params: location.params || {},\n fullPath: getFullPath(location),\n matched: record ? formatMatch(record) : []\n };\n if (redirectedFrom) {\n route.redirectedFrom = getFullPath(redirectedFrom);\n }\n return Object.freeze(route)\n}\n\n// the starting route that represents the initial state\nvar START = createRoute(null, {\n path: '/'\n});\n\nfunction formatMatch (record) {\n var res = [];\n while (record) {\n res.unshift(record);\n record = record.parent;\n }\n return res\n}\n\nfunction getFullPath (ref) {\n var path = ref.path;\n var query = ref.query; if ( query === void 0 ) query = {};\n var hash = ref.hash; if ( hash === void 0 ) hash = '';\n\n return (path || '/') + stringifyQuery(query) + hash\n}\n\nfunction isSameRoute (a, b) {\n if (b === START) {\n return a === b\n } else if (!b) {\n return false\n } else if (a.path && b.path) {\n return (\n a.path.replace(trailingSlashRE, '') === b.path.replace(trailingSlashRE, '') &&\n a.hash === b.hash &&\n isObjectEqual(a.query, b.query)\n )\n } else if (a.name && b.name) {\n return (\n a.name === b.name &&\n a.hash === b.hash &&\n isObjectEqual(a.query, b.query) &&\n isObjectEqual(a.params, b.params)\n )\n } else {\n return false\n }\n}\n\nfunction isObjectEqual (a, b) {\n if ( a === void 0 ) a = {};\n if ( b === void 0 ) b = {};\n\n var aKeys = Object.keys(a);\n var bKeys = Object.keys(b);\n if (aKeys.length !== bKeys.length) {\n return false\n }\n return aKeys.every(function (key) { return String(a[key]) === String(b[key]); })\n}\n\nfunction isIncludedRoute (current, target) {\n return (\n current.path.replace(trailingSlashRE, '/').indexOf(\n target.path.replace(trailingSlashRE, '/')\n ) === 0 &&\n (!target.hash || current.hash === target.hash) &&\n queryIncludes(current.query, target.query)\n )\n}\n\nfunction queryIncludes (current, target) {\n for (var key in target) {\n if (!(key in current)) {\n return false\n }\n }\n return true\n}\n\n/* */\n\n// work around weird flow bug\nvar toTypes = [String, Object];\nvar eventTypes = [String, Array];\n\nvar Link = {\n name: 'router-link',\n props: {\n to: {\n type: toTypes,\n required: true\n },\n tag: {\n type: String,\n default: 'a'\n },\n exact: Boolean,\n append: Boolean,\n replace: Boolean,\n activeClass: String,\n event: {\n type: eventTypes,\n default: 'click'\n }\n },\n render: function render (h) {\n var this$1 = this;\n\n var router = this.$router;\n var current = this.$route;\n var ref = router.resolve(this.to, current, this.append);\n var location = ref.location;\n var route = ref.route;\n var href = ref.href;\n var classes = {};\n var activeClass = this.activeClass || router.options.linkActiveClass || 'router-link-active';\n var compareTarget = location.path ? createRoute(null, location) : route;\n classes[activeClass] = this.exact\n ? isSameRoute(current, compareTarget)\n : isIncludedRoute(current, compareTarget);\n\n var handler = function (e) {\n if (guardEvent(e)) {\n if (this$1.replace) {\n router.replace(location);\n } else {\n router.push(location);\n }\n }\n };\n\n var on = { click: guardEvent };\n if (Array.isArray(this.event)) {\n this.event.forEach(function (e) { on[e] = handler; });\n } else {\n on[this.event] = handler;\n }\n\n var data = {\n class: classes\n };\n\n if (this.tag === 'a') {\n data.on = on;\n data.attrs = { href: href };\n } else {\n // find the first <a> child and apply listener and href\n var a = findAnchor(this.$slots.default);\n if (a) {\n // in case the <a> is a static node\n a.isStatic = false;\n var extend = _Vue.util.extend;\n var aData = a.data = extend({}, a.data);\n aData.on = on;\n var aAttrs = a.data.attrs = extend({}, a.data.attrs);\n aAttrs.href = href;\n } else {\n // doesn't have <a> child, apply listener to self\n data.on = on;\n }\n }\n\n return h(this.tag, data, this.$slots.default)\n }\n};\n\nfunction guardEvent (e) {\n // don't redirect with control keys\n if (e.metaKey || e.ctrlKey || e.shiftKey) { return }\n // don't redirect when preventDefault called\n if (e.defaultPrevented) { return }\n // don't redirect on right click\n if (e.button !== undefined && e.button !== 0) { return }\n // don't redirect if `target=\"_blank\"`\n if (e.target && e.target.getAttribute) {\n var target = e.target.getAttribute('target');\n if (/\\b_blank\\b/i.test(target)) { return }\n }\n // this may be a Weex event which doesn't have this method\n if (e.preventDefault) {\n e.preventDefault();\n }\n return true\n}\n\nfunction findAnchor (children) {\n if (children) {\n var child;\n for (var i = 0; i < children.length; i++) {\n child = children[i];\n if (child.tag === 'a') {\n return child\n }\n if (child.children && (child = findAnchor(child.children))) {\n return child\n }\n }\n }\n}\n\nvar _Vue;\n\nfunction install (Vue) {\n if (install.installed) { return }\n install.installed = true;\n\n _Vue = Vue;\n\n Object.defineProperty(Vue.prototype, '$router', {\n get: function get () { return this.$root._router }\n });\n\n Object.defineProperty(Vue.prototype, '$route', {\n get: function get () { return this.$root._route }\n });\n\n Vue.mixin({\n beforeCreate: function beforeCreate () {\n if (this.$options.router) {\n this._router = this.$options.router;\n this._router.init(this);\n Vue.util.defineReactive(this, '_route', this._router.history.current);\n }\n }\n });\n\n Vue.component('router-view', View);\n Vue.component('router-link', Link);\n\n var strats = Vue.config.optionMergeStrategies;\n // use the same hook merging strategy for route hooks\n strats.beforeRouteEnter = strats.beforeRouteLeave = strats.created;\n}\n\n/* */\n\nvar inBrowser = typeof window !== 'undefined';\n\n/* */\n\nfunction resolvePath (\n relative,\n base,\n append\n) {\n if (relative.charAt(0) === '/') {\n return relative\n }\n\n if (relative.charAt(0) === '?' || relative.charAt(0) === '#') {\n return base + relative\n }\n\n var stack = base.split('/');\n\n // remove trailing segment if:\n // - not appending\n // - appending to trailing slash (last segment is empty)\n if (!append || !stack[stack.length - 1]) {\n stack.pop();\n }\n\n // resolve relative path\n var segments = relative.replace(/^\\//, '').split('/');\n for (var i = 0; i < segments.length; i++) {\n var segment = segments[i];\n if (segment === '.') {\n continue\n } else if (segment === '..') {\n stack.pop();\n } else {\n stack.push(segment);\n }\n }\n\n // ensure leading slash\n if (stack[0] !== '') {\n stack.unshift('');\n }\n\n return stack.join('/')\n}\n\nfunction parsePath (path) {\n var hash = '';\n var query = '';\n\n var hashIndex = path.indexOf('#');\n if (hashIndex >= 0) {\n hash = path.slice(hashIndex);\n path = path.slice(0, hashIndex);\n }\n\n var queryIndex = path.indexOf('?');\n if (queryIndex >= 0) {\n query = path.slice(queryIndex + 1);\n path = path.slice(0, queryIndex);\n }\n\n return {\n path: path,\n query: query,\n hash: hash\n }\n}\n\nfunction cleanPath (path) {\n return path.replace(/\\/\\//g, '/')\n}\n\n/* */\n\nfunction createRouteMap (\n routes,\n oldPathMap,\n oldNameMap\n) {\n var pathMap = oldPathMap || Object.create(null);\n var nameMap = oldNameMap || Object.create(null);\n\n routes.forEach(function (route) {\n addRouteRecord(pathMap, nameMap, route);\n });\n\n return {\n pathMap: pathMap,\n nameMap: nameMap\n }\n}\n\nfunction addRouteRecord (\n pathMap,\n nameMap,\n route,\n parent,\n matchAs\n) {\n var path = route.path;\n var name = route.name;\n if (false) {\n assert(path != null, \"\\\"path\\\" is required in a route configuration.\");\n assert(\n typeof route.component !== 'string',\n \"route config \\\"component\\\" for path: \" + (String(path || name)) + \" cannot be a \" +\n \"string id. Use an actual component instead.\"\n );\n }\n\n var record = {\n path: normalizePath(path, parent),\n components: route.components || { default: route.component },\n instances: {},\n name: name,\n parent: parent,\n matchAs: matchAs,\n redirect: route.redirect,\n beforeEnter: route.beforeEnter,\n meta: route.meta || {},\n props: route.props == null\n ? {}\n : route.components\n ? route.props\n : { default: route.props }\n };\n\n if (route.children) {\n // Warn if route is named and has a default child route.\n // If users navigate to this route by name, the default child will\n // not be rendered (GH Issue #629)\n if (false) {\n if (route.name && route.children.some(function (child) { return /^\\/?$/.test(child.path); })) {\n warn(\n false,\n \"Named Route '\" + (route.name) + \"' has a default child route. \" +\n \"When navigating to this named route (:to=\\\"{name: '\" + (route.name) + \"'\\\"), \" +\n \"the default child route will not be rendered. Remove the name from \" +\n \"this route and use the name of the default child route for named \" +\n \"links instead.\"\n );\n }\n }\n route.children.forEach(function (child) {\n var childMatchAs = matchAs\n ? cleanPath((matchAs + \"/\" + (child.path)))\n : undefined;\n addRouteRecord(pathMap, nameMap, child, record, childMatchAs);\n });\n }\n\n if (route.alias !== undefined) {\n if (Array.isArray(route.alias)) {\n route.alias.forEach(function (alias) {\n var aliasRoute = {\n path: alias,\n children: route.children\n };\n addRouteRecord(pathMap, nameMap, aliasRoute, parent, record.path);\n });\n } else {\n var aliasRoute = {\n path: route.alias,\n children: route.children\n };\n addRouteRecord(pathMap, nameMap, aliasRoute, parent, record.path);\n }\n }\n\n if (!pathMap[record.path]) {\n pathMap[record.path] = record;\n }\n\n if (name) {\n if (!nameMap[name]) {\n nameMap[name] = record;\n } else if (false) {\n warn(\n false,\n \"Duplicate named routes definition: \" +\n \"{ name: \\\"\" + name + \"\\\", path: \\\"\" + (record.path) + \"\\\" }\"\n );\n }\n }\n}\n\nfunction normalizePath (path, parent) {\n path = path.replace(/\\/$/, '');\n if (path[0] === '/') { return path }\n if (parent == null) { return path }\n return cleanPath(((parent.path) + \"/\" + path))\n}\n\nvar index$1 = Array.isArray || function (arr) {\n return Object.prototype.toString.call(arr) == '[object Array]';\n};\n\nvar isarray = index$1;\n\n/**\n * Expose `pathToRegexp`.\n */\nvar index = pathToRegexp;\nvar parse_1 = parse;\nvar compile_1 = compile;\nvar tokensToFunction_1 = tokensToFunction;\nvar tokensToRegExp_1 = tokensToRegExp;\n\n/**\n * The main path matching regexp utility.\n *\n * @type {RegExp}\n */\nvar PATH_REGEXP = new RegExp([\n // Match escaped characters that would otherwise appear in future matches.\n // This allows the user to escape special characters that won't transform.\n '(\\\\\\\\.)',\n // Match Express-style parameters and un-named parameters with a prefix\n // and optional suffixes. Matches appear as:\n //\n // \"/:test(\\\\d+)?\" => [\"/\", \"test\", \"\\d+\", undefined, \"?\", undefined]\n // \"/route(\\\\d+)\" => [undefined, undefined, undefined, \"\\d+\", undefined, undefined]\n // \"/*\" => [\"/\", undefined, undefined, undefined, undefined, \"*\"]\n '([\\\\/.])?(?:(?:\\\\:(\\\\w+)(?:\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))?|\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))([+*?])?|(\\\\*))'\n].join('|'), 'g');\n\n/**\n * Parse a string for the raw tokens.\n *\n * @param {string} str\n * @param {Object=} options\n * @return {!Array}\n */\nfunction parse (str, options) {\n var tokens = [];\n var key = 0;\n var index = 0;\n var path = '';\n var defaultDelimiter = options && options.delimiter || '/';\n var res;\n\n while ((res = PATH_REGEXP.exec(str)) != null) {\n var m = res[0];\n var escaped = res[1];\n var offset = res.index;\n path += str.slice(index, offset);\n index = offset + m.length;\n\n // Ignore already escaped sequences.\n if (escaped) {\n path += escaped[1];\n continue\n }\n\n var next = str[index];\n var prefix = res[2];\n var name = res[3];\n var capture = res[4];\n var group = res[5];\n var modifier = res[6];\n var asterisk = res[7];\n\n // Push the current path onto the tokens.\n if (path) {\n tokens.push(path);\n path = '';\n }\n\n var partial = prefix != null && next != null && next !== prefix;\n var repeat = modifier === '+' || modifier === '*';\n var optional = modifier === '?' || modifier === '*';\n var delimiter = res[2] || defaultDelimiter;\n var pattern = capture || group;\n\n tokens.push({\n name: name || key++,\n prefix: prefix || '',\n delimiter: delimiter,\n optional: optional,\n repeat: repeat,\n partial: partial,\n asterisk: !!asterisk,\n pattern: pattern ? escapeGroup(pattern) : (asterisk ? '.*' : '[^' + escapeString(delimiter) + ']+?')\n });\n }\n\n // Match any characters still remaining.\n if (index < str.length) {\n path += str.substr(index);\n }\n\n // If the path exists, push it onto the end.\n if (path) {\n tokens.push(path);\n }\n\n return tokens\n}\n\n/**\n * Compile a string to a template function for the path.\n *\n * @param {string} str\n * @param {Object=} options\n * @return {!function(Object=, Object=)}\n */\nfunction compile (str, options) {\n return tokensToFunction(parse(str, options))\n}\n\n/**\n * Prettier encoding of URI path segments.\n *\n * @param {string}\n * @return {string}\n */\nfunction encodeURIComponentPretty (str) {\n return encodeURI(str).replace(/[\\/?#]/g, function (c) {\n return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n })\n}\n\n/**\n * Encode the asterisk parameter. Similar to `pretty`, but allows slashes.\n *\n * @param {string}\n * @return {string}\n */\nfunction encodeAsterisk (str) {\n return encodeURI(str).replace(/[?#]/g, function (c) {\n return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n })\n}\n\n/**\n * Expose a method for transforming tokens into the path function.\n */\nfunction tokensToFunction (tokens) {\n // Compile all the tokens into regexps.\n var matches = new Array(tokens.length);\n\n // Compile all the patterns before compilation.\n for (var i = 0; i < tokens.length; i++) {\n if (typeof tokens[i] === 'object') {\n matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$');\n }\n }\n\n return function (obj, opts) {\n var path = '';\n var data = obj || {};\n var options = opts || {};\n var encode = options.pretty ? encodeURIComponentPretty : encodeURIComponent;\n\n for (var i = 0; i < tokens.length; i++) {\n var token = tokens[i];\n\n if (typeof token === 'string') {\n path += token;\n\n continue\n }\n\n var value = data[token.name];\n var segment;\n\n if (value == null) {\n if (token.optional) {\n // Prepend partial segment prefixes.\n if (token.partial) {\n path += token.prefix;\n }\n\n continue\n } else {\n throw new TypeError('Expected \"' + token.name + '\" to be defined')\n }\n }\n\n if (isarray(value)) {\n if (!token.repeat) {\n throw new TypeError('Expected \"' + token.name + '\" to not repeat, but received `' + JSON.stringify(value) + '`')\n }\n\n if (value.length === 0) {\n if (token.optional) {\n continue\n } else {\n throw new TypeError('Expected \"' + token.name + '\" to not be empty')\n }\n }\n\n for (var j = 0; j < value.length; j++) {\n segment = encode(value[j]);\n\n if (!matches[i].test(segment)) {\n throw new TypeError('Expected all \"' + token.name + '\" to match \"' + token.pattern + '\", but received `' + JSON.stringify(segment) + '`')\n }\n\n path += (j === 0 ? token.prefix : token.delimiter) + segment;\n }\n\n continue\n }\n\n segment = token.asterisk ? encodeAsterisk(value) : encode(value);\n\n if (!matches[i].test(segment)) {\n throw new TypeError('Expected \"' + token.name + '\" to match \"' + token.pattern + '\", but received \"' + segment + '\"')\n }\n\n path += token.prefix + segment;\n }\n\n return path\n }\n}\n\n/**\n * Escape a regular expression string.\n *\n * @param {string} str\n * @return {string}\n */\nfunction escapeString (str) {\n return str.replace(/([.+*?=^!:${}()[\\]|\\/\\\\])/g, '\\\\$1')\n}\n\n/**\n * Escape the capturing group by escaping special characters and meaning.\n *\n * @param {string} group\n * @return {string}\n */\nfunction escapeGroup (group) {\n return group.replace(/([=!:$\\/()])/g, '\\\\$1')\n}\n\n/**\n * Attach the keys as a property of the regexp.\n *\n * @param {!RegExp} re\n * @param {Array} keys\n * @return {!RegExp}\n */\nfunction attachKeys (re, keys) {\n re.keys = keys;\n return re\n}\n\n/**\n * Get the flags for a regexp from the options.\n *\n * @param {Object} options\n * @return {string}\n */\nfunction flags (options) {\n return options.sensitive ? '' : 'i'\n}\n\n/**\n * Pull out keys from a regexp.\n *\n * @param {!RegExp} path\n * @param {!Array} keys\n * @return {!RegExp}\n */\nfunction regexpToRegexp (path, keys) {\n // Use a negative lookahead to match only capturing groups.\n var groups = path.source.match(/\\((?!\\?)/g);\n\n if (groups) {\n for (var i = 0; i < groups.length; i++) {\n keys.push({\n name: i,\n prefix: null,\n delimiter: null,\n optional: false,\n repeat: false,\n partial: false,\n asterisk: false,\n pattern: null\n });\n }\n }\n\n return attachKeys(path, keys)\n}\n\n/**\n * Transform an array into a regexp.\n *\n * @param {!Array} path\n * @param {Array} keys\n * @param {!Object} options\n * @return {!RegExp}\n */\nfunction arrayToRegexp (path, keys, options) {\n var parts = [];\n\n for (var i = 0; i < path.length; i++) {\n parts.push(pathToRegexp(path[i], keys, options).source);\n }\n\n var regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options));\n\n return attachKeys(regexp, keys)\n}\n\n/**\n * Create a path regexp from string input.\n *\n * @param {string} path\n * @param {!Array} keys\n * @param {!Object} options\n * @return {!RegExp}\n */\nfunction stringToRegexp (path, keys, options) {\n return tokensToRegExp(parse(path, options), keys, options)\n}\n\n/**\n * Expose a function for taking tokens and returning a RegExp.\n *\n * @param {!Array} tokens\n * @param {(Array|Object)=} keys\n * @param {Object=} options\n * @return {!RegExp}\n */\nfunction tokensToRegExp (tokens, keys, options) {\n if (!isarray(keys)) {\n options = /** @type {!Object} */ (keys || options);\n keys = [];\n }\n\n options = options || {};\n\n var strict = options.strict;\n var end = options.end !== false;\n var route = '';\n\n // Iterate over the tokens and create our regexp string.\n for (var i = 0; i < tokens.length; i++) {\n var token = tokens[i];\n\n if (typeof token === 'string') {\n route += escapeString(token);\n } else {\n var prefix = escapeString(token.prefix);\n var capture = '(?:' + token.pattern + ')';\n\n keys.push(token);\n\n if (token.repeat) {\n capture += '(?:' + prefix + capture + ')*';\n }\n\n if (token.optional) {\n if (!token.partial) {\n capture = '(?:' + prefix + '(' + capture + '))?';\n } else {\n capture = prefix + '(' + capture + ')?';\n }\n } else {\n capture = prefix + '(' + capture + ')';\n }\n\n route += capture;\n }\n }\n\n var delimiter = escapeString(options.delimiter || '/');\n var endsWithDelimiter = route.slice(-delimiter.length) === delimiter;\n\n // In non-strict mode we allow a slash at the end of match. If the path to\n // match already ends with a slash, we remove it for consistency. The slash\n // is valid at the end of a path match, not in the middle. This is important\n // in non-ending mode, where \"/test/\" shouldn't match \"/test//route\".\n if (!strict) {\n route = (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) + '(?:' + delimiter + '(?=$))?';\n }\n\n if (end) {\n route += '$';\n } else {\n // In non-ending mode, we need the capturing groups to match as much as\n // possible by using a positive lookahead to the end or next path segment.\n route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)';\n }\n\n return attachKeys(new RegExp('^' + route, flags(options)), keys)\n}\n\n/**\n * Normalize the given path string, returning a regular expression.\n *\n * An empty array can be passed in for the keys, which will hold the\n * placeholder key descriptions. For example, using `/user/:id`, `keys` will\n * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.\n *\n * @param {(string|RegExp|Array)} path\n * @param {(Array|Object)=} keys\n * @param {Object=} options\n * @return {!RegExp}\n */\nfunction pathToRegexp (path, keys, options) {\n if (!isarray(keys)) {\n options = /** @type {!Object} */ (keys || options);\n keys = [];\n }\n\n options = options || {};\n\n if (path instanceof RegExp) {\n return regexpToRegexp(path, /** @type {!Array} */ (keys))\n }\n\n if (isarray(path)) {\n return arrayToRegexp(/** @type {!Array} */ (path), /** @type {!Array} */ (keys), options)\n }\n\n return stringToRegexp(/** @type {string} */ (path), /** @type {!Array} */ (keys), options)\n}\n\nindex.parse = parse_1;\nindex.compile = compile_1;\nindex.tokensToFunction = tokensToFunction_1;\nindex.tokensToRegExp = tokensToRegExp_1;\n\n/* */\n\nvar regexpCache = Object.create(null);\n\nfunction getRouteRegex (path) {\n var hit = regexpCache[path];\n var keys, regexp;\n\n if (hit) {\n keys = hit.keys;\n regexp = hit.regexp;\n } else {\n keys = [];\n regexp = index(path, keys);\n regexpCache[path] = { keys: keys, regexp: regexp };\n }\n\n return { keys: keys, regexp: regexp }\n}\n\nvar regexpCompileCache = Object.create(null);\n\nfunction fillParams (\n path,\n params,\n routeMsg\n) {\n try {\n var filler =\n regexpCompileCache[path] ||\n (regexpCompileCache[path] = index.compile(path));\n return filler(params || {}, { pretty: true })\n } catch (e) {\n if (false) {\n warn(false, (\"missing param for \" + routeMsg + \": \" + (e.message)));\n }\n return ''\n }\n}\n\n/* */\n\nfunction normalizeLocation (\n raw,\n current,\n append\n) {\n var next = typeof raw === 'string' ? { path: raw } : raw;\n // named target\n if (next.name || next._normalized) {\n return next\n }\n\n // relative params\n if (!next.path && next.params && current) {\n next = assign({}, next);\n next._normalized = true;\n var params = assign(assign({}, current.params), next.params);\n if (current.name) {\n next.name = current.name;\n next.params = params;\n } else if (current.matched) {\n var rawPath = current.matched[current.matched.length - 1].path;\n next.path = fillParams(rawPath, params, (\"path \" + (current.path)));\n } else if (false) {\n warn(false, \"relative params navigation requires a current route.\");\n }\n return next\n }\n\n var parsedPath = parsePath(next.path || '');\n var basePath = (current && current.path) || '/';\n var path = parsedPath.path\n ? resolvePath(parsedPath.path, basePath, append || next.append)\n : (current && current.path) || '/';\n var query = resolveQuery(parsedPath.query, next.query);\n var hash = next.hash || parsedPath.hash;\n if (hash && hash.charAt(0) !== '#') {\n hash = \"#\" + hash;\n }\n\n return {\n _normalized: true,\n path: path,\n query: query,\n hash: hash\n }\n}\n\nfunction assign (a, b) {\n for (var key in b) {\n a[key] = b[key];\n }\n return a\n}\n\n/* */\n\nfunction createMatcher (routes) {\n var ref = createRouteMap(routes);\n var pathMap = ref.pathMap;\n var nameMap = ref.nameMap;\n\n function addRoutes (routes) {\n createRouteMap(routes, pathMap, nameMap);\n }\n\n function match (\n raw,\n currentRoute,\n redirectedFrom\n ) {\n var location = normalizeLocation(raw, currentRoute);\n var name = location.name;\n\n if (name) {\n var record = nameMap[name];\n if (false) {\n warn(record, (\"Route with name '\" + name + \"' does not exist\"));\n }\n var paramNames = getRouteRegex(record.path).keys\n .filter(function (key) { return !key.optional; })\n .map(function (key) { return key.name; });\n\n if (typeof location.params !== 'object') {\n location.params = {};\n }\n\n if (currentRoute && typeof currentRoute.params === 'object') {\n for (var key in currentRoute.params) {\n if (!(key in location.params) && paramNames.indexOf(key) > -1) {\n location.params[key] = currentRoute.params[key];\n }\n }\n }\n\n if (record) {\n location.path = fillParams(record.path, location.params, (\"named route \\\"\" + name + \"\\\"\"));\n return _createRoute(record, location, redirectedFrom)\n }\n } else if (location.path) {\n location.params = {};\n for (var path in pathMap) {\n if (matchRoute(path, location.params, location.path)) {\n return _createRoute(pathMap[path], location, redirectedFrom)\n }\n }\n }\n // no match\n return _createRoute(null, location)\n }\n\n function redirect (\n record,\n location\n ) {\n var originalRedirect = record.redirect;\n var redirect = typeof originalRedirect === 'function'\n ? originalRedirect(createRoute(record, location))\n : originalRedirect;\n\n if (typeof redirect === 'string') {\n redirect = { path: redirect };\n }\n\n if (!redirect || typeof redirect !== 'object') {\n \"production\" !== 'production' && warn(\n false, (\"invalid redirect option: \" + (JSON.stringify(redirect)))\n );\n return _createRoute(null, location)\n }\n\n var re = redirect;\n var name = re.name;\n var path = re.path;\n var query = location.query;\n var hash = location.hash;\n var params = location.params;\n query = re.hasOwnProperty('query') ? re.query : query;\n hash = re.hasOwnProperty('hash') ? re.hash : hash;\n params = re.hasOwnProperty('params') ? re.params : params;\n\n if (name) {\n // resolved named direct\n var targetRecord = nameMap[name];\n if (false) {\n assert(targetRecord, (\"redirect failed: named route \\\"\" + name + \"\\\" not found.\"));\n }\n return match({\n _normalized: true,\n name: name,\n query: query,\n hash: hash,\n params: params\n }, undefined, location)\n } else if (path) {\n // 1. resolve relative redirect\n var rawPath = resolveRecordPath(path, record);\n // 2. resolve params\n var resolvedPath = fillParams(rawPath, params, (\"redirect route with path \\\"\" + rawPath + \"\\\"\"));\n // 3. rematch with existing query and hash\n return match({\n _normalized: true,\n path: resolvedPath,\n query: query,\n hash: hash\n }, undefined, location)\n } else {\n warn(false, (\"invalid redirect option: \" + (JSON.stringify(redirect))));\n return _createRoute(null, location)\n }\n }\n\n function alias (\n record,\n location,\n matchAs\n ) {\n var aliasedPath = fillParams(matchAs, location.params, (\"aliased route with path \\\"\" + matchAs + \"\\\"\"));\n var aliasedMatch = match({\n _normalized: true,\n path: aliasedPath\n });\n if (aliasedMatch) {\n var matched = aliasedMatch.matched;\n var aliasedRecord = matched[matched.length - 1];\n location.params = aliasedMatch.params;\n return _createRoute(aliasedRecord, location)\n }\n return _createRoute(null, location)\n }\n\n function _createRoute (\n record,\n location,\n redirectedFrom\n ) {\n if (record && record.redirect) {\n return redirect(record, redirectedFrom || location)\n }\n if (record && record.matchAs) {\n return alias(record, location, record.matchAs)\n }\n return createRoute(record, location, redirectedFrom)\n }\n\n return {\n match: match,\n addRoutes: addRoutes\n }\n}\n\nfunction matchRoute (\n path,\n params,\n pathname\n) {\n var ref = getRouteRegex(path);\n var regexp = ref.regexp;\n var keys = ref.keys;\n var m = pathname.match(regexp);\n\n if (!m) {\n return false\n } else if (!params) {\n return true\n }\n\n for (var i = 1, len = m.length; i < len; ++i) {\n var key = keys[i - 1];\n var val = typeof m[i] === 'string' ? decodeURIComponent(m[i]) : m[i];\n if (key) { params[key.name] = val; }\n }\n\n return true\n}\n\nfunction resolveRecordPath (path, record) {\n return resolvePath(path, record.parent ? record.parent.path : '/', true)\n}\n\n/* */\n\n\nvar positionStore = Object.create(null);\n\nfunction setupScroll () {\n window.addEventListener('popstate', function (e) {\n saveScrollPosition();\n if (e.state && e.state.key) {\n setStateKey(e.state.key);\n }\n });\n}\n\nfunction handleScroll (\n router,\n to,\n from,\n isPop\n) {\n if (!router.app) {\n return\n }\n\n var behavior = router.options.scrollBehavior;\n if (!behavior) {\n return\n }\n\n if (false) {\n assert(typeof behavior === 'function', \"scrollBehavior must be a function\");\n }\n\n // wait until re-render finishes before scrolling\n router.app.$nextTick(function () {\n var position = getScrollPosition();\n var shouldScroll = behavior(to, from, isPop ? position : null);\n if (!shouldScroll) {\n return\n }\n var isObject = typeof shouldScroll === 'object';\n if (isObject && typeof shouldScroll.selector === 'string') {\n var el = document.querySelector(shouldScroll.selector);\n if (el) {\n position = getElementPosition(el);\n } else if (isValidPosition(shouldScroll)) {\n position = normalizePosition(shouldScroll);\n }\n } else if (isObject && isValidPosition(shouldScroll)) {\n position = normalizePosition(shouldScroll);\n }\n\n if (position) {\n window.scrollTo(position.x, position.y);\n }\n });\n}\n\nfunction saveScrollPosition () {\n var key = getStateKey();\n if (key) {\n positionStore[key] = {\n x: window.pageXOffset,\n y: window.pageYOffset\n };\n }\n}\n\nfunction getScrollPosition () {\n var key = getStateKey();\n if (key) {\n return positionStore[key]\n }\n}\n\nfunction getElementPosition (el) {\n var docRect = document.documentElement.getBoundingClientRect();\n var elRect = el.getBoundingClientRect();\n return {\n x: elRect.left - docRect.left,\n y: elRect.top - docRect.top\n }\n}\n\nfunction isValidPosition (obj) {\n return isNumber(obj.x) || isNumber(obj.y)\n}\n\nfunction normalizePosition (obj) {\n return {\n x: isNumber(obj.x) ? obj.x : window.pageXOffset,\n y: isNumber(obj.y) ? obj.y : window.pageYOffset\n }\n}\n\nfunction isNumber (v) {\n return typeof v === 'number'\n}\n\n/* */\n\nvar supportsPushState = inBrowser && (function () {\n var ua = window.navigator.userAgent;\n\n if (\n (ua.indexOf('Android 2.') !== -1 || ua.indexOf('Android 4.0') !== -1) &&\n ua.indexOf('Mobile Safari') !== -1 &&\n ua.indexOf('Chrome') === -1 &&\n ua.indexOf('Windows Phone') === -1\n ) {\n return false\n }\n\n return window.history && 'pushState' in window.history\n})();\n\n// use User Timing api (if present) for more accurate key precision\nvar Time = inBrowser && window.performance && window.performance.now\n ? window.performance\n : Date;\n\nvar _key = genKey();\n\nfunction genKey () {\n return Time.now().toFixed(3)\n}\n\nfunction getStateKey () {\n return _key\n}\n\nfunction setStateKey (key) {\n _key = key;\n}\n\nfunction pushState (url, replace) {\n saveScrollPosition();\n // try...catch the pushState call to get around Safari\n // DOM Exception 18 where it limits to 100 pushState calls\n var history = window.history;\n try {\n if (replace) {\n history.replaceState({ key: _key }, '', url);\n } else {\n _key = genKey();\n history.pushState({ key: _key }, '', url);\n }\n } catch (e) {\n window.location[replace ? 'replace' : 'assign'](url);\n }\n}\n\nfunction replaceState (url) {\n pushState(url, true);\n}\n\n/* */\n\nfunction runQueue (queue, fn, cb) {\n var step = function (index) {\n if (index >= queue.length) {\n cb();\n } else {\n if (queue[index]) {\n fn(queue[index], function () {\n step(index + 1);\n });\n } else {\n step(index + 1);\n }\n }\n };\n step(0);\n}\n\n/* */\n\n\nvar History = function History (router, base) {\n this.router = router;\n this.base = normalizeBase(base);\n // start with a route object that stands for \"nowhere\"\n this.current = START;\n this.pending = null;\n this.ready = false;\n this.readyCbs = [];\n};\n\nHistory.prototype.listen = function listen (cb) {\n this.cb = cb;\n};\n\nHistory.prototype.onReady = function onReady (cb) {\n if (this.ready) {\n cb();\n } else {\n this.readyCbs.push(cb);\n }\n};\n\nHistory.prototype.transitionTo = function transitionTo (location, onComplete, onAbort) {\n var this$1 = this;\n\n var route = this.router.match(location, this.current);\n this.confirmTransition(route, function () {\n this$1.updateRoute(route);\n onComplete && onComplete(route);\n this$1.ensureURL();\n\n // fire ready cbs once\n if (!this$1.ready) {\n this$1.ready = true;\n this$1.readyCbs.forEach(function (cb) {\n cb(route);\n });\n }\n }, onAbort);\n};\n\nHistory.prototype.confirmTransition = function confirmTransition (route, onComplete, onAbort) {\n var this$1 = this;\n\n var current = this.current;\n var abort = function () { onAbort && onAbort(); };\n if (\n isSameRoute(route, current) &&\n // in the case the route map has been dynamically appended to\n route.matched.length === current.matched.length\n ) {\n this.ensureURL();\n return abort()\n }\n\n var ref = resolveQueue(this.current.matched, route.matched);\n var updated = ref.updated;\n var deactivated = ref.deactivated;\n var activated = ref.activated;\n\n var queue = [].concat(\n // in-component leave guards\n extractLeaveGuards(deactivated),\n // global before hooks\n this.router.beforeHooks,\n // in-component update hooks\n extractUpdateHooks(updated),\n // in-config enter guards\n activated.map(function (m) { return m.beforeEnter; }),\n // async components\n resolveAsyncComponents(activated)\n );\n\n this.pending = route;\n var iterator = function (hook, next) {\n if (this$1.pending !== route) {\n return abort()\n }\n hook(route, current, function (to) {\n if (to === false) {\n // next(false) -> abort navigation, ensure current URL\n this$1.ensureURL(true);\n abort();\n } else if (typeof to === 'string' || typeof to === 'object') {\n // next('/') or next({ path: '/' }) -> redirect\n (typeof to === 'object' && to.replace) ? this$1.replace(to) : this$1.push(to);\n abort();\n } else {\n // confirm transition and pass on the value\n next(to);\n }\n });\n };\n\n runQueue(queue, iterator, function () {\n var postEnterCbs = [];\n var isValid = function () { return this$1.current === route; };\n var enterGuards = extractEnterGuards(activated, postEnterCbs, isValid);\n // wait until async components are resolved before\n // extracting in-component enter guards\n runQueue(enterGuards, iterator, function () {\n if (this$1.pending !== route) {\n return abort()\n }\n this$1.pending = null;\n onComplete(route);\n if (this$1.router.app) {\n this$1.router.app.$nextTick(function () {\n postEnterCbs.forEach(function (cb) { return cb(); });\n });\n }\n });\n });\n};\n\nHistory.prototype.updateRoute = function updateRoute (route) {\n var prev = this.current;\n this.current = route;\n this.cb && this.cb(route);\n this.router.afterHooks.forEach(function (hook) {\n hook && hook(route, prev);\n });\n};\n\nfunction normalizeBase (base) {\n if (!base) {\n if (inBrowser) {\n // respect <base> tag\n var baseEl = document.querySelector('base');\n base = baseEl ? baseEl.getAttribute('href') : '/';\n } else {\n base = '/';\n }\n }\n // make sure there's the starting slash\n if (base.charAt(0) !== '/') {\n base = '/' + base;\n }\n // remove trailing slash\n return base.replace(/\\/$/, '')\n}\n\nfunction resolveQueue (\n current,\n next\n) {\n var i;\n var max = Math.max(current.length, next.length);\n for (i = 0; i < max; i++) {\n if (current[i] !== next[i]) {\n break\n }\n }\n return {\n updated: next.slice(0, i),\n activated: next.slice(i),\n deactivated: current.slice(i)\n }\n}\n\nfunction extractGuards (\n records,\n name,\n bind,\n reverse\n) {\n var guards = flatMapComponents(records, function (def, instance, match, key) {\n var guard = extractGuard(def, name);\n if (guard) {\n return Array.isArray(guard)\n ? guard.map(function (guard) { return bind(guard, instance, match, key); })\n : bind(guard, instance, match, key)\n }\n });\n return flatten(reverse ? guards.reverse() : guards)\n}\n\nfunction extractGuard (\n def,\n key\n) {\n if (typeof def !== 'function') {\n // extend now so that global mixins are applied.\n def = _Vue.extend(def);\n }\n return def.options[key]\n}\n\nfunction extractLeaveGuards (deactivated) {\n return extractGuards(deactivated, 'beforeRouteLeave', bindGuard, true)\n}\n\nfunction extractUpdateHooks (updated) {\n return extractGuards(updated, 'beforeRouteUpdate', bindGuard)\n}\n\nfunction bindGuard (guard, instance) {\n return function boundRouteGuard () {\n return guard.apply(instance, arguments)\n }\n}\n\nfunction extractEnterGuards (\n activated,\n cbs,\n isValid\n) {\n return extractGuards(activated, 'beforeRouteEnter', function (guard, _, match, key) {\n return bindEnterGuard(guard, match, key, cbs, isValid)\n })\n}\n\nfunction bindEnterGuard (\n guard,\n match,\n key,\n cbs,\n isValid\n) {\n return function routeEnterGuard (to, from, next) {\n return guard(to, from, function (cb) {\n next(cb);\n if (typeof cb === 'function') {\n cbs.push(function () {\n // #750\n // if a router-view is wrapped with an out-in transition,\n // the instance may not have been registered at this time.\n // we will need to poll for registration until current route\n // is no longer valid.\n poll(cb, match.instances, key, isValid);\n });\n }\n })\n }\n}\n\nfunction poll (\n cb, // somehow flow cannot infer this is a function\n instances,\n key,\n isValid\n) {\n if (instances[key]) {\n cb(instances[key]);\n } else if (isValid()) {\n setTimeout(function () {\n poll(cb, instances, key, isValid);\n }, 16);\n }\n}\n\nfunction resolveAsyncComponents (matched) {\n return flatMapComponents(matched, function (def, _, match, key) {\n // if it's a function and doesn't have Vue options attached,\n // assume it's an async component resolve function.\n // we are not using Vue's default async resolving mechanism because\n // we want to halt the navigation until the incoming component has been\n // resolved.\n if (typeof def === 'function' && !def.options) {\n return function (to, from, next) {\n var resolve = once(function (resolvedDef) {\n match.components[key] = resolvedDef;\n next();\n });\n\n var reject = once(function (reason) {\n warn(false, (\"Failed to resolve async component \" + key + \": \" + reason));\n next(false);\n });\n\n var res = def(resolve, reject);\n if (res && typeof res.then === 'function') {\n res.then(resolve, reject);\n }\n }\n }\n })\n}\n\nfunction flatMapComponents (\n matched,\n fn\n) {\n return flatten(matched.map(function (m) {\n return Object.keys(m.components).map(function (key) { return fn(\n m.components[key],\n m.instances[key],\n m, key\n ); })\n }))\n}\n\nfunction flatten (arr) {\n return Array.prototype.concat.apply([], arr)\n}\n\n// in Webpack 2, require.ensure now also returns a Promise\n// so the resolve/reject functions may get called an extra time\n// if the user uses an arrow function shorthand that happens to\n// return that Promise.\nfunction once (fn) {\n var called = false;\n return function () {\n if (called) { return }\n called = true;\n return fn.apply(this, arguments)\n }\n}\n\n/* */\n\n\nvar HTML5History = (function (History$$1) {\n function HTML5History (router, base) {\n var this$1 = this;\n\n History$$1.call(this, router, base);\n\n var expectScroll = router.options.scrollBehavior;\n\n if (expectScroll) {\n setupScroll();\n }\n\n window.addEventListener('popstate', function (e) {\n this$1.transitionTo(getLocation(this$1.base), function (route) {\n if (expectScroll) {\n handleScroll(router, route, this$1.current, true);\n }\n });\n });\n }\n\n if ( History$$1 ) HTML5History.__proto__ = History$$1;\n HTML5History.prototype = Object.create( History$$1 && History$$1.prototype );\n HTML5History.prototype.constructor = HTML5History;\n\n HTML5History.prototype.go = function go (n) {\n window.history.go(n);\n };\n\n HTML5History.prototype.push = function push (location, onComplete, onAbort) {\n var this$1 = this;\n\n this.transitionTo(location, function (route) {\n pushState(cleanPath(this$1.base + route.fullPath));\n handleScroll(this$1.router, route, this$1.current, false);\n onComplete && onComplete(route);\n }, onAbort);\n };\n\n HTML5History.prototype.replace = function replace (location, onComplete, onAbort) {\n var this$1 = this;\n\n this.transitionTo(location, function (route) {\n replaceState(cleanPath(this$1.base + route.fullPath));\n handleScroll(this$1.router, route, this$1.current, false);\n onComplete && onComplete(route);\n }, onAbort);\n };\n\n HTML5History.prototype.ensureURL = function ensureURL (push) {\n if (getLocation(this.base) !== this.current.fullPath) {\n var current = cleanPath(this.base + this.current.fullPath);\n push ? pushState(current) : replaceState(current);\n }\n };\n\n HTML5History.prototype.getCurrentLocation = function getCurrentLocation () {\n return getLocation(this.base)\n };\n\n return HTML5History;\n}(History));\n\nfunction getLocation (base) {\n var path = window.location.pathname;\n if (base && path.indexOf(base) === 0) {\n path = path.slice(base.length);\n }\n return (path || '/') + window.location.search + window.location.hash\n}\n\n/* */\n\n\nvar HashHistory = (function (History$$1) {\n function HashHistory (router, base, fallback) {\n History$$1.call(this, router, base);\n // check history fallback deeplinking\n if (fallback && checkFallback(this.base)) {\n return\n }\n ensureSlash();\n }\n\n if ( History$$1 ) HashHistory.__proto__ = History$$1;\n HashHistory.prototype = Object.create( History$$1 && History$$1.prototype );\n HashHistory.prototype.constructor = HashHistory;\n\n // this is delayed until the app mounts\n // to avoid the hashchange listener being fired too early\n HashHistory.prototype.setupListeners = function setupListeners () {\n var this$1 = this;\n\n window.addEventListener('hashchange', function () {\n if (!ensureSlash()) {\n return\n }\n this$1.transitionTo(getHash(), function (route) {\n replaceHash(route.fullPath);\n });\n });\n };\n\n HashHistory.prototype.push = function push (location, onComplete, onAbort) {\n this.transitionTo(location, function (route) {\n pushHash(route.fullPath);\n onComplete && onComplete(route);\n }, onAbort);\n };\n\n HashHistory.prototype.replace = function replace (location, onComplete, onAbort) {\n this.transitionTo(location, function (route) {\n replaceHash(route.fullPath);\n onComplete && onComplete(route);\n }, onAbort);\n };\n\n HashHistory.prototype.go = function go (n) {\n window.history.go(n);\n };\n\n HashHistory.prototype.ensureURL = function ensureURL (push) {\n var current = this.current.fullPath;\n if (getHash() !== current) {\n push ? pushHash(current) : replaceHash(current);\n }\n };\n\n HashHistory.prototype.getCurrentLocation = function getCurrentLocation () {\n return getHash()\n };\n\n return HashHistory;\n}(History));\n\nfunction checkFallback (base) {\n var location = getLocation(base);\n if (!/^\\/#/.test(location)) {\n window.location.replace(\n cleanPath(base + '/#' + location)\n );\n return true\n }\n}\n\nfunction ensureSlash () {\n var path = getHash();\n if (path.charAt(0) === '/') {\n return true\n }\n replaceHash('/' + path);\n return false\n}\n\nfunction getHash () {\n // We can't use window.location.hash here because it's not\n // consistent across browsers - Firefox will pre-decode it!\n var href = window.location.href;\n var index = href.indexOf('#');\n return index === -1 ? '' : href.slice(index + 1)\n}\n\nfunction pushHash (path) {\n window.location.hash = path;\n}\n\nfunction replaceHash (path) {\n var i = window.location.href.indexOf('#');\n window.location.replace(\n window.location.href.slice(0, i >= 0 ? i : 0) + '#' + path\n );\n}\n\n/* */\n\n\nvar AbstractHistory = (function (History$$1) {\n function AbstractHistory (router, base) {\n History$$1.call(this, router, base);\n this.stack = [];\n this.index = -1;\n }\n\n if ( History$$1 ) AbstractHistory.__proto__ = History$$1;\n AbstractHistory.prototype = Object.create( History$$1 && History$$1.prototype );\n AbstractHistory.prototype.constructor = AbstractHistory;\n\n AbstractHistory.prototype.push = function push (location, onComplete, onAbort) {\n var this$1 = this;\n\n this.transitionTo(location, function (route) {\n this$1.stack = this$1.stack.slice(0, this$1.index + 1).concat(route);\n this$1.index++;\n onComplete && onComplete(route);\n }, onAbort);\n };\n\n AbstractHistory.prototype.replace = function replace (location, onComplete, onAbort) {\n var this$1 = this;\n\n this.transitionTo(location, function (route) {\n this$1.stack = this$1.stack.slice(0, this$1.index).concat(route);\n onComplete && onComplete(route);\n }, onAbort);\n };\n\n AbstractHistory.prototype.go = function go (n) {\n var this$1 = this;\n\n var targetIndex = this.index + n;\n if (targetIndex < 0 || targetIndex >= this.stack.length) {\n return\n }\n var route = this.stack[targetIndex];\n this.confirmTransition(route, function () {\n this$1.index = targetIndex;\n this$1.updateRoute(route);\n });\n };\n\n AbstractHistory.prototype.getCurrentLocation = function getCurrentLocation () {\n var current = this.stack[this.stack.length - 1];\n return current ? current.fullPath : '/'\n };\n\n AbstractHistory.prototype.ensureURL = function ensureURL () {\n // noop\n };\n\n return AbstractHistory;\n}(History));\n\n/* */\n\nvar VueRouter = function VueRouter (options) {\n if ( options === void 0 ) options = {};\n\n this.app = null;\n this.apps = [];\n this.options = options;\n this.beforeHooks = [];\n this.afterHooks = [];\n this.matcher = createMatcher(options.routes || []);\n\n var mode = options.mode || 'hash';\n this.fallback = mode === 'history' && !supportsPushState;\n if (this.fallback) {\n mode = 'hash';\n }\n if (!inBrowser) {\n mode = 'abstract';\n }\n this.mode = mode;\n\n switch (mode) {\n case 'history':\n this.history = new HTML5History(this, options.base);\n break\n case 'hash':\n this.history = new HashHistory(this, options.base, this.fallback);\n break\n case 'abstract':\n this.history = new AbstractHistory(this, options.base);\n break\n default:\n if (false) {\n assert(false, (\"invalid mode: \" + mode));\n }\n }\n};\n\nvar prototypeAccessors = { currentRoute: {} };\n\nVueRouter.prototype.match = function match (\n raw,\n current,\n redirectedFrom\n) {\n return this.matcher.match(raw, current, redirectedFrom)\n};\n\nprototypeAccessors.currentRoute.get = function () {\n return this.history && this.history.current\n};\n\nVueRouter.prototype.init = function init (app /* Vue component instance */) {\n var this$1 = this;\n\n \"production\" !== 'production' && assert(\n install.installed,\n \"not installed. Make sure to call `Vue.use(VueRouter)` \" +\n \"before creating root instance.\"\n );\n\n this.apps.push(app);\n\n // main app already initialized.\n if (this.app) {\n return\n }\n\n this.app = app;\n\n var history = this.history;\n\n if (history instanceof HTML5History) {\n history.transitionTo(history.getCurrentLocation());\n } else if (history instanceof HashHistory) {\n var setupHashListener = function () {\n history.setupListeners();\n };\n history.transitionTo(\n history.getCurrentLocation(),\n setupHashListener,\n setupHashListener\n );\n }\n\n history.listen(function (route) {\n this$1.apps.forEach(function (app) {\n app._route = route;\n });\n });\n};\n\nVueRouter.prototype.beforeEach = function beforeEach (fn) {\n this.beforeHooks.push(fn);\n};\n\nVueRouter.prototype.afterEach = function afterEach (fn) {\n this.afterHooks.push(fn);\n};\n\nVueRouter.prototype.onReady = function onReady (cb) {\n this.history.onReady(cb);\n};\n\nVueRouter.prototype.push = function push (location, onComplete, onAbort) {\n this.history.push(location, onComplete, onAbort);\n};\n\nVueRouter.prototype.replace = function replace (location, onComplete, onAbort) {\n this.history.replace(location, onComplete, onAbort);\n};\n\nVueRouter.prototype.go = function go (n) {\n this.history.go(n);\n};\n\nVueRouter.prototype.back = function back () {\n this.go(-1);\n};\n\nVueRouter.prototype.forward = function forward () {\n this.go(1);\n};\n\nVueRouter.prototype.getMatchedComponents = function getMatchedComponents (to) {\n var route = to\n ? this.resolve(to).route\n : this.currentRoute;\n if (!route) {\n return []\n }\n return [].concat.apply([], route.matched.map(function (m) {\n return Object.keys(m.components).map(function (key) {\n return m.components[key]\n })\n }))\n};\n\nVueRouter.prototype.resolve = function resolve (\n to,\n current,\n append\n) {\n var location = normalizeLocation(to, current || this.history.current, append);\n var route = this.match(location, current);\n var fullPath = route.redirectedFrom || route.fullPath;\n var base = this.history.base;\n var href = createHref(base, fullPath, this.mode);\n return {\n location: location,\n route: route,\n href: href,\n // for backwards compat\n normalizedTo: location,\n resolved: route\n }\n};\n\nVueRouter.prototype.addRoutes = function addRoutes (routes) {\n this.matcher.addRoutes(routes);\n if (this.history.current !== START) {\n this.history.transitionTo(this.history.getCurrentLocation());\n }\n};\n\nObject.defineProperties( VueRouter.prototype, prototypeAccessors );\n\nfunction createHref (base, fullPath, mode) {\n var path = mode === 'hash' ? '#' + fullPath : fullPath;\n return base ? cleanPath(base + '/' + path) : path\n}\n\nVueRouter.install = install;\nVueRouter.version = '2.2.1';\n\nif (inBrowser && window.Vue) {\n window.Vue.use(VueRouter);\n}\n\nmodule.exports = VueRouter;\n\n\n/***/ }),\n/* 81 */\n/***/ (function(module, exports) {\n\n/**\n * Translates the list format produced by css-loader into something\n * easier to manipulate.\n */\nmodule.exports = function listToStyles (parentId, list) {\n var styles = []\n var newStyles = {}\n for (var i = 0; i < list.length; i++) {\n var item = list[i]\n var id = item[0]\n var css = item[1]\n var media = item[2]\n var sourceMap = item[3]\n var part = {\n id: parentId + ':' + i,\n css: css,\n media: media,\n sourceMap: sourceMap\n }\n if (!newStyles[id]) {\n styles.push(newStyles[id] = { id: id, parts: [part] })\n } else {\n newStyles[id].parts.push(part)\n }\n }\n return styles\n}\n\n\n/***/ }),\n/* 82 */\n/***/ (function(module, exports) {\n\nvar g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n/***/ }),\n/* 83 */,\n/* 84 */\n/***/ (function(module, exports) {\n\n/*\r\n\tMIT License http://www.opensource.org/licenses/mit-license.php\r\n\tAuthor Tobias Koppers @sokra\r\n*/\r\n// css base code, injected by the css-loader\r\nmodule.exports = function() {\r\n\tvar list = [];\r\n\r\n\t// return the list of modules as css string\r\n\tlist.toString = function toString() {\r\n\t\tvar result = [];\r\n\t\tfor(var i = 0; i < this.length; i++) {\r\n\t\t\tvar item = this[i];\r\n\t\t\tif(item[2]) {\r\n\t\t\t\tresult.push(\"@media \" + item[2] + \"{\" + item[1] + \"}\");\r\n\t\t\t} else {\r\n\t\t\t\tresult.push(item[1]);\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn result.join(\"\");\r\n\t};\r\n\r\n\t// import a list of modules into the list\r\n\tlist.i = function(modules, mediaQuery) {\r\n\t\tif(typeof modules === \"string\")\r\n\t\t\tmodules = [[null, modules, \"\"]];\r\n\t\tvar alreadyImportedModules = {};\r\n\t\tfor(var i = 0; i < this.length; i++) {\r\n\t\t\tvar id = this[i][0];\r\n\t\t\tif(typeof id === \"number\")\r\n\t\t\t\talreadyImportedModules[id] = true;\r\n\t\t}\r\n\t\tfor(i = 0; i < modules.length; i++) {\r\n\t\t\tvar item = modules[i];\r\n\t\t\t// skip already imported module\r\n\t\t\t// this implementation is not 100% perfect for weird media query combinations\r\n\t\t\t// when a module is imported multiple times with different media queries.\r\n\t\t\t// I hope this will never occur (Hey this way we have smaller bundles)\r\n\t\t\tif(typeof item[0] !== \"number\" || !alreadyImportedModules[item[0]]) {\r\n\t\t\t\tif(mediaQuery && !item[2]) {\r\n\t\t\t\t\titem[2] = mediaQuery;\r\n\t\t\t\t} else if(mediaQuery) {\r\n\t\t\t\t\titem[2] = \"(\" + item[2] + \") and (\" + mediaQuery + \")\";\r\n\t\t\t\t}\r\n\t\t\t\tlist.push(item);\r\n\t\t\t}\r\n\t\t}\r\n\t};\r\n\treturn list;\r\n};\r\n\n\n/***/ }),\n/* 85 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/*\n MIT License http://www.opensource.org/licenses/mit-license.php\n Author Tobias Koppers @sokra\n Modified by Evan You @yyx990803\n*/\n\nvar hasDocument = typeof document !== 'undefined'\n\nif (typeof DEBUG !== 'undefined' && DEBUG) {\n if (!hasDocument) {\n throw new Error(\n 'vue-style-loader cannot be used in a non-browser environment. ' +\n \"Use { target: 'node' } in your Webpack config to indicate a server-rendering environment.\"\n ) }\n}\n\nvar listToStyles = __webpack_require__(81)\n\n/*\ntype StyleObject = {\n id: number;\n parts: Array<StyleObjectPart>\n}\n\ntype StyleObjectPart = {\n css: string;\n media: string;\n sourceMap: ?string\n}\n*/\n\nvar stylesInDom = {/*\n [id: number]: {\n id: number,\n refs: number,\n parts: Array<(obj?: StyleObjectPart) => void>\n }\n*/}\n\nvar head = hasDocument && (document.head || document.getElementsByTagName('head')[0])\nvar singletonElement = null\nvar singletonCounter = 0\nvar isProduction = false\nvar noop = function () {}\n\n// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>\n// tags it will allow on a page\nvar isOldIE = typeof navigator !== 'undefined' && /msie [6-9]\\b/.test(navigator.userAgent.toLowerCase())\n\nmodule.exports = function (parentId, list, _isProduction) {\n isProduction = _isProduction\n\n var styles = listToStyles(parentId, list)\n addStylesToDom(styles)\n\n return function update (newList) {\n var mayRemove = []\n for (var i = 0; i < styles.length; i++) {\n var item = styles[i]\n var domStyle = stylesInDom[item.id]\n domStyle.refs--\n mayRemove.push(domStyle)\n }\n if (newList) {\n styles = listToStyles(parentId, newList)\n addStylesToDom(styles)\n } else {\n styles = []\n }\n for (var i = 0; i < mayRemove.length; i++) {\n var domStyle = mayRemove[i]\n if (domStyle.refs === 0) {\n for (var j = 0; j < domStyle.parts.length; j++) {\n domStyle.parts[j]()\n }\n delete stylesInDom[domStyle.id]\n }\n }\n }\n}\n\nfunction addStylesToDom (styles /* Array<StyleObject> */) {\n for (var i = 0; i < styles.length; i++) {\n var item = styles[i]\n var domStyle = stylesInDom[item.id]\n if (domStyle) {\n domStyle.refs++\n for (var j = 0; j < domStyle.parts.length; j++) {\n domStyle.parts[j](item.parts[j])\n }\n for (; j < item.parts.length; j++) {\n domStyle.parts.push(addStyle(item.parts[j]))\n }\n if (domStyle.parts.length > item.parts.length) {\n domStyle.parts.length = item.parts.length\n }\n } else {\n var parts = []\n for (var j = 0; j < item.parts.length; j++) {\n parts.push(addStyle(item.parts[j]))\n }\n stylesInDom[item.id] = { id: item.id, refs: 1, parts: parts }\n }\n }\n}\n\nfunction listToStyles (parentId, list) {\n var styles = []\n var newStyles = {}\n for (var i = 0; i < list.length; i++) {\n var item = list[i]\n var id = item[0]\n var css = item[1]\n var media = item[2]\n var sourceMap = item[3]\n var part = { css: css, media: media, sourceMap: sourceMap }\n if (!newStyles[id]) {\n part.id = parentId + ':0'\n styles.push(newStyles[id] = { id: id, parts: [part] })\n } else {\n part.id = parentId + ':' + newStyles[id].parts.length\n newStyles[id].parts.push(part)\n }\n }\n return styles\n}\n\nfunction createStyleElement () {\n var styleElement = document.createElement('style')\n styleElement.type = 'text/css'\n head.appendChild(styleElement)\n return styleElement\n}\n\nfunction addStyle (obj /* StyleObjectPart */) {\n var update, remove\n var styleElement = document.querySelector('style[data-vue-ssr-id~=\"' + obj.id + '\"]')\n var hasSSR = styleElement != null\n\n // if in production mode and style is already provided by SSR,\n // simply do nothing.\n if (hasSSR && isProduction) {\n return noop\n }\n\n if (isOldIE) {\n // use singleton mode for IE9.\n var styleIndex = singletonCounter++\n styleElement = singletonElement || (singletonElement = createStyleElement())\n update = applyToSingletonTag.bind(null, styleElement, styleIndex, false)\n remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true)\n } else {\n // use multi-style-tag mode in all other cases\n styleElement = styleElement || createStyleElement()\n update = applyToTag.bind(null, styleElement)\n remove = function () {\n styleElement.parentNode.removeChild(styleElement)\n }\n }\n\n if (!hasSSR) {\n update(obj)\n }\n\n return function updateStyle (newObj /* StyleObjectPart */) {\n if (newObj) {\n if (newObj.css === obj.css &&\n newObj.media === obj.media &&\n newObj.sourceMap === obj.sourceMap) {\n return\n }\n update(obj = newObj)\n } else {\n remove()\n }\n }\n}\n\nvar replaceText = (function () {\n var textStore = []\n\n return function (index, replacement) {\n textStore[index] = replacement\n return textStore.filter(Boolean).join('\\n')\n }\n})()\n\nfunction applyToSingletonTag (styleElement, index, remove, obj) {\n var css = remove ? '' : obj.css\n\n if (styleElement.styleSheet) {\n styleElement.styleSheet.cssText = replaceText(index, css)\n } else {\n var cssNode = document.createTextNode(css)\n var childNodes = styleElement.childNodes\n if (childNodes[index]) styleElement.removeChild(childNodes[index])\n if (childNodes.length) {\n styleElement.insertBefore(cssNode, childNodes[index])\n } else {\n styleElement.appendChild(cssNode)\n }\n }\n}\n\nfunction applyToTag (styleElement, obj) {\n var css = obj.css\n var media = obj.media\n var sourceMap = obj.sourceMap\n\n if (media) {\n styleElement.setAttribute('media', media)\n }\n\n if (sourceMap) {\n // https://developer.chrome.com/devtools/docs/javascript-debugging\n // this makes source maps inside style tags work properly in Chrome\n css += '\\n/*# sourceURL=' + sourceMap.sources[0] + ' */'\n // http://stackoverflow.com/a/26603875\n css += '\\n/*# sourceMappingURL=data:application/json;base64,' + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + ' */'\n }\n\n if (styleElement.styleSheet) {\n styleElement.styleSheet.cssText = css\n } else {\n while (styleElement.firstChild) {\n styleElement.removeChild(styleElement.firstChild)\n }\n styleElement.appendChild(document.createTextNode(css))\n }\n}\n\n\n/***/ })\n]);\n\n\n// WEBPACK FOOTER //\n// static/js/vendor.969602d126b5ff83a532.js","var store = require('./_shared')('wks')\n , uid = require('./_uid')\n , Symbol = require('./_global').Symbol\n , USE_SYMBOL = typeof Symbol == 'function';\n\nvar $exports = module.exports = function(name){\n return store[name] || (store[name] =\n USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));\n};\n\n$exports.store = store;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_wks.js\n// module id = 0\n// module chunks = 0","// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nvar global = module.exports = typeof window != 'undefined' && window.Math == Math\n ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();\nif(typeof __g == 'number')__g = global; // eslint-disable-line no-undef\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_global.js\n// module id = 1\n// module chunks = 0","module.exports = function normalizeComponent (\n rawScriptExports,\n compiledTemplate,\n scopeId,\n cssModules\n) {\n var esModule\n var scriptExports = rawScriptExports = rawScriptExports || {}\n\n // ES6 modules interop\n var type = typeof rawScriptExports.default\n if (type === 'object' || type === 'function') {\n esModule = rawScriptExports\n scriptExports = rawScriptExports.default\n }\n\n // Vue.extend constructor export interop\n var options = typeof scriptExports === 'function'\n ? scriptExports.options\n : scriptExports\n\n // render functions\n if (compiledTemplate) {\n options.render = compiledTemplate.render\n options.staticRenderFns = compiledTemplate.staticRenderFns\n }\n\n // scopedId\n if (scopeId) {\n options._scopeId = scopeId\n }\n\n // inject cssModules\n if (cssModules) {\n var computed = options.computed || (options.computed = {})\n Object.keys(cssModules).forEach(function (key) {\n var module = cssModules[key]\n computed[key] = function () { return module }\n })\n }\n\n return {\n esModule: esModule,\n exports: scriptExports,\n options: options\n }\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/vue-loader/lib/component-normalizer.js\n// module id = 2\n// module chunks = 0","var isObject = require('./_is-object');\nmodule.exports = function(it){\n if(!isObject(it))throw TypeError(it + ' is not an object!');\n return it;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_an-object.js\n// module id = 3\n// module chunks = 0","// Thank's IE8 for his funny defineProperty\nmodule.exports = !require('./_fails')(function(){\n return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_descriptors.js\n// module id = 4\n// module chunks = 0","var hasOwnProperty = {}.hasOwnProperty;\nmodule.exports = function(it, key){\n return hasOwnProperty.call(it, key);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_has.js\n// module id = 5\n// module chunks = 0","var dP = require('./_object-dp')\n , createDesc = require('./_property-desc');\nmodule.exports = require('./_descriptors') ? function(object, key, value){\n return dP.f(object, key, createDesc(1, value));\n} : function(object, key, value){\n object[key] = value;\n return object;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_hide.js\n// module id = 6\n// module chunks = 0","var anObject = require('./_an-object')\n , IE8_DOM_DEFINE = require('./_ie8-dom-define')\n , toPrimitive = require('./_to-primitive')\n , dP = Object.defineProperty;\n\nexports.f = require('./_descriptors') ? Object.defineProperty : function defineProperty(O, P, Attributes){\n anObject(O);\n P = toPrimitive(P, true);\n anObject(Attributes);\n if(IE8_DOM_DEFINE)try {\n return dP(O, P, Attributes);\n } catch(e){ /* empty */ }\n if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');\n if('value' in Attributes)O[P] = Attributes.value;\n return O;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-dp.js\n// module id = 7\n// module chunks = 0","var core = module.exports = {version: '2.4.0'};\nif(typeof __e == 'number')__e = core; // eslint-disable-line no-undef\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_core.js\n// module id = 9\n// module chunks = 0","// 7.2.1 RequireObjectCoercible(argument)\nmodule.exports = function(it){\n if(it == undefined)throw TypeError(\"Can't call method on \" + it);\n return it;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_defined.js\n// module id = 10\n// module chunks = 0","module.exports = function(it){\n return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_is-object.js\n// module id = 11\n// module chunks = 0","module.exports = {};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iterators.js\n// module id = 12\n// module chunks = 0","module.exports = function(bitmap, value){\n return {\n enumerable : !(bitmap & 1),\n configurable: !(bitmap & 2),\n writable : !(bitmap & 4),\n value : value\n };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_property-desc.js\n// module id = 13\n// module chunks = 0","var shared = require('./_shared')('keys')\n , uid = require('./_uid');\nmodule.exports = function(key){\n return shared[key] || (shared[key] = uid(key));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_shared-key.js\n// module id = 14\n// module chunks = 0","// 7.1.4 ToInteger\nvar ceil = Math.ceil\n , floor = Math.floor;\nmodule.exports = function(it){\n return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-integer.js\n// module id = 15\n// module chunks = 0","/*!\n * Vue.js v2.1.10\n * (c) 2014-2017 Evan You\n * Released under the MIT License.\n */\n'use strict';\n\n/* */\n\n/**\n * Convert a value to a string that is actually rendered.\n */\nfunction _toString (val) {\n return val == null\n ? ''\n : typeof val === 'object'\n ? JSON.stringify(val, null, 2)\n : String(val)\n}\n\n/**\n * Convert a input value to a number for persistence.\n * If the conversion fails, return original string.\n */\nfunction toNumber (val) {\n var n = parseFloat(val);\n return isNaN(n) ? val : n\n}\n\n/**\n * Make a map and return a function for checking if a key\n * is in that map.\n */\nfunction makeMap (\n str,\n expectsLowerCase\n) {\n var map = Object.create(null);\n var list = str.split(',');\n for (var i = 0; i < list.length; i++) {\n map[list[i]] = true;\n }\n return expectsLowerCase\n ? function (val) { return map[val.toLowerCase()]; }\n : function (val) { return map[val]; }\n}\n\n/**\n * Check if a tag is a built-in tag.\n */\nvar isBuiltInTag = makeMap('slot,component', true);\n\n/**\n * Remove an item from an array\n */\nfunction remove$1 (arr, item) {\n if (arr.length) {\n var index = arr.indexOf(item);\n if (index > -1) {\n return arr.splice(index, 1)\n }\n }\n}\n\n/**\n * Check whether the object has the property.\n */\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction hasOwn (obj, key) {\n return hasOwnProperty.call(obj, key)\n}\n\n/**\n * Check if value is primitive\n */\nfunction isPrimitive (value) {\n return typeof value === 'string' || typeof value === 'number'\n}\n\n/**\n * Create a cached version of a pure function.\n */\nfunction cached (fn) {\n var cache = Object.create(null);\n return (function cachedFn (str) {\n var hit = cache[str];\n return hit || (cache[str] = fn(str))\n })\n}\n\n/**\n * Camelize a hyphen-delimited string.\n */\nvar camelizeRE = /-(\\w)/g;\nvar camelize = cached(function (str) {\n return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })\n});\n\n/**\n * Capitalize a string.\n */\nvar capitalize = cached(function (str) {\n return str.charAt(0).toUpperCase() + str.slice(1)\n});\n\n/**\n * Hyphenate a camelCase string.\n */\nvar hyphenateRE = /([^-])([A-Z])/g;\nvar hyphenate = cached(function (str) {\n return str\n .replace(hyphenateRE, '$1-$2')\n .replace(hyphenateRE, '$1-$2')\n .toLowerCase()\n});\n\n/**\n * Simple bind, faster than native\n */\nfunction bind$1 (fn, ctx) {\n function boundFn (a) {\n var l = arguments.length;\n return l\n ? l > 1\n ? fn.apply(ctx, arguments)\n : fn.call(ctx, a)\n : fn.call(ctx)\n }\n // record original fn length\n boundFn._length = fn.length;\n return boundFn\n}\n\n/**\n * Convert an Array-like object to a real Array.\n */\nfunction toArray (list, start) {\n start = start || 0;\n var i = list.length - start;\n var ret = new Array(i);\n while (i--) {\n ret[i] = list[i + start];\n }\n return ret\n}\n\n/**\n * Mix properties into target object.\n */\nfunction extend (to, _from) {\n for (var key in _from) {\n to[key] = _from[key];\n }\n return to\n}\n\n/**\n * Quick object check - this is primarily used to tell\n * Objects from primitive values when we know the value\n * is a JSON-compliant type.\n */\nfunction isObject (obj) {\n return obj !== null && typeof obj === 'object'\n}\n\n/**\n * Strict object type check. Only returns true\n * for plain JavaScript objects.\n */\nvar toString = Object.prototype.toString;\nvar OBJECT_STRING = '[object Object]';\nfunction isPlainObject (obj) {\n return toString.call(obj) === OBJECT_STRING\n}\n\n/**\n * Merge an Array of Objects into a single Object.\n */\nfunction toObject (arr) {\n var res = {};\n for (var i = 0; i < arr.length; i++) {\n if (arr[i]) {\n extend(res, arr[i]);\n }\n }\n return res\n}\n\n/**\n * Perform no operation.\n */\nfunction noop () {}\n\n/**\n * Always return false.\n */\nvar no = function () { return false; };\n\n/**\n * Return same value\n */\nvar identity = function (_) { return _; };\n\n/**\n * Generate a static keys string from compiler modules.\n */\nfunction genStaticKeys (modules) {\n return modules.reduce(function (keys, m) {\n return keys.concat(m.staticKeys || [])\n }, []).join(',')\n}\n\n/**\n * Check if two values are loosely equal - that is,\n * if they are plain objects, do they have the same shape?\n */\nfunction looseEqual (a, b) {\n var isObjectA = isObject(a);\n var isObjectB = isObject(b);\n if (isObjectA && isObjectB) {\n return JSON.stringify(a) === JSON.stringify(b)\n } else if (!isObjectA && !isObjectB) {\n return String(a) === String(b)\n } else {\n return false\n }\n}\n\nfunction looseIndexOf (arr, val) {\n for (var i = 0; i < arr.length; i++) {\n if (looseEqual(arr[i], val)) { return i }\n }\n return -1\n}\n\n/* */\n\nvar config = {\n /**\n * Option merge strategies (used in core/util/options)\n */\n optionMergeStrategies: Object.create(null),\n\n /**\n * Whether to suppress warnings.\n */\n silent: false,\n\n /**\n * Whether to enable devtools\n */\n devtools: process.env.NODE_ENV !== 'production',\n\n /**\n * Error handler for watcher errors\n */\n errorHandler: null,\n\n /**\n * Ignore certain custom elements\n */\n ignoredElements: [],\n\n /**\n * Custom user key aliases for v-on\n */\n keyCodes: Object.create(null),\n\n /**\n * Check if a tag is reserved so that it cannot be registered as a\n * component. This is platform-dependent and may be overwritten.\n */\n isReservedTag: no,\n\n /**\n * Check if a tag is an unknown element.\n * Platform-dependent.\n */\n isUnknownElement: no,\n\n /**\n * Get the namespace of an element\n */\n getTagNamespace: noop,\n\n /**\n * Parse the real tag name for the specific platform.\n */\n parsePlatformTagName: identity,\n\n /**\n * Check if an attribute must be bound using property, e.g. value\n * Platform-dependent.\n */\n mustUseProp: no,\n\n /**\n * List of asset types that a component can own.\n */\n _assetTypes: [\n 'component',\n 'directive',\n 'filter'\n ],\n\n /**\n * List of lifecycle hooks.\n */\n _lifecycleHooks: [\n 'beforeCreate',\n 'created',\n 'beforeMount',\n 'mounted',\n 'beforeUpdate',\n 'updated',\n 'beforeDestroy',\n 'destroyed',\n 'activated',\n 'deactivated'\n ],\n\n /**\n * Max circular updates allowed in a scheduler flush cycle.\n */\n _maxUpdateCount: 100\n};\n\n/* */\n\n/**\n * Check if a string starts with $ or _\n */\nfunction isReserved (str) {\n var c = (str + '').charCodeAt(0);\n return c === 0x24 || c === 0x5F\n}\n\n/**\n * Define a property.\n */\nfunction def (obj, key, val, enumerable) {\n Object.defineProperty(obj, key, {\n value: val,\n enumerable: !!enumerable,\n writable: true,\n configurable: true\n });\n}\n\n/**\n * Parse simple path.\n */\nvar bailRE = /[^\\w.$]/;\nfunction parsePath (path) {\n if (bailRE.test(path)) {\n return\n } else {\n var segments = path.split('.');\n return function (obj) {\n for (var i = 0; i < segments.length; i++) {\n if (!obj) { return }\n obj = obj[segments[i]];\n }\n return obj\n }\n }\n}\n\n/* */\n/* globals MutationObserver */\n\n// can we use __proto__?\nvar hasProto = '__proto__' in {};\n\n// Browser environment sniffing\nvar inBrowser = typeof window !== 'undefined';\nvar UA = inBrowser && window.navigator.userAgent.toLowerCase();\nvar isIE = UA && /msie|trident/.test(UA);\nvar isIE9 = UA && UA.indexOf('msie 9.0') > 0;\nvar isEdge = UA && UA.indexOf('edge/') > 0;\nvar isAndroid = UA && UA.indexOf('android') > 0;\nvar isIOS = UA && /iphone|ipad|ipod|ios/.test(UA);\n\n// this needs to be lazy-evaled because vue may be required before\n// vue-server-renderer can set VUE_ENV\nvar _isServer;\nvar isServerRendering = function () {\n if (_isServer === undefined) {\n /* istanbul ignore if */\n if (!inBrowser && typeof global !== 'undefined') {\n // detect presence of vue-server-renderer and avoid\n // Webpack shimming the process\n _isServer = global['process'].env.VUE_ENV === 'server';\n } else {\n _isServer = false;\n }\n }\n return _isServer\n};\n\n// detect devtools\nvar devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;\n\n/* istanbul ignore next */\nfunction isNative (Ctor) {\n return /native code/.test(Ctor.toString())\n}\n\n/**\n * Defer a task to execute it asynchronously.\n */\nvar nextTick = (function () {\n var callbacks = [];\n var pending = false;\n var timerFunc;\n\n function nextTickHandler () {\n pending = false;\n var copies = callbacks.slice(0);\n callbacks.length = 0;\n for (var i = 0; i < copies.length; i++) {\n copies[i]();\n }\n }\n\n // the nextTick behavior leverages the microtask queue, which can be accessed\n // via either native Promise.then or MutationObserver.\n // MutationObserver has wider support, however it is seriously bugged in\n // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It\n // completely stops working after triggering a few times... so, if native\n // Promise is available, we will use it:\n /* istanbul ignore if */\n if (typeof Promise !== 'undefined' && isNative(Promise)) {\n var p = Promise.resolve();\n var logError = function (err) { console.error(err); };\n timerFunc = function () {\n p.then(nextTickHandler).catch(logError);\n // in problematic UIWebViews, Promise.then doesn't completely break, but\n // it can get stuck in a weird state where callbacks are pushed into the\n // microtask queue but the queue isn't being flushed, until the browser\n // needs to do some other work, e.g. handle a timer. Therefore we can\n // \"force\" the microtask queue to be flushed by adding an empty timer.\n if (isIOS) { setTimeout(noop); }\n };\n } else if (typeof MutationObserver !== 'undefined' && (\n isNative(MutationObserver) ||\n // PhantomJS and iOS 7.x\n MutationObserver.toString() === '[object MutationObserverConstructor]'\n )) {\n // use MutationObserver where native Promise is not available,\n // e.g. PhantomJS IE11, iOS7, Android 4.4\n var counter = 1;\n var observer = new MutationObserver(nextTickHandler);\n var textNode = document.createTextNode(String(counter));\n observer.observe(textNode, {\n characterData: true\n });\n timerFunc = function () {\n counter = (counter + 1) % 2;\n textNode.data = String(counter);\n };\n } else {\n // fallback to setTimeout\n /* istanbul ignore next */\n timerFunc = function () {\n setTimeout(nextTickHandler, 0);\n };\n }\n\n return function queueNextTick (cb, ctx) {\n var _resolve;\n callbacks.push(function () {\n if (cb) { cb.call(ctx); }\n if (_resolve) { _resolve(ctx); }\n });\n if (!pending) {\n pending = true;\n timerFunc();\n }\n if (!cb && typeof Promise !== 'undefined') {\n return new Promise(function (resolve) {\n _resolve = resolve;\n })\n }\n }\n})();\n\nvar _Set;\n/* istanbul ignore if */\nif (typeof Set !== 'undefined' && isNative(Set)) {\n // use native Set when available.\n _Set = Set;\n} else {\n // a non-standard Set polyfill that only works with primitive keys.\n _Set = (function () {\n function Set () {\n this.set = Object.create(null);\n }\n Set.prototype.has = function has (key) {\n return this.set[key] === true\n };\n Set.prototype.add = function add (key) {\n this.set[key] = true;\n };\n Set.prototype.clear = function clear () {\n this.set = Object.create(null);\n };\n\n return Set;\n }());\n}\n\nvar warn = noop;\nvar formatComponentName;\n\nif (process.env.NODE_ENV !== 'production') {\n var hasConsole = typeof console !== 'undefined';\n\n warn = function (msg, vm) {\n if (hasConsole && (!config.silent)) {\n console.error(\"[Vue warn]: \" + msg + \" \" + (\n vm ? formatLocation(formatComponentName(vm)) : ''\n ));\n }\n };\n\n formatComponentName = function (vm) {\n if (vm.$root === vm) {\n return 'root instance'\n }\n var name = vm._isVue\n ? vm.$options.name || vm.$options._componentTag\n : vm.name;\n return (\n (name ? (\"component <\" + name + \">\") : \"anonymous component\") +\n (vm._isVue && vm.$options.__file ? (\" at \" + (vm.$options.__file)) : '')\n )\n };\n\n var formatLocation = function (str) {\n if (str === 'anonymous component') {\n str += \" - use the \\\"name\\\" option for better debugging messages.\";\n }\n return (\"\\n(found in \" + str + \")\")\n };\n}\n\n/* */\n\n\nvar uid$1 = 0;\n\n/**\n * A dep is an observable that can have multiple\n * directives subscribing to it.\n */\nvar Dep = function Dep () {\n this.id = uid$1++;\n this.subs = [];\n};\n\nDep.prototype.addSub = function addSub (sub) {\n this.subs.push(sub);\n};\n\nDep.prototype.removeSub = function removeSub (sub) {\n remove$1(this.subs, sub);\n};\n\nDep.prototype.depend = function depend () {\n if (Dep.target) {\n Dep.target.addDep(this);\n }\n};\n\nDep.prototype.notify = function notify () {\n // stablize the subscriber list first\n var subs = this.subs.slice();\n for (var i = 0, l = subs.length; i < l; i++) {\n subs[i].update();\n }\n};\n\n// the current target watcher being evaluated.\n// this is globally unique because there could be only one\n// watcher being evaluated at any time.\nDep.target = null;\nvar targetStack = [];\n\nfunction pushTarget (_target) {\n if (Dep.target) { targetStack.push(Dep.target); }\n Dep.target = _target;\n}\n\nfunction popTarget () {\n Dep.target = targetStack.pop();\n}\n\n/*\n * not type checking this file because flow doesn't play well with\n * dynamically accessing methods on Array prototype\n */\n\nvar arrayProto = Array.prototype;\nvar arrayMethods = Object.create(arrayProto);[\n 'push',\n 'pop',\n 'shift',\n 'unshift',\n 'splice',\n 'sort',\n 'reverse'\n]\n.forEach(function (method) {\n // cache original method\n var original = arrayProto[method];\n def(arrayMethods, method, function mutator () {\n var arguments$1 = arguments;\n\n // avoid leaking arguments:\n // http://jsperf.com/closure-with-arguments\n var i = arguments.length;\n var args = new Array(i);\n while (i--) {\n args[i] = arguments$1[i];\n }\n var result = original.apply(this, args);\n var ob = this.__ob__;\n var inserted;\n switch (method) {\n case 'push':\n inserted = args;\n break\n case 'unshift':\n inserted = args;\n break\n case 'splice':\n inserted = args.slice(2);\n break\n }\n if (inserted) { ob.observeArray(inserted); }\n // notify change\n ob.dep.notify();\n return result\n });\n});\n\n/* */\n\nvar arrayKeys = Object.getOwnPropertyNames(arrayMethods);\n\n/**\n * By default, when a reactive property is set, the new value is\n * also converted to become reactive. However when passing down props,\n * we don't want to force conversion because the value may be a nested value\n * under a frozen data structure. Converting it would defeat the optimization.\n */\nvar observerState = {\n shouldConvert: true,\n isSettingProps: false\n};\n\n/**\n * Observer class that are attached to each observed\n * object. Once attached, the observer converts target\n * object's property keys into getter/setters that\n * collect dependencies and dispatches updates.\n */\nvar Observer = function Observer (value) {\n this.value = value;\n this.dep = new Dep();\n this.vmCount = 0;\n def(value, '__ob__', this);\n if (Array.isArray(value)) {\n var augment = hasProto\n ? protoAugment\n : copyAugment;\n augment(value, arrayMethods, arrayKeys);\n this.observeArray(value);\n } else {\n this.walk(value);\n }\n};\n\n/**\n * Walk through each property and convert them into\n * getter/setters. This method should only be called when\n * value type is Object.\n */\nObserver.prototype.walk = function walk (obj) {\n var keys = Object.keys(obj);\n for (var i = 0; i < keys.length; i++) {\n defineReactive$$1(obj, keys[i], obj[keys[i]]);\n }\n};\n\n/**\n * Observe a list of Array items.\n */\nObserver.prototype.observeArray = function observeArray (items) {\n for (var i = 0, l = items.length; i < l; i++) {\n observe(items[i]);\n }\n};\n\n// helpers\n\n/**\n * Augment an target Object or Array by intercepting\n * the prototype chain using __proto__\n */\nfunction protoAugment (target, src) {\n /* eslint-disable no-proto */\n target.__proto__ = src;\n /* eslint-enable no-proto */\n}\n\n/**\n * Augment an target Object or Array by defining\n * hidden properties.\n */\n/* istanbul ignore next */\nfunction copyAugment (target, src, keys) {\n for (var i = 0, l = keys.length; i < l; i++) {\n var key = keys[i];\n def(target, key, src[key]);\n }\n}\n\n/**\n * Attempt to create an observer instance for a value,\n * returns the new observer if successfully observed,\n * or the existing observer if the value already has one.\n */\nfunction observe (value, asRootData) {\n if (!isObject(value)) {\n return\n }\n var ob;\n if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {\n ob = value.__ob__;\n } else if (\n observerState.shouldConvert &&\n !isServerRendering() &&\n (Array.isArray(value) || isPlainObject(value)) &&\n Object.isExtensible(value) &&\n !value._isVue\n ) {\n ob = new Observer(value);\n }\n if (asRootData && ob) {\n ob.vmCount++;\n }\n return ob\n}\n\n/**\n * Define a reactive property on an Object.\n */\nfunction defineReactive$$1 (\n obj,\n key,\n val,\n customSetter\n) {\n var dep = new Dep();\n\n var property = Object.getOwnPropertyDescriptor(obj, key);\n if (property && property.configurable === false) {\n return\n }\n\n // cater for pre-defined getter/setters\n var getter = property && property.get;\n var setter = property && property.set;\n\n var childOb = observe(val);\n Object.defineProperty(obj, key, {\n enumerable: true,\n configurable: true,\n get: function reactiveGetter () {\n var value = getter ? getter.call(obj) : val;\n if (Dep.target) {\n dep.depend();\n if (childOb) {\n childOb.dep.depend();\n }\n if (Array.isArray(value)) {\n dependArray(value);\n }\n }\n return value\n },\n set: function reactiveSetter (newVal) {\n var value = getter ? getter.call(obj) : val;\n /* eslint-disable no-self-compare */\n if (newVal === value || (newVal !== newVal && value !== value)) {\n return\n }\n /* eslint-enable no-self-compare */\n if (process.env.NODE_ENV !== 'production' && customSetter) {\n customSetter();\n }\n if (setter) {\n setter.call(obj, newVal);\n } else {\n val = newVal;\n }\n childOb = observe(newVal);\n dep.notify();\n }\n });\n}\n\n/**\n * Set a property on an object. Adds the new property and\n * triggers change notification if the property doesn't\n * already exist.\n */\nfunction set$1 (obj, key, val) {\n if (Array.isArray(obj)) {\n obj.length = Math.max(obj.length, key);\n obj.splice(key, 1, val);\n return val\n }\n if (hasOwn(obj, key)) {\n obj[key] = val;\n return\n }\n var ob = obj.__ob__;\n if (obj._isVue || (ob && ob.vmCount)) {\n process.env.NODE_ENV !== 'production' && warn(\n 'Avoid adding reactive properties to a Vue instance or its root $data ' +\n 'at runtime - declare it upfront in the data option.'\n );\n return\n }\n if (!ob) {\n obj[key] = val;\n return\n }\n defineReactive$$1(ob.value, key, val);\n ob.dep.notify();\n return val\n}\n\n/**\n * Delete a property and trigger change if necessary.\n */\nfunction del (obj, key) {\n var ob = obj.__ob__;\n if (obj._isVue || (ob && ob.vmCount)) {\n process.env.NODE_ENV !== 'production' && warn(\n 'Avoid deleting properties on a Vue instance or its root $data ' +\n '- just set it to null.'\n );\n return\n }\n if (!hasOwn(obj, key)) {\n return\n }\n delete obj[key];\n if (!ob) {\n return\n }\n ob.dep.notify();\n}\n\n/**\n * Collect dependencies on array elements when the array is touched, since\n * we cannot intercept array element access like property getters.\n */\nfunction dependArray (value) {\n for (var e = (void 0), i = 0, l = value.length; i < l; i++) {\n e = value[i];\n e && e.__ob__ && e.__ob__.dep.depend();\n if (Array.isArray(e)) {\n dependArray(e);\n }\n }\n}\n\n/* */\n\n/**\n * Option overwriting strategies are functions that handle\n * how to merge a parent option value and a child option\n * value into the final value.\n */\nvar strats = config.optionMergeStrategies;\n\n/**\n * Options with restrictions\n */\nif (process.env.NODE_ENV !== 'production') {\n strats.el = strats.propsData = function (parent, child, vm, key) {\n if (!vm) {\n warn(\n \"option \\\"\" + key + \"\\\" can only be used during instance \" +\n 'creation with the `new` keyword.'\n );\n }\n return defaultStrat(parent, child)\n };\n}\n\n/**\n * Helper that recursively merges two data objects together.\n */\nfunction mergeData (to, from) {\n if (!from) { return to }\n var key, toVal, fromVal;\n var keys = Object.keys(from);\n for (var i = 0; i < keys.length; i++) {\n key = keys[i];\n toVal = to[key];\n fromVal = from[key];\n if (!hasOwn(to, key)) {\n set$1(to, key, fromVal);\n } else if (isPlainObject(toVal) && isPlainObject(fromVal)) {\n mergeData(toVal, fromVal);\n }\n }\n return to\n}\n\n/**\n * Data\n */\nstrats.data = function (\n parentVal,\n childVal,\n vm\n) {\n if (!vm) {\n // in a Vue.extend merge, both should be functions\n if (!childVal) {\n return parentVal\n }\n if (typeof childVal !== 'function') {\n process.env.NODE_ENV !== 'production' && warn(\n 'The \"data\" option should be a function ' +\n 'that returns a per-instance value in component ' +\n 'definitions.',\n vm\n );\n return parentVal\n }\n if (!parentVal) {\n return childVal\n }\n // when parentVal & childVal are both present,\n // we need to return a function that returns the\n // merged result of both functions... no need to\n // check if parentVal is a function here because\n // it has to be a function to pass previous merges.\n return function mergedDataFn () {\n return mergeData(\n childVal.call(this),\n parentVal.call(this)\n )\n }\n } else if (parentVal || childVal) {\n return function mergedInstanceDataFn () {\n // instance merge\n var instanceData = typeof childVal === 'function'\n ? childVal.call(vm)\n : childVal;\n var defaultData = typeof parentVal === 'function'\n ? parentVal.call(vm)\n : undefined;\n if (instanceData) {\n return mergeData(instanceData, defaultData)\n } else {\n return defaultData\n }\n }\n }\n};\n\n/**\n * Hooks and param attributes are merged as arrays.\n */\nfunction mergeHook (\n parentVal,\n childVal\n) {\n return childVal\n ? parentVal\n ? parentVal.concat(childVal)\n : Array.isArray(childVal)\n ? childVal\n : [childVal]\n : parentVal\n}\n\nconfig._lifecycleHooks.forEach(function (hook) {\n strats[hook] = mergeHook;\n});\n\n/**\n * Assets\n *\n * When a vm is present (instance creation), we need to do\n * a three-way merge between constructor options, instance\n * options and parent options.\n */\nfunction mergeAssets (parentVal, childVal) {\n var res = Object.create(parentVal || null);\n return childVal\n ? extend(res, childVal)\n : res\n}\n\nconfig._assetTypes.forEach(function (type) {\n strats[type + 's'] = mergeAssets;\n});\n\n/**\n * Watchers.\n *\n * Watchers hashes should not overwrite one\n * another, so we merge them as arrays.\n */\nstrats.watch = function (parentVal, childVal) {\n /* istanbul ignore if */\n if (!childVal) { return parentVal }\n if (!parentVal) { return childVal }\n var ret = {};\n extend(ret, parentVal);\n for (var key in childVal) {\n var parent = ret[key];\n var child = childVal[key];\n if (parent && !Array.isArray(parent)) {\n parent = [parent];\n }\n ret[key] = parent\n ? parent.concat(child)\n : [child];\n }\n return ret\n};\n\n/**\n * Other object hashes.\n */\nstrats.props =\nstrats.methods =\nstrats.computed = function (parentVal, childVal) {\n if (!childVal) { return parentVal }\n if (!parentVal) { return childVal }\n var ret = Object.create(null);\n extend(ret, parentVal);\n extend(ret, childVal);\n return ret\n};\n\n/**\n * Default strategy.\n */\nvar defaultStrat = function (parentVal, childVal) {\n return childVal === undefined\n ? parentVal\n : childVal\n};\n\n/**\n * Validate component names\n */\nfunction checkComponents (options) {\n for (var key in options.components) {\n var lower = key.toLowerCase();\n if (isBuiltInTag(lower) || config.isReservedTag(lower)) {\n warn(\n 'Do not use built-in or reserved HTML elements as component ' +\n 'id: ' + key\n );\n }\n }\n}\n\n/**\n * Ensure all props option syntax are normalized into the\n * Object-based format.\n */\nfunction normalizeProps (options) {\n var props = options.props;\n if (!props) { return }\n var res = {};\n var i, val, name;\n if (Array.isArray(props)) {\n i = props.length;\n while (i--) {\n val = props[i];\n if (typeof val === 'string') {\n name = camelize(val);\n res[name] = { type: null };\n } else if (process.env.NODE_ENV !== 'production') {\n warn('props must be strings when using array syntax.');\n }\n }\n } else if (isPlainObject(props)) {\n for (var key in props) {\n val = props[key];\n name = camelize(key);\n res[name] = isPlainObject(val)\n ? val\n : { type: val };\n }\n }\n options.props = res;\n}\n\n/**\n * Normalize raw function directives into object format.\n */\nfunction normalizeDirectives (options) {\n var dirs = options.directives;\n if (dirs) {\n for (var key in dirs) {\n var def = dirs[key];\n if (typeof def === 'function') {\n dirs[key] = { bind: def, update: def };\n }\n }\n }\n}\n\n/**\n * Merge two option objects into a new one.\n * Core utility used in both instantiation and inheritance.\n */\nfunction mergeOptions (\n parent,\n child,\n vm\n) {\n if (process.env.NODE_ENV !== 'production') {\n checkComponents(child);\n }\n normalizeProps(child);\n normalizeDirectives(child);\n var extendsFrom = child.extends;\n if (extendsFrom) {\n parent = typeof extendsFrom === 'function'\n ? mergeOptions(parent, extendsFrom.options, vm)\n : mergeOptions(parent, extendsFrom, vm);\n }\n if (child.mixins) {\n for (var i = 0, l = child.mixins.length; i < l; i++) {\n var mixin = child.mixins[i];\n if (mixin.prototype instanceof Vue$3) {\n mixin = mixin.options;\n }\n parent = mergeOptions(parent, mixin, vm);\n }\n }\n var options = {};\n var key;\n for (key in parent) {\n mergeField(key);\n }\n for (key in child) {\n if (!hasOwn(parent, key)) {\n mergeField(key);\n }\n }\n function mergeField (key) {\n var strat = strats[key] || defaultStrat;\n options[key] = strat(parent[key], child[key], vm, key);\n }\n return options\n}\n\n/**\n * Resolve an asset.\n * This function is used because child instances need access\n * to assets defined in its ancestor chain.\n */\nfunction resolveAsset (\n options,\n type,\n id,\n warnMissing\n) {\n /* istanbul ignore if */\n if (typeof id !== 'string') {\n return\n }\n var assets = options[type];\n // check local registration variations first\n if (hasOwn(assets, id)) { return assets[id] }\n var camelizedId = camelize(id);\n if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }\n var PascalCaseId = capitalize(camelizedId);\n if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }\n // fallback to prototype chain\n var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];\n if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {\n warn(\n 'Failed to resolve ' + type.slice(0, -1) + ': ' + id,\n options\n );\n }\n return res\n}\n\n/* */\n\nfunction validateProp (\n key,\n propOptions,\n propsData,\n vm\n) {\n var prop = propOptions[key];\n var absent = !hasOwn(propsData, key);\n var value = propsData[key];\n // handle boolean props\n if (isType(Boolean, prop.type)) {\n if (absent && !hasOwn(prop, 'default')) {\n value = false;\n } else if (!isType(String, prop.type) && (value === '' || value === hyphenate(key))) {\n value = true;\n }\n }\n // check default value\n if (value === undefined) {\n value = getPropDefaultValue(vm, prop, key);\n // since the default value is a fresh copy,\n // make sure to observe it.\n var prevShouldConvert = observerState.shouldConvert;\n observerState.shouldConvert = true;\n observe(value);\n observerState.shouldConvert = prevShouldConvert;\n }\n if (process.env.NODE_ENV !== 'production') {\n assertProp(prop, key, value, vm, absent);\n }\n return value\n}\n\n/**\n * Get the default value of a prop.\n */\nfunction getPropDefaultValue (vm, prop, key) {\n // no default, return undefined\n if (!hasOwn(prop, 'default')) {\n return undefined\n }\n var def = prop.default;\n // warn against non-factory defaults for Object & Array\n if (isObject(def)) {\n process.env.NODE_ENV !== 'production' && warn(\n 'Invalid default value for prop \"' + key + '\": ' +\n 'Props with type Object/Array must use a factory function ' +\n 'to return the default value.',\n vm\n );\n }\n // the raw prop value was also undefined from previous render,\n // return previous default value to avoid unnecessary watcher trigger\n if (vm && vm.$options.propsData &&\n vm.$options.propsData[key] === undefined &&\n vm[key] !== undefined) {\n return vm[key]\n }\n // call factory function for non-Function types\n return typeof def === 'function' && prop.type !== Function\n ? def.call(vm)\n : def\n}\n\n/**\n * Assert whether a prop is valid.\n */\nfunction assertProp (\n prop,\n name,\n value,\n vm,\n absent\n) {\n if (prop.required && absent) {\n warn(\n 'Missing required prop: \"' + name + '\"',\n vm\n );\n return\n }\n if (value == null && !prop.required) {\n return\n }\n var type = prop.type;\n var valid = !type || type === true;\n var expectedTypes = [];\n if (type) {\n if (!Array.isArray(type)) {\n type = [type];\n }\n for (var i = 0; i < type.length && !valid; i++) {\n var assertedType = assertType(value, type[i]);\n expectedTypes.push(assertedType.expectedType || '');\n valid = assertedType.valid;\n }\n }\n if (!valid) {\n warn(\n 'Invalid prop: type check failed for prop \"' + name + '\".' +\n ' Expected ' + expectedTypes.map(capitalize).join(', ') +\n ', got ' + Object.prototype.toString.call(value).slice(8, -1) + '.',\n vm\n );\n return\n }\n var validator = prop.validator;\n if (validator) {\n if (!validator(value)) {\n warn(\n 'Invalid prop: custom validator check failed for prop \"' + name + '\".',\n vm\n );\n }\n }\n}\n\n/**\n * Assert the type of a value\n */\nfunction assertType (value, type) {\n var valid;\n var expectedType = getType(type);\n if (expectedType === 'String') {\n valid = typeof value === (expectedType = 'string');\n } else if (expectedType === 'Number') {\n valid = typeof value === (expectedType = 'number');\n } else if (expectedType === 'Boolean') {\n valid = typeof value === (expectedType = 'boolean');\n } else if (expectedType === 'Function') {\n valid = typeof value === (expectedType = 'function');\n } else if (expectedType === 'Object') {\n valid = isPlainObject(value);\n } else if (expectedType === 'Array') {\n valid = Array.isArray(value);\n } else {\n valid = value instanceof type;\n }\n return {\n valid: valid,\n expectedType: expectedType\n }\n}\n\n/**\n * Use function string name to check built-in types,\n * because a simple equality check will fail when running\n * across different vms / iframes.\n */\nfunction getType (fn) {\n var match = fn && fn.toString().match(/^\\s*function (\\w+)/);\n return match && match[1]\n}\n\nfunction isType (type, fn) {\n if (!Array.isArray(fn)) {\n return getType(fn) === getType(type)\n }\n for (var i = 0, len = fn.length; i < len; i++) {\n if (getType(fn[i]) === getType(type)) {\n return true\n }\n }\n /* istanbul ignore next */\n return false\n}\n\n\n\nvar util = Object.freeze({\n\tdefineReactive: defineReactive$$1,\n\t_toString: _toString,\n\ttoNumber: toNumber,\n\tmakeMap: makeMap,\n\tisBuiltInTag: isBuiltInTag,\n\tremove: remove$1,\n\thasOwn: hasOwn,\n\tisPrimitive: isPrimitive,\n\tcached: cached,\n\tcamelize: camelize,\n\tcapitalize: capitalize,\n\thyphenate: hyphenate,\n\tbind: bind$1,\n\ttoArray: toArray,\n\textend: extend,\n\tisObject: isObject,\n\tisPlainObject: isPlainObject,\n\ttoObject: toObject,\n\tnoop: noop,\n\tno: no,\n\tidentity: identity,\n\tgenStaticKeys: genStaticKeys,\n\tlooseEqual: looseEqual,\n\tlooseIndexOf: looseIndexOf,\n\tisReserved: isReserved,\n\tdef: def,\n\tparsePath: parsePath,\n\thasProto: hasProto,\n\tinBrowser: inBrowser,\n\tUA: UA,\n\tisIE: isIE,\n\tisIE9: isIE9,\n\tisEdge: isEdge,\n\tisAndroid: isAndroid,\n\tisIOS: isIOS,\n\tisServerRendering: isServerRendering,\n\tdevtools: devtools,\n\tnextTick: nextTick,\n\tget _Set () { return _Set; },\n\tmergeOptions: mergeOptions,\n\tresolveAsset: resolveAsset,\n\tget warn () { return warn; },\n\tget formatComponentName () { return formatComponentName; },\n\tvalidateProp: validateProp\n});\n\n/* not type checking this file because flow doesn't play well with Proxy */\n\nvar initProxy;\n\nif (process.env.NODE_ENV !== 'production') {\n var allowedGlobals = makeMap(\n 'Infinity,undefined,NaN,isFinite,isNaN,' +\n 'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +\n 'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +\n 'require' // for Webpack/Browserify\n );\n\n var warnNonPresent = function (target, key) {\n warn(\n \"Property or method \\\"\" + key + \"\\\" is not defined on the instance but \" +\n \"referenced during render. Make sure to declare reactive data \" +\n \"properties in the data option.\",\n target\n );\n };\n\n var hasProxy =\n typeof Proxy !== 'undefined' &&\n Proxy.toString().match(/native code/);\n\n if (hasProxy) {\n var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta');\n config.keyCodes = new Proxy(config.keyCodes, {\n set: function set (target, key, value) {\n if (isBuiltInModifier(key)) {\n warn((\"Avoid overwriting built-in modifier in config.keyCodes: .\" + key));\n return false\n } else {\n target[key] = value;\n return true\n }\n }\n });\n }\n\n var hasHandler = {\n has: function has (target, key) {\n var has = key in target;\n var isAllowed = allowedGlobals(key) || key.charAt(0) === '_';\n if (!has && !isAllowed) {\n warnNonPresent(target, key);\n }\n return has || !isAllowed\n }\n };\n\n var getHandler = {\n get: function get (target, key) {\n if (typeof key === 'string' && !(key in target)) {\n warnNonPresent(target, key);\n }\n return target[key]\n }\n };\n\n initProxy = function initProxy (vm) {\n if (hasProxy) {\n // determine which proxy handler to use\n var options = vm.$options;\n var handlers = options.render && options.render._withStripped\n ? getHandler\n : hasHandler;\n vm._renderProxy = new Proxy(vm, handlers);\n } else {\n vm._renderProxy = vm;\n }\n };\n}\n\n/* */\n\nvar VNode = function VNode (\n tag,\n data,\n children,\n text,\n elm,\n context,\n componentOptions\n) {\n this.tag = tag;\n this.data = data;\n this.children = children;\n this.text = text;\n this.elm = elm;\n this.ns = undefined;\n this.context = context;\n this.functionalContext = undefined;\n this.key = data && data.key;\n this.componentOptions = componentOptions;\n this.componentInstance = undefined;\n this.parent = undefined;\n this.raw = false;\n this.isStatic = false;\n this.isRootInsert = true;\n this.isComment = false;\n this.isCloned = false;\n this.isOnce = false;\n};\n\nvar prototypeAccessors = { child: {} };\n\n// DEPRECATED: alias for componentInstance for backwards compat.\n/* istanbul ignore next */\nprototypeAccessors.child.get = function () {\n return this.componentInstance\n};\n\nObject.defineProperties( VNode.prototype, prototypeAccessors );\n\nvar createEmptyVNode = function () {\n var node = new VNode();\n node.text = '';\n node.isComment = true;\n return node\n};\n\nfunction createTextVNode (val) {\n return new VNode(undefined, undefined, undefined, String(val))\n}\n\n// optimized shallow clone\n// used for static nodes and slot nodes because they may be reused across\n// multiple renders, cloning them avoids errors when DOM manipulations rely\n// on their elm reference.\nfunction cloneVNode (vnode) {\n var cloned = new VNode(\n vnode.tag,\n vnode.data,\n vnode.children,\n vnode.text,\n vnode.elm,\n vnode.context,\n vnode.componentOptions\n );\n cloned.ns = vnode.ns;\n cloned.isStatic = vnode.isStatic;\n cloned.key = vnode.key;\n cloned.isCloned = true;\n return cloned\n}\n\nfunction cloneVNodes (vnodes) {\n var res = new Array(vnodes.length);\n for (var i = 0; i < vnodes.length; i++) {\n res[i] = cloneVNode(vnodes[i]);\n }\n return res\n}\n\n/* */\n\nvar hooks = { init: init, prepatch: prepatch, insert: insert, destroy: destroy$1 };\nvar hooksToMerge = Object.keys(hooks);\n\nfunction createComponent (\n Ctor,\n data,\n context,\n children,\n tag\n) {\n if (!Ctor) {\n return\n }\n\n var baseCtor = context.$options._base;\n if (isObject(Ctor)) {\n Ctor = baseCtor.extend(Ctor);\n }\n\n if (typeof Ctor !== 'function') {\n if (process.env.NODE_ENV !== 'production') {\n warn((\"Invalid Component definition: \" + (String(Ctor))), context);\n }\n return\n }\n\n // async component\n if (!Ctor.cid) {\n if (Ctor.resolved) {\n Ctor = Ctor.resolved;\n } else {\n Ctor = resolveAsyncComponent(Ctor, baseCtor, function () {\n // it's ok to queue this on every render because\n // $forceUpdate is buffered by the scheduler.\n context.$forceUpdate();\n });\n if (!Ctor) {\n // return nothing if this is indeed an async component\n // wait for the callback to trigger parent update.\n return\n }\n }\n }\n\n // resolve constructor options in case global mixins are applied after\n // component constructor creation\n resolveConstructorOptions(Ctor);\n\n data = data || {};\n\n // extract props\n var propsData = extractProps(data, Ctor);\n\n // functional component\n if (Ctor.options.functional) {\n return createFunctionalComponent(Ctor, propsData, data, context, children)\n }\n\n // extract listeners, since these needs to be treated as\n // child component listeners instead of DOM listeners\n var listeners = data.on;\n // replace with listeners with .native modifier\n data.on = data.nativeOn;\n\n if (Ctor.options.abstract) {\n // abstract components do not keep anything\n // other than props & listeners\n data = {};\n }\n\n // merge component management hooks onto the placeholder node\n mergeHooks(data);\n\n // return a placeholder vnode\n var name = Ctor.options.name || tag;\n var vnode = new VNode(\n (\"vue-component-\" + (Ctor.cid) + (name ? (\"-\" + name) : '')),\n data, undefined, undefined, undefined, context,\n { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }\n );\n return vnode\n}\n\nfunction createFunctionalComponent (\n Ctor,\n propsData,\n data,\n context,\n children\n) {\n var props = {};\n var propOptions = Ctor.options.props;\n if (propOptions) {\n for (var key in propOptions) {\n props[key] = validateProp(key, propOptions, propsData);\n }\n }\n // ensure the createElement function in functional components\n // gets a unique context - this is necessary for correct named slot check\n var _context = Object.create(context);\n var h = function (a, b, c, d) { return createElement(_context, a, b, c, d, true); };\n var vnode = Ctor.options.render.call(null, h, {\n props: props,\n data: data,\n parent: context,\n children: children,\n slots: function () { return resolveSlots(children, context); }\n });\n if (vnode instanceof VNode) {\n vnode.functionalContext = context;\n if (data.slot) {\n (vnode.data || (vnode.data = {})).slot = data.slot;\n }\n }\n return vnode\n}\n\nfunction createComponentInstanceForVnode (\n vnode, // we know it's MountedComponentVNode but flow doesn't\n parent, // activeInstance in lifecycle state\n parentElm,\n refElm\n) {\n var vnodeComponentOptions = vnode.componentOptions;\n var options = {\n _isComponent: true,\n parent: parent,\n propsData: vnodeComponentOptions.propsData,\n _componentTag: vnodeComponentOptions.tag,\n _parentVnode: vnode,\n _parentListeners: vnodeComponentOptions.listeners,\n _renderChildren: vnodeComponentOptions.children,\n _parentElm: parentElm || null,\n _refElm: refElm || null\n };\n // check inline-template render functions\n var inlineTemplate = vnode.data.inlineTemplate;\n if (inlineTemplate) {\n options.render = inlineTemplate.render;\n options.staticRenderFns = inlineTemplate.staticRenderFns;\n }\n return new vnodeComponentOptions.Ctor(options)\n}\n\nfunction init (\n vnode,\n hydrating,\n parentElm,\n refElm\n) {\n if (!vnode.componentInstance || vnode.componentInstance._isDestroyed) {\n var child = vnode.componentInstance = createComponentInstanceForVnode(\n vnode,\n activeInstance,\n parentElm,\n refElm\n );\n child.$mount(hydrating ? vnode.elm : undefined, hydrating);\n } else if (vnode.data.keepAlive) {\n // kept-alive components, treat as a patch\n var mountedNode = vnode; // work around flow\n prepatch(mountedNode, mountedNode);\n }\n}\n\nfunction prepatch (\n oldVnode,\n vnode\n) {\n var options = vnode.componentOptions;\n var child = vnode.componentInstance = oldVnode.componentInstance;\n child._updateFromParent(\n options.propsData, // updated props\n options.listeners, // updated listeners\n vnode, // new parent vnode\n options.children // new children\n );\n}\n\nfunction insert (vnode) {\n if (!vnode.componentInstance._isMounted) {\n vnode.componentInstance._isMounted = true;\n callHook(vnode.componentInstance, 'mounted');\n }\n if (vnode.data.keepAlive) {\n vnode.componentInstance._inactive = false;\n callHook(vnode.componentInstance, 'activated');\n }\n}\n\nfunction destroy$1 (vnode) {\n if (!vnode.componentInstance._isDestroyed) {\n if (!vnode.data.keepAlive) {\n vnode.componentInstance.$destroy();\n } else {\n vnode.componentInstance._inactive = true;\n callHook(vnode.componentInstance, 'deactivated');\n }\n }\n}\n\nfunction resolveAsyncComponent (\n factory,\n baseCtor,\n cb\n) {\n if (factory.requested) {\n // pool callbacks\n factory.pendingCallbacks.push(cb);\n } else {\n factory.requested = true;\n var cbs = factory.pendingCallbacks = [cb];\n var sync = true;\n\n var resolve = function (res) {\n if (isObject(res)) {\n res = baseCtor.extend(res);\n }\n // cache resolved\n factory.resolved = res;\n // invoke callbacks only if this is not a synchronous resolve\n // (async resolves are shimmed as synchronous during SSR)\n if (!sync) {\n for (var i = 0, l = cbs.length; i < l; i++) {\n cbs[i](res);\n }\n }\n };\n\n var reject = function (reason) {\n process.env.NODE_ENV !== 'production' && warn(\n \"Failed to resolve async component: \" + (String(factory)) +\n (reason ? (\"\\nReason: \" + reason) : '')\n );\n };\n\n var res = factory(resolve, reject);\n\n // handle promise\n if (res && typeof res.then === 'function' && !factory.resolved) {\n res.then(resolve, reject);\n }\n\n sync = false;\n // return in case resolved synchronously\n return factory.resolved\n }\n}\n\nfunction extractProps (data, Ctor) {\n // we are only extracting raw values here.\n // validation and default values are handled in the child\n // component itself.\n var propOptions = Ctor.options.props;\n if (!propOptions) {\n return\n }\n var res = {};\n var attrs = data.attrs;\n var props = data.props;\n var domProps = data.domProps;\n if (attrs || props || domProps) {\n for (var key in propOptions) {\n var altKey = hyphenate(key);\n checkProp(res, props, key, altKey, true) ||\n checkProp(res, attrs, key, altKey) ||\n checkProp(res, domProps, key, altKey);\n }\n }\n return res\n}\n\nfunction checkProp (\n res,\n hash,\n key,\n altKey,\n preserve\n) {\n if (hash) {\n if (hasOwn(hash, key)) {\n res[key] = hash[key];\n if (!preserve) {\n delete hash[key];\n }\n return true\n } else if (hasOwn(hash, altKey)) {\n res[key] = hash[altKey];\n if (!preserve) {\n delete hash[altKey];\n }\n return true\n }\n }\n return false\n}\n\nfunction mergeHooks (data) {\n if (!data.hook) {\n data.hook = {};\n }\n for (var i = 0; i < hooksToMerge.length; i++) {\n var key = hooksToMerge[i];\n var fromParent = data.hook[key];\n var ours = hooks[key];\n data.hook[key] = fromParent ? mergeHook$1(ours, fromParent) : ours;\n }\n}\n\nfunction mergeHook$1 (one, two) {\n return function (a, b, c, d) {\n one(a, b, c, d);\n two(a, b, c, d);\n }\n}\n\n/* */\n\nfunction mergeVNodeHook (def, hookKey, hook, key) {\n key = key + hookKey;\n var injectedHash = def.__injected || (def.__injected = {});\n if (!injectedHash[key]) {\n injectedHash[key] = true;\n var oldHook = def[hookKey];\n if (oldHook) {\n def[hookKey] = function () {\n oldHook.apply(this, arguments);\n hook.apply(this, arguments);\n };\n } else {\n def[hookKey] = hook;\n }\n }\n}\n\n/* */\n\nvar normalizeEvent = cached(function (name) {\n var once = name.charAt(0) === '~'; // Prefixed last, checked first\n name = once ? name.slice(1) : name;\n var capture = name.charAt(0) === '!';\n name = capture ? name.slice(1) : name;\n return {\n name: name,\n once: once,\n capture: capture\n }\n});\n\nfunction createEventHandle (fn) {\n var handle = {\n fn: fn,\n invoker: function () {\n var arguments$1 = arguments;\n\n var fn = handle.fn;\n if (Array.isArray(fn)) {\n for (var i = 0; i < fn.length; i++) {\n fn[i].apply(null, arguments$1);\n }\n } else {\n fn.apply(null, arguments);\n }\n }\n };\n return handle\n}\n\nfunction updateListeners (\n on,\n oldOn,\n add,\n remove$$1,\n vm\n) {\n var name, cur, old, event;\n for (name in on) {\n cur = on[name];\n old = oldOn[name];\n event = normalizeEvent(name);\n if (!cur) {\n process.env.NODE_ENV !== 'production' && warn(\n \"Invalid handler for event \\\"\" + (event.name) + \"\\\": got \" + String(cur),\n vm\n );\n } else if (!old) {\n if (!cur.invoker) {\n cur = on[name] = createEventHandle(cur);\n }\n add(event.name, cur.invoker, event.once, event.capture);\n } else if (cur !== old) {\n old.fn = cur;\n on[name] = old;\n }\n }\n for (name in oldOn) {\n if (!on[name]) {\n event = normalizeEvent(name);\n remove$$1(event.name, oldOn[name].invoker, event.capture);\n }\n }\n}\n\n/* */\n\n// The template compiler attempts to minimize the need for normalization by\n// statically analyzing the template at compile time.\n//\n// For plain HTML markup, normalization can be completely skipped because the\n// generated render function is guaranteed to return Array<VNode>. There are\n// two cases where extra normalization is needed:\n\n// 1. When the children contains components - because a functional component\n// may return an Array instead of a single root. In this case, just a simple\n// nomralization is needed - if any child is an Array, we flatten the whole\n// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep\n// because functional components already normalize their own children.\nfunction simpleNormalizeChildren (children) {\n for (var i = 0; i < children.length; i++) {\n if (Array.isArray(children[i])) {\n return Array.prototype.concat.apply([], children)\n }\n }\n return children\n}\n\n// 2. When the children contains constrcuts that always generated nested Arrays,\n// e.g. <template>, <slot>, v-for, or when the children is provided by user\n// with hand-written render functions / JSX. In such cases a full normalization\n// is needed to cater to all possible types of children values.\nfunction normalizeChildren (children) {\n return isPrimitive(children)\n ? [createTextVNode(children)]\n : Array.isArray(children)\n ? normalizeArrayChildren(children)\n : undefined\n}\n\nfunction normalizeArrayChildren (children, nestedIndex) {\n var res = [];\n var i, c, last;\n for (i = 0; i < children.length; i++) {\n c = children[i];\n if (c == null || typeof c === 'boolean') { continue }\n last = res[res.length - 1];\n // nested\n if (Array.isArray(c)) {\n res.push.apply(res, normalizeArrayChildren(c, ((nestedIndex || '') + \"_\" + i)));\n } else if (isPrimitive(c)) {\n if (last && last.text) {\n last.text += String(c);\n } else if (c !== '') {\n // convert primitive to vnode\n res.push(createTextVNode(c));\n }\n } else {\n if (c.text && last && last.text) {\n res[res.length - 1] = createTextVNode(last.text + c.text);\n } else {\n // default key for nested array children (likely generated by v-for)\n if (c.tag && c.key == null && nestedIndex != null) {\n c.key = \"__vlist\" + nestedIndex + \"_\" + i + \"__\";\n }\n res.push(c);\n }\n }\n }\n return res\n}\n\n/* */\n\nfunction getFirstComponentChild (children) {\n return children && children.filter(function (c) { return c && c.componentOptions; })[0]\n}\n\n/* */\n\nvar SIMPLE_NORMALIZE = 1;\nvar ALWAYS_NORMALIZE = 2;\n\n// wrapper function for providing a more flexible interface\n// without getting yelled at by flow\nfunction createElement (\n context,\n tag,\n data,\n children,\n normalizationType,\n alwaysNormalize\n) {\n if (Array.isArray(data) || isPrimitive(data)) {\n normalizationType = children;\n children = data;\n data = undefined;\n }\n if (alwaysNormalize) { normalizationType = ALWAYS_NORMALIZE; }\n return _createElement(context, tag, data, children, normalizationType)\n}\n\nfunction _createElement (\n context,\n tag,\n data,\n children,\n normalizationType\n) {\n if (data && data.__ob__) {\n process.env.NODE_ENV !== 'production' && warn(\n \"Avoid using observed data object as vnode data: \" + (JSON.stringify(data)) + \"\\n\" +\n 'Always create fresh vnode data objects in each render!',\n context\n );\n return createEmptyVNode()\n }\n if (!tag) {\n // in case of component :is set to falsy value\n return createEmptyVNode()\n }\n // support single function children as default scoped slot\n if (Array.isArray(children) &&\n typeof children[0] === 'function') {\n data = data || {};\n data.scopedSlots = { default: children[0] };\n children.length = 0;\n }\n if (normalizationType === ALWAYS_NORMALIZE) {\n children = normalizeChildren(children);\n } else if (normalizationType === SIMPLE_NORMALIZE) {\n children = simpleNormalizeChildren(children);\n }\n var vnode, ns;\n if (typeof tag === 'string') {\n var Ctor;\n ns = config.getTagNamespace(tag);\n if (config.isReservedTag(tag)) {\n // platform built-in elements\n vnode = new VNode(\n config.parsePlatformTagName(tag), data, children,\n undefined, undefined, context\n );\n } else if ((Ctor = resolveAsset(context.$options, 'components', tag))) {\n // component\n vnode = createComponent(Ctor, data, context, children, tag);\n } else {\n // unknown or unlisted namespaced elements\n // check at runtime because it may get assigned a namespace when its\n // parent normalizes children\n vnode = new VNode(\n tag, data, children,\n undefined, undefined, context\n );\n }\n } else {\n // direct component options / constructor\n vnode = createComponent(tag, data, context, children);\n }\n if (vnode) {\n if (ns) { applyNS(vnode, ns); }\n return vnode\n } else {\n return createEmptyVNode()\n }\n}\n\nfunction applyNS (vnode, ns) {\n vnode.ns = ns;\n if (vnode.tag === 'foreignObject') {\n // use default namespace inside foreignObject\n return\n }\n if (vnode.children) {\n for (var i = 0, l = vnode.children.length; i < l; i++) {\n var child = vnode.children[i];\n if (child.tag && !child.ns) {\n applyNS(child, ns);\n }\n }\n }\n}\n\n/* */\n\nfunction initRender (vm) {\n vm.$vnode = null; // the placeholder node in parent tree\n vm._vnode = null; // the root of the child tree\n vm._staticTrees = null;\n var parentVnode = vm.$options._parentVnode;\n var renderContext = parentVnode && parentVnode.context;\n vm.$slots = resolveSlots(vm.$options._renderChildren, renderContext);\n vm.$scopedSlots = {};\n // bind the createElement fn to this instance\n // so that we get proper render context inside it.\n // args order: tag, data, children, normalizationType, alwaysNormalize\n // internal version is used by render functions compiled from templates\n vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };\n // normalization is always applied for the public version, used in\n // user-written render functions.\n vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };\n}\n\nfunction renderMixin (Vue) {\n Vue.prototype.$nextTick = function (fn) {\n return nextTick(fn, this)\n };\n\n Vue.prototype._render = function () {\n var vm = this;\n var ref = vm.$options;\n var render = ref.render;\n var staticRenderFns = ref.staticRenderFns;\n var _parentVnode = ref._parentVnode;\n\n if (vm._isMounted) {\n // clone slot nodes on re-renders\n for (var key in vm.$slots) {\n vm.$slots[key] = cloneVNodes(vm.$slots[key]);\n }\n }\n\n if (_parentVnode && _parentVnode.data.scopedSlots) {\n vm.$scopedSlots = _parentVnode.data.scopedSlots;\n }\n\n if (staticRenderFns && !vm._staticTrees) {\n vm._staticTrees = [];\n }\n // set parent vnode. this allows render functions to have access\n // to the data on the placeholder node.\n vm.$vnode = _parentVnode;\n // render self\n var vnode;\n try {\n vnode = render.call(vm._renderProxy, vm.$createElement);\n } catch (e) {\n /* istanbul ignore else */\n if (config.errorHandler) {\n config.errorHandler.call(null, e, vm);\n } else {\n if (process.env.NODE_ENV !== 'production') {\n warn((\"Error when rendering \" + (formatComponentName(vm)) + \":\"));\n }\n throw e\n }\n // return previous vnode to prevent render error causing blank component\n vnode = vm._vnode;\n }\n // return empty vnode in case the render function errored out\n if (!(vnode instanceof VNode)) {\n if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {\n warn(\n 'Multiple root nodes returned from render function. Render function ' +\n 'should return a single root node.',\n vm\n );\n }\n vnode = createEmptyVNode();\n }\n // set parent\n vnode.parent = _parentVnode;\n return vnode\n };\n\n // toString for mustaches\n Vue.prototype._s = _toString;\n // convert text to vnode\n Vue.prototype._v = createTextVNode;\n // number conversion\n Vue.prototype._n = toNumber;\n // empty vnode\n Vue.prototype._e = createEmptyVNode;\n // loose equal\n Vue.prototype._q = looseEqual;\n // loose indexOf\n Vue.prototype._i = looseIndexOf;\n\n // render static tree by index\n Vue.prototype._m = function renderStatic (\n index,\n isInFor\n ) {\n var tree = this._staticTrees[index];\n // if has already-rendered static tree and not inside v-for,\n // we can reuse the same tree by doing a shallow clone.\n if (tree && !isInFor) {\n return Array.isArray(tree)\n ? cloneVNodes(tree)\n : cloneVNode(tree)\n }\n // otherwise, render a fresh tree.\n tree = this._staticTrees[index] = this.$options.staticRenderFns[index].call(this._renderProxy);\n markStatic(tree, (\"__static__\" + index), false);\n return tree\n };\n\n // mark node as static (v-once)\n Vue.prototype._o = function markOnce (\n tree,\n index,\n key\n ) {\n markStatic(tree, (\"__once__\" + index + (key ? (\"_\" + key) : \"\")), true);\n return tree\n };\n\n function markStatic (tree, key, isOnce) {\n if (Array.isArray(tree)) {\n for (var i = 0; i < tree.length; i++) {\n if (tree[i] && typeof tree[i] !== 'string') {\n markStaticNode(tree[i], (key + \"_\" + i), isOnce);\n }\n }\n } else {\n markStaticNode(tree, key, isOnce);\n }\n }\n\n function markStaticNode (node, key, isOnce) {\n node.isStatic = true;\n node.key = key;\n node.isOnce = isOnce;\n }\n\n // filter resolution helper\n Vue.prototype._f = function resolveFilter (id) {\n return resolveAsset(this.$options, 'filters', id, true) || identity\n };\n\n // render v-for\n Vue.prototype._l = function renderList (\n val,\n render\n ) {\n var ret, i, l, keys, key;\n if (Array.isArray(val) || typeof val === 'string') {\n ret = new Array(val.length);\n for (i = 0, l = val.length; i < l; i++) {\n ret[i] = render(val[i], i);\n }\n } else if (typeof val === 'number') {\n ret = new Array(val);\n for (i = 0; i < val; i++) {\n ret[i] = render(i + 1, i);\n }\n } else if (isObject(val)) {\n keys = Object.keys(val);\n ret = new Array(keys.length);\n for (i = 0, l = keys.length; i < l; i++) {\n key = keys[i];\n ret[i] = render(val[key], key, i);\n }\n }\n return ret\n };\n\n // renderSlot\n Vue.prototype._t = function (\n name,\n fallback,\n props,\n bindObject\n ) {\n var scopedSlotFn = this.$scopedSlots[name];\n if (scopedSlotFn) { // scoped slot\n props = props || {};\n if (bindObject) {\n extend(props, bindObject);\n }\n return scopedSlotFn(props) || fallback\n } else {\n var slotNodes = this.$slots[name];\n // warn duplicate slot usage\n if (slotNodes && process.env.NODE_ENV !== 'production') {\n slotNodes._rendered && warn(\n \"Duplicate presence of slot \\\"\" + name + \"\\\" found in the same render tree \" +\n \"- this will likely cause render errors.\",\n this\n );\n slotNodes._rendered = true;\n }\n return slotNodes || fallback\n }\n };\n\n // apply v-bind object\n Vue.prototype._b = function bindProps (\n data,\n tag,\n value,\n asProp\n ) {\n if (value) {\n if (!isObject(value)) {\n process.env.NODE_ENV !== 'production' && warn(\n 'v-bind without argument expects an Object or Array value',\n this\n );\n } else {\n if (Array.isArray(value)) {\n value = toObject(value);\n }\n for (var key in value) {\n if (key === 'class' || key === 'style') {\n data[key] = value[key];\n } else {\n var type = data.attrs && data.attrs.type;\n var hash = asProp || config.mustUseProp(tag, type, key)\n ? data.domProps || (data.domProps = {})\n : data.attrs || (data.attrs = {});\n hash[key] = value[key];\n }\n }\n }\n }\n return data\n };\n\n // check v-on keyCodes\n Vue.prototype._k = function checkKeyCodes (\n eventKeyCode,\n key,\n builtInAlias\n ) {\n var keyCodes = config.keyCodes[key] || builtInAlias;\n if (Array.isArray(keyCodes)) {\n return keyCodes.indexOf(eventKeyCode) === -1\n } else {\n return keyCodes !== eventKeyCode\n }\n };\n}\n\nfunction resolveSlots (\n children,\n context\n) {\n var slots = {};\n if (!children) {\n return slots\n }\n var defaultSlot = [];\n var name, child;\n for (var i = 0, l = children.length; i < l; i++) {\n child = children[i];\n // named slots should only be respected if the vnode was rendered in the\n // same context.\n if ((child.context === context || child.functionalContext === context) &&\n child.data && (name = child.data.slot)) {\n var slot = (slots[name] || (slots[name] = []));\n if (child.tag === 'template') {\n slot.push.apply(slot, child.children);\n } else {\n slot.push(child);\n }\n } else {\n defaultSlot.push(child);\n }\n }\n // ignore single whitespace\n if (defaultSlot.length && !(\n defaultSlot.length === 1 &&\n (defaultSlot[0].text === ' ' || defaultSlot[0].isComment)\n )) {\n slots.default = defaultSlot;\n }\n return slots\n}\n\n/* */\n\nfunction initEvents (vm) {\n vm._events = Object.create(null);\n vm._hasHookEvent = false;\n // init parent attached events\n var listeners = vm.$options._parentListeners;\n if (listeners) {\n updateComponentListeners(vm, listeners);\n }\n}\n\nvar target;\n\nfunction add$1 (event, fn, once) {\n if (once) {\n target.$once(event, fn);\n } else {\n target.$on(event, fn);\n }\n}\n\nfunction remove$2 (event, fn) {\n target.$off(event, fn);\n}\n\nfunction updateComponentListeners (\n vm,\n listeners,\n oldListeners\n) {\n target = vm;\n updateListeners(listeners, oldListeners || {}, add$1, remove$2, vm);\n}\n\nfunction eventsMixin (Vue) {\n var hookRE = /^hook:/;\n Vue.prototype.$on = function (event, fn) {\n var vm = this;(vm._events[event] || (vm._events[event] = [])).push(fn);\n // optimize hook:event cost by using a boolean flag marked at registration\n // instead of a hash lookup\n if (hookRE.test(event)) {\n vm._hasHookEvent = true;\n }\n return vm\n };\n\n Vue.prototype.$once = function (event, fn) {\n var vm = this;\n function on () {\n vm.$off(event, on);\n fn.apply(vm, arguments);\n }\n on.fn = fn;\n vm.$on(event, on);\n return vm\n };\n\n Vue.prototype.$off = function (event, fn) {\n var vm = this;\n // all\n if (!arguments.length) {\n vm._events = Object.create(null);\n return vm\n }\n // specific event\n var cbs = vm._events[event];\n if (!cbs) {\n return vm\n }\n if (arguments.length === 1) {\n vm._events[event] = null;\n return vm\n }\n // specific handler\n var cb;\n var i = cbs.length;\n while (i--) {\n cb = cbs[i];\n if (cb === fn || cb.fn === fn) {\n cbs.splice(i, 1);\n break\n }\n }\n return vm\n };\n\n Vue.prototype.$emit = function (event) {\n var vm = this;\n var cbs = vm._events[event];\n if (cbs) {\n cbs = cbs.length > 1 ? toArray(cbs) : cbs;\n var args = toArray(arguments, 1);\n for (var i = 0, l = cbs.length; i < l; i++) {\n cbs[i].apply(vm, args);\n }\n }\n return vm\n };\n}\n\n/* */\n\nvar activeInstance = null;\n\nfunction initLifecycle (vm) {\n var options = vm.$options;\n\n // locate first non-abstract parent\n var parent = options.parent;\n if (parent && !options.abstract) {\n while (parent.$options.abstract && parent.$parent) {\n parent = parent.$parent;\n }\n parent.$children.push(vm);\n }\n\n vm.$parent = parent;\n vm.$root = parent ? parent.$root : vm;\n\n vm.$children = [];\n vm.$refs = {};\n\n vm._watcher = null;\n vm._inactive = false;\n vm._isMounted = false;\n vm._isDestroyed = false;\n vm._isBeingDestroyed = false;\n}\n\nfunction lifecycleMixin (Vue) {\n Vue.prototype._mount = function (\n el,\n hydrating\n ) {\n var vm = this;\n vm.$el = el;\n if (!vm.$options.render) {\n vm.$options.render = createEmptyVNode;\n if (process.env.NODE_ENV !== 'production') {\n /* istanbul ignore if */\n if (vm.$options.template && vm.$options.template.charAt(0) !== '#') {\n warn(\n 'You are using the runtime-only build of Vue where the template ' +\n 'option is not available. Either pre-compile the templates into ' +\n 'render functions, or use the compiler-included build.',\n vm\n );\n } else {\n warn(\n 'Failed to mount component: template or render function not defined.',\n vm\n );\n }\n }\n }\n callHook(vm, 'beforeMount');\n vm._watcher = new Watcher(vm, function updateComponent () {\n vm._update(vm._render(), hydrating);\n }, noop);\n hydrating = false;\n // manually mounted instance, call mounted on self\n // mounted is called for render-created child components in its inserted hook\n if (vm.$vnode == null) {\n vm._isMounted = true;\n callHook(vm, 'mounted');\n }\n return vm\n };\n\n Vue.prototype._update = function (vnode, hydrating) {\n var vm = this;\n if (vm._isMounted) {\n callHook(vm, 'beforeUpdate');\n }\n var prevEl = vm.$el;\n var prevVnode = vm._vnode;\n var prevActiveInstance = activeInstance;\n activeInstance = vm;\n vm._vnode = vnode;\n // Vue.prototype.__patch__ is injected in entry points\n // based on the rendering backend used.\n if (!prevVnode) {\n // initial render\n vm.$el = vm.__patch__(\n vm.$el, vnode, hydrating, false /* removeOnly */,\n vm.$options._parentElm,\n vm.$options._refElm\n );\n } else {\n // updates\n vm.$el = vm.__patch__(prevVnode, vnode);\n }\n activeInstance = prevActiveInstance;\n // update __vue__ reference\n if (prevEl) {\n prevEl.__vue__ = null;\n }\n if (vm.$el) {\n vm.$el.__vue__ = vm;\n }\n // if parent is an HOC, update its $el as well\n if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {\n vm.$parent.$el = vm.$el;\n }\n // updated hook is called by the scheduler to ensure that children are\n // updated in a parent's updated hook.\n };\n\n Vue.prototype._updateFromParent = function (\n propsData,\n listeners,\n parentVnode,\n renderChildren\n ) {\n var vm = this;\n var hasChildren = !!(vm.$options._renderChildren || renderChildren);\n vm.$options._parentVnode = parentVnode;\n vm.$vnode = parentVnode; // update vm's placeholder node without re-render\n if (vm._vnode) { // update child tree's parent\n vm._vnode.parent = parentVnode;\n }\n vm.$options._renderChildren = renderChildren;\n // update props\n if (propsData && vm.$options.props) {\n observerState.shouldConvert = false;\n if (process.env.NODE_ENV !== 'production') {\n observerState.isSettingProps = true;\n }\n var propKeys = vm.$options._propKeys || [];\n for (var i = 0; i < propKeys.length; i++) {\n var key = propKeys[i];\n vm[key] = validateProp(key, vm.$options.props, propsData, vm);\n }\n observerState.shouldConvert = true;\n if (process.env.NODE_ENV !== 'production') {\n observerState.isSettingProps = false;\n }\n vm.$options.propsData = propsData;\n }\n // update listeners\n if (listeners) {\n var oldListeners = vm.$options._parentListeners;\n vm.$options._parentListeners = listeners;\n updateComponentListeners(vm, listeners, oldListeners);\n }\n // resolve slots + force update if has children\n if (hasChildren) {\n vm.$slots = resolveSlots(renderChildren, parentVnode.context);\n vm.$forceUpdate();\n }\n };\n\n Vue.prototype.$forceUpdate = function () {\n var vm = this;\n if (vm._watcher) {\n vm._watcher.update();\n }\n };\n\n Vue.prototype.$destroy = function () {\n var vm = this;\n if (vm._isBeingDestroyed) {\n return\n }\n callHook(vm, 'beforeDestroy');\n vm._isBeingDestroyed = true;\n // remove self from parent\n var parent = vm.$parent;\n if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {\n remove$1(parent.$children, vm);\n }\n // teardown watchers\n if (vm._watcher) {\n vm._watcher.teardown();\n }\n var i = vm._watchers.length;\n while (i--) {\n vm._watchers[i].teardown();\n }\n // remove reference from data ob\n // frozen object may not have observer.\n if (vm._data.__ob__) {\n vm._data.__ob__.vmCount--;\n }\n // call the last hook...\n vm._isDestroyed = true;\n callHook(vm, 'destroyed');\n // turn off all instance listeners.\n vm.$off();\n // remove __vue__ reference\n if (vm.$el) {\n vm.$el.__vue__ = null;\n }\n // invoke destroy hooks on current rendered tree\n vm.__patch__(vm._vnode, null);\n };\n}\n\nfunction callHook (vm, hook) {\n var handlers = vm.$options[hook];\n if (handlers) {\n for (var i = 0, j = handlers.length; i < j; i++) {\n handlers[i].call(vm);\n }\n }\n if (vm._hasHookEvent) {\n vm.$emit('hook:' + hook);\n }\n}\n\n/* */\n\n\nvar queue = [];\nvar has$1 = {};\nvar circular = {};\nvar waiting = false;\nvar flushing = false;\nvar index = 0;\n\n/**\n * Reset the scheduler's state.\n */\nfunction resetSchedulerState () {\n queue.length = 0;\n has$1 = {};\n if (process.env.NODE_ENV !== 'production') {\n circular = {};\n }\n waiting = flushing = false;\n}\n\n/**\n * Flush both queues and run the watchers.\n */\nfunction flushSchedulerQueue () {\n flushing = true;\n var watcher, id, vm;\n\n // Sort queue before flush.\n // This ensures that:\n // 1. Components are updated from parent to child. (because parent is always\n // created before the child)\n // 2. A component's user watchers are run before its render watcher (because\n // user watchers are created before the render watcher)\n // 3. If a component is destroyed during a parent component's watcher run,\n // its watchers can be skipped.\n queue.sort(function (a, b) { return a.id - b.id; });\n\n // do not cache length because more watchers might be pushed\n // as we run existing watchers\n for (index = 0; index < queue.length; index++) {\n watcher = queue[index];\n id = watcher.id;\n has$1[id] = null;\n watcher.run();\n // in dev build, check and stop circular updates.\n if (process.env.NODE_ENV !== 'production' && has$1[id] != null) {\n circular[id] = (circular[id] || 0) + 1;\n if (circular[id] > config._maxUpdateCount) {\n warn(\n 'You may have an infinite update loop ' + (\n watcher.user\n ? (\"in watcher with expression \\\"\" + (watcher.expression) + \"\\\"\")\n : \"in a component render function.\"\n ),\n watcher.vm\n );\n break\n }\n }\n }\n\n // call updated hooks\n index = queue.length;\n while (index--) {\n watcher = queue[index];\n vm = watcher.vm;\n if (vm._watcher === watcher && vm._isMounted) {\n callHook(vm, 'updated');\n }\n }\n\n // devtool hook\n /* istanbul ignore if */\n if (devtools && config.devtools) {\n devtools.emit('flush');\n }\n\n resetSchedulerState();\n}\n\n/**\n * Push a watcher into the watcher queue.\n * Jobs with duplicate IDs will be skipped unless it's\n * pushed when the queue is being flushed.\n */\nfunction queueWatcher (watcher) {\n var id = watcher.id;\n if (has$1[id] == null) {\n has$1[id] = true;\n if (!flushing) {\n queue.push(watcher);\n } else {\n // if already flushing, splice the watcher based on its id\n // if already past its id, it will be run next immediately.\n var i = queue.length - 1;\n while (i >= 0 && queue[i].id > watcher.id) {\n i--;\n }\n queue.splice(Math.max(i, index) + 1, 0, watcher);\n }\n // queue the flush\n if (!waiting) {\n waiting = true;\n nextTick(flushSchedulerQueue);\n }\n }\n}\n\n/* */\n\nvar uid$2 = 0;\n\n/**\n * A watcher parses an expression, collects dependencies,\n * and fires callback when the expression value changes.\n * This is used for both the $watch() api and directives.\n */\nvar Watcher = function Watcher (\n vm,\n expOrFn,\n cb,\n options\n) {\n this.vm = vm;\n vm._watchers.push(this);\n // options\n if (options) {\n this.deep = !!options.deep;\n this.user = !!options.user;\n this.lazy = !!options.lazy;\n this.sync = !!options.sync;\n } else {\n this.deep = this.user = this.lazy = this.sync = false;\n }\n this.cb = cb;\n this.id = ++uid$2; // uid for batching\n this.active = true;\n this.dirty = this.lazy; // for lazy watchers\n this.deps = [];\n this.newDeps = [];\n this.depIds = new _Set();\n this.newDepIds = new _Set();\n this.expression = process.env.NODE_ENV !== 'production'\n ? expOrFn.toString()\n : '';\n // parse expression for getter\n if (typeof expOrFn === 'function') {\n this.getter = expOrFn;\n } else {\n this.getter = parsePath(expOrFn);\n if (!this.getter) {\n this.getter = function () {};\n process.env.NODE_ENV !== 'production' && warn(\n \"Failed watching path: \\\"\" + expOrFn + \"\\\" \" +\n 'Watcher only accepts simple dot-delimited paths. ' +\n 'For full control, use a function instead.',\n vm\n );\n }\n }\n this.value = this.lazy\n ? undefined\n : this.get();\n};\n\n/**\n * Evaluate the getter, and re-collect dependencies.\n */\nWatcher.prototype.get = function get () {\n pushTarget(this);\n var value = this.getter.call(this.vm, this.vm);\n // \"touch\" every property so they are all tracked as\n // dependencies for deep watching\n if (this.deep) {\n traverse(value);\n }\n popTarget();\n this.cleanupDeps();\n return value\n};\n\n/**\n * Add a dependency to this directive.\n */\nWatcher.prototype.addDep = function addDep (dep) {\n var id = dep.id;\n if (!this.newDepIds.has(id)) {\n this.newDepIds.add(id);\n this.newDeps.push(dep);\n if (!this.depIds.has(id)) {\n dep.addSub(this);\n }\n }\n};\n\n/**\n * Clean up for dependency collection.\n */\nWatcher.prototype.cleanupDeps = function cleanupDeps () {\n var this$1 = this;\n\n var i = this.deps.length;\n while (i--) {\n var dep = this$1.deps[i];\n if (!this$1.newDepIds.has(dep.id)) {\n dep.removeSub(this$1);\n }\n }\n var tmp = this.depIds;\n this.depIds = this.newDepIds;\n this.newDepIds = tmp;\n this.newDepIds.clear();\n tmp = this.deps;\n this.deps = this.newDeps;\n this.newDeps = tmp;\n this.newDeps.length = 0;\n};\n\n/**\n * Subscriber interface.\n * Will be called when a dependency changes.\n */\nWatcher.prototype.update = function update () {\n /* istanbul ignore else */\n if (this.lazy) {\n this.dirty = true;\n } else if (this.sync) {\n this.run();\n } else {\n queueWatcher(this);\n }\n};\n\n/**\n * Scheduler job interface.\n * Will be called by the scheduler.\n */\nWatcher.prototype.run = function run () {\n if (this.active) {\n var value = this.get();\n if (\n value !== this.value ||\n // Deep watchers and watchers on Object/Arrays should fire even\n // when the value is the same, because the value may\n // have mutated.\n isObject(value) ||\n this.deep\n ) {\n // set new value\n var oldValue = this.value;\n this.value = value;\n if (this.user) {\n try {\n this.cb.call(this.vm, value, oldValue);\n } catch (e) {\n /* istanbul ignore else */\n if (config.errorHandler) {\n config.errorHandler.call(null, e, this.vm);\n } else {\n process.env.NODE_ENV !== 'production' && warn(\n (\"Error in watcher \\\"\" + (this.expression) + \"\\\"\"),\n this.vm\n );\n throw e\n }\n }\n } else {\n this.cb.call(this.vm, value, oldValue);\n }\n }\n }\n};\n\n/**\n * Evaluate the value of the watcher.\n * This only gets called for lazy watchers.\n */\nWatcher.prototype.evaluate = function evaluate () {\n this.value = this.get();\n this.dirty = false;\n};\n\n/**\n * Depend on all deps collected by this watcher.\n */\nWatcher.prototype.depend = function depend () {\n var this$1 = this;\n\n var i = this.deps.length;\n while (i--) {\n this$1.deps[i].depend();\n }\n};\n\n/**\n * Remove self from all dependencies' subscriber list.\n */\nWatcher.prototype.teardown = function teardown () {\n var this$1 = this;\n\n if (this.active) {\n // remove self from vm's watcher list\n // this is a somewhat expensive operation so we skip it\n // if the vm is being destroyed.\n if (!this.vm._isBeingDestroyed) {\n remove$1(this.vm._watchers, this);\n }\n var i = this.deps.length;\n while (i--) {\n this$1.deps[i].removeSub(this$1);\n }\n this.active = false;\n }\n};\n\n/**\n * Recursively traverse an object to evoke all converted\n * getters, so that every nested property inside the object\n * is collected as a \"deep\" dependency.\n */\nvar seenObjects = new _Set();\nfunction traverse (val) {\n seenObjects.clear();\n _traverse(val, seenObjects);\n}\n\nfunction _traverse (val, seen) {\n var i, keys;\n var isA = Array.isArray(val);\n if ((!isA && !isObject(val)) || !Object.isExtensible(val)) {\n return\n }\n if (val.__ob__) {\n var depId = val.__ob__.dep.id;\n if (seen.has(depId)) {\n return\n }\n seen.add(depId);\n }\n if (isA) {\n i = val.length;\n while (i--) { _traverse(val[i], seen); }\n } else {\n keys = Object.keys(val);\n i = keys.length;\n while (i--) { _traverse(val[keys[i]], seen); }\n }\n}\n\n/* */\n\nfunction initState (vm) {\n vm._watchers = [];\n var opts = vm.$options;\n if (opts.props) { initProps(vm, opts.props); }\n if (opts.methods) { initMethods(vm, opts.methods); }\n if (opts.data) {\n initData(vm);\n } else {\n observe(vm._data = {}, true /* asRootData */);\n }\n if (opts.computed) { initComputed(vm, opts.computed); }\n if (opts.watch) { initWatch(vm, opts.watch); }\n}\n\nvar isReservedProp = { key: 1, ref: 1, slot: 1 };\n\nfunction initProps (vm, props) {\n var propsData = vm.$options.propsData || {};\n var keys = vm.$options._propKeys = Object.keys(props);\n var isRoot = !vm.$parent;\n // root instance props should be converted\n observerState.shouldConvert = isRoot;\n var loop = function ( i ) {\n var key = keys[i];\n /* istanbul ignore else */\n if (process.env.NODE_ENV !== 'production') {\n if (isReservedProp[key]) {\n warn(\n (\"\\\"\" + key + \"\\\" is a reserved attribute and cannot be used as component prop.\"),\n vm\n );\n }\n defineReactive$$1(vm, key, validateProp(key, props, propsData, vm), function () {\n if (vm.$parent && !observerState.isSettingProps) {\n warn(\n \"Avoid mutating a prop directly since the value will be \" +\n \"overwritten whenever the parent component re-renders. \" +\n \"Instead, use a data or computed property based on the prop's \" +\n \"value. Prop being mutated: \\\"\" + key + \"\\\"\",\n vm\n );\n }\n });\n } else {\n defineReactive$$1(vm, key, validateProp(key, props, propsData, vm));\n }\n };\n\n for (var i = 0; i < keys.length; i++) loop( i );\n observerState.shouldConvert = true;\n}\n\nfunction initData (vm) {\n var data = vm.$options.data;\n data = vm._data = typeof data === 'function'\n ? data.call(vm)\n : data || {};\n if (!isPlainObject(data)) {\n data = {};\n process.env.NODE_ENV !== 'production' && warn(\n 'data functions should return an object:\\n' +\n 'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',\n vm\n );\n }\n // proxy data on instance\n var keys = Object.keys(data);\n var props = vm.$options.props;\n var i = keys.length;\n while (i--) {\n if (props && hasOwn(props, keys[i])) {\n process.env.NODE_ENV !== 'production' && warn(\n \"The data property \\\"\" + (keys[i]) + \"\\\" is already declared as a prop. \" +\n \"Use prop default value instead.\",\n vm\n );\n } else {\n proxy(vm, keys[i]);\n }\n }\n // observe data\n observe(data, true /* asRootData */);\n}\n\nvar computedSharedDefinition = {\n enumerable: true,\n configurable: true,\n get: noop,\n set: noop\n};\n\nfunction initComputed (vm, computed) {\n for (var key in computed) {\n /* istanbul ignore if */\n if (process.env.NODE_ENV !== 'production' && key in vm) {\n warn(\n \"existing instance property \\\"\" + key + \"\\\" will be \" +\n \"overwritten by a computed property with the same name.\",\n vm\n );\n }\n var userDef = computed[key];\n if (typeof userDef === 'function') {\n computedSharedDefinition.get = makeComputedGetter(userDef, vm);\n computedSharedDefinition.set = noop;\n } else {\n computedSharedDefinition.get = userDef.get\n ? userDef.cache !== false\n ? makeComputedGetter(userDef.get, vm)\n : bind$1(userDef.get, vm)\n : noop;\n computedSharedDefinition.set = userDef.set\n ? bind$1(userDef.set, vm)\n : noop;\n }\n Object.defineProperty(vm, key, computedSharedDefinition);\n }\n}\n\nfunction makeComputedGetter (getter, owner) {\n var watcher = new Watcher(owner, getter, noop, {\n lazy: true\n });\n return function computedGetter () {\n if (watcher.dirty) {\n watcher.evaluate();\n }\n if (Dep.target) {\n watcher.depend();\n }\n return watcher.value\n }\n}\n\nfunction initMethods (vm, methods) {\n for (var key in methods) {\n vm[key] = methods[key] == null ? noop : bind$1(methods[key], vm);\n if (process.env.NODE_ENV !== 'production' && methods[key] == null) {\n warn(\n \"method \\\"\" + key + \"\\\" has an undefined value in the component definition. \" +\n \"Did you reference the function correctly?\",\n vm\n );\n }\n }\n}\n\nfunction initWatch (vm, watch) {\n for (var key in watch) {\n var handler = watch[key];\n if (Array.isArray(handler)) {\n for (var i = 0; i < handler.length; i++) {\n createWatcher(vm, key, handler[i]);\n }\n } else {\n createWatcher(vm, key, handler);\n }\n }\n}\n\nfunction createWatcher (vm, key, handler) {\n var options;\n if (isPlainObject(handler)) {\n options = handler;\n handler = handler.handler;\n }\n if (typeof handler === 'string') {\n handler = vm[handler];\n }\n vm.$watch(key, handler, options);\n}\n\nfunction stateMixin (Vue) {\n // flow somehow has problems with directly declared definition object\n // when using Object.defineProperty, so we have to procedurally build up\n // the object here.\n var dataDef = {};\n dataDef.get = function () {\n return this._data\n };\n if (process.env.NODE_ENV !== 'production') {\n dataDef.set = function (newData) {\n warn(\n 'Avoid replacing instance root $data. ' +\n 'Use nested data properties instead.',\n this\n );\n };\n }\n Object.defineProperty(Vue.prototype, '$data', dataDef);\n\n Vue.prototype.$set = set$1;\n Vue.prototype.$delete = del;\n\n Vue.prototype.$watch = function (\n expOrFn,\n cb,\n options\n ) {\n var vm = this;\n options = options || {};\n options.user = true;\n var watcher = new Watcher(vm, expOrFn, cb, options);\n if (options.immediate) {\n cb.call(vm, watcher.value);\n }\n return function unwatchFn () {\n watcher.teardown();\n }\n };\n}\n\nfunction proxy (vm, key) {\n if (!isReserved(key)) {\n Object.defineProperty(vm, key, {\n configurable: true,\n enumerable: true,\n get: function proxyGetter () {\n return vm._data[key]\n },\n set: function proxySetter (val) {\n vm._data[key] = val;\n }\n });\n }\n}\n\n/* */\n\nvar uid = 0;\n\nfunction initMixin (Vue) {\n Vue.prototype._init = function (options) {\n var vm = this;\n // a uid\n vm._uid = uid++;\n // a flag to avoid this being observed\n vm._isVue = true;\n // merge options\n if (options && options._isComponent) {\n // optimize internal component instantiation\n // since dynamic options merging is pretty slow, and none of the\n // internal component options needs special treatment.\n initInternalComponent(vm, options);\n } else {\n vm.$options = mergeOptions(\n resolveConstructorOptions(vm.constructor),\n options || {},\n vm\n );\n }\n /* istanbul ignore else */\n if (process.env.NODE_ENV !== 'production') {\n initProxy(vm);\n } else {\n vm._renderProxy = vm;\n }\n // expose real self\n vm._self = vm;\n initLifecycle(vm);\n initEvents(vm);\n initRender(vm);\n callHook(vm, 'beforeCreate');\n initState(vm);\n callHook(vm, 'created');\n if (vm.$options.el) {\n vm.$mount(vm.$options.el);\n }\n };\n}\n\nfunction initInternalComponent (vm, options) {\n var opts = vm.$options = Object.create(vm.constructor.options);\n // doing this because it's faster than dynamic enumeration.\n opts.parent = options.parent;\n opts.propsData = options.propsData;\n opts._parentVnode = options._parentVnode;\n opts._parentListeners = options._parentListeners;\n opts._renderChildren = options._renderChildren;\n opts._componentTag = options._componentTag;\n opts._parentElm = options._parentElm;\n opts._refElm = options._refElm;\n if (options.render) {\n opts.render = options.render;\n opts.staticRenderFns = options.staticRenderFns;\n }\n}\n\nfunction resolveConstructorOptions (Ctor) {\n var options = Ctor.options;\n if (Ctor.super) {\n var superOptions = Ctor.super.options;\n var cachedSuperOptions = Ctor.superOptions;\n var extendOptions = Ctor.extendOptions;\n if (superOptions !== cachedSuperOptions) {\n // super option changed\n Ctor.superOptions = superOptions;\n extendOptions.render = options.render;\n extendOptions.staticRenderFns = options.staticRenderFns;\n extendOptions._scopeId = options._scopeId;\n options = Ctor.options = mergeOptions(superOptions, extendOptions);\n if (options.name) {\n options.components[options.name] = Ctor;\n }\n }\n }\n return options\n}\n\nfunction Vue$3 (options) {\n if (process.env.NODE_ENV !== 'production' &&\n !(this instanceof Vue$3)) {\n warn('Vue is a constructor and should be called with the `new` keyword');\n }\n this._init(options);\n}\n\ninitMixin(Vue$3);\nstateMixin(Vue$3);\neventsMixin(Vue$3);\nlifecycleMixin(Vue$3);\nrenderMixin(Vue$3);\n\n/* */\n\nfunction initUse (Vue) {\n Vue.use = function (plugin) {\n /* istanbul ignore if */\n if (plugin.installed) {\n return\n }\n // additional parameters\n var args = toArray(arguments, 1);\n args.unshift(this);\n if (typeof plugin.install === 'function') {\n plugin.install.apply(plugin, args);\n } else {\n plugin.apply(null, args);\n }\n plugin.installed = true;\n return this\n };\n}\n\n/* */\n\nfunction initMixin$1 (Vue) {\n Vue.mixin = function (mixin) {\n this.options = mergeOptions(this.options, mixin);\n };\n}\n\n/* */\n\nfunction initExtend (Vue) {\n /**\n * Each instance constructor, including Vue, has a unique\n * cid. This enables us to create wrapped \"child\n * constructors\" for prototypal inheritance and cache them.\n */\n Vue.cid = 0;\n var cid = 1;\n\n /**\n * Class inheritance\n */\n Vue.extend = function (extendOptions) {\n extendOptions = extendOptions || {};\n var Super = this;\n var SuperId = Super.cid;\n var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});\n if (cachedCtors[SuperId]) {\n return cachedCtors[SuperId]\n }\n var name = extendOptions.name || Super.options.name;\n if (process.env.NODE_ENV !== 'production') {\n if (!/^[a-zA-Z][\\w-]*$/.test(name)) {\n warn(\n 'Invalid component name: \"' + name + '\". Component names ' +\n 'can only contain alphanumeric characters and the hyphen, ' +\n 'and must start with a letter.'\n );\n }\n }\n var Sub = function VueComponent (options) {\n this._init(options);\n };\n Sub.prototype = Object.create(Super.prototype);\n Sub.prototype.constructor = Sub;\n Sub.cid = cid++;\n Sub.options = mergeOptions(\n Super.options,\n extendOptions\n );\n Sub['super'] = Super;\n // allow further extension/mixin/plugin usage\n Sub.extend = Super.extend;\n Sub.mixin = Super.mixin;\n Sub.use = Super.use;\n // create asset registers, so extended classes\n // can have their private assets too.\n config._assetTypes.forEach(function (type) {\n Sub[type] = Super[type];\n });\n // enable recursive self-lookup\n if (name) {\n Sub.options.components[name] = Sub;\n }\n // keep a reference to the super options at extension time.\n // later at instantiation we can check if Super's options have\n // been updated.\n Sub.superOptions = Super.options;\n Sub.extendOptions = extendOptions;\n // cache constructor\n cachedCtors[SuperId] = Sub;\n return Sub\n };\n}\n\n/* */\n\nfunction initAssetRegisters (Vue) {\n /**\n * Create asset registration methods.\n */\n config._assetTypes.forEach(function (type) {\n Vue[type] = function (\n id,\n definition\n ) {\n if (!definition) {\n return this.options[type + 's'][id]\n } else {\n /* istanbul ignore if */\n if (process.env.NODE_ENV !== 'production') {\n if (type === 'component' && config.isReservedTag(id)) {\n warn(\n 'Do not use built-in or reserved HTML elements as component ' +\n 'id: ' + id\n );\n }\n }\n if (type === 'component' && isPlainObject(definition)) {\n definition.name = definition.name || id;\n definition = this.options._base.extend(definition);\n }\n if (type === 'directive' && typeof definition === 'function') {\n definition = { bind: definition, update: definition };\n }\n this.options[type + 's'][id] = definition;\n return definition\n }\n };\n });\n}\n\n/* */\n\nvar patternTypes = [String, RegExp];\n\nfunction getComponentName (opts) {\n return opts && (opts.Ctor.options.name || opts.tag)\n}\n\nfunction matches (pattern, name) {\n if (typeof pattern === 'string') {\n return pattern.split(',').indexOf(name) > -1\n } else {\n return pattern.test(name)\n }\n}\n\nfunction pruneCache (cache, filter) {\n for (var key in cache) {\n var cachedNode = cache[key];\n if (cachedNode) {\n var name = getComponentName(cachedNode.componentOptions);\n if (name && !filter(name)) {\n pruneCacheEntry(cachedNode);\n cache[key] = null;\n }\n }\n }\n}\n\nfunction pruneCacheEntry (vnode) {\n if (vnode) {\n if (!vnode.componentInstance._inactive) {\n callHook(vnode.componentInstance, 'deactivated');\n }\n vnode.componentInstance.$destroy();\n }\n}\n\nvar KeepAlive = {\n name: 'keep-alive',\n abstract: true,\n\n props: {\n include: patternTypes,\n exclude: patternTypes\n },\n\n created: function created () {\n this.cache = Object.create(null);\n },\n\n destroyed: function destroyed () {\n var this$1 = this;\n\n for (var key in this.cache) {\n pruneCacheEntry(this$1.cache[key]);\n }\n },\n\n watch: {\n include: function include (val) {\n pruneCache(this.cache, function (name) { return matches(val, name); });\n },\n exclude: function exclude (val) {\n pruneCache(this.cache, function (name) { return !matches(val, name); });\n }\n },\n\n render: function render () {\n var vnode = getFirstComponentChild(this.$slots.default);\n var componentOptions = vnode && vnode.componentOptions;\n if (componentOptions) {\n // check pattern\n var name = getComponentName(componentOptions);\n if (name && (\n (this.include && !matches(this.include, name)) ||\n (this.exclude && matches(this.exclude, name))\n )) {\n return vnode\n }\n var key = vnode.key == null\n // same constructor may get registered as different local components\n // so cid alone is not enough (#3269)\n ? componentOptions.Ctor.cid + (componentOptions.tag ? (\"::\" + (componentOptions.tag)) : '')\n : vnode.key;\n if (this.cache[key]) {\n vnode.componentInstance = this.cache[key].componentInstance;\n } else {\n this.cache[key] = vnode;\n }\n vnode.data.keepAlive = true;\n }\n return vnode\n }\n};\n\nvar builtInComponents = {\n KeepAlive: KeepAlive\n};\n\n/* */\n\nfunction initGlobalAPI (Vue) {\n // config\n var configDef = {};\n configDef.get = function () { return config; };\n if (process.env.NODE_ENV !== 'production') {\n configDef.set = function () {\n warn(\n 'Do not replace the Vue.config object, set individual fields instead.'\n );\n };\n }\n Object.defineProperty(Vue, 'config', configDef);\n Vue.util = util;\n Vue.set = set$1;\n Vue.delete = del;\n Vue.nextTick = nextTick;\n\n Vue.options = Object.create(null);\n config._assetTypes.forEach(function (type) {\n Vue.options[type + 's'] = Object.create(null);\n });\n\n // this is used to identify the \"base\" constructor to extend all plain-object\n // components with in Weex's multi-instance scenarios.\n Vue.options._base = Vue;\n\n extend(Vue.options.components, builtInComponents);\n\n initUse(Vue);\n initMixin$1(Vue);\n initExtend(Vue);\n initAssetRegisters(Vue);\n}\n\ninitGlobalAPI(Vue$3);\n\nObject.defineProperty(Vue$3.prototype, '$isServer', {\n get: isServerRendering\n});\n\nVue$3.version = '2.1.10';\n\n/* */\n\n// attributes that should be using props for binding\nvar acceptValue = makeMap('input,textarea,option,select');\nvar mustUseProp = function (tag, type, attr) {\n return (\n (attr === 'value' && acceptValue(tag)) && type !== 'button' ||\n (attr === 'selected' && tag === 'option') ||\n (attr === 'checked' && tag === 'input') ||\n (attr === 'muted' && tag === 'video')\n )\n};\n\nvar isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');\n\nvar isBooleanAttr = makeMap(\n 'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +\n 'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +\n 'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +\n 'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +\n 'required,reversed,scoped,seamless,selected,sortable,translate,' +\n 'truespeed,typemustmatch,visible'\n);\n\nvar xlinkNS = 'http://www.w3.org/1999/xlink';\n\nvar isXlink = function (name) {\n return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'\n};\n\nvar getXlinkProp = function (name) {\n return isXlink(name) ? name.slice(6, name.length) : ''\n};\n\nvar isFalsyAttrValue = function (val) {\n return val == null || val === false\n};\n\n/* */\n\nfunction genClassForVnode (vnode) {\n var data = vnode.data;\n var parentNode = vnode;\n var childNode = vnode;\n while (childNode.componentInstance) {\n childNode = childNode.componentInstance._vnode;\n if (childNode.data) {\n data = mergeClassData(childNode.data, data);\n }\n }\n while ((parentNode = parentNode.parent)) {\n if (parentNode.data) {\n data = mergeClassData(data, parentNode.data);\n }\n }\n return genClassFromData(data)\n}\n\nfunction mergeClassData (child, parent) {\n return {\n staticClass: concat(child.staticClass, parent.staticClass),\n class: child.class\n ? [child.class, parent.class]\n : parent.class\n }\n}\n\nfunction genClassFromData (data) {\n var dynamicClass = data.class;\n var staticClass = data.staticClass;\n if (staticClass || dynamicClass) {\n return concat(staticClass, stringifyClass(dynamicClass))\n }\n /* istanbul ignore next */\n return ''\n}\n\nfunction concat (a, b) {\n return a ? b ? (a + ' ' + b) : a : (b || '')\n}\n\nfunction stringifyClass (value) {\n var res = '';\n if (!value) {\n return res\n }\n if (typeof value === 'string') {\n return value\n }\n if (Array.isArray(value)) {\n var stringified;\n for (var i = 0, l = value.length; i < l; i++) {\n if (value[i]) {\n if ((stringified = stringifyClass(value[i]))) {\n res += stringified + ' ';\n }\n }\n }\n return res.slice(0, -1)\n }\n if (isObject(value)) {\n for (var key in value) {\n if (value[key]) { res += key + ' '; }\n }\n return res.slice(0, -1)\n }\n /* istanbul ignore next */\n return res\n}\n\n/* */\n\nvar namespaceMap = {\n svg: 'http://www.w3.org/2000/svg',\n math: 'http://www.w3.org/1998/Math/MathML'\n};\n\nvar isHTMLTag = makeMap(\n 'html,body,base,head,link,meta,style,title,' +\n 'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +\n 'div,dd,dl,dt,figcaption,figure,hr,img,li,main,ol,p,pre,ul,' +\n 'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +\n 's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +\n 'embed,object,param,source,canvas,script,noscript,del,ins,' +\n 'caption,col,colgroup,table,thead,tbody,td,th,tr,' +\n 'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +\n 'output,progress,select,textarea,' +\n 'details,dialog,menu,menuitem,summary,' +\n 'content,element,shadow,template'\n);\n\n// this map is intentionally selective, only covering SVG elements that may\n// contain child elements.\nvar isSVG = makeMap(\n 'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,' +\n 'font-face,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +\n 'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',\n true\n);\n\nvar isPreTag = function (tag) { return tag === 'pre'; };\n\nvar isReservedTag = function (tag) {\n return isHTMLTag(tag) || isSVG(tag)\n};\n\nfunction getTagNamespace (tag) {\n if (isSVG(tag)) {\n return 'svg'\n }\n // basic support for MathML\n // note it doesn't support other MathML elements being component roots\n if (tag === 'math') {\n return 'math'\n }\n}\n\nvar unknownElementCache = Object.create(null);\nfunction isUnknownElement (tag) {\n /* istanbul ignore if */\n if (!inBrowser) {\n return true\n }\n if (isReservedTag(tag)) {\n return false\n }\n tag = tag.toLowerCase();\n /* istanbul ignore if */\n if (unknownElementCache[tag] != null) {\n return unknownElementCache[tag]\n }\n var el = document.createElement(tag);\n if (tag.indexOf('-') > -1) {\n // http://stackoverflow.com/a/28210364/1070244\n return (unknownElementCache[tag] = (\n el.constructor === window.HTMLUnknownElement ||\n el.constructor === window.HTMLElement\n ))\n } else {\n return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))\n }\n}\n\n/* */\n\n/**\n * Query an element selector if it's not an element already.\n */\nfunction query (el) {\n if (typeof el === 'string') {\n var selector = el;\n el = document.querySelector(el);\n if (!el) {\n process.env.NODE_ENV !== 'production' && warn(\n 'Cannot find element: ' + selector\n );\n return document.createElement('div')\n }\n }\n return el\n}\n\n/* */\n\nfunction createElement$1 (tagName, vnode) {\n var elm = document.createElement(tagName);\n if (tagName !== 'select') {\n return elm\n }\n if (vnode.data && vnode.data.attrs && 'multiple' in vnode.data.attrs) {\n elm.setAttribute('multiple', 'multiple');\n }\n return elm\n}\n\nfunction createElementNS (namespace, tagName) {\n return document.createElementNS(namespaceMap[namespace], tagName)\n}\n\nfunction createTextNode (text) {\n return document.createTextNode(text)\n}\n\nfunction createComment (text) {\n return document.createComment(text)\n}\n\nfunction insertBefore (parentNode, newNode, referenceNode) {\n parentNode.insertBefore(newNode, referenceNode);\n}\n\nfunction removeChild (node, child) {\n node.removeChild(child);\n}\n\nfunction appendChild (node, child) {\n node.appendChild(child);\n}\n\nfunction parentNode (node) {\n return node.parentNode\n}\n\nfunction nextSibling (node) {\n return node.nextSibling\n}\n\nfunction tagName (node) {\n return node.tagName\n}\n\nfunction setTextContent (node, text) {\n node.textContent = text;\n}\n\nfunction setAttribute (node, key, val) {\n node.setAttribute(key, val);\n}\n\n\nvar nodeOps = Object.freeze({\n\tcreateElement: createElement$1,\n\tcreateElementNS: createElementNS,\n\tcreateTextNode: createTextNode,\n\tcreateComment: createComment,\n\tinsertBefore: insertBefore,\n\tremoveChild: removeChild,\n\tappendChild: appendChild,\n\tparentNode: parentNode,\n\tnextSibling: nextSibling,\n\ttagName: tagName,\n\tsetTextContent: setTextContent,\n\tsetAttribute: setAttribute\n});\n\n/* */\n\nvar ref = {\n create: function create (_, vnode) {\n registerRef(vnode);\n },\n update: function update (oldVnode, vnode) {\n if (oldVnode.data.ref !== vnode.data.ref) {\n registerRef(oldVnode, true);\n registerRef(vnode);\n }\n },\n destroy: function destroy (vnode) {\n registerRef(vnode, true);\n }\n};\n\nfunction registerRef (vnode, isRemoval) {\n var key = vnode.data.ref;\n if (!key) { return }\n\n var vm = vnode.context;\n var ref = vnode.componentInstance || vnode.elm;\n var refs = vm.$refs;\n if (isRemoval) {\n if (Array.isArray(refs[key])) {\n remove$1(refs[key], ref);\n } else if (refs[key] === ref) {\n refs[key] = undefined;\n }\n } else {\n if (vnode.data.refInFor) {\n if (Array.isArray(refs[key]) && refs[key].indexOf(ref) < 0) {\n refs[key].push(ref);\n } else {\n refs[key] = [ref];\n }\n } else {\n refs[key] = ref;\n }\n }\n}\n\n/**\n * Virtual DOM patching algorithm based on Snabbdom by\n * Simon Friis Vindum (@paldepind)\n * Licensed under the MIT License\n * https://github.com/paldepind/snabbdom/blob/master/LICENSE\n *\n * modified by Evan You (@yyx990803)\n *\n\n/*\n * Not type-checking this because this file is perf-critical and the cost\n * of making flow understand it is not worth it.\n */\n\nvar emptyNode = new VNode('', {}, []);\n\nvar hooks$1 = ['create', 'activate', 'update', 'remove', 'destroy'];\n\nfunction isUndef (s) {\n return s == null\n}\n\nfunction isDef (s) {\n return s != null\n}\n\nfunction sameVnode (vnode1, vnode2) {\n return (\n vnode1.key === vnode2.key &&\n vnode1.tag === vnode2.tag &&\n vnode1.isComment === vnode2.isComment &&\n !vnode1.data === !vnode2.data\n )\n}\n\nfunction createKeyToOldIdx (children, beginIdx, endIdx) {\n var i, key;\n var map = {};\n for (i = beginIdx; i <= endIdx; ++i) {\n key = children[i].key;\n if (isDef(key)) { map[key] = i; }\n }\n return map\n}\n\nfunction createPatchFunction (backend) {\n var i, j;\n var cbs = {};\n\n var modules = backend.modules;\n var nodeOps = backend.nodeOps;\n\n for (i = 0; i < hooks$1.length; ++i) {\n cbs[hooks$1[i]] = [];\n for (j = 0; j < modules.length; ++j) {\n if (modules[j][hooks$1[i]] !== undefined) { cbs[hooks$1[i]].push(modules[j][hooks$1[i]]); }\n }\n }\n\n function emptyNodeAt (elm) {\n return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)\n }\n\n function createRmCb (childElm, listeners) {\n function remove$$1 () {\n if (--remove$$1.listeners === 0) {\n removeNode(childElm);\n }\n }\n remove$$1.listeners = listeners;\n return remove$$1\n }\n\n function removeNode (el) {\n var parent = nodeOps.parentNode(el);\n // element may have already been removed due to v-html / v-text\n if (parent) {\n nodeOps.removeChild(parent, el);\n }\n }\n\n var inPre = 0;\n function createElm (vnode, insertedVnodeQueue, parentElm, refElm, nested) {\n vnode.isRootInsert = !nested; // for transition enter check\n if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {\n return\n }\n\n var data = vnode.data;\n var children = vnode.children;\n var tag = vnode.tag;\n if (isDef(tag)) {\n if (process.env.NODE_ENV !== 'production') {\n if (data && data.pre) {\n inPre++;\n }\n if (\n !inPre &&\n !vnode.ns &&\n !(config.ignoredElements.length && config.ignoredElements.indexOf(tag) > -1) &&\n config.isUnknownElement(tag)\n ) {\n warn(\n 'Unknown custom element: <' + tag + '> - did you ' +\n 'register the component correctly? For recursive components, ' +\n 'make sure to provide the \"name\" option.',\n vnode.context\n );\n }\n }\n vnode.elm = vnode.ns\n ? nodeOps.createElementNS(vnode.ns, tag)\n : nodeOps.createElement(tag, vnode);\n setScope(vnode);\n\n /* istanbul ignore if */\n {\n createChildren(vnode, children, insertedVnodeQueue);\n if (isDef(data)) {\n invokeCreateHooks(vnode, insertedVnodeQueue);\n }\n insert(parentElm, vnode.elm, refElm);\n }\n\n if (process.env.NODE_ENV !== 'production' && data && data.pre) {\n inPre--;\n }\n } else if (vnode.isComment) {\n vnode.elm = nodeOps.createComment(vnode.text);\n insert(parentElm, vnode.elm, refElm);\n } else {\n vnode.elm = nodeOps.createTextNode(vnode.text);\n insert(parentElm, vnode.elm, refElm);\n }\n }\n\n function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {\n var i = vnode.data;\n if (isDef(i)) {\n var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;\n if (isDef(i = i.hook) && isDef(i = i.init)) {\n i(vnode, false /* hydrating */, parentElm, refElm);\n }\n // after calling the init hook, if the vnode is a child component\n // it should've created a child instance and mounted it. the child\n // component also has set the placeholder vnode's elm.\n // in that case we can just return the element and be done.\n if (isDef(vnode.componentInstance)) {\n initComponent(vnode, insertedVnodeQueue);\n if (isReactivated) {\n reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);\n }\n return true\n }\n }\n }\n\n function initComponent (vnode, insertedVnodeQueue) {\n if (vnode.data.pendingInsert) {\n insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);\n }\n vnode.elm = vnode.componentInstance.$el;\n if (isPatchable(vnode)) {\n invokeCreateHooks(vnode, insertedVnodeQueue);\n setScope(vnode);\n } else {\n // empty component root.\n // skip all element-related modules except for ref (#3455)\n registerRef(vnode);\n // make sure to invoke the insert hook\n insertedVnodeQueue.push(vnode);\n }\n }\n\n function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {\n var i;\n // hack for #4339: a reactivated component with inner transition\n // does not trigger because the inner node's created hooks are not called\n // again. It's not ideal to involve module-specific logic in here but\n // there doesn't seem to be a better way to do it.\n var innerNode = vnode;\n while (innerNode.componentInstance) {\n innerNode = innerNode.componentInstance._vnode;\n if (isDef(i = innerNode.data) && isDef(i = i.transition)) {\n for (i = 0; i < cbs.activate.length; ++i) {\n cbs.activate[i](emptyNode, innerNode);\n }\n insertedVnodeQueue.push(innerNode);\n break\n }\n }\n // unlike a newly created component,\n // a reactivated keep-alive component doesn't insert itself\n insert(parentElm, vnode.elm, refElm);\n }\n\n function insert (parent, elm, ref) {\n if (parent) {\n if (ref) {\n nodeOps.insertBefore(parent, elm, ref);\n } else {\n nodeOps.appendChild(parent, elm);\n }\n }\n }\n\n function createChildren (vnode, children, insertedVnodeQueue) {\n if (Array.isArray(children)) {\n for (var i = 0; i < children.length; ++i) {\n createElm(children[i], insertedVnodeQueue, vnode.elm, null, true);\n }\n } else if (isPrimitive(vnode.text)) {\n nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(vnode.text));\n }\n }\n\n function isPatchable (vnode) {\n while (vnode.componentInstance) {\n vnode = vnode.componentInstance._vnode;\n }\n return isDef(vnode.tag)\n }\n\n function invokeCreateHooks (vnode, insertedVnodeQueue) {\n for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {\n cbs.create[i$1](emptyNode, vnode);\n }\n i = vnode.data.hook; // Reuse variable\n if (isDef(i)) {\n if (i.create) { i.create(emptyNode, vnode); }\n if (i.insert) { insertedVnodeQueue.push(vnode); }\n }\n }\n\n // set scope id attribute for scoped CSS.\n // this is implemented as a special case to avoid the overhead\n // of going through the normal attribute patching process.\n function setScope (vnode) {\n var i;\n if (isDef(i = vnode.context) && isDef(i = i.$options._scopeId)) {\n nodeOps.setAttribute(vnode.elm, i, '');\n }\n if (isDef(i = activeInstance) &&\n i !== vnode.context &&\n isDef(i = i.$options._scopeId)) {\n nodeOps.setAttribute(vnode.elm, i, '');\n }\n }\n\n function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {\n for (; startIdx <= endIdx; ++startIdx) {\n createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm);\n }\n }\n\n function invokeDestroyHook (vnode) {\n var i, j;\n var data = vnode.data;\n if (isDef(data)) {\n if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }\n for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); }\n }\n if (isDef(i = vnode.children)) {\n for (j = 0; j < vnode.children.length; ++j) {\n invokeDestroyHook(vnode.children[j]);\n }\n }\n }\n\n function removeVnodes (parentElm, vnodes, startIdx, endIdx) {\n for (; startIdx <= endIdx; ++startIdx) {\n var ch = vnodes[startIdx];\n if (isDef(ch)) {\n if (isDef(ch.tag)) {\n removeAndInvokeRemoveHook(ch);\n invokeDestroyHook(ch);\n } else { // Text node\n removeNode(ch.elm);\n }\n }\n }\n }\n\n function removeAndInvokeRemoveHook (vnode, rm) {\n if (rm || isDef(vnode.data)) {\n var listeners = cbs.remove.length + 1;\n if (!rm) {\n // directly removing\n rm = createRmCb(vnode.elm, listeners);\n } else {\n // we have a recursively passed down rm callback\n // increase the listeners count\n rm.listeners += listeners;\n }\n // recursively invoke hooks on child component root node\n if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {\n removeAndInvokeRemoveHook(i, rm);\n }\n for (i = 0; i < cbs.remove.length; ++i) {\n cbs.remove[i](vnode, rm);\n }\n if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {\n i(vnode, rm);\n } else {\n rm();\n }\n } else {\n removeNode(vnode.elm);\n }\n }\n\n function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {\n var oldStartIdx = 0;\n var newStartIdx = 0;\n var oldEndIdx = oldCh.length - 1;\n var oldStartVnode = oldCh[0];\n var oldEndVnode = oldCh[oldEndIdx];\n var newEndIdx = newCh.length - 1;\n var newStartVnode = newCh[0];\n var newEndVnode = newCh[newEndIdx];\n var oldKeyToIdx, idxInOld, elmToMove, refElm;\n\n // removeOnly is a special flag used only by <transition-group>\n // to ensure removed elements stay in correct relative positions\n // during leaving transitions\n var canMove = !removeOnly;\n\n while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n if (isUndef(oldStartVnode)) {\n oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n } else if (isUndef(oldEndVnode)) {\n oldEndVnode = oldCh[--oldEndIdx];\n } else if (sameVnode(oldStartVnode, newStartVnode)) {\n patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);\n oldStartVnode = oldCh[++oldStartIdx];\n newStartVnode = newCh[++newStartIdx];\n } else if (sameVnode(oldEndVnode, newEndVnode)) {\n patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);\n oldEndVnode = oldCh[--oldEndIdx];\n newEndVnode = newCh[--newEndIdx];\n } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);\n canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));\n oldStartVnode = oldCh[++oldStartIdx];\n newEndVnode = newCh[--newEndIdx];\n } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);\n canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);\n oldEndVnode = oldCh[--oldEndIdx];\n newStartVnode = newCh[++newStartIdx];\n } else {\n if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }\n idxInOld = isDef(newStartVnode.key) ? oldKeyToIdx[newStartVnode.key] : null;\n if (isUndef(idxInOld)) { // New element\n createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);\n newStartVnode = newCh[++newStartIdx];\n } else {\n elmToMove = oldCh[idxInOld];\n /* istanbul ignore if */\n if (process.env.NODE_ENV !== 'production' && !elmToMove) {\n warn(\n 'It seems there are duplicate keys that is causing an update error. ' +\n 'Make sure each v-for item has a unique key.'\n );\n }\n if (sameVnode(elmToMove, newStartVnode)) {\n patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);\n oldCh[idxInOld] = undefined;\n canMove && nodeOps.insertBefore(parentElm, newStartVnode.elm, oldStartVnode.elm);\n newStartVnode = newCh[++newStartIdx];\n } else {\n // same key but different element. treat as new element\n createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);\n newStartVnode = newCh[++newStartIdx];\n }\n }\n }\n }\n if (oldStartIdx > oldEndIdx) {\n refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;\n addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);\n } else if (newStartIdx > newEndIdx) {\n removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n }\n }\n\n function patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly) {\n if (oldVnode === vnode) {\n return\n }\n // reuse element for static trees.\n // note we only do this if the vnode is cloned -\n // if the new node is not cloned it means the render functions have been\n // reset by the hot-reload-api and we need to do a proper re-render.\n if (vnode.isStatic &&\n oldVnode.isStatic &&\n vnode.key === oldVnode.key &&\n (vnode.isCloned || vnode.isOnce)) {\n vnode.elm = oldVnode.elm;\n vnode.componentInstance = oldVnode.componentInstance;\n return\n }\n var i;\n var data = vnode.data;\n var hasData = isDef(data);\n if (hasData && isDef(i = data.hook) && isDef(i = i.prepatch)) {\n i(oldVnode, vnode);\n }\n var elm = vnode.elm = oldVnode.elm;\n var oldCh = oldVnode.children;\n var ch = vnode.children;\n if (hasData && isPatchable(vnode)) {\n for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); }\n if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }\n }\n if (isUndef(vnode.text)) {\n if (isDef(oldCh) && isDef(ch)) {\n if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }\n } else if (isDef(ch)) {\n if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }\n addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);\n } else if (isDef(oldCh)) {\n removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n } else if (isDef(oldVnode.text)) {\n nodeOps.setTextContent(elm, '');\n }\n } else if (oldVnode.text !== vnode.text) {\n nodeOps.setTextContent(elm, vnode.text);\n }\n if (hasData) {\n if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); }\n }\n }\n\n function invokeInsertHook (vnode, queue, initial) {\n // delay insert hooks for component root nodes, invoke them after the\n // element is really inserted\n if (initial && vnode.parent) {\n vnode.parent.data.pendingInsert = queue;\n } else {\n for (var i = 0; i < queue.length; ++i) {\n queue[i].data.hook.insert(queue[i]);\n }\n }\n }\n\n var bailed = false;\n // list of modules that can skip create hook during hydration because they\n // are already rendered on the client or has no need for initialization\n var isRenderedModule = makeMap('attrs,style,class,staticClass,staticStyle,key');\n\n // Note: this is a browser-only function so we can assume elms are DOM nodes.\n function hydrate (elm, vnode, insertedVnodeQueue) {\n if (process.env.NODE_ENV !== 'production') {\n if (!assertNodeMatch(elm, vnode)) {\n return false\n }\n }\n vnode.elm = elm;\n var tag = vnode.tag;\n var data = vnode.data;\n var children = vnode.children;\n if (isDef(data)) {\n if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }\n if (isDef(i = vnode.componentInstance)) {\n // child component. it should have hydrated its own tree.\n initComponent(vnode, insertedVnodeQueue);\n return true\n }\n }\n if (isDef(tag)) {\n if (isDef(children)) {\n // empty element, allow client to pick up and populate children\n if (!elm.hasChildNodes()) {\n createChildren(vnode, children, insertedVnodeQueue);\n } else {\n var childrenMatch = true;\n var childNode = elm.firstChild;\n for (var i$1 = 0; i$1 < children.length; i$1++) {\n if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue)) {\n childrenMatch = false;\n break\n }\n childNode = childNode.nextSibling;\n }\n // if childNode is not null, it means the actual childNodes list is\n // longer than the virtual children list.\n if (!childrenMatch || childNode) {\n if (process.env.NODE_ENV !== 'production' &&\n typeof console !== 'undefined' &&\n !bailed) {\n bailed = true;\n console.warn('Parent: ', elm);\n console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);\n }\n return false\n }\n }\n }\n if (isDef(data)) {\n for (var key in data) {\n if (!isRenderedModule(key)) {\n invokeCreateHooks(vnode, insertedVnodeQueue);\n break\n }\n }\n }\n } else if (elm.data !== vnode.text) {\n elm.data = vnode.text;\n }\n return true\n }\n\n function assertNodeMatch (node, vnode) {\n if (vnode.tag) {\n return (\n vnode.tag.indexOf('vue-component') === 0 ||\n vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())\n )\n } else {\n return node.nodeType === (vnode.isComment ? 8 : 3)\n }\n }\n\n return function patch (oldVnode, vnode, hydrating, removeOnly, parentElm, refElm) {\n if (!vnode) {\n if (oldVnode) { invokeDestroyHook(oldVnode); }\n return\n }\n\n var isInitialPatch = false;\n var insertedVnodeQueue = [];\n\n if (!oldVnode) {\n // empty mount (likely as component), create new root element\n isInitialPatch = true;\n createElm(vnode, insertedVnodeQueue, parentElm, refElm);\n } else {\n var isRealElement = isDef(oldVnode.nodeType);\n if (!isRealElement && sameVnode(oldVnode, vnode)) {\n // patch existing root node\n patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly);\n } else {\n if (isRealElement) {\n // mounting to a real element\n // check if this is server-rendered content and if we can perform\n // a successful hydration.\n if (oldVnode.nodeType === 1 && oldVnode.hasAttribute('server-rendered')) {\n oldVnode.removeAttribute('server-rendered');\n hydrating = true;\n }\n if (hydrating) {\n if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {\n invokeInsertHook(vnode, insertedVnodeQueue, true);\n return oldVnode\n } else if (process.env.NODE_ENV !== 'production') {\n warn(\n 'The client-side rendered virtual DOM tree is not matching ' +\n 'server-rendered content. This is likely caused by incorrect ' +\n 'HTML markup, for example nesting block-level elements inside ' +\n '<p>, or missing <tbody>. Bailing hydration and performing ' +\n 'full client-side render.'\n );\n }\n }\n // either not server-rendered, or hydration failed.\n // create an empty node and replace it\n oldVnode = emptyNodeAt(oldVnode);\n }\n // replacing existing element\n var oldElm = oldVnode.elm;\n var parentElm$1 = nodeOps.parentNode(oldElm);\n createElm(\n vnode,\n insertedVnodeQueue,\n // extremely rare edge case: do not insert if old element is in a\n // leaving transition. Only happens when combining transition +\n // keep-alive + HOCs. (#4590)\n oldElm._leaveCb ? null : parentElm$1,\n nodeOps.nextSibling(oldElm)\n );\n\n if (vnode.parent) {\n // component root element replaced.\n // update parent placeholder node element, recursively\n var ancestor = vnode.parent;\n while (ancestor) {\n ancestor.elm = vnode.elm;\n ancestor = ancestor.parent;\n }\n if (isPatchable(vnode)) {\n for (var i = 0; i < cbs.create.length; ++i) {\n cbs.create[i](emptyNode, vnode.parent);\n }\n }\n }\n\n if (parentElm$1 !== null) {\n removeVnodes(parentElm$1, [oldVnode], 0, 0);\n } else if (isDef(oldVnode.tag)) {\n invokeDestroyHook(oldVnode);\n }\n }\n }\n\n invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);\n return vnode.elm\n }\n}\n\n/* */\n\nvar directives = {\n create: updateDirectives,\n update: updateDirectives,\n destroy: function unbindDirectives (vnode) {\n updateDirectives(vnode, emptyNode);\n }\n};\n\nfunction updateDirectives (oldVnode, vnode) {\n if (oldVnode.data.directives || vnode.data.directives) {\n _update(oldVnode, vnode);\n }\n}\n\nfunction _update (oldVnode, vnode) {\n var isCreate = oldVnode === emptyNode;\n var isDestroy = vnode === emptyNode;\n var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);\n var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);\n\n var dirsWithInsert = [];\n var dirsWithPostpatch = [];\n\n var key, oldDir, dir;\n for (key in newDirs) {\n oldDir = oldDirs[key];\n dir = newDirs[key];\n if (!oldDir) {\n // new directive, bind\n callHook$1(dir, 'bind', vnode, oldVnode);\n if (dir.def && dir.def.inserted) {\n dirsWithInsert.push(dir);\n }\n } else {\n // existing directive, update\n dir.oldValue = oldDir.value;\n callHook$1(dir, 'update', vnode, oldVnode);\n if (dir.def && dir.def.componentUpdated) {\n dirsWithPostpatch.push(dir);\n }\n }\n }\n\n if (dirsWithInsert.length) {\n var callInsert = function () {\n for (var i = 0; i < dirsWithInsert.length; i++) {\n callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);\n }\n };\n if (isCreate) {\n mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', callInsert, 'dir-insert');\n } else {\n callInsert();\n }\n }\n\n if (dirsWithPostpatch.length) {\n mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'postpatch', function () {\n for (var i = 0; i < dirsWithPostpatch.length; i++) {\n callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);\n }\n }, 'dir-postpatch');\n }\n\n if (!isCreate) {\n for (key in oldDirs) {\n if (!newDirs[key]) {\n // no longer present, unbind\n callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);\n }\n }\n }\n}\n\nvar emptyModifiers = Object.create(null);\n\nfunction normalizeDirectives$1 (\n dirs,\n vm\n) {\n var res = Object.create(null);\n if (!dirs) {\n return res\n }\n var i, dir;\n for (i = 0; i < dirs.length; i++) {\n dir = dirs[i];\n if (!dir.modifiers) {\n dir.modifiers = emptyModifiers;\n }\n res[getRawDirName(dir)] = dir;\n dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);\n }\n return res\n}\n\nfunction getRawDirName (dir) {\n return dir.rawName || ((dir.name) + \".\" + (Object.keys(dir.modifiers || {}).join('.')))\n}\n\nfunction callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {\n var fn = dir.def && dir.def[hook];\n if (fn) {\n fn(vnode.elm, dir, vnode, oldVnode, isDestroy);\n }\n}\n\nvar baseModules = [\n ref,\n directives\n];\n\n/* */\n\nfunction updateAttrs (oldVnode, vnode) {\n if (!oldVnode.data.attrs && !vnode.data.attrs) {\n return\n }\n var key, cur, old;\n var elm = vnode.elm;\n var oldAttrs = oldVnode.data.attrs || {};\n var attrs = vnode.data.attrs || {};\n // clone observed objects, as the user probably wants to mutate it\n if (attrs.__ob__) {\n attrs = vnode.data.attrs = extend({}, attrs);\n }\n\n for (key in attrs) {\n cur = attrs[key];\n old = oldAttrs[key];\n if (old !== cur) {\n setAttr(elm, key, cur);\n }\n }\n // #4391: in IE9, setting type can reset value for input[type=radio]\n /* istanbul ignore if */\n if (isIE9 && attrs.value !== oldAttrs.value) {\n setAttr(elm, 'value', attrs.value);\n }\n for (key in oldAttrs) {\n if (attrs[key] == null) {\n if (isXlink(key)) {\n elm.removeAttributeNS(xlinkNS, getXlinkProp(key));\n } else if (!isEnumeratedAttr(key)) {\n elm.removeAttribute(key);\n }\n }\n }\n}\n\nfunction setAttr (el, key, value) {\n if (isBooleanAttr(key)) {\n // set attribute for blank value\n // e.g. <option disabled>Select one</option>\n if (isFalsyAttrValue(value)) {\n el.removeAttribute(key);\n } else {\n el.setAttribute(key, key);\n }\n } else if (isEnumeratedAttr(key)) {\n el.setAttribute(key, isFalsyAttrValue(value) || value === 'false' ? 'false' : 'true');\n } else if (isXlink(key)) {\n if (isFalsyAttrValue(value)) {\n el.removeAttributeNS(xlinkNS, getXlinkProp(key));\n } else {\n el.setAttributeNS(xlinkNS, key, value);\n }\n } else {\n if (isFalsyAttrValue(value)) {\n el.removeAttribute(key);\n } else {\n el.setAttribute(key, value);\n }\n }\n}\n\nvar attrs = {\n create: updateAttrs,\n update: updateAttrs\n};\n\n/* */\n\nfunction updateClass (oldVnode, vnode) {\n var el = vnode.elm;\n var data = vnode.data;\n var oldData = oldVnode.data;\n if (!data.staticClass && !data.class &&\n (!oldData || (!oldData.staticClass && !oldData.class))) {\n return\n }\n\n var cls = genClassForVnode(vnode);\n\n // handle transition classes\n var transitionClass = el._transitionClasses;\n if (transitionClass) {\n cls = concat(cls, stringifyClass(transitionClass));\n }\n\n // set the class\n if (cls !== el._prevClass) {\n el.setAttribute('class', cls);\n el._prevClass = cls;\n }\n}\n\nvar klass = {\n create: updateClass,\n update: updateClass\n};\n\n/* */\n\nvar target$1;\n\nfunction add$2 (\n event,\n handler,\n once,\n capture\n) {\n if (once) {\n var oldHandler = handler;\n var _target = target$1; // save current target element in closure\n handler = function (ev) {\n remove$3(event, handler, capture, _target);\n arguments.length === 1\n ? oldHandler(ev)\n : oldHandler.apply(null, arguments);\n };\n }\n target$1.addEventListener(event, handler, capture);\n}\n\nfunction remove$3 (\n event,\n handler,\n capture,\n _target\n) {\n (_target || target$1).removeEventListener(event, handler, capture);\n}\n\nfunction updateDOMListeners (oldVnode, vnode) {\n if (!oldVnode.data.on && !vnode.data.on) {\n return\n }\n var on = vnode.data.on || {};\n var oldOn = oldVnode.data.on || {};\n target$1 = vnode.elm;\n updateListeners(on, oldOn, add$2, remove$3, vnode.context);\n}\n\nvar events = {\n create: updateDOMListeners,\n update: updateDOMListeners\n};\n\n/* */\n\nfunction updateDOMProps (oldVnode, vnode) {\n if (!oldVnode.data.domProps && !vnode.data.domProps) {\n return\n }\n var key, cur;\n var elm = vnode.elm;\n var oldProps = oldVnode.data.domProps || {};\n var props = vnode.data.domProps || {};\n // clone observed objects, as the user probably wants to mutate it\n if (props.__ob__) {\n props = vnode.data.domProps = extend({}, props);\n }\n\n for (key in oldProps) {\n if (props[key] == null) {\n elm[key] = '';\n }\n }\n for (key in props) {\n cur = props[key];\n // ignore children if the node has textContent or innerHTML,\n // as these will throw away existing DOM nodes and cause removal errors\n // on subsequent patches (#3360)\n if (key === 'textContent' || key === 'innerHTML') {\n if (vnode.children) { vnode.children.length = 0; }\n if (cur === oldProps[key]) { continue }\n }\n\n if (key === 'value') {\n // store value as _value as well since\n // non-string values will be stringified\n elm._value = cur;\n // avoid resetting cursor position when value is the same\n var strCur = cur == null ? '' : String(cur);\n if (shouldUpdateValue(elm, vnode, strCur)) {\n elm.value = strCur;\n }\n } else {\n elm[key] = cur;\n }\n }\n}\n\n// check platforms/web/util/attrs.js acceptValue\n\n\nfunction shouldUpdateValue (\n elm,\n vnode,\n checkVal\n) {\n return (!elm.composing && (\n vnode.tag === 'option' ||\n isDirty(elm, checkVal) ||\n isInputChanged(vnode, checkVal)\n ))\n}\n\nfunction isDirty (elm, checkVal) {\n // return true when textbox (.number and .trim) loses focus and its value is not equal to the updated value\n return document.activeElement !== elm && elm.value !== checkVal\n}\n\nfunction isInputChanged (vnode, newVal) {\n var value = vnode.elm.value;\n var modifiers = vnode.elm._vModifiers; // injected by v-model runtime\n if ((modifiers && modifiers.number) || vnode.elm.type === 'number') {\n return toNumber(value) !== toNumber(newVal)\n }\n if (modifiers && modifiers.trim) {\n return value.trim() !== newVal.trim()\n }\n return value !== newVal\n}\n\nvar domProps = {\n create: updateDOMProps,\n update: updateDOMProps\n};\n\n/* */\n\nvar parseStyleText = cached(function (cssText) {\n var res = {};\n var listDelimiter = /;(?![^(]*\\))/g;\n var propertyDelimiter = /:(.+)/;\n cssText.split(listDelimiter).forEach(function (item) {\n if (item) {\n var tmp = item.split(propertyDelimiter);\n tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());\n }\n });\n return res\n});\n\n// merge static and dynamic style data on the same vnode\nfunction normalizeStyleData (data) {\n var style = normalizeStyleBinding(data.style);\n // static style is pre-processed into an object during compilation\n // and is always a fresh object, so it's safe to merge into it\n return data.staticStyle\n ? extend(data.staticStyle, style)\n : style\n}\n\n// normalize possible array / string values into Object\nfunction normalizeStyleBinding (bindingStyle) {\n if (Array.isArray(bindingStyle)) {\n return toObject(bindingStyle)\n }\n if (typeof bindingStyle === 'string') {\n return parseStyleText(bindingStyle)\n }\n return bindingStyle\n}\n\n/**\n * parent component style should be after child's\n * so that parent component's style could override it\n */\nfunction getStyle (vnode, checkChild) {\n var res = {};\n var styleData;\n\n if (checkChild) {\n var childNode = vnode;\n while (childNode.componentInstance) {\n childNode = childNode.componentInstance._vnode;\n if (childNode.data && (styleData = normalizeStyleData(childNode.data))) {\n extend(res, styleData);\n }\n }\n }\n\n if ((styleData = normalizeStyleData(vnode.data))) {\n extend(res, styleData);\n }\n\n var parentNode = vnode;\n while ((parentNode = parentNode.parent)) {\n if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {\n extend(res, styleData);\n }\n }\n return res\n}\n\n/* */\n\nvar cssVarRE = /^--/;\nvar importantRE = /\\s*!important$/;\nvar setProp = function (el, name, val) {\n /* istanbul ignore if */\n if (cssVarRE.test(name)) {\n el.style.setProperty(name, val);\n } else if (importantRE.test(val)) {\n el.style.setProperty(name, val.replace(importantRE, ''), 'important');\n } else {\n el.style[normalize(name)] = val;\n }\n};\n\nvar prefixes = ['Webkit', 'Moz', 'ms'];\n\nvar testEl;\nvar normalize = cached(function (prop) {\n testEl = testEl || document.createElement('div');\n prop = camelize(prop);\n if (prop !== 'filter' && (prop in testEl.style)) {\n return prop\n }\n var upper = prop.charAt(0).toUpperCase() + prop.slice(1);\n for (var i = 0; i < prefixes.length; i++) {\n var prefixed = prefixes[i] + upper;\n if (prefixed in testEl.style) {\n return prefixed\n }\n }\n});\n\nfunction updateStyle (oldVnode, vnode) {\n var data = vnode.data;\n var oldData = oldVnode.data;\n\n if (!data.staticStyle && !data.style &&\n !oldData.staticStyle && !oldData.style) {\n return\n }\n\n var cur, name;\n var el = vnode.elm;\n var oldStaticStyle = oldVnode.data.staticStyle;\n var oldStyleBinding = oldVnode.data.style || {};\n\n // if static style exists, stylebinding already merged into it when doing normalizeStyleData\n var oldStyle = oldStaticStyle || oldStyleBinding;\n\n var style = normalizeStyleBinding(vnode.data.style) || {};\n\n vnode.data.style = style.__ob__ ? extend({}, style) : style;\n\n var newStyle = getStyle(vnode, true);\n\n for (name in oldStyle) {\n if (newStyle[name] == null) {\n setProp(el, name, '');\n }\n }\n for (name in newStyle) {\n cur = newStyle[name];\n if (cur !== oldStyle[name]) {\n // ie9 setting to null has no effect, must use empty string\n setProp(el, name, cur == null ? '' : cur);\n }\n }\n}\n\nvar style = {\n create: updateStyle,\n update: updateStyle\n};\n\n/* */\n\n/**\n * Add class with compatibility for SVG since classList is not supported on\n * SVG elements in IE\n */\nfunction addClass (el, cls) {\n /* istanbul ignore if */\n if (!cls || !cls.trim()) {\n return\n }\n\n /* istanbul ignore else */\n if (el.classList) {\n if (cls.indexOf(' ') > -1) {\n cls.split(/\\s+/).forEach(function (c) { return el.classList.add(c); });\n } else {\n el.classList.add(cls);\n }\n } else {\n var cur = ' ' + el.getAttribute('class') + ' ';\n if (cur.indexOf(' ' + cls + ' ') < 0) {\n el.setAttribute('class', (cur + cls).trim());\n }\n }\n}\n\n/**\n * Remove class with compatibility for SVG since classList is not supported on\n * SVG elements in IE\n */\nfunction removeClass (el, cls) {\n /* istanbul ignore if */\n if (!cls || !cls.trim()) {\n return\n }\n\n /* istanbul ignore else */\n if (el.classList) {\n if (cls.indexOf(' ') > -1) {\n cls.split(/\\s+/).forEach(function (c) { return el.classList.remove(c); });\n } else {\n el.classList.remove(cls);\n }\n } else {\n var cur = ' ' + el.getAttribute('class') + ' ';\n var tar = ' ' + cls + ' ';\n while (cur.indexOf(tar) >= 0) {\n cur = cur.replace(tar, ' ');\n }\n el.setAttribute('class', cur.trim());\n }\n}\n\n/* */\n\nvar hasTransition = inBrowser && !isIE9;\nvar TRANSITION = 'transition';\nvar ANIMATION = 'animation';\n\n// Transition property/event sniffing\nvar transitionProp = 'transition';\nvar transitionEndEvent = 'transitionend';\nvar animationProp = 'animation';\nvar animationEndEvent = 'animationend';\nif (hasTransition) {\n /* istanbul ignore if */\n if (window.ontransitionend === undefined &&\n window.onwebkittransitionend !== undefined) {\n transitionProp = 'WebkitTransition';\n transitionEndEvent = 'webkitTransitionEnd';\n }\n if (window.onanimationend === undefined &&\n window.onwebkitanimationend !== undefined) {\n animationProp = 'WebkitAnimation';\n animationEndEvent = 'webkitAnimationEnd';\n }\n}\n\n// binding to window is necessary to make hot reload work in IE in strict mode\nvar raf = inBrowser && window.requestAnimationFrame\n ? window.requestAnimationFrame.bind(window)\n : setTimeout;\n\nfunction nextFrame (fn) {\n raf(function () {\n raf(fn);\n });\n}\n\nfunction addTransitionClass (el, cls) {\n (el._transitionClasses || (el._transitionClasses = [])).push(cls);\n addClass(el, cls);\n}\n\nfunction removeTransitionClass (el, cls) {\n if (el._transitionClasses) {\n remove$1(el._transitionClasses, cls);\n }\n removeClass(el, cls);\n}\n\nfunction whenTransitionEnds (\n el,\n expectedType,\n cb\n) {\n var ref = getTransitionInfo(el, expectedType);\n var type = ref.type;\n var timeout = ref.timeout;\n var propCount = ref.propCount;\n if (!type) { return cb() }\n var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;\n var ended = 0;\n var end = function () {\n el.removeEventListener(event, onEnd);\n cb();\n };\n var onEnd = function (e) {\n if (e.target === el) {\n if (++ended >= propCount) {\n end();\n }\n }\n };\n setTimeout(function () {\n if (ended < propCount) {\n end();\n }\n }, timeout + 1);\n el.addEventListener(event, onEnd);\n}\n\nvar transformRE = /\\b(transform|all)(,|$)/;\n\nfunction getTransitionInfo (el, expectedType) {\n var styles = window.getComputedStyle(el);\n var transitioneDelays = styles[transitionProp + 'Delay'].split(', ');\n var transitionDurations = styles[transitionProp + 'Duration'].split(', ');\n var transitionTimeout = getTimeout(transitioneDelays, transitionDurations);\n var animationDelays = styles[animationProp + 'Delay'].split(', ');\n var animationDurations = styles[animationProp + 'Duration'].split(', ');\n var animationTimeout = getTimeout(animationDelays, animationDurations);\n\n var type;\n var timeout = 0;\n var propCount = 0;\n /* istanbul ignore if */\n if (expectedType === TRANSITION) {\n if (transitionTimeout > 0) {\n type = TRANSITION;\n timeout = transitionTimeout;\n propCount = transitionDurations.length;\n }\n } else if (expectedType === ANIMATION) {\n if (animationTimeout > 0) {\n type = ANIMATION;\n timeout = animationTimeout;\n propCount = animationDurations.length;\n }\n } else {\n timeout = Math.max(transitionTimeout, animationTimeout);\n type = timeout > 0\n ? transitionTimeout > animationTimeout\n ? TRANSITION\n : ANIMATION\n : null;\n propCount = type\n ? type === TRANSITION\n ? transitionDurations.length\n : animationDurations.length\n : 0;\n }\n var hasTransform =\n type === TRANSITION &&\n transformRE.test(styles[transitionProp + 'Property']);\n return {\n type: type,\n timeout: timeout,\n propCount: propCount,\n hasTransform: hasTransform\n }\n}\n\nfunction getTimeout (delays, durations) {\n /* istanbul ignore next */\n while (delays.length < durations.length) {\n delays = delays.concat(delays);\n }\n\n return Math.max.apply(null, durations.map(function (d, i) {\n return toMs(d) + toMs(delays[i])\n }))\n}\n\nfunction toMs (s) {\n return Number(s.slice(0, -1)) * 1000\n}\n\n/* */\n\nfunction enter (vnode, toggleDisplay) {\n var el = vnode.elm;\n\n // call leave callback now\n if (el._leaveCb) {\n el._leaveCb.cancelled = true;\n el._leaveCb();\n }\n\n var data = resolveTransition(vnode.data.transition);\n if (!data) {\n return\n }\n\n /* istanbul ignore if */\n if (el._enterCb || el.nodeType !== 1) {\n return\n }\n\n var css = data.css;\n var type = data.type;\n var enterClass = data.enterClass;\n var enterToClass = data.enterToClass;\n var enterActiveClass = data.enterActiveClass;\n var appearClass = data.appearClass;\n var appearToClass = data.appearToClass;\n var appearActiveClass = data.appearActiveClass;\n var beforeEnter = data.beforeEnter;\n var enter = data.enter;\n var afterEnter = data.afterEnter;\n var enterCancelled = data.enterCancelled;\n var beforeAppear = data.beforeAppear;\n var appear = data.appear;\n var afterAppear = data.afterAppear;\n var appearCancelled = data.appearCancelled;\n\n // activeInstance will always be the <transition> component managing this\n // transition. One edge case to check is when the <transition> is placed\n // as the root node of a child component. In that case we need to check\n // <transition>'s parent for appear check.\n var context = activeInstance;\n var transitionNode = activeInstance.$vnode;\n while (transitionNode && transitionNode.parent) {\n transitionNode = transitionNode.parent;\n context = transitionNode.context;\n }\n\n var isAppear = !context._isMounted || !vnode.isRootInsert;\n\n if (isAppear && !appear && appear !== '') {\n return\n }\n\n var startClass = isAppear ? appearClass : enterClass;\n var activeClass = isAppear ? appearActiveClass : enterActiveClass;\n var toClass = isAppear ? appearToClass : enterToClass;\n var beforeEnterHook = isAppear ? (beforeAppear || beforeEnter) : beforeEnter;\n var enterHook = isAppear ? (typeof appear === 'function' ? appear : enter) : enter;\n var afterEnterHook = isAppear ? (afterAppear || afterEnter) : afterEnter;\n var enterCancelledHook = isAppear ? (appearCancelled || enterCancelled) : enterCancelled;\n\n var expectsCSS = css !== false && !isIE9;\n var userWantsControl =\n enterHook &&\n // enterHook may be a bound method which exposes\n // the length of original fn as _length\n (enterHook._length || enterHook.length) > 1;\n\n var cb = el._enterCb = once(function () {\n if (expectsCSS) {\n removeTransitionClass(el, toClass);\n removeTransitionClass(el, activeClass);\n }\n if (cb.cancelled) {\n if (expectsCSS) {\n removeTransitionClass(el, startClass);\n }\n enterCancelledHook && enterCancelledHook(el);\n } else {\n afterEnterHook && afterEnterHook(el);\n }\n el._enterCb = null;\n });\n\n if (!vnode.data.show) {\n // remove pending leave element on enter by injecting an insert hook\n mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', function () {\n var parent = el.parentNode;\n var pendingNode = parent && parent._pending && parent._pending[vnode.key];\n if (pendingNode &&\n pendingNode.tag === vnode.tag &&\n pendingNode.elm._leaveCb) {\n pendingNode.elm._leaveCb();\n }\n enterHook && enterHook(el, cb);\n }, 'transition-insert');\n }\n\n // start enter transition\n beforeEnterHook && beforeEnterHook(el);\n if (expectsCSS) {\n addTransitionClass(el, startClass);\n addTransitionClass(el, activeClass);\n nextFrame(function () {\n addTransitionClass(el, toClass);\n removeTransitionClass(el, startClass);\n if (!cb.cancelled && !userWantsControl) {\n whenTransitionEnds(el, type, cb);\n }\n });\n }\n\n if (vnode.data.show) {\n toggleDisplay && toggleDisplay();\n enterHook && enterHook(el, cb);\n }\n\n if (!expectsCSS && !userWantsControl) {\n cb();\n }\n}\n\nfunction leave (vnode, rm) {\n var el = vnode.elm;\n\n // call enter callback now\n if (el._enterCb) {\n el._enterCb.cancelled = true;\n el._enterCb();\n }\n\n var data = resolveTransition(vnode.data.transition);\n if (!data) {\n return rm()\n }\n\n /* istanbul ignore if */\n if (el._leaveCb || el.nodeType !== 1) {\n return\n }\n\n var css = data.css;\n var type = data.type;\n var leaveClass = data.leaveClass;\n var leaveToClass = data.leaveToClass;\n var leaveActiveClass = data.leaveActiveClass;\n var beforeLeave = data.beforeLeave;\n var leave = data.leave;\n var afterLeave = data.afterLeave;\n var leaveCancelled = data.leaveCancelled;\n var delayLeave = data.delayLeave;\n\n var expectsCSS = css !== false && !isIE9;\n var userWantsControl =\n leave &&\n // leave hook may be a bound method which exposes\n // the length of original fn as _length\n (leave._length || leave.length) > 1;\n\n var cb = el._leaveCb = once(function () {\n if (el.parentNode && el.parentNode._pending) {\n el.parentNode._pending[vnode.key] = null;\n }\n if (expectsCSS) {\n removeTransitionClass(el, leaveToClass);\n removeTransitionClass(el, leaveActiveClass);\n }\n if (cb.cancelled) {\n if (expectsCSS) {\n removeTransitionClass(el, leaveClass);\n }\n leaveCancelled && leaveCancelled(el);\n } else {\n rm();\n afterLeave && afterLeave(el);\n }\n el._leaveCb = null;\n });\n\n if (delayLeave) {\n delayLeave(performLeave);\n } else {\n performLeave();\n }\n\n function performLeave () {\n // the delayed leave may have already been cancelled\n if (cb.cancelled) {\n return\n }\n // record leaving element\n if (!vnode.data.show) {\n (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;\n }\n beforeLeave && beforeLeave(el);\n if (expectsCSS) {\n addTransitionClass(el, leaveClass);\n addTransitionClass(el, leaveActiveClass);\n nextFrame(function () {\n addTransitionClass(el, leaveToClass);\n removeTransitionClass(el, leaveClass);\n if (!cb.cancelled && !userWantsControl) {\n whenTransitionEnds(el, type, cb);\n }\n });\n }\n leave && leave(el, cb);\n if (!expectsCSS && !userWantsControl) {\n cb();\n }\n }\n}\n\nfunction resolveTransition (def$$1) {\n if (!def$$1) {\n return\n }\n /* istanbul ignore else */\n if (typeof def$$1 === 'object') {\n var res = {};\n if (def$$1.css !== false) {\n extend(res, autoCssTransition(def$$1.name || 'v'));\n }\n extend(res, def$$1);\n return res\n } else if (typeof def$$1 === 'string') {\n return autoCssTransition(def$$1)\n }\n}\n\nvar autoCssTransition = cached(function (name) {\n return {\n enterClass: (name + \"-enter\"),\n leaveClass: (name + \"-leave\"),\n appearClass: (name + \"-enter\"),\n enterToClass: (name + \"-enter-to\"),\n leaveToClass: (name + \"-leave-to\"),\n appearToClass: (name + \"-enter-to\"),\n enterActiveClass: (name + \"-enter-active\"),\n leaveActiveClass: (name + \"-leave-active\"),\n appearActiveClass: (name + \"-enter-active\")\n }\n});\n\nfunction once (fn) {\n var called = false;\n return function () {\n if (!called) {\n called = true;\n fn();\n }\n }\n}\n\nfunction _enter (_, vnode) {\n if (!vnode.data.show) {\n enter(vnode);\n }\n}\n\nvar transition = inBrowser ? {\n create: _enter,\n activate: _enter,\n remove: function remove (vnode, rm) {\n /* istanbul ignore else */\n if (!vnode.data.show) {\n leave(vnode, rm);\n } else {\n rm();\n }\n }\n} : {};\n\nvar platformModules = [\n attrs,\n klass,\n events,\n domProps,\n style,\n transition\n];\n\n/* */\n\n// the directive module should be applied last, after all\n// built-in modules have been applied.\nvar modules = platformModules.concat(baseModules);\n\nvar patch$1 = createPatchFunction({ nodeOps: nodeOps, modules: modules });\n\n/**\n * Not type checking this file because flow doesn't like attaching\n * properties to Elements.\n */\n\nvar modelableTagRE = /^input|select|textarea|vue-component-[0-9]+(-[0-9a-zA-Z_-]*)?$/;\n\n/* istanbul ignore if */\nif (isIE9) {\n // http://www.matts411.com/post/internet-explorer-9-oninput/\n document.addEventListener('selectionchange', function () {\n var el = document.activeElement;\n if (el && el.vmodel) {\n trigger(el, 'input');\n }\n });\n}\n\nvar model = {\n inserted: function inserted (el, binding, vnode) {\n if (process.env.NODE_ENV !== 'production') {\n if (!modelableTagRE.test(vnode.tag)) {\n warn(\n \"v-model is not supported on element type: <\" + (vnode.tag) + \">. \" +\n 'If you are working with contenteditable, it\\'s recommended to ' +\n 'wrap a library dedicated for that purpose inside a custom component.',\n vnode.context\n );\n }\n }\n if (vnode.tag === 'select') {\n var cb = function () {\n setSelected(el, binding, vnode.context);\n };\n cb();\n /* istanbul ignore if */\n if (isIE || isEdge) {\n setTimeout(cb, 0);\n }\n } else if (vnode.tag === 'textarea' || el.type === 'text') {\n el._vModifiers = binding.modifiers;\n if (!binding.modifiers.lazy) {\n if (!isAndroid) {\n el.addEventListener('compositionstart', onCompositionStart);\n el.addEventListener('compositionend', onCompositionEnd);\n }\n /* istanbul ignore if */\n if (isIE9) {\n el.vmodel = true;\n }\n }\n }\n },\n componentUpdated: function componentUpdated (el, binding, vnode) {\n if (vnode.tag === 'select') {\n setSelected(el, binding, vnode.context);\n // in case the options rendered by v-for have changed,\n // it's possible that the value is out-of-sync with the rendered options.\n // detect such cases and filter out values that no longer has a matching\n // option in the DOM.\n var needReset = el.multiple\n ? binding.value.some(function (v) { return hasNoMatchingOption(v, el.options); })\n : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, el.options);\n if (needReset) {\n trigger(el, 'change');\n }\n }\n }\n};\n\nfunction setSelected (el, binding, vm) {\n var value = binding.value;\n var isMultiple = el.multiple;\n if (isMultiple && !Array.isArray(value)) {\n process.env.NODE_ENV !== 'production' && warn(\n \"<select multiple v-model=\\\"\" + (binding.expression) + \"\\\"> \" +\n \"expects an Array value for its binding, but got \" + (Object.prototype.toString.call(value).slice(8, -1)),\n vm\n );\n return\n }\n var selected, option;\n for (var i = 0, l = el.options.length; i < l; i++) {\n option = el.options[i];\n if (isMultiple) {\n selected = looseIndexOf(value, getValue(option)) > -1;\n if (option.selected !== selected) {\n option.selected = selected;\n }\n } else {\n if (looseEqual(getValue(option), value)) {\n if (el.selectedIndex !== i) {\n el.selectedIndex = i;\n }\n return\n }\n }\n }\n if (!isMultiple) {\n el.selectedIndex = -1;\n }\n}\n\nfunction hasNoMatchingOption (value, options) {\n for (var i = 0, l = options.length; i < l; i++) {\n if (looseEqual(getValue(options[i]), value)) {\n return false\n }\n }\n return true\n}\n\nfunction getValue (option) {\n return '_value' in option\n ? option._value\n : option.value\n}\n\nfunction onCompositionStart (e) {\n e.target.composing = true;\n}\n\nfunction onCompositionEnd (e) {\n e.target.composing = false;\n trigger(e.target, 'input');\n}\n\nfunction trigger (el, type) {\n var e = document.createEvent('HTMLEvents');\n e.initEvent(type, true, true);\n el.dispatchEvent(e);\n}\n\n/* */\n\n// recursively search for possible transition defined inside the component root\nfunction locateNode (vnode) {\n return vnode.componentInstance && (!vnode.data || !vnode.data.transition)\n ? locateNode(vnode.componentInstance._vnode)\n : vnode\n}\n\nvar show = {\n bind: function bind (el, ref, vnode) {\n var value = ref.value;\n\n vnode = locateNode(vnode);\n var transition = vnode.data && vnode.data.transition;\n var originalDisplay = el.__vOriginalDisplay =\n el.style.display === 'none' ? '' : el.style.display;\n if (value && transition && !isIE9) {\n vnode.data.show = true;\n enter(vnode, function () {\n el.style.display = originalDisplay;\n });\n } else {\n el.style.display = value ? originalDisplay : 'none';\n }\n },\n\n update: function update (el, ref, vnode) {\n var value = ref.value;\n var oldValue = ref.oldValue;\n\n /* istanbul ignore if */\n if (value === oldValue) { return }\n vnode = locateNode(vnode);\n var transition = vnode.data && vnode.data.transition;\n if (transition && !isIE9) {\n vnode.data.show = true;\n if (value) {\n enter(vnode, function () {\n el.style.display = el.__vOriginalDisplay;\n });\n } else {\n leave(vnode, function () {\n el.style.display = 'none';\n });\n }\n } else {\n el.style.display = value ? el.__vOriginalDisplay : 'none';\n }\n },\n\n unbind: function unbind (\n el,\n binding,\n vnode,\n oldVnode,\n isDestroy\n ) {\n if (!isDestroy) {\n el.style.display = el.__vOriginalDisplay;\n }\n }\n};\n\nvar platformDirectives = {\n model: model,\n show: show\n};\n\n/* */\n\n// Provides transition support for a single element/component.\n// supports transition mode (out-in / in-out)\n\nvar transitionProps = {\n name: String,\n appear: Boolean,\n css: Boolean,\n mode: String,\n type: String,\n enterClass: String,\n leaveClass: String,\n enterToClass: String,\n leaveToClass: String,\n enterActiveClass: String,\n leaveActiveClass: String,\n appearClass: String,\n appearActiveClass: String,\n appearToClass: String\n};\n\n// in case the child is also an abstract component, e.g. <keep-alive>\n// we want to recursively retrieve the real component to be rendered\nfunction getRealChild (vnode) {\n var compOptions = vnode && vnode.componentOptions;\n if (compOptions && compOptions.Ctor.options.abstract) {\n return getRealChild(getFirstComponentChild(compOptions.children))\n } else {\n return vnode\n }\n}\n\nfunction extractTransitionData (comp) {\n var data = {};\n var options = comp.$options;\n // props\n for (var key in options.propsData) {\n data[key] = comp[key];\n }\n // events.\n // extract listeners and pass them directly to the transition methods\n var listeners = options._parentListeners;\n for (var key$1 in listeners) {\n data[camelize(key$1)] = listeners[key$1].fn;\n }\n return data\n}\n\nfunction placeholder (h, rawChild) {\n return /\\d-keep-alive$/.test(rawChild.tag)\n ? h('keep-alive')\n : null\n}\n\nfunction hasParentTransition (vnode) {\n while ((vnode = vnode.parent)) {\n if (vnode.data.transition) {\n return true\n }\n }\n}\n\nfunction isSameChild (child, oldChild) {\n return oldChild.key === child.key && oldChild.tag === child.tag\n}\n\nvar Transition = {\n name: 'transition',\n props: transitionProps,\n abstract: true,\n\n render: function render (h) {\n var this$1 = this;\n\n var children = this.$slots.default;\n if (!children) {\n return\n }\n\n // filter out text nodes (possible whitespaces)\n children = children.filter(function (c) { return c.tag; });\n /* istanbul ignore if */\n if (!children.length) {\n return\n }\n\n // warn multiple elements\n if (process.env.NODE_ENV !== 'production' && children.length > 1) {\n warn(\n '<transition> can only be used on a single element. Use ' +\n '<transition-group> for lists.',\n this.$parent\n );\n }\n\n var mode = this.mode;\n\n // warn invalid mode\n if (process.env.NODE_ENV !== 'production' &&\n mode && mode !== 'in-out' && mode !== 'out-in') {\n warn(\n 'invalid <transition> mode: ' + mode,\n this.$parent\n );\n }\n\n var rawChild = children[0];\n\n // if this is a component root node and the component's\n // parent container node also has transition, skip.\n if (hasParentTransition(this.$vnode)) {\n return rawChild\n }\n\n // apply transition data to child\n // use getRealChild() to ignore abstract components e.g. keep-alive\n var child = getRealChild(rawChild);\n /* istanbul ignore if */\n if (!child) {\n return rawChild\n }\n\n if (this._leaving) {\n return placeholder(h, rawChild)\n }\n\n // ensure a key that is unique to the vnode type and to this transition\n // component instance. This key will be used to remove pending leaving nodes\n // during entering.\n var id = \"__transition-\" + (this._uid) + \"-\";\n var key = child.key = child.key == null\n ? id + child.tag\n : isPrimitive(child.key)\n ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)\n : child.key;\n var data = (child.data || (child.data = {})).transition = extractTransitionData(this);\n var oldRawChild = this._vnode;\n var oldChild = getRealChild(oldRawChild);\n\n // mark v-show\n // so that the transition module can hand over the control to the directive\n if (child.data.directives && child.data.directives.some(function (d) { return d.name === 'show'; })) {\n child.data.show = true;\n }\n\n if (oldChild && oldChild.data && !isSameChild(child, oldChild)) {\n // replace old child transition data with fresh one\n // important for dynamic transitions!\n var oldData = oldChild && (oldChild.data.transition = extend({}, data));\n // handle transition mode\n if (mode === 'out-in') {\n // return placeholder node and queue update when leave finishes\n this._leaving = true;\n mergeVNodeHook(oldData, 'afterLeave', function () {\n this$1._leaving = false;\n this$1.$forceUpdate();\n }, key);\n return placeholder(h, rawChild)\n } else if (mode === 'in-out') {\n var delayedLeave;\n var performLeave = function () { delayedLeave(); };\n mergeVNodeHook(data, 'afterEnter', performLeave, key);\n mergeVNodeHook(data, 'enterCancelled', performLeave, key);\n mergeVNodeHook(oldData, 'delayLeave', function (leave) {\n delayedLeave = leave;\n }, key);\n }\n }\n\n return rawChild\n }\n};\n\n/* */\n\n// Provides transition support for list items.\n// supports move transitions using the FLIP technique.\n\n// Because the vdom's children update algorithm is \"unstable\" - i.e.\n// it doesn't guarantee the relative positioning of removed elements,\n// we force transition-group to update its children into two passes:\n// in the first pass, we remove all nodes that need to be removed,\n// triggering their leaving transition; in the second pass, we insert/move\n// into the final disired state. This way in the second pass removed\n// nodes will remain where they should be.\n\nvar props = extend({\n tag: String,\n moveClass: String\n}, transitionProps);\n\ndelete props.mode;\n\nvar TransitionGroup = {\n props: props,\n\n render: function render (h) {\n var tag = this.tag || this.$vnode.data.tag || 'span';\n var map = Object.create(null);\n var prevChildren = this.prevChildren = this.children;\n var rawChildren = this.$slots.default || [];\n var children = this.children = [];\n var transitionData = extractTransitionData(this);\n\n for (var i = 0; i < rawChildren.length; i++) {\n var c = rawChildren[i];\n if (c.tag) {\n if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {\n children.push(c);\n map[c.key] = c\n ;(c.data || (c.data = {})).transition = transitionData;\n } else if (process.env.NODE_ENV !== 'production') {\n var opts = c.componentOptions;\n var name = opts\n ? (opts.Ctor.options.name || opts.tag)\n : c.tag;\n warn((\"<transition-group> children must be keyed: <\" + name + \">\"));\n }\n }\n }\n\n if (prevChildren) {\n var kept = [];\n var removed = [];\n for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {\n var c$1 = prevChildren[i$1];\n c$1.data.transition = transitionData;\n c$1.data.pos = c$1.elm.getBoundingClientRect();\n if (map[c$1.key]) {\n kept.push(c$1);\n } else {\n removed.push(c$1);\n }\n }\n this.kept = h(tag, null, kept);\n this.removed = removed;\n }\n\n return h(tag, null, children)\n },\n\n beforeUpdate: function beforeUpdate () {\n // force removing pass\n this.__patch__(\n this._vnode,\n this.kept,\n false, // hydrating\n true // removeOnly (!important, avoids unnecessary moves)\n );\n this._vnode = this.kept;\n },\n\n updated: function updated () {\n var children = this.prevChildren;\n var moveClass = this.moveClass || ((this.name || 'v') + '-move');\n if (!children.length || !this.hasMove(children[0].elm, moveClass)) {\n return\n }\n\n // we divide the work into three loops to avoid mixing DOM reads and writes\n // in each iteration - which helps prevent layout thrashing.\n children.forEach(callPendingCbs);\n children.forEach(recordPosition);\n children.forEach(applyTranslation);\n\n // force reflow to put everything in position\n var f = document.body.offsetHeight; // eslint-disable-line\n\n children.forEach(function (c) {\n if (c.data.moved) {\n var el = c.elm;\n var s = el.style;\n addTransitionClass(el, moveClass);\n s.transform = s.WebkitTransform = s.transitionDuration = '';\n el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {\n if (!e || /transform$/.test(e.propertyName)) {\n el.removeEventListener(transitionEndEvent, cb);\n el._moveCb = null;\n removeTransitionClass(el, moveClass);\n }\n });\n }\n });\n },\n\n methods: {\n hasMove: function hasMove (el, moveClass) {\n /* istanbul ignore if */\n if (!hasTransition) {\n return false\n }\n if (this._hasMove != null) {\n return this._hasMove\n }\n addTransitionClass(el, moveClass);\n var info = getTransitionInfo(el);\n removeTransitionClass(el, moveClass);\n return (this._hasMove = info.hasTransform)\n }\n }\n};\n\nfunction callPendingCbs (c) {\n /* istanbul ignore if */\n if (c.elm._moveCb) {\n c.elm._moveCb();\n }\n /* istanbul ignore if */\n if (c.elm._enterCb) {\n c.elm._enterCb();\n }\n}\n\nfunction recordPosition (c) {\n c.data.newPos = c.elm.getBoundingClientRect();\n}\n\nfunction applyTranslation (c) {\n var oldPos = c.data.pos;\n var newPos = c.data.newPos;\n var dx = oldPos.left - newPos.left;\n var dy = oldPos.top - newPos.top;\n if (dx || dy) {\n c.data.moved = true;\n var s = c.elm.style;\n s.transform = s.WebkitTransform = \"translate(\" + dx + \"px,\" + dy + \"px)\";\n s.transitionDuration = '0s';\n }\n}\n\nvar platformComponents = {\n Transition: Transition,\n TransitionGroup: TransitionGroup\n};\n\n/* */\n\n// install platform specific utils\nVue$3.config.isUnknownElement = isUnknownElement;\nVue$3.config.isReservedTag = isReservedTag;\nVue$3.config.getTagNamespace = getTagNamespace;\nVue$3.config.mustUseProp = mustUseProp;\n\n// install platform runtime directives & components\nextend(Vue$3.options.directives, platformDirectives);\nextend(Vue$3.options.components, platformComponents);\n\n// install platform patch function\nVue$3.prototype.__patch__ = inBrowser ? patch$1 : noop;\n\n// wrap mount\nVue$3.prototype.$mount = function (\n el,\n hydrating\n) {\n el = el && inBrowser ? query(el) : undefined;\n return this._mount(el, hydrating)\n};\n\nif (process.env.NODE_ENV !== 'production' &&\n inBrowser && typeof console !== 'undefined') {\n console[console.info ? 'info' : 'log'](\n \"You are running Vue in development mode.\\n\" +\n \"Make sure to turn on production mode when deploying for production.\\n\" +\n \"See more tips at https://vuejs.org/guide/deployment.html\"\n );\n}\n\n// devtools global hook\n/* istanbul ignore next */\nsetTimeout(function () {\n if (config.devtools) {\n if (devtools) {\n devtools.emit('init', Vue$3);\n } else if (\n process.env.NODE_ENV !== 'production' &&\n inBrowser && !isEdge && /Chrome\\/\\d+/.test(window.navigator.userAgent)\n ) {\n console[console.info ? 'info' : 'log'](\n 'Download the Vue Devtools extension for a better development experience:\\n' +\n 'https://github.com/vuejs/vue-devtools'\n );\n }\n }\n}, 0);\n\n/* */\n\n// check whether current browser encodes a char inside attribute values\nfunction shouldDecode (content, encoded) {\n var div = document.createElement('div');\n div.innerHTML = \"<div a=\\\"\" + content + \"\\\">\";\n return div.innerHTML.indexOf(encoded) > 0\n}\n\n// #3663\n// IE encodes newlines inside attribute values while other browsers don't\nvar shouldDecodeNewlines = inBrowser ? shouldDecode('\\n', ' ') : false;\n\n/* */\n\nvar decoder;\n\nfunction decode (html) {\n decoder = decoder || document.createElement('div');\n decoder.innerHTML = html;\n return decoder.textContent\n}\n\n/* */\n\nvar isUnaryTag = makeMap(\n 'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +\n 'link,meta,param,source,track,wbr',\n true\n);\n\n// Elements that you can, intentionally, leave open\n// (and which close themselves)\nvar canBeLeftOpenTag = makeMap(\n 'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source',\n true\n);\n\n// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3\n// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content\nvar isNonPhrasingTag = makeMap(\n 'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +\n 'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +\n 'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +\n 'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +\n 'title,tr,track',\n true\n);\n\n/**\n * Not type-checking this file because it's mostly vendor code.\n */\n\n/*!\n * HTML Parser By John Resig (ejohn.org)\n * Modified by Juriy \"kangax\" Zaytsev\n * Original code by Erik Arvidsson, Mozilla Public License\n * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js\n */\n\n// Regular Expressions for parsing tags and attributes\nvar singleAttrIdentifier = /([^\\s\"'<>/=]+)/;\nvar singleAttrAssign = /(?:=)/;\nvar singleAttrValues = [\n // attr value double quotes\n /\"([^\"]*)\"+/.source,\n // attr value, single quotes\n /'([^']*)'+/.source,\n // attr value, no quotes\n /([^\\s\"'=<>`]+)/.source\n];\nvar attribute = new RegExp(\n '^\\\\s*' + singleAttrIdentifier.source +\n '(?:\\\\s*(' + singleAttrAssign.source + ')' +\n '\\\\s*(?:' + singleAttrValues.join('|') + '))?'\n);\n\n// could use https://www.w3.org/TR/1999/REC-xml-names-19990114/#NT-QName\n// but for Vue templates we can enforce a simple charset\nvar ncname = '[a-zA-Z_][\\\\w\\\\-\\\\.]*';\nvar qnameCapture = '((?:' + ncname + '\\\\:)?' + ncname + ')';\nvar startTagOpen = new RegExp('^<' + qnameCapture);\nvar startTagClose = /^\\s*(\\/?)>/;\nvar endTag = new RegExp('^<\\\\/' + qnameCapture + '[^>]*>');\nvar doctype = /^<!DOCTYPE [^>]+>/i;\nvar comment = /^<!--/;\nvar conditionalComment = /^<!\\[/;\n\nvar IS_REGEX_CAPTURING_BROKEN = false;\n'x'.replace(/x(.)?/g, function (m, g) {\n IS_REGEX_CAPTURING_BROKEN = g === '';\n});\n\n// Special Elements (can contain anything)\nvar isScriptOrStyle = makeMap('script,style', true);\nvar reCache = {};\n\nvar ltRE = /</g;\nvar gtRE = />/g;\nvar nlRE = / /g;\nvar ampRE = /&/g;\nvar quoteRE = /"/g;\n\nfunction decodeAttr (value, shouldDecodeNewlines) {\n if (shouldDecodeNewlines) {\n value = value.replace(nlRE, '\\n');\n }\n return value\n .replace(ltRE, '<')\n .replace(gtRE, '>')\n .replace(ampRE, '&')\n .replace(quoteRE, '\"')\n}\n\nfunction parseHTML (html, options) {\n var stack = [];\n var expectHTML = options.expectHTML;\n var isUnaryTag$$1 = options.isUnaryTag || no;\n var index = 0;\n var last, lastTag;\n while (html) {\n last = html;\n // Make sure we're not in a script or style element\n if (!lastTag || !isScriptOrStyle(lastTag)) {\n var textEnd = html.indexOf('<');\n if (textEnd === 0) {\n // Comment:\n if (comment.test(html)) {\n var commentEnd = html.indexOf('-->');\n\n if (commentEnd >= 0) {\n advance(commentEnd + 3);\n continue\n }\n }\n\n // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment\n if (conditionalComment.test(html)) {\n var conditionalEnd = html.indexOf(']>');\n\n if (conditionalEnd >= 0) {\n advance(conditionalEnd + 2);\n continue\n }\n }\n\n // Doctype:\n var doctypeMatch = html.match(doctype);\n if (doctypeMatch) {\n advance(doctypeMatch[0].length);\n continue\n }\n\n // End tag:\n var endTagMatch = html.match(endTag);\n if (endTagMatch) {\n var curIndex = index;\n advance(endTagMatch[0].length);\n parseEndTag(endTagMatch[1], curIndex, index);\n continue\n }\n\n // Start tag:\n var startTagMatch = parseStartTag();\n if (startTagMatch) {\n handleStartTag(startTagMatch);\n continue\n }\n }\n\n var text = (void 0), rest$1 = (void 0), next = (void 0);\n if (textEnd > 0) {\n rest$1 = html.slice(textEnd);\n while (\n !endTag.test(rest$1) &&\n !startTagOpen.test(rest$1) &&\n !comment.test(rest$1) &&\n !conditionalComment.test(rest$1)\n ) {\n // < in plain text, be forgiving and treat it as text\n next = rest$1.indexOf('<', 1);\n if (next < 0) { break }\n textEnd += next;\n rest$1 = html.slice(textEnd);\n }\n text = html.substring(0, textEnd);\n advance(textEnd);\n }\n\n if (textEnd < 0) {\n text = html;\n html = '';\n }\n\n if (options.chars && text) {\n options.chars(text);\n }\n } else {\n var stackedTag = lastTag.toLowerCase();\n var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\\\s\\\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));\n var endTagLength = 0;\n var rest = html.replace(reStackedTag, function (all, text, endTag) {\n endTagLength = endTag.length;\n if (stackedTag !== 'script' && stackedTag !== 'style' && stackedTag !== 'noscript') {\n text = text\n .replace(/<!--([\\s\\S]*?)-->/g, '$1')\n .replace(/<!\\[CDATA\\[([\\s\\S]*?)]]>/g, '$1');\n }\n if (options.chars) {\n options.chars(text);\n }\n return ''\n });\n index += html.length - rest.length;\n html = rest;\n parseEndTag(stackedTag, index - endTagLength, index);\n }\n\n if (html === last && options.chars) {\n options.chars(html);\n break\n }\n }\n\n // Clean up any remaining tags\n parseEndTag();\n\n function advance (n) {\n index += n;\n html = html.substring(n);\n }\n\n function parseStartTag () {\n var start = html.match(startTagOpen);\n if (start) {\n var match = {\n tagName: start[1],\n attrs: [],\n start: index\n };\n advance(start[0].length);\n var end, attr;\n while (!(end = html.match(startTagClose)) && (attr = html.match(attribute))) {\n advance(attr[0].length);\n match.attrs.push(attr);\n }\n if (end) {\n match.unarySlash = end[1];\n advance(end[0].length);\n match.end = index;\n return match\n }\n }\n }\n\n function handleStartTag (match) {\n var tagName = match.tagName;\n var unarySlash = match.unarySlash;\n\n if (expectHTML) {\n if (lastTag === 'p' && isNonPhrasingTag(tagName)) {\n parseEndTag(lastTag);\n }\n if (canBeLeftOpenTag(tagName) && lastTag === tagName) {\n parseEndTag(tagName);\n }\n }\n\n var unary = isUnaryTag$$1(tagName) || tagName === 'html' && lastTag === 'head' || !!unarySlash;\n\n var l = match.attrs.length;\n var attrs = new Array(l);\n for (var i = 0; i < l; i++) {\n var args = match.attrs[i];\n // hackish work around FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778\n if (IS_REGEX_CAPTURING_BROKEN && args[0].indexOf('\"\"') === -1) {\n if (args[3] === '') { delete args[3]; }\n if (args[4] === '') { delete args[4]; }\n if (args[5] === '') { delete args[5]; }\n }\n var value = args[3] || args[4] || args[5] || '';\n attrs[i] = {\n name: args[1],\n value: decodeAttr(\n value,\n options.shouldDecodeNewlines\n )\n };\n }\n\n if (!unary) {\n stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs });\n lastTag = tagName;\n unarySlash = '';\n }\n\n if (options.start) {\n options.start(tagName, attrs, unary, match.start, match.end);\n }\n }\n\n function parseEndTag (tagName, start, end) {\n var pos, lowerCasedTagName;\n if (start == null) { start = index; }\n if (end == null) { end = index; }\n\n if (tagName) {\n lowerCasedTagName = tagName.toLowerCase();\n }\n\n // Find the closest opened tag of the same type\n if (tagName) {\n for (pos = stack.length - 1; pos >= 0; pos--) {\n if (stack[pos].lowerCasedTag === lowerCasedTagName) {\n break\n }\n }\n } else {\n // If no tag name is provided, clean shop\n pos = 0;\n }\n\n if (pos >= 0) {\n // Close all the open elements, up the stack\n for (var i = stack.length - 1; i >= pos; i--) {\n if (options.end) {\n options.end(stack[i].tag, start, end);\n }\n }\n\n // Remove the open elements from the stack\n stack.length = pos;\n lastTag = pos && stack[pos - 1].tag;\n } else if (lowerCasedTagName === 'br') {\n if (options.start) {\n options.start(tagName, [], true, start, end);\n }\n } else if (lowerCasedTagName === 'p') {\n if (options.start) {\n options.start(tagName, [], false, start, end);\n }\n if (options.end) {\n options.end(tagName, start, end);\n }\n }\n }\n}\n\n/* */\n\nfunction parseFilters (exp) {\n var inSingle = false;\n var inDouble = false;\n var inTemplateString = false;\n var inRegex = false;\n var curly = 0;\n var square = 0;\n var paren = 0;\n var lastFilterIndex = 0;\n var c, prev, i, expression, filters;\n\n for (i = 0; i < exp.length; i++) {\n prev = c;\n c = exp.charCodeAt(i);\n if (inSingle) {\n if (c === 0x27 && prev !== 0x5C) { inSingle = false; }\n } else if (inDouble) {\n if (c === 0x22 && prev !== 0x5C) { inDouble = false; }\n } else if (inTemplateString) {\n if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }\n } else if (inRegex) {\n if (c === 0x2f && prev !== 0x5C) { inRegex = false; }\n } else if (\n c === 0x7C && // pipe\n exp.charCodeAt(i + 1) !== 0x7C &&\n exp.charCodeAt(i - 1) !== 0x7C &&\n !curly && !square && !paren\n ) {\n if (expression === undefined) {\n // first filter, end of expression\n lastFilterIndex = i + 1;\n expression = exp.slice(0, i).trim();\n } else {\n pushFilter();\n }\n } else {\n switch (c) {\n case 0x22: inDouble = true; break // \"\n case 0x27: inSingle = true; break // '\n case 0x60: inTemplateString = true; break // `\n case 0x28: paren++; break // (\n case 0x29: paren--; break // )\n case 0x5B: square++; break // [\n case 0x5D: square--; break // ]\n case 0x7B: curly++; break // {\n case 0x7D: curly--; break // }\n }\n if (c === 0x2f) { // /\n var j = i - 1;\n var p = (void 0);\n // find first non-whitespace prev char\n for (; j >= 0; j--) {\n p = exp.charAt(j);\n if (p !== ' ') { break }\n }\n if (!p || !/[\\w$]/.test(p)) {\n inRegex = true;\n }\n }\n }\n }\n\n if (expression === undefined) {\n expression = exp.slice(0, i).trim();\n } else if (lastFilterIndex !== 0) {\n pushFilter();\n }\n\n function pushFilter () {\n (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());\n lastFilterIndex = i + 1;\n }\n\n if (filters) {\n for (i = 0; i < filters.length; i++) {\n expression = wrapFilter(expression, filters[i]);\n }\n }\n\n return expression\n}\n\nfunction wrapFilter (exp, filter) {\n var i = filter.indexOf('(');\n if (i < 0) {\n // _f: resolveFilter\n return (\"_f(\\\"\" + filter + \"\\\")(\" + exp + \")\")\n } else {\n var name = filter.slice(0, i);\n var args = filter.slice(i + 1);\n return (\"_f(\\\"\" + name + \"\\\")(\" + exp + \",\" + args)\n }\n}\n\n/* */\n\nvar defaultTagRE = /\\{\\{((?:.|\\n)+?)\\}\\}/g;\nvar regexEscapeRE = /[-.*+?^${}()|[\\]\\/\\\\]/g;\n\nvar buildRegex = cached(function (delimiters) {\n var open = delimiters[0].replace(regexEscapeRE, '\\\\$&');\n var close = delimiters[1].replace(regexEscapeRE, '\\\\$&');\n return new RegExp(open + '((?:.|\\\\n)+?)' + close, 'g')\n});\n\nfunction parseText (\n text,\n delimiters\n) {\n var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;\n if (!tagRE.test(text)) {\n return\n }\n var tokens = [];\n var lastIndex = tagRE.lastIndex = 0;\n var match, index;\n while ((match = tagRE.exec(text))) {\n index = match.index;\n // push text token\n if (index > lastIndex) {\n tokens.push(JSON.stringify(text.slice(lastIndex, index)));\n }\n // tag token\n var exp = parseFilters(match[1].trim());\n tokens.push((\"_s(\" + exp + \")\"));\n lastIndex = index + match[0].length;\n }\n if (lastIndex < text.length) {\n tokens.push(JSON.stringify(text.slice(lastIndex)));\n }\n return tokens.join('+')\n}\n\n/* */\n\nfunction baseWarn (msg) {\n console.error((\"[Vue parser]: \" + msg));\n}\n\nfunction pluckModuleFunction (\n modules,\n key\n) {\n return modules\n ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })\n : []\n}\n\nfunction addProp (el, name, value) {\n (el.props || (el.props = [])).push({ name: name, value: value });\n}\n\nfunction addAttr (el, name, value) {\n (el.attrs || (el.attrs = [])).push({ name: name, value: value });\n}\n\nfunction addDirective (\n el,\n name,\n rawName,\n value,\n arg,\n modifiers\n) {\n (el.directives || (el.directives = [])).push({ name: name, rawName: rawName, value: value, arg: arg, modifiers: modifiers });\n}\n\nfunction addHandler (\n el,\n name,\n value,\n modifiers,\n important\n) {\n // check capture modifier\n if (modifiers && modifiers.capture) {\n delete modifiers.capture;\n name = '!' + name; // mark the event as captured\n }\n if (modifiers && modifiers.once) {\n delete modifiers.once;\n name = '~' + name; // mark the event as once\n }\n var events;\n if (modifiers && modifiers.native) {\n delete modifiers.native;\n events = el.nativeEvents || (el.nativeEvents = {});\n } else {\n events = el.events || (el.events = {});\n }\n var newHandler = { value: value, modifiers: modifiers };\n var handlers = events[name];\n /* istanbul ignore if */\n if (Array.isArray(handlers)) {\n important ? handlers.unshift(newHandler) : handlers.push(newHandler);\n } else if (handlers) {\n events[name] = important ? [newHandler, handlers] : [handlers, newHandler];\n } else {\n events[name] = newHandler;\n }\n}\n\nfunction getBindingAttr (\n el,\n name,\n getStatic\n) {\n var dynamicValue =\n getAndRemoveAttr(el, ':' + name) ||\n getAndRemoveAttr(el, 'v-bind:' + name);\n if (dynamicValue != null) {\n return parseFilters(dynamicValue)\n } else if (getStatic !== false) {\n var staticValue = getAndRemoveAttr(el, name);\n if (staticValue != null) {\n return JSON.stringify(staticValue)\n }\n }\n}\n\nfunction getAndRemoveAttr (el, name) {\n var val;\n if ((val = el.attrsMap[name]) != null) {\n var list = el.attrsList;\n for (var i = 0, l = list.length; i < l; i++) {\n if (list[i].name === name) {\n list.splice(i, 1);\n break\n }\n }\n }\n return val\n}\n\nvar len;\nvar str;\nvar chr;\nvar index$1;\nvar expressionPos;\nvar expressionEndPos;\n\n/**\n * parse directive model to do the array update transform. a[idx] = val => $$a.splice($$idx, 1, val)\n *\n * for loop possible cases:\n *\n * - test\n * - test[idx]\n * - test[test1[idx]]\n * - test[\"a\"][idx]\n * - xxx.test[a[a].test1[idx]]\n * - test.xxx.a[\"asa\"][test1[idx]]\n *\n */\n\nfunction parseModel (val) {\n str = val;\n len = str.length;\n index$1 = expressionPos = expressionEndPos = 0;\n\n if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {\n return {\n exp: val,\n idx: null\n }\n }\n\n while (!eof()) {\n chr = next();\n /* istanbul ignore if */\n if (isStringStart(chr)) {\n parseString(chr);\n } else if (chr === 0x5B) {\n parseBracket(chr);\n }\n }\n\n return {\n exp: val.substring(0, expressionPos),\n idx: val.substring(expressionPos + 1, expressionEndPos)\n }\n}\n\nfunction next () {\n return str.charCodeAt(++index$1)\n}\n\nfunction eof () {\n return index$1 >= len\n}\n\nfunction isStringStart (chr) {\n return chr === 0x22 || chr === 0x27\n}\n\nfunction parseBracket (chr) {\n var inBracket = 1;\n expressionPos = index$1;\n while (!eof()) {\n chr = next();\n if (isStringStart(chr)) {\n parseString(chr);\n continue\n }\n if (chr === 0x5B) { inBracket++; }\n if (chr === 0x5D) { inBracket--; }\n if (inBracket === 0) {\n expressionEndPos = index$1;\n break\n }\n }\n}\n\nfunction parseString (chr) {\n var stringQuote = chr;\n while (!eof()) {\n chr = next();\n if (chr === stringQuote) {\n break\n }\n }\n}\n\n/* */\n\nvar dirRE = /^v-|^@|^:/;\nvar forAliasRE = /(.*?)\\s+(?:in|of)\\s+(.*)/;\nvar forIteratorRE = /\\((\\{[^}]*\\}|[^,]*),([^,]*)(?:,([^,]*))?\\)/;\nvar bindRE = /^:|^v-bind:/;\nvar onRE = /^@|^v-on:/;\nvar argRE = /:(.*)$/;\nvar modifierRE = /\\.[^.]+/g;\n\nvar decodeHTMLCached = cached(decode);\n\n// configurable state\nvar warn$1;\nvar platformGetTagNamespace;\nvar platformMustUseProp;\nvar platformIsPreTag;\nvar preTransforms;\nvar transforms;\nvar postTransforms;\nvar delimiters;\n\n/**\n * Convert HTML string to AST.\n */\nfunction parse (\n template,\n options\n) {\n warn$1 = options.warn || baseWarn;\n platformGetTagNamespace = options.getTagNamespace || no;\n platformMustUseProp = options.mustUseProp || no;\n platformIsPreTag = options.isPreTag || no;\n preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');\n transforms = pluckModuleFunction(options.modules, 'transformNode');\n postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');\n delimiters = options.delimiters;\n var stack = [];\n var preserveWhitespace = options.preserveWhitespace !== false;\n var root;\n var currentParent;\n var inVPre = false;\n var inPre = false;\n var warned = false;\n parseHTML(template, {\n expectHTML: options.expectHTML,\n isUnaryTag: options.isUnaryTag,\n shouldDecodeNewlines: options.shouldDecodeNewlines,\n start: function start (tag, attrs, unary) {\n // check namespace.\n // inherit parent ns if there is one\n var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);\n\n // handle IE svg bug\n /* istanbul ignore if */\n if (isIE && ns === 'svg') {\n attrs = guardIESVGBug(attrs);\n }\n\n var element = {\n type: 1,\n tag: tag,\n attrsList: attrs,\n attrsMap: makeAttrsMap(attrs),\n parent: currentParent,\n children: []\n };\n if (ns) {\n element.ns = ns;\n }\n\n if (isForbiddenTag(element) && !isServerRendering()) {\n element.forbidden = true;\n process.env.NODE_ENV !== 'production' && warn$1(\n 'Templates should only be responsible for mapping the state to the ' +\n 'UI. Avoid placing tags with side-effects in your templates, such as ' +\n \"<\" + tag + \">\" + ', as they will not be parsed.'\n );\n }\n\n // apply pre-transforms\n for (var i = 0; i < preTransforms.length; i++) {\n preTransforms[i](element, options);\n }\n\n if (!inVPre) {\n processPre(element);\n if (element.pre) {\n inVPre = true;\n }\n }\n if (platformIsPreTag(element.tag)) {\n inPre = true;\n }\n if (inVPre) {\n processRawAttrs(element);\n } else {\n processFor(element);\n processIf(element);\n processOnce(element);\n processKey(element);\n\n // determine whether this is a plain element after\n // removing structural attributes\n element.plain = !element.key && !attrs.length;\n\n processRef(element);\n processSlot(element);\n processComponent(element);\n for (var i$1 = 0; i$1 < transforms.length; i$1++) {\n transforms[i$1](element, options);\n }\n processAttrs(element);\n }\n\n function checkRootConstraints (el) {\n if (process.env.NODE_ENV !== 'production' && !warned) {\n if (el.tag === 'slot' || el.tag === 'template') {\n warned = true;\n warn$1(\n \"Cannot use <\" + (el.tag) + \"> as component root element because it may \" +\n 'contain multiple nodes:\\n' + template\n );\n }\n if (el.attrsMap.hasOwnProperty('v-for')) {\n warned = true;\n warn$1(\n 'Cannot use v-for on stateful component root element because ' +\n 'it renders multiple elements:\\n' + template\n );\n }\n }\n }\n\n // tree management\n if (!root) {\n root = element;\n checkRootConstraints(root);\n } else if (!stack.length) {\n // allow root elements with v-if, v-else-if and v-else\n if (root.if && (element.elseif || element.else)) {\n checkRootConstraints(element);\n addIfCondition(root, {\n exp: element.elseif,\n block: element\n });\n } else if (process.env.NODE_ENV !== 'production' && !warned) {\n warned = true;\n warn$1(\n \"Component template should contain exactly one root element:\" +\n \"\\n\\n\" + template + \"\\n\\n\" +\n \"If you are using v-if on multiple elements, \" +\n \"use v-else-if to chain them instead.\"\n );\n }\n }\n if (currentParent && !element.forbidden) {\n if (element.elseif || element.else) {\n processIfConditions(element, currentParent);\n } else if (element.slotScope) { // scoped slot\n currentParent.plain = false;\n var name = element.slotTarget || 'default';(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;\n } else {\n currentParent.children.push(element);\n element.parent = currentParent;\n }\n }\n if (!unary) {\n currentParent = element;\n stack.push(element);\n }\n // apply post-transforms\n for (var i$2 = 0; i$2 < postTransforms.length; i$2++) {\n postTransforms[i$2](element, options);\n }\n },\n\n end: function end () {\n // remove trailing whitespace\n var element = stack[stack.length - 1];\n var lastNode = element.children[element.children.length - 1];\n if (lastNode && lastNode.type === 3 && lastNode.text === ' ') {\n element.children.pop();\n }\n // pop stack\n stack.length -= 1;\n currentParent = stack[stack.length - 1];\n // check pre state\n if (element.pre) {\n inVPre = false;\n }\n if (platformIsPreTag(element.tag)) {\n inPre = false;\n }\n },\n\n chars: function chars (text) {\n if (!currentParent) {\n if (process.env.NODE_ENV !== 'production' && !warned && text === template) {\n warned = true;\n warn$1(\n 'Component template requires a root element, rather than just text:\\n\\n' + template\n );\n }\n return\n }\n // IE textarea placeholder bug\n /* istanbul ignore if */\n if (isIE &&\n currentParent.tag === 'textarea' &&\n currentParent.attrsMap.placeholder === text) {\n return\n }\n var children = currentParent.children;\n text = inPre || text.trim()\n ? decodeHTMLCached(text)\n // only preserve whitespace if its not right after a starting tag\n : preserveWhitespace && children.length ? ' ' : '';\n if (text) {\n var expression;\n if (!inVPre && text !== ' ' && (expression = parseText(text, delimiters))) {\n children.push({\n type: 2,\n expression: expression,\n text: text\n });\n } else if (text !== ' ' || children[children.length - 1].text !== ' ') {\n currentParent.children.push({\n type: 3,\n text: text\n });\n }\n }\n }\n });\n return root\n}\n\nfunction processPre (el) {\n if (getAndRemoveAttr(el, 'v-pre') != null) {\n el.pre = true;\n }\n}\n\nfunction processRawAttrs (el) {\n var l = el.attrsList.length;\n if (l) {\n var attrs = el.attrs = new Array(l);\n for (var i = 0; i < l; i++) {\n attrs[i] = {\n name: el.attrsList[i].name,\n value: JSON.stringify(el.attrsList[i].value)\n };\n }\n } else if (!el.pre) {\n // non root node in pre blocks with no attributes\n el.plain = true;\n }\n}\n\nfunction processKey (el) {\n var exp = getBindingAttr(el, 'key');\n if (exp) {\n if (process.env.NODE_ENV !== 'production' && el.tag === 'template') {\n warn$1(\"<template> cannot be keyed. Place the key on real elements instead.\");\n }\n el.key = exp;\n }\n}\n\nfunction processRef (el) {\n var ref = getBindingAttr(el, 'ref');\n if (ref) {\n el.ref = ref;\n el.refInFor = checkInFor(el);\n }\n}\n\nfunction processFor (el) {\n var exp;\n if ((exp = getAndRemoveAttr(el, 'v-for'))) {\n var inMatch = exp.match(forAliasRE);\n if (!inMatch) {\n process.env.NODE_ENV !== 'production' && warn$1(\n (\"Invalid v-for expression: \" + exp)\n );\n return\n }\n el.for = inMatch[2].trim();\n var alias = inMatch[1].trim();\n var iteratorMatch = alias.match(forIteratorRE);\n if (iteratorMatch) {\n el.alias = iteratorMatch[1].trim();\n el.iterator1 = iteratorMatch[2].trim();\n if (iteratorMatch[3]) {\n el.iterator2 = iteratorMatch[3].trim();\n }\n } else {\n el.alias = alias;\n }\n }\n}\n\nfunction processIf (el) {\n var exp = getAndRemoveAttr(el, 'v-if');\n if (exp) {\n el.if = exp;\n addIfCondition(el, {\n exp: exp,\n block: el\n });\n } else {\n if (getAndRemoveAttr(el, 'v-else') != null) {\n el.else = true;\n }\n var elseif = getAndRemoveAttr(el, 'v-else-if');\n if (elseif) {\n el.elseif = elseif;\n }\n }\n}\n\nfunction processIfConditions (el, parent) {\n var prev = findPrevElement(parent.children);\n if (prev && prev.if) {\n addIfCondition(prev, {\n exp: el.elseif,\n block: el\n });\n } else if (process.env.NODE_ENV !== 'production') {\n warn$1(\n \"v-\" + (el.elseif ? ('else-if=\"' + el.elseif + '\"') : 'else') + \" \" +\n \"used on element <\" + (el.tag) + \"> without corresponding v-if.\"\n );\n }\n}\n\nfunction findPrevElement (children) {\n var i = children.length;\n while (i--) {\n if (children[i].type === 1) {\n return children[i]\n } else {\n if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {\n warn$1(\n \"text \\\"\" + (children[i].text.trim()) + \"\\\" between v-if and v-else(-if) \" +\n \"will be ignored.\"\n );\n }\n children.pop();\n }\n }\n}\n\nfunction addIfCondition (el, condition) {\n if (!el.ifConditions) {\n el.ifConditions = [];\n }\n el.ifConditions.push(condition);\n}\n\nfunction processOnce (el) {\n var once = getAndRemoveAttr(el, 'v-once');\n if (once != null) {\n el.once = true;\n }\n}\n\nfunction processSlot (el) {\n if (el.tag === 'slot') {\n el.slotName = getBindingAttr(el, 'name');\n if (process.env.NODE_ENV !== 'production' && el.key) {\n warn$1(\n \"`key` does not work on <slot> because slots are abstract outlets \" +\n \"and can possibly expand into multiple elements. \" +\n \"Use the key on a wrapping element instead.\"\n );\n }\n } else {\n var slotTarget = getBindingAttr(el, 'slot');\n if (slotTarget) {\n el.slotTarget = slotTarget === '\"\"' ? '\"default\"' : slotTarget;\n }\n if (el.tag === 'template') {\n el.slotScope = getAndRemoveAttr(el, 'scope');\n }\n }\n}\n\nfunction processComponent (el) {\n var binding;\n if ((binding = getBindingAttr(el, 'is'))) {\n el.component = binding;\n }\n if (getAndRemoveAttr(el, 'inline-template') != null) {\n el.inlineTemplate = true;\n }\n}\n\nfunction processAttrs (el) {\n var list = el.attrsList;\n var i, l, name, rawName, value, arg, modifiers, isProp;\n for (i = 0, l = list.length; i < l; i++) {\n name = rawName = list[i].name;\n value = list[i].value;\n if (dirRE.test(name)) {\n // mark element as dynamic\n el.hasBindings = true;\n // modifiers\n modifiers = parseModifiers(name);\n if (modifiers) {\n name = name.replace(modifierRE, '');\n }\n if (bindRE.test(name)) { // v-bind\n name = name.replace(bindRE, '');\n value = parseFilters(value);\n isProp = false;\n if (modifiers) {\n if (modifiers.prop) {\n isProp = true;\n name = camelize(name);\n if (name === 'innerHtml') { name = 'innerHTML'; }\n }\n if (modifiers.camel) {\n name = camelize(name);\n }\n }\n if (isProp || platformMustUseProp(el.tag, el.attrsMap.type, name)) {\n addProp(el, name, value);\n } else {\n addAttr(el, name, value);\n }\n } else if (onRE.test(name)) { // v-on\n name = name.replace(onRE, '');\n addHandler(el, name, value, modifiers);\n } else { // normal directives\n name = name.replace(dirRE, '');\n // parse arg\n var argMatch = name.match(argRE);\n if (argMatch && (arg = argMatch[1])) {\n name = name.slice(0, -(arg.length + 1));\n }\n addDirective(el, name, rawName, value, arg, modifiers);\n if (process.env.NODE_ENV !== 'production' && name === 'model') {\n checkForAliasModel(el, value);\n }\n }\n } else {\n // literal attribute\n if (process.env.NODE_ENV !== 'production') {\n var expression = parseText(value, delimiters);\n if (expression) {\n warn$1(\n name + \"=\\\"\" + value + \"\\\": \" +\n 'Interpolation inside attributes has been removed. ' +\n 'Use v-bind or the colon shorthand instead. For example, ' +\n 'instead of <div id=\"{{ val }}\">, use <div :id=\"val\">.'\n );\n }\n }\n addAttr(el, name, JSON.stringify(value));\n }\n }\n}\n\nfunction checkInFor (el) {\n var parent = el;\n while (parent) {\n if (parent.for !== undefined) {\n return true\n }\n parent = parent.parent;\n }\n return false\n}\n\nfunction parseModifiers (name) {\n var match = name.match(modifierRE);\n if (match) {\n var ret = {};\n match.forEach(function (m) { ret[m.slice(1)] = true; });\n return ret\n }\n}\n\nfunction makeAttrsMap (attrs) {\n var map = {};\n for (var i = 0, l = attrs.length; i < l; i++) {\n if (process.env.NODE_ENV !== 'production' && map[attrs[i].name] && !isIE) {\n warn$1('duplicate attribute: ' + attrs[i].name);\n }\n map[attrs[i].name] = attrs[i].value;\n }\n return map\n}\n\nfunction isForbiddenTag (el) {\n return (\n el.tag === 'style' ||\n (el.tag === 'script' && (\n !el.attrsMap.type ||\n el.attrsMap.type === 'text/javascript'\n ))\n )\n}\n\nvar ieNSBug = /^xmlns:NS\\d+/;\nvar ieNSPrefix = /^NS\\d+:/;\n\n/* istanbul ignore next */\nfunction guardIESVGBug (attrs) {\n var res = [];\n for (var i = 0; i < attrs.length; i++) {\n var attr = attrs[i];\n if (!ieNSBug.test(attr.name)) {\n attr.name = attr.name.replace(ieNSPrefix, '');\n res.push(attr);\n }\n }\n return res\n}\n\nfunction checkForAliasModel (el, value) {\n var _el = el;\n while (_el) {\n if (_el.for && _el.alias === value) {\n warn$1(\n \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\">: \" +\n \"You are binding v-model directly to a v-for iteration alias. \" +\n \"This will not be able to modify the v-for source array because \" +\n \"writing to the alias is like modifying a function local variable. \" +\n \"Consider using an array of objects and use v-model on an object property instead.\"\n );\n }\n _el = _el.parent;\n }\n}\n\n/* */\n\nvar isStaticKey;\nvar isPlatformReservedTag;\n\nvar genStaticKeysCached = cached(genStaticKeys$1);\n\n/**\n * Goal of the optimizer: walk the generated template AST tree\n * and detect sub-trees that are purely static, i.e. parts of\n * the DOM that never needs to change.\n *\n * Once we detect these sub-trees, we can:\n *\n * 1. Hoist them into constants, so that we no longer need to\n * create fresh nodes for them on each re-render;\n * 2. Completely skip them in the patching process.\n */\nfunction optimize (root, options) {\n if (!root) { return }\n isStaticKey = genStaticKeysCached(options.staticKeys || '');\n isPlatformReservedTag = options.isReservedTag || no;\n // first pass: mark all non-static nodes.\n markStatic(root);\n // second pass: mark static roots.\n markStaticRoots(root, false);\n}\n\nfunction genStaticKeys$1 (keys) {\n return makeMap(\n 'type,tag,attrsList,attrsMap,plain,parent,children,attrs' +\n (keys ? ',' + keys : '')\n )\n}\n\nfunction markStatic (node) {\n node.static = isStatic(node);\n if (node.type === 1) {\n // do not make component slot content static. this avoids\n // 1. components not able to mutate slot nodes\n // 2. static slot content fails for hot-reloading\n if (\n !isPlatformReservedTag(node.tag) &&\n node.tag !== 'slot' &&\n node.attrsMap['inline-template'] == null\n ) {\n return\n }\n for (var i = 0, l = node.children.length; i < l; i++) {\n var child = node.children[i];\n markStatic(child);\n if (!child.static) {\n node.static = false;\n }\n }\n }\n}\n\nfunction markStaticRoots (node, isInFor) {\n if (node.type === 1) {\n if (node.static || node.once) {\n node.staticInFor = isInFor;\n }\n // For a node to qualify as a static root, it should have children that\n // are not just static text. Otherwise the cost of hoisting out will\n // outweigh the benefits and it's better off to just always render it fresh.\n if (node.static && node.children.length && !(\n node.children.length === 1 &&\n node.children[0].type === 3\n )) {\n node.staticRoot = true;\n return\n } else {\n node.staticRoot = false;\n }\n if (node.children) {\n for (var i = 0, l = node.children.length; i < l; i++) {\n markStaticRoots(node.children[i], isInFor || !!node.for);\n }\n }\n if (node.ifConditions) {\n walkThroughConditionsBlocks(node.ifConditions, isInFor);\n }\n }\n}\n\nfunction walkThroughConditionsBlocks (conditionBlocks, isInFor) {\n for (var i = 1, len = conditionBlocks.length; i < len; i++) {\n markStaticRoots(conditionBlocks[i].block, isInFor);\n }\n}\n\nfunction isStatic (node) {\n if (node.type === 2) { // expression\n return false\n }\n if (node.type === 3) { // text\n return true\n }\n return !!(node.pre || (\n !node.hasBindings && // no dynamic bindings\n !node.if && !node.for && // not v-if or v-for or v-else\n !isBuiltInTag(node.tag) && // not a built-in\n isPlatformReservedTag(node.tag) && // not a component\n !isDirectChildOfTemplateFor(node) &&\n Object.keys(node).every(isStaticKey)\n ))\n}\n\nfunction isDirectChildOfTemplateFor (node) {\n while (node.parent) {\n node = node.parent;\n if (node.tag !== 'template') {\n return false\n }\n if (node.for) {\n return true\n }\n }\n return false\n}\n\n/* */\n\nvar fnExpRE = /^\\s*([\\w$_]+|\\([^)]*?\\))\\s*=>|^function\\s*\\(/;\nvar simplePathRE = /^\\s*[A-Za-z_$][\\w$]*(?:\\.[A-Za-z_$][\\w$]*|\\['.*?']|\\[\".*?\"]|\\[\\d+]|\\[[A-Za-z_$][\\w$]*])*\\s*$/;\n\n// keyCode aliases\nvar keyCodes = {\n esc: 27,\n tab: 9,\n enter: 13,\n space: 32,\n up: 38,\n left: 37,\n right: 39,\n down: 40,\n 'delete': [8, 46]\n};\n\nvar modifierCode = {\n stop: '$event.stopPropagation();',\n prevent: '$event.preventDefault();',\n self: 'if($event.target !== $event.currentTarget)return;',\n ctrl: 'if(!$event.ctrlKey)return;',\n shift: 'if(!$event.shiftKey)return;',\n alt: 'if(!$event.altKey)return;',\n meta: 'if(!$event.metaKey)return;'\n};\n\nfunction genHandlers (events, native) {\n var res = native ? 'nativeOn:{' : 'on:{';\n for (var name in events) {\n res += \"\\\"\" + name + \"\\\":\" + (genHandler(name, events[name])) + \",\";\n }\n return res.slice(0, -1) + '}'\n}\n\nfunction genHandler (\n name,\n handler\n) {\n if (!handler) {\n return 'function(){}'\n } else if (Array.isArray(handler)) {\n return (\"[\" + (handler.map(function (handler) { return genHandler(name, handler); }).join(',')) + \"]\")\n } else if (!handler.modifiers) {\n return fnExpRE.test(handler.value) || simplePathRE.test(handler.value)\n ? handler.value\n : (\"function($event){\" + (handler.value) + \"}\")\n } else {\n var code = '';\n var keys = [];\n for (var key in handler.modifiers) {\n if (modifierCode[key]) {\n code += modifierCode[key];\n } else {\n keys.push(key);\n }\n }\n if (keys.length) {\n code = genKeyFilter(keys) + code;\n }\n var handlerCode = simplePathRE.test(handler.value)\n ? handler.value + '($event)'\n : handler.value;\n return 'function($event){' + code + handlerCode + '}'\n }\n}\n\nfunction genKeyFilter (keys) {\n return (\"if(\" + (keys.map(genFilterCode).join('&&')) + \")return;\")\n}\n\nfunction genFilterCode (key) {\n var keyVal = parseInt(key, 10);\n if (keyVal) {\n return (\"$event.keyCode!==\" + keyVal)\n }\n var alias = keyCodes[key];\n return (\"_k($event.keyCode,\" + (JSON.stringify(key)) + (alias ? ',' + JSON.stringify(alias) : '') + \")\")\n}\n\n/* */\n\nfunction bind$2 (el, dir) {\n el.wrapData = function (code) {\n return (\"_b(\" + code + \",'\" + (el.tag) + \"',\" + (dir.value) + (dir.modifiers && dir.modifiers.prop ? ',true' : '') + \")\")\n };\n}\n\n/* */\n\nvar baseDirectives = {\n bind: bind$2,\n cloak: noop\n};\n\n/* */\n\n// configurable state\nvar warn$2;\nvar transforms$1;\nvar dataGenFns;\nvar platformDirectives$1;\nvar isPlatformReservedTag$1;\nvar staticRenderFns;\nvar onceCount;\nvar currentOptions;\n\nfunction generate (\n ast,\n options\n) {\n // save previous staticRenderFns so generate calls can be nested\n var prevStaticRenderFns = staticRenderFns;\n var currentStaticRenderFns = staticRenderFns = [];\n var prevOnceCount = onceCount;\n onceCount = 0;\n currentOptions = options;\n warn$2 = options.warn || baseWarn;\n transforms$1 = pluckModuleFunction(options.modules, 'transformCode');\n dataGenFns = pluckModuleFunction(options.modules, 'genData');\n platformDirectives$1 = options.directives || {};\n isPlatformReservedTag$1 = options.isReservedTag || no;\n var code = ast ? genElement(ast) : '_c(\"div\")';\n staticRenderFns = prevStaticRenderFns;\n onceCount = prevOnceCount;\n return {\n render: (\"with(this){return \" + code + \"}\"),\n staticRenderFns: currentStaticRenderFns\n }\n}\n\nfunction genElement (el) {\n if (el.staticRoot && !el.staticProcessed) {\n return genStatic(el)\n } else if (el.once && !el.onceProcessed) {\n return genOnce(el)\n } else if (el.for && !el.forProcessed) {\n return genFor(el)\n } else if (el.if && !el.ifProcessed) {\n return genIf(el)\n } else if (el.tag === 'template' && !el.slotTarget) {\n return genChildren(el) || 'void 0'\n } else if (el.tag === 'slot') {\n return genSlot(el)\n } else {\n // component or element\n var code;\n if (el.component) {\n code = genComponent(el.component, el);\n } else {\n var data = el.plain ? undefined : genData(el);\n\n var children = el.inlineTemplate ? null : genChildren(el, true);\n code = \"_c('\" + (el.tag) + \"'\" + (data ? (\",\" + data) : '') + (children ? (\",\" + children) : '') + \")\";\n }\n // module transforms\n for (var i = 0; i < transforms$1.length; i++) {\n code = transforms$1[i](el, code);\n }\n return code\n }\n}\n\n// hoist static sub-trees out\nfunction genStatic (el) {\n el.staticProcessed = true;\n staticRenderFns.push((\"with(this){return \" + (genElement(el)) + \"}\"));\n return (\"_m(\" + (staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + \")\")\n}\n\n// v-once\nfunction genOnce (el) {\n el.onceProcessed = true;\n if (el.if && !el.ifProcessed) {\n return genIf(el)\n } else if (el.staticInFor) {\n var key = '';\n var parent = el.parent;\n while (parent) {\n if (parent.for) {\n key = parent.key;\n break\n }\n parent = parent.parent;\n }\n if (!key) {\n process.env.NODE_ENV !== 'production' && warn$2(\n \"v-once can only be used inside v-for that is keyed. \"\n );\n return genElement(el)\n }\n return (\"_o(\" + (genElement(el)) + \",\" + (onceCount++) + (key ? (\",\" + key) : \"\") + \")\")\n } else {\n return genStatic(el)\n }\n}\n\nfunction genIf (el) {\n el.ifProcessed = true; // avoid recursion\n return genIfConditions(el.ifConditions.slice())\n}\n\nfunction genIfConditions (conditions) {\n if (!conditions.length) {\n return '_e()'\n }\n\n var condition = conditions.shift();\n if (condition.exp) {\n return (\"(\" + (condition.exp) + \")?\" + (genTernaryExp(condition.block)) + \":\" + (genIfConditions(conditions)))\n } else {\n return (\"\" + (genTernaryExp(condition.block)))\n }\n\n // v-if with v-once should generate code like (a)?_m(0):_m(1)\n function genTernaryExp (el) {\n return el.once ? genOnce(el) : genElement(el)\n }\n}\n\nfunction genFor (el) {\n var exp = el.for;\n var alias = el.alias;\n var iterator1 = el.iterator1 ? (\",\" + (el.iterator1)) : '';\n var iterator2 = el.iterator2 ? (\",\" + (el.iterator2)) : '';\n el.forProcessed = true; // avoid recursion\n return \"_l((\" + exp + \"),\" +\n \"function(\" + alias + iterator1 + iterator2 + \"){\" +\n \"return \" + (genElement(el)) +\n '})'\n}\n\nfunction genData (el) {\n var data = '{';\n\n // directives first.\n // directives may mutate the el's other properties before they are generated.\n var dirs = genDirectives(el);\n if (dirs) { data += dirs + ','; }\n\n // key\n if (el.key) {\n data += \"key:\" + (el.key) + \",\";\n }\n // ref\n if (el.ref) {\n data += \"ref:\" + (el.ref) + \",\";\n }\n if (el.refInFor) {\n data += \"refInFor:true,\";\n }\n // pre\n if (el.pre) {\n data += \"pre:true,\";\n }\n // record original tag name for components using \"is\" attribute\n if (el.component) {\n data += \"tag:\\\"\" + (el.tag) + \"\\\",\";\n }\n // module data generation functions\n for (var i = 0; i < dataGenFns.length; i++) {\n data += dataGenFns[i](el);\n }\n // attributes\n if (el.attrs) {\n data += \"attrs:{\" + (genProps(el.attrs)) + \"},\";\n }\n // DOM props\n if (el.props) {\n data += \"domProps:{\" + (genProps(el.props)) + \"},\";\n }\n // event handlers\n if (el.events) {\n data += (genHandlers(el.events)) + \",\";\n }\n if (el.nativeEvents) {\n data += (genHandlers(el.nativeEvents, true)) + \",\";\n }\n // slot target\n if (el.slotTarget) {\n data += \"slot:\" + (el.slotTarget) + \",\";\n }\n // scoped slots\n if (el.scopedSlots) {\n data += (genScopedSlots(el.scopedSlots)) + \",\";\n }\n // inline-template\n if (el.inlineTemplate) {\n var inlineTemplate = genInlineTemplate(el);\n if (inlineTemplate) {\n data += inlineTemplate + \",\";\n }\n }\n data = data.replace(/,$/, '') + '}';\n // v-bind data wrap\n if (el.wrapData) {\n data = el.wrapData(data);\n }\n return data\n}\n\nfunction genDirectives (el) {\n var dirs = el.directives;\n if (!dirs) { return }\n var res = 'directives:[';\n var hasRuntime = false;\n var i, l, dir, needRuntime;\n for (i = 0, l = dirs.length; i < l; i++) {\n dir = dirs[i];\n needRuntime = true;\n var gen = platformDirectives$1[dir.name] || baseDirectives[dir.name];\n if (gen) {\n // compile-time directive that manipulates AST.\n // returns true if it also needs a runtime counterpart.\n needRuntime = !!gen(el, dir, warn$2);\n }\n if (needRuntime) {\n hasRuntime = true;\n res += \"{name:\\\"\" + (dir.name) + \"\\\",rawName:\\\"\" + (dir.rawName) + \"\\\"\" + (dir.value ? (\",value:(\" + (dir.value) + \"),expression:\" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (\",arg:\\\"\" + (dir.arg) + \"\\\"\") : '') + (dir.modifiers ? (\",modifiers:\" + (JSON.stringify(dir.modifiers))) : '') + \"},\";\n }\n }\n if (hasRuntime) {\n return res.slice(0, -1) + ']'\n }\n}\n\nfunction genInlineTemplate (el) {\n var ast = el.children[0];\n if (process.env.NODE_ENV !== 'production' && (\n el.children.length > 1 || ast.type !== 1\n )) {\n warn$2('Inline-template components must have exactly one child element.');\n }\n if (ast.type === 1) {\n var inlineRenderFns = generate(ast, currentOptions);\n return (\"inlineTemplate:{render:function(){\" + (inlineRenderFns.render) + \"},staticRenderFns:[\" + (inlineRenderFns.staticRenderFns.map(function (code) { return (\"function(){\" + code + \"}\"); }).join(',')) + \"]}\")\n }\n}\n\nfunction genScopedSlots (slots) {\n return (\"scopedSlots:{\" + (Object.keys(slots).map(function (key) { return genScopedSlot(key, slots[key]); }).join(',')) + \"}\")\n}\n\nfunction genScopedSlot (key, el) {\n return key + \":function(\" + (String(el.attrsMap.scope)) + \"){\" +\n \"return \" + (el.tag === 'template'\n ? genChildren(el) || 'void 0'\n : genElement(el)) + \"}\"\n}\n\nfunction genChildren (el, checkSkip) {\n var children = el.children;\n if (children.length) {\n var el$1 = children[0];\n // optimize single v-for\n if (children.length === 1 &&\n el$1.for &&\n el$1.tag !== 'template' &&\n el$1.tag !== 'slot') {\n return genElement(el$1)\n }\n var normalizationType = getNormalizationType(children);\n return (\"[\" + (children.map(genNode).join(',')) + \"]\" + (checkSkip\n ? normalizationType ? (\",\" + normalizationType) : ''\n : ''))\n }\n}\n\n// determine the normalization needed for the children array.\n// 0: no normalization needed\n// 1: simple normalization needed (possible 1-level deep nested array)\n// 2: full normalization needed\nfunction getNormalizationType (children) {\n var res = 0;\n for (var i = 0; i < children.length; i++) {\n var el = children[i];\n if (el.type !== 1) {\n continue\n }\n if (needsNormalization(el) ||\n (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {\n res = 2;\n break\n }\n if (maybeComponent(el) ||\n (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {\n res = 1;\n }\n }\n return res\n}\n\nfunction needsNormalization (el) {\n return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'\n}\n\nfunction maybeComponent (el) {\n return !isPlatformReservedTag$1(el.tag)\n}\n\nfunction genNode (node) {\n if (node.type === 1) {\n return genElement(node)\n } else {\n return genText(node)\n }\n}\n\nfunction genText (text) {\n return (\"_v(\" + (text.type === 2\n ? text.expression // no need for () because already wrapped in _s()\n : transformSpecialNewlines(JSON.stringify(text.text))) + \")\")\n}\n\nfunction genSlot (el) {\n var slotName = el.slotName || '\"default\"';\n var children = genChildren(el);\n var res = \"_t(\" + slotName + (children ? (\",\" + children) : '');\n var attrs = el.attrs && (\"{\" + (el.attrs.map(function (a) { return ((camelize(a.name)) + \":\" + (a.value)); }).join(',')) + \"}\");\n var bind$$1 = el.attrsMap['v-bind'];\n if ((attrs || bind$$1) && !children) {\n res += \",null\";\n }\n if (attrs) {\n res += \",\" + attrs;\n }\n if (bind$$1) {\n res += (attrs ? '' : ',null') + \",\" + bind$$1;\n }\n return res + ')'\n}\n\n// componentName is el.component, take it as argument to shun flow's pessimistic refinement\nfunction genComponent (componentName, el) {\n var children = el.inlineTemplate ? null : genChildren(el, true);\n return (\"_c(\" + componentName + \",\" + (genData(el)) + (children ? (\",\" + children) : '') + \")\")\n}\n\nfunction genProps (props) {\n var res = '';\n for (var i = 0; i < props.length; i++) {\n var prop = props[i];\n res += \"\\\"\" + (prop.name) + \"\\\":\" + (transformSpecialNewlines(prop.value)) + \",\";\n }\n return res.slice(0, -1)\n}\n\n// #3895, #4268\nfunction transformSpecialNewlines (text) {\n return text\n .replace(/\\u2028/g, '\\\\u2028')\n .replace(/\\u2029/g, '\\\\u2029')\n}\n\n/* */\n\n/**\n * Compile a template.\n */\nfunction compile$1 (\n template,\n options\n) {\n var ast = parse(template.trim(), options);\n optimize(ast, options);\n var code = generate(ast, options);\n return {\n ast: ast,\n render: code.render,\n staticRenderFns: code.staticRenderFns\n }\n}\n\n/* */\n\n// operators like typeof, instanceof and in are allowed\nvar prohibitedKeywordRE = new RegExp('\\\\b' + (\n 'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +\n 'super,throw,while,yield,delete,export,import,return,switch,default,' +\n 'extends,finally,continue,debugger,function,arguments'\n).split(',').join('\\\\b|\\\\b') + '\\\\b');\n// check valid identifier for v-for\nvar identRE = /[A-Za-z_$][\\w$]*/;\n// strip strings in expressions\nvar stripStringRE = /'(?:[^'\\\\]|\\\\.)*'|\"(?:[^\"\\\\]|\\\\.)*\"|`(?:[^`\\\\]|\\\\.)*\\$\\{|\\}(?:[^`\\\\]|\\\\.)*`|`(?:[^`\\\\]|\\\\.)*`/g;\n\n// detect problematic expressions in a template\nfunction detectErrors (ast) {\n var errors = [];\n if (ast) {\n checkNode(ast, errors);\n }\n return errors\n}\n\nfunction checkNode (node, errors) {\n if (node.type === 1) {\n for (var name in node.attrsMap) {\n if (dirRE.test(name)) {\n var value = node.attrsMap[name];\n if (value) {\n if (name === 'v-for') {\n checkFor(node, (\"v-for=\\\"\" + value + \"\\\"\"), errors);\n } else {\n checkExpression(value, (name + \"=\\\"\" + value + \"\\\"\"), errors);\n }\n }\n }\n }\n if (node.children) {\n for (var i = 0; i < node.children.length; i++) {\n checkNode(node.children[i], errors);\n }\n }\n } else if (node.type === 2) {\n checkExpression(node.expression, node.text, errors);\n }\n}\n\nfunction checkFor (node, text, errors) {\n checkExpression(node.for || '', text, errors);\n checkIdentifier(node.alias, 'v-for alias', text, errors);\n checkIdentifier(node.iterator1, 'v-for iterator', text, errors);\n checkIdentifier(node.iterator2, 'v-for iterator', text, errors);\n}\n\nfunction checkIdentifier (ident, type, text, errors) {\n if (typeof ident === 'string' && !identRE.test(ident)) {\n errors.push((\"- invalid \" + type + \" \\\"\" + ident + \"\\\" in expression: \" + text));\n }\n}\n\nfunction checkExpression (exp, text, errors) {\n try {\n new Function((\"return \" + exp));\n } catch (e) {\n var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);\n if (keywordMatch) {\n errors.push(\n \"- avoid using JavaScript keyword as property name: \" +\n \"\\\"\" + (keywordMatch[0]) + \"\\\" in expression \" + text\n );\n } else {\n errors.push((\"- invalid expression: \" + text));\n }\n }\n}\n\n/* */\n\nfunction transformNode (el, options) {\n var warn = options.warn || baseWarn;\n var staticClass = getAndRemoveAttr(el, 'class');\n if (process.env.NODE_ENV !== 'production' && staticClass) {\n var expression = parseText(staticClass, options.delimiters);\n if (expression) {\n warn(\n \"class=\\\"\" + staticClass + \"\\\": \" +\n 'Interpolation inside attributes has been removed. ' +\n 'Use v-bind or the colon shorthand instead. For example, ' +\n 'instead of <div class=\"{{ val }}\">, use <div :class=\"val\">.'\n );\n }\n }\n if (staticClass) {\n el.staticClass = JSON.stringify(staticClass);\n }\n var classBinding = getBindingAttr(el, 'class', false /* getStatic */);\n if (classBinding) {\n el.classBinding = classBinding;\n }\n}\n\nfunction genData$1 (el) {\n var data = '';\n if (el.staticClass) {\n data += \"staticClass:\" + (el.staticClass) + \",\";\n }\n if (el.classBinding) {\n data += \"class:\" + (el.classBinding) + \",\";\n }\n return data\n}\n\nvar klass$1 = {\n staticKeys: ['staticClass'],\n transformNode: transformNode,\n genData: genData$1\n};\n\n/* */\n\nfunction transformNode$1 (el, options) {\n var warn = options.warn || baseWarn;\n var staticStyle = getAndRemoveAttr(el, 'style');\n if (staticStyle) {\n /* istanbul ignore if */\n if (process.env.NODE_ENV !== 'production') {\n var expression = parseText(staticStyle, options.delimiters);\n if (expression) {\n warn(\n \"style=\\\"\" + staticStyle + \"\\\": \" +\n 'Interpolation inside attributes has been removed. ' +\n 'Use v-bind or the colon shorthand instead. For example, ' +\n 'instead of <div style=\"{{ val }}\">, use <div :style=\"val\">.'\n );\n }\n }\n el.staticStyle = JSON.stringify(parseStyleText(staticStyle));\n }\n\n var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);\n if (styleBinding) {\n el.styleBinding = styleBinding;\n }\n}\n\nfunction genData$2 (el) {\n var data = '';\n if (el.staticStyle) {\n data += \"staticStyle:\" + (el.staticStyle) + \",\";\n }\n if (el.styleBinding) {\n data += \"style:(\" + (el.styleBinding) + \"),\";\n }\n return data\n}\n\nvar style$1 = {\n staticKeys: ['staticStyle'],\n transformNode: transformNode$1,\n genData: genData$2\n};\n\nvar modules$1 = [\n klass$1,\n style$1\n];\n\n/* */\n\nvar warn$3;\n\nfunction model$1 (\n el,\n dir,\n _warn\n) {\n warn$3 = _warn;\n var value = dir.value;\n var modifiers = dir.modifiers;\n var tag = el.tag;\n var type = el.attrsMap.type;\n if (process.env.NODE_ENV !== 'production') {\n var dynamicType = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];\n if (tag === 'input' && dynamicType) {\n warn$3(\n \"<input :type=\\\"\" + dynamicType + \"\\\" v-model=\\\"\" + value + \"\\\">:\\n\" +\n \"v-model does not support dynamic input types. Use v-if branches instead.\"\n );\n }\n }\n if (tag === 'select') {\n genSelect(el, value, modifiers);\n } else if (tag === 'input' && type === 'checkbox') {\n genCheckboxModel(el, value, modifiers);\n } else if (tag === 'input' && type === 'radio') {\n genRadioModel(el, value, modifiers);\n } else {\n genDefaultModel(el, value, modifiers);\n }\n // ensure runtime directive metadata\n return true\n}\n\nfunction genCheckboxModel (\n el,\n value,\n modifiers\n) {\n if (process.env.NODE_ENV !== 'production' &&\n el.attrsMap.checked != null) {\n warn$3(\n \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" checked>:\\n\" +\n \"inline checked attributes will be ignored when using v-model. \" +\n 'Declare initial values in the component\\'s data option instead.'\n );\n }\n var number = modifiers && modifiers.number;\n var valueBinding = getBindingAttr(el, 'value') || 'null';\n var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';\n var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';\n addProp(el, 'checked',\n \"Array.isArray(\" + value + \")\" +\n \"?_i(\" + value + \",\" + valueBinding + \")>-1\" + (\n trueValueBinding === 'true'\n ? (\":(\" + value + \")\")\n : (\":_q(\" + value + \",\" + trueValueBinding + \")\")\n )\n );\n addHandler(el, 'click',\n \"var $$a=\" + value + \",\" +\n '$$el=$event.target,' +\n \"$$c=$$el.checked?(\" + trueValueBinding + \"):(\" + falseValueBinding + \");\" +\n 'if(Array.isArray($$a)){' +\n \"var $$v=\" + (number ? '_n(' + valueBinding + ')' : valueBinding) + \",\" +\n '$$i=_i($$a,$$v);' +\n \"if($$c){$$i<0&&(\" + value + \"=$$a.concat($$v))}\" +\n \"else{$$i>-1&&(\" + value + \"=$$a.slice(0,$$i).concat($$a.slice($$i+1)))}\" +\n \"}else{\" + value + \"=$$c}\",\n null, true\n );\n}\n\nfunction genRadioModel (\n el,\n value,\n modifiers\n) {\n if (process.env.NODE_ENV !== 'production' &&\n el.attrsMap.checked != null) {\n warn$3(\n \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" checked>:\\n\" +\n \"inline checked attributes will be ignored when using v-model. \" +\n 'Declare initial values in the component\\'s data option instead.'\n );\n }\n var number = modifiers && modifiers.number;\n var valueBinding = getBindingAttr(el, 'value') || 'null';\n valueBinding = number ? (\"_n(\" + valueBinding + \")\") : valueBinding;\n addProp(el, 'checked', (\"_q(\" + value + \",\" + valueBinding + \")\"));\n addHandler(el, 'click', genAssignmentCode(value, valueBinding), null, true);\n}\n\nfunction genDefaultModel (\n el,\n value,\n modifiers\n) {\n if (process.env.NODE_ENV !== 'production') {\n if (el.tag === 'input' && el.attrsMap.value) {\n warn$3(\n \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" value=\\\"\" + (el.attrsMap.value) + \"\\\">:\\n\" +\n 'inline value attributes will be ignored when using v-model. ' +\n 'Declare initial values in the component\\'s data option instead.'\n );\n }\n if (el.tag === 'textarea' && el.children.length) {\n warn$3(\n \"<textarea v-model=\\\"\" + value + \"\\\">:\\n\" +\n 'inline content inside <textarea> will be ignored when using v-model. ' +\n 'Declare initial values in the component\\'s data option instead.'\n );\n }\n }\n\n var type = el.attrsMap.type;\n var ref = modifiers || {};\n var lazy = ref.lazy;\n var number = ref.number;\n var trim = ref.trim;\n var event = lazy || (isIE && type === 'range') ? 'change' : 'input';\n var needCompositionGuard = !lazy && type !== 'range';\n var isNative = el.tag === 'input' || el.tag === 'textarea';\n\n var valueExpression = isNative\n ? (\"$event.target.value\" + (trim ? '.trim()' : ''))\n : trim ? \"(typeof $event === 'string' ? $event.trim() : $event)\" : \"$event\";\n valueExpression = number || type === 'number'\n ? (\"_n(\" + valueExpression + \")\")\n : valueExpression;\n\n var code = genAssignmentCode(value, valueExpression);\n if (isNative && needCompositionGuard) {\n code = \"if($event.target.composing)return;\" + code;\n }\n\n // inputs with type=\"file\" are read only and setting the input's\n // value will throw an error.\n if (process.env.NODE_ENV !== 'production' &&\n type === 'file') {\n warn$3(\n \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" type=\\\"file\\\">:\\n\" +\n \"File inputs are read only. Use a v-on:change listener instead.\"\n );\n }\n\n addProp(el, 'value', isNative ? (\"_s(\" + value + \")\") : (\"(\" + value + \")\"));\n addHandler(el, event, code, null, true);\n if (trim || number || type === 'number') {\n addHandler(el, 'blur', '$forceUpdate()');\n }\n}\n\nfunction genSelect (\n el,\n value,\n modifiers\n) {\n if (process.env.NODE_ENV !== 'production') {\n el.children.some(checkOptionWarning);\n }\n\n var number = modifiers && modifiers.number;\n var assignment = \"Array.prototype.filter\" +\n \".call($event.target.options,function(o){return o.selected})\" +\n \".map(function(o){var val = \\\"_value\\\" in o ? o._value : o.value;\" +\n \"return \" + (number ? '_n(val)' : 'val') + \"})\" +\n (el.attrsMap.multiple == null ? '[0]' : '');\n\n var code = genAssignmentCode(value, assignment);\n addHandler(el, 'change', code, null, true);\n}\n\nfunction checkOptionWarning (option) {\n if (option.type === 1 &&\n option.tag === 'option' &&\n option.attrsMap.selected != null) {\n warn$3(\n \"<select v-model=\\\"\" + (option.parent.attrsMap['v-model']) + \"\\\">:\\n\" +\n 'inline selected attributes on <option> will be ignored when using v-model. ' +\n 'Declare initial values in the component\\'s data option instead.'\n );\n return true\n }\n return false\n}\n\nfunction genAssignmentCode (value, assignment) {\n var modelRs = parseModel(value);\n if (modelRs.idx === null) {\n return (value + \"=\" + assignment)\n } else {\n return \"var $$exp = \" + (modelRs.exp) + \", $$idx = \" + (modelRs.idx) + \";\" +\n \"if (!Array.isArray($$exp)){\" +\n value + \"=\" + assignment + \"}\" +\n \"else{$$exp.splice($$idx, 1, \" + assignment + \")}\"\n }\n}\n\n/* */\n\nfunction text (el, dir) {\n if (dir.value) {\n addProp(el, 'textContent', (\"_s(\" + (dir.value) + \")\"));\n }\n}\n\n/* */\n\nfunction html (el, dir) {\n if (dir.value) {\n addProp(el, 'innerHTML', (\"_s(\" + (dir.value) + \")\"));\n }\n}\n\nvar directives$1 = {\n model: model$1,\n text: text,\n html: html\n};\n\n/* */\n\nvar cache = Object.create(null);\n\nvar baseOptions = {\n expectHTML: true,\n modules: modules$1,\n staticKeys: genStaticKeys(modules$1),\n directives: directives$1,\n isReservedTag: isReservedTag,\n isUnaryTag: isUnaryTag,\n mustUseProp: mustUseProp,\n getTagNamespace: getTagNamespace,\n isPreTag: isPreTag\n};\n\nfunction compile$$1 (\n template,\n options\n) {\n options = options\n ? extend(extend({}, baseOptions), options)\n : baseOptions;\n return compile$1(template, options)\n}\n\nfunction compileToFunctions (\n template,\n options,\n vm\n) {\n var _warn = (options && options.warn) || warn;\n // detect possible CSP restriction\n /* istanbul ignore if */\n if (process.env.NODE_ENV !== 'production') {\n try {\n new Function('return 1');\n } catch (e) {\n if (e.toString().match(/unsafe-eval|CSP/)) {\n _warn(\n 'It seems you are using the standalone build of Vue.js in an ' +\n 'environment with Content Security Policy that prohibits unsafe-eval. ' +\n 'The template compiler cannot work in this environment. Consider ' +\n 'relaxing the policy to allow unsafe-eval or pre-compiling your ' +\n 'templates into render functions.'\n );\n }\n }\n }\n var key = options && options.delimiters\n ? String(options.delimiters) + template\n : template;\n if (cache[key]) {\n return cache[key]\n }\n var res = {};\n var compiled = compile$$1(template, options);\n res.render = makeFunction(compiled.render);\n var l = compiled.staticRenderFns.length;\n res.staticRenderFns = new Array(l);\n for (var i = 0; i < l; i++) {\n res.staticRenderFns[i] = makeFunction(compiled.staticRenderFns[i]);\n }\n if (process.env.NODE_ENV !== 'production') {\n if (res.render === noop || res.staticRenderFns.some(function (fn) { return fn === noop; })) {\n _warn(\n \"failed to compile template:\\n\\n\" + template + \"\\n\\n\" +\n detectErrors(compiled.ast).join('\\n') +\n '\\n\\n',\n vm\n );\n }\n }\n return (cache[key] = res)\n}\n\nfunction makeFunction (code) {\n try {\n return new Function(code)\n } catch (e) {\n return noop\n }\n}\n\n/* */\n\nvar idToTemplate = cached(function (id) {\n var el = query(id);\n return el && el.innerHTML\n});\n\nvar mount = Vue$3.prototype.$mount;\nVue$3.prototype.$mount = function (\n el,\n hydrating\n) {\n el = el && query(el);\n\n /* istanbul ignore if */\n if (el === document.body || el === document.documentElement) {\n process.env.NODE_ENV !== 'production' && warn(\n \"Do not mount Vue to <html> or <body> - mount to normal elements instead.\"\n );\n return this\n }\n\n var options = this.$options;\n // resolve template/el and convert to render function\n if (!options.render) {\n var template = options.template;\n if (template) {\n if (typeof template === 'string') {\n if (template.charAt(0) === '#') {\n template = idToTemplate(template);\n /* istanbul ignore if */\n if (process.env.NODE_ENV !== 'production' && !template) {\n warn(\n (\"Template element not found or is empty: \" + (options.template)),\n this\n );\n }\n }\n } else if (template.nodeType) {\n template = template.innerHTML;\n } else {\n if (process.env.NODE_ENV !== 'production') {\n warn('invalid template option:' + template, this);\n }\n return this\n }\n } else if (el) {\n template = getOuterHTML(el);\n }\n if (template) {\n var ref = compileToFunctions(template, {\n warn: warn,\n shouldDecodeNewlines: shouldDecodeNewlines,\n delimiters: options.delimiters\n }, this);\n var render = ref.render;\n var staticRenderFns = ref.staticRenderFns;\n options.render = render;\n options.staticRenderFns = staticRenderFns;\n }\n }\n return mount.call(this, el, hydrating)\n};\n\n/**\n * Get outerHTML of elements, taking care\n * of SVG elements in IE as well.\n */\nfunction getOuterHTML (el) {\n if (el.outerHTML) {\n return el.outerHTML\n } else {\n var container = document.createElement('div');\n container.appendChild(el.cloneNode(true));\n return container.innerHTML\n }\n}\n\nVue$3.compile = compileToFunctions;\n\nmodule.exports = Vue$3;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/vue/dist/vue.common.js\n// module id = 16\n// module chunks = 0","var toString = {}.toString;\n\nmodule.exports = function(it){\n return toString.call(it).slice(8, -1);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_cof.js\n// module id = 17\n// module chunks = 0","// optional / simple context binding\nvar aFunction = require('./_a-function');\nmodule.exports = function(fn, that, length){\n aFunction(fn);\n if(that === undefined)return fn;\n switch(length){\n case 1: return function(a){\n return fn.call(that, a);\n };\n case 2: return function(a, b){\n return fn.call(that, a, b);\n };\n case 3: return function(a, b, c){\n return fn.call(that, a, b, c);\n };\n }\n return function(/* ...args */){\n return fn.apply(that, arguments);\n };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_ctx.js\n// module id = 18\n// module chunks = 0","var isObject = require('./_is-object')\n , document = require('./_global').document\n // in old IE typeof document.createElement is 'object'\n , is = isObject(document) && isObject(document.createElement);\nmodule.exports = function(it){\n return is ? document.createElement(it) : {};\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_dom-create.js\n// module id = 19\n// module chunks = 0","// IE 8- don't enum bug keys\nmodule.exports = (\n 'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'\n).split(',');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_enum-bug-keys.js\n// module id = 20\n// module chunks = 0","var global = require('./_global')\n , core = require('./_core')\n , ctx = require('./_ctx')\n , hide = require('./_hide')\n , PROTOTYPE = 'prototype';\n\nvar $export = function(type, name, source){\n var IS_FORCED = type & $export.F\n , IS_GLOBAL = type & $export.G\n , IS_STATIC = type & $export.S\n , IS_PROTO = type & $export.P\n , IS_BIND = type & $export.B\n , IS_WRAP = type & $export.W\n , exports = IS_GLOBAL ? core : core[name] || (core[name] = {})\n , expProto = exports[PROTOTYPE]\n , target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]\n , key, own, out;\n if(IS_GLOBAL)source = name;\n for(key in source){\n // contains in native\n own = !IS_FORCED && target && target[key] !== undefined;\n if(own && key in exports)continue;\n // export native or passed\n out = own ? target[key] : source[key];\n // prevent global pollution for namespaces\n exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]\n // bind timers to global for call from export context\n : IS_BIND && own ? ctx(out, global)\n // wrap global constructors for prevent change them in library\n : IS_WRAP && target[key] == out ? (function(C){\n var F = function(a, b, c){\n if(this instanceof C){\n switch(arguments.length){\n case 0: return new C;\n case 1: return new C(a);\n case 2: return new C(a, b);\n } return new C(a, b, c);\n } return C.apply(this, arguments);\n };\n F[PROTOTYPE] = C[PROTOTYPE];\n return F;\n // make static versions for prototype methods\n })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;\n // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%\n if(IS_PROTO){\n (exports.virtual || (exports.virtual = {}))[key] = out;\n // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%\n if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out);\n }\n }\n};\n// type bitmap\n$export.F = 1; // forced\n$export.G = 2; // global\n$export.S = 4; // static\n$export.P = 8; // proto\n$export.B = 16; // bind\n$export.W = 32; // wrap\n$export.U = 64; // safe\n$export.R = 128; // real proto method for `library` \nmodule.exports = $export;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_export.js\n// module id = 21\n// module chunks = 0","module.exports = function(exec){\n try {\n return !!exec();\n } catch(e){\n return true;\n }\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_fails.js\n// module id = 22\n// module chunks = 0","var def = require('./_object-dp').f\n , has = require('./_has')\n , TAG = require('./_wks')('toStringTag');\n\nmodule.exports = function(it, tag, stat){\n if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_set-to-string-tag.js\n// module id = 23\n// module chunks = 0","var global = require('./_global')\n , SHARED = '__core-js_shared__'\n , store = global[SHARED] || (global[SHARED] = {});\nmodule.exports = function(key){\n return store[key] || (store[key] = {});\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_shared.js\n// module id = 24\n// module chunks = 0","// to indexed object, toObject with fallback for non-array-like ES3 strings\nvar IObject = require('./_iobject')\n , defined = require('./_defined');\nmodule.exports = function(it){\n return IObject(defined(it));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-iobject.js\n// module id = 25\n// module chunks = 0","// 7.1.15 ToLength\nvar toInteger = require('./_to-integer')\n , min = Math.min;\nmodule.exports = function(it){\n return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-length.js\n// module id = 26\n// module chunks = 0","// 7.1.13 ToObject(argument)\nvar defined = require('./_defined');\nmodule.exports = function(it){\n return Object(defined(it));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-object.js\n// module id = 27\n// module chunks = 0","var id = 0\n , px = Math.random();\nmodule.exports = function(key){\n return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_uid.js\n// module id = 28\n// module chunks = 0","// https://d3js.org Version 4.6.0. Copyright 2017 Mike Bostock.\n(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :\n\ttypeof define === 'function' && define.amd ? define(['exports'], factory) :\n\t(factory((global.d3 = global.d3 || {})));\n}(this, (function (exports) { 'use strict';\n\nvar version = \"4.6.0\";\n\nvar ascending = function(a, b) {\n return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;\n};\n\nvar bisector = function(compare) {\n if (compare.length === 1) compare = ascendingComparator(compare);\n return {\n left: function(a, x, lo, hi) {\n if (lo == null) lo = 0;\n if (hi == null) hi = a.length;\n while (lo < hi) {\n var mid = lo + hi >>> 1;\n if (compare(a[mid], x) < 0) lo = mid + 1;\n else hi = mid;\n }\n return lo;\n },\n right: function(a, x, lo, hi) {\n if (lo == null) lo = 0;\n if (hi == null) hi = a.length;\n while (lo < hi) {\n var mid = lo + hi >>> 1;\n if (compare(a[mid], x) > 0) hi = mid;\n else lo = mid + 1;\n }\n return lo;\n }\n };\n};\n\nfunction ascendingComparator(f) {\n return function(d, x) {\n return ascending(f(d), x);\n };\n}\n\nvar ascendingBisect = bisector(ascending);\nvar bisectRight = ascendingBisect.right;\nvar bisectLeft = ascendingBisect.left;\n\nvar descending = function(a, b) {\n return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;\n};\n\nvar number = function(x) {\n return x === null ? NaN : +x;\n};\n\nvar variance = function(array, f) {\n var n = array.length,\n m = 0,\n a,\n d,\n s = 0,\n i = -1,\n j = 0;\n\n if (f == null) {\n while (++i < n) {\n if (!isNaN(a = number(array[i]))) {\n d = a - m;\n m += d / ++j;\n s += d * (a - m);\n }\n }\n }\n\n else {\n while (++i < n) {\n if (!isNaN(a = number(f(array[i], i, array)))) {\n d = a - m;\n m += d / ++j;\n s += d * (a - m);\n }\n }\n }\n\n if (j > 1) return s / (j - 1);\n};\n\nvar deviation = function(array, f) {\n var v = variance(array, f);\n return v ? Math.sqrt(v) : v;\n};\n\nvar extent = function(array, f) {\n var i = -1,\n n = array.length,\n a,\n b,\n c;\n\n if (f == null) {\n while (++i < n) if ((b = array[i]) != null && b >= b) { a = c = b; break; }\n while (++i < n) if ((b = array[i]) != null) {\n if (a > b) a = b;\n if (c < b) c = b;\n }\n }\n\n else {\n while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = c = b; break; }\n while (++i < n) if ((b = f(array[i], i, array)) != null) {\n if (a > b) a = b;\n if (c < b) c = b;\n }\n }\n\n return [a, c];\n};\n\nvar array = Array.prototype;\n\nvar slice = array.slice;\nvar map = array.map;\n\nvar constant = function(x) {\n return function() {\n return x;\n };\n};\n\nvar identity = function(x) {\n return x;\n};\n\nvar sequence = function(start, stop, step) {\n start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;\n\n var i = -1,\n n = Math.max(0, Math.ceil((stop - start) / step)) | 0,\n range = new Array(n);\n\n while (++i < n) {\n range[i] = start + i * step;\n }\n\n return range;\n};\n\nvar e10 = Math.sqrt(50);\nvar e5 = Math.sqrt(10);\nvar e2 = Math.sqrt(2);\n\nvar ticks = function(start, stop, count) {\n var step = tickStep(start, stop, count);\n return sequence(\n Math.ceil(start / step) * step,\n Math.floor(stop / step) * step + step / 2, // inclusive\n step\n );\n};\n\nfunction tickStep(start, stop, count) {\n var step0 = Math.abs(stop - start) / Math.max(0, count),\n step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)),\n error = step0 / step1;\n if (error >= e10) step1 *= 10;\n else if (error >= e5) step1 *= 5;\n else if (error >= e2) step1 *= 2;\n return stop < start ? -step1 : step1;\n}\n\nvar sturges = function(values) {\n return Math.ceil(Math.log(values.length) / Math.LN2) + 1;\n};\n\nvar histogram = function() {\n var value = identity,\n domain = extent,\n threshold = sturges;\n\n function histogram(data) {\n var i,\n n = data.length,\n x,\n values = new Array(n);\n\n for (i = 0; i < n; ++i) {\n values[i] = value(data[i], i, data);\n }\n\n var xz = domain(values),\n x0 = xz[0],\n x1 = xz[1],\n tz = threshold(values, x0, x1);\n\n // Convert number of thresholds into uniform thresholds.\n if (!Array.isArray(tz)) tz = ticks(x0, x1, tz);\n\n // Remove any thresholds outside the domain.\n var m = tz.length;\n while (tz[0] <= x0) tz.shift(), --m;\n while (tz[m - 1] >= x1) tz.pop(), --m;\n\n var bins = new Array(m + 1),\n bin;\n\n // Initialize bins.\n for (i = 0; i <= m; ++i) {\n bin = bins[i] = [];\n bin.x0 = i > 0 ? tz[i - 1] : x0;\n bin.x1 = i < m ? tz[i] : x1;\n }\n\n // Assign data to bins by value, ignoring any outside the domain.\n for (i = 0; i < n; ++i) {\n x = values[i];\n if (x0 <= x && x <= x1) {\n bins[bisectRight(tz, x, 0, m)].push(data[i]);\n }\n }\n\n return bins;\n }\n\n histogram.value = function(_) {\n return arguments.length ? (value = typeof _ === \"function\" ? _ : constant(_), histogram) : value;\n };\n\n histogram.domain = function(_) {\n return arguments.length ? (domain = typeof _ === \"function\" ? _ : constant([_[0], _[1]]), histogram) : domain;\n };\n\n histogram.thresholds = function(_) {\n return arguments.length ? (threshold = typeof _ === \"function\" ? _ : Array.isArray(_) ? constant(slice.call(_)) : constant(_), histogram) : threshold;\n };\n\n return histogram;\n};\n\nvar threshold = function(array, p, f) {\n if (f == null) f = number;\n if (!(n = array.length)) return;\n if ((p = +p) <= 0 || n < 2) return +f(array[0], 0, array);\n if (p >= 1) return +f(array[n - 1], n - 1, array);\n var n,\n h = (n - 1) * p,\n i = Math.floor(h),\n a = +f(array[i], i, array),\n b = +f(array[i + 1], i + 1, array);\n return a + (b - a) * (h - i);\n};\n\nvar freedmanDiaconis = function(values, min, max) {\n values = map.call(values, number).sort(ascending);\n return Math.ceil((max - min) / (2 * (threshold(values, 0.75) - threshold(values, 0.25)) * Math.pow(values.length, -1 / 3)));\n};\n\nvar scott = function(values, min, max) {\n return Math.ceil((max - min) / (3.5 * deviation(values) * Math.pow(values.length, -1 / 3)));\n};\n\nvar max = function(array, f) {\n var i = -1,\n n = array.length,\n a,\n b;\n\n if (f == null) {\n while (++i < n) if ((b = array[i]) != null && b >= b) { a = b; break; }\n while (++i < n) if ((b = array[i]) != null && b > a) a = b;\n }\n\n else {\n while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = b; break; }\n while (++i < n) if ((b = f(array[i], i, array)) != null && b > a) a = b;\n }\n\n return a;\n};\n\nvar mean = function(array, f) {\n var s = 0,\n n = array.length,\n a,\n i = -1,\n j = n;\n\n if (f == null) {\n while (++i < n) if (!isNaN(a = number(array[i]))) s += a; else --j;\n }\n\n else {\n while (++i < n) if (!isNaN(a = number(f(array[i], i, array)))) s += a; else --j;\n }\n\n if (j) return s / j;\n};\n\nvar median = function(array, f) {\n var numbers = [],\n n = array.length,\n a,\n i = -1;\n\n if (f == null) {\n while (++i < n) if (!isNaN(a = number(array[i]))) numbers.push(a);\n }\n\n else {\n while (++i < n) if (!isNaN(a = number(f(array[i], i, array)))) numbers.push(a);\n }\n\n return threshold(numbers.sort(ascending), 0.5);\n};\n\nvar merge = function(arrays) {\n var n = arrays.length,\n m,\n i = -1,\n j = 0,\n merged,\n array;\n\n while (++i < n) j += arrays[i].length;\n merged = new Array(j);\n\n while (--n >= 0) {\n array = arrays[n];\n m = array.length;\n while (--m >= 0) {\n merged[--j] = array[m];\n }\n }\n\n return merged;\n};\n\nvar min = function(array, f) {\n var i = -1,\n n = array.length,\n a,\n b;\n\n if (f == null) {\n while (++i < n) if ((b = array[i]) != null && b >= b) { a = b; break; }\n while (++i < n) if ((b = array[i]) != null && a > b) a = b;\n }\n\n else {\n while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = b; break; }\n while (++i < n) if ((b = f(array[i], i, array)) != null && a > b) a = b;\n }\n\n return a;\n};\n\nvar pairs = function(array) {\n var i = 0, n = array.length - 1, p = array[0], pairs = new Array(n < 0 ? 0 : n);\n while (i < n) pairs[i] = [p, p = array[++i]];\n return pairs;\n};\n\nvar permute = function(array, indexes) {\n var i = indexes.length, permutes = new Array(i);\n while (i--) permutes[i] = array[indexes[i]];\n return permutes;\n};\n\nvar scan = function(array, compare) {\n if (!(n = array.length)) return;\n var i = 0,\n n,\n j = 0,\n xi,\n xj = array[j];\n\n if (!compare) compare = ascending;\n\n while (++i < n) if (compare(xi = array[i], xj) < 0 || compare(xj, xj) !== 0) xj = xi, j = i;\n\n if (compare(xj, xj) === 0) return j;\n};\n\nvar shuffle = function(array, i0, i1) {\n var m = (i1 == null ? array.length : i1) - (i0 = i0 == null ? 0 : +i0),\n t,\n i;\n\n while (m) {\n i = Math.random() * m-- | 0;\n t = array[m + i0];\n array[m + i0] = array[i + i0];\n array[i + i0] = t;\n }\n\n return array;\n};\n\nvar sum = function(array, f) {\n var s = 0,\n n = array.length,\n a,\n i = -1;\n\n if (f == null) {\n while (++i < n) if (a = +array[i]) s += a; // Note: zero and null are equivalent.\n }\n\n else {\n while (++i < n) if (a = +f(array[i], i, array)) s += a;\n }\n\n return s;\n};\n\nvar transpose = function(matrix) {\n if (!(n = matrix.length)) return [];\n for (var i = -1, m = min(matrix, length), transpose = new Array(m); ++i < m;) {\n for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n;) {\n row[j] = matrix[j][i];\n }\n }\n return transpose;\n};\n\nfunction length(d) {\n return d.length;\n}\n\nvar zip = function() {\n return transpose(arguments);\n};\n\nvar slice$1 = Array.prototype.slice;\n\nvar identity$1 = function(x) {\n return x;\n};\n\nvar top = 1;\nvar right = 2;\nvar bottom = 3;\nvar left = 4;\nvar epsilon = 1e-6;\n\nfunction translateX(scale0, scale1, d) {\n var x = scale0(d);\n return \"translate(\" + (isFinite(x) ? x : scale1(d)) + \",0)\";\n}\n\nfunction translateY(scale0, scale1, d) {\n var y = scale0(d);\n return \"translate(0,\" + (isFinite(y) ? y : scale1(d)) + \")\";\n}\n\nfunction center(scale) {\n var offset = scale.bandwidth() / 2;\n if (scale.round()) offset = Math.round(offset);\n return function(d) {\n return scale(d) + offset;\n };\n}\n\nfunction entering() {\n return !this.__axis;\n}\n\nfunction axis(orient, scale) {\n var tickArguments = [],\n tickValues = null,\n tickFormat = null,\n tickSizeInner = 6,\n tickSizeOuter = 6,\n tickPadding = 3;\n\n function axis(context) {\n var values = tickValues == null ? (scale.ticks ? scale.ticks.apply(scale, tickArguments) : scale.domain()) : tickValues,\n format = tickFormat == null ? (scale.tickFormat ? scale.tickFormat.apply(scale, tickArguments) : identity$1) : tickFormat,\n spacing = Math.max(tickSizeInner, 0) + tickPadding,\n transform = orient === top || orient === bottom ? translateX : translateY,\n range = scale.range(),\n range0 = range[0] + 0.5,\n range1 = range[range.length - 1] + 0.5,\n position = (scale.bandwidth ? center : identity$1)(scale.copy()),\n selection = context.selection ? context.selection() : context,\n path = selection.selectAll(\".domain\").data([null]),\n tick = selection.selectAll(\".tick\").data(values, scale).order(),\n tickExit = tick.exit(),\n tickEnter = tick.enter().append(\"g\").attr(\"class\", \"tick\"),\n line = tick.select(\"line\"),\n text = tick.select(\"text\"),\n k = orient === top || orient === left ? -1 : 1,\n x, y = orient === left || orient === right ? (x = \"x\", \"y\") : (x = \"y\", \"x\");\n\n path = path.merge(path.enter().insert(\"path\", \".tick\")\n .attr(\"class\", \"domain\")\n .attr(\"stroke\", \"#000\"));\n\n tick = tick.merge(tickEnter);\n\n line = line.merge(tickEnter.append(\"line\")\n .attr(\"stroke\", \"#000\")\n .attr(x + \"2\", k * tickSizeInner)\n .attr(y + \"1\", 0.5)\n .attr(y + \"2\", 0.5));\n\n text = text.merge(tickEnter.append(\"text\")\n .attr(\"fill\", \"#000\")\n .attr(x, k * spacing)\n .attr(y, 0.5)\n .attr(\"dy\", orient === top ? \"0em\" : orient === bottom ? \"0.71em\" : \"0.32em\"));\n\n if (context !== selection) {\n path = path.transition(context);\n tick = tick.transition(context);\n line = line.transition(context);\n text = text.transition(context);\n\n tickExit = tickExit.transition(context)\n .attr(\"opacity\", epsilon)\n .attr(\"transform\", function(d) { return transform(position, this.parentNode.__axis || position, d); });\n\n tickEnter\n .attr(\"opacity\", epsilon)\n .attr(\"transform\", function(d) { return transform(this.parentNode.__axis || position, position, d); });\n }\n\n tickExit.remove();\n\n path\n .attr(\"d\", orient === left || orient == right\n ? \"M\" + k * tickSizeOuter + \",\" + range0 + \"H0.5V\" + range1 + \"H\" + k * tickSizeOuter\n : \"M\" + range0 + \",\" + k * tickSizeOuter + \"V0.5H\" + range1 + \"V\" + k * tickSizeOuter);\n\n tick\n .attr(\"opacity\", 1)\n .attr(\"transform\", function(d) { return transform(position, position, d); });\n\n line\n .attr(x + \"2\", k * tickSizeInner);\n\n text\n .attr(x, k * spacing)\n .text(format);\n\n selection.filter(entering)\n .attr(\"fill\", \"none\")\n .attr(\"font-size\", 10)\n .attr(\"font-family\", \"sans-serif\")\n .attr(\"text-anchor\", orient === right ? \"start\" : orient === left ? \"end\" : \"middle\");\n\n selection\n .each(function() { this.__axis = position; });\n }\n\n axis.scale = function(_) {\n return arguments.length ? (scale = _, axis) : scale;\n };\n\n axis.ticks = function() {\n return tickArguments = slice$1.call(arguments), axis;\n };\n\n axis.tickArguments = function(_) {\n return arguments.length ? (tickArguments = _ == null ? [] : slice$1.call(_), axis) : tickArguments.slice();\n };\n\n axis.tickValues = function(_) {\n return arguments.length ? (tickValues = _ == null ? null : slice$1.call(_), axis) : tickValues && tickValues.slice();\n };\n\n axis.tickFormat = function(_) {\n return arguments.length ? (tickFormat = _, axis) : tickFormat;\n };\n\n axis.tickSize = function(_) {\n return arguments.length ? (tickSizeInner = tickSizeOuter = +_, axis) : tickSizeInner;\n };\n\n axis.tickSizeInner = function(_) {\n return arguments.length ? (tickSizeInner = +_, axis) : tickSizeInner;\n };\n\n axis.tickSizeOuter = function(_) {\n return arguments.length ? (tickSizeOuter = +_, axis) : tickSizeOuter;\n };\n\n axis.tickPadding = function(_) {\n return arguments.length ? (tickPadding = +_, axis) : tickPadding;\n };\n\n return axis;\n}\n\nfunction axisTop(scale) {\n return axis(top, scale);\n}\n\nfunction axisRight(scale) {\n return axis(right, scale);\n}\n\nfunction axisBottom(scale) {\n return axis(bottom, scale);\n}\n\nfunction axisLeft(scale) {\n return axis(left, scale);\n}\n\nvar noop = {value: function() {}};\n\nfunction dispatch() {\n for (var i = 0, n = arguments.length, _ = {}, t; i < n; ++i) {\n if (!(t = arguments[i] + \"\") || (t in _)) throw new Error(\"illegal type: \" + t);\n _[t] = [];\n }\n return new Dispatch(_);\n}\n\nfunction Dispatch(_) {\n this._ = _;\n}\n\nfunction parseTypenames(typenames, types) {\n return typenames.trim().split(/^|\\s+/).map(function(t) {\n var name = \"\", i = t.indexOf(\".\");\n if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);\n if (t && !types.hasOwnProperty(t)) throw new Error(\"unknown type: \" + t);\n return {type: t, name: name};\n });\n}\n\nDispatch.prototype = dispatch.prototype = {\n constructor: Dispatch,\n on: function(typename, callback) {\n var _ = this._,\n T = parseTypenames(typename + \"\", _),\n t,\n i = -1,\n n = T.length;\n\n // If no callback was specified, return the callback of the given type and name.\n if (arguments.length < 2) {\n while (++i < n) if ((t = (typename = T[i]).type) && (t = get(_[t], typename.name))) return t;\n return;\n }\n\n // If a type was specified, set the callback for the given type and name.\n // Otherwise, if a null callback was specified, remove callbacks of the given name.\n if (callback != null && typeof callback !== \"function\") throw new Error(\"invalid callback: \" + callback);\n while (++i < n) {\n if (t = (typename = T[i]).type) _[t] = set(_[t], typename.name, callback);\n else if (callback == null) for (t in _) _[t] = set(_[t], typename.name, null);\n }\n\n return this;\n },\n copy: function() {\n var copy = {}, _ = this._;\n for (var t in _) copy[t] = _[t].slice();\n return new Dispatch(copy);\n },\n call: function(type, that) {\n if ((n = arguments.length - 2) > 0) for (var args = new Array(n), i = 0, n, t; i < n; ++i) args[i] = arguments[i + 2];\n if (!this._.hasOwnProperty(type)) throw new Error(\"unknown type: \" + type);\n for (t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);\n },\n apply: function(type, that, args) {\n if (!this._.hasOwnProperty(type)) throw new Error(\"unknown type: \" + type);\n for (var t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);\n }\n};\n\nfunction get(type, name) {\n for (var i = 0, n = type.length, c; i < n; ++i) {\n if ((c = type[i]).name === name) {\n return c.value;\n }\n }\n}\n\nfunction set(type, name, callback) {\n for (var i = 0, n = type.length; i < n; ++i) {\n if (type[i].name === name) {\n type[i] = noop, type = type.slice(0, i).concat(type.slice(i + 1));\n break;\n }\n }\n if (callback != null) type.push({name: name, value: callback});\n return type;\n}\n\nvar xhtml = \"http://www.w3.org/1999/xhtml\";\n\nvar namespaces = {\n svg: \"http://www.w3.org/2000/svg\",\n xhtml: xhtml,\n xlink: \"http://www.w3.org/1999/xlink\",\n xml: \"http://www.w3.org/XML/1998/namespace\",\n xmlns: \"http://www.w3.org/2000/xmlns/\"\n};\n\nvar namespace = function(name) {\n var prefix = name += \"\", i = prefix.indexOf(\":\");\n if (i >= 0 && (prefix = name.slice(0, i)) !== \"xmlns\") name = name.slice(i + 1);\n return namespaces.hasOwnProperty(prefix) ? {space: namespaces[prefix], local: name} : name;\n};\n\nfunction creatorInherit(name) {\n return function() {\n var document = this.ownerDocument,\n uri = this.namespaceURI;\n return uri === xhtml && document.documentElement.namespaceURI === xhtml\n ? document.createElement(name)\n : document.createElementNS(uri, name);\n };\n}\n\nfunction creatorFixed(fullname) {\n return function() {\n return this.ownerDocument.createElementNS(fullname.space, fullname.local);\n };\n}\n\nvar creator = function(name) {\n var fullname = namespace(name);\n return (fullname.local\n ? creatorFixed\n : creatorInherit)(fullname);\n};\n\nvar nextId = 0;\n\nfunction local$1() {\n return new Local;\n}\n\nfunction Local() {\n this._ = \"@\" + (++nextId).toString(36);\n}\n\nLocal.prototype = local$1.prototype = {\n constructor: Local,\n get: function(node) {\n var id = this._;\n while (!(id in node)) if (!(node = node.parentNode)) return;\n return node[id];\n },\n set: function(node, value) {\n return node[this._] = value;\n },\n remove: function(node) {\n return this._ in node && delete node[this._];\n },\n toString: function() {\n return this._;\n }\n};\n\nvar matcher = function(selector) {\n return function() {\n return this.matches(selector);\n };\n};\n\nif (typeof document !== \"undefined\") {\n var element = document.documentElement;\n if (!element.matches) {\n var vendorMatches = element.webkitMatchesSelector\n || element.msMatchesSelector\n || element.mozMatchesSelector\n || element.oMatchesSelector;\n matcher = function(selector) {\n return function() {\n return vendorMatches.call(this, selector);\n };\n };\n }\n}\n\nvar matcher$1 = matcher;\n\nvar filterEvents = {};\n\nexports.event = null;\n\nif (typeof document !== \"undefined\") {\n var element$1 = document.documentElement;\n if (!(\"onmouseenter\" in element$1)) {\n filterEvents = {mouseenter: \"mouseover\", mouseleave: \"mouseout\"};\n }\n}\n\nfunction filterContextListener(listener, index, group) {\n listener = contextListener(listener, index, group);\n return function(event) {\n var related = event.relatedTarget;\n if (!related || (related !== this && !(related.compareDocumentPosition(this) & 8))) {\n listener.call(this, event);\n }\n };\n}\n\nfunction contextListener(listener, index, group) {\n return function(event1) {\n var event0 = exports.event; // Events can be reentrant (e.g., focus).\n exports.event = event1;\n try {\n listener.call(this, this.__data__, index, group);\n } finally {\n exports.event = event0;\n }\n };\n}\n\nfunction parseTypenames$1(typenames) {\n return typenames.trim().split(/^|\\s+/).map(function(t) {\n var name = \"\", i = t.indexOf(\".\");\n if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);\n return {type: t, name: name};\n });\n}\n\nfunction onRemove(typename) {\n return function() {\n var on = this.__on;\n if (!on) return;\n for (var j = 0, i = -1, m = on.length, o; j < m; ++j) {\n if (o = on[j], (!typename.type || o.type === typename.type) && o.name === typename.name) {\n this.removeEventListener(o.type, o.listener, o.capture);\n } else {\n on[++i] = o;\n }\n }\n if (++i) on.length = i;\n else delete this.__on;\n };\n}\n\nfunction onAdd(typename, value, capture) {\n var wrap = filterEvents.hasOwnProperty(typename.type) ? filterContextListener : contextListener;\n return function(d, i, group) {\n var on = this.__on, o, listener = wrap(value, i, group);\n if (on) for (var j = 0, m = on.length; j < m; ++j) {\n if ((o = on[j]).type === typename.type && o.name === typename.name) {\n this.removeEventListener(o.type, o.listener, o.capture);\n this.addEventListener(o.type, o.listener = listener, o.capture = capture);\n o.value = value;\n return;\n }\n }\n this.addEventListener(typename.type, listener, capture);\n o = {type: typename.type, name: typename.name, value: value, listener: listener, capture: capture};\n if (!on) this.__on = [o];\n else on.push(o);\n };\n}\n\nvar selection_on = function(typename, value, capture) {\n var typenames = parseTypenames$1(typename + \"\"), i, n = typenames.length, t;\n\n if (arguments.length < 2) {\n var on = this.node().__on;\n if (on) for (var j = 0, m = on.length, o; j < m; ++j) {\n for (i = 0, o = on[j]; i < n; ++i) {\n if ((t = typenames[i]).type === o.type && t.name === o.name) {\n return o.value;\n }\n }\n }\n return;\n }\n\n on = value ? onAdd : onRemove;\n if (capture == null) capture = false;\n for (i = 0; i < n; ++i) this.each(on(typenames[i], value, capture));\n return this;\n};\n\nfunction customEvent(event1, listener, that, args) {\n var event0 = exports.event;\n event1.sourceEvent = exports.event;\n exports.event = event1;\n try {\n return listener.apply(that, args);\n } finally {\n exports.event = event0;\n }\n}\n\nvar sourceEvent = function() {\n var current = exports.event, source;\n while (source = current.sourceEvent) current = source;\n return current;\n};\n\nvar point = function(node, event) {\n var svg = node.ownerSVGElement || node;\n\n if (svg.createSVGPoint) {\n var point = svg.createSVGPoint();\n point.x = event.clientX, point.y = event.clientY;\n point = point.matrixTransform(node.getScreenCTM().inverse());\n return [point.x, point.y];\n }\n\n var rect = node.getBoundingClientRect();\n return [event.clientX - rect.left - node.clientLeft, event.clientY - rect.top - node.clientTop];\n};\n\nvar mouse = function(node) {\n var event = sourceEvent();\n if (event.changedTouches) event = event.changedTouches[0];\n return point(node, event);\n};\n\nfunction none() {}\n\nvar selector = function(selector) {\n return selector == null ? none : function() {\n return this.querySelector(selector);\n };\n};\n\nvar selection_select = function(select) {\n if (typeof select !== \"function\") select = selector(select);\n\n for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {\n for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) {\n if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) {\n if (\"__data__\" in node) subnode.__data__ = node.__data__;\n subgroup[i] = subnode;\n }\n }\n }\n\n return new Selection(subgroups, this._parents);\n};\n\nfunction empty$1() {\n return [];\n}\n\nvar selectorAll = function(selector) {\n return selector == null ? empty$1 : function() {\n return this.querySelectorAll(selector);\n };\n};\n\nvar selection_selectAll = function(select) {\n if (typeof select !== \"function\") select = selectorAll(select);\n\n for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) {\n for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {\n if (node = group[i]) {\n subgroups.push(select.call(node, node.__data__, i, group));\n parents.push(node);\n }\n }\n }\n\n return new Selection(subgroups, parents);\n};\n\nvar selection_filter = function(match) {\n if (typeof match !== \"function\") match = matcher$1(match);\n\n for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {\n for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) {\n if ((node = group[i]) && match.call(node, node.__data__, i, group)) {\n subgroup.push(node);\n }\n }\n }\n\n return new Selection(subgroups, this._parents);\n};\n\nvar sparse = function(update) {\n return new Array(update.length);\n};\n\nvar selection_enter = function() {\n return new Selection(this._enter || this._groups.map(sparse), this._parents);\n};\n\nfunction EnterNode(parent, datum) {\n this.ownerDocument = parent.ownerDocument;\n this.namespaceURI = parent.namespaceURI;\n this._next = null;\n this._parent = parent;\n this.__data__ = datum;\n}\n\nEnterNode.prototype = {\n constructor: EnterNode,\n appendChild: function(child) { return this._parent.insertBefore(child, this._next); },\n insertBefore: function(child, next) { return this._parent.insertBefore(child, next); },\n querySelector: function(selector) { return this._parent.querySelector(selector); },\n querySelectorAll: function(selector) { return this._parent.querySelectorAll(selector); }\n};\n\nvar constant$1 = function(x) {\n return function() {\n return x;\n };\n};\n\nvar keyPrefix = \"$\"; // Protect against keys like “__proto__”.\n\nfunction bindIndex(parent, group, enter, update, exit, data) {\n var i = 0,\n node,\n groupLength = group.length,\n dataLength = data.length;\n\n // Put any non-null nodes that fit into update.\n // Put any null nodes into enter.\n // Put any remaining data into enter.\n for (; i < dataLength; ++i) {\n if (node = group[i]) {\n node.__data__ = data[i];\n update[i] = node;\n } else {\n enter[i] = new EnterNode(parent, data[i]);\n }\n }\n\n // Put any non-null nodes that don’t fit into exit.\n for (; i < groupLength; ++i) {\n if (node = group[i]) {\n exit[i] = node;\n }\n }\n}\n\nfunction bindKey(parent, group, enter, update, exit, data, key) {\n var i,\n node,\n nodeByKeyValue = {},\n groupLength = group.length,\n dataLength = data.length,\n keyValues = new Array(groupLength),\n keyValue;\n\n // Compute the key for each node.\n // If multiple nodes have the same key, the duplicates are added to exit.\n for (i = 0; i < groupLength; ++i) {\n if (node = group[i]) {\n keyValues[i] = keyValue = keyPrefix + key.call(node, node.__data__, i, group);\n if (keyValue in nodeByKeyValue) {\n exit[i] = node;\n } else {\n nodeByKeyValue[keyValue] = node;\n }\n }\n }\n\n // Compute the key for each datum.\n // If there a node associated with this key, join and add it to update.\n // If there is not (or the key is a duplicate), add it to enter.\n for (i = 0; i < dataLength; ++i) {\n keyValue = keyPrefix + key.call(parent, data[i], i, data);\n if (node = nodeByKeyValue[keyValue]) {\n update[i] = node;\n node.__data__ = data[i];\n nodeByKeyValue[keyValue] = null;\n } else {\n enter[i] = new EnterNode(parent, data[i]);\n }\n }\n\n // Add any remaining nodes that were not bound to data to exit.\n for (i = 0; i < groupLength; ++i) {\n if ((node = group[i]) && (nodeByKeyValue[keyValues[i]] === node)) {\n exit[i] = node;\n }\n }\n}\n\nvar selection_data = function(value, key) {\n if (!value) {\n data = new Array(this.size()), j = -1;\n this.each(function(d) { data[++j] = d; });\n return data;\n }\n\n var bind = key ? bindKey : bindIndex,\n parents = this._parents,\n groups = this._groups;\n\n if (typeof value !== \"function\") value = constant$1(value);\n\n for (var m = groups.length, update = new Array(m), enter = new Array(m), exit = new Array(m), j = 0; j < m; ++j) {\n var parent = parents[j],\n group = groups[j],\n groupLength = group.length,\n data = value.call(parent, parent && parent.__data__, j, parents),\n dataLength = data.length,\n enterGroup = enter[j] = new Array(dataLength),\n updateGroup = update[j] = new Array(dataLength),\n exitGroup = exit[j] = new Array(groupLength);\n\n bind(parent, group, enterGroup, updateGroup, exitGroup, data, key);\n\n // Now connect the enter nodes to their following update node, such that\n // appendChild can insert the materialized enter node before this node,\n // rather than at the end of the parent node.\n for (var i0 = 0, i1 = 0, previous, next; i0 < dataLength; ++i0) {\n if (previous = enterGroup[i0]) {\n if (i0 >= i1) i1 = i0 + 1;\n while (!(next = updateGroup[i1]) && ++i1 < dataLength);\n previous._next = next || null;\n }\n }\n }\n\n update = new Selection(update, parents);\n update._enter = enter;\n update._exit = exit;\n return update;\n};\n\nvar selection_exit = function() {\n return new Selection(this._exit || this._groups.map(sparse), this._parents);\n};\n\nvar selection_merge = function(selection) {\n\n for (var groups0 = this._groups, groups1 = selection._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) {\n for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) {\n if (node = group0[i] || group1[i]) {\n merge[i] = node;\n }\n }\n }\n\n for (; j < m0; ++j) {\n merges[j] = groups0[j];\n }\n\n return new Selection(merges, this._parents);\n};\n\nvar selection_order = function() {\n\n for (var groups = this._groups, j = -1, m = groups.length; ++j < m;) {\n for (var group = groups[j], i = group.length - 1, next = group[i], node; --i >= 0;) {\n if (node = group[i]) {\n if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next);\n next = node;\n }\n }\n }\n\n return this;\n};\n\nvar selection_sort = function(compare) {\n if (!compare) compare = ascending$1;\n\n function compareNode(a, b) {\n return a && b ? compare(a.__data__, b.__data__) : !a - !b;\n }\n\n for (var groups = this._groups, m = groups.length, sortgroups = new Array(m), j = 0; j < m; ++j) {\n for (var group = groups[j], n = group.length, sortgroup = sortgroups[j] = new Array(n), node, i = 0; i < n; ++i) {\n if (node = group[i]) {\n sortgroup[i] = node;\n }\n }\n sortgroup.sort(compareNode);\n }\n\n return new Selection(sortgroups, this._parents).order();\n};\n\nfunction ascending$1(a, b) {\n return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;\n}\n\nvar selection_call = function() {\n var callback = arguments[0];\n arguments[0] = this;\n callback.apply(null, arguments);\n return this;\n};\n\nvar selection_nodes = function() {\n var nodes = new Array(this.size()), i = -1;\n this.each(function() { nodes[++i] = this; });\n return nodes;\n};\n\nvar selection_node = function() {\n\n for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {\n for (var group = groups[j], i = 0, n = group.length; i < n; ++i) {\n var node = group[i];\n if (node) return node;\n }\n }\n\n return null;\n};\n\nvar selection_size = function() {\n var size = 0;\n this.each(function() { ++size; });\n return size;\n};\n\nvar selection_empty = function() {\n return !this.node();\n};\n\nvar selection_each = function(callback) {\n\n for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {\n for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) {\n if (node = group[i]) callback.call(node, node.__data__, i, group);\n }\n }\n\n return this;\n};\n\nfunction attrRemove(name) {\n return function() {\n this.removeAttribute(name);\n };\n}\n\nfunction attrRemoveNS(fullname) {\n return function() {\n this.removeAttributeNS(fullname.space, fullname.local);\n };\n}\n\nfunction attrConstant(name, value) {\n return function() {\n this.setAttribute(name, value);\n };\n}\n\nfunction attrConstantNS(fullname, value) {\n return function() {\n this.setAttributeNS(fullname.space, fullname.local, value);\n };\n}\n\nfunction attrFunction(name, value) {\n return function() {\n var v = value.apply(this, arguments);\n if (v == null) this.removeAttribute(name);\n else this.setAttribute(name, v);\n };\n}\n\nfunction attrFunctionNS(fullname, value) {\n return function() {\n var v = value.apply(this, arguments);\n if (v == null) this.removeAttributeNS(fullname.space, fullname.local);\n else this.setAttributeNS(fullname.space, fullname.local, v);\n };\n}\n\nvar selection_attr = function(name, value) {\n var fullname = namespace(name);\n\n if (arguments.length < 2) {\n var node = this.node();\n return fullname.local\n ? node.getAttributeNS(fullname.space, fullname.local)\n : node.getAttribute(fullname);\n }\n\n return this.each((value == null\n ? (fullname.local ? attrRemoveNS : attrRemove) : (typeof value === \"function\"\n ? (fullname.local ? attrFunctionNS : attrFunction)\n : (fullname.local ? attrConstantNS : attrConstant)))(fullname, value));\n};\n\nvar window = function(node) {\n return (node.ownerDocument && node.ownerDocument.defaultView) // node is a Node\n || (node.document && node) // node is a Window\n || node.defaultView; // node is a Document\n};\n\nfunction styleRemove(name) {\n return function() {\n this.style.removeProperty(name);\n };\n}\n\nfunction styleConstant(name, value, priority) {\n return function() {\n this.style.setProperty(name, value, priority);\n };\n}\n\nfunction styleFunction(name, value, priority) {\n return function() {\n var v = value.apply(this, arguments);\n if (v == null) this.style.removeProperty(name);\n else this.style.setProperty(name, v, priority);\n };\n}\n\nvar selection_style = function(name, value, priority) {\n var node;\n return arguments.length > 1\n ? this.each((value == null\n ? styleRemove : typeof value === \"function\"\n ? styleFunction\n : styleConstant)(name, value, priority == null ? \"\" : priority))\n : window(node = this.node())\n .getComputedStyle(node, null)\n .getPropertyValue(name);\n};\n\nfunction propertyRemove(name) {\n return function() {\n delete this[name];\n };\n}\n\nfunction propertyConstant(name, value) {\n return function() {\n this[name] = value;\n };\n}\n\nfunction propertyFunction(name, value) {\n return function() {\n var v = value.apply(this, arguments);\n if (v == null) delete this[name];\n else this[name] = v;\n };\n}\n\nvar selection_property = function(name, value) {\n return arguments.length > 1\n ? this.each((value == null\n ? propertyRemove : typeof value === \"function\"\n ? propertyFunction\n : propertyConstant)(name, value))\n : this.node()[name];\n};\n\nfunction classArray(string) {\n return string.trim().split(/^|\\s+/);\n}\n\nfunction classList(node) {\n return node.classList || new ClassList(node);\n}\n\nfunction ClassList(node) {\n this._node = node;\n this._names = classArray(node.getAttribute(\"class\") || \"\");\n}\n\nClassList.prototype = {\n add: function(name) {\n var i = this._names.indexOf(name);\n if (i < 0) {\n this._names.push(name);\n this._node.setAttribute(\"class\", this._names.join(\" \"));\n }\n },\n remove: function(name) {\n var i = this._names.indexOf(name);\n if (i >= 0) {\n this._names.splice(i, 1);\n this._node.setAttribute(\"class\", this._names.join(\" \"));\n }\n },\n contains: function(name) {\n return this._names.indexOf(name) >= 0;\n }\n};\n\nfunction classedAdd(node, names) {\n var list = classList(node), i = -1, n = names.length;\n while (++i < n) list.add(names[i]);\n}\n\nfunction classedRemove(node, names) {\n var list = classList(node), i = -1, n = names.length;\n while (++i < n) list.remove(names[i]);\n}\n\nfunction classedTrue(names) {\n return function() {\n classedAdd(this, names);\n };\n}\n\nfunction classedFalse(names) {\n return function() {\n classedRemove(this, names);\n };\n}\n\nfunction classedFunction(names, value) {\n return function() {\n (value.apply(this, arguments) ? classedAdd : classedRemove)(this, names);\n };\n}\n\nvar selection_classed = function(name, value) {\n var names = classArray(name + \"\");\n\n if (arguments.length < 2) {\n var list = classList(this.node()), i = -1, n = names.length;\n while (++i < n) if (!list.contains(names[i])) return false;\n return true;\n }\n\n return this.each((typeof value === \"function\"\n ? classedFunction : value\n ? classedTrue\n : classedFalse)(names, value));\n};\n\nfunction textRemove() {\n this.textContent = \"\";\n}\n\nfunction textConstant(value) {\n return function() {\n this.textContent = value;\n };\n}\n\nfunction textFunction(value) {\n return function() {\n var v = value.apply(this, arguments);\n this.textContent = v == null ? \"\" : v;\n };\n}\n\nvar selection_text = function(value) {\n return arguments.length\n ? this.each(value == null\n ? textRemove : (typeof value === \"function\"\n ? textFunction\n : textConstant)(value))\n : this.node().textContent;\n};\n\nfunction htmlRemove() {\n this.innerHTML = \"\";\n}\n\nfunction htmlConstant(value) {\n return function() {\n this.innerHTML = value;\n };\n}\n\nfunction htmlFunction(value) {\n return function() {\n var v = value.apply(this, arguments);\n this.innerHTML = v == null ? \"\" : v;\n };\n}\n\nvar selection_html = function(value) {\n return arguments.length\n ? this.each(value == null\n ? htmlRemove : (typeof value === \"function\"\n ? htmlFunction\n : htmlConstant)(value))\n : this.node().innerHTML;\n};\n\nfunction raise() {\n if (this.nextSibling) this.parentNode.appendChild(this);\n}\n\nvar selection_raise = function() {\n return this.each(raise);\n};\n\nfunction lower() {\n if (this.previousSibling) this.parentNode.insertBefore(this, this.parentNode.firstChild);\n}\n\nvar selection_lower = function() {\n return this.each(lower);\n};\n\nvar selection_append = function(name) {\n var create = typeof name === \"function\" ? name : creator(name);\n return this.select(function() {\n return this.appendChild(create.apply(this, arguments));\n });\n};\n\nfunction constantNull() {\n return null;\n}\n\nvar selection_insert = function(name, before) {\n var create = typeof name === \"function\" ? name : creator(name),\n select = before == null ? constantNull : typeof before === \"function\" ? before : selector(before);\n return this.select(function() {\n return this.insertBefore(create.apply(this, arguments), select.apply(this, arguments) || null);\n });\n};\n\nfunction remove() {\n var parent = this.parentNode;\n if (parent) parent.removeChild(this);\n}\n\nvar selection_remove = function() {\n return this.each(remove);\n};\n\nvar selection_datum = function(value) {\n return arguments.length\n ? this.property(\"__data__\", value)\n : this.node().__data__;\n};\n\nfunction dispatchEvent(node, type, params) {\n var window$$1 = window(node),\n event = window$$1.CustomEvent;\n\n if (event) {\n event = new event(type, params);\n } else {\n event = window$$1.document.createEvent(\"Event\");\n if (params) event.initEvent(type, params.bubbles, params.cancelable), event.detail = params.detail;\n else event.initEvent(type, false, false);\n }\n\n node.dispatchEvent(event);\n}\n\nfunction dispatchConstant(type, params) {\n return function() {\n return dispatchEvent(this, type, params);\n };\n}\n\nfunction dispatchFunction(type, params) {\n return function() {\n return dispatchEvent(this, type, params.apply(this, arguments));\n };\n}\n\nvar selection_dispatch = function(type, params) {\n return this.each((typeof params === \"function\"\n ? dispatchFunction\n : dispatchConstant)(type, params));\n};\n\nvar root = [null];\n\nfunction Selection(groups, parents) {\n this._groups = groups;\n this._parents = parents;\n}\n\nfunction selection() {\n return new Selection([[document.documentElement]], root);\n}\n\nSelection.prototype = selection.prototype = {\n constructor: Selection,\n select: selection_select,\n selectAll: selection_selectAll,\n filter: selection_filter,\n data: selection_data,\n enter: selection_enter,\n exit: selection_exit,\n merge: selection_merge,\n order: selection_order,\n sort: selection_sort,\n call: selection_call,\n nodes: selection_nodes,\n node: selection_node,\n size: selection_size,\n empty: selection_empty,\n each: selection_each,\n attr: selection_attr,\n style: selection_style,\n property: selection_property,\n classed: selection_classed,\n text: selection_text,\n html: selection_html,\n raise: selection_raise,\n lower: selection_lower,\n append: selection_append,\n insert: selection_insert,\n remove: selection_remove,\n datum: selection_datum,\n on: selection_on,\n dispatch: selection_dispatch\n};\n\nvar select = function(selector) {\n return typeof selector === \"string\"\n ? new Selection([[document.querySelector(selector)]], [document.documentElement])\n : new Selection([[selector]], root);\n};\n\nvar selectAll = function(selector) {\n return typeof selector === \"string\"\n ? new Selection([document.querySelectorAll(selector)], [document.documentElement])\n : new Selection([selector == null ? [] : selector], root);\n};\n\nvar touch = function(node, touches, identifier) {\n if (arguments.length < 3) identifier = touches, touches = sourceEvent().changedTouches;\n\n for (var i = 0, n = touches ? touches.length : 0, touch; i < n; ++i) {\n if ((touch = touches[i]).identifier === identifier) {\n return point(node, touch);\n }\n }\n\n return null;\n};\n\nvar touches = function(node, touches) {\n if (touches == null) touches = sourceEvent().touches;\n\n for (var i = 0, n = touches ? touches.length : 0, points = new Array(n); i < n; ++i) {\n points[i] = point(node, touches[i]);\n }\n\n return points;\n};\n\nfunction nopropagation() {\n exports.event.stopImmediatePropagation();\n}\n\nvar noevent = function() {\n exports.event.preventDefault();\n exports.event.stopImmediatePropagation();\n};\n\nvar dragDisable = function(view) {\n var root = view.document.documentElement,\n selection$$1 = select(view).on(\"dragstart.drag\", noevent, true);\n if (\"onselectstart\" in root) {\n selection$$1.on(\"selectstart.drag\", noevent, true);\n } else {\n root.__noselect = root.style.MozUserSelect;\n root.style.MozUserSelect = \"none\";\n }\n};\n\nfunction yesdrag(view, noclick) {\n var root = view.document.documentElement,\n selection$$1 = select(view).on(\"dragstart.drag\", null);\n if (noclick) {\n selection$$1.on(\"click.drag\", noevent, true);\n setTimeout(function() { selection$$1.on(\"click.drag\", null); }, 0);\n }\n if (\"onselectstart\" in root) {\n selection$$1.on(\"selectstart.drag\", null);\n } else {\n root.style.MozUserSelect = root.__noselect;\n delete root.__noselect;\n }\n}\n\nvar constant$2 = function(x) {\n return function() {\n return x;\n };\n};\n\nfunction DragEvent(target, type, subject, id, active, x, y, dx, dy, dispatch) {\n this.target = target;\n this.type = type;\n this.subject = subject;\n this.identifier = id;\n this.active = active;\n this.x = x;\n this.y = y;\n this.dx = dx;\n this.dy = dy;\n this._ = dispatch;\n}\n\nDragEvent.prototype.on = function() {\n var value = this._.on.apply(this._, arguments);\n return value === this._ ? this : value;\n};\n\n// Ignore right-click, since that should open the context menu.\nfunction defaultFilter$1() {\n return !exports.event.button;\n}\n\nfunction defaultContainer() {\n return this.parentNode;\n}\n\nfunction defaultSubject(d) {\n return d == null ? {x: exports.event.x, y: exports.event.y} : d;\n}\n\nvar drag = function() {\n var filter = defaultFilter$1,\n container = defaultContainer,\n subject = defaultSubject,\n gestures = {},\n listeners = dispatch(\"start\", \"drag\", \"end\"),\n active = 0,\n mousemoving,\n touchending;\n\n function drag(selection$$1) {\n selection$$1\n .on(\"mousedown.drag\", mousedowned)\n .on(\"touchstart.drag\", touchstarted)\n .on(\"touchmove.drag\", touchmoved)\n .on(\"touchend.drag touchcancel.drag\", touchended)\n .style(\"-webkit-tap-highlight-color\", \"rgba(0,0,0,0)\");\n }\n\n function mousedowned() {\n if (touchending || !filter.apply(this, arguments)) return;\n var gesture = beforestart(\"mouse\", container.apply(this, arguments), mouse, this, arguments);\n if (!gesture) return;\n select(exports.event.view).on(\"mousemove.drag\", mousemoved, true).on(\"mouseup.drag\", mouseupped, true);\n dragDisable(exports.event.view);\n nopropagation();\n mousemoving = false;\n gesture(\"start\");\n }\n\n function mousemoved() {\n noevent();\n mousemoving = true;\n gestures.mouse(\"drag\");\n }\n\n function mouseupped() {\n select(exports.event.view).on(\"mousemove.drag mouseup.drag\", null);\n yesdrag(exports.event.view, mousemoving);\n noevent();\n gestures.mouse(\"end\");\n }\n\n function touchstarted() {\n if (!filter.apply(this, arguments)) return;\n var touches$$1 = exports.event.changedTouches,\n c = container.apply(this, arguments),\n n = touches$$1.length, i, gesture;\n\n for (i = 0; i < n; ++i) {\n if (gesture = beforestart(touches$$1[i].identifier, c, touch, this, arguments)) {\n nopropagation();\n gesture(\"start\");\n }\n }\n }\n\n function touchmoved() {\n var touches$$1 = exports.event.changedTouches,\n n = touches$$1.length, i, gesture;\n\n for (i = 0; i < n; ++i) {\n if (gesture = gestures[touches$$1[i].identifier]) {\n noevent();\n gesture(\"drag\");\n }\n }\n }\n\n function touchended() {\n var touches$$1 = exports.event.changedTouches,\n n = touches$$1.length, i, gesture;\n\n if (touchending) clearTimeout(touchending);\n touchending = setTimeout(function() { touchending = null; }, 500); // Ghost clicks are delayed!\n for (i = 0; i < n; ++i) {\n if (gesture = gestures[touches$$1[i].identifier]) {\n nopropagation();\n gesture(\"end\");\n }\n }\n }\n\n function beforestart(id, container, point, that, args) {\n var p = point(container, id), s, dx, dy,\n sublisteners = listeners.copy();\n\n if (!customEvent(new DragEvent(drag, \"beforestart\", s, id, active, p[0], p[1], 0, 0, sublisteners), function() {\n if ((exports.event.subject = s = subject.apply(that, args)) == null) return false;\n dx = s.x - p[0] || 0;\n dy = s.y - p[1] || 0;\n return true;\n })) return;\n\n return function gesture(type) {\n var p0 = p, n;\n switch (type) {\n case \"start\": gestures[id] = gesture, n = active++; break;\n case \"end\": delete gestures[id], --active; // nobreak\n case \"drag\": p = point(container, id), n = active; break;\n }\n customEvent(new DragEvent(drag, type, s, id, n, p[0] + dx, p[1] + dy, p[0] - p0[0], p[1] - p0[1], sublisteners), sublisteners.apply, sublisteners, [type, that, args]);\n };\n }\n\n drag.filter = function(_) {\n return arguments.length ? (filter = typeof _ === \"function\" ? _ : constant$2(!!_), drag) : filter;\n };\n\n drag.container = function(_) {\n return arguments.length ? (container = typeof _ === \"function\" ? _ : constant$2(_), drag) : container;\n };\n\n drag.subject = function(_) {\n return arguments.length ? (subject = typeof _ === \"function\" ? _ : constant$2(_), drag) : subject;\n };\n\n drag.on = function() {\n var value = listeners.on.apply(listeners, arguments);\n return value === listeners ? drag : value;\n };\n\n return drag;\n};\n\nvar define = function(constructor, factory, prototype) {\n constructor.prototype = factory.prototype = prototype;\n prototype.constructor = constructor;\n};\n\nfunction extend(parent, definition) {\n var prototype = Object.create(parent.prototype);\n for (var key in definition) prototype[key] = definition[key];\n return prototype;\n}\n\nfunction Color() {}\n\nvar darker = 0.7;\nvar brighter = 1 / darker;\n\nvar reI = \"\\\\s*([+-]?\\\\d+)\\\\s*\";\nvar reN = \"\\\\s*([+-]?\\\\d*\\\\.?\\\\d+(?:[eE][+-]?\\\\d+)?)\\\\s*\";\nvar reP = \"\\\\s*([+-]?\\\\d*\\\\.?\\\\d+(?:[eE][+-]?\\\\d+)?)%\\\\s*\";\nvar reHex3 = /^#([0-9a-f]{3})$/;\nvar reHex6 = /^#([0-9a-f]{6})$/;\nvar reRgbInteger = new RegExp(\"^rgb\\\\(\" + [reI, reI, reI] + \"\\\\)$\");\nvar reRgbPercent = new RegExp(\"^rgb\\\\(\" + [reP, reP, reP] + \"\\\\)$\");\nvar reRgbaInteger = new RegExp(\"^rgba\\\\(\" + [reI, reI, reI, reN] + \"\\\\)$\");\nvar reRgbaPercent = new RegExp(\"^rgba\\\\(\" + [reP, reP, reP, reN] + \"\\\\)$\");\nvar reHslPercent = new RegExp(\"^hsl\\\\(\" + [reN, reP, reP] + \"\\\\)$\");\nvar reHslaPercent = new RegExp(\"^hsla\\\\(\" + [reN, reP, reP, reN] + \"\\\\)$\");\n\nvar named = {\n aliceblue: 0xf0f8ff,\n antiquewhite: 0xfaebd7,\n aqua: 0x00ffff,\n aquamarine: 0x7fffd4,\n azure: 0xf0ffff,\n beige: 0xf5f5dc,\n bisque: 0xffe4c4,\n black: 0x000000,\n blanchedalmond: 0xffebcd,\n blue: 0x0000ff,\n blueviolet: 0x8a2be2,\n brown: 0xa52a2a,\n burlywood: 0xdeb887,\n cadetblue: 0x5f9ea0,\n chartreuse: 0x7fff00,\n chocolate: 0xd2691e,\n coral: 0xff7f50,\n cornflowerblue: 0x6495ed,\n cornsilk: 0xfff8dc,\n crimson: 0xdc143c,\n cyan: 0x00ffff,\n darkblue: 0x00008b,\n darkcyan: 0x008b8b,\n darkgoldenrod: 0xb8860b,\n darkgray: 0xa9a9a9,\n darkgreen: 0x006400,\n darkgrey: 0xa9a9a9,\n darkkhaki: 0xbdb76b,\n darkmagenta: 0x8b008b,\n darkolivegreen: 0x556b2f,\n darkorange: 0xff8c00,\n darkorchid: 0x9932cc,\n darkred: 0x8b0000,\n darksalmon: 0xe9967a,\n darkseagreen: 0x8fbc8f,\n darkslateblue: 0x483d8b,\n darkslategray: 0x2f4f4f,\n darkslategrey: 0x2f4f4f,\n darkturquoise: 0x00ced1,\n darkviolet: 0x9400d3,\n deeppink: 0xff1493,\n deepskyblue: 0x00bfff,\n dimgray: 0x696969,\n dimgrey: 0x696969,\n dodgerblue: 0x1e90ff,\n firebrick: 0xb22222,\n floralwhite: 0xfffaf0,\n forestgreen: 0x228b22,\n fuchsia: 0xff00ff,\n gainsboro: 0xdcdcdc,\n ghostwhite: 0xf8f8ff,\n gold: 0xffd700,\n goldenrod: 0xdaa520,\n gray: 0x808080,\n green: 0x008000,\n greenyellow: 0xadff2f,\n grey: 0x808080,\n honeydew: 0xf0fff0,\n hotpink: 0xff69b4,\n indianred: 0xcd5c5c,\n indigo: 0x4b0082,\n ivory: 0xfffff0,\n khaki: 0xf0e68c,\n lavender: 0xe6e6fa,\n lavenderblush: 0xfff0f5,\n lawngreen: 0x7cfc00,\n lemonchiffon: 0xfffacd,\n lightblue: 0xadd8e6,\n lightcoral: 0xf08080,\n lightcyan: 0xe0ffff,\n lightgoldenrodyellow: 0xfafad2,\n lightgray: 0xd3d3d3,\n lightgreen: 0x90ee90,\n lightgrey: 0xd3d3d3,\n lightpink: 0xffb6c1,\n lightsalmon: 0xffa07a,\n lightseagreen: 0x20b2aa,\n lightskyblue: 0x87cefa,\n lightslategray: 0x778899,\n lightslategrey: 0x778899,\n lightsteelblue: 0xb0c4de,\n lightyellow: 0xffffe0,\n lime: 0x00ff00,\n limegreen: 0x32cd32,\n linen: 0xfaf0e6,\n magenta: 0xff00ff,\n maroon: 0x800000,\n mediumaquamarine: 0x66cdaa,\n mediumblue: 0x0000cd,\n mediumorchid: 0xba55d3,\n mediumpurple: 0x9370db,\n mediumseagreen: 0x3cb371,\n mediumslateblue: 0x7b68ee,\n mediumspringgreen: 0x00fa9a,\n mediumturquoise: 0x48d1cc,\n mediumvioletred: 0xc71585,\n midnightblue: 0x191970,\n mintcream: 0xf5fffa,\n mistyrose: 0xffe4e1,\n moccasin: 0xffe4b5,\n navajowhite: 0xffdead,\n navy: 0x000080,\n oldlace: 0xfdf5e6,\n olive: 0x808000,\n olivedrab: 0x6b8e23,\n orange: 0xffa500,\n orangered: 0xff4500,\n orchid: 0xda70d6,\n palegoldenrod: 0xeee8aa,\n palegreen: 0x98fb98,\n paleturquoise: 0xafeeee,\n palevioletred: 0xdb7093,\n papayawhip: 0xffefd5,\n peachpuff: 0xffdab9,\n peru: 0xcd853f,\n pink: 0xffc0cb,\n plum: 0xdda0dd,\n powderblue: 0xb0e0e6,\n purple: 0x800080,\n rebeccapurple: 0x663399,\n red: 0xff0000,\n rosybrown: 0xbc8f8f,\n royalblue: 0x4169e1,\n saddlebrown: 0x8b4513,\n salmon: 0xfa8072,\n sandybrown: 0xf4a460,\n seagreen: 0x2e8b57,\n seashell: 0xfff5ee,\n sienna: 0xa0522d,\n silver: 0xc0c0c0,\n skyblue: 0x87ceeb,\n slateblue: 0x6a5acd,\n slategray: 0x708090,\n slategrey: 0x708090,\n snow: 0xfffafa,\n springgreen: 0x00ff7f,\n steelblue: 0x4682b4,\n tan: 0xd2b48c,\n teal: 0x008080,\n thistle: 0xd8bfd8,\n tomato: 0xff6347,\n turquoise: 0x40e0d0,\n violet: 0xee82ee,\n wheat: 0xf5deb3,\n white: 0xffffff,\n whitesmoke: 0xf5f5f5,\n yellow: 0xffff00,\n yellowgreen: 0x9acd32\n};\n\ndefine(Color, color, {\n displayable: function() {\n return this.rgb().displayable();\n },\n toString: function() {\n return this.rgb() + \"\";\n }\n});\n\nfunction color(format) {\n var m;\n format = (format + \"\").trim().toLowerCase();\n return (m = reHex3.exec(format)) ? (m = parseInt(m[1], 16), new Rgb((m >> 8 & 0xf) | (m >> 4 & 0x0f0), (m >> 4 & 0xf) | (m & 0xf0), ((m & 0xf) << 4) | (m & 0xf), 1)) // #f00\n : (m = reHex6.exec(format)) ? rgbn(parseInt(m[1], 16)) // #ff0000\n : (m = reRgbInteger.exec(format)) ? new Rgb(m[1], m[2], m[3], 1) // rgb(255, 0, 0)\n : (m = reRgbPercent.exec(format)) ? new Rgb(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) // rgb(100%, 0%, 0%)\n : (m = reRgbaInteger.exec(format)) ? rgba(m[1], m[2], m[3], m[4]) // rgba(255, 0, 0, 1)\n : (m = reRgbaPercent.exec(format)) ? rgba(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) // rgb(100%, 0%, 0%, 1)\n : (m = reHslPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) // hsl(120, 50%, 50%)\n : (m = reHslaPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) // hsla(120, 50%, 50%, 1)\n : named.hasOwnProperty(format) ? rgbn(named[format])\n : format === \"transparent\" ? new Rgb(NaN, NaN, NaN, 0)\n : null;\n}\n\nfunction rgbn(n) {\n return new Rgb(n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff, 1);\n}\n\nfunction rgba(r, g, b, a) {\n if (a <= 0) r = g = b = NaN;\n return new Rgb(r, g, b, a);\n}\n\nfunction rgbConvert(o) {\n if (!(o instanceof Color)) o = color(o);\n if (!o) return new Rgb;\n o = o.rgb();\n return new Rgb(o.r, o.g, o.b, o.opacity);\n}\n\nfunction rgb(r, g, b, opacity) {\n return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity);\n}\n\nfunction Rgb(r, g, b, opacity) {\n this.r = +r;\n this.g = +g;\n this.b = +b;\n this.opacity = +opacity;\n}\n\ndefine(Rgb, rgb, extend(Color, {\n brighter: function(k) {\n k = k == null ? brighter : Math.pow(brighter, k);\n return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);\n },\n darker: function(k) {\n k = k == null ? darker : Math.pow(darker, k);\n return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);\n },\n rgb: function() {\n return this;\n },\n displayable: function() {\n return (0 <= this.r && this.r <= 255)\n && (0 <= this.g && this.g <= 255)\n && (0 <= this.b && this.b <= 255)\n && (0 <= this.opacity && this.opacity <= 1);\n },\n toString: function() {\n var a = this.opacity; a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a));\n return (a === 1 ? \"rgb(\" : \"rgba(\")\n + Math.max(0, Math.min(255, Math.round(this.r) || 0)) + \", \"\n + Math.max(0, Math.min(255, Math.round(this.g) || 0)) + \", \"\n + Math.max(0, Math.min(255, Math.round(this.b) || 0))\n + (a === 1 ? \")\" : \", \" + a + \")\");\n }\n}));\n\nfunction hsla(h, s, l, a) {\n if (a <= 0) h = s = l = NaN;\n else if (l <= 0 || l >= 1) h = s = NaN;\n else if (s <= 0) h = NaN;\n return new Hsl(h, s, l, a);\n}\n\nfunction hslConvert(o) {\n if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity);\n if (!(o instanceof Color)) o = color(o);\n if (!o) return new Hsl;\n if (o instanceof Hsl) return o;\n o = o.rgb();\n var r = o.r / 255,\n g = o.g / 255,\n b = o.b / 255,\n min = Math.min(r, g, b),\n max = Math.max(r, g, b),\n h = NaN,\n s = max - min,\n l = (max + min) / 2;\n if (s) {\n if (r === max) h = (g - b) / s + (g < b) * 6;\n else if (g === max) h = (b - r) / s + 2;\n else h = (r - g) / s + 4;\n s /= l < 0.5 ? max + min : 2 - max - min;\n h *= 60;\n } else {\n s = l > 0 && l < 1 ? 0 : h;\n }\n return new Hsl(h, s, l, o.opacity);\n}\n\nfunction hsl(h, s, l, opacity) {\n return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity);\n}\n\nfunction Hsl(h, s, l, opacity) {\n this.h = +h;\n this.s = +s;\n this.l = +l;\n this.opacity = +opacity;\n}\n\ndefine(Hsl, hsl, extend(Color, {\n brighter: function(k) {\n k = k == null ? brighter : Math.pow(brighter, k);\n return new Hsl(this.h, this.s, this.l * k, this.opacity);\n },\n darker: function(k) {\n k = k == null ? darker : Math.pow(darker, k);\n return new Hsl(this.h, this.s, this.l * k, this.opacity);\n },\n rgb: function() {\n var h = this.h % 360 + (this.h < 0) * 360,\n s = isNaN(h) || isNaN(this.s) ? 0 : this.s,\n l = this.l,\n m2 = l + (l < 0.5 ? l : 1 - l) * s,\n m1 = 2 * l - m2;\n return new Rgb(\n hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2),\n hsl2rgb(h, m1, m2),\n hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2),\n this.opacity\n );\n },\n displayable: function() {\n return (0 <= this.s && this.s <= 1 || isNaN(this.s))\n && (0 <= this.l && this.l <= 1)\n && (0 <= this.opacity && this.opacity <= 1);\n }\n}));\n\n/* From FvD 13.37, CSS Color Module Level 3 */\nfunction hsl2rgb(h, m1, m2) {\n return (h < 60 ? m1 + (m2 - m1) * h / 60\n : h < 180 ? m2\n : h < 240 ? m1 + (m2 - m1) * (240 - h) / 60\n : m1) * 255;\n}\n\nvar deg2rad = Math.PI / 180;\nvar rad2deg = 180 / Math.PI;\n\nvar Kn = 18;\nvar Xn = 0.950470;\nvar Yn = 1;\nvar Zn = 1.088830;\nvar t0 = 4 / 29;\nvar t1 = 6 / 29;\nvar t2 = 3 * t1 * t1;\nvar t3 = t1 * t1 * t1;\n\nfunction labConvert(o) {\n if (o instanceof Lab) return new Lab(o.l, o.a, o.b, o.opacity);\n if (o instanceof Hcl) {\n var h = o.h * deg2rad;\n return new Lab(o.l, Math.cos(h) * o.c, Math.sin(h) * o.c, o.opacity);\n }\n if (!(o instanceof Rgb)) o = rgbConvert(o);\n var b = rgb2xyz(o.r),\n a = rgb2xyz(o.g),\n l = rgb2xyz(o.b),\n x = xyz2lab((0.4124564 * b + 0.3575761 * a + 0.1804375 * l) / Xn),\n y = xyz2lab((0.2126729 * b + 0.7151522 * a + 0.0721750 * l) / Yn),\n z = xyz2lab((0.0193339 * b + 0.1191920 * a + 0.9503041 * l) / Zn);\n return new Lab(116 * y - 16, 500 * (x - y), 200 * (y - z), o.opacity);\n}\n\nfunction lab(l, a, b, opacity) {\n return arguments.length === 1 ? labConvert(l) : new Lab(l, a, b, opacity == null ? 1 : opacity);\n}\n\nfunction Lab(l, a, b, opacity) {\n this.l = +l;\n this.a = +a;\n this.b = +b;\n this.opacity = +opacity;\n}\n\ndefine(Lab, lab, extend(Color, {\n brighter: function(k) {\n return new Lab(this.l + Kn * (k == null ? 1 : k), this.a, this.b, this.opacity);\n },\n darker: function(k) {\n return new Lab(this.l - Kn * (k == null ? 1 : k), this.a, this.b, this.opacity);\n },\n rgb: function() {\n var y = (this.l + 16) / 116,\n x = isNaN(this.a) ? y : y + this.a / 500,\n z = isNaN(this.b) ? y : y - this.b / 200;\n y = Yn * lab2xyz(y);\n x = Xn * lab2xyz(x);\n z = Zn * lab2xyz(z);\n return new Rgb(\n xyz2rgb( 3.2404542 * x - 1.5371385 * y - 0.4985314 * z), // D65 -> sRGB\n xyz2rgb(-0.9692660 * x + 1.8760108 * y + 0.0415560 * z),\n xyz2rgb( 0.0556434 * x - 0.2040259 * y + 1.0572252 * z),\n this.opacity\n );\n }\n}));\n\nfunction xyz2lab(t) {\n return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0;\n}\n\nfunction lab2xyz(t) {\n return t > t1 ? t * t * t : t2 * (t - t0);\n}\n\nfunction xyz2rgb(x) {\n return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055);\n}\n\nfunction rgb2xyz(x) {\n return (x /= 255) <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4);\n}\n\nfunction hclConvert(o) {\n if (o instanceof Hcl) return new Hcl(o.h, o.c, o.l, o.opacity);\n if (!(o instanceof Lab)) o = labConvert(o);\n var h = Math.atan2(o.b, o.a) * rad2deg;\n return new Hcl(h < 0 ? h + 360 : h, Math.sqrt(o.a * o.a + o.b * o.b), o.l, o.opacity);\n}\n\nfunction hcl(h, c, l, opacity) {\n return arguments.length === 1 ? hclConvert(h) : new Hcl(h, c, l, opacity == null ? 1 : opacity);\n}\n\nfunction Hcl(h, c, l, opacity) {\n this.h = +h;\n this.c = +c;\n this.l = +l;\n this.opacity = +opacity;\n}\n\ndefine(Hcl, hcl, extend(Color, {\n brighter: function(k) {\n return new Hcl(this.h, this.c, this.l + Kn * (k == null ? 1 : k), this.opacity);\n },\n darker: function(k) {\n return new Hcl(this.h, this.c, this.l - Kn * (k == null ? 1 : k), this.opacity);\n },\n rgb: function() {\n return labConvert(this).rgb();\n }\n}));\n\nvar A = -0.14861;\nvar B = +1.78277;\nvar C = -0.29227;\nvar D = -0.90649;\nvar E = +1.97294;\nvar ED = E * D;\nvar EB = E * B;\nvar BC_DA = B * C - D * A;\n\nfunction cubehelixConvert(o) {\n if (o instanceof Cubehelix) return new Cubehelix(o.h, o.s, o.l, o.opacity);\n if (!(o instanceof Rgb)) o = rgbConvert(o);\n var r = o.r / 255,\n g = o.g / 255,\n b = o.b / 255,\n l = (BC_DA * b + ED * r - EB * g) / (BC_DA + ED - EB),\n bl = b - l,\n k = (E * (g - l) - C * bl) / D,\n s = Math.sqrt(k * k + bl * bl) / (E * l * (1 - l)), // NaN if l=0 or l=1\n h = s ? Math.atan2(k, bl) * rad2deg - 120 : NaN;\n return new Cubehelix(h < 0 ? h + 360 : h, s, l, o.opacity);\n}\n\nfunction cubehelix(h, s, l, opacity) {\n return arguments.length === 1 ? cubehelixConvert(h) : new Cubehelix(h, s, l, opacity == null ? 1 : opacity);\n}\n\nfunction Cubehelix(h, s, l, opacity) {\n this.h = +h;\n this.s = +s;\n this.l = +l;\n this.opacity = +opacity;\n}\n\ndefine(Cubehelix, cubehelix, extend(Color, {\n brighter: function(k) {\n k = k == null ? brighter : Math.pow(brighter, k);\n return new Cubehelix(this.h, this.s, this.l * k, this.opacity);\n },\n darker: function(k) {\n k = k == null ? darker : Math.pow(darker, k);\n return new Cubehelix(this.h, this.s, this.l * k, this.opacity);\n },\n rgb: function() {\n var h = isNaN(this.h) ? 0 : (this.h + 120) * deg2rad,\n l = +this.l,\n a = isNaN(this.s) ? 0 : this.s * l * (1 - l),\n cosh = Math.cos(h),\n sinh = Math.sin(h);\n return new Rgb(\n 255 * (l + a * (A * cosh + B * sinh)),\n 255 * (l + a * (C * cosh + D * sinh)),\n 255 * (l + a * (E * cosh)),\n this.opacity\n );\n }\n}));\n\nfunction basis(t1, v0, v1, v2, v3) {\n var t2 = t1 * t1, t3 = t2 * t1;\n return ((1 - 3 * t1 + 3 * t2 - t3) * v0\n + (4 - 6 * t2 + 3 * t3) * v1\n + (1 + 3 * t1 + 3 * t2 - 3 * t3) * v2\n + t3 * v3) / 6;\n}\n\nvar basis$1 = function(values) {\n var n = values.length - 1;\n return function(t) {\n var i = t <= 0 ? (t = 0) : t >= 1 ? (t = 1, n - 1) : Math.floor(t * n),\n v1 = values[i],\n v2 = values[i + 1],\n v0 = i > 0 ? values[i - 1] : 2 * v1 - v2,\n v3 = i < n - 1 ? values[i + 2] : 2 * v2 - v1;\n return basis((t - i / n) * n, v0, v1, v2, v3);\n };\n};\n\nvar basisClosed = function(values) {\n var n = values.length;\n return function(t) {\n var i = Math.floor(((t %= 1) < 0 ? ++t : t) * n),\n v0 = values[(i + n - 1) % n],\n v1 = values[i % n],\n v2 = values[(i + 1) % n],\n v3 = values[(i + 2) % n];\n return basis((t - i / n) * n, v0, v1, v2, v3);\n };\n};\n\nvar constant$3 = function(x) {\n return function() {\n return x;\n };\n};\n\nfunction linear(a, d) {\n return function(t) {\n return a + t * d;\n };\n}\n\nfunction exponential(a, b, y) {\n return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function(t) {\n return Math.pow(a + t * b, y);\n };\n}\n\nfunction hue(a, b) {\n var d = b - a;\n return d ? linear(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : constant$3(isNaN(a) ? b : a);\n}\n\nfunction gamma(y) {\n return (y = +y) === 1 ? nogamma : function(a, b) {\n return b - a ? exponential(a, b, y) : constant$3(isNaN(a) ? b : a);\n };\n}\n\nfunction nogamma(a, b) {\n var d = b - a;\n return d ? linear(a, d) : constant$3(isNaN(a) ? b : a);\n}\n\nvar interpolateRgb = ((function rgbGamma(y) {\n var color$$1 = gamma(y);\n\n function rgb$$1(start, end) {\n var r = color$$1((start = rgb(start)).r, (end = rgb(end)).r),\n g = color$$1(start.g, end.g),\n b = color$$1(start.b, end.b),\n opacity = nogamma(start.opacity, end.opacity);\n return function(t) {\n start.r = r(t);\n start.g = g(t);\n start.b = b(t);\n start.opacity = opacity(t);\n return start + \"\";\n };\n }\n\n rgb$$1.gamma = rgbGamma;\n\n return rgb$$1;\n}))(1);\n\nfunction rgbSpline(spline) {\n return function(colors) {\n var n = colors.length,\n r = new Array(n),\n g = new Array(n),\n b = new Array(n),\n i, color$$1;\n for (i = 0; i < n; ++i) {\n color$$1 = rgb(colors[i]);\n r[i] = color$$1.r || 0;\n g[i] = color$$1.g || 0;\n b[i] = color$$1.b || 0;\n }\n r = spline(r);\n g = spline(g);\n b = spline(b);\n color$$1.opacity = 1;\n return function(t) {\n color$$1.r = r(t);\n color$$1.g = g(t);\n color$$1.b = b(t);\n return color$$1 + \"\";\n };\n };\n}\n\nvar rgbBasis = rgbSpline(basis$1);\nvar rgbBasisClosed = rgbSpline(basisClosed);\n\nvar array$1 = function(a, b) {\n var nb = b ? b.length : 0,\n na = a ? Math.min(nb, a.length) : 0,\n x = new Array(nb),\n c = new Array(nb),\n i;\n\n for (i = 0; i < na; ++i) x[i] = interpolateValue(a[i], b[i]);\n for (; i < nb; ++i) c[i] = b[i];\n\n return function(t) {\n for (i = 0; i < na; ++i) c[i] = x[i](t);\n return c;\n };\n};\n\nvar date = function(a, b) {\n var d = new Date;\n return a = +a, b -= a, function(t) {\n return d.setTime(a + b * t), d;\n };\n};\n\nvar reinterpolate = function(a, b) {\n return a = +a, b -= a, function(t) {\n return a + b * t;\n };\n};\n\nvar object = function(a, b) {\n var i = {},\n c = {},\n k;\n\n if (a === null || typeof a !== \"object\") a = {};\n if (b === null || typeof b !== \"object\") b = {};\n\n for (k in b) {\n if (k in a) {\n i[k] = interpolateValue(a[k], b[k]);\n } else {\n c[k] = b[k];\n }\n }\n\n return function(t) {\n for (k in i) c[k] = i[k](t);\n return c;\n };\n};\n\nvar reA = /[-+]?(?:\\d+\\.?\\d*|\\.?\\d+)(?:[eE][-+]?\\d+)?/g;\nvar reB = new RegExp(reA.source, \"g\");\n\nfunction zero(b) {\n return function() {\n return b;\n };\n}\n\nfunction one(b) {\n return function(t) {\n return b(t) + \"\";\n };\n}\n\nvar interpolateString = function(a, b) {\n var bi = reA.lastIndex = reB.lastIndex = 0, // scan index for next number in b\n am, // current match in a\n bm, // current match in b\n bs, // string preceding current number in b, if any\n i = -1, // index in s\n s = [], // string constants and placeholders\n q = []; // number interpolators\n\n // Coerce inputs to strings.\n a = a + \"\", b = b + \"\";\n\n // Interpolate pairs of numbers in a & b.\n while ((am = reA.exec(a))\n && (bm = reB.exec(b))) {\n if ((bs = bm.index) > bi) { // a string precedes the next number in b\n bs = b.slice(bi, bs);\n if (s[i]) s[i] += bs; // coalesce with previous string\n else s[++i] = bs;\n }\n if ((am = am[0]) === (bm = bm[0])) { // numbers in a & b match\n if (s[i]) s[i] += bm; // coalesce with previous string\n else s[++i] = bm;\n } else { // interpolate non-matching numbers\n s[++i] = null;\n q.push({i: i, x: reinterpolate(am, bm)});\n }\n bi = reB.lastIndex;\n }\n\n // Add remains of b.\n if (bi < b.length) {\n bs = b.slice(bi);\n if (s[i]) s[i] += bs; // coalesce with previous string\n else s[++i] = bs;\n }\n\n // Special optimization for only a single match.\n // Otherwise, interpolate each of the numbers and rejoin the string.\n return s.length < 2 ? (q[0]\n ? one(q[0].x)\n : zero(b))\n : (b = q.length, function(t) {\n for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t);\n return s.join(\"\");\n });\n};\n\nvar interpolateValue = function(a, b) {\n var t = typeof b, c;\n return b == null || t === \"boolean\" ? constant$3(b)\n : (t === \"number\" ? reinterpolate\n : t === \"string\" ? ((c = color(b)) ? (b = c, interpolateRgb) : interpolateString)\n : b instanceof color ? interpolateRgb\n : b instanceof Date ? date\n : Array.isArray(b) ? array$1\n : isNaN(b) ? object\n : reinterpolate)(a, b);\n};\n\nvar interpolateRound = function(a, b) {\n return a = +a, b -= a, function(t) {\n return Math.round(a + b * t);\n };\n};\n\nvar degrees = 180 / Math.PI;\n\nvar identity$2 = {\n translateX: 0,\n translateY: 0,\n rotate: 0,\n skewX: 0,\n scaleX: 1,\n scaleY: 1\n};\n\nvar decompose = function(a, b, c, d, e, f) {\n var scaleX, scaleY, skewX;\n if (scaleX = Math.sqrt(a * a + b * b)) a /= scaleX, b /= scaleX;\n if (skewX = a * c + b * d) c -= a * skewX, d -= b * skewX;\n if (scaleY = Math.sqrt(c * c + d * d)) c /= scaleY, d /= scaleY, skewX /= scaleY;\n if (a * d < b * c) a = -a, b = -b, skewX = -skewX, scaleX = -scaleX;\n return {\n translateX: e,\n translateY: f,\n rotate: Math.atan2(b, a) * degrees,\n skewX: Math.atan(skewX) * degrees,\n scaleX: scaleX,\n scaleY: scaleY\n };\n};\n\nvar cssNode;\nvar cssRoot;\nvar cssView;\nvar svgNode;\n\nfunction parseCss(value) {\n if (value === \"none\") return identity$2;\n if (!cssNode) cssNode = document.createElement(\"DIV\"), cssRoot = document.documentElement, cssView = document.defaultView;\n cssNode.style.transform = value;\n value = cssView.getComputedStyle(cssRoot.appendChild(cssNode), null).getPropertyValue(\"transform\");\n cssRoot.removeChild(cssNode);\n value = value.slice(7, -1).split(\",\");\n return decompose(+value[0], +value[1], +value[2], +value[3], +value[4], +value[5]);\n}\n\nfunction parseSvg(value) {\n if (value == null) return identity$2;\n if (!svgNode) svgNode = document.createElementNS(\"http://www.w3.org/2000/svg\", \"g\");\n svgNode.setAttribute(\"transform\", value);\n if (!(value = svgNode.transform.baseVal.consolidate())) return identity$2;\n value = value.matrix;\n return decompose(value.a, value.b, value.c, value.d, value.e, value.f);\n}\n\nfunction interpolateTransform(parse, pxComma, pxParen, degParen) {\n\n function pop(s) {\n return s.length ? s.pop() + \" \" : \"\";\n }\n\n function translate(xa, ya, xb, yb, s, q) {\n if (xa !== xb || ya !== yb) {\n var i = s.push(\"translate(\", null, pxComma, null, pxParen);\n q.push({i: i - 4, x: reinterpolate(xa, xb)}, {i: i - 2, x: reinterpolate(ya, yb)});\n } else if (xb || yb) {\n s.push(\"translate(\" + xb + pxComma + yb + pxParen);\n }\n }\n\n function rotate(a, b, s, q) {\n if (a !== b) {\n if (a - b > 180) b += 360; else if (b - a > 180) a += 360; // shortest path\n q.push({i: s.push(pop(s) + \"rotate(\", null, degParen) - 2, x: reinterpolate(a, b)});\n } else if (b) {\n s.push(pop(s) + \"rotate(\" + b + degParen);\n }\n }\n\n function skewX(a, b, s, q) {\n if (a !== b) {\n q.push({i: s.push(pop(s) + \"skewX(\", null, degParen) - 2, x: reinterpolate(a, b)});\n } else if (b) {\n s.push(pop(s) + \"skewX(\" + b + degParen);\n }\n }\n\n function scale(xa, ya, xb, yb, s, q) {\n if (xa !== xb || ya !== yb) {\n var i = s.push(pop(s) + \"scale(\", null, \",\", null, \")\");\n q.push({i: i - 4, x: reinterpolate(xa, xb)}, {i: i - 2, x: reinterpolate(ya, yb)});\n } else if (xb !== 1 || yb !== 1) {\n s.push(pop(s) + \"scale(\" + xb + \",\" + yb + \")\");\n }\n }\n\n return function(a, b) {\n var s = [], // string constants and placeholders\n q = []; // number interpolators\n a = parse(a), b = parse(b);\n translate(a.translateX, a.translateY, b.translateX, b.translateY, s, q);\n rotate(a.rotate, b.rotate, s, q);\n skewX(a.skewX, b.skewX, s, q);\n scale(a.scaleX, a.scaleY, b.scaleX, b.scaleY, s, q);\n a = b = null; // gc\n return function(t) {\n var i = -1, n = q.length, o;\n while (++i < n) s[(o = q[i]).i] = o.x(t);\n return s.join(\"\");\n };\n };\n}\n\nvar interpolateTransformCss = interpolateTransform(parseCss, \"px, \", \"px)\", \"deg)\");\nvar interpolateTransformSvg = interpolateTransform(parseSvg, \", \", \")\", \")\");\n\nvar rho = Math.SQRT2;\nvar rho2 = 2;\nvar rho4 = 4;\nvar epsilon2 = 1e-12;\n\nfunction cosh(x) {\n return ((x = Math.exp(x)) + 1 / x) / 2;\n}\n\nfunction sinh(x) {\n return ((x = Math.exp(x)) - 1 / x) / 2;\n}\n\nfunction tanh(x) {\n return ((x = Math.exp(2 * x)) - 1) / (x + 1);\n}\n\n// p0 = [ux0, uy0, w0]\n// p1 = [ux1, uy1, w1]\nvar interpolateZoom = function(p0, p1) {\n var ux0 = p0[0], uy0 = p0[1], w0 = p0[2],\n ux1 = p1[0], uy1 = p1[1], w1 = p1[2],\n dx = ux1 - ux0,\n dy = uy1 - uy0,\n d2 = dx * dx + dy * dy,\n i,\n S;\n\n // Special case for u0 ≅ u1.\n if (d2 < epsilon2) {\n S = Math.log(w1 / w0) / rho;\n i = function(t) {\n return [\n ux0 + t * dx,\n uy0 + t * dy,\n w0 * Math.exp(rho * t * S)\n ];\n };\n }\n\n // General case.\n else {\n var d1 = Math.sqrt(d2),\n b0 = (w1 * w1 - w0 * w0 + rho4 * d2) / (2 * w0 * rho2 * d1),\n b1 = (w1 * w1 - w0 * w0 - rho4 * d2) / (2 * w1 * rho2 * d1),\n r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0),\n r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1);\n S = (r1 - r0) / rho;\n i = function(t) {\n var s = t * S,\n coshr0 = cosh(r0),\n u = w0 / (rho2 * d1) * (coshr0 * tanh(rho * s + r0) - sinh(r0));\n return [\n ux0 + u * dx,\n uy0 + u * dy,\n w0 * coshr0 / cosh(rho * s + r0)\n ];\n };\n }\n\n i.duration = S * 1000;\n\n return i;\n};\n\nfunction hsl$1(hue$$1) {\n return function(start, end) {\n var h = hue$$1((start = hsl(start)).h, (end = hsl(end)).h),\n s = nogamma(start.s, end.s),\n l = nogamma(start.l, end.l),\n opacity = nogamma(start.opacity, end.opacity);\n return function(t) {\n start.h = h(t);\n start.s = s(t);\n start.l = l(t);\n start.opacity = opacity(t);\n return start + \"\";\n };\n }\n}\n\nvar hsl$2 = hsl$1(hue);\nvar hslLong = hsl$1(nogamma);\n\nfunction lab$1(start, end) {\n var l = nogamma((start = lab(start)).l, (end = lab(end)).l),\n a = nogamma(start.a, end.a),\n b = nogamma(start.b, end.b),\n opacity = nogamma(start.opacity, end.opacity);\n return function(t) {\n start.l = l(t);\n start.a = a(t);\n start.b = b(t);\n start.opacity = opacity(t);\n return start + \"\";\n };\n}\n\nfunction hcl$1(hue$$1) {\n return function(start, end) {\n var h = hue$$1((start = hcl(start)).h, (end = hcl(end)).h),\n c = nogamma(start.c, end.c),\n l = nogamma(start.l, end.l),\n opacity = nogamma(start.opacity, end.opacity);\n return function(t) {\n start.h = h(t);\n start.c = c(t);\n start.l = l(t);\n start.opacity = opacity(t);\n return start + \"\";\n };\n }\n}\n\nvar hcl$2 = hcl$1(hue);\nvar hclLong = hcl$1(nogamma);\n\nfunction cubehelix$1(hue$$1) {\n return (function cubehelixGamma(y) {\n y = +y;\n\n function cubehelix$$1(start, end) {\n var h = hue$$1((start = cubehelix(start)).h, (end = cubehelix(end)).h),\n s = nogamma(start.s, end.s),\n l = nogamma(start.l, end.l),\n opacity = nogamma(start.opacity, end.opacity);\n return function(t) {\n start.h = h(t);\n start.s = s(t);\n start.l = l(Math.pow(t, y));\n start.opacity = opacity(t);\n return start + \"\";\n };\n }\n\n cubehelix$$1.gamma = cubehelixGamma;\n\n return cubehelix$$1;\n })(1);\n}\n\nvar cubehelix$2 = cubehelix$1(hue);\nvar cubehelixLong = cubehelix$1(nogamma);\n\nvar quantize = function(interpolator, n) {\n var samples = new Array(n);\n for (var i = 0; i < n; ++i) samples[i] = interpolator(i / (n - 1));\n return samples;\n};\n\nvar frame = 0;\nvar timeout = 0;\nvar interval = 0;\nvar pokeDelay = 1000;\nvar taskHead;\nvar taskTail;\nvar clockLast = 0;\nvar clockNow = 0;\nvar clockSkew = 0;\nvar clock = typeof performance === \"object\" && performance.now ? performance : Date;\nvar setFrame = typeof requestAnimationFrame === \"function\" ? requestAnimationFrame : function(f) { setTimeout(f, 17); };\n\nfunction now() {\n return clockNow || (setFrame(clearNow), clockNow = clock.now() + clockSkew);\n}\n\nfunction clearNow() {\n clockNow = 0;\n}\n\nfunction Timer() {\n this._call =\n this._time =\n this._next = null;\n}\n\nTimer.prototype = timer.prototype = {\n constructor: Timer,\n restart: function(callback, delay, time) {\n if (typeof callback !== \"function\") throw new TypeError(\"callback is not a function\");\n time = (time == null ? now() : +time) + (delay == null ? 0 : +delay);\n if (!this._next && taskTail !== this) {\n if (taskTail) taskTail._next = this;\n else taskHead = this;\n taskTail = this;\n }\n this._call = callback;\n this._time = time;\n sleep();\n },\n stop: function() {\n if (this._call) {\n this._call = null;\n this._time = Infinity;\n sleep();\n }\n }\n};\n\nfunction timer(callback, delay, time) {\n var t = new Timer;\n t.restart(callback, delay, time);\n return t;\n}\n\nfunction timerFlush() {\n now(); // Get the current time, if not already set.\n ++frame; // Pretend we’ve set an alarm, if we haven’t already.\n var t = taskHead, e;\n while (t) {\n if ((e = clockNow - t._time) >= 0) t._call.call(null, e);\n t = t._next;\n }\n --frame;\n}\n\nfunction wake() {\n clockNow = (clockLast = clock.now()) + clockSkew;\n frame = timeout = 0;\n try {\n timerFlush();\n } finally {\n frame = 0;\n nap();\n clockNow = 0;\n }\n}\n\nfunction poke() {\n var now = clock.now(), delay = now - clockLast;\n if (delay > pokeDelay) clockSkew -= delay, clockLast = now;\n}\n\nfunction nap() {\n var t0, t1 = taskHead, t2, time = Infinity;\n while (t1) {\n if (t1._call) {\n if (time > t1._time) time = t1._time;\n t0 = t1, t1 = t1._next;\n } else {\n t2 = t1._next, t1._next = null;\n t1 = t0 ? t0._next = t2 : taskHead = t2;\n }\n }\n taskTail = t0;\n sleep(time);\n}\n\nfunction sleep(time) {\n if (frame) return; // Soonest alarm already set, or will be.\n if (timeout) timeout = clearTimeout(timeout);\n var delay = time - clockNow;\n if (delay > 24) {\n if (time < Infinity) timeout = setTimeout(wake, delay);\n if (interval) interval = clearInterval(interval);\n } else {\n if (!interval) clockLast = clockNow, interval = setInterval(poke, pokeDelay);\n frame = 1, setFrame(wake);\n }\n}\n\nvar timeout$1 = function(callback, delay, time) {\n var t = new Timer;\n delay = delay == null ? 0 : +delay;\n t.restart(function(elapsed) {\n t.stop();\n callback(elapsed + delay);\n }, delay, time);\n return t;\n};\n\nvar interval$1 = function(callback, delay, time) {\n var t = new Timer, total = delay;\n if (delay == null) return t.restart(callback, delay, time), t;\n delay = +delay, time = time == null ? now() : +time;\n t.restart(function tick(elapsed) {\n elapsed += total;\n t.restart(tick, total += delay, time);\n callback(elapsed);\n }, delay, time);\n return t;\n};\n\nvar emptyOn = dispatch(\"start\", \"end\", \"interrupt\");\nvar emptyTween = [];\n\nvar CREATED = 0;\nvar SCHEDULED = 1;\nvar STARTING = 2;\nvar STARTED = 3;\nvar RUNNING = 4;\nvar ENDING = 5;\nvar ENDED = 6;\n\nvar schedule = function(node, name, id, index, group, timing) {\n var schedules = node.__transition;\n if (!schedules) node.__transition = {};\n else if (id in schedules) return;\n create(node, id, {\n name: name,\n index: index, // For context during callback.\n group: group, // For context during callback.\n on: emptyOn,\n tween: emptyTween,\n time: timing.time,\n delay: timing.delay,\n duration: timing.duration,\n ease: timing.ease,\n timer: null,\n state: CREATED\n });\n};\n\nfunction init(node, id) {\n var schedule = node.__transition;\n if (!schedule || !(schedule = schedule[id]) || schedule.state > CREATED) throw new Error(\"too late\");\n return schedule;\n}\n\nfunction set$1(node, id) {\n var schedule = node.__transition;\n if (!schedule || !(schedule = schedule[id]) || schedule.state > STARTING) throw new Error(\"too late\");\n return schedule;\n}\n\nfunction get$1(node, id) {\n var schedule = node.__transition;\n if (!schedule || !(schedule = schedule[id])) throw new Error(\"too late\");\n return schedule;\n}\n\nfunction create(node, id, self) {\n var schedules = node.__transition,\n tween;\n\n // Initialize the self timer when the transition is created.\n // Note the actual delay is not known until the first callback!\n schedules[id] = self;\n self.timer = timer(schedule, 0, self.time);\n\n function schedule(elapsed) {\n self.state = SCHEDULED;\n self.timer.restart(start, self.delay, self.time);\n\n // If the elapsed delay is less than our first sleep, start immediately.\n if (self.delay <= elapsed) start(elapsed - self.delay);\n }\n\n function start(elapsed) {\n var i, j, n, o;\n\n // If the state is not SCHEDULED, then we previously errored on start.\n if (self.state !== SCHEDULED) return stop();\n\n for (i in schedules) {\n o = schedules[i];\n if (o.name !== self.name) continue;\n\n // While this element already has a starting transition during this frame,\n // defer starting an interrupting transition until that transition has a\n // chance to tick (and possibly end); see d3/d3-transition#54!\n if (o.state === STARTED) return timeout$1(start);\n\n // Interrupt the active transition, if any.\n // Dispatch the interrupt event.\n if (o.state === RUNNING) {\n o.state = ENDED;\n o.timer.stop();\n o.on.call(\"interrupt\", node, node.__data__, o.index, o.group);\n delete schedules[i];\n }\n\n // Cancel any pre-empted transitions. No interrupt event is dispatched\n // because the cancelled transitions never started. Note that this also\n // removes this transition from the pending list!\n else if (+i < id) {\n o.state = ENDED;\n o.timer.stop();\n delete schedules[i];\n }\n }\n\n // Defer the first tick to end of the current frame; see d3/d3#1576.\n // Note the transition may be canceled after start and before the first tick!\n // Note this must be scheduled before the start event; see d3/d3-transition#16!\n // Assuming this is successful, subsequent callbacks go straight to tick.\n timeout$1(function() {\n if (self.state === STARTED) {\n self.state = RUNNING;\n self.timer.restart(tick, self.delay, self.time);\n tick(elapsed);\n }\n });\n\n // Dispatch the start event.\n // Note this must be done before the tween are initialized.\n self.state = STARTING;\n self.on.call(\"start\", node, node.__data__, self.index, self.group);\n if (self.state !== STARTING) return; // interrupted\n self.state = STARTED;\n\n // Initialize the tween, deleting null tween.\n tween = new Array(n = self.tween.length);\n for (i = 0, j = -1; i < n; ++i) {\n if (o = self.tween[i].value.call(node, node.__data__, self.index, self.group)) {\n tween[++j] = o;\n }\n }\n tween.length = j + 1;\n }\n\n function tick(elapsed) {\n var t = elapsed < self.duration ? self.ease.call(null, elapsed / self.duration) : (self.timer.restart(stop), self.state = ENDING, 1),\n i = -1,\n n = tween.length;\n\n while (++i < n) {\n tween[i].call(null, t);\n }\n\n // Dispatch the end event.\n if (self.state === ENDING) {\n self.on.call(\"end\", node, node.__data__, self.index, self.group);\n stop();\n }\n }\n\n function stop() {\n self.state = ENDED;\n self.timer.stop();\n delete schedules[id];\n for (var i in schedules) return; // eslint-disable-line no-unused-vars\n delete node.__transition;\n }\n}\n\nvar interrupt = function(node, name) {\n var schedules = node.__transition,\n schedule,\n active,\n empty = true,\n i;\n\n if (!schedules) return;\n\n name = name == null ? null : name + \"\";\n\n for (i in schedules) {\n if ((schedule = schedules[i]).name !== name) { empty = false; continue; }\n active = schedule.state > STARTING && schedule.state < ENDING;\n schedule.state = ENDED;\n schedule.timer.stop();\n if (active) schedule.on.call(\"interrupt\", node, node.__data__, schedule.index, schedule.group);\n delete schedules[i];\n }\n\n if (empty) delete node.__transition;\n};\n\nvar selection_interrupt = function(name) {\n return this.each(function() {\n interrupt(this, name);\n });\n};\n\nfunction tweenRemove(id, name) {\n var tween0, tween1;\n return function() {\n var schedule = set$1(this, id),\n tween = schedule.tween;\n\n // If this node shared tween with the previous node,\n // just assign the updated shared tween and we’re done!\n // Otherwise, copy-on-write.\n if (tween !== tween0) {\n tween1 = tween0 = tween;\n for (var i = 0, n = tween1.length; i < n; ++i) {\n if (tween1[i].name === name) {\n tween1 = tween1.slice();\n tween1.splice(i, 1);\n break;\n }\n }\n }\n\n schedule.tween = tween1;\n };\n}\n\nfunction tweenFunction(id, name, value) {\n var tween0, tween1;\n if (typeof value !== \"function\") throw new Error;\n return function() {\n var schedule = set$1(this, id),\n tween = schedule.tween;\n\n // If this node shared tween with the previous node,\n // just assign the updated shared tween and we’re done!\n // Otherwise, copy-on-write.\n if (tween !== tween0) {\n tween1 = (tween0 = tween).slice();\n for (var t = {name: name, value: value}, i = 0, n = tween1.length; i < n; ++i) {\n if (tween1[i].name === name) {\n tween1[i] = t;\n break;\n }\n }\n if (i === n) tween1.push(t);\n }\n\n schedule.tween = tween1;\n };\n}\n\nvar transition_tween = function(name, value) {\n var id = this._id;\n\n name += \"\";\n\n if (arguments.length < 2) {\n var tween = get$1(this.node(), id).tween;\n for (var i = 0, n = tween.length, t; i < n; ++i) {\n if ((t = tween[i]).name === name) {\n return t.value;\n }\n }\n return null;\n }\n\n return this.each((value == null ? tweenRemove : tweenFunction)(id, name, value));\n};\n\nfunction tweenValue(transition, name, value) {\n var id = transition._id;\n\n transition.each(function() {\n var schedule = set$1(this, id);\n (schedule.value || (schedule.value = {}))[name] = value.apply(this, arguments);\n });\n\n return function(node) {\n return get$1(node, id).value[name];\n };\n}\n\nvar interpolate$$1 = function(a, b) {\n var c;\n return (typeof b === \"number\" ? reinterpolate\n : b instanceof color ? interpolateRgb\n : (c = color(b)) ? (b = c, interpolateRgb)\n : interpolateString)(a, b);\n};\n\nfunction attrRemove$1(name) {\n return function() {\n this.removeAttribute(name);\n };\n}\n\nfunction attrRemoveNS$1(fullname) {\n return function() {\n this.removeAttributeNS(fullname.space, fullname.local);\n };\n}\n\nfunction attrConstant$1(name, interpolate$$1, value1) {\n var value00,\n interpolate0;\n return function() {\n var value0 = this.getAttribute(name);\n return value0 === value1 ? null\n : value0 === value00 ? interpolate0\n : interpolate0 = interpolate$$1(value00 = value0, value1);\n };\n}\n\nfunction attrConstantNS$1(fullname, interpolate$$1, value1) {\n var value00,\n interpolate0;\n return function() {\n var value0 = this.getAttributeNS(fullname.space, fullname.local);\n return value0 === value1 ? null\n : value0 === value00 ? interpolate0\n : interpolate0 = interpolate$$1(value00 = value0, value1);\n };\n}\n\nfunction attrFunction$1(name, interpolate$$1, value) {\n var value00,\n value10,\n interpolate0;\n return function() {\n var value0, value1 = value(this);\n if (value1 == null) return void this.removeAttribute(name);\n value0 = this.getAttribute(name);\n return value0 === value1 ? null\n : value0 === value00 && value1 === value10 ? interpolate0\n : interpolate0 = interpolate$$1(value00 = value0, value10 = value1);\n };\n}\n\nfunction attrFunctionNS$1(fullname, interpolate$$1, value) {\n var value00,\n value10,\n interpolate0;\n return function() {\n var value0, value1 = value(this);\n if (value1 == null) return void this.removeAttributeNS(fullname.space, fullname.local);\n value0 = this.getAttributeNS(fullname.space, fullname.local);\n return value0 === value1 ? null\n : value0 === value00 && value1 === value10 ? interpolate0\n : interpolate0 = interpolate$$1(value00 = value0, value10 = value1);\n };\n}\n\nvar transition_attr = function(name, value) {\n var fullname = namespace(name), i = fullname === \"transform\" ? interpolateTransformSvg : interpolate$$1;\n return this.attrTween(name, typeof value === \"function\"\n ? (fullname.local ? attrFunctionNS$1 : attrFunction$1)(fullname, i, tweenValue(this, \"attr.\" + name, value))\n : value == null ? (fullname.local ? attrRemoveNS$1 : attrRemove$1)(fullname)\n : (fullname.local ? attrConstantNS$1 : attrConstant$1)(fullname, i, value));\n};\n\nfunction attrTweenNS(fullname, value) {\n function tween() {\n var node = this, i = value.apply(node, arguments);\n return i && function(t) {\n node.setAttributeNS(fullname.space, fullname.local, i(t));\n };\n }\n tween._value = value;\n return tween;\n}\n\nfunction attrTween(name, value) {\n function tween() {\n var node = this, i = value.apply(node, arguments);\n return i && function(t) {\n node.setAttribute(name, i(t));\n };\n }\n tween._value = value;\n return tween;\n}\n\nvar transition_attrTween = function(name, value) {\n var key = \"attr.\" + name;\n if (arguments.length < 2) return (key = this.tween(key)) && key._value;\n if (value == null) return this.tween(key, null);\n if (typeof value !== \"function\") throw new Error;\n var fullname = namespace(name);\n return this.tween(key, (fullname.local ? attrTweenNS : attrTween)(fullname, value));\n};\n\nfunction delayFunction(id, value) {\n return function() {\n init(this, id).delay = +value.apply(this, arguments);\n };\n}\n\nfunction delayConstant(id, value) {\n return value = +value, function() {\n init(this, id).delay = value;\n };\n}\n\nvar transition_delay = function(value) {\n var id = this._id;\n\n return arguments.length\n ? this.each((typeof value === \"function\"\n ? delayFunction\n : delayConstant)(id, value))\n : get$1(this.node(), id).delay;\n};\n\nfunction durationFunction(id, value) {\n return function() {\n set$1(this, id).duration = +value.apply(this, arguments);\n };\n}\n\nfunction durationConstant(id, value) {\n return value = +value, function() {\n set$1(this, id).duration = value;\n };\n}\n\nvar transition_duration = function(value) {\n var id = this._id;\n\n return arguments.length\n ? this.each((typeof value === \"function\"\n ? durationFunction\n : durationConstant)(id, value))\n : get$1(this.node(), id).duration;\n};\n\nfunction easeConstant(id, value) {\n if (typeof value !== \"function\") throw new Error;\n return function() {\n set$1(this, id).ease = value;\n };\n}\n\nvar transition_ease = function(value) {\n var id = this._id;\n\n return arguments.length\n ? this.each(easeConstant(id, value))\n : get$1(this.node(), id).ease;\n};\n\nvar transition_filter = function(match) {\n if (typeof match !== \"function\") match = matcher$1(match);\n\n for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {\n for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) {\n if ((node = group[i]) && match.call(node, node.__data__, i, group)) {\n subgroup.push(node);\n }\n }\n }\n\n return new Transition(subgroups, this._parents, this._name, this._id);\n};\n\nvar transition_merge = function(transition) {\n if (transition._id !== this._id) throw new Error;\n\n for (var groups0 = this._groups, groups1 = transition._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) {\n for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) {\n if (node = group0[i] || group1[i]) {\n merge[i] = node;\n }\n }\n }\n\n for (; j < m0; ++j) {\n merges[j] = groups0[j];\n }\n\n return new Transition(merges, this._parents, this._name, this._id);\n};\n\nfunction start(name) {\n return (name + \"\").trim().split(/^|\\s+/).every(function(t) {\n var i = t.indexOf(\".\");\n if (i >= 0) t = t.slice(0, i);\n return !t || t === \"start\";\n });\n}\n\nfunction onFunction(id, name, listener) {\n var on0, on1, sit = start(name) ? init : set$1;\n return function() {\n var schedule = sit(this, id),\n on = schedule.on;\n\n // If this node shared a dispatch with the previous node,\n // just assign the updated shared dispatch and we’re done!\n // Otherwise, copy-on-write.\n if (on !== on0) (on1 = (on0 = on).copy()).on(name, listener);\n\n schedule.on = on1;\n };\n}\n\nvar transition_on = function(name, listener) {\n var id = this._id;\n\n return arguments.length < 2\n ? get$1(this.node(), id).on.on(name)\n : this.each(onFunction(id, name, listener));\n};\n\nfunction removeFunction(id) {\n return function() {\n var parent = this.parentNode;\n for (var i in this.__transition) if (+i !== id) return;\n if (parent) parent.removeChild(this);\n };\n}\n\nvar transition_remove = function() {\n return this.on(\"end.remove\", removeFunction(this._id));\n};\n\nvar transition_select = function(select$$1) {\n var name = this._name,\n id = this._id;\n\n if (typeof select$$1 !== \"function\") select$$1 = selector(select$$1);\n\n for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {\n for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) {\n if ((node = group[i]) && (subnode = select$$1.call(node, node.__data__, i, group))) {\n if (\"__data__\" in node) subnode.__data__ = node.__data__;\n subgroup[i] = subnode;\n schedule(subgroup[i], name, id, i, subgroup, get$1(node, id));\n }\n }\n }\n\n return new Transition(subgroups, this._parents, name, id);\n};\n\nvar transition_selectAll = function(select$$1) {\n var name = this._name,\n id = this._id;\n\n if (typeof select$$1 !== \"function\") select$$1 = selectorAll(select$$1);\n\n for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) {\n for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {\n if (node = group[i]) {\n for (var children = select$$1.call(node, node.__data__, i, group), child, inherit = get$1(node, id), k = 0, l = children.length; k < l; ++k) {\n if (child = children[k]) {\n schedule(child, name, id, k, children, inherit);\n }\n }\n subgroups.push(children);\n parents.push(node);\n }\n }\n }\n\n return new Transition(subgroups, parents, name, id);\n};\n\nvar Selection$1 = selection.prototype.constructor;\n\nvar transition_selection = function() {\n return new Selection$1(this._groups, this._parents);\n};\n\nfunction styleRemove$1(name, interpolate$$2) {\n var value00,\n value10,\n interpolate0;\n return function() {\n var style = window(this).getComputedStyle(this, null),\n value0 = style.getPropertyValue(name),\n value1 = (this.style.removeProperty(name), style.getPropertyValue(name));\n return value0 === value1 ? null\n : value0 === value00 && value1 === value10 ? interpolate0\n : interpolate0 = interpolate$$2(value00 = value0, value10 = value1);\n };\n}\n\nfunction styleRemoveEnd(name) {\n return function() {\n this.style.removeProperty(name);\n };\n}\n\nfunction styleConstant$1(name, interpolate$$2, value1) {\n var value00,\n interpolate0;\n return function() {\n var value0 = window(this).getComputedStyle(this, null).getPropertyValue(name);\n return value0 === value1 ? null\n : value0 === value00 ? interpolate0\n : interpolate0 = interpolate$$2(value00 = value0, value1);\n };\n}\n\nfunction styleFunction$1(name, interpolate$$2, value) {\n var value00,\n value10,\n interpolate0;\n return function() {\n var style = window(this).getComputedStyle(this, null),\n value0 = style.getPropertyValue(name),\n value1 = value(this);\n if (value1 == null) value1 = (this.style.removeProperty(name), style.getPropertyValue(name));\n return value0 === value1 ? null\n : value0 === value00 && value1 === value10 ? interpolate0\n : interpolate0 = interpolate$$2(value00 = value0, value10 = value1);\n };\n}\n\nvar transition_style = function(name, value, priority) {\n var i = (name += \"\") === \"transform\" ? interpolateTransformCss : interpolate$$1;\n return value == null ? this\n .styleTween(name, styleRemove$1(name, i))\n .on(\"end.style.\" + name, styleRemoveEnd(name))\n : this.styleTween(name, typeof value === \"function\"\n ? styleFunction$1(name, i, tweenValue(this, \"style.\" + name, value))\n : styleConstant$1(name, i, value), priority);\n};\n\nfunction styleTween(name, value, priority) {\n function tween() {\n var node = this, i = value.apply(node, arguments);\n return i && function(t) {\n node.style.setProperty(name, i(t), priority);\n };\n }\n tween._value = value;\n return tween;\n}\n\nvar transition_styleTween = function(name, value, priority) {\n var key = \"style.\" + (name += \"\");\n if (arguments.length < 2) return (key = this.tween(key)) && key._value;\n if (value == null) return this.tween(key, null);\n if (typeof value !== \"function\") throw new Error;\n return this.tween(key, styleTween(name, value, priority == null ? \"\" : priority));\n};\n\nfunction textConstant$1(value) {\n return function() {\n this.textContent = value;\n };\n}\n\nfunction textFunction$1(value) {\n return function() {\n var value1 = value(this);\n this.textContent = value1 == null ? \"\" : value1;\n };\n}\n\nvar transition_text = function(value) {\n return this.tween(\"text\", typeof value === \"function\"\n ? textFunction$1(tweenValue(this, \"text\", value))\n : textConstant$1(value == null ? \"\" : value + \"\"));\n};\n\nvar transition_transition = function() {\n var name = this._name,\n id0 = this._id,\n id1 = newId();\n\n for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) {\n for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {\n if (node = group[i]) {\n var inherit = get$1(node, id0);\n schedule(node, name, id1, i, group, {\n time: inherit.time + inherit.delay + inherit.duration,\n delay: 0,\n duration: inherit.duration,\n ease: inherit.ease\n });\n }\n }\n }\n\n return new Transition(groups, this._parents, name, id1);\n};\n\nvar id = 0;\n\nfunction Transition(groups, parents, name, id) {\n this._groups = groups;\n this._parents = parents;\n this._name = name;\n this._id = id;\n}\n\nfunction transition(name) {\n return selection().transition(name);\n}\n\nfunction newId() {\n return ++id;\n}\n\nvar selection_prototype = selection.prototype;\n\nTransition.prototype = transition.prototype = {\n constructor: Transition,\n select: transition_select,\n selectAll: transition_selectAll,\n filter: transition_filter,\n merge: transition_merge,\n selection: transition_selection,\n transition: transition_transition,\n call: selection_prototype.call,\n nodes: selection_prototype.nodes,\n node: selection_prototype.node,\n size: selection_prototype.size,\n empty: selection_prototype.empty,\n each: selection_prototype.each,\n on: transition_on,\n attr: transition_attr,\n attrTween: transition_attrTween,\n style: transition_style,\n styleTween: transition_styleTween,\n text: transition_text,\n remove: transition_remove,\n tween: transition_tween,\n delay: transition_delay,\n duration: transition_duration,\n ease: transition_ease\n};\n\nfunction linear$1(t) {\n return +t;\n}\n\nfunction quadIn(t) {\n return t * t;\n}\n\nfunction quadOut(t) {\n return t * (2 - t);\n}\n\nfunction quadInOut(t) {\n return ((t *= 2) <= 1 ? t * t : --t * (2 - t) + 1) / 2;\n}\n\nfunction cubicIn(t) {\n return t * t * t;\n}\n\nfunction cubicOut(t) {\n return --t * t * t + 1;\n}\n\nfunction cubicInOut(t) {\n return ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2;\n}\n\nvar exponent = 3;\n\nvar polyIn = (function custom(e) {\n e = +e;\n\n function polyIn(t) {\n return Math.pow(t, e);\n }\n\n polyIn.exponent = custom;\n\n return polyIn;\n})(exponent);\n\nvar polyOut = (function custom(e) {\n e = +e;\n\n function polyOut(t) {\n return 1 - Math.pow(1 - t, e);\n }\n\n polyOut.exponent = custom;\n\n return polyOut;\n})(exponent);\n\nvar polyInOut = (function custom(e) {\n e = +e;\n\n function polyInOut(t) {\n return ((t *= 2) <= 1 ? Math.pow(t, e) : 2 - Math.pow(2 - t, e)) / 2;\n }\n\n polyInOut.exponent = custom;\n\n return polyInOut;\n})(exponent);\n\nvar pi = Math.PI;\nvar halfPi = pi / 2;\n\nfunction sinIn(t) {\n return 1 - Math.cos(t * halfPi);\n}\n\nfunction sinOut(t) {\n return Math.sin(t * halfPi);\n}\n\nfunction sinInOut(t) {\n return (1 - Math.cos(pi * t)) / 2;\n}\n\nfunction expIn(t) {\n return Math.pow(2, 10 * t - 10);\n}\n\nfunction expOut(t) {\n return 1 - Math.pow(2, -10 * t);\n}\n\nfunction expInOut(t) {\n return ((t *= 2) <= 1 ? Math.pow(2, 10 * t - 10) : 2 - Math.pow(2, 10 - 10 * t)) / 2;\n}\n\nfunction circleIn(t) {\n return 1 - Math.sqrt(1 - t * t);\n}\n\nfunction circleOut(t) {\n return Math.sqrt(1 - --t * t);\n}\n\nfunction circleInOut(t) {\n return ((t *= 2) <= 1 ? 1 - Math.sqrt(1 - t * t) : Math.sqrt(1 - (t -= 2) * t) + 1) / 2;\n}\n\nvar b1 = 4 / 11;\nvar b2 = 6 / 11;\nvar b3 = 8 / 11;\nvar b4 = 3 / 4;\nvar b5 = 9 / 11;\nvar b6 = 10 / 11;\nvar b7 = 15 / 16;\nvar b8 = 21 / 22;\nvar b9 = 63 / 64;\nvar b0 = 1 / b1 / b1;\n\nfunction bounceIn(t) {\n return 1 - bounceOut(1 - t);\n}\n\nfunction bounceOut(t) {\n return (t = +t) < b1 ? b0 * t * t : t < b3 ? b0 * (t -= b2) * t + b4 : t < b6 ? b0 * (t -= b5) * t + b7 : b0 * (t -= b8) * t + b9;\n}\n\nfunction bounceInOut(t) {\n return ((t *= 2) <= 1 ? 1 - bounceOut(1 - t) : bounceOut(t - 1) + 1) / 2;\n}\n\nvar overshoot = 1.70158;\n\nvar backIn = (function custom(s) {\n s = +s;\n\n function backIn(t) {\n return t * t * ((s + 1) * t - s);\n }\n\n backIn.overshoot = custom;\n\n return backIn;\n})(overshoot);\n\nvar backOut = (function custom(s) {\n s = +s;\n\n function backOut(t) {\n return --t * t * ((s + 1) * t + s) + 1;\n }\n\n backOut.overshoot = custom;\n\n return backOut;\n})(overshoot);\n\nvar backInOut = (function custom(s) {\n s = +s;\n\n function backInOut(t) {\n return ((t *= 2) < 1 ? t * t * ((s + 1) * t - s) : (t -= 2) * t * ((s + 1) * t + s) + 2) / 2;\n }\n\n backInOut.overshoot = custom;\n\n return backInOut;\n})(overshoot);\n\nvar tau = 2 * Math.PI;\nvar amplitude = 1;\nvar period = 0.3;\n\nvar elasticIn = (function custom(a, p) {\n var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau);\n\n function elasticIn(t) {\n return a * Math.pow(2, 10 * --t) * Math.sin((s - t) / p);\n }\n\n elasticIn.amplitude = function(a) { return custom(a, p * tau); };\n elasticIn.period = function(p) { return custom(a, p); };\n\n return elasticIn;\n})(amplitude, period);\n\nvar elasticOut = (function custom(a, p) {\n var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau);\n\n function elasticOut(t) {\n return 1 - a * Math.pow(2, -10 * (t = +t)) * Math.sin((t + s) / p);\n }\n\n elasticOut.amplitude = function(a) { return custom(a, p * tau); };\n elasticOut.period = function(p) { return custom(a, p); };\n\n return elasticOut;\n})(amplitude, period);\n\nvar elasticInOut = (function custom(a, p) {\n var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau);\n\n function elasticInOut(t) {\n return ((t = t * 2 - 1) < 0\n ? a * Math.pow(2, 10 * t) * Math.sin((s - t) / p)\n : 2 - a * Math.pow(2, -10 * t) * Math.sin((s + t) / p)) / 2;\n }\n\n elasticInOut.amplitude = function(a) { return custom(a, p * tau); };\n elasticInOut.period = function(p) { return custom(a, p); };\n\n return elasticInOut;\n})(amplitude, period);\n\nvar defaultTiming = {\n time: null, // Set on use.\n delay: 0,\n duration: 250,\n ease: cubicInOut\n};\n\nfunction inherit(node, id) {\n var timing;\n while (!(timing = node.__transition) || !(timing = timing[id])) {\n if (!(node = node.parentNode)) {\n return defaultTiming.time = now(), defaultTiming;\n }\n }\n return timing;\n}\n\nvar selection_transition = function(name) {\n var id,\n timing;\n\n if (name instanceof Transition) {\n id = name._id, name = name._name;\n } else {\n id = newId(), (timing = defaultTiming).time = now(), name = name == null ? null : name + \"\";\n }\n\n for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) {\n for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {\n if (node = group[i]) {\n schedule(node, name, id, i, group, timing || inherit(node, id));\n }\n }\n }\n\n return new Transition(groups, this._parents, name, id);\n};\n\nselection.prototype.interrupt = selection_interrupt;\nselection.prototype.transition = selection_transition;\n\nvar root$1 = [null];\n\nvar active = function(node, name) {\n var schedules = node.__transition,\n schedule,\n i;\n\n if (schedules) {\n name = name == null ? null : name + \"\";\n for (i in schedules) {\n if ((schedule = schedules[i]).state > SCHEDULED && schedule.name === name) {\n return new Transition([[node]], root$1, name, +i);\n }\n }\n }\n\n return null;\n};\n\nvar constant$4 = function(x) {\n return function() {\n return x;\n };\n};\n\nvar BrushEvent = function(target, type, selection) {\n this.target = target;\n this.type = type;\n this.selection = selection;\n};\n\nfunction nopropagation$1() {\n exports.event.stopImmediatePropagation();\n}\n\nvar noevent$1 = function() {\n exports.event.preventDefault();\n exports.event.stopImmediatePropagation();\n};\n\nvar MODE_DRAG = {name: \"drag\"};\nvar MODE_SPACE = {name: \"space\"};\nvar MODE_HANDLE = {name: \"handle\"};\nvar MODE_CENTER = {name: \"center\"};\n\nvar X = {\n name: \"x\",\n handles: [\"e\", \"w\"].map(type),\n input: function(x, e) { return x && [[x[0], e[0][1]], [x[1], e[1][1]]]; },\n output: function(xy) { return xy && [xy[0][0], xy[1][0]]; }\n};\n\nvar Y = {\n name: \"y\",\n handles: [\"n\", \"s\"].map(type),\n input: function(y, e) { return y && [[e[0][0], y[0]], [e[1][0], y[1]]]; },\n output: function(xy) { return xy && [xy[0][1], xy[1][1]]; }\n};\n\nvar XY = {\n name: \"xy\",\n handles: [\"n\", \"e\", \"s\", \"w\", \"nw\", \"ne\", \"se\", \"sw\"].map(type),\n input: function(xy) { return xy; },\n output: function(xy) { return xy; }\n};\n\nvar cursors = {\n overlay: \"crosshair\",\n selection: \"move\",\n n: \"ns-resize\",\n e: \"ew-resize\",\n s: \"ns-resize\",\n w: \"ew-resize\",\n nw: \"nwse-resize\",\n ne: \"nesw-resize\",\n se: \"nwse-resize\",\n sw: \"nesw-resize\"\n};\n\nvar flipX = {\n e: \"w\",\n w: \"e\",\n nw: \"ne\",\n ne: \"nw\",\n se: \"sw\",\n sw: \"se\"\n};\n\nvar flipY = {\n n: \"s\",\n s: \"n\",\n nw: \"sw\",\n ne: \"se\",\n se: \"ne\",\n sw: \"nw\"\n};\n\nvar signsX = {\n overlay: +1,\n selection: +1,\n n: null,\n e: +1,\n s: null,\n w: -1,\n nw: -1,\n ne: +1,\n se: +1,\n sw: -1\n};\n\nvar signsY = {\n overlay: +1,\n selection: +1,\n n: -1,\n e: null,\n s: +1,\n w: null,\n nw: -1,\n ne: -1,\n se: +1,\n sw: +1\n};\n\nfunction type(t) {\n return {type: t};\n}\n\n// Ignore right-click, since that should open the context menu.\nfunction defaultFilter() {\n return !exports.event.button;\n}\n\nfunction defaultExtent() {\n var svg = this.ownerSVGElement || this;\n return [[0, 0], [svg.width.baseVal.value, svg.height.baseVal.value]];\n}\n\n// Like d3.local, but with the name “__brush” rather than auto-generated.\nfunction local$$1(node) {\n while (!node.__brush) if (!(node = node.parentNode)) return;\n return node.__brush;\n}\n\nfunction empty(extent) {\n return extent[0][0] === extent[1][0]\n || extent[0][1] === extent[1][1];\n}\n\nfunction brushSelection(node) {\n var state = node.__brush;\n return state ? state.dim.output(state.selection) : null;\n}\n\nfunction brushX() {\n return brush$1(X);\n}\n\nfunction brushY() {\n return brush$1(Y);\n}\n\nvar brush = function() {\n return brush$1(XY);\n};\n\nfunction brush$1(dim) {\n var extent = defaultExtent,\n filter = defaultFilter,\n listeners = dispatch(brush, \"start\", \"brush\", \"end\"),\n handleSize = 6,\n touchending;\n\n function brush(group) {\n var overlay = group\n .property(\"__brush\", initialize)\n .selectAll(\".overlay\")\n .data([type(\"overlay\")]);\n\n overlay.enter().append(\"rect\")\n .attr(\"class\", \"overlay\")\n .attr(\"pointer-events\", \"all\")\n .attr(\"cursor\", cursors.overlay)\n .merge(overlay)\n .each(function() {\n var extent = local$$1(this).extent;\n select(this)\n .attr(\"x\", extent[0][0])\n .attr(\"y\", extent[0][1])\n .attr(\"width\", extent[1][0] - extent[0][0])\n .attr(\"height\", extent[1][1] - extent[0][1]);\n });\n\n group.selectAll(\".selection\")\n .data([type(\"selection\")])\n .enter().append(\"rect\")\n .attr(\"class\", \"selection\")\n .attr(\"cursor\", cursors.selection)\n .attr(\"fill\", \"#777\")\n .attr(\"fill-opacity\", 0.3)\n .attr(\"stroke\", \"#fff\")\n .attr(\"shape-rendering\", \"crispEdges\");\n\n var handle = group.selectAll(\".handle\")\n .data(dim.handles, function(d) { return d.type; });\n\n handle.exit().remove();\n\n handle.enter().append(\"rect\")\n .attr(\"class\", function(d) { return \"handle handle--\" + d.type; })\n .attr(\"cursor\", function(d) { return cursors[d.type]; });\n\n group\n .each(redraw)\n .attr(\"fill\", \"none\")\n .attr(\"pointer-events\", \"all\")\n .style(\"-webkit-tap-highlight-color\", \"rgba(0,0,0,0)\")\n .on(\"mousedown.brush touchstart.brush\", started);\n }\n\n brush.move = function(group, selection$$1) {\n if (group.selection) {\n group\n .on(\"start.brush\", function() { emitter(this, arguments).beforestart().start(); })\n .on(\"interrupt.brush end.brush\", function() { emitter(this, arguments).end(); })\n .tween(\"brush\", function() {\n var that = this,\n state = that.__brush,\n emit = emitter(that, arguments),\n selection0 = state.selection,\n selection1 = dim.input(typeof selection$$1 === \"function\" ? selection$$1.apply(this, arguments) : selection$$1, state.extent),\n i = interpolateValue(selection0, selection1);\n\n function tween(t) {\n state.selection = t === 1 && empty(selection1) ? null : i(t);\n redraw.call(that);\n emit.brush();\n }\n\n return selection0 && selection1 ? tween : tween(1);\n });\n } else {\n group\n .each(function() {\n var that = this,\n args = arguments,\n state = that.__brush,\n selection1 = dim.input(typeof selection$$1 === \"function\" ? selection$$1.apply(that, args) : selection$$1, state.extent),\n emit = emitter(that, args).beforestart();\n\n interrupt(that);\n state.selection = selection1 == null || empty(selection1) ? null : selection1;\n redraw.call(that);\n emit.start().brush().end();\n });\n }\n };\n\n function redraw() {\n var group = select(this),\n selection$$1 = local$$1(this).selection;\n\n if (selection$$1) {\n group.selectAll(\".selection\")\n .style(\"display\", null)\n .attr(\"x\", selection$$1[0][0])\n .attr(\"y\", selection$$1[0][1])\n .attr(\"width\", selection$$1[1][0] - selection$$1[0][0])\n .attr(\"height\", selection$$1[1][1] - selection$$1[0][1]);\n\n group.selectAll(\".handle\")\n .style(\"display\", null)\n .attr(\"x\", function(d) { return d.type[d.type.length - 1] === \"e\" ? selection$$1[1][0] - handleSize / 2 : selection$$1[0][0] - handleSize / 2; })\n .attr(\"y\", function(d) { return d.type[0] === \"s\" ? selection$$1[1][1] - handleSize / 2 : selection$$1[0][1] - handleSize / 2; })\n .attr(\"width\", function(d) { return d.type === \"n\" || d.type === \"s\" ? selection$$1[1][0] - selection$$1[0][0] + handleSize : handleSize; })\n .attr(\"height\", function(d) { return d.type === \"e\" || d.type === \"w\" ? selection$$1[1][1] - selection$$1[0][1] + handleSize : handleSize; });\n }\n\n else {\n group.selectAll(\".selection,.handle\")\n .style(\"display\", \"none\")\n .attr(\"x\", null)\n .attr(\"y\", null)\n .attr(\"width\", null)\n .attr(\"height\", null);\n }\n }\n\n function emitter(that, args) {\n return that.__brush.emitter || new Emitter(that, args);\n }\n\n function Emitter(that, args) {\n this.that = that;\n this.args = args;\n this.state = that.__brush;\n this.active = 0;\n }\n\n Emitter.prototype = {\n beforestart: function() {\n if (++this.active === 1) this.state.emitter = this, this.starting = true;\n return this;\n },\n start: function() {\n if (this.starting) this.starting = false, this.emit(\"start\");\n return this;\n },\n brush: function() {\n this.emit(\"brush\");\n return this;\n },\n end: function() {\n if (--this.active === 0) delete this.state.emitter, this.emit(\"end\");\n return this;\n },\n emit: function(type) {\n customEvent(new BrushEvent(brush, type, dim.output(this.state.selection)), listeners.apply, listeners, [type, this.that, this.args]);\n }\n };\n\n function started() {\n if (exports.event.touches) { if (exports.event.changedTouches.length < exports.event.touches.length) return noevent$1(); }\n else if (touchending) return;\n if (!filter.apply(this, arguments)) return;\n\n var that = this,\n type = exports.event.target.__data__.type,\n mode = (exports.event.metaKey ? type = \"overlay\" : type) === \"selection\" ? MODE_DRAG : (exports.event.altKey ? MODE_CENTER : MODE_HANDLE),\n signX = dim === Y ? null : signsX[type],\n signY = dim === X ? null : signsY[type],\n state = local$$1(that),\n extent = state.extent,\n selection$$1 = state.selection,\n W = extent[0][0], w0, w1,\n N = extent[0][1], n0, n1,\n E = extent[1][0], e0, e1,\n S = extent[1][1], s0, s1,\n dx,\n dy,\n moving,\n shifting = signX && signY && exports.event.shiftKey,\n lockX,\n lockY,\n point0 = mouse(that),\n point = point0,\n emit = emitter(that, arguments).beforestart();\n\n if (type === \"overlay\") {\n state.selection = selection$$1 = [\n [w0 = dim === Y ? W : point0[0], n0 = dim === X ? N : point0[1]],\n [e0 = dim === Y ? E : w0, s0 = dim === X ? S : n0]\n ];\n } else {\n w0 = selection$$1[0][0];\n n0 = selection$$1[0][1];\n e0 = selection$$1[1][0];\n s0 = selection$$1[1][1];\n }\n\n w1 = w0;\n n1 = n0;\n e1 = e0;\n s1 = s0;\n\n var group = select(that)\n .attr(\"pointer-events\", \"none\");\n\n var overlay = group.selectAll(\".overlay\")\n .attr(\"cursor\", cursors[type]);\n\n if (exports.event.touches) {\n group\n .on(\"touchmove.brush\", moved, true)\n .on(\"touchend.brush touchcancel.brush\", ended, true);\n } else {\n var view = select(exports.event.view)\n .on(\"keydown.brush\", keydowned, true)\n .on(\"keyup.brush\", keyupped, true)\n .on(\"mousemove.brush\", moved, true)\n .on(\"mouseup.brush\", ended, true);\n\n dragDisable(exports.event.view);\n }\n\n nopropagation$1();\n interrupt(that);\n redraw.call(that);\n emit.start();\n\n function moved() {\n var point1 = mouse(that);\n if (shifting && !lockX && !lockY) {\n if (Math.abs(point1[0] - point[0]) > Math.abs(point1[1] - point[1])) lockY = true;\n else lockX = true;\n }\n point = point1;\n moving = true;\n noevent$1();\n move();\n }\n\n function move() {\n var t;\n\n dx = point[0] - point0[0];\n dy = point[1] - point0[1];\n\n switch (mode) {\n case MODE_SPACE:\n case MODE_DRAG: {\n if (signX) dx = Math.max(W - w0, Math.min(E - e0, dx)), w1 = w0 + dx, e1 = e0 + dx;\n if (signY) dy = Math.max(N - n0, Math.min(S - s0, dy)), n1 = n0 + dy, s1 = s0 + dy;\n break;\n }\n case MODE_HANDLE: {\n if (signX < 0) dx = Math.max(W - w0, Math.min(E - w0, dx)), w1 = w0 + dx, e1 = e0;\n else if (signX > 0) dx = Math.max(W - e0, Math.min(E - e0, dx)), w1 = w0, e1 = e0 + dx;\n if (signY < 0) dy = Math.max(N - n0, Math.min(S - n0, dy)), n1 = n0 + dy, s1 = s0;\n else if (signY > 0) dy = Math.max(N - s0, Math.min(S - s0, dy)), n1 = n0, s1 = s0 + dy;\n break;\n }\n case MODE_CENTER: {\n if (signX) w1 = Math.max(W, Math.min(E, w0 - dx * signX)), e1 = Math.max(W, Math.min(E, e0 + dx * signX));\n if (signY) n1 = Math.max(N, Math.min(S, n0 - dy * signY)), s1 = Math.max(N, Math.min(S, s0 + dy * signY));\n break;\n }\n }\n\n if (e1 < w1) {\n signX *= -1;\n t = w0, w0 = e0, e0 = t;\n t = w1, w1 = e1, e1 = t;\n if (type in flipX) overlay.attr(\"cursor\", cursors[type = flipX[type]]);\n }\n\n if (s1 < n1) {\n signY *= -1;\n t = n0, n0 = s0, s0 = t;\n t = n1, n1 = s1, s1 = t;\n if (type in flipY) overlay.attr(\"cursor\", cursors[type = flipY[type]]);\n }\n\n if (state.selection) selection$$1 = state.selection; // May be set by brush.move!\n if (lockX) w1 = selection$$1[0][0], e1 = selection$$1[1][0];\n if (lockY) n1 = selection$$1[0][1], s1 = selection$$1[1][1];\n\n if (selection$$1[0][0] !== w1\n || selection$$1[0][1] !== n1\n || selection$$1[1][0] !== e1\n || selection$$1[1][1] !== s1) {\n state.selection = [[w1, n1], [e1, s1]];\n redraw.call(that);\n emit.brush();\n }\n }\n\n function ended() {\n nopropagation$1();\n if (exports.event.touches) {\n if (exports.event.touches.length) return;\n if (touchending) clearTimeout(touchending);\n touchending = setTimeout(function() { touchending = null; }, 500); // Ghost clicks are delayed!\n group.on(\"touchmove.brush touchend.brush touchcancel.brush\", null);\n } else {\n yesdrag(exports.event.view, moving);\n view.on(\"keydown.brush keyup.brush mousemove.brush mouseup.brush\", null);\n }\n group.attr(\"pointer-events\", \"all\");\n overlay.attr(\"cursor\", cursors.overlay);\n if (state.selection) selection$$1 = state.selection; // May be set by brush.move (on start)!\n if (empty(selection$$1)) state.selection = null, redraw.call(that);\n emit.end();\n }\n\n function keydowned() {\n switch (exports.event.keyCode) {\n case 16: { // SHIFT\n shifting = signX && signY;\n break;\n }\n case 18: { // ALT\n if (mode === MODE_HANDLE) {\n if (signX) e0 = e1 - dx * signX, w0 = w1 + dx * signX;\n if (signY) s0 = s1 - dy * signY, n0 = n1 + dy * signY;\n mode = MODE_CENTER;\n move();\n }\n break;\n }\n case 32: { // SPACE; takes priority over ALT\n if (mode === MODE_HANDLE || mode === MODE_CENTER) {\n if (signX < 0) e0 = e1 - dx; else if (signX > 0) w0 = w1 - dx;\n if (signY < 0) s0 = s1 - dy; else if (signY > 0) n0 = n1 - dy;\n mode = MODE_SPACE;\n overlay.attr(\"cursor\", cursors.selection);\n move();\n }\n break;\n }\n default: return;\n }\n noevent$1();\n }\n\n function keyupped() {\n switch (exports.event.keyCode) {\n case 16: { // SHIFT\n if (shifting) {\n lockX = lockY = shifting = false;\n move();\n }\n break;\n }\n case 18: { // ALT\n if (mode === MODE_CENTER) {\n if (signX < 0) e0 = e1; else if (signX > 0) w0 = w1;\n if (signY < 0) s0 = s1; else if (signY > 0) n0 = n1;\n mode = MODE_HANDLE;\n move();\n }\n break;\n }\n case 32: { // SPACE\n if (mode === MODE_SPACE) {\n if (exports.event.altKey) {\n if (signX) e0 = e1 - dx * signX, w0 = w1 + dx * signX;\n if (signY) s0 = s1 - dy * signY, n0 = n1 + dy * signY;\n mode = MODE_CENTER;\n } else {\n if (signX < 0) e0 = e1; else if (signX > 0) w0 = w1;\n if (signY < 0) s0 = s1; else if (signY > 0) n0 = n1;\n mode = MODE_HANDLE;\n }\n overlay.attr(\"cursor\", cursors[type]);\n move();\n }\n break;\n }\n default: return;\n }\n noevent$1();\n }\n }\n\n function initialize() {\n var state = this.__brush || {selection: null};\n state.extent = extent.apply(this, arguments);\n state.dim = dim;\n return state;\n }\n\n brush.extent = function(_) {\n return arguments.length ? (extent = typeof _ === \"function\" ? _ : constant$4([[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]]), brush) : extent;\n };\n\n brush.filter = function(_) {\n return arguments.length ? (filter = typeof _ === \"function\" ? _ : constant$4(!!_), brush) : filter;\n };\n\n brush.handleSize = function(_) {\n return arguments.length ? (handleSize = +_, brush) : handleSize;\n };\n\n brush.on = function() {\n var value = listeners.on.apply(listeners, arguments);\n return value === listeners ? brush : value;\n };\n\n return brush;\n}\n\nvar cos = Math.cos;\nvar sin = Math.sin;\nvar pi$1 = Math.PI;\nvar halfPi$1 = pi$1 / 2;\nvar tau$1 = pi$1 * 2;\nvar max$1 = Math.max;\n\nfunction compareValue(compare) {\n return function(a, b) {\n return compare(\n a.source.value + a.target.value,\n b.source.value + b.target.value\n );\n };\n}\n\nvar chord = function() {\n var padAngle = 0,\n sortGroups = null,\n sortSubgroups = null,\n sortChords = null;\n\n function chord(matrix) {\n var n = matrix.length,\n groupSums = [],\n groupIndex = sequence(n),\n subgroupIndex = [],\n chords = [],\n groups = chords.groups = new Array(n),\n subgroups = new Array(n * n),\n k,\n x,\n x0,\n dx,\n i,\n j;\n\n // Compute the sum.\n k = 0, i = -1; while (++i < n) {\n x = 0, j = -1; while (++j < n) {\n x += matrix[i][j];\n }\n groupSums.push(x);\n subgroupIndex.push(sequence(n));\n k += x;\n }\n\n // Sort groups…\n if (sortGroups) groupIndex.sort(function(a, b) {\n return sortGroups(groupSums[a], groupSums[b]);\n });\n\n // Sort subgroups…\n if (sortSubgroups) subgroupIndex.forEach(function(d, i) {\n d.sort(function(a, b) {\n return sortSubgroups(matrix[i][a], matrix[i][b]);\n });\n });\n\n // Convert the sum to scaling factor for [0, 2pi].\n // TODO Allow start and end angle to be specified?\n // TODO Allow padding to be specified as percentage?\n k = max$1(0, tau$1 - padAngle * n) / k;\n dx = k ? padAngle : tau$1 / n;\n\n // Compute the start and end angle for each group and subgroup.\n // Note: Opera has a bug reordering object literal properties!\n x = 0, i = -1; while (++i < n) {\n x0 = x, j = -1; while (++j < n) {\n var di = groupIndex[i],\n dj = subgroupIndex[di][j],\n v = matrix[di][dj],\n a0 = x,\n a1 = x += v * k;\n subgroups[dj * n + di] = {\n index: di,\n subindex: dj,\n startAngle: a0,\n endAngle: a1,\n value: v\n };\n }\n groups[di] = {\n index: di,\n startAngle: x0,\n endAngle: x,\n value: groupSums[di]\n };\n x += dx;\n }\n\n // Generate chords for each (non-empty) subgroup-subgroup link.\n i = -1; while (++i < n) {\n j = i - 1; while (++j < n) {\n var source = subgroups[j * n + i],\n target = subgroups[i * n + j];\n if (source.value || target.value) {\n chords.push(source.value < target.value\n ? {source: target, target: source}\n : {source: source, target: target});\n }\n }\n }\n\n return sortChords ? chords.sort(sortChords) : chords;\n }\n\n chord.padAngle = function(_) {\n return arguments.length ? (padAngle = max$1(0, _), chord) : padAngle;\n };\n\n chord.sortGroups = function(_) {\n return arguments.length ? (sortGroups = _, chord) : sortGroups;\n };\n\n chord.sortSubgroups = function(_) {\n return arguments.length ? (sortSubgroups = _, chord) : sortSubgroups;\n };\n\n chord.sortChords = function(_) {\n return arguments.length ? (_ == null ? sortChords = null : (sortChords = compareValue(_))._ = _, chord) : sortChords && sortChords._;\n };\n\n return chord;\n};\n\nvar slice$2 = Array.prototype.slice;\n\nvar constant$5 = function(x) {\n return function() {\n return x;\n };\n};\n\nvar pi$2 = Math.PI;\nvar tau$2 = 2 * pi$2;\nvar epsilon$1 = 1e-6;\nvar tauEpsilon = tau$2 - epsilon$1;\n\nfunction Path() {\n this._x0 = this._y0 = // start of current subpath\n this._x1 = this._y1 = null; // end of current subpath\n this._ = \"\";\n}\n\nfunction path() {\n return new Path;\n}\n\nPath.prototype = path.prototype = {\n constructor: Path,\n moveTo: function(x, y) {\n this._ += \"M\" + (this._x0 = this._x1 = +x) + \",\" + (this._y0 = this._y1 = +y);\n },\n closePath: function() {\n if (this._x1 !== null) {\n this._x1 = this._x0, this._y1 = this._y0;\n this._ += \"Z\";\n }\n },\n lineTo: function(x, y) {\n this._ += \"L\" + (this._x1 = +x) + \",\" + (this._y1 = +y);\n },\n quadraticCurveTo: function(x1, y1, x, y) {\n this._ += \"Q\" + (+x1) + \",\" + (+y1) + \",\" + (this._x1 = +x) + \",\" + (this._y1 = +y);\n },\n bezierCurveTo: function(x1, y1, x2, y2, x, y) {\n this._ += \"C\" + (+x1) + \",\" + (+y1) + \",\" + (+x2) + \",\" + (+y2) + \",\" + (this._x1 = +x) + \",\" + (this._y1 = +y);\n },\n arcTo: function(x1, y1, x2, y2, r) {\n x1 = +x1, y1 = +y1, x2 = +x2, y2 = +y2, r = +r;\n var x0 = this._x1,\n y0 = this._y1,\n x21 = x2 - x1,\n y21 = y2 - y1,\n x01 = x0 - x1,\n y01 = y0 - y1,\n l01_2 = x01 * x01 + y01 * y01;\n\n // Is the radius negative? Error.\n if (r < 0) throw new Error(\"negative radius: \" + r);\n\n // Is this path empty? Move to (x1,y1).\n if (this._x1 === null) {\n this._ += \"M\" + (this._x1 = x1) + \",\" + (this._y1 = y1);\n }\n\n // Or, is (x1,y1) coincident with (x0,y0)? Do nothing.\n else if (!(l01_2 > epsilon$1)) {}\n\n // Or, are (x0,y0), (x1,y1) and (x2,y2) collinear?\n // Equivalently, is (x1,y1) coincident with (x2,y2)?\n // Or, is the radius zero? Line to (x1,y1).\n else if (!(Math.abs(y01 * x21 - y21 * x01) > epsilon$1) || !r) {\n this._ += \"L\" + (this._x1 = x1) + \",\" + (this._y1 = y1);\n }\n\n // Otherwise, draw an arc!\n else {\n var x20 = x2 - x0,\n y20 = y2 - y0,\n l21_2 = x21 * x21 + y21 * y21,\n l20_2 = x20 * x20 + y20 * y20,\n l21 = Math.sqrt(l21_2),\n l01 = Math.sqrt(l01_2),\n l = r * Math.tan((pi$2 - Math.acos((l21_2 + l01_2 - l20_2) / (2 * l21 * l01))) / 2),\n t01 = l / l01,\n t21 = l / l21;\n\n // If the start tangent is not coincident with (x0,y0), line to.\n if (Math.abs(t01 - 1) > epsilon$1) {\n this._ += \"L\" + (x1 + t01 * x01) + \",\" + (y1 + t01 * y01);\n }\n\n this._ += \"A\" + r + \",\" + r + \",0,0,\" + (+(y01 * x20 > x01 * y20)) + \",\" + (this._x1 = x1 + t21 * x21) + \",\" + (this._y1 = y1 + t21 * y21);\n }\n },\n arc: function(x, y, r, a0, a1, ccw) {\n x = +x, y = +y, r = +r;\n var dx = r * Math.cos(a0),\n dy = r * Math.sin(a0),\n x0 = x + dx,\n y0 = y + dy,\n cw = 1 ^ ccw,\n da = ccw ? a0 - a1 : a1 - a0;\n\n // Is the radius negative? Error.\n if (r < 0) throw new Error(\"negative radius: \" + r);\n\n // Is this path empty? Move to (x0,y0).\n if (this._x1 === null) {\n this._ += \"M\" + x0 + \",\" + y0;\n }\n\n // Or, is (x0,y0) not coincident with the previous point? Line to (x0,y0).\n else if (Math.abs(this._x1 - x0) > epsilon$1 || Math.abs(this._y1 - y0) > epsilon$1) {\n this._ += \"L\" + x0 + \",\" + y0;\n }\n\n // Is this arc empty? We’re done.\n if (!r) return;\n\n // Is this a complete circle? Draw two arcs to complete the circle.\n if (da > tauEpsilon) {\n this._ += \"A\" + r + \",\" + r + \",0,1,\" + cw + \",\" + (x - dx) + \",\" + (y - dy) + \"A\" + r + \",\" + r + \",0,1,\" + cw + \",\" + (this._x1 = x0) + \",\" + (this._y1 = y0);\n }\n\n // Otherwise, draw an arc!\n else {\n if (da < 0) da = da % tau$2 + tau$2;\n this._ += \"A\" + r + \",\" + r + \",0,\" + (+(da >= pi$2)) + \",\" + cw + \",\" + (this._x1 = x + r * Math.cos(a1)) + \",\" + (this._y1 = y + r * Math.sin(a1));\n }\n },\n rect: function(x, y, w, h) {\n this._ += \"M\" + (this._x0 = this._x1 = +x) + \",\" + (this._y0 = this._y1 = +y) + \"h\" + (+w) + \"v\" + (+h) + \"h\" + (-w) + \"Z\";\n },\n toString: function() {\n return this._;\n }\n};\n\nfunction defaultSource(d) {\n return d.source;\n}\n\nfunction defaultTarget(d) {\n return d.target;\n}\n\nfunction defaultRadius(d) {\n return d.radius;\n}\n\nfunction defaultStartAngle(d) {\n return d.startAngle;\n}\n\nfunction defaultEndAngle(d) {\n return d.endAngle;\n}\n\nvar ribbon = function() {\n var source = defaultSource,\n target = defaultTarget,\n radius = defaultRadius,\n startAngle = defaultStartAngle,\n endAngle = defaultEndAngle,\n context = null;\n\n function ribbon() {\n var buffer,\n argv = slice$2.call(arguments),\n s = source.apply(this, argv),\n t = target.apply(this, argv),\n sr = +radius.apply(this, (argv[0] = s, argv)),\n sa0 = startAngle.apply(this, argv) - halfPi$1,\n sa1 = endAngle.apply(this, argv) - halfPi$1,\n sx0 = sr * cos(sa0),\n sy0 = sr * sin(sa0),\n tr = +radius.apply(this, (argv[0] = t, argv)),\n ta0 = startAngle.apply(this, argv) - halfPi$1,\n ta1 = endAngle.apply(this, argv) - halfPi$1;\n\n if (!context) context = buffer = path();\n\n context.moveTo(sx0, sy0);\n context.arc(0, 0, sr, sa0, sa1);\n if (sa0 !== ta0 || sa1 !== ta1) { // TODO sr !== tr?\n context.quadraticCurveTo(0, 0, tr * cos(ta0), tr * sin(ta0));\n context.arc(0, 0, tr, ta0, ta1);\n }\n context.quadraticCurveTo(0, 0, sx0, sy0);\n context.closePath();\n\n if (buffer) return context = null, buffer + \"\" || null;\n }\n\n ribbon.radius = function(_) {\n return arguments.length ? (radius = typeof _ === \"function\" ? _ : constant$5(+_), ribbon) : radius;\n };\n\n ribbon.startAngle = function(_) {\n return arguments.length ? (startAngle = typeof _ === \"function\" ? _ : constant$5(+_), ribbon) : startAngle;\n };\n\n ribbon.endAngle = function(_) {\n return arguments.length ? (endAngle = typeof _ === \"function\" ? _ : constant$5(+_), ribbon) : endAngle;\n };\n\n ribbon.source = function(_) {\n return arguments.length ? (source = _, ribbon) : source;\n };\n\n ribbon.target = function(_) {\n return arguments.length ? (target = _, ribbon) : target;\n };\n\n ribbon.context = function(_) {\n return arguments.length ? ((context = _ == null ? null : _), ribbon) : context;\n };\n\n return ribbon;\n};\n\nvar prefix = \"$\";\n\nfunction Map() {}\n\nMap.prototype = map$1.prototype = {\n constructor: Map,\n has: function(key) {\n return (prefix + key) in this;\n },\n get: function(key) {\n return this[prefix + key];\n },\n set: function(key, value) {\n this[prefix + key] = value;\n return this;\n },\n remove: function(key) {\n var property = prefix + key;\n return property in this && delete this[property];\n },\n clear: function() {\n for (var property in this) if (property[0] === prefix) delete this[property];\n },\n keys: function() {\n var keys = [];\n for (var property in this) if (property[0] === prefix) keys.push(property.slice(1));\n return keys;\n },\n values: function() {\n var values = [];\n for (var property in this) if (property[0] === prefix) values.push(this[property]);\n return values;\n },\n entries: function() {\n var entries = [];\n for (var property in this) if (property[0] === prefix) entries.push({key: property.slice(1), value: this[property]});\n return entries;\n },\n size: function() {\n var size = 0;\n for (var property in this) if (property[0] === prefix) ++size;\n return size;\n },\n empty: function() {\n for (var property in this) if (property[0] === prefix) return false;\n return true;\n },\n each: function(f) {\n for (var property in this) if (property[0] === prefix) f(this[property], property.slice(1), this);\n }\n};\n\nfunction map$1(object, f) {\n var map = new Map;\n\n // Copy constructor.\n if (object instanceof Map) object.each(function(value, key) { map.set(key, value); });\n\n // Index array by numeric index or specified key function.\n else if (Array.isArray(object)) {\n var i = -1,\n n = object.length,\n o;\n\n if (f == null) while (++i < n) map.set(i, object[i]);\n else while (++i < n) map.set(f(o = object[i], i, object), o);\n }\n\n // Convert object to map.\n else if (object) for (var key in object) map.set(key, object[key]);\n\n return map;\n}\n\nvar nest = function() {\n var keys = [],\n sortKeys = [],\n sortValues,\n rollup,\n nest;\n\n function apply(array, depth, createResult, setResult) {\n if (depth >= keys.length) return rollup != null\n ? rollup(array) : (sortValues != null\n ? array.sort(sortValues)\n : array);\n\n var i = -1,\n n = array.length,\n key = keys[depth++],\n keyValue,\n value,\n valuesByKey = map$1(),\n values,\n result = createResult();\n\n while (++i < n) {\n if (values = valuesByKey.get(keyValue = key(value = array[i]) + \"\")) {\n values.push(value);\n } else {\n valuesByKey.set(keyValue, [value]);\n }\n }\n\n valuesByKey.each(function(values, key) {\n setResult(result, key, apply(values, depth, createResult, setResult));\n });\n\n return result;\n }\n\n function entries(map, depth) {\n if (++depth > keys.length) return map;\n var array, sortKey = sortKeys[depth - 1];\n if (rollup != null && depth >= keys.length) array = map.entries();\n else array = [], map.each(function(v, k) { array.push({key: k, values: entries(v, depth)}); });\n return sortKey != null ? array.sort(function(a, b) { return sortKey(a.key, b.key); }) : array;\n }\n\n return nest = {\n object: function(array) { return apply(array, 0, createObject, setObject); },\n map: function(array) { return apply(array, 0, createMap, setMap); },\n entries: function(array) { return entries(apply(array, 0, createMap, setMap), 0); },\n key: function(d) { keys.push(d); return nest; },\n sortKeys: function(order) { sortKeys[keys.length - 1] = order; return nest; },\n sortValues: function(order) { sortValues = order; return nest; },\n rollup: function(f) { rollup = f; return nest; }\n };\n};\n\nfunction createObject() {\n return {};\n}\n\nfunction setObject(object, key, value) {\n object[key] = value;\n}\n\nfunction createMap() {\n return map$1();\n}\n\nfunction setMap(map, key, value) {\n map.set(key, value);\n}\n\nfunction Set() {}\n\nvar proto = map$1.prototype;\n\nSet.prototype = set$2.prototype = {\n constructor: Set,\n has: proto.has,\n add: function(value) {\n value += \"\";\n this[prefix + value] = value;\n return this;\n },\n remove: proto.remove,\n clear: proto.clear,\n values: proto.keys,\n size: proto.size,\n empty: proto.empty,\n each: proto.each\n};\n\nfunction set$2(object, f) {\n var set = new Set;\n\n // Copy constructor.\n if (object instanceof Set) object.each(function(value) { set.add(value); });\n\n // Otherwise, assume it’s an array.\n else if (object) {\n var i = -1, n = object.length;\n if (f == null) while (++i < n) set.add(object[i]);\n else while (++i < n) set.add(f(object[i], i, object));\n }\n\n return set;\n}\n\nvar keys = function(map) {\n var keys = [];\n for (var key in map) keys.push(key);\n return keys;\n};\n\nvar values = function(map) {\n var values = [];\n for (var key in map) values.push(map[key]);\n return values;\n};\n\nvar entries = function(map) {\n var entries = [];\n for (var key in map) entries.push({key: key, value: map[key]});\n return entries;\n};\n\nfunction objectConverter(columns) {\n return new Function(\"d\", \"return {\" + columns.map(function(name, i) {\n return JSON.stringify(name) + \": d[\" + i + \"]\";\n }).join(\",\") + \"}\");\n}\n\nfunction customConverter(columns, f) {\n var object = objectConverter(columns);\n return function(row, i) {\n return f(object(row), i, columns);\n };\n}\n\n// Compute unique columns in order of discovery.\nfunction inferColumns(rows) {\n var columnSet = Object.create(null),\n columns = [];\n\n rows.forEach(function(row) {\n for (var column in row) {\n if (!(column in columnSet)) {\n columns.push(columnSet[column] = column);\n }\n }\n });\n\n return columns;\n}\n\nvar dsv = function(delimiter) {\n var reFormat = new RegExp(\"[\\\"\" + delimiter + \"\\n]\"),\n delimiterCode = delimiter.charCodeAt(0);\n\n function parse(text, f) {\n var convert, columns, rows = parseRows(text, function(row, i) {\n if (convert) return convert(row, i - 1);\n columns = row, convert = f ? customConverter(row, f) : objectConverter(row);\n });\n rows.columns = columns;\n return rows;\n }\n\n function parseRows(text, f) {\n var EOL = {}, // sentinel value for end-of-line\n EOF = {}, // sentinel value for end-of-file\n rows = [], // output rows\n N = text.length,\n I = 0, // current character index\n n = 0, // the current line number\n t, // the current token\n eol; // is the current token followed by EOL?\n\n function token() {\n if (I >= N) return EOF; // special case: end of file\n if (eol) return eol = false, EOL; // special case: end of line\n\n // special case: quotes\n var j = I, c;\n if (text.charCodeAt(j) === 34) {\n var i = j;\n while (i++ < N) {\n if (text.charCodeAt(i) === 34) {\n if (text.charCodeAt(i + 1) !== 34) break;\n ++i;\n }\n }\n I = i + 2;\n c = text.charCodeAt(i + 1);\n if (c === 13) {\n eol = true;\n if (text.charCodeAt(i + 2) === 10) ++I;\n } else if (c === 10) {\n eol = true;\n }\n return text.slice(j + 1, i).replace(/\"\"/g, \"\\\"\");\n }\n\n // common case: find next delimiter or newline\n while (I < N) {\n var k = 1;\n c = text.charCodeAt(I++);\n if (c === 10) eol = true; // \\n\n else if (c === 13) { eol = true; if (text.charCodeAt(I) === 10) ++I, ++k; } // \\r|\\r\\n\n else if (c !== delimiterCode) continue;\n return text.slice(j, I - k);\n }\n\n // special case: last token before EOF\n return text.slice(j);\n }\n\n while ((t = token()) !== EOF) {\n var a = [];\n while (t !== EOL && t !== EOF) {\n a.push(t);\n t = token();\n }\n if (f && (a = f(a, n++)) == null) continue;\n rows.push(a);\n }\n\n return rows;\n }\n\n function format(rows, columns) {\n if (columns == null) columns = inferColumns(rows);\n return [columns.map(formatValue).join(delimiter)].concat(rows.map(function(row) {\n return columns.map(function(column) {\n return formatValue(row[column]);\n }).join(delimiter);\n })).join(\"\\n\");\n }\n\n function formatRows(rows) {\n return rows.map(formatRow).join(\"\\n\");\n }\n\n function formatRow(row) {\n return row.map(formatValue).join(delimiter);\n }\n\n function formatValue(text) {\n return text == null ? \"\"\n : reFormat.test(text += \"\") ? \"\\\"\" + text.replace(/\\\"/g, \"\\\"\\\"\") + \"\\\"\"\n : text;\n }\n\n return {\n parse: parse,\n parseRows: parseRows,\n format: format,\n formatRows: formatRows\n };\n};\n\nvar csv = dsv(\",\");\n\nvar csvParse = csv.parse;\nvar csvParseRows = csv.parseRows;\nvar csvFormat = csv.format;\nvar csvFormatRows = csv.formatRows;\n\nvar tsv = dsv(\"\\t\");\n\nvar tsvParse = tsv.parse;\nvar tsvParseRows = tsv.parseRows;\nvar tsvFormat = tsv.format;\nvar tsvFormatRows = tsv.formatRows;\n\nvar center$1 = function(x, y) {\n var nodes;\n\n if (x == null) x = 0;\n if (y == null) y = 0;\n\n function force() {\n var i,\n n = nodes.length,\n node,\n sx = 0,\n sy = 0;\n\n for (i = 0; i < n; ++i) {\n node = nodes[i], sx += node.x, sy += node.y;\n }\n\n for (sx = sx / n - x, sy = sy / n - y, i = 0; i < n; ++i) {\n node = nodes[i], node.x -= sx, node.y -= sy;\n }\n }\n\n force.initialize = function(_) {\n nodes = _;\n };\n\n force.x = function(_) {\n return arguments.length ? (x = +_, force) : x;\n };\n\n force.y = function(_) {\n return arguments.length ? (y = +_, force) : y;\n };\n\n return force;\n};\n\nvar constant$6 = function(x) {\n return function() {\n return x;\n };\n};\n\nvar jiggle = function() {\n return (Math.random() - 0.5) * 1e-6;\n};\n\nvar tree_add = function(d) {\n var x = +this._x.call(null, d),\n y = +this._y.call(null, d);\n return add(this.cover(x, y), x, y, d);\n};\n\nfunction add(tree, x, y, d) {\n if (isNaN(x) || isNaN(y)) return tree; // ignore invalid points\n\n var parent,\n node = tree._root,\n leaf = {data: d},\n x0 = tree._x0,\n y0 = tree._y0,\n x1 = tree._x1,\n y1 = tree._y1,\n xm,\n ym,\n xp,\n yp,\n right,\n bottom,\n i,\n j;\n\n // If the tree is empty, initialize the root as a leaf.\n if (!node) return tree._root = leaf, tree;\n\n // Find the existing leaf for the new point, or add it.\n while (node.length) {\n if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm;\n if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym;\n if (parent = node, !(node = node[i = bottom << 1 | right])) return parent[i] = leaf, tree;\n }\n\n // Is the new point is exactly coincident with the existing point?\n xp = +tree._x.call(null, node.data);\n yp = +tree._y.call(null, node.data);\n if (x === xp && y === yp) return leaf.next = node, parent ? parent[i] = leaf : tree._root = leaf, tree;\n\n // Otherwise, split the leaf node until the old and new point are separated.\n do {\n parent = parent ? parent[i] = new Array(4) : tree._root = new Array(4);\n if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm;\n if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym;\n } while ((i = bottom << 1 | right) === (j = (yp >= ym) << 1 | (xp >= xm)));\n return parent[j] = node, parent[i] = leaf, tree;\n}\n\nfunction addAll(data) {\n var d, i, n = data.length,\n x,\n y,\n xz = new Array(n),\n yz = new Array(n),\n x0 = Infinity,\n y0 = Infinity,\n x1 = -Infinity,\n y1 = -Infinity;\n\n // Compute the points and their extent.\n for (i = 0; i < n; ++i) {\n if (isNaN(x = +this._x.call(null, d = data[i])) || isNaN(y = +this._y.call(null, d))) continue;\n xz[i] = x;\n yz[i] = y;\n if (x < x0) x0 = x;\n if (x > x1) x1 = x;\n if (y < y0) y0 = y;\n if (y > y1) y1 = y;\n }\n\n // If there were no (valid) points, inherit the existing extent.\n if (x1 < x0) x0 = this._x0, x1 = this._x1;\n if (y1 < y0) y0 = this._y0, y1 = this._y1;\n\n // Expand the tree to cover the new points.\n this.cover(x0, y0).cover(x1, y1);\n\n // Add the new points.\n for (i = 0; i < n; ++i) {\n add(this, xz[i], yz[i], data[i]);\n }\n\n return this;\n}\n\nvar tree_cover = function(x, y) {\n if (isNaN(x = +x) || isNaN(y = +y)) return this; // ignore invalid points\n\n var x0 = this._x0,\n y0 = this._y0,\n x1 = this._x1,\n y1 = this._y1;\n\n // If the quadtree has no extent, initialize them.\n // Integer extent are necessary so that if we later double the extent,\n // the existing quadrant boundaries don’t change due to floating point error!\n if (isNaN(x0)) {\n x1 = (x0 = Math.floor(x)) + 1;\n y1 = (y0 = Math.floor(y)) + 1;\n }\n\n // Otherwise, double repeatedly to cover.\n else if (x0 > x || x > x1 || y0 > y || y > y1) {\n var z = x1 - x0,\n node = this._root,\n parent,\n i;\n\n switch (i = (y < (y0 + y1) / 2) << 1 | (x < (x0 + x1) / 2)) {\n case 0: {\n do parent = new Array(4), parent[i] = node, node = parent;\n while (z *= 2, x1 = x0 + z, y1 = y0 + z, x > x1 || y > y1);\n break;\n }\n case 1: {\n do parent = new Array(4), parent[i] = node, node = parent;\n while (z *= 2, x0 = x1 - z, y1 = y0 + z, x0 > x || y > y1);\n break;\n }\n case 2: {\n do parent = new Array(4), parent[i] = node, node = parent;\n while (z *= 2, x1 = x0 + z, y0 = y1 - z, x > x1 || y0 > y);\n break;\n }\n case 3: {\n do parent = new Array(4), parent[i] = node, node = parent;\n while (z *= 2, x0 = x1 - z, y0 = y1 - z, x0 > x || y0 > y);\n break;\n }\n }\n\n if (this._root && this._root.length) this._root = node;\n }\n\n // If the quadtree covers the point already, just return.\n else return this;\n\n this._x0 = x0;\n this._y0 = y0;\n this._x1 = x1;\n this._y1 = y1;\n return this;\n};\n\nvar tree_data = function() {\n var data = [];\n this.visit(function(node) {\n if (!node.length) do data.push(node.data); while (node = node.next)\n });\n return data;\n};\n\nvar tree_extent = function(_) {\n return arguments.length\n ? this.cover(+_[0][0], +_[0][1]).cover(+_[1][0], +_[1][1])\n : isNaN(this._x0) ? undefined : [[this._x0, this._y0], [this._x1, this._y1]];\n};\n\nvar Quad = function(node, x0, y0, x1, y1) {\n this.node = node;\n this.x0 = x0;\n this.y0 = y0;\n this.x1 = x1;\n this.y1 = y1;\n};\n\nvar tree_find = function(x, y, radius) {\n var data,\n x0 = this._x0,\n y0 = this._y0,\n x1,\n y1,\n x2,\n y2,\n x3 = this._x1,\n y3 = this._y1,\n quads = [],\n node = this._root,\n q,\n i;\n\n if (node) quads.push(new Quad(node, x0, y0, x3, y3));\n if (radius == null) radius = Infinity;\n else {\n x0 = x - radius, y0 = y - radius;\n x3 = x + radius, y3 = y + radius;\n radius *= radius;\n }\n\n while (q = quads.pop()) {\n\n // Stop searching if this quadrant can’t contain a closer node.\n if (!(node = q.node)\n || (x1 = q.x0) > x3\n || (y1 = q.y0) > y3\n || (x2 = q.x1) < x0\n || (y2 = q.y1) < y0) continue;\n\n // Bisect the current quadrant.\n if (node.length) {\n var xm = (x1 + x2) / 2,\n ym = (y1 + y2) / 2;\n\n quads.push(\n new Quad(node[3], xm, ym, x2, y2),\n new Quad(node[2], x1, ym, xm, y2),\n new Quad(node[1], xm, y1, x2, ym),\n new Quad(node[0], x1, y1, xm, ym)\n );\n\n // Visit the closest quadrant first.\n if (i = (y >= ym) << 1 | (x >= xm)) {\n q = quads[quads.length - 1];\n quads[quads.length - 1] = quads[quads.length - 1 - i];\n quads[quads.length - 1 - i] = q;\n }\n }\n\n // Visit this point. (Visiting coincident points isn’t necessary!)\n else {\n var dx = x - +this._x.call(null, node.data),\n dy = y - +this._y.call(null, node.data),\n d2 = dx * dx + dy * dy;\n if (d2 < radius) {\n var d = Math.sqrt(radius = d2);\n x0 = x - d, y0 = y - d;\n x3 = x + d, y3 = y + d;\n data = node.data;\n }\n }\n }\n\n return data;\n};\n\nvar tree_remove = function(d) {\n if (isNaN(x = +this._x.call(null, d)) || isNaN(y = +this._y.call(null, d))) return this; // ignore invalid points\n\n var parent,\n node = this._root,\n retainer,\n previous,\n next,\n x0 = this._x0,\n y0 = this._y0,\n x1 = this._x1,\n y1 = this._y1,\n x,\n y,\n xm,\n ym,\n right,\n bottom,\n i,\n j;\n\n // If the tree is empty, initialize the root as a leaf.\n if (!node) return this;\n\n // Find the leaf node for the point.\n // While descending, also retain the deepest parent with a non-removed sibling.\n if (node.length) while (true) {\n if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm;\n if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym;\n if (!(parent = node, node = node[i = bottom << 1 | right])) return this;\n if (!node.length) break;\n if (parent[(i + 1) & 3] || parent[(i + 2) & 3] || parent[(i + 3) & 3]) retainer = parent, j = i;\n }\n\n // Find the point to remove.\n while (node.data !== d) if (!(previous = node, node = node.next)) return this;\n if (next = node.next) delete node.next;\n\n // If there are multiple coincident points, remove just the point.\n if (previous) return (next ? previous.next = next : delete previous.next), this;\n\n // If this is the root point, remove it.\n if (!parent) return this._root = next, this;\n\n // Remove this leaf.\n next ? parent[i] = next : delete parent[i];\n\n // If the parent now contains exactly one leaf, collapse superfluous parents.\n if ((node = parent[0] || parent[1] || parent[2] || parent[3])\n && node === (parent[3] || parent[2] || parent[1] || parent[0])\n && !node.length) {\n if (retainer) retainer[j] = node;\n else this._root = node;\n }\n\n return this;\n};\n\nfunction removeAll(data) {\n for (var i = 0, n = data.length; i < n; ++i) this.remove(data[i]);\n return this;\n}\n\nvar tree_root = function() {\n return this._root;\n};\n\nvar tree_size = function() {\n var size = 0;\n this.visit(function(node) {\n if (!node.length) do ++size; while (node = node.next)\n });\n return size;\n};\n\nvar tree_visit = function(callback) {\n var quads = [], q, node = this._root, child, x0, y0, x1, y1;\n if (node) quads.push(new Quad(node, this._x0, this._y0, this._x1, this._y1));\n while (q = quads.pop()) {\n if (!callback(node = q.node, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1) && node.length) {\n var xm = (x0 + x1) / 2, ym = (y0 + y1) / 2;\n if (child = node[3]) quads.push(new Quad(child, xm, ym, x1, y1));\n if (child = node[2]) quads.push(new Quad(child, x0, ym, xm, y1));\n if (child = node[1]) quads.push(new Quad(child, xm, y0, x1, ym));\n if (child = node[0]) quads.push(new Quad(child, x0, y0, xm, ym));\n }\n }\n return this;\n};\n\nvar tree_visitAfter = function(callback) {\n var quads = [], next = [], q;\n if (this._root) quads.push(new Quad(this._root, this._x0, this._y0, this._x1, this._y1));\n while (q = quads.pop()) {\n var node = q.node;\n if (node.length) {\n var child, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1, xm = (x0 + x1) / 2, ym = (y0 + y1) / 2;\n if (child = node[0]) quads.push(new Quad(child, x0, y0, xm, ym));\n if (child = node[1]) quads.push(new Quad(child, xm, y0, x1, ym));\n if (child = node[2]) quads.push(new Quad(child, x0, ym, xm, y1));\n if (child = node[3]) quads.push(new Quad(child, xm, ym, x1, y1));\n }\n next.push(q);\n }\n while (q = next.pop()) {\n callback(q.node, q.x0, q.y0, q.x1, q.y1);\n }\n return this;\n};\n\nfunction defaultX(d) {\n return d[0];\n}\n\nvar tree_x = function(_) {\n return arguments.length ? (this._x = _, this) : this._x;\n};\n\nfunction defaultY(d) {\n return d[1];\n}\n\nvar tree_y = function(_) {\n return arguments.length ? (this._y = _, this) : this._y;\n};\n\nfunction quadtree(nodes, x, y) {\n var tree = new Quadtree(x == null ? defaultX : x, y == null ? defaultY : y, NaN, NaN, NaN, NaN);\n return nodes == null ? tree : tree.addAll(nodes);\n}\n\nfunction Quadtree(x, y, x0, y0, x1, y1) {\n this._x = x;\n this._y = y;\n this._x0 = x0;\n this._y0 = y0;\n this._x1 = x1;\n this._y1 = y1;\n this._root = undefined;\n}\n\nfunction leaf_copy(leaf) {\n var copy = {data: leaf.data}, next = copy;\n while (leaf = leaf.next) next = next.next = {data: leaf.data};\n return copy;\n}\n\nvar treeProto = quadtree.prototype = Quadtree.prototype;\n\ntreeProto.copy = function() {\n var copy = new Quadtree(this._x, this._y, this._x0, this._y0, this._x1, this._y1),\n node = this._root,\n nodes,\n child;\n\n if (!node) return copy;\n\n if (!node.length) return copy._root = leaf_copy(node), copy;\n\n nodes = [{source: node, target: copy._root = new Array(4)}];\n while (node = nodes.pop()) {\n for (var i = 0; i < 4; ++i) {\n if (child = node.source[i]) {\n if (child.length) nodes.push({source: child, target: node.target[i] = new Array(4)});\n else node.target[i] = leaf_copy(child);\n }\n }\n }\n\n return copy;\n};\n\ntreeProto.add = tree_add;\ntreeProto.addAll = addAll;\ntreeProto.cover = tree_cover;\ntreeProto.data = tree_data;\ntreeProto.extent = tree_extent;\ntreeProto.find = tree_find;\ntreeProto.remove = tree_remove;\ntreeProto.removeAll = removeAll;\ntreeProto.root = tree_root;\ntreeProto.size = tree_size;\ntreeProto.visit = tree_visit;\ntreeProto.visitAfter = tree_visitAfter;\ntreeProto.x = tree_x;\ntreeProto.y = tree_y;\n\nfunction x(d) {\n return d.x + d.vx;\n}\n\nfunction y(d) {\n return d.y + d.vy;\n}\n\nvar collide = function(radius) {\n var nodes,\n radii,\n strength = 1,\n iterations = 1;\n\n if (typeof radius !== \"function\") radius = constant$6(radius == null ? 1 : +radius);\n\n function force() {\n var i, n = nodes.length,\n tree,\n node,\n xi,\n yi,\n ri,\n ri2;\n\n for (var k = 0; k < iterations; ++k) {\n tree = quadtree(nodes, x, y).visitAfter(prepare);\n for (i = 0; i < n; ++i) {\n node = nodes[i];\n ri = radii[node.index], ri2 = ri * ri;\n xi = node.x + node.vx;\n yi = node.y + node.vy;\n tree.visit(apply);\n }\n }\n\n function apply(quad, x0, y0, x1, y1) {\n var data = quad.data, rj = quad.r, r = ri + rj;\n if (data) {\n if (data.index > node.index) {\n var x = xi - data.x - data.vx,\n y = yi - data.y - data.vy,\n l = x * x + y * y;\n if (l < r * r) {\n if (x === 0) x = jiggle(), l += x * x;\n if (y === 0) y = jiggle(), l += y * y;\n l = (r - (l = Math.sqrt(l))) / l * strength;\n node.vx += (x *= l) * (r = (rj *= rj) / (ri2 + rj));\n node.vy += (y *= l) * r;\n data.vx -= x * (r = 1 - r);\n data.vy -= y * r;\n }\n }\n return;\n }\n return x0 > xi + r || x1 < xi - r || y0 > yi + r || y1 < yi - r;\n }\n }\n\n function prepare(quad) {\n if (quad.data) return quad.r = radii[quad.data.index];\n for (var i = quad.r = 0; i < 4; ++i) {\n if (quad[i] && quad[i].r > quad.r) {\n quad.r = quad[i].r;\n }\n }\n }\n\n function initialize() {\n if (!nodes) return;\n var i, n = nodes.length, node;\n radii = new Array(n);\n for (i = 0; i < n; ++i) node = nodes[i], radii[node.index] = +radius(node, i, nodes);\n }\n\n force.initialize = function(_) {\n nodes = _;\n initialize();\n };\n\n force.iterations = function(_) {\n return arguments.length ? (iterations = +_, force) : iterations;\n };\n\n force.strength = function(_) {\n return arguments.length ? (strength = +_, force) : strength;\n };\n\n force.radius = function(_) {\n return arguments.length ? (radius = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : radius;\n };\n\n return force;\n};\n\nfunction index(d) {\n return d.index;\n}\n\nfunction find(nodeById, nodeId) {\n var node = nodeById.get(nodeId);\n if (!node) throw new Error(\"missing: \" + nodeId);\n return node;\n}\n\nvar link = function(links) {\n var id = index,\n strength = defaultStrength,\n strengths,\n distance = constant$6(30),\n distances,\n nodes,\n count,\n bias,\n iterations = 1;\n\n if (links == null) links = [];\n\n function defaultStrength(link) {\n return 1 / Math.min(count[link.source.index], count[link.target.index]);\n }\n\n function force(alpha) {\n for (var k = 0, n = links.length; k < iterations; ++k) {\n for (var i = 0, link, source, target, x, y, l, b; i < n; ++i) {\n link = links[i], source = link.source, target = link.target;\n x = target.x + target.vx - source.x - source.vx || jiggle();\n y = target.y + target.vy - source.y - source.vy || jiggle();\n l = Math.sqrt(x * x + y * y);\n l = (l - distances[i]) / l * alpha * strengths[i];\n x *= l, y *= l;\n target.vx -= x * (b = bias[i]);\n target.vy -= y * b;\n source.vx += x * (b = 1 - b);\n source.vy += y * b;\n }\n }\n }\n\n function initialize() {\n if (!nodes) return;\n\n var i,\n n = nodes.length,\n m = links.length,\n nodeById = map$1(nodes, id),\n link;\n\n for (i = 0, count = new Array(n); i < m; ++i) {\n link = links[i], link.index = i;\n if (typeof link.source !== \"object\") link.source = find(nodeById, link.source);\n if (typeof link.target !== \"object\") link.target = find(nodeById, link.target);\n count[link.source.index] = (count[link.source.index] || 0) + 1;\n count[link.target.index] = (count[link.target.index] || 0) + 1;\n }\n\n for (i = 0, bias = new Array(m); i < m; ++i) {\n link = links[i], bias[i] = count[link.source.index] / (count[link.source.index] + count[link.target.index]);\n }\n\n strengths = new Array(m), initializeStrength();\n distances = new Array(m), initializeDistance();\n }\n\n function initializeStrength() {\n if (!nodes) return;\n\n for (var i = 0, n = links.length; i < n; ++i) {\n strengths[i] = +strength(links[i], i, links);\n }\n }\n\n function initializeDistance() {\n if (!nodes) return;\n\n for (var i = 0, n = links.length; i < n; ++i) {\n distances[i] = +distance(links[i], i, links);\n }\n }\n\n force.initialize = function(_) {\n nodes = _;\n initialize();\n };\n\n force.links = function(_) {\n return arguments.length ? (links = _, initialize(), force) : links;\n };\n\n force.id = function(_) {\n return arguments.length ? (id = _, force) : id;\n };\n\n force.iterations = function(_) {\n return arguments.length ? (iterations = +_, force) : iterations;\n };\n\n force.strength = function(_) {\n return arguments.length ? (strength = typeof _ === \"function\" ? _ : constant$6(+_), initializeStrength(), force) : strength;\n };\n\n force.distance = function(_) {\n return arguments.length ? (distance = typeof _ === \"function\" ? _ : constant$6(+_), initializeDistance(), force) : distance;\n };\n\n return force;\n};\n\nfunction x$1(d) {\n return d.x;\n}\n\nfunction y$1(d) {\n return d.y;\n}\n\nvar initialRadius = 10;\nvar initialAngle = Math.PI * (3 - Math.sqrt(5));\n\nvar simulation = function(nodes) {\n var simulation,\n alpha = 1,\n alphaMin = 0.001,\n alphaDecay = 1 - Math.pow(alphaMin, 1 / 300),\n alphaTarget = 0,\n velocityDecay = 0.6,\n forces = map$1(),\n stepper = timer(step),\n event = dispatch(\"tick\", \"end\");\n\n if (nodes == null) nodes = [];\n\n function step() {\n tick();\n event.call(\"tick\", simulation);\n if (alpha < alphaMin) {\n stepper.stop();\n event.call(\"end\", simulation);\n }\n }\n\n function tick() {\n var i, n = nodes.length, node;\n\n alpha += (alphaTarget - alpha) * alphaDecay;\n\n forces.each(function(force) {\n force(alpha);\n });\n\n for (i = 0; i < n; ++i) {\n node = nodes[i];\n if (node.fx == null) node.x += node.vx *= velocityDecay;\n else node.x = node.fx, node.vx = 0;\n if (node.fy == null) node.y += node.vy *= velocityDecay;\n else node.y = node.fy, node.vy = 0;\n }\n }\n\n function initializeNodes() {\n for (var i = 0, n = nodes.length, node; i < n; ++i) {\n node = nodes[i], node.index = i;\n if (isNaN(node.x) || isNaN(node.y)) {\n var radius = initialRadius * Math.sqrt(i), angle = i * initialAngle;\n node.x = radius * Math.cos(angle);\n node.y = radius * Math.sin(angle);\n }\n if (isNaN(node.vx) || isNaN(node.vy)) {\n node.vx = node.vy = 0;\n }\n }\n }\n\n function initializeForce(force) {\n if (force.initialize) force.initialize(nodes);\n return force;\n }\n\n initializeNodes();\n\n return simulation = {\n tick: tick,\n\n restart: function() {\n return stepper.restart(step), simulation;\n },\n\n stop: function() {\n return stepper.stop(), simulation;\n },\n\n nodes: function(_) {\n return arguments.length ? (nodes = _, initializeNodes(), forces.each(initializeForce), simulation) : nodes;\n },\n\n alpha: function(_) {\n return arguments.length ? (alpha = +_, simulation) : alpha;\n },\n\n alphaMin: function(_) {\n return arguments.length ? (alphaMin = +_, simulation) : alphaMin;\n },\n\n alphaDecay: function(_) {\n return arguments.length ? (alphaDecay = +_, simulation) : +alphaDecay;\n },\n\n alphaTarget: function(_) {\n return arguments.length ? (alphaTarget = +_, simulation) : alphaTarget;\n },\n\n velocityDecay: function(_) {\n return arguments.length ? (velocityDecay = 1 - _, simulation) : 1 - velocityDecay;\n },\n\n force: function(name, _) {\n return arguments.length > 1 ? ((_ == null ? forces.remove(name) : forces.set(name, initializeForce(_))), simulation) : forces.get(name);\n },\n\n find: function(x, y, radius) {\n var i = 0,\n n = nodes.length,\n dx,\n dy,\n d2,\n node,\n closest;\n\n if (radius == null) radius = Infinity;\n else radius *= radius;\n\n for (i = 0; i < n; ++i) {\n node = nodes[i];\n dx = x - node.x;\n dy = y - node.y;\n d2 = dx * dx + dy * dy;\n if (d2 < radius) closest = node, radius = d2;\n }\n\n return closest;\n },\n\n on: function(name, _) {\n return arguments.length > 1 ? (event.on(name, _), simulation) : event.on(name);\n }\n };\n};\n\nvar manyBody = function() {\n var nodes,\n node,\n alpha,\n strength = constant$6(-30),\n strengths,\n distanceMin2 = 1,\n distanceMax2 = Infinity,\n theta2 = 0.81;\n\n function force(_) {\n var i, n = nodes.length, tree = quadtree(nodes, x$1, y$1).visitAfter(accumulate);\n for (alpha = _, i = 0; i < n; ++i) node = nodes[i], tree.visit(apply);\n }\n\n function initialize() {\n if (!nodes) return;\n var i, n = nodes.length, node;\n strengths = new Array(n);\n for (i = 0; i < n; ++i) node = nodes[i], strengths[node.index] = +strength(node, i, nodes);\n }\n\n function accumulate(quad) {\n var strength = 0, q, c, x$$1, y$$1, i;\n\n // For internal nodes, accumulate forces from child quadrants.\n if (quad.length) {\n for (x$$1 = y$$1 = i = 0; i < 4; ++i) {\n if ((q = quad[i]) && (c = q.value)) {\n strength += c, x$$1 += c * q.x, y$$1 += c * q.y;\n }\n }\n quad.x = x$$1 / strength;\n quad.y = y$$1 / strength;\n }\n\n // For leaf nodes, accumulate forces from coincident quadrants.\n else {\n q = quad;\n q.x = q.data.x;\n q.y = q.data.y;\n do strength += strengths[q.data.index];\n while (q = q.next);\n }\n\n quad.value = strength;\n }\n\n function apply(quad, x1, _, x2) {\n if (!quad.value) return true;\n\n var x$$1 = quad.x - node.x,\n y$$1 = quad.y - node.y,\n w = x2 - x1,\n l = x$$1 * x$$1 + y$$1 * y$$1;\n\n // Apply the Barnes-Hut approximation if possible.\n // Limit forces for very close nodes; randomize direction if coincident.\n if (w * w / theta2 < l) {\n if (l < distanceMax2) {\n if (x$$1 === 0) x$$1 = jiggle(), l += x$$1 * x$$1;\n if (y$$1 === 0) y$$1 = jiggle(), l += y$$1 * y$$1;\n if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l);\n node.vx += x$$1 * quad.value * alpha / l;\n node.vy += y$$1 * quad.value * alpha / l;\n }\n return true;\n }\n\n // Otherwise, process points directly.\n else if (quad.length || l >= distanceMax2) return;\n\n // Limit forces for very close nodes; randomize direction if coincident.\n if (quad.data !== node || quad.next) {\n if (x$$1 === 0) x$$1 = jiggle(), l += x$$1 * x$$1;\n if (y$$1 === 0) y$$1 = jiggle(), l += y$$1 * y$$1;\n if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l);\n }\n\n do if (quad.data !== node) {\n w = strengths[quad.data.index] * alpha / l;\n node.vx += x$$1 * w;\n node.vy += y$$1 * w;\n } while (quad = quad.next);\n }\n\n force.initialize = function(_) {\n nodes = _;\n initialize();\n };\n\n force.strength = function(_) {\n return arguments.length ? (strength = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : strength;\n };\n\n force.distanceMin = function(_) {\n return arguments.length ? (distanceMin2 = _ * _, force) : Math.sqrt(distanceMin2);\n };\n\n force.distanceMax = function(_) {\n return arguments.length ? (distanceMax2 = _ * _, force) : Math.sqrt(distanceMax2);\n };\n\n force.theta = function(_) {\n return arguments.length ? (theta2 = _ * _, force) : Math.sqrt(theta2);\n };\n\n return force;\n};\n\nvar x$2 = function(x) {\n var strength = constant$6(0.1),\n nodes,\n strengths,\n xz;\n\n if (typeof x !== \"function\") x = constant$6(x == null ? 0 : +x);\n\n function force(alpha) {\n for (var i = 0, n = nodes.length, node; i < n; ++i) {\n node = nodes[i], node.vx += (xz[i] - node.x) * strengths[i] * alpha;\n }\n }\n\n function initialize() {\n if (!nodes) return;\n var i, n = nodes.length;\n strengths = new Array(n);\n xz = new Array(n);\n for (i = 0; i < n; ++i) {\n strengths[i] = isNaN(xz[i] = +x(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes);\n }\n }\n\n force.initialize = function(_) {\n nodes = _;\n initialize();\n };\n\n force.strength = function(_) {\n return arguments.length ? (strength = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : strength;\n };\n\n force.x = function(_) {\n return arguments.length ? (x = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : x;\n };\n\n return force;\n};\n\nvar y$2 = function(y) {\n var strength = constant$6(0.1),\n nodes,\n strengths,\n yz;\n\n if (typeof y !== \"function\") y = constant$6(y == null ? 0 : +y);\n\n function force(alpha) {\n for (var i = 0, n = nodes.length, node; i < n; ++i) {\n node = nodes[i], node.vy += (yz[i] - node.y) * strengths[i] * alpha;\n }\n }\n\n function initialize() {\n if (!nodes) return;\n var i, n = nodes.length;\n strengths = new Array(n);\n yz = new Array(n);\n for (i = 0; i < n; ++i) {\n strengths[i] = isNaN(yz[i] = +y(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes);\n }\n }\n\n force.initialize = function(_) {\n nodes = _;\n initialize();\n };\n\n force.strength = function(_) {\n return arguments.length ? (strength = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : strength;\n };\n\n force.y = function(_) {\n return arguments.length ? (y = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : y;\n };\n\n return force;\n};\n\n// Computes the decimal coefficient and exponent of the specified number x with\n// significant digits p, where x is positive and p is in [1, 21] or undefined.\n// For example, formatDecimal(1.23) returns [\"123\", 0].\nvar formatDecimal = function(x, p) {\n if ((i = (x = p ? x.toExponential(p - 1) : x.toExponential()).indexOf(\"e\")) < 0) return null; // NaN, ±Infinity\n var i, coefficient = x.slice(0, i);\n\n // The string returned by toExponential either has the form \\d\\.\\d+e[-+]\\d+\n // (e.g., 1.2e+3) or the form \\de[-+]\\d+ (e.g., 1e+3).\n return [\n coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient,\n +x.slice(i + 1)\n ];\n};\n\nvar exponent$1 = function(x) {\n return x = formatDecimal(Math.abs(x)), x ? x[1] : NaN;\n};\n\nvar formatGroup = function(grouping, thousands) {\n return function(value, width) {\n var i = value.length,\n t = [],\n j = 0,\n g = grouping[0],\n length = 0;\n\n while (i > 0 && g > 0) {\n if (length + g + 1 > width) g = Math.max(1, width - length);\n t.push(value.substring(i -= g, i + g));\n if ((length += g + 1) > width) break;\n g = grouping[j = (j + 1) % grouping.length];\n }\n\n return t.reverse().join(thousands);\n };\n};\n\nvar formatDefault = function(x, p) {\n x = x.toPrecision(p);\n\n out: for (var n = x.length, i = 1, i0 = -1, i1; i < n; ++i) {\n switch (x[i]) {\n case \".\": i0 = i1 = i; break;\n case \"0\": if (i0 === 0) i0 = i; i1 = i; break;\n case \"e\": break out;\n default: if (i0 > 0) i0 = 0; break;\n }\n }\n\n return i0 > 0 ? x.slice(0, i0) + x.slice(i1 + 1) : x;\n};\n\nvar prefixExponent;\n\nvar formatPrefixAuto = function(x, p) {\n var d = formatDecimal(x, p);\n if (!d) return x + \"\";\n var coefficient = d[0],\n exponent = d[1],\n i = exponent - (prefixExponent = Math.max(-8, Math.min(8, Math.floor(exponent / 3))) * 3) + 1,\n n = coefficient.length;\n return i === n ? coefficient\n : i > n ? coefficient + new Array(i - n + 1).join(\"0\")\n : i > 0 ? coefficient.slice(0, i) + \".\" + coefficient.slice(i)\n : \"0.\" + new Array(1 - i).join(\"0\") + formatDecimal(x, Math.max(0, p + i - 1))[0]; // less than 1y!\n};\n\nvar formatRounded = function(x, p) {\n var d = formatDecimal(x, p);\n if (!d) return x + \"\";\n var coefficient = d[0],\n exponent = d[1];\n return exponent < 0 ? \"0.\" + new Array(-exponent).join(\"0\") + coefficient\n : coefficient.length > exponent + 1 ? coefficient.slice(0, exponent + 1) + \".\" + coefficient.slice(exponent + 1)\n : coefficient + new Array(exponent - coefficient.length + 2).join(\"0\");\n};\n\nvar formatTypes = {\n \"\": formatDefault,\n \"%\": function(x, p) { return (x * 100).toFixed(p); },\n \"b\": function(x) { return Math.round(x).toString(2); },\n \"c\": function(x) { return x + \"\"; },\n \"d\": function(x) { return Math.round(x).toString(10); },\n \"e\": function(x, p) { return x.toExponential(p); },\n \"f\": function(x, p) { return x.toFixed(p); },\n \"g\": function(x, p) { return x.toPrecision(p); },\n \"o\": function(x) { return Math.round(x).toString(8); },\n \"p\": function(x, p) { return formatRounded(x * 100, p); },\n \"r\": formatRounded,\n \"s\": formatPrefixAuto,\n \"X\": function(x) { return Math.round(x).toString(16).toUpperCase(); },\n \"x\": function(x) { return Math.round(x).toString(16); }\n};\n\n// [[fill]align][sign][symbol][0][width][,][.precision][type]\nvar re = /^(?:(.)?([<>=^]))?([+\\-\\( ])?([$#])?(0)?(\\d+)?(,)?(\\.\\d+)?([a-z%])?$/i;\n\nvar formatSpecifier = function(specifier) {\n return new FormatSpecifier(specifier);\n};\n\nfunction FormatSpecifier(specifier) {\n if (!(match = re.exec(specifier))) throw new Error(\"invalid format: \" + specifier);\n\n var match,\n fill = match[1] || \" \",\n align = match[2] || \">\",\n sign = match[3] || \"-\",\n symbol = match[4] || \"\",\n zero = !!match[5],\n width = match[6] && +match[6],\n comma = !!match[7],\n precision = match[8] && +match[8].slice(1),\n type = match[9] || \"\";\n\n // The \"n\" type is an alias for \",g\".\n if (type === \"n\") comma = true, type = \"g\";\n\n // Map invalid types to the default format.\n else if (!formatTypes[type]) type = \"\";\n\n // If zero fill is specified, padding goes after sign and before digits.\n if (zero || (fill === \"0\" && align === \"=\")) zero = true, fill = \"0\", align = \"=\";\n\n this.fill = fill;\n this.align = align;\n this.sign = sign;\n this.symbol = symbol;\n this.zero = zero;\n this.width = width;\n this.comma = comma;\n this.precision = precision;\n this.type = type;\n}\n\nFormatSpecifier.prototype.toString = function() {\n return this.fill\n + this.align\n + this.sign\n + this.symbol\n + (this.zero ? \"0\" : \"\")\n + (this.width == null ? \"\" : Math.max(1, this.width | 0))\n + (this.comma ? \",\" : \"\")\n + (this.precision == null ? \"\" : \".\" + Math.max(0, this.precision | 0))\n + this.type;\n};\n\nvar prefixes = [\"y\",\"z\",\"a\",\"f\",\"p\",\"n\",\"\\xB5\",\"m\",\"\",\"k\",\"M\",\"G\",\"T\",\"P\",\"E\",\"Z\",\"Y\"];\n\nfunction identity$3(x) {\n return x;\n}\n\nvar formatLocale = function(locale) {\n var group = locale.grouping && locale.thousands ? formatGroup(locale.grouping, locale.thousands) : identity$3,\n currency = locale.currency,\n decimal = locale.decimal;\n\n function newFormat(specifier) {\n specifier = formatSpecifier(specifier);\n\n var fill = specifier.fill,\n align = specifier.align,\n sign = specifier.sign,\n symbol = specifier.symbol,\n zero = specifier.zero,\n width = specifier.width,\n comma = specifier.comma,\n precision = specifier.precision,\n type = specifier.type;\n\n // Compute the prefix and suffix.\n // For SI-prefix, the suffix is lazily computed.\n var prefix = symbol === \"$\" ? currency[0] : symbol === \"#\" && /[boxX]/.test(type) ? \"0\" + type.toLowerCase() : \"\",\n suffix = symbol === \"$\" ? currency[1] : /[%p]/.test(type) ? \"%\" : \"\";\n\n // What format function should we use?\n // Is this an integer type?\n // Can this type generate exponential notation?\n var formatType = formatTypes[type],\n maybeSuffix = !type || /[defgprs%]/.test(type);\n\n // Set the default precision if not specified,\n // or clamp the specified precision to the supported range.\n // For significant precision, it must be in [1, 21].\n // For fixed precision, it must be in [0, 20].\n precision = precision == null ? (type ? 6 : 12)\n : /[gprs]/.test(type) ? Math.max(1, Math.min(21, precision))\n : Math.max(0, Math.min(20, precision));\n\n function format(value) {\n var valuePrefix = prefix,\n valueSuffix = suffix,\n i, n, c;\n\n if (type === \"c\") {\n valueSuffix = formatType(value) + valueSuffix;\n value = \"\";\n } else {\n value = +value;\n\n // Convert negative to positive, and compute the prefix.\n // Note that -0 is not less than 0, but 1 / -0 is!\n var valueNegative = (value < 0 || 1 / value < 0) && (value *= -1, true);\n\n // Perform the initial formatting.\n value = formatType(value, precision);\n\n // If the original value was negative, it may be rounded to zero during\n // formatting; treat this as (positive) zero.\n if (valueNegative) {\n i = -1, n = value.length;\n valueNegative = false;\n while (++i < n) {\n if (c = value.charCodeAt(i), (48 < c && c < 58)\n || (type === \"x\" && 96 < c && c < 103)\n || (type === \"X\" && 64 < c && c < 71)) {\n valueNegative = true;\n break;\n }\n }\n }\n\n // Compute the prefix and suffix.\n valuePrefix = (valueNegative ? (sign === \"(\" ? sign : \"-\") : sign === \"-\" || sign === \"(\" ? \"\" : sign) + valuePrefix;\n valueSuffix = valueSuffix + (type === \"s\" ? prefixes[8 + prefixExponent / 3] : \"\") + (valueNegative && sign === \"(\" ? \")\" : \"\");\n\n // Break the formatted value into the integer “value” part that can be\n // grouped, and fractional or exponential “suffix” part that is not.\n if (maybeSuffix) {\n i = -1, n = value.length;\n while (++i < n) {\n if (c = value.charCodeAt(i), 48 > c || c > 57) {\n valueSuffix = (c === 46 ? decimal + value.slice(i + 1) : value.slice(i)) + valueSuffix;\n value = value.slice(0, i);\n break;\n }\n }\n }\n }\n\n // If the fill character is not \"0\", grouping is applied before padding.\n if (comma && !zero) value = group(value, Infinity);\n\n // Compute the padding.\n var length = valuePrefix.length + value.length + valueSuffix.length,\n padding = length < width ? new Array(width - length + 1).join(fill) : \"\";\n\n // If the fill character is \"0\", grouping is applied after padding.\n if (comma && zero) value = group(padding + value, padding.length ? width - valueSuffix.length : Infinity), padding = \"\";\n\n // Reconstruct the final output based on the desired alignment.\n switch (align) {\n case \"<\": return valuePrefix + value + valueSuffix + padding;\n case \"=\": return valuePrefix + padding + value + valueSuffix;\n case \"^\": return padding.slice(0, length = padding.length >> 1) + valuePrefix + value + valueSuffix + padding.slice(length);\n }\n return padding + valuePrefix + value + valueSuffix;\n }\n\n format.toString = function() {\n return specifier + \"\";\n };\n\n return format;\n }\n\n function formatPrefix(specifier, value) {\n var f = newFormat((specifier = formatSpecifier(specifier), specifier.type = \"f\", specifier)),\n e = Math.max(-8, Math.min(8, Math.floor(exponent$1(value) / 3))) * 3,\n k = Math.pow(10, -e),\n prefix = prefixes[8 + e / 3];\n return function(value) {\n return f(k * value) + prefix;\n };\n }\n\n return {\n format: newFormat,\n formatPrefix: formatPrefix\n };\n};\n\nvar locale$1;\n\n\n\ndefaultLocale({\n decimal: \".\",\n thousands: \",\",\n grouping: [3],\n currency: [\"$\", \"\"]\n});\n\nfunction defaultLocale(definition) {\n locale$1 = formatLocale(definition);\n exports.format = locale$1.format;\n exports.formatPrefix = locale$1.formatPrefix;\n return locale$1;\n}\n\nvar precisionFixed = function(step) {\n return Math.max(0, -exponent$1(Math.abs(step)));\n};\n\nvar precisionPrefix = function(step, value) {\n return Math.max(0, Math.max(-8, Math.min(8, Math.floor(exponent$1(value) / 3))) * 3 - exponent$1(Math.abs(step)));\n};\n\nvar precisionRound = function(step, max) {\n step = Math.abs(step), max = Math.abs(max) - step;\n return Math.max(0, exponent$1(max) - exponent$1(step)) + 1;\n};\n\n// Adds floating point numbers with twice the normal precision.\n// Reference: J. R. Shewchuk, Adaptive Precision Floating-Point Arithmetic and\n// Fast Robust Geometric Predicates, Discrete & Computational Geometry 18(3)\n// 305–363 (1997).\n// Code adapted from GeographicLib by Charles F. F. Karney,\n// http://geographiclib.sourceforge.net/\n\nvar adder = function() {\n return new Adder;\n};\n\nfunction Adder() {\n this.reset();\n}\n\nAdder.prototype = {\n constructor: Adder,\n reset: function() {\n this.s = // rounded value\n this.t = 0; // exact error\n },\n add: function(y) {\n add$1(temp, y, this.t);\n add$1(this, temp.s, this.s);\n if (this.s) this.t += temp.t;\n else this.s = temp.t;\n },\n valueOf: function() {\n return this.s;\n }\n};\n\nvar temp = new Adder;\n\nfunction add$1(adder, a, b) {\n var x = adder.s = a + b,\n bv = x - a,\n av = x - bv;\n adder.t = (a - av) + (b - bv);\n}\n\nvar epsilon$2 = 1e-6;\nvar epsilon2$1 = 1e-12;\nvar pi$3 = Math.PI;\nvar halfPi$2 = pi$3 / 2;\nvar quarterPi = pi$3 / 4;\nvar tau$3 = pi$3 * 2;\n\nvar degrees$1 = 180 / pi$3;\nvar radians = pi$3 / 180;\n\nvar abs = Math.abs;\nvar atan = Math.atan;\nvar atan2 = Math.atan2;\nvar cos$1 = Math.cos;\nvar ceil = Math.ceil;\nvar exp = Math.exp;\n\nvar log = Math.log;\nvar pow = Math.pow;\nvar sin$1 = Math.sin;\nvar sign = Math.sign || function(x) { return x > 0 ? 1 : x < 0 ? -1 : 0; };\nvar sqrt = Math.sqrt;\nvar tan = Math.tan;\n\nfunction acos(x) {\n return x > 1 ? 0 : x < -1 ? pi$3 : Math.acos(x);\n}\n\nfunction asin(x) {\n return x > 1 ? halfPi$2 : x < -1 ? -halfPi$2 : Math.asin(x);\n}\n\nfunction haversin(x) {\n return (x = sin$1(x / 2)) * x;\n}\n\nfunction noop$1() {}\n\nfunction streamGeometry(geometry, stream) {\n if (geometry && streamGeometryType.hasOwnProperty(geometry.type)) {\n streamGeometryType[geometry.type](geometry, stream);\n }\n}\n\nvar streamObjectType = {\n Feature: function(feature, stream) {\n streamGeometry(feature.geometry, stream);\n },\n FeatureCollection: function(object, stream) {\n var features = object.features, i = -1, n = features.length;\n while (++i < n) streamGeometry(features[i].geometry, stream);\n }\n};\n\nvar streamGeometryType = {\n Sphere: function(object, stream) {\n stream.sphere();\n },\n Point: function(object, stream) {\n object = object.coordinates;\n stream.point(object[0], object[1], object[2]);\n },\n MultiPoint: function(object, stream) {\n var coordinates = object.coordinates, i = -1, n = coordinates.length;\n while (++i < n) object = coordinates[i], stream.point(object[0], object[1], object[2]);\n },\n LineString: function(object, stream) {\n streamLine(object.coordinates, stream, 0);\n },\n MultiLineString: function(object, stream) {\n var coordinates = object.coordinates, i = -1, n = coordinates.length;\n while (++i < n) streamLine(coordinates[i], stream, 0);\n },\n Polygon: function(object, stream) {\n streamPolygon(object.coordinates, stream);\n },\n MultiPolygon: function(object, stream) {\n var coordinates = object.coordinates, i = -1, n = coordinates.length;\n while (++i < n) streamPolygon(coordinates[i], stream);\n },\n GeometryCollection: function(object, stream) {\n var geometries = object.geometries, i = -1, n = geometries.length;\n while (++i < n) streamGeometry(geometries[i], stream);\n }\n};\n\nfunction streamLine(coordinates, stream, closed) {\n var i = -1, n = coordinates.length - closed, coordinate;\n stream.lineStart();\n while (++i < n) coordinate = coordinates[i], stream.point(coordinate[0], coordinate[1], coordinate[2]);\n stream.lineEnd();\n}\n\nfunction streamPolygon(coordinates, stream) {\n var i = -1, n = coordinates.length;\n stream.polygonStart();\n while (++i < n) streamLine(coordinates[i], stream, 1);\n stream.polygonEnd();\n}\n\nvar geoStream = function(object, stream) {\n if (object && streamObjectType.hasOwnProperty(object.type)) {\n streamObjectType[object.type](object, stream);\n } else {\n streamGeometry(object, stream);\n }\n};\n\nvar areaRingSum = adder();\n\nvar areaSum = adder();\nvar lambda00;\nvar phi00;\nvar lambda0;\nvar cosPhi0;\nvar sinPhi0;\n\nvar areaStream = {\n point: noop$1,\n lineStart: noop$1,\n lineEnd: noop$1,\n polygonStart: function() {\n areaRingSum.reset();\n areaStream.lineStart = areaRingStart;\n areaStream.lineEnd = areaRingEnd;\n },\n polygonEnd: function() {\n var areaRing = +areaRingSum;\n areaSum.add(areaRing < 0 ? tau$3 + areaRing : areaRing);\n this.lineStart = this.lineEnd = this.point = noop$1;\n },\n sphere: function() {\n areaSum.add(tau$3);\n }\n};\n\nfunction areaRingStart() {\n areaStream.point = areaPointFirst;\n}\n\nfunction areaRingEnd() {\n areaPoint(lambda00, phi00);\n}\n\nfunction areaPointFirst(lambda, phi) {\n areaStream.point = areaPoint;\n lambda00 = lambda, phi00 = phi;\n lambda *= radians, phi *= radians;\n lambda0 = lambda, cosPhi0 = cos$1(phi = phi / 2 + quarterPi), sinPhi0 = sin$1(phi);\n}\n\nfunction areaPoint(lambda, phi) {\n lambda *= radians, phi *= radians;\n phi = phi / 2 + quarterPi; // half the angular distance from south pole\n\n // Spherical excess E for a spherical triangle with vertices: south pole,\n // previous point, current point. Uses a formula derived from Cagnoli’s\n // theorem. See Todhunter, Spherical Trig. (1871), Sec. 103, Eq. (2).\n var dLambda = lambda - lambda0,\n sdLambda = dLambda >= 0 ? 1 : -1,\n adLambda = sdLambda * dLambda,\n cosPhi = cos$1(phi),\n sinPhi = sin$1(phi),\n k = sinPhi0 * sinPhi,\n u = cosPhi0 * cosPhi + k * cos$1(adLambda),\n v = k * sdLambda * sin$1(adLambda);\n areaRingSum.add(atan2(v, u));\n\n // Advance the previous points.\n lambda0 = lambda, cosPhi0 = cosPhi, sinPhi0 = sinPhi;\n}\n\nvar area = function(object) {\n areaSum.reset();\n geoStream(object, areaStream);\n return areaSum * 2;\n};\n\nfunction spherical(cartesian) {\n return [atan2(cartesian[1], cartesian[0]), asin(cartesian[2])];\n}\n\nfunction cartesian(spherical) {\n var lambda = spherical[0], phi = spherical[1], cosPhi = cos$1(phi);\n return [cosPhi * cos$1(lambda), cosPhi * sin$1(lambda), sin$1(phi)];\n}\n\nfunction cartesianDot(a, b) {\n return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];\n}\n\nfunction cartesianCross(a, b) {\n return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];\n}\n\n// TODO return a\nfunction cartesianAddInPlace(a, b) {\n a[0] += b[0], a[1] += b[1], a[2] += b[2];\n}\n\nfunction cartesianScale(vector, k) {\n return [vector[0] * k, vector[1] * k, vector[2] * k];\n}\n\n// TODO return d\nfunction cartesianNormalizeInPlace(d) {\n var l = sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);\n d[0] /= l, d[1] /= l, d[2] /= l;\n}\n\nvar lambda0$1;\nvar phi0;\nvar lambda1;\nvar phi1;\nvar lambda2;\nvar lambda00$1;\nvar phi00$1;\nvar p0;\nvar deltaSum = adder();\nvar ranges;\nvar range;\n\nvar boundsStream = {\n point: boundsPoint,\n lineStart: boundsLineStart,\n lineEnd: boundsLineEnd,\n polygonStart: function() {\n boundsStream.point = boundsRingPoint;\n boundsStream.lineStart = boundsRingStart;\n boundsStream.lineEnd = boundsRingEnd;\n deltaSum.reset();\n areaStream.polygonStart();\n },\n polygonEnd: function() {\n areaStream.polygonEnd();\n boundsStream.point = boundsPoint;\n boundsStream.lineStart = boundsLineStart;\n boundsStream.lineEnd = boundsLineEnd;\n if (areaRingSum < 0) lambda0$1 = -(lambda1 = 180), phi0 = -(phi1 = 90);\n else if (deltaSum > epsilon$2) phi1 = 90;\n else if (deltaSum < -epsilon$2) phi0 = -90;\n range[0] = lambda0$1, range[1] = lambda1;\n }\n};\n\nfunction boundsPoint(lambda, phi) {\n ranges.push(range = [lambda0$1 = lambda, lambda1 = lambda]);\n if (phi < phi0) phi0 = phi;\n if (phi > phi1) phi1 = phi;\n}\n\nfunction linePoint(lambda, phi) {\n var p = cartesian([lambda * radians, phi * radians]);\n if (p0) {\n var normal = cartesianCross(p0, p),\n equatorial = [normal[1], -normal[0], 0],\n inflection = cartesianCross(equatorial, normal);\n cartesianNormalizeInPlace(inflection);\n inflection = spherical(inflection);\n var delta = lambda - lambda2,\n sign$$1 = delta > 0 ? 1 : -1,\n lambdai = inflection[0] * degrees$1 * sign$$1,\n phii,\n antimeridian = abs(delta) > 180;\n if (antimeridian ^ (sign$$1 * lambda2 < lambdai && lambdai < sign$$1 * lambda)) {\n phii = inflection[1] * degrees$1;\n if (phii > phi1) phi1 = phii;\n } else if (lambdai = (lambdai + 360) % 360 - 180, antimeridian ^ (sign$$1 * lambda2 < lambdai && lambdai < sign$$1 * lambda)) {\n phii = -inflection[1] * degrees$1;\n if (phii < phi0) phi0 = phii;\n } else {\n if (phi < phi0) phi0 = phi;\n if (phi > phi1) phi1 = phi;\n }\n if (antimeridian) {\n if (lambda < lambda2) {\n if (angle(lambda0$1, lambda) > angle(lambda0$1, lambda1)) lambda1 = lambda;\n } else {\n if (angle(lambda, lambda1) > angle(lambda0$1, lambda1)) lambda0$1 = lambda;\n }\n } else {\n if (lambda1 >= lambda0$1) {\n if (lambda < lambda0$1) lambda0$1 = lambda;\n if (lambda > lambda1) lambda1 = lambda;\n } else {\n if (lambda > lambda2) {\n if (angle(lambda0$1, lambda) > angle(lambda0$1, lambda1)) lambda1 = lambda;\n } else {\n if (angle(lambda, lambda1) > angle(lambda0$1, lambda1)) lambda0$1 = lambda;\n }\n }\n }\n } else {\n ranges.push(range = [lambda0$1 = lambda, lambda1 = lambda]);\n }\n if (phi < phi0) phi0 = phi;\n if (phi > phi1) phi1 = phi;\n p0 = p, lambda2 = lambda;\n}\n\nfunction boundsLineStart() {\n boundsStream.point = linePoint;\n}\n\nfunction boundsLineEnd() {\n range[0] = lambda0$1, range[1] = lambda1;\n boundsStream.point = boundsPoint;\n p0 = null;\n}\n\nfunction boundsRingPoint(lambda, phi) {\n if (p0) {\n var delta = lambda - lambda2;\n deltaSum.add(abs(delta) > 180 ? delta + (delta > 0 ? 360 : -360) : delta);\n } else {\n lambda00$1 = lambda, phi00$1 = phi;\n }\n areaStream.point(lambda, phi);\n linePoint(lambda, phi);\n}\n\nfunction boundsRingStart() {\n areaStream.lineStart();\n}\n\nfunction boundsRingEnd() {\n boundsRingPoint(lambda00$1, phi00$1);\n areaStream.lineEnd();\n if (abs(deltaSum) > epsilon$2) lambda0$1 = -(lambda1 = 180);\n range[0] = lambda0$1, range[1] = lambda1;\n p0 = null;\n}\n\n// Finds the left-right distance between two longitudes.\n// This is almost the same as (lambda1 - lambda0 + 360°) % 360°, except that we want\n// the distance between ±180° to be 360°.\nfunction angle(lambda0, lambda1) {\n return (lambda1 -= lambda0) < 0 ? lambda1 + 360 : lambda1;\n}\n\nfunction rangeCompare(a, b) {\n return a[0] - b[0];\n}\n\nfunction rangeContains(range, x) {\n return range[0] <= range[1] ? range[0] <= x && x <= range[1] : x < range[0] || range[1] < x;\n}\n\nvar bounds = function(feature) {\n var i, n, a, b, merged, deltaMax, delta;\n\n phi1 = lambda1 = -(lambda0$1 = phi0 = Infinity);\n ranges = [];\n geoStream(feature, boundsStream);\n\n // First, sort ranges by their minimum longitudes.\n if (n = ranges.length) {\n ranges.sort(rangeCompare);\n\n // Then, merge any ranges that overlap.\n for (i = 1, a = ranges[0], merged = [a]; i < n; ++i) {\n b = ranges[i];\n if (rangeContains(a, b[0]) || rangeContains(a, b[1])) {\n if (angle(a[0], b[1]) > angle(a[0], a[1])) a[1] = b[1];\n if (angle(b[0], a[1]) > angle(a[0], a[1])) a[0] = b[0];\n } else {\n merged.push(a = b);\n }\n }\n\n // Finally, find the largest gap between the merged ranges.\n // The final bounding box will be the inverse of this gap.\n for (deltaMax = -Infinity, n = merged.length - 1, i = 0, a = merged[n]; i <= n; a = b, ++i) {\n b = merged[i];\n if ((delta = angle(a[1], b[0])) > deltaMax) deltaMax = delta, lambda0$1 = b[0], lambda1 = a[1];\n }\n }\n\n ranges = range = null;\n\n return lambda0$1 === Infinity || phi0 === Infinity\n ? [[NaN, NaN], [NaN, NaN]]\n : [[lambda0$1, phi0], [lambda1, phi1]];\n};\n\nvar W0;\nvar W1;\nvar X0;\nvar Y0;\nvar Z0;\nvar X1;\nvar Y1;\nvar Z1;\nvar X2;\nvar Y2;\nvar Z2;\nvar lambda00$2;\nvar phi00$2;\nvar x0;\nvar y0;\nvar z0; // previous point\n\nvar centroidStream = {\n sphere: noop$1,\n point: centroidPoint,\n lineStart: centroidLineStart,\n lineEnd: centroidLineEnd,\n polygonStart: function() {\n centroidStream.lineStart = centroidRingStart;\n centroidStream.lineEnd = centroidRingEnd;\n },\n polygonEnd: function() {\n centroidStream.lineStart = centroidLineStart;\n centroidStream.lineEnd = centroidLineEnd;\n }\n};\n\n// Arithmetic mean of Cartesian vectors.\nfunction centroidPoint(lambda, phi) {\n lambda *= radians, phi *= radians;\n var cosPhi = cos$1(phi);\n centroidPointCartesian(cosPhi * cos$1(lambda), cosPhi * sin$1(lambda), sin$1(phi));\n}\n\nfunction centroidPointCartesian(x, y, z) {\n ++W0;\n X0 += (x - X0) / W0;\n Y0 += (y - Y0) / W0;\n Z0 += (z - Z0) / W0;\n}\n\nfunction centroidLineStart() {\n centroidStream.point = centroidLinePointFirst;\n}\n\nfunction centroidLinePointFirst(lambda, phi) {\n lambda *= radians, phi *= radians;\n var cosPhi = cos$1(phi);\n x0 = cosPhi * cos$1(lambda);\n y0 = cosPhi * sin$1(lambda);\n z0 = sin$1(phi);\n centroidStream.point = centroidLinePoint;\n centroidPointCartesian(x0, y0, z0);\n}\n\nfunction centroidLinePoint(lambda, phi) {\n lambda *= radians, phi *= radians;\n var cosPhi = cos$1(phi),\n x = cosPhi * cos$1(lambda),\n y = cosPhi * sin$1(lambda),\n z = sin$1(phi),\n w = atan2(sqrt((w = y0 * z - z0 * y) * w + (w = z0 * x - x0 * z) * w + (w = x0 * y - y0 * x) * w), x0 * x + y0 * y + z0 * z);\n W1 += w;\n X1 += w * (x0 + (x0 = x));\n Y1 += w * (y0 + (y0 = y));\n Z1 += w * (z0 + (z0 = z));\n centroidPointCartesian(x0, y0, z0);\n}\n\nfunction centroidLineEnd() {\n centroidStream.point = centroidPoint;\n}\n\n// See J. E. Brock, The Inertia Tensor for a Spherical Triangle,\n// J. Applied Mechanics 42, 239 (1975).\nfunction centroidRingStart() {\n centroidStream.point = centroidRingPointFirst;\n}\n\nfunction centroidRingEnd() {\n centroidRingPoint(lambda00$2, phi00$2);\n centroidStream.point = centroidPoint;\n}\n\nfunction centroidRingPointFirst(lambda, phi) {\n lambda00$2 = lambda, phi00$2 = phi;\n lambda *= radians, phi *= radians;\n centroidStream.point = centroidRingPoint;\n var cosPhi = cos$1(phi);\n x0 = cosPhi * cos$1(lambda);\n y0 = cosPhi * sin$1(lambda);\n z0 = sin$1(phi);\n centroidPointCartesian(x0, y0, z0);\n}\n\nfunction centroidRingPoint(lambda, phi) {\n lambda *= radians, phi *= radians;\n var cosPhi = cos$1(phi),\n x = cosPhi * cos$1(lambda),\n y = cosPhi * sin$1(lambda),\n z = sin$1(phi),\n cx = y0 * z - z0 * y,\n cy = z0 * x - x0 * z,\n cz = x0 * y - y0 * x,\n m = sqrt(cx * cx + cy * cy + cz * cz),\n u = x0 * x + y0 * y + z0 * z,\n v = m && -asin(m) / m, // area weight\n w = atan2(m, u); // line weight\n X2 += v * cx;\n Y2 += v * cy;\n Z2 += v * cz;\n W1 += w;\n X1 += w * (x0 + (x0 = x));\n Y1 += w * (y0 + (y0 = y));\n Z1 += w * (z0 + (z0 = z));\n centroidPointCartesian(x0, y0, z0);\n}\n\nvar centroid = function(object) {\n W0 = W1 =\n X0 = Y0 = Z0 =\n X1 = Y1 = Z1 =\n X2 = Y2 = Z2 = 0;\n geoStream(object, centroidStream);\n\n var x = X2,\n y = Y2,\n z = Z2,\n m = x * x + y * y + z * z;\n\n // If the area-weighted ccentroid is undefined, fall back to length-weighted ccentroid.\n if (m < epsilon2$1) {\n x = X1, y = Y1, z = Z1;\n // If the feature has zero length, fall back to arithmetic mean of point vectors.\n if (W1 < epsilon$2) x = X0, y = Y0, z = Z0;\n m = x * x + y * y + z * z;\n // If the feature still has an undefined ccentroid, then return.\n if (m < epsilon2$1) return [NaN, NaN];\n }\n\n return [atan2(y, x) * degrees$1, asin(z / sqrt(m)) * degrees$1];\n};\n\nvar constant$7 = function(x) {\n return function() {\n return x;\n };\n};\n\nvar compose = function(a, b) {\n\n function compose(x, y) {\n return x = a(x, y), b(x[0], x[1]);\n }\n\n if (a.invert && b.invert) compose.invert = function(x, y) {\n return x = b.invert(x, y), x && a.invert(x[0], x[1]);\n };\n\n return compose;\n};\n\nfunction rotationIdentity(lambda, phi) {\n return [lambda > pi$3 ? lambda - tau$3 : lambda < -pi$3 ? lambda + tau$3 : lambda, phi];\n}\n\nrotationIdentity.invert = rotationIdentity;\n\nfunction rotateRadians(deltaLambda, deltaPhi, deltaGamma) {\n return (deltaLambda %= tau$3) ? (deltaPhi || deltaGamma ? compose(rotationLambda(deltaLambda), rotationPhiGamma(deltaPhi, deltaGamma))\n : rotationLambda(deltaLambda))\n : (deltaPhi || deltaGamma ? rotationPhiGamma(deltaPhi, deltaGamma)\n : rotationIdentity);\n}\n\nfunction forwardRotationLambda(deltaLambda) {\n return function(lambda, phi) {\n return lambda += deltaLambda, [lambda > pi$3 ? lambda - tau$3 : lambda < -pi$3 ? lambda + tau$3 : lambda, phi];\n };\n}\n\nfunction rotationLambda(deltaLambda) {\n var rotation = forwardRotationLambda(deltaLambda);\n rotation.invert = forwardRotationLambda(-deltaLambda);\n return rotation;\n}\n\nfunction rotationPhiGamma(deltaPhi, deltaGamma) {\n var cosDeltaPhi = cos$1(deltaPhi),\n sinDeltaPhi = sin$1(deltaPhi),\n cosDeltaGamma = cos$1(deltaGamma),\n sinDeltaGamma = sin$1(deltaGamma);\n\n function rotation(lambda, phi) {\n var cosPhi = cos$1(phi),\n x = cos$1(lambda) * cosPhi,\n y = sin$1(lambda) * cosPhi,\n z = sin$1(phi),\n k = z * cosDeltaPhi + x * sinDeltaPhi;\n return [\n atan2(y * cosDeltaGamma - k * sinDeltaGamma, x * cosDeltaPhi - z * sinDeltaPhi),\n asin(k * cosDeltaGamma + y * sinDeltaGamma)\n ];\n }\n\n rotation.invert = function(lambda, phi) {\n var cosPhi = cos$1(phi),\n x = cos$1(lambda) * cosPhi,\n y = sin$1(lambda) * cosPhi,\n z = sin$1(phi),\n k = z * cosDeltaGamma - y * sinDeltaGamma;\n return [\n atan2(y * cosDeltaGamma + z * sinDeltaGamma, x * cosDeltaPhi + k * sinDeltaPhi),\n asin(k * cosDeltaPhi - x * sinDeltaPhi)\n ];\n };\n\n return rotation;\n}\n\nvar rotation = function(rotate) {\n rotate = rotateRadians(rotate[0] * radians, rotate[1] * radians, rotate.length > 2 ? rotate[2] * radians : 0);\n\n function forward(coordinates) {\n coordinates = rotate(coordinates[0] * radians, coordinates[1] * radians);\n return coordinates[0] *= degrees$1, coordinates[1] *= degrees$1, coordinates;\n }\n\n forward.invert = function(coordinates) {\n coordinates = rotate.invert(coordinates[0] * radians, coordinates[1] * radians);\n return coordinates[0] *= degrees$1, coordinates[1] *= degrees$1, coordinates;\n };\n\n return forward;\n};\n\n// Generates a circle centered at [0°, 0°], with a given radius and precision.\nfunction circleStream(stream, radius, delta, direction, t0, t1) {\n if (!delta) return;\n var cosRadius = cos$1(radius),\n sinRadius = sin$1(radius),\n step = direction * delta;\n if (t0 == null) {\n t0 = radius + direction * tau$3;\n t1 = radius - step / 2;\n } else {\n t0 = circleRadius(cosRadius, t0);\n t1 = circleRadius(cosRadius, t1);\n if (direction > 0 ? t0 < t1 : t0 > t1) t0 += direction * tau$3;\n }\n for (var point, t = t0; direction > 0 ? t > t1 : t < t1; t -= step) {\n point = spherical([cosRadius, -sinRadius * cos$1(t), -sinRadius * sin$1(t)]);\n stream.point(point[0], point[1]);\n }\n}\n\n// Returns the signed angle of a cartesian point relative to [cosRadius, 0, 0].\nfunction circleRadius(cosRadius, point) {\n point = cartesian(point), point[0] -= cosRadius;\n cartesianNormalizeInPlace(point);\n var radius = acos(-point[1]);\n return ((-point[2] < 0 ? -radius : radius) + tau$3 - epsilon$2) % tau$3;\n}\n\nvar circle = function() {\n var center = constant$7([0, 0]),\n radius = constant$7(90),\n precision = constant$7(6),\n ring,\n rotate,\n stream = {point: point};\n\n function point(x, y) {\n ring.push(x = rotate(x, y));\n x[0] *= degrees$1, x[1] *= degrees$1;\n }\n\n function circle() {\n var c = center.apply(this, arguments),\n r = radius.apply(this, arguments) * radians,\n p = precision.apply(this, arguments) * radians;\n ring = [];\n rotate = rotateRadians(-c[0] * radians, -c[1] * radians, 0).invert;\n circleStream(stream, r, p, 1);\n c = {type: \"Polygon\", coordinates: [ring]};\n ring = rotate = null;\n return c;\n }\n\n circle.center = function(_) {\n return arguments.length ? (center = typeof _ === \"function\" ? _ : constant$7([+_[0], +_[1]]), circle) : center;\n };\n\n circle.radius = function(_) {\n return arguments.length ? (radius = typeof _ === \"function\" ? _ : constant$7(+_), circle) : radius;\n };\n\n circle.precision = function(_) {\n return arguments.length ? (precision = typeof _ === \"function\" ? _ : constant$7(+_), circle) : precision;\n };\n\n return circle;\n};\n\nvar clipBuffer = function() {\n var lines = [],\n line;\n return {\n point: function(x, y) {\n line.push([x, y]);\n },\n lineStart: function() {\n lines.push(line = []);\n },\n lineEnd: noop$1,\n rejoin: function() {\n if (lines.length > 1) lines.push(lines.pop().concat(lines.shift()));\n },\n result: function() {\n var result = lines;\n lines = [];\n line = null;\n return result;\n }\n };\n};\n\nvar clipLine = function(a, b, x0, y0, x1, y1) {\n var ax = a[0],\n ay = a[1],\n bx = b[0],\n by = b[1],\n t0 = 0,\n t1 = 1,\n dx = bx - ax,\n dy = by - ay,\n r;\n\n r = x0 - ax;\n if (!dx && r > 0) return;\n r /= dx;\n if (dx < 0) {\n if (r < t0) return;\n if (r < t1) t1 = r;\n } else if (dx > 0) {\n if (r > t1) return;\n if (r > t0) t0 = r;\n }\n\n r = x1 - ax;\n if (!dx && r < 0) return;\n r /= dx;\n if (dx < 0) {\n if (r > t1) return;\n if (r > t0) t0 = r;\n } else if (dx > 0) {\n if (r < t0) return;\n if (r < t1) t1 = r;\n }\n\n r = y0 - ay;\n if (!dy && r > 0) return;\n r /= dy;\n if (dy < 0) {\n if (r < t0) return;\n if (r < t1) t1 = r;\n } else if (dy > 0) {\n if (r > t1) return;\n if (r > t0) t0 = r;\n }\n\n r = y1 - ay;\n if (!dy && r < 0) return;\n r /= dy;\n if (dy < 0) {\n if (r > t1) return;\n if (r > t0) t0 = r;\n } else if (dy > 0) {\n if (r < t0) return;\n if (r < t1) t1 = r;\n }\n\n if (t0 > 0) a[0] = ax + t0 * dx, a[1] = ay + t0 * dy;\n if (t1 < 1) b[0] = ax + t1 * dx, b[1] = ay + t1 * dy;\n return true;\n};\n\nvar pointEqual = function(a, b) {\n return abs(a[0] - b[0]) < epsilon$2 && abs(a[1] - b[1]) < epsilon$2;\n};\n\nfunction Intersection(point, points, other, entry) {\n this.x = point;\n this.z = points;\n this.o = other; // another intersection\n this.e = entry; // is an entry?\n this.v = false; // visited\n this.n = this.p = null; // next & previous\n}\n\n// A generalized polygon clipping algorithm: given a polygon that has been cut\n// into its visible line segments, and rejoins the segments by interpolating\n// along the clip edge.\nvar clipPolygon = function(segments, compareIntersection, startInside, interpolate, stream) {\n var subject = [],\n clip = [],\n i,\n n;\n\n segments.forEach(function(segment) {\n if ((n = segment.length - 1) <= 0) return;\n var n, p0 = segment[0], p1 = segment[n], x;\n\n // If the first and last points of a segment are coincident, then treat as a\n // closed ring. TODO if all rings are closed, then the winding order of the\n // exterior ring should be checked.\n if (pointEqual(p0, p1)) {\n stream.lineStart();\n for (i = 0; i < n; ++i) stream.point((p0 = segment[i])[0], p0[1]);\n stream.lineEnd();\n return;\n }\n\n subject.push(x = new Intersection(p0, segment, null, true));\n clip.push(x.o = new Intersection(p0, null, x, false));\n subject.push(x = new Intersection(p1, segment, null, false));\n clip.push(x.o = new Intersection(p1, null, x, true));\n });\n\n if (!subject.length) return;\n\n clip.sort(compareIntersection);\n link$1(subject);\n link$1(clip);\n\n for (i = 0, n = clip.length; i < n; ++i) {\n clip[i].e = startInside = !startInside;\n }\n\n var start = subject[0],\n points,\n point;\n\n while (1) {\n // Find first unvisited intersection.\n var current = start,\n isSubject = true;\n while (current.v) if ((current = current.n) === start) return;\n points = current.z;\n stream.lineStart();\n do {\n current.v = current.o.v = true;\n if (current.e) {\n if (isSubject) {\n for (i = 0, n = points.length; i < n; ++i) stream.point((point = points[i])[0], point[1]);\n } else {\n interpolate(current.x, current.n.x, 1, stream);\n }\n current = current.n;\n } else {\n if (isSubject) {\n points = current.p.z;\n for (i = points.length - 1; i >= 0; --i) stream.point((point = points[i])[0], point[1]);\n } else {\n interpolate(current.x, current.p.x, -1, stream);\n }\n current = current.p;\n }\n current = current.o;\n points = current.z;\n isSubject = !isSubject;\n } while (!current.v);\n stream.lineEnd();\n }\n};\n\nfunction link$1(array) {\n if (!(n = array.length)) return;\n var n,\n i = 0,\n a = array[0],\n b;\n while (++i < n) {\n a.n = b = array[i];\n b.p = a;\n a = b;\n }\n a.n = b = array[0];\n b.p = a;\n}\n\nvar clipMax = 1e9;\nvar clipMin = -clipMax;\n\n// TODO Use d3-polygon’s polygonContains here for the ring check?\n// TODO Eliminate duplicate buffering in clipBuffer and polygon.push?\n\nfunction clipExtent(x0, y0, x1, y1) {\n\n function visible(x, y) {\n return x0 <= x && x <= x1 && y0 <= y && y <= y1;\n }\n\n function interpolate(from, to, direction, stream) {\n var a = 0, a1 = 0;\n if (from == null\n || (a = corner(from, direction)) !== (a1 = corner(to, direction))\n || comparePoint(from, to) < 0 ^ direction > 0) {\n do stream.point(a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0);\n while ((a = (a + direction + 4) % 4) !== a1);\n } else {\n stream.point(to[0], to[1]);\n }\n }\n\n function corner(p, direction) {\n return abs(p[0] - x0) < epsilon$2 ? direction > 0 ? 0 : 3\n : abs(p[0] - x1) < epsilon$2 ? direction > 0 ? 2 : 1\n : abs(p[1] - y0) < epsilon$2 ? direction > 0 ? 1 : 0\n : direction > 0 ? 3 : 2; // abs(p[1] - y1) < epsilon\n }\n\n function compareIntersection(a, b) {\n return comparePoint(a.x, b.x);\n }\n\n function comparePoint(a, b) {\n var ca = corner(a, 1),\n cb = corner(b, 1);\n return ca !== cb ? ca - cb\n : ca === 0 ? b[1] - a[1]\n : ca === 1 ? a[0] - b[0]\n : ca === 2 ? a[1] - b[1]\n : b[0] - a[0];\n }\n\n return function(stream) {\n var activeStream = stream,\n bufferStream = clipBuffer(),\n segments,\n polygon,\n ring,\n x__, y__, v__, // first point\n x_, y_, v_, // previous point\n first,\n clean;\n\n var clipStream = {\n point: point,\n lineStart: lineStart,\n lineEnd: lineEnd,\n polygonStart: polygonStart,\n polygonEnd: polygonEnd\n };\n\n function point(x, y) {\n if (visible(x, y)) activeStream.point(x, y);\n }\n\n function polygonInside() {\n var winding = 0;\n\n for (var i = 0, n = polygon.length; i < n; ++i) {\n for (var ring = polygon[i], j = 1, m = ring.length, point = ring[0], a0, a1, b0 = point[0], b1 = point[1]; j < m; ++j) {\n a0 = b0, a1 = b1, point = ring[j], b0 = point[0], b1 = point[1];\n if (a1 <= y1) { if (b1 > y1 && (b0 - a0) * (y1 - a1) > (b1 - a1) * (x0 - a0)) ++winding; }\n else { if (b1 <= y1 && (b0 - a0) * (y1 - a1) < (b1 - a1) * (x0 - a0)) --winding; }\n }\n }\n\n return winding;\n }\n\n // Buffer geometry within a polygon and then clip it en masse.\n function polygonStart() {\n activeStream = bufferStream, segments = [], polygon = [], clean = true;\n }\n\n function polygonEnd() {\n var startInside = polygonInside(),\n cleanInside = clean && startInside,\n visible = (segments = merge(segments)).length;\n if (cleanInside || visible) {\n stream.polygonStart();\n if (cleanInside) {\n stream.lineStart();\n interpolate(null, null, 1, stream);\n stream.lineEnd();\n }\n if (visible) {\n clipPolygon(segments, compareIntersection, startInside, interpolate, stream);\n }\n stream.polygonEnd();\n }\n activeStream = stream, segments = polygon = ring = null;\n }\n\n function lineStart() {\n clipStream.point = linePoint;\n if (polygon) polygon.push(ring = []);\n first = true;\n v_ = false;\n x_ = y_ = NaN;\n }\n\n // TODO rather than special-case polygons, simply handle them separately.\n // Ideally, coincident intersection points should be jittered to avoid\n // clipping issues.\n function lineEnd() {\n if (segments) {\n linePoint(x__, y__);\n if (v__ && v_) bufferStream.rejoin();\n segments.push(bufferStream.result());\n }\n clipStream.point = point;\n if (v_) activeStream.lineEnd();\n }\n\n function linePoint(x, y) {\n var v = visible(x, y);\n if (polygon) ring.push([x, y]);\n if (first) {\n x__ = x, y__ = y, v__ = v;\n first = false;\n if (v) {\n activeStream.lineStart();\n activeStream.point(x, y);\n }\n } else {\n if (v && v_) activeStream.point(x, y);\n else {\n var a = [x_ = Math.max(clipMin, Math.min(clipMax, x_)), y_ = Math.max(clipMin, Math.min(clipMax, y_))],\n b = [x = Math.max(clipMin, Math.min(clipMax, x)), y = Math.max(clipMin, Math.min(clipMax, y))];\n if (clipLine(a, b, x0, y0, x1, y1)) {\n if (!v_) {\n activeStream.lineStart();\n activeStream.point(a[0], a[1]);\n }\n activeStream.point(b[0], b[1]);\n if (!v) activeStream.lineEnd();\n clean = false;\n } else if (v) {\n activeStream.lineStart();\n activeStream.point(x, y);\n clean = false;\n }\n }\n }\n x_ = x, y_ = y, v_ = v;\n }\n\n return clipStream;\n };\n}\n\nvar extent$1 = function() {\n var x0 = 0,\n y0 = 0,\n x1 = 960,\n y1 = 500,\n cache,\n cacheStream,\n clip;\n\n return clip = {\n stream: function(stream) {\n return cache && cacheStream === stream ? cache : cache = clipExtent(x0, y0, x1, y1)(cacheStream = stream);\n },\n extent: function(_) {\n return arguments.length ? (x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1], cache = cacheStream = null, clip) : [[x0, y0], [x1, y1]];\n }\n };\n};\n\nvar lengthSum = adder();\nvar lambda0$2;\nvar sinPhi0$1;\nvar cosPhi0$1;\n\nvar lengthStream = {\n sphere: noop$1,\n point: noop$1,\n lineStart: lengthLineStart,\n lineEnd: noop$1,\n polygonStart: noop$1,\n polygonEnd: noop$1\n};\n\nfunction lengthLineStart() {\n lengthStream.point = lengthPointFirst;\n lengthStream.lineEnd = lengthLineEnd;\n}\n\nfunction lengthLineEnd() {\n lengthStream.point = lengthStream.lineEnd = noop$1;\n}\n\nfunction lengthPointFirst(lambda, phi) {\n lambda *= radians, phi *= radians;\n lambda0$2 = lambda, sinPhi0$1 = sin$1(phi), cosPhi0$1 = cos$1(phi);\n lengthStream.point = lengthPoint;\n}\n\nfunction lengthPoint(lambda, phi) {\n lambda *= radians, phi *= radians;\n var sinPhi = sin$1(phi),\n cosPhi = cos$1(phi),\n delta = abs(lambda - lambda0$2),\n cosDelta = cos$1(delta),\n sinDelta = sin$1(delta),\n x = cosPhi * sinDelta,\n y = cosPhi0$1 * sinPhi - sinPhi0$1 * cosPhi * cosDelta,\n z = sinPhi0$1 * sinPhi + cosPhi0$1 * cosPhi * cosDelta;\n lengthSum.add(atan2(sqrt(x * x + y * y), z));\n lambda0$2 = lambda, sinPhi0$1 = sinPhi, cosPhi0$1 = cosPhi;\n}\n\nvar length$1 = function(object) {\n lengthSum.reset();\n geoStream(object, lengthStream);\n return +lengthSum;\n};\n\nvar coordinates = [null, null];\nvar object$1 = {type: \"LineString\", coordinates: coordinates};\n\nvar distance = function(a, b) {\n coordinates[0] = a;\n coordinates[1] = b;\n return length$1(object$1);\n};\n\nfunction graticuleX(y0, y1, dy) {\n var y = sequence(y0, y1 - epsilon$2, dy).concat(y1);\n return function(x) { return y.map(function(y) { return [x, y]; }); };\n}\n\nfunction graticuleY(x0, x1, dx) {\n var x = sequence(x0, x1 - epsilon$2, dx).concat(x1);\n return function(y) { return x.map(function(x) { return [x, y]; }); };\n}\n\nfunction graticule() {\n var x1, x0, X1, X0,\n y1, y0, Y1, Y0,\n dx = 10, dy = dx, DX = 90, DY = 360,\n x, y, X, Y,\n precision = 2.5;\n\n function graticule() {\n return {type: \"MultiLineString\", coordinates: lines()};\n }\n\n function lines() {\n return sequence(ceil(X0 / DX) * DX, X1, DX).map(X)\n .concat(sequence(ceil(Y0 / DY) * DY, Y1, DY).map(Y))\n .concat(sequence(ceil(x0 / dx) * dx, x1, dx).filter(function(x) { return abs(x % DX) > epsilon$2; }).map(x))\n .concat(sequence(ceil(y0 / dy) * dy, y1, dy).filter(function(y) { return abs(y % DY) > epsilon$2; }).map(y));\n }\n\n graticule.lines = function() {\n return lines().map(function(coordinates) { return {type: \"LineString\", coordinates: coordinates}; });\n };\n\n graticule.outline = function() {\n return {\n type: \"Polygon\",\n coordinates: [\n X(X0).concat(\n Y(Y1).slice(1),\n X(X1).reverse().slice(1),\n Y(Y0).reverse().slice(1))\n ]\n };\n };\n\n graticule.extent = function(_) {\n if (!arguments.length) return graticule.extentMinor();\n return graticule.extentMajor(_).extentMinor(_);\n };\n\n graticule.extentMajor = function(_) {\n if (!arguments.length) return [[X0, Y0], [X1, Y1]];\n X0 = +_[0][0], X1 = +_[1][0];\n Y0 = +_[0][1], Y1 = +_[1][1];\n if (X0 > X1) _ = X0, X0 = X1, X1 = _;\n if (Y0 > Y1) _ = Y0, Y0 = Y1, Y1 = _;\n return graticule.precision(precision);\n };\n\n graticule.extentMinor = function(_) {\n if (!arguments.length) return [[x0, y0], [x1, y1]];\n x0 = +_[0][0], x1 = +_[1][0];\n y0 = +_[0][1], y1 = +_[1][1];\n if (x0 > x1) _ = x0, x0 = x1, x1 = _;\n if (y0 > y1) _ = y0, y0 = y1, y1 = _;\n return graticule.precision(precision);\n };\n\n graticule.step = function(_) {\n if (!arguments.length) return graticule.stepMinor();\n return graticule.stepMajor(_).stepMinor(_);\n };\n\n graticule.stepMajor = function(_) {\n if (!arguments.length) return [DX, DY];\n DX = +_[0], DY = +_[1];\n return graticule;\n };\n\n graticule.stepMinor = function(_) {\n if (!arguments.length) return [dx, dy];\n dx = +_[0], dy = +_[1];\n return graticule;\n };\n\n graticule.precision = function(_) {\n if (!arguments.length) return precision;\n precision = +_;\n x = graticuleX(y0, y1, 90);\n y = graticuleY(x0, x1, precision);\n X = graticuleX(Y0, Y1, 90);\n Y = graticuleY(X0, X1, precision);\n return graticule;\n };\n\n return graticule\n .extentMajor([[-180, -90 + epsilon$2], [180, 90 - epsilon$2]])\n .extentMinor([[-180, -80 - epsilon$2], [180, 80 + epsilon$2]]);\n}\n\nfunction graticule10() {\n return graticule()();\n}\n\nvar interpolate$1 = function(a, b) {\n var x0 = a[0] * radians,\n y0 = a[1] * radians,\n x1 = b[0] * radians,\n y1 = b[1] * radians,\n cy0 = cos$1(y0),\n sy0 = sin$1(y0),\n cy1 = cos$1(y1),\n sy1 = sin$1(y1),\n kx0 = cy0 * cos$1(x0),\n ky0 = cy0 * sin$1(x0),\n kx1 = cy1 * cos$1(x1),\n ky1 = cy1 * sin$1(x1),\n d = 2 * asin(sqrt(haversin(y1 - y0) + cy0 * cy1 * haversin(x1 - x0))),\n k = sin$1(d);\n\n var interpolate = d ? function(t) {\n var B = sin$1(t *= d) / k,\n A = sin$1(d - t) / k,\n x = A * kx0 + B * kx1,\n y = A * ky0 + B * ky1,\n z = A * sy0 + B * sy1;\n return [\n atan2(y, x) * degrees$1,\n atan2(z, sqrt(x * x + y * y)) * degrees$1\n ];\n } : function() {\n return [x0 * degrees$1, y0 * degrees$1];\n };\n\n interpolate.distance = d;\n\n return interpolate;\n};\n\nvar identity$4 = function(x) {\n return x;\n};\n\nvar areaSum$1 = adder();\nvar areaRingSum$1 = adder();\nvar x00;\nvar y00;\nvar x0$1;\nvar y0$1;\n\nvar areaStream$1 = {\n point: noop$1,\n lineStart: noop$1,\n lineEnd: noop$1,\n polygonStart: function() {\n areaStream$1.lineStart = areaRingStart$1;\n areaStream$1.lineEnd = areaRingEnd$1;\n },\n polygonEnd: function() {\n areaStream$1.lineStart = areaStream$1.lineEnd = areaStream$1.point = noop$1;\n areaSum$1.add(abs(areaRingSum$1));\n areaRingSum$1.reset();\n },\n result: function() {\n var area = areaSum$1 / 2;\n areaSum$1.reset();\n return area;\n }\n};\n\nfunction areaRingStart$1() {\n areaStream$1.point = areaPointFirst$1;\n}\n\nfunction areaPointFirst$1(x, y) {\n areaStream$1.point = areaPoint$1;\n x00 = x0$1 = x, y00 = y0$1 = y;\n}\n\nfunction areaPoint$1(x, y) {\n areaRingSum$1.add(y0$1 * x - x0$1 * y);\n x0$1 = x, y0$1 = y;\n}\n\nfunction areaRingEnd$1() {\n areaPoint$1(x00, y00);\n}\n\nvar x0$2 = Infinity;\nvar y0$2 = x0$2;\nvar x1 = -x0$2;\nvar y1 = x1;\n\nvar boundsStream$1 = {\n point: boundsPoint$1,\n lineStart: noop$1,\n lineEnd: noop$1,\n polygonStart: noop$1,\n polygonEnd: noop$1,\n result: function() {\n var bounds = [[x0$2, y0$2], [x1, y1]];\n x1 = y1 = -(y0$2 = x0$2 = Infinity);\n return bounds;\n }\n};\n\nfunction boundsPoint$1(x, y) {\n if (x < x0$2) x0$2 = x;\n if (x > x1) x1 = x;\n if (y < y0$2) y0$2 = y;\n if (y > y1) y1 = y;\n}\n\n// TODO Enforce positive area for exterior, negative area for interior?\n\nvar X0$1 = 0;\nvar Y0$1 = 0;\nvar Z0$1 = 0;\nvar X1$1 = 0;\nvar Y1$1 = 0;\nvar Z1$1 = 0;\nvar X2$1 = 0;\nvar Y2$1 = 0;\nvar Z2$1 = 0;\nvar x00$1;\nvar y00$1;\nvar x0$3;\nvar y0$3;\n\nvar centroidStream$1 = {\n point: centroidPoint$1,\n lineStart: centroidLineStart$1,\n lineEnd: centroidLineEnd$1,\n polygonStart: function() {\n centroidStream$1.lineStart = centroidRingStart$1;\n centroidStream$1.lineEnd = centroidRingEnd$1;\n },\n polygonEnd: function() {\n centroidStream$1.point = centroidPoint$1;\n centroidStream$1.lineStart = centroidLineStart$1;\n centroidStream$1.lineEnd = centroidLineEnd$1;\n },\n result: function() {\n var centroid = Z2$1 ? [X2$1 / Z2$1, Y2$1 / Z2$1]\n : Z1$1 ? [X1$1 / Z1$1, Y1$1 / Z1$1]\n : Z0$1 ? [X0$1 / Z0$1, Y0$1 / Z0$1]\n : [NaN, NaN];\n X0$1 = Y0$1 = Z0$1 =\n X1$1 = Y1$1 = Z1$1 =\n X2$1 = Y2$1 = Z2$1 = 0;\n return centroid;\n }\n};\n\nfunction centroidPoint$1(x, y) {\n X0$1 += x;\n Y0$1 += y;\n ++Z0$1;\n}\n\nfunction centroidLineStart$1() {\n centroidStream$1.point = centroidPointFirstLine;\n}\n\nfunction centroidPointFirstLine(x, y) {\n centroidStream$1.point = centroidPointLine;\n centroidPoint$1(x0$3 = x, y0$3 = y);\n}\n\nfunction centroidPointLine(x, y) {\n var dx = x - x0$3, dy = y - y0$3, z = sqrt(dx * dx + dy * dy);\n X1$1 += z * (x0$3 + x) / 2;\n Y1$1 += z * (y0$3 + y) / 2;\n Z1$1 += z;\n centroidPoint$1(x0$3 = x, y0$3 = y);\n}\n\nfunction centroidLineEnd$1() {\n centroidStream$1.point = centroidPoint$1;\n}\n\nfunction centroidRingStart$1() {\n centroidStream$1.point = centroidPointFirstRing;\n}\n\nfunction centroidRingEnd$1() {\n centroidPointRing(x00$1, y00$1);\n}\n\nfunction centroidPointFirstRing(x, y) {\n centroidStream$1.point = centroidPointRing;\n centroidPoint$1(x00$1 = x0$3 = x, y00$1 = y0$3 = y);\n}\n\nfunction centroidPointRing(x, y) {\n var dx = x - x0$3,\n dy = y - y0$3,\n z = sqrt(dx * dx + dy * dy);\n\n X1$1 += z * (x0$3 + x) / 2;\n Y1$1 += z * (y0$3 + y) / 2;\n Z1$1 += z;\n\n z = y0$3 * x - x0$3 * y;\n X2$1 += z * (x0$3 + x);\n Y2$1 += z * (y0$3 + y);\n Z2$1 += z * 3;\n centroidPoint$1(x0$3 = x, y0$3 = y);\n}\n\nfunction PathContext(context) {\n this._context = context;\n}\n\nPathContext.prototype = {\n _radius: 4.5,\n pointRadius: function(_) {\n return this._radius = _, this;\n },\n polygonStart: function() {\n this._line = 0;\n },\n polygonEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._point = 0;\n },\n lineEnd: function() {\n if (this._line === 0) this._context.closePath();\n this._point = NaN;\n },\n point: function(x, y) {\n switch (this._point) {\n case 0: {\n this._context.moveTo(x, y);\n this._point = 1;\n break;\n }\n case 1: {\n this._context.lineTo(x, y);\n break;\n }\n default: {\n this._context.moveTo(x + this._radius, y);\n this._context.arc(x, y, this._radius, 0, tau$3);\n break;\n }\n }\n },\n result: noop$1\n};\n\nvar lengthSum$1 = adder();\nvar lengthRing;\nvar x00$2;\nvar y00$2;\nvar x0$4;\nvar y0$4;\n\nvar lengthStream$1 = {\n point: noop$1,\n lineStart: function() {\n lengthStream$1.point = lengthPointFirst$1;\n },\n lineEnd: function() {\n if (lengthRing) lengthPoint$1(x00$2, y00$2);\n lengthStream$1.point = noop$1;\n },\n polygonStart: function() {\n lengthRing = true;\n },\n polygonEnd: function() {\n lengthRing = null;\n },\n result: function() {\n var length = +lengthSum$1;\n lengthSum$1.reset();\n return length;\n }\n};\n\nfunction lengthPointFirst$1(x, y) {\n lengthStream$1.point = lengthPoint$1;\n x00$2 = x0$4 = x, y00$2 = y0$4 = y;\n}\n\nfunction lengthPoint$1(x, y) {\n x0$4 -= x, y0$4 -= y;\n lengthSum$1.add(sqrt(x0$4 * x0$4 + y0$4 * y0$4));\n x0$4 = x, y0$4 = y;\n}\n\nfunction PathString() {\n this._string = [];\n}\n\nPathString.prototype = {\n _circle: circle$1(4.5),\n pointRadius: function(_) {\n return this._circle = circle$1(_), this;\n },\n polygonStart: function() {\n this._line = 0;\n },\n polygonEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._point = 0;\n },\n lineEnd: function() {\n if (this._line === 0) this._string.push(\"Z\");\n this._point = NaN;\n },\n point: function(x, y) {\n switch (this._point) {\n case 0: {\n this._string.push(\"M\", x, \",\", y);\n this._point = 1;\n break;\n }\n case 1: {\n this._string.push(\"L\", x, \",\", y);\n break;\n }\n default: {\n this._string.push(\"M\", x, \",\", y, this._circle);\n break;\n }\n }\n },\n result: function() {\n if (this._string.length) {\n var result = this._string.join(\"\");\n this._string = [];\n return result;\n }\n }\n};\n\nfunction circle$1(radius) {\n return \"m0,\" + radius\n + \"a\" + radius + \",\" + radius + \" 0 1,1 0,\" + -2 * radius\n + \"a\" + radius + \",\" + radius + \" 0 1,1 0,\" + 2 * radius\n + \"z\";\n}\n\nvar index$1 = function(projection, context) {\n var pointRadius = 4.5,\n projectionStream,\n contextStream;\n\n function path(object) {\n if (object) {\n if (typeof pointRadius === \"function\") contextStream.pointRadius(+pointRadius.apply(this, arguments));\n geoStream(object, projectionStream(contextStream));\n }\n return contextStream.result();\n }\n\n path.area = function(object) {\n geoStream(object, projectionStream(areaStream$1));\n return areaStream$1.result();\n };\n\n path.measure = function(object) {\n geoStream(object, projectionStream(lengthStream$1));\n return lengthStream$1.result();\n };\n\n path.bounds = function(object) {\n geoStream(object, projectionStream(boundsStream$1));\n return boundsStream$1.result();\n };\n\n path.centroid = function(object) {\n geoStream(object, projectionStream(centroidStream$1));\n return centroidStream$1.result();\n };\n\n path.projection = function(_) {\n return arguments.length ? (projectionStream = _ == null ? (projection = null, identity$4) : (projection = _).stream, path) : projection;\n };\n\n path.context = function(_) {\n if (!arguments.length) return context;\n contextStream = _ == null ? (context = null, new PathString) : new PathContext(context = _);\n if (typeof pointRadius !== \"function\") contextStream.pointRadius(pointRadius);\n return path;\n };\n\n path.pointRadius = function(_) {\n if (!arguments.length) return pointRadius;\n pointRadius = typeof _ === \"function\" ? _ : (contextStream.pointRadius(+_), +_);\n return path;\n };\n\n return path.projection(projection).context(context);\n};\n\nvar sum$1 = adder();\n\nvar polygonContains = function(polygon, point) {\n var lambda = point[0],\n phi = point[1],\n normal = [sin$1(lambda), -cos$1(lambda), 0],\n angle = 0,\n winding = 0;\n\n sum$1.reset();\n\n for (var i = 0, n = polygon.length; i < n; ++i) {\n if (!(m = (ring = polygon[i]).length)) continue;\n var ring,\n m,\n point0 = ring[m - 1],\n lambda0 = point0[0],\n phi0 = point0[1] / 2 + quarterPi,\n sinPhi0 = sin$1(phi0),\n cosPhi0 = cos$1(phi0);\n\n for (var j = 0; j < m; ++j, lambda0 = lambda1, sinPhi0 = sinPhi1, cosPhi0 = cosPhi1, point0 = point1) {\n var point1 = ring[j],\n lambda1 = point1[0],\n phi1 = point1[1] / 2 + quarterPi,\n sinPhi1 = sin$1(phi1),\n cosPhi1 = cos$1(phi1),\n delta = lambda1 - lambda0,\n sign$$1 = delta >= 0 ? 1 : -1,\n absDelta = sign$$1 * delta,\n antimeridian = absDelta > pi$3,\n k = sinPhi0 * sinPhi1;\n\n sum$1.add(atan2(k * sign$$1 * sin$1(absDelta), cosPhi0 * cosPhi1 + k * cos$1(absDelta)));\n angle += antimeridian ? delta + sign$$1 * tau$3 : delta;\n\n // Are the longitudes either side of the point’s meridian (lambda),\n // and are the latitudes smaller than the parallel (phi)?\n if (antimeridian ^ lambda0 >= lambda ^ lambda1 >= lambda) {\n var arc = cartesianCross(cartesian(point0), cartesian(point1));\n cartesianNormalizeInPlace(arc);\n var intersection = cartesianCross(normal, arc);\n cartesianNormalizeInPlace(intersection);\n var phiArc = (antimeridian ^ delta >= 0 ? -1 : 1) * asin(intersection[2]);\n if (phi > phiArc || phi === phiArc && (arc[0] || arc[1])) {\n winding += antimeridian ^ delta >= 0 ? 1 : -1;\n }\n }\n }\n }\n\n // First, determine whether the South pole is inside or outside:\n //\n // It is inside if:\n // * the polygon winds around it in a clockwise direction.\n // * the polygon does not (cumulatively) wind around it, but has a negative\n // (counter-clockwise) area.\n //\n // Second, count the (signed) number of times a segment crosses a lambda\n // from the point to the South pole. If it is zero, then the point is the\n // same side as the South pole.\n\n return (angle < -epsilon$2 || angle < epsilon$2 && sum$1 < -epsilon$2) ^ (winding & 1);\n};\n\nvar clip = function(pointVisible, clipLine, interpolate, start) {\n return function(rotate, sink) {\n var line = clipLine(sink),\n rotatedStart = rotate.invert(start[0], start[1]),\n ringBuffer = clipBuffer(),\n ringSink = clipLine(ringBuffer),\n polygonStarted = false,\n polygon,\n segments,\n ring;\n\n var clip = {\n point: point,\n lineStart: lineStart,\n lineEnd: lineEnd,\n polygonStart: function() {\n clip.point = pointRing;\n clip.lineStart = ringStart;\n clip.lineEnd = ringEnd;\n segments = [];\n polygon = [];\n },\n polygonEnd: function() {\n clip.point = point;\n clip.lineStart = lineStart;\n clip.lineEnd = lineEnd;\n segments = merge(segments);\n var startInside = polygonContains(polygon, rotatedStart);\n if (segments.length) {\n if (!polygonStarted) sink.polygonStart(), polygonStarted = true;\n clipPolygon(segments, compareIntersection, startInside, interpolate, sink);\n } else if (startInside) {\n if (!polygonStarted) sink.polygonStart(), polygonStarted = true;\n sink.lineStart();\n interpolate(null, null, 1, sink);\n sink.lineEnd();\n }\n if (polygonStarted) sink.polygonEnd(), polygonStarted = false;\n segments = polygon = null;\n },\n sphere: function() {\n sink.polygonStart();\n sink.lineStart();\n interpolate(null, null, 1, sink);\n sink.lineEnd();\n sink.polygonEnd();\n }\n };\n\n function point(lambda, phi) {\n var point = rotate(lambda, phi);\n if (pointVisible(lambda = point[0], phi = point[1])) sink.point(lambda, phi);\n }\n\n function pointLine(lambda, phi) {\n var point = rotate(lambda, phi);\n line.point(point[0], point[1]);\n }\n\n function lineStart() {\n clip.point = pointLine;\n line.lineStart();\n }\n\n function lineEnd() {\n clip.point = point;\n line.lineEnd();\n }\n\n function pointRing(lambda, phi) {\n ring.push([lambda, phi]);\n var point = rotate(lambda, phi);\n ringSink.point(point[0], point[1]);\n }\n\n function ringStart() {\n ringSink.lineStart();\n ring = [];\n }\n\n function ringEnd() {\n pointRing(ring[0][0], ring[0][1]);\n ringSink.lineEnd();\n\n var clean = ringSink.clean(),\n ringSegments = ringBuffer.result(),\n i, n = ringSegments.length, m,\n segment,\n point;\n\n ring.pop();\n polygon.push(ring);\n ring = null;\n\n if (!n) return;\n\n // No intersections.\n if (clean & 1) {\n segment = ringSegments[0];\n if ((m = segment.length - 1) > 0) {\n if (!polygonStarted) sink.polygonStart(), polygonStarted = true;\n sink.lineStart();\n for (i = 0; i < m; ++i) sink.point((point = segment[i])[0], point[1]);\n sink.lineEnd();\n }\n return;\n }\n\n // Rejoin connected segments.\n // TODO reuse ringBuffer.rejoin()?\n if (n > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift()));\n\n segments.push(ringSegments.filter(validSegment));\n }\n\n return clip;\n };\n};\n\nfunction validSegment(segment) {\n return segment.length > 1;\n}\n\n// Intersections are sorted along the clip edge. For both antimeridian cutting\n// and circle clipping, the same comparison is used.\nfunction compareIntersection(a, b) {\n return ((a = a.x)[0] < 0 ? a[1] - halfPi$2 - epsilon$2 : halfPi$2 - a[1])\n - ((b = b.x)[0] < 0 ? b[1] - halfPi$2 - epsilon$2 : halfPi$2 - b[1]);\n}\n\nvar clipAntimeridian = clip(\n function() { return true; },\n clipAntimeridianLine,\n clipAntimeridianInterpolate,\n [-pi$3, -halfPi$2]\n);\n\n// Takes a line and cuts into visible segments. Return values: 0 - there were\n// intersections or the line was empty; 1 - no intersections; 2 - there were\n// intersections, and the first and last segments should be rejoined.\nfunction clipAntimeridianLine(stream) {\n var lambda0 = NaN,\n phi0 = NaN,\n sign0 = NaN,\n clean; // no intersections\n\n return {\n lineStart: function() {\n stream.lineStart();\n clean = 1;\n },\n point: function(lambda1, phi1) {\n var sign1 = lambda1 > 0 ? pi$3 : -pi$3,\n delta = abs(lambda1 - lambda0);\n if (abs(delta - pi$3) < epsilon$2) { // line crosses a pole\n stream.point(lambda0, phi0 = (phi0 + phi1) / 2 > 0 ? halfPi$2 : -halfPi$2);\n stream.point(sign0, phi0);\n stream.lineEnd();\n stream.lineStart();\n stream.point(sign1, phi0);\n stream.point(lambda1, phi0);\n clean = 0;\n } else if (sign0 !== sign1 && delta >= pi$3) { // line crosses antimeridian\n if (abs(lambda0 - sign0) < epsilon$2) lambda0 -= sign0 * epsilon$2; // handle degeneracies\n if (abs(lambda1 - sign1) < epsilon$2) lambda1 -= sign1 * epsilon$2;\n phi0 = clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1);\n stream.point(sign0, phi0);\n stream.lineEnd();\n stream.lineStart();\n stream.point(sign1, phi0);\n clean = 0;\n }\n stream.point(lambda0 = lambda1, phi0 = phi1);\n sign0 = sign1;\n },\n lineEnd: function() {\n stream.lineEnd();\n lambda0 = phi0 = NaN;\n },\n clean: function() {\n return 2 - clean; // if intersections, rejoin first and last segments\n }\n };\n}\n\nfunction clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1) {\n var cosPhi0,\n cosPhi1,\n sinLambda0Lambda1 = sin$1(lambda0 - lambda1);\n return abs(sinLambda0Lambda1) > epsilon$2\n ? atan((sin$1(phi0) * (cosPhi1 = cos$1(phi1)) * sin$1(lambda1)\n - sin$1(phi1) * (cosPhi0 = cos$1(phi0)) * sin$1(lambda0))\n / (cosPhi0 * cosPhi1 * sinLambda0Lambda1))\n : (phi0 + phi1) / 2;\n}\n\nfunction clipAntimeridianInterpolate(from, to, direction, stream) {\n var phi;\n if (from == null) {\n phi = direction * halfPi$2;\n stream.point(-pi$3, phi);\n stream.point(0, phi);\n stream.point(pi$3, phi);\n stream.point(pi$3, 0);\n stream.point(pi$3, -phi);\n stream.point(0, -phi);\n stream.point(-pi$3, -phi);\n stream.point(-pi$3, 0);\n stream.point(-pi$3, phi);\n } else if (abs(from[0] - to[0]) > epsilon$2) {\n var lambda = from[0] < to[0] ? pi$3 : -pi$3;\n phi = direction * lambda / 2;\n stream.point(-lambda, phi);\n stream.point(0, phi);\n stream.point(lambda, phi);\n } else {\n stream.point(to[0], to[1]);\n }\n}\n\nvar clipCircle = function(radius, delta) {\n var cr = cos$1(radius),\n smallRadius = cr > 0,\n notHemisphere = abs(cr) > epsilon$2; // TODO optimise for this common case\n\n function interpolate(from, to, direction, stream) {\n circleStream(stream, radius, delta, direction, from, to);\n }\n\n function visible(lambda, phi) {\n return cos$1(lambda) * cos$1(phi) > cr;\n }\n\n // Takes a line and cuts into visible segments. Return values used for polygon\n // clipping: 0 - there were intersections or the line was empty; 1 - no\n // intersections 2 - there were intersections, and the first and last segments\n // should be rejoined.\n function clipLine(stream) {\n var point0, // previous point\n c0, // code for previous point\n v0, // visibility of previous point\n v00, // visibility of first point\n clean; // no intersections\n return {\n lineStart: function() {\n v00 = v0 = false;\n clean = 1;\n },\n point: function(lambda, phi) {\n var point1 = [lambda, phi],\n point2,\n v = visible(lambda, phi),\n c = smallRadius\n ? v ? 0 : code(lambda, phi)\n : v ? code(lambda + (lambda < 0 ? pi$3 : -pi$3), phi) : 0;\n if (!point0 && (v00 = v0 = v)) stream.lineStart();\n // Handle degeneracies.\n // TODO ignore if not clipping polygons.\n if (v !== v0) {\n point2 = intersect(point0, point1);\n if (pointEqual(point0, point2) || pointEqual(point1, point2)) {\n point1[0] += epsilon$2;\n point1[1] += epsilon$2;\n v = visible(point1[0], point1[1]);\n }\n }\n if (v !== v0) {\n clean = 0;\n if (v) {\n // outside going in\n stream.lineStart();\n point2 = intersect(point1, point0);\n stream.point(point2[0], point2[1]);\n } else {\n // inside going out\n point2 = intersect(point0, point1);\n stream.point(point2[0], point2[1]);\n stream.lineEnd();\n }\n point0 = point2;\n } else if (notHemisphere && point0 && smallRadius ^ v) {\n var t;\n // If the codes for two points are different, or are both zero,\n // and there this segment intersects with the small circle.\n if (!(c & c0) && (t = intersect(point1, point0, true))) {\n clean = 0;\n if (smallRadius) {\n stream.lineStart();\n stream.point(t[0][0], t[0][1]);\n stream.point(t[1][0], t[1][1]);\n stream.lineEnd();\n } else {\n stream.point(t[1][0], t[1][1]);\n stream.lineEnd();\n stream.lineStart();\n stream.point(t[0][0], t[0][1]);\n }\n }\n }\n if (v && (!point0 || !pointEqual(point0, point1))) {\n stream.point(point1[0], point1[1]);\n }\n point0 = point1, v0 = v, c0 = c;\n },\n lineEnd: function() {\n if (v0) stream.lineEnd();\n point0 = null;\n },\n // Rejoin first and last segments if there were intersections and the first\n // and last points were visible.\n clean: function() {\n return clean | ((v00 && v0) << 1);\n }\n };\n }\n\n // Intersects the great circle between a and b with the clip circle.\n function intersect(a, b, two) {\n var pa = cartesian(a),\n pb = cartesian(b);\n\n // We have two planes, n1.p = d1 and n2.p = d2.\n // Find intersection line p(t) = c1 n1 + c2 n2 + t (n1 ⨯ n2).\n var n1 = [1, 0, 0], // normal\n n2 = cartesianCross(pa, pb),\n n2n2 = cartesianDot(n2, n2),\n n1n2 = n2[0], // cartesianDot(n1, n2),\n determinant = n2n2 - n1n2 * n1n2;\n\n // Two polar points.\n if (!determinant) return !two && a;\n\n var c1 = cr * n2n2 / determinant,\n c2 = -cr * n1n2 / determinant,\n n1xn2 = cartesianCross(n1, n2),\n A = cartesianScale(n1, c1),\n B = cartesianScale(n2, c2);\n cartesianAddInPlace(A, B);\n\n // Solve |p(t)|^2 = 1.\n var u = n1xn2,\n w = cartesianDot(A, u),\n uu = cartesianDot(u, u),\n t2 = w * w - uu * (cartesianDot(A, A) - 1);\n\n if (t2 < 0) return;\n\n var t = sqrt(t2),\n q = cartesianScale(u, (-w - t) / uu);\n cartesianAddInPlace(q, A);\n q = spherical(q);\n\n if (!two) return q;\n\n // Two intersection points.\n var lambda0 = a[0],\n lambda1 = b[0],\n phi0 = a[1],\n phi1 = b[1],\n z;\n\n if (lambda1 < lambda0) z = lambda0, lambda0 = lambda1, lambda1 = z;\n\n var delta = lambda1 - lambda0,\n polar = abs(delta - pi$3) < epsilon$2,\n meridian = polar || delta < epsilon$2;\n\n if (!polar && phi1 < phi0) z = phi0, phi0 = phi1, phi1 = z;\n\n // Check that the first point is between a and b.\n if (meridian\n ? polar\n ? phi0 + phi1 > 0 ^ q[1] < (abs(q[0] - lambda0) < epsilon$2 ? phi0 : phi1)\n : phi0 <= q[1] && q[1] <= phi1\n : delta > pi$3 ^ (lambda0 <= q[0] && q[0] <= lambda1)) {\n var q1 = cartesianScale(u, (-w + t) / uu);\n cartesianAddInPlace(q1, A);\n return [q, spherical(q1)];\n }\n }\n\n // Generates a 4-bit vector representing the location of a point relative to\n // the small circle's bounding box.\n function code(lambda, phi) {\n var r = smallRadius ? radius : pi$3 - radius,\n code = 0;\n if (lambda < -r) code |= 1; // left\n else if (lambda > r) code |= 2; // right\n if (phi < -r) code |= 4; // below\n else if (phi > r) code |= 8; // above\n return code;\n }\n\n return clip(visible, clipLine, interpolate, smallRadius ? [0, -radius] : [-pi$3, radius - pi$3]);\n};\n\nvar transform = function(methods) {\n return {\n stream: transformer(methods)\n };\n};\n\nfunction transformer(methods) {\n return function(stream) {\n var s = new TransformStream;\n for (var key in methods) s[key] = methods[key];\n s.stream = stream;\n return s;\n };\n}\n\nfunction TransformStream() {}\n\nTransformStream.prototype = {\n constructor: TransformStream,\n point: function(x, y) { this.stream.point(x, y); },\n sphere: function() { this.stream.sphere(); },\n lineStart: function() { this.stream.lineStart(); },\n lineEnd: function() { this.stream.lineEnd(); },\n polygonStart: function() { this.stream.polygonStart(); },\n polygonEnd: function() { this.stream.polygonEnd(); }\n};\n\nfunction fitExtent(projection, extent, object) {\n var w = extent[1][0] - extent[0][0],\n h = extent[1][1] - extent[0][1],\n clip = projection.clipExtent && projection.clipExtent();\n\n projection\n .scale(150)\n .translate([0, 0]);\n\n if (clip != null) projection.clipExtent(null);\n\n geoStream(object, projection.stream(boundsStream$1));\n\n var b = boundsStream$1.result(),\n k = Math.min(w / (b[1][0] - b[0][0]), h / (b[1][1] - b[0][1])),\n x = +extent[0][0] + (w - k * (b[1][0] + b[0][0])) / 2,\n y = +extent[0][1] + (h - k * (b[1][1] + b[0][1])) / 2;\n\n if (clip != null) projection.clipExtent(clip);\n\n return projection\n .scale(k * 150)\n .translate([x, y]);\n}\n\nfunction fitSize(projection, size, object) {\n return fitExtent(projection, [[0, 0], size], object);\n}\n\nvar maxDepth = 16;\nvar cosMinDistance = cos$1(30 * radians); // cos(minimum angular distance)\n\nvar resample = function(project, delta2) {\n return +delta2 ? resample$1(project, delta2) : resampleNone(project);\n};\n\nfunction resampleNone(project) {\n return transformer({\n point: function(x, y) {\n x = project(x, y);\n this.stream.point(x[0], x[1]);\n }\n });\n}\n\nfunction resample$1(project, delta2) {\n\n function resampleLineTo(x0, y0, lambda0, a0, b0, c0, x1, y1, lambda1, a1, b1, c1, depth, stream) {\n var dx = x1 - x0,\n dy = y1 - y0,\n d2 = dx * dx + dy * dy;\n if (d2 > 4 * delta2 && depth--) {\n var a = a0 + a1,\n b = b0 + b1,\n c = c0 + c1,\n m = sqrt(a * a + b * b + c * c),\n phi2 = asin(c /= m),\n lambda2 = abs(abs(c) - 1) < epsilon$2 || abs(lambda0 - lambda1) < epsilon$2 ? (lambda0 + lambda1) / 2 : atan2(b, a),\n p = project(lambda2, phi2),\n x2 = p[0],\n y2 = p[1],\n dx2 = x2 - x0,\n dy2 = y2 - y0,\n dz = dy * dx2 - dx * dy2;\n if (dz * dz / d2 > delta2 // perpendicular projected distance\n || abs((dx * dx2 + dy * dy2) / d2 - 0.5) > 0.3 // midpoint close to an end\n || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) { // angular distance\n resampleLineTo(x0, y0, lambda0, a0, b0, c0, x2, y2, lambda2, a /= m, b /= m, c, depth, stream);\n stream.point(x2, y2);\n resampleLineTo(x2, y2, lambda2, a, b, c, x1, y1, lambda1, a1, b1, c1, depth, stream);\n }\n }\n }\n return function(stream) {\n var lambda00, x00, y00, a00, b00, c00, // first point\n lambda0, x0, y0, a0, b0, c0; // previous point\n\n var resampleStream = {\n point: point,\n lineStart: lineStart,\n lineEnd: lineEnd,\n polygonStart: function() { stream.polygonStart(); resampleStream.lineStart = ringStart; },\n polygonEnd: function() { stream.polygonEnd(); resampleStream.lineStart = lineStart; }\n };\n\n function point(x, y) {\n x = project(x, y);\n stream.point(x[0], x[1]);\n }\n\n function lineStart() {\n x0 = NaN;\n resampleStream.point = linePoint;\n stream.lineStart();\n }\n\n function linePoint(lambda, phi) {\n var c = cartesian([lambda, phi]), p = project(lambda, phi);\n resampleLineTo(x0, y0, lambda0, a0, b0, c0, x0 = p[0], y0 = p[1], lambda0 = lambda, a0 = c[0], b0 = c[1], c0 = c[2], maxDepth, stream);\n stream.point(x0, y0);\n }\n\n function lineEnd() {\n resampleStream.point = point;\n stream.lineEnd();\n }\n\n function ringStart() {\n lineStart();\n resampleStream.point = ringPoint;\n resampleStream.lineEnd = ringEnd;\n }\n\n function ringPoint(lambda, phi) {\n linePoint(lambda00 = lambda, phi), x00 = x0, y00 = y0, a00 = a0, b00 = b0, c00 = c0;\n resampleStream.point = linePoint;\n }\n\n function ringEnd() {\n resampleLineTo(x0, y0, lambda0, a0, b0, c0, x00, y00, lambda00, a00, b00, c00, maxDepth, stream);\n resampleStream.lineEnd = lineEnd;\n lineEnd();\n }\n\n return resampleStream;\n };\n}\n\nvar transformRadians = transformer({\n point: function(x, y) {\n this.stream.point(x * radians, y * radians);\n }\n});\n\nfunction projection(project) {\n return projectionMutator(function() { return project; })();\n}\n\nfunction projectionMutator(projectAt) {\n var project,\n k = 150, // scale\n x = 480, y = 250, // translate\n dx, dy, lambda = 0, phi = 0, // center\n deltaLambda = 0, deltaPhi = 0, deltaGamma = 0, rotate, projectRotate, // rotate\n theta = null, preclip = clipAntimeridian, // clip angle\n x0 = null, y0, x1, y1, postclip = identity$4, // clip extent\n delta2 = 0.5, projectResample = resample(projectTransform, delta2), // precision\n cache,\n cacheStream;\n\n function projection(point) {\n point = projectRotate(point[0] * radians, point[1] * radians);\n return [point[0] * k + dx, dy - point[1] * k];\n }\n\n function invert(point) {\n point = projectRotate.invert((point[0] - dx) / k, (dy - point[1]) / k);\n return point && [point[0] * degrees$1, point[1] * degrees$1];\n }\n\n function projectTransform(x, y) {\n return x = project(x, y), [x[0] * k + dx, dy - x[1] * k];\n }\n\n projection.stream = function(stream) {\n return cache && cacheStream === stream ? cache : cache = transformRadians(preclip(rotate, projectResample(postclip(cacheStream = stream))));\n };\n\n projection.clipAngle = function(_) {\n return arguments.length ? (preclip = +_ ? clipCircle(theta = _ * radians, 6 * radians) : (theta = null, clipAntimeridian), reset()) : theta * degrees$1;\n };\n\n projection.clipExtent = function(_) {\n return arguments.length ? (postclip = _ == null ? (x0 = y0 = x1 = y1 = null, identity$4) : clipExtent(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]), reset()) : x0 == null ? null : [[x0, y0], [x1, y1]];\n };\n\n projection.scale = function(_) {\n return arguments.length ? (k = +_, recenter()) : k;\n };\n\n projection.translate = function(_) {\n return arguments.length ? (x = +_[0], y = +_[1], recenter()) : [x, y];\n };\n\n projection.center = function(_) {\n return arguments.length ? (lambda = _[0] % 360 * radians, phi = _[1] % 360 * radians, recenter()) : [lambda * degrees$1, phi * degrees$1];\n };\n\n projection.rotate = function(_) {\n return arguments.length ? (deltaLambda = _[0] % 360 * radians, deltaPhi = _[1] % 360 * radians, deltaGamma = _.length > 2 ? _[2] % 360 * radians : 0, recenter()) : [deltaLambda * degrees$1, deltaPhi * degrees$1, deltaGamma * degrees$1];\n };\n\n projection.precision = function(_) {\n return arguments.length ? (projectResample = resample(projectTransform, delta2 = _ * _), reset()) : sqrt(delta2);\n };\n\n projection.fitExtent = function(extent, object) {\n return fitExtent(projection, extent, object);\n };\n\n projection.fitSize = function(size, object) {\n return fitSize(projection, size, object);\n };\n\n function recenter() {\n projectRotate = compose(rotate = rotateRadians(deltaLambda, deltaPhi, deltaGamma), project);\n var center = project(lambda, phi);\n dx = x - center[0] * k;\n dy = y + center[1] * k;\n return reset();\n }\n\n function reset() {\n cache = cacheStream = null;\n return projection;\n }\n\n return function() {\n project = projectAt.apply(this, arguments);\n projection.invert = project.invert && invert;\n return recenter();\n };\n}\n\nfunction conicProjection(projectAt) {\n var phi0 = 0,\n phi1 = pi$3 / 3,\n m = projectionMutator(projectAt),\n p = m(phi0, phi1);\n\n p.parallels = function(_) {\n return arguments.length ? m(phi0 = _[0] * radians, phi1 = _[1] * radians) : [phi0 * degrees$1, phi1 * degrees$1];\n };\n\n return p;\n}\n\nfunction cylindricalEqualAreaRaw(phi0) {\n var cosPhi0 = cos$1(phi0);\n\n function forward(lambda, phi) {\n return [lambda * cosPhi0, sin$1(phi) / cosPhi0];\n }\n\n forward.invert = function(x, y) {\n return [x / cosPhi0, asin(y * cosPhi0)];\n };\n\n return forward;\n}\n\nfunction conicEqualAreaRaw(y0, y1) {\n var sy0 = sin$1(y0), n = (sy0 + sin$1(y1)) / 2;\n\n // Are the parallels symmetrical around the Equator?\n if (abs(n) < epsilon$2) return cylindricalEqualAreaRaw(y0);\n\n var c = 1 + sy0 * (2 * n - sy0), r0 = sqrt(c) / n;\n\n function project(x, y) {\n var r = sqrt(c - 2 * n * sin$1(y)) / n;\n return [r * sin$1(x *= n), r0 - r * cos$1(x)];\n }\n\n project.invert = function(x, y) {\n var r0y = r0 - y;\n return [atan2(x, abs(r0y)) / n * sign(r0y), asin((c - (x * x + r0y * r0y) * n * n) / (2 * n))];\n };\n\n return project;\n}\n\nvar conicEqualArea = function() {\n return conicProjection(conicEqualAreaRaw)\n .scale(155.424)\n .center([0, 33.6442]);\n};\n\nvar albers = function() {\n return conicEqualArea()\n .parallels([29.5, 45.5])\n .scale(1070)\n .translate([480, 250])\n .rotate([96, 0])\n .center([-0.6, 38.7]);\n};\n\n// The projections must have mutually exclusive clip regions on the sphere,\n// as this will avoid emitting interleaving lines and polygons.\nfunction multiplex(streams) {\n var n = streams.length;\n return {\n point: function(x, y) { var i = -1; while (++i < n) streams[i].point(x, y); },\n sphere: function() { var i = -1; while (++i < n) streams[i].sphere(); },\n lineStart: function() { var i = -1; while (++i < n) streams[i].lineStart(); },\n lineEnd: function() { var i = -1; while (++i < n) streams[i].lineEnd(); },\n polygonStart: function() { var i = -1; while (++i < n) streams[i].polygonStart(); },\n polygonEnd: function() { var i = -1; while (++i < n) streams[i].polygonEnd(); }\n };\n}\n\n// A composite projection for the United States, configured by default for\n// 960×500. The projection also works quite well at 960×600 if you change the\n// scale to 1285 and adjust the translate accordingly. The set of standard\n// parallels for each region comes from USGS, which is published here:\n// http://egsc.usgs.gov/isb/pubs/MapProjections/projections.html#albers\nvar albersUsa = function() {\n var cache,\n cacheStream,\n lower48 = albers(), lower48Point,\n alaska = conicEqualArea().rotate([154, 0]).center([-2, 58.5]).parallels([55, 65]), alaskaPoint, // EPSG:3338\n hawaii = conicEqualArea().rotate([157, 0]).center([-3, 19.9]).parallels([8, 18]), hawaiiPoint, // ESRI:102007\n point, pointStream = {point: function(x, y) { point = [x, y]; }};\n\n function albersUsa(coordinates) {\n var x = coordinates[0], y = coordinates[1];\n return point = null,\n (lower48Point.point(x, y), point)\n || (alaskaPoint.point(x, y), point)\n || (hawaiiPoint.point(x, y), point);\n }\n\n albersUsa.invert = function(coordinates) {\n var k = lower48.scale(),\n t = lower48.translate(),\n x = (coordinates[0] - t[0]) / k,\n y = (coordinates[1] - t[1]) / k;\n return (y >= 0.120 && y < 0.234 && x >= -0.425 && x < -0.214 ? alaska\n : y >= 0.166 && y < 0.234 && x >= -0.214 && x < -0.115 ? hawaii\n : lower48).invert(coordinates);\n };\n\n albersUsa.stream = function(stream) {\n return cache && cacheStream === stream ? cache : cache = multiplex([lower48.stream(cacheStream = stream), alaska.stream(stream), hawaii.stream(stream)]);\n };\n\n albersUsa.precision = function(_) {\n if (!arguments.length) return lower48.precision();\n lower48.precision(_), alaska.precision(_), hawaii.precision(_);\n return reset();\n };\n\n albersUsa.scale = function(_) {\n if (!arguments.length) return lower48.scale();\n lower48.scale(_), alaska.scale(_ * 0.35), hawaii.scale(_);\n return albersUsa.translate(lower48.translate());\n };\n\n albersUsa.translate = function(_) {\n if (!arguments.length) return lower48.translate();\n var k = lower48.scale(), x = +_[0], y = +_[1];\n\n lower48Point = lower48\n .translate(_)\n .clipExtent([[x - 0.455 * k, y - 0.238 * k], [x + 0.455 * k, y + 0.238 * k]])\n .stream(pointStream);\n\n alaskaPoint = alaska\n .translate([x - 0.307 * k, y + 0.201 * k])\n .clipExtent([[x - 0.425 * k + epsilon$2, y + 0.120 * k + epsilon$2], [x - 0.214 * k - epsilon$2, y + 0.234 * k - epsilon$2]])\n .stream(pointStream);\n\n hawaiiPoint = hawaii\n .translate([x - 0.205 * k, y + 0.212 * k])\n .clipExtent([[x - 0.214 * k + epsilon$2, y + 0.166 * k + epsilon$2], [x - 0.115 * k - epsilon$2, y + 0.234 * k - epsilon$2]])\n .stream(pointStream);\n\n return reset();\n };\n\n albersUsa.fitExtent = function(extent, object) {\n return fitExtent(albersUsa, extent, object);\n };\n\n albersUsa.fitSize = function(size, object) {\n return fitSize(albersUsa, size, object);\n };\n\n function reset() {\n cache = cacheStream = null;\n return albersUsa;\n }\n\n return albersUsa.scale(1070);\n};\n\nfunction azimuthalRaw(scale) {\n return function(x, y) {\n var cx = cos$1(x),\n cy = cos$1(y),\n k = scale(cx * cy);\n return [\n k * cy * sin$1(x),\n k * sin$1(y)\n ];\n }\n}\n\nfunction azimuthalInvert(angle) {\n return function(x, y) {\n var z = sqrt(x * x + y * y),\n c = angle(z),\n sc = sin$1(c),\n cc = cos$1(c);\n return [\n atan2(x * sc, z * cc),\n asin(z && y * sc / z)\n ];\n }\n}\n\nvar azimuthalEqualAreaRaw = azimuthalRaw(function(cxcy) {\n return sqrt(2 / (1 + cxcy));\n});\n\nazimuthalEqualAreaRaw.invert = azimuthalInvert(function(z) {\n return 2 * asin(z / 2);\n});\n\nvar azimuthalEqualArea = function() {\n return projection(azimuthalEqualAreaRaw)\n .scale(124.75)\n .clipAngle(180 - 1e-3);\n};\n\nvar azimuthalEquidistantRaw = azimuthalRaw(function(c) {\n return (c = acos(c)) && c / sin$1(c);\n});\n\nazimuthalEquidistantRaw.invert = azimuthalInvert(function(z) {\n return z;\n});\n\nvar azimuthalEquidistant = function() {\n return projection(azimuthalEquidistantRaw)\n .scale(79.4188)\n .clipAngle(180 - 1e-3);\n};\n\nfunction mercatorRaw(lambda, phi) {\n return [lambda, log(tan((halfPi$2 + phi) / 2))];\n}\n\nmercatorRaw.invert = function(x, y) {\n return [x, 2 * atan(exp(y)) - halfPi$2];\n};\n\nvar mercator = function() {\n return mercatorProjection(mercatorRaw)\n .scale(961 / tau$3);\n};\n\nfunction mercatorProjection(project) {\n var m = projection(project),\n scale = m.scale,\n translate = m.translate,\n clipExtent = m.clipExtent,\n clipAuto;\n\n m.scale = function(_) {\n return arguments.length ? (scale(_), clipAuto && m.clipExtent(null), m) : scale();\n };\n\n m.translate = function(_) {\n return arguments.length ? (translate(_), clipAuto && m.clipExtent(null), m) : translate();\n };\n\n m.clipExtent = function(_) {\n if (!arguments.length) return clipAuto ? null : clipExtent();\n if (clipAuto = _ == null) {\n var k = pi$3 * scale(),\n t = translate();\n _ = [[t[0] - k, t[1] - k], [t[0] + k, t[1] + k]];\n }\n clipExtent(_);\n return m;\n };\n\n return m.clipExtent(null);\n}\n\nfunction tany(y) {\n return tan((halfPi$2 + y) / 2);\n}\n\nfunction conicConformalRaw(y0, y1) {\n var cy0 = cos$1(y0),\n n = y0 === y1 ? sin$1(y0) : log(cy0 / cos$1(y1)) / log(tany(y1) / tany(y0)),\n f = cy0 * pow(tany(y0), n) / n;\n\n if (!n) return mercatorRaw;\n\n function project(x, y) {\n if (f > 0) { if (y < -halfPi$2 + epsilon$2) y = -halfPi$2 + epsilon$2; }\n else { if (y > halfPi$2 - epsilon$2) y = halfPi$2 - epsilon$2; }\n var r = f / pow(tany(y), n);\n return [r * sin$1(n * x), f - r * cos$1(n * x)];\n }\n\n project.invert = function(x, y) {\n var fy = f - y, r = sign(n) * sqrt(x * x + fy * fy);\n return [atan2(x, abs(fy)) / n * sign(fy), 2 * atan(pow(f / r, 1 / n)) - halfPi$2];\n };\n\n return project;\n}\n\nvar conicConformal = function() {\n return conicProjection(conicConformalRaw)\n .scale(109.5)\n .parallels([30, 30]);\n};\n\nfunction equirectangularRaw(lambda, phi) {\n return [lambda, phi];\n}\n\nequirectangularRaw.invert = equirectangularRaw;\n\nvar equirectangular = function() {\n return projection(equirectangularRaw)\n .scale(152.63);\n};\n\nfunction conicEquidistantRaw(y0, y1) {\n var cy0 = cos$1(y0),\n n = y0 === y1 ? sin$1(y0) : (cy0 - cos$1(y1)) / (y1 - y0),\n g = cy0 / n + y0;\n\n if (abs(n) < epsilon$2) return equirectangularRaw;\n\n function project(x, y) {\n var gy = g - y, nx = n * x;\n return [gy * sin$1(nx), g - gy * cos$1(nx)];\n }\n\n project.invert = function(x, y) {\n var gy = g - y;\n return [atan2(x, abs(gy)) / n * sign(gy), g - sign(n) * sqrt(x * x + gy * gy)];\n };\n\n return project;\n}\n\nvar conicEquidistant = function() {\n return conicProjection(conicEquidistantRaw)\n .scale(131.154)\n .center([0, 13.9389]);\n};\n\nfunction gnomonicRaw(x, y) {\n var cy = cos$1(y), k = cos$1(x) * cy;\n return [cy * sin$1(x) / k, sin$1(y) / k];\n}\n\ngnomonicRaw.invert = azimuthalInvert(atan);\n\nvar gnomonic = function() {\n return projection(gnomonicRaw)\n .scale(144.049)\n .clipAngle(60);\n};\n\nfunction scaleTranslate(kx, ky, tx, ty) {\n return kx === 1 && ky === 1 && tx === 0 && ty === 0 ? identity$4 : transformer({\n point: function(x, y) {\n this.stream.point(x * kx + tx, y * ky + ty);\n }\n });\n}\n\nvar identity$5 = function() {\n var k = 1, tx = 0, ty = 0, sx = 1, sy = 1, transform = identity$4, // scale, translate and reflect\n x0 = null, y0, x1, y1, clip = identity$4, // clip extent\n cache,\n cacheStream,\n projection;\n\n function reset() {\n cache = cacheStream = null;\n return projection;\n }\n\n return projection = {\n stream: function(stream) {\n return cache && cacheStream === stream ? cache : cache = transform(clip(cacheStream = stream));\n },\n clipExtent: function(_) {\n return arguments.length ? (clip = _ == null ? (x0 = y0 = x1 = y1 = null, identity$4) : clipExtent(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]), reset()) : x0 == null ? null : [[x0, y0], [x1, y1]];\n },\n scale: function(_) {\n return arguments.length ? (transform = scaleTranslate((k = +_) * sx, k * sy, tx, ty), reset()) : k;\n },\n translate: function(_) {\n return arguments.length ? (transform = scaleTranslate(k * sx, k * sy, tx = +_[0], ty = +_[1]), reset()) : [tx, ty];\n },\n reflectX: function(_) {\n return arguments.length ? (transform = scaleTranslate(k * (sx = _ ? -1 : 1), k * sy, tx, ty), reset()) : sx < 0;\n },\n reflectY: function(_) {\n return arguments.length ? (transform = scaleTranslate(k * sx, k * (sy = _ ? -1 : 1), tx, ty), reset()) : sy < 0;\n },\n fitExtent: function(extent, object) {\n return fitExtent(projection, extent, object);\n },\n fitSize: function(size, object) {\n return fitSize(projection, size, object);\n }\n };\n};\n\nfunction orthographicRaw(x, y) {\n return [cos$1(y) * sin$1(x), sin$1(y)];\n}\n\northographicRaw.invert = azimuthalInvert(asin);\n\nvar orthographic = function() {\n return projection(orthographicRaw)\n .scale(249.5)\n .clipAngle(90 + epsilon$2);\n};\n\nfunction stereographicRaw(x, y) {\n var cy = cos$1(y), k = 1 + cos$1(x) * cy;\n return [cy * sin$1(x) / k, sin$1(y) / k];\n}\n\nstereographicRaw.invert = azimuthalInvert(function(z) {\n return 2 * atan(z);\n});\n\nvar stereographic = function() {\n return projection(stereographicRaw)\n .scale(250)\n .clipAngle(142);\n};\n\nfunction transverseMercatorRaw(lambda, phi) {\n return [log(tan((halfPi$2 + phi) / 2)), -lambda];\n}\n\ntransverseMercatorRaw.invert = function(x, y) {\n return [-y, 2 * atan(exp(x)) - halfPi$2];\n};\n\nvar transverseMercator = function() {\n var m = mercatorProjection(transverseMercatorRaw),\n center = m.center,\n rotate = m.rotate;\n\n m.center = function(_) {\n return arguments.length ? center([-_[1], _[0]]) : (_ = center(), [_[1], -_[0]]);\n };\n\n m.rotate = function(_) {\n return arguments.length ? rotate([_[0], _[1], _.length > 2 ? _[2] + 90 : 90]) : (_ = rotate(), [_[0], _[1], _[2] - 90]);\n };\n\n return rotate([0, 0, 90])\n .scale(159.155);\n};\n\nfunction defaultSeparation(a, b) {\n return a.parent === b.parent ? 1 : 2;\n}\n\nfunction meanX(children) {\n return children.reduce(meanXReduce, 0) / children.length;\n}\n\nfunction meanXReduce(x, c) {\n return x + c.x;\n}\n\nfunction maxY(children) {\n return 1 + children.reduce(maxYReduce, 0);\n}\n\nfunction maxYReduce(y, c) {\n return Math.max(y, c.y);\n}\n\nfunction leafLeft(node) {\n var children;\n while (children = node.children) node = children[0];\n return node;\n}\n\nfunction leafRight(node) {\n var children;\n while (children = node.children) node = children[children.length - 1];\n return node;\n}\n\nvar cluster = function() {\n var separation = defaultSeparation,\n dx = 1,\n dy = 1,\n nodeSize = false;\n\n function cluster(root) {\n var previousNode,\n x = 0;\n\n // First walk, computing the initial x & y values.\n root.eachAfter(function(node) {\n var children = node.children;\n if (children) {\n node.x = meanX(children);\n node.y = maxY(children);\n } else {\n node.x = previousNode ? x += separation(node, previousNode) : 0;\n node.y = 0;\n previousNode = node;\n }\n });\n\n var left = leafLeft(root),\n right = leafRight(root),\n x0 = left.x - separation(left, right) / 2,\n x1 = right.x + separation(right, left) / 2;\n\n // Second walk, normalizing x & y to the desired size.\n return root.eachAfter(nodeSize ? function(node) {\n node.x = (node.x - root.x) * dx;\n node.y = (root.y - node.y) * dy;\n } : function(node) {\n node.x = (node.x - x0) / (x1 - x0) * dx;\n node.y = (1 - (root.y ? node.y / root.y : 1)) * dy;\n });\n }\n\n cluster.separation = function(x) {\n return arguments.length ? (separation = x, cluster) : separation;\n };\n\n cluster.size = function(x) {\n return arguments.length ? (nodeSize = false, dx = +x[0], dy = +x[1], cluster) : (nodeSize ? null : [dx, dy]);\n };\n\n cluster.nodeSize = function(x) {\n return arguments.length ? (nodeSize = true, dx = +x[0], dy = +x[1], cluster) : (nodeSize ? [dx, dy] : null);\n };\n\n return cluster;\n};\n\nfunction count(node) {\n var sum = 0,\n children = node.children,\n i = children && children.length;\n if (!i) sum = 1;\n else while (--i >= 0) sum += children[i].value;\n node.value = sum;\n}\n\nvar node_count = function() {\n return this.eachAfter(count);\n};\n\nvar node_each = function(callback) {\n var node = this, current, next = [node], children, i, n;\n do {\n current = next.reverse(), next = [];\n while (node = current.pop()) {\n callback(node), children = node.children;\n if (children) for (i = 0, n = children.length; i < n; ++i) {\n next.push(children[i]);\n }\n }\n } while (next.length);\n return this;\n};\n\nvar node_eachBefore = function(callback) {\n var node = this, nodes = [node], children, i;\n while (node = nodes.pop()) {\n callback(node), children = node.children;\n if (children) for (i = children.length - 1; i >= 0; --i) {\n nodes.push(children[i]);\n }\n }\n return this;\n};\n\nvar node_eachAfter = function(callback) {\n var node = this, nodes = [node], next = [], children, i, n;\n while (node = nodes.pop()) {\n next.push(node), children = node.children;\n if (children) for (i = 0, n = children.length; i < n; ++i) {\n nodes.push(children[i]);\n }\n }\n while (node = next.pop()) {\n callback(node);\n }\n return this;\n};\n\nvar node_sum = function(value) {\n return this.eachAfter(function(node) {\n var sum = +value(node.data) || 0,\n children = node.children,\n i = children && children.length;\n while (--i >= 0) sum += children[i].value;\n node.value = sum;\n });\n};\n\nvar node_sort = function(compare) {\n return this.eachBefore(function(node) {\n if (node.children) {\n node.children.sort(compare);\n }\n });\n};\n\nvar node_path = function(end) {\n var start = this,\n ancestor = leastCommonAncestor(start, end),\n nodes = [start];\n while (start !== ancestor) {\n start = start.parent;\n nodes.push(start);\n }\n var k = nodes.length;\n while (end !== ancestor) {\n nodes.splice(k, 0, end);\n end = end.parent;\n }\n return nodes;\n};\n\nfunction leastCommonAncestor(a, b) {\n if (a === b) return a;\n var aNodes = a.ancestors(),\n bNodes = b.ancestors(),\n c = null;\n a = aNodes.pop();\n b = bNodes.pop();\n while (a === b) {\n c = a;\n a = aNodes.pop();\n b = bNodes.pop();\n }\n return c;\n}\n\nvar node_ancestors = function() {\n var node = this, nodes = [node];\n while (node = node.parent) {\n nodes.push(node);\n }\n return nodes;\n};\n\nvar node_descendants = function() {\n var nodes = [];\n this.each(function(node) {\n nodes.push(node);\n });\n return nodes;\n};\n\nvar node_leaves = function() {\n var leaves = [];\n this.eachBefore(function(node) {\n if (!node.children) {\n leaves.push(node);\n }\n });\n return leaves;\n};\n\nvar node_links = function() {\n var root = this, links = [];\n root.each(function(node) {\n if (node !== root) { // Don’t include the root’s parent, if any.\n links.push({source: node.parent, target: node});\n }\n });\n return links;\n};\n\nfunction hierarchy(data, children) {\n var root = new Node(data),\n valued = +data.value && (root.value = data.value),\n node,\n nodes = [root],\n child,\n childs,\n i,\n n;\n\n if (children == null) children = defaultChildren;\n\n while (node = nodes.pop()) {\n if (valued) node.value = +node.data.value;\n if ((childs = children(node.data)) && (n = childs.length)) {\n node.children = new Array(n);\n for (i = n - 1; i >= 0; --i) {\n nodes.push(child = node.children[i] = new Node(childs[i]));\n child.parent = node;\n child.depth = node.depth + 1;\n }\n }\n }\n\n return root.eachBefore(computeHeight);\n}\n\nfunction node_copy() {\n return hierarchy(this).eachBefore(copyData);\n}\n\nfunction defaultChildren(d) {\n return d.children;\n}\n\nfunction copyData(node) {\n node.data = node.data.data;\n}\n\nfunction computeHeight(node) {\n var height = 0;\n do node.height = height;\n while ((node = node.parent) && (node.height < ++height));\n}\n\nfunction Node(data) {\n this.data = data;\n this.depth =\n this.height = 0;\n this.parent = null;\n}\n\nNode.prototype = hierarchy.prototype = {\n constructor: Node,\n count: node_count,\n each: node_each,\n eachAfter: node_eachAfter,\n eachBefore: node_eachBefore,\n sum: node_sum,\n sort: node_sort,\n path: node_path,\n ancestors: node_ancestors,\n descendants: node_descendants,\n leaves: node_leaves,\n links: node_links,\n copy: node_copy\n};\n\nfunction Node$2(value) {\n this._ = value;\n this.next = null;\n}\n\nvar shuffle$1 = function(array) {\n var i,\n n = (array = array.slice()).length,\n head = null,\n node = head;\n\n while (n) {\n var next = new Node$2(array[n - 1]);\n if (node) node = node.next = next;\n else node = head = next;\n array[i] = array[--n];\n }\n\n return {\n head: head,\n tail: node\n };\n};\n\nvar enclose = function(circles) {\n return encloseN(shuffle$1(circles), []);\n};\n\nfunction encloses(a, b) {\n var dx = b.x - a.x,\n dy = b.y - a.y,\n dr = a.r - b.r;\n return dr * dr + 1e-6 > dx * dx + dy * dy;\n}\n\n// Returns the smallest circle that contains circles L and intersects circles B.\nfunction encloseN(L, B) {\n var circle,\n l0 = null,\n l1 = L.head,\n l2,\n p1;\n\n switch (B.length) {\n case 1: circle = enclose1(B[0]); break;\n case 2: circle = enclose2(B[0], B[1]); break;\n case 3: circle = enclose3(B[0], B[1], B[2]); break;\n }\n\n while (l1) {\n p1 = l1._, l2 = l1.next;\n if (!circle || !encloses(circle, p1)) {\n\n // Temporarily truncate L before l1.\n if (l0) L.tail = l0, l0.next = null;\n else L.head = L.tail = null;\n\n B.push(p1);\n circle = encloseN(L, B); // Note: reorders L!\n B.pop();\n\n // Move l1 to the front of L and reconnect the truncated list L.\n if (L.head) l1.next = L.head, L.head = l1;\n else l1.next = null, L.head = L.tail = l1;\n l0 = L.tail, l0.next = l2;\n\n } else {\n l0 = l1;\n }\n l1 = l2;\n }\n\n L.tail = l0;\n return circle;\n}\n\nfunction enclose1(a) {\n return {\n x: a.x,\n y: a.y,\n r: a.r\n };\n}\n\nfunction enclose2(a, b) {\n var x1 = a.x, y1 = a.y, r1 = a.r,\n x2 = b.x, y2 = b.y, r2 = b.r,\n x21 = x2 - x1, y21 = y2 - y1, r21 = r2 - r1,\n l = Math.sqrt(x21 * x21 + y21 * y21);\n return {\n x: (x1 + x2 + x21 / l * r21) / 2,\n y: (y1 + y2 + y21 / l * r21) / 2,\n r: (l + r1 + r2) / 2\n };\n}\n\nfunction enclose3(a, b, c) {\n var x1 = a.x, y1 = a.y, r1 = a.r,\n x2 = b.x, y2 = b.y, r2 = b.r,\n x3 = c.x, y3 = c.y, r3 = c.r,\n a2 = 2 * (x1 - x2),\n b2 = 2 * (y1 - y2),\n c2 = 2 * (r2 - r1),\n d2 = x1 * x1 + y1 * y1 - r1 * r1 - x2 * x2 - y2 * y2 + r2 * r2,\n a3 = 2 * (x1 - x3),\n b3 = 2 * (y1 - y3),\n c3 = 2 * (r3 - r1),\n d3 = x1 * x1 + y1 * y1 - r1 * r1 - x3 * x3 - y3 * y3 + r3 * r3,\n ab = a3 * b2 - a2 * b3,\n xa = (b2 * d3 - b3 * d2) / ab - x1,\n xb = (b3 * c2 - b2 * c3) / ab,\n ya = (a3 * d2 - a2 * d3) / ab - y1,\n yb = (a2 * c3 - a3 * c2) / ab,\n A = xb * xb + yb * yb - 1,\n B = 2 * (xa * xb + ya * yb + r1),\n C = xa * xa + ya * ya - r1 * r1,\n r = (-B - Math.sqrt(B * B - 4 * A * C)) / (2 * A);\n return {\n x: xa + xb * r + x1,\n y: ya + yb * r + y1,\n r: r\n };\n}\n\nfunction place(a, b, c) {\n var ax = a.x,\n ay = a.y,\n da = b.r + c.r,\n db = a.r + c.r,\n dx = b.x - ax,\n dy = b.y - ay,\n dc = dx * dx + dy * dy;\n if (dc) {\n var x = 0.5 + ((db *= db) - (da *= da)) / (2 * dc),\n y = Math.sqrt(Math.max(0, 2 * da * (db + dc) - (db -= dc) * db - da * da)) / (2 * dc);\n c.x = ax + x * dx + y * dy;\n c.y = ay + x * dy - y * dx;\n } else {\n c.x = ax + db;\n c.y = ay;\n }\n}\n\nfunction intersects(a, b) {\n var dx = b.x - a.x,\n dy = b.y - a.y,\n dr = a.r + b.r;\n return dr * dr - 1e-6 > dx * dx + dy * dy;\n}\n\nfunction distance1(a, b) {\n var l = a._.r;\n while (a !== b) l += 2 * (a = a.next)._.r;\n return l - b._.r;\n}\n\nfunction distance2(node, x, y) {\n var a = node._,\n b = node.next._,\n ab = a.r + b.r,\n dx = (a.x * b.r + b.x * a.r) / ab - x,\n dy = (a.y * b.r + b.y * a.r) / ab - y;\n return dx * dx + dy * dy;\n}\n\nfunction Node$1(circle) {\n this._ = circle;\n this.next = null;\n this.previous = null;\n}\n\nfunction packEnclose(circles) {\n if (!(n = circles.length)) return 0;\n\n var a, b, c, n;\n\n // Place the first circle.\n a = circles[0], a.x = 0, a.y = 0;\n if (!(n > 1)) return a.r;\n\n // Place the second circle.\n b = circles[1], a.x = -b.r, b.x = a.r, b.y = 0;\n if (!(n > 2)) return a.r + b.r;\n\n // Place the third circle.\n place(b, a, c = circles[2]);\n\n // Initialize the weighted centroid.\n var aa = a.r * a.r,\n ba = b.r * b.r,\n ca = c.r * c.r,\n oa = aa + ba + ca,\n ox = aa * a.x + ba * b.x + ca * c.x,\n oy = aa * a.y + ba * b.y + ca * c.y,\n cx, cy, i, j, k, sj, sk;\n\n // Initialize the front-chain using the first three circles a, b and c.\n a = new Node$1(a), b = new Node$1(b), c = new Node$1(c);\n a.next = c.previous = b;\n b.next = a.previous = c;\n c.next = b.previous = a;\n\n // Attempt to place each remaining circle…\n pack: for (i = 3; i < n; ++i) {\n place(a._, b._, c = circles[i]), c = new Node$1(c);\n\n // Find the closest intersecting circle on the front-chain, if any.\n // “Closeness” is determined by linear distance along the front-chain.\n // “Ahead” or “behind” is likewise determined by linear distance.\n j = b.next, k = a.previous, sj = b._.r, sk = a._.r;\n do {\n if (sj <= sk) {\n if (intersects(j._, c._)) {\n if (sj + a._.r + b._.r > distance1(j, b)) a = j; else b = j;\n a.next = b, b.previous = a, --i;\n continue pack;\n }\n sj += j._.r, j = j.next;\n } else {\n if (intersects(k._, c._)) {\n if (distance1(a, k) > sk + a._.r + b._.r) a = k; else b = k;\n a.next = b, b.previous = a, --i;\n continue pack;\n }\n sk += k._.r, k = k.previous;\n }\n } while (j !== k.next);\n\n // Success! Insert the new circle c between a and b.\n c.previous = a, c.next = b, a.next = b.previous = b = c;\n\n // Update the weighted centroid.\n oa += ca = c._.r * c._.r;\n ox += ca * c._.x;\n oy += ca * c._.y;\n\n // Compute the new closest circle pair to the centroid.\n aa = distance2(a, cx = ox / oa, cy = oy / oa);\n while ((c = c.next) !== b) {\n if ((ca = distance2(c, cx, cy)) < aa) {\n a = c, aa = ca;\n }\n }\n b = a.next;\n }\n\n // Compute the enclosing circle of the front chain.\n a = [b._], c = b; while ((c = c.next) !== b) a.push(c._); c = enclose(a);\n\n // Translate the circles to put the enclosing circle around the origin.\n for (i = 0; i < n; ++i) a = circles[i], a.x -= c.x, a.y -= c.y;\n\n return c.r;\n}\n\nvar siblings = function(circles) {\n packEnclose(circles);\n return circles;\n};\n\nfunction optional(f) {\n return f == null ? null : required(f);\n}\n\nfunction required(f) {\n if (typeof f !== \"function\") throw new Error;\n return f;\n}\n\nfunction constantZero() {\n return 0;\n}\n\nvar constant$8 = function(x) {\n return function() {\n return x;\n };\n};\n\nfunction defaultRadius$1(d) {\n return Math.sqrt(d.value);\n}\n\nvar index$2 = function() {\n var radius = null,\n dx = 1,\n dy = 1,\n padding = constantZero;\n\n function pack(root) {\n root.x = dx / 2, root.y = dy / 2;\n if (radius) {\n root.eachBefore(radiusLeaf(radius))\n .eachAfter(packChildren(padding, 0.5))\n .eachBefore(translateChild(1));\n } else {\n root.eachBefore(radiusLeaf(defaultRadius$1))\n .eachAfter(packChildren(constantZero, 1))\n .eachAfter(packChildren(padding, root.r / Math.min(dx, dy)))\n .eachBefore(translateChild(Math.min(dx, dy) / (2 * root.r)));\n }\n return root;\n }\n\n pack.radius = function(x) {\n return arguments.length ? (radius = optional(x), pack) : radius;\n };\n\n pack.size = function(x) {\n return arguments.length ? (dx = +x[0], dy = +x[1], pack) : [dx, dy];\n };\n\n pack.padding = function(x) {\n return arguments.length ? (padding = typeof x === \"function\" ? x : constant$8(+x), pack) : padding;\n };\n\n return pack;\n};\n\nfunction radiusLeaf(radius) {\n return function(node) {\n if (!node.children) {\n node.r = Math.max(0, +radius(node) || 0);\n }\n };\n}\n\nfunction packChildren(padding, k) {\n return function(node) {\n if (children = node.children) {\n var children,\n i,\n n = children.length,\n r = padding(node) * k || 0,\n e;\n\n if (r) for (i = 0; i < n; ++i) children[i].r += r;\n e = packEnclose(children);\n if (r) for (i = 0; i < n; ++i) children[i].r -= r;\n node.r = e + r;\n }\n };\n}\n\nfunction translateChild(k) {\n return function(node) {\n var parent = node.parent;\n node.r *= k;\n if (parent) {\n node.x = parent.x + k * node.x;\n node.y = parent.y + k * node.y;\n }\n };\n}\n\nvar roundNode = function(node) {\n node.x0 = Math.round(node.x0);\n node.y0 = Math.round(node.y0);\n node.x1 = Math.round(node.x1);\n node.y1 = Math.round(node.y1);\n};\n\nvar treemapDice = function(parent, x0, y0, x1, y1) {\n var nodes = parent.children,\n node,\n i = -1,\n n = nodes.length,\n k = parent.value && (x1 - x0) / parent.value;\n\n while (++i < n) {\n node = nodes[i], node.y0 = y0, node.y1 = y1;\n node.x0 = x0, node.x1 = x0 += node.value * k;\n }\n};\n\nvar partition = function() {\n var dx = 1,\n dy = 1,\n padding = 0,\n round = false;\n\n function partition(root) {\n var n = root.height + 1;\n root.x0 =\n root.y0 = padding;\n root.x1 = dx;\n root.y1 = dy / n;\n root.eachBefore(positionNode(dy, n));\n if (round) root.eachBefore(roundNode);\n return root;\n }\n\n function positionNode(dy, n) {\n return function(node) {\n if (node.children) {\n treemapDice(node, node.x0, dy * (node.depth + 1) / n, node.x1, dy * (node.depth + 2) / n);\n }\n var x0 = node.x0,\n y0 = node.y0,\n x1 = node.x1 - padding,\n y1 = node.y1 - padding;\n if (x1 < x0) x0 = x1 = (x0 + x1) / 2;\n if (y1 < y0) y0 = y1 = (y0 + y1) / 2;\n node.x0 = x0;\n node.y0 = y0;\n node.x1 = x1;\n node.y1 = y1;\n };\n }\n\n partition.round = function(x) {\n return arguments.length ? (round = !!x, partition) : round;\n };\n\n partition.size = function(x) {\n return arguments.length ? (dx = +x[0], dy = +x[1], partition) : [dx, dy];\n };\n\n partition.padding = function(x) {\n return arguments.length ? (padding = +x, partition) : padding;\n };\n\n return partition;\n};\n\nvar keyPrefix$1 = \"$\";\nvar preroot = {depth: -1};\nvar ambiguous = {};\n\nfunction defaultId(d) {\n return d.id;\n}\n\nfunction defaultParentId(d) {\n return d.parentId;\n}\n\nvar stratify = function() {\n var id = defaultId,\n parentId = defaultParentId;\n\n function stratify(data) {\n var d,\n i,\n n = data.length,\n root,\n parent,\n node,\n nodes = new Array(n),\n nodeId,\n nodeKey,\n nodeByKey = {};\n\n for (i = 0; i < n; ++i) {\n d = data[i], node = nodes[i] = new Node(d);\n if ((nodeId = id(d, i, data)) != null && (nodeId += \"\")) {\n nodeKey = keyPrefix$1 + (node.id = nodeId);\n nodeByKey[nodeKey] = nodeKey in nodeByKey ? ambiguous : node;\n }\n }\n\n for (i = 0; i < n; ++i) {\n node = nodes[i], nodeId = parentId(data[i], i, data);\n if (nodeId == null || !(nodeId += \"\")) {\n if (root) throw new Error(\"multiple roots\");\n root = node;\n } else {\n parent = nodeByKey[keyPrefix$1 + nodeId];\n if (!parent) throw new Error(\"missing: \" + nodeId);\n if (parent === ambiguous) throw new Error(\"ambiguous: \" + nodeId);\n if (parent.children) parent.children.push(node);\n else parent.children = [node];\n node.parent = parent;\n }\n }\n\n if (!root) throw new Error(\"no root\");\n root.parent = preroot;\n root.eachBefore(function(node) { node.depth = node.parent.depth + 1; --n; }).eachBefore(computeHeight);\n root.parent = null;\n if (n > 0) throw new Error(\"cycle\");\n\n return root;\n }\n\n stratify.id = function(x) {\n return arguments.length ? (id = required(x), stratify) : id;\n };\n\n stratify.parentId = function(x) {\n return arguments.length ? (parentId = required(x), stratify) : parentId;\n };\n\n return stratify;\n};\n\nfunction defaultSeparation$1(a, b) {\n return a.parent === b.parent ? 1 : 2;\n}\n\n// function radialSeparation(a, b) {\n// return (a.parent === b.parent ? 1 : 2) / a.depth;\n// }\n\n// This function is used to traverse the left contour of a subtree (or\n// subforest). It returns the successor of v on this contour. This successor is\n// either given by the leftmost child of v or by the thread of v. The function\n// returns null if and only if v is on the highest level of its subtree.\nfunction nextLeft(v) {\n var children = v.children;\n return children ? children[0] : v.t;\n}\n\n// This function works analogously to nextLeft.\nfunction nextRight(v) {\n var children = v.children;\n return children ? children[children.length - 1] : v.t;\n}\n\n// Shifts the current subtree rooted at w+. This is done by increasing\n// prelim(w+) and mod(w+) by shift.\nfunction moveSubtree(wm, wp, shift) {\n var change = shift / (wp.i - wm.i);\n wp.c -= change;\n wp.s += shift;\n wm.c += change;\n wp.z += shift;\n wp.m += shift;\n}\n\n// All other shifts, applied to the smaller subtrees between w- and w+, are\n// performed by this function. To prepare the shifts, we have to adjust\n// change(w+), shift(w+), and change(w-).\nfunction executeShifts(v) {\n var shift = 0,\n change = 0,\n children = v.children,\n i = children.length,\n w;\n while (--i >= 0) {\n w = children[i];\n w.z += shift;\n w.m += shift;\n shift += w.s + (change += w.c);\n }\n}\n\n// If vi-’s ancestor is a sibling of v, returns vi-’s ancestor. Otherwise,\n// returns the specified (default) ancestor.\nfunction nextAncestor(vim, v, ancestor) {\n return vim.a.parent === v.parent ? vim.a : ancestor;\n}\n\nfunction TreeNode(node, i) {\n this._ = node;\n this.parent = null;\n this.children = null;\n this.A = null; // default ancestor\n this.a = this; // ancestor\n this.z = 0; // prelim\n this.m = 0; // mod\n this.c = 0; // change\n this.s = 0; // shift\n this.t = null; // thread\n this.i = i; // number\n}\n\nTreeNode.prototype = Object.create(Node.prototype);\n\nfunction treeRoot(root) {\n var tree = new TreeNode(root, 0),\n node,\n nodes = [tree],\n child,\n children,\n i,\n n;\n\n while (node = nodes.pop()) {\n if (children = node._.children) {\n node.children = new Array(n = children.length);\n for (i = n - 1; i >= 0; --i) {\n nodes.push(child = node.children[i] = new TreeNode(children[i], i));\n child.parent = node;\n }\n }\n }\n\n (tree.parent = new TreeNode(null, 0)).children = [tree];\n return tree;\n}\n\n// Node-link tree diagram using the Reingold-Tilford \"tidy\" algorithm\nvar tree = function() {\n var separation = defaultSeparation$1,\n dx = 1,\n dy = 1,\n nodeSize = null;\n\n function tree(root) {\n var t = treeRoot(root);\n\n // Compute the layout using Buchheim et al.’s algorithm.\n t.eachAfter(firstWalk), t.parent.m = -t.z;\n t.eachBefore(secondWalk);\n\n // If a fixed node size is specified, scale x and y.\n if (nodeSize) root.eachBefore(sizeNode);\n\n // If a fixed tree size is specified, scale x and y based on the extent.\n // Compute the left-most, right-most, and depth-most nodes for extents.\n else {\n var left = root,\n right = root,\n bottom = root;\n root.eachBefore(function(node) {\n if (node.x < left.x) left = node;\n if (node.x > right.x) right = node;\n if (node.depth > bottom.depth) bottom = node;\n });\n var s = left === right ? 1 : separation(left, right) / 2,\n tx = s - left.x,\n kx = dx / (right.x + s + tx),\n ky = dy / (bottom.depth || 1);\n root.eachBefore(function(node) {\n node.x = (node.x + tx) * kx;\n node.y = node.depth * ky;\n });\n }\n\n return root;\n }\n\n // Computes a preliminary x-coordinate for v. Before that, FIRST WALK is\n // applied recursively to the children of v, as well as the function\n // APPORTION. After spacing out the children by calling EXECUTE SHIFTS, the\n // node v is placed to the midpoint of its outermost children.\n function firstWalk(v) {\n var children = v.children,\n siblings = v.parent.children,\n w = v.i ? siblings[v.i - 1] : null;\n if (children) {\n executeShifts(v);\n var midpoint = (children[0].z + children[children.length - 1].z) / 2;\n if (w) {\n v.z = w.z + separation(v._, w._);\n v.m = v.z - midpoint;\n } else {\n v.z = midpoint;\n }\n } else if (w) {\n v.z = w.z + separation(v._, w._);\n }\n v.parent.A = apportion(v, w, v.parent.A || siblings[0]);\n }\n\n // Computes all real x-coordinates by summing up the modifiers recursively.\n function secondWalk(v) {\n v._.x = v.z + v.parent.m;\n v.m += v.parent.m;\n }\n\n // The core of the algorithm. Here, a new subtree is combined with the\n // previous subtrees. Threads are used to traverse the inside and outside\n // contours of the left and right subtree up to the highest common level. The\n // vertices used for the traversals are vi+, vi-, vo-, and vo+, where the\n // superscript o means outside and i means inside, the subscript - means left\n // subtree and + means right subtree. For summing up the modifiers along the\n // contour, we use respective variables si+, si-, so-, and so+. Whenever two\n // nodes of the inside contours conflict, we compute the left one of the\n // greatest uncommon ancestors using the function ANCESTOR and call MOVE\n // SUBTREE to shift the subtree and prepare the shifts of smaller subtrees.\n // Finally, we add a new thread (if necessary).\n function apportion(v, w, ancestor) {\n if (w) {\n var vip = v,\n vop = v,\n vim = w,\n vom = vip.parent.children[0],\n sip = vip.m,\n sop = vop.m,\n sim = vim.m,\n som = vom.m,\n shift;\n while (vim = nextRight(vim), vip = nextLeft(vip), vim && vip) {\n vom = nextLeft(vom);\n vop = nextRight(vop);\n vop.a = v;\n shift = vim.z + sim - vip.z - sip + separation(vim._, vip._);\n if (shift > 0) {\n moveSubtree(nextAncestor(vim, v, ancestor), v, shift);\n sip += shift;\n sop += shift;\n }\n sim += vim.m;\n sip += vip.m;\n som += vom.m;\n sop += vop.m;\n }\n if (vim && !nextRight(vop)) {\n vop.t = vim;\n vop.m += sim - sop;\n }\n if (vip && !nextLeft(vom)) {\n vom.t = vip;\n vom.m += sip - som;\n ancestor = v;\n }\n }\n return ancestor;\n }\n\n function sizeNode(node) {\n node.x *= dx;\n node.y = node.depth * dy;\n }\n\n tree.separation = function(x) {\n return arguments.length ? (separation = x, tree) : separation;\n };\n\n tree.size = function(x) {\n return arguments.length ? (nodeSize = false, dx = +x[0], dy = +x[1], tree) : (nodeSize ? null : [dx, dy]);\n };\n\n tree.nodeSize = function(x) {\n return arguments.length ? (nodeSize = true, dx = +x[0], dy = +x[1], tree) : (nodeSize ? [dx, dy] : null);\n };\n\n return tree;\n};\n\nvar treemapSlice = function(parent, x0, y0, x1, y1) {\n var nodes = parent.children,\n node,\n i = -1,\n n = nodes.length,\n k = parent.value && (y1 - y0) / parent.value;\n\n while (++i < n) {\n node = nodes[i], node.x0 = x0, node.x1 = x1;\n node.y0 = y0, node.y1 = y0 += node.value * k;\n }\n};\n\nvar phi = (1 + Math.sqrt(5)) / 2;\n\nfunction squarifyRatio(ratio, parent, x0, y0, x1, y1) {\n var rows = [],\n nodes = parent.children,\n row,\n nodeValue,\n i0 = 0,\n i1 = 0,\n n = nodes.length,\n dx, dy,\n value = parent.value,\n sumValue,\n minValue,\n maxValue,\n newRatio,\n minRatio,\n alpha,\n beta;\n\n while (i0 < n) {\n dx = x1 - x0, dy = y1 - y0;\n\n // Find the next non-empty node.\n do sumValue = nodes[i1++].value; while (!sumValue && i1 < n);\n minValue = maxValue = sumValue;\n alpha = Math.max(dy / dx, dx / dy) / (value * ratio);\n beta = sumValue * sumValue * alpha;\n minRatio = Math.max(maxValue / beta, beta / minValue);\n\n // Keep adding nodes while the aspect ratio maintains or improves.\n for (; i1 < n; ++i1) {\n sumValue += nodeValue = nodes[i1].value;\n if (nodeValue < minValue) minValue = nodeValue;\n if (nodeValue > maxValue) maxValue = nodeValue;\n beta = sumValue * sumValue * alpha;\n newRatio = Math.max(maxValue / beta, beta / minValue);\n if (newRatio > minRatio) { sumValue -= nodeValue; break; }\n minRatio = newRatio;\n }\n\n // Position and record the row orientation.\n rows.push(row = {value: sumValue, dice: dx < dy, children: nodes.slice(i0, i1)});\n if (row.dice) treemapDice(row, x0, y0, x1, value ? y0 += dy * sumValue / value : y1);\n else treemapSlice(row, x0, y0, value ? x0 += dx * sumValue / value : x1, y1);\n value -= sumValue, i0 = i1;\n }\n\n return rows;\n}\n\nvar squarify = ((function custom(ratio) {\n\n function squarify(parent, x0, y0, x1, y1) {\n squarifyRatio(ratio, parent, x0, y0, x1, y1);\n }\n\n squarify.ratio = function(x) {\n return custom((x = +x) > 1 ? x : 1);\n };\n\n return squarify;\n}))(phi);\n\nvar index$3 = function() {\n var tile = squarify,\n round = false,\n dx = 1,\n dy = 1,\n paddingStack = [0],\n paddingInner = constantZero,\n paddingTop = constantZero,\n paddingRight = constantZero,\n paddingBottom = constantZero,\n paddingLeft = constantZero;\n\n function treemap(root) {\n root.x0 =\n root.y0 = 0;\n root.x1 = dx;\n root.y1 = dy;\n root.eachBefore(positionNode);\n paddingStack = [0];\n if (round) root.eachBefore(roundNode);\n return root;\n }\n\n function positionNode(node) {\n var p = paddingStack[node.depth],\n x0 = node.x0 + p,\n y0 = node.y0 + p,\n x1 = node.x1 - p,\n y1 = node.y1 - p;\n if (x1 < x0) x0 = x1 = (x0 + x1) / 2;\n if (y1 < y0) y0 = y1 = (y0 + y1) / 2;\n node.x0 = x0;\n node.y0 = y0;\n node.x1 = x1;\n node.y1 = y1;\n if (node.children) {\n p = paddingStack[node.depth + 1] = paddingInner(node) / 2;\n x0 += paddingLeft(node) - p;\n y0 += paddingTop(node) - p;\n x1 -= paddingRight(node) - p;\n y1 -= paddingBottom(node) - p;\n if (x1 < x0) x0 = x1 = (x0 + x1) / 2;\n if (y1 < y0) y0 = y1 = (y0 + y1) / 2;\n tile(node, x0, y0, x1, y1);\n }\n }\n\n treemap.round = function(x) {\n return arguments.length ? (round = !!x, treemap) : round;\n };\n\n treemap.size = function(x) {\n return arguments.length ? (dx = +x[0], dy = +x[1], treemap) : [dx, dy];\n };\n\n treemap.tile = function(x) {\n return arguments.length ? (tile = required(x), treemap) : tile;\n };\n\n treemap.padding = function(x) {\n return arguments.length ? treemap.paddingInner(x).paddingOuter(x) : treemap.paddingInner();\n };\n\n treemap.paddingInner = function(x) {\n return arguments.length ? (paddingInner = typeof x === \"function\" ? x : constant$8(+x), treemap) : paddingInner;\n };\n\n treemap.paddingOuter = function(x) {\n return arguments.length ? treemap.paddingTop(x).paddingRight(x).paddingBottom(x).paddingLeft(x) : treemap.paddingTop();\n };\n\n treemap.paddingTop = function(x) {\n return arguments.length ? (paddingTop = typeof x === \"function\" ? x : constant$8(+x), treemap) : paddingTop;\n };\n\n treemap.paddingRight = function(x) {\n return arguments.length ? (paddingRight = typeof x === \"function\" ? x : constant$8(+x), treemap) : paddingRight;\n };\n\n treemap.paddingBottom = function(x) {\n return arguments.length ? (paddingBottom = typeof x === \"function\" ? x : constant$8(+x), treemap) : paddingBottom;\n };\n\n treemap.paddingLeft = function(x) {\n return arguments.length ? (paddingLeft = typeof x === \"function\" ? x : constant$8(+x), treemap) : paddingLeft;\n };\n\n return treemap;\n};\n\nvar binary = function(parent, x0, y0, x1, y1) {\n var nodes = parent.children,\n i, n = nodes.length,\n sum, sums = new Array(n + 1);\n\n for (sums[0] = sum = i = 0; i < n; ++i) {\n sums[i + 1] = sum += nodes[i].value;\n }\n\n partition(0, n, parent.value, x0, y0, x1, y1);\n\n function partition(i, j, value, x0, y0, x1, y1) {\n if (i >= j - 1) {\n var node = nodes[i];\n node.x0 = x0, node.y0 = y0;\n node.x1 = x1, node.y1 = y1;\n return;\n }\n\n var valueOffset = sums[i],\n valueTarget = (value / 2) + valueOffset,\n k = i + 1,\n hi = j - 1;\n\n while (k < hi) {\n var mid = k + hi >>> 1;\n if (sums[mid] < valueTarget) k = mid + 1;\n else hi = mid;\n }\n\n var valueLeft = sums[k] - valueOffset,\n valueRight = value - valueLeft;\n\n if ((y1 - y0) > (x1 - x0)) {\n var yk = (y0 * valueRight + y1 * valueLeft) / value;\n partition(i, k, valueLeft, x0, y0, x1, yk);\n partition(k, j, valueRight, x0, yk, x1, y1);\n } else {\n var xk = (x0 * valueRight + x1 * valueLeft) / value;\n partition(i, k, valueLeft, x0, y0, xk, y1);\n partition(k, j, valueRight, xk, y0, x1, y1);\n }\n }\n};\n\nvar sliceDice = function(parent, x0, y0, x1, y1) {\n (parent.depth & 1 ? treemapSlice : treemapDice)(parent, x0, y0, x1, y1);\n};\n\nvar resquarify = ((function custom(ratio) {\n\n function resquarify(parent, x0, y0, x1, y1) {\n if ((rows = parent._squarify) && (rows.ratio === ratio)) {\n var rows,\n row,\n nodes,\n i,\n j = -1,\n n,\n m = rows.length,\n value = parent.value;\n\n while (++j < m) {\n row = rows[j], nodes = row.children;\n for (i = row.value = 0, n = nodes.length; i < n; ++i) row.value += nodes[i].value;\n if (row.dice) treemapDice(row, x0, y0, x1, y0 += (y1 - y0) * row.value / value);\n else treemapSlice(row, x0, y0, x0 += (x1 - x0) * row.value / value, y1);\n value -= row.value;\n }\n } else {\n parent._squarify = rows = squarifyRatio(ratio, parent, x0, y0, x1, y1);\n rows.ratio = ratio;\n }\n }\n\n resquarify.ratio = function(x) {\n return custom((x = +x) > 1 ? x : 1);\n };\n\n return resquarify;\n}))(phi);\n\nvar area$1 = function(polygon) {\n var i = -1,\n n = polygon.length,\n a,\n b = polygon[n - 1],\n area = 0;\n\n while (++i < n) {\n a = b;\n b = polygon[i];\n area += a[1] * b[0] - a[0] * b[1];\n }\n\n return area / 2;\n};\n\nvar centroid$1 = function(polygon) {\n var i = -1,\n n = polygon.length,\n x = 0,\n y = 0,\n a,\n b = polygon[n - 1],\n c,\n k = 0;\n\n while (++i < n) {\n a = b;\n b = polygon[i];\n k += c = a[0] * b[1] - b[0] * a[1];\n x += (a[0] + b[0]) * c;\n y += (a[1] + b[1]) * c;\n }\n\n return k *= 3, [x / k, y / k];\n};\n\n// Returns the 2D cross product of AB and AC vectors, i.e., the z-component of\n// the 3D cross product in a quadrant I Cartesian coordinate system (+x is\n// right, +y is up). Returns a positive value if ABC is counter-clockwise,\n// negative if clockwise, and zero if the points are collinear.\nvar cross = function(a, b, c) {\n return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);\n};\n\nfunction lexicographicOrder(a, b) {\n return a[0] - b[0] || a[1] - b[1];\n}\n\n// Computes the upper convex hull per the monotone chain algorithm.\n// Assumes points.length >= 3, is sorted by x, unique in y.\n// Returns an array of indices into points in left-to-right order.\nfunction computeUpperHullIndexes(points) {\n var n = points.length,\n indexes = [0, 1],\n size = 2;\n\n for (var i = 2; i < n; ++i) {\n while (size > 1 && cross(points[indexes[size - 2]], points[indexes[size - 1]], points[i]) <= 0) --size;\n indexes[size++] = i;\n }\n\n return indexes.slice(0, size); // remove popped points\n}\n\nvar hull = function(points) {\n if ((n = points.length) < 3) return null;\n\n var i,\n n,\n sortedPoints = new Array(n),\n flippedPoints = new Array(n);\n\n for (i = 0; i < n; ++i) sortedPoints[i] = [+points[i][0], +points[i][1], i];\n sortedPoints.sort(lexicographicOrder);\n for (i = 0; i < n; ++i) flippedPoints[i] = [sortedPoints[i][0], -sortedPoints[i][1]];\n\n var upperIndexes = computeUpperHullIndexes(sortedPoints),\n lowerIndexes = computeUpperHullIndexes(flippedPoints);\n\n // Construct the hull polygon, removing possible duplicate endpoints.\n var skipLeft = lowerIndexes[0] === upperIndexes[0],\n skipRight = lowerIndexes[lowerIndexes.length - 1] === upperIndexes[upperIndexes.length - 1],\n hull = [];\n\n // Add upper hull in right-to-l order.\n // Then add lower hull in left-to-right order.\n for (i = upperIndexes.length - 1; i >= 0; --i) hull.push(points[sortedPoints[upperIndexes[i]][2]]);\n for (i = +skipLeft; i < lowerIndexes.length - skipRight; ++i) hull.push(points[sortedPoints[lowerIndexes[i]][2]]);\n\n return hull;\n};\n\nvar contains = function(polygon, point) {\n var n = polygon.length,\n p = polygon[n - 1],\n x = point[0], y = point[1],\n x0 = p[0], y0 = p[1],\n x1, y1,\n inside = false;\n\n for (var i = 0; i < n; ++i) {\n p = polygon[i], x1 = p[0], y1 = p[1];\n if (((y1 > y) !== (y0 > y)) && (x < (x0 - x1) * (y - y1) / (y0 - y1) + x1)) inside = !inside;\n x0 = x1, y0 = y1;\n }\n\n return inside;\n};\n\nvar length$2 = function(polygon) {\n var i = -1,\n n = polygon.length,\n b = polygon[n - 1],\n xa,\n ya,\n xb = b[0],\n yb = b[1],\n perimeter = 0;\n\n while (++i < n) {\n xa = xb;\n ya = yb;\n b = polygon[i];\n xb = b[0];\n yb = b[1];\n xa -= xb;\n ya -= yb;\n perimeter += Math.sqrt(xa * xa + ya * ya);\n }\n\n return perimeter;\n};\n\nvar slice$3 = [].slice;\n\nvar noabort = {};\n\nfunction Queue(size) {\n if (!(size >= 1)) throw new Error;\n this._size = size;\n this._call =\n this._error = null;\n this._tasks = [];\n this._data = [];\n this._waiting =\n this._active =\n this._ended =\n this._start = 0; // inside a synchronous task callback?\n}\n\nQueue.prototype = queue.prototype = {\n constructor: Queue,\n defer: function(callback) {\n if (typeof callback !== \"function\" || this._call) throw new Error;\n if (this._error != null) return this;\n var t = slice$3.call(arguments, 1);\n t.push(callback);\n ++this._waiting, this._tasks.push(t);\n poke$1(this);\n return this;\n },\n abort: function() {\n if (this._error == null) abort(this, new Error(\"abort\"));\n return this;\n },\n await: function(callback) {\n if (typeof callback !== \"function\" || this._call) throw new Error;\n this._call = function(error, results) { callback.apply(null, [error].concat(results)); };\n maybeNotify(this);\n return this;\n },\n awaitAll: function(callback) {\n if (typeof callback !== \"function\" || this._call) throw new Error;\n this._call = callback;\n maybeNotify(this);\n return this;\n }\n};\n\nfunction poke$1(q) {\n if (!q._start) {\n try { start$1(q); } // let the current task complete\n catch (e) {\n if (q._tasks[q._ended + q._active - 1]) abort(q, e); // task errored synchronously\n else if (!q._data) throw e; // await callback errored synchronously\n }\n }\n}\n\nfunction start$1(q) {\n while (q._start = q._waiting && q._active < q._size) {\n var i = q._ended + q._active,\n t = q._tasks[i],\n j = t.length - 1,\n c = t[j];\n t[j] = end(q, i);\n --q._waiting, ++q._active;\n t = c.apply(null, t);\n if (!q._tasks[i]) continue; // task finished synchronously\n q._tasks[i] = t || noabort;\n }\n}\n\nfunction end(q, i) {\n return function(e, r) {\n if (!q._tasks[i]) return; // ignore multiple callbacks\n --q._active, ++q._ended;\n q._tasks[i] = null;\n if (q._error != null) return; // ignore secondary errors\n if (e != null) {\n abort(q, e);\n } else {\n q._data[i] = r;\n if (q._waiting) poke$1(q);\n else maybeNotify(q);\n }\n };\n}\n\nfunction abort(q, e) {\n var i = q._tasks.length, t;\n q._error = e; // ignore active callbacks\n q._data = undefined; // allow gc\n q._waiting = NaN; // prevent starting\n\n while (--i >= 0) {\n if (t = q._tasks[i]) {\n q._tasks[i] = null;\n if (t.abort) {\n try { t.abort(); }\n catch (e) { /* ignore */ }\n }\n }\n }\n\n q._active = NaN; // allow notification\n maybeNotify(q);\n}\n\nfunction maybeNotify(q) {\n if (!q._active && q._call) {\n var d = q._data;\n q._data = undefined; // allow gc\n q._call(q._error, d);\n }\n}\n\nfunction queue(concurrency) {\n return new Queue(arguments.length ? +concurrency : Infinity);\n}\n\nvar uniform = function(min, max) {\n min = min == null ? 0 : +min;\n max = max == null ? 1 : +max;\n if (arguments.length === 1) max = min, min = 0;\n else max -= min;\n return function() {\n return Math.random() * max + min;\n };\n};\n\nvar normal = function(mu, sigma) {\n var x, r;\n mu = mu == null ? 0 : +mu;\n sigma = sigma == null ? 1 : +sigma;\n return function() {\n var y;\n\n // If available, use the second previously-generated uniform random.\n if (x != null) y = x, x = null;\n\n // Otherwise, generate a new x and y.\n else do {\n x = Math.random() * 2 - 1;\n y = Math.random() * 2 - 1;\n r = x * x + y * y;\n } while (!r || r > 1);\n\n return mu + sigma * y * Math.sqrt(-2 * Math.log(r) / r);\n };\n};\n\nvar logNormal = function() {\n var randomNormal = normal.apply(this, arguments);\n return function() {\n return Math.exp(randomNormal());\n };\n};\n\nvar irwinHall = function(n) {\n return function() {\n for (var sum = 0, i = 0; i < n; ++i) sum += Math.random();\n return sum;\n };\n};\n\nvar bates = function(n) {\n var randomIrwinHall = irwinHall(n);\n return function() {\n return randomIrwinHall() / n;\n };\n};\n\nvar exponential$1 = function(lambda) {\n return function() {\n return -Math.log(1 - Math.random()) / lambda;\n };\n};\n\nvar request = function(url, callback) {\n var request,\n event = dispatch(\"beforesend\", \"progress\", \"load\", \"error\"),\n mimeType,\n headers = map$1(),\n xhr = new XMLHttpRequest,\n user = null,\n password = null,\n response,\n responseType,\n timeout = 0;\n\n // If IE does not support CORS, use XDomainRequest.\n if (typeof XDomainRequest !== \"undefined\"\n && !(\"withCredentials\" in xhr)\n && /^(http(s)?:)?\\/\\//.test(url)) xhr = new XDomainRequest;\n\n \"onload\" in xhr\n ? xhr.onload = xhr.onerror = xhr.ontimeout = respond\n : xhr.onreadystatechange = function(o) { xhr.readyState > 3 && respond(o); };\n\n function respond(o) {\n var status = xhr.status, result;\n if (!status && hasResponse(xhr)\n || status >= 200 && status < 300\n || status === 304) {\n if (response) {\n try {\n result = response.call(request, xhr);\n } catch (e) {\n event.call(\"error\", request, e);\n return;\n }\n } else {\n result = xhr;\n }\n event.call(\"load\", request, result);\n } else {\n event.call(\"error\", request, o);\n }\n }\n\n xhr.onprogress = function(e) {\n event.call(\"progress\", request, e);\n };\n\n request = {\n header: function(name, value) {\n name = (name + \"\").toLowerCase();\n if (arguments.length < 2) return headers.get(name);\n if (value == null) headers.remove(name);\n else headers.set(name, value + \"\");\n return request;\n },\n\n // If mimeType is non-null and no Accept header is set, a default is used.\n mimeType: function(value) {\n if (!arguments.length) return mimeType;\n mimeType = value == null ? null : value + \"\";\n return request;\n },\n\n // Specifies what type the response value should take;\n // for instance, arraybuffer, blob, document, or text.\n responseType: function(value) {\n if (!arguments.length) return responseType;\n responseType = value;\n return request;\n },\n\n timeout: function(value) {\n if (!arguments.length) return timeout;\n timeout = +value;\n return request;\n },\n\n user: function(value) {\n return arguments.length < 1 ? user : (user = value == null ? null : value + \"\", request);\n },\n\n password: function(value) {\n return arguments.length < 1 ? password : (password = value == null ? null : value + \"\", request);\n },\n\n // Specify how to convert the response content to a specific type;\n // changes the callback value on \"load\" events.\n response: function(value) {\n response = value;\n return request;\n },\n\n // Alias for send(\"GET\", …).\n get: function(data, callback) {\n return request.send(\"GET\", data, callback);\n },\n\n // Alias for send(\"POST\", …).\n post: function(data, callback) {\n return request.send(\"POST\", data, callback);\n },\n\n // If callback is non-null, it will be used for error and load events.\n send: function(method, data, callback) {\n xhr.open(method, url, true, user, password);\n if (mimeType != null && !headers.has(\"accept\")) headers.set(\"accept\", mimeType + \",*/*\");\n if (xhr.setRequestHeader) headers.each(function(value, name) { xhr.setRequestHeader(name, value); });\n if (mimeType != null && xhr.overrideMimeType) xhr.overrideMimeType(mimeType);\n if (responseType != null) xhr.responseType = responseType;\n if (timeout > 0) xhr.timeout = timeout;\n if (callback == null && typeof data === \"function\") callback = data, data = null;\n if (callback != null && callback.length === 1) callback = fixCallback(callback);\n if (callback != null) request.on(\"error\", callback).on(\"load\", function(xhr) { callback(null, xhr); });\n event.call(\"beforesend\", request, xhr);\n xhr.send(data == null ? null : data);\n return request;\n },\n\n abort: function() {\n xhr.abort();\n return request;\n },\n\n on: function() {\n var value = event.on.apply(event, arguments);\n return value === event ? request : value;\n }\n };\n\n if (callback != null) {\n if (typeof callback !== \"function\") throw new Error(\"invalid callback: \" + callback);\n return request.get(callback);\n }\n\n return request;\n};\n\nfunction fixCallback(callback) {\n return function(error, xhr) {\n callback(error == null ? xhr : null);\n };\n}\n\nfunction hasResponse(xhr) {\n var type = xhr.responseType;\n return type && type !== \"text\"\n ? xhr.response // null on error\n : xhr.responseText; // \"\" on error\n}\n\nvar type$1 = function(defaultMimeType, response) {\n return function(url, callback) {\n var r = request(url).mimeType(defaultMimeType).response(response);\n if (callback != null) {\n if (typeof callback !== \"function\") throw new Error(\"invalid callback: \" + callback);\n return r.get(callback);\n }\n return r;\n };\n};\n\nvar html = type$1(\"text/html\", function(xhr) {\n return document.createRange().createContextualFragment(xhr.responseText);\n});\n\nvar json = type$1(\"application/json\", function(xhr) {\n return JSON.parse(xhr.responseText);\n});\n\nvar text = type$1(\"text/plain\", function(xhr) {\n return xhr.responseText;\n});\n\nvar xml = type$1(\"application/xml\", function(xhr) {\n var xml = xhr.responseXML;\n if (!xml) throw new Error(\"parse error\");\n return xml;\n});\n\nvar dsv$1 = function(defaultMimeType, parse) {\n return function(url, row, callback) {\n if (arguments.length < 3) callback = row, row = null;\n var r = request(url).mimeType(defaultMimeType);\n r.row = function(_) { return arguments.length ? r.response(responseOf(parse, row = _)) : row; };\n r.row(row);\n return callback ? r.get(callback) : r;\n };\n};\n\nfunction responseOf(parse, row) {\n return function(request$$1) {\n return parse(request$$1.responseText, row);\n };\n}\n\nvar csv$1 = dsv$1(\"text/csv\", csvParse);\n\nvar tsv$1 = dsv$1(\"text/tab-separated-values\", tsvParse);\n\nvar array$2 = Array.prototype;\n\nvar map$3 = array$2.map;\nvar slice$4 = array$2.slice;\n\nvar implicit = {name: \"implicit\"};\n\nfunction ordinal(range) {\n var index = map$1(),\n domain = [],\n unknown = implicit;\n\n range = range == null ? [] : slice$4.call(range);\n\n function scale(d) {\n var key = d + \"\", i = index.get(key);\n if (!i) {\n if (unknown !== implicit) return unknown;\n index.set(key, i = domain.push(d));\n }\n return range[(i - 1) % range.length];\n }\n\n scale.domain = function(_) {\n if (!arguments.length) return domain.slice();\n domain = [], index = map$1();\n var i = -1, n = _.length, d, key;\n while (++i < n) if (!index.has(key = (d = _[i]) + \"\")) index.set(key, domain.push(d));\n return scale;\n };\n\n scale.range = function(_) {\n return arguments.length ? (range = slice$4.call(_), scale) : range.slice();\n };\n\n scale.unknown = function(_) {\n return arguments.length ? (unknown = _, scale) : unknown;\n };\n\n scale.copy = function() {\n return ordinal()\n .domain(domain)\n .range(range)\n .unknown(unknown);\n };\n\n return scale;\n}\n\nfunction band() {\n var scale = ordinal().unknown(undefined),\n domain = scale.domain,\n ordinalRange = scale.range,\n range$$1 = [0, 1],\n step,\n bandwidth,\n round = false,\n paddingInner = 0,\n paddingOuter = 0,\n align = 0.5;\n\n delete scale.unknown;\n\n function rescale() {\n var n = domain().length,\n reverse = range$$1[1] < range$$1[0],\n start = range$$1[reverse - 0],\n stop = range$$1[1 - reverse];\n step = (stop - start) / Math.max(1, n - paddingInner + paddingOuter * 2);\n if (round) step = Math.floor(step);\n start += (stop - start - step * (n - paddingInner)) * align;\n bandwidth = step * (1 - paddingInner);\n if (round) start = Math.round(start), bandwidth = Math.round(bandwidth);\n var values = sequence(n).map(function(i) { return start + step * i; });\n return ordinalRange(reverse ? values.reverse() : values);\n }\n\n scale.domain = function(_) {\n return arguments.length ? (domain(_), rescale()) : domain();\n };\n\n scale.range = function(_) {\n return arguments.length ? (range$$1 = [+_[0], +_[1]], rescale()) : range$$1.slice();\n };\n\n scale.rangeRound = function(_) {\n return range$$1 = [+_[0], +_[1]], round = true, rescale();\n };\n\n scale.bandwidth = function() {\n return bandwidth;\n };\n\n scale.step = function() {\n return step;\n };\n\n scale.round = function(_) {\n return arguments.length ? (round = !!_, rescale()) : round;\n };\n\n scale.padding = function(_) {\n return arguments.length ? (paddingInner = paddingOuter = Math.max(0, Math.min(1, _)), rescale()) : paddingInner;\n };\n\n scale.paddingInner = function(_) {\n return arguments.length ? (paddingInner = Math.max(0, Math.min(1, _)), rescale()) : paddingInner;\n };\n\n scale.paddingOuter = function(_) {\n return arguments.length ? (paddingOuter = Math.max(0, Math.min(1, _)), rescale()) : paddingOuter;\n };\n\n scale.align = function(_) {\n return arguments.length ? (align = Math.max(0, Math.min(1, _)), rescale()) : align;\n };\n\n scale.copy = function() {\n return band()\n .domain(domain())\n .range(range$$1)\n .round(round)\n .paddingInner(paddingInner)\n .paddingOuter(paddingOuter)\n .align(align);\n };\n\n return rescale();\n}\n\nfunction pointish(scale) {\n var copy = scale.copy;\n\n scale.padding = scale.paddingOuter;\n delete scale.paddingInner;\n delete scale.paddingOuter;\n\n scale.copy = function() {\n return pointish(copy());\n };\n\n return scale;\n}\n\nfunction point$1() {\n return pointish(band().paddingInner(1));\n}\n\nvar constant$9 = function(x) {\n return function() {\n return x;\n };\n};\n\nvar number$1 = function(x) {\n return +x;\n};\n\nvar unit = [0, 1];\n\nfunction deinterpolateLinear(a, b) {\n return (b -= (a = +a))\n ? function(x) { return (x - a) / b; }\n : constant$9(b);\n}\n\nfunction deinterpolateClamp(deinterpolate) {\n return function(a, b) {\n var d = deinterpolate(a = +a, b = +b);\n return function(x) { return x <= a ? 0 : x >= b ? 1 : d(x); };\n };\n}\n\nfunction reinterpolateClamp(reinterpolate) {\n return function(a, b) {\n var r = reinterpolate(a = +a, b = +b);\n return function(t) { return t <= 0 ? a : t >= 1 ? b : r(t); };\n };\n}\n\nfunction bimap(domain, range$$1, deinterpolate, reinterpolate) {\n var d0 = domain[0], d1 = domain[1], r0 = range$$1[0], r1 = range$$1[1];\n if (d1 < d0) d0 = deinterpolate(d1, d0), r0 = reinterpolate(r1, r0);\n else d0 = deinterpolate(d0, d1), r0 = reinterpolate(r0, r1);\n return function(x) { return r0(d0(x)); };\n}\n\nfunction polymap(domain, range$$1, deinterpolate, reinterpolate) {\n var j = Math.min(domain.length, range$$1.length) - 1,\n d = new Array(j),\n r = new Array(j),\n i = -1;\n\n // Reverse descending domains.\n if (domain[j] < domain[0]) {\n domain = domain.slice().reverse();\n range$$1 = range$$1.slice().reverse();\n }\n\n while (++i < j) {\n d[i] = deinterpolate(domain[i], domain[i + 1]);\n r[i] = reinterpolate(range$$1[i], range$$1[i + 1]);\n }\n\n return function(x) {\n var i = bisectRight(domain, x, 1, j) - 1;\n return r[i](d[i](x));\n };\n}\n\nfunction copy(source, target) {\n return target\n .domain(source.domain())\n .range(source.range())\n .interpolate(source.interpolate())\n .clamp(source.clamp());\n}\n\n// deinterpolate(a, b)(x) takes a domain value x in [a,b] and returns the corresponding parameter t in [0,1].\n// reinterpolate(a, b)(t) takes a parameter t in [0,1] and returns the corresponding domain value x in [a,b].\nfunction continuous(deinterpolate, reinterpolate) {\n var domain = unit,\n range$$1 = unit,\n interpolate$$1 = interpolateValue,\n clamp = false,\n piecewise,\n output,\n input;\n\n function rescale() {\n piecewise = Math.min(domain.length, range$$1.length) > 2 ? polymap : bimap;\n output = input = null;\n return scale;\n }\n\n function scale(x) {\n return (output || (output = piecewise(domain, range$$1, clamp ? deinterpolateClamp(deinterpolate) : deinterpolate, interpolate$$1)))(+x);\n }\n\n scale.invert = function(y) {\n return (input || (input = piecewise(range$$1, domain, deinterpolateLinear, clamp ? reinterpolateClamp(reinterpolate) : reinterpolate)))(+y);\n };\n\n scale.domain = function(_) {\n return arguments.length ? (domain = map$3.call(_, number$1), rescale()) : domain.slice();\n };\n\n scale.range = function(_) {\n return arguments.length ? (range$$1 = slice$4.call(_), rescale()) : range$$1.slice();\n };\n\n scale.rangeRound = function(_) {\n return range$$1 = slice$4.call(_), interpolate$$1 = interpolateRound, rescale();\n };\n\n scale.clamp = function(_) {\n return arguments.length ? (clamp = !!_, rescale()) : clamp;\n };\n\n scale.interpolate = function(_) {\n return arguments.length ? (interpolate$$1 = _, rescale()) : interpolate$$1;\n };\n\n return rescale();\n}\n\nvar tickFormat = function(domain, count, specifier) {\n var start = domain[0],\n stop = domain[domain.length - 1],\n step = tickStep(start, stop, count == null ? 10 : count),\n precision;\n specifier = formatSpecifier(specifier == null ? \",f\" : specifier);\n switch (specifier.type) {\n case \"s\": {\n var value = Math.max(Math.abs(start), Math.abs(stop));\n if (specifier.precision == null && !isNaN(precision = precisionPrefix(step, value))) specifier.precision = precision;\n return exports.formatPrefix(specifier, value);\n }\n case \"\":\n case \"e\":\n case \"g\":\n case \"p\":\n case \"r\": {\n if (specifier.precision == null && !isNaN(precision = precisionRound(step, Math.max(Math.abs(start), Math.abs(stop))))) specifier.precision = precision - (specifier.type === \"e\");\n break;\n }\n case \"f\":\n case \"%\": {\n if (specifier.precision == null && !isNaN(precision = precisionFixed(step))) specifier.precision = precision - (specifier.type === \"%\") * 2;\n break;\n }\n }\n return exports.format(specifier);\n};\n\nfunction linearish(scale) {\n var domain = scale.domain;\n\n scale.ticks = function(count) {\n var d = domain();\n return ticks(d[0], d[d.length - 1], count == null ? 10 : count);\n };\n\n scale.tickFormat = function(count, specifier) {\n return tickFormat(domain(), count, specifier);\n };\n\n scale.nice = function(count) {\n var d = domain(),\n i = d.length - 1,\n n = count == null ? 10 : count,\n start = d[0],\n stop = d[i],\n step = tickStep(start, stop, n);\n\n if (step) {\n step = tickStep(Math.floor(start / step) * step, Math.ceil(stop / step) * step, n);\n d[0] = Math.floor(start / step) * step;\n d[i] = Math.ceil(stop / step) * step;\n domain(d);\n }\n\n return scale;\n };\n\n return scale;\n}\n\nfunction linear$2() {\n var scale = continuous(deinterpolateLinear, reinterpolate);\n\n scale.copy = function() {\n return copy(scale, linear$2());\n };\n\n return linearish(scale);\n}\n\nfunction identity$6() {\n var domain = [0, 1];\n\n function scale(x) {\n return +x;\n }\n\n scale.invert = scale;\n\n scale.domain = scale.range = function(_) {\n return arguments.length ? (domain = map$3.call(_, number$1), scale) : domain.slice();\n };\n\n scale.copy = function() {\n return identity$6().domain(domain);\n };\n\n return linearish(scale);\n}\n\nvar nice = function(domain, interval) {\n domain = domain.slice();\n\n var i0 = 0,\n i1 = domain.length - 1,\n x0 = domain[i0],\n x1 = domain[i1],\n t;\n\n if (x1 < x0) {\n t = i0, i0 = i1, i1 = t;\n t = x0, x0 = x1, x1 = t;\n }\n\n domain[i0] = interval.floor(x0);\n domain[i1] = interval.ceil(x1);\n return domain;\n};\n\nfunction deinterpolate(a, b) {\n return (b = Math.log(b / a))\n ? function(x) { return Math.log(x / a) / b; }\n : constant$9(b);\n}\n\nfunction reinterpolate$1(a, b) {\n return a < 0\n ? function(t) { return -Math.pow(-b, t) * Math.pow(-a, 1 - t); }\n : function(t) { return Math.pow(b, t) * Math.pow(a, 1 - t); };\n}\n\nfunction pow10(x) {\n return isFinite(x) ? +(\"1e\" + x) : x < 0 ? 0 : x;\n}\n\nfunction powp(base) {\n return base === 10 ? pow10\n : base === Math.E ? Math.exp\n : function(x) { return Math.pow(base, x); };\n}\n\nfunction logp(base) {\n return base === Math.E ? Math.log\n : base === 10 && Math.log10\n || base === 2 && Math.log2\n || (base = Math.log(base), function(x) { return Math.log(x) / base; });\n}\n\nfunction reflect(f) {\n return function(x) {\n return -f(-x);\n };\n}\n\nfunction log$1() {\n var scale = continuous(deinterpolate, reinterpolate$1).domain([1, 10]),\n domain = scale.domain,\n base = 10,\n logs = logp(10),\n pows = powp(10);\n\n function rescale() {\n logs = logp(base), pows = powp(base);\n if (domain()[0] < 0) logs = reflect(logs), pows = reflect(pows);\n return scale;\n }\n\n scale.base = function(_) {\n return arguments.length ? (base = +_, rescale()) : base;\n };\n\n scale.domain = function(_) {\n return arguments.length ? (domain(_), rescale()) : domain();\n };\n\n scale.ticks = function(count) {\n var d = domain(),\n u = d[0],\n v = d[d.length - 1],\n r;\n\n if (r = v < u) i = u, u = v, v = i;\n\n var i = logs(u),\n j = logs(v),\n p,\n k,\n t,\n n = count == null ? 10 : +count,\n z = [];\n\n if (!(base % 1) && j - i < n) {\n i = Math.round(i) - 1, j = Math.round(j) + 1;\n if (u > 0) for (; i < j; ++i) {\n for (k = 1, p = pows(i); k < base; ++k) {\n t = p * k;\n if (t < u) continue;\n if (t > v) break;\n z.push(t);\n }\n } else for (; i < j; ++i) {\n for (k = base - 1, p = pows(i); k >= 1; --k) {\n t = p * k;\n if (t < u) continue;\n if (t > v) break;\n z.push(t);\n }\n }\n } else {\n z = ticks(i, j, Math.min(j - i, n)).map(pows);\n }\n\n return r ? z.reverse() : z;\n };\n\n scale.tickFormat = function(count, specifier) {\n if (specifier == null) specifier = base === 10 ? \".0e\" : \",\";\n if (typeof specifier !== \"function\") specifier = exports.format(specifier);\n if (count === Infinity) return specifier;\n if (count == null) count = 10;\n var k = Math.max(1, base * count / scale.ticks().length); // TODO fast estimate?\n return function(d) {\n var i = d / pows(Math.round(logs(d)));\n if (i * base < base - 0.5) i *= base;\n return i <= k ? specifier(d) : \"\";\n };\n };\n\n scale.nice = function() {\n return domain(nice(domain(), {\n floor: function(x) { return pows(Math.floor(logs(x))); },\n ceil: function(x) { return pows(Math.ceil(logs(x))); }\n }));\n };\n\n scale.copy = function() {\n return copy(scale, log$1().base(base));\n };\n\n return scale;\n}\n\nfunction raise$1(x, exponent) {\n return x < 0 ? -Math.pow(-x, exponent) : Math.pow(x, exponent);\n}\n\nfunction pow$1() {\n var exponent = 1,\n scale = continuous(deinterpolate, reinterpolate),\n domain = scale.domain;\n\n function deinterpolate(a, b) {\n return (b = raise$1(b, exponent) - (a = raise$1(a, exponent)))\n ? function(x) { return (raise$1(x, exponent) - a) / b; }\n : constant$9(b);\n }\n\n function reinterpolate(a, b) {\n b = raise$1(b, exponent) - (a = raise$1(a, exponent));\n return function(t) { return raise$1(a + b * t, 1 / exponent); };\n }\n\n scale.exponent = function(_) {\n return arguments.length ? (exponent = +_, domain(domain())) : exponent;\n };\n\n scale.copy = function() {\n return copy(scale, pow$1().exponent(exponent));\n };\n\n return linearish(scale);\n}\n\nfunction sqrt$1() {\n return pow$1().exponent(0.5);\n}\n\nfunction quantile$$1() {\n var domain = [],\n range$$1 = [],\n thresholds = [];\n\n function rescale() {\n var i = 0, n = Math.max(1, range$$1.length);\n thresholds = new Array(n - 1);\n while (++i < n) thresholds[i - 1] = threshold(domain, i / n);\n return scale;\n }\n\n function scale(x) {\n if (!isNaN(x = +x)) return range$$1[bisectRight(thresholds, x)];\n }\n\n scale.invertExtent = function(y) {\n var i = range$$1.indexOf(y);\n return i < 0 ? [NaN, NaN] : [\n i > 0 ? thresholds[i - 1] : domain[0],\n i < thresholds.length ? thresholds[i] : domain[domain.length - 1]\n ];\n };\n\n scale.domain = function(_) {\n if (!arguments.length) return domain.slice();\n domain = [];\n for (var i = 0, n = _.length, d; i < n; ++i) if (d = _[i], d != null && !isNaN(d = +d)) domain.push(d);\n domain.sort(ascending);\n return rescale();\n };\n\n scale.range = function(_) {\n return arguments.length ? (range$$1 = slice$4.call(_), rescale()) : range$$1.slice();\n };\n\n scale.quantiles = function() {\n return thresholds.slice();\n };\n\n scale.copy = function() {\n return quantile$$1()\n .domain(domain)\n .range(range$$1);\n };\n\n return scale;\n}\n\nfunction quantize$1() {\n var x0 = 0,\n x1 = 1,\n n = 1,\n domain = [0.5],\n range$$1 = [0, 1];\n\n function scale(x) {\n if (x <= x) return range$$1[bisectRight(domain, x, 0, n)];\n }\n\n function rescale() {\n var i = -1;\n domain = new Array(n);\n while (++i < n) domain[i] = ((i + 1) * x1 - (i - n) * x0) / (n + 1);\n return scale;\n }\n\n scale.domain = function(_) {\n return arguments.length ? (x0 = +_[0], x1 = +_[1], rescale()) : [x0, x1];\n };\n\n scale.range = function(_) {\n return arguments.length ? (n = (range$$1 = slice$4.call(_)).length - 1, rescale()) : range$$1.slice();\n };\n\n scale.invertExtent = function(y) {\n var i = range$$1.indexOf(y);\n return i < 0 ? [NaN, NaN]\n : i < 1 ? [x0, domain[0]]\n : i >= n ? [domain[n - 1], x1]\n : [domain[i - 1], domain[i]];\n };\n\n scale.copy = function() {\n return quantize$1()\n .domain([x0, x1])\n .range(range$$1);\n };\n\n return linearish(scale);\n}\n\nfunction threshold$1() {\n var domain = [0.5],\n range$$1 = [0, 1],\n n = 1;\n\n function scale(x) {\n if (x <= x) return range$$1[bisectRight(domain, x, 0, n)];\n }\n\n scale.domain = function(_) {\n return arguments.length ? (domain = slice$4.call(_), n = Math.min(domain.length, range$$1.length - 1), scale) : domain.slice();\n };\n\n scale.range = function(_) {\n return arguments.length ? (range$$1 = slice$4.call(_), n = Math.min(domain.length, range$$1.length - 1), scale) : range$$1.slice();\n };\n\n scale.invertExtent = function(y) {\n var i = range$$1.indexOf(y);\n return [domain[i - 1], domain[i]];\n };\n\n scale.copy = function() {\n return threshold$1()\n .domain(domain)\n .range(range$$1);\n };\n\n return scale;\n}\n\nvar t0$1 = new Date;\nvar t1$1 = new Date;\n\nfunction newInterval(floori, offseti, count, field) {\n\n function interval(date) {\n return floori(date = new Date(+date)), date;\n }\n\n interval.floor = interval;\n\n interval.ceil = function(date) {\n return floori(date = new Date(date - 1)), offseti(date, 1), floori(date), date;\n };\n\n interval.round = function(date) {\n var d0 = interval(date),\n d1 = interval.ceil(date);\n return date - d0 < d1 - date ? d0 : d1;\n };\n\n interval.offset = function(date, step) {\n return offseti(date = new Date(+date), step == null ? 1 : Math.floor(step)), date;\n };\n\n interval.range = function(start, stop, step) {\n var range = [];\n start = interval.ceil(start);\n step = step == null ? 1 : Math.floor(step);\n if (!(start < stop) || !(step > 0)) return range; // also handles Invalid Date\n do range.push(new Date(+start)); while (offseti(start, step), floori(start), start < stop)\n return range;\n };\n\n interval.filter = function(test) {\n return newInterval(function(date) {\n if (date >= date) while (floori(date), !test(date)) date.setTime(date - 1);\n }, function(date, step) {\n if (date >= date) while (--step >= 0) while (offseti(date, 1), !test(date)) {} // eslint-disable-line no-empty\n });\n };\n\n if (count) {\n interval.count = function(start, end) {\n t0$1.setTime(+start), t1$1.setTime(+end);\n floori(t0$1), floori(t1$1);\n return Math.floor(count(t0$1, t1$1));\n };\n\n interval.every = function(step) {\n step = Math.floor(step);\n return !isFinite(step) || !(step > 0) ? null\n : !(step > 1) ? interval\n : interval.filter(field\n ? function(d) { return field(d) % step === 0; }\n : function(d) { return interval.count(0, d) % step === 0; });\n };\n }\n\n return interval;\n}\n\nvar millisecond = newInterval(function() {\n // noop\n}, function(date, step) {\n date.setTime(+date + step);\n}, function(start, end) {\n return end - start;\n});\n\n// An optimized implementation for this simple case.\nmillisecond.every = function(k) {\n k = Math.floor(k);\n if (!isFinite(k) || !(k > 0)) return null;\n if (!(k > 1)) return millisecond;\n return newInterval(function(date) {\n date.setTime(Math.floor(date / k) * k);\n }, function(date, step) {\n date.setTime(+date + step * k);\n }, function(start, end) {\n return (end - start) / k;\n });\n};\n\nvar milliseconds = millisecond.range;\n\nvar durationSecond$1 = 1e3;\nvar durationMinute$1 = 6e4;\nvar durationHour$1 = 36e5;\nvar durationDay$1 = 864e5;\nvar durationWeek$1 = 6048e5;\n\nvar second = newInterval(function(date) {\n date.setTime(Math.floor(date / durationSecond$1) * durationSecond$1);\n}, function(date, step) {\n date.setTime(+date + step * durationSecond$1);\n}, function(start, end) {\n return (end - start) / durationSecond$1;\n}, function(date) {\n return date.getUTCSeconds();\n});\n\nvar seconds = second.range;\n\nvar minute = newInterval(function(date) {\n date.setTime(Math.floor(date / durationMinute$1) * durationMinute$1);\n}, function(date, step) {\n date.setTime(+date + step * durationMinute$1);\n}, function(start, end) {\n return (end - start) / durationMinute$1;\n}, function(date) {\n return date.getMinutes();\n});\n\nvar minutes = minute.range;\n\nvar hour = newInterval(function(date) {\n var offset = date.getTimezoneOffset() * durationMinute$1 % durationHour$1;\n if (offset < 0) offset += durationHour$1;\n date.setTime(Math.floor((+date - offset) / durationHour$1) * durationHour$1 + offset);\n}, function(date, step) {\n date.setTime(+date + step * durationHour$1);\n}, function(start, end) {\n return (end - start) / durationHour$1;\n}, function(date) {\n return date.getHours();\n});\n\nvar hours = hour.range;\n\nvar day = newInterval(function(date) {\n date.setHours(0, 0, 0, 0);\n}, function(date, step) {\n date.setDate(date.getDate() + step);\n}, function(start, end) {\n return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute$1) / durationDay$1;\n}, function(date) {\n return date.getDate() - 1;\n});\n\nvar days = day.range;\n\nfunction weekday(i) {\n return newInterval(function(date) {\n date.setDate(date.getDate() - (date.getDay() + 7 - i) % 7);\n date.setHours(0, 0, 0, 0);\n }, function(date, step) {\n date.setDate(date.getDate() + step * 7);\n }, function(start, end) {\n return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute$1) / durationWeek$1;\n });\n}\n\nvar sunday = weekday(0);\nvar monday = weekday(1);\nvar tuesday = weekday(2);\nvar wednesday = weekday(3);\nvar thursday = weekday(4);\nvar friday = weekday(5);\nvar saturday = weekday(6);\n\nvar sundays = sunday.range;\nvar mondays = monday.range;\nvar tuesdays = tuesday.range;\nvar wednesdays = wednesday.range;\nvar thursdays = thursday.range;\nvar fridays = friday.range;\nvar saturdays = saturday.range;\n\nvar month = newInterval(function(date) {\n date.setDate(1);\n date.setHours(0, 0, 0, 0);\n}, function(date, step) {\n date.setMonth(date.getMonth() + step);\n}, function(start, end) {\n return end.getMonth() - start.getMonth() + (end.getFullYear() - start.getFullYear()) * 12;\n}, function(date) {\n return date.getMonth();\n});\n\nvar months = month.range;\n\nvar year = newInterval(function(date) {\n date.setMonth(0, 1);\n date.setHours(0, 0, 0, 0);\n}, function(date, step) {\n date.setFullYear(date.getFullYear() + step);\n}, function(start, end) {\n return end.getFullYear() - start.getFullYear();\n}, function(date) {\n return date.getFullYear();\n});\n\n// An optimized implementation for this simple case.\nyear.every = function(k) {\n return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : newInterval(function(date) {\n date.setFullYear(Math.floor(date.getFullYear() / k) * k);\n date.setMonth(0, 1);\n date.setHours(0, 0, 0, 0);\n }, function(date, step) {\n date.setFullYear(date.getFullYear() + step * k);\n });\n};\n\nvar years = year.range;\n\nvar utcMinute = newInterval(function(date) {\n date.setUTCSeconds(0, 0);\n}, function(date, step) {\n date.setTime(+date + step * durationMinute$1);\n}, function(start, end) {\n return (end - start) / durationMinute$1;\n}, function(date) {\n return date.getUTCMinutes();\n});\n\nvar utcMinutes = utcMinute.range;\n\nvar utcHour = newInterval(function(date) {\n date.setUTCMinutes(0, 0, 0);\n}, function(date, step) {\n date.setTime(+date + step * durationHour$1);\n}, function(start, end) {\n return (end - start) / durationHour$1;\n}, function(date) {\n return date.getUTCHours();\n});\n\nvar utcHours = utcHour.range;\n\nvar utcDay = newInterval(function(date) {\n date.setUTCHours(0, 0, 0, 0);\n}, function(date, step) {\n date.setUTCDate(date.getUTCDate() + step);\n}, function(start, end) {\n return (end - start) / durationDay$1;\n}, function(date) {\n return date.getUTCDate() - 1;\n});\n\nvar utcDays = utcDay.range;\n\nfunction utcWeekday(i) {\n return newInterval(function(date) {\n date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 7 - i) % 7);\n date.setUTCHours(0, 0, 0, 0);\n }, function(date, step) {\n date.setUTCDate(date.getUTCDate() + step * 7);\n }, function(start, end) {\n return (end - start) / durationWeek$1;\n });\n}\n\nvar utcSunday = utcWeekday(0);\nvar utcMonday = utcWeekday(1);\nvar utcTuesday = utcWeekday(2);\nvar utcWednesday = utcWeekday(3);\nvar utcThursday = utcWeekday(4);\nvar utcFriday = utcWeekday(5);\nvar utcSaturday = utcWeekday(6);\n\nvar utcSundays = utcSunday.range;\nvar utcMondays = utcMonday.range;\nvar utcTuesdays = utcTuesday.range;\nvar utcWednesdays = utcWednesday.range;\nvar utcThursdays = utcThursday.range;\nvar utcFridays = utcFriday.range;\nvar utcSaturdays = utcSaturday.range;\n\nvar utcMonth = newInterval(function(date) {\n date.setUTCDate(1);\n date.setUTCHours(0, 0, 0, 0);\n}, function(date, step) {\n date.setUTCMonth(date.getUTCMonth() + step);\n}, function(start, end) {\n return end.getUTCMonth() - start.getUTCMonth() + (end.getUTCFullYear() - start.getUTCFullYear()) * 12;\n}, function(date) {\n return date.getUTCMonth();\n});\n\nvar utcMonths = utcMonth.range;\n\nvar utcYear = newInterval(function(date) {\n date.setUTCMonth(0, 1);\n date.setUTCHours(0, 0, 0, 0);\n}, function(date, step) {\n date.setUTCFullYear(date.getUTCFullYear() + step);\n}, function(start, end) {\n return end.getUTCFullYear() - start.getUTCFullYear();\n}, function(date) {\n return date.getUTCFullYear();\n});\n\n// An optimized implementation for this simple case.\nutcYear.every = function(k) {\n return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : newInterval(function(date) {\n date.setUTCFullYear(Math.floor(date.getUTCFullYear() / k) * k);\n date.setUTCMonth(0, 1);\n date.setUTCHours(0, 0, 0, 0);\n }, function(date, step) {\n date.setUTCFullYear(date.getUTCFullYear() + step * k);\n });\n};\n\nvar utcYears = utcYear.range;\n\nfunction localDate(d) {\n if (0 <= d.y && d.y < 100) {\n var date = new Date(-1, d.m, d.d, d.H, d.M, d.S, d.L);\n date.setFullYear(d.y);\n return date;\n }\n return new Date(d.y, d.m, d.d, d.H, d.M, d.S, d.L);\n}\n\nfunction utcDate(d) {\n if (0 <= d.y && d.y < 100) {\n var date = new Date(Date.UTC(-1, d.m, d.d, d.H, d.M, d.S, d.L));\n date.setUTCFullYear(d.y);\n return date;\n }\n return new Date(Date.UTC(d.y, d.m, d.d, d.H, d.M, d.S, d.L));\n}\n\nfunction newYear(y) {\n return {y: y, m: 0, d: 1, H: 0, M: 0, S: 0, L: 0};\n}\n\nfunction formatLocale$1(locale) {\n var locale_dateTime = locale.dateTime,\n locale_date = locale.date,\n locale_time = locale.time,\n locale_periods = locale.periods,\n locale_weekdays = locale.days,\n locale_shortWeekdays = locale.shortDays,\n locale_months = locale.months,\n locale_shortMonths = locale.shortMonths;\n\n var periodRe = formatRe(locale_periods),\n periodLookup = formatLookup(locale_periods),\n weekdayRe = formatRe(locale_weekdays),\n weekdayLookup = formatLookup(locale_weekdays),\n shortWeekdayRe = formatRe(locale_shortWeekdays),\n shortWeekdayLookup = formatLookup(locale_shortWeekdays),\n monthRe = formatRe(locale_months),\n monthLookup = formatLookup(locale_months),\n shortMonthRe = formatRe(locale_shortMonths),\n shortMonthLookup = formatLookup(locale_shortMonths);\n\n var formats = {\n \"a\": formatShortWeekday,\n \"A\": formatWeekday,\n \"b\": formatShortMonth,\n \"B\": formatMonth,\n \"c\": null,\n \"d\": formatDayOfMonth,\n \"e\": formatDayOfMonth,\n \"H\": formatHour24,\n \"I\": formatHour12,\n \"j\": formatDayOfYear,\n \"L\": formatMilliseconds,\n \"m\": formatMonthNumber,\n \"M\": formatMinutes,\n \"p\": formatPeriod,\n \"S\": formatSeconds,\n \"U\": formatWeekNumberSunday,\n \"w\": formatWeekdayNumber,\n \"W\": formatWeekNumberMonday,\n \"x\": null,\n \"X\": null,\n \"y\": formatYear,\n \"Y\": formatFullYear,\n \"Z\": formatZone,\n \"%\": formatLiteralPercent\n };\n\n var utcFormats = {\n \"a\": formatUTCShortWeekday,\n \"A\": formatUTCWeekday,\n \"b\": formatUTCShortMonth,\n \"B\": formatUTCMonth,\n \"c\": null,\n \"d\": formatUTCDayOfMonth,\n \"e\": formatUTCDayOfMonth,\n \"H\": formatUTCHour24,\n \"I\": formatUTCHour12,\n \"j\": formatUTCDayOfYear,\n \"L\": formatUTCMilliseconds,\n \"m\": formatUTCMonthNumber,\n \"M\": formatUTCMinutes,\n \"p\": formatUTCPeriod,\n \"S\": formatUTCSeconds,\n \"U\": formatUTCWeekNumberSunday,\n \"w\": formatUTCWeekdayNumber,\n \"W\": formatUTCWeekNumberMonday,\n \"x\": null,\n \"X\": null,\n \"y\": formatUTCYear,\n \"Y\": formatUTCFullYear,\n \"Z\": formatUTCZone,\n \"%\": formatLiteralPercent\n };\n\n var parses = {\n \"a\": parseShortWeekday,\n \"A\": parseWeekday,\n \"b\": parseShortMonth,\n \"B\": parseMonth,\n \"c\": parseLocaleDateTime,\n \"d\": parseDayOfMonth,\n \"e\": parseDayOfMonth,\n \"H\": parseHour24,\n \"I\": parseHour24,\n \"j\": parseDayOfYear,\n \"L\": parseMilliseconds,\n \"m\": parseMonthNumber,\n \"M\": parseMinutes,\n \"p\": parsePeriod,\n \"S\": parseSeconds,\n \"U\": parseWeekNumberSunday,\n \"w\": parseWeekdayNumber,\n \"W\": parseWeekNumberMonday,\n \"x\": parseLocaleDate,\n \"X\": parseLocaleTime,\n \"y\": parseYear,\n \"Y\": parseFullYear,\n \"Z\": parseZone,\n \"%\": parseLiteralPercent\n };\n\n // These recursive directive definitions must be deferred.\n formats.x = newFormat(locale_date, formats);\n formats.X = newFormat(locale_time, formats);\n formats.c = newFormat(locale_dateTime, formats);\n utcFormats.x = newFormat(locale_date, utcFormats);\n utcFormats.X = newFormat(locale_time, utcFormats);\n utcFormats.c = newFormat(locale_dateTime, utcFormats);\n\n function newFormat(specifier, formats) {\n return function(date) {\n var string = [],\n i = -1,\n j = 0,\n n = specifier.length,\n c,\n pad,\n format;\n\n if (!(date instanceof Date)) date = new Date(+date);\n\n while (++i < n) {\n if (specifier.charCodeAt(i) === 37) {\n string.push(specifier.slice(j, i));\n if ((pad = pads[c = specifier.charAt(++i)]) != null) c = specifier.charAt(++i);\n else pad = c === \"e\" ? \" \" : \"0\";\n if (format = formats[c]) c = format(date, pad);\n string.push(c);\n j = i + 1;\n }\n }\n\n string.push(specifier.slice(j, i));\n return string.join(\"\");\n };\n }\n\n function newParse(specifier, newDate) {\n return function(string) {\n var d = newYear(1900),\n i = parseSpecifier(d, specifier, string += \"\", 0);\n if (i != string.length) return null;\n\n // The am-pm flag is 0 for AM, and 1 for PM.\n if (\"p\" in d) d.H = d.H % 12 + d.p * 12;\n\n // Convert day-of-week and week-of-year to day-of-year.\n if (\"W\" in d || \"U\" in d) {\n if (!(\"w\" in d)) d.w = \"W\" in d ? 1 : 0;\n var day$$1 = \"Z\" in d ? utcDate(newYear(d.y)).getUTCDay() : newDate(newYear(d.y)).getDay();\n d.m = 0;\n d.d = \"W\" in d ? (d.w + 6) % 7 + d.W * 7 - (day$$1 + 5) % 7 : d.w + d.U * 7 - (day$$1 + 6) % 7;\n }\n\n // If a time zone is specified, all fields are interpreted as UTC and then\n // offset according to the specified time zone.\n if (\"Z\" in d) {\n d.H += d.Z / 100 | 0;\n d.M += d.Z % 100;\n return utcDate(d);\n }\n\n // Otherwise, all fields are in local time.\n return newDate(d);\n };\n }\n\n function parseSpecifier(d, specifier, string, j) {\n var i = 0,\n n = specifier.length,\n m = string.length,\n c,\n parse;\n\n while (i < n) {\n if (j >= m) return -1;\n c = specifier.charCodeAt(i++);\n if (c === 37) {\n c = specifier.charAt(i++);\n parse = parses[c in pads ? specifier.charAt(i++) : c];\n if (!parse || ((j = parse(d, string, j)) < 0)) return -1;\n } else if (c != string.charCodeAt(j++)) {\n return -1;\n }\n }\n\n return j;\n }\n\n function parsePeriod(d, string, i) {\n var n = periodRe.exec(string.slice(i));\n return n ? (d.p = periodLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n }\n\n function parseShortWeekday(d, string, i) {\n var n = shortWeekdayRe.exec(string.slice(i));\n return n ? (d.w = shortWeekdayLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n }\n\n function parseWeekday(d, string, i) {\n var n = weekdayRe.exec(string.slice(i));\n return n ? (d.w = weekdayLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n }\n\n function parseShortMonth(d, string, i) {\n var n = shortMonthRe.exec(string.slice(i));\n return n ? (d.m = shortMonthLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n }\n\n function parseMonth(d, string, i) {\n var n = monthRe.exec(string.slice(i));\n return n ? (d.m = monthLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n }\n\n function parseLocaleDateTime(d, string, i) {\n return parseSpecifier(d, locale_dateTime, string, i);\n }\n\n function parseLocaleDate(d, string, i) {\n return parseSpecifier(d, locale_date, string, i);\n }\n\n function parseLocaleTime(d, string, i) {\n return parseSpecifier(d, locale_time, string, i);\n }\n\n function formatShortWeekday(d) {\n return locale_shortWeekdays[d.getDay()];\n }\n\n function formatWeekday(d) {\n return locale_weekdays[d.getDay()];\n }\n\n function formatShortMonth(d) {\n return locale_shortMonths[d.getMonth()];\n }\n\n function formatMonth(d) {\n return locale_months[d.getMonth()];\n }\n\n function formatPeriod(d) {\n return locale_periods[+(d.getHours() >= 12)];\n }\n\n function formatUTCShortWeekday(d) {\n return locale_shortWeekdays[d.getUTCDay()];\n }\n\n function formatUTCWeekday(d) {\n return locale_weekdays[d.getUTCDay()];\n }\n\n function formatUTCShortMonth(d) {\n return locale_shortMonths[d.getUTCMonth()];\n }\n\n function formatUTCMonth(d) {\n return locale_months[d.getUTCMonth()];\n }\n\n function formatUTCPeriod(d) {\n return locale_periods[+(d.getUTCHours() >= 12)];\n }\n\n return {\n format: function(specifier) {\n var f = newFormat(specifier += \"\", formats);\n f.toString = function() { return specifier; };\n return f;\n },\n parse: function(specifier) {\n var p = newParse(specifier += \"\", localDate);\n p.toString = function() { return specifier; };\n return p;\n },\n utcFormat: function(specifier) {\n var f = newFormat(specifier += \"\", utcFormats);\n f.toString = function() { return specifier; };\n return f;\n },\n utcParse: function(specifier) {\n var p = newParse(specifier, utcDate);\n p.toString = function() { return specifier; };\n return p;\n }\n };\n}\n\nvar pads = {\"-\": \"\", \"_\": \" \", \"0\": \"0\"};\nvar numberRe = /^\\s*\\d+/;\nvar percentRe = /^%/;\nvar requoteRe = /[\\\\\\^\\$\\*\\+\\?\\|\\[\\]\\(\\)\\.\\{\\}]/g;\n\nfunction pad(value, fill, width) {\n var sign = value < 0 ? \"-\" : \"\",\n string = (sign ? -value : value) + \"\",\n length = string.length;\n return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string);\n}\n\nfunction requote(s) {\n return s.replace(requoteRe, \"\\\\$&\");\n}\n\nfunction formatRe(names) {\n return new RegExp(\"^(?:\" + names.map(requote).join(\"|\") + \")\", \"i\");\n}\n\nfunction formatLookup(names) {\n var map = {}, i = -1, n = names.length;\n while (++i < n) map[names[i].toLowerCase()] = i;\n return map;\n}\n\nfunction parseWeekdayNumber(d, string, i) {\n var n = numberRe.exec(string.slice(i, i + 1));\n return n ? (d.w = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseWeekNumberSunday(d, string, i) {\n var n = numberRe.exec(string.slice(i));\n return n ? (d.U = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseWeekNumberMonday(d, string, i) {\n var n = numberRe.exec(string.slice(i));\n return n ? (d.W = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseFullYear(d, string, i) {\n var n = numberRe.exec(string.slice(i, i + 4));\n return n ? (d.y = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseYear(d, string, i) {\n var n = numberRe.exec(string.slice(i, i + 2));\n return n ? (d.y = +n[0] + (+n[0] > 68 ? 1900 : 2000), i + n[0].length) : -1;\n}\n\nfunction parseZone(d, string, i) {\n var n = /^(Z)|([+-]\\d\\d)(?:\\:?(\\d\\d))?/.exec(string.slice(i, i + 6));\n return n ? (d.Z = n[1] ? 0 : -(n[2] + (n[3] || \"00\")), i + n[0].length) : -1;\n}\n\nfunction parseMonthNumber(d, string, i) {\n var n = numberRe.exec(string.slice(i, i + 2));\n return n ? (d.m = n[0] - 1, i + n[0].length) : -1;\n}\n\nfunction parseDayOfMonth(d, string, i) {\n var n = numberRe.exec(string.slice(i, i + 2));\n return n ? (d.d = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseDayOfYear(d, string, i) {\n var n = numberRe.exec(string.slice(i, i + 3));\n return n ? (d.m = 0, d.d = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseHour24(d, string, i) {\n var n = numberRe.exec(string.slice(i, i + 2));\n return n ? (d.H = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseMinutes(d, string, i) {\n var n = numberRe.exec(string.slice(i, i + 2));\n return n ? (d.M = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseSeconds(d, string, i) {\n var n = numberRe.exec(string.slice(i, i + 2));\n return n ? (d.S = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseMilliseconds(d, string, i) {\n var n = numberRe.exec(string.slice(i, i + 3));\n return n ? (d.L = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseLiteralPercent(d, string, i) {\n var n = percentRe.exec(string.slice(i, i + 1));\n return n ? i + n[0].length : -1;\n}\n\nfunction formatDayOfMonth(d, p) {\n return pad(d.getDate(), p, 2);\n}\n\nfunction formatHour24(d, p) {\n return pad(d.getHours(), p, 2);\n}\n\nfunction formatHour12(d, p) {\n return pad(d.getHours() % 12 || 12, p, 2);\n}\n\nfunction formatDayOfYear(d, p) {\n return pad(1 + day.count(year(d), d), p, 3);\n}\n\nfunction formatMilliseconds(d, p) {\n return pad(d.getMilliseconds(), p, 3);\n}\n\nfunction formatMonthNumber(d, p) {\n return pad(d.getMonth() + 1, p, 2);\n}\n\nfunction formatMinutes(d, p) {\n return pad(d.getMinutes(), p, 2);\n}\n\nfunction formatSeconds(d, p) {\n return pad(d.getSeconds(), p, 2);\n}\n\nfunction formatWeekNumberSunday(d, p) {\n return pad(sunday.count(year(d), d), p, 2);\n}\n\nfunction formatWeekdayNumber(d) {\n return d.getDay();\n}\n\nfunction formatWeekNumberMonday(d, p) {\n return pad(monday.count(year(d), d), p, 2);\n}\n\nfunction formatYear(d, p) {\n return pad(d.getFullYear() % 100, p, 2);\n}\n\nfunction formatFullYear(d, p) {\n return pad(d.getFullYear() % 10000, p, 4);\n}\n\nfunction formatZone(d) {\n var z = d.getTimezoneOffset();\n return (z > 0 ? \"-\" : (z *= -1, \"+\"))\n + pad(z / 60 | 0, \"0\", 2)\n + pad(z % 60, \"0\", 2);\n}\n\nfunction formatUTCDayOfMonth(d, p) {\n return pad(d.getUTCDate(), p, 2);\n}\n\nfunction formatUTCHour24(d, p) {\n return pad(d.getUTCHours(), p, 2);\n}\n\nfunction formatUTCHour12(d, p) {\n return pad(d.getUTCHours() % 12 || 12, p, 2);\n}\n\nfunction formatUTCDayOfYear(d, p) {\n return pad(1 + utcDay.count(utcYear(d), d), p, 3);\n}\n\nfunction formatUTCMilliseconds(d, p) {\n return pad(d.getUTCMilliseconds(), p, 3);\n}\n\nfunction formatUTCMonthNumber(d, p) {\n return pad(d.getUTCMonth() + 1, p, 2);\n}\n\nfunction formatUTCMinutes(d, p) {\n return pad(d.getUTCMinutes(), p, 2);\n}\n\nfunction formatUTCSeconds(d, p) {\n return pad(d.getUTCSeconds(), p, 2);\n}\n\nfunction formatUTCWeekNumberSunday(d, p) {\n return pad(utcSunday.count(utcYear(d), d), p, 2);\n}\n\nfunction formatUTCWeekdayNumber(d) {\n return d.getUTCDay();\n}\n\nfunction formatUTCWeekNumberMonday(d, p) {\n return pad(utcMonday.count(utcYear(d), d), p, 2);\n}\n\nfunction formatUTCYear(d, p) {\n return pad(d.getUTCFullYear() % 100, p, 2);\n}\n\nfunction formatUTCFullYear(d, p) {\n return pad(d.getUTCFullYear() % 10000, p, 4);\n}\n\nfunction formatUTCZone() {\n return \"+0000\";\n}\n\nfunction formatLiteralPercent() {\n return \"%\";\n}\n\nvar locale$2;\n\n\n\n\n\ndefaultLocale$1({\n dateTime: \"%x, %X\",\n date: \"%-m/%-d/%Y\",\n time: \"%-I:%M:%S %p\",\n periods: [\"AM\", \"PM\"],\n days: [\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"],\n shortDays: [\"Sun\", \"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\"],\n months: [\"January\", \"February\", \"March\", \"April\", \"May\", \"June\", \"July\", \"August\", \"September\", \"October\", \"November\", \"December\"],\n shortMonths: [\"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"Jun\", \"Jul\", \"Aug\", \"Sep\", \"Oct\", \"Nov\", \"Dec\"]\n});\n\nfunction defaultLocale$1(definition) {\n locale$2 = formatLocale$1(definition);\n exports.timeFormat = locale$2.format;\n exports.timeParse = locale$2.parse;\n exports.utcFormat = locale$2.utcFormat;\n exports.utcParse = locale$2.utcParse;\n return locale$2;\n}\n\nvar isoSpecifier = \"%Y-%m-%dT%H:%M:%S.%LZ\";\n\nfunction formatIsoNative(date) {\n return date.toISOString();\n}\n\nvar formatIso = Date.prototype.toISOString\n ? formatIsoNative\n : exports.utcFormat(isoSpecifier);\n\nfunction parseIsoNative(string) {\n var date = new Date(string);\n return isNaN(date) ? null : date;\n}\n\nvar parseIso = +new Date(\"2000-01-01T00:00:00.000Z\")\n ? parseIsoNative\n : exports.utcParse(isoSpecifier);\n\nvar durationSecond = 1000;\nvar durationMinute = durationSecond * 60;\nvar durationHour = durationMinute * 60;\nvar durationDay = durationHour * 24;\nvar durationWeek = durationDay * 7;\nvar durationMonth = durationDay * 30;\nvar durationYear = durationDay * 365;\n\nfunction date$1(t) {\n return new Date(t);\n}\n\nfunction number$2(t) {\n return t instanceof Date ? +t : +new Date(+t);\n}\n\nfunction calendar(year$$1, month$$1, week, day$$1, hour$$1, minute$$1, second$$1, millisecond$$1, format) {\n var scale = continuous(deinterpolateLinear, reinterpolate),\n invert = scale.invert,\n domain = scale.domain;\n\n var formatMillisecond = format(\".%L\"),\n formatSecond = format(\":%S\"),\n formatMinute = format(\"%I:%M\"),\n formatHour = format(\"%I %p\"),\n formatDay = format(\"%a %d\"),\n formatWeek = format(\"%b %d\"),\n formatMonth = format(\"%B\"),\n formatYear = format(\"%Y\");\n\n var tickIntervals = [\n [second$$1, 1, durationSecond],\n [second$$1, 5, 5 * durationSecond],\n [second$$1, 15, 15 * durationSecond],\n [second$$1, 30, 30 * durationSecond],\n [minute$$1, 1, durationMinute],\n [minute$$1, 5, 5 * durationMinute],\n [minute$$1, 15, 15 * durationMinute],\n [minute$$1, 30, 30 * durationMinute],\n [ hour$$1, 1, durationHour ],\n [ hour$$1, 3, 3 * durationHour ],\n [ hour$$1, 6, 6 * durationHour ],\n [ hour$$1, 12, 12 * durationHour ],\n [ day$$1, 1, durationDay ],\n [ day$$1, 2, 2 * durationDay ],\n [ week, 1, durationWeek ],\n [ month$$1, 1, durationMonth ],\n [ month$$1, 3, 3 * durationMonth ],\n [ year$$1, 1, durationYear ]\n ];\n\n function tickFormat(date) {\n return (second$$1(date) < date ? formatMillisecond\n : minute$$1(date) < date ? formatSecond\n : hour$$1(date) < date ? formatMinute\n : day$$1(date) < date ? formatHour\n : month$$1(date) < date ? (week(date) < date ? formatDay : formatWeek)\n : year$$1(date) < date ? formatMonth\n : formatYear)(date);\n }\n\n function tickInterval(interval, start, stop, step) {\n if (interval == null) interval = 10;\n\n // If a desired tick count is specified, pick a reasonable tick interval\n // based on the extent of the domain and a rough estimate of tick size.\n // Otherwise, assume interval is already a time interval and use it.\n if (typeof interval === \"number\") {\n var target = Math.abs(stop - start) / interval,\n i = bisector(function(i) { return i[2]; }).right(tickIntervals, target);\n if (i === tickIntervals.length) {\n step = tickStep(start / durationYear, stop / durationYear, interval);\n interval = year$$1;\n } else if (i) {\n i = tickIntervals[target / tickIntervals[i - 1][2] < tickIntervals[i][2] / target ? i - 1 : i];\n step = i[1];\n interval = i[0];\n } else {\n step = tickStep(start, stop, interval);\n interval = millisecond$$1;\n }\n }\n\n return step == null ? interval : interval.every(step);\n }\n\n scale.invert = function(y) {\n return new Date(invert(y));\n };\n\n scale.domain = function(_) {\n return arguments.length ? domain(map$3.call(_, number$2)) : domain().map(date$1);\n };\n\n scale.ticks = function(interval, step) {\n var d = domain(),\n t0 = d[0],\n t1 = d[d.length - 1],\n r = t1 < t0,\n t;\n if (r) t = t0, t0 = t1, t1 = t;\n t = tickInterval(interval, t0, t1, step);\n t = t ? t.range(t0, t1 + 1) : []; // inclusive stop\n return r ? t.reverse() : t;\n };\n\n scale.tickFormat = function(count, specifier) {\n return specifier == null ? tickFormat : format(specifier);\n };\n\n scale.nice = function(interval, step) {\n var d = domain();\n return (interval = tickInterval(interval, d[0], d[d.length - 1], step))\n ? domain(nice(d, interval))\n : scale;\n };\n\n scale.copy = function() {\n return copy(scale, calendar(year$$1, month$$1, week, day$$1, hour$$1, minute$$1, second$$1, millisecond$$1, format));\n };\n\n return scale;\n}\n\nvar time = function() {\n return calendar(year, month, sunday, day, hour, minute, second, millisecond, exports.timeFormat).domain([new Date(2000, 0, 1), new Date(2000, 0, 2)]);\n};\n\nvar utcTime = function() {\n return calendar(utcYear, utcMonth, utcSunday, utcDay, utcHour, utcMinute, second, millisecond, exports.utcFormat).domain([Date.UTC(2000, 0, 1), Date.UTC(2000, 0, 2)]);\n};\n\nvar colors = function(s) {\n return s.match(/.{6}/g).map(function(x) {\n return \"#\" + x;\n });\n};\n\nvar category10 = colors(\"1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf\");\n\nvar category20b = colors(\"393b795254a36b6ecf9c9ede6379398ca252b5cf6bcedb9c8c6d31bd9e39e7ba52e7cb94843c39ad494ad6616be7969c7b4173a55194ce6dbdde9ed6\");\n\nvar category20c = colors(\"3182bd6baed69ecae1c6dbefe6550dfd8d3cfdae6bfdd0a231a35474c476a1d99bc7e9c0756bb19e9ac8bcbddcdadaeb636363969696bdbdbdd9d9d9\");\n\nvar category20 = colors(\"1f77b4aec7e8ff7f0effbb782ca02c98df8ad62728ff98969467bdc5b0d58c564bc49c94e377c2f7b6d27f7f7fc7c7c7bcbd22dbdb8d17becf9edae5\");\n\nvar cubehelix$3 = cubehelixLong(cubehelix(300, 0.5, 0.0), cubehelix(-240, 0.5, 1.0));\n\nvar warm = cubehelixLong(cubehelix(-100, 0.75, 0.35), cubehelix(80, 1.50, 0.8));\n\nvar cool = cubehelixLong(cubehelix(260, 0.75, 0.35), cubehelix(80, 1.50, 0.8));\n\nvar rainbow = cubehelix();\n\nvar rainbow$1 = function(t) {\n if (t < 0 || t > 1) t -= Math.floor(t);\n var ts = Math.abs(t - 0.5);\n rainbow.h = 360 * t - 100;\n rainbow.s = 1.5 - 1.5 * ts;\n rainbow.l = 0.8 - 0.9 * ts;\n return rainbow + \"\";\n};\n\nfunction ramp(range) {\n var n = range.length;\n return function(t) {\n return range[Math.max(0, Math.min(n - 1, Math.floor(t * n)))];\n };\n}\n\nvar viridis = ramp(colors(\"44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725\"));\n\nvar magma = ramp(colors(\"00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf\"));\n\nvar inferno = ramp(colors(\"00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4\"));\n\nvar plasma = ramp(colors(\"0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921\"));\n\nfunction sequential(interpolator) {\n var x0 = 0,\n x1 = 1,\n clamp = false;\n\n function scale(x) {\n var t = (x - x0) / (x1 - x0);\n return interpolator(clamp ? Math.max(0, Math.min(1, t)) : t);\n }\n\n scale.domain = function(_) {\n return arguments.length ? (x0 = +_[0], x1 = +_[1], scale) : [x0, x1];\n };\n\n scale.clamp = function(_) {\n return arguments.length ? (clamp = !!_, scale) : clamp;\n };\n\n scale.interpolator = function(_) {\n return arguments.length ? (interpolator = _, scale) : interpolator;\n };\n\n scale.copy = function() {\n return sequential(interpolator).domain([x0, x1]).clamp(clamp);\n };\n\n return linearish(scale);\n}\n\nvar constant$10 = function(x) {\n return function constant() {\n return x;\n };\n};\n\nvar epsilon$3 = 1e-12;\nvar pi$4 = Math.PI;\nvar halfPi$3 = pi$4 / 2;\nvar tau$4 = 2 * pi$4;\n\nfunction arcInnerRadius(d) {\n return d.innerRadius;\n}\n\nfunction arcOuterRadius(d) {\n return d.outerRadius;\n}\n\nfunction arcStartAngle(d) {\n return d.startAngle;\n}\n\nfunction arcEndAngle(d) {\n return d.endAngle;\n}\n\nfunction arcPadAngle(d) {\n return d && d.padAngle; // Note: optional!\n}\n\nfunction asin$1(x) {\n return x >= 1 ? halfPi$3 : x <= -1 ? -halfPi$3 : Math.asin(x);\n}\n\nfunction intersect(x0, y0, x1, y1, x2, y2, x3, y3) {\n var x10 = x1 - x0, y10 = y1 - y0,\n x32 = x3 - x2, y32 = y3 - y2,\n t = (x32 * (y0 - y2) - y32 * (x0 - x2)) / (y32 * x10 - x32 * y10);\n return [x0 + t * x10, y0 + t * y10];\n}\n\n// Compute perpendicular offset line of length rc.\n// http://mathworld.wolfram.com/Circle-LineIntersection.html\nfunction cornerTangents(x0, y0, x1, y1, r1, rc, cw) {\n var x01 = x0 - x1,\n y01 = y0 - y1,\n lo = (cw ? rc : -rc) / Math.sqrt(x01 * x01 + y01 * y01),\n ox = lo * y01,\n oy = -lo * x01,\n x11 = x0 + ox,\n y11 = y0 + oy,\n x10 = x1 + ox,\n y10 = y1 + oy,\n x00 = (x11 + x10) / 2,\n y00 = (y11 + y10) / 2,\n dx = x10 - x11,\n dy = y10 - y11,\n d2 = dx * dx + dy * dy,\n r = r1 - rc,\n D = x11 * y10 - x10 * y11,\n d = (dy < 0 ? -1 : 1) * Math.sqrt(Math.max(0, r * r * d2 - D * D)),\n cx0 = (D * dy - dx * d) / d2,\n cy0 = (-D * dx - dy * d) / d2,\n cx1 = (D * dy + dx * d) / d2,\n cy1 = (-D * dx + dy * d) / d2,\n dx0 = cx0 - x00,\n dy0 = cy0 - y00,\n dx1 = cx1 - x00,\n dy1 = cy1 - y00;\n\n // Pick the closer of the two intersection points.\n // TODO Is there a faster way to determine which intersection to use?\n if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) cx0 = cx1, cy0 = cy1;\n\n return {\n cx: cx0,\n cy: cy0,\n x01: -ox,\n y01: -oy,\n x11: cx0 * (r1 / r - 1),\n y11: cy0 * (r1 / r - 1)\n };\n}\n\nvar arc = function() {\n var innerRadius = arcInnerRadius,\n outerRadius = arcOuterRadius,\n cornerRadius = constant$10(0),\n padRadius = null,\n startAngle = arcStartAngle,\n endAngle = arcEndAngle,\n padAngle = arcPadAngle,\n context = null;\n\n function arc() {\n var buffer,\n r,\n r0 = +innerRadius.apply(this, arguments),\n r1 = +outerRadius.apply(this, arguments),\n a0 = startAngle.apply(this, arguments) - halfPi$3,\n a1 = endAngle.apply(this, arguments) - halfPi$3,\n da = Math.abs(a1 - a0),\n cw = a1 > a0;\n\n if (!context) context = buffer = path();\n\n // Ensure that the outer radius is always larger than the inner radius.\n if (r1 < r0) r = r1, r1 = r0, r0 = r;\n\n // Is it a point?\n if (!(r1 > epsilon$3)) context.moveTo(0, 0);\n\n // Or is it a circle or annulus?\n else if (da > tau$4 - epsilon$3) {\n context.moveTo(r1 * Math.cos(a0), r1 * Math.sin(a0));\n context.arc(0, 0, r1, a0, a1, !cw);\n if (r0 > epsilon$3) {\n context.moveTo(r0 * Math.cos(a1), r0 * Math.sin(a1));\n context.arc(0, 0, r0, a1, a0, cw);\n }\n }\n\n // Or is it a circular or annular sector?\n else {\n var a01 = a0,\n a11 = a1,\n a00 = a0,\n a10 = a1,\n da0 = da,\n da1 = da,\n ap = padAngle.apply(this, arguments) / 2,\n rp = (ap > epsilon$3) && (padRadius ? +padRadius.apply(this, arguments) : Math.sqrt(r0 * r0 + r1 * r1)),\n rc = Math.min(Math.abs(r1 - r0) / 2, +cornerRadius.apply(this, arguments)),\n rc0 = rc,\n rc1 = rc,\n t0,\n t1;\n\n // Apply padding? Note that since r1 ≥ r0, da1 ≥ da0.\n if (rp > epsilon$3) {\n var p0 = asin$1(rp / r0 * Math.sin(ap)),\n p1 = asin$1(rp / r1 * Math.sin(ap));\n if ((da0 -= p0 * 2) > epsilon$3) p0 *= (cw ? 1 : -1), a00 += p0, a10 -= p0;\n else da0 = 0, a00 = a10 = (a0 + a1) / 2;\n if ((da1 -= p1 * 2) > epsilon$3) p1 *= (cw ? 1 : -1), a01 += p1, a11 -= p1;\n else da1 = 0, a01 = a11 = (a0 + a1) / 2;\n }\n\n var x01 = r1 * Math.cos(a01),\n y01 = r1 * Math.sin(a01),\n x10 = r0 * Math.cos(a10),\n y10 = r0 * Math.sin(a10);\n\n // Apply rounded corners?\n if (rc > epsilon$3) {\n var x11 = r1 * Math.cos(a11),\n y11 = r1 * Math.sin(a11),\n x00 = r0 * Math.cos(a00),\n y00 = r0 * Math.sin(a00);\n\n // Restrict the corner radius according to the sector angle.\n if (da < pi$4) {\n var oc = da0 > epsilon$3 ? intersect(x01, y01, x00, y00, x11, y11, x10, y10) : [x10, y10],\n ax = x01 - oc[0],\n ay = y01 - oc[1],\n bx = x11 - oc[0],\n by = y11 - oc[1],\n kc = 1 / Math.sin(Math.acos((ax * bx + ay * by) / (Math.sqrt(ax * ax + ay * ay) * Math.sqrt(bx * bx + by * by))) / 2),\n lc = Math.sqrt(oc[0] * oc[0] + oc[1] * oc[1]);\n rc0 = Math.min(rc, (r0 - lc) / (kc - 1));\n rc1 = Math.min(rc, (r1 - lc) / (kc + 1));\n }\n }\n\n // Is the sector collapsed to a line?\n if (!(da1 > epsilon$3)) context.moveTo(x01, y01);\n\n // Does the sector’s outer ring have rounded corners?\n else if (rc1 > epsilon$3) {\n t0 = cornerTangents(x00, y00, x01, y01, r1, rc1, cw);\n t1 = cornerTangents(x11, y11, x10, y10, r1, rc1, cw);\n\n context.moveTo(t0.cx + t0.x01, t0.cy + t0.y01);\n\n // Have the corners merged?\n if (rc1 < rc) context.arc(t0.cx, t0.cy, rc1, Math.atan2(t0.y01, t0.x01), Math.atan2(t1.y01, t1.x01), !cw);\n\n // Otherwise, draw the two corners and the ring.\n else {\n context.arc(t0.cx, t0.cy, rc1, Math.atan2(t0.y01, t0.x01), Math.atan2(t0.y11, t0.x11), !cw);\n context.arc(0, 0, r1, Math.atan2(t0.cy + t0.y11, t0.cx + t0.x11), Math.atan2(t1.cy + t1.y11, t1.cx + t1.x11), !cw);\n context.arc(t1.cx, t1.cy, rc1, Math.atan2(t1.y11, t1.x11), Math.atan2(t1.y01, t1.x01), !cw);\n }\n }\n\n // Or is the outer ring just a circular arc?\n else context.moveTo(x01, y01), context.arc(0, 0, r1, a01, a11, !cw);\n\n // Is there no inner ring, and it’s a circular sector?\n // Or perhaps it’s an annular sector collapsed due to padding?\n if (!(r0 > epsilon$3) || !(da0 > epsilon$3)) context.lineTo(x10, y10);\n\n // Does the sector’s inner ring (or point) have rounded corners?\n else if (rc0 > epsilon$3) {\n t0 = cornerTangents(x10, y10, x11, y11, r0, -rc0, cw);\n t1 = cornerTangents(x01, y01, x00, y00, r0, -rc0, cw);\n\n context.lineTo(t0.cx + t0.x01, t0.cy + t0.y01);\n\n // Have the corners merged?\n if (rc0 < rc) context.arc(t0.cx, t0.cy, rc0, Math.atan2(t0.y01, t0.x01), Math.atan2(t1.y01, t1.x01), !cw);\n\n // Otherwise, draw the two corners and the ring.\n else {\n context.arc(t0.cx, t0.cy, rc0, Math.atan2(t0.y01, t0.x01), Math.atan2(t0.y11, t0.x11), !cw);\n context.arc(0, 0, r0, Math.atan2(t0.cy + t0.y11, t0.cx + t0.x11), Math.atan2(t1.cy + t1.y11, t1.cx + t1.x11), cw);\n context.arc(t1.cx, t1.cy, rc0, Math.atan2(t1.y11, t1.x11), Math.atan2(t1.y01, t1.x01), !cw);\n }\n }\n\n // Or is the inner ring just a circular arc?\n else context.arc(0, 0, r0, a10, a00, cw);\n }\n\n context.closePath();\n\n if (buffer) return context = null, buffer + \"\" || null;\n }\n\n arc.centroid = function() {\n var r = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2,\n a = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - pi$4 / 2;\n return [Math.cos(a) * r, Math.sin(a) * r];\n };\n\n arc.innerRadius = function(_) {\n return arguments.length ? (innerRadius = typeof _ === \"function\" ? _ : constant$10(+_), arc) : innerRadius;\n };\n\n arc.outerRadius = function(_) {\n return arguments.length ? (outerRadius = typeof _ === \"function\" ? _ : constant$10(+_), arc) : outerRadius;\n };\n\n arc.cornerRadius = function(_) {\n return arguments.length ? (cornerRadius = typeof _ === \"function\" ? _ : constant$10(+_), arc) : cornerRadius;\n };\n\n arc.padRadius = function(_) {\n return arguments.length ? (padRadius = _ == null ? null : typeof _ === \"function\" ? _ : constant$10(+_), arc) : padRadius;\n };\n\n arc.startAngle = function(_) {\n return arguments.length ? (startAngle = typeof _ === \"function\" ? _ : constant$10(+_), arc) : startAngle;\n };\n\n arc.endAngle = function(_) {\n return arguments.length ? (endAngle = typeof _ === \"function\" ? _ : constant$10(+_), arc) : endAngle;\n };\n\n arc.padAngle = function(_) {\n return arguments.length ? (padAngle = typeof _ === \"function\" ? _ : constant$10(+_), arc) : padAngle;\n };\n\n arc.context = function(_) {\n return arguments.length ? ((context = _ == null ? null : _), arc) : context;\n };\n\n return arc;\n};\n\nfunction Linear(context) {\n this._context = context;\n}\n\nLinear.prototype = {\n areaStart: function() {\n this._line = 0;\n },\n areaEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._point = 0;\n },\n lineEnd: function() {\n if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n this._line = 1 - this._line;\n },\n point: function(x, y) {\n x = +x, y = +y;\n switch (this._point) {\n case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n case 1: this._point = 2; // proceed\n default: this._context.lineTo(x, y); break;\n }\n }\n};\n\nvar curveLinear = function(context) {\n return new Linear(context);\n};\n\nfunction x$3(p) {\n return p[0];\n}\n\nfunction y$3(p) {\n return p[1];\n}\n\nvar line = function() {\n var x$$1 = x$3,\n y$$1 = y$3,\n defined = constant$10(true),\n context = null,\n curve = curveLinear,\n output = null;\n\n function line(data) {\n var i,\n n = data.length,\n d,\n defined0 = false,\n buffer;\n\n if (context == null) output = curve(buffer = path());\n\n for (i = 0; i <= n; ++i) {\n if (!(i < n && defined(d = data[i], i, data)) === defined0) {\n if (defined0 = !defined0) output.lineStart();\n else output.lineEnd();\n }\n if (defined0) output.point(+x$$1(d, i, data), +y$$1(d, i, data));\n }\n\n if (buffer) return output = null, buffer + \"\" || null;\n }\n\n line.x = function(_) {\n return arguments.length ? (x$$1 = typeof _ === \"function\" ? _ : constant$10(+_), line) : x$$1;\n };\n\n line.y = function(_) {\n return arguments.length ? (y$$1 = typeof _ === \"function\" ? _ : constant$10(+_), line) : y$$1;\n };\n\n line.defined = function(_) {\n return arguments.length ? (defined = typeof _ === \"function\" ? _ : constant$10(!!_), line) : defined;\n };\n\n line.curve = function(_) {\n return arguments.length ? (curve = _, context != null && (output = curve(context)), line) : curve;\n };\n\n line.context = function(_) {\n return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), line) : context;\n };\n\n return line;\n};\n\nvar area$2 = function() {\n var x0 = x$3,\n x1 = null,\n y0 = constant$10(0),\n y1 = y$3,\n defined = constant$10(true),\n context = null,\n curve = curveLinear,\n output = null;\n\n function area(data) {\n var i,\n j,\n k,\n n = data.length,\n d,\n defined0 = false,\n buffer,\n x0z = new Array(n),\n y0z = new Array(n);\n\n if (context == null) output = curve(buffer = path());\n\n for (i = 0; i <= n; ++i) {\n if (!(i < n && defined(d = data[i], i, data)) === defined0) {\n if (defined0 = !defined0) {\n j = i;\n output.areaStart();\n output.lineStart();\n } else {\n output.lineEnd();\n output.lineStart();\n for (k = i - 1; k >= j; --k) {\n output.point(x0z[k], y0z[k]);\n }\n output.lineEnd();\n output.areaEnd();\n }\n }\n if (defined0) {\n x0z[i] = +x0(d, i, data), y0z[i] = +y0(d, i, data);\n output.point(x1 ? +x1(d, i, data) : x0z[i], y1 ? +y1(d, i, data) : y0z[i]);\n }\n }\n\n if (buffer) return output = null, buffer + \"\" || null;\n }\n\n function arealine() {\n return line().defined(defined).curve(curve).context(context);\n }\n\n area.x = function(_) {\n return arguments.length ? (x0 = typeof _ === \"function\" ? _ : constant$10(+_), x1 = null, area) : x0;\n };\n\n area.x0 = function(_) {\n return arguments.length ? (x0 = typeof _ === \"function\" ? _ : constant$10(+_), area) : x0;\n };\n\n area.x1 = function(_) {\n return arguments.length ? (x1 = _ == null ? null : typeof _ === \"function\" ? _ : constant$10(+_), area) : x1;\n };\n\n area.y = function(_) {\n return arguments.length ? (y0 = typeof _ === \"function\" ? _ : constant$10(+_), y1 = null, area) : y0;\n };\n\n area.y0 = function(_) {\n return arguments.length ? (y0 = typeof _ === \"function\" ? _ : constant$10(+_), area) : y0;\n };\n\n area.y1 = function(_) {\n return arguments.length ? (y1 = _ == null ? null : typeof _ === \"function\" ? _ : constant$10(+_), area) : y1;\n };\n\n area.lineX0 =\n area.lineY0 = function() {\n return arealine().x(x0).y(y0);\n };\n\n area.lineY1 = function() {\n return arealine().x(x0).y(y1);\n };\n\n area.lineX1 = function() {\n return arealine().x(x1).y(y0);\n };\n\n area.defined = function(_) {\n return arguments.length ? (defined = typeof _ === \"function\" ? _ : constant$10(!!_), area) : defined;\n };\n\n area.curve = function(_) {\n return arguments.length ? (curve = _, context != null && (output = curve(context)), area) : curve;\n };\n\n area.context = function(_) {\n return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), area) : context;\n };\n\n return area;\n};\n\nvar descending$1 = function(a, b) {\n return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;\n};\n\nvar identity$7 = function(d) {\n return d;\n};\n\nvar pie = function() {\n var value = identity$7,\n sortValues = descending$1,\n sort = null,\n startAngle = constant$10(0),\n endAngle = constant$10(tau$4),\n padAngle = constant$10(0);\n\n function pie(data) {\n var i,\n n = data.length,\n j,\n k,\n sum = 0,\n index = new Array(n),\n arcs = new Array(n),\n a0 = +startAngle.apply(this, arguments),\n da = Math.min(tau$4, Math.max(-tau$4, endAngle.apply(this, arguments) - a0)),\n a1,\n p = Math.min(Math.abs(da) / n, padAngle.apply(this, arguments)),\n pa = p * (da < 0 ? -1 : 1),\n v;\n\n for (i = 0; i < n; ++i) {\n if ((v = arcs[index[i] = i] = +value(data[i], i, data)) > 0) {\n sum += v;\n }\n }\n\n // Optionally sort the arcs by previously-computed values or by data.\n if (sortValues != null) index.sort(function(i, j) { return sortValues(arcs[i], arcs[j]); });\n else if (sort != null) index.sort(function(i, j) { return sort(data[i], data[j]); });\n\n // Compute the arcs! They are stored in the original data's order.\n for (i = 0, k = sum ? (da - n * pa) / sum : 0; i < n; ++i, a0 = a1) {\n j = index[i], v = arcs[j], a1 = a0 + (v > 0 ? v * k : 0) + pa, arcs[j] = {\n data: data[j],\n index: i,\n value: v,\n startAngle: a0,\n endAngle: a1,\n padAngle: p\n };\n }\n\n return arcs;\n }\n\n pie.value = function(_) {\n return arguments.length ? (value = typeof _ === \"function\" ? _ : constant$10(+_), pie) : value;\n };\n\n pie.sortValues = function(_) {\n return arguments.length ? (sortValues = _, sort = null, pie) : sortValues;\n };\n\n pie.sort = function(_) {\n return arguments.length ? (sort = _, sortValues = null, pie) : sort;\n };\n\n pie.startAngle = function(_) {\n return arguments.length ? (startAngle = typeof _ === \"function\" ? _ : constant$10(+_), pie) : startAngle;\n };\n\n pie.endAngle = function(_) {\n return arguments.length ? (endAngle = typeof _ === \"function\" ? _ : constant$10(+_), pie) : endAngle;\n };\n\n pie.padAngle = function(_) {\n return arguments.length ? (padAngle = typeof _ === \"function\" ? _ : constant$10(+_), pie) : padAngle;\n };\n\n return pie;\n};\n\nvar curveRadialLinear = curveRadial(curveLinear);\n\nfunction Radial(curve) {\n this._curve = curve;\n}\n\nRadial.prototype = {\n areaStart: function() {\n this._curve.areaStart();\n },\n areaEnd: function() {\n this._curve.areaEnd();\n },\n lineStart: function() {\n this._curve.lineStart();\n },\n lineEnd: function() {\n this._curve.lineEnd();\n },\n point: function(a, r) {\n this._curve.point(r * Math.sin(a), r * -Math.cos(a));\n }\n};\n\nfunction curveRadial(curve) {\n\n function radial(context) {\n return new Radial(curve(context));\n }\n\n radial._curve = curve;\n\n return radial;\n}\n\nfunction radialLine(l) {\n var c = l.curve;\n\n l.angle = l.x, delete l.x;\n l.radius = l.y, delete l.y;\n\n l.curve = function(_) {\n return arguments.length ? c(curveRadial(_)) : c()._curve;\n };\n\n return l;\n}\n\nvar radialLine$1 = function() {\n return radialLine(line().curve(curveRadialLinear));\n};\n\nvar radialArea = function() {\n var a = area$2().curve(curveRadialLinear),\n c = a.curve,\n x0 = a.lineX0,\n x1 = a.lineX1,\n y0 = a.lineY0,\n y1 = a.lineY1;\n\n a.angle = a.x, delete a.x;\n a.startAngle = a.x0, delete a.x0;\n a.endAngle = a.x1, delete a.x1;\n a.radius = a.y, delete a.y;\n a.innerRadius = a.y0, delete a.y0;\n a.outerRadius = a.y1, delete a.y1;\n a.lineStartAngle = function() { return radialLine(x0()); }, delete a.lineX0;\n a.lineEndAngle = function() { return radialLine(x1()); }, delete a.lineX1;\n a.lineInnerRadius = function() { return radialLine(y0()); }, delete a.lineY0;\n a.lineOuterRadius = function() { return radialLine(y1()); }, delete a.lineY1;\n\n a.curve = function(_) {\n return arguments.length ? c(curveRadial(_)) : c()._curve;\n };\n\n return a;\n};\n\nvar circle$2 = {\n draw: function(context, size) {\n var r = Math.sqrt(size / pi$4);\n context.moveTo(r, 0);\n context.arc(0, 0, r, 0, tau$4);\n }\n};\n\nvar cross$1 = {\n draw: function(context, size) {\n var r = Math.sqrt(size / 5) / 2;\n context.moveTo(-3 * r, -r);\n context.lineTo(-r, -r);\n context.lineTo(-r, -3 * r);\n context.lineTo(r, -3 * r);\n context.lineTo(r, -r);\n context.lineTo(3 * r, -r);\n context.lineTo(3 * r, r);\n context.lineTo(r, r);\n context.lineTo(r, 3 * r);\n context.lineTo(-r, 3 * r);\n context.lineTo(-r, r);\n context.lineTo(-3 * r, r);\n context.closePath();\n }\n};\n\nvar tan30 = Math.sqrt(1 / 3);\nvar tan30_2 = tan30 * 2;\n\nvar diamond = {\n draw: function(context, size) {\n var y = Math.sqrt(size / tan30_2),\n x = y * tan30;\n context.moveTo(0, -y);\n context.lineTo(x, 0);\n context.lineTo(0, y);\n context.lineTo(-x, 0);\n context.closePath();\n }\n};\n\nvar ka = 0.89081309152928522810;\nvar kr = Math.sin(pi$4 / 10) / Math.sin(7 * pi$4 / 10);\nvar kx = Math.sin(tau$4 / 10) * kr;\nvar ky = -Math.cos(tau$4 / 10) * kr;\n\nvar star = {\n draw: function(context, size) {\n var r = Math.sqrt(size * ka),\n x = kx * r,\n y = ky * r;\n context.moveTo(0, -r);\n context.lineTo(x, y);\n for (var i = 1; i < 5; ++i) {\n var a = tau$4 * i / 5,\n c = Math.cos(a),\n s = Math.sin(a);\n context.lineTo(s * r, -c * r);\n context.lineTo(c * x - s * y, s * x + c * y);\n }\n context.closePath();\n }\n};\n\nvar square = {\n draw: function(context, size) {\n var w = Math.sqrt(size),\n x = -w / 2;\n context.rect(x, x, w, w);\n }\n};\n\nvar sqrt3 = Math.sqrt(3);\n\nvar triangle = {\n draw: function(context, size) {\n var y = -Math.sqrt(size / (sqrt3 * 3));\n context.moveTo(0, y * 2);\n context.lineTo(-sqrt3 * y, -y);\n context.lineTo(sqrt3 * y, -y);\n context.closePath();\n }\n};\n\nvar c = -0.5;\nvar s = Math.sqrt(3) / 2;\nvar k = 1 / Math.sqrt(12);\nvar a = (k / 2 + 1) * 3;\n\nvar wye = {\n draw: function(context, size) {\n var r = Math.sqrt(size / a),\n x0 = r / 2,\n y0 = r * k,\n x1 = x0,\n y1 = r * k + r,\n x2 = -x1,\n y2 = y1;\n context.moveTo(x0, y0);\n context.lineTo(x1, y1);\n context.lineTo(x2, y2);\n context.lineTo(c * x0 - s * y0, s * x0 + c * y0);\n context.lineTo(c * x1 - s * y1, s * x1 + c * y1);\n context.lineTo(c * x2 - s * y2, s * x2 + c * y2);\n context.lineTo(c * x0 + s * y0, c * y0 - s * x0);\n context.lineTo(c * x1 + s * y1, c * y1 - s * x1);\n context.lineTo(c * x2 + s * y2, c * y2 - s * x2);\n context.closePath();\n }\n};\n\nvar symbols = [\n circle$2,\n cross$1,\n diamond,\n square,\n star,\n triangle,\n wye\n];\n\nvar symbol = function() {\n var type = constant$10(circle$2),\n size = constant$10(64),\n context = null;\n\n function symbol() {\n var buffer;\n if (!context) context = buffer = path();\n type.apply(this, arguments).draw(context, +size.apply(this, arguments));\n if (buffer) return context = null, buffer + \"\" || null;\n }\n\n symbol.type = function(_) {\n return arguments.length ? (type = typeof _ === \"function\" ? _ : constant$10(_), symbol) : type;\n };\n\n symbol.size = function(_) {\n return arguments.length ? (size = typeof _ === \"function\" ? _ : constant$10(+_), symbol) : size;\n };\n\n symbol.context = function(_) {\n return arguments.length ? (context = _ == null ? null : _, symbol) : context;\n };\n\n return symbol;\n};\n\nvar noop$2 = function() {};\n\nfunction point$2(that, x, y) {\n that._context.bezierCurveTo(\n (2 * that._x0 + that._x1) / 3,\n (2 * that._y0 + that._y1) / 3,\n (that._x0 + 2 * that._x1) / 3,\n (that._y0 + 2 * that._y1) / 3,\n (that._x0 + 4 * that._x1 + x) / 6,\n (that._y0 + 4 * that._y1 + y) / 6\n );\n}\n\nfunction Basis(context) {\n this._context = context;\n}\n\nBasis.prototype = {\n areaStart: function() {\n this._line = 0;\n },\n areaEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._x0 = this._x1 =\n this._y0 = this._y1 = NaN;\n this._point = 0;\n },\n lineEnd: function() {\n switch (this._point) {\n case 3: point$2(this, this._x1, this._y1); // proceed\n case 2: this._context.lineTo(this._x1, this._y1); break;\n }\n if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n this._line = 1 - this._line;\n },\n point: function(x, y) {\n x = +x, y = +y;\n switch (this._point) {\n case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n case 1: this._point = 2; break;\n case 2: this._point = 3; this._context.lineTo((5 * this._x0 + this._x1) / 6, (5 * this._y0 + this._y1) / 6); // proceed\n default: point$2(this, x, y); break;\n }\n this._x0 = this._x1, this._x1 = x;\n this._y0 = this._y1, this._y1 = y;\n }\n};\n\nvar basis$2 = function(context) {\n return new Basis(context);\n};\n\nfunction BasisClosed(context) {\n this._context = context;\n}\n\nBasisClosed.prototype = {\n areaStart: noop$2,\n areaEnd: noop$2,\n lineStart: function() {\n this._x0 = this._x1 = this._x2 = this._x3 = this._x4 =\n this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = NaN;\n this._point = 0;\n },\n lineEnd: function() {\n switch (this._point) {\n case 1: {\n this._context.moveTo(this._x2, this._y2);\n this._context.closePath();\n break;\n }\n case 2: {\n this._context.moveTo((this._x2 + 2 * this._x3) / 3, (this._y2 + 2 * this._y3) / 3);\n this._context.lineTo((this._x3 + 2 * this._x2) / 3, (this._y3 + 2 * this._y2) / 3);\n this._context.closePath();\n break;\n }\n case 3: {\n this.point(this._x2, this._y2);\n this.point(this._x3, this._y3);\n this.point(this._x4, this._y4);\n break;\n }\n }\n },\n point: function(x, y) {\n x = +x, y = +y;\n switch (this._point) {\n case 0: this._point = 1; this._x2 = x, this._y2 = y; break;\n case 1: this._point = 2; this._x3 = x, this._y3 = y; break;\n case 2: this._point = 3; this._x4 = x, this._y4 = y; this._context.moveTo((this._x0 + 4 * this._x1 + x) / 6, (this._y0 + 4 * this._y1 + y) / 6); break;\n default: point$2(this, x, y); break;\n }\n this._x0 = this._x1, this._x1 = x;\n this._y0 = this._y1, this._y1 = y;\n }\n};\n\nvar basisClosed$1 = function(context) {\n return new BasisClosed(context);\n};\n\nfunction BasisOpen(context) {\n this._context = context;\n}\n\nBasisOpen.prototype = {\n areaStart: function() {\n this._line = 0;\n },\n areaEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._x0 = this._x1 =\n this._y0 = this._y1 = NaN;\n this._point = 0;\n },\n lineEnd: function() {\n if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath();\n this._line = 1 - this._line;\n },\n point: function(x, y) {\n x = +x, y = +y;\n switch (this._point) {\n case 0: this._point = 1; break;\n case 1: this._point = 2; break;\n case 2: this._point = 3; var x0 = (this._x0 + 4 * this._x1 + x) / 6, y0 = (this._y0 + 4 * this._y1 + y) / 6; this._line ? this._context.lineTo(x0, y0) : this._context.moveTo(x0, y0); break;\n case 3: this._point = 4; // proceed\n default: point$2(this, x, y); break;\n }\n this._x0 = this._x1, this._x1 = x;\n this._y0 = this._y1, this._y1 = y;\n }\n};\n\nvar basisOpen = function(context) {\n return new BasisOpen(context);\n};\n\nfunction Bundle(context, beta) {\n this._basis = new Basis(context);\n this._beta = beta;\n}\n\nBundle.prototype = {\n lineStart: function() {\n this._x = [];\n this._y = [];\n this._basis.lineStart();\n },\n lineEnd: function() {\n var x = this._x,\n y = this._y,\n j = x.length - 1;\n\n if (j > 0) {\n var x0 = x[0],\n y0 = y[0],\n dx = x[j] - x0,\n dy = y[j] - y0,\n i = -1,\n t;\n\n while (++i <= j) {\n t = i / j;\n this._basis.point(\n this._beta * x[i] + (1 - this._beta) * (x0 + t * dx),\n this._beta * y[i] + (1 - this._beta) * (y0 + t * dy)\n );\n }\n }\n\n this._x = this._y = null;\n this._basis.lineEnd();\n },\n point: function(x, y) {\n this._x.push(+x);\n this._y.push(+y);\n }\n};\n\nvar bundle = ((function custom(beta) {\n\n function bundle(context) {\n return beta === 1 ? new Basis(context) : new Bundle(context, beta);\n }\n\n bundle.beta = function(beta) {\n return custom(+beta);\n };\n\n return bundle;\n}))(0.85);\n\nfunction point$3(that, x, y) {\n that._context.bezierCurveTo(\n that._x1 + that._k * (that._x2 - that._x0),\n that._y1 + that._k * (that._y2 - that._y0),\n that._x2 + that._k * (that._x1 - x),\n that._y2 + that._k * (that._y1 - y),\n that._x2,\n that._y2\n );\n}\n\nfunction Cardinal(context, tension) {\n this._context = context;\n this._k = (1 - tension) / 6;\n}\n\nCardinal.prototype = {\n areaStart: function() {\n this._line = 0;\n },\n areaEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._x0 = this._x1 = this._x2 =\n this._y0 = this._y1 = this._y2 = NaN;\n this._point = 0;\n },\n lineEnd: function() {\n switch (this._point) {\n case 2: this._context.lineTo(this._x2, this._y2); break;\n case 3: point$3(this, this._x1, this._y1); break;\n }\n if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n this._line = 1 - this._line;\n },\n point: function(x, y) {\n x = +x, y = +y;\n switch (this._point) {\n case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n case 1: this._point = 2; this._x1 = x, this._y1 = y; break;\n case 2: this._point = 3; // proceed\n default: point$3(this, x, y); break;\n }\n this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n }\n};\n\nvar cardinal = ((function custom(tension) {\n\n function cardinal(context) {\n return new Cardinal(context, tension);\n }\n\n cardinal.tension = function(tension) {\n return custom(+tension);\n };\n\n return cardinal;\n}))(0);\n\nfunction CardinalClosed(context, tension) {\n this._context = context;\n this._k = (1 - tension) / 6;\n}\n\nCardinalClosed.prototype = {\n areaStart: noop$2,\n areaEnd: noop$2,\n lineStart: function() {\n this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 =\n this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN;\n this._point = 0;\n },\n lineEnd: function() {\n switch (this._point) {\n case 1: {\n this._context.moveTo(this._x3, this._y3);\n this._context.closePath();\n break;\n }\n case 2: {\n this._context.lineTo(this._x3, this._y3);\n this._context.closePath();\n break;\n }\n case 3: {\n this.point(this._x3, this._y3);\n this.point(this._x4, this._y4);\n this.point(this._x5, this._y5);\n break;\n }\n }\n },\n point: function(x, y) {\n x = +x, y = +y;\n switch (this._point) {\n case 0: this._point = 1; this._x3 = x, this._y3 = y; break;\n case 1: this._point = 2; this._context.moveTo(this._x4 = x, this._y4 = y); break;\n case 2: this._point = 3; this._x5 = x, this._y5 = y; break;\n default: point$3(this, x, y); break;\n }\n this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n }\n};\n\nvar cardinalClosed = ((function custom(tension) {\n\n function cardinal(context) {\n return new CardinalClosed(context, tension);\n }\n\n cardinal.tension = function(tension) {\n return custom(+tension);\n };\n\n return cardinal;\n}))(0);\n\nfunction CardinalOpen(context, tension) {\n this._context = context;\n this._k = (1 - tension) / 6;\n}\n\nCardinalOpen.prototype = {\n areaStart: function() {\n this._line = 0;\n },\n areaEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._x0 = this._x1 = this._x2 =\n this._y0 = this._y1 = this._y2 = NaN;\n this._point = 0;\n },\n lineEnd: function() {\n if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath();\n this._line = 1 - this._line;\n },\n point: function(x, y) {\n x = +x, y = +y;\n switch (this._point) {\n case 0: this._point = 1; break;\n case 1: this._point = 2; break;\n case 2: this._point = 3; this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2); break;\n case 3: this._point = 4; // proceed\n default: point$3(this, x, y); break;\n }\n this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n }\n};\n\nvar cardinalOpen = ((function custom(tension) {\n\n function cardinal(context) {\n return new CardinalOpen(context, tension);\n }\n\n cardinal.tension = function(tension) {\n return custom(+tension);\n };\n\n return cardinal;\n}))(0);\n\nfunction point$4(that, x, y) {\n var x1 = that._x1,\n y1 = that._y1,\n x2 = that._x2,\n y2 = that._y2;\n\n if (that._l01_a > epsilon$3) {\n var a = 2 * that._l01_2a + 3 * that._l01_a * that._l12_a + that._l12_2a,\n n = 3 * that._l01_a * (that._l01_a + that._l12_a);\n x1 = (x1 * a - that._x0 * that._l12_2a + that._x2 * that._l01_2a) / n;\n y1 = (y1 * a - that._y0 * that._l12_2a + that._y2 * that._l01_2a) / n;\n }\n\n if (that._l23_a > epsilon$3) {\n var b = 2 * that._l23_2a + 3 * that._l23_a * that._l12_a + that._l12_2a,\n m = 3 * that._l23_a * (that._l23_a + that._l12_a);\n x2 = (x2 * b + that._x1 * that._l23_2a - x * that._l12_2a) / m;\n y2 = (y2 * b + that._y1 * that._l23_2a - y * that._l12_2a) / m;\n }\n\n that._context.bezierCurveTo(x1, y1, x2, y2, that._x2, that._y2);\n}\n\nfunction CatmullRom(context, alpha) {\n this._context = context;\n this._alpha = alpha;\n}\n\nCatmullRom.prototype = {\n areaStart: function() {\n this._line = 0;\n },\n areaEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._x0 = this._x1 = this._x2 =\n this._y0 = this._y1 = this._y2 = NaN;\n this._l01_a = this._l12_a = this._l23_a =\n this._l01_2a = this._l12_2a = this._l23_2a =\n this._point = 0;\n },\n lineEnd: function() {\n switch (this._point) {\n case 2: this._context.lineTo(this._x2, this._y2); break;\n case 3: this.point(this._x2, this._y2); break;\n }\n if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n this._line = 1 - this._line;\n },\n point: function(x, y) {\n x = +x, y = +y;\n\n if (this._point) {\n var x23 = this._x2 - x,\n y23 = this._y2 - y;\n this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));\n }\n\n switch (this._point) {\n case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n case 1: this._point = 2; break;\n case 2: this._point = 3; // proceed\n default: point$4(this, x, y); break;\n }\n\n this._l01_a = this._l12_a, this._l12_a = this._l23_a;\n this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;\n this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n }\n};\n\nvar catmullRom = ((function custom(alpha) {\n\n function catmullRom(context) {\n return alpha ? new CatmullRom(context, alpha) : new Cardinal(context, 0);\n }\n\n catmullRom.alpha = function(alpha) {\n return custom(+alpha);\n };\n\n return catmullRom;\n}))(0.5);\n\nfunction CatmullRomClosed(context, alpha) {\n this._context = context;\n this._alpha = alpha;\n}\n\nCatmullRomClosed.prototype = {\n areaStart: noop$2,\n areaEnd: noop$2,\n lineStart: function() {\n this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 =\n this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN;\n this._l01_a = this._l12_a = this._l23_a =\n this._l01_2a = this._l12_2a = this._l23_2a =\n this._point = 0;\n },\n lineEnd: function() {\n switch (this._point) {\n case 1: {\n this._context.moveTo(this._x3, this._y3);\n this._context.closePath();\n break;\n }\n case 2: {\n this._context.lineTo(this._x3, this._y3);\n this._context.closePath();\n break;\n }\n case 3: {\n this.point(this._x3, this._y3);\n this.point(this._x4, this._y4);\n this.point(this._x5, this._y5);\n break;\n }\n }\n },\n point: function(x, y) {\n x = +x, y = +y;\n\n if (this._point) {\n var x23 = this._x2 - x,\n y23 = this._y2 - y;\n this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));\n }\n\n switch (this._point) {\n case 0: this._point = 1; this._x3 = x, this._y3 = y; break;\n case 1: this._point = 2; this._context.moveTo(this._x4 = x, this._y4 = y); break;\n case 2: this._point = 3; this._x5 = x, this._y5 = y; break;\n default: point$4(this, x, y); break;\n }\n\n this._l01_a = this._l12_a, this._l12_a = this._l23_a;\n this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;\n this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n }\n};\n\nvar catmullRomClosed = ((function custom(alpha) {\n\n function catmullRom(context) {\n return alpha ? new CatmullRomClosed(context, alpha) : new CardinalClosed(context, 0);\n }\n\n catmullRom.alpha = function(alpha) {\n return custom(+alpha);\n };\n\n return catmullRom;\n}))(0.5);\n\nfunction CatmullRomOpen(context, alpha) {\n this._context = context;\n this._alpha = alpha;\n}\n\nCatmullRomOpen.prototype = {\n areaStart: function() {\n this._line = 0;\n },\n areaEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._x0 = this._x1 = this._x2 =\n this._y0 = this._y1 = this._y2 = NaN;\n this._l01_a = this._l12_a = this._l23_a =\n this._l01_2a = this._l12_2a = this._l23_2a =\n this._point = 0;\n },\n lineEnd: function() {\n if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath();\n this._line = 1 - this._line;\n },\n point: function(x, y) {\n x = +x, y = +y;\n\n if (this._point) {\n var x23 = this._x2 - x,\n y23 = this._y2 - y;\n this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));\n }\n\n switch (this._point) {\n case 0: this._point = 1; break;\n case 1: this._point = 2; break;\n case 2: this._point = 3; this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2); break;\n case 3: this._point = 4; // proceed\n default: point$4(this, x, y); break;\n }\n\n this._l01_a = this._l12_a, this._l12_a = this._l23_a;\n this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;\n this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n }\n};\n\nvar catmullRomOpen = ((function custom(alpha) {\n\n function catmullRom(context) {\n return alpha ? new CatmullRomOpen(context, alpha) : new CardinalOpen(context, 0);\n }\n\n catmullRom.alpha = function(alpha) {\n return custom(+alpha);\n };\n\n return catmullRom;\n}))(0.5);\n\nfunction LinearClosed(context) {\n this._context = context;\n}\n\nLinearClosed.prototype = {\n areaStart: noop$2,\n areaEnd: noop$2,\n lineStart: function() {\n this._point = 0;\n },\n lineEnd: function() {\n if (this._point) this._context.closePath();\n },\n point: function(x, y) {\n x = +x, y = +y;\n if (this._point) this._context.lineTo(x, y);\n else this._point = 1, this._context.moveTo(x, y);\n }\n};\n\nvar linearClosed = function(context) {\n return new LinearClosed(context);\n};\n\nfunction sign$1(x) {\n return x < 0 ? -1 : 1;\n}\n\n// Calculate the slopes of the tangents (Hermite-type interpolation) based on\n// the following paper: Steffen, M. 1990. A Simple Method for Monotonic\n// Interpolation in One Dimension. Astronomy and Astrophysics, Vol. 239, NO.\n// NOV(II), P. 443, 1990.\nfunction slope3(that, x2, y2) {\n var h0 = that._x1 - that._x0,\n h1 = x2 - that._x1,\n s0 = (that._y1 - that._y0) / (h0 || h1 < 0 && -0),\n s1 = (y2 - that._y1) / (h1 || h0 < 0 && -0),\n p = (s0 * h1 + s1 * h0) / (h0 + h1);\n return (sign$1(s0) + sign$1(s1)) * Math.min(Math.abs(s0), Math.abs(s1), 0.5 * Math.abs(p)) || 0;\n}\n\n// Calculate a one-sided slope.\nfunction slope2(that, t) {\n var h = that._x1 - that._x0;\n return h ? (3 * (that._y1 - that._y0) / h - t) / 2 : t;\n}\n\n// According to https://en.wikipedia.org/wiki/Cubic_Hermite_spline#Representations\n// \"you can express cubic Hermite interpolation in terms of cubic Bézier curves\n// with respect to the four values p0, p0 + m0 / 3, p1 - m1 / 3, p1\".\nfunction point$5(that, t0, t1) {\n var x0 = that._x0,\n y0 = that._y0,\n x1 = that._x1,\n y1 = that._y1,\n dx = (x1 - x0) / 3;\n that._context.bezierCurveTo(x0 + dx, y0 + dx * t0, x1 - dx, y1 - dx * t1, x1, y1);\n}\n\nfunction MonotoneX(context) {\n this._context = context;\n}\n\nMonotoneX.prototype = {\n areaStart: function() {\n this._line = 0;\n },\n areaEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._x0 = this._x1 =\n this._y0 = this._y1 =\n this._t0 = NaN;\n this._point = 0;\n },\n lineEnd: function() {\n switch (this._point) {\n case 2: this._context.lineTo(this._x1, this._y1); break;\n case 3: point$5(this, this._t0, slope2(this, this._t0)); break;\n }\n if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n this._line = 1 - this._line;\n },\n point: function(x, y) {\n var t1 = NaN;\n\n x = +x, y = +y;\n if (x === this._x1 && y === this._y1) return; // Ignore coincident points.\n switch (this._point) {\n case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n case 1: this._point = 2; break;\n case 2: this._point = 3; point$5(this, slope2(this, t1 = slope3(this, x, y)), t1); break;\n default: point$5(this, this._t0, t1 = slope3(this, x, y)); break;\n }\n\n this._x0 = this._x1, this._x1 = x;\n this._y0 = this._y1, this._y1 = y;\n this._t0 = t1;\n }\n};\n\nfunction MonotoneY(context) {\n this._context = new ReflectContext(context);\n}\n\n(MonotoneY.prototype = Object.create(MonotoneX.prototype)).point = function(x, y) {\n MonotoneX.prototype.point.call(this, y, x);\n};\n\nfunction ReflectContext(context) {\n this._context = context;\n}\n\nReflectContext.prototype = {\n moveTo: function(x, y) { this._context.moveTo(y, x); },\n closePath: function() { this._context.closePath(); },\n lineTo: function(x, y) { this._context.lineTo(y, x); },\n bezierCurveTo: function(x1, y1, x2, y2, x, y) { this._context.bezierCurveTo(y1, x1, y2, x2, y, x); }\n};\n\nfunction monotoneX(context) {\n return new MonotoneX(context);\n}\n\nfunction monotoneY(context) {\n return new MonotoneY(context);\n}\n\nfunction Natural(context) {\n this._context = context;\n}\n\nNatural.prototype = {\n areaStart: function() {\n this._line = 0;\n },\n areaEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._x = [];\n this._y = [];\n },\n lineEnd: function() {\n var x = this._x,\n y = this._y,\n n = x.length;\n\n if (n) {\n this._line ? this._context.lineTo(x[0], y[0]) : this._context.moveTo(x[0], y[0]);\n if (n === 2) {\n this._context.lineTo(x[1], y[1]);\n } else {\n var px = controlPoints(x),\n py = controlPoints(y);\n for (var i0 = 0, i1 = 1; i1 < n; ++i0, ++i1) {\n this._context.bezierCurveTo(px[0][i0], py[0][i0], px[1][i0], py[1][i0], x[i1], y[i1]);\n }\n }\n }\n\n if (this._line || (this._line !== 0 && n === 1)) this._context.closePath();\n this._line = 1 - this._line;\n this._x = this._y = null;\n },\n point: function(x, y) {\n this._x.push(+x);\n this._y.push(+y);\n }\n};\n\n// See https://www.particleincell.com/2012/bezier-splines/ for derivation.\nfunction controlPoints(x) {\n var i,\n n = x.length - 1,\n m,\n a = new Array(n),\n b = new Array(n),\n r = new Array(n);\n a[0] = 0, b[0] = 2, r[0] = x[0] + 2 * x[1];\n for (i = 1; i < n - 1; ++i) a[i] = 1, b[i] = 4, r[i] = 4 * x[i] + 2 * x[i + 1];\n a[n - 1] = 2, b[n - 1] = 7, r[n - 1] = 8 * x[n - 1] + x[n];\n for (i = 1; i < n; ++i) m = a[i] / b[i - 1], b[i] -= m, r[i] -= m * r[i - 1];\n a[n - 1] = r[n - 1] / b[n - 1];\n for (i = n - 2; i >= 0; --i) a[i] = (r[i] - a[i + 1]) / b[i];\n b[n - 1] = (x[n] + a[n - 1]) / 2;\n for (i = 0; i < n - 1; ++i) b[i] = 2 * x[i + 1] - a[i + 1];\n return [a, b];\n}\n\nvar natural = function(context) {\n return new Natural(context);\n};\n\nfunction Step(context, t) {\n this._context = context;\n this._t = t;\n}\n\nStep.prototype = {\n areaStart: function() {\n this._line = 0;\n },\n areaEnd: function() {\n this._line = NaN;\n },\n lineStart: function() {\n this._x = this._y = NaN;\n this._point = 0;\n },\n lineEnd: function() {\n if (0 < this._t && this._t < 1 && this._point === 2) this._context.lineTo(this._x, this._y);\n if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n if (this._line >= 0) this._t = 1 - this._t, this._line = 1 - this._line;\n },\n point: function(x, y) {\n x = +x, y = +y;\n switch (this._point) {\n case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n case 1: this._point = 2; // proceed\n default: {\n if (this._t <= 0) {\n this._context.lineTo(this._x, y);\n this._context.lineTo(x, y);\n } else {\n var x1 = this._x * (1 - this._t) + x * this._t;\n this._context.lineTo(x1, this._y);\n this._context.lineTo(x1, y);\n }\n break;\n }\n }\n this._x = x, this._y = y;\n }\n};\n\nvar step = function(context) {\n return new Step(context, 0.5);\n};\n\nfunction stepBefore(context) {\n return new Step(context, 0);\n}\n\nfunction stepAfter(context) {\n return new Step(context, 1);\n}\n\nvar slice$5 = Array.prototype.slice;\n\nvar none$1 = function(series, order) {\n if (!((n = series.length) > 1)) return;\n for (var i = 1, s0, s1 = series[order[0]], n, m = s1.length; i < n; ++i) {\n s0 = s1, s1 = series[order[i]];\n for (var j = 0; j < m; ++j) {\n s1[j][1] += s1[j][0] = isNaN(s0[j][1]) ? s0[j][0] : s0[j][1];\n }\n }\n};\n\nvar none$2 = function(series) {\n var n = series.length, o = new Array(n);\n while (--n >= 0) o[n] = n;\n return o;\n};\n\nfunction stackValue(d, key) {\n return d[key];\n}\n\nvar stack = function() {\n var keys = constant$10([]),\n order = none$2,\n offset = none$1,\n value = stackValue;\n\n function stack(data) {\n var kz = keys.apply(this, arguments),\n i,\n m = data.length,\n n = kz.length,\n sz = new Array(n),\n oz;\n\n for (i = 0; i < n; ++i) {\n for (var ki = kz[i], si = sz[i] = new Array(m), j = 0, sij; j < m; ++j) {\n si[j] = sij = [0, +value(data[j], ki, j, data)];\n sij.data = data[j];\n }\n si.key = ki;\n }\n\n for (i = 0, oz = order(sz); i < n; ++i) {\n sz[oz[i]].index = i;\n }\n\n offset(sz, oz);\n return sz;\n }\n\n stack.keys = function(_) {\n return arguments.length ? (keys = typeof _ === \"function\" ? _ : constant$10(slice$5.call(_)), stack) : keys;\n };\n\n stack.value = function(_) {\n return arguments.length ? (value = typeof _ === \"function\" ? _ : constant$10(+_), stack) : value;\n };\n\n stack.order = function(_) {\n return arguments.length ? (order = _ == null ? none$2 : typeof _ === \"function\" ? _ : constant$10(slice$5.call(_)), stack) : order;\n };\n\n stack.offset = function(_) {\n return arguments.length ? (offset = _ == null ? none$1 : _, stack) : offset;\n };\n\n return stack;\n};\n\nvar expand = function(series, order) {\n if (!((n = series.length) > 0)) return;\n for (var i, n, j = 0, m = series[0].length, y; j < m; ++j) {\n for (y = i = 0; i < n; ++i) y += series[i][j][1] || 0;\n if (y) for (i = 0; i < n; ++i) series[i][j][1] /= y;\n }\n none$1(series, order);\n};\n\nvar silhouette = function(series, order) {\n if (!((n = series.length) > 0)) return;\n for (var j = 0, s0 = series[order[0]], n, m = s0.length; j < m; ++j) {\n for (var i = 0, y = 0; i < n; ++i) y += series[i][j][1] || 0;\n s0[j][1] += s0[j][0] = -y / 2;\n }\n none$1(series, order);\n};\n\nvar wiggle = function(series, order) {\n if (!((n = series.length) > 0) || !((m = (s0 = series[order[0]]).length) > 0)) return;\n for (var y = 0, j = 1, s0, m, n; j < m; ++j) {\n for (var i = 0, s1 = 0, s2 = 0; i < n; ++i) {\n var si = series[order[i]],\n sij0 = si[j][1] || 0,\n sij1 = si[j - 1][1] || 0,\n s3 = (sij0 - sij1) / 2;\n for (var k = 0; k < i; ++k) {\n var sk = series[order[k]],\n skj0 = sk[j][1] || 0,\n skj1 = sk[j - 1][1] || 0;\n s3 += skj0 - skj1;\n }\n s1 += sij0, s2 += s3 * sij0;\n }\n s0[j - 1][1] += s0[j - 1][0] = y;\n if (s1) y -= s2 / s1;\n }\n s0[j - 1][1] += s0[j - 1][0] = y;\n none$1(series, order);\n};\n\nvar ascending$2 = function(series) {\n var sums = series.map(sum$2);\n return none$2(series).sort(function(a, b) { return sums[a] - sums[b]; });\n};\n\nfunction sum$2(series) {\n var s = 0, i = -1, n = series.length, v;\n while (++i < n) if (v = +series[i][1]) s += v;\n return s;\n}\n\nvar descending$2 = function(series) {\n return ascending$2(series).reverse();\n};\n\nvar insideOut = function(series) {\n var n = series.length,\n i,\n j,\n sums = series.map(sum$2),\n order = none$2(series).sort(function(a, b) { return sums[b] - sums[a]; }),\n top = 0,\n bottom = 0,\n tops = [],\n bottoms = [];\n\n for (i = 0; i < n; ++i) {\n j = order[i];\n if (top < bottom) {\n top += sums[j];\n tops.push(j);\n } else {\n bottom += sums[j];\n bottoms.push(j);\n }\n }\n\n return bottoms.reverse().concat(tops);\n};\n\nvar reverse = function(series) {\n return none$2(series).reverse();\n};\n\nvar constant$11 = function(x) {\n return function() {\n return x;\n };\n};\n\nfunction x$4(d) {\n return d[0];\n}\n\nfunction y$4(d) {\n return d[1];\n}\n\nfunction RedBlackTree() {\n this._ = null; // root node\n}\n\nfunction RedBlackNode(node) {\n node.U = // parent node\n node.C = // color - true for red, false for black\n node.L = // left node\n node.R = // right node\n node.P = // previous node\n node.N = null; // next node\n}\n\nRedBlackTree.prototype = {\n constructor: RedBlackTree,\n\n insert: function(after, node) {\n var parent, grandpa, uncle;\n\n if (after) {\n node.P = after;\n node.N = after.N;\n if (after.N) after.N.P = node;\n after.N = node;\n if (after.R) {\n after = after.R;\n while (after.L) after = after.L;\n after.L = node;\n } else {\n after.R = node;\n }\n parent = after;\n } else if (this._) {\n after = RedBlackFirst(this._);\n node.P = null;\n node.N = after;\n after.P = after.L = node;\n parent = after;\n } else {\n node.P = node.N = null;\n this._ = node;\n parent = null;\n }\n node.L = node.R = null;\n node.U = parent;\n node.C = true;\n\n after = node;\n while (parent && parent.C) {\n grandpa = parent.U;\n if (parent === grandpa.L) {\n uncle = grandpa.R;\n if (uncle && uncle.C) {\n parent.C = uncle.C = false;\n grandpa.C = true;\n after = grandpa;\n } else {\n if (after === parent.R) {\n RedBlackRotateLeft(this, parent);\n after = parent;\n parent = after.U;\n }\n parent.C = false;\n grandpa.C = true;\n RedBlackRotateRight(this, grandpa);\n }\n } else {\n uncle = grandpa.L;\n if (uncle && uncle.C) {\n parent.C = uncle.C = false;\n grandpa.C = true;\n after = grandpa;\n } else {\n if (after === parent.L) {\n RedBlackRotateRight(this, parent);\n after = parent;\n parent = after.U;\n }\n parent.C = false;\n grandpa.C = true;\n RedBlackRotateLeft(this, grandpa);\n }\n }\n parent = after.U;\n }\n this._.C = false;\n },\n\n remove: function(node) {\n if (node.N) node.N.P = node.P;\n if (node.P) node.P.N = node.N;\n node.N = node.P = null;\n\n var parent = node.U,\n sibling,\n left = node.L,\n right = node.R,\n next,\n red;\n\n if (!left) next = right;\n else if (!right) next = left;\n else next = RedBlackFirst(right);\n\n if (parent) {\n if (parent.L === node) parent.L = next;\n else parent.R = next;\n } else {\n this._ = next;\n }\n\n if (left && right) {\n red = next.C;\n next.C = node.C;\n next.L = left;\n left.U = next;\n if (next !== right) {\n parent = next.U;\n next.U = node.U;\n node = next.R;\n parent.L = node;\n next.R = right;\n right.U = next;\n } else {\n next.U = parent;\n parent = next;\n node = next.R;\n }\n } else {\n red = node.C;\n node = next;\n }\n\n if (node) node.U = parent;\n if (red) return;\n if (node && node.C) { node.C = false; return; }\n\n do {\n if (node === this._) break;\n if (node === parent.L) {\n sibling = parent.R;\n if (sibling.C) {\n sibling.C = false;\n parent.C = true;\n RedBlackRotateLeft(this, parent);\n sibling = parent.R;\n }\n if ((sibling.L && sibling.L.C)\n || (sibling.R && sibling.R.C)) {\n if (!sibling.R || !sibling.R.C) {\n sibling.L.C = false;\n sibling.C = true;\n RedBlackRotateRight(this, sibling);\n sibling = parent.R;\n }\n sibling.C = parent.C;\n parent.C = sibling.R.C = false;\n RedBlackRotateLeft(this, parent);\n node = this._;\n break;\n }\n } else {\n sibling = parent.L;\n if (sibling.C) {\n sibling.C = false;\n parent.C = true;\n RedBlackRotateRight(this, parent);\n sibling = parent.L;\n }\n if ((sibling.L && sibling.L.C)\n || (sibling.R && sibling.R.C)) {\n if (!sibling.L || !sibling.L.C) {\n sibling.R.C = false;\n sibling.C = true;\n RedBlackRotateLeft(this, sibling);\n sibling = parent.L;\n }\n sibling.C = parent.C;\n parent.C = sibling.L.C = false;\n RedBlackRotateRight(this, parent);\n node = this._;\n break;\n }\n }\n sibling.C = true;\n node = parent;\n parent = parent.U;\n } while (!node.C);\n\n if (node) node.C = false;\n }\n};\n\nfunction RedBlackRotateLeft(tree, node) {\n var p = node,\n q = node.R,\n parent = p.U;\n\n if (parent) {\n if (parent.L === p) parent.L = q;\n else parent.R = q;\n } else {\n tree._ = q;\n }\n\n q.U = parent;\n p.U = q;\n p.R = q.L;\n if (p.R) p.R.U = p;\n q.L = p;\n}\n\nfunction RedBlackRotateRight(tree, node) {\n var p = node,\n q = node.L,\n parent = p.U;\n\n if (parent) {\n if (parent.L === p) parent.L = q;\n else parent.R = q;\n } else {\n tree._ = q;\n }\n\n q.U = parent;\n p.U = q;\n p.L = q.R;\n if (p.L) p.L.U = p;\n q.R = p;\n}\n\nfunction RedBlackFirst(node) {\n while (node.L) node = node.L;\n return node;\n}\n\nfunction createEdge(left, right, v0, v1) {\n var edge = [null, null],\n index = edges.push(edge) - 1;\n edge.left = left;\n edge.right = right;\n if (v0) setEdgeEnd(edge, left, right, v0);\n if (v1) setEdgeEnd(edge, right, left, v1);\n cells[left.index].halfedges.push(index);\n cells[right.index].halfedges.push(index);\n return edge;\n}\n\nfunction createBorderEdge(left, v0, v1) {\n var edge = [v0, v1];\n edge.left = left;\n return edge;\n}\n\nfunction setEdgeEnd(edge, left, right, vertex) {\n if (!edge[0] && !edge[1]) {\n edge[0] = vertex;\n edge.left = left;\n edge.right = right;\n } else if (edge.left === right) {\n edge[1] = vertex;\n } else {\n edge[0] = vertex;\n }\n}\n\n// Liang–Barsky line clipping.\nfunction clipEdge(edge, x0, y0, x1, y1) {\n var a = edge[0],\n b = edge[1],\n ax = a[0],\n ay = a[1],\n bx = b[0],\n by = b[1],\n t0 = 0,\n t1 = 1,\n dx = bx - ax,\n dy = by - ay,\n r;\n\n r = x0 - ax;\n if (!dx && r > 0) return;\n r /= dx;\n if (dx < 0) {\n if (r < t0) return;\n if (r < t1) t1 = r;\n } else if (dx > 0) {\n if (r > t1) return;\n if (r > t0) t0 = r;\n }\n\n r = x1 - ax;\n if (!dx && r < 0) return;\n r /= dx;\n if (dx < 0) {\n if (r > t1) return;\n if (r > t0) t0 = r;\n } else if (dx > 0) {\n if (r < t0) return;\n if (r < t1) t1 = r;\n }\n\n r = y0 - ay;\n if (!dy && r > 0) return;\n r /= dy;\n if (dy < 0) {\n if (r < t0) return;\n if (r < t1) t1 = r;\n } else if (dy > 0) {\n if (r > t1) return;\n if (r > t0) t0 = r;\n }\n\n r = y1 - ay;\n if (!dy && r < 0) return;\n r /= dy;\n if (dy < 0) {\n if (r > t1) return;\n if (r > t0) t0 = r;\n } else if (dy > 0) {\n if (r < t0) return;\n if (r < t1) t1 = r;\n }\n\n if (!(t0 > 0) && !(t1 < 1)) return true; // TODO Better check?\n\n if (t0 > 0) edge[0] = [ax + t0 * dx, ay + t0 * dy];\n if (t1 < 1) edge[1] = [ax + t1 * dx, ay + t1 * dy];\n return true;\n}\n\nfunction connectEdge(edge, x0, y0, x1, y1) {\n var v1 = edge[1];\n if (v1) return true;\n\n var v0 = edge[0],\n left = edge.left,\n right = edge.right,\n lx = left[0],\n ly = left[1],\n rx = right[0],\n ry = right[1],\n fx = (lx + rx) / 2,\n fy = (ly + ry) / 2,\n fm,\n fb;\n\n if (ry === ly) {\n if (fx < x0 || fx >= x1) return;\n if (lx > rx) {\n if (!v0) v0 = [fx, y0];\n else if (v0[1] >= y1) return;\n v1 = [fx, y1];\n } else {\n if (!v0) v0 = [fx, y1];\n else if (v0[1] < y0) return;\n v1 = [fx, y0];\n }\n } else {\n fm = (lx - rx) / (ry - ly);\n fb = fy - fm * fx;\n if (fm < -1 || fm > 1) {\n if (lx > rx) {\n if (!v0) v0 = [(y0 - fb) / fm, y0];\n else if (v0[1] >= y1) return;\n v1 = [(y1 - fb) / fm, y1];\n } else {\n if (!v0) v0 = [(y1 - fb) / fm, y1];\n else if (v0[1] < y0) return;\n v1 = [(y0 - fb) / fm, y0];\n }\n } else {\n if (ly < ry) {\n if (!v0) v0 = [x0, fm * x0 + fb];\n else if (v0[0] >= x1) return;\n v1 = [x1, fm * x1 + fb];\n } else {\n if (!v0) v0 = [x1, fm * x1 + fb];\n else if (v0[0] < x0) return;\n v1 = [x0, fm * x0 + fb];\n }\n }\n }\n\n edge[0] = v0;\n edge[1] = v1;\n return true;\n}\n\nfunction clipEdges(x0, y0, x1, y1) {\n var i = edges.length,\n edge;\n\n while (i--) {\n if (!connectEdge(edge = edges[i], x0, y0, x1, y1)\n || !clipEdge(edge, x0, y0, x1, y1)\n || !(Math.abs(edge[0][0] - edge[1][0]) > epsilon$4\n || Math.abs(edge[0][1] - edge[1][1]) > epsilon$4)) {\n delete edges[i];\n }\n }\n}\n\nfunction createCell(site) {\n return cells[site.index] = {\n site: site,\n halfedges: []\n };\n}\n\nfunction cellHalfedgeAngle(cell, edge) {\n var site = cell.site,\n va = edge.left,\n vb = edge.right;\n if (site === vb) vb = va, va = site;\n if (vb) return Math.atan2(vb[1] - va[1], vb[0] - va[0]);\n if (site === va) va = edge[1], vb = edge[0];\n else va = edge[0], vb = edge[1];\n return Math.atan2(va[0] - vb[0], vb[1] - va[1]);\n}\n\nfunction cellHalfedgeStart(cell, edge) {\n return edge[+(edge.left !== cell.site)];\n}\n\nfunction cellHalfedgeEnd(cell, edge) {\n return edge[+(edge.left === cell.site)];\n}\n\nfunction sortCellHalfedges() {\n for (var i = 0, n = cells.length, cell, halfedges, j, m; i < n; ++i) {\n if ((cell = cells[i]) && (m = (halfedges = cell.halfedges).length)) {\n var index = new Array(m),\n array = new Array(m);\n for (j = 0; j < m; ++j) index[j] = j, array[j] = cellHalfedgeAngle(cell, edges[halfedges[j]]);\n index.sort(function(i, j) { return array[j] - array[i]; });\n for (j = 0; j < m; ++j) array[j] = halfedges[index[j]];\n for (j = 0; j < m; ++j) halfedges[j] = array[j];\n }\n }\n}\n\nfunction clipCells(x0, y0, x1, y1) {\n var nCells = cells.length,\n iCell,\n cell,\n site,\n iHalfedge,\n halfedges,\n nHalfedges,\n start,\n startX,\n startY,\n end,\n endX,\n endY,\n cover = true;\n\n for (iCell = 0; iCell < nCells; ++iCell) {\n if (cell = cells[iCell]) {\n site = cell.site;\n halfedges = cell.halfedges;\n iHalfedge = halfedges.length;\n\n // Remove any dangling clipped edges.\n while (iHalfedge--) {\n if (!edges[halfedges[iHalfedge]]) {\n halfedges.splice(iHalfedge, 1);\n }\n }\n\n // Insert any border edges as necessary.\n iHalfedge = 0, nHalfedges = halfedges.length;\n while (iHalfedge < nHalfedges) {\n end = cellHalfedgeEnd(cell, edges[halfedges[iHalfedge]]), endX = end[0], endY = end[1];\n start = cellHalfedgeStart(cell, edges[halfedges[++iHalfedge % nHalfedges]]), startX = start[0], startY = start[1];\n if (Math.abs(endX - startX) > epsilon$4 || Math.abs(endY - startY) > epsilon$4) {\n halfedges.splice(iHalfedge, 0, edges.push(createBorderEdge(site, end,\n Math.abs(endX - x0) < epsilon$4 && y1 - endY > epsilon$4 ? [x0, Math.abs(startX - x0) < epsilon$4 ? startY : y1]\n : Math.abs(endY - y1) < epsilon$4 && x1 - endX > epsilon$4 ? [Math.abs(startY - y1) < epsilon$4 ? startX : x1, y1]\n : Math.abs(endX - x1) < epsilon$4 && endY - y0 > epsilon$4 ? [x1, Math.abs(startX - x1) < epsilon$4 ? startY : y0]\n : Math.abs(endY - y0) < epsilon$4 && endX - x0 > epsilon$4 ? [Math.abs(startY - y0) < epsilon$4 ? startX : x0, y0]\n : null)) - 1);\n ++nHalfedges;\n }\n }\n\n if (nHalfedges) cover = false;\n }\n }\n\n // If there weren’t any edges, have the closest site cover the extent.\n // It doesn’t matter which corner of the extent we measure!\n if (cover) {\n var dx, dy, d2, dc = Infinity;\n\n for (iCell = 0, cover = null; iCell < nCells; ++iCell) {\n if (cell = cells[iCell]) {\n site = cell.site;\n dx = site[0] - x0;\n dy = site[1] - y0;\n d2 = dx * dx + dy * dy;\n if (d2 < dc) dc = d2, cover = cell;\n }\n }\n\n if (cover) {\n var v00 = [x0, y0], v01 = [x0, y1], v11 = [x1, y1], v10 = [x1, y0];\n cover.halfedges.push(\n edges.push(createBorderEdge(site = cover.site, v00, v01)) - 1,\n edges.push(createBorderEdge(site, v01, v11)) - 1,\n edges.push(createBorderEdge(site, v11, v10)) - 1,\n edges.push(createBorderEdge(site, v10, v00)) - 1\n );\n }\n }\n\n // Lastly delete any cells with no edges; these were entirely clipped.\n for (iCell = 0; iCell < nCells; ++iCell) {\n if (cell = cells[iCell]) {\n if (!cell.halfedges.length) {\n delete cells[iCell];\n }\n }\n }\n}\n\nvar circlePool = [];\n\nvar firstCircle;\n\nfunction Circle() {\n RedBlackNode(this);\n this.x =\n this.y =\n this.arc =\n this.site =\n this.cy = null;\n}\n\nfunction attachCircle(arc) {\n var lArc = arc.P,\n rArc = arc.N;\n\n if (!lArc || !rArc) return;\n\n var lSite = lArc.site,\n cSite = arc.site,\n rSite = rArc.site;\n\n if (lSite === rSite) return;\n\n var bx = cSite[0],\n by = cSite[1],\n ax = lSite[0] - bx,\n ay = lSite[1] - by,\n cx = rSite[0] - bx,\n cy = rSite[1] - by;\n\n var d = 2 * (ax * cy - ay * cx);\n if (d >= -epsilon2$2) return;\n\n var ha = ax * ax + ay * ay,\n hc = cx * cx + cy * cy,\n x = (cy * ha - ay * hc) / d,\n y = (ax * hc - cx * ha) / d;\n\n var circle = circlePool.pop() || new Circle;\n circle.arc = arc;\n circle.site = cSite;\n circle.x = x + bx;\n circle.y = (circle.cy = y + by) + Math.sqrt(x * x + y * y); // y bottom\n\n arc.circle = circle;\n\n var before = null,\n node = circles._;\n\n while (node) {\n if (circle.y < node.y || (circle.y === node.y && circle.x <= node.x)) {\n if (node.L) node = node.L;\n else { before = node.P; break; }\n } else {\n if (node.R) node = node.R;\n else { before = node; break; }\n }\n }\n\n circles.insert(before, circle);\n if (!before) firstCircle = circle;\n}\n\nfunction detachCircle(arc) {\n var circle = arc.circle;\n if (circle) {\n if (!circle.P) firstCircle = circle.N;\n circles.remove(circle);\n circlePool.push(circle);\n RedBlackNode(circle);\n arc.circle = null;\n }\n}\n\nvar beachPool = [];\n\nfunction Beach() {\n RedBlackNode(this);\n this.edge =\n this.site =\n this.circle = null;\n}\n\nfunction createBeach(site) {\n var beach = beachPool.pop() || new Beach;\n beach.site = site;\n return beach;\n}\n\nfunction detachBeach(beach) {\n detachCircle(beach);\n beaches.remove(beach);\n beachPool.push(beach);\n RedBlackNode(beach);\n}\n\nfunction removeBeach(beach) {\n var circle = beach.circle,\n x = circle.x,\n y = circle.cy,\n vertex = [x, y],\n previous = beach.P,\n next = beach.N,\n disappearing = [beach];\n\n detachBeach(beach);\n\n var lArc = previous;\n while (lArc.circle\n && Math.abs(x - lArc.circle.x) < epsilon$4\n && Math.abs(y - lArc.circle.cy) < epsilon$4) {\n previous = lArc.P;\n disappearing.unshift(lArc);\n detachBeach(lArc);\n lArc = previous;\n }\n\n disappearing.unshift(lArc);\n detachCircle(lArc);\n\n var rArc = next;\n while (rArc.circle\n && Math.abs(x - rArc.circle.x) < epsilon$4\n && Math.abs(y - rArc.circle.cy) < epsilon$4) {\n next = rArc.N;\n disappearing.push(rArc);\n detachBeach(rArc);\n rArc = next;\n }\n\n disappearing.push(rArc);\n detachCircle(rArc);\n\n var nArcs = disappearing.length,\n iArc;\n for (iArc = 1; iArc < nArcs; ++iArc) {\n rArc = disappearing[iArc];\n lArc = disappearing[iArc - 1];\n setEdgeEnd(rArc.edge, lArc.site, rArc.site, vertex);\n }\n\n lArc = disappearing[0];\n rArc = disappearing[nArcs - 1];\n rArc.edge = createEdge(lArc.site, rArc.site, null, vertex);\n\n attachCircle(lArc);\n attachCircle(rArc);\n}\n\nfunction addBeach(site) {\n var x = site[0],\n directrix = site[1],\n lArc,\n rArc,\n dxl,\n dxr,\n node = beaches._;\n\n while (node) {\n dxl = leftBreakPoint(node, directrix) - x;\n if (dxl > epsilon$4) node = node.L; else {\n dxr = x - rightBreakPoint(node, directrix);\n if (dxr > epsilon$4) {\n if (!node.R) {\n lArc = node;\n break;\n }\n node = node.R;\n } else {\n if (dxl > -epsilon$4) {\n lArc = node.P;\n rArc = node;\n } else if (dxr > -epsilon$4) {\n lArc = node;\n rArc = node.N;\n } else {\n lArc = rArc = node;\n }\n break;\n }\n }\n }\n\n createCell(site);\n var newArc = createBeach(site);\n beaches.insert(lArc, newArc);\n\n if (!lArc && !rArc) return;\n\n if (lArc === rArc) {\n detachCircle(lArc);\n rArc = createBeach(lArc.site);\n beaches.insert(newArc, rArc);\n newArc.edge = rArc.edge = createEdge(lArc.site, newArc.site);\n attachCircle(lArc);\n attachCircle(rArc);\n return;\n }\n\n if (!rArc) { // && lArc\n newArc.edge = createEdge(lArc.site, newArc.site);\n return;\n }\n\n // else lArc !== rArc\n detachCircle(lArc);\n detachCircle(rArc);\n\n var lSite = lArc.site,\n ax = lSite[0],\n ay = lSite[1],\n bx = site[0] - ax,\n by = site[1] - ay,\n rSite = rArc.site,\n cx = rSite[0] - ax,\n cy = rSite[1] - ay,\n d = 2 * (bx * cy - by * cx),\n hb = bx * bx + by * by,\n hc = cx * cx + cy * cy,\n vertex = [(cy * hb - by * hc) / d + ax, (bx * hc - cx * hb) / d + ay];\n\n setEdgeEnd(rArc.edge, lSite, rSite, vertex);\n newArc.edge = createEdge(lSite, site, null, vertex);\n rArc.edge = createEdge(site, rSite, null, vertex);\n attachCircle(lArc);\n attachCircle(rArc);\n}\n\nfunction leftBreakPoint(arc, directrix) {\n var site = arc.site,\n rfocx = site[0],\n rfocy = site[1],\n pby2 = rfocy - directrix;\n\n if (!pby2) return rfocx;\n\n var lArc = arc.P;\n if (!lArc) return -Infinity;\n\n site = lArc.site;\n var lfocx = site[0],\n lfocy = site[1],\n plby2 = lfocy - directrix;\n\n if (!plby2) return lfocx;\n\n var hl = lfocx - rfocx,\n aby2 = 1 / pby2 - 1 / plby2,\n b = hl / plby2;\n\n if (aby2) return (-b + Math.sqrt(b * b - 2 * aby2 * (hl * hl / (-2 * plby2) - lfocy + plby2 / 2 + rfocy - pby2 / 2))) / aby2 + rfocx;\n\n return (rfocx + lfocx) / 2;\n}\n\nfunction rightBreakPoint(arc, directrix) {\n var rArc = arc.N;\n if (rArc) return leftBreakPoint(rArc, directrix);\n var site = arc.site;\n return site[1] === directrix ? site[0] : Infinity;\n}\n\nvar epsilon$4 = 1e-6;\nvar epsilon2$2 = 1e-12;\nvar beaches;\nvar cells;\nvar circles;\nvar edges;\n\nfunction triangleArea(a, b, c) {\n return (a[0] - c[0]) * (b[1] - a[1]) - (a[0] - b[0]) * (c[1] - a[1]);\n}\n\nfunction lexicographic(a, b) {\n return b[1] - a[1]\n || b[0] - a[0];\n}\n\nfunction Diagram(sites, extent) {\n var site = sites.sort(lexicographic).pop(),\n x,\n y,\n circle;\n\n edges = [];\n cells = new Array(sites.length);\n beaches = new RedBlackTree;\n circles = new RedBlackTree;\n\n while (true) {\n circle = firstCircle;\n if (site && (!circle || site[1] < circle.y || (site[1] === circle.y && site[0] < circle.x))) {\n if (site[0] !== x || site[1] !== y) {\n addBeach(site);\n x = site[0], y = site[1];\n }\n site = sites.pop();\n } else if (circle) {\n removeBeach(circle.arc);\n } else {\n break;\n }\n }\n\n sortCellHalfedges();\n\n if (extent) {\n var x0 = +extent[0][0],\n y0 = +extent[0][1],\n x1 = +extent[1][0],\n y1 = +extent[1][1];\n clipEdges(x0, y0, x1, y1);\n clipCells(x0, y0, x1, y1);\n }\n\n this.edges = edges;\n this.cells = cells;\n\n beaches =\n circles =\n edges =\n cells = null;\n}\n\nDiagram.prototype = {\n constructor: Diagram,\n\n polygons: function() {\n var edges = this.edges;\n\n return this.cells.map(function(cell) {\n var polygon = cell.halfedges.map(function(i) { return cellHalfedgeStart(cell, edges[i]); });\n polygon.data = cell.site.data;\n return polygon;\n });\n },\n\n triangles: function() {\n var triangles = [],\n edges = this.edges;\n\n this.cells.forEach(function(cell, i) {\n if (!(m = (halfedges = cell.halfedges).length)) return;\n var site = cell.site,\n halfedges,\n j = -1,\n m,\n s0,\n e1 = edges[halfedges[m - 1]],\n s1 = e1.left === site ? e1.right : e1.left;\n\n while (++j < m) {\n s0 = s1;\n e1 = edges[halfedges[j]];\n s1 = e1.left === site ? e1.right : e1.left;\n if (s0 && s1 && i < s0.index && i < s1.index && triangleArea(site, s0, s1) < 0) {\n triangles.push([site.data, s0.data, s1.data]);\n }\n }\n });\n\n return triangles;\n },\n\n links: function() {\n return this.edges.filter(function(edge) {\n return edge.right;\n }).map(function(edge) {\n return {\n source: edge.left.data,\n target: edge.right.data\n };\n });\n },\n\n find: function(x, y, radius) {\n var that = this, i0, i1 = that._found || 0, n = that.cells.length, cell;\n\n // Use the previously-found cell, or start with an arbitrary one.\n while (!(cell = that.cells[i1])) if (++i1 >= n) return null;\n var dx = x - cell.site[0], dy = y - cell.site[1], d2 = dx * dx + dy * dy;\n\n // Traverse the half-edges to find a closer cell, if any.\n do {\n cell = that.cells[i0 = i1], i1 = null;\n cell.halfedges.forEach(function(e) {\n var edge = that.edges[e], v = edge.left;\n if ((v === cell.site || !v) && !(v = edge.right)) return;\n var vx = x - v[0], vy = y - v[1], v2 = vx * vx + vy * vy;\n if (v2 < d2) d2 = v2, i1 = v.index;\n });\n } while (i1 !== null);\n\n that._found = i0;\n\n return radius == null || d2 <= radius * radius ? cell.site : null;\n }\n};\n\nvar voronoi = function() {\n var x$$1 = x$4,\n y$$1 = y$4,\n extent = null;\n\n function voronoi(data) {\n return new Diagram(data.map(function(d, i) {\n var s = [Math.round(x$$1(d, i, data) / epsilon$4) * epsilon$4, Math.round(y$$1(d, i, data) / epsilon$4) * epsilon$4];\n s.index = i;\n s.data = d;\n return s;\n }), extent);\n }\n\n voronoi.polygons = function(data) {\n return voronoi(data).polygons();\n };\n\n voronoi.links = function(data) {\n return voronoi(data).links();\n };\n\n voronoi.triangles = function(data) {\n return voronoi(data).triangles();\n };\n\n voronoi.x = function(_) {\n return arguments.length ? (x$$1 = typeof _ === \"function\" ? _ : constant$11(+_), voronoi) : x$$1;\n };\n\n voronoi.y = function(_) {\n return arguments.length ? (y$$1 = typeof _ === \"function\" ? _ : constant$11(+_), voronoi) : y$$1;\n };\n\n voronoi.extent = function(_) {\n return arguments.length ? (extent = _ == null ? null : [[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]], voronoi) : extent && [[extent[0][0], extent[0][1]], [extent[1][0], extent[1][1]]];\n };\n\n voronoi.size = function(_) {\n return arguments.length ? (extent = _ == null ? null : [[0, 0], [+_[0], +_[1]]], voronoi) : extent && [extent[1][0] - extent[0][0], extent[1][1] - extent[0][1]];\n };\n\n return voronoi;\n};\n\nvar constant$12 = function(x) {\n return function() {\n return x;\n };\n};\n\nfunction ZoomEvent(target, type, transform) {\n this.target = target;\n this.type = type;\n this.transform = transform;\n}\n\nfunction Transform(k, x, y) {\n this.k = k;\n this.x = x;\n this.y = y;\n}\n\nTransform.prototype = {\n constructor: Transform,\n scale: function(k) {\n return k === 1 ? this : new Transform(this.k * k, this.x, this.y);\n },\n translate: function(x, y) {\n return x === 0 & y === 0 ? this : new Transform(this.k, this.x + this.k * x, this.y + this.k * y);\n },\n apply: function(point) {\n return [point[0] * this.k + this.x, point[1] * this.k + this.y];\n },\n applyX: function(x) {\n return x * this.k + this.x;\n },\n applyY: function(y) {\n return y * this.k + this.y;\n },\n invert: function(location) {\n return [(location[0] - this.x) / this.k, (location[1] - this.y) / this.k];\n },\n invertX: function(x) {\n return (x - this.x) / this.k;\n },\n invertY: function(y) {\n return (y - this.y) / this.k;\n },\n rescaleX: function(x) {\n return x.copy().domain(x.range().map(this.invertX, this).map(x.invert, x));\n },\n rescaleY: function(y) {\n return y.copy().domain(y.range().map(this.invertY, this).map(y.invert, y));\n },\n toString: function() {\n return \"translate(\" + this.x + \",\" + this.y + \") scale(\" + this.k + \")\";\n }\n};\n\nvar identity$8 = new Transform(1, 0, 0);\n\ntransform$1.prototype = Transform.prototype;\n\nfunction transform$1(node) {\n return node.__zoom || identity$8;\n}\n\nfunction nopropagation$2() {\n exports.event.stopImmediatePropagation();\n}\n\nvar noevent$2 = function() {\n exports.event.preventDefault();\n exports.event.stopImmediatePropagation();\n};\n\n// Ignore right-click, since that should open the context menu.\nfunction defaultFilter$2() {\n return !exports.event.button;\n}\n\nfunction defaultExtent$1() {\n var e = this, w, h;\n if (e instanceof SVGElement) {\n e = e.ownerSVGElement || e;\n w = e.width.baseVal.value;\n h = e.height.baseVal.value;\n } else {\n w = e.clientWidth;\n h = e.clientHeight;\n }\n return [[0, 0], [w, h]];\n}\n\nfunction defaultTransform() {\n return this.__zoom || identity$8;\n}\n\nvar zoom = function() {\n var filter = defaultFilter$2,\n extent = defaultExtent$1,\n k0 = 0,\n k1 = Infinity,\n x0 = -k1,\n x1 = k1,\n y0 = x0,\n y1 = x1,\n duration = 250,\n interpolate$$1 = interpolateZoom,\n gestures = [],\n listeners = dispatch(\"start\", \"zoom\", \"end\"),\n touchstarting,\n touchending,\n touchDelay = 500,\n wheelDelay = 150;\n\n function zoom(selection$$1) {\n selection$$1\n .on(\"wheel.zoom\", wheeled)\n .on(\"mousedown.zoom\", mousedowned)\n .on(\"dblclick.zoom\", dblclicked)\n .on(\"touchstart.zoom\", touchstarted)\n .on(\"touchmove.zoom\", touchmoved)\n .on(\"touchend.zoom touchcancel.zoom\", touchended)\n .style(\"-webkit-tap-highlight-color\", \"rgba(0,0,0,0)\")\n .property(\"__zoom\", defaultTransform);\n }\n\n zoom.transform = function(collection, transform) {\n var selection$$1 = collection.selection ? collection.selection() : collection;\n selection$$1.property(\"__zoom\", defaultTransform);\n if (collection !== selection$$1) {\n schedule(collection, transform);\n } else {\n selection$$1.interrupt().each(function() {\n gesture(this, arguments)\n .start()\n .zoom(null, typeof transform === \"function\" ? transform.apply(this, arguments) : transform)\n .end();\n });\n }\n };\n\n zoom.scaleBy = function(selection$$1, k) {\n zoom.scaleTo(selection$$1, function() {\n var k0 = this.__zoom.k,\n k1 = typeof k === \"function\" ? k.apply(this, arguments) : k;\n return k0 * k1;\n });\n };\n\n zoom.scaleTo = function(selection$$1, k) {\n zoom.transform(selection$$1, function() {\n var e = extent.apply(this, arguments),\n t0 = this.__zoom,\n p0 = centroid(e),\n p1 = t0.invert(p0),\n k1 = typeof k === \"function\" ? k.apply(this, arguments) : k;\n return constrain(translate(scale(t0, k1), p0, p1), e);\n });\n };\n\n zoom.translateBy = function(selection$$1, x, y) {\n zoom.transform(selection$$1, function() {\n return constrain(this.__zoom.translate(\n typeof x === \"function\" ? x.apply(this, arguments) : x,\n typeof y === \"function\" ? y.apply(this, arguments) : y\n ), extent.apply(this, arguments));\n });\n };\n\n function scale(transform, k) {\n k = Math.max(k0, Math.min(k1, k));\n return k === transform.k ? transform : new Transform(k, transform.x, transform.y);\n }\n\n function translate(transform, p0, p1) {\n var x = p0[0] - p1[0] * transform.k, y = p0[1] - p1[1] * transform.k;\n return x === transform.x && y === transform.y ? transform : new Transform(transform.k, x, y);\n }\n\n function constrain(transform, extent) {\n var dx0 = transform.invertX(extent[0][0]) - x0,\n dx1 = transform.invertX(extent[1][0]) - x1,\n dy0 = transform.invertY(extent[0][1]) - y0,\n dy1 = transform.invertY(extent[1][1]) - y1;\n return transform.translate(\n dx1 > dx0 ? (dx0 + dx1) / 2 : Math.min(0, dx0) || Math.max(0, dx1),\n dy1 > dy0 ? (dy0 + dy1) / 2 : Math.min(0, dy0) || Math.max(0, dy1)\n );\n }\n\n function centroid(extent) {\n return [(+extent[0][0] + +extent[1][0]) / 2, (+extent[0][1] + +extent[1][1]) / 2];\n }\n\n function schedule(transition$$1, transform, center) {\n transition$$1\n .on(\"start.zoom\", function() { gesture(this, arguments).start(); })\n .on(\"interrupt.zoom end.zoom\", function() { gesture(this, arguments).end(); })\n .tween(\"zoom\", function() {\n var that = this,\n args = arguments,\n g = gesture(that, args),\n e = extent.apply(that, args),\n p = center || centroid(e),\n w = Math.max(e[1][0] - e[0][0], e[1][1] - e[0][1]),\n a = that.__zoom,\n b = typeof transform === \"function\" ? transform.apply(that, args) : transform,\n i = interpolate$$1(a.invert(p).concat(w / a.k), b.invert(p).concat(w / b.k));\n return function(t) {\n if (t === 1) t = b; // Avoid rounding error on end.\n else { var l = i(t), k = w / l[2]; t = new Transform(k, p[0] - l[0] * k, p[1] - l[1] * k); }\n g.zoom(null, t);\n };\n });\n }\n\n function gesture(that, args) {\n for (var i = 0, n = gestures.length, g; i < n; ++i) {\n if ((g = gestures[i]).that === that) {\n return g;\n }\n }\n return new Gesture(that, args);\n }\n\n function Gesture(that, args) {\n this.that = that;\n this.args = args;\n this.index = -1;\n this.active = 0;\n this.extent = extent.apply(that, args);\n }\n\n Gesture.prototype = {\n start: function() {\n if (++this.active === 1) {\n this.index = gestures.push(this) - 1;\n this.emit(\"start\");\n }\n return this;\n },\n zoom: function(key, transform) {\n if (this.mouse && key !== \"mouse\") this.mouse[1] = transform.invert(this.mouse[0]);\n if (this.touch0 && key !== \"touch\") this.touch0[1] = transform.invert(this.touch0[0]);\n if (this.touch1 && key !== \"touch\") this.touch1[1] = transform.invert(this.touch1[0]);\n this.that.__zoom = transform;\n this.emit(\"zoom\");\n return this;\n },\n end: function() {\n if (--this.active === 0) {\n gestures.splice(this.index, 1);\n this.index = -1;\n this.emit(\"end\");\n }\n return this;\n },\n emit: function(type) {\n customEvent(new ZoomEvent(zoom, type, this.that.__zoom), listeners.apply, listeners, [type, this.that, this.args]);\n }\n };\n\n function wheeled() {\n if (!filter.apply(this, arguments)) return;\n var g = gesture(this, arguments),\n t = this.__zoom,\n k = Math.max(k0, Math.min(k1, t.k * Math.pow(2, -exports.event.deltaY * (exports.event.deltaMode ? 120 : 1) / 500))),\n p = mouse(this);\n\n // If the mouse is in the same location as before, reuse it.\n // If there were recent wheel events, reset the wheel idle timeout.\n if (g.wheel) {\n if (g.mouse[0][0] !== p[0] || g.mouse[0][1] !== p[1]) {\n g.mouse[1] = t.invert(g.mouse[0] = p);\n }\n clearTimeout(g.wheel);\n }\n\n // If this wheel event won’t trigger a transform change, ignore it.\n else if (t.k === k) return;\n\n // Otherwise, capture the mouse point and location at the start.\n else {\n g.mouse = [p, t.invert(p)];\n interrupt(this);\n g.start();\n }\n\n noevent$2();\n g.wheel = setTimeout(wheelidled, wheelDelay);\n g.zoom(\"mouse\", constrain(translate(scale(t, k), g.mouse[0], g.mouse[1]), g.extent));\n\n function wheelidled() {\n g.wheel = null;\n g.end();\n }\n }\n\n function mousedowned() {\n if (touchending || !filter.apply(this, arguments)) return;\n var g = gesture(this, arguments),\n v = select(exports.event.view).on(\"mousemove.zoom\", mousemoved, true).on(\"mouseup.zoom\", mouseupped, true),\n p = mouse(this);\n\n dragDisable(exports.event.view);\n nopropagation$2();\n g.mouse = [p, this.__zoom.invert(p)];\n interrupt(this);\n g.start();\n\n function mousemoved() {\n noevent$2();\n g.moved = true;\n g.zoom(\"mouse\", constrain(translate(g.that.__zoom, g.mouse[0] = mouse(g.that), g.mouse[1]), g.extent));\n }\n\n function mouseupped() {\n v.on(\"mousemove.zoom mouseup.zoom\", null);\n yesdrag(exports.event.view, g.moved);\n noevent$2();\n g.end();\n }\n }\n\n function dblclicked() {\n if (!filter.apply(this, arguments)) return;\n var t0 = this.__zoom,\n p0 = mouse(this),\n p1 = t0.invert(p0),\n k1 = t0.k * (exports.event.shiftKey ? 0.5 : 2),\n t1 = constrain(translate(scale(t0, k1), p0, p1), extent.apply(this, arguments));\n\n noevent$2();\n if (duration > 0) select(this).transition().duration(duration).call(schedule, t1, p0);\n else select(this).call(zoom.transform, t1);\n }\n\n function touchstarted() {\n if (!filter.apply(this, arguments)) return;\n var g = gesture(this, arguments),\n touches$$1 = exports.event.changedTouches,\n started,\n n = touches$$1.length, i, t, p;\n\n nopropagation$2();\n for (i = 0; i < n; ++i) {\n t = touches$$1[i], p = touch(this, touches$$1, t.identifier);\n p = [p, this.__zoom.invert(p), t.identifier];\n if (!g.touch0) g.touch0 = p, started = true;\n else if (!g.touch1) g.touch1 = p;\n }\n\n // If this is a dbltap, reroute to the (optional) dblclick.zoom handler.\n if (touchstarting) {\n touchstarting = clearTimeout(touchstarting);\n if (!g.touch1) {\n g.end();\n p = select(this).on(\"dblclick.zoom\");\n if (p) p.apply(this, arguments);\n return;\n }\n }\n\n if (started) {\n touchstarting = setTimeout(function() { touchstarting = null; }, touchDelay);\n interrupt(this);\n g.start();\n }\n }\n\n function touchmoved() {\n var g = gesture(this, arguments),\n touches$$1 = exports.event.changedTouches,\n n = touches$$1.length, i, t, p, l;\n\n noevent$2();\n if (touchstarting) touchstarting = clearTimeout(touchstarting);\n for (i = 0; i < n; ++i) {\n t = touches$$1[i], p = touch(this, touches$$1, t.identifier);\n if (g.touch0 && g.touch0[2] === t.identifier) g.touch0[0] = p;\n else if (g.touch1 && g.touch1[2] === t.identifier) g.touch1[0] = p;\n }\n t = g.that.__zoom;\n if (g.touch1) {\n var p0 = g.touch0[0], l0 = g.touch0[1],\n p1 = g.touch1[0], l1 = g.touch1[1],\n dp = (dp = p1[0] - p0[0]) * dp + (dp = p1[1] - p0[1]) * dp,\n dl = (dl = l1[0] - l0[0]) * dl + (dl = l1[1] - l0[1]) * dl;\n t = scale(t, Math.sqrt(dp / dl));\n p = [(p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2];\n l = [(l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2];\n }\n else if (g.touch0) p = g.touch0[0], l = g.touch0[1];\n else return;\n g.zoom(\"touch\", constrain(translate(t, p, l), g.extent));\n }\n\n function touchended() {\n var g = gesture(this, arguments),\n touches$$1 = exports.event.changedTouches,\n n = touches$$1.length, i, t;\n\n nopropagation$2();\n if (touchending) clearTimeout(touchending);\n touchending = setTimeout(function() { touchending = null; }, touchDelay);\n for (i = 0; i < n; ++i) {\n t = touches$$1[i];\n if (g.touch0 && g.touch0[2] === t.identifier) delete g.touch0;\n else if (g.touch1 && g.touch1[2] === t.identifier) delete g.touch1;\n }\n if (g.touch1 && !g.touch0) g.touch0 = g.touch1, delete g.touch1;\n if (!g.touch0) g.end();\n }\n\n zoom.filter = function(_) {\n return arguments.length ? (filter = typeof _ === \"function\" ? _ : constant$12(!!_), zoom) : filter;\n };\n\n zoom.extent = function(_) {\n return arguments.length ? (extent = typeof _ === \"function\" ? _ : constant$12([[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]]), zoom) : extent;\n };\n\n zoom.scaleExtent = function(_) {\n return arguments.length ? (k0 = +_[0], k1 = +_[1], zoom) : [k0, k1];\n };\n\n zoom.translateExtent = function(_) {\n return arguments.length ? (x0 = +_[0][0], x1 = +_[1][0], y0 = +_[0][1], y1 = +_[1][1], zoom) : [[x0, y0], [x1, y1]];\n };\n\n zoom.duration = function(_) {\n return arguments.length ? (duration = +_, zoom) : duration;\n };\n\n zoom.interpolate = function(_) {\n return arguments.length ? (interpolate$$1 = _, zoom) : interpolate$$1;\n };\n\n zoom.on = function() {\n var value = listeners.on.apply(listeners, arguments);\n return value === listeners ? zoom : value;\n };\n\n return zoom;\n};\n\nexports.version = version;\nexports.bisect = bisectRight;\nexports.bisectRight = bisectRight;\nexports.bisectLeft = bisectLeft;\nexports.ascending = ascending;\nexports.bisector = bisector;\nexports.descending = descending;\nexports.deviation = deviation;\nexports.extent = extent;\nexports.histogram = histogram;\nexports.thresholdFreedmanDiaconis = freedmanDiaconis;\nexports.thresholdScott = scott;\nexports.thresholdSturges = sturges;\nexports.max = max;\nexports.mean = mean;\nexports.median = median;\nexports.merge = merge;\nexports.min = min;\nexports.pairs = pairs;\nexports.permute = permute;\nexports.quantile = threshold;\nexports.range = sequence;\nexports.scan = scan;\nexports.shuffle = shuffle;\nexports.sum = sum;\nexports.ticks = ticks;\nexports.tickStep = tickStep;\nexports.transpose = transpose;\nexports.variance = variance;\nexports.zip = zip;\nexports.axisTop = axisTop;\nexports.axisRight = axisRight;\nexports.axisBottom = axisBottom;\nexports.axisLeft = axisLeft;\nexports.brush = brush;\nexports.brushX = brushX;\nexports.brushY = brushY;\nexports.brushSelection = brushSelection;\nexports.chord = chord;\nexports.ribbon = ribbon;\nexports.nest = nest;\nexports.set = set$2;\nexports.map = map$1;\nexports.keys = keys;\nexports.values = values;\nexports.entries = entries;\nexports.color = color;\nexports.rgb = rgb;\nexports.hsl = hsl;\nexports.lab = lab;\nexports.hcl = hcl;\nexports.cubehelix = cubehelix;\nexports.dispatch = dispatch;\nexports.drag = drag;\nexports.dragDisable = dragDisable;\nexports.dragEnable = yesdrag;\nexports.dsvFormat = dsv;\nexports.csvParse = csvParse;\nexports.csvParseRows = csvParseRows;\nexports.csvFormat = csvFormat;\nexports.csvFormatRows = csvFormatRows;\nexports.tsvParse = tsvParse;\nexports.tsvParseRows = tsvParseRows;\nexports.tsvFormat = tsvFormat;\nexports.tsvFormatRows = tsvFormatRows;\nexports.easeLinear = linear$1;\nexports.easeQuad = quadInOut;\nexports.easeQuadIn = quadIn;\nexports.easeQuadOut = quadOut;\nexports.easeQuadInOut = quadInOut;\nexports.easeCubic = cubicInOut;\nexports.easeCubicIn = cubicIn;\nexports.easeCubicOut = cubicOut;\nexports.easeCubicInOut = cubicInOut;\nexports.easePoly = polyInOut;\nexports.easePolyIn = polyIn;\nexports.easePolyOut = polyOut;\nexports.easePolyInOut = polyInOut;\nexports.easeSin = sinInOut;\nexports.easeSinIn = sinIn;\nexports.easeSinOut = sinOut;\nexports.easeSinInOut = sinInOut;\nexports.easeExp = expInOut;\nexports.easeExpIn = expIn;\nexports.easeExpOut = expOut;\nexports.easeExpInOut = expInOut;\nexports.easeCircle = circleInOut;\nexports.easeCircleIn = circleIn;\nexports.easeCircleOut = circleOut;\nexports.easeCircleInOut = circleInOut;\nexports.easeBounce = bounceOut;\nexports.easeBounceIn = bounceIn;\nexports.easeBounceOut = bounceOut;\nexports.easeBounceInOut = bounceInOut;\nexports.easeBack = backInOut;\nexports.easeBackIn = backIn;\nexports.easeBackOut = backOut;\nexports.easeBackInOut = backInOut;\nexports.easeElastic = elasticOut;\nexports.easeElasticIn = elasticIn;\nexports.easeElasticOut = elasticOut;\nexports.easeElasticInOut = elasticInOut;\nexports.forceCenter = center$1;\nexports.forceCollide = collide;\nexports.forceLink = link;\nexports.forceManyBody = manyBody;\nexports.forceSimulation = simulation;\nexports.forceX = x$2;\nexports.forceY = y$2;\nexports.formatDefaultLocale = defaultLocale;\nexports.formatLocale = formatLocale;\nexports.formatSpecifier = formatSpecifier;\nexports.precisionFixed = precisionFixed;\nexports.precisionPrefix = precisionPrefix;\nexports.precisionRound = precisionRound;\nexports.geoArea = area;\nexports.geoBounds = bounds;\nexports.geoCentroid = centroid;\nexports.geoCircle = circle;\nexports.geoClipExtent = extent$1;\nexports.geoDistance = distance;\nexports.geoGraticule = graticule;\nexports.geoGraticule10 = graticule10;\nexports.geoInterpolate = interpolate$1;\nexports.geoLength = length$1;\nexports.geoPath = index$1;\nexports.geoAlbers = albers;\nexports.geoAlbersUsa = albersUsa;\nexports.geoAzimuthalEqualArea = azimuthalEqualArea;\nexports.geoAzimuthalEqualAreaRaw = azimuthalEqualAreaRaw;\nexports.geoAzimuthalEquidistant = azimuthalEquidistant;\nexports.geoAzimuthalEquidistantRaw = azimuthalEquidistantRaw;\nexports.geoConicConformal = conicConformal;\nexports.geoConicConformalRaw = conicConformalRaw;\nexports.geoConicEqualArea = conicEqualArea;\nexports.geoConicEqualAreaRaw = conicEqualAreaRaw;\nexports.geoConicEquidistant = conicEquidistant;\nexports.geoConicEquidistantRaw = conicEquidistantRaw;\nexports.geoEquirectangular = equirectangular;\nexports.geoEquirectangularRaw = equirectangularRaw;\nexports.geoGnomonic = gnomonic;\nexports.geoGnomonicRaw = gnomonicRaw;\nexports.geoIdentity = identity$5;\nexports.geoProjection = projection;\nexports.geoProjectionMutator = projectionMutator;\nexports.geoMercator = mercator;\nexports.geoMercatorRaw = mercatorRaw;\nexports.geoOrthographic = orthographic;\nexports.geoOrthographicRaw = orthographicRaw;\nexports.geoStereographic = stereographic;\nexports.geoStereographicRaw = stereographicRaw;\nexports.geoTransverseMercator = transverseMercator;\nexports.geoTransverseMercatorRaw = transverseMercatorRaw;\nexports.geoRotation = rotation;\nexports.geoStream = geoStream;\nexports.geoTransform = transform;\nexports.cluster = cluster;\nexports.hierarchy = hierarchy;\nexports.pack = index$2;\nexports.packSiblings = siblings;\nexports.packEnclose = enclose;\nexports.partition = partition;\nexports.stratify = stratify;\nexports.tree = tree;\nexports.treemap = index$3;\nexports.treemapBinary = binary;\nexports.treemapDice = treemapDice;\nexports.treemapSlice = treemapSlice;\nexports.treemapSliceDice = sliceDice;\nexports.treemapSquarify = squarify;\nexports.treemapResquarify = resquarify;\nexports.interpolate = interpolateValue;\nexports.interpolateArray = array$1;\nexports.interpolateBasis = basis$1;\nexports.interpolateBasisClosed = basisClosed;\nexports.interpolateDate = date;\nexports.interpolateNumber = reinterpolate;\nexports.interpolateObject = object;\nexports.interpolateRound = interpolateRound;\nexports.interpolateString = interpolateString;\nexports.interpolateTransformCss = interpolateTransformCss;\nexports.interpolateTransformSvg = interpolateTransformSvg;\nexports.interpolateZoom = interpolateZoom;\nexports.interpolateRgb = interpolateRgb;\nexports.interpolateRgbBasis = rgbBasis;\nexports.interpolateRgbBasisClosed = rgbBasisClosed;\nexports.interpolateHsl = hsl$2;\nexports.interpolateHslLong = hslLong;\nexports.interpolateLab = lab$1;\nexports.interpolateHcl = hcl$2;\nexports.interpolateHclLong = hclLong;\nexports.interpolateCubehelix = cubehelix$2;\nexports.interpolateCubehelixLong = cubehelixLong;\nexports.quantize = quantize;\nexports.path = path;\nexports.polygonArea = area$1;\nexports.polygonCentroid = centroid$1;\nexports.polygonHull = hull;\nexports.polygonContains = contains;\nexports.polygonLength = length$2;\nexports.quadtree = quadtree;\nexports.queue = queue;\nexports.randomUniform = uniform;\nexports.randomNormal = normal;\nexports.randomLogNormal = logNormal;\nexports.randomBates = bates;\nexports.randomIrwinHall = irwinHall;\nexports.randomExponential = exponential$1;\nexports.request = request;\nexports.html = html;\nexports.json = json;\nexports.text = text;\nexports.xml = xml;\nexports.csv = csv$1;\nexports.tsv = tsv$1;\nexports.scaleBand = band;\nexports.scalePoint = point$1;\nexports.scaleIdentity = identity$6;\nexports.scaleLinear = linear$2;\nexports.scaleLog = log$1;\nexports.scaleOrdinal = ordinal;\nexports.scaleImplicit = implicit;\nexports.scalePow = pow$1;\nexports.scaleSqrt = sqrt$1;\nexports.scaleQuantile = quantile$$1;\nexports.scaleQuantize = quantize$1;\nexports.scaleThreshold = threshold$1;\nexports.scaleTime = time;\nexports.scaleUtc = utcTime;\nexports.schemeCategory10 = category10;\nexports.schemeCategory20b = category20b;\nexports.schemeCategory20c = category20c;\nexports.schemeCategory20 = category20;\nexports.interpolateCubehelixDefault = cubehelix$3;\nexports.interpolateRainbow = rainbow$1;\nexports.interpolateWarm = warm;\nexports.interpolateCool = cool;\nexports.interpolateViridis = viridis;\nexports.interpolateMagma = magma;\nexports.interpolateInferno = inferno;\nexports.interpolatePlasma = plasma;\nexports.scaleSequential = sequential;\nexports.creator = creator;\nexports.local = local$1;\nexports.matcher = matcher$1;\nexports.mouse = mouse;\nexports.namespace = namespace;\nexports.namespaces = namespaces;\nexports.select = select;\nexports.selectAll = selectAll;\nexports.selection = selection;\nexports.selector = selector;\nexports.selectorAll = selectorAll;\nexports.touch = touch;\nexports.touches = touches;\nexports.window = window;\nexports.customEvent = customEvent;\nexports.arc = arc;\nexports.area = area$2;\nexports.line = line;\nexports.pie = pie;\nexports.radialArea = radialArea;\nexports.radialLine = radialLine$1;\nexports.symbol = symbol;\nexports.symbols = symbols;\nexports.symbolCircle = circle$2;\nexports.symbolCross = cross$1;\nexports.symbolDiamond = diamond;\nexports.symbolSquare = square;\nexports.symbolStar = star;\nexports.symbolTriangle = triangle;\nexports.symbolWye = wye;\nexports.curveBasisClosed = basisClosed$1;\nexports.curveBasisOpen = basisOpen;\nexports.curveBasis = basis$2;\nexports.curveBundle = bundle;\nexports.curveCardinalClosed = cardinalClosed;\nexports.curveCardinalOpen = cardinalOpen;\nexports.curveCardinal = cardinal;\nexports.curveCatmullRomClosed = catmullRomClosed;\nexports.curveCatmullRomOpen = catmullRomOpen;\nexports.curveCatmullRom = catmullRom;\nexports.curveLinearClosed = linearClosed;\nexports.curveLinear = curveLinear;\nexports.curveMonotoneX = monotoneX;\nexports.curveMonotoneY = monotoneY;\nexports.curveNatural = natural;\nexports.curveStep = step;\nexports.curveStepAfter = stepAfter;\nexports.curveStepBefore = stepBefore;\nexports.stack = stack;\nexports.stackOffsetExpand = expand;\nexports.stackOffsetNone = none$1;\nexports.stackOffsetSilhouette = silhouette;\nexports.stackOffsetWiggle = wiggle;\nexports.stackOrderAscending = ascending$2;\nexports.stackOrderDescending = descending$2;\nexports.stackOrderInsideOut = insideOut;\nexports.stackOrderNone = none$2;\nexports.stackOrderReverse = reverse;\nexports.timeInterval = newInterval;\nexports.timeMillisecond = millisecond;\nexports.timeMilliseconds = milliseconds;\nexports.utcMillisecond = millisecond;\nexports.utcMilliseconds = milliseconds;\nexports.timeSecond = second;\nexports.timeSeconds = seconds;\nexports.utcSecond = second;\nexports.utcSeconds = seconds;\nexports.timeMinute = minute;\nexports.timeMinutes = minutes;\nexports.timeHour = hour;\nexports.timeHours = hours;\nexports.timeDay = day;\nexports.timeDays = days;\nexports.timeWeek = sunday;\nexports.timeWeeks = sundays;\nexports.timeSunday = sunday;\nexports.timeSundays = sundays;\nexports.timeMonday = monday;\nexports.timeMondays = mondays;\nexports.timeTuesday = tuesday;\nexports.timeTuesdays = tuesdays;\nexports.timeWednesday = wednesday;\nexports.timeWednesdays = wednesdays;\nexports.timeThursday = thursday;\nexports.timeThursdays = thursdays;\nexports.timeFriday = friday;\nexports.timeFridays = fridays;\nexports.timeSaturday = saturday;\nexports.timeSaturdays = saturdays;\nexports.timeMonth = month;\nexports.timeMonths = months;\nexports.timeYear = year;\nexports.timeYears = years;\nexports.utcMinute = utcMinute;\nexports.utcMinutes = utcMinutes;\nexports.utcHour = utcHour;\nexports.utcHours = utcHours;\nexports.utcDay = utcDay;\nexports.utcDays = utcDays;\nexports.utcWeek = utcSunday;\nexports.utcWeeks = utcSundays;\nexports.utcSunday = utcSunday;\nexports.utcSundays = utcSundays;\nexports.utcMonday = utcMonday;\nexports.utcMondays = utcMondays;\nexports.utcTuesday = utcTuesday;\nexports.utcTuesdays = utcTuesdays;\nexports.utcWednesday = utcWednesday;\nexports.utcWednesdays = utcWednesdays;\nexports.utcThursday = utcThursday;\nexports.utcThursdays = utcThursdays;\nexports.utcFriday = utcFriday;\nexports.utcFridays = utcFridays;\nexports.utcSaturday = utcSaturday;\nexports.utcSaturdays = utcSaturdays;\nexports.utcMonth = utcMonth;\nexports.utcMonths = utcMonths;\nexports.utcYear = utcYear;\nexports.utcYears = utcYears;\nexports.timeFormatDefaultLocale = defaultLocale$1;\nexports.timeFormatLocale = formatLocale$1;\nexports.isoFormat = formatIso;\nexports.isoParse = parseIso;\nexports.now = now;\nexports.timer = timer;\nexports.timerFlush = timerFlush;\nexports.timeout = timeout$1;\nexports.interval = interval$1;\nexports.transition = transition;\nexports.active = active;\nexports.interrupt = interrupt;\nexports.voronoi = voronoi;\nexports.zoom = zoom;\nexports.zoomTransform = transform$1;\nexports.zoomIdentity = identity$8;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3/build/d3.js\n// module id = 29\n// module chunks = 0","module.exports = { \"default\": require(\"core-js/library/fn/array/from\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/array/from.js\n// module id = 38\n// module chunks = 0","\"use strict\";\n\nexports.__esModule = true;\n\nvar _from = require(\"../core-js/array/from\");\n\nvar _from2 = _interopRequireDefault(_from);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function (arr) {\n if (Array.isArray(arr)) {\n for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {\n arr2[i] = arr[i];\n }\n\n return arr2;\n } else {\n return (0, _from2.default)(arr);\n }\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/helpers/toConsumableArray.js\n// module id = 39\n// module chunks = 0","require('../../modules/es6.string.iterator');\nrequire('../../modules/es6.array.from');\nmodule.exports = require('../../modules/_core').Array.from;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/fn/array/from.js\n// module id = 40\n// module chunks = 0","module.exports = function(it){\n if(typeof it != 'function')throw TypeError(it + ' is not a function!');\n return it;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_a-function.js\n// module id = 41\n// module chunks = 0","// false -> Array#indexOf\n// true -> Array#includes\nvar toIObject = require('./_to-iobject')\n , toLength = require('./_to-length')\n , toIndex = require('./_to-index');\nmodule.exports = function(IS_INCLUDES){\n return function($this, el, fromIndex){\n var O = toIObject($this)\n , length = toLength(O.length)\n , index = toIndex(fromIndex, length)\n , value;\n // Array#includes uses SameValueZero equality algorithm\n if(IS_INCLUDES && el != el)while(length > index){\n value = O[index++];\n if(value != value)return true;\n // Array#toIndex ignores holes, Array#includes - not\n } else for(;length > index; index++)if(IS_INCLUDES || index in O){\n if(O[index] === el)return IS_INCLUDES || index || 0;\n } return !IS_INCLUDES && -1;\n };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_array-includes.js\n// module id = 42\n// module chunks = 0","// getting tag from 19.1.3.6 Object.prototype.toString()\nvar cof = require('./_cof')\n , TAG = require('./_wks')('toStringTag')\n // ES3 wrong here\n , ARG = cof(function(){ return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function(it, key){\n try {\n return it[key];\n } catch(e){ /* empty */ }\n};\n\nmodule.exports = function(it){\n var O, T, B;\n return it === undefined ? 'Undefined' : it === null ? 'Null'\n // @@toStringTag case\n : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T\n // builtinTag case\n : ARG ? cof(O)\n // ES3 arguments fallback\n : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_classof.js\n// module id = 43\n// module chunks = 0","'use strict';\nvar $defineProperty = require('./_object-dp')\n , createDesc = require('./_property-desc');\n\nmodule.exports = function(object, index, value){\n if(index in object)$defineProperty.f(object, index, createDesc(0, value));\n else object[index] = value;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_create-property.js\n// module id = 44\n// module chunks = 0","module.exports = require('./_global').document && document.documentElement;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_html.js\n// module id = 45\n// module chunks = 0","module.exports = !require('./_descriptors') && !require('./_fails')(function(){\n return Object.defineProperty(require('./_dom-create')('div'), 'a', {get: function(){ return 7; }}).a != 7;\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_ie8-dom-define.js\n// module id = 46\n// module chunks = 0","// fallback for non-array-like ES3 and non-enumerable old V8 strings\nvar cof = require('./_cof');\nmodule.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){\n return cof(it) == 'String' ? it.split('') : Object(it);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iobject.js\n// module id = 47\n// module chunks = 0","// check on default Array iterator\nvar Iterators = require('./_iterators')\n , ITERATOR = require('./_wks')('iterator')\n , ArrayProto = Array.prototype;\n\nmodule.exports = function(it){\n return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_is-array-iter.js\n// module id = 48\n// module chunks = 0","// call something on iterator step with safe closing on error\nvar anObject = require('./_an-object');\nmodule.exports = function(iterator, fn, value, entries){\n try {\n return entries ? fn(anObject(value)[0], value[1]) : fn(value);\n // 7.4.6 IteratorClose(iterator, completion)\n } catch(e){\n var ret = iterator['return'];\n if(ret !== undefined)anObject(ret.call(iterator));\n throw e;\n }\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iter-call.js\n// module id = 49\n// module chunks = 0","'use strict';\nvar create = require('./_object-create')\n , descriptor = require('./_property-desc')\n , setToStringTag = require('./_set-to-string-tag')\n , IteratorPrototype = {};\n\n// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()\nrequire('./_hide')(IteratorPrototype, require('./_wks')('iterator'), function(){ return this; });\n\nmodule.exports = function(Constructor, NAME, next){\n Constructor.prototype = create(IteratorPrototype, {next: descriptor(1, next)});\n setToStringTag(Constructor, NAME + ' Iterator');\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iter-create.js\n// module id = 50\n// module chunks = 0","'use strict';\nvar LIBRARY = require('./_library')\n , $export = require('./_export')\n , redefine = require('./_redefine')\n , hide = require('./_hide')\n , has = require('./_has')\n , Iterators = require('./_iterators')\n , $iterCreate = require('./_iter-create')\n , setToStringTag = require('./_set-to-string-tag')\n , getPrototypeOf = require('./_object-gpo')\n , ITERATOR = require('./_wks')('iterator')\n , BUGGY = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`\n , FF_ITERATOR = '@@iterator'\n , KEYS = 'keys'\n , VALUES = 'values';\n\nvar returnThis = function(){ return this; };\n\nmodule.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){\n $iterCreate(Constructor, NAME, next);\n var getMethod = function(kind){\n if(!BUGGY && kind in proto)return proto[kind];\n switch(kind){\n case KEYS: return function keys(){ return new Constructor(this, kind); };\n case VALUES: return function values(){ return new Constructor(this, kind); };\n } return function entries(){ return new Constructor(this, kind); };\n };\n var TAG = NAME + ' Iterator'\n , DEF_VALUES = DEFAULT == VALUES\n , VALUES_BUG = false\n , proto = Base.prototype\n , $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]\n , $default = $native || getMethod(DEFAULT)\n , $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined\n , $anyNative = NAME == 'Array' ? proto.entries || $native : $native\n , methods, key, IteratorPrototype;\n // Fix native\n if($anyNative){\n IteratorPrototype = getPrototypeOf($anyNative.call(new Base));\n if(IteratorPrototype !== Object.prototype){\n // Set @@toStringTag to native iterators\n setToStringTag(IteratorPrototype, TAG, true);\n // fix for some old engines\n if(!LIBRARY && !has(IteratorPrototype, ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis);\n }\n }\n // fix Array#{values, @@iterator}.name in V8 / FF\n if(DEF_VALUES && $native && $native.name !== VALUES){\n VALUES_BUG = true;\n $default = function values(){ return $native.call(this); };\n }\n // Define iterator\n if((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])){\n hide(proto, ITERATOR, $default);\n }\n // Plug for library\n Iterators[NAME] = $default;\n Iterators[TAG] = returnThis;\n if(DEFAULT){\n methods = {\n values: DEF_VALUES ? $default : getMethod(VALUES),\n keys: IS_SET ? $default : getMethod(KEYS),\n entries: $entries\n };\n if(FORCED)for(key in methods){\n if(!(key in proto))redefine(proto, key, methods[key]);\n } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);\n }\n return methods;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iter-define.js\n// module id = 51\n// module chunks = 0","var ITERATOR = require('./_wks')('iterator')\n , SAFE_CLOSING = false;\n\ntry {\n var riter = [7][ITERATOR]();\n riter['return'] = function(){ SAFE_CLOSING = true; };\n Array.from(riter, function(){ throw 2; });\n} catch(e){ /* empty */ }\n\nmodule.exports = function(exec, skipClosing){\n if(!skipClosing && !SAFE_CLOSING)return false;\n var safe = false;\n try {\n var arr = [7]\n , iter = arr[ITERATOR]();\n iter.next = function(){ return {done: safe = true}; };\n arr[ITERATOR] = function(){ return iter; };\n exec(arr);\n } catch(e){ /* empty */ }\n return safe;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iter-detect.js\n// module id = 52\n// module chunks = 0","module.exports = true;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_library.js\n// module id = 53\n// module chunks = 0","// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])\nvar anObject = require('./_an-object')\n , dPs = require('./_object-dps')\n , enumBugKeys = require('./_enum-bug-keys')\n , IE_PROTO = require('./_shared-key')('IE_PROTO')\n , Empty = function(){ /* empty */ }\n , PROTOTYPE = 'prototype';\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar createDict = function(){\n // Thrash, waste and sodomy: IE GC bug\n var iframe = require('./_dom-create')('iframe')\n , i = enumBugKeys.length\n , lt = '<'\n , gt = '>'\n , iframeDocument;\n iframe.style.display = 'none';\n require('./_html').appendChild(iframe);\n iframe.src = 'javascript:'; // eslint-disable-line no-script-url\n // createDict = iframe.contentWindow.Object;\n // html.removeChild(iframe);\n iframeDocument = iframe.contentWindow.document;\n iframeDocument.open();\n iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);\n iframeDocument.close();\n createDict = iframeDocument.F;\n while(i--)delete createDict[PROTOTYPE][enumBugKeys[i]];\n return createDict();\n};\n\nmodule.exports = Object.create || function create(O, Properties){\n var result;\n if(O !== null){\n Empty[PROTOTYPE] = anObject(O);\n result = new Empty;\n Empty[PROTOTYPE] = null;\n // add \"__proto__\" for Object.getPrototypeOf polyfill\n result[IE_PROTO] = O;\n } else result = createDict();\n return Properties === undefined ? result : dPs(result, Properties);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-create.js\n// module id = 54\n// module chunks = 0","var dP = require('./_object-dp')\n , anObject = require('./_an-object')\n , getKeys = require('./_object-keys');\n\nmodule.exports = require('./_descriptors') ? Object.defineProperties : function defineProperties(O, Properties){\n anObject(O);\n var keys = getKeys(Properties)\n , length = keys.length\n , i = 0\n , P;\n while(length > i)dP.f(O, P = keys[i++], Properties[P]);\n return O;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-dps.js\n// module id = 55\n// module chunks = 0","// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)\nvar has = require('./_has')\n , toObject = require('./_to-object')\n , IE_PROTO = require('./_shared-key')('IE_PROTO')\n , ObjectProto = Object.prototype;\n\nmodule.exports = Object.getPrototypeOf || function(O){\n O = toObject(O);\n if(has(O, IE_PROTO))return O[IE_PROTO];\n if(typeof O.constructor == 'function' && O instanceof O.constructor){\n return O.constructor.prototype;\n } return O instanceof Object ? ObjectProto : null;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-gpo.js\n// module id = 56\n// module chunks = 0","var has = require('./_has')\n , toIObject = require('./_to-iobject')\n , arrayIndexOf = require('./_array-includes')(false)\n , IE_PROTO = require('./_shared-key')('IE_PROTO');\n\nmodule.exports = function(object, names){\n var O = toIObject(object)\n , i = 0\n , result = []\n , key;\n for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);\n // Don't enum bug & hidden keys\n while(names.length > i)if(has(O, key = names[i++])){\n ~arrayIndexOf(result, key) || result.push(key);\n }\n return result;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-keys-internal.js\n// module id = 57\n// module chunks = 0","// 19.1.2.14 / 15.2.3.14 Object.keys(O)\nvar $keys = require('./_object-keys-internal')\n , enumBugKeys = require('./_enum-bug-keys');\n\nmodule.exports = Object.keys || function keys(O){\n return $keys(O, enumBugKeys);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-keys.js\n// module id = 58\n// module chunks = 0","module.exports = require('./_hide');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_redefine.js\n// module id = 59\n// module chunks = 0","var toInteger = require('./_to-integer')\n , defined = require('./_defined');\n// true -> String#at\n// false -> String#codePointAt\nmodule.exports = function(TO_STRING){\n return function(that, pos){\n var s = String(defined(that))\n , i = toInteger(pos)\n , l = s.length\n , a, b;\n if(i < 0 || i >= l)return TO_STRING ? '' : undefined;\n a = s.charCodeAt(i);\n return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff\n ? TO_STRING ? s.charAt(i) : a\n : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;\n };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_string-at.js\n// module id = 60\n// module chunks = 0","var toInteger = require('./_to-integer')\n , max = Math.max\n , min = Math.min;\nmodule.exports = function(index, length){\n index = toInteger(index);\n return index < 0 ? max(index + length, 0) : min(index, length);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-index.js\n// module id = 61\n// module chunks = 0","// 7.1.1 ToPrimitive(input [, PreferredType])\nvar isObject = require('./_is-object');\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function(it, S){\n if(!isObject(it))return it;\n var fn, val;\n if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;\n if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n throw TypeError(\"Can't convert object to primitive value\");\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-primitive.js\n// module id = 62\n// module chunks = 0","var classof = require('./_classof')\n , ITERATOR = require('./_wks')('iterator')\n , Iterators = require('./_iterators');\nmodule.exports = require('./_core').getIteratorMethod = function(it){\n if(it != undefined)return it[ITERATOR]\n || it['@@iterator']\n || Iterators[classof(it)];\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/core.get-iterator-method.js\n// module id = 63\n// module chunks = 0","'use strict';\nvar ctx = require('./_ctx')\n , $export = require('./_export')\n , toObject = require('./_to-object')\n , call = require('./_iter-call')\n , isArrayIter = require('./_is-array-iter')\n , toLength = require('./_to-length')\n , createProperty = require('./_create-property')\n , getIterFn = require('./core.get-iterator-method');\n\n$export($export.S + $export.F * !require('./_iter-detect')(function(iter){ Array.from(iter); }), 'Array', {\n // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)\n from: function from(arrayLike/*, mapfn = undefined, thisArg = undefined*/){\n var O = toObject(arrayLike)\n , C = typeof this == 'function' ? this : Array\n , aLen = arguments.length\n , mapfn = aLen > 1 ? arguments[1] : undefined\n , mapping = mapfn !== undefined\n , index = 0\n , iterFn = getIterFn(O)\n , length, result, step, iterator;\n if(mapping)mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);\n // if object isn't iterable or it's array with default iterator - use simple case\n if(iterFn != undefined && !(C == Array && isArrayIter(iterFn))){\n for(iterator = iterFn.call(O), result = new C; !(step = iterator.next()).done; index++){\n createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value);\n }\n } else {\n length = toLength(O.length);\n for(result = new C(length); length > index; index++){\n createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);\n }\n }\n result.length = index;\n return result;\n }\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es6.array.from.js\n// module id = 64\n// module chunks = 0","'use strict';\nvar $at = require('./_string-at')(true);\n\n// 21.1.3.27 String.prototype[@@iterator]()\nrequire('./_iter-define')(String, 'String', function(iterated){\n this._t = String(iterated); // target\n this._i = 0; // next index\n// 21.1.5.2.1 %StringIteratorPrototype%.next()\n}, function(){\n var O = this._t\n , index = this._i\n , point;\n if(index >= O.length)return {value: undefined, done: true};\n point = $at(O, index);\n this._i += point.length;\n return {value: point, done: false};\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es6.string.iterator.js\n// module id = 65\n// module chunks = 0","/**\n * vue-router v2.2.1\n * (c) 2017 Evan You\n * @license MIT\n */\n'use strict';\n\n/* */\n\nfunction assert (condition, message) {\n if (!condition) {\n throw new Error((\"[vue-router] \" + message))\n }\n}\n\nfunction warn (condition, message) {\n if (!condition) {\n typeof console !== 'undefined' && console.warn((\"[vue-router] \" + message));\n }\n}\n\nvar View = {\n name: 'router-view',\n functional: true,\n props: {\n name: {\n type: String,\n default: 'default'\n }\n },\n render: function render (h, ref) {\n var props = ref.props;\n var children = ref.children;\n var parent = ref.parent;\n var data = ref.data;\n\n data.routerView = true;\n\n var name = props.name;\n var route = parent.$route;\n var cache = parent._routerViewCache || (parent._routerViewCache = {});\n\n // determine current view depth, also check to see if the tree\n // has been toggled inactive but kept-alive.\n var depth = 0;\n var inactive = false;\n while (parent) {\n if (parent.$vnode && parent.$vnode.data.routerView) {\n depth++;\n }\n if (parent._inactive) {\n inactive = true;\n }\n parent = parent.$parent;\n }\n data.routerViewDepth = depth;\n\n // render previous view if the tree is inactive and kept-alive\n if (inactive) {\n return h(cache[name], data, children)\n }\n\n var matched = route.matched[depth];\n // render empty node if no matched route\n if (!matched) {\n cache[name] = null;\n return h()\n }\n\n var component = cache[name] = matched.components[name];\n\n // inject instance registration hooks\n var hooks = data.hook || (data.hook = {});\n hooks.init = function (vnode) {\n matched.instances[name] = vnode.child;\n };\n hooks.prepatch = function (oldVnode, vnode) {\n matched.instances[name] = vnode.child;\n };\n hooks.destroy = function (vnode) {\n if (matched.instances[name] === vnode.child) {\n matched.instances[name] = undefined;\n }\n };\n\n // resolve props\n data.props = resolveProps(route, matched.props && matched.props[name]);\n\n return h(component, data, children)\n }\n};\n\nfunction resolveProps (route, config) {\n switch (typeof config) {\n case 'undefined':\n return\n case 'object':\n return config\n case 'function':\n return config(route)\n case 'boolean':\n return config ? route.params : undefined\n default:\n warn(false, (\"props in \\\"\" + (route.path) + \"\\\" is a \" + (typeof config) + \", expecting an object, function or boolean.\"));\n }\n}\n\n/* */\n\nvar encodeReserveRE = /[!'()*]/g;\nvar encodeReserveReplacer = function (c) { return '%' + c.charCodeAt(0).toString(16); };\nvar commaRE = /%2C/g;\n\n// fixed encodeURIComponent which is more comformant to RFC3986:\n// - escapes [!'()*]\n// - preserve commas\nvar encode = function (str) { return encodeURIComponent(str)\n .replace(encodeReserveRE, encodeReserveReplacer)\n .replace(commaRE, ','); };\n\nvar decode = decodeURIComponent;\n\nfunction resolveQuery (\n query,\n extraQuery\n) {\n if ( extraQuery === void 0 ) extraQuery = {};\n\n if (query) {\n var parsedQuery;\n try {\n parsedQuery = parseQuery(query);\n } catch (e) {\n process.env.NODE_ENV !== 'production' && warn(false, e.message);\n parsedQuery = {};\n }\n for (var key in extraQuery) {\n parsedQuery[key] = extraQuery[key];\n }\n return parsedQuery\n } else {\n return extraQuery\n }\n}\n\nfunction parseQuery (query) {\n var res = {};\n\n query = query.trim().replace(/^(\\?|#|&)/, '');\n\n if (!query) {\n return res\n }\n\n query.split('&').forEach(function (param) {\n var parts = param.replace(/\\+/g, ' ').split('=');\n var key = decode(parts.shift());\n var val = parts.length > 0\n ? decode(parts.join('='))\n : null;\n\n if (res[key] === undefined) {\n res[key] = val;\n } else if (Array.isArray(res[key])) {\n res[key].push(val);\n } else {\n res[key] = [res[key], val];\n }\n });\n\n return res\n}\n\nfunction stringifyQuery (obj) {\n var res = obj ? Object.keys(obj).map(function (key) {\n var val = obj[key];\n\n if (val === undefined) {\n return ''\n }\n\n if (val === null) {\n return encode(key)\n }\n\n if (Array.isArray(val)) {\n var result = [];\n val.slice().forEach(function (val2) {\n if (val2 === undefined) {\n return\n }\n if (val2 === null) {\n result.push(encode(key));\n } else {\n result.push(encode(key) + '=' + encode(val2));\n }\n });\n return result.join('&')\n }\n\n return encode(key) + '=' + encode(val)\n }).filter(function (x) { return x.length > 0; }).join('&') : null;\n return res ? (\"?\" + res) : ''\n}\n\n/* */\n\nvar trailingSlashRE = /\\/?$/;\n\nfunction createRoute (\n record,\n location,\n redirectedFrom\n) {\n var route = {\n name: location.name || (record && record.name),\n meta: (record && record.meta) || {},\n path: location.path || '/',\n hash: location.hash || '',\n query: location.query || {},\n params: location.params || {},\n fullPath: getFullPath(location),\n matched: record ? formatMatch(record) : []\n };\n if (redirectedFrom) {\n route.redirectedFrom = getFullPath(redirectedFrom);\n }\n return Object.freeze(route)\n}\n\n// the starting route that represents the initial state\nvar START = createRoute(null, {\n path: '/'\n});\n\nfunction formatMatch (record) {\n var res = [];\n while (record) {\n res.unshift(record);\n record = record.parent;\n }\n return res\n}\n\nfunction getFullPath (ref) {\n var path = ref.path;\n var query = ref.query; if ( query === void 0 ) query = {};\n var hash = ref.hash; if ( hash === void 0 ) hash = '';\n\n return (path || '/') + stringifyQuery(query) + hash\n}\n\nfunction isSameRoute (a, b) {\n if (b === START) {\n return a === b\n } else if (!b) {\n return false\n } else if (a.path && b.path) {\n return (\n a.path.replace(trailingSlashRE, '') === b.path.replace(trailingSlashRE, '') &&\n a.hash === b.hash &&\n isObjectEqual(a.query, b.query)\n )\n } else if (a.name && b.name) {\n return (\n a.name === b.name &&\n a.hash === b.hash &&\n isObjectEqual(a.query, b.query) &&\n isObjectEqual(a.params, b.params)\n )\n } else {\n return false\n }\n}\n\nfunction isObjectEqual (a, b) {\n if ( a === void 0 ) a = {};\n if ( b === void 0 ) b = {};\n\n var aKeys = Object.keys(a);\n var bKeys = Object.keys(b);\n if (aKeys.length !== bKeys.length) {\n return false\n }\n return aKeys.every(function (key) { return String(a[key]) === String(b[key]); })\n}\n\nfunction isIncludedRoute (current, target) {\n return (\n current.path.replace(trailingSlashRE, '/').indexOf(\n target.path.replace(trailingSlashRE, '/')\n ) === 0 &&\n (!target.hash || current.hash === target.hash) &&\n queryIncludes(current.query, target.query)\n )\n}\n\nfunction queryIncludes (current, target) {\n for (var key in target) {\n if (!(key in current)) {\n return false\n }\n }\n return true\n}\n\n/* */\n\n// work around weird flow bug\nvar toTypes = [String, Object];\nvar eventTypes = [String, Array];\n\nvar Link = {\n name: 'router-link',\n props: {\n to: {\n type: toTypes,\n required: true\n },\n tag: {\n type: String,\n default: 'a'\n },\n exact: Boolean,\n append: Boolean,\n replace: Boolean,\n activeClass: String,\n event: {\n type: eventTypes,\n default: 'click'\n }\n },\n render: function render (h) {\n var this$1 = this;\n\n var router = this.$router;\n var current = this.$route;\n var ref = router.resolve(this.to, current, this.append);\n var location = ref.location;\n var route = ref.route;\n var href = ref.href;\n var classes = {};\n var activeClass = this.activeClass || router.options.linkActiveClass || 'router-link-active';\n var compareTarget = location.path ? createRoute(null, location) : route;\n classes[activeClass] = this.exact\n ? isSameRoute(current, compareTarget)\n : isIncludedRoute(current, compareTarget);\n\n var handler = function (e) {\n if (guardEvent(e)) {\n if (this$1.replace) {\n router.replace(location);\n } else {\n router.push(location);\n }\n }\n };\n\n var on = { click: guardEvent };\n if (Array.isArray(this.event)) {\n this.event.forEach(function (e) { on[e] = handler; });\n } else {\n on[this.event] = handler;\n }\n\n var data = {\n class: classes\n };\n\n if (this.tag === 'a') {\n data.on = on;\n data.attrs = { href: href };\n } else {\n // find the first <a> child and apply listener and href\n var a = findAnchor(this.$slots.default);\n if (a) {\n // in case the <a> is a static node\n a.isStatic = false;\n var extend = _Vue.util.extend;\n var aData = a.data = extend({}, a.data);\n aData.on = on;\n var aAttrs = a.data.attrs = extend({}, a.data.attrs);\n aAttrs.href = href;\n } else {\n // doesn't have <a> child, apply listener to self\n data.on = on;\n }\n }\n\n return h(this.tag, data, this.$slots.default)\n }\n};\n\nfunction guardEvent (e) {\n // don't redirect with control keys\n if (e.metaKey || e.ctrlKey || e.shiftKey) { return }\n // don't redirect when preventDefault called\n if (e.defaultPrevented) { return }\n // don't redirect on right click\n if (e.button !== undefined && e.button !== 0) { return }\n // don't redirect if `target=\"_blank\"`\n if (e.target && e.target.getAttribute) {\n var target = e.target.getAttribute('target');\n if (/\\b_blank\\b/i.test(target)) { return }\n }\n // this may be a Weex event which doesn't have this method\n if (e.preventDefault) {\n e.preventDefault();\n }\n return true\n}\n\nfunction findAnchor (children) {\n if (children) {\n var child;\n for (var i = 0; i < children.length; i++) {\n child = children[i];\n if (child.tag === 'a') {\n return child\n }\n if (child.children && (child = findAnchor(child.children))) {\n return child\n }\n }\n }\n}\n\nvar _Vue;\n\nfunction install (Vue) {\n if (install.installed) { return }\n install.installed = true;\n\n _Vue = Vue;\n\n Object.defineProperty(Vue.prototype, '$router', {\n get: function get () { return this.$root._router }\n });\n\n Object.defineProperty(Vue.prototype, '$route', {\n get: function get () { return this.$root._route }\n });\n\n Vue.mixin({\n beforeCreate: function beforeCreate () {\n if (this.$options.router) {\n this._router = this.$options.router;\n this._router.init(this);\n Vue.util.defineReactive(this, '_route', this._router.history.current);\n }\n }\n });\n\n Vue.component('router-view', View);\n Vue.component('router-link', Link);\n\n var strats = Vue.config.optionMergeStrategies;\n // use the same hook merging strategy for route hooks\n strats.beforeRouteEnter = strats.beforeRouteLeave = strats.created;\n}\n\n/* */\n\nvar inBrowser = typeof window !== 'undefined';\n\n/* */\n\nfunction resolvePath (\n relative,\n base,\n append\n) {\n if (relative.charAt(0) === '/') {\n return relative\n }\n\n if (relative.charAt(0) === '?' || relative.charAt(0) === '#') {\n return base + relative\n }\n\n var stack = base.split('/');\n\n // remove trailing segment if:\n // - not appending\n // - appending to trailing slash (last segment is empty)\n if (!append || !stack[stack.length - 1]) {\n stack.pop();\n }\n\n // resolve relative path\n var segments = relative.replace(/^\\//, '').split('/');\n for (var i = 0; i < segments.length; i++) {\n var segment = segments[i];\n if (segment === '.') {\n continue\n } else if (segment === '..') {\n stack.pop();\n } else {\n stack.push(segment);\n }\n }\n\n // ensure leading slash\n if (stack[0] !== '') {\n stack.unshift('');\n }\n\n return stack.join('/')\n}\n\nfunction parsePath (path) {\n var hash = '';\n var query = '';\n\n var hashIndex = path.indexOf('#');\n if (hashIndex >= 0) {\n hash = path.slice(hashIndex);\n path = path.slice(0, hashIndex);\n }\n\n var queryIndex = path.indexOf('?');\n if (queryIndex >= 0) {\n query = path.slice(queryIndex + 1);\n path = path.slice(0, queryIndex);\n }\n\n return {\n path: path,\n query: query,\n hash: hash\n }\n}\n\nfunction cleanPath (path) {\n return path.replace(/\\/\\//g, '/')\n}\n\n/* */\n\nfunction createRouteMap (\n routes,\n oldPathMap,\n oldNameMap\n) {\n var pathMap = oldPathMap || Object.create(null);\n var nameMap = oldNameMap || Object.create(null);\n\n routes.forEach(function (route) {\n addRouteRecord(pathMap, nameMap, route);\n });\n\n return {\n pathMap: pathMap,\n nameMap: nameMap\n }\n}\n\nfunction addRouteRecord (\n pathMap,\n nameMap,\n route,\n parent,\n matchAs\n) {\n var path = route.path;\n var name = route.name;\n if (process.env.NODE_ENV !== 'production') {\n assert(path != null, \"\\\"path\\\" is required in a route configuration.\");\n assert(\n typeof route.component !== 'string',\n \"route config \\\"component\\\" for path: \" + (String(path || name)) + \" cannot be a \" +\n \"string id. Use an actual component instead.\"\n );\n }\n\n var record = {\n path: normalizePath(path, parent),\n components: route.components || { default: route.component },\n instances: {},\n name: name,\n parent: parent,\n matchAs: matchAs,\n redirect: route.redirect,\n beforeEnter: route.beforeEnter,\n meta: route.meta || {},\n props: route.props == null\n ? {}\n : route.components\n ? route.props\n : { default: route.props }\n };\n\n if (route.children) {\n // Warn if route is named and has a default child route.\n // If users navigate to this route by name, the default child will\n // not be rendered (GH Issue #629)\n if (process.env.NODE_ENV !== 'production') {\n if (route.name && route.children.some(function (child) { return /^\\/?$/.test(child.path); })) {\n warn(\n false,\n \"Named Route '\" + (route.name) + \"' has a default child route. \" +\n \"When navigating to this named route (:to=\\\"{name: '\" + (route.name) + \"'\\\"), \" +\n \"the default child route will not be rendered. Remove the name from \" +\n \"this route and use the name of the default child route for named \" +\n \"links instead.\"\n );\n }\n }\n route.children.forEach(function (child) {\n var childMatchAs = matchAs\n ? cleanPath((matchAs + \"/\" + (child.path)))\n : undefined;\n addRouteRecord(pathMap, nameMap, child, record, childMatchAs);\n });\n }\n\n if (route.alias !== undefined) {\n if (Array.isArray(route.alias)) {\n route.alias.forEach(function (alias) {\n var aliasRoute = {\n path: alias,\n children: route.children\n };\n addRouteRecord(pathMap, nameMap, aliasRoute, parent, record.path);\n });\n } else {\n var aliasRoute = {\n path: route.alias,\n children: route.children\n };\n addRouteRecord(pathMap, nameMap, aliasRoute, parent, record.path);\n }\n }\n\n if (!pathMap[record.path]) {\n pathMap[record.path] = record;\n }\n\n if (name) {\n if (!nameMap[name]) {\n nameMap[name] = record;\n } else if (process.env.NODE_ENV !== 'production' && !matchAs) {\n warn(\n false,\n \"Duplicate named routes definition: \" +\n \"{ name: \\\"\" + name + \"\\\", path: \\\"\" + (record.path) + \"\\\" }\"\n );\n }\n }\n}\n\nfunction normalizePath (path, parent) {\n path = path.replace(/\\/$/, '');\n if (path[0] === '/') { return path }\n if (parent == null) { return path }\n return cleanPath(((parent.path) + \"/\" + path))\n}\n\nvar index$1 = Array.isArray || function (arr) {\n return Object.prototype.toString.call(arr) == '[object Array]';\n};\n\nvar isarray = index$1;\n\n/**\n * Expose `pathToRegexp`.\n */\nvar index = pathToRegexp;\nvar parse_1 = parse;\nvar compile_1 = compile;\nvar tokensToFunction_1 = tokensToFunction;\nvar tokensToRegExp_1 = tokensToRegExp;\n\n/**\n * The main path matching regexp utility.\n *\n * @type {RegExp}\n */\nvar PATH_REGEXP = new RegExp([\n // Match escaped characters that would otherwise appear in future matches.\n // This allows the user to escape special characters that won't transform.\n '(\\\\\\\\.)',\n // Match Express-style parameters and un-named parameters with a prefix\n // and optional suffixes. Matches appear as:\n //\n // \"/:test(\\\\d+)?\" => [\"/\", \"test\", \"\\d+\", undefined, \"?\", undefined]\n // \"/route(\\\\d+)\" => [undefined, undefined, undefined, \"\\d+\", undefined, undefined]\n // \"/*\" => [\"/\", undefined, undefined, undefined, undefined, \"*\"]\n '([\\\\/.])?(?:(?:\\\\:(\\\\w+)(?:\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))?|\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))([+*?])?|(\\\\*))'\n].join('|'), 'g');\n\n/**\n * Parse a string for the raw tokens.\n *\n * @param {string} str\n * @param {Object=} options\n * @return {!Array}\n */\nfunction parse (str, options) {\n var tokens = [];\n var key = 0;\n var index = 0;\n var path = '';\n var defaultDelimiter = options && options.delimiter || '/';\n var res;\n\n while ((res = PATH_REGEXP.exec(str)) != null) {\n var m = res[0];\n var escaped = res[1];\n var offset = res.index;\n path += str.slice(index, offset);\n index = offset + m.length;\n\n // Ignore already escaped sequences.\n if (escaped) {\n path += escaped[1];\n continue\n }\n\n var next = str[index];\n var prefix = res[2];\n var name = res[3];\n var capture = res[4];\n var group = res[5];\n var modifier = res[6];\n var asterisk = res[7];\n\n // Push the current path onto the tokens.\n if (path) {\n tokens.push(path);\n path = '';\n }\n\n var partial = prefix != null && next != null && next !== prefix;\n var repeat = modifier === '+' || modifier === '*';\n var optional = modifier === '?' || modifier === '*';\n var delimiter = res[2] || defaultDelimiter;\n var pattern = capture || group;\n\n tokens.push({\n name: name || key++,\n prefix: prefix || '',\n delimiter: delimiter,\n optional: optional,\n repeat: repeat,\n partial: partial,\n asterisk: !!asterisk,\n pattern: pattern ? escapeGroup(pattern) : (asterisk ? '.*' : '[^' + escapeString(delimiter) + ']+?')\n });\n }\n\n // Match any characters still remaining.\n if (index < str.length) {\n path += str.substr(index);\n }\n\n // If the path exists, push it onto the end.\n if (path) {\n tokens.push(path);\n }\n\n return tokens\n}\n\n/**\n * Compile a string to a template function for the path.\n *\n * @param {string} str\n * @param {Object=} options\n * @return {!function(Object=, Object=)}\n */\nfunction compile (str, options) {\n return tokensToFunction(parse(str, options))\n}\n\n/**\n * Prettier encoding of URI path segments.\n *\n * @param {string}\n * @return {string}\n */\nfunction encodeURIComponentPretty (str) {\n return encodeURI(str).replace(/[\\/?#]/g, function (c) {\n return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n })\n}\n\n/**\n * Encode the asterisk parameter. Similar to `pretty`, but allows slashes.\n *\n * @param {string}\n * @return {string}\n */\nfunction encodeAsterisk (str) {\n return encodeURI(str).replace(/[?#]/g, function (c) {\n return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n })\n}\n\n/**\n * Expose a method for transforming tokens into the path function.\n */\nfunction tokensToFunction (tokens) {\n // Compile all the tokens into regexps.\n var matches = new Array(tokens.length);\n\n // Compile all the patterns before compilation.\n for (var i = 0; i < tokens.length; i++) {\n if (typeof tokens[i] === 'object') {\n matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$');\n }\n }\n\n return function (obj, opts) {\n var path = '';\n var data = obj || {};\n var options = opts || {};\n var encode = options.pretty ? encodeURIComponentPretty : encodeURIComponent;\n\n for (var i = 0; i < tokens.length; i++) {\n var token = tokens[i];\n\n if (typeof token === 'string') {\n path += token;\n\n continue\n }\n\n var value = data[token.name];\n var segment;\n\n if (value == null) {\n if (token.optional) {\n // Prepend partial segment prefixes.\n if (token.partial) {\n path += token.prefix;\n }\n\n continue\n } else {\n throw new TypeError('Expected \"' + token.name + '\" to be defined')\n }\n }\n\n if (isarray(value)) {\n if (!token.repeat) {\n throw new TypeError('Expected \"' + token.name + '\" to not repeat, but received `' + JSON.stringify(value) + '`')\n }\n\n if (value.length === 0) {\n if (token.optional) {\n continue\n } else {\n throw new TypeError('Expected \"' + token.name + '\" to not be empty')\n }\n }\n\n for (var j = 0; j < value.length; j++) {\n segment = encode(value[j]);\n\n if (!matches[i].test(segment)) {\n throw new TypeError('Expected all \"' + token.name + '\" to match \"' + token.pattern + '\", but received `' + JSON.stringify(segment) + '`')\n }\n\n path += (j === 0 ? token.prefix : token.delimiter) + segment;\n }\n\n continue\n }\n\n segment = token.asterisk ? encodeAsterisk(value) : encode(value);\n\n if (!matches[i].test(segment)) {\n throw new TypeError('Expected \"' + token.name + '\" to match \"' + token.pattern + '\", but received \"' + segment + '\"')\n }\n\n path += token.prefix + segment;\n }\n\n return path\n }\n}\n\n/**\n * Escape a regular expression string.\n *\n * @param {string} str\n * @return {string}\n */\nfunction escapeString (str) {\n return str.replace(/([.+*?=^!:${}()[\\]|\\/\\\\])/g, '\\\\$1')\n}\n\n/**\n * Escape the capturing group by escaping special characters and meaning.\n *\n * @param {string} group\n * @return {string}\n */\nfunction escapeGroup (group) {\n return group.replace(/([=!:$\\/()])/g, '\\\\$1')\n}\n\n/**\n * Attach the keys as a property of the regexp.\n *\n * @param {!RegExp} re\n * @param {Array} keys\n * @return {!RegExp}\n */\nfunction attachKeys (re, keys) {\n re.keys = keys;\n return re\n}\n\n/**\n * Get the flags for a regexp from the options.\n *\n * @param {Object} options\n * @return {string}\n */\nfunction flags (options) {\n return options.sensitive ? '' : 'i'\n}\n\n/**\n * Pull out keys from a regexp.\n *\n * @param {!RegExp} path\n * @param {!Array} keys\n * @return {!RegExp}\n */\nfunction regexpToRegexp (path, keys) {\n // Use a negative lookahead to match only capturing groups.\n var groups = path.source.match(/\\((?!\\?)/g);\n\n if (groups) {\n for (var i = 0; i < groups.length; i++) {\n keys.push({\n name: i,\n prefix: null,\n delimiter: null,\n optional: false,\n repeat: false,\n partial: false,\n asterisk: false,\n pattern: null\n });\n }\n }\n\n return attachKeys(path, keys)\n}\n\n/**\n * Transform an array into a regexp.\n *\n * @param {!Array} path\n * @param {Array} keys\n * @param {!Object} options\n * @return {!RegExp}\n */\nfunction arrayToRegexp (path, keys, options) {\n var parts = [];\n\n for (var i = 0; i < path.length; i++) {\n parts.push(pathToRegexp(path[i], keys, options).source);\n }\n\n var regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options));\n\n return attachKeys(regexp, keys)\n}\n\n/**\n * Create a path regexp from string input.\n *\n * @param {string} path\n * @param {!Array} keys\n * @param {!Object} options\n * @return {!RegExp}\n */\nfunction stringToRegexp (path, keys, options) {\n return tokensToRegExp(parse(path, options), keys, options)\n}\n\n/**\n * Expose a function for taking tokens and returning a RegExp.\n *\n * @param {!Array} tokens\n * @param {(Array|Object)=} keys\n * @param {Object=} options\n * @return {!RegExp}\n */\nfunction tokensToRegExp (tokens, keys, options) {\n if (!isarray(keys)) {\n options = /** @type {!Object} */ (keys || options);\n keys = [];\n }\n\n options = options || {};\n\n var strict = options.strict;\n var end = options.end !== false;\n var route = '';\n\n // Iterate over the tokens and create our regexp string.\n for (var i = 0; i < tokens.length; i++) {\n var token = tokens[i];\n\n if (typeof token === 'string') {\n route += escapeString(token);\n } else {\n var prefix = escapeString(token.prefix);\n var capture = '(?:' + token.pattern + ')';\n\n keys.push(token);\n\n if (token.repeat) {\n capture += '(?:' + prefix + capture + ')*';\n }\n\n if (token.optional) {\n if (!token.partial) {\n capture = '(?:' + prefix + '(' + capture + '))?';\n } else {\n capture = prefix + '(' + capture + ')?';\n }\n } else {\n capture = prefix + '(' + capture + ')';\n }\n\n route += capture;\n }\n }\n\n var delimiter = escapeString(options.delimiter || '/');\n var endsWithDelimiter = route.slice(-delimiter.length) === delimiter;\n\n // In non-strict mode we allow a slash at the end of match. If the path to\n // match already ends with a slash, we remove it for consistency. The slash\n // is valid at the end of a path match, not in the middle. This is important\n // in non-ending mode, where \"/test/\" shouldn't match \"/test//route\".\n if (!strict) {\n route = (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) + '(?:' + delimiter + '(?=$))?';\n }\n\n if (end) {\n route += '$';\n } else {\n // In non-ending mode, we need the capturing groups to match as much as\n // possible by using a positive lookahead to the end or next path segment.\n route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)';\n }\n\n return attachKeys(new RegExp('^' + route, flags(options)), keys)\n}\n\n/**\n * Normalize the given path string, returning a regular expression.\n *\n * An empty array can be passed in for the keys, which will hold the\n * placeholder key descriptions. For example, using `/user/:id`, `keys` will\n * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.\n *\n * @param {(string|RegExp|Array)} path\n * @param {(Array|Object)=} keys\n * @param {Object=} options\n * @return {!RegExp}\n */\nfunction pathToRegexp (path, keys, options) {\n if (!isarray(keys)) {\n options = /** @type {!Object} */ (keys || options);\n keys = [];\n }\n\n options = options || {};\n\n if (path instanceof RegExp) {\n return regexpToRegexp(path, /** @type {!Array} */ (keys))\n }\n\n if (isarray(path)) {\n return arrayToRegexp(/** @type {!Array} */ (path), /** @type {!Array} */ (keys), options)\n }\n\n return stringToRegexp(/** @type {string} */ (path), /** @type {!Array} */ (keys), options)\n}\n\nindex.parse = parse_1;\nindex.compile = compile_1;\nindex.tokensToFunction = tokensToFunction_1;\nindex.tokensToRegExp = tokensToRegExp_1;\n\n/* */\n\nvar regexpCache = Object.create(null);\n\nfunction getRouteRegex (path) {\n var hit = regexpCache[path];\n var keys, regexp;\n\n if (hit) {\n keys = hit.keys;\n regexp = hit.regexp;\n } else {\n keys = [];\n regexp = index(path, keys);\n regexpCache[path] = { keys: keys, regexp: regexp };\n }\n\n return { keys: keys, regexp: regexp }\n}\n\nvar regexpCompileCache = Object.create(null);\n\nfunction fillParams (\n path,\n params,\n routeMsg\n) {\n try {\n var filler =\n regexpCompileCache[path] ||\n (regexpCompileCache[path] = index.compile(path));\n return filler(params || {}, { pretty: true })\n } catch (e) {\n if (process.env.NODE_ENV !== 'production') {\n warn(false, (\"missing param for \" + routeMsg + \": \" + (e.message)));\n }\n return ''\n }\n}\n\n/* */\n\nfunction normalizeLocation (\n raw,\n current,\n append\n) {\n var next = typeof raw === 'string' ? { path: raw } : raw;\n // named target\n if (next.name || next._normalized) {\n return next\n }\n\n // relative params\n if (!next.path && next.params && current) {\n next = assign({}, next);\n next._normalized = true;\n var params = assign(assign({}, current.params), next.params);\n if (current.name) {\n next.name = current.name;\n next.params = params;\n } else if (current.matched) {\n var rawPath = current.matched[current.matched.length - 1].path;\n next.path = fillParams(rawPath, params, (\"path \" + (current.path)));\n } else if (process.env.NODE_ENV !== 'production') {\n warn(false, \"relative params navigation requires a current route.\");\n }\n return next\n }\n\n var parsedPath = parsePath(next.path || '');\n var basePath = (current && current.path) || '/';\n var path = parsedPath.path\n ? resolvePath(parsedPath.path, basePath, append || next.append)\n : (current && current.path) || '/';\n var query = resolveQuery(parsedPath.query, next.query);\n var hash = next.hash || parsedPath.hash;\n if (hash && hash.charAt(0) !== '#') {\n hash = \"#\" + hash;\n }\n\n return {\n _normalized: true,\n path: path,\n query: query,\n hash: hash\n }\n}\n\nfunction assign (a, b) {\n for (var key in b) {\n a[key] = b[key];\n }\n return a\n}\n\n/* */\n\nfunction createMatcher (routes) {\n var ref = createRouteMap(routes);\n var pathMap = ref.pathMap;\n var nameMap = ref.nameMap;\n\n function addRoutes (routes) {\n createRouteMap(routes, pathMap, nameMap);\n }\n\n function match (\n raw,\n currentRoute,\n redirectedFrom\n ) {\n var location = normalizeLocation(raw, currentRoute);\n var name = location.name;\n\n if (name) {\n var record = nameMap[name];\n if (process.env.NODE_ENV !== 'production') {\n warn(record, (\"Route with name '\" + name + \"' does not exist\"));\n }\n var paramNames = getRouteRegex(record.path).keys\n .filter(function (key) { return !key.optional; })\n .map(function (key) { return key.name; });\n\n if (typeof location.params !== 'object') {\n location.params = {};\n }\n\n if (currentRoute && typeof currentRoute.params === 'object') {\n for (var key in currentRoute.params) {\n if (!(key in location.params) && paramNames.indexOf(key) > -1) {\n location.params[key] = currentRoute.params[key];\n }\n }\n }\n\n if (record) {\n location.path = fillParams(record.path, location.params, (\"named route \\\"\" + name + \"\\\"\"));\n return _createRoute(record, location, redirectedFrom)\n }\n } else if (location.path) {\n location.params = {};\n for (var path in pathMap) {\n if (matchRoute(path, location.params, location.path)) {\n return _createRoute(pathMap[path], location, redirectedFrom)\n }\n }\n }\n // no match\n return _createRoute(null, location)\n }\n\n function redirect (\n record,\n location\n ) {\n var originalRedirect = record.redirect;\n var redirect = typeof originalRedirect === 'function'\n ? originalRedirect(createRoute(record, location))\n : originalRedirect;\n\n if (typeof redirect === 'string') {\n redirect = { path: redirect };\n }\n\n if (!redirect || typeof redirect !== 'object') {\n process.env.NODE_ENV !== 'production' && warn(\n false, (\"invalid redirect option: \" + (JSON.stringify(redirect)))\n );\n return _createRoute(null, location)\n }\n\n var re = redirect;\n var name = re.name;\n var path = re.path;\n var query = location.query;\n var hash = location.hash;\n var params = location.params;\n query = re.hasOwnProperty('query') ? re.query : query;\n hash = re.hasOwnProperty('hash') ? re.hash : hash;\n params = re.hasOwnProperty('params') ? re.params : params;\n\n if (name) {\n // resolved named direct\n var targetRecord = nameMap[name];\n if (process.env.NODE_ENV !== 'production') {\n assert(targetRecord, (\"redirect failed: named route \\\"\" + name + \"\\\" not found.\"));\n }\n return match({\n _normalized: true,\n name: name,\n query: query,\n hash: hash,\n params: params\n }, undefined, location)\n } else if (path) {\n // 1. resolve relative redirect\n var rawPath = resolveRecordPath(path, record);\n // 2. resolve params\n var resolvedPath = fillParams(rawPath, params, (\"redirect route with path \\\"\" + rawPath + \"\\\"\"));\n // 3. rematch with existing query and hash\n return match({\n _normalized: true,\n path: resolvedPath,\n query: query,\n hash: hash\n }, undefined, location)\n } else {\n warn(false, (\"invalid redirect option: \" + (JSON.stringify(redirect))));\n return _createRoute(null, location)\n }\n }\n\n function alias (\n record,\n location,\n matchAs\n ) {\n var aliasedPath = fillParams(matchAs, location.params, (\"aliased route with path \\\"\" + matchAs + \"\\\"\"));\n var aliasedMatch = match({\n _normalized: true,\n path: aliasedPath\n });\n if (aliasedMatch) {\n var matched = aliasedMatch.matched;\n var aliasedRecord = matched[matched.length - 1];\n location.params = aliasedMatch.params;\n return _createRoute(aliasedRecord, location)\n }\n return _createRoute(null, location)\n }\n\n function _createRoute (\n record,\n location,\n redirectedFrom\n ) {\n if (record && record.redirect) {\n return redirect(record, redirectedFrom || location)\n }\n if (record && record.matchAs) {\n return alias(record, location, record.matchAs)\n }\n return createRoute(record, location, redirectedFrom)\n }\n\n return {\n match: match,\n addRoutes: addRoutes\n }\n}\n\nfunction matchRoute (\n path,\n params,\n pathname\n) {\n var ref = getRouteRegex(path);\n var regexp = ref.regexp;\n var keys = ref.keys;\n var m = pathname.match(regexp);\n\n if (!m) {\n return false\n } else if (!params) {\n return true\n }\n\n for (var i = 1, len = m.length; i < len; ++i) {\n var key = keys[i - 1];\n var val = typeof m[i] === 'string' ? decodeURIComponent(m[i]) : m[i];\n if (key) { params[key.name] = val; }\n }\n\n return true\n}\n\nfunction resolveRecordPath (path, record) {\n return resolvePath(path, record.parent ? record.parent.path : '/', true)\n}\n\n/* */\n\n\nvar positionStore = Object.create(null);\n\nfunction setupScroll () {\n window.addEventListener('popstate', function (e) {\n saveScrollPosition();\n if (e.state && e.state.key) {\n setStateKey(e.state.key);\n }\n });\n}\n\nfunction handleScroll (\n router,\n to,\n from,\n isPop\n) {\n if (!router.app) {\n return\n }\n\n var behavior = router.options.scrollBehavior;\n if (!behavior) {\n return\n }\n\n if (process.env.NODE_ENV !== 'production') {\n assert(typeof behavior === 'function', \"scrollBehavior must be a function\");\n }\n\n // wait until re-render finishes before scrolling\n router.app.$nextTick(function () {\n var position = getScrollPosition();\n var shouldScroll = behavior(to, from, isPop ? position : null);\n if (!shouldScroll) {\n return\n }\n var isObject = typeof shouldScroll === 'object';\n if (isObject && typeof shouldScroll.selector === 'string') {\n var el = document.querySelector(shouldScroll.selector);\n if (el) {\n position = getElementPosition(el);\n } else if (isValidPosition(shouldScroll)) {\n position = normalizePosition(shouldScroll);\n }\n } else if (isObject && isValidPosition(shouldScroll)) {\n position = normalizePosition(shouldScroll);\n }\n\n if (position) {\n window.scrollTo(position.x, position.y);\n }\n });\n}\n\nfunction saveScrollPosition () {\n var key = getStateKey();\n if (key) {\n positionStore[key] = {\n x: window.pageXOffset,\n y: window.pageYOffset\n };\n }\n}\n\nfunction getScrollPosition () {\n var key = getStateKey();\n if (key) {\n return positionStore[key]\n }\n}\n\nfunction getElementPosition (el) {\n var docRect = document.documentElement.getBoundingClientRect();\n var elRect = el.getBoundingClientRect();\n return {\n x: elRect.left - docRect.left,\n y: elRect.top - docRect.top\n }\n}\n\nfunction isValidPosition (obj) {\n return isNumber(obj.x) || isNumber(obj.y)\n}\n\nfunction normalizePosition (obj) {\n return {\n x: isNumber(obj.x) ? obj.x : window.pageXOffset,\n y: isNumber(obj.y) ? obj.y : window.pageYOffset\n }\n}\n\nfunction isNumber (v) {\n return typeof v === 'number'\n}\n\n/* */\n\nvar supportsPushState = inBrowser && (function () {\n var ua = window.navigator.userAgent;\n\n if (\n (ua.indexOf('Android 2.') !== -1 || ua.indexOf('Android 4.0') !== -1) &&\n ua.indexOf('Mobile Safari') !== -1 &&\n ua.indexOf('Chrome') === -1 &&\n ua.indexOf('Windows Phone') === -1\n ) {\n return false\n }\n\n return window.history && 'pushState' in window.history\n})();\n\n// use User Timing api (if present) for more accurate key precision\nvar Time = inBrowser && window.performance && window.performance.now\n ? window.performance\n : Date;\n\nvar _key = genKey();\n\nfunction genKey () {\n return Time.now().toFixed(3)\n}\n\nfunction getStateKey () {\n return _key\n}\n\nfunction setStateKey (key) {\n _key = key;\n}\n\nfunction pushState (url, replace) {\n saveScrollPosition();\n // try...catch the pushState call to get around Safari\n // DOM Exception 18 where it limits to 100 pushState calls\n var history = window.history;\n try {\n if (replace) {\n history.replaceState({ key: _key }, '', url);\n } else {\n _key = genKey();\n history.pushState({ key: _key }, '', url);\n }\n } catch (e) {\n window.location[replace ? 'replace' : 'assign'](url);\n }\n}\n\nfunction replaceState (url) {\n pushState(url, true);\n}\n\n/* */\n\nfunction runQueue (queue, fn, cb) {\n var step = function (index) {\n if (index >= queue.length) {\n cb();\n } else {\n if (queue[index]) {\n fn(queue[index], function () {\n step(index + 1);\n });\n } else {\n step(index + 1);\n }\n }\n };\n step(0);\n}\n\n/* */\n\n\nvar History = function History (router, base) {\n this.router = router;\n this.base = normalizeBase(base);\n // start with a route object that stands for \"nowhere\"\n this.current = START;\n this.pending = null;\n this.ready = false;\n this.readyCbs = [];\n};\n\nHistory.prototype.listen = function listen (cb) {\n this.cb = cb;\n};\n\nHistory.prototype.onReady = function onReady (cb) {\n if (this.ready) {\n cb();\n } else {\n this.readyCbs.push(cb);\n }\n};\n\nHistory.prototype.transitionTo = function transitionTo (location, onComplete, onAbort) {\n var this$1 = this;\n\n var route = this.router.match(location, this.current);\n this.confirmTransition(route, function () {\n this$1.updateRoute(route);\n onComplete && onComplete(route);\n this$1.ensureURL();\n\n // fire ready cbs once\n if (!this$1.ready) {\n this$1.ready = true;\n this$1.readyCbs.forEach(function (cb) {\n cb(route);\n });\n }\n }, onAbort);\n};\n\nHistory.prototype.confirmTransition = function confirmTransition (route, onComplete, onAbort) {\n var this$1 = this;\n\n var current = this.current;\n var abort = function () { onAbort && onAbort(); };\n if (\n isSameRoute(route, current) &&\n // in the case the route map has been dynamically appended to\n route.matched.length === current.matched.length\n ) {\n this.ensureURL();\n return abort()\n }\n\n var ref = resolveQueue(this.current.matched, route.matched);\n var updated = ref.updated;\n var deactivated = ref.deactivated;\n var activated = ref.activated;\n\n var queue = [].concat(\n // in-component leave guards\n extractLeaveGuards(deactivated),\n // global before hooks\n this.router.beforeHooks,\n // in-component update hooks\n extractUpdateHooks(updated),\n // in-config enter guards\n activated.map(function (m) { return m.beforeEnter; }),\n // async components\n resolveAsyncComponents(activated)\n );\n\n this.pending = route;\n var iterator = function (hook, next) {\n if (this$1.pending !== route) {\n return abort()\n }\n hook(route, current, function (to) {\n if (to === false) {\n // next(false) -> abort navigation, ensure current URL\n this$1.ensureURL(true);\n abort();\n } else if (typeof to === 'string' || typeof to === 'object') {\n // next('/') or next({ path: '/' }) -> redirect\n (typeof to === 'object' && to.replace) ? this$1.replace(to) : this$1.push(to);\n abort();\n } else {\n // confirm transition and pass on the value\n next(to);\n }\n });\n };\n\n runQueue(queue, iterator, function () {\n var postEnterCbs = [];\n var isValid = function () { return this$1.current === route; };\n var enterGuards = extractEnterGuards(activated, postEnterCbs, isValid);\n // wait until async components are resolved before\n // extracting in-component enter guards\n runQueue(enterGuards, iterator, function () {\n if (this$1.pending !== route) {\n return abort()\n }\n this$1.pending = null;\n onComplete(route);\n if (this$1.router.app) {\n this$1.router.app.$nextTick(function () {\n postEnterCbs.forEach(function (cb) { return cb(); });\n });\n }\n });\n });\n};\n\nHistory.prototype.updateRoute = function updateRoute (route) {\n var prev = this.current;\n this.current = route;\n this.cb && this.cb(route);\n this.router.afterHooks.forEach(function (hook) {\n hook && hook(route, prev);\n });\n};\n\nfunction normalizeBase (base) {\n if (!base) {\n if (inBrowser) {\n // respect <base> tag\n var baseEl = document.querySelector('base');\n base = baseEl ? baseEl.getAttribute('href') : '/';\n } else {\n base = '/';\n }\n }\n // make sure there's the starting slash\n if (base.charAt(0) !== '/') {\n base = '/' + base;\n }\n // remove trailing slash\n return base.replace(/\\/$/, '')\n}\n\nfunction resolveQueue (\n current,\n next\n) {\n var i;\n var max = Math.max(current.length, next.length);\n for (i = 0; i < max; i++) {\n if (current[i] !== next[i]) {\n break\n }\n }\n return {\n updated: next.slice(0, i),\n activated: next.slice(i),\n deactivated: current.slice(i)\n }\n}\n\nfunction extractGuards (\n records,\n name,\n bind,\n reverse\n) {\n var guards = flatMapComponents(records, function (def, instance, match, key) {\n var guard = extractGuard(def, name);\n if (guard) {\n return Array.isArray(guard)\n ? guard.map(function (guard) { return bind(guard, instance, match, key); })\n : bind(guard, instance, match, key)\n }\n });\n return flatten(reverse ? guards.reverse() : guards)\n}\n\nfunction extractGuard (\n def,\n key\n) {\n if (typeof def !== 'function') {\n // extend now so that global mixins are applied.\n def = _Vue.extend(def);\n }\n return def.options[key]\n}\n\nfunction extractLeaveGuards (deactivated) {\n return extractGuards(deactivated, 'beforeRouteLeave', bindGuard, true)\n}\n\nfunction extractUpdateHooks (updated) {\n return extractGuards(updated, 'beforeRouteUpdate', bindGuard)\n}\n\nfunction bindGuard (guard, instance) {\n return function boundRouteGuard () {\n return guard.apply(instance, arguments)\n }\n}\n\nfunction extractEnterGuards (\n activated,\n cbs,\n isValid\n) {\n return extractGuards(activated, 'beforeRouteEnter', function (guard, _, match, key) {\n return bindEnterGuard(guard, match, key, cbs, isValid)\n })\n}\n\nfunction bindEnterGuard (\n guard,\n match,\n key,\n cbs,\n isValid\n) {\n return function routeEnterGuard (to, from, next) {\n return guard(to, from, function (cb) {\n next(cb);\n if (typeof cb === 'function') {\n cbs.push(function () {\n // #750\n // if a router-view is wrapped with an out-in transition,\n // the instance may not have been registered at this time.\n // we will need to poll for registration until current route\n // is no longer valid.\n poll(cb, match.instances, key, isValid);\n });\n }\n })\n }\n}\n\nfunction poll (\n cb, // somehow flow cannot infer this is a function\n instances,\n key,\n isValid\n) {\n if (instances[key]) {\n cb(instances[key]);\n } else if (isValid()) {\n setTimeout(function () {\n poll(cb, instances, key, isValid);\n }, 16);\n }\n}\n\nfunction resolveAsyncComponents (matched) {\n return flatMapComponents(matched, function (def, _, match, key) {\n // if it's a function and doesn't have Vue options attached,\n // assume it's an async component resolve function.\n // we are not using Vue's default async resolving mechanism because\n // we want to halt the navigation until the incoming component has been\n // resolved.\n if (typeof def === 'function' && !def.options) {\n return function (to, from, next) {\n var resolve = once(function (resolvedDef) {\n match.components[key] = resolvedDef;\n next();\n });\n\n var reject = once(function (reason) {\n warn(false, (\"Failed to resolve async component \" + key + \": \" + reason));\n next(false);\n });\n\n var res = def(resolve, reject);\n if (res && typeof res.then === 'function') {\n res.then(resolve, reject);\n }\n }\n }\n })\n}\n\nfunction flatMapComponents (\n matched,\n fn\n) {\n return flatten(matched.map(function (m) {\n return Object.keys(m.components).map(function (key) { return fn(\n m.components[key],\n m.instances[key],\n m, key\n ); })\n }))\n}\n\nfunction flatten (arr) {\n return Array.prototype.concat.apply([], arr)\n}\n\n// in Webpack 2, require.ensure now also returns a Promise\n// so the resolve/reject functions may get called an extra time\n// if the user uses an arrow function shorthand that happens to\n// return that Promise.\nfunction once (fn) {\n var called = false;\n return function () {\n if (called) { return }\n called = true;\n return fn.apply(this, arguments)\n }\n}\n\n/* */\n\n\nvar HTML5History = (function (History$$1) {\n function HTML5History (router, base) {\n var this$1 = this;\n\n History$$1.call(this, router, base);\n\n var expectScroll = router.options.scrollBehavior;\n\n if (expectScroll) {\n setupScroll();\n }\n\n window.addEventListener('popstate', function (e) {\n this$1.transitionTo(getLocation(this$1.base), function (route) {\n if (expectScroll) {\n handleScroll(router, route, this$1.current, true);\n }\n });\n });\n }\n\n if ( History$$1 ) HTML5History.__proto__ = History$$1;\n HTML5History.prototype = Object.create( History$$1 && History$$1.prototype );\n HTML5History.prototype.constructor = HTML5History;\n\n HTML5History.prototype.go = function go (n) {\n window.history.go(n);\n };\n\n HTML5History.prototype.push = function push (location, onComplete, onAbort) {\n var this$1 = this;\n\n this.transitionTo(location, function (route) {\n pushState(cleanPath(this$1.base + route.fullPath));\n handleScroll(this$1.router, route, this$1.current, false);\n onComplete && onComplete(route);\n }, onAbort);\n };\n\n HTML5History.prototype.replace = function replace (location, onComplete, onAbort) {\n var this$1 = this;\n\n this.transitionTo(location, function (route) {\n replaceState(cleanPath(this$1.base + route.fullPath));\n handleScroll(this$1.router, route, this$1.current, false);\n onComplete && onComplete(route);\n }, onAbort);\n };\n\n HTML5History.prototype.ensureURL = function ensureURL (push) {\n if (getLocation(this.base) !== this.current.fullPath) {\n var current = cleanPath(this.base + this.current.fullPath);\n push ? pushState(current) : replaceState(current);\n }\n };\n\n HTML5History.prototype.getCurrentLocation = function getCurrentLocation () {\n return getLocation(this.base)\n };\n\n return HTML5History;\n}(History));\n\nfunction getLocation (base) {\n var path = window.location.pathname;\n if (base && path.indexOf(base) === 0) {\n path = path.slice(base.length);\n }\n return (path || '/') + window.location.search + window.location.hash\n}\n\n/* */\n\n\nvar HashHistory = (function (History$$1) {\n function HashHistory (router, base, fallback) {\n History$$1.call(this, router, base);\n // check history fallback deeplinking\n if (fallback && checkFallback(this.base)) {\n return\n }\n ensureSlash();\n }\n\n if ( History$$1 ) HashHistory.__proto__ = History$$1;\n HashHistory.prototype = Object.create( History$$1 && History$$1.prototype );\n HashHistory.prototype.constructor = HashHistory;\n\n // this is delayed until the app mounts\n // to avoid the hashchange listener being fired too early\n HashHistory.prototype.setupListeners = function setupListeners () {\n var this$1 = this;\n\n window.addEventListener('hashchange', function () {\n if (!ensureSlash()) {\n return\n }\n this$1.transitionTo(getHash(), function (route) {\n replaceHash(route.fullPath);\n });\n });\n };\n\n HashHistory.prototype.push = function push (location, onComplete, onAbort) {\n this.transitionTo(location, function (route) {\n pushHash(route.fullPath);\n onComplete && onComplete(route);\n }, onAbort);\n };\n\n HashHistory.prototype.replace = function replace (location, onComplete, onAbort) {\n this.transitionTo(location, function (route) {\n replaceHash(route.fullPath);\n onComplete && onComplete(route);\n }, onAbort);\n };\n\n HashHistory.prototype.go = function go (n) {\n window.history.go(n);\n };\n\n HashHistory.prototype.ensureURL = function ensureURL (push) {\n var current = this.current.fullPath;\n if (getHash() !== current) {\n push ? pushHash(current) : replaceHash(current);\n }\n };\n\n HashHistory.prototype.getCurrentLocation = function getCurrentLocation () {\n return getHash()\n };\n\n return HashHistory;\n}(History));\n\nfunction checkFallback (base) {\n var location = getLocation(base);\n if (!/^\\/#/.test(location)) {\n window.location.replace(\n cleanPath(base + '/#' + location)\n );\n return true\n }\n}\n\nfunction ensureSlash () {\n var path = getHash();\n if (path.charAt(0) === '/') {\n return true\n }\n replaceHash('/' + path);\n return false\n}\n\nfunction getHash () {\n // We can't use window.location.hash here because it's not\n // consistent across browsers - Firefox will pre-decode it!\n var href = window.location.href;\n var index = href.indexOf('#');\n return index === -1 ? '' : href.slice(index + 1)\n}\n\nfunction pushHash (path) {\n window.location.hash = path;\n}\n\nfunction replaceHash (path) {\n var i = window.location.href.indexOf('#');\n window.location.replace(\n window.location.href.slice(0, i >= 0 ? i : 0) + '#' + path\n );\n}\n\n/* */\n\n\nvar AbstractHistory = (function (History$$1) {\n function AbstractHistory (router, base) {\n History$$1.call(this, router, base);\n this.stack = [];\n this.index = -1;\n }\n\n if ( History$$1 ) AbstractHistory.__proto__ = History$$1;\n AbstractHistory.prototype = Object.create( History$$1 && History$$1.prototype );\n AbstractHistory.prototype.constructor = AbstractHistory;\n\n AbstractHistory.prototype.push = function push (location, onComplete, onAbort) {\n var this$1 = this;\n\n this.transitionTo(location, function (route) {\n this$1.stack = this$1.stack.slice(0, this$1.index + 1).concat(route);\n this$1.index++;\n onComplete && onComplete(route);\n }, onAbort);\n };\n\n AbstractHistory.prototype.replace = function replace (location, onComplete, onAbort) {\n var this$1 = this;\n\n this.transitionTo(location, function (route) {\n this$1.stack = this$1.stack.slice(0, this$1.index).concat(route);\n onComplete && onComplete(route);\n }, onAbort);\n };\n\n AbstractHistory.prototype.go = function go (n) {\n var this$1 = this;\n\n var targetIndex = this.index + n;\n if (targetIndex < 0 || targetIndex >= this.stack.length) {\n return\n }\n var route = this.stack[targetIndex];\n this.confirmTransition(route, function () {\n this$1.index = targetIndex;\n this$1.updateRoute(route);\n });\n };\n\n AbstractHistory.prototype.getCurrentLocation = function getCurrentLocation () {\n var current = this.stack[this.stack.length - 1];\n return current ? current.fullPath : '/'\n };\n\n AbstractHistory.prototype.ensureURL = function ensureURL () {\n // noop\n };\n\n return AbstractHistory;\n}(History));\n\n/* */\n\nvar VueRouter = function VueRouter (options) {\n if ( options === void 0 ) options = {};\n\n this.app = null;\n this.apps = [];\n this.options = options;\n this.beforeHooks = [];\n this.afterHooks = [];\n this.matcher = createMatcher(options.routes || []);\n\n var mode = options.mode || 'hash';\n this.fallback = mode === 'history' && !supportsPushState;\n if (this.fallback) {\n mode = 'hash';\n }\n if (!inBrowser) {\n mode = 'abstract';\n }\n this.mode = mode;\n\n switch (mode) {\n case 'history':\n this.history = new HTML5History(this, options.base);\n break\n case 'hash':\n this.history = new HashHistory(this, options.base, this.fallback);\n break\n case 'abstract':\n this.history = new AbstractHistory(this, options.base);\n break\n default:\n if (process.env.NODE_ENV !== 'production') {\n assert(false, (\"invalid mode: \" + mode));\n }\n }\n};\n\nvar prototypeAccessors = { currentRoute: {} };\n\nVueRouter.prototype.match = function match (\n raw,\n current,\n redirectedFrom\n) {\n return this.matcher.match(raw, current, redirectedFrom)\n};\n\nprototypeAccessors.currentRoute.get = function () {\n return this.history && this.history.current\n};\n\nVueRouter.prototype.init = function init (app /* Vue component instance */) {\n var this$1 = this;\n\n process.env.NODE_ENV !== 'production' && assert(\n install.installed,\n \"not installed. Make sure to call `Vue.use(VueRouter)` \" +\n \"before creating root instance.\"\n );\n\n this.apps.push(app);\n\n // main app already initialized.\n if (this.app) {\n return\n }\n\n this.app = app;\n\n var history = this.history;\n\n if (history instanceof HTML5History) {\n history.transitionTo(history.getCurrentLocation());\n } else if (history instanceof HashHistory) {\n var setupHashListener = function () {\n history.setupListeners();\n };\n history.transitionTo(\n history.getCurrentLocation(),\n setupHashListener,\n setupHashListener\n );\n }\n\n history.listen(function (route) {\n this$1.apps.forEach(function (app) {\n app._route = route;\n });\n });\n};\n\nVueRouter.prototype.beforeEach = function beforeEach (fn) {\n this.beforeHooks.push(fn);\n};\n\nVueRouter.prototype.afterEach = function afterEach (fn) {\n this.afterHooks.push(fn);\n};\n\nVueRouter.prototype.onReady = function onReady (cb) {\n this.history.onReady(cb);\n};\n\nVueRouter.prototype.push = function push (location, onComplete, onAbort) {\n this.history.push(location, onComplete, onAbort);\n};\n\nVueRouter.prototype.replace = function replace (location, onComplete, onAbort) {\n this.history.replace(location, onComplete, onAbort);\n};\n\nVueRouter.prototype.go = function go (n) {\n this.history.go(n);\n};\n\nVueRouter.prototype.back = function back () {\n this.go(-1);\n};\n\nVueRouter.prototype.forward = function forward () {\n this.go(1);\n};\n\nVueRouter.prototype.getMatchedComponents = function getMatchedComponents (to) {\n var route = to\n ? this.resolve(to).route\n : this.currentRoute;\n if (!route) {\n return []\n }\n return [].concat.apply([], route.matched.map(function (m) {\n return Object.keys(m.components).map(function (key) {\n return m.components[key]\n })\n }))\n};\n\nVueRouter.prototype.resolve = function resolve (\n to,\n current,\n append\n) {\n var location = normalizeLocation(to, current || this.history.current, append);\n var route = this.match(location, current);\n var fullPath = route.redirectedFrom || route.fullPath;\n var base = this.history.base;\n var href = createHref(base, fullPath, this.mode);\n return {\n location: location,\n route: route,\n href: href,\n // for backwards compat\n normalizedTo: location,\n resolved: route\n }\n};\n\nVueRouter.prototype.addRoutes = function addRoutes (routes) {\n this.matcher.addRoutes(routes);\n if (this.history.current !== START) {\n this.history.transitionTo(this.history.getCurrentLocation());\n }\n};\n\nObject.defineProperties( VueRouter.prototype, prototypeAccessors );\n\nfunction createHref (base, fullPath, mode) {\n var path = mode === 'hash' ? '#' + fullPath : fullPath;\n return base ? cleanPath(base + '/' + path) : path\n}\n\nVueRouter.install = install;\nVueRouter.version = '2.2.1';\n\nif (inBrowser && window.Vue) {\n window.Vue.use(VueRouter);\n}\n\nmodule.exports = VueRouter;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/vue-router/dist/vue-router.common.js\n// module id = 80\n// module chunks = 0","/**\n * Translates the list format produced by css-loader into something\n * easier to manipulate.\n */\nmodule.exports = function listToStyles (parentId, list) {\n var styles = []\n var newStyles = {}\n for (var i = 0; i < list.length; i++) {\n var item = list[i]\n var id = item[0]\n var css = item[1]\n var media = item[2]\n var sourceMap = item[3]\n var part = {\n id: parentId + ':' + i,\n css: css,\n media: media,\n sourceMap: sourceMap\n }\n if (!newStyles[id]) {\n styles.push(newStyles[id] = { id: id, parts: [part] })\n } else {\n newStyles[id].parts.push(part)\n }\n }\n return styles\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/vue-style-loader/lib/listToStyles.js\n// module id = 81\n// module chunks = 0","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/global.js\n// module id = 82\n// module chunks = 0","/*\r\n\tMIT License http://www.opensource.org/licenses/mit-license.php\r\n\tAuthor Tobias Koppers @sokra\r\n*/\r\n// css base code, injected by the css-loader\r\nmodule.exports = function() {\r\n\tvar list = [];\r\n\r\n\t// return the list of modules as css string\r\n\tlist.toString = function toString() {\r\n\t\tvar result = [];\r\n\t\tfor(var i = 0; i < this.length; i++) {\r\n\t\t\tvar item = this[i];\r\n\t\t\tif(item[2]) {\r\n\t\t\t\tresult.push(\"@media \" + item[2] + \"{\" + item[1] + \"}\");\r\n\t\t\t} else {\r\n\t\t\t\tresult.push(item[1]);\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn result.join(\"\");\r\n\t};\r\n\r\n\t// import a list of modules into the list\r\n\tlist.i = function(modules, mediaQuery) {\r\n\t\tif(typeof modules === \"string\")\r\n\t\t\tmodules = [[null, modules, \"\"]];\r\n\t\tvar alreadyImportedModules = {};\r\n\t\tfor(var i = 0; i < this.length; i++) {\r\n\t\t\tvar id = this[i][0];\r\n\t\t\tif(typeof id === \"number\")\r\n\t\t\t\talreadyImportedModules[id] = true;\r\n\t\t}\r\n\t\tfor(i = 0; i < modules.length; i++) {\r\n\t\t\tvar item = modules[i];\r\n\t\t\t// skip already imported module\r\n\t\t\t// this implementation is not 100% perfect for weird media query combinations\r\n\t\t\t// when a module is imported multiple times with different media queries.\r\n\t\t\t// I hope this will never occur (Hey this way we have smaller bundles)\r\n\t\t\tif(typeof item[0] !== \"number\" || !alreadyImportedModules[item[0]]) {\r\n\t\t\t\tif(mediaQuery && !item[2]) {\r\n\t\t\t\t\titem[2] = mediaQuery;\r\n\t\t\t\t} else if(mediaQuery) {\r\n\t\t\t\t\titem[2] = \"(\" + item[2] + \") and (\" + mediaQuery + \")\";\r\n\t\t\t\t}\r\n\t\t\t\tlist.push(item);\r\n\t\t\t}\r\n\t\t}\r\n\t};\r\n\treturn list;\r\n};\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/css-loader/lib/css-base.js\n// module id = 84\n// module chunks = 0","/*\n MIT License http://www.opensource.org/licenses/mit-license.php\n Author Tobias Koppers @sokra\n Modified by Evan You @yyx990803\n*/\n\nvar hasDocument = typeof document !== 'undefined'\n\nif (typeof DEBUG !== 'undefined' && DEBUG) {\n if (!hasDocument) {\n throw new Error(\n 'vue-style-loader cannot be used in a non-browser environment. ' +\n \"Use { target: 'node' } in your Webpack config to indicate a server-rendering environment.\"\n ) }\n}\n\nvar listToStyles = require('./listToStyles')\n\n/*\ntype StyleObject = {\n id: number;\n parts: Array<StyleObjectPart>\n}\n\ntype StyleObjectPart = {\n css: string;\n media: string;\n sourceMap: ?string\n}\n*/\n\nvar stylesInDom = {/*\n [id: number]: {\n id: number,\n refs: number,\n parts: Array<(obj?: StyleObjectPart) => void>\n }\n*/}\n\nvar head = hasDocument && (document.head || document.getElementsByTagName('head')[0])\nvar singletonElement = null\nvar singletonCounter = 0\nvar isProduction = false\nvar noop = function () {}\n\n// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>\n// tags it will allow on a page\nvar isOldIE = typeof navigator !== 'undefined' && /msie [6-9]\\b/.test(navigator.userAgent.toLowerCase())\n\nmodule.exports = function (parentId, list, _isProduction) {\n isProduction = _isProduction\n\n var styles = listToStyles(parentId, list)\n addStylesToDom(styles)\n\n return function update (newList) {\n var mayRemove = []\n for (var i = 0; i < styles.length; i++) {\n var item = styles[i]\n var domStyle = stylesInDom[item.id]\n domStyle.refs--\n mayRemove.push(domStyle)\n }\n if (newList) {\n styles = listToStyles(parentId, newList)\n addStylesToDom(styles)\n } else {\n styles = []\n }\n for (var i = 0; i < mayRemove.length; i++) {\n var domStyle = mayRemove[i]\n if (domStyle.refs === 0) {\n for (var j = 0; j < domStyle.parts.length; j++) {\n domStyle.parts[j]()\n }\n delete stylesInDom[domStyle.id]\n }\n }\n }\n}\n\nfunction addStylesToDom (styles /* Array<StyleObject> */) {\n for (var i = 0; i < styles.length; i++) {\n var item = styles[i]\n var domStyle = stylesInDom[item.id]\n if (domStyle) {\n domStyle.refs++\n for (var j = 0; j < domStyle.parts.length; j++) {\n domStyle.parts[j](item.parts[j])\n }\n for (; j < item.parts.length; j++) {\n domStyle.parts.push(addStyle(item.parts[j]))\n }\n if (domStyle.parts.length > item.parts.length) {\n domStyle.parts.length = item.parts.length\n }\n } else {\n var parts = []\n for (var j = 0; j < item.parts.length; j++) {\n parts.push(addStyle(item.parts[j]))\n }\n stylesInDom[item.id] = { id: item.id, refs: 1, parts: parts }\n }\n }\n}\n\nfunction listToStyles (parentId, list) {\n var styles = []\n var newStyles = {}\n for (var i = 0; i < list.length; i++) {\n var item = list[i]\n var id = item[0]\n var css = item[1]\n var media = item[2]\n var sourceMap = item[3]\n var part = { css: css, media: media, sourceMap: sourceMap }\n if (!newStyles[id]) {\n part.id = parentId + ':0'\n styles.push(newStyles[id] = { id: id, parts: [part] })\n } else {\n part.id = parentId + ':' + newStyles[id].parts.length\n newStyles[id].parts.push(part)\n }\n }\n return styles\n}\n\nfunction createStyleElement () {\n var styleElement = document.createElement('style')\n styleElement.type = 'text/css'\n head.appendChild(styleElement)\n return styleElement\n}\n\nfunction addStyle (obj /* StyleObjectPart */) {\n var update, remove\n var styleElement = document.querySelector('style[data-vue-ssr-id~=\"' + obj.id + '\"]')\n var hasSSR = styleElement != null\n\n // if in production mode and style is already provided by SSR,\n // simply do nothing.\n if (hasSSR && isProduction) {\n return noop\n }\n\n if (isOldIE) {\n // use singleton mode for IE9.\n var styleIndex = singletonCounter++\n styleElement = singletonElement || (singletonElement = createStyleElement())\n update = applyToSingletonTag.bind(null, styleElement, styleIndex, false)\n remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true)\n } else {\n // use multi-style-tag mode in all other cases\n styleElement = styleElement || createStyleElement()\n update = applyToTag.bind(null, styleElement)\n remove = function () {\n styleElement.parentNode.removeChild(styleElement)\n }\n }\n\n if (!hasSSR) {\n update(obj)\n }\n\n return function updateStyle (newObj /* StyleObjectPart */) {\n if (newObj) {\n if (newObj.css === obj.css &&\n newObj.media === obj.media &&\n newObj.sourceMap === obj.sourceMap) {\n return\n }\n update(obj = newObj)\n } else {\n remove()\n }\n }\n}\n\nvar replaceText = (function () {\n var textStore = []\n\n return function (index, replacement) {\n textStore[index] = replacement\n return textStore.filter(Boolean).join('\\n')\n }\n})()\n\nfunction applyToSingletonTag (styleElement, index, remove, obj) {\n var css = remove ? '' : obj.css\n\n if (styleElement.styleSheet) {\n styleElement.styleSheet.cssText = replaceText(index, css)\n } else {\n var cssNode = document.createTextNode(css)\n var childNodes = styleElement.childNodes\n if (childNodes[index]) styleElement.removeChild(childNodes[index])\n if (childNodes.length) {\n styleElement.insertBefore(cssNode, childNodes[index])\n } else {\n styleElement.appendChild(cssNode)\n }\n }\n}\n\nfunction applyToTag (styleElement, obj) {\n var css = obj.css\n var media = obj.media\n var sourceMap = obj.sourceMap\n\n if (media) {\n styleElement.setAttribute('media', media)\n }\n\n if (sourceMap) {\n // https://developer.chrome.com/devtools/docs/javascript-debugging\n // this makes source maps inside style tags work properly in Chrome\n css += '\\n/*# sourceURL=' + sourceMap.sources[0] + ' */'\n // http://stackoverflow.com/a/26603875\n css += '\\n/*# sourceMappingURL=data:application/json;base64,' + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + ' */'\n }\n\n if (styleElement.styleSheet) {\n styleElement.styleSheet.cssText = css\n } else {\n while (styleElement.firstChild) {\n styleElement.removeChild(styleElement.firstChild)\n }\n styleElement.appendChild(document.createTextNode(css))\n }\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/vue-style-loader/lib/addStylesClient.js\n// module id = 85\n// module chunks = 0"],"sourceRoot":""} |