{"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', '&#10;') : 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 = /&lt;/g;\nvar gtRE = /&gt;/g;\nvar nlRE = /&#10;/g;\nvar ampRE = /&amp;/g;\nvar quoteRE = /&quot;/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', '&#10;') : 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 = /&lt;/g;\nvar gtRE = /&gt;/g;\nvar nlRE = /&#10;/g;\nvar ampRE = /&amp;/g;\nvar quoteRE = /&quot;/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":""}