You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 lines
2.0 MiB
1 lines
2.0 MiB
{"version":3,"sources":["webpack:///static/js/vendor.68e97f3128ceb6fa491d.js","webpack:///./~/core-js/library/modules/_wks.js","webpack:///./~/vue-loader/lib/component-normalizer.js","webpack:///./~/core-js/library/modules/_global.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:///./~/d3/build/d3.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:///./~/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","rawScriptExports","compiledTemplate","scopeId","cssModules","esModule","scriptExports","type","default","options","render","staticRenderFns","_scopeId","computed","Object","keys","forEach","key","global","window","Math","self","Function","__g","isObject","it","TypeError","defineProperty","get","a","hasOwnProperty","call","dP","createDesc","object","value","f","anObject","IE8_DOM_DEFINE","toPrimitive","O","P","Attributes","e","factory","this","ascendingComparator","d","x","ascending","tickStep","start","stop","count","step0","abs","max","step1","pow","floor","log","LN10","error","e10","e5","e2","length","translateX","scale0","scale1","isFinite","translateY","y","center","scale","offset","bandwidth","round","entering","__axis","axis","orient","context","values","tickValues","ticks","apply","tickArguments","domain","format","tickFormat","identity$1","spacing","tickSizeInner","tickPadding","transform","top","bottom","range","range0","range1","position","copy","selection","path","selectAll","data","tick","order","tickExit","exit","tickEnter","enter","append","attr","line","select","text","k","left","right","merge","insert","transition","epsilon","parentNode","remove","tickSizeOuter","filter","each","_","arguments","slice$1","slice","tickSize","axisTop","axisRight","axisBottom","axisLeft","dispatch","t","i","n","Error","Dispatch","parseTypenames","typenames","types","trim","split","map","indexOf","c","set","callback","noop","concat","push","creatorInherit","document","ownerDocument","uri","namespaceURI","xhtml","documentElement","createElement","createElementNS","creatorFixed","fullname","space","local","local$1","Local","nextId","toString","filterContextListener","listener","index","group","contextListener","event","related","relatedTarget","compareDocumentPosition","event1","event0","__data__","parseTypenames$1","onRemove","typename","on","__on","o","j","m","removeEventListener","capture","onAdd","wrap","filterEvents","addEventListener","customEvent","that","args","sourceEvent","none","empty$1","EnterNode","parent","datum","_next","_parent","bindIndex","update","node","groupLength","dataLength","bindKey","keyValue","nodeByKeyValue","keyValues","Array","keyPrefix","ascending$1","b","NaN","attrRemove","removeAttribute","attrRemoveNS","removeAttributeNS","attrConstant","setAttribute","attrConstantNS","setAttributeNS","attrFunction","v","attrFunctionNS","styleRemove","style","removeProperty","styleConstant","priority","setProperty","styleFunction","propertyRemove","propertyConstant","propertyFunction","classArray","string","classList","ClassList","_node","_names","getAttribute","classedAdd","names","list","add","classedRemove","classedTrue","classedFalse","classedFunction","textRemove","textContent","textConstant","textFunction","htmlRemove","innerHTML","htmlConstant","htmlFunction","raise","nextSibling","appendChild","lower","previousSibling","insertBefore","firstChild","constantNull","removeChild","dispatchEvent","params","window$$1","CustomEvent","createEvent","initEvent","bubbles","cancelable","detail","dispatchConstant","dispatchFunction","Selection","groups","parents","_groups","_parents","root","nopropagation","stopImmediatePropagation","yesdrag","view","noclick","selection$$1","noevent","setTimeout","MozUserSelect","__noselect","DragEvent","target","subject","id","active","dx","dy","identifier","defaultFilter$1","button","defaultContainer","defaultSubject","extend","definition","prototype","create","Color","color","toLowerCase","reHex3","exec","parseInt","Rgb","reHex6","rgbn","reRgbInteger","reRgbPercent","reRgbaInteger","rgba","reRgbaPercent","reHslPercent","hsla","reHslaPercent","named","r","g","rgbConvert","rgb","opacity","h","s","l","Hsl","hslConvert","min","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","C","D","cubehelix","basis","v0","v1","v2","v3","linear","exponential","hue","constant$3","isNaN","gamma","nogamma","rgbSpline","spline","colors","color$$1","zero","one","parseCss","identity$2","cssNode","cssRoot","cssView","defaultView","getComputedStyle","getPropertyValue","decompose","parseSvg","svgNode","baseVal","consolidate","matrix","interpolateTransform","parse","pxComma","pxParen","degParen","pop","translate","xa","ya","xb","yb","q","reinterpolate","rotate","skewX","scaleX","scaleY","join","cosh","exp","sinh","tanh","hsl$1","hue$$1","end","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","timeout","nap","poke","pokeDelay","Infinity","taskTail","sleep","clearTimeout","interval","clearInterval","setInterval","init","schedule","__transition","state","CREATED","set$1","STARTING","get$1","elapsed","SCHEDULED","schedules","STARTED","timeout$1","RUNNING","ENDED","tween","duration","ease","ENDING","tweenRemove","tween0","tween1","splice","tweenFunction","tweenValue","_id","attrRemove$1","attrRemoveNS$1","attrConstant$1","interpolate$$1","value1","value00","interpolate0","value0","attrConstantNS$1","getAttributeNS","attrFunction$1","value10","attrFunctionNS$1","attrTweenNS","_value","attrTween","delayFunction","delayConstant","durationFunction","durationConstant","easeConstant","every","onFunction","on0","on1","sit","removeFunction","styleRemove$1","interpolate$$2","styleRemoveEnd","styleConstant$1","styleFunction$1","styleTween","textConstant$1","textFunction$1","Transition","_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","svg","ownerSVGElement","width","height","local$$1","__brush","empty","extent","brushSelection","dim","output","brushX","brush$1","X","brushY","Y","brush","overlay","property","initialize","cursors","handle","handles","redraw","started","handleSize","emitter","Emitter","moved","point1","mouse","shifting","lockX","lockY","point","moving","noevent$1","move","point0","mode","MODE_SPACE","MODE_DRAG","signX","W","w0","e0","w1","e1","signY","N","n0","S","s0","n1","s1","MODE_HANDLE","MODE_CENTER","flipX","flipY","emit","ended","touches","touchending","keydowned","keyCode","keyupped","altKey","changedTouches","metaKey","signsX","signsY","shiftKey","beforestart","dragDisable","interrupt","listeners","selection1","selection0","input","interpolateValue","starting","BrushEvent","constant$4","compareValue","compare","source","Path","_x0","_y0","_x1","_y1","defaultSource","defaultTarget","defaultRadius","radius","defaultStartAngle","startAngle","defaultEndAngle","endAngle","Map","map$1","isArray","createObject","setObject","createMap","setMap","Set","set$2","objectConverter","columns","JSON","stringify","customConverter","row","inferColumns","rows","columnSet","column","tree","xm","ym","xp","yp","_root","leaf","x0","y0","x1","y1","_x","_y","next","addAll","xz","yz","cover","removeAll","defaultX","defaultY","quadtree","nodes","Quadtree","undefined","leaf_copy","vx","vy","find","nodeById","nodeId","x$1","y$1","FormatSpecifier","specifier","match","re","fill","align","sign","symbol","comma","precision","formatTypes","identity$3","defaultLocale","locale$1","formatLocale","formatPrefix","Adder","reset","add$1","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","p","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","from","to","a1","corner","comparePoint","compareIntersection","ca","cb","activeStream","polygonInside","winding","polygon","a0","ring","bufferStream","segments","clean","startInside","cleanInside","clipPolygon","clipStream","first","v_","x_","y_","x__","y__","v__","rejoin","result","clipMin","clipMax","clipLine","clipBuffer","lengthLineStart","lengthStream","lengthPointFirst","lengthLineEnd","lambda0$2","sinPhi0$1","cosPhi0$1","lengthPoint","cosDelta","sinDelta","lengthSum","graticuleX","sequence","graticuleY","graticule","lines","ceil","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","_context","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","methods","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","cache","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","children","reduce","meanXReduce","maxY","maxYReduce","leafLeft","leafRight","sum","leastCommonAncestor","aNodes","ancestors","bNodes","hierarchy","child","childs","Node","valued","defaultChildren","eachBefore","computeHeight","node_copy","copyData","Node$2","encloses","dr","encloseN","L","B","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","shift","change","executeShifts","nextAncestor","vim","ancestor","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","_data","_waiting","_active","_ended","_start","poke$1","start$1","abort","noabort","maybeNotify","queue","concurrency","fixCallback","xhr","hasResponse","responseType","response","responseText","responseOf","request$$1","ordinal","unknown","implicit","slice$4","has","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","sort","quantiles","quantize$1","threshold$1","newInterval","floori","offseti","field","date","Date","test","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","charCodeAt","pads","charAt","newParse","newDate","parseSpecifier","day$$1","U","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","replace","requoteRe","RegExp","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","_k","_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","_t","stepBefore","stepAfter","stackValue","sum$2","series","x$4","y$4","RedBlackTree","RedBlackNode","R","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","unshift","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","version","hi","mid","ascendingBisect","bisectLeft","descending","number","variance","deviation","constant","identity","sturges","LN2","histogram","tz","bin","bins","freedmanDiaconis","scott","mean","median","numbers","arrays","merged","pairs","permute","permutes","scan","xi","xj","shuffle","random","transpose","zip","constructor","T","namespaces","xlink","xml","xmlns","namespace","prefix","creator","matcher","selector","matches","element","vendorMatches","webkitMatchesSelector","msMatchesSelector","mozMatchesSelector","oMatchesSelector","matcher$1","element$1","mouseenter","mouseleave","selection_on","current","createSVGPoint","clientX","clientY","matrixTransform","getScreenCTM","inverse","rect","getBoundingClientRect","clientLeft","clientTop","querySelector","selection_select","subgroups","subnode","subgroup","selectorAll","querySelectorAll","selection_selectAll","selection_filter","sparse","selection_enter","_enter","constant$1","selection_data","bind","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","html","touch","preventDefault","constant$2","drag","mousedowned","touchstarted","touchmoved","touchended","gesture","container","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","lastIndex","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","requestAnimationFrame","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","clear","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","substring","formatDefault","toPrecision","out","formatPrefixAuto","formatRounded","","toFixed","toUpperCase","formatSpecifier","prefixes","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","index$1","contextStream","projectionStream","measure","sum$1","polygonContains","sinPhi1","absDelta","intersection","phiArc","pointVisible","sink","pointLine","pointRing","ringSink","ringSegments","ringBuffer","polygonStarted","rotatedStart","cr","point2","smallRadius","code","notHemisphere","two","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","user","password","XDomainRequest","onload","onerror","ontimeout","onreadystatechange","readyState","onprogress","header","send","post","method","open","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","defined","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","square","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","px","py","natural","slice$5","none$1","none$2","stack","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","core","__e","bitmap","enumerable","configurable","writable","shared","_toString","val","String","toNumber","parseFloat","makeMap","str","expectsLowerCase","remove$1","arr","item","hasOwn","obj","isPrimitive","cached","fn","hit","bind$1","ctx","boundFn","_length","toArray","ret","_from","isPlainObject","OBJECT_STRING","toObject","res","genStaticKeys","modules","staticKeys","looseEqual","isObjectA","isObjectB","looseIndexOf","isReserved","def","parsePath","bailRE","isNative","Ctor","pushTarget","_target","Dep","targetStack","popTarget","protoAugment","src","__proto__","copyAugment","observe","asRootData","ob","__ob__","Observer","observerState","shouldConvert","isServerRendering","isExtensible","_isVue","vmCount","defineReactive$$1","customSetter","dep","getOwnPropertyDescriptor","getter","setter","childOb","depend","dependArray","newVal","notify","del","mergeData","toVal","fromVal","mergeHook","parentVal","childVal","mergeAssets","normalizeProps","props","camelize","normalizeDirectives","dirs","directives","mergeOptions","vm","mergeField","strat","strats","defaultStrat","extendsFrom","extends","mixins","mixin","Vue$3","resolveAsset","warnMissing","assets","camelizedId","PascalCaseId","capitalize","validateProp","propOptions","propsData","prop","absent","isType","Boolean","hyphenate","getPropDefaultValue","prevShouldConvert","$options","getType","len","createTextVNode","VNode","cloneVNode","vnode","cloned","tag","elm","componentOptions","ns","isStatic","isCloned","cloneVNodes","vnodes","createComponent","baseCtor","_base","cid","resolved","resolveAsyncComponent","$forceUpdate","resolveConstructorOptions","extractProps","functional","createFunctionalComponent","nativeOn","abstract","mergeHooks","slots","resolveSlots","functionalContext","slot","createComponentInstanceForVnode","parentElm","refElm","vnodeComponentOptions","_isComponent","_componentTag","_parentVnode","_parentListeners","_renderChildren","_parentElm","_refElm","inlineTemplate","hydrating","componentInstance","_isDestroyed","activeInstance","$mount","keepAlive","mountedNode","prepatch","oldVnode","_updateFromParent","_isMounted","callHook","_inactive","destroy$1","$destroy","requested","cbs","pendingCallbacks","sync","resolve","reject","reason","then","attrs","domProps","checkProp","hash","preserve","hook","hooksToMerge","fromParent","ours","hooks","mergeHook$1","mergeVNodeHook","hookKey","injectedHash","__injected","oldHook","createEventHandle","invoker","arguments$1","updateListeners","oldOn","remove$$1","cur","old","normalizeEvent","once","simpleNormalizeChildren","normalizeChildren","normalizeArrayChildren","nestedIndex","last","getFirstComponentChild","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","isOnce","markStaticNode","$nextTick","nextTick","_render","ref","_renderProxy","errorHandler","_s","_v","_n","_e","_q","_i","_m","isInFor","_o","_f","_l","fallback","bindObject","scopedSlotFn","slotNodes","_b","asProp","mustUseProp","eventKeyCode","builtInAlias","keyCodes","defaultSlot","isComment","initEvents","_events","_hasHookEvent","updateComponentListeners","$once","$on","remove$2","$off","oldListeners","eventsMixin","hookRE","$emit","initLifecycle","$parent","$children","$root","$refs","_watcher","_isBeingDestroyed","lifecycleMixin","_mount","el","$el","Watcher","_update","prevEl","prevVnode","prevActiveInstance","__patch__","__vue__","renderChildren","hasChildren","propKeys","_propKeys","teardown","_watchers","handlers","resetSchedulerState","has$1","waiting","flushing","flushSchedulerQueue","watcher","run","devtools","queueWatcher","traverse","seenObjects","_traverse","seen","isA","depId","initState","opts","initProps","initMethods","initData","initComputed","watch","initWatch","isRoot","loop","proxy","userDef","computedSharedDefinition","makeComputedGetter","owner","lazy","dirty","evaluate","handler","createWatcher","$watch","stateMixin","dataDef","$set","$delete","expOrFn","immediate","initMixin","_init","_uid","initInternalComponent","_self","super","superOptions","cachedSuperOptions","extendOptions","components","initUse","use","plugin","installed","install","initMixin$1","initExtend","Super","SuperId","cachedCtors","_Ctor","Sub","_assetTypes","initAssetRegisters","getComponentName","pattern","pruneCache","cachedNode","pruneCacheEntry","initGlobalAPI","configDef","util","delete","builtInComponents","genClassForVnode","childNode","mergeClassData","genClassFromData","staticClass","class","dynamicClass","stringifyClass","stringified","isSVG","isUnknownElement","inBrowser","unknownElementCache","HTMLUnknownElement","HTMLElement","query","createElement$1","tagName","namespaceMap","createTextNode","createComment","newNode","referenceNode","setTextContent","registerRef","isRemoval","refs","refInFor","isUndef","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","activate","emptyNode","i$1","addVnodes","startIdx","invokeDestroyHook","destroy","removeVnodes","ch","removeAndInvokeRemoveHook","rm","updateChildren","oldCh","newCh","removeOnly","oldKeyToIdx","idxInOld","elmToMove","oldStartIdx","newStartIdx","oldEndIdx","oldStartVnode","oldEndVnode","newEndIdx","newStartVnode","newEndVnode","canMove","patchVnode","hasData","postpatch","invokeInsertHook","initial","hydrate","hasChildNodes","childrenMatch","isRenderedModule","hooks$1","isInitialPatch","isRealElement","nodeType","hasAttribute","oldElm","parentElm$1","_leaveCb","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","xlinkNS","getXlinkProp","isEnumeratedAttr","isBooleanAttr","isFalsyAttrValue","updateClass","oldData","cls","transitionClass","_transitionClasses","_prevClass","add$2","oldHandler","target$1","ev","remove$3","updateDOMListeners","updateDOMProps","oldProps","strCur","shouldUpdateValue","checkVal","composing","isDirty","isInputChanged","activeElement","_vModifiers","normalizeStyleData","normalizeStyleBinding","staticStyle","bindingStyle","parseStyleText","getStyle","checkChild","styleData","updateStyle","oldStaticStyle","oldStyleBinding","oldStyle","newStyle","setProp","addClass","removeClass","tar","nextFrame","raf","addTransitionClass","removeTransitionClass","whenTransitionEnds","expectedType","getTransitionInfo","propCount","TRANSITION","transitionEndEvent","animationEndEvent","onEnd","styles","transitioneDelays","transitionProp","transitionDurations","transitionTimeout","getTimeout","animationDelays","animationProp","animationDurations","animationTimeout","ANIMATION","hasTransform","transformRE","delays","durations","toMs","Number","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","setSelected","binding","isMultiple","multiple","selected","option","getValue","selectedIndex","hasNoMatchingOption","onCompositionStart","onCompositionEnd","trigger","locateNode","getRealChild","compOptions","extractTransitionData","comp","key$1","placeholder","rawChild","hasParentTransition","isSameChild","oldChild","callPendingCbs","_moveCb","recordPosition","newPos","applyTranslation","oldPos","pos","WebkitTransform","transitionDuration","shouldDecode","content","encoded","div","decode","decoder","decodeAttr","shouldDecodeNewlines","nlRE","ltRE","gtRE","ampRE","quoteRE","parseHTML","advance","parseStartTag","startTagOpen","startTagClose","attribute","unarySlash","handleStartTag","expectHTML","lastTag","isNonPhrasingTag","parseEndTag","canBeLeftOpenTag","unary","isUnaryTag$$1","IS_REGEX_CAPTURING_BROKEN","lowerCasedTag","lowerCasedTagName","isUnaryTag","no","isScriptOrStyle","stackedTag","reStackedTag","reCache","endTagLength","rest","all","endTag","chars","textEnd","comment","commentEnd","conditionalComment","conditionalEnd","doctypeMatch","doctype","endTagMatch","curIndex","startTagMatch","rest$1","parseFilters","pushFilter","filters","lastFilterIndex","prev","expression","inSingle","inDouble","inTemplateString","inRegex","curly","paren","wrapFilter","parseText","delimiters","tagRE","buildRegex","defaultTagRE","tokens","baseWarn","msg","console","pluckModuleFunction","addProp","addAttr","addDirective","arg","addHandler","important","events","native","nativeEvents","newHandler","getBindingAttr","getStatic","dynamicValue","getAndRemoveAttr","staticValue","attrsMap","attrsList","parseModel","expressionPos","expressionEndPos","lastIndexOf","idx","eof","chr","isStringStart","parseString","parseBracket","inBracket","stringQuote","template","warn$1","warn","platformGetTagNamespace","platformMustUseProp","platformIsPreTag","isPreTag","preTransforms","transforms","postTransforms","currentParent","preserveWhitespace","inVPre","inPre","checkRootConstraints","isIE","guardIESVGBug","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","genHandlers","genHandler","modifierCode","genKeyFilter","handlerCode","simplePathRE","fnExpRE","genFilterCode","keyVal","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","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","cloneNode","_isServer","_Set","camelizeRE","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","formatComponentName","uid$1","subs","addSub","sub","removeSub","addDep","arrayProto","arrayMethods","original","observeArray","arrayKeys","getOwnPropertyNames","isSettingProps","augment","walk","items","instanceData","defaultData","freeze","defineReactive","raw","prototypeAccessors","defineProperties","uid$2","deep","deps","newDeps","depIds","newDepIds","cleanupDeps","this$1","tmp","patternTypes","KeepAlive","include","exclude","created","destroyed","testEl","acceptValue","math","isHTMLTag","baseModules","klass","cssText","listDelimiter","propertyDelimiter","cssVarRE","importantRE","normalize","upper","prefixed","hasTransition","ontransitionend","onwebkittransitionend","onanimationend","onwebkitanimationend","platformModules","patch$1","vmodel","model","needReset","originalDisplay","__vOriginalDisplay","display","unbind","platformDirectives","transitionProps","_leaving","oldRawChild","delayedLeave","moveClass","TransitionGroup","prevChildren","rawChildren","transitionData","kept","removed","c$1","beforeUpdate","updated","hasMove","body","offsetHeight","propertyName","_hasMove","info","platformComponents","singleAttrIdentifier","singleAttrAssign","singleAttrValues","ncname","qnameCapture","regexEscapeRE","close","esc","tab","up","down","prevent","ctrl","alt","meta","cloak","klass$1","style$1","modules$1","directives$1","idToTemplate","mount","compile","aFunction","is","hide","PROTOTYPE","$export","own","IS_FORCED","F","IS_GLOBAL","G","IS_STATIC","IS_PROTO","IS_BIND","IS_WRAP","expProto","virtual","TAG","stat","SHARED","IObject","toInteger","__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.68e97f3128ceb6fa491d.js","sourcesContent":["webpackJsonp([0,2],[\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar store = __webpack_require__(25)('wks')\n , uid = __webpack_require__(29)\n , Symbol = __webpack_require__(2).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\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/* 2 */\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/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar isObject = __webpack_require__(12);\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__(23)(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__(14);\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__(48)\n , toPrimitive = __webpack_require__(64)\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/***/ (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/* 9 */,\n/* 10 */\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/* 11 */\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/* 12 */\n/***/ (function(module, exports) {\n\nmodule.exports = function(it){\n return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports) {\n\nmodule.exports = {};\n\n/***/ }),\n/* 14 */\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/* 15 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar shared = __webpack_require__(25)('keys')\n , uid = __webpack_require__(29);\nmodule.exports = function(key){\n return shared[key] || (shared[key] = uid(key));\n};\n\n/***/ }),\n/* 16 */\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/* 17 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/*!\n * Vue.js v2.1.10\n * (c) 2014-2017 Evan You\n * Released under the MIT License.\n */\n\n\n/* */\n\n/**\n * Convert a value to a string that is actually rendered.\n */\nfunction _toString (val) {\n return val == null\n ? ''\n : typeof val === 'object'\n ? JSON.stringify(val, null, 2)\n : String(val)\n}\n\n/**\n * Convert a input value to a number for persistence.\n * If the conversion fails, return original string.\n */\nfunction toNumber (val) {\n var n = parseFloat(val);\n return isNaN(n) ? val : n\n}\n\n/**\n * Make a map and return a function for checking if a key\n * is in that map.\n */\nfunction makeMap (\n str,\n expectsLowerCase\n) {\n var map = Object.create(null);\n var list = str.split(',');\n for (var i = 0; i < list.length; i++) {\n map[list[i]] = true;\n }\n return expectsLowerCase\n ? function (val) { return map[val.toLowerCase()]; }\n : function (val) { return map[val]; }\n}\n\n/**\n * Check if a tag is a built-in tag.\n */\nvar isBuiltInTag = makeMap('slot,component', true);\n\n/**\n * Remove an item from an array\n */\nfunction remove$1 (arr, item) {\n if (arr.length) {\n var index = arr.indexOf(item);\n if (index > -1) {\n return arr.splice(index, 1)\n }\n }\n}\n\n/**\n * Check whether the object has the property.\n */\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction hasOwn (obj, key) {\n return hasOwnProperty.call(obj, key)\n}\n\n/**\n * Check if value is primitive\n */\nfunction isPrimitive (value) {\n return typeof value === 'string' || typeof value === 'number'\n}\n\n/**\n * Create a cached version of a pure function.\n */\nfunction cached (fn) {\n var cache = Object.create(null);\n return (function cachedFn (str) {\n var hit = cache[str];\n return hit || (cache[str] = fn(str))\n })\n}\n\n/**\n * Camelize a hyphen-delimited string.\n */\nvar camelizeRE = /-(\\w)/g;\nvar camelize = cached(function (str) {\n return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })\n});\n\n/**\n * Capitalize a string.\n */\nvar capitalize = cached(function (str) {\n return str.charAt(0).toUpperCase() + str.slice(1)\n});\n\n/**\n * Hyphenate a camelCase string.\n */\nvar hyphenateRE = /([^-])([A-Z])/g;\nvar hyphenate = cached(function (str) {\n return str\n .replace(hyphenateRE, '$1-$2')\n .replace(hyphenateRE, '$1-$2')\n .toLowerCase()\n});\n\n/**\n * Simple bind, faster than native\n */\nfunction bind$1 (fn, ctx) {\n function boundFn (a) {\n var l = arguments.length;\n return l\n ? l > 1\n ? fn.apply(ctx, arguments)\n : fn.call(ctx, a)\n : fn.call(ctx)\n }\n // record original fn length\n boundFn._length = fn.length;\n return boundFn\n}\n\n/**\n * Convert an Array-like object to a real Array.\n */\nfunction toArray (list, start) {\n start = start || 0;\n var i = list.length - start;\n var ret = new Array(i);\n while (i--) {\n ret[i] = list[i + start];\n }\n return ret\n}\n\n/**\n * Mix properties into target object.\n */\nfunction extend (to, _from) {\n for (var key in _from) {\n to[key] = _from[key];\n }\n return to\n}\n\n/**\n * Quick object check - this is primarily used to tell\n * Objects from primitive values when we know the value\n * is a JSON-compliant type.\n */\nfunction isObject (obj) {\n return obj !== null && typeof obj === 'object'\n}\n\n/**\n * Strict object type check. Only returns true\n * for plain JavaScript objects.\n */\nvar toString = Object.prototype.toString;\nvar OBJECT_STRING = '[object Object]';\nfunction isPlainObject (obj) {\n return toString.call(obj) === OBJECT_STRING\n}\n\n/**\n * Merge an Array of Objects into a single Object.\n */\nfunction toObject (arr) {\n var res = {};\n for (var i = 0; i < arr.length; i++) {\n if (arr[i]) {\n extend(res, arr[i]);\n }\n }\n return res\n}\n\n/**\n * Perform no operation.\n */\nfunction noop () {}\n\n/**\n * Always return false.\n */\nvar no = function () { return false; };\n\n/**\n * Return same value\n */\nvar identity = function (_) { return _; };\n\n/**\n * Generate a static keys string from compiler modules.\n */\nfunction genStaticKeys (modules) {\n return modules.reduce(function (keys, m) {\n return keys.concat(m.staticKeys || [])\n }, []).join(',')\n}\n\n/**\n * Check if two values are loosely equal - that is,\n * if they are plain objects, do they have the same shape?\n */\nfunction looseEqual (a, b) {\n var isObjectA = isObject(a);\n var isObjectB = isObject(b);\n if (isObjectA && isObjectB) {\n return JSON.stringify(a) === JSON.stringify(b)\n } else if (!isObjectA && !isObjectB) {\n return String(a) === String(b)\n } else {\n return false\n }\n}\n\nfunction looseIndexOf (arr, val) {\n for (var i = 0; i < arr.length; i++) {\n if (looseEqual(arr[i], val)) { return i }\n }\n return -1\n}\n\n/* */\n\nvar config = {\n /**\n * Option merge strategies (used in core/util/options)\n */\n optionMergeStrategies: Object.create(null),\n\n /**\n * Whether to suppress warnings.\n */\n silent: false,\n\n /**\n * Whether to enable devtools\n */\n devtools: \"production\" !== 'production',\n\n /**\n * Error handler for watcher errors\n */\n errorHandler: null,\n\n /**\n * Ignore certain custom elements\n */\n ignoredElements: [],\n\n /**\n * Custom user key aliases for v-on\n */\n keyCodes: Object.create(null),\n\n /**\n * Check if a tag is reserved so that it cannot be registered as a\n * component. This is platform-dependent and may be overwritten.\n */\n isReservedTag: no,\n\n /**\n * Check if a tag is an unknown element.\n * Platform-dependent.\n */\n isUnknownElement: no,\n\n /**\n * Get the namespace of an element\n */\n getTagNamespace: noop,\n\n /**\n * Parse the real tag name for the specific platform.\n */\n parsePlatformTagName: identity,\n\n /**\n * Check if an attribute must be bound using property, e.g. value\n * Platform-dependent.\n */\n mustUseProp: no,\n\n /**\n * List of asset types that a component can own.\n */\n _assetTypes: [\n 'component',\n 'directive',\n 'filter'\n ],\n\n /**\n * List of lifecycle hooks.\n */\n _lifecycleHooks: [\n 'beforeCreate',\n 'created',\n 'beforeMount',\n 'mounted',\n 'beforeUpdate',\n 'updated',\n 'beforeDestroy',\n 'destroyed',\n 'activated',\n 'deactivated'\n ],\n\n /**\n * Max circular updates allowed in a scheduler flush cycle.\n */\n _maxUpdateCount: 100\n};\n\n/* */\n\n/**\n * Check if a string starts with $ or _\n */\nfunction isReserved (str) {\n var c = (str + '').charCodeAt(0);\n return c === 0x24 || c === 0x5F\n}\n\n/**\n * Define a property.\n */\nfunction def (obj, key, val, enumerable) {\n Object.defineProperty(obj, key, {\n value: val,\n enumerable: !!enumerable,\n writable: true,\n configurable: true\n });\n}\n\n/**\n * Parse simple path.\n */\nvar bailRE = /[^\\w.$]/;\nfunction parsePath (path) {\n if (bailRE.test(path)) {\n return\n } else {\n var segments = path.split('.');\n return function (obj) {\n for (var i = 0; i < segments.length; i++) {\n if (!obj) { return }\n obj = obj[segments[i]];\n }\n return obj\n }\n }\n}\n\n/* */\n/* globals MutationObserver */\n\n// can we use __proto__?\nvar hasProto = '__proto__' in {};\n\n// Browser environment sniffing\nvar inBrowser = typeof window !== 'undefined';\nvar UA = inBrowser && window.navigator.userAgent.toLowerCase();\nvar isIE = UA && /msie|trident/.test(UA);\nvar isIE9 = UA && UA.indexOf('msie 9.0') > 0;\nvar isEdge = UA && UA.indexOf('edge/') > 0;\nvar isAndroid = UA && UA.indexOf('android') > 0;\nvar isIOS = UA && /iphone|ipad|ipod|ios/.test(UA);\n\n// this needs to be lazy-evaled because vue may be required before\n// vue-server-renderer can set VUE_ENV\nvar _isServer;\nvar isServerRendering = function () {\n if (_isServer === undefined) {\n /* istanbul ignore if */\n if (!inBrowser && typeof global !== 'undefined') {\n // detect presence of vue-server-renderer and avoid\n // Webpack shimming the process\n _isServer = global['process'].env.VUE_ENV === 'server';\n } else {\n _isServer = false;\n }\n }\n return _isServer\n};\n\n// detect devtools\nvar devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;\n\n/* istanbul ignore next */\nfunction isNative (Ctor) {\n return /native code/.test(Ctor.toString())\n}\n\n/**\n * Defer a task to execute it asynchronously.\n */\nvar nextTick = (function () {\n var callbacks = [];\n var pending = false;\n var timerFunc;\n\n function nextTickHandler () {\n pending = false;\n var copies = callbacks.slice(0);\n callbacks.length = 0;\n for (var i = 0; i < copies.length; i++) {\n copies[i]();\n }\n }\n\n // the nextTick behavior leverages the microtask queue, which can be accessed\n // via either native Promise.then or MutationObserver.\n // MutationObserver has wider support, however it is seriously bugged in\n // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It\n // completely stops working after triggering a few times... so, if native\n // Promise is available, we will use it:\n /* istanbul ignore if */\n if (typeof Promise !== 'undefined' && isNative(Promise)) {\n var p = Promise.resolve();\n var logError = function (err) { console.error(err); };\n timerFunc = function () {\n p.then(nextTickHandler).catch(logError);\n // in problematic UIWebViews, Promise.then doesn't completely break, but\n // it can get stuck in a weird state where callbacks are pushed into the\n // microtask queue but the queue isn't being flushed, until the browser\n // needs to do some other work, e.g. handle a timer. Therefore we can\n // \"force\" the microtask queue to be flushed by adding an empty timer.\n if (isIOS) { setTimeout(noop); }\n };\n } else if (typeof MutationObserver !== 'undefined' && (\n isNative(MutationObserver) ||\n // PhantomJS and iOS 7.x\n MutationObserver.toString() === '[object MutationObserverConstructor]'\n )) {\n // use MutationObserver where native Promise is not available,\n // e.g. PhantomJS IE11, iOS7, Android 4.4\n var counter = 1;\n var observer = new MutationObserver(nextTickHandler);\n var textNode = document.createTextNode(String(counter));\n observer.observe(textNode, {\n characterData: true\n });\n timerFunc = function () {\n counter = (counter + 1) % 2;\n textNode.data = String(counter);\n };\n } else {\n // fallback to setTimeout\n /* istanbul ignore next */\n timerFunc = function () {\n setTimeout(nextTickHandler, 0);\n };\n }\n\n return function queueNextTick (cb, ctx) {\n var _resolve;\n callbacks.push(function () {\n if (cb) { cb.call(ctx); }\n if (_resolve) { _resolve(ctx); }\n });\n if (!pending) {\n pending = true;\n timerFunc();\n }\n if (!cb && typeof Promise !== 'undefined') {\n return new Promise(function (resolve) {\n _resolve = resolve;\n })\n }\n }\n})();\n\nvar _Set;\n/* istanbul ignore if */\nif (typeof Set !== 'undefined' && isNative(Set)) {\n // use native Set when available.\n _Set = Set;\n} else {\n // a non-standard Set polyfill that only works with primitive keys.\n _Set = (function () {\n function Set () {\n this.set = Object.create(null);\n }\n Set.prototype.has = function has (key) {\n return this.set[key] === true\n };\n Set.prototype.add = function add (key) {\n this.set[key] = true;\n };\n Set.prototype.clear = function clear () {\n this.set = Object.create(null);\n };\n\n return Set;\n }());\n}\n\nvar warn = noop;\nvar formatComponentName;\n\nif (false) {\n var hasConsole = typeof console !== 'undefined';\n\n warn = function (msg, vm) {\n if (hasConsole && (!config.silent)) {\n console.error(\"[Vue warn]: \" + msg + \" \" + (\n vm ? formatLocation(formatComponentName(vm)) : ''\n ));\n }\n };\n\n formatComponentName = function (vm) {\n if (vm.$root === vm) {\n return 'root instance'\n }\n var name = vm._isVue\n ? vm.$options.name || vm.$options._componentTag\n : vm.name;\n return (\n (name ? (\"component <\" + name + \">\") : \"anonymous component\") +\n (vm._isVue && vm.$options.__file ? (\" at \" + (vm.$options.__file)) : '')\n )\n };\n\n var formatLocation = function (str) {\n if (str === 'anonymous component') {\n str += \" - use the \\\"name\\\" option for better debugging messages.\";\n }\n return (\"\\n(found in \" + str + \")\")\n };\n}\n\n/* */\n\n\nvar uid$1 = 0;\n\n/**\n * A dep is an observable that can have multiple\n * directives subscribing to it.\n */\nvar Dep = function Dep () {\n this.id = uid$1++;\n this.subs = [];\n};\n\nDep.prototype.addSub = function addSub (sub) {\n this.subs.push(sub);\n};\n\nDep.prototype.removeSub = function removeSub (sub) {\n remove$1(this.subs, sub);\n};\n\nDep.prototype.depend = function depend () {\n if (Dep.target) {\n Dep.target.addDep(this);\n }\n};\n\nDep.prototype.notify = function notify () {\n // stablize the subscriber list first\n var subs = this.subs.slice();\n for (var i = 0, l = subs.length; i < l; i++) {\n subs[i].update();\n }\n};\n\n// the current target watcher being evaluated.\n// this is globally unique because there could be only one\n// watcher being evaluated at any time.\nDep.target = null;\nvar targetStack = [];\n\nfunction pushTarget (_target) {\n if (Dep.target) { targetStack.push(Dep.target); }\n Dep.target = _target;\n}\n\nfunction popTarget () {\n Dep.target = targetStack.pop();\n}\n\n/*\n * not type checking this file because flow doesn't play well with\n * dynamically accessing methods on Array prototype\n */\n\nvar arrayProto = Array.prototype;\nvar arrayMethods = Object.create(arrayProto);[\n 'push',\n 'pop',\n 'shift',\n 'unshift',\n 'splice',\n 'sort',\n 'reverse'\n]\n.forEach(function (method) {\n // cache original method\n var original = arrayProto[method];\n def(arrayMethods, method, function mutator () {\n var arguments$1 = arguments;\n\n // avoid leaking arguments:\n // http://jsperf.com/closure-with-arguments\n var i = arguments.length;\n var args = new Array(i);\n while (i--) {\n args[i] = arguments$1[i];\n }\n var result = original.apply(this, args);\n var ob = this.__ob__;\n var inserted;\n switch (method) {\n case 'push':\n inserted = args;\n break\n case 'unshift':\n inserted = args;\n break\n case 'splice':\n inserted = args.slice(2);\n break\n }\n if (inserted) { ob.observeArray(inserted); }\n // notify change\n ob.dep.notify();\n return result\n });\n});\n\n/* */\n\nvar arrayKeys = Object.getOwnPropertyNames(arrayMethods);\n\n/**\n * By default, when a reactive property is set, the new value is\n * also converted to become reactive. However when passing down props,\n * we don't want to force conversion because the value may be a nested value\n * under a frozen data structure. Converting it would defeat the optimization.\n */\nvar observerState = {\n shouldConvert: true,\n isSettingProps: false\n};\n\n/**\n * Observer class that are attached to each observed\n * object. Once attached, the observer converts target\n * object's property keys into getter/setters that\n * collect dependencies and dispatches updates.\n */\nvar Observer = function Observer (value) {\n this.value = value;\n this.dep = new Dep();\n this.vmCount = 0;\n def(value, '__ob__', this);\n if (Array.isArray(value)) {\n var augment = hasProto\n ? protoAugment\n : copyAugment;\n augment(value, arrayMethods, arrayKeys);\n this.observeArray(value);\n } else {\n this.walk(value);\n }\n};\n\n/**\n * Walk through each property and convert them into\n * getter/setters. This method should only be called when\n * value type is Object.\n */\nObserver.prototype.walk = function walk (obj) {\n var keys = Object.keys(obj);\n for (var i = 0; i < keys.length; i++) {\n defineReactive$$1(obj, keys[i], obj[keys[i]]);\n }\n};\n\n/**\n * Observe a list of Array items.\n */\nObserver.prototype.observeArray = function observeArray (items) {\n for (var i = 0, l = items.length; i < l; i++) {\n observe(items[i]);\n }\n};\n\n// helpers\n\n/**\n * Augment an target Object or Array by intercepting\n * the prototype chain using __proto__\n */\nfunction protoAugment (target, src) {\n /* eslint-disable no-proto */\n target.__proto__ = src;\n /* eslint-enable no-proto */\n}\n\n/**\n * Augment an target Object or Array by defining\n * hidden properties.\n */\n/* istanbul ignore next */\nfunction copyAugment (target, src, keys) {\n for (var i = 0, l = keys.length; i < l; i++) {\n var key = keys[i];\n def(target, key, src[key]);\n }\n}\n\n/**\n * Attempt to create an observer instance for a value,\n * returns the new observer if successfully observed,\n * or the existing observer if the value already has one.\n */\nfunction observe (value, asRootData) {\n if (!isObject(value)) {\n return\n }\n var ob;\n if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {\n ob = value.__ob__;\n } else if (\n observerState.shouldConvert &&\n !isServerRendering() &&\n (Array.isArray(value) || isPlainObject(value)) &&\n Object.isExtensible(value) &&\n !value._isVue\n ) {\n ob = new Observer(value);\n }\n if (asRootData && ob) {\n ob.vmCount++;\n }\n return ob\n}\n\n/**\n * Define a reactive property on an Object.\n */\nfunction defineReactive$$1 (\n obj,\n key,\n val,\n customSetter\n) {\n var dep = new Dep();\n\n var property = Object.getOwnPropertyDescriptor(obj, key);\n if (property && property.configurable === false) {\n return\n }\n\n // cater for pre-defined getter/setters\n var getter = property && property.get;\n var setter = property && property.set;\n\n var childOb = observe(val);\n Object.defineProperty(obj, key, {\n enumerable: true,\n configurable: true,\n get: function reactiveGetter () {\n var value = getter ? getter.call(obj) : val;\n if (Dep.target) {\n dep.depend();\n if (childOb) {\n childOb.dep.depend();\n }\n if (Array.isArray(value)) {\n dependArray(value);\n }\n }\n return value\n },\n set: function reactiveSetter (newVal) {\n var value = getter ? getter.call(obj) : val;\n /* eslint-disable no-self-compare */\n if (newVal === value || (newVal !== newVal && value !== value)) {\n return\n }\n /* eslint-enable no-self-compare */\n if (false) {\n customSetter();\n }\n if (setter) {\n setter.call(obj, newVal);\n } else {\n val = newVal;\n }\n childOb = observe(newVal);\n dep.notify();\n }\n });\n}\n\n/**\n * Set a property on an object. Adds the new property and\n * triggers change notification if the property doesn't\n * already exist.\n */\nfunction set$1 (obj, key, val) {\n if (Array.isArray(obj)) {\n obj.length = Math.max(obj.length, key);\n obj.splice(key, 1, val);\n return val\n }\n if (hasOwn(obj, key)) {\n obj[key] = val;\n return\n }\n var ob = obj.__ob__;\n if (obj._isVue || (ob && ob.vmCount)) {\n \"production\" !== 'production' && warn(\n 'Avoid adding reactive properties to a Vue instance or its root $data ' +\n 'at runtime - declare it upfront in the data option.'\n );\n return\n }\n if (!ob) {\n obj[key] = val;\n return\n }\n defineReactive$$1(ob.value, key, val);\n ob.dep.notify();\n return val\n}\n\n/**\n * Delete a property and trigger change if necessary.\n */\nfunction del (obj, key) {\n var ob = obj.__ob__;\n if (obj._isVue || (ob && ob.vmCount)) {\n \"production\" !== 'production' && warn(\n 'Avoid deleting properties on a Vue instance or its root $data ' +\n '- just set it to null.'\n );\n return\n }\n if (!hasOwn(obj, key)) {\n return\n }\n delete obj[key];\n if (!ob) {\n return\n }\n ob.dep.notify();\n}\n\n/**\n * Collect dependencies on array elements when the array is touched, since\n * we cannot intercept array element access like property getters.\n */\nfunction dependArray (value) {\n for (var e = (void 0), i = 0, l = value.length; i < l; i++) {\n e = value[i];\n e && e.__ob__ && e.__ob__.dep.depend();\n if (Array.isArray(e)) {\n dependArray(e);\n }\n }\n}\n\n/* */\n\n/**\n * Option overwriting strategies are functions that handle\n * how to merge a parent option value and a child option\n * value into the final value.\n */\nvar strats = config.optionMergeStrategies;\n\n/**\n * Options with restrictions\n */\nif (false) {\n strats.el = strats.propsData = function (parent, child, vm, key) {\n if (!vm) {\n warn(\n \"option \\\"\" + key + \"\\\" can only be used during instance \" +\n 'creation with the `new` keyword.'\n );\n }\n return defaultStrat(parent, child)\n };\n}\n\n/**\n * Helper that recursively merges two data objects together.\n */\nfunction mergeData (to, from) {\n if (!from) { return to }\n var key, toVal, fromVal;\n var keys = Object.keys(from);\n for (var i = 0; i < keys.length; i++) {\n key = keys[i];\n toVal = to[key];\n fromVal = from[key];\n if (!hasOwn(to, key)) {\n set$1(to, key, fromVal);\n } else if (isPlainObject(toVal) && isPlainObject(fromVal)) {\n mergeData(toVal, fromVal);\n }\n }\n return to\n}\n\n/**\n * Data\n */\nstrats.data = function (\n parentVal,\n childVal,\n vm\n) {\n if (!vm) {\n // in a Vue.extend merge, both should be functions\n if (!childVal) {\n return parentVal\n }\n if (typeof childVal !== 'function') {\n \"production\" !== 'production' && warn(\n 'The \"data\" option should be a function ' +\n 'that returns a per-instance value in component ' +\n 'definitions.',\n vm\n );\n return parentVal\n }\n if (!parentVal) {\n return childVal\n }\n // when parentVal & childVal are both present,\n // we need to return a function that returns the\n // merged result of both functions... no need to\n // check if parentVal is a function here because\n // it has to be a function to pass previous merges.\n return function mergedDataFn () {\n return mergeData(\n childVal.call(this),\n parentVal.call(this)\n )\n }\n } else if (parentVal || childVal) {\n return function mergedInstanceDataFn () {\n // instance merge\n var instanceData = typeof childVal === 'function'\n ? childVal.call(vm)\n : childVal;\n var defaultData = typeof parentVal === 'function'\n ? parentVal.call(vm)\n : undefined;\n if (instanceData) {\n return mergeData(instanceData, defaultData)\n } else {\n return defaultData\n }\n }\n }\n};\n\n/**\n * Hooks and param attributes are merged as arrays.\n */\nfunction mergeHook (\n parentVal,\n childVal\n) {\n return childVal\n ? parentVal\n ? parentVal.concat(childVal)\n : Array.isArray(childVal)\n ? childVal\n : [childVal]\n : parentVal\n}\n\nconfig._lifecycleHooks.forEach(function (hook) {\n strats[hook] = mergeHook;\n});\n\n/**\n * Assets\n *\n * When a vm is present (instance creation), we need to do\n * a three-way merge between constructor options, instance\n * options and parent options.\n */\nfunction mergeAssets (parentVal, childVal) {\n var res = Object.create(parentVal || null);\n return childVal\n ? extend(res, childVal)\n : res\n}\n\nconfig._assetTypes.forEach(function (type) {\n strats[type + 's'] = mergeAssets;\n});\n\n/**\n * Watchers.\n *\n * Watchers hashes should not overwrite one\n * another, so we merge them as arrays.\n */\nstrats.watch = function (parentVal, childVal) {\n /* istanbul ignore if */\n if (!childVal) { return parentVal }\n if (!parentVal) { return childVal }\n var ret = {};\n extend(ret, parentVal);\n for (var key in childVal) {\n var parent = ret[key];\n var child = childVal[key];\n if (parent && !Array.isArray(parent)) {\n parent = [parent];\n }\n ret[key] = parent\n ? parent.concat(child)\n : [child];\n }\n return ret\n};\n\n/**\n * Other object hashes.\n */\nstrats.props =\nstrats.methods =\nstrats.computed = function (parentVal, childVal) {\n if (!childVal) { return parentVal }\n if (!parentVal) { return childVal }\n var ret = Object.create(null);\n extend(ret, parentVal);\n extend(ret, childVal);\n return ret\n};\n\n/**\n * Default strategy.\n */\nvar defaultStrat = function (parentVal, childVal) {\n return childVal === undefined\n ? parentVal\n : childVal\n};\n\n/**\n * Validate component names\n */\nfunction checkComponents (options) {\n for (var key in options.components) {\n var lower = key.toLowerCase();\n if (isBuiltInTag(lower) || config.isReservedTag(lower)) {\n warn(\n 'Do not use built-in or reserved HTML elements as component ' +\n 'id: ' + key\n );\n }\n }\n}\n\n/**\n * Ensure all props option syntax are normalized into the\n * Object-based format.\n */\nfunction normalizeProps (options) {\n var props = options.props;\n if (!props) { return }\n var res = {};\n var i, val, name;\n if (Array.isArray(props)) {\n i = props.length;\n while (i--) {\n val = props[i];\n if (typeof val === 'string') {\n name = camelize(val);\n res[name] = { type: null };\n } else if (false) {\n warn('props must be strings when using array syntax.');\n }\n }\n } else if (isPlainObject(props)) {\n for (var key in props) {\n val = props[key];\n name = camelize(key);\n res[name] = isPlainObject(val)\n ? val\n : { type: val };\n }\n }\n options.props = res;\n}\n\n/**\n * Normalize raw function directives into object format.\n */\nfunction normalizeDirectives (options) {\n var dirs = options.directives;\n if (dirs) {\n for (var key in dirs) {\n var def = dirs[key];\n if (typeof def === 'function') {\n dirs[key] = { bind: def, update: def };\n }\n }\n }\n}\n\n/**\n * Merge two option objects into a new one.\n * Core utility used in both instantiation and inheritance.\n */\nfunction mergeOptions (\n parent,\n child,\n vm\n) {\n if (false) {\n checkComponents(child);\n }\n normalizeProps(child);\n normalizeDirectives(child);\n var extendsFrom = child.extends;\n if (extendsFrom) {\n parent = typeof extendsFrom === 'function'\n ? mergeOptions(parent, extendsFrom.options, vm)\n : mergeOptions(parent, extendsFrom, vm);\n }\n if (child.mixins) {\n for (var i = 0, l = child.mixins.length; i < l; i++) {\n var mixin = child.mixins[i];\n if (mixin.prototype instanceof Vue$3) {\n mixin = mixin.options;\n }\n parent = mergeOptions(parent, mixin, vm);\n }\n }\n var options = {};\n var key;\n for (key in parent) {\n mergeField(key);\n }\n for (key in child) {\n if (!hasOwn(parent, key)) {\n mergeField(key);\n }\n }\n function mergeField (key) {\n var strat = strats[key] || defaultStrat;\n options[key] = strat(parent[key], child[key], vm, key);\n }\n return options\n}\n\n/**\n * Resolve an asset.\n * This function is used because child instances need access\n * to assets defined in its ancestor chain.\n */\nfunction resolveAsset (\n options,\n type,\n id,\n warnMissing\n) {\n /* istanbul ignore if */\n if (typeof id !== 'string') {\n return\n }\n var assets = options[type];\n // check local registration variations first\n if (hasOwn(assets, id)) { return assets[id] }\n var camelizedId = camelize(id);\n if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }\n var PascalCaseId = capitalize(camelizedId);\n if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }\n // fallback to prototype chain\n var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];\n if (false) {\n warn(\n 'Failed to resolve ' + type.slice(0, -1) + ': ' + id,\n options\n );\n }\n return res\n}\n\n/* */\n\nfunction validateProp (\n key,\n propOptions,\n propsData,\n vm\n) {\n var prop = propOptions[key];\n var absent = !hasOwn(propsData, key);\n var value = propsData[key];\n // handle boolean props\n if (isType(Boolean, prop.type)) {\n if (absent && !hasOwn(prop, 'default')) {\n value = false;\n } else if (!isType(String, prop.type) && (value === '' || value === hyphenate(key))) {\n value = true;\n }\n }\n // check default value\n if (value === undefined) {\n value = getPropDefaultValue(vm, prop, key);\n // since the default value is a fresh copy,\n // make sure to observe it.\n var prevShouldConvert = observerState.shouldConvert;\n observerState.shouldConvert = true;\n observe(value);\n observerState.shouldConvert = prevShouldConvert;\n }\n if (false) {\n assertProp(prop, key, value, vm, absent);\n }\n return value\n}\n\n/**\n * Get the default value of a prop.\n */\nfunction getPropDefaultValue (vm, prop, key) {\n // no default, return undefined\n if (!hasOwn(prop, 'default')) {\n return undefined\n }\n var def = prop.default;\n // warn against non-factory defaults for Object & Array\n if (isObject(def)) {\n \"production\" !== 'production' && warn(\n 'Invalid default value for prop \"' + key + '\": ' +\n 'Props with type Object/Array must use a factory function ' +\n 'to return the default value.',\n vm\n );\n }\n // the raw prop value was also undefined from previous render,\n // return previous default value to avoid unnecessary watcher trigger\n if (vm && vm.$options.propsData &&\n vm.$options.propsData[key] === undefined &&\n vm[key] !== undefined) {\n return vm[key]\n }\n // call factory function for non-Function types\n return typeof def === 'function' && prop.type !== Function\n ? def.call(vm)\n : def\n}\n\n/**\n * Assert whether a prop is valid.\n */\nfunction assertProp (\n prop,\n name,\n value,\n vm,\n absent\n) {\n if (prop.required && absent) {\n warn(\n 'Missing required prop: \"' + name + '\"',\n vm\n );\n return\n }\n if (value == null && !prop.required) {\n return\n }\n var type = prop.type;\n var valid = !type || type === true;\n var expectedTypes = [];\n if (type) {\n if (!Array.isArray(type)) {\n type = [type];\n }\n for (var i = 0; i < type.length && !valid; i++) {\n var assertedType = assertType(value, type[i]);\n expectedTypes.push(assertedType.expectedType || '');\n valid = assertedType.valid;\n }\n }\n if (!valid) {\n warn(\n 'Invalid prop: type check failed for prop \"' + name + '\".' +\n ' Expected ' + expectedTypes.map(capitalize).join(', ') +\n ', got ' + Object.prototype.toString.call(value).slice(8, -1) + '.',\n vm\n );\n return\n }\n var validator = prop.validator;\n if (validator) {\n if (!validator(value)) {\n warn(\n 'Invalid prop: custom validator check failed for prop \"' + name + '\".',\n vm\n );\n }\n }\n}\n\n/**\n * Assert the type of a value\n */\nfunction assertType (value, type) {\n var valid;\n var expectedType = getType(type);\n if (expectedType === 'String') {\n valid = typeof value === (expectedType = 'string');\n } else if (expectedType === 'Number') {\n valid = typeof value === (expectedType = 'number');\n } else if (expectedType === 'Boolean') {\n valid = typeof value === (expectedType = 'boolean');\n } else if (expectedType === 'Function') {\n valid = typeof value === (expectedType = 'function');\n } else if (expectedType === 'Object') {\n valid = isPlainObject(value);\n } else if (expectedType === 'Array') {\n valid = Array.isArray(value);\n } else {\n valid = value instanceof type;\n }\n return {\n valid: valid,\n expectedType: expectedType\n }\n}\n\n/**\n * Use function string name to check built-in types,\n * because a simple equality check will fail when running\n * across different vms / iframes.\n */\nfunction getType (fn) {\n var match = fn && fn.toString().match(/^\\s*function (\\w+)/);\n return match && match[1]\n}\n\nfunction isType (type, fn) {\n if (!Array.isArray(fn)) {\n return getType(fn) === getType(type)\n }\n for (var i = 0, len = fn.length; i < len; i++) {\n if (getType(fn[i]) === getType(type)) {\n return true\n }\n }\n /* istanbul ignore next */\n return false\n}\n\n\n\nvar util = Object.freeze({\n\tdefineReactive: defineReactive$$1,\n\t_toString: _toString,\n\ttoNumber: toNumber,\n\tmakeMap: makeMap,\n\tisBuiltInTag: isBuiltInTag,\n\tremove: remove$1,\n\thasOwn: hasOwn,\n\tisPrimitive: isPrimitive,\n\tcached: cached,\n\tcamelize: camelize,\n\tcapitalize: capitalize,\n\thyphenate: hyphenate,\n\tbind: bind$1,\n\ttoArray: toArray,\n\textend: extend,\n\tisObject: isObject,\n\tisPlainObject: isPlainObject,\n\ttoObject: toObject,\n\tnoop: noop,\n\tno: no,\n\tidentity: identity,\n\tgenStaticKeys: genStaticKeys,\n\tlooseEqual: looseEqual,\n\tlooseIndexOf: looseIndexOf,\n\tisReserved: isReserved,\n\tdef: def,\n\tparsePath: parsePath,\n\thasProto: hasProto,\n\tinBrowser: inBrowser,\n\tUA: UA,\n\tisIE: isIE,\n\tisIE9: isIE9,\n\tisEdge: isEdge,\n\tisAndroid: isAndroid,\n\tisIOS: isIOS,\n\tisServerRendering: isServerRendering,\n\tdevtools: devtools,\n\tnextTick: nextTick,\n\tget _Set () { return _Set; },\n\tmergeOptions: mergeOptions,\n\tresolveAsset: resolveAsset,\n\tget warn () { return warn; },\n\tget formatComponentName () { return formatComponentName; },\n\tvalidateProp: validateProp\n});\n\n/* not type checking this file because flow doesn't play well with Proxy */\n\nvar initProxy;\n\nif (false) {\n var allowedGlobals = makeMap(\n 'Infinity,undefined,NaN,isFinite,isNaN,' +\n 'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +\n 'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +\n 'require' // for Webpack/Browserify\n );\n\n var warnNonPresent = function (target, key) {\n warn(\n \"Property or method \\\"\" + key + \"\\\" is not defined on the instance but \" +\n \"referenced during render. Make sure to declare reactive data \" +\n \"properties in the data option.\",\n target\n );\n };\n\n var hasProxy =\n typeof Proxy !== 'undefined' &&\n Proxy.toString().match(/native code/);\n\n if (hasProxy) {\n var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta');\n config.keyCodes = new Proxy(config.keyCodes, {\n set: function set (target, key, value) {\n if (isBuiltInModifier(key)) {\n warn((\"Avoid overwriting built-in modifier in config.keyCodes: .\" + key));\n return false\n } else {\n target[key] = value;\n return true\n }\n }\n });\n }\n\n var hasHandler = {\n has: function has (target, key) {\n var has = key in target;\n var isAllowed = allowedGlobals(key) || key.charAt(0) === '_';\n if (!has && !isAllowed) {\n warnNonPresent(target, key);\n }\n return has || !isAllowed\n }\n };\n\n var getHandler = {\n get: function get (target, key) {\n if (typeof key === 'string' && !(key in target)) {\n warnNonPresent(target, key);\n }\n return target[key]\n }\n };\n\n initProxy = function initProxy (vm) {\n if (hasProxy) {\n // determine which proxy handler to use\n var options = vm.$options;\n var handlers = options.render && options.render._withStripped\n ? getHandler\n : hasHandler;\n vm._renderProxy = new Proxy(vm, handlers);\n } else {\n vm._renderProxy = vm;\n }\n };\n}\n\n/* */\n\nvar VNode = function VNode (\n tag,\n data,\n children,\n text,\n elm,\n context,\n componentOptions\n) {\n this.tag = tag;\n this.data = data;\n this.children = children;\n this.text = text;\n this.elm = elm;\n this.ns = undefined;\n this.context = context;\n this.functionalContext = undefined;\n this.key = data && data.key;\n this.componentOptions = componentOptions;\n this.componentInstance = undefined;\n this.parent = undefined;\n this.raw = false;\n this.isStatic = false;\n this.isRootInsert = true;\n this.isComment = false;\n this.isCloned = false;\n this.isOnce = false;\n};\n\nvar prototypeAccessors = { child: {} };\n\n// DEPRECATED: alias for componentInstance for backwards compat.\n/* istanbul ignore next */\nprototypeAccessors.child.get = function () {\n return this.componentInstance\n};\n\nObject.defineProperties( VNode.prototype, prototypeAccessors );\n\nvar createEmptyVNode = function () {\n var node = new VNode();\n node.text = '';\n node.isComment = true;\n return node\n};\n\nfunction createTextVNode (val) {\n return new VNode(undefined, undefined, undefined, String(val))\n}\n\n// optimized shallow clone\n// used for static nodes and slot nodes because they may be reused across\n// multiple renders, cloning them avoids errors when DOM manipulations rely\n// on their elm reference.\nfunction cloneVNode (vnode) {\n var cloned = new VNode(\n vnode.tag,\n vnode.data,\n vnode.children,\n vnode.text,\n vnode.elm,\n vnode.context,\n vnode.componentOptions\n );\n cloned.ns = vnode.ns;\n cloned.isStatic = vnode.isStatic;\n cloned.key = vnode.key;\n cloned.isCloned = true;\n return cloned\n}\n\nfunction cloneVNodes (vnodes) {\n var res = new Array(vnodes.length);\n for (var i = 0; i < vnodes.length; i++) {\n res[i] = cloneVNode(vnodes[i]);\n }\n return res\n}\n\n/* */\n\nvar hooks = { init: init, prepatch: prepatch, insert: insert, destroy: destroy$1 };\nvar hooksToMerge = Object.keys(hooks);\n\nfunction createComponent (\n Ctor,\n data,\n context,\n children,\n tag\n) {\n if (!Ctor) {\n return\n }\n\n var baseCtor = context.$options._base;\n if (isObject(Ctor)) {\n Ctor = baseCtor.extend(Ctor);\n }\n\n if (typeof Ctor !== 'function') {\n if (false) {\n warn((\"Invalid Component definition: \" + (String(Ctor))), context);\n }\n return\n }\n\n // async component\n if (!Ctor.cid) {\n if (Ctor.resolved) {\n Ctor = Ctor.resolved;\n } else {\n Ctor = resolveAsyncComponent(Ctor, baseCtor, function () {\n // it's ok to queue this on every render because\n // $forceUpdate is buffered by the scheduler.\n context.$forceUpdate();\n });\n if (!Ctor) {\n // return nothing if this is indeed an async component\n // wait for the callback to trigger parent update.\n return\n }\n }\n }\n\n // resolve constructor options in case global mixins are applied after\n // component constructor creation\n resolveConstructorOptions(Ctor);\n\n data = data || {};\n\n // extract props\n var propsData = extractProps(data, Ctor);\n\n // functional component\n if (Ctor.options.functional) {\n return createFunctionalComponent(Ctor, propsData, data, context, children)\n }\n\n // extract listeners, since these needs to be treated as\n // child component listeners instead of DOM listeners\n var listeners = data.on;\n // replace with listeners with .native modifier\n data.on = data.nativeOn;\n\n if (Ctor.options.abstract) {\n // abstract components do not keep anything\n // other than props & listeners\n data = {};\n }\n\n // merge component management hooks onto the placeholder node\n mergeHooks(data);\n\n // return a placeholder vnode\n var name = Ctor.options.name || tag;\n var vnode = new VNode(\n (\"vue-component-\" + (Ctor.cid) + (name ? (\"-\" + name) : '')),\n data, undefined, undefined, undefined, context,\n { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }\n );\n return vnode\n}\n\nfunction createFunctionalComponent (\n Ctor,\n propsData,\n data,\n context,\n children\n) {\n var props = {};\n var propOptions = Ctor.options.props;\n if (propOptions) {\n for (var key in propOptions) {\n props[key] = validateProp(key, propOptions, propsData);\n }\n }\n // ensure the createElement function in functional components\n // gets a unique context - this is necessary for correct named slot check\n var _context = Object.create(context);\n var h = function (a, b, c, d) { return createElement(_context, a, b, c, d, true); };\n var vnode = Ctor.options.render.call(null, h, {\n props: props,\n data: data,\n parent: context,\n children: children,\n slots: function () { return resolveSlots(children, context); }\n });\n if (vnode instanceof VNode) {\n vnode.functionalContext = context;\n if (data.slot) {\n (vnode.data || (vnode.data = {})).slot = data.slot;\n }\n }\n return vnode\n}\n\nfunction createComponentInstanceForVnode (\n vnode, // we know it's MountedComponentVNode but flow doesn't\n parent, // activeInstance in lifecycle state\n parentElm,\n refElm\n) {\n var vnodeComponentOptions = vnode.componentOptions;\n var options = {\n _isComponent: true,\n parent: parent,\n propsData: vnodeComponentOptions.propsData,\n _componentTag: vnodeComponentOptions.tag,\n _parentVnode: vnode,\n _parentListeners: vnodeComponentOptions.listeners,\n _renderChildren: vnodeComponentOptions.children,\n _parentElm: parentElm || null,\n _refElm: refElm || null\n };\n // check inline-template render functions\n var inlineTemplate = vnode.data.inlineTemplate;\n if (inlineTemplate) {\n options.render = inlineTemplate.render;\n options.staticRenderFns = inlineTemplate.staticRenderFns;\n }\n return new vnodeComponentOptions.Ctor(options)\n}\n\nfunction init (\n vnode,\n hydrating,\n parentElm,\n refElm\n) {\n if (!vnode.componentInstance || vnode.componentInstance._isDestroyed) {\n var child = vnode.componentInstance = createComponentInstanceForVnode(\n vnode,\n activeInstance,\n parentElm,\n refElm\n );\n child.$mount(hydrating ? vnode.elm : undefined, hydrating);\n } else if (vnode.data.keepAlive) {\n // kept-alive components, treat as a patch\n var mountedNode = vnode; // work around flow\n prepatch(mountedNode, mountedNode);\n }\n}\n\nfunction prepatch (\n oldVnode,\n vnode\n) {\n var options = vnode.componentOptions;\n var child = vnode.componentInstance = oldVnode.componentInstance;\n child._updateFromParent(\n options.propsData, // updated props\n options.listeners, // updated listeners\n vnode, // new parent vnode\n options.children // new children\n );\n}\n\nfunction insert (vnode) {\n if (!vnode.componentInstance._isMounted) {\n vnode.componentInstance._isMounted = true;\n callHook(vnode.componentInstance, 'mounted');\n }\n if (vnode.data.keepAlive) {\n vnode.componentInstance._inactive = false;\n callHook(vnode.componentInstance, 'activated');\n }\n}\n\nfunction destroy$1 (vnode) {\n if (!vnode.componentInstance._isDestroyed) {\n if (!vnode.data.keepAlive) {\n vnode.componentInstance.$destroy();\n } else {\n vnode.componentInstance._inactive = true;\n callHook(vnode.componentInstance, 'deactivated');\n }\n }\n}\n\nfunction resolveAsyncComponent (\n factory,\n baseCtor,\n cb\n) {\n if (factory.requested) {\n // pool callbacks\n factory.pendingCallbacks.push(cb);\n } else {\n factory.requested = true;\n var cbs = factory.pendingCallbacks = [cb];\n var sync = true;\n\n var resolve = function (res) {\n if (isObject(res)) {\n res = baseCtor.extend(res);\n }\n // cache resolved\n factory.resolved = res;\n // invoke callbacks only if this is not a synchronous resolve\n // (async resolves are shimmed as synchronous during SSR)\n if (!sync) {\n for (var i = 0, l = cbs.length; i < l; i++) {\n cbs[i](res);\n }\n }\n };\n\n var reject = function (reason) {\n \"production\" !== 'production' && warn(\n \"Failed to resolve async component: \" + (String(factory)) +\n (reason ? (\"\\nReason: \" + reason) : '')\n );\n };\n\n var res = factory(resolve, reject);\n\n // handle promise\n if (res && typeof res.then === 'function' && !factory.resolved) {\n res.then(resolve, reject);\n }\n\n sync = false;\n // return in case resolved synchronously\n return factory.resolved\n }\n}\n\nfunction extractProps (data, Ctor) {\n // we are only extracting raw values here.\n // validation and default values are handled in the child\n // component itself.\n var propOptions = Ctor.options.props;\n if (!propOptions) {\n return\n }\n var res = {};\n var attrs = data.attrs;\n var props = data.props;\n var domProps = data.domProps;\n if (attrs || props || domProps) {\n for (var key in propOptions) {\n var altKey = hyphenate(key);\n checkProp(res, props, key, altKey, true) ||\n checkProp(res, attrs, key, altKey) ||\n checkProp(res, domProps, key, altKey);\n }\n }\n return res\n}\n\nfunction checkProp (\n res,\n hash,\n key,\n altKey,\n preserve\n) {\n if (hash) {\n if (hasOwn(hash, key)) {\n res[key] = hash[key];\n if (!preserve) {\n delete hash[key];\n }\n return true\n } else if (hasOwn(hash, altKey)) {\n res[key] = hash[altKey];\n if (!preserve) {\n delete hash[altKey];\n }\n return true\n }\n }\n return false\n}\n\nfunction mergeHooks (data) {\n if (!data.hook) {\n data.hook = {};\n }\n for (var i = 0; i < hooksToMerge.length; i++) {\n var key = hooksToMerge[i];\n var fromParent = data.hook[key];\n var ours = hooks[key];\n data.hook[key] = fromParent ? mergeHook$1(ours, fromParent) : ours;\n }\n}\n\nfunction mergeHook$1 (one, two) {\n return function (a, b, c, d) {\n one(a, b, c, d);\n two(a, b, c, d);\n }\n}\n\n/* */\n\nfunction mergeVNodeHook (def, hookKey, hook, key) {\n key = key + hookKey;\n var injectedHash = def.__injected || (def.__injected = {});\n if (!injectedHash[key]) {\n injectedHash[key] = true;\n var oldHook = def[hookKey];\n if (oldHook) {\n def[hookKey] = function () {\n oldHook.apply(this, arguments);\n hook.apply(this, arguments);\n };\n } else {\n def[hookKey] = hook;\n }\n }\n}\n\n/* */\n\nvar normalizeEvent = cached(function (name) {\n var once = name.charAt(0) === '~'; // Prefixed last, checked first\n name = once ? name.slice(1) : name;\n var capture = name.charAt(0) === '!';\n name = capture ? name.slice(1) : name;\n return {\n name: name,\n once: once,\n capture: capture\n }\n});\n\nfunction createEventHandle (fn) {\n var handle = {\n fn: fn,\n invoker: function () {\n var arguments$1 = arguments;\n\n var fn = handle.fn;\n if (Array.isArray(fn)) {\n for (var i = 0; i < fn.length; i++) {\n fn[i].apply(null, arguments$1);\n }\n } else {\n fn.apply(null, arguments);\n }\n }\n };\n return handle\n}\n\nfunction updateListeners (\n on,\n oldOn,\n add,\n remove$$1,\n vm\n) {\n var name, cur, old, event;\n for (name in on) {\n cur = on[name];\n old = oldOn[name];\n event = normalizeEvent(name);\n if (!cur) {\n \"production\" !== 'production' && warn(\n \"Invalid handler for event \\\"\" + (event.name) + \"\\\": got \" + String(cur),\n vm\n );\n } else if (!old) {\n if (!cur.invoker) {\n cur = on[name] = createEventHandle(cur);\n }\n add(event.name, cur.invoker, event.once, event.capture);\n } else if (cur !== old) {\n old.fn = cur;\n on[name] = old;\n }\n }\n for (name in oldOn) {\n if (!on[name]) {\n event = normalizeEvent(name);\n remove$$1(event.name, oldOn[name].invoker, event.capture);\n }\n }\n}\n\n/* */\n\n// The template compiler attempts to minimize the need for normalization by\n// statically analyzing the template at compile time.\n//\n// For plain HTML markup, normalization can be completely skipped because the\n// generated render function is guaranteed to return Array<VNode>. There are\n// two cases where extra normalization is needed:\n\n// 1. When the children contains components - because a functional component\n// may return an Array instead of a single root. In this case, just a simple\n// nomralization is needed - if any child is an Array, we flatten the whole\n// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep\n// because functional components already normalize their own children.\nfunction simpleNormalizeChildren (children) {\n for (var i = 0; i < children.length; i++) {\n if (Array.isArray(children[i])) {\n return Array.prototype.concat.apply([], children)\n }\n }\n return children\n}\n\n// 2. When the children contains constrcuts that always generated nested Arrays,\n// e.g. <template>, <slot>, v-for, or when the children is provided by user\n// with hand-written render functions / JSX. In such cases a full normalization\n// is needed to cater to all possible types of children values.\nfunction normalizeChildren (children) {\n return isPrimitive(children)\n ? [createTextVNode(children)]\n : Array.isArray(children)\n ? normalizeArrayChildren(children)\n : undefined\n}\n\nfunction normalizeArrayChildren (children, nestedIndex) {\n var res = [];\n var i, c, last;\n for (i = 0; i < children.length; i++) {\n c = children[i];\n if (c == null || typeof c === 'boolean') { continue }\n last = res[res.length - 1];\n // nested\n if (Array.isArray(c)) {\n res.push.apply(res, normalizeArrayChildren(c, ((nestedIndex || '') + \"_\" + i)));\n } else if (isPrimitive(c)) {\n if (last && last.text) {\n last.text += String(c);\n } else if (c !== '') {\n // convert primitive to vnode\n res.push(createTextVNode(c));\n }\n } else {\n if (c.text && last && last.text) {\n res[res.length - 1] = createTextVNode(last.text + c.text);\n } else {\n // default key for nested array children (likely generated by v-for)\n if (c.tag && c.key == null && nestedIndex != null) {\n c.key = \"__vlist\" + nestedIndex + \"_\" + i + \"__\";\n }\n res.push(c);\n }\n }\n }\n return res\n}\n\n/* */\n\nfunction getFirstComponentChild (children) {\n return children && children.filter(function (c) { return c && c.componentOptions; })[0]\n}\n\n/* */\n\nvar SIMPLE_NORMALIZE = 1;\nvar ALWAYS_NORMALIZE = 2;\n\n// wrapper function for providing a more flexible interface\n// without getting yelled at by flow\nfunction createElement (\n context,\n tag,\n data,\n children,\n normalizationType,\n alwaysNormalize\n) {\n if (Array.isArray(data) || isPrimitive(data)) {\n normalizationType = children;\n children = data;\n data = undefined;\n }\n if (alwaysNormalize) { normalizationType = ALWAYS_NORMALIZE; }\n return _createElement(context, tag, data, children, normalizationType)\n}\n\nfunction _createElement (\n context,\n tag,\n data,\n children,\n normalizationType\n) {\n if (data && data.__ob__) {\n \"production\" !== 'production' && warn(\n \"Avoid using observed data object as vnode data: \" + (JSON.stringify(data)) + \"\\n\" +\n 'Always create fresh vnode data objects in each render!',\n context\n );\n return createEmptyVNode()\n }\n if (!tag) {\n // in case of component :is set to falsy value\n return createEmptyVNode()\n }\n // support single function children as default scoped slot\n if (Array.isArray(children) &&\n typeof children[0] === 'function') {\n data = data || {};\n data.scopedSlots = { default: children[0] };\n children.length = 0;\n }\n if (normalizationType === ALWAYS_NORMALIZE) {\n children = normalizeChildren(children);\n } else if (normalizationType === SIMPLE_NORMALIZE) {\n children = simpleNormalizeChildren(children);\n }\n var vnode, ns;\n if (typeof tag === 'string') {\n var Ctor;\n ns = config.getTagNamespace(tag);\n if (config.isReservedTag(tag)) {\n // platform built-in elements\n vnode = new VNode(\n config.parsePlatformTagName(tag), data, children,\n undefined, undefined, context\n );\n } else if ((Ctor = resolveAsset(context.$options, 'components', tag))) {\n // component\n vnode = createComponent(Ctor, data, context, children, tag);\n } else {\n // unknown or unlisted namespaced elements\n // check at runtime because it may get assigned a namespace when its\n // parent normalizes children\n vnode = new VNode(\n tag, data, children,\n undefined, undefined, context\n );\n }\n } else {\n // direct component options / constructor\n vnode = createComponent(tag, data, context, children);\n }\n if (vnode) {\n if (ns) { applyNS(vnode, ns); }\n return vnode\n } else {\n return createEmptyVNode()\n }\n}\n\nfunction applyNS (vnode, ns) {\n vnode.ns = ns;\n if (vnode.tag === 'foreignObject') {\n // use default namespace inside foreignObject\n return\n }\n if (vnode.children) {\n for (var i = 0, l = vnode.children.length; i < l; i++) {\n var child = vnode.children[i];\n if (child.tag && !child.ns) {\n applyNS(child, ns);\n }\n }\n }\n}\n\n/* */\n\nfunction initRender (vm) {\n vm.$vnode = null; // the placeholder node in parent tree\n vm._vnode = null; // the root of the child tree\n vm._staticTrees = null;\n var parentVnode = vm.$options._parentVnode;\n var renderContext = parentVnode && parentVnode.context;\n vm.$slots = resolveSlots(vm.$options._renderChildren, renderContext);\n vm.$scopedSlots = {};\n // bind the createElement fn to this instance\n // so that we get proper render context inside it.\n // args order: tag, data, children, normalizationType, alwaysNormalize\n // internal version is used by render functions compiled from templates\n vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };\n // normalization is always applied for the public version, used in\n // user-written render functions.\n vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };\n}\n\nfunction renderMixin (Vue) {\n Vue.prototype.$nextTick = function (fn) {\n return nextTick(fn, this)\n };\n\n Vue.prototype._render = function () {\n var vm = this;\n var ref = vm.$options;\n var render = ref.render;\n var staticRenderFns = ref.staticRenderFns;\n var _parentVnode = ref._parentVnode;\n\n if (vm._isMounted) {\n // clone slot nodes on re-renders\n for (var key in vm.$slots) {\n vm.$slots[key] = cloneVNodes(vm.$slots[key]);\n }\n }\n\n if (_parentVnode && _parentVnode.data.scopedSlots) {\n vm.$scopedSlots = _parentVnode.data.scopedSlots;\n }\n\n if (staticRenderFns && !vm._staticTrees) {\n vm._staticTrees = [];\n }\n // set parent vnode. this allows render functions to have access\n // to the data on the placeholder node.\n vm.$vnode = _parentVnode;\n // render self\n var vnode;\n try {\n vnode = render.call(vm._renderProxy, vm.$createElement);\n } catch (e) {\n /* istanbul ignore else */\n if (config.errorHandler) {\n config.errorHandler.call(null, e, vm);\n } else {\n if (false) {\n warn((\"Error when rendering \" + (formatComponentName(vm)) + \":\"));\n }\n throw e\n }\n // return previous vnode to prevent render error causing blank component\n vnode = vm._vnode;\n }\n // return empty vnode in case the render function errored out\n if (!(vnode instanceof VNode)) {\n if (false) {\n warn(\n 'Multiple root nodes returned from render function. Render function ' +\n 'should return a single root node.',\n vm\n );\n }\n vnode = createEmptyVNode();\n }\n // set parent\n vnode.parent = _parentVnode;\n return vnode\n };\n\n // toString for mustaches\n Vue.prototype._s = _toString;\n // convert text to vnode\n Vue.prototype._v = createTextVNode;\n // number conversion\n Vue.prototype._n = toNumber;\n // empty vnode\n Vue.prototype._e = createEmptyVNode;\n // loose equal\n Vue.prototype._q = looseEqual;\n // loose indexOf\n Vue.prototype._i = looseIndexOf;\n\n // render static tree by index\n Vue.prototype._m = function renderStatic (\n index,\n isInFor\n ) {\n var tree = this._staticTrees[index];\n // if has already-rendered static tree and not inside v-for,\n // we can reuse the same tree by doing a shallow clone.\n if (tree && !isInFor) {\n return Array.isArray(tree)\n ? cloneVNodes(tree)\n : cloneVNode(tree)\n }\n // otherwise, render a fresh tree.\n tree = this._staticTrees[index] = this.$options.staticRenderFns[index].call(this._renderProxy);\n markStatic(tree, (\"__static__\" + index), false);\n return tree\n };\n\n // mark node as static (v-once)\n Vue.prototype._o = function markOnce (\n tree,\n index,\n key\n ) {\n markStatic(tree, (\"__once__\" + index + (key ? (\"_\" + key) : \"\")), true);\n return tree\n };\n\n function markStatic (tree, key, isOnce) {\n if (Array.isArray(tree)) {\n for (var i = 0; i < tree.length; i++) {\n if (tree[i] && typeof tree[i] !== 'string') {\n markStaticNode(tree[i], (key + \"_\" + i), isOnce);\n }\n }\n } else {\n markStaticNode(tree, key, isOnce);\n }\n }\n\n function markStaticNode (node, key, isOnce) {\n node.isStatic = true;\n node.key = key;\n node.isOnce = isOnce;\n }\n\n // filter resolution helper\n Vue.prototype._f = function resolveFilter (id) {\n return resolveAsset(this.$options, 'filters', id, true) || identity\n };\n\n // render v-for\n Vue.prototype._l = function renderList (\n val,\n render\n ) {\n var ret, i, l, keys, key;\n if (Array.isArray(val) || typeof val === 'string') {\n ret = new Array(val.length);\n for (i = 0, l = val.length; i < l; i++) {\n ret[i] = render(val[i], i);\n }\n } else if (typeof val === 'number') {\n ret = new Array(val);\n for (i = 0; i < val; i++) {\n ret[i] = render(i + 1, i);\n }\n } else if (isObject(val)) {\n keys = Object.keys(val);\n ret = new Array(keys.length);\n for (i = 0, l = keys.length; i < l; i++) {\n key = keys[i];\n ret[i] = render(val[key], key, i);\n }\n }\n return ret\n };\n\n // renderSlot\n Vue.prototype._t = function (\n name,\n fallback,\n props,\n bindObject\n ) {\n var scopedSlotFn = this.$scopedSlots[name];\n if (scopedSlotFn) { // scoped slot\n props = props || {};\n if (bindObject) {\n extend(props, bindObject);\n }\n return scopedSlotFn(props) || fallback\n } else {\n var slotNodes = this.$slots[name];\n // warn duplicate slot usage\n if (slotNodes && \"production\" !== 'production') {\n slotNodes._rendered && warn(\n \"Duplicate presence of slot \\\"\" + name + \"\\\" found in the same render tree \" +\n \"- this will likely cause render errors.\",\n this\n );\n slotNodes._rendered = true;\n }\n return slotNodes || fallback\n }\n };\n\n // apply v-bind object\n Vue.prototype._b = function bindProps (\n data,\n tag,\n value,\n asProp\n ) {\n if (value) {\n if (!isObject(value)) {\n \"production\" !== 'production' && warn(\n 'v-bind without argument expects an Object or Array value',\n this\n );\n } else {\n if (Array.isArray(value)) {\n value = toObject(value);\n }\n for (var key in value) {\n if (key === 'class' || key === 'style') {\n data[key] = value[key];\n } else {\n var type = data.attrs && data.attrs.type;\n var hash = asProp || config.mustUseProp(tag, type, key)\n ? data.domProps || (data.domProps = {})\n : data.attrs || (data.attrs = {});\n hash[key] = value[key];\n }\n }\n }\n }\n return data\n };\n\n // check v-on keyCodes\n Vue.prototype._k = function checkKeyCodes (\n eventKeyCode,\n key,\n builtInAlias\n ) {\n var keyCodes = config.keyCodes[key] || builtInAlias;\n if (Array.isArray(keyCodes)) {\n return keyCodes.indexOf(eventKeyCode) === -1\n } else {\n return keyCodes !== eventKeyCode\n }\n };\n}\n\nfunction resolveSlots (\n children,\n context\n) {\n var slots = {};\n if (!children) {\n return slots\n }\n var defaultSlot = [];\n var name, child;\n for (var i = 0, l = children.length; i < l; i++) {\n child = children[i];\n // named slots should only be respected if the vnode was rendered in the\n // same context.\n if ((child.context === context || child.functionalContext === context) &&\n child.data && (name = child.data.slot)) {\n var slot = (slots[name] || (slots[name] = []));\n if (child.tag === 'template') {\n slot.push.apply(slot, child.children);\n } else {\n slot.push(child);\n }\n } else {\n defaultSlot.push(child);\n }\n }\n // ignore single whitespace\n if (defaultSlot.length && !(\n defaultSlot.length === 1 &&\n (defaultSlot[0].text === ' ' || defaultSlot[0].isComment)\n )) {\n slots.default = defaultSlot;\n }\n return slots\n}\n\n/* */\n\nfunction initEvents (vm) {\n vm._events = Object.create(null);\n vm._hasHookEvent = false;\n // init parent attached events\n var listeners = vm.$options._parentListeners;\n if (listeners) {\n updateComponentListeners(vm, listeners);\n }\n}\n\nvar target;\n\nfunction add$1 (event, fn, once) {\n if (once) {\n target.$once(event, fn);\n } else {\n target.$on(event, fn);\n }\n}\n\nfunction remove$2 (event, fn) {\n target.$off(event, fn);\n}\n\nfunction updateComponentListeners (\n vm,\n listeners,\n oldListeners\n) {\n target = vm;\n updateListeners(listeners, oldListeners || {}, add$1, remove$2, vm);\n}\n\nfunction eventsMixin (Vue) {\n var hookRE = /^hook:/;\n Vue.prototype.$on = function (event, fn) {\n var vm = this;(vm._events[event] || (vm._events[event] = [])).push(fn);\n // optimize hook:event cost by using a boolean flag marked at registration\n // instead of a hash lookup\n if (hookRE.test(event)) {\n vm._hasHookEvent = true;\n }\n return vm\n };\n\n Vue.prototype.$once = function (event, fn) {\n var vm = this;\n function on () {\n vm.$off(event, on);\n fn.apply(vm, arguments);\n }\n on.fn = fn;\n vm.$on(event, on);\n return vm\n };\n\n Vue.prototype.$off = function (event, fn) {\n var vm = this;\n // all\n if (!arguments.length) {\n vm._events = Object.create(null);\n return vm\n }\n // specific event\n var cbs = vm._events[event];\n if (!cbs) {\n return vm\n }\n if (arguments.length === 1) {\n vm._events[event] = null;\n return vm\n }\n // specific handler\n var cb;\n var i = cbs.length;\n while (i--) {\n cb = cbs[i];\n if (cb === fn || cb.fn === fn) {\n cbs.splice(i, 1);\n break\n }\n }\n return vm\n };\n\n Vue.prototype.$emit = function (event) {\n var vm = this;\n var cbs = vm._events[event];\n if (cbs) {\n cbs = cbs.length > 1 ? toArray(cbs) : cbs;\n var args = toArray(arguments, 1);\n for (var i = 0, l = cbs.length; i < l; i++) {\n cbs[i].apply(vm, args);\n }\n }\n return vm\n };\n}\n\n/* */\n\nvar activeInstance = null;\n\nfunction initLifecycle (vm) {\n var options = vm.$options;\n\n // locate first non-abstract parent\n var parent = options.parent;\n if (parent && !options.abstract) {\n while (parent.$options.abstract && parent.$parent) {\n parent = parent.$parent;\n }\n parent.$children.push(vm);\n }\n\n vm.$parent = parent;\n vm.$root = parent ? parent.$root : vm;\n\n vm.$children = [];\n vm.$refs = {};\n\n vm._watcher = null;\n vm._inactive = false;\n vm._isMounted = false;\n vm._isDestroyed = false;\n vm._isBeingDestroyed = false;\n}\n\nfunction lifecycleMixin (Vue) {\n Vue.prototype._mount = function (\n el,\n hydrating\n ) {\n var vm = this;\n vm.$el = el;\n if (!vm.$options.render) {\n vm.$options.render = createEmptyVNode;\n if (false) {\n /* istanbul ignore if */\n if (vm.$options.template && vm.$options.template.charAt(0) !== '#') {\n warn(\n 'You are using the runtime-only build of Vue where the template ' +\n 'option is not available. Either pre-compile the templates into ' +\n 'render functions, or use the compiler-included build.',\n vm\n );\n } else {\n warn(\n 'Failed to mount component: template or render function not defined.',\n vm\n );\n }\n }\n }\n callHook(vm, 'beforeMount');\n vm._watcher = new Watcher(vm, function updateComponent () {\n vm._update(vm._render(), hydrating);\n }, noop);\n hydrating = false;\n // manually mounted instance, call mounted on self\n // mounted is called for render-created child components in its inserted hook\n if (vm.$vnode == null) {\n vm._isMounted = true;\n callHook(vm, 'mounted');\n }\n return vm\n };\n\n Vue.prototype._update = function (vnode, hydrating) {\n var vm = this;\n if (vm._isMounted) {\n callHook(vm, 'beforeUpdate');\n }\n var prevEl = vm.$el;\n var prevVnode = vm._vnode;\n var prevActiveInstance = activeInstance;\n activeInstance = vm;\n vm._vnode = vnode;\n // Vue.prototype.__patch__ is injected in entry points\n // based on the rendering backend used.\n if (!prevVnode) {\n // initial render\n vm.$el = vm.__patch__(\n vm.$el, vnode, hydrating, false /* removeOnly */,\n vm.$options._parentElm,\n vm.$options._refElm\n );\n } else {\n // updates\n vm.$el = vm.__patch__(prevVnode, vnode);\n }\n activeInstance = prevActiveInstance;\n // update __vue__ reference\n if (prevEl) {\n prevEl.__vue__ = null;\n }\n if (vm.$el) {\n vm.$el.__vue__ = vm;\n }\n // if parent is an HOC, update its $el as well\n if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {\n vm.$parent.$el = vm.$el;\n }\n // updated hook is called by the scheduler to ensure that children are\n // updated in a parent's updated hook.\n };\n\n Vue.prototype._updateFromParent = function (\n propsData,\n listeners,\n parentVnode,\n renderChildren\n ) {\n var vm = this;\n var hasChildren = !!(vm.$options._renderChildren || renderChildren);\n vm.$options._parentVnode = parentVnode;\n vm.$vnode = parentVnode; // update vm's placeholder node without re-render\n if (vm._vnode) { // update child tree's parent\n vm._vnode.parent = parentVnode;\n }\n vm.$options._renderChildren = renderChildren;\n // update props\n if (propsData && vm.$options.props) {\n observerState.shouldConvert = false;\n if (false) {\n observerState.isSettingProps = true;\n }\n var propKeys = vm.$options._propKeys || [];\n for (var i = 0; i < propKeys.length; i++) {\n var key = propKeys[i];\n vm[key] = validateProp(key, vm.$options.props, propsData, vm);\n }\n observerState.shouldConvert = true;\n if (false) {\n observerState.isSettingProps = false;\n }\n vm.$options.propsData = propsData;\n }\n // update listeners\n if (listeners) {\n var oldListeners = vm.$options._parentListeners;\n vm.$options._parentListeners = listeners;\n updateComponentListeners(vm, listeners, oldListeners);\n }\n // resolve slots + force update if has children\n if (hasChildren) {\n vm.$slots = resolveSlots(renderChildren, parentVnode.context);\n vm.$forceUpdate();\n }\n };\n\n Vue.prototype.$forceUpdate = function () {\n var vm = this;\n if (vm._watcher) {\n vm._watcher.update();\n }\n };\n\n Vue.prototype.$destroy = function () {\n var vm = this;\n if (vm._isBeingDestroyed) {\n return\n }\n callHook(vm, 'beforeDestroy');\n vm._isBeingDestroyed = true;\n // remove self from parent\n var parent = vm.$parent;\n if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {\n remove$1(parent.$children, vm);\n }\n // teardown watchers\n if (vm._watcher) {\n vm._watcher.teardown();\n }\n var i = vm._watchers.length;\n while (i--) {\n vm._watchers[i].teardown();\n }\n // remove reference from data ob\n // frozen object may not have observer.\n if (vm._data.__ob__) {\n vm._data.__ob__.vmCount--;\n }\n // call the last hook...\n vm._isDestroyed = true;\n callHook(vm, 'destroyed');\n // turn off all instance listeners.\n vm.$off();\n // remove __vue__ reference\n if (vm.$el) {\n vm.$el.__vue__ = null;\n }\n // invoke destroy hooks on current rendered tree\n vm.__patch__(vm._vnode, null);\n };\n}\n\nfunction callHook (vm, hook) {\n var handlers = vm.$options[hook];\n if (handlers) {\n for (var i = 0, j = handlers.length; i < j; i++) {\n handlers[i].call(vm);\n }\n }\n if (vm._hasHookEvent) {\n vm.$emit('hook:' + hook);\n }\n}\n\n/* */\n\n\nvar queue = [];\nvar has$1 = {};\nvar circular = {};\nvar waiting = false;\nvar flushing = false;\nvar index = 0;\n\n/**\n * Reset the scheduler's state.\n */\nfunction resetSchedulerState () {\n queue.length = 0;\n has$1 = {};\n if (false) {\n circular = {};\n }\n waiting = flushing = false;\n}\n\n/**\n * Flush both queues and run the watchers.\n */\nfunction flushSchedulerQueue () {\n flushing = true;\n var watcher, id, vm;\n\n // Sort queue before flush.\n // This ensures that:\n // 1. Components are updated from parent to child. (because parent is always\n // created before the child)\n // 2. A component's user watchers are run before its render watcher (because\n // user watchers are created before the render watcher)\n // 3. If a component is destroyed during a parent component's watcher run,\n // its watchers can be skipped.\n queue.sort(function (a, b) { return a.id - b.id; });\n\n // do not cache length because more watchers might be pushed\n // as we run existing watchers\n for (index = 0; index < queue.length; index++) {\n watcher = queue[index];\n id = watcher.id;\n has$1[id] = null;\n watcher.run();\n // in dev build, check and stop circular updates.\n if (false) {\n circular[id] = (circular[id] || 0) + 1;\n if (circular[id] > config._maxUpdateCount) {\n warn(\n 'You may have an infinite update loop ' + (\n watcher.user\n ? (\"in watcher with expression \\\"\" + (watcher.expression) + \"\\\"\")\n : \"in a component render function.\"\n ),\n watcher.vm\n );\n break\n }\n }\n }\n\n // call updated hooks\n index = queue.length;\n while (index--) {\n watcher = queue[index];\n vm = watcher.vm;\n if (vm._watcher === watcher && vm._isMounted) {\n callHook(vm, 'updated');\n }\n }\n\n // devtool hook\n /* istanbul ignore if */\n if (devtools && config.devtools) {\n devtools.emit('flush');\n }\n\n resetSchedulerState();\n}\n\n/**\n * Push a watcher into the watcher queue.\n * Jobs with duplicate IDs will be skipped unless it's\n * pushed when the queue is being flushed.\n */\nfunction queueWatcher (watcher) {\n var id = watcher.id;\n if (has$1[id] == null) {\n has$1[id] = true;\n if (!flushing) {\n queue.push(watcher);\n } else {\n // if already flushing, splice the watcher based on its id\n // if already past its id, it will be run next immediately.\n var i = queue.length - 1;\n while (i >= 0 && queue[i].id > watcher.id) {\n i--;\n }\n queue.splice(Math.max(i, index) + 1, 0, watcher);\n }\n // queue the flush\n if (!waiting) {\n waiting = true;\n nextTick(flushSchedulerQueue);\n }\n }\n}\n\n/* */\n\nvar uid$2 = 0;\n\n/**\n * A watcher parses an expression, collects dependencies,\n * and fires callback when the expression value changes.\n * This is used for both the $watch() api and directives.\n */\nvar Watcher = function Watcher (\n vm,\n expOrFn,\n cb,\n options\n) {\n this.vm = vm;\n vm._watchers.push(this);\n // options\n if (options) {\n this.deep = !!options.deep;\n this.user = !!options.user;\n this.lazy = !!options.lazy;\n this.sync = !!options.sync;\n } else {\n this.deep = this.user = this.lazy = this.sync = false;\n }\n this.cb = cb;\n this.id = ++uid$2; // uid for batching\n this.active = true;\n this.dirty = this.lazy; // for lazy watchers\n this.deps = [];\n this.newDeps = [];\n this.depIds = new _Set();\n this.newDepIds = new _Set();\n this.expression = false\n ? expOrFn.toString()\n : '';\n // parse expression for getter\n if (typeof expOrFn === 'function') {\n this.getter = expOrFn;\n } else {\n this.getter = parsePath(expOrFn);\n if (!this.getter) {\n this.getter = function () {};\n \"production\" !== 'production' && warn(\n \"Failed watching path: \\\"\" + expOrFn + \"\\\" \" +\n 'Watcher only accepts simple dot-delimited paths. ' +\n 'For full control, use a function instead.',\n vm\n );\n }\n }\n this.value = this.lazy\n ? undefined\n : this.get();\n};\n\n/**\n * Evaluate the getter, and re-collect dependencies.\n */\nWatcher.prototype.get = function get () {\n pushTarget(this);\n var value = this.getter.call(this.vm, this.vm);\n // \"touch\" every property so they are all tracked as\n // dependencies for deep watching\n if (this.deep) {\n traverse(value);\n }\n popTarget();\n this.cleanupDeps();\n return value\n};\n\n/**\n * Add a dependency to this directive.\n */\nWatcher.prototype.addDep = function addDep (dep) {\n var id = dep.id;\n if (!this.newDepIds.has(id)) {\n this.newDepIds.add(id);\n this.newDeps.push(dep);\n if (!this.depIds.has(id)) {\n dep.addSub(this);\n }\n }\n};\n\n/**\n * Clean up for dependency collection.\n */\nWatcher.prototype.cleanupDeps = function cleanupDeps () {\n var this$1 = this;\n\n var i = this.deps.length;\n while (i--) {\n var dep = this$1.deps[i];\n if (!this$1.newDepIds.has(dep.id)) {\n dep.removeSub(this$1);\n }\n }\n var tmp = this.depIds;\n this.depIds = this.newDepIds;\n this.newDepIds = tmp;\n this.newDepIds.clear();\n tmp = this.deps;\n this.deps = this.newDeps;\n this.newDeps = tmp;\n this.newDeps.length = 0;\n};\n\n/**\n * Subscriber interface.\n * Will be called when a dependency changes.\n */\nWatcher.prototype.update = function update () {\n /* istanbul ignore else */\n if (this.lazy) {\n this.dirty = true;\n } else if (this.sync) {\n this.run();\n } else {\n queueWatcher(this);\n }\n};\n\n/**\n * Scheduler job interface.\n * Will be called by the scheduler.\n */\nWatcher.prototype.run = function run () {\n if (this.active) {\n var value = this.get();\n if (\n value !== this.value ||\n // Deep watchers and watchers on Object/Arrays should fire even\n // when the value is the same, because the value may\n // have mutated.\n isObject(value) ||\n this.deep\n ) {\n // set new value\n var oldValue = this.value;\n this.value = value;\n if (this.user) {\n try {\n this.cb.call(this.vm, value, oldValue);\n } catch (e) {\n /* istanbul ignore else */\n if (config.errorHandler) {\n config.errorHandler.call(null, e, this.vm);\n } else {\n \"production\" !== 'production' && warn(\n (\"Error in watcher \\\"\" + (this.expression) + \"\\\"\"),\n this.vm\n );\n throw e\n }\n }\n } else {\n this.cb.call(this.vm, value, oldValue);\n }\n }\n }\n};\n\n/**\n * Evaluate the value of the watcher.\n * This only gets called for lazy watchers.\n */\nWatcher.prototype.evaluate = function evaluate () {\n this.value = this.get();\n this.dirty = false;\n};\n\n/**\n * Depend on all deps collected by this watcher.\n */\nWatcher.prototype.depend = function depend () {\n var this$1 = this;\n\n var i = this.deps.length;\n while (i--) {\n this$1.deps[i].depend();\n }\n};\n\n/**\n * Remove self from all dependencies' subscriber list.\n */\nWatcher.prototype.teardown = function teardown () {\n var this$1 = this;\n\n if (this.active) {\n // remove self from vm's watcher list\n // this is a somewhat expensive operation so we skip it\n // if the vm is being destroyed.\n if (!this.vm._isBeingDestroyed) {\n remove$1(this.vm._watchers, this);\n }\n var i = this.deps.length;\n while (i--) {\n this$1.deps[i].removeSub(this$1);\n }\n this.active = false;\n }\n};\n\n/**\n * Recursively traverse an object to evoke all converted\n * getters, so that every nested property inside the object\n * is collected as a \"deep\" dependency.\n */\nvar seenObjects = new _Set();\nfunction traverse (val) {\n seenObjects.clear();\n _traverse(val, seenObjects);\n}\n\nfunction _traverse (val, seen) {\n var i, keys;\n var isA = Array.isArray(val);\n if ((!isA && !isObject(val)) || !Object.isExtensible(val)) {\n return\n }\n if (val.__ob__) {\n var depId = val.__ob__.dep.id;\n if (seen.has(depId)) {\n return\n }\n seen.add(depId);\n }\n if (isA) {\n i = val.length;\n while (i--) { _traverse(val[i], seen); }\n } else {\n keys = Object.keys(val);\n i = keys.length;\n while (i--) { _traverse(val[keys[i]], seen); }\n }\n}\n\n/* */\n\nfunction initState (vm) {\n vm._watchers = [];\n var opts = vm.$options;\n if (opts.props) { initProps(vm, opts.props); }\n if (opts.methods) { initMethods(vm, opts.methods); }\n if (opts.data) {\n initData(vm);\n } else {\n observe(vm._data = {}, true /* asRootData */);\n }\n if (opts.computed) { initComputed(vm, opts.computed); }\n if (opts.watch) { initWatch(vm, opts.watch); }\n}\n\nvar isReservedProp = { key: 1, ref: 1, slot: 1 };\n\nfunction initProps (vm, props) {\n var propsData = vm.$options.propsData || {};\n var keys = vm.$options._propKeys = Object.keys(props);\n var isRoot = !vm.$parent;\n // root instance props should be converted\n observerState.shouldConvert = isRoot;\n var loop = function ( i ) {\n var key = keys[i];\n /* istanbul ignore else */\n if (false) {\n if (isReservedProp[key]) {\n warn(\n (\"\\\"\" + key + \"\\\" is a reserved attribute and cannot be used as component prop.\"),\n vm\n );\n }\n defineReactive$$1(vm, key, validateProp(key, props, propsData, vm), function () {\n if (vm.$parent && !observerState.isSettingProps) {\n warn(\n \"Avoid mutating a prop directly since the value will be \" +\n \"overwritten whenever the parent component re-renders. \" +\n \"Instead, use a data or computed property based on the prop's \" +\n \"value. Prop being mutated: \\\"\" + key + \"\\\"\",\n vm\n );\n }\n });\n } else {\n defineReactive$$1(vm, key, validateProp(key, props, propsData, vm));\n }\n };\n\n for (var i = 0; i < keys.length; i++) loop( i );\n observerState.shouldConvert = true;\n}\n\nfunction initData (vm) {\n var data = vm.$options.data;\n data = vm._data = typeof data === 'function'\n ? data.call(vm)\n : data || {};\n if (!isPlainObject(data)) {\n data = {};\n \"production\" !== 'production' && warn(\n 'data functions should return an object:\\n' +\n 'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',\n vm\n );\n }\n // proxy data on instance\n var keys = Object.keys(data);\n var props = vm.$options.props;\n var i = keys.length;\n while (i--) {\n if (props && hasOwn(props, keys[i])) {\n \"production\" !== 'production' && warn(\n \"The data property \\\"\" + (keys[i]) + \"\\\" is already declared as a prop. \" +\n \"Use prop default value instead.\",\n vm\n );\n } else {\n proxy(vm, keys[i]);\n }\n }\n // observe data\n observe(data, true /* asRootData */);\n}\n\nvar computedSharedDefinition = {\n enumerable: true,\n configurable: true,\n get: noop,\n set: noop\n};\n\nfunction initComputed (vm, computed) {\n for (var key in computed) {\n /* istanbul ignore if */\n if (false) {\n warn(\n \"existing instance property \\\"\" + key + \"\\\" will be \" +\n \"overwritten by a computed property with the same name.\",\n vm\n );\n }\n var userDef = computed[key];\n if (typeof userDef === 'function') {\n computedSharedDefinition.get = makeComputedGetter(userDef, vm);\n computedSharedDefinition.set = noop;\n } else {\n computedSharedDefinition.get = userDef.get\n ? userDef.cache !== false\n ? makeComputedGetter(userDef.get, vm)\n : bind$1(userDef.get, vm)\n : noop;\n computedSharedDefinition.set = userDef.set\n ? bind$1(userDef.set, vm)\n : noop;\n }\n Object.defineProperty(vm, key, computedSharedDefinition);\n }\n}\n\nfunction makeComputedGetter (getter, owner) {\n var watcher = new Watcher(owner, getter, noop, {\n lazy: true\n });\n return function computedGetter () {\n if (watcher.dirty) {\n watcher.evaluate();\n }\n if (Dep.target) {\n watcher.depend();\n }\n return watcher.value\n }\n}\n\nfunction initMethods (vm, methods) {\n for (var key in methods) {\n vm[key] = methods[key] == null ? noop : bind$1(methods[key], vm);\n if (false) {\n warn(\n \"method \\\"\" + key + \"\\\" has an undefined value in the component definition. \" +\n \"Did you reference the function correctly?\",\n vm\n );\n }\n }\n}\n\nfunction initWatch (vm, watch) {\n for (var key in watch) {\n var handler = watch[key];\n if (Array.isArray(handler)) {\n for (var i = 0; i < handler.length; i++) {\n createWatcher(vm, key, handler[i]);\n }\n } else {\n createWatcher(vm, key, handler);\n }\n }\n}\n\nfunction createWatcher (vm, key, handler) {\n var options;\n if (isPlainObject(handler)) {\n options = handler;\n handler = handler.handler;\n }\n if (typeof handler === 'string') {\n handler = vm[handler];\n }\n vm.$watch(key, handler, options);\n}\n\nfunction stateMixin (Vue) {\n // flow somehow has problems with directly declared definition object\n // when using Object.defineProperty, so we have to procedurally build up\n // the object here.\n var dataDef = {};\n dataDef.get = function () {\n return this._data\n };\n if (false) {\n dataDef.set = function (newData) {\n warn(\n 'Avoid replacing instance root $data. ' +\n 'Use nested data properties instead.',\n this\n );\n };\n }\n Object.defineProperty(Vue.prototype, '$data', dataDef);\n\n Vue.prototype.$set = set$1;\n Vue.prototype.$delete = del;\n\n Vue.prototype.$watch = function (\n expOrFn,\n cb,\n options\n ) {\n var vm = this;\n options = options || {};\n options.user = true;\n var watcher = new Watcher(vm, expOrFn, cb, options);\n if (options.immediate) {\n cb.call(vm, watcher.value);\n }\n return function unwatchFn () {\n watcher.teardown();\n }\n };\n}\n\nfunction proxy (vm, key) {\n if (!isReserved(key)) {\n Object.defineProperty(vm, key, {\n configurable: true,\n enumerable: true,\n get: function proxyGetter () {\n return vm._data[key]\n },\n set: function proxySetter (val) {\n vm._data[key] = val;\n }\n });\n }\n}\n\n/* */\n\nvar uid = 0;\n\nfunction initMixin (Vue) {\n Vue.prototype._init = function (options) {\n var vm = this;\n // a uid\n vm._uid = uid++;\n // a flag to avoid this being observed\n vm._isVue = true;\n // merge options\n if (options && options._isComponent) {\n // optimize internal component instantiation\n // since dynamic options merging is pretty slow, and none of the\n // internal component options needs special treatment.\n initInternalComponent(vm, options);\n } else {\n vm.$options = mergeOptions(\n resolveConstructorOptions(vm.constructor),\n options || {},\n vm\n );\n }\n /* istanbul ignore else */\n if (false) {\n initProxy(vm);\n } else {\n vm._renderProxy = vm;\n }\n // expose real self\n vm._self = vm;\n initLifecycle(vm);\n initEvents(vm);\n initRender(vm);\n callHook(vm, 'beforeCreate');\n initState(vm);\n callHook(vm, 'created');\n if (vm.$options.el) {\n vm.$mount(vm.$options.el);\n }\n };\n}\n\nfunction initInternalComponent (vm, options) {\n var opts = vm.$options = Object.create(vm.constructor.options);\n // doing this because it's faster than dynamic enumeration.\n opts.parent = options.parent;\n opts.propsData = options.propsData;\n opts._parentVnode = options._parentVnode;\n opts._parentListeners = options._parentListeners;\n opts._renderChildren = options._renderChildren;\n opts._componentTag = options._componentTag;\n opts._parentElm = options._parentElm;\n opts._refElm = options._refElm;\n if (options.render) {\n opts.render = options.render;\n opts.staticRenderFns = options.staticRenderFns;\n }\n}\n\nfunction resolveConstructorOptions (Ctor) {\n var options = Ctor.options;\n if (Ctor.super) {\n var superOptions = Ctor.super.options;\n var cachedSuperOptions = Ctor.superOptions;\n var extendOptions = Ctor.extendOptions;\n if (superOptions !== cachedSuperOptions) {\n // super option changed\n Ctor.superOptions = superOptions;\n extendOptions.render = options.render;\n extendOptions.staticRenderFns = options.staticRenderFns;\n extendOptions._scopeId = options._scopeId;\n options = Ctor.options = mergeOptions(superOptions, extendOptions);\n if (options.name) {\n options.components[options.name] = Ctor;\n }\n }\n }\n return options\n}\n\nfunction Vue$3 (options) {\n if (false) {\n warn('Vue is a constructor and should be called with the `new` keyword');\n }\n this._init(options);\n}\n\ninitMixin(Vue$3);\nstateMixin(Vue$3);\neventsMixin(Vue$3);\nlifecycleMixin(Vue$3);\nrenderMixin(Vue$3);\n\n/* */\n\nfunction initUse (Vue) {\n Vue.use = function (plugin) {\n /* istanbul ignore if */\n if (plugin.installed) {\n return\n }\n // additional parameters\n var args = toArray(arguments, 1);\n args.unshift(this);\n if (typeof plugin.install === 'function') {\n plugin.install.apply(plugin, args);\n } else {\n plugin.apply(null, args);\n }\n plugin.installed = true;\n return this\n };\n}\n\n/* */\n\nfunction initMixin$1 (Vue) {\n Vue.mixin = function (mixin) {\n this.options = mergeOptions(this.options, mixin);\n };\n}\n\n/* */\n\nfunction initExtend (Vue) {\n /**\n * Each instance constructor, including Vue, has a unique\n * cid. This enables us to create wrapped \"child\n * constructors\" for prototypal inheritance and cache them.\n */\n Vue.cid = 0;\n var cid = 1;\n\n /**\n * Class inheritance\n */\n Vue.extend = function (extendOptions) {\n extendOptions = extendOptions || {};\n var Super = this;\n var SuperId = Super.cid;\n var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});\n if (cachedCtors[SuperId]) {\n return cachedCtors[SuperId]\n }\n var name = extendOptions.name || Super.options.name;\n if (false) {\n if (!/^[a-zA-Z][\\w-]*$/.test(name)) {\n warn(\n 'Invalid component name: \"' + name + '\". Component names ' +\n 'can only contain alphanumeric characters and the hyphen, ' +\n 'and must start with a letter.'\n );\n }\n }\n var Sub = function VueComponent (options) {\n this._init(options);\n };\n Sub.prototype = Object.create(Super.prototype);\n Sub.prototype.constructor = Sub;\n Sub.cid = cid++;\n Sub.options = mergeOptions(\n Super.options,\n extendOptions\n );\n Sub['super'] = Super;\n // allow further extension/mixin/plugin usage\n Sub.extend = Super.extend;\n Sub.mixin = Super.mixin;\n Sub.use = Super.use;\n // create asset registers, so extended classes\n // can have their private assets too.\n config._assetTypes.forEach(function (type) {\n Sub[type] = Super[type];\n });\n // enable recursive self-lookup\n if (name) {\n Sub.options.components[name] = Sub;\n }\n // keep a reference to the super options at extension time.\n // later at instantiation we can check if Super's options have\n // been updated.\n Sub.superOptions = Super.options;\n Sub.extendOptions = extendOptions;\n // cache constructor\n cachedCtors[SuperId] = Sub;\n return Sub\n };\n}\n\n/* */\n\nfunction initAssetRegisters (Vue) {\n /**\n * Create asset registration methods.\n */\n config._assetTypes.forEach(function (type) {\n Vue[type] = function (\n id,\n definition\n ) {\n if (!definition) {\n return this.options[type + 's'][id]\n } else {\n /* istanbul ignore if */\n if (false) {\n if (type === 'component' && config.isReservedTag(id)) {\n warn(\n 'Do not use built-in or reserved HTML elements as component ' +\n 'id: ' + id\n );\n }\n }\n if (type === 'component' && isPlainObject(definition)) {\n definition.name = definition.name || id;\n definition = this.options._base.extend(definition);\n }\n if (type === 'directive' && typeof definition === 'function') {\n definition = { bind: definition, update: definition };\n }\n this.options[type + 's'][id] = definition;\n return definition\n }\n };\n });\n}\n\n/* */\n\nvar patternTypes = [String, RegExp];\n\nfunction getComponentName (opts) {\n return opts && (opts.Ctor.options.name || opts.tag)\n}\n\nfunction matches (pattern, name) {\n if (typeof pattern === 'string') {\n return pattern.split(',').indexOf(name) > -1\n } else {\n return pattern.test(name)\n }\n}\n\nfunction pruneCache (cache, filter) {\n for (var key in cache) {\n var cachedNode = cache[key];\n if (cachedNode) {\n var name = getComponentName(cachedNode.componentOptions);\n if (name && !filter(name)) {\n pruneCacheEntry(cachedNode);\n cache[key] = null;\n }\n }\n }\n}\n\nfunction pruneCacheEntry (vnode) {\n if (vnode) {\n if (!vnode.componentInstance._inactive) {\n callHook(vnode.componentInstance, 'deactivated');\n }\n vnode.componentInstance.$destroy();\n }\n}\n\nvar KeepAlive = {\n name: 'keep-alive',\n abstract: true,\n\n props: {\n include: patternTypes,\n exclude: patternTypes\n },\n\n created: function created () {\n this.cache = Object.create(null);\n },\n\n destroyed: function destroyed () {\n var this$1 = this;\n\n for (var key in this.cache) {\n pruneCacheEntry(this$1.cache[key]);\n }\n },\n\n watch: {\n include: function include (val) {\n pruneCache(this.cache, function (name) { return matches(val, name); });\n },\n exclude: function exclude (val) {\n pruneCache(this.cache, function (name) { return !matches(val, name); });\n }\n },\n\n render: function render () {\n var vnode = getFirstComponentChild(this.$slots.default);\n var componentOptions = vnode && vnode.componentOptions;\n if (componentOptions) {\n // check pattern\n var name = getComponentName(componentOptions);\n if (name && (\n (this.include && !matches(this.include, name)) ||\n (this.exclude && matches(this.exclude, name))\n )) {\n return vnode\n }\n var key = vnode.key == null\n // same constructor may get registered as different local components\n // so cid alone is not enough (#3269)\n ? componentOptions.Ctor.cid + (componentOptions.tag ? (\"::\" + (componentOptions.tag)) : '')\n : vnode.key;\n if (this.cache[key]) {\n vnode.componentInstance = this.cache[key].componentInstance;\n } else {\n this.cache[key] = vnode;\n }\n vnode.data.keepAlive = true;\n }\n return vnode\n }\n};\n\nvar builtInComponents = {\n KeepAlive: KeepAlive\n};\n\n/* */\n\nfunction initGlobalAPI (Vue) {\n // config\n var configDef = {};\n configDef.get = function () { return config; };\n if (false) {\n configDef.set = function () {\n warn(\n 'Do not replace the Vue.config object, set individual fields instead.'\n );\n };\n }\n Object.defineProperty(Vue, 'config', configDef);\n Vue.util = util;\n Vue.set = set$1;\n Vue.delete = del;\n Vue.nextTick = nextTick;\n\n Vue.options = Object.create(null);\n config._assetTypes.forEach(function (type) {\n Vue.options[type + 's'] = Object.create(null);\n });\n\n // this is used to identify the \"base\" constructor to extend all plain-object\n // components with in Weex's multi-instance scenarios.\n Vue.options._base = Vue;\n\n extend(Vue.options.components, builtInComponents);\n\n initUse(Vue);\n initMixin$1(Vue);\n initExtend(Vue);\n initAssetRegisters(Vue);\n}\n\ninitGlobalAPI(Vue$3);\n\nObject.defineProperty(Vue$3.prototype, '$isServer', {\n get: isServerRendering\n});\n\nVue$3.version = '2.1.10';\n\n/* */\n\n// attributes that should be using props for binding\nvar acceptValue = makeMap('input,textarea,option,select');\nvar mustUseProp = function (tag, type, attr) {\n return (\n (attr === 'value' && acceptValue(tag)) && type !== 'button' ||\n (attr === 'selected' && tag === 'option') ||\n (attr === 'checked' && tag === 'input') ||\n (attr === 'muted' && tag === 'video')\n )\n};\n\nvar isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');\n\nvar isBooleanAttr = makeMap(\n 'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +\n 'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +\n 'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +\n 'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +\n 'required,reversed,scoped,seamless,selected,sortable,translate,' +\n 'truespeed,typemustmatch,visible'\n);\n\nvar xlinkNS = 'http://www.w3.org/1999/xlink';\n\nvar isXlink = function (name) {\n return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'\n};\n\nvar getXlinkProp = function (name) {\n return isXlink(name) ? name.slice(6, name.length) : ''\n};\n\nvar isFalsyAttrValue = function (val) {\n return val == null || val === false\n};\n\n/* */\n\nfunction genClassForVnode (vnode) {\n var data = vnode.data;\n var parentNode = vnode;\n var childNode = vnode;\n while (childNode.componentInstance) {\n childNode = childNode.componentInstance._vnode;\n if (childNode.data) {\n data = mergeClassData(childNode.data, data);\n }\n }\n while ((parentNode = parentNode.parent)) {\n if (parentNode.data) {\n data = mergeClassData(data, parentNode.data);\n }\n }\n return genClassFromData(data)\n}\n\nfunction mergeClassData (child, parent) {\n return {\n staticClass: concat(child.staticClass, parent.staticClass),\n class: child.class\n ? [child.class, parent.class]\n : parent.class\n }\n}\n\nfunction genClassFromData (data) {\n var dynamicClass = data.class;\n var staticClass = data.staticClass;\n if (staticClass || dynamicClass) {\n return concat(staticClass, stringifyClass(dynamicClass))\n }\n /* istanbul ignore next */\n return ''\n}\n\nfunction concat (a, b) {\n return a ? b ? (a + ' ' + b) : a : (b || '')\n}\n\nfunction stringifyClass (value) {\n var res = '';\n if (!value) {\n return res\n }\n if (typeof value === 'string') {\n return value\n }\n if (Array.isArray(value)) {\n var stringified;\n for (var i = 0, l = value.length; i < l; i++) {\n if (value[i]) {\n if ((stringified = stringifyClass(value[i]))) {\n res += stringified + ' ';\n }\n }\n }\n return res.slice(0, -1)\n }\n if (isObject(value)) {\n for (var key in value) {\n if (value[key]) { res += key + ' '; }\n }\n return res.slice(0, -1)\n }\n /* istanbul ignore next */\n return res\n}\n\n/* */\n\nvar namespaceMap = {\n svg: 'http://www.w3.org/2000/svg',\n math: 'http://www.w3.org/1998/Math/MathML'\n};\n\nvar isHTMLTag = makeMap(\n 'html,body,base,head,link,meta,style,title,' +\n 'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +\n 'div,dd,dl,dt,figcaption,figure,hr,img,li,main,ol,p,pre,ul,' +\n 'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +\n 's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +\n 'embed,object,param,source,canvas,script,noscript,del,ins,' +\n 'caption,col,colgroup,table,thead,tbody,td,th,tr,' +\n 'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +\n 'output,progress,select,textarea,' +\n 'details,dialog,menu,menuitem,summary,' +\n 'content,element,shadow,template'\n);\n\n// this map is intentionally selective, only covering SVG elements that may\n// contain child elements.\nvar isSVG = makeMap(\n 'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,' +\n 'font-face,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +\n 'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',\n true\n);\n\nvar isPreTag = function (tag) { return tag === 'pre'; };\n\nvar isReservedTag = function (tag) {\n return isHTMLTag(tag) || isSVG(tag)\n};\n\nfunction getTagNamespace (tag) {\n if (isSVG(tag)) {\n return 'svg'\n }\n // basic support for MathML\n // note it doesn't support other MathML elements being component roots\n if (tag === 'math') {\n return 'math'\n }\n}\n\nvar unknownElementCache = Object.create(null);\nfunction isUnknownElement (tag) {\n /* istanbul ignore if */\n if (!inBrowser) {\n return true\n }\n if (isReservedTag(tag)) {\n return false\n }\n tag = tag.toLowerCase();\n /* istanbul ignore if */\n if (unknownElementCache[tag] != null) {\n return unknownElementCache[tag]\n }\n var el = document.createElement(tag);\n if (tag.indexOf('-') > -1) {\n // http://stackoverflow.com/a/28210364/1070244\n return (unknownElementCache[tag] = (\n el.constructor === window.HTMLUnknownElement ||\n el.constructor === window.HTMLElement\n ))\n } else {\n return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))\n }\n}\n\n/* */\n\n/**\n * Query an element selector if it's not an element already.\n */\nfunction query (el) {\n if (typeof el === 'string') {\n var selector = el;\n el = document.querySelector(el);\n if (!el) {\n \"production\" !== 'production' && warn(\n 'Cannot find element: ' + selector\n );\n return document.createElement('div')\n }\n }\n return el\n}\n\n/* */\n\nfunction createElement$1 (tagName, vnode) {\n var elm = document.createElement(tagName);\n if (tagName !== 'select') {\n return elm\n }\n if (vnode.data && vnode.data.attrs && 'multiple' in vnode.data.attrs) {\n elm.setAttribute('multiple', 'multiple');\n }\n return elm\n}\n\nfunction createElementNS (namespace, tagName) {\n return document.createElementNS(namespaceMap[namespace], tagName)\n}\n\nfunction createTextNode (text) {\n return document.createTextNode(text)\n}\n\nfunction createComment (text) {\n return document.createComment(text)\n}\n\nfunction insertBefore (parentNode, newNode, referenceNode) {\n parentNode.insertBefore(newNode, referenceNode);\n}\n\nfunction removeChild (node, child) {\n node.removeChild(child);\n}\n\nfunction appendChild (node, child) {\n node.appendChild(child);\n}\n\nfunction parentNode (node) {\n return node.parentNode\n}\n\nfunction nextSibling (node) {\n return node.nextSibling\n}\n\nfunction tagName (node) {\n return node.tagName\n}\n\nfunction setTextContent (node, text) {\n node.textContent = text;\n}\n\nfunction setAttribute (node, key, val) {\n node.setAttribute(key, val);\n}\n\n\nvar nodeOps = Object.freeze({\n\tcreateElement: createElement$1,\n\tcreateElementNS: createElementNS,\n\tcreateTextNode: createTextNode,\n\tcreateComment: createComment,\n\tinsertBefore: insertBefore,\n\tremoveChild: removeChild,\n\tappendChild: appendChild,\n\tparentNode: parentNode,\n\tnextSibling: nextSibling,\n\ttagName: tagName,\n\tsetTextContent: setTextContent,\n\tsetAttribute: setAttribute\n});\n\n/* */\n\nvar ref = {\n create: function create (_, vnode) {\n registerRef(vnode);\n },\n update: function update (oldVnode, vnode) {\n if (oldVnode.data.ref !== vnode.data.ref) {\n registerRef(oldVnode, true);\n registerRef(vnode);\n }\n },\n destroy: function destroy (vnode) {\n registerRef(vnode, true);\n }\n};\n\nfunction registerRef (vnode, isRemoval) {\n var key = vnode.data.ref;\n if (!key) { return }\n\n var vm = vnode.context;\n var ref = vnode.componentInstance || vnode.elm;\n var refs = vm.$refs;\n if (isRemoval) {\n if (Array.isArray(refs[key])) {\n remove$1(refs[key], ref);\n } else if (refs[key] === ref) {\n refs[key] = undefined;\n }\n } else {\n if (vnode.data.refInFor) {\n if (Array.isArray(refs[key]) && refs[key].indexOf(ref) < 0) {\n refs[key].push(ref);\n } else {\n refs[key] = [ref];\n }\n } else {\n refs[key] = ref;\n }\n }\n}\n\n/**\n * Virtual DOM patching algorithm based on Snabbdom by\n * Simon Friis Vindum (@paldepind)\n * Licensed under the MIT License\n * https://github.com/paldepind/snabbdom/blob/master/LICENSE\n *\n * modified by Evan You (@yyx990803)\n *\n\n/*\n * Not type-checking this because this file is perf-critical and the cost\n * of making flow understand it is not worth it.\n */\n\nvar emptyNode = new VNode('', {}, []);\n\nvar hooks$1 = ['create', 'activate', 'update', 'remove', 'destroy'];\n\nfunction isUndef (s) {\n return s == null\n}\n\nfunction isDef (s) {\n return s != null\n}\n\nfunction sameVnode (vnode1, vnode2) {\n return (\n vnode1.key === vnode2.key &&\n vnode1.tag === vnode2.tag &&\n vnode1.isComment === vnode2.isComment &&\n !vnode1.data === !vnode2.data\n )\n}\n\nfunction createKeyToOldIdx (children, beginIdx, endIdx) {\n var i, key;\n var map = {};\n for (i = beginIdx; i <= endIdx; ++i) {\n key = children[i].key;\n if (isDef(key)) { map[key] = i; }\n }\n return map\n}\n\nfunction createPatchFunction (backend) {\n var i, j;\n var cbs = {};\n\n var modules = backend.modules;\n var nodeOps = backend.nodeOps;\n\n for (i = 0; i < hooks$1.length; ++i) {\n cbs[hooks$1[i]] = [];\n for (j = 0; j < modules.length; ++j) {\n if (modules[j][hooks$1[i]] !== undefined) { cbs[hooks$1[i]].push(modules[j][hooks$1[i]]); }\n }\n }\n\n function emptyNodeAt (elm) {\n return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)\n }\n\n function createRmCb (childElm, listeners) {\n function remove$$1 () {\n if (--remove$$1.listeners === 0) {\n removeNode(childElm);\n }\n }\n remove$$1.listeners = listeners;\n return remove$$1\n }\n\n function removeNode (el) {\n var parent = nodeOps.parentNode(el);\n // element may have already been removed due to v-html / v-text\n if (parent) {\n nodeOps.removeChild(parent, el);\n }\n }\n\n var inPre = 0;\n function createElm (vnode, insertedVnodeQueue, parentElm, refElm, nested) {\n vnode.isRootInsert = !nested; // for transition enter check\n if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {\n return\n }\n\n var data = vnode.data;\n var children = vnode.children;\n var tag = vnode.tag;\n if (isDef(tag)) {\n if (false) {\n if (data && data.pre) {\n inPre++;\n }\n if (\n !inPre &&\n !vnode.ns &&\n !(config.ignoredElements.length && config.ignoredElements.indexOf(tag) > -1) &&\n config.isUnknownElement(tag)\n ) {\n warn(\n 'Unknown custom element: <' + tag + '> - did you ' +\n 'register the component correctly? For recursive components, ' +\n 'make sure to provide the \"name\" option.',\n vnode.context\n );\n }\n }\n vnode.elm = vnode.ns\n ? nodeOps.createElementNS(vnode.ns, tag)\n : nodeOps.createElement(tag, vnode);\n setScope(vnode);\n\n /* istanbul ignore if */\n {\n createChildren(vnode, children, insertedVnodeQueue);\n if (isDef(data)) {\n invokeCreateHooks(vnode, insertedVnodeQueue);\n }\n insert(parentElm, vnode.elm, refElm);\n }\n\n if (false) {\n inPre--;\n }\n } else if (vnode.isComment) {\n vnode.elm = nodeOps.createComment(vnode.text);\n insert(parentElm, vnode.elm, refElm);\n } else {\n vnode.elm = nodeOps.createTextNode(vnode.text);\n insert(parentElm, vnode.elm, refElm);\n }\n }\n\n function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {\n var i = vnode.data;\n if (isDef(i)) {\n var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;\n if (isDef(i = i.hook) && isDef(i = i.init)) {\n i(vnode, false /* hydrating */, parentElm, refElm);\n }\n // after calling the init hook, if the vnode is a child component\n // it should've created a child instance and mounted it. the child\n // component also has set the placeholder vnode's elm.\n // in that case we can just return the element and be done.\n if (isDef(vnode.componentInstance)) {\n initComponent(vnode, insertedVnodeQueue);\n if (isReactivated) {\n reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);\n }\n return true\n }\n }\n }\n\n function initComponent (vnode, insertedVnodeQueue) {\n if (vnode.data.pendingInsert) {\n insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);\n }\n vnode.elm = vnode.componentInstance.$el;\n if (isPatchable(vnode)) {\n invokeCreateHooks(vnode, insertedVnodeQueue);\n setScope(vnode);\n } else {\n // empty component root.\n // skip all element-related modules except for ref (#3455)\n registerRef(vnode);\n // make sure to invoke the insert hook\n insertedVnodeQueue.push(vnode);\n }\n }\n\n function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {\n var i;\n // hack for #4339: a reactivated component with inner transition\n // does not trigger because the inner node's created hooks are not called\n // again. It's not ideal to involve module-specific logic in here but\n // there doesn't seem to be a better way to do it.\n var innerNode = vnode;\n while (innerNode.componentInstance) {\n innerNode = innerNode.componentInstance._vnode;\n if (isDef(i = innerNode.data) && isDef(i = i.transition)) {\n for (i = 0; i < cbs.activate.length; ++i) {\n cbs.activate[i](emptyNode, innerNode);\n }\n insertedVnodeQueue.push(innerNode);\n break\n }\n }\n // unlike a newly created component,\n // a reactivated keep-alive component doesn't insert itself\n insert(parentElm, vnode.elm, refElm);\n }\n\n function insert (parent, elm, ref) {\n if (parent) {\n if (ref) {\n nodeOps.insertBefore(parent, elm, ref);\n } else {\n nodeOps.appendChild(parent, elm);\n }\n }\n }\n\n function createChildren (vnode, children, insertedVnodeQueue) {\n if (Array.isArray(children)) {\n for (var i = 0; i < children.length; ++i) {\n createElm(children[i], insertedVnodeQueue, vnode.elm, null, true);\n }\n } else if (isPrimitive(vnode.text)) {\n nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(vnode.text));\n }\n }\n\n function isPatchable (vnode) {\n while (vnode.componentInstance) {\n vnode = vnode.componentInstance._vnode;\n }\n return isDef(vnode.tag)\n }\n\n function invokeCreateHooks (vnode, insertedVnodeQueue) {\n for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {\n cbs.create[i$1](emptyNode, vnode);\n }\n i = vnode.data.hook; // Reuse variable\n if (isDef(i)) {\n if (i.create) { i.create(emptyNode, vnode); }\n if (i.insert) { insertedVnodeQueue.push(vnode); }\n }\n }\n\n // set scope id attribute for scoped CSS.\n // this is implemented as a special case to avoid the overhead\n // of going through the normal attribute patching process.\n function setScope (vnode) {\n var i;\n if (isDef(i = vnode.context) && isDef(i = i.$options._scopeId)) {\n nodeOps.setAttribute(vnode.elm, i, '');\n }\n if (isDef(i = activeInstance) &&\n i !== vnode.context &&\n isDef(i = i.$options._scopeId)) {\n nodeOps.setAttribute(vnode.elm, i, '');\n }\n }\n\n function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {\n for (; startIdx <= endIdx; ++startIdx) {\n createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm);\n }\n }\n\n function invokeDestroyHook (vnode) {\n var i, j;\n var data = vnode.data;\n if (isDef(data)) {\n if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }\n for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); }\n }\n if (isDef(i = vnode.children)) {\n for (j = 0; j < vnode.children.length; ++j) {\n invokeDestroyHook(vnode.children[j]);\n }\n }\n }\n\n function removeVnodes (parentElm, vnodes, startIdx, endIdx) {\n for (; startIdx <= endIdx; ++startIdx) {\n var ch = vnodes[startIdx];\n if (isDef(ch)) {\n if (isDef(ch.tag)) {\n removeAndInvokeRemoveHook(ch);\n invokeDestroyHook(ch);\n } else { // Text node\n removeNode(ch.elm);\n }\n }\n }\n }\n\n function removeAndInvokeRemoveHook (vnode, rm) {\n if (rm || isDef(vnode.data)) {\n var listeners = cbs.remove.length + 1;\n if (!rm) {\n // directly removing\n rm = createRmCb(vnode.elm, listeners);\n } else {\n // we have a recursively passed down rm callback\n // increase the listeners count\n rm.listeners += listeners;\n }\n // recursively invoke hooks on child component root node\n if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {\n removeAndInvokeRemoveHook(i, rm);\n }\n for (i = 0; i < cbs.remove.length; ++i) {\n cbs.remove[i](vnode, rm);\n }\n if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {\n i(vnode, rm);\n } else {\n rm();\n }\n } else {\n removeNode(vnode.elm);\n }\n }\n\n function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {\n var oldStartIdx = 0;\n var newStartIdx = 0;\n var oldEndIdx = oldCh.length - 1;\n var oldStartVnode = oldCh[0];\n var oldEndVnode = oldCh[oldEndIdx];\n var newEndIdx = newCh.length - 1;\n var newStartVnode = newCh[0];\n var newEndVnode = newCh[newEndIdx];\n var oldKeyToIdx, idxInOld, elmToMove, refElm;\n\n // removeOnly is a special flag used only by <transition-group>\n // to ensure removed elements stay in correct relative positions\n // during leaving transitions\n var canMove = !removeOnly;\n\n while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n if (isUndef(oldStartVnode)) {\n oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n } else if (isUndef(oldEndVnode)) {\n oldEndVnode = oldCh[--oldEndIdx];\n } else if (sameVnode(oldStartVnode, newStartVnode)) {\n patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);\n oldStartVnode = oldCh[++oldStartIdx];\n newStartVnode = newCh[++newStartIdx];\n } else if (sameVnode(oldEndVnode, newEndVnode)) {\n patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);\n oldEndVnode = oldCh[--oldEndIdx];\n newEndVnode = newCh[--newEndIdx];\n } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);\n canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));\n oldStartVnode = oldCh[++oldStartIdx];\n newEndVnode = newCh[--newEndIdx];\n } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);\n canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);\n oldEndVnode = oldCh[--oldEndIdx];\n newStartVnode = newCh[++newStartIdx];\n } else {\n if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }\n idxInOld = isDef(newStartVnode.key) ? oldKeyToIdx[newStartVnode.key] : null;\n if (isUndef(idxInOld)) { // New element\n createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);\n newStartVnode = newCh[++newStartIdx];\n } else {\n elmToMove = oldCh[idxInOld];\n /* istanbul ignore if */\n if (false) {\n warn(\n 'It seems there are duplicate keys that is causing an update error. ' +\n 'Make sure each v-for item has a unique key.'\n );\n }\n if (sameVnode(elmToMove, newStartVnode)) {\n patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);\n oldCh[idxInOld] = undefined;\n canMove && nodeOps.insertBefore(parentElm, newStartVnode.elm, oldStartVnode.elm);\n newStartVnode = newCh[++newStartIdx];\n } else {\n // same key but different element. treat as new element\n createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);\n newStartVnode = newCh[++newStartIdx];\n }\n }\n }\n }\n if (oldStartIdx > oldEndIdx) {\n refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;\n addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);\n } else if (newStartIdx > newEndIdx) {\n removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n }\n }\n\n function patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly) {\n if (oldVnode === vnode) {\n return\n }\n // reuse element for static trees.\n // note we only do this if the vnode is cloned -\n // if the new node is not cloned it means the render functions have been\n // reset by the hot-reload-api and we need to do a proper re-render.\n if (vnode.isStatic &&\n oldVnode.isStatic &&\n vnode.key === oldVnode.key &&\n (vnode.isCloned || vnode.isOnce)) {\n vnode.elm = oldVnode.elm;\n vnode.componentInstance = oldVnode.componentInstance;\n return\n }\n var i;\n var data = vnode.data;\n var hasData = isDef(data);\n if (hasData && isDef(i = data.hook) && isDef(i = i.prepatch)) {\n i(oldVnode, vnode);\n }\n var elm = vnode.elm = oldVnode.elm;\n var oldCh = oldVnode.children;\n var ch = vnode.children;\n if (hasData && isPatchable(vnode)) {\n for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); }\n if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }\n }\n if (isUndef(vnode.text)) {\n if (isDef(oldCh) && isDef(ch)) {\n if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }\n } else if (isDef(ch)) {\n if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }\n addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);\n } else if (isDef(oldCh)) {\n removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n } else if (isDef(oldVnode.text)) {\n nodeOps.setTextContent(elm, '');\n }\n } else if (oldVnode.text !== vnode.text) {\n nodeOps.setTextContent(elm, vnode.text);\n }\n if (hasData) {\n if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); }\n }\n }\n\n function invokeInsertHook (vnode, queue, initial) {\n // delay insert hooks for component root nodes, invoke them after the\n // element is really inserted\n if (initial && vnode.parent) {\n vnode.parent.data.pendingInsert = queue;\n } else {\n for (var i = 0; i < queue.length; ++i) {\n queue[i].data.hook.insert(queue[i]);\n }\n }\n }\n\n var bailed = false;\n // list of modules that can skip create hook during hydration because they\n // are already rendered on the client or has no need for initialization\n var isRenderedModule = makeMap('attrs,style,class,staticClass,staticStyle,key');\n\n // Note: this is a browser-only function so we can assume elms are DOM nodes.\n function hydrate (elm, vnode, insertedVnodeQueue) {\n if (false) {\n if (!assertNodeMatch(elm, vnode)) {\n return false\n }\n }\n vnode.elm = elm;\n var tag = vnode.tag;\n var data = vnode.data;\n var children = vnode.children;\n if (isDef(data)) {\n if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }\n if (isDef(i = vnode.componentInstance)) {\n // child component. it should have hydrated its own tree.\n initComponent(vnode, insertedVnodeQueue);\n return true\n }\n }\n if (isDef(tag)) {\n if (isDef(children)) {\n // empty element, allow client to pick up and populate children\n if (!elm.hasChildNodes()) {\n createChildren(vnode, children, insertedVnodeQueue);\n } else {\n var childrenMatch = true;\n var childNode = elm.firstChild;\n for (var i$1 = 0; i$1 < children.length; i$1++) {\n if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue)) {\n childrenMatch = false;\n break\n }\n childNode = childNode.nextSibling;\n }\n // if childNode is not null, it means the actual childNodes list is\n // longer than the virtual children list.\n if (!childrenMatch || childNode) {\n if (false) {\n bailed = true;\n console.warn('Parent: ', elm);\n console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);\n }\n return false\n }\n }\n }\n if (isDef(data)) {\n for (var key in data) {\n if (!isRenderedModule(key)) {\n invokeCreateHooks(vnode, insertedVnodeQueue);\n break\n }\n }\n }\n } else if (elm.data !== vnode.text) {\n elm.data = vnode.text;\n }\n return true\n }\n\n function assertNodeMatch (node, vnode) {\n if (vnode.tag) {\n return (\n vnode.tag.indexOf('vue-component') === 0 ||\n vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())\n )\n } else {\n return node.nodeType === (vnode.isComment ? 8 : 3)\n }\n }\n\n return function patch (oldVnode, vnode, hydrating, removeOnly, parentElm, refElm) {\n if (!vnode) {\n if (oldVnode) { invokeDestroyHook(oldVnode); }\n return\n }\n\n var isInitialPatch = false;\n var insertedVnodeQueue = [];\n\n if (!oldVnode) {\n // empty mount (likely as component), create new root element\n isInitialPatch = true;\n createElm(vnode, insertedVnodeQueue, parentElm, refElm);\n } else {\n var isRealElement = isDef(oldVnode.nodeType);\n if (!isRealElement && sameVnode(oldVnode, vnode)) {\n // patch existing root node\n patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly);\n } else {\n if (isRealElement) {\n // mounting to a real element\n // check if this is server-rendered content and if we can perform\n // a successful hydration.\n if (oldVnode.nodeType === 1 && oldVnode.hasAttribute('server-rendered')) {\n oldVnode.removeAttribute('server-rendered');\n hydrating = true;\n }\n if (hydrating) {\n if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {\n invokeInsertHook(vnode, insertedVnodeQueue, true);\n return oldVnode\n } else if (false) {\n warn(\n 'The client-side rendered virtual DOM tree is not matching ' +\n 'server-rendered content. This is likely caused by incorrect ' +\n 'HTML markup, for example nesting block-level elements inside ' +\n '<p>, or missing <tbody>. Bailing hydration and performing ' +\n 'full client-side render.'\n );\n }\n }\n // either not server-rendered, or hydration failed.\n // create an empty node and replace it\n oldVnode = emptyNodeAt(oldVnode);\n }\n // replacing existing element\n var oldElm = oldVnode.elm;\n var parentElm$1 = nodeOps.parentNode(oldElm);\n createElm(\n vnode,\n insertedVnodeQueue,\n // extremely rare edge case: do not insert if old element is in a\n // leaving transition. Only happens when combining transition +\n // keep-alive + HOCs. (#4590)\n oldElm._leaveCb ? null : parentElm$1,\n nodeOps.nextSibling(oldElm)\n );\n\n if (vnode.parent) {\n // component root element replaced.\n // update parent placeholder node element, recursively\n var ancestor = vnode.parent;\n while (ancestor) {\n ancestor.elm = vnode.elm;\n ancestor = ancestor.parent;\n }\n if (isPatchable(vnode)) {\n for (var i = 0; i < cbs.create.length; ++i) {\n cbs.create[i](emptyNode, vnode.parent);\n }\n }\n }\n\n if (parentElm$1 !== null) {\n removeVnodes(parentElm$1, [oldVnode], 0, 0);\n } else if (isDef(oldVnode.tag)) {\n invokeDestroyHook(oldVnode);\n }\n }\n }\n\n invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);\n return vnode.elm\n }\n}\n\n/* */\n\nvar directives = {\n create: updateDirectives,\n update: updateDirectives,\n destroy: function unbindDirectives (vnode) {\n updateDirectives(vnode, emptyNode);\n }\n};\n\nfunction updateDirectives (oldVnode, vnode) {\n if (oldVnode.data.directives || vnode.data.directives) {\n _update(oldVnode, vnode);\n }\n}\n\nfunction _update (oldVnode, vnode) {\n var isCreate = oldVnode === emptyNode;\n var isDestroy = vnode === emptyNode;\n var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);\n var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);\n\n var dirsWithInsert = [];\n var dirsWithPostpatch = [];\n\n var key, oldDir, dir;\n for (key in newDirs) {\n oldDir = oldDirs[key];\n dir = newDirs[key];\n if (!oldDir) {\n // new directive, bind\n callHook$1(dir, 'bind', vnode, oldVnode);\n if (dir.def && dir.def.inserted) {\n dirsWithInsert.push(dir);\n }\n } else {\n // existing directive, update\n dir.oldValue = oldDir.value;\n callHook$1(dir, 'update', vnode, oldVnode);\n if (dir.def && dir.def.componentUpdated) {\n dirsWithPostpatch.push(dir);\n }\n }\n }\n\n if (dirsWithInsert.length) {\n var callInsert = function () {\n for (var i = 0; i < dirsWithInsert.length; i++) {\n callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);\n }\n };\n if (isCreate) {\n mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', callInsert, 'dir-insert');\n } else {\n callInsert();\n }\n }\n\n if (dirsWithPostpatch.length) {\n mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'postpatch', function () {\n for (var i = 0; i < dirsWithPostpatch.length; i++) {\n callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);\n }\n }, 'dir-postpatch');\n }\n\n if (!isCreate) {\n for (key in oldDirs) {\n if (!newDirs[key]) {\n // no longer present, unbind\n callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);\n }\n }\n }\n}\n\nvar emptyModifiers = Object.create(null);\n\nfunction normalizeDirectives$1 (\n dirs,\n vm\n) {\n var res = Object.create(null);\n if (!dirs) {\n return res\n }\n var i, dir;\n for (i = 0; i < dirs.length; i++) {\n dir = dirs[i];\n if (!dir.modifiers) {\n dir.modifiers = emptyModifiers;\n }\n res[getRawDirName(dir)] = dir;\n dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);\n }\n return res\n}\n\nfunction getRawDirName (dir) {\n return dir.rawName || ((dir.name) + \".\" + (Object.keys(dir.modifiers || {}).join('.')))\n}\n\nfunction callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {\n var fn = dir.def && dir.def[hook];\n if (fn) {\n fn(vnode.elm, dir, vnode, oldVnode, isDestroy);\n }\n}\n\nvar baseModules = [\n ref,\n directives\n];\n\n/* */\n\nfunction updateAttrs (oldVnode, vnode) {\n if (!oldVnode.data.attrs && !vnode.data.attrs) {\n return\n }\n var key, cur, old;\n var elm = vnode.elm;\n var oldAttrs = oldVnode.data.attrs || {};\n var attrs = vnode.data.attrs || {};\n // clone observed objects, as the user probably wants to mutate it\n if (attrs.__ob__) {\n attrs = vnode.data.attrs = extend({}, attrs);\n }\n\n for (key in attrs) {\n cur = attrs[key];\n old = oldAttrs[key];\n if (old !== cur) {\n setAttr(elm, key, cur);\n }\n }\n // #4391: in IE9, setting type can reset value for input[type=radio]\n /* istanbul ignore if */\n if (isIE9 && attrs.value !== oldAttrs.value) {\n setAttr(elm, 'value', attrs.value);\n }\n for (key in oldAttrs) {\n if (attrs[key] == null) {\n if (isXlink(key)) {\n elm.removeAttributeNS(xlinkNS, getXlinkProp(key));\n } else if (!isEnumeratedAttr(key)) {\n elm.removeAttribute(key);\n }\n }\n }\n}\n\nfunction setAttr (el, key, value) {\n if (isBooleanAttr(key)) {\n // set attribute for blank value\n // e.g. <option disabled>Select one</option>\n if (isFalsyAttrValue(value)) {\n el.removeAttribute(key);\n } else {\n el.setAttribute(key, key);\n }\n } else if (isEnumeratedAttr(key)) {\n el.setAttribute(key, isFalsyAttrValue(value) || value === 'false' ? 'false' : 'true');\n } else if (isXlink(key)) {\n if (isFalsyAttrValue(value)) {\n el.removeAttributeNS(xlinkNS, getXlinkProp(key));\n } else {\n el.setAttributeNS(xlinkNS, key, value);\n }\n } else {\n if (isFalsyAttrValue(value)) {\n el.removeAttribute(key);\n } else {\n el.setAttribute(key, value);\n }\n }\n}\n\nvar attrs = {\n create: updateAttrs,\n update: updateAttrs\n};\n\n/* */\n\nfunction updateClass (oldVnode, vnode) {\n var el = vnode.elm;\n var data = vnode.data;\n var oldData = oldVnode.data;\n if (!data.staticClass && !data.class &&\n (!oldData || (!oldData.staticClass && !oldData.class))) {\n return\n }\n\n var cls = genClassForVnode(vnode);\n\n // handle transition classes\n var transitionClass = el._transitionClasses;\n if (transitionClass) {\n cls = concat(cls, stringifyClass(transitionClass));\n }\n\n // set the class\n if (cls !== el._prevClass) {\n el.setAttribute('class', cls);\n el._prevClass = cls;\n }\n}\n\nvar klass = {\n create: updateClass,\n update: updateClass\n};\n\n/* */\n\nvar target$1;\n\nfunction add$2 (\n event,\n handler,\n once,\n capture\n) {\n if (once) {\n var oldHandler = handler;\n var _target = target$1; // save current target element in closure\n handler = function (ev) {\n remove$3(event, handler, capture, _target);\n arguments.length === 1\n ? oldHandler(ev)\n : oldHandler.apply(null, arguments);\n };\n }\n target$1.addEventListener(event, handler, capture);\n}\n\nfunction remove$3 (\n event,\n handler,\n capture,\n _target\n) {\n (_target || target$1).removeEventListener(event, handler, capture);\n}\n\nfunction updateDOMListeners (oldVnode, vnode) {\n if (!oldVnode.data.on && !vnode.data.on) {\n return\n }\n var on = vnode.data.on || {};\n var oldOn = oldVnode.data.on || {};\n target$1 = vnode.elm;\n updateListeners(on, oldOn, add$2, remove$3, vnode.context);\n}\n\nvar events = {\n create: updateDOMListeners,\n update: updateDOMListeners\n};\n\n/* */\n\nfunction updateDOMProps (oldVnode, vnode) {\n if (!oldVnode.data.domProps && !vnode.data.domProps) {\n return\n }\n var key, cur;\n var elm = vnode.elm;\n var oldProps = oldVnode.data.domProps || {};\n var props = vnode.data.domProps || {};\n // clone observed objects, as the user probably wants to mutate it\n if (props.__ob__) {\n props = vnode.data.domProps = extend({}, props);\n }\n\n for (key in oldProps) {\n if (props[key] == null) {\n elm[key] = '';\n }\n }\n for (key in props) {\n cur = props[key];\n // ignore children if the node has textContent or innerHTML,\n // as these will throw away existing DOM nodes and cause removal errors\n // on subsequent patches (#3360)\n if (key === 'textContent' || key === 'innerHTML') {\n if (vnode.children) { vnode.children.length = 0; }\n if (cur === oldProps[key]) { continue }\n }\n\n if (key === 'value') {\n // store value as _value as well since\n // non-string values will be stringified\n elm._value = cur;\n // avoid resetting cursor position when value is the same\n var strCur = cur == null ? '' : String(cur);\n if (shouldUpdateValue(elm, vnode, strCur)) {\n elm.value = strCur;\n }\n } else {\n elm[key] = cur;\n }\n }\n}\n\n// check platforms/web/util/attrs.js acceptValue\n\n\nfunction shouldUpdateValue (\n elm,\n vnode,\n checkVal\n) {\n return (!elm.composing && (\n vnode.tag === 'option' ||\n isDirty(elm, checkVal) ||\n isInputChanged(vnode, checkVal)\n ))\n}\n\nfunction isDirty (elm, checkVal) {\n // return true when textbox (.number and .trim) loses focus and its value is not equal to the updated value\n return document.activeElement !== elm && elm.value !== checkVal\n}\n\nfunction isInputChanged (vnode, newVal) {\n var value = vnode.elm.value;\n var modifiers = vnode.elm._vModifiers; // injected by v-model runtime\n if ((modifiers && modifiers.number) || vnode.elm.type === 'number') {\n return toNumber(value) !== toNumber(newVal)\n }\n if (modifiers && modifiers.trim) {\n return value.trim() !== newVal.trim()\n }\n return value !== newVal\n}\n\nvar domProps = {\n create: updateDOMProps,\n update: updateDOMProps\n};\n\n/* */\n\nvar parseStyleText = cached(function (cssText) {\n var res = {};\n var listDelimiter = /;(?![^(]*\\))/g;\n var propertyDelimiter = /:(.+)/;\n cssText.split(listDelimiter).forEach(function (item) {\n if (item) {\n var tmp = item.split(propertyDelimiter);\n tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());\n }\n });\n return res\n});\n\n// merge static and dynamic style data on the same vnode\nfunction normalizeStyleData (data) {\n var style = normalizeStyleBinding(data.style);\n // static style is pre-processed into an object during compilation\n // and is always a fresh object, so it's safe to merge into it\n return data.staticStyle\n ? extend(data.staticStyle, style)\n : style\n}\n\n// normalize possible array / string values into Object\nfunction normalizeStyleBinding (bindingStyle) {\n if (Array.isArray(bindingStyle)) {\n return toObject(bindingStyle)\n }\n if (typeof bindingStyle === 'string') {\n return parseStyleText(bindingStyle)\n }\n return bindingStyle\n}\n\n/**\n * parent component style should be after child's\n * so that parent component's style could override it\n */\nfunction getStyle (vnode, checkChild) {\n var res = {};\n var styleData;\n\n if (checkChild) {\n var childNode = vnode;\n while (childNode.componentInstance) {\n childNode = childNode.componentInstance._vnode;\n if (childNode.data && (styleData = normalizeStyleData(childNode.data))) {\n extend(res, styleData);\n }\n }\n }\n\n if ((styleData = normalizeStyleData(vnode.data))) {\n extend(res, styleData);\n }\n\n var parentNode = vnode;\n while ((parentNode = parentNode.parent)) {\n if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {\n extend(res, styleData);\n }\n }\n return res\n}\n\n/* */\n\nvar cssVarRE = /^--/;\nvar importantRE = /\\s*!important$/;\nvar setProp = function (el, name, val) {\n /* istanbul ignore if */\n if (cssVarRE.test(name)) {\n el.style.setProperty(name, val);\n } else if (importantRE.test(val)) {\n el.style.setProperty(name, val.replace(importantRE, ''), 'important');\n } else {\n el.style[normalize(name)] = val;\n }\n};\n\nvar prefixes = ['Webkit', 'Moz', 'ms'];\n\nvar testEl;\nvar normalize = cached(function (prop) {\n testEl = testEl || document.createElement('div');\n prop = camelize(prop);\n if (prop !== 'filter' && (prop in testEl.style)) {\n return prop\n }\n var upper = prop.charAt(0).toUpperCase() + prop.slice(1);\n for (var i = 0; i < prefixes.length; i++) {\n var prefixed = prefixes[i] + upper;\n if (prefixed in testEl.style) {\n return prefixed\n }\n }\n});\n\nfunction updateStyle (oldVnode, vnode) {\n var data = vnode.data;\n var oldData = oldVnode.data;\n\n if (!data.staticStyle && !data.style &&\n !oldData.staticStyle && !oldData.style) {\n return\n }\n\n var cur, name;\n var el = vnode.elm;\n var oldStaticStyle = oldVnode.data.staticStyle;\n var oldStyleBinding = oldVnode.data.style || {};\n\n // if static style exists, stylebinding already merged into it when doing normalizeStyleData\n var oldStyle = oldStaticStyle || oldStyleBinding;\n\n var style = normalizeStyleBinding(vnode.data.style) || {};\n\n vnode.data.style = style.__ob__ ? extend({}, style) : style;\n\n var newStyle = getStyle(vnode, true);\n\n for (name in oldStyle) {\n if (newStyle[name] == null) {\n setProp(el, name, '');\n }\n }\n for (name in newStyle) {\n cur = newStyle[name];\n if (cur !== oldStyle[name]) {\n // ie9 setting to null has no effect, must use empty string\n setProp(el, name, cur == null ? '' : cur);\n }\n }\n}\n\nvar style = {\n create: updateStyle,\n update: updateStyle\n};\n\n/* */\n\n/**\n * Add class with compatibility for SVG since classList is not supported on\n * SVG elements in IE\n */\nfunction addClass (el, cls) {\n /* istanbul ignore if */\n if (!cls || !cls.trim()) {\n return\n }\n\n /* istanbul ignore else */\n if (el.classList) {\n if (cls.indexOf(' ') > -1) {\n cls.split(/\\s+/).forEach(function (c) { return el.classList.add(c); });\n } else {\n el.classList.add(cls);\n }\n } else {\n var cur = ' ' + el.getAttribute('class') + ' ';\n if (cur.indexOf(' ' + cls + ' ') < 0) {\n el.setAttribute('class', (cur + cls).trim());\n }\n }\n}\n\n/**\n * Remove class with compatibility for SVG since classList is not supported on\n * SVG elements in IE\n */\nfunction removeClass (el, cls) {\n /* istanbul ignore if */\n if (!cls || !cls.trim()) {\n return\n }\n\n /* istanbul ignore else */\n if (el.classList) {\n if (cls.indexOf(' ') > -1) {\n cls.split(/\\s+/).forEach(function (c) { return el.classList.remove(c); });\n } else {\n el.classList.remove(cls);\n }\n } else {\n var cur = ' ' + el.getAttribute('class') + ' ';\n var tar = ' ' + cls + ' ';\n while (cur.indexOf(tar) >= 0) {\n cur = cur.replace(tar, ' ');\n }\n el.setAttribute('class', cur.trim());\n }\n}\n\n/* */\n\nvar hasTransition = inBrowser && !isIE9;\nvar TRANSITION = 'transition';\nvar ANIMATION = 'animation';\n\n// Transition property/event sniffing\nvar transitionProp = 'transition';\nvar transitionEndEvent = 'transitionend';\nvar animationProp = 'animation';\nvar animationEndEvent = 'animationend';\nif (hasTransition) {\n /* istanbul ignore if */\n if (window.ontransitionend === undefined &&\n window.onwebkittransitionend !== undefined) {\n transitionProp = 'WebkitTransition';\n transitionEndEvent = 'webkitTransitionEnd';\n }\n if (window.onanimationend === undefined &&\n window.onwebkitanimationend !== undefined) {\n animationProp = 'WebkitAnimation';\n animationEndEvent = 'webkitAnimationEnd';\n }\n}\n\n// binding to window is necessary to make hot reload work in IE in strict mode\nvar raf = inBrowser && window.requestAnimationFrame\n ? window.requestAnimationFrame.bind(window)\n : setTimeout;\n\nfunction nextFrame (fn) {\n raf(function () {\n raf(fn);\n });\n}\n\nfunction addTransitionClass (el, cls) {\n (el._transitionClasses || (el._transitionClasses = [])).push(cls);\n addClass(el, cls);\n}\n\nfunction removeTransitionClass (el, cls) {\n if (el._transitionClasses) {\n remove$1(el._transitionClasses, cls);\n }\n removeClass(el, cls);\n}\n\nfunction whenTransitionEnds (\n el,\n expectedType,\n cb\n) {\n var ref = getTransitionInfo(el, expectedType);\n var type = ref.type;\n var timeout = ref.timeout;\n var propCount = ref.propCount;\n if (!type) { return cb() }\n var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;\n var ended = 0;\n var end = function () {\n el.removeEventListener(event, onEnd);\n cb();\n };\n var onEnd = function (e) {\n if (e.target === el) {\n if (++ended >= propCount) {\n end();\n }\n }\n };\n setTimeout(function () {\n if (ended < propCount) {\n end();\n }\n }, timeout + 1);\n el.addEventListener(event, onEnd);\n}\n\nvar transformRE = /\\b(transform|all)(,|$)/;\n\nfunction getTransitionInfo (el, expectedType) {\n var styles = window.getComputedStyle(el);\n var transitioneDelays = styles[transitionProp + 'Delay'].split(', ');\n var transitionDurations = styles[transitionProp + 'Duration'].split(', ');\n var transitionTimeout = getTimeout(transitioneDelays, transitionDurations);\n var animationDelays = styles[animationProp + 'Delay'].split(', ');\n var animationDurations = styles[animationProp + 'Duration'].split(', ');\n var animationTimeout = getTimeout(animationDelays, animationDurations);\n\n var type;\n var timeout = 0;\n var propCount = 0;\n /* istanbul ignore if */\n if (expectedType === TRANSITION) {\n if (transitionTimeout > 0) {\n type = TRANSITION;\n timeout = transitionTimeout;\n propCount = transitionDurations.length;\n }\n } else if (expectedType === ANIMATION) {\n if (animationTimeout > 0) {\n type = ANIMATION;\n timeout = animationTimeout;\n propCount = animationDurations.length;\n }\n } else {\n timeout = Math.max(transitionTimeout, animationTimeout);\n type = timeout > 0\n ? transitionTimeout > animationTimeout\n ? TRANSITION\n : ANIMATION\n : null;\n propCount = type\n ? type === TRANSITION\n ? transitionDurations.length\n : animationDurations.length\n : 0;\n }\n var hasTransform =\n type === TRANSITION &&\n transformRE.test(styles[transitionProp + 'Property']);\n return {\n type: type,\n timeout: timeout,\n propCount: propCount,\n hasTransform: hasTransform\n }\n}\n\nfunction getTimeout (delays, durations) {\n /* istanbul ignore next */\n while (delays.length < durations.length) {\n delays = delays.concat(delays);\n }\n\n return Math.max.apply(null, durations.map(function (d, i) {\n return toMs(d) + toMs(delays[i])\n }))\n}\n\nfunction toMs (s) {\n return Number(s.slice(0, -1)) * 1000\n}\n\n/* */\n\nfunction enter (vnode, toggleDisplay) {\n var el = vnode.elm;\n\n // call leave callback now\n if (el._leaveCb) {\n el._leaveCb.cancelled = true;\n el._leaveCb();\n }\n\n var data = resolveTransition(vnode.data.transition);\n if (!data) {\n return\n }\n\n /* istanbul ignore if */\n if (el._enterCb || el.nodeType !== 1) {\n return\n }\n\n var css = data.css;\n var type = data.type;\n var enterClass = data.enterClass;\n var enterToClass = data.enterToClass;\n var enterActiveClass = data.enterActiveClass;\n var appearClass = data.appearClass;\n var appearToClass = data.appearToClass;\n var appearActiveClass = data.appearActiveClass;\n var beforeEnter = data.beforeEnter;\n var enter = data.enter;\n var afterEnter = data.afterEnter;\n var enterCancelled = data.enterCancelled;\n var beforeAppear = data.beforeAppear;\n var appear = data.appear;\n var afterAppear = data.afterAppear;\n var appearCancelled = data.appearCancelled;\n\n // activeInstance will always be the <transition> component managing this\n // transition. One edge case to check is when the <transition> is placed\n // as the root node of a child component. In that case we need to check\n // <transition>'s parent for appear check.\n var context = activeInstance;\n var transitionNode = activeInstance.$vnode;\n while (transitionNode && transitionNode.parent) {\n transitionNode = transitionNode.parent;\n context = transitionNode.context;\n }\n\n var isAppear = !context._isMounted || !vnode.isRootInsert;\n\n if (isAppear && !appear && appear !== '') {\n return\n }\n\n var startClass = isAppear ? appearClass : enterClass;\n var activeClass = isAppear ? appearActiveClass : enterActiveClass;\n var toClass = isAppear ? appearToClass : enterToClass;\n var beforeEnterHook = isAppear ? (beforeAppear || beforeEnter) : beforeEnter;\n var enterHook = isAppear ? (typeof appear === 'function' ? appear : enter) : enter;\n var afterEnterHook = isAppear ? (afterAppear || afterEnter) : afterEnter;\n var enterCancelledHook = isAppear ? (appearCancelled || enterCancelled) : enterCancelled;\n\n var expectsCSS = css !== false && !isIE9;\n var userWantsControl =\n enterHook &&\n // enterHook may be a bound method which exposes\n // the length of original fn as _length\n (enterHook._length || enterHook.length) > 1;\n\n var cb = el._enterCb = once(function () {\n if (expectsCSS) {\n removeTransitionClass(el, toClass);\n removeTransitionClass(el, activeClass);\n }\n if (cb.cancelled) {\n if (expectsCSS) {\n removeTransitionClass(el, startClass);\n }\n enterCancelledHook && enterCancelledHook(el);\n } else {\n afterEnterHook && afterEnterHook(el);\n }\n el._enterCb = null;\n });\n\n if (!vnode.data.show) {\n // remove pending leave element on enter by injecting an insert hook\n mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', function () {\n var parent = el.parentNode;\n var pendingNode = parent && parent._pending && parent._pending[vnode.key];\n if (pendingNode &&\n pendingNode.tag === vnode.tag &&\n pendingNode.elm._leaveCb) {\n pendingNode.elm._leaveCb();\n }\n enterHook && enterHook(el, cb);\n }, 'transition-insert');\n }\n\n // start enter transition\n beforeEnterHook && beforeEnterHook(el);\n if (expectsCSS) {\n addTransitionClass(el, startClass);\n addTransitionClass(el, activeClass);\n nextFrame(function () {\n addTransitionClass(el, toClass);\n removeTransitionClass(el, startClass);\n if (!cb.cancelled && !userWantsControl) {\n whenTransitionEnds(el, type, cb);\n }\n });\n }\n\n if (vnode.data.show) {\n toggleDisplay && toggleDisplay();\n enterHook && enterHook(el, cb);\n }\n\n if (!expectsCSS && !userWantsControl) {\n cb();\n }\n}\n\nfunction leave (vnode, rm) {\n var el = vnode.elm;\n\n // call enter callback now\n if (el._enterCb) {\n el._enterCb.cancelled = true;\n el._enterCb();\n }\n\n var data = resolveTransition(vnode.data.transition);\n if (!data) {\n return rm()\n }\n\n /* istanbul ignore if */\n if (el._leaveCb || el.nodeType !== 1) {\n return\n }\n\n var css = data.css;\n var type = data.type;\n var leaveClass = data.leaveClass;\n var leaveToClass = data.leaveToClass;\n var leaveActiveClass = data.leaveActiveClass;\n var beforeLeave = data.beforeLeave;\n var leave = data.leave;\n var afterLeave = data.afterLeave;\n var leaveCancelled = data.leaveCancelled;\n var delayLeave = data.delayLeave;\n\n var expectsCSS = css !== false && !isIE9;\n var userWantsControl =\n leave &&\n // leave hook may be a bound method which exposes\n // the length of original fn as _length\n (leave._length || leave.length) > 1;\n\n var cb = el._leaveCb = once(function () {\n if (el.parentNode && el.parentNode._pending) {\n el.parentNode._pending[vnode.key] = null;\n }\n if (expectsCSS) {\n removeTransitionClass(el, leaveToClass);\n removeTransitionClass(el, leaveActiveClass);\n }\n if (cb.cancelled) {\n if (expectsCSS) {\n removeTransitionClass(el, leaveClass);\n }\n leaveCancelled && leaveCancelled(el);\n } else {\n rm();\n afterLeave && afterLeave(el);\n }\n el._leaveCb = null;\n });\n\n if (delayLeave) {\n delayLeave(performLeave);\n } else {\n performLeave();\n }\n\n function performLeave () {\n // the delayed leave may have already been cancelled\n if (cb.cancelled) {\n return\n }\n // record leaving element\n if (!vnode.data.show) {\n (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;\n }\n beforeLeave && beforeLeave(el);\n if (expectsCSS) {\n addTransitionClass(el, leaveClass);\n addTransitionClass(el, leaveActiveClass);\n nextFrame(function () {\n addTransitionClass(el, leaveToClass);\n removeTransitionClass(el, leaveClass);\n if (!cb.cancelled && !userWantsControl) {\n whenTransitionEnds(el, type, cb);\n }\n });\n }\n leave && leave(el, cb);\n if (!expectsCSS && !userWantsControl) {\n cb();\n }\n }\n}\n\nfunction resolveTransition (def$$1) {\n if (!def$$1) {\n return\n }\n /* istanbul ignore else */\n if (typeof def$$1 === 'object') {\n var res = {};\n if (def$$1.css !== false) {\n extend(res, autoCssTransition(def$$1.name || 'v'));\n }\n extend(res, def$$1);\n return res\n } else if (typeof def$$1 === 'string') {\n return autoCssTransition(def$$1)\n }\n}\n\nvar autoCssTransition = cached(function (name) {\n return {\n enterClass: (name + \"-enter\"),\n leaveClass: (name + \"-leave\"),\n appearClass: (name + \"-enter\"),\n enterToClass: (name + \"-enter-to\"),\n leaveToClass: (name + \"-leave-to\"),\n appearToClass: (name + \"-enter-to\"),\n enterActiveClass: (name + \"-enter-active\"),\n leaveActiveClass: (name + \"-leave-active\"),\n appearActiveClass: (name + \"-enter-active\")\n }\n});\n\nfunction once (fn) {\n var called = false;\n return function () {\n if (!called) {\n called = true;\n fn();\n }\n }\n}\n\nfunction _enter (_, vnode) {\n if (!vnode.data.show) {\n enter(vnode);\n }\n}\n\nvar transition = inBrowser ? {\n create: _enter,\n activate: _enter,\n remove: function remove (vnode, rm) {\n /* istanbul ignore else */\n if (!vnode.data.show) {\n leave(vnode, rm);\n } else {\n rm();\n }\n }\n} : {};\n\nvar platformModules = [\n attrs,\n klass,\n events,\n domProps,\n style,\n transition\n];\n\n/* */\n\n// the directive module should be applied last, after all\n// built-in modules have been applied.\nvar modules = platformModules.concat(baseModules);\n\nvar patch$1 = createPatchFunction({ nodeOps: nodeOps, modules: modules });\n\n/**\n * Not type checking this file because flow doesn't like attaching\n * properties to Elements.\n */\n\nvar modelableTagRE = /^input|select|textarea|vue-component-[0-9]+(-[0-9a-zA-Z_-]*)?$/;\n\n/* istanbul ignore if */\nif (isIE9) {\n // http://www.matts411.com/post/internet-explorer-9-oninput/\n document.addEventListener('selectionchange', function () {\n var el = document.activeElement;\n if (el && el.vmodel) {\n trigger(el, 'input');\n }\n });\n}\n\nvar model = {\n inserted: function inserted (el, binding, vnode) {\n if (false) {\n if (!modelableTagRE.test(vnode.tag)) {\n warn(\n \"v-model is not supported on element type: <\" + (vnode.tag) + \">. \" +\n 'If you are working with contenteditable, it\\'s recommended to ' +\n 'wrap a library dedicated for that purpose inside a custom component.',\n vnode.context\n );\n }\n }\n if (vnode.tag === 'select') {\n var cb = function () {\n setSelected(el, binding, vnode.context);\n };\n cb();\n /* istanbul ignore if */\n if (isIE || isEdge) {\n setTimeout(cb, 0);\n }\n } else if (vnode.tag === 'textarea' || el.type === 'text') {\n el._vModifiers = binding.modifiers;\n if (!binding.modifiers.lazy) {\n if (!isAndroid) {\n el.addEventListener('compositionstart', onCompositionStart);\n el.addEventListener('compositionend', onCompositionEnd);\n }\n /* istanbul ignore if */\n if (isIE9) {\n el.vmodel = true;\n }\n }\n }\n },\n componentUpdated: function componentUpdated (el, binding, vnode) {\n if (vnode.tag === 'select') {\n setSelected(el, binding, vnode.context);\n // in case the options rendered by v-for have changed,\n // it's possible that the value is out-of-sync with the rendered options.\n // detect such cases and filter out values that no longer has a matching\n // option in the DOM.\n var needReset = el.multiple\n ? binding.value.some(function (v) { return hasNoMatchingOption(v, el.options); })\n : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, el.options);\n if (needReset) {\n trigger(el, 'change');\n }\n }\n }\n};\n\nfunction setSelected (el, binding, vm) {\n var value = binding.value;\n var isMultiple = el.multiple;\n if (isMultiple && !Array.isArray(value)) {\n \"production\" !== 'production' && warn(\n \"<select multiple v-model=\\\"\" + (binding.expression) + \"\\\"> \" +\n \"expects an Array value for its binding, but got \" + (Object.prototype.toString.call(value).slice(8, -1)),\n vm\n );\n return\n }\n var selected, option;\n for (var i = 0, l = el.options.length; i < l; i++) {\n option = el.options[i];\n if (isMultiple) {\n selected = looseIndexOf(value, getValue(option)) > -1;\n if (option.selected !== selected) {\n option.selected = selected;\n }\n } else {\n if (looseEqual(getValue(option), value)) {\n if (el.selectedIndex !== i) {\n el.selectedIndex = i;\n }\n return\n }\n }\n }\n if (!isMultiple) {\n el.selectedIndex = -1;\n }\n}\n\nfunction hasNoMatchingOption (value, options) {\n for (var i = 0, l = options.length; i < l; i++) {\n if (looseEqual(getValue(options[i]), value)) {\n return false\n }\n }\n return true\n}\n\nfunction getValue (option) {\n return '_value' in option\n ? option._value\n : option.value\n}\n\nfunction onCompositionStart (e) {\n e.target.composing = true;\n}\n\nfunction onCompositionEnd (e) {\n e.target.composing = false;\n trigger(e.target, 'input');\n}\n\nfunction trigger (el, type) {\n var e = document.createEvent('HTMLEvents');\n e.initEvent(type, true, true);\n el.dispatchEvent(e);\n}\n\n/* */\n\n// recursively search for possible transition defined inside the component root\nfunction locateNode (vnode) {\n return vnode.componentInstance && (!vnode.data || !vnode.data.transition)\n ? locateNode(vnode.componentInstance._vnode)\n : vnode\n}\n\nvar show = {\n bind: function bind (el, ref, vnode) {\n var value = ref.value;\n\n vnode = locateNode(vnode);\n var transition = vnode.data && vnode.data.transition;\n var originalDisplay = el.__vOriginalDisplay =\n el.style.display === 'none' ? '' : el.style.display;\n if (value && transition && !isIE9) {\n vnode.data.show = true;\n enter(vnode, function () {\n el.style.display = originalDisplay;\n });\n } else {\n el.style.display = value ? originalDisplay : 'none';\n }\n },\n\n update: function update (el, ref, vnode) {\n var value = ref.value;\n var oldValue = ref.oldValue;\n\n /* istanbul ignore if */\n if (value === oldValue) { return }\n vnode = locateNode(vnode);\n var transition = vnode.data && vnode.data.transition;\n if (transition && !isIE9) {\n vnode.data.show = true;\n if (value) {\n enter(vnode, function () {\n el.style.display = el.__vOriginalDisplay;\n });\n } else {\n leave(vnode, function () {\n el.style.display = 'none';\n });\n }\n } else {\n el.style.display = value ? el.__vOriginalDisplay : 'none';\n }\n },\n\n unbind: function unbind (\n el,\n binding,\n vnode,\n oldVnode,\n isDestroy\n ) {\n if (!isDestroy) {\n el.style.display = el.__vOriginalDisplay;\n }\n }\n};\n\nvar platformDirectives = {\n model: model,\n show: show\n};\n\n/* */\n\n// Provides transition support for a single element/component.\n// supports transition mode (out-in / in-out)\n\nvar transitionProps = {\n name: String,\n appear: Boolean,\n css: Boolean,\n mode: String,\n type: String,\n enterClass: String,\n leaveClass: String,\n enterToClass: String,\n leaveToClass: String,\n enterActiveClass: String,\n leaveActiveClass: String,\n appearClass: String,\n appearActiveClass: String,\n appearToClass: String\n};\n\n// in case the child is also an abstract component, e.g. <keep-alive>\n// we want to recursively retrieve the real component to be rendered\nfunction getRealChild (vnode) {\n var compOptions = vnode && vnode.componentOptions;\n if (compOptions && compOptions.Ctor.options.abstract) {\n return getRealChild(getFirstComponentChild(compOptions.children))\n } else {\n return vnode\n }\n}\n\nfunction extractTransitionData (comp) {\n var data = {};\n var options = comp.$options;\n // props\n for (var key in options.propsData) {\n data[key] = comp[key];\n }\n // events.\n // extract listeners and pass them directly to the transition methods\n var listeners = options._parentListeners;\n for (var key$1 in listeners) {\n data[camelize(key$1)] = listeners[key$1].fn;\n }\n return data\n}\n\nfunction placeholder (h, rawChild) {\n return /\\d-keep-alive$/.test(rawChild.tag)\n ? h('keep-alive')\n : null\n}\n\nfunction hasParentTransition (vnode) {\n while ((vnode = vnode.parent)) {\n if (vnode.data.transition) {\n return true\n }\n }\n}\n\nfunction isSameChild (child, oldChild) {\n return oldChild.key === child.key && oldChild.tag === child.tag\n}\n\nvar Transition = {\n name: 'transition',\n props: transitionProps,\n abstract: true,\n\n render: function render (h) {\n var this$1 = this;\n\n var children = this.$slots.default;\n if (!children) {\n return\n }\n\n // filter out text nodes (possible whitespaces)\n children = children.filter(function (c) { return c.tag; });\n /* istanbul ignore if */\n if (!children.length) {\n return\n }\n\n // warn multiple elements\n if (false) {\n warn(\n '<transition> can only be used on a single element. Use ' +\n '<transition-group> for lists.',\n this.$parent\n );\n }\n\n var mode = this.mode;\n\n // warn invalid mode\n if (false) {\n warn(\n 'invalid <transition> mode: ' + mode,\n this.$parent\n );\n }\n\n var rawChild = children[0];\n\n // if this is a component root node and the component's\n // parent container node also has transition, skip.\n if (hasParentTransition(this.$vnode)) {\n return rawChild\n }\n\n // apply transition data to child\n // use getRealChild() to ignore abstract components e.g. keep-alive\n var child = getRealChild(rawChild);\n /* istanbul ignore if */\n if (!child) {\n return rawChild\n }\n\n if (this._leaving) {\n return placeholder(h, rawChild)\n }\n\n // ensure a key that is unique to the vnode type and to this transition\n // component instance. This key will be used to remove pending leaving nodes\n // during entering.\n var id = \"__transition-\" + (this._uid) + \"-\";\n var key = child.key = child.key == null\n ? id + child.tag\n : isPrimitive(child.key)\n ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)\n : child.key;\n var data = (child.data || (child.data = {})).transition = extractTransitionData(this);\n var oldRawChild = this._vnode;\n var oldChild = getRealChild(oldRawChild);\n\n // mark v-show\n // so that the transition module can hand over the control to the directive\n if (child.data.directives && child.data.directives.some(function (d) { return d.name === 'show'; })) {\n child.data.show = true;\n }\n\n if (oldChild && oldChild.data && !isSameChild(child, oldChild)) {\n // replace old child transition data with fresh one\n // important for dynamic transitions!\n var oldData = oldChild && (oldChild.data.transition = extend({}, data));\n // handle transition mode\n if (mode === 'out-in') {\n // return placeholder node and queue update when leave finishes\n this._leaving = true;\n mergeVNodeHook(oldData, 'afterLeave', function () {\n this$1._leaving = false;\n this$1.$forceUpdate();\n }, key);\n return placeholder(h, rawChild)\n } else if (mode === 'in-out') {\n var delayedLeave;\n var performLeave = function () { delayedLeave(); };\n mergeVNodeHook(data, 'afterEnter', performLeave, key);\n mergeVNodeHook(data, 'enterCancelled', performLeave, key);\n mergeVNodeHook(oldData, 'delayLeave', function (leave) {\n delayedLeave = leave;\n }, key);\n }\n }\n\n return rawChild\n }\n};\n\n/* */\n\n// Provides transition support for list items.\n// supports move transitions using the FLIP technique.\n\n// Because the vdom's children update algorithm is \"unstable\" - i.e.\n// it doesn't guarantee the relative positioning of removed elements,\n// we force transition-group to update its children into two passes:\n// in the first pass, we remove all nodes that need to be removed,\n// triggering their leaving transition; in the second pass, we insert/move\n// into the final disired state. This way in the second pass removed\n// nodes will remain where they should be.\n\nvar props = extend({\n tag: String,\n moveClass: String\n}, transitionProps);\n\ndelete props.mode;\n\nvar TransitionGroup = {\n props: props,\n\n render: function render (h) {\n var tag = this.tag || this.$vnode.data.tag || 'span';\n var map = Object.create(null);\n var prevChildren = this.prevChildren = this.children;\n var rawChildren = this.$slots.default || [];\n var children = this.children = [];\n var transitionData = extractTransitionData(this);\n\n for (var i = 0; i < rawChildren.length; i++) {\n var c = rawChildren[i];\n if (c.tag) {\n if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {\n children.push(c);\n map[c.key] = c\n ;(c.data || (c.data = {})).transition = transitionData;\n } else if (false) {\n var opts = c.componentOptions;\n var name = opts\n ? (opts.Ctor.options.name || opts.tag)\n : c.tag;\n warn((\"<transition-group> children must be keyed: <\" + name + \">\"));\n }\n }\n }\n\n if (prevChildren) {\n var kept = [];\n var removed = [];\n for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {\n var c$1 = prevChildren[i$1];\n c$1.data.transition = transitionData;\n c$1.data.pos = c$1.elm.getBoundingClientRect();\n if (map[c$1.key]) {\n kept.push(c$1);\n } else {\n removed.push(c$1);\n }\n }\n this.kept = h(tag, null, kept);\n this.removed = removed;\n }\n\n return h(tag, null, children)\n },\n\n beforeUpdate: function beforeUpdate () {\n // force removing pass\n this.__patch__(\n this._vnode,\n this.kept,\n false, // hydrating\n true // removeOnly (!important, avoids unnecessary moves)\n );\n this._vnode = this.kept;\n },\n\n updated: function updated () {\n var children = this.prevChildren;\n var moveClass = this.moveClass || ((this.name || 'v') + '-move');\n if (!children.length || !this.hasMove(children[0].elm, moveClass)) {\n return\n }\n\n // we divide the work into three loops to avoid mixing DOM reads and writes\n // in each iteration - which helps prevent layout thrashing.\n children.forEach(callPendingCbs);\n children.forEach(recordPosition);\n children.forEach(applyTranslation);\n\n // force reflow to put everything in position\n var f = document.body.offsetHeight; // eslint-disable-line\n\n children.forEach(function (c) {\n if (c.data.moved) {\n var el = c.elm;\n var s = el.style;\n addTransitionClass(el, moveClass);\n s.transform = s.WebkitTransform = s.transitionDuration = '';\n el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {\n if (!e || /transform$/.test(e.propertyName)) {\n el.removeEventListener(transitionEndEvent, cb);\n el._moveCb = null;\n removeTransitionClass(el, moveClass);\n }\n });\n }\n });\n },\n\n methods: {\n hasMove: function hasMove (el, moveClass) {\n /* istanbul ignore if */\n if (!hasTransition) {\n return false\n }\n if (this._hasMove != null) {\n return this._hasMove\n }\n addTransitionClass(el, moveClass);\n var info = getTransitionInfo(el);\n removeTransitionClass(el, moveClass);\n return (this._hasMove = info.hasTransform)\n }\n }\n};\n\nfunction callPendingCbs (c) {\n /* istanbul ignore if */\n if (c.elm._moveCb) {\n c.elm._moveCb();\n }\n /* istanbul ignore if */\n if (c.elm._enterCb) {\n c.elm._enterCb();\n }\n}\n\nfunction recordPosition (c) {\n c.data.newPos = c.elm.getBoundingClientRect();\n}\n\nfunction applyTranslation (c) {\n var oldPos = c.data.pos;\n var newPos = c.data.newPos;\n var dx = oldPos.left - newPos.left;\n var dy = oldPos.top - newPos.top;\n if (dx || dy) {\n c.data.moved = true;\n var s = c.elm.style;\n s.transform = s.WebkitTransform = \"translate(\" + dx + \"px,\" + dy + \"px)\";\n s.transitionDuration = '0s';\n }\n}\n\nvar platformComponents = {\n Transition: Transition,\n TransitionGroup: TransitionGroup\n};\n\n/* */\n\n// install platform specific utils\nVue$3.config.isUnknownElement = isUnknownElement;\nVue$3.config.isReservedTag = isReservedTag;\nVue$3.config.getTagNamespace = getTagNamespace;\nVue$3.config.mustUseProp = mustUseProp;\n\n// install platform runtime directives & components\nextend(Vue$3.options.directives, platformDirectives);\nextend(Vue$3.options.components, platformComponents);\n\n// install platform patch function\nVue$3.prototype.__patch__ = inBrowser ? patch$1 : noop;\n\n// wrap mount\nVue$3.prototype.$mount = function (\n el,\n hydrating\n) {\n el = el && inBrowser ? query(el) : undefined;\n return this._mount(el, hydrating)\n};\n\nif (false) {\n console[console.info ? 'info' : 'log'](\n \"You are running Vue in development mode.\\n\" +\n \"Make sure to turn on production mode when deploying for production.\\n\" +\n \"See more tips at https://vuejs.org/guide/deployment.html\"\n );\n}\n\n// devtools global hook\n/* istanbul ignore next */\nsetTimeout(function () {\n if (config.devtools) {\n if (devtools) {\n devtools.emit('init', Vue$3);\n } else if (\n false\n ) {\n console[console.info ? 'info' : 'log'](\n 'Download the Vue Devtools extension for a better development experience:\\n' +\n 'https://github.com/vuejs/vue-devtools'\n );\n }\n }\n}, 0);\n\n/* */\n\n// check whether current browser encodes a char inside attribute values\nfunction shouldDecode (content, encoded) {\n var div = document.createElement('div');\n div.innerHTML = \"<div a=\\\"\" + content + \"\\\">\";\n return div.innerHTML.indexOf(encoded) > 0\n}\n\n// #3663\n// IE encodes newlines inside attribute values while other browsers don't\nvar shouldDecodeNewlines = inBrowser ? shouldDecode('\\n', ' ') : false;\n\n/* */\n\nvar decoder;\n\nfunction decode (html) {\n decoder = decoder || document.createElement('div');\n decoder.innerHTML = html;\n return decoder.textContent\n}\n\n/* */\n\nvar isUnaryTag = makeMap(\n 'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +\n 'link,meta,param,source,track,wbr',\n true\n);\n\n// Elements that you can, intentionally, leave open\n// (and which close themselves)\nvar canBeLeftOpenTag = makeMap(\n 'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source',\n true\n);\n\n// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3\n// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content\nvar isNonPhrasingTag = makeMap(\n 'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +\n 'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +\n 'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +\n 'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +\n 'title,tr,track',\n true\n);\n\n/**\n * Not type-checking this file because it's mostly vendor code.\n */\n\n/*!\n * HTML Parser By John Resig (ejohn.org)\n * Modified by Juriy \"kangax\" Zaytsev\n * Original code by Erik Arvidsson, Mozilla Public License\n * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js\n */\n\n// Regular Expressions for parsing tags and attributes\nvar singleAttrIdentifier = /([^\\s\"'<>/=]+)/;\nvar singleAttrAssign = /(?:=)/;\nvar singleAttrValues = [\n // attr value double quotes\n /\"([^\"]*)\"+/.source,\n // attr value, single quotes\n /'([^']*)'+/.source,\n // attr value, no quotes\n /([^\\s\"'=<>`]+)/.source\n];\nvar attribute = new RegExp(\n '^\\\\s*' + singleAttrIdentifier.source +\n '(?:\\\\s*(' + singleAttrAssign.source + ')' +\n '\\\\s*(?:' + singleAttrValues.join('|') + '))?'\n);\n\n// could use https://www.w3.org/TR/1999/REC-xml-names-19990114/#NT-QName\n// but for Vue templates we can enforce a simple charset\nvar ncname = '[a-zA-Z_][\\\\w\\\\-\\\\.]*';\nvar qnameCapture = '((?:' + ncname + '\\\\:)?' + ncname + ')';\nvar startTagOpen = new RegExp('^<' + qnameCapture);\nvar startTagClose = /^\\s*(\\/?)>/;\nvar endTag = new RegExp('^<\\\\/' + qnameCapture + '[^>]*>');\nvar doctype = /^<!DOCTYPE [^>]+>/i;\nvar comment = /^<!--/;\nvar conditionalComment = /^<!\\[/;\n\nvar IS_REGEX_CAPTURING_BROKEN = false;\n'x'.replace(/x(.)?/g, function (m, g) {\n IS_REGEX_CAPTURING_BROKEN = g === '';\n});\n\n// Special Elements (can contain anything)\nvar isScriptOrStyle = makeMap('script,style', true);\nvar reCache = {};\n\nvar ltRE = /</g;\nvar gtRE = />/g;\nvar nlRE = / /g;\nvar ampRE = /&/g;\nvar quoteRE = /"/g;\n\nfunction decodeAttr (value, shouldDecodeNewlines) {\n if (shouldDecodeNewlines) {\n value = value.replace(nlRE, '\\n');\n }\n return value\n .replace(ltRE, '<')\n .replace(gtRE, '>')\n .replace(ampRE, '&')\n .replace(quoteRE, '\"')\n}\n\nfunction parseHTML (html, options) {\n var stack = [];\n var expectHTML = options.expectHTML;\n var isUnaryTag$$1 = options.isUnaryTag || no;\n var index = 0;\n var last, lastTag;\n while (html) {\n last = html;\n // Make sure we're not in a script or style element\n if (!lastTag || !isScriptOrStyle(lastTag)) {\n var textEnd = html.indexOf('<');\n if (textEnd === 0) {\n // Comment:\n if (comment.test(html)) {\n var commentEnd = html.indexOf('-->');\n\n if (commentEnd >= 0) {\n advance(commentEnd + 3);\n continue\n }\n }\n\n // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment\n if (conditionalComment.test(html)) {\n var conditionalEnd = html.indexOf(']>');\n\n if (conditionalEnd >= 0) {\n advance(conditionalEnd + 2);\n continue\n }\n }\n\n // Doctype:\n var doctypeMatch = html.match(doctype);\n if (doctypeMatch) {\n advance(doctypeMatch[0].length);\n continue\n }\n\n // End tag:\n var endTagMatch = html.match(endTag);\n if (endTagMatch) {\n var curIndex = index;\n advance(endTagMatch[0].length);\n parseEndTag(endTagMatch[1], curIndex, index);\n continue\n }\n\n // Start tag:\n var startTagMatch = parseStartTag();\n if (startTagMatch) {\n handleStartTag(startTagMatch);\n continue\n }\n }\n\n var text = (void 0), rest$1 = (void 0), next = (void 0);\n if (textEnd > 0) {\n rest$1 = html.slice(textEnd);\n while (\n !endTag.test(rest$1) &&\n !startTagOpen.test(rest$1) &&\n !comment.test(rest$1) &&\n !conditionalComment.test(rest$1)\n ) {\n // < in plain text, be forgiving and treat it as text\n next = rest$1.indexOf('<', 1);\n if (next < 0) { break }\n textEnd += next;\n rest$1 = html.slice(textEnd);\n }\n text = html.substring(0, textEnd);\n advance(textEnd);\n }\n\n if (textEnd < 0) {\n text = html;\n html = '';\n }\n\n if (options.chars && text) {\n options.chars(text);\n }\n } else {\n var stackedTag = lastTag.toLowerCase();\n var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\\\s\\\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));\n var endTagLength = 0;\n var rest = html.replace(reStackedTag, function (all, text, endTag) {\n endTagLength = endTag.length;\n if (stackedTag !== 'script' && stackedTag !== 'style' && stackedTag !== 'noscript') {\n text = text\n .replace(/<!--([\\s\\S]*?)-->/g, '$1')\n .replace(/<!\\[CDATA\\[([\\s\\S]*?)]]>/g, '$1');\n }\n if (options.chars) {\n options.chars(text);\n }\n return ''\n });\n index += html.length - rest.length;\n html = rest;\n parseEndTag(stackedTag, index - endTagLength, index);\n }\n\n if (html === last && options.chars) {\n options.chars(html);\n break\n }\n }\n\n // Clean up any remaining tags\n parseEndTag();\n\n function advance (n) {\n index += n;\n html = html.substring(n);\n }\n\n function parseStartTag () {\n var start = html.match(startTagOpen);\n if (start) {\n var match = {\n tagName: start[1],\n attrs: [],\n start: index\n };\n advance(start[0].length);\n var end, attr;\n while (!(end = html.match(startTagClose)) && (attr = html.match(attribute))) {\n advance(attr[0].length);\n match.attrs.push(attr);\n }\n if (end) {\n match.unarySlash = end[1];\n advance(end[0].length);\n match.end = index;\n return match\n }\n }\n }\n\n function handleStartTag (match) {\n var tagName = match.tagName;\n var unarySlash = match.unarySlash;\n\n if (expectHTML) {\n if (lastTag === 'p' && isNonPhrasingTag(tagName)) {\n parseEndTag(lastTag);\n }\n if (canBeLeftOpenTag(tagName) && lastTag === tagName) {\n parseEndTag(tagName);\n }\n }\n\n var unary = isUnaryTag$$1(tagName) || tagName === 'html' && lastTag === 'head' || !!unarySlash;\n\n var l = match.attrs.length;\n var attrs = new Array(l);\n for (var i = 0; i < l; i++) {\n var args = match.attrs[i];\n // hackish work around FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778\n if (IS_REGEX_CAPTURING_BROKEN && args[0].indexOf('\"\"') === -1) {\n if (args[3] === '') { delete args[3]; }\n if (args[4] === '') { delete args[4]; }\n if (args[5] === '') { delete args[5]; }\n }\n var value = args[3] || args[4] || args[5] || '';\n attrs[i] = {\n name: args[1],\n value: decodeAttr(\n value,\n options.shouldDecodeNewlines\n )\n };\n }\n\n if (!unary) {\n stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs });\n lastTag = tagName;\n unarySlash = '';\n }\n\n if (options.start) {\n options.start(tagName, attrs, unary, match.start, match.end);\n }\n }\n\n function parseEndTag (tagName, start, end) {\n var pos, lowerCasedTagName;\n if (start == null) { start = index; }\n if (end == null) { end = index; }\n\n if (tagName) {\n lowerCasedTagName = tagName.toLowerCase();\n }\n\n // Find the closest opened tag of the same type\n if (tagName) {\n for (pos = stack.length - 1; pos >= 0; pos--) {\n if (stack[pos].lowerCasedTag === lowerCasedTagName) {\n break\n }\n }\n } else {\n // If no tag name is provided, clean shop\n pos = 0;\n }\n\n if (pos >= 0) {\n // Close all the open elements, up the stack\n for (var i = stack.length - 1; i >= pos; i--) {\n if (options.end) {\n options.end(stack[i].tag, start, end);\n }\n }\n\n // Remove the open elements from the stack\n stack.length = pos;\n lastTag = pos && stack[pos - 1].tag;\n } else if (lowerCasedTagName === 'br') {\n if (options.start) {\n options.start(tagName, [], true, start, end);\n }\n } else if (lowerCasedTagName === 'p') {\n if (options.start) {\n options.start(tagName, [], false, start, end);\n }\n if (options.end) {\n options.end(tagName, start, end);\n }\n }\n }\n}\n\n/* */\n\nfunction parseFilters (exp) {\n var inSingle = false;\n var inDouble = false;\n var inTemplateString = false;\n var inRegex = false;\n var curly = 0;\n var square = 0;\n var paren = 0;\n var lastFilterIndex = 0;\n var c, prev, i, expression, filters;\n\n for (i = 0; i < exp.length; i++) {\n prev = c;\n c = exp.charCodeAt(i);\n if (inSingle) {\n if (c === 0x27 && prev !== 0x5C) { inSingle = false; }\n } else if (inDouble) {\n if (c === 0x22 && prev !== 0x5C) { inDouble = false; }\n } else if (inTemplateString) {\n if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }\n } else if (inRegex) {\n if (c === 0x2f && prev !== 0x5C) { inRegex = false; }\n } else if (\n c === 0x7C && // pipe\n exp.charCodeAt(i + 1) !== 0x7C &&\n exp.charCodeAt(i - 1) !== 0x7C &&\n !curly && !square && !paren\n ) {\n if (expression === undefined) {\n // first filter, end of expression\n lastFilterIndex = i + 1;\n expression = exp.slice(0, i).trim();\n } else {\n pushFilter();\n }\n } else {\n switch (c) {\n case 0x22: inDouble = true; break // \"\n case 0x27: inSingle = true; break // '\n case 0x60: inTemplateString = true; break // `\n case 0x28: paren++; break // (\n case 0x29: paren--; break // )\n case 0x5B: square++; break // [\n case 0x5D: square--; break // ]\n case 0x7B: curly++; break // {\n case 0x7D: curly--; break // }\n }\n if (c === 0x2f) { // /\n var j = i - 1;\n var p = (void 0);\n // find first non-whitespace prev char\n for (; j >= 0; j--) {\n p = exp.charAt(j);\n if (p !== ' ') { break }\n }\n if (!p || !/[\\w$]/.test(p)) {\n inRegex = true;\n }\n }\n }\n }\n\n if (expression === undefined) {\n expression = exp.slice(0, i).trim();\n } else if (lastFilterIndex !== 0) {\n pushFilter();\n }\n\n function pushFilter () {\n (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());\n lastFilterIndex = i + 1;\n }\n\n if (filters) {\n for (i = 0; i < filters.length; i++) {\n expression = wrapFilter(expression, filters[i]);\n }\n }\n\n return expression\n}\n\nfunction wrapFilter (exp, filter) {\n var i = filter.indexOf('(');\n if (i < 0) {\n // _f: resolveFilter\n return (\"_f(\\\"\" + filter + \"\\\")(\" + exp + \")\")\n } else {\n var name = filter.slice(0, i);\n var args = filter.slice(i + 1);\n return (\"_f(\\\"\" + name + \"\\\")(\" + exp + \",\" + args)\n }\n}\n\n/* */\n\nvar defaultTagRE = /\\{\\{((?:.|\\n)+?)\\}\\}/g;\nvar regexEscapeRE = /[-.*+?^${}()|[\\]\\/\\\\]/g;\n\nvar buildRegex = cached(function (delimiters) {\n var open = delimiters[0].replace(regexEscapeRE, '\\\\$&');\n var close = delimiters[1].replace(regexEscapeRE, '\\\\$&');\n return new RegExp(open + '((?:.|\\\\n)+?)' + close, 'g')\n});\n\nfunction parseText (\n text,\n delimiters\n) {\n var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;\n if (!tagRE.test(text)) {\n return\n }\n var tokens = [];\n var lastIndex = tagRE.lastIndex = 0;\n var match, index;\n while ((match = tagRE.exec(text))) {\n index = match.index;\n // push text token\n if (index > lastIndex) {\n tokens.push(JSON.stringify(text.slice(lastIndex, index)));\n }\n // tag token\n var exp = parseFilters(match[1].trim());\n tokens.push((\"_s(\" + exp + \")\"));\n lastIndex = index + match[0].length;\n }\n if (lastIndex < text.length) {\n tokens.push(JSON.stringify(text.slice(lastIndex)));\n }\n return tokens.join('+')\n}\n\n/* */\n\nfunction baseWarn (msg) {\n console.error((\"[Vue parser]: \" + msg));\n}\n\nfunction pluckModuleFunction (\n modules,\n key\n) {\n return modules\n ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })\n : []\n}\n\nfunction addProp (el, name, value) {\n (el.props || (el.props = [])).push({ name: name, value: value });\n}\n\nfunction addAttr (el, name, value) {\n (el.attrs || (el.attrs = [])).push({ name: name, value: value });\n}\n\nfunction addDirective (\n el,\n name,\n rawName,\n value,\n arg,\n modifiers\n) {\n (el.directives || (el.directives = [])).push({ name: name, rawName: rawName, value: value, arg: arg, modifiers: modifiers });\n}\n\nfunction addHandler (\n el,\n name,\n value,\n modifiers,\n important\n) {\n // check capture modifier\n if (modifiers && modifiers.capture) {\n delete modifiers.capture;\n name = '!' + name; // mark the event as captured\n }\n if (modifiers && modifiers.once) {\n delete modifiers.once;\n name = '~' + name; // mark the event as once\n }\n var events;\n if (modifiers && modifiers.native) {\n delete modifiers.native;\n events = el.nativeEvents || (el.nativeEvents = {});\n } else {\n events = el.events || (el.events = {});\n }\n var newHandler = { value: value, modifiers: modifiers };\n var handlers = events[name];\n /* istanbul ignore if */\n if (Array.isArray(handlers)) {\n important ? handlers.unshift(newHandler) : handlers.push(newHandler);\n } else if (handlers) {\n events[name] = important ? [newHandler, handlers] : [handlers, newHandler];\n } else {\n events[name] = newHandler;\n }\n}\n\nfunction getBindingAttr (\n el,\n name,\n getStatic\n) {\n var dynamicValue =\n getAndRemoveAttr(el, ':' + name) ||\n getAndRemoveAttr(el, 'v-bind:' + name);\n if (dynamicValue != null) {\n return parseFilters(dynamicValue)\n } else if (getStatic !== false) {\n var staticValue = getAndRemoveAttr(el, name);\n if (staticValue != null) {\n return JSON.stringify(staticValue)\n }\n }\n}\n\nfunction getAndRemoveAttr (el, name) {\n var val;\n if ((val = el.attrsMap[name]) != null) {\n var list = el.attrsList;\n for (var i = 0, l = list.length; i < l; i++) {\n if (list[i].name === name) {\n list.splice(i, 1);\n break\n }\n }\n }\n return val\n}\n\nvar len;\nvar str;\nvar chr;\nvar index$1;\nvar expressionPos;\nvar expressionEndPos;\n\n/**\n * parse directive model to do the array update transform. a[idx] = val => $$a.splice($$idx, 1, val)\n *\n * for loop possible cases:\n *\n * - test\n * - test[idx]\n * - test[test1[idx]]\n * - test[\"a\"][idx]\n * - xxx.test[a[a].test1[idx]]\n * - test.xxx.a[\"asa\"][test1[idx]]\n *\n */\n\nfunction parseModel (val) {\n str = val;\n len = str.length;\n index$1 = expressionPos = expressionEndPos = 0;\n\n if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {\n return {\n exp: val,\n idx: null\n }\n }\n\n while (!eof()) {\n chr = next();\n /* istanbul ignore if */\n if (isStringStart(chr)) {\n parseString(chr);\n } else if (chr === 0x5B) {\n parseBracket(chr);\n }\n }\n\n return {\n exp: val.substring(0, expressionPos),\n idx: val.substring(expressionPos + 1, expressionEndPos)\n }\n}\n\nfunction next () {\n return str.charCodeAt(++index$1)\n}\n\nfunction eof () {\n return index$1 >= len\n}\n\nfunction isStringStart (chr) {\n return chr === 0x22 || chr === 0x27\n}\n\nfunction parseBracket (chr) {\n var inBracket = 1;\n expressionPos = index$1;\n while (!eof()) {\n chr = next();\n if (isStringStart(chr)) {\n parseString(chr);\n continue\n }\n if (chr === 0x5B) { inBracket++; }\n if (chr === 0x5D) { inBracket--; }\n if (inBracket === 0) {\n expressionEndPos = index$1;\n break\n }\n }\n}\n\nfunction parseString (chr) {\n var stringQuote = chr;\n while (!eof()) {\n chr = next();\n if (chr === stringQuote) {\n break\n }\n }\n}\n\n/* */\n\nvar dirRE = /^v-|^@|^:/;\nvar forAliasRE = /(.*?)\\s+(?:in|of)\\s+(.*)/;\nvar forIteratorRE = /\\((\\{[^}]*\\}|[^,]*),([^,]*)(?:,([^,]*))?\\)/;\nvar bindRE = /^:|^v-bind:/;\nvar onRE = /^@|^v-on:/;\nvar argRE = /:(.*)$/;\nvar modifierRE = /\\.[^.]+/g;\n\nvar decodeHTMLCached = cached(decode);\n\n// configurable state\nvar warn$1;\nvar platformGetTagNamespace;\nvar platformMustUseProp;\nvar platformIsPreTag;\nvar preTransforms;\nvar transforms;\nvar postTransforms;\nvar delimiters;\n\n/**\n * Convert HTML string to AST.\n */\nfunction parse (\n template,\n options\n) {\n warn$1 = options.warn || baseWarn;\n platformGetTagNamespace = options.getTagNamespace || no;\n platformMustUseProp = options.mustUseProp || no;\n platformIsPreTag = options.isPreTag || no;\n preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');\n transforms = pluckModuleFunction(options.modules, 'transformNode');\n postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');\n delimiters = options.delimiters;\n var stack = [];\n var preserveWhitespace = options.preserveWhitespace !== false;\n var root;\n var currentParent;\n var inVPre = false;\n var inPre = false;\n var warned = false;\n parseHTML(template, {\n expectHTML: options.expectHTML,\n isUnaryTag: options.isUnaryTag,\n shouldDecodeNewlines: options.shouldDecodeNewlines,\n start: function start (tag, attrs, unary) {\n // check namespace.\n // inherit parent ns if there is one\n var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);\n\n // handle IE svg bug\n /* istanbul ignore if */\n if (isIE && ns === 'svg') {\n attrs = guardIESVGBug(attrs);\n }\n\n var element = {\n type: 1,\n tag: tag,\n attrsList: attrs,\n attrsMap: makeAttrsMap(attrs),\n parent: currentParent,\n children: []\n };\n if (ns) {\n element.ns = ns;\n }\n\n if (isForbiddenTag(element) && !isServerRendering()) {\n element.forbidden = true;\n \"production\" !== 'production' && warn$1(\n 'Templates should only be responsible for mapping the state to the ' +\n 'UI. Avoid placing tags with side-effects in your templates, such as ' +\n \"<\" + tag + \">\" + ', as they will not be parsed.'\n );\n }\n\n // apply pre-transforms\n for (var i = 0; i < preTransforms.length; i++) {\n preTransforms[i](element, options);\n }\n\n if (!inVPre) {\n processPre(element);\n if (element.pre) {\n inVPre = true;\n }\n }\n if (platformIsPreTag(element.tag)) {\n inPre = true;\n }\n if (inVPre) {\n processRawAttrs(element);\n } else {\n processFor(element);\n processIf(element);\n processOnce(element);\n processKey(element);\n\n // determine whether this is a plain element after\n // removing structural attributes\n element.plain = !element.key && !attrs.length;\n\n processRef(element);\n processSlot(element);\n processComponent(element);\n for (var i$1 = 0; i$1 < transforms.length; i$1++) {\n transforms[i$1](element, options);\n }\n processAttrs(element);\n }\n\n function checkRootConstraints (el) {\n if (false) {\n if (el.tag === 'slot' || el.tag === 'template') {\n warned = true;\n warn$1(\n \"Cannot use <\" + (el.tag) + \"> as component root element because it may \" +\n 'contain multiple nodes:\\n' + template\n );\n }\n if (el.attrsMap.hasOwnProperty('v-for')) {\n warned = true;\n warn$1(\n 'Cannot use v-for on stateful component root element because ' +\n 'it renders multiple elements:\\n' + template\n );\n }\n }\n }\n\n // tree management\n if (!root) {\n root = element;\n checkRootConstraints(root);\n } else if (!stack.length) {\n // allow root elements with v-if, v-else-if and v-else\n if (root.if && (element.elseif || element.else)) {\n checkRootConstraints(element);\n addIfCondition(root, {\n exp: element.elseif,\n block: element\n });\n } else if (false) {\n warned = true;\n warn$1(\n \"Component template should contain exactly one root element:\" +\n \"\\n\\n\" + template + \"\\n\\n\" +\n \"If you are using v-if on multiple elements, \" +\n \"use v-else-if to chain them instead.\"\n );\n }\n }\n if (currentParent && !element.forbidden) {\n if (element.elseif || element.else) {\n processIfConditions(element, currentParent);\n } else if (element.slotScope) { // scoped slot\n currentParent.plain = false;\n var name = element.slotTarget || 'default';(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;\n } else {\n currentParent.children.push(element);\n element.parent = currentParent;\n }\n }\n if (!unary) {\n currentParent = element;\n stack.push(element);\n }\n // apply post-transforms\n for (var i$2 = 0; i$2 < postTransforms.length; i$2++) {\n postTransforms[i$2](element, options);\n }\n },\n\n end: function end () {\n // remove trailing whitespace\n var element = stack[stack.length - 1];\n var lastNode = element.children[element.children.length - 1];\n if (lastNode && lastNode.type === 3 && lastNode.text === ' ') {\n element.children.pop();\n }\n // pop stack\n stack.length -= 1;\n currentParent = stack[stack.length - 1];\n // check pre state\n if (element.pre) {\n inVPre = false;\n }\n if (platformIsPreTag(element.tag)) {\n inPre = false;\n }\n },\n\n chars: function chars (text) {\n if (!currentParent) {\n if (false) {\n warned = true;\n warn$1(\n 'Component template requires a root element, rather than just text:\\n\\n' + template\n );\n }\n return\n }\n // IE textarea placeholder bug\n /* istanbul ignore if */\n if (isIE &&\n currentParent.tag === 'textarea' &&\n currentParent.attrsMap.placeholder === text) {\n return\n }\n var children = currentParent.children;\n text = inPre || text.trim()\n ? decodeHTMLCached(text)\n // only preserve whitespace if its not right after a starting tag\n : preserveWhitespace && children.length ? ' ' : '';\n if (text) {\n var expression;\n if (!inVPre && text !== ' ' && (expression = parseText(text, delimiters))) {\n children.push({\n type: 2,\n expression: expression,\n text: text\n });\n } else if (text !== ' ' || children[children.length - 1].text !== ' ') {\n currentParent.children.push({\n type: 3,\n text: text\n });\n }\n }\n }\n });\n return root\n}\n\nfunction processPre (el) {\n if (getAndRemoveAttr(el, 'v-pre') != null) {\n el.pre = true;\n }\n}\n\nfunction processRawAttrs (el) {\n var l = el.attrsList.length;\n if (l) {\n var attrs = el.attrs = new Array(l);\n for (var i = 0; i < l; i++) {\n attrs[i] = {\n name: el.attrsList[i].name,\n value: JSON.stringify(el.attrsList[i].value)\n };\n }\n } else if (!el.pre) {\n // non root node in pre blocks with no attributes\n el.plain = true;\n }\n}\n\nfunction processKey (el) {\n var exp = getBindingAttr(el, 'key');\n if (exp) {\n if (false) {\n warn$1(\"<template> cannot be keyed. Place the key on real elements instead.\");\n }\n el.key = exp;\n }\n}\n\nfunction processRef (el) {\n var ref = getBindingAttr(el, 'ref');\n if (ref) {\n el.ref = ref;\n el.refInFor = checkInFor(el);\n }\n}\n\nfunction processFor (el) {\n var exp;\n if ((exp = getAndRemoveAttr(el, 'v-for'))) {\n var inMatch = exp.match(forAliasRE);\n if (!inMatch) {\n \"production\" !== 'production' && warn$1(\n (\"Invalid v-for expression: \" + exp)\n );\n return\n }\n el.for = inMatch[2].trim();\n var alias = inMatch[1].trim();\n var iteratorMatch = alias.match(forIteratorRE);\n if (iteratorMatch) {\n el.alias = iteratorMatch[1].trim();\n el.iterator1 = iteratorMatch[2].trim();\n if (iteratorMatch[3]) {\n el.iterator2 = iteratorMatch[3].trim();\n }\n } else {\n el.alias = alias;\n }\n }\n}\n\nfunction processIf (el) {\n var exp = getAndRemoveAttr(el, 'v-if');\n if (exp) {\n el.if = exp;\n addIfCondition(el, {\n exp: exp,\n block: el\n });\n } else {\n if (getAndRemoveAttr(el, 'v-else') != null) {\n el.else = true;\n }\n var elseif = getAndRemoveAttr(el, 'v-else-if');\n if (elseif) {\n el.elseif = elseif;\n }\n }\n}\n\nfunction processIfConditions (el, parent) {\n var prev = findPrevElement(parent.children);\n if (prev && prev.if) {\n addIfCondition(prev, {\n exp: el.elseif,\n block: el\n });\n } else if (false) {\n warn$1(\n \"v-\" + (el.elseif ? ('else-if=\"' + el.elseif + '\"') : 'else') + \" \" +\n \"used on element <\" + (el.tag) + \"> without corresponding v-if.\"\n );\n }\n}\n\nfunction findPrevElement (children) {\n var i = children.length;\n while (i--) {\n if (children[i].type === 1) {\n return children[i]\n } else {\n if (false) {\n warn$1(\n \"text \\\"\" + (children[i].text.trim()) + \"\\\" between v-if and v-else(-if) \" +\n \"will be ignored.\"\n );\n }\n children.pop();\n }\n }\n}\n\nfunction addIfCondition (el, condition) {\n if (!el.ifConditions) {\n el.ifConditions = [];\n }\n el.ifConditions.push(condition);\n}\n\nfunction processOnce (el) {\n var once = getAndRemoveAttr(el, 'v-once');\n if (once != null) {\n el.once = true;\n }\n}\n\nfunction processSlot (el) {\n if (el.tag === 'slot') {\n el.slotName = getBindingAttr(el, 'name');\n if (false) {\n warn$1(\n \"`key` does not work on <slot> because slots are abstract outlets \" +\n \"and can possibly expand into multiple elements. \" +\n \"Use the key on a wrapping element instead.\"\n );\n }\n } else {\n var slotTarget = getBindingAttr(el, 'slot');\n if (slotTarget) {\n el.slotTarget = slotTarget === '\"\"' ? '\"default\"' : slotTarget;\n }\n if (el.tag === 'template') {\n el.slotScope = getAndRemoveAttr(el, 'scope');\n }\n }\n}\n\nfunction processComponent (el) {\n var binding;\n if ((binding = getBindingAttr(el, 'is'))) {\n el.component = binding;\n }\n if (getAndRemoveAttr(el, 'inline-template') != null) {\n el.inlineTemplate = true;\n }\n}\n\nfunction processAttrs (el) {\n var list = el.attrsList;\n var i, l, name, rawName, value, arg, modifiers, isProp;\n for (i = 0, l = list.length; i < l; i++) {\n name = rawName = list[i].name;\n value = list[i].value;\n if (dirRE.test(name)) {\n // mark element as dynamic\n el.hasBindings = true;\n // modifiers\n modifiers = parseModifiers(name);\n if (modifiers) {\n name = name.replace(modifierRE, '');\n }\n if (bindRE.test(name)) { // v-bind\n name = name.replace(bindRE, '');\n value = parseFilters(value);\n isProp = false;\n if (modifiers) {\n if (modifiers.prop) {\n isProp = true;\n name = camelize(name);\n if (name === 'innerHtml') { name = 'innerHTML'; }\n }\n if (modifiers.camel) {\n name = camelize(name);\n }\n }\n if (isProp || platformMustUseProp(el.tag, el.attrsMap.type, name)) {\n addProp(el, name, value);\n } else {\n addAttr(el, name, value);\n }\n } else if (onRE.test(name)) { // v-on\n name = name.replace(onRE, '');\n addHandler(el, name, value, modifiers);\n } else { // normal directives\n name = name.replace(dirRE, '');\n // parse arg\n var argMatch = name.match(argRE);\n if (argMatch && (arg = argMatch[1])) {\n name = name.slice(0, -(arg.length + 1));\n }\n addDirective(el, name, rawName, value, arg, modifiers);\n if (false) {\n checkForAliasModel(el, value);\n }\n }\n } else {\n // literal attribute\n if (false) {\n var expression = parseText(value, delimiters);\n if (expression) {\n warn$1(\n name + \"=\\\"\" + value + \"\\\": \" +\n 'Interpolation inside attributes has been removed. ' +\n 'Use v-bind or the colon shorthand instead. For example, ' +\n 'instead of <div id=\"{{ val }}\">, use <div :id=\"val\">.'\n );\n }\n }\n addAttr(el, name, JSON.stringify(value));\n }\n }\n}\n\nfunction checkInFor (el) {\n var parent = el;\n while (parent) {\n if (parent.for !== undefined) {\n return true\n }\n parent = parent.parent;\n }\n return false\n}\n\nfunction parseModifiers (name) {\n var match = name.match(modifierRE);\n if (match) {\n var ret = {};\n match.forEach(function (m) { ret[m.slice(1)] = true; });\n return ret\n }\n}\n\nfunction makeAttrsMap (attrs) {\n var map = {};\n for (var i = 0, l = attrs.length; i < l; i++) {\n if (false) {\n warn$1('duplicate attribute: ' + attrs[i].name);\n }\n map[attrs[i].name] = attrs[i].value;\n }\n return map\n}\n\nfunction isForbiddenTag (el) {\n return (\n el.tag === 'style' ||\n (el.tag === 'script' && (\n !el.attrsMap.type ||\n el.attrsMap.type === 'text/javascript'\n ))\n )\n}\n\nvar ieNSBug = /^xmlns:NS\\d+/;\nvar ieNSPrefix = /^NS\\d+:/;\n\n/* istanbul ignore next */\nfunction guardIESVGBug (attrs) {\n var res = [];\n for (var i = 0; i < attrs.length; i++) {\n var attr = attrs[i];\n if (!ieNSBug.test(attr.name)) {\n attr.name = attr.name.replace(ieNSPrefix, '');\n res.push(attr);\n }\n }\n return res\n}\n\nfunction checkForAliasModel (el, value) {\n var _el = el;\n while (_el) {\n if (_el.for && _el.alias === value) {\n warn$1(\n \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\">: \" +\n \"You are binding v-model directly to a v-for iteration alias. \" +\n \"This will not be able to modify the v-for source array because \" +\n \"writing to the alias is like modifying a function local variable. \" +\n \"Consider using an array of objects and use v-model on an object property instead.\"\n );\n }\n _el = _el.parent;\n }\n}\n\n/* */\n\nvar isStaticKey;\nvar isPlatformReservedTag;\n\nvar genStaticKeysCached = cached(genStaticKeys$1);\n\n/**\n * Goal of the optimizer: walk the generated template AST tree\n * and detect sub-trees that are purely static, i.e. parts of\n * the DOM that never needs to change.\n *\n * Once we detect these sub-trees, we can:\n *\n * 1. Hoist them into constants, so that we no longer need to\n * create fresh nodes for them on each re-render;\n * 2. Completely skip them in the patching process.\n */\nfunction optimize (root, options) {\n if (!root) { return }\n isStaticKey = genStaticKeysCached(options.staticKeys || '');\n isPlatformReservedTag = options.isReservedTag || no;\n // first pass: mark all non-static nodes.\n markStatic(root);\n // second pass: mark static roots.\n markStaticRoots(root, false);\n}\n\nfunction genStaticKeys$1 (keys) {\n return makeMap(\n 'type,tag,attrsList,attrsMap,plain,parent,children,attrs' +\n (keys ? ',' + keys : '')\n )\n}\n\nfunction markStatic (node) {\n node.static = isStatic(node);\n if (node.type === 1) {\n // do not make component slot content static. this avoids\n // 1. components not able to mutate slot nodes\n // 2. static slot content fails for hot-reloading\n if (\n !isPlatformReservedTag(node.tag) &&\n node.tag !== 'slot' &&\n node.attrsMap['inline-template'] == null\n ) {\n return\n }\n for (var i = 0, l = node.children.length; i < l; i++) {\n var child = node.children[i];\n markStatic(child);\n if (!child.static) {\n node.static = false;\n }\n }\n }\n}\n\nfunction markStaticRoots (node, isInFor) {\n if (node.type === 1) {\n if (node.static || node.once) {\n node.staticInFor = isInFor;\n }\n // For a node to qualify as a static root, it should have children that\n // are not just static text. Otherwise the cost of hoisting out will\n // outweigh the benefits and it's better off to just always render it fresh.\n if (node.static && node.children.length && !(\n node.children.length === 1 &&\n node.children[0].type === 3\n )) {\n node.staticRoot = true;\n return\n } else {\n node.staticRoot = false;\n }\n if (node.children) {\n for (var i = 0, l = node.children.length; i < l; i++) {\n markStaticRoots(node.children[i], isInFor || !!node.for);\n }\n }\n if (node.ifConditions) {\n walkThroughConditionsBlocks(node.ifConditions, isInFor);\n }\n }\n}\n\nfunction walkThroughConditionsBlocks (conditionBlocks, isInFor) {\n for (var i = 1, len = conditionBlocks.length; i < len; i++) {\n markStaticRoots(conditionBlocks[i].block, isInFor);\n }\n}\n\nfunction isStatic (node) {\n if (node.type === 2) { // expression\n return false\n }\n if (node.type === 3) { // text\n return true\n }\n return !!(node.pre || (\n !node.hasBindings && // no dynamic bindings\n !node.if && !node.for && // not v-if or v-for or v-else\n !isBuiltInTag(node.tag) && // not a built-in\n isPlatformReservedTag(node.tag) && // not a component\n !isDirectChildOfTemplateFor(node) &&\n Object.keys(node).every(isStaticKey)\n ))\n}\n\nfunction isDirectChildOfTemplateFor (node) {\n while (node.parent) {\n node = node.parent;\n if (node.tag !== 'template') {\n return false\n }\n if (node.for) {\n return true\n }\n }\n return false\n}\n\n/* */\n\nvar fnExpRE = /^\\s*([\\w$_]+|\\([^)]*?\\))\\s*=>|^function\\s*\\(/;\nvar simplePathRE = /^\\s*[A-Za-z_$][\\w$]*(?:\\.[A-Za-z_$][\\w$]*|\\['.*?']|\\[\".*?\"]|\\[\\d+]|\\[[A-Za-z_$][\\w$]*])*\\s*$/;\n\n// keyCode aliases\nvar keyCodes = {\n esc: 27,\n tab: 9,\n enter: 13,\n space: 32,\n up: 38,\n left: 37,\n right: 39,\n down: 40,\n 'delete': [8, 46]\n};\n\nvar modifierCode = {\n stop: '$event.stopPropagation();',\n prevent: '$event.preventDefault();',\n self: 'if($event.target !== $event.currentTarget)return;',\n ctrl: 'if(!$event.ctrlKey)return;',\n shift: 'if(!$event.shiftKey)return;',\n alt: 'if(!$event.altKey)return;',\n meta: 'if(!$event.metaKey)return;'\n};\n\nfunction genHandlers (events, native) {\n var res = native ? 'nativeOn:{' : 'on:{';\n for (var name in events) {\n res += \"\\\"\" + name + \"\\\":\" + (genHandler(name, events[name])) + \",\";\n }\n return res.slice(0, -1) + '}'\n}\n\nfunction genHandler (\n name,\n handler\n) {\n if (!handler) {\n return 'function(){}'\n } else if (Array.isArray(handler)) {\n return (\"[\" + (handler.map(function (handler) { return genHandler(name, handler); }).join(',')) + \"]\")\n } else if (!handler.modifiers) {\n return fnExpRE.test(handler.value) || simplePathRE.test(handler.value)\n ? handler.value\n : (\"function($event){\" + (handler.value) + \"}\")\n } else {\n var code = '';\n var keys = [];\n for (var key in handler.modifiers) {\n if (modifierCode[key]) {\n code += modifierCode[key];\n } else {\n keys.push(key);\n }\n }\n if (keys.length) {\n code = genKeyFilter(keys) + code;\n }\n var handlerCode = simplePathRE.test(handler.value)\n ? handler.value + '($event)'\n : handler.value;\n return 'function($event){' + code + handlerCode + '}'\n }\n}\n\nfunction genKeyFilter (keys) {\n return (\"if(\" + (keys.map(genFilterCode).join('&&')) + \")return;\")\n}\n\nfunction genFilterCode (key) {\n var keyVal = parseInt(key, 10);\n if (keyVal) {\n return (\"$event.keyCode!==\" + keyVal)\n }\n var alias = keyCodes[key];\n return (\"_k($event.keyCode,\" + (JSON.stringify(key)) + (alias ? ',' + JSON.stringify(alias) : '') + \")\")\n}\n\n/* */\n\nfunction bind$2 (el, dir) {\n el.wrapData = function (code) {\n return (\"_b(\" + code + \",'\" + (el.tag) + \"',\" + (dir.value) + (dir.modifiers && dir.modifiers.prop ? ',true' : '') + \")\")\n };\n}\n\n/* */\n\nvar baseDirectives = {\n bind: bind$2,\n cloak: noop\n};\n\n/* */\n\n// configurable state\nvar warn$2;\nvar transforms$1;\nvar dataGenFns;\nvar platformDirectives$1;\nvar isPlatformReservedTag$1;\nvar staticRenderFns;\nvar onceCount;\nvar currentOptions;\n\nfunction generate (\n ast,\n options\n) {\n // save previous staticRenderFns so generate calls can be nested\n var prevStaticRenderFns = staticRenderFns;\n var currentStaticRenderFns = staticRenderFns = [];\n var prevOnceCount = onceCount;\n onceCount = 0;\n currentOptions = options;\n warn$2 = options.warn || baseWarn;\n transforms$1 = pluckModuleFunction(options.modules, 'transformCode');\n dataGenFns = pluckModuleFunction(options.modules, 'genData');\n platformDirectives$1 = options.directives || {};\n isPlatformReservedTag$1 = options.isReservedTag || no;\n var code = ast ? genElement(ast) : '_c(\"div\")';\n staticRenderFns = prevStaticRenderFns;\n onceCount = prevOnceCount;\n return {\n render: (\"with(this){return \" + code + \"}\"),\n staticRenderFns: currentStaticRenderFns\n }\n}\n\nfunction genElement (el) {\n if (el.staticRoot && !el.staticProcessed) {\n return genStatic(el)\n } else if (el.once && !el.onceProcessed) {\n return genOnce(el)\n } else if (el.for && !el.forProcessed) {\n return genFor(el)\n } else if (el.if && !el.ifProcessed) {\n return genIf(el)\n } else if (el.tag === 'template' && !el.slotTarget) {\n return genChildren(el) || 'void 0'\n } else if (el.tag === 'slot') {\n return genSlot(el)\n } else {\n // component or element\n var code;\n if (el.component) {\n code = genComponent(el.component, el);\n } else {\n var data = el.plain ? undefined : genData(el);\n\n var children = el.inlineTemplate ? null : genChildren(el, true);\n code = \"_c('\" + (el.tag) + \"'\" + (data ? (\",\" + data) : '') + (children ? (\",\" + children) : '') + \")\";\n }\n // module transforms\n for (var i = 0; i < transforms$1.length; i++) {\n code = transforms$1[i](el, code);\n }\n return code\n }\n}\n\n// hoist static sub-trees out\nfunction genStatic (el) {\n el.staticProcessed = true;\n staticRenderFns.push((\"with(this){return \" + (genElement(el)) + \"}\"));\n return (\"_m(\" + (staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + \")\")\n}\n\n// v-once\nfunction genOnce (el) {\n el.onceProcessed = true;\n if (el.if && !el.ifProcessed) {\n return genIf(el)\n } else if (el.staticInFor) {\n var key = '';\n var parent = el.parent;\n while (parent) {\n if (parent.for) {\n key = parent.key;\n break\n }\n parent = parent.parent;\n }\n if (!key) {\n \"production\" !== 'production' && warn$2(\n \"v-once can only be used inside v-for that is keyed. \"\n );\n return genElement(el)\n }\n return (\"_o(\" + (genElement(el)) + \",\" + (onceCount++) + (key ? (\",\" + key) : \"\") + \")\")\n } else {\n return genStatic(el)\n }\n}\n\nfunction genIf (el) {\n el.ifProcessed = true; // avoid recursion\n return genIfConditions(el.ifConditions.slice())\n}\n\nfunction genIfConditions (conditions) {\n if (!conditions.length) {\n return '_e()'\n }\n\n var condition = conditions.shift();\n if (condition.exp) {\n return (\"(\" + (condition.exp) + \")?\" + (genTernaryExp(condition.block)) + \":\" + (genIfConditions(conditions)))\n } else {\n return (\"\" + (genTernaryExp(condition.block)))\n }\n\n // v-if with v-once should generate code like (a)?_m(0):_m(1)\n function genTernaryExp (el) {\n return el.once ? genOnce(el) : genElement(el)\n }\n}\n\nfunction genFor (el) {\n var exp = el.for;\n var alias = el.alias;\n var iterator1 = el.iterator1 ? (\",\" + (el.iterator1)) : '';\n var iterator2 = el.iterator2 ? (\",\" + (el.iterator2)) : '';\n el.forProcessed = true; // avoid recursion\n return \"_l((\" + exp + \"),\" +\n \"function(\" + alias + iterator1 + iterator2 + \"){\" +\n \"return \" + (genElement(el)) +\n '})'\n}\n\nfunction genData (el) {\n var data = '{';\n\n // directives first.\n // directives may mutate the el's other properties before they are generated.\n var dirs = genDirectives(el);\n if (dirs) { data += dirs + ','; }\n\n // key\n if (el.key) {\n data += \"key:\" + (el.key) + \",\";\n }\n // ref\n if (el.ref) {\n data += \"ref:\" + (el.ref) + \",\";\n }\n if (el.refInFor) {\n data += \"refInFor:true,\";\n }\n // pre\n if (el.pre) {\n data += \"pre:true,\";\n }\n // record original tag name for components using \"is\" attribute\n if (el.component) {\n data += \"tag:\\\"\" + (el.tag) + \"\\\",\";\n }\n // module data generation functions\n for (var i = 0; i < dataGenFns.length; i++) {\n data += dataGenFns[i](el);\n }\n // attributes\n if (el.attrs) {\n data += \"attrs:{\" + (genProps(el.attrs)) + \"},\";\n }\n // DOM props\n if (el.props) {\n data += \"domProps:{\" + (genProps(el.props)) + \"},\";\n }\n // event handlers\n if (el.events) {\n data += (genHandlers(el.events)) + \",\";\n }\n if (el.nativeEvents) {\n data += (genHandlers(el.nativeEvents, true)) + \",\";\n }\n // slot target\n if (el.slotTarget) {\n data += \"slot:\" + (el.slotTarget) + \",\";\n }\n // scoped slots\n if (el.scopedSlots) {\n data += (genScopedSlots(el.scopedSlots)) + \",\";\n }\n // inline-template\n if (el.inlineTemplate) {\n var inlineTemplate = genInlineTemplate(el);\n if (inlineTemplate) {\n data += inlineTemplate + \",\";\n }\n }\n data = data.replace(/,$/, '') + '}';\n // v-bind data wrap\n if (el.wrapData) {\n data = el.wrapData(data);\n }\n return data\n}\n\nfunction genDirectives (el) {\n var dirs = el.directives;\n if (!dirs) { return }\n var res = 'directives:[';\n var hasRuntime = false;\n var i, l, dir, needRuntime;\n for (i = 0, l = dirs.length; i < l; i++) {\n dir = dirs[i];\n needRuntime = true;\n var gen = platformDirectives$1[dir.name] || baseDirectives[dir.name];\n if (gen) {\n // compile-time directive that manipulates AST.\n // returns true if it also needs a runtime counterpart.\n needRuntime = !!gen(el, dir, warn$2);\n }\n if (needRuntime) {\n hasRuntime = true;\n res += \"{name:\\\"\" + (dir.name) + \"\\\",rawName:\\\"\" + (dir.rawName) + \"\\\"\" + (dir.value ? (\",value:(\" + (dir.value) + \"),expression:\" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (\",arg:\\\"\" + (dir.arg) + \"\\\"\") : '') + (dir.modifiers ? (\",modifiers:\" + (JSON.stringify(dir.modifiers))) : '') + \"},\";\n }\n }\n if (hasRuntime) {\n return res.slice(0, -1) + ']'\n }\n}\n\nfunction genInlineTemplate (el) {\n var ast = el.children[0];\n if (false) {\n warn$2('Inline-template components must have exactly one child element.');\n }\n if (ast.type === 1) {\n var inlineRenderFns = generate(ast, currentOptions);\n return (\"inlineTemplate:{render:function(){\" + (inlineRenderFns.render) + \"},staticRenderFns:[\" + (inlineRenderFns.staticRenderFns.map(function (code) { return (\"function(){\" + code + \"}\"); }).join(',')) + \"]}\")\n }\n}\n\nfunction genScopedSlots (slots) {\n return (\"scopedSlots:{\" + (Object.keys(slots).map(function (key) { return genScopedSlot(key, slots[key]); }).join(',')) + \"}\")\n}\n\nfunction genScopedSlot (key, el) {\n return key + \":function(\" + (String(el.attrsMap.scope)) + \"){\" +\n \"return \" + (el.tag === 'template'\n ? genChildren(el) || 'void 0'\n : genElement(el)) + \"}\"\n}\n\nfunction genChildren (el, checkSkip) {\n var children = el.children;\n if (children.length) {\n var el$1 = children[0];\n // optimize single v-for\n if (children.length === 1 &&\n el$1.for &&\n el$1.tag !== 'template' &&\n el$1.tag !== 'slot') {\n return genElement(el$1)\n }\n var normalizationType = getNormalizationType(children);\n return (\"[\" + (children.map(genNode).join(',')) + \"]\" + (checkSkip\n ? normalizationType ? (\",\" + normalizationType) : ''\n : ''))\n }\n}\n\n// determine the normalization needed for the children array.\n// 0: no normalization needed\n// 1: simple normalization needed (possible 1-level deep nested array)\n// 2: full normalization needed\nfunction getNormalizationType (children) {\n var res = 0;\n for (var i = 0; i < children.length; i++) {\n var el = children[i];\n if (el.type !== 1) {\n continue\n }\n if (needsNormalization(el) ||\n (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {\n res = 2;\n break\n }\n if (maybeComponent(el) ||\n (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {\n res = 1;\n }\n }\n return res\n}\n\nfunction needsNormalization (el) {\n return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'\n}\n\nfunction maybeComponent (el) {\n return !isPlatformReservedTag$1(el.tag)\n}\n\nfunction genNode (node) {\n if (node.type === 1) {\n return genElement(node)\n } else {\n return genText(node)\n }\n}\n\nfunction genText (text) {\n return (\"_v(\" + (text.type === 2\n ? text.expression // no need for () because already wrapped in _s()\n : transformSpecialNewlines(JSON.stringify(text.text))) + \")\")\n}\n\nfunction genSlot (el) {\n var slotName = el.slotName || '\"default\"';\n var children = genChildren(el);\n var res = \"_t(\" + slotName + (children ? (\",\" + children) : '');\n var attrs = el.attrs && (\"{\" + (el.attrs.map(function (a) { return ((camelize(a.name)) + \":\" + (a.value)); }).join(',')) + \"}\");\n var bind$$1 = el.attrsMap['v-bind'];\n if ((attrs || bind$$1) && !children) {\n res += \",null\";\n }\n if (attrs) {\n res += \",\" + attrs;\n }\n if (bind$$1) {\n res += (attrs ? '' : ',null') + \",\" + bind$$1;\n }\n return res + ')'\n}\n\n// componentName is el.component, take it as argument to shun flow's pessimistic refinement\nfunction genComponent (componentName, el) {\n var children = el.inlineTemplate ? null : genChildren(el, true);\n return (\"_c(\" + componentName + \",\" + (genData(el)) + (children ? (\",\" + children) : '') + \")\")\n}\n\nfunction genProps (props) {\n var res = '';\n for (var i = 0; i < props.length; i++) {\n var prop = props[i];\n res += \"\\\"\" + (prop.name) + \"\\\":\" + (transformSpecialNewlines(prop.value)) + \",\";\n }\n return res.slice(0, -1)\n}\n\n// #3895, #4268\nfunction transformSpecialNewlines (text) {\n return text\n .replace(/\\u2028/g, '\\\\u2028')\n .replace(/\\u2029/g, '\\\\u2029')\n}\n\n/* */\n\n/**\n * Compile a template.\n */\nfunction compile$1 (\n template,\n options\n) {\n var ast = parse(template.trim(), options);\n optimize(ast, options);\n var code = generate(ast, options);\n return {\n ast: ast,\n render: code.render,\n staticRenderFns: code.staticRenderFns\n }\n}\n\n/* */\n\n// operators like typeof, instanceof and in are allowed\nvar prohibitedKeywordRE = new RegExp('\\\\b' + (\n 'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +\n 'super,throw,while,yield,delete,export,import,return,switch,default,' +\n 'extends,finally,continue,debugger,function,arguments'\n).split(',').join('\\\\b|\\\\b') + '\\\\b');\n// check valid identifier for v-for\nvar identRE = /[A-Za-z_$][\\w$]*/;\n// strip strings in expressions\nvar stripStringRE = /'(?:[^'\\\\]|\\\\.)*'|\"(?:[^\"\\\\]|\\\\.)*\"|`(?:[^`\\\\]|\\\\.)*\\$\\{|\\}(?:[^`\\\\]|\\\\.)*`|`(?:[^`\\\\]|\\\\.)*`/g;\n\n// detect problematic expressions in a template\nfunction detectErrors (ast) {\n var errors = [];\n if (ast) {\n checkNode(ast, errors);\n }\n return errors\n}\n\nfunction checkNode (node, errors) {\n if (node.type === 1) {\n for (var name in node.attrsMap) {\n if (dirRE.test(name)) {\n var value = node.attrsMap[name];\n if (value) {\n if (name === 'v-for') {\n checkFor(node, (\"v-for=\\\"\" + value + \"\\\"\"), errors);\n } else {\n checkExpression(value, (name + \"=\\\"\" + value + \"\\\"\"), errors);\n }\n }\n }\n }\n if (node.children) {\n for (var i = 0; i < node.children.length; i++) {\n checkNode(node.children[i], errors);\n }\n }\n } else if (node.type === 2) {\n checkExpression(node.expression, node.text, errors);\n }\n}\n\nfunction checkFor (node, text, errors) {\n checkExpression(node.for || '', text, errors);\n checkIdentifier(node.alias, 'v-for alias', text, errors);\n checkIdentifier(node.iterator1, 'v-for iterator', text, errors);\n checkIdentifier(node.iterator2, 'v-for iterator', text, errors);\n}\n\nfunction checkIdentifier (ident, type, text, errors) {\n if (typeof ident === 'string' && !identRE.test(ident)) {\n errors.push((\"- invalid \" + type + \" \\\"\" + ident + \"\\\" in expression: \" + text));\n }\n}\n\nfunction checkExpression (exp, text, errors) {\n try {\n new Function((\"return \" + exp));\n } catch (e) {\n var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);\n if (keywordMatch) {\n errors.push(\n \"- avoid using JavaScript keyword as property name: \" +\n \"\\\"\" + (keywordMatch[0]) + \"\\\" in expression \" + text\n );\n } else {\n errors.push((\"- invalid expression: \" + text));\n }\n }\n}\n\n/* */\n\nfunction transformNode (el, options) {\n var warn = options.warn || baseWarn;\n var staticClass = getAndRemoveAttr(el, 'class');\n if (false) {\n var expression = parseText(staticClass, options.delimiters);\n if (expression) {\n warn(\n \"class=\\\"\" + staticClass + \"\\\": \" +\n 'Interpolation inside attributes has been removed. ' +\n 'Use v-bind or the colon shorthand instead. For example, ' +\n 'instead of <div class=\"{{ val }}\">, use <div :class=\"val\">.'\n );\n }\n }\n if (staticClass) {\n el.staticClass = JSON.stringify(staticClass);\n }\n var classBinding = getBindingAttr(el, 'class', false /* getStatic */);\n if (classBinding) {\n el.classBinding = classBinding;\n }\n}\n\nfunction genData$1 (el) {\n var data = '';\n if (el.staticClass) {\n data += \"staticClass:\" + (el.staticClass) + \",\";\n }\n if (el.classBinding) {\n data += \"class:\" + (el.classBinding) + \",\";\n }\n return data\n}\n\nvar klass$1 = {\n staticKeys: ['staticClass'],\n transformNode: transformNode,\n genData: genData$1\n};\n\n/* */\n\nfunction transformNode$1 (el, options) {\n var warn = options.warn || baseWarn;\n var staticStyle = getAndRemoveAttr(el, 'style');\n if (staticStyle) {\n /* istanbul ignore if */\n if (false) {\n var expression = parseText(staticStyle, options.delimiters);\n if (expression) {\n warn(\n \"style=\\\"\" + staticStyle + \"\\\": \" +\n 'Interpolation inside attributes has been removed. ' +\n 'Use v-bind or the colon shorthand instead. For example, ' +\n 'instead of <div style=\"{{ val }}\">, use <div :style=\"val\">.'\n );\n }\n }\n el.staticStyle = JSON.stringify(parseStyleText(staticStyle));\n }\n\n var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);\n if (styleBinding) {\n el.styleBinding = styleBinding;\n }\n}\n\nfunction genData$2 (el) {\n var data = '';\n if (el.staticStyle) {\n data += \"staticStyle:\" + (el.staticStyle) + \",\";\n }\n if (el.styleBinding) {\n data += \"style:(\" + (el.styleBinding) + \"),\";\n }\n return data\n}\n\nvar style$1 = {\n staticKeys: ['staticStyle'],\n transformNode: transformNode$1,\n genData: genData$2\n};\n\nvar modules$1 = [\n klass$1,\n style$1\n];\n\n/* */\n\nvar warn$3;\n\nfunction model$1 (\n el,\n dir,\n _warn\n) {\n warn$3 = _warn;\n var value = dir.value;\n var modifiers = dir.modifiers;\n var tag = el.tag;\n var type = el.attrsMap.type;\n if (false) {\n var dynamicType = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];\n if (tag === 'input' && dynamicType) {\n warn$3(\n \"<input :type=\\\"\" + dynamicType + \"\\\" v-model=\\\"\" + value + \"\\\">:\\n\" +\n \"v-model does not support dynamic input types. Use v-if branches instead.\"\n );\n }\n }\n if (tag === 'select') {\n genSelect(el, value, modifiers);\n } else if (tag === 'input' && type === 'checkbox') {\n genCheckboxModel(el, value, modifiers);\n } else if (tag === 'input' && type === 'radio') {\n genRadioModel(el, value, modifiers);\n } else {\n genDefaultModel(el, value, modifiers);\n }\n // ensure runtime directive metadata\n return true\n}\n\nfunction genCheckboxModel (\n el,\n value,\n modifiers\n) {\n if (false) {\n warn$3(\n \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" checked>:\\n\" +\n \"inline checked attributes will be ignored when using v-model. \" +\n 'Declare initial values in the component\\'s data option instead.'\n );\n }\n var number = modifiers && modifiers.number;\n var valueBinding = getBindingAttr(el, 'value') || 'null';\n var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';\n var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';\n addProp(el, 'checked',\n \"Array.isArray(\" + value + \")\" +\n \"?_i(\" + value + \",\" + valueBinding + \")>-1\" + (\n trueValueBinding === 'true'\n ? (\":(\" + value + \")\")\n : (\":_q(\" + value + \",\" + trueValueBinding + \")\")\n )\n );\n addHandler(el, 'click',\n \"var $$a=\" + value + \",\" +\n '$$el=$event.target,' +\n \"$$c=$$el.checked?(\" + trueValueBinding + \"):(\" + falseValueBinding + \");\" +\n 'if(Array.isArray($$a)){' +\n \"var $$v=\" + (number ? '_n(' + valueBinding + ')' : valueBinding) + \",\" +\n '$$i=_i($$a,$$v);' +\n \"if($$c){$$i<0&&(\" + value + \"=$$a.concat($$v))}\" +\n \"else{$$i>-1&&(\" + value + \"=$$a.slice(0,$$i).concat($$a.slice($$i+1)))}\" +\n \"}else{\" + value + \"=$$c}\",\n null, true\n );\n}\n\nfunction genRadioModel (\n el,\n value,\n modifiers\n) {\n if (false) {\n warn$3(\n \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" checked>:\\n\" +\n \"inline checked attributes will be ignored when using v-model. \" +\n 'Declare initial values in the component\\'s data option instead.'\n );\n }\n var number = modifiers && modifiers.number;\n var valueBinding = getBindingAttr(el, 'value') || 'null';\n valueBinding = number ? (\"_n(\" + valueBinding + \")\") : valueBinding;\n addProp(el, 'checked', (\"_q(\" + value + \",\" + valueBinding + \")\"));\n addHandler(el, 'click', genAssignmentCode(value, valueBinding), null, true);\n}\n\nfunction genDefaultModel (\n el,\n value,\n modifiers\n) {\n if (false) {\n if (el.tag === 'input' && el.attrsMap.value) {\n warn$3(\n \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" value=\\\"\" + (el.attrsMap.value) + \"\\\">:\\n\" +\n 'inline value attributes will be ignored when using v-model. ' +\n 'Declare initial values in the component\\'s data option instead.'\n );\n }\n if (el.tag === 'textarea' && el.children.length) {\n warn$3(\n \"<textarea v-model=\\\"\" + value + \"\\\">:\\n\" +\n 'inline content inside <textarea> will be ignored when using v-model. ' +\n 'Declare initial values in the component\\'s data option instead.'\n );\n }\n }\n\n var type = el.attrsMap.type;\n var ref = modifiers || {};\n var lazy = ref.lazy;\n var number = ref.number;\n var trim = ref.trim;\n var event = lazy || (isIE && type === 'range') ? 'change' : 'input';\n var needCompositionGuard = !lazy && type !== 'range';\n var isNative = el.tag === 'input' || el.tag === 'textarea';\n\n var valueExpression = isNative\n ? (\"$event.target.value\" + (trim ? '.trim()' : ''))\n : trim ? \"(typeof $event === 'string' ? $event.trim() : $event)\" : \"$event\";\n valueExpression = number || type === 'number'\n ? (\"_n(\" + valueExpression + \")\")\n : valueExpression;\n\n var code = genAssignmentCode(value, valueExpression);\n if (isNative && needCompositionGuard) {\n code = \"if($event.target.composing)return;\" + code;\n }\n\n // inputs with type=\"file\" are read only and setting the input's\n // value will throw an error.\n if (false) {\n warn$3(\n \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" type=\\\"file\\\">:\\n\" +\n \"File inputs are read only. Use a v-on:change listener instead.\"\n );\n }\n\n addProp(el, 'value', isNative ? (\"_s(\" + value + \")\") : (\"(\" + value + \")\"));\n addHandler(el, event, code, null, true);\n if (trim || number || type === 'number') {\n addHandler(el, 'blur', '$forceUpdate()');\n }\n}\n\nfunction genSelect (\n el,\n value,\n modifiers\n) {\n if (false) {\n el.children.some(checkOptionWarning);\n }\n\n var number = modifiers && modifiers.number;\n var assignment = \"Array.prototype.filter\" +\n \".call($event.target.options,function(o){return o.selected})\" +\n \".map(function(o){var val = \\\"_value\\\" in o ? o._value : o.value;\" +\n \"return \" + (number ? '_n(val)' : 'val') + \"})\" +\n (el.attrsMap.multiple == null ? '[0]' : '');\n\n var code = genAssignmentCode(value, assignment);\n addHandler(el, 'change', code, null, true);\n}\n\nfunction checkOptionWarning (option) {\n if (option.type === 1 &&\n option.tag === 'option' &&\n option.attrsMap.selected != null) {\n warn$3(\n \"<select v-model=\\\"\" + (option.parent.attrsMap['v-model']) + \"\\\">:\\n\" +\n 'inline selected attributes on <option> will be ignored when using v-model. ' +\n 'Declare initial values in the component\\'s data option instead.'\n );\n return true\n }\n return false\n}\n\nfunction genAssignmentCode (value, assignment) {\n var modelRs = parseModel(value);\n if (modelRs.idx === null) {\n return (value + \"=\" + assignment)\n } else {\n return \"var $$exp = \" + (modelRs.exp) + \", $$idx = \" + (modelRs.idx) + \";\" +\n \"if (!Array.isArray($$exp)){\" +\n value + \"=\" + assignment + \"}\" +\n \"else{$$exp.splice($$idx, 1, \" + assignment + \")}\"\n }\n}\n\n/* */\n\nfunction text (el, dir) {\n if (dir.value) {\n addProp(el, 'textContent', (\"_s(\" + (dir.value) + \")\"));\n }\n}\n\n/* */\n\nfunction html (el, dir) {\n if (dir.value) {\n addProp(el, 'innerHTML', (\"_s(\" + (dir.value) + \")\"));\n }\n}\n\nvar directives$1 = {\n model: model$1,\n text: text,\n html: html\n};\n\n/* */\n\nvar cache = Object.create(null);\n\nvar baseOptions = {\n expectHTML: true,\n modules: modules$1,\n staticKeys: genStaticKeys(modules$1),\n directives: directives$1,\n isReservedTag: isReservedTag,\n isUnaryTag: isUnaryTag,\n mustUseProp: mustUseProp,\n getTagNamespace: getTagNamespace,\n isPreTag: isPreTag\n};\n\nfunction compile$$1 (\n template,\n options\n) {\n options = options\n ? extend(extend({}, baseOptions), options)\n : baseOptions;\n return compile$1(template, options)\n}\n\nfunction compileToFunctions (\n template,\n options,\n vm\n) {\n var _warn = (options && options.warn) || warn;\n // detect possible CSP restriction\n /* istanbul ignore if */\n if (false) {\n try {\n new Function('return 1');\n } catch (e) {\n if (e.toString().match(/unsafe-eval|CSP/)) {\n _warn(\n 'It seems you are using the standalone build of Vue.js in an ' +\n 'environment with Content Security Policy that prohibits unsafe-eval. ' +\n 'The template compiler cannot work in this environment. Consider ' +\n 'relaxing the policy to allow unsafe-eval or pre-compiling your ' +\n 'templates into render functions.'\n );\n }\n }\n }\n var key = options && options.delimiters\n ? String(options.delimiters) + template\n : template;\n if (cache[key]) {\n return cache[key]\n }\n var res = {};\n var compiled = compile$$1(template, options);\n res.render = makeFunction(compiled.render);\n var l = compiled.staticRenderFns.length;\n res.staticRenderFns = new Array(l);\n for (var i = 0; i < l; i++) {\n res.staticRenderFns[i] = makeFunction(compiled.staticRenderFns[i]);\n }\n if (false) {\n if (res.render === noop || res.staticRenderFns.some(function (fn) { return fn === noop; })) {\n _warn(\n \"failed to compile template:\\n\\n\" + template + \"\\n\\n\" +\n detectErrors(compiled.ast).join('\\n') +\n '\\n\\n',\n vm\n );\n }\n }\n return (cache[key] = res)\n}\n\nfunction makeFunction (code) {\n try {\n return new Function(code)\n } catch (e) {\n return noop\n }\n}\n\n/* */\n\nvar idToTemplate = cached(function (id) {\n var el = query(id);\n return el && el.innerHTML\n});\n\nvar mount = Vue$3.prototype.$mount;\nVue$3.prototype.$mount = function (\n el,\n hydrating\n) {\n el = el && query(el);\n\n /* istanbul ignore if */\n if (el === document.body || el === document.documentElement) {\n \"production\" !== 'production' && warn(\n \"Do not mount Vue to <html> or <body> - mount to normal elements instead.\"\n );\n return this\n }\n\n var options = this.$options;\n // resolve template/el and convert to render function\n if (!options.render) {\n var template = options.template;\n if (template) {\n if (typeof template === 'string') {\n if (template.charAt(0) === '#') {\n template = idToTemplate(template);\n /* istanbul ignore if */\n if (false) {\n warn(\n (\"Template element not found or is empty: \" + (options.template)),\n this\n );\n }\n }\n } else if (template.nodeType) {\n template = template.innerHTML;\n } else {\n if (false) {\n warn('invalid template option:' + template, this);\n }\n return this\n }\n } else if (el) {\n template = getOuterHTML(el);\n }\n if (template) {\n var ref = compileToFunctions(template, {\n warn: warn,\n shouldDecodeNewlines: shouldDecodeNewlines,\n delimiters: options.delimiters\n }, this);\n var render = ref.render;\n var staticRenderFns = ref.staticRenderFns;\n options.render = render;\n options.staticRenderFns = staticRenderFns;\n }\n }\n return mount.call(this, el, hydrating)\n};\n\n/**\n * Get outerHTML of elements, taking care\n * of SVG elements in IE as well.\n */\nfunction getOuterHTML (el) {\n if (el.outerHTML) {\n return el.outerHTML\n } else {\n var container = document.createElement('div');\n container.appendChild(el.cloneNode(true));\n return container.innerHTML\n }\n}\n\nVue$3.compile = compileToFunctions;\n\nmodule.exports = Vue$3;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(90)))\n\n/***/ }),\n/* 18 */\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/* 19 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// optional / simple context binding\nvar aFunction = __webpack_require__(43);\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/* 20 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar isObject = __webpack_require__(12)\n , document = __webpack_require__(2).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/* 21 */\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/* 22 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar global = __webpack_require__(2)\n , core = __webpack_require__(10)\n , ctx = __webpack_require__(19)\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/* 23 */\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/* 24 */\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/* 25 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar global = __webpack_require__(2)\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/* 26 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// to indexed object, toObject with fallback for non-array-like ES3 strings\nvar IObject = __webpack_require__(49)\n , defined = __webpack_require__(11);\nmodule.exports = function(it){\n return IObject(defined(it));\n};\n\n/***/ }),\n/* 27 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// 7.1.15 ToLength\nvar toInteger = __webpack_require__(16)\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/* 28 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// 7.1.13 ToObject(argument)\nvar defined = __webpack_require__(11);\nmodule.exports = function(it){\n return Object(defined(it));\n};\n\n/***/ }),\n/* 29 */\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/* 30 */,\n/* 31 */,\n/* 32 */,\n/* 33 */,\n/* 34 */,\n/* 35 */,\n/* 36 */,\n/* 37 */,\n/* 38 */,\n/* 39 */,\n/* 40 */\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = { \"default\": __webpack_require__(42), __esModule: true };\n\n/***/ }),\n/* 41 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nexports.__esModule = true;\n\nvar _from = __webpack_require__(40);\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/* 42 */\n/***/ (function(module, exports, __webpack_require__) {\n\n__webpack_require__(67);\n__webpack_require__(66);\nmodule.exports = __webpack_require__(10).Array.from;\n\n/***/ }),\n/* 43 */\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/* 44 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// false -> Array#indexOf\n// true -> Array#includes\nvar toIObject = __webpack_require__(26)\n , toLength = __webpack_require__(27)\n , toIndex = __webpack_require__(63);\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/* 45 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// getting tag from 19.1.3.6 Object.prototype.toString()\nvar cof = __webpack_require__(18)\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/* 46 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar $defineProperty = __webpack_require__(7)\n , createDesc = __webpack_require__(14);\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/* 47 */\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = __webpack_require__(2).document && document.documentElement;\n\n/***/ }),\n/* 48 */\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = !__webpack_require__(4) && !__webpack_require__(23)(function(){\n return Object.defineProperty(__webpack_require__(20)('div'), 'a', {get: function(){ return 7; }}).a != 7;\n});\n\n/***/ }),\n/* 49 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nvar cof = __webpack_require__(18);\nmodule.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){\n return cof(it) == 'String' ? it.split('') : Object(it);\n};\n\n/***/ }),\n/* 50 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// check on default Array iterator\nvar Iterators = __webpack_require__(13)\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/* 51 */\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/* 52 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar create = __webpack_require__(56)\n , descriptor = __webpack_require__(14)\n , setToStringTag = __webpack_require__(24)\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/* 53 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar LIBRARY = __webpack_require__(55)\n , $export = __webpack_require__(22)\n , redefine = __webpack_require__(61)\n , hide = __webpack_require__(6)\n , has = __webpack_require__(5)\n , Iterators = __webpack_require__(13)\n , $iterCreate = __webpack_require__(52)\n , setToStringTag = __webpack_require__(24)\n , getPrototypeOf = __webpack_require__(58)\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/* 54 */\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/* 55 */\n/***/ (function(module, exports) {\n\nmodule.exports = true;\n\n/***/ }),\n/* 56 */\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__(57)\n , enumBugKeys = __webpack_require__(21)\n , IE_PROTO = __webpack_require__(15)('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__(20)('iframe')\n , i = enumBugKeys.length\n , lt = '<'\n , gt = '>'\n , iframeDocument;\n iframe.style.display = 'none';\n __webpack_require__(47).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/* 57 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar dP = __webpack_require__(7)\n , anObject = __webpack_require__(3)\n , getKeys = __webpack_require__(60);\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/* 58 */\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__(28)\n , IE_PROTO = __webpack_require__(15)('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/* 59 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar has = __webpack_require__(5)\n , toIObject = __webpack_require__(26)\n , arrayIndexOf = __webpack_require__(44)(false)\n , IE_PROTO = __webpack_require__(15)('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/* 60 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// 19.1.2.14 / 15.2.3.14 Object.keys(O)\nvar $keys = __webpack_require__(59)\n , enumBugKeys = __webpack_require__(21);\n\nmodule.exports = Object.keys || function keys(O){\n return $keys(O, enumBugKeys);\n};\n\n/***/ }),\n/* 61 */\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = __webpack_require__(6);\n\n/***/ }),\n/* 62 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar toInteger = __webpack_require__(16)\n , defined = __webpack_require__(11);\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/* 63 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar toInteger = __webpack_require__(16)\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/* 64 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// 7.1.1 ToPrimitive(input [, PreferredType])\nvar isObject = __webpack_require__(12);\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/* 65 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar classof = __webpack_require__(45)\n , ITERATOR = __webpack_require__(0)('iterator')\n , Iterators = __webpack_require__(13);\nmodule.exports = __webpack_require__(10).getIteratorMethod = function(it){\n if(it != undefined)return it[ITERATOR]\n || it['@@iterator']\n || Iterators[classof(it)];\n};\n\n/***/ }),\n/* 66 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar ctx = __webpack_require__(19)\n , $export = __webpack_require__(22)\n , toObject = __webpack_require__(28)\n , call = __webpack_require__(51)\n , isArrayIter = __webpack_require__(50)\n , toLength = __webpack_require__(27)\n , createProperty = __webpack_require__(46)\n , getIterFn = __webpack_require__(65);\n\n$export($export.S + $export.F * !__webpack_require__(54)(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/* 67 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar $at = __webpack_require__(62)(true);\n\n// 21.1.3.27 String.prototype[@@iterator]()\n__webpack_require__(53)(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/* 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/* 81 */,\n/* 82 */,\n/* 83 */,\n/* 84 */,\n/* 85 */,\n/* 86 */,\n/* 87 */,\n/* 88 */\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/* 89 */\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/* 90 */\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/* 91 */,\n/* 92 */\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/* 93 */\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__(89)\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.68e97f3128ceb6fa491d.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","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 = 1\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 = 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","// 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 = 8\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 = 10\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 = 11\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 = 12\n// module chunks = 0","module.exports = {};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iterators.js\n// module id = 13\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 = 14\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 = 15\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 = 16\n// module chunks = 0","/*!\n * Vue.js v2.1.10\n * (c) 2014-2017 Evan You\n * Released under the MIT License.\n */\n'use strict';\n\n/* */\n\n/**\n * Convert a value to a string that is actually rendered.\n */\nfunction _toString (val) {\n return val == null\n ? ''\n : typeof val === 'object'\n ? JSON.stringify(val, null, 2)\n : String(val)\n}\n\n/**\n * Convert a input value to a number for persistence.\n * If the conversion fails, return original string.\n */\nfunction toNumber (val) {\n var n = parseFloat(val);\n return isNaN(n) ? val : n\n}\n\n/**\n * Make a map and return a function for checking if a key\n * is in that map.\n */\nfunction makeMap (\n str,\n expectsLowerCase\n) {\n var map = Object.create(null);\n var list = str.split(',');\n for (var i = 0; i < list.length; i++) {\n map[list[i]] = true;\n }\n return expectsLowerCase\n ? function (val) { return map[val.toLowerCase()]; }\n : function (val) { return map[val]; }\n}\n\n/**\n * Check if a tag is a built-in tag.\n */\nvar isBuiltInTag = makeMap('slot,component', true);\n\n/**\n * Remove an item from an array\n */\nfunction remove$1 (arr, item) {\n if (arr.length) {\n var index = arr.indexOf(item);\n if (index > -1) {\n return arr.splice(index, 1)\n }\n }\n}\n\n/**\n * Check whether the object has the property.\n */\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction hasOwn (obj, key) {\n return hasOwnProperty.call(obj, key)\n}\n\n/**\n * Check if value is primitive\n */\nfunction isPrimitive (value) {\n return typeof value === 'string' || typeof value === 'number'\n}\n\n/**\n * Create a cached version of a pure function.\n */\nfunction cached (fn) {\n var cache = Object.create(null);\n return (function cachedFn (str) {\n var hit = cache[str];\n return hit || (cache[str] = fn(str))\n })\n}\n\n/**\n * Camelize a hyphen-delimited string.\n */\nvar camelizeRE = /-(\\w)/g;\nvar camelize = cached(function (str) {\n return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })\n});\n\n/**\n * Capitalize a string.\n */\nvar capitalize = cached(function (str) {\n return str.charAt(0).toUpperCase() + str.slice(1)\n});\n\n/**\n * Hyphenate a camelCase string.\n */\nvar hyphenateRE = /([^-])([A-Z])/g;\nvar hyphenate = cached(function (str) {\n return str\n .replace(hyphenateRE, '$1-$2')\n .replace(hyphenateRE, '$1-$2')\n .toLowerCase()\n});\n\n/**\n * Simple bind, faster than native\n */\nfunction bind$1 (fn, ctx) {\n function boundFn (a) {\n var l = arguments.length;\n return l\n ? l > 1\n ? fn.apply(ctx, arguments)\n : fn.call(ctx, a)\n : fn.call(ctx)\n }\n // record original fn length\n boundFn._length = fn.length;\n return boundFn\n}\n\n/**\n * Convert an Array-like object to a real Array.\n */\nfunction toArray (list, start) {\n start = start || 0;\n var i = list.length - start;\n var ret = new Array(i);\n while (i--) {\n ret[i] = list[i + start];\n }\n return ret\n}\n\n/**\n * Mix properties into target object.\n */\nfunction extend (to, _from) {\n for (var key in _from) {\n to[key] = _from[key];\n }\n return to\n}\n\n/**\n * Quick object check - this is primarily used to tell\n * Objects from primitive values when we know the value\n * is a JSON-compliant type.\n */\nfunction isObject (obj) {\n return obj !== null && typeof obj === 'object'\n}\n\n/**\n * Strict object type check. Only returns true\n * for plain JavaScript objects.\n */\nvar toString = Object.prototype.toString;\nvar OBJECT_STRING = '[object Object]';\nfunction isPlainObject (obj) {\n return toString.call(obj) === OBJECT_STRING\n}\n\n/**\n * Merge an Array of Objects into a single Object.\n */\nfunction toObject (arr) {\n var res = {};\n for (var i = 0; i < arr.length; i++) {\n if (arr[i]) {\n extend(res, arr[i]);\n }\n }\n return res\n}\n\n/**\n * Perform no operation.\n */\nfunction noop () {}\n\n/**\n * Always return false.\n */\nvar no = function () { return false; };\n\n/**\n * Return same value\n */\nvar identity = function (_) { return _; };\n\n/**\n * Generate a static keys string from compiler modules.\n */\nfunction genStaticKeys (modules) {\n return modules.reduce(function (keys, m) {\n return keys.concat(m.staticKeys || [])\n }, []).join(',')\n}\n\n/**\n * Check if two values are loosely equal - that is,\n * if they are plain objects, do they have the same shape?\n */\nfunction looseEqual (a, b) {\n var isObjectA = isObject(a);\n var isObjectB = isObject(b);\n if (isObjectA && isObjectB) {\n return JSON.stringify(a) === JSON.stringify(b)\n } else if (!isObjectA && !isObjectB) {\n return String(a) === String(b)\n } else {\n return false\n }\n}\n\nfunction looseIndexOf (arr, val) {\n for (var i = 0; i < arr.length; i++) {\n if (looseEqual(arr[i], val)) { return i }\n }\n return -1\n}\n\n/* */\n\nvar config = {\n /**\n * Option merge strategies (used in core/util/options)\n */\n optionMergeStrategies: Object.create(null),\n\n /**\n * Whether to suppress warnings.\n */\n silent: false,\n\n /**\n * Whether to enable devtools\n */\n devtools: process.env.NODE_ENV !== 'production',\n\n /**\n * Error handler for watcher errors\n */\n errorHandler: null,\n\n /**\n * Ignore certain custom elements\n */\n ignoredElements: [],\n\n /**\n * Custom user key aliases for v-on\n */\n keyCodes: Object.create(null),\n\n /**\n * Check if a tag is reserved so that it cannot be registered as a\n * component. This is platform-dependent and may be overwritten.\n */\n isReservedTag: no,\n\n /**\n * Check if a tag is an unknown element.\n * Platform-dependent.\n */\n isUnknownElement: no,\n\n /**\n * Get the namespace of an element\n */\n getTagNamespace: noop,\n\n /**\n * Parse the real tag name for the specific platform.\n */\n parsePlatformTagName: identity,\n\n /**\n * Check if an attribute must be bound using property, e.g. value\n * Platform-dependent.\n */\n mustUseProp: no,\n\n /**\n * List of asset types that a component can own.\n */\n _assetTypes: [\n 'component',\n 'directive',\n 'filter'\n ],\n\n /**\n * List of lifecycle hooks.\n */\n _lifecycleHooks: [\n 'beforeCreate',\n 'created',\n 'beforeMount',\n 'mounted',\n 'beforeUpdate',\n 'updated',\n 'beforeDestroy',\n 'destroyed',\n 'activated',\n 'deactivated'\n ],\n\n /**\n * Max circular updates allowed in a scheduler flush cycle.\n */\n _maxUpdateCount: 100\n};\n\n/* */\n\n/**\n * Check if a string starts with $ or _\n */\nfunction isReserved (str) {\n var c = (str + '').charCodeAt(0);\n return c === 0x24 || c === 0x5F\n}\n\n/**\n * Define a property.\n */\nfunction def (obj, key, val, enumerable) {\n Object.defineProperty(obj, key, {\n value: val,\n enumerable: !!enumerable,\n writable: true,\n configurable: true\n });\n}\n\n/**\n * Parse simple path.\n */\nvar bailRE = /[^\\w.$]/;\nfunction parsePath (path) {\n if (bailRE.test(path)) {\n return\n } else {\n var segments = path.split('.');\n return function (obj) {\n for (var i = 0; i < segments.length; i++) {\n if (!obj) { return }\n obj = obj[segments[i]];\n }\n return obj\n }\n }\n}\n\n/* */\n/* globals MutationObserver */\n\n// can we use __proto__?\nvar hasProto = '__proto__' in {};\n\n// Browser environment sniffing\nvar inBrowser = typeof window !== 'undefined';\nvar UA = inBrowser && window.navigator.userAgent.toLowerCase();\nvar isIE = UA && /msie|trident/.test(UA);\nvar isIE9 = UA && UA.indexOf('msie 9.0') > 0;\nvar isEdge = UA && UA.indexOf('edge/') > 0;\nvar isAndroid = UA && UA.indexOf('android') > 0;\nvar isIOS = UA && /iphone|ipad|ipod|ios/.test(UA);\n\n// this needs to be lazy-evaled because vue may be required before\n// vue-server-renderer can set VUE_ENV\nvar _isServer;\nvar isServerRendering = function () {\n if (_isServer === undefined) {\n /* istanbul ignore if */\n if (!inBrowser && typeof global !== 'undefined') {\n // detect presence of vue-server-renderer and avoid\n // Webpack shimming the process\n _isServer = global['process'].env.VUE_ENV === 'server';\n } else {\n _isServer = false;\n }\n }\n return _isServer\n};\n\n// detect devtools\nvar devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;\n\n/* istanbul ignore next */\nfunction isNative (Ctor) {\n return /native code/.test(Ctor.toString())\n}\n\n/**\n * Defer a task to execute it asynchronously.\n */\nvar nextTick = (function () {\n var callbacks = [];\n var pending = false;\n var timerFunc;\n\n function nextTickHandler () {\n pending = false;\n var copies = callbacks.slice(0);\n callbacks.length = 0;\n for (var i = 0; i < copies.length; i++) {\n copies[i]();\n }\n }\n\n // the nextTick behavior leverages the microtask queue, which can be accessed\n // via either native Promise.then or MutationObserver.\n // MutationObserver has wider support, however it is seriously bugged in\n // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It\n // completely stops working after triggering a few times... so, if native\n // Promise is available, we will use it:\n /* istanbul ignore if */\n if (typeof Promise !== 'undefined' && isNative(Promise)) {\n var p = Promise.resolve();\n var logError = function (err) { console.error(err); };\n timerFunc = function () {\n p.then(nextTickHandler).catch(logError);\n // in problematic UIWebViews, Promise.then doesn't completely break, but\n // it can get stuck in a weird state where callbacks are pushed into the\n // microtask queue but the queue isn't being flushed, until the browser\n // needs to do some other work, e.g. handle a timer. Therefore we can\n // \"force\" the microtask queue to be flushed by adding an empty timer.\n if (isIOS) { setTimeout(noop); }\n };\n } else if (typeof MutationObserver !== 'undefined' && (\n isNative(MutationObserver) ||\n // PhantomJS and iOS 7.x\n MutationObserver.toString() === '[object MutationObserverConstructor]'\n )) {\n // use MutationObserver where native Promise is not available,\n // e.g. PhantomJS IE11, iOS7, Android 4.4\n var counter = 1;\n var observer = new MutationObserver(nextTickHandler);\n var textNode = document.createTextNode(String(counter));\n observer.observe(textNode, {\n characterData: true\n });\n timerFunc = function () {\n counter = (counter + 1) % 2;\n textNode.data = String(counter);\n };\n } else {\n // fallback to setTimeout\n /* istanbul ignore next */\n timerFunc = function () {\n setTimeout(nextTickHandler, 0);\n };\n }\n\n return function queueNextTick (cb, ctx) {\n var _resolve;\n callbacks.push(function () {\n if (cb) { cb.call(ctx); }\n if (_resolve) { _resolve(ctx); }\n });\n if (!pending) {\n pending = true;\n timerFunc();\n }\n if (!cb && typeof Promise !== 'undefined') {\n return new Promise(function (resolve) {\n _resolve = resolve;\n })\n }\n }\n})();\n\nvar _Set;\n/* istanbul ignore if */\nif (typeof Set !== 'undefined' && isNative(Set)) {\n // use native Set when available.\n _Set = Set;\n} else {\n // a non-standard Set polyfill that only works with primitive keys.\n _Set = (function () {\n function Set () {\n this.set = Object.create(null);\n }\n Set.prototype.has = function has (key) {\n return this.set[key] === true\n };\n Set.prototype.add = function add (key) {\n this.set[key] = true;\n };\n Set.prototype.clear = function clear () {\n this.set = Object.create(null);\n };\n\n return Set;\n }());\n}\n\nvar warn = noop;\nvar formatComponentName;\n\nif (process.env.NODE_ENV !== 'production') {\n var hasConsole = typeof console !== 'undefined';\n\n warn = function (msg, vm) {\n if (hasConsole && (!config.silent)) {\n console.error(\"[Vue warn]: \" + msg + \" \" + (\n vm ? formatLocation(formatComponentName(vm)) : ''\n ));\n }\n };\n\n formatComponentName = function (vm) {\n if (vm.$root === vm) {\n return 'root instance'\n }\n var name = vm._isVue\n ? vm.$options.name || vm.$options._componentTag\n : vm.name;\n return (\n (name ? (\"component <\" + name + \">\") : \"anonymous component\") +\n (vm._isVue && vm.$options.__file ? (\" at \" + (vm.$options.__file)) : '')\n )\n };\n\n var formatLocation = function (str) {\n if (str === 'anonymous component') {\n str += \" - use the \\\"name\\\" option for better debugging messages.\";\n }\n return (\"\\n(found in \" + str + \")\")\n };\n}\n\n/* */\n\n\nvar uid$1 = 0;\n\n/**\n * A dep is an observable that can have multiple\n * directives subscribing to it.\n */\nvar Dep = function Dep () {\n this.id = uid$1++;\n this.subs = [];\n};\n\nDep.prototype.addSub = function addSub (sub) {\n this.subs.push(sub);\n};\n\nDep.prototype.removeSub = function removeSub (sub) {\n remove$1(this.subs, sub);\n};\n\nDep.prototype.depend = function depend () {\n if (Dep.target) {\n Dep.target.addDep(this);\n }\n};\n\nDep.prototype.notify = function notify () {\n // stablize the subscriber list first\n var subs = this.subs.slice();\n for (var i = 0, l = subs.length; i < l; i++) {\n subs[i].update();\n }\n};\n\n// the current target watcher being evaluated.\n// this is globally unique because there could be only one\n// watcher being evaluated at any time.\nDep.target = null;\nvar targetStack = [];\n\nfunction pushTarget (_target) {\n if (Dep.target) { targetStack.push(Dep.target); }\n Dep.target = _target;\n}\n\nfunction popTarget () {\n Dep.target = targetStack.pop();\n}\n\n/*\n * not type checking this file because flow doesn't play well with\n * dynamically accessing methods on Array prototype\n */\n\nvar arrayProto = Array.prototype;\nvar arrayMethods = Object.create(arrayProto);[\n 'push',\n 'pop',\n 'shift',\n 'unshift',\n 'splice',\n 'sort',\n 'reverse'\n]\n.forEach(function (method) {\n // cache original method\n var original = arrayProto[method];\n def(arrayMethods, method, function mutator () {\n var arguments$1 = arguments;\n\n // avoid leaking arguments:\n // http://jsperf.com/closure-with-arguments\n var i = arguments.length;\n var args = new Array(i);\n while (i--) {\n args[i] = arguments$1[i];\n }\n var result = original.apply(this, args);\n var ob = this.__ob__;\n var inserted;\n switch (method) {\n case 'push':\n inserted = args;\n break\n case 'unshift':\n inserted = args;\n break\n case 'splice':\n inserted = args.slice(2);\n break\n }\n if (inserted) { ob.observeArray(inserted); }\n // notify change\n ob.dep.notify();\n return result\n });\n});\n\n/* */\n\nvar arrayKeys = Object.getOwnPropertyNames(arrayMethods);\n\n/**\n * By default, when a reactive property is set, the new value is\n * also converted to become reactive. However when passing down props,\n * we don't want to force conversion because the value may be a nested value\n * under a frozen data structure. Converting it would defeat the optimization.\n */\nvar observerState = {\n shouldConvert: true,\n isSettingProps: false\n};\n\n/**\n * Observer class that are attached to each observed\n * object. Once attached, the observer converts target\n * object's property keys into getter/setters that\n * collect dependencies and dispatches updates.\n */\nvar Observer = function Observer (value) {\n this.value = value;\n this.dep = new Dep();\n this.vmCount = 0;\n def(value, '__ob__', this);\n if (Array.isArray(value)) {\n var augment = hasProto\n ? protoAugment\n : copyAugment;\n augment(value, arrayMethods, arrayKeys);\n this.observeArray(value);\n } else {\n this.walk(value);\n }\n};\n\n/**\n * Walk through each property and convert them into\n * getter/setters. This method should only be called when\n * value type is Object.\n */\nObserver.prototype.walk = function walk (obj) {\n var keys = Object.keys(obj);\n for (var i = 0; i < keys.length; i++) {\n defineReactive$$1(obj, keys[i], obj[keys[i]]);\n }\n};\n\n/**\n * Observe a list of Array items.\n */\nObserver.prototype.observeArray = function observeArray (items) {\n for (var i = 0, l = items.length; i < l; i++) {\n observe(items[i]);\n }\n};\n\n// helpers\n\n/**\n * Augment an target Object or Array by intercepting\n * the prototype chain using __proto__\n */\nfunction protoAugment (target, src) {\n /* eslint-disable no-proto */\n target.__proto__ = src;\n /* eslint-enable no-proto */\n}\n\n/**\n * Augment an target Object or Array by defining\n * hidden properties.\n */\n/* istanbul ignore next */\nfunction copyAugment (target, src, keys) {\n for (var i = 0, l = keys.length; i < l; i++) {\n var key = keys[i];\n def(target, key, src[key]);\n }\n}\n\n/**\n * Attempt to create an observer instance for a value,\n * returns the new observer if successfully observed,\n * or the existing observer if the value already has one.\n */\nfunction observe (value, asRootData) {\n if (!isObject(value)) {\n return\n }\n var ob;\n if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {\n ob = value.__ob__;\n } else if (\n observerState.shouldConvert &&\n !isServerRendering() &&\n (Array.isArray(value) || isPlainObject(value)) &&\n Object.isExtensible(value) &&\n !value._isVue\n ) {\n ob = new Observer(value);\n }\n if (asRootData && ob) {\n ob.vmCount++;\n }\n return ob\n}\n\n/**\n * Define a reactive property on an Object.\n */\nfunction defineReactive$$1 (\n obj,\n key,\n val,\n customSetter\n) {\n var dep = new Dep();\n\n var property = Object.getOwnPropertyDescriptor(obj, key);\n if (property && property.configurable === false) {\n return\n }\n\n // cater for pre-defined getter/setters\n var getter = property && property.get;\n var setter = property && property.set;\n\n var childOb = observe(val);\n Object.defineProperty(obj, key, {\n enumerable: true,\n configurable: true,\n get: function reactiveGetter () {\n var value = getter ? getter.call(obj) : val;\n if (Dep.target) {\n dep.depend();\n if (childOb) {\n childOb.dep.depend();\n }\n if (Array.isArray(value)) {\n dependArray(value);\n }\n }\n return value\n },\n set: function reactiveSetter (newVal) {\n var value = getter ? getter.call(obj) : val;\n /* eslint-disable no-self-compare */\n if (newVal === value || (newVal !== newVal && value !== value)) {\n return\n }\n /* eslint-enable no-self-compare */\n if (process.env.NODE_ENV !== 'production' && customSetter) {\n customSetter();\n }\n if (setter) {\n setter.call(obj, newVal);\n } else {\n val = newVal;\n }\n childOb = observe(newVal);\n dep.notify();\n }\n });\n}\n\n/**\n * Set a property on an object. Adds the new property and\n * triggers change notification if the property doesn't\n * already exist.\n */\nfunction set$1 (obj, key, val) {\n if (Array.isArray(obj)) {\n obj.length = Math.max(obj.length, key);\n obj.splice(key, 1, val);\n return val\n }\n if (hasOwn(obj, key)) {\n obj[key] = val;\n return\n }\n var ob = obj.__ob__;\n if (obj._isVue || (ob && ob.vmCount)) {\n process.env.NODE_ENV !== 'production' && warn(\n 'Avoid adding reactive properties to a Vue instance or its root $data ' +\n 'at runtime - declare it upfront in the data option.'\n );\n return\n }\n if (!ob) {\n obj[key] = val;\n return\n }\n defineReactive$$1(ob.value, key, val);\n ob.dep.notify();\n return val\n}\n\n/**\n * Delete a property and trigger change if necessary.\n */\nfunction del (obj, key) {\n var ob = obj.__ob__;\n if (obj._isVue || (ob && ob.vmCount)) {\n process.env.NODE_ENV !== 'production' && warn(\n 'Avoid deleting properties on a Vue instance or its root $data ' +\n '- just set it to null.'\n );\n return\n }\n if (!hasOwn(obj, key)) {\n return\n }\n delete obj[key];\n if (!ob) {\n return\n }\n ob.dep.notify();\n}\n\n/**\n * Collect dependencies on array elements when the array is touched, since\n * we cannot intercept array element access like property getters.\n */\nfunction dependArray (value) {\n for (var e = (void 0), i = 0, l = value.length; i < l; i++) {\n e = value[i];\n e && e.__ob__ && e.__ob__.dep.depend();\n if (Array.isArray(e)) {\n dependArray(e);\n }\n }\n}\n\n/* */\n\n/**\n * Option overwriting strategies are functions that handle\n * how to merge a parent option value and a child option\n * value into the final value.\n */\nvar strats = config.optionMergeStrategies;\n\n/**\n * Options with restrictions\n */\nif (process.env.NODE_ENV !== 'production') {\n strats.el = strats.propsData = function (parent, child, vm, key) {\n if (!vm) {\n warn(\n \"option \\\"\" + key + \"\\\" can only be used during instance \" +\n 'creation with the `new` keyword.'\n );\n }\n return defaultStrat(parent, child)\n };\n}\n\n/**\n * Helper that recursively merges two data objects together.\n */\nfunction mergeData (to, from) {\n if (!from) { return to }\n var key, toVal, fromVal;\n var keys = Object.keys(from);\n for (var i = 0; i < keys.length; i++) {\n key = keys[i];\n toVal = to[key];\n fromVal = from[key];\n if (!hasOwn(to, key)) {\n set$1(to, key, fromVal);\n } else if (isPlainObject(toVal) && isPlainObject(fromVal)) {\n mergeData(toVal, fromVal);\n }\n }\n return to\n}\n\n/**\n * Data\n */\nstrats.data = function (\n parentVal,\n childVal,\n vm\n) {\n if (!vm) {\n // in a Vue.extend merge, both should be functions\n if (!childVal) {\n return parentVal\n }\n if (typeof childVal !== 'function') {\n process.env.NODE_ENV !== 'production' && warn(\n 'The \"data\" option should be a function ' +\n 'that returns a per-instance value in component ' +\n 'definitions.',\n vm\n );\n return parentVal\n }\n if (!parentVal) {\n return childVal\n }\n // when parentVal & childVal are both present,\n // we need to return a function that returns the\n // merged result of both functions... no need to\n // check if parentVal is a function here because\n // it has to be a function to pass previous merges.\n return function mergedDataFn () {\n return mergeData(\n childVal.call(this),\n parentVal.call(this)\n )\n }\n } else if (parentVal || childVal) {\n return function mergedInstanceDataFn () {\n // instance merge\n var instanceData = typeof childVal === 'function'\n ? childVal.call(vm)\n : childVal;\n var defaultData = typeof parentVal === 'function'\n ? parentVal.call(vm)\n : undefined;\n if (instanceData) {\n return mergeData(instanceData, defaultData)\n } else {\n return defaultData\n }\n }\n }\n};\n\n/**\n * Hooks and param attributes are merged as arrays.\n */\nfunction mergeHook (\n parentVal,\n childVal\n) {\n return childVal\n ? parentVal\n ? parentVal.concat(childVal)\n : Array.isArray(childVal)\n ? childVal\n : [childVal]\n : parentVal\n}\n\nconfig._lifecycleHooks.forEach(function (hook) {\n strats[hook] = mergeHook;\n});\n\n/**\n * Assets\n *\n * When a vm is present (instance creation), we need to do\n * a three-way merge between constructor options, instance\n * options and parent options.\n */\nfunction mergeAssets (parentVal, childVal) {\n var res = Object.create(parentVal || null);\n return childVal\n ? extend(res, childVal)\n : res\n}\n\nconfig._assetTypes.forEach(function (type) {\n strats[type + 's'] = mergeAssets;\n});\n\n/**\n * Watchers.\n *\n * Watchers hashes should not overwrite one\n * another, so we merge them as arrays.\n */\nstrats.watch = function (parentVal, childVal) {\n /* istanbul ignore if */\n if (!childVal) { return parentVal }\n if (!parentVal) { return childVal }\n var ret = {};\n extend(ret, parentVal);\n for (var key in childVal) {\n var parent = ret[key];\n var child = childVal[key];\n if (parent && !Array.isArray(parent)) {\n parent = [parent];\n }\n ret[key] = parent\n ? parent.concat(child)\n : [child];\n }\n return ret\n};\n\n/**\n * Other object hashes.\n */\nstrats.props =\nstrats.methods =\nstrats.computed = function (parentVal, childVal) {\n if (!childVal) { return parentVal }\n if (!parentVal) { return childVal }\n var ret = Object.create(null);\n extend(ret, parentVal);\n extend(ret, childVal);\n return ret\n};\n\n/**\n * Default strategy.\n */\nvar defaultStrat = function (parentVal, childVal) {\n return childVal === undefined\n ? parentVal\n : childVal\n};\n\n/**\n * Validate component names\n */\nfunction checkComponents (options) {\n for (var key in options.components) {\n var lower = key.toLowerCase();\n if (isBuiltInTag(lower) || config.isReservedTag(lower)) {\n warn(\n 'Do not use built-in or reserved HTML elements as component ' +\n 'id: ' + key\n );\n }\n }\n}\n\n/**\n * Ensure all props option syntax are normalized into the\n * Object-based format.\n */\nfunction normalizeProps (options) {\n var props = options.props;\n if (!props) { return }\n var res = {};\n var i, val, name;\n if (Array.isArray(props)) {\n i = props.length;\n while (i--) {\n val = props[i];\n if (typeof val === 'string') {\n name = camelize(val);\n res[name] = { type: null };\n } else if (process.env.NODE_ENV !== 'production') {\n warn('props must be strings when using array syntax.');\n }\n }\n } else if (isPlainObject(props)) {\n for (var key in props) {\n val = props[key];\n name = camelize(key);\n res[name] = isPlainObject(val)\n ? val\n : { type: val };\n }\n }\n options.props = res;\n}\n\n/**\n * Normalize raw function directives into object format.\n */\nfunction normalizeDirectives (options) {\n var dirs = options.directives;\n if (dirs) {\n for (var key in dirs) {\n var def = dirs[key];\n if (typeof def === 'function') {\n dirs[key] = { bind: def, update: def };\n }\n }\n }\n}\n\n/**\n * Merge two option objects into a new one.\n * Core utility used in both instantiation and inheritance.\n */\nfunction mergeOptions (\n parent,\n child,\n vm\n) {\n if (process.env.NODE_ENV !== 'production') {\n checkComponents(child);\n }\n normalizeProps(child);\n normalizeDirectives(child);\n var extendsFrom = child.extends;\n if (extendsFrom) {\n parent = typeof extendsFrom === 'function'\n ? mergeOptions(parent, extendsFrom.options, vm)\n : mergeOptions(parent, extendsFrom, vm);\n }\n if (child.mixins) {\n for (var i = 0, l = child.mixins.length; i < l; i++) {\n var mixin = child.mixins[i];\n if (mixin.prototype instanceof Vue$3) {\n mixin = mixin.options;\n }\n parent = mergeOptions(parent, mixin, vm);\n }\n }\n var options = {};\n var key;\n for (key in parent) {\n mergeField(key);\n }\n for (key in child) {\n if (!hasOwn(parent, key)) {\n mergeField(key);\n }\n }\n function mergeField (key) {\n var strat = strats[key] || defaultStrat;\n options[key] = strat(parent[key], child[key], vm, key);\n }\n return options\n}\n\n/**\n * Resolve an asset.\n * This function is used because child instances need access\n * to assets defined in its ancestor chain.\n */\nfunction resolveAsset (\n options,\n type,\n id,\n warnMissing\n) {\n /* istanbul ignore if */\n if (typeof id !== 'string') {\n return\n }\n var assets = options[type];\n // check local registration variations first\n if (hasOwn(assets, id)) { return assets[id] }\n var camelizedId = camelize(id);\n if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }\n var PascalCaseId = capitalize(camelizedId);\n if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }\n // fallback to prototype chain\n var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];\n if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {\n warn(\n 'Failed to resolve ' + type.slice(0, -1) + ': ' + id,\n options\n );\n }\n return res\n}\n\n/* */\n\nfunction validateProp (\n key,\n propOptions,\n propsData,\n vm\n) {\n var prop = propOptions[key];\n var absent = !hasOwn(propsData, key);\n var value = propsData[key];\n // handle boolean props\n if (isType(Boolean, prop.type)) {\n if (absent && !hasOwn(prop, 'default')) {\n value = false;\n } else if (!isType(String, prop.type) && (value === '' || value === hyphenate(key))) {\n value = true;\n }\n }\n // check default value\n if (value === undefined) {\n value = getPropDefaultValue(vm, prop, key);\n // since the default value is a fresh copy,\n // make sure to observe it.\n var prevShouldConvert = observerState.shouldConvert;\n observerState.shouldConvert = true;\n observe(value);\n observerState.shouldConvert = prevShouldConvert;\n }\n if (process.env.NODE_ENV !== 'production') {\n assertProp(prop, key, value, vm, absent);\n }\n return value\n}\n\n/**\n * Get the default value of a prop.\n */\nfunction getPropDefaultValue (vm, prop, key) {\n // no default, return undefined\n if (!hasOwn(prop, 'default')) {\n return undefined\n }\n var def = prop.default;\n // warn against non-factory defaults for Object & Array\n if (isObject(def)) {\n process.env.NODE_ENV !== 'production' && warn(\n 'Invalid default value for prop \"' + key + '\": ' +\n 'Props with type Object/Array must use a factory function ' +\n 'to return the default value.',\n vm\n );\n }\n // the raw prop value was also undefined from previous render,\n // return previous default value to avoid unnecessary watcher trigger\n if (vm && vm.$options.propsData &&\n vm.$options.propsData[key] === undefined &&\n vm[key] !== undefined) {\n return vm[key]\n }\n // call factory function for non-Function types\n return typeof def === 'function' && prop.type !== Function\n ? def.call(vm)\n : def\n}\n\n/**\n * Assert whether a prop is valid.\n */\nfunction assertProp (\n prop,\n name,\n value,\n vm,\n absent\n) {\n if (prop.required && absent) {\n warn(\n 'Missing required prop: \"' + name + '\"',\n vm\n );\n return\n }\n if (value == null && !prop.required) {\n return\n }\n var type = prop.type;\n var valid = !type || type === true;\n var expectedTypes = [];\n if (type) {\n if (!Array.isArray(type)) {\n type = [type];\n }\n for (var i = 0; i < type.length && !valid; i++) {\n var assertedType = assertType(value, type[i]);\n expectedTypes.push(assertedType.expectedType || '');\n valid = assertedType.valid;\n }\n }\n if (!valid) {\n warn(\n 'Invalid prop: type check failed for prop \"' + name + '\".' +\n ' Expected ' + expectedTypes.map(capitalize).join(', ') +\n ', got ' + Object.prototype.toString.call(value).slice(8, -1) + '.',\n vm\n );\n return\n }\n var validator = prop.validator;\n if (validator) {\n if (!validator(value)) {\n warn(\n 'Invalid prop: custom validator check failed for prop \"' + name + '\".',\n vm\n );\n }\n }\n}\n\n/**\n * Assert the type of a value\n */\nfunction assertType (value, type) {\n var valid;\n var expectedType = getType(type);\n if (expectedType === 'String') {\n valid = typeof value === (expectedType = 'string');\n } else if (expectedType === 'Number') {\n valid = typeof value === (expectedType = 'number');\n } else if (expectedType === 'Boolean') {\n valid = typeof value === (expectedType = 'boolean');\n } else if (expectedType === 'Function') {\n valid = typeof value === (expectedType = 'function');\n } else if (expectedType === 'Object') {\n valid = isPlainObject(value);\n } else if (expectedType === 'Array') {\n valid = Array.isArray(value);\n } else {\n valid = value instanceof type;\n }\n return {\n valid: valid,\n expectedType: expectedType\n }\n}\n\n/**\n * Use function string name to check built-in types,\n * because a simple equality check will fail when running\n * across different vms / iframes.\n */\nfunction getType (fn) {\n var match = fn && fn.toString().match(/^\\s*function (\\w+)/);\n return match && match[1]\n}\n\nfunction isType (type, fn) {\n if (!Array.isArray(fn)) {\n return getType(fn) === getType(type)\n }\n for (var i = 0, len = fn.length; i < len; i++) {\n if (getType(fn[i]) === getType(type)) {\n return true\n }\n }\n /* istanbul ignore next */\n return false\n}\n\n\n\nvar util = Object.freeze({\n\tdefineReactive: defineReactive$$1,\n\t_toString: _toString,\n\ttoNumber: toNumber,\n\tmakeMap: makeMap,\n\tisBuiltInTag: isBuiltInTag,\n\tremove: remove$1,\n\thasOwn: hasOwn,\n\tisPrimitive: isPrimitive,\n\tcached: cached,\n\tcamelize: camelize,\n\tcapitalize: capitalize,\n\thyphenate: hyphenate,\n\tbind: bind$1,\n\ttoArray: toArray,\n\textend: extend,\n\tisObject: isObject,\n\tisPlainObject: isPlainObject,\n\ttoObject: toObject,\n\tnoop: noop,\n\tno: no,\n\tidentity: identity,\n\tgenStaticKeys: genStaticKeys,\n\tlooseEqual: looseEqual,\n\tlooseIndexOf: looseIndexOf,\n\tisReserved: isReserved,\n\tdef: def,\n\tparsePath: parsePath,\n\thasProto: hasProto,\n\tinBrowser: inBrowser,\n\tUA: UA,\n\tisIE: isIE,\n\tisIE9: isIE9,\n\tisEdge: isEdge,\n\tisAndroid: isAndroid,\n\tisIOS: isIOS,\n\tisServerRendering: isServerRendering,\n\tdevtools: devtools,\n\tnextTick: nextTick,\n\tget _Set () { return _Set; },\n\tmergeOptions: mergeOptions,\n\tresolveAsset: resolveAsset,\n\tget warn () { return warn; },\n\tget formatComponentName () { return formatComponentName; },\n\tvalidateProp: validateProp\n});\n\n/* not type checking this file because flow doesn't play well with Proxy */\n\nvar initProxy;\n\nif (process.env.NODE_ENV !== 'production') {\n var allowedGlobals = makeMap(\n 'Infinity,undefined,NaN,isFinite,isNaN,' +\n 'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +\n 'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +\n 'require' // for Webpack/Browserify\n );\n\n var warnNonPresent = function (target, key) {\n warn(\n \"Property or method \\\"\" + key + \"\\\" is not defined on the instance but \" +\n \"referenced during render. Make sure to declare reactive data \" +\n \"properties in the data option.\",\n target\n );\n };\n\n var hasProxy =\n typeof Proxy !== 'undefined' &&\n Proxy.toString().match(/native code/);\n\n if (hasProxy) {\n var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta');\n config.keyCodes = new Proxy(config.keyCodes, {\n set: function set (target, key, value) {\n if (isBuiltInModifier(key)) {\n warn((\"Avoid overwriting built-in modifier in config.keyCodes: .\" + key));\n return false\n } else {\n target[key] = value;\n return true\n }\n }\n });\n }\n\n var hasHandler = {\n has: function has (target, key) {\n var has = key in target;\n var isAllowed = allowedGlobals(key) || key.charAt(0) === '_';\n if (!has && !isAllowed) {\n warnNonPresent(target, key);\n }\n return has || !isAllowed\n }\n };\n\n var getHandler = {\n get: function get (target, key) {\n if (typeof key === 'string' && !(key in target)) {\n warnNonPresent(target, key);\n }\n return target[key]\n }\n };\n\n initProxy = function initProxy (vm) {\n if (hasProxy) {\n // determine which proxy handler to use\n var options = vm.$options;\n var handlers = options.render && options.render._withStripped\n ? getHandler\n : hasHandler;\n vm._renderProxy = new Proxy(vm, handlers);\n } else {\n vm._renderProxy = vm;\n }\n };\n}\n\n/* */\n\nvar VNode = function VNode (\n tag,\n data,\n children,\n text,\n elm,\n context,\n componentOptions\n) {\n this.tag = tag;\n this.data = data;\n this.children = children;\n this.text = text;\n this.elm = elm;\n this.ns = undefined;\n this.context = context;\n this.functionalContext = undefined;\n this.key = data && data.key;\n this.componentOptions = componentOptions;\n this.componentInstance = undefined;\n this.parent = undefined;\n this.raw = false;\n this.isStatic = false;\n this.isRootInsert = true;\n this.isComment = false;\n this.isCloned = false;\n this.isOnce = false;\n};\n\nvar prototypeAccessors = { child: {} };\n\n// DEPRECATED: alias for componentInstance for backwards compat.\n/* istanbul ignore next */\nprototypeAccessors.child.get = function () {\n return this.componentInstance\n};\n\nObject.defineProperties( VNode.prototype, prototypeAccessors );\n\nvar createEmptyVNode = function () {\n var node = new VNode();\n node.text = '';\n node.isComment = true;\n return node\n};\n\nfunction createTextVNode (val) {\n return new VNode(undefined, undefined, undefined, String(val))\n}\n\n// optimized shallow clone\n// used for static nodes and slot nodes because they may be reused across\n// multiple renders, cloning them avoids errors when DOM manipulations rely\n// on their elm reference.\nfunction cloneVNode (vnode) {\n var cloned = new VNode(\n vnode.tag,\n vnode.data,\n vnode.children,\n vnode.text,\n vnode.elm,\n vnode.context,\n vnode.componentOptions\n );\n cloned.ns = vnode.ns;\n cloned.isStatic = vnode.isStatic;\n cloned.key = vnode.key;\n cloned.isCloned = true;\n return cloned\n}\n\nfunction cloneVNodes (vnodes) {\n var res = new Array(vnodes.length);\n for (var i = 0; i < vnodes.length; i++) {\n res[i] = cloneVNode(vnodes[i]);\n }\n return res\n}\n\n/* */\n\nvar hooks = { init: init, prepatch: prepatch, insert: insert, destroy: destroy$1 };\nvar hooksToMerge = Object.keys(hooks);\n\nfunction createComponent (\n Ctor,\n data,\n context,\n children,\n tag\n) {\n if (!Ctor) {\n return\n }\n\n var baseCtor = context.$options._base;\n if (isObject(Ctor)) {\n Ctor = baseCtor.extend(Ctor);\n }\n\n if (typeof Ctor !== 'function') {\n if (process.env.NODE_ENV !== 'production') {\n warn((\"Invalid Component definition: \" + (String(Ctor))), context);\n }\n return\n }\n\n // async component\n if (!Ctor.cid) {\n if (Ctor.resolved) {\n Ctor = Ctor.resolved;\n } else {\n Ctor = resolveAsyncComponent(Ctor, baseCtor, function () {\n // it's ok to queue this on every render because\n // $forceUpdate is buffered by the scheduler.\n context.$forceUpdate();\n });\n if (!Ctor) {\n // return nothing if this is indeed an async component\n // wait for the callback to trigger parent update.\n return\n }\n }\n }\n\n // resolve constructor options in case global mixins are applied after\n // component constructor creation\n resolveConstructorOptions(Ctor);\n\n data = data || {};\n\n // extract props\n var propsData = extractProps(data, Ctor);\n\n // functional component\n if (Ctor.options.functional) {\n return createFunctionalComponent(Ctor, propsData, data, context, children)\n }\n\n // extract listeners, since these needs to be treated as\n // child component listeners instead of DOM listeners\n var listeners = data.on;\n // replace with listeners with .native modifier\n data.on = data.nativeOn;\n\n if (Ctor.options.abstract) {\n // abstract components do not keep anything\n // other than props & listeners\n data = {};\n }\n\n // merge component management hooks onto the placeholder node\n mergeHooks(data);\n\n // return a placeholder vnode\n var name = Ctor.options.name || tag;\n var vnode = new VNode(\n (\"vue-component-\" + (Ctor.cid) + (name ? (\"-\" + name) : '')),\n data, undefined, undefined, undefined, context,\n { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }\n );\n return vnode\n}\n\nfunction createFunctionalComponent (\n Ctor,\n propsData,\n data,\n context,\n children\n) {\n var props = {};\n var propOptions = Ctor.options.props;\n if (propOptions) {\n for (var key in propOptions) {\n props[key] = validateProp(key, propOptions, propsData);\n }\n }\n // ensure the createElement function in functional components\n // gets a unique context - this is necessary for correct named slot check\n var _context = Object.create(context);\n var h = function (a, b, c, d) { return createElement(_context, a, b, c, d, true); };\n var vnode = Ctor.options.render.call(null, h, {\n props: props,\n data: data,\n parent: context,\n children: children,\n slots: function () { return resolveSlots(children, context); }\n });\n if (vnode instanceof VNode) {\n vnode.functionalContext = context;\n if (data.slot) {\n (vnode.data || (vnode.data = {})).slot = data.slot;\n }\n }\n return vnode\n}\n\nfunction createComponentInstanceForVnode (\n vnode, // we know it's MountedComponentVNode but flow doesn't\n parent, // activeInstance in lifecycle state\n parentElm,\n refElm\n) {\n var vnodeComponentOptions = vnode.componentOptions;\n var options = {\n _isComponent: true,\n parent: parent,\n propsData: vnodeComponentOptions.propsData,\n _componentTag: vnodeComponentOptions.tag,\n _parentVnode: vnode,\n _parentListeners: vnodeComponentOptions.listeners,\n _renderChildren: vnodeComponentOptions.children,\n _parentElm: parentElm || null,\n _refElm: refElm || null\n };\n // check inline-template render functions\n var inlineTemplate = vnode.data.inlineTemplate;\n if (inlineTemplate) {\n options.render = inlineTemplate.render;\n options.staticRenderFns = inlineTemplate.staticRenderFns;\n }\n return new vnodeComponentOptions.Ctor(options)\n}\n\nfunction init (\n vnode,\n hydrating,\n parentElm,\n refElm\n) {\n if (!vnode.componentInstance || vnode.componentInstance._isDestroyed) {\n var child = vnode.componentInstance = createComponentInstanceForVnode(\n vnode,\n activeInstance,\n parentElm,\n refElm\n );\n child.$mount(hydrating ? vnode.elm : undefined, hydrating);\n } else if (vnode.data.keepAlive) {\n // kept-alive components, treat as a patch\n var mountedNode = vnode; // work around flow\n prepatch(mountedNode, mountedNode);\n }\n}\n\nfunction prepatch (\n oldVnode,\n vnode\n) {\n var options = vnode.componentOptions;\n var child = vnode.componentInstance = oldVnode.componentInstance;\n child._updateFromParent(\n options.propsData, // updated props\n options.listeners, // updated listeners\n vnode, // new parent vnode\n options.children // new children\n );\n}\n\nfunction insert (vnode) {\n if (!vnode.componentInstance._isMounted) {\n vnode.componentInstance._isMounted = true;\n callHook(vnode.componentInstance, 'mounted');\n }\n if (vnode.data.keepAlive) {\n vnode.componentInstance._inactive = false;\n callHook(vnode.componentInstance, 'activated');\n }\n}\n\nfunction destroy$1 (vnode) {\n if (!vnode.componentInstance._isDestroyed) {\n if (!vnode.data.keepAlive) {\n vnode.componentInstance.$destroy();\n } else {\n vnode.componentInstance._inactive = true;\n callHook(vnode.componentInstance, 'deactivated');\n }\n }\n}\n\nfunction resolveAsyncComponent (\n factory,\n baseCtor,\n cb\n) {\n if (factory.requested) {\n // pool callbacks\n factory.pendingCallbacks.push(cb);\n } else {\n factory.requested = true;\n var cbs = factory.pendingCallbacks = [cb];\n var sync = true;\n\n var resolve = function (res) {\n if (isObject(res)) {\n res = baseCtor.extend(res);\n }\n // cache resolved\n factory.resolved = res;\n // invoke callbacks only if this is not a synchronous resolve\n // (async resolves are shimmed as synchronous during SSR)\n if (!sync) {\n for (var i = 0, l = cbs.length; i < l; i++) {\n cbs[i](res);\n }\n }\n };\n\n var reject = function (reason) {\n process.env.NODE_ENV !== 'production' && warn(\n \"Failed to resolve async component: \" + (String(factory)) +\n (reason ? (\"\\nReason: \" + reason) : '')\n );\n };\n\n var res = factory(resolve, reject);\n\n // handle promise\n if (res && typeof res.then === 'function' && !factory.resolved) {\n res.then(resolve, reject);\n }\n\n sync = false;\n // return in case resolved synchronously\n return factory.resolved\n }\n}\n\nfunction extractProps (data, Ctor) {\n // we are only extracting raw values here.\n // validation and default values are handled in the child\n // component itself.\n var propOptions = Ctor.options.props;\n if (!propOptions) {\n return\n }\n var res = {};\n var attrs = data.attrs;\n var props = data.props;\n var domProps = data.domProps;\n if (attrs || props || domProps) {\n for (var key in propOptions) {\n var altKey = hyphenate(key);\n checkProp(res, props, key, altKey, true) ||\n checkProp(res, attrs, key, altKey) ||\n checkProp(res, domProps, key, altKey);\n }\n }\n return res\n}\n\nfunction checkProp (\n res,\n hash,\n key,\n altKey,\n preserve\n) {\n if (hash) {\n if (hasOwn(hash, key)) {\n res[key] = hash[key];\n if (!preserve) {\n delete hash[key];\n }\n return true\n } else if (hasOwn(hash, altKey)) {\n res[key] = hash[altKey];\n if (!preserve) {\n delete hash[altKey];\n }\n return true\n }\n }\n return false\n}\n\nfunction mergeHooks (data) {\n if (!data.hook) {\n data.hook = {};\n }\n for (var i = 0; i < hooksToMerge.length; i++) {\n var key = hooksToMerge[i];\n var fromParent = data.hook[key];\n var ours = hooks[key];\n data.hook[key] = fromParent ? mergeHook$1(ours, fromParent) : ours;\n }\n}\n\nfunction mergeHook$1 (one, two) {\n return function (a, b, c, d) {\n one(a, b, c, d);\n two(a, b, c, d);\n }\n}\n\n/* */\n\nfunction mergeVNodeHook (def, hookKey, hook, key) {\n key = key + hookKey;\n var injectedHash = def.__injected || (def.__injected = {});\n if (!injectedHash[key]) {\n injectedHash[key] = true;\n var oldHook = def[hookKey];\n if (oldHook) {\n def[hookKey] = function () {\n oldHook.apply(this, arguments);\n hook.apply(this, arguments);\n };\n } else {\n def[hookKey] = hook;\n }\n }\n}\n\n/* */\n\nvar normalizeEvent = cached(function (name) {\n var once = name.charAt(0) === '~'; // Prefixed last, checked first\n name = once ? name.slice(1) : name;\n var capture = name.charAt(0) === '!';\n name = capture ? name.slice(1) : name;\n return {\n name: name,\n once: once,\n capture: capture\n }\n});\n\nfunction createEventHandle (fn) {\n var handle = {\n fn: fn,\n invoker: function () {\n var arguments$1 = arguments;\n\n var fn = handle.fn;\n if (Array.isArray(fn)) {\n for (var i = 0; i < fn.length; i++) {\n fn[i].apply(null, arguments$1);\n }\n } else {\n fn.apply(null, arguments);\n }\n }\n };\n return handle\n}\n\nfunction updateListeners (\n on,\n oldOn,\n add,\n remove$$1,\n vm\n) {\n var name, cur, old, event;\n for (name in on) {\n cur = on[name];\n old = oldOn[name];\n event = normalizeEvent(name);\n if (!cur) {\n process.env.NODE_ENV !== 'production' && warn(\n \"Invalid handler for event \\\"\" + (event.name) + \"\\\": got \" + String(cur),\n vm\n );\n } else if (!old) {\n if (!cur.invoker) {\n cur = on[name] = createEventHandle(cur);\n }\n add(event.name, cur.invoker, event.once, event.capture);\n } else if (cur !== old) {\n old.fn = cur;\n on[name] = old;\n }\n }\n for (name in oldOn) {\n if (!on[name]) {\n event = normalizeEvent(name);\n remove$$1(event.name, oldOn[name].invoker, event.capture);\n }\n }\n}\n\n/* */\n\n// The template compiler attempts to minimize the need for normalization by\n// statically analyzing the template at compile time.\n//\n// For plain HTML markup, normalization can be completely skipped because the\n// generated render function is guaranteed to return Array<VNode>. There are\n// two cases where extra normalization is needed:\n\n// 1. When the children contains components - because a functional component\n// may return an Array instead of a single root. In this case, just a simple\n// nomralization is needed - if any child is an Array, we flatten the whole\n// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep\n// because functional components already normalize their own children.\nfunction simpleNormalizeChildren (children) {\n for (var i = 0; i < children.length; i++) {\n if (Array.isArray(children[i])) {\n return Array.prototype.concat.apply([], children)\n }\n }\n return children\n}\n\n// 2. When the children contains constrcuts that always generated nested Arrays,\n// e.g. <template>, <slot>, v-for, or when the children is provided by user\n// with hand-written render functions / JSX. In such cases a full normalization\n// is needed to cater to all possible types of children values.\nfunction normalizeChildren (children) {\n return isPrimitive(children)\n ? [createTextVNode(children)]\n : Array.isArray(children)\n ? normalizeArrayChildren(children)\n : undefined\n}\n\nfunction normalizeArrayChildren (children, nestedIndex) {\n var res = [];\n var i, c, last;\n for (i = 0; i < children.length; i++) {\n c = children[i];\n if (c == null || typeof c === 'boolean') { continue }\n last = res[res.length - 1];\n // nested\n if (Array.isArray(c)) {\n res.push.apply(res, normalizeArrayChildren(c, ((nestedIndex || '') + \"_\" + i)));\n } else if (isPrimitive(c)) {\n if (last && last.text) {\n last.text += String(c);\n } else if (c !== '') {\n // convert primitive to vnode\n res.push(createTextVNode(c));\n }\n } else {\n if (c.text && last && last.text) {\n res[res.length - 1] = createTextVNode(last.text + c.text);\n } else {\n // default key for nested array children (likely generated by v-for)\n if (c.tag && c.key == null && nestedIndex != null) {\n c.key = \"__vlist\" + nestedIndex + \"_\" + i + \"__\";\n }\n res.push(c);\n }\n }\n }\n return res\n}\n\n/* */\n\nfunction getFirstComponentChild (children) {\n return children && children.filter(function (c) { return c && c.componentOptions; })[0]\n}\n\n/* */\n\nvar SIMPLE_NORMALIZE = 1;\nvar ALWAYS_NORMALIZE = 2;\n\n// wrapper function for providing a more flexible interface\n// without getting yelled at by flow\nfunction createElement (\n context,\n tag,\n data,\n children,\n normalizationType,\n alwaysNormalize\n) {\n if (Array.isArray(data) || isPrimitive(data)) {\n normalizationType = children;\n children = data;\n data = undefined;\n }\n if (alwaysNormalize) { normalizationType = ALWAYS_NORMALIZE; }\n return _createElement(context, tag, data, children, normalizationType)\n}\n\nfunction _createElement (\n context,\n tag,\n data,\n children,\n normalizationType\n) {\n if (data && data.__ob__) {\n process.env.NODE_ENV !== 'production' && warn(\n \"Avoid using observed data object as vnode data: \" + (JSON.stringify(data)) + \"\\n\" +\n 'Always create fresh vnode data objects in each render!',\n context\n );\n return createEmptyVNode()\n }\n if (!tag) {\n // in case of component :is set to falsy value\n return createEmptyVNode()\n }\n // support single function children as default scoped slot\n if (Array.isArray(children) &&\n typeof children[0] === 'function') {\n data = data || {};\n data.scopedSlots = { default: children[0] };\n children.length = 0;\n }\n if (normalizationType === ALWAYS_NORMALIZE) {\n children = normalizeChildren(children);\n } else if (normalizationType === SIMPLE_NORMALIZE) {\n children = simpleNormalizeChildren(children);\n }\n var vnode, ns;\n if (typeof tag === 'string') {\n var Ctor;\n ns = config.getTagNamespace(tag);\n if (config.isReservedTag(tag)) {\n // platform built-in elements\n vnode = new VNode(\n config.parsePlatformTagName(tag), data, children,\n undefined, undefined, context\n );\n } else if ((Ctor = resolveAsset(context.$options, 'components', tag))) {\n // component\n vnode = createComponent(Ctor, data, context, children, tag);\n } else {\n // unknown or unlisted namespaced elements\n // check at runtime because it may get assigned a namespace when its\n // parent normalizes children\n vnode = new VNode(\n tag, data, children,\n undefined, undefined, context\n );\n }\n } else {\n // direct component options / constructor\n vnode = createComponent(tag, data, context, children);\n }\n if (vnode) {\n if (ns) { applyNS(vnode, ns); }\n return vnode\n } else {\n return createEmptyVNode()\n }\n}\n\nfunction applyNS (vnode, ns) {\n vnode.ns = ns;\n if (vnode.tag === 'foreignObject') {\n // use default namespace inside foreignObject\n return\n }\n if (vnode.children) {\n for (var i = 0, l = vnode.children.length; i < l; i++) {\n var child = vnode.children[i];\n if (child.tag && !child.ns) {\n applyNS(child, ns);\n }\n }\n }\n}\n\n/* */\n\nfunction initRender (vm) {\n vm.$vnode = null; // the placeholder node in parent tree\n vm._vnode = null; // the root of the child tree\n vm._staticTrees = null;\n var parentVnode = vm.$options._parentVnode;\n var renderContext = parentVnode && parentVnode.context;\n vm.$slots = resolveSlots(vm.$options._renderChildren, renderContext);\n vm.$scopedSlots = {};\n // bind the createElement fn to this instance\n // so that we get proper render context inside it.\n // args order: tag, data, children, normalizationType, alwaysNormalize\n // internal version is used by render functions compiled from templates\n vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };\n // normalization is always applied for the public version, used in\n // user-written render functions.\n vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };\n}\n\nfunction renderMixin (Vue) {\n Vue.prototype.$nextTick = function (fn) {\n return nextTick(fn, this)\n };\n\n Vue.prototype._render = function () {\n var vm = this;\n var ref = vm.$options;\n var render = ref.render;\n var staticRenderFns = ref.staticRenderFns;\n var _parentVnode = ref._parentVnode;\n\n if (vm._isMounted) {\n // clone slot nodes on re-renders\n for (var key in vm.$slots) {\n vm.$slots[key] = cloneVNodes(vm.$slots[key]);\n }\n }\n\n if (_parentVnode && _parentVnode.data.scopedSlots) {\n vm.$scopedSlots = _parentVnode.data.scopedSlots;\n }\n\n if (staticRenderFns && !vm._staticTrees) {\n vm._staticTrees = [];\n }\n // set parent vnode. this allows render functions to have access\n // to the data on the placeholder node.\n vm.$vnode = _parentVnode;\n // render self\n var vnode;\n try {\n vnode = render.call(vm._renderProxy, vm.$createElement);\n } catch (e) {\n /* istanbul ignore else */\n if (config.errorHandler) {\n config.errorHandler.call(null, e, vm);\n } else {\n if (process.env.NODE_ENV !== 'production') {\n warn((\"Error when rendering \" + (formatComponentName(vm)) + \":\"));\n }\n throw e\n }\n // return previous vnode to prevent render error causing blank component\n vnode = vm._vnode;\n }\n // return empty vnode in case the render function errored out\n if (!(vnode instanceof VNode)) {\n if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {\n warn(\n 'Multiple root nodes returned from render function. Render function ' +\n 'should return a single root node.',\n vm\n );\n }\n vnode = createEmptyVNode();\n }\n // set parent\n vnode.parent = _parentVnode;\n return vnode\n };\n\n // toString for mustaches\n Vue.prototype._s = _toString;\n // convert text to vnode\n Vue.prototype._v = createTextVNode;\n // number conversion\n Vue.prototype._n = toNumber;\n // empty vnode\n Vue.prototype._e = createEmptyVNode;\n // loose equal\n Vue.prototype._q = looseEqual;\n // loose indexOf\n Vue.prototype._i = looseIndexOf;\n\n // render static tree by index\n Vue.prototype._m = function renderStatic (\n index,\n isInFor\n ) {\n var tree = this._staticTrees[index];\n // if has already-rendered static tree and not inside v-for,\n // we can reuse the same tree by doing a shallow clone.\n if (tree && !isInFor) {\n return Array.isArray(tree)\n ? cloneVNodes(tree)\n : cloneVNode(tree)\n }\n // otherwise, render a fresh tree.\n tree = this._staticTrees[index] = this.$options.staticRenderFns[index].call(this._renderProxy);\n markStatic(tree, (\"__static__\" + index), false);\n return tree\n };\n\n // mark node as static (v-once)\n Vue.prototype._o = function markOnce (\n tree,\n index,\n key\n ) {\n markStatic(tree, (\"__once__\" + index + (key ? (\"_\" + key) : \"\")), true);\n return tree\n };\n\n function markStatic (tree, key, isOnce) {\n if (Array.isArray(tree)) {\n for (var i = 0; i < tree.length; i++) {\n if (tree[i] && typeof tree[i] !== 'string') {\n markStaticNode(tree[i], (key + \"_\" + i), isOnce);\n }\n }\n } else {\n markStaticNode(tree, key, isOnce);\n }\n }\n\n function markStaticNode (node, key, isOnce) {\n node.isStatic = true;\n node.key = key;\n node.isOnce = isOnce;\n }\n\n // filter resolution helper\n Vue.prototype._f = function resolveFilter (id) {\n return resolveAsset(this.$options, 'filters', id, true) || identity\n };\n\n // render v-for\n Vue.prototype._l = function renderList (\n val,\n render\n ) {\n var ret, i, l, keys, key;\n if (Array.isArray(val) || typeof val === 'string') {\n ret = new Array(val.length);\n for (i = 0, l = val.length; i < l; i++) {\n ret[i] = render(val[i], i);\n }\n } else if (typeof val === 'number') {\n ret = new Array(val);\n for (i = 0; i < val; i++) {\n ret[i] = render(i + 1, i);\n }\n } else if (isObject(val)) {\n keys = Object.keys(val);\n ret = new Array(keys.length);\n for (i = 0, l = keys.length; i < l; i++) {\n key = keys[i];\n ret[i] = render(val[key], key, i);\n }\n }\n return ret\n };\n\n // renderSlot\n Vue.prototype._t = function (\n name,\n fallback,\n props,\n bindObject\n ) {\n var scopedSlotFn = this.$scopedSlots[name];\n if (scopedSlotFn) { // scoped slot\n props = props || {};\n if (bindObject) {\n extend(props, bindObject);\n }\n return scopedSlotFn(props) || fallback\n } else {\n var slotNodes = this.$slots[name];\n // warn duplicate slot usage\n if (slotNodes && process.env.NODE_ENV !== 'production') {\n slotNodes._rendered && warn(\n \"Duplicate presence of slot \\\"\" + name + \"\\\" found in the same render tree \" +\n \"- this will likely cause render errors.\",\n this\n );\n slotNodes._rendered = true;\n }\n return slotNodes || fallback\n }\n };\n\n // apply v-bind object\n Vue.prototype._b = function bindProps (\n data,\n tag,\n value,\n asProp\n ) {\n if (value) {\n if (!isObject(value)) {\n process.env.NODE_ENV !== 'production' && warn(\n 'v-bind without argument expects an Object or Array value',\n this\n );\n } else {\n if (Array.isArray(value)) {\n value = toObject(value);\n }\n for (var key in value) {\n if (key === 'class' || key === 'style') {\n data[key] = value[key];\n } else {\n var type = data.attrs && data.attrs.type;\n var hash = asProp || config.mustUseProp(tag, type, key)\n ? data.domProps || (data.domProps = {})\n : data.attrs || (data.attrs = {});\n hash[key] = value[key];\n }\n }\n }\n }\n return data\n };\n\n // check v-on keyCodes\n Vue.prototype._k = function checkKeyCodes (\n eventKeyCode,\n key,\n builtInAlias\n ) {\n var keyCodes = config.keyCodes[key] || builtInAlias;\n if (Array.isArray(keyCodes)) {\n return keyCodes.indexOf(eventKeyCode) === -1\n } else {\n return keyCodes !== eventKeyCode\n }\n };\n}\n\nfunction resolveSlots (\n children,\n context\n) {\n var slots = {};\n if (!children) {\n return slots\n }\n var defaultSlot = [];\n var name, child;\n for (var i = 0, l = children.length; i < l; i++) {\n child = children[i];\n // named slots should only be respected if the vnode was rendered in the\n // same context.\n if ((child.context === context || child.functionalContext === context) &&\n child.data && (name = child.data.slot)) {\n var slot = (slots[name] || (slots[name] = []));\n if (child.tag === 'template') {\n slot.push.apply(slot, child.children);\n } else {\n slot.push(child);\n }\n } else {\n defaultSlot.push(child);\n }\n }\n // ignore single whitespace\n if (defaultSlot.length && !(\n defaultSlot.length === 1 &&\n (defaultSlot[0].text === ' ' || defaultSlot[0].isComment)\n )) {\n slots.default = defaultSlot;\n }\n return slots\n}\n\n/* */\n\nfunction initEvents (vm) {\n vm._events = Object.create(null);\n vm._hasHookEvent = false;\n // init parent attached events\n var listeners = vm.$options._parentListeners;\n if (listeners) {\n updateComponentListeners(vm, listeners);\n }\n}\n\nvar target;\n\nfunction add$1 (event, fn, once) {\n if (once) {\n target.$once(event, fn);\n } else {\n target.$on(event, fn);\n }\n}\n\nfunction remove$2 (event, fn) {\n target.$off(event, fn);\n}\n\nfunction updateComponentListeners (\n vm,\n listeners,\n oldListeners\n) {\n target = vm;\n updateListeners(listeners, oldListeners || {}, add$1, remove$2, vm);\n}\n\nfunction eventsMixin (Vue) {\n var hookRE = /^hook:/;\n Vue.prototype.$on = function (event, fn) {\n var vm = this;(vm._events[event] || (vm._events[event] = [])).push(fn);\n // optimize hook:event cost by using a boolean flag marked at registration\n // instead of a hash lookup\n if (hookRE.test(event)) {\n vm._hasHookEvent = true;\n }\n return vm\n };\n\n Vue.prototype.$once = function (event, fn) {\n var vm = this;\n function on () {\n vm.$off(event, on);\n fn.apply(vm, arguments);\n }\n on.fn = fn;\n vm.$on(event, on);\n return vm\n };\n\n Vue.prototype.$off = function (event, fn) {\n var vm = this;\n // all\n if (!arguments.length) {\n vm._events = Object.create(null);\n return vm\n }\n // specific event\n var cbs = vm._events[event];\n if (!cbs) {\n return vm\n }\n if (arguments.length === 1) {\n vm._events[event] = null;\n return vm\n }\n // specific handler\n var cb;\n var i = cbs.length;\n while (i--) {\n cb = cbs[i];\n if (cb === fn || cb.fn === fn) {\n cbs.splice(i, 1);\n break\n }\n }\n return vm\n };\n\n Vue.prototype.$emit = function (event) {\n var vm = this;\n var cbs = vm._events[event];\n if (cbs) {\n cbs = cbs.length > 1 ? toArray(cbs) : cbs;\n var args = toArray(arguments, 1);\n for (var i = 0, l = cbs.length; i < l; i++) {\n cbs[i].apply(vm, args);\n }\n }\n return vm\n };\n}\n\n/* */\n\nvar activeInstance = null;\n\nfunction initLifecycle (vm) {\n var options = vm.$options;\n\n // locate first non-abstract parent\n var parent = options.parent;\n if (parent && !options.abstract) {\n while (parent.$options.abstract && parent.$parent) {\n parent = parent.$parent;\n }\n parent.$children.push(vm);\n }\n\n vm.$parent = parent;\n vm.$root = parent ? parent.$root : vm;\n\n vm.$children = [];\n vm.$refs = {};\n\n vm._watcher = null;\n vm._inactive = false;\n vm._isMounted = false;\n vm._isDestroyed = false;\n vm._isBeingDestroyed = false;\n}\n\nfunction lifecycleMixin (Vue) {\n Vue.prototype._mount = function (\n el,\n hydrating\n ) {\n var vm = this;\n vm.$el = el;\n if (!vm.$options.render) {\n vm.$options.render = createEmptyVNode;\n if (process.env.NODE_ENV !== 'production') {\n /* istanbul ignore if */\n if (vm.$options.template && vm.$options.template.charAt(0) !== '#') {\n warn(\n 'You are using the runtime-only build of Vue where the template ' +\n 'option is not available. Either pre-compile the templates into ' +\n 'render functions, or use the compiler-included build.',\n vm\n );\n } else {\n warn(\n 'Failed to mount component: template or render function not defined.',\n vm\n );\n }\n }\n }\n callHook(vm, 'beforeMount');\n vm._watcher = new Watcher(vm, function updateComponent () {\n vm._update(vm._render(), hydrating);\n }, noop);\n hydrating = false;\n // manually mounted instance, call mounted on self\n // mounted is called for render-created child components in its inserted hook\n if (vm.$vnode == null) {\n vm._isMounted = true;\n callHook(vm, 'mounted');\n }\n return vm\n };\n\n Vue.prototype._update = function (vnode, hydrating) {\n var vm = this;\n if (vm._isMounted) {\n callHook(vm, 'beforeUpdate');\n }\n var prevEl = vm.$el;\n var prevVnode = vm._vnode;\n var prevActiveInstance = activeInstance;\n activeInstance = vm;\n vm._vnode = vnode;\n // Vue.prototype.__patch__ is injected in entry points\n // based on the rendering backend used.\n if (!prevVnode) {\n // initial render\n vm.$el = vm.__patch__(\n vm.$el, vnode, hydrating, false /* removeOnly */,\n vm.$options._parentElm,\n vm.$options._refElm\n );\n } else {\n // updates\n vm.$el = vm.__patch__(prevVnode, vnode);\n }\n activeInstance = prevActiveInstance;\n // update __vue__ reference\n if (prevEl) {\n prevEl.__vue__ = null;\n }\n if (vm.$el) {\n vm.$el.__vue__ = vm;\n }\n // if parent is an HOC, update its $el as well\n if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {\n vm.$parent.$el = vm.$el;\n }\n // updated hook is called by the scheduler to ensure that children are\n // updated in a parent's updated hook.\n };\n\n Vue.prototype._updateFromParent = function (\n propsData,\n listeners,\n parentVnode,\n renderChildren\n ) {\n var vm = this;\n var hasChildren = !!(vm.$options._renderChildren || renderChildren);\n vm.$options._parentVnode = parentVnode;\n vm.$vnode = parentVnode; // update vm's placeholder node without re-render\n if (vm._vnode) { // update child tree's parent\n vm._vnode.parent = parentVnode;\n }\n vm.$options._renderChildren = renderChildren;\n // update props\n if (propsData && vm.$options.props) {\n observerState.shouldConvert = false;\n if (process.env.NODE_ENV !== 'production') {\n observerState.isSettingProps = true;\n }\n var propKeys = vm.$options._propKeys || [];\n for (var i = 0; i < propKeys.length; i++) {\n var key = propKeys[i];\n vm[key] = validateProp(key, vm.$options.props, propsData, vm);\n }\n observerState.shouldConvert = true;\n if (process.env.NODE_ENV !== 'production') {\n observerState.isSettingProps = false;\n }\n vm.$options.propsData = propsData;\n }\n // update listeners\n if (listeners) {\n var oldListeners = vm.$options._parentListeners;\n vm.$options._parentListeners = listeners;\n updateComponentListeners(vm, listeners, oldListeners);\n }\n // resolve slots + force update if has children\n if (hasChildren) {\n vm.$slots = resolveSlots(renderChildren, parentVnode.context);\n vm.$forceUpdate();\n }\n };\n\n Vue.prototype.$forceUpdate = function () {\n var vm = this;\n if (vm._watcher) {\n vm._watcher.update();\n }\n };\n\n Vue.prototype.$destroy = function () {\n var vm = this;\n if (vm._isBeingDestroyed) {\n return\n }\n callHook(vm, 'beforeDestroy');\n vm._isBeingDestroyed = true;\n // remove self from parent\n var parent = vm.$parent;\n if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {\n remove$1(parent.$children, vm);\n }\n // teardown watchers\n if (vm._watcher) {\n vm._watcher.teardown();\n }\n var i = vm._watchers.length;\n while (i--) {\n vm._watchers[i].teardown();\n }\n // remove reference from data ob\n // frozen object may not have observer.\n if (vm._data.__ob__) {\n vm._data.__ob__.vmCount--;\n }\n // call the last hook...\n vm._isDestroyed = true;\n callHook(vm, 'destroyed');\n // turn off all instance listeners.\n vm.$off();\n // remove __vue__ reference\n if (vm.$el) {\n vm.$el.__vue__ = null;\n }\n // invoke destroy hooks on current rendered tree\n vm.__patch__(vm._vnode, null);\n };\n}\n\nfunction callHook (vm, hook) {\n var handlers = vm.$options[hook];\n if (handlers) {\n for (var i = 0, j = handlers.length; i < j; i++) {\n handlers[i].call(vm);\n }\n }\n if (vm._hasHookEvent) {\n vm.$emit('hook:' + hook);\n }\n}\n\n/* */\n\n\nvar queue = [];\nvar has$1 = {};\nvar circular = {};\nvar waiting = false;\nvar flushing = false;\nvar index = 0;\n\n/**\n * Reset the scheduler's state.\n */\nfunction resetSchedulerState () {\n queue.length = 0;\n has$1 = {};\n if (process.env.NODE_ENV !== 'production') {\n circular = {};\n }\n waiting = flushing = false;\n}\n\n/**\n * Flush both queues and run the watchers.\n */\nfunction flushSchedulerQueue () {\n flushing = true;\n var watcher, id, vm;\n\n // Sort queue before flush.\n // This ensures that:\n // 1. Components are updated from parent to child. (because parent is always\n // created before the child)\n // 2. A component's user watchers are run before its render watcher (because\n // user watchers are created before the render watcher)\n // 3. If a component is destroyed during a parent component's watcher run,\n // its watchers can be skipped.\n queue.sort(function (a, b) { return a.id - b.id; });\n\n // do not cache length because more watchers might be pushed\n // as we run existing watchers\n for (index = 0; index < queue.length; index++) {\n watcher = queue[index];\n id = watcher.id;\n has$1[id] = null;\n watcher.run();\n // in dev build, check and stop circular updates.\n if (process.env.NODE_ENV !== 'production' && has$1[id] != null) {\n circular[id] = (circular[id] || 0) + 1;\n if (circular[id] > config._maxUpdateCount) {\n warn(\n 'You may have an infinite update loop ' + (\n watcher.user\n ? (\"in watcher with expression \\\"\" + (watcher.expression) + \"\\\"\")\n : \"in a component render function.\"\n ),\n watcher.vm\n );\n break\n }\n }\n }\n\n // call updated hooks\n index = queue.length;\n while (index--) {\n watcher = queue[index];\n vm = watcher.vm;\n if (vm._watcher === watcher && vm._isMounted) {\n callHook(vm, 'updated');\n }\n }\n\n // devtool hook\n /* istanbul ignore if */\n if (devtools && config.devtools) {\n devtools.emit('flush');\n }\n\n resetSchedulerState();\n}\n\n/**\n * Push a watcher into the watcher queue.\n * Jobs with duplicate IDs will be skipped unless it's\n * pushed when the queue is being flushed.\n */\nfunction queueWatcher (watcher) {\n var id = watcher.id;\n if (has$1[id] == null) {\n has$1[id] = true;\n if (!flushing) {\n queue.push(watcher);\n } else {\n // if already flushing, splice the watcher based on its id\n // if already past its id, it will be run next immediately.\n var i = queue.length - 1;\n while (i >= 0 && queue[i].id > watcher.id) {\n i--;\n }\n queue.splice(Math.max(i, index) + 1, 0, watcher);\n }\n // queue the flush\n if (!waiting) {\n waiting = true;\n nextTick(flushSchedulerQueue);\n }\n }\n}\n\n/* */\n\nvar uid$2 = 0;\n\n/**\n * A watcher parses an expression, collects dependencies,\n * and fires callback when the expression value changes.\n * This is used for both the $watch() api and directives.\n */\nvar Watcher = function Watcher (\n vm,\n expOrFn,\n cb,\n options\n) {\n this.vm = vm;\n vm._watchers.push(this);\n // options\n if (options) {\n this.deep = !!options.deep;\n this.user = !!options.user;\n this.lazy = !!options.lazy;\n this.sync = !!options.sync;\n } else {\n this.deep = this.user = this.lazy = this.sync = false;\n }\n this.cb = cb;\n this.id = ++uid$2; // uid for batching\n this.active = true;\n this.dirty = this.lazy; // for lazy watchers\n this.deps = [];\n this.newDeps = [];\n this.depIds = new _Set();\n this.newDepIds = new _Set();\n this.expression = process.env.NODE_ENV !== 'production'\n ? expOrFn.toString()\n : '';\n // parse expression for getter\n if (typeof expOrFn === 'function') {\n this.getter = expOrFn;\n } else {\n this.getter = parsePath(expOrFn);\n if (!this.getter) {\n this.getter = function () {};\n process.env.NODE_ENV !== 'production' && warn(\n \"Failed watching path: \\\"\" + expOrFn + \"\\\" \" +\n 'Watcher only accepts simple dot-delimited paths. ' +\n 'For full control, use a function instead.',\n vm\n );\n }\n }\n this.value = this.lazy\n ? undefined\n : this.get();\n};\n\n/**\n * Evaluate the getter, and re-collect dependencies.\n */\nWatcher.prototype.get = function get () {\n pushTarget(this);\n var value = this.getter.call(this.vm, this.vm);\n // \"touch\" every property so they are all tracked as\n // dependencies for deep watching\n if (this.deep) {\n traverse(value);\n }\n popTarget();\n this.cleanupDeps();\n return value\n};\n\n/**\n * Add a dependency to this directive.\n */\nWatcher.prototype.addDep = function addDep (dep) {\n var id = dep.id;\n if (!this.newDepIds.has(id)) {\n this.newDepIds.add(id);\n this.newDeps.push(dep);\n if (!this.depIds.has(id)) {\n dep.addSub(this);\n }\n }\n};\n\n/**\n * Clean up for dependency collection.\n */\nWatcher.prototype.cleanupDeps = function cleanupDeps () {\n var this$1 = this;\n\n var i = this.deps.length;\n while (i--) {\n var dep = this$1.deps[i];\n if (!this$1.newDepIds.has(dep.id)) {\n dep.removeSub(this$1);\n }\n }\n var tmp = this.depIds;\n this.depIds = this.newDepIds;\n this.newDepIds = tmp;\n this.newDepIds.clear();\n tmp = this.deps;\n this.deps = this.newDeps;\n this.newDeps = tmp;\n this.newDeps.length = 0;\n};\n\n/**\n * Subscriber interface.\n * Will be called when a dependency changes.\n */\nWatcher.prototype.update = function update () {\n /* istanbul ignore else */\n if (this.lazy) {\n this.dirty = true;\n } else if (this.sync) {\n this.run();\n } else {\n queueWatcher(this);\n }\n};\n\n/**\n * Scheduler job interface.\n * Will be called by the scheduler.\n */\nWatcher.prototype.run = function run () {\n if (this.active) {\n var value = this.get();\n if (\n value !== this.value ||\n // Deep watchers and watchers on Object/Arrays should fire even\n // when the value is the same, because the value may\n // have mutated.\n isObject(value) ||\n this.deep\n ) {\n // set new value\n var oldValue = this.value;\n this.value = value;\n if (this.user) {\n try {\n this.cb.call(this.vm, value, oldValue);\n } catch (e) {\n /* istanbul ignore else */\n if (config.errorHandler) {\n config.errorHandler.call(null, e, this.vm);\n } else {\n process.env.NODE_ENV !== 'production' && warn(\n (\"Error in watcher \\\"\" + (this.expression) + \"\\\"\"),\n this.vm\n );\n throw e\n }\n }\n } else {\n this.cb.call(this.vm, value, oldValue);\n }\n }\n }\n};\n\n/**\n * Evaluate the value of the watcher.\n * This only gets called for lazy watchers.\n */\nWatcher.prototype.evaluate = function evaluate () {\n this.value = this.get();\n this.dirty = false;\n};\n\n/**\n * Depend on all deps collected by this watcher.\n */\nWatcher.prototype.depend = function depend () {\n var this$1 = this;\n\n var i = this.deps.length;\n while (i--) {\n this$1.deps[i].depend();\n }\n};\n\n/**\n * Remove self from all dependencies' subscriber list.\n */\nWatcher.prototype.teardown = function teardown () {\n var this$1 = this;\n\n if (this.active) {\n // remove self from vm's watcher list\n // this is a somewhat expensive operation so we skip it\n // if the vm is being destroyed.\n if (!this.vm._isBeingDestroyed) {\n remove$1(this.vm._watchers, this);\n }\n var i = this.deps.length;\n while (i--) {\n this$1.deps[i].removeSub(this$1);\n }\n this.active = false;\n }\n};\n\n/**\n * Recursively traverse an object to evoke all converted\n * getters, so that every nested property inside the object\n * is collected as a \"deep\" dependency.\n */\nvar seenObjects = new _Set();\nfunction traverse (val) {\n seenObjects.clear();\n _traverse(val, seenObjects);\n}\n\nfunction _traverse (val, seen) {\n var i, keys;\n var isA = Array.isArray(val);\n if ((!isA && !isObject(val)) || !Object.isExtensible(val)) {\n return\n }\n if (val.__ob__) {\n var depId = val.__ob__.dep.id;\n if (seen.has(depId)) {\n return\n }\n seen.add(depId);\n }\n if (isA) {\n i = val.length;\n while (i--) { _traverse(val[i], seen); }\n } else {\n keys = Object.keys(val);\n i = keys.length;\n while (i--) { _traverse(val[keys[i]], seen); }\n }\n}\n\n/* */\n\nfunction initState (vm) {\n vm._watchers = [];\n var opts = vm.$options;\n if (opts.props) { initProps(vm, opts.props); }\n if (opts.methods) { initMethods(vm, opts.methods); }\n if (opts.data) {\n initData(vm);\n } else {\n observe(vm._data = {}, true /* asRootData */);\n }\n if (opts.computed) { initComputed(vm, opts.computed); }\n if (opts.watch) { initWatch(vm, opts.watch); }\n}\n\nvar isReservedProp = { key: 1, ref: 1, slot: 1 };\n\nfunction initProps (vm, props) {\n var propsData = vm.$options.propsData || {};\n var keys = vm.$options._propKeys = Object.keys(props);\n var isRoot = !vm.$parent;\n // root instance props should be converted\n observerState.shouldConvert = isRoot;\n var loop = function ( i ) {\n var key = keys[i];\n /* istanbul ignore else */\n if (process.env.NODE_ENV !== 'production') {\n if (isReservedProp[key]) {\n warn(\n (\"\\\"\" + key + \"\\\" is a reserved attribute and cannot be used as component prop.\"),\n vm\n );\n }\n defineReactive$$1(vm, key, validateProp(key, props, propsData, vm), function () {\n if (vm.$parent && !observerState.isSettingProps) {\n warn(\n \"Avoid mutating a prop directly since the value will be \" +\n \"overwritten whenever the parent component re-renders. \" +\n \"Instead, use a data or computed property based on the prop's \" +\n \"value. Prop being mutated: \\\"\" + key + \"\\\"\",\n vm\n );\n }\n });\n } else {\n defineReactive$$1(vm, key, validateProp(key, props, propsData, vm));\n }\n };\n\n for (var i = 0; i < keys.length; i++) loop( i );\n observerState.shouldConvert = true;\n}\n\nfunction initData (vm) {\n var data = vm.$options.data;\n data = vm._data = typeof data === 'function'\n ? data.call(vm)\n : data || {};\n if (!isPlainObject(data)) {\n data = {};\n process.env.NODE_ENV !== 'production' && warn(\n 'data functions should return an object:\\n' +\n 'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',\n vm\n );\n }\n // proxy data on instance\n var keys = Object.keys(data);\n var props = vm.$options.props;\n var i = keys.length;\n while (i--) {\n if (props && hasOwn(props, keys[i])) {\n process.env.NODE_ENV !== 'production' && warn(\n \"The data property \\\"\" + (keys[i]) + \"\\\" is already declared as a prop. \" +\n \"Use prop default value instead.\",\n vm\n );\n } else {\n proxy(vm, keys[i]);\n }\n }\n // observe data\n observe(data, true /* asRootData */);\n}\n\nvar computedSharedDefinition = {\n enumerable: true,\n configurable: true,\n get: noop,\n set: noop\n};\n\nfunction initComputed (vm, computed) {\n for (var key in computed) {\n /* istanbul ignore if */\n if (process.env.NODE_ENV !== 'production' && key in vm) {\n warn(\n \"existing instance property \\\"\" + key + \"\\\" will be \" +\n \"overwritten by a computed property with the same name.\",\n vm\n );\n }\n var userDef = computed[key];\n if (typeof userDef === 'function') {\n computedSharedDefinition.get = makeComputedGetter(userDef, vm);\n computedSharedDefinition.set = noop;\n } else {\n computedSharedDefinition.get = userDef.get\n ? userDef.cache !== false\n ? makeComputedGetter(userDef.get, vm)\n : bind$1(userDef.get, vm)\n : noop;\n computedSharedDefinition.set = userDef.set\n ? bind$1(userDef.set, vm)\n : noop;\n }\n Object.defineProperty(vm, key, computedSharedDefinition);\n }\n}\n\nfunction makeComputedGetter (getter, owner) {\n var watcher = new Watcher(owner, getter, noop, {\n lazy: true\n });\n return function computedGetter () {\n if (watcher.dirty) {\n watcher.evaluate();\n }\n if (Dep.target) {\n watcher.depend();\n }\n return watcher.value\n }\n}\n\nfunction initMethods (vm, methods) {\n for (var key in methods) {\n vm[key] = methods[key] == null ? noop : bind$1(methods[key], vm);\n if (process.env.NODE_ENV !== 'production' && methods[key] == null) {\n warn(\n \"method \\\"\" + key + \"\\\" has an undefined value in the component definition. \" +\n \"Did you reference the function correctly?\",\n vm\n );\n }\n }\n}\n\nfunction initWatch (vm, watch) {\n for (var key in watch) {\n var handler = watch[key];\n if (Array.isArray(handler)) {\n for (var i = 0; i < handler.length; i++) {\n createWatcher(vm, key, handler[i]);\n }\n } else {\n createWatcher(vm, key, handler);\n }\n }\n}\n\nfunction createWatcher (vm, key, handler) {\n var options;\n if (isPlainObject(handler)) {\n options = handler;\n handler = handler.handler;\n }\n if (typeof handler === 'string') {\n handler = vm[handler];\n }\n vm.$watch(key, handler, options);\n}\n\nfunction stateMixin (Vue) {\n // flow somehow has problems with directly declared definition object\n // when using Object.defineProperty, so we have to procedurally build up\n // the object here.\n var dataDef = {};\n dataDef.get = function () {\n return this._data\n };\n if (process.env.NODE_ENV !== 'production') {\n dataDef.set = function (newData) {\n warn(\n 'Avoid replacing instance root $data. ' +\n 'Use nested data properties instead.',\n this\n );\n };\n }\n Object.defineProperty(Vue.prototype, '$data', dataDef);\n\n Vue.prototype.$set = set$1;\n Vue.prototype.$delete = del;\n\n Vue.prototype.$watch = function (\n expOrFn,\n cb,\n options\n ) {\n var vm = this;\n options = options || {};\n options.user = true;\n var watcher = new Watcher(vm, expOrFn, cb, options);\n if (options.immediate) {\n cb.call(vm, watcher.value);\n }\n return function unwatchFn () {\n watcher.teardown();\n }\n };\n}\n\nfunction proxy (vm, key) {\n if (!isReserved(key)) {\n Object.defineProperty(vm, key, {\n configurable: true,\n enumerable: true,\n get: function proxyGetter () {\n return vm._data[key]\n },\n set: function proxySetter (val) {\n vm._data[key] = val;\n }\n });\n }\n}\n\n/* */\n\nvar uid = 0;\n\nfunction initMixin (Vue) {\n Vue.prototype._init = function (options) {\n var vm = this;\n // a uid\n vm._uid = uid++;\n // a flag to avoid this being observed\n vm._isVue = true;\n // merge options\n if (options && options._isComponent) {\n // optimize internal component instantiation\n // since dynamic options merging is pretty slow, and none of the\n // internal component options needs special treatment.\n initInternalComponent(vm, options);\n } else {\n vm.$options = mergeOptions(\n resolveConstructorOptions(vm.constructor),\n options || {},\n vm\n );\n }\n /* istanbul ignore else */\n if (process.env.NODE_ENV !== 'production') {\n initProxy(vm);\n } else {\n vm._renderProxy = vm;\n }\n // expose real self\n vm._self = vm;\n initLifecycle(vm);\n initEvents(vm);\n initRender(vm);\n callHook(vm, 'beforeCreate');\n initState(vm);\n callHook(vm, 'created');\n if (vm.$options.el) {\n vm.$mount(vm.$options.el);\n }\n };\n}\n\nfunction initInternalComponent (vm, options) {\n var opts = vm.$options = Object.create(vm.constructor.options);\n // doing this because it's faster than dynamic enumeration.\n opts.parent = options.parent;\n opts.propsData = options.propsData;\n opts._parentVnode = options._parentVnode;\n opts._parentListeners = options._parentListeners;\n opts._renderChildren = options._renderChildren;\n opts._componentTag = options._componentTag;\n opts._parentElm = options._parentElm;\n opts._refElm = options._refElm;\n if (options.render) {\n opts.render = options.render;\n opts.staticRenderFns = options.staticRenderFns;\n }\n}\n\nfunction resolveConstructorOptions (Ctor) {\n var options = Ctor.options;\n if (Ctor.super) {\n var superOptions = Ctor.super.options;\n var cachedSuperOptions = Ctor.superOptions;\n var extendOptions = Ctor.extendOptions;\n if (superOptions !== cachedSuperOptions) {\n // super option changed\n Ctor.superOptions = superOptions;\n extendOptions.render = options.render;\n extendOptions.staticRenderFns = options.staticRenderFns;\n extendOptions._scopeId = options._scopeId;\n options = Ctor.options = mergeOptions(superOptions, extendOptions);\n if (options.name) {\n options.components[options.name] = Ctor;\n }\n }\n }\n return options\n}\n\nfunction Vue$3 (options) {\n if (process.env.NODE_ENV !== 'production' &&\n !(this instanceof Vue$3)) {\n warn('Vue is a constructor and should be called with the `new` keyword');\n }\n this._init(options);\n}\n\ninitMixin(Vue$3);\nstateMixin(Vue$3);\neventsMixin(Vue$3);\nlifecycleMixin(Vue$3);\nrenderMixin(Vue$3);\n\n/* */\n\nfunction initUse (Vue) {\n Vue.use = function (plugin) {\n /* istanbul ignore if */\n if (plugin.installed) {\n return\n }\n // additional parameters\n var args = toArray(arguments, 1);\n args.unshift(this);\n if (typeof plugin.install === 'function') {\n plugin.install.apply(plugin, args);\n } else {\n plugin.apply(null, args);\n }\n plugin.installed = true;\n return this\n };\n}\n\n/* */\n\nfunction initMixin$1 (Vue) {\n Vue.mixin = function (mixin) {\n this.options = mergeOptions(this.options, mixin);\n };\n}\n\n/* */\n\nfunction initExtend (Vue) {\n /**\n * Each instance constructor, including Vue, has a unique\n * cid. This enables us to create wrapped \"child\n * constructors\" for prototypal inheritance and cache them.\n */\n Vue.cid = 0;\n var cid = 1;\n\n /**\n * Class inheritance\n */\n Vue.extend = function (extendOptions) {\n extendOptions = extendOptions || {};\n var Super = this;\n var SuperId = Super.cid;\n var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});\n if (cachedCtors[SuperId]) {\n return cachedCtors[SuperId]\n }\n var name = extendOptions.name || Super.options.name;\n if (process.env.NODE_ENV !== 'production') {\n if (!/^[a-zA-Z][\\w-]*$/.test(name)) {\n warn(\n 'Invalid component name: \"' + name + '\". Component names ' +\n 'can only contain alphanumeric characters and the hyphen, ' +\n 'and must start with a letter.'\n );\n }\n }\n var Sub = function VueComponent (options) {\n this._init(options);\n };\n Sub.prototype = Object.create(Super.prototype);\n Sub.prototype.constructor = Sub;\n Sub.cid = cid++;\n Sub.options = mergeOptions(\n Super.options,\n extendOptions\n );\n Sub['super'] = Super;\n // allow further extension/mixin/plugin usage\n Sub.extend = Super.extend;\n Sub.mixin = Super.mixin;\n Sub.use = Super.use;\n // create asset registers, so extended classes\n // can have their private assets too.\n config._assetTypes.forEach(function (type) {\n Sub[type] = Super[type];\n });\n // enable recursive self-lookup\n if (name) {\n Sub.options.components[name] = Sub;\n }\n // keep a reference to the super options at extension time.\n // later at instantiation we can check if Super's options have\n // been updated.\n Sub.superOptions = Super.options;\n Sub.extendOptions = extendOptions;\n // cache constructor\n cachedCtors[SuperId] = Sub;\n return Sub\n };\n}\n\n/* */\n\nfunction initAssetRegisters (Vue) {\n /**\n * Create asset registration methods.\n */\n config._assetTypes.forEach(function (type) {\n Vue[type] = function (\n id,\n definition\n ) {\n if (!definition) {\n return this.options[type + 's'][id]\n } else {\n /* istanbul ignore if */\n if (process.env.NODE_ENV !== 'production') {\n if (type === 'component' && config.isReservedTag(id)) {\n warn(\n 'Do not use built-in or reserved HTML elements as component ' +\n 'id: ' + id\n );\n }\n }\n if (type === 'component' && isPlainObject(definition)) {\n definition.name = definition.name || id;\n definition = this.options._base.extend(definition);\n }\n if (type === 'directive' && typeof definition === 'function') {\n definition = { bind: definition, update: definition };\n }\n this.options[type + 's'][id] = definition;\n return definition\n }\n };\n });\n}\n\n/* */\n\nvar patternTypes = [String, RegExp];\n\nfunction getComponentName (opts) {\n return opts && (opts.Ctor.options.name || opts.tag)\n}\n\nfunction matches (pattern, name) {\n if (typeof pattern === 'string') {\n return pattern.split(',').indexOf(name) > -1\n } else {\n return pattern.test(name)\n }\n}\n\nfunction pruneCache (cache, filter) {\n for (var key in cache) {\n var cachedNode = cache[key];\n if (cachedNode) {\n var name = getComponentName(cachedNode.componentOptions);\n if (name && !filter(name)) {\n pruneCacheEntry(cachedNode);\n cache[key] = null;\n }\n }\n }\n}\n\nfunction pruneCacheEntry (vnode) {\n if (vnode) {\n if (!vnode.componentInstance._inactive) {\n callHook(vnode.componentInstance, 'deactivated');\n }\n vnode.componentInstance.$destroy();\n }\n}\n\nvar KeepAlive = {\n name: 'keep-alive',\n abstract: true,\n\n props: {\n include: patternTypes,\n exclude: patternTypes\n },\n\n created: function created () {\n this.cache = Object.create(null);\n },\n\n destroyed: function destroyed () {\n var this$1 = this;\n\n for (var key in this.cache) {\n pruneCacheEntry(this$1.cache[key]);\n }\n },\n\n watch: {\n include: function include (val) {\n pruneCache(this.cache, function (name) { return matches(val, name); });\n },\n exclude: function exclude (val) {\n pruneCache(this.cache, function (name) { return !matches(val, name); });\n }\n },\n\n render: function render () {\n var vnode = getFirstComponentChild(this.$slots.default);\n var componentOptions = vnode && vnode.componentOptions;\n if (componentOptions) {\n // check pattern\n var name = getComponentName(componentOptions);\n if (name && (\n (this.include && !matches(this.include, name)) ||\n (this.exclude && matches(this.exclude, name))\n )) {\n return vnode\n }\n var key = vnode.key == null\n // same constructor may get registered as different local components\n // so cid alone is not enough (#3269)\n ? componentOptions.Ctor.cid + (componentOptions.tag ? (\"::\" + (componentOptions.tag)) : '')\n : vnode.key;\n if (this.cache[key]) {\n vnode.componentInstance = this.cache[key].componentInstance;\n } else {\n this.cache[key] = vnode;\n }\n vnode.data.keepAlive = true;\n }\n return vnode\n }\n};\n\nvar builtInComponents = {\n KeepAlive: KeepAlive\n};\n\n/* */\n\nfunction initGlobalAPI (Vue) {\n // config\n var configDef = {};\n configDef.get = function () { return config; };\n if (process.env.NODE_ENV !== 'production') {\n configDef.set = function () {\n warn(\n 'Do not replace the Vue.config object, set individual fields instead.'\n );\n };\n }\n Object.defineProperty(Vue, 'config', configDef);\n Vue.util = util;\n Vue.set = set$1;\n Vue.delete = del;\n Vue.nextTick = nextTick;\n\n Vue.options = Object.create(null);\n config._assetTypes.forEach(function (type) {\n Vue.options[type + 's'] = Object.create(null);\n });\n\n // this is used to identify the \"base\" constructor to extend all plain-object\n // components with in Weex's multi-instance scenarios.\n Vue.options._base = Vue;\n\n extend(Vue.options.components, builtInComponents);\n\n initUse(Vue);\n initMixin$1(Vue);\n initExtend(Vue);\n initAssetRegisters(Vue);\n}\n\ninitGlobalAPI(Vue$3);\n\nObject.defineProperty(Vue$3.prototype, '$isServer', {\n get: isServerRendering\n});\n\nVue$3.version = '2.1.10';\n\n/* */\n\n// attributes that should be using props for binding\nvar acceptValue = makeMap('input,textarea,option,select');\nvar mustUseProp = function (tag, type, attr) {\n return (\n (attr === 'value' && acceptValue(tag)) && type !== 'button' ||\n (attr === 'selected' && tag === 'option') ||\n (attr === 'checked' && tag === 'input') ||\n (attr === 'muted' && tag === 'video')\n )\n};\n\nvar isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');\n\nvar isBooleanAttr = makeMap(\n 'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +\n 'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +\n 'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +\n 'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +\n 'required,reversed,scoped,seamless,selected,sortable,translate,' +\n 'truespeed,typemustmatch,visible'\n);\n\nvar xlinkNS = 'http://www.w3.org/1999/xlink';\n\nvar isXlink = function (name) {\n return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'\n};\n\nvar getXlinkProp = function (name) {\n return isXlink(name) ? name.slice(6, name.length) : ''\n};\n\nvar isFalsyAttrValue = function (val) {\n return val == null || val === false\n};\n\n/* */\n\nfunction genClassForVnode (vnode) {\n var data = vnode.data;\n var parentNode = vnode;\n var childNode = vnode;\n while (childNode.componentInstance) {\n childNode = childNode.componentInstance._vnode;\n if (childNode.data) {\n data = mergeClassData(childNode.data, data);\n }\n }\n while ((parentNode = parentNode.parent)) {\n if (parentNode.data) {\n data = mergeClassData(data, parentNode.data);\n }\n }\n return genClassFromData(data)\n}\n\nfunction mergeClassData (child, parent) {\n return {\n staticClass: concat(child.staticClass, parent.staticClass),\n class: child.class\n ? [child.class, parent.class]\n : parent.class\n }\n}\n\nfunction genClassFromData (data) {\n var dynamicClass = data.class;\n var staticClass = data.staticClass;\n if (staticClass || dynamicClass) {\n return concat(staticClass, stringifyClass(dynamicClass))\n }\n /* istanbul ignore next */\n return ''\n}\n\nfunction concat (a, b) {\n return a ? b ? (a + ' ' + b) : a : (b || '')\n}\n\nfunction stringifyClass (value) {\n var res = '';\n if (!value) {\n return res\n }\n if (typeof value === 'string') {\n return value\n }\n if (Array.isArray(value)) {\n var stringified;\n for (var i = 0, l = value.length; i < l; i++) {\n if (value[i]) {\n if ((stringified = stringifyClass(value[i]))) {\n res += stringified + ' ';\n }\n }\n }\n return res.slice(0, -1)\n }\n if (isObject(value)) {\n for (var key in value) {\n if (value[key]) { res += key + ' '; }\n }\n return res.slice(0, -1)\n }\n /* istanbul ignore next */\n return res\n}\n\n/* */\n\nvar namespaceMap = {\n svg: 'http://www.w3.org/2000/svg',\n math: 'http://www.w3.org/1998/Math/MathML'\n};\n\nvar isHTMLTag = makeMap(\n 'html,body,base,head,link,meta,style,title,' +\n 'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +\n 'div,dd,dl,dt,figcaption,figure,hr,img,li,main,ol,p,pre,ul,' +\n 'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +\n 's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +\n 'embed,object,param,source,canvas,script,noscript,del,ins,' +\n 'caption,col,colgroup,table,thead,tbody,td,th,tr,' +\n 'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +\n 'output,progress,select,textarea,' +\n 'details,dialog,menu,menuitem,summary,' +\n 'content,element,shadow,template'\n);\n\n// this map is intentionally selective, only covering SVG elements that may\n// contain child elements.\nvar isSVG = makeMap(\n 'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,' +\n 'font-face,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +\n 'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',\n true\n);\n\nvar isPreTag = function (tag) { return tag === 'pre'; };\n\nvar isReservedTag = function (tag) {\n return isHTMLTag(tag) || isSVG(tag)\n};\n\nfunction getTagNamespace (tag) {\n if (isSVG(tag)) {\n return 'svg'\n }\n // basic support for MathML\n // note it doesn't support other MathML elements being component roots\n if (tag === 'math') {\n return 'math'\n }\n}\n\nvar unknownElementCache = Object.create(null);\nfunction isUnknownElement (tag) {\n /* istanbul ignore if */\n if (!inBrowser) {\n return true\n }\n if (isReservedTag(tag)) {\n return false\n }\n tag = tag.toLowerCase();\n /* istanbul ignore if */\n if (unknownElementCache[tag] != null) {\n return unknownElementCache[tag]\n }\n var el = document.createElement(tag);\n if (tag.indexOf('-') > -1) {\n // http://stackoverflow.com/a/28210364/1070244\n return (unknownElementCache[tag] = (\n el.constructor === window.HTMLUnknownElement ||\n el.constructor === window.HTMLElement\n ))\n } else {\n return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))\n }\n}\n\n/* */\n\n/**\n * Query an element selector if it's not an element already.\n */\nfunction query (el) {\n if (typeof el === 'string') {\n var selector = el;\n el = document.querySelector(el);\n if (!el) {\n process.env.NODE_ENV !== 'production' && warn(\n 'Cannot find element: ' + selector\n );\n return document.createElement('div')\n }\n }\n return el\n}\n\n/* */\n\nfunction createElement$1 (tagName, vnode) {\n var elm = document.createElement(tagName);\n if (tagName !== 'select') {\n return elm\n }\n if (vnode.data && vnode.data.attrs && 'multiple' in vnode.data.attrs) {\n elm.setAttribute('multiple', 'multiple');\n }\n return elm\n}\n\nfunction createElementNS (namespace, tagName) {\n return document.createElementNS(namespaceMap[namespace], tagName)\n}\n\nfunction createTextNode (text) {\n return document.createTextNode(text)\n}\n\nfunction createComment (text) {\n return document.createComment(text)\n}\n\nfunction insertBefore (parentNode, newNode, referenceNode) {\n parentNode.insertBefore(newNode, referenceNode);\n}\n\nfunction removeChild (node, child) {\n node.removeChild(child);\n}\n\nfunction appendChild (node, child) {\n node.appendChild(child);\n}\n\nfunction parentNode (node) {\n return node.parentNode\n}\n\nfunction nextSibling (node) {\n return node.nextSibling\n}\n\nfunction tagName (node) {\n return node.tagName\n}\n\nfunction setTextContent (node, text) {\n node.textContent = text;\n}\n\nfunction setAttribute (node, key, val) {\n node.setAttribute(key, val);\n}\n\n\nvar nodeOps = Object.freeze({\n\tcreateElement: createElement$1,\n\tcreateElementNS: createElementNS,\n\tcreateTextNode: createTextNode,\n\tcreateComment: createComment,\n\tinsertBefore: insertBefore,\n\tremoveChild: removeChild,\n\tappendChild: appendChild,\n\tparentNode: parentNode,\n\tnextSibling: nextSibling,\n\ttagName: tagName,\n\tsetTextContent: setTextContent,\n\tsetAttribute: setAttribute\n});\n\n/* */\n\nvar ref = {\n create: function create (_, vnode) {\n registerRef(vnode);\n },\n update: function update (oldVnode, vnode) {\n if (oldVnode.data.ref !== vnode.data.ref) {\n registerRef(oldVnode, true);\n registerRef(vnode);\n }\n },\n destroy: function destroy (vnode) {\n registerRef(vnode, true);\n }\n};\n\nfunction registerRef (vnode, isRemoval) {\n var key = vnode.data.ref;\n if (!key) { return }\n\n var vm = vnode.context;\n var ref = vnode.componentInstance || vnode.elm;\n var refs = vm.$refs;\n if (isRemoval) {\n if (Array.isArray(refs[key])) {\n remove$1(refs[key], ref);\n } else if (refs[key] === ref) {\n refs[key] = undefined;\n }\n } else {\n if (vnode.data.refInFor) {\n if (Array.isArray(refs[key]) && refs[key].indexOf(ref) < 0) {\n refs[key].push(ref);\n } else {\n refs[key] = [ref];\n }\n } else {\n refs[key] = ref;\n }\n }\n}\n\n/**\n * Virtual DOM patching algorithm based on Snabbdom by\n * Simon Friis Vindum (@paldepind)\n * Licensed under the MIT License\n * https://github.com/paldepind/snabbdom/blob/master/LICENSE\n *\n * modified by Evan You (@yyx990803)\n *\n\n/*\n * Not type-checking this because this file is perf-critical and the cost\n * of making flow understand it is not worth it.\n */\n\nvar emptyNode = new VNode('', {}, []);\n\nvar hooks$1 = ['create', 'activate', 'update', 'remove', 'destroy'];\n\nfunction isUndef (s) {\n return s == null\n}\n\nfunction isDef (s) {\n return s != null\n}\n\nfunction sameVnode (vnode1, vnode2) {\n return (\n vnode1.key === vnode2.key &&\n vnode1.tag === vnode2.tag &&\n vnode1.isComment === vnode2.isComment &&\n !vnode1.data === !vnode2.data\n )\n}\n\nfunction createKeyToOldIdx (children, beginIdx, endIdx) {\n var i, key;\n var map = {};\n for (i = beginIdx; i <= endIdx; ++i) {\n key = children[i].key;\n if (isDef(key)) { map[key] = i; }\n }\n return map\n}\n\nfunction createPatchFunction (backend) {\n var i, j;\n var cbs = {};\n\n var modules = backend.modules;\n var nodeOps = backend.nodeOps;\n\n for (i = 0; i < hooks$1.length; ++i) {\n cbs[hooks$1[i]] = [];\n for (j = 0; j < modules.length; ++j) {\n if (modules[j][hooks$1[i]] !== undefined) { cbs[hooks$1[i]].push(modules[j][hooks$1[i]]); }\n }\n }\n\n function emptyNodeAt (elm) {\n return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)\n }\n\n function createRmCb (childElm, listeners) {\n function remove$$1 () {\n if (--remove$$1.listeners === 0) {\n removeNode(childElm);\n }\n }\n remove$$1.listeners = listeners;\n return remove$$1\n }\n\n function removeNode (el) {\n var parent = nodeOps.parentNode(el);\n // element may have already been removed due to v-html / v-text\n if (parent) {\n nodeOps.removeChild(parent, el);\n }\n }\n\n var inPre = 0;\n function createElm (vnode, insertedVnodeQueue, parentElm, refElm, nested) {\n vnode.isRootInsert = !nested; // for transition enter check\n if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {\n return\n }\n\n var data = vnode.data;\n var children = vnode.children;\n var tag = vnode.tag;\n if (isDef(tag)) {\n if (process.env.NODE_ENV !== 'production') {\n if (data && data.pre) {\n inPre++;\n }\n if (\n !inPre &&\n !vnode.ns &&\n !(config.ignoredElements.length && config.ignoredElements.indexOf(tag) > -1) &&\n config.isUnknownElement(tag)\n ) {\n warn(\n 'Unknown custom element: <' + tag + '> - did you ' +\n 'register the component correctly? For recursive components, ' +\n 'make sure to provide the \"name\" option.',\n vnode.context\n );\n }\n }\n vnode.elm = vnode.ns\n ? nodeOps.createElementNS(vnode.ns, tag)\n : nodeOps.createElement(tag, vnode);\n setScope(vnode);\n\n /* istanbul ignore if */\n {\n createChildren(vnode, children, insertedVnodeQueue);\n if (isDef(data)) {\n invokeCreateHooks(vnode, insertedVnodeQueue);\n }\n insert(parentElm, vnode.elm, refElm);\n }\n\n if (process.env.NODE_ENV !== 'production' && data && data.pre) {\n inPre--;\n }\n } else if (vnode.isComment) {\n vnode.elm = nodeOps.createComment(vnode.text);\n insert(parentElm, vnode.elm, refElm);\n } else {\n vnode.elm = nodeOps.createTextNode(vnode.text);\n insert(parentElm, vnode.elm, refElm);\n }\n }\n\n function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {\n var i = vnode.data;\n if (isDef(i)) {\n var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;\n if (isDef(i = i.hook) && isDef(i = i.init)) {\n i(vnode, false /* hydrating */, parentElm, refElm);\n }\n // after calling the init hook, if the vnode is a child component\n // it should've created a child instance and mounted it. the child\n // component also has set the placeholder vnode's elm.\n // in that case we can just return the element and be done.\n if (isDef(vnode.componentInstance)) {\n initComponent(vnode, insertedVnodeQueue);\n if (isReactivated) {\n reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);\n }\n return true\n }\n }\n }\n\n function initComponent (vnode, insertedVnodeQueue) {\n if (vnode.data.pendingInsert) {\n insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);\n }\n vnode.elm = vnode.componentInstance.$el;\n if (isPatchable(vnode)) {\n invokeCreateHooks(vnode, insertedVnodeQueue);\n setScope(vnode);\n } else {\n // empty component root.\n // skip all element-related modules except for ref (#3455)\n registerRef(vnode);\n // make sure to invoke the insert hook\n insertedVnodeQueue.push(vnode);\n }\n }\n\n function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {\n var i;\n // hack for #4339: a reactivated component with inner transition\n // does not trigger because the inner node's created hooks are not called\n // again. It's not ideal to involve module-specific logic in here but\n // there doesn't seem to be a better way to do it.\n var innerNode = vnode;\n while (innerNode.componentInstance) {\n innerNode = innerNode.componentInstance._vnode;\n if (isDef(i = innerNode.data) && isDef(i = i.transition)) {\n for (i = 0; i < cbs.activate.length; ++i) {\n cbs.activate[i](emptyNode, innerNode);\n }\n insertedVnodeQueue.push(innerNode);\n break\n }\n }\n // unlike a newly created component,\n // a reactivated keep-alive component doesn't insert itself\n insert(parentElm, vnode.elm, refElm);\n }\n\n function insert (parent, elm, ref) {\n if (parent) {\n if (ref) {\n nodeOps.insertBefore(parent, elm, ref);\n } else {\n nodeOps.appendChild(parent, elm);\n }\n }\n }\n\n function createChildren (vnode, children, insertedVnodeQueue) {\n if (Array.isArray(children)) {\n for (var i = 0; i < children.length; ++i) {\n createElm(children[i], insertedVnodeQueue, vnode.elm, null, true);\n }\n } else if (isPrimitive(vnode.text)) {\n nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(vnode.text));\n }\n }\n\n function isPatchable (vnode) {\n while (vnode.componentInstance) {\n vnode = vnode.componentInstance._vnode;\n }\n return isDef(vnode.tag)\n }\n\n function invokeCreateHooks (vnode, insertedVnodeQueue) {\n for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {\n cbs.create[i$1](emptyNode, vnode);\n }\n i = vnode.data.hook; // Reuse variable\n if (isDef(i)) {\n if (i.create) { i.create(emptyNode, vnode); }\n if (i.insert) { insertedVnodeQueue.push(vnode); }\n }\n }\n\n // set scope id attribute for scoped CSS.\n // this is implemented as a special case to avoid the overhead\n // of going through the normal attribute patching process.\n function setScope (vnode) {\n var i;\n if (isDef(i = vnode.context) && isDef(i = i.$options._scopeId)) {\n nodeOps.setAttribute(vnode.elm, i, '');\n }\n if (isDef(i = activeInstance) &&\n i !== vnode.context &&\n isDef(i = i.$options._scopeId)) {\n nodeOps.setAttribute(vnode.elm, i, '');\n }\n }\n\n function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {\n for (; startIdx <= endIdx; ++startIdx) {\n createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm);\n }\n }\n\n function invokeDestroyHook (vnode) {\n var i, j;\n var data = vnode.data;\n if (isDef(data)) {\n if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }\n for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); }\n }\n if (isDef(i = vnode.children)) {\n for (j = 0; j < vnode.children.length; ++j) {\n invokeDestroyHook(vnode.children[j]);\n }\n }\n }\n\n function removeVnodes (parentElm, vnodes, startIdx, endIdx) {\n for (; startIdx <= endIdx; ++startIdx) {\n var ch = vnodes[startIdx];\n if (isDef(ch)) {\n if (isDef(ch.tag)) {\n removeAndInvokeRemoveHook(ch);\n invokeDestroyHook(ch);\n } else { // Text node\n removeNode(ch.elm);\n }\n }\n }\n }\n\n function removeAndInvokeRemoveHook (vnode, rm) {\n if (rm || isDef(vnode.data)) {\n var listeners = cbs.remove.length + 1;\n if (!rm) {\n // directly removing\n rm = createRmCb(vnode.elm, listeners);\n } else {\n // we have a recursively passed down rm callback\n // increase the listeners count\n rm.listeners += listeners;\n }\n // recursively invoke hooks on child component root node\n if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {\n removeAndInvokeRemoveHook(i, rm);\n }\n for (i = 0; i < cbs.remove.length; ++i) {\n cbs.remove[i](vnode, rm);\n }\n if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {\n i(vnode, rm);\n } else {\n rm();\n }\n } else {\n removeNode(vnode.elm);\n }\n }\n\n function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {\n var oldStartIdx = 0;\n var newStartIdx = 0;\n var oldEndIdx = oldCh.length - 1;\n var oldStartVnode = oldCh[0];\n var oldEndVnode = oldCh[oldEndIdx];\n var newEndIdx = newCh.length - 1;\n var newStartVnode = newCh[0];\n var newEndVnode = newCh[newEndIdx];\n var oldKeyToIdx, idxInOld, elmToMove, refElm;\n\n // removeOnly is a special flag used only by <transition-group>\n // to ensure removed elements stay in correct relative positions\n // during leaving transitions\n var canMove = !removeOnly;\n\n while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n if (isUndef(oldStartVnode)) {\n oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n } else if (isUndef(oldEndVnode)) {\n oldEndVnode = oldCh[--oldEndIdx];\n } else if (sameVnode(oldStartVnode, newStartVnode)) {\n patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);\n oldStartVnode = oldCh[++oldStartIdx];\n newStartVnode = newCh[++newStartIdx];\n } else if (sameVnode(oldEndVnode, newEndVnode)) {\n patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);\n oldEndVnode = oldCh[--oldEndIdx];\n newEndVnode = newCh[--newEndIdx];\n } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);\n canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));\n oldStartVnode = oldCh[++oldStartIdx];\n newEndVnode = newCh[--newEndIdx];\n } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);\n canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);\n oldEndVnode = oldCh[--oldEndIdx];\n newStartVnode = newCh[++newStartIdx];\n } else {\n if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }\n idxInOld = isDef(newStartVnode.key) ? oldKeyToIdx[newStartVnode.key] : null;\n if (isUndef(idxInOld)) { // New element\n createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);\n newStartVnode = newCh[++newStartIdx];\n } else {\n elmToMove = oldCh[idxInOld];\n /* istanbul ignore if */\n if (process.env.NODE_ENV !== 'production' && !elmToMove) {\n warn(\n 'It seems there are duplicate keys that is causing an update error. ' +\n 'Make sure each v-for item has a unique key.'\n );\n }\n if (sameVnode(elmToMove, newStartVnode)) {\n patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);\n oldCh[idxInOld] = undefined;\n canMove && nodeOps.insertBefore(parentElm, newStartVnode.elm, oldStartVnode.elm);\n newStartVnode = newCh[++newStartIdx];\n } else {\n // same key but different element. treat as new element\n createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);\n newStartVnode = newCh[++newStartIdx];\n }\n }\n }\n }\n if (oldStartIdx > oldEndIdx) {\n refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;\n addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);\n } else if (newStartIdx > newEndIdx) {\n removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n }\n }\n\n function patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly) {\n if (oldVnode === vnode) {\n return\n }\n // reuse element for static trees.\n // note we only do this if the vnode is cloned -\n // if the new node is not cloned it means the render functions have been\n // reset by the hot-reload-api and we need to do a proper re-render.\n if (vnode.isStatic &&\n oldVnode.isStatic &&\n vnode.key === oldVnode.key &&\n (vnode.isCloned || vnode.isOnce)) {\n vnode.elm = oldVnode.elm;\n vnode.componentInstance = oldVnode.componentInstance;\n return\n }\n var i;\n var data = vnode.data;\n var hasData = isDef(data);\n if (hasData && isDef(i = data.hook) && isDef(i = i.prepatch)) {\n i(oldVnode, vnode);\n }\n var elm = vnode.elm = oldVnode.elm;\n var oldCh = oldVnode.children;\n var ch = vnode.children;\n if (hasData && isPatchable(vnode)) {\n for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); }\n if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }\n }\n if (isUndef(vnode.text)) {\n if (isDef(oldCh) && isDef(ch)) {\n if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }\n } else if (isDef(ch)) {\n if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }\n addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);\n } else if (isDef(oldCh)) {\n removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n } else if (isDef(oldVnode.text)) {\n nodeOps.setTextContent(elm, '');\n }\n } else if (oldVnode.text !== vnode.text) {\n nodeOps.setTextContent(elm, vnode.text);\n }\n if (hasData) {\n if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); }\n }\n }\n\n function invokeInsertHook (vnode, queue, initial) {\n // delay insert hooks for component root nodes, invoke them after the\n // element is really inserted\n if (initial && vnode.parent) {\n vnode.parent.data.pendingInsert = queue;\n } else {\n for (var i = 0; i < queue.length; ++i) {\n queue[i].data.hook.insert(queue[i]);\n }\n }\n }\n\n var bailed = false;\n // list of modules that can skip create hook during hydration because they\n // are already rendered on the client or has no need for initialization\n var isRenderedModule = makeMap('attrs,style,class,staticClass,staticStyle,key');\n\n // Note: this is a browser-only function so we can assume elms are DOM nodes.\n function hydrate (elm, vnode, insertedVnodeQueue) {\n if (process.env.NODE_ENV !== 'production') {\n if (!assertNodeMatch(elm, vnode)) {\n return false\n }\n }\n vnode.elm = elm;\n var tag = vnode.tag;\n var data = vnode.data;\n var children = vnode.children;\n if (isDef(data)) {\n if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }\n if (isDef(i = vnode.componentInstance)) {\n // child component. it should have hydrated its own tree.\n initComponent(vnode, insertedVnodeQueue);\n return true\n }\n }\n if (isDef(tag)) {\n if (isDef(children)) {\n // empty element, allow client to pick up and populate children\n if (!elm.hasChildNodes()) {\n createChildren(vnode, children, insertedVnodeQueue);\n } else {\n var childrenMatch = true;\n var childNode = elm.firstChild;\n for (var i$1 = 0; i$1 < children.length; i$1++) {\n if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue)) {\n childrenMatch = false;\n break\n }\n childNode = childNode.nextSibling;\n }\n // if childNode is not null, it means the actual childNodes list is\n // longer than the virtual children list.\n if (!childrenMatch || childNode) {\n if (process.env.NODE_ENV !== 'production' &&\n typeof console !== 'undefined' &&\n !bailed) {\n bailed = true;\n console.warn('Parent: ', elm);\n console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);\n }\n return false\n }\n }\n }\n if (isDef(data)) {\n for (var key in data) {\n if (!isRenderedModule(key)) {\n invokeCreateHooks(vnode, insertedVnodeQueue);\n break\n }\n }\n }\n } else if (elm.data !== vnode.text) {\n elm.data = vnode.text;\n }\n return true\n }\n\n function assertNodeMatch (node, vnode) {\n if (vnode.tag) {\n return (\n vnode.tag.indexOf('vue-component') === 0 ||\n vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())\n )\n } else {\n return node.nodeType === (vnode.isComment ? 8 : 3)\n }\n }\n\n return function patch (oldVnode, vnode, hydrating, removeOnly, parentElm, refElm) {\n if (!vnode) {\n if (oldVnode) { invokeDestroyHook(oldVnode); }\n return\n }\n\n var isInitialPatch = false;\n var insertedVnodeQueue = [];\n\n if (!oldVnode) {\n // empty mount (likely as component), create new root element\n isInitialPatch = true;\n createElm(vnode, insertedVnodeQueue, parentElm, refElm);\n } else {\n var isRealElement = isDef(oldVnode.nodeType);\n if (!isRealElement && sameVnode(oldVnode, vnode)) {\n // patch existing root node\n patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly);\n } else {\n if (isRealElement) {\n // mounting to a real element\n // check if this is server-rendered content and if we can perform\n // a successful hydration.\n if (oldVnode.nodeType === 1 && oldVnode.hasAttribute('server-rendered')) {\n oldVnode.removeAttribute('server-rendered');\n hydrating = true;\n }\n if (hydrating) {\n if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {\n invokeInsertHook(vnode, insertedVnodeQueue, true);\n return oldVnode\n } else if (process.env.NODE_ENV !== 'production') {\n warn(\n 'The client-side rendered virtual DOM tree is not matching ' +\n 'server-rendered content. This is likely caused by incorrect ' +\n 'HTML markup, for example nesting block-level elements inside ' +\n '<p>, or missing <tbody>. Bailing hydration and performing ' +\n 'full client-side render.'\n );\n }\n }\n // either not server-rendered, or hydration failed.\n // create an empty node and replace it\n oldVnode = emptyNodeAt(oldVnode);\n }\n // replacing existing element\n var oldElm = oldVnode.elm;\n var parentElm$1 = nodeOps.parentNode(oldElm);\n createElm(\n vnode,\n insertedVnodeQueue,\n // extremely rare edge case: do not insert if old element is in a\n // leaving transition. Only happens when combining transition +\n // keep-alive + HOCs. (#4590)\n oldElm._leaveCb ? null : parentElm$1,\n nodeOps.nextSibling(oldElm)\n );\n\n if (vnode.parent) {\n // component root element replaced.\n // update parent placeholder node element, recursively\n var ancestor = vnode.parent;\n while (ancestor) {\n ancestor.elm = vnode.elm;\n ancestor = ancestor.parent;\n }\n if (isPatchable(vnode)) {\n for (var i = 0; i < cbs.create.length; ++i) {\n cbs.create[i](emptyNode, vnode.parent);\n }\n }\n }\n\n if (parentElm$1 !== null) {\n removeVnodes(parentElm$1, [oldVnode], 0, 0);\n } else if (isDef(oldVnode.tag)) {\n invokeDestroyHook(oldVnode);\n }\n }\n }\n\n invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);\n return vnode.elm\n }\n}\n\n/* */\n\nvar directives = {\n create: updateDirectives,\n update: updateDirectives,\n destroy: function unbindDirectives (vnode) {\n updateDirectives(vnode, emptyNode);\n }\n};\n\nfunction updateDirectives (oldVnode, vnode) {\n if (oldVnode.data.directives || vnode.data.directives) {\n _update(oldVnode, vnode);\n }\n}\n\nfunction _update (oldVnode, vnode) {\n var isCreate = oldVnode === emptyNode;\n var isDestroy = vnode === emptyNode;\n var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);\n var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);\n\n var dirsWithInsert = [];\n var dirsWithPostpatch = [];\n\n var key, oldDir, dir;\n for (key in newDirs) {\n oldDir = oldDirs[key];\n dir = newDirs[key];\n if (!oldDir) {\n // new directive, bind\n callHook$1(dir, 'bind', vnode, oldVnode);\n if (dir.def && dir.def.inserted) {\n dirsWithInsert.push(dir);\n }\n } else {\n // existing directive, update\n dir.oldValue = oldDir.value;\n callHook$1(dir, 'update', vnode, oldVnode);\n if (dir.def && dir.def.componentUpdated) {\n dirsWithPostpatch.push(dir);\n }\n }\n }\n\n if (dirsWithInsert.length) {\n var callInsert = function () {\n for (var i = 0; i < dirsWithInsert.length; i++) {\n callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);\n }\n };\n if (isCreate) {\n mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', callInsert, 'dir-insert');\n } else {\n callInsert();\n }\n }\n\n if (dirsWithPostpatch.length) {\n mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'postpatch', function () {\n for (var i = 0; i < dirsWithPostpatch.length; i++) {\n callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);\n }\n }, 'dir-postpatch');\n }\n\n if (!isCreate) {\n for (key in oldDirs) {\n if (!newDirs[key]) {\n // no longer present, unbind\n callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);\n }\n }\n }\n}\n\nvar emptyModifiers = Object.create(null);\n\nfunction normalizeDirectives$1 (\n dirs,\n vm\n) {\n var res = Object.create(null);\n if (!dirs) {\n return res\n }\n var i, dir;\n for (i = 0; i < dirs.length; i++) {\n dir = dirs[i];\n if (!dir.modifiers) {\n dir.modifiers = emptyModifiers;\n }\n res[getRawDirName(dir)] = dir;\n dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);\n }\n return res\n}\n\nfunction getRawDirName (dir) {\n return dir.rawName || ((dir.name) + \".\" + (Object.keys(dir.modifiers || {}).join('.')))\n}\n\nfunction callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {\n var fn = dir.def && dir.def[hook];\n if (fn) {\n fn(vnode.elm, dir, vnode, oldVnode, isDestroy);\n }\n}\n\nvar baseModules = [\n ref,\n directives\n];\n\n/* */\n\nfunction updateAttrs (oldVnode, vnode) {\n if (!oldVnode.data.attrs && !vnode.data.attrs) {\n return\n }\n var key, cur, old;\n var elm = vnode.elm;\n var oldAttrs = oldVnode.data.attrs || {};\n var attrs = vnode.data.attrs || {};\n // clone observed objects, as the user probably wants to mutate it\n if (attrs.__ob__) {\n attrs = vnode.data.attrs = extend({}, attrs);\n }\n\n for (key in attrs) {\n cur = attrs[key];\n old = oldAttrs[key];\n if (old !== cur) {\n setAttr(elm, key, cur);\n }\n }\n // #4391: in IE9, setting type can reset value for input[type=radio]\n /* istanbul ignore if */\n if (isIE9 && attrs.value !== oldAttrs.value) {\n setAttr(elm, 'value', attrs.value);\n }\n for (key in oldAttrs) {\n if (attrs[key] == null) {\n if (isXlink(key)) {\n elm.removeAttributeNS(xlinkNS, getXlinkProp(key));\n } else if (!isEnumeratedAttr(key)) {\n elm.removeAttribute(key);\n }\n }\n }\n}\n\nfunction setAttr (el, key, value) {\n if (isBooleanAttr(key)) {\n // set attribute for blank value\n // e.g. <option disabled>Select one</option>\n if (isFalsyAttrValue(value)) {\n el.removeAttribute(key);\n } else {\n el.setAttribute(key, key);\n }\n } else if (isEnumeratedAttr(key)) {\n el.setAttribute(key, isFalsyAttrValue(value) || value === 'false' ? 'false' : 'true');\n } else if (isXlink(key)) {\n if (isFalsyAttrValue(value)) {\n el.removeAttributeNS(xlinkNS, getXlinkProp(key));\n } else {\n el.setAttributeNS(xlinkNS, key, value);\n }\n } else {\n if (isFalsyAttrValue(value)) {\n el.removeAttribute(key);\n } else {\n el.setAttribute(key, value);\n }\n }\n}\n\nvar attrs = {\n create: updateAttrs,\n update: updateAttrs\n};\n\n/* */\n\nfunction updateClass (oldVnode, vnode) {\n var el = vnode.elm;\n var data = vnode.data;\n var oldData = oldVnode.data;\n if (!data.staticClass && !data.class &&\n (!oldData || (!oldData.staticClass && !oldData.class))) {\n return\n }\n\n var cls = genClassForVnode(vnode);\n\n // handle transition classes\n var transitionClass = el._transitionClasses;\n if (transitionClass) {\n cls = concat(cls, stringifyClass(transitionClass));\n }\n\n // set the class\n if (cls !== el._prevClass) {\n el.setAttribute('class', cls);\n el._prevClass = cls;\n }\n}\n\nvar klass = {\n create: updateClass,\n update: updateClass\n};\n\n/* */\n\nvar target$1;\n\nfunction add$2 (\n event,\n handler,\n once,\n capture\n) {\n if (once) {\n var oldHandler = handler;\n var _target = target$1; // save current target element in closure\n handler = function (ev) {\n remove$3(event, handler, capture, _target);\n arguments.length === 1\n ? oldHandler(ev)\n : oldHandler.apply(null, arguments);\n };\n }\n target$1.addEventListener(event, handler, capture);\n}\n\nfunction remove$3 (\n event,\n handler,\n capture,\n _target\n) {\n (_target || target$1).removeEventListener(event, handler, capture);\n}\n\nfunction updateDOMListeners (oldVnode, vnode) {\n if (!oldVnode.data.on && !vnode.data.on) {\n return\n }\n var on = vnode.data.on || {};\n var oldOn = oldVnode.data.on || {};\n target$1 = vnode.elm;\n updateListeners(on, oldOn, add$2, remove$3, vnode.context);\n}\n\nvar events = {\n create: updateDOMListeners,\n update: updateDOMListeners\n};\n\n/* */\n\nfunction updateDOMProps (oldVnode, vnode) {\n if (!oldVnode.data.domProps && !vnode.data.domProps) {\n return\n }\n var key, cur;\n var elm = vnode.elm;\n var oldProps = oldVnode.data.domProps || {};\n var props = vnode.data.domProps || {};\n // clone observed objects, as the user probably wants to mutate it\n if (props.__ob__) {\n props = vnode.data.domProps = extend({}, props);\n }\n\n for (key in oldProps) {\n if (props[key] == null) {\n elm[key] = '';\n }\n }\n for (key in props) {\n cur = props[key];\n // ignore children if the node has textContent or innerHTML,\n // as these will throw away existing DOM nodes and cause removal errors\n // on subsequent patches (#3360)\n if (key === 'textContent' || key === 'innerHTML') {\n if (vnode.children) { vnode.children.length = 0; }\n if (cur === oldProps[key]) { continue }\n }\n\n if (key === 'value') {\n // store value as _value as well since\n // non-string values will be stringified\n elm._value = cur;\n // avoid resetting cursor position when value is the same\n var strCur = cur == null ? '' : String(cur);\n if (shouldUpdateValue(elm, vnode, strCur)) {\n elm.value = strCur;\n }\n } else {\n elm[key] = cur;\n }\n }\n}\n\n// check platforms/web/util/attrs.js acceptValue\n\n\nfunction shouldUpdateValue (\n elm,\n vnode,\n checkVal\n) {\n return (!elm.composing && (\n vnode.tag === 'option' ||\n isDirty(elm, checkVal) ||\n isInputChanged(vnode, checkVal)\n ))\n}\n\nfunction isDirty (elm, checkVal) {\n // return true when textbox (.number and .trim) loses focus and its value is not equal to the updated value\n return document.activeElement !== elm && elm.value !== checkVal\n}\n\nfunction isInputChanged (vnode, newVal) {\n var value = vnode.elm.value;\n var modifiers = vnode.elm._vModifiers; // injected by v-model runtime\n if ((modifiers && modifiers.number) || vnode.elm.type === 'number') {\n return toNumber(value) !== toNumber(newVal)\n }\n if (modifiers && modifiers.trim) {\n return value.trim() !== newVal.trim()\n }\n return value !== newVal\n}\n\nvar domProps = {\n create: updateDOMProps,\n update: updateDOMProps\n};\n\n/* */\n\nvar parseStyleText = cached(function (cssText) {\n var res = {};\n var listDelimiter = /;(?![^(]*\\))/g;\n var propertyDelimiter = /:(.+)/;\n cssText.split(listDelimiter).forEach(function (item) {\n if (item) {\n var tmp = item.split(propertyDelimiter);\n tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());\n }\n });\n return res\n});\n\n// merge static and dynamic style data on the same vnode\nfunction normalizeStyleData (data) {\n var style = normalizeStyleBinding(data.style);\n // static style is pre-processed into an object during compilation\n // and is always a fresh object, so it's safe to merge into it\n return data.staticStyle\n ? extend(data.staticStyle, style)\n : style\n}\n\n// normalize possible array / string values into Object\nfunction normalizeStyleBinding (bindingStyle) {\n if (Array.isArray(bindingStyle)) {\n return toObject(bindingStyle)\n }\n if (typeof bindingStyle === 'string') {\n return parseStyleText(bindingStyle)\n }\n return bindingStyle\n}\n\n/**\n * parent component style should be after child's\n * so that parent component's style could override it\n */\nfunction getStyle (vnode, checkChild) {\n var res = {};\n var styleData;\n\n if (checkChild) {\n var childNode = vnode;\n while (childNode.componentInstance) {\n childNode = childNode.componentInstance._vnode;\n if (childNode.data && (styleData = normalizeStyleData(childNode.data))) {\n extend(res, styleData);\n }\n }\n }\n\n if ((styleData = normalizeStyleData(vnode.data))) {\n extend(res, styleData);\n }\n\n var parentNode = vnode;\n while ((parentNode = parentNode.parent)) {\n if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {\n extend(res, styleData);\n }\n }\n return res\n}\n\n/* */\n\nvar cssVarRE = /^--/;\nvar importantRE = /\\s*!important$/;\nvar setProp = function (el, name, val) {\n /* istanbul ignore if */\n if (cssVarRE.test(name)) {\n el.style.setProperty(name, val);\n } else if (importantRE.test(val)) {\n el.style.setProperty(name, val.replace(importantRE, ''), 'important');\n } else {\n el.style[normalize(name)] = val;\n }\n};\n\nvar prefixes = ['Webkit', 'Moz', 'ms'];\n\nvar testEl;\nvar normalize = cached(function (prop) {\n testEl = testEl || document.createElement('div');\n prop = camelize(prop);\n if (prop !== 'filter' && (prop in testEl.style)) {\n return prop\n }\n var upper = prop.charAt(0).toUpperCase() + prop.slice(1);\n for (var i = 0; i < prefixes.length; i++) {\n var prefixed = prefixes[i] + upper;\n if (prefixed in testEl.style) {\n return prefixed\n }\n }\n});\n\nfunction updateStyle (oldVnode, vnode) {\n var data = vnode.data;\n var oldData = oldVnode.data;\n\n if (!data.staticStyle && !data.style &&\n !oldData.staticStyle && !oldData.style) {\n return\n }\n\n var cur, name;\n var el = vnode.elm;\n var oldStaticStyle = oldVnode.data.staticStyle;\n var oldStyleBinding = oldVnode.data.style || {};\n\n // if static style exists, stylebinding already merged into it when doing normalizeStyleData\n var oldStyle = oldStaticStyle || oldStyleBinding;\n\n var style = normalizeStyleBinding(vnode.data.style) || {};\n\n vnode.data.style = style.__ob__ ? extend({}, style) : style;\n\n var newStyle = getStyle(vnode, true);\n\n for (name in oldStyle) {\n if (newStyle[name] == null) {\n setProp(el, name, '');\n }\n }\n for (name in newStyle) {\n cur = newStyle[name];\n if (cur !== oldStyle[name]) {\n // ie9 setting to null has no effect, must use empty string\n setProp(el, name, cur == null ? '' : cur);\n }\n }\n}\n\nvar style = {\n create: updateStyle,\n update: updateStyle\n};\n\n/* */\n\n/**\n * Add class with compatibility for SVG since classList is not supported on\n * SVG elements in IE\n */\nfunction addClass (el, cls) {\n /* istanbul ignore if */\n if (!cls || !cls.trim()) {\n return\n }\n\n /* istanbul ignore else */\n if (el.classList) {\n if (cls.indexOf(' ') > -1) {\n cls.split(/\\s+/).forEach(function (c) { return el.classList.add(c); });\n } else {\n el.classList.add(cls);\n }\n } else {\n var cur = ' ' + el.getAttribute('class') + ' ';\n if (cur.indexOf(' ' + cls + ' ') < 0) {\n el.setAttribute('class', (cur + cls).trim());\n }\n }\n}\n\n/**\n * Remove class with compatibility for SVG since classList is not supported on\n * SVG elements in IE\n */\nfunction removeClass (el, cls) {\n /* istanbul ignore if */\n if (!cls || !cls.trim()) {\n return\n }\n\n /* istanbul ignore else */\n if (el.classList) {\n if (cls.indexOf(' ') > -1) {\n cls.split(/\\s+/).forEach(function (c) { return el.classList.remove(c); });\n } else {\n el.classList.remove(cls);\n }\n } else {\n var cur = ' ' + el.getAttribute('class') + ' ';\n var tar = ' ' + cls + ' ';\n while (cur.indexOf(tar) >= 0) {\n cur = cur.replace(tar, ' ');\n }\n el.setAttribute('class', cur.trim());\n }\n}\n\n/* */\n\nvar hasTransition = inBrowser && !isIE9;\nvar TRANSITION = 'transition';\nvar ANIMATION = 'animation';\n\n// Transition property/event sniffing\nvar transitionProp = 'transition';\nvar transitionEndEvent = 'transitionend';\nvar animationProp = 'animation';\nvar animationEndEvent = 'animationend';\nif (hasTransition) {\n /* istanbul ignore if */\n if (window.ontransitionend === undefined &&\n window.onwebkittransitionend !== undefined) {\n transitionProp = 'WebkitTransition';\n transitionEndEvent = 'webkitTransitionEnd';\n }\n if (window.onanimationend === undefined &&\n window.onwebkitanimationend !== undefined) {\n animationProp = 'WebkitAnimation';\n animationEndEvent = 'webkitAnimationEnd';\n }\n}\n\n// binding to window is necessary to make hot reload work in IE in strict mode\nvar raf = inBrowser && window.requestAnimationFrame\n ? window.requestAnimationFrame.bind(window)\n : setTimeout;\n\nfunction nextFrame (fn) {\n raf(function () {\n raf(fn);\n });\n}\n\nfunction addTransitionClass (el, cls) {\n (el._transitionClasses || (el._transitionClasses = [])).push(cls);\n addClass(el, cls);\n}\n\nfunction removeTransitionClass (el, cls) {\n if (el._transitionClasses) {\n remove$1(el._transitionClasses, cls);\n }\n removeClass(el, cls);\n}\n\nfunction whenTransitionEnds (\n el,\n expectedType,\n cb\n) {\n var ref = getTransitionInfo(el, expectedType);\n var type = ref.type;\n var timeout = ref.timeout;\n var propCount = ref.propCount;\n if (!type) { return cb() }\n var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;\n var ended = 0;\n var end = function () {\n el.removeEventListener(event, onEnd);\n cb();\n };\n var onEnd = function (e) {\n if (e.target === el) {\n if (++ended >= propCount) {\n end();\n }\n }\n };\n setTimeout(function () {\n if (ended < propCount) {\n end();\n }\n }, timeout + 1);\n el.addEventListener(event, onEnd);\n}\n\nvar transformRE = /\\b(transform|all)(,|$)/;\n\nfunction getTransitionInfo (el, expectedType) {\n var styles = window.getComputedStyle(el);\n var transitioneDelays = styles[transitionProp + 'Delay'].split(', ');\n var transitionDurations = styles[transitionProp + 'Duration'].split(', ');\n var transitionTimeout = getTimeout(transitioneDelays, transitionDurations);\n var animationDelays = styles[animationProp + 'Delay'].split(', ');\n var animationDurations = styles[animationProp + 'Duration'].split(', ');\n var animationTimeout = getTimeout(animationDelays, animationDurations);\n\n var type;\n var timeout = 0;\n var propCount = 0;\n /* istanbul ignore if */\n if (expectedType === TRANSITION) {\n if (transitionTimeout > 0) {\n type = TRANSITION;\n timeout = transitionTimeout;\n propCount = transitionDurations.length;\n }\n } else if (expectedType === ANIMATION) {\n if (animationTimeout > 0) {\n type = ANIMATION;\n timeout = animationTimeout;\n propCount = animationDurations.length;\n }\n } else {\n timeout = Math.max(transitionTimeout, animationTimeout);\n type = timeout > 0\n ? transitionTimeout > animationTimeout\n ? TRANSITION\n : ANIMATION\n : null;\n propCount = type\n ? type === TRANSITION\n ? transitionDurations.length\n : animationDurations.length\n : 0;\n }\n var hasTransform =\n type === TRANSITION &&\n transformRE.test(styles[transitionProp + 'Property']);\n return {\n type: type,\n timeout: timeout,\n propCount: propCount,\n hasTransform: hasTransform\n }\n}\n\nfunction getTimeout (delays, durations) {\n /* istanbul ignore next */\n while (delays.length < durations.length) {\n delays = delays.concat(delays);\n }\n\n return Math.max.apply(null, durations.map(function (d, i) {\n return toMs(d) + toMs(delays[i])\n }))\n}\n\nfunction toMs (s) {\n return Number(s.slice(0, -1)) * 1000\n}\n\n/* */\n\nfunction enter (vnode, toggleDisplay) {\n var el = vnode.elm;\n\n // call leave callback now\n if (el._leaveCb) {\n el._leaveCb.cancelled = true;\n el._leaveCb();\n }\n\n var data = resolveTransition(vnode.data.transition);\n if (!data) {\n return\n }\n\n /* istanbul ignore if */\n if (el._enterCb || el.nodeType !== 1) {\n return\n }\n\n var css = data.css;\n var type = data.type;\n var enterClass = data.enterClass;\n var enterToClass = data.enterToClass;\n var enterActiveClass = data.enterActiveClass;\n var appearClass = data.appearClass;\n var appearToClass = data.appearToClass;\n var appearActiveClass = data.appearActiveClass;\n var beforeEnter = data.beforeEnter;\n var enter = data.enter;\n var afterEnter = data.afterEnter;\n var enterCancelled = data.enterCancelled;\n var beforeAppear = data.beforeAppear;\n var appear = data.appear;\n var afterAppear = data.afterAppear;\n var appearCancelled = data.appearCancelled;\n\n // activeInstance will always be the <transition> component managing this\n // transition. One edge case to check is when the <transition> is placed\n // as the root node of a child component. In that case we need to check\n // <transition>'s parent for appear check.\n var context = activeInstance;\n var transitionNode = activeInstance.$vnode;\n while (transitionNode && transitionNode.parent) {\n transitionNode = transitionNode.parent;\n context = transitionNode.context;\n }\n\n var isAppear = !context._isMounted || !vnode.isRootInsert;\n\n if (isAppear && !appear && appear !== '') {\n return\n }\n\n var startClass = isAppear ? appearClass : enterClass;\n var activeClass = isAppear ? appearActiveClass : enterActiveClass;\n var toClass = isAppear ? appearToClass : enterToClass;\n var beforeEnterHook = isAppear ? (beforeAppear || beforeEnter) : beforeEnter;\n var enterHook = isAppear ? (typeof appear === 'function' ? appear : enter) : enter;\n var afterEnterHook = isAppear ? (afterAppear || afterEnter) : afterEnter;\n var enterCancelledHook = isAppear ? (appearCancelled || enterCancelled) : enterCancelled;\n\n var expectsCSS = css !== false && !isIE9;\n var userWantsControl =\n enterHook &&\n // enterHook may be a bound method which exposes\n // the length of original fn as _length\n (enterHook._length || enterHook.length) > 1;\n\n var cb = el._enterCb = once(function () {\n if (expectsCSS) {\n removeTransitionClass(el, toClass);\n removeTransitionClass(el, activeClass);\n }\n if (cb.cancelled) {\n if (expectsCSS) {\n removeTransitionClass(el, startClass);\n }\n enterCancelledHook && enterCancelledHook(el);\n } else {\n afterEnterHook && afterEnterHook(el);\n }\n el._enterCb = null;\n });\n\n if (!vnode.data.show) {\n // remove pending leave element on enter by injecting an insert hook\n mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', function () {\n var parent = el.parentNode;\n var pendingNode = parent && parent._pending && parent._pending[vnode.key];\n if (pendingNode &&\n pendingNode.tag === vnode.tag &&\n pendingNode.elm._leaveCb) {\n pendingNode.elm._leaveCb();\n }\n enterHook && enterHook(el, cb);\n }, 'transition-insert');\n }\n\n // start enter transition\n beforeEnterHook && beforeEnterHook(el);\n if (expectsCSS) {\n addTransitionClass(el, startClass);\n addTransitionClass(el, activeClass);\n nextFrame(function () {\n addTransitionClass(el, toClass);\n removeTransitionClass(el, startClass);\n if (!cb.cancelled && !userWantsControl) {\n whenTransitionEnds(el, type, cb);\n }\n });\n }\n\n if (vnode.data.show) {\n toggleDisplay && toggleDisplay();\n enterHook && enterHook(el, cb);\n }\n\n if (!expectsCSS && !userWantsControl) {\n cb();\n }\n}\n\nfunction leave (vnode, rm) {\n var el = vnode.elm;\n\n // call enter callback now\n if (el._enterCb) {\n el._enterCb.cancelled = true;\n el._enterCb();\n }\n\n var data = resolveTransition(vnode.data.transition);\n if (!data) {\n return rm()\n }\n\n /* istanbul ignore if */\n if (el._leaveCb || el.nodeType !== 1) {\n return\n }\n\n var css = data.css;\n var type = data.type;\n var leaveClass = data.leaveClass;\n var leaveToClass = data.leaveToClass;\n var leaveActiveClass = data.leaveActiveClass;\n var beforeLeave = data.beforeLeave;\n var leave = data.leave;\n var afterLeave = data.afterLeave;\n var leaveCancelled = data.leaveCancelled;\n var delayLeave = data.delayLeave;\n\n var expectsCSS = css !== false && !isIE9;\n var userWantsControl =\n leave &&\n // leave hook may be a bound method which exposes\n // the length of original fn as _length\n (leave._length || leave.length) > 1;\n\n var cb = el._leaveCb = once(function () {\n if (el.parentNode && el.parentNode._pending) {\n el.parentNode._pending[vnode.key] = null;\n }\n if (expectsCSS) {\n removeTransitionClass(el, leaveToClass);\n removeTransitionClass(el, leaveActiveClass);\n }\n if (cb.cancelled) {\n if (expectsCSS) {\n removeTransitionClass(el, leaveClass);\n }\n leaveCancelled && leaveCancelled(el);\n } else {\n rm();\n afterLeave && afterLeave(el);\n }\n el._leaveCb = null;\n });\n\n if (delayLeave) {\n delayLeave(performLeave);\n } else {\n performLeave();\n }\n\n function performLeave () {\n // the delayed leave may have already been cancelled\n if (cb.cancelled) {\n return\n }\n // record leaving element\n if (!vnode.data.show) {\n (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;\n }\n beforeLeave && beforeLeave(el);\n if (expectsCSS) {\n addTransitionClass(el, leaveClass);\n addTransitionClass(el, leaveActiveClass);\n nextFrame(function () {\n addTransitionClass(el, leaveToClass);\n removeTransitionClass(el, leaveClass);\n if (!cb.cancelled && !userWantsControl) {\n whenTransitionEnds(el, type, cb);\n }\n });\n }\n leave && leave(el, cb);\n if (!expectsCSS && !userWantsControl) {\n cb();\n }\n }\n}\n\nfunction resolveTransition (def$$1) {\n if (!def$$1) {\n return\n }\n /* istanbul ignore else */\n if (typeof def$$1 === 'object') {\n var res = {};\n if (def$$1.css !== false) {\n extend(res, autoCssTransition(def$$1.name || 'v'));\n }\n extend(res, def$$1);\n return res\n } else if (typeof def$$1 === 'string') {\n return autoCssTransition(def$$1)\n }\n}\n\nvar autoCssTransition = cached(function (name) {\n return {\n enterClass: (name + \"-enter\"),\n leaveClass: (name + \"-leave\"),\n appearClass: (name + \"-enter\"),\n enterToClass: (name + \"-enter-to\"),\n leaveToClass: (name + \"-leave-to\"),\n appearToClass: (name + \"-enter-to\"),\n enterActiveClass: (name + \"-enter-active\"),\n leaveActiveClass: (name + \"-leave-active\"),\n appearActiveClass: (name + \"-enter-active\")\n }\n});\n\nfunction once (fn) {\n var called = false;\n return function () {\n if (!called) {\n called = true;\n fn();\n }\n }\n}\n\nfunction _enter (_, vnode) {\n if (!vnode.data.show) {\n enter(vnode);\n }\n}\n\nvar transition = inBrowser ? {\n create: _enter,\n activate: _enter,\n remove: function remove (vnode, rm) {\n /* istanbul ignore else */\n if (!vnode.data.show) {\n leave(vnode, rm);\n } else {\n rm();\n }\n }\n} : {};\n\nvar platformModules = [\n attrs,\n klass,\n events,\n domProps,\n style,\n transition\n];\n\n/* */\n\n// the directive module should be applied last, after all\n// built-in modules have been applied.\nvar modules = platformModules.concat(baseModules);\n\nvar patch$1 = createPatchFunction({ nodeOps: nodeOps, modules: modules });\n\n/**\n * Not type checking this file because flow doesn't like attaching\n * properties to Elements.\n */\n\nvar modelableTagRE = /^input|select|textarea|vue-component-[0-9]+(-[0-9a-zA-Z_-]*)?$/;\n\n/* istanbul ignore if */\nif (isIE9) {\n // http://www.matts411.com/post/internet-explorer-9-oninput/\n document.addEventListener('selectionchange', function () {\n var el = document.activeElement;\n if (el && el.vmodel) {\n trigger(el, 'input');\n }\n });\n}\n\nvar model = {\n inserted: function inserted (el, binding, vnode) {\n if (process.env.NODE_ENV !== 'production') {\n if (!modelableTagRE.test(vnode.tag)) {\n warn(\n \"v-model is not supported on element type: <\" + (vnode.tag) + \">. \" +\n 'If you are working with contenteditable, it\\'s recommended to ' +\n 'wrap a library dedicated for that purpose inside a custom component.',\n vnode.context\n );\n }\n }\n if (vnode.tag === 'select') {\n var cb = function () {\n setSelected(el, binding, vnode.context);\n };\n cb();\n /* istanbul ignore if */\n if (isIE || isEdge) {\n setTimeout(cb, 0);\n }\n } else if (vnode.tag === 'textarea' || el.type === 'text') {\n el._vModifiers = binding.modifiers;\n if (!binding.modifiers.lazy) {\n if (!isAndroid) {\n el.addEventListener('compositionstart', onCompositionStart);\n el.addEventListener('compositionend', onCompositionEnd);\n }\n /* istanbul ignore if */\n if (isIE9) {\n el.vmodel = true;\n }\n }\n }\n },\n componentUpdated: function componentUpdated (el, binding, vnode) {\n if (vnode.tag === 'select') {\n setSelected(el, binding, vnode.context);\n // in case the options rendered by v-for have changed,\n // it's possible that the value is out-of-sync with the rendered options.\n // detect such cases and filter out values that no longer has a matching\n // option in the DOM.\n var needReset = el.multiple\n ? binding.value.some(function (v) { return hasNoMatchingOption(v, el.options); })\n : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, el.options);\n if (needReset) {\n trigger(el, 'change');\n }\n }\n }\n};\n\nfunction setSelected (el, binding, vm) {\n var value = binding.value;\n var isMultiple = el.multiple;\n if (isMultiple && !Array.isArray(value)) {\n process.env.NODE_ENV !== 'production' && warn(\n \"<select multiple v-model=\\\"\" + (binding.expression) + \"\\\"> \" +\n \"expects an Array value for its binding, but got \" + (Object.prototype.toString.call(value).slice(8, -1)),\n vm\n );\n return\n }\n var selected, option;\n for (var i = 0, l = el.options.length; i < l; i++) {\n option = el.options[i];\n if (isMultiple) {\n selected = looseIndexOf(value, getValue(option)) > -1;\n if (option.selected !== selected) {\n option.selected = selected;\n }\n } else {\n if (looseEqual(getValue(option), value)) {\n if (el.selectedIndex !== i) {\n el.selectedIndex = i;\n }\n return\n }\n }\n }\n if (!isMultiple) {\n el.selectedIndex = -1;\n }\n}\n\nfunction hasNoMatchingOption (value, options) {\n for (var i = 0, l = options.length; i < l; i++) {\n if (looseEqual(getValue(options[i]), value)) {\n return false\n }\n }\n return true\n}\n\nfunction getValue (option) {\n return '_value' in option\n ? option._value\n : option.value\n}\n\nfunction onCompositionStart (e) {\n e.target.composing = true;\n}\n\nfunction onCompositionEnd (e) {\n e.target.composing = false;\n trigger(e.target, 'input');\n}\n\nfunction trigger (el, type) {\n var e = document.createEvent('HTMLEvents');\n e.initEvent(type, true, true);\n el.dispatchEvent(e);\n}\n\n/* */\n\n// recursively search for possible transition defined inside the component root\nfunction locateNode (vnode) {\n return vnode.componentInstance && (!vnode.data || !vnode.data.transition)\n ? locateNode(vnode.componentInstance._vnode)\n : vnode\n}\n\nvar show = {\n bind: function bind (el, ref, vnode) {\n var value = ref.value;\n\n vnode = locateNode(vnode);\n var transition = vnode.data && vnode.data.transition;\n var originalDisplay = el.__vOriginalDisplay =\n el.style.display === 'none' ? '' : el.style.display;\n if (value && transition && !isIE9) {\n vnode.data.show = true;\n enter(vnode, function () {\n el.style.display = originalDisplay;\n });\n } else {\n el.style.display = value ? originalDisplay : 'none';\n }\n },\n\n update: function update (el, ref, vnode) {\n var value = ref.value;\n var oldValue = ref.oldValue;\n\n /* istanbul ignore if */\n if (value === oldValue) { return }\n vnode = locateNode(vnode);\n var transition = vnode.data && vnode.data.transition;\n if (transition && !isIE9) {\n vnode.data.show = true;\n if (value) {\n enter(vnode, function () {\n el.style.display = el.__vOriginalDisplay;\n });\n } else {\n leave(vnode, function () {\n el.style.display = 'none';\n });\n }\n } else {\n el.style.display = value ? el.__vOriginalDisplay : 'none';\n }\n },\n\n unbind: function unbind (\n el,\n binding,\n vnode,\n oldVnode,\n isDestroy\n ) {\n if (!isDestroy) {\n el.style.display = el.__vOriginalDisplay;\n }\n }\n};\n\nvar platformDirectives = {\n model: model,\n show: show\n};\n\n/* */\n\n// Provides transition support for a single element/component.\n// supports transition mode (out-in / in-out)\n\nvar transitionProps = {\n name: String,\n appear: Boolean,\n css: Boolean,\n mode: String,\n type: String,\n enterClass: String,\n leaveClass: String,\n enterToClass: String,\n leaveToClass: String,\n enterActiveClass: String,\n leaveActiveClass: String,\n appearClass: String,\n appearActiveClass: String,\n appearToClass: String\n};\n\n// in case the child is also an abstract component, e.g. <keep-alive>\n// we want to recursively retrieve the real component to be rendered\nfunction getRealChild (vnode) {\n var compOptions = vnode && vnode.componentOptions;\n if (compOptions && compOptions.Ctor.options.abstract) {\n return getRealChild(getFirstComponentChild(compOptions.children))\n } else {\n return vnode\n }\n}\n\nfunction extractTransitionData (comp) {\n var data = {};\n var options = comp.$options;\n // props\n for (var key in options.propsData) {\n data[key] = comp[key];\n }\n // events.\n // extract listeners and pass them directly to the transition methods\n var listeners = options._parentListeners;\n for (var key$1 in listeners) {\n data[camelize(key$1)] = listeners[key$1].fn;\n }\n return data\n}\n\nfunction placeholder (h, rawChild) {\n return /\\d-keep-alive$/.test(rawChild.tag)\n ? h('keep-alive')\n : null\n}\n\nfunction hasParentTransition (vnode) {\n while ((vnode = vnode.parent)) {\n if (vnode.data.transition) {\n return true\n }\n }\n}\n\nfunction isSameChild (child, oldChild) {\n return oldChild.key === child.key && oldChild.tag === child.tag\n}\n\nvar Transition = {\n name: 'transition',\n props: transitionProps,\n abstract: true,\n\n render: function render (h) {\n var this$1 = this;\n\n var children = this.$slots.default;\n if (!children) {\n return\n }\n\n // filter out text nodes (possible whitespaces)\n children = children.filter(function (c) { return c.tag; });\n /* istanbul ignore if */\n if (!children.length) {\n return\n }\n\n // warn multiple elements\n if (process.env.NODE_ENV !== 'production' && children.length > 1) {\n warn(\n '<transition> can only be used on a single element. Use ' +\n '<transition-group> for lists.',\n this.$parent\n );\n }\n\n var mode = this.mode;\n\n // warn invalid mode\n if (process.env.NODE_ENV !== 'production' &&\n mode && mode !== 'in-out' && mode !== 'out-in') {\n warn(\n 'invalid <transition> mode: ' + mode,\n this.$parent\n );\n }\n\n var rawChild = children[0];\n\n // if this is a component root node and the component's\n // parent container node also has transition, skip.\n if (hasParentTransition(this.$vnode)) {\n return rawChild\n }\n\n // apply transition data to child\n // use getRealChild() to ignore abstract components e.g. keep-alive\n var child = getRealChild(rawChild);\n /* istanbul ignore if */\n if (!child) {\n return rawChild\n }\n\n if (this._leaving) {\n return placeholder(h, rawChild)\n }\n\n // ensure a key that is unique to the vnode type and to this transition\n // component instance. This key will be used to remove pending leaving nodes\n // during entering.\n var id = \"__transition-\" + (this._uid) + \"-\";\n var key = child.key = child.key == null\n ? id + child.tag\n : isPrimitive(child.key)\n ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)\n : child.key;\n var data = (child.data || (child.data = {})).transition = extractTransitionData(this);\n var oldRawChild = this._vnode;\n var oldChild = getRealChild(oldRawChild);\n\n // mark v-show\n // so that the transition module can hand over the control to the directive\n if (child.data.directives && child.data.directives.some(function (d) { return d.name === 'show'; })) {\n child.data.show = true;\n }\n\n if (oldChild && oldChild.data && !isSameChild(child, oldChild)) {\n // replace old child transition data with fresh one\n // important for dynamic transitions!\n var oldData = oldChild && (oldChild.data.transition = extend({}, data));\n // handle transition mode\n if (mode === 'out-in') {\n // return placeholder node and queue update when leave finishes\n this._leaving = true;\n mergeVNodeHook(oldData, 'afterLeave', function () {\n this$1._leaving = false;\n this$1.$forceUpdate();\n }, key);\n return placeholder(h, rawChild)\n } else if (mode === 'in-out') {\n var delayedLeave;\n var performLeave = function () { delayedLeave(); };\n mergeVNodeHook(data, 'afterEnter', performLeave, key);\n mergeVNodeHook(data, 'enterCancelled', performLeave, key);\n mergeVNodeHook(oldData, 'delayLeave', function (leave) {\n delayedLeave = leave;\n }, key);\n }\n }\n\n return rawChild\n }\n};\n\n/* */\n\n// Provides transition support for list items.\n// supports move transitions using the FLIP technique.\n\n// Because the vdom's children update algorithm is \"unstable\" - i.e.\n// it doesn't guarantee the relative positioning of removed elements,\n// we force transition-group to update its children into two passes:\n// in the first pass, we remove all nodes that need to be removed,\n// triggering their leaving transition; in the second pass, we insert/move\n// into the final disired state. This way in the second pass removed\n// nodes will remain where they should be.\n\nvar props = extend({\n tag: String,\n moveClass: String\n}, transitionProps);\n\ndelete props.mode;\n\nvar TransitionGroup = {\n props: props,\n\n render: function render (h) {\n var tag = this.tag || this.$vnode.data.tag || 'span';\n var map = Object.create(null);\n var prevChildren = this.prevChildren = this.children;\n var rawChildren = this.$slots.default || [];\n var children = this.children = [];\n var transitionData = extractTransitionData(this);\n\n for (var i = 0; i < rawChildren.length; i++) {\n var c = rawChildren[i];\n if (c.tag) {\n if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {\n children.push(c);\n map[c.key] = c\n ;(c.data || (c.data = {})).transition = transitionData;\n } else if (process.env.NODE_ENV !== 'production') {\n var opts = c.componentOptions;\n var name = opts\n ? (opts.Ctor.options.name || opts.tag)\n : c.tag;\n warn((\"<transition-group> children must be keyed: <\" + name + \">\"));\n }\n }\n }\n\n if (prevChildren) {\n var kept = [];\n var removed = [];\n for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {\n var c$1 = prevChildren[i$1];\n c$1.data.transition = transitionData;\n c$1.data.pos = c$1.elm.getBoundingClientRect();\n if (map[c$1.key]) {\n kept.push(c$1);\n } else {\n removed.push(c$1);\n }\n }\n this.kept = h(tag, null, kept);\n this.removed = removed;\n }\n\n return h(tag, null, children)\n },\n\n beforeUpdate: function beforeUpdate () {\n // force removing pass\n this.__patch__(\n this._vnode,\n this.kept,\n false, // hydrating\n true // removeOnly (!important, avoids unnecessary moves)\n );\n this._vnode = this.kept;\n },\n\n updated: function updated () {\n var children = this.prevChildren;\n var moveClass = this.moveClass || ((this.name || 'v') + '-move');\n if (!children.length || !this.hasMove(children[0].elm, moveClass)) {\n return\n }\n\n // we divide the work into three loops to avoid mixing DOM reads and writes\n // in each iteration - which helps prevent layout thrashing.\n children.forEach(callPendingCbs);\n children.forEach(recordPosition);\n children.forEach(applyTranslation);\n\n // force reflow to put everything in position\n var f = document.body.offsetHeight; // eslint-disable-line\n\n children.forEach(function (c) {\n if (c.data.moved) {\n var el = c.elm;\n var s = el.style;\n addTransitionClass(el, moveClass);\n s.transform = s.WebkitTransform = s.transitionDuration = '';\n el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {\n if (!e || /transform$/.test(e.propertyName)) {\n el.removeEventListener(transitionEndEvent, cb);\n el._moveCb = null;\n removeTransitionClass(el, moveClass);\n }\n });\n }\n });\n },\n\n methods: {\n hasMove: function hasMove (el, moveClass) {\n /* istanbul ignore if */\n if (!hasTransition) {\n return false\n }\n if (this._hasMove != null) {\n return this._hasMove\n }\n addTransitionClass(el, moveClass);\n var info = getTransitionInfo(el);\n removeTransitionClass(el, moveClass);\n return (this._hasMove = info.hasTransform)\n }\n }\n};\n\nfunction callPendingCbs (c) {\n /* istanbul ignore if */\n if (c.elm._moveCb) {\n c.elm._moveCb();\n }\n /* istanbul ignore if */\n if (c.elm._enterCb) {\n c.elm._enterCb();\n }\n}\n\nfunction recordPosition (c) {\n c.data.newPos = c.elm.getBoundingClientRect();\n}\n\nfunction applyTranslation (c) {\n var oldPos = c.data.pos;\n var newPos = c.data.newPos;\n var dx = oldPos.left - newPos.left;\n var dy = oldPos.top - newPos.top;\n if (dx || dy) {\n c.data.moved = true;\n var s = c.elm.style;\n s.transform = s.WebkitTransform = \"translate(\" + dx + \"px,\" + dy + \"px)\";\n s.transitionDuration = '0s';\n }\n}\n\nvar platformComponents = {\n Transition: Transition,\n TransitionGroup: TransitionGroup\n};\n\n/* */\n\n// install platform specific utils\nVue$3.config.isUnknownElement = isUnknownElement;\nVue$3.config.isReservedTag = isReservedTag;\nVue$3.config.getTagNamespace = getTagNamespace;\nVue$3.config.mustUseProp = mustUseProp;\n\n// install platform runtime directives & components\nextend(Vue$3.options.directives, platformDirectives);\nextend(Vue$3.options.components, platformComponents);\n\n// install platform patch function\nVue$3.prototype.__patch__ = inBrowser ? patch$1 : noop;\n\n// wrap mount\nVue$3.prototype.$mount = function (\n el,\n hydrating\n) {\n el = el && inBrowser ? query(el) : undefined;\n return this._mount(el, hydrating)\n};\n\nif (process.env.NODE_ENV !== 'production' &&\n inBrowser && typeof console !== 'undefined') {\n console[console.info ? 'info' : 'log'](\n \"You are running Vue in development mode.\\n\" +\n \"Make sure to turn on production mode when deploying for production.\\n\" +\n \"See more tips at https://vuejs.org/guide/deployment.html\"\n );\n}\n\n// devtools global hook\n/* istanbul ignore next */\nsetTimeout(function () {\n if (config.devtools) {\n if (devtools) {\n devtools.emit('init', Vue$3);\n } else if (\n process.env.NODE_ENV !== 'production' &&\n inBrowser && !isEdge && /Chrome\\/\\d+/.test(window.navigator.userAgent)\n ) {\n console[console.info ? 'info' : 'log'](\n 'Download the Vue Devtools extension for a better development experience:\\n' +\n 'https://github.com/vuejs/vue-devtools'\n );\n }\n }\n}, 0);\n\n/* */\n\n// check whether current browser encodes a char inside attribute values\nfunction shouldDecode (content, encoded) {\n var div = document.createElement('div');\n div.innerHTML = \"<div a=\\\"\" + content + \"\\\">\";\n return div.innerHTML.indexOf(encoded) > 0\n}\n\n// #3663\n// IE encodes newlines inside attribute values while other browsers don't\nvar shouldDecodeNewlines = inBrowser ? shouldDecode('\\n', ' ') : false;\n\n/* */\n\nvar decoder;\n\nfunction decode (html) {\n decoder = decoder || document.createElement('div');\n decoder.innerHTML = html;\n return decoder.textContent\n}\n\n/* */\n\nvar isUnaryTag = makeMap(\n 'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +\n 'link,meta,param,source,track,wbr',\n true\n);\n\n// Elements that you can, intentionally, leave open\n// (and which close themselves)\nvar canBeLeftOpenTag = makeMap(\n 'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source',\n true\n);\n\n// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3\n// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content\nvar isNonPhrasingTag = makeMap(\n 'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +\n 'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +\n 'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +\n 'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +\n 'title,tr,track',\n true\n);\n\n/**\n * Not type-checking this file because it's mostly vendor code.\n */\n\n/*!\n * HTML Parser By John Resig (ejohn.org)\n * Modified by Juriy \"kangax\" Zaytsev\n * Original code by Erik Arvidsson, Mozilla Public License\n * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js\n */\n\n// Regular Expressions for parsing tags and attributes\nvar singleAttrIdentifier = /([^\\s\"'<>/=]+)/;\nvar singleAttrAssign = /(?:=)/;\nvar singleAttrValues = [\n // attr value double quotes\n /\"([^\"]*)\"+/.source,\n // attr value, single quotes\n /'([^']*)'+/.source,\n // attr value, no quotes\n /([^\\s\"'=<>`]+)/.source\n];\nvar attribute = new RegExp(\n '^\\\\s*' + singleAttrIdentifier.source +\n '(?:\\\\s*(' + singleAttrAssign.source + ')' +\n '\\\\s*(?:' + singleAttrValues.join('|') + '))?'\n);\n\n// could use https://www.w3.org/TR/1999/REC-xml-names-19990114/#NT-QName\n// but for Vue templates we can enforce a simple charset\nvar ncname = '[a-zA-Z_][\\\\w\\\\-\\\\.]*';\nvar qnameCapture = '((?:' + ncname + '\\\\:)?' + ncname + ')';\nvar startTagOpen = new RegExp('^<' + qnameCapture);\nvar startTagClose = /^\\s*(\\/?)>/;\nvar endTag = new RegExp('^<\\\\/' + qnameCapture + '[^>]*>');\nvar doctype = /^<!DOCTYPE [^>]+>/i;\nvar comment = /^<!--/;\nvar conditionalComment = /^<!\\[/;\n\nvar IS_REGEX_CAPTURING_BROKEN = false;\n'x'.replace(/x(.)?/g, function (m, g) {\n IS_REGEX_CAPTURING_BROKEN = g === '';\n});\n\n// Special Elements (can contain anything)\nvar isScriptOrStyle = makeMap('script,style', true);\nvar reCache = {};\n\nvar ltRE = /</g;\nvar gtRE = />/g;\nvar nlRE = / /g;\nvar ampRE = /&/g;\nvar quoteRE = /"/g;\n\nfunction decodeAttr (value, shouldDecodeNewlines) {\n if (shouldDecodeNewlines) {\n value = value.replace(nlRE, '\\n');\n }\n return value\n .replace(ltRE, '<')\n .replace(gtRE, '>')\n .replace(ampRE, '&')\n .replace(quoteRE, '\"')\n}\n\nfunction parseHTML (html, options) {\n var stack = [];\n var expectHTML = options.expectHTML;\n var isUnaryTag$$1 = options.isUnaryTag || no;\n var index = 0;\n var last, lastTag;\n while (html) {\n last = html;\n // Make sure we're not in a script or style element\n if (!lastTag || !isScriptOrStyle(lastTag)) {\n var textEnd = html.indexOf('<');\n if (textEnd === 0) {\n // Comment:\n if (comment.test(html)) {\n var commentEnd = html.indexOf('-->');\n\n if (commentEnd >= 0) {\n advance(commentEnd + 3);\n continue\n }\n }\n\n // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment\n if (conditionalComment.test(html)) {\n var conditionalEnd = html.indexOf(']>');\n\n if (conditionalEnd >= 0) {\n advance(conditionalEnd + 2);\n continue\n }\n }\n\n // Doctype:\n var doctypeMatch = html.match(doctype);\n if (doctypeMatch) {\n advance(doctypeMatch[0].length);\n continue\n }\n\n // End tag:\n var endTagMatch = html.match(endTag);\n if (endTagMatch) {\n var curIndex = index;\n advance(endTagMatch[0].length);\n parseEndTag(endTagMatch[1], curIndex, index);\n continue\n }\n\n // Start tag:\n var startTagMatch = parseStartTag();\n if (startTagMatch) {\n handleStartTag(startTagMatch);\n continue\n }\n }\n\n var text = (void 0), rest$1 = (void 0), next = (void 0);\n if (textEnd > 0) {\n rest$1 = html.slice(textEnd);\n while (\n !endTag.test(rest$1) &&\n !startTagOpen.test(rest$1) &&\n !comment.test(rest$1) &&\n !conditionalComment.test(rest$1)\n ) {\n // < in plain text, be forgiving and treat it as text\n next = rest$1.indexOf('<', 1);\n if (next < 0) { break }\n textEnd += next;\n rest$1 = html.slice(textEnd);\n }\n text = html.substring(0, textEnd);\n advance(textEnd);\n }\n\n if (textEnd < 0) {\n text = html;\n html = '';\n }\n\n if (options.chars && text) {\n options.chars(text);\n }\n } else {\n var stackedTag = lastTag.toLowerCase();\n var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\\\s\\\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));\n var endTagLength = 0;\n var rest = html.replace(reStackedTag, function (all, text, endTag) {\n endTagLength = endTag.length;\n if (stackedTag !== 'script' && stackedTag !== 'style' && stackedTag !== 'noscript') {\n text = text\n .replace(/<!--([\\s\\S]*?)-->/g, '$1')\n .replace(/<!\\[CDATA\\[([\\s\\S]*?)]]>/g, '$1');\n }\n if (options.chars) {\n options.chars(text);\n }\n return ''\n });\n index += html.length - rest.length;\n html = rest;\n parseEndTag(stackedTag, index - endTagLength, index);\n }\n\n if (html === last && options.chars) {\n options.chars(html);\n break\n }\n }\n\n // Clean up any remaining tags\n parseEndTag();\n\n function advance (n) {\n index += n;\n html = html.substring(n);\n }\n\n function parseStartTag () {\n var start = html.match(startTagOpen);\n if (start) {\n var match = {\n tagName: start[1],\n attrs: [],\n start: index\n };\n advance(start[0].length);\n var end, attr;\n while (!(end = html.match(startTagClose)) && (attr = html.match(attribute))) {\n advance(attr[0].length);\n match.attrs.push(attr);\n }\n if (end) {\n match.unarySlash = end[1];\n advance(end[0].length);\n match.end = index;\n return match\n }\n }\n }\n\n function handleStartTag (match) {\n var tagName = match.tagName;\n var unarySlash = match.unarySlash;\n\n if (expectHTML) {\n if (lastTag === 'p' && isNonPhrasingTag(tagName)) {\n parseEndTag(lastTag);\n }\n if (canBeLeftOpenTag(tagName) && lastTag === tagName) {\n parseEndTag(tagName);\n }\n }\n\n var unary = isUnaryTag$$1(tagName) || tagName === 'html' && lastTag === 'head' || !!unarySlash;\n\n var l = match.attrs.length;\n var attrs = new Array(l);\n for (var i = 0; i < l; i++) {\n var args = match.attrs[i];\n // hackish work around FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778\n if (IS_REGEX_CAPTURING_BROKEN && args[0].indexOf('\"\"') === -1) {\n if (args[3] === '') { delete args[3]; }\n if (args[4] === '') { delete args[4]; }\n if (args[5] === '') { delete args[5]; }\n }\n var value = args[3] || args[4] || args[5] || '';\n attrs[i] = {\n name: args[1],\n value: decodeAttr(\n value,\n options.shouldDecodeNewlines\n )\n };\n }\n\n if (!unary) {\n stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs });\n lastTag = tagName;\n unarySlash = '';\n }\n\n if (options.start) {\n options.start(tagName, attrs, unary, match.start, match.end);\n }\n }\n\n function parseEndTag (tagName, start, end) {\n var pos, lowerCasedTagName;\n if (start == null) { start = index; }\n if (end == null) { end = index; }\n\n if (tagName) {\n lowerCasedTagName = tagName.toLowerCase();\n }\n\n // Find the closest opened tag of the same type\n if (tagName) {\n for (pos = stack.length - 1; pos >= 0; pos--) {\n if (stack[pos].lowerCasedTag === lowerCasedTagName) {\n break\n }\n }\n } else {\n // If no tag name is provided, clean shop\n pos = 0;\n }\n\n if (pos >= 0) {\n // Close all the open elements, up the stack\n for (var i = stack.length - 1; i >= pos; i--) {\n if (options.end) {\n options.end(stack[i].tag, start, end);\n }\n }\n\n // Remove the open elements from the stack\n stack.length = pos;\n lastTag = pos && stack[pos - 1].tag;\n } else if (lowerCasedTagName === 'br') {\n if (options.start) {\n options.start(tagName, [], true, start, end);\n }\n } else if (lowerCasedTagName === 'p') {\n if (options.start) {\n options.start(tagName, [], false, start, end);\n }\n if (options.end) {\n options.end(tagName, start, end);\n }\n }\n }\n}\n\n/* */\n\nfunction parseFilters (exp) {\n var inSingle = false;\n var inDouble = false;\n var inTemplateString = false;\n var inRegex = false;\n var curly = 0;\n var square = 0;\n var paren = 0;\n var lastFilterIndex = 0;\n var c, prev, i, expression, filters;\n\n for (i = 0; i < exp.length; i++) {\n prev = c;\n c = exp.charCodeAt(i);\n if (inSingle) {\n if (c === 0x27 && prev !== 0x5C) { inSingle = false; }\n } else if (inDouble) {\n if (c === 0x22 && prev !== 0x5C) { inDouble = false; }\n } else if (inTemplateString) {\n if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }\n } else if (inRegex) {\n if (c === 0x2f && prev !== 0x5C) { inRegex = false; }\n } else if (\n c === 0x7C && // pipe\n exp.charCodeAt(i + 1) !== 0x7C &&\n exp.charCodeAt(i - 1) !== 0x7C &&\n !curly && !square && !paren\n ) {\n if (expression === undefined) {\n // first filter, end of expression\n lastFilterIndex = i + 1;\n expression = exp.slice(0, i).trim();\n } else {\n pushFilter();\n }\n } else {\n switch (c) {\n case 0x22: inDouble = true; break // \"\n case 0x27: inSingle = true; break // '\n case 0x60: inTemplateString = true; break // `\n case 0x28: paren++; break // (\n case 0x29: paren--; break // )\n case 0x5B: square++; break // [\n case 0x5D: square--; break // ]\n case 0x7B: curly++; break // {\n case 0x7D: curly--; break // }\n }\n if (c === 0x2f) { // /\n var j = i - 1;\n var p = (void 0);\n // find first non-whitespace prev char\n for (; j >= 0; j--) {\n p = exp.charAt(j);\n if (p !== ' ') { break }\n }\n if (!p || !/[\\w$]/.test(p)) {\n inRegex = true;\n }\n }\n }\n }\n\n if (expression === undefined) {\n expression = exp.slice(0, i).trim();\n } else if (lastFilterIndex !== 0) {\n pushFilter();\n }\n\n function pushFilter () {\n (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());\n lastFilterIndex = i + 1;\n }\n\n if (filters) {\n for (i = 0; i < filters.length; i++) {\n expression = wrapFilter(expression, filters[i]);\n }\n }\n\n return expression\n}\n\nfunction wrapFilter (exp, filter) {\n var i = filter.indexOf('(');\n if (i < 0) {\n // _f: resolveFilter\n return (\"_f(\\\"\" + filter + \"\\\")(\" + exp + \")\")\n } else {\n var name = filter.slice(0, i);\n var args = filter.slice(i + 1);\n return (\"_f(\\\"\" + name + \"\\\")(\" + exp + \",\" + args)\n }\n}\n\n/* */\n\nvar defaultTagRE = /\\{\\{((?:.|\\n)+?)\\}\\}/g;\nvar regexEscapeRE = /[-.*+?^${}()|[\\]\\/\\\\]/g;\n\nvar buildRegex = cached(function (delimiters) {\n var open = delimiters[0].replace(regexEscapeRE, '\\\\$&');\n var close = delimiters[1].replace(regexEscapeRE, '\\\\$&');\n return new RegExp(open + '((?:.|\\\\n)+?)' + close, 'g')\n});\n\nfunction parseText (\n text,\n delimiters\n) {\n var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;\n if (!tagRE.test(text)) {\n return\n }\n var tokens = [];\n var lastIndex = tagRE.lastIndex = 0;\n var match, index;\n while ((match = tagRE.exec(text))) {\n index = match.index;\n // push text token\n if (index > lastIndex) {\n tokens.push(JSON.stringify(text.slice(lastIndex, index)));\n }\n // tag token\n var exp = parseFilters(match[1].trim());\n tokens.push((\"_s(\" + exp + \")\"));\n lastIndex = index + match[0].length;\n }\n if (lastIndex < text.length) {\n tokens.push(JSON.stringify(text.slice(lastIndex)));\n }\n return tokens.join('+')\n}\n\n/* */\n\nfunction baseWarn (msg) {\n console.error((\"[Vue parser]: \" + msg));\n}\n\nfunction pluckModuleFunction (\n modules,\n key\n) {\n return modules\n ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })\n : []\n}\n\nfunction addProp (el, name, value) {\n (el.props || (el.props = [])).push({ name: name, value: value });\n}\n\nfunction addAttr (el, name, value) {\n (el.attrs || (el.attrs = [])).push({ name: name, value: value });\n}\n\nfunction addDirective (\n el,\n name,\n rawName,\n value,\n arg,\n modifiers\n) {\n (el.directives || (el.directives = [])).push({ name: name, rawName: rawName, value: value, arg: arg, modifiers: modifiers });\n}\n\nfunction addHandler (\n el,\n name,\n value,\n modifiers,\n important\n) {\n // check capture modifier\n if (modifiers && modifiers.capture) {\n delete modifiers.capture;\n name = '!' + name; // mark the event as captured\n }\n if (modifiers && modifiers.once) {\n delete modifiers.once;\n name = '~' + name; // mark the event as once\n }\n var events;\n if (modifiers && modifiers.native) {\n delete modifiers.native;\n events = el.nativeEvents || (el.nativeEvents = {});\n } else {\n events = el.events || (el.events = {});\n }\n var newHandler = { value: value, modifiers: modifiers };\n var handlers = events[name];\n /* istanbul ignore if */\n if (Array.isArray(handlers)) {\n important ? handlers.unshift(newHandler) : handlers.push(newHandler);\n } else if (handlers) {\n events[name] = important ? [newHandler, handlers] : [handlers, newHandler];\n } else {\n events[name] = newHandler;\n }\n}\n\nfunction getBindingAttr (\n el,\n name,\n getStatic\n) {\n var dynamicValue =\n getAndRemoveAttr(el, ':' + name) ||\n getAndRemoveAttr(el, 'v-bind:' + name);\n if (dynamicValue != null) {\n return parseFilters(dynamicValue)\n } else if (getStatic !== false) {\n var staticValue = getAndRemoveAttr(el, name);\n if (staticValue != null) {\n return JSON.stringify(staticValue)\n }\n }\n}\n\nfunction getAndRemoveAttr (el, name) {\n var val;\n if ((val = el.attrsMap[name]) != null) {\n var list = el.attrsList;\n for (var i = 0, l = list.length; i < l; i++) {\n if (list[i].name === name) {\n list.splice(i, 1);\n break\n }\n }\n }\n return val\n}\n\nvar len;\nvar str;\nvar chr;\nvar index$1;\nvar expressionPos;\nvar expressionEndPos;\n\n/**\n * parse directive model to do the array update transform. a[idx] = val => $$a.splice($$idx, 1, val)\n *\n * for loop possible cases:\n *\n * - test\n * - test[idx]\n * - test[test1[idx]]\n * - test[\"a\"][idx]\n * - xxx.test[a[a].test1[idx]]\n * - test.xxx.a[\"asa\"][test1[idx]]\n *\n */\n\nfunction parseModel (val) {\n str = val;\n len = str.length;\n index$1 = expressionPos = expressionEndPos = 0;\n\n if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {\n return {\n exp: val,\n idx: null\n }\n }\n\n while (!eof()) {\n chr = next();\n /* istanbul ignore if */\n if (isStringStart(chr)) {\n parseString(chr);\n } else if (chr === 0x5B) {\n parseBracket(chr);\n }\n }\n\n return {\n exp: val.substring(0, expressionPos),\n idx: val.substring(expressionPos + 1, expressionEndPos)\n }\n}\n\nfunction next () {\n return str.charCodeAt(++index$1)\n}\n\nfunction eof () {\n return index$1 >= len\n}\n\nfunction isStringStart (chr) {\n return chr === 0x22 || chr === 0x27\n}\n\nfunction parseBracket (chr) {\n var inBracket = 1;\n expressionPos = index$1;\n while (!eof()) {\n chr = next();\n if (isStringStart(chr)) {\n parseString(chr);\n continue\n }\n if (chr === 0x5B) { inBracket++; }\n if (chr === 0x5D) { inBracket--; }\n if (inBracket === 0) {\n expressionEndPos = index$1;\n break\n }\n }\n}\n\nfunction parseString (chr) {\n var stringQuote = chr;\n while (!eof()) {\n chr = next();\n if (chr === stringQuote) {\n break\n }\n }\n}\n\n/* */\n\nvar dirRE = /^v-|^@|^:/;\nvar forAliasRE = /(.*?)\\s+(?:in|of)\\s+(.*)/;\nvar forIteratorRE = /\\((\\{[^}]*\\}|[^,]*),([^,]*)(?:,([^,]*))?\\)/;\nvar bindRE = /^:|^v-bind:/;\nvar onRE = /^@|^v-on:/;\nvar argRE = /:(.*)$/;\nvar modifierRE = /\\.[^.]+/g;\n\nvar decodeHTMLCached = cached(decode);\n\n// configurable state\nvar warn$1;\nvar platformGetTagNamespace;\nvar platformMustUseProp;\nvar platformIsPreTag;\nvar preTransforms;\nvar transforms;\nvar postTransforms;\nvar delimiters;\n\n/**\n * Convert HTML string to AST.\n */\nfunction parse (\n template,\n options\n) {\n warn$1 = options.warn || baseWarn;\n platformGetTagNamespace = options.getTagNamespace || no;\n platformMustUseProp = options.mustUseProp || no;\n platformIsPreTag = options.isPreTag || no;\n preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');\n transforms = pluckModuleFunction(options.modules, 'transformNode');\n postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');\n delimiters = options.delimiters;\n var stack = [];\n var preserveWhitespace = options.preserveWhitespace !== false;\n var root;\n var currentParent;\n var inVPre = false;\n var inPre = false;\n var warned = false;\n parseHTML(template, {\n expectHTML: options.expectHTML,\n isUnaryTag: options.isUnaryTag,\n shouldDecodeNewlines: options.shouldDecodeNewlines,\n start: function start (tag, attrs, unary) {\n // check namespace.\n // inherit parent ns if there is one\n var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);\n\n // handle IE svg bug\n /* istanbul ignore if */\n if (isIE && ns === 'svg') {\n attrs = guardIESVGBug(attrs);\n }\n\n var element = {\n type: 1,\n tag: tag,\n attrsList: attrs,\n attrsMap: makeAttrsMap(attrs),\n parent: currentParent,\n children: []\n };\n if (ns) {\n element.ns = ns;\n }\n\n if (isForbiddenTag(element) && !isServerRendering()) {\n element.forbidden = true;\n process.env.NODE_ENV !== 'production' && warn$1(\n 'Templates should only be responsible for mapping the state to the ' +\n 'UI. Avoid placing tags with side-effects in your templates, such as ' +\n \"<\" + tag + \">\" + ', as they will not be parsed.'\n );\n }\n\n // apply pre-transforms\n for (var i = 0; i < preTransforms.length; i++) {\n preTransforms[i](element, options);\n }\n\n if (!inVPre) {\n processPre(element);\n if (element.pre) {\n inVPre = true;\n }\n }\n if (platformIsPreTag(element.tag)) {\n inPre = true;\n }\n if (inVPre) {\n processRawAttrs(element);\n } else {\n processFor(element);\n processIf(element);\n processOnce(element);\n processKey(element);\n\n // determine whether this is a plain element after\n // removing structural attributes\n element.plain = !element.key && !attrs.length;\n\n processRef(element);\n processSlot(element);\n processComponent(element);\n for (var i$1 = 0; i$1 < transforms.length; i$1++) {\n transforms[i$1](element, options);\n }\n processAttrs(element);\n }\n\n function checkRootConstraints (el) {\n if (process.env.NODE_ENV !== 'production' && !warned) {\n if (el.tag === 'slot' || el.tag === 'template') {\n warned = true;\n warn$1(\n \"Cannot use <\" + (el.tag) + \"> as component root element because it may \" +\n 'contain multiple nodes:\\n' + template\n );\n }\n if (el.attrsMap.hasOwnProperty('v-for')) {\n warned = true;\n warn$1(\n 'Cannot use v-for on stateful component root element because ' +\n 'it renders multiple elements:\\n' + template\n );\n }\n }\n }\n\n // tree management\n if (!root) {\n root = element;\n checkRootConstraints(root);\n } else if (!stack.length) {\n // allow root elements with v-if, v-else-if and v-else\n if (root.if && (element.elseif || element.else)) {\n checkRootConstraints(element);\n addIfCondition(root, {\n exp: element.elseif,\n block: element\n });\n } else if (process.env.NODE_ENV !== 'production' && !warned) {\n warned = true;\n warn$1(\n \"Component template should contain exactly one root element:\" +\n \"\\n\\n\" + template + \"\\n\\n\" +\n \"If you are using v-if on multiple elements, \" +\n \"use v-else-if to chain them instead.\"\n );\n }\n }\n if (currentParent && !element.forbidden) {\n if (element.elseif || element.else) {\n processIfConditions(element, currentParent);\n } else if (element.slotScope) { // scoped slot\n currentParent.plain = false;\n var name = element.slotTarget || 'default';(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;\n } else {\n currentParent.children.push(element);\n element.parent = currentParent;\n }\n }\n if (!unary) {\n currentParent = element;\n stack.push(element);\n }\n // apply post-transforms\n for (var i$2 = 0; i$2 < postTransforms.length; i$2++) {\n postTransforms[i$2](element, options);\n }\n },\n\n end: function end () {\n // remove trailing whitespace\n var element = stack[stack.length - 1];\n var lastNode = element.children[element.children.length - 1];\n if (lastNode && lastNode.type === 3 && lastNode.text === ' ') {\n element.children.pop();\n }\n // pop stack\n stack.length -= 1;\n currentParent = stack[stack.length - 1];\n // check pre state\n if (element.pre) {\n inVPre = false;\n }\n if (platformIsPreTag(element.tag)) {\n inPre = false;\n }\n },\n\n chars: function chars (text) {\n if (!currentParent) {\n if (process.env.NODE_ENV !== 'production' && !warned && text === template) {\n warned = true;\n warn$1(\n 'Component template requires a root element, rather than just text:\\n\\n' + template\n );\n }\n return\n }\n // IE textarea placeholder bug\n /* istanbul ignore if */\n if (isIE &&\n currentParent.tag === 'textarea' &&\n currentParent.attrsMap.placeholder === text) {\n return\n }\n var children = currentParent.children;\n text = inPre || text.trim()\n ? decodeHTMLCached(text)\n // only preserve whitespace if its not right after a starting tag\n : preserveWhitespace && children.length ? ' ' : '';\n if (text) {\n var expression;\n if (!inVPre && text !== ' ' && (expression = parseText(text, delimiters))) {\n children.push({\n type: 2,\n expression: expression,\n text: text\n });\n } else if (text !== ' ' || children[children.length - 1].text !== ' ') {\n currentParent.children.push({\n type: 3,\n text: text\n });\n }\n }\n }\n });\n return root\n}\n\nfunction processPre (el) {\n if (getAndRemoveAttr(el, 'v-pre') != null) {\n el.pre = true;\n }\n}\n\nfunction processRawAttrs (el) {\n var l = el.attrsList.length;\n if (l) {\n var attrs = el.attrs = new Array(l);\n for (var i = 0; i < l; i++) {\n attrs[i] = {\n name: el.attrsList[i].name,\n value: JSON.stringify(el.attrsList[i].value)\n };\n }\n } else if (!el.pre) {\n // non root node in pre blocks with no attributes\n el.plain = true;\n }\n}\n\nfunction processKey (el) {\n var exp = getBindingAttr(el, 'key');\n if (exp) {\n if (process.env.NODE_ENV !== 'production' && el.tag === 'template') {\n warn$1(\"<template> cannot be keyed. Place the key on real elements instead.\");\n }\n el.key = exp;\n }\n}\n\nfunction processRef (el) {\n var ref = getBindingAttr(el, 'ref');\n if (ref) {\n el.ref = ref;\n el.refInFor = checkInFor(el);\n }\n}\n\nfunction processFor (el) {\n var exp;\n if ((exp = getAndRemoveAttr(el, 'v-for'))) {\n var inMatch = exp.match(forAliasRE);\n if (!inMatch) {\n process.env.NODE_ENV !== 'production' && warn$1(\n (\"Invalid v-for expression: \" + exp)\n );\n return\n }\n el.for = inMatch[2].trim();\n var alias = inMatch[1].trim();\n var iteratorMatch = alias.match(forIteratorRE);\n if (iteratorMatch) {\n el.alias = iteratorMatch[1].trim();\n el.iterator1 = iteratorMatch[2].trim();\n if (iteratorMatch[3]) {\n el.iterator2 = iteratorMatch[3].trim();\n }\n } else {\n el.alias = alias;\n }\n }\n}\n\nfunction processIf (el) {\n var exp = getAndRemoveAttr(el, 'v-if');\n if (exp) {\n el.if = exp;\n addIfCondition(el, {\n exp: exp,\n block: el\n });\n } else {\n if (getAndRemoveAttr(el, 'v-else') != null) {\n el.else = true;\n }\n var elseif = getAndRemoveAttr(el, 'v-else-if');\n if (elseif) {\n el.elseif = elseif;\n }\n }\n}\n\nfunction processIfConditions (el, parent) {\n var prev = findPrevElement(parent.children);\n if (prev && prev.if) {\n addIfCondition(prev, {\n exp: el.elseif,\n block: el\n });\n } else if (process.env.NODE_ENV !== 'production') {\n warn$1(\n \"v-\" + (el.elseif ? ('else-if=\"' + el.elseif + '\"') : 'else') + \" \" +\n \"used on element <\" + (el.tag) + \"> without corresponding v-if.\"\n );\n }\n}\n\nfunction findPrevElement (children) {\n var i = children.length;\n while (i--) {\n if (children[i].type === 1) {\n return children[i]\n } else {\n if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {\n warn$1(\n \"text \\\"\" + (children[i].text.trim()) + \"\\\" between v-if and v-else(-if) \" +\n \"will be ignored.\"\n );\n }\n children.pop();\n }\n }\n}\n\nfunction addIfCondition (el, condition) {\n if (!el.ifConditions) {\n el.ifConditions = [];\n }\n el.ifConditions.push(condition);\n}\n\nfunction processOnce (el) {\n var once = getAndRemoveAttr(el, 'v-once');\n if (once != null) {\n el.once = true;\n }\n}\n\nfunction processSlot (el) {\n if (el.tag === 'slot') {\n el.slotName = getBindingAttr(el, 'name');\n if (process.env.NODE_ENV !== 'production' && el.key) {\n warn$1(\n \"`key` does not work on <slot> because slots are abstract outlets \" +\n \"and can possibly expand into multiple elements. \" +\n \"Use the key on a wrapping element instead.\"\n );\n }\n } else {\n var slotTarget = getBindingAttr(el, 'slot');\n if (slotTarget) {\n el.slotTarget = slotTarget === '\"\"' ? '\"default\"' : slotTarget;\n }\n if (el.tag === 'template') {\n el.slotScope = getAndRemoveAttr(el, 'scope');\n }\n }\n}\n\nfunction processComponent (el) {\n var binding;\n if ((binding = getBindingAttr(el, 'is'))) {\n el.component = binding;\n }\n if (getAndRemoveAttr(el, 'inline-template') != null) {\n el.inlineTemplate = true;\n }\n}\n\nfunction processAttrs (el) {\n var list = el.attrsList;\n var i, l, name, rawName, value, arg, modifiers, isProp;\n for (i = 0, l = list.length; i < l; i++) {\n name = rawName = list[i].name;\n value = list[i].value;\n if (dirRE.test(name)) {\n // mark element as dynamic\n el.hasBindings = true;\n // modifiers\n modifiers = parseModifiers(name);\n if (modifiers) {\n name = name.replace(modifierRE, '');\n }\n if (bindRE.test(name)) { // v-bind\n name = name.replace(bindRE, '');\n value = parseFilters(value);\n isProp = false;\n if (modifiers) {\n if (modifiers.prop) {\n isProp = true;\n name = camelize(name);\n if (name === 'innerHtml') { name = 'innerHTML'; }\n }\n if (modifiers.camel) {\n name = camelize(name);\n }\n }\n if (isProp || platformMustUseProp(el.tag, el.attrsMap.type, name)) {\n addProp(el, name, value);\n } else {\n addAttr(el, name, value);\n }\n } else if (onRE.test(name)) { // v-on\n name = name.replace(onRE, '');\n addHandler(el, name, value, modifiers);\n } else { // normal directives\n name = name.replace(dirRE, '');\n // parse arg\n var argMatch = name.match(argRE);\n if (argMatch && (arg = argMatch[1])) {\n name = name.slice(0, -(arg.length + 1));\n }\n addDirective(el, name, rawName, value, arg, modifiers);\n if (process.env.NODE_ENV !== 'production' && name === 'model') {\n checkForAliasModel(el, value);\n }\n }\n } else {\n // literal attribute\n if (process.env.NODE_ENV !== 'production') {\n var expression = parseText(value, delimiters);\n if (expression) {\n warn$1(\n name + \"=\\\"\" + value + \"\\\": \" +\n 'Interpolation inside attributes has been removed. ' +\n 'Use v-bind or the colon shorthand instead. For example, ' +\n 'instead of <div id=\"{{ val }}\">, use <div :id=\"val\">.'\n );\n }\n }\n addAttr(el, name, JSON.stringify(value));\n }\n }\n}\n\nfunction checkInFor (el) {\n var parent = el;\n while (parent) {\n if (parent.for !== undefined) {\n return true\n }\n parent = parent.parent;\n }\n return false\n}\n\nfunction parseModifiers (name) {\n var match = name.match(modifierRE);\n if (match) {\n var ret = {};\n match.forEach(function (m) { ret[m.slice(1)] = true; });\n return ret\n }\n}\n\nfunction makeAttrsMap (attrs) {\n var map = {};\n for (var i = 0, l = attrs.length; i < l; i++) {\n if (process.env.NODE_ENV !== 'production' && map[attrs[i].name] && !isIE) {\n warn$1('duplicate attribute: ' + attrs[i].name);\n }\n map[attrs[i].name] = attrs[i].value;\n }\n return map\n}\n\nfunction isForbiddenTag (el) {\n return (\n el.tag === 'style' ||\n (el.tag === 'script' && (\n !el.attrsMap.type ||\n el.attrsMap.type === 'text/javascript'\n ))\n )\n}\n\nvar ieNSBug = /^xmlns:NS\\d+/;\nvar ieNSPrefix = /^NS\\d+:/;\n\n/* istanbul ignore next */\nfunction guardIESVGBug (attrs) {\n var res = [];\n for (var i = 0; i < attrs.length; i++) {\n var attr = attrs[i];\n if (!ieNSBug.test(attr.name)) {\n attr.name = attr.name.replace(ieNSPrefix, '');\n res.push(attr);\n }\n }\n return res\n}\n\nfunction checkForAliasModel (el, value) {\n var _el = el;\n while (_el) {\n if (_el.for && _el.alias === value) {\n warn$1(\n \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\">: \" +\n \"You are binding v-model directly to a v-for iteration alias. \" +\n \"This will not be able to modify the v-for source array because \" +\n \"writing to the alias is like modifying a function local variable. \" +\n \"Consider using an array of objects and use v-model on an object property instead.\"\n );\n }\n _el = _el.parent;\n }\n}\n\n/* */\n\nvar isStaticKey;\nvar isPlatformReservedTag;\n\nvar genStaticKeysCached = cached(genStaticKeys$1);\n\n/**\n * Goal of the optimizer: walk the generated template AST tree\n * and detect sub-trees that are purely static, i.e. parts of\n * the DOM that never needs to change.\n *\n * Once we detect these sub-trees, we can:\n *\n * 1. Hoist them into constants, so that we no longer need to\n * create fresh nodes for them on each re-render;\n * 2. Completely skip them in the patching process.\n */\nfunction optimize (root, options) {\n if (!root) { return }\n isStaticKey = genStaticKeysCached(options.staticKeys || '');\n isPlatformReservedTag = options.isReservedTag || no;\n // first pass: mark all non-static nodes.\n markStatic(root);\n // second pass: mark static roots.\n markStaticRoots(root, false);\n}\n\nfunction genStaticKeys$1 (keys) {\n return makeMap(\n 'type,tag,attrsList,attrsMap,plain,parent,children,attrs' +\n (keys ? ',' + keys : '')\n )\n}\n\nfunction markStatic (node) {\n node.static = isStatic(node);\n if (node.type === 1) {\n // do not make component slot content static. this avoids\n // 1. components not able to mutate slot nodes\n // 2. static slot content fails for hot-reloading\n if (\n !isPlatformReservedTag(node.tag) &&\n node.tag !== 'slot' &&\n node.attrsMap['inline-template'] == null\n ) {\n return\n }\n for (var i = 0, l = node.children.length; i < l; i++) {\n var child = node.children[i];\n markStatic(child);\n if (!child.static) {\n node.static = false;\n }\n }\n }\n}\n\nfunction markStaticRoots (node, isInFor) {\n if (node.type === 1) {\n if (node.static || node.once) {\n node.staticInFor = isInFor;\n }\n // For a node to qualify as a static root, it should have children that\n // are not just static text. Otherwise the cost of hoisting out will\n // outweigh the benefits and it's better off to just always render it fresh.\n if (node.static && node.children.length && !(\n node.children.length === 1 &&\n node.children[0].type === 3\n )) {\n node.staticRoot = true;\n return\n } else {\n node.staticRoot = false;\n }\n if (node.children) {\n for (var i = 0, l = node.children.length; i < l; i++) {\n markStaticRoots(node.children[i], isInFor || !!node.for);\n }\n }\n if (node.ifConditions) {\n walkThroughConditionsBlocks(node.ifConditions, isInFor);\n }\n }\n}\n\nfunction walkThroughConditionsBlocks (conditionBlocks, isInFor) {\n for (var i = 1, len = conditionBlocks.length; i < len; i++) {\n markStaticRoots(conditionBlocks[i].block, isInFor);\n }\n}\n\nfunction isStatic (node) {\n if (node.type === 2) { // expression\n return false\n }\n if (node.type === 3) { // text\n return true\n }\n return !!(node.pre || (\n !node.hasBindings && // no dynamic bindings\n !node.if && !node.for && // not v-if or v-for or v-else\n !isBuiltInTag(node.tag) && // not a built-in\n isPlatformReservedTag(node.tag) && // not a component\n !isDirectChildOfTemplateFor(node) &&\n Object.keys(node).every(isStaticKey)\n ))\n}\n\nfunction isDirectChildOfTemplateFor (node) {\n while (node.parent) {\n node = node.parent;\n if (node.tag !== 'template') {\n return false\n }\n if (node.for) {\n return true\n }\n }\n return false\n}\n\n/* */\n\nvar fnExpRE = /^\\s*([\\w$_]+|\\([^)]*?\\))\\s*=>|^function\\s*\\(/;\nvar simplePathRE = /^\\s*[A-Za-z_$][\\w$]*(?:\\.[A-Za-z_$][\\w$]*|\\['.*?']|\\[\".*?\"]|\\[\\d+]|\\[[A-Za-z_$][\\w$]*])*\\s*$/;\n\n// keyCode aliases\nvar keyCodes = {\n esc: 27,\n tab: 9,\n enter: 13,\n space: 32,\n up: 38,\n left: 37,\n right: 39,\n down: 40,\n 'delete': [8, 46]\n};\n\nvar modifierCode = {\n stop: '$event.stopPropagation();',\n prevent: '$event.preventDefault();',\n self: 'if($event.target !== $event.currentTarget)return;',\n ctrl: 'if(!$event.ctrlKey)return;',\n shift: 'if(!$event.shiftKey)return;',\n alt: 'if(!$event.altKey)return;',\n meta: 'if(!$event.metaKey)return;'\n};\n\nfunction genHandlers (events, native) {\n var res = native ? 'nativeOn:{' : 'on:{';\n for (var name in events) {\n res += \"\\\"\" + name + \"\\\":\" + (genHandler(name, events[name])) + \",\";\n }\n return res.slice(0, -1) + '}'\n}\n\nfunction genHandler (\n name,\n handler\n) {\n if (!handler) {\n return 'function(){}'\n } else if (Array.isArray(handler)) {\n return (\"[\" + (handler.map(function (handler) { return genHandler(name, handler); }).join(',')) + \"]\")\n } else if (!handler.modifiers) {\n return fnExpRE.test(handler.value) || simplePathRE.test(handler.value)\n ? handler.value\n : (\"function($event){\" + (handler.value) + \"}\")\n } else {\n var code = '';\n var keys = [];\n for (var key in handler.modifiers) {\n if (modifierCode[key]) {\n code += modifierCode[key];\n } else {\n keys.push(key);\n }\n }\n if (keys.length) {\n code = genKeyFilter(keys) + code;\n }\n var handlerCode = simplePathRE.test(handler.value)\n ? handler.value + '($event)'\n : handler.value;\n return 'function($event){' + code + handlerCode + '}'\n }\n}\n\nfunction genKeyFilter (keys) {\n return (\"if(\" + (keys.map(genFilterCode).join('&&')) + \")return;\")\n}\n\nfunction genFilterCode (key) {\n var keyVal = parseInt(key, 10);\n if (keyVal) {\n return (\"$event.keyCode!==\" + keyVal)\n }\n var alias = keyCodes[key];\n return (\"_k($event.keyCode,\" + (JSON.stringify(key)) + (alias ? ',' + JSON.stringify(alias) : '') + \")\")\n}\n\n/* */\n\nfunction bind$2 (el, dir) {\n el.wrapData = function (code) {\n return (\"_b(\" + code + \",'\" + (el.tag) + \"',\" + (dir.value) + (dir.modifiers && dir.modifiers.prop ? ',true' : '') + \")\")\n };\n}\n\n/* */\n\nvar baseDirectives = {\n bind: bind$2,\n cloak: noop\n};\n\n/* */\n\n// configurable state\nvar warn$2;\nvar transforms$1;\nvar dataGenFns;\nvar platformDirectives$1;\nvar isPlatformReservedTag$1;\nvar staticRenderFns;\nvar onceCount;\nvar currentOptions;\n\nfunction generate (\n ast,\n options\n) {\n // save previous staticRenderFns so generate calls can be nested\n var prevStaticRenderFns = staticRenderFns;\n var currentStaticRenderFns = staticRenderFns = [];\n var prevOnceCount = onceCount;\n onceCount = 0;\n currentOptions = options;\n warn$2 = options.warn || baseWarn;\n transforms$1 = pluckModuleFunction(options.modules, 'transformCode');\n dataGenFns = pluckModuleFunction(options.modules, 'genData');\n platformDirectives$1 = options.directives || {};\n isPlatformReservedTag$1 = options.isReservedTag || no;\n var code = ast ? genElement(ast) : '_c(\"div\")';\n staticRenderFns = prevStaticRenderFns;\n onceCount = prevOnceCount;\n return {\n render: (\"with(this){return \" + code + \"}\"),\n staticRenderFns: currentStaticRenderFns\n }\n}\n\nfunction genElement (el) {\n if (el.staticRoot && !el.staticProcessed) {\n return genStatic(el)\n } else if (el.once && !el.onceProcessed) {\n return genOnce(el)\n } else if (el.for && !el.forProcessed) {\n return genFor(el)\n } else if (el.if && !el.ifProcessed) {\n return genIf(el)\n } else if (el.tag === 'template' && !el.slotTarget) {\n return genChildren(el) || 'void 0'\n } else if (el.tag === 'slot') {\n return genSlot(el)\n } else {\n // component or element\n var code;\n if (el.component) {\n code = genComponent(el.component, el);\n } else {\n var data = el.plain ? undefined : genData(el);\n\n var children = el.inlineTemplate ? null : genChildren(el, true);\n code = \"_c('\" + (el.tag) + \"'\" + (data ? (\",\" + data) : '') + (children ? (\",\" + children) : '') + \")\";\n }\n // module transforms\n for (var i = 0; i < transforms$1.length; i++) {\n code = transforms$1[i](el, code);\n }\n return code\n }\n}\n\n// hoist static sub-trees out\nfunction genStatic (el) {\n el.staticProcessed = true;\n staticRenderFns.push((\"with(this){return \" + (genElement(el)) + \"}\"));\n return (\"_m(\" + (staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + \")\")\n}\n\n// v-once\nfunction genOnce (el) {\n el.onceProcessed = true;\n if (el.if && !el.ifProcessed) {\n return genIf(el)\n } else if (el.staticInFor) {\n var key = '';\n var parent = el.parent;\n while (parent) {\n if (parent.for) {\n key = parent.key;\n break\n }\n parent = parent.parent;\n }\n if (!key) {\n process.env.NODE_ENV !== 'production' && warn$2(\n \"v-once can only be used inside v-for that is keyed. \"\n );\n return genElement(el)\n }\n return (\"_o(\" + (genElement(el)) + \",\" + (onceCount++) + (key ? (\",\" + key) : \"\") + \")\")\n } else {\n return genStatic(el)\n }\n}\n\nfunction genIf (el) {\n el.ifProcessed = true; // avoid recursion\n return genIfConditions(el.ifConditions.slice())\n}\n\nfunction genIfConditions (conditions) {\n if (!conditions.length) {\n return '_e()'\n }\n\n var condition = conditions.shift();\n if (condition.exp) {\n return (\"(\" + (condition.exp) + \")?\" + (genTernaryExp(condition.block)) + \":\" + (genIfConditions(conditions)))\n } else {\n return (\"\" + (genTernaryExp(condition.block)))\n }\n\n // v-if with v-once should generate code like (a)?_m(0):_m(1)\n function genTernaryExp (el) {\n return el.once ? genOnce(el) : genElement(el)\n }\n}\n\nfunction genFor (el) {\n var exp = el.for;\n var alias = el.alias;\n var iterator1 = el.iterator1 ? (\",\" + (el.iterator1)) : '';\n var iterator2 = el.iterator2 ? (\",\" + (el.iterator2)) : '';\n el.forProcessed = true; // avoid recursion\n return \"_l((\" + exp + \"),\" +\n \"function(\" + alias + iterator1 + iterator2 + \"){\" +\n \"return \" + (genElement(el)) +\n '})'\n}\n\nfunction genData (el) {\n var data = '{';\n\n // directives first.\n // directives may mutate the el's other properties before they are generated.\n var dirs = genDirectives(el);\n if (dirs) { data += dirs + ','; }\n\n // key\n if (el.key) {\n data += \"key:\" + (el.key) + \",\";\n }\n // ref\n if (el.ref) {\n data += \"ref:\" + (el.ref) + \",\";\n }\n if (el.refInFor) {\n data += \"refInFor:true,\";\n }\n // pre\n if (el.pre) {\n data += \"pre:true,\";\n }\n // record original tag name for components using \"is\" attribute\n if (el.component) {\n data += \"tag:\\\"\" + (el.tag) + \"\\\",\";\n }\n // module data generation functions\n for (var i = 0; i < dataGenFns.length; i++) {\n data += dataGenFns[i](el);\n }\n // attributes\n if (el.attrs) {\n data += \"attrs:{\" + (genProps(el.attrs)) + \"},\";\n }\n // DOM props\n if (el.props) {\n data += \"domProps:{\" + (genProps(el.props)) + \"},\";\n }\n // event handlers\n if (el.events) {\n data += (genHandlers(el.events)) + \",\";\n }\n if (el.nativeEvents) {\n data += (genHandlers(el.nativeEvents, true)) + \",\";\n }\n // slot target\n if (el.slotTarget) {\n data += \"slot:\" + (el.slotTarget) + \",\";\n }\n // scoped slots\n if (el.scopedSlots) {\n data += (genScopedSlots(el.scopedSlots)) + \",\";\n }\n // inline-template\n if (el.inlineTemplate) {\n var inlineTemplate = genInlineTemplate(el);\n if (inlineTemplate) {\n data += inlineTemplate + \",\";\n }\n }\n data = data.replace(/,$/, '') + '}';\n // v-bind data wrap\n if (el.wrapData) {\n data = el.wrapData(data);\n }\n return data\n}\n\nfunction genDirectives (el) {\n var dirs = el.directives;\n if (!dirs) { return }\n var res = 'directives:[';\n var hasRuntime = false;\n var i, l, dir, needRuntime;\n for (i = 0, l = dirs.length; i < l; i++) {\n dir = dirs[i];\n needRuntime = true;\n var gen = platformDirectives$1[dir.name] || baseDirectives[dir.name];\n if (gen) {\n // compile-time directive that manipulates AST.\n // returns true if it also needs a runtime counterpart.\n needRuntime = !!gen(el, dir, warn$2);\n }\n if (needRuntime) {\n hasRuntime = true;\n res += \"{name:\\\"\" + (dir.name) + \"\\\",rawName:\\\"\" + (dir.rawName) + \"\\\"\" + (dir.value ? (\",value:(\" + (dir.value) + \"),expression:\" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (\",arg:\\\"\" + (dir.arg) + \"\\\"\") : '') + (dir.modifiers ? (\",modifiers:\" + (JSON.stringify(dir.modifiers))) : '') + \"},\";\n }\n }\n if (hasRuntime) {\n return res.slice(0, -1) + ']'\n }\n}\n\nfunction genInlineTemplate (el) {\n var ast = el.children[0];\n if (process.env.NODE_ENV !== 'production' && (\n el.children.length > 1 || ast.type !== 1\n )) {\n warn$2('Inline-template components must have exactly one child element.');\n }\n if (ast.type === 1) {\n var inlineRenderFns = generate(ast, currentOptions);\n return (\"inlineTemplate:{render:function(){\" + (inlineRenderFns.render) + \"},staticRenderFns:[\" + (inlineRenderFns.staticRenderFns.map(function (code) { return (\"function(){\" + code + \"}\"); }).join(',')) + \"]}\")\n }\n}\n\nfunction genScopedSlots (slots) {\n return (\"scopedSlots:{\" + (Object.keys(slots).map(function (key) { return genScopedSlot(key, slots[key]); }).join(',')) + \"}\")\n}\n\nfunction genScopedSlot (key, el) {\n return key + \":function(\" + (String(el.attrsMap.scope)) + \"){\" +\n \"return \" + (el.tag === 'template'\n ? genChildren(el) || 'void 0'\n : genElement(el)) + \"}\"\n}\n\nfunction genChildren (el, checkSkip) {\n var children = el.children;\n if (children.length) {\n var el$1 = children[0];\n // optimize single v-for\n if (children.length === 1 &&\n el$1.for &&\n el$1.tag !== 'template' &&\n el$1.tag !== 'slot') {\n return genElement(el$1)\n }\n var normalizationType = getNormalizationType(children);\n return (\"[\" + (children.map(genNode).join(',')) + \"]\" + (checkSkip\n ? normalizationType ? (\",\" + normalizationType) : ''\n : ''))\n }\n}\n\n// determine the normalization needed for the children array.\n// 0: no normalization needed\n// 1: simple normalization needed (possible 1-level deep nested array)\n// 2: full normalization needed\nfunction getNormalizationType (children) {\n var res = 0;\n for (var i = 0; i < children.length; i++) {\n var el = children[i];\n if (el.type !== 1) {\n continue\n }\n if (needsNormalization(el) ||\n (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {\n res = 2;\n break\n }\n if (maybeComponent(el) ||\n (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {\n res = 1;\n }\n }\n return res\n}\n\nfunction needsNormalization (el) {\n return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'\n}\n\nfunction maybeComponent (el) {\n return !isPlatformReservedTag$1(el.tag)\n}\n\nfunction genNode (node) {\n if (node.type === 1) {\n return genElement(node)\n } else {\n return genText(node)\n }\n}\n\nfunction genText (text) {\n return (\"_v(\" + (text.type === 2\n ? text.expression // no need for () because already wrapped in _s()\n : transformSpecialNewlines(JSON.stringify(text.text))) + \")\")\n}\n\nfunction genSlot (el) {\n var slotName = el.slotName || '\"default\"';\n var children = genChildren(el);\n var res = \"_t(\" + slotName + (children ? (\",\" + children) : '');\n var attrs = el.attrs && (\"{\" + (el.attrs.map(function (a) { return ((camelize(a.name)) + \":\" + (a.value)); }).join(',')) + \"}\");\n var bind$$1 = el.attrsMap['v-bind'];\n if ((attrs || bind$$1) && !children) {\n res += \",null\";\n }\n if (attrs) {\n res += \",\" + attrs;\n }\n if (bind$$1) {\n res += (attrs ? '' : ',null') + \",\" + bind$$1;\n }\n return res + ')'\n}\n\n// componentName is el.component, take it as argument to shun flow's pessimistic refinement\nfunction genComponent (componentName, el) {\n var children = el.inlineTemplate ? null : genChildren(el, true);\n return (\"_c(\" + componentName + \",\" + (genData(el)) + (children ? (\",\" + children) : '') + \")\")\n}\n\nfunction genProps (props) {\n var res = '';\n for (var i = 0; i < props.length; i++) {\n var prop = props[i];\n res += \"\\\"\" + (prop.name) + \"\\\":\" + (transformSpecialNewlines(prop.value)) + \",\";\n }\n return res.slice(0, -1)\n}\n\n// #3895, #4268\nfunction transformSpecialNewlines (text) {\n return text\n .replace(/\\u2028/g, '\\\\u2028')\n .replace(/\\u2029/g, '\\\\u2029')\n}\n\n/* */\n\n/**\n * Compile a template.\n */\nfunction compile$1 (\n template,\n options\n) {\n var ast = parse(template.trim(), options);\n optimize(ast, options);\n var code = generate(ast, options);\n return {\n ast: ast,\n render: code.render,\n staticRenderFns: code.staticRenderFns\n }\n}\n\n/* */\n\n// operators like typeof, instanceof and in are allowed\nvar prohibitedKeywordRE = new RegExp('\\\\b' + (\n 'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +\n 'super,throw,while,yield,delete,export,import,return,switch,default,' +\n 'extends,finally,continue,debugger,function,arguments'\n).split(',').join('\\\\b|\\\\b') + '\\\\b');\n// check valid identifier for v-for\nvar identRE = /[A-Za-z_$][\\w$]*/;\n// strip strings in expressions\nvar stripStringRE = /'(?:[^'\\\\]|\\\\.)*'|\"(?:[^\"\\\\]|\\\\.)*\"|`(?:[^`\\\\]|\\\\.)*\\$\\{|\\}(?:[^`\\\\]|\\\\.)*`|`(?:[^`\\\\]|\\\\.)*`/g;\n\n// detect problematic expressions in a template\nfunction detectErrors (ast) {\n var errors = [];\n if (ast) {\n checkNode(ast, errors);\n }\n return errors\n}\n\nfunction checkNode (node, errors) {\n if (node.type === 1) {\n for (var name in node.attrsMap) {\n if (dirRE.test(name)) {\n var value = node.attrsMap[name];\n if (value) {\n if (name === 'v-for') {\n checkFor(node, (\"v-for=\\\"\" + value + \"\\\"\"), errors);\n } else {\n checkExpression(value, (name + \"=\\\"\" + value + \"\\\"\"), errors);\n }\n }\n }\n }\n if (node.children) {\n for (var i = 0; i < node.children.length; i++) {\n checkNode(node.children[i], errors);\n }\n }\n } else if (node.type === 2) {\n checkExpression(node.expression, node.text, errors);\n }\n}\n\nfunction checkFor (node, text, errors) {\n checkExpression(node.for || '', text, errors);\n checkIdentifier(node.alias, 'v-for alias', text, errors);\n checkIdentifier(node.iterator1, 'v-for iterator', text, errors);\n checkIdentifier(node.iterator2, 'v-for iterator', text, errors);\n}\n\nfunction checkIdentifier (ident, type, text, errors) {\n if (typeof ident === 'string' && !identRE.test(ident)) {\n errors.push((\"- invalid \" + type + \" \\\"\" + ident + \"\\\" in expression: \" + text));\n }\n}\n\nfunction checkExpression (exp, text, errors) {\n try {\n new Function((\"return \" + exp));\n } catch (e) {\n var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);\n if (keywordMatch) {\n errors.push(\n \"- avoid using JavaScript keyword as property name: \" +\n \"\\\"\" + (keywordMatch[0]) + \"\\\" in expression \" + text\n );\n } else {\n errors.push((\"- invalid expression: \" + text));\n }\n }\n}\n\n/* */\n\nfunction transformNode (el, options) {\n var warn = options.warn || baseWarn;\n var staticClass = getAndRemoveAttr(el, 'class');\n if (process.env.NODE_ENV !== 'production' && staticClass) {\n var expression = parseText(staticClass, options.delimiters);\n if (expression) {\n warn(\n \"class=\\\"\" + staticClass + \"\\\": \" +\n 'Interpolation inside attributes has been removed. ' +\n 'Use v-bind or the colon shorthand instead. For example, ' +\n 'instead of <div class=\"{{ val }}\">, use <div :class=\"val\">.'\n );\n }\n }\n if (staticClass) {\n el.staticClass = JSON.stringify(staticClass);\n }\n var classBinding = getBindingAttr(el, 'class', false /* getStatic */);\n if (classBinding) {\n el.classBinding = classBinding;\n }\n}\n\nfunction genData$1 (el) {\n var data = '';\n if (el.staticClass) {\n data += \"staticClass:\" + (el.staticClass) + \",\";\n }\n if (el.classBinding) {\n data += \"class:\" + (el.classBinding) + \",\";\n }\n return data\n}\n\nvar klass$1 = {\n staticKeys: ['staticClass'],\n transformNode: transformNode,\n genData: genData$1\n};\n\n/* */\n\nfunction transformNode$1 (el, options) {\n var warn = options.warn || baseWarn;\n var staticStyle = getAndRemoveAttr(el, 'style');\n if (staticStyle) {\n /* istanbul ignore if */\n if (process.env.NODE_ENV !== 'production') {\n var expression = parseText(staticStyle, options.delimiters);\n if (expression) {\n warn(\n \"style=\\\"\" + staticStyle + \"\\\": \" +\n 'Interpolation inside attributes has been removed. ' +\n 'Use v-bind or the colon shorthand instead. For example, ' +\n 'instead of <div style=\"{{ val }}\">, use <div :style=\"val\">.'\n );\n }\n }\n el.staticStyle = JSON.stringify(parseStyleText(staticStyle));\n }\n\n var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);\n if (styleBinding) {\n el.styleBinding = styleBinding;\n }\n}\n\nfunction genData$2 (el) {\n var data = '';\n if (el.staticStyle) {\n data += \"staticStyle:\" + (el.staticStyle) + \",\";\n }\n if (el.styleBinding) {\n data += \"style:(\" + (el.styleBinding) + \"),\";\n }\n return data\n}\n\nvar style$1 = {\n staticKeys: ['staticStyle'],\n transformNode: transformNode$1,\n genData: genData$2\n};\n\nvar modules$1 = [\n klass$1,\n style$1\n];\n\n/* */\n\nvar warn$3;\n\nfunction model$1 (\n el,\n dir,\n _warn\n) {\n warn$3 = _warn;\n var value = dir.value;\n var modifiers = dir.modifiers;\n var tag = el.tag;\n var type = el.attrsMap.type;\n if (process.env.NODE_ENV !== 'production') {\n var dynamicType = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];\n if (tag === 'input' && dynamicType) {\n warn$3(\n \"<input :type=\\\"\" + dynamicType + \"\\\" v-model=\\\"\" + value + \"\\\">:\\n\" +\n \"v-model does not support dynamic input types. Use v-if branches instead.\"\n );\n }\n }\n if (tag === 'select') {\n genSelect(el, value, modifiers);\n } else if (tag === 'input' && type === 'checkbox') {\n genCheckboxModel(el, value, modifiers);\n } else if (tag === 'input' && type === 'radio') {\n genRadioModel(el, value, modifiers);\n } else {\n genDefaultModel(el, value, modifiers);\n }\n // ensure runtime directive metadata\n return true\n}\n\nfunction genCheckboxModel (\n el,\n value,\n modifiers\n) {\n if (process.env.NODE_ENV !== 'production' &&\n el.attrsMap.checked != null) {\n warn$3(\n \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" checked>:\\n\" +\n \"inline checked attributes will be ignored when using v-model. \" +\n 'Declare initial values in the component\\'s data option instead.'\n );\n }\n var number = modifiers && modifiers.number;\n var valueBinding = getBindingAttr(el, 'value') || 'null';\n var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';\n var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';\n addProp(el, 'checked',\n \"Array.isArray(\" + value + \")\" +\n \"?_i(\" + value + \",\" + valueBinding + \")>-1\" + (\n trueValueBinding === 'true'\n ? (\":(\" + value + \")\")\n : (\":_q(\" + value + \",\" + trueValueBinding + \")\")\n )\n );\n addHandler(el, 'click',\n \"var $$a=\" + value + \",\" +\n '$$el=$event.target,' +\n \"$$c=$$el.checked?(\" + trueValueBinding + \"):(\" + falseValueBinding + \");\" +\n 'if(Array.isArray($$a)){' +\n \"var $$v=\" + (number ? '_n(' + valueBinding + ')' : valueBinding) + \",\" +\n '$$i=_i($$a,$$v);' +\n \"if($$c){$$i<0&&(\" + value + \"=$$a.concat($$v))}\" +\n \"else{$$i>-1&&(\" + value + \"=$$a.slice(0,$$i).concat($$a.slice($$i+1)))}\" +\n \"}else{\" + value + \"=$$c}\",\n null, true\n );\n}\n\nfunction genRadioModel (\n el,\n value,\n modifiers\n) {\n if (process.env.NODE_ENV !== 'production' &&\n el.attrsMap.checked != null) {\n warn$3(\n \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" checked>:\\n\" +\n \"inline checked attributes will be ignored when using v-model. \" +\n 'Declare initial values in the component\\'s data option instead.'\n );\n }\n var number = modifiers && modifiers.number;\n var valueBinding = getBindingAttr(el, 'value') || 'null';\n valueBinding = number ? (\"_n(\" + valueBinding + \")\") : valueBinding;\n addProp(el, 'checked', (\"_q(\" + value + \",\" + valueBinding + \")\"));\n addHandler(el, 'click', genAssignmentCode(value, valueBinding), null, true);\n}\n\nfunction genDefaultModel (\n el,\n value,\n modifiers\n) {\n if (process.env.NODE_ENV !== 'production') {\n if (el.tag === 'input' && el.attrsMap.value) {\n warn$3(\n \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" value=\\\"\" + (el.attrsMap.value) + \"\\\">:\\n\" +\n 'inline value attributes will be ignored when using v-model. ' +\n 'Declare initial values in the component\\'s data option instead.'\n );\n }\n if (el.tag === 'textarea' && el.children.length) {\n warn$3(\n \"<textarea v-model=\\\"\" + value + \"\\\">:\\n\" +\n 'inline content inside <textarea> will be ignored when using v-model. ' +\n 'Declare initial values in the component\\'s data option instead.'\n );\n }\n }\n\n var type = el.attrsMap.type;\n var ref = modifiers || {};\n var lazy = ref.lazy;\n var number = ref.number;\n var trim = ref.trim;\n var event = lazy || (isIE && type === 'range') ? 'change' : 'input';\n var needCompositionGuard = !lazy && type !== 'range';\n var isNative = el.tag === 'input' || el.tag === 'textarea';\n\n var valueExpression = isNative\n ? (\"$event.target.value\" + (trim ? '.trim()' : ''))\n : trim ? \"(typeof $event === 'string' ? $event.trim() : $event)\" : \"$event\";\n valueExpression = number || type === 'number'\n ? (\"_n(\" + valueExpression + \")\")\n : valueExpression;\n\n var code = genAssignmentCode(value, valueExpression);\n if (isNative && needCompositionGuard) {\n code = \"if($event.target.composing)return;\" + code;\n }\n\n // inputs with type=\"file\" are read only and setting the input's\n // value will throw an error.\n if (process.env.NODE_ENV !== 'production' &&\n type === 'file') {\n warn$3(\n \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" type=\\\"file\\\">:\\n\" +\n \"File inputs are read only. Use a v-on:change listener instead.\"\n );\n }\n\n addProp(el, 'value', isNative ? (\"_s(\" + value + \")\") : (\"(\" + value + \")\"));\n addHandler(el, event, code, null, true);\n if (trim || number || type === 'number') {\n addHandler(el, 'blur', '$forceUpdate()');\n }\n}\n\nfunction genSelect (\n el,\n value,\n modifiers\n) {\n if (process.env.NODE_ENV !== 'production') {\n el.children.some(checkOptionWarning);\n }\n\n var number = modifiers && modifiers.number;\n var assignment = \"Array.prototype.filter\" +\n \".call($event.target.options,function(o){return o.selected})\" +\n \".map(function(o){var val = \\\"_value\\\" in o ? o._value : o.value;\" +\n \"return \" + (number ? '_n(val)' : 'val') + \"})\" +\n (el.attrsMap.multiple == null ? '[0]' : '');\n\n var code = genAssignmentCode(value, assignment);\n addHandler(el, 'change', code, null, true);\n}\n\nfunction checkOptionWarning (option) {\n if (option.type === 1 &&\n option.tag === 'option' &&\n option.attrsMap.selected != null) {\n warn$3(\n \"<select v-model=\\\"\" + (option.parent.attrsMap['v-model']) + \"\\\">:\\n\" +\n 'inline selected attributes on <option> will be ignored when using v-model. ' +\n 'Declare initial values in the component\\'s data option instead.'\n );\n return true\n }\n return false\n}\n\nfunction genAssignmentCode (value, assignment) {\n var modelRs = parseModel(value);\n if (modelRs.idx === null) {\n return (value + \"=\" + assignment)\n } else {\n return \"var $$exp = \" + (modelRs.exp) + \", $$idx = \" + (modelRs.idx) + \";\" +\n \"if (!Array.isArray($$exp)){\" +\n value + \"=\" + assignment + \"}\" +\n \"else{$$exp.splice($$idx, 1, \" + assignment + \")}\"\n }\n}\n\n/* */\n\nfunction text (el, dir) {\n if (dir.value) {\n addProp(el, 'textContent', (\"_s(\" + (dir.value) + \")\"));\n }\n}\n\n/* */\n\nfunction html (el, dir) {\n if (dir.value) {\n addProp(el, 'innerHTML', (\"_s(\" + (dir.value) + \")\"));\n }\n}\n\nvar directives$1 = {\n model: model$1,\n text: text,\n html: html\n};\n\n/* */\n\nvar cache = Object.create(null);\n\nvar baseOptions = {\n expectHTML: true,\n modules: modules$1,\n staticKeys: genStaticKeys(modules$1),\n directives: directives$1,\n isReservedTag: isReservedTag,\n isUnaryTag: isUnaryTag,\n mustUseProp: mustUseProp,\n getTagNamespace: getTagNamespace,\n isPreTag: isPreTag\n};\n\nfunction compile$$1 (\n template,\n options\n) {\n options = options\n ? extend(extend({}, baseOptions), options)\n : baseOptions;\n return compile$1(template, options)\n}\n\nfunction compileToFunctions (\n template,\n options,\n vm\n) {\n var _warn = (options && options.warn) || warn;\n // detect possible CSP restriction\n /* istanbul ignore if */\n if (process.env.NODE_ENV !== 'production') {\n try {\n new Function('return 1');\n } catch (e) {\n if (e.toString().match(/unsafe-eval|CSP/)) {\n _warn(\n 'It seems you are using the standalone build of Vue.js in an ' +\n 'environment with Content Security Policy that prohibits unsafe-eval. ' +\n 'The template compiler cannot work in this environment. Consider ' +\n 'relaxing the policy to allow unsafe-eval or pre-compiling your ' +\n 'templates into render functions.'\n );\n }\n }\n }\n var key = options && options.delimiters\n ? String(options.delimiters) + template\n : template;\n if (cache[key]) {\n return cache[key]\n }\n var res = {};\n var compiled = compile$$1(template, options);\n res.render = makeFunction(compiled.render);\n var l = compiled.staticRenderFns.length;\n res.staticRenderFns = new Array(l);\n for (var i = 0; i < l; i++) {\n res.staticRenderFns[i] = makeFunction(compiled.staticRenderFns[i]);\n }\n if (process.env.NODE_ENV !== 'production') {\n if (res.render === noop || res.staticRenderFns.some(function (fn) { return fn === noop; })) {\n _warn(\n \"failed to compile template:\\n\\n\" + template + \"\\n\\n\" +\n detectErrors(compiled.ast).join('\\n') +\n '\\n\\n',\n vm\n );\n }\n }\n return (cache[key] = res)\n}\n\nfunction makeFunction (code) {\n try {\n return new Function(code)\n } catch (e) {\n return noop\n }\n}\n\n/* */\n\nvar idToTemplate = cached(function (id) {\n var el = query(id);\n return el && el.innerHTML\n});\n\nvar mount = Vue$3.prototype.$mount;\nVue$3.prototype.$mount = function (\n el,\n hydrating\n) {\n el = el && query(el);\n\n /* istanbul ignore if */\n if (el === document.body || el === document.documentElement) {\n process.env.NODE_ENV !== 'production' && warn(\n \"Do not mount Vue to <html> or <body> - mount to normal elements instead.\"\n );\n return this\n }\n\n var options = this.$options;\n // resolve template/el and convert to render function\n if (!options.render) {\n var template = options.template;\n if (template) {\n if (typeof template === 'string') {\n if (template.charAt(0) === '#') {\n template = idToTemplate(template);\n /* istanbul ignore if */\n if (process.env.NODE_ENV !== 'production' && !template) {\n warn(\n (\"Template element not found or is empty: \" + (options.template)),\n this\n );\n }\n }\n } else if (template.nodeType) {\n template = template.innerHTML;\n } else {\n if (process.env.NODE_ENV !== 'production') {\n warn('invalid template option:' + template, this);\n }\n return this\n }\n } else if (el) {\n template = getOuterHTML(el);\n }\n if (template) {\n var ref = compileToFunctions(template, {\n warn: warn,\n shouldDecodeNewlines: shouldDecodeNewlines,\n delimiters: options.delimiters\n }, this);\n var render = ref.render;\n var staticRenderFns = ref.staticRenderFns;\n options.render = render;\n options.staticRenderFns = staticRenderFns;\n }\n }\n return mount.call(this, el, hydrating)\n};\n\n/**\n * Get outerHTML of elements, taking care\n * of SVG elements in IE as well.\n */\nfunction getOuterHTML (el) {\n if (el.outerHTML) {\n return el.outerHTML\n } else {\n var container = document.createElement('div');\n container.appendChild(el.cloneNode(true));\n return container.innerHTML\n }\n}\n\nVue$3.compile = compileToFunctions;\n\nmodule.exports = Vue$3;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/vue/dist/vue.common.js\n// module id = 17\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 = 18\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 = 19\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 = 20\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 = 21\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 = 22\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 = 23\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 = 24\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 = 25\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 = 26\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 = 27\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 = 28\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 = 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 = 40\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 = 41\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 = 42\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 = 43\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 = 44\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 = 45\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 = 46\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 = 47\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 = 48\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 = 49\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 = 50\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 = 51\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 = 52\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 = 53\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 = 54\n// module chunks = 0","module.exports = true;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_library.js\n// module id = 55\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 = 56\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 = 57\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 = 58\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 = 59\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 = 60\n// module chunks = 0","module.exports = require('./_hide');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_redefine.js\n// module id = 61\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 = 62\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 = 63\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 = 64\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 = 65\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 = 66\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 = 67\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 = 88\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 = 89\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 = 90\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 = 92\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 = 93\n// module chunks = 0"],"sourceRoot":""} |