{"version":3,"sources":["webpack:///webpack/universalModuleDefinition?5ca6****","webpack:///groupedBar.min.js","webpack:///webpack/bootstrap 0a1eb6cfa29181d5999f?cc57****","webpack:///./src/charts/grouped-bar.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/exportChart.js?f69b*","webpack:///./src/charts/helpers/colors.js?2682****","webpack:///./src/charts/helpers/constants.js?4e60**","webpack:///./src/charts/helpers/serializeWithStyles.js?b833*","webpack:///./~/base-64/base64.js?68a6*","webpack:///(webpack)/buildin/module.js?c3c2*","webpack:///./~/lodash.assign/index.js"],"names":["root","factory","exports","module","define","amd","this","modules","__webpack_require__","moduleId","installedModules","id","loaded","call","m","c","p","__WEBPACK_AMD_DEFINE_RESULT__","_slicedToArray","sliceIterator","arr","i","_arr","_n","_d","_e","undefined","_s","_i","Symbol","iterator","next","done","push","value","length","err","Array","isArray","Object","TypeError","require","d3Array","d3Axis","d3Color","d3Collection","d3Dispatch","d3Ease","d3Interpolate","d3Scale","d3Selection","assign","_require","exportChart","colorHelper","NUMBER_FORMAT","uniq","arrArg","filter","elem","pos","indexOf","_selection","each","_data","chartWidth","width","margin","left","right","chartHeight","height","top","bottom","data","cleanData","prepareData","buildScales","buildLayers","buildSVG","drawGridLines","buildAxis","drawAxis","drawGroupedBar","addMouseEvents","shouldShowTooltip","svg","on","d","handleMouseOver","handleMouseOut","handleMouseMove","selectAll","handleBarsMouseOver","handleBarsMouseOut","adjustYTickLabels","selection","attr","yTickTextXOffset","yTickTextYOffset","isHorizontal","xAxis","axisBottom","xScale","ticks","xTicks","valueLabelFormat","yAxis","axisLeft","yScale","yTicks","buildContainerGroups","container","append","classed","layers","transformedData","map","item","ret","groups","forEach","key","yMax","max","getValue","scaleLinear","domain","rangeRound","scaleBand","getName","padding","yScale2","getGroup","bandwidth","xScale2","nice","colorScale","scaleOrdinal","range","colorSchema","categoryColorMap","reduce","memo","v","name","group","select","valueLabel","groupLabel","topicName","nameLabel","xAxisPadding","drawHorizontalExtendedLine","baseLine","enter","drawVerticalExtendedLine","scale","grid","slice","drawHorizontalBars","series","bars","_ref4","_ref5","values","isAnimated","style","barOpacity","transition","delay","_","animationDelays","duration","animationDuration","ease","tween","horizontalBarsTween","drawVerticalBars","verticalBarsTween","exit","remove","getMousePosition","event","mouse","getNearestDataPoint","mouseX","adjustedMouseX","epsilon","nearest","found","find","d2","Math","abs","getNearestDataPoint2","mouseY","adjustedMouseY","e","color","darker","_getMousePosition","_getMousePosition2","dataPoint","x","y","moveTooltipOriginXY","dispatcher","node","interpolateRound","j","interpolateNumber","t","originXPosition","originYPosition","nest","rollup","entry","entries","total","sum","permute","tooltipThreshold","aspectRatio","colorSchemas","britecharts","easeQuadInOut","maxBarNumber","animationDelayStep","_ref","_ref2","_ref3","dispatch","_x","arguments","filename","title","ceil","apply","global","ascendingComparator","f","ascending","pair","a","b","tickIncrement","start","stop","count","step","power","floor","log","LN10","error","pow","e10","e5","e2","tickStep","step0","step1","NaN","bisector","compare","lo","hi","mid","ascendingBisect","bisectRight","bisectLeft","pairs","array","n","cross","values0","values1","i0","i1","value0","n0","n1","descending","number","variance","valueof","delta","mean","isNaN","deviation","sqrt","extent","min","prototype","constant","identity","reverse","isFinite","sturges","LN2","histogram","xz","x0","x1","tz","threshold","shift","pop","bin","bins","thresholds","quantile","value1","freedmanDiaconis","sort","scott","median","numbers","merge","arrays","merged","indexes","permutes","scan","xi","xj","shuffle","random","transpose","matrix","row","zip","bisect","thresholdFreedmanDiaconis","thresholdScott","thresholdSturges","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","polyOut","polyInOut","PI","overshoot","backIn","s","backOut","backInOut","tau","amplitude","period","elasticIn","asin","elasticOut","elasticInOut","easeLinear","easeQuad","easeQuadIn","easeQuadOut","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","center","offset","round","entering","__axis","axis","orient","context","tickValues","tickArguments","format","tickFormat","spacing","tickSizeInner","tickPadding","range0","range1","position","copy","path","tick","order","tickExit","tickEnter","line","text","insert","k","transform","getAttribute","parentNode","tickSizeOuter","tickSize","axisTop","axisRight","extend","parent","definition","create","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","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","grey","honeydew","hotpink","indianred","indigo","ivory","khaki","lavender","lavenderblush","lawngreen","lemonchiffon","lightblue","lightcoral","lightcyan","lightgoldenrodyellow","lightgray","lightgreen","lightgrey","lightpink","lightsalmon","lightseagreen","lightskyblue","lightslategray","lightslategrey","lightsteelblue","lightyellow","lime","limegreen","linen","magenta","maroon","mediumaquamarine","mediumblue","mediumorchid","mediumpurple","mediumseagreen","mediumslateblue","mediumspringgreen","mediumturquoise","mediumvioletred","midnightblue","mintcream","mistyrose","moccasin","navajowhite","navy","oldlace","olive","olivedrab","orange","orangered","orchid","palegoldenrod","palegreen","paleturquoise","palevioletred","papayawhip","peachpuff","peru","pink","plum","powderblue","purple","rebeccapurple","red","rosybrown","royalblue","saddlebrown","salmon","sandybrown","seagreen","seashell","sienna","silver","skyblue","slateblue","slategray","slategrey","snow","springgreen","steelblue","tan","teal","thistle","tomato","turquoise","violet","wheat","white","whitesmoke","yellow","yellowgreen","displayable","toString","Kn","A","B","cosh","sinh","Error","Dispatch","parseTypenames","typenames","types","split","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","Infinity","currency","test","percent","precisionFixed","precisionPrefix","precisionRound","formatDefaultLocale","d3Format","d3Time","d3TimeFormat","ordinal","range$$1","index","unknown","implicit","has","band","rescale","paddingInner","paddingOuter","ordinalRange","pointish","point","deinterpolateLinear","deinterpolateClamp","deinterpolate","reinterpolateClamp","reinterpolate","bimap","d0","d1","r0","r1","polymap","source","target","interpolate","clamp","continuous","piecewise","output","input","interpolate$$1","unit","invert","map$1","linearish","pow10","powp","base","exp","logp","log10","log2","reflect","logs","pows","u","raise","quantile$1","invertExtent","quantiles","quantize","date","Date","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","timeDay","timeHour","timeMinute","timeSecond","timeMillisecond","timeFormat","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","scalePoint","scaleIdentity","scaleLog","scaleImplicit","scalePow","scaleSqrt","scaleQuantile","scaleQuantize","scaleThreshold","scaleTime","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","size","empty","depth","createResult","setResult","sortValues","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","parse","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","coshr0","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","getDate","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","sourceEvent","none","EnterNode","datum","_next","_parent","bindIndex","update","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","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","changedTouches","querySelector","selection_select","subgroups","subnode","subgroup","selectorAll","querySelectorAll","selection_selectAll","selection_filter","sparse","selection_enter","_enter","child","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","schedules","STARTED","timeout","RUNNING","ENDED","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","timeout$1","interval$1","d3svg","img","createImage","convertSvgToHtml","onload","handleImageLoad","createCanvas","addBackground","config","styleBackgroundString","serializer","serializeWithStyles","initializeSerializer","formatHtmlByBrowser","prependTitle","canvas","svgHtml","Image","src","imageSourceBase","b64EncodeUnicode","drawImageOnCanvas","image","getContext","drawImage","downloadCanvas","defaultFilename","extensionType","url","toDataURL","link","href","download","body","click","navigator","userAgent","search","constants","lineGradientId","preventDefault","svgWidth","titleTopOffset","titleFontFamily","titleFontSize","encoder","btoa","encode","str","encodeURIComponent","String","fromCharCode","styleClass","chartBackground","britechartGradients","greenBlue","orangePink","bluePurple","blueGreen","aloeGreen","colorSchemasHuman","singleColors","colorGradients","colorGradientsHuman","axisTimeCombinations","MINUTE_HOUR","HOUR_DAY","DAY_MONTH","MONTH_YEAR","timeBenchmarks","ONE_AND_A_HALF_YEARS","ONE_YEAR","ONE_DAY","computeDefaultStyleByTagName","tagName","defaultStyle","computedStyle","getDefaultStyleByTagName","defaultStylesByTagName","cssTexts","elements","nodeType","Node","ELEMENT_NODE","el","noStyleTags","cssText","cssPropName","outerHTML","BASE","HEAD","HTML","META","NOFRAME","NOSCRIPT","PARAM","SCRIPT","STYLE","TITLE","tagNames","freeExports","freeGlobal","InvalidCharacterError","message","TABLE","REGEX_SPACE_CHARACTERS","decode","bitStorage","buffer","bitCounter","base64","version","webpackPolyfill","deprecate","paths","func","thisArg","baseTimes","iteratee","overArg","arg","arrayLikeKeys","inherited","isArguments","skipIndexes","isIndex","assignValue","objValue","eq","baseKeys","isPrototype","nativeKeys","baseRest","nativeMax","otherArgs","copyObject","props","customizer","newValue","createAssigner","assigner","sources","guard","isIterateeCall","MAX_SAFE_INTEGER","reIsUint","isObject","isArrayLike","Ctor","objectProto","other","isArrayLikeObject","propertyIsEnumerable","objectToString","argsTag","isLength","isFunction","isObjectLike","tag","funcTag","genTag","nonEnumShadows"],"mappings":"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","file":"groupedBar.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[\"groupedBar\"] = factory();\n\telse\n\t\troot[\"britecharts\"] = root[\"britecharts\"] || {}, root[\"britecharts\"][\"groupedBar\"] = 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[\"groupedBar\"] = factory();\n\telse\n\t\troot[\"britecharts\"] = root[\"britecharts\"] || {}, root[\"britecharts\"][\"groupedBar\"] = 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\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\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 d3Color = __webpack_require__(4);\n\t    var d3Collection = __webpack_require__(8);\n\t    var d3Dispatch = __webpack_require__(5);\n\t    var d3Ease = __webpack_require__(2);\n\t    var d3Interpolate = __webpack_require__(9);\n\t    var d3Scale = __webpack_require__(7);\n\t    var d3Selection = __webpack_require__(12);\n\t    var assign = __webpack_require__(28);\n\t    var d3Transition = __webpack_require__(13);\n\t\n\t    var _require = __webpack_require__(16),\n\t        exportChart = _require.exportChart;\n\t\n\t    var colorHelper = __webpack_require__(17);\n\t    var NUMBER_FORMAT = ',f';\n\t    var uniq = function uniq(arrArg) {\n\t        return arrArg.filter(function (elem, pos, arr) {\n\t            return arr.indexOf(elem) == pos;\n\t        });\n\t    };\n\t\n\t    /**\n\t     * @typdef D3Layout\n\t     * @type function\n\t     */\n\t\n\t    /**\n\t     * @typedef GroupedBarChartData\n\t     * @type {Object}\n\t     * @property {Object[]} data       All data entries\n\t     * @property {String} name         Name of the entry\n\t     * @property {String} group        group of the entry\n\t     * @property {Number} value        Value of the entry\n\t     *\n\t     * @example\n\t     * {\n\t     *     'data': [\n\t     *         {\n\t     *             \"name\": \"2011-01\",\n\t     *             \"group\": \"Direct\",\n\t     *             \"value\": 0\n\t     *         }\n\t     *     ]\n\t     * }\n\t     */\n\t\n\t    /**\n\t     * Grouped Bar Chart reusable API module that allows us\n\t     * rendering a multi grouped bar and configurable chart.\n\t     *\n\t     * @module Grouped-bar\n\t     * @tutorial grouped-bar\n\t     * @requires d3-array, d3-axis, d3-color, d3-collection, d3-dispatch, d3-ease,\n\t     *  d3-interpolate, d3-scale, d3-selection, lodash assign\n\t     *\n\t     * @example\n\t     * let groupedBar = GroupedBar();\n\t     *\n\t     * groupedBar\n\t     *     .width(containerWidth);\n\t     *\n\t     * d3Selection.select('.css-selector')\n\t     *     .datum(dataset.data)\n\t     *     .call(groupedBar);\n\t     *\n\t     */\n\t    return function module() {\n\t\n\t        var margin = {\n\t            top: 40,\n\t            right: 30,\n\t            bottom: 60,\n\t            left: 70\n\t        },\n\t            width = 960,\n\t            height = 500,\n\t            xScale = void 0,\n\t            xScale2 = void 0,\n\t            xAxis = void 0,\n\t            yScale = void 0,\n\t            yScale2 = void 0,\n\t            yAxis = void 0,\n\t            aspectRatio = null,\n\t            yTickTextYOffset = -8,\n\t            yTickTextXOffset = -20,\n\t            yTicks = 5,\n\t            xTicks = 5,\n\t            baseLine = void 0,\n\t            colorSchema = colorHelper.colorSchemas.britecharts,\n\t            colorScale = void 0,\n\t            categoryColorMap = void 0,\n\t            layers = void 0,\n\t            ease = d3Ease.easeQuadInOut,\n\t            isHorizontal = false,\n\t            svg = void 0,\n\t            chartWidth = void 0,\n\t            chartHeight = void 0,\n\t            data = void 0,\n\t            groups = void 0,\n\t            transformedData = void 0,\n\t            tooltipThreshold = 480,\n\t            xAxisPadding = {\n\t            top: 0,\n\t            left: 0,\n\t            bottom: 0,\n\t            right: 0\n\t        },\n\t            maxBarNumber = 8,\n\t            barOpacity = 0.24,\n\t            animationDelayStep = 20,\n\t            animationDelays = d3Array.range(animationDelayStep, maxBarNumber * animationDelayStep, animationDelayStep),\n\t            animationDuration = 1000,\n\t            grid = null,\n\t            nameLabel = 'name',\n\t            valueLabel = 'value',\n\t            groupLabel = 'group',\n\t            valueLabelFormat = NUMBER_FORMAT,\n\t\n\t\n\t        // getters\n\t        getName = function getName(_ref) {\n\t            var name = _ref.name;\n\t            return name;\n\t        },\n\t            getValue = function getValue(_ref2) {\n\t            var value = _ref2.value;\n\t            return value;\n\t        },\n\t            getGroup = function getGroup(_ref3) {\n\t            var group = _ref3.group;\n\t            return group;\n\t        },\n\t            isAnimated = false,\n\t\n\t\n\t        // events\n\t        dispatcher = d3Dispatch.dispatch('customMouseOver', 'customMouseOut', 'customMouseMove');\n\t\n\t        /**\n\t         * This function creates the graph using the selection and data provided\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 {GroupedBarChartData} _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(_data);\n\t\n\t                prepareData(data);\n\t                buildScales();\n\t                buildLayers();\n\t                buildSVG(this);\n\t                drawGridLines();\n\t                buildAxis();\n\t                drawAxis();\n\t                drawGroupedBar();\n\t                addMouseEvents();\n\t            });\n\t        }\n\t\n\t        /**\n\t         * Adds events to the container group if the environment is not mobile\n\t         * Adding: mouseover, mouseout and mousemove\n\t         */\n\t        function addMouseEvents() {\n\t            if (shouldShowTooltip()) {\n\t                svg.on('mouseover', function (d) {\n\t                    handleMouseOver(this, d);\n\t                }).on('mouseout', function (d) {\n\t                    handleMouseOut(this, d);\n\t                }).on('mousemove', function (d) {\n\t                    handleMouseMove(this, d);\n\t                });\n\t            }\n\t\n\t            svg.selectAll('.bar').on('mouseover', function (d) {\n\t                handleBarsMouseOver(this, d);\n\t            }).on('mouseout', function (d) {\n\t                handleBarsMouseOut(this, d);\n\t            });\n\t        }\n\t\n\t        /**\n\t         * Adjusts the position of the y axis' ticks\n\t         * @param  {D3Selection} selection Y axis group\n\t         * @return void\n\t         */\n\t        function adjustYTickLabels(selection) {\n\t            selection.selectAll('.tick text').attr('transform', 'translate(' + yTickTextXOffset + ', ' + yTickTextYOffset + ')');\n\t        }\n\t\n\t        /**\n\t         * Creates the d3 x and y axis, setting orientations\n\t         * @private\n\t         */\n\t        function buildAxis() {\n\t            if (isHorizontal) {\n\t                xAxis = d3Axis.axisBottom(xScale).ticks(xTicks, valueLabelFormat);\n\t                yAxis = d3Axis.axisLeft(yScale);\n\t            } else {\n\t                xAxis = d3Axis.axisBottom(xScale);\n\t                yAxis = d3Axis.axisLeft(yScale).ticks(yTicks, valueLabelFormat);\n\t            }\n\t        }\n\t\n\t        /**\n\t         * Builds containers for the chart, the axis and a wrapper for all of them\n\t         * NOTE: The order of drawing of this group elements is really important,\n\t         * as everything else will be drawn on top of them\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('x-axis-group', true).append('g').classed('x axis', true);\n\t            container.selectAll('.x-axis-group').append('g').classed('month-axis', true);\n\t            container.append('g').classed('y-axis-group axis', true);\n\t            container.append('g').classed('grid-lines-group', true);\n\t            container.append('g').classed('chart-group', true);\n\t            container.append('g').classed('metadata-group', true);\n\t        }\n\t\n\t        /**\n\t         * Builds the grouped layers layout\n\t         * @return {D3Layout} Layout for drawing the chart\n\t         * @private\n\t         */\n\t        function buildLayers() {\n\t            layers = transformedData.map(function (item) {\n\t                var ret = {};\n\t\n\t                groups.forEach(function (key) {\n\t                    ret[key] = item[key];\n\t                });\n\t\n\t                return assign({}, item, ret);\n\t            });\n\t        }\n\t\n\t        /**\n\t         * Creates the x, y and color scales of the chart\n\t         * @private\n\t         */\n\t        function buildScales() {\n\t            var yMax = d3Array.max(data.map(getValue));\n\t\n\t            if (isHorizontal) {\n\t                xScale = d3Scale.scaleLinear().domain([0, yMax]).rangeRound([0, chartWidth - 1]);\n\t                // 1 pix for edge tick\n\t\n\t                yScale = d3Scale.scaleBand().domain(data.map(getName)).rangeRound([chartHeight, 0]).padding(0.1);\n\t\n\t                yScale2 = d3Scale.scaleBand().domain(data.map(getGroup)).rangeRound([yScale.bandwidth(), 0]).padding(0.1);\n\t            } else {\n\t                xScale = d3Scale.scaleBand().domain(data.map(getName)).rangeRound([0, chartWidth]).padding(0.1);\n\t                xScale2 = d3Scale.scaleBand().domain(data.map(getGroup)).rangeRound([0, xScale.bandwidth()]).padding(0.1);\n\t\n\t                yScale = d3Scale.scaleLinear().domain([0, yMax]).rangeRound([chartHeight, 0]).nice();\n\t            }\n\t\n\t            colorScale = d3Scale.scaleOrdinal().range(colorSchema).domain(data.map(getGroup));\n\t\n\t            categoryColorMap = colorScale.domain(data.map(getName)).domain().reduce(function (memo, item) {\n\t                data.forEach(function (v) {\n\t                    if (getName(v) == item) {\n\t                        memo[v.name] = colorScale(v.group);\n\t                        memo[v.group] = colorScale(v.group);\n\t                        memo[v.group + item] = colorScale(v.group);\n\t                    }\n\t                });\n\t                return memo;\n\t            }, {});\n\t        }\n\t\n\t        /**\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 grouped-bar', 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         * Parses dates and values into JS Date objects and numbers\n\t         * @param  {obj} data Raw data from JSON file\n\t         * @return {obj}      Parsed data with values and dates\n\t         */\n\t        function cleanData(data) {\n\t            return data.map(function (d) {\n\t                d.value = +d[valueLabel];\n\t                d.group = d[groupLabel];\n\t                // for tooltip\n\t                d.topicName = getGroup(d);\n\t                d.name = d[nameLabel];\n\t\n\t                return d;\n\t            });\n\t        }\n\t\n\t        /**\n\t         * Draws the x and y axis on the svg object within their\n\t         * respective groups\n\t         * @private\n\t         */\n\t        function drawAxis() {\n\t            if (isHorizontal) {\n\t                svg.select('.x-axis-group .axis.x').attr('transform', 'translate( 0, ' + chartHeight + ' )').call(xAxis);\n\t\n\t                svg.select('.y-axis-group.axis').attr('transform', 'translate( ' + -xAxisPadding.left + ', 0)').call(yAxis);\n\t            } else {\n\t                svg.select('.x-axis-group .axis.x').attr('transform', 'translate( 0, ' + chartHeight + ' )').call(xAxis);\n\t\n\t                svg.select('.y-axis-group.axis').attr('transform', 'translate( ' + -xAxisPadding.left + ', 0)').call(yAxis).call(adjustYTickLabels);\n\t            }\n\t        }\n\t\n\t        /**\n\t         * Draws a vertical line to extend x-axis till the edges\n\t         * @return {void}\n\t         */\n\t        function drawHorizontalExtendedLine() {\n\t            baseLine = svg.select('.grid-lines-group').selectAll('line.extended-x-line').data([0]).enter().append('line').attr('class', 'extended-x-line').attr('x1', xAxisPadding.left).attr('x2', chartWidth).attr('y1', chartHeight).attr('y2', chartHeight);\n\t        }\n\t\n\t        /**\n\t         * Draws a vertical line to extend y-axis till the edges\n\t         * @return {void}\n\t         */\n\t        function drawVerticalExtendedLine() {\n\t            baseLine = svg.select('.grid-lines-group').selectAll('line.extended-y-line').data([0]).enter().append('line').attr('class', 'extended-y-line').attr('y1', xAxisPadding.bottom).attr('y2', chartHeight).attr('x1', 0).attr('x2', 0);\n\t        }\n\t\n\t        /**\n\t         * Draws grid lines on the background of the chart\n\t         * @return void\n\t         */\n\t        function drawGridLines() {\n\t            var scale = isHorizontal ? xScale : yScale;\n\t\n\t            if (grid === 'horizontal' || grid === 'full') {\n\t                svg.select('.grid-lines-group').selectAll('line.horizontal-grid-line').data(scale.ticks(yTicks).slice(1)).enter().append('line').attr('class', 'horizontal-grid-line').attr('x1', -xAxisPadding.left + 1).attr('x2', chartWidth).attr('y1', function (d) {\n\t                    return yScale(d);\n\t                }).attr('y2', function (d) {\n\t                    return yScale(d);\n\t                });\n\t            }\n\t\n\t            if (grid === 'vertical' || grid === 'full') {\n\t                svg.select('.grid-lines-group').selectAll('line.vertical-grid-line').data(scale.ticks(xTicks).slice(1)).enter().append('line').attr('class', 'vertical-grid-line').attr('y1', 0).attr('y2', chartHeight).attr('x1', function (d) {\n\t                    return xScale(d);\n\t                }).attr('x2', function (d) {\n\t                    return xScale(d);\n\t                });\n\t            }\n\t\n\t            if (isHorizontal) {\n\t                drawVerticalExtendedLine();\n\t            } else {\n\t                drawHorizontalExtendedLine();\n\t            }\n\t        }\n\t\n\t        /**\n\t         * Draws the bars along the x axis\n\t         * @param  {D3Selection} bars Selection of bars\n\t         * @return {void}\n\t         */\n\t        function drawHorizontalBars(series) {\n\t            // Enter + Update\n\t            var bars = series.data(layers).enter().append('g').attr('transform', function (_ref4) {\n\t                var key = _ref4.key;\n\t                return 'translate(0,' + yScale(key) + ')';\n\t            }).classed('layer', true).selectAll('.bar').data(function (_ref5) {\n\t                var values = _ref5.values;\n\t                return values;\n\t            }).enter().append('rect').classed('bar', true).attr('x', 1).attr('y', function (d) {\n\t                return yScale2(getGroup(d));\n\t            }).attr('height', yScale2.bandwidth()).attr('fill', function (data) {\n\t                return categoryColorMap[data.group];\n\t            });\n\t\n\t            if (isAnimated) {\n\t                bars.style('opacity', barOpacity).transition().delay(function (_, i) {\n\t                    return animationDelays[i];\n\t                }).duration(animationDuration).ease(ease).tween('attr.width', horizontalBarsTween);\n\t            } else {\n\t                bars.attr('width', function (d) {\n\t                    return xScale(getValue(d));\n\t                });\n\t            }\n\t        }\n\t\n\t        /**\n\t         * Draws the bars along the y axis\n\t         * @param  {D3Selection} bars Selection of bars\n\t         * @return {void}\n\t         */\n\t        function drawVerticalBars(series) {\n\t            // Enter + Update\n\t            var bars = series.data(layers).enter().append('g').attr('transform', function (d) {\n\t                return 'translate(' + xScale(d.key) + ',0)';\n\t            }).classed('layer', true).selectAll('.bar').data(function (d) {\n\t                return d.values;\n\t            }).enter().append('rect').classed('bar', true).attr('x', function (d) {\n\t                return xScale2(getGroup(d));\n\t            }).attr('y', function (d) {\n\t                return yScale(d.value);\n\t            }).attr('width', xScale2.bandwidth).attr('fill', function (data) {\n\t                return categoryColorMap[data.group];\n\t            });\n\t\n\t            if (isAnimated) {\n\t                bars.style('opacity', barOpacity).transition().delay(function (_, i) {\n\t                    return animationDelays[i];\n\t                }).duration(animationDuration).ease(ease).tween('attr.height', verticalBarsTween);\n\t            } else {\n\t                bars.attr('height', function (d) {\n\t                    return chartHeight - yScale(getValue(d));\n\t                });\n\t            }\n\t        }\n\t\n\t        /**\n\t         * Draws the different areas into the chart-group element\n\t         * @private\n\t         */\n\t        function drawGroupedBar() {\n\t            var series = svg.select('.chart-group').selectAll('.layer');\n\t\n\t            if (isHorizontal) {\n\t                drawHorizontalBars(series);\n\t            } else {\n\t                drawVerticalBars(series);\n\t            }\n\t            // Exit\n\t            series.exit().transition().style('opacity', 0).remove();\n\t        }\n\t\n\t        /**\n\t         * Extract X position on the chart from a given mouse event\n\t         * @param  {obj} event D3 mouse event\n\t         * @return {Number}       Position on the x axis of the mouse\n\t         * @private\n\t         */\n\t        function getMousePosition(event) {\n\t            return d3Selection.mouse(event);\n\t        }\n\t\n\t        /**\n\t         * Finds out the data entry that is closer to the given position on pixels\n\t         * @param  {Number} mouseX X position of the mouse\n\t         * @return {obj}        Data entry that is closer to that x axis position\n\t         */\n\t        function getNearestDataPoint(mouseX) {\n\t            var adjustedMouseX = mouseX - margin.left,\n\t                epsilon = xScale2.bandwidth(),\n\t                nearest = [];\n\t\n\t            layers.forEach(function (data) {\n\t                var found = data.values.find(function (d2) {\n\t                    return Math.abs(adjustedMouseX >= xScale(d2[nameLabel]) + xScale2(d2[groupLabel])) && Math.abs(adjustedMouseX - xScale2(d2[groupLabel]) - xScale(d2[nameLabel]) <= epsilon);\n\t                });\n\t\n\t                if (found) {\n\t                    found.values = data.values;\n\t                    found.key = found.name;\n\t                    nearest.push(found);\n\t                }\n\t            });\n\t\n\t            return nearest.length ? nearest[0] : undefined;\n\t        }\n\t\n\t        /**\n\t        * Finds out the data entry that is closer to the given position on pixels\n\t        * @param  {Number} mouseX X position of the mouse\n\t        * @return {obj}        Data entry that is closer to that x axis position\n\t        */\n\t        function getNearestDataPoint2(mouseY) {\n\t            var adjustedMouseY = mouseY - margin.bottom,\n\t                epsilon = yScale.bandwidth(),\n\t                nearest = [];\n\t\n\t            layers.map(function (data) {\n\t                var found = data.values.find(function (d2) {\n\t                    return Math.abs(adjustedMouseY >= yScale(d2[nameLabel])) && Math.abs(adjustedMouseY - yScale(d2[nameLabel]) <= epsilon * 2);\n\t                });\n\t\n\t                if (found) {\n\t                    found.values = data.values;\n\t                    found.key = found.name;\n\t                    nearest.push(found);\n\t                }\n\t            });\n\t\n\t            return nearest.length ? nearest[0] : undefined;\n\t        }\n\t\n\t        /**\n\t         * Handles a mouseover event on top of a bar\n\t         * @param  {obj} e the fired event\n\t         * @param  {obj} d data of bar\n\t         * @return {void}\n\t         */\n\t        function handleBarsMouseOver(e, d) {\n\t            d3Selection.select(e).attr('fill', function () {\n\t                return d3Color.color(categoryColorMap[d.group]).darker();\n\t            });\n\t        }\n\t\n\t        /**\n\t         * Handles a mouseout event out of a bar\n\t         * @param  {obj} e the fired event\n\t         * @param  {obj} d data of bar\n\t         * @return {void}\n\t         */\n\t        function handleBarsMouseOut(e, d) {\n\t            d3Selection.select(e).attr('fill', function () {\n\t                return categoryColorMap[d.group];\n\t            });\n\t        }\n\t\n\t        /**\n\t         * MouseMove handler, calculates the nearest dataPoint to the cursor\n\t         * and updates metadata related to it\n\t         * @param  {obj} e the fired event\n\t         * @private\n\t         */\n\t        function handleMouseMove(e) {\n\t            var _getMousePosition = getMousePosition(e),\n\t                _getMousePosition2 = _slicedToArray(_getMousePosition, 2),\n\t                mouseX = _getMousePosition2[0],\n\t                mouseY = _getMousePosition2[1],\n\t                dataPoint = isHorizontal ? getNearestDataPoint2(mouseY) : getNearestDataPoint(mouseX),\n\t                x = void 0,\n\t                y = void 0;\n\t\n\t            if (dataPoint) {\n\t                // Move verticalMarker to that datapoint\n\t                if (isHorizontal) {\n\t                    x = mouseX - margin.left;\n\t                    y = yScale(dataPoint.key) + yScale.bandwidth() / 2;\n\t                } else {\n\t                    x = xScale(dataPoint.key) + xScale2(dataPoint[groupLabel]);\n\t                    y = mouseY - margin.bottom;\n\t                }\n\t                moveTooltipOriginXY(x, y);\n\t\n\t                // Emit event with xPosition for tooltip or similar feature\n\t                dispatcher.call('customMouseMove', e, dataPoint, categoryColorMap, x, y);\n\t            }\n\t        }\n\t\n\t        /**\n\t         * MouseOut handler, hides overlay and removes active class on verticalMarkerLine\n\t         * It also resets the container of the vertical marker\n\t         * @private\n\t         */\n\t        function handleMouseOut(e, d) {\n\t            svg.select('.metadata-group').attr('transform', 'translate(9999, 0)');\n\t            dispatcher.call('customMouseOut', e, d, d3Selection.mouse(e));\n\t        }\n\t\n\t        /**\n\t         * Mouseover handler, shows overlay and adds active class to verticalMarkerLine\n\t         * @private\n\t         */\n\t        function handleMouseOver(e, d) {\n\t            dispatcher.call('customMouseOver', e, d, d3Selection.mouse(e));\n\t        }\n\t\n\t        /**\n\t         * Animation tween of horizontal bars\n\t         * @param  {obj} d data of bar\n\t         * @return {void}\n\t         */\n\t        function horizontalBarsTween(d) {\n\t            var node = d3Selection.select(this),\n\t                i = d3Interpolate.interpolateRound(0, xScale(getValue(d))),\n\t                j = d3Interpolate.interpolateNumber(0, 1);\n\t\n\t            return function (t) {\n\t                node.attr('width', i(t)).style('opacity', j(t));\n\t            };\n\t        }\n\t\n\t        /**\n\t         * Helper method to update the x position of the vertical marker\n\t         * @param  {obj} dataPoint Data entry to extract info\n\t         * @return void\n\t         */\n\t        function moveTooltipOriginXY(originXPosition, originYPosition) {\n\t            svg.select('.metadata-group').attr('transform', 'translate(' + originXPosition + ',' + originYPosition + ')');\n\t        }\n\t\n\t        /**\n\t         * Prepare data for create chart.\n\t         * @private\n\t         */\n\t        function prepareData(data) {\n\t            groups = uniq(data.map(function (d) {\n\t                return getGroup(d);\n\t            }));\n\t            transformedData = d3Collection.nest().key(getName).rollup(function (values) {\n\t                var ret = {};\n\t\n\t                values.forEach(function (entry) {\n\t                    if (entry && entry[groupLabel]) {\n\t                        ret[entry[groupLabel]] = getValue(entry);\n\t                    }\n\t                });\n\t                //for tooltip\n\t                ret.values = values;\n\t                return ret;\n\t            }).entries(data).map(function (data) {\n\t                return assign({}, {\n\t                    total: d3Array.sum(d3Array.permute(data.value, groups)),\n\t                    key: data.key\n\t                }, data.value);\n\t            });\n\t        }\n\t\n\t        /**\n\t         * Determines if we should add the tooltip related logic depending on the\n\t         * size of the chart and the tooltipThreshold variable value\n\t         * @return {boolean} Should we build the tooltip?\n\t         * @private\n\t         */\n\t        function shouldShowTooltip() {\n\t            return width > tooltipThreshold;\n\t        }\n\t\n\t        /**\n\t         * Animation tween of vertical bars\n\t         * @param  {obj} d data of bar\n\t         * @return {void}\n\t         */\n\t        function verticalBarsTween(d) {\n\t            var node = d3Selection.select(this),\n\t                i = d3Interpolate.interpolateRound(0, chartHeight - yScale(getValue(d))),\n\t                y = d3Interpolate.interpolateRound(chartHeight, yScale(getValue(d))),\n\t                j = d3Interpolate.interpolateNumber(0, 1);\n\t\n\t            return function (t) {\n\t                node.attr('y', y(t)).attr('height', i(t)).style('opacity', j(t));\n\t            };\n\t        }\n\t\n\t        // API\n\t\n\t        /**\n\t         * Gets or Sets the aspect ratio of the chart\n\t         * @param  {Number} _x Desired aspect ratio for the graph\n\t         * @return { (Number | Module) } Current aspect ratio or Area Chart module to chain calls\n\t         * @public\n\t         */\n\t        exports.aspectRatio = function (_x) {\n\t            if (!arguments.length) {\n\t                return aspectRatio;\n\t            }\n\t            aspectRatio = _x;\n\t\n\t            return this;\n\t        };\n\t\n\t        /**\n\t         * Gets or Sets the colorSchema of the chart\n\t         * @param  {String[]} _x Desired colorSchema for the graph\n\t         * @return { colorSchema | module} Current colorSchema or Chart module to chain calls\n\t         * @public\n\t         */\n\t        exports.colorSchema = function (_x) {\n\t            if (!arguments.length) {\n\t                return colorSchema;\n\t            }\n\t            colorSchema = _x;\n\t\n\t            return this;\n\t        };\n\t\n\t        /**\n\t         * Chart exported to png and a download action is fired\n\t         * @public\n\t         */\n\t        exports.exportChart = function (filename, title) {\n\t            exportChart.call(exports, svg, filename, title);\n\t        };\n\t\n\t        /**\n\t         * Gets or Sets the groupLabel of the chart\n\t         * @param  {String} _x Desired groupLabel for the graph\n\t         * @return { groupLabel | module} Current groupLabel or Chart module to chain calls\n\t         * @public\n\t         */\n\t        exports.groupLabel = function (_x) {\n\t            if (!arguments.length) {\n\t                return groupLabel;\n\t            }\n\t            groupLabel = _x;\n\t\n\t            return this;\n\t        };\n\t\n\t        /**\n\t         * Gets or Sets the grid mode.\n\t         *\n\t         * @param  {String} _x Desired mode for the grid ('vertical'|'horizontal'|'full')\n\t         * @return { String | module} Current mode of the grid or Area Chart module to chain calls\n\t         * @public\n\t         */\n\t        exports.grid = function (_x) {\n\t            if (!arguments.length) {\n\t                return grid;\n\t            }\n\t            grid = _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 { height | module} Current height or Area 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            if (aspectRatio) {\n\t                width = Math.ceil(_x / aspectRatio);\n\t            }\n\t            height = _x;\n\t\n\t            return this;\n\t        };\n\t\n\t        /**\n\t         * Gets or Sets the horizontal direction of the chart\n\t         * @param  {number} _x Desired horizontal direction for the graph\n\t         * @return { isHorizontal | module} If it is horizontal or Bar Chart module to chain calls\n\t         * @public\n\t         */\n\t        exports.isHorizontal = function (_x) {\n\t            if (!arguments.length) {\n\t                return isHorizontal;\n\t            }\n\t            isHorizontal = _x;\n\t\n\t            return this;\n\t        };\n\t\n\t        /**\n\t         * Gets or Sets the isAnimated property of the chart, making it to animate when render.\n\t         * By default this is 'false'\n\t         *\n\t         * @param  {Boolean} _x Desired animation flag\n\t         * @return { isAnimated | module} Current isAnimated flag or Chart module\n\t         * @public\n\t         */\n\t        exports.isAnimated = function (_x) {\n\t            if (!arguments.length) {\n\t                return isAnimated;\n\t            }\n\t            isAnimated = _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 { margin | module} Current margin or Area 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         * Gets or Sets the nameLabel of the chart\n\t         * @param  {Number} _x Desired dateLabel for the graph\n\t         * @return { nameLabel | module} Current nameLabel or Chart module to chain calls\n\t         * @public\n\t         */\n\t        exports.nameLabel = function (_x) {\n\t            if (!arguments.length) {\n\t                return nameLabel;\n\t            }\n\t            nameLabel = _x;\n\t\n\t            return this;\n\t        };\n\t\n\t        /**\n\t         * Gets or Sets the number of ticks of the y axis on the chart\n\t         * @param  {Number} _x          Desired vertical ticks\n\t         * @return {Number | module}    Current yTicks or Chart module to chain calls\n\t         * @public\n\t         */\n\t        exports.yTicks = function (_x) {\n\t            if (!arguments.length) {\n\t                return yTicks;\n\t            }\n\t            yTicks = _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 minimum width of the graph in order to show the tooltip\n\t         * NOTE: This could also depend on the aspect ratio\n\t         *\n\t         * @param  {Object} _x Margin object to get/set\n\t         * @return { tooltipThreshold | module} Current tooltipThreshold or Area Chart module to chain calls\n\t         * @public\n\t         */\n\t        exports.tooltipThreshold = function (_x) {\n\t            if (!arguments.length) {\n\t                return tooltipThreshold;\n\t            }\n\t            tooltipThreshold = _x;\n\t\n\t            return this;\n\t        };\n\t\n\t        /**\n\t         * Gets or Sets the valueLabel of the chart\n\t         * @param  {Number} _x Desired valueLabel for the graph\n\t         * @return { valueLabel | module} Current valueLabel or Chart module to chain calls\n\t         * @public\n\t         */\n\t        exports.valueLabel = function (_x) {\n\t            if (!arguments.length) {\n\t                return valueLabel;\n\t            }\n\t            valueLabel = _x;\n\t\n\t            return this;\n\t        };\n\t\n\t        /**\n\t         * Gets or Sets the valueLabelFormat of the chart\n\t         * @param  {String[]} _x Desired valueLabelFormat for the graph\n\t         * @return { valueLabelFormat | module} Current valueLabelFormat or Chart module to chain calls\n\t         * @public\n\t         */\n\t        exports.valueLabelFormat = function (_x) {\n\t            if (!arguments.length) {\n\t                return valueLabelFormat;\n\t            }\n\t            valueLabelFormat = _x;\n\t\n\t            return this;\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 { width | module} Current width or Area 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            if (aspectRatio) {\n\t                height = Math.ceil(_x * aspectRatio);\n\t            }\n\t            width = _x;\n\t\n\t            return this;\n\t        };\n\t\n\t        /**\n\t         * Gets or Sets the number of ticks of the x axis on the chart\n\t         * @param  {Number} _x Desired xTicks\n\t         * @return {Number | module} Current xTicks or Chart module to chain calls\n\t         * @public\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/***/ (function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_RESULT__;'use strict';\n\t\n\t!(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) {\n\t    'use strict';\n\t\n\t    var _require = __webpack_require__(17),\n\t        colorSchemas = _require.colorSchemas;\n\t\n\t    var constants = __webpack_require__(18);\n\t    var serializeWithStyles = __webpack_require__(19);\n\t\n\t    var encoder = window.btoa;\n\t\n\t    if (!encoder) {\n\t        encoder = __webpack_require__(20).encode;\n\t    }\n\t\n\t    // Base64 doesn't work really well with Unicode strings, so we need to use this function\n\t    // Ref: https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding\n\t    var b64EncodeUnicode = function b64EncodeUnicode(str) {\n\t        return encoder(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, function (match, p1) {\n\t            return String.fromCharCode('0x' + p1);\n\t        }));\n\t    };\n\t\n\t    var config = {\n\t        styleClass: 'britechartStyle',\n\t        defaultFilename: 'britechart.png',\n\t        chartBackground: 'white',\n\t        imageSourceBase: 'data:image/svg+xml;base64,',\n\t        titleFontSize: '15px',\n\t        titleFontFamily: '\\'Benton Sans\\', sans-serif',\n\t        titleTopOffset: 30,\n\t        get styleBackgroundString() {\n\t            return '<style>svg{background:' + this.chartBackground + ';}</style>';\n\t        }\n\t    };\n\t\n\t    /**\n\t     * Main function to be used as a method by chart instances to export charts to png\n\t     * @param  {array} svgs         (or an svg element) pass in both chart & legend as array or just chart as svg or in array\n\t     * @param  {string} filename    [download to be called <filename>.png]\n\t     * @param  {string} title       Title for the image\n\t     */\n\t    function exportChart(d3svg, filename, title) {\n\t        var img = createImage(convertSvgToHtml.call(this, d3svg, title));\n\t\n\t        img.onload = handleImageLoad.bind(img, createCanvas(this.width(), this.height()), filename);\n\t    }\n\t\n\t    /**\n\t     * adds background styles to raw html\n\t     * @param {string} html raw html\n\t     */\n\t    function addBackground(html) {\n\t        return html.replace('>', '>' + config.styleBackgroundString);\n\t    }\n\t\n\t    /**\n\t     * takes d3 svg el, adds proper svg tags, adds inline styles\n\t     * from stylesheets, adds white background and returns string\n\t     * @param  {object} d3svg TYPE d3 svg element\n\t     * @return {string} string of passed d3\n\t     */\n\t    function convertSvgToHtml(d3svg, title) {\n\t        if (!d3svg) {\n\t            return;\n\t        }\n\t\n\t        d3svg.attr('version', 1.1).attr('xmlns', 'http://www.w3.org/2000/svg');\n\t        var serializer = serializeWithStyles.initializeSerializer();\n\t        var html = serializer(d3svg.node());\n\t\n\t        html = formatHtmlByBrowser(html);\n\t        html = prependTitle.call(this, html, title, parseInt(d3svg.attr('width'), 10));\n\t        html = addBackground(html);\n\t\n\t        return html;\n\t    }\n\t\n\t    /**\n\t     * Create Canvas\n\t     * @param  {number} width\n\t     * @param  {number} height\n\t     * @return {object} TYPE canvas element\n\t     */\n\t    function createCanvas(width, height) {\n\t        var canvas = document.createElement('canvas');\n\t\n\t        canvas.height = height;\n\t        canvas.width = width;\n\t\n\t        return canvas;\n\t    }\n\t\n\t    /**\n\t     * Create Image\n\t     * @param  {string} svgHtml string representation of svg el\n\t     * @return {object}  TYPE element <img>, src points at svg\n\t     */\n\t    function createImage(svgHtml) {\n\t        var img = new Image();\n\t\n\t        img.src = '' + config.imageSourceBase + b64EncodeUnicode(svgHtml);\n\t\n\t        return img;\n\t    };\n\t\n\t    /**\n\t     * Draws image on canvas\n\t     * @param  {object} image TYPE:el <img>, to be drawn\n\t     * @param  {object} canvas TYPE: el <canvas>, to draw on\n\t     */\n\t    function drawImageOnCanvas(image, canvas) {\n\t        canvas.getContext('2d').drawImage(image, 0, 0);\n\t\n\t        return canvas;\n\t    }\n\t\n\t    /**\n\t     * Triggers browser to download image, convert canvas to url,\n\t     * we need to append the link el to the dom before clicking it for Firefox to register\n\t     * point <a> at it and trigger click\n\t     * @param  {object} canvas TYPE: el <canvas>\n\t     * @param  {string} filename\n\t     * @param  {string} extensionType\n\t     */\n\t    function downloadCanvas(canvas) {\n\t        var filename = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : config.defaultFilename;\n\t        var extensionType = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'image/png';\n\t\n\t        var url = canvas.toDataURL(extensionType);\n\t        var link = document.createElement('a');\n\t\n\t        link.href = url;\n\t        link.download = filename;\n\t        document.body.appendChild(link);\n\t        link.click();\n\t        document.body.removeChild(link);\n\t    }\n\t\n\t    /**\n\t     * Some browsers need special formatting, we handle that here\n\t     * @param  {string} html string of svg html\n\t     * @return {string} string of svg html\n\t     */\n\t    function formatHtmlByBrowser(html) {\n\t        if (navigator.userAgent.search('FireFox') > -1) {\n\t            return html.replace(/url.*&quot;\\)/, 'url(&quot;#' + constants.lineGradientId + '&quot;);');\n\t        }\n\t\n\t        return html;\n\t    }\n\t\n\t    /**\n\t     * Handles on load event fired by img.onload, this=img\n\t     * @param  {object} canvas TYPE: el <canvas>\n\t     * @param  {string} filename\n\t     * @param  {object} e\n\t     */\n\t    function handleImageLoad(canvas, filename, e) {\n\t        e.preventDefault();\n\t\n\t        downloadCanvas(drawImageOnCanvas(this, canvas), filename);\n\t    }\n\t\n\t    /**\n\t     * if passed, append title to the raw html to appear on graph\n\t     * @param  {string} html     raw html string\n\t     * @param  {string} title    title of the graph\n\t     * @param  {number} svgWidth width of graph container\n\t     * @return {string}         raw html with title prepended\n\t     */\n\t    function prependTitle(html, title, svgWidth) {\n\t        if (!title || !svgWidth) {\n\t            return html;\n\t        }\n\t        var grey = colorSchemas.grey;\n\t\n\t\n\t        html = html.replace(/<g/, '<text x=\"' + this.margin().left + '\" y=\"' + config.titleTopOffset + '\" font-family=\"' + config.titleFontFamily + '\" font-size=\"' + config.titleFontSize + '\" fill=\"' + grey[6] + '\"> ' + title + ' </text><g ');\n\t\n\t        return html;\n\t    }\n\t\n\t    return {\n\t        exportChart: exportChart,\n\t        convertSvgToHtml: convertSvgToHtml,\n\t        createImage: createImage,\n\t        drawImageOnCanvas: drawImageOnCanvas\n\t    };\n\t}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\n/***/ }),\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/***/ (function(module, exports) {\n\n\t'use strict';\n\t\n\tmodule.exports = function () {\n\t\n\t    'use strict';\n\t\n\t    return {\n\t\n\t        /**\n\t         * returns serializer function, only run it when you know you want to serialize your chart\n\t         * @return {func} serializer to add styles in line to dom string\n\t         */\n\t        initializeSerializer: function initializeSerializer() {\n\t\n\t            // Mapping between tag names and css default values lookup tables. This allows to exclude default values in the result.\n\t            var defaultStylesByTagName = {};\n\t\n\t            // Styles inherited from style sheets will not be rendered for elements with these tag names\n\t            var noStyleTags = { 'BASE': true, 'HEAD': true, 'HTML': true, 'META': true, 'NOFRAME': true, 'NOSCRIPT': true, 'PARAM': true, 'SCRIPT': true, 'STYLE': true, 'TITLE': true };\n\t\n\t            // This list determines which css default values lookup tables are precomputed at load time\n\t            // Lookup tables for other tag names will be automatically built at runtime if needed\n\t            var tagNames = ['A', 'ABBR', 'ADDRESS', 'AREA', 'ARTICLE', 'ASIDE', 'AUDIO', 'B', 'BASE', 'BDI', 'BDO', 'BLOCKQUOTE', 'BODY', 'BR', 'BUTTON', 'CANVAS', 'CAPTION', 'CENTER', 'CITE', 'CODE', 'COL', 'COLGROUP', 'COMMAND', 'DATALIST', 'DD', 'DEL', 'DETAILS', 'DFN', 'DIV', 'DL', 'DT', 'EM', 'EMBED', 'FIELDSET', 'FIGCAPTION', 'FIGURE', 'FONT', 'FOOTER', 'FORM', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6', 'HEAD', 'HEADER', 'HGROUP', 'HR', 'HTML', 'I', 'IFRAME', 'IMG', 'INPUT', 'INS', 'KBD', 'LABEL', 'LEGEND', 'LI', 'LINK', 'MAP', 'MARK', 'MATH', 'MENU', 'META', 'METER', 'NAV', 'NOBR', 'NOSCRIPT', 'OBJECT', 'OL', 'OPTION', 'OPTGROUP', 'OUTPUT', 'P', 'PARAM', 'PRE', 'PROGRESS', 'Q', 'RP', 'RT', 'RUBY', 'S', 'SAMP', 'SCRIPT', 'SECTION', 'SELECT', 'SMALL', 'SOURCE', 'SPAN', 'STRONG', 'STYLE', 'SUB', 'SUMMARY', 'SUP', 'SVG', 'TABLE', 'TBODY', 'TD', 'TEXTAREA', 'TFOOT', 'TH', 'THEAD', 'TIME', 'TITLE', 'TR', 'TRACK', 'U', 'UL', 'VAR', 'VIDEO', 'WBR'];\n\t\n\t            // Precompute the lookup tables.\n\t            [].forEach.call(tagNames, function (name) {\n\t                if (!noStyleTags[name]) {\n\t                    defaultStylesByTagName[name] = computeDefaultStyleByTagName(name);\n\t                }\n\t            });\n\t\n\t            function computeDefaultStyleByTagName(tagName) {\n\t                var defaultStyle = {},\n\t                    element = document.body.appendChild(document.createElement(tagName)),\n\t                    computedStyle = window.getComputedStyle(element);\n\t\n\t                [].forEach.call(computedStyle, function (style) {\n\t                    defaultStyle[style] = computedStyle[style];\n\t                });\n\t                document.body.removeChild(element);\n\t                return defaultStyle;\n\t            }\n\t\n\t            function getDefaultStyleByTagName(tagName) {\n\t                tagName = tagName.toUpperCase();\n\t                if (!defaultStylesByTagName[tagName]) {\n\t                    defaultStylesByTagName[tagName] = computeDefaultStyleByTagName(tagName);\n\t                }\n\t                return defaultStylesByTagName[tagName];\n\t            };\n\t\n\t            function serializeWithStyles(elem) {\n\t\n\t                var cssTexts = [],\n\t                    elements = void 0,\n\t                    computedStyle = void 0,\n\t                    defaultStyle = void 0,\n\t                    result = void 0;\n\t\n\t                if (!elem || elem.nodeType !== Node.ELEMENT_NODE) {\n\t                    // 'Error: Object passed in to serializeWithSyles not of nodeType Node.ELEMENT_NODE'\n\t\n\t                    return;\n\t                }\n\t\n\t                cssTexts = [];\n\t                elements = elem.querySelectorAll('*');\n\t\n\t                [].forEach.call(elements, function (el, i) {\n\t                    if (!noStyleTags[el.tagName]) {\n\t                        computedStyle = window.getComputedStyle(el);\n\t                        defaultStyle = getDefaultStyleByTagName(el.tagName);\n\t                        cssTexts[i] = el.style.cssText;\n\t                        [].forEach.call(computedStyle, function (cssPropName) {\n\t                            if (computedStyle[cssPropName] !== defaultStyle[cssPropName]) {\n\t                                el.style[cssPropName] = computedStyle[cssPropName];\n\t                            }\n\t                        });\n\t                    }\n\t                });\n\t\n\t                result = elem.outerHTML;\n\t                elements = [].map.call(elements, function (el, i) {\n\t                    el.style.cssText = cssTexts[i];\n\t                    return el;\n\t                });\n\t\n\t                return result;\n\t            };\n\t\n\t            return serializeWithStyles;\n\t        }\n\t    };\n\t}();\n\n/***/ }),\n/* 20 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(module, global) {/*! http://mths.be/base64 v0.1.0 by @mathias | MIT license */\n\t;(function(root) {\n\t\n\t\t// Detect free variables `exports`.\n\t\tvar freeExports = typeof exports == 'object' && exports;\n\t\n\t\t// Detect free variable `module`.\n\t\tvar freeModule = typeof module == 'object' && module &&\n\t\t\tmodule.exports == freeExports && module;\n\t\n\t\t// Detect free variable `global`, from Node.js or Browserified code, and use\n\t\t// it as `root`.\n\t\tvar freeGlobal = typeof global == 'object' && global;\n\t\tif (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {\n\t\t\troot = freeGlobal;\n\t\t}\n\t\n\t\t/*--------------------------------------------------------------------------*/\n\t\n\t\tvar InvalidCharacterError = function(message) {\n\t\t\tthis.message = message;\n\t\t};\n\t\tInvalidCharacterError.prototype = new Error;\n\t\tInvalidCharacterError.prototype.name = 'InvalidCharacterError';\n\t\n\t\tvar error = function(message) {\n\t\t\t// Note: the error messages used throughout this file match those used by\n\t\t\t// the native `atob`/`btoa` implementation in Chromium.\n\t\t\tthrow new InvalidCharacterError(message);\n\t\t};\n\t\n\t\tvar TABLE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n\t\t// http://whatwg.org/html/common-microsyntaxes.html#space-character\n\t\tvar REGEX_SPACE_CHARACTERS = /[\\t\\n\\f\\r ]/g;\n\t\n\t\t// `decode` is designed to be fully compatible with `atob` as described in the\n\t\t// HTML Standard. http://whatwg.org/html/webappapis.html#dom-windowbase64-atob\n\t\t// The optimized base64-decoding algorithm used is based on @atk’s excellent\n\t\t// implementation. https://gist.github.com/atk/1020396\n\t\tvar decode = function(input) {\n\t\t\tinput = String(input)\n\t\t\t\t.replace(REGEX_SPACE_CHARACTERS, '');\n\t\t\tvar length = input.length;\n\t\t\tif (length % 4 == 0) {\n\t\t\t\tinput = input.replace(/==?$/, '');\n\t\t\t\tlength = input.length;\n\t\t\t}\n\t\t\tif (\n\t\t\t\tlength % 4 == 1 ||\n\t\t\t\t// http://whatwg.org/C#alphanumeric-ascii-characters\n\t\t\t\t/[^+a-zA-Z0-9/]/.test(input)\n\t\t\t) {\n\t\t\t\terror(\n\t\t\t\t\t'Invalid character: the string to be decoded is not correctly encoded.'\n\t\t\t\t);\n\t\t\t}\n\t\t\tvar bitCounter = 0;\n\t\t\tvar bitStorage;\n\t\t\tvar buffer;\n\t\t\tvar output = '';\n\t\t\tvar position = -1;\n\t\t\twhile (++position < length) {\n\t\t\t\tbuffer = TABLE.indexOf(input.charAt(position));\n\t\t\t\tbitStorage = bitCounter % 4 ? bitStorage * 64 + buffer : buffer;\n\t\t\t\t// Unless this is the first of a group of 4 characters…\n\t\t\t\tif (bitCounter++ % 4) {\n\t\t\t\t\t// …convert the first 8 bits to a single ASCII character.\n\t\t\t\t\toutput += String.fromCharCode(\n\t\t\t\t\t\t0xFF & bitStorage >> (-2 * bitCounter & 6)\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn output;\n\t\t};\n\t\n\t\t// `encode` is designed to be fully compatible with `btoa` as described in the\n\t\t// HTML Standard: http://whatwg.org/html/webappapis.html#dom-windowbase64-btoa\n\t\tvar encode = function(input) {\n\t\t\tinput = String(input);\n\t\t\tif (/[^\\0-\\xFF]/.test(input)) {\n\t\t\t\t// Note: no need to special-case astral symbols here, as surrogates are\n\t\t\t\t// matched, and the input is supposed to only contain ASCII anyway.\n\t\t\t\terror(\n\t\t\t\t\t'The string to be encoded contains characters outside of the ' +\n\t\t\t\t\t'Latin1 range.'\n\t\t\t\t);\n\t\t\t}\n\t\t\tvar padding = input.length % 3;\n\t\t\tvar output = '';\n\t\t\tvar position = -1;\n\t\t\tvar a;\n\t\t\tvar b;\n\t\t\tvar c;\n\t\t\tvar d;\n\t\t\tvar buffer;\n\t\t\t// Make sure any padding is handled outside of the loop.\n\t\t\tvar length = input.length - padding;\n\t\n\t\t\twhile (++position < length) {\n\t\t\t\t// Read three bytes, i.e. 24 bits.\n\t\t\t\ta = input.charCodeAt(position) << 16;\n\t\t\t\tb = input.charCodeAt(++position) << 8;\n\t\t\t\tc = input.charCodeAt(++position);\n\t\t\t\tbuffer = a + b + c;\n\t\t\t\t// Turn the 24 bits into four chunks of 6 bits each, and append the\n\t\t\t\t// matching character for each of them to the output.\n\t\t\t\toutput += (\n\t\t\t\t\tTABLE.charAt(buffer >> 18 & 0x3F) +\n\t\t\t\t\tTABLE.charAt(buffer >> 12 & 0x3F) +\n\t\t\t\t\tTABLE.charAt(buffer >> 6 & 0x3F) +\n\t\t\t\t\tTABLE.charAt(buffer & 0x3F)\n\t\t\t\t);\n\t\t\t}\n\t\n\t\t\tif (padding == 2) {\n\t\t\t\ta = input.charCodeAt(position) << 8;\n\t\t\t\tb = input.charCodeAt(++position);\n\t\t\t\tbuffer = a + b;\n\t\t\t\toutput += (\n\t\t\t\t\tTABLE.charAt(buffer >> 10) +\n\t\t\t\t\tTABLE.charAt((buffer >> 4) & 0x3F) +\n\t\t\t\t\tTABLE.charAt((buffer << 2) & 0x3F) +\n\t\t\t\t\t'='\n\t\t\t\t);\n\t\t\t} else if (padding == 1) {\n\t\t\t\tbuffer = input.charCodeAt(position);\n\t\t\t\toutput += (\n\t\t\t\t\tTABLE.charAt(buffer >> 2) +\n\t\t\t\t\tTABLE.charAt((buffer << 4) & 0x3F) +\n\t\t\t\t\t'=='\n\t\t\t\t);\n\t\t\t}\n\t\n\t\t\treturn output;\n\t\t};\n\t\n\t\tvar base64 = {\n\t\t\t'encode': encode,\n\t\t\t'decode': decode,\n\t\t\t'version': '0.1.0'\n\t\t};\n\t\n\t\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t\t// like the following:\n\t\tif (\n\t\t\ttrue\n\t\t) {\n\t\t\t!(__WEBPACK_AMD_DEFINE_RESULT__ = function() {\n\t\t\t\treturn base64;\n\t\t\t}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t\t}\telse if (freeExports && !freeExports.nodeType) {\n\t\t\tif (freeModule) { // in Node.js or RingoJS v0.8.0+\n\t\t\t\tfreeModule.exports = base64;\n\t\t\t} else { // in Narwhal or RingoJS v0.7.0-\n\t\t\t\tfor (var key in base64) {\n\t\t\t\t\tbase64.hasOwnProperty(key) && (freeExports[key] = base64[key]);\n\t\t\t\t}\n\t\t\t}\n\t\t} else { // in Rhino or a web browser\n\t\t\troot.base64 = base64;\n\t\t}\n\t\n\t}(this));\n\t\n\t/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(21)(module), (function() { return this; }())))\n\n/***/ }),\n/* 21 */\n/***/ (function(module, exports) {\n\n\tmodule.exports = function(module) {\r\n\t\tif(!module.webpackPolyfill) {\r\n\t\t\tmodule.deprecate = function() {};\r\n\t\t\tmodule.paths = [];\r\n\t\t\t// module.parent = undefined by default\r\n\t\t\tmodule.children = [];\r\n\t\t\tmodule.webpackPolyfill = 1;\r\n\t\t}\r\n\t\treturn module;\r\n\t}\r\n\n\n/***/ }),\n/* 22 */,\n/* 23 */,\n/* 24 */,\n/* 25 */,\n/* 26 */,\n/* 27 */,\n/* 28 */\n/***/ (function(module, exports) {\n\n\t/**\n\t * lodash (Custom Build) <https://lodash.com/>\n\t * Build: `lodash modularize exports=\"npm\" -o ./`\n\t * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n\t * Released under MIT license <https://lodash.com/license>\n\t * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n\t * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n\t */\n\t\n\t/** Used as references for various `Number` constants. */\n\tvar MAX_SAFE_INTEGER = 9007199254740991;\n\t\n\t/** `Object#toString` result references. */\n\tvar argsTag = '[object Arguments]',\n\t    funcTag = '[object Function]',\n\t    genTag = '[object GeneratorFunction]';\n\t\n\t/** Used to detect unsigned integer values. */\n\tvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\t\n\t/**\n\t * A faster alternative to `Function#apply`, this function invokes `func`\n\t * with the `this` binding of `thisArg` and the arguments of `args`.\n\t *\n\t * @private\n\t * @param {Function} func The function to invoke.\n\t * @param {*} thisArg The `this` binding of `func`.\n\t * @param {Array} args The arguments to invoke `func` with.\n\t * @returns {*} Returns the result of `func`.\n\t */\n\tfunction apply(func, thisArg, args) {\n\t  switch (args.length) {\n\t    case 0: return func.call(thisArg);\n\t    case 1: return func.call(thisArg, args[0]);\n\t    case 2: return func.call(thisArg, args[0], args[1]);\n\t    case 3: return func.call(thisArg, args[0], args[1], args[2]);\n\t  }\n\t  return func.apply(thisArg, args);\n\t}\n\t\n\t/**\n\t * The base implementation of `_.times` without support for iteratee shorthands\n\t * or max array length checks.\n\t *\n\t * @private\n\t * @param {number} n The number of times to invoke `iteratee`.\n\t * @param {Function} iteratee The function invoked per iteration.\n\t * @returns {Array} Returns the array of results.\n\t */\n\tfunction baseTimes(n, iteratee) {\n\t  var index = -1,\n\t      result = Array(n);\n\t\n\t  while (++index < n) {\n\t    result[index] = iteratee(index);\n\t  }\n\t  return result;\n\t}\n\t\n\t/**\n\t * Creates a unary function that invokes `func` with its argument transformed.\n\t *\n\t * @private\n\t * @param {Function} func The function to wrap.\n\t * @param {Function} transform The argument transform.\n\t * @returns {Function} Returns the new function.\n\t */\n\tfunction overArg(func, transform) {\n\t  return function(arg) {\n\t    return func(transform(arg));\n\t  };\n\t}\n\t\n\t/** Used for built-in method references. */\n\tvar objectProto = Object.prototype;\n\t\n\t/** Used to check objects for own properties. */\n\tvar hasOwnProperty = objectProto.hasOwnProperty;\n\t\n\t/**\n\t * Used to resolve the\n\t * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n\t * of values.\n\t */\n\tvar objectToString = objectProto.toString;\n\t\n\t/** Built-in value references. */\n\tvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\t\n\t/* Built-in method references for those with the same name as other `lodash` methods. */\n\tvar nativeKeys = overArg(Object.keys, Object),\n\t    nativeMax = Math.max;\n\t\n\t/** Detect if properties shadowing those on `Object.prototype` are non-enumerable. */\n\tvar nonEnumShadows = !propertyIsEnumerable.call({ 'valueOf': 1 }, 'valueOf');\n\t\n\t/**\n\t * Creates an array of the enumerable property names of the array-like `value`.\n\t *\n\t * @private\n\t * @param {*} value The value to query.\n\t * @param {boolean} inherited Specify returning inherited property names.\n\t * @returns {Array} Returns the array of property names.\n\t */\n\tfunction arrayLikeKeys(value, inherited) {\n\t  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n\t  // Safari 9 makes `arguments.length` enumerable in strict mode.\n\t  var result = (isArray(value) || isArguments(value))\n\t    ? baseTimes(value.length, String)\n\t    : [];\n\t\n\t  var length = result.length,\n\t      skipIndexes = !!length;\n\t\n\t  for (var key in value) {\n\t    if ((inherited || hasOwnProperty.call(value, key)) &&\n\t        !(skipIndexes && (key == 'length' || isIndex(key, length)))) {\n\t      result.push(key);\n\t    }\n\t  }\n\t  return result;\n\t}\n\t\n\t/**\n\t * Assigns `value` to `key` of `object` if the existing value is not equivalent\n\t * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n\t * for equality comparisons.\n\t *\n\t * @private\n\t * @param {Object} object The object to modify.\n\t * @param {string} key The key of the property to assign.\n\t * @param {*} value The value to assign.\n\t */\n\tfunction assignValue(object, key, value) {\n\t  var objValue = object[key];\n\t  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n\t      (value === undefined && !(key in object))) {\n\t    object[key] = value;\n\t  }\n\t}\n\t\n\t/**\n\t * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n\t *\n\t * @private\n\t * @param {Object} object The object to query.\n\t * @returns {Array} Returns the array of property names.\n\t */\n\tfunction baseKeys(object) {\n\t  if (!isPrototype(object)) {\n\t    return nativeKeys(object);\n\t  }\n\t  var result = [];\n\t  for (var key in Object(object)) {\n\t    if (hasOwnProperty.call(object, key) && key != 'constructor') {\n\t      result.push(key);\n\t    }\n\t  }\n\t  return result;\n\t}\n\t\n\t/**\n\t * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n\t *\n\t * @private\n\t * @param {Function} func The function to apply a rest parameter to.\n\t * @param {number} [start=func.length-1] The start position of the rest parameter.\n\t * @returns {Function} Returns the new function.\n\t */\n\tfunction baseRest(func, start) {\n\t  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n\t  return function() {\n\t    var args = arguments,\n\t        index = -1,\n\t        length = nativeMax(args.length - start, 0),\n\t        array = Array(length);\n\t\n\t    while (++index < length) {\n\t      array[index] = args[start + index];\n\t    }\n\t    index = -1;\n\t    var otherArgs = Array(start + 1);\n\t    while (++index < start) {\n\t      otherArgs[index] = args[index];\n\t    }\n\t    otherArgs[start] = array;\n\t    return apply(func, this, otherArgs);\n\t  };\n\t}\n\t\n\t/**\n\t * Copies properties of `source` to `object`.\n\t *\n\t * @private\n\t * @param {Object} source The object to copy properties from.\n\t * @param {Array} props The property identifiers to copy.\n\t * @param {Object} [object={}] The object to copy properties to.\n\t * @param {Function} [customizer] The function to customize copied values.\n\t * @returns {Object} Returns `object`.\n\t */\n\tfunction copyObject(source, props, object, customizer) {\n\t  object || (object = {});\n\t\n\t  var index = -1,\n\t      length = props.length;\n\t\n\t  while (++index < length) {\n\t    var key = props[index];\n\t\n\t    var newValue = customizer\n\t      ? customizer(object[key], source[key], key, object, source)\n\t      : undefined;\n\t\n\t    assignValue(object, key, newValue === undefined ? source[key] : newValue);\n\t  }\n\t  return object;\n\t}\n\t\n\t/**\n\t * Creates a function like `_.assign`.\n\t *\n\t * @private\n\t * @param {Function} assigner The function to assign values.\n\t * @returns {Function} Returns the new assigner function.\n\t */\n\tfunction createAssigner(assigner) {\n\t  return baseRest(function(object, sources) {\n\t    var index = -1,\n\t        length = sources.length,\n\t        customizer = length > 1 ? sources[length - 1] : undefined,\n\t        guard = length > 2 ? sources[2] : undefined;\n\t\n\t    customizer = (assigner.length > 3 && typeof customizer == 'function')\n\t      ? (length--, customizer)\n\t      : undefined;\n\t\n\t    if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n\t      customizer = length < 3 ? undefined : customizer;\n\t      length = 1;\n\t    }\n\t    object = Object(object);\n\t    while (++index < length) {\n\t      var source = sources[index];\n\t      if (source) {\n\t        assigner(object, source, index, customizer);\n\t      }\n\t    }\n\t    return object;\n\t  });\n\t}\n\t\n\t/**\n\t * Checks if `value` is a valid array-like index.\n\t *\n\t * @private\n\t * @param {*} value The value to check.\n\t * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n\t * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n\t */\n\tfunction isIndex(value, length) {\n\t  length = length == null ? MAX_SAFE_INTEGER : length;\n\t  return !!length &&\n\t    (typeof value == 'number' || reIsUint.test(value)) &&\n\t    (value > -1 && value % 1 == 0 && value < length);\n\t}\n\t\n\t/**\n\t * Checks if the given arguments are from an iteratee call.\n\t *\n\t * @private\n\t * @param {*} value The potential iteratee value argument.\n\t * @param {*} index The potential iteratee index or key argument.\n\t * @param {*} object The potential iteratee object argument.\n\t * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n\t *  else `false`.\n\t */\n\tfunction isIterateeCall(value, index, object) {\n\t  if (!isObject(object)) {\n\t    return false;\n\t  }\n\t  var type = typeof index;\n\t  if (type == 'number'\n\t        ? (isArrayLike(object) && isIndex(index, object.length))\n\t        : (type == 'string' && index in object)\n\t      ) {\n\t    return eq(object[index], value);\n\t  }\n\t  return false;\n\t}\n\t\n\t/**\n\t * Checks if `value` is likely a prototype object.\n\t *\n\t * @private\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n\t */\n\tfunction isPrototype(value) {\n\t  var Ctor = value && value.constructor,\n\t      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\t\n\t  return value === proto;\n\t}\n\t\n\t/**\n\t * Performs a\n\t * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n\t * comparison between two values to determine if they are equivalent.\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 4.0.0\n\t * @category Lang\n\t * @param {*} value The value to compare.\n\t * @param {*} other The other value to compare.\n\t * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n\t * @example\n\t *\n\t * var object = { 'a': 1 };\n\t * var other = { 'a': 1 };\n\t *\n\t * _.eq(object, object);\n\t * // => true\n\t *\n\t * _.eq(object, other);\n\t * // => false\n\t *\n\t * _.eq('a', 'a');\n\t * // => true\n\t *\n\t * _.eq('a', Object('a'));\n\t * // => false\n\t *\n\t * _.eq(NaN, NaN);\n\t * // => true\n\t */\n\tfunction eq(value, other) {\n\t  return value === other || (value !== value && other !== other);\n\t}\n\t\n\t/**\n\t * Checks if `value` is likely an `arguments` object.\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 0.1.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n\t *  else `false`.\n\t * @example\n\t *\n\t * _.isArguments(function() { return arguments; }());\n\t * // => true\n\t *\n\t * _.isArguments([1, 2, 3]);\n\t * // => false\n\t */\n\tfunction isArguments(value) {\n\t  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n\t  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&\n\t    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);\n\t}\n\t\n\t/**\n\t * Checks if `value` is classified as an `Array` object.\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 0.1.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n\t * @example\n\t *\n\t * _.isArray([1, 2, 3]);\n\t * // => true\n\t *\n\t * _.isArray(document.body.children);\n\t * // => false\n\t *\n\t * _.isArray('abc');\n\t * // => false\n\t *\n\t * _.isArray(_.noop);\n\t * // => false\n\t */\n\tvar isArray = Array.isArray;\n\t\n\t/**\n\t * Checks if `value` is array-like. A value is considered array-like if it's\n\t * not a function and has a `value.length` that's an integer greater than or\n\t * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 4.0.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n\t * @example\n\t *\n\t * _.isArrayLike([1, 2, 3]);\n\t * // => true\n\t *\n\t * _.isArrayLike(document.body.children);\n\t * // => true\n\t *\n\t * _.isArrayLike('abc');\n\t * // => true\n\t *\n\t * _.isArrayLike(_.noop);\n\t * // => false\n\t */\n\tfunction isArrayLike(value) {\n\t  return value != null && isLength(value.length) && !isFunction(value);\n\t}\n\t\n\t/**\n\t * This method is like `_.isArrayLike` except that it also checks if `value`\n\t * is an object.\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 4.0.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is an array-like object,\n\t *  else `false`.\n\t * @example\n\t *\n\t * _.isArrayLikeObject([1, 2, 3]);\n\t * // => true\n\t *\n\t * _.isArrayLikeObject(document.body.children);\n\t * // => true\n\t *\n\t * _.isArrayLikeObject('abc');\n\t * // => false\n\t *\n\t * _.isArrayLikeObject(_.noop);\n\t * // => false\n\t */\n\tfunction isArrayLikeObject(value) {\n\t  return isObjectLike(value) && isArrayLike(value);\n\t}\n\t\n\t/**\n\t * Checks if `value` is classified as a `Function` object.\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 0.1.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n\t * @example\n\t *\n\t * _.isFunction(_);\n\t * // => true\n\t *\n\t * _.isFunction(/abc/);\n\t * // => false\n\t */\n\tfunction isFunction(value) {\n\t  // The use of `Object#toString` avoids issues with the `typeof` operator\n\t  // in Safari 8-9 which returns 'object' for typed array and other constructors.\n\t  var tag = isObject(value) ? objectToString.call(value) : '';\n\t  return tag == funcTag || tag == genTag;\n\t}\n\t\n\t/**\n\t * Checks if `value` is a valid array-like length.\n\t *\n\t * **Note:** This method is loosely based on\n\t * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 4.0.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n\t * @example\n\t *\n\t * _.isLength(3);\n\t * // => true\n\t *\n\t * _.isLength(Number.MIN_VALUE);\n\t * // => false\n\t *\n\t * _.isLength(Infinity);\n\t * // => false\n\t *\n\t * _.isLength('3');\n\t * // => false\n\t */\n\tfunction isLength(value) {\n\t  return typeof value == 'number' &&\n\t    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n\t}\n\t\n\t/**\n\t * Checks if `value` is the\n\t * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n\t * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 0.1.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n\t * @example\n\t *\n\t * _.isObject({});\n\t * // => true\n\t *\n\t * _.isObject([1, 2, 3]);\n\t * // => true\n\t *\n\t * _.isObject(_.noop);\n\t * // => true\n\t *\n\t * _.isObject(null);\n\t * // => false\n\t */\n\tfunction isObject(value) {\n\t  var type = typeof value;\n\t  return !!value && (type == 'object' || type == 'function');\n\t}\n\t\n\t/**\n\t * Checks if `value` is object-like. A value is object-like if it's not `null`\n\t * and has a `typeof` result of \"object\".\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 4.0.0\n\t * @category Lang\n\t * @param {*} value The value to check.\n\t * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n\t * @example\n\t *\n\t * _.isObjectLike({});\n\t * // => true\n\t *\n\t * _.isObjectLike([1, 2, 3]);\n\t * // => true\n\t *\n\t * _.isObjectLike(_.noop);\n\t * // => false\n\t *\n\t * _.isObjectLike(null);\n\t * // => false\n\t */\n\tfunction isObjectLike(value) {\n\t  return !!value && typeof value == 'object';\n\t}\n\t\n\t/**\n\t * Assigns own enumerable string keyed properties of source objects to the\n\t * destination object. Source objects are applied from left to right.\n\t * Subsequent sources overwrite property assignments of previous sources.\n\t *\n\t * **Note:** This method mutates `object` and is loosely based on\n\t * [`Object.assign`](https://mdn.io/Object/assign).\n\t *\n\t * @static\n\t * @memberOf _\n\t * @since 0.10.0\n\t * @category Object\n\t * @param {Object} object The destination object.\n\t * @param {...Object} [sources] The source objects.\n\t * @returns {Object} Returns `object`.\n\t * @see _.assignIn\n\t * @example\n\t *\n\t * function Foo() {\n\t *   this.a = 1;\n\t * }\n\t *\n\t * function Bar() {\n\t *   this.c = 3;\n\t * }\n\t *\n\t * Foo.prototype.b = 2;\n\t * Bar.prototype.d = 4;\n\t *\n\t * _.assign({ 'a': 0 }, new Foo, new Bar);\n\t * // => { 'a': 1, 'c': 3 }\n\t */\n\tvar assign = createAssigner(function(object, source) {\n\t  if (nonEnumShadows || isPrototype(source) || isArrayLike(source)) {\n\t    copyObject(source, keys(source), object);\n\t    return;\n\t  }\n\t  for (var key in source) {\n\t    if (hasOwnProperty.call(source, key)) {\n\t      assignValue(object, key, source[key]);\n\t    }\n\t  }\n\t});\n\t\n\t/**\n\t * Creates an array of the own enumerable property names of `object`.\n\t *\n\t * **Note:** Non-object values are coerced to objects. See the\n\t * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n\t * for more details.\n\t *\n\t * @static\n\t * @since 0.1.0\n\t * @memberOf _\n\t * @category Object\n\t * @param {Object} object The object to query.\n\t * @returns {Array} Returns the array of property names.\n\t * @example\n\t *\n\t * function Foo() {\n\t *   this.a = 1;\n\t *   this.b = 2;\n\t * }\n\t *\n\t * Foo.prototype.c = 3;\n\t *\n\t * _.keys(new Foo);\n\t * // => ['a', 'b'] (iteration order is not guaranteed)\n\t *\n\t * _.keys('hi');\n\t * // => ['0', '1']\n\t */\n\tfunction keys(object) {\n\t  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n\t}\n\t\n\tmodule.exports = assign;\n\n\n/***/ })\n/******/ ])\n});\n;\n\n\n// WEBPACK FOOTER //\n// groupedBar.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 d3Color = require('d3-color');\n    const d3Collection = require('d3-collection');\n    const d3Dispatch = require('d3-dispatch');\n    const d3Ease = require('d3-ease');\n    const d3Interpolate = require('d3-interpolate');\n    const d3Scale = require('d3-scale');\n    const d3Selection = require('d3-selection');\n    const assign = require('lodash.assign');\n    const d3Transition = require('d3-transition');\n\n    const { exportChart } = require('./helpers/exportChart');\n    const colorHelper = require('./helpers/colors');\n    const NUMBER_FORMAT = ',f';\n    const uniq = (arrArg) => arrArg.filter((elem, pos, arr) => arr.indexOf(elem) == pos);\n\n\n    /**\n     * @typdef D3Layout\n     * @type function\n     */\n\n    /**\n     * @typedef GroupedBarChartData\n     * @type {Object}\n     * @property {Object[]} data       All data entries\n     * @property {String} name         Name of the entry\n     * @property {String} group        group of the entry\n     * @property {Number} value        Value of the entry\n     *\n     * @example\n     * {\n     *     'data': [\n     *         {\n     *             \"name\": \"2011-01\",\n     *             \"group\": \"Direct\",\n     *             \"value\": 0\n     *         }\n     *     ]\n     * }\n     */\n\n    /**\n     * Grouped Bar Chart reusable API module that allows us\n     * rendering a multi grouped bar and configurable chart.\n     *\n     * @module Grouped-bar\n     * @tutorial grouped-bar\n     * @requires d3-array, d3-axis, d3-color, d3-collection, d3-dispatch, d3-ease,\n     *  d3-interpolate, d3-scale, d3-selection, lodash assign\n     *\n     * @example\n     * let groupedBar = GroupedBar();\n     *\n     * groupedBar\n     *     .width(containerWidth);\n     *\n     * d3Selection.select('.css-selector')\n     *     .datum(dataset.data)\n     *     .call(groupedBar);\n     *\n     */\n    return function module() {\n\n        let margin = {\n                top: 40,\n                right: 30,\n                bottom: 60,\n                left: 70\n            },\n            width = 960,\n            height = 500,\n\n            xScale,\n            xScale2,\n            xAxis,\n            yScale,\n            yScale2,\n            yAxis,\n\n            aspectRatio = null,\n\n            yTickTextYOffset = -8,\n            yTickTextXOffset = -20,\n\n            yTicks = 5,\n            xTicks = 5,\n            baseLine,\n\n            colorSchema = colorHelper.colorSchemas.britecharts,\n\n            colorScale,\n            categoryColorMap,\n\n            layers,\n\n            ease = d3Ease.easeQuadInOut,\n            isHorizontal = false,\n\n            svg,\n            chartWidth, chartHeight,\n            data,\n            groups,\n\n            transformedData,\n\n            tooltipThreshold = 480,\n\n            xAxisPadding = {\n                top: 0,\n                left: 0,\n                bottom: 0,\n                right: 0\n            },\n            maxBarNumber = 8,\n            barOpacity = 0.24,\n\n            animationDelayStep = 20,\n            animationDelays = d3Array.range(animationDelayStep, maxBarNumber * animationDelayStep, animationDelayStep),\n            animationDuration = 1000,\n\n            grid = null,\n\n            nameLabel = 'name',\n            valueLabel = 'value',\n            groupLabel = 'group',\n            valueLabelFormat = NUMBER_FORMAT,\n\n            // getters\n            getName = ({name}) => name,\n            getValue = ({value}) => value,\n            getGroup = ({group}) => group,\n            isAnimated = false,\n\n            // events\n            dispatcher = d3Dispatch.dispatch('customMouseOver', 'customMouseOut', 'customMouseMove');\n\n        /**\n         * This function creates the graph using the selection and data provided\n         * @param {D3Selection} _selection A d3 selection that represents\n         * the container(s) where the chart(s) will be rendered\n         * @param {GroupedBarChartData} _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(_data);\n\n                prepareData(data);\n                buildScales();\n                buildLayers();\n                buildSVG(this);\n                drawGridLines();\n                buildAxis();\n                drawAxis();\n                drawGroupedBar();\n                addMouseEvents();\n            });\n        }\n\n        /**\n         * Adds events to the container group if the environment is not mobile\n         * Adding: mouseover, mouseout and mousemove\n         */\n        function addMouseEvents() {\n            if (shouldShowTooltip()) {\n                svg\n                    .on('mouseover', function(d) {\n                        handleMouseOver(this, d);\n                    })\n                    .on('mouseout', function(d) {\n                        handleMouseOut(this, d);\n                    })\n                    .on('mousemove',  function(d) {\n                        handleMouseMove(this, d);\n                    });\n            }\n\n            svg.selectAll('.bar')\n                .on('mouseover', function(d) {\n                    handleBarsMouseOver(this, d);\n                })\n                .on('mouseout', function(d) {\n                    handleBarsMouseOut(this, d);\n                });\n        }\n\n        /**\n         * Adjusts the position of the y axis' ticks\n         * @param  {D3Selection} selection Y axis group\n         * @return void\n         */\n        function adjustYTickLabels(selection) {\n            selection.selectAll('.tick text')\n                .attr('transform', `translate(${yTickTextXOffset}, ${yTickTextYOffset})`);\n        }\n\n        /**\n         * Creates the d3 x and y axis, setting orientations\n         * @private\n         */\n        function buildAxis() {\n            if (isHorizontal) {\n                xAxis = d3Axis.axisBottom(xScale)\n                    .ticks(xTicks, valueLabelFormat);\n                yAxis = d3Axis.axisLeft(yScale)\n            } else {\n                xAxis = d3Axis.axisBottom(xScale)\n                yAxis = d3Axis.axisLeft(yScale)\n                    .ticks(yTicks, valueLabelFormat)\n            }\n        }\n\n        /**\n         * Builds containers for the chart, the axis and a wrapper for all of them\n         * NOTE: The order of drawing of this group elements is really important,\n         * as everything else will be drawn on top of them\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').classed('x-axis-group', true)\n                .append('g').classed('x axis', true);\n            container.selectAll('.x-axis-group')\n                .append('g').classed('month-axis', true);\n            container\n                .append('g').classed('y-axis-group axis', true);\n            container\n                .append('g').classed('grid-lines-group', true);\n            container\n                .append('g').classed('chart-group', true);\n            container\n                .append('g').classed('metadata-group', true);\n        }\n\n        /**\n         * Builds the grouped layers layout\n         * @return {D3Layout} Layout for drawing the chart\n         * @private\n         */\n        function buildLayers() {\n            layers = transformedData.map((item) => {\n                let ret = {};\n\n                groups.forEach((key) => {\n                    ret[key] = item[key];\n                });\n\n                return assign({}, item, ret);\n            });\n        }\n\n        /**\n         * Creates the x, y and color scales of the chart\n         * @private\n         */\n        function buildScales() {\n            let yMax = d3Array.max(data.map(getValue));\n\n            if (isHorizontal) {\n                xScale = d3Scale.scaleLinear()\n                    .domain([0, yMax])\n                    .rangeRound([0, chartWidth - 1]);\n                // 1 pix for edge tick\n\n                yScale = d3Scale.scaleBand()\n                    .domain(data.map(getName))\n                    .rangeRound([chartHeight, 0])\n                    .padding(0.1);\n\n                yScale2 = d3Scale.scaleBand()\n                    .domain(data.map(getGroup))\n                    .rangeRound([yScale.bandwidth(), 0])\n                    .padding(0.1);\n            } else {\n                xScale = d3Scale.scaleBand()\n                    .domain(data.map(getName))\n                    .rangeRound([0, chartWidth])\n                    .padding(0.1);\n                xScale2 = d3Scale.scaleBand()\n                    .domain(data.map(getGroup))\n                    .rangeRound([0, xScale.bandwidth()])\n                    .padding(0.1);\n\n                yScale = d3Scale.scaleLinear()\n                    .domain([0, yMax])\n                    .rangeRound([chartHeight, 0])\n                    .nice();\n            }\n\n            colorScale = d3Scale.scaleOrdinal()\n                .range(colorSchema)\n                .domain(data.map(getGroup));\n\n            categoryColorMap = colorScale\n                .domain(data.map(getName)).domain()\n                .reduce((memo, item) => {\n                    data.forEach(function (v) {\n                        if (getName(v) == item) {\n                            memo[v.name] = colorScale(v.group)\n                            memo[v.group] = colorScale(v.group)\n                            memo[v.group + item] = colorScale(v.group)\n                        }\n                    })\n                    return memo;\n                }, {});\n        }\n\n        /**\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 grouped-bar', true);\n\n                buildContainerGroups();\n            }\n\n            svg\n                .attr('width', width)\n                .attr('height', height);\n        }\n\n        /**\n         * Parses dates and values into JS Date objects and numbers\n         * @param  {obj} data Raw data from JSON file\n         * @return {obj}      Parsed data with values and dates\n         */\n        function cleanData(data) {\n            return data.map((d) => {\n                    d.value = +d[valueLabel];\n                    d.group = d[groupLabel];\n                    // for tooltip\n                    d.topicName = getGroup(d);\n                    d.name = d[nameLabel];\n\n                    return d;\n                });\n        }\n\n        /**\n         * Draws the x and y axis on the svg object within their\n         * respective groups\n         * @private\n         */\n        function drawAxis() {\n            if (isHorizontal) {\n                svg.select('.x-axis-group .axis.x')\n                    .attr('transform', `translate( 0, ${chartHeight} )`)\n                    .call(xAxis);\n\n                svg.select('.y-axis-group.axis')\n                    .attr('transform', `translate( ${-xAxisPadding.left}, 0)`)\n                    .call(yAxis);\n            } else {\n                svg.select('.x-axis-group .axis.x')\n                    .attr('transform', `translate( 0, ${chartHeight} )`)\n                    .call(xAxis);\n\n                svg.select('.y-axis-group.axis')\n                    .attr('transform', `translate( ${-xAxisPadding.left}, 0)`)\n                    .call(yAxis)\n                    .call(adjustYTickLabels);\n            }\n        }\n\n        /**\n         * Draws a vertical line to extend x-axis till the edges\n         * @return {void}\n         */\n        function drawHorizontalExtendedLine() {\n            baseLine = svg.select('.grid-lines-group')\n                .selectAll('line.extended-x-line')\n                .data([0])\n                .enter()\n                  .append('line')\n                    .attr('class', 'extended-x-line')\n                    .attr('x1', (xAxisPadding.left))\n                    .attr('x2', chartWidth)\n                    .attr('y1', chartHeight)\n                    .attr('y2', chartHeight);\n        }\n\n        /**\n         * Draws a vertical line to extend y-axis till the edges\n         * @return {void}\n         */\n        function drawVerticalExtendedLine() {\n            baseLine = svg.select('.grid-lines-group')\n                .selectAll('line.extended-y-line')\n                .data([0])\n                .enter()\n                  .append('line')\n                    .attr('class', 'extended-y-line')\n                    .attr('y1', (xAxisPadding.bottom))\n                    .attr('y2', chartHeight)\n                    .attr('x1', 0)\n                    .attr('x2', 0);\n        }\n\n        /**\n         * Draws grid lines on the background of the chart\n         * @return void\n         */\n        function drawGridLines() {\n            let scale = isHorizontal ? xScale : yScale;\n\n            if (grid === 'horizontal' || grid === 'full') {\n                svg.select('.grid-lines-group')\n                    .selectAll('line.horizontal-grid-line')\n                    .data(scale.ticks(yTicks).slice(1))\n                    .enter()\n                      .append('line')\n                        .attr('class', 'horizontal-grid-line')\n                        .attr('x1', (-xAxisPadding.left + 1))\n                        .attr('x2', chartWidth)\n                        .attr('y1', (d) => yScale(d))\n                        .attr('y2', (d) => yScale(d));\n            }\n\n            if (grid === 'vertical' || grid === 'full') {\n                svg.select('.grid-lines-group')\n                    .selectAll('line.vertical-grid-line')\n                    .data(scale.ticks(xTicks).slice(1))\n                    .enter()\n                      .append('line')\n                        .attr('class', 'vertical-grid-line')\n                        .attr('y1', 0)\n                        .attr('y2', chartHeight)\n                        .attr('x1', (d) => xScale(d))\n                        .attr('x2', (d) => xScale(d));\n            }\n\n            if (isHorizontal) {\n                drawVerticalExtendedLine();\n            } else {\n                drawHorizontalExtendedLine();\n            }\n        }\n\n        /**\n         * Draws the bars along the x axis\n         * @param  {D3Selection} bars Selection of bars\n         * @return {void}\n         */\n        function drawHorizontalBars(series) {\n            // Enter + Update\n            let bars = series\n                .data(layers)\n                .enter()\n                  .append('g')\n                    .attr('transform', function ({key}) { return `translate(0,${yScale(key)})`; })\n                    .classed('layer', true)\n                    .selectAll('.bar')\n                    .data(({values}) => values)\n                    .enter()\n                      .append('rect')\n                        .classed('bar', true)\n                        .attr('x', 1)\n                        .attr('y', (d) => yScale2(getGroup(d)))\n                        .attr('height', yScale2.bandwidth())\n                        .attr('fill', ((data) => categoryColorMap[data.group]));\n\n            if (isAnimated) {\n                bars.style('opacity', barOpacity)\n                    .transition()\n                    .delay((_, i) => animationDelays[i])\n                    .duration(animationDuration)\n                    .ease(ease)\n                    .tween('attr.width', horizontalBarsTween);\n            } else {\n                bars.attr('width', (d) => xScale(getValue(d)))\n            }\n        }\n\n        /**\n         * Draws the bars along the y axis\n         * @param  {D3Selection} bars Selection of bars\n         * @return {void}\n         */\n        function drawVerticalBars(series) {\n            // Enter + Update\n            let bars = series\n                .data(layers)\n                .enter()\n                .append('g')\n                  .attr('transform', function (d) { return 'translate(' + xScale(d.key) + ',0)'; })\n                  .classed('layer', true)\n                  .selectAll('.bar')\n                  .data((d) => d.values)\n                  .enter()\n                    .append('rect')\n                      .classed('bar', true)\n                      .attr('x', (d) => xScale2(getGroup(d)))\n                      .attr('y', (d) => yScale(d.value))\n                      .attr('width', xScale2.bandwidth)\n                      .attr('fill', ((data) => categoryColorMap[data.group]));\n\n            if (isAnimated) {\n                bars.style('opacity', barOpacity)\n                    .transition()\n                    .delay((_, i) => animationDelays[i])\n                    .duration(animationDuration)\n                    .ease(ease)\n                    .tween('attr.height', verticalBarsTween);\n            } else {\n                bars.attr('height', (d) => chartHeight - yScale(getValue(d)));\n            }\n        }\n\n        /**\n         * Draws the different areas into the chart-group element\n         * @private\n         */\n        function drawGroupedBar() {\n            let series = svg.select('.chart-group').selectAll('.layer');\n\n            if (isHorizontal) {\n                drawHorizontalBars(series);\n            } else {\n                drawVerticalBars(series);\n            }\n            // Exit\n            series.exit()\n                .transition()\n                .style('opacity', 0)\n                .remove();\n        }\n\n        /**\n         * Extract X position on the chart from a given mouse event\n         * @param  {obj} event D3 mouse event\n         * @return {Number}       Position on the x axis of the mouse\n         * @private\n         */\n        function getMousePosition(event) {\n            return d3Selection.mouse(event);\n        }\n\n        /**\n         * Finds out the data entry that is closer to the given position on pixels\n         * @param  {Number} mouseX X position of the mouse\n         * @return {obj}        Data entry that is closer to that x axis position\n         */\n        function getNearestDataPoint(mouseX) {\n            let adjustedMouseX = mouseX - margin.left,\n                epsilon = xScale2.bandwidth(),\n                nearest = [];\n\n            layers.forEach(function (data) {\n                let found = data.values.find((d2) => Math.abs(adjustedMouseX >= xScale(d2[nameLabel]) + xScale2(d2[groupLabel])) && Math.abs(adjustedMouseX - xScale2(d2[groupLabel]) - xScale(d2[nameLabel]) <= epsilon));\n\n                if (found) {\n                    found.values = data.values;\n                    found.key = found.name;\n                    nearest.push(found);\n                }\n\n            });\n\n            return nearest.length ? nearest[0] : undefined;\n        }\n\n        /**\n        * Finds out the data entry that is closer to the given position on pixels\n        * @param  {Number} mouseX X position of the mouse\n        * @return {obj}        Data entry that is closer to that x axis position\n        */\n        function getNearestDataPoint2(mouseY) {\n            let adjustedMouseY = mouseY - margin.bottom,\n                epsilon = yScale.bandwidth(),\n                nearest = [];\n\n            layers.map(function (data) {\n                let found = data.values.find((d2) => Math.abs(adjustedMouseY >= yScale(d2[nameLabel])) && Math.abs(adjustedMouseY - yScale(d2[nameLabel]) <= epsilon * 2));\n\n                if (found) {\n                    found.values = data.values;\n                    found.key = found.name;\n                    nearest.push(found)\n                }\n            });\n\n            return nearest.length ? nearest[0] : undefined;\n        }\n\n        /**\n         * Handles a mouseover event on top of a bar\n         * @param  {obj} e the fired event\n         * @param  {obj} d data of bar\n         * @return {void}\n         */\n        function handleBarsMouseOver(e, d) {\n            d3Selection.select(e)\n                .attr('fill', () => d3Color.color(categoryColorMap[d.group]).darker());\n        }\n\n        /**\n         * Handles a mouseout event out of a bar\n         * @param  {obj} e the fired event\n         * @param  {obj} d data of bar\n         * @return {void}\n         */\n        function handleBarsMouseOut(e, d) {\n            d3Selection.select(e)\n                .attr('fill', () => categoryColorMap[d.group])\n        }\n\n        /**\n         * MouseMove handler, calculates the nearest dataPoint to the cursor\n         * and updates metadata related to it\n         * @param  {obj} e the fired event\n         * @private\n         */\n        function handleMouseMove(e) {\n            let [mouseX, mouseY] = getMousePosition(e),\n                dataPoint = isHorizontal ? getNearestDataPoint2(mouseY) : getNearestDataPoint(mouseX),\n                x,\n                y;\n\n            if (dataPoint) {\n                // Move verticalMarker to that datapoint\n                if (isHorizontal) {\n                    x = mouseX - margin.left;\n                    y = yScale(dataPoint.key) + yScale.bandwidth() / 2;\n                } else {\n                    x = xScale(dataPoint.key) + xScale2(dataPoint[groupLabel]);\n                    y = mouseY - margin.bottom;\n                }\n                moveTooltipOriginXY(x, y);\n\n                // Emit event with xPosition for tooltip or similar feature\n                dispatcher.call('customMouseMove', e, dataPoint, categoryColorMap, x, y);\n            }\n        }\n\n        /**\n         * MouseOut handler, hides overlay and removes active class on verticalMarkerLine\n         * It also resets the container of the vertical marker\n         * @private\n         */\n        function handleMouseOut(e, d) {\n            svg.select('.metadata-group').attr('transform', 'translate(9999, 0)');\n            dispatcher.call('customMouseOut', e, d, d3Selection.mouse(e));\n        }\n\n        /**\n         * Mouseover handler, shows overlay and adds active class to verticalMarkerLine\n         * @private\n         */\n        function handleMouseOver(e, d) {\n            dispatcher.call('customMouseOver', e, d, d3Selection.mouse(e));\n        }\n\n        /**\n         * Animation tween of horizontal bars\n         * @param  {obj} d data of bar\n         * @return {void}\n         */\n        function horizontalBarsTween(d) {\n            let node = d3Selection.select(this),\n                i = d3Interpolate.interpolateRound(0, xScale(getValue(d))),\n                j = d3Interpolate.interpolateNumber(0, 1);\n\n            return function (t) {\n                node.attr('width', i(t)).style('opacity', j(t));\n            }\n        }\n\n        /**\n         * Helper method to update the x position of the vertical marker\n         * @param  {obj} dataPoint Data entry to extract info\n         * @return void\n         */\n        function moveTooltipOriginXY(originXPosition, originYPosition) {\n            svg.select('.metadata-group')\n                .attr('transform', `translate(${originXPosition},${originYPosition})`);\n        }\n\n        /**\n         * Prepare data for create chart.\n         * @private\n         */\n        function prepareData(data) {\n            groups = uniq(data.map((d) => getGroup(d)));\n            transformedData = d3Collection.nest()\n                .key(getName)\n                .rollup(function (values) {\n                    let ret = {};\n\n                    values.forEach((entry) => {\n                        if (entry && entry[groupLabel]) {\n                            ret[entry[groupLabel]] = getValue(entry);\n                        }\n                    });\n                    //for tooltip\n                    ret.values = values;\n                    return ret;\n                })\n                .entries(data)\n                .map(function (data) {\n                    return assign({}, {\n                        total: d3Array.sum(d3Array.permute(data.value, groups)),\n                        key: data.key\n                    }, data.value);\n                });\n        }\n\n        /**\n         * Determines if we should add the tooltip related logic depending on the\n         * size of the chart and the tooltipThreshold variable value\n         * @return {boolean} Should we build the tooltip?\n         * @private\n         */\n        function shouldShowTooltip() {\n            return width > tooltipThreshold;\n        }\n\n        /**\n         * Animation tween of vertical bars\n         * @param  {obj} d data of bar\n         * @return {void}\n         */\n        function verticalBarsTween(d) {\n            let node = d3Selection.select(this),\n                i = d3Interpolate.interpolateRound(0, chartHeight - yScale(getValue(d))),\n                y = d3Interpolate.interpolateRound(chartHeight, yScale(getValue(d))),\n                j = d3Interpolate.interpolateNumber(0, 1);\n\n            return function (t) {\n                node.attr('y', y(t))\n                    .attr('height', i(t)).style('opacity', j(t));\n            }\n        }\n\n        // API\n\n        /**\n         * Gets or Sets the aspect ratio of the chart\n         * @param  {Number} _x Desired aspect ratio for the graph\n         * @return { (Number | Module) } Current aspect ratio or Area Chart module to chain calls\n         * @public\n         */\n        exports.aspectRatio = function (_x) {\n            if (!arguments.length) {\n                return aspectRatio;\n            }\n            aspectRatio = _x;\n\n            return this;\n        };\n\n        /**\n         * Gets or Sets the colorSchema of the chart\n         * @param  {String[]} _x Desired colorSchema for the graph\n         * @return { colorSchema | module} Current colorSchema or Chart module to chain calls\n         * @public\n         */\n        exports.colorSchema = function (_x) {\n            if (!arguments.length) {\n                return colorSchema;\n            }\n            colorSchema = _x;\n\n            return this;\n        };\n\n        /**\n         * Chart exported to png and a download action is fired\n         * @public\n         */\n        exports.exportChart = function (filename, title) {\n            exportChart.call(exports, svg, filename, title);\n        };\n\n        /**\n         * Gets or Sets the groupLabel of the chart\n         * @param  {String} _x Desired groupLabel for the graph\n         * @return { groupLabel | module} Current groupLabel or Chart module to chain calls\n         * @public\n         */\n        exports.groupLabel = function (_x) {\n            if (!arguments.length) {\n                return groupLabel;\n            }\n            groupLabel = _x;\n\n            return this;\n        };\n\n        /**\n         * Gets or Sets the grid mode.\n         *\n         * @param  {String} _x Desired mode for the grid ('vertical'|'horizontal'|'full')\n         * @return { String | module} Current mode of the grid or Area Chart module to chain calls\n         * @public\n         */\n        exports.grid = function (_x) {\n            if (!arguments.length) {\n                return grid;\n            }\n            grid = _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 { height | module} Current height or Area Chart module to chain calls\n         * @public\n         */\n        exports.height = function (_x) {\n            if (!arguments.length) {\n                return height;\n            }\n            if (aspectRatio) {\n                width = Math.ceil(_x / aspectRatio);\n            }\n            height = _x;\n\n            return this;\n        };\n\n        /**\n         * Gets or Sets the horizontal direction of the chart\n         * @param  {number} _x Desired horizontal direction for the graph\n         * @return { isHorizontal | module} If it is horizontal or Bar Chart module to chain calls\n         * @public\n         */\n        exports.isHorizontal = function (_x) {\n            if (!arguments.length) {\n                return isHorizontal;\n            }\n            isHorizontal = _x;\n\n            return this;\n        };\n\n        /**\n         * Gets or Sets the isAnimated property of the chart, making it to animate when render.\n         * By default this is 'false'\n         *\n         * @param  {Boolean} _x Desired animation flag\n         * @return { isAnimated | module} Current isAnimated flag or Chart module\n         * @public\n         */\n        exports.isAnimated = function (_x) {\n            if (!arguments.length) {\n                return isAnimated;\n            }\n            isAnimated = _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 { margin | module} Current margin or Area 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         * Gets or Sets the nameLabel of the chart\n         * @param  {Number} _x Desired dateLabel for the graph\n         * @return { nameLabel | module} Current nameLabel or Chart module to chain calls\n         * @public\n         */\n        exports.nameLabel = function (_x) {\n            if (!arguments.length) {\n                return nameLabel;\n            }\n            nameLabel = _x;\n\n            return this;\n        };\n\n        /**\n         * Gets or Sets the number of ticks of the y axis on the chart\n         * @param  {Number} _x          Desired vertical ticks\n         * @return {Number | module}    Current yTicks or Chart module to chain calls\n         * @public\n         */\n        exports.yTicks = function (_x) {\n            if (!arguments.length) {\n                return yTicks;\n            }\n            yTicks = _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 minimum width of the graph in order to show the tooltip\n         * NOTE: This could also depend on the aspect ratio\n         *\n         * @param  {Object} _x Margin object to get/set\n         * @return { tooltipThreshold | module} Current tooltipThreshold or Area Chart module to chain calls\n         * @public\n         */\n        exports.tooltipThreshold = function (_x) {\n            if (!arguments.length) {\n                return tooltipThreshold;\n            }\n            tooltipThreshold = _x;\n\n            return this;\n        };\n\n        /**\n         * Gets or Sets the valueLabel of the chart\n         * @param  {Number} _x Desired valueLabel for the graph\n         * @return { valueLabel | module} Current valueLabel or Chart module to chain calls\n         * @public\n         */\n        exports.valueLabel = function (_x) {\n            if (!arguments.length) {\n                return valueLabel;\n            }\n            valueLabel = _x;\n\n            return this;\n        };\n\n        /**\n         * Gets or Sets the valueLabelFormat of the chart\n         * @param  {String[]} _x Desired valueLabelFormat for the graph\n         * @return { valueLabelFormat | module} Current valueLabelFormat or Chart module to chain calls\n         * @public\n         */\n        exports.valueLabelFormat = function (_x) {\n            if (!arguments.length) {\n                return valueLabelFormat;\n            }\n            valueLabelFormat = _x;\n\n            return this;\n        };\n\n        /**\n         * Gets or Sets the width of the chart\n         * @param  {Number} _x Desired width for the graph\n         * @return { width | module} Current width or Area Chart module to chain calls\n         * @public\n         */\n        exports.width = function (_x) {\n            if (!arguments.length) {\n                return width;\n            }\n            if (aspectRatio) {\n                height = Math.ceil(_x * aspectRatio);\n            }\n            width = _x;\n\n            return this;\n        };\n\n        /**\n         * Gets or Sets the number of ticks of the x axis on the chart\n         * @param  {Number} _x Desired xTicks\n         * @return {Number | module} Current xTicks or Chart module to chain calls\n         * @public\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// WEBPACK FOOTER //\n// ./src/charts/grouped-bar.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(require) {\n    'use strict';\n\n    const {colorSchemas} = require('./colors.js');\n    const constants = require('./constants.js');\n    const serializeWithStyles = require('./serializeWithStyles.js');\n\n    let encoder = window.btoa;\n\n    if (!encoder) {\n        encoder = require('base-64').encode;\n    }\n\n    // Base64 doesn't work really well with Unicode strings, so we need to use this function\n    // Ref: https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding\n    const b64EncodeUnicode = (str) => {\n        return encoder(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, function(match, p1) {\n            return String.fromCharCode('0x' + p1);\n        }));\n    };\n\n    const config = {\n        styleClass : 'britechartStyle',\n        defaultFilename: 'britechart.png',\n        chartBackground: 'white',\n        imageSourceBase: 'data:image/svg+xml;base64,',\n        titleFontSize: '15px',\n        titleFontFamily: '\\'Benton Sans\\', sans-serif',\n        titleTopOffset: 30,\n        get styleBackgroundString () {\n            return `<style>svg{background:${this.chartBackground};}</style>`;\n        }\n    };\n\n    /**\n     * Main function to be used as a method by chart instances to export charts to png\n     * @param  {array} svgs         (or an svg element) pass in both chart & legend as array or just chart as svg or in array\n     * @param  {string} filename    [download to be called <filename>.png]\n     * @param  {string} title       Title for the image\n     */\n    function exportChart(d3svg, filename, title) {\n        let img = createImage(convertSvgToHtml.call(this, d3svg, title));\n\n        img.onload = handleImageLoad.bind(\n                img,\n                createCanvas(this.width(), this.height()),\n                filename\n            );\n    }\n\n    /**\n     * adds background styles to raw html\n     * @param {string} html raw html\n     */\n    function addBackground(html) {\n        return html.replace('>',`>${config.styleBackgroundString}`);\n    }\n\n    /**\n     * takes d3 svg el, adds proper svg tags, adds inline styles\n     * from stylesheets, adds white background and returns string\n     * @param  {object} d3svg TYPE d3 svg element\n     * @return {string} string of passed d3\n     */\n    function convertSvgToHtml (d3svg, title) {\n        if (!d3svg) {\n            return;\n        }\n\n        d3svg.attr('version', 1.1)\n            .attr('xmlns', 'http://www.w3.org/2000/svg');\n        let serializer = serializeWithStyles.initializeSerializer();\n        let html = serializer(d3svg.node());\n\n        html = formatHtmlByBrowser(html);\n        html = prependTitle.call(this, html, title, parseInt(d3svg.attr('width'), 10));\n        html = addBackground(html);\n\n        return html;\n    }\n\n    /**\n     * Create Canvas\n     * @param  {number} width\n     * @param  {number} height\n     * @return {object} TYPE canvas element\n     */\n    function createCanvas(width, height) {\n        let canvas = document.createElement('canvas');\n\n        canvas.height = height;\n        canvas.width = width;\n\n        return canvas;\n    }\n\n    /**\n     * Create Image\n     * @param  {string} svgHtml string representation of svg el\n     * @return {object}  TYPE element <img>, src points at svg\n     */\n    function createImage(svgHtml) {\n        let img = new Image();\n\n        img.src = `${config.imageSourceBase}${ b64EncodeUnicode(svgHtml) }`;\n\n        return img;\n    };\n\n    /**\n     * Draws image on canvas\n     * @param  {object} image TYPE:el <img>, to be drawn\n     * @param  {object} canvas TYPE: el <canvas>, to draw on\n     */\n    function drawImageOnCanvas(image, canvas) {\n        canvas.getContext('2d').drawImage(image, 0, 0);\n\n        return canvas;\n    }\n\n    /**\n     * Triggers browser to download image, convert canvas to url,\n     * we need to append the link el to the dom before clicking it for Firefox to register\n     * point <a> at it and trigger click\n     * @param  {object} canvas TYPE: el <canvas>\n     * @param  {string} filename\n     * @param  {string} extensionType\n     */\n    function downloadCanvas(canvas, filename=config.defaultFilename, extensionType='image/png') {\n        let url = canvas.toDataURL(extensionType);\n        let link = document.createElement('a');\n\n        link.href = url;\n        link.download = filename;\n        document.body.appendChild(link);\n        link.click();\n        document.body.removeChild(link);\n    }\n\n    /**\n     * Some browsers need special formatting, we handle that here\n     * @param  {string} html string of svg html\n     * @return {string} string of svg html\n     */\n    function formatHtmlByBrowser(html) {\n        if (navigator.userAgent.search('FireFox') > -1) {\n            return html.replace(/url.*&quot;\\)/, `url(&quot;#${constants.lineGradientId}&quot;);`);\n        }\n\n        return html;\n    }\n\n    /**\n     * Handles on load event fired by img.onload, this=img\n     * @param  {object} canvas TYPE: el <canvas>\n     * @param  {string} filename\n     * @param  {object} e\n     */\n    function handleImageLoad(canvas, filename, e) {\n        e.preventDefault();\n\n        downloadCanvas(drawImageOnCanvas(this, canvas), filename);\n    }\n\n    /**\n     * if passed, append title to the raw html to appear on graph\n     * @param  {string} html     raw html string\n     * @param  {string} title    title of the graph\n     * @param  {number} svgWidth width of graph container\n     * @return {string}         raw html with title prepended\n     */\n    function prependTitle(html, title, svgWidth) {\n        if (!title || !svgWidth) {\n            return html;\n        }\n        let {grey} = colorSchemas;\n        \n        html =  html.replace(/<g/,`<text x=\"${this.margin().left}\" y=\"${config.titleTopOffset}\" font-family=\"${config.titleFontFamily}\" font-size=\"${config.titleFontSize}\" fill=\"${grey[6]}\"> ${title} </text><g `);\n\n        return html;\n    }\n\n    return {\n        exportChart,\n        convertSvgToHtml,\n        createImage,\n        drawImageOnCanvas\n    };\n});\n\n\n\n// WEBPACK FOOTER //\n// ./src/charts/helpers/exportChart.js","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","module.exports = (function() {\n\n    'use strict';\n\n    return {\n\n        /**\n         * returns serializer function, only run it when you know you want to serialize your chart\n         * @return {func} serializer to add styles in line to dom string\n         */\n        initializeSerializer() {\n\n            // Mapping between tag names and css default values lookup tables. This allows to exclude default values in the result.\n            const defaultStylesByTagName = {};\n\n            // Styles inherited from style sheets will not be rendered for elements with these tag names\n            const noStyleTags = {'BASE':true,'HEAD':true,'HTML':true,'META':true,'NOFRAME':true,'NOSCRIPT':true,'PARAM':true,'SCRIPT':true,'STYLE':true,'TITLE':true};\n\n            // This list determines which css default values lookup tables are precomputed at load time\n            // Lookup tables for other tag names will be automatically built at runtime if needed\n            const tagNames = ['A','ABBR','ADDRESS','AREA','ARTICLE','ASIDE','AUDIO','B','BASE','BDI','BDO','BLOCKQUOTE','BODY','BR','BUTTON','CANVAS','CAPTION','CENTER','CITE','CODE','COL','COLGROUP','COMMAND','DATALIST','DD','DEL','DETAILS','DFN','DIV','DL','DT','EM','EMBED','FIELDSET','FIGCAPTION','FIGURE','FONT','FOOTER','FORM','H1','H2','H3','H4','H5','H6','HEAD','HEADER','HGROUP','HR','HTML','I','IFRAME','IMG','INPUT','INS','KBD','LABEL','LEGEND','LI','LINK','MAP','MARK','MATH','MENU','META','METER','NAV','NOBR','NOSCRIPT','OBJECT','OL','OPTION','OPTGROUP','OUTPUT','P','PARAM','PRE','PROGRESS','Q','RP','RT','RUBY','S','SAMP','SCRIPT','SECTION','SELECT','SMALL','SOURCE','SPAN','STRONG','STYLE','SUB','SUMMARY','SUP','SVG','TABLE','TBODY','TD','TEXTAREA','TFOOT','TH','THEAD','TIME','TITLE','TR','TRACK','U','UL','VAR','VIDEO','WBR'];\n\n            // Precompute the lookup tables.\n            [].forEach.call(tagNames, (name) => {\n                if (!noStyleTags[name]) {\n                    defaultStylesByTagName[name] = computeDefaultStyleByTagName(name);\n                }\n            });\n\n            function computeDefaultStyleByTagName(tagName) {\n                let defaultStyle = {},\n                    element = document.body.appendChild(document.createElement(tagName)),\n                    computedStyle = window.getComputedStyle(element);\n\n                [].forEach.call(computedStyle, (style) => {\n                    defaultStyle[style] = computedStyle[style];\n                });\n                document.body.removeChild(element);\n                return defaultStyle;\n            }\n\n            function getDefaultStyleByTagName (tagName) {\n                tagName = tagName.toUpperCase();\n                if (!defaultStylesByTagName[tagName]) {\n                    defaultStylesByTagName[tagName] = computeDefaultStyleByTagName(tagName);\n                }\n                return defaultStylesByTagName[tagName];\n            };\n\n            function serializeWithStyles(elem) {\n\n                let cssTexts = [],\n                    elements,\n                    computedStyle,\n                    defaultStyle,\n                    result;\n\n                if (!elem || elem.nodeType !== Node.ELEMENT_NODE) {\n                    // 'Error: Object passed in to serializeWithSyles not of nodeType Node.ELEMENT_NODE'\n                    \n                    return;\n                }\n\n                cssTexts = [];\n                elements = elem.querySelectorAll('*');\n\n                [].forEach.call(elements, (el, i) => {\n                    if (!noStyleTags[el.tagName]) {\n                        computedStyle = window.getComputedStyle(el);\n                        defaultStyle = getDefaultStyleByTagName(el.tagName);\n                        cssTexts[i] = el.style.cssText;\n                        [].forEach.call(computedStyle, (cssPropName) => {\n                            if (computedStyle[cssPropName] !== defaultStyle[cssPropName]) {\n                                el.style[cssPropName] = computedStyle[cssPropName];\n                            }\n                        });\n                    }\n                });\n\n                result = elem.outerHTML;\n                elements = [].map.call(elements, (el, i) => {\n                    el.style.cssText = cssTexts[i];\n                    return el;\n                });\n\n                return result;\n\n            };\n\n            return serializeWithStyles;\n        }\n    }\n})();\n\n\n// WEBPACK FOOTER //\n// ./src/charts/helpers/serializeWithStyles.js","/*! http://mths.be/base64 v0.1.0 by @mathias | MIT license */\n;(function(root) {\n\n\t// Detect free variables `exports`.\n\tvar freeExports = typeof exports == 'object' && exports;\n\n\t// Detect free variable `module`.\n\tvar freeModule = typeof module == 'object' && module &&\n\t\tmodule.exports == freeExports && module;\n\n\t// Detect free variable `global`, from Node.js or Browserified code, and use\n\t// it as `root`.\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {\n\t\troot = freeGlobal;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar InvalidCharacterError = function(message) {\n\t\tthis.message = message;\n\t};\n\tInvalidCharacterError.prototype = new Error;\n\tInvalidCharacterError.prototype.name = 'InvalidCharacterError';\n\n\tvar error = function(message) {\n\t\t// Note: the error messages used throughout this file match those used by\n\t\t// the native `atob`/`btoa` implementation in Chromium.\n\t\tthrow new InvalidCharacterError(message);\n\t};\n\n\tvar TABLE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n\t// http://whatwg.org/html/common-microsyntaxes.html#space-character\n\tvar REGEX_SPACE_CHARACTERS = /[\\t\\n\\f\\r ]/g;\n\n\t// `decode` is designed to be fully compatible with `atob` as described in the\n\t// HTML Standard. http://whatwg.org/html/webappapis.html#dom-windowbase64-atob\n\t// The optimized base64-decoding algorithm used is based on @atk’s excellent\n\t// implementation. https://gist.github.com/atk/1020396\n\tvar decode = function(input) {\n\t\tinput = String(input)\n\t\t\t.replace(REGEX_SPACE_CHARACTERS, '');\n\t\tvar length = input.length;\n\t\tif (length % 4 == 0) {\n\t\t\tinput = input.replace(/==?$/, '');\n\t\t\tlength = input.length;\n\t\t}\n\t\tif (\n\t\t\tlength % 4 == 1 ||\n\t\t\t// http://whatwg.org/C#alphanumeric-ascii-characters\n\t\t\t/[^+a-zA-Z0-9/]/.test(input)\n\t\t) {\n\t\t\terror(\n\t\t\t\t'Invalid character: the string to be decoded is not correctly encoded.'\n\t\t\t);\n\t\t}\n\t\tvar bitCounter = 0;\n\t\tvar bitStorage;\n\t\tvar buffer;\n\t\tvar output = '';\n\t\tvar position = -1;\n\t\twhile (++position < length) {\n\t\t\tbuffer = TABLE.indexOf(input.charAt(position));\n\t\t\tbitStorage = bitCounter % 4 ? bitStorage * 64 + buffer : buffer;\n\t\t\t// Unless this is the first of a group of 4 characters…\n\t\t\tif (bitCounter++ % 4) {\n\t\t\t\t// …convert the first 8 bits to a single ASCII character.\n\t\t\t\toutput += String.fromCharCode(\n\t\t\t\t\t0xFF & bitStorage >> (-2 * bitCounter & 6)\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t};\n\n\t// `encode` is designed to be fully compatible with `btoa` as described in the\n\t// HTML Standard: http://whatwg.org/html/webappapis.html#dom-windowbase64-btoa\n\tvar encode = function(input) {\n\t\tinput = String(input);\n\t\tif (/[^\\0-\\xFF]/.test(input)) {\n\t\t\t// Note: no need to special-case astral symbols here, as surrogates are\n\t\t\t// matched, and the input is supposed to only contain ASCII anyway.\n\t\t\terror(\n\t\t\t\t'The string to be encoded contains characters outside of the ' +\n\t\t\t\t'Latin1 range.'\n\t\t\t);\n\t\t}\n\t\tvar padding = input.length % 3;\n\t\tvar output = '';\n\t\tvar position = -1;\n\t\tvar a;\n\t\tvar b;\n\t\tvar c;\n\t\tvar d;\n\t\tvar buffer;\n\t\t// Make sure any padding is handled outside of the loop.\n\t\tvar length = input.length - padding;\n\n\t\twhile (++position < length) {\n\t\t\t// Read three bytes, i.e. 24 bits.\n\t\t\ta = input.charCodeAt(position) << 16;\n\t\t\tb = input.charCodeAt(++position) << 8;\n\t\t\tc = input.charCodeAt(++position);\n\t\t\tbuffer = a + b + c;\n\t\t\t// Turn the 24 bits into four chunks of 6 bits each, and append the\n\t\t\t// matching character for each of them to the output.\n\t\t\toutput += (\n\t\t\t\tTABLE.charAt(buffer >> 18 & 0x3F) +\n\t\t\t\tTABLE.charAt(buffer >> 12 & 0x3F) +\n\t\t\t\tTABLE.charAt(buffer >> 6 & 0x3F) +\n\t\t\t\tTABLE.charAt(buffer & 0x3F)\n\t\t\t);\n\t\t}\n\n\t\tif (padding == 2) {\n\t\t\ta = input.charCodeAt(position) << 8;\n\t\t\tb = input.charCodeAt(++position);\n\t\t\tbuffer = a + b;\n\t\t\toutput += (\n\t\t\t\tTABLE.charAt(buffer >> 10) +\n\t\t\t\tTABLE.charAt((buffer >> 4) & 0x3F) +\n\t\t\t\tTABLE.charAt((buffer << 2) & 0x3F) +\n\t\t\t\t'='\n\t\t\t);\n\t\t} else if (padding == 1) {\n\t\t\tbuffer = input.charCodeAt(position);\n\t\t\toutput += (\n\t\t\t\tTABLE.charAt(buffer >> 2) +\n\t\t\t\tTABLE.charAt((buffer << 4) & 0x3F) +\n\t\t\t\t'=='\n\t\t\t);\n\t\t}\n\n\t\treturn output;\n\t};\n\n\tvar base64 = {\n\t\t'encode': encode,\n\t\t'decode': decode,\n\t\t'version': '0.1.0'\n\t};\n\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine(function() {\n\t\t\treturn base64;\n\t\t});\n\t}\telse if (freeExports && !freeExports.nodeType) {\n\t\tif (freeModule) { // in Node.js or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = base64;\n\t\t} else { // in Narwhal or RingoJS v0.7.0-\n\t\t\tfor (var key in base64) {\n\t\t\t\tbase64.hasOwnProperty(key) && (freeExports[key] = base64[key]);\n\t\t\t}\n\t\t}\n\t} else { // in Rhino or a web browser\n\t\troot.base64 = base64;\n\t}\n\n}(this));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/base-64/base64.js\n// module id = 20\n// module chunks = 0 3 4 6 8 9 10 11","module.exports = function(module) {\r\n\tif(!module.webpackPolyfill) {\r\n\t\tmodule.deprecate = function() {};\r\n\t\tmodule.paths = [];\r\n\t\t// module.parent = undefined by default\r\n\t\tmodule.children = [];\r\n\t\tmodule.webpackPolyfill = 1;\r\n\t}\r\n\treturn module;\r\n}\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/module.js\n// module id = 21\n// module chunks = 0 3 4 6 8 9 10 11","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]';\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n  switch (args.length) {\n    case 0: return func.call(thisArg);\n    case 1: return func.call(thisArg, args[0]);\n    case 2: return func.call(thisArg, args[0], args[1]);\n    case 3: return func.call(thisArg, args[0], args[1], args[2]);\n  }\n  return func.apply(thisArg, args);\n}\n\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeKeys = overArg(Object.keys, Object),\n    nativeMax = Math.max;\n\n/** Detect if properties shadowing those on `Object.prototype` are non-enumerable. */\nvar nonEnumShadows = !propertyIsEnumerable.call({ 'valueOf': 1 }, 'valueOf');\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n  // Safari 9 makes `arguments.length` enumerable in strict mode.\n  var result = (isArray(value) || isArguments(value))\n    ? baseTimes(value.length, String)\n    : [];\n\n  var length = result.length,\n      skipIndexes = !!length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) &&\n        !(skipIndexes && (key == 'length' || isIndex(key, length)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n  var objValue = object[key];\n  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n      (value === undefined && !(key in object))) {\n    object[key] = value;\n  }\n}\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n  if (!isPrototype(object)) {\n    return nativeKeys(object);\n  }\n  var result = [];\n  for (var key in Object(object)) {\n    if (hasOwnProperty.call(object, key) && key != 'constructor') {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n  return function() {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        array = Array(length);\n\n    while (++index < length) {\n      array[index] = args[start + index];\n    }\n    index = -1;\n    var otherArgs = Array(start + 1);\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n    otherArgs[start] = array;\n    return apply(func, this, otherArgs);\n  };\n}\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n  object || (object = {});\n\n  var index = -1,\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index];\n\n    var newValue = customizer\n      ? customizer(object[key], source[key], key, object, source)\n      : undefined;\n\n    assignValue(object, key, newValue === undefined ? source[key] : newValue);\n  }\n  return object;\n}\n\n/**\n * Creates a function like `_.assign`.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\nfunction createAssigner(assigner) {\n  return baseRest(function(object, sources) {\n    var index = -1,\n        length = sources.length,\n        customizer = length > 1 ? sources[length - 1] : undefined,\n        guard = length > 2 ? sources[2] : undefined;\n\n    customizer = (assigner.length > 3 && typeof customizer == 'function')\n      ? (length--, customizer)\n      : undefined;\n\n    if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n      customizer = length < 3 ? undefined : customizer;\n      length = 1;\n    }\n    object = Object(object);\n    while (++index < length) {\n      var source = sources[index];\n      if (source) {\n        assigner(object, source, index, customizer);\n      }\n    }\n    return object;\n  });\n}\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return !!length &&\n    (typeof value == 'number' || reIsUint.test(value)) &&\n    (value > -1 && value % 1 == 0 && value < length);\n}\n\n/**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n *  else `false`.\n */\nfunction isIterateeCall(value, index, object) {\n  if (!isObject(object)) {\n    return false;\n  }\n  var type = typeof index;\n  if (type == 'number'\n        ? (isArrayLike(object) && isIndex(index, object.length))\n        : (type == 'string' && index in object)\n      ) {\n    return eq(object[index], value);\n  }\n  return false;\n}\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\n/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nfunction isArguments(value) {\n  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&\n    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);\n}\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(value);\n}\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 8-9 which returns 'object' for typed array and other constructors.\n  var tag = isObject(value) ? objectToString.call(value) : '';\n  return tag == funcTag || tag == genTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Assigns own enumerable string keyed properties of source objects to the\n * destination object. Source objects are applied from left to right.\n * Subsequent sources overwrite property assignments of previous sources.\n *\n * **Note:** This method mutates `object` and is loosely based on\n * [`Object.assign`](https://mdn.io/Object/assign).\n *\n * @static\n * @memberOf _\n * @since 0.10.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @see _.assignIn\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n * }\n *\n * function Bar() {\n *   this.c = 3;\n * }\n *\n * Foo.prototype.b = 2;\n * Bar.prototype.d = 4;\n *\n * _.assign({ 'a': 0 }, new Foo, new Bar);\n * // => { 'a': 1, 'c': 3 }\n */\nvar assign = createAssigner(function(object, source) {\n  if (nonEnumShadows || isPrototype(source) || isArrayLike(source)) {\n    copyObject(source, keys(source), object);\n    return;\n  }\n  for (var key in source) {\n    if (hasOwnProperty.call(source, key)) {\n      assignValue(object, key, source[key]);\n    }\n  }\n});\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\nmodule.exports = assign;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash.assign/index.js\n// module id = 28\n// module chunks = 4 9 10"],"sourceRoot":""}