{"version":3,"sources":["webpack:///webpack/universalModuleDefinition?5ca6*","webpack:///brush.min.js","webpack:///webpack/bootstrap 0a1eb6cfa29181d5999f?cc57*","webpack:///./src/charts/brush.js","webpack:///./~/d3-array/build/d3-array.js?d8bc*","webpack:///./~/d3-ease/build/d3-ease.js?034c*","webpack:///./~/d3-axis/build/d3-axis.js?abd6","webpack:///./~/d3-color/build/d3-color.js?f7c1*","webpack:///./~/d3-dispatch/build/d3-dispatch.js?a489*","webpack:///./~/d3-format/build/d3-format.js?fb4a*","webpack:///./~/d3-scale/build/d3-scale.js?7e54","webpack:///./~/d3-collection/build/d3-collection.js?6c84","webpack:///./~/d3-interpolate/build/d3-interpolate.js?f797*","webpack:///./~/d3-time/build/d3-time.js?70a1*","webpack:///./~/d3-time-format/build/d3-time-format.js?bb40*","webpack:///./~/d3-selection/build/d3-selection.js?6638*","webpack:///./~/d3-transition/build/d3-transition.js?07b0*","webpack:///./~/d3-timer/build/d3-timer.js?2468*","webpack:///./src/charts/helpers/colors.js?2682*","webpack:///./src/charts/helpers/constants.js?4e60","webpack:///./~/d3-brush/build/d3-brush.js","webpack:///./~/d3-drag/build/d3-drag.js","webpack:///./~/d3-shape/build/d3-shape.js","webpack:///./~/d3-path/build/d3-path.js","webpack:///./src/charts/helpers/timeAxis.js"],"names":["root","factory","exports","module","define","amd","this","modules","__webpack_require__","moduleId","installedModules","id","loaded","call","m","c","p","_toConsumableArray","arr","Array","isArray","i","arr2","length","from","__WEBPACK_AMD_DEFINE_RESULT__","require","d3Array","d3Axis","d3Brush","d3Ease","d3Scale","d3Shape","d3Dispatch","d3Selection","d3Time","d3TimeFormat","colorHelper","timeAxisHelper","_require","axisTimeCombinations","_selection","each","_data","chartWidth","width","margin","left","right","chartHeight","height","top","bottom","data","cleanData","cloneData","buildScales","buildAxis","buildSVG","buildGradient","buildBrush","drawArea","drawAxis","drawBrush","drawHandles","minor","major","xAxisFormat","xAxisCustomFormat","tick","xTicks","format","timeFormat","_timeAxisHelper$getXA","getXAxisSettings","xAxis","axisBottom","xScale","ticks","tickSize","tickPadding","tickFormat","brush","brushX","extent","on","handleBrushStart","handleBrushEnd","buildContainerGroups","container","svg","append","classed","attr","metadataGroup","select","date","selectAll","offset","color","gradient","enter","_ref3","_ref4","scaleTime","domain","getDate","range","yScale","scaleLinear","max","getValue","map","d","Date","dateLabel","value","valueLabel","dataToClone","JSON","parse","stringify","area","x","_ref5","y0","y1","_ref6","curve","curveBasis","datum","chartBrush","handleFillColor","colorSchemasHuman","grey","handle","style","s","event","selection","dateExtent","invert","dispatcher","sourceEvent","dateExtentRounded","timeDay","round","floor","transition","target","move","setBrushByDates","dateA","dateB","x0","x1","easeQuadOut","dateRange","colorGradients","greenBlue","dispatch","_ref","_ref2","_x","arguments","apply","undefined","global","ascendingComparator","f","ascending","pair","a","b","tickIncrement","start","stop","count","step","Math","power","log","LN10","error","pow","e10","e5","e2","tickStep","step0","abs","step1","NaN","bisector","compare","lo","hi","mid","ascendingBisect","bisectRight","bisectLeft","pairs","array","n","cross","values0","values1","reduce","i0","i1","value0","n0","n1","values","descending","number","variance","valueof","delta","mean","sum","isNaN","deviation","v","sqrt","min","prototype","slice","constant","identity","ceil","reverse","isFinite","sturges","LN2","histogram","xz","tz","threshold","shift","pop","bin","bins","push","_","thresholds","quantile","value1","freedmanDiaconis","sort","scott","median","numbers","merge","arrays","merged","j","permute","indexes","permutes","scan","xi","xj","shuffle","t","random","transpose","matrix","row","zip","bisect","thresholdFreedmanDiaconis","thresholdScott","thresholdSturges","Object","defineProperty","linear","quadIn","quadOut","quadInOut","cubicIn","cubicOut","cubicInOut","sinIn","cos","halfPi","sinOut","sin","sinInOut","pi","expIn","expOut","expInOut","circleIn","circleOut","circleInOut","bounceIn","bounceOut","b1","b0","b3","b2","b4","b6","b5","b7","b8","b9","bounceInOut","exponent","polyIn","custom","e","polyOut","polyInOut","PI","overshoot","backIn","backOut","backInOut","tau","amplitude","period","elasticIn","asin","elasticOut","elasticInOut","easeLinear","easeQuad","easeQuadIn","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","translateX","translateY","y","scale","center","bandwidth","entering","__axis","axis","orient","context","tickValues","tickArguments","spacing","tickSizeInner","range0","range1","position","copy","path","order","tickExit","exit","tickEnter","line","text","insert","k","epsilon","transform","getAttribute","parentNode","remove","tickSizeOuter","filter","axisTop","axisRight","axisLeft","extend","parent","definition","create","key","Color","trim","toLowerCase","reHex3","exec","parseInt","Rgb","reHex6","rgbn","reRgbInteger","reRgbPercent","reRgbaInteger","rgba","reRgbaPercent","reHslPercent","hsla","reHslaPercent","named","hasOwnProperty","r","g","rgbConvert","o","rgb","opacity","h","l","Hsl","hslConvert","hsl","hsl2rgb","m1","m2","labConvert","Lab","Hcl","deg2rad","rgb2xyz","xyz2lab","Xn","Yn","z","Zn","lab","t3","t2","t0","lab2xyz","t1","xyz2rgb","hclConvert","atan2","rad2deg","hcl","cubehelixConvert","Cubehelix","BC_DA","ED","EB","bl","E","C","D","cubehelix","constructor","darker","brighter","reI","reN","reP","RegExp","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","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","tan","teal","thistle","tomato","turquoise","violet","wheat","white","whitesmoke","yellow","yellowgreen","displayable","toString","Kn","A","B","cosh","sinh","Error","Dispatch","parseTypenames","typenames","types","split","name","indexOf","type","get","set","callback","noop","concat","typename","T","that","args","formatSpecifier","specifier","FormatSpecifier","match","re","fill","align","sign","symbol","zero","comma","precision","formatTypes","defaultLocale","locale","formatLocale","formatPrefix","prefixExponent","formatDecimal","toExponential","coefficient","formatGroup","grouping","thousands","substring","join","formatNumerals","numerals","replace","formatDefault","toPrecision","out","formatPrefixAuto","formatRounded","","%","toFixed","X","toUpperCase","prefixes","newFormat","valuePrefix","prefix","valueSuffix","suffix","formatType","valueNegative","maybeSuffix","charCodeAt","decimal","group","Infinity","padding","currency","test","percent","precisionFixed","precisionPrefix","precisionRound","formatDefaultLocale","d3Collection","d3Interpolate","d3Format","d3Color","ordinal","range$$1","index","unknown","implicit","has","band","rescale","paddingInner","paddingOuter","ordinalRange","rangeRound","pointish","point","deinterpolateLinear","deinterpolateClamp","deinterpolate","reinterpolateClamp","reinterpolate","bimap","d0","d1","r0","r1","polymap","source","interpolate","clamp","continuous","piecewise","output","input","interpolate$$1","unit","map$1","interpolateRound","linearish","nice","interpolateNumber","pow10","powp","base","exp","logp","log10","log2","reflect","logs","pows","u","raise","quantile$1","invertExtent","quantiles","quantize","number$1","calendar","year","month","week","day","hour","minute","second","millisecond","format$$1","formatMillisecond","formatSecond","formatMinute","formatHour","formatDay","formatWeek","formatMonth","formatYear","tickInterval","interval","tickIntervals","durationYear","every","durationSecond","durationMinute","durationHour","durationDay","durationWeek","durationMonth","ramp","sequential","interpolator","time","timeYear","timeMonth","timeWeek","timeHour","timeMinute","timeSecond","timeMillisecond","utcTime","utcYear","utcMonth","utcWeek","utcDay","utcHour","utcMinute","utcSecond","utcMillisecond","utcFormat","UTC","colors","category10","category20b","category20c","category20","cubehelix$1","interpolateCubehelixLong","warm","cool","rainbow","rainbow$1","ts","viridis","magma","inferno","plasma","scaleBand","scalePoint","scaleIdentity","scaleLog","scaleOrdinal","scaleImplicit","scalePow","scaleSqrt","scaleQuantile","scaleQuantize","scaleThreshold","scaleUtc","schemeCategory10","schemeCategory20b","schemeCategory20c","schemeCategory20","interpolateCubehelixDefault","interpolateRainbow","interpolateWarm","interpolateCool","interpolateViridis","interpolateMagma","interpolateInferno","interpolatePlasma","scaleSequential","Map","object","createObject","setObject","createMap","setMap","map$$1","Set","add","property","clear","keys","entries","size","empty","nest","depth","createResult","setResult","sortValues","rollup","keyValue","valuesByKey","result","sortKey","sortKeys","proto","basis","v0","v1","v2","v3","exponential","hue","gamma","nogamma","rgbSpline","spline","color$$1","one","parseCss","cssNode","document","createElement","cssRoot","documentElement","cssView","defaultView","getComputedStyle","appendChild","getPropertyValue","removeChild","decompose","parseSvg","svgNode","createElementNS","setAttribute","baseVal","consolidate","interpolateTransform","pxComma","pxParen","degParen","translate","xa","ya","xb","yb","q","rotate","skewX","scaleX","scaleY","tanh","hsl$1","hue$$1","end","lab$1","hcl$1","cubehelixGamma","cubehelix$$1","basis$1","basisClosed","rgb$1","rgbGamma","rgb$$1","rgbBasis","rgbBasisClosed","nb","na","setTime","reA","reB","string","am","bm","bs","bi","lastIndex","valueOf","degrees","atan","interpolateTransformCss","interpolateTransformSvg","rho","SQRT2","rho2","rho4","epsilon2","zoom","p0","p1","S","ux0","uy0","w0","ux1","uy1","w1","dx","dy","d2","coshr0","duration","hsl$2","hslLong","hcl$2","hclLong","cubehelix$2","cubehelixLong","samples","interpolateArray","interpolateBasis","interpolateBasisClosed","interpolateDate","interpolateObject","interpolateString","interpolateZoom","interpolateRgb","interpolateRgbBasis","interpolateRgbBasisClosed","interpolateHsl","interpolateHslLong","interpolateLab","interpolateHcl","interpolateHclLong","interpolateCubehelix","newInterval","floori","offseti","field","weekday","setDate","getDay","setHours","getTimezoneOffset","utcWeekday","setUTCDate","getUTCDate","getUTCDay","setUTCHours","milliseconds","getUTCSeconds","seconds","getMinutes","minutes","getHours","hours","days","sunday","monday","tuesday","wednesday","thursday","friday","saturday","sundays","mondays","tuesdays","wednesdays","thursdays","fridays","saturdays","setMonth","getMonth","getFullYear","months","setFullYear","years","setUTCSeconds","getUTCMinutes","utcMinutes","setUTCMinutes","getUTCHours","utcHours","utcDays","utcSunday","utcMonday","utcTuesday","utcWednesday","utcThursday","utcFriday","utcSaturday","utcSundays","utcMondays","utcTuesdays","utcWednesdays","utcThursdays","utcFridays","utcSaturdays","setUTCMonth","getUTCMonth","getUTCFullYear","utcMonths","setUTCFullYear","utcYears","timeInterval","timeMilliseconds","utcMilliseconds","timeSeconds","utcSeconds","timeMinutes","timeHours","timeDays","timeWeeks","timeSunday","timeSundays","timeMonday","timeMondays","timeTuesday","timeTuesdays","timeWednesday","timeWednesdays","timeThursday","timeThursdays","timeFriday","timeFridays","timeSaturday","timeSaturdays","timeMonths","timeYears","utcWeeks","localDate","H","M","L","utcDate","newYear","formats","pad","pads","charAt","newParse","newDate","parseSpecifier","w","W","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","locale_months","formatPeriod","locale_periods","formatUTCShortWeekday","formatUTCWeekday","formatUTCShortMonth","formatUTCMonth","formatUTCPeriod","dateTime","periods","shortDays","shortMonths","formatRe","formatLookup","formatDayOfMonth","formatHour24","I","formatHour12","formatDayOfYear","formatMilliseconds","formatMonthNumber","formatMinutes","formatSeconds","formatWeekNumberSunday","formatWeekdayNumber","formatWeekNumberMonday","Y","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","utcParse","requote","requoteRe","names","numberRe","percentRe","getMilliseconds","getSeconds","getUTCMilliseconds","locale$1","timeParse","formatIsoNative","toISOString","parseIsoNative","-","0","isoSpecifier","formatIso","parseIso","timeFormatDefaultLocale","timeFormatLocale","isoFormat","isoParse","creatorInherit","ownerDocument","uri","namespaceURI","xhtml","creatorFixed","fullname","space","local","Local","nextId","filterContextListener","listener","contextListener","related","relatedTarget","compareDocumentPosition","event1","event0","__data__","onRemove","__on","removeEventListener","capture","onAdd","wrap","filterEvents","addEventListener","customEvent","none","EnterNode","_next","_parent","bindIndex","update","node","groupLength","dataLength","bindKey","nodeByKeyValue","keyValues","keyPrefix","attrRemove","removeAttribute","attrRemoveNS","removeAttributeNS","attrConstant","attrConstantNS","setAttributeNS","attrFunction","attrFunctionNS","styleRemove","removeProperty","styleConstant","priority","setProperty","styleFunction","styleValue","propertyRemove","propertyConstant","propertyFunction","classArray","classList","ClassList","_node","_names","classedAdd","list","classedRemove","classedTrue","classedFalse","classedFunction","textRemove","textContent","textConstant","textFunction","htmlRemove","innerHTML","htmlConstant","htmlFunction","nextSibling","lower","previousSibling","insertBefore","firstChild","constantNull","dispatchEvent","params","window","CustomEvent","createEvent","initEvent","bubbles","cancelable","detail","dispatchConstant","dispatchFunction","Selection","groups","parents","_groups","_parents","namespaces","xlink","xml","xmlns","namespace","creator","matcher","selector","matches","element","vendorMatches","webkitMatchesSelector","msMatchesSelector","mozMatchesSelector","oMatchesSelector","matcher$1","element$1","mouseenter","mouseleave","selection_on","current","ownerSVGElement","createSVGPoint","clientX","clientY","matrixTransform","getScreenCTM","inverse","rect","getBoundingClientRect","clientLeft","clientTop","mouse","changedTouches","querySelector","selection_select","subgroups","subnode","subgroup","selectorAll","querySelectorAll","selection_selectAll","selection_filter","sparse","selection_enter","_enter","child","next","selection_data","bind","enterGroup","updateGroup","exitGroup","previous","_exit","selection_exit","selection_merge","groups0","groups1","m0","merges","group0","group1","selection_order","selection_sort","compareNode","sortgroups","sortgroup","selection_call","selection_nodes","nodes","selection_node","selection_size","selection_empty","selection_each","selection_attr","getAttributeNS","selection_style","selection_property","splice","contains","selection_classed","selection_text","selection_html","selection_raise","selection_lower","selection_append","selection_insert","before","selection_remove","selection_datum","selection_dispatch","html","touch","touches","identifier","points","d3Timer","init","schedule","__transition","state","CREATED","STARTING","self","elapsed","SCHEDULED","timer","restart","delay","schedules","STARTED","timeout","RUNNING","ENDED","tween","ease","ENDING","tweenRemove","tween0","tween1","tweenFunction","tweenValue","_id","value00","interpolate0","value10","attrTweenNS","_value","attrTween","delayFunction","delayConstant","durationFunction","durationConstant","easeConstant","onFunction","on0","on1","sit","removeFunction","styleRemoveEnd","styleTween","Transition","_name","newId","inherit","timing","defaultTiming","now","emptyOn","emptyTween","interrupt","active","selection_interrupt","transition_tween","transition_attr","transition_attrTween","transition_delay","transition_duration","transition_ease","transition_filter","transition_merge","transition_on","transition_remove","transition_select","transition_selectAll","children","transition_selection","transition_style","transition_styleTween","transition_text","transition_transition","id0","id1","selection_prototype","selection_transition","clockNow","setFrame","clearNow","clock","clockSkew","Timer","_call","_time","timerFlush","frame","taskHead","wake","clockLast","nap","poke","pokeDelay","taskTail","sleep","clearTimeout","setTimeout","clearInterval","setInterval","performance","requestAnimationFrame","TypeError","timeout$1","interval$1","total","britechartGradients","orangePink","bluePurple","britecharts","blueGreen","aloeGreen","colorSchemas","singleColors","colorGradientsHuman","MINUTE_HOUR","HOUR_DAY","DAY_MONTH","MONTH_YEAR","timeBenchmarks","ONE_AND_A_HALF_YEARS","ONE_YEAR","ONE_DAY","lineGradientId","d3Drag","d3Transition","nopropagation","stopImmediatePropagation","defaultFilter","button","defaultExtent","__brush","brushSelection","dim","brush$1","brushY","overlay","initialize","cursors","handles","redraw","started","handleSize","emitter","Emitter","moved","point1","shifting","lockX","lockY","moving","noevent","point0","mode","MODE_SPACE","MODE_DRAG","signX","e0","e1","signY","N","s0","s1","MODE_HANDLE","MODE_CENTER","flipX","flipY","emit","ended","touchending","dragEnable","view","keydowned","keyCode","keyupped","altKey","metaKey","signsX","signsY","shiftKey","beforestart","dragDisable","listeners","selection1","selection0","starting","BrushEvent","preventDefault","xy","XY","nw","ne","se","sw","yesdrag","noclick","MozUserSelect","__noselect","DragEvent","subject","dispatch$$1","defaultContainer","defaultSubject","touchable","nodrag","drag","mousedowned","touchstarted","touchmoved","touchended","gesture","mousemoved","mouseupped","mousemoving","mousedownx","mousedowny","clickDistance2","gestures","sublisteners","clickDistance","d3Path","acos","arcInnerRadius","innerRadius","arcOuterRadius","outerRadius","arcStartAngle","startAngle","arcEndAngle","endAngle","arcPadAngle","padAngle","intersect","x2","y2","x3","y3","x10","y10","x32","y32","cornerTangents","rc","cw","x01","y01","ox","oy","x11","y11","x00","y00","cx0","cy0","cx1","cy1","dx0","dy0","dx1","dy1","cx","cy","Linear","_context","Radial","_curve","curveRadial","radial","lineRadial","angle","radius","linkSource","linkTarget","link","buffer","argv","x$$1","y$$1","curveHorizontal","moveTo","bezierCurveTo","curveVertical","curveRadial$1","pointRadial","p2","p3","linkHorizontal","linkVertical","linkRadial","_x0","_x1","_y0","_y1","Basis","BasisClosed","BasisOpen","Bundle","beta","_basis","_beta","point$1","_k","_x2","_y2","Cardinal","tension","CardinalClosed","CardinalOpen","point$2","_l01_a","_l01_2a","_l12_a","_l12_2a","_l23_a","_l23_2a","CatmullRom","alpha","_alpha","CatmullRomClosed","CatmullRomOpen","LinearClosed","slope3","h0","h1","slope2","point$3","MonotoneX","MonotoneY","ReflectContext","monotoneX","monotoneY","Natural","controlPoints","Step","_t","stepBefore","stepAfter","stackValue","series","arc","a0","a1","da","a01","a11","a00","a10","da0","da1","ap","rp","padRadius","cornerRadius","rc0","rc1","oc","ax","ay","bx","by","kc","lc","lineTo","closePath","centroid","areaStart","_line","areaEnd","lineStart","_point","lineEnd","curveLinear","defined0","defined","x0z","y0z","arealine","lineX0","lineY0","lineY1","lineX1","pie","arcs","pa","curveRadialLinear","lineRadial$1","areaRadial","lineStartAngle","lineEndAngle","lineInnerRadius","lineOuterRadius","circle","draw","tan30","tan30_2","diamond","ka","kr","kx","ky","star","square","sqrt3","triangle","wye","symbols","_x3","_x4","_y3","_y4","basisOpen","_y","bundle","cardinal","_x5","_y5","cardinalClosed","cardinalOpen","x23","y23","catmullRom","catmullRomClosed","catmullRomOpen","linearClosed","_t0","px","py","natural","none$1","stack","oz","kz","sz","sij","ki","si","expand","diverging","yp","yn","silhouette","wiggle","s2","sij0","sij1","s3","sk","skj0","skj1","sums","descending$1","insideOut","tops","bottoms","radialArea","radialLine","symbolCircle","symbolCross","symbolDiamond","symbolSquare","symbolStar","symbolTriangle","symbolWye","curveBasisClosed","curveBasisOpen","curveBundle","curveCardinalClosed","curveCardinalOpen","curveCardinal","curveCatmullRomClosed","curveCatmullRomOpen","curveCatmullRom","curveLinearClosed","curveMonotoneX","curveMonotoneY","curveNatural","curveStep","curveStepAfter","curveStepBefore","stackOffsetExpand","stackOffsetDiverging","stackOffsetNone","stackOffsetSilhouette","stackOffsetWiggle","stackOrderAscending","stackOrderDescending","stackOrderInsideOut","stackOrderNone","stackOrderReverse","Path","tauEpsilon","quadraticCurveTo","arcTo","x21","y21","l01_2","x20","y20","l21_2","l20_2","l21","l01","t01","t21","ccw","_defineProperty","obj","enumerable","configurable","writable","_slicedToArray","sliceIterator","_arr","_n","_d","_e","_s","_i","Symbol","iterator","done","err","_typeof","_settingsToMajorTickM","singleTickWidth","horizontalTickSpacing","minEntryNumForDayFormat","formatMap","daymonth","localeTimeMap","settingsToMajorTickMap","getAxisSettingsFromTimeSpan","timeSpan","settings","getMaxNumOfHorizontalTicks","dataPointNumber","ticksForWidth","getLocaleDateFormatter","timeUnit","options","formatter","Intl","DateTimeFormat","dataByDate","firstDate","lastDate","dateTimeSpan","_settings$split","_settings$split2","majorTickValue","minorTickValue"],"mappings":"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","file":"brush.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"brush\"] = factory();\n\telse\n\t\troot[\"britecharts\"] = root[\"britecharts\"] || {}, root[\"britecharts\"][\"brush\"] = factory();\n})(this, function() {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"brush\"] = factory();\n\telse\n\t\troot[\"britecharts\"] = root[\"britecharts\"] || {}, root[\"britecharts\"][\"brush\"] = factory();\n})(this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_RESULT__;'use strict';\n\t\n\tfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\t\n\t!(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) {\n\t    'use strict';\n\t\n\t    var d3Array = __webpack_require__(1);\n\t    var d3Axis = __webpack_require__(3);\n\t    var d3Brush = __webpack_require__(22);\n\t    var d3Ease = __webpack_require__(2);\n\t    var d3Scale = __webpack_require__(7);\n\t    var d3Shape = __webpack_require__(24);\n\t    var d3Dispatch = __webpack_require__(5);\n\t    var d3Selection = __webpack_require__(12);\n\t    var d3Time = __webpack_require__(10);\n\t    var d3Transition = __webpack_require__(13);\n\t    var d3TimeFormat = __webpack_require__(11);\n\t\n\t    var colorHelper = __webpack_require__(17);\n\t    var timeAxisHelper = __webpack_require__(26);\n\t\n\t    var _require = __webpack_require__(18),\n\t        axisTimeCombinations = _require.axisTimeCombinations;\n\t\n\t    /**\n\t     * @typedef BrushChartData\n\t     * @type {Object[]}\n\t     * @property {Number} value        Value to chart (required)\n\t     * @property {Date} date           Date of the value (required)\n\t     *\n\t     * @example\n\t     * [\n\t     *     {\n\t     *         value: 1,\n\t     *         date: '2011-01-06T00:00:00Z'\n\t     *     },\n\t     *     {\n\t     *         value: 2,\n\t     *         date: '2011-01-07T00:00:00Z'\n\t     *     }\n\t     * ]\n\t     */\n\t\n\t    /**\n\t     * Brush Chart reusable API class that renders a\n\t     * simple and configurable brush chart.\n\t     *\n\t     * @module Brush\n\t     * @tutorial brush\n\t     * @requires d3-array, d3-axis, d3-brush, d3-ease, d3-scale, d3-shape, d3-selection, d3-time, d3-time-format\n\t     *\n\t     * @example\n\t     * let brushChart = brush();\n\t     *\n\t     * brushChart\n\t     *     .height(500)\n\t     *     .width(800);\n\t     *\n\t     * d3Selection.select('.css-selector')\n\t     *     .datum(dataset)\n\t     *     .call(brushChart);\n\t     *\n\t     */\n\t\n\t    return function module() {\n\t\n\t        var margin = {\n\t            top: 20,\n\t            right: 20,\n\t            bottom: 30,\n\t            left: 20\n\t        },\n\t            width = 960,\n\t            height = 500,\n\t            data = void 0,\n\t            svg = void 0,\n\t            ease = d3Ease.easeQuadOut,\n\t            dateLabel = 'date',\n\t            valueLabel = 'value',\n\t            dateRange = [null, null],\n\t            chartWidth = void 0,\n\t            chartHeight = void 0,\n\t            xScale = void 0,\n\t            yScale = void 0,\n\t            xAxis = void 0,\n\t            xAxisFormat = null,\n\t            xTicks = null,\n\t            xAxisCustomFormat = null,\n\t            brush = void 0,\n\t            chartBrush = void 0,\n\t            handle = void 0,\n\t            tickPadding = 5,\n\t            gradient = colorHelper.colorGradients.greenBlue,\n\t\n\t\n\t        // Dispatcher object to broadcast the mouse events\n\t        // Ref: https://github.com/mbostock/d3/wiki/Internals#d3_dispatch\n\t        dispatcher = d3Dispatch.dispatch('customBrushStart', 'customBrushEnd'),\n\t\n\t\n\t        // extractors\n\t        getValue = function getValue(_ref) {\n\t            var value = _ref.value;\n\t            return value;\n\t        },\n\t            getDate = function getDate(_ref2) {\n\t            var date = _ref2.date;\n\t            return date;\n\t        };\n\t\n\t        /**\n\t         * This function creates the graph using the selection as container\n\t         * @param  {D3Selection} _selection A d3 selection that represents\n\t         *                                  the container(s) where the chart(s) will be rendered\n\t         * @param {BrushChartData} _data The data to attach and generate the chart\n\t         */\n\t        function exports(_selection) {\n\t            _selection.each(function (_data) {\n\t                chartWidth = width - margin.left - margin.right;\n\t                chartHeight = height - margin.top - margin.bottom;\n\t                data = cleanData(cloneData(_data));\n\t\n\t                buildScales();\n\t                buildAxis();\n\t                buildSVG(this);\n\t                buildGradient();\n\t                buildBrush();\n\t                drawArea();\n\t                drawAxis();\n\t                drawBrush();\n\t                drawHandles();\n\t            });\n\t        }\n\t\n\t        /**\n\t         * Creates the d3 x axis, setting orientation\n\t         * @private\n\t         */\n\t        function buildAxis() {\n\t            var minor = void 0,\n\t                major = void 0;\n\t\n\t            if (xAxisFormat === 'custom' && typeof xAxisCustomFormat === 'string') {\n\t                minor = {\n\t                    tick: xTicks,\n\t                    format: d3TimeFormat.timeFormat(xAxisCustomFormat)\n\t                };\n\t            } else {\n\t                var _timeAxisHelper$getXA = timeAxisHelper.getXAxisSettings(data, width, xAxisFormat);\n\t\n\t                minor = _timeAxisHelper$getXA.minor;\n\t                major = _timeAxisHelper$getXA.major;\n\t            }\n\t\n\t            xAxis = d3Axis.axisBottom(xScale).ticks(minor.tick).tickSize(10, 0).tickPadding([tickPadding]).tickFormat(minor.format);\n\t        }\n\t\n\t        /**\n\t         * Creates the brush element and attaches a listener\n\t         * @return {void}\n\t         */\n\t        function buildBrush() {\n\t            brush = d3Brush.brushX().extent([[0, 0], [chartWidth, chartHeight]]).on('brush', handleBrushStart).on('end', handleBrushEnd);\n\t        }\n\t\n\t        /**\n\t         * Builds containers for the chart, the axis and a wrapper for all of them\n\t         * Also applies the Margin convention\n\t         * @private\n\t         */\n\t        function buildContainerGroups() {\n\t            var container = svg.append('g').classed('container-group', true).attr('transform', 'translate(' + margin.left + ', ' + margin.top + ')');\n\t\n\t            container.append('g').classed('chart-group', true);\n\t            container.append('g').classed('metadata-group', true);\n\t            container.append('g').classed('x-axis-group', true);\n\t            container.append('g').classed('brush-group', true);\n\t        }\n\t\n\t        /**\n\t         * Creates the gradient on the area\n\t         * @return {void}\n\t         */\n\t        function buildGradient() {\n\t            var metadataGroup = svg.select('.metadata-group');\n\t\n\t            metadataGroup.append('linearGradient').attr('id', 'brush-area-gradient').attr('gradientUnits', 'userSpaceOnUse').attr('x1', 0).attr('x2', xScale(data[data.length - 1].date)).attr('y1', 0).attr('y2', 0).selectAll('stop').data([{ offset: '0%', color: gradient[0] }, { offset: '100%', color: gradient[1] }]).enter().append('stop').attr('offset', function (_ref3) {\n\t                var offset = _ref3.offset;\n\t                return offset;\n\t            }).attr('stop-color', function (_ref4) {\n\t                var color = _ref4.color;\n\t                return color;\n\t            });\n\t        }\n\t\n\t        /**\n\t         * Creates the x and y scales of the graph\n\t         * @private\n\t         */\n\t        function buildScales() {\n\t            xScale = d3Scale.scaleTime().domain(d3Array.extent(data, getDate)).range([0, chartWidth]);\n\t\n\t            yScale = d3Scale.scaleLinear().domain([0, d3Array.max(data, getValue)]).range([chartHeight, 0]);\n\t        }\n\t\n\t        /**\n\t         * Builds the SVG element that will contain the chart\n\t         * @param  {HTMLElement} container DOM element that will work as the container of the graph\n\t         * @private\n\t         */\n\t        function buildSVG(container) {\n\t            if (!svg) {\n\t                svg = d3Selection.select(container).append('svg').classed('britechart brush-chart', true);\n\t\n\t                buildContainerGroups();\n\t            }\n\t\n\t            svg.attr('width', width).attr('height', height);\n\t        }\n\t\n\t        /**\n\t         * Cleaning data adding the proper format\n\t         *\n\t         * @param  {BrushChartData} data Data\n\t         */\n\t        function cleanData(data) {\n\t            return data.map(function (d) {\n\t                d.date = new Date(d[dateLabel]);\n\t                d.value = +d[valueLabel];\n\t\n\t                return d;\n\t            });\n\t        }\n\t\n\t        /**\n\t         * Clones the passed array of data\n\t         * @param  {Object[]} dataToClone Data to clone\n\t         * @return {Object[]}             Cloned data\n\t         */\n\t        function cloneData(dataToClone) {\n\t            return JSON.parse(JSON.stringify(dataToClone));\n\t        }\n\t\n\t        /**\n\t         * Draws the x axis on the svg object within its group\n\t         *\n\t         * @private\n\t         */\n\t        function drawAxis() {\n\t            svg.select('.x-axis-group').append('g').attr('class', 'x axis').attr('transform', 'translate(0, ' + chartHeight + ')').call(xAxis);\n\t        }\n\t\n\t        /**\n\t         * Draws the area that is going to represent the data\n\t         *\n\t         * @return {void}\n\t         */\n\t        function drawArea() {\n\t            // Create and configure the area generator\n\t            var area = d3Shape.area().x(function (_ref5) {\n\t                var date = _ref5.date;\n\t                return xScale(date);\n\t            }).y0(chartHeight).y1(function (_ref6) {\n\t                var value = _ref6.value;\n\t                return yScale(value);\n\t            }).curve(d3Shape.curveBasis);\n\t\n\t            // Create the area path\n\t            svg.select('.chart-group').append('path').datum(data).attr('class', 'brush-area').attr('d', area);\n\t        }\n\t\n\t        /**\n\t         * Draws the Brush components on its group\n\t         * @return {void}\n\t         */\n\t        function drawBrush() {\n\t            chartBrush = svg.select('.brush-group').call(brush);\n\t\n\t            // Update the height of the brushing rectangle\n\t            chartBrush.selectAll('rect').classed('brush-rect', true).attr('height', chartHeight);\n\t        }\n\t\n\t        /**\n\t         * Draws a handle for the Brush section\n\t         * @return {void}\n\t         */\n\t        function drawHandles() {\n\t            var handleFillColor = colorHelper.colorSchemasHuman.grey[1];\n\t\n\t            // Styling\n\t            handle = chartBrush.selectAll('.handle.brush-rect').style('fill', handleFillColor);\n\t        }\n\t\n\t        /**\n\t         * When a brush event starts, we can extract info from the extension\n\t         * of the brush.\n\t         *\n\t         * @return {void}\n\t         */\n\t        function handleBrushStart() {\n\t            var s = d3Selection.event.selection,\n\t                dateExtent = s.map(xScale.invert);\n\t\n\t            dispatcher.call('customBrushStart', this, dateExtent);\n\t            // updateHandlers(dateExtent);\n\t        }\n\t\n\t        /**\n\t         * Processes the end brush event, snapping the boundaries to days\n\t         * as showed on the example on https://bl.ocks.org/mbostock/6232537\n\t         * @return {void}\n\t         * @private\n\t         */\n\t        function handleBrushEnd() {\n\t            if (!d3Selection.event.sourceEvent) return; // Only transition after input.\n\t            if (!d3Selection.event.selection) return; // Ignore empty selections.\n\t\n\t            var s = d3Selection.event.selection,\n\t                dateExtent = s.map(xScale.invert),\n\t                dateExtentRounded = dateExtent.map(d3Time.timeDay.round);\n\t\n\t            // If empty when rounded, use floor & ceil instead.\n\t            if (dateExtentRounded[0] >= dateExtentRounded[1]) {\n\t                dateExtentRounded[0] = d3Time.timeDay.floor(dateExtent[0]);\n\t                dateExtentRounded[1] = d3Time.timeDay.offset(dateExtentRounded[0]);\n\t            }\n\t\n\t            d3Selection.select(this).transition().call(d3Selection.event.target.move, dateExtentRounded.map(xScale));\n\t\n\t            dispatcher.call('customBrushEnd', this, dateExtentRounded);\n\t        }\n\t\n\t        /**\n\t         * Sets a new brush extent within the passed percentage positions\n\t         * @param {Number} a Percentage of data that the brush start with\n\t         * @param {Number} b Percentage of data that the brush ends with\n\t         * @example\n\t         *     setBrushByPercentages(0.25, 0.5)\n\t         */\n\t        function setBrushByPercentages(a, b) {\n\t            var x0 = a * chartWidth,\n\t                x1 = b * chartWidth;\n\t\n\t            brush.move(chartBrush, [x0, x1]);\n\t        }\n\t\n\t        /**\n\t         * Sets a new brush extent within the passed dates\n\t         * @param {String | Date} dateA Initial Date\n\t         * @param {String | Date} dateB End Date\n\t         */\n\t        function setBrushByDates(dateA, dateB) {\n\t            var x0 = xScale(new Date(dateA)),\n\t                x1 = xScale(new Date(dateB));\n\t\n\t            brush.move(chartBrush, [x0, x1]);\n\t        }\n\t\n\t        /**\n\t         * Updates visibility and position of the brush handlers\n\t         * @param  {Number[]} dateExtent Date range\n\t         * @return {void}\n\t         */\n\t        function updateHandlers(dateExtent) {\n\t            if (dateExtent === null) {\n\t                handle.attr('display', 'none');\n\t            } else {\n\t                handle.attr('display', null).attr('transform', function (d, i) {\n\t                    return 'translate(' + dateExtent[i] + ',' + chartHeight / 2 + ')';\n\t                });\n\t            }\n\t        }\n\t\n\t        // API\n\t\n\t        /**\n\t         * Exposes the constants to be used to force the x axis to respect a certain granularity\n\t         * current options: MINUTE_HOUR, HOUR_DAY, DAY_MONTH, MONTH_YEAR\n\t         * @example\n\t         *     brush.xAxisCustomFormat(brush.axisTimeCombinations.HOUR_DAY)\n\t         */\n\t        exports.axisTimeCombinations = axisTimeCombinations;\n\t\n\t        /**\n\t         * Gets or Sets the dateRange for the selected part of the brush\n\t         * @param  {String[]} _x Desired dateRange for the graph\n\t         * @return { dateRange | module} Current dateRange or Chart module to chain calls\n\t         * @public\n\t         */\n\t        exports.dateRange = function (_x) {\n\t            if (!arguments.length) {\n\t                return dateRange;\n\t            }\n\t            dateRange = _x;\n\t\n\t            if (Array.isArray(dateRange)) {\n\t                setBrushByDates.apply(undefined, _toConsumableArray(dateRange));\n\t            }\n\t\n\t            return this;\n\t        };\n\t\n\t        /**\n\t         * Gets or Sets the gradient of the chart\n\t         * @param  {String[]} _x        Desired gradient for the graph\n\t         * @return {String | Module}    Current gradient or Chart module to chain calls\n\t         * @public\n\t         */\n\t        exports.gradient = function (_x) {\n\t            if (!arguments.length) {\n\t                return gradient;\n\t            }\n\t            gradient = _x;\n\t\n\t            return this;\n\t        };\n\t\n\t        /**\n\t         * Gets or Sets the height of the chart\n\t         * @param  {Number} _x          Desired width for the graph\n\t         * @return {Number | Module}    Current height or Chart module to chain calls\n\t         * @public\n\t         */\n\t        exports.height = function (_x) {\n\t            if (!arguments.length) {\n\t                return height;\n\t            }\n\t            height = _x;\n\t\n\t            return this;\n\t        };\n\t\n\t        /**\n\t         * Gets or Sets the margin of the chart\n\t         * @param  {Object} _x          Margin object to get/set\n\t         * @return {Object | Module}    Current margin or Chart module to chain calls\n\t         * @public\n\t         */\n\t        exports.margin = function (_x) {\n\t            if (!arguments.length) {\n\t                return margin;\n\t            }\n\t            margin = _x;\n\t\n\t            return this;\n\t        };\n\t\n\t        /**\n\t         * Exposes an 'on' method that acts as a bridge with the event dispatcher\n\t         * We are going to expose this events:\n\t         * customMouseOver, customMouseMove and customMouseOut\n\t         *\n\t         * @return {module} Bar Chart\n\t         * @public\n\t         */\n\t        exports.on = function () {\n\t            var value = dispatcher.on.apply(dispatcher, arguments);\n\t\n\t            return value === dispatcher ? exports : value;\n\t        };\n\t\n\t        /**\n\t         * Gets or Sets the width of the chart\n\t         * @param  {Number} _x          Desired width for the graph\n\t         * @return {Number | Module}    Current width or Chart module to chain calls\n\t         * @public\n\t         */\n\t        exports.width = function (_x) {\n\t            if (!arguments.length) {\n\t                return width;\n\t            }\n\t            width = _x;\n\t\n\t            return this;\n\t        };\n\t\n\t        /**\n\t         * Exposes the ability to force the chart to show a certain x format\n\t         * It requires a `xAxisFormat` of 'custom' in order to work.\n\t         * @param  {String} _x              Desired format for x axis\n\t         * @return {String | Module}        Current format or module to chain calls\n\t         */\n\t        exports.xAxisCustomFormat = function (_x) {\n\t            if (!arguments.length) {\n\t                return xAxisCustomFormat;\n\t            }\n\t            xAxisCustomFormat = _x;\n\t\n\t            return this;\n\t        };\n\t\n\t        /**\n\t         * Exposes the ability to force the chart to show a certain x axis grouping\n\t         * @param  {String} _x          Desired format\n\t         * @return {String | Module}    Current format or module to chain calls\n\t         * @example\n\t         *     brush.xAxisFormat(brush.axisTimeCombinations.HOUR_DAY)\n\t         */\n\t        exports.xAxisFormat = function (_x) {\n\t            if (!arguments.length) {\n\t                return xAxisFormat;\n\t            }\n\t            xAxisFormat = _x;\n\t\n\t            return this;\n\t        };\n\t\n\t        /**\n\t         * Exposes the ability to force the chart to show a certain x ticks. It requires a `xAxisCustomFormat` of 'custom' in order to work.\n\t         * NOTE: This value needs to be a multiple of 2, 5 or 10. They won't always work as expected, as D3 decides at the end\n\t         * how many and where the ticks will appear.\n\t         *\n\t         * @param  {Number} _x              Desired number of x axis ticks (multiple of 2, 5 or 10)\n\t         * @return {Number | Module}        Current number or ticks or module to chain calls\n\t         */\n\t        exports.xTicks = function (_x) {\n\t            if (!arguments.length) {\n\t                return xTicks;\n\t            }\n\t            xTicks = _x;\n\t\n\t            return this;\n\t        };\n\t\n\t        return exports;\n\t    };\n\t}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t// https://d3js.org/d3-array/ Version 1.2.0. Copyright 2017 Mike Bostock.\n\t(function (global, factory) {\n\t\t true ? factory(exports) :\n\t\ttypeof define === 'function' && define.amd ? define(['exports'], factory) :\n\t\t(factory((global.d3 = global.d3 || {})));\n\t}(this, (function (exports) { 'use strict';\n\t\n\tvar ascending = function(a, b) {\n\t  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;\n\t};\n\t\n\tvar bisector = function(compare) {\n\t  if (compare.length === 1) compare = ascendingComparator(compare);\n\t  return {\n\t    left: function(a, x, lo, hi) {\n\t      if (lo == null) lo = 0;\n\t      if (hi == null) hi = a.length;\n\t      while (lo < hi) {\n\t        var mid = lo + hi >>> 1;\n\t        if (compare(a[mid], x) < 0) lo = mid + 1;\n\t        else hi = mid;\n\t      }\n\t      return lo;\n\t    },\n\t    right: function(a, x, lo, hi) {\n\t      if (lo == null) lo = 0;\n\t      if (hi == null) hi = a.length;\n\t      while (lo < hi) {\n\t        var mid = lo + hi >>> 1;\n\t        if (compare(a[mid], x) > 0) hi = mid;\n\t        else lo = mid + 1;\n\t      }\n\t      return lo;\n\t    }\n\t  };\n\t};\n\t\n\tfunction ascendingComparator(f) {\n\t  return function(d, x) {\n\t    return ascending(f(d), x);\n\t  };\n\t}\n\t\n\tvar ascendingBisect = bisector(ascending);\n\tvar bisectRight = ascendingBisect.right;\n\tvar bisectLeft = ascendingBisect.left;\n\t\n\tvar pairs = function(array, f) {\n\t  if (f == null) f = pair;\n\t  var i = 0, n = array.length - 1, p = array[0], pairs = new Array(n < 0 ? 0 : n);\n\t  while (i < n) pairs[i] = f(p, p = array[++i]);\n\t  return pairs;\n\t};\n\t\n\tfunction pair(a, b) {\n\t  return [a, b];\n\t}\n\t\n\tvar cross = function(values0, values1, reduce) {\n\t  var n0 = values0.length,\n\t      n1 = values1.length,\n\t      values = new Array(n0 * n1),\n\t      i0,\n\t      i1,\n\t      i,\n\t      value0;\n\t\n\t  if (reduce == null) reduce = pair;\n\t\n\t  for (i0 = i = 0; i0 < n0; ++i0) {\n\t    for (value0 = values0[i0], i1 = 0; i1 < n1; ++i1, ++i) {\n\t      values[i] = reduce(value0, values1[i1]);\n\t    }\n\t  }\n\t\n\t  return values;\n\t};\n\t\n\tvar descending = function(a, b) {\n\t  return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;\n\t};\n\t\n\tvar number = function(x) {\n\t  return x === null ? NaN : +x;\n\t};\n\t\n\tvar variance = function(values, valueof) {\n\t  var n = values.length,\n\t      m = 0,\n\t      i = -1,\n\t      mean = 0,\n\t      value,\n\t      delta,\n\t      sum = 0;\n\t\n\t  if (valueof == null) {\n\t    while (++i < n) {\n\t      if (!isNaN(value = number(values[i]))) {\n\t        delta = value - mean;\n\t        mean += delta / ++m;\n\t        sum += delta * (value - mean);\n\t      }\n\t    }\n\t  }\n\t\n\t  else {\n\t    while (++i < n) {\n\t      if (!isNaN(value = number(valueof(values[i], i, values)))) {\n\t        delta = value - mean;\n\t        mean += delta / ++m;\n\t        sum += delta * (value - mean);\n\t      }\n\t    }\n\t  }\n\t\n\t  if (m > 1) return sum / (m - 1);\n\t};\n\t\n\tvar deviation = function(array, f) {\n\t  var v = variance(array, f);\n\t  return v ? Math.sqrt(v) : v;\n\t};\n\t\n\tvar extent = function(values, valueof) {\n\t  var n = values.length,\n\t      i = -1,\n\t      value,\n\t      min,\n\t      max;\n\t\n\t  if (valueof == null) {\n\t    while (++i < n) { // Find the first comparable value.\n\t      if ((value = values[i]) != null && value >= value) {\n\t        min = max = value;\n\t        while (++i < n) { // Compare the remaining values.\n\t          if ((value = values[i]) != null) {\n\t            if (min > value) min = value;\n\t            if (max < value) max = value;\n\t          }\n\t        }\n\t      }\n\t    }\n\t  }\n\t\n\t  else {\n\t    while (++i < n) { // Find the first comparable value.\n\t      if ((value = valueof(values[i], i, values)) != null && value >= value) {\n\t        min = max = value;\n\t        while (++i < n) { // Compare the remaining values.\n\t          if ((value = valueof(values[i], i, values)) != null) {\n\t            if (min > value) min = value;\n\t            if (max < value) max = value;\n\t          }\n\t        }\n\t      }\n\t    }\n\t  }\n\t\n\t  return [min, max];\n\t};\n\t\n\tvar array = Array.prototype;\n\t\n\tvar slice = array.slice;\n\tvar map = array.map;\n\t\n\tvar constant = function(x) {\n\t  return function() {\n\t    return x;\n\t  };\n\t};\n\t\n\tvar identity = function(x) {\n\t  return x;\n\t};\n\t\n\tvar range = function(start, stop, step) {\n\t  start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;\n\t\n\t  var i = -1,\n\t      n = Math.max(0, Math.ceil((stop - start) / step)) | 0,\n\t      range = new Array(n);\n\t\n\t  while (++i < n) {\n\t    range[i] = start + i * step;\n\t  }\n\t\n\t  return range;\n\t};\n\t\n\tvar e10 = Math.sqrt(50);\n\tvar e5 = Math.sqrt(10);\n\tvar e2 = Math.sqrt(2);\n\t\n\tvar ticks = function(start, stop, count) {\n\t  var reverse = stop < start,\n\t      i = -1,\n\t      n,\n\t      ticks,\n\t      step;\n\t\n\t  if (reverse) n = start, start = stop, stop = n;\n\t\n\t  if ((step = tickIncrement(start, stop, count)) === 0 || !isFinite(step)) return [];\n\t\n\t  if (step > 0) {\n\t    start = Math.ceil(start / step);\n\t    stop = Math.floor(stop / step);\n\t    ticks = new Array(n = Math.ceil(stop - start + 1));\n\t    while (++i < n) ticks[i] = (start + i) * step;\n\t  } else {\n\t    start = Math.floor(start * step);\n\t    stop = Math.ceil(stop * step);\n\t    ticks = new Array(n = Math.ceil(start - stop + 1));\n\t    while (++i < n) ticks[i] = (start - i) / step;\n\t  }\n\t\n\t  if (reverse) ticks.reverse();\n\t\n\t  return ticks;\n\t};\n\t\n\tfunction tickIncrement(start, stop, count) {\n\t  var step = (stop - start) / Math.max(0, count),\n\t      power = Math.floor(Math.log(step) / Math.LN10),\n\t      error = step / Math.pow(10, power);\n\t  return power >= 0\n\t      ? (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1) * Math.pow(10, power)\n\t      : -Math.pow(10, -power) / (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1);\n\t}\n\t\n\tfunction tickStep(start, stop, count) {\n\t  var step0 = Math.abs(stop - start) / Math.max(0, count),\n\t      step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)),\n\t      error = step0 / step1;\n\t  if (error >= e10) step1 *= 10;\n\t  else if (error >= e5) step1 *= 5;\n\t  else if (error >= e2) step1 *= 2;\n\t  return stop < start ? -step1 : step1;\n\t}\n\t\n\tvar sturges = function(values) {\n\t  return Math.ceil(Math.log(values.length) / Math.LN2) + 1;\n\t};\n\t\n\tvar histogram = function() {\n\t  var value = identity,\n\t      domain = extent,\n\t      threshold = sturges;\n\t\n\t  function histogram(data) {\n\t    var i,\n\t        n = data.length,\n\t        x,\n\t        values = new Array(n);\n\t\n\t    for (i = 0; i < n; ++i) {\n\t      values[i] = value(data[i], i, data);\n\t    }\n\t\n\t    var xz = domain(values),\n\t        x0 = xz[0],\n\t        x1 = xz[1],\n\t        tz = threshold(values, x0, x1);\n\t\n\t    // Convert number of thresholds into uniform thresholds.\n\t    if (!Array.isArray(tz)) {\n\t      tz = tickStep(x0, x1, tz);\n\t      tz = range(Math.ceil(x0 / tz) * tz, Math.floor(x1 / tz) * tz, tz); // exclusive\n\t    }\n\t\n\t    // Remove any thresholds outside the domain.\n\t    var m = tz.length;\n\t    while (tz[0] <= x0) tz.shift(), --m;\n\t    while (tz[m - 1] > x1) tz.pop(), --m;\n\t\n\t    var bins = new Array(m + 1),\n\t        bin;\n\t\n\t    // Initialize bins.\n\t    for (i = 0; i <= m; ++i) {\n\t      bin = bins[i] = [];\n\t      bin.x0 = i > 0 ? tz[i - 1] : x0;\n\t      bin.x1 = i < m ? tz[i] : x1;\n\t    }\n\t\n\t    // Assign data to bins by value, ignoring any outside the domain.\n\t    for (i = 0; i < n; ++i) {\n\t      x = values[i];\n\t      if (x0 <= x && x <= x1) {\n\t        bins[bisectRight(tz, x, 0, m)].push(data[i]);\n\t      }\n\t    }\n\t\n\t    return bins;\n\t  }\n\t\n\t  histogram.value = function(_) {\n\t    return arguments.length ? (value = typeof _ === \"function\" ? _ : constant(_), histogram) : value;\n\t  };\n\t\n\t  histogram.domain = function(_) {\n\t    return arguments.length ? (domain = typeof _ === \"function\" ? _ : constant([_[0], _[1]]), histogram) : domain;\n\t  };\n\t\n\t  histogram.thresholds = function(_) {\n\t    return arguments.length ? (threshold = typeof _ === \"function\" ? _ : Array.isArray(_) ? constant(slice.call(_)) : constant(_), histogram) : threshold;\n\t  };\n\t\n\t  return histogram;\n\t};\n\t\n\tvar quantile = function(values, p, valueof) {\n\t  if (valueof == null) valueof = number;\n\t  if (!(n = values.length)) return;\n\t  if ((p = +p) <= 0 || n < 2) return +valueof(values[0], 0, values);\n\t  if (p >= 1) return +valueof(values[n - 1], n - 1, values);\n\t  var n,\n\t      i = (n - 1) * p,\n\t      i0 = Math.floor(i),\n\t      value0 = +valueof(values[i0], i0, values),\n\t      value1 = +valueof(values[i0 + 1], i0 + 1, values);\n\t  return value0 + (value1 - value0) * (i - i0);\n\t};\n\t\n\tvar freedmanDiaconis = function(values, min, max) {\n\t  values = map.call(values, number).sort(ascending);\n\t  return Math.ceil((max - min) / (2 * (quantile(values, 0.75) - quantile(values, 0.25)) * Math.pow(values.length, -1 / 3)));\n\t};\n\t\n\tvar scott = function(values, min, max) {\n\t  return Math.ceil((max - min) / (3.5 * deviation(values) * Math.pow(values.length, -1 / 3)));\n\t};\n\t\n\tvar max = function(values, valueof) {\n\t  var n = values.length,\n\t      i = -1,\n\t      value,\n\t      max;\n\t\n\t  if (valueof == null) {\n\t    while (++i < n) { // Find the first comparable value.\n\t      if ((value = values[i]) != null && value >= value) {\n\t        max = value;\n\t        while (++i < n) { // Compare the remaining values.\n\t          if ((value = values[i]) != null && value > max) {\n\t            max = value;\n\t          }\n\t        }\n\t      }\n\t    }\n\t  }\n\t\n\t  else {\n\t    while (++i < n) { // Find the first comparable value.\n\t      if ((value = valueof(values[i], i, values)) != null && value >= value) {\n\t        max = value;\n\t        while (++i < n) { // Compare the remaining values.\n\t          if ((value = valueof(values[i], i, values)) != null && value > max) {\n\t            max = value;\n\t          }\n\t        }\n\t      }\n\t    }\n\t  }\n\t\n\t  return max;\n\t};\n\t\n\tvar mean = function(values, valueof) {\n\t  var n = values.length,\n\t      m = n,\n\t      i = -1,\n\t      value,\n\t      sum = 0;\n\t\n\t  if (valueof == null) {\n\t    while (++i < n) {\n\t      if (!isNaN(value = number(values[i]))) sum += value;\n\t      else --m;\n\t    }\n\t  }\n\t\n\t  else {\n\t    while (++i < n) {\n\t      if (!isNaN(value = number(valueof(values[i], i, values)))) sum += value;\n\t      else --m;\n\t    }\n\t  }\n\t\n\t  if (m) return sum / m;\n\t};\n\t\n\tvar median = function(values, valueof) {\n\t  var n = values.length,\n\t      i = -1,\n\t      value,\n\t      numbers = [];\n\t\n\t  if (valueof == null) {\n\t    while (++i < n) {\n\t      if (!isNaN(value = number(values[i]))) {\n\t        numbers.push(value);\n\t      }\n\t    }\n\t  }\n\t\n\t  else {\n\t    while (++i < n) {\n\t      if (!isNaN(value = number(valueof(values[i], i, values)))) {\n\t        numbers.push(value);\n\t      }\n\t    }\n\t  }\n\t\n\t  return quantile(numbers.sort(ascending), 0.5);\n\t};\n\t\n\tvar merge = function(arrays) {\n\t  var n = arrays.length,\n\t      m,\n\t      i = -1,\n\t      j = 0,\n\t      merged,\n\t      array;\n\t\n\t  while (++i < n) j += arrays[i].length;\n\t  merged = new Array(j);\n\t\n\t  while (--n >= 0) {\n\t    array = arrays[n];\n\t    m = array.length;\n\t    while (--m >= 0) {\n\t      merged[--j] = array[m];\n\t    }\n\t  }\n\t\n\t  return merged;\n\t};\n\t\n\tvar min = function(values, valueof) {\n\t  var n = values.length,\n\t      i = -1,\n\t      value,\n\t      min;\n\t\n\t  if (valueof == null) {\n\t    while (++i < n) { // Find the first comparable value.\n\t      if ((value = values[i]) != null && value >= value) {\n\t        min = value;\n\t        while (++i < n) { // Compare the remaining values.\n\t          if ((value = values[i]) != null && min > value) {\n\t            min = value;\n\t          }\n\t        }\n\t      }\n\t    }\n\t  }\n\t\n\t  else {\n\t    while (++i < n) { // Find the first comparable value.\n\t      if ((value = valueof(values[i], i, values)) != null && value >= value) {\n\t        min = value;\n\t        while (++i < n) { // Compare the remaining values.\n\t          if ((value = valueof(values[i], i, values)) != null && min > value) {\n\t            min = value;\n\t          }\n\t        }\n\t      }\n\t    }\n\t  }\n\t\n\t  return min;\n\t};\n\t\n\tvar permute = function(array, indexes) {\n\t  var i = indexes.length, permutes = new Array(i);\n\t  while (i--) permutes[i] = array[indexes[i]];\n\t  return permutes;\n\t};\n\t\n\tvar scan = function(values, compare) {\n\t  if (!(n = values.length)) return;\n\t  var n,\n\t      i = 0,\n\t      j = 0,\n\t      xi,\n\t      xj = values[j];\n\t\n\t  if (compare == null) compare = ascending;\n\t\n\t  while (++i < n) {\n\t    if (compare(xi = values[i], xj) < 0 || compare(xj, xj) !== 0) {\n\t      xj = xi, j = i;\n\t    }\n\t  }\n\t\n\t  if (compare(xj, xj) === 0) return j;\n\t};\n\t\n\tvar shuffle = function(array, i0, i1) {\n\t  var m = (i1 == null ? array.length : i1) - (i0 = i0 == null ? 0 : +i0),\n\t      t,\n\t      i;\n\t\n\t  while (m) {\n\t    i = Math.random() * m-- | 0;\n\t    t = array[m + i0];\n\t    array[m + i0] = array[i + i0];\n\t    array[i + i0] = t;\n\t  }\n\t\n\t  return array;\n\t};\n\t\n\tvar sum = function(values, valueof) {\n\t  var n = values.length,\n\t      i = -1,\n\t      value,\n\t      sum = 0;\n\t\n\t  if (valueof == null) {\n\t    while (++i < n) {\n\t      if (value = +values[i]) sum += value; // Note: zero and null are equivalent.\n\t    }\n\t  }\n\t\n\t  else {\n\t    while (++i < n) {\n\t      if (value = +valueof(values[i], i, values)) sum += value;\n\t    }\n\t  }\n\t\n\t  return sum;\n\t};\n\t\n\tvar transpose = function(matrix) {\n\t  if (!(n = matrix.length)) return [];\n\t  for (var i = -1, m = min(matrix, length), transpose = new Array(m); ++i < m;) {\n\t    for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n;) {\n\t      row[j] = matrix[j][i];\n\t    }\n\t  }\n\t  return transpose;\n\t};\n\t\n\tfunction length(d) {\n\t  return d.length;\n\t}\n\t\n\tvar zip = function() {\n\t  return transpose(arguments);\n\t};\n\t\n\texports.bisect = bisectRight;\n\texports.bisectRight = bisectRight;\n\texports.bisectLeft = bisectLeft;\n\texports.ascending = ascending;\n\texports.bisector = bisector;\n\texports.cross = cross;\n\texports.descending = descending;\n\texports.deviation = deviation;\n\texports.extent = extent;\n\texports.histogram = histogram;\n\texports.thresholdFreedmanDiaconis = freedmanDiaconis;\n\texports.thresholdScott = scott;\n\texports.thresholdSturges = sturges;\n\texports.max = max;\n\texports.mean = mean;\n\texports.median = median;\n\texports.merge = merge;\n\texports.min = min;\n\texports.pairs = pairs;\n\texports.permute = permute;\n\texports.quantile = quantile;\n\texports.range = range;\n\texports.scan = scan;\n\texports.shuffle = shuffle;\n\texports.sum = sum;\n\texports.ticks = ticks;\n\texports.tickIncrement = tickIncrement;\n\texports.tickStep = tickStep;\n\texports.transpose = transpose;\n\texports.variance = variance;\n\texports.zip = zip;\n\t\n\tObject.defineProperty(exports, '__esModule', { value: true });\n\t\n\t})));\n\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t// https://d3js.org/d3-ease/ Version 1.0.3. Copyright 2017 Mike Bostock.\n\t(function (global, factory) {\n\t\t true ? factory(exports) :\n\t\ttypeof define === 'function' && define.amd ? define(['exports'], factory) :\n\t\t(factory((global.d3 = global.d3 || {})));\n\t}(this, (function (exports) { 'use strict';\n\t\n\tfunction linear(t) {\n\t  return +t;\n\t}\n\t\n\tfunction quadIn(t) {\n\t  return t * t;\n\t}\n\t\n\tfunction quadOut(t) {\n\t  return t * (2 - t);\n\t}\n\t\n\tfunction quadInOut(t) {\n\t  return ((t *= 2) <= 1 ? t * t : --t * (2 - t) + 1) / 2;\n\t}\n\t\n\tfunction cubicIn(t) {\n\t  return t * t * t;\n\t}\n\t\n\tfunction cubicOut(t) {\n\t  return --t * t * t + 1;\n\t}\n\t\n\tfunction cubicInOut(t) {\n\t  return ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2;\n\t}\n\t\n\tvar exponent = 3;\n\t\n\tvar polyIn = (function custom(e) {\n\t  e = +e;\n\t\n\t  function polyIn(t) {\n\t    return Math.pow(t, e);\n\t  }\n\t\n\t  polyIn.exponent = custom;\n\t\n\t  return polyIn;\n\t})(exponent);\n\t\n\tvar polyOut = (function custom(e) {\n\t  e = +e;\n\t\n\t  function polyOut(t) {\n\t    return 1 - Math.pow(1 - t, e);\n\t  }\n\t\n\t  polyOut.exponent = custom;\n\t\n\t  return polyOut;\n\t})(exponent);\n\t\n\tvar polyInOut = (function custom(e) {\n\t  e = +e;\n\t\n\t  function polyInOut(t) {\n\t    return ((t *= 2) <= 1 ? Math.pow(t, e) : 2 - Math.pow(2 - t, e)) / 2;\n\t  }\n\t\n\t  polyInOut.exponent = custom;\n\t\n\t  return polyInOut;\n\t})(exponent);\n\t\n\tvar pi = Math.PI;\n\tvar halfPi = pi / 2;\n\t\n\tfunction sinIn(t) {\n\t  return 1 - Math.cos(t * halfPi);\n\t}\n\t\n\tfunction sinOut(t) {\n\t  return Math.sin(t * halfPi);\n\t}\n\t\n\tfunction sinInOut(t) {\n\t  return (1 - Math.cos(pi * t)) / 2;\n\t}\n\t\n\tfunction expIn(t) {\n\t  return Math.pow(2, 10 * t - 10);\n\t}\n\t\n\tfunction expOut(t) {\n\t  return 1 - Math.pow(2, -10 * t);\n\t}\n\t\n\tfunction expInOut(t) {\n\t  return ((t *= 2) <= 1 ? Math.pow(2, 10 * t - 10) : 2 - Math.pow(2, 10 - 10 * t)) / 2;\n\t}\n\t\n\tfunction circleIn(t) {\n\t  return 1 - Math.sqrt(1 - t * t);\n\t}\n\t\n\tfunction circleOut(t) {\n\t  return Math.sqrt(1 - --t * t);\n\t}\n\t\n\tfunction circleInOut(t) {\n\t  return ((t *= 2) <= 1 ? 1 - Math.sqrt(1 - t * t) : Math.sqrt(1 - (t -= 2) * t) + 1) / 2;\n\t}\n\t\n\tvar b1 = 4 / 11;\n\tvar b2 = 6 / 11;\n\tvar b3 = 8 / 11;\n\tvar b4 = 3 / 4;\n\tvar b5 = 9 / 11;\n\tvar b6 = 10 / 11;\n\tvar b7 = 15 / 16;\n\tvar b8 = 21 / 22;\n\tvar b9 = 63 / 64;\n\tvar b0 = 1 / b1 / b1;\n\t\n\tfunction bounceIn(t) {\n\t  return 1 - bounceOut(1 - t);\n\t}\n\t\n\tfunction bounceOut(t) {\n\t  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\t}\n\t\n\tfunction bounceInOut(t) {\n\t  return ((t *= 2) <= 1 ? 1 - bounceOut(1 - t) : bounceOut(t - 1) + 1) / 2;\n\t}\n\t\n\tvar overshoot = 1.70158;\n\t\n\tvar backIn = (function custom(s) {\n\t  s = +s;\n\t\n\t  function backIn(t) {\n\t    return t * t * ((s + 1) * t - s);\n\t  }\n\t\n\t  backIn.overshoot = custom;\n\t\n\t  return backIn;\n\t})(overshoot);\n\t\n\tvar backOut = (function custom(s) {\n\t  s = +s;\n\t\n\t  function backOut(t) {\n\t    return --t * t * ((s + 1) * t + s) + 1;\n\t  }\n\t\n\t  backOut.overshoot = custom;\n\t\n\t  return backOut;\n\t})(overshoot);\n\t\n\tvar backInOut = (function custom(s) {\n\t  s = +s;\n\t\n\t  function backInOut(t) {\n\t    return ((t *= 2) < 1 ? t * t * ((s + 1) * t - s) : (t -= 2) * t * ((s + 1) * t + s) + 2) / 2;\n\t  }\n\t\n\t  backInOut.overshoot = custom;\n\t\n\t  return backInOut;\n\t})(overshoot);\n\t\n\tvar tau = 2 * Math.PI;\n\tvar amplitude = 1;\n\tvar period = 0.3;\n\t\n\tvar elasticIn = (function custom(a, p) {\n\t  var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau);\n\t\n\t  function elasticIn(t) {\n\t    return a * Math.pow(2, 10 * --t) * Math.sin((s - t) / p);\n\t  }\n\t\n\t  elasticIn.amplitude = function(a) { return custom(a, p * tau); };\n\t  elasticIn.period = function(p) { return custom(a, p); };\n\t\n\t  return elasticIn;\n\t})(amplitude, period);\n\t\n\tvar elasticOut = (function custom(a, p) {\n\t  var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau);\n\t\n\t  function elasticOut(t) {\n\t    return 1 - a * Math.pow(2, -10 * (t = +t)) * Math.sin((t + s) / p);\n\t  }\n\t\n\t  elasticOut.amplitude = function(a) { return custom(a, p * tau); };\n\t  elasticOut.period = function(p) { return custom(a, p); };\n\t\n\t  return elasticOut;\n\t})(amplitude, period);\n\t\n\tvar elasticInOut = (function custom(a, p) {\n\t  var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau);\n\t\n\t  function elasticInOut(t) {\n\t    return ((t = t * 2 - 1) < 0\n\t        ? a * Math.pow(2, 10 * t) * Math.sin((s - t) / p)\n\t        : 2 - a * Math.pow(2, -10 * t) * Math.sin((s + t) / p)) / 2;\n\t  }\n\t\n\t  elasticInOut.amplitude = function(a) { return custom(a, p * tau); };\n\t  elasticInOut.period = function(p) { return custom(a, p); };\n\t\n\t  return elasticInOut;\n\t})(amplitude, period);\n\t\n\texports.easeLinear = linear;\n\texports.easeQuad = quadInOut;\n\texports.easeQuadIn = quadIn;\n\texports.easeQuadOut = quadOut;\n\texports.easeQuadInOut = quadInOut;\n\texports.easeCubic = cubicInOut;\n\texports.easeCubicIn = cubicIn;\n\texports.easeCubicOut = cubicOut;\n\texports.easeCubicInOut = cubicInOut;\n\texports.easePoly = polyInOut;\n\texports.easePolyIn = polyIn;\n\texports.easePolyOut = polyOut;\n\texports.easePolyInOut = polyInOut;\n\texports.easeSin = sinInOut;\n\texports.easeSinIn = sinIn;\n\texports.easeSinOut = sinOut;\n\texports.easeSinInOut = sinInOut;\n\texports.easeExp = expInOut;\n\texports.easeExpIn = expIn;\n\texports.easeExpOut = expOut;\n\texports.easeExpInOut = expInOut;\n\texports.easeCircle = circleInOut;\n\texports.easeCircleIn = circleIn;\n\texports.easeCircleOut = circleOut;\n\texports.easeCircleInOut = circleInOut;\n\texports.easeBounce = bounceOut;\n\texports.easeBounceIn = bounceIn;\n\texports.easeBounceOut = bounceOut;\n\texports.easeBounceInOut = bounceInOut;\n\texports.easeBack = backInOut;\n\texports.easeBackIn = backIn;\n\texports.easeBackOut = backOut;\n\texports.easeBackInOut = backInOut;\n\texports.easeElastic = elasticOut;\n\texports.easeElasticIn = elasticIn;\n\texports.easeElasticOut = elasticOut;\n\texports.easeElasticInOut = elasticInOut;\n\t\n\tObject.defineProperty(exports, '__esModule', { value: true });\n\t\n\t})));\n\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t// https://d3js.org/d3-axis/ Version 1.0.8. Copyright 2017 Mike Bostock.\n\t(function (global, factory) {\n\t\t true ? factory(exports) :\n\t\ttypeof define === 'function' && define.amd ? define(['exports'], factory) :\n\t\t(factory((global.d3 = global.d3 || {})));\n\t}(this, (function (exports) { 'use strict';\n\t\n\tvar slice = Array.prototype.slice;\n\t\n\tvar identity = function(x) {\n\t  return x;\n\t};\n\t\n\tvar top = 1;\n\tvar right = 2;\n\tvar bottom = 3;\n\tvar left = 4;\n\tvar epsilon = 1e-6;\n\t\n\tfunction translateX(x) {\n\t  return \"translate(\" + (x + 0.5) + \",0)\";\n\t}\n\t\n\tfunction translateY(y) {\n\t  return \"translate(0,\" + (y + 0.5) + \")\";\n\t}\n\t\n\tfunction number(scale) {\n\t  return function(d) {\n\t    return +scale(d);\n\t  };\n\t}\n\t\n\tfunction center(scale) {\n\t  var offset = Math.max(0, scale.bandwidth() - 1) / 2; // Adjust for 0.5px offset.\n\t  if (scale.round()) offset = Math.round(offset);\n\t  return function(d) {\n\t    return +scale(d) + offset;\n\t  };\n\t}\n\t\n\tfunction entering() {\n\t  return !this.__axis;\n\t}\n\t\n\tfunction axis(orient, scale) {\n\t  var tickArguments = [],\n\t      tickValues = null,\n\t      tickFormat = null,\n\t      tickSizeInner = 6,\n\t      tickSizeOuter = 6,\n\t      tickPadding = 3,\n\t      k = orient === top || orient === left ? -1 : 1,\n\t      x = orient === left || orient === right ? \"x\" : \"y\",\n\t      transform = orient === top || orient === bottom ? translateX : translateY;\n\t\n\t  function axis(context) {\n\t    var values = tickValues == null ? (scale.ticks ? scale.ticks.apply(scale, tickArguments) : scale.domain()) : tickValues,\n\t        format = tickFormat == null ? (scale.tickFormat ? scale.tickFormat.apply(scale, tickArguments) : identity) : tickFormat,\n\t        spacing = Math.max(tickSizeInner, 0) + tickPadding,\n\t        range = scale.range(),\n\t        range0 = +range[0] + 0.5,\n\t        range1 = +range[range.length - 1] + 0.5,\n\t        position = (scale.bandwidth ? center : number)(scale.copy()),\n\t        selection = context.selection ? context.selection() : context,\n\t        path = selection.selectAll(\".domain\").data([null]),\n\t        tick = selection.selectAll(\".tick\").data(values, scale).order(),\n\t        tickExit = tick.exit(),\n\t        tickEnter = tick.enter().append(\"g\").attr(\"class\", \"tick\"),\n\t        line = tick.select(\"line\"),\n\t        text = tick.select(\"text\");\n\t\n\t    path = path.merge(path.enter().insert(\"path\", \".tick\")\n\t        .attr(\"class\", \"domain\")\n\t        .attr(\"stroke\", \"#000\"));\n\t\n\t    tick = tick.merge(tickEnter);\n\t\n\t    line = line.merge(tickEnter.append(\"line\")\n\t        .attr(\"stroke\", \"#000\")\n\t        .attr(x + \"2\", k * tickSizeInner));\n\t\n\t    text = text.merge(tickEnter.append(\"text\")\n\t        .attr(\"fill\", \"#000\")\n\t        .attr(x, k * spacing)\n\t        .attr(\"dy\", orient === top ? \"0em\" : orient === bottom ? \"0.71em\" : \"0.32em\"));\n\t\n\t    if (context !== selection) {\n\t      path = path.transition(context);\n\t      tick = tick.transition(context);\n\t      line = line.transition(context);\n\t      text = text.transition(context);\n\t\n\t      tickExit = tickExit.transition(context)\n\t          .attr(\"opacity\", epsilon)\n\t          .attr(\"transform\", function(d) { return isFinite(d = position(d)) ? transform(d) : this.getAttribute(\"transform\"); });\n\t\n\t      tickEnter\n\t          .attr(\"opacity\", epsilon)\n\t          .attr(\"transform\", function(d) { var p = this.parentNode.__axis; return transform(p && isFinite(p = p(d)) ? p : position(d)); });\n\t    }\n\t\n\t    tickExit.remove();\n\t\n\t    path\n\t        .attr(\"d\", orient === left || orient == right\n\t            ? \"M\" + k * tickSizeOuter + \",\" + range0 + \"H0.5V\" + range1 + \"H\" + k * tickSizeOuter\n\t            : \"M\" + range0 + \",\" + k * tickSizeOuter + \"V0.5H\" + range1 + \"V\" + k * tickSizeOuter);\n\t\n\t    tick\n\t        .attr(\"opacity\", 1)\n\t        .attr(\"transform\", function(d) { return transform(position(d)); });\n\t\n\t    line\n\t        .attr(x + \"2\", k * tickSizeInner);\n\t\n\t    text\n\t        .attr(x, k * spacing)\n\t        .text(format);\n\t\n\t    selection.filter(entering)\n\t        .attr(\"fill\", \"none\")\n\t        .attr(\"font-size\", 10)\n\t        .attr(\"font-family\", \"sans-serif\")\n\t        .attr(\"text-anchor\", orient === right ? \"start\" : orient === left ? \"end\" : \"middle\");\n\t\n\t    selection\n\t        .each(function() { this.__axis = position; });\n\t  }\n\t\n\t  axis.scale = function(_) {\n\t    return arguments.length ? (scale = _, axis) : scale;\n\t  };\n\t\n\t  axis.ticks = function() {\n\t    return tickArguments = slice.call(arguments), axis;\n\t  };\n\t\n\t  axis.tickArguments = function(_) {\n\t    return arguments.length ? (tickArguments = _ == null ? [] : slice.call(_), axis) : tickArguments.slice();\n\t  };\n\t\n\t  axis.tickValues = function(_) {\n\t    return arguments.length ? (tickValues = _ == null ? null : slice.call(_), axis) : tickValues && tickValues.slice();\n\t  };\n\t\n\t  axis.tickFormat = function(_) {\n\t    return arguments.length ? (tickFormat = _, axis) : tickFormat;\n\t  };\n\t\n\t  axis.tickSize = function(_) {\n\t    return arguments.length ? (tickSizeInner = tickSizeOuter = +_, axis) : tickSizeInner;\n\t  };\n\t\n\t  axis.tickSizeInner = function(_) {\n\t    return arguments.length ? (tickSizeInner = +_, axis) : tickSizeInner;\n\t  };\n\t\n\t  axis.tickSizeOuter = function(_) {\n\t    return arguments.length ? (tickSizeOuter = +_, axis) : tickSizeOuter;\n\t  };\n\t\n\t  axis.tickPadding = function(_) {\n\t    return arguments.length ? (tickPadding = +_, axis) : tickPadding;\n\t  };\n\t\n\t  return axis;\n\t}\n\t\n\tfunction axisTop(scale) {\n\t  return axis(top, scale);\n\t}\n\t\n\tfunction axisRight(scale) {\n\t  return axis(right, scale);\n\t}\n\t\n\tfunction axisBottom(scale) {\n\t  return axis(bottom, scale);\n\t}\n\t\n\tfunction axisLeft(scale) {\n\t  return axis(left, scale);\n\t}\n\t\n\texports.axisTop = axisTop;\n\texports.axisRight = axisRight;\n\texports.axisBottom = axisBottom;\n\texports.axisLeft = axisLeft;\n\t\n\tObject.defineProperty(exports, '__esModule', { value: true });\n\t\n\t})));\n\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t// https://d3js.org/d3-color/ Version 1.0.3. Copyright 2017 Mike Bostock.\n\t(function (global, factory) {\n\t\t true ? factory(exports) :\n\t\ttypeof define === 'function' && define.amd ? define(['exports'], factory) :\n\t\t(factory((global.d3 = global.d3 || {})));\n\t}(this, (function (exports) { 'use strict';\n\t\n\tvar define = function(constructor, factory, prototype) {\n\t  constructor.prototype = factory.prototype = prototype;\n\t  prototype.constructor = constructor;\n\t};\n\t\n\tfunction extend(parent, definition) {\n\t  var prototype = Object.create(parent.prototype);\n\t  for (var key in definition) prototype[key] = definition[key];\n\t  return prototype;\n\t}\n\t\n\tfunction Color() {}\n\t\n\tvar darker = 0.7;\n\tvar brighter = 1 / darker;\n\t\n\tvar reI = \"\\\\s*([+-]?\\\\d+)\\\\s*\";\n\tvar reN = \"\\\\s*([+-]?\\\\d*\\\\.?\\\\d+(?:[eE][+-]?\\\\d+)?)\\\\s*\";\n\tvar reP = \"\\\\s*([+-]?\\\\d*\\\\.?\\\\d+(?:[eE][+-]?\\\\d+)?)%\\\\s*\";\n\tvar reHex3 = /^#([0-9a-f]{3})$/;\n\tvar reHex6 = /^#([0-9a-f]{6})$/;\n\tvar reRgbInteger = new RegExp(\"^rgb\\\\(\" + [reI, reI, reI] + \"\\\\)$\");\n\tvar reRgbPercent = new RegExp(\"^rgb\\\\(\" + [reP, reP, reP] + \"\\\\)$\");\n\tvar reRgbaInteger = new RegExp(\"^rgba\\\\(\" + [reI, reI, reI, reN] + \"\\\\)$\");\n\tvar reRgbaPercent = new RegExp(\"^rgba\\\\(\" + [reP, reP, reP, reN] + \"\\\\)$\");\n\tvar reHslPercent = new RegExp(\"^hsl\\\\(\" + [reN, reP, reP] + \"\\\\)$\");\n\tvar reHslaPercent = new RegExp(\"^hsla\\\\(\" + [reN, reP, reP, reN] + \"\\\\)$\");\n\t\n\tvar named = {\n\t  aliceblue: 0xf0f8ff,\n\t  antiquewhite: 0xfaebd7,\n\t  aqua: 0x00ffff,\n\t  aquamarine: 0x7fffd4,\n\t  azure: 0xf0ffff,\n\t  beige: 0xf5f5dc,\n\t  bisque: 0xffe4c4,\n\t  black: 0x000000,\n\t  blanchedalmond: 0xffebcd,\n\t  blue: 0x0000ff,\n\t  blueviolet: 0x8a2be2,\n\t  brown: 0xa52a2a,\n\t  burlywood: 0xdeb887,\n\t  cadetblue: 0x5f9ea0,\n\t  chartreuse: 0x7fff00,\n\t  chocolate: 0xd2691e,\n\t  coral: 0xff7f50,\n\t  cornflowerblue: 0x6495ed,\n\t  cornsilk: 0xfff8dc,\n\t  crimson: 0xdc143c,\n\t  cyan: 0x00ffff,\n\t  darkblue: 0x00008b,\n\t  darkcyan: 0x008b8b,\n\t  darkgoldenrod: 0xb8860b,\n\t  darkgray: 0xa9a9a9,\n\t  darkgreen: 0x006400,\n\t  darkgrey: 0xa9a9a9,\n\t  darkkhaki: 0xbdb76b,\n\t  darkmagenta: 0x8b008b,\n\t  darkolivegreen: 0x556b2f,\n\t  darkorange: 0xff8c00,\n\t  darkorchid: 0x9932cc,\n\t  darkred: 0x8b0000,\n\t  darksalmon: 0xe9967a,\n\t  darkseagreen: 0x8fbc8f,\n\t  darkslateblue: 0x483d8b,\n\t  darkslategray: 0x2f4f4f,\n\t  darkslategrey: 0x2f4f4f,\n\t  darkturquoise: 0x00ced1,\n\t  darkviolet: 0x9400d3,\n\t  deeppink: 0xff1493,\n\t  deepskyblue: 0x00bfff,\n\t  dimgray: 0x696969,\n\t  dimgrey: 0x696969,\n\t  dodgerblue: 0x1e90ff,\n\t  firebrick: 0xb22222,\n\t  floralwhite: 0xfffaf0,\n\t  forestgreen: 0x228b22,\n\t  fuchsia: 0xff00ff,\n\t  gainsboro: 0xdcdcdc,\n\t  ghostwhite: 0xf8f8ff,\n\t  gold: 0xffd700,\n\t  goldenrod: 0xdaa520,\n\t  gray: 0x808080,\n\t  green: 0x008000,\n\t  greenyellow: 0xadff2f,\n\t  grey: 0x808080,\n\t  honeydew: 0xf0fff0,\n\t  hotpink: 0xff69b4,\n\t  indianred: 0xcd5c5c,\n\t  indigo: 0x4b0082,\n\t  ivory: 0xfffff0,\n\t  khaki: 0xf0e68c,\n\t  lavender: 0xe6e6fa,\n\t  lavenderblush: 0xfff0f5,\n\t  lawngreen: 0x7cfc00,\n\t  lemonchiffon: 0xfffacd,\n\t  lightblue: 0xadd8e6,\n\t  lightcoral: 0xf08080,\n\t  lightcyan: 0xe0ffff,\n\t  lightgoldenrodyellow: 0xfafad2,\n\t  lightgray: 0xd3d3d3,\n\t  lightgreen: 0x90ee90,\n\t  lightgrey: 0xd3d3d3,\n\t  lightpink: 0xffb6c1,\n\t  lightsalmon: 0xffa07a,\n\t  lightseagreen: 0x20b2aa,\n\t  lightskyblue: 0x87cefa,\n\t  lightslategray: 0x778899,\n\t  lightslategrey: 0x778899,\n\t  lightsteelblue: 0xb0c4de,\n\t  lightyellow: 0xffffe0,\n\t  lime: 0x00ff00,\n\t  limegreen: 0x32cd32,\n\t  linen: 0xfaf0e6,\n\t  magenta: 0xff00ff,\n\t  maroon: 0x800000,\n\t  mediumaquamarine: 0x66cdaa,\n\t  mediumblue: 0x0000cd,\n\t  mediumorchid: 0xba55d3,\n\t  mediumpurple: 0x9370db,\n\t  mediumseagreen: 0x3cb371,\n\t  mediumslateblue: 0x7b68ee,\n\t  mediumspringgreen: 0x00fa9a,\n\t  mediumturquoise: 0x48d1cc,\n\t  mediumvioletred: 0xc71585,\n\t  midnightblue: 0x191970,\n\t  mintcream: 0xf5fffa,\n\t  mistyrose: 0xffe4e1,\n\t  moccasin: 0xffe4b5,\n\t  navajowhite: 0xffdead,\n\t  navy: 0x000080,\n\t  oldlace: 0xfdf5e6,\n\t  olive: 0x808000,\n\t  olivedrab: 0x6b8e23,\n\t  orange: 0xffa500,\n\t  orangered: 0xff4500,\n\t  orchid: 0xda70d6,\n\t  palegoldenrod: 0xeee8aa,\n\t  palegreen: 0x98fb98,\n\t  paleturquoise: 0xafeeee,\n\t  palevioletred: 0xdb7093,\n\t  papayawhip: 0xffefd5,\n\t  peachpuff: 0xffdab9,\n\t  peru: 0xcd853f,\n\t  pink: 0xffc0cb,\n\t  plum: 0xdda0dd,\n\t  powderblue: 0xb0e0e6,\n\t  purple: 0x800080,\n\t  rebeccapurple: 0x663399,\n\t  red: 0xff0000,\n\t  rosybrown: 0xbc8f8f,\n\t  royalblue: 0x4169e1,\n\t  saddlebrown: 0x8b4513,\n\t  salmon: 0xfa8072,\n\t  sandybrown: 0xf4a460,\n\t  seagreen: 0x2e8b57,\n\t  seashell: 0xfff5ee,\n\t  sienna: 0xa0522d,\n\t  silver: 0xc0c0c0,\n\t  skyblue: 0x87ceeb,\n\t  slateblue: 0x6a5acd,\n\t  slategray: 0x708090,\n\t  slategrey: 0x708090,\n\t  snow: 0xfffafa,\n\t  springgreen: 0x00ff7f,\n\t  steelblue: 0x4682b4,\n\t  tan: 0xd2b48c,\n\t  teal: 0x008080,\n\t  thistle: 0xd8bfd8,\n\t  tomato: 0xff6347,\n\t  turquoise: 0x40e0d0,\n\t  violet: 0xee82ee,\n\t  wheat: 0xf5deb3,\n\t  white: 0xffffff,\n\t  whitesmoke: 0xf5f5f5,\n\t  yellow: 0xffff00,\n\t  yellowgreen: 0x9acd32\n\t};\n\t\n\tdefine(Color, color, {\n\t  displayable: function() {\n\t    return this.rgb().displayable();\n\t  },\n\t  toString: function() {\n\t    return this.rgb() + \"\";\n\t  }\n\t});\n\t\n\tfunction color(format) {\n\t  var m;\n\t  format = (format + \"\").trim().toLowerCase();\n\t  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\t      : (m = reHex6.exec(format)) ? rgbn(parseInt(m[1], 16)) // #ff0000\n\t      : (m = reRgbInteger.exec(format)) ? new Rgb(m[1], m[2], m[3], 1) // rgb(255, 0, 0)\n\t      : (m = reRgbPercent.exec(format)) ? new Rgb(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) // rgb(100%, 0%, 0%)\n\t      : (m = reRgbaInteger.exec(format)) ? rgba(m[1], m[2], m[3], m[4]) // rgba(255, 0, 0, 1)\n\t      : (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\t      : (m = reHslPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) // hsl(120, 50%, 50%)\n\t      : (m = reHslaPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) // hsla(120, 50%, 50%, 1)\n\t      : named.hasOwnProperty(format) ? rgbn(named[format])\n\t      : format === \"transparent\" ? new Rgb(NaN, NaN, NaN, 0)\n\t      : null;\n\t}\n\t\n\tfunction rgbn(n) {\n\t  return new Rgb(n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff, 1);\n\t}\n\t\n\tfunction rgba(r, g, b, a) {\n\t  if (a <= 0) r = g = b = NaN;\n\t  return new Rgb(r, g, b, a);\n\t}\n\t\n\tfunction rgbConvert(o) {\n\t  if (!(o instanceof Color)) o = color(o);\n\t  if (!o) return new Rgb;\n\t  o = o.rgb();\n\t  return new Rgb(o.r, o.g, o.b, o.opacity);\n\t}\n\t\n\tfunction rgb(r, g, b, opacity) {\n\t  return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity);\n\t}\n\t\n\tfunction Rgb(r, g, b, opacity) {\n\t  this.r = +r;\n\t  this.g = +g;\n\t  this.b = +b;\n\t  this.opacity = +opacity;\n\t}\n\t\n\tdefine(Rgb, rgb, extend(Color, {\n\t  brighter: function(k) {\n\t    k = k == null ? brighter : Math.pow(brighter, k);\n\t    return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);\n\t  },\n\t  darker: function(k) {\n\t    k = k == null ? darker : Math.pow(darker, k);\n\t    return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);\n\t  },\n\t  rgb: function() {\n\t    return this;\n\t  },\n\t  displayable: function() {\n\t    return (0 <= this.r && this.r <= 255)\n\t        && (0 <= this.g && this.g <= 255)\n\t        && (0 <= this.b && this.b <= 255)\n\t        && (0 <= this.opacity && this.opacity <= 1);\n\t  },\n\t  toString: function() {\n\t    var a = this.opacity; a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a));\n\t    return (a === 1 ? \"rgb(\" : \"rgba(\")\n\t        + Math.max(0, Math.min(255, Math.round(this.r) || 0)) + \", \"\n\t        + Math.max(0, Math.min(255, Math.round(this.g) || 0)) + \", \"\n\t        + Math.max(0, Math.min(255, Math.round(this.b) || 0))\n\t        + (a === 1 ? \")\" : \", \" + a + \")\");\n\t  }\n\t}));\n\t\n\tfunction hsla(h, s, l, a) {\n\t  if (a <= 0) h = s = l = NaN;\n\t  else if (l <= 0 || l >= 1) h = s = NaN;\n\t  else if (s <= 0) h = NaN;\n\t  return new Hsl(h, s, l, a);\n\t}\n\t\n\tfunction hslConvert(o) {\n\t  if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity);\n\t  if (!(o instanceof Color)) o = color(o);\n\t  if (!o) return new Hsl;\n\t  if (o instanceof Hsl) return o;\n\t  o = o.rgb();\n\t  var r = o.r / 255,\n\t      g = o.g / 255,\n\t      b = o.b / 255,\n\t      min = Math.min(r, g, b),\n\t      max = Math.max(r, g, b),\n\t      h = NaN,\n\t      s = max - min,\n\t      l = (max + min) / 2;\n\t  if (s) {\n\t    if (r === max) h = (g - b) / s + (g < b) * 6;\n\t    else if (g === max) h = (b - r) / s + 2;\n\t    else h = (r - g) / s + 4;\n\t    s /= l < 0.5 ? max + min : 2 - max - min;\n\t    h *= 60;\n\t  } else {\n\t    s = l > 0 && l < 1 ? 0 : h;\n\t  }\n\t  return new Hsl(h, s, l, o.opacity);\n\t}\n\t\n\tfunction hsl(h, s, l, opacity) {\n\t  return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity);\n\t}\n\t\n\tfunction Hsl(h, s, l, opacity) {\n\t  this.h = +h;\n\t  this.s = +s;\n\t  this.l = +l;\n\t  this.opacity = +opacity;\n\t}\n\t\n\tdefine(Hsl, hsl, extend(Color, {\n\t  brighter: function(k) {\n\t    k = k == null ? brighter : Math.pow(brighter, k);\n\t    return new Hsl(this.h, this.s, this.l * k, this.opacity);\n\t  },\n\t  darker: function(k) {\n\t    k = k == null ? darker : Math.pow(darker, k);\n\t    return new Hsl(this.h, this.s, this.l * k, this.opacity);\n\t  },\n\t  rgb: function() {\n\t    var h = this.h % 360 + (this.h < 0) * 360,\n\t        s = isNaN(h) || isNaN(this.s) ? 0 : this.s,\n\t        l = this.l,\n\t        m2 = l + (l < 0.5 ? l : 1 - l) * s,\n\t        m1 = 2 * l - m2;\n\t    return new Rgb(\n\t      hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2),\n\t      hsl2rgb(h, m1, m2),\n\t      hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2),\n\t      this.opacity\n\t    );\n\t  },\n\t  displayable: function() {\n\t    return (0 <= this.s && this.s <= 1 || isNaN(this.s))\n\t        && (0 <= this.l && this.l <= 1)\n\t        && (0 <= this.opacity && this.opacity <= 1);\n\t  }\n\t}));\n\t\n\t/* From FvD 13.37, CSS Color Module Level 3 */\n\tfunction hsl2rgb(h, m1, m2) {\n\t  return (h < 60 ? m1 + (m2 - m1) * h / 60\n\t      : h < 180 ? m2\n\t      : h < 240 ? m1 + (m2 - m1) * (240 - h) / 60\n\t      : m1) * 255;\n\t}\n\t\n\tvar deg2rad = Math.PI / 180;\n\tvar rad2deg = 180 / Math.PI;\n\t\n\tvar Kn = 18;\n\tvar Xn = 0.950470;\n\tvar Yn = 1;\n\tvar Zn = 1.088830;\n\tvar t0 = 4 / 29;\n\tvar t1 = 6 / 29;\n\tvar t2 = 3 * t1 * t1;\n\tvar t3 = t1 * t1 * t1;\n\t\n\tfunction labConvert(o) {\n\t  if (o instanceof Lab) return new Lab(o.l, o.a, o.b, o.opacity);\n\t  if (o instanceof Hcl) {\n\t    var h = o.h * deg2rad;\n\t    return new Lab(o.l, Math.cos(h) * o.c, Math.sin(h) * o.c, o.opacity);\n\t  }\n\t  if (!(o instanceof Rgb)) o = rgbConvert(o);\n\t  var b = rgb2xyz(o.r),\n\t      a = rgb2xyz(o.g),\n\t      l = rgb2xyz(o.b),\n\t      x = xyz2lab((0.4124564 * b + 0.3575761 * a + 0.1804375 * l) / Xn),\n\t      y = xyz2lab((0.2126729 * b + 0.7151522 * a + 0.0721750 * l) / Yn),\n\t      z = xyz2lab((0.0193339 * b + 0.1191920 * a + 0.9503041 * l) / Zn);\n\t  return new Lab(116 * y - 16, 500 * (x - y), 200 * (y - z), o.opacity);\n\t}\n\t\n\tfunction lab(l, a, b, opacity) {\n\t  return arguments.length === 1 ? labConvert(l) : new Lab(l, a, b, opacity == null ? 1 : opacity);\n\t}\n\t\n\tfunction Lab(l, a, b, opacity) {\n\t  this.l = +l;\n\t  this.a = +a;\n\t  this.b = +b;\n\t  this.opacity = +opacity;\n\t}\n\t\n\tdefine(Lab, lab, extend(Color, {\n\t  brighter: function(k) {\n\t    return new Lab(this.l + Kn * (k == null ? 1 : k), this.a, this.b, this.opacity);\n\t  },\n\t  darker: function(k) {\n\t    return new Lab(this.l - Kn * (k == null ? 1 : k), this.a, this.b, this.opacity);\n\t  },\n\t  rgb: function() {\n\t    var y = (this.l + 16) / 116,\n\t        x = isNaN(this.a) ? y : y + this.a / 500,\n\t        z = isNaN(this.b) ? y : y - this.b / 200;\n\t    y = Yn * lab2xyz(y);\n\t    x = Xn * lab2xyz(x);\n\t    z = Zn * lab2xyz(z);\n\t    return new Rgb(\n\t      xyz2rgb( 3.2404542 * x - 1.5371385 * y - 0.4985314 * z), // D65 -> sRGB\n\t      xyz2rgb(-0.9692660 * x + 1.8760108 * y + 0.0415560 * z),\n\t      xyz2rgb( 0.0556434 * x - 0.2040259 * y + 1.0572252 * z),\n\t      this.opacity\n\t    );\n\t  }\n\t}));\n\t\n\tfunction xyz2lab(t) {\n\t  return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0;\n\t}\n\t\n\tfunction lab2xyz(t) {\n\t  return t > t1 ? t * t * t : t2 * (t - t0);\n\t}\n\t\n\tfunction xyz2rgb(x) {\n\t  return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055);\n\t}\n\t\n\tfunction rgb2xyz(x) {\n\t  return (x /= 255) <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4);\n\t}\n\t\n\tfunction hclConvert(o) {\n\t  if (o instanceof Hcl) return new Hcl(o.h, o.c, o.l, o.opacity);\n\t  if (!(o instanceof Lab)) o = labConvert(o);\n\t  var h = Math.atan2(o.b, o.a) * rad2deg;\n\t  return new Hcl(h < 0 ? h + 360 : h, Math.sqrt(o.a * o.a + o.b * o.b), o.l, o.opacity);\n\t}\n\t\n\tfunction hcl(h, c, l, opacity) {\n\t  return arguments.length === 1 ? hclConvert(h) : new Hcl(h, c, l, opacity == null ? 1 : opacity);\n\t}\n\t\n\tfunction Hcl(h, c, l, opacity) {\n\t  this.h = +h;\n\t  this.c = +c;\n\t  this.l = +l;\n\t  this.opacity = +opacity;\n\t}\n\t\n\tdefine(Hcl, hcl, extend(Color, {\n\t  brighter: function(k) {\n\t    return new Hcl(this.h, this.c, this.l + Kn * (k == null ? 1 : k), this.opacity);\n\t  },\n\t  darker: function(k) {\n\t    return new Hcl(this.h, this.c, this.l - Kn * (k == null ? 1 : k), this.opacity);\n\t  },\n\t  rgb: function() {\n\t    return labConvert(this).rgb();\n\t  }\n\t}));\n\t\n\tvar A = -0.14861;\n\tvar B = +1.78277;\n\tvar C = -0.29227;\n\tvar D = -0.90649;\n\tvar E = +1.97294;\n\tvar ED = E * D;\n\tvar EB = E * B;\n\tvar BC_DA = B * C - D * A;\n\t\n\tfunction cubehelixConvert(o) {\n\t  if (o instanceof Cubehelix) return new Cubehelix(o.h, o.s, o.l, o.opacity);\n\t  if (!(o instanceof Rgb)) o = rgbConvert(o);\n\t  var r = o.r / 255,\n\t      g = o.g / 255,\n\t      b = o.b / 255,\n\t      l = (BC_DA * b + ED * r - EB * g) / (BC_DA + ED - EB),\n\t      bl = b - l,\n\t      k = (E * (g - l) - C * bl) / D,\n\t      s = Math.sqrt(k * k + bl * bl) / (E * l * (1 - l)), // NaN if l=0 or l=1\n\t      h = s ? Math.atan2(k, bl) * rad2deg - 120 : NaN;\n\t  return new Cubehelix(h < 0 ? h + 360 : h, s, l, o.opacity);\n\t}\n\t\n\tfunction cubehelix(h, s, l, opacity) {\n\t  return arguments.length === 1 ? cubehelixConvert(h) : new Cubehelix(h, s, l, opacity == null ? 1 : opacity);\n\t}\n\t\n\tfunction Cubehelix(h, s, l, opacity) {\n\t  this.h = +h;\n\t  this.s = +s;\n\t  this.l = +l;\n\t  this.opacity = +opacity;\n\t}\n\t\n\tdefine(Cubehelix, cubehelix, extend(Color, {\n\t  brighter: function(k) {\n\t    k = k == null ? brighter : Math.pow(brighter, k);\n\t    return new Cubehelix(this.h, this.s, this.l * k, this.opacity);\n\t  },\n\t  darker: function(k) {\n\t    k = k == null ? darker : Math.pow(darker, k);\n\t    return new Cubehelix(this.h, this.s, this.l * k, this.opacity);\n\t  },\n\t  rgb: function() {\n\t    var h = isNaN(this.h) ? 0 : (this.h + 120) * deg2rad,\n\t        l = +this.l,\n\t        a = isNaN(this.s) ? 0 : this.s * l * (1 - l),\n\t        cosh = Math.cos(h),\n\t        sinh = Math.sin(h);\n\t    return new Rgb(\n\t      255 * (l + a * (A * cosh + B * sinh)),\n\t      255 * (l + a * (C * cosh + D * sinh)),\n\t      255 * (l + a * (E * cosh)),\n\t      this.opacity\n\t    );\n\t  }\n\t}));\n\t\n\texports.color = color;\n\texports.rgb = rgb;\n\texports.hsl = hsl;\n\texports.lab = lab;\n\texports.hcl = hcl;\n\texports.cubehelix = cubehelix;\n\t\n\tObject.defineProperty(exports, '__esModule', { value: true });\n\t\n\t})));\n\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t// https://d3js.org/d3-dispatch/ Version 1.0.3. Copyright 2017 Mike Bostock.\n\t(function (global, factory) {\n\t\t true ? factory(exports) :\n\t\ttypeof define === 'function' && define.amd ? define(['exports'], factory) :\n\t\t(factory((global.d3 = global.d3 || {})));\n\t}(this, (function (exports) { 'use strict';\n\t\n\tvar noop = {value: function() {}};\n\t\n\tfunction dispatch() {\n\t  for (var i = 0, n = arguments.length, _ = {}, t; i < n; ++i) {\n\t    if (!(t = arguments[i] + \"\") || (t in _)) throw new Error(\"illegal type: \" + t);\n\t    _[t] = [];\n\t  }\n\t  return new Dispatch(_);\n\t}\n\t\n\tfunction Dispatch(_) {\n\t  this._ = _;\n\t}\n\t\n\tfunction parseTypenames(typenames, types) {\n\t  return typenames.trim().split(/^|\\s+/).map(function(t) {\n\t    var name = \"\", i = t.indexOf(\".\");\n\t    if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);\n\t    if (t && !types.hasOwnProperty(t)) throw new Error(\"unknown type: \" + t);\n\t    return {type: t, name: name};\n\t  });\n\t}\n\t\n\tDispatch.prototype = dispatch.prototype = {\n\t  constructor: Dispatch,\n\t  on: function(typename, callback) {\n\t    var _ = this._,\n\t        T = parseTypenames(typename + \"\", _),\n\t        t,\n\t        i = -1,\n\t        n = T.length;\n\t\n\t    // If no callback was specified, return the callback of the given type and name.\n\t    if (arguments.length < 2) {\n\t      while (++i < n) if ((t = (typename = T[i]).type) && (t = get(_[t], typename.name))) return t;\n\t      return;\n\t    }\n\t\n\t    // If a type was specified, set the callback for the given type and name.\n\t    // Otherwise, if a null callback was specified, remove callbacks of the given name.\n\t    if (callback != null && typeof callback !== \"function\") throw new Error(\"invalid callback: \" + callback);\n\t    while (++i < n) {\n\t      if (t = (typename = T[i]).type) _[t] = set(_[t], typename.name, callback);\n\t      else if (callback == null) for (t in _) _[t] = set(_[t], typename.name, null);\n\t    }\n\t\n\t    return this;\n\t  },\n\t  copy: function() {\n\t    var copy = {}, _ = this._;\n\t    for (var t in _) copy[t] = _[t].slice();\n\t    return new Dispatch(copy);\n\t  },\n\t  call: function(type, that) {\n\t    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\t    if (!this._.hasOwnProperty(type)) throw new Error(\"unknown type: \" + type);\n\t    for (t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);\n\t  },\n\t  apply: function(type, that, args) {\n\t    if (!this._.hasOwnProperty(type)) throw new Error(\"unknown type: \" + type);\n\t    for (var t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);\n\t  }\n\t};\n\t\n\tfunction get(type, name) {\n\t  for (var i = 0, n = type.length, c; i < n; ++i) {\n\t    if ((c = type[i]).name === name) {\n\t      return c.value;\n\t    }\n\t  }\n\t}\n\t\n\tfunction set(type, name, callback) {\n\t  for (var i = 0, n = type.length; i < n; ++i) {\n\t    if (type[i].name === name) {\n\t      type[i] = noop, type = type.slice(0, i).concat(type.slice(i + 1));\n\t      break;\n\t    }\n\t  }\n\t  if (callback != null) type.push({name: name, value: callback});\n\t  return type;\n\t}\n\t\n\texports.dispatch = dispatch;\n\t\n\tObject.defineProperty(exports, '__esModule', { value: true });\n\t\n\t})));\n\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t// https://d3js.org/d3-format/ Version 1.2.0. Copyright 2017 Mike Bostock.\n\t(function (global, factory) {\n\t\t true ? factory(exports) :\n\t\ttypeof define === 'function' && define.amd ? define(['exports'], factory) :\n\t\t(factory((global.d3 = global.d3 || {})));\n\t}(this, (function (exports) { 'use strict';\n\t\n\t// Computes the decimal coefficient and exponent of the specified number x with\n\t// significant digits p, where x is positive and p is in [1, 21] or undefined.\n\t// For example, formatDecimal(1.23) returns [\"123\", 0].\n\tvar formatDecimal = function(x, p) {\n\t  if ((i = (x = p ? x.toExponential(p - 1) : x.toExponential()).indexOf(\"e\")) < 0) return null; // NaN, ±Infinity\n\t  var i, coefficient = x.slice(0, i);\n\t\n\t  // The string returned by toExponential either has the form \\d\\.\\d+e[-+]\\d+\n\t  // (e.g., 1.2e+3) or the form \\de[-+]\\d+ (e.g., 1e+3).\n\t  return [\n\t    coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient,\n\t    +x.slice(i + 1)\n\t  ];\n\t};\n\t\n\tvar exponent = function(x) {\n\t  return x = formatDecimal(Math.abs(x)), x ? x[1] : NaN;\n\t};\n\t\n\tvar formatGroup = function(grouping, thousands) {\n\t  return function(value, width) {\n\t    var i = value.length,\n\t        t = [],\n\t        j = 0,\n\t        g = grouping[0],\n\t        length = 0;\n\t\n\t    while (i > 0 && g > 0) {\n\t      if (length + g + 1 > width) g = Math.max(1, width - length);\n\t      t.push(value.substring(i -= g, i + g));\n\t      if ((length += g + 1) > width) break;\n\t      g = grouping[j = (j + 1) % grouping.length];\n\t    }\n\t\n\t    return t.reverse().join(thousands);\n\t  };\n\t};\n\t\n\tvar formatNumerals = function(numerals) {\n\t  return function(value) {\n\t    return value.replace(/[0-9]/g, function(i) {\n\t      return numerals[+i];\n\t    });\n\t  };\n\t};\n\t\n\tvar formatDefault = function(x, p) {\n\t  x = x.toPrecision(p);\n\t\n\t  out: for (var n = x.length, i = 1, i0 = -1, i1; i < n; ++i) {\n\t    switch (x[i]) {\n\t      case \".\": i0 = i1 = i; break;\n\t      case \"0\": if (i0 === 0) i0 = i; i1 = i; break;\n\t      case \"e\": break out;\n\t      default: if (i0 > 0) i0 = 0; break;\n\t    }\n\t  }\n\t\n\t  return i0 > 0 ? x.slice(0, i0) + x.slice(i1 + 1) : x;\n\t};\n\t\n\tvar prefixExponent;\n\t\n\tvar formatPrefixAuto = function(x, p) {\n\t  var d = formatDecimal(x, p);\n\t  if (!d) return x + \"\";\n\t  var coefficient = d[0],\n\t      exponent = d[1],\n\t      i = exponent - (prefixExponent = Math.max(-8, Math.min(8, Math.floor(exponent / 3))) * 3) + 1,\n\t      n = coefficient.length;\n\t  return i === n ? coefficient\n\t      : i > n ? coefficient + new Array(i - n + 1).join(\"0\")\n\t      : i > 0 ? coefficient.slice(0, i) + \".\" + coefficient.slice(i)\n\t      : \"0.\" + new Array(1 - i).join(\"0\") + formatDecimal(x, Math.max(0, p + i - 1))[0]; // less than 1y!\n\t};\n\t\n\tvar formatRounded = function(x, p) {\n\t  var d = formatDecimal(x, p);\n\t  if (!d) return x + \"\";\n\t  var coefficient = d[0],\n\t      exponent = d[1];\n\t  return exponent < 0 ? \"0.\" + new Array(-exponent).join(\"0\") + coefficient\n\t      : coefficient.length > exponent + 1 ? coefficient.slice(0, exponent + 1) + \".\" + coefficient.slice(exponent + 1)\n\t      : coefficient + new Array(exponent - coefficient.length + 2).join(\"0\");\n\t};\n\t\n\tvar formatTypes = {\n\t  \"\": formatDefault,\n\t  \"%\": function(x, p) { return (x * 100).toFixed(p); },\n\t  \"b\": function(x) { return Math.round(x).toString(2); },\n\t  \"c\": function(x) { return x + \"\"; },\n\t  \"d\": function(x) { return Math.round(x).toString(10); },\n\t  \"e\": function(x, p) { return x.toExponential(p); },\n\t  \"f\": function(x, p) { return x.toFixed(p); },\n\t  \"g\": function(x, p) { return x.toPrecision(p); },\n\t  \"o\": function(x) { return Math.round(x).toString(8); },\n\t  \"p\": function(x, p) { return formatRounded(x * 100, p); },\n\t  \"r\": formatRounded,\n\t  \"s\": formatPrefixAuto,\n\t  \"X\": function(x) { return Math.round(x).toString(16).toUpperCase(); },\n\t  \"x\": function(x) { return Math.round(x).toString(16); }\n\t};\n\t\n\t// [[fill]align][sign][symbol][0][width][,][.precision][type]\n\tvar re = /^(?:(.)?([<>=^]))?([+\\-\\( ])?([$#])?(0)?(\\d+)?(,)?(\\.\\d+)?([a-z%])?$/i;\n\t\n\tfunction formatSpecifier(specifier) {\n\t  return new FormatSpecifier(specifier);\n\t}\n\t\n\tformatSpecifier.prototype = FormatSpecifier.prototype; // instanceof\n\t\n\tfunction FormatSpecifier(specifier) {\n\t  if (!(match = re.exec(specifier))) throw new Error(\"invalid format: \" + specifier);\n\t\n\t  var match,\n\t      fill = match[1] || \" \",\n\t      align = match[2] || \">\",\n\t      sign = match[3] || \"-\",\n\t      symbol = match[4] || \"\",\n\t      zero = !!match[5],\n\t      width = match[6] && +match[6],\n\t      comma = !!match[7],\n\t      precision = match[8] && +match[8].slice(1),\n\t      type = match[9] || \"\";\n\t\n\t  // The \"n\" type is an alias for \",g\".\n\t  if (type === \"n\") comma = true, type = \"g\";\n\t\n\t  // Map invalid types to the default format.\n\t  else if (!formatTypes[type]) type = \"\";\n\t\n\t  // If zero fill is specified, padding goes after sign and before digits.\n\t  if (zero || (fill === \"0\" && align === \"=\")) zero = true, fill = \"0\", align = \"=\";\n\t\n\t  this.fill = fill;\n\t  this.align = align;\n\t  this.sign = sign;\n\t  this.symbol = symbol;\n\t  this.zero = zero;\n\t  this.width = width;\n\t  this.comma = comma;\n\t  this.precision = precision;\n\t  this.type = type;\n\t}\n\t\n\tFormatSpecifier.prototype.toString = function() {\n\t  return this.fill\n\t      + this.align\n\t      + this.sign\n\t      + this.symbol\n\t      + (this.zero ? \"0\" : \"\")\n\t      + (this.width == null ? \"\" : Math.max(1, this.width | 0))\n\t      + (this.comma ? \",\" : \"\")\n\t      + (this.precision == null ? \"\" : \".\" + Math.max(0, this.precision | 0))\n\t      + this.type;\n\t};\n\t\n\tvar identity = function(x) {\n\t  return x;\n\t};\n\t\n\tvar prefixes = [\"y\",\"z\",\"a\",\"f\",\"p\",\"n\",\"µ\",\"m\",\"\",\"k\",\"M\",\"G\",\"T\",\"P\",\"E\",\"Z\",\"Y\"];\n\t\n\tvar formatLocale = function(locale) {\n\t  var group = locale.grouping && locale.thousands ? formatGroup(locale.grouping, locale.thousands) : identity,\n\t      currency = locale.currency,\n\t      decimal = locale.decimal,\n\t      numerals = locale.numerals ? formatNumerals(locale.numerals) : identity,\n\t      percent = locale.percent || \"%\";\n\t\n\t  function newFormat(specifier) {\n\t    specifier = formatSpecifier(specifier);\n\t\n\t    var fill = specifier.fill,\n\t        align = specifier.align,\n\t        sign = specifier.sign,\n\t        symbol = specifier.symbol,\n\t        zero = specifier.zero,\n\t        width = specifier.width,\n\t        comma = specifier.comma,\n\t        precision = specifier.precision,\n\t        type = specifier.type;\n\t\n\t    // Compute the prefix and suffix.\n\t    // For SI-prefix, the suffix is lazily computed.\n\t    var prefix = symbol === \"$\" ? currency[0] : symbol === \"#\" && /[boxX]/.test(type) ? \"0\" + type.toLowerCase() : \"\",\n\t        suffix = symbol === \"$\" ? currency[1] : /[%p]/.test(type) ? percent : \"\";\n\t\n\t    // What format function should we use?\n\t    // Is this an integer type?\n\t    // Can this type generate exponential notation?\n\t    var formatType = formatTypes[type],\n\t        maybeSuffix = !type || /[defgprs%]/.test(type);\n\t\n\t    // Set the default precision if not specified,\n\t    // or clamp the specified precision to the supported range.\n\t    // For significant precision, it must be in [1, 21].\n\t    // For fixed precision, it must be in [0, 20].\n\t    precision = precision == null ? (type ? 6 : 12)\n\t        : /[gprs]/.test(type) ? Math.max(1, Math.min(21, precision))\n\t        : Math.max(0, Math.min(20, precision));\n\t\n\t    function format(value) {\n\t      var valuePrefix = prefix,\n\t          valueSuffix = suffix,\n\t          i, n, c;\n\t\n\t      if (type === \"c\") {\n\t        valueSuffix = formatType(value) + valueSuffix;\n\t        value = \"\";\n\t      } else {\n\t        value = +value;\n\t\n\t        // Perform the initial formatting.\n\t        var valueNegative = value < 0;\n\t        value = formatType(Math.abs(value), precision);\n\t\n\t        // If a negative value rounds to zero during formatting, treat as positive.\n\t        if (valueNegative && +value === 0) valueNegative = false;\n\t\n\t        // Compute the prefix and suffix.\n\t        valuePrefix = (valueNegative ? (sign === \"(\" ? sign : \"-\") : sign === \"-\" || sign === \"(\" ? \"\" : sign) + valuePrefix;\n\t        valueSuffix = valueSuffix + (type === \"s\" ? prefixes[8 + prefixExponent / 3] : \"\") + (valueNegative && sign === \"(\" ? \")\" : \"\");\n\t\n\t        // Break the formatted value into the integer “value” part that can be\n\t        // grouped, and fractional or exponential “suffix” part that is not.\n\t        if (maybeSuffix) {\n\t          i = -1, n = value.length;\n\t          while (++i < n) {\n\t            if (c = value.charCodeAt(i), 48 > c || c > 57) {\n\t              valueSuffix = (c === 46 ? decimal + value.slice(i + 1) : value.slice(i)) + valueSuffix;\n\t              value = value.slice(0, i);\n\t              break;\n\t            }\n\t          }\n\t        }\n\t      }\n\t\n\t      // If the fill character is not \"0\", grouping is applied before padding.\n\t      if (comma && !zero) value = group(value, Infinity);\n\t\n\t      // Compute the padding.\n\t      var length = valuePrefix.length + value.length + valueSuffix.length,\n\t          padding = length < width ? new Array(width - length + 1).join(fill) : \"\";\n\t\n\t      // If the fill character is \"0\", grouping is applied after padding.\n\t      if (comma && zero) value = group(padding + value, padding.length ? width - valueSuffix.length : Infinity), padding = \"\";\n\t\n\t      // Reconstruct the final output based on the desired alignment.\n\t      switch (align) {\n\t        case \"<\": value = valuePrefix + value + valueSuffix + padding; break;\n\t        case \"=\": value = valuePrefix + padding + value + valueSuffix; break;\n\t        case \"^\": value = padding.slice(0, length = padding.length >> 1) + valuePrefix + value + valueSuffix + padding.slice(length); break;\n\t        default: value = padding + valuePrefix + value + valueSuffix; break;\n\t      }\n\t\n\t      return numerals(value);\n\t    }\n\t\n\t    format.toString = function() {\n\t      return specifier + \"\";\n\t    };\n\t\n\t    return format;\n\t  }\n\t\n\t  function formatPrefix(specifier, value) {\n\t    var f = newFormat((specifier = formatSpecifier(specifier), specifier.type = \"f\", specifier)),\n\t        e = Math.max(-8, Math.min(8, Math.floor(exponent(value) / 3))) * 3,\n\t        k = Math.pow(10, -e),\n\t        prefix = prefixes[8 + e / 3];\n\t    return function(value) {\n\t      return f(k * value) + prefix;\n\t    };\n\t  }\n\t\n\t  return {\n\t    format: newFormat,\n\t    formatPrefix: formatPrefix\n\t  };\n\t};\n\t\n\tvar locale;\n\t\n\t\n\t\n\tdefaultLocale({\n\t  decimal: \".\",\n\t  thousands: \",\",\n\t  grouping: [3],\n\t  currency: [\"$\", \"\"]\n\t});\n\t\n\tfunction defaultLocale(definition) {\n\t  locale = formatLocale(definition);\n\t  exports.format = locale.format;\n\t  exports.formatPrefix = locale.formatPrefix;\n\t  return locale;\n\t}\n\t\n\tvar precisionFixed = function(step) {\n\t  return Math.max(0, -exponent(Math.abs(step)));\n\t};\n\t\n\tvar precisionPrefix = function(step, value) {\n\t  return Math.max(0, Math.max(-8, Math.min(8, Math.floor(exponent(value) / 3))) * 3 - exponent(Math.abs(step)));\n\t};\n\t\n\tvar precisionRound = function(step, max) {\n\t  step = Math.abs(step), max = Math.abs(max) - step;\n\t  return Math.max(0, exponent(max) - exponent(step)) + 1;\n\t};\n\t\n\texports.formatDefaultLocale = defaultLocale;\n\texports.formatLocale = formatLocale;\n\texports.formatSpecifier = formatSpecifier;\n\texports.precisionFixed = precisionFixed;\n\texports.precisionPrefix = precisionPrefix;\n\texports.precisionRound = precisionRound;\n\t\n\tObject.defineProperty(exports, '__esModule', { value: true });\n\t\n\t})));\n\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t// https://d3js.org/d3-scale/ Version 1.0.6. Copyright 2017 Mike Bostock.\n\t(function (global, factory) {\n\t\t true ? factory(exports, __webpack_require__(1), __webpack_require__(8), __webpack_require__(9), __webpack_require__(6), __webpack_require__(10), __webpack_require__(11), __webpack_require__(4)) :\n\t\ttypeof define === 'function' && define.amd ? define(['exports', 'd3-array', 'd3-collection', 'd3-interpolate', 'd3-format', 'd3-time', 'd3-time-format', 'd3-color'], factory) :\n\t\t(factory((global.d3 = global.d3 || {}),global.d3,global.d3,global.d3,global.d3,global.d3,global.d3,global.d3));\n\t}(this, (function (exports,d3Array,d3Collection,d3Interpolate,d3Format,d3Time,d3TimeFormat,d3Color) { 'use strict';\n\t\n\tvar array = Array.prototype;\n\t\n\tvar map$1 = array.map;\n\tvar slice = array.slice;\n\t\n\tvar implicit = {name: \"implicit\"};\n\t\n\tfunction ordinal(range$$1) {\n\t  var index = d3Collection.map(),\n\t      domain = [],\n\t      unknown = implicit;\n\t\n\t  range$$1 = range$$1 == null ? [] : slice.call(range$$1);\n\t\n\t  function scale(d) {\n\t    var key = d + \"\", i = index.get(key);\n\t    if (!i) {\n\t      if (unknown !== implicit) return unknown;\n\t      index.set(key, i = domain.push(d));\n\t    }\n\t    return range$$1[(i - 1) % range$$1.length];\n\t  }\n\t\n\t  scale.domain = function(_) {\n\t    if (!arguments.length) return domain.slice();\n\t    domain = [], index = d3Collection.map();\n\t    var i = -1, n = _.length, d, key;\n\t    while (++i < n) if (!index.has(key = (d = _[i]) + \"\")) index.set(key, domain.push(d));\n\t    return scale;\n\t  };\n\t\n\t  scale.range = function(_) {\n\t    return arguments.length ? (range$$1 = slice.call(_), scale) : range$$1.slice();\n\t  };\n\t\n\t  scale.unknown = function(_) {\n\t    return arguments.length ? (unknown = _, scale) : unknown;\n\t  };\n\t\n\t  scale.copy = function() {\n\t    return ordinal()\n\t        .domain(domain)\n\t        .range(range$$1)\n\t        .unknown(unknown);\n\t  };\n\t\n\t  return scale;\n\t}\n\t\n\tfunction band() {\n\t  var scale = ordinal().unknown(undefined),\n\t      domain = scale.domain,\n\t      ordinalRange = scale.range,\n\t      range$$1 = [0, 1],\n\t      step,\n\t      bandwidth,\n\t      round = false,\n\t      paddingInner = 0,\n\t      paddingOuter = 0,\n\t      align = 0.5;\n\t\n\t  delete scale.unknown;\n\t\n\t  function rescale() {\n\t    var n = domain().length,\n\t        reverse = range$$1[1] < range$$1[0],\n\t        start = range$$1[reverse - 0],\n\t        stop = range$$1[1 - reverse];\n\t    step = (stop - start) / Math.max(1, n - paddingInner + paddingOuter * 2);\n\t    if (round) step = Math.floor(step);\n\t    start += (stop - start - step * (n - paddingInner)) * align;\n\t    bandwidth = step * (1 - paddingInner);\n\t    if (round) start = Math.round(start), bandwidth = Math.round(bandwidth);\n\t    var values = d3Array.range(n).map(function(i) { return start + step * i; });\n\t    return ordinalRange(reverse ? values.reverse() : values);\n\t  }\n\t\n\t  scale.domain = function(_) {\n\t    return arguments.length ? (domain(_), rescale()) : domain();\n\t  };\n\t\n\t  scale.range = function(_) {\n\t    return arguments.length ? (range$$1 = [+_[0], +_[1]], rescale()) : range$$1.slice();\n\t  };\n\t\n\t  scale.rangeRound = function(_) {\n\t    return range$$1 = [+_[0], +_[1]], round = true, rescale();\n\t  };\n\t\n\t  scale.bandwidth = function() {\n\t    return bandwidth;\n\t  };\n\t\n\t  scale.step = function() {\n\t    return step;\n\t  };\n\t\n\t  scale.round = function(_) {\n\t    return arguments.length ? (round = !!_, rescale()) : round;\n\t  };\n\t\n\t  scale.padding = function(_) {\n\t    return arguments.length ? (paddingInner = paddingOuter = Math.max(0, Math.min(1, _)), rescale()) : paddingInner;\n\t  };\n\t\n\t  scale.paddingInner = function(_) {\n\t    return arguments.length ? (paddingInner = Math.max(0, Math.min(1, _)), rescale()) : paddingInner;\n\t  };\n\t\n\t  scale.paddingOuter = function(_) {\n\t    return arguments.length ? (paddingOuter = Math.max(0, Math.min(1, _)), rescale()) : paddingOuter;\n\t  };\n\t\n\t  scale.align = function(_) {\n\t    return arguments.length ? (align = Math.max(0, Math.min(1, _)), rescale()) : align;\n\t  };\n\t\n\t  scale.copy = function() {\n\t    return band()\n\t        .domain(domain())\n\t        .range(range$$1)\n\t        .round(round)\n\t        .paddingInner(paddingInner)\n\t        .paddingOuter(paddingOuter)\n\t        .align(align);\n\t  };\n\t\n\t  return rescale();\n\t}\n\t\n\tfunction pointish(scale) {\n\t  var copy = scale.copy;\n\t\n\t  scale.padding = scale.paddingOuter;\n\t  delete scale.paddingInner;\n\t  delete scale.paddingOuter;\n\t\n\t  scale.copy = function() {\n\t    return pointish(copy());\n\t  };\n\t\n\t  return scale;\n\t}\n\t\n\tfunction point() {\n\t  return pointish(band().paddingInner(1));\n\t}\n\t\n\tvar constant = function(x) {\n\t  return function() {\n\t    return x;\n\t  };\n\t};\n\t\n\tvar number = function(x) {\n\t  return +x;\n\t};\n\t\n\tvar unit = [0, 1];\n\t\n\tfunction deinterpolateLinear(a, b) {\n\t  return (b -= (a = +a))\n\t      ? function(x) { return (x - a) / b; }\n\t      : constant(b);\n\t}\n\t\n\tfunction deinterpolateClamp(deinterpolate) {\n\t  return function(a, b) {\n\t    var d = deinterpolate(a = +a, b = +b);\n\t    return function(x) { return x <= a ? 0 : x >= b ? 1 : d(x); };\n\t  };\n\t}\n\t\n\tfunction reinterpolateClamp(reinterpolate) {\n\t  return function(a, b) {\n\t    var r = reinterpolate(a = +a, b = +b);\n\t    return function(t) { return t <= 0 ? a : t >= 1 ? b : r(t); };\n\t  };\n\t}\n\t\n\tfunction bimap(domain, range$$1, deinterpolate, reinterpolate) {\n\t  var d0 = domain[0], d1 = domain[1], r0 = range$$1[0], r1 = range$$1[1];\n\t  if (d1 < d0) d0 = deinterpolate(d1, d0), r0 = reinterpolate(r1, r0);\n\t  else d0 = deinterpolate(d0, d1), r0 = reinterpolate(r0, r1);\n\t  return function(x) { return r0(d0(x)); };\n\t}\n\t\n\tfunction polymap(domain, range$$1, deinterpolate, reinterpolate) {\n\t  var j = Math.min(domain.length, range$$1.length) - 1,\n\t      d = new Array(j),\n\t      r = new Array(j),\n\t      i = -1;\n\t\n\t  // Reverse descending domains.\n\t  if (domain[j] < domain[0]) {\n\t    domain = domain.slice().reverse();\n\t    range$$1 = range$$1.slice().reverse();\n\t  }\n\t\n\t  while (++i < j) {\n\t    d[i] = deinterpolate(domain[i], domain[i + 1]);\n\t    r[i] = reinterpolate(range$$1[i], range$$1[i + 1]);\n\t  }\n\t\n\t  return function(x) {\n\t    var i = d3Array.bisect(domain, x, 1, j) - 1;\n\t    return r[i](d[i](x));\n\t  };\n\t}\n\t\n\tfunction copy(source, target) {\n\t  return target\n\t      .domain(source.domain())\n\t      .range(source.range())\n\t      .interpolate(source.interpolate())\n\t      .clamp(source.clamp());\n\t}\n\t\n\t// deinterpolate(a, b)(x) takes a domain value x in [a,b] and returns the corresponding parameter t in [0,1].\n\t// reinterpolate(a, b)(t) takes a parameter t in [0,1] and returns the corresponding domain value x in [a,b].\n\tfunction continuous(deinterpolate, reinterpolate) {\n\t  var domain = unit,\n\t      range$$1 = unit,\n\t      interpolate$$1 = d3Interpolate.interpolate,\n\t      clamp = false,\n\t      piecewise,\n\t      output,\n\t      input;\n\t\n\t  function rescale() {\n\t    piecewise = Math.min(domain.length, range$$1.length) > 2 ? polymap : bimap;\n\t    output = input = null;\n\t    return scale;\n\t  }\n\t\n\t  function scale(x) {\n\t    return (output || (output = piecewise(domain, range$$1, clamp ? deinterpolateClamp(deinterpolate) : deinterpolate, interpolate$$1)))(+x);\n\t  }\n\t\n\t  scale.invert = function(y) {\n\t    return (input || (input = piecewise(range$$1, domain, deinterpolateLinear, clamp ? reinterpolateClamp(reinterpolate) : reinterpolate)))(+y);\n\t  };\n\t\n\t  scale.domain = function(_) {\n\t    return arguments.length ? (domain = map$1.call(_, number), rescale()) : domain.slice();\n\t  };\n\t\n\t  scale.range = function(_) {\n\t    return arguments.length ? (range$$1 = slice.call(_), rescale()) : range$$1.slice();\n\t  };\n\t\n\t  scale.rangeRound = function(_) {\n\t    return range$$1 = slice.call(_), interpolate$$1 = d3Interpolate.interpolateRound, rescale();\n\t  };\n\t\n\t  scale.clamp = function(_) {\n\t    return arguments.length ? (clamp = !!_, rescale()) : clamp;\n\t  };\n\t\n\t  scale.interpolate = function(_) {\n\t    return arguments.length ? (interpolate$$1 = _, rescale()) : interpolate$$1;\n\t  };\n\t\n\t  return rescale();\n\t}\n\t\n\tvar tickFormat = function(domain, count, specifier) {\n\t  var start = domain[0],\n\t      stop = domain[domain.length - 1],\n\t      step = d3Array.tickStep(start, stop, count == null ? 10 : count),\n\t      precision;\n\t  specifier = d3Format.formatSpecifier(specifier == null ? \",f\" : specifier);\n\t  switch (specifier.type) {\n\t    case \"s\": {\n\t      var value = Math.max(Math.abs(start), Math.abs(stop));\n\t      if (specifier.precision == null && !isNaN(precision = d3Format.precisionPrefix(step, value))) specifier.precision = precision;\n\t      return d3Format.formatPrefix(specifier, value);\n\t    }\n\t    case \"\":\n\t    case \"e\":\n\t    case \"g\":\n\t    case \"p\":\n\t    case \"r\": {\n\t      if (specifier.precision == null && !isNaN(precision = d3Format.precisionRound(step, Math.max(Math.abs(start), Math.abs(stop))))) specifier.precision = precision - (specifier.type === \"e\");\n\t      break;\n\t    }\n\t    case \"f\":\n\t    case \"%\": {\n\t      if (specifier.precision == null && !isNaN(precision = d3Format.precisionFixed(step))) specifier.precision = precision - (specifier.type === \"%\") * 2;\n\t      break;\n\t    }\n\t  }\n\t  return d3Format.format(specifier);\n\t};\n\t\n\tfunction linearish(scale) {\n\t  var domain = scale.domain;\n\t\n\t  scale.ticks = function(count) {\n\t    var d = domain();\n\t    return d3Array.ticks(d[0], d[d.length - 1], count == null ? 10 : count);\n\t  };\n\t\n\t  scale.tickFormat = function(count, specifier) {\n\t    return tickFormat(domain(), count, specifier);\n\t  };\n\t\n\t  scale.nice = function(count) {\n\t    if (count == null) count = 10;\n\t\n\t    var d = domain(),\n\t        i0 = 0,\n\t        i1 = d.length - 1,\n\t        start = d[i0],\n\t        stop = d[i1],\n\t        step;\n\t\n\t    if (stop < start) {\n\t      step = start, start = stop, stop = step;\n\t      step = i0, i0 = i1, i1 = step;\n\t    }\n\t\n\t    step = d3Array.tickIncrement(start, stop, count);\n\t\n\t    if (step > 0) {\n\t      start = Math.floor(start / step) * step;\n\t      stop = Math.ceil(stop / step) * step;\n\t      step = d3Array.tickIncrement(start, stop, count);\n\t    } else if (step < 0) {\n\t      start = Math.ceil(start * step) / step;\n\t      stop = Math.floor(stop * step) / step;\n\t      step = d3Array.tickIncrement(start, stop, count);\n\t    }\n\t\n\t    if (step > 0) {\n\t      d[i0] = Math.floor(start / step) * step;\n\t      d[i1] = Math.ceil(stop / step) * step;\n\t      domain(d);\n\t    } else if (step < 0) {\n\t      d[i0] = Math.ceil(start * step) / step;\n\t      d[i1] = Math.floor(stop * step) / step;\n\t      domain(d);\n\t    }\n\t\n\t    return scale;\n\t  };\n\t\n\t  return scale;\n\t}\n\t\n\tfunction linear() {\n\t  var scale = continuous(deinterpolateLinear, d3Interpolate.interpolateNumber);\n\t\n\t  scale.copy = function() {\n\t    return copy(scale, linear());\n\t  };\n\t\n\t  return linearish(scale);\n\t}\n\t\n\tfunction identity() {\n\t  var domain = [0, 1];\n\t\n\t  function scale(x) {\n\t    return +x;\n\t  }\n\t\n\t  scale.invert = scale;\n\t\n\t  scale.domain = scale.range = function(_) {\n\t    return arguments.length ? (domain = map$1.call(_, number), scale) : domain.slice();\n\t  };\n\t\n\t  scale.copy = function() {\n\t    return identity().domain(domain);\n\t  };\n\t\n\t  return linearish(scale);\n\t}\n\t\n\tvar nice = function(domain, interval) {\n\t  domain = domain.slice();\n\t\n\t  var i0 = 0,\n\t      i1 = domain.length - 1,\n\t      x0 = domain[i0],\n\t      x1 = domain[i1],\n\t      t;\n\t\n\t  if (x1 < x0) {\n\t    t = i0, i0 = i1, i1 = t;\n\t    t = x0, x0 = x1, x1 = t;\n\t  }\n\t\n\t  domain[i0] = interval.floor(x0);\n\t  domain[i1] = interval.ceil(x1);\n\t  return domain;\n\t};\n\t\n\tfunction deinterpolate(a, b) {\n\t  return (b = Math.log(b / a))\n\t      ? function(x) { return Math.log(x / a) / b; }\n\t      : constant(b);\n\t}\n\t\n\tfunction reinterpolate(a, b) {\n\t  return a < 0\n\t      ? function(t) { return -Math.pow(-b, t) * Math.pow(-a, 1 - t); }\n\t      : function(t) { return Math.pow(b, t) * Math.pow(a, 1 - t); };\n\t}\n\t\n\tfunction pow10(x) {\n\t  return isFinite(x) ? +(\"1e\" + x) : x < 0 ? 0 : x;\n\t}\n\t\n\tfunction powp(base) {\n\t  return base === 10 ? pow10\n\t      : base === Math.E ? Math.exp\n\t      : function(x) { return Math.pow(base, x); };\n\t}\n\t\n\tfunction logp(base) {\n\t  return base === Math.E ? Math.log\n\t      : base === 10 && Math.log10\n\t      || base === 2 && Math.log2\n\t      || (base = Math.log(base), function(x) { return Math.log(x) / base; });\n\t}\n\t\n\tfunction reflect(f) {\n\t  return function(x) {\n\t    return -f(-x);\n\t  };\n\t}\n\t\n\tfunction log() {\n\t  var scale = continuous(deinterpolate, reinterpolate).domain([1, 10]),\n\t      domain = scale.domain,\n\t      base = 10,\n\t      logs = logp(10),\n\t      pows = powp(10);\n\t\n\t  function rescale() {\n\t    logs = logp(base), pows = powp(base);\n\t    if (domain()[0] < 0) logs = reflect(logs), pows = reflect(pows);\n\t    return scale;\n\t  }\n\t\n\t  scale.base = function(_) {\n\t    return arguments.length ? (base = +_, rescale()) : base;\n\t  };\n\t\n\t  scale.domain = function(_) {\n\t    return arguments.length ? (domain(_), rescale()) : domain();\n\t  };\n\t\n\t  scale.ticks = function(count) {\n\t    var d = domain(),\n\t        u = d[0],\n\t        v = d[d.length - 1],\n\t        r;\n\t\n\t    if (r = v < u) i = u, u = v, v = i;\n\t\n\t    var i = logs(u),\n\t        j = logs(v),\n\t        p,\n\t        k,\n\t        t,\n\t        n = count == null ? 10 : +count,\n\t        z = [];\n\t\n\t    if (!(base % 1) && j - i < n) {\n\t      i = Math.round(i) - 1, j = Math.round(j) + 1;\n\t      if (u > 0) for (; i < j; ++i) {\n\t        for (k = 1, p = pows(i); k < base; ++k) {\n\t          t = p * k;\n\t          if (t < u) continue;\n\t          if (t > v) break;\n\t          z.push(t);\n\t        }\n\t      } else for (; i < j; ++i) {\n\t        for (k = base - 1, p = pows(i); k >= 1; --k) {\n\t          t = p * k;\n\t          if (t < u) continue;\n\t          if (t > v) break;\n\t          z.push(t);\n\t        }\n\t      }\n\t    } else {\n\t      z = d3Array.ticks(i, j, Math.min(j - i, n)).map(pows);\n\t    }\n\t\n\t    return r ? z.reverse() : z;\n\t  };\n\t\n\t  scale.tickFormat = function(count, specifier) {\n\t    if (specifier == null) specifier = base === 10 ? \".0e\" : \",\";\n\t    if (typeof specifier !== \"function\") specifier = d3Format.format(specifier);\n\t    if (count === Infinity) return specifier;\n\t    if (count == null) count = 10;\n\t    var k = Math.max(1, base * count / scale.ticks().length); // TODO fast estimate?\n\t    return function(d) {\n\t      var i = d / pows(Math.round(logs(d)));\n\t      if (i * base < base - 0.5) i *= base;\n\t      return i <= k ? specifier(d) : \"\";\n\t    };\n\t  };\n\t\n\t  scale.nice = function() {\n\t    return domain(nice(domain(), {\n\t      floor: function(x) { return pows(Math.floor(logs(x))); },\n\t      ceil: function(x) { return pows(Math.ceil(logs(x))); }\n\t    }));\n\t  };\n\t\n\t  scale.copy = function() {\n\t    return copy(scale, log().base(base));\n\t  };\n\t\n\t  return scale;\n\t}\n\t\n\tfunction raise(x, exponent) {\n\t  return x < 0 ? -Math.pow(-x, exponent) : Math.pow(x, exponent);\n\t}\n\t\n\tfunction pow() {\n\t  var exponent = 1,\n\t      scale = continuous(deinterpolate, reinterpolate),\n\t      domain = scale.domain;\n\t\n\t  function deinterpolate(a, b) {\n\t    return (b = raise(b, exponent) - (a = raise(a, exponent)))\n\t        ? function(x) { return (raise(x, exponent) - a) / b; }\n\t        : constant(b);\n\t  }\n\t\n\t  function reinterpolate(a, b) {\n\t    b = raise(b, exponent) - (a = raise(a, exponent));\n\t    return function(t) { return raise(a + b * t, 1 / exponent); };\n\t  }\n\t\n\t  scale.exponent = function(_) {\n\t    return arguments.length ? (exponent = +_, domain(domain())) : exponent;\n\t  };\n\t\n\t  scale.copy = function() {\n\t    return copy(scale, pow().exponent(exponent));\n\t  };\n\t\n\t  return linearish(scale);\n\t}\n\t\n\tfunction sqrt() {\n\t  return pow().exponent(0.5);\n\t}\n\t\n\tfunction quantile$1() {\n\t  var domain = [],\n\t      range$$1 = [],\n\t      thresholds = [];\n\t\n\t  function rescale() {\n\t    var i = 0, n = Math.max(1, range$$1.length);\n\t    thresholds = new Array(n - 1);\n\t    while (++i < n) thresholds[i - 1] = d3Array.quantile(domain, i / n);\n\t    return scale;\n\t  }\n\t\n\t  function scale(x) {\n\t    if (!isNaN(x = +x)) return range$$1[d3Array.bisect(thresholds, x)];\n\t  }\n\t\n\t  scale.invertExtent = function(y) {\n\t    var i = range$$1.indexOf(y);\n\t    return i < 0 ? [NaN, NaN] : [\n\t      i > 0 ? thresholds[i - 1] : domain[0],\n\t      i < thresholds.length ? thresholds[i] : domain[domain.length - 1]\n\t    ];\n\t  };\n\t\n\t  scale.domain = function(_) {\n\t    if (!arguments.length) return domain.slice();\n\t    domain = [];\n\t    for (var i = 0, n = _.length, d; i < n; ++i) if (d = _[i], d != null && !isNaN(d = +d)) domain.push(d);\n\t    domain.sort(d3Array.ascending);\n\t    return rescale();\n\t  };\n\t\n\t  scale.range = function(_) {\n\t    return arguments.length ? (range$$1 = slice.call(_), rescale()) : range$$1.slice();\n\t  };\n\t\n\t  scale.quantiles = function() {\n\t    return thresholds.slice();\n\t  };\n\t\n\t  scale.copy = function() {\n\t    return quantile$1()\n\t        .domain(domain)\n\t        .range(range$$1);\n\t  };\n\t\n\t  return scale;\n\t}\n\t\n\tfunction quantize() {\n\t  var x0 = 0,\n\t      x1 = 1,\n\t      n = 1,\n\t      domain = [0.5],\n\t      range$$1 = [0, 1];\n\t\n\t  function scale(x) {\n\t    if (x <= x) return range$$1[d3Array.bisect(domain, x, 0, n)];\n\t  }\n\t\n\t  function rescale() {\n\t    var i = -1;\n\t    domain = new Array(n);\n\t    while (++i < n) domain[i] = ((i + 1) * x1 - (i - n) * x0) / (n + 1);\n\t    return scale;\n\t  }\n\t\n\t  scale.domain = function(_) {\n\t    return arguments.length ? (x0 = +_[0], x1 = +_[1], rescale()) : [x0, x1];\n\t  };\n\t\n\t  scale.range = function(_) {\n\t    return arguments.length ? (n = (range$$1 = slice.call(_)).length - 1, rescale()) : range$$1.slice();\n\t  };\n\t\n\t  scale.invertExtent = function(y) {\n\t    var i = range$$1.indexOf(y);\n\t    return i < 0 ? [NaN, NaN]\n\t        : i < 1 ? [x0, domain[0]]\n\t        : i >= n ? [domain[n - 1], x1]\n\t        : [domain[i - 1], domain[i]];\n\t  };\n\t\n\t  scale.copy = function() {\n\t    return quantize()\n\t        .domain([x0, x1])\n\t        .range(range$$1);\n\t  };\n\t\n\t  return linearish(scale);\n\t}\n\t\n\tfunction threshold() {\n\t  var domain = [0.5],\n\t      range$$1 = [0, 1],\n\t      n = 1;\n\t\n\t  function scale(x) {\n\t    if (x <= x) return range$$1[d3Array.bisect(domain, x, 0, n)];\n\t  }\n\t\n\t  scale.domain = function(_) {\n\t    return arguments.length ? (domain = slice.call(_), n = Math.min(domain.length, range$$1.length - 1), scale) : domain.slice();\n\t  };\n\t\n\t  scale.range = function(_) {\n\t    return arguments.length ? (range$$1 = slice.call(_), n = Math.min(domain.length, range$$1.length - 1), scale) : range$$1.slice();\n\t  };\n\t\n\t  scale.invertExtent = function(y) {\n\t    var i = range$$1.indexOf(y);\n\t    return [domain[i - 1], domain[i]];\n\t  };\n\t\n\t  scale.copy = function() {\n\t    return threshold()\n\t        .domain(domain)\n\t        .range(range$$1);\n\t  };\n\t\n\t  return scale;\n\t}\n\t\n\tvar durationSecond = 1000;\n\tvar durationMinute = durationSecond * 60;\n\tvar durationHour = durationMinute * 60;\n\tvar durationDay = durationHour * 24;\n\tvar durationWeek = durationDay * 7;\n\tvar durationMonth = durationDay * 30;\n\tvar durationYear = durationDay * 365;\n\t\n\tfunction date(t) {\n\t  return new Date(t);\n\t}\n\t\n\tfunction number$1(t) {\n\t  return t instanceof Date ? +t : +new Date(+t);\n\t}\n\t\n\tfunction calendar(year, month, week, day, hour, minute, second, millisecond, format$$1) {\n\t  var scale = continuous(deinterpolateLinear, d3Interpolate.interpolateNumber),\n\t      invert = scale.invert,\n\t      domain = scale.domain;\n\t\n\t  var formatMillisecond = format$$1(\".%L\"),\n\t      formatSecond = format$$1(\":%S\"),\n\t      formatMinute = format$$1(\"%I:%M\"),\n\t      formatHour = format$$1(\"%I %p\"),\n\t      formatDay = format$$1(\"%a %d\"),\n\t      formatWeek = format$$1(\"%b %d\"),\n\t      formatMonth = format$$1(\"%B\"),\n\t      formatYear = format$$1(\"%Y\");\n\t\n\t  var tickIntervals = [\n\t    [second,  1,      durationSecond],\n\t    [second,  5,  5 * durationSecond],\n\t    [second, 15, 15 * durationSecond],\n\t    [second, 30, 30 * durationSecond],\n\t    [minute,  1,      durationMinute],\n\t    [minute,  5,  5 * durationMinute],\n\t    [minute, 15, 15 * durationMinute],\n\t    [minute, 30, 30 * durationMinute],\n\t    [  hour,  1,      durationHour  ],\n\t    [  hour,  3,  3 * durationHour  ],\n\t    [  hour,  6,  6 * durationHour  ],\n\t    [  hour, 12, 12 * durationHour  ],\n\t    [   day,  1,      durationDay   ],\n\t    [   day,  2,  2 * durationDay   ],\n\t    [  week,  1,      durationWeek  ],\n\t    [ month,  1,      durationMonth ],\n\t    [ month,  3,  3 * durationMonth ],\n\t    [  year,  1,      durationYear  ]\n\t  ];\n\t\n\t  function tickFormat(date) {\n\t    return (second(date) < date ? formatMillisecond\n\t        : minute(date) < date ? formatSecond\n\t        : hour(date) < date ? formatMinute\n\t        : day(date) < date ? formatHour\n\t        : month(date) < date ? (week(date) < date ? formatDay : formatWeek)\n\t        : year(date) < date ? formatMonth\n\t        : formatYear)(date);\n\t  }\n\t\n\t  function tickInterval(interval, start, stop, step) {\n\t    if (interval == null) interval = 10;\n\t\n\t    // If a desired tick count is specified, pick a reasonable tick interval\n\t    // based on the extent of the domain and a rough estimate of tick size.\n\t    // Otherwise, assume interval is already a time interval and use it.\n\t    if (typeof interval === \"number\") {\n\t      var target = Math.abs(stop - start) / interval,\n\t          i = d3Array.bisector(function(i) { return i[2]; }).right(tickIntervals, target);\n\t      if (i === tickIntervals.length) {\n\t        step = d3Array.tickStep(start / durationYear, stop / durationYear, interval);\n\t        interval = year;\n\t      } else if (i) {\n\t        i = tickIntervals[target / tickIntervals[i - 1][2] < tickIntervals[i][2] / target ? i - 1 : i];\n\t        step = i[1];\n\t        interval = i[0];\n\t      } else {\n\t        step = d3Array.tickStep(start, stop, interval);\n\t        interval = millisecond;\n\t      }\n\t    }\n\t\n\t    return step == null ? interval : interval.every(step);\n\t  }\n\t\n\t  scale.invert = function(y) {\n\t    return new Date(invert(y));\n\t  };\n\t\n\t  scale.domain = function(_) {\n\t    return arguments.length ? domain(map$1.call(_, number$1)) : domain().map(date);\n\t  };\n\t\n\t  scale.ticks = function(interval, step) {\n\t    var d = domain(),\n\t        t0 = d[0],\n\t        t1 = d[d.length - 1],\n\t        r = t1 < t0,\n\t        t;\n\t    if (r) t = t0, t0 = t1, t1 = t;\n\t    t = tickInterval(interval, t0, t1, step);\n\t    t = t ? t.range(t0, t1 + 1) : []; // inclusive stop\n\t    return r ? t.reverse() : t;\n\t  };\n\t\n\t  scale.tickFormat = function(count, specifier) {\n\t    return specifier == null ? tickFormat : format$$1(specifier);\n\t  };\n\t\n\t  scale.nice = function(interval, step) {\n\t    var d = domain();\n\t    return (interval = tickInterval(interval, d[0], d[d.length - 1], step))\n\t        ? domain(nice(d, interval))\n\t        : scale;\n\t  };\n\t\n\t  scale.copy = function() {\n\t    return copy(scale, calendar(year, month, week, day, hour, minute, second, millisecond, format$$1));\n\t  };\n\t\n\t  return scale;\n\t}\n\t\n\tvar time = function() {\n\t  return calendar(d3Time.timeYear, d3Time.timeMonth, d3Time.timeWeek, d3Time.timeDay, d3Time.timeHour, d3Time.timeMinute, d3Time.timeSecond, d3Time.timeMillisecond, d3TimeFormat.timeFormat).domain([new Date(2000, 0, 1), new Date(2000, 0, 2)]);\n\t};\n\t\n\tvar utcTime = function() {\n\t  return calendar(d3Time.utcYear, d3Time.utcMonth, d3Time.utcWeek, d3Time.utcDay, d3Time.utcHour, d3Time.utcMinute, d3Time.utcSecond, d3Time.utcMillisecond, d3TimeFormat.utcFormat).domain([Date.UTC(2000, 0, 1), Date.UTC(2000, 0, 2)]);\n\t};\n\t\n\tvar colors = function(s) {\n\t  return s.match(/.{6}/g).map(function(x) {\n\t    return \"#\" + x;\n\t  });\n\t};\n\t\n\tvar category10 = colors(\"1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf\");\n\t\n\tvar category20b = colors(\"393b795254a36b6ecf9c9ede6379398ca252b5cf6bcedb9c8c6d31bd9e39e7ba52e7cb94843c39ad494ad6616be7969c7b4173a55194ce6dbdde9ed6\");\n\t\n\tvar category20c = colors(\"3182bd6baed69ecae1c6dbefe6550dfd8d3cfdae6bfdd0a231a35474c476a1d99bc7e9c0756bb19e9ac8bcbddcdadaeb636363969696bdbdbdd9d9d9\");\n\t\n\tvar category20 = colors(\"1f77b4aec7e8ff7f0effbb782ca02c98df8ad62728ff98969467bdc5b0d58c564bc49c94e377c2f7b6d27f7f7fc7c7c7bcbd22dbdb8d17becf9edae5\");\n\t\n\tvar cubehelix$1 = d3Interpolate.interpolateCubehelixLong(d3Color.cubehelix(300, 0.5, 0.0), d3Color.cubehelix(-240, 0.5, 1.0));\n\t\n\tvar warm = d3Interpolate.interpolateCubehelixLong(d3Color.cubehelix(-100, 0.75, 0.35), d3Color.cubehelix(80, 1.50, 0.8));\n\t\n\tvar cool = d3Interpolate.interpolateCubehelixLong(d3Color.cubehelix(260, 0.75, 0.35), d3Color.cubehelix(80, 1.50, 0.8));\n\t\n\tvar rainbow = d3Color.cubehelix();\n\t\n\tvar rainbow$1 = function(t) {\n\t  if (t < 0 || t > 1) t -= Math.floor(t);\n\t  var ts = Math.abs(t - 0.5);\n\t  rainbow.h = 360 * t - 100;\n\t  rainbow.s = 1.5 - 1.5 * ts;\n\t  rainbow.l = 0.8 - 0.9 * ts;\n\t  return rainbow + \"\";\n\t};\n\t\n\tfunction ramp(range$$1) {\n\t  var n = range$$1.length;\n\t  return function(t) {\n\t    return range$$1[Math.max(0, Math.min(n - 1, Math.floor(t * n)))];\n\t  };\n\t}\n\t\n\tvar viridis = ramp(colors(\"44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725\"));\n\t\n\tvar magma = ramp(colors(\"00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf\"));\n\t\n\tvar inferno = ramp(colors(\"00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4\"));\n\t\n\tvar plasma = ramp(colors(\"0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921\"));\n\t\n\tfunction sequential(interpolator) {\n\t  var x0 = 0,\n\t      x1 = 1,\n\t      clamp = false;\n\t\n\t  function scale(x) {\n\t    var t = (x - x0) / (x1 - x0);\n\t    return interpolator(clamp ? Math.max(0, Math.min(1, t)) : t);\n\t  }\n\t\n\t  scale.domain = function(_) {\n\t    return arguments.length ? (x0 = +_[0], x1 = +_[1], scale) : [x0, x1];\n\t  };\n\t\n\t  scale.clamp = function(_) {\n\t    return arguments.length ? (clamp = !!_, scale) : clamp;\n\t  };\n\t\n\t  scale.interpolator = function(_) {\n\t    return arguments.length ? (interpolator = _, scale) : interpolator;\n\t  };\n\t\n\t  scale.copy = function() {\n\t    return sequential(interpolator).domain([x0, x1]).clamp(clamp);\n\t  };\n\t\n\t  return linearish(scale);\n\t}\n\t\n\texports.scaleBand = band;\n\texports.scalePoint = point;\n\texports.scaleIdentity = identity;\n\texports.scaleLinear = linear;\n\texports.scaleLog = log;\n\texports.scaleOrdinal = ordinal;\n\texports.scaleImplicit = implicit;\n\texports.scalePow = pow;\n\texports.scaleSqrt = sqrt;\n\texports.scaleQuantile = quantile$1;\n\texports.scaleQuantize = quantize;\n\texports.scaleThreshold = threshold;\n\texports.scaleTime = time;\n\texports.scaleUtc = utcTime;\n\texports.schemeCategory10 = category10;\n\texports.schemeCategory20b = category20b;\n\texports.schemeCategory20c = category20c;\n\texports.schemeCategory20 = category20;\n\texports.interpolateCubehelixDefault = cubehelix$1;\n\texports.interpolateRainbow = rainbow$1;\n\texports.interpolateWarm = warm;\n\texports.interpolateCool = cool;\n\texports.interpolateViridis = viridis;\n\texports.interpolateMagma = magma;\n\texports.interpolateInferno = inferno;\n\texports.interpolatePlasma = plasma;\n\texports.scaleSequential = sequential;\n\t\n\tObject.defineProperty(exports, '__esModule', { value: true });\n\t\n\t})));\n\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t// https://d3js.org/d3-collection/ Version 1.0.4. Copyright 2017 Mike Bostock.\n\t(function (global, factory) {\n\t\t true ? factory(exports) :\n\t\ttypeof define === 'function' && define.amd ? define(['exports'], factory) :\n\t\t(factory((global.d3 = global.d3 || {})));\n\t}(this, (function (exports) { 'use strict';\n\t\n\tvar prefix = \"$\";\n\t\n\tfunction Map() {}\n\t\n\tMap.prototype = map.prototype = {\n\t  constructor: Map,\n\t  has: function(key) {\n\t    return (prefix + key) in this;\n\t  },\n\t  get: function(key) {\n\t    return this[prefix + key];\n\t  },\n\t  set: function(key, value) {\n\t    this[prefix + key] = value;\n\t    return this;\n\t  },\n\t  remove: function(key) {\n\t    var property = prefix + key;\n\t    return property in this && delete this[property];\n\t  },\n\t  clear: function() {\n\t    for (var property in this) if (property[0] === prefix) delete this[property];\n\t  },\n\t  keys: function() {\n\t    var keys = [];\n\t    for (var property in this) if (property[0] === prefix) keys.push(property.slice(1));\n\t    return keys;\n\t  },\n\t  values: function() {\n\t    var values = [];\n\t    for (var property in this) if (property[0] === prefix) values.push(this[property]);\n\t    return values;\n\t  },\n\t  entries: function() {\n\t    var entries = [];\n\t    for (var property in this) if (property[0] === prefix) entries.push({key: property.slice(1), value: this[property]});\n\t    return entries;\n\t  },\n\t  size: function() {\n\t    var size = 0;\n\t    for (var property in this) if (property[0] === prefix) ++size;\n\t    return size;\n\t  },\n\t  empty: function() {\n\t    for (var property in this) if (property[0] === prefix) return false;\n\t    return true;\n\t  },\n\t  each: function(f) {\n\t    for (var property in this) if (property[0] === prefix) f(this[property], property.slice(1), this);\n\t  }\n\t};\n\t\n\tfunction map(object, f) {\n\t  var map = new Map;\n\t\n\t  // Copy constructor.\n\t  if (object instanceof Map) object.each(function(value, key) { map.set(key, value); });\n\t\n\t  // Index array by numeric index or specified key function.\n\t  else if (Array.isArray(object)) {\n\t    var i = -1,\n\t        n = object.length,\n\t        o;\n\t\n\t    if (f == null) while (++i < n) map.set(i, object[i]);\n\t    else while (++i < n) map.set(f(o = object[i], i, object), o);\n\t  }\n\t\n\t  // Convert object to map.\n\t  else if (object) for (var key in object) map.set(key, object[key]);\n\t\n\t  return map;\n\t}\n\t\n\tvar nest = function() {\n\t  var keys = [],\n\t      sortKeys = [],\n\t      sortValues,\n\t      rollup,\n\t      nest;\n\t\n\t  function apply(array, depth, createResult, setResult) {\n\t    if (depth >= keys.length) {\n\t      if (sortValues != null) array.sort(sortValues);\n\t      return rollup != null ? rollup(array) : array;\n\t    }\n\t\n\t    var i = -1,\n\t        n = array.length,\n\t        key = keys[depth++],\n\t        keyValue,\n\t        value,\n\t        valuesByKey = map(),\n\t        values,\n\t        result = createResult();\n\t\n\t    while (++i < n) {\n\t      if (values = valuesByKey.get(keyValue = key(value = array[i]) + \"\")) {\n\t        values.push(value);\n\t      } else {\n\t        valuesByKey.set(keyValue, [value]);\n\t      }\n\t    }\n\t\n\t    valuesByKey.each(function(values, key) {\n\t      setResult(result, key, apply(values, depth, createResult, setResult));\n\t    });\n\t\n\t    return result;\n\t  }\n\t\n\t  function entries(map$$1, depth) {\n\t    if (++depth > keys.length) return map$$1;\n\t    var array, sortKey = sortKeys[depth - 1];\n\t    if (rollup != null && depth >= keys.length) array = map$$1.entries();\n\t    else array = [], map$$1.each(function(v, k) { array.push({key: k, values: entries(v, depth)}); });\n\t    return sortKey != null ? array.sort(function(a, b) { return sortKey(a.key, b.key); }) : array;\n\t  }\n\t\n\t  return nest = {\n\t    object: function(array) { return apply(array, 0, createObject, setObject); },\n\t    map: function(array) { return apply(array, 0, createMap, setMap); },\n\t    entries: function(array) { return entries(apply(array, 0, createMap, setMap), 0); },\n\t    key: function(d) { keys.push(d); return nest; },\n\t    sortKeys: function(order) { sortKeys[keys.length - 1] = order; return nest; },\n\t    sortValues: function(order) { sortValues = order; return nest; },\n\t    rollup: function(f) { rollup = f; return nest; }\n\t  };\n\t};\n\t\n\tfunction createObject() {\n\t  return {};\n\t}\n\t\n\tfunction setObject(object, key, value) {\n\t  object[key] = value;\n\t}\n\t\n\tfunction createMap() {\n\t  return map();\n\t}\n\t\n\tfunction setMap(map$$1, key, value) {\n\t  map$$1.set(key, value);\n\t}\n\t\n\tfunction Set() {}\n\t\n\tvar proto = map.prototype;\n\t\n\tSet.prototype = set.prototype = {\n\t  constructor: Set,\n\t  has: proto.has,\n\t  add: function(value) {\n\t    value += \"\";\n\t    this[prefix + value] = value;\n\t    return this;\n\t  },\n\t  remove: proto.remove,\n\t  clear: proto.clear,\n\t  values: proto.keys,\n\t  size: proto.size,\n\t  empty: proto.empty,\n\t  each: proto.each\n\t};\n\t\n\tfunction set(object, f) {\n\t  var set = new Set;\n\t\n\t  // Copy constructor.\n\t  if (object instanceof Set) object.each(function(value) { set.add(value); });\n\t\n\t  // Otherwise, assume it’s an array.\n\t  else if (object) {\n\t    var i = -1, n = object.length;\n\t    if (f == null) while (++i < n) set.add(object[i]);\n\t    else while (++i < n) set.add(f(object[i], i, object));\n\t  }\n\t\n\t  return set;\n\t}\n\t\n\tvar keys = function(map) {\n\t  var keys = [];\n\t  for (var key in map) keys.push(key);\n\t  return keys;\n\t};\n\t\n\tvar values = function(map) {\n\t  var values = [];\n\t  for (var key in map) values.push(map[key]);\n\t  return values;\n\t};\n\t\n\tvar entries = function(map) {\n\t  var entries = [];\n\t  for (var key in map) entries.push({key: key, value: map[key]});\n\t  return entries;\n\t};\n\t\n\texports.nest = nest;\n\texports.set = set;\n\texports.map = map;\n\texports.keys = keys;\n\texports.values = values;\n\texports.entries = entries;\n\t\n\tObject.defineProperty(exports, '__esModule', { value: true });\n\t\n\t})));\n\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t// https://d3js.org/d3-interpolate/ Version 1.1.5. Copyright 2017 Mike Bostock.\n\t(function (global, factory) {\n\t\t true ? factory(exports, __webpack_require__(4)) :\n\t\ttypeof define === 'function' && define.amd ? define(['exports', 'd3-color'], factory) :\n\t\t(factory((global.d3 = global.d3 || {}),global.d3));\n\t}(this, (function (exports,d3Color) { 'use strict';\n\t\n\tfunction basis(t1, v0, v1, v2, v3) {\n\t  var t2 = t1 * t1, t3 = t2 * t1;\n\t  return ((1 - 3 * t1 + 3 * t2 - t3) * v0\n\t      + (4 - 6 * t2 + 3 * t3) * v1\n\t      + (1 + 3 * t1 + 3 * t2 - 3 * t3) * v2\n\t      + t3 * v3) / 6;\n\t}\n\t\n\tvar basis$1 = function(values) {\n\t  var n = values.length - 1;\n\t  return function(t) {\n\t    var i = t <= 0 ? (t = 0) : t >= 1 ? (t = 1, n - 1) : Math.floor(t * n),\n\t        v1 = values[i],\n\t        v2 = values[i + 1],\n\t        v0 = i > 0 ? values[i - 1] : 2 * v1 - v2,\n\t        v3 = i < n - 1 ? values[i + 2] : 2 * v2 - v1;\n\t    return basis((t - i / n) * n, v0, v1, v2, v3);\n\t  };\n\t};\n\t\n\tvar basisClosed = function(values) {\n\t  var n = values.length;\n\t  return function(t) {\n\t    var i = Math.floor(((t %= 1) < 0 ? ++t : t) * n),\n\t        v0 = values[(i + n - 1) % n],\n\t        v1 = values[i % n],\n\t        v2 = values[(i + 1) % n],\n\t        v3 = values[(i + 2) % n];\n\t    return basis((t - i / n) * n, v0, v1, v2, v3);\n\t  };\n\t};\n\t\n\tvar constant = function(x) {\n\t  return function() {\n\t    return x;\n\t  };\n\t};\n\t\n\tfunction linear(a, d) {\n\t  return function(t) {\n\t    return a + t * d;\n\t  };\n\t}\n\t\n\tfunction exponential(a, b, y) {\n\t  return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function(t) {\n\t    return Math.pow(a + t * b, y);\n\t  };\n\t}\n\t\n\tfunction hue(a, b) {\n\t  var d = b - a;\n\t  return d ? linear(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : constant(isNaN(a) ? b : a);\n\t}\n\t\n\tfunction gamma(y) {\n\t  return (y = +y) === 1 ? nogamma : function(a, b) {\n\t    return b - a ? exponential(a, b, y) : constant(isNaN(a) ? b : a);\n\t  };\n\t}\n\t\n\tfunction nogamma(a, b) {\n\t  var d = b - a;\n\t  return d ? linear(a, d) : constant(isNaN(a) ? b : a);\n\t}\n\t\n\tvar rgb$1 = ((function rgbGamma(y) {\n\t  var color$$1 = gamma(y);\n\t\n\t  function rgb$$1(start, end) {\n\t    var r = color$$1((start = d3Color.rgb(start)).r, (end = d3Color.rgb(end)).r),\n\t        g = color$$1(start.g, end.g),\n\t        b = color$$1(start.b, end.b),\n\t        opacity = nogamma(start.opacity, end.opacity);\n\t    return function(t) {\n\t      start.r = r(t);\n\t      start.g = g(t);\n\t      start.b = b(t);\n\t      start.opacity = opacity(t);\n\t      return start + \"\";\n\t    };\n\t  }\n\t\n\t  rgb$$1.gamma = rgbGamma;\n\t\n\t  return rgb$$1;\n\t}))(1);\n\t\n\tfunction rgbSpline(spline) {\n\t  return function(colors) {\n\t    var n = colors.length,\n\t        r = new Array(n),\n\t        g = new Array(n),\n\t        b = new Array(n),\n\t        i, color$$1;\n\t    for (i = 0; i < n; ++i) {\n\t      color$$1 = d3Color.rgb(colors[i]);\n\t      r[i] = color$$1.r || 0;\n\t      g[i] = color$$1.g || 0;\n\t      b[i] = color$$1.b || 0;\n\t    }\n\t    r = spline(r);\n\t    g = spline(g);\n\t    b = spline(b);\n\t    color$$1.opacity = 1;\n\t    return function(t) {\n\t      color$$1.r = r(t);\n\t      color$$1.g = g(t);\n\t      color$$1.b = b(t);\n\t      return color$$1 + \"\";\n\t    };\n\t  };\n\t}\n\t\n\tvar rgbBasis = rgbSpline(basis$1);\n\tvar rgbBasisClosed = rgbSpline(basisClosed);\n\t\n\tvar array = function(a, b) {\n\t  var nb = b ? b.length : 0,\n\t      na = a ? Math.min(nb, a.length) : 0,\n\t      x = new Array(nb),\n\t      c = new Array(nb),\n\t      i;\n\t\n\t  for (i = 0; i < na; ++i) x[i] = value(a[i], b[i]);\n\t  for (; i < nb; ++i) c[i] = b[i];\n\t\n\t  return function(t) {\n\t    for (i = 0; i < na; ++i) c[i] = x[i](t);\n\t    return c;\n\t  };\n\t};\n\t\n\tvar date = function(a, b) {\n\t  var d = new Date;\n\t  return a = +a, b -= a, function(t) {\n\t    return d.setTime(a + b * t), d;\n\t  };\n\t};\n\t\n\tvar number = function(a, b) {\n\t  return a = +a, b -= a, function(t) {\n\t    return a + b * t;\n\t  };\n\t};\n\t\n\tvar object = function(a, b) {\n\t  var i = {},\n\t      c = {},\n\t      k;\n\t\n\t  if (a === null || typeof a !== \"object\") a = {};\n\t  if (b === null || typeof b !== \"object\") b = {};\n\t\n\t  for (k in b) {\n\t    if (k in a) {\n\t      i[k] = value(a[k], b[k]);\n\t    } else {\n\t      c[k] = b[k];\n\t    }\n\t  }\n\t\n\t  return function(t) {\n\t    for (k in i) c[k] = i[k](t);\n\t    return c;\n\t  };\n\t};\n\t\n\tvar reA = /[-+]?(?:\\d+\\.?\\d*|\\.?\\d+)(?:[eE][-+]?\\d+)?/g;\n\tvar reB = new RegExp(reA.source, \"g\");\n\t\n\tfunction zero(b) {\n\t  return function() {\n\t    return b;\n\t  };\n\t}\n\t\n\tfunction one(b) {\n\t  return function(t) {\n\t    return b(t) + \"\";\n\t  };\n\t}\n\t\n\tvar string = function(a, b) {\n\t  var bi = reA.lastIndex = reB.lastIndex = 0, // scan index for next number in b\n\t      am, // current match in a\n\t      bm, // current match in b\n\t      bs, // string preceding current number in b, if any\n\t      i = -1, // index in s\n\t      s = [], // string constants and placeholders\n\t      q = []; // number interpolators\n\t\n\t  // Coerce inputs to strings.\n\t  a = a + \"\", b = b + \"\";\n\t\n\t  // Interpolate pairs of numbers in a & b.\n\t  while ((am = reA.exec(a))\n\t      && (bm = reB.exec(b))) {\n\t    if ((bs = bm.index) > bi) { // a string precedes the next number in b\n\t      bs = b.slice(bi, bs);\n\t      if (s[i]) s[i] += bs; // coalesce with previous string\n\t      else s[++i] = bs;\n\t    }\n\t    if ((am = am[0]) === (bm = bm[0])) { // numbers in a & b match\n\t      if (s[i]) s[i] += bm; // coalesce with previous string\n\t      else s[++i] = bm;\n\t    } else { // interpolate non-matching numbers\n\t      s[++i] = null;\n\t      q.push({i: i, x: number(am, bm)});\n\t    }\n\t    bi = reB.lastIndex;\n\t  }\n\t\n\t  // Add remains of b.\n\t  if (bi < b.length) {\n\t    bs = b.slice(bi);\n\t    if (s[i]) s[i] += bs; // coalesce with previous string\n\t    else s[++i] = bs;\n\t  }\n\t\n\t  // Special optimization for only a single match.\n\t  // Otherwise, interpolate each of the numbers and rejoin the string.\n\t  return s.length < 2 ? (q[0]\n\t      ? one(q[0].x)\n\t      : zero(b))\n\t      : (b = q.length, function(t) {\n\t          for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t);\n\t          return s.join(\"\");\n\t        });\n\t};\n\t\n\tvar value = function(a, b) {\n\t  var t = typeof b, c;\n\t  return b == null || t === \"boolean\" ? constant(b)\n\t      : (t === \"number\" ? number\n\t      : t === \"string\" ? ((c = d3Color.color(b)) ? (b = c, rgb$1) : string)\n\t      : b instanceof d3Color.color ? rgb$1\n\t      : b instanceof Date ? date\n\t      : Array.isArray(b) ? array\n\t      : typeof b.valueOf !== \"function\" && typeof b.toString !== \"function\" || isNaN(b) ? object\n\t      : number)(a, b);\n\t};\n\t\n\tvar round = function(a, b) {\n\t  return a = +a, b -= a, function(t) {\n\t    return Math.round(a + b * t);\n\t  };\n\t};\n\t\n\tvar degrees = 180 / Math.PI;\n\t\n\tvar identity = {\n\t  translateX: 0,\n\t  translateY: 0,\n\t  rotate: 0,\n\t  skewX: 0,\n\t  scaleX: 1,\n\t  scaleY: 1\n\t};\n\t\n\tvar decompose = function(a, b, c, d, e, f) {\n\t  var scaleX, scaleY, skewX;\n\t  if (scaleX = Math.sqrt(a * a + b * b)) a /= scaleX, b /= scaleX;\n\t  if (skewX = a * c + b * d) c -= a * skewX, d -= b * skewX;\n\t  if (scaleY = Math.sqrt(c * c + d * d)) c /= scaleY, d /= scaleY, skewX /= scaleY;\n\t  if (a * d < b * c) a = -a, b = -b, skewX = -skewX, scaleX = -scaleX;\n\t  return {\n\t    translateX: e,\n\t    translateY: f,\n\t    rotate: Math.atan2(b, a) * degrees,\n\t    skewX: Math.atan(skewX) * degrees,\n\t    scaleX: scaleX,\n\t    scaleY: scaleY\n\t  };\n\t};\n\t\n\tvar cssNode;\n\tvar cssRoot;\n\tvar cssView;\n\tvar svgNode;\n\t\n\tfunction parseCss(value) {\n\t  if (value === \"none\") return identity;\n\t  if (!cssNode) cssNode = document.createElement(\"DIV\"), cssRoot = document.documentElement, cssView = document.defaultView;\n\t  cssNode.style.transform = value;\n\t  value = cssView.getComputedStyle(cssRoot.appendChild(cssNode), null).getPropertyValue(\"transform\");\n\t  cssRoot.removeChild(cssNode);\n\t  value = value.slice(7, -1).split(\",\");\n\t  return decompose(+value[0], +value[1], +value[2], +value[3], +value[4], +value[5]);\n\t}\n\t\n\tfunction parseSvg(value) {\n\t  if (value == null) return identity;\n\t  if (!svgNode) svgNode = document.createElementNS(\"http://www.w3.org/2000/svg\", \"g\");\n\t  svgNode.setAttribute(\"transform\", value);\n\t  if (!(value = svgNode.transform.baseVal.consolidate())) return identity;\n\t  value = value.matrix;\n\t  return decompose(value.a, value.b, value.c, value.d, value.e, value.f);\n\t}\n\t\n\tfunction interpolateTransform(parse, pxComma, pxParen, degParen) {\n\t\n\t  function pop(s) {\n\t    return s.length ? s.pop() + \" \" : \"\";\n\t  }\n\t\n\t  function translate(xa, ya, xb, yb, s, q) {\n\t    if (xa !== xb || ya !== yb) {\n\t      var i = s.push(\"translate(\", null, pxComma, null, pxParen);\n\t      q.push({i: i - 4, x: number(xa, xb)}, {i: i - 2, x: number(ya, yb)});\n\t    } else if (xb || yb) {\n\t      s.push(\"translate(\" + xb + pxComma + yb + pxParen);\n\t    }\n\t  }\n\t\n\t  function rotate(a, b, s, q) {\n\t    if (a !== b) {\n\t      if (a - b > 180) b += 360; else if (b - a > 180) a += 360; // shortest path\n\t      q.push({i: s.push(pop(s) + \"rotate(\", null, degParen) - 2, x: number(a, b)});\n\t    } else if (b) {\n\t      s.push(pop(s) + \"rotate(\" + b + degParen);\n\t    }\n\t  }\n\t\n\t  function skewX(a, b, s, q) {\n\t    if (a !== b) {\n\t      q.push({i: s.push(pop(s) + \"skewX(\", null, degParen) - 2, x: number(a, b)});\n\t    } else if (b) {\n\t      s.push(pop(s) + \"skewX(\" + b + degParen);\n\t    }\n\t  }\n\t\n\t  function scale(xa, ya, xb, yb, s, q) {\n\t    if (xa !== xb || ya !== yb) {\n\t      var i = s.push(pop(s) + \"scale(\", null, \",\", null, \")\");\n\t      q.push({i: i - 4, x: number(xa, xb)}, {i: i - 2, x: number(ya, yb)});\n\t    } else if (xb !== 1 || yb !== 1) {\n\t      s.push(pop(s) + \"scale(\" + xb + \",\" + yb + \")\");\n\t    }\n\t  }\n\t\n\t  return function(a, b) {\n\t    var s = [], // string constants and placeholders\n\t        q = []; // number interpolators\n\t    a = parse(a), b = parse(b);\n\t    translate(a.translateX, a.translateY, b.translateX, b.translateY, s, q);\n\t    rotate(a.rotate, b.rotate, s, q);\n\t    skewX(a.skewX, b.skewX, s, q);\n\t    scale(a.scaleX, a.scaleY, b.scaleX, b.scaleY, s, q);\n\t    a = b = null; // gc\n\t    return function(t) {\n\t      var i = -1, n = q.length, o;\n\t      while (++i < n) s[(o = q[i]).i] = o.x(t);\n\t      return s.join(\"\");\n\t    };\n\t  };\n\t}\n\t\n\tvar interpolateTransformCss = interpolateTransform(parseCss, \"px, \", \"px)\", \"deg)\");\n\tvar interpolateTransformSvg = interpolateTransform(parseSvg, \", \", \")\", \")\");\n\t\n\tvar rho = Math.SQRT2;\n\tvar rho2 = 2;\n\tvar rho4 = 4;\n\tvar epsilon2 = 1e-12;\n\t\n\tfunction cosh(x) {\n\t  return ((x = Math.exp(x)) + 1 / x) / 2;\n\t}\n\t\n\tfunction sinh(x) {\n\t  return ((x = Math.exp(x)) - 1 / x) / 2;\n\t}\n\t\n\tfunction tanh(x) {\n\t  return ((x = Math.exp(2 * x)) - 1) / (x + 1);\n\t}\n\t\n\t// p0 = [ux0, uy0, w0]\n\t// p1 = [ux1, uy1, w1]\n\tvar zoom = function(p0, p1) {\n\t  var ux0 = p0[0], uy0 = p0[1], w0 = p0[2],\n\t      ux1 = p1[0], uy1 = p1[1], w1 = p1[2],\n\t      dx = ux1 - ux0,\n\t      dy = uy1 - uy0,\n\t      d2 = dx * dx + dy * dy,\n\t      i,\n\t      S;\n\t\n\t  // Special case for u0 ≅ u1.\n\t  if (d2 < epsilon2) {\n\t    S = Math.log(w1 / w0) / rho;\n\t    i = function(t) {\n\t      return [\n\t        ux0 + t * dx,\n\t        uy0 + t * dy,\n\t        w0 * Math.exp(rho * t * S)\n\t      ];\n\t    };\n\t  }\n\t\n\t  // General case.\n\t  else {\n\t    var d1 = Math.sqrt(d2),\n\t        b0 = (w1 * w1 - w0 * w0 + rho4 * d2) / (2 * w0 * rho2 * d1),\n\t        b1 = (w1 * w1 - w0 * w0 - rho4 * d2) / (2 * w1 * rho2 * d1),\n\t        r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0),\n\t        r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1);\n\t    S = (r1 - r0) / rho;\n\t    i = function(t) {\n\t      var s = t * S,\n\t          coshr0 = cosh(r0),\n\t          u = w0 / (rho2 * d1) * (coshr0 * tanh(rho * s + r0) - sinh(r0));\n\t      return [\n\t        ux0 + u * dx,\n\t        uy0 + u * dy,\n\t        w0 * coshr0 / cosh(rho * s + r0)\n\t      ];\n\t    };\n\t  }\n\t\n\t  i.duration = S * 1000;\n\t\n\t  return i;\n\t};\n\t\n\tfunction hsl$1(hue$$1) {\n\t  return function(start, end) {\n\t    var h = hue$$1((start = d3Color.hsl(start)).h, (end = d3Color.hsl(end)).h),\n\t        s = nogamma(start.s, end.s),\n\t        l = nogamma(start.l, end.l),\n\t        opacity = nogamma(start.opacity, end.opacity);\n\t    return function(t) {\n\t      start.h = h(t);\n\t      start.s = s(t);\n\t      start.l = l(t);\n\t      start.opacity = opacity(t);\n\t      return start + \"\";\n\t    };\n\t  }\n\t}\n\t\n\tvar hsl$2 = hsl$1(hue);\n\tvar hslLong = hsl$1(nogamma);\n\t\n\tfunction lab$1(start, end) {\n\t  var l = nogamma((start = d3Color.lab(start)).l, (end = d3Color.lab(end)).l),\n\t      a = nogamma(start.a, end.a),\n\t      b = nogamma(start.b, end.b),\n\t      opacity = nogamma(start.opacity, end.opacity);\n\t  return function(t) {\n\t    start.l = l(t);\n\t    start.a = a(t);\n\t    start.b = b(t);\n\t    start.opacity = opacity(t);\n\t    return start + \"\";\n\t  };\n\t}\n\t\n\tfunction hcl$1(hue$$1) {\n\t  return function(start, end) {\n\t    var h = hue$$1((start = d3Color.hcl(start)).h, (end = d3Color.hcl(end)).h),\n\t        c = nogamma(start.c, end.c),\n\t        l = nogamma(start.l, end.l),\n\t        opacity = nogamma(start.opacity, end.opacity);\n\t    return function(t) {\n\t      start.h = h(t);\n\t      start.c = c(t);\n\t      start.l = l(t);\n\t      start.opacity = opacity(t);\n\t      return start + \"\";\n\t    };\n\t  }\n\t}\n\t\n\tvar hcl$2 = hcl$1(hue);\n\tvar hclLong = hcl$1(nogamma);\n\t\n\tfunction cubehelix$1(hue$$1) {\n\t  return (function cubehelixGamma(y) {\n\t    y = +y;\n\t\n\t    function cubehelix$$1(start, end) {\n\t      var h = hue$$1((start = d3Color.cubehelix(start)).h, (end = d3Color.cubehelix(end)).h),\n\t          s = nogamma(start.s, end.s),\n\t          l = nogamma(start.l, end.l),\n\t          opacity = nogamma(start.opacity, end.opacity);\n\t      return function(t) {\n\t        start.h = h(t);\n\t        start.s = s(t);\n\t        start.l = l(Math.pow(t, y));\n\t        start.opacity = opacity(t);\n\t        return start + \"\";\n\t      };\n\t    }\n\t\n\t    cubehelix$$1.gamma = cubehelixGamma;\n\t\n\t    return cubehelix$$1;\n\t  })(1);\n\t}\n\t\n\tvar cubehelix$2 = cubehelix$1(hue);\n\tvar cubehelixLong = cubehelix$1(nogamma);\n\t\n\tvar quantize = function(interpolator, n) {\n\t  var samples = new Array(n);\n\t  for (var i = 0; i < n; ++i) samples[i] = interpolator(i / (n - 1));\n\t  return samples;\n\t};\n\t\n\texports.interpolate = value;\n\texports.interpolateArray = array;\n\texports.interpolateBasis = basis$1;\n\texports.interpolateBasisClosed = basisClosed;\n\texports.interpolateDate = date;\n\texports.interpolateNumber = number;\n\texports.interpolateObject = object;\n\texports.interpolateRound = round;\n\texports.interpolateString = string;\n\texports.interpolateTransformCss = interpolateTransformCss;\n\texports.interpolateTransformSvg = interpolateTransformSvg;\n\texports.interpolateZoom = zoom;\n\texports.interpolateRgb = rgb$1;\n\texports.interpolateRgbBasis = rgbBasis;\n\texports.interpolateRgbBasisClosed = rgbBasisClosed;\n\texports.interpolateHsl = hsl$2;\n\texports.interpolateHslLong = hslLong;\n\texports.interpolateLab = lab$1;\n\texports.interpolateHcl = hcl$2;\n\texports.interpolateHclLong = hclLong;\n\texports.interpolateCubehelix = cubehelix$2;\n\texports.interpolateCubehelixLong = cubehelixLong;\n\texports.quantize = quantize;\n\t\n\tObject.defineProperty(exports, '__esModule', { value: true });\n\t\n\t})));\n\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t// https://d3js.org/d3-time/ Version 1.0.7. Copyright 2017 Mike Bostock.\n\t(function (global, factory) {\n\t\t true ? factory(exports) :\n\t\ttypeof define === 'function' && define.amd ? define(['exports'], factory) :\n\t\t(factory((global.d3 = global.d3 || {})));\n\t}(this, (function (exports) { 'use strict';\n\t\n\tvar t0 = new Date;\n\tvar t1 = new Date;\n\t\n\tfunction newInterval(floori, offseti, count, field) {\n\t\n\t  function interval(date) {\n\t    return floori(date = new Date(+date)), date;\n\t  }\n\t\n\t  interval.floor = interval;\n\t\n\t  interval.ceil = function(date) {\n\t    return floori(date = new Date(date - 1)), offseti(date, 1), floori(date), date;\n\t  };\n\t\n\t  interval.round = function(date) {\n\t    var d0 = interval(date),\n\t        d1 = interval.ceil(date);\n\t    return date - d0 < d1 - date ? d0 : d1;\n\t  };\n\t\n\t  interval.offset = function(date, step) {\n\t    return offseti(date = new Date(+date), step == null ? 1 : Math.floor(step)), date;\n\t  };\n\t\n\t  interval.range = function(start, stop, step) {\n\t    var range = [];\n\t    start = interval.ceil(start);\n\t    step = step == null ? 1 : Math.floor(step);\n\t    if (!(start < stop) || !(step > 0)) return range; // also handles Invalid Date\n\t    do range.push(new Date(+start)); while (offseti(start, step), floori(start), start < stop)\n\t    return range;\n\t  };\n\t\n\t  interval.filter = function(test) {\n\t    return newInterval(function(date) {\n\t      if (date >= date) while (floori(date), !test(date)) date.setTime(date - 1);\n\t    }, function(date, step) {\n\t      if (date >= date) {\n\t        if (step < 0) while (++step <= 0) {\n\t          while (offseti(date, -1), !test(date)) {} // eslint-disable-line no-empty\n\t        } else while (--step >= 0) {\n\t          while (offseti(date, +1), !test(date)) {} // eslint-disable-line no-empty\n\t        }\n\t      }\n\t    });\n\t  };\n\t\n\t  if (count) {\n\t    interval.count = function(start, end) {\n\t      t0.setTime(+start), t1.setTime(+end);\n\t      floori(t0), floori(t1);\n\t      return Math.floor(count(t0, t1));\n\t    };\n\t\n\t    interval.every = function(step) {\n\t      step = Math.floor(step);\n\t      return !isFinite(step) || !(step > 0) ? null\n\t          : !(step > 1) ? interval\n\t          : interval.filter(field\n\t              ? function(d) { return field(d) % step === 0; }\n\t              : function(d) { return interval.count(0, d) % step === 0; });\n\t    };\n\t  }\n\t\n\t  return interval;\n\t}\n\t\n\tvar millisecond = newInterval(function() {\n\t  // noop\n\t}, function(date, step) {\n\t  date.setTime(+date + step);\n\t}, function(start, end) {\n\t  return end - start;\n\t});\n\t\n\t// An optimized implementation for this simple case.\n\tmillisecond.every = function(k) {\n\t  k = Math.floor(k);\n\t  if (!isFinite(k) || !(k > 0)) return null;\n\t  if (!(k > 1)) return millisecond;\n\t  return newInterval(function(date) {\n\t    date.setTime(Math.floor(date / k) * k);\n\t  }, function(date, step) {\n\t    date.setTime(+date + step * k);\n\t  }, function(start, end) {\n\t    return (end - start) / k;\n\t  });\n\t};\n\t\n\tvar milliseconds = millisecond.range;\n\t\n\tvar durationSecond = 1e3;\n\tvar durationMinute = 6e4;\n\tvar durationHour = 36e5;\n\tvar durationDay = 864e5;\n\tvar durationWeek = 6048e5;\n\t\n\tvar second = newInterval(function(date) {\n\t  date.setTime(Math.floor(date / durationSecond) * durationSecond);\n\t}, function(date, step) {\n\t  date.setTime(+date + step * durationSecond);\n\t}, function(start, end) {\n\t  return (end - start) / durationSecond;\n\t}, function(date) {\n\t  return date.getUTCSeconds();\n\t});\n\t\n\tvar seconds = second.range;\n\t\n\tvar minute = newInterval(function(date) {\n\t  date.setTime(Math.floor(date / durationMinute) * durationMinute);\n\t}, function(date, step) {\n\t  date.setTime(+date + step * durationMinute);\n\t}, function(start, end) {\n\t  return (end - start) / durationMinute;\n\t}, function(date) {\n\t  return date.getMinutes();\n\t});\n\t\n\tvar minutes = minute.range;\n\t\n\tvar hour = newInterval(function(date) {\n\t  var offset = date.getTimezoneOffset() * durationMinute % durationHour;\n\t  if (offset < 0) offset += durationHour;\n\t  date.setTime(Math.floor((+date - offset) / durationHour) * durationHour + offset);\n\t}, function(date, step) {\n\t  date.setTime(+date + step * durationHour);\n\t}, function(start, end) {\n\t  return (end - start) / durationHour;\n\t}, function(date) {\n\t  return date.getHours();\n\t});\n\t\n\tvar hours = hour.range;\n\t\n\tvar day = newInterval(function(date) {\n\t  date.setHours(0, 0, 0, 0);\n\t}, function(date, step) {\n\t  date.setDate(date.getDate() + step);\n\t}, function(start, end) {\n\t  return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationDay;\n\t}, function(date) {\n\t  return date.getDate() - 1;\n\t});\n\t\n\tvar days = day.range;\n\t\n\tfunction weekday(i) {\n\t  return newInterval(function(date) {\n\t    date.setDate(date.getDate() - (date.getDay() + 7 - i) % 7);\n\t    date.setHours(0, 0, 0, 0);\n\t  }, function(date, step) {\n\t    date.setDate(date.getDate() + step * 7);\n\t  }, function(start, end) {\n\t    return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationWeek;\n\t  });\n\t}\n\t\n\tvar sunday = weekday(0);\n\tvar monday = weekday(1);\n\tvar tuesday = weekday(2);\n\tvar wednesday = weekday(3);\n\tvar thursday = weekday(4);\n\tvar friday = weekday(5);\n\tvar saturday = weekday(6);\n\t\n\tvar sundays = sunday.range;\n\tvar mondays = monday.range;\n\tvar tuesdays = tuesday.range;\n\tvar wednesdays = wednesday.range;\n\tvar thursdays = thursday.range;\n\tvar fridays = friday.range;\n\tvar saturdays = saturday.range;\n\t\n\tvar month = newInterval(function(date) {\n\t  date.setDate(1);\n\t  date.setHours(0, 0, 0, 0);\n\t}, function(date, step) {\n\t  date.setMonth(date.getMonth() + step);\n\t}, function(start, end) {\n\t  return end.getMonth() - start.getMonth() + (end.getFullYear() - start.getFullYear()) * 12;\n\t}, function(date) {\n\t  return date.getMonth();\n\t});\n\t\n\tvar months = month.range;\n\t\n\tvar year = newInterval(function(date) {\n\t  date.setMonth(0, 1);\n\t  date.setHours(0, 0, 0, 0);\n\t}, function(date, step) {\n\t  date.setFullYear(date.getFullYear() + step);\n\t}, function(start, end) {\n\t  return end.getFullYear() - start.getFullYear();\n\t}, function(date) {\n\t  return date.getFullYear();\n\t});\n\t\n\t// An optimized implementation for this simple case.\n\tyear.every = function(k) {\n\t  return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : newInterval(function(date) {\n\t    date.setFullYear(Math.floor(date.getFullYear() / k) * k);\n\t    date.setMonth(0, 1);\n\t    date.setHours(0, 0, 0, 0);\n\t  }, function(date, step) {\n\t    date.setFullYear(date.getFullYear() + step * k);\n\t  });\n\t};\n\t\n\tvar years = year.range;\n\t\n\tvar utcMinute = newInterval(function(date) {\n\t  date.setUTCSeconds(0, 0);\n\t}, function(date, step) {\n\t  date.setTime(+date + step * durationMinute);\n\t}, function(start, end) {\n\t  return (end - start) / durationMinute;\n\t}, function(date) {\n\t  return date.getUTCMinutes();\n\t});\n\t\n\tvar utcMinutes = utcMinute.range;\n\t\n\tvar utcHour = newInterval(function(date) {\n\t  date.setUTCMinutes(0, 0, 0);\n\t}, function(date, step) {\n\t  date.setTime(+date + step * durationHour);\n\t}, function(start, end) {\n\t  return (end - start) / durationHour;\n\t}, function(date) {\n\t  return date.getUTCHours();\n\t});\n\t\n\tvar utcHours = utcHour.range;\n\t\n\tvar utcDay = newInterval(function(date) {\n\t  date.setUTCHours(0, 0, 0, 0);\n\t}, function(date, step) {\n\t  date.setUTCDate(date.getUTCDate() + step);\n\t}, function(start, end) {\n\t  return (end - start) / durationDay;\n\t}, function(date) {\n\t  return date.getUTCDate() - 1;\n\t});\n\t\n\tvar utcDays = utcDay.range;\n\t\n\tfunction utcWeekday(i) {\n\t  return newInterval(function(date) {\n\t    date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 7 - i) % 7);\n\t    date.setUTCHours(0, 0, 0, 0);\n\t  }, function(date, step) {\n\t    date.setUTCDate(date.getUTCDate() + step * 7);\n\t  }, function(start, end) {\n\t    return (end - start) / durationWeek;\n\t  });\n\t}\n\t\n\tvar utcSunday = utcWeekday(0);\n\tvar utcMonday = utcWeekday(1);\n\tvar utcTuesday = utcWeekday(2);\n\tvar utcWednesday = utcWeekday(3);\n\tvar utcThursday = utcWeekday(4);\n\tvar utcFriday = utcWeekday(5);\n\tvar utcSaturday = utcWeekday(6);\n\t\n\tvar utcSundays = utcSunday.range;\n\tvar utcMondays = utcMonday.range;\n\tvar utcTuesdays = utcTuesday.range;\n\tvar utcWednesdays = utcWednesday.range;\n\tvar utcThursdays = utcThursday.range;\n\tvar utcFridays = utcFriday.range;\n\tvar utcSaturdays = utcSaturday.range;\n\t\n\tvar utcMonth = newInterval(function(date) {\n\t  date.setUTCDate(1);\n\t  date.setUTCHours(0, 0, 0, 0);\n\t}, function(date, step) {\n\t  date.setUTCMonth(date.getUTCMonth() + step);\n\t}, function(start, end) {\n\t  return end.getUTCMonth() - start.getUTCMonth() + (end.getUTCFullYear() - start.getUTCFullYear()) * 12;\n\t}, function(date) {\n\t  return date.getUTCMonth();\n\t});\n\t\n\tvar utcMonths = utcMonth.range;\n\t\n\tvar utcYear = newInterval(function(date) {\n\t  date.setUTCMonth(0, 1);\n\t  date.setUTCHours(0, 0, 0, 0);\n\t}, function(date, step) {\n\t  date.setUTCFullYear(date.getUTCFullYear() + step);\n\t}, function(start, end) {\n\t  return end.getUTCFullYear() - start.getUTCFullYear();\n\t}, function(date) {\n\t  return date.getUTCFullYear();\n\t});\n\t\n\t// An optimized implementation for this simple case.\n\tutcYear.every = function(k) {\n\t  return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : newInterval(function(date) {\n\t    date.setUTCFullYear(Math.floor(date.getUTCFullYear() / k) * k);\n\t    date.setUTCMonth(0, 1);\n\t    date.setUTCHours(0, 0, 0, 0);\n\t  }, function(date, step) {\n\t    date.setUTCFullYear(date.getUTCFullYear() + step * k);\n\t  });\n\t};\n\t\n\tvar utcYears = utcYear.range;\n\t\n\texports.timeInterval = newInterval;\n\texports.timeMillisecond = millisecond;\n\texports.timeMilliseconds = milliseconds;\n\texports.utcMillisecond = millisecond;\n\texports.utcMilliseconds = milliseconds;\n\texports.timeSecond = second;\n\texports.timeSeconds = seconds;\n\texports.utcSecond = second;\n\texports.utcSeconds = seconds;\n\texports.timeMinute = minute;\n\texports.timeMinutes = minutes;\n\texports.timeHour = hour;\n\texports.timeHours = hours;\n\texports.timeDay = day;\n\texports.timeDays = days;\n\texports.timeWeek = sunday;\n\texports.timeWeeks = sundays;\n\texports.timeSunday = sunday;\n\texports.timeSundays = sundays;\n\texports.timeMonday = monday;\n\texports.timeMondays = mondays;\n\texports.timeTuesday = tuesday;\n\texports.timeTuesdays = tuesdays;\n\texports.timeWednesday = wednesday;\n\texports.timeWednesdays = wednesdays;\n\texports.timeThursday = thursday;\n\texports.timeThursdays = thursdays;\n\texports.timeFriday = friday;\n\texports.timeFridays = fridays;\n\texports.timeSaturday = saturday;\n\texports.timeSaturdays = saturdays;\n\texports.timeMonth = month;\n\texports.timeMonths = months;\n\texports.timeYear = year;\n\texports.timeYears = years;\n\texports.utcMinute = utcMinute;\n\texports.utcMinutes = utcMinutes;\n\texports.utcHour = utcHour;\n\texports.utcHours = utcHours;\n\texports.utcDay = utcDay;\n\texports.utcDays = utcDays;\n\texports.utcWeek = utcSunday;\n\texports.utcWeeks = utcSundays;\n\texports.utcSunday = utcSunday;\n\texports.utcSundays = utcSundays;\n\texports.utcMonday = utcMonday;\n\texports.utcMondays = utcMondays;\n\texports.utcTuesday = utcTuesday;\n\texports.utcTuesdays = utcTuesdays;\n\texports.utcWednesday = utcWednesday;\n\texports.utcWednesdays = utcWednesdays;\n\texports.utcThursday = utcThursday;\n\texports.utcThursdays = utcThursdays;\n\texports.utcFriday = utcFriday;\n\texports.utcFridays = utcFridays;\n\texports.utcSaturday = utcSaturday;\n\texports.utcSaturdays = utcSaturdays;\n\texports.utcMonth = utcMonth;\n\texports.utcMonths = utcMonths;\n\texports.utcYear = utcYear;\n\texports.utcYears = utcYears;\n\t\n\tObject.defineProperty(exports, '__esModule', { value: true });\n\t\n\t})));\n\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t// https://d3js.org/d3-time-format/ Version 2.0.5. Copyright 2017 Mike Bostock.\n\t(function (global, factory) {\n\t\t true ? factory(exports, __webpack_require__(10)) :\n\t\ttypeof define === 'function' && define.amd ? define(['exports', 'd3-time'], factory) :\n\t\t(factory((global.d3 = global.d3 || {}),global.d3));\n\t}(this, (function (exports,d3Time) { 'use strict';\n\t\n\tfunction localDate(d) {\n\t  if (0 <= d.y && d.y < 100) {\n\t    var date = new Date(-1, d.m, d.d, d.H, d.M, d.S, d.L);\n\t    date.setFullYear(d.y);\n\t    return date;\n\t  }\n\t  return new Date(d.y, d.m, d.d, d.H, d.M, d.S, d.L);\n\t}\n\t\n\tfunction utcDate(d) {\n\t  if (0 <= d.y && d.y < 100) {\n\t    var date = new Date(Date.UTC(-1, d.m, d.d, d.H, d.M, d.S, d.L));\n\t    date.setUTCFullYear(d.y);\n\t    return date;\n\t  }\n\t  return new Date(Date.UTC(d.y, d.m, d.d, d.H, d.M, d.S, d.L));\n\t}\n\t\n\tfunction newYear(y) {\n\t  return {y: y, m: 0, d: 1, H: 0, M: 0, S: 0, L: 0};\n\t}\n\t\n\tfunction formatLocale(locale) {\n\t  var locale_dateTime = locale.dateTime,\n\t      locale_date = locale.date,\n\t      locale_time = locale.time,\n\t      locale_periods = locale.periods,\n\t      locale_weekdays = locale.days,\n\t      locale_shortWeekdays = locale.shortDays,\n\t      locale_months = locale.months,\n\t      locale_shortMonths = locale.shortMonths;\n\t\n\t  var periodRe = formatRe(locale_periods),\n\t      periodLookup = formatLookup(locale_periods),\n\t      weekdayRe = formatRe(locale_weekdays),\n\t      weekdayLookup = formatLookup(locale_weekdays),\n\t      shortWeekdayRe = formatRe(locale_shortWeekdays),\n\t      shortWeekdayLookup = formatLookup(locale_shortWeekdays),\n\t      monthRe = formatRe(locale_months),\n\t      monthLookup = formatLookup(locale_months),\n\t      shortMonthRe = formatRe(locale_shortMonths),\n\t      shortMonthLookup = formatLookup(locale_shortMonths);\n\t\n\t  var formats = {\n\t    \"a\": formatShortWeekday,\n\t    \"A\": formatWeekday,\n\t    \"b\": formatShortMonth,\n\t    \"B\": formatMonth,\n\t    \"c\": null,\n\t    \"d\": formatDayOfMonth,\n\t    \"e\": formatDayOfMonth,\n\t    \"H\": formatHour24,\n\t    \"I\": formatHour12,\n\t    \"j\": formatDayOfYear,\n\t    \"L\": formatMilliseconds,\n\t    \"m\": formatMonthNumber,\n\t    \"M\": formatMinutes,\n\t    \"p\": formatPeriod,\n\t    \"S\": formatSeconds,\n\t    \"U\": formatWeekNumberSunday,\n\t    \"w\": formatWeekdayNumber,\n\t    \"W\": formatWeekNumberMonday,\n\t    \"x\": null,\n\t    \"X\": null,\n\t    \"y\": formatYear,\n\t    \"Y\": formatFullYear,\n\t    \"Z\": formatZone,\n\t    \"%\": formatLiteralPercent\n\t  };\n\t\n\t  var utcFormats = {\n\t    \"a\": formatUTCShortWeekday,\n\t    \"A\": formatUTCWeekday,\n\t    \"b\": formatUTCShortMonth,\n\t    \"B\": formatUTCMonth,\n\t    \"c\": null,\n\t    \"d\": formatUTCDayOfMonth,\n\t    \"e\": formatUTCDayOfMonth,\n\t    \"H\": formatUTCHour24,\n\t    \"I\": formatUTCHour12,\n\t    \"j\": formatUTCDayOfYear,\n\t    \"L\": formatUTCMilliseconds,\n\t    \"m\": formatUTCMonthNumber,\n\t    \"M\": formatUTCMinutes,\n\t    \"p\": formatUTCPeriod,\n\t    \"S\": formatUTCSeconds,\n\t    \"U\": formatUTCWeekNumberSunday,\n\t    \"w\": formatUTCWeekdayNumber,\n\t    \"W\": formatUTCWeekNumberMonday,\n\t    \"x\": null,\n\t    \"X\": null,\n\t    \"y\": formatUTCYear,\n\t    \"Y\": formatUTCFullYear,\n\t    \"Z\": formatUTCZone,\n\t    \"%\": formatLiteralPercent\n\t  };\n\t\n\t  var parses = {\n\t    \"a\": parseShortWeekday,\n\t    \"A\": parseWeekday,\n\t    \"b\": parseShortMonth,\n\t    \"B\": parseMonth,\n\t    \"c\": parseLocaleDateTime,\n\t    \"d\": parseDayOfMonth,\n\t    \"e\": parseDayOfMonth,\n\t    \"H\": parseHour24,\n\t    \"I\": parseHour24,\n\t    \"j\": parseDayOfYear,\n\t    \"L\": parseMilliseconds,\n\t    \"m\": parseMonthNumber,\n\t    \"M\": parseMinutes,\n\t    \"p\": parsePeriod,\n\t    \"S\": parseSeconds,\n\t    \"U\": parseWeekNumberSunday,\n\t    \"w\": parseWeekdayNumber,\n\t    \"W\": parseWeekNumberMonday,\n\t    \"x\": parseLocaleDate,\n\t    \"X\": parseLocaleTime,\n\t    \"y\": parseYear,\n\t    \"Y\": parseFullYear,\n\t    \"Z\": parseZone,\n\t    \"%\": parseLiteralPercent\n\t  };\n\t\n\t  // These recursive directive definitions must be deferred.\n\t  formats.x = newFormat(locale_date, formats);\n\t  formats.X = newFormat(locale_time, formats);\n\t  formats.c = newFormat(locale_dateTime, formats);\n\t  utcFormats.x = newFormat(locale_date, utcFormats);\n\t  utcFormats.X = newFormat(locale_time, utcFormats);\n\t  utcFormats.c = newFormat(locale_dateTime, utcFormats);\n\t\n\t  function newFormat(specifier, formats) {\n\t    return function(date) {\n\t      var string = [],\n\t          i = -1,\n\t          j = 0,\n\t          n = specifier.length,\n\t          c,\n\t          pad,\n\t          format;\n\t\n\t      if (!(date instanceof Date)) date = new Date(+date);\n\t\n\t      while (++i < n) {\n\t        if (specifier.charCodeAt(i) === 37) {\n\t          string.push(specifier.slice(j, i));\n\t          if ((pad = pads[c = specifier.charAt(++i)]) != null) c = specifier.charAt(++i);\n\t          else pad = c === \"e\" ? \" \" : \"0\";\n\t          if (format = formats[c]) c = format(date, pad);\n\t          string.push(c);\n\t          j = i + 1;\n\t        }\n\t      }\n\t\n\t      string.push(specifier.slice(j, i));\n\t      return string.join(\"\");\n\t    };\n\t  }\n\t\n\t  function newParse(specifier, newDate) {\n\t    return function(string) {\n\t      var d = newYear(1900),\n\t          i = parseSpecifier(d, specifier, string += \"\", 0);\n\t      if (i != string.length) return null;\n\t\n\t      // The am-pm flag is 0 for AM, and 1 for PM.\n\t      if (\"p\" in d) d.H = d.H % 12 + d.p * 12;\n\t\n\t      // Convert day-of-week and week-of-year to day-of-year.\n\t      if (\"W\" in d || \"U\" in d) {\n\t        if (!(\"w\" in d)) d.w = \"W\" in d ? 1 : 0;\n\t        var day = \"Z\" in d ? utcDate(newYear(d.y)).getUTCDay() : newDate(newYear(d.y)).getDay();\n\t        d.m = 0;\n\t        d.d = \"W\" in d ? (d.w + 6) % 7 + d.W * 7 - (day + 5) % 7 : d.w + d.U * 7 - (day + 6) % 7;\n\t      }\n\t\n\t      // If a time zone is specified, all fields are interpreted as UTC and then\n\t      // offset according to the specified time zone.\n\t      if (\"Z\" in d) {\n\t        d.H += d.Z / 100 | 0;\n\t        d.M += d.Z % 100;\n\t        return utcDate(d);\n\t      }\n\t\n\t      // Otherwise, all fields are in local time.\n\t      return newDate(d);\n\t    };\n\t  }\n\t\n\t  function parseSpecifier(d, specifier, string, j) {\n\t    var i = 0,\n\t        n = specifier.length,\n\t        m = string.length,\n\t        c,\n\t        parse;\n\t\n\t    while (i < n) {\n\t      if (j >= m) return -1;\n\t      c = specifier.charCodeAt(i++);\n\t      if (c === 37) {\n\t        c = specifier.charAt(i++);\n\t        parse = parses[c in pads ? specifier.charAt(i++) : c];\n\t        if (!parse || ((j = parse(d, string, j)) < 0)) return -1;\n\t      } else if (c != string.charCodeAt(j++)) {\n\t        return -1;\n\t      }\n\t    }\n\t\n\t    return j;\n\t  }\n\t\n\t  function parsePeriod(d, string, i) {\n\t    var n = periodRe.exec(string.slice(i));\n\t    return n ? (d.p = periodLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n\t  }\n\t\n\t  function parseShortWeekday(d, string, i) {\n\t    var n = shortWeekdayRe.exec(string.slice(i));\n\t    return n ? (d.w = shortWeekdayLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n\t  }\n\t\n\t  function parseWeekday(d, string, i) {\n\t    var n = weekdayRe.exec(string.slice(i));\n\t    return n ? (d.w = weekdayLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n\t  }\n\t\n\t  function parseShortMonth(d, string, i) {\n\t    var n = shortMonthRe.exec(string.slice(i));\n\t    return n ? (d.m = shortMonthLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n\t  }\n\t\n\t  function parseMonth(d, string, i) {\n\t    var n = monthRe.exec(string.slice(i));\n\t    return n ? (d.m = monthLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n\t  }\n\t\n\t  function parseLocaleDateTime(d, string, i) {\n\t    return parseSpecifier(d, locale_dateTime, string, i);\n\t  }\n\t\n\t  function parseLocaleDate(d, string, i) {\n\t    return parseSpecifier(d, locale_date, string, i);\n\t  }\n\t\n\t  function parseLocaleTime(d, string, i) {\n\t    return parseSpecifier(d, locale_time, string, i);\n\t  }\n\t\n\t  function formatShortWeekday(d) {\n\t    return locale_shortWeekdays[d.getDay()];\n\t  }\n\t\n\t  function formatWeekday(d) {\n\t    return locale_weekdays[d.getDay()];\n\t  }\n\t\n\t  function formatShortMonth(d) {\n\t    return locale_shortMonths[d.getMonth()];\n\t  }\n\t\n\t  function formatMonth(d) {\n\t    return locale_months[d.getMonth()];\n\t  }\n\t\n\t  function formatPeriod(d) {\n\t    return locale_periods[+(d.getHours() >= 12)];\n\t  }\n\t\n\t  function formatUTCShortWeekday(d) {\n\t    return locale_shortWeekdays[d.getUTCDay()];\n\t  }\n\t\n\t  function formatUTCWeekday(d) {\n\t    return locale_weekdays[d.getUTCDay()];\n\t  }\n\t\n\t  function formatUTCShortMonth(d) {\n\t    return locale_shortMonths[d.getUTCMonth()];\n\t  }\n\t\n\t  function formatUTCMonth(d) {\n\t    return locale_months[d.getUTCMonth()];\n\t  }\n\t\n\t  function formatUTCPeriod(d) {\n\t    return locale_periods[+(d.getUTCHours() >= 12)];\n\t  }\n\t\n\t  return {\n\t    format: function(specifier) {\n\t      var f = newFormat(specifier += \"\", formats);\n\t      f.toString = function() { return specifier; };\n\t      return f;\n\t    },\n\t    parse: function(specifier) {\n\t      var p = newParse(specifier += \"\", localDate);\n\t      p.toString = function() { return specifier; };\n\t      return p;\n\t    },\n\t    utcFormat: function(specifier) {\n\t      var f = newFormat(specifier += \"\", utcFormats);\n\t      f.toString = function() { return specifier; };\n\t      return f;\n\t    },\n\t    utcParse: function(specifier) {\n\t      var p = newParse(specifier, utcDate);\n\t      p.toString = function() { return specifier; };\n\t      return p;\n\t    }\n\t  };\n\t}\n\t\n\tvar pads = {\"-\": \"\", \"_\": \" \", \"0\": \"0\"};\n\tvar numberRe = /^\\s*\\d+/;\n\tvar percentRe = /^%/;\n\tvar requoteRe = /[\\\\\\^\\$\\*\\+\\?\\|\\[\\]\\(\\)\\.\\{\\}]/g;\n\t\n\tfunction pad(value, fill, width) {\n\t  var sign = value < 0 ? \"-\" : \"\",\n\t      string = (sign ? -value : value) + \"\",\n\t      length = string.length;\n\t  return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string);\n\t}\n\t\n\tfunction requote(s) {\n\t  return s.replace(requoteRe, \"\\\\$&\");\n\t}\n\t\n\tfunction formatRe(names) {\n\t  return new RegExp(\"^(?:\" + names.map(requote).join(\"|\") + \")\", \"i\");\n\t}\n\t\n\tfunction formatLookup(names) {\n\t  var map = {}, i = -1, n = names.length;\n\t  while (++i < n) map[names[i].toLowerCase()] = i;\n\t  return map;\n\t}\n\t\n\tfunction parseWeekdayNumber(d, string, i) {\n\t  var n = numberRe.exec(string.slice(i, i + 1));\n\t  return n ? (d.w = +n[0], i + n[0].length) : -1;\n\t}\n\t\n\tfunction parseWeekNumberSunday(d, string, i) {\n\t  var n = numberRe.exec(string.slice(i));\n\t  return n ? (d.U = +n[0], i + n[0].length) : -1;\n\t}\n\t\n\tfunction parseWeekNumberMonday(d, string, i) {\n\t  var n = numberRe.exec(string.slice(i));\n\t  return n ? (d.W = +n[0], i + n[0].length) : -1;\n\t}\n\t\n\tfunction parseFullYear(d, string, i) {\n\t  var n = numberRe.exec(string.slice(i, i + 4));\n\t  return n ? (d.y = +n[0], i + n[0].length) : -1;\n\t}\n\t\n\tfunction parseYear(d, string, i) {\n\t  var n = numberRe.exec(string.slice(i, i + 2));\n\t  return n ? (d.y = +n[0] + (+n[0] > 68 ? 1900 : 2000), i + n[0].length) : -1;\n\t}\n\t\n\tfunction parseZone(d, string, i) {\n\t  var n = /^(Z)|([+-]\\d\\d)(?:\\:?(\\d\\d))?/.exec(string.slice(i, i + 6));\n\t  return n ? (d.Z = n[1] ? 0 : -(n[2] + (n[3] || \"00\")), i + n[0].length) : -1;\n\t}\n\t\n\tfunction parseMonthNumber(d, string, i) {\n\t  var n = numberRe.exec(string.slice(i, i + 2));\n\t  return n ? (d.m = n[0] - 1, i + n[0].length) : -1;\n\t}\n\t\n\tfunction parseDayOfMonth(d, string, i) {\n\t  var n = numberRe.exec(string.slice(i, i + 2));\n\t  return n ? (d.d = +n[0], i + n[0].length) : -1;\n\t}\n\t\n\tfunction parseDayOfYear(d, string, i) {\n\t  var n = numberRe.exec(string.slice(i, i + 3));\n\t  return n ? (d.m = 0, d.d = +n[0], i + n[0].length) : -1;\n\t}\n\t\n\tfunction parseHour24(d, string, i) {\n\t  var n = numberRe.exec(string.slice(i, i + 2));\n\t  return n ? (d.H = +n[0], i + n[0].length) : -1;\n\t}\n\t\n\tfunction parseMinutes(d, string, i) {\n\t  var n = numberRe.exec(string.slice(i, i + 2));\n\t  return n ? (d.M = +n[0], i + n[0].length) : -1;\n\t}\n\t\n\tfunction parseSeconds(d, string, i) {\n\t  var n = numberRe.exec(string.slice(i, i + 2));\n\t  return n ? (d.S = +n[0], i + n[0].length) : -1;\n\t}\n\t\n\tfunction parseMilliseconds(d, string, i) {\n\t  var n = numberRe.exec(string.slice(i, i + 3));\n\t  return n ? (d.L = +n[0], i + n[0].length) : -1;\n\t}\n\t\n\tfunction parseLiteralPercent(d, string, i) {\n\t  var n = percentRe.exec(string.slice(i, i + 1));\n\t  return n ? i + n[0].length : -1;\n\t}\n\t\n\tfunction formatDayOfMonth(d, p) {\n\t  return pad(d.getDate(), p, 2);\n\t}\n\t\n\tfunction formatHour24(d, p) {\n\t  return pad(d.getHours(), p, 2);\n\t}\n\t\n\tfunction formatHour12(d, p) {\n\t  return pad(d.getHours() % 12 || 12, p, 2);\n\t}\n\t\n\tfunction formatDayOfYear(d, p) {\n\t  return pad(1 + d3Time.timeDay.count(d3Time.timeYear(d), d), p, 3);\n\t}\n\t\n\tfunction formatMilliseconds(d, p) {\n\t  return pad(d.getMilliseconds(), p, 3);\n\t}\n\t\n\tfunction formatMonthNumber(d, p) {\n\t  return pad(d.getMonth() + 1, p, 2);\n\t}\n\t\n\tfunction formatMinutes(d, p) {\n\t  return pad(d.getMinutes(), p, 2);\n\t}\n\t\n\tfunction formatSeconds(d, p) {\n\t  return pad(d.getSeconds(), p, 2);\n\t}\n\t\n\tfunction formatWeekNumberSunday(d, p) {\n\t  return pad(d3Time.timeSunday.count(d3Time.timeYear(d), d), p, 2);\n\t}\n\t\n\tfunction formatWeekdayNumber(d) {\n\t  return d.getDay();\n\t}\n\t\n\tfunction formatWeekNumberMonday(d, p) {\n\t  return pad(d3Time.timeMonday.count(d3Time.timeYear(d), d), p, 2);\n\t}\n\t\n\tfunction formatYear(d, p) {\n\t  return pad(d.getFullYear() % 100, p, 2);\n\t}\n\t\n\tfunction formatFullYear(d, p) {\n\t  return pad(d.getFullYear() % 10000, p, 4);\n\t}\n\t\n\tfunction formatZone(d) {\n\t  var z = d.getTimezoneOffset();\n\t  return (z > 0 ? \"-\" : (z *= -1, \"+\"))\n\t      + pad(z / 60 | 0, \"0\", 2)\n\t      + pad(z % 60, \"0\", 2);\n\t}\n\t\n\tfunction formatUTCDayOfMonth(d, p) {\n\t  return pad(d.getUTCDate(), p, 2);\n\t}\n\t\n\tfunction formatUTCHour24(d, p) {\n\t  return pad(d.getUTCHours(), p, 2);\n\t}\n\t\n\tfunction formatUTCHour12(d, p) {\n\t  return pad(d.getUTCHours() % 12 || 12, p, 2);\n\t}\n\t\n\tfunction formatUTCDayOfYear(d, p) {\n\t  return pad(1 + d3Time.utcDay.count(d3Time.utcYear(d), d), p, 3);\n\t}\n\t\n\tfunction formatUTCMilliseconds(d, p) {\n\t  return pad(d.getUTCMilliseconds(), p, 3);\n\t}\n\t\n\tfunction formatUTCMonthNumber(d, p) {\n\t  return pad(d.getUTCMonth() + 1, p, 2);\n\t}\n\t\n\tfunction formatUTCMinutes(d, p) {\n\t  return pad(d.getUTCMinutes(), p, 2);\n\t}\n\t\n\tfunction formatUTCSeconds(d, p) {\n\t  return pad(d.getUTCSeconds(), p, 2);\n\t}\n\t\n\tfunction formatUTCWeekNumberSunday(d, p) {\n\t  return pad(d3Time.utcSunday.count(d3Time.utcYear(d), d), p, 2);\n\t}\n\t\n\tfunction formatUTCWeekdayNumber(d) {\n\t  return d.getUTCDay();\n\t}\n\t\n\tfunction formatUTCWeekNumberMonday(d, p) {\n\t  return pad(d3Time.utcMonday.count(d3Time.utcYear(d), d), p, 2);\n\t}\n\t\n\tfunction formatUTCYear(d, p) {\n\t  return pad(d.getUTCFullYear() % 100, p, 2);\n\t}\n\t\n\tfunction formatUTCFullYear(d, p) {\n\t  return pad(d.getUTCFullYear() % 10000, p, 4);\n\t}\n\t\n\tfunction formatUTCZone() {\n\t  return \"+0000\";\n\t}\n\t\n\tfunction formatLiteralPercent() {\n\t  return \"%\";\n\t}\n\t\n\tvar locale$1;\n\t\n\t\n\t\n\t\n\t\n\tdefaultLocale({\n\t  dateTime: \"%x, %X\",\n\t  date: \"%-m/%-d/%Y\",\n\t  time: \"%-I:%M:%S %p\",\n\t  periods: [\"AM\", \"PM\"],\n\t  days: [\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"],\n\t  shortDays: [\"Sun\", \"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\"],\n\t  months: [\"January\", \"February\", \"March\", \"April\", \"May\", \"June\", \"July\", \"August\", \"September\", \"October\", \"November\", \"December\"],\n\t  shortMonths: [\"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"Jun\", \"Jul\", \"Aug\", \"Sep\", \"Oct\", \"Nov\", \"Dec\"]\n\t});\n\t\n\tfunction defaultLocale(definition) {\n\t  locale$1 = formatLocale(definition);\n\t  exports.timeFormat = locale$1.format;\n\t  exports.timeParse = locale$1.parse;\n\t  exports.utcFormat = locale$1.utcFormat;\n\t  exports.utcParse = locale$1.utcParse;\n\t  return locale$1;\n\t}\n\t\n\tvar isoSpecifier = \"%Y-%m-%dT%H:%M:%S.%LZ\";\n\t\n\tfunction formatIsoNative(date) {\n\t  return date.toISOString();\n\t}\n\t\n\tvar formatIso = Date.prototype.toISOString\n\t    ? formatIsoNative\n\t    : exports.utcFormat(isoSpecifier);\n\t\n\tfunction parseIsoNative(string) {\n\t  var date = new Date(string);\n\t  return isNaN(date) ? null : date;\n\t}\n\t\n\tvar parseIso = +new Date(\"2000-01-01T00:00:00.000Z\")\n\t    ? parseIsoNative\n\t    : exports.utcParse(isoSpecifier);\n\t\n\texports.timeFormatDefaultLocale = defaultLocale;\n\texports.timeFormatLocale = formatLocale;\n\texports.isoFormat = formatIso;\n\texports.isoParse = parseIso;\n\t\n\tObject.defineProperty(exports, '__esModule', { value: true });\n\t\n\t})));\n\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t// https://d3js.org/d3-selection/ Version 1.1.0. Copyright 2017 Mike Bostock.\n\t(function (global, factory) {\n\t\t true ? factory(exports) :\n\t\ttypeof define === 'function' && define.amd ? define(['exports'], factory) :\n\t\t(factory((global.d3 = global.d3 || {})));\n\t}(this, (function (exports) { 'use strict';\n\t\n\tvar xhtml = \"http://www.w3.org/1999/xhtml\";\n\t\n\tvar namespaces = {\n\t  svg: \"http://www.w3.org/2000/svg\",\n\t  xhtml: xhtml,\n\t  xlink: \"http://www.w3.org/1999/xlink\",\n\t  xml: \"http://www.w3.org/XML/1998/namespace\",\n\t  xmlns: \"http://www.w3.org/2000/xmlns/\"\n\t};\n\t\n\tvar namespace = function(name) {\n\t  var prefix = name += \"\", i = prefix.indexOf(\":\");\n\t  if (i >= 0 && (prefix = name.slice(0, i)) !== \"xmlns\") name = name.slice(i + 1);\n\t  return namespaces.hasOwnProperty(prefix) ? {space: namespaces[prefix], local: name} : name;\n\t};\n\t\n\tfunction creatorInherit(name) {\n\t  return function() {\n\t    var document = this.ownerDocument,\n\t        uri = this.namespaceURI;\n\t    return uri === xhtml && document.documentElement.namespaceURI === xhtml\n\t        ? document.createElement(name)\n\t        : document.createElementNS(uri, name);\n\t  };\n\t}\n\t\n\tfunction creatorFixed(fullname) {\n\t  return function() {\n\t    return this.ownerDocument.createElementNS(fullname.space, fullname.local);\n\t  };\n\t}\n\t\n\tvar creator = function(name) {\n\t  var fullname = namespace(name);\n\t  return (fullname.local\n\t      ? creatorFixed\n\t      : creatorInherit)(fullname);\n\t};\n\t\n\tvar nextId = 0;\n\t\n\tfunction local() {\n\t  return new Local;\n\t}\n\t\n\tfunction Local() {\n\t  this._ = \"@\" + (++nextId).toString(36);\n\t}\n\t\n\tLocal.prototype = local.prototype = {\n\t  constructor: Local,\n\t  get: function(node) {\n\t    var id = this._;\n\t    while (!(id in node)) if (!(node = node.parentNode)) return;\n\t    return node[id];\n\t  },\n\t  set: function(node, value) {\n\t    return node[this._] = value;\n\t  },\n\t  remove: function(node) {\n\t    return this._ in node && delete node[this._];\n\t  },\n\t  toString: function() {\n\t    return this._;\n\t  }\n\t};\n\t\n\tvar matcher = function(selector) {\n\t  return function() {\n\t    return this.matches(selector);\n\t  };\n\t};\n\t\n\tif (typeof document !== \"undefined\") {\n\t  var element = document.documentElement;\n\t  if (!element.matches) {\n\t    var vendorMatches = element.webkitMatchesSelector\n\t        || element.msMatchesSelector\n\t        || element.mozMatchesSelector\n\t        || element.oMatchesSelector;\n\t    matcher = function(selector) {\n\t      return function() {\n\t        return vendorMatches.call(this, selector);\n\t      };\n\t    };\n\t  }\n\t}\n\t\n\tvar matcher$1 = matcher;\n\t\n\tvar filterEvents = {};\n\t\n\texports.event = null;\n\t\n\tif (typeof document !== \"undefined\") {\n\t  var element$1 = document.documentElement;\n\t  if (!(\"onmouseenter\" in element$1)) {\n\t    filterEvents = {mouseenter: \"mouseover\", mouseleave: \"mouseout\"};\n\t  }\n\t}\n\t\n\tfunction filterContextListener(listener, index, group) {\n\t  listener = contextListener(listener, index, group);\n\t  return function(event) {\n\t    var related = event.relatedTarget;\n\t    if (!related || (related !== this && !(related.compareDocumentPosition(this) & 8))) {\n\t      listener.call(this, event);\n\t    }\n\t  };\n\t}\n\t\n\tfunction contextListener(listener, index, group) {\n\t  return function(event1) {\n\t    var event0 = exports.event; // Events can be reentrant (e.g., focus).\n\t    exports.event = event1;\n\t    try {\n\t      listener.call(this, this.__data__, index, group);\n\t    } finally {\n\t      exports.event = event0;\n\t    }\n\t  };\n\t}\n\t\n\tfunction parseTypenames(typenames) {\n\t  return typenames.trim().split(/^|\\s+/).map(function(t) {\n\t    var name = \"\", i = t.indexOf(\".\");\n\t    if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);\n\t    return {type: t, name: name};\n\t  });\n\t}\n\t\n\tfunction onRemove(typename) {\n\t  return function() {\n\t    var on = this.__on;\n\t    if (!on) return;\n\t    for (var j = 0, i = -1, m = on.length, o; j < m; ++j) {\n\t      if (o = on[j], (!typename.type || o.type === typename.type) && o.name === typename.name) {\n\t        this.removeEventListener(o.type, o.listener, o.capture);\n\t      } else {\n\t        on[++i] = o;\n\t      }\n\t    }\n\t    if (++i) on.length = i;\n\t    else delete this.__on;\n\t  };\n\t}\n\t\n\tfunction onAdd(typename, value, capture) {\n\t  var wrap = filterEvents.hasOwnProperty(typename.type) ? filterContextListener : contextListener;\n\t  return function(d, i, group) {\n\t    var on = this.__on, o, listener = wrap(value, i, group);\n\t    if (on) for (var j = 0, m = on.length; j < m; ++j) {\n\t      if ((o = on[j]).type === typename.type && o.name === typename.name) {\n\t        this.removeEventListener(o.type, o.listener, o.capture);\n\t        this.addEventListener(o.type, o.listener = listener, o.capture = capture);\n\t        o.value = value;\n\t        return;\n\t      }\n\t    }\n\t    this.addEventListener(typename.type, listener, capture);\n\t    o = {type: typename.type, name: typename.name, value: value, listener: listener, capture: capture};\n\t    if (!on) this.__on = [o];\n\t    else on.push(o);\n\t  };\n\t}\n\t\n\tvar selection_on = function(typename, value, capture) {\n\t  var typenames = parseTypenames(typename + \"\"), i, n = typenames.length, t;\n\t\n\t  if (arguments.length < 2) {\n\t    var on = this.node().__on;\n\t    if (on) for (var j = 0, m = on.length, o; j < m; ++j) {\n\t      for (i = 0, o = on[j]; i < n; ++i) {\n\t        if ((t = typenames[i]).type === o.type && t.name === o.name) {\n\t          return o.value;\n\t        }\n\t      }\n\t    }\n\t    return;\n\t  }\n\t\n\t  on = value ? onAdd : onRemove;\n\t  if (capture == null) capture = false;\n\t  for (i = 0; i < n; ++i) this.each(on(typenames[i], value, capture));\n\t  return this;\n\t};\n\t\n\tfunction customEvent(event1, listener, that, args) {\n\t  var event0 = exports.event;\n\t  event1.sourceEvent = exports.event;\n\t  exports.event = event1;\n\t  try {\n\t    return listener.apply(that, args);\n\t  } finally {\n\t    exports.event = event0;\n\t  }\n\t}\n\t\n\tvar sourceEvent = function() {\n\t  var current = exports.event, source;\n\t  while (source = current.sourceEvent) current = source;\n\t  return current;\n\t};\n\t\n\tvar point = function(node, event) {\n\t  var svg = node.ownerSVGElement || node;\n\t\n\t  if (svg.createSVGPoint) {\n\t    var point = svg.createSVGPoint();\n\t    point.x = event.clientX, point.y = event.clientY;\n\t    point = point.matrixTransform(node.getScreenCTM().inverse());\n\t    return [point.x, point.y];\n\t  }\n\t\n\t  var rect = node.getBoundingClientRect();\n\t  return [event.clientX - rect.left - node.clientLeft, event.clientY - rect.top - node.clientTop];\n\t};\n\t\n\tvar mouse = function(node) {\n\t  var event = sourceEvent();\n\t  if (event.changedTouches) event = event.changedTouches[0];\n\t  return point(node, event);\n\t};\n\t\n\tfunction none() {}\n\t\n\tvar selector = function(selector) {\n\t  return selector == null ? none : function() {\n\t    return this.querySelector(selector);\n\t  };\n\t};\n\t\n\tvar selection_select = function(select) {\n\t  if (typeof select !== \"function\") select = selector(select);\n\t\n\t  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {\n\t    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) {\n\t      if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) {\n\t        if (\"__data__\" in node) subnode.__data__ = node.__data__;\n\t        subgroup[i] = subnode;\n\t      }\n\t    }\n\t  }\n\t\n\t  return new Selection(subgroups, this._parents);\n\t};\n\t\n\tfunction empty() {\n\t  return [];\n\t}\n\t\n\tvar selectorAll = function(selector) {\n\t  return selector == null ? empty : function() {\n\t    return this.querySelectorAll(selector);\n\t  };\n\t};\n\t\n\tvar selection_selectAll = function(select) {\n\t  if (typeof select !== \"function\") select = selectorAll(select);\n\t\n\t  for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) {\n\t    for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {\n\t      if (node = group[i]) {\n\t        subgroups.push(select.call(node, node.__data__, i, group));\n\t        parents.push(node);\n\t      }\n\t    }\n\t  }\n\t\n\t  return new Selection(subgroups, parents);\n\t};\n\t\n\tvar selection_filter = function(match) {\n\t  if (typeof match !== \"function\") match = matcher$1(match);\n\t\n\t  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {\n\t    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) {\n\t      if ((node = group[i]) && match.call(node, node.__data__, i, group)) {\n\t        subgroup.push(node);\n\t      }\n\t    }\n\t  }\n\t\n\t  return new Selection(subgroups, this._parents);\n\t};\n\t\n\tvar sparse = function(update) {\n\t  return new Array(update.length);\n\t};\n\t\n\tvar selection_enter = function() {\n\t  return new Selection(this._enter || this._groups.map(sparse), this._parents);\n\t};\n\t\n\tfunction EnterNode(parent, datum) {\n\t  this.ownerDocument = parent.ownerDocument;\n\t  this.namespaceURI = parent.namespaceURI;\n\t  this._next = null;\n\t  this._parent = parent;\n\t  this.__data__ = datum;\n\t}\n\t\n\tEnterNode.prototype = {\n\t  constructor: EnterNode,\n\t  appendChild: function(child) { return this._parent.insertBefore(child, this._next); },\n\t  insertBefore: function(child, next) { return this._parent.insertBefore(child, next); },\n\t  querySelector: function(selector) { return this._parent.querySelector(selector); },\n\t  querySelectorAll: function(selector) { return this._parent.querySelectorAll(selector); }\n\t};\n\t\n\tvar constant = function(x) {\n\t  return function() {\n\t    return x;\n\t  };\n\t};\n\t\n\tvar keyPrefix = \"$\"; // Protect against keys like “__proto__”.\n\t\n\tfunction bindIndex(parent, group, enter, update, exit, data) {\n\t  var i = 0,\n\t      node,\n\t      groupLength = group.length,\n\t      dataLength = data.length;\n\t\n\t  // Put any non-null nodes that fit into update.\n\t  // Put any null nodes into enter.\n\t  // Put any remaining data into enter.\n\t  for (; i < dataLength; ++i) {\n\t    if (node = group[i]) {\n\t      node.__data__ = data[i];\n\t      update[i] = node;\n\t    } else {\n\t      enter[i] = new EnterNode(parent, data[i]);\n\t    }\n\t  }\n\t\n\t  // Put any non-null nodes that don’t fit into exit.\n\t  for (; i < groupLength; ++i) {\n\t    if (node = group[i]) {\n\t      exit[i] = node;\n\t    }\n\t  }\n\t}\n\t\n\tfunction bindKey(parent, group, enter, update, exit, data, key) {\n\t  var i,\n\t      node,\n\t      nodeByKeyValue = {},\n\t      groupLength = group.length,\n\t      dataLength = data.length,\n\t      keyValues = new Array(groupLength),\n\t      keyValue;\n\t\n\t  // Compute the key for each node.\n\t  // If multiple nodes have the same key, the duplicates are added to exit.\n\t  for (i = 0; i < groupLength; ++i) {\n\t    if (node = group[i]) {\n\t      keyValues[i] = keyValue = keyPrefix + key.call(node, node.__data__, i, group);\n\t      if (keyValue in nodeByKeyValue) {\n\t        exit[i] = node;\n\t      } else {\n\t        nodeByKeyValue[keyValue] = node;\n\t      }\n\t    }\n\t  }\n\t\n\t  // Compute the key for each datum.\n\t  // If there a node associated with this key, join and add it to update.\n\t  // If there is not (or the key is a duplicate), add it to enter.\n\t  for (i = 0; i < dataLength; ++i) {\n\t    keyValue = keyPrefix + key.call(parent, data[i], i, data);\n\t    if (node = nodeByKeyValue[keyValue]) {\n\t      update[i] = node;\n\t      node.__data__ = data[i];\n\t      nodeByKeyValue[keyValue] = null;\n\t    } else {\n\t      enter[i] = new EnterNode(parent, data[i]);\n\t    }\n\t  }\n\t\n\t  // Add any remaining nodes that were not bound to data to exit.\n\t  for (i = 0; i < groupLength; ++i) {\n\t    if ((node = group[i]) && (nodeByKeyValue[keyValues[i]] === node)) {\n\t      exit[i] = node;\n\t    }\n\t  }\n\t}\n\t\n\tvar selection_data = function(value, key) {\n\t  if (!value) {\n\t    data = new Array(this.size()), j = -1;\n\t    this.each(function(d) { data[++j] = d; });\n\t    return data;\n\t  }\n\t\n\t  var bind = key ? bindKey : bindIndex,\n\t      parents = this._parents,\n\t      groups = this._groups;\n\t\n\t  if (typeof value !== \"function\") value = constant(value);\n\t\n\t  for (var m = groups.length, update = new Array(m), enter = new Array(m), exit = new Array(m), j = 0; j < m; ++j) {\n\t    var parent = parents[j],\n\t        group = groups[j],\n\t        groupLength = group.length,\n\t        data = value.call(parent, parent && parent.__data__, j, parents),\n\t        dataLength = data.length,\n\t        enterGroup = enter[j] = new Array(dataLength),\n\t        updateGroup = update[j] = new Array(dataLength),\n\t        exitGroup = exit[j] = new Array(groupLength);\n\t\n\t    bind(parent, group, enterGroup, updateGroup, exitGroup, data, key);\n\t\n\t    // Now connect the enter nodes to their following update node, such that\n\t    // appendChild can insert the materialized enter node before this node,\n\t    // rather than at the end of the parent node.\n\t    for (var i0 = 0, i1 = 0, previous, next; i0 < dataLength; ++i0) {\n\t      if (previous = enterGroup[i0]) {\n\t        if (i0 >= i1) i1 = i0 + 1;\n\t        while (!(next = updateGroup[i1]) && ++i1 < dataLength);\n\t        previous._next = next || null;\n\t      }\n\t    }\n\t  }\n\t\n\t  update = new Selection(update, parents);\n\t  update._enter = enter;\n\t  update._exit = exit;\n\t  return update;\n\t};\n\t\n\tvar selection_exit = function() {\n\t  return new Selection(this._exit || this._groups.map(sparse), this._parents);\n\t};\n\t\n\tvar selection_merge = function(selection) {\n\t\n\t  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\t    for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) {\n\t      if (node = group0[i] || group1[i]) {\n\t        merge[i] = node;\n\t      }\n\t    }\n\t  }\n\t\n\t  for (; j < m0; ++j) {\n\t    merges[j] = groups0[j];\n\t  }\n\t\n\t  return new Selection(merges, this._parents);\n\t};\n\t\n\tvar selection_order = function() {\n\t\n\t  for (var groups = this._groups, j = -1, m = groups.length; ++j < m;) {\n\t    for (var group = groups[j], i = group.length - 1, next = group[i], node; --i >= 0;) {\n\t      if (node = group[i]) {\n\t        if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next);\n\t        next = node;\n\t      }\n\t    }\n\t  }\n\t\n\t  return this;\n\t};\n\t\n\tvar selection_sort = function(compare) {\n\t  if (!compare) compare = ascending;\n\t\n\t  function compareNode(a, b) {\n\t    return a && b ? compare(a.__data__, b.__data__) : !a - !b;\n\t  }\n\t\n\t  for (var groups = this._groups, m = groups.length, sortgroups = new Array(m), j = 0; j < m; ++j) {\n\t    for (var group = groups[j], n = group.length, sortgroup = sortgroups[j] = new Array(n), node, i = 0; i < n; ++i) {\n\t      if (node = group[i]) {\n\t        sortgroup[i] = node;\n\t      }\n\t    }\n\t    sortgroup.sort(compareNode);\n\t  }\n\t\n\t  return new Selection(sortgroups, this._parents).order();\n\t};\n\t\n\tfunction ascending(a, b) {\n\t  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;\n\t}\n\t\n\tvar selection_call = function() {\n\t  var callback = arguments[0];\n\t  arguments[0] = this;\n\t  callback.apply(null, arguments);\n\t  return this;\n\t};\n\t\n\tvar selection_nodes = function() {\n\t  var nodes = new Array(this.size()), i = -1;\n\t  this.each(function() { nodes[++i] = this; });\n\t  return nodes;\n\t};\n\t\n\tvar selection_node = function() {\n\t\n\t  for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {\n\t    for (var group = groups[j], i = 0, n = group.length; i < n; ++i) {\n\t      var node = group[i];\n\t      if (node) return node;\n\t    }\n\t  }\n\t\n\t  return null;\n\t};\n\t\n\tvar selection_size = function() {\n\t  var size = 0;\n\t  this.each(function() { ++size; });\n\t  return size;\n\t};\n\t\n\tvar selection_empty = function() {\n\t  return !this.node();\n\t};\n\t\n\tvar selection_each = function(callback) {\n\t\n\t  for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {\n\t    for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) {\n\t      if (node = group[i]) callback.call(node, node.__data__, i, group);\n\t    }\n\t  }\n\t\n\t  return this;\n\t};\n\t\n\tfunction attrRemove(name) {\n\t  return function() {\n\t    this.removeAttribute(name);\n\t  };\n\t}\n\t\n\tfunction attrRemoveNS(fullname) {\n\t  return function() {\n\t    this.removeAttributeNS(fullname.space, fullname.local);\n\t  };\n\t}\n\t\n\tfunction attrConstant(name, value) {\n\t  return function() {\n\t    this.setAttribute(name, value);\n\t  };\n\t}\n\t\n\tfunction attrConstantNS(fullname, value) {\n\t  return function() {\n\t    this.setAttributeNS(fullname.space, fullname.local, value);\n\t  };\n\t}\n\t\n\tfunction attrFunction(name, value) {\n\t  return function() {\n\t    var v = value.apply(this, arguments);\n\t    if (v == null) this.removeAttribute(name);\n\t    else this.setAttribute(name, v);\n\t  };\n\t}\n\t\n\tfunction attrFunctionNS(fullname, value) {\n\t  return function() {\n\t    var v = value.apply(this, arguments);\n\t    if (v == null) this.removeAttributeNS(fullname.space, fullname.local);\n\t    else this.setAttributeNS(fullname.space, fullname.local, v);\n\t  };\n\t}\n\t\n\tvar selection_attr = function(name, value) {\n\t  var fullname = namespace(name);\n\t\n\t  if (arguments.length < 2) {\n\t    var node = this.node();\n\t    return fullname.local\n\t        ? node.getAttributeNS(fullname.space, fullname.local)\n\t        : node.getAttribute(fullname);\n\t  }\n\t\n\t  return this.each((value == null\n\t      ? (fullname.local ? attrRemoveNS : attrRemove) : (typeof value === \"function\"\n\t      ? (fullname.local ? attrFunctionNS : attrFunction)\n\t      : (fullname.local ? attrConstantNS : attrConstant)))(fullname, value));\n\t};\n\t\n\tvar defaultView = function(node) {\n\t  return (node.ownerDocument && node.ownerDocument.defaultView) // node is a Node\n\t      || (node.document && node) // node is a Window\n\t      || node.defaultView; // node is a Document\n\t};\n\t\n\tfunction styleRemove(name) {\n\t  return function() {\n\t    this.style.removeProperty(name);\n\t  };\n\t}\n\t\n\tfunction styleConstant(name, value, priority) {\n\t  return function() {\n\t    this.style.setProperty(name, value, priority);\n\t  };\n\t}\n\t\n\tfunction styleFunction(name, value, priority) {\n\t  return function() {\n\t    var v = value.apply(this, arguments);\n\t    if (v == null) this.style.removeProperty(name);\n\t    else this.style.setProperty(name, v, priority);\n\t  };\n\t}\n\t\n\tvar selection_style = function(name, value, priority) {\n\t  return arguments.length > 1\n\t      ? this.each((value == null\n\t            ? styleRemove : typeof value === \"function\"\n\t            ? styleFunction\n\t            : styleConstant)(name, value, priority == null ? \"\" : priority))\n\t      : styleValue(this.node(), name);\n\t};\n\t\n\tfunction styleValue(node, name) {\n\t  return node.style.getPropertyValue(name)\n\t      || defaultView(node).getComputedStyle(node, null).getPropertyValue(name);\n\t}\n\t\n\tfunction propertyRemove(name) {\n\t  return function() {\n\t    delete this[name];\n\t  };\n\t}\n\t\n\tfunction propertyConstant(name, value) {\n\t  return function() {\n\t    this[name] = value;\n\t  };\n\t}\n\t\n\tfunction propertyFunction(name, value) {\n\t  return function() {\n\t    var v = value.apply(this, arguments);\n\t    if (v == null) delete this[name];\n\t    else this[name] = v;\n\t  };\n\t}\n\t\n\tvar selection_property = function(name, value) {\n\t  return arguments.length > 1\n\t      ? this.each((value == null\n\t          ? propertyRemove : typeof value === \"function\"\n\t          ? propertyFunction\n\t          : propertyConstant)(name, value))\n\t      : this.node()[name];\n\t};\n\t\n\tfunction classArray(string) {\n\t  return string.trim().split(/^|\\s+/);\n\t}\n\t\n\tfunction classList(node) {\n\t  return node.classList || new ClassList(node);\n\t}\n\t\n\tfunction ClassList(node) {\n\t  this._node = node;\n\t  this._names = classArray(node.getAttribute(\"class\") || \"\");\n\t}\n\t\n\tClassList.prototype = {\n\t  add: function(name) {\n\t    var i = this._names.indexOf(name);\n\t    if (i < 0) {\n\t      this._names.push(name);\n\t      this._node.setAttribute(\"class\", this._names.join(\" \"));\n\t    }\n\t  },\n\t  remove: function(name) {\n\t    var i = this._names.indexOf(name);\n\t    if (i >= 0) {\n\t      this._names.splice(i, 1);\n\t      this._node.setAttribute(\"class\", this._names.join(\" \"));\n\t    }\n\t  },\n\t  contains: function(name) {\n\t    return this._names.indexOf(name) >= 0;\n\t  }\n\t};\n\t\n\tfunction classedAdd(node, names) {\n\t  var list = classList(node), i = -1, n = names.length;\n\t  while (++i < n) list.add(names[i]);\n\t}\n\t\n\tfunction classedRemove(node, names) {\n\t  var list = classList(node), i = -1, n = names.length;\n\t  while (++i < n) list.remove(names[i]);\n\t}\n\t\n\tfunction classedTrue(names) {\n\t  return function() {\n\t    classedAdd(this, names);\n\t  };\n\t}\n\t\n\tfunction classedFalse(names) {\n\t  return function() {\n\t    classedRemove(this, names);\n\t  };\n\t}\n\t\n\tfunction classedFunction(names, value) {\n\t  return function() {\n\t    (value.apply(this, arguments) ? classedAdd : classedRemove)(this, names);\n\t  };\n\t}\n\t\n\tvar selection_classed = function(name, value) {\n\t  var names = classArray(name + \"\");\n\t\n\t  if (arguments.length < 2) {\n\t    var list = classList(this.node()), i = -1, n = names.length;\n\t    while (++i < n) if (!list.contains(names[i])) return false;\n\t    return true;\n\t  }\n\t\n\t  return this.each((typeof value === \"function\"\n\t      ? classedFunction : value\n\t      ? classedTrue\n\t      : classedFalse)(names, value));\n\t};\n\t\n\tfunction textRemove() {\n\t  this.textContent = \"\";\n\t}\n\t\n\tfunction textConstant(value) {\n\t  return function() {\n\t    this.textContent = value;\n\t  };\n\t}\n\t\n\tfunction textFunction(value) {\n\t  return function() {\n\t    var v = value.apply(this, arguments);\n\t    this.textContent = v == null ? \"\" : v;\n\t  };\n\t}\n\t\n\tvar selection_text = function(value) {\n\t  return arguments.length\n\t      ? this.each(value == null\n\t          ? textRemove : (typeof value === \"function\"\n\t          ? textFunction\n\t          : textConstant)(value))\n\t      : this.node().textContent;\n\t};\n\t\n\tfunction htmlRemove() {\n\t  this.innerHTML = \"\";\n\t}\n\t\n\tfunction htmlConstant(value) {\n\t  return function() {\n\t    this.innerHTML = value;\n\t  };\n\t}\n\t\n\tfunction htmlFunction(value) {\n\t  return function() {\n\t    var v = value.apply(this, arguments);\n\t    this.innerHTML = v == null ? \"\" : v;\n\t  };\n\t}\n\t\n\tvar selection_html = function(value) {\n\t  return arguments.length\n\t      ? this.each(value == null\n\t          ? htmlRemove : (typeof value === \"function\"\n\t          ? htmlFunction\n\t          : htmlConstant)(value))\n\t      : this.node().innerHTML;\n\t};\n\t\n\tfunction raise() {\n\t  if (this.nextSibling) this.parentNode.appendChild(this);\n\t}\n\t\n\tvar selection_raise = function() {\n\t  return this.each(raise);\n\t};\n\t\n\tfunction lower() {\n\t  if (this.previousSibling) this.parentNode.insertBefore(this, this.parentNode.firstChild);\n\t}\n\t\n\tvar selection_lower = function() {\n\t  return this.each(lower);\n\t};\n\t\n\tvar selection_append = function(name) {\n\t  var create = typeof name === \"function\" ? name : creator(name);\n\t  return this.select(function() {\n\t    return this.appendChild(create.apply(this, arguments));\n\t  });\n\t};\n\t\n\tfunction constantNull() {\n\t  return null;\n\t}\n\t\n\tvar selection_insert = function(name, before) {\n\t  var create = typeof name === \"function\" ? name : creator(name),\n\t      select = before == null ? constantNull : typeof before === \"function\" ? before : selector(before);\n\t  return this.select(function() {\n\t    return this.insertBefore(create.apply(this, arguments), select.apply(this, arguments) || null);\n\t  });\n\t};\n\t\n\tfunction remove() {\n\t  var parent = this.parentNode;\n\t  if (parent) parent.removeChild(this);\n\t}\n\t\n\tvar selection_remove = function() {\n\t  return this.each(remove);\n\t};\n\t\n\tvar selection_datum = function(value) {\n\t  return arguments.length\n\t      ? this.property(\"__data__\", value)\n\t      : this.node().__data__;\n\t};\n\t\n\tfunction dispatchEvent(node, type, params) {\n\t  var window = defaultView(node),\n\t      event = window.CustomEvent;\n\t\n\t  if (typeof event === \"function\") {\n\t    event = new event(type, params);\n\t  } else {\n\t    event = window.document.createEvent(\"Event\");\n\t    if (params) event.initEvent(type, params.bubbles, params.cancelable), event.detail = params.detail;\n\t    else event.initEvent(type, false, false);\n\t  }\n\t\n\t  node.dispatchEvent(event);\n\t}\n\t\n\tfunction dispatchConstant(type, params) {\n\t  return function() {\n\t    return dispatchEvent(this, type, params);\n\t  };\n\t}\n\t\n\tfunction dispatchFunction(type, params) {\n\t  return function() {\n\t    return dispatchEvent(this, type, params.apply(this, arguments));\n\t  };\n\t}\n\t\n\tvar selection_dispatch = function(type, params) {\n\t  return this.each((typeof params === \"function\"\n\t      ? dispatchFunction\n\t      : dispatchConstant)(type, params));\n\t};\n\t\n\tvar root = [null];\n\t\n\tfunction Selection(groups, parents) {\n\t  this._groups = groups;\n\t  this._parents = parents;\n\t}\n\t\n\tfunction selection() {\n\t  return new Selection([[document.documentElement]], root);\n\t}\n\t\n\tSelection.prototype = selection.prototype = {\n\t  constructor: Selection,\n\t  select: selection_select,\n\t  selectAll: selection_selectAll,\n\t  filter: selection_filter,\n\t  data: selection_data,\n\t  enter: selection_enter,\n\t  exit: selection_exit,\n\t  merge: selection_merge,\n\t  order: selection_order,\n\t  sort: selection_sort,\n\t  call: selection_call,\n\t  nodes: selection_nodes,\n\t  node: selection_node,\n\t  size: selection_size,\n\t  empty: selection_empty,\n\t  each: selection_each,\n\t  attr: selection_attr,\n\t  style: selection_style,\n\t  property: selection_property,\n\t  classed: selection_classed,\n\t  text: selection_text,\n\t  html: selection_html,\n\t  raise: selection_raise,\n\t  lower: selection_lower,\n\t  append: selection_append,\n\t  insert: selection_insert,\n\t  remove: selection_remove,\n\t  datum: selection_datum,\n\t  on: selection_on,\n\t  dispatch: selection_dispatch\n\t};\n\t\n\tvar select = function(selector) {\n\t  return typeof selector === \"string\"\n\t      ? new Selection([[document.querySelector(selector)]], [document.documentElement])\n\t      : new Selection([[selector]], root);\n\t};\n\t\n\tvar selectAll = function(selector) {\n\t  return typeof selector === \"string\"\n\t      ? new Selection([document.querySelectorAll(selector)], [document.documentElement])\n\t      : new Selection([selector == null ? [] : selector], root);\n\t};\n\t\n\tvar touch = function(node, touches, identifier) {\n\t  if (arguments.length < 3) identifier = touches, touches = sourceEvent().changedTouches;\n\t\n\t  for (var i = 0, n = touches ? touches.length : 0, touch; i < n; ++i) {\n\t    if ((touch = touches[i]).identifier === identifier) {\n\t      return point(node, touch);\n\t    }\n\t  }\n\t\n\t  return null;\n\t};\n\t\n\tvar touches = function(node, touches) {\n\t  if (touches == null) touches = sourceEvent().touches;\n\t\n\t  for (var i = 0, n = touches ? touches.length : 0, points = new Array(n); i < n; ++i) {\n\t    points[i] = point(node, touches[i]);\n\t  }\n\t\n\t  return points;\n\t};\n\t\n\texports.creator = creator;\n\texports.local = local;\n\texports.matcher = matcher$1;\n\texports.mouse = mouse;\n\texports.namespace = namespace;\n\texports.namespaces = namespaces;\n\texports.select = select;\n\texports.selectAll = selectAll;\n\texports.selection = selection;\n\texports.selector = selector;\n\texports.selectorAll = selectorAll;\n\texports.style = styleValue;\n\texports.touch = touch;\n\texports.touches = touches;\n\texports.window = defaultView;\n\texports.customEvent = customEvent;\n\t\n\tObject.defineProperty(exports, '__esModule', { value: true });\n\t\n\t})));\n\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t// https://d3js.org/d3-transition/ Version 1.1.0. Copyright 2017 Mike Bostock.\n\t(function (global, factory) {\n\t\t true ? factory(exports, __webpack_require__(12), __webpack_require__(5), __webpack_require__(14), __webpack_require__(9), __webpack_require__(4), __webpack_require__(2)) :\n\t\ttypeof define === 'function' && define.amd ? define(['exports', 'd3-selection', 'd3-dispatch', 'd3-timer', 'd3-interpolate', 'd3-color', 'd3-ease'], factory) :\n\t\t(factory((global.d3 = global.d3 || {}),global.d3,global.d3,global.d3,global.d3,global.d3,global.d3));\n\t}(this, (function (exports,d3Selection,d3Dispatch,d3Timer,d3Interpolate,d3Color,d3Ease) { 'use strict';\n\t\n\tvar emptyOn = d3Dispatch.dispatch(\"start\", \"end\", \"interrupt\");\n\tvar emptyTween = [];\n\t\n\tvar CREATED = 0;\n\tvar SCHEDULED = 1;\n\tvar STARTING = 2;\n\tvar STARTED = 3;\n\tvar RUNNING = 4;\n\tvar ENDING = 5;\n\tvar ENDED = 6;\n\t\n\tvar schedule = function(node, name, id, index, group, timing) {\n\t  var schedules = node.__transition;\n\t  if (!schedules) node.__transition = {};\n\t  else if (id in schedules) return;\n\t  create(node, id, {\n\t    name: name,\n\t    index: index, // For context during callback.\n\t    group: group, // For context during callback.\n\t    on: emptyOn,\n\t    tween: emptyTween,\n\t    time: timing.time,\n\t    delay: timing.delay,\n\t    duration: timing.duration,\n\t    ease: timing.ease,\n\t    timer: null,\n\t    state: CREATED\n\t  });\n\t};\n\t\n\tfunction init(node, id) {\n\t  var schedule = node.__transition;\n\t  if (!schedule || !(schedule = schedule[id]) || schedule.state > CREATED) throw new Error(\"too late\");\n\t  return schedule;\n\t}\n\t\n\tfunction set(node, id) {\n\t  var schedule = node.__transition;\n\t  if (!schedule || !(schedule = schedule[id]) || schedule.state > STARTING) throw new Error(\"too late\");\n\t  return schedule;\n\t}\n\t\n\tfunction get(node, id) {\n\t  var schedule = node.__transition;\n\t  if (!schedule || !(schedule = schedule[id])) throw new Error(\"too late\");\n\t  return schedule;\n\t}\n\t\n\tfunction create(node, id, self) {\n\t  var schedules = node.__transition,\n\t      tween;\n\t\n\t  // Initialize the self timer when the transition is created.\n\t  // Note the actual delay is not known until the first callback!\n\t  schedules[id] = self;\n\t  self.timer = d3Timer.timer(schedule, 0, self.time);\n\t\n\t  function schedule(elapsed) {\n\t    self.state = SCHEDULED;\n\t    self.timer.restart(start, self.delay, self.time);\n\t\n\t    // If the elapsed delay is less than our first sleep, start immediately.\n\t    if (self.delay <= elapsed) start(elapsed - self.delay);\n\t  }\n\t\n\t  function start(elapsed) {\n\t    var i, j, n, o;\n\t\n\t    // If the state is not SCHEDULED, then we previously errored on start.\n\t    if (self.state !== SCHEDULED) return stop();\n\t\n\t    for (i in schedules) {\n\t      o = schedules[i];\n\t      if (o.name !== self.name) continue;\n\t\n\t      // While this element already has a starting transition during this frame,\n\t      // defer starting an interrupting transition until that transition has a\n\t      // chance to tick (and possibly end); see d3/d3-transition#54!\n\t      if (o.state === STARTED) return d3Timer.timeout(start);\n\t\n\t      // Interrupt the active transition, if any.\n\t      // Dispatch the interrupt event.\n\t      if (o.state === RUNNING) {\n\t        o.state = ENDED;\n\t        o.timer.stop();\n\t        o.on.call(\"interrupt\", node, node.__data__, o.index, o.group);\n\t        delete schedules[i];\n\t      }\n\t\n\t      // Cancel any pre-empted transitions. No interrupt event is dispatched\n\t      // because the cancelled transitions never started. Note that this also\n\t      // removes this transition from the pending list!\n\t      else if (+i < id) {\n\t        o.state = ENDED;\n\t        o.timer.stop();\n\t        delete schedules[i];\n\t      }\n\t    }\n\t\n\t    // Defer the first tick to end of the current frame; see d3/d3#1576.\n\t    // Note the transition may be canceled after start and before the first tick!\n\t    // Note this must be scheduled before the start event; see d3/d3-transition#16!\n\t    // Assuming this is successful, subsequent callbacks go straight to tick.\n\t    d3Timer.timeout(function() {\n\t      if (self.state === STARTED) {\n\t        self.state = RUNNING;\n\t        self.timer.restart(tick, self.delay, self.time);\n\t        tick(elapsed);\n\t      }\n\t    });\n\t\n\t    // Dispatch the start event.\n\t    // Note this must be done before the tween are initialized.\n\t    self.state = STARTING;\n\t    self.on.call(\"start\", node, node.__data__, self.index, self.group);\n\t    if (self.state !== STARTING) return; // interrupted\n\t    self.state = STARTED;\n\t\n\t    // Initialize the tween, deleting null tween.\n\t    tween = new Array(n = self.tween.length);\n\t    for (i = 0, j = -1; i < n; ++i) {\n\t      if (o = self.tween[i].value.call(node, node.__data__, self.index, self.group)) {\n\t        tween[++j] = o;\n\t      }\n\t    }\n\t    tween.length = j + 1;\n\t  }\n\t\n\t  function tick(elapsed) {\n\t    var t = elapsed < self.duration ? self.ease.call(null, elapsed / self.duration) : (self.timer.restart(stop), self.state = ENDING, 1),\n\t        i = -1,\n\t        n = tween.length;\n\t\n\t    while (++i < n) {\n\t      tween[i].call(null, t);\n\t    }\n\t\n\t    // Dispatch the end event.\n\t    if (self.state === ENDING) {\n\t      self.on.call(\"end\", node, node.__data__, self.index, self.group);\n\t      stop();\n\t    }\n\t  }\n\t\n\t  function stop() {\n\t    self.state = ENDED;\n\t    self.timer.stop();\n\t    delete schedules[id];\n\t    for (var i in schedules) return; // eslint-disable-line no-unused-vars\n\t    delete node.__transition;\n\t  }\n\t}\n\t\n\tvar interrupt = function(node, name) {\n\t  var schedules = node.__transition,\n\t      schedule,\n\t      active,\n\t      empty = true,\n\t      i;\n\t\n\t  if (!schedules) return;\n\t\n\t  name = name == null ? null : name + \"\";\n\t\n\t  for (i in schedules) {\n\t    if ((schedule = schedules[i]).name !== name) { empty = false; continue; }\n\t    active = schedule.state > STARTING && schedule.state < ENDING;\n\t    schedule.state = ENDED;\n\t    schedule.timer.stop();\n\t    if (active) schedule.on.call(\"interrupt\", node, node.__data__, schedule.index, schedule.group);\n\t    delete schedules[i];\n\t  }\n\t\n\t  if (empty) delete node.__transition;\n\t};\n\t\n\tvar selection_interrupt = function(name) {\n\t  return this.each(function() {\n\t    interrupt(this, name);\n\t  });\n\t};\n\t\n\tfunction tweenRemove(id, name) {\n\t  var tween0, tween1;\n\t  return function() {\n\t    var schedule = set(this, id),\n\t        tween = schedule.tween;\n\t\n\t    // If this node shared tween with the previous node,\n\t    // just assign the updated shared tween and we’re done!\n\t    // Otherwise, copy-on-write.\n\t    if (tween !== tween0) {\n\t      tween1 = tween0 = tween;\n\t      for (var i = 0, n = tween1.length; i < n; ++i) {\n\t        if (tween1[i].name === name) {\n\t          tween1 = tween1.slice();\n\t          tween1.splice(i, 1);\n\t          break;\n\t        }\n\t      }\n\t    }\n\t\n\t    schedule.tween = tween1;\n\t  };\n\t}\n\t\n\tfunction tweenFunction(id, name, value) {\n\t  var tween0, tween1;\n\t  if (typeof value !== \"function\") throw new Error;\n\t  return function() {\n\t    var schedule = set(this, id),\n\t        tween = schedule.tween;\n\t\n\t    // If this node shared tween with the previous node,\n\t    // just assign the updated shared tween and we’re done!\n\t    // Otherwise, copy-on-write.\n\t    if (tween !== tween0) {\n\t      tween1 = (tween0 = tween).slice();\n\t      for (var t = {name: name, value: value}, i = 0, n = tween1.length; i < n; ++i) {\n\t        if (tween1[i].name === name) {\n\t          tween1[i] = t;\n\t          break;\n\t        }\n\t      }\n\t      if (i === n) tween1.push(t);\n\t    }\n\t\n\t    schedule.tween = tween1;\n\t  };\n\t}\n\t\n\tvar transition_tween = function(name, value) {\n\t  var id = this._id;\n\t\n\t  name += \"\";\n\t\n\t  if (arguments.length < 2) {\n\t    var tween = get(this.node(), id).tween;\n\t    for (var i = 0, n = tween.length, t; i < n; ++i) {\n\t      if ((t = tween[i]).name === name) {\n\t        return t.value;\n\t      }\n\t    }\n\t    return null;\n\t  }\n\t\n\t  return this.each((value == null ? tweenRemove : tweenFunction)(id, name, value));\n\t};\n\t\n\tfunction tweenValue(transition, name, value) {\n\t  var id = transition._id;\n\t\n\t  transition.each(function() {\n\t    var schedule = set(this, id);\n\t    (schedule.value || (schedule.value = {}))[name] = value.apply(this, arguments);\n\t  });\n\t\n\t  return function(node) {\n\t    return get(node, id).value[name];\n\t  };\n\t}\n\t\n\tvar interpolate = function(a, b) {\n\t  var c;\n\t  return (typeof b === \"number\" ? d3Interpolate.interpolateNumber\n\t      : b instanceof d3Color.color ? d3Interpolate.interpolateRgb\n\t      : (c = d3Color.color(b)) ? (b = c, d3Interpolate.interpolateRgb)\n\t      : d3Interpolate.interpolateString)(a, b);\n\t};\n\t\n\tfunction attrRemove(name) {\n\t  return function() {\n\t    this.removeAttribute(name);\n\t  };\n\t}\n\t\n\tfunction attrRemoveNS(fullname) {\n\t  return function() {\n\t    this.removeAttributeNS(fullname.space, fullname.local);\n\t  };\n\t}\n\t\n\tfunction attrConstant(name, interpolate$$1, value1) {\n\t  var value00,\n\t      interpolate0;\n\t  return function() {\n\t    var value0 = this.getAttribute(name);\n\t    return value0 === value1 ? null\n\t        : value0 === value00 ? interpolate0\n\t        : interpolate0 = interpolate$$1(value00 = value0, value1);\n\t  };\n\t}\n\t\n\tfunction attrConstantNS(fullname, interpolate$$1, value1) {\n\t  var value00,\n\t      interpolate0;\n\t  return function() {\n\t    var value0 = this.getAttributeNS(fullname.space, fullname.local);\n\t    return value0 === value1 ? null\n\t        : value0 === value00 ? interpolate0\n\t        : interpolate0 = interpolate$$1(value00 = value0, value1);\n\t  };\n\t}\n\t\n\tfunction attrFunction(name, interpolate$$1, value) {\n\t  var value00,\n\t      value10,\n\t      interpolate0;\n\t  return function() {\n\t    var value0, value1 = value(this);\n\t    if (value1 == null) return void this.removeAttribute(name);\n\t    value0 = this.getAttribute(name);\n\t    return value0 === value1 ? null\n\t        : value0 === value00 && value1 === value10 ? interpolate0\n\t        : interpolate0 = interpolate$$1(value00 = value0, value10 = value1);\n\t  };\n\t}\n\t\n\tfunction attrFunctionNS(fullname, interpolate$$1, value) {\n\t  var value00,\n\t      value10,\n\t      interpolate0;\n\t  return function() {\n\t    var value0, value1 = value(this);\n\t    if (value1 == null) return void this.removeAttributeNS(fullname.space, fullname.local);\n\t    value0 = this.getAttributeNS(fullname.space, fullname.local);\n\t    return value0 === value1 ? null\n\t        : value0 === value00 && value1 === value10 ? interpolate0\n\t        : interpolate0 = interpolate$$1(value00 = value0, value10 = value1);\n\t  };\n\t}\n\t\n\tvar transition_attr = function(name, value) {\n\t  var fullname = d3Selection.namespace(name), i = fullname === \"transform\" ? d3Interpolate.interpolateTransformSvg : interpolate;\n\t  return this.attrTween(name, typeof value === \"function\"\n\t      ? (fullname.local ? attrFunctionNS : attrFunction)(fullname, i, tweenValue(this, \"attr.\" + name, value))\n\t      : value == null ? (fullname.local ? attrRemoveNS : attrRemove)(fullname)\n\t      : (fullname.local ? attrConstantNS : attrConstant)(fullname, i, value + \"\"));\n\t};\n\t\n\tfunction attrTweenNS(fullname, value) {\n\t  function tween() {\n\t    var node = this, i = value.apply(node, arguments);\n\t    return i && function(t) {\n\t      node.setAttributeNS(fullname.space, fullname.local, i(t));\n\t    };\n\t  }\n\t  tween._value = value;\n\t  return tween;\n\t}\n\t\n\tfunction attrTween(name, value) {\n\t  function tween() {\n\t    var node = this, i = value.apply(node, arguments);\n\t    return i && function(t) {\n\t      node.setAttribute(name, i(t));\n\t    };\n\t  }\n\t  tween._value = value;\n\t  return tween;\n\t}\n\t\n\tvar transition_attrTween = function(name, value) {\n\t  var key = \"attr.\" + name;\n\t  if (arguments.length < 2) return (key = this.tween(key)) && key._value;\n\t  if (value == null) return this.tween(key, null);\n\t  if (typeof value !== \"function\") throw new Error;\n\t  var fullname = d3Selection.namespace(name);\n\t  return this.tween(key, (fullname.local ? attrTweenNS : attrTween)(fullname, value));\n\t};\n\t\n\tfunction delayFunction(id, value) {\n\t  return function() {\n\t    init(this, id).delay = +value.apply(this, arguments);\n\t  };\n\t}\n\t\n\tfunction delayConstant(id, value) {\n\t  return value = +value, function() {\n\t    init(this, id).delay = value;\n\t  };\n\t}\n\t\n\tvar transition_delay = function(value) {\n\t  var id = this._id;\n\t\n\t  return arguments.length\n\t      ? this.each((typeof value === \"function\"\n\t          ? delayFunction\n\t          : delayConstant)(id, value))\n\t      : get(this.node(), id).delay;\n\t};\n\t\n\tfunction durationFunction(id, value) {\n\t  return function() {\n\t    set(this, id).duration = +value.apply(this, arguments);\n\t  };\n\t}\n\t\n\tfunction durationConstant(id, value) {\n\t  return value = +value, function() {\n\t    set(this, id).duration = value;\n\t  };\n\t}\n\t\n\tvar transition_duration = function(value) {\n\t  var id = this._id;\n\t\n\t  return arguments.length\n\t      ? this.each((typeof value === \"function\"\n\t          ? durationFunction\n\t          : durationConstant)(id, value))\n\t      : get(this.node(), id).duration;\n\t};\n\t\n\tfunction easeConstant(id, value) {\n\t  if (typeof value !== \"function\") throw new Error;\n\t  return function() {\n\t    set(this, id).ease = value;\n\t  };\n\t}\n\t\n\tvar transition_ease = function(value) {\n\t  var id = this._id;\n\t\n\t  return arguments.length\n\t      ? this.each(easeConstant(id, value))\n\t      : get(this.node(), id).ease;\n\t};\n\t\n\tvar transition_filter = function(match) {\n\t  if (typeof match !== \"function\") match = d3Selection.matcher(match);\n\t\n\t  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {\n\t    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) {\n\t      if ((node = group[i]) && match.call(node, node.__data__, i, group)) {\n\t        subgroup.push(node);\n\t      }\n\t    }\n\t  }\n\t\n\t  return new Transition(subgroups, this._parents, this._name, this._id);\n\t};\n\t\n\tvar transition_merge = function(transition) {\n\t  if (transition._id !== this._id) throw new Error;\n\t\n\t  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\t    for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) {\n\t      if (node = group0[i] || group1[i]) {\n\t        merge[i] = node;\n\t      }\n\t    }\n\t  }\n\t\n\t  for (; j < m0; ++j) {\n\t    merges[j] = groups0[j];\n\t  }\n\t\n\t  return new Transition(merges, this._parents, this._name, this._id);\n\t};\n\t\n\tfunction start(name) {\n\t  return (name + \"\").trim().split(/^|\\s+/).every(function(t) {\n\t    var i = t.indexOf(\".\");\n\t    if (i >= 0) t = t.slice(0, i);\n\t    return !t || t === \"start\";\n\t  });\n\t}\n\t\n\tfunction onFunction(id, name, listener) {\n\t  var on0, on1, sit = start(name) ? init : set;\n\t  return function() {\n\t    var schedule = sit(this, id),\n\t        on = schedule.on;\n\t\n\t    // If this node shared a dispatch with the previous node,\n\t    // just assign the updated shared dispatch and we’re done!\n\t    // Otherwise, copy-on-write.\n\t    if (on !== on0) (on1 = (on0 = on).copy()).on(name, listener);\n\t\n\t    schedule.on = on1;\n\t  };\n\t}\n\t\n\tvar transition_on = function(name, listener) {\n\t  var id = this._id;\n\t\n\t  return arguments.length < 2\n\t      ? get(this.node(), id).on.on(name)\n\t      : this.each(onFunction(id, name, listener));\n\t};\n\t\n\tfunction removeFunction(id) {\n\t  return function() {\n\t    var parent = this.parentNode;\n\t    for (var i in this.__transition) if (+i !== id) return;\n\t    if (parent) parent.removeChild(this);\n\t  };\n\t}\n\t\n\tvar transition_remove = function() {\n\t  return this.on(\"end.remove\", removeFunction(this._id));\n\t};\n\t\n\tvar transition_select = function(select) {\n\t  var name = this._name,\n\t      id = this._id;\n\t\n\t  if (typeof select !== \"function\") select = d3Selection.selector(select);\n\t\n\t  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {\n\t    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) {\n\t      if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) {\n\t        if (\"__data__\" in node) subnode.__data__ = node.__data__;\n\t        subgroup[i] = subnode;\n\t        schedule(subgroup[i], name, id, i, subgroup, get(node, id));\n\t      }\n\t    }\n\t  }\n\t\n\t  return new Transition(subgroups, this._parents, name, id);\n\t};\n\t\n\tvar transition_selectAll = function(select) {\n\t  var name = this._name,\n\t      id = this._id;\n\t\n\t  if (typeof select !== \"function\") select = d3Selection.selectorAll(select);\n\t\n\t  for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) {\n\t    for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {\n\t      if (node = group[i]) {\n\t        for (var children = select.call(node, node.__data__, i, group), child, inherit = get(node, id), k = 0, l = children.length; k < l; ++k) {\n\t          if (child = children[k]) {\n\t            schedule(child, name, id, k, children, inherit);\n\t          }\n\t        }\n\t        subgroups.push(children);\n\t        parents.push(node);\n\t      }\n\t    }\n\t  }\n\t\n\t  return new Transition(subgroups, parents, name, id);\n\t};\n\t\n\tvar Selection = d3Selection.selection.prototype.constructor;\n\t\n\tvar transition_selection = function() {\n\t  return new Selection(this._groups, this._parents);\n\t};\n\t\n\tfunction styleRemove(name, interpolate$$1) {\n\t  var value00,\n\t      value10,\n\t      interpolate0;\n\t  return function() {\n\t    var value0 = d3Selection.style(this, name),\n\t        value1 = (this.style.removeProperty(name), d3Selection.style(this, name));\n\t    return value0 === value1 ? null\n\t        : value0 === value00 && value1 === value10 ? interpolate0\n\t        : interpolate0 = interpolate$$1(value00 = value0, value10 = value1);\n\t  };\n\t}\n\t\n\tfunction styleRemoveEnd(name) {\n\t  return function() {\n\t    this.style.removeProperty(name);\n\t  };\n\t}\n\t\n\tfunction styleConstant(name, interpolate$$1, value1) {\n\t  var value00,\n\t      interpolate0;\n\t  return function() {\n\t    var value0 = d3Selection.style(this, name);\n\t    return value0 === value1 ? null\n\t        : value0 === value00 ? interpolate0\n\t        : interpolate0 = interpolate$$1(value00 = value0, value1);\n\t  };\n\t}\n\t\n\tfunction styleFunction(name, interpolate$$1, value) {\n\t  var value00,\n\t      value10,\n\t      interpolate0;\n\t  return function() {\n\t    var value0 = d3Selection.style(this, name),\n\t        value1 = value(this);\n\t    if (value1 == null) value1 = (this.style.removeProperty(name), d3Selection.style(this, name));\n\t    return value0 === value1 ? null\n\t        : value0 === value00 && value1 === value10 ? interpolate0\n\t        : interpolate0 = interpolate$$1(value00 = value0, value10 = value1);\n\t  };\n\t}\n\t\n\tvar transition_style = function(name, value, priority) {\n\t  var i = (name += \"\") === \"transform\" ? d3Interpolate.interpolateTransformCss : interpolate;\n\t  return value == null ? this\n\t          .styleTween(name, styleRemove(name, i))\n\t          .on(\"end.style.\" + name, styleRemoveEnd(name))\n\t      : this.styleTween(name, typeof value === \"function\"\n\t          ? styleFunction(name, i, tweenValue(this, \"style.\" + name, value))\n\t          : styleConstant(name, i, value + \"\"), priority);\n\t};\n\t\n\tfunction styleTween(name, value, priority) {\n\t  function tween() {\n\t    var node = this, i = value.apply(node, arguments);\n\t    return i && function(t) {\n\t      node.style.setProperty(name, i(t), priority);\n\t    };\n\t  }\n\t  tween._value = value;\n\t  return tween;\n\t}\n\t\n\tvar transition_styleTween = function(name, value, priority) {\n\t  var key = \"style.\" + (name += \"\");\n\t  if (arguments.length < 2) return (key = this.tween(key)) && key._value;\n\t  if (value == null) return this.tween(key, null);\n\t  if (typeof value !== \"function\") throw new Error;\n\t  return this.tween(key, styleTween(name, value, priority == null ? \"\" : priority));\n\t};\n\t\n\tfunction textConstant(value) {\n\t  return function() {\n\t    this.textContent = value;\n\t  };\n\t}\n\t\n\tfunction textFunction(value) {\n\t  return function() {\n\t    var value1 = value(this);\n\t    this.textContent = value1 == null ? \"\" : value1;\n\t  };\n\t}\n\t\n\tvar transition_text = function(value) {\n\t  return this.tween(\"text\", typeof value === \"function\"\n\t      ? textFunction(tweenValue(this, \"text\", value))\n\t      : textConstant(value == null ? \"\" : value + \"\"));\n\t};\n\t\n\tvar transition_transition = function() {\n\t  var name = this._name,\n\t      id0 = this._id,\n\t      id1 = newId();\n\t\n\t  for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) {\n\t    for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {\n\t      if (node = group[i]) {\n\t        var inherit = get(node, id0);\n\t        schedule(node, name, id1, i, group, {\n\t          time: inherit.time + inherit.delay + inherit.duration,\n\t          delay: 0,\n\t          duration: inherit.duration,\n\t          ease: inherit.ease\n\t        });\n\t      }\n\t    }\n\t  }\n\t\n\t  return new Transition(groups, this._parents, name, id1);\n\t};\n\t\n\tvar id = 0;\n\t\n\tfunction Transition(groups, parents, name, id) {\n\t  this._groups = groups;\n\t  this._parents = parents;\n\t  this._name = name;\n\t  this._id = id;\n\t}\n\t\n\tfunction transition(name) {\n\t  return d3Selection.selection().transition(name);\n\t}\n\t\n\tfunction newId() {\n\t  return ++id;\n\t}\n\t\n\tvar selection_prototype = d3Selection.selection.prototype;\n\t\n\tTransition.prototype = transition.prototype = {\n\t  constructor: Transition,\n\t  select: transition_select,\n\t  selectAll: transition_selectAll,\n\t  filter: transition_filter,\n\t  merge: transition_merge,\n\t  selection: transition_selection,\n\t  transition: transition_transition,\n\t  call: selection_prototype.call,\n\t  nodes: selection_prototype.nodes,\n\t  node: selection_prototype.node,\n\t  size: selection_prototype.size,\n\t  empty: selection_prototype.empty,\n\t  each: selection_prototype.each,\n\t  on: transition_on,\n\t  attr: transition_attr,\n\t  attrTween: transition_attrTween,\n\t  style: transition_style,\n\t  styleTween: transition_styleTween,\n\t  text: transition_text,\n\t  remove: transition_remove,\n\t  tween: transition_tween,\n\t  delay: transition_delay,\n\t  duration: transition_duration,\n\t  ease: transition_ease\n\t};\n\t\n\tvar defaultTiming = {\n\t  time: null, // Set on use.\n\t  delay: 0,\n\t  duration: 250,\n\t  ease: d3Ease.easeCubicInOut\n\t};\n\t\n\tfunction inherit(node, id) {\n\t  var timing;\n\t  while (!(timing = node.__transition) || !(timing = timing[id])) {\n\t    if (!(node = node.parentNode)) {\n\t      return defaultTiming.time = d3Timer.now(), defaultTiming;\n\t    }\n\t  }\n\t  return timing;\n\t}\n\t\n\tvar selection_transition = function(name) {\n\t  var id,\n\t      timing;\n\t\n\t  if (name instanceof Transition) {\n\t    id = name._id, name = name._name;\n\t  } else {\n\t    id = newId(), (timing = defaultTiming).time = d3Timer.now(), name = name == null ? null : name + \"\";\n\t  }\n\t\n\t  for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) {\n\t    for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {\n\t      if (node = group[i]) {\n\t        schedule(node, name, id, i, group, timing || inherit(node, id));\n\t      }\n\t    }\n\t  }\n\t\n\t  return new Transition(groups, this._parents, name, id);\n\t};\n\t\n\td3Selection.selection.prototype.interrupt = selection_interrupt;\n\td3Selection.selection.prototype.transition = selection_transition;\n\t\n\tvar root = [null];\n\t\n\tvar active = function(node, name) {\n\t  var schedules = node.__transition,\n\t      schedule,\n\t      i;\n\t\n\t  if (schedules) {\n\t    name = name == null ? null : name + \"\";\n\t    for (i in schedules) {\n\t      if ((schedule = schedules[i]).state > SCHEDULED && schedule.name === name) {\n\t        return new Transition([[node]], root, name, +i);\n\t      }\n\t    }\n\t  }\n\t\n\t  return null;\n\t};\n\t\n\texports.transition = transition;\n\texports.active = active;\n\texports.interrupt = interrupt;\n\t\n\tObject.defineProperty(exports, '__esModule', { value: true });\n\t\n\t})));\n\n\n/***/ }),\n/* 14 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t// https://d3js.org/d3-timer/ Version 1.0.6. Copyright 2017 Mike Bostock.\n\t(function (global, factory) {\n\t\t true ? factory(exports) :\n\t\ttypeof define === 'function' && define.amd ? define(['exports'], factory) :\n\t\t(factory((global.d3 = global.d3 || {})));\n\t}(this, (function (exports) { 'use strict';\n\t\n\tvar frame = 0;\n\tvar timeout = 0;\n\tvar interval = 0;\n\tvar pokeDelay = 1000;\n\tvar taskHead;\n\tvar taskTail;\n\tvar clockLast = 0;\n\tvar clockNow = 0;\n\tvar clockSkew = 0;\n\tvar clock = typeof performance === \"object\" && performance.now ? performance : Date;\n\tvar setFrame = typeof window === \"object\" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : function(f) { setTimeout(f, 17); };\n\t\n\tfunction now() {\n\t  return clockNow || (setFrame(clearNow), clockNow = clock.now() + clockSkew);\n\t}\n\t\n\tfunction clearNow() {\n\t  clockNow = 0;\n\t}\n\t\n\tfunction Timer() {\n\t  this._call =\n\t  this._time =\n\t  this._next = null;\n\t}\n\t\n\tTimer.prototype = timer.prototype = {\n\t  constructor: Timer,\n\t  restart: function(callback, delay, time) {\n\t    if (typeof callback !== \"function\") throw new TypeError(\"callback is not a function\");\n\t    time = (time == null ? now() : +time) + (delay == null ? 0 : +delay);\n\t    if (!this._next && taskTail !== this) {\n\t      if (taskTail) taskTail._next = this;\n\t      else taskHead = this;\n\t      taskTail = this;\n\t    }\n\t    this._call = callback;\n\t    this._time = time;\n\t    sleep();\n\t  },\n\t  stop: function() {\n\t    if (this._call) {\n\t      this._call = null;\n\t      this._time = Infinity;\n\t      sleep();\n\t    }\n\t  }\n\t};\n\t\n\tfunction timer(callback, delay, time) {\n\t  var t = new Timer;\n\t  t.restart(callback, delay, time);\n\t  return t;\n\t}\n\t\n\tfunction timerFlush() {\n\t  now(); // Get the current time, if not already set.\n\t  ++frame; // Pretend we’ve set an alarm, if we haven’t already.\n\t  var t = taskHead, e;\n\t  while (t) {\n\t    if ((e = clockNow - t._time) >= 0) t._call.call(null, e);\n\t    t = t._next;\n\t  }\n\t  --frame;\n\t}\n\t\n\tfunction wake() {\n\t  clockNow = (clockLast = clock.now()) + clockSkew;\n\t  frame = timeout = 0;\n\t  try {\n\t    timerFlush();\n\t  } finally {\n\t    frame = 0;\n\t    nap();\n\t    clockNow = 0;\n\t  }\n\t}\n\t\n\tfunction poke() {\n\t  var now = clock.now(), delay = now - clockLast;\n\t  if (delay > pokeDelay) clockSkew -= delay, clockLast = now;\n\t}\n\t\n\tfunction nap() {\n\t  var t0, t1 = taskHead, t2, time = Infinity;\n\t  while (t1) {\n\t    if (t1._call) {\n\t      if (time > t1._time) time = t1._time;\n\t      t0 = t1, t1 = t1._next;\n\t    } else {\n\t      t2 = t1._next, t1._next = null;\n\t      t1 = t0 ? t0._next = t2 : taskHead = t2;\n\t    }\n\t  }\n\t  taskTail = t0;\n\t  sleep(time);\n\t}\n\t\n\tfunction sleep(time) {\n\t  if (frame) return; // Soonest alarm already set, or will be.\n\t  if (timeout) timeout = clearTimeout(timeout);\n\t  var delay = time - clockNow;\n\t  if (delay > 24) {\n\t    if (time < Infinity) timeout = setTimeout(wake, delay);\n\t    if (interval) interval = clearInterval(interval);\n\t  } else {\n\t    if (!interval) clockLast = clockNow, interval = setInterval(poke, pokeDelay);\n\t    frame = 1, setFrame(wake);\n\t  }\n\t}\n\t\n\tvar timeout$1 = function(callback, delay, time) {\n\t  var t = new Timer;\n\t  delay = delay == null ? 0 : +delay;\n\t  t.restart(function(elapsed) {\n\t    t.stop();\n\t    callback(elapsed + delay);\n\t  }, delay, time);\n\t  return t;\n\t};\n\t\n\tvar interval$1 = function(callback, delay, time) {\n\t  var t = new Timer, total = delay;\n\t  if (delay == null) return t.restart(callback, delay, time), t;\n\t  delay = +delay, time = time == null ? now() : +time;\n\t  t.restart(function tick(elapsed) {\n\t    elapsed += total;\n\t    t.restart(tick, total += delay, time);\n\t    callback(elapsed);\n\t  }, delay, time);\n\t  return t;\n\t};\n\t\n\texports.now = now;\n\texports.timer = timer;\n\texports.timerFlush = timerFlush;\n\texports.timeout = timeout$1;\n\texports.interval = interval$1;\n\t\n\tObject.defineProperty(exports, '__esModule', { value: true });\n\t\n\t})));\n\n\n/***/ }),\n/* 15 */,\n/* 16 */,\n/* 17 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_RESULT__;'use strict';\n\t\n\t!(__WEBPACK_AMD_DEFINE_RESULT__ = function () {\n\t\n\t    // Color Gradients\n\t    var britechartGradients = {\n\t        greenBlue: ['#39C7EA', '#4CDCBA'],\n\t        orangePink: ['#FBC670', '#F766B8'],\n\t        bluePurple: ['#3DC3C9', '#824a9e']\n\t    };\n\t\n\t    // Color Schemas\n\t    // Standard Color Schema for Britecharts\n\t    var britecharts = ['#6aedc7', //green\n\t    '#39c2c9', //blue\n\t    '#ffce00', //yellow\n\t    '#ffa71a', //orange\n\t    '#f866b9', //pink\n\t    '#998ce3' //purple\n\t    ];\n\t\n\t    // Grey Schema for Britecharts\n\t    var grey = ['#F8F8FA', '#EFF2F5', '#D2D6DF', '#C3C6CF', '#ADB0B6', '#666A73', '#45494E', '#363A43', '#282C35'];\n\t\n\t    // Orange Palette\n\t    var orange = ['#fcc870', '#ffa71a', '#fb8825', '#f6682f', '#db5a2c', '#bf4c28', '#a43b1c', '#892a10', '#f9e9c5'];\n\t    // Blue Palette\n\t    var blueGreen = ['#ccf7f6', '#70e4e0', '#00d8d2', '#00acaf', '#007f8c', '#005e66', '#003c3f', '#002d2f', '#0d2223'];\n\t    // LightBlue Palette\n\t    var teal = ['#ccfffe', '#94f7f4', '#00fff8', '#1de1e1', '#39c2c9', '#2e9a9d', '#227270', '#1a5957', '#133f3e'];\n\t    // Green Palette\n\t    var green = ['#edfff7', '#d7ffef', '#c0ffe7', '#95f5d7', '#6aedc7', '#59c3a3', '#479980', '#34816a', '#206953'];\n\t    // Yellow Palette\n\t    var yellow = ['#f9f2b3', '#fbe986', '#fce05a', '#fed72d', '#ffce00', '#fcc11c', '#f9b438', '#eda629', '#e09819'];\n\t    // Pink Palette\n\t    var pink = ['#fdd1ea', '#fb9cd2', '#f866b9', '#fc40b6', '#ff1ab3', '#e3239d', '#c62c86', '#a62073', '#85135f'];\n\t    // Purple Palette\n\t    var purple = ['#ddd6fc', '#bbb1f0', '#998ce3', '#8e6bc1', '#824a9e', '#77337f', '#6b1c60', '#591650', '#470f3f'];\n\t    // Red Palette\n\t    var red = ['#ffd8d4', '#ffb5b0', '#ff938c', '#ff766c', '#ff584c', '#f04b42', '#e03d38', '#be2e29', '#9c1e19'];\n\t\n\t    var aloeGreen = ['#7bdcc0'];\n\t\n\t    return {\n\t        colorSchemas: {\n\t            britecharts: britecharts,\n\t            grey: grey,\n\t            orange: orange,\n\t            blueGreen: blueGreen,\n\t            teal: teal,\n\t            green: green,\n\t            yellow: yellow,\n\t            pink: pink,\n\t            purple: purple,\n\t            red: red\n\t        },\n\t        colorSchemasHuman: {\n\t            'britecharts': 'Britecharts Default',\n\t            'grey': 'Britecharts Grey',\n\t            'orange': 'Orange',\n\t            'blueGreen': 'Blue',\n\t            'teal': 'Light Blue',\n\t            'green': 'Green',\n\t            'yellow': 'Yellow',\n\t            'pink': 'Pink',\n\t            'purple': 'Purple',\n\t            'red': 'Red'\n\t        },\n\t        singleColors: {\n\t            aloeGreen: aloeGreen\n\t        },\n\t        colorGradients: britechartGradients,\n\t        colorGradientsHuman: {\n\t            greenBlue: 'Green To Blue',\n\t            orangePink: 'Orange to Pink',\n\t            bluePurple: 'Blue to Purple'\n\t        }\n\t    };\n\t}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\n/***/ }),\n/* 18 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_RESULT__;'use strict';\n\t\n\t!(__WEBPACK_AMD_DEFINE_RESULT__ = function () {\n\t\n\t    var axisTimeCombinations = {\n\t        MINUTE_HOUR: 'minute-hour',\n\t        HOUR_DAY: 'hour-daymonth',\n\t        DAY_MONTH: 'day-month',\n\t        MONTH_YEAR: 'month-year'\n\t    };\n\t\n\t    var timeBenchmarks = {\n\t        ONE_AND_A_HALF_YEARS: 47304000000,\n\t        ONE_YEAR: 31536000365,\n\t        ONE_DAY: 86400001\n\t    };\n\t\n\t    return {\n\t        axisTimeCombinations: axisTimeCombinations,\n\t        timeBenchmarks: timeBenchmarks,\n\t        lineGradientId: 'lineGradientId'\n\t    };\n\t}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\n/***/ }),\n/* 19 */,\n/* 20 */,\n/* 21 */,\n/* 22 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t// https://d3js.org/d3-brush/ Version 1.0.4. Copyright 2017 Mike Bostock.\n\t(function (global, factory) {\n\t\t true ? factory(exports, __webpack_require__(5), __webpack_require__(23), __webpack_require__(9), __webpack_require__(12), __webpack_require__(13)) :\n\t\ttypeof define === 'function' && define.amd ? define(['exports', 'd3-dispatch', 'd3-drag', 'd3-interpolate', 'd3-selection', 'd3-transition'], factory) :\n\t\t(factory((global.d3 = global.d3 || {}),global.d3,global.d3,global.d3,global.d3,global.d3));\n\t}(this, (function (exports,d3Dispatch,d3Drag,d3Interpolate,d3Selection,d3Transition) { 'use strict';\n\t\n\tvar constant = function(x) {\n\t  return function() {\n\t    return x;\n\t  };\n\t};\n\t\n\tvar BrushEvent = function(target, type, selection) {\n\t  this.target = target;\n\t  this.type = type;\n\t  this.selection = selection;\n\t};\n\t\n\tfunction nopropagation() {\n\t  d3Selection.event.stopImmediatePropagation();\n\t}\n\t\n\tvar noevent = function() {\n\t  d3Selection.event.preventDefault();\n\t  d3Selection.event.stopImmediatePropagation();\n\t};\n\t\n\tvar MODE_DRAG = {name: \"drag\"};\n\tvar MODE_SPACE = {name: \"space\"};\n\tvar MODE_HANDLE = {name: \"handle\"};\n\tvar MODE_CENTER = {name: \"center\"};\n\t\n\tvar X = {\n\t  name: \"x\",\n\t  handles: [\"e\", \"w\"].map(type),\n\t  input: function(x, e) { return x && [[x[0], e[0][1]], [x[1], e[1][1]]]; },\n\t  output: function(xy) { return xy && [xy[0][0], xy[1][0]]; }\n\t};\n\t\n\tvar Y = {\n\t  name: \"y\",\n\t  handles: [\"n\", \"s\"].map(type),\n\t  input: function(y, e) { return y && [[e[0][0], y[0]], [e[1][0], y[1]]]; },\n\t  output: function(xy) { return xy && [xy[0][1], xy[1][1]]; }\n\t};\n\t\n\tvar XY = {\n\t  name: \"xy\",\n\t  handles: [\"n\", \"e\", \"s\", \"w\", \"nw\", \"ne\", \"se\", \"sw\"].map(type),\n\t  input: function(xy) { return xy; },\n\t  output: function(xy) { return xy; }\n\t};\n\t\n\tvar cursors = {\n\t  overlay: \"crosshair\",\n\t  selection: \"move\",\n\t  n: \"ns-resize\",\n\t  e: \"ew-resize\",\n\t  s: \"ns-resize\",\n\t  w: \"ew-resize\",\n\t  nw: \"nwse-resize\",\n\t  ne: \"nesw-resize\",\n\t  se: \"nwse-resize\",\n\t  sw: \"nesw-resize\"\n\t};\n\t\n\tvar flipX = {\n\t  e: \"w\",\n\t  w: \"e\",\n\t  nw: \"ne\",\n\t  ne: \"nw\",\n\t  se: \"sw\",\n\t  sw: \"se\"\n\t};\n\t\n\tvar flipY = {\n\t  n: \"s\",\n\t  s: \"n\",\n\t  nw: \"sw\",\n\t  ne: \"se\",\n\t  se: \"ne\",\n\t  sw: \"nw\"\n\t};\n\t\n\tvar signsX = {\n\t  overlay: +1,\n\t  selection: +1,\n\t  n: null,\n\t  e: +1,\n\t  s: null,\n\t  w: -1,\n\t  nw: -1,\n\t  ne: +1,\n\t  se: +1,\n\t  sw: -1\n\t};\n\t\n\tvar signsY = {\n\t  overlay: +1,\n\t  selection: +1,\n\t  n: -1,\n\t  e: null,\n\t  s: +1,\n\t  w: null,\n\t  nw: -1,\n\t  ne: -1,\n\t  se: +1,\n\t  sw: +1\n\t};\n\t\n\tfunction type(t) {\n\t  return {type: t};\n\t}\n\t\n\t// Ignore right-click, since that should open the context menu.\n\tfunction defaultFilter() {\n\t  return !d3Selection.event.button;\n\t}\n\t\n\tfunction defaultExtent() {\n\t  var svg = this.ownerSVGElement || this;\n\t  return [[0, 0], [svg.width.baseVal.value, svg.height.baseVal.value]];\n\t}\n\t\n\t// Like d3.local, but with the name “__brush” rather than auto-generated.\n\tfunction local(node) {\n\t  while (!node.__brush) if (!(node = node.parentNode)) return;\n\t  return node.__brush;\n\t}\n\t\n\tfunction empty(extent) {\n\t  return extent[0][0] === extent[1][0]\n\t      || extent[0][1] === extent[1][1];\n\t}\n\t\n\tfunction brushSelection(node) {\n\t  var state = node.__brush;\n\t  return state ? state.dim.output(state.selection) : null;\n\t}\n\t\n\tfunction brushX() {\n\t  return brush$1(X);\n\t}\n\t\n\tfunction brushY() {\n\t  return brush$1(Y);\n\t}\n\t\n\tvar brush = function() {\n\t  return brush$1(XY);\n\t};\n\t\n\tfunction brush$1(dim) {\n\t  var extent = defaultExtent,\n\t      filter = defaultFilter,\n\t      listeners = d3Dispatch.dispatch(brush, \"start\", \"brush\", \"end\"),\n\t      handleSize = 6,\n\t      touchending;\n\t\n\t  function brush(group) {\n\t    var overlay = group\n\t        .property(\"__brush\", initialize)\n\t      .selectAll(\".overlay\")\n\t      .data([type(\"overlay\")]);\n\t\n\t    overlay.enter().append(\"rect\")\n\t        .attr(\"class\", \"overlay\")\n\t        .attr(\"pointer-events\", \"all\")\n\t        .attr(\"cursor\", cursors.overlay)\n\t      .merge(overlay)\n\t        .each(function() {\n\t          var extent = local(this).extent;\n\t          d3Selection.select(this)\n\t              .attr(\"x\", extent[0][0])\n\t              .attr(\"y\", extent[0][1])\n\t              .attr(\"width\", extent[1][0] - extent[0][0])\n\t              .attr(\"height\", extent[1][1] - extent[0][1]);\n\t        });\n\t\n\t    group.selectAll(\".selection\")\n\t      .data([type(\"selection\")])\n\t      .enter().append(\"rect\")\n\t        .attr(\"class\", \"selection\")\n\t        .attr(\"cursor\", cursors.selection)\n\t        .attr(\"fill\", \"#777\")\n\t        .attr(\"fill-opacity\", 0.3)\n\t        .attr(\"stroke\", \"#fff\")\n\t        .attr(\"shape-rendering\", \"crispEdges\");\n\t\n\t    var handle = group.selectAll(\".handle\")\n\t      .data(dim.handles, function(d) { return d.type; });\n\t\n\t    handle.exit().remove();\n\t\n\t    handle.enter().append(\"rect\")\n\t        .attr(\"class\", function(d) { return \"handle handle--\" + d.type; })\n\t        .attr(\"cursor\", function(d) { return cursors[d.type]; });\n\t\n\t    group\n\t        .each(redraw)\n\t        .attr(\"fill\", \"none\")\n\t        .attr(\"pointer-events\", \"all\")\n\t        .style(\"-webkit-tap-highlight-color\", \"rgba(0,0,0,0)\")\n\t        .on(\"mousedown.brush touchstart.brush\", started);\n\t  }\n\t\n\t  brush.move = function(group, selection) {\n\t    if (group.selection) {\n\t      group\n\t          .on(\"start.brush\", function() { emitter(this, arguments).beforestart().start(); })\n\t          .on(\"interrupt.brush end.brush\", function() { emitter(this, arguments).end(); })\n\t          .tween(\"brush\", function() {\n\t            var that = this,\n\t                state = that.__brush,\n\t                emit = emitter(that, arguments),\n\t                selection0 = state.selection,\n\t                selection1 = dim.input(typeof selection === \"function\" ? selection.apply(this, arguments) : selection, state.extent),\n\t                i = d3Interpolate.interpolate(selection0, selection1);\n\t\n\t            function tween(t) {\n\t              state.selection = t === 1 && empty(selection1) ? null : i(t);\n\t              redraw.call(that);\n\t              emit.brush();\n\t            }\n\t\n\t            return selection0 && selection1 ? tween : tween(1);\n\t          });\n\t    } else {\n\t      group\n\t          .each(function() {\n\t            var that = this,\n\t                args = arguments,\n\t                state = that.__brush,\n\t                selection1 = dim.input(typeof selection === \"function\" ? selection.apply(that, args) : selection, state.extent),\n\t                emit = emitter(that, args).beforestart();\n\t\n\t            d3Transition.interrupt(that);\n\t            state.selection = selection1 == null || empty(selection1) ? null : selection1;\n\t            redraw.call(that);\n\t            emit.start().brush().end();\n\t          });\n\t    }\n\t  };\n\t\n\t  function redraw() {\n\t    var group = d3Selection.select(this),\n\t        selection = local(this).selection;\n\t\n\t    if (selection) {\n\t      group.selectAll(\".selection\")\n\t          .style(\"display\", null)\n\t          .attr(\"x\", selection[0][0])\n\t          .attr(\"y\", selection[0][1])\n\t          .attr(\"width\", selection[1][0] - selection[0][0])\n\t          .attr(\"height\", selection[1][1] - selection[0][1]);\n\t\n\t      group.selectAll(\".handle\")\n\t          .style(\"display\", null)\n\t          .attr(\"x\", function(d) { return d.type[d.type.length - 1] === \"e\" ? selection[1][0] - handleSize / 2 : selection[0][0] - handleSize / 2; })\n\t          .attr(\"y\", function(d) { return d.type[0] === \"s\" ? selection[1][1] - handleSize / 2 : selection[0][1] - handleSize / 2; })\n\t          .attr(\"width\", function(d) { return d.type === \"n\" || d.type === \"s\" ? selection[1][0] - selection[0][0] + handleSize : handleSize; })\n\t          .attr(\"height\", function(d) { return d.type === \"e\" || d.type === \"w\" ? selection[1][1] - selection[0][1] + handleSize : handleSize; });\n\t    }\n\t\n\t    else {\n\t      group.selectAll(\".selection,.handle\")\n\t          .style(\"display\", \"none\")\n\t          .attr(\"x\", null)\n\t          .attr(\"y\", null)\n\t          .attr(\"width\", null)\n\t          .attr(\"height\", null);\n\t    }\n\t  }\n\t\n\t  function emitter(that, args) {\n\t    return that.__brush.emitter || new Emitter(that, args);\n\t  }\n\t\n\t  function Emitter(that, args) {\n\t    this.that = that;\n\t    this.args = args;\n\t    this.state = that.__brush;\n\t    this.active = 0;\n\t  }\n\t\n\t  Emitter.prototype = {\n\t    beforestart: function() {\n\t      if (++this.active === 1) this.state.emitter = this, this.starting = true;\n\t      return this;\n\t    },\n\t    start: function() {\n\t      if (this.starting) this.starting = false, this.emit(\"start\");\n\t      return this;\n\t    },\n\t    brush: function() {\n\t      this.emit(\"brush\");\n\t      return this;\n\t    },\n\t    end: function() {\n\t      if (--this.active === 0) delete this.state.emitter, this.emit(\"end\");\n\t      return this;\n\t    },\n\t    emit: function(type) {\n\t      d3Selection.customEvent(new BrushEvent(brush, type, dim.output(this.state.selection)), listeners.apply, listeners, [type, this.that, this.args]);\n\t    }\n\t  };\n\t\n\t  function started() {\n\t    if (d3Selection.event.touches) { if (d3Selection.event.changedTouches.length < d3Selection.event.touches.length) return noevent(); }\n\t    else if (touchending) return;\n\t    if (!filter.apply(this, arguments)) return;\n\t\n\t    var that = this,\n\t        type = d3Selection.event.target.__data__.type,\n\t        mode = (d3Selection.event.metaKey ? type = \"overlay\" : type) === \"selection\" ? MODE_DRAG : (d3Selection.event.altKey ? MODE_CENTER : MODE_HANDLE),\n\t        signX = dim === Y ? null : signsX[type],\n\t        signY = dim === X ? null : signsY[type],\n\t        state = local(that),\n\t        extent = state.extent,\n\t        selection = state.selection,\n\t        W = extent[0][0], w0, w1,\n\t        N = extent[0][1], n0, n1,\n\t        E = extent[1][0], e0, e1,\n\t        S = extent[1][1], s0, s1,\n\t        dx,\n\t        dy,\n\t        moving,\n\t        shifting = signX && signY && d3Selection.event.shiftKey,\n\t        lockX,\n\t        lockY,\n\t        point0 = d3Selection.mouse(that),\n\t        point = point0,\n\t        emit = emitter(that, arguments).beforestart();\n\t\n\t    if (type === \"overlay\") {\n\t      state.selection = selection = [\n\t        [w0 = dim === Y ? W : point0[0], n0 = dim === X ? N : point0[1]],\n\t        [e0 = dim === Y ? E : w0, s0 = dim === X ? S : n0]\n\t      ];\n\t    } else {\n\t      w0 = selection[0][0];\n\t      n0 = selection[0][1];\n\t      e0 = selection[1][0];\n\t      s0 = selection[1][1];\n\t    }\n\t\n\t    w1 = w0;\n\t    n1 = n0;\n\t    e1 = e0;\n\t    s1 = s0;\n\t\n\t    var group = d3Selection.select(that)\n\t        .attr(\"pointer-events\", \"none\");\n\t\n\t    var overlay = group.selectAll(\".overlay\")\n\t        .attr(\"cursor\", cursors[type]);\n\t\n\t    if (d3Selection.event.touches) {\n\t      group\n\t          .on(\"touchmove.brush\", moved, true)\n\t          .on(\"touchend.brush touchcancel.brush\", ended, true);\n\t    } else {\n\t      var view = d3Selection.select(d3Selection.event.view)\n\t          .on(\"keydown.brush\", keydowned, true)\n\t          .on(\"keyup.brush\", keyupped, true)\n\t          .on(\"mousemove.brush\", moved, true)\n\t          .on(\"mouseup.brush\", ended, true);\n\t\n\t      d3Drag.dragDisable(d3Selection.event.view);\n\t    }\n\t\n\t    nopropagation();\n\t    d3Transition.interrupt(that);\n\t    redraw.call(that);\n\t    emit.start();\n\t\n\t    function moved() {\n\t      var point1 = d3Selection.mouse(that);\n\t      if (shifting && !lockX && !lockY) {\n\t        if (Math.abs(point1[0] - point[0]) > Math.abs(point1[1] - point[1])) lockY = true;\n\t        else lockX = true;\n\t      }\n\t      point = point1;\n\t      moving = true;\n\t      noevent();\n\t      move();\n\t    }\n\t\n\t    function move() {\n\t      var t;\n\t\n\t      dx = point[0] - point0[0];\n\t      dy = point[1] - point0[1];\n\t\n\t      switch (mode) {\n\t        case MODE_SPACE:\n\t        case MODE_DRAG: {\n\t          if (signX) dx = Math.max(W - w0, Math.min(E - e0, dx)), w1 = w0 + dx, e1 = e0 + dx;\n\t          if (signY) dy = Math.max(N - n0, Math.min(S - s0, dy)), n1 = n0 + dy, s1 = s0 + dy;\n\t          break;\n\t        }\n\t        case MODE_HANDLE: {\n\t          if (signX < 0) dx = Math.max(W - w0, Math.min(E - w0, dx)), w1 = w0 + dx, e1 = e0;\n\t          else if (signX > 0) dx = Math.max(W - e0, Math.min(E - e0, dx)), w1 = w0, e1 = e0 + dx;\n\t          if (signY < 0) dy = Math.max(N - n0, Math.min(S - n0, dy)), n1 = n0 + dy, s1 = s0;\n\t          else if (signY > 0) dy = Math.max(N - s0, Math.min(S - s0, dy)), n1 = n0, s1 = s0 + dy;\n\t          break;\n\t        }\n\t        case MODE_CENTER: {\n\t          if (signX) w1 = Math.max(W, Math.min(E, w0 - dx * signX)), e1 = Math.max(W, Math.min(E, e0 + dx * signX));\n\t          if (signY) n1 = Math.max(N, Math.min(S, n0 - dy * signY)), s1 = Math.max(N, Math.min(S, s0 + dy * signY));\n\t          break;\n\t        }\n\t      }\n\t\n\t      if (e1 < w1) {\n\t        signX *= -1;\n\t        t = w0, w0 = e0, e0 = t;\n\t        t = w1, w1 = e1, e1 = t;\n\t        if (type in flipX) overlay.attr(\"cursor\", cursors[type = flipX[type]]);\n\t      }\n\t\n\t      if (s1 < n1) {\n\t        signY *= -1;\n\t        t = n0, n0 = s0, s0 = t;\n\t        t = n1, n1 = s1, s1 = t;\n\t        if (type in flipY) overlay.attr(\"cursor\", cursors[type = flipY[type]]);\n\t      }\n\t\n\t      if (state.selection) selection = state.selection; // May be set by brush.move!\n\t      if (lockX) w1 = selection[0][0], e1 = selection[1][0];\n\t      if (lockY) n1 = selection[0][1], s1 = selection[1][1];\n\t\n\t      if (selection[0][0] !== w1\n\t          || selection[0][1] !== n1\n\t          || selection[1][0] !== e1\n\t          || selection[1][1] !== s1) {\n\t        state.selection = [[w1, n1], [e1, s1]];\n\t        redraw.call(that);\n\t        emit.brush();\n\t      }\n\t    }\n\t\n\t    function ended() {\n\t      nopropagation();\n\t      if (d3Selection.event.touches) {\n\t        if (d3Selection.event.touches.length) return;\n\t        if (touchending) clearTimeout(touchending);\n\t        touchending = setTimeout(function() { touchending = null; }, 500); // Ghost clicks are delayed!\n\t        group.on(\"touchmove.brush touchend.brush touchcancel.brush\", null);\n\t      } else {\n\t        d3Drag.dragEnable(d3Selection.event.view, moving);\n\t        view.on(\"keydown.brush keyup.brush mousemove.brush mouseup.brush\", null);\n\t      }\n\t      group.attr(\"pointer-events\", \"all\");\n\t      overlay.attr(\"cursor\", cursors.overlay);\n\t      if (state.selection) selection = state.selection; // May be set by brush.move (on start)!\n\t      if (empty(selection)) state.selection = null, redraw.call(that);\n\t      emit.end();\n\t    }\n\t\n\t    function keydowned() {\n\t      switch (d3Selection.event.keyCode) {\n\t        case 16: { // SHIFT\n\t          shifting = signX && signY;\n\t          break;\n\t        }\n\t        case 18: { // ALT\n\t          if (mode === MODE_HANDLE) {\n\t            if (signX) e0 = e1 - dx * signX, w0 = w1 + dx * signX;\n\t            if (signY) s0 = s1 - dy * signY, n0 = n1 + dy * signY;\n\t            mode = MODE_CENTER;\n\t            move();\n\t          }\n\t          break;\n\t        }\n\t        case 32: { // SPACE; takes priority over ALT\n\t          if (mode === MODE_HANDLE || mode === MODE_CENTER) {\n\t            if (signX < 0) e0 = e1 - dx; else if (signX > 0) w0 = w1 - dx;\n\t            if (signY < 0) s0 = s1 - dy; else if (signY > 0) n0 = n1 - dy;\n\t            mode = MODE_SPACE;\n\t            overlay.attr(\"cursor\", cursors.selection);\n\t            move();\n\t          }\n\t          break;\n\t        }\n\t        default: return;\n\t      }\n\t      noevent();\n\t    }\n\t\n\t    function keyupped() {\n\t      switch (d3Selection.event.keyCode) {\n\t        case 16: { // SHIFT\n\t          if (shifting) {\n\t            lockX = lockY = shifting = false;\n\t            move();\n\t          }\n\t          break;\n\t        }\n\t        case 18: { // ALT\n\t          if (mode === MODE_CENTER) {\n\t            if (signX < 0) e0 = e1; else if (signX > 0) w0 = w1;\n\t            if (signY < 0) s0 = s1; else if (signY > 0) n0 = n1;\n\t            mode = MODE_HANDLE;\n\t            move();\n\t          }\n\t          break;\n\t        }\n\t        case 32: { // SPACE\n\t          if (mode === MODE_SPACE) {\n\t            if (d3Selection.event.altKey) {\n\t              if (signX) e0 = e1 - dx * signX, w0 = w1 + dx * signX;\n\t              if (signY) s0 = s1 - dy * signY, n0 = n1 + dy * signY;\n\t              mode = MODE_CENTER;\n\t            } else {\n\t              if (signX < 0) e0 = e1; else if (signX > 0) w0 = w1;\n\t              if (signY < 0) s0 = s1; else if (signY > 0) n0 = n1;\n\t              mode = MODE_HANDLE;\n\t            }\n\t            overlay.attr(\"cursor\", cursors[type]);\n\t            move();\n\t          }\n\t          break;\n\t        }\n\t        default: return;\n\t      }\n\t      noevent();\n\t    }\n\t  }\n\t\n\t  function initialize() {\n\t    var state = this.__brush || {selection: null};\n\t    state.extent = extent.apply(this, arguments);\n\t    state.dim = dim;\n\t    return state;\n\t  }\n\t\n\t  brush.extent = function(_) {\n\t    return arguments.length ? (extent = typeof _ === \"function\" ? _ : constant([[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]]), brush) : extent;\n\t  };\n\t\n\t  brush.filter = function(_) {\n\t    return arguments.length ? (filter = typeof _ === \"function\" ? _ : constant(!!_), brush) : filter;\n\t  };\n\t\n\t  brush.handleSize = function(_) {\n\t    return arguments.length ? (handleSize = +_, brush) : handleSize;\n\t  };\n\t\n\t  brush.on = function() {\n\t    var value = listeners.on.apply(listeners, arguments);\n\t    return value === listeners ? brush : value;\n\t  };\n\t\n\t  return brush;\n\t}\n\t\n\texports.brush = brush;\n\texports.brushX = brushX;\n\texports.brushY = brushY;\n\texports.brushSelection = brushSelection;\n\t\n\tObject.defineProperty(exports, '__esModule', { value: true });\n\t\n\t})));\n\n\n/***/ }),\n/* 23 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t// https://d3js.org/d3-drag/ Version 1.1.1. Copyright 2017 Mike Bostock.\n\t(function (global, factory) {\n\t\t true ? factory(exports, __webpack_require__(5), __webpack_require__(12)) :\n\t\ttypeof define === 'function' && define.amd ? define(['exports', 'd3-dispatch', 'd3-selection'], factory) :\n\t\t(factory((global.d3 = global.d3 || {}),global.d3,global.d3));\n\t}(this, (function (exports,d3Dispatch,d3Selection) { 'use strict';\n\t\n\tfunction nopropagation() {\n\t  d3Selection.event.stopImmediatePropagation();\n\t}\n\t\n\tvar noevent = function() {\n\t  d3Selection.event.preventDefault();\n\t  d3Selection.event.stopImmediatePropagation();\n\t};\n\t\n\tvar nodrag = function(view) {\n\t  var root = view.document.documentElement,\n\t      selection = d3Selection.select(view).on(\"dragstart.drag\", noevent, true);\n\t  if (\"onselectstart\" in root) {\n\t    selection.on(\"selectstart.drag\", noevent, true);\n\t  } else {\n\t    root.__noselect = root.style.MozUserSelect;\n\t    root.style.MozUserSelect = \"none\";\n\t  }\n\t};\n\t\n\tfunction yesdrag(view, noclick) {\n\t  var root = view.document.documentElement,\n\t      selection = d3Selection.select(view).on(\"dragstart.drag\", null);\n\t  if (noclick) {\n\t    selection.on(\"click.drag\", noevent, true);\n\t    setTimeout(function() { selection.on(\"click.drag\", null); }, 0);\n\t  }\n\t  if (\"onselectstart\" in root) {\n\t    selection.on(\"selectstart.drag\", null);\n\t  } else {\n\t    root.style.MozUserSelect = root.__noselect;\n\t    delete root.__noselect;\n\t  }\n\t}\n\t\n\tvar constant = function(x) {\n\t  return function() {\n\t    return x;\n\t  };\n\t};\n\t\n\tfunction DragEvent(target, type, subject, id, active, x, y, dx, dy, dispatch$$1) {\n\t  this.target = target;\n\t  this.type = type;\n\t  this.subject = subject;\n\t  this.identifier = id;\n\t  this.active = active;\n\t  this.x = x;\n\t  this.y = y;\n\t  this.dx = dx;\n\t  this.dy = dy;\n\t  this._ = dispatch$$1;\n\t}\n\t\n\tDragEvent.prototype.on = function() {\n\t  var value = this._.on.apply(this._, arguments);\n\t  return value === this._ ? this : value;\n\t};\n\t\n\t// Ignore right-click, since that should open the context menu.\n\tfunction defaultFilter() {\n\t  return !d3Selection.event.button;\n\t}\n\t\n\tfunction defaultContainer() {\n\t  return this.parentNode;\n\t}\n\t\n\tfunction defaultSubject(d) {\n\t  return d == null ? {x: d3Selection.event.x, y: d3Selection.event.y} : d;\n\t}\n\t\n\tfunction touchable() {\n\t  return \"ontouchstart\" in this;\n\t}\n\t\n\tvar drag = function() {\n\t  var filter = defaultFilter,\n\t      container = defaultContainer,\n\t      subject = defaultSubject,\n\t      gestures = {},\n\t      listeners = d3Dispatch.dispatch(\"start\", \"drag\", \"end\"),\n\t      active = 0,\n\t      mousedownx,\n\t      mousedowny,\n\t      mousemoving,\n\t      touchending,\n\t      clickDistance2 = 0;\n\t\n\t  function drag(selection) {\n\t    selection\n\t        .on(\"mousedown.drag\", mousedowned)\n\t      .filter(touchable)\n\t        .on(\"touchstart.drag\", touchstarted)\n\t        .on(\"touchmove.drag\", touchmoved)\n\t        .on(\"touchend.drag touchcancel.drag\", touchended)\n\t        .style(\"touch-action\", \"none\")\n\t        .style(\"-webkit-tap-highlight-color\", \"rgba(0,0,0,0)\");\n\t  }\n\t\n\t  function mousedowned() {\n\t    if (touchending || !filter.apply(this, arguments)) return;\n\t    var gesture = beforestart(\"mouse\", container.apply(this, arguments), d3Selection.mouse, this, arguments);\n\t    if (!gesture) return;\n\t    d3Selection.select(d3Selection.event.view).on(\"mousemove.drag\", mousemoved, true).on(\"mouseup.drag\", mouseupped, true);\n\t    nodrag(d3Selection.event.view);\n\t    nopropagation();\n\t    mousemoving = false;\n\t    mousedownx = d3Selection.event.clientX;\n\t    mousedowny = d3Selection.event.clientY;\n\t    gesture(\"start\");\n\t  }\n\t\n\t  function mousemoved() {\n\t    noevent();\n\t    if (!mousemoving) {\n\t      var dx = d3Selection.event.clientX - mousedownx, dy = d3Selection.event.clientY - mousedowny;\n\t      mousemoving = dx * dx + dy * dy > clickDistance2;\n\t    }\n\t    gestures.mouse(\"drag\");\n\t  }\n\t\n\t  function mouseupped() {\n\t    d3Selection.select(d3Selection.event.view).on(\"mousemove.drag mouseup.drag\", null);\n\t    yesdrag(d3Selection.event.view, mousemoving);\n\t    noevent();\n\t    gestures.mouse(\"end\");\n\t  }\n\t\n\t  function touchstarted() {\n\t    if (!filter.apply(this, arguments)) return;\n\t    var touches = d3Selection.event.changedTouches,\n\t        c = container.apply(this, arguments),\n\t        n = touches.length, i, gesture;\n\t\n\t    for (i = 0; i < n; ++i) {\n\t      if (gesture = beforestart(touches[i].identifier, c, d3Selection.touch, this, arguments)) {\n\t        nopropagation();\n\t        gesture(\"start\");\n\t      }\n\t    }\n\t  }\n\t\n\t  function touchmoved() {\n\t    var touches = d3Selection.event.changedTouches,\n\t        n = touches.length, i, gesture;\n\t\n\t    for (i = 0; i < n; ++i) {\n\t      if (gesture = gestures[touches[i].identifier]) {\n\t        noevent();\n\t        gesture(\"drag\");\n\t      }\n\t    }\n\t  }\n\t\n\t  function touchended() {\n\t    var touches = d3Selection.event.changedTouches,\n\t        n = touches.length, i, gesture;\n\t\n\t    if (touchending) clearTimeout(touchending);\n\t    touchending = setTimeout(function() { touchending = null; }, 500); // Ghost clicks are delayed!\n\t    for (i = 0; i < n; ++i) {\n\t      if (gesture = gestures[touches[i].identifier]) {\n\t        nopropagation();\n\t        gesture(\"end\");\n\t      }\n\t    }\n\t  }\n\t\n\t  function beforestart(id, container, point, that, args) {\n\t    var p = point(container, id), s, dx, dy,\n\t        sublisteners = listeners.copy();\n\t\n\t    if (!d3Selection.customEvent(new DragEvent(drag, \"beforestart\", s, id, active, p[0], p[1], 0, 0, sublisteners), function() {\n\t      if ((d3Selection.event.subject = s = subject.apply(that, args)) == null) return false;\n\t      dx = s.x - p[0] || 0;\n\t      dy = s.y - p[1] || 0;\n\t      return true;\n\t    })) return;\n\t\n\t    return function gesture(type) {\n\t      var p0 = p, n;\n\t      switch (type) {\n\t        case \"start\": gestures[id] = gesture, n = active++; break;\n\t        case \"end\": delete gestures[id], --active; // nobreak\n\t        case \"drag\": p = point(container, id), n = active; break;\n\t      }\n\t      d3Selection.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\t    };\n\t  }\n\t\n\t  drag.filter = function(_) {\n\t    return arguments.length ? (filter = typeof _ === \"function\" ? _ : constant(!!_), drag) : filter;\n\t  };\n\t\n\t  drag.container = function(_) {\n\t    return arguments.length ? (container = typeof _ === \"function\" ? _ : constant(_), drag) : container;\n\t  };\n\t\n\t  drag.subject = function(_) {\n\t    return arguments.length ? (subject = typeof _ === \"function\" ? _ : constant(_), drag) : subject;\n\t  };\n\t\n\t  drag.on = function() {\n\t    var value = listeners.on.apply(listeners, arguments);\n\t    return value === listeners ? drag : value;\n\t  };\n\t\n\t  drag.clickDistance = function(_) {\n\t    return arguments.length ? (clickDistance2 = (_ = +_) * _, drag) : Math.sqrt(clickDistance2);\n\t  };\n\t\n\t  return drag;\n\t};\n\t\n\texports.drag = drag;\n\texports.dragDisable = nodrag;\n\texports.dragEnable = yesdrag;\n\t\n\tObject.defineProperty(exports, '__esModule', { value: true });\n\t\n\t})));\n\n\n/***/ }),\n/* 24 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t// https://d3js.org/d3-shape/ Version 1.2.0. Copyright 2017 Mike Bostock.\n\t(function (global, factory) {\n\t\t true ? factory(exports, __webpack_require__(25)) :\n\t\ttypeof define === 'function' && define.amd ? define(['exports', 'd3-path'], factory) :\n\t\t(factory((global.d3 = global.d3 || {}),global.d3));\n\t}(this, (function (exports,d3Path) { 'use strict';\n\t\n\tvar constant = function(x) {\n\t  return function constant() {\n\t    return x;\n\t  };\n\t};\n\t\n\tvar abs = Math.abs;\n\tvar atan2 = Math.atan2;\n\tvar cos = Math.cos;\n\tvar max = Math.max;\n\tvar min = Math.min;\n\tvar sin = Math.sin;\n\tvar sqrt = Math.sqrt;\n\t\n\tvar epsilon = 1e-12;\n\tvar pi = Math.PI;\n\tvar halfPi = pi / 2;\n\tvar tau = 2 * pi;\n\t\n\tfunction acos(x) {\n\t  return x > 1 ? 0 : x < -1 ? pi : Math.acos(x);\n\t}\n\t\n\tfunction asin(x) {\n\t  return x >= 1 ? halfPi : x <= -1 ? -halfPi : Math.asin(x);\n\t}\n\t\n\tfunction arcInnerRadius(d) {\n\t  return d.innerRadius;\n\t}\n\t\n\tfunction arcOuterRadius(d) {\n\t  return d.outerRadius;\n\t}\n\t\n\tfunction arcStartAngle(d) {\n\t  return d.startAngle;\n\t}\n\t\n\tfunction arcEndAngle(d) {\n\t  return d.endAngle;\n\t}\n\t\n\tfunction arcPadAngle(d) {\n\t  return d && d.padAngle; // Note: optional!\n\t}\n\t\n\tfunction intersect(x0, y0, x1, y1, x2, y2, x3, y3) {\n\t  var x10 = x1 - x0, y10 = y1 - y0,\n\t      x32 = x3 - x2, y32 = y3 - y2,\n\t      t = (x32 * (y0 - y2) - y32 * (x0 - x2)) / (y32 * x10 - x32 * y10);\n\t  return [x0 + t * x10, y0 + t * y10];\n\t}\n\t\n\t// Compute perpendicular offset line of length rc.\n\t// http://mathworld.wolfram.com/Circle-LineIntersection.html\n\tfunction cornerTangents(x0, y0, x1, y1, r1, rc, cw) {\n\t  var x01 = x0 - x1,\n\t      y01 = y0 - y1,\n\t      lo = (cw ? rc : -rc) / sqrt(x01 * x01 + y01 * y01),\n\t      ox = lo * y01,\n\t      oy = -lo * x01,\n\t      x11 = x0 + ox,\n\t      y11 = y0 + oy,\n\t      x10 = x1 + ox,\n\t      y10 = y1 + oy,\n\t      x00 = (x11 + x10) / 2,\n\t      y00 = (y11 + y10) / 2,\n\t      dx = x10 - x11,\n\t      dy = y10 - y11,\n\t      d2 = dx * dx + dy * dy,\n\t      r = r1 - rc,\n\t      D = x11 * y10 - x10 * y11,\n\t      d = (dy < 0 ? -1 : 1) * sqrt(max(0, r * r * d2 - D * D)),\n\t      cx0 = (D * dy - dx * d) / d2,\n\t      cy0 = (-D * dx - dy * d) / d2,\n\t      cx1 = (D * dy + dx * d) / d2,\n\t      cy1 = (-D * dx + dy * d) / d2,\n\t      dx0 = cx0 - x00,\n\t      dy0 = cy0 - y00,\n\t      dx1 = cx1 - x00,\n\t      dy1 = cy1 - y00;\n\t\n\t  // Pick the closer of the two intersection points.\n\t  // TODO Is there a faster way to determine which intersection to use?\n\t  if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) cx0 = cx1, cy0 = cy1;\n\t\n\t  return {\n\t    cx: cx0,\n\t    cy: cy0,\n\t    x01: -ox,\n\t    y01: -oy,\n\t    x11: cx0 * (r1 / r - 1),\n\t    y11: cy0 * (r1 / r - 1)\n\t  };\n\t}\n\t\n\tvar arc = function() {\n\t  var innerRadius = arcInnerRadius,\n\t      outerRadius = arcOuterRadius,\n\t      cornerRadius = constant(0),\n\t      padRadius = null,\n\t      startAngle = arcStartAngle,\n\t      endAngle = arcEndAngle,\n\t      padAngle = arcPadAngle,\n\t      context = null;\n\t\n\t  function arc() {\n\t    var buffer,\n\t        r,\n\t        r0 = +innerRadius.apply(this, arguments),\n\t        r1 = +outerRadius.apply(this, arguments),\n\t        a0 = startAngle.apply(this, arguments) - halfPi,\n\t        a1 = endAngle.apply(this, arguments) - halfPi,\n\t        da = abs(a1 - a0),\n\t        cw = a1 > a0;\n\t\n\t    if (!context) context = buffer = d3Path.path();\n\t\n\t    // Ensure that the outer radius is always larger than the inner radius.\n\t    if (r1 < r0) r = r1, r1 = r0, r0 = r;\n\t\n\t    // Is it a point?\n\t    if (!(r1 > epsilon)) context.moveTo(0, 0);\n\t\n\t    // Or is it a circle or annulus?\n\t    else if (da > tau - epsilon) {\n\t      context.moveTo(r1 * cos(a0), r1 * sin(a0));\n\t      context.arc(0, 0, r1, a0, a1, !cw);\n\t      if (r0 > epsilon) {\n\t        context.moveTo(r0 * cos(a1), r0 * sin(a1));\n\t        context.arc(0, 0, r0, a1, a0, cw);\n\t      }\n\t    }\n\t\n\t    // Or is it a circular or annular sector?\n\t    else {\n\t      var a01 = a0,\n\t          a11 = a1,\n\t          a00 = a0,\n\t          a10 = a1,\n\t          da0 = da,\n\t          da1 = da,\n\t          ap = padAngle.apply(this, arguments) / 2,\n\t          rp = (ap > epsilon) && (padRadius ? +padRadius.apply(this, arguments) : sqrt(r0 * r0 + r1 * r1)),\n\t          rc = min(abs(r1 - r0) / 2, +cornerRadius.apply(this, arguments)),\n\t          rc0 = rc,\n\t          rc1 = rc,\n\t          t0,\n\t          t1;\n\t\n\t      // Apply padding? Note that since r1 ≥ r0, da1 ≥ da0.\n\t      if (rp > epsilon) {\n\t        var p0 = asin(rp / r0 * sin(ap)),\n\t            p1 = asin(rp / r1 * sin(ap));\n\t        if ((da0 -= p0 * 2) > epsilon) p0 *= (cw ? 1 : -1), a00 += p0, a10 -= p0;\n\t        else da0 = 0, a00 = a10 = (a0 + a1) / 2;\n\t        if ((da1 -= p1 * 2) > epsilon) p1 *= (cw ? 1 : -1), a01 += p1, a11 -= p1;\n\t        else da1 = 0, a01 = a11 = (a0 + a1) / 2;\n\t      }\n\t\n\t      var x01 = r1 * cos(a01),\n\t          y01 = r1 * sin(a01),\n\t          x10 = r0 * cos(a10),\n\t          y10 = r0 * sin(a10);\n\t\n\t      // Apply rounded corners?\n\t      if (rc > epsilon) {\n\t        var x11 = r1 * cos(a11),\n\t            y11 = r1 * sin(a11),\n\t            x00 = r0 * cos(a00),\n\t            y00 = r0 * sin(a00);\n\t\n\t        // Restrict the corner radius according to the sector angle.\n\t        if (da < pi) {\n\t          var oc = da0 > epsilon ? intersect(x01, y01, x00, y00, x11, y11, x10, y10) : [x10, y10],\n\t              ax = x01 - oc[0],\n\t              ay = y01 - oc[1],\n\t              bx = x11 - oc[0],\n\t              by = y11 - oc[1],\n\t              kc = 1 / sin(acos((ax * bx + ay * by) / (sqrt(ax * ax + ay * ay) * sqrt(bx * bx + by * by))) / 2),\n\t              lc = sqrt(oc[0] * oc[0] + oc[1] * oc[1]);\n\t          rc0 = min(rc, (r0 - lc) / (kc - 1));\n\t          rc1 = min(rc, (r1 - lc) / (kc + 1));\n\t        }\n\t      }\n\t\n\t      // Is the sector collapsed to a line?\n\t      if (!(da1 > epsilon)) context.moveTo(x01, y01);\n\t\n\t      // Does the sector’s outer ring have rounded corners?\n\t      else if (rc1 > epsilon) {\n\t        t0 = cornerTangents(x00, y00, x01, y01, r1, rc1, cw);\n\t        t1 = cornerTangents(x11, y11, x10, y10, r1, rc1, cw);\n\t\n\t        context.moveTo(t0.cx + t0.x01, t0.cy + t0.y01);\n\t\n\t        // Have the corners merged?\n\t        if (rc1 < rc) context.arc(t0.cx, t0.cy, rc1, atan2(t0.y01, t0.x01), atan2(t1.y01, t1.x01), !cw);\n\t\n\t        // Otherwise, draw the two corners and the ring.\n\t        else {\n\t          context.arc(t0.cx, t0.cy, rc1, atan2(t0.y01, t0.x01), atan2(t0.y11, t0.x11), !cw);\n\t          context.arc(0, 0, r1, atan2(t0.cy + t0.y11, t0.cx + t0.x11), atan2(t1.cy + t1.y11, t1.cx + t1.x11), !cw);\n\t          context.arc(t1.cx, t1.cy, rc1, atan2(t1.y11, t1.x11), atan2(t1.y01, t1.x01), !cw);\n\t        }\n\t      }\n\t\n\t      // Or is the outer ring just a circular arc?\n\t      else context.moveTo(x01, y01), context.arc(0, 0, r1, a01, a11, !cw);\n\t\n\t      // Is there no inner ring, and it’s a circular sector?\n\t      // Or perhaps it’s an annular sector collapsed due to padding?\n\t      if (!(r0 > epsilon) || !(da0 > epsilon)) context.lineTo(x10, y10);\n\t\n\t      // Does the sector’s inner ring (or point) have rounded corners?\n\t      else if (rc0 > epsilon) {\n\t        t0 = cornerTangents(x10, y10, x11, y11, r0, -rc0, cw);\n\t        t1 = cornerTangents(x01, y01, x00, y00, r0, -rc0, cw);\n\t\n\t        context.lineTo(t0.cx + t0.x01, t0.cy + t0.y01);\n\t\n\t        // Have the corners merged?\n\t        if (rc0 < rc) context.arc(t0.cx, t0.cy, rc0, atan2(t0.y01, t0.x01), atan2(t1.y01, t1.x01), !cw);\n\t\n\t        // Otherwise, draw the two corners and the ring.\n\t        else {\n\t          context.arc(t0.cx, t0.cy, rc0, atan2(t0.y01, t0.x01), atan2(t0.y11, t0.x11), !cw);\n\t          context.arc(0, 0, r0, atan2(t0.cy + t0.y11, t0.cx + t0.x11), atan2(t1.cy + t1.y11, t1.cx + t1.x11), cw);\n\t          context.arc(t1.cx, t1.cy, rc0, atan2(t1.y11, t1.x11), atan2(t1.y01, t1.x01), !cw);\n\t        }\n\t      }\n\t\n\t      // Or is the inner ring just a circular arc?\n\t      else context.arc(0, 0, r0, a10, a00, cw);\n\t    }\n\t\n\t    context.closePath();\n\t\n\t    if (buffer) return context = null, buffer + \"\" || null;\n\t  }\n\t\n\t  arc.centroid = function() {\n\t    var r = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2,\n\t        a = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - pi / 2;\n\t    return [cos(a) * r, sin(a) * r];\n\t  };\n\t\n\t  arc.innerRadius = function(_) {\n\t    return arguments.length ? (innerRadius = typeof _ === \"function\" ? _ : constant(+_), arc) : innerRadius;\n\t  };\n\t\n\t  arc.outerRadius = function(_) {\n\t    return arguments.length ? (outerRadius = typeof _ === \"function\" ? _ : constant(+_), arc) : outerRadius;\n\t  };\n\t\n\t  arc.cornerRadius = function(_) {\n\t    return arguments.length ? (cornerRadius = typeof _ === \"function\" ? _ : constant(+_), arc) : cornerRadius;\n\t  };\n\t\n\t  arc.padRadius = function(_) {\n\t    return arguments.length ? (padRadius = _ == null ? null : typeof _ === \"function\" ? _ : constant(+_), arc) : padRadius;\n\t  };\n\t\n\t  arc.startAngle = function(_) {\n\t    return arguments.length ? (startAngle = typeof _ === \"function\" ? _ : constant(+_), arc) : startAngle;\n\t  };\n\t\n\t  arc.endAngle = function(_) {\n\t    return arguments.length ? (endAngle = typeof _ === \"function\" ? _ : constant(+_), arc) : endAngle;\n\t  };\n\t\n\t  arc.padAngle = function(_) {\n\t    return arguments.length ? (padAngle = typeof _ === \"function\" ? _ : constant(+_), arc) : padAngle;\n\t  };\n\t\n\t  arc.context = function(_) {\n\t    return arguments.length ? ((context = _ == null ? null : _), arc) : context;\n\t  };\n\t\n\t  return arc;\n\t};\n\t\n\tfunction Linear(context) {\n\t  this._context = context;\n\t}\n\t\n\tLinear.prototype = {\n\t  areaStart: function() {\n\t    this._line = 0;\n\t  },\n\t  areaEnd: function() {\n\t    this._line = NaN;\n\t  },\n\t  lineStart: function() {\n\t    this._point = 0;\n\t  },\n\t  lineEnd: function() {\n\t    if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n\t    this._line = 1 - this._line;\n\t  },\n\t  point: function(x, y) {\n\t    x = +x, y = +y;\n\t    switch (this._point) {\n\t      case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n\t      case 1: this._point = 2; // proceed\n\t      default: this._context.lineTo(x, y); break;\n\t    }\n\t  }\n\t};\n\t\n\tvar curveLinear = function(context) {\n\t  return new Linear(context);\n\t};\n\t\n\tfunction x(p) {\n\t  return p[0];\n\t}\n\t\n\tfunction y(p) {\n\t  return p[1];\n\t}\n\t\n\tvar line = function() {\n\t  var x$$1 = x,\n\t      y$$1 = y,\n\t      defined = constant(true),\n\t      context = null,\n\t      curve = curveLinear,\n\t      output = null;\n\t\n\t  function line(data) {\n\t    var i,\n\t        n = data.length,\n\t        d,\n\t        defined0 = false,\n\t        buffer;\n\t\n\t    if (context == null) output = curve(buffer = d3Path.path());\n\t\n\t    for (i = 0; i <= n; ++i) {\n\t      if (!(i < n && defined(d = data[i], i, data)) === defined0) {\n\t        if (defined0 = !defined0) output.lineStart();\n\t        else output.lineEnd();\n\t      }\n\t      if (defined0) output.point(+x$$1(d, i, data), +y$$1(d, i, data));\n\t    }\n\t\n\t    if (buffer) return output = null, buffer + \"\" || null;\n\t  }\n\t\n\t  line.x = function(_) {\n\t    return arguments.length ? (x$$1 = typeof _ === \"function\" ? _ : constant(+_), line) : x$$1;\n\t  };\n\t\n\t  line.y = function(_) {\n\t    return arguments.length ? (y$$1 = typeof _ === \"function\" ? _ : constant(+_), line) : y$$1;\n\t  };\n\t\n\t  line.defined = function(_) {\n\t    return arguments.length ? (defined = typeof _ === \"function\" ? _ : constant(!!_), line) : defined;\n\t  };\n\t\n\t  line.curve = function(_) {\n\t    return arguments.length ? (curve = _, context != null && (output = curve(context)), line) : curve;\n\t  };\n\t\n\t  line.context = function(_) {\n\t    return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), line) : context;\n\t  };\n\t\n\t  return line;\n\t};\n\t\n\tvar area = function() {\n\t  var x0 = x,\n\t      x1 = null,\n\t      y0 = constant(0),\n\t      y1 = y,\n\t      defined = constant(true),\n\t      context = null,\n\t      curve = curveLinear,\n\t      output = null;\n\t\n\t  function area(data) {\n\t    var i,\n\t        j,\n\t        k,\n\t        n = data.length,\n\t        d,\n\t        defined0 = false,\n\t        buffer,\n\t        x0z = new Array(n),\n\t        y0z = new Array(n);\n\t\n\t    if (context == null) output = curve(buffer = d3Path.path());\n\t\n\t    for (i = 0; i <= n; ++i) {\n\t      if (!(i < n && defined(d = data[i], i, data)) === defined0) {\n\t        if (defined0 = !defined0) {\n\t          j = i;\n\t          output.areaStart();\n\t          output.lineStart();\n\t        } else {\n\t          output.lineEnd();\n\t          output.lineStart();\n\t          for (k = i - 1; k >= j; --k) {\n\t            output.point(x0z[k], y0z[k]);\n\t          }\n\t          output.lineEnd();\n\t          output.areaEnd();\n\t        }\n\t      }\n\t      if (defined0) {\n\t        x0z[i] = +x0(d, i, data), y0z[i] = +y0(d, i, data);\n\t        output.point(x1 ? +x1(d, i, data) : x0z[i], y1 ? +y1(d, i, data) : y0z[i]);\n\t      }\n\t    }\n\t\n\t    if (buffer) return output = null, buffer + \"\" || null;\n\t  }\n\t\n\t  function arealine() {\n\t    return line().defined(defined).curve(curve).context(context);\n\t  }\n\t\n\t  area.x = function(_) {\n\t    return arguments.length ? (x0 = typeof _ === \"function\" ? _ : constant(+_), x1 = null, area) : x0;\n\t  };\n\t\n\t  area.x0 = function(_) {\n\t    return arguments.length ? (x0 = typeof _ === \"function\" ? _ : constant(+_), area) : x0;\n\t  };\n\t\n\t  area.x1 = function(_) {\n\t    return arguments.length ? (x1 = _ == null ? null : typeof _ === \"function\" ? _ : constant(+_), area) : x1;\n\t  };\n\t\n\t  area.y = function(_) {\n\t    return arguments.length ? (y0 = typeof _ === \"function\" ? _ : constant(+_), y1 = null, area) : y0;\n\t  };\n\t\n\t  area.y0 = function(_) {\n\t    return arguments.length ? (y0 = typeof _ === \"function\" ? _ : constant(+_), area) : y0;\n\t  };\n\t\n\t  area.y1 = function(_) {\n\t    return arguments.length ? (y1 = _ == null ? null : typeof _ === \"function\" ? _ : constant(+_), area) : y1;\n\t  };\n\t\n\t  area.lineX0 =\n\t  area.lineY0 = function() {\n\t    return arealine().x(x0).y(y0);\n\t  };\n\t\n\t  area.lineY1 = function() {\n\t    return arealine().x(x0).y(y1);\n\t  };\n\t\n\t  area.lineX1 = function() {\n\t    return arealine().x(x1).y(y0);\n\t  };\n\t\n\t  area.defined = function(_) {\n\t    return arguments.length ? (defined = typeof _ === \"function\" ? _ : constant(!!_), area) : defined;\n\t  };\n\t\n\t  area.curve = function(_) {\n\t    return arguments.length ? (curve = _, context != null && (output = curve(context)), area) : curve;\n\t  };\n\t\n\t  area.context = function(_) {\n\t    return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), area) : context;\n\t  };\n\t\n\t  return area;\n\t};\n\t\n\tvar descending = function(a, b) {\n\t  return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;\n\t};\n\t\n\tvar identity = function(d) {\n\t  return d;\n\t};\n\t\n\tvar pie = function() {\n\t  var value = identity,\n\t      sortValues = descending,\n\t      sort = null,\n\t      startAngle = constant(0),\n\t      endAngle = constant(tau),\n\t      padAngle = constant(0);\n\t\n\t  function pie(data) {\n\t    var i,\n\t        n = data.length,\n\t        j,\n\t        k,\n\t        sum = 0,\n\t        index = new Array(n),\n\t        arcs = new Array(n),\n\t        a0 = +startAngle.apply(this, arguments),\n\t        da = Math.min(tau, Math.max(-tau, endAngle.apply(this, arguments) - a0)),\n\t        a1,\n\t        p = Math.min(Math.abs(da) / n, padAngle.apply(this, arguments)),\n\t        pa = p * (da < 0 ? -1 : 1),\n\t        v;\n\t\n\t    for (i = 0; i < n; ++i) {\n\t      if ((v = arcs[index[i] = i] = +value(data[i], i, data)) > 0) {\n\t        sum += v;\n\t      }\n\t    }\n\t\n\t    // Optionally sort the arcs by previously-computed values or by data.\n\t    if (sortValues != null) index.sort(function(i, j) { return sortValues(arcs[i], arcs[j]); });\n\t    else if (sort != null) index.sort(function(i, j) { return sort(data[i], data[j]); });\n\t\n\t    // Compute the arcs! They are stored in the original data's order.\n\t    for (i = 0, k = sum ? (da - n * pa) / sum : 0; i < n; ++i, a0 = a1) {\n\t      j = index[i], v = arcs[j], a1 = a0 + (v > 0 ? v * k : 0) + pa, arcs[j] = {\n\t        data: data[j],\n\t        index: i,\n\t        value: v,\n\t        startAngle: a0,\n\t        endAngle: a1,\n\t        padAngle: p\n\t      };\n\t    }\n\t\n\t    return arcs;\n\t  }\n\t\n\t  pie.value = function(_) {\n\t    return arguments.length ? (value = typeof _ === \"function\" ? _ : constant(+_), pie) : value;\n\t  };\n\t\n\t  pie.sortValues = function(_) {\n\t    return arguments.length ? (sortValues = _, sort = null, pie) : sortValues;\n\t  };\n\t\n\t  pie.sort = function(_) {\n\t    return arguments.length ? (sort = _, sortValues = null, pie) : sort;\n\t  };\n\t\n\t  pie.startAngle = function(_) {\n\t    return arguments.length ? (startAngle = typeof _ === \"function\" ? _ : constant(+_), pie) : startAngle;\n\t  };\n\t\n\t  pie.endAngle = function(_) {\n\t    return arguments.length ? (endAngle = typeof _ === \"function\" ? _ : constant(+_), pie) : endAngle;\n\t  };\n\t\n\t  pie.padAngle = function(_) {\n\t    return arguments.length ? (padAngle = typeof _ === \"function\" ? _ : constant(+_), pie) : padAngle;\n\t  };\n\t\n\t  return pie;\n\t};\n\t\n\tvar curveRadialLinear = curveRadial(curveLinear);\n\t\n\tfunction Radial(curve) {\n\t  this._curve = curve;\n\t}\n\t\n\tRadial.prototype = {\n\t  areaStart: function() {\n\t    this._curve.areaStart();\n\t  },\n\t  areaEnd: function() {\n\t    this._curve.areaEnd();\n\t  },\n\t  lineStart: function() {\n\t    this._curve.lineStart();\n\t  },\n\t  lineEnd: function() {\n\t    this._curve.lineEnd();\n\t  },\n\t  point: function(a, r) {\n\t    this._curve.point(r * Math.sin(a), r * -Math.cos(a));\n\t  }\n\t};\n\t\n\tfunction curveRadial(curve) {\n\t\n\t  function radial(context) {\n\t    return new Radial(curve(context));\n\t  }\n\t\n\t  radial._curve = curve;\n\t\n\t  return radial;\n\t}\n\t\n\tfunction lineRadial(l) {\n\t  var c = l.curve;\n\t\n\t  l.angle = l.x, delete l.x;\n\t  l.radius = l.y, delete l.y;\n\t\n\t  l.curve = function(_) {\n\t    return arguments.length ? c(curveRadial(_)) : c()._curve;\n\t  };\n\t\n\t  return l;\n\t}\n\t\n\tvar lineRadial$1 = function() {\n\t  return lineRadial(line().curve(curveRadialLinear));\n\t};\n\t\n\tvar areaRadial = function() {\n\t  var a = area().curve(curveRadialLinear),\n\t      c = a.curve,\n\t      x0 = a.lineX0,\n\t      x1 = a.lineX1,\n\t      y0 = a.lineY0,\n\t      y1 = a.lineY1;\n\t\n\t  a.angle = a.x, delete a.x;\n\t  a.startAngle = a.x0, delete a.x0;\n\t  a.endAngle = a.x1, delete a.x1;\n\t  a.radius = a.y, delete a.y;\n\t  a.innerRadius = a.y0, delete a.y0;\n\t  a.outerRadius = a.y1, delete a.y1;\n\t  a.lineStartAngle = function() { return lineRadial(x0()); }, delete a.lineX0;\n\t  a.lineEndAngle = function() { return lineRadial(x1()); }, delete a.lineX1;\n\t  a.lineInnerRadius = function() { return lineRadial(y0()); }, delete a.lineY0;\n\t  a.lineOuterRadius = function() { return lineRadial(y1()); }, delete a.lineY1;\n\t\n\t  a.curve = function(_) {\n\t    return arguments.length ? c(curveRadial(_)) : c()._curve;\n\t  };\n\t\n\t  return a;\n\t};\n\t\n\tvar pointRadial = function(x, y) {\n\t  return [(y = +y) * Math.cos(x -= Math.PI / 2), y * Math.sin(x)];\n\t};\n\t\n\tvar slice = Array.prototype.slice;\n\t\n\tfunction linkSource(d) {\n\t  return d.source;\n\t}\n\t\n\tfunction linkTarget(d) {\n\t  return d.target;\n\t}\n\t\n\tfunction link(curve) {\n\t  var source = linkSource,\n\t      target = linkTarget,\n\t      x$$1 = x,\n\t      y$$1 = y,\n\t      context = null;\n\t\n\t  function link() {\n\t    var buffer, argv = slice.call(arguments), s = source.apply(this, argv), t = target.apply(this, argv);\n\t    if (!context) context = buffer = d3Path.path();\n\t    curve(context, +x$$1.apply(this, (argv[0] = s, argv)), +y$$1.apply(this, argv), +x$$1.apply(this, (argv[0] = t, argv)), +y$$1.apply(this, argv));\n\t    if (buffer) return context = null, buffer + \"\" || null;\n\t  }\n\t\n\t  link.source = function(_) {\n\t    return arguments.length ? (source = _, link) : source;\n\t  };\n\t\n\t  link.target = function(_) {\n\t    return arguments.length ? (target = _, link) : target;\n\t  };\n\t\n\t  link.x = function(_) {\n\t    return arguments.length ? (x$$1 = typeof _ === \"function\" ? _ : constant(+_), link) : x$$1;\n\t  };\n\t\n\t  link.y = function(_) {\n\t    return arguments.length ? (y$$1 = typeof _ === \"function\" ? _ : constant(+_), link) : y$$1;\n\t  };\n\t\n\t  link.context = function(_) {\n\t    return arguments.length ? ((context = _ == null ? null : _), link) : context;\n\t  };\n\t\n\t  return link;\n\t}\n\t\n\tfunction curveHorizontal(context, x0, y0, x1, y1) {\n\t  context.moveTo(x0, y0);\n\t  context.bezierCurveTo(x0 = (x0 + x1) / 2, y0, x0, y1, x1, y1);\n\t}\n\t\n\tfunction curveVertical(context, x0, y0, x1, y1) {\n\t  context.moveTo(x0, y0);\n\t  context.bezierCurveTo(x0, y0 = (y0 + y1) / 2, x1, y0, x1, y1);\n\t}\n\t\n\tfunction curveRadial$1(context, x0, y0, x1, y1) {\n\t  var p0 = pointRadial(x0, y0),\n\t      p1 = pointRadial(x0, y0 = (y0 + y1) / 2),\n\t      p2 = pointRadial(x1, y0),\n\t      p3 = pointRadial(x1, y1);\n\t  context.moveTo(p0[0], p0[1]);\n\t  context.bezierCurveTo(p1[0], p1[1], p2[0], p2[1], p3[0], p3[1]);\n\t}\n\t\n\tfunction linkHorizontal() {\n\t  return link(curveHorizontal);\n\t}\n\t\n\tfunction linkVertical() {\n\t  return link(curveVertical);\n\t}\n\t\n\tfunction linkRadial() {\n\t  var l = link(curveRadial$1);\n\t  l.angle = l.x, delete l.x;\n\t  l.radius = l.y, delete l.y;\n\t  return l;\n\t}\n\t\n\tvar circle = {\n\t  draw: function(context, size) {\n\t    var r = Math.sqrt(size / pi);\n\t    context.moveTo(r, 0);\n\t    context.arc(0, 0, r, 0, tau);\n\t  }\n\t};\n\t\n\tvar cross = {\n\t  draw: function(context, size) {\n\t    var r = Math.sqrt(size / 5) / 2;\n\t    context.moveTo(-3 * r, -r);\n\t    context.lineTo(-r, -r);\n\t    context.lineTo(-r, -3 * r);\n\t    context.lineTo(r, -3 * r);\n\t    context.lineTo(r, -r);\n\t    context.lineTo(3 * r, -r);\n\t    context.lineTo(3 * r, r);\n\t    context.lineTo(r, r);\n\t    context.lineTo(r, 3 * r);\n\t    context.lineTo(-r, 3 * r);\n\t    context.lineTo(-r, r);\n\t    context.lineTo(-3 * r, r);\n\t    context.closePath();\n\t  }\n\t};\n\t\n\tvar tan30 = Math.sqrt(1 / 3);\n\tvar tan30_2 = tan30 * 2;\n\t\n\tvar diamond = {\n\t  draw: function(context, size) {\n\t    var y = Math.sqrt(size / tan30_2),\n\t        x = y * tan30;\n\t    context.moveTo(0, -y);\n\t    context.lineTo(x, 0);\n\t    context.lineTo(0, y);\n\t    context.lineTo(-x, 0);\n\t    context.closePath();\n\t  }\n\t};\n\t\n\tvar ka = 0.89081309152928522810;\n\tvar kr = Math.sin(pi / 10) / Math.sin(7 * pi / 10);\n\tvar kx = Math.sin(tau / 10) * kr;\n\tvar ky = -Math.cos(tau / 10) * kr;\n\t\n\tvar star = {\n\t  draw: function(context, size) {\n\t    var r = Math.sqrt(size * ka),\n\t        x = kx * r,\n\t        y = ky * r;\n\t    context.moveTo(0, -r);\n\t    context.lineTo(x, y);\n\t    for (var i = 1; i < 5; ++i) {\n\t      var a = tau * i / 5,\n\t          c = Math.cos(a),\n\t          s = Math.sin(a);\n\t      context.lineTo(s * r, -c * r);\n\t      context.lineTo(c * x - s * y, s * x + c * y);\n\t    }\n\t    context.closePath();\n\t  }\n\t};\n\t\n\tvar square = {\n\t  draw: function(context, size) {\n\t    var w = Math.sqrt(size),\n\t        x = -w / 2;\n\t    context.rect(x, x, w, w);\n\t  }\n\t};\n\t\n\tvar sqrt3 = Math.sqrt(3);\n\t\n\tvar triangle = {\n\t  draw: function(context, size) {\n\t    var y = -Math.sqrt(size / (sqrt3 * 3));\n\t    context.moveTo(0, y * 2);\n\t    context.lineTo(-sqrt3 * y, -y);\n\t    context.lineTo(sqrt3 * y, -y);\n\t    context.closePath();\n\t  }\n\t};\n\t\n\tvar c = -0.5;\n\tvar s = Math.sqrt(3) / 2;\n\tvar k = 1 / Math.sqrt(12);\n\tvar a = (k / 2 + 1) * 3;\n\t\n\tvar wye = {\n\t  draw: function(context, size) {\n\t    var r = Math.sqrt(size / a),\n\t        x0 = r / 2,\n\t        y0 = r * k,\n\t        x1 = x0,\n\t        y1 = r * k + r,\n\t        x2 = -x1,\n\t        y2 = y1;\n\t    context.moveTo(x0, y0);\n\t    context.lineTo(x1, y1);\n\t    context.lineTo(x2, y2);\n\t    context.lineTo(c * x0 - s * y0, s * x0 + c * y0);\n\t    context.lineTo(c * x1 - s * y1, s * x1 + c * y1);\n\t    context.lineTo(c * x2 - s * y2, s * x2 + c * y2);\n\t    context.lineTo(c * x0 + s * y0, c * y0 - s * x0);\n\t    context.lineTo(c * x1 + s * y1, c * y1 - s * x1);\n\t    context.lineTo(c * x2 + s * y2, c * y2 - s * x2);\n\t    context.closePath();\n\t  }\n\t};\n\t\n\tvar symbols = [\n\t  circle,\n\t  cross,\n\t  diamond,\n\t  square,\n\t  star,\n\t  triangle,\n\t  wye\n\t];\n\t\n\tvar symbol = function() {\n\t  var type = constant(circle),\n\t      size = constant(64),\n\t      context = null;\n\t\n\t  function symbol() {\n\t    var buffer;\n\t    if (!context) context = buffer = d3Path.path();\n\t    type.apply(this, arguments).draw(context, +size.apply(this, arguments));\n\t    if (buffer) return context = null, buffer + \"\" || null;\n\t  }\n\t\n\t  symbol.type = function(_) {\n\t    return arguments.length ? (type = typeof _ === \"function\" ? _ : constant(_), symbol) : type;\n\t  };\n\t\n\t  symbol.size = function(_) {\n\t    return arguments.length ? (size = typeof _ === \"function\" ? _ : constant(+_), symbol) : size;\n\t  };\n\t\n\t  symbol.context = function(_) {\n\t    return arguments.length ? (context = _ == null ? null : _, symbol) : context;\n\t  };\n\t\n\t  return symbol;\n\t};\n\t\n\tvar noop = function() {};\n\t\n\tfunction point(that, x, y) {\n\t  that._context.bezierCurveTo(\n\t    (2 * that._x0 + that._x1) / 3,\n\t    (2 * that._y0 + that._y1) / 3,\n\t    (that._x0 + 2 * that._x1) / 3,\n\t    (that._y0 + 2 * that._y1) / 3,\n\t    (that._x0 + 4 * that._x1 + x) / 6,\n\t    (that._y0 + 4 * that._y1 + y) / 6\n\t  );\n\t}\n\t\n\tfunction Basis(context) {\n\t  this._context = context;\n\t}\n\t\n\tBasis.prototype = {\n\t  areaStart: function() {\n\t    this._line = 0;\n\t  },\n\t  areaEnd: function() {\n\t    this._line = NaN;\n\t  },\n\t  lineStart: function() {\n\t    this._x0 = this._x1 =\n\t    this._y0 = this._y1 = NaN;\n\t    this._point = 0;\n\t  },\n\t  lineEnd: function() {\n\t    switch (this._point) {\n\t      case 3: point(this, this._x1, this._y1); // proceed\n\t      case 2: this._context.lineTo(this._x1, this._y1); break;\n\t    }\n\t    if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n\t    this._line = 1 - this._line;\n\t  },\n\t  point: function(x, y) {\n\t    x = +x, y = +y;\n\t    switch (this._point) {\n\t      case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n\t      case 1: this._point = 2; break;\n\t      case 2: this._point = 3; this._context.lineTo((5 * this._x0 + this._x1) / 6, (5 * this._y0 + this._y1) / 6); // proceed\n\t      default: point(this, x, y); break;\n\t    }\n\t    this._x0 = this._x1, this._x1 = x;\n\t    this._y0 = this._y1, this._y1 = y;\n\t  }\n\t};\n\t\n\tvar basis = function(context) {\n\t  return new Basis(context);\n\t};\n\t\n\tfunction BasisClosed(context) {\n\t  this._context = context;\n\t}\n\t\n\tBasisClosed.prototype = {\n\t  areaStart: noop,\n\t  areaEnd: noop,\n\t  lineStart: function() {\n\t    this._x0 = this._x1 = this._x2 = this._x3 = this._x4 =\n\t    this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = NaN;\n\t    this._point = 0;\n\t  },\n\t  lineEnd: function() {\n\t    switch (this._point) {\n\t      case 1: {\n\t        this._context.moveTo(this._x2, this._y2);\n\t        this._context.closePath();\n\t        break;\n\t      }\n\t      case 2: {\n\t        this._context.moveTo((this._x2 + 2 * this._x3) / 3, (this._y2 + 2 * this._y3) / 3);\n\t        this._context.lineTo((this._x3 + 2 * this._x2) / 3, (this._y3 + 2 * this._y2) / 3);\n\t        this._context.closePath();\n\t        break;\n\t      }\n\t      case 3: {\n\t        this.point(this._x2, this._y2);\n\t        this.point(this._x3, this._y3);\n\t        this.point(this._x4, this._y4);\n\t        break;\n\t      }\n\t    }\n\t  },\n\t  point: function(x, y) {\n\t    x = +x, y = +y;\n\t    switch (this._point) {\n\t      case 0: this._point = 1; this._x2 = x, this._y2 = y; break;\n\t      case 1: this._point = 2; this._x3 = x, this._y3 = y; break;\n\t      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\t      default: point(this, x, y); break;\n\t    }\n\t    this._x0 = this._x1, this._x1 = x;\n\t    this._y0 = this._y1, this._y1 = y;\n\t  }\n\t};\n\t\n\tvar basisClosed = function(context) {\n\t  return new BasisClosed(context);\n\t};\n\t\n\tfunction BasisOpen(context) {\n\t  this._context = context;\n\t}\n\t\n\tBasisOpen.prototype = {\n\t  areaStart: function() {\n\t    this._line = 0;\n\t  },\n\t  areaEnd: function() {\n\t    this._line = NaN;\n\t  },\n\t  lineStart: function() {\n\t    this._x0 = this._x1 =\n\t    this._y0 = this._y1 = NaN;\n\t    this._point = 0;\n\t  },\n\t  lineEnd: function() {\n\t    if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath();\n\t    this._line = 1 - this._line;\n\t  },\n\t  point: function(x, y) {\n\t    x = +x, y = +y;\n\t    switch (this._point) {\n\t      case 0: this._point = 1; break;\n\t      case 1: this._point = 2; break;\n\t      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\t      case 3: this._point = 4; // proceed\n\t      default: point(this, x, y); break;\n\t    }\n\t    this._x0 = this._x1, this._x1 = x;\n\t    this._y0 = this._y1, this._y1 = y;\n\t  }\n\t};\n\t\n\tvar basisOpen = function(context) {\n\t  return new BasisOpen(context);\n\t};\n\t\n\tfunction Bundle(context, beta) {\n\t  this._basis = new Basis(context);\n\t  this._beta = beta;\n\t}\n\t\n\tBundle.prototype = {\n\t  lineStart: function() {\n\t    this._x = [];\n\t    this._y = [];\n\t    this._basis.lineStart();\n\t  },\n\t  lineEnd: function() {\n\t    var x = this._x,\n\t        y = this._y,\n\t        j = x.length - 1;\n\t\n\t    if (j > 0) {\n\t      var x0 = x[0],\n\t          y0 = y[0],\n\t          dx = x[j] - x0,\n\t          dy = y[j] - y0,\n\t          i = -1,\n\t          t;\n\t\n\t      while (++i <= j) {\n\t        t = i / j;\n\t        this._basis.point(\n\t          this._beta * x[i] + (1 - this._beta) * (x0 + t * dx),\n\t          this._beta * y[i] + (1 - this._beta) * (y0 + t * dy)\n\t        );\n\t      }\n\t    }\n\t\n\t    this._x = this._y = null;\n\t    this._basis.lineEnd();\n\t  },\n\t  point: function(x, y) {\n\t    this._x.push(+x);\n\t    this._y.push(+y);\n\t  }\n\t};\n\t\n\tvar bundle = ((function custom(beta) {\n\t\n\t  function bundle(context) {\n\t    return beta === 1 ? new Basis(context) : new Bundle(context, beta);\n\t  }\n\t\n\t  bundle.beta = function(beta) {\n\t    return custom(+beta);\n\t  };\n\t\n\t  return bundle;\n\t}))(0.85);\n\t\n\tfunction point$1(that, x, y) {\n\t  that._context.bezierCurveTo(\n\t    that._x1 + that._k * (that._x2 - that._x0),\n\t    that._y1 + that._k * (that._y2 - that._y0),\n\t    that._x2 + that._k * (that._x1 - x),\n\t    that._y2 + that._k * (that._y1 - y),\n\t    that._x2,\n\t    that._y2\n\t  );\n\t}\n\t\n\tfunction Cardinal(context, tension) {\n\t  this._context = context;\n\t  this._k = (1 - tension) / 6;\n\t}\n\t\n\tCardinal.prototype = {\n\t  areaStart: function() {\n\t    this._line = 0;\n\t  },\n\t  areaEnd: function() {\n\t    this._line = NaN;\n\t  },\n\t  lineStart: function() {\n\t    this._x0 = this._x1 = this._x2 =\n\t    this._y0 = this._y1 = this._y2 = NaN;\n\t    this._point = 0;\n\t  },\n\t  lineEnd: function() {\n\t    switch (this._point) {\n\t      case 2: this._context.lineTo(this._x2, this._y2); break;\n\t      case 3: point$1(this, this._x1, this._y1); break;\n\t    }\n\t    if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n\t    this._line = 1 - this._line;\n\t  },\n\t  point: function(x, y) {\n\t    x = +x, y = +y;\n\t    switch (this._point) {\n\t      case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n\t      case 1: this._point = 2; this._x1 = x, this._y1 = y; break;\n\t      case 2: this._point = 3; // proceed\n\t      default: point$1(this, x, y); break;\n\t    }\n\t    this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n\t    this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n\t  }\n\t};\n\t\n\tvar cardinal = ((function custom(tension) {\n\t\n\t  function cardinal(context) {\n\t    return new Cardinal(context, tension);\n\t  }\n\t\n\t  cardinal.tension = function(tension) {\n\t    return custom(+tension);\n\t  };\n\t\n\t  return cardinal;\n\t}))(0);\n\t\n\tfunction CardinalClosed(context, tension) {\n\t  this._context = context;\n\t  this._k = (1 - tension) / 6;\n\t}\n\t\n\tCardinalClosed.prototype = {\n\t  areaStart: noop,\n\t  areaEnd: noop,\n\t  lineStart: function() {\n\t    this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 =\n\t    this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN;\n\t    this._point = 0;\n\t  },\n\t  lineEnd: function() {\n\t    switch (this._point) {\n\t      case 1: {\n\t        this._context.moveTo(this._x3, this._y3);\n\t        this._context.closePath();\n\t        break;\n\t      }\n\t      case 2: {\n\t        this._context.lineTo(this._x3, this._y3);\n\t        this._context.closePath();\n\t        break;\n\t      }\n\t      case 3: {\n\t        this.point(this._x3, this._y3);\n\t        this.point(this._x4, this._y4);\n\t        this.point(this._x5, this._y5);\n\t        break;\n\t      }\n\t    }\n\t  },\n\t  point: function(x, y) {\n\t    x = +x, y = +y;\n\t    switch (this._point) {\n\t      case 0: this._point = 1; this._x3 = x, this._y3 = y; break;\n\t      case 1: this._point = 2; this._context.moveTo(this._x4 = x, this._y4 = y); break;\n\t      case 2: this._point = 3; this._x5 = x, this._y5 = y; break;\n\t      default: point$1(this, x, y); break;\n\t    }\n\t    this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n\t    this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n\t  }\n\t};\n\t\n\tvar cardinalClosed = ((function custom(tension) {\n\t\n\t  function cardinal(context) {\n\t    return new CardinalClosed(context, tension);\n\t  }\n\t\n\t  cardinal.tension = function(tension) {\n\t    return custom(+tension);\n\t  };\n\t\n\t  return cardinal;\n\t}))(0);\n\t\n\tfunction CardinalOpen(context, tension) {\n\t  this._context = context;\n\t  this._k = (1 - tension) / 6;\n\t}\n\t\n\tCardinalOpen.prototype = {\n\t  areaStart: function() {\n\t    this._line = 0;\n\t  },\n\t  areaEnd: function() {\n\t    this._line = NaN;\n\t  },\n\t  lineStart: function() {\n\t    this._x0 = this._x1 = this._x2 =\n\t    this._y0 = this._y1 = this._y2 = NaN;\n\t    this._point = 0;\n\t  },\n\t  lineEnd: function() {\n\t    if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath();\n\t    this._line = 1 - this._line;\n\t  },\n\t  point: function(x, y) {\n\t    x = +x, y = +y;\n\t    switch (this._point) {\n\t      case 0: this._point = 1; break;\n\t      case 1: this._point = 2; break;\n\t      case 2: this._point = 3; this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2); break;\n\t      case 3: this._point = 4; // proceed\n\t      default: point$1(this, x, y); break;\n\t    }\n\t    this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n\t    this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n\t  }\n\t};\n\t\n\tvar cardinalOpen = ((function custom(tension) {\n\t\n\t  function cardinal(context) {\n\t    return new CardinalOpen(context, tension);\n\t  }\n\t\n\t  cardinal.tension = function(tension) {\n\t    return custom(+tension);\n\t  };\n\t\n\t  return cardinal;\n\t}))(0);\n\t\n\tfunction point$2(that, x, y) {\n\t  var x1 = that._x1,\n\t      y1 = that._y1,\n\t      x2 = that._x2,\n\t      y2 = that._y2;\n\t\n\t  if (that._l01_a > epsilon) {\n\t    var a = 2 * that._l01_2a + 3 * that._l01_a * that._l12_a + that._l12_2a,\n\t        n = 3 * that._l01_a * (that._l01_a + that._l12_a);\n\t    x1 = (x1 * a - that._x0 * that._l12_2a + that._x2 * that._l01_2a) / n;\n\t    y1 = (y1 * a - that._y0 * that._l12_2a + that._y2 * that._l01_2a) / n;\n\t  }\n\t\n\t  if (that._l23_a > epsilon) {\n\t    var b = 2 * that._l23_2a + 3 * that._l23_a * that._l12_a + that._l12_2a,\n\t        m = 3 * that._l23_a * (that._l23_a + that._l12_a);\n\t    x2 = (x2 * b + that._x1 * that._l23_2a - x * that._l12_2a) / m;\n\t    y2 = (y2 * b + that._y1 * that._l23_2a - y * that._l12_2a) / m;\n\t  }\n\t\n\t  that._context.bezierCurveTo(x1, y1, x2, y2, that._x2, that._y2);\n\t}\n\t\n\tfunction CatmullRom(context, alpha) {\n\t  this._context = context;\n\t  this._alpha = alpha;\n\t}\n\t\n\tCatmullRom.prototype = {\n\t  areaStart: function() {\n\t    this._line = 0;\n\t  },\n\t  areaEnd: function() {\n\t    this._line = NaN;\n\t  },\n\t  lineStart: function() {\n\t    this._x0 = this._x1 = this._x2 =\n\t    this._y0 = this._y1 = this._y2 = NaN;\n\t    this._l01_a = this._l12_a = this._l23_a =\n\t    this._l01_2a = this._l12_2a = this._l23_2a =\n\t    this._point = 0;\n\t  },\n\t  lineEnd: function() {\n\t    switch (this._point) {\n\t      case 2: this._context.lineTo(this._x2, this._y2); break;\n\t      case 3: this.point(this._x2, this._y2); break;\n\t    }\n\t    if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n\t    this._line = 1 - this._line;\n\t  },\n\t  point: function(x, y) {\n\t    x = +x, y = +y;\n\t\n\t    if (this._point) {\n\t      var x23 = this._x2 - x,\n\t          y23 = this._y2 - y;\n\t      this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));\n\t    }\n\t\n\t    switch (this._point) {\n\t      case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n\t      case 1: this._point = 2; break;\n\t      case 2: this._point = 3; // proceed\n\t      default: point$2(this, x, y); break;\n\t    }\n\t\n\t    this._l01_a = this._l12_a, this._l12_a = this._l23_a;\n\t    this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;\n\t    this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n\t    this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n\t  }\n\t};\n\t\n\tvar catmullRom = ((function custom(alpha) {\n\t\n\t  function catmullRom(context) {\n\t    return alpha ? new CatmullRom(context, alpha) : new Cardinal(context, 0);\n\t  }\n\t\n\t  catmullRom.alpha = function(alpha) {\n\t    return custom(+alpha);\n\t  };\n\t\n\t  return catmullRom;\n\t}))(0.5);\n\t\n\tfunction CatmullRomClosed(context, alpha) {\n\t  this._context = context;\n\t  this._alpha = alpha;\n\t}\n\t\n\tCatmullRomClosed.prototype = {\n\t  areaStart: noop,\n\t  areaEnd: noop,\n\t  lineStart: function() {\n\t    this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 =\n\t    this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN;\n\t    this._l01_a = this._l12_a = this._l23_a =\n\t    this._l01_2a = this._l12_2a = this._l23_2a =\n\t    this._point = 0;\n\t  },\n\t  lineEnd: function() {\n\t    switch (this._point) {\n\t      case 1: {\n\t        this._context.moveTo(this._x3, this._y3);\n\t        this._context.closePath();\n\t        break;\n\t      }\n\t      case 2: {\n\t        this._context.lineTo(this._x3, this._y3);\n\t        this._context.closePath();\n\t        break;\n\t      }\n\t      case 3: {\n\t        this.point(this._x3, this._y3);\n\t        this.point(this._x4, this._y4);\n\t        this.point(this._x5, this._y5);\n\t        break;\n\t      }\n\t    }\n\t  },\n\t  point: function(x, y) {\n\t    x = +x, y = +y;\n\t\n\t    if (this._point) {\n\t      var x23 = this._x2 - x,\n\t          y23 = this._y2 - y;\n\t      this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));\n\t    }\n\t\n\t    switch (this._point) {\n\t      case 0: this._point = 1; this._x3 = x, this._y3 = y; break;\n\t      case 1: this._point = 2; this._context.moveTo(this._x4 = x, this._y4 = y); break;\n\t      case 2: this._point = 3; this._x5 = x, this._y5 = y; break;\n\t      default: point$2(this, x, y); break;\n\t    }\n\t\n\t    this._l01_a = this._l12_a, this._l12_a = this._l23_a;\n\t    this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;\n\t    this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n\t    this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n\t  }\n\t};\n\t\n\tvar catmullRomClosed = ((function custom(alpha) {\n\t\n\t  function catmullRom(context) {\n\t    return alpha ? new CatmullRomClosed(context, alpha) : new CardinalClosed(context, 0);\n\t  }\n\t\n\t  catmullRom.alpha = function(alpha) {\n\t    return custom(+alpha);\n\t  };\n\t\n\t  return catmullRom;\n\t}))(0.5);\n\t\n\tfunction CatmullRomOpen(context, alpha) {\n\t  this._context = context;\n\t  this._alpha = alpha;\n\t}\n\t\n\tCatmullRomOpen.prototype = {\n\t  areaStart: function() {\n\t    this._line = 0;\n\t  },\n\t  areaEnd: function() {\n\t    this._line = NaN;\n\t  },\n\t  lineStart: function() {\n\t    this._x0 = this._x1 = this._x2 =\n\t    this._y0 = this._y1 = this._y2 = NaN;\n\t    this._l01_a = this._l12_a = this._l23_a =\n\t    this._l01_2a = this._l12_2a = this._l23_2a =\n\t    this._point = 0;\n\t  },\n\t  lineEnd: function() {\n\t    if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath();\n\t    this._line = 1 - this._line;\n\t  },\n\t  point: function(x, y) {\n\t    x = +x, y = +y;\n\t\n\t    if (this._point) {\n\t      var x23 = this._x2 - x,\n\t          y23 = this._y2 - y;\n\t      this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));\n\t    }\n\t\n\t    switch (this._point) {\n\t      case 0: this._point = 1; break;\n\t      case 1: this._point = 2; break;\n\t      case 2: this._point = 3; this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2); break;\n\t      case 3: this._point = 4; // proceed\n\t      default: point$2(this, x, y); break;\n\t    }\n\t\n\t    this._l01_a = this._l12_a, this._l12_a = this._l23_a;\n\t    this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;\n\t    this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n\t    this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n\t  }\n\t};\n\t\n\tvar catmullRomOpen = ((function custom(alpha) {\n\t\n\t  function catmullRom(context) {\n\t    return alpha ? new CatmullRomOpen(context, alpha) : new CardinalOpen(context, 0);\n\t  }\n\t\n\t  catmullRom.alpha = function(alpha) {\n\t    return custom(+alpha);\n\t  };\n\t\n\t  return catmullRom;\n\t}))(0.5);\n\t\n\tfunction LinearClosed(context) {\n\t  this._context = context;\n\t}\n\t\n\tLinearClosed.prototype = {\n\t  areaStart: noop,\n\t  areaEnd: noop,\n\t  lineStart: function() {\n\t    this._point = 0;\n\t  },\n\t  lineEnd: function() {\n\t    if (this._point) this._context.closePath();\n\t  },\n\t  point: function(x, y) {\n\t    x = +x, y = +y;\n\t    if (this._point) this._context.lineTo(x, y);\n\t    else this._point = 1, this._context.moveTo(x, y);\n\t  }\n\t};\n\t\n\tvar linearClosed = function(context) {\n\t  return new LinearClosed(context);\n\t};\n\t\n\tfunction sign(x) {\n\t  return x < 0 ? -1 : 1;\n\t}\n\t\n\t// Calculate the slopes of the tangents (Hermite-type interpolation) based on\n\t// the following paper: Steffen, M. 1990. A Simple Method for Monotonic\n\t// Interpolation in One Dimension. Astronomy and Astrophysics, Vol. 239, NO.\n\t// NOV(II), P. 443, 1990.\n\tfunction slope3(that, x2, y2) {\n\t  var h0 = that._x1 - that._x0,\n\t      h1 = x2 - that._x1,\n\t      s0 = (that._y1 - that._y0) / (h0 || h1 < 0 && -0),\n\t      s1 = (y2 - that._y1) / (h1 || h0 < 0 && -0),\n\t      p = (s0 * h1 + s1 * h0) / (h0 + h1);\n\t  return (sign(s0) + sign(s1)) * Math.min(Math.abs(s0), Math.abs(s1), 0.5 * Math.abs(p)) || 0;\n\t}\n\t\n\t// Calculate a one-sided slope.\n\tfunction slope2(that, t) {\n\t  var h = that._x1 - that._x0;\n\t  return h ? (3 * (that._y1 - that._y0) / h - t) / 2 : t;\n\t}\n\t\n\t// According to https://en.wikipedia.org/wiki/Cubic_Hermite_spline#Representations\n\t// \"you can express cubic Hermite interpolation in terms of cubic Bézier curves\n\t// with respect to the four values p0, p0 + m0 / 3, p1 - m1 / 3, p1\".\n\tfunction point$3(that, t0, t1) {\n\t  var x0 = that._x0,\n\t      y0 = that._y0,\n\t      x1 = that._x1,\n\t      y1 = that._y1,\n\t      dx = (x1 - x0) / 3;\n\t  that._context.bezierCurveTo(x0 + dx, y0 + dx * t0, x1 - dx, y1 - dx * t1, x1, y1);\n\t}\n\t\n\tfunction MonotoneX(context) {\n\t  this._context = context;\n\t}\n\t\n\tMonotoneX.prototype = {\n\t  areaStart: function() {\n\t    this._line = 0;\n\t  },\n\t  areaEnd: function() {\n\t    this._line = NaN;\n\t  },\n\t  lineStart: function() {\n\t    this._x0 = this._x1 =\n\t    this._y0 = this._y1 =\n\t    this._t0 = NaN;\n\t    this._point = 0;\n\t  },\n\t  lineEnd: function() {\n\t    switch (this._point) {\n\t      case 2: this._context.lineTo(this._x1, this._y1); break;\n\t      case 3: point$3(this, this._t0, slope2(this, this._t0)); break;\n\t    }\n\t    if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n\t    this._line = 1 - this._line;\n\t  },\n\t  point: function(x, y) {\n\t    var t1 = NaN;\n\t\n\t    x = +x, y = +y;\n\t    if (x === this._x1 && y === this._y1) return; // Ignore coincident points.\n\t    switch (this._point) {\n\t      case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n\t      case 1: this._point = 2; break;\n\t      case 2: this._point = 3; point$3(this, slope2(this, t1 = slope3(this, x, y)), t1); break;\n\t      default: point$3(this, this._t0, t1 = slope3(this, x, y)); break;\n\t    }\n\t\n\t    this._x0 = this._x1, this._x1 = x;\n\t    this._y0 = this._y1, this._y1 = y;\n\t    this._t0 = t1;\n\t  }\n\t};\n\t\n\tfunction MonotoneY(context) {\n\t  this._context = new ReflectContext(context);\n\t}\n\t\n\t(MonotoneY.prototype = Object.create(MonotoneX.prototype)).point = function(x, y) {\n\t  MonotoneX.prototype.point.call(this, y, x);\n\t};\n\t\n\tfunction ReflectContext(context) {\n\t  this._context = context;\n\t}\n\t\n\tReflectContext.prototype = {\n\t  moveTo: function(x, y) { this._context.moveTo(y, x); },\n\t  closePath: function() { this._context.closePath(); },\n\t  lineTo: function(x, y) { this._context.lineTo(y, x); },\n\t  bezierCurveTo: function(x1, y1, x2, y2, x, y) { this._context.bezierCurveTo(y1, x1, y2, x2, y, x); }\n\t};\n\t\n\tfunction monotoneX(context) {\n\t  return new MonotoneX(context);\n\t}\n\t\n\tfunction monotoneY(context) {\n\t  return new MonotoneY(context);\n\t}\n\t\n\tfunction Natural(context) {\n\t  this._context = context;\n\t}\n\t\n\tNatural.prototype = {\n\t  areaStart: function() {\n\t    this._line = 0;\n\t  },\n\t  areaEnd: function() {\n\t    this._line = NaN;\n\t  },\n\t  lineStart: function() {\n\t    this._x = [];\n\t    this._y = [];\n\t  },\n\t  lineEnd: function() {\n\t    var x = this._x,\n\t        y = this._y,\n\t        n = x.length;\n\t\n\t    if (n) {\n\t      this._line ? this._context.lineTo(x[0], y[0]) : this._context.moveTo(x[0], y[0]);\n\t      if (n === 2) {\n\t        this._context.lineTo(x[1], y[1]);\n\t      } else {\n\t        var px = controlPoints(x),\n\t            py = controlPoints(y);\n\t        for (var i0 = 0, i1 = 1; i1 < n; ++i0, ++i1) {\n\t          this._context.bezierCurveTo(px[0][i0], py[0][i0], px[1][i0], py[1][i0], x[i1], y[i1]);\n\t        }\n\t      }\n\t    }\n\t\n\t    if (this._line || (this._line !== 0 && n === 1)) this._context.closePath();\n\t    this._line = 1 - this._line;\n\t    this._x = this._y = null;\n\t  },\n\t  point: function(x, y) {\n\t    this._x.push(+x);\n\t    this._y.push(+y);\n\t  }\n\t};\n\t\n\t// See https://www.particleincell.com/2012/bezier-splines/ for derivation.\n\tfunction controlPoints(x) {\n\t  var i,\n\t      n = x.length - 1,\n\t      m,\n\t      a = new Array(n),\n\t      b = new Array(n),\n\t      r = new Array(n);\n\t  a[0] = 0, b[0] = 2, r[0] = x[0] + 2 * x[1];\n\t  for (i = 1; i < n - 1; ++i) a[i] = 1, b[i] = 4, r[i] = 4 * x[i] + 2 * x[i + 1];\n\t  a[n - 1] = 2, b[n - 1] = 7, r[n - 1] = 8 * x[n - 1] + x[n];\n\t  for (i = 1; i < n; ++i) m = a[i] / b[i - 1], b[i] -= m, r[i] -= m * r[i - 1];\n\t  a[n - 1] = r[n - 1] / b[n - 1];\n\t  for (i = n - 2; i >= 0; --i) a[i] = (r[i] - a[i + 1]) / b[i];\n\t  b[n - 1] = (x[n] + a[n - 1]) / 2;\n\t  for (i = 0; i < n - 1; ++i) b[i] = 2 * x[i + 1] - a[i + 1];\n\t  return [a, b];\n\t}\n\t\n\tvar natural = function(context) {\n\t  return new Natural(context);\n\t};\n\t\n\tfunction Step(context, t) {\n\t  this._context = context;\n\t  this._t = t;\n\t}\n\t\n\tStep.prototype = {\n\t  areaStart: function() {\n\t    this._line = 0;\n\t  },\n\t  areaEnd: function() {\n\t    this._line = NaN;\n\t  },\n\t  lineStart: function() {\n\t    this._x = this._y = NaN;\n\t    this._point = 0;\n\t  },\n\t  lineEnd: function() {\n\t    if (0 < this._t && this._t < 1 && this._point === 2) this._context.lineTo(this._x, this._y);\n\t    if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n\t    if (this._line >= 0) this._t = 1 - this._t, this._line = 1 - this._line;\n\t  },\n\t  point: function(x, y) {\n\t    x = +x, y = +y;\n\t    switch (this._point) {\n\t      case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n\t      case 1: this._point = 2; // proceed\n\t      default: {\n\t        if (this._t <= 0) {\n\t          this._context.lineTo(this._x, y);\n\t          this._context.lineTo(x, y);\n\t        } else {\n\t          var x1 = this._x * (1 - this._t) + x * this._t;\n\t          this._context.lineTo(x1, this._y);\n\t          this._context.lineTo(x1, y);\n\t        }\n\t        break;\n\t      }\n\t    }\n\t    this._x = x, this._y = y;\n\t  }\n\t};\n\t\n\tvar step = function(context) {\n\t  return new Step(context, 0.5);\n\t};\n\t\n\tfunction stepBefore(context) {\n\t  return new Step(context, 0);\n\t}\n\t\n\tfunction stepAfter(context) {\n\t  return new Step(context, 1);\n\t}\n\t\n\tvar none = function(series, order) {\n\t  if (!((n = series.length) > 1)) return;\n\t  for (var i = 1, j, s0, s1 = series[order[0]], n, m = s1.length; i < n; ++i) {\n\t    s0 = s1, s1 = series[order[i]];\n\t    for (j = 0; j < m; ++j) {\n\t      s1[j][1] += s1[j][0] = isNaN(s0[j][1]) ? s0[j][0] : s0[j][1];\n\t    }\n\t  }\n\t};\n\t\n\tvar none$1 = function(series) {\n\t  var n = series.length, o = new Array(n);\n\t  while (--n >= 0) o[n] = n;\n\t  return o;\n\t};\n\t\n\tfunction stackValue(d, key) {\n\t  return d[key];\n\t}\n\t\n\tvar stack = function() {\n\t  var keys = constant([]),\n\t      order = none$1,\n\t      offset = none,\n\t      value = stackValue;\n\t\n\t  function stack(data) {\n\t    var kz = keys.apply(this, arguments),\n\t        i,\n\t        m = data.length,\n\t        n = kz.length,\n\t        sz = new Array(n),\n\t        oz;\n\t\n\t    for (i = 0; i < n; ++i) {\n\t      for (var ki = kz[i], si = sz[i] = new Array(m), j = 0, sij; j < m; ++j) {\n\t        si[j] = sij = [0, +value(data[j], ki, j, data)];\n\t        sij.data = data[j];\n\t      }\n\t      si.key = ki;\n\t    }\n\t\n\t    for (i = 0, oz = order(sz); i < n; ++i) {\n\t      sz[oz[i]].index = i;\n\t    }\n\t\n\t    offset(sz, oz);\n\t    return sz;\n\t  }\n\t\n\t  stack.keys = function(_) {\n\t    return arguments.length ? (keys = typeof _ === \"function\" ? _ : constant(slice.call(_)), stack) : keys;\n\t  };\n\t\n\t  stack.value = function(_) {\n\t    return arguments.length ? (value = typeof _ === \"function\" ? _ : constant(+_), stack) : value;\n\t  };\n\t\n\t  stack.order = function(_) {\n\t    return arguments.length ? (order = _ == null ? none$1 : typeof _ === \"function\" ? _ : constant(slice.call(_)), stack) : order;\n\t  };\n\t\n\t  stack.offset = function(_) {\n\t    return arguments.length ? (offset = _ == null ? none : _, stack) : offset;\n\t  };\n\t\n\t  return stack;\n\t};\n\t\n\tvar expand = function(series, order) {\n\t  if (!((n = series.length) > 0)) return;\n\t  for (var i, n, j = 0, m = series[0].length, y; j < m; ++j) {\n\t    for (y = i = 0; i < n; ++i) y += series[i][j][1] || 0;\n\t    if (y) for (i = 0; i < n; ++i) series[i][j][1] /= y;\n\t  }\n\t  none(series, order);\n\t};\n\t\n\tvar diverging = function(series, order) {\n\t  if (!((n = series.length) > 1)) return;\n\t  for (var i, j = 0, d, dy, yp, yn, n, m = series[order[0]].length; j < m; ++j) {\n\t    for (yp = yn = 0, i = 0; i < n; ++i) {\n\t      if ((dy = (d = series[order[i]][j])[1] - d[0]) >= 0) {\n\t        d[0] = yp, d[1] = yp += dy;\n\t      } else if (dy < 0) {\n\t        d[1] = yn, d[0] = yn += dy;\n\t      } else {\n\t        d[0] = yp;\n\t      }\n\t    }\n\t  }\n\t};\n\t\n\tvar silhouette = function(series, order) {\n\t  if (!((n = series.length) > 0)) return;\n\t  for (var j = 0, s0 = series[order[0]], n, m = s0.length; j < m; ++j) {\n\t    for (var i = 0, y = 0; i < n; ++i) y += series[i][j][1] || 0;\n\t    s0[j][1] += s0[j][0] = -y / 2;\n\t  }\n\t  none(series, order);\n\t};\n\t\n\tvar wiggle = function(series, order) {\n\t  if (!((n = series.length) > 0) || !((m = (s0 = series[order[0]]).length) > 0)) return;\n\t  for (var y = 0, j = 1, s0, m, n; j < m; ++j) {\n\t    for (var i = 0, s1 = 0, s2 = 0; i < n; ++i) {\n\t      var si = series[order[i]],\n\t          sij0 = si[j][1] || 0,\n\t          sij1 = si[j - 1][1] || 0,\n\t          s3 = (sij0 - sij1) / 2;\n\t      for (var k = 0; k < i; ++k) {\n\t        var sk = series[order[k]],\n\t            skj0 = sk[j][1] || 0,\n\t            skj1 = sk[j - 1][1] || 0;\n\t        s3 += skj0 - skj1;\n\t      }\n\t      s1 += sij0, s2 += s3 * sij0;\n\t    }\n\t    s0[j - 1][1] += s0[j - 1][0] = y;\n\t    if (s1) y -= s2 / s1;\n\t  }\n\t  s0[j - 1][1] += s0[j - 1][0] = y;\n\t  none(series, order);\n\t};\n\t\n\tvar ascending = function(series) {\n\t  var sums = series.map(sum);\n\t  return none$1(series).sort(function(a, b) { return sums[a] - sums[b]; });\n\t};\n\t\n\tfunction sum(series) {\n\t  var s = 0, i = -1, n = series.length, v;\n\t  while (++i < n) if (v = +series[i][1]) s += v;\n\t  return s;\n\t}\n\t\n\tvar descending$1 = function(series) {\n\t  return ascending(series).reverse();\n\t};\n\t\n\tvar insideOut = function(series) {\n\t  var n = series.length,\n\t      i,\n\t      j,\n\t      sums = series.map(sum),\n\t      order = none$1(series).sort(function(a, b) { return sums[b] - sums[a]; }),\n\t      top = 0,\n\t      bottom = 0,\n\t      tops = [],\n\t      bottoms = [];\n\t\n\t  for (i = 0; i < n; ++i) {\n\t    j = order[i];\n\t    if (top < bottom) {\n\t      top += sums[j];\n\t      tops.push(j);\n\t    } else {\n\t      bottom += sums[j];\n\t      bottoms.push(j);\n\t    }\n\t  }\n\t\n\t  return bottoms.reverse().concat(tops);\n\t};\n\t\n\tvar reverse = function(series) {\n\t  return none$1(series).reverse();\n\t};\n\t\n\texports.arc = arc;\n\texports.area = area;\n\texports.line = line;\n\texports.pie = pie;\n\texports.areaRadial = areaRadial;\n\texports.radialArea = areaRadial;\n\texports.lineRadial = lineRadial$1;\n\texports.radialLine = lineRadial$1;\n\texports.pointRadial = pointRadial;\n\texports.linkHorizontal = linkHorizontal;\n\texports.linkVertical = linkVertical;\n\texports.linkRadial = linkRadial;\n\texports.symbol = symbol;\n\texports.symbols = symbols;\n\texports.symbolCircle = circle;\n\texports.symbolCross = cross;\n\texports.symbolDiamond = diamond;\n\texports.symbolSquare = square;\n\texports.symbolStar = star;\n\texports.symbolTriangle = triangle;\n\texports.symbolWye = wye;\n\texports.curveBasisClosed = basisClosed;\n\texports.curveBasisOpen = basisOpen;\n\texports.curveBasis = basis;\n\texports.curveBundle = bundle;\n\texports.curveCardinalClosed = cardinalClosed;\n\texports.curveCardinalOpen = cardinalOpen;\n\texports.curveCardinal = cardinal;\n\texports.curveCatmullRomClosed = catmullRomClosed;\n\texports.curveCatmullRomOpen = catmullRomOpen;\n\texports.curveCatmullRom = catmullRom;\n\texports.curveLinearClosed = linearClosed;\n\texports.curveLinear = curveLinear;\n\texports.curveMonotoneX = monotoneX;\n\texports.curveMonotoneY = monotoneY;\n\texports.curveNatural = natural;\n\texports.curveStep = step;\n\texports.curveStepAfter = stepAfter;\n\texports.curveStepBefore = stepBefore;\n\texports.stack = stack;\n\texports.stackOffsetExpand = expand;\n\texports.stackOffsetDiverging = diverging;\n\texports.stackOffsetNone = none;\n\texports.stackOffsetSilhouette = silhouette;\n\texports.stackOffsetWiggle = wiggle;\n\texports.stackOrderAscending = ascending;\n\texports.stackOrderDescending = descending$1;\n\texports.stackOrderInsideOut = insideOut;\n\texports.stackOrderNone = none$1;\n\texports.stackOrderReverse = reverse;\n\t\n\tObject.defineProperty(exports, '__esModule', { value: true });\n\t\n\t})));\n\n\n/***/ }),\n/* 25 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t// https://d3js.org/d3-path/ Version 1.0.5. Copyright 2017 Mike Bostock.\n\t(function (global, factory) {\n\t\t true ? factory(exports) :\n\t\ttypeof define === 'function' && define.amd ? define(['exports'], factory) :\n\t\t(factory((global.d3 = global.d3 || {})));\n\t}(this, (function (exports) { 'use strict';\n\t\n\tvar pi = Math.PI;\n\tvar tau = 2 * pi;\n\tvar epsilon = 1e-6;\n\tvar tauEpsilon = tau - epsilon;\n\t\n\tfunction Path() {\n\t  this._x0 = this._y0 = // start of current subpath\n\t  this._x1 = this._y1 = null; // end of current subpath\n\t  this._ = \"\";\n\t}\n\t\n\tfunction path() {\n\t  return new Path;\n\t}\n\t\n\tPath.prototype = path.prototype = {\n\t  constructor: Path,\n\t  moveTo: function(x, y) {\n\t    this._ += \"M\" + (this._x0 = this._x1 = +x) + \",\" + (this._y0 = this._y1 = +y);\n\t  },\n\t  closePath: function() {\n\t    if (this._x1 !== null) {\n\t      this._x1 = this._x0, this._y1 = this._y0;\n\t      this._ += \"Z\";\n\t    }\n\t  },\n\t  lineTo: function(x, y) {\n\t    this._ += \"L\" + (this._x1 = +x) + \",\" + (this._y1 = +y);\n\t  },\n\t  quadraticCurveTo: function(x1, y1, x, y) {\n\t    this._ += \"Q\" + (+x1) + \",\" + (+y1) + \",\" + (this._x1 = +x) + \",\" + (this._y1 = +y);\n\t  },\n\t  bezierCurveTo: function(x1, y1, x2, y2, x, y) {\n\t    this._ += \"C\" + (+x1) + \",\" + (+y1) + \",\" + (+x2) + \",\" + (+y2) + \",\" + (this._x1 = +x) + \",\" + (this._y1 = +y);\n\t  },\n\t  arcTo: function(x1, y1, x2, y2, r) {\n\t    x1 = +x1, y1 = +y1, x2 = +x2, y2 = +y2, r = +r;\n\t    var x0 = this._x1,\n\t        y0 = this._y1,\n\t        x21 = x2 - x1,\n\t        y21 = y2 - y1,\n\t        x01 = x0 - x1,\n\t        y01 = y0 - y1,\n\t        l01_2 = x01 * x01 + y01 * y01;\n\t\n\t    // Is the radius negative? Error.\n\t    if (r < 0) throw new Error(\"negative radius: \" + r);\n\t\n\t    // Is this path empty? Move to (x1,y1).\n\t    if (this._x1 === null) {\n\t      this._ += \"M\" + (this._x1 = x1) + \",\" + (this._y1 = y1);\n\t    }\n\t\n\t    // Or, is (x1,y1) coincident with (x0,y0)? Do nothing.\n\t    else if (!(l01_2 > epsilon)) {}\n\t\n\t    // Or, are (x0,y0), (x1,y1) and (x2,y2) collinear?\n\t    // Equivalently, is (x1,y1) coincident with (x2,y2)?\n\t    // Or, is the radius zero? Line to (x1,y1).\n\t    else if (!(Math.abs(y01 * x21 - y21 * x01) > epsilon) || !r) {\n\t      this._ += \"L\" + (this._x1 = x1) + \",\" + (this._y1 = y1);\n\t    }\n\t\n\t    // Otherwise, draw an arc!\n\t    else {\n\t      var x20 = x2 - x0,\n\t          y20 = y2 - y0,\n\t          l21_2 = x21 * x21 + y21 * y21,\n\t          l20_2 = x20 * x20 + y20 * y20,\n\t          l21 = Math.sqrt(l21_2),\n\t          l01 = Math.sqrt(l01_2),\n\t          l = r * Math.tan((pi - Math.acos((l21_2 + l01_2 - l20_2) / (2 * l21 * l01))) / 2),\n\t          t01 = l / l01,\n\t          t21 = l / l21;\n\t\n\t      // If the start tangent is not coincident with (x0,y0), line to.\n\t      if (Math.abs(t01 - 1) > epsilon) {\n\t        this._ += \"L\" + (x1 + t01 * x01) + \",\" + (y1 + t01 * y01);\n\t      }\n\t\n\t      this._ += \"A\" + r + \",\" + r + \",0,0,\" + (+(y01 * x20 > x01 * y20)) + \",\" + (this._x1 = x1 + t21 * x21) + \",\" + (this._y1 = y1 + t21 * y21);\n\t    }\n\t  },\n\t  arc: function(x, y, r, a0, a1, ccw) {\n\t    x = +x, y = +y, r = +r;\n\t    var dx = r * Math.cos(a0),\n\t        dy = r * Math.sin(a0),\n\t        x0 = x + dx,\n\t        y0 = y + dy,\n\t        cw = 1 ^ ccw,\n\t        da = ccw ? a0 - a1 : a1 - a0;\n\t\n\t    // Is the radius negative? Error.\n\t    if (r < 0) throw new Error(\"negative radius: \" + r);\n\t\n\t    // Is this path empty? Move to (x0,y0).\n\t    if (this._x1 === null) {\n\t      this._ += \"M\" + x0 + \",\" + y0;\n\t    }\n\t\n\t    // Or, is (x0,y0) not coincident with the previous point? Line to (x0,y0).\n\t    else if (Math.abs(this._x1 - x0) > epsilon || Math.abs(this._y1 - y0) > epsilon) {\n\t      this._ += \"L\" + x0 + \",\" + y0;\n\t    }\n\t\n\t    // Is this arc empty? We’re done.\n\t    if (!r) return;\n\t\n\t    // Does the angle go the wrong way? Flip the direction.\n\t    if (da < 0) da = da % tau + tau;\n\t\n\t    // Is this a complete circle? Draw two arcs to complete the circle.\n\t    if (da > tauEpsilon) {\n\t      this._ += \"A\" + r + \",\" + r + \",0,1,\" + cw + \",\" + (x - dx) + \",\" + (y - dy) + \"A\" + r + \",\" + r + \",0,1,\" + cw + \",\" + (this._x1 = x0) + \",\" + (this._y1 = y0);\n\t    }\n\t\n\t    // Is this arc non-empty? Draw an arc!\n\t    else if (da > epsilon) {\n\t      this._ += \"A\" + r + \",\" + r + \",0,\" + (+(da >= pi)) + \",\" + cw + \",\" + (this._x1 = x + r * Math.cos(a1)) + \",\" + (this._y1 = y + r * Math.sin(a1));\n\t    }\n\t  },\n\t  rect: function(x, y, w, h) {\n\t    this._ += \"M\" + (this._x0 = this._x1 = +x) + \",\" + (this._y0 = this._y1 = +y) + \"h\" + (+w) + \"v\" + (+h) + \"h\" + (-w) + \"Z\";\n\t  },\n\t  toString: function() {\n\t    return this._;\n\t  }\n\t};\n\t\n\texports.path = path;\n\t\n\tObject.defineProperty(exports, '__esModule', { value: true });\n\t\n\t})));\n\n\n/***/ }),\n/* 26 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_RESULT__;'use strict';\n\t\n\tvar _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"]) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); } }; }();\n\t\n\tvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\t\n\tfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\t\n\t!(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) {\n\t    'use strict';\n\t\n\t    var _settingsToMajorTickM;\n\t\n\t    var d3Time = __webpack_require__(10);\n\t    var d3TimeFormat = __webpack_require__(11);\n\t\n\t    var _require = __webpack_require__(18),\n\t        axisTimeCombinations = _require.axisTimeCombinations,\n\t        timeBenchmarks = _require.timeBenchmarks;\n\t\n\t    var singleTickWidth = 20;\n\t    var horizontalTickSpacing = 50;\n\t    var minEntryNumForDayFormat = 5;\n\t\n\t    var formatMap = {\n\t        minute: d3TimeFormat.timeFormat('%M m'),\n\t        hour: d3TimeFormat.timeFormat('%H %p'),\n\t        day: d3TimeFormat.timeFormat('%e'),\n\t        daymonth: d3TimeFormat.timeFormat('%d %b'),\n\t        month: d3TimeFormat.timeFormat('%b'),\n\t        year: d3TimeFormat.timeFormat('%Y')\n\t    };\n\t    var localeTimeMap = {\n\t        minute: { minute: 'numeric' },\n\t        hour: { hour: 'numeric' },\n\t        day: { day: 'numeric' },\n\t        daymonth: { day: 'numeric', month: 'short' },\n\t        month: { month: 'short' },\n\t        year: { year: 'numeric' }\n\t    };\n\t    var settingsToMajorTickMap = (_settingsToMajorTickM = {}, _defineProperty(_settingsToMajorTickM, axisTimeCombinations.MINUTE_HOUR, d3Time.timeHour.every(1)), _defineProperty(_settingsToMajorTickM, axisTimeCombinations.HOUR_DAY, d3Time.timeDay.every(1)), _defineProperty(_settingsToMajorTickM, axisTimeCombinations.DAY_MONTH, d3Time.timeMonth.every(1)), _defineProperty(_settingsToMajorTickM, axisTimeCombinations.MONTH_YEAR, d3Time.timeYear.every(1)), _settingsToMajorTickM);\n\t\n\t    /**\n\t     * Figures out the proper settings from the current time span\n\t     * @param  {Number} timeSpan    Span of time charted by the graph in milliseconds\n\t     * @return {String}             Type of settings for the given timeSpan\n\t     */\n\t    var getAxisSettingsFromTimeSpan = function getAxisSettingsFromTimeSpan(timeSpan) {\n\t        var ONE_YEAR = timeBenchmarks.ONE_YEAR,\n\t            ONE_DAY = timeBenchmarks.ONE_DAY;\n\t\n\t        var settings = void 0;\n\t\n\t        if (timeSpan < ONE_DAY) {\n\t            settings = axisTimeCombinations.HOUR_DAY;\n\t        } else if (timeSpan < ONE_YEAR) {\n\t            settings = axisTimeCombinations.DAY_MONTH;\n\t        } else {\n\t            settings = axisTimeCombinations.MONTH_YEAR;\n\t        }\n\t\n\t        return settings;\n\t    };\n\t\n\t    /**\n\t     * Calculates the maximum number of ticks for the x axis\n\t     * @param  {Number} width Chart width\n\t     * @param  {Number} dataPointNumber  Number of entries on the data\n\t     * @return {Number}       Number of ticks to render\n\t     */\n\t    var getMaxNumOfHorizontalTicks = function getMaxNumOfHorizontalTicks(width, dataPointNumber) {\n\t        var ticksForWidth = Math.ceil(width / (singleTickWidth + horizontalTickSpacing));\n\t\n\t        return dataPointNumber < minEntryNumForDayFormat ? d3Time.timeDay : Math.min(dataPointNumber, ticksForWidth);\n\t    };\n\t\n\t    /**\n\t     * Takes a locale (string) and the format to return and returns a function to format dates\n\t     * @param  {String} locale    locale tag eg. en-US, fr-FR, ru-RU\n\t     * @param  {string} timeUnit  minute, hour, day, dayMonth, month, year\n\t     * @return {function}         function that formats dates in the proper locale\n\t     */\n\t    var getLocaleDateFormatter = function getLocaleDateFormatter(locale) {\n\t        var timeUnit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'day';\n\t\n\t        var options = localeTimeMap[timeUnit];\n\t        var formatter = new Intl.DateTimeFormat(locale, options);\n\t\n\t        return function (date) {\n\t            return formatter.format(date);\n\t        };\n\t    };\n\t\n\t    /**\n\t     * Returns tick object to be used when building the x axis\n\t     * @param {dataByDate} dataByDate       Chart data ordered by Date\n\t     * @param {Number} width                Chart width\n\t     * @param {String} settings             Optional forced settings for axis\n\t     * @return {object} tick settings for major and minr axis\n\t     */\n\t    var getXAxisSettings = function getXAxisSettings(dataByDate, width) {\n\t        var settings = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n\t        var locale = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n\t\n\t        var firstDate = new Date(dataByDate[0].date);\n\t        var lastDate = new Date(dataByDate[dataByDate.length - 1].date);\n\t        var dateTimeSpan = lastDate - firstDate;\n\t\n\t        if (locale && (typeof Intl === 'undefined' || (typeof Intl === 'undefined' ? 'undefined' : _typeof(Intl)) === 'object' && !Intl.DateTimeFormat)) {\n\t            locale = null;\n\t        }\n\t\n\t        if (!settings) {\n\t            settings = getAxisSettingsFromTimeSpan(dateTimeSpan);\n\t        }\n\t\n\t        var _settings$split = settings.split('-'),\n\t            _settings$split2 = _slicedToArray(_settings$split, 2),\n\t            minor = _settings$split2[0],\n\t            major = _settings$split2[1];\n\t\n\t        var majorTickValue = settingsToMajorTickMap[settings];\n\t        var minorTickValue = getMaxNumOfHorizontalTicks(width, dataByDate.length);\n\t\n\t        return {\n\t            minor: {\n\t                format: locale ? getLocaleDateFormatter(locale, minor) : formatMap[minor],\n\t                tick: minorTickValue\n\t            },\n\t            major: {\n\t                format: locale ? getLocaleDateFormatter(locale, major) : formatMap[major],\n\t                tick: majorTickValue\n\t            }\n\t        };\n\t    };\n\t\n\t    return {\n\t        getXAxisSettings: getXAxisSettings,\n\t        getLocaleDateFormatter: getLocaleDateFormatter\n\t    };\n\t}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\n/***/ })\n/******/ ])\n});\n;\n\n\n// WEBPACK FOOTER //\n// brush.min.js"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 0a1eb6cfa29181d5999f","define(function(require) {\n    'use strict';\n\n    const d3Array = require('d3-array');\n    const d3Axis = require('d3-axis');\n    const d3Brush = require('d3-brush');\n    const d3Ease = require('d3-ease');\n    const d3Scale = require('d3-scale');\n    const d3Shape = require('d3-shape');\n    const d3Dispatch = require('d3-dispatch');\n    const d3Selection = require('d3-selection');\n    const d3Time = require('d3-time');\n    const d3Transition = require('d3-transition');\n    const d3TimeFormat = require('d3-time-format');\n\n    const colorHelper = require('./helpers/colors');\n    const timeAxisHelper = require('./helpers/timeAxis');\n\n    const {axisTimeCombinations} = require('./helpers/constants');\n\n\n    /**\n     * @typedef BrushChartData\n     * @type {Object[]}\n     * @property {Number} value        Value to chart (required)\n     * @property {Date} date           Date of the value (required)\n     *\n     * @example\n     * [\n     *     {\n     *         value: 1,\n     *         date: '2011-01-06T00:00:00Z'\n     *     },\n     *     {\n     *         value: 2,\n     *         date: '2011-01-07T00:00:00Z'\n     *     }\n     * ]\n     */\n\n    /**\n     * Brush Chart reusable API class that renders a\n     * simple and configurable brush chart.\n     *\n     * @module Brush\n     * @tutorial brush\n     * @requires d3-array, d3-axis, d3-brush, d3-ease, d3-scale, d3-shape, d3-selection, d3-time, d3-time-format\n     *\n     * @example\n     * let brushChart = brush();\n     *\n     * brushChart\n     *     .height(500)\n     *     .width(800);\n     *\n     * d3Selection.select('.css-selector')\n     *     .datum(dataset)\n     *     .call(brushChart);\n     *\n     */\n\n    return function module() {\n\n        let margin = {\n                top: 20,\n                right: 20,\n                bottom: 30,\n                left: 20\n            },\n            width = 960,\n            height = 500,\n            data,\n            svg,\n\n            ease = d3Ease.easeQuadOut,\n\n            dateLabel = 'date',\n            valueLabel = 'value',\n\n            dateRange = [null, null],\n\n            chartWidth, chartHeight,\n            xScale, yScale,\n            xAxis,\n\n            xAxisFormat = null,\n            xTicks = null,\n            xAxisCustomFormat = null,\n\n            brush,\n            chartBrush,\n            handle,\n\n            tickPadding = 5,\n\n            gradient = colorHelper.colorGradients.greenBlue,\n\n            // Dispatcher object to broadcast the mouse events\n            // Ref: https://github.com/mbostock/d3/wiki/Internals#d3_dispatch\n            dispatcher = d3Dispatch.dispatch('customBrushStart', 'customBrushEnd'),\n\n            // extractors\n            getValue = ({value}) => value,\n            getDate = ({date}) => date;\n\n\n        /**\n         * This function creates the graph using the selection as container\n         * @param  {D3Selection} _selection A d3 selection that represents\n         *                                  the container(s) where the chart(s) will be rendered\n         * @param {BrushChartData} _data The data to attach and generate the chart\n         */\n        function exports(_selection){\n            _selection.each(function(_data){\n                chartWidth = width - margin.left - margin.right;\n                chartHeight = height - margin.top - margin.bottom;\n                data = cleanData(cloneData(_data));\n\n                buildScales();\n                buildAxis();\n                buildSVG(this);\n                buildGradient();\n                buildBrush();\n                drawArea();\n                drawAxis();\n                drawBrush();\n                drawHandles();\n            });\n        }\n\n        /**\n         * Creates the d3 x axis, setting orientation\n         * @private\n         */\n        function buildAxis(){\n            let minor, major;\n\n            if (xAxisFormat === 'custom' && typeof xAxisCustomFormat === 'string') {\n                minor = {\n                    tick: xTicks,\n                    format: d3TimeFormat.timeFormat(xAxisCustomFormat)\n                };\n            } else {\n                ({minor, major} = timeAxisHelper.getXAxisSettings(data, width, xAxisFormat));\n            }\n\n            xAxis = d3Axis.axisBottom(xScale)\n                .ticks(minor.tick)\n                .tickSize(10, 0)\n                .tickPadding([tickPadding])\n                .tickFormat(minor.format);\n        }\n\n        /**\n         * Creates the brush element and attaches a listener\n         * @return {void}\n         */\n        function buildBrush() {\n            brush = d3Brush.brushX()\n                .extent([[0, 0], [chartWidth, chartHeight]])\n                .on('brush', handleBrushStart)\n                .on('end', handleBrushEnd);\n        }\n\n        /**\n         * Builds containers for the chart, the axis and a wrapper for all of them\n         * Also applies the Margin convention\n         * @private\n         */\n        function buildContainerGroups(){\n            let container = svg\n              .append('g')\n                .classed('container-group', true)\n                .attr('transform', `translate(${margin.left}, ${margin.top})`);\n\n            container\n              .append('g')\n                .classed('chart-group', true);\n            container\n              .append('g')\n                .classed('metadata-group', true);\n            container\n              .append('g')\n                .classed('x-axis-group', true);\n            container\n              .append('g')\n                .classed('brush-group', true);\n        }\n\n        /**\n         * Creates the gradient on the area\n         * @return {void}\n         */\n        function buildGradient() {\n            let metadataGroup = svg.select('.metadata-group');\n\n            metadataGroup.append('linearGradient')\n                .attr('id', 'brush-area-gradient')\n                .attr('gradientUnits', 'userSpaceOnUse')\n                .attr('x1', 0)\n                .attr('x2', xScale(data[data.length - 1].date))\n                .attr('y1', 0)\n                .attr('y2', 0)\n              .selectAll('stop')\n                .data([\n                    {offset: '0%', color: gradient[0]},\n                    {offset: '100%', color: gradient[1]}\n                ])\n              .enter().append('stop')\n                .attr('offset', ({offset}) => offset)\n                .attr('stop-color', ({color}) => color);\n        }\n\n        /**\n         * Creates the x and y scales of the graph\n         * @private\n         */\n        function buildScales(){\n            xScale = d3Scale.scaleTime()\n                .domain(d3Array.extent(data, getDate ))\n                .range([0, chartWidth]);\n\n            yScale = d3Scale.scaleLinear()\n                .domain([0, d3Array.max(data, getValue)])\n                .range([chartHeight, 0]);\n        }\n\n        /**\n         * Builds the SVG element that will contain the chart\n         * @param  {HTMLElement} container DOM element that will work as the container of the graph\n         * @private\n         */\n        function buildSVG(container){\n            if (!svg) {\n                svg = d3Selection.select(container)\n                  .append('svg')\n                    .classed('britechart brush-chart', true);\n\n                buildContainerGroups();\n            }\n\n            svg\n                .attr('width', width)\n                .attr('height', height);\n        }\n\n        /**\n         * Cleaning data adding the proper format\n         *\n         * @param  {BrushChartData} data Data\n         */\n        function cleanData(data) {\n            return data.map(function (d) {\n                d.date = new Date(d[dateLabel]);\n                d.value = +d[valueLabel];\n\n                return d;\n            });\n        }\n\n        /**\n         * Clones the passed array of data\n         * @param  {Object[]} dataToClone Data to clone\n         * @return {Object[]}             Cloned data\n         */\n        function cloneData(dataToClone) {\n            return JSON.parse(JSON.stringify(dataToClone));\n        }\n\n        /**\n         * Draws the x axis on the svg object within its group\n         *\n         * @private\n         */\n        function drawAxis(){\n            svg.select('.x-axis-group')\n              .append('g')\n                .attr('class', 'x axis')\n                .attr('transform', `translate(0, ${chartHeight})`)\n                .call(xAxis);\n        }\n\n        /**\n         * Draws the area that is going to represent the data\n         *\n         * @return {void}\n         */\n        function drawArea() {\n            // Create and configure the area generator\n            let area = d3Shape.area()\n                .x(({date}) => xScale(date))\n                .y0(chartHeight)\n                .y1(({value}) => yScale(value))\n                .curve(d3Shape.curveBasis);\n\n            // Create the area path\n            svg.select('.chart-group')\n              .append('path')\n                .datum(data)\n                .attr('class', 'brush-area')\n                .attr('d', area);\n        }\n\n        /**\n         * Draws the Brush components on its group\n         * @return {void}\n         */\n        function drawBrush() {\n            chartBrush = svg.select('.brush-group')\n                                .call(brush);\n\n            // Update the height of the brushing rectangle\n            chartBrush.selectAll('rect')\n                .classed('brush-rect', true)\n                .attr('height', chartHeight);\n        }\n\n        /**\n         * Draws a handle for the Brush section\n         * @return {void}\n         */\n        function drawHandles() {\n            let handleFillColor = colorHelper.colorSchemasHuman.grey[1];\n\n            // Styling\n            handle = chartBrush\n                        .selectAll('.handle.brush-rect')\n                        .style('fill', handleFillColor);\n        }\n\n        /**\n         * When a brush event starts, we can extract info from the extension\n         * of the brush.\n         *\n         * @return {void}\n         */\n        function handleBrushStart() {\n            let s = d3Selection.event.selection,\n                dateExtent = s.map(xScale.invert);\n\n            dispatcher.call('customBrushStart', this, dateExtent);\n            // updateHandlers(dateExtent);\n        }\n\n        /**\n         * Processes the end brush event, snapping the boundaries to days\n         * as showed on the example on https://bl.ocks.org/mbostock/6232537\n         * @return {void}\n         * @private\n         */\n        function handleBrushEnd() {\n            if (!d3Selection.event.sourceEvent) return; // Only transition after input.\n            if (!d3Selection.event.selection) return; // Ignore empty selections.\n\n            let s = d3Selection.event.selection,\n                dateExtent = s.map(xScale.invert),\n                dateExtentRounded = dateExtent.map(d3Time.timeDay.round);\n\n            // If empty when rounded, use floor & ceil instead.\n            if (dateExtentRounded[0] >= dateExtentRounded[1]) {\n                dateExtentRounded[0] = d3Time.timeDay.floor(dateExtent[0]);\n                dateExtentRounded[1] = d3Time.timeDay.offset(dateExtentRounded[0]);\n            }\n\n            d3Selection.select(this)\n                .transition()\n                .call(d3Selection.event.target.move, dateExtentRounded.map(xScale));\n\n            dispatcher.call('customBrushEnd', this, dateExtentRounded);\n        }\n\n        /**\n         * Sets a new brush extent within the passed percentage positions\n         * @param {Number} a Percentage of data that the brush start with\n         * @param {Number} b Percentage of data that the brush ends with\n         * @example\n         *     setBrushByPercentages(0.25, 0.5)\n         */\n        function setBrushByPercentages(a, b) {\n            let x0 = a * chartWidth,\n                x1 = b * chartWidth;\n\n            brush\n                .move(chartBrush, [x0, x1]);\n        }\n\n        /**\n         * Sets a new brush extent within the passed dates\n         * @param {String | Date} dateA Initial Date\n         * @param {String | Date} dateB End Date\n         */\n        function setBrushByDates(dateA, dateB) {\n            let x0 = xScale(new Date(dateA)),\n                x1 = xScale(new Date(dateB));\n\n            brush\n                .move(chartBrush, [x0, x1]);\n        }\n\n        /**\n         * Updates visibility and position of the brush handlers\n         * @param  {Number[]} dateExtent Date range\n         * @return {void}\n         */\n        function updateHandlers(dateExtent) {\n            if (dateExtent === null) {\n                handle.attr('display', 'none');\n            } else {\n                handle\n                    .attr('display', null)\n                    .attr('transform', function(d, i) {\n                        return `translate(${dateExtent[i]},${chartHeight / 2})`;\n                    });\n            }\n        }\n\n        // API\n\n        /**\n         * Exposes the constants to be used to force the x axis to respect a certain granularity\n         * current options: MINUTE_HOUR, HOUR_DAY, DAY_MONTH, MONTH_YEAR\n         * @example\n         *     brush.xAxisCustomFormat(brush.axisTimeCombinations.HOUR_DAY)\n         */\n        exports.axisTimeCombinations = axisTimeCombinations;\n\n        /**\n         * Gets or Sets the dateRange for the selected part of the brush\n         * @param  {String[]} _x Desired dateRange for the graph\n         * @return { dateRange | module} Current dateRange or Chart module to chain calls\n         * @public\n         */\n        exports.dateRange = function(_x) {\n            if (!arguments.length) {\n                return dateRange;\n            }\n            dateRange = _x;\n\n            if (Array.isArray(dateRange)) {\n                setBrushByDates(...dateRange);\n            }\n\n            return this;\n        };\n\n        /**\n         * Gets or Sets the gradient of the chart\n         * @param  {String[]} _x        Desired gradient for the graph\n         * @return {String | Module}    Current gradient or Chart module to chain calls\n         * @public\n         */\n        exports.gradient = function(_x) {\n            if (!arguments.length) {\n                return gradient;\n            }\n            gradient = _x;\n\n            return this;\n        };\n\n        /**\n         * Gets or Sets the height of the chart\n         * @param  {Number} _x          Desired width for the graph\n         * @return {Number | Module}    Current height or Chart module to chain calls\n         * @public\n         */\n        exports.height = function(_x) {\n            if (!arguments.length) {\n                return height;\n            }\n            height = _x;\n\n            return this;\n        };\n\n        /**\n         * Gets or Sets the margin of the chart\n         * @param  {Object} _x          Margin object to get/set\n         * @return {Object | Module}    Current margin or Chart module to chain calls\n         * @public\n         */\n        exports.margin = function(_x) {\n            if (!arguments.length) {\n                return margin;\n            }\n            margin = _x;\n\n            return this;\n        };\n\n        /**\n         * Exposes an 'on' method that acts as a bridge with the event dispatcher\n         * We are going to expose this events:\n         * customMouseOver, customMouseMove and customMouseOut\n         *\n         * @return {module} Bar Chart\n         * @public\n         */\n        exports.on = function() {\n            let value = dispatcher.on.apply(dispatcher, arguments);\n\n            return value === dispatcher ? exports : value;\n        };\n\n        /**\n         * Gets or Sets the width of the chart\n         * @param  {Number} _x          Desired width for the graph\n         * @return {Number | Module}    Current width or Chart module to chain calls\n         * @public\n         */\n        exports.width = function(_x) {\n            if (!arguments.length) {\n                return width;\n            }\n            width = _x;\n\n            return this;\n        };\n\n        /**\n         * Exposes the ability to force the chart to show a certain x format\n         * It requires a `xAxisFormat` of 'custom' in order to work.\n         * @param  {String} _x              Desired format for x axis\n         * @return {String | Module}        Current format or module to chain calls\n         */\n        exports.xAxisCustomFormat = function(_x) {\n            if (!arguments.length) {\n              return xAxisCustomFormat;\n            }\n            xAxisCustomFormat = _x;\n\n            return this;\n        };\n\n        /**\n         * Exposes the ability to force the chart to show a certain x axis grouping\n         * @param  {String} _x          Desired format\n         * @return {String | Module}    Current format or module to chain calls\n         * @example\n         *     brush.xAxisFormat(brush.axisTimeCombinations.HOUR_DAY)\n         */\n        exports.xAxisFormat = function(_x) {\n            if (!arguments.length) {\n              return xAxisFormat;\n            }\n            xAxisFormat = _x;\n\n            return this;\n        };\n\n        /**\n         * Exposes the ability to force the chart to show a certain x ticks. It requires a `xAxisCustomFormat` of 'custom' in order to work.\n         * NOTE: This value needs to be a multiple of 2, 5 or 10. They won't always work as expected, as D3 decides at the end\n         * how many and where the ticks will appear.\n         *\n         * @param  {Number} _x              Desired number of x axis ticks (multiple of 2, 5 or 10)\n         * @return {Number | Module}        Current number or ticks or module to chain calls\n         */\n        exports.xTicks = function(_x) {\n            if (!arguments.length) {\n              return xTicks;\n            }\n            xTicks = _x;\n\n            return this;\n        };\n\n        return exports;\n    };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./src/charts/brush.js","// https://d3js.org/d3-array/ Version 1.2.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 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 pairs = function(array, f) {\n  if (f == null) f = pair;\n  var i = 0, n = array.length - 1, p = array[0], pairs = new Array(n < 0 ? 0 : n);\n  while (i < n) pairs[i] = f(p, p = array[++i]);\n  return pairs;\n};\n\nfunction pair(a, b) {\n  return [a, b];\n}\n\nvar cross = function(values0, values1, reduce) {\n  var n0 = values0.length,\n      n1 = values1.length,\n      values = new Array(n0 * n1),\n      i0,\n      i1,\n      i,\n      value0;\n\n  if (reduce == null) reduce = pair;\n\n  for (i0 = i = 0; i0 < n0; ++i0) {\n    for (value0 = values0[i0], i1 = 0; i1 < n1; ++i1, ++i) {\n      values[i] = reduce(value0, values1[i1]);\n    }\n  }\n\n  return values;\n};\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(values, valueof) {\n  var n = values.length,\n      m = 0,\n      i = -1,\n      mean = 0,\n      value,\n      delta,\n      sum = 0;\n\n  if (valueof == null) {\n    while (++i < n) {\n      if (!isNaN(value = number(values[i]))) {\n        delta = value - mean;\n        mean += delta / ++m;\n        sum += delta * (value - mean);\n      }\n    }\n  }\n\n  else {\n    while (++i < n) {\n      if (!isNaN(value = number(valueof(values[i], i, values)))) {\n        delta = value - mean;\n        mean += delta / ++m;\n        sum += delta * (value - mean);\n      }\n    }\n  }\n\n  if (m > 1) return sum / (m - 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(values, valueof) {\n  var n = values.length,\n      i = -1,\n      value,\n      min,\n      max;\n\n  if (valueof == null) {\n    while (++i < n) { // Find the first comparable value.\n      if ((value = values[i]) != null && value >= value) {\n        min = max = value;\n        while (++i < n) { // Compare the remaining values.\n          if ((value = values[i]) != null) {\n            if (min > value) min = value;\n            if (max < value) max = value;\n          }\n        }\n      }\n    }\n  }\n\n  else {\n    while (++i < n) { // Find the first comparable value.\n      if ((value = valueof(values[i], i, values)) != null && value >= value) {\n        min = max = value;\n        while (++i < n) { // Compare the remaining values.\n          if ((value = valueof(values[i], i, values)) != null) {\n            if (min > value) min = value;\n            if (max < value) max = value;\n          }\n        }\n      }\n    }\n  }\n\n  return [min, max];\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 range = 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 reverse = stop < start,\n      i = -1,\n      n,\n      ticks,\n      step;\n\n  if (reverse) n = start, start = stop, stop = n;\n\n  if ((step = tickIncrement(start, stop, count)) === 0 || !isFinite(step)) return [];\n\n  if (step > 0) {\n    start = Math.ceil(start / step);\n    stop = Math.floor(stop / step);\n    ticks = new Array(n = Math.ceil(stop - start + 1));\n    while (++i < n) ticks[i] = (start + i) * step;\n  } else {\n    start = Math.floor(start * step);\n    stop = Math.ceil(stop * step);\n    ticks = new Array(n = Math.ceil(start - stop + 1));\n    while (++i < n) ticks[i] = (start - i) / step;\n  }\n\n  if (reverse) ticks.reverse();\n\n  return ticks;\n};\n\nfunction tickIncrement(start, stop, count) {\n  var step = (stop - start) / Math.max(0, count),\n      power = Math.floor(Math.log(step) / Math.LN10),\n      error = step / Math.pow(10, power);\n  return power >= 0\n      ? (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1) * Math.pow(10, power)\n      : -Math.pow(10, -power) / (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1);\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)) {\n      tz = tickStep(x0, x1, tz);\n      tz = range(Math.ceil(x0 / tz) * tz, Math.floor(x1 / tz) * tz, tz); // exclusive\n    }\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 quantile = function(values, p, valueof) {\n  if (valueof == null) valueof = number;\n  if (!(n = values.length)) return;\n  if ((p = +p) <= 0 || n < 2) return +valueof(values[0], 0, values);\n  if (p >= 1) return +valueof(values[n - 1], n - 1, values);\n  var n,\n      i = (n - 1) * p,\n      i0 = Math.floor(i),\n      value0 = +valueof(values[i0], i0, values),\n      value1 = +valueof(values[i0 + 1], i0 + 1, values);\n  return value0 + (value1 - value0) * (i - i0);\n};\n\nvar freedmanDiaconis = function(values, min, max) {\n  values = map.call(values, number).sort(ascending);\n  return Math.ceil((max - min) / (2 * (quantile(values, 0.75) - quantile(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(values, valueof) {\n  var n = values.length,\n      i = -1,\n      value,\n      max;\n\n  if (valueof == null) {\n    while (++i < n) { // Find the first comparable value.\n      if ((value = values[i]) != null && value >= value) {\n        max = value;\n        while (++i < n) { // Compare the remaining values.\n          if ((value = values[i]) != null && value > max) {\n            max = value;\n          }\n        }\n      }\n    }\n  }\n\n  else {\n    while (++i < n) { // Find the first comparable value.\n      if ((value = valueof(values[i], i, values)) != null && value >= value) {\n        max = value;\n        while (++i < n) { // Compare the remaining values.\n          if ((value = valueof(values[i], i, values)) != null && value > max) {\n            max = value;\n          }\n        }\n      }\n    }\n  }\n\n  return max;\n};\n\nvar mean = function(values, valueof) {\n  var n = values.length,\n      m = n,\n      i = -1,\n      value,\n      sum = 0;\n\n  if (valueof == null) {\n    while (++i < n) {\n      if (!isNaN(value = number(values[i]))) sum += value;\n      else --m;\n    }\n  }\n\n  else {\n    while (++i < n) {\n      if (!isNaN(value = number(valueof(values[i], i, values)))) sum += value;\n      else --m;\n    }\n  }\n\n  if (m) return sum / m;\n};\n\nvar median = function(values, valueof) {\n  var n = values.length,\n      i = -1,\n      value,\n      numbers = [];\n\n  if (valueof == null) {\n    while (++i < n) {\n      if (!isNaN(value = number(values[i]))) {\n        numbers.push(value);\n      }\n    }\n  }\n\n  else {\n    while (++i < n) {\n      if (!isNaN(value = number(valueof(values[i], i, values)))) {\n        numbers.push(value);\n      }\n    }\n  }\n\n  return quantile(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(values, valueof) {\n  var n = values.length,\n      i = -1,\n      value,\n      min;\n\n  if (valueof == null) {\n    while (++i < n) { // Find the first comparable value.\n      if ((value = values[i]) != null && value >= value) {\n        min = value;\n        while (++i < n) { // Compare the remaining values.\n          if ((value = values[i]) != null && min > value) {\n            min = value;\n          }\n        }\n      }\n    }\n  }\n\n  else {\n    while (++i < n) { // Find the first comparable value.\n      if ((value = valueof(values[i], i, values)) != null && value >= value) {\n        min = value;\n        while (++i < n) { // Compare the remaining values.\n          if ((value = valueof(values[i], i, values)) != null && min > value) {\n            min = value;\n          }\n        }\n      }\n    }\n  }\n\n  return min;\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(values, compare) {\n  if (!(n = values.length)) return;\n  var n,\n      i = 0,\n      j = 0,\n      xi,\n      xj = values[j];\n\n  if (compare == null) compare = ascending;\n\n  while (++i < n) {\n    if (compare(xi = values[i], xj) < 0 || compare(xj, xj) !== 0) {\n      xj = xi, j = i;\n    }\n  }\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(values, valueof) {\n  var n = values.length,\n      i = -1,\n      value,\n      sum = 0;\n\n  if (valueof == null) {\n    while (++i < n) {\n      if (value = +values[i]) sum += value; // Note: zero and null are equivalent.\n    }\n  }\n\n  else {\n    while (++i < n) {\n      if (value = +valueof(values[i], i, values)) sum += value;\n    }\n  }\n\n  return sum;\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\nexports.bisect = bisectRight;\nexports.bisectRight = bisectRight;\nexports.bisectLeft = bisectLeft;\nexports.ascending = ascending;\nexports.bisector = bisector;\nexports.cross = cross;\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 = quantile;\nexports.range = range;\nexports.scan = scan;\nexports.shuffle = shuffle;\nexports.sum = sum;\nexports.ticks = ticks;\nexports.tickIncrement = tickIncrement;\nexports.tickStep = tickStep;\nexports.transpose = transpose;\nexports.variance = variance;\nexports.zip = zip;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3-array/build/d3-array.js\n// module id = 1\n// module chunks = 0 1 3 4 5 6 7 8 9 10 11","// https://d3js.org/d3-ease/ Version 1.0.3. 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\nfunction linear(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\nexports.easeLinear = linear;\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;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3-ease/build/d3-ease.js\n// module id = 2\n// module chunks = 0 1 3 4 5 6 7 8 9 10 11 12","// https://d3js.org/d3-axis/ Version 1.0.8. 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 slice = Array.prototype.slice;\n\nvar identity = 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(x) {\n  return \"translate(\" + (x + 0.5) + \",0)\";\n}\n\nfunction translateY(y) {\n  return \"translate(0,\" + (y + 0.5) + \")\";\n}\n\nfunction number(scale) {\n  return function(d) {\n    return +scale(d);\n  };\n}\n\nfunction center(scale) {\n  var offset = Math.max(0, scale.bandwidth() - 1) / 2; // Adjust for 0.5px offset.\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      k = orient === top || orient === left ? -1 : 1,\n      x = orient === left || orient === right ? \"x\" : \"y\",\n      transform = orient === top || orient === bottom ? translateX : translateY;\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) : tickFormat,\n        spacing = Math.max(tickSizeInner, 0) + tickPadding,\n        range = scale.range(),\n        range0 = +range[0] + 0.5,\n        range1 = +range[range.length - 1] + 0.5,\n        position = (scale.bandwidth ? center : number)(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\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\n    text = text.merge(tickEnter.append(\"text\")\n        .attr(\"fill\", \"#000\")\n        .attr(x, k * spacing)\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 isFinite(d = position(d)) ? transform(d) : this.getAttribute(\"transform\"); });\n\n      tickEnter\n          .attr(\"opacity\", epsilon)\n          .attr(\"transform\", function(d) { var p = this.parentNode.__axis; return transform(p && isFinite(p = p(d)) ? p : 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(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.call(arguments), axis;\n  };\n\n  axis.tickArguments = function(_) {\n    return arguments.length ? (tickArguments = _ == null ? [] : slice.call(_), axis) : tickArguments.slice();\n  };\n\n  axis.tickValues = function(_) {\n    return arguments.length ? (tickValues = _ == null ? null : slice.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\nexports.axisTop = axisTop;\nexports.axisRight = axisRight;\nexports.axisBottom = axisBottom;\nexports.axisLeft = axisLeft;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3-axis/build/d3-axis.js\n// module id = 3\n// module chunks = 0 1 4 6 9 10 11","// https://d3js.org/d3-color/ Version 1.0.3. 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 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\nexports.color = color;\nexports.rgb = rgb;\nexports.hsl = hsl;\nexports.lab = lab;\nexports.hcl = hcl;\nexports.cubehelix = cubehelix;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3-color/build/d3-color.js\n// module id = 4\n// module chunks = 0 1 3 4 5 6 7 8 9 10 11 12","// https://d3js.org/d3-dispatch/ Version 1.0.3. 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 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\nexports.dispatch = dispatch;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3-dispatch/build/d3-dispatch.js\n// module id = 5\n// module chunks = 0 1 3 4 5 6 7 8 9 10 11 12","// https://d3js.org/d3-format/ Version 1.2.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\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 = 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 formatNumerals = function(numerals) {\n  return function(value) {\n    return value.replace(/[0-9]/g, function(i) {\n      return numerals[+i];\n    });\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\nfunction formatSpecifier(specifier) {\n  return new FormatSpecifier(specifier);\n}\n\nformatSpecifier.prototype = FormatSpecifier.prototype; // instanceof\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 identity = function(x) {\n  return x;\n};\n\nvar prefixes = [\"y\",\"z\",\"a\",\"f\",\"p\",\"n\",\"µ\",\"m\",\"\",\"k\",\"M\",\"G\",\"T\",\"P\",\"E\",\"Z\",\"Y\"];\n\nvar formatLocale = function(locale) {\n  var group = locale.grouping && locale.thousands ? formatGroup(locale.grouping, locale.thousands) : identity,\n      currency = locale.currency,\n      decimal = locale.decimal,\n      numerals = locale.numerals ? formatNumerals(locale.numerals) : identity,\n      percent = locale.percent || \"%\";\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) ? percent : \"\";\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        // Perform the initial formatting.\n        var valueNegative = value < 0;\n        value = formatType(Math.abs(value), precision);\n\n        // If a negative value rounds to zero during formatting, treat as positive.\n        if (valueNegative && +value === 0) valueNegative = false;\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 \"<\": value = valuePrefix + value + valueSuffix + padding; break;\n        case \"=\": value = valuePrefix + padding + value + valueSuffix; break;\n        case \"^\": value = padding.slice(0, length = padding.length >> 1) + valuePrefix + value + valueSuffix + padding.slice(length); break;\n        default: value = padding + valuePrefix + value + valueSuffix; break;\n      }\n\n      return numerals(value);\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(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;\n\n\n\ndefaultLocale({\n  decimal: \".\",\n  thousands: \",\",\n  grouping: [3],\n  currency: [\"$\", \"\"]\n});\n\nfunction defaultLocale(definition) {\n  locale = formatLocale(definition);\n  exports.format = locale.format;\n  exports.formatPrefix = locale.formatPrefix;\n  return locale;\n}\n\nvar precisionFixed = function(step) {\n  return Math.max(0, -exponent(Math.abs(step)));\n};\n\nvar precisionPrefix = function(step, value) {\n  return Math.max(0, Math.max(-8, Math.min(8, Math.floor(exponent(value) / 3))) * 3 - exponent(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(max) - exponent(step)) + 1;\n};\n\nexports.formatDefaultLocale = defaultLocale;\nexports.formatLocale = formatLocale;\nexports.formatSpecifier = formatSpecifier;\nexports.precisionFixed = precisionFixed;\nexports.precisionPrefix = precisionPrefix;\nexports.precisionRound = precisionRound;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3-format/build/d3-format.js\n// module id = 6\n// module chunks = 0 1 3 4 5 6 7 8 9 10 11 12","// https://d3js.org/d3-scale/ Version 1.0.6. Copyright 2017 Mike Bostock.\n(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('d3-array'), require('d3-collection'), require('d3-interpolate'), require('d3-format'), require('d3-time'), require('d3-time-format'), require('d3-color')) :\n\ttypeof define === 'function' && define.amd ? define(['exports', 'd3-array', 'd3-collection', 'd3-interpolate', 'd3-format', 'd3-time', 'd3-time-format', 'd3-color'], factory) :\n\t(factory((global.d3 = global.d3 || {}),global.d3,global.d3,global.d3,global.d3,global.d3,global.d3,global.d3));\n}(this, (function (exports,d3Array,d3Collection,d3Interpolate,d3Format,d3Time,d3TimeFormat,d3Color) { 'use strict';\n\nvar array = Array.prototype;\n\nvar map$1 = array.map;\nvar slice = array.slice;\n\nvar implicit = {name: \"implicit\"};\n\nfunction ordinal(range$$1) {\n  var index = d3Collection.map(),\n      domain = [],\n      unknown = implicit;\n\n  range$$1 = range$$1 == null ? [] : slice.call(range$$1);\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$$1[(i - 1) % range$$1.length];\n  }\n\n  scale.domain = function(_) {\n    if (!arguments.length) return domain.slice();\n    domain = [], index = d3Collection.map();\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$$1 = slice.call(_), scale) : range$$1.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$$1)\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 = d3Array.range(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() {\n  return pointish(band().paddingInner(1));\n}\n\nvar constant = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nvar number = 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(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 = d3Array.bisect(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 = d3Interpolate.interpolate,\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$1.call(_, number), rescale()) : domain.slice();\n  };\n\n  scale.range = function(_) {\n    return arguments.length ? (range$$1 = slice.call(_), rescale()) : range$$1.slice();\n  };\n\n  scale.rangeRound = function(_) {\n    return range$$1 = slice.call(_), interpolate$$1 = d3Interpolate.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 = d3Array.tickStep(start, stop, count == null ? 10 : count),\n      precision;\n  specifier = d3Format.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 = d3Format.precisionPrefix(step, value))) specifier.precision = precision;\n      return d3Format.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 = d3Format.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 = d3Format.precisionFixed(step))) specifier.precision = precision - (specifier.type === \"%\") * 2;\n      break;\n    }\n  }\n  return d3Format.format(specifier);\n};\n\nfunction linearish(scale) {\n  var domain = scale.domain;\n\n  scale.ticks = function(count) {\n    var d = domain();\n    return d3Array.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    if (count == null) count = 10;\n\n    var d = domain(),\n        i0 = 0,\n        i1 = d.length - 1,\n        start = d[i0],\n        stop = d[i1],\n        step;\n\n    if (stop < start) {\n      step = start, start = stop, stop = step;\n      step = i0, i0 = i1, i1 = step;\n    }\n\n    step = d3Array.tickIncrement(start, stop, count);\n\n    if (step > 0) {\n      start = Math.floor(start / step) * step;\n      stop = Math.ceil(stop / step) * step;\n      step = d3Array.tickIncrement(start, stop, count);\n    } else if (step < 0) {\n      start = Math.ceil(start * step) / step;\n      stop = Math.floor(stop * step) / step;\n      step = d3Array.tickIncrement(start, stop, count);\n    }\n\n    if (step > 0) {\n      d[i0] = Math.floor(start / step) * step;\n      d[i1] = Math.ceil(stop / step) * step;\n      domain(d);\n    } else if (step < 0) {\n      d[i0] = Math.ceil(start * step) / step;\n      d[i1] = Math.floor(stop * step) / step;\n      domain(d);\n    }\n\n    return scale;\n  };\n\n  return scale;\n}\n\nfunction linear() {\n  var scale = continuous(deinterpolateLinear, d3Interpolate.interpolateNumber);\n\n  scale.copy = function() {\n    return copy(scale, linear());\n  };\n\n  return linearish(scale);\n}\n\nfunction identity() {\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$1.call(_, number), scale) : domain.slice();\n  };\n\n  scale.copy = function() {\n    return identity().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(b);\n}\n\nfunction reinterpolate(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() {\n  var scale = continuous(deinterpolate, reinterpolate).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 = d3Array.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 = d3Format.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().base(base));\n  };\n\n  return scale;\n}\n\nfunction raise(x, exponent) {\n  return x < 0 ? -Math.pow(-x, exponent) : Math.pow(x, exponent);\n}\n\nfunction pow() {\n  var exponent = 1,\n      scale = continuous(deinterpolate, reinterpolate),\n      domain = scale.domain;\n\n  function deinterpolate(a, b) {\n    return (b = raise(b, exponent) - (a = raise(a, exponent)))\n        ? function(x) { return (raise(x, exponent) - a) / b; }\n        : constant(b);\n  }\n\n  function reinterpolate(a, b) {\n    b = raise(b, exponent) - (a = raise(a, exponent));\n    return function(t) { return raise(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().exponent(exponent));\n  };\n\n  return linearish(scale);\n}\n\nfunction sqrt() {\n  return pow().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] = d3Array.quantile(domain, i / n);\n    return scale;\n  }\n\n  function scale(x) {\n    if (!isNaN(x = +x)) return range$$1[d3Array.bisect(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(d3Array.ascending);\n    return rescale();\n  };\n\n  scale.range = function(_) {\n    return arguments.length ? (range$$1 = slice.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() {\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[d3Array.bisect(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.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()\n        .domain([x0, x1])\n        .range(range$$1);\n  };\n\n  return linearish(scale);\n}\n\nfunction threshold() {\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[d3Array.bisect(domain, x, 0, n)];\n  }\n\n  scale.domain = function(_) {\n    return arguments.length ? (domain = slice.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.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()\n        .domain(domain)\n        .range(range$$1);\n  };\n\n  return scale;\n}\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(t) {\n  return new Date(t);\n}\n\nfunction number$1(t) {\n  return t instanceof Date ? +t : +new Date(+t);\n}\n\nfunction calendar(year, month, week, day, hour, minute, second, millisecond, format$$1) {\n  var scale = continuous(deinterpolateLinear, d3Interpolate.interpolateNumber),\n      invert = scale.invert,\n      domain = scale.domain;\n\n  var formatMillisecond = format$$1(\".%L\"),\n      formatSecond = format$$1(\":%S\"),\n      formatMinute = format$$1(\"%I:%M\"),\n      formatHour = format$$1(\"%I %p\"),\n      formatDay = format$$1(\"%a %d\"),\n      formatWeek = format$$1(\"%b %d\"),\n      formatMonth = format$$1(\"%B\"),\n      formatYear = format$$1(\"%Y\");\n\n  var tickIntervals = [\n    [second,  1,      durationSecond],\n    [second,  5,  5 * durationSecond],\n    [second, 15, 15 * durationSecond],\n    [second, 30, 30 * durationSecond],\n    [minute,  1,      durationMinute],\n    [minute,  5,  5 * durationMinute],\n    [minute, 15, 15 * durationMinute],\n    [minute, 30, 30 * durationMinute],\n    [  hour,  1,      durationHour  ],\n    [  hour,  3,  3 * durationHour  ],\n    [  hour,  6,  6 * durationHour  ],\n    [  hour, 12, 12 * durationHour  ],\n    [   day,  1,      durationDay   ],\n    [   day,  2,  2 * durationDay   ],\n    [  week,  1,      durationWeek  ],\n    [ month,  1,      durationMonth ],\n    [ month,  3,  3 * durationMonth ],\n    [  year,  1,      durationYear  ]\n  ];\n\n  function tickFormat(date) {\n    return (second(date) < date ? formatMillisecond\n        : minute(date) < date ? formatSecond\n        : hour(date) < date ? formatMinute\n        : day(date) < date ? formatHour\n        : month(date) < date ? (week(date) < date ? formatDay : formatWeek)\n        : year(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 = d3Array.bisector(function(i) { return i[2]; }).right(tickIntervals, target);\n      if (i === tickIntervals.length) {\n        step = d3Array.tickStep(start / durationYear, stop / durationYear, interval);\n        interval = year;\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 = d3Array.tickStep(start, stop, interval);\n        interval = millisecond;\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$1.call(_, number$1)) : domain().map(date);\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$$1(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, month, week, day, hour, minute, second, millisecond, format$$1));\n  };\n\n  return scale;\n}\n\nvar time = function() {\n  return calendar(d3Time.timeYear, d3Time.timeMonth, d3Time.timeWeek, d3Time.timeDay, d3Time.timeHour, d3Time.timeMinute, d3Time.timeSecond, d3Time.timeMillisecond, d3TimeFormat.timeFormat).domain([new Date(2000, 0, 1), new Date(2000, 0, 2)]);\n};\n\nvar utcTime = function() {\n  return calendar(d3Time.utcYear, d3Time.utcMonth, d3Time.utcWeek, d3Time.utcDay, d3Time.utcHour, d3Time.utcMinute, d3Time.utcSecond, d3Time.utcMillisecond, d3TimeFormat.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$1 = d3Interpolate.interpolateCubehelixLong(d3Color.cubehelix(300, 0.5, 0.0), d3Color.cubehelix(-240, 0.5, 1.0));\n\nvar warm = d3Interpolate.interpolateCubehelixLong(d3Color.cubehelix(-100, 0.75, 0.35), d3Color.cubehelix(80, 1.50, 0.8));\n\nvar cool = d3Interpolate.interpolateCubehelixLong(d3Color.cubehelix(260, 0.75, 0.35), d3Color.cubehelix(80, 1.50, 0.8));\n\nvar rainbow = d3Color.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$$1) {\n  var n = range$$1.length;\n  return function(t) {\n    return range$$1[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\nexports.scaleBand = band;\nexports.scalePoint = point;\nexports.scaleIdentity = identity;\nexports.scaleLinear = linear;\nexports.scaleLog = log;\nexports.scaleOrdinal = ordinal;\nexports.scaleImplicit = implicit;\nexports.scalePow = pow;\nexports.scaleSqrt = sqrt;\nexports.scaleQuantile = quantile$1;\nexports.scaleQuantize = quantize;\nexports.scaleThreshold = threshold;\nexports.scaleTime = time;\nexports.scaleUtc = utcTime;\nexports.schemeCategory10 = category10;\nexports.schemeCategory20b = category20b;\nexports.schemeCategory20c = category20c;\nexports.schemeCategory20 = category20;\nexports.interpolateCubehelixDefault = cubehelix$1;\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;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3-scale/build/d3-scale.js\n// module id = 7\n// module chunks = 0 1 3 4 5 6 8 9 10 11","// https://d3js.org/d3-collection/ Version 1.0.4. 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 prefix = \"$\";\n\nfunction Map() {}\n\nMap.prototype = map.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(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) {\n      if (sortValues != null) array.sort(sortValues);\n      return rollup != null ? rollup(array) : array;\n    }\n\n    var i = -1,\n        n = array.length,\n        key = keys[depth++],\n        keyValue,\n        value,\n        valuesByKey = map(),\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$$1, depth) {\n    if (++depth > keys.length) return map$$1;\n    var array, sortKey = sortKeys[depth - 1];\n    if (rollup != null && depth >= keys.length) array = map$$1.entries();\n    else array = [], map$$1.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();\n}\n\nfunction setMap(map$$1, key, value) {\n  map$$1.set(key, value);\n}\n\nfunction Set() {}\n\nvar proto = map.prototype;\n\nSet.prototype = set.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(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\nexports.nest = nest;\nexports.set = set;\nexports.map = map;\nexports.keys = keys;\nexports.values = values;\nexports.entries = entries;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3-collection/build/d3-collection.js\n// module id = 8\n// module chunks = 0 1 3 4 5 6 8 9 10 11","// https://d3js.org/d3-interpolate/ Version 1.1.5. Copyright 2017 Mike Bostock.\n(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('d3-color')) :\n\ttypeof define === 'function' && define.amd ? define(['exports', 'd3-color'], factory) :\n\t(factory((global.d3 = global.d3 || {}),global.d3));\n}(this, (function (exports,d3Color) { 'use strict';\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 = 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(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(isNaN(a) ? b : a);\n  };\n}\n\nfunction nogamma(a, b) {\n  var d = b - a;\n  return d ? linear(a, d) : constant(isNaN(a) ? b : a);\n}\n\nvar rgb$1 = ((function rgbGamma(y) {\n  var color$$1 = gamma(y);\n\n  function rgb$$1(start, end) {\n    var r = color$$1((start = d3Color.rgb(start)).r, (end = d3Color.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 = d3Color.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 = 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] = value(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 number = 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] = value(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 string = 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: number(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 value = function(a, b) {\n  var t = typeof b, c;\n  return b == null || t === \"boolean\" ? constant(b)\n      : (t === \"number\" ? number\n      : t === \"string\" ? ((c = d3Color.color(b)) ? (b = c, rgb$1) : string)\n      : b instanceof d3Color.color ? rgb$1\n      : b instanceof Date ? date\n      : Array.isArray(b) ? array\n      : typeof b.valueOf !== \"function\" && typeof b.toString !== \"function\" || isNaN(b) ? object\n      : number)(a, b);\n};\n\nvar round = 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 = {\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;\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;\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;\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: number(xa, xb)}, {i: i - 2, x: number(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: number(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: number(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: number(xa, xb)}, {i: i - 2, x: number(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 zoom = 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 = d3Color.hsl(start)).h, (end = d3Color.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 = d3Color.lab(start)).l, (end = d3Color.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 = d3Color.hcl(start)).h, (end = d3Color.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 = d3Color.cubehelix(start)).h, (end = d3Color.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\nexports.interpolate = value;\nexports.interpolateArray = array;\nexports.interpolateBasis = basis$1;\nexports.interpolateBasisClosed = basisClosed;\nexports.interpolateDate = date;\nexports.interpolateNumber = number;\nexports.interpolateObject = object;\nexports.interpolateRound = round;\nexports.interpolateString = string;\nexports.interpolateTransformCss = interpolateTransformCss;\nexports.interpolateTransformSvg = interpolateTransformSvg;\nexports.interpolateZoom = zoom;\nexports.interpolateRgb = rgb$1;\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;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3-interpolate/build/d3-interpolate.js\n// module id = 9\n// module chunks = 0 1 3 4 5 6 7 8 9 10 11 12","// https://d3js.org/d3-time/ Version 1.0.7. 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 t0 = new Date;\nvar t1 = 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) {\n        if (step < 0) while (++step <= 0) {\n          while (offseti(date, -1), !test(date)) {} // eslint-disable-line no-empty\n        } else while (--step >= 0) {\n          while (offseti(date, +1), !test(date)) {} // eslint-disable-line no-empty\n        }\n      }\n    });\n  };\n\n  if (count) {\n    interval.count = function(start, end) {\n      t0.setTime(+start), t1.setTime(+end);\n      floori(t0), floori(t1);\n      return Math.floor(count(t0, t1));\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 = 1e3;\nvar durationMinute = 6e4;\nvar durationHour = 36e5;\nvar durationDay = 864e5;\nvar durationWeek = 6048e5;\n\nvar second = newInterval(function(date) {\n  date.setTime(Math.floor(date / durationSecond) * durationSecond);\n}, function(date, step) {\n  date.setTime(+date + step * durationSecond);\n}, function(start, end) {\n  return (end - start) / durationSecond;\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) * durationMinute);\n}, function(date, step) {\n  date.setTime(+date + step * durationMinute);\n}, function(start, end) {\n  return (end - start) / durationMinute;\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 % durationHour;\n  if (offset < 0) offset += durationHour;\n  date.setTime(Math.floor((+date - offset) / durationHour) * durationHour + offset);\n}, function(date, step) {\n  date.setTime(+date + step * durationHour);\n}, function(start, end) {\n  return (end - start) / durationHour;\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) / durationDay;\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) / durationWeek;\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);\n}, function(start, end) {\n  return (end - start) / durationMinute;\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);\n}, function(start, end) {\n  return (end - start) / durationHour;\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;\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;\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\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;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3-time/build/d3-time.js\n// module id = 10\n// module chunks = 0 1 3 4 5 6 8 9 10 11 12","// https://d3js.org/d3-time-format/ Version 2.0.5. Copyright 2017 Mike Bostock.\n(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('d3-time')) :\n\ttypeof define === 'function' && define.amd ? define(['exports', 'd3-time'], factory) :\n\t(factory((global.d3 = global.d3 || {}),global.d3));\n}(this, (function (exports,d3Time) { 'use strict';\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(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 = \"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 + 5) % 7 : d.w + d.U * 7 - (day + 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 + d3Time.timeDay.count(d3Time.timeYear(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(d3Time.timeSunday.count(d3Time.timeYear(d), d), p, 2);\n}\n\nfunction formatWeekdayNumber(d) {\n  return d.getDay();\n}\n\nfunction formatWeekNumberMonday(d, p) {\n  return pad(d3Time.timeMonday.count(d3Time.timeYear(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 + d3Time.utcDay.count(d3Time.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(d3Time.utcSunday.count(d3Time.utcYear(d), d), p, 2);\n}\n\nfunction formatUTCWeekdayNumber(d) {\n  return d.getUTCDay();\n}\n\nfunction formatUTCWeekNumberMonday(d, p) {\n  return pad(d3Time.utcMonday.count(d3Time.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$1;\n\n\n\n\n\ndefaultLocale({\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(definition) {\n  locale$1 = formatLocale(definition);\n  exports.timeFormat = locale$1.format;\n  exports.timeParse = locale$1.parse;\n  exports.utcFormat = locale$1.utcFormat;\n  exports.utcParse = locale$1.utcParse;\n  return locale$1;\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\nexports.timeFormatDefaultLocale = defaultLocale;\nexports.timeFormatLocale = formatLocale;\nexports.isoFormat = formatIso;\nexports.isoParse = parseIso;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3-time-format/build/d3-time-format.js\n// module id = 11\n// module chunks = 0 1 3 4 5 6 8 9 10 11 12","// https://d3js.org/d3-selection/ Version 1.1.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 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() {\n  return new Local;\n}\n\nfunction Local() {\n  this._ = \"@\" + (++nextId).toString(36);\n}\n\nLocal.prototype = local.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(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(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() {\n  return [];\n}\n\nvar selectorAll = function(selector) {\n  return selector == null ? empty : 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 = 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(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;\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(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 defaultView = 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  return arguments.length > 1\n      ? this.each((value == null\n            ? styleRemove : typeof value === \"function\"\n            ? styleFunction\n            : styleConstant)(name, value, priority == null ? \"\" : priority))\n      : styleValue(this.node(), name);\n};\n\nfunction styleValue(node, name) {\n  return node.style.getPropertyValue(name)\n      || defaultView(node).getComputedStyle(node, null).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 = defaultView(node),\n      event = window.CustomEvent;\n\n  if (typeof event === \"function\") {\n    event = new event(type, params);\n  } else {\n    event = window.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\nexports.creator = creator;\nexports.local = local;\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.style = styleValue;\nexports.touch = touch;\nexports.touches = touches;\nexports.window = defaultView;\nexports.customEvent = customEvent;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3-selection/build/d3-selection.js\n// module id = 12\n// module chunks = 0 1 3 4 5 6 7 8 9 10 11 12","// https://d3js.org/d3-transition/ Version 1.1.0. Copyright 2017 Mike Bostock.\n(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('d3-selection'), require('d3-dispatch'), require('d3-timer'), require('d3-interpolate'), require('d3-color'), require('d3-ease')) :\n\ttypeof define === 'function' && define.amd ? define(['exports', 'd3-selection', 'd3-dispatch', 'd3-timer', 'd3-interpolate', 'd3-color', 'd3-ease'], factory) :\n\t(factory((global.d3 = global.d3 || {}),global.d3,global.d3,global.d3,global.d3,global.d3,global.d3));\n}(this, (function (exports,d3Selection,d3Dispatch,d3Timer,d3Interpolate,d3Color,d3Ease) { 'use strict';\n\nvar emptyOn = d3Dispatch.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(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(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 = d3Timer.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 d3Timer.timeout(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    d3Timer.timeout(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(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(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(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(this, id);\n    (schedule.value || (schedule.value = {}))[name] = value.apply(this, arguments);\n  });\n\n  return function(node) {\n    return get(node, id).value[name];\n  };\n}\n\nvar interpolate = function(a, b) {\n  var c;\n  return (typeof b === \"number\" ? d3Interpolate.interpolateNumber\n      : b instanceof d3Color.color ? d3Interpolate.interpolateRgb\n      : (c = d3Color.color(b)) ? (b = c, d3Interpolate.interpolateRgb)\n      : d3Interpolate.interpolateString)(a, b);\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, 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(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(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(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 = d3Selection.namespace(name), i = fullname === \"transform\" ? d3Interpolate.interpolateTransformSvg : interpolate;\n  return this.attrTween(name, typeof value === \"function\"\n      ? (fullname.local ? attrFunctionNS : attrFunction)(fullname, i, tweenValue(this, \"attr.\" + name, value))\n      : value == null ? (fullname.local ? attrRemoveNS : attrRemove)(fullname)\n      : (fullname.local ? attrConstantNS : attrConstant)(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 = d3Selection.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(this.node(), id).delay;\n};\n\nfunction durationFunction(id, value) {\n  return function() {\n    set(this, id).duration = +value.apply(this, arguments);\n  };\n}\n\nfunction durationConstant(id, value) {\n  return value = +value, function() {\n    set(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(this.node(), id).duration;\n};\n\nfunction easeConstant(id, value) {\n  if (typeof value !== \"function\") throw new Error;\n  return function() {\n    set(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(this.node(), id).ease;\n};\n\nvar transition_filter = function(match) {\n  if (typeof match !== \"function\") match = d3Selection.matcher(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;\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(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) {\n  var name = this._name,\n      id = this._id;\n\n  if (typeof select !== \"function\") select = d3Selection.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        schedule(subgroup[i], name, id, i, subgroup, get(node, id));\n      }\n    }\n  }\n\n  return new Transition(subgroups, this._parents, name, id);\n};\n\nvar transition_selectAll = function(select) {\n  var name = this._name,\n      id = this._id;\n\n  if (typeof select !== \"function\") select = d3Selection.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        for (var children = select.call(node, node.__data__, i, group), child, inherit = get(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 = d3Selection.selection.prototype.constructor;\n\nvar transition_selection = function() {\n  return new Selection(this._groups, this._parents);\n};\n\nfunction styleRemove(name, interpolate$$1) {\n  var value00,\n      value10,\n      interpolate0;\n  return function() {\n    var value0 = d3Selection.style(this, name),\n        value1 = (this.style.removeProperty(name), d3Selection.style(this, name));\n    return value0 === value1 ? null\n        : value0 === value00 && value1 === value10 ? interpolate0\n        : interpolate0 = interpolate$$1(value00 = value0, value10 = value1);\n  };\n}\n\nfunction styleRemoveEnd(name) {\n  return function() {\n    this.style.removeProperty(name);\n  };\n}\n\nfunction styleConstant(name, interpolate$$1, value1) {\n  var value00,\n      interpolate0;\n  return function() {\n    var value0 = d3Selection.style(this, name);\n    return value0 === value1 ? null\n        : value0 === value00 ? interpolate0\n        : interpolate0 = interpolate$$1(value00 = value0, value1);\n  };\n}\n\nfunction styleFunction(name, interpolate$$1, value) {\n  var value00,\n      value10,\n      interpolate0;\n  return function() {\n    var value0 = d3Selection.style(this, name),\n        value1 = value(this);\n    if (value1 == null) value1 = (this.style.removeProperty(name), d3Selection.style(this, name));\n    return value0 === value1 ? null\n        : value0 === value00 && value1 === value10 ? interpolate0\n        : interpolate0 = interpolate$$1(value00 = value0, value10 = value1);\n  };\n}\n\nvar transition_style = function(name, value, priority) {\n  var i = (name += \"\") === \"transform\" ? d3Interpolate.interpolateTransformCss : interpolate;\n  return value == null ? this\n          .styleTween(name, styleRemove(name, i))\n          .on(\"end.style.\" + name, styleRemoveEnd(name))\n      : this.styleTween(name, typeof value === \"function\"\n          ? styleFunction(name, i, tweenValue(this, \"style.\" + name, value))\n          : styleConstant(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(value) {\n  return function() {\n    this.textContent = value;\n  };\n}\n\nfunction textFunction(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(tweenValue(this, \"text\", value))\n      : textConstant(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(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 d3Selection.selection().transition(name);\n}\n\nfunction newId() {\n  return ++id;\n}\n\nvar selection_prototype = d3Selection.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\nvar defaultTiming = {\n  time: null, // Set on use.\n  delay: 0,\n  duration: 250,\n  ease: d3Ease.easeCubicInOut\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 = d3Timer.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 = d3Timer.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\nd3Selection.selection.prototype.interrupt = selection_interrupt;\nd3Selection.selection.prototype.transition = selection_transition;\n\nvar root = [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, name, +i);\n      }\n    }\n  }\n\n  return null;\n};\n\nexports.transition = transition;\nexports.active = active;\nexports.interrupt = interrupt;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3-transition/build/d3-transition.js\n// module id = 13\n// module chunks = 0 1 3 4 5 6 7 8 9 10 11 12","// https://d3js.org/d3-timer/ Version 1.0.6. 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 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 window === \"object\" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : 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\nexports.now = now;\nexports.timer = timer;\nexports.timerFlush = timerFlush;\nexports.timeout = timeout$1;\nexports.interval = interval$1;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3-timer/build/d3-timer.js\n// module id = 14\n// module chunks = 0 1 3 4 5 6 7 8 9 10 11 12","define(function() {\n\n    // Color Gradients\n    const britechartGradients = {\n            greenBlue: ['#39C7EA', '#4CDCBA'],\n            orangePink: ['#FBC670', '#F766B8'],\n            bluePurple: ['#3DC3C9', '#824a9e']\n        };\n\n    // Color Schemas\n    // Standard Color Schema for Britecharts\n    const britecharts = [\n            '#6aedc7', //green\n            '#39c2c9', //blue\n            '#ffce00', //yellow\n            '#ffa71a', //orange\n            '#f866b9', //pink\n            '#998ce3' //purple\n        ];\n\n    // Grey Schema for Britecharts\n    const grey = [\n            '#F8F8FA',\n            '#EFF2F5',\n            '#D2D6DF',\n            '#C3C6CF',\n            '#ADB0B6',\n            '#666A73',\n            '#45494E',\n            '#363A43',\n            '#282C35'\n        ];\n\n    // Orange Palette\n    const orange = [\n            '#fcc870',\n            '#ffa71a',\n            '#fb8825',\n            '#f6682f',\n            '#db5a2c',\n            '#bf4c28',\n            '#a43b1c',\n            '#892a10',\n            '#f9e9c5'\n        ];\n    // Blue Palette\n    const blueGreen = [\n            '#ccf7f6',\n            '#70e4e0',\n            '#00d8d2',\n            '#00acaf',\n            '#007f8c',\n            '#005e66',\n            '#003c3f',\n            '#002d2f',\n            '#0d2223'\n        ];\n    // LightBlue Palette\n    const teal = [\n            '#ccfffe',\n            '#94f7f4',\n            '#00fff8',\n            '#1de1e1',\n            '#39c2c9',\n            '#2e9a9d',\n            '#227270',\n            '#1a5957',\n            '#133f3e'\n        ];\n    // Green Palette\n    const green = [\n            '#edfff7',\n            '#d7ffef',\n            '#c0ffe7',\n            '#95f5d7',\n            '#6aedc7',\n            '#59c3a3',\n            '#479980',\n            '#34816a',\n            '#206953'\n        ];\n    // Yellow Palette\n    const yellow = [\n            '#f9f2b3',\n            '#fbe986',\n            '#fce05a',\n            '#fed72d',\n            '#ffce00',\n            '#fcc11c',\n            '#f9b438',\n            '#eda629',\n            '#e09819'\n        ];\n    // Pink Palette\n    const pink = [\n            '#fdd1ea',\n            '#fb9cd2',\n            '#f866b9',\n            '#fc40b6',\n            '#ff1ab3',\n            '#e3239d',\n            '#c62c86',\n            '#a62073',\n            '#85135f'\n        ];\n    // Purple Palette\n    const purple = [\n            '#ddd6fc',\n            '#bbb1f0',\n            '#998ce3',\n            '#8e6bc1',\n            '#824a9e',\n            '#77337f',\n            '#6b1c60',\n            '#591650',\n            '#470f3f'\n        ];\n    // Red Palette\n    const red = [\n            '#ffd8d4',\n            '#ffb5b0',\n            '#ff938c',\n            '#ff766c',\n            '#ff584c',\n            '#f04b42',\n            '#e03d38',\n            '#be2e29',\n            '#9c1e19'\n        ];\n\n    const aloeGreen = [\n            '#7bdcc0'\n        ];\n\n    return {\n        colorSchemas: {\n            britecharts,\n            grey,\n            orange,\n            blueGreen,\n            teal,\n            green,\n            yellow,\n            pink,\n            purple,\n            red\n        },\n        colorSchemasHuman: {\n            'britecharts': 'Britecharts Default',\n            'grey': 'Britecharts Grey',\n            'orange': 'Orange',\n            'blueGreen': 'Blue',\n            'teal': 'Light Blue',\n            'green': 'Green',\n            'yellow': 'Yellow',\n            'pink': 'Pink',\n            'purple': 'Purple',\n            'red': 'Red'\n        },\n        singleColors: {\n            aloeGreen\n        },\n        colorGradients: britechartGradients,\n        colorGradientsHuman: {\n            greenBlue: 'Green To Blue',\n            orangePink: 'Orange to Pink',\n            bluePurple: 'Blue to Purple'\n        }\n    };\n});\n\n\n\n// WEBPACK FOOTER //\n// ./src/charts/helpers/colors.js","define(function() {\n    \n    const axisTimeCombinations = {\n        MINUTE_HOUR: 'minute-hour',\n        HOUR_DAY: 'hour-daymonth',\n        DAY_MONTH: 'day-month',\n        MONTH_YEAR: 'month-year'\n    };\n\n    const timeBenchmarks= {\n        ONE_AND_A_HALF_YEARS: 47304000000,\n        ONE_YEAR: 31536000365,\n        ONE_DAY: 86400001\n    };\n\n    return {\n        axisTimeCombinations,\n        timeBenchmarks,\n        lineGradientId: 'lineGradientId'\n    };\n});\n\n\n\n\n// WEBPACK FOOTER //\n// ./src/charts/helpers/constants.js","// https://d3js.org/d3-brush/ Version 1.0.4. Copyright 2017 Mike Bostock.\n(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('d3-dispatch'), require('d3-drag'), require('d3-interpolate'), require('d3-selection'), require('d3-transition')) :\n\ttypeof define === 'function' && define.amd ? define(['exports', 'd3-dispatch', 'd3-drag', 'd3-interpolate', 'd3-selection', 'd3-transition'], factory) :\n\t(factory((global.d3 = global.d3 || {}),global.d3,global.d3,global.d3,global.d3,global.d3));\n}(this, (function (exports,d3Dispatch,d3Drag,d3Interpolate,d3Selection,d3Transition) { 'use strict';\n\nvar constant = 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() {\n  d3Selection.event.stopImmediatePropagation();\n}\n\nvar noevent = function() {\n  d3Selection.event.preventDefault();\n  d3Selection.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 !d3Selection.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(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 = d3Dispatch.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(this).extent;\n          d3Selection.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) {\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 === \"function\" ? selection.apply(this, arguments) : selection, state.extent),\n                i = d3Interpolate.interpolate(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 === \"function\" ? selection.apply(that, args) : selection, state.extent),\n                emit = emitter(that, args).beforestart();\n\n            d3Transition.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 = d3Selection.select(this),\n        selection = local(this).selection;\n\n    if (selection) {\n      group.selectAll(\".selection\")\n          .style(\"display\", null)\n          .attr(\"x\", selection[0][0])\n          .attr(\"y\", selection[0][1])\n          .attr(\"width\", selection[1][0] - selection[0][0])\n          .attr(\"height\", selection[1][1] - selection[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][0] - handleSize / 2 : selection[0][0] - handleSize / 2; })\n          .attr(\"y\", function(d) { return d.type[0] === \"s\" ? selection[1][1] - handleSize / 2 : selection[0][1] - handleSize / 2; })\n          .attr(\"width\", function(d) { return d.type === \"n\" || d.type === \"s\" ? selection[1][0] - selection[0][0] + handleSize : handleSize; })\n          .attr(\"height\", function(d) { return d.type === \"e\" || d.type === \"w\" ? selection[1][1] - selection[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      d3Selection.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 (d3Selection.event.touches) { if (d3Selection.event.changedTouches.length < d3Selection.event.touches.length) return noevent(); }\n    else if (touchending) return;\n    if (!filter.apply(this, arguments)) return;\n\n    var that = this,\n        type = d3Selection.event.target.__data__.type,\n        mode = (d3Selection.event.metaKey ? type = \"overlay\" : type) === \"selection\" ? MODE_DRAG : (d3Selection.event.altKey ? MODE_CENTER : MODE_HANDLE),\n        signX = dim === Y ? null : signsX[type],\n        signY = dim === X ? null : signsY[type],\n        state = local(that),\n        extent = state.extent,\n        selection = 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 && d3Selection.event.shiftKey,\n        lockX,\n        lockY,\n        point0 = d3Selection.mouse(that),\n        point = point0,\n        emit = emitter(that, arguments).beforestart();\n\n    if (type === \"overlay\") {\n      state.selection = selection = [\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[0][0];\n      n0 = selection[0][1];\n      e0 = selection[1][0];\n      s0 = selection[1][1];\n    }\n\n    w1 = w0;\n    n1 = n0;\n    e1 = e0;\n    s1 = s0;\n\n    var group = d3Selection.select(that)\n        .attr(\"pointer-events\", \"none\");\n\n    var overlay = group.selectAll(\".overlay\")\n        .attr(\"cursor\", cursors[type]);\n\n    if (d3Selection.event.touches) {\n      group\n          .on(\"touchmove.brush\", moved, true)\n          .on(\"touchend.brush touchcancel.brush\", ended, true);\n    } else {\n      var view = d3Selection.select(d3Selection.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      d3Drag.dragDisable(d3Selection.event.view);\n    }\n\n    nopropagation();\n    d3Transition.interrupt(that);\n    redraw.call(that);\n    emit.start();\n\n    function moved() {\n      var point1 = d3Selection.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();\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 = state.selection; // May be set by brush.move!\n      if (lockX) w1 = selection[0][0], e1 = selection[1][0];\n      if (lockY) n1 = selection[0][1], s1 = selection[1][1];\n\n      if (selection[0][0] !== w1\n          || selection[0][1] !== n1\n          || selection[1][0] !== e1\n          || selection[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();\n      if (d3Selection.event.touches) {\n        if (d3Selection.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        d3Drag.dragEnable(d3Selection.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 = state.selection; // May be set by brush.move (on start)!\n      if (empty(selection)) state.selection = null, redraw.call(that);\n      emit.end();\n    }\n\n    function keydowned() {\n      switch (d3Selection.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();\n    }\n\n    function keyupped() {\n      switch (d3Selection.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 (d3Selection.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();\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([[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]]), brush) : extent;\n  };\n\n  brush.filter = function(_) {\n    return arguments.length ? (filter = typeof _ === \"function\" ? _ : constant(!!_), 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\nexports.brush = brush;\nexports.brushX = brushX;\nexports.brushY = brushY;\nexports.brushSelection = brushSelection;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3-brush/build/d3-brush.js\n// module id = 22\n// module chunks = 1","// https://d3js.org/d3-drag/ Version 1.1.1. Copyright 2017 Mike Bostock.\n(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('d3-dispatch'), require('d3-selection')) :\n\ttypeof define === 'function' && define.amd ? define(['exports', 'd3-dispatch', 'd3-selection'], factory) :\n\t(factory((global.d3 = global.d3 || {}),global.d3,global.d3));\n}(this, (function (exports,d3Dispatch,d3Selection) { 'use strict';\n\nfunction nopropagation() {\n  d3Selection.event.stopImmediatePropagation();\n}\n\nvar noevent = function() {\n  d3Selection.event.preventDefault();\n  d3Selection.event.stopImmediatePropagation();\n};\n\nvar nodrag = function(view) {\n  var root = view.document.documentElement,\n      selection = d3Selection.select(view).on(\"dragstart.drag\", noevent, true);\n  if (\"onselectstart\" in root) {\n    selection.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 = d3Selection.select(view).on(\"dragstart.drag\", null);\n  if (noclick) {\n    selection.on(\"click.drag\", noevent, true);\n    setTimeout(function() { selection.on(\"click.drag\", null); }, 0);\n  }\n  if (\"onselectstart\" in root) {\n    selection.on(\"selectstart.drag\", null);\n  } else {\n    root.style.MozUserSelect = root.__noselect;\n    delete root.__noselect;\n  }\n}\n\nvar constant = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nfunction DragEvent(target, type, subject, id, active, x, y, dx, dy, dispatch$$1) {\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$$1;\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() {\n  return !d3Selection.event.button;\n}\n\nfunction defaultContainer() {\n  return this.parentNode;\n}\n\nfunction defaultSubject(d) {\n  return d == null ? {x: d3Selection.event.x, y: d3Selection.event.y} : d;\n}\n\nfunction touchable() {\n  return \"ontouchstart\" in this;\n}\n\nvar drag = function() {\n  var filter = defaultFilter,\n      container = defaultContainer,\n      subject = defaultSubject,\n      gestures = {},\n      listeners = d3Dispatch.dispatch(\"start\", \"drag\", \"end\"),\n      active = 0,\n      mousedownx,\n      mousedowny,\n      mousemoving,\n      touchending,\n      clickDistance2 = 0;\n\n  function drag(selection) {\n    selection\n        .on(\"mousedown.drag\", mousedowned)\n      .filter(touchable)\n        .on(\"touchstart.drag\", touchstarted)\n        .on(\"touchmove.drag\", touchmoved)\n        .on(\"touchend.drag touchcancel.drag\", touchended)\n        .style(\"touch-action\", \"none\")\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), d3Selection.mouse, this, arguments);\n    if (!gesture) return;\n    d3Selection.select(d3Selection.event.view).on(\"mousemove.drag\", mousemoved, true).on(\"mouseup.drag\", mouseupped, true);\n    nodrag(d3Selection.event.view);\n    nopropagation();\n    mousemoving = false;\n    mousedownx = d3Selection.event.clientX;\n    mousedowny = d3Selection.event.clientY;\n    gesture(\"start\");\n  }\n\n  function mousemoved() {\n    noevent();\n    if (!mousemoving) {\n      var dx = d3Selection.event.clientX - mousedownx, dy = d3Selection.event.clientY - mousedowny;\n      mousemoving = dx * dx + dy * dy > clickDistance2;\n    }\n    gestures.mouse(\"drag\");\n  }\n\n  function mouseupped() {\n    d3Selection.select(d3Selection.event.view).on(\"mousemove.drag mouseup.drag\", null);\n    yesdrag(d3Selection.event.view, mousemoving);\n    noevent();\n    gestures.mouse(\"end\");\n  }\n\n  function touchstarted() {\n    if (!filter.apply(this, arguments)) return;\n    var touches = d3Selection.event.changedTouches,\n        c = container.apply(this, arguments),\n        n = touches.length, i, gesture;\n\n    for (i = 0; i < n; ++i) {\n      if (gesture = beforestart(touches[i].identifier, c, d3Selection.touch, this, arguments)) {\n        nopropagation();\n        gesture(\"start\");\n      }\n    }\n  }\n\n  function touchmoved() {\n    var touches = d3Selection.event.changedTouches,\n        n = touches.length, i, gesture;\n\n    for (i = 0; i < n; ++i) {\n      if (gesture = gestures[touches[i].identifier]) {\n        noevent();\n        gesture(\"drag\");\n      }\n    }\n  }\n\n  function touchended() {\n    var touches = d3Selection.event.changedTouches,\n        n = touches.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[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 (!d3Selection.customEvent(new DragEvent(drag, \"beforestart\", s, id, active, p[0], p[1], 0, 0, sublisteners), function() {\n      if ((d3Selection.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      d3Selection.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(!!_), drag) : filter;\n  };\n\n  drag.container = function(_) {\n    return arguments.length ? (container = typeof _ === \"function\" ? _ : constant(_), drag) : container;\n  };\n\n  drag.subject = function(_) {\n    return arguments.length ? (subject = typeof _ === \"function\" ? _ : constant(_), 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  drag.clickDistance = function(_) {\n    return arguments.length ? (clickDistance2 = (_ = +_) * _, drag) : Math.sqrt(clickDistance2);\n  };\n\n  return drag;\n};\n\nexports.drag = drag;\nexports.dragDisable = nodrag;\nexports.dragEnable = yesdrag;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3-drag/build/d3-drag.js\n// module id = 23\n// module chunks = 1","// https://d3js.org/d3-shape/ Version 1.2.0. Copyright 2017 Mike Bostock.\n(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('d3-path')) :\n\ttypeof define === 'function' && define.amd ? define(['exports', 'd3-path'], factory) :\n\t(factory((global.d3 = global.d3 || {}),global.d3));\n}(this, (function (exports,d3Path) { 'use strict';\n\nvar constant = function(x) {\n  return function constant() {\n    return x;\n  };\n};\n\nvar abs = Math.abs;\nvar atan2 = Math.atan2;\nvar cos = Math.cos;\nvar max = Math.max;\nvar min = Math.min;\nvar sin = Math.sin;\nvar sqrt = Math.sqrt;\n\nvar epsilon = 1e-12;\nvar pi = Math.PI;\nvar halfPi = pi / 2;\nvar tau = 2 * pi;\n\nfunction acos(x) {\n  return x > 1 ? 0 : x < -1 ? pi : Math.acos(x);\n}\n\nfunction asin(x) {\n  return x >= 1 ? halfPi : x <= -1 ? -halfPi : Math.asin(x);\n}\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 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) / 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) * sqrt(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(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,\n        a1 = endAngle.apply(this, arguments) - halfPi,\n        da = abs(a1 - a0),\n        cw = a1 > a0;\n\n    if (!context) context = buffer = d3Path.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)) context.moveTo(0, 0);\n\n    // Or is it a circle or annulus?\n    else if (da > tau - epsilon) {\n      context.moveTo(r1 * cos(a0), r1 * sin(a0));\n      context.arc(0, 0, r1, a0, a1, !cw);\n      if (r0 > epsilon) {\n        context.moveTo(r0 * cos(a1), r0 * 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) && (padRadius ? +padRadius.apply(this, arguments) : sqrt(r0 * r0 + r1 * r1)),\n          rc = min(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) {\n        var p0 = asin(rp / r0 * sin(ap)),\n            p1 = asin(rp / r1 * sin(ap));\n        if ((da0 -= p0 * 2) > epsilon) p0 *= (cw ? 1 : -1), a00 += p0, a10 -= p0;\n        else da0 = 0, a00 = a10 = (a0 + a1) / 2;\n        if ((da1 -= p1 * 2) > epsilon) p1 *= (cw ? 1 : -1), a01 += p1, a11 -= p1;\n        else da1 = 0, a01 = a11 = (a0 + a1) / 2;\n      }\n\n      var x01 = r1 * cos(a01),\n          y01 = r1 * sin(a01),\n          x10 = r0 * cos(a10),\n          y10 = r0 * sin(a10);\n\n      // Apply rounded corners?\n      if (rc > epsilon) {\n        var x11 = r1 * cos(a11),\n            y11 = r1 * sin(a11),\n            x00 = r0 * cos(a00),\n            y00 = r0 * sin(a00);\n\n        // Restrict the corner radius according to the sector angle.\n        if (da < pi) {\n          var oc = da0 > epsilon ? 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 / sin(acos((ax * bx + ay * by) / (sqrt(ax * ax + ay * ay) * sqrt(bx * bx + by * by))) / 2),\n              lc = sqrt(oc[0] * oc[0] + oc[1] * oc[1]);\n          rc0 = min(rc, (r0 - lc) / (kc - 1));\n          rc1 = min(rc, (r1 - lc) / (kc + 1));\n        }\n      }\n\n      // Is the sector collapsed to a line?\n      if (!(da1 > epsilon)) context.moveTo(x01, y01);\n\n      // Does the sector’s outer ring have rounded corners?\n      else if (rc1 > epsilon) {\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, atan2(t0.y01, t0.x01), 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, atan2(t0.y01, t0.x01), atan2(t0.y11, t0.x11), !cw);\n          context.arc(0, 0, r1, atan2(t0.cy + t0.y11, t0.cx + t0.x11), atan2(t1.cy + t1.y11, t1.cx + t1.x11), !cw);\n          context.arc(t1.cx, t1.cy, rc1, atan2(t1.y11, t1.x11), 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) || !(da0 > epsilon)) context.lineTo(x10, y10);\n\n      // Does the sector’s inner ring (or point) have rounded corners?\n      else if (rc0 > epsilon) {\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, atan2(t0.y01, t0.x01), 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, atan2(t0.y01, t0.x01), atan2(t0.y11, t0.x11), !cw);\n          context.arc(0, 0, r0, atan2(t0.cy + t0.y11, t0.cx + t0.x11), atan2(t1.cy + t1.y11, t1.cx + t1.x11), cw);\n          context.arc(t1.cx, t1.cy, rc0, atan2(t1.y11, t1.x11), 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 / 2;\n    return [cos(a) * r, sin(a) * r];\n  };\n\n  arc.innerRadius = function(_) {\n    return arguments.length ? (innerRadius = typeof _ === \"function\" ? _ : constant(+_), arc) : innerRadius;\n  };\n\n  arc.outerRadius = function(_) {\n    return arguments.length ? (outerRadius = typeof _ === \"function\" ? _ : constant(+_), arc) : outerRadius;\n  };\n\n  arc.cornerRadius = function(_) {\n    return arguments.length ? (cornerRadius = typeof _ === \"function\" ? _ : constant(+_), arc) : cornerRadius;\n  };\n\n  arc.padRadius = function(_) {\n    return arguments.length ? (padRadius = _ == null ? null : typeof _ === \"function\" ? _ : constant(+_), arc) : padRadius;\n  };\n\n  arc.startAngle = function(_) {\n    return arguments.length ? (startAngle = typeof _ === \"function\" ? _ : constant(+_), arc) : startAngle;\n  };\n\n  arc.endAngle = function(_) {\n    return arguments.length ? (endAngle = typeof _ === \"function\" ? _ : constant(+_), arc) : endAngle;\n  };\n\n  arc.padAngle = function(_) {\n    return arguments.length ? (padAngle = typeof _ === \"function\" ? _ : constant(+_), 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(p) {\n  return p[0];\n}\n\nfunction y(p) {\n  return p[1];\n}\n\nvar line = function() {\n  var x$$1 = x,\n      y$$1 = y,\n      defined = constant(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 = d3Path.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(+_), line) : x$$1;\n  };\n\n  line.y = function(_) {\n    return arguments.length ? (y$$1 = typeof _ === \"function\" ? _ : constant(+_), line) : y$$1;\n  };\n\n  line.defined = function(_) {\n    return arguments.length ? (defined = typeof _ === \"function\" ? _ : constant(!!_), 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 = function() {\n  var x0 = x,\n      x1 = null,\n      y0 = constant(0),\n      y1 = y,\n      defined = constant(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 = d3Path.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(+_), x1 = null, area) : x0;\n  };\n\n  area.x0 = function(_) {\n    return arguments.length ? (x0 = typeof _ === \"function\" ? _ : constant(+_), area) : x0;\n  };\n\n  area.x1 = function(_) {\n    return arguments.length ? (x1 = _ == null ? null : typeof _ === \"function\" ? _ : constant(+_), area) : x1;\n  };\n\n  area.y = function(_) {\n    return arguments.length ? (y0 = typeof _ === \"function\" ? _ : constant(+_), y1 = null, area) : y0;\n  };\n\n  area.y0 = function(_) {\n    return arguments.length ? (y0 = typeof _ === \"function\" ? _ : constant(+_), area) : y0;\n  };\n\n  area.y1 = function(_) {\n    return arguments.length ? (y1 = _ == null ? null : typeof _ === \"function\" ? _ : constant(+_), 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(!!_), 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 = function(a, b) {\n  return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;\n};\n\nvar identity = function(d) {\n  return d;\n};\n\nvar pie = function() {\n  var value = identity,\n      sortValues = descending,\n      sort = null,\n      startAngle = constant(0),\n      endAngle = constant(tau),\n      padAngle = constant(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, Math.max(-tau, 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(+_), 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(+_), pie) : startAngle;\n  };\n\n  pie.endAngle = function(_) {\n    return arguments.length ? (endAngle = typeof _ === \"function\" ? _ : constant(+_), pie) : endAngle;\n  };\n\n  pie.padAngle = function(_) {\n    return arguments.length ? (padAngle = typeof _ === \"function\" ? _ : constant(+_), 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 lineRadial(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 lineRadial$1 = function() {\n  return lineRadial(line().curve(curveRadialLinear));\n};\n\nvar areaRadial = function() {\n  var a = area().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 lineRadial(x0()); }, delete a.lineX0;\n  a.lineEndAngle = function() { return lineRadial(x1()); }, delete a.lineX1;\n  a.lineInnerRadius = function() { return lineRadial(y0()); }, delete a.lineY0;\n  a.lineOuterRadius = function() { return lineRadial(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 pointRadial = function(x, y) {\n  return [(y = +y) * Math.cos(x -= Math.PI / 2), y * Math.sin(x)];\n};\n\nvar slice = Array.prototype.slice;\n\nfunction linkSource(d) {\n  return d.source;\n}\n\nfunction linkTarget(d) {\n  return d.target;\n}\n\nfunction link(curve) {\n  var source = linkSource,\n      target = linkTarget,\n      x$$1 = x,\n      y$$1 = y,\n      context = null;\n\n  function link() {\n    var buffer, argv = slice.call(arguments), s = source.apply(this, argv), t = target.apply(this, argv);\n    if (!context) context = buffer = d3Path.path();\n    curve(context, +x$$1.apply(this, (argv[0] = s, argv)), +y$$1.apply(this, argv), +x$$1.apply(this, (argv[0] = t, argv)), +y$$1.apply(this, argv));\n    if (buffer) return context = null, buffer + \"\" || null;\n  }\n\n  link.source = function(_) {\n    return arguments.length ? (source = _, link) : source;\n  };\n\n  link.target = function(_) {\n    return arguments.length ? (target = _, link) : target;\n  };\n\n  link.x = function(_) {\n    return arguments.length ? (x$$1 = typeof _ === \"function\" ? _ : constant(+_), link) : x$$1;\n  };\n\n  link.y = function(_) {\n    return arguments.length ? (y$$1 = typeof _ === \"function\" ? _ : constant(+_), link) : y$$1;\n  };\n\n  link.context = function(_) {\n    return arguments.length ? ((context = _ == null ? null : _), link) : context;\n  };\n\n  return link;\n}\n\nfunction curveHorizontal(context, x0, y0, x1, y1) {\n  context.moveTo(x0, y0);\n  context.bezierCurveTo(x0 = (x0 + x1) / 2, y0, x0, y1, x1, y1);\n}\n\nfunction curveVertical(context, x0, y0, x1, y1) {\n  context.moveTo(x0, y0);\n  context.bezierCurveTo(x0, y0 = (y0 + y1) / 2, x1, y0, x1, y1);\n}\n\nfunction curveRadial$1(context, x0, y0, x1, y1) {\n  var p0 = pointRadial(x0, y0),\n      p1 = pointRadial(x0, y0 = (y0 + y1) / 2),\n      p2 = pointRadial(x1, y0),\n      p3 = pointRadial(x1, y1);\n  context.moveTo(p0[0], p0[1]);\n  context.bezierCurveTo(p1[0], p1[1], p2[0], p2[1], p3[0], p3[1]);\n}\n\nfunction linkHorizontal() {\n  return link(curveHorizontal);\n}\n\nfunction linkVertical() {\n  return link(curveVertical);\n}\n\nfunction linkRadial() {\n  var l = link(curveRadial$1);\n  l.angle = l.x, delete l.x;\n  l.radius = l.y, delete l.y;\n  return l;\n}\n\nvar circle = {\n  draw: function(context, size) {\n    var r = Math.sqrt(size / pi);\n    context.moveTo(r, 0);\n    context.arc(0, 0, r, 0, tau);\n  }\n};\n\nvar cross = {\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 / 10) / Math.sin(7 * pi / 10);\nvar kx = Math.sin(tau / 10) * kr;\nvar ky = -Math.cos(tau / 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 * 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,\n  cross,\n  diamond,\n  square,\n  star,\n  triangle,\n  wye\n];\n\nvar symbol = function() {\n  var type = constant(circle),\n      size = constant(64),\n      context = null;\n\n  function symbol() {\n    var buffer;\n    if (!context) context = buffer = d3Path.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(_), symbol) : type;\n  };\n\n  symbol.size = function(_) {\n    return arguments.length ? (size = typeof _ === \"function\" ? _ : constant(+_), 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 = function() {};\n\nfunction point(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(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(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 = function(context) {\n  return new Basis(context);\n};\n\nfunction BasisClosed(context) {\n  this._context = context;\n}\n\nBasisClosed.prototype = {\n  areaStart: noop,\n  areaEnd: noop,\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(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 = 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(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$1(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$1(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$1(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,\n  areaEnd: noop,\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$1(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$1(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$2(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) {\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) {\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$2(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,\n  areaEnd: noop,\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$2(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$2(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,\n  areaEnd: noop,\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(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(s0) + sign(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$3(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$3(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$3(this, slope2(this, t1 = slope3(this, x, y)), t1); break;\n      default: point$3(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 none = function(series, order) {\n  if (!((n = series.length) > 1)) return;\n  for (var i = 1, j, s0, s1 = series[order[0]], n, m = s1.length; i < n; ++i) {\n    s0 = s1, s1 = series[order[i]];\n    for (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$1 = 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([]),\n      order = none$1,\n      offset = none,\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(slice.call(_)), stack) : keys;\n  };\n\n  stack.value = function(_) {\n    return arguments.length ? (value = typeof _ === \"function\" ? _ : constant(+_), stack) : value;\n  };\n\n  stack.order = function(_) {\n    return arguments.length ? (order = _ == null ? none$1 : typeof _ === \"function\" ? _ : constant(slice.call(_)), stack) : order;\n  };\n\n  stack.offset = function(_) {\n    return arguments.length ? (offset = _ == null ? none : _, 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(series, order);\n};\n\nvar diverging = function(series, order) {\n  if (!((n = series.length) > 1)) return;\n  for (var i, j = 0, d, dy, yp, yn, n, m = series[order[0]].length; j < m; ++j) {\n    for (yp = yn = 0, i = 0; i < n; ++i) {\n      if ((dy = (d = series[order[i]][j])[1] - d[0]) >= 0) {\n        d[0] = yp, d[1] = yp += dy;\n      } else if (dy < 0) {\n        d[1] = yn, d[0] = yn += dy;\n      } else {\n        d[0] = yp;\n      }\n    }\n  }\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(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(series, order);\n};\n\nvar ascending = function(series) {\n  var sums = series.map(sum);\n  return none$1(series).sort(function(a, b) { return sums[a] - sums[b]; });\n};\n\nfunction sum(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$1 = function(series) {\n  return ascending(series).reverse();\n};\n\nvar insideOut = function(series) {\n  var n = series.length,\n      i,\n      j,\n      sums = series.map(sum),\n      order = none$1(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$1(series).reverse();\n};\n\nexports.arc = arc;\nexports.area = area;\nexports.line = line;\nexports.pie = pie;\nexports.areaRadial = areaRadial;\nexports.radialArea = areaRadial;\nexports.lineRadial = lineRadial$1;\nexports.radialLine = lineRadial$1;\nexports.pointRadial = pointRadial;\nexports.linkHorizontal = linkHorizontal;\nexports.linkVertical = linkVertical;\nexports.linkRadial = linkRadial;\nexports.symbol = symbol;\nexports.symbols = symbols;\nexports.symbolCircle = circle;\nexports.symbolCross = cross;\nexports.symbolDiamond = diamond;\nexports.symbolSquare = square;\nexports.symbolStar = star;\nexports.symbolTriangle = triangle;\nexports.symbolWye = wye;\nexports.curveBasisClosed = basisClosed;\nexports.curveBasisOpen = basisOpen;\nexports.curveBasis = basis;\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.stackOffsetDiverging = diverging;\nexports.stackOffsetNone = none;\nexports.stackOffsetSilhouette = silhouette;\nexports.stackOffsetWiggle = wiggle;\nexports.stackOrderAscending = ascending;\nexports.stackOrderDescending = descending$1;\nexports.stackOrderInsideOut = insideOut;\nexports.stackOrderNone = none$1;\nexports.stackOrderReverse = reverse;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3-shape/build/d3-shape.js\n// module id = 24\n// module chunks = 1 3 6 8 9 10","// https://d3js.org/d3-path/ Version 1.0.5. 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 pi = Math.PI;\nvar tau = 2 * pi;\nvar epsilon = 1e-6;\nvar tauEpsilon = tau - epsilon;\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)) {}\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) || !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 - 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) {\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 || Math.abs(this._y1 - y0) > epsilon) {\n      this._ += \"L\" + x0 + \",\" + y0;\n    }\n\n    // Is this arc empty? We’re done.\n    if (!r) return;\n\n    // Does the angle go the wrong way? Flip the direction.\n    if (da < 0) da = da % tau + tau;\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    // Is this arc non-empty? Draw an arc!\n    else if (da > epsilon) {\n      this._ += \"A\" + r + \",\" + r + \",0,\" + (+(da >= pi)) + \",\" + 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\nexports.path = path;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3-path/build/d3-path.js\n// module id = 25\n// module chunks = 1 3 6 8 9 10","define(function(require) {\n    'use strict';\n\n    const d3Time = require('d3-time');\n    const d3TimeFormat = require('d3-time-format');\n\n    const {\n        axisTimeCombinations,\n        timeBenchmarks\n    } = require('./constants');\n\n\n    const singleTickWidth = 20;\n    const horizontalTickSpacing = 50;\n    const minEntryNumForDayFormat = 5;\n\n    const formatMap = {\n        minute: d3TimeFormat.timeFormat('%M m'),\n        hour: d3TimeFormat.timeFormat('%H %p'),\n        day: d3TimeFormat.timeFormat('%e'),\n        daymonth: d3TimeFormat.timeFormat('%d %b'),\n        month: d3TimeFormat.timeFormat('%b'),\n        year: d3TimeFormat.timeFormat('%Y')\n    };\n    const localeTimeMap = {\n        minute: {minute:'numeric'},\n        hour: {hour:'numeric'},\n        day: {day: 'numeric'},\n        daymonth: {day: 'numeric', month:'short'},\n        month: {month: 'short'},\n        year: {year: 'numeric'}\n    };\n    const settingsToMajorTickMap = {\n        [axisTimeCombinations.MINUTE_HOUR]: d3Time.timeHour.every(1),\n        [axisTimeCombinations.HOUR_DAY]: d3Time.timeDay.every(1),\n        [axisTimeCombinations.DAY_MONTH]: d3Time.timeMonth.every(1),\n        [axisTimeCombinations.MONTH_YEAR]: d3Time.timeYear.every(1)\n    };\n\n    /**\n     * Figures out the proper settings from the current time span\n     * @param  {Number} timeSpan    Span of time charted by the graph in milliseconds\n     * @return {String}             Type of settings for the given timeSpan\n     */\n    const getAxisSettingsFromTimeSpan = (timeSpan) => {\n        let {\n          ONE_YEAR,\n          ONE_DAY\n        } = timeBenchmarks;\n        let settings;\n\n        if (timeSpan < ONE_DAY) {\n            settings = axisTimeCombinations.HOUR_DAY;\n        } else if (timeSpan < ONE_YEAR) {\n            settings = axisTimeCombinations.DAY_MONTH;\n        } else {\n            settings = axisTimeCombinations.MONTH_YEAR;\n        }\n\n        return settings;\n    }\n\n    /**\n     * Calculates the maximum number of ticks for the x axis\n     * @param  {Number} width Chart width\n     * @param  {Number} dataPointNumber  Number of entries on the data\n     * @return {Number}       Number of ticks to render\n     */\n    const getMaxNumOfHorizontalTicks = (width, dataPointNumber) => {\n        let ticksForWidth = Math.ceil(width / (singleTickWidth + horizontalTickSpacing));\n\n        return dataPointNumber < minEntryNumForDayFormat ? d3Time.timeDay : Math.min(dataPointNumber, ticksForWidth);\n    }\n\n    /**\n     * Takes a locale (string) and the format to return and returns a function to format dates\n     * @param  {String} locale    locale tag eg. en-US, fr-FR, ru-RU\n     * @param  {string} timeUnit  minute, hour, day, dayMonth, month, year\n     * @return {function}         function that formats dates in the proper locale\n     */\n    const getLocaleDateFormatter = (locale, timeUnit='day') => {\n        let options = localeTimeMap[timeUnit];\n        let formatter = new Intl.DateTimeFormat(locale, options);\n\n        return (date) => formatter.format(date);\n    }\n\n    /**\n     * Returns tick object to be used when building the x axis\n     * @param {dataByDate} dataByDate       Chart data ordered by Date\n     * @param {Number} width                Chart width\n     * @param {String} settings             Optional forced settings for axis\n     * @return {object} tick settings for major and minr axis\n     */\n    const getXAxisSettings = (dataByDate, width, settings = null, locale=null) => {\n        let firstDate = new Date(dataByDate[0].date);\n        let lastDate = new Date(dataByDate[dataByDate.length - 1].date);\n        let dateTimeSpan = lastDate - firstDate;\n\n        if (locale && ((typeof Intl === 'undefined') || (typeof Intl === 'object' && !Intl.DateTimeFormat))) {\n            locale = null;\n        }\n\n        if (!settings) {\n            settings = getAxisSettingsFromTimeSpan(dateTimeSpan);\n        }\n\n        let [minor, major] = settings.split('-');\n\n        let majorTickValue = settingsToMajorTickMap[settings];\n        let minorTickValue = getMaxNumOfHorizontalTicks(width, dataByDate.length);\n\n        return {\n            minor: {\n              format: locale ? getLocaleDateFormatter(locale, minor) : formatMap[minor],\n              tick: minorTickValue\n            },\n            major: {\n              format: locale ? getLocaleDateFormatter(locale, major) : formatMap[major],\n              tick: majorTickValue\n            }\n        };\n    };\n\n    return {\n        getXAxisSettings,\n        getLocaleDateFormatter\n    };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./src/charts/helpers/timeAxis.js"],"sourceRoot":""}