d3vue/static/js/vendor.03b56a03b17565331709.js.map

{"version":3,"sources":["webpack:///static/js/vendor.03b56a03b17565331709.js","webpack:///./~/vue-loader/lib/component-normalizer.js","webpack:///./~/d3/build/d3.js","webpack:///./~/core-js/library/modules/_wks.js","webpack:///./~/lodash/lodash.js","webpack:///./~/core-js/library/modules/_descriptors.js","webpack:///./~/core-js/library/modules/_global.js","webpack:///./~/core-js/library/modules/_object-dp.js","webpack:///./~/babel-runtime/helpers/classCallCheck.js","webpack:///./~/babel-runtime/helpers/createClass.js","webpack:///./~/core-js/library/modules/_an-object.js","webpack:///./~/core-js/library/modules/_core.js","webpack:///./~/core-js/library/modules/_has.js","webpack:///./~/core-js/library/modules/_hide.js","webpack:///./~/core-js/library/modules/_defined.js","webpack:///./~/core-js/library/modules/_export.js","webpack:///./~/core-js/library/modules/_is-object.js","webpack:///./~/core-js/library/modules/_iterators.js","webpack:///./~/core-js/library/modules/_property-desc.js","webpack:///./~/core-js/library/modules/_shared-key.js","webpack:///./~/core-js/library/modules/_to-integer.js","webpack:///./~/d3-dsv/src/dsv.js","webpack:///./~/vue/dist/vue.common.js","webpack:///./~/core-js/library/modules/_cof.js","webpack:///./~/core-js/library/modules/_ctx.js","webpack:///./~/core-js/library/modules/_dom-create.js","webpack:///./~/core-js/library/modules/_enum-bug-keys.js","webpack:///./~/core-js/library/modules/_fails.js","webpack:///./~/core-js/library/modules/_set-to-string-tag.js","webpack:///./~/core-js/library/modules/_shared.js","webpack:///./~/core-js/library/modules/_to-iobject.js","webpack:///./~/core-js/library/modules/_to-length.js","webpack:///./~/core-js/library/modules/_to-object.js","webpack:///./~/core-js/library/modules/_uid.js","webpack:///(webpack)/buildin/global.js","webpack:///./~/vue-resource/dist/vue-resource.common.js","webpack:///./~/babel-runtime/core-js/array/from.js","webpack:///./~/babel-runtime/core-js/object/define-property.js","webpack:///./~/babel-runtime/helpers/toConsumableArray.js","webpack:///./~/core-js/library/fn/array/from.js","webpack:///./~/core-js/library/fn/object/define-property.js","webpack:///./~/core-js/library/modules/_a-function.js","webpack:///./~/core-js/library/modules/_array-includes.js","webpack:///./~/core-js/library/modules/_classof.js","webpack:///./~/core-js/library/modules/_create-property.js","webpack:///./~/core-js/library/modules/_html.js","webpack:///./~/core-js/library/modules/_ie8-dom-define.js","webpack:///./~/core-js/library/modules/_iobject.js","webpack:///./~/core-js/library/modules/_is-array-iter.js","webpack:///./~/core-js/library/modules/_iter-call.js","webpack:///./~/core-js/library/modules/_iter-create.js","webpack:///./~/core-js/library/modules/_iter-define.js","webpack:///./~/core-js/library/modules/_iter-detect.js","webpack:///./~/core-js/library/modules/_library.js","webpack:///./~/core-js/library/modules/_object-create.js","webpack:///./~/core-js/library/modules/_object-dps.js","webpack:///./~/core-js/library/modules/_object-gpo.js","webpack:///./~/core-js/library/modules/_object-keys-internal.js","webpack:///./~/core-js/library/modules/_object-keys.js","webpack:///./~/core-js/library/modules/_redefine.js","webpack:///./~/core-js/library/modules/_string-at.js","webpack:///./~/core-js/library/modules/_to-index.js","webpack:///./~/core-js/library/modules/_to-primitive.js","webpack:///./~/core-js/library/modules/core.get-iterator-method.js","webpack:///./~/core-js/library/modules/es6.array.from.js","webpack:///./~/core-js/library/modules/es6.object.define-property.js","webpack:///./~/core-js/library/modules/es6.string.iterator.js","webpack:///./~/d3-dsv/src/csv.js","webpack:///./~/d3-dsv/src/tsv.js","webpack:///./~/topojson/dist/topojson.js","webpack:///./~/vue-router/dist/vue-router.common.js","webpack:///./~/vue-style-loader/lib/listToStyles.js","webpack:///(webpack)/buildin/module.js","webpack:///./~/css-loader/lib/css-base.js","webpack:///./~/vue-style-loader/lib/addStylesClient.js"],"names":["webpackJsonp","module","exports","rawScriptExports","compiledTemplate","scopeId","cssModules","esModule","scriptExports","type","default","options","render","staticRenderFns","_scopeId","computed","Object","keys","forEach","key","__webpack_require__","global","factory","this","ascendingComparator","f","d","x","ascending","tickStep","start","stop","count","step0","Math","abs","max","step1","pow","floor","log","LN10","error","e10","e5","e2","length","translateX","scale0","scale1","isFinite","translateY","y","center","scale","offset","bandwidth","round","entering","__axis","axis","orient","context","values","tickValues","ticks","apply","tickArguments","domain","format","tickFormat","identity$1","spacing","tickSizeInner","tickPadding","transform","top","bottom","range","range0","range1","position","copy","selection","path","selectAll","data","tick","order","tickExit","exit","tickEnter","enter","append","attr","line","select","text","k","left","right","merge","insert","transition","epsilon","parentNode","remove","tickSizeOuter","filter","each","_","arguments","slice$1","call","slice","tickSize","axisTop","axisRight","axisBottom","axisLeft","dispatch","t","i","n","Error","Dispatch","parseTypenames","typenames","types","trim","split","map","name","indexOf","hasOwnProperty","get","c","value","set","callback","noop","concat","push","creatorInherit","document","ownerDocument","uri","namespaceURI","xhtml","documentElement","createElement","createElementNS","creatorFixed","fullname","space","local","local$1","Local","nextId","toString","filterContextListener","listener","index","group","contextListener","event","related","relatedTarget","compareDocumentPosition","event1","event0","__data__","parseTypenames$1","onRemove","typename","on","__on","o","j","m","removeEventListener","capture","onAdd","wrap","filterEvents","addEventListener","customEvent","that","args","sourceEvent","none","empty$1","EnterNode","parent","datum","_next","_parent","bindIndex","update","node","groupLength","dataLength","bindKey","keyValue","nodeByKeyValue","keyValues","Array","keyPrefix","ascending$1","a","b","NaN","attrRemove","removeAttribute","attrRemoveNS","removeAttributeNS","attrConstant","setAttribute","attrConstantNS","setAttributeNS","attrFunction","v","attrFunctionNS","styleRemove","style","removeProperty","styleConstant","priority","setProperty","styleFunction","propertyRemove","propertyConstant","propertyFunction","classArray","string","classList","ClassList","_node","_names","getAttribute","classedAdd","names","list","add","classedRemove","classedTrue","classedFalse","classedFunction","textRemove","textContent","textConstant","textFunction","htmlRemove","innerHTML","htmlConstant","htmlFunction","raise","nextSibling","appendChild","lower","previousSibling","insertBefore","firstChild","constantNull","removeChild","dispatchEvent","params","window$$1","window","CustomEvent","createEvent","initEvent","bubbles","cancelable","detail","dispatchConstant","dispatchFunction","Selection","groups","parents","_groups","_parents","root","nopropagation","stopImmediatePropagation","yesdrag","view","noclick","selection$$1","noevent","setTimeout","MozUserSelect","__noselect","DragEvent","target","subject","id","active","dx","dy","identifier","defaultFilter$1","button","defaultContainer","defaultSubject","extend","definition","prototype","create","Color","color","toLowerCase","reHex3","exec","parseInt","Rgb","reHex6","rgbn","reRgbInteger","reRgbPercent","reRgbaInteger","rgba","reRgbaPercent","reHslPercent","hsla","reHslaPercent","named","r","g","rgbConvert","rgb","opacity","h","s","l","Hsl","hslConvert","min","hsl","hsl2rgb","m1","m2","labConvert","Lab","Hcl","deg2rad","cos","sin","rgb2xyz","xyz2lab","Xn","Yn","z","Zn","lab","t3","t2","t0","lab2xyz","t1","xyz2rgb","hclConvert","atan2","rad2deg","sqrt","hcl","cubehelixConvert","Cubehelix","BC_DA","ED","EB","bl","E","C","D","cubehelix","basis","v0","v1","v2","v3","linear","exponential","hue","constant$3","isNaN","gamma","nogamma","rgbSpline","spline","colors","color$$1","zero","one","parseCss","identity$2","cssNode","cssRoot","cssView","defaultView","getComputedStyle","getPropertyValue","decompose","parseSvg","svgNode","baseVal","consolidate","matrix","e","interpolateTransform","parse","pxComma","pxParen","degParen","pop","translate","xa","ya","xb","yb","q","reinterpolate","rotate","skewX","scaleX","scaleY","join","cosh","exp","sinh","tanh","hsl$1","hue$$1","end","lab$1","hcl$1","cubehelix$1","cubehelixGamma","cubehelix$$1","now","clockNow","setFrame","clearNow","clock","clockSkew","Timer","_call","_time","timer","delay","time","restart","timerFlush","frame","taskHead","wake","clockLast","timeout","nap","poke","pokeDelay","Infinity","taskTail","sleep","clearTimeout","interval","clearInterval","setInterval","init","schedule","__transition","state","CREATED","set$1","STARTING","get$1","self","elapsed","SCHEDULED","schedules","STARTED","timeout$1","RUNNING","ENDED","tween","duration","ease","ENDING","tweenRemove","tween0","tween1","splice","tweenFunction","tweenValue","_id","attrRemove$1","attrRemoveNS$1","attrConstant$1","interpolate$$1","value1","value00","interpolate0","value0","attrConstantNS$1","getAttributeNS","attrFunction$1","value10","attrFunctionNS$1","attrTweenNS","_value","attrTween","delayFunction","delayConstant","durationFunction","durationConstant","easeConstant","every","onFunction","on0","on1","sit","removeFunction","styleRemove$1","interpolate$$2","styleRemoveEnd","styleConstant$1","styleFunction$1","styleTween","textConstant$1","textFunction$1","Transition","_name","newId","linear$1","quadIn","quadOut","quadInOut","cubicIn","cubicOut","cubicInOut","sinIn","halfPi","sinOut","sinInOut","pi","expIn","expOut","expInOut","circleIn","circleOut","circleInOut","bounceIn","bounceOut","b1","b0","b3","b2","b4","b6","b5","b7","b8","b9","bounceInOut","inherit","timing","defaultTiming","nopropagation$1","defaultFilter","defaultExtent","svg","ownerSVGElement","width","height","local$$1","__brush","empty","extent","brushSelection","dim","output","brushX","brush$1","X","brushY","Y","brush","overlay","property","initialize","cursors","handle","handles","redraw","started","handleSize","emitter","Emitter","moved","point1","mouse","shifting","lockX","lockY","point","moving","noevent$1","move","point0","mode","MODE_SPACE","MODE_DRAG","signX","W","w0","e0","w1","e1","signY","N","n0","S","s0","n1","s1","MODE_HANDLE","MODE_CENTER","flipX","flipY","emit","ended","touches","touchending","keydowned","keyCode","keyupped","altKey","changedTouches","metaKey","signsX","signsY","shiftKey","beforestart","dragDisable","interrupt","listeners","selection1","selection0","input","interpolateValue","starting","BrushEvent","constant$4","compareValue","compare","source","Path","_x0","_y0","_x1","_y1","defaultSource","defaultTarget","defaultRadius","radius","defaultStartAngle","startAngle","defaultEndAngle","endAngle","Map","map$1","object","isArray","createObject","setObject","createMap","setMap","Set","set$2","objectConverter","columns","Function","JSON","stringify","customConverter","row","inferColumns","rows","columnSet","column","tree","xm","ym","xp","yp","_root","leaf","x0","y0","x1","y1","_x","_y","next","addAll","xz","yz","cover","removeAll","defaultX","defaultY","quadtree","nodes","Quadtree","undefined","leaf_copy","vx","vy","find","nodeById","nodeId","x$1","y$1","FormatSpecifier","specifier","match","re","fill","align","sign","symbol","comma","precision","formatTypes","identity$3","defaultLocale","locale$1","formatLocale","formatPrefix","Adder","reset","add$1","adder","bv","av","acos","pi$3","asin","halfPi$2","haversin","sin$1","noop$1","streamGeometry","geometry","stream","streamGeometryType","streamLine","coordinates","closed","coordinate","lineStart","lineEnd","streamPolygon","polygonStart","polygonEnd","areaRingStart","areaStream","areaPointFirst","areaRingEnd","areaPoint","lambda00","phi00","lambda","phi","radians","lambda0","cosPhi0","cos$1","quarterPi","sinPhi0","dLambda","sdLambda","adLambda","cosPhi","sinPhi","u","areaRingSum","spherical","cartesian","cartesianDot","cartesianCross","cartesianAddInPlace","cartesianScale","vector","cartesianNormalizeInPlace","boundsPoint","ranges","lambda0$1","lambda1","phi0","phi1","linePoint","p","p0","normal","equatorial","inflection","phii","delta","lambda2","sign$$1","lambdai","degrees$1","antimeridian","angle","boundsLineStart","boundsStream","boundsLineEnd","boundsRingPoint","deltaSum","lambda00$1","phi00$1","boundsRingStart","boundsRingEnd","epsilon$2","rangeCompare","rangeContains","centroidPoint","centroidPointCartesian","W0","X0","Y0","Z0","centroidLineStart","centroidStream","centroidLinePointFirst","z0","centroidLinePoint","w","W1","X1","Y1","Z1","centroidLineEnd","centroidRingStart","centroidRingPointFirst","centroidRingEnd","centroidRingPoint","lambda00$2","phi00$2","cx","cy","cz","X2","Y2","Z2","rotationIdentity","tau$3","rotateRadians","deltaLambda","deltaPhi","deltaGamma","compose","rotationLambda","rotationPhiGamma","forwardRotationLambda","rotation","invert","cosDeltaPhi","sinDeltaPhi","cosDeltaGamma","sinDeltaGamma","circleStream","direction","cosRadius","sinRadius","step","circleRadius","Intersection","points","other","entry","link$1","array","clipExtent","visible","interpolate","from","to","a1","corner","comparePoint","compareIntersection","ca","cb","activeStream","polygonInside","winding","polygon","a0","ring","bufferStream","segments","clean","startInside","cleanInside","clipPolygon","clipStream","first","v_","x_","y_","x__","y__","v__","rejoin","result","clipMin","clipMax","clipLine","clipBuffer","lengthLineStart","lengthStream","lengthPointFirst","lengthLineEnd","lambda0$2","sinPhi0$1","cosPhi0$1","lengthPoint","cosDelta","sinDelta","lengthSum","graticuleX","sequence","graticuleY","graticule","lines","ceil","DX","DY","outline","reverse","extentMajor","extentMinor","stepMajor","stepMinor","graticule10","areaRingStart$1","areaStream$1","areaPointFirst$1","areaPoint$1","x00","x0$1","y00","y0$1","areaRingSum$1","areaRingEnd$1","boundsPoint$1","x0$2","y0$2","centroidPoint$1","X0$1","Y0$1","Z0$1","centroidLineStart$1","centroidStream$1","centroidPointFirstLine","centroidPointLine","x0$3","y0$3","X1$1","Y1$1","Z1$1","centroidLineEnd$1","centroidRingStart$1","centroidPointFirstRing","centroidRingEnd$1","centroidPointRing","x00$1","y00$1","X2$1","Y2$1","Z2$1","PathContext","_context","lengthPointFirst$1","lengthStream$1","lengthPoint$1","x00$2","x0$4","y00$2","y0$4","lengthSum$1","PathString","_string","circle$1","validSegment","segment","clipAntimeridianLine","sign0","sign1","clipAntimeridianIntersect","cosPhi1","sinLambda0Lambda1","atan","clipAntimeridianInterpolate","transformer","methods","TransformStream","fitExtent","projection","clip","geoStream","boundsStream$1","fitSize","size","resampleNone","project","resample$1","delta2","resampleLineTo","c0","c1","depth","d2","phi2","x2","y2","dx2","dy2","dz","cosMinDistance","resampleStream","maxDepth","ringStart","ringPoint","ringEnd","a00","b00","c00","projectionMutator","projectAt","projectRotate","projectTransform","recenter","cache","cacheStream","theta","preclip","clipAntimeridian","postclip","identity$4","projectResample","resample","transformRadians","clipAngle","clipCircle","conicProjection","parallels","cylindricalEqualAreaRaw","forward","conicEqualAreaRaw","r0","sy0","r0y","multiplex","streams","sphere","azimuthalRaw","azimuthalInvert","sc","cc","mercatorRaw","tan","mercatorProjection","clipAuto","tany","conicConformalRaw","cy0","fy","equirectangularRaw","conicEquidistantRaw","gy","nx","gnomonicRaw","scaleTranslate","kx","ky","tx","ty","orthographicRaw","stereographicRaw","transverseMercatorRaw","defaultSeparation","meanX","children","reduce","meanXReduce","maxY","maxYReduce","leafLeft","leafRight","sum","leastCommonAncestor","aNodes","ancestors","bNodes","hierarchy","child","childs","Node","valued","defaultChildren","eachBefore","computeHeight","node_copy","copyData","Node$2","encloses","dr","encloseN","L","B","circle","l2","p1","l0","l1","head","enclose1","enclose2","enclose3","tail","r1","r2","x21","y21","r21","x3","y3","r3","a2","c2","a3","c3","d3","ab","A","place","ax","ay","da","db","dc","intersects","distance1","distance2","Node$1","previous","packEnclose","circles","sj","sk","aa","ba","oa","ox","oy","pack","enclose","optional","required","constantZero","defaultRadius$1","radiusLeaf","packChildren","padding","translateChild","defaultId","defaultParentId","parentId","defaultSeparation$1","nextLeft","nextRight","moveSubtree","wm","wp","shift","change","executeShifts","nextAncestor","vim","ancestor","TreeNode","treeRoot","squarifyRatio","ratio","nodeValue","sumValue","minValue","maxValue","newRatio","minRatio","alpha","beta","i0","i1","dice","treemapDice","treemapSlice","lexicographicOrder","computeUpperHullIndexes","indexes","cross","Queue","_size","_error","_tasks","_data","_waiting","_active","_ended","_start","poke$1","start$1","abort","noabort","maybeNotify","queue","concurrency","fixCallback","xhr","hasResponse","responseType","response","responseText","responseOf","request$$1","ordinal","unknown","implicit","slice$4","has","band","rescale","range$$1","paddingInner","paddingOuter","ordinalRange","rangeRound","pointish","point$1","deinterpolateLinear","constant$9","deinterpolateClamp","deinterpolate","reinterpolateClamp","bimap","d0","d1","polymap","bisectRight","clamp","continuous","piecewise","unit","map$3","number$1","interpolateRound","linearish","nice","linear$2","identity$6","reinterpolate$1","pow10","powp","base","logp","log10","log2","reflect","log$1","logs","pows","raise$1","exponent","pow$1","sqrt$1","quantile$$1","thresholds","threshold","invertExtent","sort","quantiles","quantize$1","threshold$1","newInterval","floori","offseti","field","date","Date","test","setTime","t0$1","t1$1","weekday","setDate","getDate","getDay","setHours","getTimezoneOffset","durationMinute$1","durationWeek$1","utcWeekday","setUTCDate","getUTCDate","getUTCDay","setUTCHours","localDate","H","M","setFullYear","utcDate","UTC","setUTCFullYear","newYear","formatLocale$1","locale","newFormat","formats","pad","charCodeAt","pads","charAt","newParse","newDate","parseSpecifier","day$$1","U","Z","parses","parsePeriod","periodRe","periodLookup","parseShortWeekday","shortWeekdayRe","shortWeekdayLookup","parseWeekday","weekdayRe","weekdayLookup","parseShortMonth","shortMonthRe","shortMonthLookup","parseMonth","monthRe","monthLookup","parseLocaleDateTime","locale_dateTime","parseLocaleDate","locale_date","parseLocaleTime","locale_time","formatShortWeekday","locale_shortWeekdays","formatWeekday","locale_weekdays","formatShortMonth","locale_shortMonths","getMonth","formatMonth","locale_months","formatPeriod","locale_periods","getHours","formatUTCShortWeekday","formatUTCWeekday","formatUTCShortMonth","getUTCMonth","formatUTCMonth","formatUTCPeriod","getUTCHours","dateTime","periods","days","shortDays","months","shortMonths","formatRe","formatLookup","formatDayOfMonth","formatHour24","I","formatHour12","formatDayOfYear","formatMilliseconds","formatMonthNumber","formatMinutes","formatSeconds","formatWeekNumberSunday","formatWeekdayNumber","formatWeekNumberMonday","formatYear","formatFullYear","formatZone","%","formatLiteralPercent","utcFormats","formatUTCDayOfMonth","formatUTCHour24","formatUTCHour12","formatUTCDayOfYear","formatUTCMilliseconds","formatUTCMonthNumber","formatUTCMinutes","formatUTCSeconds","formatUTCWeekNumberSunday","formatUTCWeekdayNumber","formatUTCWeekNumberMonday","formatUTCYear","formatUTCFullYear","formatUTCZone","parseDayOfMonth","parseHour24","parseDayOfYear","parseMilliseconds","parseMonthNumber","parseMinutes","parseSeconds","parseWeekNumberSunday","parseWeekdayNumber","parseWeekNumberMonday","parseYear","parseFullYear","parseZone","parseLiteralPercent","utcFormat","utcParse","requote","replace","requoteRe","RegExp","numberRe","percentRe","day","year","getMilliseconds","getMinutes","getSeconds","sunday","monday","getFullYear","utcDay","utcYear","getUTCMilliseconds","getUTCMinutes","getUTCSeconds","utcSunday","utcMonday","getUTCFullYear","defaultLocale$1","locale$2","timeFormat","timeParse","formatIsoNative","toISOString","parseIsoNative","date$1","number$2","calendar","year$$1","month$$1","week","hour$$1","minute$$1","second$$1","millisecond$$1","formatMillisecond","formatSecond","formatMinute","formatHour","formatDay","formatWeek","tickInterval","bisector","tickIntervals","durationYear","durationSecond","durationMinute","durationHour","durationDay","durationWeek","durationMonth","ramp","sequential","interpolator","arcInnerRadius","innerRadius","arcOuterRadius","outerRadius","arcStartAngle","arcEndAngle","arcPadAngle","padAngle","asin$1","halfPi$3","intersect","x10","y10","x32","y32","cornerTangents","rc","cw","x01","y01","lo","x11","y11","cx0","cx1","cy1","dx0","dy0","dx1","dy1","Linear","x$3","y$3","Radial","curve","_curve","curveRadial","radial","radialLine","point$2","bezierCurveTo","Basis","BasisClosed","BasisOpen","Bundle","_basis","_beta","point$3","_k","_x2","_y2","Cardinal","tension","CardinalClosed","CardinalOpen","point$4","_l01_a","epsilon$3","_l01_2a","_l12_a","_l12_2a","_l23_a","_l23_2a","CatmullRom","_alpha","CatmullRomClosed","CatmullRomOpen","LinearClosed","sign$1","slope3","h0","h1","slope2","point$5","MonotoneX","MonotoneY","ReflectContext","monotoneX","monotoneY","Natural","controlPoints","Step","_t","stepBefore","stepAfter","stackValue","sum$2","series","x$4","y$4","RedBlackTree","RedBlackNode","R","P","RedBlackRotateLeft","RedBlackRotateRight","RedBlackFirst","createEdge","edge","edges","setEdgeEnd","cells","halfedges","createBorderEdge","vertex","clipEdge","bx","by","connectEdge","fm","fb","lx","ly","rx","ry","fx","clipEdges","epsilon$4","createCell","site","cellHalfedgeAngle","cell","va","vb","cellHalfedgeStart","cellHalfedgeEnd","sortCellHalfedges","clipCells","iCell","iHalfedge","nHalfedges","startX","startY","endX","endY","nCells","v00","v01","v11","v10","Circle","arc","attachCircle","lArc","rArc","lSite","cSite","rSite","epsilon2$2","ha","hc","circlePool","before","firstCircle","detachCircle","Beach","createBeach","beach","beachPool","detachBeach","beaches","removeBeach","disappearing","unshift","iArc","nArcs","addBeach","dxl","dxr","directrix","leftBreakPoint","rightBreakPoint","newArc","hb","rfocx","rfocy","pby2","lfocx","lfocy","plby2","hl","aby2","triangleArea","lexicographic","Diagram","sites","ZoomEvent","Transform","transform$1","__zoom","identity$8","nopropagation$2","defaultFilter$2","defaultExtent$1","SVGElement","clientWidth","clientHeight","defaultTransform","version","hi","mid","ascendingBisect","bisectLeft","descending","number","variance","deviation","constant","identity","sturges","LN2","histogram","tz","bin","bins","freedmanDiaconis","scott","mean","median","numbers","arrays","merged","pairs","permute","permutes","scan","xi","xj","shuffle","random","transpose","zip","constructor","T","namespaces","xlink","xml","xmlns","namespace","prefix","creator","matcher","selector","matches","element","vendorMatches","webkitMatchesSelector","msMatchesSelector","mozMatchesSelector","oMatchesSelector","matcher$1","element$1","mouseenter","mouseleave","selection_on","current","createSVGPoint","clientX","clientY","matrixTransform","getScreenCTM","inverse","rect","getBoundingClientRect","clientLeft","clientTop","querySelector","selection_select","subgroups","subnode","subgroup","selectorAll","querySelectorAll","selection_selectAll","selection_filter","sparse","selection_enter","_enter","constant$1","selection_data","bind","enterGroup","updateGroup","exitGroup","_exit","selection_exit","selection_merge","groups0","groups1","m0","merges","group0","group1","selection_order","selection_sort","compareNode","sortgroups","sortgroup","selection_call","selection_nodes","selection_node","selection_size","selection_empty","selection_each","selection_attr","selection_style","selection_property","contains","selection_classed","selection_text","selection_html","selection_raise","selection_lower","selection_append","selection_insert","selection_remove","selection_datum","selection_dispatch","classed","html","touch","preventDefault","constant$2","drag","mousedowned","touchstarted","touchmoved","touchended","gesture","container","mousemoved","mouseupped","mousemoving","gestures","touches$$1","sublisteners","define","darker","brighter","reI","reN","reP","aliceblue","antiquewhite","aqua","aquamarine","azure","beige","bisque","black","blanchedalmond","blue","blueviolet","brown","burlywood","cadetblue","chartreuse","chocolate","coral","cornflowerblue","cornsilk","crimson","cyan","darkblue","darkcyan","darkgoldenrod","darkgray","darkgreen","darkgrey","darkkhaki","darkmagenta","darkolivegreen","darkorange","darkorchid","darkred","darksalmon","darkseagreen","darkslateblue","darkslategray","darkslategrey","darkturquoise","darkviolet","deeppink","deepskyblue","dimgray","dimgrey","dodgerblue","firebrick","floralwhite","forestgreen","fuchsia","gainsboro","ghostwhite","gold","goldenrod","gray","green","greenyellow","grey","honeydew","hotpink","indianred","indigo","ivory","khaki","lavender","lavenderblush","lawngreen","lemonchiffon","lightblue","lightcoral","lightcyan","lightgoldenrodyellow","lightgray","lightgreen","lightgrey","lightpink","lightsalmon","lightseagreen","lightskyblue","lightslategray","lightslategrey","lightsteelblue","lightyellow","lime","limegreen","linen","magenta","maroon","mediumaquamarine","mediumblue","mediumorchid","mediumpurple","mediumseagreen","mediumslateblue","mediumspringgreen","mediumturquoise","mediumvioletred","midnightblue","mintcream","mistyrose","moccasin","navajowhite","navy","oldlace","olive","olivedrab","orange","orangered","orchid","palegoldenrod","palegreen","paleturquoise","palevioletred","papayawhip","peachpuff","peru","pink","plum","powderblue","purple","rebeccapurple","red","rosybrown","royalblue","saddlebrown","salmon","sandybrown","seagreen","seashell","sienna","silver","skyblue","slateblue","slategray","slategrey","snow","springgreen","steelblue","teal","thistle","tomato","turquoise","violet","wheat","white","whitesmoke","yellow","yellowgreen","displayable","PI","Kn","basis$1","basisClosed","interpolateRgb","rgbGamma","rgb$$1","rgbBasis","rgbBasisClosed","array$1","nb","na","reA","reB","interpolateString","am","bm","bs","bi","lastIndex","degrees","interpolateTransformCss","interpolateTransformSvg","rho","SQRT2","rho2","rho4","epsilon2","interpolateZoom","ux0","uy0","ux1","uy1","coshr0","hsl$2","hslLong","hcl$2","hclLong","cubehelix$2","cubehelixLong","quantize","samples","performance","requestAnimationFrame","TypeError","interval$1","total","emptyOn","emptyTween","selection_interrupt","transition_tween","transition_attr","transition_attrTween","transition_delay","transition_duration","transition_ease","transition_filter","transition_merge","transition_on","transition_remove","transition_select","select$$1","transition_selectAll","Selection$1","transition_selection","transition_style","transition_styleTween","transition_text","transition_transition","id0","id1","selection_prototype","polyIn","custom","polyOut","polyInOut","overshoot","backIn","backOut","backInOut","tau","amplitude","period","elasticIn","elasticOut","elasticInOut","selection_transition","root$1","xy","XY","nw","ne","se","sw","pi$1","halfPi$1","tau$1","max$1","chord","groupSums","groupIndex","subgroupIndex","chords","sortGroups","sortSubgroups","di","dj","subindex","sortChords","slice$2","constant$5","pi$2","tau$2","epsilon$1","tauEpsilon","moveTo","closePath","lineTo","quadraticCurveTo","arcTo","l01_2","x20","y20","l21_2","l20_2","l21","l01","t01","t21","ccw","ribbon","buffer","argv","sr","sa0","sa1","sx0","tr","ta0","ta1","clear","entries","nest","createResult","setResult","rollup","sortValues","valuesByKey","sortKey","sortKeys","proto","dsv","delimiter","convert","parseRows","token","EOF","eol","EOL","delimiterCode","formatValue","formatRows","formatRow","reFormat","csv","csvParse","csvParseRows","csvFormat","csvFormatRows","tsv","tsvParse","tsvParseRows","tsvFormat","tsvFormatRows","center$1","force","sx","sy","constant$6","jiggle","tree_add","tree_cover","tree_data","visit","tree_extent","Quad","tree_find","quads","tree_remove","retainer","tree_root","tree_size","tree_visit","tree_visitAfter","tree_x","tree_y","treeProto","visitAfter","prefixExponent","collide","quad","rj","ri","yi","strength","ri2","iterations","prepare","radii","link","links","defaultStrength","distances","strengths","bias","initializeStrength","initializeDistance","distance","initialRadius","initialAngle","simulation","alphaMin","stepper","alphaTarget","alphaDecay","forces","velocityDecay","initializeNodes","initializeForce","closest","manyBody","accumulate","x$$1","y$$1","theta2","distanceMax2","distanceMin2","distanceMin","distanceMax","x$2","y$2","formatDecimal","toExponential","coefficient","exponent$1","formatGroup","grouping","thousands","substring","formatDefault","toPrecision","out","formatPrefixAuto","formatRounded","","toFixed","toUpperCase","formatSpecifier","prefixes","valuePrefix","valueSuffix","suffix","formatType","valueNegative","maybeSuffix","decimal","currency","precisionFixed","precisionPrefix","precisionRound","temp","valueOf","epsilon2$1","streamObjectType","Feature","feature","FeatureCollection","features","Sphere","Point","MultiPoint","LineString","MultiLineString","Polygon","MultiPolygon","GeometryCollection","geometries","areaSum","areaRing","area","bounds","deltaMax","centroid","constant$7","pointEqual","isSubject","extent$1","length$1","object$1","interpolate$1","sy1","kx0","ky0","kx1","ky1","areaSum$1","_radius","pointRadius","_line","_point","lengthRing","_circle","index$1","contextStream","projectionStream","measure","sum$1","polygonContains","sinPhi1","absDelta","intersection","phiArc","pointVisible","sink","pointLine","pointRing","ringSink","ringSegments","ringBuffer","polygonStarted","rotatedStart","cr","point2","smallRadius","code","notHemisphere","two","pa","pb","n2","n2n2","n1n2","determinant","n1xn2","uu","polar","meridian","q1","conicEqualArea","albers","albersUsa","lower48Point","alaskaPoint","hawaiiPoint","lower48","alaska","hawaii","pointStream","azimuthalEqualAreaRaw","cxcy","azimuthalEqualArea","azimuthalEquidistantRaw","azimuthalEquidistant","mercator","conicConformal","equirectangular","conicEquidistant","gnomonic","identity$5","reflectX","reflectY","orthographic","stereographic","transverseMercator","cluster","previousNode","eachAfter","separation","nodeSize","node_count","node_each","node_eachBefore","node_eachAfter","node_sum","node_sort","node_path","node_ancestors","node_descendants","node_leaves","leaves","node_links","descendants","shuffle$1","siblings","constant$8","index$2","roundNode","partition","positionNode","keyPrefix$1","preroot","ambiguous","stratify","nodeKey","nodeByKey","firstWalk","secondWalk","sizeNode","midpoint","apportion","vip","vop","vom","sip","sop","sim","som","squarify","index$3","treemap","paddingStack","paddingLeft","paddingTop","paddingRight","paddingBottom","tile","binary","valueOffset","sums","valueTarget","valueLeft","valueRight","yk","xk","sliceDice","resquarify","_squarify","area$1","centroid$1","hull","sortedPoints","flippedPoints","upperIndexes","lowerIndexes","skipLeft","skipRight","inside","length$2","perimeter","slice$3","defer","await","results","awaitAll","uniform","mu","sigma","logNormal","randomNormal","irwinHall","bates","randomIrwinHall","exponential$1","request","url","respond","status","mimeType","headers","XMLHttpRequest","user","password","XDomainRequest","onload","onerror","ontimeout","onreadystatechange","readyState","onprogress","header","send","post","method","open","setRequestHeader","overrideMimeType","type$1","defaultMimeType","createRange","createContextualFragment","json","responseXML","dsv$1","csv$1","tsv$1","array$2","millisecond","milliseconds","durationSecond$1","durationHour$1","durationDay$1","second","seconds","minute","minutes","hour","hours","tuesday","wednesday","thursday","friday","saturday","sundays","mondays","tuesdays","wednesdays","thursdays","fridays","saturdays","month","setMonth","years","utcMinute","setUTCSeconds","utcMinutes","utcHour","setUTCMinutes","utcHours","utcDays","utcTuesday","utcWednesday","utcThursday","utcFriday","utcSaturday","utcSundays","utcMondays","utcTuesdays","utcWednesdays","utcThursdays","utcFridays","utcSaturdays","utcMonth","setUTCMonth","utcMonths","utcYears","-","0","isoSpecifier","formatIso","parseIso","utcTime","category10","category20b","category20c","category20","cubehelix$3","warm","cool","rainbow","rainbow$1","ts","viridis","magma","inferno","plasma","constant$10","pi$4","tau$4","a01","a11","a10","da0","da1","ap","rp","padRadius","cornerRadius","rc0","rc1","oc","kc","lc","areaStart","areaEnd","curveLinear","defined0","defined","area$2","x0z","y0z","arealine","lineX0","lineY0","lineY1","lineX1","descending$1","identity$7","pie","arcs","curveRadialLinear","radialLine$1","radialArea","lineStartAngle","lineEndAngle","lineInnerRadius","lineOuterRadius","circle$2","draw","cross$1","tan30","tan30_2","diamond","ka","kr","star","square","sqrt3","triangle","wye","symbols","noop$2","basis$2","_x3","_x4","_y3","_y4","basisClosed$1","basisOpen","bundle","cardinal","_x5","_y5","cardinalClosed","cardinalOpen","x23","y23","catmullRom","catmullRomClosed","catmullRomOpen","linearClosed","_t0","px","py","natural","slice$5","none$1","none$2","stack","oz","kz","sz","sij","ki","si","expand","silhouette","wiggle","s2","sij0","sij1","s3","skj0","skj1","ascending$2","descending$2","insideOut","tops","bottoms","constant$11","after","grandpa","uncle","sibling","polygons","triangles","_found","voronoi","constant$12","applyX","applyY","location","invertX","invertY","rescaleX","rescaleY","noevent$2","zoom","wheeled","dblclicked","k0","k1","constrain","transition$$1","Gesture","wheelidled","wheel","deltaY","deltaMode","wheelDelay","touch0","touch1","touchstarting","touchDelay","dp","dl","collection","scaleBy","scaleTo","translateBy","scaleExtent","translateExtent","bisect","thresholdFreedmanDiaconis","thresholdScott","thresholdSturges","quantile","dragEnable","dsvFormat","easeLinear","easeQuad","easeQuadIn","easeQuadOut","easeQuadInOut","easeCubic","easeCubicIn","easeCubicOut","easeCubicInOut","easePoly","easePolyIn","easePolyOut","easePolyInOut","easeSin","easeSinIn","easeSinOut","easeSinInOut","easeExp","easeExpIn","easeExpOut","easeExpInOut","easeCircle","easeCircleIn","easeCircleOut","easeCircleInOut","easeBounce","easeBounceIn","easeBounceOut","easeBounceInOut","easeBack","easeBackIn","easeBackOut","easeBackInOut","easeElastic","easeElasticIn","easeElasticOut","easeElasticInOut","forceCenter","forceCollide","forceLink","forceManyBody","forceSimulation","forceX","forceY","formatDefaultLocale","geoArea","geoBounds","geoCentroid","geoCircle","geoClipExtent","geoDistance","geoGraticule","geoGraticule10","geoInterpolate","geoLength","geoPath","geoAlbers","geoAlbersUsa","geoAzimuthalEqualArea","geoAzimuthalEqualAreaRaw","geoAzimuthalEquidistant","geoAzimuthalEquidistantRaw","geoConicConformal","geoConicConformalRaw","geoConicEqualArea","geoConicEqualAreaRaw","geoConicEquidistant","geoConicEquidistantRaw","geoEquirectangular","geoEquirectangularRaw","geoGnomonic","geoGnomonicRaw","geoIdentity","geoProjection","geoProjectionMutator","geoMercator","geoMercatorRaw","geoOrthographic","geoOrthographicRaw","geoStereographic","geoStereographicRaw","geoTransverseMercator","geoTransverseMercatorRaw","geoRotation","geoTransform","packSiblings","treemapBinary","treemapSliceDice","treemapSquarify","treemapResquarify","interpolateArray","interpolateBasis","interpolateBasisClosed","interpolateDate","interpolateNumber","interpolateObject","interpolateRgbBasis","interpolateRgbBasisClosed","interpolateHsl","interpolateHslLong","interpolateLab","interpolateHcl","interpolateHclLong","interpolateCubehelix","interpolateCubehelixLong","polygonArea","polygonCentroid","polygonHull","polygonLength","randomUniform","randomLogNormal","randomBates","randomExponential","scaleBand","scalePoint","scaleIdentity","scaleLinear","scaleLog","scaleOrdinal","scaleImplicit","scalePow","scaleSqrt","scaleQuantile","scaleQuantize","scaleThreshold","scaleTime","scaleUtc","schemeCategory10","schemeCategory20b","schemeCategory20c","schemeCategory20","interpolateCubehelixDefault","interpolateRainbow","interpolateWarm","interpolateCool","interpolateViridis","interpolateMagma","interpolateInferno","interpolatePlasma","scaleSequential","symbolCircle","symbolCross","symbolDiamond","symbolSquare","symbolStar","symbolTriangle","symbolWye","curveBasisClosed","curveBasisOpen","curveBasis","curveBundle","curveCardinalClosed","curveCardinalOpen","curveCardinal","curveCatmullRomClosed","curveCatmullRomOpen","curveCatmullRom","curveLinearClosed","curveMonotoneX","curveMonotoneY","curveNatural","curveStep","curveStepAfter","curveStepBefore","stackOffsetExpand","stackOffsetNone","stackOffsetSilhouette","stackOffsetWiggle","stackOrderAscending","stackOrderDescending","stackOrderInsideOut","stackOrderNone","stackOrderReverse","timeInterval","timeMillisecond","timeMilliseconds","utcMillisecond","utcMilliseconds","timeSecond","timeSeconds","utcSecond","utcSeconds","timeMinute","timeMinutes","timeHour","timeHours","timeDay","timeDays","timeWeek","timeWeeks","timeSunday","timeSundays","timeMonday","timeMondays","timeTuesday","timeTuesdays","timeWednesday","timeWednesdays","timeThursday","timeThursdays","timeFriday","timeFridays","timeSaturday","timeSaturdays","timeMonth","timeMonths","timeYear","timeYears","utcWeek","utcWeeks","timeFormatDefaultLocale","timeFormatLocale","isoFormat","isoParse","zoomTransform","zoomIdentity","defineProperty","store","uid","Symbol","USE_SYMBOL","$exports","__WEBPACK_AMD_DEFINE_RESULT__","addMapEntry","pair","addSetEntry","func","thisArg","arrayAggregator","setter","iteratee","accumulator","arrayEach","arrayEachRight","arrayEvery","predicate","arrayFilter","resIndex","arrayIncludes","baseIndexOf","arrayIncludesWith","comparator","arrayMap","arrayPush","arrayReduce","initAccum","arrayReduceRight","arraySome","asciiToArray","asciiWords","reAsciiWord","baseFindKey","eachFunc","baseFindIndex","fromIndex","fromRight","strictIndexOf","baseIsNaN","baseIndexOfWith","baseMean","baseSum","NAN","baseProperty","basePropertyOf","baseReduce","baseSortBy","comparer","baseTimes","baseToPairs","props","baseUnary","baseValues","cacheHas","charsStartIndex","strSymbols","chrSymbols","charsEndIndex","countHolders","placeholder","escapeStringChar","chr","stringEscapes","getValue","hasUnicode","reHasUnicode","hasUnicodeWord","reHasUnicodeWord","iteratorToArray","iterator","done","mapToArray","overArg","arg","replaceHolders","PLACEHOLDER","setToArray","setToPairs","strictLastIndexOf","stringSize","unicodeSize","asciiSize","stringToArray","unicodeToArray","reUnicode","unicodeWords","reUnicodeWord","VERSION","LARGE_ARRAY_SIZE","CORE_ERROR_TEXT","FUNC_ERROR_TEXT","HASH_UNDEFINED","MAX_MEMOIZE_SIZE","CLONE_DEEP_FLAG","CLONE_FLAT_FLAG","CLONE_SYMBOLS_FLAG","COMPARE_PARTIAL_FLAG","COMPARE_UNORDERED_FLAG","WRAP_BIND_FLAG","WRAP_BIND_KEY_FLAG","WRAP_CURRY_BOUND_FLAG","WRAP_CURRY_FLAG","WRAP_CURRY_RIGHT_FLAG","WRAP_PARTIAL_FLAG","WRAP_PARTIAL_RIGHT_FLAG","WRAP_ARY_FLAG","WRAP_REARG_FLAG","WRAP_FLIP_FLAG","DEFAULT_TRUNC_LENGTH","DEFAULT_TRUNC_OMISSION","HOT_COUNT","HOT_SPAN","LAZY_FILTER_FLAG","LAZY_MAP_FLAG","LAZY_WHILE_FLAG","INFINITY","MAX_SAFE_INTEGER","MAX_INTEGER","MAX_ARRAY_LENGTH","MAX_ARRAY_INDEX","HALF_MAX_ARRAY_LENGTH","wrapFlags","argsTag","arrayTag","asyncTag","boolTag","dateTag","domExcTag","errorTag","funcTag","genTag","mapTag","numberTag","nullTag","objectTag","promiseTag","proxyTag","regexpTag","setTag","stringTag","symbolTag","undefinedTag","weakMapTag","weakSetTag","arrayBufferTag","dataViewTag","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint8ClampedTag","uint16Tag","uint32Tag","reEmptyStringLeading","reEmptyStringMiddle","reEmptyStringTrailing","reEscapedHtml","reUnescapedHtml","reHasEscapedHtml","reHasUnescapedHtml","reEscape","reEvaluate","reInterpolate","reIsDeepProp","reIsPlainProp","reLeadingDot","rePropName","reRegExpChar","reHasRegExpChar","reTrim","reTrimStart","reTrimEnd","reWrapComment","reWrapDetails","reSplitDetails","reEscapeChar","reEsTemplate","reFlags","reIsBadHex","reIsBinary","reIsHostCtor","reIsOctal","reIsUint","reLatin","reNoMatch","reUnescapedString","rsAstralRange","rsComboMarksRange","reComboHalfMarksRange","rsComboSymbolsRange","rsComboRange","rsDingbatRange","rsLowerRange","rsMathOpRange","rsNonCharRange","rsPunctuationRange","rsSpaceRange","rsUpperRange","rsVarRange","rsBreakRange","rsApos","rsAstral","rsBreak","rsCombo","rsDigits","rsDingbat","rsLower","rsMisc","rsFitz","rsModifier","rsNonAstral","rsRegional","rsSurrPair","rsUpper","rsZWJ","rsMiscLower","rsMiscUpper","rsOptContrLower","rsOptContrUpper","reOptMod","rsOptVar","rsOptJoin","rsOrdLower","rsOrdUpper","rsSeq","rsEmoji","rsSymbol","reApos","reComboMark","contextProps","templateCounter","typedArrayTags","cloneableTags","deburredLetters","À","Á","Â","Ã","Ä","Å","à","á","â","ã","ä","å","Ç","ç","Ð","ð","È","É","Ê","Ë","è","é","ê","ë","Ì","Í","Î","Ï","ì","í","î","ï","Ñ","ñ","Ò","Ó","Ô","Õ","Ö","Ø","ò","ó","ô","õ","ö","ø","Ù","Ú","Û","Ü","ù","ú","û","ü","Ý","ý","ÿ","Æ","æ","Þ","þ","ß","Ā","Ă","Ą","ā","ă","ą","Ć","Ĉ","Ċ","Č","ć","ĉ","ċ","č","Ď","Đ","ď","đ","Ē","Ĕ","Ė","Ę","Ě","ē","ĕ","ė","ę","ě","Ĝ","Ğ","Ġ","Ģ","ĝ","ğ","ġ","ģ","Ĥ","Ħ","ĥ","ħ","Ĩ","Ī","Ĭ","Į","İ","ĩ","ī","ĭ","į","ı","Ĵ","ĵ","Ķ","ķ","ĸ","Ĺ","Ļ","Ľ","Ŀ","Ł","ĺ","ļ","ľ","ŀ","ł","Ń","Ņ","Ň","Ŋ","ń","ņ","ň","ŋ","Ō","Ŏ","Ő","ō","ŏ","ő","Ŕ","Ŗ","Ř","ŕ","ŗ","ř","Ś","Ŝ","Ş","Š","ś","ŝ","ş","š","Ţ","Ť","Ŧ","ţ","ť","ŧ","Ũ","Ū","Ŭ","Ů","Ű","Ų","ũ","ū","ŭ","ů","ű","ų","Ŵ","ŵ","Ŷ","ŷ","Ÿ","Ź","Ż","Ž","ź","ż","ž","IJ","ij","Œ","œ","ʼn","ſ","htmlEscapes","&","<",">","\"","'","htmlUnescapes","&amp;","&lt;","&gt;","&quot;","&#39;","\\","\n","\r","
","
","freeParseFloat","parseFloat","freeParseInt","freeGlobal","freeSelf","freeExports","nodeType","freeModule","moduleExports","freeProcess","process","nodeUtil","binding","nodeIsArrayBuffer","isArrayBuffer","nodeIsDate","isDate","nodeIsMap","isMap","nodeIsRegExp","isRegExp","nodeIsSet","isSet","nodeIsTypedArray","isTypedArray","deburrLetter","escapeHtmlChar","unescapeHtmlChar","runInContext","lodash","isObjectLike","LazyWrapper","LodashWrapper","wrapperClone","baseLodash","chainAll","__wrapped__","__actions__","__chain__","__index__","__values__","__dir__","__filtered__","__iteratees__","__takeCount__","__views__","lazyClone","copyArray","lazyReverse","clone","lazyValue","dir","isArr","isRight","arrLength","getView","iteratees","iterLength","takeCount","nativeMin","baseWrapperValue","outer","iterIndex","Hash","hashClear","nativeCreate","hashDelete","hashGet","hashHas","hashSet","ListCache","listCacheClear","listCacheDelete","assocIndexOf","listCacheGet","listCacheHas","listCacheSet","MapCache","mapCacheClear","hash","mapCacheDelete","getMapData","mapCacheGet","mapCacheHas","mapCacheSet","SetCache","setCacheAdd","setCacheHas","Stack","stackClear","stackDelete","stackGet","stackHas","stackSet","arrayLikeKeys","inherited","isArg","isArguments","isBuff","isBuffer","isType","skipIndexes","String","isIndex","arraySample","baseRandom","arraySampleSize","shuffleSelf","baseClamp","arrayShuffle","assignMergeValue","eq","baseAssignValue","assignValue","objValue","baseAggregator","baseEach","baseAssign","copyObject","baseAssignIn","keysIn","configurable","enumerable","writable","baseAt","paths","skip","upper","baseClone","bitmask","customizer","isDeep","isFlat","isFull","isObject","initCloneArray","tag","getTag","isFunc","cloneBuffer","initCloneObject","copySymbolsIn","copySymbols","initCloneByTag","stacked","keysFunc","getAllKeysIn","getAllKeys","subValue","baseConforms","baseConformsTo","baseDelay","wait","baseDifference","includes","isCommon","valuesLength","valuesIndex","baseEvery","baseExtremum","isSymbol","baseFill","toInteger","toLength","baseFilter","baseFlatten","isStrict","isFlattenable","baseForOwn","baseFor","baseForOwnRight","baseForRight","baseFunctions","isFunction","baseGet","castPath","toKey","baseGetAllKeys","symbolsFunc","baseGetTag","symToStringTag","getRawTag","objectToString","baseGt","baseHas","baseHasIn","baseInRange","nativeMax","baseIntersection","othLength","othIndex","caches","maxLength","seen","baseInverter","baseInvoke","last","baseIsArguments","baseIsArrayBuffer","baseIsDate","baseIsEqual","baseIsEqualDeep","equalFunc","objIsArr","othIsArr","objTag","othTag","objIsObj","othIsObj","isSameTag","equalArrays","equalByTag","objIsWrapped","othIsWrapped","objUnwrapped","othUnwrapped","equalObjects","baseIsMap","baseIsMatch","matchData","noCustomizer","srcValue","baseIsNative","isMasked","pattern","reIsNative","toSource","baseIsRegExp","baseIsSet","baseIsTypedArray","isLength","baseIteratee","baseMatchesProperty","baseMatches","baseKeys","isPrototype","nativeKeys","baseKeysIn","nativeKeysIn","isProto","baseLt","baseMap","isArrayLike","getMatchData","matchesStrictComparable","isKey","isStrictComparable","hasIn","baseMerge","srcIndex","baseMergeDeep","newValue","mergeFunc","isTyped","isArrayLikeObject","cloneTypedArray","isPlainObject","toPlainObject","baseNth","baseOrderBy","orders","getIteratee","criteria","compareMultiple","basePick","basePickBy","baseSet","basePropertyDeep","basePullAll","basePullAt","baseUnset","nativeFloor","nativeRandom","baseRange","nativeCeil","baseRepeat","baseRest","setToString","overRest","baseSample","baseSampleSize","nested","baseShuffle","baseSlice","baseSome","baseSortedIndex","retHighest","low","high","baseSortedIndexBy","valIsNaN","valIsNull","valIsSymbol","valIsUndefined","othIsDefined","othIsNull","othIsReflexive","othIsSymbol","setLow","baseSortedUniq","baseToNumber","baseToString","symbolToString","baseUniq","createSet","seenIndex","baseUpdate","updater","baseWhile","isDrop","actions","action","baseXor","baseZipObject","assignFunc","valsLength","castArrayLikeObject","castFunction","stringToPath","castSlice","allocUnsafe","cloneArrayBuffer","arrayBuffer","byteLength","Uint8Array","cloneDataView","dataView","byteOffset","cloneMap","cloneFunc","cloneRegExp","regexp","cloneSet","cloneSymbol","symbolValueOf","typedArray","compareAscending","valIsDefined","valIsReflexive","objCriteria","othCriteria","ordersLength","composeArgs","partials","holders","isCurried","argsIndex","argsLength","holdersLength","leftIndex","leftLength","rangeLength","isUncurried","composeArgsRight","holdersIndex","rightIndex","rightLength","isNew","getSymbols","getSymbolsIn","createAggregator","initializer","createAssigner","assigner","sources","guard","isIterateeCall","createBaseEach","iterable","createBaseFor","createBind","wrapper","fn","Ctor","isBind","createCtor","createCaseFirst","methodName","trailing","createCompounder","words","deburr","thisBinding","baseCreate","createCurry","arity","getHolder","createRecurry","createHybrid","createFind","findIndexFunc","createFlow","flatRest","funcs","prereq","thru","getFuncName","funcName","getData","isLaziable","plant","partialsRight","holdersRight","argPos","ary","holdersCount","newHolders","isBindKey","reorder","isFlip","isAry","createInverter","toIteratee","createMathOperation","operator","defaultValue","createOver","arrayFunc","createPadding","chars","charsLength","createPartial","toFinite","createRelationalOperation","toNumber","wrapFunc","isCurry","newHoldersRight","newPartials","newPartialsRight","newData","setData","setWrapToString","createRound","createToPairs","createWrap","mergeData","baseSetData","customDefaultsAssignIn","objectProto","customDefaultsMerge","customOmitClone","isPartial","arrValue","othValue","compared","message","objProps","objLength","othProps","skipCtor","objCtor","othCtor","flatten","realNames","otherFunc","isKeyable","getNative","isOwn","unmasked","nativeObjectToString","transforms","getWrapDetails","hasPath","hasFunc","getPrototype","insertWrapDetails","details","spreadableSymbol","maskSrcKey","memoizeCapped","memoize","srcBitmask","newBitmask","isCombo","otherArgs","oldArray","reference","updateWrapDetails","shortOut","lastCalled","stamp","nativeNow","remaining","rand","funcToString","chunk","compact","drop","dropRight","dropRightWhile","dropWhile","findIndex","findLastIndex","flattenDeep","flattenDepth","fromPairs","initial","separator","nativeJoin","lastIndexOf","nth","pullAll","pullAllBy","pullAllWith","nativeReverse","sortedIndex","sortedIndexBy","sortedIndexOf","sortedLastIndex","sortedLastIndexBy","sortedLastIndexOf","sortedUniq","sortedUniqBy","take","takeRight","takeRightWhile","takeWhile","uniq","uniqBy","uniqWith","unzip","unzipWith","zipObject","zipObjectDeep","chain","tap","interceptor","wrapperChain","wrapperCommit","wrapperNext","toArray","wrapperToIterator","wrapperPlant","wrapperReverse","wrapped","wrapperValue","flatMap","flatMapDeep","flatMapDepth","forEachRight","baseEachRight","isString","orderBy","reduceRight","reject","negate","sample","sampleSize","some","curry","curryRight","debounce","invokeFunc","lastArgs","lastThis","lastInvokeTime","leadingEdge","timerId","timerExpired","leading","remainingWait","timeSinceLastCall","lastCallTime","timeSinceLastInvoke","maxing","maxWait","shouldInvoke","trailingEdge","cancel","flush","debounced","isInvoking","flip","resolver","memoized","Cache","once","rest","spread","throttle","unary","partial","castArray","cloneWith","cloneDeep","cloneDeepWith","conformsTo","isBoolean","isElement","isEmpty","isEqual","isEqualWith","isError","nativeIsFinite","isInteger","isMatch","isMatchWith","isNumber","isNative","isMaskable","isNull","isNil","objectCtorString","isSafeInteger","isUndefined","isWeakMap","isWeakSet","symIterator","remainder","isBinary","toSafeInteger","properties","findKey","findLastKey","forIn","forInRight","forOwn","forOwnRight","functions","functionsIn","mapKeys","mapValues","omitBy","pickBy","prop","setWith","isArrLike","unset","updateWith","valuesIn","inRange","floating","capitalize","upperFirst","endsWith","escape","escapeRegExp","strLength","padEnd","padStart","radix","nativeParseInt","repeat","limit","startsWith","template","settings","templateSettings","assignInWith","isEscaping","isEvaluating","imports","importsKeys","importsValues","reDelimiters","evaluate","sourceURL","escapeValue","esTemplateValue","evaluateValue","variable","attempt","toLower","toUpper","trimEnd","trimStart","truncate","omission","search","newEnd","unescape","cond","conforms","defaultTo","matchesProperty","mixin","methodNames","noConflict","oldDash","nthArg","propertyOf","stubArray","stubFalse","stubObject","stubString","stubTrue","times","toPath","uniqueId","idCounter","maxBy","meanBy","minBy","sumBy","defaults","pick","arrayProto","funcProto","coreJsData","IE_PROTO","Buffer","getPrototypeOf","objectCreate","propertyIsEnumerable","isConcatSpreadable","toStringTag","ctxClearTimeout","ctxNow","ctxSetTimeout","nativeGetSymbols","getOwnPropertySymbols","nativeIsBuffer","DataView","Promise","WeakMap","metaMap","dataViewCtorString","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","symbolProto","baseSetToString","castRest","ArrayBuffer","resolve","ctorString","quote","difference","differenceBy","differenceWith","mapped","intersectionBy","intersectionWith","pull","pullAt","union","unionBy","unionWith","without","xor","xorBy","xorWith","zipWith","wrapperAt","countBy","findLast","groupBy","invokeMap","keyBy","sortBy","overArgs","funcsLength","partialRight","rearg","gt","gte","lt","lte","assign","assignIn","assignWith","at","defaultsDeep","mergeWith","invertBy","invoke","omit","toPairs","toPairsIn","camelCase","word","kebabCase","lowerCase","lowerFirst","snakeCase","startCase","upperCase","bindAll","flow","flowRight","methodOf","over","overEvery","overSome","rangeRight","augend","addend","divide","dividend","divisor","multiply","multiplier","multiplicand","subtract","minuend","subtrahend","entriesIn","extendWith","eachRight","isFilter","takeName","dropName","checkIteratee","isTaker","lodashFunc","retUnwrapped","isLazy","useLazy","isHybrid","isUnwrapped","onlyLazy","chainName","commit","toJSON","__g","anObject","IE8_DOM_DEFINE","toPrimitive","dP","O","Attributes","__esModule","instance","Constructor","_interopRequireDefault","obj","_defineProperty","_defineProperty2","defineProperties","descriptor","protoProps","staticProps","it","core","__e","createDesc","ctx","hide","PROTOTYPE","$export","own","IS_FORCED","F","IS_GLOBAL","G","IS_STATIC","IS_PROTO","IS_BIND","IS_WRAP","expProto","virtual","bitmap","shared","__webpack_exports__","_toString","val","makeMap","str","expectsLowerCase","remove$1","arr","item","hasOwn","isPrimitive","cached","hit","bind$1","boundFn","_length","ret","_from","OBJECT_STRING","toObject","res","genStaticKeys","modules","staticKeys","looseEqual","isObjectA","isObjectB","looseIndexOf","isReserved","def","parsePath","bailRE","pushTarget","_target","Dep","targetStack","popTarget","protoAugment","src","__proto__","copyAugment","observe","asRootData","ob","__ob__","Observer","observerState","shouldConvert","isServerRendering","isExtensible","_isVue","vmCount","defineReactive$$1","customSetter","dep","getOwnPropertyDescriptor","getter","childOb","depend","dependArray","newVal","notify","del","toVal","fromVal","mergeHook","parentVal","childVal","mergeAssets","normalizeProps","camelize","normalizeDirectives","dirs","directives","mergeOptions","vm","mergeField","strat","strats","defaultStrat","extendsFrom","extends","mixins","Vue$3","resolveAsset","warnMissing","assets","camelizedId","PascalCaseId","validateProp","propOptions","propsData","absent","Boolean","hyphenate","getPropDefaultValue","prevShouldConvert","$options","getType","len","createTextVNode","VNode","cloneVNode","vnode","cloned","elm","componentOptions","ns","isStatic","isCloned","cloneVNodes","vnodes","createComponent","baseCtor","_base","cid","resolved","resolveAsyncComponent","$forceUpdate","resolveConstructorOptions","extractProps","functional","createFunctionalComponent","nativeOn","abstract","mergeHooks","slots","resolveSlots","functionalContext","slot","createComponentInstanceForVnode","parentElm","refElm","vnodeComponentOptions","_isComponent","_componentTag","_parentVnode","_parentListeners","_renderChildren","_parentElm","_refElm","inlineTemplate","hydrating","componentInstance","_isDestroyed","activeInstance","$mount","keepAlive","mountedNode","prepatch","oldVnode","_updateFromParent","_isMounted","callHook","_inactive","destroy$1","$destroy","requested","cbs","pendingCallbacks","sync","reason","then","attrs","domProps","checkProp","preserve","hook","hooksToMerge","fromParent","ours","hooks","mergeHook$1","mergeVNodeHook","hookKey","injectedHash","__injected","oldHook","createEventHandle","invoker","arguments$1","updateListeners","oldOn","remove$$1","cur","old","normalizeEvent","simpleNormalizeChildren","normalizeChildren","normalizeArrayChildren","nestedIndex","getFirstComponentChild","normalizationType","alwaysNormalize","ALWAYS_NORMALIZE","_createElement","createEmptyVNode","scopedSlots","SIMPLE_NORMALIZE","config","getTagNamespace","isReservedTag","parsePlatformTagName","applyNS","initRender","$vnode","_vnode","_staticTrees","parentVnode","renderContext","$slots","$scopedSlots","_c","$createElement","renderMixin","Vue","markStatic","isOnce","markStaticNode","$nextTick","nextTick","_render","ref","_renderProxy","errorHandler","_s","_v","_n","_e","_q","_i","_m","isInFor","_o","_f","_l","fallback","bindObject","scopedSlotFn","slotNodes","_b","asProp","mustUseProp","eventKeyCode","builtInAlias","keyCodes","defaultSlot","isComment","initEvents","_events","_hasHookEvent","updateComponentListeners","$once","$on","remove$2","$off","oldListeners","eventsMixin","hookRE","$emit","initLifecycle","$parent","$children","$root","$refs","_watcher","_isBeingDestroyed","lifecycleMixin","_mount","el","$el","Watcher","_update","prevEl","prevVnode","prevActiveInstance","__patch__","__vue__","renderChildren","hasChildren","propKeys","_propKeys","teardown","_watchers","handlers","resetSchedulerState","has$1","waiting","flushing","flushSchedulerQueue","watcher","run","devtools","queueWatcher","traverse","seenObjects","_traverse","isA","depId","initState","opts","initProps","initMethods","initData","initComputed","watch","initWatch","isRoot","loop","proxy","userDef","computedSharedDefinition","makeComputedGetter","owner","lazy","dirty","handler","createWatcher","$watch","stateMixin","dataDef","$set","$delete","expOrFn","immediate","initMixin","_init","_uid","initInternalComponent","_self","super","superOptions","cachedSuperOptions","extendOptions","components","initUse","use","plugin","installed","install","initMixin$1","initExtend","Super","SuperId","cachedCtors","_Ctor","Sub","_assetTypes","initAssetRegisters","getComponentName","pruneCache","cachedNode","pruneCacheEntry","initGlobalAPI","configDef","util","delete","builtInComponents","genClassForVnode","childNode","mergeClassData","genClassFromData","staticClass","class","dynamicClass","stringifyClass","stringified","isSVG","isUnknownElement","inBrowser","unknownElementCache","HTMLUnknownElement","HTMLElement","query","createElement$1","tagName","namespaceMap","createTextNode","createComment","newNode","referenceNode","setTextContent","registerRef","isRemoval","refs","refInFor","isUndef","isDef","sameVnode","vnode1","vnode2","createKeyToOldIdx","beginIdx","endIdx","createPatchFunction","backend","emptyNodeAt","nodeOps","createRmCb","childElm","removeNode","createElm","insertedVnodeQueue","isRootInsert","setScope","createChildren","invokeCreateHooks","isReactivated","initComponent","reactivateComponent","pendingInsert","isPatchable","innerNode","activate","emptyNode","i$1","addVnodes","startIdx","invokeDestroyHook","destroy","removeVnodes","ch","removeAndInvokeRemoveHook","rm","updateChildren","oldCh","newCh","removeOnly","oldKeyToIdx","idxInOld","elmToMove","oldStartIdx","newStartIdx","oldEndIdx","oldStartVnode","oldEndVnode","newEndIdx","newStartVnode","newEndVnode","canMove","patchVnode","hasData","postpatch","invokeInsertHook","hydrate","hasChildNodes","childrenMatch","isRenderedModule","hooks$1","isInitialPatch","isRealElement","hasAttribute","oldElm","parentElm$1","_leaveCb","updateDirectives","oldDir","isCreate","isDestroy","oldDirs","normalizeDirectives$1","newDirs","dirsWithInsert","dirsWithPostpatch","oldValue","callHook$1","componentUpdated","inserted","callInsert","modifiers","emptyModifiers","getRawDirName","rawName","updateAttrs","oldAttrs","setAttr","isIE9","isXlink","xlinkNS","getXlinkProp","isEnumeratedAttr","isBooleanAttr","isFalsyAttrValue","updateClass","oldData","cls","transitionClass","_transitionClasses","_prevClass","add$2","oldHandler","target$1","ev","remove$3","updateDOMListeners","updateDOMProps","oldProps","strCur","shouldUpdateValue","checkVal","composing","isDirty","isInputChanged","activeElement","_vModifiers","normalizeStyleData","normalizeStyleBinding","staticStyle","bindingStyle","parseStyleText","getStyle","checkChild","styleData","updateStyle","oldStaticStyle","oldStyleBinding","oldStyle","newStyle","setProp","addClass","removeClass","tar","nextFrame","raf","addTransitionClass","removeTransitionClass","whenTransitionEnds","expectedType","getTransitionInfo","propCount","TRANSITION","transitionEndEvent","animationEndEvent","onEnd","styles","transitioneDelays","transitionProp","transitionDurations","transitionTimeout","getTimeout","animationDelays","animationProp","animationDurations","animationTimeout","ANIMATION","hasTransform","transformRE","delays","durations","toMs","Number","toggleDisplay","cancelled","resolveTransition","_enterCb","css","enterClass","enterToClass","enterActiveClass","appearClass","appearToClass","appearActiveClass","beforeEnter","afterEnter","enterCancelled","beforeAppear","appear","afterAppear","appearCancelled","transitionNode","isAppear","startClass","activeClass","toClass","beforeEnterHook","enterHook","afterEnterHook","enterCancelledHook","expectsCSS","userWantsControl","show","pendingNode","_pending","leave","performLeave","beforeLeave","leaveClass","leaveActiveClass","leaveToClass","afterLeave","leaveCancelled","delayLeave","def$$1","autoCssTransition","called","setSelected","isMultiple","multiple","selected","option","selectedIndex","hasNoMatchingOption","onCompositionStart","onCompositionEnd","trigger","locateNode","getRealChild","compOptions","extractTransitionData","comp","key$1","rawChild","hasParentTransition","isSameChild","oldChild","callPendingCbs","_moveCb","recordPosition","newPos","applyTranslation","oldPos","pos","WebkitTransform","transitionDuration","shouldDecode","content","encoded","div","decode","decoder","decodeAttr","shouldDecodeNewlines","nlRE","ltRE","gtRE","ampRE","quoteRE","parseHTML","advance","parseStartTag","startTagOpen","startTagClose","attribute","unarySlash","handleStartTag","expectHTML","lastTag","isNonPhrasingTag","parseEndTag","canBeLeftOpenTag","isUnaryTag$$1","IS_REGEX_CAPTURING_BROKEN","lowerCasedTag","lowerCasedTagName","isUnaryTag","no","isScriptOrStyle","stackedTag","reStackedTag","reCache","endTagLength","all","endTag","textEnd","comment","commentEnd","conditionalComment","conditionalEnd","doctypeMatch","doctype","endTagMatch","curIndex","startTagMatch","rest$1","parseFilters","pushFilter","filters","lastFilterIndex","prev","expression","inSingle","inDouble","inTemplateString","inRegex","curly","paren","wrapFilter","parseText","delimiters","tagRE","buildRegex","defaultTagRE","tokens","baseWarn","msg","console","pluckModuleFunction","addProp","addAttr","addDirective","addHandler","important","events","native","nativeEvents","newHandler","getBindingAttr","getStatic","dynamicValue","getAndRemoveAttr","staticValue","attrsMap","attrsList","parseModel","expressionPos","expressionEndPos","idx","eof","isStringStart","parseString","parseBracket","inBracket","stringQuote","warn$1","warn","platformGetTagNamespace","platformMustUseProp","platformIsPreTag","isPreTag","preTransforms","postTransforms","currentParent","preserveWhitespace","inVPre","inPre","checkRootConstraints","isIE","guardIESVGBug","makeAttrsMap","isForbiddenTag","forbidden","processPre","pre","processRawAttrs","processFor","processIf","processOnce","processKey","plain","processRef","processSlot","processComponent","processAttrs","if","elseif","else","addIfCondition","block","processIfConditions","slotScope","slotTarget","i$2","lastNode","decodeHTMLCached","checkInFor","inMatch","forAliasRE","for","alias","iteratorMatch","forIteratorRE","iterator1","iterator2","findPrevElement","condition","ifConditions","slotName","component","isProp","dirRE","hasBindings","parseModifiers","modifierRE","bindRE","camel","onRE","argMatch","argRE","ieNSBug","ieNSPrefix","optimize","isStaticKey","genStaticKeysCached","isPlatformReservedTag","markStaticRoots","genStaticKeys$1","static","staticInFor","staticRoot","walkThroughConditionsBlocks","conditionBlocks","isBuiltInTag","isDirectChildOfTemplateFor","genHandlers","genHandler","modifierCode","genKeyFilter","handlerCode","simplePathRE","fnExpRE","genFilterCode","keyVal","bind$2","wrapData","generate","ast","prevStaticRenderFns","currentStaticRenderFns","prevOnceCount","onceCount","currentOptions","warn$2","transforms$1","dataGenFns","platformDirectives$1","isPlatformReservedTag$1","genElement","staticProcessed","genStatic","onceProcessed","genOnce","forProcessed","genFor","ifProcessed","genIf","genSlot","genComponent","genData","genChildren","genIfConditions","conditions","genTernaryExp","genDirectives","genProps","genScopedSlots","genInlineTemplate","needRuntime","hasRuntime","gen","baseDirectives","inlineRenderFns","genScopedSlot","scope","checkSkip","el$1","getNormalizationType","genNode","needsNormalization","maybeComponent","genText","transformSpecialNewlines","bind$$1","componentName","compile$1","transformNode","classBinding","genData$1","transformNode$1","styleBinding","genData$2","model$1","_warn","warn$3","genSelect","genCheckboxModel","genRadioModel","genDefaultModel","valueBinding","trueValueBinding","falseValueBinding","genAssignmentCode","needCompositionGuard","valueExpression","assignment","modelRs","compile$$1","baseOptions","compileToFunctions","compiled","makeFunction","getOuterHTML","outerHTML","cloneNode","_isServer","_Set","camelizeRE","hyphenateRE","optionMergeStrategies","silent","ignoredElements","_lifecycleHooks","_maxUpdateCount","hasProto","UA","navigator","userAgent","isEdge","isAndroid","isIOS","env","VUE_ENV","__VUE_DEVTOOLS_GLOBAL_HOOK__","nextTickHandler","pending","copies","callbacks","timerFunc","logError","err","catch","MutationObserver","counter","observer","textNode","characterData","_resolve","formatComponentName","uid$1","subs","addSub","sub","removeSub","addDep","arrayMethods","original","observeArray","arrayKeys","getOwnPropertyNames","isSettingProps","augment","walk","items","instanceData","defaultData","freeze","defineReactive","raw","prototypeAccessors","uid$2","deep","deps","newDeps","depIds","newDepIds","cleanupDeps","this$1","tmp","patternTypes","KeepAlive","include","exclude","created","destroyed","testEl","acceptValue","math","isHTMLTag","baseModules","klass","cssText","listDelimiter","propertyDelimiter","cssVarRE","importantRE","normalize","prefixed","hasTransition","ontransitionend","onwebkittransitionend","onanimationend","onwebkitanimationend","platformModules","patch$1","vmodel","model","needReset","originalDisplay","__vOriginalDisplay","display","unbind","platformDirectives","transitionProps","_leaving","oldRawChild","delayedLeave","moveClass","TransitionGroup","prevChildren","rawChildren","transitionData","kept","removed","c$1","beforeUpdate","updated","hasMove","body","offsetHeight","propertyName","_hasMove","info","platformComponents","singleAttrIdentifier","singleAttrAssign","singleAttrValues","ncname","qnameCapture","regexEscapeRE","close","esc","tab","up","down","prevent","ctrl","alt","meta","cloak","klass$1","style$1","modules$1","directives$1","idToTemplate","mount","compile","aFunction","is","TAG","stat","SHARED","IObject","eval","Promise$1","executor","PENDING","deferred","promise","PromiseObj","debug","ntick","isBlob","Blob","isFormData","FormData","when","fulfilled","rejected","$vm","_merge","_assign","variables","tmpl","expanded","vars","operators","literal","substr","getValues","encodeReserved","modifier","isDefined","encodeValue","isKeyOperator","encodeURIComponent","part","encodeURI","Url","options$$1","serialize","isJson","[","{","sendRequest","client","xhrClient","nodeClient","getName","curr","normalizeName","blobText","reader","FileReader","readAsText","isBlobText","Http","Client","interceptors","Request","ok","Resource","resource","$http","Util","http","$url","$resource","$promise","RESOLVED","REJECTED","race","p$1","onResolved","onRejected","finally","ref$1","urlParams","documentMode","href","protocol","port","host","hostname","pathname","xdrClient","xdr","respondWith","getUrl","onabort","getBody","SUPPORTS_CORS","cors","orgUrl","reqUrl","crossOrigin","emulateHTTP","emulateJSON","bodyText","jsonpClient","script","jsonp","jsonpCallback","async","common","SUPPORTS_BLOB","statusText","getAllResponseHeaders","progress","upload","credentials","withCredentials","resp","statusCode","statusMessage","error$$1","reqHandlers","resHandlers","Headers","getAll","deleteAll","Response","bodyBlob","blob","COMMON_HEADERS","Accept","JSON_CONTENT_TYPE","Content-Type","put","patch","method$$1","body$$1","save","_from2","arr2","$Object","desc","toIObject","toIndex","IS_INCLUDES","$this","cof","ARG","tryGet","callee","$defineProperty","Iterators","ITERATOR","ArrayProto","setToStringTag","IteratorPrototype","NAME","LIBRARY","redefine","$iterCreate","BUGGY","FF_ITERATOR","KEYS","VALUES","returnThis","Base","DEFAULT","IS_SET","FORCED","getMethod","kind","DEF_VALUES","VALUES_BUG","$native","$default","$entries","$anyNative","SAFE_CLOSING","riter","skipClosing","safe","iter","dPs","enumBugKeys","Empty","createDict","iframeDocument","iframe","contentWindow","write","Properties","getKeys","ObjectProto","arrayIndexOf","$keys","TO_STRING","classof","getIteratorMethod","isArrayIter","createProperty","getIterFn","arrayLike","aLen","mapfn","mapping","iterFn","$at","iterated","__WEBPACK_IMPORTED_MODULE_0__src_dsv__","__WEBPACK_IMPORTED_MODULE_0__dsv__","rotateArray","geomifyObject","geomifyObjectType","geomifyGeometry","geomifyFeature","bbox","geomifyGeometryType","hashArc","equalArc","arcA","arcB","ia","ja","ib","jb","filterTrue","filterIdentity","filterNotNull","feature$1","topology","transformPoint","reverse$1","meshArcs","object$$1","extractArcs","stitch","extract0","geomsByArc","geom","extract1","extract2","extract3","geoms","planarRingArea","mergeArcs","objects","extract","polygonsByArc","neighbors","planarTriangleArea","planarRingArea$1","quantile$1","sphericalRingArea","interior","fourPi","sphericalTriangleArea","cosPhi2","sinPhi2","boundGeometry","boundGeometryType","boundPoint","boundLine","boundMultiLine","hashset","equal","mask","collisions","hashmap","keyType","keyEmpty","valueType","matchKey","keystore","valstore","maybeSet","missingValue","equalPoint","pointA","pointB","floats","Float64Array","uints","Uint32Array","hashPoint","previousIndex","currentIndex","nextIndex","visitedByIndex","leftByIndex","rightByIndex","junctionCount","junctionByIndex","indexByPoint","hashIndex","equalIndex","Int32Array","rings","Int8Array","junctionByPoint","cut","junctions","lineMid","1","ringMid","ringFixed","dedup","dedupLine","startPoint","endPoint","startArcs","startArc","endArcs","endArc","arcsByEnd","equalLine","reverseEqualLine","dedupRing","equalRing","reverseEqualRing","findMinimumOffset","kb","minimum","minimumPoint","arcCount","extractGeometry","extractGeometryType","extractLine","extractRing","extractMultiRing","prequantize","quantizePoint","quantizeLine","pj","quantizeGeometry","quantizeGeometryType","quantization","indexGeometry","geometry$$1","indexGeometryType","indexArcs","indexByArc","indexMultiArcs","prune","pruneGeometry","pruneArcs","pruneMultiArcs","newIndex","oldIndex","oldReverse","newIndexByOldIndex","newArcIndex","newArcs","oldArcs","filterGeometry","filterRings","filterExteriorRing","filterInteriorRing","filterAttached","testGeometry","testArcs","ringIndex","uniqueRing","uniqueRingByArc","bboxPoint","bboxGeometry","ends","fragmentByEnd","fragmentByStart","stitchedArcs","fragments","emptyIndex","fg","gf","mesh","indexesByArc","geometryType","ij","ik","bb","untransform","filterWeight","minWeight","weight","MIN_VALUE","newHeap","heap","presimplify","absolute","relative","maxWeight","simplify","resolveProps","route","resolveQuery","extraQuery","parsedQuery","parseQuery","param","parts","stringifyQuery","encode","val2","createRoute","record","redirectedFrom","fullPath","getFullPath","matched","formatMatch","isSameRoute","START","trailingSlashRE","isObjectEqual","aKeys","bKeys","isIncludedRoute","queryIncludes","guardEvent","ctrlKey","defaultPrevented","findAnchor","_Vue","_router","_route","beforeCreate","router","history","View","Link","beforeRouteEnter","beforeRouteLeave","resolvePath","queryIndex","cleanPath","createRouteMap","routes","oldPathMap","oldNameMap","pathMap","nameMap","addRouteRecord","matchAs","normalizePath","instances","redirect","childMatchAs","aliasRoute","defaultDelimiter","PATH_REGEXP","escaped","asterisk","escapeGroup","escapeString","tokensToFunction","encodeURIComponentPretty","encodeAsterisk","pretty","isarray","attachKeys","flags","sensitive","regexpToRegexp","arrayToRegexp","pathToRegexp","stringToRegexp","tokensToRegExp","strict","endsWithDelimiter","getRouteRegex","regexpCache","fillParams","routeMsg","filler","regexpCompileCache","normalizeLocation","_normalized","rawPath","parsedPath","basePath","createMatcher","addRoutes","currentRoute","paramNames","_createRoute","matchRoute","originalRedirect","resolveRecordPath","resolvedPath","aliasedPath","aliasedMatch","aliasedRecord","decodeURIComponent","setupScroll","saveScrollPosition","setStateKey","handleScroll","isPop","app","behavior","scrollBehavior","getScrollPosition","shouldScroll","getElementPosition","isValidPosition","normalizePosition","scrollTo","getStateKey","positionStore","pageXOffset","pageYOffset","docRect","elRect","genKey","Time","_key","pushState","replaceState","runQueue","normalizeBase","baseEl","resolveQueue","activated","deactivated","extractGuards","records","guards","flatMapComponents","extractGuard","extractLeaveGuards","bindGuard","extractUpdateHooks","extractEnterGuards","isValid","bindEnterGuard","poll","resolveAsyncComponents","resolvedDef","getLocation","checkFallback","ensureSlash","getHash","replaceHash","pushHash","createHref","routerView","$route","_routerViewCache","inactive","routerViewDepth","encodeReserveRE","encodeReserveReplacer","commaRE","toTypes","eventTypes","exact","$router","classes","linkActiveClass","compareTarget","click","aData","aAttrs","parse_1","compile_1","tokensToFunction_1","tokensToRegExp_1","supportsPushState","ua","History","ready","readyCbs","listen","onReady","transitionTo","onComplete","onAbort","confirmTransition","updateRoute","ensureURL","beforeHooks","postEnterCbs","enterGuards","afterHooks","HTML5History","History$$1","expectScroll","go","getCurrentLocation","HashHistory","setupListeners","AbstractHistory","targetIndex","VueRouter","apps","setupHashListener","beforeEach","afterEach","back","getMatchedComponents","normalizedTo","newStyles","media","sourceMap","webpackPolyfill","deprecate","mediaQuery","alreadyImportedModules","addStylesToDom","domStyle","stylesInDom","addStyle","listToStyles","createStyleElement","styleElement","hasSSR","isProduction","isOldIE","styleIndex","singletonCounter","singletonElement","applyToSingletonTag","applyToTag","newObj","styleSheet","replaceText","childNodes","btoa","hasDocument","DEBUG","getElementsByTagName","_isProduction","newList","mayRemove","textStore","replacement"],"mappings":"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B,EAAAmuB,QACAnuB,EAAAklB,UACAllB,EAAAoiB,QACApiB,EAAAkgB,WACAlgB,EAAAkvB,QACAlvB,EAAAmtB,YACAntB,EAAAmvB,aACAnvB,EAAAovB,YACApvB,EAAAyiB,WACAziB,EAAAqtB,gBACArtB,EAAAp/B,aACAo/B,EAAA2pB,QACA3pB,EAAAmlB,UACAnlB,EAAAvvF,YACAuvF,EAAA4oB,cACA5oB,EAAAksB,QACAlsB,EAAAyd,WACAzd,EAAA0d,aACA1d,EAAA2d,eACA3d,EAAAmsB,UACAnsB,EAAArvG,SACAqvG,EAAAqvB,cACArvB,EAAAstB,SACAttB,EAAAogB,UACApgB,EAAAztG,UACAytG,EAAAqiB,QACAriB,EAAAt5E,WACAs5E,EAAAugB,cACAvgB,EAAAzrG,OACAyrG,EAAAqlB,WACArlB,EAAAvoD,WACAuoD,EAAAjtG,SACAitG,EAAAktB,UACAltB,EAAAme,cACAne,EAAAoe,gBACApe,EAAAjsG,SACAisG,EAAAsiB,UACAtiB,EAAAvtE,QACAutE,EAAAqe,QACAre,EAAAse,aACAte,EAAAue,kBACAve,EAAAwe,aACAxe,EAAAif,OACAjf,EAAAuiB,YACAviB,EAAA8W,QACA9W,EAAAsf,WACAtf,EAAAouB,WACApuB,EAAAquB,aACAruB,EAAAmpB,UACAnpB,EAAAoO,iBACApO,EAAAxvG,aACAwvG,EAAAwiB,SACAxiB,EAAAosB,SACApsB,EAAAqsB,WACArsB,EAAAssB,aACAtsB,EAAAye,QACAze,EAAA0e,UACA1e,EAAA2e,YACA3e,EAAAulB,SACAvlB,EAAA4e,SACA5e,EAAA6e,aACA7e,EAAA7nG,UACA6nG,EAAAwlB,cACAxlB,EAAApwG,UACAowG,EAAAylB,YACAzlB,EAAAusB,WACAvsB,EAAA+V,SACA/V,EAAA5oG,QACA4oG,EAAAwsB,OACAxsB,EAAAysB,SACAzsB,EAAA0sB,WACA1sB,EAAApoD,OACAooD,EAAA8e,aACA9e,EAAA+e,iBACA/e,EAAA2sB,WAGA3sB,EAAApvC,QAAAw9D,GACApuB,EAAAiwB,UAA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","file":"static/js/vendor.03b56a03b17565331709.js","sourcesContent":["webpackJsonp([0,2],[\n/* 0 */\n/***/ (function(module, exports) {\n\nmodule.exports = function normalizeComponent (\n  rawScriptExports,\n  compiledTemplate,\n  scopeId,\n  cssModules\n) {\n  var esModule\n  var scriptExports = rawScriptExports = rawScriptExports || {}\n\n  // ES6 modules interop\n  var type = typeof rawScriptExports.default\n  if (type === 'object' || type === 'function') {\n    esModule = rawScriptExports\n    scriptExports = rawScriptExports.default\n  }\n\n  // Vue.extend constructor export interop\n  var options = typeof scriptExports === 'function'\n    ? scriptExports.options\n    : scriptExports\n\n  // render functions\n  if (compiledTemplate) {\n    options.render = compiledTemplate.render\n    options.staticRenderFns = compiledTemplate.staticRenderFns\n  }\n\n  // scopedId\n  if (scopeId) {\n    options._scopeId = scopeId\n  }\n\n  // inject cssModules\n  if (cssModules) {\n    var computed = options.computed || (options.computed = {})\n    Object.keys(cssModules).forEach(function (key) {\n      var module = cssModules[key]\n      computed[key] = function () { return module }\n    })\n  }\n\n  return {\n    esModule: esModule,\n    exports: scriptExports,\n    options: options\n  }\n}\n\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// https://d3js.org Version 4.6.0. Copyright 2017 Mike Bostock.\n(function (global, factory) {\n\t true ? factory(exports) :\n\ttypeof define === 'function' && define.amd ? define(['exports'], factory) :\n\t(factory((global.d3 = global.d3 || {})));\n}(this, (function (exports) { 'use strict';\n\nvar version = \"4.6.0\";\n\nvar ascending = function(a, b) {\n  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;\n};\n\nvar bisector = function(compare) {\n  if (compare.length === 1) compare = ascendingComparator(compare);\n  return {\n    left: function(a, x, lo, hi) {\n      if (lo == null) lo = 0;\n      if (hi == null) hi = a.length;\n      while (lo < hi) {\n        var mid = lo + hi >>> 1;\n        if (compare(a[mid], x) < 0) lo = mid + 1;\n        else hi = mid;\n      }\n      return lo;\n    },\n    right: function(a, x, lo, hi) {\n      if (lo == null) lo = 0;\n      if (hi == null) hi = a.length;\n      while (lo < hi) {\n        var mid = lo + hi >>> 1;\n        if (compare(a[mid], x) > 0) hi = mid;\n        else lo = mid + 1;\n      }\n      return lo;\n    }\n  };\n};\n\nfunction ascendingComparator(f) {\n  return function(d, x) {\n    return ascending(f(d), x);\n  };\n}\n\nvar ascendingBisect = bisector(ascending);\nvar bisectRight = ascendingBisect.right;\nvar bisectLeft = ascendingBisect.left;\n\nvar descending = function(a, b) {\n  return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;\n};\n\nvar number = function(x) {\n  return x === null ? NaN : +x;\n};\n\nvar variance = function(array, f) {\n  var n = array.length,\n      m = 0,\n      a,\n      d,\n      s = 0,\n      i = -1,\n      j = 0;\n\n  if (f == null) {\n    while (++i < n) {\n      if (!isNaN(a = number(array[i]))) {\n        d = a - m;\n        m += d / ++j;\n        s += d * (a - m);\n      }\n    }\n  }\n\n  else {\n    while (++i < n) {\n      if (!isNaN(a = number(f(array[i], i, array)))) {\n        d = a - m;\n        m += d / ++j;\n        s += d * (a - m);\n      }\n    }\n  }\n\n  if (j > 1) return s / (j - 1);\n};\n\nvar deviation = function(array, f) {\n  var v = variance(array, f);\n  return v ? Math.sqrt(v) : v;\n};\n\nvar extent = function(array, f) {\n  var i = -1,\n      n = array.length,\n      a,\n      b,\n      c;\n\n  if (f == null) {\n    while (++i < n) if ((b = array[i]) != null && b >= b) { a = c = b; break; }\n    while (++i < n) if ((b = array[i]) != null) {\n      if (a > b) a = b;\n      if (c < b) c = b;\n    }\n  }\n\n  else {\n    while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = c = b; break; }\n    while (++i < n) if ((b = f(array[i], i, array)) != null) {\n      if (a > b) a = b;\n      if (c < b) c = b;\n    }\n  }\n\n  return [a, c];\n};\n\nvar array = Array.prototype;\n\nvar slice = array.slice;\nvar map = array.map;\n\nvar constant = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nvar identity = function(x) {\n  return x;\n};\n\nvar sequence = function(start, stop, step) {\n  start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;\n\n  var i = -1,\n      n = Math.max(0, Math.ceil((stop - start) / step)) | 0,\n      range = new Array(n);\n\n  while (++i < n) {\n    range[i] = start + i * step;\n  }\n\n  return range;\n};\n\nvar e10 = Math.sqrt(50);\nvar e5 = Math.sqrt(10);\nvar e2 = Math.sqrt(2);\n\nvar ticks = function(start, stop, count) {\n  var step = tickStep(start, stop, count);\n  return sequence(\n    Math.ceil(start / step) * step,\n    Math.floor(stop / step) * step + step / 2, // inclusive\n    step\n  );\n};\n\nfunction tickStep(start, stop, count) {\n  var step0 = Math.abs(stop - start) / Math.max(0, count),\n      step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)),\n      error = step0 / step1;\n  if (error >= e10) step1 *= 10;\n  else if (error >= e5) step1 *= 5;\n  else if (error >= e2) step1 *= 2;\n  return stop < start ? -step1 : step1;\n}\n\nvar sturges = function(values) {\n  return Math.ceil(Math.log(values.length) / Math.LN2) + 1;\n};\n\nvar histogram = function() {\n  var value = identity,\n      domain = extent,\n      threshold = sturges;\n\n  function histogram(data) {\n    var i,\n        n = data.length,\n        x,\n        values = new Array(n);\n\n    for (i = 0; i < n; ++i) {\n      values[i] = value(data[i], i, data);\n    }\n\n    var xz = domain(values),\n        x0 = xz[0],\n        x1 = xz[1],\n        tz = threshold(values, x0, x1);\n\n    // Convert number of thresholds into uniform thresholds.\n    if (!Array.isArray(tz)) tz = ticks(x0, x1, tz);\n\n    // Remove any thresholds outside the domain.\n    var m = tz.length;\n    while (tz[0] <= x0) tz.shift(), --m;\n    while (tz[m - 1] >= x1) tz.pop(), --m;\n\n    var bins = new Array(m + 1),\n        bin;\n\n    // Initialize bins.\n    for (i = 0; i <= m; ++i) {\n      bin = bins[i] = [];\n      bin.x0 = i > 0 ? tz[i - 1] : x0;\n      bin.x1 = i < m ? tz[i] : x1;\n    }\n\n    // Assign data to bins by value, ignoring any outside the domain.\n    for (i = 0; i < n; ++i) {\n      x = values[i];\n      if (x0 <= x && x <= x1) {\n        bins[bisectRight(tz, x, 0, m)].push(data[i]);\n      }\n    }\n\n    return bins;\n  }\n\n  histogram.value = function(_) {\n    return arguments.length ? (value = typeof _ === \"function\" ? _ : constant(_), histogram) : value;\n  };\n\n  histogram.domain = function(_) {\n    return arguments.length ? (domain = typeof _ === \"function\" ? _ : constant([_[0], _[1]]), histogram) : domain;\n  };\n\n  histogram.thresholds = function(_) {\n    return arguments.length ? (threshold = typeof _ === \"function\" ? _ : Array.isArray(_) ? constant(slice.call(_)) : constant(_), histogram) : threshold;\n  };\n\n  return histogram;\n};\n\nvar threshold = function(array, p, f) {\n  if (f == null) f = number;\n  if (!(n = array.length)) return;\n  if ((p = +p) <= 0 || n < 2) return +f(array[0], 0, array);\n  if (p >= 1) return +f(array[n - 1], n - 1, array);\n  var n,\n      h = (n - 1) * p,\n      i = Math.floor(h),\n      a = +f(array[i], i, array),\n      b = +f(array[i + 1], i + 1, array);\n  return a + (b - a) * (h - i);\n};\n\nvar freedmanDiaconis = function(values, min, max) {\n  values = map.call(values, number).sort(ascending);\n  return Math.ceil((max - min) / (2 * (threshold(values, 0.75) - threshold(values, 0.25)) * Math.pow(values.length, -1 / 3)));\n};\n\nvar scott = function(values, min, max) {\n  return Math.ceil((max - min) / (3.5 * deviation(values) * Math.pow(values.length, -1 / 3)));\n};\n\nvar max = function(array, f) {\n  var i = -1,\n      n = array.length,\n      a,\n      b;\n\n  if (f == null) {\n    while (++i < n) if ((b = array[i]) != null && b >= b) { a = b; break; }\n    while (++i < n) if ((b = array[i]) != null && b > a) a = b;\n  }\n\n  else {\n    while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = b; break; }\n    while (++i < n) if ((b = f(array[i], i, array)) != null && b > a) a = b;\n  }\n\n  return a;\n};\n\nvar mean = function(array, f) {\n  var s = 0,\n      n = array.length,\n      a,\n      i = -1,\n      j = n;\n\n  if (f == null) {\n    while (++i < n) if (!isNaN(a = number(array[i]))) s += a; else --j;\n  }\n\n  else {\n    while (++i < n) if (!isNaN(a = number(f(array[i], i, array)))) s += a; else --j;\n  }\n\n  if (j) return s / j;\n};\n\nvar median = function(array, f) {\n  var numbers = [],\n      n = array.length,\n      a,\n      i = -1;\n\n  if (f == null) {\n    while (++i < n) if (!isNaN(a = number(array[i]))) numbers.push(a);\n  }\n\n  else {\n    while (++i < n) if (!isNaN(a = number(f(array[i], i, array)))) numbers.push(a);\n  }\n\n  return threshold(numbers.sort(ascending), 0.5);\n};\n\nvar merge = function(arrays) {\n  var n = arrays.length,\n      m,\n      i = -1,\n      j = 0,\n      merged,\n      array;\n\n  while (++i < n) j += arrays[i].length;\n  merged = new Array(j);\n\n  while (--n >= 0) {\n    array = arrays[n];\n    m = array.length;\n    while (--m >= 0) {\n      merged[--j] = array[m];\n    }\n  }\n\n  return merged;\n};\n\nvar min = function(array, f) {\n  var i = -1,\n      n = array.length,\n      a,\n      b;\n\n  if (f == null) {\n    while (++i < n) if ((b = array[i]) != null && b >= b) { a = b; break; }\n    while (++i < n) if ((b = array[i]) != null && a > b) a = b;\n  }\n\n  else {\n    while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = b; break; }\n    while (++i < n) if ((b = f(array[i], i, array)) != null && a > b) a = b;\n  }\n\n  return a;\n};\n\nvar pairs = function(array) {\n  var i = 0, n = array.length - 1, p = array[0], pairs = new Array(n < 0 ? 0 : n);\n  while (i < n) pairs[i] = [p, p = array[++i]];\n  return pairs;\n};\n\nvar permute = function(array, indexes) {\n  var i = indexes.length, permutes = new Array(i);\n  while (i--) permutes[i] = array[indexes[i]];\n  return permutes;\n};\n\nvar scan = function(array, compare) {\n  if (!(n = array.length)) return;\n  var i = 0,\n      n,\n      j = 0,\n      xi,\n      xj = array[j];\n\n  if (!compare) compare = ascending;\n\n  while (++i < n) if (compare(xi = array[i], xj) < 0 || compare(xj, xj) !== 0) xj = xi, j = i;\n\n  if (compare(xj, xj) === 0) return j;\n};\n\nvar shuffle = function(array, i0, i1) {\n  var m = (i1 == null ? array.length : i1) - (i0 = i0 == null ? 0 : +i0),\n      t,\n      i;\n\n  while (m) {\n    i = Math.random() * m-- | 0;\n    t = array[m + i0];\n    array[m + i0] = array[i + i0];\n    array[i + i0] = t;\n  }\n\n  return array;\n};\n\nvar sum = function(array, f) {\n  var s = 0,\n      n = array.length,\n      a,\n      i = -1;\n\n  if (f == null) {\n    while (++i < n) if (a = +array[i]) s += a; // Note: zero and null are equivalent.\n  }\n\n  else {\n    while (++i < n) if (a = +f(array[i], i, array)) s += a;\n  }\n\n  return s;\n};\n\nvar transpose = function(matrix) {\n  if (!(n = matrix.length)) return [];\n  for (var i = -1, m = min(matrix, length), transpose = new Array(m); ++i < m;) {\n    for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n;) {\n      row[j] = matrix[j][i];\n    }\n  }\n  return transpose;\n};\n\nfunction length(d) {\n  return d.length;\n}\n\nvar zip = function() {\n  return transpose(arguments);\n};\n\nvar slice$1 = Array.prototype.slice;\n\nvar identity$1 = function(x) {\n  return x;\n};\n\nvar top = 1;\nvar right = 2;\nvar bottom = 3;\nvar left = 4;\nvar epsilon = 1e-6;\n\nfunction translateX(scale0, scale1, d) {\n  var x = scale0(d);\n  return \"translate(\" + (isFinite(x) ? x : scale1(d)) + \",0)\";\n}\n\nfunction translateY(scale0, scale1, d) {\n  var y = scale0(d);\n  return \"translate(0,\" + (isFinite(y) ? y : scale1(d)) + \")\";\n}\n\nfunction center(scale) {\n  var offset = scale.bandwidth() / 2;\n  if (scale.round()) offset = Math.round(offset);\n  return function(d) {\n    return scale(d) + offset;\n  };\n}\n\nfunction entering() {\n  return !this.__axis;\n}\n\nfunction axis(orient, scale) {\n  var tickArguments = [],\n      tickValues = null,\n      tickFormat = null,\n      tickSizeInner = 6,\n      tickSizeOuter = 6,\n      tickPadding = 3;\n\n  function axis(context) {\n    var values = tickValues == null ? (scale.ticks ? scale.ticks.apply(scale, tickArguments) : scale.domain()) : tickValues,\n        format = tickFormat == null ? (scale.tickFormat ? scale.tickFormat.apply(scale, tickArguments) : identity$1) : tickFormat,\n        spacing = Math.max(tickSizeInner, 0) + tickPadding,\n        transform = orient === top || orient === bottom ? translateX : translateY,\n        range = scale.range(),\n        range0 = range[0] + 0.5,\n        range1 = range[range.length - 1] + 0.5,\n        position = (scale.bandwidth ? center : identity$1)(scale.copy()),\n        selection = context.selection ? context.selection() : context,\n        path = selection.selectAll(\".domain\").data([null]),\n        tick = selection.selectAll(\".tick\").data(values, scale).order(),\n        tickExit = tick.exit(),\n        tickEnter = tick.enter().append(\"g\").attr(\"class\", \"tick\"),\n        line = tick.select(\"line\"),\n        text = tick.select(\"text\"),\n        k = orient === top || orient === left ? -1 : 1,\n        x, y = orient === left || orient === right ? (x = \"x\", \"y\") : (x = \"y\", \"x\");\n\n    path = path.merge(path.enter().insert(\"path\", \".tick\")\n        .attr(\"class\", \"domain\")\n        .attr(\"stroke\", \"#000\"));\n\n    tick = tick.merge(tickEnter);\n\n    line = line.merge(tickEnter.append(\"line\")\n        .attr(\"stroke\", \"#000\")\n        .attr(x + \"2\", k * tickSizeInner)\n        .attr(y + \"1\", 0.5)\n        .attr(y + \"2\", 0.5));\n\n    text = text.merge(tickEnter.append(\"text\")\n        .attr(\"fill\", \"#000\")\n        .attr(x, k * spacing)\n        .attr(y, 0.5)\n        .attr(\"dy\", orient === top ? \"0em\" : orient === bottom ? \"0.71em\" : \"0.32em\"));\n\n    if (context !== selection) {\n      path = path.transition(context);\n      tick = tick.transition(context);\n      line = line.transition(context);\n      text = text.transition(context);\n\n      tickExit = tickExit.transition(context)\n          .attr(\"opacity\", epsilon)\n          .attr(\"transform\", function(d) { return transform(position, this.parentNode.__axis || position, d); });\n\n      tickEnter\n          .attr(\"opacity\", epsilon)\n          .attr(\"transform\", function(d) { return transform(this.parentNode.__axis || position, position, d); });\n    }\n\n    tickExit.remove();\n\n    path\n        .attr(\"d\", orient === left || orient == right\n            ? \"M\" + k * tickSizeOuter + \",\" + range0 + \"H0.5V\" + range1 + \"H\" + k * tickSizeOuter\n            : \"M\" + range0 + \",\" + k * tickSizeOuter + \"V0.5H\" + range1 + \"V\" + k * tickSizeOuter);\n\n    tick\n        .attr(\"opacity\", 1)\n        .attr(\"transform\", function(d) { return transform(position, position, d); });\n\n    line\n        .attr(x + \"2\", k * tickSizeInner);\n\n    text\n        .attr(x, k * spacing)\n        .text(format);\n\n    selection.filter(entering)\n        .attr(\"fill\", \"none\")\n        .attr(\"font-size\", 10)\n        .attr(\"font-family\", \"sans-serif\")\n        .attr(\"text-anchor\", orient === right ? \"start\" : orient === left ? \"end\" : \"middle\");\n\n    selection\n        .each(function() { this.__axis = position; });\n  }\n\n  axis.scale = function(_) {\n    return arguments.length ? (scale = _, axis) : scale;\n  };\n\n  axis.ticks = function() {\n    return tickArguments = slice$1.call(arguments), axis;\n  };\n\n  axis.tickArguments = function(_) {\n    return arguments.length ? (tickArguments = _ == null ? [] : slice$1.call(_), axis) : tickArguments.slice();\n  };\n\n  axis.tickValues = function(_) {\n    return arguments.length ? (tickValues = _ == null ? null : slice$1.call(_), axis) : tickValues && tickValues.slice();\n  };\n\n  axis.tickFormat = function(_) {\n    return arguments.length ? (tickFormat = _, axis) : tickFormat;\n  };\n\n  axis.tickSize = function(_) {\n    return arguments.length ? (tickSizeInner = tickSizeOuter = +_, axis) : tickSizeInner;\n  };\n\n  axis.tickSizeInner = function(_) {\n    return arguments.length ? (tickSizeInner = +_, axis) : tickSizeInner;\n  };\n\n  axis.tickSizeOuter = function(_) {\n    return arguments.length ? (tickSizeOuter = +_, axis) : tickSizeOuter;\n  };\n\n  axis.tickPadding = function(_) {\n    return arguments.length ? (tickPadding = +_, axis) : tickPadding;\n  };\n\n  return axis;\n}\n\nfunction axisTop(scale) {\n  return axis(top, scale);\n}\n\nfunction axisRight(scale) {\n  return axis(right, scale);\n}\n\nfunction axisBottom(scale) {\n  return axis(bottom, scale);\n}\n\nfunction axisLeft(scale) {\n  return axis(left, scale);\n}\n\nvar noop = {value: function() {}};\n\nfunction dispatch() {\n  for (var i = 0, n = arguments.length, _ = {}, t; i < n; ++i) {\n    if (!(t = arguments[i] + \"\") || (t in _)) throw new Error(\"illegal type: \" + t);\n    _[t] = [];\n  }\n  return new Dispatch(_);\n}\n\nfunction Dispatch(_) {\n  this._ = _;\n}\n\nfunction parseTypenames(typenames, types) {\n  return typenames.trim().split(/^|\\s+/).map(function(t) {\n    var name = \"\", i = t.indexOf(\".\");\n    if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);\n    if (t && !types.hasOwnProperty(t)) throw new Error(\"unknown type: \" + t);\n    return {type: t, name: name};\n  });\n}\n\nDispatch.prototype = dispatch.prototype = {\n  constructor: Dispatch,\n  on: function(typename, callback) {\n    var _ = this._,\n        T = parseTypenames(typename + \"\", _),\n        t,\n        i = -1,\n        n = T.length;\n\n    // If no callback was specified, return the callback of the given type and name.\n    if (arguments.length < 2) {\n      while (++i < n) if ((t = (typename = T[i]).type) && (t = get(_[t], typename.name))) return t;\n      return;\n    }\n\n    // If a type was specified, set the callback for the given type and name.\n    // Otherwise, if a null callback was specified, remove callbacks of the given name.\n    if (callback != null && typeof callback !== \"function\") throw new Error(\"invalid callback: \" + callback);\n    while (++i < n) {\n      if (t = (typename = T[i]).type) _[t] = set(_[t], typename.name, callback);\n      else if (callback == null) for (t in _) _[t] = set(_[t], typename.name, null);\n    }\n\n    return this;\n  },\n  copy: function() {\n    var copy = {}, _ = this._;\n    for (var t in _) copy[t] = _[t].slice();\n    return new Dispatch(copy);\n  },\n  call: function(type, that) {\n    if ((n = arguments.length - 2) > 0) for (var args = new Array(n), i = 0, n, t; i < n; ++i) args[i] = arguments[i + 2];\n    if (!this._.hasOwnProperty(type)) throw new Error(\"unknown type: \" + type);\n    for (t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);\n  },\n  apply: function(type, that, args) {\n    if (!this._.hasOwnProperty(type)) throw new Error(\"unknown type: \" + type);\n    for (var t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);\n  }\n};\n\nfunction get(type, name) {\n  for (var i = 0, n = type.length, c; i < n; ++i) {\n    if ((c = type[i]).name === name) {\n      return c.value;\n    }\n  }\n}\n\nfunction set(type, name, callback) {\n  for (var i = 0, n = type.length; i < n; ++i) {\n    if (type[i].name === name) {\n      type[i] = noop, type = type.slice(0, i).concat(type.slice(i + 1));\n      break;\n    }\n  }\n  if (callback != null) type.push({name: name, value: callback});\n  return type;\n}\n\nvar xhtml = \"http://www.w3.org/1999/xhtml\";\n\nvar namespaces = {\n  svg: \"http://www.w3.org/2000/svg\",\n  xhtml: xhtml,\n  xlink: \"http://www.w3.org/1999/xlink\",\n  xml: \"http://www.w3.org/XML/1998/namespace\",\n  xmlns: \"http://www.w3.org/2000/xmlns/\"\n};\n\nvar namespace = function(name) {\n  var prefix = name += \"\", i = prefix.indexOf(\":\");\n  if (i >= 0 && (prefix = name.slice(0, i)) !== \"xmlns\") name = name.slice(i + 1);\n  return namespaces.hasOwnProperty(prefix) ? {space: namespaces[prefix], local: name} : name;\n};\n\nfunction creatorInherit(name) {\n  return function() {\n    var document = this.ownerDocument,\n        uri = this.namespaceURI;\n    return uri === xhtml && document.documentElement.namespaceURI === xhtml\n        ? document.createElement(name)\n        : document.createElementNS(uri, name);\n  };\n}\n\nfunction creatorFixed(fullname) {\n  return function() {\n    return this.ownerDocument.createElementNS(fullname.space, fullname.local);\n  };\n}\n\nvar creator = function(name) {\n  var fullname = namespace(name);\n  return (fullname.local\n      ? creatorFixed\n      : creatorInherit)(fullname);\n};\n\nvar nextId = 0;\n\nfunction local$1() {\n  return new Local;\n}\n\nfunction Local() {\n  this._ = \"@\" + (++nextId).toString(36);\n}\n\nLocal.prototype = local$1.prototype = {\n  constructor: Local,\n  get: function(node) {\n    var id = this._;\n    while (!(id in node)) if (!(node = node.parentNode)) return;\n    return node[id];\n  },\n  set: function(node, value) {\n    return node[this._] = value;\n  },\n  remove: function(node) {\n    return this._ in node && delete node[this._];\n  },\n  toString: function() {\n    return this._;\n  }\n};\n\nvar matcher = function(selector) {\n  return function() {\n    return this.matches(selector);\n  };\n};\n\nif (typeof document !== \"undefined\") {\n  var element = document.documentElement;\n  if (!element.matches) {\n    var vendorMatches = element.webkitMatchesSelector\n        || element.msMatchesSelector\n        || element.mozMatchesSelector\n        || element.oMatchesSelector;\n    matcher = function(selector) {\n      return function() {\n        return vendorMatches.call(this, selector);\n      };\n    };\n  }\n}\n\nvar matcher$1 = matcher;\n\nvar filterEvents = {};\n\nexports.event = null;\n\nif (typeof document !== \"undefined\") {\n  var element$1 = document.documentElement;\n  if (!(\"onmouseenter\" in element$1)) {\n    filterEvents = {mouseenter: \"mouseover\", mouseleave: \"mouseout\"};\n  }\n}\n\nfunction filterContextListener(listener, index, group) {\n  listener = contextListener(listener, index, group);\n  return function(event) {\n    var related = event.relatedTarget;\n    if (!related || (related !== this && !(related.compareDocumentPosition(this) & 8))) {\n      listener.call(this, event);\n    }\n  };\n}\n\nfunction contextListener(listener, index, group) {\n  return function(event1) {\n    var event0 = exports.event; // Events can be reentrant (e.g., focus).\n    exports.event = event1;\n    try {\n      listener.call(this, this.__data__, index, group);\n    } finally {\n      exports.event = event0;\n    }\n  };\n}\n\nfunction parseTypenames$1(typenames) {\n  return typenames.trim().split(/^|\\s+/).map(function(t) {\n    var name = \"\", i = t.indexOf(\".\");\n    if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);\n    return {type: t, name: name};\n  });\n}\n\nfunction onRemove(typename) {\n  return function() {\n    var on = this.__on;\n    if (!on) return;\n    for (var j = 0, i = -1, m = on.length, o; j < m; ++j) {\n      if (o = on[j], (!typename.type || o.type === typename.type) && o.name === typename.name) {\n        this.removeEventListener(o.type, o.listener, o.capture);\n      } else {\n        on[++i] = o;\n      }\n    }\n    if (++i) on.length = i;\n    else delete this.__on;\n  };\n}\n\nfunction onAdd(typename, value, capture) {\n  var wrap = filterEvents.hasOwnProperty(typename.type) ? filterContextListener : contextListener;\n  return function(d, i, group) {\n    var on = this.__on, o, listener = wrap(value, i, group);\n    if (on) for (var j = 0, m = on.length; j < m; ++j) {\n      if ((o = on[j]).type === typename.type && o.name === typename.name) {\n        this.removeEventListener(o.type, o.listener, o.capture);\n        this.addEventListener(o.type, o.listener = listener, o.capture = capture);\n        o.value = value;\n        return;\n      }\n    }\n    this.addEventListener(typename.type, listener, capture);\n    o = {type: typename.type, name: typename.name, value: value, listener: listener, capture: capture};\n    if (!on) this.__on = [o];\n    else on.push(o);\n  };\n}\n\nvar selection_on = function(typename, value, capture) {\n  var typenames = parseTypenames$1(typename + \"\"), i, n = typenames.length, t;\n\n  if (arguments.length < 2) {\n    var on = this.node().__on;\n    if (on) for (var j = 0, m = on.length, o; j < m; ++j) {\n      for (i = 0, o = on[j]; i < n; ++i) {\n        if ((t = typenames[i]).type === o.type && t.name === o.name) {\n          return o.value;\n        }\n      }\n    }\n    return;\n  }\n\n  on = value ? onAdd : onRemove;\n  if (capture == null) capture = false;\n  for (i = 0; i < n; ++i) this.each(on(typenames[i], value, capture));\n  return this;\n};\n\nfunction customEvent(event1, listener, that, args) {\n  var event0 = exports.event;\n  event1.sourceEvent = exports.event;\n  exports.event = event1;\n  try {\n    return listener.apply(that, args);\n  } finally {\n    exports.event = event0;\n  }\n}\n\nvar sourceEvent = function() {\n  var current = exports.event, source;\n  while (source = current.sourceEvent) current = source;\n  return current;\n};\n\nvar point = function(node, event) {\n  var svg = node.ownerSVGElement || node;\n\n  if (svg.createSVGPoint) {\n    var point = svg.createSVGPoint();\n    point.x = event.clientX, point.y = event.clientY;\n    point = point.matrixTransform(node.getScreenCTM().inverse());\n    return [point.x, point.y];\n  }\n\n  var rect = node.getBoundingClientRect();\n  return [event.clientX - rect.left - node.clientLeft, event.clientY - rect.top - node.clientTop];\n};\n\nvar mouse = function(node) {\n  var event = sourceEvent();\n  if (event.changedTouches) event = event.changedTouches[0];\n  return point(node, event);\n};\n\nfunction none() {}\n\nvar selector = function(selector) {\n  return selector == null ? none : function() {\n    return this.querySelector(selector);\n  };\n};\n\nvar selection_select = function(select) {\n  if (typeof select !== \"function\") select = selector(select);\n\n  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {\n    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) {\n      if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) {\n        if (\"__data__\" in node) subnode.__data__ = node.__data__;\n        subgroup[i] = subnode;\n      }\n    }\n  }\n\n  return new Selection(subgroups, this._parents);\n};\n\nfunction empty$1() {\n  return [];\n}\n\nvar selectorAll = function(selector) {\n  return selector == null ? empty$1 : function() {\n    return this.querySelectorAll(selector);\n  };\n};\n\nvar selection_selectAll = function(select) {\n  if (typeof select !== \"function\") select = selectorAll(select);\n\n  for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) {\n    for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {\n      if (node = group[i]) {\n        subgroups.push(select.call(node, node.__data__, i, group));\n        parents.push(node);\n      }\n    }\n  }\n\n  return new Selection(subgroups, parents);\n};\n\nvar selection_filter = function(match) {\n  if (typeof match !== \"function\") match = matcher$1(match);\n\n  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {\n    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) {\n      if ((node = group[i]) && match.call(node, node.__data__, i, group)) {\n        subgroup.push(node);\n      }\n    }\n  }\n\n  return new Selection(subgroups, this._parents);\n};\n\nvar sparse = function(update) {\n  return new Array(update.length);\n};\n\nvar selection_enter = function() {\n  return new Selection(this._enter || this._groups.map(sparse), this._parents);\n};\n\nfunction EnterNode(parent, datum) {\n  this.ownerDocument = parent.ownerDocument;\n  this.namespaceURI = parent.namespaceURI;\n  this._next = null;\n  this._parent = parent;\n  this.__data__ = datum;\n}\n\nEnterNode.prototype = {\n  constructor: EnterNode,\n  appendChild: function(child) { return this._parent.insertBefore(child, this._next); },\n  insertBefore: function(child, next) { return this._parent.insertBefore(child, next); },\n  querySelector: function(selector) { return this._parent.querySelector(selector); },\n  querySelectorAll: function(selector) { return this._parent.querySelectorAll(selector); }\n};\n\nvar constant$1 = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nvar keyPrefix = \"$\"; // Protect against keys like “__proto__”.\n\nfunction bindIndex(parent, group, enter, update, exit, data) {\n  var i = 0,\n      node,\n      groupLength = group.length,\n      dataLength = data.length;\n\n  // Put any non-null nodes that fit into update.\n  // Put any null nodes into enter.\n  // Put any remaining data into enter.\n  for (; i < dataLength; ++i) {\n    if (node = group[i]) {\n      node.__data__ = data[i];\n      update[i] = node;\n    } else {\n      enter[i] = new EnterNode(parent, data[i]);\n    }\n  }\n\n  // Put any non-null nodes that don’t fit into exit.\n  for (; i < groupLength; ++i) {\n    if (node = group[i]) {\n      exit[i] = node;\n    }\n  }\n}\n\nfunction bindKey(parent, group, enter, update, exit, data, key) {\n  var i,\n      node,\n      nodeByKeyValue = {},\n      groupLength = group.length,\n      dataLength = data.length,\n      keyValues = new Array(groupLength),\n      keyValue;\n\n  // Compute the key for each node.\n  // If multiple nodes have the same key, the duplicates are added to exit.\n  for (i = 0; i < groupLength; ++i) {\n    if (node = group[i]) {\n      keyValues[i] = keyValue = keyPrefix + key.call(node, node.__data__, i, group);\n      if (keyValue in nodeByKeyValue) {\n        exit[i] = node;\n      } else {\n        nodeByKeyValue[keyValue] = node;\n      }\n    }\n  }\n\n  // Compute the key for each datum.\n  // If there a node associated with this key, join and add it to update.\n  // If there is not (or the key is a duplicate), add it to enter.\n  for (i = 0; i < dataLength; ++i) {\n    keyValue = keyPrefix + key.call(parent, data[i], i, data);\n    if (node = nodeByKeyValue[keyValue]) {\n      update[i] = node;\n      node.__data__ = data[i];\n      nodeByKeyValue[keyValue] = null;\n    } else {\n      enter[i] = new EnterNode(parent, data[i]);\n    }\n  }\n\n  // Add any remaining nodes that were not bound to data to exit.\n  for (i = 0; i < groupLength; ++i) {\n    if ((node = group[i]) && (nodeByKeyValue[keyValues[i]] === node)) {\n      exit[i] = node;\n    }\n  }\n}\n\nvar selection_data = function(value, key) {\n  if (!value) {\n    data = new Array(this.size()), j = -1;\n    this.each(function(d) { data[++j] = d; });\n    return data;\n  }\n\n  var bind = key ? bindKey : bindIndex,\n      parents = this._parents,\n      groups = this._groups;\n\n  if (typeof value !== \"function\") value = constant$1(value);\n\n  for (var m = groups.length, update = new Array(m), enter = new Array(m), exit = new Array(m), j = 0; j < m; ++j) {\n    var parent = parents[j],\n        group = groups[j],\n        groupLength = group.length,\n        data = value.call(parent, parent && parent.__data__, j, parents),\n        dataLength = data.length,\n        enterGroup = enter[j] = new Array(dataLength),\n        updateGroup = update[j] = new Array(dataLength),\n        exitGroup = exit[j] = new Array(groupLength);\n\n    bind(parent, group, enterGroup, updateGroup, exitGroup, data, key);\n\n    // Now connect the enter nodes to their following update node, such that\n    // appendChild can insert the materialized enter node before this node,\n    // rather than at the end of the parent node.\n    for (var i0 = 0, i1 = 0, previous, next; i0 < dataLength; ++i0) {\n      if (previous = enterGroup[i0]) {\n        if (i0 >= i1) i1 = i0 + 1;\n        while (!(next = updateGroup[i1]) && ++i1 < dataLength);\n        previous._next = next || null;\n      }\n    }\n  }\n\n  update = new Selection(update, parents);\n  update._enter = enter;\n  update._exit = exit;\n  return update;\n};\n\nvar selection_exit = function() {\n  return new Selection(this._exit || this._groups.map(sparse), this._parents);\n};\n\nvar selection_merge = function(selection) {\n\n  for (var groups0 = this._groups, groups1 = selection._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) {\n    for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) {\n      if (node = group0[i] || group1[i]) {\n        merge[i] = node;\n      }\n    }\n  }\n\n  for (; j < m0; ++j) {\n    merges[j] = groups0[j];\n  }\n\n  return new Selection(merges, this._parents);\n};\n\nvar selection_order = function() {\n\n  for (var groups = this._groups, j = -1, m = groups.length; ++j < m;) {\n    for (var group = groups[j], i = group.length - 1, next = group[i], node; --i >= 0;) {\n      if (node = group[i]) {\n        if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next);\n        next = node;\n      }\n    }\n  }\n\n  return this;\n};\n\nvar selection_sort = function(compare) {\n  if (!compare) compare = ascending$1;\n\n  function compareNode(a, b) {\n    return a && b ? compare(a.__data__, b.__data__) : !a - !b;\n  }\n\n  for (var groups = this._groups, m = groups.length, sortgroups = new Array(m), j = 0; j < m; ++j) {\n    for (var group = groups[j], n = group.length, sortgroup = sortgroups[j] = new Array(n), node, i = 0; i < n; ++i) {\n      if (node = group[i]) {\n        sortgroup[i] = node;\n      }\n    }\n    sortgroup.sort(compareNode);\n  }\n\n  return new Selection(sortgroups, this._parents).order();\n};\n\nfunction ascending$1(a, b) {\n  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;\n}\n\nvar selection_call = function() {\n  var callback = arguments[0];\n  arguments[0] = this;\n  callback.apply(null, arguments);\n  return this;\n};\n\nvar selection_nodes = function() {\n  var nodes = new Array(this.size()), i = -1;\n  this.each(function() { nodes[++i] = this; });\n  return nodes;\n};\n\nvar selection_node = function() {\n\n  for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {\n    for (var group = groups[j], i = 0, n = group.length; i < n; ++i) {\n      var node = group[i];\n      if (node) return node;\n    }\n  }\n\n  return null;\n};\n\nvar selection_size = function() {\n  var size = 0;\n  this.each(function() { ++size; });\n  return size;\n};\n\nvar selection_empty = function() {\n  return !this.node();\n};\n\nvar selection_each = function(callback) {\n\n  for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {\n    for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) {\n      if (node = group[i]) callback.call(node, node.__data__, i, group);\n    }\n  }\n\n  return this;\n};\n\nfunction attrRemove(name) {\n  return function() {\n    this.removeAttribute(name);\n  };\n}\n\nfunction attrRemoveNS(fullname) {\n  return function() {\n    this.removeAttributeNS(fullname.space, fullname.local);\n  };\n}\n\nfunction attrConstant(name, value) {\n  return function() {\n    this.setAttribute(name, value);\n  };\n}\n\nfunction attrConstantNS(fullname, value) {\n  return function() {\n    this.setAttributeNS(fullname.space, fullname.local, value);\n  };\n}\n\nfunction attrFunction(name, value) {\n  return function() {\n    var v = value.apply(this, arguments);\n    if (v == null) this.removeAttribute(name);\n    else this.setAttribute(name, v);\n  };\n}\n\nfunction attrFunctionNS(fullname, value) {\n  return function() {\n    var v = value.apply(this, arguments);\n    if (v == null) this.removeAttributeNS(fullname.space, fullname.local);\n    else this.setAttributeNS(fullname.space, fullname.local, v);\n  };\n}\n\nvar selection_attr = function(name, value) {\n  var fullname = namespace(name);\n\n  if (arguments.length < 2) {\n    var node = this.node();\n    return fullname.local\n        ? node.getAttributeNS(fullname.space, fullname.local)\n        : node.getAttribute(fullname);\n  }\n\n  return this.each((value == null\n      ? (fullname.local ? attrRemoveNS : attrRemove) : (typeof value === \"function\"\n      ? (fullname.local ? attrFunctionNS : attrFunction)\n      : (fullname.local ? attrConstantNS : attrConstant)))(fullname, value));\n};\n\nvar window = function(node) {\n  return (node.ownerDocument && node.ownerDocument.defaultView) // node is a Node\n      || (node.document && node) // node is a Window\n      || node.defaultView; // node is a Document\n};\n\nfunction styleRemove(name) {\n  return function() {\n    this.style.removeProperty(name);\n  };\n}\n\nfunction styleConstant(name, value, priority) {\n  return function() {\n    this.style.setProperty(name, value, priority);\n  };\n}\n\nfunction styleFunction(name, value, priority) {\n  return function() {\n    var v = value.apply(this, arguments);\n    if (v == null) this.style.removeProperty(name);\n    else this.style.setProperty(name, v, priority);\n  };\n}\n\nvar selection_style = function(name, value, priority) {\n  var node;\n  return arguments.length > 1\n      ? this.each((value == null\n            ? styleRemove : typeof value === \"function\"\n            ? styleFunction\n            : styleConstant)(name, value, priority == null ? \"\" : priority))\n      : window(node = this.node())\n          .getComputedStyle(node, null)\n          .getPropertyValue(name);\n};\n\nfunction propertyRemove(name) {\n  return function() {\n    delete this[name];\n  };\n}\n\nfunction propertyConstant(name, value) {\n  return function() {\n    this[name] = value;\n  };\n}\n\nfunction propertyFunction(name, value) {\n  return function() {\n    var v = value.apply(this, arguments);\n    if (v == null) delete this[name];\n    else this[name] = v;\n  };\n}\n\nvar selection_property = function(name, value) {\n  return arguments.length > 1\n      ? this.each((value == null\n          ? propertyRemove : typeof value === \"function\"\n          ? propertyFunction\n          : propertyConstant)(name, value))\n      : this.node()[name];\n};\n\nfunction classArray(string) {\n  return string.trim().split(/^|\\s+/);\n}\n\nfunction classList(node) {\n  return node.classList || new ClassList(node);\n}\n\nfunction ClassList(node) {\n  this._node = node;\n  this._names = classArray(node.getAttribute(\"class\") || \"\");\n}\n\nClassList.prototype = {\n  add: function(name) {\n    var i = this._names.indexOf(name);\n    if (i < 0) {\n      this._names.push(name);\n      this._node.setAttribute(\"class\", this._names.join(\" \"));\n    }\n  },\n  remove: function(name) {\n    var i = this._names.indexOf(name);\n    if (i >= 0) {\n      this._names.splice(i, 1);\n      this._node.setAttribute(\"class\", this._names.join(\" \"));\n    }\n  },\n  contains: function(name) {\n    return this._names.indexOf(name) >= 0;\n  }\n};\n\nfunction classedAdd(node, names) {\n  var list = classList(node), i = -1, n = names.length;\n  while (++i < n) list.add(names[i]);\n}\n\nfunction classedRemove(node, names) {\n  var list = classList(node), i = -1, n = names.length;\n  while (++i < n) list.remove(names[i]);\n}\n\nfunction classedTrue(names) {\n  return function() {\n    classedAdd(this, names);\n  };\n}\n\nfunction classedFalse(names) {\n  return function() {\n    classedRemove(this, names);\n  };\n}\n\nfunction classedFunction(names, value) {\n  return function() {\n    (value.apply(this, arguments) ? classedAdd : classedRemove)(this, names);\n  };\n}\n\nvar selection_classed = function(name, value) {\n  var names = classArray(name + \"\");\n\n  if (arguments.length < 2) {\n    var list = classList(this.node()), i = -1, n = names.length;\n    while (++i < n) if (!list.contains(names[i])) return false;\n    return true;\n  }\n\n  return this.each((typeof value === \"function\"\n      ? classedFunction : value\n      ? classedTrue\n      : classedFalse)(names, value));\n};\n\nfunction textRemove() {\n  this.textContent = \"\";\n}\n\nfunction textConstant(value) {\n  return function() {\n    this.textContent = value;\n  };\n}\n\nfunction textFunction(value) {\n  return function() {\n    var v = value.apply(this, arguments);\n    this.textContent = v == null ? \"\" : v;\n  };\n}\n\nvar selection_text = function(value) {\n  return arguments.length\n      ? this.each(value == null\n          ? textRemove : (typeof value === \"function\"\n          ? textFunction\n          : textConstant)(value))\n      : this.node().textContent;\n};\n\nfunction htmlRemove() {\n  this.innerHTML = \"\";\n}\n\nfunction htmlConstant(value) {\n  return function() {\n    this.innerHTML = value;\n  };\n}\n\nfunction htmlFunction(value) {\n  return function() {\n    var v = value.apply(this, arguments);\n    this.innerHTML = v == null ? \"\" : v;\n  };\n}\n\nvar selection_html = function(value) {\n  return arguments.length\n      ? this.each(value == null\n          ? htmlRemove : (typeof value === \"function\"\n          ? htmlFunction\n          : htmlConstant)(value))\n      : this.node().innerHTML;\n};\n\nfunction raise() {\n  if (this.nextSibling) this.parentNode.appendChild(this);\n}\n\nvar selection_raise = function() {\n  return this.each(raise);\n};\n\nfunction lower() {\n  if (this.previousSibling) this.parentNode.insertBefore(this, this.parentNode.firstChild);\n}\n\nvar selection_lower = function() {\n  return this.each(lower);\n};\n\nvar selection_append = function(name) {\n  var create = typeof name === \"function\" ? name : creator(name);\n  return this.select(function() {\n    return this.appendChild(create.apply(this, arguments));\n  });\n};\n\nfunction constantNull() {\n  return null;\n}\n\nvar selection_insert = function(name, before) {\n  var create = typeof name === \"function\" ? name : creator(name),\n      select = before == null ? constantNull : typeof before === \"function\" ? before : selector(before);\n  return this.select(function() {\n    return this.insertBefore(create.apply(this, arguments), select.apply(this, arguments) || null);\n  });\n};\n\nfunction remove() {\n  var parent = this.parentNode;\n  if (parent) parent.removeChild(this);\n}\n\nvar selection_remove = function() {\n  return this.each(remove);\n};\n\nvar selection_datum = function(value) {\n  return arguments.length\n      ? this.property(\"__data__\", value)\n      : this.node().__data__;\n};\n\nfunction dispatchEvent(node, type, params) {\n  var window$$1 = window(node),\n      event = window$$1.CustomEvent;\n\n  if (event) {\n    event = new event(type, params);\n  } else {\n    event = window$$1.document.createEvent(\"Event\");\n    if (params) event.initEvent(type, params.bubbles, params.cancelable), event.detail = params.detail;\n    else event.initEvent(type, false, false);\n  }\n\n  node.dispatchEvent(event);\n}\n\nfunction dispatchConstant(type, params) {\n  return function() {\n    return dispatchEvent(this, type, params);\n  };\n}\n\nfunction dispatchFunction(type, params) {\n  return function() {\n    return dispatchEvent(this, type, params.apply(this, arguments));\n  };\n}\n\nvar selection_dispatch = function(type, params) {\n  return this.each((typeof params === \"function\"\n      ? dispatchFunction\n      : dispatchConstant)(type, params));\n};\n\nvar root = [null];\n\nfunction Selection(groups, parents) {\n  this._groups = groups;\n  this._parents = parents;\n}\n\nfunction selection() {\n  return new Selection([[document.documentElement]], root);\n}\n\nSelection.prototype = selection.prototype = {\n  constructor: Selection,\n  select: selection_select,\n  selectAll: selection_selectAll,\n  filter: selection_filter,\n  data: selection_data,\n  enter: selection_enter,\n  exit: selection_exit,\n  merge: selection_merge,\n  order: selection_order,\n  sort: selection_sort,\n  call: selection_call,\n  nodes: selection_nodes,\n  node: selection_node,\n  size: selection_size,\n  empty: selection_empty,\n  each: selection_each,\n  attr: selection_attr,\n  style: selection_style,\n  property: selection_property,\n  classed: selection_classed,\n  text: selection_text,\n  html: selection_html,\n  raise: selection_raise,\n  lower: selection_lower,\n  append: selection_append,\n  insert: selection_insert,\n  remove: selection_remove,\n  datum: selection_datum,\n  on: selection_on,\n  dispatch: selection_dispatch\n};\n\nvar select = function(selector) {\n  return typeof selector === \"string\"\n      ? new Selection([[document.querySelector(selector)]], [document.documentElement])\n      : new Selection([[selector]], root);\n};\n\nvar selectAll = function(selector) {\n  return typeof selector === \"string\"\n      ? new Selection([document.querySelectorAll(selector)], [document.documentElement])\n      : new Selection([selector == null ? [] : selector], root);\n};\n\nvar touch = function(node, touches, identifier) {\n  if (arguments.length < 3) identifier = touches, touches = sourceEvent().changedTouches;\n\n  for (var i = 0, n = touches ? touches.length : 0, touch; i < n; ++i) {\n    if ((touch = touches[i]).identifier === identifier) {\n      return point(node, touch);\n    }\n  }\n\n  return null;\n};\n\nvar touches = function(node, touches) {\n  if (touches == null) touches = sourceEvent().touches;\n\n  for (var i = 0, n = touches ? touches.length : 0, points = new Array(n); i < n; ++i) {\n    points[i] = point(node, touches[i]);\n  }\n\n  return points;\n};\n\nfunction nopropagation() {\n  exports.event.stopImmediatePropagation();\n}\n\nvar noevent = function() {\n  exports.event.preventDefault();\n  exports.event.stopImmediatePropagation();\n};\n\nvar dragDisable = function(view) {\n  var root = view.document.documentElement,\n      selection$$1 = select(view).on(\"dragstart.drag\", noevent, true);\n  if (\"onselectstart\" in root) {\n    selection$$1.on(\"selectstart.drag\", noevent, true);\n  } else {\n    root.__noselect = root.style.MozUserSelect;\n    root.style.MozUserSelect = \"none\";\n  }\n};\n\nfunction yesdrag(view, noclick) {\n  var root = view.document.documentElement,\n      selection$$1 = select(view).on(\"dragstart.drag\", null);\n  if (noclick) {\n    selection$$1.on(\"click.drag\", noevent, true);\n    setTimeout(function() { selection$$1.on(\"click.drag\", null); }, 0);\n  }\n  if (\"onselectstart\" in root) {\n    selection$$1.on(\"selectstart.drag\", null);\n  } else {\n    root.style.MozUserSelect = root.__noselect;\n    delete root.__noselect;\n  }\n}\n\nvar constant$2 = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nfunction DragEvent(target, type, subject, id, active, x, y, dx, dy, dispatch) {\n  this.target = target;\n  this.type = type;\n  this.subject = subject;\n  this.identifier = id;\n  this.active = active;\n  this.x = x;\n  this.y = y;\n  this.dx = dx;\n  this.dy = dy;\n  this._ = dispatch;\n}\n\nDragEvent.prototype.on = function() {\n  var value = this._.on.apply(this._, arguments);\n  return value === this._ ? this : value;\n};\n\n// Ignore right-click, since that should open the context menu.\nfunction defaultFilter$1() {\n  return !exports.event.button;\n}\n\nfunction defaultContainer() {\n  return this.parentNode;\n}\n\nfunction defaultSubject(d) {\n  return d == null ? {x: exports.event.x, y: exports.event.y} : d;\n}\n\nvar drag = function() {\n  var filter = defaultFilter$1,\n      container = defaultContainer,\n      subject = defaultSubject,\n      gestures = {},\n      listeners = dispatch(\"start\", \"drag\", \"end\"),\n      active = 0,\n      mousemoving,\n      touchending;\n\n  function drag(selection$$1) {\n    selection$$1\n        .on(\"mousedown.drag\", mousedowned)\n        .on(\"touchstart.drag\", touchstarted)\n        .on(\"touchmove.drag\", touchmoved)\n        .on(\"touchend.drag touchcancel.drag\", touchended)\n        .style(\"-webkit-tap-highlight-color\", \"rgba(0,0,0,0)\");\n  }\n\n  function mousedowned() {\n    if (touchending || !filter.apply(this, arguments)) return;\n    var gesture = beforestart(\"mouse\", container.apply(this, arguments), mouse, this, arguments);\n    if (!gesture) return;\n    select(exports.event.view).on(\"mousemove.drag\", mousemoved, true).on(\"mouseup.drag\", mouseupped, true);\n    dragDisable(exports.event.view);\n    nopropagation();\n    mousemoving = false;\n    gesture(\"start\");\n  }\n\n  function mousemoved() {\n    noevent();\n    mousemoving = true;\n    gestures.mouse(\"drag\");\n  }\n\n  function mouseupped() {\n    select(exports.event.view).on(\"mousemove.drag mouseup.drag\", null);\n    yesdrag(exports.event.view, mousemoving);\n    noevent();\n    gestures.mouse(\"end\");\n  }\n\n  function touchstarted() {\n    if (!filter.apply(this, arguments)) return;\n    var touches$$1 = exports.event.changedTouches,\n        c = container.apply(this, arguments),\n        n = touches$$1.length, i, gesture;\n\n    for (i = 0; i < n; ++i) {\n      if (gesture = beforestart(touches$$1[i].identifier, c, touch, this, arguments)) {\n        nopropagation();\n        gesture(\"start\");\n      }\n    }\n  }\n\n  function touchmoved() {\n    var touches$$1 = exports.event.changedTouches,\n        n = touches$$1.length, i, gesture;\n\n    for (i = 0; i < n; ++i) {\n      if (gesture = gestures[touches$$1[i].identifier]) {\n        noevent();\n        gesture(\"drag\");\n      }\n    }\n  }\n\n  function touchended() {\n    var touches$$1 = exports.event.changedTouches,\n        n = touches$$1.length, i, gesture;\n\n    if (touchending) clearTimeout(touchending);\n    touchending = setTimeout(function() { touchending = null; }, 500); // Ghost clicks are delayed!\n    for (i = 0; i < n; ++i) {\n      if (gesture = gestures[touches$$1[i].identifier]) {\n        nopropagation();\n        gesture(\"end\");\n      }\n    }\n  }\n\n  function beforestart(id, container, point, that, args) {\n    var p = point(container, id), s, dx, dy,\n        sublisteners = listeners.copy();\n\n    if (!customEvent(new DragEvent(drag, \"beforestart\", s, id, active, p[0], p[1], 0, 0, sublisteners), function() {\n      if ((exports.event.subject = s = subject.apply(that, args)) == null) return false;\n      dx = s.x - p[0] || 0;\n      dy = s.y - p[1] || 0;\n      return true;\n    })) return;\n\n    return function gesture(type) {\n      var p0 = p, n;\n      switch (type) {\n        case \"start\": gestures[id] = gesture, n = active++; break;\n        case \"end\": delete gestures[id], --active; // nobreak\n        case \"drag\": p = point(container, id), n = active; break;\n      }\n      customEvent(new DragEvent(drag, type, s, id, n, p[0] + dx, p[1] + dy, p[0] - p0[0], p[1] - p0[1], sublisteners), sublisteners.apply, sublisteners, [type, that, args]);\n    };\n  }\n\n  drag.filter = function(_) {\n    return arguments.length ? (filter = typeof _ === \"function\" ? _ : constant$2(!!_), drag) : filter;\n  };\n\n  drag.container = function(_) {\n    return arguments.length ? (container = typeof _ === \"function\" ? _ : constant$2(_), drag) : container;\n  };\n\n  drag.subject = function(_) {\n    return arguments.length ? (subject = typeof _ === \"function\" ? _ : constant$2(_), drag) : subject;\n  };\n\n  drag.on = function() {\n    var value = listeners.on.apply(listeners, arguments);\n    return value === listeners ? drag : value;\n  };\n\n  return drag;\n};\n\nvar define = function(constructor, factory, prototype) {\n  constructor.prototype = factory.prototype = prototype;\n  prototype.constructor = constructor;\n};\n\nfunction extend(parent, definition) {\n  var prototype = Object.create(parent.prototype);\n  for (var key in definition) prototype[key] = definition[key];\n  return prototype;\n}\n\nfunction Color() {}\n\nvar darker = 0.7;\nvar brighter = 1 / darker;\n\nvar reI = \"\\\\s*([+-]?\\\\d+)\\\\s*\";\nvar reN = \"\\\\s*([+-]?\\\\d*\\\\.?\\\\d+(?:[eE][+-]?\\\\d+)?)\\\\s*\";\nvar reP = \"\\\\s*([+-]?\\\\d*\\\\.?\\\\d+(?:[eE][+-]?\\\\d+)?)%\\\\s*\";\nvar reHex3 = /^#([0-9a-f]{3})$/;\nvar reHex6 = /^#([0-9a-f]{6})$/;\nvar reRgbInteger = new RegExp(\"^rgb\\\\(\" + [reI, reI, reI] + \"\\\\)$\");\nvar reRgbPercent = new RegExp(\"^rgb\\\\(\" + [reP, reP, reP] + \"\\\\)$\");\nvar reRgbaInteger = new RegExp(\"^rgba\\\\(\" + [reI, reI, reI, reN] + \"\\\\)$\");\nvar reRgbaPercent = new RegExp(\"^rgba\\\\(\" + [reP, reP, reP, reN] + \"\\\\)$\");\nvar reHslPercent = new RegExp(\"^hsl\\\\(\" + [reN, reP, reP] + \"\\\\)$\");\nvar reHslaPercent = new RegExp(\"^hsla\\\\(\" + [reN, reP, reP, reN] + \"\\\\)$\");\n\nvar named = {\n  aliceblue: 0xf0f8ff,\n  antiquewhite: 0xfaebd7,\n  aqua: 0x00ffff,\n  aquamarine: 0x7fffd4,\n  azure: 0xf0ffff,\n  beige: 0xf5f5dc,\n  bisque: 0xffe4c4,\n  black: 0x000000,\n  blanchedalmond: 0xffebcd,\n  blue: 0x0000ff,\n  blueviolet: 0x8a2be2,\n  brown: 0xa52a2a,\n  burlywood: 0xdeb887,\n  cadetblue: 0x5f9ea0,\n  chartreuse: 0x7fff00,\n  chocolate: 0xd2691e,\n  coral: 0xff7f50,\n  cornflowerblue: 0x6495ed,\n  cornsilk: 0xfff8dc,\n  crimson: 0xdc143c,\n  cyan: 0x00ffff,\n  darkblue: 0x00008b,\n  darkcyan: 0x008b8b,\n  darkgoldenrod: 0xb8860b,\n  darkgray: 0xa9a9a9,\n  darkgreen: 0x006400,\n  darkgrey: 0xa9a9a9,\n  darkkhaki: 0xbdb76b,\n  darkmagenta: 0x8b008b,\n  darkolivegreen: 0x556b2f,\n  darkorange: 0xff8c00,\n  darkorchid: 0x9932cc,\n  darkred: 0x8b0000,\n  darksalmon: 0xe9967a,\n  darkseagreen: 0x8fbc8f,\n  darkslateblue: 0x483d8b,\n  darkslategray: 0x2f4f4f,\n  darkslategrey: 0x2f4f4f,\n  darkturquoise: 0x00ced1,\n  darkviolet: 0x9400d3,\n  deeppink: 0xff1493,\n  deepskyblue: 0x00bfff,\n  dimgray: 0x696969,\n  dimgrey: 0x696969,\n  dodgerblue: 0x1e90ff,\n  firebrick: 0xb22222,\n  floralwhite: 0xfffaf0,\n  forestgreen: 0x228b22,\n  fuchsia: 0xff00ff,\n  gainsboro: 0xdcdcdc,\n  ghostwhite: 0xf8f8ff,\n  gold: 0xffd700,\n  goldenrod: 0xdaa520,\n  gray: 0x808080,\n  green: 0x008000,\n  greenyellow: 0xadff2f,\n  grey: 0x808080,\n  honeydew: 0xf0fff0,\n  hotpink: 0xff69b4,\n  indianred: 0xcd5c5c,\n  indigo: 0x4b0082,\n  ivory: 0xfffff0,\n  khaki: 0xf0e68c,\n  lavender: 0xe6e6fa,\n  lavenderblush: 0xfff0f5,\n  lawngreen: 0x7cfc00,\n  lemonchiffon: 0xfffacd,\n  lightblue: 0xadd8e6,\n  lightcoral: 0xf08080,\n  lightcyan: 0xe0ffff,\n  lightgoldenrodyellow: 0xfafad2,\n  lightgray: 0xd3d3d3,\n  lightgreen: 0x90ee90,\n  lightgrey: 0xd3d3d3,\n  lightpink: 0xffb6c1,\n  lightsalmon: 0xffa07a,\n  lightseagreen: 0x20b2aa,\n  lightskyblue: 0x87cefa,\n  lightslategray: 0x778899,\n  lightslategrey: 0x778899,\n  lightsteelblue: 0xb0c4de,\n  lightyellow: 0xffffe0,\n  lime: 0x00ff00,\n  limegreen: 0x32cd32,\n  linen: 0xfaf0e6,\n  magenta: 0xff00ff,\n  maroon: 0x800000,\n  mediumaquamarine: 0x66cdaa,\n  mediumblue: 0x0000cd,\n  mediumorchid: 0xba55d3,\n  mediumpurple: 0x9370db,\n  mediumseagreen: 0x3cb371,\n  mediumslateblue: 0x7b68ee,\n  mediumspringgreen: 0x00fa9a,\n  mediumturquoise: 0x48d1cc,\n  mediumvioletred: 0xc71585,\n  midnightblue: 0x191970,\n  mintcream: 0xf5fffa,\n  mistyrose: 0xffe4e1,\n  moccasin: 0xffe4b5,\n  navajowhite: 0xffdead,\n  navy: 0x000080,\n  oldlace: 0xfdf5e6,\n  olive: 0x808000,\n  olivedrab: 0x6b8e23,\n  orange: 0xffa500,\n  orangered: 0xff4500,\n  orchid: 0xda70d6,\n  palegoldenrod: 0xeee8aa,\n  palegreen: 0x98fb98,\n  paleturquoise: 0xafeeee,\n  palevioletred: 0xdb7093,\n  papayawhip: 0xffefd5,\n  peachpuff: 0xffdab9,\n  peru: 0xcd853f,\n  pink: 0xffc0cb,\n  plum: 0xdda0dd,\n  powderblue: 0xb0e0e6,\n  purple: 0x800080,\n  rebeccapurple: 0x663399,\n  red: 0xff0000,\n  rosybrown: 0xbc8f8f,\n  royalblue: 0x4169e1,\n  saddlebrown: 0x8b4513,\n  salmon: 0xfa8072,\n  sandybrown: 0xf4a460,\n  seagreen: 0x2e8b57,\n  seashell: 0xfff5ee,\n  sienna: 0xa0522d,\n  silver: 0xc0c0c0,\n  skyblue: 0x87ceeb,\n  slateblue: 0x6a5acd,\n  slategray: 0x708090,\n  slategrey: 0x708090,\n  snow: 0xfffafa,\n  springgreen: 0x00ff7f,\n  steelblue: 0x4682b4,\n  tan: 0xd2b48c,\n  teal: 0x008080,\n  thistle: 0xd8bfd8,\n  tomato: 0xff6347,\n  turquoise: 0x40e0d0,\n  violet: 0xee82ee,\n  wheat: 0xf5deb3,\n  white: 0xffffff,\n  whitesmoke: 0xf5f5f5,\n  yellow: 0xffff00,\n  yellowgreen: 0x9acd32\n};\n\ndefine(Color, color, {\n  displayable: function() {\n    return this.rgb().displayable();\n  },\n  toString: function() {\n    return this.rgb() + \"\";\n  }\n});\n\nfunction color(format) {\n  var m;\n  format = (format + \"\").trim().toLowerCase();\n  return (m = reHex3.exec(format)) ? (m = parseInt(m[1], 16), new Rgb((m >> 8 & 0xf) | (m >> 4 & 0x0f0), (m >> 4 & 0xf) | (m & 0xf0), ((m & 0xf) << 4) | (m & 0xf), 1)) // #f00\n      : (m = reHex6.exec(format)) ? rgbn(parseInt(m[1], 16)) // #ff0000\n      : (m = reRgbInteger.exec(format)) ? new Rgb(m[1], m[2], m[3], 1) // rgb(255, 0, 0)\n      : (m = reRgbPercent.exec(format)) ? new Rgb(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) // rgb(100%, 0%, 0%)\n      : (m = reRgbaInteger.exec(format)) ? rgba(m[1], m[2], m[3], m[4]) // rgba(255, 0, 0, 1)\n      : (m = reRgbaPercent.exec(format)) ? rgba(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) // rgb(100%, 0%, 0%, 1)\n      : (m = reHslPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) // hsl(120, 50%, 50%)\n      : (m = reHslaPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) // hsla(120, 50%, 50%, 1)\n      : named.hasOwnProperty(format) ? rgbn(named[format])\n      : format === \"transparent\" ? new Rgb(NaN, NaN, NaN, 0)\n      : null;\n}\n\nfunction rgbn(n) {\n  return new Rgb(n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff, 1);\n}\n\nfunction rgba(r, g, b, a) {\n  if (a <= 0) r = g = b = NaN;\n  return new Rgb(r, g, b, a);\n}\n\nfunction rgbConvert(o) {\n  if (!(o instanceof Color)) o = color(o);\n  if (!o) return new Rgb;\n  o = o.rgb();\n  return new Rgb(o.r, o.g, o.b, o.opacity);\n}\n\nfunction rgb(r, g, b, opacity) {\n  return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity);\n}\n\nfunction Rgb(r, g, b, opacity) {\n  this.r = +r;\n  this.g = +g;\n  this.b = +b;\n  this.opacity = +opacity;\n}\n\ndefine(Rgb, rgb, extend(Color, {\n  brighter: function(k) {\n    k = k == null ? brighter : Math.pow(brighter, k);\n    return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);\n  },\n  darker: function(k) {\n    k = k == null ? darker : Math.pow(darker, k);\n    return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);\n  },\n  rgb: function() {\n    return this;\n  },\n  displayable: function() {\n    return (0 <= this.r && this.r <= 255)\n        && (0 <= this.g && this.g <= 255)\n        && (0 <= this.b && this.b <= 255)\n        && (0 <= this.opacity && this.opacity <= 1);\n  },\n  toString: function() {\n    var a = this.opacity; a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a));\n    return (a === 1 ? \"rgb(\" : \"rgba(\")\n        + Math.max(0, Math.min(255, Math.round(this.r) || 0)) + \", \"\n        + Math.max(0, Math.min(255, Math.round(this.g) || 0)) + \", \"\n        + Math.max(0, Math.min(255, Math.round(this.b) || 0))\n        + (a === 1 ? \")\" : \", \" + a + \")\");\n  }\n}));\n\nfunction hsla(h, s, l, a) {\n  if (a <= 0) h = s = l = NaN;\n  else if (l <= 0 || l >= 1) h = s = NaN;\n  else if (s <= 0) h = NaN;\n  return new Hsl(h, s, l, a);\n}\n\nfunction hslConvert(o) {\n  if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity);\n  if (!(o instanceof Color)) o = color(o);\n  if (!o) return new Hsl;\n  if (o instanceof Hsl) return o;\n  o = o.rgb();\n  var r = o.r / 255,\n      g = o.g / 255,\n      b = o.b / 255,\n      min = Math.min(r, g, b),\n      max = Math.max(r, g, b),\n      h = NaN,\n      s = max - min,\n      l = (max + min) / 2;\n  if (s) {\n    if (r === max) h = (g - b) / s + (g < b) * 6;\n    else if (g === max) h = (b - r) / s + 2;\n    else h = (r - g) / s + 4;\n    s /= l < 0.5 ? max + min : 2 - max - min;\n    h *= 60;\n  } else {\n    s = l > 0 && l < 1 ? 0 : h;\n  }\n  return new Hsl(h, s, l, o.opacity);\n}\n\nfunction hsl(h, s, l, opacity) {\n  return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity);\n}\n\nfunction Hsl(h, s, l, opacity) {\n  this.h = +h;\n  this.s = +s;\n  this.l = +l;\n  this.opacity = +opacity;\n}\n\ndefine(Hsl, hsl, extend(Color, {\n  brighter: function(k) {\n    k = k == null ? brighter : Math.pow(brighter, k);\n    return new Hsl(this.h, this.s, this.l * k, this.opacity);\n  },\n  darker: function(k) {\n    k = k == null ? darker : Math.pow(darker, k);\n    return new Hsl(this.h, this.s, this.l * k, this.opacity);\n  },\n  rgb: function() {\n    var h = this.h % 360 + (this.h < 0) * 360,\n        s = isNaN(h) || isNaN(this.s) ? 0 : this.s,\n        l = this.l,\n        m2 = l + (l < 0.5 ? l : 1 - l) * s,\n        m1 = 2 * l - m2;\n    return new Rgb(\n      hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2),\n      hsl2rgb(h, m1, m2),\n      hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2),\n      this.opacity\n    );\n  },\n  displayable: function() {\n    return (0 <= this.s && this.s <= 1 || isNaN(this.s))\n        && (0 <= this.l && this.l <= 1)\n        && (0 <= this.opacity && this.opacity <= 1);\n  }\n}));\n\n/* From FvD 13.37, CSS Color Module Level 3 */\nfunction hsl2rgb(h, m1, m2) {\n  return (h < 60 ? m1 + (m2 - m1) * h / 60\n      : h < 180 ? m2\n      : h < 240 ? m1 + (m2 - m1) * (240 - h) / 60\n      : m1) * 255;\n}\n\nvar deg2rad = Math.PI / 180;\nvar rad2deg = 180 / Math.PI;\n\nvar Kn = 18;\nvar Xn = 0.950470;\nvar Yn = 1;\nvar Zn = 1.088830;\nvar t0 = 4 / 29;\nvar t1 = 6 / 29;\nvar t2 = 3 * t1 * t1;\nvar t3 = t1 * t1 * t1;\n\nfunction labConvert(o) {\n  if (o instanceof Lab) return new Lab(o.l, o.a, o.b, o.opacity);\n  if (o instanceof Hcl) {\n    var h = o.h * deg2rad;\n    return new Lab(o.l, Math.cos(h) * o.c, Math.sin(h) * o.c, o.opacity);\n  }\n  if (!(o instanceof Rgb)) o = rgbConvert(o);\n  var b = rgb2xyz(o.r),\n      a = rgb2xyz(o.g),\n      l = rgb2xyz(o.b),\n      x = xyz2lab((0.4124564 * b + 0.3575761 * a + 0.1804375 * l) / Xn),\n      y = xyz2lab((0.2126729 * b + 0.7151522 * a + 0.0721750 * l) / Yn),\n      z = xyz2lab((0.0193339 * b + 0.1191920 * a + 0.9503041 * l) / Zn);\n  return new Lab(116 * y - 16, 500 * (x - y), 200 * (y - z), o.opacity);\n}\n\nfunction lab(l, a, b, opacity) {\n  return arguments.length === 1 ? labConvert(l) : new Lab(l, a, b, opacity == null ? 1 : opacity);\n}\n\nfunction Lab(l, a, b, opacity) {\n  this.l = +l;\n  this.a = +a;\n  this.b = +b;\n  this.opacity = +opacity;\n}\n\ndefine(Lab, lab, extend(Color, {\n  brighter: function(k) {\n    return new Lab(this.l + Kn * (k == null ? 1 : k), this.a, this.b, this.opacity);\n  },\n  darker: function(k) {\n    return new Lab(this.l - Kn * (k == null ? 1 : k), this.a, this.b, this.opacity);\n  },\n  rgb: function() {\n    var y = (this.l + 16) / 116,\n        x = isNaN(this.a) ? y : y + this.a / 500,\n        z = isNaN(this.b) ? y : y - this.b / 200;\n    y = Yn * lab2xyz(y);\n    x = Xn * lab2xyz(x);\n    z = Zn * lab2xyz(z);\n    return new Rgb(\n      xyz2rgb( 3.2404542 * x - 1.5371385 * y - 0.4985314 * z), // D65 -> sRGB\n      xyz2rgb(-0.9692660 * x + 1.8760108 * y + 0.0415560 * z),\n      xyz2rgb( 0.0556434 * x - 0.2040259 * y + 1.0572252 * z),\n      this.opacity\n    );\n  }\n}));\n\nfunction xyz2lab(t) {\n  return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0;\n}\n\nfunction lab2xyz(t) {\n  return t > t1 ? t * t * t : t2 * (t - t0);\n}\n\nfunction xyz2rgb(x) {\n  return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055);\n}\n\nfunction rgb2xyz(x) {\n  return (x /= 255) <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4);\n}\n\nfunction hclConvert(o) {\n  if (o instanceof Hcl) return new Hcl(o.h, o.c, o.l, o.opacity);\n  if (!(o instanceof Lab)) o = labConvert(o);\n  var h = Math.atan2(o.b, o.a) * rad2deg;\n  return new Hcl(h < 0 ? h + 360 : h, Math.sqrt(o.a * o.a + o.b * o.b), o.l, o.opacity);\n}\n\nfunction hcl(h, c, l, opacity) {\n  return arguments.length === 1 ? hclConvert(h) : new Hcl(h, c, l, opacity == null ? 1 : opacity);\n}\n\nfunction Hcl(h, c, l, opacity) {\n  this.h = +h;\n  this.c = +c;\n  this.l = +l;\n  this.opacity = +opacity;\n}\n\ndefine(Hcl, hcl, extend(Color, {\n  brighter: function(k) {\n    return new Hcl(this.h, this.c, this.l + Kn * (k == null ? 1 : k), this.opacity);\n  },\n  darker: function(k) {\n    return new Hcl(this.h, this.c, this.l - Kn * (k == null ? 1 : k), this.opacity);\n  },\n  rgb: function() {\n    return labConvert(this).rgb();\n  }\n}));\n\nvar A = -0.14861;\nvar B = +1.78277;\nvar C = -0.29227;\nvar D = -0.90649;\nvar E = +1.97294;\nvar ED = E * D;\nvar EB = E * B;\nvar BC_DA = B * C - D * A;\n\nfunction cubehelixConvert(o) {\n  if (o instanceof Cubehelix) return new Cubehelix(o.h, o.s, o.l, o.opacity);\n  if (!(o instanceof Rgb)) o = rgbConvert(o);\n  var r = o.r / 255,\n      g = o.g / 255,\n      b = o.b / 255,\n      l = (BC_DA * b + ED * r - EB * g) / (BC_DA + ED - EB),\n      bl = b - l,\n      k = (E * (g - l) - C * bl) / D,\n      s = Math.sqrt(k * k + bl * bl) / (E * l * (1 - l)), // NaN if l=0 or l=1\n      h = s ? Math.atan2(k, bl) * rad2deg - 120 : NaN;\n  return new Cubehelix(h < 0 ? h + 360 : h, s, l, o.opacity);\n}\n\nfunction cubehelix(h, s, l, opacity) {\n  return arguments.length === 1 ? cubehelixConvert(h) : new Cubehelix(h, s, l, opacity == null ? 1 : opacity);\n}\n\nfunction Cubehelix(h, s, l, opacity) {\n  this.h = +h;\n  this.s = +s;\n  this.l = +l;\n  this.opacity = +opacity;\n}\n\ndefine(Cubehelix, cubehelix, extend(Color, {\n  brighter: function(k) {\n    k = k == null ? brighter : Math.pow(brighter, k);\n    return new Cubehelix(this.h, this.s, this.l * k, this.opacity);\n  },\n  darker: function(k) {\n    k = k == null ? darker : Math.pow(darker, k);\n    return new Cubehelix(this.h, this.s, this.l * k, this.opacity);\n  },\n  rgb: function() {\n    var h = isNaN(this.h) ? 0 : (this.h + 120) * deg2rad,\n        l = +this.l,\n        a = isNaN(this.s) ? 0 : this.s * l * (1 - l),\n        cosh = Math.cos(h),\n        sinh = Math.sin(h);\n    return new Rgb(\n      255 * (l + a * (A * cosh + B * sinh)),\n      255 * (l + a * (C * cosh + D * sinh)),\n      255 * (l + a * (E * cosh)),\n      this.opacity\n    );\n  }\n}));\n\nfunction basis(t1, v0, v1, v2, v3) {\n  var t2 = t1 * t1, t3 = t2 * t1;\n  return ((1 - 3 * t1 + 3 * t2 - t3) * v0\n      + (4 - 6 * t2 + 3 * t3) * v1\n      + (1 + 3 * t1 + 3 * t2 - 3 * t3) * v2\n      + t3 * v3) / 6;\n}\n\nvar basis$1 = function(values) {\n  var n = values.length - 1;\n  return function(t) {\n    var i = t <= 0 ? (t = 0) : t >= 1 ? (t = 1, n - 1) : Math.floor(t * n),\n        v1 = values[i],\n        v2 = values[i + 1],\n        v0 = i > 0 ? values[i - 1] : 2 * v1 - v2,\n        v3 = i < n - 1 ? values[i + 2] : 2 * v2 - v1;\n    return basis((t - i / n) * n, v0, v1, v2, v3);\n  };\n};\n\nvar basisClosed = function(values) {\n  var n = values.length;\n  return function(t) {\n    var i = Math.floor(((t %= 1) < 0 ? ++t : t) * n),\n        v0 = values[(i + n - 1) % n],\n        v1 = values[i % n],\n        v2 = values[(i + 1) % n],\n        v3 = values[(i + 2) % n];\n    return basis((t - i / n) * n, v0, v1, v2, v3);\n  };\n};\n\nvar constant$3 = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nfunction linear(a, d) {\n  return function(t) {\n    return a + t * d;\n  };\n}\n\nfunction exponential(a, b, y) {\n  return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function(t) {\n    return Math.pow(a + t * b, y);\n  };\n}\n\nfunction hue(a, b) {\n  var d = b - a;\n  return d ? linear(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : constant$3(isNaN(a) ? b : a);\n}\n\nfunction gamma(y) {\n  return (y = +y) === 1 ? nogamma : function(a, b) {\n    return b - a ? exponential(a, b, y) : constant$3(isNaN(a) ? b : a);\n  };\n}\n\nfunction nogamma(a, b) {\n  var d = b - a;\n  return d ? linear(a, d) : constant$3(isNaN(a) ? b : a);\n}\n\nvar interpolateRgb = ((function rgbGamma(y) {\n  var color$$1 = gamma(y);\n\n  function rgb$$1(start, end) {\n    var r = color$$1((start = rgb(start)).r, (end = rgb(end)).r),\n        g = color$$1(start.g, end.g),\n        b = color$$1(start.b, end.b),\n        opacity = nogamma(start.opacity, end.opacity);\n    return function(t) {\n      start.r = r(t);\n      start.g = g(t);\n      start.b = b(t);\n      start.opacity = opacity(t);\n      return start + \"\";\n    };\n  }\n\n  rgb$$1.gamma = rgbGamma;\n\n  return rgb$$1;\n}))(1);\n\nfunction rgbSpline(spline) {\n  return function(colors) {\n    var n = colors.length,\n        r = new Array(n),\n        g = new Array(n),\n        b = new Array(n),\n        i, color$$1;\n    for (i = 0; i < n; ++i) {\n      color$$1 = rgb(colors[i]);\n      r[i] = color$$1.r || 0;\n      g[i] = color$$1.g || 0;\n      b[i] = color$$1.b || 0;\n    }\n    r = spline(r);\n    g = spline(g);\n    b = spline(b);\n    color$$1.opacity = 1;\n    return function(t) {\n      color$$1.r = r(t);\n      color$$1.g = g(t);\n      color$$1.b = b(t);\n      return color$$1 + \"\";\n    };\n  };\n}\n\nvar rgbBasis = rgbSpline(basis$1);\nvar rgbBasisClosed = rgbSpline(basisClosed);\n\nvar array$1 = function(a, b) {\n  var nb = b ? b.length : 0,\n      na = a ? Math.min(nb, a.length) : 0,\n      x = new Array(nb),\n      c = new Array(nb),\n      i;\n\n  for (i = 0; i < na; ++i) x[i] = interpolateValue(a[i], b[i]);\n  for (; i < nb; ++i) c[i] = b[i];\n\n  return function(t) {\n    for (i = 0; i < na; ++i) c[i] = x[i](t);\n    return c;\n  };\n};\n\nvar date = function(a, b) {\n  var d = new Date;\n  return a = +a, b -= a, function(t) {\n    return d.setTime(a + b * t), d;\n  };\n};\n\nvar reinterpolate = function(a, b) {\n  return a = +a, b -= a, function(t) {\n    return a + b * t;\n  };\n};\n\nvar object = function(a, b) {\n  var i = {},\n      c = {},\n      k;\n\n  if (a === null || typeof a !== \"object\") a = {};\n  if (b === null || typeof b !== \"object\") b = {};\n\n  for (k in b) {\n    if (k in a) {\n      i[k] = interpolateValue(a[k], b[k]);\n    } else {\n      c[k] = b[k];\n    }\n  }\n\n  return function(t) {\n    for (k in i) c[k] = i[k](t);\n    return c;\n  };\n};\n\nvar reA = /[-+]?(?:\\d+\\.?\\d*|\\.?\\d+)(?:[eE][-+]?\\d+)?/g;\nvar reB = new RegExp(reA.source, \"g\");\n\nfunction zero(b) {\n  return function() {\n    return b;\n  };\n}\n\nfunction one(b) {\n  return function(t) {\n    return b(t) + \"\";\n  };\n}\n\nvar interpolateString = function(a, b) {\n  var bi = reA.lastIndex = reB.lastIndex = 0, // scan index for next number in b\n      am, // current match in a\n      bm, // current match in b\n      bs, // string preceding current number in b, if any\n      i = -1, // index in s\n      s = [], // string constants and placeholders\n      q = []; // number interpolators\n\n  // Coerce inputs to strings.\n  a = a + \"\", b = b + \"\";\n\n  // Interpolate pairs of numbers in a & b.\n  while ((am = reA.exec(a))\n      && (bm = reB.exec(b))) {\n    if ((bs = bm.index) > bi) { // a string precedes the next number in b\n      bs = b.slice(bi, bs);\n      if (s[i]) s[i] += bs; // coalesce with previous string\n      else s[++i] = bs;\n    }\n    if ((am = am[0]) === (bm = bm[0])) { // numbers in a & b match\n      if (s[i]) s[i] += bm; // coalesce with previous string\n      else s[++i] = bm;\n    } else { // interpolate non-matching numbers\n      s[++i] = null;\n      q.push({i: i, x: reinterpolate(am, bm)});\n    }\n    bi = reB.lastIndex;\n  }\n\n  // Add remains of b.\n  if (bi < b.length) {\n    bs = b.slice(bi);\n    if (s[i]) s[i] += bs; // coalesce with previous string\n    else s[++i] = bs;\n  }\n\n  // Special optimization for only a single match.\n  // Otherwise, interpolate each of the numbers and rejoin the string.\n  return s.length < 2 ? (q[0]\n      ? one(q[0].x)\n      : zero(b))\n      : (b = q.length, function(t) {\n          for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t);\n          return s.join(\"\");\n        });\n};\n\nvar interpolateValue = function(a, b) {\n  var t = typeof b, c;\n  return b == null || t === \"boolean\" ? constant$3(b)\n      : (t === \"number\" ? reinterpolate\n      : t === \"string\" ? ((c = color(b)) ? (b = c, interpolateRgb) : interpolateString)\n      : b instanceof color ? interpolateRgb\n      : b instanceof Date ? date\n      : Array.isArray(b) ? array$1\n      : isNaN(b) ? object\n      : reinterpolate)(a, b);\n};\n\nvar interpolateRound = function(a, b) {\n  return a = +a, b -= a, function(t) {\n    return Math.round(a + b * t);\n  };\n};\n\nvar degrees = 180 / Math.PI;\n\nvar identity$2 = {\n  translateX: 0,\n  translateY: 0,\n  rotate: 0,\n  skewX: 0,\n  scaleX: 1,\n  scaleY: 1\n};\n\nvar decompose = function(a, b, c, d, e, f) {\n  var scaleX, scaleY, skewX;\n  if (scaleX = Math.sqrt(a * a + b * b)) a /= scaleX, b /= scaleX;\n  if (skewX = a * c + b * d) c -= a * skewX, d -= b * skewX;\n  if (scaleY = Math.sqrt(c * c + d * d)) c /= scaleY, d /= scaleY, skewX /= scaleY;\n  if (a * d < b * c) a = -a, b = -b, skewX = -skewX, scaleX = -scaleX;\n  return {\n    translateX: e,\n    translateY: f,\n    rotate: Math.atan2(b, a) * degrees,\n    skewX: Math.atan(skewX) * degrees,\n    scaleX: scaleX,\n    scaleY: scaleY\n  };\n};\n\nvar cssNode;\nvar cssRoot;\nvar cssView;\nvar svgNode;\n\nfunction parseCss(value) {\n  if (value === \"none\") return identity$2;\n  if (!cssNode) cssNode = document.createElement(\"DIV\"), cssRoot = document.documentElement, cssView = document.defaultView;\n  cssNode.style.transform = value;\n  value = cssView.getComputedStyle(cssRoot.appendChild(cssNode), null).getPropertyValue(\"transform\");\n  cssRoot.removeChild(cssNode);\n  value = value.slice(7, -1).split(\",\");\n  return decompose(+value[0], +value[1], +value[2], +value[3], +value[4], +value[5]);\n}\n\nfunction parseSvg(value) {\n  if (value == null) return identity$2;\n  if (!svgNode) svgNode = document.createElementNS(\"http://www.w3.org/2000/svg\", \"g\");\n  svgNode.setAttribute(\"transform\", value);\n  if (!(value = svgNode.transform.baseVal.consolidate())) return identity$2;\n  value = value.matrix;\n  return decompose(value.a, value.b, value.c, value.d, value.e, value.f);\n}\n\nfunction interpolateTransform(parse, pxComma, pxParen, degParen) {\n\n  function pop(s) {\n    return s.length ? s.pop() + \" \" : \"\";\n  }\n\n  function translate(xa, ya, xb, yb, s, q) {\n    if (xa !== xb || ya !== yb) {\n      var i = s.push(\"translate(\", null, pxComma, null, pxParen);\n      q.push({i: i - 4, x: reinterpolate(xa, xb)}, {i: i - 2, x: reinterpolate(ya, yb)});\n    } else if (xb || yb) {\n      s.push(\"translate(\" + xb + pxComma + yb + pxParen);\n    }\n  }\n\n  function rotate(a, b, s, q) {\n    if (a !== b) {\n      if (a - b > 180) b += 360; else if (b - a > 180) a += 360; // shortest path\n      q.push({i: s.push(pop(s) + \"rotate(\", null, degParen) - 2, x: reinterpolate(a, b)});\n    } else if (b) {\n      s.push(pop(s) + \"rotate(\" + b + degParen);\n    }\n  }\n\n  function skewX(a, b, s, q) {\n    if (a !== b) {\n      q.push({i: s.push(pop(s) + \"skewX(\", null, degParen) - 2, x: reinterpolate(a, b)});\n    } else if (b) {\n      s.push(pop(s) + \"skewX(\" + b + degParen);\n    }\n  }\n\n  function scale(xa, ya, xb, yb, s, q) {\n    if (xa !== xb || ya !== yb) {\n      var i = s.push(pop(s) + \"scale(\", null, \",\", null, \")\");\n      q.push({i: i - 4, x: reinterpolate(xa, xb)}, {i: i - 2, x: reinterpolate(ya, yb)});\n    } else if (xb !== 1 || yb !== 1) {\n      s.push(pop(s) + \"scale(\" + xb + \",\" + yb + \")\");\n    }\n  }\n\n  return function(a, b) {\n    var s = [], // string constants and placeholders\n        q = []; // number interpolators\n    a = parse(a), b = parse(b);\n    translate(a.translateX, a.translateY, b.translateX, b.translateY, s, q);\n    rotate(a.rotate, b.rotate, s, q);\n    skewX(a.skewX, b.skewX, s, q);\n    scale(a.scaleX, a.scaleY, b.scaleX, b.scaleY, s, q);\n    a = b = null; // gc\n    return function(t) {\n      var i = -1, n = q.length, o;\n      while (++i < n) s[(o = q[i]).i] = o.x(t);\n      return s.join(\"\");\n    };\n  };\n}\n\nvar interpolateTransformCss = interpolateTransform(parseCss, \"px, \", \"px)\", \"deg)\");\nvar interpolateTransformSvg = interpolateTransform(parseSvg, \", \", \")\", \")\");\n\nvar rho = Math.SQRT2;\nvar rho2 = 2;\nvar rho4 = 4;\nvar epsilon2 = 1e-12;\n\nfunction cosh(x) {\n  return ((x = Math.exp(x)) + 1 / x) / 2;\n}\n\nfunction sinh(x) {\n  return ((x = Math.exp(x)) - 1 / x) / 2;\n}\n\nfunction tanh(x) {\n  return ((x = Math.exp(2 * x)) - 1) / (x + 1);\n}\n\n// p0 = [ux0, uy0, w0]\n// p1 = [ux1, uy1, w1]\nvar interpolateZoom = function(p0, p1) {\n  var ux0 = p0[0], uy0 = p0[1], w0 = p0[2],\n      ux1 = p1[0], uy1 = p1[1], w1 = p1[2],\n      dx = ux1 - ux0,\n      dy = uy1 - uy0,\n      d2 = dx * dx + dy * dy,\n      i,\n      S;\n\n  // Special case for u0 ≅ u1.\n  if (d2 < epsilon2) {\n    S = Math.log(w1 / w0) / rho;\n    i = function(t) {\n      return [\n        ux0 + t * dx,\n        uy0 + t * dy,\n        w0 * Math.exp(rho * t * S)\n      ];\n    };\n  }\n\n  // General case.\n  else {\n    var d1 = Math.sqrt(d2),\n        b0 = (w1 * w1 - w0 * w0 + rho4 * d2) / (2 * w0 * rho2 * d1),\n        b1 = (w1 * w1 - w0 * w0 - rho4 * d2) / (2 * w1 * rho2 * d1),\n        r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0),\n        r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1);\n    S = (r1 - r0) / rho;\n    i = function(t) {\n      var s = t * S,\n          coshr0 = cosh(r0),\n          u = w0 / (rho2 * d1) * (coshr0 * tanh(rho * s + r0) - sinh(r0));\n      return [\n        ux0 + u * dx,\n        uy0 + u * dy,\n        w0 * coshr0 / cosh(rho * s + r0)\n      ];\n    };\n  }\n\n  i.duration = S * 1000;\n\n  return i;\n};\n\nfunction hsl$1(hue$$1) {\n  return function(start, end) {\n    var h = hue$$1((start = hsl(start)).h, (end = hsl(end)).h),\n        s = nogamma(start.s, end.s),\n        l = nogamma(start.l, end.l),\n        opacity = nogamma(start.opacity, end.opacity);\n    return function(t) {\n      start.h = h(t);\n      start.s = s(t);\n      start.l = l(t);\n      start.opacity = opacity(t);\n      return start + \"\";\n    };\n  }\n}\n\nvar hsl$2 = hsl$1(hue);\nvar hslLong = hsl$1(nogamma);\n\nfunction lab$1(start, end) {\n  var l = nogamma((start = lab(start)).l, (end = lab(end)).l),\n      a = nogamma(start.a, end.a),\n      b = nogamma(start.b, end.b),\n      opacity = nogamma(start.opacity, end.opacity);\n  return function(t) {\n    start.l = l(t);\n    start.a = a(t);\n    start.b = b(t);\n    start.opacity = opacity(t);\n    return start + \"\";\n  };\n}\n\nfunction hcl$1(hue$$1) {\n  return function(start, end) {\n    var h = hue$$1((start = hcl(start)).h, (end = hcl(end)).h),\n        c = nogamma(start.c, end.c),\n        l = nogamma(start.l, end.l),\n        opacity = nogamma(start.opacity, end.opacity);\n    return function(t) {\n      start.h = h(t);\n      start.c = c(t);\n      start.l = l(t);\n      start.opacity = opacity(t);\n      return start + \"\";\n    };\n  }\n}\n\nvar hcl$2 = hcl$1(hue);\nvar hclLong = hcl$1(nogamma);\n\nfunction cubehelix$1(hue$$1) {\n  return (function cubehelixGamma(y) {\n    y = +y;\n\n    function cubehelix$$1(start, end) {\n      var h = hue$$1((start = cubehelix(start)).h, (end = cubehelix(end)).h),\n          s = nogamma(start.s, end.s),\n          l = nogamma(start.l, end.l),\n          opacity = nogamma(start.opacity, end.opacity);\n      return function(t) {\n        start.h = h(t);\n        start.s = s(t);\n        start.l = l(Math.pow(t, y));\n        start.opacity = opacity(t);\n        return start + \"\";\n      };\n    }\n\n    cubehelix$$1.gamma = cubehelixGamma;\n\n    return cubehelix$$1;\n  })(1);\n}\n\nvar cubehelix$2 = cubehelix$1(hue);\nvar cubehelixLong = cubehelix$1(nogamma);\n\nvar quantize = function(interpolator, n) {\n  var samples = new Array(n);\n  for (var i = 0; i < n; ++i) samples[i] = interpolator(i / (n - 1));\n  return samples;\n};\n\nvar frame = 0;\nvar timeout = 0;\nvar interval = 0;\nvar pokeDelay = 1000;\nvar taskHead;\nvar taskTail;\nvar clockLast = 0;\nvar clockNow = 0;\nvar clockSkew = 0;\nvar clock = typeof performance === \"object\" && performance.now ? performance : Date;\nvar setFrame = typeof requestAnimationFrame === \"function\" ? requestAnimationFrame : function(f) { setTimeout(f, 17); };\n\nfunction now() {\n  return clockNow || (setFrame(clearNow), clockNow = clock.now() + clockSkew);\n}\n\nfunction clearNow() {\n  clockNow = 0;\n}\n\nfunction Timer() {\n  this._call =\n  this._time =\n  this._next = null;\n}\n\nTimer.prototype = timer.prototype = {\n  constructor: Timer,\n  restart: function(callback, delay, time) {\n    if (typeof callback !== \"function\") throw new TypeError(\"callback is not a function\");\n    time = (time == null ? now() : +time) + (delay == null ? 0 : +delay);\n    if (!this._next && taskTail !== this) {\n      if (taskTail) taskTail._next = this;\n      else taskHead = this;\n      taskTail = this;\n    }\n    this._call = callback;\n    this._time = time;\n    sleep();\n  },\n  stop: function() {\n    if (this._call) {\n      this._call = null;\n      this._time = Infinity;\n      sleep();\n    }\n  }\n};\n\nfunction timer(callback, delay, time) {\n  var t = new Timer;\n  t.restart(callback, delay, time);\n  return t;\n}\n\nfunction timerFlush() {\n  now(); // Get the current time, if not already set.\n  ++frame; // Pretend we’ve set an alarm, if we haven’t already.\n  var t = taskHead, e;\n  while (t) {\n    if ((e = clockNow - t._time) >= 0) t._call.call(null, e);\n    t = t._next;\n  }\n  --frame;\n}\n\nfunction wake() {\n  clockNow = (clockLast = clock.now()) + clockSkew;\n  frame = timeout = 0;\n  try {\n    timerFlush();\n  } finally {\n    frame = 0;\n    nap();\n    clockNow = 0;\n  }\n}\n\nfunction poke() {\n  var now = clock.now(), delay = now - clockLast;\n  if (delay > pokeDelay) clockSkew -= delay, clockLast = now;\n}\n\nfunction nap() {\n  var t0, t1 = taskHead, t2, time = Infinity;\n  while (t1) {\n    if (t1._call) {\n      if (time > t1._time) time = t1._time;\n      t0 = t1, t1 = t1._next;\n    } else {\n      t2 = t1._next, t1._next = null;\n      t1 = t0 ? t0._next = t2 : taskHead = t2;\n    }\n  }\n  taskTail = t0;\n  sleep(time);\n}\n\nfunction sleep(time) {\n  if (frame) return; // Soonest alarm already set, or will be.\n  if (timeout) timeout = clearTimeout(timeout);\n  var delay = time - clockNow;\n  if (delay > 24) {\n    if (time < Infinity) timeout = setTimeout(wake, delay);\n    if (interval) interval = clearInterval(interval);\n  } else {\n    if (!interval) clockLast = clockNow, interval = setInterval(poke, pokeDelay);\n    frame = 1, setFrame(wake);\n  }\n}\n\nvar timeout$1 = function(callback, delay, time) {\n  var t = new Timer;\n  delay = delay == null ? 0 : +delay;\n  t.restart(function(elapsed) {\n    t.stop();\n    callback(elapsed + delay);\n  }, delay, time);\n  return t;\n};\n\nvar interval$1 = function(callback, delay, time) {\n  var t = new Timer, total = delay;\n  if (delay == null) return t.restart(callback, delay, time), t;\n  delay = +delay, time = time == null ? now() : +time;\n  t.restart(function tick(elapsed) {\n    elapsed += total;\n    t.restart(tick, total += delay, time);\n    callback(elapsed);\n  }, delay, time);\n  return t;\n};\n\nvar emptyOn = dispatch(\"start\", \"end\", \"interrupt\");\nvar emptyTween = [];\n\nvar CREATED = 0;\nvar SCHEDULED = 1;\nvar STARTING = 2;\nvar STARTED = 3;\nvar RUNNING = 4;\nvar ENDING = 5;\nvar ENDED = 6;\n\nvar schedule = function(node, name, id, index, group, timing) {\n  var schedules = node.__transition;\n  if (!schedules) node.__transition = {};\n  else if (id in schedules) return;\n  create(node, id, {\n    name: name,\n    index: index, // For context during callback.\n    group: group, // For context during callback.\n    on: emptyOn,\n    tween: emptyTween,\n    time: timing.time,\n    delay: timing.delay,\n    duration: timing.duration,\n    ease: timing.ease,\n    timer: null,\n    state: CREATED\n  });\n};\n\nfunction init(node, id) {\n  var schedule = node.__transition;\n  if (!schedule || !(schedule = schedule[id]) || schedule.state > CREATED) throw new Error(\"too late\");\n  return schedule;\n}\n\nfunction set$1(node, id) {\n  var schedule = node.__transition;\n  if (!schedule || !(schedule = schedule[id]) || schedule.state > STARTING) throw new Error(\"too late\");\n  return schedule;\n}\n\nfunction get$1(node, id) {\n  var schedule = node.__transition;\n  if (!schedule || !(schedule = schedule[id])) throw new Error(\"too late\");\n  return schedule;\n}\n\nfunction create(node, id, self) {\n  var schedules = node.__transition,\n      tween;\n\n  // Initialize the self timer when the transition is created.\n  // Note the actual delay is not known until the first callback!\n  schedules[id] = self;\n  self.timer = timer(schedule, 0, self.time);\n\n  function schedule(elapsed) {\n    self.state = SCHEDULED;\n    self.timer.restart(start, self.delay, self.time);\n\n    // If the elapsed delay is less than our first sleep, start immediately.\n    if (self.delay <= elapsed) start(elapsed - self.delay);\n  }\n\n  function start(elapsed) {\n    var i, j, n, o;\n\n    // If the state is not SCHEDULED, then we previously errored on start.\n    if (self.state !== SCHEDULED) return stop();\n\n    for (i in schedules) {\n      o = schedules[i];\n      if (o.name !== self.name) continue;\n\n      // While this element already has a starting transition during this frame,\n      // defer starting an interrupting transition until that transition has a\n      // chance to tick (and possibly end); see d3/d3-transition#54!\n      if (o.state === STARTED) return timeout$1(start);\n\n      // Interrupt the active transition, if any.\n      // Dispatch the interrupt event.\n      if (o.state === RUNNING) {\n        o.state = ENDED;\n        o.timer.stop();\n        o.on.call(\"interrupt\", node, node.__data__, o.index, o.group);\n        delete schedules[i];\n      }\n\n      // Cancel any pre-empted transitions. No interrupt event is dispatched\n      // because the cancelled transitions never started. Note that this also\n      // removes this transition from the pending list!\n      else if (+i < id) {\n        o.state = ENDED;\n        o.timer.stop();\n        delete schedules[i];\n      }\n    }\n\n    // Defer the first tick to end of the current frame; see d3/d3#1576.\n    // Note the transition may be canceled after start and before the first tick!\n    // Note this must be scheduled before the start event; see d3/d3-transition#16!\n    // Assuming this is successful, subsequent callbacks go straight to tick.\n    timeout$1(function() {\n      if (self.state === STARTED) {\n        self.state = RUNNING;\n        self.timer.restart(tick, self.delay, self.time);\n        tick(elapsed);\n      }\n    });\n\n    // Dispatch the start event.\n    // Note this must be done before the tween are initialized.\n    self.state = STARTING;\n    self.on.call(\"start\", node, node.__data__, self.index, self.group);\n    if (self.state !== STARTING) return; // interrupted\n    self.state = STARTED;\n\n    // Initialize the tween, deleting null tween.\n    tween = new Array(n = self.tween.length);\n    for (i = 0, j = -1; i < n; ++i) {\n      if (o = self.tween[i].value.call(node, node.__data__, self.index, self.group)) {\n        tween[++j] = o;\n      }\n    }\n    tween.length = j + 1;\n  }\n\n  function tick(elapsed) {\n    var t = elapsed < self.duration ? self.ease.call(null, elapsed / self.duration) : (self.timer.restart(stop), self.state = ENDING, 1),\n        i = -1,\n        n = tween.length;\n\n    while (++i < n) {\n      tween[i].call(null, t);\n    }\n\n    // Dispatch the end event.\n    if (self.state === ENDING) {\n      self.on.call(\"end\", node, node.__data__, self.index, self.group);\n      stop();\n    }\n  }\n\n  function stop() {\n    self.state = ENDED;\n    self.timer.stop();\n    delete schedules[id];\n    for (var i in schedules) return; // eslint-disable-line no-unused-vars\n    delete node.__transition;\n  }\n}\n\nvar interrupt = function(node, name) {\n  var schedules = node.__transition,\n      schedule,\n      active,\n      empty = true,\n      i;\n\n  if (!schedules) return;\n\n  name = name == null ? null : name + \"\";\n\n  for (i in schedules) {\n    if ((schedule = schedules[i]).name !== name) { empty = false; continue; }\n    active = schedule.state > STARTING && schedule.state < ENDING;\n    schedule.state = ENDED;\n    schedule.timer.stop();\n    if (active) schedule.on.call(\"interrupt\", node, node.__data__, schedule.index, schedule.group);\n    delete schedules[i];\n  }\n\n  if (empty) delete node.__transition;\n};\n\nvar selection_interrupt = function(name) {\n  return this.each(function() {\n    interrupt(this, name);\n  });\n};\n\nfunction tweenRemove(id, name) {\n  var tween0, tween1;\n  return function() {\n    var schedule = set$1(this, id),\n        tween = schedule.tween;\n\n    // If this node shared tween with the previous node,\n    // just assign the updated shared tween and we’re done!\n    // Otherwise, copy-on-write.\n    if (tween !== tween0) {\n      tween1 = tween0 = tween;\n      for (var i = 0, n = tween1.length; i < n; ++i) {\n        if (tween1[i].name === name) {\n          tween1 = tween1.slice();\n          tween1.splice(i, 1);\n          break;\n        }\n      }\n    }\n\n    schedule.tween = tween1;\n  };\n}\n\nfunction tweenFunction(id, name, value) {\n  var tween0, tween1;\n  if (typeof value !== \"function\") throw new Error;\n  return function() {\n    var schedule = set$1(this, id),\n        tween = schedule.tween;\n\n    // If this node shared tween with the previous node,\n    // just assign the updated shared tween and we’re done!\n    // Otherwise, copy-on-write.\n    if (tween !== tween0) {\n      tween1 = (tween0 = tween).slice();\n      for (var t = {name: name, value: value}, i = 0, n = tween1.length; i < n; ++i) {\n        if (tween1[i].name === name) {\n          tween1[i] = t;\n          break;\n        }\n      }\n      if (i === n) tween1.push(t);\n    }\n\n    schedule.tween = tween1;\n  };\n}\n\nvar transition_tween = function(name, value) {\n  var id = this._id;\n\n  name += \"\";\n\n  if (arguments.length < 2) {\n    var tween = get$1(this.node(), id).tween;\n    for (var i = 0, n = tween.length, t; i < n; ++i) {\n      if ((t = tween[i]).name === name) {\n        return t.value;\n      }\n    }\n    return null;\n  }\n\n  return this.each((value == null ? tweenRemove : tweenFunction)(id, name, value));\n};\n\nfunction tweenValue(transition, name, value) {\n  var id = transition._id;\n\n  transition.each(function() {\n    var schedule = set$1(this, id);\n    (schedule.value || (schedule.value = {}))[name] = value.apply(this, arguments);\n  });\n\n  return function(node) {\n    return get$1(node, id).value[name];\n  };\n}\n\nvar interpolate$$1 = function(a, b) {\n  var c;\n  return (typeof b === \"number\" ? reinterpolate\n      : b instanceof color ? interpolateRgb\n      : (c = color(b)) ? (b = c, interpolateRgb)\n      : interpolateString)(a, b);\n};\n\nfunction attrRemove$1(name) {\n  return function() {\n    this.removeAttribute(name);\n  };\n}\n\nfunction attrRemoveNS$1(fullname) {\n  return function() {\n    this.removeAttributeNS(fullname.space, fullname.local);\n  };\n}\n\nfunction attrConstant$1(name, interpolate$$1, value1) {\n  var value00,\n      interpolate0;\n  return function() {\n    var value0 = this.getAttribute(name);\n    return value0 === value1 ? null\n        : value0 === value00 ? interpolate0\n        : interpolate0 = interpolate$$1(value00 = value0, value1);\n  };\n}\n\nfunction attrConstantNS$1(fullname, interpolate$$1, value1) {\n  var value00,\n      interpolate0;\n  return function() {\n    var value0 = this.getAttributeNS(fullname.space, fullname.local);\n    return value0 === value1 ? null\n        : value0 === value00 ? interpolate0\n        : interpolate0 = interpolate$$1(value00 = value0, value1);\n  };\n}\n\nfunction attrFunction$1(name, interpolate$$1, value) {\n  var value00,\n      value10,\n      interpolate0;\n  return function() {\n    var value0, value1 = value(this);\n    if (value1 == null) return void this.removeAttribute(name);\n    value0 = this.getAttribute(name);\n    return value0 === value1 ? null\n        : value0 === value00 && value1 === value10 ? interpolate0\n        : interpolate0 = interpolate$$1(value00 = value0, value10 = value1);\n  };\n}\n\nfunction attrFunctionNS$1(fullname, interpolate$$1, value) {\n  var value00,\n      value10,\n      interpolate0;\n  return function() {\n    var value0, value1 = value(this);\n    if (value1 == null) return void this.removeAttributeNS(fullname.space, fullname.local);\n    value0 = this.getAttributeNS(fullname.space, fullname.local);\n    return value0 === value1 ? null\n        : value0 === value00 && value1 === value10 ? interpolate0\n        : interpolate0 = interpolate$$1(value00 = value0, value10 = value1);\n  };\n}\n\nvar transition_attr = function(name, value) {\n  var fullname = namespace(name), i = fullname === \"transform\" ? interpolateTransformSvg : interpolate$$1;\n  return this.attrTween(name, typeof value === \"function\"\n      ? (fullname.local ? attrFunctionNS$1 : attrFunction$1)(fullname, i, tweenValue(this, \"attr.\" + name, value))\n      : value == null ? (fullname.local ? attrRemoveNS$1 : attrRemove$1)(fullname)\n      : (fullname.local ? attrConstantNS$1 : attrConstant$1)(fullname, i, value));\n};\n\nfunction attrTweenNS(fullname, value) {\n  function tween() {\n    var node = this, i = value.apply(node, arguments);\n    return i && function(t) {\n      node.setAttributeNS(fullname.space, fullname.local, i(t));\n    };\n  }\n  tween._value = value;\n  return tween;\n}\n\nfunction attrTween(name, value) {\n  function tween() {\n    var node = this, i = value.apply(node, arguments);\n    return i && function(t) {\n      node.setAttribute(name, i(t));\n    };\n  }\n  tween._value = value;\n  return tween;\n}\n\nvar transition_attrTween = function(name, value) {\n  var key = \"attr.\" + name;\n  if (arguments.length < 2) return (key = this.tween(key)) && key._value;\n  if (value == null) return this.tween(key, null);\n  if (typeof value !== \"function\") throw new Error;\n  var fullname = namespace(name);\n  return this.tween(key, (fullname.local ? attrTweenNS : attrTween)(fullname, value));\n};\n\nfunction delayFunction(id, value) {\n  return function() {\n    init(this, id).delay = +value.apply(this, arguments);\n  };\n}\n\nfunction delayConstant(id, value) {\n  return value = +value, function() {\n    init(this, id).delay = value;\n  };\n}\n\nvar transition_delay = function(value) {\n  var id = this._id;\n\n  return arguments.length\n      ? this.each((typeof value === \"function\"\n          ? delayFunction\n          : delayConstant)(id, value))\n      : get$1(this.node(), id).delay;\n};\n\nfunction durationFunction(id, value) {\n  return function() {\n    set$1(this, id).duration = +value.apply(this, arguments);\n  };\n}\n\nfunction durationConstant(id, value) {\n  return value = +value, function() {\n    set$1(this, id).duration = value;\n  };\n}\n\nvar transition_duration = function(value) {\n  var id = this._id;\n\n  return arguments.length\n      ? this.each((typeof value === \"function\"\n          ? durationFunction\n          : durationConstant)(id, value))\n      : get$1(this.node(), id).duration;\n};\n\nfunction easeConstant(id, value) {\n  if (typeof value !== \"function\") throw new Error;\n  return function() {\n    set$1(this, id).ease = value;\n  };\n}\n\nvar transition_ease = function(value) {\n  var id = this._id;\n\n  return arguments.length\n      ? this.each(easeConstant(id, value))\n      : get$1(this.node(), id).ease;\n};\n\nvar transition_filter = function(match) {\n  if (typeof match !== \"function\") match = matcher$1(match);\n\n  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {\n    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) {\n      if ((node = group[i]) && match.call(node, node.__data__, i, group)) {\n        subgroup.push(node);\n      }\n    }\n  }\n\n  return new Transition(subgroups, this._parents, this._name, this._id);\n};\n\nvar transition_merge = function(transition) {\n  if (transition._id !== this._id) throw new Error;\n\n  for (var groups0 = this._groups, groups1 = transition._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) {\n    for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) {\n      if (node = group0[i] || group1[i]) {\n        merge[i] = node;\n      }\n    }\n  }\n\n  for (; j < m0; ++j) {\n    merges[j] = groups0[j];\n  }\n\n  return new Transition(merges, this._parents, this._name, this._id);\n};\n\nfunction start(name) {\n  return (name + \"\").trim().split(/^|\\s+/).every(function(t) {\n    var i = t.indexOf(\".\");\n    if (i >= 0) t = t.slice(0, i);\n    return !t || t === \"start\";\n  });\n}\n\nfunction onFunction(id, name, listener) {\n  var on0, on1, sit = start(name) ? init : set$1;\n  return function() {\n    var schedule = sit(this, id),\n        on = schedule.on;\n\n    // If this node shared a dispatch with the previous node,\n    // just assign the updated shared dispatch and we’re done!\n    // Otherwise, copy-on-write.\n    if (on !== on0) (on1 = (on0 = on).copy()).on(name, listener);\n\n    schedule.on = on1;\n  };\n}\n\nvar transition_on = function(name, listener) {\n  var id = this._id;\n\n  return arguments.length < 2\n      ? get$1(this.node(), id).on.on(name)\n      : this.each(onFunction(id, name, listener));\n};\n\nfunction removeFunction(id) {\n  return function() {\n    var parent = this.parentNode;\n    for (var i in this.__transition) if (+i !== id) return;\n    if (parent) parent.removeChild(this);\n  };\n}\n\nvar transition_remove = function() {\n  return this.on(\"end.remove\", removeFunction(this._id));\n};\n\nvar transition_select = function(select$$1) {\n  var name = this._name,\n      id = this._id;\n\n  if (typeof select$$1 !== \"function\") select$$1 = selector(select$$1);\n\n  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {\n    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) {\n      if ((node = group[i]) && (subnode = select$$1.call(node, node.__data__, i, group))) {\n        if (\"__data__\" in node) subnode.__data__ = node.__data__;\n        subgroup[i] = subnode;\n        schedule(subgroup[i], name, id, i, subgroup, get$1(node, id));\n      }\n    }\n  }\n\n  return new Transition(subgroups, this._parents, name, id);\n};\n\nvar transition_selectAll = function(select$$1) {\n  var name = this._name,\n      id = this._id;\n\n  if (typeof select$$1 !== \"function\") select$$1 = selectorAll(select$$1);\n\n  for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) {\n    for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {\n      if (node = group[i]) {\n        for (var children = select$$1.call(node, node.__data__, i, group), child, inherit = get$1(node, id), k = 0, l = children.length; k < l; ++k) {\n          if (child = children[k]) {\n            schedule(child, name, id, k, children, inherit);\n          }\n        }\n        subgroups.push(children);\n        parents.push(node);\n      }\n    }\n  }\n\n  return new Transition(subgroups, parents, name, id);\n};\n\nvar Selection$1 = selection.prototype.constructor;\n\nvar transition_selection = function() {\n  return new Selection$1(this._groups, this._parents);\n};\n\nfunction styleRemove$1(name, interpolate$$2) {\n  var value00,\n      value10,\n      interpolate0;\n  return function() {\n    var style = window(this).getComputedStyle(this, null),\n        value0 = style.getPropertyValue(name),\n        value1 = (this.style.removeProperty(name), style.getPropertyValue(name));\n    return value0 === value1 ? null\n        : value0 === value00 && value1 === value10 ? interpolate0\n        : interpolate0 = interpolate$$2(value00 = value0, value10 = value1);\n  };\n}\n\nfunction styleRemoveEnd(name) {\n  return function() {\n    this.style.removeProperty(name);\n  };\n}\n\nfunction styleConstant$1(name, interpolate$$2, value1) {\n  var value00,\n      interpolate0;\n  return function() {\n    var value0 = window(this).getComputedStyle(this, null).getPropertyValue(name);\n    return value0 === value1 ? null\n        : value0 === value00 ? interpolate0\n        : interpolate0 = interpolate$$2(value00 = value0, value1);\n  };\n}\n\nfunction styleFunction$1(name, interpolate$$2, value) {\n  var value00,\n      value10,\n      interpolate0;\n  return function() {\n    var style = window(this).getComputedStyle(this, null),\n        value0 = style.getPropertyValue(name),\n        value1 = value(this);\n    if (value1 == null) value1 = (this.style.removeProperty(name), style.getPropertyValue(name));\n    return value0 === value1 ? null\n        : value0 === value00 && value1 === value10 ? interpolate0\n        : interpolate0 = interpolate$$2(value00 = value0, value10 = value1);\n  };\n}\n\nvar transition_style = function(name, value, priority) {\n  var i = (name += \"\") === \"transform\" ? interpolateTransformCss : interpolate$$1;\n  return value == null ? this\n          .styleTween(name, styleRemove$1(name, i))\n          .on(\"end.style.\" + name, styleRemoveEnd(name))\n      : this.styleTween(name, typeof value === \"function\"\n          ? styleFunction$1(name, i, tweenValue(this, \"style.\" + name, value))\n          : styleConstant$1(name, i, value), priority);\n};\n\nfunction styleTween(name, value, priority) {\n  function tween() {\n    var node = this, i = value.apply(node, arguments);\n    return i && function(t) {\n      node.style.setProperty(name, i(t), priority);\n    };\n  }\n  tween._value = value;\n  return tween;\n}\n\nvar transition_styleTween = function(name, value, priority) {\n  var key = \"style.\" + (name += \"\");\n  if (arguments.length < 2) return (key = this.tween(key)) && key._value;\n  if (value == null) return this.tween(key, null);\n  if (typeof value !== \"function\") throw new Error;\n  return this.tween(key, styleTween(name, value, priority == null ? \"\" : priority));\n};\n\nfunction textConstant$1(value) {\n  return function() {\n    this.textContent = value;\n  };\n}\n\nfunction textFunction$1(value) {\n  return function() {\n    var value1 = value(this);\n    this.textContent = value1 == null ? \"\" : value1;\n  };\n}\n\nvar transition_text = function(value) {\n  return this.tween(\"text\", typeof value === \"function\"\n      ? textFunction$1(tweenValue(this, \"text\", value))\n      : textConstant$1(value == null ? \"\" : value + \"\"));\n};\n\nvar transition_transition = function() {\n  var name = this._name,\n      id0 = this._id,\n      id1 = newId();\n\n  for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) {\n    for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {\n      if (node = group[i]) {\n        var inherit = get$1(node, id0);\n        schedule(node, name, id1, i, group, {\n          time: inherit.time + inherit.delay + inherit.duration,\n          delay: 0,\n          duration: inherit.duration,\n          ease: inherit.ease\n        });\n      }\n    }\n  }\n\n  return new Transition(groups, this._parents, name, id1);\n};\n\nvar id = 0;\n\nfunction Transition(groups, parents, name, id) {\n  this._groups = groups;\n  this._parents = parents;\n  this._name = name;\n  this._id = id;\n}\n\nfunction transition(name) {\n  return selection().transition(name);\n}\n\nfunction newId() {\n  return ++id;\n}\n\nvar selection_prototype = selection.prototype;\n\nTransition.prototype = transition.prototype = {\n  constructor: Transition,\n  select: transition_select,\n  selectAll: transition_selectAll,\n  filter: transition_filter,\n  merge: transition_merge,\n  selection: transition_selection,\n  transition: transition_transition,\n  call: selection_prototype.call,\n  nodes: selection_prototype.nodes,\n  node: selection_prototype.node,\n  size: selection_prototype.size,\n  empty: selection_prototype.empty,\n  each: selection_prototype.each,\n  on: transition_on,\n  attr: transition_attr,\n  attrTween: transition_attrTween,\n  style: transition_style,\n  styleTween: transition_styleTween,\n  text: transition_text,\n  remove: transition_remove,\n  tween: transition_tween,\n  delay: transition_delay,\n  duration: transition_duration,\n  ease: transition_ease\n};\n\nfunction linear$1(t) {\n  return +t;\n}\n\nfunction quadIn(t) {\n  return t * t;\n}\n\nfunction quadOut(t) {\n  return t * (2 - t);\n}\n\nfunction quadInOut(t) {\n  return ((t *= 2) <= 1 ? t * t : --t * (2 - t) + 1) / 2;\n}\n\nfunction cubicIn(t) {\n  return t * t * t;\n}\n\nfunction cubicOut(t) {\n  return --t * t * t + 1;\n}\n\nfunction cubicInOut(t) {\n  return ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2;\n}\n\nvar exponent = 3;\n\nvar polyIn = (function custom(e) {\n  e = +e;\n\n  function polyIn(t) {\n    return Math.pow(t, e);\n  }\n\n  polyIn.exponent = custom;\n\n  return polyIn;\n})(exponent);\n\nvar polyOut = (function custom(e) {\n  e = +e;\n\n  function polyOut(t) {\n    return 1 - Math.pow(1 - t, e);\n  }\n\n  polyOut.exponent = custom;\n\n  return polyOut;\n})(exponent);\n\nvar polyInOut = (function custom(e) {\n  e = +e;\n\n  function polyInOut(t) {\n    return ((t *= 2) <= 1 ? Math.pow(t, e) : 2 - Math.pow(2 - t, e)) / 2;\n  }\n\n  polyInOut.exponent = custom;\n\n  return polyInOut;\n})(exponent);\n\nvar pi = Math.PI;\nvar halfPi = pi / 2;\n\nfunction sinIn(t) {\n  return 1 - Math.cos(t * halfPi);\n}\n\nfunction sinOut(t) {\n  return Math.sin(t * halfPi);\n}\n\nfunction sinInOut(t) {\n  return (1 - Math.cos(pi * t)) / 2;\n}\n\nfunction expIn(t) {\n  return Math.pow(2, 10 * t - 10);\n}\n\nfunction expOut(t) {\n  return 1 - Math.pow(2, -10 * t);\n}\n\nfunction expInOut(t) {\n  return ((t *= 2) <= 1 ? Math.pow(2, 10 * t - 10) : 2 - Math.pow(2, 10 - 10 * t)) / 2;\n}\n\nfunction circleIn(t) {\n  return 1 - Math.sqrt(1 - t * t);\n}\n\nfunction circleOut(t) {\n  return Math.sqrt(1 - --t * t);\n}\n\nfunction circleInOut(t) {\n  return ((t *= 2) <= 1 ? 1 - Math.sqrt(1 - t * t) : Math.sqrt(1 - (t -= 2) * t) + 1) / 2;\n}\n\nvar b1 = 4 / 11;\nvar b2 = 6 / 11;\nvar b3 = 8 / 11;\nvar b4 = 3 / 4;\nvar b5 = 9 / 11;\nvar b6 = 10 / 11;\nvar b7 = 15 / 16;\nvar b8 = 21 / 22;\nvar b9 = 63 / 64;\nvar b0 = 1 / b1 / b1;\n\nfunction bounceIn(t) {\n  return 1 - bounceOut(1 - t);\n}\n\nfunction bounceOut(t) {\n  return (t = +t) < b1 ? b0 * t * t : t < b3 ? b0 * (t -= b2) * t + b4 : t < b6 ? b0 * (t -= b5) * t + b7 : b0 * (t -= b8) * t + b9;\n}\n\nfunction bounceInOut(t) {\n  return ((t *= 2) <= 1 ? 1 - bounceOut(1 - t) : bounceOut(t - 1) + 1) / 2;\n}\n\nvar overshoot = 1.70158;\n\nvar backIn = (function custom(s) {\n  s = +s;\n\n  function backIn(t) {\n    return t * t * ((s + 1) * t - s);\n  }\n\n  backIn.overshoot = custom;\n\n  return backIn;\n})(overshoot);\n\nvar backOut = (function custom(s) {\n  s = +s;\n\n  function backOut(t) {\n    return --t * t * ((s + 1) * t + s) + 1;\n  }\n\n  backOut.overshoot = custom;\n\n  return backOut;\n})(overshoot);\n\nvar backInOut = (function custom(s) {\n  s = +s;\n\n  function backInOut(t) {\n    return ((t *= 2) < 1 ? t * t * ((s + 1) * t - s) : (t -= 2) * t * ((s + 1) * t + s) + 2) / 2;\n  }\n\n  backInOut.overshoot = custom;\n\n  return backInOut;\n})(overshoot);\n\nvar tau = 2 * Math.PI;\nvar amplitude = 1;\nvar period = 0.3;\n\nvar elasticIn = (function custom(a, p) {\n  var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau);\n\n  function elasticIn(t) {\n    return a * Math.pow(2, 10 * --t) * Math.sin((s - t) / p);\n  }\n\n  elasticIn.amplitude = function(a) { return custom(a, p * tau); };\n  elasticIn.period = function(p) { return custom(a, p); };\n\n  return elasticIn;\n})(amplitude, period);\n\nvar elasticOut = (function custom(a, p) {\n  var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau);\n\n  function elasticOut(t) {\n    return 1 - a * Math.pow(2, -10 * (t = +t)) * Math.sin((t + s) / p);\n  }\n\n  elasticOut.amplitude = function(a) { return custom(a, p * tau); };\n  elasticOut.period = function(p) { return custom(a, p); };\n\n  return elasticOut;\n})(amplitude, period);\n\nvar elasticInOut = (function custom(a, p) {\n  var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau);\n\n  function elasticInOut(t) {\n    return ((t = t * 2 - 1) < 0\n        ? a * Math.pow(2, 10 * t) * Math.sin((s - t) / p)\n        : 2 - a * Math.pow(2, -10 * t) * Math.sin((s + t) / p)) / 2;\n  }\n\n  elasticInOut.amplitude = function(a) { return custom(a, p * tau); };\n  elasticInOut.period = function(p) { return custom(a, p); };\n\n  return elasticInOut;\n})(amplitude, period);\n\nvar defaultTiming = {\n  time: null, // Set on use.\n  delay: 0,\n  duration: 250,\n  ease: cubicInOut\n};\n\nfunction inherit(node, id) {\n  var timing;\n  while (!(timing = node.__transition) || !(timing = timing[id])) {\n    if (!(node = node.parentNode)) {\n      return defaultTiming.time = now(), defaultTiming;\n    }\n  }\n  return timing;\n}\n\nvar selection_transition = function(name) {\n  var id,\n      timing;\n\n  if (name instanceof Transition) {\n    id = name._id, name = name._name;\n  } else {\n    id = newId(), (timing = defaultTiming).time = now(), name = name == null ? null : name + \"\";\n  }\n\n  for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) {\n    for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {\n      if (node = group[i]) {\n        schedule(node, name, id, i, group, timing || inherit(node, id));\n      }\n    }\n  }\n\n  return new Transition(groups, this._parents, name, id);\n};\n\nselection.prototype.interrupt = selection_interrupt;\nselection.prototype.transition = selection_transition;\n\nvar root$1 = [null];\n\nvar active = function(node, name) {\n  var schedules = node.__transition,\n      schedule,\n      i;\n\n  if (schedules) {\n    name = name == null ? null : name + \"\";\n    for (i in schedules) {\n      if ((schedule = schedules[i]).state > SCHEDULED && schedule.name === name) {\n        return new Transition([[node]], root$1, name, +i);\n      }\n    }\n  }\n\n  return null;\n};\n\nvar constant$4 = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nvar BrushEvent = function(target, type, selection) {\n  this.target = target;\n  this.type = type;\n  this.selection = selection;\n};\n\nfunction nopropagation$1() {\n  exports.event.stopImmediatePropagation();\n}\n\nvar noevent$1 = function() {\n  exports.event.preventDefault();\n  exports.event.stopImmediatePropagation();\n};\n\nvar MODE_DRAG = {name: \"drag\"};\nvar MODE_SPACE = {name: \"space\"};\nvar MODE_HANDLE = {name: \"handle\"};\nvar MODE_CENTER = {name: \"center\"};\n\nvar X = {\n  name: \"x\",\n  handles: [\"e\", \"w\"].map(type),\n  input: function(x, e) { return x && [[x[0], e[0][1]], [x[1], e[1][1]]]; },\n  output: function(xy) { return xy && [xy[0][0], xy[1][0]]; }\n};\n\nvar Y = {\n  name: \"y\",\n  handles: [\"n\", \"s\"].map(type),\n  input: function(y, e) { return y && [[e[0][0], y[0]], [e[1][0], y[1]]]; },\n  output: function(xy) { return xy && [xy[0][1], xy[1][1]]; }\n};\n\nvar XY = {\n  name: \"xy\",\n  handles: [\"n\", \"e\", \"s\", \"w\", \"nw\", \"ne\", \"se\", \"sw\"].map(type),\n  input: function(xy) { return xy; },\n  output: function(xy) { return xy; }\n};\n\nvar cursors = {\n  overlay: \"crosshair\",\n  selection: \"move\",\n  n: \"ns-resize\",\n  e: \"ew-resize\",\n  s: \"ns-resize\",\n  w: \"ew-resize\",\n  nw: \"nwse-resize\",\n  ne: \"nesw-resize\",\n  se: \"nwse-resize\",\n  sw: \"nesw-resize\"\n};\n\nvar flipX = {\n  e: \"w\",\n  w: \"e\",\n  nw: \"ne\",\n  ne: \"nw\",\n  se: \"sw\",\n  sw: \"se\"\n};\n\nvar flipY = {\n  n: \"s\",\n  s: \"n\",\n  nw: \"sw\",\n  ne: \"se\",\n  se: \"ne\",\n  sw: \"nw\"\n};\n\nvar signsX = {\n  overlay: +1,\n  selection: +1,\n  n: null,\n  e: +1,\n  s: null,\n  w: -1,\n  nw: -1,\n  ne: +1,\n  se: +1,\n  sw: -1\n};\n\nvar signsY = {\n  overlay: +1,\n  selection: +1,\n  n: -1,\n  e: null,\n  s: +1,\n  w: null,\n  nw: -1,\n  ne: -1,\n  se: +1,\n  sw: +1\n};\n\nfunction type(t) {\n  return {type: t};\n}\n\n// Ignore right-click, since that should open the context menu.\nfunction defaultFilter() {\n  return !exports.event.button;\n}\n\nfunction defaultExtent() {\n  var svg = this.ownerSVGElement || this;\n  return [[0, 0], [svg.width.baseVal.value, svg.height.baseVal.value]];\n}\n\n// Like d3.local, but with the name “__brush” rather than auto-generated.\nfunction local$$1(node) {\n  while (!node.__brush) if (!(node = node.parentNode)) return;\n  return node.__brush;\n}\n\nfunction empty(extent) {\n  return extent[0][0] === extent[1][0]\n      || extent[0][1] === extent[1][1];\n}\n\nfunction brushSelection(node) {\n  var state = node.__brush;\n  return state ? state.dim.output(state.selection) : null;\n}\n\nfunction brushX() {\n  return brush$1(X);\n}\n\nfunction brushY() {\n  return brush$1(Y);\n}\n\nvar brush = function() {\n  return brush$1(XY);\n};\n\nfunction brush$1(dim) {\n  var extent = defaultExtent,\n      filter = defaultFilter,\n      listeners = dispatch(brush, \"start\", \"brush\", \"end\"),\n      handleSize = 6,\n      touchending;\n\n  function brush(group) {\n    var overlay = group\n        .property(\"__brush\", initialize)\n      .selectAll(\".overlay\")\n      .data([type(\"overlay\")]);\n\n    overlay.enter().append(\"rect\")\n        .attr(\"class\", \"overlay\")\n        .attr(\"pointer-events\", \"all\")\n        .attr(\"cursor\", cursors.overlay)\n      .merge(overlay)\n        .each(function() {\n          var extent = local$$1(this).extent;\n          select(this)\n              .attr(\"x\", extent[0][0])\n              .attr(\"y\", extent[0][1])\n              .attr(\"width\", extent[1][0] - extent[0][0])\n              .attr(\"height\", extent[1][1] - extent[0][1]);\n        });\n\n    group.selectAll(\".selection\")\n      .data([type(\"selection\")])\n      .enter().append(\"rect\")\n        .attr(\"class\", \"selection\")\n        .attr(\"cursor\", cursors.selection)\n        .attr(\"fill\", \"#777\")\n        .attr(\"fill-opacity\", 0.3)\n        .attr(\"stroke\", \"#fff\")\n        .attr(\"shape-rendering\", \"crispEdges\");\n\n    var handle = group.selectAll(\".handle\")\n      .data(dim.handles, function(d) { return d.type; });\n\n    handle.exit().remove();\n\n    handle.enter().append(\"rect\")\n        .attr(\"class\", function(d) { return \"handle handle--\" + d.type; })\n        .attr(\"cursor\", function(d) { return cursors[d.type]; });\n\n    group\n        .each(redraw)\n        .attr(\"fill\", \"none\")\n        .attr(\"pointer-events\", \"all\")\n        .style(\"-webkit-tap-highlight-color\", \"rgba(0,0,0,0)\")\n        .on(\"mousedown.brush touchstart.brush\", started);\n  }\n\n  brush.move = function(group, selection$$1) {\n    if (group.selection) {\n      group\n          .on(\"start.brush\", function() { emitter(this, arguments).beforestart().start(); })\n          .on(\"interrupt.brush end.brush\", function() { emitter(this, arguments).end(); })\n          .tween(\"brush\", function() {\n            var that = this,\n                state = that.__brush,\n                emit = emitter(that, arguments),\n                selection0 = state.selection,\n                selection1 = dim.input(typeof selection$$1 === \"function\" ? selection$$1.apply(this, arguments) : selection$$1, state.extent),\n                i = interpolateValue(selection0, selection1);\n\n            function tween(t) {\n              state.selection = t === 1 && empty(selection1) ? null : i(t);\n              redraw.call(that);\n              emit.brush();\n            }\n\n            return selection0 && selection1 ? tween : tween(1);\n          });\n    } else {\n      group\n          .each(function() {\n            var that = this,\n                args = arguments,\n                state = that.__brush,\n                selection1 = dim.input(typeof selection$$1 === \"function\" ? selection$$1.apply(that, args) : selection$$1, state.extent),\n                emit = emitter(that, args).beforestart();\n\n            interrupt(that);\n            state.selection = selection1 == null || empty(selection1) ? null : selection1;\n            redraw.call(that);\n            emit.start().brush().end();\n          });\n    }\n  };\n\n  function redraw() {\n    var group = select(this),\n        selection$$1 = local$$1(this).selection;\n\n    if (selection$$1) {\n      group.selectAll(\".selection\")\n          .style(\"display\", null)\n          .attr(\"x\", selection$$1[0][0])\n          .attr(\"y\", selection$$1[0][1])\n          .attr(\"width\", selection$$1[1][0] - selection$$1[0][0])\n          .attr(\"height\", selection$$1[1][1] - selection$$1[0][1]);\n\n      group.selectAll(\".handle\")\n          .style(\"display\", null)\n          .attr(\"x\", function(d) { return d.type[d.type.length - 1] === \"e\" ? selection$$1[1][0] - handleSize / 2 : selection$$1[0][0] - handleSize / 2; })\n          .attr(\"y\", function(d) { return d.type[0] === \"s\" ? selection$$1[1][1] - handleSize / 2 : selection$$1[0][1] - handleSize / 2; })\n          .attr(\"width\", function(d) { return d.type === \"n\" || d.type === \"s\" ? selection$$1[1][0] - selection$$1[0][0] + handleSize : handleSize; })\n          .attr(\"height\", function(d) { return d.type === \"e\" || d.type === \"w\" ? selection$$1[1][1] - selection$$1[0][1] + handleSize : handleSize; });\n    }\n\n    else {\n      group.selectAll(\".selection,.handle\")\n          .style(\"display\", \"none\")\n          .attr(\"x\", null)\n          .attr(\"y\", null)\n          .attr(\"width\", null)\n          .attr(\"height\", null);\n    }\n  }\n\n  function emitter(that, args) {\n    return that.__brush.emitter || new Emitter(that, args);\n  }\n\n  function Emitter(that, args) {\n    this.that = that;\n    this.args = args;\n    this.state = that.__brush;\n    this.active = 0;\n  }\n\n  Emitter.prototype = {\n    beforestart: function() {\n      if (++this.active === 1) this.state.emitter = this, this.starting = true;\n      return this;\n    },\n    start: function() {\n      if (this.starting) this.starting = false, this.emit(\"start\");\n      return this;\n    },\n    brush: function() {\n      this.emit(\"brush\");\n      return this;\n    },\n    end: function() {\n      if (--this.active === 0) delete this.state.emitter, this.emit(\"end\");\n      return this;\n    },\n    emit: function(type) {\n      customEvent(new BrushEvent(brush, type, dim.output(this.state.selection)), listeners.apply, listeners, [type, this.that, this.args]);\n    }\n  };\n\n  function started() {\n    if (exports.event.touches) { if (exports.event.changedTouches.length < exports.event.touches.length) return noevent$1(); }\n    else if (touchending) return;\n    if (!filter.apply(this, arguments)) return;\n\n    var that = this,\n        type = exports.event.target.__data__.type,\n        mode = (exports.event.metaKey ? type = \"overlay\" : type) === \"selection\" ? MODE_DRAG : (exports.event.altKey ? MODE_CENTER : MODE_HANDLE),\n        signX = dim === Y ? null : signsX[type],\n        signY = dim === X ? null : signsY[type],\n        state = local$$1(that),\n        extent = state.extent,\n        selection$$1 = state.selection,\n        W = extent[0][0], w0, w1,\n        N = extent[0][1], n0, n1,\n        E = extent[1][0], e0, e1,\n        S = extent[1][1], s0, s1,\n        dx,\n        dy,\n        moving,\n        shifting = signX && signY && exports.event.shiftKey,\n        lockX,\n        lockY,\n        point0 = mouse(that),\n        point = point0,\n        emit = emitter(that, arguments).beforestart();\n\n    if (type === \"overlay\") {\n      state.selection = selection$$1 = [\n        [w0 = dim === Y ? W : point0[0], n0 = dim === X ? N : point0[1]],\n        [e0 = dim === Y ? E : w0, s0 = dim === X ? S : n0]\n      ];\n    } else {\n      w0 = selection$$1[0][0];\n      n0 = selection$$1[0][1];\n      e0 = selection$$1[1][0];\n      s0 = selection$$1[1][1];\n    }\n\n    w1 = w0;\n    n1 = n0;\n    e1 = e0;\n    s1 = s0;\n\n    var group = select(that)\n        .attr(\"pointer-events\", \"none\");\n\n    var overlay = group.selectAll(\".overlay\")\n        .attr(\"cursor\", cursors[type]);\n\n    if (exports.event.touches) {\n      group\n          .on(\"touchmove.brush\", moved, true)\n          .on(\"touchend.brush touchcancel.brush\", ended, true);\n    } else {\n      var view = select(exports.event.view)\n          .on(\"keydown.brush\", keydowned, true)\n          .on(\"keyup.brush\", keyupped, true)\n          .on(\"mousemove.brush\", moved, true)\n          .on(\"mouseup.brush\", ended, true);\n\n      dragDisable(exports.event.view);\n    }\n\n    nopropagation$1();\n    interrupt(that);\n    redraw.call(that);\n    emit.start();\n\n    function moved() {\n      var point1 = mouse(that);\n      if (shifting && !lockX && !lockY) {\n        if (Math.abs(point1[0] - point[0]) > Math.abs(point1[1] - point[1])) lockY = true;\n        else lockX = true;\n      }\n      point = point1;\n      moving = true;\n      noevent$1();\n      move();\n    }\n\n    function move() {\n      var t;\n\n      dx = point[0] - point0[0];\n      dy = point[1] - point0[1];\n\n      switch (mode) {\n        case MODE_SPACE:\n        case MODE_DRAG: {\n          if (signX) dx = Math.max(W - w0, Math.min(E - e0, dx)), w1 = w0 + dx, e1 = e0 + dx;\n          if (signY) dy = Math.max(N - n0, Math.min(S - s0, dy)), n1 = n0 + dy, s1 = s0 + dy;\n          break;\n        }\n        case MODE_HANDLE: {\n          if (signX < 0) dx = Math.max(W - w0, Math.min(E - w0, dx)), w1 = w0 + dx, e1 = e0;\n          else if (signX > 0) dx = Math.max(W - e0, Math.min(E - e0, dx)), w1 = w0, e1 = e0 + dx;\n          if (signY < 0) dy = Math.max(N - n0, Math.min(S - n0, dy)), n1 = n0 + dy, s1 = s0;\n          else if (signY > 0) dy = Math.max(N - s0, Math.min(S - s0, dy)), n1 = n0, s1 = s0 + dy;\n          break;\n        }\n        case MODE_CENTER: {\n          if (signX) w1 = Math.max(W, Math.min(E, w0 - dx * signX)), e1 = Math.max(W, Math.min(E, e0 + dx * signX));\n          if (signY) n1 = Math.max(N, Math.min(S, n0 - dy * signY)), s1 = Math.max(N, Math.min(S, s0 + dy * signY));\n          break;\n        }\n      }\n\n      if (e1 < w1) {\n        signX *= -1;\n        t = w0, w0 = e0, e0 = t;\n        t = w1, w1 = e1, e1 = t;\n        if (type in flipX) overlay.attr(\"cursor\", cursors[type = flipX[type]]);\n      }\n\n      if (s1 < n1) {\n        signY *= -1;\n        t = n0, n0 = s0, s0 = t;\n        t = n1, n1 = s1, s1 = t;\n        if (type in flipY) overlay.attr(\"cursor\", cursors[type = flipY[type]]);\n      }\n\n      if (state.selection) selection$$1 = state.selection; // May be set by brush.move!\n      if (lockX) w1 = selection$$1[0][0], e1 = selection$$1[1][0];\n      if (lockY) n1 = selection$$1[0][1], s1 = selection$$1[1][1];\n\n      if (selection$$1[0][0] !== w1\n          || selection$$1[0][1] !== n1\n          || selection$$1[1][0] !== e1\n          || selection$$1[1][1] !== s1) {\n        state.selection = [[w1, n1], [e1, s1]];\n        redraw.call(that);\n        emit.brush();\n      }\n    }\n\n    function ended() {\n      nopropagation$1();\n      if (exports.event.touches) {\n        if (exports.event.touches.length) return;\n        if (touchending) clearTimeout(touchending);\n        touchending = setTimeout(function() { touchending = null; }, 500); // Ghost clicks are delayed!\n        group.on(\"touchmove.brush touchend.brush touchcancel.brush\", null);\n      } else {\n        yesdrag(exports.event.view, moving);\n        view.on(\"keydown.brush keyup.brush mousemove.brush mouseup.brush\", null);\n      }\n      group.attr(\"pointer-events\", \"all\");\n      overlay.attr(\"cursor\", cursors.overlay);\n      if (state.selection) selection$$1 = state.selection; // May be set by brush.move (on start)!\n      if (empty(selection$$1)) state.selection = null, redraw.call(that);\n      emit.end();\n    }\n\n    function keydowned() {\n      switch (exports.event.keyCode) {\n        case 16: { // SHIFT\n          shifting = signX && signY;\n          break;\n        }\n        case 18: { // ALT\n          if (mode === MODE_HANDLE) {\n            if (signX) e0 = e1 - dx * signX, w0 = w1 + dx * signX;\n            if (signY) s0 = s1 - dy * signY, n0 = n1 + dy * signY;\n            mode = MODE_CENTER;\n            move();\n          }\n          break;\n        }\n        case 32: { // SPACE; takes priority over ALT\n          if (mode === MODE_HANDLE || mode === MODE_CENTER) {\n            if (signX < 0) e0 = e1 - dx; else if (signX > 0) w0 = w1 - dx;\n            if (signY < 0) s0 = s1 - dy; else if (signY > 0) n0 = n1 - dy;\n            mode = MODE_SPACE;\n            overlay.attr(\"cursor\", cursors.selection);\n            move();\n          }\n          break;\n        }\n        default: return;\n      }\n      noevent$1();\n    }\n\n    function keyupped() {\n      switch (exports.event.keyCode) {\n        case 16: { // SHIFT\n          if (shifting) {\n            lockX = lockY = shifting = false;\n            move();\n          }\n          break;\n        }\n        case 18: { // ALT\n          if (mode === MODE_CENTER) {\n            if (signX < 0) e0 = e1; else if (signX > 0) w0 = w1;\n            if (signY < 0) s0 = s1; else if (signY > 0) n0 = n1;\n            mode = MODE_HANDLE;\n            move();\n          }\n          break;\n        }\n        case 32: { // SPACE\n          if (mode === MODE_SPACE) {\n            if (exports.event.altKey) {\n              if (signX) e0 = e1 - dx * signX, w0 = w1 + dx * signX;\n              if (signY) s0 = s1 - dy * signY, n0 = n1 + dy * signY;\n              mode = MODE_CENTER;\n            } else {\n              if (signX < 0) e0 = e1; else if (signX > 0) w0 = w1;\n              if (signY < 0) s0 = s1; else if (signY > 0) n0 = n1;\n              mode = MODE_HANDLE;\n            }\n            overlay.attr(\"cursor\", cursors[type]);\n            move();\n          }\n          break;\n        }\n        default: return;\n      }\n      noevent$1();\n    }\n  }\n\n  function initialize() {\n    var state = this.__brush || {selection: null};\n    state.extent = extent.apply(this, arguments);\n    state.dim = dim;\n    return state;\n  }\n\n  brush.extent = function(_) {\n    return arguments.length ? (extent = typeof _ === \"function\" ? _ : constant$4([[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]]), brush) : extent;\n  };\n\n  brush.filter = function(_) {\n    return arguments.length ? (filter = typeof _ === \"function\" ? _ : constant$4(!!_), brush) : filter;\n  };\n\n  brush.handleSize = function(_) {\n    return arguments.length ? (handleSize = +_, brush) : handleSize;\n  };\n\n  brush.on = function() {\n    var value = listeners.on.apply(listeners, arguments);\n    return value === listeners ? brush : value;\n  };\n\n  return brush;\n}\n\nvar cos = Math.cos;\nvar sin = Math.sin;\nvar pi$1 = Math.PI;\nvar halfPi$1 = pi$1 / 2;\nvar tau$1 = pi$1 * 2;\nvar max$1 = Math.max;\n\nfunction compareValue(compare) {\n  return function(a, b) {\n    return compare(\n      a.source.value + a.target.value,\n      b.source.value + b.target.value\n    );\n  };\n}\n\nvar chord = function() {\n  var padAngle = 0,\n      sortGroups = null,\n      sortSubgroups = null,\n      sortChords = null;\n\n  function chord(matrix) {\n    var n = matrix.length,\n        groupSums = [],\n        groupIndex = sequence(n),\n        subgroupIndex = [],\n        chords = [],\n        groups = chords.groups = new Array(n),\n        subgroups = new Array(n * n),\n        k,\n        x,\n        x0,\n        dx,\n        i,\n        j;\n\n    // Compute the sum.\n    k = 0, i = -1; while (++i < n) {\n      x = 0, j = -1; while (++j < n) {\n        x += matrix[i][j];\n      }\n      groupSums.push(x);\n      subgroupIndex.push(sequence(n));\n      k += x;\n    }\n\n    // Sort groups…\n    if (sortGroups) groupIndex.sort(function(a, b) {\n      return sortGroups(groupSums[a], groupSums[b]);\n    });\n\n    // Sort subgroups…\n    if (sortSubgroups) subgroupIndex.forEach(function(d, i) {\n      d.sort(function(a, b) {\n        return sortSubgroups(matrix[i][a], matrix[i][b]);\n      });\n    });\n\n    // Convert the sum to scaling factor for [0, 2pi].\n    // TODO Allow start and end angle to be specified?\n    // TODO Allow padding to be specified as percentage?\n    k = max$1(0, tau$1 - padAngle * n) / k;\n    dx = k ? padAngle : tau$1 / n;\n\n    // Compute the start and end angle for each group and subgroup.\n    // Note: Opera has a bug reordering object literal properties!\n    x = 0, i = -1; while (++i < n) {\n      x0 = x, j = -1; while (++j < n) {\n        var di = groupIndex[i],\n            dj = subgroupIndex[di][j],\n            v = matrix[di][dj],\n            a0 = x,\n            a1 = x += v * k;\n        subgroups[dj * n + di] = {\n          index: di,\n          subindex: dj,\n          startAngle: a0,\n          endAngle: a1,\n          value: v\n        };\n      }\n      groups[di] = {\n        index: di,\n        startAngle: x0,\n        endAngle: x,\n        value: groupSums[di]\n      };\n      x += dx;\n    }\n\n    // Generate chords for each (non-empty) subgroup-subgroup link.\n    i = -1; while (++i < n) {\n      j = i - 1; while (++j < n) {\n        var source = subgroups[j * n + i],\n            target = subgroups[i * n + j];\n        if (source.value || target.value) {\n          chords.push(source.value < target.value\n              ? {source: target, target: source}\n              : {source: source, target: target});\n        }\n      }\n    }\n\n    return sortChords ? chords.sort(sortChords) : chords;\n  }\n\n  chord.padAngle = function(_) {\n    return arguments.length ? (padAngle = max$1(0, _), chord) : padAngle;\n  };\n\n  chord.sortGroups = function(_) {\n    return arguments.length ? (sortGroups = _, chord) : sortGroups;\n  };\n\n  chord.sortSubgroups = function(_) {\n    return arguments.length ? (sortSubgroups = _, chord) : sortSubgroups;\n  };\n\n  chord.sortChords = function(_) {\n    return arguments.length ? (_ == null ? sortChords = null : (sortChords = compareValue(_))._ = _, chord) : sortChords && sortChords._;\n  };\n\n  return chord;\n};\n\nvar slice$2 = Array.prototype.slice;\n\nvar constant$5 = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nvar pi$2 = Math.PI;\nvar tau$2 = 2 * pi$2;\nvar epsilon$1 = 1e-6;\nvar tauEpsilon = tau$2 - epsilon$1;\n\nfunction Path() {\n  this._x0 = this._y0 = // start of current subpath\n  this._x1 = this._y1 = null; // end of current subpath\n  this._ = \"\";\n}\n\nfunction path() {\n  return new Path;\n}\n\nPath.prototype = path.prototype = {\n  constructor: Path,\n  moveTo: function(x, y) {\n    this._ += \"M\" + (this._x0 = this._x1 = +x) + \",\" + (this._y0 = this._y1 = +y);\n  },\n  closePath: function() {\n    if (this._x1 !== null) {\n      this._x1 = this._x0, this._y1 = this._y0;\n      this._ += \"Z\";\n    }\n  },\n  lineTo: function(x, y) {\n    this._ += \"L\" + (this._x1 = +x) + \",\" + (this._y1 = +y);\n  },\n  quadraticCurveTo: function(x1, y1, x, y) {\n    this._ += \"Q\" + (+x1) + \",\" + (+y1) + \",\" + (this._x1 = +x) + \",\" + (this._y1 = +y);\n  },\n  bezierCurveTo: function(x1, y1, x2, y2, x, y) {\n    this._ += \"C\" + (+x1) + \",\" + (+y1) + \",\" + (+x2) + \",\" + (+y2) + \",\" + (this._x1 = +x) + \",\" + (this._y1 = +y);\n  },\n  arcTo: function(x1, y1, x2, y2, r) {\n    x1 = +x1, y1 = +y1, x2 = +x2, y2 = +y2, r = +r;\n    var x0 = this._x1,\n        y0 = this._y1,\n        x21 = x2 - x1,\n        y21 = y2 - y1,\n        x01 = x0 - x1,\n        y01 = y0 - y1,\n        l01_2 = x01 * x01 + y01 * y01;\n\n    // Is the radius negative? Error.\n    if (r < 0) throw new Error(\"negative radius: \" + r);\n\n    // Is this path empty? Move to (x1,y1).\n    if (this._x1 === null) {\n      this._ += \"M\" + (this._x1 = x1) + \",\" + (this._y1 = y1);\n    }\n\n    // Or, is (x1,y1) coincident with (x0,y0)? Do nothing.\n    else if (!(l01_2 > epsilon$1)) {}\n\n    // Or, are (x0,y0), (x1,y1) and (x2,y2) collinear?\n    // Equivalently, is (x1,y1) coincident with (x2,y2)?\n    // Or, is the radius zero? Line to (x1,y1).\n    else if (!(Math.abs(y01 * x21 - y21 * x01) > epsilon$1) || !r) {\n      this._ += \"L\" + (this._x1 = x1) + \",\" + (this._y1 = y1);\n    }\n\n    // Otherwise, draw an arc!\n    else {\n      var x20 = x2 - x0,\n          y20 = y2 - y0,\n          l21_2 = x21 * x21 + y21 * y21,\n          l20_2 = x20 * x20 + y20 * y20,\n          l21 = Math.sqrt(l21_2),\n          l01 = Math.sqrt(l01_2),\n          l = r * Math.tan((pi$2 - Math.acos((l21_2 + l01_2 - l20_2) / (2 * l21 * l01))) / 2),\n          t01 = l / l01,\n          t21 = l / l21;\n\n      // If the start tangent is not coincident with (x0,y0), line to.\n      if (Math.abs(t01 - 1) > epsilon$1) {\n        this._ += \"L\" + (x1 + t01 * x01) + \",\" + (y1 + t01 * y01);\n      }\n\n      this._ += \"A\" + r + \",\" + r + \",0,0,\" + (+(y01 * x20 > x01 * y20)) + \",\" + (this._x1 = x1 + t21 * x21) + \",\" + (this._y1 = y1 + t21 * y21);\n    }\n  },\n  arc: function(x, y, r, a0, a1, ccw) {\n    x = +x, y = +y, r = +r;\n    var dx = r * Math.cos(a0),\n        dy = r * Math.sin(a0),\n        x0 = x + dx,\n        y0 = y + dy,\n        cw = 1 ^ ccw,\n        da = ccw ? a0 - a1 : a1 - a0;\n\n    // Is the radius negative? Error.\n    if (r < 0) throw new Error(\"negative radius: \" + r);\n\n    // Is this path empty? Move to (x0,y0).\n    if (this._x1 === null) {\n      this._ += \"M\" + x0 + \",\" + y0;\n    }\n\n    // Or, is (x0,y0) not coincident with the previous point? Line to (x0,y0).\n    else if (Math.abs(this._x1 - x0) > epsilon$1 || Math.abs(this._y1 - y0) > epsilon$1) {\n      this._ += \"L\" + x0 + \",\" + y0;\n    }\n\n    // Is this arc empty? We’re done.\n    if (!r) return;\n\n    // Is this a complete circle? Draw two arcs to complete the circle.\n    if (da > tauEpsilon) {\n      this._ += \"A\" + r + \",\" + r + \",0,1,\" + cw + \",\" + (x - dx) + \",\" + (y - dy) + \"A\" + r + \",\" + r + \",0,1,\" + cw + \",\" + (this._x1 = x0) + \",\" + (this._y1 = y0);\n    }\n\n    // Otherwise, draw an arc!\n    else {\n      if (da < 0) da = da % tau$2 + tau$2;\n      this._ += \"A\" + r + \",\" + r + \",0,\" + (+(da >= pi$2)) + \",\" + cw + \",\" + (this._x1 = x + r * Math.cos(a1)) + \",\" + (this._y1 = y + r * Math.sin(a1));\n    }\n  },\n  rect: function(x, y, w, h) {\n    this._ += \"M\" + (this._x0 = this._x1 = +x) + \",\" + (this._y0 = this._y1 = +y) + \"h\" + (+w) + \"v\" + (+h) + \"h\" + (-w) + \"Z\";\n  },\n  toString: function() {\n    return this._;\n  }\n};\n\nfunction defaultSource(d) {\n  return d.source;\n}\n\nfunction defaultTarget(d) {\n  return d.target;\n}\n\nfunction defaultRadius(d) {\n  return d.radius;\n}\n\nfunction defaultStartAngle(d) {\n  return d.startAngle;\n}\n\nfunction defaultEndAngle(d) {\n  return d.endAngle;\n}\n\nvar ribbon = function() {\n  var source = defaultSource,\n      target = defaultTarget,\n      radius = defaultRadius,\n      startAngle = defaultStartAngle,\n      endAngle = defaultEndAngle,\n      context = null;\n\n  function ribbon() {\n    var buffer,\n        argv = slice$2.call(arguments),\n        s = source.apply(this, argv),\n        t = target.apply(this, argv),\n        sr = +radius.apply(this, (argv[0] = s, argv)),\n        sa0 = startAngle.apply(this, argv) - halfPi$1,\n        sa1 = endAngle.apply(this, argv) - halfPi$1,\n        sx0 = sr * cos(sa0),\n        sy0 = sr * sin(sa0),\n        tr = +radius.apply(this, (argv[0] = t, argv)),\n        ta0 = startAngle.apply(this, argv) - halfPi$1,\n        ta1 = endAngle.apply(this, argv) - halfPi$1;\n\n    if (!context) context = buffer = path();\n\n    context.moveTo(sx0, sy0);\n    context.arc(0, 0, sr, sa0, sa1);\n    if (sa0 !== ta0 || sa1 !== ta1) { // TODO sr !== tr?\n      context.quadraticCurveTo(0, 0, tr * cos(ta0), tr * sin(ta0));\n      context.arc(0, 0, tr, ta0, ta1);\n    }\n    context.quadraticCurveTo(0, 0, sx0, sy0);\n    context.closePath();\n\n    if (buffer) return context = null, buffer + \"\" || null;\n  }\n\n  ribbon.radius = function(_) {\n    return arguments.length ? (radius = typeof _ === \"function\" ? _ : constant$5(+_), ribbon) : radius;\n  };\n\n  ribbon.startAngle = function(_) {\n    return arguments.length ? (startAngle = typeof _ === \"function\" ? _ : constant$5(+_), ribbon) : startAngle;\n  };\n\n  ribbon.endAngle = function(_) {\n    return arguments.length ? (endAngle = typeof _ === \"function\" ? _ : constant$5(+_), ribbon) : endAngle;\n  };\n\n  ribbon.source = function(_) {\n    return arguments.length ? (source = _, ribbon) : source;\n  };\n\n  ribbon.target = function(_) {\n    return arguments.length ? (target = _, ribbon) : target;\n  };\n\n  ribbon.context = function(_) {\n    return arguments.length ? ((context = _ == null ? null : _), ribbon) : context;\n  };\n\n  return ribbon;\n};\n\nvar prefix = \"$\";\n\nfunction Map() {}\n\nMap.prototype = map$1.prototype = {\n  constructor: Map,\n  has: function(key) {\n    return (prefix + key) in this;\n  },\n  get: function(key) {\n    return this[prefix + key];\n  },\n  set: function(key, value) {\n    this[prefix + key] = value;\n    return this;\n  },\n  remove: function(key) {\n    var property = prefix + key;\n    return property in this && delete this[property];\n  },\n  clear: function() {\n    for (var property in this) if (property[0] === prefix) delete this[property];\n  },\n  keys: function() {\n    var keys = [];\n    for (var property in this) if (property[0] === prefix) keys.push(property.slice(1));\n    return keys;\n  },\n  values: function() {\n    var values = [];\n    for (var property in this) if (property[0] === prefix) values.push(this[property]);\n    return values;\n  },\n  entries: function() {\n    var entries = [];\n    for (var property in this) if (property[0] === prefix) entries.push({key: property.slice(1), value: this[property]});\n    return entries;\n  },\n  size: function() {\n    var size = 0;\n    for (var property in this) if (property[0] === prefix) ++size;\n    return size;\n  },\n  empty: function() {\n    for (var property in this) if (property[0] === prefix) return false;\n    return true;\n  },\n  each: function(f) {\n    for (var property in this) if (property[0] === prefix) f(this[property], property.slice(1), this);\n  }\n};\n\nfunction map$1(object, f) {\n  var map = new Map;\n\n  // Copy constructor.\n  if (object instanceof Map) object.each(function(value, key) { map.set(key, value); });\n\n  // Index array by numeric index or specified key function.\n  else if (Array.isArray(object)) {\n    var i = -1,\n        n = object.length,\n        o;\n\n    if (f == null) while (++i < n) map.set(i, object[i]);\n    else while (++i < n) map.set(f(o = object[i], i, object), o);\n  }\n\n  // Convert object to map.\n  else if (object) for (var key in object) map.set(key, object[key]);\n\n  return map;\n}\n\nvar nest = function() {\n  var keys = [],\n      sortKeys = [],\n      sortValues,\n      rollup,\n      nest;\n\n  function apply(array, depth, createResult, setResult) {\n    if (depth >= keys.length) return rollup != null\n        ? rollup(array) : (sortValues != null\n        ? array.sort(sortValues)\n        : array);\n\n    var i = -1,\n        n = array.length,\n        key = keys[depth++],\n        keyValue,\n        value,\n        valuesByKey = map$1(),\n        values,\n        result = createResult();\n\n    while (++i < n) {\n      if (values = valuesByKey.get(keyValue = key(value = array[i]) + \"\")) {\n        values.push(value);\n      } else {\n        valuesByKey.set(keyValue, [value]);\n      }\n    }\n\n    valuesByKey.each(function(values, key) {\n      setResult(result, key, apply(values, depth, createResult, setResult));\n    });\n\n    return result;\n  }\n\n  function entries(map, depth) {\n    if (++depth > keys.length) return map;\n    var array, sortKey = sortKeys[depth - 1];\n    if (rollup != null && depth >= keys.length) array = map.entries();\n    else array = [], map.each(function(v, k) { array.push({key: k, values: entries(v, depth)}); });\n    return sortKey != null ? array.sort(function(a, b) { return sortKey(a.key, b.key); }) : array;\n  }\n\n  return nest = {\n    object: function(array) { return apply(array, 0, createObject, setObject); },\n    map: function(array) { return apply(array, 0, createMap, setMap); },\n    entries: function(array) { return entries(apply(array, 0, createMap, setMap), 0); },\n    key: function(d) { keys.push(d); return nest; },\n    sortKeys: function(order) { sortKeys[keys.length - 1] = order; return nest; },\n    sortValues: function(order) { sortValues = order; return nest; },\n    rollup: function(f) { rollup = f; return nest; }\n  };\n};\n\nfunction createObject() {\n  return {};\n}\n\nfunction setObject(object, key, value) {\n  object[key] = value;\n}\n\nfunction createMap() {\n  return map$1();\n}\n\nfunction setMap(map, key, value) {\n  map.set(key, value);\n}\n\nfunction Set() {}\n\nvar proto = map$1.prototype;\n\nSet.prototype = set$2.prototype = {\n  constructor: Set,\n  has: proto.has,\n  add: function(value) {\n    value += \"\";\n    this[prefix + value] = value;\n    return this;\n  },\n  remove: proto.remove,\n  clear: proto.clear,\n  values: proto.keys,\n  size: proto.size,\n  empty: proto.empty,\n  each: proto.each\n};\n\nfunction set$2(object, f) {\n  var set = new Set;\n\n  // Copy constructor.\n  if (object instanceof Set) object.each(function(value) { set.add(value); });\n\n  // Otherwise, assume it’s an array.\n  else if (object) {\n    var i = -1, n = object.length;\n    if (f == null) while (++i < n) set.add(object[i]);\n    else while (++i < n) set.add(f(object[i], i, object));\n  }\n\n  return set;\n}\n\nvar keys = function(map) {\n  var keys = [];\n  for (var key in map) keys.push(key);\n  return keys;\n};\n\nvar values = function(map) {\n  var values = [];\n  for (var key in map) values.push(map[key]);\n  return values;\n};\n\nvar entries = function(map) {\n  var entries = [];\n  for (var key in map) entries.push({key: key, value: map[key]});\n  return entries;\n};\n\nfunction objectConverter(columns) {\n  return new Function(\"d\", \"return {\" + columns.map(function(name, i) {\n    return JSON.stringify(name) + \": d[\" + i + \"]\";\n  }).join(\",\") + \"}\");\n}\n\nfunction customConverter(columns, f) {\n  var object = objectConverter(columns);\n  return function(row, i) {\n    return f(object(row), i, columns);\n  };\n}\n\n// Compute unique columns in order of discovery.\nfunction inferColumns(rows) {\n  var columnSet = Object.create(null),\n      columns = [];\n\n  rows.forEach(function(row) {\n    for (var column in row) {\n      if (!(column in columnSet)) {\n        columns.push(columnSet[column] = column);\n      }\n    }\n  });\n\n  return columns;\n}\n\nvar dsv = function(delimiter) {\n  var reFormat = new RegExp(\"[\\\"\" + delimiter + \"\\n]\"),\n      delimiterCode = delimiter.charCodeAt(0);\n\n  function parse(text, f) {\n    var convert, columns, rows = parseRows(text, function(row, i) {\n      if (convert) return convert(row, i - 1);\n      columns = row, convert = f ? customConverter(row, f) : objectConverter(row);\n    });\n    rows.columns = columns;\n    return rows;\n  }\n\n  function parseRows(text, f) {\n    var EOL = {}, // sentinel value for end-of-line\n        EOF = {}, // sentinel value for end-of-file\n        rows = [], // output rows\n        N = text.length,\n        I = 0, // current character index\n        n = 0, // the current line number\n        t, // the current token\n        eol; // is the current token followed by EOL?\n\n    function token() {\n      if (I >= N) return EOF; // special case: end of file\n      if (eol) return eol = false, EOL; // special case: end of line\n\n      // special case: quotes\n      var j = I, c;\n      if (text.charCodeAt(j) === 34) {\n        var i = j;\n        while (i++ < N) {\n          if (text.charCodeAt(i) === 34) {\n            if (text.charCodeAt(i + 1) !== 34) break;\n            ++i;\n          }\n        }\n        I = i + 2;\n        c = text.charCodeAt(i + 1);\n        if (c === 13) {\n          eol = true;\n          if (text.charCodeAt(i + 2) === 10) ++I;\n        } else if (c === 10) {\n          eol = true;\n        }\n        return text.slice(j + 1, i).replace(/\"\"/g, \"\\\"\");\n      }\n\n      // common case: find next delimiter or newline\n      while (I < N) {\n        var k = 1;\n        c = text.charCodeAt(I++);\n        if (c === 10) eol = true; // \\n\n        else if (c === 13) { eol = true; if (text.charCodeAt(I) === 10) ++I, ++k; } // \\r|\\r\\n\n        else if (c !== delimiterCode) continue;\n        return text.slice(j, I - k);\n      }\n\n      // special case: last token before EOF\n      return text.slice(j);\n    }\n\n    while ((t = token()) !== EOF) {\n      var a = [];\n      while (t !== EOL && t !== EOF) {\n        a.push(t);\n        t = token();\n      }\n      if (f && (a = f(a, n++)) == null) continue;\n      rows.push(a);\n    }\n\n    return rows;\n  }\n\n  function format(rows, columns) {\n    if (columns == null) columns = inferColumns(rows);\n    return [columns.map(formatValue).join(delimiter)].concat(rows.map(function(row) {\n      return columns.map(function(column) {\n        return formatValue(row[column]);\n      }).join(delimiter);\n    })).join(\"\\n\");\n  }\n\n  function formatRows(rows) {\n    return rows.map(formatRow).join(\"\\n\");\n  }\n\n  function formatRow(row) {\n    return row.map(formatValue).join(delimiter);\n  }\n\n  function formatValue(text) {\n    return text == null ? \"\"\n        : reFormat.test(text += \"\") ? \"\\\"\" + text.replace(/\\\"/g, \"\\\"\\\"\") + \"\\\"\"\n        : text;\n  }\n\n  return {\n    parse: parse,\n    parseRows: parseRows,\n    format: format,\n    formatRows: formatRows\n  };\n};\n\nvar csv = dsv(\",\");\n\nvar csvParse = csv.parse;\nvar csvParseRows = csv.parseRows;\nvar csvFormat = csv.format;\nvar csvFormatRows = csv.formatRows;\n\nvar tsv = dsv(\"\\t\");\n\nvar tsvParse = tsv.parse;\nvar tsvParseRows = tsv.parseRows;\nvar tsvFormat = tsv.format;\nvar tsvFormatRows = tsv.formatRows;\n\nvar center$1 = function(x, y) {\n  var nodes;\n\n  if (x == null) x = 0;\n  if (y == null) y = 0;\n\n  function force() {\n    var i,\n        n = nodes.length,\n        node,\n        sx = 0,\n        sy = 0;\n\n    for (i = 0; i < n; ++i) {\n      node = nodes[i], sx += node.x, sy += node.y;\n    }\n\n    for (sx = sx / n - x, sy = sy / n - y, i = 0; i < n; ++i) {\n      node = nodes[i], node.x -= sx, node.y -= sy;\n    }\n  }\n\n  force.initialize = function(_) {\n    nodes = _;\n  };\n\n  force.x = function(_) {\n    return arguments.length ? (x = +_, force) : x;\n  };\n\n  force.y = function(_) {\n    return arguments.length ? (y = +_, force) : y;\n  };\n\n  return force;\n};\n\nvar constant$6 = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nvar jiggle = function() {\n  return (Math.random() - 0.5) * 1e-6;\n};\n\nvar tree_add = function(d) {\n  var x = +this._x.call(null, d),\n      y = +this._y.call(null, d);\n  return add(this.cover(x, y), x, y, d);\n};\n\nfunction add(tree, x, y, d) {\n  if (isNaN(x) || isNaN(y)) return tree; // ignore invalid points\n\n  var parent,\n      node = tree._root,\n      leaf = {data: d},\n      x0 = tree._x0,\n      y0 = tree._y0,\n      x1 = tree._x1,\n      y1 = tree._y1,\n      xm,\n      ym,\n      xp,\n      yp,\n      right,\n      bottom,\n      i,\n      j;\n\n  // If the tree is empty, initialize the root as a leaf.\n  if (!node) return tree._root = leaf, tree;\n\n  // Find the existing leaf for the new point, or add it.\n  while (node.length) {\n    if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm;\n    if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym;\n    if (parent = node, !(node = node[i = bottom << 1 | right])) return parent[i] = leaf, tree;\n  }\n\n  // Is the new point is exactly coincident with the existing point?\n  xp = +tree._x.call(null, node.data);\n  yp = +tree._y.call(null, node.data);\n  if (x === xp && y === yp) return leaf.next = node, parent ? parent[i] = leaf : tree._root = leaf, tree;\n\n  // Otherwise, split the leaf node until the old and new point are separated.\n  do {\n    parent = parent ? parent[i] = new Array(4) : tree._root = new Array(4);\n    if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm;\n    if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym;\n  } while ((i = bottom << 1 | right) === (j = (yp >= ym) << 1 | (xp >= xm)));\n  return parent[j] = node, parent[i] = leaf, tree;\n}\n\nfunction addAll(data) {\n  var d, i, n = data.length,\n      x,\n      y,\n      xz = new Array(n),\n      yz = new Array(n),\n      x0 = Infinity,\n      y0 = Infinity,\n      x1 = -Infinity,\n      y1 = -Infinity;\n\n  // Compute the points and their extent.\n  for (i = 0; i < n; ++i) {\n    if (isNaN(x = +this._x.call(null, d = data[i])) || isNaN(y = +this._y.call(null, d))) continue;\n    xz[i] = x;\n    yz[i] = y;\n    if (x < x0) x0 = x;\n    if (x > x1) x1 = x;\n    if (y < y0) y0 = y;\n    if (y > y1) y1 = y;\n  }\n\n  // If there were no (valid) points, inherit the existing extent.\n  if (x1 < x0) x0 = this._x0, x1 = this._x1;\n  if (y1 < y0) y0 = this._y0, y1 = this._y1;\n\n  // Expand the tree to cover the new points.\n  this.cover(x0, y0).cover(x1, y1);\n\n  // Add the new points.\n  for (i = 0; i < n; ++i) {\n    add(this, xz[i], yz[i], data[i]);\n  }\n\n  return this;\n}\n\nvar tree_cover = function(x, y) {\n  if (isNaN(x = +x) || isNaN(y = +y)) return this; // ignore invalid points\n\n  var x0 = this._x0,\n      y0 = this._y0,\n      x1 = this._x1,\n      y1 = this._y1;\n\n  // If the quadtree has no extent, initialize them.\n  // Integer extent are necessary so that if we later double the extent,\n  // the existing quadrant boundaries don’t change due to floating point error!\n  if (isNaN(x0)) {\n    x1 = (x0 = Math.floor(x)) + 1;\n    y1 = (y0 = Math.floor(y)) + 1;\n  }\n\n  // Otherwise, double repeatedly to cover.\n  else if (x0 > x || x > x1 || y0 > y || y > y1) {\n    var z = x1 - x0,\n        node = this._root,\n        parent,\n        i;\n\n    switch (i = (y < (y0 + y1) / 2) << 1 | (x < (x0 + x1) / 2)) {\n      case 0: {\n        do parent = new Array(4), parent[i] = node, node = parent;\n        while (z *= 2, x1 = x0 + z, y1 = y0 + z, x > x1 || y > y1);\n        break;\n      }\n      case 1: {\n        do parent = new Array(4), parent[i] = node, node = parent;\n        while (z *= 2, x0 = x1 - z, y1 = y0 + z, x0 > x || y > y1);\n        break;\n      }\n      case 2: {\n        do parent = new Array(4), parent[i] = node, node = parent;\n        while (z *= 2, x1 = x0 + z, y0 = y1 - z, x > x1 || y0 > y);\n        break;\n      }\n      case 3: {\n        do parent = new Array(4), parent[i] = node, node = parent;\n        while (z *= 2, x0 = x1 - z, y0 = y1 - z, x0 > x || y0 > y);\n        break;\n      }\n    }\n\n    if (this._root && this._root.length) this._root = node;\n  }\n\n  // If the quadtree covers the point already, just return.\n  else return this;\n\n  this._x0 = x0;\n  this._y0 = y0;\n  this._x1 = x1;\n  this._y1 = y1;\n  return this;\n};\n\nvar tree_data = function() {\n  var data = [];\n  this.visit(function(node) {\n    if (!node.length) do data.push(node.data); while (node = node.next)\n  });\n  return data;\n};\n\nvar tree_extent = function(_) {\n  return arguments.length\n      ? this.cover(+_[0][0], +_[0][1]).cover(+_[1][0], +_[1][1])\n      : isNaN(this._x0) ? undefined : [[this._x0, this._y0], [this._x1, this._y1]];\n};\n\nvar Quad = function(node, x0, y0, x1, y1) {\n  this.node = node;\n  this.x0 = x0;\n  this.y0 = y0;\n  this.x1 = x1;\n  this.y1 = y1;\n};\n\nvar tree_find = function(x, y, radius) {\n  var data,\n      x0 = this._x0,\n      y0 = this._y0,\n      x1,\n      y1,\n      x2,\n      y2,\n      x3 = this._x1,\n      y3 = this._y1,\n      quads = [],\n      node = this._root,\n      q,\n      i;\n\n  if (node) quads.push(new Quad(node, x0, y0, x3, y3));\n  if (radius == null) radius = Infinity;\n  else {\n    x0 = x - radius, y0 = y - radius;\n    x3 = x + radius, y3 = y + radius;\n    radius *= radius;\n  }\n\n  while (q = quads.pop()) {\n\n    // Stop searching if this quadrant can’t contain a closer node.\n    if (!(node = q.node)\n        || (x1 = q.x0) > x3\n        || (y1 = q.y0) > y3\n        || (x2 = q.x1) < x0\n        || (y2 = q.y1) < y0) continue;\n\n    // Bisect the current quadrant.\n    if (node.length) {\n      var xm = (x1 + x2) / 2,\n          ym = (y1 + y2) / 2;\n\n      quads.push(\n        new Quad(node[3], xm, ym, x2, y2),\n        new Quad(node[2], x1, ym, xm, y2),\n        new Quad(node[1], xm, y1, x2, ym),\n        new Quad(node[0], x1, y1, xm, ym)\n      );\n\n      // Visit the closest quadrant first.\n      if (i = (y >= ym) << 1 | (x >= xm)) {\n        q = quads[quads.length - 1];\n        quads[quads.length - 1] = quads[quads.length - 1 - i];\n        quads[quads.length - 1 - i] = q;\n      }\n    }\n\n    // Visit this point. (Visiting coincident points isn’t necessary!)\n    else {\n      var dx = x - +this._x.call(null, node.data),\n          dy = y - +this._y.call(null, node.data),\n          d2 = dx * dx + dy * dy;\n      if (d2 < radius) {\n        var d = Math.sqrt(radius = d2);\n        x0 = x - d, y0 = y - d;\n        x3 = x + d, y3 = y + d;\n        data = node.data;\n      }\n    }\n  }\n\n  return data;\n};\n\nvar tree_remove = function(d) {\n  if (isNaN(x = +this._x.call(null, d)) || isNaN(y = +this._y.call(null, d))) return this; // ignore invalid points\n\n  var parent,\n      node = this._root,\n      retainer,\n      previous,\n      next,\n      x0 = this._x0,\n      y0 = this._y0,\n      x1 = this._x1,\n      y1 = this._y1,\n      x,\n      y,\n      xm,\n      ym,\n      right,\n      bottom,\n      i,\n      j;\n\n  // If the tree is empty, initialize the root as a leaf.\n  if (!node) return this;\n\n  // Find the leaf node for the point.\n  // While descending, also retain the deepest parent with a non-removed sibling.\n  if (node.length) while (true) {\n    if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm;\n    if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym;\n    if (!(parent = node, node = node[i = bottom << 1 | right])) return this;\n    if (!node.length) break;\n    if (parent[(i + 1) & 3] || parent[(i + 2) & 3] || parent[(i + 3) & 3]) retainer = parent, j = i;\n  }\n\n  // Find the point to remove.\n  while (node.data !== d) if (!(previous = node, node = node.next)) return this;\n  if (next = node.next) delete node.next;\n\n  // If there are multiple coincident points, remove just the point.\n  if (previous) return (next ? previous.next = next : delete previous.next), this;\n\n  // If this is the root point, remove it.\n  if (!parent) return this._root = next, this;\n\n  // Remove this leaf.\n  next ? parent[i] = next : delete parent[i];\n\n  // If the parent now contains exactly one leaf, collapse superfluous parents.\n  if ((node = parent[0] || parent[1] || parent[2] || parent[3])\n      && node === (parent[3] || parent[2] || parent[1] || parent[0])\n      && !node.length) {\n    if (retainer) retainer[j] = node;\n    else this._root = node;\n  }\n\n  return this;\n};\n\nfunction removeAll(data) {\n  for (var i = 0, n = data.length; i < n; ++i) this.remove(data[i]);\n  return this;\n}\n\nvar tree_root = function() {\n  return this._root;\n};\n\nvar tree_size = function() {\n  var size = 0;\n  this.visit(function(node) {\n    if (!node.length) do ++size; while (node = node.next)\n  });\n  return size;\n};\n\nvar tree_visit = function(callback) {\n  var quads = [], q, node = this._root, child, x0, y0, x1, y1;\n  if (node) quads.push(new Quad(node, this._x0, this._y0, this._x1, this._y1));\n  while (q = quads.pop()) {\n    if (!callback(node = q.node, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1) && node.length) {\n      var xm = (x0 + x1) / 2, ym = (y0 + y1) / 2;\n      if (child = node[3]) quads.push(new Quad(child, xm, ym, x1, y1));\n      if (child = node[2]) quads.push(new Quad(child, x0, ym, xm, y1));\n      if (child = node[1]) quads.push(new Quad(child, xm, y0, x1, ym));\n      if (child = node[0]) quads.push(new Quad(child, x0, y0, xm, ym));\n    }\n  }\n  return this;\n};\n\nvar tree_visitAfter = function(callback) {\n  var quads = [], next = [], q;\n  if (this._root) quads.push(new Quad(this._root, this._x0, this._y0, this._x1, this._y1));\n  while (q = quads.pop()) {\n    var node = q.node;\n    if (node.length) {\n      var child, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1, xm = (x0 + x1) / 2, ym = (y0 + y1) / 2;\n      if (child = node[0]) quads.push(new Quad(child, x0, y0, xm, ym));\n      if (child = node[1]) quads.push(new Quad(child, xm, y0, x1, ym));\n      if (child = node[2]) quads.push(new Quad(child, x0, ym, xm, y1));\n      if (child = node[3]) quads.push(new Quad(child, xm, ym, x1, y1));\n    }\n    next.push(q);\n  }\n  while (q = next.pop()) {\n    callback(q.node, q.x0, q.y0, q.x1, q.y1);\n  }\n  return this;\n};\n\nfunction defaultX(d) {\n  return d[0];\n}\n\nvar tree_x = function(_) {\n  return arguments.length ? (this._x = _, this) : this._x;\n};\n\nfunction defaultY(d) {\n  return d[1];\n}\n\nvar tree_y = function(_) {\n  return arguments.length ? (this._y = _, this) : this._y;\n};\n\nfunction quadtree(nodes, x, y) {\n  var tree = new Quadtree(x == null ? defaultX : x, y == null ? defaultY : y, NaN, NaN, NaN, NaN);\n  return nodes == null ? tree : tree.addAll(nodes);\n}\n\nfunction Quadtree(x, y, x0, y0, x1, y1) {\n  this._x = x;\n  this._y = y;\n  this._x0 = x0;\n  this._y0 = y0;\n  this._x1 = x1;\n  this._y1 = y1;\n  this._root = undefined;\n}\n\nfunction leaf_copy(leaf) {\n  var copy = {data: leaf.data}, next = copy;\n  while (leaf = leaf.next) next = next.next = {data: leaf.data};\n  return copy;\n}\n\nvar treeProto = quadtree.prototype = Quadtree.prototype;\n\ntreeProto.copy = function() {\n  var copy = new Quadtree(this._x, this._y, this._x0, this._y0, this._x1, this._y1),\n      node = this._root,\n      nodes,\n      child;\n\n  if (!node) return copy;\n\n  if (!node.length) return copy._root = leaf_copy(node), copy;\n\n  nodes = [{source: node, target: copy._root = new Array(4)}];\n  while (node = nodes.pop()) {\n    for (var i = 0; i < 4; ++i) {\n      if (child = node.source[i]) {\n        if (child.length) nodes.push({source: child, target: node.target[i] = new Array(4)});\n        else node.target[i] = leaf_copy(child);\n      }\n    }\n  }\n\n  return copy;\n};\n\ntreeProto.add = tree_add;\ntreeProto.addAll = addAll;\ntreeProto.cover = tree_cover;\ntreeProto.data = tree_data;\ntreeProto.extent = tree_extent;\ntreeProto.find = tree_find;\ntreeProto.remove = tree_remove;\ntreeProto.removeAll = removeAll;\ntreeProto.root = tree_root;\ntreeProto.size = tree_size;\ntreeProto.visit = tree_visit;\ntreeProto.visitAfter = tree_visitAfter;\ntreeProto.x = tree_x;\ntreeProto.y = tree_y;\n\nfunction x(d) {\n  return d.x + d.vx;\n}\n\nfunction y(d) {\n  return d.y + d.vy;\n}\n\nvar collide = function(radius) {\n  var nodes,\n      radii,\n      strength = 1,\n      iterations = 1;\n\n  if (typeof radius !== \"function\") radius = constant$6(radius == null ? 1 : +radius);\n\n  function force() {\n    var i, n = nodes.length,\n        tree,\n        node,\n        xi,\n        yi,\n        ri,\n        ri2;\n\n    for (var k = 0; k < iterations; ++k) {\n      tree = quadtree(nodes, x, y).visitAfter(prepare);\n      for (i = 0; i < n; ++i) {\n        node = nodes[i];\n        ri = radii[node.index], ri2 = ri * ri;\n        xi = node.x + node.vx;\n        yi = node.y + node.vy;\n        tree.visit(apply);\n      }\n    }\n\n    function apply(quad, x0, y0, x1, y1) {\n      var data = quad.data, rj = quad.r, r = ri + rj;\n      if (data) {\n        if (data.index > node.index) {\n          var x = xi - data.x - data.vx,\n              y = yi - data.y - data.vy,\n              l = x * x + y * y;\n          if (l < r * r) {\n            if (x === 0) x = jiggle(), l += x * x;\n            if (y === 0) y = jiggle(), l += y * y;\n            l = (r - (l = Math.sqrt(l))) / l * strength;\n            node.vx += (x *= l) * (r = (rj *= rj) / (ri2 + rj));\n            node.vy += (y *= l) * r;\n            data.vx -= x * (r = 1 - r);\n            data.vy -= y * r;\n          }\n        }\n        return;\n      }\n      return x0 > xi + r || x1 < xi - r || y0 > yi + r || y1 < yi - r;\n    }\n  }\n\n  function prepare(quad) {\n    if (quad.data) return quad.r = radii[quad.data.index];\n    for (var i = quad.r = 0; i < 4; ++i) {\n      if (quad[i] && quad[i].r > quad.r) {\n        quad.r = quad[i].r;\n      }\n    }\n  }\n\n  function initialize() {\n    if (!nodes) return;\n    var i, n = nodes.length, node;\n    radii = new Array(n);\n    for (i = 0; i < n; ++i) node = nodes[i], radii[node.index] = +radius(node, i, nodes);\n  }\n\n  force.initialize = function(_) {\n    nodes = _;\n    initialize();\n  };\n\n  force.iterations = function(_) {\n    return arguments.length ? (iterations = +_, force) : iterations;\n  };\n\n  force.strength = function(_) {\n    return arguments.length ? (strength = +_, force) : strength;\n  };\n\n  force.radius = function(_) {\n    return arguments.length ? (radius = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : radius;\n  };\n\n  return force;\n};\n\nfunction index(d) {\n  return d.index;\n}\n\nfunction find(nodeById, nodeId) {\n  var node = nodeById.get(nodeId);\n  if (!node) throw new Error(\"missing: \" + nodeId);\n  return node;\n}\n\nvar link = function(links) {\n  var id = index,\n      strength = defaultStrength,\n      strengths,\n      distance = constant$6(30),\n      distances,\n      nodes,\n      count,\n      bias,\n      iterations = 1;\n\n  if (links == null) links = [];\n\n  function defaultStrength(link) {\n    return 1 / Math.min(count[link.source.index], count[link.target.index]);\n  }\n\n  function force(alpha) {\n    for (var k = 0, n = links.length; k < iterations; ++k) {\n      for (var i = 0, link, source, target, x, y, l, b; i < n; ++i) {\n        link = links[i], source = link.source, target = link.target;\n        x = target.x + target.vx - source.x - source.vx || jiggle();\n        y = target.y + target.vy - source.y - source.vy || jiggle();\n        l = Math.sqrt(x * x + y * y);\n        l = (l - distances[i]) / l * alpha * strengths[i];\n        x *= l, y *= l;\n        target.vx -= x * (b = bias[i]);\n        target.vy -= y * b;\n        source.vx += x * (b = 1 - b);\n        source.vy += y * b;\n      }\n    }\n  }\n\n  function initialize() {\n    if (!nodes) return;\n\n    var i,\n        n = nodes.length,\n        m = links.length,\n        nodeById = map$1(nodes, id),\n        link;\n\n    for (i = 0, count = new Array(n); i < m; ++i) {\n      link = links[i], link.index = i;\n      if (typeof link.source !== \"object\") link.source = find(nodeById, link.source);\n      if (typeof link.target !== \"object\") link.target = find(nodeById, link.target);\n      count[link.source.index] = (count[link.source.index] || 0) + 1;\n      count[link.target.index] = (count[link.target.index] || 0) + 1;\n    }\n\n    for (i = 0, bias = new Array(m); i < m; ++i) {\n      link = links[i], bias[i] = count[link.source.index] / (count[link.source.index] + count[link.target.index]);\n    }\n\n    strengths = new Array(m), initializeStrength();\n    distances = new Array(m), initializeDistance();\n  }\n\n  function initializeStrength() {\n    if (!nodes) return;\n\n    for (var i = 0, n = links.length; i < n; ++i) {\n      strengths[i] = +strength(links[i], i, links);\n    }\n  }\n\n  function initializeDistance() {\n    if (!nodes) return;\n\n    for (var i = 0, n = links.length; i < n; ++i) {\n      distances[i] = +distance(links[i], i, links);\n    }\n  }\n\n  force.initialize = function(_) {\n    nodes = _;\n    initialize();\n  };\n\n  force.links = function(_) {\n    return arguments.length ? (links = _, initialize(), force) : links;\n  };\n\n  force.id = function(_) {\n    return arguments.length ? (id = _, force) : id;\n  };\n\n  force.iterations = function(_) {\n    return arguments.length ? (iterations = +_, force) : iterations;\n  };\n\n  force.strength = function(_) {\n    return arguments.length ? (strength = typeof _ === \"function\" ? _ : constant$6(+_), initializeStrength(), force) : strength;\n  };\n\n  force.distance = function(_) {\n    return arguments.length ? (distance = typeof _ === \"function\" ? _ : constant$6(+_), initializeDistance(), force) : distance;\n  };\n\n  return force;\n};\n\nfunction x$1(d) {\n  return d.x;\n}\n\nfunction y$1(d) {\n  return d.y;\n}\n\nvar initialRadius = 10;\nvar initialAngle = Math.PI * (3 - Math.sqrt(5));\n\nvar simulation = function(nodes) {\n  var simulation,\n      alpha = 1,\n      alphaMin = 0.001,\n      alphaDecay = 1 - Math.pow(alphaMin, 1 / 300),\n      alphaTarget = 0,\n      velocityDecay = 0.6,\n      forces = map$1(),\n      stepper = timer(step),\n      event = dispatch(\"tick\", \"end\");\n\n  if (nodes == null) nodes = [];\n\n  function step() {\n    tick();\n    event.call(\"tick\", simulation);\n    if (alpha < alphaMin) {\n      stepper.stop();\n      event.call(\"end\", simulation);\n    }\n  }\n\n  function tick() {\n    var i, n = nodes.length, node;\n\n    alpha += (alphaTarget - alpha) * alphaDecay;\n\n    forces.each(function(force) {\n      force(alpha);\n    });\n\n    for (i = 0; i < n; ++i) {\n      node = nodes[i];\n      if (node.fx == null) node.x += node.vx *= velocityDecay;\n      else node.x = node.fx, node.vx = 0;\n      if (node.fy == null) node.y += node.vy *= velocityDecay;\n      else node.y = node.fy, node.vy = 0;\n    }\n  }\n\n  function initializeNodes() {\n    for (var i = 0, n = nodes.length, node; i < n; ++i) {\n      node = nodes[i], node.index = i;\n      if (isNaN(node.x) || isNaN(node.y)) {\n        var radius = initialRadius * Math.sqrt(i), angle = i * initialAngle;\n        node.x = radius * Math.cos(angle);\n        node.y = radius * Math.sin(angle);\n      }\n      if (isNaN(node.vx) || isNaN(node.vy)) {\n        node.vx = node.vy = 0;\n      }\n    }\n  }\n\n  function initializeForce(force) {\n    if (force.initialize) force.initialize(nodes);\n    return force;\n  }\n\n  initializeNodes();\n\n  return simulation = {\n    tick: tick,\n\n    restart: function() {\n      return stepper.restart(step), simulation;\n    },\n\n    stop: function() {\n      return stepper.stop(), simulation;\n    },\n\n    nodes: function(_) {\n      return arguments.length ? (nodes = _, initializeNodes(), forces.each(initializeForce), simulation) : nodes;\n    },\n\n    alpha: function(_) {\n      return arguments.length ? (alpha = +_, simulation) : alpha;\n    },\n\n    alphaMin: function(_) {\n      return arguments.length ? (alphaMin = +_, simulation) : alphaMin;\n    },\n\n    alphaDecay: function(_) {\n      return arguments.length ? (alphaDecay = +_, simulation) : +alphaDecay;\n    },\n\n    alphaTarget: function(_) {\n      return arguments.length ? (alphaTarget = +_, simulation) : alphaTarget;\n    },\n\n    velocityDecay: function(_) {\n      return arguments.length ? (velocityDecay = 1 - _, simulation) : 1 - velocityDecay;\n    },\n\n    force: function(name, _) {\n      return arguments.length > 1 ? ((_ == null ? forces.remove(name) : forces.set(name, initializeForce(_))), simulation) : forces.get(name);\n    },\n\n    find: function(x, y, radius) {\n      var i = 0,\n          n = nodes.length,\n          dx,\n          dy,\n          d2,\n          node,\n          closest;\n\n      if (radius == null) radius = Infinity;\n      else radius *= radius;\n\n      for (i = 0; i < n; ++i) {\n        node = nodes[i];\n        dx = x - node.x;\n        dy = y - node.y;\n        d2 = dx * dx + dy * dy;\n        if (d2 < radius) closest = node, radius = d2;\n      }\n\n      return closest;\n    },\n\n    on: function(name, _) {\n      return arguments.length > 1 ? (event.on(name, _), simulation) : event.on(name);\n    }\n  };\n};\n\nvar manyBody = function() {\n  var nodes,\n      node,\n      alpha,\n      strength = constant$6(-30),\n      strengths,\n      distanceMin2 = 1,\n      distanceMax2 = Infinity,\n      theta2 = 0.81;\n\n  function force(_) {\n    var i, n = nodes.length, tree = quadtree(nodes, x$1, y$1).visitAfter(accumulate);\n    for (alpha = _, i = 0; i < n; ++i) node = nodes[i], tree.visit(apply);\n  }\n\n  function initialize() {\n    if (!nodes) return;\n    var i, n = nodes.length, node;\n    strengths = new Array(n);\n    for (i = 0; i < n; ++i) node = nodes[i], strengths[node.index] = +strength(node, i, nodes);\n  }\n\n  function accumulate(quad) {\n    var strength = 0, q, c, x$$1, y$$1, i;\n\n    // For internal nodes, accumulate forces from child quadrants.\n    if (quad.length) {\n      for (x$$1 = y$$1 = i = 0; i < 4; ++i) {\n        if ((q = quad[i]) && (c = q.value)) {\n          strength += c, x$$1 += c * q.x, y$$1 += c * q.y;\n        }\n      }\n      quad.x = x$$1 / strength;\n      quad.y = y$$1 / strength;\n    }\n\n    // For leaf nodes, accumulate forces from coincident quadrants.\n    else {\n      q = quad;\n      q.x = q.data.x;\n      q.y = q.data.y;\n      do strength += strengths[q.data.index];\n      while (q = q.next);\n    }\n\n    quad.value = strength;\n  }\n\n  function apply(quad, x1, _, x2) {\n    if (!quad.value) return true;\n\n    var x$$1 = quad.x - node.x,\n        y$$1 = quad.y - node.y,\n        w = x2 - x1,\n        l = x$$1 * x$$1 + y$$1 * y$$1;\n\n    // Apply the Barnes-Hut approximation if possible.\n    // Limit forces for very close nodes; randomize direction if coincident.\n    if (w * w / theta2 < l) {\n      if (l < distanceMax2) {\n        if (x$$1 === 0) x$$1 = jiggle(), l += x$$1 * x$$1;\n        if (y$$1 === 0) y$$1 = jiggle(), l += y$$1 * y$$1;\n        if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l);\n        node.vx += x$$1 * quad.value * alpha / l;\n        node.vy += y$$1 * quad.value * alpha / l;\n      }\n      return true;\n    }\n\n    // Otherwise, process points directly.\n    else if (quad.length || l >= distanceMax2) return;\n\n    // Limit forces for very close nodes; randomize direction if coincident.\n    if (quad.data !== node || quad.next) {\n      if (x$$1 === 0) x$$1 = jiggle(), l += x$$1 * x$$1;\n      if (y$$1 === 0) y$$1 = jiggle(), l += y$$1 * y$$1;\n      if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l);\n    }\n\n    do if (quad.data !== node) {\n      w = strengths[quad.data.index] * alpha / l;\n      node.vx += x$$1 * w;\n      node.vy += y$$1 * w;\n    } while (quad = quad.next);\n  }\n\n  force.initialize = function(_) {\n    nodes = _;\n    initialize();\n  };\n\n  force.strength = function(_) {\n    return arguments.length ? (strength = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : strength;\n  };\n\n  force.distanceMin = function(_) {\n    return arguments.length ? (distanceMin2 = _ * _, force) : Math.sqrt(distanceMin2);\n  };\n\n  force.distanceMax = function(_) {\n    return arguments.length ? (distanceMax2 = _ * _, force) : Math.sqrt(distanceMax2);\n  };\n\n  force.theta = function(_) {\n    return arguments.length ? (theta2 = _ * _, force) : Math.sqrt(theta2);\n  };\n\n  return force;\n};\n\nvar x$2 = function(x) {\n  var strength = constant$6(0.1),\n      nodes,\n      strengths,\n      xz;\n\n  if (typeof x !== \"function\") x = constant$6(x == null ? 0 : +x);\n\n  function force(alpha) {\n    for (var i = 0, n = nodes.length, node; i < n; ++i) {\n      node = nodes[i], node.vx += (xz[i] - node.x) * strengths[i] * alpha;\n    }\n  }\n\n  function initialize() {\n    if (!nodes) return;\n    var i, n = nodes.length;\n    strengths = new Array(n);\n    xz = new Array(n);\n    for (i = 0; i < n; ++i) {\n      strengths[i] = isNaN(xz[i] = +x(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes);\n    }\n  }\n\n  force.initialize = function(_) {\n    nodes = _;\n    initialize();\n  };\n\n  force.strength = function(_) {\n    return arguments.length ? (strength = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : strength;\n  };\n\n  force.x = function(_) {\n    return arguments.length ? (x = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : x;\n  };\n\n  return force;\n};\n\nvar y$2 = function(y) {\n  var strength = constant$6(0.1),\n      nodes,\n      strengths,\n      yz;\n\n  if (typeof y !== \"function\") y = constant$6(y == null ? 0 : +y);\n\n  function force(alpha) {\n    for (var i = 0, n = nodes.length, node; i < n; ++i) {\n      node = nodes[i], node.vy += (yz[i] - node.y) * strengths[i] * alpha;\n    }\n  }\n\n  function initialize() {\n    if (!nodes) return;\n    var i, n = nodes.length;\n    strengths = new Array(n);\n    yz = new Array(n);\n    for (i = 0; i < n; ++i) {\n      strengths[i] = isNaN(yz[i] = +y(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes);\n    }\n  }\n\n  force.initialize = function(_) {\n    nodes = _;\n    initialize();\n  };\n\n  force.strength = function(_) {\n    return arguments.length ? (strength = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : strength;\n  };\n\n  force.y = function(_) {\n    return arguments.length ? (y = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : y;\n  };\n\n  return force;\n};\n\n// Computes the decimal coefficient and exponent of the specified number x with\n// significant digits p, where x is positive and p is in [1, 21] or undefined.\n// For example, formatDecimal(1.23) returns [\"123\", 0].\nvar formatDecimal = function(x, p) {\n  if ((i = (x = p ? x.toExponential(p - 1) : x.toExponential()).indexOf(\"e\")) < 0) return null; // NaN, ±Infinity\n  var i, coefficient = x.slice(0, i);\n\n  // The string returned by toExponential either has the form \\d\\.\\d+e[-+]\\d+\n  // (e.g., 1.2e+3) or the form \\de[-+]\\d+ (e.g., 1e+3).\n  return [\n    coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient,\n    +x.slice(i + 1)\n  ];\n};\n\nvar exponent$1 = function(x) {\n  return x = formatDecimal(Math.abs(x)), x ? x[1] : NaN;\n};\n\nvar formatGroup = function(grouping, thousands) {\n  return function(value, width) {\n    var i = value.length,\n        t = [],\n        j = 0,\n        g = grouping[0],\n        length = 0;\n\n    while (i > 0 && g > 0) {\n      if (length + g + 1 > width) g = Math.max(1, width - length);\n      t.push(value.substring(i -= g, i + g));\n      if ((length += g + 1) > width) break;\n      g = grouping[j = (j + 1) % grouping.length];\n    }\n\n    return t.reverse().join(thousands);\n  };\n};\n\nvar formatDefault = function(x, p) {\n  x = x.toPrecision(p);\n\n  out: for (var n = x.length, i = 1, i0 = -1, i1; i < n; ++i) {\n    switch (x[i]) {\n      case \".\": i0 = i1 = i; break;\n      case \"0\": if (i0 === 0) i0 = i; i1 = i; break;\n      case \"e\": break out;\n      default: if (i0 > 0) i0 = 0; break;\n    }\n  }\n\n  return i0 > 0 ? x.slice(0, i0) + x.slice(i1 + 1) : x;\n};\n\nvar prefixExponent;\n\nvar formatPrefixAuto = function(x, p) {\n  var d = formatDecimal(x, p);\n  if (!d) return x + \"\";\n  var coefficient = d[0],\n      exponent = d[1],\n      i = exponent - (prefixExponent = Math.max(-8, Math.min(8, Math.floor(exponent / 3))) * 3) + 1,\n      n = coefficient.length;\n  return i === n ? coefficient\n      : i > n ? coefficient + new Array(i - n + 1).join(\"0\")\n      : i > 0 ? coefficient.slice(0, i) + \".\" + coefficient.slice(i)\n      : \"0.\" + new Array(1 - i).join(\"0\") + formatDecimal(x, Math.max(0, p + i - 1))[0]; // less than 1y!\n};\n\nvar formatRounded = function(x, p) {\n  var d = formatDecimal(x, p);\n  if (!d) return x + \"\";\n  var coefficient = d[0],\n      exponent = d[1];\n  return exponent < 0 ? \"0.\" + new Array(-exponent).join(\"0\") + coefficient\n      : coefficient.length > exponent + 1 ? coefficient.slice(0, exponent + 1) + \".\" + coefficient.slice(exponent + 1)\n      : coefficient + new Array(exponent - coefficient.length + 2).join(\"0\");\n};\n\nvar formatTypes = {\n  \"\": formatDefault,\n  \"%\": function(x, p) { return (x * 100).toFixed(p); },\n  \"b\": function(x) { return Math.round(x).toString(2); },\n  \"c\": function(x) { return x + \"\"; },\n  \"d\": function(x) { return Math.round(x).toString(10); },\n  \"e\": function(x, p) { return x.toExponential(p); },\n  \"f\": function(x, p) { return x.toFixed(p); },\n  \"g\": function(x, p) { return x.toPrecision(p); },\n  \"o\": function(x) { return Math.round(x).toString(8); },\n  \"p\": function(x, p) { return formatRounded(x * 100, p); },\n  \"r\": formatRounded,\n  \"s\": formatPrefixAuto,\n  \"X\": function(x) { return Math.round(x).toString(16).toUpperCase(); },\n  \"x\": function(x) { return Math.round(x).toString(16); }\n};\n\n// [[fill]align][sign][symbol][0][width][,][.precision][type]\nvar re = /^(?:(.)?([<>=^]))?([+\\-\\( ])?([$#])?(0)?(\\d+)?(,)?(\\.\\d+)?([a-z%])?$/i;\n\nvar formatSpecifier = function(specifier) {\n  return new FormatSpecifier(specifier);\n};\n\nfunction FormatSpecifier(specifier) {\n  if (!(match = re.exec(specifier))) throw new Error(\"invalid format: \" + specifier);\n\n  var match,\n      fill = match[1] || \" \",\n      align = match[2] || \">\",\n      sign = match[3] || \"-\",\n      symbol = match[4] || \"\",\n      zero = !!match[5],\n      width = match[6] && +match[6],\n      comma = !!match[7],\n      precision = match[8] && +match[8].slice(1),\n      type = match[9] || \"\";\n\n  // The \"n\" type is an alias for \",g\".\n  if (type === \"n\") comma = true, type = \"g\";\n\n  // Map invalid types to the default format.\n  else if (!formatTypes[type]) type = \"\";\n\n  // If zero fill is specified, padding goes after sign and before digits.\n  if (zero || (fill === \"0\" && align === \"=\")) zero = true, fill = \"0\", align = \"=\";\n\n  this.fill = fill;\n  this.align = align;\n  this.sign = sign;\n  this.symbol = symbol;\n  this.zero = zero;\n  this.width = width;\n  this.comma = comma;\n  this.precision = precision;\n  this.type = type;\n}\n\nFormatSpecifier.prototype.toString = function() {\n  return this.fill\n      + this.align\n      + this.sign\n      + this.symbol\n      + (this.zero ? \"0\" : \"\")\n      + (this.width == null ? \"\" : Math.max(1, this.width | 0))\n      + (this.comma ? \",\" : \"\")\n      + (this.precision == null ? \"\" : \".\" + Math.max(0, this.precision | 0))\n      + this.type;\n};\n\nvar prefixes = [\"y\",\"z\",\"a\",\"f\",\"p\",\"n\",\"\\xB5\",\"m\",\"\",\"k\",\"M\",\"G\",\"T\",\"P\",\"E\",\"Z\",\"Y\"];\n\nfunction identity$3(x) {\n  return x;\n}\n\nvar formatLocale = function(locale) {\n  var group = locale.grouping && locale.thousands ? formatGroup(locale.grouping, locale.thousands) : identity$3,\n      currency = locale.currency,\n      decimal = locale.decimal;\n\n  function newFormat(specifier) {\n    specifier = formatSpecifier(specifier);\n\n    var fill = specifier.fill,\n        align = specifier.align,\n        sign = specifier.sign,\n        symbol = specifier.symbol,\n        zero = specifier.zero,\n        width = specifier.width,\n        comma = specifier.comma,\n        precision = specifier.precision,\n        type = specifier.type;\n\n    // Compute the prefix and suffix.\n    // For SI-prefix, the suffix is lazily computed.\n    var prefix = symbol === \"$\" ? currency[0] : symbol === \"#\" && /[boxX]/.test(type) ? \"0\" + type.toLowerCase() : \"\",\n        suffix = symbol === \"$\" ? currency[1] : /[%p]/.test(type) ? \"%\" : \"\";\n\n    // What format function should we use?\n    // Is this an integer type?\n    // Can this type generate exponential notation?\n    var formatType = formatTypes[type],\n        maybeSuffix = !type || /[defgprs%]/.test(type);\n\n    // Set the default precision if not specified,\n    // or clamp the specified precision to the supported range.\n    // For significant precision, it must be in [1, 21].\n    // For fixed precision, it must be in [0, 20].\n    precision = precision == null ? (type ? 6 : 12)\n        : /[gprs]/.test(type) ? Math.max(1, Math.min(21, precision))\n        : Math.max(0, Math.min(20, precision));\n\n    function format(value) {\n      var valuePrefix = prefix,\n          valueSuffix = suffix,\n          i, n, c;\n\n      if (type === \"c\") {\n        valueSuffix = formatType(value) + valueSuffix;\n        value = \"\";\n      } else {\n        value = +value;\n\n        // Convert negative to positive, and compute the prefix.\n        // Note that -0 is not less than 0, but 1 / -0 is!\n        var valueNegative = (value < 0 || 1 / value < 0) && (value *= -1, true);\n\n        // Perform the initial formatting.\n        value = formatType(value, precision);\n\n        // If the original value was negative, it may be rounded to zero during\n        // formatting; treat this as (positive) zero.\n        if (valueNegative) {\n          i = -1, n = value.length;\n          valueNegative = false;\n          while (++i < n) {\n            if (c = value.charCodeAt(i), (48 < c && c < 58)\n                || (type === \"x\" && 96 < c && c < 103)\n                || (type === \"X\" && 64 < c && c < 71)) {\n              valueNegative = true;\n              break;\n            }\n          }\n        }\n\n        // Compute the prefix and suffix.\n        valuePrefix = (valueNegative ? (sign === \"(\" ? sign : \"-\") : sign === \"-\" || sign === \"(\" ? \"\" : sign) + valuePrefix;\n        valueSuffix = valueSuffix + (type === \"s\" ? prefixes[8 + prefixExponent / 3] : \"\") + (valueNegative && sign === \"(\" ? \")\" : \"\");\n\n        // Break the formatted value into the integer “value” part that can be\n        // grouped, and fractional or exponential “suffix” part that is not.\n        if (maybeSuffix) {\n          i = -1, n = value.length;\n          while (++i < n) {\n            if (c = value.charCodeAt(i), 48 > c || c > 57) {\n              valueSuffix = (c === 46 ? decimal + value.slice(i + 1) : value.slice(i)) + valueSuffix;\n              value = value.slice(0, i);\n              break;\n            }\n          }\n        }\n      }\n\n      // If the fill character is not \"0\", grouping is applied before padding.\n      if (comma && !zero) value = group(value, Infinity);\n\n      // Compute the padding.\n      var length = valuePrefix.length + value.length + valueSuffix.length,\n          padding = length < width ? new Array(width - length + 1).join(fill) : \"\";\n\n      // If the fill character is \"0\", grouping is applied after padding.\n      if (comma && zero) value = group(padding + value, padding.length ? width - valueSuffix.length : Infinity), padding = \"\";\n\n      // Reconstruct the final output based on the desired alignment.\n      switch (align) {\n        case \"<\": return valuePrefix + value + valueSuffix + padding;\n        case \"=\": return valuePrefix + padding + value + valueSuffix;\n        case \"^\": return padding.slice(0, length = padding.length >> 1) + valuePrefix + value + valueSuffix + padding.slice(length);\n      }\n      return padding + valuePrefix + value + valueSuffix;\n    }\n\n    format.toString = function() {\n      return specifier + \"\";\n    };\n\n    return format;\n  }\n\n  function formatPrefix(specifier, value) {\n    var f = newFormat((specifier = formatSpecifier(specifier), specifier.type = \"f\", specifier)),\n        e = Math.max(-8, Math.min(8, Math.floor(exponent$1(value) / 3))) * 3,\n        k = Math.pow(10, -e),\n        prefix = prefixes[8 + e / 3];\n    return function(value) {\n      return f(k * value) + prefix;\n    };\n  }\n\n  return {\n    format: newFormat,\n    formatPrefix: formatPrefix\n  };\n};\n\nvar locale$1;\n\n\n\ndefaultLocale({\n  decimal: \".\",\n  thousands: \",\",\n  grouping: [3],\n  currency: [\"$\", \"\"]\n});\n\nfunction defaultLocale(definition) {\n  locale$1 = formatLocale(definition);\n  exports.format = locale$1.format;\n  exports.formatPrefix = locale$1.formatPrefix;\n  return locale$1;\n}\n\nvar precisionFixed = function(step) {\n  return Math.max(0, -exponent$1(Math.abs(step)));\n};\n\nvar precisionPrefix = function(step, value) {\n  return Math.max(0, Math.max(-8, Math.min(8, Math.floor(exponent$1(value) / 3))) * 3 - exponent$1(Math.abs(step)));\n};\n\nvar precisionRound = function(step, max) {\n  step = Math.abs(step), max = Math.abs(max) - step;\n  return Math.max(0, exponent$1(max) - exponent$1(step)) + 1;\n};\n\n// Adds floating point numbers with twice the normal precision.\n// Reference: J. R. Shewchuk, Adaptive Precision Floating-Point Arithmetic and\n// Fast Robust Geometric Predicates, Discrete & Computational Geometry 18(3)\n// 305–363 (1997).\n// Code adapted from GeographicLib by Charles F. F. Karney,\n// http://geographiclib.sourceforge.net/\n\nvar adder = function() {\n  return new Adder;\n};\n\nfunction Adder() {\n  this.reset();\n}\n\nAdder.prototype = {\n  constructor: Adder,\n  reset: function() {\n    this.s = // rounded value\n    this.t = 0; // exact error\n  },\n  add: function(y) {\n    add$1(temp, y, this.t);\n    add$1(this, temp.s, this.s);\n    if (this.s) this.t += temp.t;\n    else this.s = temp.t;\n  },\n  valueOf: function() {\n    return this.s;\n  }\n};\n\nvar temp = new Adder;\n\nfunction add$1(adder, a, b) {\n  var x = adder.s = a + b,\n      bv = x - a,\n      av = x - bv;\n  adder.t = (a - av) + (b - bv);\n}\n\nvar epsilon$2 = 1e-6;\nvar epsilon2$1 = 1e-12;\nvar pi$3 = Math.PI;\nvar halfPi$2 = pi$3 / 2;\nvar quarterPi = pi$3 / 4;\nvar tau$3 = pi$3 * 2;\n\nvar degrees$1 = 180 / pi$3;\nvar radians = pi$3 / 180;\n\nvar abs = Math.abs;\nvar atan = Math.atan;\nvar atan2 = Math.atan2;\nvar cos$1 = Math.cos;\nvar ceil = Math.ceil;\nvar exp = Math.exp;\n\nvar log = Math.log;\nvar pow = Math.pow;\nvar sin$1 = Math.sin;\nvar sign = Math.sign || function(x) { return x > 0 ? 1 : x < 0 ? -1 : 0; };\nvar sqrt = Math.sqrt;\nvar tan = Math.tan;\n\nfunction acos(x) {\n  return x > 1 ? 0 : x < -1 ? pi$3 : Math.acos(x);\n}\n\nfunction asin(x) {\n  return x > 1 ? halfPi$2 : x < -1 ? -halfPi$2 : Math.asin(x);\n}\n\nfunction haversin(x) {\n  return (x = sin$1(x / 2)) * x;\n}\n\nfunction noop$1() {}\n\nfunction streamGeometry(geometry, stream) {\n  if (geometry && streamGeometryType.hasOwnProperty(geometry.type)) {\n    streamGeometryType[geometry.type](geometry, stream);\n  }\n}\n\nvar streamObjectType = {\n  Feature: function(feature, stream) {\n    streamGeometry(feature.geometry, stream);\n  },\n  FeatureCollection: function(object, stream) {\n    var features = object.features, i = -1, n = features.length;\n    while (++i < n) streamGeometry(features[i].geometry, stream);\n  }\n};\n\nvar streamGeometryType = {\n  Sphere: function(object, stream) {\n    stream.sphere();\n  },\n  Point: function(object, stream) {\n    object = object.coordinates;\n    stream.point(object[0], object[1], object[2]);\n  },\n  MultiPoint: function(object, stream) {\n    var coordinates = object.coordinates, i = -1, n = coordinates.length;\n    while (++i < n) object = coordinates[i], stream.point(object[0], object[1], object[2]);\n  },\n  LineString: function(object, stream) {\n    streamLine(object.coordinates, stream, 0);\n  },\n  MultiLineString: function(object, stream) {\n    var coordinates = object.coordinates, i = -1, n = coordinates.length;\n    while (++i < n) streamLine(coordinates[i], stream, 0);\n  },\n  Polygon: function(object, stream) {\n    streamPolygon(object.coordinates, stream);\n  },\n  MultiPolygon: function(object, stream) {\n    var coordinates = object.coordinates, i = -1, n = coordinates.length;\n    while (++i < n) streamPolygon(coordinates[i], stream);\n  },\n  GeometryCollection: function(object, stream) {\n    var geometries = object.geometries, i = -1, n = geometries.length;\n    while (++i < n) streamGeometry(geometries[i], stream);\n  }\n};\n\nfunction streamLine(coordinates, stream, closed) {\n  var i = -1, n = coordinates.length - closed, coordinate;\n  stream.lineStart();\n  while (++i < n) coordinate = coordinates[i], stream.point(coordinate[0], coordinate[1], coordinate[2]);\n  stream.lineEnd();\n}\n\nfunction streamPolygon(coordinates, stream) {\n  var i = -1, n = coordinates.length;\n  stream.polygonStart();\n  while (++i < n) streamLine(coordinates[i], stream, 1);\n  stream.polygonEnd();\n}\n\nvar geoStream = function(object, stream) {\n  if (object && streamObjectType.hasOwnProperty(object.type)) {\n    streamObjectType[object.type](object, stream);\n  } else {\n    streamGeometry(object, stream);\n  }\n};\n\nvar areaRingSum = adder();\n\nvar areaSum = adder();\nvar lambda00;\nvar phi00;\nvar lambda0;\nvar cosPhi0;\nvar sinPhi0;\n\nvar areaStream = {\n  point: noop$1,\n  lineStart: noop$1,\n  lineEnd: noop$1,\n  polygonStart: function() {\n    areaRingSum.reset();\n    areaStream.lineStart = areaRingStart;\n    areaStream.lineEnd = areaRingEnd;\n  },\n  polygonEnd: function() {\n    var areaRing = +areaRingSum;\n    areaSum.add(areaRing < 0 ? tau$3 + areaRing : areaRing);\n    this.lineStart = this.lineEnd = this.point = noop$1;\n  },\n  sphere: function() {\n    areaSum.add(tau$3);\n  }\n};\n\nfunction areaRingStart() {\n  areaStream.point = areaPointFirst;\n}\n\nfunction areaRingEnd() {\n  areaPoint(lambda00, phi00);\n}\n\nfunction areaPointFirst(lambda, phi) {\n  areaStream.point = areaPoint;\n  lambda00 = lambda, phi00 = phi;\n  lambda *= radians, phi *= radians;\n  lambda0 = lambda, cosPhi0 = cos$1(phi = phi / 2 + quarterPi), sinPhi0 = sin$1(phi);\n}\n\nfunction areaPoint(lambda, phi) {\n  lambda *= radians, phi *= radians;\n  phi = phi / 2 + quarterPi; // half the angular distance from south pole\n\n  // Spherical excess E for a spherical triangle with vertices: south pole,\n  // previous point, current point.  Uses a formula derived from Cagnoli’s\n  // theorem.  See Todhunter, Spherical Trig. (1871), Sec. 103, Eq. (2).\n  var dLambda = lambda - lambda0,\n      sdLambda = dLambda >= 0 ? 1 : -1,\n      adLambda = sdLambda * dLambda,\n      cosPhi = cos$1(phi),\n      sinPhi = sin$1(phi),\n      k = sinPhi0 * sinPhi,\n      u = cosPhi0 * cosPhi + k * cos$1(adLambda),\n      v = k * sdLambda * sin$1(adLambda);\n  areaRingSum.add(atan2(v, u));\n\n  // Advance the previous points.\n  lambda0 = lambda, cosPhi0 = cosPhi, sinPhi0 = sinPhi;\n}\n\nvar area = function(object) {\n  areaSum.reset();\n  geoStream(object, areaStream);\n  return areaSum * 2;\n};\n\nfunction spherical(cartesian) {\n  return [atan2(cartesian[1], cartesian[0]), asin(cartesian[2])];\n}\n\nfunction cartesian(spherical) {\n  var lambda = spherical[0], phi = spherical[1], cosPhi = cos$1(phi);\n  return [cosPhi * cos$1(lambda), cosPhi * sin$1(lambda), sin$1(phi)];\n}\n\nfunction cartesianDot(a, b) {\n  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];\n}\n\nfunction cartesianCross(a, b) {\n  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];\n}\n\n// TODO return a\nfunction cartesianAddInPlace(a, b) {\n  a[0] += b[0], a[1] += b[1], a[2] += b[2];\n}\n\nfunction cartesianScale(vector, k) {\n  return [vector[0] * k, vector[1] * k, vector[2] * k];\n}\n\n// TODO return d\nfunction cartesianNormalizeInPlace(d) {\n  var l = sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);\n  d[0] /= l, d[1] /= l, d[2] /= l;\n}\n\nvar lambda0$1;\nvar phi0;\nvar lambda1;\nvar phi1;\nvar lambda2;\nvar lambda00$1;\nvar phi00$1;\nvar p0;\nvar deltaSum = adder();\nvar ranges;\nvar range;\n\nvar boundsStream = {\n  point: boundsPoint,\n  lineStart: boundsLineStart,\n  lineEnd: boundsLineEnd,\n  polygonStart: function() {\n    boundsStream.point = boundsRingPoint;\n    boundsStream.lineStart = boundsRingStart;\n    boundsStream.lineEnd = boundsRingEnd;\n    deltaSum.reset();\n    areaStream.polygonStart();\n  },\n  polygonEnd: function() {\n    areaStream.polygonEnd();\n    boundsStream.point = boundsPoint;\n    boundsStream.lineStart = boundsLineStart;\n    boundsStream.lineEnd = boundsLineEnd;\n    if (areaRingSum < 0) lambda0$1 = -(lambda1 = 180), phi0 = -(phi1 = 90);\n    else if (deltaSum > epsilon$2) phi1 = 90;\n    else if (deltaSum < -epsilon$2) phi0 = -90;\n    range[0] = lambda0$1, range[1] = lambda1;\n  }\n};\n\nfunction boundsPoint(lambda, phi) {\n  ranges.push(range = [lambda0$1 = lambda, lambda1 = lambda]);\n  if (phi < phi0) phi0 = phi;\n  if (phi > phi1) phi1 = phi;\n}\n\nfunction linePoint(lambda, phi) {\n  var p = cartesian([lambda * radians, phi * radians]);\n  if (p0) {\n    var normal = cartesianCross(p0, p),\n        equatorial = [normal[1], -normal[0], 0],\n        inflection = cartesianCross(equatorial, normal);\n    cartesianNormalizeInPlace(inflection);\n    inflection = spherical(inflection);\n    var delta = lambda - lambda2,\n        sign$$1 = delta > 0 ? 1 : -1,\n        lambdai = inflection[0] * degrees$1 * sign$$1,\n        phii,\n        antimeridian = abs(delta) > 180;\n    if (antimeridian ^ (sign$$1 * lambda2 < lambdai && lambdai < sign$$1 * lambda)) {\n      phii = inflection[1] * degrees$1;\n      if (phii > phi1) phi1 = phii;\n    } else if (lambdai = (lambdai + 360) % 360 - 180, antimeridian ^ (sign$$1 * lambda2 < lambdai && lambdai < sign$$1 * lambda)) {\n      phii = -inflection[1] * degrees$1;\n      if (phii < phi0) phi0 = phii;\n    } else {\n      if (phi < phi0) phi0 = phi;\n      if (phi > phi1) phi1 = phi;\n    }\n    if (antimeridian) {\n      if (lambda < lambda2) {\n        if (angle(lambda0$1, lambda) > angle(lambda0$1, lambda1)) lambda1 = lambda;\n      } else {\n        if (angle(lambda, lambda1) > angle(lambda0$1, lambda1)) lambda0$1 = lambda;\n      }\n    } else {\n      if (lambda1 >= lambda0$1) {\n        if (lambda < lambda0$1) lambda0$1 = lambda;\n        if (lambda > lambda1) lambda1 = lambda;\n      } else {\n        if (lambda > lambda2) {\n          if (angle(lambda0$1, lambda) > angle(lambda0$1, lambda1)) lambda1 = lambda;\n        } else {\n          if (angle(lambda, lambda1) > angle(lambda0$1, lambda1)) lambda0$1 = lambda;\n        }\n      }\n    }\n  } else {\n    ranges.push(range = [lambda0$1 = lambda, lambda1 = lambda]);\n  }\n  if (phi < phi0) phi0 = phi;\n  if (phi > phi1) phi1 = phi;\n  p0 = p, lambda2 = lambda;\n}\n\nfunction boundsLineStart() {\n  boundsStream.point = linePoint;\n}\n\nfunction boundsLineEnd() {\n  range[0] = lambda0$1, range[1] = lambda1;\n  boundsStream.point = boundsPoint;\n  p0 = null;\n}\n\nfunction boundsRingPoint(lambda, phi) {\n  if (p0) {\n    var delta = lambda - lambda2;\n    deltaSum.add(abs(delta) > 180 ? delta + (delta > 0 ? 360 : -360) : delta);\n  } else {\n    lambda00$1 = lambda, phi00$1 = phi;\n  }\n  areaStream.point(lambda, phi);\n  linePoint(lambda, phi);\n}\n\nfunction boundsRingStart() {\n  areaStream.lineStart();\n}\n\nfunction boundsRingEnd() {\n  boundsRingPoint(lambda00$1, phi00$1);\n  areaStream.lineEnd();\n  if (abs(deltaSum) > epsilon$2) lambda0$1 = -(lambda1 = 180);\n  range[0] = lambda0$1, range[1] = lambda1;\n  p0 = null;\n}\n\n// Finds the left-right distance between two longitudes.\n// This is almost the same as (lambda1 - lambda0 + 360°) % 360°, except that we want\n// the distance between ±180° to be 360°.\nfunction angle(lambda0, lambda1) {\n  return (lambda1 -= lambda0) < 0 ? lambda1 + 360 : lambda1;\n}\n\nfunction rangeCompare(a, b) {\n  return a[0] - b[0];\n}\n\nfunction rangeContains(range, x) {\n  return range[0] <= range[1] ? range[0] <= x && x <= range[1] : x < range[0] || range[1] < x;\n}\n\nvar bounds = function(feature) {\n  var i, n, a, b, merged, deltaMax, delta;\n\n  phi1 = lambda1 = -(lambda0$1 = phi0 = Infinity);\n  ranges = [];\n  geoStream(feature, boundsStream);\n\n  // First, sort ranges by their minimum longitudes.\n  if (n = ranges.length) {\n    ranges.sort(rangeCompare);\n\n    // Then, merge any ranges that overlap.\n    for (i = 1, a = ranges[0], merged = [a]; i < n; ++i) {\n      b = ranges[i];\n      if (rangeContains(a, b[0]) || rangeContains(a, b[1])) {\n        if (angle(a[0], b[1]) > angle(a[0], a[1])) a[1] = b[1];\n        if (angle(b[0], a[1]) > angle(a[0], a[1])) a[0] = b[0];\n      } else {\n        merged.push(a = b);\n      }\n    }\n\n    // Finally, find the largest gap between the merged ranges.\n    // The final bounding box will be the inverse of this gap.\n    for (deltaMax = -Infinity, n = merged.length - 1, i = 0, a = merged[n]; i <= n; a = b, ++i) {\n      b = merged[i];\n      if ((delta = angle(a[1], b[0])) > deltaMax) deltaMax = delta, lambda0$1 = b[0], lambda1 = a[1];\n    }\n  }\n\n  ranges = range = null;\n\n  return lambda0$1 === Infinity || phi0 === Infinity\n      ? [[NaN, NaN], [NaN, NaN]]\n      : [[lambda0$1, phi0], [lambda1, phi1]];\n};\n\nvar W0;\nvar W1;\nvar X0;\nvar Y0;\nvar Z0;\nvar X1;\nvar Y1;\nvar Z1;\nvar X2;\nvar Y2;\nvar Z2;\nvar lambda00$2;\nvar phi00$2;\nvar x0;\nvar y0;\nvar z0; // previous point\n\nvar centroidStream = {\n  sphere: noop$1,\n  point: centroidPoint,\n  lineStart: centroidLineStart,\n  lineEnd: centroidLineEnd,\n  polygonStart: function() {\n    centroidStream.lineStart = centroidRingStart;\n    centroidStream.lineEnd = centroidRingEnd;\n  },\n  polygonEnd: function() {\n    centroidStream.lineStart = centroidLineStart;\n    centroidStream.lineEnd = centroidLineEnd;\n  }\n};\n\n// Arithmetic mean of Cartesian vectors.\nfunction centroidPoint(lambda, phi) {\n  lambda *= radians, phi *= radians;\n  var cosPhi = cos$1(phi);\n  centroidPointCartesian(cosPhi * cos$1(lambda), cosPhi * sin$1(lambda), sin$1(phi));\n}\n\nfunction centroidPointCartesian(x, y, z) {\n  ++W0;\n  X0 += (x - X0) / W0;\n  Y0 += (y - Y0) / W0;\n  Z0 += (z - Z0) / W0;\n}\n\nfunction centroidLineStart() {\n  centroidStream.point = centroidLinePointFirst;\n}\n\nfunction centroidLinePointFirst(lambda, phi) {\n  lambda *= radians, phi *= radians;\n  var cosPhi = cos$1(phi);\n  x0 = cosPhi * cos$1(lambda);\n  y0 = cosPhi * sin$1(lambda);\n  z0 = sin$1(phi);\n  centroidStream.point = centroidLinePoint;\n  centroidPointCartesian(x0, y0, z0);\n}\n\nfunction centroidLinePoint(lambda, phi) {\n  lambda *= radians, phi *= radians;\n  var cosPhi = cos$1(phi),\n      x = cosPhi * cos$1(lambda),\n      y = cosPhi * sin$1(lambda),\n      z = sin$1(phi),\n      w = atan2(sqrt((w = y0 * z - z0 * y) * w + (w = z0 * x - x0 * z) * w + (w = x0 * y - y0 * x) * w), x0 * x + y0 * y + z0 * z);\n  W1 += w;\n  X1 += w * (x0 + (x0 = x));\n  Y1 += w * (y0 + (y0 = y));\n  Z1 += w * (z0 + (z0 = z));\n  centroidPointCartesian(x0, y0, z0);\n}\n\nfunction centroidLineEnd() {\n  centroidStream.point = centroidPoint;\n}\n\n// See J. E. Brock, The Inertia Tensor for a Spherical Triangle,\n// J. Applied Mechanics 42, 239 (1975).\nfunction centroidRingStart() {\n  centroidStream.point = centroidRingPointFirst;\n}\n\nfunction centroidRingEnd() {\n  centroidRingPoint(lambda00$2, phi00$2);\n  centroidStream.point = centroidPoint;\n}\n\nfunction centroidRingPointFirst(lambda, phi) {\n  lambda00$2 = lambda, phi00$2 = phi;\n  lambda *= radians, phi *= radians;\n  centroidStream.point = centroidRingPoint;\n  var cosPhi = cos$1(phi);\n  x0 = cosPhi * cos$1(lambda);\n  y0 = cosPhi * sin$1(lambda);\n  z0 = sin$1(phi);\n  centroidPointCartesian(x0, y0, z0);\n}\n\nfunction centroidRingPoint(lambda, phi) {\n  lambda *= radians, phi *= radians;\n  var cosPhi = cos$1(phi),\n      x = cosPhi * cos$1(lambda),\n      y = cosPhi * sin$1(lambda),\n      z = sin$1(phi),\n      cx = y0 * z - z0 * y,\n      cy = z0 * x - x0 * z,\n      cz = x0 * y - y0 * x,\n      m = sqrt(cx * cx + cy * cy + cz * cz),\n      u = x0 * x + y0 * y + z0 * z,\n      v = m && -asin(m) / m, // area weight\n      w = atan2(m, u); // line weight\n  X2 += v * cx;\n  Y2 += v * cy;\n  Z2 += v * cz;\n  W1 += w;\n  X1 += w * (x0 + (x0 = x));\n  Y1 += w * (y0 + (y0 = y));\n  Z1 += w * (z0 + (z0 = z));\n  centroidPointCartesian(x0, y0, z0);\n}\n\nvar centroid = function(object) {\n  W0 = W1 =\n  X0 = Y0 = Z0 =\n  X1 = Y1 = Z1 =\n  X2 = Y2 = Z2 = 0;\n  geoStream(object, centroidStream);\n\n  var x = X2,\n      y = Y2,\n      z = Z2,\n      m = x * x + y * y + z * z;\n\n  // If the area-weighted ccentroid is undefined, fall back to length-weighted ccentroid.\n  if (m < epsilon2$1) {\n    x = X1, y = Y1, z = Z1;\n    // If the feature has zero length, fall back to arithmetic mean of point vectors.\n    if (W1 < epsilon$2) x = X0, y = Y0, z = Z0;\n    m = x * x + y * y + z * z;\n    // If the feature still has an undefined ccentroid, then return.\n    if (m < epsilon2$1) return [NaN, NaN];\n  }\n\n  return [atan2(y, x) * degrees$1, asin(z / sqrt(m)) * degrees$1];\n};\n\nvar constant$7 = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nvar compose = function(a, b) {\n\n  function compose(x, y) {\n    return x = a(x, y), b(x[0], x[1]);\n  }\n\n  if (a.invert && b.invert) compose.invert = function(x, y) {\n    return x = b.invert(x, y), x && a.invert(x[0], x[1]);\n  };\n\n  return compose;\n};\n\nfunction rotationIdentity(lambda, phi) {\n  return [lambda > pi$3 ? lambda - tau$3 : lambda < -pi$3 ? lambda + tau$3 : lambda, phi];\n}\n\nrotationIdentity.invert = rotationIdentity;\n\nfunction rotateRadians(deltaLambda, deltaPhi, deltaGamma) {\n  return (deltaLambda %= tau$3) ? (deltaPhi || deltaGamma ? compose(rotationLambda(deltaLambda), rotationPhiGamma(deltaPhi, deltaGamma))\n    : rotationLambda(deltaLambda))\n    : (deltaPhi || deltaGamma ? rotationPhiGamma(deltaPhi, deltaGamma)\n    : rotationIdentity);\n}\n\nfunction forwardRotationLambda(deltaLambda) {\n  return function(lambda, phi) {\n    return lambda += deltaLambda, [lambda > pi$3 ? lambda - tau$3 : lambda < -pi$3 ? lambda + tau$3 : lambda, phi];\n  };\n}\n\nfunction rotationLambda(deltaLambda) {\n  var rotation = forwardRotationLambda(deltaLambda);\n  rotation.invert = forwardRotationLambda(-deltaLambda);\n  return rotation;\n}\n\nfunction rotationPhiGamma(deltaPhi, deltaGamma) {\n  var cosDeltaPhi = cos$1(deltaPhi),\n      sinDeltaPhi = sin$1(deltaPhi),\n      cosDeltaGamma = cos$1(deltaGamma),\n      sinDeltaGamma = sin$1(deltaGamma);\n\n  function rotation(lambda, phi) {\n    var cosPhi = cos$1(phi),\n        x = cos$1(lambda) * cosPhi,\n        y = sin$1(lambda) * cosPhi,\n        z = sin$1(phi),\n        k = z * cosDeltaPhi + x * sinDeltaPhi;\n    return [\n      atan2(y * cosDeltaGamma - k * sinDeltaGamma, x * cosDeltaPhi - z * sinDeltaPhi),\n      asin(k * cosDeltaGamma + y * sinDeltaGamma)\n    ];\n  }\n\n  rotation.invert = function(lambda, phi) {\n    var cosPhi = cos$1(phi),\n        x = cos$1(lambda) * cosPhi,\n        y = sin$1(lambda) * cosPhi,\n        z = sin$1(phi),\n        k = z * cosDeltaGamma - y * sinDeltaGamma;\n    return [\n      atan2(y * cosDeltaGamma + z * sinDeltaGamma, x * cosDeltaPhi + k * sinDeltaPhi),\n      asin(k * cosDeltaPhi - x * sinDeltaPhi)\n    ];\n  };\n\n  return rotation;\n}\n\nvar rotation = function(rotate) {\n  rotate = rotateRadians(rotate[0] * radians, rotate[1] * radians, rotate.length > 2 ? rotate[2] * radians : 0);\n\n  function forward(coordinates) {\n    coordinates = rotate(coordinates[0] * radians, coordinates[1] * radians);\n    return coordinates[0] *= degrees$1, coordinates[1] *= degrees$1, coordinates;\n  }\n\n  forward.invert = function(coordinates) {\n    coordinates = rotate.invert(coordinates[0] * radians, coordinates[1] * radians);\n    return coordinates[0] *= degrees$1, coordinates[1] *= degrees$1, coordinates;\n  };\n\n  return forward;\n};\n\n// Generates a circle centered at [0°, 0°], with a given radius and precision.\nfunction circleStream(stream, radius, delta, direction, t0, t1) {\n  if (!delta) return;\n  var cosRadius = cos$1(radius),\n      sinRadius = sin$1(radius),\n      step = direction * delta;\n  if (t0 == null) {\n    t0 = radius + direction * tau$3;\n    t1 = radius - step / 2;\n  } else {\n    t0 = circleRadius(cosRadius, t0);\n    t1 = circleRadius(cosRadius, t1);\n    if (direction > 0 ? t0 < t1 : t0 > t1) t0 += direction * tau$3;\n  }\n  for (var point, t = t0; direction > 0 ? t > t1 : t < t1; t -= step) {\n    point = spherical([cosRadius, -sinRadius * cos$1(t), -sinRadius * sin$1(t)]);\n    stream.point(point[0], point[1]);\n  }\n}\n\n// Returns the signed angle of a cartesian point relative to [cosRadius, 0, 0].\nfunction circleRadius(cosRadius, point) {\n  point = cartesian(point), point[0] -= cosRadius;\n  cartesianNormalizeInPlace(point);\n  var radius = acos(-point[1]);\n  return ((-point[2] < 0 ? -radius : radius) + tau$3 - epsilon$2) % tau$3;\n}\n\nvar circle = function() {\n  var center = constant$7([0, 0]),\n      radius = constant$7(90),\n      precision = constant$7(6),\n      ring,\n      rotate,\n      stream = {point: point};\n\n  function point(x, y) {\n    ring.push(x = rotate(x, y));\n    x[0] *= degrees$1, x[1] *= degrees$1;\n  }\n\n  function circle() {\n    var c = center.apply(this, arguments),\n        r = radius.apply(this, arguments) * radians,\n        p = precision.apply(this, arguments) * radians;\n    ring = [];\n    rotate = rotateRadians(-c[0] * radians, -c[1] * radians, 0).invert;\n    circleStream(stream, r, p, 1);\n    c = {type: \"Polygon\", coordinates: [ring]};\n    ring = rotate = null;\n    return c;\n  }\n\n  circle.center = function(_) {\n    return arguments.length ? (center = typeof _ === \"function\" ? _ : constant$7([+_[0], +_[1]]), circle) : center;\n  };\n\n  circle.radius = function(_) {\n    return arguments.length ? (radius = typeof _ === \"function\" ? _ : constant$7(+_), circle) : radius;\n  };\n\n  circle.precision = function(_) {\n    return arguments.length ? (precision = typeof _ === \"function\" ? _ : constant$7(+_), circle) : precision;\n  };\n\n  return circle;\n};\n\nvar clipBuffer = function() {\n  var lines = [],\n      line;\n  return {\n    point: function(x, y) {\n      line.push([x, y]);\n    },\n    lineStart: function() {\n      lines.push(line = []);\n    },\n    lineEnd: noop$1,\n    rejoin: function() {\n      if (lines.length > 1) lines.push(lines.pop().concat(lines.shift()));\n    },\n    result: function() {\n      var result = lines;\n      lines = [];\n      line = null;\n      return result;\n    }\n  };\n};\n\nvar clipLine = function(a, b, x0, y0, x1, y1) {\n  var ax = a[0],\n      ay = a[1],\n      bx = b[0],\n      by = b[1],\n      t0 = 0,\n      t1 = 1,\n      dx = bx - ax,\n      dy = by - ay,\n      r;\n\n  r = x0 - ax;\n  if (!dx && r > 0) return;\n  r /= dx;\n  if (dx < 0) {\n    if (r < t0) return;\n    if (r < t1) t1 = r;\n  } else if (dx > 0) {\n    if (r > t1) return;\n    if (r > t0) t0 = r;\n  }\n\n  r = x1 - ax;\n  if (!dx && r < 0) return;\n  r /= dx;\n  if (dx < 0) {\n    if (r > t1) return;\n    if (r > t0) t0 = r;\n  } else if (dx > 0) {\n    if (r < t0) return;\n    if (r < t1) t1 = r;\n  }\n\n  r = y0 - ay;\n  if (!dy && r > 0) return;\n  r /= dy;\n  if (dy < 0) {\n    if (r < t0) return;\n    if (r < t1) t1 = r;\n  } else if (dy > 0) {\n    if (r > t1) return;\n    if (r > t0) t0 = r;\n  }\n\n  r = y1 - ay;\n  if (!dy && r < 0) return;\n  r /= dy;\n  if (dy < 0) {\n    if (r > t1) return;\n    if (r > t0) t0 = r;\n  } else if (dy > 0) {\n    if (r < t0) return;\n    if (r < t1) t1 = r;\n  }\n\n  if (t0 > 0) a[0] = ax + t0 * dx, a[1] = ay + t0 * dy;\n  if (t1 < 1) b[0] = ax + t1 * dx, b[1] = ay + t1 * dy;\n  return true;\n};\n\nvar pointEqual = function(a, b) {\n  return abs(a[0] - b[0]) < epsilon$2 && abs(a[1] - b[1]) < epsilon$2;\n};\n\nfunction Intersection(point, points, other, entry) {\n  this.x = point;\n  this.z = points;\n  this.o = other; // another intersection\n  this.e = entry; // is an entry?\n  this.v = false; // visited\n  this.n = this.p = null; // next & previous\n}\n\n// A generalized polygon clipping algorithm: given a polygon that has been cut\n// into its visible line segments, and rejoins the segments by interpolating\n// along the clip edge.\nvar clipPolygon = function(segments, compareIntersection, startInside, interpolate, stream) {\n  var subject = [],\n      clip = [],\n      i,\n      n;\n\n  segments.forEach(function(segment) {\n    if ((n = segment.length - 1) <= 0) return;\n    var n, p0 = segment[0], p1 = segment[n], x;\n\n    // If the first and last points of a segment are coincident, then treat as a\n    // closed ring. TODO if all rings are closed, then the winding order of the\n    // exterior ring should be checked.\n    if (pointEqual(p0, p1)) {\n      stream.lineStart();\n      for (i = 0; i < n; ++i) stream.point((p0 = segment[i])[0], p0[1]);\n      stream.lineEnd();\n      return;\n    }\n\n    subject.push(x = new Intersection(p0, segment, null, true));\n    clip.push(x.o = new Intersection(p0, null, x, false));\n    subject.push(x = new Intersection(p1, segment, null, false));\n    clip.push(x.o = new Intersection(p1, null, x, true));\n  });\n\n  if (!subject.length) return;\n\n  clip.sort(compareIntersection);\n  link$1(subject);\n  link$1(clip);\n\n  for (i = 0, n = clip.length; i < n; ++i) {\n    clip[i].e = startInside = !startInside;\n  }\n\n  var start = subject[0],\n      points,\n      point;\n\n  while (1) {\n    // Find first unvisited intersection.\n    var current = start,\n        isSubject = true;\n    while (current.v) if ((current = current.n) === start) return;\n    points = current.z;\n    stream.lineStart();\n    do {\n      current.v = current.o.v = true;\n      if (current.e) {\n        if (isSubject) {\n          for (i = 0, n = points.length; i < n; ++i) stream.point((point = points[i])[0], point[1]);\n        } else {\n          interpolate(current.x, current.n.x, 1, stream);\n        }\n        current = current.n;\n      } else {\n        if (isSubject) {\n          points = current.p.z;\n          for (i = points.length - 1; i >= 0; --i) stream.point((point = points[i])[0], point[1]);\n        } else {\n          interpolate(current.x, current.p.x, -1, stream);\n        }\n        current = current.p;\n      }\n      current = current.o;\n      points = current.z;\n      isSubject = !isSubject;\n    } while (!current.v);\n    stream.lineEnd();\n  }\n};\n\nfunction link$1(array) {\n  if (!(n = array.length)) return;\n  var n,\n      i = 0,\n      a = array[0],\n      b;\n  while (++i < n) {\n    a.n = b = array[i];\n    b.p = a;\n    a = b;\n  }\n  a.n = b = array[0];\n  b.p = a;\n}\n\nvar clipMax = 1e9;\nvar clipMin = -clipMax;\n\n// TODO Use d3-polygon’s polygonContains here for the ring check?\n// TODO Eliminate duplicate buffering in clipBuffer and polygon.push?\n\nfunction clipExtent(x0, y0, x1, y1) {\n\n  function visible(x, y) {\n    return x0 <= x && x <= x1 && y0 <= y && y <= y1;\n  }\n\n  function interpolate(from, to, direction, stream) {\n    var a = 0, a1 = 0;\n    if (from == null\n        || (a = corner(from, direction)) !== (a1 = corner(to, direction))\n        || comparePoint(from, to) < 0 ^ direction > 0) {\n      do stream.point(a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0);\n      while ((a = (a + direction + 4) % 4) !== a1);\n    } else {\n      stream.point(to[0], to[1]);\n    }\n  }\n\n  function corner(p, direction) {\n    return abs(p[0] - x0) < epsilon$2 ? direction > 0 ? 0 : 3\n        : abs(p[0] - x1) < epsilon$2 ? direction > 0 ? 2 : 1\n        : abs(p[1] - y0) < epsilon$2 ? direction > 0 ? 1 : 0\n        : direction > 0 ? 3 : 2; // abs(p[1] - y1) < epsilon\n  }\n\n  function compareIntersection(a, b) {\n    return comparePoint(a.x, b.x);\n  }\n\n  function comparePoint(a, b) {\n    var ca = corner(a, 1),\n        cb = corner(b, 1);\n    return ca !== cb ? ca - cb\n        : ca === 0 ? b[1] - a[1]\n        : ca === 1 ? a[0] - b[0]\n        : ca === 2 ? a[1] - b[1]\n        : b[0] - a[0];\n  }\n\n  return function(stream) {\n    var activeStream = stream,\n        bufferStream = clipBuffer(),\n        segments,\n        polygon,\n        ring,\n        x__, y__, v__, // first point\n        x_, y_, v_, // previous point\n        first,\n        clean;\n\n    var clipStream = {\n      point: point,\n      lineStart: lineStart,\n      lineEnd: lineEnd,\n      polygonStart: polygonStart,\n      polygonEnd: polygonEnd\n    };\n\n    function point(x, y) {\n      if (visible(x, y)) activeStream.point(x, y);\n    }\n\n    function polygonInside() {\n      var winding = 0;\n\n      for (var i = 0, n = polygon.length; i < n; ++i) {\n        for (var ring = polygon[i], j = 1, m = ring.length, point = ring[0], a0, a1, b0 = point[0], b1 = point[1]; j < m; ++j) {\n          a0 = b0, a1 = b1, point = ring[j], b0 = point[0], b1 = point[1];\n          if (a1 <= y1) { if (b1 > y1 && (b0 - a0) * (y1 - a1) > (b1 - a1) * (x0 - a0)) ++winding; }\n          else { if (b1 <= y1 && (b0 - a0) * (y1 - a1) < (b1 - a1) * (x0 - a0)) --winding; }\n        }\n      }\n\n      return winding;\n    }\n\n    // Buffer geometry within a polygon and then clip it en masse.\n    function polygonStart() {\n      activeStream = bufferStream, segments = [], polygon = [], clean = true;\n    }\n\n    function polygonEnd() {\n      var startInside = polygonInside(),\n          cleanInside = clean && startInside,\n          visible = (segments = merge(segments)).length;\n      if (cleanInside || visible) {\n        stream.polygonStart();\n        if (cleanInside) {\n          stream.lineStart();\n          interpolate(null, null, 1, stream);\n          stream.lineEnd();\n        }\n        if (visible) {\n          clipPolygon(segments, compareIntersection, startInside, interpolate, stream);\n        }\n        stream.polygonEnd();\n      }\n      activeStream = stream, segments = polygon = ring = null;\n    }\n\n    function lineStart() {\n      clipStream.point = linePoint;\n      if (polygon) polygon.push(ring = []);\n      first = true;\n      v_ = false;\n      x_ = y_ = NaN;\n    }\n\n    // TODO rather than special-case polygons, simply handle them separately.\n    // Ideally, coincident intersection points should be jittered to avoid\n    // clipping issues.\n    function lineEnd() {\n      if (segments) {\n        linePoint(x__, y__);\n        if (v__ && v_) bufferStream.rejoin();\n        segments.push(bufferStream.result());\n      }\n      clipStream.point = point;\n      if (v_) activeStream.lineEnd();\n    }\n\n    function linePoint(x, y) {\n      var v = visible(x, y);\n      if (polygon) ring.push([x, y]);\n      if (first) {\n        x__ = x, y__ = y, v__ = v;\n        first = false;\n        if (v) {\n          activeStream.lineStart();\n          activeStream.point(x, y);\n        }\n      } else {\n        if (v && v_) activeStream.point(x, y);\n        else {\n          var a = [x_ = Math.max(clipMin, Math.min(clipMax, x_)), y_ = Math.max(clipMin, Math.min(clipMax, y_))],\n              b = [x = Math.max(clipMin, Math.min(clipMax, x)), y = Math.max(clipMin, Math.min(clipMax, y))];\n          if (clipLine(a, b, x0, y0, x1, y1)) {\n            if (!v_) {\n              activeStream.lineStart();\n              activeStream.point(a[0], a[1]);\n            }\n            activeStream.point(b[0], b[1]);\n            if (!v) activeStream.lineEnd();\n            clean = false;\n          } else if (v) {\n            activeStream.lineStart();\n            activeStream.point(x, y);\n            clean = false;\n          }\n        }\n      }\n      x_ = x, y_ = y, v_ = v;\n    }\n\n    return clipStream;\n  };\n}\n\nvar extent$1 = function() {\n  var x0 = 0,\n      y0 = 0,\n      x1 = 960,\n      y1 = 500,\n      cache,\n      cacheStream,\n      clip;\n\n  return clip = {\n    stream: function(stream) {\n      return cache && cacheStream === stream ? cache : cache = clipExtent(x0, y0, x1, y1)(cacheStream = stream);\n    },\n    extent: function(_) {\n      return arguments.length ? (x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1], cache = cacheStream = null, clip) : [[x0, y0], [x1, y1]];\n    }\n  };\n};\n\nvar lengthSum = adder();\nvar lambda0$2;\nvar sinPhi0$1;\nvar cosPhi0$1;\n\nvar lengthStream = {\n  sphere: noop$1,\n  point: noop$1,\n  lineStart: lengthLineStart,\n  lineEnd: noop$1,\n  polygonStart: noop$1,\n  polygonEnd: noop$1\n};\n\nfunction lengthLineStart() {\n  lengthStream.point = lengthPointFirst;\n  lengthStream.lineEnd = lengthLineEnd;\n}\n\nfunction lengthLineEnd() {\n  lengthStream.point = lengthStream.lineEnd = noop$1;\n}\n\nfunction lengthPointFirst(lambda, phi) {\n  lambda *= radians, phi *= radians;\n  lambda0$2 = lambda, sinPhi0$1 = sin$1(phi), cosPhi0$1 = cos$1(phi);\n  lengthStream.point = lengthPoint;\n}\n\nfunction lengthPoint(lambda, phi) {\n  lambda *= radians, phi *= radians;\n  var sinPhi = sin$1(phi),\n      cosPhi = cos$1(phi),\n      delta = abs(lambda - lambda0$2),\n      cosDelta = cos$1(delta),\n      sinDelta = sin$1(delta),\n      x = cosPhi * sinDelta,\n      y = cosPhi0$1 * sinPhi - sinPhi0$1 * cosPhi * cosDelta,\n      z = sinPhi0$1 * sinPhi + cosPhi0$1 * cosPhi * cosDelta;\n  lengthSum.add(atan2(sqrt(x * x + y * y), z));\n  lambda0$2 = lambda, sinPhi0$1 = sinPhi, cosPhi0$1 = cosPhi;\n}\n\nvar length$1 = function(object) {\n  lengthSum.reset();\n  geoStream(object, lengthStream);\n  return +lengthSum;\n};\n\nvar coordinates = [null, null];\nvar object$1 = {type: \"LineString\", coordinates: coordinates};\n\nvar distance = function(a, b) {\n  coordinates[0] = a;\n  coordinates[1] = b;\n  return length$1(object$1);\n};\n\nfunction graticuleX(y0, y1, dy) {\n  var y = sequence(y0, y1 - epsilon$2, dy).concat(y1);\n  return function(x) { return y.map(function(y) { return [x, y]; }); };\n}\n\nfunction graticuleY(x0, x1, dx) {\n  var x = sequence(x0, x1 - epsilon$2, dx).concat(x1);\n  return function(y) { return x.map(function(x) { return [x, y]; }); };\n}\n\nfunction graticule() {\n  var x1, x0, X1, X0,\n      y1, y0, Y1, Y0,\n      dx = 10, dy = dx, DX = 90, DY = 360,\n      x, y, X, Y,\n      precision = 2.5;\n\n  function graticule() {\n    return {type: \"MultiLineString\", coordinates: lines()};\n  }\n\n  function lines() {\n    return sequence(ceil(X0 / DX) * DX, X1, DX).map(X)\n        .concat(sequence(ceil(Y0 / DY) * DY, Y1, DY).map(Y))\n        .concat(sequence(ceil(x0 / dx) * dx, x1, dx).filter(function(x) { return abs(x % DX) > epsilon$2; }).map(x))\n        .concat(sequence(ceil(y0 / dy) * dy, y1, dy).filter(function(y) { return abs(y % DY) > epsilon$2; }).map(y));\n  }\n\n  graticule.lines = function() {\n    return lines().map(function(coordinates) { return {type: \"LineString\", coordinates: coordinates}; });\n  };\n\n  graticule.outline = function() {\n    return {\n      type: \"Polygon\",\n      coordinates: [\n        X(X0).concat(\n        Y(Y1).slice(1),\n        X(X1).reverse().slice(1),\n        Y(Y0).reverse().slice(1))\n      ]\n    };\n  };\n\n  graticule.extent = function(_) {\n    if (!arguments.length) return graticule.extentMinor();\n    return graticule.extentMajor(_).extentMinor(_);\n  };\n\n  graticule.extentMajor = function(_) {\n    if (!arguments.length) return [[X0, Y0], [X1, Y1]];\n    X0 = +_[0][0], X1 = +_[1][0];\n    Y0 = +_[0][1], Y1 = +_[1][1];\n    if (X0 > X1) _ = X0, X0 = X1, X1 = _;\n    if (Y0 > Y1) _ = Y0, Y0 = Y1, Y1 = _;\n    return graticule.precision(precision);\n  };\n\n  graticule.extentMinor = function(_) {\n    if (!arguments.length) return [[x0, y0], [x1, y1]];\n    x0 = +_[0][0], x1 = +_[1][0];\n    y0 = +_[0][1], y1 = +_[1][1];\n    if (x0 > x1) _ = x0, x0 = x1, x1 = _;\n    if (y0 > y1) _ = y0, y0 = y1, y1 = _;\n    return graticule.precision(precision);\n  };\n\n  graticule.step = function(_) {\n    if (!arguments.length) return graticule.stepMinor();\n    return graticule.stepMajor(_).stepMinor(_);\n  };\n\n  graticule.stepMajor = function(_) {\n    if (!arguments.length) return [DX, DY];\n    DX = +_[0], DY = +_[1];\n    return graticule;\n  };\n\n  graticule.stepMinor = function(_) {\n    if (!arguments.length) return [dx, dy];\n    dx = +_[0], dy = +_[1];\n    return graticule;\n  };\n\n  graticule.precision = function(_) {\n    if (!arguments.length) return precision;\n    precision = +_;\n    x = graticuleX(y0, y1, 90);\n    y = graticuleY(x0, x1, precision);\n    X = graticuleX(Y0, Y1, 90);\n    Y = graticuleY(X0, X1, precision);\n    return graticule;\n  };\n\n  return graticule\n      .extentMajor([[-180, -90 + epsilon$2], [180, 90 - epsilon$2]])\n      .extentMinor([[-180, -80 - epsilon$2], [180, 80 + epsilon$2]]);\n}\n\nfunction graticule10() {\n  return graticule()();\n}\n\nvar interpolate$1 = function(a, b) {\n  var x0 = a[0] * radians,\n      y0 = a[1] * radians,\n      x1 = b[0] * radians,\n      y1 = b[1] * radians,\n      cy0 = cos$1(y0),\n      sy0 = sin$1(y0),\n      cy1 = cos$1(y1),\n      sy1 = sin$1(y1),\n      kx0 = cy0 * cos$1(x0),\n      ky0 = cy0 * sin$1(x0),\n      kx1 = cy1 * cos$1(x1),\n      ky1 = cy1 * sin$1(x1),\n      d = 2 * asin(sqrt(haversin(y1 - y0) + cy0 * cy1 * haversin(x1 - x0))),\n      k = sin$1(d);\n\n  var interpolate = d ? function(t) {\n    var B = sin$1(t *= d) / k,\n        A = sin$1(d - t) / k,\n        x = A * kx0 + B * kx1,\n        y = A * ky0 + B * ky1,\n        z = A * sy0 + B * sy1;\n    return [\n      atan2(y, x) * degrees$1,\n      atan2(z, sqrt(x * x + y * y)) * degrees$1\n    ];\n  } : function() {\n    return [x0 * degrees$1, y0 * degrees$1];\n  };\n\n  interpolate.distance = d;\n\n  return interpolate;\n};\n\nvar identity$4 = function(x) {\n  return x;\n};\n\nvar areaSum$1 = adder();\nvar areaRingSum$1 = adder();\nvar x00;\nvar y00;\nvar x0$1;\nvar y0$1;\n\nvar areaStream$1 = {\n  point: noop$1,\n  lineStart: noop$1,\n  lineEnd: noop$1,\n  polygonStart: function() {\n    areaStream$1.lineStart = areaRingStart$1;\n    areaStream$1.lineEnd = areaRingEnd$1;\n  },\n  polygonEnd: function() {\n    areaStream$1.lineStart = areaStream$1.lineEnd = areaStream$1.point = noop$1;\n    areaSum$1.add(abs(areaRingSum$1));\n    areaRingSum$1.reset();\n  },\n  result: function() {\n    var area = areaSum$1 / 2;\n    areaSum$1.reset();\n    return area;\n  }\n};\n\nfunction areaRingStart$1() {\n  areaStream$1.point = areaPointFirst$1;\n}\n\nfunction areaPointFirst$1(x, y) {\n  areaStream$1.point = areaPoint$1;\n  x00 = x0$1 = x, y00 = y0$1 = y;\n}\n\nfunction areaPoint$1(x, y) {\n  areaRingSum$1.add(y0$1 * x - x0$1 * y);\n  x0$1 = x, y0$1 = y;\n}\n\nfunction areaRingEnd$1() {\n  areaPoint$1(x00, y00);\n}\n\nvar x0$2 = Infinity;\nvar y0$2 = x0$2;\nvar x1 = -x0$2;\nvar y1 = x1;\n\nvar boundsStream$1 = {\n  point: boundsPoint$1,\n  lineStart: noop$1,\n  lineEnd: noop$1,\n  polygonStart: noop$1,\n  polygonEnd: noop$1,\n  result: function() {\n    var bounds = [[x0$2, y0$2], [x1, y1]];\n    x1 = y1 = -(y0$2 = x0$2 = Infinity);\n    return bounds;\n  }\n};\n\nfunction boundsPoint$1(x, y) {\n  if (x < x0$2) x0$2 = x;\n  if (x > x1) x1 = x;\n  if (y < y0$2) y0$2 = y;\n  if (y > y1) y1 = y;\n}\n\n// TODO Enforce positive area for exterior, negative area for interior?\n\nvar X0$1 = 0;\nvar Y0$1 = 0;\nvar Z0$1 = 0;\nvar X1$1 = 0;\nvar Y1$1 = 0;\nvar Z1$1 = 0;\nvar X2$1 = 0;\nvar Y2$1 = 0;\nvar Z2$1 = 0;\nvar x00$1;\nvar y00$1;\nvar x0$3;\nvar y0$3;\n\nvar centroidStream$1 = {\n  point: centroidPoint$1,\n  lineStart: centroidLineStart$1,\n  lineEnd: centroidLineEnd$1,\n  polygonStart: function() {\n    centroidStream$1.lineStart = centroidRingStart$1;\n    centroidStream$1.lineEnd = centroidRingEnd$1;\n  },\n  polygonEnd: function() {\n    centroidStream$1.point = centroidPoint$1;\n    centroidStream$1.lineStart = centroidLineStart$1;\n    centroidStream$1.lineEnd = centroidLineEnd$1;\n  },\n  result: function() {\n    var centroid = Z2$1 ? [X2$1 / Z2$1, Y2$1 / Z2$1]\n        : Z1$1 ? [X1$1 / Z1$1, Y1$1 / Z1$1]\n        : Z0$1 ? [X0$1 / Z0$1, Y0$1 / Z0$1]\n        : [NaN, NaN];\n    X0$1 = Y0$1 = Z0$1 =\n    X1$1 = Y1$1 = Z1$1 =\n    X2$1 = Y2$1 = Z2$1 = 0;\n    return centroid;\n  }\n};\n\nfunction centroidPoint$1(x, y) {\n  X0$1 += x;\n  Y0$1 += y;\n  ++Z0$1;\n}\n\nfunction centroidLineStart$1() {\n  centroidStream$1.point = centroidPointFirstLine;\n}\n\nfunction centroidPointFirstLine(x, y) {\n  centroidStream$1.point = centroidPointLine;\n  centroidPoint$1(x0$3 = x, y0$3 = y);\n}\n\nfunction centroidPointLine(x, y) {\n  var dx = x - x0$3, dy = y - y0$3, z = sqrt(dx * dx + dy * dy);\n  X1$1 += z * (x0$3 + x) / 2;\n  Y1$1 += z * (y0$3 + y) / 2;\n  Z1$1 += z;\n  centroidPoint$1(x0$3 = x, y0$3 = y);\n}\n\nfunction centroidLineEnd$1() {\n  centroidStream$1.point = centroidPoint$1;\n}\n\nfunction centroidRingStart$1() {\n  centroidStream$1.point = centroidPointFirstRing;\n}\n\nfunction centroidRingEnd$1() {\n  centroidPointRing(x00$1, y00$1);\n}\n\nfunction centroidPointFirstRing(x, y) {\n  centroidStream$1.point = centroidPointRing;\n  centroidPoint$1(x00$1 = x0$3 = x, y00$1 = y0$3 = y);\n}\n\nfunction centroidPointRing(x, y) {\n  var dx = x - x0$3,\n      dy = y - y0$3,\n      z = sqrt(dx * dx + dy * dy);\n\n  X1$1 += z * (x0$3 + x) / 2;\n  Y1$1 += z * (y0$3 + y) / 2;\n  Z1$1 += z;\n\n  z = y0$3 * x - x0$3 * y;\n  X2$1 += z * (x0$3 + x);\n  Y2$1 += z * (y0$3 + y);\n  Z2$1 += z * 3;\n  centroidPoint$1(x0$3 = x, y0$3 = y);\n}\n\nfunction PathContext(context) {\n  this._context = context;\n}\n\nPathContext.prototype = {\n  _radius: 4.5,\n  pointRadius: function(_) {\n    return this._radius = _, this;\n  },\n  polygonStart: function() {\n    this._line = 0;\n  },\n  polygonEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._point = 0;\n  },\n  lineEnd: function() {\n    if (this._line === 0) this._context.closePath();\n    this._point = NaN;\n  },\n  point: function(x, y) {\n    switch (this._point) {\n      case 0: {\n        this._context.moveTo(x, y);\n        this._point = 1;\n        break;\n      }\n      case 1: {\n        this._context.lineTo(x, y);\n        break;\n      }\n      default: {\n        this._context.moveTo(x + this._radius, y);\n        this._context.arc(x, y, this._radius, 0, tau$3);\n        break;\n      }\n    }\n  },\n  result: noop$1\n};\n\nvar lengthSum$1 = adder();\nvar lengthRing;\nvar x00$2;\nvar y00$2;\nvar x0$4;\nvar y0$4;\n\nvar lengthStream$1 = {\n  point: noop$1,\n  lineStart: function() {\n    lengthStream$1.point = lengthPointFirst$1;\n  },\n  lineEnd: function() {\n    if (lengthRing) lengthPoint$1(x00$2, y00$2);\n    lengthStream$1.point = noop$1;\n  },\n  polygonStart: function() {\n    lengthRing = true;\n  },\n  polygonEnd: function() {\n    lengthRing = null;\n  },\n  result: function() {\n    var length = +lengthSum$1;\n    lengthSum$1.reset();\n    return length;\n  }\n};\n\nfunction lengthPointFirst$1(x, y) {\n  lengthStream$1.point = lengthPoint$1;\n  x00$2 = x0$4 = x, y00$2 = y0$4 = y;\n}\n\nfunction lengthPoint$1(x, y) {\n  x0$4 -= x, y0$4 -= y;\n  lengthSum$1.add(sqrt(x0$4 * x0$4 + y0$4 * y0$4));\n  x0$4 = x, y0$4 = y;\n}\n\nfunction PathString() {\n  this._string = [];\n}\n\nPathString.prototype = {\n  _circle: circle$1(4.5),\n  pointRadius: function(_) {\n    return this._circle = circle$1(_), this;\n  },\n  polygonStart: function() {\n    this._line = 0;\n  },\n  polygonEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._point = 0;\n  },\n  lineEnd: function() {\n    if (this._line === 0) this._string.push(\"Z\");\n    this._point = NaN;\n  },\n  point: function(x, y) {\n    switch (this._point) {\n      case 0: {\n        this._string.push(\"M\", x, \",\", y);\n        this._point = 1;\n        break;\n      }\n      case 1: {\n        this._string.push(\"L\", x, \",\", y);\n        break;\n      }\n      default: {\n        this._string.push(\"M\", x, \",\", y, this._circle);\n        break;\n      }\n    }\n  },\n  result: function() {\n    if (this._string.length) {\n      var result = this._string.join(\"\");\n      this._string = [];\n      return result;\n    }\n  }\n};\n\nfunction circle$1(radius) {\n  return \"m0,\" + radius\n      + \"a\" + radius + \",\" + radius + \" 0 1,1 0,\" + -2 * radius\n      + \"a\" + radius + \",\" + radius + \" 0 1,1 0,\" + 2 * radius\n      + \"z\";\n}\n\nvar index$1 = function(projection, context) {\n  var pointRadius = 4.5,\n      projectionStream,\n      contextStream;\n\n  function path(object) {\n    if (object) {\n      if (typeof pointRadius === \"function\") contextStream.pointRadius(+pointRadius.apply(this, arguments));\n      geoStream(object, projectionStream(contextStream));\n    }\n    return contextStream.result();\n  }\n\n  path.area = function(object) {\n    geoStream(object, projectionStream(areaStream$1));\n    return areaStream$1.result();\n  };\n\n  path.measure = function(object) {\n    geoStream(object, projectionStream(lengthStream$1));\n    return lengthStream$1.result();\n  };\n\n  path.bounds = function(object) {\n    geoStream(object, projectionStream(boundsStream$1));\n    return boundsStream$1.result();\n  };\n\n  path.centroid = function(object) {\n    geoStream(object, projectionStream(centroidStream$1));\n    return centroidStream$1.result();\n  };\n\n  path.projection = function(_) {\n    return arguments.length ? (projectionStream = _ == null ? (projection = null, identity$4) : (projection = _).stream, path) : projection;\n  };\n\n  path.context = function(_) {\n    if (!arguments.length) return context;\n    contextStream = _ == null ? (context = null, new PathString) : new PathContext(context = _);\n    if (typeof pointRadius !== \"function\") contextStream.pointRadius(pointRadius);\n    return path;\n  };\n\n  path.pointRadius = function(_) {\n    if (!arguments.length) return pointRadius;\n    pointRadius = typeof _ === \"function\" ? _ : (contextStream.pointRadius(+_), +_);\n    return path;\n  };\n\n  return path.projection(projection).context(context);\n};\n\nvar sum$1 = adder();\n\nvar polygonContains = function(polygon, point) {\n  var lambda = point[0],\n      phi = point[1],\n      normal = [sin$1(lambda), -cos$1(lambda), 0],\n      angle = 0,\n      winding = 0;\n\n  sum$1.reset();\n\n  for (var i = 0, n = polygon.length; i < n; ++i) {\n    if (!(m = (ring = polygon[i]).length)) continue;\n    var ring,\n        m,\n        point0 = ring[m - 1],\n        lambda0 = point0[0],\n        phi0 = point0[1] / 2 + quarterPi,\n        sinPhi0 = sin$1(phi0),\n        cosPhi0 = cos$1(phi0);\n\n    for (var j = 0; j < m; ++j, lambda0 = lambda1, sinPhi0 = sinPhi1, cosPhi0 = cosPhi1, point0 = point1) {\n      var point1 = ring[j],\n          lambda1 = point1[0],\n          phi1 = point1[1] / 2 + quarterPi,\n          sinPhi1 = sin$1(phi1),\n          cosPhi1 = cos$1(phi1),\n          delta = lambda1 - lambda0,\n          sign$$1 = delta >= 0 ? 1 : -1,\n          absDelta = sign$$1 * delta,\n          antimeridian = absDelta > pi$3,\n          k = sinPhi0 * sinPhi1;\n\n      sum$1.add(atan2(k * sign$$1 * sin$1(absDelta), cosPhi0 * cosPhi1 + k * cos$1(absDelta)));\n      angle += antimeridian ? delta + sign$$1 * tau$3 : delta;\n\n      // Are the longitudes either side of the point’s meridian (lambda),\n      // and are the latitudes smaller than the parallel (phi)?\n      if (antimeridian ^ lambda0 >= lambda ^ lambda1 >= lambda) {\n        var arc = cartesianCross(cartesian(point0), cartesian(point1));\n        cartesianNormalizeInPlace(arc);\n        var intersection = cartesianCross(normal, arc);\n        cartesianNormalizeInPlace(intersection);\n        var phiArc = (antimeridian ^ delta >= 0 ? -1 : 1) * asin(intersection[2]);\n        if (phi > phiArc || phi === phiArc && (arc[0] || arc[1])) {\n          winding += antimeridian ^ delta >= 0 ? 1 : -1;\n        }\n      }\n    }\n  }\n\n  // First, determine whether the South pole is inside or outside:\n  //\n  // It is inside if:\n  // * the polygon winds around it in a clockwise direction.\n  // * the polygon does not (cumulatively) wind around it, but has a negative\n  //   (counter-clockwise) area.\n  //\n  // Second, count the (signed) number of times a segment crosses a lambda\n  // from the point to the South pole.  If it is zero, then the point is the\n  // same side as the South pole.\n\n  return (angle < -epsilon$2 || angle < epsilon$2 && sum$1 < -epsilon$2) ^ (winding & 1);\n};\n\nvar clip = function(pointVisible, clipLine, interpolate, start) {\n  return function(rotate, sink) {\n    var line = clipLine(sink),\n        rotatedStart = rotate.invert(start[0], start[1]),\n        ringBuffer = clipBuffer(),\n        ringSink = clipLine(ringBuffer),\n        polygonStarted = false,\n        polygon,\n        segments,\n        ring;\n\n    var clip = {\n      point: point,\n      lineStart: lineStart,\n      lineEnd: lineEnd,\n      polygonStart: function() {\n        clip.point = pointRing;\n        clip.lineStart = ringStart;\n        clip.lineEnd = ringEnd;\n        segments = [];\n        polygon = [];\n      },\n      polygonEnd: function() {\n        clip.point = point;\n        clip.lineStart = lineStart;\n        clip.lineEnd = lineEnd;\n        segments = merge(segments);\n        var startInside = polygonContains(polygon, rotatedStart);\n        if (segments.length) {\n          if (!polygonStarted) sink.polygonStart(), polygonStarted = true;\n          clipPolygon(segments, compareIntersection, startInside, interpolate, sink);\n        } else if (startInside) {\n          if (!polygonStarted) sink.polygonStart(), polygonStarted = true;\n          sink.lineStart();\n          interpolate(null, null, 1, sink);\n          sink.lineEnd();\n        }\n        if (polygonStarted) sink.polygonEnd(), polygonStarted = false;\n        segments = polygon = null;\n      },\n      sphere: function() {\n        sink.polygonStart();\n        sink.lineStart();\n        interpolate(null, null, 1, sink);\n        sink.lineEnd();\n        sink.polygonEnd();\n      }\n    };\n\n    function point(lambda, phi) {\n      var point = rotate(lambda, phi);\n      if (pointVisible(lambda = point[0], phi = point[1])) sink.point(lambda, phi);\n    }\n\n    function pointLine(lambda, phi) {\n      var point = rotate(lambda, phi);\n      line.point(point[0], point[1]);\n    }\n\n    function lineStart() {\n      clip.point = pointLine;\n      line.lineStart();\n    }\n\n    function lineEnd() {\n      clip.point = point;\n      line.lineEnd();\n    }\n\n    function pointRing(lambda, phi) {\n      ring.push([lambda, phi]);\n      var point = rotate(lambda, phi);\n      ringSink.point(point[0], point[1]);\n    }\n\n    function ringStart() {\n      ringSink.lineStart();\n      ring = [];\n    }\n\n    function ringEnd() {\n      pointRing(ring[0][0], ring[0][1]);\n      ringSink.lineEnd();\n\n      var clean = ringSink.clean(),\n          ringSegments = ringBuffer.result(),\n          i, n = ringSegments.length, m,\n          segment,\n          point;\n\n      ring.pop();\n      polygon.push(ring);\n      ring = null;\n\n      if (!n) return;\n\n      // No intersections.\n      if (clean & 1) {\n        segment = ringSegments[0];\n        if ((m = segment.length - 1) > 0) {\n          if (!polygonStarted) sink.polygonStart(), polygonStarted = true;\n          sink.lineStart();\n          for (i = 0; i < m; ++i) sink.point((point = segment[i])[0], point[1]);\n          sink.lineEnd();\n        }\n        return;\n      }\n\n      // Rejoin connected segments.\n      // TODO reuse ringBuffer.rejoin()?\n      if (n > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift()));\n\n      segments.push(ringSegments.filter(validSegment));\n    }\n\n    return clip;\n  };\n};\n\nfunction validSegment(segment) {\n  return segment.length > 1;\n}\n\n// Intersections are sorted along the clip edge. For both antimeridian cutting\n// and circle clipping, the same comparison is used.\nfunction compareIntersection(a, b) {\n  return ((a = a.x)[0] < 0 ? a[1] - halfPi$2 - epsilon$2 : halfPi$2 - a[1])\n       - ((b = b.x)[0] < 0 ? b[1] - halfPi$2 - epsilon$2 : halfPi$2 - b[1]);\n}\n\nvar clipAntimeridian = clip(\n  function() { return true; },\n  clipAntimeridianLine,\n  clipAntimeridianInterpolate,\n  [-pi$3, -halfPi$2]\n);\n\n// Takes a line and cuts into visible segments. Return values: 0 - there were\n// intersections or the line was empty; 1 - no intersections; 2 - there were\n// intersections, and the first and last segments should be rejoined.\nfunction clipAntimeridianLine(stream) {\n  var lambda0 = NaN,\n      phi0 = NaN,\n      sign0 = NaN,\n      clean; // no intersections\n\n  return {\n    lineStart: function() {\n      stream.lineStart();\n      clean = 1;\n    },\n    point: function(lambda1, phi1) {\n      var sign1 = lambda1 > 0 ? pi$3 : -pi$3,\n          delta = abs(lambda1 - lambda0);\n      if (abs(delta - pi$3) < epsilon$2) { // line crosses a pole\n        stream.point(lambda0, phi0 = (phi0 + phi1) / 2 > 0 ? halfPi$2 : -halfPi$2);\n        stream.point(sign0, phi0);\n        stream.lineEnd();\n        stream.lineStart();\n        stream.point(sign1, phi0);\n        stream.point(lambda1, phi0);\n        clean = 0;\n      } else if (sign0 !== sign1 && delta >= pi$3) { // line crosses antimeridian\n        if (abs(lambda0 - sign0) < epsilon$2) lambda0 -= sign0 * epsilon$2; // handle degeneracies\n        if (abs(lambda1 - sign1) < epsilon$2) lambda1 -= sign1 * epsilon$2;\n        phi0 = clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1);\n        stream.point(sign0, phi0);\n        stream.lineEnd();\n        stream.lineStart();\n        stream.point(sign1, phi0);\n        clean = 0;\n      }\n      stream.point(lambda0 = lambda1, phi0 = phi1);\n      sign0 = sign1;\n    },\n    lineEnd: function() {\n      stream.lineEnd();\n      lambda0 = phi0 = NaN;\n    },\n    clean: function() {\n      return 2 - clean; // if intersections, rejoin first and last segments\n    }\n  };\n}\n\nfunction clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1) {\n  var cosPhi0,\n      cosPhi1,\n      sinLambda0Lambda1 = sin$1(lambda0 - lambda1);\n  return abs(sinLambda0Lambda1) > epsilon$2\n      ? atan((sin$1(phi0) * (cosPhi1 = cos$1(phi1)) * sin$1(lambda1)\n          - sin$1(phi1) * (cosPhi0 = cos$1(phi0)) * sin$1(lambda0))\n          / (cosPhi0 * cosPhi1 * sinLambda0Lambda1))\n      : (phi0 + phi1) / 2;\n}\n\nfunction clipAntimeridianInterpolate(from, to, direction, stream) {\n  var phi;\n  if (from == null) {\n    phi = direction * halfPi$2;\n    stream.point(-pi$3, phi);\n    stream.point(0, phi);\n    stream.point(pi$3, phi);\n    stream.point(pi$3, 0);\n    stream.point(pi$3, -phi);\n    stream.point(0, -phi);\n    stream.point(-pi$3, -phi);\n    stream.point(-pi$3, 0);\n    stream.point(-pi$3, phi);\n  } else if (abs(from[0] - to[0]) > epsilon$2) {\n    var lambda = from[0] < to[0] ? pi$3 : -pi$3;\n    phi = direction * lambda / 2;\n    stream.point(-lambda, phi);\n    stream.point(0, phi);\n    stream.point(lambda, phi);\n  } else {\n    stream.point(to[0], to[1]);\n  }\n}\n\nvar clipCircle = function(radius, delta) {\n  var cr = cos$1(radius),\n      smallRadius = cr > 0,\n      notHemisphere = abs(cr) > epsilon$2; // TODO optimise for this common case\n\n  function interpolate(from, to, direction, stream) {\n    circleStream(stream, radius, delta, direction, from, to);\n  }\n\n  function visible(lambda, phi) {\n    return cos$1(lambda) * cos$1(phi) > cr;\n  }\n\n  // Takes a line and cuts into visible segments. Return values used for polygon\n  // clipping: 0 - there were intersections or the line was empty; 1 - no\n  // intersections 2 - there were intersections, and the first and last segments\n  // should be rejoined.\n  function clipLine(stream) {\n    var point0, // previous point\n        c0, // code for previous point\n        v0, // visibility of previous point\n        v00, // visibility of first point\n        clean; // no intersections\n    return {\n      lineStart: function() {\n        v00 = v0 = false;\n        clean = 1;\n      },\n      point: function(lambda, phi) {\n        var point1 = [lambda, phi],\n            point2,\n            v = visible(lambda, phi),\n            c = smallRadius\n              ? v ? 0 : code(lambda, phi)\n              : v ? code(lambda + (lambda < 0 ? pi$3 : -pi$3), phi) : 0;\n        if (!point0 && (v00 = v0 = v)) stream.lineStart();\n        // Handle degeneracies.\n        // TODO ignore if not clipping polygons.\n        if (v !== v0) {\n          point2 = intersect(point0, point1);\n          if (pointEqual(point0, point2) || pointEqual(point1, point2)) {\n            point1[0] += epsilon$2;\n            point1[1] += epsilon$2;\n            v = visible(point1[0], point1[1]);\n          }\n        }\n        if (v !== v0) {\n          clean = 0;\n          if (v) {\n            // outside going in\n            stream.lineStart();\n            point2 = intersect(point1, point0);\n            stream.point(point2[0], point2[1]);\n          } else {\n            // inside going out\n            point2 = intersect(point0, point1);\n            stream.point(point2[0], point2[1]);\n            stream.lineEnd();\n          }\n          point0 = point2;\n        } else if (notHemisphere && point0 && smallRadius ^ v) {\n          var t;\n          // If the codes for two points are different, or are both zero,\n          // and there this segment intersects with the small circle.\n          if (!(c & c0) && (t = intersect(point1, point0, true))) {\n            clean = 0;\n            if (smallRadius) {\n              stream.lineStart();\n              stream.point(t[0][0], t[0][1]);\n              stream.point(t[1][0], t[1][1]);\n              stream.lineEnd();\n            } else {\n              stream.point(t[1][0], t[1][1]);\n              stream.lineEnd();\n              stream.lineStart();\n              stream.point(t[0][0], t[0][1]);\n            }\n          }\n        }\n        if (v && (!point0 || !pointEqual(point0, point1))) {\n          stream.point(point1[0], point1[1]);\n        }\n        point0 = point1, v0 = v, c0 = c;\n      },\n      lineEnd: function() {\n        if (v0) stream.lineEnd();\n        point0 = null;\n      },\n      // Rejoin first and last segments if there were intersections and the first\n      // and last points were visible.\n      clean: function() {\n        return clean | ((v00 && v0) << 1);\n      }\n    };\n  }\n\n  // Intersects the great circle between a and b with the clip circle.\n  function intersect(a, b, two) {\n    var pa = cartesian(a),\n        pb = cartesian(b);\n\n    // We have two planes, n1.p = d1 and n2.p = d2.\n    // Find intersection line p(t) = c1 n1 + c2 n2 + t (n1 ⨯ n2).\n    var n1 = [1, 0, 0], // normal\n        n2 = cartesianCross(pa, pb),\n        n2n2 = cartesianDot(n2, n2),\n        n1n2 = n2[0], // cartesianDot(n1, n2),\n        determinant = n2n2 - n1n2 * n1n2;\n\n    // Two polar points.\n    if (!determinant) return !two && a;\n\n    var c1 =  cr * n2n2 / determinant,\n        c2 = -cr * n1n2 / determinant,\n        n1xn2 = cartesianCross(n1, n2),\n        A = cartesianScale(n1, c1),\n        B = cartesianScale(n2, c2);\n    cartesianAddInPlace(A, B);\n\n    // Solve |p(t)|^2 = 1.\n    var u = n1xn2,\n        w = cartesianDot(A, u),\n        uu = cartesianDot(u, u),\n        t2 = w * w - uu * (cartesianDot(A, A) - 1);\n\n    if (t2 < 0) return;\n\n    var t = sqrt(t2),\n        q = cartesianScale(u, (-w - t) / uu);\n    cartesianAddInPlace(q, A);\n    q = spherical(q);\n\n    if (!two) return q;\n\n    // Two intersection points.\n    var lambda0 = a[0],\n        lambda1 = b[0],\n        phi0 = a[1],\n        phi1 = b[1],\n        z;\n\n    if (lambda1 < lambda0) z = lambda0, lambda0 = lambda1, lambda1 = z;\n\n    var delta = lambda1 - lambda0,\n        polar = abs(delta - pi$3) < epsilon$2,\n        meridian = polar || delta < epsilon$2;\n\n    if (!polar && phi1 < phi0) z = phi0, phi0 = phi1, phi1 = z;\n\n    // Check that the first point is between a and b.\n    if (meridian\n        ? polar\n          ? phi0 + phi1 > 0 ^ q[1] < (abs(q[0] - lambda0) < epsilon$2 ? phi0 : phi1)\n          : phi0 <= q[1] && q[1] <= phi1\n        : delta > pi$3 ^ (lambda0 <= q[0] && q[0] <= lambda1)) {\n      var q1 = cartesianScale(u, (-w + t) / uu);\n      cartesianAddInPlace(q1, A);\n      return [q, spherical(q1)];\n    }\n  }\n\n  // Generates a 4-bit vector representing the location of a point relative to\n  // the small circle's bounding box.\n  function code(lambda, phi) {\n    var r = smallRadius ? radius : pi$3 - radius,\n        code = 0;\n    if (lambda < -r) code |= 1; // left\n    else if (lambda > r) code |= 2; // right\n    if (phi < -r) code |= 4; // below\n    else if (phi > r) code |= 8; // above\n    return code;\n  }\n\n  return clip(visible, clipLine, interpolate, smallRadius ? [0, -radius] : [-pi$3, radius - pi$3]);\n};\n\nvar transform = function(methods) {\n  return {\n    stream: transformer(methods)\n  };\n};\n\nfunction transformer(methods) {\n  return function(stream) {\n    var s = new TransformStream;\n    for (var key in methods) s[key] = methods[key];\n    s.stream = stream;\n    return s;\n  };\n}\n\nfunction TransformStream() {}\n\nTransformStream.prototype = {\n  constructor: TransformStream,\n  point: function(x, y) { this.stream.point(x, y); },\n  sphere: function() { this.stream.sphere(); },\n  lineStart: function() { this.stream.lineStart(); },\n  lineEnd: function() { this.stream.lineEnd(); },\n  polygonStart: function() { this.stream.polygonStart(); },\n  polygonEnd: function() { this.stream.polygonEnd(); }\n};\n\nfunction fitExtent(projection, extent, object) {\n  var w = extent[1][0] - extent[0][0],\n      h = extent[1][1] - extent[0][1],\n      clip = projection.clipExtent && projection.clipExtent();\n\n  projection\n      .scale(150)\n      .translate([0, 0]);\n\n  if (clip != null) projection.clipExtent(null);\n\n  geoStream(object, projection.stream(boundsStream$1));\n\n  var b = boundsStream$1.result(),\n      k = Math.min(w / (b[1][0] - b[0][0]), h / (b[1][1] - b[0][1])),\n      x = +extent[0][0] + (w - k * (b[1][0] + b[0][0])) / 2,\n      y = +extent[0][1] + (h - k * (b[1][1] + b[0][1])) / 2;\n\n  if (clip != null) projection.clipExtent(clip);\n\n  return projection\n      .scale(k * 150)\n      .translate([x, y]);\n}\n\nfunction fitSize(projection, size, object) {\n  return fitExtent(projection, [[0, 0], size], object);\n}\n\nvar maxDepth = 16;\nvar cosMinDistance = cos$1(30 * radians); // cos(minimum angular distance)\n\nvar resample = function(project, delta2) {\n  return +delta2 ? resample$1(project, delta2) : resampleNone(project);\n};\n\nfunction resampleNone(project) {\n  return transformer({\n    point: function(x, y) {\n      x = project(x, y);\n      this.stream.point(x[0], x[1]);\n    }\n  });\n}\n\nfunction resample$1(project, delta2) {\n\n  function resampleLineTo(x0, y0, lambda0, a0, b0, c0, x1, y1, lambda1, a1, b1, c1, depth, stream) {\n    var dx = x1 - x0,\n        dy = y1 - y0,\n        d2 = dx * dx + dy * dy;\n    if (d2 > 4 * delta2 && depth--) {\n      var a = a0 + a1,\n          b = b0 + b1,\n          c = c0 + c1,\n          m = sqrt(a * a + b * b + c * c),\n          phi2 = asin(c /= m),\n          lambda2 = abs(abs(c) - 1) < epsilon$2 || abs(lambda0 - lambda1) < epsilon$2 ? (lambda0 + lambda1) / 2 : atan2(b, a),\n          p = project(lambda2, phi2),\n          x2 = p[0],\n          y2 = p[1],\n          dx2 = x2 - x0,\n          dy2 = y2 - y0,\n          dz = dy * dx2 - dx * dy2;\n      if (dz * dz / d2 > delta2 // perpendicular projected distance\n          || abs((dx * dx2 + dy * dy2) / d2 - 0.5) > 0.3 // midpoint close to an end\n          || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) { // angular distance\n        resampleLineTo(x0, y0, lambda0, a0, b0, c0, x2, y2, lambda2, a /= m, b /= m, c, depth, stream);\n        stream.point(x2, y2);\n        resampleLineTo(x2, y2, lambda2, a, b, c, x1, y1, lambda1, a1, b1, c1, depth, stream);\n      }\n    }\n  }\n  return function(stream) {\n    var lambda00, x00, y00, a00, b00, c00, // first point\n        lambda0, x0, y0, a0, b0, c0; // previous point\n\n    var resampleStream = {\n      point: point,\n      lineStart: lineStart,\n      lineEnd: lineEnd,\n      polygonStart: function() { stream.polygonStart(); resampleStream.lineStart = ringStart; },\n      polygonEnd: function() { stream.polygonEnd(); resampleStream.lineStart = lineStart; }\n    };\n\n    function point(x, y) {\n      x = project(x, y);\n      stream.point(x[0], x[1]);\n    }\n\n    function lineStart() {\n      x0 = NaN;\n      resampleStream.point = linePoint;\n      stream.lineStart();\n    }\n\n    function linePoint(lambda, phi) {\n      var c = cartesian([lambda, phi]), p = project(lambda, phi);\n      resampleLineTo(x0, y0, lambda0, a0, b0, c0, x0 = p[0], y0 = p[1], lambda0 = lambda, a0 = c[0], b0 = c[1], c0 = c[2], maxDepth, stream);\n      stream.point(x0, y0);\n    }\n\n    function lineEnd() {\n      resampleStream.point = point;\n      stream.lineEnd();\n    }\n\n    function ringStart() {\n      lineStart();\n      resampleStream.point = ringPoint;\n      resampleStream.lineEnd = ringEnd;\n    }\n\n    function ringPoint(lambda, phi) {\n      linePoint(lambda00 = lambda, phi), x00 = x0, y00 = y0, a00 = a0, b00 = b0, c00 = c0;\n      resampleStream.point = linePoint;\n    }\n\n    function ringEnd() {\n      resampleLineTo(x0, y0, lambda0, a0, b0, c0, x00, y00, lambda00, a00, b00, c00, maxDepth, stream);\n      resampleStream.lineEnd = lineEnd;\n      lineEnd();\n    }\n\n    return resampleStream;\n  };\n}\n\nvar transformRadians = transformer({\n  point: function(x, y) {\n    this.stream.point(x * radians, y * radians);\n  }\n});\n\nfunction projection(project) {\n  return projectionMutator(function() { return project; })();\n}\n\nfunction projectionMutator(projectAt) {\n  var project,\n      k = 150, // scale\n      x = 480, y = 250, // translate\n      dx, dy, lambda = 0, phi = 0, // center\n      deltaLambda = 0, deltaPhi = 0, deltaGamma = 0, rotate, projectRotate, // rotate\n      theta = null, preclip = clipAntimeridian, // clip angle\n      x0 = null, y0, x1, y1, postclip = identity$4, // clip extent\n      delta2 = 0.5, projectResample = resample(projectTransform, delta2), // precision\n      cache,\n      cacheStream;\n\n  function projection(point) {\n    point = projectRotate(point[0] * radians, point[1] * radians);\n    return [point[0] * k + dx, dy - point[1] * k];\n  }\n\n  function invert(point) {\n    point = projectRotate.invert((point[0] - dx) / k, (dy - point[1]) / k);\n    return point && [point[0] * degrees$1, point[1] * degrees$1];\n  }\n\n  function projectTransform(x, y) {\n    return x = project(x, y), [x[0] * k + dx, dy - x[1] * k];\n  }\n\n  projection.stream = function(stream) {\n    return cache && cacheStream === stream ? cache : cache = transformRadians(preclip(rotate, projectResample(postclip(cacheStream = stream))));\n  };\n\n  projection.clipAngle = function(_) {\n    return arguments.length ? (preclip = +_ ? clipCircle(theta = _ * radians, 6 * radians) : (theta = null, clipAntimeridian), reset()) : theta * degrees$1;\n  };\n\n  projection.clipExtent = function(_) {\n    return arguments.length ? (postclip = _ == null ? (x0 = y0 = x1 = y1 = null, identity$4) : clipExtent(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]), reset()) : x0 == null ? null : [[x0, y0], [x1, y1]];\n  };\n\n  projection.scale = function(_) {\n    return arguments.length ? (k = +_, recenter()) : k;\n  };\n\n  projection.translate = function(_) {\n    return arguments.length ? (x = +_[0], y = +_[1], recenter()) : [x, y];\n  };\n\n  projection.center = function(_) {\n    return arguments.length ? (lambda = _[0] % 360 * radians, phi = _[1] % 360 * radians, recenter()) : [lambda * degrees$1, phi * degrees$1];\n  };\n\n  projection.rotate = function(_) {\n    return arguments.length ? (deltaLambda = _[0] % 360 * radians, deltaPhi = _[1] % 360 * radians, deltaGamma = _.length > 2 ? _[2] % 360 * radians : 0, recenter()) : [deltaLambda * degrees$1, deltaPhi * degrees$1, deltaGamma * degrees$1];\n  };\n\n  projection.precision = function(_) {\n    return arguments.length ? (projectResample = resample(projectTransform, delta2 = _ * _), reset()) : sqrt(delta2);\n  };\n\n  projection.fitExtent = function(extent, object) {\n    return fitExtent(projection, extent, object);\n  };\n\n  projection.fitSize = function(size, object) {\n    return fitSize(projection, size, object);\n  };\n\n  function recenter() {\n    projectRotate = compose(rotate = rotateRadians(deltaLambda, deltaPhi, deltaGamma), project);\n    var center = project(lambda, phi);\n    dx = x - center[0] * k;\n    dy = y + center[1] * k;\n    return reset();\n  }\n\n  function reset() {\n    cache = cacheStream = null;\n    return projection;\n  }\n\n  return function() {\n    project = projectAt.apply(this, arguments);\n    projection.invert = project.invert && invert;\n    return recenter();\n  };\n}\n\nfunction conicProjection(projectAt) {\n  var phi0 = 0,\n      phi1 = pi$3 / 3,\n      m = projectionMutator(projectAt),\n      p = m(phi0, phi1);\n\n  p.parallels = function(_) {\n    return arguments.length ? m(phi0 = _[0] * radians, phi1 = _[1] * radians) : [phi0 * degrees$1, phi1 * degrees$1];\n  };\n\n  return p;\n}\n\nfunction cylindricalEqualAreaRaw(phi0) {\n  var cosPhi0 = cos$1(phi0);\n\n  function forward(lambda, phi) {\n    return [lambda * cosPhi0, sin$1(phi) / cosPhi0];\n  }\n\n  forward.invert = function(x, y) {\n    return [x / cosPhi0, asin(y * cosPhi0)];\n  };\n\n  return forward;\n}\n\nfunction conicEqualAreaRaw(y0, y1) {\n  var sy0 = sin$1(y0), n = (sy0 + sin$1(y1)) / 2;\n\n  // Are the parallels symmetrical around the Equator?\n  if (abs(n) < epsilon$2) return cylindricalEqualAreaRaw(y0);\n\n  var c = 1 + sy0 * (2 * n - sy0), r0 = sqrt(c) / n;\n\n  function project(x, y) {\n    var r = sqrt(c - 2 * n * sin$1(y)) / n;\n    return [r * sin$1(x *= n), r0 - r * cos$1(x)];\n  }\n\n  project.invert = function(x, y) {\n    var r0y = r0 - y;\n    return [atan2(x, abs(r0y)) / n * sign(r0y), asin((c - (x * x + r0y * r0y) * n * n) / (2 * n))];\n  };\n\n  return project;\n}\n\nvar conicEqualArea = function() {\n  return conicProjection(conicEqualAreaRaw)\n      .scale(155.424)\n      .center([0, 33.6442]);\n};\n\nvar albers = function() {\n  return conicEqualArea()\n      .parallels([29.5, 45.5])\n      .scale(1070)\n      .translate([480, 250])\n      .rotate([96, 0])\n      .center([-0.6, 38.7]);\n};\n\n// The projections must have mutually exclusive clip regions on the sphere,\n// as this will avoid emitting interleaving lines and polygons.\nfunction multiplex(streams) {\n  var n = streams.length;\n  return {\n    point: function(x, y) { var i = -1; while (++i < n) streams[i].point(x, y); },\n    sphere: function() { var i = -1; while (++i < n) streams[i].sphere(); },\n    lineStart: function() { var i = -1; while (++i < n) streams[i].lineStart(); },\n    lineEnd: function() { var i = -1; while (++i < n) streams[i].lineEnd(); },\n    polygonStart: function() { var i = -1; while (++i < n) streams[i].polygonStart(); },\n    polygonEnd: function() { var i = -1; while (++i < n) streams[i].polygonEnd(); }\n  };\n}\n\n// A composite projection for the United States, configured by default for\n// 960×500. The projection also works quite well at 960×600 if you change the\n// scale to 1285 and adjust the translate accordingly. The set of standard\n// parallels for each region comes from USGS, which is published here:\n// http://egsc.usgs.gov/isb/pubs/MapProjections/projections.html#albers\nvar albersUsa = function() {\n  var cache,\n      cacheStream,\n      lower48 = albers(), lower48Point,\n      alaska = conicEqualArea().rotate([154, 0]).center([-2, 58.5]).parallels([55, 65]), alaskaPoint, // EPSG:3338\n      hawaii = conicEqualArea().rotate([157, 0]).center([-3, 19.9]).parallels([8, 18]), hawaiiPoint, // ESRI:102007\n      point, pointStream = {point: function(x, y) { point = [x, y]; }};\n\n  function albersUsa(coordinates) {\n    var x = coordinates[0], y = coordinates[1];\n    return point = null,\n        (lower48Point.point(x, y), point)\n        || (alaskaPoint.point(x, y), point)\n        || (hawaiiPoint.point(x, y), point);\n  }\n\n  albersUsa.invert = function(coordinates) {\n    var k = lower48.scale(),\n        t = lower48.translate(),\n        x = (coordinates[0] - t[0]) / k,\n        y = (coordinates[1] - t[1]) / k;\n    return (y >= 0.120 && y < 0.234 && x >= -0.425 && x < -0.214 ? alaska\n        : y >= 0.166 && y < 0.234 && x >= -0.214 && x < -0.115 ? hawaii\n        : lower48).invert(coordinates);\n  };\n\n  albersUsa.stream = function(stream) {\n    return cache && cacheStream === stream ? cache : cache = multiplex([lower48.stream(cacheStream = stream), alaska.stream(stream), hawaii.stream(stream)]);\n  };\n\n  albersUsa.precision = function(_) {\n    if (!arguments.length) return lower48.precision();\n    lower48.precision(_), alaska.precision(_), hawaii.precision(_);\n    return reset();\n  };\n\n  albersUsa.scale = function(_) {\n    if (!arguments.length) return lower48.scale();\n    lower48.scale(_), alaska.scale(_ * 0.35), hawaii.scale(_);\n    return albersUsa.translate(lower48.translate());\n  };\n\n  albersUsa.translate = function(_) {\n    if (!arguments.length) return lower48.translate();\n    var k = lower48.scale(), x = +_[0], y = +_[1];\n\n    lower48Point = lower48\n        .translate(_)\n        .clipExtent([[x - 0.455 * k, y - 0.238 * k], [x + 0.455 * k, y + 0.238 * k]])\n        .stream(pointStream);\n\n    alaskaPoint = alaska\n        .translate([x - 0.307 * k, y + 0.201 * k])\n        .clipExtent([[x - 0.425 * k + epsilon$2, y + 0.120 * k + epsilon$2], [x - 0.214 * k - epsilon$2, y + 0.234 * k - epsilon$2]])\n        .stream(pointStream);\n\n    hawaiiPoint = hawaii\n        .translate([x - 0.205 * k, y + 0.212 * k])\n        .clipExtent([[x - 0.214 * k + epsilon$2, y + 0.166 * k + epsilon$2], [x - 0.115 * k - epsilon$2, y + 0.234 * k - epsilon$2]])\n        .stream(pointStream);\n\n    return reset();\n  };\n\n  albersUsa.fitExtent = function(extent, object) {\n    return fitExtent(albersUsa, extent, object);\n  };\n\n  albersUsa.fitSize = function(size, object) {\n    return fitSize(albersUsa, size, object);\n  };\n\n  function reset() {\n    cache = cacheStream = null;\n    return albersUsa;\n  }\n\n  return albersUsa.scale(1070);\n};\n\nfunction azimuthalRaw(scale) {\n  return function(x, y) {\n    var cx = cos$1(x),\n        cy = cos$1(y),\n        k = scale(cx * cy);\n    return [\n      k * cy * sin$1(x),\n      k * sin$1(y)\n    ];\n  }\n}\n\nfunction azimuthalInvert(angle) {\n  return function(x, y) {\n    var z = sqrt(x * x + y * y),\n        c = angle(z),\n        sc = sin$1(c),\n        cc = cos$1(c);\n    return [\n      atan2(x * sc, z * cc),\n      asin(z && y * sc / z)\n    ];\n  }\n}\n\nvar azimuthalEqualAreaRaw = azimuthalRaw(function(cxcy) {\n  return sqrt(2 / (1 + cxcy));\n});\n\nazimuthalEqualAreaRaw.invert = azimuthalInvert(function(z) {\n  return 2 * asin(z / 2);\n});\n\nvar azimuthalEqualArea = function() {\n  return projection(azimuthalEqualAreaRaw)\n      .scale(124.75)\n      .clipAngle(180 - 1e-3);\n};\n\nvar azimuthalEquidistantRaw = azimuthalRaw(function(c) {\n  return (c = acos(c)) && c / sin$1(c);\n});\n\nazimuthalEquidistantRaw.invert = azimuthalInvert(function(z) {\n  return z;\n});\n\nvar azimuthalEquidistant = function() {\n  return projection(azimuthalEquidistantRaw)\n      .scale(79.4188)\n      .clipAngle(180 - 1e-3);\n};\n\nfunction mercatorRaw(lambda, phi) {\n  return [lambda, log(tan((halfPi$2 + phi) / 2))];\n}\n\nmercatorRaw.invert = function(x, y) {\n  return [x, 2 * atan(exp(y)) - halfPi$2];\n};\n\nvar mercator = function() {\n  return mercatorProjection(mercatorRaw)\n      .scale(961 / tau$3);\n};\n\nfunction mercatorProjection(project) {\n  var m = projection(project),\n      scale = m.scale,\n      translate = m.translate,\n      clipExtent = m.clipExtent,\n      clipAuto;\n\n  m.scale = function(_) {\n    return arguments.length ? (scale(_), clipAuto && m.clipExtent(null), m) : scale();\n  };\n\n  m.translate = function(_) {\n    return arguments.length ? (translate(_), clipAuto && m.clipExtent(null), m) : translate();\n  };\n\n  m.clipExtent = function(_) {\n    if (!arguments.length) return clipAuto ? null : clipExtent();\n    if (clipAuto = _ == null) {\n      var k = pi$3 * scale(),\n          t = translate();\n      _ = [[t[0] - k, t[1] - k], [t[0] + k, t[1] + k]];\n    }\n    clipExtent(_);\n    return m;\n  };\n\n  return m.clipExtent(null);\n}\n\nfunction tany(y) {\n  return tan((halfPi$2 + y) / 2);\n}\n\nfunction conicConformalRaw(y0, y1) {\n  var cy0 = cos$1(y0),\n      n = y0 === y1 ? sin$1(y0) : log(cy0 / cos$1(y1)) / log(tany(y1) / tany(y0)),\n      f = cy0 * pow(tany(y0), n) / n;\n\n  if (!n) return mercatorRaw;\n\n  function project(x, y) {\n    if (f > 0) { if (y < -halfPi$2 + epsilon$2) y = -halfPi$2 + epsilon$2; }\n    else { if (y > halfPi$2 - epsilon$2) y = halfPi$2 - epsilon$2; }\n    var r = f / pow(tany(y), n);\n    return [r * sin$1(n * x), f - r * cos$1(n * x)];\n  }\n\n  project.invert = function(x, y) {\n    var fy = f - y, r = sign(n) * sqrt(x * x + fy * fy);\n    return [atan2(x, abs(fy)) / n * sign(fy), 2 * atan(pow(f / r, 1 / n)) - halfPi$2];\n  };\n\n  return project;\n}\n\nvar conicConformal = function() {\n  return conicProjection(conicConformalRaw)\n      .scale(109.5)\n      .parallels([30, 30]);\n};\n\nfunction equirectangularRaw(lambda, phi) {\n  return [lambda, phi];\n}\n\nequirectangularRaw.invert = equirectangularRaw;\n\nvar equirectangular = function() {\n  return projection(equirectangularRaw)\n      .scale(152.63);\n};\n\nfunction conicEquidistantRaw(y0, y1) {\n  var cy0 = cos$1(y0),\n      n = y0 === y1 ? sin$1(y0) : (cy0 - cos$1(y1)) / (y1 - y0),\n      g = cy0 / n + y0;\n\n  if (abs(n) < epsilon$2) return equirectangularRaw;\n\n  function project(x, y) {\n    var gy = g - y, nx = n * x;\n    return [gy * sin$1(nx), g - gy * cos$1(nx)];\n  }\n\n  project.invert = function(x, y) {\n    var gy = g - y;\n    return [atan2(x, abs(gy)) / n * sign(gy), g - sign(n) * sqrt(x * x + gy * gy)];\n  };\n\n  return project;\n}\n\nvar conicEquidistant = function() {\n  return conicProjection(conicEquidistantRaw)\n      .scale(131.154)\n      .center([0, 13.9389]);\n};\n\nfunction gnomonicRaw(x, y) {\n  var cy = cos$1(y), k = cos$1(x) * cy;\n  return [cy * sin$1(x) / k, sin$1(y) / k];\n}\n\ngnomonicRaw.invert = azimuthalInvert(atan);\n\nvar gnomonic = function() {\n  return projection(gnomonicRaw)\n      .scale(144.049)\n      .clipAngle(60);\n};\n\nfunction scaleTranslate(kx, ky, tx, ty) {\n  return kx === 1 && ky === 1 && tx === 0 && ty === 0 ? identity$4 : transformer({\n    point: function(x, y) {\n      this.stream.point(x * kx + tx, y * ky + ty);\n    }\n  });\n}\n\nvar identity$5 = function() {\n  var k = 1, tx = 0, ty = 0, sx = 1, sy = 1, transform = identity$4, // scale, translate and reflect\n      x0 = null, y0, x1, y1, clip = identity$4, // clip extent\n      cache,\n      cacheStream,\n      projection;\n\n  function reset() {\n    cache = cacheStream = null;\n    return projection;\n  }\n\n  return projection = {\n    stream: function(stream) {\n      return cache && cacheStream === stream ? cache : cache = transform(clip(cacheStream = stream));\n    },\n    clipExtent: function(_) {\n      return arguments.length ? (clip = _ == null ? (x0 = y0 = x1 = y1 = null, identity$4) : clipExtent(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]), reset()) : x0 == null ? null : [[x0, y0], [x1, y1]];\n    },\n    scale: function(_) {\n      return arguments.length ? (transform = scaleTranslate((k = +_) * sx, k * sy, tx, ty), reset()) : k;\n    },\n    translate: function(_) {\n      return arguments.length ? (transform = scaleTranslate(k * sx, k * sy, tx = +_[0], ty = +_[1]), reset()) : [tx, ty];\n    },\n    reflectX: function(_) {\n      return arguments.length ? (transform = scaleTranslate(k * (sx = _ ? -1 : 1), k * sy, tx, ty), reset()) : sx < 0;\n    },\n    reflectY: function(_) {\n      return arguments.length ? (transform = scaleTranslate(k * sx, k * (sy = _ ? -1 : 1), tx, ty), reset()) : sy < 0;\n    },\n    fitExtent: function(extent, object) {\n      return fitExtent(projection, extent, object);\n    },\n    fitSize: function(size, object) {\n      return fitSize(projection, size, object);\n    }\n  };\n};\n\nfunction orthographicRaw(x, y) {\n  return [cos$1(y) * sin$1(x), sin$1(y)];\n}\n\northographicRaw.invert = azimuthalInvert(asin);\n\nvar orthographic = function() {\n  return projection(orthographicRaw)\n      .scale(249.5)\n      .clipAngle(90 + epsilon$2);\n};\n\nfunction stereographicRaw(x, y) {\n  var cy = cos$1(y), k = 1 + cos$1(x) * cy;\n  return [cy * sin$1(x) / k, sin$1(y) / k];\n}\n\nstereographicRaw.invert = azimuthalInvert(function(z) {\n  return 2 * atan(z);\n});\n\nvar stereographic = function() {\n  return projection(stereographicRaw)\n      .scale(250)\n      .clipAngle(142);\n};\n\nfunction transverseMercatorRaw(lambda, phi) {\n  return [log(tan((halfPi$2 + phi) / 2)), -lambda];\n}\n\ntransverseMercatorRaw.invert = function(x, y) {\n  return [-y, 2 * atan(exp(x)) - halfPi$2];\n};\n\nvar transverseMercator = function() {\n  var m = mercatorProjection(transverseMercatorRaw),\n      center = m.center,\n      rotate = m.rotate;\n\n  m.center = function(_) {\n    return arguments.length ? center([-_[1], _[0]]) : (_ = center(), [_[1], -_[0]]);\n  };\n\n  m.rotate = function(_) {\n    return arguments.length ? rotate([_[0], _[1], _.length > 2 ? _[2] + 90 : 90]) : (_ = rotate(), [_[0], _[1], _[2] - 90]);\n  };\n\n  return rotate([0, 0, 90])\n      .scale(159.155);\n};\n\nfunction defaultSeparation(a, b) {\n  return a.parent === b.parent ? 1 : 2;\n}\n\nfunction meanX(children) {\n  return children.reduce(meanXReduce, 0) / children.length;\n}\n\nfunction meanXReduce(x, c) {\n  return x + c.x;\n}\n\nfunction maxY(children) {\n  return 1 + children.reduce(maxYReduce, 0);\n}\n\nfunction maxYReduce(y, c) {\n  return Math.max(y, c.y);\n}\n\nfunction leafLeft(node) {\n  var children;\n  while (children = node.children) node = children[0];\n  return node;\n}\n\nfunction leafRight(node) {\n  var children;\n  while (children = node.children) node = children[children.length - 1];\n  return node;\n}\n\nvar cluster = function() {\n  var separation = defaultSeparation,\n      dx = 1,\n      dy = 1,\n      nodeSize = false;\n\n  function cluster(root) {\n    var previousNode,\n        x = 0;\n\n    // First walk, computing the initial x & y values.\n    root.eachAfter(function(node) {\n      var children = node.children;\n      if (children) {\n        node.x = meanX(children);\n        node.y = maxY(children);\n      } else {\n        node.x = previousNode ? x += separation(node, previousNode) : 0;\n        node.y = 0;\n        previousNode = node;\n      }\n    });\n\n    var left = leafLeft(root),\n        right = leafRight(root),\n        x0 = left.x - separation(left, right) / 2,\n        x1 = right.x + separation(right, left) / 2;\n\n    // Second walk, normalizing x & y to the desired size.\n    return root.eachAfter(nodeSize ? function(node) {\n      node.x = (node.x - root.x) * dx;\n      node.y = (root.y - node.y) * dy;\n    } : function(node) {\n      node.x = (node.x - x0) / (x1 - x0) * dx;\n      node.y = (1 - (root.y ? node.y / root.y : 1)) * dy;\n    });\n  }\n\n  cluster.separation = function(x) {\n    return arguments.length ? (separation = x, cluster) : separation;\n  };\n\n  cluster.size = function(x) {\n    return arguments.length ? (nodeSize = false, dx = +x[0], dy = +x[1], cluster) : (nodeSize ? null : [dx, dy]);\n  };\n\n  cluster.nodeSize = function(x) {\n    return arguments.length ? (nodeSize = true, dx = +x[0], dy = +x[1], cluster) : (nodeSize ? [dx, dy] : null);\n  };\n\n  return cluster;\n};\n\nfunction count(node) {\n  var sum = 0,\n      children = node.children,\n      i = children && children.length;\n  if (!i) sum = 1;\n  else while (--i >= 0) sum += children[i].value;\n  node.value = sum;\n}\n\nvar node_count = function() {\n  return this.eachAfter(count);\n};\n\nvar node_each = function(callback) {\n  var node = this, current, next = [node], children, i, n;\n  do {\n    current = next.reverse(), next = [];\n    while (node = current.pop()) {\n      callback(node), children = node.children;\n      if (children) for (i = 0, n = children.length; i < n; ++i) {\n        next.push(children[i]);\n      }\n    }\n  } while (next.length);\n  return this;\n};\n\nvar node_eachBefore = function(callback) {\n  var node = this, nodes = [node], children, i;\n  while (node = nodes.pop()) {\n    callback(node), children = node.children;\n    if (children) for (i = children.length - 1; i >= 0; --i) {\n      nodes.push(children[i]);\n    }\n  }\n  return this;\n};\n\nvar node_eachAfter = function(callback) {\n  var node = this, nodes = [node], next = [], children, i, n;\n  while (node = nodes.pop()) {\n    next.push(node), children = node.children;\n    if (children) for (i = 0, n = children.length; i < n; ++i) {\n      nodes.push(children[i]);\n    }\n  }\n  while (node = next.pop()) {\n    callback(node);\n  }\n  return this;\n};\n\nvar node_sum = function(value) {\n  return this.eachAfter(function(node) {\n    var sum = +value(node.data) || 0,\n        children = node.children,\n        i = children && children.length;\n    while (--i >= 0) sum += children[i].value;\n    node.value = sum;\n  });\n};\n\nvar node_sort = function(compare) {\n  return this.eachBefore(function(node) {\n    if (node.children) {\n      node.children.sort(compare);\n    }\n  });\n};\n\nvar node_path = function(end) {\n  var start = this,\n      ancestor = leastCommonAncestor(start, end),\n      nodes = [start];\n  while (start !== ancestor) {\n    start = start.parent;\n    nodes.push(start);\n  }\n  var k = nodes.length;\n  while (end !== ancestor) {\n    nodes.splice(k, 0, end);\n    end = end.parent;\n  }\n  return nodes;\n};\n\nfunction leastCommonAncestor(a, b) {\n  if (a === b) return a;\n  var aNodes = a.ancestors(),\n      bNodes = b.ancestors(),\n      c = null;\n  a = aNodes.pop();\n  b = bNodes.pop();\n  while (a === b) {\n    c = a;\n    a = aNodes.pop();\n    b = bNodes.pop();\n  }\n  return c;\n}\n\nvar node_ancestors = function() {\n  var node = this, nodes = [node];\n  while (node = node.parent) {\n    nodes.push(node);\n  }\n  return nodes;\n};\n\nvar node_descendants = function() {\n  var nodes = [];\n  this.each(function(node) {\n    nodes.push(node);\n  });\n  return nodes;\n};\n\nvar node_leaves = function() {\n  var leaves = [];\n  this.eachBefore(function(node) {\n    if (!node.children) {\n      leaves.push(node);\n    }\n  });\n  return leaves;\n};\n\nvar node_links = function() {\n  var root = this, links = [];\n  root.each(function(node) {\n    if (node !== root) { // Don’t include the root’s parent, if any.\n      links.push({source: node.parent, target: node});\n    }\n  });\n  return links;\n};\n\nfunction hierarchy(data, children) {\n  var root = new Node(data),\n      valued = +data.value && (root.value = data.value),\n      node,\n      nodes = [root],\n      child,\n      childs,\n      i,\n      n;\n\n  if (children == null) children = defaultChildren;\n\n  while (node = nodes.pop()) {\n    if (valued) node.value = +node.data.value;\n    if ((childs = children(node.data)) && (n = childs.length)) {\n      node.children = new Array(n);\n      for (i = n - 1; i >= 0; --i) {\n        nodes.push(child = node.children[i] = new Node(childs[i]));\n        child.parent = node;\n        child.depth = node.depth + 1;\n      }\n    }\n  }\n\n  return root.eachBefore(computeHeight);\n}\n\nfunction node_copy() {\n  return hierarchy(this).eachBefore(copyData);\n}\n\nfunction defaultChildren(d) {\n  return d.children;\n}\n\nfunction copyData(node) {\n  node.data = node.data.data;\n}\n\nfunction computeHeight(node) {\n  var height = 0;\n  do node.height = height;\n  while ((node = node.parent) && (node.height < ++height));\n}\n\nfunction Node(data) {\n  this.data = data;\n  this.depth =\n  this.height = 0;\n  this.parent = null;\n}\n\nNode.prototype = hierarchy.prototype = {\n  constructor: Node,\n  count: node_count,\n  each: node_each,\n  eachAfter: node_eachAfter,\n  eachBefore: node_eachBefore,\n  sum: node_sum,\n  sort: node_sort,\n  path: node_path,\n  ancestors: node_ancestors,\n  descendants: node_descendants,\n  leaves: node_leaves,\n  links: node_links,\n  copy: node_copy\n};\n\nfunction Node$2(value) {\n  this._ = value;\n  this.next = null;\n}\n\nvar shuffle$1 = function(array) {\n  var i,\n      n = (array = array.slice()).length,\n      head = null,\n      node = head;\n\n  while (n) {\n    var next = new Node$2(array[n - 1]);\n    if (node) node = node.next = next;\n    else node = head = next;\n    array[i] = array[--n];\n  }\n\n  return {\n    head: head,\n    tail: node\n  };\n};\n\nvar enclose = function(circles) {\n  return encloseN(shuffle$1(circles), []);\n};\n\nfunction encloses(a, b) {\n  var dx = b.x - a.x,\n      dy = b.y - a.y,\n      dr = a.r - b.r;\n  return dr * dr + 1e-6 > dx * dx + dy * dy;\n}\n\n// Returns the smallest circle that contains circles L and intersects circles B.\nfunction encloseN(L, B) {\n  var circle,\n      l0 = null,\n      l1 = L.head,\n      l2,\n      p1;\n\n  switch (B.length) {\n    case 1: circle = enclose1(B[0]); break;\n    case 2: circle = enclose2(B[0], B[1]); break;\n    case 3: circle = enclose3(B[0], B[1], B[2]); break;\n  }\n\n  while (l1) {\n    p1 = l1._, l2 = l1.next;\n    if (!circle || !encloses(circle, p1)) {\n\n      // Temporarily truncate L before l1.\n      if (l0) L.tail = l0, l0.next = null;\n      else L.head = L.tail = null;\n\n      B.push(p1);\n      circle = encloseN(L, B); // Note: reorders L!\n      B.pop();\n\n      // Move l1 to the front of L and reconnect the truncated list L.\n      if (L.head) l1.next = L.head, L.head = l1;\n      else l1.next = null, L.head = L.tail = l1;\n      l0 = L.tail, l0.next = l2;\n\n    } else {\n      l0 = l1;\n    }\n    l1 = l2;\n  }\n\n  L.tail = l0;\n  return circle;\n}\n\nfunction enclose1(a) {\n  return {\n    x: a.x,\n    y: a.y,\n    r: a.r\n  };\n}\n\nfunction enclose2(a, b) {\n  var x1 = a.x, y1 = a.y, r1 = a.r,\n      x2 = b.x, y2 = b.y, r2 = b.r,\n      x21 = x2 - x1, y21 = y2 - y1, r21 = r2 - r1,\n      l = Math.sqrt(x21 * x21 + y21 * y21);\n  return {\n    x: (x1 + x2 + x21 / l * r21) / 2,\n    y: (y1 + y2 + y21 / l * r21) / 2,\n    r: (l + r1 + r2) / 2\n  };\n}\n\nfunction enclose3(a, b, c) {\n  var x1 = a.x, y1 = a.y, r1 = a.r,\n      x2 = b.x, y2 = b.y, r2 = b.r,\n      x3 = c.x, y3 = c.y, r3 = c.r,\n      a2 = 2 * (x1 - x2),\n      b2 = 2 * (y1 - y2),\n      c2 = 2 * (r2 - r1),\n      d2 = x1 * x1 + y1 * y1 - r1 * r1 - x2 * x2 - y2 * y2 + r2 * r2,\n      a3 = 2 * (x1 - x3),\n      b3 = 2 * (y1 - y3),\n      c3 = 2 * (r3 - r1),\n      d3 = x1 * x1 + y1 * y1 - r1 * r1 - x3 * x3 - y3 * y3 + r3 * r3,\n      ab = a3 * b2 - a2 * b3,\n      xa = (b2 * d3 - b3 * d2) / ab - x1,\n      xb = (b3 * c2 - b2 * c3) / ab,\n      ya = (a3 * d2 - a2 * d3) / ab - y1,\n      yb = (a2 * c3 - a3 * c2) / ab,\n      A = xb * xb + yb * yb - 1,\n      B = 2 * (xa * xb + ya * yb + r1),\n      C = xa * xa + ya * ya - r1 * r1,\n      r = (-B - Math.sqrt(B * B - 4 * A * C)) / (2 * A);\n  return {\n    x: xa + xb * r + x1,\n    y: ya + yb * r + y1,\n    r: r\n  };\n}\n\nfunction place(a, b, c) {\n  var ax = a.x,\n      ay = a.y,\n      da = b.r + c.r,\n      db = a.r + c.r,\n      dx = b.x - ax,\n      dy = b.y - ay,\n      dc = dx * dx + dy * dy;\n  if (dc) {\n    var x = 0.5 + ((db *= db) - (da *= da)) / (2 * dc),\n        y = Math.sqrt(Math.max(0, 2 * da * (db + dc) - (db -= dc) * db - da * da)) / (2 * dc);\n    c.x = ax + x * dx + y * dy;\n    c.y = ay + x * dy - y * dx;\n  } else {\n    c.x = ax + db;\n    c.y = ay;\n  }\n}\n\nfunction intersects(a, b) {\n  var dx = b.x - a.x,\n      dy = b.y - a.y,\n      dr = a.r + b.r;\n  return dr * dr - 1e-6 > dx * dx + dy * dy;\n}\n\nfunction distance1(a, b) {\n  var l = a._.r;\n  while (a !== b) l += 2 * (a = a.next)._.r;\n  return l - b._.r;\n}\n\nfunction distance2(node, x, y) {\n  var a = node._,\n      b = node.next._,\n      ab = a.r + b.r,\n      dx = (a.x * b.r + b.x * a.r) / ab - x,\n      dy = (a.y * b.r + b.y * a.r) / ab - y;\n  return dx * dx + dy * dy;\n}\n\nfunction Node$1(circle) {\n  this._ = circle;\n  this.next = null;\n  this.previous = null;\n}\n\nfunction packEnclose(circles) {\n  if (!(n = circles.length)) return 0;\n\n  var a, b, c, n;\n\n  // Place the first circle.\n  a = circles[0], a.x = 0, a.y = 0;\n  if (!(n > 1)) return a.r;\n\n  // Place the second circle.\n  b = circles[1], a.x = -b.r, b.x = a.r, b.y = 0;\n  if (!(n > 2)) return a.r + b.r;\n\n  // Place the third circle.\n  place(b, a, c = circles[2]);\n\n  // Initialize the weighted centroid.\n  var aa = a.r * a.r,\n      ba = b.r * b.r,\n      ca = c.r * c.r,\n      oa = aa + ba + ca,\n      ox = aa * a.x + ba * b.x + ca * c.x,\n      oy = aa * a.y + ba * b.y + ca * c.y,\n      cx, cy, i, j, k, sj, sk;\n\n  // Initialize the front-chain using the first three circles a, b and c.\n  a = new Node$1(a), b = new Node$1(b), c = new Node$1(c);\n  a.next = c.previous = b;\n  b.next = a.previous = c;\n  c.next = b.previous = a;\n\n  // Attempt to place each remaining circle…\n  pack: for (i = 3; i < n; ++i) {\n    place(a._, b._, c = circles[i]), c = new Node$1(c);\n\n    // Find the closest intersecting circle on the front-chain, if any.\n    // “Closeness” is determined by linear distance along the front-chain.\n    // “Ahead” or “behind” is likewise determined by linear distance.\n    j = b.next, k = a.previous, sj = b._.r, sk = a._.r;\n    do {\n      if (sj <= sk) {\n        if (intersects(j._, c._)) {\n          if (sj + a._.r + b._.r > distance1(j, b)) a = j; else b = j;\n          a.next = b, b.previous = a, --i;\n          continue pack;\n        }\n        sj += j._.r, j = j.next;\n      } else {\n        if (intersects(k._, c._)) {\n          if (distance1(a, k) > sk + a._.r + b._.r) a = k; else b = k;\n          a.next = b, b.previous = a, --i;\n          continue pack;\n        }\n        sk += k._.r, k = k.previous;\n      }\n    } while (j !== k.next);\n\n    // Success! Insert the new circle c between a and b.\n    c.previous = a, c.next = b, a.next = b.previous = b = c;\n\n    // Update the weighted centroid.\n    oa += ca = c._.r * c._.r;\n    ox += ca * c._.x;\n    oy += ca * c._.y;\n\n    // Compute the new closest circle pair to the centroid.\n    aa = distance2(a, cx = ox / oa, cy = oy / oa);\n    while ((c = c.next) !== b) {\n      if ((ca = distance2(c, cx, cy)) < aa) {\n        a = c, aa = ca;\n      }\n    }\n    b = a.next;\n  }\n\n  // Compute the enclosing circle of the front chain.\n  a = [b._], c = b; while ((c = c.next) !== b) a.push(c._); c = enclose(a);\n\n  // Translate the circles to put the enclosing circle around the origin.\n  for (i = 0; i < n; ++i) a = circles[i], a.x -= c.x, a.y -= c.y;\n\n  return c.r;\n}\n\nvar siblings = function(circles) {\n  packEnclose(circles);\n  return circles;\n};\n\nfunction optional(f) {\n  return f == null ? null : required(f);\n}\n\nfunction required(f) {\n  if (typeof f !== \"function\") throw new Error;\n  return f;\n}\n\nfunction constantZero() {\n  return 0;\n}\n\nvar constant$8 = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nfunction defaultRadius$1(d) {\n  return Math.sqrt(d.value);\n}\n\nvar index$2 = function() {\n  var radius = null,\n      dx = 1,\n      dy = 1,\n      padding = constantZero;\n\n  function pack(root) {\n    root.x = dx / 2, root.y = dy / 2;\n    if (radius) {\n      root.eachBefore(radiusLeaf(radius))\n          .eachAfter(packChildren(padding, 0.5))\n          .eachBefore(translateChild(1));\n    } else {\n      root.eachBefore(radiusLeaf(defaultRadius$1))\n          .eachAfter(packChildren(constantZero, 1))\n          .eachAfter(packChildren(padding, root.r / Math.min(dx, dy)))\n          .eachBefore(translateChild(Math.min(dx, dy) / (2 * root.r)));\n    }\n    return root;\n  }\n\n  pack.radius = function(x) {\n    return arguments.length ? (radius = optional(x), pack) : radius;\n  };\n\n  pack.size = function(x) {\n    return arguments.length ? (dx = +x[0], dy = +x[1], pack) : [dx, dy];\n  };\n\n  pack.padding = function(x) {\n    return arguments.length ? (padding = typeof x === \"function\" ? x : constant$8(+x), pack) : padding;\n  };\n\n  return pack;\n};\n\nfunction radiusLeaf(radius) {\n  return function(node) {\n    if (!node.children) {\n      node.r = Math.max(0, +radius(node) || 0);\n    }\n  };\n}\n\nfunction packChildren(padding, k) {\n  return function(node) {\n    if (children = node.children) {\n      var children,\n          i,\n          n = children.length,\n          r = padding(node) * k || 0,\n          e;\n\n      if (r) for (i = 0; i < n; ++i) children[i].r += r;\n      e = packEnclose(children);\n      if (r) for (i = 0; i < n; ++i) children[i].r -= r;\n      node.r = e + r;\n    }\n  };\n}\n\nfunction translateChild(k) {\n  return function(node) {\n    var parent = node.parent;\n    node.r *= k;\n    if (parent) {\n      node.x = parent.x + k * node.x;\n      node.y = parent.y + k * node.y;\n    }\n  };\n}\n\nvar roundNode = function(node) {\n  node.x0 = Math.round(node.x0);\n  node.y0 = Math.round(node.y0);\n  node.x1 = Math.round(node.x1);\n  node.y1 = Math.round(node.y1);\n};\n\nvar treemapDice = function(parent, x0, y0, x1, y1) {\n  var nodes = parent.children,\n      node,\n      i = -1,\n      n = nodes.length,\n      k = parent.value && (x1 - x0) / parent.value;\n\n  while (++i < n) {\n    node = nodes[i], node.y0 = y0, node.y1 = y1;\n    node.x0 = x0, node.x1 = x0 += node.value * k;\n  }\n};\n\nvar partition = function() {\n  var dx = 1,\n      dy = 1,\n      padding = 0,\n      round = false;\n\n  function partition(root) {\n    var n = root.height + 1;\n    root.x0 =\n    root.y0 = padding;\n    root.x1 = dx;\n    root.y1 = dy / n;\n    root.eachBefore(positionNode(dy, n));\n    if (round) root.eachBefore(roundNode);\n    return root;\n  }\n\n  function positionNode(dy, n) {\n    return function(node) {\n      if (node.children) {\n        treemapDice(node, node.x0, dy * (node.depth + 1) / n, node.x1, dy * (node.depth + 2) / n);\n      }\n      var x0 = node.x0,\n          y0 = node.y0,\n          x1 = node.x1 - padding,\n          y1 = node.y1 - padding;\n      if (x1 < x0) x0 = x1 = (x0 + x1) / 2;\n      if (y1 < y0) y0 = y1 = (y0 + y1) / 2;\n      node.x0 = x0;\n      node.y0 = y0;\n      node.x1 = x1;\n      node.y1 = y1;\n    };\n  }\n\n  partition.round = function(x) {\n    return arguments.length ? (round = !!x, partition) : round;\n  };\n\n  partition.size = function(x) {\n    return arguments.length ? (dx = +x[0], dy = +x[1], partition) : [dx, dy];\n  };\n\n  partition.padding = function(x) {\n    return arguments.length ? (padding = +x, partition) : padding;\n  };\n\n  return partition;\n};\n\nvar keyPrefix$1 = \"$\";\nvar preroot = {depth: -1};\nvar ambiguous = {};\n\nfunction defaultId(d) {\n  return d.id;\n}\n\nfunction defaultParentId(d) {\n  return d.parentId;\n}\n\nvar stratify = function() {\n  var id = defaultId,\n      parentId = defaultParentId;\n\n  function stratify(data) {\n    var d,\n        i,\n        n = data.length,\n        root,\n        parent,\n        node,\n        nodes = new Array(n),\n        nodeId,\n        nodeKey,\n        nodeByKey = {};\n\n    for (i = 0; i < n; ++i) {\n      d = data[i], node = nodes[i] = new Node(d);\n      if ((nodeId = id(d, i, data)) != null && (nodeId += \"\")) {\n        nodeKey = keyPrefix$1 + (node.id = nodeId);\n        nodeByKey[nodeKey] = nodeKey in nodeByKey ? ambiguous : node;\n      }\n    }\n\n    for (i = 0; i < n; ++i) {\n      node = nodes[i], nodeId = parentId(data[i], i, data);\n      if (nodeId == null || !(nodeId += \"\")) {\n        if (root) throw new Error(\"multiple roots\");\n        root = node;\n      } else {\n        parent = nodeByKey[keyPrefix$1 + nodeId];\n        if (!parent) throw new Error(\"missing: \" + nodeId);\n        if (parent === ambiguous) throw new Error(\"ambiguous: \" + nodeId);\n        if (parent.children) parent.children.push(node);\n        else parent.children = [node];\n        node.parent = parent;\n      }\n    }\n\n    if (!root) throw new Error(\"no root\");\n    root.parent = preroot;\n    root.eachBefore(function(node) { node.depth = node.parent.depth + 1; --n; }).eachBefore(computeHeight);\n    root.parent = null;\n    if (n > 0) throw new Error(\"cycle\");\n\n    return root;\n  }\n\n  stratify.id = function(x) {\n    return arguments.length ? (id = required(x), stratify) : id;\n  };\n\n  stratify.parentId = function(x) {\n    return arguments.length ? (parentId = required(x), stratify) : parentId;\n  };\n\n  return stratify;\n};\n\nfunction defaultSeparation$1(a, b) {\n  return a.parent === b.parent ? 1 : 2;\n}\n\n// function radialSeparation(a, b) {\n//   return (a.parent === b.parent ? 1 : 2) / a.depth;\n// }\n\n// This function is used to traverse the left contour of a subtree (or\n// subforest). It returns the successor of v on this contour. This successor is\n// either given by the leftmost child of v or by the thread of v. The function\n// returns null if and only if v is on the highest level of its subtree.\nfunction nextLeft(v) {\n  var children = v.children;\n  return children ? children[0] : v.t;\n}\n\n// This function works analogously to nextLeft.\nfunction nextRight(v) {\n  var children = v.children;\n  return children ? children[children.length - 1] : v.t;\n}\n\n// Shifts the current subtree rooted at w+. This is done by increasing\n// prelim(w+) and mod(w+) by shift.\nfunction moveSubtree(wm, wp, shift) {\n  var change = shift / (wp.i - wm.i);\n  wp.c -= change;\n  wp.s += shift;\n  wm.c += change;\n  wp.z += shift;\n  wp.m += shift;\n}\n\n// All other shifts, applied to the smaller subtrees between w- and w+, are\n// performed by this function. To prepare the shifts, we have to adjust\n// change(w+), shift(w+), and change(w-).\nfunction executeShifts(v) {\n  var shift = 0,\n      change = 0,\n      children = v.children,\n      i = children.length,\n      w;\n  while (--i >= 0) {\n    w = children[i];\n    w.z += shift;\n    w.m += shift;\n    shift += w.s + (change += w.c);\n  }\n}\n\n// If vi-’s ancestor is a sibling of v, returns vi-’s ancestor. Otherwise,\n// returns the specified (default) ancestor.\nfunction nextAncestor(vim, v, ancestor) {\n  return vim.a.parent === v.parent ? vim.a : ancestor;\n}\n\nfunction TreeNode(node, i) {\n  this._ = node;\n  this.parent = null;\n  this.children = null;\n  this.A = null; // default ancestor\n  this.a = this; // ancestor\n  this.z = 0; // prelim\n  this.m = 0; // mod\n  this.c = 0; // change\n  this.s = 0; // shift\n  this.t = null; // thread\n  this.i = i; // number\n}\n\nTreeNode.prototype = Object.create(Node.prototype);\n\nfunction treeRoot(root) {\n  var tree = new TreeNode(root, 0),\n      node,\n      nodes = [tree],\n      child,\n      children,\n      i,\n      n;\n\n  while (node = nodes.pop()) {\n    if (children = node._.children) {\n      node.children = new Array(n = children.length);\n      for (i = n - 1; i >= 0; --i) {\n        nodes.push(child = node.children[i] = new TreeNode(children[i], i));\n        child.parent = node;\n      }\n    }\n  }\n\n  (tree.parent = new TreeNode(null, 0)).children = [tree];\n  return tree;\n}\n\n// Node-link tree diagram using the Reingold-Tilford \"tidy\" algorithm\nvar tree = function() {\n  var separation = defaultSeparation$1,\n      dx = 1,\n      dy = 1,\n      nodeSize = null;\n\n  function tree(root) {\n    var t = treeRoot(root);\n\n    // Compute the layout using Buchheim et al.’s algorithm.\n    t.eachAfter(firstWalk), t.parent.m = -t.z;\n    t.eachBefore(secondWalk);\n\n    // If a fixed node size is specified, scale x and y.\n    if (nodeSize) root.eachBefore(sizeNode);\n\n    // If a fixed tree size is specified, scale x and y based on the extent.\n    // Compute the left-most, right-most, and depth-most nodes for extents.\n    else {\n      var left = root,\n          right = root,\n          bottom = root;\n      root.eachBefore(function(node) {\n        if (node.x < left.x) left = node;\n        if (node.x > right.x) right = node;\n        if (node.depth > bottom.depth) bottom = node;\n      });\n      var s = left === right ? 1 : separation(left, right) / 2,\n          tx = s - left.x,\n          kx = dx / (right.x + s + tx),\n          ky = dy / (bottom.depth || 1);\n      root.eachBefore(function(node) {\n        node.x = (node.x + tx) * kx;\n        node.y = node.depth * ky;\n      });\n    }\n\n    return root;\n  }\n\n  // Computes a preliminary x-coordinate for v. Before that, FIRST WALK is\n  // applied recursively to the children of v, as well as the function\n  // APPORTION. After spacing out the children by calling EXECUTE SHIFTS, the\n  // node v is placed to the midpoint of its outermost children.\n  function firstWalk(v) {\n    var children = v.children,\n        siblings = v.parent.children,\n        w = v.i ? siblings[v.i - 1] : null;\n    if (children) {\n      executeShifts(v);\n      var midpoint = (children[0].z + children[children.length - 1].z) / 2;\n      if (w) {\n        v.z = w.z + separation(v._, w._);\n        v.m = v.z - midpoint;\n      } else {\n        v.z = midpoint;\n      }\n    } else if (w) {\n      v.z = w.z + separation(v._, w._);\n    }\n    v.parent.A = apportion(v, w, v.parent.A || siblings[0]);\n  }\n\n  // Computes all real x-coordinates by summing up the modifiers recursively.\n  function secondWalk(v) {\n    v._.x = v.z + v.parent.m;\n    v.m += v.parent.m;\n  }\n\n  // The core of the algorithm. Here, a new subtree is combined with the\n  // previous subtrees. Threads are used to traverse the inside and outside\n  // contours of the left and right subtree up to the highest common level. The\n  // vertices used for the traversals are vi+, vi-, vo-, and vo+, where the\n  // superscript o means outside and i means inside, the subscript - means left\n  // subtree and + means right subtree. For summing up the modifiers along the\n  // contour, we use respective variables si+, si-, so-, and so+. Whenever two\n  // nodes of the inside contours conflict, we compute the left one of the\n  // greatest uncommon ancestors using the function ANCESTOR and call MOVE\n  // SUBTREE to shift the subtree and prepare the shifts of smaller subtrees.\n  // Finally, we add a new thread (if necessary).\n  function apportion(v, w, ancestor) {\n    if (w) {\n      var vip = v,\n          vop = v,\n          vim = w,\n          vom = vip.parent.children[0],\n          sip = vip.m,\n          sop = vop.m,\n          sim = vim.m,\n          som = vom.m,\n          shift;\n      while (vim = nextRight(vim), vip = nextLeft(vip), vim && vip) {\n        vom = nextLeft(vom);\n        vop = nextRight(vop);\n        vop.a = v;\n        shift = vim.z + sim - vip.z - sip + separation(vim._, vip._);\n        if (shift > 0) {\n          moveSubtree(nextAncestor(vim, v, ancestor), v, shift);\n          sip += shift;\n          sop += shift;\n        }\n        sim += vim.m;\n        sip += vip.m;\n        som += vom.m;\n        sop += vop.m;\n      }\n      if (vim && !nextRight(vop)) {\n        vop.t = vim;\n        vop.m += sim - sop;\n      }\n      if (vip && !nextLeft(vom)) {\n        vom.t = vip;\n        vom.m += sip - som;\n        ancestor = v;\n      }\n    }\n    return ancestor;\n  }\n\n  function sizeNode(node) {\n    node.x *= dx;\n    node.y = node.depth * dy;\n  }\n\n  tree.separation = function(x) {\n    return arguments.length ? (separation = x, tree) : separation;\n  };\n\n  tree.size = function(x) {\n    return arguments.length ? (nodeSize = false, dx = +x[0], dy = +x[1], tree) : (nodeSize ? null : [dx, dy]);\n  };\n\n  tree.nodeSize = function(x) {\n    return arguments.length ? (nodeSize = true, dx = +x[0], dy = +x[1], tree) : (nodeSize ? [dx, dy] : null);\n  };\n\n  return tree;\n};\n\nvar treemapSlice = function(parent, x0, y0, x1, y1) {\n  var nodes = parent.children,\n      node,\n      i = -1,\n      n = nodes.length,\n      k = parent.value && (y1 - y0) / parent.value;\n\n  while (++i < n) {\n    node = nodes[i], node.x0 = x0, node.x1 = x1;\n    node.y0 = y0, node.y1 = y0 += node.value * k;\n  }\n};\n\nvar phi = (1 + Math.sqrt(5)) / 2;\n\nfunction squarifyRatio(ratio, parent, x0, y0, x1, y1) {\n  var rows = [],\n      nodes = parent.children,\n      row,\n      nodeValue,\n      i0 = 0,\n      i1 = 0,\n      n = nodes.length,\n      dx, dy,\n      value = parent.value,\n      sumValue,\n      minValue,\n      maxValue,\n      newRatio,\n      minRatio,\n      alpha,\n      beta;\n\n  while (i0 < n) {\n    dx = x1 - x0, dy = y1 - y0;\n\n    // Find the next non-empty node.\n    do sumValue = nodes[i1++].value; while (!sumValue && i1 < n);\n    minValue = maxValue = sumValue;\n    alpha = Math.max(dy / dx, dx / dy) / (value * ratio);\n    beta = sumValue * sumValue * alpha;\n    minRatio = Math.max(maxValue / beta, beta / minValue);\n\n    // Keep adding nodes while the aspect ratio maintains or improves.\n    for (; i1 < n; ++i1) {\n      sumValue += nodeValue = nodes[i1].value;\n      if (nodeValue < minValue) minValue = nodeValue;\n      if (nodeValue > maxValue) maxValue = nodeValue;\n      beta = sumValue * sumValue * alpha;\n      newRatio = Math.max(maxValue / beta, beta / minValue);\n      if (newRatio > minRatio) { sumValue -= nodeValue; break; }\n      minRatio = newRatio;\n    }\n\n    // Position and record the row orientation.\n    rows.push(row = {value: sumValue, dice: dx < dy, children: nodes.slice(i0, i1)});\n    if (row.dice) treemapDice(row, x0, y0, x1, value ? y0 += dy * sumValue / value : y1);\n    else treemapSlice(row, x0, y0, value ? x0 += dx * sumValue / value : x1, y1);\n    value -= sumValue, i0 = i1;\n  }\n\n  return rows;\n}\n\nvar squarify = ((function custom(ratio) {\n\n  function squarify(parent, x0, y0, x1, y1) {\n    squarifyRatio(ratio, parent, x0, y0, x1, y1);\n  }\n\n  squarify.ratio = function(x) {\n    return custom((x = +x) > 1 ? x : 1);\n  };\n\n  return squarify;\n}))(phi);\n\nvar index$3 = function() {\n  var tile = squarify,\n      round = false,\n      dx = 1,\n      dy = 1,\n      paddingStack = [0],\n      paddingInner = constantZero,\n      paddingTop = constantZero,\n      paddingRight = constantZero,\n      paddingBottom = constantZero,\n      paddingLeft = constantZero;\n\n  function treemap(root) {\n    root.x0 =\n    root.y0 = 0;\n    root.x1 = dx;\n    root.y1 = dy;\n    root.eachBefore(positionNode);\n    paddingStack = [0];\n    if (round) root.eachBefore(roundNode);\n    return root;\n  }\n\n  function positionNode(node) {\n    var p = paddingStack[node.depth],\n        x0 = node.x0 + p,\n        y0 = node.y0 + p,\n        x1 = node.x1 - p,\n        y1 = node.y1 - p;\n    if (x1 < x0) x0 = x1 = (x0 + x1) / 2;\n    if (y1 < y0) y0 = y1 = (y0 + y1) / 2;\n    node.x0 = x0;\n    node.y0 = y0;\n    node.x1 = x1;\n    node.y1 = y1;\n    if (node.children) {\n      p = paddingStack[node.depth + 1] = paddingInner(node) / 2;\n      x0 += paddingLeft(node) - p;\n      y0 += paddingTop(node) - p;\n      x1 -= paddingRight(node) - p;\n      y1 -= paddingBottom(node) - p;\n      if (x1 < x0) x0 = x1 = (x0 + x1) / 2;\n      if (y1 < y0) y0 = y1 = (y0 + y1) / 2;\n      tile(node, x0, y0, x1, y1);\n    }\n  }\n\n  treemap.round = function(x) {\n    return arguments.length ? (round = !!x, treemap) : round;\n  };\n\n  treemap.size = function(x) {\n    return arguments.length ? (dx = +x[0], dy = +x[1], treemap) : [dx, dy];\n  };\n\n  treemap.tile = function(x) {\n    return arguments.length ? (tile = required(x), treemap) : tile;\n  };\n\n  treemap.padding = function(x) {\n    return arguments.length ? treemap.paddingInner(x).paddingOuter(x) : treemap.paddingInner();\n  };\n\n  treemap.paddingInner = function(x) {\n    return arguments.length ? (paddingInner = typeof x === \"function\" ? x : constant$8(+x), treemap) : paddingInner;\n  };\n\n  treemap.paddingOuter = function(x) {\n    return arguments.length ? treemap.paddingTop(x).paddingRight(x).paddingBottom(x).paddingLeft(x) : treemap.paddingTop();\n  };\n\n  treemap.paddingTop = function(x) {\n    return arguments.length ? (paddingTop = typeof x === \"function\" ? x : constant$8(+x), treemap) : paddingTop;\n  };\n\n  treemap.paddingRight = function(x) {\n    return arguments.length ? (paddingRight = typeof x === \"function\" ? x : constant$8(+x), treemap) : paddingRight;\n  };\n\n  treemap.paddingBottom = function(x) {\n    return arguments.length ? (paddingBottom = typeof x === \"function\" ? x : constant$8(+x), treemap) : paddingBottom;\n  };\n\n  treemap.paddingLeft = function(x) {\n    return arguments.length ? (paddingLeft = typeof x === \"function\" ? x : constant$8(+x), treemap) : paddingLeft;\n  };\n\n  return treemap;\n};\n\nvar binary = function(parent, x0, y0, x1, y1) {\n  var nodes = parent.children,\n      i, n = nodes.length,\n      sum, sums = new Array(n + 1);\n\n  for (sums[0] = sum = i = 0; i < n; ++i) {\n    sums[i + 1] = sum += nodes[i].value;\n  }\n\n  partition(0, n, parent.value, x0, y0, x1, y1);\n\n  function partition(i, j, value, x0, y0, x1, y1) {\n    if (i >= j - 1) {\n      var node = nodes[i];\n      node.x0 = x0, node.y0 = y0;\n      node.x1 = x1, node.y1 = y1;\n      return;\n    }\n\n    var valueOffset = sums[i],\n        valueTarget = (value / 2) + valueOffset,\n        k = i + 1,\n        hi = j - 1;\n\n    while (k < hi) {\n      var mid = k + hi >>> 1;\n      if (sums[mid] < valueTarget) k = mid + 1;\n      else hi = mid;\n    }\n\n    var valueLeft = sums[k] - valueOffset,\n        valueRight = value - valueLeft;\n\n    if ((y1 - y0) > (x1 - x0)) {\n      var yk = (y0 * valueRight + y1 * valueLeft) / value;\n      partition(i, k, valueLeft, x0, y0, x1, yk);\n      partition(k, j, valueRight, x0, yk, x1, y1);\n    } else {\n      var xk = (x0 * valueRight + x1 * valueLeft) / value;\n      partition(i, k, valueLeft, x0, y0, xk, y1);\n      partition(k, j, valueRight, xk, y0, x1, y1);\n    }\n  }\n};\n\nvar sliceDice = function(parent, x0, y0, x1, y1) {\n  (parent.depth & 1 ? treemapSlice : treemapDice)(parent, x0, y0, x1, y1);\n};\n\nvar resquarify = ((function custom(ratio) {\n\n  function resquarify(parent, x0, y0, x1, y1) {\n    if ((rows = parent._squarify) && (rows.ratio === ratio)) {\n      var rows,\n          row,\n          nodes,\n          i,\n          j = -1,\n          n,\n          m = rows.length,\n          value = parent.value;\n\n      while (++j < m) {\n        row = rows[j], nodes = row.children;\n        for (i = row.value = 0, n = nodes.length; i < n; ++i) row.value += nodes[i].value;\n        if (row.dice) treemapDice(row, x0, y0, x1, y0 += (y1 - y0) * row.value / value);\n        else treemapSlice(row, x0, y0, x0 += (x1 - x0) * row.value / value, y1);\n        value -= row.value;\n      }\n    } else {\n      parent._squarify = rows = squarifyRatio(ratio, parent, x0, y0, x1, y1);\n      rows.ratio = ratio;\n    }\n  }\n\n  resquarify.ratio = function(x) {\n    return custom((x = +x) > 1 ? x : 1);\n  };\n\n  return resquarify;\n}))(phi);\n\nvar area$1 = function(polygon) {\n  var i = -1,\n      n = polygon.length,\n      a,\n      b = polygon[n - 1],\n      area = 0;\n\n  while (++i < n) {\n    a = b;\n    b = polygon[i];\n    area += a[1] * b[0] - a[0] * b[1];\n  }\n\n  return area / 2;\n};\n\nvar centroid$1 = function(polygon) {\n  var i = -1,\n      n = polygon.length,\n      x = 0,\n      y = 0,\n      a,\n      b = polygon[n - 1],\n      c,\n      k = 0;\n\n  while (++i < n) {\n    a = b;\n    b = polygon[i];\n    k += c = a[0] * b[1] - b[0] * a[1];\n    x += (a[0] + b[0]) * c;\n    y += (a[1] + b[1]) * c;\n  }\n\n  return k *= 3, [x / k, y / k];\n};\n\n// Returns the 2D cross product of AB and AC vectors, i.e., the z-component of\n// the 3D cross product in a quadrant I Cartesian coordinate system (+x is\n// right, +y is up). Returns a positive value if ABC is counter-clockwise,\n// negative if clockwise, and zero if the points are collinear.\nvar cross = function(a, b, c) {\n  return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);\n};\n\nfunction lexicographicOrder(a, b) {\n  return a[0] - b[0] || a[1] - b[1];\n}\n\n// Computes the upper convex hull per the monotone chain algorithm.\n// Assumes points.length >= 3, is sorted by x, unique in y.\n// Returns an array of indices into points in left-to-right order.\nfunction computeUpperHullIndexes(points) {\n  var n = points.length,\n      indexes = [0, 1],\n      size = 2;\n\n  for (var i = 2; i < n; ++i) {\n    while (size > 1 && cross(points[indexes[size - 2]], points[indexes[size - 1]], points[i]) <= 0) --size;\n    indexes[size++] = i;\n  }\n\n  return indexes.slice(0, size); // remove popped points\n}\n\nvar hull = function(points) {\n  if ((n = points.length) < 3) return null;\n\n  var i,\n      n,\n      sortedPoints = new Array(n),\n      flippedPoints = new Array(n);\n\n  for (i = 0; i < n; ++i) sortedPoints[i] = [+points[i][0], +points[i][1], i];\n  sortedPoints.sort(lexicographicOrder);\n  for (i = 0; i < n; ++i) flippedPoints[i] = [sortedPoints[i][0], -sortedPoints[i][1]];\n\n  var upperIndexes = computeUpperHullIndexes(sortedPoints),\n      lowerIndexes = computeUpperHullIndexes(flippedPoints);\n\n  // Construct the hull polygon, removing possible duplicate endpoints.\n  var skipLeft = lowerIndexes[0] === upperIndexes[0],\n      skipRight = lowerIndexes[lowerIndexes.length - 1] === upperIndexes[upperIndexes.length - 1],\n      hull = [];\n\n  // Add upper hull in right-to-l order.\n  // Then add lower hull in left-to-right order.\n  for (i = upperIndexes.length - 1; i >= 0; --i) hull.push(points[sortedPoints[upperIndexes[i]][2]]);\n  for (i = +skipLeft; i < lowerIndexes.length - skipRight; ++i) hull.push(points[sortedPoints[lowerIndexes[i]][2]]);\n\n  return hull;\n};\n\nvar contains = function(polygon, point) {\n  var n = polygon.length,\n      p = polygon[n - 1],\n      x = point[0], y = point[1],\n      x0 = p[0], y0 = p[1],\n      x1, y1,\n      inside = false;\n\n  for (var i = 0; i < n; ++i) {\n    p = polygon[i], x1 = p[0], y1 = p[1];\n    if (((y1 > y) !== (y0 > y)) && (x < (x0 - x1) * (y - y1) / (y0 - y1) + x1)) inside = !inside;\n    x0 = x1, y0 = y1;\n  }\n\n  return inside;\n};\n\nvar length$2 = function(polygon) {\n  var i = -1,\n      n = polygon.length,\n      b = polygon[n - 1],\n      xa,\n      ya,\n      xb = b[0],\n      yb = b[1],\n      perimeter = 0;\n\n  while (++i < n) {\n    xa = xb;\n    ya = yb;\n    b = polygon[i];\n    xb = b[0];\n    yb = b[1];\n    xa -= xb;\n    ya -= yb;\n    perimeter += Math.sqrt(xa * xa + ya * ya);\n  }\n\n  return perimeter;\n};\n\nvar slice$3 = [].slice;\n\nvar noabort = {};\n\nfunction Queue(size) {\n  if (!(size >= 1)) throw new Error;\n  this._size = size;\n  this._call =\n  this._error = null;\n  this._tasks = [];\n  this._data = [];\n  this._waiting =\n  this._active =\n  this._ended =\n  this._start = 0; // inside a synchronous task callback?\n}\n\nQueue.prototype = queue.prototype = {\n  constructor: Queue,\n  defer: function(callback) {\n    if (typeof callback !== \"function\" || this._call) throw new Error;\n    if (this._error != null) return this;\n    var t = slice$3.call(arguments, 1);\n    t.push(callback);\n    ++this._waiting, this._tasks.push(t);\n    poke$1(this);\n    return this;\n  },\n  abort: function() {\n    if (this._error == null) abort(this, new Error(\"abort\"));\n    return this;\n  },\n  await: function(callback) {\n    if (typeof callback !== \"function\" || this._call) throw new Error;\n    this._call = function(error, results) { callback.apply(null, [error].concat(results)); };\n    maybeNotify(this);\n    return this;\n  },\n  awaitAll: function(callback) {\n    if (typeof callback !== \"function\" || this._call) throw new Error;\n    this._call = callback;\n    maybeNotify(this);\n    return this;\n  }\n};\n\nfunction poke$1(q) {\n  if (!q._start) {\n    try { start$1(q); } // let the current task complete\n    catch (e) {\n      if (q._tasks[q._ended + q._active - 1]) abort(q, e); // task errored synchronously\n      else if (!q._data) throw e; // await callback errored synchronously\n    }\n  }\n}\n\nfunction start$1(q) {\n  while (q._start = q._waiting && q._active < q._size) {\n    var i = q._ended + q._active,\n        t = q._tasks[i],\n        j = t.length - 1,\n        c = t[j];\n    t[j] = end(q, i);\n    --q._waiting, ++q._active;\n    t = c.apply(null, t);\n    if (!q._tasks[i]) continue; // task finished synchronously\n    q._tasks[i] = t || noabort;\n  }\n}\n\nfunction end(q, i) {\n  return function(e, r) {\n    if (!q._tasks[i]) return; // ignore multiple callbacks\n    --q._active, ++q._ended;\n    q._tasks[i] = null;\n    if (q._error != null) return; // ignore secondary errors\n    if (e != null) {\n      abort(q, e);\n    } else {\n      q._data[i] = r;\n      if (q._waiting) poke$1(q);\n      else maybeNotify(q);\n    }\n  };\n}\n\nfunction abort(q, e) {\n  var i = q._tasks.length, t;\n  q._error = e; // ignore active callbacks\n  q._data = undefined; // allow gc\n  q._waiting = NaN; // prevent starting\n\n  while (--i >= 0) {\n    if (t = q._tasks[i]) {\n      q._tasks[i] = null;\n      if (t.abort) {\n        try { t.abort(); }\n        catch (e) { /* ignore */ }\n      }\n    }\n  }\n\n  q._active = NaN; // allow notification\n  maybeNotify(q);\n}\n\nfunction maybeNotify(q) {\n  if (!q._active && q._call) {\n    var d = q._data;\n    q._data = undefined; // allow gc\n    q._call(q._error, d);\n  }\n}\n\nfunction queue(concurrency) {\n  return new Queue(arguments.length ? +concurrency : Infinity);\n}\n\nvar uniform = function(min, max) {\n  min = min == null ? 0 : +min;\n  max = max == null ? 1 : +max;\n  if (arguments.length === 1) max = min, min = 0;\n  else max -= min;\n  return function() {\n    return Math.random() * max + min;\n  };\n};\n\nvar normal = function(mu, sigma) {\n  var x, r;\n  mu = mu == null ? 0 : +mu;\n  sigma = sigma == null ? 1 : +sigma;\n  return function() {\n    var y;\n\n    // If available, use the second previously-generated uniform random.\n    if (x != null) y = x, x = null;\n\n    // Otherwise, generate a new x and y.\n    else do {\n      x = Math.random() * 2 - 1;\n      y = Math.random() * 2 - 1;\n      r = x * x + y * y;\n    } while (!r || r > 1);\n\n    return mu + sigma * y * Math.sqrt(-2 * Math.log(r) / r);\n  };\n};\n\nvar logNormal = function() {\n  var randomNormal = normal.apply(this, arguments);\n  return function() {\n    return Math.exp(randomNormal());\n  };\n};\n\nvar irwinHall = function(n) {\n  return function() {\n    for (var sum = 0, i = 0; i < n; ++i) sum += Math.random();\n    return sum;\n  };\n};\n\nvar bates = function(n) {\n  var randomIrwinHall = irwinHall(n);\n  return function() {\n    return randomIrwinHall() / n;\n  };\n};\n\nvar exponential$1 = function(lambda) {\n  return function() {\n    return -Math.log(1 - Math.random()) / lambda;\n  };\n};\n\nvar request = function(url, callback) {\n  var request,\n      event = dispatch(\"beforesend\", \"progress\", \"load\", \"error\"),\n      mimeType,\n      headers = map$1(),\n      xhr = new XMLHttpRequest,\n      user = null,\n      password = null,\n      response,\n      responseType,\n      timeout = 0;\n\n  // If IE does not support CORS, use XDomainRequest.\n  if (typeof XDomainRequest !== \"undefined\"\n      && !(\"withCredentials\" in xhr)\n      && /^(http(s)?:)?\\/\\//.test(url)) xhr = new XDomainRequest;\n\n  \"onload\" in xhr\n      ? xhr.onload = xhr.onerror = xhr.ontimeout = respond\n      : xhr.onreadystatechange = function(o) { xhr.readyState > 3 && respond(o); };\n\n  function respond(o) {\n    var status = xhr.status, result;\n    if (!status && hasResponse(xhr)\n        || status >= 200 && status < 300\n        || status === 304) {\n      if (response) {\n        try {\n          result = response.call(request, xhr);\n        } catch (e) {\n          event.call(\"error\", request, e);\n          return;\n        }\n      } else {\n        result = xhr;\n      }\n      event.call(\"load\", request, result);\n    } else {\n      event.call(\"error\", request, o);\n    }\n  }\n\n  xhr.onprogress = function(e) {\n    event.call(\"progress\", request, e);\n  };\n\n  request = {\n    header: function(name, value) {\n      name = (name + \"\").toLowerCase();\n      if (arguments.length < 2) return headers.get(name);\n      if (value == null) headers.remove(name);\n      else headers.set(name, value + \"\");\n      return request;\n    },\n\n    // If mimeType is non-null and no Accept header is set, a default is used.\n    mimeType: function(value) {\n      if (!arguments.length) return mimeType;\n      mimeType = value == null ? null : value + \"\";\n      return request;\n    },\n\n    // Specifies what type the response value should take;\n    // for instance, arraybuffer, blob, document, or text.\n    responseType: function(value) {\n      if (!arguments.length) return responseType;\n      responseType = value;\n      return request;\n    },\n\n    timeout: function(value) {\n      if (!arguments.length) return timeout;\n      timeout = +value;\n      return request;\n    },\n\n    user: function(value) {\n      return arguments.length < 1 ? user : (user = value == null ? null : value + \"\", request);\n    },\n\n    password: function(value) {\n      return arguments.length < 1 ? password : (password = value == null ? null : value + \"\", request);\n    },\n\n    // Specify how to convert the response content to a specific type;\n    // changes the callback value on \"load\" events.\n    response: function(value) {\n      response = value;\n      return request;\n    },\n\n    // Alias for send(\"GET\", …).\n    get: function(data, callback) {\n      return request.send(\"GET\", data, callback);\n    },\n\n    // Alias for send(\"POST\", …).\n    post: function(data, callback) {\n      return request.send(\"POST\", data, callback);\n    },\n\n    // If callback is non-null, it will be used for error and load events.\n    send: function(method, data, callback) {\n      xhr.open(method, url, true, user, password);\n      if (mimeType != null && !headers.has(\"accept\")) headers.set(\"accept\", mimeType + \",*/*\");\n      if (xhr.setRequestHeader) headers.each(function(value, name) { xhr.setRequestHeader(name, value); });\n      if (mimeType != null && xhr.overrideMimeType) xhr.overrideMimeType(mimeType);\n      if (responseType != null) xhr.responseType = responseType;\n      if (timeout > 0) xhr.timeout = timeout;\n      if (callback == null && typeof data === \"function\") callback = data, data = null;\n      if (callback != null && callback.length === 1) callback = fixCallback(callback);\n      if (callback != null) request.on(\"error\", callback).on(\"load\", function(xhr) { callback(null, xhr); });\n      event.call(\"beforesend\", request, xhr);\n      xhr.send(data == null ? null : data);\n      return request;\n    },\n\n    abort: function() {\n      xhr.abort();\n      return request;\n    },\n\n    on: function() {\n      var value = event.on.apply(event, arguments);\n      return value === event ? request : value;\n    }\n  };\n\n  if (callback != null) {\n    if (typeof callback !== \"function\") throw new Error(\"invalid callback: \" + callback);\n    return request.get(callback);\n  }\n\n  return request;\n};\n\nfunction fixCallback(callback) {\n  return function(error, xhr) {\n    callback(error == null ? xhr : null);\n  };\n}\n\nfunction hasResponse(xhr) {\n  var type = xhr.responseType;\n  return type && type !== \"text\"\n      ? xhr.response // null on error\n      : xhr.responseText; // \"\" on error\n}\n\nvar type$1 = function(defaultMimeType, response) {\n  return function(url, callback) {\n    var r = request(url).mimeType(defaultMimeType).response(response);\n    if (callback != null) {\n      if (typeof callback !== \"function\") throw new Error(\"invalid callback: \" + callback);\n      return r.get(callback);\n    }\n    return r;\n  };\n};\n\nvar html = type$1(\"text/html\", function(xhr) {\n  return document.createRange().createContextualFragment(xhr.responseText);\n});\n\nvar json = type$1(\"application/json\", function(xhr) {\n  return JSON.parse(xhr.responseText);\n});\n\nvar text = type$1(\"text/plain\", function(xhr) {\n  return xhr.responseText;\n});\n\nvar xml = type$1(\"application/xml\", function(xhr) {\n  var xml = xhr.responseXML;\n  if (!xml) throw new Error(\"parse error\");\n  return xml;\n});\n\nvar dsv$1 = function(defaultMimeType, parse) {\n  return function(url, row, callback) {\n    if (arguments.length < 3) callback = row, row = null;\n    var r = request(url).mimeType(defaultMimeType);\n    r.row = function(_) { return arguments.length ? r.response(responseOf(parse, row = _)) : row; };\n    r.row(row);\n    return callback ? r.get(callback) : r;\n  };\n};\n\nfunction responseOf(parse, row) {\n  return function(request$$1) {\n    return parse(request$$1.responseText, row);\n  };\n}\n\nvar csv$1 = dsv$1(\"text/csv\", csvParse);\n\nvar tsv$1 = dsv$1(\"text/tab-separated-values\", tsvParse);\n\nvar array$2 = Array.prototype;\n\nvar map$3 = array$2.map;\nvar slice$4 = array$2.slice;\n\nvar implicit = {name: \"implicit\"};\n\nfunction ordinal(range) {\n  var index = map$1(),\n      domain = [],\n      unknown = implicit;\n\n  range = range == null ? [] : slice$4.call(range);\n\n  function scale(d) {\n    var key = d + \"\", i = index.get(key);\n    if (!i) {\n      if (unknown !== implicit) return unknown;\n      index.set(key, i = domain.push(d));\n    }\n    return range[(i - 1) % range.length];\n  }\n\n  scale.domain = function(_) {\n    if (!arguments.length) return domain.slice();\n    domain = [], index = map$1();\n    var i = -1, n = _.length, d, key;\n    while (++i < n) if (!index.has(key = (d = _[i]) + \"\")) index.set(key, domain.push(d));\n    return scale;\n  };\n\n  scale.range = function(_) {\n    return arguments.length ? (range = slice$4.call(_), scale) : range.slice();\n  };\n\n  scale.unknown = function(_) {\n    return arguments.length ? (unknown = _, scale) : unknown;\n  };\n\n  scale.copy = function() {\n    return ordinal()\n        .domain(domain)\n        .range(range)\n        .unknown(unknown);\n  };\n\n  return scale;\n}\n\nfunction band() {\n  var scale = ordinal().unknown(undefined),\n      domain = scale.domain,\n      ordinalRange = scale.range,\n      range$$1 = [0, 1],\n      step,\n      bandwidth,\n      round = false,\n      paddingInner = 0,\n      paddingOuter = 0,\n      align = 0.5;\n\n  delete scale.unknown;\n\n  function rescale() {\n    var n = domain().length,\n        reverse = range$$1[1] < range$$1[0],\n        start = range$$1[reverse - 0],\n        stop = range$$1[1 - reverse];\n    step = (stop - start) / Math.max(1, n - paddingInner + paddingOuter * 2);\n    if (round) step = Math.floor(step);\n    start += (stop - start - step * (n - paddingInner)) * align;\n    bandwidth = step * (1 - paddingInner);\n    if (round) start = Math.round(start), bandwidth = Math.round(bandwidth);\n    var values = sequence(n).map(function(i) { return start + step * i; });\n    return ordinalRange(reverse ? values.reverse() : values);\n  }\n\n  scale.domain = function(_) {\n    return arguments.length ? (domain(_), rescale()) : domain();\n  };\n\n  scale.range = function(_) {\n    return arguments.length ? (range$$1 = [+_[0], +_[1]], rescale()) : range$$1.slice();\n  };\n\n  scale.rangeRound = function(_) {\n    return range$$1 = [+_[0], +_[1]], round = true, rescale();\n  };\n\n  scale.bandwidth = function() {\n    return bandwidth;\n  };\n\n  scale.step = function() {\n    return step;\n  };\n\n  scale.round = function(_) {\n    return arguments.length ? (round = !!_, rescale()) : round;\n  };\n\n  scale.padding = function(_) {\n    return arguments.length ? (paddingInner = paddingOuter = Math.max(0, Math.min(1, _)), rescale()) : paddingInner;\n  };\n\n  scale.paddingInner = function(_) {\n    return arguments.length ? (paddingInner = Math.max(0, Math.min(1, _)), rescale()) : paddingInner;\n  };\n\n  scale.paddingOuter = function(_) {\n    return arguments.length ? (paddingOuter = Math.max(0, Math.min(1, _)), rescale()) : paddingOuter;\n  };\n\n  scale.align = function(_) {\n    return arguments.length ? (align = Math.max(0, Math.min(1, _)), rescale()) : align;\n  };\n\n  scale.copy = function() {\n    return band()\n        .domain(domain())\n        .range(range$$1)\n        .round(round)\n        .paddingInner(paddingInner)\n        .paddingOuter(paddingOuter)\n        .align(align);\n  };\n\n  return rescale();\n}\n\nfunction pointish(scale) {\n  var copy = scale.copy;\n\n  scale.padding = scale.paddingOuter;\n  delete scale.paddingInner;\n  delete scale.paddingOuter;\n\n  scale.copy = function() {\n    return pointish(copy());\n  };\n\n  return scale;\n}\n\nfunction point$1() {\n  return pointish(band().paddingInner(1));\n}\n\nvar constant$9 = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nvar number$1 = function(x) {\n  return +x;\n};\n\nvar unit = [0, 1];\n\nfunction deinterpolateLinear(a, b) {\n  return (b -= (a = +a))\n      ? function(x) { return (x - a) / b; }\n      : constant$9(b);\n}\n\nfunction deinterpolateClamp(deinterpolate) {\n  return function(a, b) {\n    var d = deinterpolate(a = +a, b = +b);\n    return function(x) { return x <= a ? 0 : x >= b ? 1 : d(x); };\n  };\n}\n\nfunction reinterpolateClamp(reinterpolate) {\n  return function(a, b) {\n    var r = reinterpolate(a = +a, b = +b);\n    return function(t) { return t <= 0 ? a : t >= 1 ? b : r(t); };\n  };\n}\n\nfunction bimap(domain, range$$1, deinterpolate, reinterpolate) {\n  var d0 = domain[0], d1 = domain[1], r0 = range$$1[0], r1 = range$$1[1];\n  if (d1 < d0) d0 = deinterpolate(d1, d0), r0 = reinterpolate(r1, r0);\n  else d0 = deinterpolate(d0, d1), r0 = reinterpolate(r0, r1);\n  return function(x) { return r0(d0(x)); };\n}\n\nfunction polymap(domain, range$$1, deinterpolate, reinterpolate) {\n  var j = Math.min(domain.length, range$$1.length) - 1,\n      d = new Array(j),\n      r = new Array(j),\n      i = -1;\n\n  // Reverse descending domains.\n  if (domain[j] < domain[0]) {\n    domain = domain.slice().reverse();\n    range$$1 = range$$1.slice().reverse();\n  }\n\n  while (++i < j) {\n    d[i] = deinterpolate(domain[i], domain[i + 1]);\n    r[i] = reinterpolate(range$$1[i], range$$1[i + 1]);\n  }\n\n  return function(x) {\n    var i = bisectRight(domain, x, 1, j) - 1;\n    return r[i](d[i](x));\n  };\n}\n\nfunction copy(source, target) {\n  return target\n      .domain(source.domain())\n      .range(source.range())\n      .interpolate(source.interpolate())\n      .clamp(source.clamp());\n}\n\n// deinterpolate(a, b)(x) takes a domain value x in [a,b] and returns the corresponding parameter t in [0,1].\n// reinterpolate(a, b)(t) takes a parameter t in [0,1] and returns the corresponding domain value x in [a,b].\nfunction continuous(deinterpolate, reinterpolate) {\n  var domain = unit,\n      range$$1 = unit,\n      interpolate$$1 = interpolateValue,\n      clamp = false,\n      piecewise,\n      output,\n      input;\n\n  function rescale() {\n    piecewise = Math.min(domain.length, range$$1.length) > 2 ? polymap : bimap;\n    output = input = null;\n    return scale;\n  }\n\n  function scale(x) {\n    return (output || (output = piecewise(domain, range$$1, clamp ? deinterpolateClamp(deinterpolate) : deinterpolate, interpolate$$1)))(+x);\n  }\n\n  scale.invert = function(y) {\n    return (input || (input = piecewise(range$$1, domain, deinterpolateLinear, clamp ? reinterpolateClamp(reinterpolate) : reinterpolate)))(+y);\n  };\n\n  scale.domain = function(_) {\n    return arguments.length ? (domain = map$3.call(_, number$1), rescale()) : domain.slice();\n  };\n\n  scale.range = function(_) {\n    return arguments.length ? (range$$1 = slice$4.call(_), rescale()) : range$$1.slice();\n  };\n\n  scale.rangeRound = function(_) {\n    return range$$1 = slice$4.call(_), interpolate$$1 = interpolateRound, rescale();\n  };\n\n  scale.clamp = function(_) {\n    return arguments.length ? (clamp = !!_, rescale()) : clamp;\n  };\n\n  scale.interpolate = function(_) {\n    return arguments.length ? (interpolate$$1 = _, rescale()) : interpolate$$1;\n  };\n\n  return rescale();\n}\n\nvar tickFormat = function(domain, count, specifier) {\n  var start = domain[0],\n      stop = domain[domain.length - 1],\n      step = tickStep(start, stop, count == null ? 10 : count),\n      precision;\n  specifier = formatSpecifier(specifier == null ? \",f\" : specifier);\n  switch (specifier.type) {\n    case \"s\": {\n      var value = Math.max(Math.abs(start), Math.abs(stop));\n      if (specifier.precision == null && !isNaN(precision = precisionPrefix(step, value))) specifier.precision = precision;\n      return exports.formatPrefix(specifier, value);\n    }\n    case \"\":\n    case \"e\":\n    case \"g\":\n    case \"p\":\n    case \"r\": {\n      if (specifier.precision == null && !isNaN(precision = precisionRound(step, Math.max(Math.abs(start), Math.abs(stop))))) specifier.precision = precision - (specifier.type === \"e\");\n      break;\n    }\n    case \"f\":\n    case \"%\": {\n      if (specifier.precision == null && !isNaN(precision = precisionFixed(step))) specifier.precision = precision - (specifier.type === \"%\") * 2;\n      break;\n    }\n  }\n  return exports.format(specifier);\n};\n\nfunction linearish(scale) {\n  var domain = scale.domain;\n\n  scale.ticks = function(count) {\n    var d = domain();\n    return ticks(d[0], d[d.length - 1], count == null ? 10 : count);\n  };\n\n  scale.tickFormat = function(count, specifier) {\n    return tickFormat(domain(), count, specifier);\n  };\n\n  scale.nice = function(count) {\n    var d = domain(),\n        i = d.length - 1,\n        n = count == null ? 10 : count,\n        start = d[0],\n        stop = d[i],\n        step = tickStep(start, stop, n);\n\n    if (step) {\n      step = tickStep(Math.floor(start / step) * step, Math.ceil(stop / step) * step, n);\n      d[0] = Math.floor(start / step) * step;\n      d[i] = Math.ceil(stop / step) * step;\n      domain(d);\n    }\n\n    return scale;\n  };\n\n  return scale;\n}\n\nfunction linear$2() {\n  var scale = continuous(deinterpolateLinear, reinterpolate);\n\n  scale.copy = function() {\n    return copy(scale, linear$2());\n  };\n\n  return linearish(scale);\n}\n\nfunction identity$6() {\n  var domain = [0, 1];\n\n  function scale(x) {\n    return +x;\n  }\n\n  scale.invert = scale;\n\n  scale.domain = scale.range = function(_) {\n    return arguments.length ? (domain = map$3.call(_, number$1), scale) : domain.slice();\n  };\n\n  scale.copy = function() {\n    return identity$6().domain(domain);\n  };\n\n  return linearish(scale);\n}\n\nvar nice = function(domain, interval) {\n  domain = domain.slice();\n\n  var i0 = 0,\n      i1 = domain.length - 1,\n      x0 = domain[i0],\n      x1 = domain[i1],\n      t;\n\n  if (x1 < x0) {\n    t = i0, i0 = i1, i1 = t;\n    t = x0, x0 = x1, x1 = t;\n  }\n\n  domain[i0] = interval.floor(x0);\n  domain[i1] = interval.ceil(x1);\n  return domain;\n};\n\nfunction deinterpolate(a, b) {\n  return (b = Math.log(b / a))\n      ? function(x) { return Math.log(x / a) / b; }\n      : constant$9(b);\n}\n\nfunction reinterpolate$1(a, b) {\n  return a < 0\n      ? function(t) { return -Math.pow(-b, t) * Math.pow(-a, 1 - t); }\n      : function(t) { return Math.pow(b, t) * Math.pow(a, 1 - t); };\n}\n\nfunction pow10(x) {\n  return isFinite(x) ? +(\"1e\" + x) : x < 0 ? 0 : x;\n}\n\nfunction powp(base) {\n  return base === 10 ? pow10\n      : base === Math.E ? Math.exp\n      : function(x) { return Math.pow(base, x); };\n}\n\nfunction logp(base) {\n  return base === Math.E ? Math.log\n      : base === 10 && Math.log10\n      || base === 2 && Math.log2\n      || (base = Math.log(base), function(x) { return Math.log(x) / base; });\n}\n\nfunction reflect(f) {\n  return function(x) {\n    return -f(-x);\n  };\n}\n\nfunction log$1() {\n  var scale = continuous(deinterpolate, reinterpolate$1).domain([1, 10]),\n      domain = scale.domain,\n      base = 10,\n      logs = logp(10),\n      pows = powp(10);\n\n  function rescale() {\n    logs = logp(base), pows = powp(base);\n    if (domain()[0] < 0) logs = reflect(logs), pows = reflect(pows);\n    return scale;\n  }\n\n  scale.base = function(_) {\n    return arguments.length ? (base = +_, rescale()) : base;\n  };\n\n  scale.domain = function(_) {\n    return arguments.length ? (domain(_), rescale()) : domain();\n  };\n\n  scale.ticks = function(count) {\n    var d = domain(),\n        u = d[0],\n        v = d[d.length - 1],\n        r;\n\n    if (r = v < u) i = u, u = v, v = i;\n\n    var i = logs(u),\n        j = logs(v),\n        p,\n        k,\n        t,\n        n = count == null ? 10 : +count,\n        z = [];\n\n    if (!(base % 1) && j - i < n) {\n      i = Math.round(i) - 1, j = Math.round(j) + 1;\n      if (u > 0) for (; i < j; ++i) {\n        for (k = 1, p = pows(i); k < base; ++k) {\n          t = p * k;\n          if (t < u) continue;\n          if (t > v) break;\n          z.push(t);\n        }\n      } else for (; i < j; ++i) {\n        for (k = base - 1, p = pows(i); k >= 1; --k) {\n          t = p * k;\n          if (t < u) continue;\n          if (t > v) break;\n          z.push(t);\n        }\n      }\n    } else {\n      z = ticks(i, j, Math.min(j - i, n)).map(pows);\n    }\n\n    return r ? z.reverse() : z;\n  };\n\n  scale.tickFormat = function(count, specifier) {\n    if (specifier == null) specifier = base === 10 ? \".0e\" : \",\";\n    if (typeof specifier !== \"function\") specifier = exports.format(specifier);\n    if (count === Infinity) return specifier;\n    if (count == null) count = 10;\n    var k = Math.max(1, base * count / scale.ticks().length); // TODO fast estimate?\n    return function(d) {\n      var i = d / pows(Math.round(logs(d)));\n      if (i * base < base - 0.5) i *= base;\n      return i <= k ? specifier(d) : \"\";\n    };\n  };\n\n  scale.nice = function() {\n    return domain(nice(domain(), {\n      floor: function(x) { return pows(Math.floor(logs(x))); },\n      ceil: function(x) { return pows(Math.ceil(logs(x))); }\n    }));\n  };\n\n  scale.copy = function() {\n    return copy(scale, log$1().base(base));\n  };\n\n  return scale;\n}\n\nfunction raise$1(x, exponent) {\n  return x < 0 ? -Math.pow(-x, exponent) : Math.pow(x, exponent);\n}\n\nfunction pow$1() {\n  var exponent = 1,\n      scale = continuous(deinterpolate, reinterpolate),\n      domain = scale.domain;\n\n  function deinterpolate(a, b) {\n    return (b = raise$1(b, exponent) - (a = raise$1(a, exponent)))\n        ? function(x) { return (raise$1(x, exponent) - a) / b; }\n        : constant$9(b);\n  }\n\n  function reinterpolate(a, b) {\n    b = raise$1(b, exponent) - (a = raise$1(a, exponent));\n    return function(t) { return raise$1(a + b * t, 1 / exponent); };\n  }\n\n  scale.exponent = function(_) {\n    return arguments.length ? (exponent = +_, domain(domain())) : exponent;\n  };\n\n  scale.copy = function() {\n    return copy(scale, pow$1().exponent(exponent));\n  };\n\n  return linearish(scale);\n}\n\nfunction sqrt$1() {\n  return pow$1().exponent(0.5);\n}\n\nfunction quantile$$1() {\n  var domain = [],\n      range$$1 = [],\n      thresholds = [];\n\n  function rescale() {\n    var i = 0, n = Math.max(1, range$$1.length);\n    thresholds = new Array(n - 1);\n    while (++i < n) thresholds[i - 1] = threshold(domain, i / n);\n    return scale;\n  }\n\n  function scale(x) {\n    if (!isNaN(x = +x)) return range$$1[bisectRight(thresholds, x)];\n  }\n\n  scale.invertExtent = function(y) {\n    var i = range$$1.indexOf(y);\n    return i < 0 ? [NaN, NaN] : [\n      i > 0 ? thresholds[i - 1] : domain[0],\n      i < thresholds.length ? thresholds[i] : domain[domain.length - 1]\n    ];\n  };\n\n  scale.domain = function(_) {\n    if (!arguments.length) return domain.slice();\n    domain = [];\n    for (var i = 0, n = _.length, d; i < n; ++i) if (d = _[i], d != null && !isNaN(d = +d)) domain.push(d);\n    domain.sort(ascending);\n    return rescale();\n  };\n\n  scale.range = function(_) {\n    return arguments.length ? (range$$1 = slice$4.call(_), rescale()) : range$$1.slice();\n  };\n\n  scale.quantiles = function() {\n    return thresholds.slice();\n  };\n\n  scale.copy = function() {\n    return quantile$$1()\n        .domain(domain)\n        .range(range$$1);\n  };\n\n  return scale;\n}\n\nfunction quantize$1() {\n  var x0 = 0,\n      x1 = 1,\n      n = 1,\n      domain = [0.5],\n      range$$1 = [0, 1];\n\n  function scale(x) {\n    if (x <= x) return range$$1[bisectRight(domain, x, 0, n)];\n  }\n\n  function rescale() {\n    var i = -1;\n    domain = new Array(n);\n    while (++i < n) domain[i] = ((i + 1) * x1 - (i - n) * x0) / (n + 1);\n    return scale;\n  }\n\n  scale.domain = function(_) {\n    return arguments.length ? (x0 = +_[0], x1 = +_[1], rescale()) : [x0, x1];\n  };\n\n  scale.range = function(_) {\n    return arguments.length ? (n = (range$$1 = slice$4.call(_)).length - 1, rescale()) : range$$1.slice();\n  };\n\n  scale.invertExtent = function(y) {\n    var i = range$$1.indexOf(y);\n    return i < 0 ? [NaN, NaN]\n        : i < 1 ? [x0, domain[0]]\n        : i >= n ? [domain[n - 1], x1]\n        : [domain[i - 1], domain[i]];\n  };\n\n  scale.copy = function() {\n    return quantize$1()\n        .domain([x0, x1])\n        .range(range$$1);\n  };\n\n  return linearish(scale);\n}\n\nfunction threshold$1() {\n  var domain = [0.5],\n      range$$1 = [0, 1],\n      n = 1;\n\n  function scale(x) {\n    if (x <= x) return range$$1[bisectRight(domain, x, 0, n)];\n  }\n\n  scale.domain = function(_) {\n    return arguments.length ? (domain = slice$4.call(_), n = Math.min(domain.length, range$$1.length - 1), scale) : domain.slice();\n  };\n\n  scale.range = function(_) {\n    return arguments.length ? (range$$1 = slice$4.call(_), n = Math.min(domain.length, range$$1.length - 1), scale) : range$$1.slice();\n  };\n\n  scale.invertExtent = function(y) {\n    var i = range$$1.indexOf(y);\n    return [domain[i - 1], domain[i]];\n  };\n\n  scale.copy = function() {\n    return threshold$1()\n        .domain(domain)\n        .range(range$$1);\n  };\n\n  return scale;\n}\n\nvar t0$1 = new Date;\nvar t1$1 = new Date;\n\nfunction newInterval(floori, offseti, count, field) {\n\n  function interval(date) {\n    return floori(date = new Date(+date)), date;\n  }\n\n  interval.floor = interval;\n\n  interval.ceil = function(date) {\n    return floori(date = new Date(date - 1)), offseti(date, 1), floori(date), date;\n  };\n\n  interval.round = function(date) {\n    var d0 = interval(date),\n        d1 = interval.ceil(date);\n    return date - d0 < d1 - date ? d0 : d1;\n  };\n\n  interval.offset = function(date, step) {\n    return offseti(date = new Date(+date), step == null ? 1 : Math.floor(step)), date;\n  };\n\n  interval.range = function(start, stop, step) {\n    var range = [];\n    start = interval.ceil(start);\n    step = step == null ? 1 : Math.floor(step);\n    if (!(start < stop) || !(step > 0)) return range; // also handles Invalid Date\n    do range.push(new Date(+start)); while (offseti(start, step), floori(start), start < stop)\n    return range;\n  };\n\n  interval.filter = function(test) {\n    return newInterval(function(date) {\n      if (date >= date) while (floori(date), !test(date)) date.setTime(date - 1);\n    }, function(date, step) {\n      if (date >= date) while (--step >= 0) while (offseti(date, 1), !test(date)) {} // eslint-disable-line no-empty\n    });\n  };\n\n  if (count) {\n    interval.count = function(start, end) {\n      t0$1.setTime(+start), t1$1.setTime(+end);\n      floori(t0$1), floori(t1$1);\n      return Math.floor(count(t0$1, t1$1));\n    };\n\n    interval.every = function(step) {\n      step = Math.floor(step);\n      return !isFinite(step) || !(step > 0) ? null\n          : !(step > 1) ? interval\n          : interval.filter(field\n              ? function(d) { return field(d) % step === 0; }\n              : function(d) { return interval.count(0, d) % step === 0; });\n    };\n  }\n\n  return interval;\n}\n\nvar millisecond = newInterval(function() {\n  // noop\n}, function(date, step) {\n  date.setTime(+date + step);\n}, function(start, end) {\n  return end - start;\n});\n\n// An optimized implementation for this simple case.\nmillisecond.every = function(k) {\n  k = Math.floor(k);\n  if (!isFinite(k) || !(k > 0)) return null;\n  if (!(k > 1)) return millisecond;\n  return newInterval(function(date) {\n    date.setTime(Math.floor(date / k) * k);\n  }, function(date, step) {\n    date.setTime(+date + step * k);\n  }, function(start, end) {\n    return (end - start) / k;\n  });\n};\n\nvar milliseconds = millisecond.range;\n\nvar durationSecond$1 = 1e3;\nvar durationMinute$1 = 6e4;\nvar durationHour$1 = 36e5;\nvar durationDay$1 = 864e5;\nvar durationWeek$1 = 6048e5;\n\nvar second = newInterval(function(date) {\n  date.setTime(Math.floor(date / durationSecond$1) * durationSecond$1);\n}, function(date, step) {\n  date.setTime(+date + step * durationSecond$1);\n}, function(start, end) {\n  return (end - start) / durationSecond$1;\n}, function(date) {\n  return date.getUTCSeconds();\n});\n\nvar seconds = second.range;\n\nvar minute = newInterval(function(date) {\n  date.setTime(Math.floor(date / durationMinute$1) * durationMinute$1);\n}, function(date, step) {\n  date.setTime(+date + step * durationMinute$1);\n}, function(start, end) {\n  return (end - start) / durationMinute$1;\n}, function(date) {\n  return date.getMinutes();\n});\n\nvar minutes = minute.range;\n\nvar hour = newInterval(function(date) {\n  var offset = date.getTimezoneOffset() * durationMinute$1 % durationHour$1;\n  if (offset < 0) offset += durationHour$1;\n  date.setTime(Math.floor((+date - offset) / durationHour$1) * durationHour$1 + offset);\n}, function(date, step) {\n  date.setTime(+date + step * durationHour$1);\n}, function(start, end) {\n  return (end - start) / durationHour$1;\n}, function(date) {\n  return date.getHours();\n});\n\nvar hours = hour.range;\n\nvar day = newInterval(function(date) {\n  date.setHours(0, 0, 0, 0);\n}, function(date, step) {\n  date.setDate(date.getDate() + step);\n}, function(start, end) {\n  return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute$1) / durationDay$1;\n}, function(date) {\n  return date.getDate() - 1;\n});\n\nvar days = day.range;\n\nfunction weekday(i) {\n  return newInterval(function(date) {\n    date.setDate(date.getDate() - (date.getDay() + 7 - i) % 7);\n    date.setHours(0, 0, 0, 0);\n  }, function(date, step) {\n    date.setDate(date.getDate() + step * 7);\n  }, function(start, end) {\n    return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute$1) / durationWeek$1;\n  });\n}\n\nvar sunday = weekday(0);\nvar monday = weekday(1);\nvar tuesday = weekday(2);\nvar wednesday = weekday(3);\nvar thursday = weekday(4);\nvar friday = weekday(5);\nvar saturday = weekday(6);\n\nvar sundays = sunday.range;\nvar mondays = monday.range;\nvar tuesdays = tuesday.range;\nvar wednesdays = wednesday.range;\nvar thursdays = thursday.range;\nvar fridays = friday.range;\nvar saturdays = saturday.range;\n\nvar month = newInterval(function(date) {\n  date.setDate(1);\n  date.setHours(0, 0, 0, 0);\n}, function(date, step) {\n  date.setMonth(date.getMonth() + step);\n}, function(start, end) {\n  return end.getMonth() - start.getMonth() + (end.getFullYear() - start.getFullYear()) * 12;\n}, function(date) {\n  return date.getMonth();\n});\n\nvar months = month.range;\n\nvar year = newInterval(function(date) {\n  date.setMonth(0, 1);\n  date.setHours(0, 0, 0, 0);\n}, function(date, step) {\n  date.setFullYear(date.getFullYear() + step);\n}, function(start, end) {\n  return end.getFullYear() - start.getFullYear();\n}, function(date) {\n  return date.getFullYear();\n});\n\n// An optimized implementation for this simple case.\nyear.every = function(k) {\n  return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : newInterval(function(date) {\n    date.setFullYear(Math.floor(date.getFullYear() / k) * k);\n    date.setMonth(0, 1);\n    date.setHours(0, 0, 0, 0);\n  }, function(date, step) {\n    date.setFullYear(date.getFullYear() + step * k);\n  });\n};\n\nvar years = year.range;\n\nvar utcMinute = newInterval(function(date) {\n  date.setUTCSeconds(0, 0);\n}, function(date, step) {\n  date.setTime(+date + step * durationMinute$1);\n}, function(start, end) {\n  return (end - start) / durationMinute$1;\n}, function(date) {\n  return date.getUTCMinutes();\n});\n\nvar utcMinutes = utcMinute.range;\n\nvar utcHour = newInterval(function(date) {\n  date.setUTCMinutes(0, 0, 0);\n}, function(date, step) {\n  date.setTime(+date + step * durationHour$1);\n}, function(start, end) {\n  return (end - start) / durationHour$1;\n}, function(date) {\n  return date.getUTCHours();\n});\n\nvar utcHours = utcHour.range;\n\nvar utcDay = newInterval(function(date) {\n  date.setUTCHours(0, 0, 0, 0);\n}, function(date, step) {\n  date.setUTCDate(date.getUTCDate() + step);\n}, function(start, end) {\n  return (end - start) / durationDay$1;\n}, function(date) {\n  return date.getUTCDate() - 1;\n});\n\nvar utcDays = utcDay.range;\n\nfunction utcWeekday(i) {\n  return newInterval(function(date) {\n    date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 7 - i) % 7);\n    date.setUTCHours(0, 0, 0, 0);\n  }, function(date, step) {\n    date.setUTCDate(date.getUTCDate() + step * 7);\n  }, function(start, end) {\n    return (end - start) / durationWeek$1;\n  });\n}\n\nvar utcSunday = utcWeekday(0);\nvar utcMonday = utcWeekday(1);\nvar utcTuesday = utcWeekday(2);\nvar utcWednesday = utcWeekday(3);\nvar utcThursday = utcWeekday(4);\nvar utcFriday = utcWeekday(5);\nvar utcSaturday = utcWeekday(6);\n\nvar utcSundays = utcSunday.range;\nvar utcMondays = utcMonday.range;\nvar utcTuesdays = utcTuesday.range;\nvar utcWednesdays = utcWednesday.range;\nvar utcThursdays = utcThursday.range;\nvar utcFridays = utcFriday.range;\nvar utcSaturdays = utcSaturday.range;\n\nvar utcMonth = newInterval(function(date) {\n  date.setUTCDate(1);\n  date.setUTCHours(0, 0, 0, 0);\n}, function(date, step) {\n  date.setUTCMonth(date.getUTCMonth() + step);\n}, function(start, end) {\n  return end.getUTCMonth() - start.getUTCMonth() + (end.getUTCFullYear() - start.getUTCFullYear()) * 12;\n}, function(date) {\n  return date.getUTCMonth();\n});\n\nvar utcMonths = utcMonth.range;\n\nvar utcYear = newInterval(function(date) {\n  date.setUTCMonth(0, 1);\n  date.setUTCHours(0, 0, 0, 0);\n}, function(date, step) {\n  date.setUTCFullYear(date.getUTCFullYear() + step);\n}, function(start, end) {\n  return end.getUTCFullYear() - start.getUTCFullYear();\n}, function(date) {\n  return date.getUTCFullYear();\n});\n\n// An optimized implementation for this simple case.\nutcYear.every = function(k) {\n  return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : newInterval(function(date) {\n    date.setUTCFullYear(Math.floor(date.getUTCFullYear() / k) * k);\n    date.setUTCMonth(0, 1);\n    date.setUTCHours(0, 0, 0, 0);\n  }, function(date, step) {\n    date.setUTCFullYear(date.getUTCFullYear() + step * k);\n  });\n};\n\nvar utcYears = utcYear.range;\n\nfunction localDate(d) {\n  if (0 <= d.y && d.y < 100) {\n    var date = new Date(-1, d.m, d.d, d.H, d.M, d.S, d.L);\n    date.setFullYear(d.y);\n    return date;\n  }\n  return new Date(d.y, d.m, d.d, d.H, d.M, d.S, d.L);\n}\n\nfunction utcDate(d) {\n  if (0 <= d.y && d.y < 100) {\n    var date = new Date(Date.UTC(-1, d.m, d.d, d.H, d.M, d.S, d.L));\n    date.setUTCFullYear(d.y);\n    return date;\n  }\n  return new Date(Date.UTC(d.y, d.m, d.d, d.H, d.M, d.S, d.L));\n}\n\nfunction newYear(y) {\n  return {y: y, m: 0, d: 1, H: 0, M: 0, S: 0, L: 0};\n}\n\nfunction formatLocale$1(locale) {\n  var locale_dateTime = locale.dateTime,\n      locale_date = locale.date,\n      locale_time = locale.time,\n      locale_periods = locale.periods,\n      locale_weekdays = locale.days,\n      locale_shortWeekdays = locale.shortDays,\n      locale_months = locale.months,\n      locale_shortMonths = locale.shortMonths;\n\n  var periodRe = formatRe(locale_periods),\n      periodLookup = formatLookup(locale_periods),\n      weekdayRe = formatRe(locale_weekdays),\n      weekdayLookup = formatLookup(locale_weekdays),\n      shortWeekdayRe = formatRe(locale_shortWeekdays),\n      shortWeekdayLookup = formatLookup(locale_shortWeekdays),\n      monthRe = formatRe(locale_months),\n      monthLookup = formatLookup(locale_months),\n      shortMonthRe = formatRe(locale_shortMonths),\n      shortMonthLookup = formatLookup(locale_shortMonths);\n\n  var formats = {\n    \"a\": formatShortWeekday,\n    \"A\": formatWeekday,\n    \"b\": formatShortMonth,\n    \"B\": formatMonth,\n    \"c\": null,\n    \"d\": formatDayOfMonth,\n    \"e\": formatDayOfMonth,\n    \"H\": formatHour24,\n    \"I\": formatHour12,\n    \"j\": formatDayOfYear,\n    \"L\": formatMilliseconds,\n    \"m\": formatMonthNumber,\n    \"M\": formatMinutes,\n    \"p\": formatPeriod,\n    \"S\": formatSeconds,\n    \"U\": formatWeekNumberSunday,\n    \"w\": formatWeekdayNumber,\n    \"W\": formatWeekNumberMonday,\n    \"x\": null,\n    \"X\": null,\n    \"y\": formatYear,\n    \"Y\": formatFullYear,\n    \"Z\": formatZone,\n    \"%\": formatLiteralPercent\n  };\n\n  var utcFormats = {\n    \"a\": formatUTCShortWeekday,\n    \"A\": formatUTCWeekday,\n    \"b\": formatUTCShortMonth,\n    \"B\": formatUTCMonth,\n    \"c\": null,\n    \"d\": formatUTCDayOfMonth,\n    \"e\": formatUTCDayOfMonth,\n    \"H\": formatUTCHour24,\n    \"I\": formatUTCHour12,\n    \"j\": formatUTCDayOfYear,\n    \"L\": formatUTCMilliseconds,\n    \"m\": formatUTCMonthNumber,\n    \"M\": formatUTCMinutes,\n    \"p\": formatUTCPeriod,\n    \"S\": formatUTCSeconds,\n    \"U\": formatUTCWeekNumberSunday,\n    \"w\": formatUTCWeekdayNumber,\n    \"W\": formatUTCWeekNumberMonday,\n    \"x\": null,\n    \"X\": null,\n    \"y\": formatUTCYear,\n    \"Y\": formatUTCFullYear,\n    \"Z\": formatUTCZone,\n    \"%\": formatLiteralPercent\n  };\n\n  var parses = {\n    \"a\": parseShortWeekday,\n    \"A\": parseWeekday,\n    \"b\": parseShortMonth,\n    \"B\": parseMonth,\n    \"c\": parseLocaleDateTime,\n    \"d\": parseDayOfMonth,\n    \"e\": parseDayOfMonth,\n    \"H\": parseHour24,\n    \"I\": parseHour24,\n    \"j\": parseDayOfYear,\n    \"L\": parseMilliseconds,\n    \"m\": parseMonthNumber,\n    \"M\": parseMinutes,\n    \"p\": parsePeriod,\n    \"S\": parseSeconds,\n    \"U\": parseWeekNumberSunday,\n    \"w\": parseWeekdayNumber,\n    \"W\": parseWeekNumberMonday,\n    \"x\": parseLocaleDate,\n    \"X\": parseLocaleTime,\n    \"y\": parseYear,\n    \"Y\": parseFullYear,\n    \"Z\": parseZone,\n    \"%\": parseLiteralPercent\n  };\n\n  // These recursive directive definitions must be deferred.\n  formats.x = newFormat(locale_date, formats);\n  formats.X = newFormat(locale_time, formats);\n  formats.c = newFormat(locale_dateTime, formats);\n  utcFormats.x = newFormat(locale_date, utcFormats);\n  utcFormats.X = newFormat(locale_time, utcFormats);\n  utcFormats.c = newFormat(locale_dateTime, utcFormats);\n\n  function newFormat(specifier, formats) {\n    return function(date) {\n      var string = [],\n          i = -1,\n          j = 0,\n          n = specifier.length,\n          c,\n          pad,\n          format;\n\n      if (!(date instanceof Date)) date = new Date(+date);\n\n      while (++i < n) {\n        if (specifier.charCodeAt(i) === 37) {\n          string.push(specifier.slice(j, i));\n          if ((pad = pads[c = specifier.charAt(++i)]) != null) c = specifier.charAt(++i);\n          else pad = c === \"e\" ? \" \" : \"0\";\n          if (format = formats[c]) c = format(date, pad);\n          string.push(c);\n          j = i + 1;\n        }\n      }\n\n      string.push(specifier.slice(j, i));\n      return string.join(\"\");\n    };\n  }\n\n  function newParse(specifier, newDate) {\n    return function(string) {\n      var d = newYear(1900),\n          i = parseSpecifier(d, specifier, string += \"\", 0);\n      if (i != string.length) return null;\n\n      // The am-pm flag is 0 for AM, and 1 for PM.\n      if (\"p\" in d) d.H = d.H % 12 + d.p * 12;\n\n      // Convert day-of-week and week-of-year to day-of-year.\n      if (\"W\" in d || \"U\" in d) {\n        if (!(\"w\" in d)) d.w = \"W\" in d ? 1 : 0;\n        var day$$1 = \"Z\" in d ? utcDate(newYear(d.y)).getUTCDay() : newDate(newYear(d.y)).getDay();\n        d.m = 0;\n        d.d = \"W\" in d ? (d.w + 6) % 7 + d.W * 7 - (day$$1 + 5) % 7 : d.w + d.U * 7 - (day$$1 + 6) % 7;\n      }\n\n      // If a time zone is specified, all fields are interpreted as UTC and then\n      // offset according to the specified time zone.\n      if (\"Z\" in d) {\n        d.H += d.Z / 100 | 0;\n        d.M += d.Z % 100;\n        return utcDate(d);\n      }\n\n      // Otherwise, all fields are in local time.\n      return newDate(d);\n    };\n  }\n\n  function parseSpecifier(d, specifier, string, j) {\n    var i = 0,\n        n = specifier.length,\n        m = string.length,\n        c,\n        parse;\n\n    while (i < n) {\n      if (j >= m) return -1;\n      c = specifier.charCodeAt(i++);\n      if (c === 37) {\n        c = specifier.charAt(i++);\n        parse = parses[c in pads ? specifier.charAt(i++) : c];\n        if (!parse || ((j = parse(d, string, j)) < 0)) return -1;\n      } else if (c != string.charCodeAt(j++)) {\n        return -1;\n      }\n    }\n\n    return j;\n  }\n\n  function parsePeriod(d, string, i) {\n    var n = periodRe.exec(string.slice(i));\n    return n ? (d.p = periodLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n  }\n\n  function parseShortWeekday(d, string, i) {\n    var n = shortWeekdayRe.exec(string.slice(i));\n    return n ? (d.w = shortWeekdayLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n  }\n\n  function parseWeekday(d, string, i) {\n    var n = weekdayRe.exec(string.slice(i));\n    return n ? (d.w = weekdayLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n  }\n\n  function parseShortMonth(d, string, i) {\n    var n = shortMonthRe.exec(string.slice(i));\n    return n ? (d.m = shortMonthLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n  }\n\n  function parseMonth(d, string, i) {\n    var n = monthRe.exec(string.slice(i));\n    return n ? (d.m = monthLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n  }\n\n  function parseLocaleDateTime(d, string, i) {\n    return parseSpecifier(d, locale_dateTime, string, i);\n  }\n\n  function parseLocaleDate(d, string, i) {\n    return parseSpecifier(d, locale_date, string, i);\n  }\n\n  function parseLocaleTime(d, string, i) {\n    return parseSpecifier(d, locale_time, string, i);\n  }\n\n  function formatShortWeekday(d) {\n    return locale_shortWeekdays[d.getDay()];\n  }\n\n  function formatWeekday(d) {\n    return locale_weekdays[d.getDay()];\n  }\n\n  function formatShortMonth(d) {\n    return locale_shortMonths[d.getMonth()];\n  }\n\n  function formatMonth(d) {\n    return locale_months[d.getMonth()];\n  }\n\n  function formatPeriod(d) {\n    return locale_periods[+(d.getHours() >= 12)];\n  }\n\n  function formatUTCShortWeekday(d) {\n    return locale_shortWeekdays[d.getUTCDay()];\n  }\n\n  function formatUTCWeekday(d) {\n    return locale_weekdays[d.getUTCDay()];\n  }\n\n  function formatUTCShortMonth(d) {\n    return locale_shortMonths[d.getUTCMonth()];\n  }\n\n  function formatUTCMonth(d) {\n    return locale_months[d.getUTCMonth()];\n  }\n\n  function formatUTCPeriod(d) {\n    return locale_periods[+(d.getUTCHours() >= 12)];\n  }\n\n  return {\n    format: function(specifier) {\n      var f = newFormat(specifier += \"\", formats);\n      f.toString = function() { return specifier; };\n      return f;\n    },\n    parse: function(specifier) {\n      var p = newParse(specifier += \"\", localDate);\n      p.toString = function() { return specifier; };\n      return p;\n    },\n    utcFormat: function(specifier) {\n      var f = newFormat(specifier += \"\", utcFormats);\n      f.toString = function() { return specifier; };\n      return f;\n    },\n    utcParse: function(specifier) {\n      var p = newParse(specifier, utcDate);\n      p.toString = function() { return specifier; };\n      return p;\n    }\n  };\n}\n\nvar pads = {\"-\": \"\", \"_\": \" \", \"0\": \"0\"};\nvar numberRe = /^\\s*\\d+/;\nvar percentRe = /^%/;\nvar requoteRe = /[\\\\\\^\\$\\*\\+\\?\\|\\[\\]\\(\\)\\.\\{\\}]/g;\n\nfunction pad(value, fill, width) {\n  var sign = value < 0 ? \"-\" : \"\",\n      string = (sign ? -value : value) + \"\",\n      length = string.length;\n  return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string);\n}\n\nfunction requote(s) {\n  return s.replace(requoteRe, \"\\\\$&\");\n}\n\nfunction formatRe(names) {\n  return new RegExp(\"^(?:\" + names.map(requote).join(\"|\") + \")\", \"i\");\n}\n\nfunction formatLookup(names) {\n  var map = {}, i = -1, n = names.length;\n  while (++i < n) map[names[i].toLowerCase()] = i;\n  return map;\n}\n\nfunction parseWeekdayNumber(d, string, i) {\n  var n = numberRe.exec(string.slice(i, i + 1));\n  return n ? (d.w = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseWeekNumberSunday(d, string, i) {\n  var n = numberRe.exec(string.slice(i));\n  return n ? (d.U = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseWeekNumberMonday(d, string, i) {\n  var n = numberRe.exec(string.slice(i));\n  return n ? (d.W = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseFullYear(d, string, i) {\n  var n = numberRe.exec(string.slice(i, i + 4));\n  return n ? (d.y = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseYear(d, string, i) {\n  var n = numberRe.exec(string.slice(i, i + 2));\n  return n ? (d.y = +n[0] + (+n[0] > 68 ? 1900 : 2000), i + n[0].length) : -1;\n}\n\nfunction parseZone(d, string, i) {\n  var n = /^(Z)|([+-]\\d\\d)(?:\\:?(\\d\\d))?/.exec(string.slice(i, i + 6));\n  return n ? (d.Z = n[1] ? 0 : -(n[2] + (n[3] || \"00\")), i + n[0].length) : -1;\n}\n\nfunction parseMonthNumber(d, string, i) {\n  var n = numberRe.exec(string.slice(i, i + 2));\n  return n ? (d.m = n[0] - 1, i + n[0].length) : -1;\n}\n\nfunction parseDayOfMonth(d, string, i) {\n  var n = numberRe.exec(string.slice(i, i + 2));\n  return n ? (d.d = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseDayOfYear(d, string, i) {\n  var n = numberRe.exec(string.slice(i, i + 3));\n  return n ? (d.m = 0, d.d = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseHour24(d, string, i) {\n  var n = numberRe.exec(string.slice(i, i + 2));\n  return n ? (d.H = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseMinutes(d, string, i) {\n  var n = numberRe.exec(string.slice(i, i + 2));\n  return n ? (d.M = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseSeconds(d, string, i) {\n  var n = numberRe.exec(string.slice(i, i + 2));\n  return n ? (d.S = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseMilliseconds(d, string, i) {\n  var n = numberRe.exec(string.slice(i, i + 3));\n  return n ? (d.L = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseLiteralPercent(d, string, i) {\n  var n = percentRe.exec(string.slice(i, i + 1));\n  return n ? i + n[0].length : -1;\n}\n\nfunction formatDayOfMonth(d, p) {\n  return pad(d.getDate(), p, 2);\n}\n\nfunction formatHour24(d, p) {\n  return pad(d.getHours(), p, 2);\n}\n\nfunction formatHour12(d, p) {\n  return pad(d.getHours() % 12 || 12, p, 2);\n}\n\nfunction formatDayOfYear(d, p) {\n  return pad(1 + day.count(year(d), d), p, 3);\n}\n\nfunction formatMilliseconds(d, p) {\n  return pad(d.getMilliseconds(), p, 3);\n}\n\nfunction formatMonthNumber(d, p) {\n  return pad(d.getMonth() + 1, p, 2);\n}\n\nfunction formatMinutes(d, p) {\n  return pad(d.getMinutes(), p, 2);\n}\n\nfunction formatSeconds(d, p) {\n  return pad(d.getSeconds(), p, 2);\n}\n\nfunction formatWeekNumberSunday(d, p) {\n  return pad(sunday.count(year(d), d), p, 2);\n}\n\nfunction formatWeekdayNumber(d) {\n  return d.getDay();\n}\n\nfunction formatWeekNumberMonday(d, p) {\n  return pad(monday.count(year(d), d), p, 2);\n}\n\nfunction formatYear(d, p) {\n  return pad(d.getFullYear() % 100, p, 2);\n}\n\nfunction formatFullYear(d, p) {\n  return pad(d.getFullYear() % 10000, p, 4);\n}\n\nfunction formatZone(d) {\n  var z = d.getTimezoneOffset();\n  return (z > 0 ? \"-\" : (z *= -1, \"+\"))\n      + pad(z / 60 | 0, \"0\", 2)\n      + pad(z % 60, \"0\", 2);\n}\n\nfunction formatUTCDayOfMonth(d, p) {\n  return pad(d.getUTCDate(), p, 2);\n}\n\nfunction formatUTCHour24(d, p) {\n  return pad(d.getUTCHours(), p, 2);\n}\n\nfunction formatUTCHour12(d, p) {\n  return pad(d.getUTCHours() % 12 || 12, p, 2);\n}\n\nfunction formatUTCDayOfYear(d, p) {\n  return pad(1 + utcDay.count(utcYear(d), d), p, 3);\n}\n\nfunction formatUTCMilliseconds(d, p) {\n  return pad(d.getUTCMilliseconds(), p, 3);\n}\n\nfunction formatUTCMonthNumber(d, p) {\n  return pad(d.getUTCMonth() + 1, p, 2);\n}\n\nfunction formatUTCMinutes(d, p) {\n  return pad(d.getUTCMinutes(), p, 2);\n}\n\nfunction formatUTCSeconds(d, p) {\n  return pad(d.getUTCSeconds(), p, 2);\n}\n\nfunction formatUTCWeekNumberSunday(d, p) {\n  return pad(utcSunday.count(utcYear(d), d), p, 2);\n}\n\nfunction formatUTCWeekdayNumber(d) {\n  return d.getUTCDay();\n}\n\nfunction formatUTCWeekNumberMonday(d, p) {\n  return pad(utcMonday.count(utcYear(d), d), p, 2);\n}\n\nfunction formatUTCYear(d, p) {\n  return pad(d.getUTCFullYear() % 100, p, 2);\n}\n\nfunction formatUTCFullYear(d, p) {\n  return pad(d.getUTCFullYear() % 10000, p, 4);\n}\n\nfunction formatUTCZone() {\n  return \"+0000\";\n}\n\nfunction formatLiteralPercent() {\n  return \"%\";\n}\n\nvar locale$2;\n\n\n\n\n\ndefaultLocale$1({\n  dateTime: \"%x, %X\",\n  date: \"%-m/%-d/%Y\",\n  time: \"%-I:%M:%S %p\",\n  periods: [\"AM\", \"PM\"],\n  days: [\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"],\n  shortDays: [\"Sun\", \"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\"],\n  months: [\"January\", \"February\", \"March\", \"April\", \"May\", \"June\", \"July\", \"August\", \"September\", \"October\", \"November\", \"December\"],\n  shortMonths: [\"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"Jun\", \"Jul\", \"Aug\", \"Sep\", \"Oct\", \"Nov\", \"Dec\"]\n});\n\nfunction defaultLocale$1(definition) {\n  locale$2 = formatLocale$1(definition);\n  exports.timeFormat = locale$2.format;\n  exports.timeParse = locale$2.parse;\n  exports.utcFormat = locale$2.utcFormat;\n  exports.utcParse = locale$2.utcParse;\n  return locale$2;\n}\n\nvar isoSpecifier = \"%Y-%m-%dT%H:%M:%S.%LZ\";\n\nfunction formatIsoNative(date) {\n  return date.toISOString();\n}\n\nvar formatIso = Date.prototype.toISOString\n    ? formatIsoNative\n    : exports.utcFormat(isoSpecifier);\n\nfunction parseIsoNative(string) {\n  var date = new Date(string);\n  return isNaN(date) ? null : date;\n}\n\nvar parseIso = +new Date(\"2000-01-01T00:00:00.000Z\")\n    ? parseIsoNative\n    : exports.utcParse(isoSpecifier);\n\nvar durationSecond = 1000;\nvar durationMinute = durationSecond * 60;\nvar durationHour = durationMinute * 60;\nvar durationDay = durationHour * 24;\nvar durationWeek = durationDay * 7;\nvar durationMonth = durationDay * 30;\nvar durationYear = durationDay * 365;\n\nfunction date$1(t) {\n  return new Date(t);\n}\n\nfunction number$2(t) {\n  return t instanceof Date ? +t : +new Date(+t);\n}\n\nfunction calendar(year$$1, month$$1, week, day$$1, hour$$1, minute$$1, second$$1, millisecond$$1, format) {\n  var scale = continuous(deinterpolateLinear, reinterpolate),\n      invert = scale.invert,\n      domain = scale.domain;\n\n  var formatMillisecond = format(\".%L\"),\n      formatSecond = format(\":%S\"),\n      formatMinute = format(\"%I:%M\"),\n      formatHour = format(\"%I %p\"),\n      formatDay = format(\"%a %d\"),\n      formatWeek = format(\"%b %d\"),\n      formatMonth = format(\"%B\"),\n      formatYear = format(\"%Y\");\n\n  var tickIntervals = [\n    [second$$1,  1,      durationSecond],\n    [second$$1,  5,  5 * durationSecond],\n    [second$$1, 15, 15 * durationSecond],\n    [second$$1, 30, 30 * durationSecond],\n    [minute$$1,  1,      durationMinute],\n    [minute$$1,  5,  5 * durationMinute],\n    [minute$$1, 15, 15 * durationMinute],\n    [minute$$1, 30, 30 * durationMinute],\n    [  hour$$1,  1,      durationHour  ],\n    [  hour$$1,  3,  3 * durationHour  ],\n    [  hour$$1,  6,  6 * durationHour  ],\n    [  hour$$1, 12, 12 * durationHour  ],\n    [   day$$1,  1,      durationDay   ],\n    [   day$$1,  2,  2 * durationDay   ],\n    [  week,  1,      durationWeek  ],\n    [ month$$1,  1,      durationMonth ],\n    [ month$$1,  3,  3 * durationMonth ],\n    [  year$$1,  1,      durationYear  ]\n  ];\n\n  function tickFormat(date) {\n    return (second$$1(date) < date ? formatMillisecond\n        : minute$$1(date) < date ? formatSecond\n        : hour$$1(date) < date ? formatMinute\n        : day$$1(date) < date ? formatHour\n        : month$$1(date) < date ? (week(date) < date ? formatDay : formatWeek)\n        : year$$1(date) < date ? formatMonth\n        : formatYear)(date);\n  }\n\n  function tickInterval(interval, start, stop, step) {\n    if (interval == null) interval = 10;\n\n    // If a desired tick count is specified, pick a reasonable tick interval\n    // based on the extent of the domain and a rough estimate of tick size.\n    // Otherwise, assume interval is already a time interval and use it.\n    if (typeof interval === \"number\") {\n      var target = Math.abs(stop - start) / interval,\n          i = bisector(function(i) { return i[2]; }).right(tickIntervals, target);\n      if (i === tickIntervals.length) {\n        step = tickStep(start / durationYear, stop / durationYear, interval);\n        interval = year$$1;\n      } else if (i) {\n        i = tickIntervals[target / tickIntervals[i - 1][2] < tickIntervals[i][2] / target ? i - 1 : i];\n        step = i[1];\n        interval = i[0];\n      } else {\n        step = tickStep(start, stop, interval);\n        interval = millisecond$$1;\n      }\n    }\n\n    return step == null ? interval : interval.every(step);\n  }\n\n  scale.invert = function(y) {\n    return new Date(invert(y));\n  };\n\n  scale.domain = function(_) {\n    return arguments.length ? domain(map$3.call(_, number$2)) : domain().map(date$1);\n  };\n\n  scale.ticks = function(interval, step) {\n    var d = domain(),\n        t0 = d[0],\n        t1 = d[d.length - 1],\n        r = t1 < t0,\n        t;\n    if (r) t = t0, t0 = t1, t1 = t;\n    t = tickInterval(interval, t0, t1, step);\n    t = t ? t.range(t0, t1 + 1) : []; // inclusive stop\n    return r ? t.reverse() : t;\n  };\n\n  scale.tickFormat = function(count, specifier) {\n    return specifier == null ? tickFormat : format(specifier);\n  };\n\n  scale.nice = function(interval, step) {\n    var d = domain();\n    return (interval = tickInterval(interval, d[0], d[d.length - 1], step))\n        ? domain(nice(d, interval))\n        : scale;\n  };\n\n  scale.copy = function() {\n    return copy(scale, calendar(year$$1, month$$1, week, day$$1, hour$$1, minute$$1, second$$1, millisecond$$1, format));\n  };\n\n  return scale;\n}\n\nvar time = function() {\n  return calendar(year, month, sunday, day, hour, minute, second, millisecond, exports.timeFormat).domain([new Date(2000, 0, 1), new Date(2000, 0, 2)]);\n};\n\nvar utcTime = function() {\n  return calendar(utcYear, utcMonth, utcSunday, utcDay, utcHour, utcMinute, second, millisecond, exports.utcFormat).domain([Date.UTC(2000, 0, 1), Date.UTC(2000, 0, 2)]);\n};\n\nvar colors = function(s) {\n  return s.match(/.{6}/g).map(function(x) {\n    return \"#\" + x;\n  });\n};\n\nvar category10 = colors(\"1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf\");\n\nvar category20b = colors(\"393b795254a36b6ecf9c9ede6379398ca252b5cf6bcedb9c8c6d31bd9e39e7ba52e7cb94843c39ad494ad6616be7969c7b4173a55194ce6dbdde9ed6\");\n\nvar category20c = colors(\"3182bd6baed69ecae1c6dbefe6550dfd8d3cfdae6bfdd0a231a35474c476a1d99bc7e9c0756bb19e9ac8bcbddcdadaeb636363969696bdbdbdd9d9d9\");\n\nvar category20 = colors(\"1f77b4aec7e8ff7f0effbb782ca02c98df8ad62728ff98969467bdc5b0d58c564bc49c94e377c2f7b6d27f7f7fc7c7c7bcbd22dbdb8d17becf9edae5\");\n\nvar cubehelix$3 = cubehelixLong(cubehelix(300, 0.5, 0.0), cubehelix(-240, 0.5, 1.0));\n\nvar warm = cubehelixLong(cubehelix(-100, 0.75, 0.35), cubehelix(80, 1.50, 0.8));\n\nvar cool = cubehelixLong(cubehelix(260, 0.75, 0.35), cubehelix(80, 1.50, 0.8));\n\nvar rainbow = cubehelix();\n\nvar rainbow$1 = function(t) {\n  if (t < 0 || t > 1) t -= Math.floor(t);\n  var ts = Math.abs(t - 0.5);\n  rainbow.h = 360 * t - 100;\n  rainbow.s = 1.5 - 1.5 * ts;\n  rainbow.l = 0.8 - 0.9 * ts;\n  return rainbow + \"\";\n};\n\nfunction ramp(range) {\n  var n = range.length;\n  return function(t) {\n    return range[Math.max(0, Math.min(n - 1, Math.floor(t * n)))];\n  };\n}\n\nvar viridis = ramp(colors(\"44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725\"));\n\nvar magma = ramp(colors(\"00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf\"));\n\nvar inferno = ramp(colors(\"00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4\"));\n\nvar plasma = ramp(colors(\"0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921\"));\n\nfunction sequential(interpolator) {\n  var x0 = 0,\n      x1 = 1,\n      clamp = false;\n\n  function scale(x) {\n    var t = (x - x0) / (x1 - x0);\n    return interpolator(clamp ? Math.max(0, Math.min(1, t)) : t);\n  }\n\n  scale.domain = function(_) {\n    return arguments.length ? (x0 = +_[0], x1 = +_[1], scale) : [x0, x1];\n  };\n\n  scale.clamp = function(_) {\n    return arguments.length ? (clamp = !!_, scale) : clamp;\n  };\n\n  scale.interpolator = function(_) {\n    return arguments.length ? (interpolator = _, scale) : interpolator;\n  };\n\n  scale.copy = function() {\n    return sequential(interpolator).domain([x0, x1]).clamp(clamp);\n  };\n\n  return linearish(scale);\n}\n\nvar constant$10 = function(x) {\n  return function constant() {\n    return x;\n  };\n};\n\nvar epsilon$3 = 1e-12;\nvar pi$4 = Math.PI;\nvar halfPi$3 = pi$4 / 2;\nvar tau$4 = 2 * pi$4;\n\nfunction arcInnerRadius(d) {\n  return d.innerRadius;\n}\n\nfunction arcOuterRadius(d) {\n  return d.outerRadius;\n}\n\nfunction arcStartAngle(d) {\n  return d.startAngle;\n}\n\nfunction arcEndAngle(d) {\n  return d.endAngle;\n}\n\nfunction arcPadAngle(d) {\n  return d && d.padAngle; // Note: optional!\n}\n\nfunction asin$1(x) {\n  return x >= 1 ? halfPi$3 : x <= -1 ? -halfPi$3 : Math.asin(x);\n}\n\nfunction intersect(x0, y0, x1, y1, x2, y2, x3, y3) {\n  var x10 = x1 - x0, y10 = y1 - y0,\n      x32 = x3 - x2, y32 = y3 - y2,\n      t = (x32 * (y0 - y2) - y32 * (x0 - x2)) / (y32 * x10 - x32 * y10);\n  return [x0 + t * x10, y0 + t * y10];\n}\n\n// Compute perpendicular offset line of length rc.\n// http://mathworld.wolfram.com/Circle-LineIntersection.html\nfunction cornerTangents(x0, y0, x1, y1, r1, rc, cw) {\n  var x01 = x0 - x1,\n      y01 = y0 - y1,\n      lo = (cw ? rc : -rc) / Math.sqrt(x01 * x01 + y01 * y01),\n      ox = lo * y01,\n      oy = -lo * x01,\n      x11 = x0 + ox,\n      y11 = y0 + oy,\n      x10 = x1 + ox,\n      y10 = y1 + oy,\n      x00 = (x11 + x10) / 2,\n      y00 = (y11 + y10) / 2,\n      dx = x10 - x11,\n      dy = y10 - y11,\n      d2 = dx * dx + dy * dy,\n      r = r1 - rc,\n      D = x11 * y10 - x10 * y11,\n      d = (dy < 0 ? -1 : 1) * Math.sqrt(Math.max(0, r * r * d2 - D * D)),\n      cx0 = (D * dy - dx * d) / d2,\n      cy0 = (-D * dx - dy * d) / d2,\n      cx1 = (D * dy + dx * d) / d2,\n      cy1 = (-D * dx + dy * d) / d2,\n      dx0 = cx0 - x00,\n      dy0 = cy0 - y00,\n      dx1 = cx1 - x00,\n      dy1 = cy1 - y00;\n\n  // Pick the closer of the two intersection points.\n  // TODO Is there a faster way to determine which intersection to use?\n  if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) cx0 = cx1, cy0 = cy1;\n\n  return {\n    cx: cx0,\n    cy: cy0,\n    x01: -ox,\n    y01: -oy,\n    x11: cx0 * (r1 / r - 1),\n    y11: cy0 * (r1 / r - 1)\n  };\n}\n\nvar arc = function() {\n  var innerRadius = arcInnerRadius,\n      outerRadius = arcOuterRadius,\n      cornerRadius = constant$10(0),\n      padRadius = null,\n      startAngle = arcStartAngle,\n      endAngle = arcEndAngle,\n      padAngle = arcPadAngle,\n      context = null;\n\n  function arc() {\n    var buffer,\n        r,\n        r0 = +innerRadius.apply(this, arguments),\n        r1 = +outerRadius.apply(this, arguments),\n        a0 = startAngle.apply(this, arguments) - halfPi$3,\n        a1 = endAngle.apply(this, arguments) - halfPi$3,\n        da = Math.abs(a1 - a0),\n        cw = a1 > a0;\n\n    if (!context) context = buffer = path();\n\n    // Ensure that the outer radius is always larger than the inner radius.\n    if (r1 < r0) r = r1, r1 = r0, r0 = r;\n\n    // Is it a point?\n    if (!(r1 > epsilon$3)) context.moveTo(0, 0);\n\n    // Or is it a circle or annulus?\n    else if (da > tau$4 - epsilon$3) {\n      context.moveTo(r1 * Math.cos(a0), r1 * Math.sin(a0));\n      context.arc(0, 0, r1, a0, a1, !cw);\n      if (r0 > epsilon$3) {\n        context.moveTo(r0 * Math.cos(a1), r0 * Math.sin(a1));\n        context.arc(0, 0, r0, a1, a0, cw);\n      }\n    }\n\n    // Or is it a circular or annular sector?\n    else {\n      var a01 = a0,\n          a11 = a1,\n          a00 = a0,\n          a10 = a1,\n          da0 = da,\n          da1 = da,\n          ap = padAngle.apply(this, arguments) / 2,\n          rp = (ap > epsilon$3) && (padRadius ? +padRadius.apply(this, arguments) : Math.sqrt(r0 * r0 + r1 * r1)),\n          rc = Math.min(Math.abs(r1 - r0) / 2, +cornerRadius.apply(this, arguments)),\n          rc0 = rc,\n          rc1 = rc,\n          t0,\n          t1;\n\n      // Apply padding? Note that since r1 ≥ r0, da1 ≥ da0.\n      if (rp > epsilon$3) {\n        var p0 = asin$1(rp / r0 * Math.sin(ap)),\n            p1 = asin$1(rp / r1 * Math.sin(ap));\n        if ((da0 -= p0 * 2) > epsilon$3) p0 *= (cw ? 1 : -1), a00 += p0, a10 -= p0;\n        else da0 = 0, a00 = a10 = (a0 + a1) / 2;\n        if ((da1 -= p1 * 2) > epsilon$3) p1 *= (cw ? 1 : -1), a01 += p1, a11 -= p1;\n        else da1 = 0, a01 = a11 = (a0 + a1) / 2;\n      }\n\n      var x01 = r1 * Math.cos(a01),\n          y01 = r1 * Math.sin(a01),\n          x10 = r0 * Math.cos(a10),\n          y10 = r0 * Math.sin(a10);\n\n      // Apply rounded corners?\n      if (rc > epsilon$3) {\n        var x11 = r1 * Math.cos(a11),\n            y11 = r1 * Math.sin(a11),\n            x00 = r0 * Math.cos(a00),\n            y00 = r0 * Math.sin(a00);\n\n        // Restrict the corner radius according to the sector angle.\n        if (da < pi$4) {\n          var oc = da0 > epsilon$3 ? intersect(x01, y01, x00, y00, x11, y11, x10, y10) : [x10, y10],\n              ax = x01 - oc[0],\n              ay = y01 - oc[1],\n              bx = x11 - oc[0],\n              by = y11 - oc[1],\n              kc = 1 / Math.sin(Math.acos((ax * bx + ay * by) / (Math.sqrt(ax * ax + ay * ay) * Math.sqrt(bx * bx + by * by))) / 2),\n              lc = Math.sqrt(oc[0] * oc[0] + oc[1] * oc[1]);\n          rc0 = Math.min(rc, (r0 - lc) / (kc - 1));\n          rc1 = Math.min(rc, (r1 - lc) / (kc + 1));\n        }\n      }\n\n      // Is the sector collapsed to a line?\n      if (!(da1 > epsilon$3)) context.moveTo(x01, y01);\n\n      // Does the sector’s outer ring have rounded corners?\n      else if (rc1 > epsilon$3) {\n        t0 = cornerTangents(x00, y00, x01, y01, r1, rc1, cw);\n        t1 = cornerTangents(x11, y11, x10, y10, r1, rc1, cw);\n\n        context.moveTo(t0.cx + t0.x01, t0.cy + t0.y01);\n\n        // Have the corners merged?\n        if (rc1 < rc) context.arc(t0.cx, t0.cy, rc1, Math.atan2(t0.y01, t0.x01), Math.atan2(t1.y01, t1.x01), !cw);\n\n        // Otherwise, draw the two corners and the ring.\n        else {\n          context.arc(t0.cx, t0.cy, rc1, Math.atan2(t0.y01, t0.x01), Math.atan2(t0.y11, t0.x11), !cw);\n          context.arc(0, 0, r1, Math.atan2(t0.cy + t0.y11, t0.cx + t0.x11), Math.atan2(t1.cy + t1.y11, t1.cx + t1.x11), !cw);\n          context.arc(t1.cx, t1.cy, rc1, Math.atan2(t1.y11, t1.x11), Math.atan2(t1.y01, t1.x01), !cw);\n        }\n      }\n\n      // Or is the outer ring just a circular arc?\n      else context.moveTo(x01, y01), context.arc(0, 0, r1, a01, a11, !cw);\n\n      // Is there no inner ring, and it’s a circular sector?\n      // Or perhaps it’s an annular sector collapsed due to padding?\n      if (!(r0 > epsilon$3) || !(da0 > epsilon$3)) context.lineTo(x10, y10);\n\n      // Does the sector’s inner ring (or point) have rounded corners?\n      else if (rc0 > epsilon$3) {\n        t0 = cornerTangents(x10, y10, x11, y11, r0, -rc0, cw);\n        t1 = cornerTangents(x01, y01, x00, y00, r0, -rc0, cw);\n\n        context.lineTo(t0.cx + t0.x01, t0.cy + t0.y01);\n\n        // Have the corners merged?\n        if (rc0 < rc) context.arc(t0.cx, t0.cy, rc0, Math.atan2(t0.y01, t0.x01), Math.atan2(t1.y01, t1.x01), !cw);\n\n        // Otherwise, draw the two corners and the ring.\n        else {\n          context.arc(t0.cx, t0.cy, rc0, Math.atan2(t0.y01, t0.x01), Math.atan2(t0.y11, t0.x11), !cw);\n          context.arc(0, 0, r0, Math.atan2(t0.cy + t0.y11, t0.cx + t0.x11), Math.atan2(t1.cy + t1.y11, t1.cx + t1.x11), cw);\n          context.arc(t1.cx, t1.cy, rc0, Math.atan2(t1.y11, t1.x11), Math.atan2(t1.y01, t1.x01), !cw);\n        }\n      }\n\n      // Or is the inner ring just a circular arc?\n      else context.arc(0, 0, r0, a10, a00, cw);\n    }\n\n    context.closePath();\n\n    if (buffer) return context = null, buffer + \"\" || null;\n  }\n\n  arc.centroid = function() {\n    var r = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2,\n        a = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - pi$4 / 2;\n    return [Math.cos(a) * r, Math.sin(a) * r];\n  };\n\n  arc.innerRadius = function(_) {\n    return arguments.length ? (innerRadius = typeof _ === \"function\" ? _ : constant$10(+_), arc) : innerRadius;\n  };\n\n  arc.outerRadius = function(_) {\n    return arguments.length ? (outerRadius = typeof _ === \"function\" ? _ : constant$10(+_), arc) : outerRadius;\n  };\n\n  arc.cornerRadius = function(_) {\n    return arguments.length ? (cornerRadius = typeof _ === \"function\" ? _ : constant$10(+_), arc) : cornerRadius;\n  };\n\n  arc.padRadius = function(_) {\n    return arguments.length ? (padRadius = _ == null ? null : typeof _ === \"function\" ? _ : constant$10(+_), arc) : padRadius;\n  };\n\n  arc.startAngle = function(_) {\n    return arguments.length ? (startAngle = typeof _ === \"function\" ? _ : constant$10(+_), arc) : startAngle;\n  };\n\n  arc.endAngle = function(_) {\n    return arguments.length ? (endAngle = typeof _ === \"function\" ? _ : constant$10(+_), arc) : endAngle;\n  };\n\n  arc.padAngle = function(_) {\n    return arguments.length ? (padAngle = typeof _ === \"function\" ? _ : constant$10(+_), arc) : padAngle;\n  };\n\n  arc.context = function(_) {\n    return arguments.length ? ((context = _ == null ? null : _), arc) : context;\n  };\n\n  return arc;\n};\n\nfunction Linear(context) {\n  this._context = context;\n}\n\nLinear.prototype = {\n  areaStart: function() {\n    this._line = 0;\n  },\n  areaEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._point = 0;\n  },\n  lineEnd: function() {\n    if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n    this._line = 1 - this._line;\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n    switch (this._point) {\n      case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n      case 1: this._point = 2; // proceed\n      default: this._context.lineTo(x, y); break;\n    }\n  }\n};\n\nvar curveLinear = function(context) {\n  return new Linear(context);\n};\n\nfunction x$3(p) {\n  return p[0];\n}\n\nfunction y$3(p) {\n  return p[1];\n}\n\nvar line = function() {\n  var x$$1 = x$3,\n      y$$1 = y$3,\n      defined = constant$10(true),\n      context = null,\n      curve = curveLinear,\n      output = null;\n\n  function line(data) {\n    var i,\n        n = data.length,\n        d,\n        defined0 = false,\n        buffer;\n\n    if (context == null) output = curve(buffer = path());\n\n    for (i = 0; i <= n; ++i) {\n      if (!(i < n && defined(d = data[i], i, data)) === defined0) {\n        if (defined0 = !defined0) output.lineStart();\n        else output.lineEnd();\n      }\n      if (defined0) output.point(+x$$1(d, i, data), +y$$1(d, i, data));\n    }\n\n    if (buffer) return output = null, buffer + \"\" || null;\n  }\n\n  line.x = function(_) {\n    return arguments.length ? (x$$1 = typeof _ === \"function\" ? _ : constant$10(+_), line) : x$$1;\n  };\n\n  line.y = function(_) {\n    return arguments.length ? (y$$1 = typeof _ === \"function\" ? _ : constant$10(+_), line) : y$$1;\n  };\n\n  line.defined = function(_) {\n    return arguments.length ? (defined = typeof _ === \"function\" ? _ : constant$10(!!_), line) : defined;\n  };\n\n  line.curve = function(_) {\n    return arguments.length ? (curve = _, context != null && (output = curve(context)), line) : curve;\n  };\n\n  line.context = function(_) {\n    return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), line) : context;\n  };\n\n  return line;\n};\n\nvar area$2 = function() {\n  var x0 = x$3,\n      x1 = null,\n      y0 = constant$10(0),\n      y1 = y$3,\n      defined = constant$10(true),\n      context = null,\n      curve = curveLinear,\n      output = null;\n\n  function area(data) {\n    var i,\n        j,\n        k,\n        n = data.length,\n        d,\n        defined0 = false,\n        buffer,\n        x0z = new Array(n),\n        y0z = new Array(n);\n\n    if (context == null) output = curve(buffer = path());\n\n    for (i = 0; i <= n; ++i) {\n      if (!(i < n && defined(d = data[i], i, data)) === defined0) {\n        if (defined0 = !defined0) {\n          j = i;\n          output.areaStart();\n          output.lineStart();\n        } else {\n          output.lineEnd();\n          output.lineStart();\n          for (k = i - 1; k >= j; --k) {\n            output.point(x0z[k], y0z[k]);\n          }\n          output.lineEnd();\n          output.areaEnd();\n        }\n      }\n      if (defined0) {\n        x0z[i] = +x0(d, i, data), y0z[i] = +y0(d, i, data);\n        output.point(x1 ? +x1(d, i, data) : x0z[i], y1 ? +y1(d, i, data) : y0z[i]);\n      }\n    }\n\n    if (buffer) return output = null, buffer + \"\" || null;\n  }\n\n  function arealine() {\n    return line().defined(defined).curve(curve).context(context);\n  }\n\n  area.x = function(_) {\n    return arguments.length ? (x0 = typeof _ === \"function\" ? _ : constant$10(+_), x1 = null, area) : x0;\n  };\n\n  area.x0 = function(_) {\n    return arguments.length ? (x0 = typeof _ === \"function\" ? _ : constant$10(+_), area) : x0;\n  };\n\n  area.x1 = function(_) {\n    return arguments.length ? (x1 = _ == null ? null : typeof _ === \"function\" ? _ : constant$10(+_), area) : x1;\n  };\n\n  area.y = function(_) {\n    return arguments.length ? (y0 = typeof _ === \"function\" ? _ : constant$10(+_), y1 = null, area) : y0;\n  };\n\n  area.y0 = function(_) {\n    return arguments.length ? (y0 = typeof _ === \"function\" ? _ : constant$10(+_), area) : y0;\n  };\n\n  area.y1 = function(_) {\n    return arguments.length ? (y1 = _ == null ? null : typeof _ === \"function\" ? _ : constant$10(+_), area) : y1;\n  };\n\n  area.lineX0 =\n  area.lineY0 = function() {\n    return arealine().x(x0).y(y0);\n  };\n\n  area.lineY1 = function() {\n    return arealine().x(x0).y(y1);\n  };\n\n  area.lineX1 = function() {\n    return arealine().x(x1).y(y0);\n  };\n\n  area.defined = function(_) {\n    return arguments.length ? (defined = typeof _ === \"function\" ? _ : constant$10(!!_), area) : defined;\n  };\n\n  area.curve = function(_) {\n    return arguments.length ? (curve = _, context != null && (output = curve(context)), area) : curve;\n  };\n\n  area.context = function(_) {\n    return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), area) : context;\n  };\n\n  return area;\n};\n\nvar descending$1 = function(a, b) {\n  return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;\n};\n\nvar identity$7 = function(d) {\n  return d;\n};\n\nvar pie = function() {\n  var value = identity$7,\n      sortValues = descending$1,\n      sort = null,\n      startAngle = constant$10(0),\n      endAngle = constant$10(tau$4),\n      padAngle = constant$10(0);\n\n  function pie(data) {\n    var i,\n        n = data.length,\n        j,\n        k,\n        sum = 0,\n        index = new Array(n),\n        arcs = new Array(n),\n        a0 = +startAngle.apply(this, arguments),\n        da = Math.min(tau$4, Math.max(-tau$4, endAngle.apply(this, arguments) - a0)),\n        a1,\n        p = Math.min(Math.abs(da) / n, padAngle.apply(this, arguments)),\n        pa = p * (da < 0 ? -1 : 1),\n        v;\n\n    for (i = 0; i < n; ++i) {\n      if ((v = arcs[index[i] = i] = +value(data[i], i, data)) > 0) {\n        sum += v;\n      }\n    }\n\n    // Optionally sort the arcs by previously-computed values or by data.\n    if (sortValues != null) index.sort(function(i, j) { return sortValues(arcs[i], arcs[j]); });\n    else if (sort != null) index.sort(function(i, j) { return sort(data[i], data[j]); });\n\n    // Compute the arcs! They are stored in the original data's order.\n    for (i = 0, k = sum ? (da - n * pa) / sum : 0; i < n; ++i, a0 = a1) {\n      j = index[i], v = arcs[j], a1 = a0 + (v > 0 ? v * k : 0) + pa, arcs[j] = {\n        data: data[j],\n        index: i,\n        value: v,\n        startAngle: a0,\n        endAngle: a1,\n        padAngle: p\n      };\n    }\n\n    return arcs;\n  }\n\n  pie.value = function(_) {\n    return arguments.length ? (value = typeof _ === \"function\" ? _ : constant$10(+_), pie) : value;\n  };\n\n  pie.sortValues = function(_) {\n    return arguments.length ? (sortValues = _, sort = null, pie) : sortValues;\n  };\n\n  pie.sort = function(_) {\n    return arguments.length ? (sort = _, sortValues = null, pie) : sort;\n  };\n\n  pie.startAngle = function(_) {\n    return arguments.length ? (startAngle = typeof _ === \"function\" ? _ : constant$10(+_), pie) : startAngle;\n  };\n\n  pie.endAngle = function(_) {\n    return arguments.length ? (endAngle = typeof _ === \"function\" ? _ : constant$10(+_), pie) : endAngle;\n  };\n\n  pie.padAngle = function(_) {\n    return arguments.length ? (padAngle = typeof _ === \"function\" ? _ : constant$10(+_), pie) : padAngle;\n  };\n\n  return pie;\n};\n\nvar curveRadialLinear = curveRadial(curveLinear);\n\nfunction Radial(curve) {\n  this._curve = curve;\n}\n\nRadial.prototype = {\n  areaStart: function() {\n    this._curve.areaStart();\n  },\n  areaEnd: function() {\n    this._curve.areaEnd();\n  },\n  lineStart: function() {\n    this._curve.lineStart();\n  },\n  lineEnd: function() {\n    this._curve.lineEnd();\n  },\n  point: function(a, r) {\n    this._curve.point(r * Math.sin(a), r * -Math.cos(a));\n  }\n};\n\nfunction curveRadial(curve) {\n\n  function radial(context) {\n    return new Radial(curve(context));\n  }\n\n  radial._curve = curve;\n\n  return radial;\n}\n\nfunction radialLine(l) {\n  var c = l.curve;\n\n  l.angle = l.x, delete l.x;\n  l.radius = l.y, delete l.y;\n\n  l.curve = function(_) {\n    return arguments.length ? c(curveRadial(_)) : c()._curve;\n  };\n\n  return l;\n}\n\nvar radialLine$1 = function() {\n  return radialLine(line().curve(curveRadialLinear));\n};\n\nvar radialArea = function() {\n  var a = area$2().curve(curveRadialLinear),\n      c = a.curve,\n      x0 = a.lineX0,\n      x1 = a.lineX1,\n      y0 = a.lineY0,\n      y1 = a.lineY1;\n\n  a.angle = a.x, delete a.x;\n  a.startAngle = a.x0, delete a.x0;\n  a.endAngle = a.x1, delete a.x1;\n  a.radius = a.y, delete a.y;\n  a.innerRadius = a.y0, delete a.y0;\n  a.outerRadius = a.y1, delete a.y1;\n  a.lineStartAngle = function() { return radialLine(x0()); }, delete a.lineX0;\n  a.lineEndAngle = function() { return radialLine(x1()); }, delete a.lineX1;\n  a.lineInnerRadius = function() { return radialLine(y0()); }, delete a.lineY0;\n  a.lineOuterRadius = function() { return radialLine(y1()); }, delete a.lineY1;\n\n  a.curve = function(_) {\n    return arguments.length ? c(curveRadial(_)) : c()._curve;\n  };\n\n  return a;\n};\n\nvar circle$2 = {\n  draw: function(context, size) {\n    var r = Math.sqrt(size / pi$4);\n    context.moveTo(r, 0);\n    context.arc(0, 0, r, 0, tau$4);\n  }\n};\n\nvar cross$1 = {\n  draw: function(context, size) {\n    var r = Math.sqrt(size / 5) / 2;\n    context.moveTo(-3 * r, -r);\n    context.lineTo(-r, -r);\n    context.lineTo(-r, -3 * r);\n    context.lineTo(r, -3 * r);\n    context.lineTo(r, -r);\n    context.lineTo(3 * r, -r);\n    context.lineTo(3 * r, r);\n    context.lineTo(r, r);\n    context.lineTo(r, 3 * r);\n    context.lineTo(-r, 3 * r);\n    context.lineTo(-r, r);\n    context.lineTo(-3 * r, r);\n    context.closePath();\n  }\n};\n\nvar tan30 = Math.sqrt(1 / 3);\nvar tan30_2 = tan30 * 2;\n\nvar diamond = {\n  draw: function(context, size) {\n    var y = Math.sqrt(size / tan30_2),\n        x = y * tan30;\n    context.moveTo(0, -y);\n    context.lineTo(x, 0);\n    context.lineTo(0, y);\n    context.lineTo(-x, 0);\n    context.closePath();\n  }\n};\n\nvar ka = 0.89081309152928522810;\nvar kr = Math.sin(pi$4 / 10) / Math.sin(7 * pi$4 / 10);\nvar kx = Math.sin(tau$4 / 10) * kr;\nvar ky = -Math.cos(tau$4 / 10) * kr;\n\nvar star = {\n  draw: function(context, size) {\n    var r = Math.sqrt(size * ka),\n        x = kx * r,\n        y = ky * r;\n    context.moveTo(0, -r);\n    context.lineTo(x, y);\n    for (var i = 1; i < 5; ++i) {\n      var a = tau$4 * i / 5,\n          c = Math.cos(a),\n          s = Math.sin(a);\n      context.lineTo(s * r, -c * r);\n      context.lineTo(c * x - s * y, s * x + c * y);\n    }\n    context.closePath();\n  }\n};\n\nvar square = {\n  draw: function(context, size) {\n    var w = Math.sqrt(size),\n        x = -w / 2;\n    context.rect(x, x, w, w);\n  }\n};\n\nvar sqrt3 = Math.sqrt(3);\n\nvar triangle = {\n  draw: function(context, size) {\n    var y = -Math.sqrt(size / (sqrt3 * 3));\n    context.moveTo(0, y * 2);\n    context.lineTo(-sqrt3 * y, -y);\n    context.lineTo(sqrt3 * y, -y);\n    context.closePath();\n  }\n};\n\nvar c = -0.5;\nvar s = Math.sqrt(3) / 2;\nvar k = 1 / Math.sqrt(12);\nvar a = (k / 2 + 1) * 3;\n\nvar wye = {\n  draw: function(context, size) {\n    var r = Math.sqrt(size / a),\n        x0 = r / 2,\n        y0 = r * k,\n        x1 = x0,\n        y1 = r * k + r,\n        x2 = -x1,\n        y2 = y1;\n    context.moveTo(x0, y0);\n    context.lineTo(x1, y1);\n    context.lineTo(x2, y2);\n    context.lineTo(c * x0 - s * y0, s * x0 + c * y0);\n    context.lineTo(c * x1 - s * y1, s * x1 + c * y1);\n    context.lineTo(c * x2 - s * y2, s * x2 + c * y2);\n    context.lineTo(c * x0 + s * y0, c * y0 - s * x0);\n    context.lineTo(c * x1 + s * y1, c * y1 - s * x1);\n    context.lineTo(c * x2 + s * y2, c * y2 - s * x2);\n    context.closePath();\n  }\n};\n\nvar symbols = [\n  circle$2,\n  cross$1,\n  diamond,\n  square,\n  star,\n  triangle,\n  wye\n];\n\nvar symbol = function() {\n  var type = constant$10(circle$2),\n      size = constant$10(64),\n      context = null;\n\n  function symbol() {\n    var buffer;\n    if (!context) context = buffer = path();\n    type.apply(this, arguments).draw(context, +size.apply(this, arguments));\n    if (buffer) return context = null, buffer + \"\" || null;\n  }\n\n  symbol.type = function(_) {\n    return arguments.length ? (type = typeof _ === \"function\" ? _ : constant$10(_), symbol) : type;\n  };\n\n  symbol.size = function(_) {\n    return arguments.length ? (size = typeof _ === \"function\" ? _ : constant$10(+_), symbol) : size;\n  };\n\n  symbol.context = function(_) {\n    return arguments.length ? (context = _ == null ? null : _, symbol) : context;\n  };\n\n  return symbol;\n};\n\nvar noop$2 = function() {};\n\nfunction point$2(that, x, y) {\n  that._context.bezierCurveTo(\n    (2 * that._x0 + that._x1) / 3,\n    (2 * that._y0 + that._y1) / 3,\n    (that._x0 + 2 * that._x1) / 3,\n    (that._y0 + 2 * that._y1) / 3,\n    (that._x0 + 4 * that._x1 + x) / 6,\n    (that._y0 + 4 * that._y1 + y) / 6\n  );\n}\n\nfunction Basis(context) {\n  this._context = context;\n}\n\nBasis.prototype = {\n  areaStart: function() {\n    this._line = 0;\n  },\n  areaEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._x0 = this._x1 =\n    this._y0 = this._y1 = NaN;\n    this._point = 0;\n  },\n  lineEnd: function() {\n    switch (this._point) {\n      case 3: point$2(this, this._x1, this._y1); // proceed\n      case 2: this._context.lineTo(this._x1, this._y1); break;\n    }\n    if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n    this._line = 1 - this._line;\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n    switch (this._point) {\n      case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n      case 1: this._point = 2; break;\n      case 2: this._point = 3; this._context.lineTo((5 * this._x0 + this._x1) / 6, (5 * this._y0 + this._y1) / 6); // proceed\n      default: point$2(this, x, y); break;\n    }\n    this._x0 = this._x1, this._x1 = x;\n    this._y0 = this._y1, this._y1 = y;\n  }\n};\n\nvar basis$2 = function(context) {\n  return new Basis(context);\n};\n\nfunction BasisClosed(context) {\n  this._context = context;\n}\n\nBasisClosed.prototype = {\n  areaStart: noop$2,\n  areaEnd: noop$2,\n  lineStart: function() {\n    this._x0 = this._x1 = this._x2 = this._x3 = this._x4 =\n    this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = NaN;\n    this._point = 0;\n  },\n  lineEnd: function() {\n    switch (this._point) {\n      case 1: {\n        this._context.moveTo(this._x2, this._y2);\n        this._context.closePath();\n        break;\n      }\n      case 2: {\n        this._context.moveTo((this._x2 + 2 * this._x3) / 3, (this._y2 + 2 * this._y3) / 3);\n        this._context.lineTo((this._x3 + 2 * this._x2) / 3, (this._y3 + 2 * this._y2) / 3);\n        this._context.closePath();\n        break;\n      }\n      case 3: {\n        this.point(this._x2, this._y2);\n        this.point(this._x3, this._y3);\n        this.point(this._x4, this._y4);\n        break;\n      }\n    }\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n    switch (this._point) {\n      case 0: this._point = 1; this._x2 = x, this._y2 = y; break;\n      case 1: this._point = 2; this._x3 = x, this._y3 = y; break;\n      case 2: this._point = 3; this._x4 = x, this._y4 = y; this._context.moveTo((this._x0 + 4 * this._x1 + x) / 6, (this._y0 + 4 * this._y1 + y) / 6); break;\n      default: point$2(this, x, y); break;\n    }\n    this._x0 = this._x1, this._x1 = x;\n    this._y0 = this._y1, this._y1 = y;\n  }\n};\n\nvar basisClosed$1 = function(context) {\n  return new BasisClosed(context);\n};\n\nfunction BasisOpen(context) {\n  this._context = context;\n}\n\nBasisOpen.prototype = {\n  areaStart: function() {\n    this._line = 0;\n  },\n  areaEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._x0 = this._x1 =\n    this._y0 = this._y1 = NaN;\n    this._point = 0;\n  },\n  lineEnd: function() {\n    if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath();\n    this._line = 1 - this._line;\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n    switch (this._point) {\n      case 0: this._point = 1; break;\n      case 1: this._point = 2; break;\n      case 2: this._point = 3; var x0 = (this._x0 + 4 * this._x1 + x) / 6, y0 = (this._y0 + 4 * this._y1 + y) / 6; this._line ? this._context.lineTo(x0, y0) : this._context.moveTo(x0, y0); break;\n      case 3: this._point = 4; // proceed\n      default: point$2(this, x, y); break;\n    }\n    this._x0 = this._x1, this._x1 = x;\n    this._y0 = this._y1, this._y1 = y;\n  }\n};\n\nvar basisOpen = function(context) {\n  return new BasisOpen(context);\n};\n\nfunction Bundle(context, beta) {\n  this._basis = new Basis(context);\n  this._beta = beta;\n}\n\nBundle.prototype = {\n  lineStart: function() {\n    this._x = [];\n    this._y = [];\n    this._basis.lineStart();\n  },\n  lineEnd: function() {\n    var x = this._x,\n        y = this._y,\n        j = x.length - 1;\n\n    if (j > 0) {\n      var x0 = x[0],\n          y0 = y[0],\n          dx = x[j] - x0,\n          dy = y[j] - y0,\n          i = -1,\n          t;\n\n      while (++i <= j) {\n        t = i / j;\n        this._basis.point(\n          this._beta * x[i] + (1 - this._beta) * (x0 + t * dx),\n          this._beta * y[i] + (1 - this._beta) * (y0 + t * dy)\n        );\n      }\n    }\n\n    this._x = this._y = null;\n    this._basis.lineEnd();\n  },\n  point: function(x, y) {\n    this._x.push(+x);\n    this._y.push(+y);\n  }\n};\n\nvar bundle = ((function custom(beta) {\n\n  function bundle(context) {\n    return beta === 1 ? new Basis(context) : new Bundle(context, beta);\n  }\n\n  bundle.beta = function(beta) {\n    return custom(+beta);\n  };\n\n  return bundle;\n}))(0.85);\n\nfunction point$3(that, x, y) {\n  that._context.bezierCurveTo(\n    that._x1 + that._k * (that._x2 - that._x0),\n    that._y1 + that._k * (that._y2 - that._y0),\n    that._x2 + that._k * (that._x1 - x),\n    that._y2 + that._k * (that._y1 - y),\n    that._x2,\n    that._y2\n  );\n}\n\nfunction Cardinal(context, tension) {\n  this._context = context;\n  this._k = (1 - tension) / 6;\n}\n\nCardinal.prototype = {\n  areaStart: function() {\n    this._line = 0;\n  },\n  areaEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._x0 = this._x1 = this._x2 =\n    this._y0 = this._y1 = this._y2 = NaN;\n    this._point = 0;\n  },\n  lineEnd: function() {\n    switch (this._point) {\n      case 2: this._context.lineTo(this._x2, this._y2); break;\n      case 3: point$3(this, this._x1, this._y1); break;\n    }\n    if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n    this._line = 1 - this._line;\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n    switch (this._point) {\n      case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n      case 1: this._point = 2; this._x1 = x, this._y1 = y; break;\n      case 2: this._point = 3; // proceed\n      default: point$3(this, x, y); break;\n    }\n    this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n    this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n  }\n};\n\nvar cardinal = ((function custom(tension) {\n\n  function cardinal(context) {\n    return new Cardinal(context, tension);\n  }\n\n  cardinal.tension = function(tension) {\n    return custom(+tension);\n  };\n\n  return cardinal;\n}))(0);\n\nfunction CardinalClosed(context, tension) {\n  this._context = context;\n  this._k = (1 - tension) / 6;\n}\n\nCardinalClosed.prototype = {\n  areaStart: noop$2,\n  areaEnd: noop$2,\n  lineStart: function() {\n    this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 =\n    this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN;\n    this._point = 0;\n  },\n  lineEnd: function() {\n    switch (this._point) {\n      case 1: {\n        this._context.moveTo(this._x3, this._y3);\n        this._context.closePath();\n        break;\n      }\n      case 2: {\n        this._context.lineTo(this._x3, this._y3);\n        this._context.closePath();\n        break;\n      }\n      case 3: {\n        this.point(this._x3, this._y3);\n        this.point(this._x4, this._y4);\n        this.point(this._x5, this._y5);\n        break;\n      }\n    }\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n    switch (this._point) {\n      case 0: this._point = 1; this._x3 = x, this._y3 = y; break;\n      case 1: this._point = 2; this._context.moveTo(this._x4 = x, this._y4 = y); break;\n      case 2: this._point = 3; this._x5 = x, this._y5 = y; break;\n      default: point$3(this, x, y); break;\n    }\n    this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n    this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n  }\n};\n\nvar cardinalClosed = ((function custom(tension) {\n\n  function cardinal(context) {\n    return new CardinalClosed(context, tension);\n  }\n\n  cardinal.tension = function(tension) {\n    return custom(+tension);\n  };\n\n  return cardinal;\n}))(0);\n\nfunction CardinalOpen(context, tension) {\n  this._context = context;\n  this._k = (1 - tension) / 6;\n}\n\nCardinalOpen.prototype = {\n  areaStart: function() {\n    this._line = 0;\n  },\n  areaEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._x0 = this._x1 = this._x2 =\n    this._y0 = this._y1 = this._y2 = NaN;\n    this._point = 0;\n  },\n  lineEnd: function() {\n    if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath();\n    this._line = 1 - this._line;\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n    switch (this._point) {\n      case 0: this._point = 1; break;\n      case 1: this._point = 2; break;\n      case 2: this._point = 3; this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2); break;\n      case 3: this._point = 4; // proceed\n      default: point$3(this, x, y); break;\n    }\n    this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n    this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n  }\n};\n\nvar cardinalOpen = ((function custom(tension) {\n\n  function cardinal(context) {\n    return new CardinalOpen(context, tension);\n  }\n\n  cardinal.tension = function(tension) {\n    return custom(+tension);\n  };\n\n  return cardinal;\n}))(0);\n\nfunction point$4(that, x, y) {\n  var x1 = that._x1,\n      y1 = that._y1,\n      x2 = that._x2,\n      y2 = that._y2;\n\n  if (that._l01_a > epsilon$3) {\n    var a = 2 * that._l01_2a + 3 * that._l01_a * that._l12_a + that._l12_2a,\n        n = 3 * that._l01_a * (that._l01_a + that._l12_a);\n    x1 = (x1 * a - that._x0 * that._l12_2a + that._x2 * that._l01_2a) / n;\n    y1 = (y1 * a - that._y0 * that._l12_2a + that._y2 * that._l01_2a) / n;\n  }\n\n  if (that._l23_a > epsilon$3) {\n    var b = 2 * that._l23_2a + 3 * that._l23_a * that._l12_a + that._l12_2a,\n        m = 3 * that._l23_a * (that._l23_a + that._l12_a);\n    x2 = (x2 * b + that._x1 * that._l23_2a - x * that._l12_2a) / m;\n    y2 = (y2 * b + that._y1 * that._l23_2a - y * that._l12_2a) / m;\n  }\n\n  that._context.bezierCurveTo(x1, y1, x2, y2, that._x2, that._y2);\n}\n\nfunction CatmullRom(context, alpha) {\n  this._context = context;\n  this._alpha = alpha;\n}\n\nCatmullRom.prototype = {\n  areaStart: function() {\n    this._line = 0;\n  },\n  areaEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._x0 = this._x1 = this._x2 =\n    this._y0 = this._y1 = this._y2 = NaN;\n    this._l01_a = this._l12_a = this._l23_a =\n    this._l01_2a = this._l12_2a = this._l23_2a =\n    this._point = 0;\n  },\n  lineEnd: function() {\n    switch (this._point) {\n      case 2: this._context.lineTo(this._x2, this._y2); break;\n      case 3: this.point(this._x2, this._y2); break;\n    }\n    if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n    this._line = 1 - this._line;\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n\n    if (this._point) {\n      var x23 = this._x2 - x,\n          y23 = this._y2 - y;\n      this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));\n    }\n\n    switch (this._point) {\n      case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n      case 1: this._point = 2; break;\n      case 2: this._point = 3; // proceed\n      default: point$4(this, x, y); break;\n    }\n\n    this._l01_a = this._l12_a, this._l12_a = this._l23_a;\n    this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;\n    this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n    this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n  }\n};\n\nvar catmullRom = ((function custom(alpha) {\n\n  function catmullRom(context) {\n    return alpha ? new CatmullRom(context, alpha) : new Cardinal(context, 0);\n  }\n\n  catmullRom.alpha = function(alpha) {\n    return custom(+alpha);\n  };\n\n  return catmullRom;\n}))(0.5);\n\nfunction CatmullRomClosed(context, alpha) {\n  this._context = context;\n  this._alpha = alpha;\n}\n\nCatmullRomClosed.prototype = {\n  areaStart: noop$2,\n  areaEnd: noop$2,\n  lineStart: function() {\n    this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 =\n    this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN;\n    this._l01_a = this._l12_a = this._l23_a =\n    this._l01_2a = this._l12_2a = this._l23_2a =\n    this._point = 0;\n  },\n  lineEnd: function() {\n    switch (this._point) {\n      case 1: {\n        this._context.moveTo(this._x3, this._y3);\n        this._context.closePath();\n        break;\n      }\n      case 2: {\n        this._context.lineTo(this._x3, this._y3);\n        this._context.closePath();\n        break;\n      }\n      case 3: {\n        this.point(this._x3, this._y3);\n        this.point(this._x4, this._y4);\n        this.point(this._x5, this._y5);\n        break;\n      }\n    }\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n\n    if (this._point) {\n      var x23 = this._x2 - x,\n          y23 = this._y2 - y;\n      this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));\n    }\n\n    switch (this._point) {\n      case 0: this._point = 1; this._x3 = x, this._y3 = y; break;\n      case 1: this._point = 2; this._context.moveTo(this._x4 = x, this._y4 = y); break;\n      case 2: this._point = 3; this._x5 = x, this._y5 = y; break;\n      default: point$4(this, x, y); break;\n    }\n\n    this._l01_a = this._l12_a, this._l12_a = this._l23_a;\n    this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;\n    this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n    this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n  }\n};\n\nvar catmullRomClosed = ((function custom(alpha) {\n\n  function catmullRom(context) {\n    return alpha ? new CatmullRomClosed(context, alpha) : new CardinalClosed(context, 0);\n  }\n\n  catmullRom.alpha = function(alpha) {\n    return custom(+alpha);\n  };\n\n  return catmullRom;\n}))(0.5);\n\nfunction CatmullRomOpen(context, alpha) {\n  this._context = context;\n  this._alpha = alpha;\n}\n\nCatmullRomOpen.prototype = {\n  areaStart: function() {\n    this._line = 0;\n  },\n  areaEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._x0 = this._x1 = this._x2 =\n    this._y0 = this._y1 = this._y2 = NaN;\n    this._l01_a = this._l12_a = this._l23_a =\n    this._l01_2a = this._l12_2a = this._l23_2a =\n    this._point = 0;\n  },\n  lineEnd: function() {\n    if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath();\n    this._line = 1 - this._line;\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n\n    if (this._point) {\n      var x23 = this._x2 - x,\n          y23 = this._y2 - y;\n      this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));\n    }\n\n    switch (this._point) {\n      case 0: this._point = 1; break;\n      case 1: this._point = 2; break;\n      case 2: this._point = 3; this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2); break;\n      case 3: this._point = 4; // proceed\n      default: point$4(this, x, y); break;\n    }\n\n    this._l01_a = this._l12_a, this._l12_a = this._l23_a;\n    this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;\n    this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n    this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n  }\n};\n\nvar catmullRomOpen = ((function custom(alpha) {\n\n  function catmullRom(context) {\n    return alpha ? new CatmullRomOpen(context, alpha) : new CardinalOpen(context, 0);\n  }\n\n  catmullRom.alpha = function(alpha) {\n    return custom(+alpha);\n  };\n\n  return catmullRom;\n}))(0.5);\n\nfunction LinearClosed(context) {\n  this._context = context;\n}\n\nLinearClosed.prototype = {\n  areaStart: noop$2,\n  areaEnd: noop$2,\n  lineStart: function() {\n    this._point = 0;\n  },\n  lineEnd: function() {\n    if (this._point) this._context.closePath();\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n    if (this._point) this._context.lineTo(x, y);\n    else this._point = 1, this._context.moveTo(x, y);\n  }\n};\n\nvar linearClosed = function(context) {\n  return new LinearClosed(context);\n};\n\nfunction sign$1(x) {\n  return x < 0 ? -1 : 1;\n}\n\n// Calculate the slopes of the tangents (Hermite-type interpolation) based on\n// the following paper: Steffen, M. 1990. A Simple Method for Monotonic\n// Interpolation in One Dimension. Astronomy and Astrophysics, Vol. 239, NO.\n// NOV(II), P. 443, 1990.\nfunction slope3(that, x2, y2) {\n  var h0 = that._x1 - that._x0,\n      h1 = x2 - that._x1,\n      s0 = (that._y1 - that._y0) / (h0 || h1 < 0 && -0),\n      s1 = (y2 - that._y1) / (h1 || h0 < 0 && -0),\n      p = (s0 * h1 + s1 * h0) / (h0 + h1);\n  return (sign$1(s0) + sign$1(s1)) * Math.min(Math.abs(s0), Math.abs(s1), 0.5 * Math.abs(p)) || 0;\n}\n\n// Calculate a one-sided slope.\nfunction slope2(that, t) {\n  var h = that._x1 - that._x0;\n  return h ? (3 * (that._y1 - that._y0) / h - t) / 2 : t;\n}\n\n// According to https://en.wikipedia.org/wiki/Cubic_Hermite_spline#Representations\n// \"you can express cubic Hermite interpolation in terms of cubic Bézier curves\n// with respect to the four values p0, p0 + m0 / 3, p1 - m1 / 3, p1\".\nfunction point$5(that, t0, t1) {\n  var x0 = that._x0,\n      y0 = that._y0,\n      x1 = that._x1,\n      y1 = that._y1,\n      dx = (x1 - x0) / 3;\n  that._context.bezierCurveTo(x0 + dx, y0 + dx * t0, x1 - dx, y1 - dx * t1, x1, y1);\n}\n\nfunction MonotoneX(context) {\n  this._context = context;\n}\n\nMonotoneX.prototype = {\n  areaStart: function() {\n    this._line = 0;\n  },\n  areaEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._x0 = this._x1 =\n    this._y0 = this._y1 =\n    this._t0 = NaN;\n    this._point = 0;\n  },\n  lineEnd: function() {\n    switch (this._point) {\n      case 2: this._context.lineTo(this._x1, this._y1); break;\n      case 3: point$5(this, this._t0, slope2(this, this._t0)); break;\n    }\n    if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n    this._line = 1 - this._line;\n  },\n  point: function(x, y) {\n    var t1 = NaN;\n\n    x = +x, y = +y;\n    if (x === this._x1 && y === this._y1) return; // Ignore coincident points.\n    switch (this._point) {\n      case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n      case 1: this._point = 2; break;\n      case 2: this._point = 3; point$5(this, slope2(this, t1 = slope3(this, x, y)), t1); break;\n      default: point$5(this, this._t0, t1 = slope3(this, x, y)); break;\n    }\n\n    this._x0 = this._x1, this._x1 = x;\n    this._y0 = this._y1, this._y1 = y;\n    this._t0 = t1;\n  }\n};\n\nfunction MonotoneY(context) {\n  this._context = new ReflectContext(context);\n}\n\n(MonotoneY.prototype = Object.create(MonotoneX.prototype)).point = function(x, y) {\n  MonotoneX.prototype.point.call(this, y, x);\n};\n\nfunction ReflectContext(context) {\n  this._context = context;\n}\n\nReflectContext.prototype = {\n  moveTo: function(x, y) { this._context.moveTo(y, x); },\n  closePath: function() { this._context.closePath(); },\n  lineTo: function(x, y) { this._context.lineTo(y, x); },\n  bezierCurveTo: function(x1, y1, x2, y2, x, y) { this._context.bezierCurveTo(y1, x1, y2, x2, y, x); }\n};\n\nfunction monotoneX(context) {\n  return new MonotoneX(context);\n}\n\nfunction monotoneY(context) {\n  return new MonotoneY(context);\n}\n\nfunction Natural(context) {\n  this._context = context;\n}\n\nNatural.prototype = {\n  areaStart: function() {\n    this._line = 0;\n  },\n  areaEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._x = [];\n    this._y = [];\n  },\n  lineEnd: function() {\n    var x = this._x,\n        y = this._y,\n        n = x.length;\n\n    if (n) {\n      this._line ? this._context.lineTo(x[0], y[0]) : this._context.moveTo(x[0], y[0]);\n      if (n === 2) {\n        this._context.lineTo(x[1], y[1]);\n      } else {\n        var px = controlPoints(x),\n            py = controlPoints(y);\n        for (var i0 = 0, i1 = 1; i1 < n; ++i0, ++i1) {\n          this._context.bezierCurveTo(px[0][i0], py[0][i0], px[1][i0], py[1][i0], x[i1], y[i1]);\n        }\n      }\n    }\n\n    if (this._line || (this._line !== 0 && n === 1)) this._context.closePath();\n    this._line = 1 - this._line;\n    this._x = this._y = null;\n  },\n  point: function(x, y) {\n    this._x.push(+x);\n    this._y.push(+y);\n  }\n};\n\n// See https://www.particleincell.com/2012/bezier-splines/ for derivation.\nfunction controlPoints(x) {\n  var i,\n      n = x.length - 1,\n      m,\n      a = new Array(n),\n      b = new Array(n),\n      r = new Array(n);\n  a[0] = 0, b[0] = 2, r[0] = x[0] + 2 * x[1];\n  for (i = 1; i < n - 1; ++i) a[i] = 1, b[i] = 4, r[i] = 4 * x[i] + 2 * x[i + 1];\n  a[n - 1] = 2, b[n - 1] = 7, r[n - 1] = 8 * x[n - 1] + x[n];\n  for (i = 1; i < n; ++i) m = a[i] / b[i - 1], b[i] -= m, r[i] -= m * r[i - 1];\n  a[n - 1] = r[n - 1] / b[n - 1];\n  for (i = n - 2; i >= 0; --i) a[i] = (r[i] - a[i + 1]) / b[i];\n  b[n - 1] = (x[n] + a[n - 1]) / 2;\n  for (i = 0; i < n - 1; ++i) b[i] = 2 * x[i + 1] - a[i + 1];\n  return [a, b];\n}\n\nvar natural = function(context) {\n  return new Natural(context);\n};\n\nfunction Step(context, t) {\n  this._context = context;\n  this._t = t;\n}\n\nStep.prototype = {\n  areaStart: function() {\n    this._line = 0;\n  },\n  areaEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._x = this._y = NaN;\n    this._point = 0;\n  },\n  lineEnd: function() {\n    if (0 < this._t && this._t < 1 && this._point === 2) this._context.lineTo(this._x, this._y);\n    if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n    if (this._line >= 0) this._t = 1 - this._t, this._line = 1 - this._line;\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n    switch (this._point) {\n      case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n      case 1: this._point = 2; // proceed\n      default: {\n        if (this._t <= 0) {\n          this._context.lineTo(this._x, y);\n          this._context.lineTo(x, y);\n        } else {\n          var x1 = this._x * (1 - this._t) + x * this._t;\n          this._context.lineTo(x1, this._y);\n          this._context.lineTo(x1, y);\n        }\n        break;\n      }\n    }\n    this._x = x, this._y = y;\n  }\n};\n\nvar step = function(context) {\n  return new Step(context, 0.5);\n};\n\nfunction stepBefore(context) {\n  return new Step(context, 0);\n}\n\nfunction stepAfter(context) {\n  return new Step(context, 1);\n}\n\nvar slice$5 = Array.prototype.slice;\n\nvar none$1 = function(series, order) {\n  if (!((n = series.length) > 1)) return;\n  for (var i = 1, s0, s1 = series[order[0]], n, m = s1.length; i < n; ++i) {\n    s0 = s1, s1 = series[order[i]];\n    for (var j = 0; j < m; ++j) {\n      s1[j][1] += s1[j][0] = isNaN(s0[j][1]) ? s0[j][0] : s0[j][1];\n    }\n  }\n};\n\nvar none$2 = function(series) {\n  var n = series.length, o = new Array(n);\n  while (--n >= 0) o[n] = n;\n  return o;\n};\n\nfunction stackValue(d, key) {\n  return d[key];\n}\n\nvar stack = function() {\n  var keys = constant$10([]),\n      order = none$2,\n      offset = none$1,\n      value = stackValue;\n\n  function stack(data) {\n    var kz = keys.apply(this, arguments),\n        i,\n        m = data.length,\n        n = kz.length,\n        sz = new Array(n),\n        oz;\n\n    for (i = 0; i < n; ++i) {\n      for (var ki = kz[i], si = sz[i] = new Array(m), j = 0, sij; j < m; ++j) {\n        si[j] = sij = [0, +value(data[j], ki, j, data)];\n        sij.data = data[j];\n      }\n      si.key = ki;\n    }\n\n    for (i = 0, oz = order(sz); i < n; ++i) {\n      sz[oz[i]].index = i;\n    }\n\n    offset(sz, oz);\n    return sz;\n  }\n\n  stack.keys = function(_) {\n    return arguments.length ? (keys = typeof _ === \"function\" ? _ : constant$10(slice$5.call(_)), stack) : keys;\n  };\n\n  stack.value = function(_) {\n    return arguments.length ? (value = typeof _ === \"function\" ? _ : constant$10(+_), stack) : value;\n  };\n\n  stack.order = function(_) {\n    return arguments.length ? (order = _ == null ? none$2 : typeof _ === \"function\" ? _ : constant$10(slice$5.call(_)), stack) : order;\n  };\n\n  stack.offset = function(_) {\n    return arguments.length ? (offset = _ == null ? none$1 : _, stack) : offset;\n  };\n\n  return stack;\n};\n\nvar expand = function(series, order) {\n  if (!((n = series.length) > 0)) return;\n  for (var i, n, j = 0, m = series[0].length, y; j < m; ++j) {\n    for (y = i = 0; i < n; ++i) y += series[i][j][1] || 0;\n    if (y) for (i = 0; i < n; ++i) series[i][j][1] /= y;\n  }\n  none$1(series, order);\n};\n\nvar silhouette = function(series, order) {\n  if (!((n = series.length) > 0)) return;\n  for (var j = 0, s0 = series[order[0]], n, m = s0.length; j < m; ++j) {\n    for (var i = 0, y = 0; i < n; ++i) y += series[i][j][1] || 0;\n    s0[j][1] += s0[j][0] = -y / 2;\n  }\n  none$1(series, order);\n};\n\nvar wiggle = function(series, order) {\n  if (!((n = series.length) > 0) || !((m = (s0 = series[order[0]]).length) > 0)) return;\n  for (var y = 0, j = 1, s0, m, n; j < m; ++j) {\n    for (var i = 0, s1 = 0, s2 = 0; i < n; ++i) {\n      var si = series[order[i]],\n          sij0 = si[j][1] || 0,\n          sij1 = si[j - 1][1] || 0,\n          s3 = (sij0 - sij1) / 2;\n      for (var k = 0; k < i; ++k) {\n        var sk = series[order[k]],\n            skj0 = sk[j][1] || 0,\n            skj1 = sk[j - 1][1] || 0;\n        s3 += skj0 - skj1;\n      }\n      s1 += sij0, s2 += s3 * sij0;\n    }\n    s0[j - 1][1] += s0[j - 1][0] = y;\n    if (s1) y -= s2 / s1;\n  }\n  s0[j - 1][1] += s0[j - 1][0] = y;\n  none$1(series, order);\n};\n\nvar ascending$2 = function(series) {\n  var sums = series.map(sum$2);\n  return none$2(series).sort(function(a, b) { return sums[a] - sums[b]; });\n};\n\nfunction sum$2(series) {\n  var s = 0, i = -1, n = series.length, v;\n  while (++i < n) if (v = +series[i][1]) s += v;\n  return s;\n}\n\nvar descending$2 = function(series) {\n  return ascending$2(series).reverse();\n};\n\nvar insideOut = function(series) {\n  var n = series.length,\n      i,\n      j,\n      sums = series.map(sum$2),\n      order = none$2(series).sort(function(a, b) { return sums[b] - sums[a]; }),\n      top = 0,\n      bottom = 0,\n      tops = [],\n      bottoms = [];\n\n  for (i = 0; i < n; ++i) {\n    j = order[i];\n    if (top < bottom) {\n      top += sums[j];\n      tops.push(j);\n    } else {\n      bottom += sums[j];\n      bottoms.push(j);\n    }\n  }\n\n  return bottoms.reverse().concat(tops);\n};\n\nvar reverse = function(series) {\n  return none$2(series).reverse();\n};\n\nvar constant$11 = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nfunction x$4(d) {\n  return d[0];\n}\n\nfunction y$4(d) {\n  return d[1];\n}\n\nfunction RedBlackTree() {\n  this._ = null; // root node\n}\n\nfunction RedBlackNode(node) {\n  node.U = // parent node\n  node.C = // color - true for red, false for black\n  node.L = // left node\n  node.R = // right node\n  node.P = // previous node\n  node.N = null; // next node\n}\n\nRedBlackTree.prototype = {\n  constructor: RedBlackTree,\n\n  insert: function(after, node) {\n    var parent, grandpa, uncle;\n\n    if (after) {\n      node.P = after;\n      node.N = after.N;\n      if (after.N) after.N.P = node;\n      after.N = node;\n      if (after.R) {\n        after = after.R;\n        while (after.L) after = after.L;\n        after.L = node;\n      } else {\n        after.R = node;\n      }\n      parent = after;\n    } else if (this._) {\n      after = RedBlackFirst(this._);\n      node.P = null;\n      node.N = after;\n      after.P = after.L = node;\n      parent = after;\n    } else {\n      node.P = node.N = null;\n      this._ = node;\n      parent = null;\n    }\n    node.L = node.R = null;\n    node.U = parent;\n    node.C = true;\n\n    after = node;\n    while (parent && parent.C) {\n      grandpa = parent.U;\n      if (parent === grandpa.L) {\n        uncle = grandpa.R;\n        if (uncle && uncle.C) {\n          parent.C = uncle.C = false;\n          grandpa.C = true;\n          after = grandpa;\n        } else {\n          if (after === parent.R) {\n            RedBlackRotateLeft(this, parent);\n            after = parent;\n            parent = after.U;\n          }\n          parent.C = false;\n          grandpa.C = true;\n          RedBlackRotateRight(this, grandpa);\n        }\n      } else {\n        uncle = grandpa.L;\n        if (uncle && uncle.C) {\n          parent.C = uncle.C = false;\n          grandpa.C = true;\n          after = grandpa;\n        } else {\n          if (after === parent.L) {\n            RedBlackRotateRight(this, parent);\n            after = parent;\n            parent = after.U;\n          }\n          parent.C = false;\n          grandpa.C = true;\n          RedBlackRotateLeft(this, grandpa);\n        }\n      }\n      parent = after.U;\n    }\n    this._.C = false;\n  },\n\n  remove: function(node) {\n    if (node.N) node.N.P = node.P;\n    if (node.P) node.P.N = node.N;\n    node.N = node.P = null;\n\n    var parent = node.U,\n        sibling,\n        left = node.L,\n        right = node.R,\n        next,\n        red;\n\n    if (!left) next = right;\n    else if (!right) next = left;\n    else next = RedBlackFirst(right);\n\n    if (parent) {\n      if (parent.L === node) parent.L = next;\n      else parent.R = next;\n    } else {\n      this._ = next;\n    }\n\n    if (left && right) {\n      red = next.C;\n      next.C = node.C;\n      next.L = left;\n      left.U = next;\n      if (next !== right) {\n        parent = next.U;\n        next.U = node.U;\n        node = next.R;\n        parent.L = node;\n        next.R = right;\n        right.U = next;\n      } else {\n        next.U = parent;\n        parent = next;\n        node = next.R;\n      }\n    } else {\n      red = node.C;\n      node = next;\n    }\n\n    if (node) node.U = parent;\n    if (red) return;\n    if (node && node.C) { node.C = false; return; }\n\n    do {\n      if (node === this._) break;\n      if (node === parent.L) {\n        sibling = parent.R;\n        if (sibling.C) {\n          sibling.C = false;\n          parent.C = true;\n          RedBlackRotateLeft(this, parent);\n          sibling = parent.R;\n        }\n        if ((sibling.L && sibling.L.C)\n            || (sibling.R && sibling.R.C)) {\n          if (!sibling.R || !sibling.R.C) {\n            sibling.L.C = false;\n            sibling.C = true;\n            RedBlackRotateRight(this, sibling);\n            sibling = parent.R;\n          }\n          sibling.C = parent.C;\n          parent.C = sibling.R.C = false;\n          RedBlackRotateLeft(this, parent);\n          node = this._;\n          break;\n        }\n      } else {\n        sibling = parent.L;\n        if (sibling.C) {\n          sibling.C = false;\n          parent.C = true;\n          RedBlackRotateRight(this, parent);\n          sibling = parent.L;\n        }\n        if ((sibling.L && sibling.L.C)\n          || (sibling.R && sibling.R.C)) {\n          if (!sibling.L || !sibling.L.C) {\n            sibling.R.C = false;\n            sibling.C = true;\n            RedBlackRotateLeft(this, sibling);\n            sibling = parent.L;\n          }\n          sibling.C = parent.C;\n          parent.C = sibling.L.C = false;\n          RedBlackRotateRight(this, parent);\n          node = this._;\n          break;\n        }\n      }\n      sibling.C = true;\n      node = parent;\n      parent = parent.U;\n    } while (!node.C);\n\n    if (node) node.C = false;\n  }\n};\n\nfunction RedBlackRotateLeft(tree, node) {\n  var p = node,\n      q = node.R,\n      parent = p.U;\n\n  if (parent) {\n    if (parent.L === p) parent.L = q;\n    else parent.R = q;\n  } else {\n    tree._ = q;\n  }\n\n  q.U = parent;\n  p.U = q;\n  p.R = q.L;\n  if (p.R) p.R.U = p;\n  q.L = p;\n}\n\nfunction RedBlackRotateRight(tree, node) {\n  var p = node,\n      q = node.L,\n      parent = p.U;\n\n  if (parent) {\n    if (parent.L === p) parent.L = q;\n    else parent.R = q;\n  } else {\n    tree._ = q;\n  }\n\n  q.U = parent;\n  p.U = q;\n  p.L = q.R;\n  if (p.L) p.L.U = p;\n  q.R = p;\n}\n\nfunction RedBlackFirst(node) {\n  while (node.L) node = node.L;\n  return node;\n}\n\nfunction createEdge(left, right, v0, v1) {\n  var edge = [null, null],\n      index = edges.push(edge) - 1;\n  edge.left = left;\n  edge.right = right;\n  if (v0) setEdgeEnd(edge, left, right, v0);\n  if (v1) setEdgeEnd(edge, right, left, v1);\n  cells[left.index].halfedges.push(index);\n  cells[right.index].halfedges.push(index);\n  return edge;\n}\n\nfunction createBorderEdge(left, v0, v1) {\n  var edge = [v0, v1];\n  edge.left = left;\n  return edge;\n}\n\nfunction setEdgeEnd(edge, left, right, vertex) {\n  if (!edge[0] && !edge[1]) {\n    edge[0] = vertex;\n    edge.left = left;\n    edge.right = right;\n  } else if (edge.left === right) {\n    edge[1] = vertex;\n  } else {\n    edge[0] = vertex;\n  }\n}\n\n// Liang–Barsky line clipping.\nfunction clipEdge(edge, x0, y0, x1, y1) {\n  var a = edge[0],\n      b = edge[1],\n      ax = a[0],\n      ay = a[1],\n      bx = b[0],\n      by = b[1],\n      t0 = 0,\n      t1 = 1,\n      dx = bx - ax,\n      dy = by - ay,\n      r;\n\n  r = x0 - ax;\n  if (!dx && r > 0) return;\n  r /= dx;\n  if (dx < 0) {\n    if (r < t0) return;\n    if (r < t1) t1 = r;\n  } else if (dx > 0) {\n    if (r > t1) return;\n    if (r > t0) t0 = r;\n  }\n\n  r = x1 - ax;\n  if (!dx && r < 0) return;\n  r /= dx;\n  if (dx < 0) {\n    if (r > t1) return;\n    if (r > t0) t0 = r;\n  } else if (dx > 0) {\n    if (r < t0) return;\n    if (r < t1) t1 = r;\n  }\n\n  r = y0 - ay;\n  if (!dy && r > 0) return;\n  r /= dy;\n  if (dy < 0) {\n    if (r < t0) return;\n    if (r < t1) t1 = r;\n  } else if (dy > 0) {\n    if (r > t1) return;\n    if (r > t0) t0 = r;\n  }\n\n  r = y1 - ay;\n  if (!dy && r < 0) return;\n  r /= dy;\n  if (dy < 0) {\n    if (r > t1) return;\n    if (r > t0) t0 = r;\n  } else if (dy > 0) {\n    if (r < t0) return;\n    if (r < t1) t1 = r;\n  }\n\n  if (!(t0 > 0) && !(t1 < 1)) return true; // TODO Better check?\n\n  if (t0 > 0) edge[0] = [ax + t0 * dx, ay + t0 * dy];\n  if (t1 < 1) edge[1] = [ax + t1 * dx, ay + t1 * dy];\n  return true;\n}\n\nfunction connectEdge(edge, x0, y0, x1, y1) {\n  var v1 = edge[1];\n  if (v1) return true;\n\n  var v0 = edge[0],\n      left = edge.left,\n      right = edge.right,\n      lx = left[0],\n      ly = left[1],\n      rx = right[0],\n      ry = right[1],\n      fx = (lx + rx) / 2,\n      fy = (ly + ry) / 2,\n      fm,\n      fb;\n\n  if (ry === ly) {\n    if (fx < x0 || fx >= x1) return;\n    if (lx > rx) {\n      if (!v0) v0 = [fx, y0];\n      else if (v0[1] >= y1) return;\n      v1 = [fx, y1];\n    } else {\n      if (!v0) v0 = [fx, y1];\n      else if (v0[1] < y0) return;\n      v1 = [fx, y0];\n    }\n  } else {\n    fm = (lx - rx) / (ry - ly);\n    fb = fy - fm * fx;\n    if (fm < -1 || fm > 1) {\n      if (lx > rx) {\n        if (!v0) v0 = [(y0 - fb) / fm, y0];\n        else if (v0[1] >= y1) return;\n        v1 = [(y1 - fb) / fm, y1];\n      } else {\n        if (!v0) v0 = [(y1 - fb) / fm, y1];\n        else if (v0[1] < y0) return;\n        v1 = [(y0 - fb) / fm, y0];\n      }\n    } else {\n      if (ly < ry) {\n        if (!v0) v0 = [x0, fm * x0 + fb];\n        else if (v0[0] >= x1) return;\n        v1 = [x1, fm * x1 + fb];\n      } else {\n        if (!v0) v0 = [x1, fm * x1 + fb];\n        else if (v0[0] < x0) return;\n        v1 = [x0, fm * x0 + fb];\n      }\n    }\n  }\n\n  edge[0] = v0;\n  edge[1] = v1;\n  return true;\n}\n\nfunction clipEdges(x0, y0, x1, y1) {\n  var i = edges.length,\n      edge;\n\n  while (i--) {\n    if (!connectEdge(edge = edges[i], x0, y0, x1, y1)\n        || !clipEdge(edge, x0, y0, x1, y1)\n        || !(Math.abs(edge[0][0] - edge[1][0]) > epsilon$4\n            || Math.abs(edge[0][1] - edge[1][1]) > epsilon$4)) {\n      delete edges[i];\n    }\n  }\n}\n\nfunction createCell(site) {\n  return cells[site.index] = {\n    site: site,\n    halfedges: []\n  };\n}\n\nfunction cellHalfedgeAngle(cell, edge) {\n  var site = cell.site,\n      va = edge.left,\n      vb = edge.right;\n  if (site === vb) vb = va, va = site;\n  if (vb) return Math.atan2(vb[1] - va[1], vb[0] - va[0]);\n  if (site === va) va = edge[1], vb = edge[0];\n  else va = edge[0], vb = edge[1];\n  return Math.atan2(va[0] - vb[0], vb[1] - va[1]);\n}\n\nfunction cellHalfedgeStart(cell, edge) {\n  return edge[+(edge.left !== cell.site)];\n}\n\nfunction cellHalfedgeEnd(cell, edge) {\n  return edge[+(edge.left === cell.site)];\n}\n\nfunction sortCellHalfedges() {\n  for (var i = 0, n = cells.length, cell, halfedges, j, m; i < n; ++i) {\n    if ((cell = cells[i]) && (m = (halfedges = cell.halfedges).length)) {\n      var index = new Array(m),\n          array = new Array(m);\n      for (j = 0; j < m; ++j) index[j] = j, array[j] = cellHalfedgeAngle(cell, edges[halfedges[j]]);\n      index.sort(function(i, j) { return array[j] - array[i]; });\n      for (j = 0; j < m; ++j) array[j] = halfedges[index[j]];\n      for (j = 0; j < m; ++j) halfedges[j] = array[j];\n    }\n  }\n}\n\nfunction clipCells(x0, y0, x1, y1) {\n  var nCells = cells.length,\n      iCell,\n      cell,\n      site,\n      iHalfedge,\n      halfedges,\n      nHalfedges,\n      start,\n      startX,\n      startY,\n      end,\n      endX,\n      endY,\n      cover = true;\n\n  for (iCell = 0; iCell < nCells; ++iCell) {\n    if (cell = cells[iCell]) {\n      site = cell.site;\n      halfedges = cell.halfedges;\n      iHalfedge = halfedges.length;\n\n      // Remove any dangling clipped edges.\n      while (iHalfedge--) {\n        if (!edges[halfedges[iHalfedge]]) {\n          halfedges.splice(iHalfedge, 1);\n        }\n      }\n\n      // Insert any border edges as necessary.\n      iHalfedge = 0, nHalfedges = halfedges.length;\n      while (iHalfedge < nHalfedges) {\n        end = cellHalfedgeEnd(cell, edges[halfedges[iHalfedge]]), endX = end[0], endY = end[1];\n        start = cellHalfedgeStart(cell, edges[halfedges[++iHalfedge % nHalfedges]]), startX = start[0], startY = start[1];\n        if (Math.abs(endX - startX) > epsilon$4 || Math.abs(endY - startY) > epsilon$4) {\n          halfedges.splice(iHalfedge, 0, edges.push(createBorderEdge(site, end,\n              Math.abs(endX - x0) < epsilon$4 && y1 - endY > epsilon$4 ? [x0, Math.abs(startX - x0) < epsilon$4 ? startY : y1]\n              : Math.abs(endY - y1) < epsilon$4 && x1 - endX > epsilon$4 ? [Math.abs(startY - y1) < epsilon$4 ? startX : x1, y1]\n              : Math.abs(endX - x1) < epsilon$4 && endY - y0 > epsilon$4 ? [x1, Math.abs(startX - x1) < epsilon$4 ? startY : y0]\n              : Math.abs(endY - y0) < epsilon$4 && endX - x0 > epsilon$4 ? [Math.abs(startY - y0) < epsilon$4 ? startX : x0, y0]\n              : null)) - 1);\n          ++nHalfedges;\n        }\n      }\n\n      if (nHalfedges) cover = false;\n    }\n  }\n\n  // If there weren’t any edges, have the closest site cover the extent.\n  // It doesn’t matter which corner of the extent we measure!\n  if (cover) {\n    var dx, dy, d2, dc = Infinity;\n\n    for (iCell = 0, cover = null; iCell < nCells; ++iCell) {\n      if (cell = cells[iCell]) {\n        site = cell.site;\n        dx = site[0] - x0;\n        dy = site[1] - y0;\n        d2 = dx * dx + dy * dy;\n        if (d2 < dc) dc = d2, cover = cell;\n      }\n    }\n\n    if (cover) {\n      var v00 = [x0, y0], v01 = [x0, y1], v11 = [x1, y1], v10 = [x1, y0];\n      cover.halfedges.push(\n        edges.push(createBorderEdge(site = cover.site, v00, v01)) - 1,\n        edges.push(createBorderEdge(site, v01, v11)) - 1,\n        edges.push(createBorderEdge(site, v11, v10)) - 1,\n        edges.push(createBorderEdge(site, v10, v00)) - 1\n      );\n    }\n  }\n\n  // Lastly delete any cells with no edges; these were entirely clipped.\n  for (iCell = 0; iCell < nCells; ++iCell) {\n    if (cell = cells[iCell]) {\n      if (!cell.halfedges.length) {\n        delete cells[iCell];\n      }\n    }\n  }\n}\n\nvar circlePool = [];\n\nvar firstCircle;\n\nfunction Circle() {\n  RedBlackNode(this);\n  this.x =\n  this.y =\n  this.arc =\n  this.site =\n  this.cy = null;\n}\n\nfunction attachCircle(arc) {\n  var lArc = arc.P,\n      rArc = arc.N;\n\n  if (!lArc || !rArc) return;\n\n  var lSite = lArc.site,\n      cSite = arc.site,\n      rSite = rArc.site;\n\n  if (lSite === rSite) return;\n\n  var bx = cSite[0],\n      by = cSite[1],\n      ax = lSite[0] - bx,\n      ay = lSite[1] - by,\n      cx = rSite[0] - bx,\n      cy = rSite[1] - by;\n\n  var d = 2 * (ax * cy - ay * cx);\n  if (d >= -epsilon2$2) return;\n\n  var ha = ax * ax + ay * ay,\n      hc = cx * cx + cy * cy,\n      x = (cy * ha - ay * hc) / d,\n      y = (ax * hc - cx * ha) / d;\n\n  var circle = circlePool.pop() || new Circle;\n  circle.arc = arc;\n  circle.site = cSite;\n  circle.x = x + bx;\n  circle.y = (circle.cy = y + by) + Math.sqrt(x * x + y * y); // y bottom\n\n  arc.circle = circle;\n\n  var before = null,\n      node = circles._;\n\n  while (node) {\n    if (circle.y < node.y || (circle.y === node.y && circle.x <= node.x)) {\n      if (node.L) node = node.L;\n      else { before = node.P; break; }\n    } else {\n      if (node.R) node = node.R;\n      else { before = node; break; }\n    }\n  }\n\n  circles.insert(before, circle);\n  if (!before) firstCircle = circle;\n}\n\nfunction detachCircle(arc) {\n  var circle = arc.circle;\n  if (circle) {\n    if (!circle.P) firstCircle = circle.N;\n    circles.remove(circle);\n    circlePool.push(circle);\n    RedBlackNode(circle);\n    arc.circle = null;\n  }\n}\n\nvar beachPool = [];\n\nfunction Beach() {\n  RedBlackNode(this);\n  this.edge =\n  this.site =\n  this.circle = null;\n}\n\nfunction createBeach(site) {\n  var beach = beachPool.pop() || new Beach;\n  beach.site = site;\n  return beach;\n}\n\nfunction detachBeach(beach) {\n  detachCircle(beach);\n  beaches.remove(beach);\n  beachPool.push(beach);\n  RedBlackNode(beach);\n}\n\nfunction removeBeach(beach) {\n  var circle = beach.circle,\n      x = circle.x,\n      y = circle.cy,\n      vertex = [x, y],\n      previous = beach.P,\n      next = beach.N,\n      disappearing = [beach];\n\n  detachBeach(beach);\n\n  var lArc = previous;\n  while (lArc.circle\n      && Math.abs(x - lArc.circle.x) < epsilon$4\n      && Math.abs(y - lArc.circle.cy) < epsilon$4) {\n    previous = lArc.P;\n    disappearing.unshift(lArc);\n    detachBeach(lArc);\n    lArc = previous;\n  }\n\n  disappearing.unshift(lArc);\n  detachCircle(lArc);\n\n  var rArc = next;\n  while (rArc.circle\n      && Math.abs(x - rArc.circle.x) < epsilon$4\n      && Math.abs(y - rArc.circle.cy) < epsilon$4) {\n    next = rArc.N;\n    disappearing.push(rArc);\n    detachBeach(rArc);\n    rArc = next;\n  }\n\n  disappearing.push(rArc);\n  detachCircle(rArc);\n\n  var nArcs = disappearing.length,\n      iArc;\n  for (iArc = 1; iArc < nArcs; ++iArc) {\n    rArc = disappearing[iArc];\n    lArc = disappearing[iArc - 1];\n    setEdgeEnd(rArc.edge, lArc.site, rArc.site, vertex);\n  }\n\n  lArc = disappearing[0];\n  rArc = disappearing[nArcs - 1];\n  rArc.edge = createEdge(lArc.site, rArc.site, null, vertex);\n\n  attachCircle(lArc);\n  attachCircle(rArc);\n}\n\nfunction addBeach(site) {\n  var x = site[0],\n      directrix = site[1],\n      lArc,\n      rArc,\n      dxl,\n      dxr,\n      node = beaches._;\n\n  while (node) {\n    dxl = leftBreakPoint(node, directrix) - x;\n    if (dxl > epsilon$4) node = node.L; else {\n      dxr = x - rightBreakPoint(node, directrix);\n      if (dxr > epsilon$4) {\n        if (!node.R) {\n          lArc = node;\n          break;\n        }\n        node = node.R;\n      } else {\n        if (dxl > -epsilon$4) {\n          lArc = node.P;\n          rArc = node;\n        } else if (dxr > -epsilon$4) {\n          lArc = node;\n          rArc = node.N;\n        } else {\n          lArc = rArc = node;\n        }\n        break;\n      }\n    }\n  }\n\n  createCell(site);\n  var newArc = createBeach(site);\n  beaches.insert(lArc, newArc);\n\n  if (!lArc && !rArc) return;\n\n  if (lArc === rArc) {\n    detachCircle(lArc);\n    rArc = createBeach(lArc.site);\n    beaches.insert(newArc, rArc);\n    newArc.edge = rArc.edge = createEdge(lArc.site, newArc.site);\n    attachCircle(lArc);\n    attachCircle(rArc);\n    return;\n  }\n\n  if (!rArc) { // && lArc\n    newArc.edge = createEdge(lArc.site, newArc.site);\n    return;\n  }\n\n  // else lArc !== rArc\n  detachCircle(lArc);\n  detachCircle(rArc);\n\n  var lSite = lArc.site,\n      ax = lSite[0],\n      ay = lSite[1],\n      bx = site[0] - ax,\n      by = site[1] - ay,\n      rSite = rArc.site,\n      cx = rSite[0] - ax,\n      cy = rSite[1] - ay,\n      d = 2 * (bx * cy - by * cx),\n      hb = bx * bx + by * by,\n      hc = cx * cx + cy * cy,\n      vertex = [(cy * hb - by * hc) / d + ax, (bx * hc - cx * hb) / d + ay];\n\n  setEdgeEnd(rArc.edge, lSite, rSite, vertex);\n  newArc.edge = createEdge(lSite, site, null, vertex);\n  rArc.edge = createEdge(site, rSite, null, vertex);\n  attachCircle(lArc);\n  attachCircle(rArc);\n}\n\nfunction leftBreakPoint(arc, directrix) {\n  var site = arc.site,\n      rfocx = site[0],\n      rfocy = site[1],\n      pby2 = rfocy - directrix;\n\n  if (!pby2) return rfocx;\n\n  var lArc = arc.P;\n  if (!lArc) return -Infinity;\n\n  site = lArc.site;\n  var lfocx = site[0],\n      lfocy = site[1],\n      plby2 = lfocy - directrix;\n\n  if (!plby2) return lfocx;\n\n  var hl = lfocx - rfocx,\n      aby2 = 1 / pby2 - 1 / plby2,\n      b = hl / plby2;\n\n  if (aby2) return (-b + Math.sqrt(b * b - 2 * aby2 * (hl * hl / (-2 * plby2) - lfocy + plby2 / 2 + rfocy - pby2 / 2))) / aby2 + rfocx;\n\n  return (rfocx + lfocx) / 2;\n}\n\nfunction rightBreakPoint(arc, directrix) {\n  var rArc = arc.N;\n  if (rArc) return leftBreakPoint(rArc, directrix);\n  var site = arc.site;\n  return site[1] === directrix ? site[0] : Infinity;\n}\n\nvar epsilon$4 = 1e-6;\nvar epsilon2$2 = 1e-12;\nvar beaches;\nvar cells;\nvar circles;\nvar edges;\n\nfunction triangleArea(a, b, c) {\n  return (a[0] - c[0]) * (b[1] - a[1]) - (a[0] - b[0]) * (c[1] - a[1]);\n}\n\nfunction lexicographic(a, b) {\n  return b[1] - a[1]\n      || b[0] - a[0];\n}\n\nfunction Diagram(sites, extent) {\n  var site = sites.sort(lexicographic).pop(),\n      x,\n      y,\n      circle;\n\n  edges = [];\n  cells = new Array(sites.length);\n  beaches = new RedBlackTree;\n  circles = new RedBlackTree;\n\n  while (true) {\n    circle = firstCircle;\n    if (site && (!circle || site[1] < circle.y || (site[1] === circle.y && site[0] < circle.x))) {\n      if (site[0] !== x || site[1] !== y) {\n        addBeach(site);\n        x = site[0], y = site[1];\n      }\n      site = sites.pop();\n    } else if (circle) {\n      removeBeach(circle.arc);\n    } else {\n      break;\n    }\n  }\n\n  sortCellHalfedges();\n\n  if (extent) {\n    var x0 = +extent[0][0],\n        y0 = +extent[0][1],\n        x1 = +extent[1][0],\n        y1 = +extent[1][1];\n    clipEdges(x0, y0, x1, y1);\n    clipCells(x0, y0, x1, y1);\n  }\n\n  this.edges = edges;\n  this.cells = cells;\n\n  beaches =\n  circles =\n  edges =\n  cells = null;\n}\n\nDiagram.prototype = {\n  constructor: Diagram,\n\n  polygons: function() {\n    var edges = this.edges;\n\n    return this.cells.map(function(cell) {\n      var polygon = cell.halfedges.map(function(i) { return cellHalfedgeStart(cell, edges[i]); });\n      polygon.data = cell.site.data;\n      return polygon;\n    });\n  },\n\n  triangles: function() {\n    var triangles = [],\n        edges = this.edges;\n\n    this.cells.forEach(function(cell, i) {\n      if (!(m = (halfedges = cell.halfedges).length)) return;\n      var site = cell.site,\n          halfedges,\n          j = -1,\n          m,\n          s0,\n          e1 = edges[halfedges[m - 1]],\n          s1 = e1.left === site ? e1.right : e1.left;\n\n      while (++j < m) {\n        s0 = s1;\n        e1 = edges[halfedges[j]];\n        s1 = e1.left === site ? e1.right : e1.left;\n        if (s0 && s1 && i < s0.index && i < s1.index && triangleArea(site, s0, s1) < 0) {\n          triangles.push([site.data, s0.data, s1.data]);\n        }\n      }\n    });\n\n    return triangles;\n  },\n\n  links: function() {\n    return this.edges.filter(function(edge) {\n      return edge.right;\n    }).map(function(edge) {\n      return {\n        source: edge.left.data,\n        target: edge.right.data\n      };\n    });\n  },\n\n  find: function(x, y, radius) {\n    var that = this, i0, i1 = that._found || 0, n = that.cells.length, cell;\n\n    // Use the previously-found cell, or start with an arbitrary one.\n    while (!(cell = that.cells[i1])) if (++i1 >= n) return null;\n    var dx = x - cell.site[0], dy = y - cell.site[1], d2 = dx * dx + dy * dy;\n\n    // Traverse the half-edges to find a closer cell, if any.\n    do {\n      cell = that.cells[i0 = i1], i1 = null;\n      cell.halfedges.forEach(function(e) {\n        var edge = that.edges[e], v = edge.left;\n        if ((v === cell.site || !v) && !(v = edge.right)) return;\n        var vx = x - v[0], vy = y - v[1], v2 = vx * vx + vy * vy;\n        if (v2 < d2) d2 = v2, i1 = v.index;\n      });\n    } while (i1 !== null);\n\n    that._found = i0;\n\n    return radius == null || d2 <= radius * radius ? cell.site : null;\n  }\n};\n\nvar voronoi = function() {\n  var x$$1 = x$4,\n      y$$1 = y$4,\n      extent = null;\n\n  function voronoi(data) {\n    return new Diagram(data.map(function(d, i) {\n      var s = [Math.round(x$$1(d, i, data) / epsilon$4) * epsilon$4, Math.round(y$$1(d, i, data) / epsilon$4) * epsilon$4];\n      s.index = i;\n      s.data = d;\n      return s;\n    }), extent);\n  }\n\n  voronoi.polygons = function(data) {\n    return voronoi(data).polygons();\n  };\n\n  voronoi.links = function(data) {\n    return voronoi(data).links();\n  };\n\n  voronoi.triangles = function(data) {\n    return voronoi(data).triangles();\n  };\n\n  voronoi.x = function(_) {\n    return arguments.length ? (x$$1 = typeof _ === \"function\" ? _ : constant$11(+_), voronoi) : x$$1;\n  };\n\n  voronoi.y = function(_) {\n    return arguments.length ? (y$$1 = typeof _ === \"function\" ? _ : constant$11(+_), voronoi) : y$$1;\n  };\n\n  voronoi.extent = function(_) {\n    return arguments.length ? (extent = _ == null ? null : [[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]], voronoi) : extent && [[extent[0][0], extent[0][1]], [extent[1][0], extent[1][1]]];\n  };\n\n  voronoi.size = function(_) {\n    return arguments.length ? (extent = _ == null ? null : [[0, 0], [+_[0], +_[1]]], voronoi) : extent && [extent[1][0] - extent[0][0], extent[1][1] - extent[0][1]];\n  };\n\n  return voronoi;\n};\n\nvar constant$12 = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nfunction ZoomEvent(target, type, transform) {\n  this.target = target;\n  this.type = type;\n  this.transform = transform;\n}\n\nfunction Transform(k, x, y) {\n  this.k = k;\n  this.x = x;\n  this.y = y;\n}\n\nTransform.prototype = {\n  constructor: Transform,\n  scale: function(k) {\n    return k === 1 ? this : new Transform(this.k * k, this.x, this.y);\n  },\n  translate: function(x, y) {\n    return x === 0 & y === 0 ? this : new Transform(this.k, this.x + this.k * x, this.y + this.k * y);\n  },\n  apply: function(point) {\n    return [point[0] * this.k + this.x, point[1] * this.k + this.y];\n  },\n  applyX: function(x) {\n    return x * this.k + this.x;\n  },\n  applyY: function(y) {\n    return y * this.k + this.y;\n  },\n  invert: function(location) {\n    return [(location[0] - this.x) / this.k, (location[1] - this.y) / this.k];\n  },\n  invertX: function(x) {\n    return (x - this.x) / this.k;\n  },\n  invertY: function(y) {\n    return (y - this.y) / this.k;\n  },\n  rescaleX: function(x) {\n    return x.copy().domain(x.range().map(this.invertX, this).map(x.invert, x));\n  },\n  rescaleY: function(y) {\n    return y.copy().domain(y.range().map(this.invertY, this).map(y.invert, y));\n  },\n  toString: function() {\n    return \"translate(\" + this.x + \",\" + this.y + \") scale(\" + this.k + \")\";\n  }\n};\n\nvar identity$8 = new Transform(1, 0, 0);\n\ntransform$1.prototype = Transform.prototype;\n\nfunction transform$1(node) {\n  return node.__zoom || identity$8;\n}\n\nfunction nopropagation$2() {\n  exports.event.stopImmediatePropagation();\n}\n\nvar noevent$2 = function() {\n  exports.event.preventDefault();\n  exports.event.stopImmediatePropagation();\n};\n\n// Ignore right-click, since that should open the context menu.\nfunction defaultFilter$2() {\n  return !exports.event.button;\n}\n\nfunction defaultExtent$1() {\n  var e = this, w, h;\n  if (e instanceof SVGElement) {\n    e = e.ownerSVGElement || e;\n    w = e.width.baseVal.value;\n    h = e.height.baseVal.value;\n  } else {\n    w = e.clientWidth;\n    h = e.clientHeight;\n  }\n  return [[0, 0], [w, h]];\n}\n\nfunction defaultTransform() {\n  return this.__zoom || identity$8;\n}\n\nvar zoom = function() {\n  var filter = defaultFilter$2,\n      extent = defaultExtent$1,\n      k0 = 0,\n      k1 = Infinity,\n      x0 = -k1,\n      x1 = k1,\n      y0 = x0,\n      y1 = x1,\n      duration = 250,\n      interpolate$$1 = interpolateZoom,\n      gestures = [],\n      listeners = dispatch(\"start\", \"zoom\", \"end\"),\n      touchstarting,\n      touchending,\n      touchDelay = 500,\n      wheelDelay = 150;\n\n  function zoom(selection$$1) {\n    selection$$1\n        .on(\"wheel.zoom\", wheeled)\n        .on(\"mousedown.zoom\", mousedowned)\n        .on(\"dblclick.zoom\", dblclicked)\n        .on(\"touchstart.zoom\", touchstarted)\n        .on(\"touchmove.zoom\", touchmoved)\n        .on(\"touchend.zoom touchcancel.zoom\", touchended)\n        .style(\"-webkit-tap-highlight-color\", \"rgba(0,0,0,0)\")\n        .property(\"__zoom\", defaultTransform);\n  }\n\n  zoom.transform = function(collection, transform) {\n    var selection$$1 = collection.selection ? collection.selection() : collection;\n    selection$$1.property(\"__zoom\", defaultTransform);\n    if (collection !== selection$$1) {\n      schedule(collection, transform);\n    } else {\n      selection$$1.interrupt().each(function() {\n        gesture(this, arguments)\n            .start()\n            .zoom(null, typeof transform === \"function\" ? transform.apply(this, arguments) : transform)\n            .end();\n      });\n    }\n  };\n\n  zoom.scaleBy = function(selection$$1, k) {\n    zoom.scaleTo(selection$$1, function() {\n      var k0 = this.__zoom.k,\n          k1 = typeof k === \"function\" ? k.apply(this, arguments) : k;\n      return k0 * k1;\n    });\n  };\n\n  zoom.scaleTo = function(selection$$1, k) {\n    zoom.transform(selection$$1, function() {\n      var e = extent.apply(this, arguments),\n          t0 = this.__zoom,\n          p0 = centroid(e),\n          p1 = t0.invert(p0),\n          k1 = typeof k === \"function\" ? k.apply(this, arguments) : k;\n      return constrain(translate(scale(t0, k1), p0, p1), e);\n    });\n  };\n\n  zoom.translateBy = function(selection$$1, x, y) {\n    zoom.transform(selection$$1, function() {\n      return constrain(this.__zoom.translate(\n        typeof x === \"function\" ? x.apply(this, arguments) : x,\n        typeof y === \"function\" ? y.apply(this, arguments) : y\n      ), extent.apply(this, arguments));\n    });\n  };\n\n  function scale(transform, k) {\n    k = Math.max(k0, Math.min(k1, k));\n    return k === transform.k ? transform : new Transform(k, transform.x, transform.y);\n  }\n\n  function translate(transform, p0, p1) {\n    var x = p0[0] - p1[0] * transform.k, y = p0[1] - p1[1] * transform.k;\n    return x === transform.x && y === transform.y ? transform : new Transform(transform.k, x, y);\n  }\n\n  function constrain(transform, extent) {\n    var dx0 = transform.invertX(extent[0][0]) - x0,\n        dx1 = transform.invertX(extent[1][0]) - x1,\n        dy0 = transform.invertY(extent[0][1]) - y0,\n        dy1 = transform.invertY(extent[1][1]) - y1;\n    return transform.translate(\n      dx1 > dx0 ? (dx0 + dx1) / 2 : Math.min(0, dx0) || Math.max(0, dx1),\n      dy1 > dy0 ? (dy0 + dy1) / 2 : Math.min(0, dy0) || Math.max(0, dy1)\n    );\n  }\n\n  function centroid(extent) {\n    return [(+extent[0][0] + +extent[1][0]) / 2, (+extent[0][1] + +extent[1][1]) / 2];\n  }\n\n  function schedule(transition$$1, transform, center) {\n    transition$$1\n        .on(\"start.zoom\", function() { gesture(this, arguments).start(); })\n        .on(\"interrupt.zoom end.zoom\", function() { gesture(this, arguments).end(); })\n        .tween(\"zoom\", function() {\n          var that = this,\n              args = arguments,\n              g = gesture(that, args),\n              e = extent.apply(that, args),\n              p = center || centroid(e),\n              w = Math.max(e[1][0] - e[0][0], e[1][1] - e[0][1]),\n              a = that.__zoom,\n              b = typeof transform === \"function\" ? transform.apply(that, args) : transform,\n              i = interpolate$$1(a.invert(p).concat(w / a.k), b.invert(p).concat(w / b.k));\n          return function(t) {\n            if (t === 1) t = b; // Avoid rounding error on end.\n            else { var l = i(t), k = w / l[2]; t = new Transform(k, p[0] - l[0] * k, p[1] - l[1] * k); }\n            g.zoom(null, t);\n          };\n        });\n  }\n\n  function gesture(that, args) {\n    for (var i = 0, n = gestures.length, g; i < n; ++i) {\n      if ((g = gestures[i]).that === that) {\n        return g;\n      }\n    }\n    return new Gesture(that, args);\n  }\n\n  function Gesture(that, args) {\n    this.that = that;\n    this.args = args;\n    this.index = -1;\n    this.active = 0;\n    this.extent = extent.apply(that, args);\n  }\n\n  Gesture.prototype = {\n    start: function() {\n      if (++this.active === 1) {\n        this.index = gestures.push(this) - 1;\n        this.emit(\"start\");\n      }\n      return this;\n    },\n    zoom: function(key, transform) {\n      if (this.mouse && key !== \"mouse\") this.mouse[1] = transform.invert(this.mouse[0]);\n      if (this.touch0 && key !== \"touch\") this.touch0[1] = transform.invert(this.touch0[0]);\n      if (this.touch1 && key !== \"touch\") this.touch1[1] = transform.invert(this.touch1[0]);\n      this.that.__zoom = transform;\n      this.emit(\"zoom\");\n      return this;\n    },\n    end: function() {\n      if (--this.active === 0) {\n        gestures.splice(this.index, 1);\n        this.index = -1;\n        this.emit(\"end\");\n      }\n      return this;\n    },\n    emit: function(type) {\n      customEvent(new ZoomEvent(zoom, type, this.that.__zoom), listeners.apply, listeners, [type, this.that, this.args]);\n    }\n  };\n\n  function wheeled() {\n    if (!filter.apply(this, arguments)) return;\n    var g = gesture(this, arguments),\n        t = this.__zoom,\n        k = Math.max(k0, Math.min(k1, t.k * Math.pow(2, -exports.event.deltaY * (exports.event.deltaMode ? 120 : 1) / 500))),\n        p = mouse(this);\n\n    // If the mouse is in the same location as before, reuse it.\n    // If there were recent wheel events, reset the wheel idle timeout.\n    if (g.wheel) {\n      if (g.mouse[0][0] !== p[0] || g.mouse[0][1] !== p[1]) {\n        g.mouse[1] = t.invert(g.mouse[0] = p);\n      }\n      clearTimeout(g.wheel);\n    }\n\n    // If this wheel event won’t trigger a transform change, ignore it.\n    else if (t.k === k) return;\n\n    // Otherwise, capture the mouse point and location at the start.\n    else {\n      g.mouse = [p, t.invert(p)];\n      interrupt(this);\n      g.start();\n    }\n\n    noevent$2();\n    g.wheel = setTimeout(wheelidled, wheelDelay);\n    g.zoom(\"mouse\", constrain(translate(scale(t, k), g.mouse[0], g.mouse[1]), g.extent));\n\n    function wheelidled() {\n      g.wheel = null;\n      g.end();\n    }\n  }\n\n  function mousedowned() {\n    if (touchending || !filter.apply(this, arguments)) return;\n    var g = gesture(this, arguments),\n        v = select(exports.event.view).on(\"mousemove.zoom\", mousemoved, true).on(\"mouseup.zoom\", mouseupped, true),\n        p = mouse(this);\n\n    dragDisable(exports.event.view);\n    nopropagation$2();\n    g.mouse = [p, this.__zoom.invert(p)];\n    interrupt(this);\n    g.start();\n\n    function mousemoved() {\n      noevent$2();\n      g.moved = true;\n      g.zoom(\"mouse\", constrain(translate(g.that.__zoom, g.mouse[0] = mouse(g.that), g.mouse[1]), g.extent));\n    }\n\n    function mouseupped() {\n      v.on(\"mousemove.zoom mouseup.zoom\", null);\n      yesdrag(exports.event.view, g.moved);\n      noevent$2();\n      g.end();\n    }\n  }\n\n  function dblclicked() {\n    if (!filter.apply(this, arguments)) return;\n    var t0 = this.__zoom,\n        p0 = mouse(this),\n        p1 = t0.invert(p0),\n        k1 = t0.k * (exports.event.shiftKey ? 0.5 : 2),\n        t1 = constrain(translate(scale(t0, k1), p0, p1), extent.apply(this, arguments));\n\n    noevent$2();\n    if (duration > 0) select(this).transition().duration(duration).call(schedule, t1, p0);\n    else select(this).call(zoom.transform, t1);\n  }\n\n  function touchstarted() {\n    if (!filter.apply(this, arguments)) return;\n    var g = gesture(this, arguments),\n        touches$$1 = exports.event.changedTouches,\n        started,\n        n = touches$$1.length, i, t, p;\n\n    nopropagation$2();\n    for (i = 0; i < n; ++i) {\n      t = touches$$1[i], p = touch(this, touches$$1, t.identifier);\n      p = [p, this.__zoom.invert(p), t.identifier];\n      if (!g.touch0) g.touch0 = p, started = true;\n      else if (!g.touch1) g.touch1 = p;\n    }\n\n    // If this is a dbltap, reroute to the (optional) dblclick.zoom handler.\n    if (touchstarting) {\n      touchstarting = clearTimeout(touchstarting);\n      if (!g.touch1) {\n        g.end();\n        p = select(this).on(\"dblclick.zoom\");\n        if (p) p.apply(this, arguments);\n        return;\n      }\n    }\n\n    if (started) {\n      touchstarting = setTimeout(function() { touchstarting = null; }, touchDelay);\n      interrupt(this);\n      g.start();\n    }\n  }\n\n  function touchmoved() {\n    var g = gesture(this, arguments),\n        touches$$1 = exports.event.changedTouches,\n        n = touches$$1.length, i, t, p, l;\n\n    noevent$2();\n    if (touchstarting) touchstarting = clearTimeout(touchstarting);\n    for (i = 0; i < n; ++i) {\n      t = touches$$1[i], p = touch(this, touches$$1, t.identifier);\n      if (g.touch0 && g.touch0[2] === t.identifier) g.touch0[0] = p;\n      else if (g.touch1 && g.touch1[2] === t.identifier) g.touch1[0] = p;\n    }\n    t = g.that.__zoom;\n    if (g.touch1) {\n      var p0 = g.touch0[0], l0 = g.touch0[1],\n          p1 = g.touch1[0], l1 = g.touch1[1],\n          dp = (dp = p1[0] - p0[0]) * dp + (dp = p1[1] - p0[1]) * dp,\n          dl = (dl = l1[0] - l0[0]) * dl + (dl = l1[1] - l0[1]) * dl;\n      t = scale(t, Math.sqrt(dp / dl));\n      p = [(p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2];\n      l = [(l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2];\n    }\n    else if (g.touch0) p = g.touch0[0], l = g.touch0[1];\n    else return;\n    g.zoom(\"touch\", constrain(translate(t, p, l), g.extent));\n  }\n\n  function touchended() {\n    var g = gesture(this, arguments),\n        touches$$1 = exports.event.changedTouches,\n        n = touches$$1.length, i, t;\n\n    nopropagation$2();\n    if (touchending) clearTimeout(touchending);\n    touchending = setTimeout(function() { touchending = null; }, touchDelay);\n    for (i = 0; i < n; ++i) {\n      t = touches$$1[i];\n      if (g.touch0 && g.touch0[2] === t.identifier) delete g.touch0;\n      else if (g.touch1 && g.touch1[2] === t.identifier) delete g.touch1;\n    }\n    if (g.touch1 && !g.touch0) g.touch0 = g.touch1, delete g.touch1;\n    if (!g.touch0) g.end();\n  }\n\n  zoom.filter = function(_) {\n    return arguments.length ? (filter = typeof _ === \"function\" ? _ : constant$12(!!_), zoom) : filter;\n  };\n\n  zoom.extent = function(_) {\n    return arguments.length ? (extent = typeof _ === \"function\" ? _ : constant$12([[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]]), zoom) : extent;\n  };\n\n  zoom.scaleExtent = function(_) {\n    return arguments.length ? (k0 = +_[0], k1 = +_[1], zoom) : [k0, k1];\n  };\n\n  zoom.translateExtent = function(_) {\n    return arguments.length ? (x0 = +_[0][0], x1 = +_[1][0], y0 = +_[0][1], y1 = +_[1][1], zoom) : [[x0, y0], [x1, y1]];\n  };\n\n  zoom.duration = function(_) {\n    return arguments.length ? (duration = +_, zoom) : duration;\n  };\n\n  zoom.interpolate = function(_) {\n    return arguments.length ? (interpolate$$1 = _, zoom) : interpolate$$1;\n  };\n\n  zoom.on = function() {\n    var value = listeners.on.apply(listeners, arguments);\n    return value === listeners ? zoom : value;\n  };\n\n  return zoom;\n};\n\nexports.version = version;\nexports.bisect = bisectRight;\nexports.bisectRight = bisectRight;\nexports.bisectLeft = bisectLeft;\nexports.ascending = ascending;\nexports.bisector = bisector;\nexports.descending = descending;\nexports.deviation = deviation;\nexports.extent = extent;\nexports.histogram = histogram;\nexports.thresholdFreedmanDiaconis = freedmanDiaconis;\nexports.thresholdScott = scott;\nexports.thresholdSturges = sturges;\nexports.max = max;\nexports.mean = mean;\nexports.median = median;\nexports.merge = merge;\nexports.min = min;\nexports.pairs = pairs;\nexports.permute = permute;\nexports.quantile = threshold;\nexports.range = sequence;\nexports.scan = scan;\nexports.shuffle = shuffle;\nexports.sum = sum;\nexports.ticks = ticks;\nexports.tickStep = tickStep;\nexports.transpose = transpose;\nexports.variance = variance;\nexports.zip = zip;\nexports.axisTop = axisTop;\nexports.axisRight = axisRight;\nexports.axisBottom = axisBottom;\nexports.axisLeft = axisLeft;\nexports.brush = brush;\nexports.brushX = brushX;\nexports.brushY = brushY;\nexports.brushSelection = brushSelection;\nexports.chord = chord;\nexports.ribbon = ribbon;\nexports.nest = nest;\nexports.set = set$2;\nexports.map = map$1;\nexports.keys = keys;\nexports.values = values;\nexports.entries = entries;\nexports.color = color;\nexports.rgb = rgb;\nexports.hsl = hsl;\nexports.lab = lab;\nexports.hcl = hcl;\nexports.cubehelix = cubehelix;\nexports.dispatch = dispatch;\nexports.drag = drag;\nexports.dragDisable = dragDisable;\nexports.dragEnable = yesdrag;\nexports.dsvFormat = dsv;\nexports.csvParse = csvParse;\nexports.csvParseRows = csvParseRows;\nexports.csvFormat = csvFormat;\nexports.csvFormatRows = csvFormatRows;\nexports.tsvParse = tsvParse;\nexports.tsvParseRows = tsvParseRows;\nexports.tsvFormat = tsvFormat;\nexports.tsvFormatRows = tsvFormatRows;\nexports.easeLinear = linear$1;\nexports.easeQuad = quadInOut;\nexports.easeQuadIn = quadIn;\nexports.easeQuadOut = quadOut;\nexports.easeQuadInOut = quadInOut;\nexports.easeCubic = cubicInOut;\nexports.easeCubicIn = cubicIn;\nexports.easeCubicOut = cubicOut;\nexports.easeCubicInOut = cubicInOut;\nexports.easePoly = polyInOut;\nexports.easePolyIn = polyIn;\nexports.easePolyOut = polyOut;\nexports.easePolyInOut = polyInOut;\nexports.easeSin = sinInOut;\nexports.easeSinIn = sinIn;\nexports.easeSinOut = sinOut;\nexports.easeSinInOut = sinInOut;\nexports.easeExp = expInOut;\nexports.easeExpIn = expIn;\nexports.easeExpOut = expOut;\nexports.easeExpInOut = expInOut;\nexports.easeCircle = circleInOut;\nexports.easeCircleIn = circleIn;\nexports.easeCircleOut = circleOut;\nexports.easeCircleInOut = circleInOut;\nexports.easeBounce = bounceOut;\nexports.easeBounceIn = bounceIn;\nexports.easeBounceOut = bounceOut;\nexports.easeBounceInOut = bounceInOut;\nexports.easeBack = backInOut;\nexports.easeBackIn = backIn;\nexports.easeBackOut = backOut;\nexports.easeBackInOut = backInOut;\nexports.easeElastic = elasticOut;\nexports.easeElasticIn = elasticIn;\nexports.easeElasticOut = elasticOut;\nexports.easeElasticInOut = elasticInOut;\nexports.forceCenter = center$1;\nexports.forceCollide = collide;\nexports.forceLink = link;\nexports.forceManyBody = manyBody;\nexports.forceSimulation = simulation;\nexports.forceX = x$2;\nexports.forceY = y$2;\nexports.formatDefaultLocale = defaultLocale;\nexports.formatLocale = formatLocale;\nexports.formatSpecifier = formatSpecifier;\nexports.precisionFixed = precisionFixed;\nexports.precisionPrefix = precisionPrefix;\nexports.precisionRound = precisionRound;\nexports.geoArea = area;\nexports.geoBounds = bounds;\nexports.geoCentroid = centroid;\nexports.geoCircle = circle;\nexports.geoClipExtent = extent$1;\nexports.geoDistance = distance;\nexports.geoGraticule = graticule;\nexports.geoGraticule10 = graticule10;\nexports.geoInterpolate = interpolate$1;\nexports.geoLength = length$1;\nexports.geoPath = index$1;\nexports.geoAlbers = albers;\nexports.geoAlbersUsa = albersUsa;\nexports.geoAzimuthalEqualArea = azimuthalEqualArea;\nexports.geoAzimuthalEqualAreaRaw = azimuthalEqualAreaRaw;\nexports.geoAzimuthalEquidistant = azimuthalEquidistant;\nexports.geoAzimuthalEquidistantRaw = azimuthalEquidistantRaw;\nexports.geoConicConformal = conicConformal;\nexports.geoConicConformalRaw = conicConformalRaw;\nexports.geoConicEqualArea = conicEqualArea;\nexports.geoConicEqualAreaRaw = conicEqualAreaRaw;\nexports.geoConicEquidistant = conicEquidistant;\nexports.geoConicEquidistantRaw = conicEquidistantRaw;\nexports.geoEquirectangular = equirectangular;\nexports.geoEquirectangularRaw = equirectangularRaw;\nexports.geoGnomonic = gnomonic;\nexports.geoGnomonicRaw = gnomonicRaw;\nexports.geoIdentity = identity$5;\nexports.geoProjection = projection;\nexports.geoProjectionMutator = projectionMutator;\nexports.geoMercator = mercator;\nexports.geoMercatorRaw = mercatorRaw;\nexports.geoOrthographic = orthographic;\nexports.geoOrthographicRaw = orthographicRaw;\nexports.geoStereographic = stereographic;\nexports.geoStereographicRaw = stereographicRaw;\nexports.geoTransverseMercator = transverseMercator;\nexports.geoTransverseMercatorRaw = transverseMercatorRaw;\nexports.geoRotation = rotation;\nexports.geoStream = geoStream;\nexports.geoTransform = transform;\nexports.cluster = cluster;\nexports.hierarchy = hierarchy;\nexports.pack = index$2;\nexports.packSiblings = siblings;\nexports.packEnclose = enclose;\nexports.partition = partition;\nexports.stratify = stratify;\nexports.tree = tree;\nexports.treemap = index$3;\nexports.treemapBinary = binary;\nexports.treemapDice = treemapDice;\nexports.treemapSlice = treemapSlice;\nexports.treemapSliceDice = sliceDice;\nexports.treemapSquarify = squarify;\nexports.treemapResquarify = resquarify;\nexports.interpolate = interpolateValue;\nexports.interpolateArray = array$1;\nexports.interpolateBasis = basis$1;\nexports.interpolateBasisClosed = basisClosed;\nexports.interpolateDate = date;\nexports.interpolateNumber = reinterpolate;\nexports.interpolateObject = object;\nexports.interpolateRound = interpolateRound;\nexports.interpolateString = interpolateString;\nexports.interpolateTransformCss = interpolateTransformCss;\nexports.interpolateTransformSvg = interpolateTransformSvg;\nexports.interpolateZoom = interpolateZoom;\nexports.interpolateRgb = interpolateRgb;\nexports.interpolateRgbBasis = rgbBasis;\nexports.interpolateRgbBasisClosed = rgbBasisClosed;\nexports.interpolateHsl = hsl$2;\nexports.interpolateHslLong = hslLong;\nexports.interpolateLab = lab$1;\nexports.interpolateHcl = hcl$2;\nexports.interpolateHclLong = hclLong;\nexports.interpolateCubehelix = cubehelix$2;\nexports.interpolateCubehelixLong = cubehelixLong;\nexports.quantize = quantize;\nexports.path = path;\nexports.polygonArea = area$1;\nexports.polygonCentroid = centroid$1;\nexports.polygonHull = hull;\nexports.polygonContains = contains;\nexports.polygonLength = length$2;\nexports.quadtree = quadtree;\nexports.queue = queue;\nexports.randomUniform = uniform;\nexports.randomNormal = normal;\nexports.randomLogNormal = logNormal;\nexports.randomBates = bates;\nexports.randomIrwinHall = irwinHall;\nexports.randomExponential = exponential$1;\nexports.request = request;\nexports.html = html;\nexports.json = json;\nexports.text = text;\nexports.xml = xml;\nexports.csv = csv$1;\nexports.tsv = tsv$1;\nexports.scaleBand = band;\nexports.scalePoint = point$1;\nexports.scaleIdentity = identity$6;\nexports.scaleLinear = linear$2;\nexports.scaleLog = log$1;\nexports.scaleOrdinal = ordinal;\nexports.scaleImplicit = implicit;\nexports.scalePow = pow$1;\nexports.scaleSqrt = sqrt$1;\nexports.scaleQuantile = quantile$$1;\nexports.scaleQuantize = quantize$1;\nexports.scaleThreshold = threshold$1;\nexports.scaleTime = time;\nexports.scaleUtc = utcTime;\nexports.schemeCategory10 = category10;\nexports.schemeCategory20b = category20b;\nexports.schemeCategory20c = category20c;\nexports.schemeCategory20 = category20;\nexports.interpolateCubehelixDefault = cubehelix$3;\nexports.interpolateRainbow = rainbow$1;\nexports.interpolateWarm = warm;\nexports.interpolateCool = cool;\nexports.interpolateViridis = viridis;\nexports.interpolateMagma = magma;\nexports.interpolateInferno = inferno;\nexports.interpolatePlasma = plasma;\nexports.scaleSequential = sequential;\nexports.creator = creator;\nexports.local = local$1;\nexports.matcher = matcher$1;\nexports.mouse = mouse;\nexports.namespace = namespace;\nexports.namespaces = namespaces;\nexports.select = select;\nexports.selectAll = selectAll;\nexports.selection = selection;\nexports.selector = selector;\nexports.selectorAll = selectorAll;\nexports.touch = touch;\nexports.touches = touches;\nexports.window = window;\nexports.customEvent = customEvent;\nexports.arc = arc;\nexports.area = area$2;\nexports.line = line;\nexports.pie = pie;\nexports.radialArea = radialArea;\nexports.radialLine = radialLine$1;\nexports.symbol = symbol;\nexports.symbols = symbols;\nexports.symbolCircle = circle$2;\nexports.symbolCross = cross$1;\nexports.symbolDiamond = diamond;\nexports.symbolSquare = square;\nexports.symbolStar = star;\nexports.symbolTriangle = triangle;\nexports.symbolWye = wye;\nexports.curveBasisClosed = basisClosed$1;\nexports.curveBasisOpen = basisOpen;\nexports.curveBasis = basis$2;\nexports.curveBundle = bundle;\nexports.curveCardinalClosed = cardinalClosed;\nexports.curveCardinalOpen = cardinalOpen;\nexports.curveCardinal = cardinal;\nexports.curveCatmullRomClosed = catmullRomClosed;\nexports.curveCatmullRomOpen = catmullRomOpen;\nexports.curveCatmullRom = catmullRom;\nexports.curveLinearClosed = linearClosed;\nexports.curveLinear = curveLinear;\nexports.curveMonotoneX = monotoneX;\nexports.curveMonotoneY = monotoneY;\nexports.curveNatural = natural;\nexports.curveStep = step;\nexports.curveStepAfter = stepAfter;\nexports.curveStepBefore = stepBefore;\nexports.stack = stack;\nexports.stackOffsetExpand = expand;\nexports.stackOffsetNone = none$1;\nexports.stackOffsetSilhouette = silhouette;\nexports.stackOffsetWiggle = wiggle;\nexports.stackOrderAscending = ascending$2;\nexports.stackOrderDescending = descending$2;\nexports.stackOrderInsideOut = insideOut;\nexports.stackOrderNone = none$2;\nexports.stackOrderReverse = reverse;\nexports.timeInterval = newInterval;\nexports.timeMillisecond = millisecond;\nexports.timeMilliseconds = milliseconds;\nexports.utcMillisecond = millisecond;\nexports.utcMilliseconds = milliseconds;\nexports.timeSecond = second;\nexports.timeSeconds = seconds;\nexports.utcSecond = second;\nexports.utcSeconds = seconds;\nexports.timeMinute = minute;\nexports.timeMinutes = minutes;\nexports.timeHour = hour;\nexports.timeHours = hours;\nexports.timeDay = day;\nexports.timeDays = days;\nexports.timeWeek = sunday;\nexports.timeWeeks = sundays;\nexports.timeSunday = sunday;\nexports.timeSundays = sundays;\nexports.timeMonday = monday;\nexports.timeMondays = mondays;\nexports.timeTuesday = tuesday;\nexports.timeTuesdays = tuesdays;\nexports.timeWednesday = wednesday;\nexports.timeWednesdays = wednesdays;\nexports.timeThursday = thursday;\nexports.timeThursdays = thursdays;\nexports.timeFriday = friday;\nexports.timeFridays = fridays;\nexports.timeSaturday = saturday;\nexports.timeSaturdays = saturdays;\nexports.timeMonth = month;\nexports.timeMonths = months;\nexports.timeYear = year;\nexports.timeYears = years;\nexports.utcMinute = utcMinute;\nexports.utcMinutes = utcMinutes;\nexports.utcHour = utcHour;\nexports.utcHours = utcHours;\nexports.utcDay = utcDay;\nexports.utcDays = utcDays;\nexports.utcWeek = utcSunday;\nexports.utcWeeks = utcSundays;\nexports.utcSunday = utcSunday;\nexports.utcSundays = utcSundays;\nexports.utcMonday = utcMonday;\nexports.utcMondays = utcMondays;\nexports.utcTuesday = utcTuesday;\nexports.utcTuesdays = utcTuesdays;\nexports.utcWednesday = utcWednesday;\nexports.utcWednesdays = utcWednesdays;\nexports.utcThursday = utcThursday;\nexports.utcThursdays = utcThursdays;\nexports.utcFriday = utcFriday;\nexports.utcFridays = utcFridays;\nexports.utcSaturday = utcSaturday;\nexports.utcSaturdays = utcSaturdays;\nexports.utcMonth = utcMonth;\nexports.utcMonths = utcMonths;\nexports.utcYear = utcYear;\nexports.utcYears = utcYears;\nexports.timeFormatDefaultLocale = defaultLocale$1;\nexports.timeFormatLocale = formatLocale$1;\nexports.isoFormat = formatIso;\nexports.isoParse = parseIso;\nexports.now = now;\nexports.timer = timer;\nexports.timerFlush = timerFlush;\nexports.timeout = timeout$1;\nexports.interval = interval$1;\nexports.transition = transition;\nexports.active = active;\nexports.interrupt = interrupt;\nexports.voronoi = voronoi;\nexports.zoom = zoom;\nexports.zoomTransform = transform$1;\nexports.zoomIdentity = identity$8;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar store      = __webpack_require__(29)('wks')\n  , uid        = __webpack_require__(33)\n  , Symbol     = __webpack_require__(5).Symbol\n  , USE_SYMBOL = typeof Symbol == 'function';\n\nvar $exports = module.exports = function(name){\n  return store[name] || (store[name] =\n    USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));\n};\n\n$exports.store = store;\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global, module) {var __WEBPACK_AMD_DEFINE_RESULT__;/**\n * @license\n * Lodash <https://lodash.com/>\n * Copyright JS Foundation and other contributors <https://js.foundation/>\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;(function() {\n\n  /** Used as a safe reference for `undefined` in pre-ES5 environments. */\n  var undefined;\n\n  /** Used as the semantic version number. */\n  var VERSION = '4.17.4';\n\n  /** Used as the size to enable large array optimizations. */\n  var LARGE_ARRAY_SIZE = 200;\n\n  /** Error message constants. */\n  var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',\n      FUNC_ERROR_TEXT = 'Expected a function';\n\n  /** Used to stand-in for `undefined` hash values. */\n  var HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n  /** Used as the maximum memoize cache size. */\n  var MAX_MEMOIZE_SIZE = 500;\n\n  /** Used as the internal argument placeholder. */\n  var PLACEHOLDER = '__lodash_placeholder__';\n\n  /** Used to compose bitmasks for cloning. */\n  var CLONE_DEEP_FLAG = 1,\n      CLONE_FLAT_FLAG = 2,\n      CLONE_SYMBOLS_FLAG = 4;\n\n  /** Used to compose bitmasks for value comparisons. */\n  var COMPARE_PARTIAL_FLAG = 1,\n      COMPARE_UNORDERED_FLAG = 2;\n\n  /** Used to compose bitmasks for function metadata. */\n  var WRAP_BIND_FLAG = 1,\n      WRAP_BIND_KEY_FLAG = 2,\n      WRAP_CURRY_BOUND_FLAG = 4,\n      WRAP_CURRY_FLAG = 8,\n      WRAP_CURRY_RIGHT_FLAG = 16,\n      WRAP_PARTIAL_FLAG = 32,\n      WRAP_PARTIAL_RIGHT_FLAG = 64,\n      WRAP_ARY_FLAG = 128,\n      WRAP_REARG_FLAG = 256,\n      WRAP_FLIP_FLAG = 512;\n\n  /** Used as default options for `_.truncate`. */\n  var DEFAULT_TRUNC_LENGTH = 30,\n      DEFAULT_TRUNC_OMISSION = '...';\n\n  /** Used to detect hot functions by number of calls within a span of milliseconds. */\n  var HOT_COUNT = 800,\n      HOT_SPAN = 16;\n\n  /** Used to indicate the type of lazy iteratees. */\n  var LAZY_FILTER_FLAG = 1,\n      LAZY_MAP_FLAG = 2,\n      LAZY_WHILE_FLAG = 3;\n\n  /** Used as references for various `Number` constants. */\n  var INFINITY = 1 / 0,\n      MAX_SAFE_INTEGER = 9007199254740991,\n      MAX_INTEGER = 1.7976931348623157e+308,\n      NAN = 0 / 0;\n\n  /** Used as references for the maximum length and index of an array. */\n  var MAX_ARRAY_LENGTH = 4294967295,\n      MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,\n      HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;\n\n  /** Used to associate wrap methods with their bit flags. */\n  var wrapFlags = [\n    ['ary', WRAP_ARY_FLAG],\n    ['bind', WRAP_BIND_FLAG],\n    ['bindKey', WRAP_BIND_KEY_FLAG],\n    ['curry', WRAP_CURRY_FLAG],\n    ['curryRight', WRAP_CURRY_RIGHT_FLAG],\n    ['flip', WRAP_FLIP_FLAG],\n    ['partial', WRAP_PARTIAL_FLAG],\n    ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],\n    ['rearg', WRAP_REARG_FLAG]\n  ];\n\n  /** `Object#toString` result references. */\n  var argsTag = '[object Arguments]',\n      arrayTag = '[object Array]',\n      asyncTag = '[object AsyncFunction]',\n      boolTag = '[object Boolean]',\n      dateTag = '[object Date]',\n      domExcTag = '[object DOMException]',\n      errorTag = '[object Error]',\n      funcTag = '[object Function]',\n      genTag = '[object GeneratorFunction]',\n      mapTag = '[object Map]',\n      numberTag = '[object Number]',\n      nullTag = '[object Null]',\n      objectTag = '[object Object]',\n      promiseTag = '[object Promise]',\n      proxyTag = '[object Proxy]',\n      regexpTag = '[object RegExp]',\n      setTag = '[object Set]',\n      stringTag = '[object String]',\n      symbolTag = '[object Symbol]',\n      undefinedTag = '[object Undefined]',\n      weakMapTag = '[object WeakMap]',\n      weakSetTag = '[object WeakSet]';\n\n  var arrayBufferTag = '[object ArrayBuffer]',\n      dataViewTag = '[object DataView]',\n      float32Tag = '[object Float32Array]',\n      float64Tag = '[object Float64Array]',\n      int8Tag = '[object Int8Array]',\n      int16Tag = '[object Int16Array]',\n      int32Tag = '[object Int32Array]',\n      uint8Tag = '[object Uint8Array]',\n      uint8ClampedTag = '[object Uint8ClampedArray]',\n      uint16Tag = '[object Uint16Array]',\n      uint32Tag = '[object Uint32Array]';\n\n  /** Used to match empty string literals in compiled template source. */\n  var reEmptyStringLeading = /\\b__p \\+= '';/g,\n      reEmptyStringMiddle = /\\b(__p \\+=) '' \\+/g,\n      reEmptyStringTrailing = /(__e\\(.*?\\)|\\b__t\\)) \\+\\n'';/g;\n\n  /** Used to match HTML entities and HTML characters. */\n  var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,\n      reUnescapedHtml = /[&<>\"']/g,\n      reHasEscapedHtml = RegExp(reEscapedHtml.source),\n      reHasUnescapedHtml = RegExp(reUnescapedHtml.source);\n\n  /** Used to match template delimiters. */\n  var reEscape = /<%-([\\s\\S]+?)%>/g,\n      reEvaluate = /<%([\\s\\S]+?)%>/g,\n      reInterpolate = /<%=([\\s\\S]+?)%>/g;\n\n  /** Used to match property names within property paths. */\n  var reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/,\n      reIsPlainProp = /^\\w*$/,\n      reLeadingDot = /^\\./,\n      rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\n\n  /**\n   * Used to match `RegExp`\n   * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n   */\n  var reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g,\n      reHasRegExpChar = RegExp(reRegExpChar.source);\n\n  /** Used to match leading and trailing whitespace. */\n  var reTrim = /^\\s+|\\s+$/g,\n      reTrimStart = /^\\s+/,\n      reTrimEnd = /\\s+$/;\n\n  /** Used to match wrap detail comments. */\n  var reWrapComment = /\\{(?:\\n\\/\\* \\[wrapped with .+\\] \\*\\/)?\\n?/,\n      reWrapDetails = /\\{\\n\\/\\* \\[wrapped with (.+)\\] \\*/,\n      reSplitDetails = /,? & /;\n\n  /** Used to match words composed of alphanumeric characters. */\n  var reAsciiWord = /[^\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\x7f]+/g;\n\n  /** Used to match backslashes in property paths. */\n  var reEscapeChar = /\\\\(\\\\)?/g;\n\n  /**\n   * Used to match\n   * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).\n   */\n  var reEsTemplate = /\\$\\{([^\\\\}]*(?:\\\\.[^\\\\}]*)*)\\}/g;\n\n  /** Used to match `RegExp` flags from their coerced string values. */\n  var reFlags = /\\w*$/;\n\n  /** Used to detect bad signed hexadecimal string values. */\n  var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n  /** Used to detect binary string values. */\n  var reIsBinary = /^0b[01]+$/i;\n\n  /** Used to detect host constructors (Safari). */\n  var reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n  /** Used to detect octal string values. */\n  var reIsOctal = /^0o[0-7]+$/i;\n\n  /** Used to detect unsigned integer values. */\n  var reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n  /** Used to match Latin Unicode letters (excluding mathematical operators). */\n  var reLatin = /[\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\xff\\u0100-\\u017f]/g;\n\n  /** Used to ensure capturing order of template delimiters. */\n  var reNoMatch = /($^)/;\n\n  /** Used to match unescaped characters in compiled string literals. */\n  var reUnescapedString = /['\\n\\r\\u2028\\u2029\\\\]/g;\n\n  /** Used to compose unicode character classes. */\n  var rsAstralRange = '\\\\ud800-\\\\udfff',\n      rsComboMarksRange = '\\\\u0300-\\\\u036f',\n      reComboHalfMarksRange = '\\\\ufe20-\\\\ufe2f',\n      rsComboSymbolsRange = '\\\\u20d0-\\\\u20ff',\n      rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,\n      rsDingbatRange = '\\\\u2700-\\\\u27bf',\n      rsLowerRange = 'a-z\\\\xdf-\\\\xf6\\\\xf8-\\\\xff',\n      rsMathOpRange = '\\\\xac\\\\xb1\\\\xd7\\\\xf7',\n      rsNonCharRange = '\\\\x00-\\\\x2f\\\\x3a-\\\\x40\\\\x5b-\\\\x60\\\\x7b-\\\\xbf',\n      rsPunctuationRange = '\\\\u2000-\\\\u206f',\n      rsSpaceRange = ' \\\\t\\\\x0b\\\\f\\\\xa0\\\\ufeff\\\\n\\\\r\\\\u2028\\\\u2029\\\\u1680\\\\u180e\\\\u2000\\\\u2001\\\\u2002\\\\u2003\\\\u2004\\\\u2005\\\\u2006\\\\u2007\\\\u2008\\\\u2009\\\\u200a\\\\u202f\\\\u205f\\\\u3000',\n      rsUpperRange = 'A-Z\\\\xc0-\\\\xd6\\\\xd8-\\\\xde',\n      rsVarRange = '\\\\ufe0e\\\\ufe0f',\n      rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;\n\n  /** Used to compose unicode capture groups. */\n  var rsApos = \"['\\u2019]\",\n      rsAstral = '[' + rsAstralRange + ']',\n      rsBreak = '[' + rsBreakRange + ']',\n      rsCombo = '[' + rsComboRange + ']',\n      rsDigits = '\\\\d+',\n      rsDingbat = '[' + rsDingbatRange + ']',\n      rsLower = '[' + rsLowerRange + ']',\n      rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',\n      rsFitz = '\\\\ud83c[\\\\udffb-\\\\udfff]',\n      rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',\n      rsNonAstral = '[^' + rsAstralRange + ']',\n      rsRegional = '(?:\\\\ud83c[\\\\udde6-\\\\uddff]){2}',\n      rsSurrPair = '[\\\\ud800-\\\\udbff][\\\\udc00-\\\\udfff]',\n      rsUpper = '[' + rsUpperRange + ']',\n      rsZWJ = '\\\\u200d';\n\n  /** Used to compose unicode regexes. */\n  var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',\n      rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',\n      rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',\n      rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',\n      reOptMod = rsModifier + '?',\n      rsOptVar = '[' + rsVarRange + ']?',\n      rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',\n      rsOrdLower = '\\\\d*(?:(?:1st|2nd|3rd|(?![123])\\\\dth)\\\\b)',\n      rsOrdUpper = '\\\\d*(?:(?:1ST|2ND|3RD|(?![123])\\\\dTH)\\\\b)',\n      rsSeq = rsOptVar + reOptMod + rsOptJoin,\n      rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,\n      rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';\n\n  /** Used to match apostrophes. */\n  var reApos = RegExp(rsApos, 'g');\n\n  /**\n   * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and\n   * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).\n   */\n  var reComboMark = RegExp(rsCombo, 'g');\n\n  /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */\n  var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');\n\n  /** Used to match complex or compound words. */\n  var reUnicodeWord = RegExp([\n    rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',\n    rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',\n    rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,\n    rsUpper + '+' + rsOptContrUpper,\n    rsOrdUpper,\n    rsOrdLower,\n    rsDigits,\n    rsEmoji\n  ].join('|'), 'g');\n\n  /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */\n  var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboRange + rsVarRange + ']');\n\n  /** Used to detect strings that need a more robust regexp to match words. */\n  var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;\n\n  /** Used to assign default `context` object properties. */\n  var contextProps = [\n    'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array',\n    'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object',\n    'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array',\n    'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',\n    '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout'\n  ];\n\n  /** Used to make template sourceURLs easier to identify. */\n  var templateCounter = -1;\n\n  /** Used to identify `toStringTag` values of typed arrays. */\n  var typedArrayTags = {};\n  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\n  typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\n  typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\n  typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\n  typedArrayTags[uint32Tag] = true;\n  typedArrayTags[argsTag] = typedArrayTags[arrayTag] =\n  typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\n  typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\n  typedArrayTags[errorTag] = typedArrayTags[funcTag] =\n  typedArrayTags[mapTag] = typedArrayTags[numberTag] =\n  typedArrayTags[objectTag] = typedArrayTags[regexpTag] =\n  typedArrayTags[setTag] = typedArrayTags[stringTag] =\n  typedArrayTags[weakMapTag] = false;\n\n  /** Used to identify `toStringTag` values supported by `_.clone`. */\n  var cloneableTags = {};\n  cloneableTags[argsTag] = cloneableTags[arrayTag] =\n  cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\n  cloneableTags[boolTag] = cloneableTags[dateTag] =\n  cloneableTags[float32Tag] = cloneableTags[float64Tag] =\n  cloneableTags[int8Tag] = cloneableTags[int16Tag] =\n  cloneableTags[int32Tag] = cloneableTags[mapTag] =\n  cloneableTags[numberTag] = cloneableTags[objectTag] =\n  cloneableTags[regexpTag] = cloneableTags[setTag] =\n  cloneableTags[stringTag] = cloneableTags[symbolTag] =\n  cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\n  cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\n  cloneableTags[errorTag] = cloneableTags[funcTag] =\n  cloneableTags[weakMapTag] = false;\n\n  /** Used to map Latin Unicode letters to basic Latin letters. */\n  var deburredLetters = {\n    // Latin-1 Supplement block.\n    '\\xc0': 'A',  '\\xc1': 'A', '\\xc2': 'A', '\\xc3': 'A', '\\xc4': 'A', '\\xc5': 'A',\n    '\\xe0': 'a',  '\\xe1': 'a', '\\xe2': 'a', '\\xe3': 'a', '\\xe4': 'a', '\\xe5': 'a',\n    '\\xc7': 'C',  '\\xe7': 'c',\n    '\\xd0': 'D',  '\\xf0': 'd',\n    '\\xc8': 'E',  '\\xc9': 'E', '\\xca': 'E', '\\xcb': 'E',\n    '\\xe8': 'e',  '\\xe9': 'e', '\\xea': 'e', '\\xeb': 'e',\n    '\\xcc': 'I',  '\\xcd': 'I', '\\xce': 'I', '\\xcf': 'I',\n    '\\xec': 'i',  '\\xed': 'i', '\\xee': 'i', '\\xef': 'i',\n    '\\xd1': 'N',  '\\xf1': 'n',\n    '\\xd2': 'O',  '\\xd3': 'O', '\\xd4': 'O', '\\xd5': 'O', '\\xd6': 'O', '\\xd8': 'O',\n    '\\xf2': 'o',  '\\xf3': 'o', '\\xf4': 'o', '\\xf5': 'o', '\\xf6': 'o', '\\xf8': 'o',\n    '\\xd9': 'U',  '\\xda': 'U', '\\xdb': 'U', '\\xdc': 'U',\n    '\\xf9': 'u',  '\\xfa': 'u', '\\xfb': 'u', '\\xfc': 'u',\n    '\\xdd': 'Y',  '\\xfd': 'y', '\\xff': 'y',\n    '\\xc6': 'Ae', '\\xe6': 'ae',\n    '\\xde': 'Th', '\\xfe': 'th',\n    '\\xdf': 'ss',\n    // Latin Extended-A block.\n    '\\u0100': 'A',  '\\u0102': 'A', '\\u0104': 'A',\n    '\\u0101': 'a',  '\\u0103': 'a', '\\u0105': 'a',\n    '\\u0106': 'C',  '\\u0108': 'C', '\\u010a': 'C', '\\u010c': 'C',\n    '\\u0107': 'c',  '\\u0109': 'c', '\\u010b': 'c', '\\u010d': 'c',\n    '\\u010e': 'D',  '\\u0110': 'D', '\\u010f': 'd', '\\u0111': 'd',\n    '\\u0112': 'E',  '\\u0114': 'E', '\\u0116': 'E', '\\u0118': 'E', '\\u011a': 'E',\n    '\\u0113': 'e',  '\\u0115': 'e', '\\u0117': 'e', '\\u0119': 'e', '\\u011b': 'e',\n    '\\u011c': 'G',  '\\u011e': 'G', '\\u0120': 'G', '\\u0122': 'G',\n    '\\u011d': 'g',  '\\u011f': 'g', '\\u0121': 'g', '\\u0123': 'g',\n    '\\u0124': 'H',  '\\u0126': 'H', '\\u0125': 'h', '\\u0127': 'h',\n    '\\u0128': 'I',  '\\u012a': 'I', '\\u012c': 'I', '\\u012e': 'I', '\\u0130': 'I',\n    '\\u0129': 'i',  '\\u012b': 'i', '\\u012d': 'i', '\\u012f': 'i', '\\u0131': 'i',\n    '\\u0134': 'J',  '\\u0135': 'j',\n    '\\u0136': 'K',  '\\u0137': 'k', '\\u0138': 'k',\n    '\\u0139': 'L',  '\\u013b': 'L', '\\u013d': 'L', '\\u013f': 'L', '\\u0141': 'L',\n    '\\u013a': 'l',  '\\u013c': 'l', '\\u013e': 'l', '\\u0140': 'l', '\\u0142': 'l',\n    '\\u0143': 'N',  '\\u0145': 'N', '\\u0147': 'N', '\\u014a': 'N',\n    '\\u0144': 'n',  '\\u0146': 'n', '\\u0148': 'n', '\\u014b': 'n',\n    '\\u014c': 'O',  '\\u014e': 'O', '\\u0150': 'O',\n    '\\u014d': 'o',  '\\u014f': 'o', '\\u0151': 'o',\n    '\\u0154': 'R',  '\\u0156': 'R', '\\u0158': 'R',\n    '\\u0155': 'r',  '\\u0157': 'r', '\\u0159': 'r',\n    '\\u015a': 'S',  '\\u015c': 'S', '\\u015e': 'S', '\\u0160': 'S',\n    '\\u015b': 's',  '\\u015d': 's', '\\u015f': 's', '\\u0161': 's',\n    '\\u0162': 'T',  '\\u0164': 'T', '\\u0166': 'T',\n    '\\u0163': 't',  '\\u0165': 't', '\\u0167': 't',\n    '\\u0168': 'U',  '\\u016a': 'U', '\\u016c': 'U', '\\u016e': 'U', '\\u0170': 'U', '\\u0172': 'U',\n    '\\u0169': 'u',  '\\u016b': 'u', '\\u016d': 'u', '\\u016f': 'u', '\\u0171': 'u', '\\u0173': 'u',\n    '\\u0174': 'W',  '\\u0175': 'w',\n    '\\u0176': 'Y',  '\\u0177': 'y', '\\u0178': 'Y',\n    '\\u0179': 'Z',  '\\u017b': 'Z', '\\u017d': 'Z',\n    '\\u017a': 'z',  '\\u017c': 'z', '\\u017e': 'z',\n    '\\u0132': 'IJ', '\\u0133': 'ij',\n    '\\u0152': 'Oe', '\\u0153': 'oe',\n    '\\u0149': \"'n\", '\\u017f': 's'\n  };\n\n  /** Used to map characters to HTML entities. */\n  var htmlEscapes = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#39;'\n  };\n\n  /** Used to map HTML entities to characters. */\n  var htmlUnescapes = {\n    '&amp;': '&',\n    '&lt;': '<',\n    '&gt;': '>',\n    '&quot;': '\"',\n    '&#39;': \"'\"\n  };\n\n  /** Used to escape characters for inclusion in compiled string literals. */\n  var stringEscapes = {\n    '\\\\': '\\\\',\n    \"'\": \"'\",\n    '\\n': 'n',\n    '\\r': 'r',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  /** Built-in method references without a dependency on `root`. */\n  var freeParseFloat = parseFloat,\n      freeParseInt = parseInt;\n\n  /** Detect free variable `global` from Node.js. */\n  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n  /** Detect free variable `self`. */\n  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n  /** Used as a reference to the global object. */\n  var root = freeGlobal || freeSelf || Function('return this')();\n\n  /** Detect free variable `exports`. */\n  var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n  /** Detect free variable `module`. */\n  var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n  /** Detect the popular CommonJS extension `module.exports`. */\n  var moduleExports = freeModule && freeModule.exports === freeExports;\n\n  /** Detect free variable `process` from Node.js. */\n  var freeProcess = moduleExports && freeGlobal.process;\n\n  /** Used to access faster Node.js helpers. */\n  var nodeUtil = (function() {\n    try {\n      return freeProcess && freeProcess.binding && freeProcess.binding('util');\n    } catch (e) {}\n  }());\n\n  /* Node.js helper references. */\n  var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,\n      nodeIsDate = nodeUtil && nodeUtil.isDate,\n      nodeIsMap = nodeUtil && nodeUtil.isMap,\n      nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,\n      nodeIsSet = nodeUtil && nodeUtil.isSet,\n      nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n  /*--------------------------------------------------------------------------*/\n\n  /**\n   * Adds the key-value `pair` to `map`.\n   *\n   * @private\n   * @param {Object} map The map to modify.\n   * @param {Array} pair The key-value pair to add.\n   * @returns {Object} Returns `map`.\n   */\n  function addMapEntry(map, pair) {\n    // Don't return `map.set` because it's not chainable in IE 11.\n    map.set(pair[0], pair[1]);\n    return map;\n  }\n\n  /**\n   * Adds `value` to `set`.\n   *\n   * @private\n   * @param {Object} set The set to modify.\n   * @param {*} value The value to add.\n   * @returns {Object} Returns `set`.\n   */\n  function addSetEntry(set, value) {\n    // Don't return `set.add` because it's not chainable in IE 11.\n    set.add(value);\n    return set;\n  }\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   */\n  function 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   * A specialized version of `baseAggregator` for arrays.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} setter The function to set `accumulator` values.\n   * @param {Function} iteratee The iteratee to transform keys.\n   * @param {Object} accumulator The initial aggregated object.\n   * @returns {Function} Returns `accumulator`.\n   */\n  function arrayAggregator(array, setter, iteratee, accumulator) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      var value = array[index];\n      setter(accumulator, value, iteratee(value), array);\n    }\n    return accumulator;\n  }\n\n  /**\n   * A specialized version of `_.forEach` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {Array} Returns `array`.\n   */\n  function arrayEach(array, iteratee) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (iteratee(array[index], index, array) === false) {\n        break;\n      }\n    }\n    return array;\n  }\n\n  /**\n   * A specialized version of `_.forEachRight` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {Array} Returns `array`.\n   */\n  function arrayEachRight(array, iteratee) {\n    var length = array == null ? 0 : array.length;\n\n    while (length--) {\n      if (iteratee(array[length], length, array) === false) {\n        break;\n      }\n    }\n    return array;\n  }\n\n  /**\n   * A specialized version of `_.every` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} predicate The function invoked per iteration.\n   * @returns {boolean} Returns `true` if all elements pass the predicate check,\n   *  else `false`.\n   */\n  function arrayEvery(array, predicate) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (!predicate(array[index], index, array)) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * A specialized version of `_.filter` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} predicate The function invoked per iteration.\n   * @returns {Array} Returns the new filtered array.\n   */\n  function arrayFilter(array, predicate) {\n    var index = -1,\n        length = array == null ? 0 : array.length,\n        resIndex = 0,\n        result = [];\n\n    while (++index < length) {\n      var value = array[index];\n      if (predicate(value, index, array)) {\n        result[resIndex++] = value;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * A specialized version of `_.includes` for arrays without support for\n   * specifying an index to search from.\n   *\n   * @private\n   * @param {Array} [array] The array to inspect.\n   * @param {*} target The value to search for.\n   * @returns {boolean} Returns `true` if `target` is found, else `false`.\n   */\n  function arrayIncludes(array, value) {\n    var length = array == null ? 0 : array.length;\n    return !!length && baseIndexOf(array, value, 0) > -1;\n  }\n\n  /**\n   * This function is like `arrayIncludes` except that it accepts a comparator.\n   *\n   * @private\n   * @param {Array} [array] The array to inspect.\n   * @param {*} target The value to search for.\n   * @param {Function} comparator The comparator invoked per element.\n   * @returns {boolean} Returns `true` if `target` is found, else `false`.\n   */\n  function arrayIncludesWith(array, value, comparator) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (comparator(value, array[index])) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * A specialized version of `_.map` for arrays without support for iteratee\n   * shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {Array} Returns the new mapped array.\n   */\n  function arrayMap(array, iteratee) {\n    var index = -1,\n        length = array == null ? 0 : array.length,\n        result = Array(length);\n\n    while (++index < length) {\n      result[index] = iteratee(array[index], index, array);\n    }\n    return result;\n  }\n\n  /**\n   * Appends the elements of `values` to `array`.\n   *\n   * @private\n   * @param {Array} array The array to modify.\n   * @param {Array} values The values to append.\n   * @returns {Array} Returns `array`.\n   */\n  function arrayPush(array, values) {\n    var index = -1,\n        length = values.length,\n        offset = array.length;\n\n    while (++index < length) {\n      array[offset + index] = values[index];\n    }\n    return array;\n  }\n\n  /**\n   * A specialized version of `_.reduce` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @param {*} [accumulator] The initial value.\n   * @param {boolean} [initAccum] Specify using the first element of `array` as\n   *  the initial value.\n   * @returns {*} Returns the accumulated value.\n   */\n  function arrayReduce(array, iteratee, accumulator, initAccum) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    if (initAccum && length) {\n      accumulator = array[++index];\n    }\n    while (++index < length) {\n      accumulator = iteratee(accumulator, array[index], index, array);\n    }\n    return accumulator;\n  }\n\n  /**\n   * A specialized version of `_.reduceRight` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @param {*} [accumulator] The initial value.\n   * @param {boolean} [initAccum] Specify using the last element of `array` as\n   *  the initial value.\n   * @returns {*} Returns the accumulated value.\n   */\n  function arrayReduceRight(array, iteratee, accumulator, initAccum) {\n    var length = array == null ? 0 : array.length;\n    if (initAccum && length) {\n      accumulator = array[--length];\n    }\n    while (length--) {\n      accumulator = iteratee(accumulator, array[length], length, array);\n    }\n    return accumulator;\n  }\n\n  /**\n   * A specialized version of `_.some` for arrays without support for iteratee\n   * shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} predicate The function invoked per iteration.\n   * @returns {boolean} Returns `true` if any element passes the predicate check,\n   *  else `false`.\n   */\n  function arraySome(array, predicate) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (predicate(array[index], index, array)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Gets the size of an ASCII `string`.\n   *\n   * @private\n   * @param {string} string The string inspect.\n   * @returns {number} Returns the string size.\n   */\n  var asciiSize = baseProperty('length');\n\n  /**\n   * Converts an ASCII `string` to an array.\n   *\n   * @private\n   * @param {string} string The string to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function asciiToArray(string) {\n    return string.split('');\n  }\n\n  /**\n   * Splits an ASCII `string` into an array of its words.\n   *\n   * @private\n   * @param {string} The string to inspect.\n   * @returns {Array} Returns the words of `string`.\n   */\n  function asciiWords(string) {\n    return string.match(reAsciiWord) || [];\n  }\n\n  /**\n   * The base implementation of methods like `_.findKey` and `_.findLastKey`,\n   * without support for iteratee shorthands, which iterates over `collection`\n   * using `eachFunc`.\n   *\n   * @private\n   * @param {Array|Object} collection The collection to inspect.\n   * @param {Function} predicate The function invoked per iteration.\n   * @param {Function} eachFunc The function to iterate over `collection`.\n   * @returns {*} Returns the found element or its key, else `undefined`.\n   */\n  function baseFindKey(collection, predicate, eachFunc) {\n    var result;\n    eachFunc(collection, function(value, key, collection) {\n      if (predicate(value, key, collection)) {\n        result = key;\n        return false;\n      }\n    });\n    return result;\n  }\n\n  /**\n   * The base implementation of `_.findIndex` and `_.findLastIndex` without\n   * support for iteratee shorthands.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {Function} predicate The function invoked per iteration.\n   * @param {number} fromIndex The index to search from.\n   * @param {boolean} [fromRight] Specify iterating from right to left.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function baseFindIndex(array, predicate, fromIndex, fromRight) {\n    var length = array.length,\n        index = fromIndex + (fromRight ? 1 : -1);\n\n    while ((fromRight ? index-- : ++index < length)) {\n      if (predicate(array[index], index, array)) {\n        return index;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * The base implementation of `_.indexOf` without `fromIndex` bounds checks.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function baseIndexOf(array, value, fromIndex) {\n    return value === value\n      ? strictIndexOf(array, value, fromIndex)\n      : baseFindIndex(array, baseIsNaN, fromIndex);\n  }\n\n  /**\n   * This function is like `baseIndexOf` except that it accepts a comparator.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @param {Function} comparator The comparator invoked per element.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function baseIndexOfWith(array, value, fromIndex, comparator) {\n    var index = fromIndex - 1,\n        length = array.length;\n\n    while (++index < length) {\n      if (comparator(array[index], value)) {\n        return index;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * The base implementation of `_.isNaN` without support for number objects.\n   *\n   * @private\n   * @param {*} value The value to check.\n   * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n   */\n  function baseIsNaN(value) {\n    return value !== value;\n  }\n\n  /**\n   * The base implementation of `_.mean` and `_.meanBy` without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} array The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {number} Returns the mean.\n   */\n  function baseMean(array, iteratee) {\n    var length = array == null ? 0 : array.length;\n    return length ? (baseSum(array, iteratee) / length) : NAN;\n  }\n\n  /**\n   * The base implementation of `_.property` without support for deep paths.\n   *\n   * @private\n   * @param {string} key The key of the property to get.\n   * @returns {Function} Returns the new accessor function.\n   */\n  function baseProperty(key) {\n    return function(object) {\n      return object == null ? undefined : object[key];\n    };\n  }\n\n  /**\n   * The base implementation of `_.propertyOf` without support for deep paths.\n   *\n   * @private\n   * @param {Object} object The object to query.\n   * @returns {Function} Returns the new accessor function.\n   */\n  function basePropertyOf(object) {\n    return function(key) {\n      return object == null ? undefined : object[key];\n    };\n  }\n\n  /**\n   * The base implementation of `_.reduce` and `_.reduceRight`, without support\n   * for iteratee shorthands, which iterates over `collection` using `eachFunc`.\n   *\n   * @private\n   * @param {Array|Object} collection The collection to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @param {*} accumulator The initial value.\n   * @param {boolean} initAccum Specify using the first or last element of\n   *  `collection` as the initial value.\n   * @param {Function} eachFunc The function to iterate over `collection`.\n   * @returns {*} Returns the accumulated value.\n   */\n  function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {\n    eachFunc(collection, function(value, index, collection) {\n      accumulator = initAccum\n        ? (initAccum = false, value)\n        : iteratee(accumulator, value, index, collection);\n    });\n    return accumulator;\n  }\n\n  /**\n   * The base implementation of `_.sortBy` which uses `comparer` to define the\n   * sort order of `array` and replaces criteria objects with their corresponding\n   * values.\n   *\n   * @private\n   * @param {Array} array The array to sort.\n   * @param {Function} comparer The function to define sort order.\n   * @returns {Array} Returns `array`.\n   */\n  function baseSortBy(array, comparer) {\n    var length = array.length;\n\n    array.sort(comparer);\n    while (length--) {\n      array[length] = array[length].value;\n    }\n    return array;\n  }\n\n  /**\n   * The base implementation of `_.sum` and `_.sumBy` without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} array The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {number} Returns the sum.\n   */\n  function baseSum(array, iteratee) {\n    var result,\n        index = -1,\n        length = array.length;\n\n    while (++index < length) {\n      var current = iteratee(array[index]);\n      if (current !== undefined) {\n        result = result === undefined ? current : (result + current);\n      }\n    }\n    return result;\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   */\n  function 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   * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array\n   * of key-value pairs for `object` corresponding to the property names of `props`.\n   *\n   * @private\n   * @param {Object} object The object to query.\n   * @param {Array} props The property names to get values for.\n   * @returns {Object} Returns the key-value pairs.\n   */\n  function baseToPairs(object, props) {\n    return arrayMap(props, function(key) {\n      return [key, object[key]];\n    });\n  }\n\n  /**\n   * The base implementation of `_.unary` without support for storing metadata.\n   *\n   * @private\n   * @param {Function} func The function to cap arguments for.\n   * @returns {Function} Returns the new capped function.\n   */\n  function baseUnary(func) {\n    return function(value) {\n      return func(value);\n    };\n  }\n\n  /**\n   * The base implementation of `_.values` and `_.valuesIn` which creates an\n   * array of `object` property values corresponding to the property names\n   * of `props`.\n   *\n   * @private\n   * @param {Object} object The object to query.\n   * @param {Array} props The property names to get values for.\n   * @returns {Object} Returns the array of property values.\n   */\n  function baseValues(object, props) {\n    return arrayMap(props, function(key) {\n      return object[key];\n    });\n  }\n\n  /**\n   * Checks if a `cache` value for `key` exists.\n   *\n   * @private\n   * @param {Object} cache The cache to query.\n   * @param {string} key The key of the entry to check.\n   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n   */\n  function cacheHas(cache, key) {\n    return cache.has(key);\n  }\n\n  /**\n   * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol\n   * that is not found in the character symbols.\n   *\n   * @private\n   * @param {Array} strSymbols The string symbols to inspect.\n   * @param {Array} chrSymbols The character symbols to find.\n   * @returns {number} Returns the index of the first unmatched string symbol.\n   */\n  function charsStartIndex(strSymbols, chrSymbols) {\n    var index = -1,\n        length = strSymbols.length;\n\n    while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}\n    return index;\n  }\n\n  /**\n   * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol\n   * that is not found in the character symbols.\n   *\n   * @private\n   * @param {Array} strSymbols The string symbols to inspect.\n   * @param {Array} chrSymbols The character symbols to find.\n   * @returns {number} Returns the index of the last unmatched string symbol.\n   */\n  function charsEndIndex(strSymbols, chrSymbols) {\n    var index = strSymbols.length;\n\n    while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}\n    return index;\n  }\n\n  /**\n   * Gets the number of `placeholder` occurrences in `array`.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} placeholder The placeholder to search for.\n   * @returns {number} Returns the placeholder count.\n   */\n  function countHolders(array, placeholder) {\n    var length = array.length,\n        result = 0;\n\n    while (length--) {\n      if (array[length] === placeholder) {\n        ++result;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A\n   * letters to basic Latin letters.\n   *\n   * @private\n   * @param {string} letter The matched letter to deburr.\n   * @returns {string} Returns the deburred letter.\n   */\n  var deburrLetter = basePropertyOf(deburredLetters);\n\n  /**\n   * Used by `_.escape` to convert characters to HTML entities.\n   *\n   * @private\n   * @param {string} chr The matched character to escape.\n   * @returns {string} Returns the escaped character.\n   */\n  var escapeHtmlChar = basePropertyOf(htmlEscapes);\n\n  /**\n   * Used by `_.template` to escape characters for inclusion in compiled string literals.\n   *\n   * @private\n   * @param {string} chr The matched character to escape.\n   * @returns {string} Returns the escaped character.\n   */\n  function escapeStringChar(chr) {\n    return '\\\\' + stringEscapes[chr];\n  }\n\n  /**\n   * Gets the value at `key` of `object`.\n   *\n   * @private\n   * @param {Object} [object] The object to query.\n   * @param {string} key The key of the property to get.\n   * @returns {*} Returns the property value.\n   */\n  function getValue(object, key) {\n    return object == null ? undefined : object[key];\n  }\n\n  /**\n   * Checks if `string` contains Unicode symbols.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {boolean} Returns `true` if a symbol is found, else `false`.\n   */\n  function hasUnicode(string) {\n    return reHasUnicode.test(string);\n  }\n\n  /**\n   * Checks if `string` contains a word composed of Unicode symbols.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {boolean} Returns `true` if a word is found, else `false`.\n   */\n  function hasUnicodeWord(string) {\n    return reHasUnicodeWord.test(string);\n  }\n\n  /**\n   * Converts `iterator` to an array.\n   *\n   * @private\n   * @param {Object} iterator The iterator to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function iteratorToArray(iterator) {\n    var data,\n        result = [];\n\n    while (!(data = iterator.next()).done) {\n      result.push(data.value);\n    }\n    return result;\n  }\n\n  /**\n   * Converts `map` to its key-value pairs.\n   *\n   * @private\n   * @param {Object} map The map to convert.\n   * @returns {Array} Returns the key-value pairs.\n   */\n  function mapToArray(map) {\n    var index = -1,\n        result = Array(map.size);\n\n    map.forEach(function(value, key) {\n      result[++index] = [key, value];\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   */\n  function overArg(func, transform) {\n    return function(arg) {\n      return func(transform(arg));\n    };\n  }\n\n  /**\n   * Replaces all `placeholder` elements in `array` with an internal placeholder\n   * and returns an array of their indexes.\n   *\n   * @private\n   * @param {Array} array The array to modify.\n   * @param {*} placeholder The placeholder to replace.\n   * @returns {Array} Returns the new array of placeholder indexes.\n   */\n  function replaceHolders(array, placeholder) {\n    var index = -1,\n        length = array.length,\n        resIndex = 0,\n        result = [];\n\n    while (++index < length) {\n      var value = array[index];\n      if (value === placeholder || value === PLACEHOLDER) {\n        array[index] = PLACEHOLDER;\n        result[resIndex++] = index;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Converts `set` to an array of its values.\n   *\n   * @private\n   * @param {Object} set The set to convert.\n   * @returns {Array} Returns the values.\n   */\n  function setToArray(set) {\n    var index = -1,\n        result = Array(set.size);\n\n    set.forEach(function(value) {\n      result[++index] = value;\n    });\n    return result;\n  }\n\n  /**\n   * Converts `set` to its value-value pairs.\n   *\n   * @private\n   * @param {Object} set The set to convert.\n   * @returns {Array} Returns the value-value pairs.\n   */\n  function setToPairs(set) {\n    var index = -1,\n        result = Array(set.size);\n\n    set.forEach(function(value) {\n      result[++index] = [value, value];\n    });\n    return result;\n  }\n\n  /**\n   * A specialized version of `_.indexOf` which performs strict equality\n   * comparisons of values, i.e. `===`.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function strictIndexOf(array, value, fromIndex) {\n    var index = fromIndex - 1,\n        length = array.length;\n\n    while (++index < length) {\n      if (array[index] === value) {\n        return index;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * A specialized version of `_.lastIndexOf` which performs strict equality\n   * comparisons of values, i.e. `===`.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function strictLastIndexOf(array, value, fromIndex) {\n    var index = fromIndex + 1;\n    while (index--) {\n      if (array[index] === value) {\n        return index;\n      }\n    }\n    return index;\n  }\n\n  /**\n   * Gets the number of symbols in `string`.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {number} Returns the string size.\n   */\n  function stringSize(string) {\n    return hasUnicode(string)\n      ? unicodeSize(string)\n      : asciiSize(string);\n  }\n\n  /**\n   * Converts `string` to an array.\n   *\n   * @private\n   * @param {string} string The string to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function stringToArray(string) {\n    return hasUnicode(string)\n      ? unicodeToArray(string)\n      : asciiToArray(string);\n  }\n\n  /**\n   * Used by `_.unescape` to convert HTML entities to characters.\n   *\n   * @private\n   * @param {string} chr The matched character to unescape.\n   * @returns {string} Returns the unescaped character.\n   */\n  var unescapeHtmlChar = basePropertyOf(htmlUnescapes);\n\n  /**\n   * Gets the size of a Unicode `string`.\n   *\n   * @private\n   * @param {string} string The string inspect.\n   * @returns {number} Returns the string size.\n   */\n  function unicodeSize(string) {\n    var result = reUnicode.lastIndex = 0;\n    while (reUnicode.test(string)) {\n      ++result;\n    }\n    return result;\n  }\n\n  /**\n   * Converts a Unicode `string` to an array.\n   *\n   * @private\n   * @param {string} string The string to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function unicodeToArray(string) {\n    return string.match(reUnicode) || [];\n  }\n\n  /**\n   * Splits a Unicode `string` into an array of its words.\n   *\n   * @private\n   * @param {string} The string to inspect.\n   * @returns {Array} Returns the words of `string`.\n   */\n  function unicodeWords(string) {\n    return string.match(reUnicodeWord) || [];\n  }\n\n  /*--------------------------------------------------------------------------*/\n\n  /**\n   * Create a new pristine `lodash` function using the `context` object.\n   *\n   * @static\n   * @memberOf _\n   * @since 1.1.0\n   * @category Util\n   * @param {Object} [context=root] The context object.\n   * @returns {Function} Returns a new `lodash` function.\n   * @example\n   *\n   * _.mixin({ 'foo': _.constant('foo') });\n   *\n   * var lodash = _.runInContext();\n   * lodash.mixin({ 'bar': lodash.constant('bar') });\n   *\n   * _.isFunction(_.foo);\n   * // => true\n   * _.isFunction(_.bar);\n   * // => false\n   *\n   * lodash.isFunction(lodash.foo);\n   * // => false\n   * lodash.isFunction(lodash.bar);\n   * // => true\n   *\n   * // Create a suped-up `defer` in Node.js.\n   * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;\n   */\n  var runInContext = (function runInContext(context) {\n    context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps));\n\n    /** Built-in constructor references. */\n    var Array = context.Array,\n        Date = context.Date,\n        Error = context.Error,\n        Function = context.Function,\n        Math = context.Math,\n        Object = context.Object,\n        RegExp = context.RegExp,\n        String = context.String,\n        TypeError = context.TypeError;\n\n    /** Used for built-in method references. */\n    var arrayProto = Array.prototype,\n        funcProto = Function.prototype,\n        objectProto = Object.prototype;\n\n    /** Used to detect overreaching core-js shims. */\n    var coreJsData = context['__core-js_shared__'];\n\n    /** Used to resolve the decompiled source of functions. */\n    var funcToString = funcProto.toString;\n\n    /** Used to check objects for own properties. */\n    var hasOwnProperty = objectProto.hasOwnProperty;\n\n    /** Used to generate unique IDs. */\n    var idCounter = 0;\n\n    /** Used to detect methods masquerading as native. */\n    var maskSrcKey = (function() {\n      var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n      return uid ? ('Symbol(src)_1.' + uid) : '';\n    }());\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     */\n    var nativeObjectToString = objectProto.toString;\n\n    /** Used to infer the `Object` constructor. */\n    var objectCtorString = funcToString.call(Object);\n\n    /** Used to restore the original `_` reference in `_.noConflict`. */\n    var oldDash = root._;\n\n    /** Used to detect if a method is native. */\n    var reIsNative = RegExp('^' +\n      funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n      .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n    );\n\n    /** Built-in value references. */\n    var Buffer = moduleExports ? context.Buffer : undefined,\n        Symbol = context.Symbol,\n        Uint8Array = context.Uint8Array,\n        allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,\n        getPrototype = overArg(Object.getPrototypeOf, Object),\n        objectCreate = Object.create,\n        propertyIsEnumerable = objectProto.propertyIsEnumerable,\n        splice = arrayProto.splice,\n        spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined,\n        symIterator = Symbol ? Symbol.iterator : undefined,\n        symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n    var defineProperty = (function() {\n      try {\n        var func = getNative(Object, 'defineProperty');\n        func({}, '', {});\n        return func;\n      } catch (e) {}\n    }());\n\n    /** Mocked built-ins. */\n    var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout,\n        ctxNow = Date && Date.now !== root.Date.now && Date.now,\n        ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;\n\n    /* Built-in method references for those with the same name as other `lodash` methods. */\n    var nativeCeil = Math.ceil,\n        nativeFloor = Math.floor,\n        nativeGetSymbols = Object.getOwnPropertySymbols,\n        nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n        nativeIsFinite = context.isFinite,\n        nativeJoin = arrayProto.join,\n        nativeKeys = overArg(Object.keys, Object),\n        nativeMax = Math.max,\n        nativeMin = Math.min,\n        nativeNow = Date.now,\n        nativeParseInt = context.parseInt,\n        nativeRandom = Math.random,\n        nativeReverse = arrayProto.reverse;\n\n    /* Built-in method references that are verified to be native. */\n    var DataView = getNative(context, 'DataView'),\n        Map = getNative(context, 'Map'),\n        Promise = getNative(context, 'Promise'),\n        Set = getNative(context, 'Set'),\n        WeakMap = getNative(context, 'WeakMap'),\n        nativeCreate = getNative(Object, 'create');\n\n    /** Used to store function metadata. */\n    var metaMap = WeakMap && new WeakMap;\n\n    /** Used to lookup unminified function names. */\n    var realNames = {};\n\n    /** Used to detect maps, sets, and weakmaps. */\n    var dataViewCtorString = toSource(DataView),\n        mapCtorString = toSource(Map),\n        promiseCtorString = toSource(Promise),\n        setCtorString = toSource(Set),\n        weakMapCtorString = toSource(WeakMap);\n\n    /** Used to convert symbols to primitives and strings. */\n    var symbolProto = Symbol ? Symbol.prototype : undefined,\n        symbolValueOf = symbolProto ? symbolProto.valueOf : undefined,\n        symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a `lodash` object which wraps `value` to enable implicit method\n     * chain sequences. Methods that operate on and return arrays, collections,\n     * and functions can be chained together. Methods that retrieve a single value\n     * or may return a primitive value will automatically end the chain sequence\n     * and return the unwrapped value. Otherwise, the value must be unwrapped\n     * with `_#value`.\n     *\n     * Explicit chain sequences, which must be unwrapped with `_#value`, may be\n     * enabled using `_.chain`.\n     *\n     * The execution of chained methods is lazy, that is, it's deferred until\n     * `_#value` is implicitly or explicitly called.\n     *\n     * Lazy evaluation allows several methods to support shortcut fusion.\n     * Shortcut fusion is an optimization to merge iteratee calls; this avoids\n     * the creation of intermediate arrays and can greatly reduce the number of\n     * iteratee executions. Sections of a chain sequence qualify for shortcut\n     * fusion if the section is applied to an array and iteratees accept only\n     * one argument. The heuristic for whether a section qualifies for shortcut\n     * fusion is subject to change.\n     *\n     * Chaining is supported in custom builds as long as the `_#value` method is\n     * directly or indirectly included in the build.\n     *\n     * In addition to lodash methods, wrappers have `Array` and `String` methods.\n     *\n     * The wrapper `Array` methods are:\n     * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`\n     *\n     * The wrapper `String` methods are:\n     * `replace` and `split`\n     *\n     * The wrapper methods that support shortcut fusion are:\n     * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,\n     * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,\n     * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`\n     *\n     * The chainable wrapper methods are:\n     * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,\n     * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,\n     * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,\n     * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,\n     * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,\n     * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,\n     * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,\n     * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,\n     * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,\n     * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,\n     * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,\n     * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,\n     * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,\n     * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,\n     * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,\n     * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,\n     * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,\n     * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,\n     * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,\n     * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,\n     * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,\n     * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,\n     * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,\n     * `zipObject`, `zipObjectDeep`, and `zipWith`\n     *\n     * The wrapper methods that are **not** chainable by default are:\n     * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,\n     * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,\n     * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,\n     * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,\n     * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,\n     * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,\n     * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,\n     * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,\n     * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,\n     * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,\n     * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,\n     * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,\n     * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,\n     * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,\n     * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,\n     * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,\n     * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,\n     * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,\n     * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,\n     * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,\n     * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,\n     * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,\n     * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,\n     * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,\n     * `upperFirst`, `value`, and `words`\n     *\n     * @name _\n     * @constructor\n     * @category Seq\n     * @param {*} value The value to wrap in a `lodash` instance.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var wrapped = _([1, 2, 3]);\n     *\n     * // Returns an unwrapped value.\n     * wrapped.reduce(_.add);\n     * // => 6\n     *\n     * // Returns a wrapped value.\n     * var squares = wrapped.map(square);\n     *\n     * _.isArray(squares);\n     * // => false\n     *\n     * _.isArray(squares.value());\n     * // => true\n     */\n    function lodash(value) {\n      if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {\n        if (value instanceof LodashWrapper) {\n          return value;\n        }\n        if (hasOwnProperty.call(value, '__wrapped__')) {\n          return wrapperClone(value);\n        }\n      }\n      return new LodashWrapper(value);\n    }\n\n    /**\n     * The base implementation of `_.create` without support for assigning\n     * properties to the created object.\n     *\n     * @private\n     * @param {Object} proto The object to inherit from.\n     * @returns {Object} Returns the new object.\n     */\n    var baseCreate = (function() {\n      function object() {}\n      return function(proto) {\n        if (!isObject(proto)) {\n          return {};\n        }\n        if (objectCreate) {\n          return objectCreate(proto);\n        }\n        object.prototype = proto;\n        var result = new object;\n        object.prototype = undefined;\n        return result;\n      };\n    }());\n\n    /**\n     * The function whose prototype chain sequence wrappers inherit from.\n     *\n     * @private\n     */\n    function baseLodash() {\n      // No operation performed.\n    }\n\n    /**\n     * The base constructor for creating `lodash` wrapper objects.\n     *\n     * @private\n     * @param {*} value The value to wrap.\n     * @param {boolean} [chainAll] Enable explicit method chain sequences.\n     */\n    function LodashWrapper(value, chainAll) {\n      this.__wrapped__ = value;\n      this.__actions__ = [];\n      this.__chain__ = !!chainAll;\n      this.__index__ = 0;\n      this.__values__ = undefined;\n    }\n\n    /**\n     * By default, the template delimiters used by lodash are like those in\n     * embedded Ruby (ERB) as well as ES2015 template strings. Change the\n     * following template settings to use alternative delimiters.\n     *\n     * @static\n     * @memberOf _\n     * @type {Object}\n     */\n    lodash.templateSettings = {\n\n      /**\n       * Used to detect `data` property values to be HTML-escaped.\n       *\n       * @memberOf _.templateSettings\n       * @type {RegExp}\n       */\n      'escape': reEscape,\n\n      /**\n       * Used to detect code to be evaluated.\n       *\n       * @memberOf _.templateSettings\n       * @type {RegExp}\n       */\n      'evaluate': reEvaluate,\n\n      /**\n       * Used to detect `data` property values to inject.\n       *\n       * @memberOf _.templateSettings\n       * @type {RegExp}\n       */\n      'interpolate': reInterpolate,\n\n      /**\n       * Used to reference the data object in the template text.\n       *\n       * @memberOf _.templateSettings\n       * @type {string}\n       */\n      'variable': '',\n\n      /**\n       * Used to import variables into the compiled template.\n       *\n       * @memberOf _.templateSettings\n       * @type {Object}\n       */\n      'imports': {\n\n        /**\n         * A reference to the `lodash` function.\n         *\n         * @memberOf _.templateSettings.imports\n         * @type {Function}\n         */\n        '_': lodash\n      }\n    };\n\n    // Ensure wrappers are instances of `baseLodash`.\n    lodash.prototype = baseLodash.prototype;\n    lodash.prototype.constructor = lodash;\n\n    LodashWrapper.prototype = baseCreate(baseLodash.prototype);\n    LodashWrapper.prototype.constructor = LodashWrapper;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.\n     *\n     * @private\n     * @constructor\n     * @param {*} value The value to wrap.\n     */\n    function LazyWrapper(value) {\n      this.__wrapped__ = value;\n      this.__actions__ = [];\n      this.__dir__ = 1;\n      this.__filtered__ = false;\n      this.__iteratees__ = [];\n      this.__takeCount__ = MAX_ARRAY_LENGTH;\n      this.__views__ = [];\n    }\n\n    /**\n     * Creates a clone of the lazy wrapper object.\n     *\n     * @private\n     * @name clone\n     * @memberOf LazyWrapper\n     * @returns {Object} Returns the cloned `LazyWrapper` object.\n     */\n    function lazyClone() {\n      var result = new LazyWrapper(this.__wrapped__);\n      result.__actions__ = copyArray(this.__actions__);\n      result.__dir__ = this.__dir__;\n      result.__filtered__ = this.__filtered__;\n      result.__iteratees__ = copyArray(this.__iteratees__);\n      result.__takeCount__ = this.__takeCount__;\n      result.__views__ = copyArray(this.__views__);\n      return result;\n    }\n\n    /**\n     * Reverses the direction of lazy iteration.\n     *\n     * @private\n     * @name reverse\n     * @memberOf LazyWrapper\n     * @returns {Object} Returns the new reversed `LazyWrapper` object.\n     */\n    function lazyReverse() {\n      if (this.__filtered__) {\n        var result = new LazyWrapper(this);\n        result.__dir__ = -1;\n        result.__filtered__ = true;\n      } else {\n        result = this.clone();\n        result.__dir__ *= -1;\n      }\n      return result;\n    }\n\n    /**\n     * Extracts the unwrapped value from its lazy wrapper.\n     *\n     * @private\n     * @name value\n     * @memberOf LazyWrapper\n     * @returns {*} Returns the unwrapped value.\n     */\n    function lazyValue() {\n      var array = this.__wrapped__.value(),\n          dir = this.__dir__,\n          isArr = isArray(array),\n          isRight = dir < 0,\n          arrLength = isArr ? array.length : 0,\n          view = getView(0, arrLength, this.__views__),\n          start = view.start,\n          end = view.end,\n          length = end - start,\n          index = isRight ? end : (start - 1),\n          iteratees = this.__iteratees__,\n          iterLength = iteratees.length,\n          resIndex = 0,\n          takeCount = nativeMin(length, this.__takeCount__);\n\n      if (!isArr || (!isRight && arrLength == length && takeCount == length)) {\n        return baseWrapperValue(array, this.__actions__);\n      }\n      var result = [];\n\n      outer:\n      while (length-- && resIndex < takeCount) {\n        index += dir;\n\n        var iterIndex = -1,\n            value = array[index];\n\n        while (++iterIndex < iterLength) {\n          var data = iteratees[iterIndex],\n              iteratee = data.iteratee,\n              type = data.type,\n              computed = iteratee(value);\n\n          if (type == LAZY_MAP_FLAG) {\n            value = computed;\n          } else if (!computed) {\n            if (type == LAZY_FILTER_FLAG) {\n              continue outer;\n            } else {\n              break outer;\n            }\n          }\n        }\n        result[resIndex++] = value;\n      }\n      return result;\n    }\n\n    // Ensure `LazyWrapper` is an instance of `baseLodash`.\n    LazyWrapper.prototype = baseCreate(baseLodash.prototype);\n    LazyWrapper.prototype.constructor = LazyWrapper;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a hash object.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function Hash(entries) {\n      var index = -1,\n          length = entries == null ? 0 : entries.length;\n\n      this.clear();\n      while (++index < length) {\n        var entry = entries[index];\n        this.set(entry[0], entry[1]);\n      }\n    }\n\n    /**\n     * Removes all key-value entries from the hash.\n     *\n     * @private\n     * @name clear\n     * @memberOf Hash\n     */\n    function hashClear() {\n      this.__data__ = nativeCreate ? nativeCreate(null) : {};\n      this.size = 0;\n    }\n\n    /**\n     * Removes `key` and its value from the hash.\n     *\n     * @private\n     * @name delete\n     * @memberOf Hash\n     * @param {Object} hash The hash to modify.\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function hashDelete(key) {\n      var result = this.has(key) && delete this.__data__[key];\n      this.size -= result ? 1 : 0;\n      return result;\n    }\n\n    /**\n     * Gets the hash value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf Hash\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function hashGet(key) {\n      var data = this.__data__;\n      if (nativeCreate) {\n        var result = data[key];\n        return result === HASH_UNDEFINED ? undefined : result;\n      }\n      return hasOwnProperty.call(data, key) ? data[key] : undefined;\n    }\n\n    /**\n     * Checks if a hash value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf Hash\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function hashHas(key) {\n      var data = this.__data__;\n      return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n    }\n\n    /**\n     * Sets the hash `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf Hash\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the hash instance.\n     */\n    function hashSet(key, value) {\n      var data = this.__data__;\n      this.size += this.has(key) ? 0 : 1;\n      data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n      return this;\n    }\n\n    // Add methods to `Hash`.\n    Hash.prototype.clear = hashClear;\n    Hash.prototype['delete'] = hashDelete;\n    Hash.prototype.get = hashGet;\n    Hash.prototype.has = hashHas;\n    Hash.prototype.set = hashSet;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an list cache object.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function ListCache(entries) {\n      var index = -1,\n          length = entries == null ? 0 : entries.length;\n\n      this.clear();\n      while (++index < length) {\n        var entry = entries[index];\n        this.set(entry[0], entry[1]);\n      }\n    }\n\n    /**\n     * Removes all key-value entries from the list cache.\n     *\n     * @private\n     * @name clear\n     * @memberOf ListCache\n     */\n    function listCacheClear() {\n      this.__data__ = [];\n      this.size = 0;\n    }\n\n    /**\n     * Removes `key` and its value from the list cache.\n     *\n     * @private\n     * @name delete\n     * @memberOf ListCache\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function listCacheDelete(key) {\n      var data = this.__data__,\n          index = assocIndexOf(data, key);\n\n      if (index < 0) {\n        return false;\n      }\n      var lastIndex = data.length - 1;\n      if (index == lastIndex) {\n        data.pop();\n      } else {\n        splice.call(data, index, 1);\n      }\n      --this.size;\n      return true;\n    }\n\n    /**\n     * Gets the list cache value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf ListCache\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function listCacheGet(key) {\n      var data = this.__data__,\n          index = assocIndexOf(data, key);\n\n      return index < 0 ? undefined : data[index][1];\n    }\n\n    /**\n     * Checks if a list cache value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf ListCache\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function listCacheHas(key) {\n      return assocIndexOf(this.__data__, key) > -1;\n    }\n\n    /**\n     * Sets the list cache `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf ListCache\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the list cache instance.\n     */\n    function listCacheSet(key, value) {\n      var data = this.__data__,\n          index = assocIndexOf(data, key);\n\n      if (index < 0) {\n        ++this.size;\n        data.push([key, value]);\n      } else {\n        data[index][1] = value;\n      }\n      return this;\n    }\n\n    // Add methods to `ListCache`.\n    ListCache.prototype.clear = listCacheClear;\n    ListCache.prototype['delete'] = listCacheDelete;\n    ListCache.prototype.get = listCacheGet;\n    ListCache.prototype.has = listCacheHas;\n    ListCache.prototype.set = listCacheSet;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a map cache object to store key-value pairs.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function MapCache(entries) {\n      var index = -1,\n          length = entries == null ? 0 : entries.length;\n\n      this.clear();\n      while (++index < length) {\n        var entry = entries[index];\n        this.set(entry[0], entry[1]);\n      }\n    }\n\n    /**\n     * Removes all key-value entries from the map.\n     *\n     * @private\n     * @name clear\n     * @memberOf MapCache\n     */\n    function mapCacheClear() {\n      this.size = 0;\n      this.__data__ = {\n        'hash': new Hash,\n        'map': new (Map || ListCache),\n        'string': new Hash\n      };\n    }\n\n    /**\n     * Removes `key` and its value from the map.\n     *\n     * @private\n     * @name delete\n     * @memberOf MapCache\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function mapCacheDelete(key) {\n      var result = getMapData(this, key)['delete'](key);\n      this.size -= result ? 1 : 0;\n      return result;\n    }\n\n    /**\n     * Gets the map value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf MapCache\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function mapCacheGet(key) {\n      return getMapData(this, key).get(key);\n    }\n\n    /**\n     * Checks if a map value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf MapCache\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function mapCacheHas(key) {\n      return getMapData(this, key).has(key);\n    }\n\n    /**\n     * Sets the map `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf MapCache\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the map cache instance.\n     */\n    function mapCacheSet(key, value) {\n      var data = getMapData(this, key),\n          size = data.size;\n\n      data.set(key, value);\n      this.size += data.size == size ? 0 : 1;\n      return this;\n    }\n\n    // Add methods to `MapCache`.\n    MapCache.prototype.clear = mapCacheClear;\n    MapCache.prototype['delete'] = mapCacheDelete;\n    MapCache.prototype.get = mapCacheGet;\n    MapCache.prototype.has = mapCacheHas;\n    MapCache.prototype.set = mapCacheSet;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     *\n     * Creates an array cache object to store unique values.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [values] The values to cache.\n     */\n    function SetCache(values) {\n      var index = -1,\n          length = values == null ? 0 : values.length;\n\n      this.__data__ = new MapCache;\n      while (++index < length) {\n        this.add(values[index]);\n      }\n    }\n\n    /**\n     * Adds `value` to the array cache.\n     *\n     * @private\n     * @name add\n     * @memberOf SetCache\n     * @alias push\n     * @param {*} value The value to cache.\n     * @returns {Object} Returns the cache instance.\n     */\n    function setCacheAdd(value) {\n      this.__data__.set(value, HASH_UNDEFINED);\n      return this;\n    }\n\n    /**\n     * Checks if `value` is in the array cache.\n     *\n     * @private\n     * @name has\n     * @memberOf SetCache\n     * @param {*} value The value to search for.\n     * @returns {number} Returns `true` if `value` is found, else `false`.\n     */\n    function setCacheHas(value) {\n      return this.__data__.has(value);\n    }\n\n    // Add methods to `SetCache`.\n    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\n    SetCache.prototype.has = setCacheHas;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a stack cache object to store key-value pairs.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function Stack(entries) {\n      var data = this.__data__ = new ListCache(entries);\n      this.size = data.size;\n    }\n\n    /**\n     * Removes all key-value entries from the stack.\n     *\n     * @private\n     * @name clear\n     * @memberOf Stack\n     */\n    function stackClear() {\n      this.__data__ = new ListCache;\n      this.size = 0;\n    }\n\n    /**\n     * Removes `key` and its value from the stack.\n     *\n     * @private\n     * @name delete\n     * @memberOf Stack\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function stackDelete(key) {\n      var data = this.__data__,\n          result = data['delete'](key);\n\n      this.size = data.size;\n      return result;\n    }\n\n    /**\n     * Gets the stack value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf Stack\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function stackGet(key) {\n      return this.__data__.get(key);\n    }\n\n    /**\n     * Checks if a stack value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf Stack\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function stackHas(key) {\n      return this.__data__.has(key);\n    }\n\n    /**\n     * Sets the stack `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf Stack\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the stack cache instance.\n     */\n    function stackSet(key, value) {\n      var data = this.__data__;\n      if (data instanceof ListCache) {\n        var pairs = data.__data__;\n        if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n          pairs.push([key, value]);\n          this.size = ++data.size;\n          return this;\n        }\n        data = this.__data__ = new MapCache(pairs);\n      }\n      data.set(key, value);\n      this.size = data.size;\n      return this;\n    }\n\n    // Add methods to `Stack`.\n    Stack.prototype.clear = stackClear;\n    Stack.prototype['delete'] = stackDelete;\n    Stack.prototype.get = stackGet;\n    Stack.prototype.has = stackHas;\n    Stack.prototype.set = stackSet;\n\n    /*------------------------------------------------------------------------*/\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     */\n    function arrayLikeKeys(value, inherited) {\n      var isArr = isArray(value),\n          isArg = !isArr && isArguments(value),\n          isBuff = !isArr && !isArg && isBuffer(value),\n          isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n          skipIndexes = isArr || isArg || isBuff || isType,\n          result = skipIndexes ? baseTimes(value.length, String) : [],\n          length = result.length;\n\n      for (var key in value) {\n        if ((inherited || hasOwnProperty.call(value, key)) &&\n            !(skipIndexes && (\n               // Safari 9 has enumerable `arguments.length` in strict mode.\n               key == 'length' ||\n               // Node.js 0.10 has enumerable non-index properties on buffers.\n               (isBuff && (key == 'offset' || key == 'parent')) ||\n               // PhantomJS 2 has enumerable non-index properties on typed arrays.\n               (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n               // Skip index properties.\n               isIndex(key, length)\n            ))) {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * A specialized version of `_.sample` for arrays.\n     *\n     * @private\n     * @param {Array} array The array to sample.\n     * @returns {*} Returns the random element.\n     */\n    function arraySample(array) {\n      var length = array.length;\n      return length ? array[baseRandom(0, length - 1)] : undefined;\n    }\n\n    /**\n     * A specialized version of `_.sampleSize` for arrays.\n     *\n     * @private\n     * @param {Array} array The array to sample.\n     * @param {number} n The number of elements to sample.\n     * @returns {Array} Returns the random elements.\n     */\n    function arraySampleSize(array, n) {\n      return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));\n    }\n\n    /**\n     * A specialized version of `_.shuffle` for arrays.\n     *\n     * @private\n     * @param {Array} array The array to shuffle.\n     * @returns {Array} Returns the new shuffled array.\n     */\n    function arrayShuffle(array) {\n      return shuffleSelf(copyArray(array));\n    }\n\n    /**\n     * This function is like `assignValue` except that it doesn't assign\n     * `undefined` values.\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     */\n    function assignMergeValue(object, key, value) {\n      if ((value !== undefined && !eq(object[key], value)) ||\n          (value === undefined && !(key in object))) {\n        baseAssignValue(object, key, value);\n      }\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     */\n    function 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        baseAssignValue(object, key, value);\n      }\n    }\n\n    /**\n     * Gets the index at which the `key` is found in `array` of key-value pairs.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {*} key The key to search for.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     */\n    function assocIndexOf(array, key) {\n      var length = array.length;\n      while (length--) {\n        if (eq(array[length][0], key)) {\n          return length;\n        }\n      }\n      return -1;\n    }\n\n    /**\n     * Aggregates elements of `collection` on `accumulator` with keys transformed\n     * by `iteratee` and values set by `setter`.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} setter The function to set `accumulator` values.\n     * @param {Function} iteratee The iteratee to transform keys.\n     * @param {Object} accumulator The initial aggregated object.\n     * @returns {Function} Returns `accumulator`.\n     */\n    function baseAggregator(collection, setter, iteratee, accumulator) {\n      baseEach(collection, function(value, key, collection) {\n        setter(accumulator, value, iteratee(value), collection);\n      });\n      return accumulator;\n    }\n\n    /**\n     * The base implementation of `_.assign` without support for multiple sources\n     * or `customizer` functions.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @returns {Object} Returns `object`.\n     */\n    function baseAssign(object, source) {\n      return object && copyObject(source, keys(source), object);\n    }\n\n    /**\n     * The base implementation of `_.assignIn` without support for multiple sources\n     * or `customizer` functions.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @returns {Object} Returns `object`.\n     */\n    function baseAssignIn(object, source) {\n      return object && copyObject(source, keysIn(source), object);\n    }\n\n    /**\n     * The base implementation of `assignValue` and `assignMergeValue` without\n     * value checks.\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     */\n    function baseAssignValue(object, key, value) {\n      if (key == '__proto__' && defineProperty) {\n        defineProperty(object, key, {\n          'configurable': true,\n          'enumerable': true,\n          'value': value,\n          'writable': true\n        });\n      } else {\n        object[key] = value;\n      }\n    }\n\n    /**\n     * The base implementation of `_.at` without support for individual paths.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {string[]} paths The property paths to pick.\n     * @returns {Array} Returns the picked elements.\n     */\n    function baseAt(object, paths) {\n      var index = -1,\n          length = paths.length,\n          result = Array(length),\n          skip = object == null;\n\n      while (++index < length) {\n        result[index] = skip ? undefined : get(object, paths[index]);\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.clamp` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {number} number The number to clamp.\n     * @param {number} [lower] The lower bound.\n     * @param {number} upper The upper bound.\n     * @returns {number} Returns the clamped number.\n     */\n    function baseClamp(number, lower, upper) {\n      if (number === number) {\n        if (upper !== undefined) {\n          number = number <= upper ? number : upper;\n        }\n        if (lower !== undefined) {\n          number = number >= lower ? number : lower;\n        }\n      }\n      return number;\n    }\n\n    /**\n     * The base implementation of `_.clone` and `_.cloneDeep` which tracks\n     * traversed objects.\n     *\n     * @private\n     * @param {*} value The value to clone.\n     * @param {boolean} bitmask The bitmask flags.\n     *  1 - Deep clone\n     *  2 - Flatten inherited properties\n     *  4 - Clone symbols\n     * @param {Function} [customizer] The function to customize cloning.\n     * @param {string} [key] The key of `value`.\n     * @param {Object} [object] The parent object of `value`.\n     * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n     * @returns {*} Returns the cloned value.\n     */\n    function baseClone(value, bitmask, customizer, key, object, stack) {\n      var result,\n          isDeep = bitmask & CLONE_DEEP_FLAG,\n          isFlat = bitmask & CLONE_FLAT_FLAG,\n          isFull = bitmask & CLONE_SYMBOLS_FLAG;\n\n      if (customizer) {\n        result = object ? customizer(value, key, object, stack) : customizer(value);\n      }\n      if (result !== undefined) {\n        return result;\n      }\n      if (!isObject(value)) {\n        return value;\n      }\n      var isArr = isArray(value);\n      if (isArr) {\n        result = initCloneArray(value);\n        if (!isDeep) {\n          return copyArray(value, result);\n        }\n      } else {\n        var tag = getTag(value),\n            isFunc = tag == funcTag || tag == genTag;\n\n        if (isBuffer(value)) {\n          return cloneBuffer(value, isDeep);\n        }\n        if (tag == objectTag || tag == argsTag || (isFunc && !object)) {\n          result = (isFlat || isFunc) ? {} : initCloneObject(value);\n          if (!isDeep) {\n            return isFlat\n              ? copySymbolsIn(value, baseAssignIn(result, value))\n              : copySymbols(value, baseAssign(result, value));\n          }\n        } else {\n          if (!cloneableTags[tag]) {\n            return object ? value : {};\n          }\n          result = initCloneByTag(value, tag, baseClone, isDeep);\n        }\n      }\n      // Check for circular references and return its corresponding clone.\n      stack || (stack = new Stack);\n      var stacked = stack.get(value);\n      if (stacked) {\n        return stacked;\n      }\n      stack.set(value, result);\n\n      var keysFunc = isFull\n        ? (isFlat ? getAllKeysIn : getAllKeys)\n        : (isFlat ? keysIn : keys);\n\n      var props = isArr ? undefined : keysFunc(value);\n      arrayEach(props || value, function(subValue, key) {\n        if (props) {\n          key = subValue;\n          subValue = value[key];\n        }\n        // Recursively populate clone (susceptible to call stack limits).\n        assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.conforms` which doesn't clone `source`.\n     *\n     * @private\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {Function} Returns the new spec function.\n     */\n    function baseConforms(source) {\n      var props = keys(source);\n      return function(object) {\n        return baseConformsTo(object, source, props);\n      };\n    }\n\n    /**\n     * The base implementation of `_.conformsTo` which accepts `props` to check.\n     *\n     * @private\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {boolean} Returns `true` if `object` conforms, else `false`.\n     */\n    function baseConformsTo(object, source, props) {\n      var length = props.length;\n      if (object == null) {\n        return !length;\n      }\n      object = Object(object);\n      while (length--) {\n        var key = props[length],\n            predicate = source[key],\n            value = object[key];\n\n        if ((value === undefined && !(key in object)) || !predicate(value)) {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    /**\n     * The base implementation of `_.delay` and `_.defer` which accepts `args`\n     * to provide to `func`.\n     *\n     * @private\n     * @param {Function} func The function to delay.\n     * @param {number} wait The number of milliseconds to delay invocation.\n     * @param {Array} args The arguments to provide to `func`.\n     * @returns {number|Object} Returns the timer id or timeout object.\n     */\n    function baseDelay(func, wait, args) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      return setTimeout(function() { func.apply(undefined, args); }, wait);\n    }\n\n    /**\n     * The base implementation of methods like `_.difference` without support\n     * for excluding multiple arrays or iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {Array} values The values to exclude.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     */\n    function baseDifference(array, values, iteratee, comparator) {\n      var index = -1,\n          includes = arrayIncludes,\n          isCommon = true,\n          length = array.length,\n          result = [],\n          valuesLength = values.length;\n\n      if (!length) {\n        return result;\n      }\n      if (iteratee) {\n        values = arrayMap(values, baseUnary(iteratee));\n      }\n      if (comparator) {\n        includes = arrayIncludesWith;\n        isCommon = false;\n      }\n      else if (values.length >= LARGE_ARRAY_SIZE) {\n        includes = cacheHas;\n        isCommon = false;\n        values = new SetCache(values);\n      }\n      outer:\n      while (++index < length) {\n        var value = array[index],\n            computed = iteratee == null ? value : iteratee(value);\n\n        value = (comparator || value !== 0) ? value : 0;\n        if (isCommon && computed === computed) {\n          var valuesIndex = valuesLength;\n          while (valuesIndex--) {\n            if (values[valuesIndex] === computed) {\n              continue outer;\n            }\n          }\n          result.push(value);\n        }\n        else if (!includes(values, computed, comparator)) {\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.forEach` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     */\n    var baseEach = createBaseEach(baseForOwn);\n\n    /**\n     * The base implementation of `_.forEachRight` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     */\n    var baseEachRight = createBaseEach(baseForOwnRight, true);\n\n    /**\n     * The base implementation of `_.every` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {boolean} Returns `true` if all elements pass the predicate check,\n     *  else `false`\n     */\n    function baseEvery(collection, predicate) {\n      var result = true;\n      baseEach(collection, function(value, index, collection) {\n        result = !!predicate(value, index, collection);\n        return result;\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of methods like `_.max` and `_.min` which accepts a\n     * `comparator` to determine the extremum value.\n     *\n     * @private\n     * @param {Array} array The array to iterate over.\n     * @param {Function} iteratee The iteratee invoked per iteration.\n     * @param {Function} comparator The comparator used to compare values.\n     * @returns {*} Returns the extremum value.\n     */\n    function baseExtremum(array, iteratee, comparator) {\n      var index = -1,\n          length = array.length;\n\n      while (++index < length) {\n        var value = array[index],\n            current = iteratee(value);\n\n        if (current != null && (computed === undefined\n              ? (current === current && !isSymbol(current))\n              : comparator(current, computed)\n            )) {\n          var computed = current,\n              result = value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.fill` without an iteratee call guard.\n     *\n     * @private\n     * @param {Array} array The array to fill.\n     * @param {*} value The value to fill `array` with.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns `array`.\n     */\n    function baseFill(array, value, start, end) {\n      var length = array.length;\n\n      start = toInteger(start);\n      if (start < 0) {\n        start = -start > length ? 0 : (length + start);\n      }\n      end = (end === undefined || end > length) ? length : toInteger(end);\n      if (end < 0) {\n        end += length;\n      }\n      end = start > end ? 0 : toLength(end);\n      while (start < end) {\n        array[start++] = value;\n      }\n      return array;\n    }\n\n    /**\n     * The base implementation of `_.filter` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {Array} Returns the new filtered array.\n     */\n    function baseFilter(collection, predicate) {\n      var result = [];\n      baseEach(collection, function(value, index, collection) {\n        if (predicate(value, index, collection)) {\n          result.push(value);\n        }\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.flatten` with support for restricting flattening.\n     *\n     * @private\n     * @param {Array} array The array to flatten.\n     * @param {number} depth The maximum recursion depth.\n     * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.\n     * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.\n     * @param {Array} [result=[]] The initial result value.\n     * @returns {Array} Returns the new flattened array.\n     */\n    function baseFlatten(array, depth, predicate, isStrict, result) {\n      var index = -1,\n          length = array.length;\n\n      predicate || (predicate = isFlattenable);\n      result || (result = []);\n\n      while (++index < length) {\n        var value = array[index];\n        if (depth > 0 && predicate(value)) {\n          if (depth > 1) {\n            // Recursively flatten arrays (susceptible to call stack limits).\n            baseFlatten(value, depth - 1, predicate, isStrict, result);\n          } else {\n            arrayPush(result, value);\n          }\n        } else if (!isStrict) {\n          result[result.length] = value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `baseForOwn` which iterates over `object`\n     * properties returned by `keysFunc` and invokes `iteratee` for each property.\n     * Iteratee functions may exit iteration early by explicitly returning `false`.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @param {Function} keysFunc The function to get the keys of `object`.\n     * @returns {Object} Returns `object`.\n     */\n    var baseFor = createBaseFor();\n\n    /**\n     * This function is like `baseFor` except that it iterates over properties\n     * in the opposite order.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @param {Function} keysFunc The function to get the keys of `object`.\n     * @returns {Object} Returns `object`.\n     */\n    var baseForRight = createBaseFor(true);\n\n    /**\n     * The base implementation of `_.forOwn` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     */\n    function baseForOwn(object, iteratee) {\n      return object && baseFor(object, iteratee, keys);\n    }\n\n    /**\n     * The base implementation of `_.forOwnRight` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     */\n    function baseForOwnRight(object, iteratee) {\n      return object && baseForRight(object, iteratee, keys);\n    }\n\n    /**\n     * The base implementation of `_.functions` which creates an array of\n     * `object` function property names filtered from `props`.\n     *\n     * @private\n     * @param {Object} object The object to inspect.\n     * @param {Array} props The property names to filter.\n     * @returns {Array} Returns the function names.\n     */\n    function baseFunctions(object, props) {\n      return arrayFilter(props, function(key) {\n        return isFunction(object[key]);\n      });\n    }\n\n    /**\n     * The base implementation of `_.get` without support for default values.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the property to get.\n     * @returns {*} Returns the resolved value.\n     */\n    function baseGet(object, path) {\n      path = castPath(path, object);\n\n      var index = 0,\n          length = path.length;\n\n      while (object != null && index < length) {\n        object = object[toKey(path[index++])];\n      }\n      return (index && index == length) ? object : undefined;\n    }\n\n    /**\n     * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n     * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n     * symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Function} keysFunc The function to get the keys of `object`.\n     * @param {Function} symbolsFunc The function to get the symbols of `object`.\n     * @returns {Array} Returns the array of property names and symbols.\n     */\n    function baseGetAllKeys(object, keysFunc, symbolsFunc) {\n      var result = keysFunc(object);\n      return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n    }\n\n    /**\n     * The base implementation of `getTag` without fallbacks for buggy environments.\n     *\n     * @private\n     * @param {*} value The value to query.\n     * @returns {string} Returns the `toStringTag`.\n     */\n    function baseGetTag(value) {\n      if (value == null) {\n        return value === undefined ? undefinedTag : nullTag;\n      }\n      return (symToStringTag && symToStringTag in Object(value))\n        ? getRawTag(value)\n        : objectToString(value);\n    }\n\n    /**\n     * The base implementation of `_.gt` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is greater than `other`,\n     *  else `false`.\n     */\n    function baseGt(value, other) {\n      return value > other;\n    }\n\n    /**\n     * The base implementation of `_.has` without support for deep paths.\n     *\n     * @private\n     * @param {Object} [object] The object to query.\n     * @param {Array|string} key The key to check.\n     * @returns {boolean} Returns `true` if `key` exists, else `false`.\n     */\n    function baseHas(object, key) {\n      return object != null && hasOwnProperty.call(object, key);\n    }\n\n    /**\n     * The base implementation of `_.hasIn` without support for deep paths.\n     *\n     * @private\n     * @param {Object} [object] The object to query.\n     * @param {Array|string} key The key to check.\n     * @returns {boolean} Returns `true` if `key` exists, else `false`.\n     */\n    function baseHasIn(object, key) {\n      return object != null && key in Object(object);\n    }\n\n    /**\n     * The base implementation of `_.inRange` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {number} number The number to check.\n     * @param {number} start The start of the range.\n     * @param {number} end The end of the range.\n     * @returns {boolean} Returns `true` if `number` is in the range, else `false`.\n     */\n    function baseInRange(number, start, end) {\n      return number >= nativeMin(start, end) && number < nativeMax(start, end);\n    }\n\n    /**\n     * The base implementation of methods like `_.intersection`, without support\n     * for iteratee shorthands, that accepts an array of arrays to inspect.\n     *\n     * @private\n     * @param {Array} arrays The arrays to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of shared values.\n     */\n    function baseIntersection(arrays, iteratee, comparator) {\n      var includes = comparator ? arrayIncludesWith : arrayIncludes,\n          length = arrays[0].length,\n          othLength = arrays.length,\n          othIndex = othLength,\n          caches = Array(othLength),\n          maxLength = Infinity,\n          result = [];\n\n      while (othIndex--) {\n        var array = arrays[othIndex];\n        if (othIndex && iteratee) {\n          array = arrayMap(array, baseUnary(iteratee));\n        }\n        maxLength = nativeMin(array.length, maxLength);\n        caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))\n          ? new SetCache(othIndex && array)\n          : undefined;\n      }\n      array = arrays[0];\n\n      var index = -1,\n          seen = caches[0];\n\n      outer:\n      while (++index < length && result.length < maxLength) {\n        var value = array[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        value = (comparator || value !== 0) ? value : 0;\n        if (!(seen\n              ? cacheHas(seen, computed)\n              : includes(result, computed, comparator)\n            )) {\n          othIndex = othLength;\n          while (--othIndex) {\n            var cache = caches[othIndex];\n            if (!(cache\n                  ? cacheHas(cache, computed)\n                  : includes(arrays[othIndex], computed, comparator))\n                ) {\n              continue outer;\n            }\n          }\n          if (seen) {\n            seen.push(computed);\n          }\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.invert` and `_.invertBy` which inverts\n     * `object` with values transformed by `iteratee` and set by `setter`.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} setter The function to set `accumulator` values.\n     * @param {Function} iteratee The iteratee to transform values.\n     * @param {Object} accumulator The initial inverted object.\n     * @returns {Function} Returns `accumulator`.\n     */\n    function baseInverter(object, setter, iteratee, accumulator) {\n      baseForOwn(object, function(value, key, object) {\n        setter(accumulator, iteratee(value), key, object);\n      });\n      return accumulator;\n    }\n\n    /**\n     * The base implementation of `_.invoke` without support for individual\n     * method arguments.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the method to invoke.\n     * @param {Array} args The arguments to invoke the method with.\n     * @returns {*} Returns the result of the invoked method.\n     */\n    function baseInvoke(object, path, args) {\n      path = castPath(path, object);\n      object = parent(object, path);\n      var func = object == null ? object : object[toKey(last(path))];\n      return func == null ? undefined : apply(func, object, args);\n    }\n\n    /**\n     * The base implementation of `_.isArguments`.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n     */\n    function baseIsArguments(value) {\n      return isObjectLike(value) && baseGetTag(value) == argsTag;\n    }\n\n    /**\n     * The base implementation of `_.isArrayBuffer` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.\n     */\n    function baseIsArrayBuffer(value) {\n      return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;\n    }\n\n    /**\n     * The base implementation of `_.isDate` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a date object, else `false`.\n     */\n    function baseIsDate(value) {\n      return isObjectLike(value) && baseGetTag(value) == dateTag;\n    }\n\n    /**\n     * The base implementation of `_.isEqual` which supports partial comparisons\n     * and tracks traversed objects.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @param {boolean} bitmask The bitmask flags.\n     *  1 - Unordered comparison\n     *  2 - Partial comparison\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     */\n    function baseIsEqual(value, other, bitmask, customizer, stack) {\n      if (value === other) {\n        return true;\n      }\n      if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n        return value !== value && other !== other;\n      }\n      return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n    }\n\n    /**\n     * A specialized version of `baseIsEqual` for arrays and objects which performs\n     * deep comparisons and tracks traversed objects enabling objects with circular\n     * references to be compared.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n     */\n    function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n      var objIsArr = isArray(object),\n          othIsArr = isArray(other),\n          objTag = objIsArr ? arrayTag : getTag(object),\n          othTag = othIsArr ? arrayTag : getTag(other);\n\n      objTag = objTag == argsTag ? objectTag : objTag;\n      othTag = othTag == argsTag ? objectTag : othTag;\n\n      var objIsObj = objTag == objectTag,\n          othIsObj = othTag == objectTag,\n          isSameTag = objTag == othTag;\n\n      if (isSameTag && isBuffer(object)) {\n        if (!isBuffer(other)) {\n          return false;\n        }\n        objIsArr = true;\n        objIsObj = false;\n      }\n      if (isSameTag && !objIsObj) {\n        stack || (stack = new Stack);\n        return (objIsArr || isTypedArray(object))\n          ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n          : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n      }\n      if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n        var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n            othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n        if (objIsWrapped || othIsWrapped) {\n          var objUnwrapped = objIsWrapped ? object.value() : object,\n              othUnwrapped = othIsWrapped ? other.value() : other;\n\n          stack || (stack = new Stack);\n          return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n        }\n      }\n      if (!isSameTag) {\n        return false;\n      }\n      stack || (stack = new Stack);\n      return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n    }\n\n    /**\n     * The base implementation of `_.isMap` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n     */\n    function baseIsMap(value) {\n      return isObjectLike(value) && getTag(value) == mapTag;\n    }\n\n    /**\n     * The base implementation of `_.isMatch` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property values to match.\n     * @param {Array} matchData The property names, values, and compare flags to match.\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n     */\n    function baseIsMatch(object, source, matchData, customizer) {\n      var index = matchData.length,\n          length = index,\n          noCustomizer = !customizer;\n\n      if (object == null) {\n        return !length;\n      }\n      object = Object(object);\n      while (index--) {\n        var data = matchData[index];\n        if ((noCustomizer && data[2])\n              ? data[1] !== object[data[0]]\n              : !(data[0] in object)\n            ) {\n          return false;\n        }\n      }\n      while (++index < length) {\n        data = matchData[index];\n        var key = data[0],\n            objValue = object[key],\n            srcValue = data[1];\n\n        if (noCustomizer && data[2]) {\n          if (objValue === undefined && !(key in object)) {\n            return false;\n          }\n        } else {\n          var stack = new Stack;\n          if (customizer) {\n            var result = customizer(objValue, srcValue, key, object, source, stack);\n          }\n          if (!(result === undefined\n                ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)\n                : result\n              )) {\n            return false;\n          }\n        }\n      }\n      return true;\n    }\n\n    /**\n     * The base implementation of `_.isNative` without bad shim checks.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a native function,\n     *  else `false`.\n     */\n    function baseIsNative(value) {\n      if (!isObject(value) || isMasked(value)) {\n        return false;\n      }\n      var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n      return pattern.test(toSource(value));\n    }\n\n    /**\n     * The base implementation of `_.isRegExp` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.\n     */\n    function baseIsRegExp(value) {\n      return isObjectLike(value) && baseGetTag(value) == regexpTag;\n    }\n\n    /**\n     * The base implementation of `_.isSet` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n     */\n    function baseIsSet(value) {\n      return isObjectLike(value) && getTag(value) == setTag;\n    }\n\n    /**\n     * The base implementation of `_.isTypedArray` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n     */\n    function baseIsTypedArray(value) {\n      return isObjectLike(value) &&\n        isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n    }\n\n    /**\n     * The base implementation of `_.iteratee`.\n     *\n     * @private\n     * @param {*} [value=_.identity] The value to convert to an iteratee.\n     * @returns {Function} Returns the iteratee.\n     */\n    function baseIteratee(value) {\n      // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.\n      // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.\n      if (typeof value == 'function') {\n        return value;\n      }\n      if (value == null) {\n        return identity;\n      }\n      if (typeof value == 'object') {\n        return isArray(value)\n          ? baseMatchesProperty(value[0], value[1])\n          : baseMatches(value);\n      }\n      return property(value);\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     */\n    function 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 `_.keysIn` 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     */\n    function baseKeysIn(object) {\n      if (!isObject(object)) {\n        return nativeKeysIn(object);\n      }\n      var isProto = isPrototype(object),\n          result = [];\n\n      for (var key in object) {\n        if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.lt` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is less than `other`,\n     *  else `false`.\n     */\n    function baseLt(value, other) {\n      return value < other;\n    }\n\n    /**\n     * The base implementation of `_.map` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array} Returns the new mapped array.\n     */\n    function baseMap(collection, iteratee) {\n      var index = -1,\n          result = isArrayLike(collection) ? Array(collection.length) : [];\n\n      baseEach(collection, function(value, key, collection) {\n        result[++index] = iteratee(value, key, collection);\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.matches` which doesn't clone `source`.\n     *\n     * @private\n     * @param {Object} source The object of property values to match.\n     * @returns {Function} Returns the new spec function.\n     */\n    function baseMatches(source) {\n      var matchData = getMatchData(source);\n      if (matchData.length == 1 && matchData[0][2]) {\n        return matchesStrictComparable(matchData[0][0], matchData[0][1]);\n      }\n      return function(object) {\n        return object === source || baseIsMatch(object, source, matchData);\n      };\n    }\n\n    /**\n     * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.\n     *\n     * @private\n     * @param {string} path The path of the property to get.\n     * @param {*} srcValue The value to match.\n     * @returns {Function} Returns the new spec function.\n     */\n    function baseMatchesProperty(path, srcValue) {\n      if (isKey(path) && isStrictComparable(srcValue)) {\n        return matchesStrictComparable(toKey(path), srcValue);\n      }\n      return function(object) {\n        var objValue = get(object, path);\n        return (objValue === undefined && objValue === srcValue)\n          ? hasIn(object, path)\n          : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);\n      };\n    }\n\n    /**\n     * The base implementation of `_.merge` without support for multiple sources.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @param {number} srcIndex The index of `source`.\n     * @param {Function} [customizer] The function to customize merged values.\n     * @param {Object} [stack] Tracks traversed source values and their merged\n     *  counterparts.\n     */\n    function baseMerge(object, source, srcIndex, customizer, stack) {\n      if (object === source) {\n        return;\n      }\n      baseFor(source, function(srcValue, key) {\n        if (isObject(srcValue)) {\n          stack || (stack = new Stack);\n          baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n        }\n        else {\n          var newValue = customizer\n            ? customizer(object[key], srcValue, (key + ''), object, source, stack)\n            : undefined;\n\n          if (newValue === undefined) {\n            newValue = srcValue;\n          }\n          assignMergeValue(object, key, newValue);\n        }\n      }, keysIn);\n    }\n\n    /**\n     * A specialized version of `baseMerge` for arrays and objects which performs\n     * deep merges and tracks traversed objects enabling objects with circular\n     * references to be merged.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @param {string} key The key of the value to merge.\n     * @param {number} srcIndex The index of `source`.\n     * @param {Function} mergeFunc The function to merge values.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @param {Object} [stack] Tracks traversed source values and their merged\n     *  counterparts.\n     */\n    function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n      var objValue = object[key],\n          srcValue = source[key],\n          stacked = stack.get(srcValue);\n\n      if (stacked) {\n        assignMergeValue(object, key, stacked);\n        return;\n      }\n      var newValue = customizer\n        ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n        : undefined;\n\n      var isCommon = newValue === undefined;\n\n      if (isCommon) {\n        var isArr = isArray(srcValue),\n            isBuff = !isArr && isBuffer(srcValue),\n            isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n\n        newValue = srcValue;\n        if (isArr || isBuff || isTyped) {\n          if (isArray(objValue)) {\n            newValue = objValue;\n          }\n          else if (isArrayLikeObject(objValue)) {\n            newValue = copyArray(objValue);\n          }\n          else if (isBuff) {\n            isCommon = false;\n            newValue = cloneBuffer(srcValue, true);\n          }\n          else if (isTyped) {\n            isCommon = false;\n            newValue = cloneTypedArray(srcValue, true);\n          }\n          else {\n            newValue = [];\n          }\n        }\n        else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n          newValue = objValue;\n          if (isArguments(objValue)) {\n            newValue = toPlainObject(objValue);\n          }\n          else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {\n            newValue = initCloneObject(srcValue);\n          }\n        }\n        else {\n          isCommon = false;\n        }\n      }\n      if (isCommon) {\n        // Recursively merge objects and arrays (susceptible to call stack limits).\n        stack.set(srcValue, newValue);\n        mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n        stack['delete'](srcValue);\n      }\n      assignMergeValue(object, key, newValue);\n    }\n\n    /**\n     * The base implementation of `_.nth` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {Array} array The array to query.\n     * @param {number} n The index of the element to return.\n     * @returns {*} Returns the nth element of `array`.\n     */\n    function baseNth(array, n) {\n      var length = array.length;\n      if (!length) {\n        return;\n      }\n      n += n < 0 ? length : 0;\n      return isIndex(n, length) ? array[n] : undefined;\n    }\n\n    /**\n     * The base implementation of `_.orderBy` without param guards.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.\n     * @param {string[]} orders The sort orders of `iteratees`.\n     * @returns {Array} Returns the new sorted array.\n     */\n    function baseOrderBy(collection, iteratees, orders) {\n      var index = -1;\n      iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(getIteratee()));\n\n      var result = baseMap(collection, function(value, key, collection) {\n        var criteria = arrayMap(iteratees, function(iteratee) {\n          return iteratee(value);\n        });\n        return { 'criteria': criteria, 'index': ++index, 'value': value };\n      });\n\n      return baseSortBy(result, function(object, other) {\n        return compareMultiple(object, other, orders);\n      });\n    }\n\n    /**\n     * The base implementation of `_.pick` without support for individual\n     * property identifiers.\n     *\n     * @private\n     * @param {Object} object The source object.\n     * @param {string[]} paths The property paths to pick.\n     * @returns {Object} Returns the new object.\n     */\n    function basePick(object, paths) {\n      return basePickBy(object, paths, function(value, path) {\n        return hasIn(object, path);\n      });\n    }\n\n    /**\n     * The base implementation of  `_.pickBy` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The source object.\n     * @param {string[]} paths The property paths to pick.\n     * @param {Function} predicate The function invoked per property.\n     * @returns {Object} Returns the new object.\n     */\n    function basePickBy(object, paths, predicate) {\n      var index = -1,\n          length = paths.length,\n          result = {};\n\n      while (++index < length) {\n        var path = paths[index],\n            value = baseGet(object, path);\n\n        if (predicate(value, path)) {\n          baseSet(result, castPath(path, object), value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * A specialized version of `baseProperty` which supports deep paths.\n     *\n     * @private\n     * @param {Array|string} path The path of the property to get.\n     * @returns {Function} Returns the new accessor function.\n     */\n    function basePropertyDeep(path) {\n      return function(object) {\n        return baseGet(object, path);\n      };\n    }\n\n    /**\n     * The base implementation of `_.pullAllBy` without support for iteratee\n     * shorthands.\n     *\n     * @private\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns `array`.\n     */\n    function basePullAll(array, values, iteratee, comparator) {\n      var indexOf = comparator ? baseIndexOfWith : baseIndexOf,\n          index = -1,\n          length = values.length,\n          seen = array;\n\n      if (array === values) {\n        values = copyArray(values);\n      }\n      if (iteratee) {\n        seen = arrayMap(array, baseUnary(iteratee));\n      }\n      while (++index < length) {\n        var fromIndex = 0,\n            value = values[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {\n          if (seen !== array) {\n            splice.call(seen, fromIndex, 1);\n          }\n          splice.call(array, fromIndex, 1);\n        }\n      }\n      return array;\n    }\n\n    /**\n     * The base implementation of `_.pullAt` without support for individual\n     * indexes or capturing the removed elements.\n     *\n     * @private\n     * @param {Array} array The array to modify.\n     * @param {number[]} indexes The indexes of elements to remove.\n     * @returns {Array} Returns `array`.\n     */\n    function basePullAt(array, indexes) {\n      var length = array ? indexes.length : 0,\n          lastIndex = length - 1;\n\n      while (length--) {\n        var index = indexes[length];\n        if (length == lastIndex || index !== previous) {\n          var previous = index;\n          if (isIndex(index)) {\n            splice.call(array, index, 1);\n          } else {\n            baseUnset(array, index);\n          }\n        }\n      }\n      return array;\n    }\n\n    /**\n     * The base implementation of `_.random` without support for returning\n     * floating-point numbers.\n     *\n     * @private\n     * @param {number} lower The lower bound.\n     * @param {number} upper The upper bound.\n     * @returns {number} Returns the random number.\n     */\n    function baseRandom(lower, upper) {\n      return lower + nativeFloor(nativeRandom() * (upper - lower + 1));\n    }\n\n    /**\n     * The base implementation of `_.range` and `_.rangeRight` which doesn't\n     * coerce arguments.\n     *\n     * @private\n     * @param {number} start The start of the range.\n     * @param {number} end The end of the range.\n     * @param {number} step The value to increment or decrement by.\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Array} Returns the range of numbers.\n     */\n    function baseRange(start, end, step, fromRight) {\n      var index = -1,\n          length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),\n          result = Array(length);\n\n      while (length--) {\n        result[fromRight ? length : ++index] = start;\n        start += step;\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.repeat` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {string} string The string to repeat.\n     * @param {number} n The number of times to repeat the string.\n     * @returns {string} Returns the repeated string.\n     */\n    function baseRepeat(string, n) {\n      var result = '';\n      if (!string || n < 1 || n > MAX_SAFE_INTEGER) {\n        return result;\n      }\n      // Leverage the exponentiation by squaring algorithm for a faster repeat.\n      // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.\n      do {\n        if (n % 2) {\n          result += string;\n        }\n        n = nativeFloor(n / 2);\n        if (n) {\n          string += string;\n        }\n      } while (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     */\n    function baseRest(func, start) {\n      return setToString(overRest(func, start, identity), func + '');\n    }\n\n    /**\n     * The base implementation of `_.sample`.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to sample.\n     * @returns {*} Returns the random element.\n     */\n    function baseSample(collection) {\n      return arraySample(values(collection));\n    }\n\n    /**\n     * The base implementation of `_.sampleSize` without param guards.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to sample.\n     * @param {number} n The number of elements to sample.\n     * @returns {Array} Returns the random elements.\n     */\n    function baseSampleSize(collection, n) {\n      var array = values(collection);\n      return shuffleSelf(array, baseClamp(n, 0, array.length));\n    }\n\n    /**\n     * The base implementation of `_.set`.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {*} value The value to set.\n     * @param {Function} [customizer] The function to customize path creation.\n     * @returns {Object} Returns `object`.\n     */\n    function baseSet(object, path, value, customizer) {\n      if (!isObject(object)) {\n        return object;\n      }\n      path = castPath(path, object);\n\n      var index = -1,\n          length = path.length,\n          lastIndex = length - 1,\n          nested = object;\n\n      while (nested != null && ++index < length) {\n        var key = toKey(path[index]),\n            newValue = value;\n\n        if (index != lastIndex) {\n          var objValue = nested[key];\n          newValue = customizer ? customizer(objValue, key, nested) : undefined;\n          if (newValue === undefined) {\n            newValue = isObject(objValue)\n              ? objValue\n              : (isIndex(path[index + 1]) ? [] : {});\n          }\n        }\n        assignValue(nested, key, newValue);\n        nested = nested[key];\n      }\n      return object;\n    }\n\n    /**\n     * The base implementation of `setData` without support for hot loop shorting.\n     *\n     * @private\n     * @param {Function} func The function to associate metadata with.\n     * @param {*} data The metadata.\n     * @returns {Function} Returns `func`.\n     */\n    var baseSetData = !metaMap ? identity : function(func, data) {\n      metaMap.set(func, data);\n      return func;\n    };\n\n    /**\n     * The base implementation of `setToString` without support for hot loop shorting.\n     *\n     * @private\n     * @param {Function} func The function to modify.\n     * @param {Function} string The `toString` result.\n     * @returns {Function} Returns `func`.\n     */\n    var baseSetToString = !defineProperty ? identity : function(func, string) {\n      return defineProperty(func, 'toString', {\n        'configurable': true,\n        'enumerable': false,\n        'value': constant(string),\n        'writable': true\n      });\n    };\n\n    /**\n     * The base implementation of `_.shuffle`.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to shuffle.\n     * @returns {Array} Returns the new shuffled array.\n     */\n    function baseShuffle(collection) {\n      return shuffleSelf(values(collection));\n    }\n\n    /**\n     * The base implementation of `_.slice` without an iteratee call guard.\n     *\n     * @private\n     * @param {Array} array The array to slice.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns the slice of `array`.\n     */\n    function baseSlice(array, start, end) {\n      var index = -1,\n          length = array.length;\n\n      if (start < 0) {\n        start = -start > length ? 0 : (length + start);\n      }\n      end = end > length ? length : end;\n      if (end < 0) {\n        end += length;\n      }\n      length = start > end ? 0 : ((end - start) >>> 0);\n      start >>>= 0;\n\n      var result = Array(length);\n      while (++index < length) {\n        result[index] = array[index + start];\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.some` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {boolean} Returns `true` if any element passes the predicate check,\n     *  else `false`.\n     */\n    function baseSome(collection, predicate) {\n      var result;\n\n      baseEach(collection, function(value, index, collection) {\n        result = predicate(value, index, collection);\n        return !result;\n      });\n      return !!result;\n    }\n\n    /**\n     * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which\n     * performs a binary search of `array` to determine the index at which `value`\n     * should be inserted into `array` in order to maintain its sort order.\n     *\n     * @private\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {boolean} [retHighest] Specify returning the highest qualified index.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     */\n    function baseSortedIndex(array, value, retHighest) {\n      var low = 0,\n          high = array == null ? low : array.length;\n\n      if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {\n        while (low < high) {\n          var mid = (low + high) >>> 1,\n              computed = array[mid];\n\n          if (computed !== null && !isSymbol(computed) &&\n              (retHighest ? (computed <= value) : (computed < value))) {\n            low = mid + 1;\n          } else {\n            high = mid;\n          }\n        }\n        return high;\n      }\n      return baseSortedIndexBy(array, value, identity, retHighest);\n    }\n\n    /**\n     * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`\n     * which invokes `iteratee` for `value` and each element of `array` to compute\n     * their sort ranking. The iteratee is invoked with one argument; (value).\n     *\n     * @private\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {Function} iteratee The iteratee invoked per element.\n     * @param {boolean} [retHighest] Specify returning the highest qualified index.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     */\n    function baseSortedIndexBy(array, value, iteratee, retHighest) {\n      value = iteratee(value);\n\n      var low = 0,\n          high = array == null ? 0 : array.length,\n          valIsNaN = value !== value,\n          valIsNull = value === null,\n          valIsSymbol = isSymbol(value),\n          valIsUndefined = value === undefined;\n\n      while (low < high) {\n        var mid = nativeFloor((low + high) / 2),\n            computed = iteratee(array[mid]),\n            othIsDefined = computed !== undefined,\n            othIsNull = computed === null,\n            othIsReflexive = computed === computed,\n            othIsSymbol = isSymbol(computed);\n\n        if (valIsNaN) {\n          var setLow = retHighest || othIsReflexive;\n        } else if (valIsUndefined) {\n          setLow = othIsReflexive && (retHighest || othIsDefined);\n        } else if (valIsNull) {\n          setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);\n        } else if (valIsSymbol) {\n          setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);\n        } else if (othIsNull || othIsSymbol) {\n          setLow = false;\n        } else {\n          setLow = retHighest ? (computed <= value) : (computed < value);\n        }\n        if (setLow) {\n          low = mid + 1;\n        } else {\n          high = mid;\n        }\n      }\n      return nativeMin(high, MAX_ARRAY_INDEX);\n    }\n\n    /**\n     * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without\n     * support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     */\n    function baseSortedUniq(array, iteratee) {\n      var index = -1,\n          length = array.length,\n          resIndex = 0,\n          result = [];\n\n      while (++index < length) {\n        var value = array[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        if (!index || !eq(computed, seen)) {\n          var seen = computed;\n          result[resIndex++] = value === 0 ? 0 : value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.toNumber` which doesn't ensure correct\n     * conversions of binary, hexadecimal, or octal string values.\n     *\n     * @private\n     * @param {*} value The value to process.\n     * @returns {number} Returns the number.\n     */\n    function baseToNumber(value) {\n      if (typeof value == 'number') {\n        return value;\n      }\n      if (isSymbol(value)) {\n        return NAN;\n      }\n      return +value;\n    }\n\n    /**\n     * The base implementation of `_.toString` which doesn't convert nullish\n     * values to empty strings.\n     *\n     * @private\n     * @param {*} value The value to process.\n     * @returns {string} Returns the string.\n     */\n    function baseToString(value) {\n      // Exit early for strings to avoid a performance hit in some environments.\n      if (typeof value == 'string') {\n        return value;\n      }\n      if (isArray(value)) {\n        // Recursively convert values (susceptible to call stack limits).\n        return arrayMap(value, baseToString) + '';\n      }\n      if (isSymbol(value)) {\n        return symbolToString ? symbolToString.call(value) : '';\n      }\n      var result = (value + '');\n      return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n    }\n\n    /**\n     * The base implementation of `_.uniqBy` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     */\n    function baseUniq(array, iteratee, comparator) {\n      var index = -1,\n          includes = arrayIncludes,\n          length = array.length,\n          isCommon = true,\n          result = [],\n          seen = result;\n\n      if (comparator) {\n        isCommon = false;\n        includes = arrayIncludesWith;\n      }\n      else if (length >= LARGE_ARRAY_SIZE) {\n        var set = iteratee ? null : createSet(array);\n        if (set) {\n          return setToArray(set);\n        }\n        isCommon = false;\n        includes = cacheHas;\n        seen = new SetCache;\n      }\n      else {\n        seen = iteratee ? [] : result;\n      }\n      outer:\n      while (++index < length) {\n        var value = array[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        value = (comparator || value !== 0) ? value : 0;\n        if (isCommon && computed === computed) {\n          var seenIndex = seen.length;\n          while (seenIndex--) {\n            if (seen[seenIndex] === computed) {\n              continue outer;\n            }\n          }\n          if (iteratee) {\n            seen.push(computed);\n          }\n          result.push(value);\n        }\n        else if (!includes(seen, computed, comparator)) {\n          if (seen !== result) {\n            seen.push(computed);\n          }\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.unset`.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The property path to unset.\n     * @returns {boolean} Returns `true` if the property is deleted, else `false`.\n     */\n    function baseUnset(object, path) {\n      path = castPath(path, object);\n      object = parent(object, path);\n      return object == null || delete object[toKey(last(path))];\n    }\n\n    /**\n     * The base implementation of `_.update`.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to update.\n     * @param {Function} updater The function to produce the updated value.\n     * @param {Function} [customizer] The function to customize path creation.\n     * @returns {Object} Returns `object`.\n     */\n    function baseUpdate(object, path, updater, customizer) {\n      return baseSet(object, path, updater(baseGet(object, path)), customizer);\n    }\n\n    /**\n     * The base implementation of methods like `_.dropWhile` and `_.takeWhile`\n     * without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to query.\n     * @param {Function} predicate The function invoked per iteration.\n     * @param {boolean} [isDrop] Specify dropping elements instead of taking them.\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Array} Returns the slice of `array`.\n     */\n    function baseWhile(array, predicate, isDrop, fromRight) {\n      var length = array.length,\n          index = fromRight ? length : -1;\n\n      while ((fromRight ? index-- : ++index < length) &&\n        predicate(array[index], index, array)) {}\n\n      return isDrop\n        ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length))\n        : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index));\n    }\n\n    /**\n     * The base implementation of `wrapperValue` which returns the result of\n     * performing a sequence of actions on the unwrapped `value`, where each\n     * successive action is supplied the return value of the previous.\n     *\n     * @private\n     * @param {*} value The unwrapped value.\n     * @param {Array} actions Actions to perform to resolve the unwrapped value.\n     * @returns {*} Returns the resolved value.\n     */\n    function baseWrapperValue(value, actions) {\n      var result = value;\n      if (result instanceof LazyWrapper) {\n        result = result.value();\n      }\n      return arrayReduce(actions, function(result, action) {\n        return action.func.apply(action.thisArg, arrayPush([result], action.args));\n      }, result);\n    }\n\n    /**\n     * The base implementation of methods like `_.xor`, without support for\n     * iteratee shorthands, that accepts an array of arrays to inspect.\n     *\n     * @private\n     * @param {Array} arrays The arrays to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of values.\n     */\n    function baseXor(arrays, iteratee, comparator) {\n      var length = arrays.length;\n      if (length < 2) {\n        return length ? baseUniq(arrays[0]) : [];\n      }\n      var index = -1,\n          result = Array(length);\n\n      while (++index < length) {\n        var array = arrays[index],\n            othIndex = -1;\n\n        while (++othIndex < length) {\n          if (othIndex != index) {\n            result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);\n          }\n        }\n      }\n      return baseUniq(baseFlatten(result, 1), iteratee, comparator);\n    }\n\n    /**\n     * This base implementation of `_.zipObject` which assigns values using `assignFunc`.\n     *\n     * @private\n     * @param {Array} props The property identifiers.\n     * @param {Array} values The property values.\n     * @param {Function} assignFunc The function to assign values.\n     * @returns {Object} Returns the new object.\n     */\n    function baseZipObject(props, values, assignFunc) {\n      var index = -1,\n          length = props.length,\n          valsLength = values.length,\n          result = {};\n\n      while (++index < length) {\n        var value = index < valsLength ? values[index] : undefined;\n        assignFunc(result, props[index], value);\n      }\n      return result;\n    }\n\n    /**\n     * Casts `value` to an empty array if it's not an array like object.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @returns {Array|Object} Returns the cast array-like object.\n     */\n    function castArrayLikeObject(value) {\n      return isArrayLikeObject(value) ? value : [];\n    }\n\n    /**\n     * Casts `value` to `identity` if it's not a function.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @returns {Function} Returns cast function.\n     */\n    function castFunction(value) {\n      return typeof value == 'function' ? value : identity;\n    }\n\n    /**\n     * Casts `value` to a path array if it's not one.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @param {Object} [object] The object to query keys on.\n     * @returns {Array} Returns the cast property path array.\n     */\n    function castPath(value, object) {\n      if (isArray(value)) {\n        return value;\n      }\n      return isKey(value, object) ? [value] : stringToPath(toString(value));\n    }\n\n    /**\n     * A `baseRest` alias which can be replaced with `identity` by module\n     * replacement plugins.\n     *\n     * @private\n     * @type {Function}\n     * @param {Function} func The function to apply a rest parameter to.\n     * @returns {Function} Returns the new function.\n     */\n    var castRest = baseRest;\n\n    /**\n     * Casts `array` to a slice if it's needed.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {number} start The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns the cast slice.\n     */\n    function castSlice(array, start, end) {\n      var length = array.length;\n      end = end === undefined ? length : end;\n      return (!start && end >= length) ? array : baseSlice(array, start, end);\n    }\n\n    /**\n     * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout).\n     *\n     * @private\n     * @param {number|Object} id The timer id or timeout object of the timer to clear.\n     */\n    var clearTimeout = ctxClearTimeout || function(id) {\n      return root.clearTimeout(id);\n    };\n\n    /**\n     * Creates a clone of  `buffer`.\n     *\n     * @private\n     * @param {Buffer} buffer The buffer to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Buffer} Returns the cloned buffer.\n     */\n    function cloneBuffer(buffer, isDeep) {\n      if (isDeep) {\n        return buffer.slice();\n      }\n      var length = buffer.length,\n          result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n      buffer.copy(result);\n      return result;\n    }\n\n    /**\n     * Creates a clone of `arrayBuffer`.\n     *\n     * @private\n     * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n     * @returns {ArrayBuffer} Returns the cloned array buffer.\n     */\n    function cloneArrayBuffer(arrayBuffer) {\n      var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n      new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n      return result;\n    }\n\n    /**\n     * Creates a clone of `dataView`.\n     *\n     * @private\n     * @param {Object} dataView The data view to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the cloned data view.\n     */\n    function cloneDataView(dataView, isDeep) {\n      var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n      return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n    }\n\n    /**\n     * Creates a clone of `map`.\n     *\n     * @private\n     * @param {Object} map The map to clone.\n     * @param {Function} cloneFunc The function to clone values.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the cloned map.\n     */\n    function cloneMap(map, isDeep, cloneFunc) {\n      var array = isDeep ? cloneFunc(mapToArray(map), CLONE_DEEP_FLAG) : mapToArray(map);\n      return arrayReduce(array, addMapEntry, new map.constructor);\n    }\n\n    /**\n     * Creates a clone of `regexp`.\n     *\n     * @private\n     * @param {Object} regexp The regexp to clone.\n     * @returns {Object} Returns the cloned regexp.\n     */\n    function cloneRegExp(regexp) {\n      var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n      result.lastIndex = regexp.lastIndex;\n      return result;\n    }\n\n    /**\n     * Creates a clone of `set`.\n     *\n     * @private\n     * @param {Object} set The set to clone.\n     * @param {Function} cloneFunc The function to clone values.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the cloned set.\n     */\n    function cloneSet(set, isDeep, cloneFunc) {\n      var array = isDeep ? cloneFunc(setToArray(set), CLONE_DEEP_FLAG) : setToArray(set);\n      return arrayReduce(array, addSetEntry, new set.constructor);\n    }\n\n    /**\n     * Creates a clone of the `symbol` object.\n     *\n     * @private\n     * @param {Object} symbol The symbol object to clone.\n     * @returns {Object} Returns the cloned symbol object.\n     */\n    function cloneSymbol(symbol) {\n      return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};\n    }\n\n    /**\n     * Creates a clone of `typedArray`.\n     *\n     * @private\n     * @param {Object} typedArray The typed array to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the cloned typed array.\n     */\n    function cloneTypedArray(typedArray, isDeep) {\n      var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n      return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n    }\n\n    /**\n     * Compares values to sort them in ascending order.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {number} Returns the sort order indicator for `value`.\n     */\n    function compareAscending(value, other) {\n      if (value !== other) {\n        var valIsDefined = value !== undefined,\n            valIsNull = value === null,\n            valIsReflexive = value === value,\n            valIsSymbol = isSymbol(value);\n\n        var othIsDefined = other !== undefined,\n            othIsNull = other === null,\n            othIsReflexive = other === other,\n            othIsSymbol = isSymbol(other);\n\n        if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||\n            (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||\n            (valIsNull && othIsDefined && othIsReflexive) ||\n            (!valIsDefined && othIsReflexive) ||\n            !valIsReflexive) {\n          return 1;\n        }\n        if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||\n            (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||\n            (othIsNull && valIsDefined && valIsReflexive) ||\n            (!othIsDefined && valIsReflexive) ||\n            !othIsReflexive) {\n          return -1;\n        }\n      }\n      return 0;\n    }\n\n    /**\n     * Used by `_.orderBy` to compare multiple properties of a value to another\n     * and stable sort them.\n     *\n     * If `orders` is unspecified, all values are sorted in ascending order. Otherwise,\n     * specify an order of \"desc\" for descending or \"asc\" for ascending sort order\n     * of corresponding values.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {boolean[]|string[]} orders The order to sort by for each property.\n     * @returns {number} Returns the sort order indicator for `object`.\n     */\n    function compareMultiple(object, other, orders) {\n      var index = -1,\n          objCriteria = object.criteria,\n          othCriteria = other.criteria,\n          length = objCriteria.length,\n          ordersLength = orders.length;\n\n      while (++index < length) {\n        var result = compareAscending(objCriteria[index], othCriteria[index]);\n        if (result) {\n          if (index >= ordersLength) {\n            return result;\n          }\n          var order = orders[index];\n          return result * (order == 'desc' ? -1 : 1);\n        }\n      }\n      // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications\n      // that causes it, under certain circumstances, to provide the same value for\n      // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247\n      // for more details.\n      //\n      // This also ensures a stable sort in V8 and other engines.\n      // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.\n      return object.index - other.index;\n    }\n\n    /**\n     * Creates an array that is the composition of partially applied arguments,\n     * placeholders, and provided arguments into a single array of arguments.\n     *\n     * @private\n     * @param {Array} args The provided arguments.\n     * @param {Array} partials The arguments to prepend to those provided.\n     * @param {Array} holders The `partials` placeholder indexes.\n     * @params {boolean} [isCurried] Specify composing for a curried function.\n     * @returns {Array} Returns the new array of composed arguments.\n     */\n    function composeArgs(args, partials, holders, isCurried) {\n      var argsIndex = -1,\n          argsLength = args.length,\n          holdersLength = holders.length,\n          leftIndex = -1,\n          leftLength = partials.length,\n          rangeLength = nativeMax(argsLength - holdersLength, 0),\n          result = Array(leftLength + rangeLength),\n          isUncurried = !isCurried;\n\n      while (++leftIndex < leftLength) {\n        result[leftIndex] = partials[leftIndex];\n      }\n      while (++argsIndex < holdersLength) {\n        if (isUncurried || argsIndex < argsLength) {\n          result[holders[argsIndex]] = args[argsIndex];\n        }\n      }\n      while (rangeLength--) {\n        result[leftIndex++] = args[argsIndex++];\n      }\n      return result;\n    }\n\n    /**\n     * This function is like `composeArgs` except that the arguments composition\n     * is tailored for `_.partialRight`.\n     *\n     * @private\n     * @param {Array} args The provided arguments.\n     * @param {Array} partials The arguments to append to those provided.\n     * @param {Array} holders The `partials` placeholder indexes.\n     * @params {boolean} [isCurried] Specify composing for a curried function.\n     * @returns {Array} Returns the new array of composed arguments.\n     */\n    function composeArgsRight(args, partials, holders, isCurried) {\n      var argsIndex = -1,\n          argsLength = args.length,\n          holdersIndex = -1,\n          holdersLength = holders.length,\n          rightIndex = -1,\n          rightLength = partials.length,\n          rangeLength = nativeMax(argsLength - holdersLength, 0),\n          result = Array(rangeLength + rightLength),\n          isUncurried = !isCurried;\n\n      while (++argsIndex < rangeLength) {\n        result[argsIndex] = args[argsIndex];\n      }\n      var offset = argsIndex;\n      while (++rightIndex < rightLength) {\n        result[offset + rightIndex] = partials[rightIndex];\n      }\n      while (++holdersIndex < holdersLength) {\n        if (isUncurried || argsIndex < argsLength) {\n          result[offset + holders[holdersIndex]] = args[argsIndex++];\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Copies the values of `source` to `array`.\n     *\n     * @private\n     * @param {Array} source The array to copy values from.\n     * @param {Array} [array=[]] The array to copy values to.\n     * @returns {Array} Returns `array`.\n     */\n    function copyArray(source, array) {\n      var index = -1,\n          length = source.length;\n\n      array || (array = Array(length));\n      while (++index < length) {\n        array[index] = source[index];\n      }\n      return array;\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     */\n    function copyObject(source, props, object, customizer) {\n      var isNew = !object;\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        if (newValue === undefined) {\n          newValue = source[key];\n        }\n        if (isNew) {\n          baseAssignValue(object, key, newValue);\n        } else {\n          assignValue(object, key, newValue);\n        }\n      }\n      return object;\n    }\n\n    /**\n     * Copies own symbols of `source` to `object`.\n     *\n     * @private\n     * @param {Object} source The object to copy symbols from.\n     * @param {Object} [object={}] The object to copy symbols to.\n     * @returns {Object} Returns `object`.\n     */\n    function copySymbols(source, object) {\n      return copyObject(source, getSymbols(source), object);\n    }\n\n    /**\n     * Copies own and inherited symbols of `source` to `object`.\n     *\n     * @private\n     * @param {Object} source The object to copy symbols from.\n     * @param {Object} [object={}] The object to copy symbols to.\n     * @returns {Object} Returns `object`.\n     */\n    function copySymbolsIn(source, object) {\n      return copyObject(source, getSymbolsIn(source), object);\n    }\n\n    /**\n     * Creates a function like `_.groupBy`.\n     *\n     * @private\n     * @param {Function} setter The function to set accumulator values.\n     * @param {Function} [initializer] The accumulator object initializer.\n     * @returns {Function} Returns the new aggregator function.\n     */\n    function createAggregator(setter, initializer) {\n      return function(collection, iteratee) {\n        var func = isArray(collection) ? arrayAggregator : baseAggregator,\n            accumulator = initializer ? initializer() : {};\n\n        return func(collection, setter, getIteratee(iteratee, 2), accumulator);\n      };\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     */\n    function 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     * Creates a `baseEach` or `baseEachRight` function.\n     *\n     * @private\n     * @param {Function} eachFunc The function to iterate over a collection.\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new base function.\n     */\n    function createBaseEach(eachFunc, fromRight) {\n      return function(collection, iteratee) {\n        if (collection == null) {\n          return collection;\n        }\n        if (!isArrayLike(collection)) {\n          return eachFunc(collection, iteratee);\n        }\n        var length = collection.length,\n            index = fromRight ? length : -1,\n            iterable = Object(collection);\n\n        while ((fromRight ? index-- : ++index < length)) {\n          if (iteratee(iterable[index], index, iterable) === false) {\n            break;\n          }\n        }\n        return collection;\n      };\n    }\n\n    /**\n     * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n     *\n     * @private\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new base function.\n     */\n    function createBaseFor(fromRight) {\n      return function(object, iteratee, keysFunc) {\n        var index = -1,\n            iterable = Object(object),\n            props = keysFunc(object),\n            length = props.length;\n\n        while (length--) {\n          var key = props[fromRight ? length : ++index];\n          if (iteratee(iterable[key], key, iterable) === false) {\n            break;\n          }\n        }\n        return object;\n      };\n    }\n\n    /**\n     * Creates a function that wraps `func` to invoke it with the optional `this`\n     * binding of `thisArg`.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createBind(func, bitmask, thisArg) {\n      var isBind = bitmask & WRAP_BIND_FLAG,\n          Ctor = createCtor(func);\n\n      function wrapper() {\n        var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n        return fn.apply(isBind ? thisArg : this, arguments);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a function like `_.lowerFirst`.\n     *\n     * @private\n     * @param {string} methodName The name of the `String` case method to use.\n     * @returns {Function} Returns the new case function.\n     */\n    function createCaseFirst(methodName) {\n      return function(string) {\n        string = toString(string);\n\n        var strSymbols = hasUnicode(string)\n          ? stringToArray(string)\n          : undefined;\n\n        var chr = strSymbols\n          ? strSymbols[0]\n          : string.charAt(0);\n\n        var trailing = strSymbols\n          ? castSlice(strSymbols, 1).join('')\n          : string.slice(1);\n\n        return chr[methodName]() + trailing;\n      };\n    }\n\n    /**\n     * Creates a function like `_.camelCase`.\n     *\n     * @private\n     * @param {Function} callback The function to combine each word.\n     * @returns {Function} Returns the new compounder function.\n     */\n    function createCompounder(callback) {\n      return function(string) {\n        return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');\n      };\n    }\n\n    /**\n     * Creates a function that produces an instance of `Ctor` regardless of\n     * whether it was invoked as part of a `new` expression or by `call` or `apply`.\n     *\n     * @private\n     * @param {Function} Ctor The constructor to wrap.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createCtor(Ctor) {\n      return function() {\n        // Use a `switch` statement to work with class constructors. See\n        // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist\n        // for more details.\n        var args = arguments;\n        switch (args.length) {\n          case 0: return new Ctor;\n          case 1: return new Ctor(args[0]);\n          case 2: return new Ctor(args[0], args[1]);\n          case 3: return new Ctor(args[0], args[1], args[2]);\n          case 4: return new Ctor(args[0], args[1], args[2], args[3]);\n          case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]);\n          case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);\n          case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);\n        }\n        var thisBinding = baseCreate(Ctor.prototype),\n            result = Ctor.apply(thisBinding, args);\n\n        // Mimic the constructor's `return` behavior.\n        // See https://es5.github.io/#x13.2.2 for more details.\n        return isObject(result) ? result : thisBinding;\n      };\n    }\n\n    /**\n     * Creates a function that wraps `func` to enable currying.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {number} arity The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createCurry(func, bitmask, arity) {\n      var Ctor = createCtor(func);\n\n      function wrapper() {\n        var length = arguments.length,\n            args = Array(length),\n            index = length,\n            placeholder = getHolder(wrapper);\n\n        while (index--) {\n          args[index] = arguments[index];\n        }\n        var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder)\n          ? []\n          : replaceHolders(args, placeholder);\n\n        length -= holders.length;\n        if (length < arity) {\n          return createRecurry(\n            func, bitmask, createHybrid, wrapper.placeholder, undefined,\n            args, holders, undefined, undefined, arity - length);\n        }\n        var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n        return apply(fn, this, args);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a `_.find` or `_.findLast` function.\n     *\n     * @private\n     * @param {Function} findIndexFunc The function to find the collection index.\n     * @returns {Function} Returns the new find function.\n     */\n    function createFind(findIndexFunc) {\n      return function(collection, predicate, fromIndex) {\n        var iterable = Object(collection);\n        if (!isArrayLike(collection)) {\n          var iteratee = getIteratee(predicate, 3);\n          collection = keys(collection);\n          predicate = function(key) { return iteratee(iterable[key], key, iterable); };\n        }\n        var index = findIndexFunc(collection, predicate, fromIndex);\n        return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;\n      };\n    }\n\n    /**\n     * Creates a `_.flow` or `_.flowRight` function.\n     *\n     * @private\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new flow function.\n     */\n    function createFlow(fromRight) {\n      return flatRest(function(funcs) {\n        var length = funcs.length,\n            index = length,\n            prereq = LodashWrapper.prototype.thru;\n\n        if (fromRight) {\n          funcs.reverse();\n        }\n        while (index--) {\n          var func = funcs[index];\n          if (typeof func != 'function') {\n            throw new TypeError(FUNC_ERROR_TEXT);\n          }\n          if (prereq && !wrapper && getFuncName(func) == 'wrapper') {\n            var wrapper = new LodashWrapper([], true);\n          }\n        }\n        index = wrapper ? index : length;\n        while (++index < length) {\n          func = funcs[index];\n\n          var funcName = getFuncName(func),\n              data = funcName == 'wrapper' ? getData(func) : undefined;\n\n          if (data && isLaziable(data[0]) &&\n                data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) &&\n                !data[4].length && data[9] == 1\n              ) {\n            wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);\n          } else {\n            wrapper = (func.length == 1 && isLaziable(func))\n              ? wrapper[funcName]()\n              : wrapper.thru(func);\n          }\n        }\n        return function() {\n          var args = arguments,\n              value = args[0];\n\n          if (wrapper && args.length == 1 && isArray(value)) {\n            return wrapper.plant(value).value();\n          }\n          var index = 0,\n              result = length ? funcs[index].apply(this, args) : value;\n\n          while (++index < length) {\n            result = funcs[index].call(this, result);\n          }\n          return result;\n        };\n      });\n    }\n\n    /**\n     * Creates a function that wraps `func` to invoke it with optional `this`\n     * binding of `thisArg`, partial application, and currying.\n     *\n     * @private\n     * @param {Function|string} func The function or method name to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @param {Array} [partials] The arguments to prepend to those provided to\n     *  the new function.\n     * @param {Array} [holders] The `partials` placeholder indexes.\n     * @param {Array} [partialsRight] The arguments to append to those provided\n     *  to the new function.\n     * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.\n     * @param {Array} [argPos] The argument positions of the new function.\n     * @param {number} [ary] The arity cap of `func`.\n     * @param {number} [arity] The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {\n      var isAry = bitmask & WRAP_ARY_FLAG,\n          isBind = bitmask & WRAP_BIND_FLAG,\n          isBindKey = bitmask & WRAP_BIND_KEY_FLAG,\n          isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG),\n          isFlip = bitmask & WRAP_FLIP_FLAG,\n          Ctor = isBindKey ? undefined : createCtor(func);\n\n      function wrapper() {\n        var length = arguments.length,\n            args = Array(length),\n            index = length;\n\n        while (index--) {\n          args[index] = arguments[index];\n        }\n        if (isCurried) {\n          var placeholder = getHolder(wrapper),\n              holdersCount = countHolders(args, placeholder);\n        }\n        if (partials) {\n          args = composeArgs(args, partials, holders, isCurried);\n        }\n        if (partialsRight) {\n          args = composeArgsRight(args, partialsRight, holdersRight, isCurried);\n        }\n        length -= holdersCount;\n        if (isCurried && length < arity) {\n          var newHolders = replaceHolders(args, placeholder);\n          return createRecurry(\n            func, bitmask, createHybrid, wrapper.placeholder, thisArg,\n            args, newHolders, argPos, ary, arity - length\n          );\n        }\n        var thisBinding = isBind ? thisArg : this,\n            fn = isBindKey ? thisBinding[func] : func;\n\n        length = args.length;\n        if (argPos) {\n          args = reorder(args, argPos);\n        } else if (isFlip && length > 1) {\n          args.reverse();\n        }\n        if (isAry && ary < length) {\n          args.length = ary;\n        }\n        if (this && this !== root && this instanceof wrapper) {\n          fn = Ctor || createCtor(fn);\n        }\n        return fn.apply(thisBinding, args);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a function like `_.invertBy`.\n     *\n     * @private\n     * @param {Function} setter The function to set accumulator values.\n     * @param {Function} toIteratee The function to resolve iteratees.\n     * @returns {Function} Returns the new inverter function.\n     */\n    function createInverter(setter, toIteratee) {\n      return function(object, iteratee) {\n        return baseInverter(object, setter, toIteratee(iteratee), {});\n      };\n    }\n\n    /**\n     * Creates a function that performs a mathematical operation on two values.\n     *\n     * @private\n     * @param {Function} operator The function to perform the operation.\n     * @param {number} [defaultValue] The value used for `undefined` arguments.\n     * @returns {Function} Returns the new mathematical operation function.\n     */\n    function createMathOperation(operator, defaultValue) {\n      return function(value, other) {\n        var result;\n        if (value === undefined && other === undefined) {\n          return defaultValue;\n        }\n        if (value !== undefined) {\n          result = value;\n        }\n        if (other !== undefined) {\n          if (result === undefined) {\n            return other;\n          }\n          if (typeof value == 'string' || typeof other == 'string') {\n            value = baseToString(value);\n            other = baseToString(other);\n          } else {\n            value = baseToNumber(value);\n            other = baseToNumber(other);\n          }\n          result = operator(value, other);\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Creates a function like `_.over`.\n     *\n     * @private\n     * @param {Function} arrayFunc The function to iterate over iteratees.\n     * @returns {Function} Returns the new over function.\n     */\n    function createOver(arrayFunc) {\n      return flatRest(function(iteratees) {\n        iteratees = arrayMap(iteratees, baseUnary(getIteratee()));\n        return baseRest(function(args) {\n          var thisArg = this;\n          return arrayFunc(iteratees, function(iteratee) {\n            return apply(iteratee, thisArg, args);\n          });\n        });\n      });\n    }\n\n    /**\n     * Creates the padding for `string` based on `length`. The `chars` string\n     * is truncated if the number of characters exceeds `length`.\n     *\n     * @private\n     * @param {number} length The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padding for `string`.\n     */\n    function createPadding(length, chars) {\n      chars = chars === undefined ? ' ' : baseToString(chars);\n\n      var charsLength = chars.length;\n      if (charsLength < 2) {\n        return charsLength ? baseRepeat(chars, length) : chars;\n      }\n      var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));\n      return hasUnicode(chars)\n        ? castSlice(stringToArray(result), 0, length).join('')\n        : result.slice(0, length);\n    }\n\n    /**\n     * Creates a function that wraps `func` to invoke it with the `this` binding\n     * of `thisArg` and `partials` prepended to the arguments it receives.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {*} thisArg The `this` binding of `func`.\n     * @param {Array} partials The arguments to prepend to those provided to\n     *  the new function.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createPartial(func, bitmask, thisArg, partials) {\n      var isBind = bitmask & WRAP_BIND_FLAG,\n          Ctor = createCtor(func);\n\n      function wrapper() {\n        var argsIndex = -1,\n            argsLength = arguments.length,\n            leftIndex = -1,\n            leftLength = partials.length,\n            args = Array(leftLength + argsLength),\n            fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n\n        while (++leftIndex < leftLength) {\n          args[leftIndex] = partials[leftIndex];\n        }\n        while (argsLength--) {\n          args[leftIndex++] = arguments[++argsIndex];\n        }\n        return apply(fn, isBind ? thisArg : this, args);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a `_.range` or `_.rangeRight` function.\n     *\n     * @private\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new range function.\n     */\n    function createRange(fromRight) {\n      return function(start, end, step) {\n        if (step && typeof step != 'number' && isIterateeCall(start, end, step)) {\n          end = step = undefined;\n        }\n        // Ensure the sign of `-0` is preserved.\n        start = toFinite(start);\n        if (end === undefined) {\n          end = start;\n          start = 0;\n        } else {\n          end = toFinite(end);\n        }\n        step = step === undefined ? (start < end ? 1 : -1) : toFinite(step);\n        return baseRange(start, end, step, fromRight);\n      };\n    }\n\n    /**\n     * Creates a function that performs a relational operation on two values.\n     *\n     * @private\n     * @param {Function} operator The function to perform the operation.\n     * @returns {Function} Returns the new relational operation function.\n     */\n    function createRelationalOperation(operator) {\n      return function(value, other) {\n        if (!(typeof value == 'string' && typeof other == 'string')) {\n          value = toNumber(value);\n          other = toNumber(other);\n        }\n        return operator(value, other);\n      };\n    }\n\n    /**\n     * Creates a function that wraps `func` to continue currying.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {Function} wrapFunc The function to create the `func` wrapper.\n     * @param {*} placeholder The placeholder value.\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @param {Array} [partials] The arguments to prepend to those provided to\n     *  the new function.\n     * @param {Array} [holders] The `partials` placeholder indexes.\n     * @param {Array} [argPos] The argument positions of the new function.\n     * @param {number} [ary] The arity cap of `func`.\n     * @param {number} [arity] The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {\n      var isCurry = bitmask & WRAP_CURRY_FLAG,\n          newHolders = isCurry ? holders : undefined,\n          newHoldersRight = isCurry ? undefined : holders,\n          newPartials = isCurry ? partials : undefined,\n          newPartialsRight = isCurry ? undefined : partials;\n\n      bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);\n      bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);\n\n      if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {\n        bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);\n      }\n      var newData = [\n        func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,\n        newHoldersRight, argPos, ary, arity\n      ];\n\n      var result = wrapFunc.apply(undefined, newData);\n      if (isLaziable(func)) {\n        setData(result, newData);\n      }\n      result.placeholder = placeholder;\n      return setWrapToString(result, func, bitmask);\n    }\n\n    /**\n     * Creates a function like `_.round`.\n     *\n     * @private\n     * @param {string} methodName The name of the `Math` method to use when rounding.\n     * @returns {Function} Returns the new round function.\n     */\n    function createRound(methodName) {\n      var func = Math[methodName];\n      return function(number, precision) {\n        number = toNumber(number);\n        precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);\n        if (precision) {\n          // Shift with exponential notation to avoid floating-point issues.\n          // See [MDN](https://mdn.io/round#Examples) for more details.\n          var pair = (toString(number) + 'e').split('e'),\n              value = func(pair[0] + 'e' + (+pair[1] + precision));\n\n          pair = (toString(value) + 'e').split('e');\n          return +(pair[0] + 'e' + (+pair[1] - precision));\n        }\n        return func(number);\n      };\n    }\n\n    /**\n     * Creates a set object of `values`.\n     *\n     * @private\n     * @param {Array} values The values to add to the set.\n     * @returns {Object} Returns the new set.\n     */\n    var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {\n      return new Set(values);\n    };\n\n    /**\n     * Creates a `_.toPairs` or `_.toPairsIn` function.\n     *\n     * @private\n     * @param {Function} keysFunc The function to get the keys of a given object.\n     * @returns {Function} Returns the new pairs function.\n     */\n    function createToPairs(keysFunc) {\n      return function(object) {\n        var tag = getTag(object);\n        if (tag == mapTag) {\n          return mapToArray(object);\n        }\n        if (tag == setTag) {\n          return setToPairs(object);\n        }\n        return baseToPairs(object, keysFunc(object));\n      };\n    }\n\n    /**\n     * Creates a function that either curries or invokes `func` with optional\n     * `this` binding and partially applied arguments.\n     *\n     * @private\n     * @param {Function|string} func The function or method name to wrap.\n     * @param {number} bitmask The bitmask flags.\n     *    1 - `_.bind`\n     *    2 - `_.bindKey`\n     *    4 - `_.curry` or `_.curryRight` of a bound function\n     *    8 - `_.curry`\n     *   16 - `_.curryRight`\n     *   32 - `_.partial`\n     *   64 - `_.partialRight`\n     *  128 - `_.rearg`\n     *  256 - `_.ary`\n     *  512 - `_.flip`\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @param {Array} [partials] The arguments to be partially applied.\n     * @param {Array} [holders] The `partials` placeholder indexes.\n     * @param {Array} [argPos] The argument positions of the new function.\n     * @param {number} [ary] The arity cap of `func`.\n     * @param {number} [arity] The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {\n      var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;\n      if (!isBindKey && typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      var length = partials ? partials.length : 0;\n      if (!length) {\n        bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);\n        partials = holders = undefined;\n      }\n      ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0);\n      arity = arity === undefined ? arity : toInteger(arity);\n      length -= holders ? holders.length : 0;\n\n      if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {\n        var partialsRight = partials,\n            holdersRight = holders;\n\n        partials = holders = undefined;\n      }\n      var data = isBindKey ? undefined : getData(func);\n\n      var newData = [\n        func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,\n        argPos, ary, arity\n      ];\n\n      if (data) {\n        mergeData(newData, data);\n      }\n      func = newData[0];\n      bitmask = newData[1];\n      thisArg = newData[2];\n      partials = newData[3];\n      holders = newData[4];\n      arity = newData[9] = newData[9] === undefined\n        ? (isBindKey ? 0 : func.length)\n        : nativeMax(newData[9] - length, 0);\n\n      if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {\n        bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);\n      }\n      if (!bitmask || bitmask == WRAP_BIND_FLAG) {\n        var result = createBind(func, bitmask, thisArg);\n      } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {\n        result = createCurry(func, bitmask, arity);\n      } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {\n        result = createPartial(func, bitmask, thisArg, partials);\n      } else {\n        result = createHybrid.apply(undefined, newData);\n      }\n      var setter = data ? baseSetData : setData;\n      return setWrapToString(setter(result, newData), func, bitmask);\n    }\n\n    /**\n     * Used by `_.defaults` to customize its `_.assignIn` use to assign properties\n     * of source objects to the destination object for all destination properties\n     * that resolve to `undefined`.\n     *\n     * @private\n     * @param {*} objValue The destination value.\n     * @param {*} srcValue The source value.\n     * @param {string} key The key of the property to assign.\n     * @param {Object} object The parent object of `objValue`.\n     * @returns {*} Returns the value to assign.\n     */\n    function customDefaultsAssignIn(objValue, srcValue, key, object) {\n      if (objValue === undefined ||\n          (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) {\n        return srcValue;\n      }\n      return objValue;\n    }\n\n    /**\n     * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source\n     * objects into destination objects that are passed thru.\n     *\n     * @private\n     * @param {*} objValue The destination value.\n     * @param {*} srcValue The source value.\n     * @param {string} key The key of the property to merge.\n     * @param {Object} object The parent object of `objValue`.\n     * @param {Object} source The parent object of `srcValue`.\n     * @param {Object} [stack] Tracks traversed source values and their merged\n     *  counterparts.\n     * @returns {*} Returns the value to assign.\n     */\n    function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {\n      if (isObject(objValue) && isObject(srcValue)) {\n        // Recursively merge objects and arrays (susceptible to call stack limits).\n        stack.set(srcValue, objValue);\n        baseMerge(objValue, srcValue, undefined, customDefaultsMerge, stack);\n        stack['delete'](srcValue);\n      }\n      return objValue;\n    }\n\n    /**\n     * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain\n     * objects.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @param {string} key The key of the property to inspect.\n     * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.\n     */\n    function customOmitClone(value) {\n      return isPlainObject(value) ? undefined : value;\n    }\n\n    /**\n     * A specialized version of `baseIsEqualDeep` for arrays with support for\n     * partial deep comparisons.\n     *\n     * @private\n     * @param {Array} array The array to compare.\n     * @param {Array} other The other array to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} stack Tracks traversed `array` and `other` objects.\n     * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n     */\n    function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n      var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n          arrLength = array.length,\n          othLength = other.length;\n\n      if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n        return false;\n      }\n      // Assume cyclic values are equal.\n      var stacked = stack.get(array);\n      if (stacked && stack.get(other)) {\n        return stacked == other;\n      }\n      var index = -1,\n          result = true,\n          seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n      stack.set(array, other);\n      stack.set(other, array);\n\n      // Ignore non-index properties.\n      while (++index < arrLength) {\n        var arrValue = array[index],\n            othValue = other[index];\n\n        if (customizer) {\n          var compared = isPartial\n            ? customizer(othValue, arrValue, index, other, array, stack)\n            : customizer(arrValue, othValue, index, array, other, stack);\n        }\n        if (compared !== undefined) {\n          if (compared) {\n            continue;\n          }\n          result = false;\n          break;\n        }\n        // Recursively compare arrays (susceptible to call stack limits).\n        if (seen) {\n          if (!arraySome(other, function(othValue, othIndex) {\n                if (!cacheHas(seen, othIndex) &&\n                    (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n                  return seen.push(othIndex);\n                }\n              })) {\n            result = false;\n            break;\n          }\n        } else if (!(\n              arrValue === othValue ||\n                equalFunc(arrValue, othValue, bitmask, customizer, stack)\n            )) {\n          result = false;\n          break;\n        }\n      }\n      stack['delete'](array);\n      stack['delete'](other);\n      return result;\n    }\n\n    /**\n     * A specialized version of `baseIsEqualDeep` for comparing objects of\n     * the same `toStringTag`.\n     *\n     * **Note:** This function only supports comparing values with tags of\n     * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {string} tag The `toStringTag` of the objects to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} stack Tracks traversed `object` and `other` objects.\n     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n     */\n    function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n      switch (tag) {\n        case dataViewTag:\n          if ((object.byteLength != other.byteLength) ||\n              (object.byteOffset != other.byteOffset)) {\n            return false;\n          }\n          object = object.buffer;\n          other = other.buffer;\n\n        case arrayBufferTag:\n          if ((object.byteLength != other.byteLength) ||\n              !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n            return false;\n          }\n          return true;\n\n        case boolTag:\n        case dateTag:\n        case numberTag:\n          // Coerce booleans to `1` or `0` and dates to milliseconds.\n          // Invalid dates are coerced to `NaN`.\n          return eq(+object, +other);\n\n        case errorTag:\n          return object.name == other.name && object.message == other.message;\n\n        case regexpTag:\n        case stringTag:\n          // Coerce regexes to strings and treat strings, primitives and objects,\n          // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n          // for more details.\n          return object == (other + '');\n\n        case mapTag:\n          var convert = mapToArray;\n\n        case setTag:\n          var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n          convert || (convert = setToArray);\n\n          if (object.size != other.size && !isPartial) {\n            return false;\n          }\n          // Assume cyclic values are equal.\n          var stacked = stack.get(object);\n          if (stacked) {\n            return stacked == other;\n          }\n          bitmask |= COMPARE_UNORDERED_FLAG;\n\n          // Recursively compare objects (susceptible to call stack limits).\n          stack.set(object, other);\n          var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n          stack['delete'](object);\n          return result;\n\n        case symbolTag:\n          if (symbolValueOf) {\n            return symbolValueOf.call(object) == symbolValueOf.call(other);\n          }\n      }\n      return false;\n    }\n\n    /**\n     * A specialized version of `baseIsEqualDeep` for objects with support for\n     * partial deep comparisons.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} stack Tracks traversed `object` and `other` objects.\n     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n     */\n    function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n      var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n          objProps = getAllKeys(object),\n          objLength = objProps.length,\n          othProps = getAllKeys(other),\n          othLength = othProps.length;\n\n      if (objLength != othLength && !isPartial) {\n        return false;\n      }\n      var index = objLength;\n      while (index--) {\n        var key = objProps[index];\n        if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n          return false;\n        }\n      }\n      // Assume cyclic values are equal.\n      var stacked = stack.get(object);\n      if (stacked && stack.get(other)) {\n        return stacked == other;\n      }\n      var result = true;\n      stack.set(object, other);\n      stack.set(other, object);\n\n      var skipCtor = isPartial;\n      while (++index < objLength) {\n        key = objProps[index];\n        var objValue = object[key],\n            othValue = other[key];\n\n        if (customizer) {\n          var compared = isPartial\n            ? customizer(othValue, objValue, key, other, object, stack)\n            : customizer(objValue, othValue, key, object, other, stack);\n        }\n        // Recursively compare objects (susceptible to call stack limits).\n        if (!(compared === undefined\n              ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n              : compared\n            )) {\n          result = false;\n          break;\n        }\n        skipCtor || (skipCtor = key == 'constructor');\n      }\n      if (result && !skipCtor) {\n        var objCtor = object.constructor,\n            othCtor = other.constructor;\n\n        // Non `Object` object instances with different constructors are not equal.\n        if (objCtor != othCtor &&\n            ('constructor' in object && 'constructor' in other) &&\n            !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n              typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n          result = false;\n        }\n      }\n      stack['delete'](object);\n      stack['delete'](other);\n      return result;\n    }\n\n    /**\n     * A specialized version of `baseRest` which flattens the rest array.\n     *\n     * @private\n     * @param {Function} func The function to apply a rest parameter to.\n     * @returns {Function} Returns the new function.\n     */\n    function flatRest(func) {\n      return setToString(overRest(func, undefined, flatten), func + '');\n    }\n\n    /**\n     * Creates an array of own enumerable property names and symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names and symbols.\n     */\n    function getAllKeys(object) {\n      return baseGetAllKeys(object, keys, getSymbols);\n    }\n\n    /**\n     * Creates an array of own and inherited enumerable property names and\n     * symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names and symbols.\n     */\n    function getAllKeysIn(object) {\n      return baseGetAllKeys(object, keysIn, getSymbolsIn);\n    }\n\n    /**\n     * Gets metadata for `func`.\n     *\n     * @private\n     * @param {Function} func The function to query.\n     * @returns {*} Returns the metadata for `func`.\n     */\n    var getData = !metaMap ? noop : function(func) {\n      return metaMap.get(func);\n    };\n\n    /**\n     * Gets the name of `func`.\n     *\n     * @private\n     * @param {Function} func The function to query.\n     * @returns {string} Returns the function name.\n     */\n    function getFuncName(func) {\n      var result = (func.name + ''),\n          array = realNames[result],\n          length = hasOwnProperty.call(realNames, result) ? array.length : 0;\n\n      while (length--) {\n        var data = array[length],\n            otherFunc = data.func;\n        if (otherFunc == null || otherFunc == func) {\n          return data.name;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Gets the argument placeholder value for `func`.\n     *\n     * @private\n     * @param {Function} func The function to inspect.\n     * @returns {*} Returns the placeholder value.\n     */\n    function getHolder(func) {\n      var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func;\n      return object.placeholder;\n    }\n\n    /**\n     * Gets the appropriate \"iteratee\" function. If `_.iteratee` is customized,\n     * this function returns the custom method, otherwise it returns `baseIteratee`.\n     * If arguments are provided, the chosen function is invoked with them and\n     * its result is returned.\n     *\n     * @private\n     * @param {*} [value] The value to convert to an iteratee.\n     * @param {number} [arity] The arity of the created iteratee.\n     * @returns {Function} Returns the chosen function or its result.\n     */\n    function getIteratee() {\n      var result = lodash.iteratee || iteratee;\n      result = result === iteratee ? baseIteratee : result;\n      return arguments.length ? result(arguments[0], arguments[1]) : result;\n    }\n\n    /**\n     * Gets the data for `map`.\n     *\n     * @private\n     * @param {Object} map The map to query.\n     * @param {string} key The reference key.\n     * @returns {*} Returns the map data.\n     */\n    function getMapData(map, key) {\n      var data = map.__data__;\n      return isKeyable(key)\n        ? data[typeof key == 'string' ? 'string' : 'hash']\n        : data.map;\n    }\n\n    /**\n     * Gets the property names, values, and compare flags of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the match data of `object`.\n     */\n    function getMatchData(object) {\n      var result = keys(object),\n          length = result.length;\n\n      while (length--) {\n        var key = result[length],\n            value = object[key];\n\n        result[length] = [key, value, isStrictComparable(value)];\n      }\n      return result;\n    }\n\n    /**\n     * Gets the native function at `key` of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {string} key The key of the method to get.\n     * @returns {*} Returns the function if it's native, else `undefined`.\n     */\n    function getNative(object, key) {\n      var value = getValue(object, key);\n      return baseIsNative(value) ? value : undefined;\n    }\n\n    /**\n     * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n     *\n     * @private\n     * @param {*} value The value to query.\n     * @returns {string} Returns the raw `toStringTag`.\n     */\n    function getRawTag(value) {\n      var isOwn = hasOwnProperty.call(value, symToStringTag),\n          tag = value[symToStringTag];\n\n      try {\n        value[symToStringTag] = undefined;\n        var unmasked = true;\n      } catch (e) {}\n\n      var result = nativeObjectToString.call(value);\n      if (unmasked) {\n        if (isOwn) {\n          value[symToStringTag] = tag;\n        } else {\n          delete value[symToStringTag];\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Creates an array of the own enumerable symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of symbols.\n     */\n    var getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n      if (object == null) {\n        return [];\n      }\n      object = Object(object);\n      return arrayFilter(nativeGetSymbols(object), function(symbol) {\n        return propertyIsEnumerable.call(object, symbol);\n      });\n    };\n\n    /**\n     * Creates an array of the own and inherited enumerable symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of symbols.\n     */\n    var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {\n      var result = [];\n      while (object) {\n        arrayPush(result, getSymbols(object));\n        object = getPrototype(object);\n      }\n      return result;\n    };\n\n    /**\n     * Gets the `toStringTag` of `value`.\n     *\n     * @private\n     * @param {*} value The value to query.\n     * @returns {string} Returns the `toStringTag`.\n     */\n    var getTag = baseGetTag;\n\n    // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\n    if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n        (Map && getTag(new Map) != mapTag) ||\n        (Promise && getTag(Promise.resolve()) != promiseTag) ||\n        (Set && getTag(new Set) != setTag) ||\n        (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n      getTag = function(value) {\n        var result = baseGetTag(value),\n            Ctor = result == objectTag ? value.constructor : undefined,\n            ctorString = Ctor ? toSource(Ctor) : '';\n\n        if (ctorString) {\n          switch (ctorString) {\n            case dataViewCtorString: return dataViewTag;\n            case mapCtorString: return mapTag;\n            case promiseCtorString: return promiseTag;\n            case setCtorString: return setTag;\n            case weakMapCtorString: return weakMapTag;\n          }\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Gets the view, applying any `transforms` to the `start` and `end` positions.\n     *\n     * @private\n     * @param {number} start The start of the view.\n     * @param {number} end The end of the view.\n     * @param {Array} transforms The transformations to apply to the view.\n     * @returns {Object} Returns an object containing the `start` and `end`\n     *  positions of the view.\n     */\n    function getView(start, end, transforms) {\n      var index = -1,\n          length = transforms.length;\n\n      while (++index < length) {\n        var data = transforms[index],\n            size = data.size;\n\n        switch (data.type) {\n          case 'drop':      start += size; break;\n          case 'dropRight': end -= size; break;\n          case 'take':      end = nativeMin(end, start + size); break;\n          case 'takeRight': start = nativeMax(start, end - size); break;\n        }\n      }\n      return { 'start': start, 'end': end };\n    }\n\n    /**\n     * Extracts wrapper details from the `source` body comment.\n     *\n     * @private\n     * @param {string} source The source to inspect.\n     * @returns {Array} Returns the wrapper details.\n     */\n    function getWrapDetails(source) {\n      var match = source.match(reWrapDetails);\n      return match ? match[1].split(reSplitDetails) : [];\n    }\n\n    /**\n     * Checks if `path` exists on `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path to check.\n     * @param {Function} hasFunc The function to check properties.\n     * @returns {boolean} Returns `true` if `path` exists, else `false`.\n     */\n    function hasPath(object, path, hasFunc) {\n      path = castPath(path, object);\n\n      var index = -1,\n          length = path.length,\n          result = false;\n\n      while (++index < length) {\n        var key = toKey(path[index]);\n        if (!(result = object != null && hasFunc(object, key))) {\n          break;\n        }\n        object = object[key];\n      }\n      if (result || ++index != length) {\n        return result;\n      }\n      length = object == null ? 0 : object.length;\n      return !!length && isLength(length) && isIndex(key, length) &&\n        (isArray(object) || isArguments(object));\n    }\n\n    /**\n     * Initializes an array clone.\n     *\n     * @private\n     * @param {Array} array The array to clone.\n     * @returns {Array} Returns the initialized clone.\n     */\n    function initCloneArray(array) {\n      var length = array.length,\n          result = array.constructor(length);\n\n      // Add properties assigned by `RegExp#exec`.\n      if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n        result.index = array.index;\n        result.input = array.input;\n      }\n      return result;\n    }\n\n    /**\n     * Initializes an object clone.\n     *\n     * @private\n     * @param {Object} object The object to clone.\n     * @returns {Object} Returns the initialized clone.\n     */\n    function initCloneObject(object) {\n      return (typeof object.constructor == 'function' && !isPrototype(object))\n        ? baseCreate(getPrototype(object))\n        : {};\n    }\n\n    /**\n     * Initializes an object clone based on its `toStringTag`.\n     *\n     * **Note:** This function only supports cloning values with tags of\n     * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n     *\n     * @private\n     * @param {Object} object The object to clone.\n     * @param {string} tag The `toStringTag` of the object to clone.\n     * @param {Function} cloneFunc The function to clone values.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the initialized clone.\n     */\n    function initCloneByTag(object, tag, cloneFunc, isDeep) {\n      var Ctor = object.constructor;\n      switch (tag) {\n        case arrayBufferTag:\n          return cloneArrayBuffer(object);\n\n        case boolTag:\n        case dateTag:\n          return new Ctor(+object);\n\n        case dataViewTag:\n          return cloneDataView(object, isDeep);\n\n        case float32Tag: case float64Tag:\n        case int8Tag: case int16Tag: case int32Tag:\n        case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n          return cloneTypedArray(object, isDeep);\n\n        case mapTag:\n          return cloneMap(object, isDeep, cloneFunc);\n\n        case numberTag:\n        case stringTag:\n          return new Ctor(object);\n\n        case regexpTag:\n          return cloneRegExp(object);\n\n        case setTag:\n          return cloneSet(object, isDeep, cloneFunc);\n\n        case symbolTag:\n          return cloneSymbol(object);\n      }\n    }\n\n    /**\n     * Inserts wrapper `details` in a comment at the top of the `source` body.\n     *\n     * @private\n     * @param {string} source The source to modify.\n     * @returns {Array} details The details to insert.\n     * @returns {string} Returns the modified source.\n     */\n    function insertWrapDetails(source, details) {\n      var length = details.length;\n      if (!length) {\n        return source;\n      }\n      var lastIndex = length - 1;\n      details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex];\n      details = details.join(length > 2 ? ', ' : ' ');\n      return source.replace(reWrapComment, '{\\n/* [wrapped with ' + details + '] */\\n');\n    }\n\n    /**\n     * Checks if `value` is a flattenable `arguments` object or array.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.\n     */\n    function isFlattenable(value) {\n      return isArray(value) || isArguments(value) ||\n        !!(spreadableSymbol && value && value[spreadableSymbol]);\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     */\n    function 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     */\n    function 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 a property name and not a property path.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @param {Object} [object] The object to query keys on.\n     * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n     */\n    function isKey(value, object) {\n      if (isArray(value)) {\n        return false;\n      }\n      var type = typeof value;\n      if (type == 'number' || type == 'symbol' || type == 'boolean' ||\n          value == null || isSymbol(value)) {\n        return true;\n      }\n      return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||\n        (object != null && value in Object(object));\n    }\n\n    /**\n     * Checks if `value` is suitable for use as unique object key.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n     */\n    function isKeyable(value) {\n      var type = typeof value;\n      return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n        ? (value !== '__proto__')\n        : (value === null);\n    }\n\n    /**\n     * Checks if `func` has a lazy counterpart.\n     *\n     * @private\n     * @param {Function} func The function to check.\n     * @returns {boolean} Returns `true` if `func` has a lazy counterpart,\n     *  else `false`.\n     */\n    function isLaziable(func) {\n      var funcName = getFuncName(func),\n          other = lodash[funcName];\n\n      if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) {\n        return false;\n      }\n      if (func === other) {\n        return true;\n      }\n      var data = getData(other);\n      return !!data && func === data[0];\n    }\n\n    /**\n     * Checks if `func` has its source masked.\n     *\n     * @private\n     * @param {Function} func The function to check.\n     * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n     */\n    function isMasked(func) {\n      return !!maskSrcKey && (maskSrcKey in func);\n    }\n\n    /**\n     * Checks if `func` is capable of being masked.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `func` is maskable, else `false`.\n     */\n    var isMaskable = coreJsData ? isFunction : stubFalse;\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     */\n    function 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     * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` if suitable for strict\n     *  equality comparisons, else `false`.\n     */\n    function isStrictComparable(value) {\n      return value === value && !isObject(value);\n    }\n\n    /**\n     * A specialized version of `matchesProperty` for source values suitable\n     * for strict equality comparisons, i.e. `===`.\n     *\n     * @private\n     * @param {string} key The key of the property to get.\n     * @param {*} srcValue The value to match.\n     * @returns {Function} Returns the new spec function.\n     */\n    function matchesStrictComparable(key, srcValue) {\n      return function(object) {\n        if (object == null) {\n          return false;\n        }\n        return object[key] === srcValue &&\n          (srcValue !== undefined || (key in Object(object)));\n      };\n    }\n\n    /**\n     * A specialized version of `_.memoize` which clears the memoized function's\n     * cache when it exceeds `MAX_MEMOIZE_SIZE`.\n     *\n     * @private\n     * @param {Function} func The function to have its output memoized.\n     * @returns {Function} Returns the new memoized function.\n     */\n    function memoizeCapped(func) {\n      var result = memoize(func, function(key) {\n        if (cache.size === MAX_MEMOIZE_SIZE) {\n          cache.clear();\n        }\n        return key;\n      });\n\n      var cache = result.cache;\n      return result;\n    }\n\n    /**\n     * Merges the function metadata of `source` into `data`.\n     *\n     * Merging metadata reduces the number of wrappers used to invoke a function.\n     * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`\n     * may be applied regardless of execution order. Methods like `_.ary` and\n     * `_.rearg` modify function arguments, making the order in which they are\n     * executed important, preventing the merging of metadata. However, we make\n     * an exception for a safe combined case where curried functions have `_.ary`\n     * and or `_.rearg` applied.\n     *\n     * @private\n     * @param {Array} data The destination metadata.\n     * @param {Array} source The source metadata.\n     * @returns {Array} Returns `data`.\n     */\n    function mergeData(data, source) {\n      var bitmask = data[1],\n          srcBitmask = source[1],\n          newBitmask = bitmask | srcBitmask,\n          isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);\n\n      var isCombo =\n        ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) ||\n        ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) ||\n        ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));\n\n      // Exit early if metadata can't be merged.\n      if (!(isCommon || isCombo)) {\n        return data;\n      }\n      // Use source `thisArg` if available.\n      if (srcBitmask & WRAP_BIND_FLAG) {\n        data[2] = source[2];\n        // Set when currying a bound function.\n        newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;\n      }\n      // Compose partial arguments.\n      var value = source[3];\n      if (value) {\n        var partials = data[3];\n        data[3] = partials ? composeArgs(partials, value, source[4]) : value;\n        data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];\n      }\n      // Compose partial right arguments.\n      value = source[5];\n      if (value) {\n        partials = data[5];\n        data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;\n        data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];\n      }\n      // Use source `argPos` if available.\n      value = source[7];\n      if (value) {\n        data[7] = value;\n      }\n      // Use source `ary` if it's smaller.\n      if (srcBitmask & WRAP_ARY_FLAG) {\n        data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);\n      }\n      // Use source `arity` if one is not provided.\n      if (data[9] == null) {\n        data[9] = source[9];\n      }\n      // Use source `func` and merge bitmasks.\n      data[0] = source[0];\n      data[1] = newBitmask;\n\n      return data;\n    }\n\n    /**\n     * This function is like\n     * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n     * except that it includes inherited enumerable properties.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     */\n    function nativeKeysIn(object) {\n      var result = [];\n      if (object != null) {\n        for (var key in Object(object)) {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Converts `value` to a string using `Object.prototype.toString`.\n     *\n     * @private\n     * @param {*} value The value to convert.\n     * @returns {string} Returns the converted string.\n     */\n    function objectToString(value) {\n      return nativeObjectToString.call(value);\n    }\n\n    /**\n     * A specialized version of `baseRest` which transforms the rest array.\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     * @param {Function} transform The rest array transform.\n     * @returns {Function} Returns the new function.\n     */\n    function overRest(func, start, transform) {\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] = transform(array);\n        return apply(func, this, otherArgs);\n      };\n    }\n\n    /**\n     * Gets the parent value at `path` of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array} path The path to get the parent value of.\n     * @returns {*} Returns the parent value.\n     */\n    function parent(object, path) {\n      return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));\n    }\n\n    /**\n     * Reorder `array` according to the specified indexes where the element at\n     * the first index is assigned as the first element, the element at\n     * the second index is assigned as the second element, and so on.\n     *\n     * @private\n     * @param {Array} array The array to reorder.\n     * @param {Array} indexes The arranged array indexes.\n     * @returns {Array} Returns `array`.\n     */\n    function reorder(array, indexes) {\n      var arrLength = array.length,\n          length = nativeMin(indexes.length, arrLength),\n          oldArray = copyArray(array);\n\n      while (length--) {\n        var index = indexes[length];\n        array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined;\n      }\n      return array;\n    }\n\n    /**\n     * Sets metadata for `func`.\n     *\n     * **Note:** If this function becomes hot, i.e. is invoked a lot in a short\n     * period of time, it will trip its breaker and transition to an identity\n     * function to avoid garbage collection pauses in V8. See\n     * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070)\n     * for more details.\n     *\n     * @private\n     * @param {Function} func The function to associate metadata with.\n     * @param {*} data The metadata.\n     * @returns {Function} Returns `func`.\n     */\n    var setData = shortOut(baseSetData);\n\n    /**\n     * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout).\n     *\n     * @private\n     * @param {Function} func The function to delay.\n     * @param {number} wait The number of milliseconds to delay invocation.\n     * @returns {number|Object} Returns the timer id or timeout object.\n     */\n    var setTimeout = ctxSetTimeout || function(func, wait) {\n      return root.setTimeout(func, wait);\n    };\n\n    /**\n     * Sets the `toString` method of `func` to return `string`.\n     *\n     * @private\n     * @param {Function} func The function to modify.\n     * @param {Function} string The `toString` result.\n     * @returns {Function} Returns `func`.\n     */\n    var setToString = shortOut(baseSetToString);\n\n    /**\n     * Sets the `toString` method of `wrapper` to mimic the source of `reference`\n     * with wrapper details in a comment at the top of the source body.\n     *\n     * @private\n     * @param {Function} wrapper The function to modify.\n     * @param {Function} reference The reference function.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @returns {Function} Returns `wrapper`.\n     */\n    function setWrapToString(wrapper, reference, bitmask) {\n      var source = (reference + '');\n      return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));\n    }\n\n    /**\n     * Creates a function that'll short out and invoke `identity` instead\n     * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n     * milliseconds.\n     *\n     * @private\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new shortable function.\n     */\n    function shortOut(func) {\n      var count = 0,\n          lastCalled = 0;\n\n      return function() {\n        var stamp = nativeNow(),\n            remaining = HOT_SPAN - (stamp - lastCalled);\n\n        lastCalled = stamp;\n        if (remaining > 0) {\n          if (++count >= HOT_COUNT) {\n            return arguments[0];\n          }\n        } else {\n          count = 0;\n        }\n        return func.apply(undefined, arguments);\n      };\n    }\n\n    /**\n     * A specialized version of `_.shuffle` which mutates and sets the size of `array`.\n     *\n     * @private\n     * @param {Array} array The array to shuffle.\n     * @param {number} [size=array.length] The size of `array`.\n     * @returns {Array} Returns `array`.\n     */\n    function shuffleSelf(array, size) {\n      var index = -1,\n          length = array.length,\n          lastIndex = length - 1;\n\n      size = size === undefined ? length : size;\n      while (++index < size) {\n        var rand = baseRandom(index, lastIndex),\n            value = array[rand];\n\n        array[rand] = array[index];\n        array[index] = value;\n      }\n      array.length = size;\n      return array;\n    }\n\n    /**\n     * Converts `string` to a property path array.\n     *\n     * @private\n     * @param {string} string The string to convert.\n     * @returns {Array} Returns the property path array.\n     */\n    var stringToPath = memoizeCapped(function(string) {\n      var result = [];\n      if (reLeadingDot.test(string)) {\n        result.push('');\n      }\n      string.replace(rePropName, function(match, number, quote, string) {\n        result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));\n      });\n      return result;\n    });\n\n    /**\n     * Converts `value` to a string key if it's not a string or symbol.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @returns {string|symbol} Returns the key.\n     */\n    function toKey(value) {\n      if (typeof value == 'string' || isSymbol(value)) {\n        return value;\n      }\n      var result = (value + '');\n      return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n    }\n\n    /**\n     * Converts `func` to its source code.\n     *\n     * @private\n     * @param {Function} func The function to convert.\n     * @returns {string} Returns the source code.\n     */\n    function toSource(func) {\n      if (func != null) {\n        try {\n          return funcToString.call(func);\n        } catch (e) {}\n        try {\n          return (func + '');\n        } catch (e) {}\n      }\n      return '';\n    }\n\n    /**\n     * Updates wrapper `details` based on `bitmask` flags.\n     *\n     * @private\n     * @returns {Array} details The details to modify.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @returns {Array} Returns `details`.\n     */\n    function updateWrapDetails(details, bitmask) {\n      arrayEach(wrapFlags, function(pair) {\n        var value = '_.' + pair[0];\n        if ((bitmask & pair[1]) && !arrayIncludes(details, value)) {\n          details.push(value);\n        }\n      });\n      return details.sort();\n    }\n\n    /**\n     * Creates a clone of `wrapper`.\n     *\n     * @private\n     * @param {Object} wrapper The wrapper to clone.\n     * @returns {Object} Returns the cloned wrapper.\n     */\n    function wrapperClone(wrapper) {\n      if (wrapper instanceof LazyWrapper) {\n        return wrapper.clone();\n      }\n      var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);\n      result.__actions__ = copyArray(wrapper.__actions__);\n      result.__index__  = wrapper.__index__;\n      result.__values__ = wrapper.__values__;\n      return result;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an array of elements split into groups the length of `size`.\n     * If `array` can't be split evenly, the final chunk will be the remaining\n     * elements.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to process.\n     * @param {number} [size=1] The length of each chunk\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the new array of chunks.\n     * @example\n     *\n     * _.chunk(['a', 'b', 'c', 'd'], 2);\n     * // => [['a', 'b'], ['c', 'd']]\n     *\n     * _.chunk(['a', 'b', 'c', 'd'], 3);\n     * // => [['a', 'b', 'c'], ['d']]\n     */\n    function chunk(array, size, guard) {\n      if ((guard ? isIterateeCall(array, size, guard) : size === undefined)) {\n        size = 1;\n      } else {\n        size = nativeMax(toInteger(size), 0);\n      }\n      var length = array == null ? 0 : array.length;\n      if (!length || size < 1) {\n        return [];\n      }\n      var index = 0,\n          resIndex = 0,\n          result = Array(nativeCeil(length / size));\n\n      while (index < length) {\n        result[resIndex++] = baseSlice(array, index, (index += size));\n      }\n      return result;\n    }\n\n    /**\n     * Creates an array with all falsey values removed. The values `false`, `null`,\n     * `0`, `\"\"`, `undefined`, and `NaN` are falsey.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to compact.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * _.compact([0, 1, false, 2, '', 3]);\n     * // => [1, 2, 3]\n     */\n    function compact(array) {\n      var index = -1,\n          length = array == null ? 0 : array.length,\n          resIndex = 0,\n          result = [];\n\n      while (++index < length) {\n        var value = array[index];\n        if (value) {\n          result[resIndex++] = value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Creates a new array concatenating `array` with any additional arrays\n     * and/or values.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to concatenate.\n     * @param {...*} [values] The values to concatenate.\n     * @returns {Array} Returns the new concatenated array.\n     * @example\n     *\n     * var array = [1];\n     * var other = _.concat(array, 2, [3], [[4]]);\n     *\n     * console.log(other);\n     * // => [1, 2, 3, [4]]\n     *\n     * console.log(array);\n     * // => [1]\n     */\n    function concat() {\n      var length = arguments.length;\n      if (!length) {\n        return [];\n      }\n      var args = Array(length - 1),\n          array = arguments[0],\n          index = length;\n\n      while (index--) {\n        args[index - 1] = arguments[index];\n      }\n      return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));\n    }\n\n    /**\n     * Creates an array of `array` values not included in the other given arrays\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons. The order and references of result values are\n     * determined by the first array.\n     *\n     * **Note:** Unlike `_.pullAll`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...Array} [values] The values to exclude.\n     * @returns {Array} Returns the new array of filtered values.\n     * @see _.without, _.xor\n     * @example\n     *\n     * _.difference([2, 1], [2, 3]);\n     * // => [1]\n     */\n    var difference = baseRest(function(array, values) {\n      return isArrayLikeObject(array)\n        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))\n        : [];\n    });\n\n    /**\n     * This method is like `_.difference` except that it accepts `iteratee` which\n     * is invoked for each element of `array` and `values` to generate the criterion\n     * by which they're compared. The order and references of result values are\n     * determined by the first array. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * **Note:** Unlike `_.pullAllBy`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...Array} [values] The values to exclude.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n     * // => [1.2]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');\n     * // => [{ 'x': 2 }]\n     */\n    var differenceBy = baseRest(function(array, values) {\n      var iteratee = last(values);\n      if (isArrayLikeObject(iteratee)) {\n        iteratee = undefined;\n      }\n      return isArrayLikeObject(array)\n        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), getIteratee(iteratee, 2))\n        : [];\n    });\n\n    /**\n     * This method is like `_.difference` except that it accepts `comparator`\n     * which is invoked to compare elements of `array` to `values`. The order and\n     * references of result values are determined by the first array. The comparator\n     * is invoked with two arguments: (arrVal, othVal).\n     *\n     * **Note:** Unlike `_.pullAllWith`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...Array} [values] The values to exclude.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     *\n     * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual);\n     * // => [{ 'x': 2, 'y': 1 }]\n     */\n    var differenceWith = baseRest(function(array, values) {\n      var comparator = last(values);\n      if (isArrayLikeObject(comparator)) {\n        comparator = undefined;\n      }\n      return isArrayLikeObject(array)\n        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined, comparator)\n        : [];\n    });\n\n    /**\n     * Creates a slice of `array` with `n` elements dropped from the beginning.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.5.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to drop.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.drop([1, 2, 3]);\n     * // => [2, 3]\n     *\n     * _.drop([1, 2, 3], 2);\n     * // => [3]\n     *\n     * _.drop([1, 2, 3], 5);\n     * // => []\n     *\n     * _.drop([1, 2, 3], 0);\n     * // => [1, 2, 3]\n     */\n    function drop(array, n, guard) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      n = (guard || n === undefined) ? 1 : toInteger(n);\n      return baseSlice(array, n < 0 ? 0 : n, length);\n    }\n\n    /**\n     * Creates a slice of `array` with `n` elements dropped from the end.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to drop.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.dropRight([1, 2, 3]);\n     * // => [1, 2]\n     *\n     * _.dropRight([1, 2, 3], 2);\n     * // => [1]\n     *\n     * _.dropRight([1, 2, 3], 5);\n     * // => []\n     *\n     * _.dropRight([1, 2, 3], 0);\n     * // => [1, 2, 3]\n     */\n    function dropRight(array, n, guard) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      n = (guard || n === undefined) ? 1 : toInteger(n);\n      n = length - n;\n      return baseSlice(array, 0, n < 0 ? 0 : n);\n    }\n\n    /**\n     * Creates a slice of `array` excluding elements dropped from the end.\n     * Elements are dropped until `predicate` returns falsey. The predicate is\n     * invoked with three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': true },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': false }\n     * ];\n     *\n     * _.dropRightWhile(users, function(o) { return !o.active; });\n     * // => objects for ['barney']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false });\n     * // => objects for ['barney', 'fred']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.dropRightWhile(users, ['active', false]);\n     * // => objects for ['barney']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.dropRightWhile(users, 'active');\n     * // => objects for ['barney', 'fred', 'pebbles']\n     */\n    function dropRightWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3), true, true)\n        : [];\n    }\n\n    /**\n     * Creates a slice of `array` excluding elements dropped from the beginning.\n     * Elements are dropped until `predicate` returns falsey. The predicate is\n     * invoked with three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': false },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': true }\n     * ];\n     *\n     * _.dropWhile(users, function(o) { return !o.active; });\n     * // => objects for ['pebbles']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.dropWhile(users, { 'user': 'barney', 'active': false });\n     * // => objects for ['fred', 'pebbles']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.dropWhile(users, ['active', false]);\n     * // => objects for ['pebbles']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.dropWhile(users, 'active');\n     * // => objects for ['barney', 'fred', 'pebbles']\n     */\n    function dropWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3), true)\n        : [];\n    }\n\n    /**\n     * Fills elements of `array` with `value` from `start` up to, but not\n     * including, `end`.\n     *\n     * **Note:** This method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.2.0\n     * @category Array\n     * @param {Array} array The array to fill.\n     * @param {*} value The value to fill `array` with.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [1, 2, 3];\n     *\n     * _.fill(array, 'a');\n     * console.log(array);\n     * // => ['a', 'a', 'a']\n     *\n     * _.fill(Array(3), 2);\n     * // => [2, 2, 2]\n     *\n     * _.fill([4, 6, 8, 10], '*', 1, 3);\n     * // => [4, '*', '*', 10]\n     */\n    function fill(array, value, start, end) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {\n        start = 0;\n        end = length;\n      }\n      return baseFill(array, value, start, end);\n    }\n\n    /**\n     * This method is like `_.find` except that it returns the index of the first\n     * element `predicate` returns truthy for instead of the element itself.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @returns {number} Returns the index of the found element, else `-1`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': false },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': true }\n     * ];\n     *\n     * _.findIndex(users, function(o) { return o.user == 'barney'; });\n     * // => 0\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findIndex(users, { 'user': 'fred', 'active': false });\n     * // => 1\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findIndex(users, ['active', false]);\n     * // => 0\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findIndex(users, 'active');\n     * // => 2\n     */\n    function findIndex(array, predicate, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = fromIndex == null ? 0 : toInteger(fromIndex);\n      if (index < 0) {\n        index = nativeMax(length + index, 0);\n      }\n      return baseFindIndex(array, getIteratee(predicate, 3), index);\n    }\n\n    /**\n     * This method is like `_.findIndex` except that it iterates over elements\n     * of `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=array.length-1] The index to search from.\n     * @returns {number} Returns the index of the found element, else `-1`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': true },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': false }\n     * ];\n     *\n     * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; });\n     * // => 2\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findLastIndex(users, { 'user': 'barney', 'active': true });\n     * // => 0\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findLastIndex(users, ['active', false]);\n     * // => 2\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findLastIndex(users, 'active');\n     * // => 0\n     */\n    function findLastIndex(array, predicate, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = length - 1;\n      if (fromIndex !== undefined) {\n        index = toInteger(fromIndex);\n        index = fromIndex < 0\n          ? nativeMax(length + index, 0)\n          : nativeMin(index, length - 1);\n      }\n      return baseFindIndex(array, getIteratee(predicate, 3), index, true);\n    }\n\n    /**\n     * Flattens `array` a single level deep.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to flatten.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * _.flatten([1, [2, [3, [4]], 5]]);\n     * // => [1, 2, [3, [4]], 5]\n     */\n    function flatten(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseFlatten(array, 1) : [];\n    }\n\n    /**\n     * Recursively flattens `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to flatten.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * _.flattenDeep([1, [2, [3, [4]], 5]]);\n     * // => [1, 2, 3, 4, 5]\n     */\n    function flattenDeep(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseFlatten(array, INFINITY) : [];\n    }\n\n    /**\n     * Recursively flatten `array` up to `depth` times.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.4.0\n     * @category Array\n     * @param {Array} array The array to flatten.\n     * @param {number} [depth=1] The maximum recursion depth.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * var array = [1, [2, [3, [4]], 5]];\n     *\n     * _.flattenDepth(array, 1);\n     * // => [1, 2, [3, [4]], 5]\n     *\n     * _.flattenDepth(array, 2);\n     * // => [1, 2, 3, [4], 5]\n     */\n    function flattenDepth(array, depth) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      depth = depth === undefined ? 1 : toInteger(depth);\n      return baseFlatten(array, depth);\n    }\n\n    /**\n     * The inverse of `_.toPairs`; this method returns an object composed\n     * from key-value `pairs`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} pairs The key-value pairs.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * _.fromPairs([['a', 1], ['b', 2]]);\n     * // => { 'a': 1, 'b': 2 }\n     */\n    function fromPairs(pairs) {\n      var index = -1,\n          length = pairs == null ? 0 : pairs.length,\n          result = {};\n\n      while (++index < length) {\n        var pair = pairs[index];\n        result[pair[0]] = pair[1];\n      }\n      return result;\n    }\n\n    /**\n     * Gets the first element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @alias first\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {*} Returns the first element of `array`.\n     * @example\n     *\n     * _.head([1, 2, 3]);\n     * // => 1\n     *\n     * _.head([]);\n     * // => undefined\n     */\n    function head(array) {\n      return (array && array.length) ? array[0] : undefined;\n    }\n\n    /**\n     * Gets the index at which the first occurrence of `value` is found in `array`\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons. If `fromIndex` is negative, it's used as the\n     * offset from the end of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.indexOf([1, 2, 1, 2], 2);\n     * // => 1\n     *\n     * // Search from the `fromIndex`.\n     * _.indexOf([1, 2, 1, 2], 2, 2);\n     * // => 3\n     */\n    function indexOf(array, value, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = fromIndex == null ? 0 : toInteger(fromIndex);\n      if (index < 0) {\n        index = nativeMax(length + index, 0);\n      }\n      return baseIndexOf(array, value, index);\n    }\n\n    /**\n     * Gets all but the last element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.initial([1, 2, 3]);\n     * // => [1, 2]\n     */\n    function initial(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseSlice(array, 0, -1) : [];\n    }\n\n    /**\n     * Creates an array of unique values that are included in all given arrays\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons. The order and references of result values are\n     * determined by the first array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @returns {Array} Returns the new array of intersecting values.\n     * @example\n     *\n     * _.intersection([2, 1], [2, 3]);\n     * // => [2]\n     */\n    var intersection = baseRest(function(arrays) {\n      var mapped = arrayMap(arrays, castArrayLikeObject);\n      return (mapped.length && mapped[0] === arrays[0])\n        ? baseIntersection(mapped)\n        : [];\n    });\n\n    /**\n     * This method is like `_.intersection` except that it accepts `iteratee`\n     * which is invoked for each element of each `arrays` to generate the criterion\n     * by which they're compared. The order and references of result values are\n     * determined by the first array. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of intersecting values.\n     * @example\n     *\n     * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n     * // => [2.1]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 1 }]\n     */\n    var intersectionBy = baseRest(function(arrays) {\n      var iteratee = last(arrays),\n          mapped = arrayMap(arrays, castArrayLikeObject);\n\n      if (iteratee === last(mapped)) {\n        iteratee = undefined;\n      } else {\n        mapped.pop();\n      }\n      return (mapped.length && mapped[0] === arrays[0])\n        ? baseIntersection(mapped, getIteratee(iteratee, 2))\n        : [];\n    });\n\n    /**\n     * This method is like `_.intersection` except that it accepts `comparator`\n     * which is invoked to compare elements of `arrays`. The order and references\n     * of result values are determined by the first array. The comparator is\n     * invoked with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of intersecting values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.intersectionWith(objects, others, _.isEqual);\n     * // => [{ 'x': 1, 'y': 2 }]\n     */\n    var intersectionWith = baseRest(function(arrays) {\n      var comparator = last(arrays),\n          mapped = arrayMap(arrays, castArrayLikeObject);\n\n      comparator = typeof comparator == 'function' ? comparator : undefined;\n      if (comparator) {\n        mapped.pop();\n      }\n      return (mapped.length && mapped[0] === arrays[0])\n        ? baseIntersection(mapped, undefined, comparator)\n        : [];\n    });\n\n    /**\n     * Converts all elements in `array` into a string separated by `separator`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to convert.\n     * @param {string} [separator=','] The element separator.\n     * @returns {string} Returns the joined string.\n     * @example\n     *\n     * _.join(['a', 'b', 'c'], '~');\n     * // => 'a~b~c'\n     */\n    function join(array, separator) {\n      return array == null ? '' : nativeJoin.call(array, separator);\n    }\n\n    /**\n     * Gets the last element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {*} Returns the last element of `array`.\n     * @example\n     *\n     * _.last([1, 2, 3]);\n     * // => 3\n     */\n    function last(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? array[length - 1] : undefined;\n    }\n\n    /**\n     * This method is like `_.indexOf` except that it iterates over elements of\n     * `array` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @param {number} [fromIndex=array.length-1] The index to search from.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.lastIndexOf([1, 2, 1, 2], 2);\n     * // => 3\n     *\n     * // Search from the `fromIndex`.\n     * _.lastIndexOf([1, 2, 1, 2], 2, 2);\n     * // => 1\n     */\n    function lastIndexOf(array, value, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = length;\n      if (fromIndex !== undefined) {\n        index = toInteger(fromIndex);\n        index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);\n      }\n      return value === value\n        ? strictLastIndexOf(array, value, index)\n        : baseFindIndex(array, baseIsNaN, index, true);\n    }\n\n    /**\n     * Gets the element at index `n` of `array`. If `n` is negative, the nth\n     * element from the end is returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.11.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=0] The index of the element to return.\n     * @returns {*} Returns the nth element of `array`.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'd'];\n     *\n     * _.nth(array, 1);\n     * // => 'b'\n     *\n     * _.nth(array, -2);\n     * // => 'c';\n     */\n    function nth(array, n) {\n      return (array && array.length) ? baseNth(array, toInteger(n)) : undefined;\n    }\n\n    /**\n     * Removes all given values from `array` using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove`\n     * to remove elements from an array by predicate.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {...*} [values] The values to remove.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'a', 'b', 'c'];\n     *\n     * _.pull(array, 'a', 'c');\n     * console.log(array);\n     * // => ['b', 'b']\n     */\n    var pull = baseRest(pullAll);\n\n    /**\n     * This method is like `_.pull` except that it accepts an array of values to remove.\n     *\n     * **Note:** Unlike `_.difference`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'a', 'b', 'c'];\n     *\n     * _.pullAll(array, ['a', 'c']);\n     * console.log(array);\n     * // => ['b', 'b']\n     */\n    function pullAll(array, values) {\n      return (array && array.length && values && values.length)\n        ? basePullAll(array, values)\n        : array;\n    }\n\n    /**\n     * This method is like `_.pullAll` except that it accepts `iteratee` which is\n     * invoked for each element of `array` and `values` to generate the criterion\n     * by which they're compared. The iteratee is invoked with one argument: (value).\n     *\n     * **Note:** Unlike `_.differenceBy`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];\n     *\n     * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');\n     * console.log(array);\n     * // => [{ 'x': 2 }]\n     */\n    function pullAllBy(array, values, iteratee) {\n      return (array && array.length && values && values.length)\n        ? basePullAll(array, values, getIteratee(iteratee, 2))\n        : array;\n    }\n\n    /**\n     * This method is like `_.pullAll` except that it accepts `comparator` which\n     * is invoked to compare elements of `array` to `values`. The comparator is\n     * invoked with two arguments: (arrVal, othVal).\n     *\n     * **Note:** Unlike `_.differenceWith`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.6.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];\n     *\n     * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);\n     * console.log(array);\n     * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]\n     */\n    function pullAllWith(array, values, comparator) {\n      return (array && array.length && values && values.length)\n        ? basePullAll(array, values, undefined, comparator)\n        : array;\n    }\n\n    /**\n     * Removes elements from `array` corresponding to `indexes` and returns an\n     * array of removed elements.\n     *\n     * **Note:** Unlike `_.at`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {...(number|number[])} [indexes] The indexes of elements to remove.\n     * @returns {Array} Returns the new array of removed elements.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'd'];\n     * var pulled = _.pullAt(array, [1, 3]);\n     *\n     * console.log(array);\n     * // => ['a', 'c']\n     *\n     * console.log(pulled);\n     * // => ['b', 'd']\n     */\n    var pullAt = flatRest(function(array, indexes) {\n      var length = array == null ? 0 : array.length,\n          result = baseAt(array, indexes);\n\n      basePullAt(array, arrayMap(indexes, function(index) {\n        return isIndex(index, length) ? +index : index;\n      }).sort(compareAscending));\n\n      return result;\n    });\n\n    /**\n     * Removes all elements from `array` that `predicate` returns truthy for\n     * and returns an array of the removed elements. The predicate is invoked\n     * with three arguments: (value, index, array).\n     *\n     * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull`\n     * to pull elements from an array by value.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new array of removed elements.\n     * @example\n     *\n     * var array = [1, 2, 3, 4];\n     * var evens = _.remove(array, function(n) {\n     *   return n % 2 == 0;\n     * });\n     *\n     * console.log(array);\n     * // => [1, 3]\n     *\n     * console.log(evens);\n     * // => [2, 4]\n     */\n    function remove(array, predicate) {\n      var result = [];\n      if (!(array && array.length)) {\n        return result;\n      }\n      var index = -1,\n          indexes = [],\n          length = array.length;\n\n      predicate = getIteratee(predicate, 3);\n      while (++index < length) {\n        var value = array[index];\n        if (predicate(value, index, array)) {\n          result.push(value);\n          indexes.push(index);\n        }\n      }\n      basePullAt(array, indexes);\n      return result;\n    }\n\n    /**\n     * Reverses `array` so that the first element becomes the last, the second\n     * element becomes the second to last, and so on.\n     *\n     * **Note:** This method mutates `array` and is based on\n     * [`Array#reverse`](https://mdn.io/Array/reverse).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [1, 2, 3];\n     *\n     * _.reverse(array);\n     * // => [3, 2, 1]\n     *\n     * console.log(array);\n     * // => [3, 2, 1]\n     */\n    function reverse(array) {\n      return array == null ? array : nativeReverse.call(array);\n    }\n\n    /**\n     * Creates a slice of `array` from `start` up to, but not including, `end`.\n     *\n     * **Note:** This method is used instead of\n     * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are\n     * returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to slice.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns the slice of `array`.\n     */\n    function slice(array, start, end) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      if (end && typeof end != 'number' && isIterateeCall(array, start, end)) {\n        start = 0;\n        end = length;\n      }\n      else {\n        start = start == null ? 0 : toInteger(start);\n        end = end === undefined ? length : toInteger(end);\n      }\n      return baseSlice(array, start, end);\n    }\n\n    /**\n     * Uses a binary search to determine the lowest index at which `value`\n     * should be inserted into `array` in order to maintain its sort order.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * _.sortedIndex([30, 50], 40);\n     * // => 1\n     */\n    function sortedIndex(array, value) {\n      return baseSortedIndex(array, value);\n    }\n\n    /**\n     * This method is like `_.sortedIndex` except that it accepts `iteratee`\n     * which is invoked for `value` and each element of `array` to compute their\n     * sort ranking. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * var objects = [{ 'x': 4 }, { 'x': 5 }];\n     *\n     * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });\n     * // => 0\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.sortedIndexBy(objects, { 'x': 4 }, 'x');\n     * // => 0\n     */\n    function sortedIndexBy(array, value, iteratee) {\n      return baseSortedIndexBy(array, value, getIteratee(iteratee, 2));\n    }\n\n    /**\n     * This method is like `_.indexOf` except that it performs a binary\n     * search on a sorted `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.sortedIndexOf([4, 5, 5, 5, 6], 5);\n     * // => 1\n     */\n    function sortedIndexOf(array, value) {\n      var length = array == null ? 0 : array.length;\n      if (length) {\n        var index = baseSortedIndex(array, value);\n        if (index < length && eq(array[index], value)) {\n          return index;\n        }\n      }\n      return -1;\n    }\n\n    /**\n     * This method is like `_.sortedIndex` except that it returns the highest\n     * index at which `value` should be inserted into `array` in order to\n     * maintain its sort order.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * _.sortedLastIndex([4, 5, 5, 5, 6], 5);\n     * // => 4\n     */\n    function sortedLastIndex(array, value) {\n      return baseSortedIndex(array, value, true);\n    }\n\n    /**\n     * This method is like `_.sortedLastIndex` except that it accepts `iteratee`\n     * which is invoked for `value` and each element of `array` to compute their\n     * sort ranking. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * var objects = [{ 'x': 4 }, { 'x': 5 }];\n     *\n     * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });\n     * // => 1\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x');\n     * // => 1\n     */\n    function sortedLastIndexBy(array, value, iteratee) {\n      return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true);\n    }\n\n    /**\n     * This method is like `_.lastIndexOf` except that it performs a binary\n     * search on a sorted `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5);\n     * // => 3\n     */\n    function sortedLastIndexOf(array, value) {\n      var length = array == null ? 0 : array.length;\n      if (length) {\n        var index = baseSortedIndex(array, value, true) - 1;\n        if (eq(array[index], value)) {\n          return index;\n        }\n      }\n      return -1;\n    }\n\n    /**\n     * This method is like `_.uniq` except that it's designed and optimized\n     * for sorted arrays.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.sortedUniq([1, 1, 2]);\n     * // => [1, 2]\n     */\n    function sortedUniq(array) {\n      return (array && array.length)\n        ? baseSortedUniq(array)\n        : [];\n    }\n\n    /**\n     * This method is like `_.uniqBy` except that it's designed and optimized\n     * for sorted arrays.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);\n     * // => [1.1, 2.3]\n     */\n    function sortedUniqBy(array, iteratee) {\n      return (array && array.length)\n        ? baseSortedUniq(array, getIteratee(iteratee, 2))\n        : [];\n    }\n\n    /**\n     * Gets all but the first element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.tail([1, 2, 3]);\n     * // => [2, 3]\n     */\n    function tail(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseSlice(array, 1, length) : [];\n    }\n\n    /**\n     * Creates a slice of `array` with `n` elements taken from the beginning.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to take.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.take([1, 2, 3]);\n     * // => [1]\n     *\n     * _.take([1, 2, 3], 2);\n     * // => [1, 2]\n     *\n     * _.take([1, 2, 3], 5);\n     * // => [1, 2, 3]\n     *\n     * _.take([1, 2, 3], 0);\n     * // => []\n     */\n    function take(array, n, guard) {\n      if (!(array && array.length)) {\n        return [];\n      }\n      n = (guard || n === undefined) ? 1 : toInteger(n);\n      return baseSlice(array, 0, n < 0 ? 0 : n);\n    }\n\n    /**\n     * Creates a slice of `array` with `n` elements taken from the end.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to take.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.takeRight([1, 2, 3]);\n     * // => [3]\n     *\n     * _.takeRight([1, 2, 3], 2);\n     * // => [2, 3]\n     *\n     * _.takeRight([1, 2, 3], 5);\n     * // => [1, 2, 3]\n     *\n     * _.takeRight([1, 2, 3], 0);\n     * // => []\n     */\n    function takeRight(array, n, guard) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      n = (guard || n === undefined) ? 1 : toInteger(n);\n      n = length - n;\n      return baseSlice(array, n < 0 ? 0 : n, length);\n    }\n\n    /**\n     * Creates a slice of `array` with elements taken from the end. Elements are\n     * taken until `predicate` returns falsey. The predicate is invoked with\n     * three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': true },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': false }\n     * ];\n     *\n     * _.takeRightWhile(users, function(o) { return !o.active; });\n     * // => objects for ['fred', 'pebbles']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false });\n     * // => objects for ['pebbles']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.takeRightWhile(users, ['active', false]);\n     * // => objects for ['fred', 'pebbles']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.takeRightWhile(users, 'active');\n     * // => []\n     */\n    function takeRightWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3), false, true)\n        : [];\n    }\n\n    /**\n     * Creates a slice of `array` with elements taken from the beginning. Elements\n     * are taken until `predicate` returns falsey. The predicate is invoked with\n     * three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': false },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': true }\n     * ];\n     *\n     * _.takeWhile(users, function(o) { return !o.active; });\n     * // => objects for ['barney', 'fred']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.takeWhile(users, { 'user': 'barney', 'active': false });\n     * // => objects for ['barney']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.takeWhile(users, ['active', false]);\n     * // => objects for ['barney', 'fred']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.takeWhile(users, 'active');\n     * // => []\n     */\n    function takeWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3))\n        : [];\n    }\n\n    /**\n     * Creates an array of unique values, in order, from all given arrays using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @returns {Array} Returns the new array of combined values.\n     * @example\n     *\n     * _.union([2], [1, 2]);\n     * // => [2, 1]\n     */\n    var union = baseRest(function(arrays) {\n      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));\n    });\n\n    /**\n     * This method is like `_.union` except that it accepts `iteratee` which is\n     * invoked for each element of each `arrays` to generate the criterion by\n     * which uniqueness is computed. Result values are chosen from the first\n     * array in which the value occurs. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of combined values.\n     * @example\n     *\n     * _.unionBy([2.1], [1.2, 2.3], Math.floor);\n     * // => [2.1, 1.2]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 1 }, { 'x': 2 }]\n     */\n    var unionBy = baseRest(function(arrays) {\n      var iteratee = last(arrays);\n      if (isArrayLikeObject(iteratee)) {\n        iteratee = undefined;\n      }\n      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee, 2));\n    });\n\n    /**\n     * This method is like `_.union` except that it accepts `comparator` which\n     * is invoked to compare elements of `arrays`. Result values are chosen from\n     * the first array in which the value occurs. The comparator is invoked\n     * with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of combined values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.unionWith(objects, others, _.isEqual);\n     * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]\n     */\n    var unionWith = baseRest(function(arrays) {\n      var comparator = last(arrays);\n      comparator = typeof comparator == 'function' ? comparator : undefined;\n      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined, comparator);\n    });\n\n    /**\n     * Creates a duplicate-free version of an array, using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons, in which only the first occurrence of each element\n     * is kept. The order of result values is determined by the order they occur\n     * in the array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.uniq([2, 1, 2]);\n     * // => [2, 1]\n     */\n    function uniq(array) {\n      return (array && array.length) ? baseUniq(array) : [];\n    }\n\n    /**\n     * This method is like `_.uniq` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the criterion by which\n     * uniqueness is computed. The order of result values is determined by the\n     * order they occur in the array. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.uniqBy([2.1, 1.2, 2.3], Math.floor);\n     * // => [2.1, 1.2]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 1 }, { 'x': 2 }]\n     */\n    function uniqBy(array, iteratee) {\n      return (array && array.length) ? baseUniq(array, getIteratee(iteratee, 2)) : [];\n    }\n\n    /**\n     * This method is like `_.uniq` except that it accepts `comparator` which\n     * is invoked to compare elements of `array`. The order of result values is\n     * determined by the order they occur in the array.The comparator is invoked\n     * with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.uniqWith(objects, _.isEqual);\n     * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]\n     */\n    function uniqWith(array, comparator) {\n      comparator = typeof comparator == 'function' ? comparator : undefined;\n      return (array && array.length) ? baseUniq(array, undefined, comparator) : [];\n    }\n\n    /**\n     * This method is like `_.zip` except that it accepts an array of grouped\n     * elements and creates an array regrouping the elements to their pre-zip\n     * configuration.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.2.0\n     * @category Array\n     * @param {Array} array The array of grouped elements to process.\n     * @returns {Array} Returns the new array of regrouped elements.\n     * @example\n     *\n     * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]);\n     * // => [['a', 1, true], ['b', 2, false]]\n     *\n     * _.unzip(zipped);\n     * // => [['a', 'b'], [1, 2], [true, false]]\n     */\n    function unzip(array) {\n      if (!(array && array.length)) {\n        return [];\n      }\n      var length = 0;\n      array = arrayFilter(array, function(group) {\n        if (isArrayLikeObject(group)) {\n          length = nativeMax(group.length, length);\n          return true;\n        }\n      });\n      return baseTimes(length, function(index) {\n        return arrayMap(array, baseProperty(index));\n      });\n    }\n\n    /**\n     * This method is like `_.unzip` except that it accepts `iteratee` to specify\n     * how regrouped values should be combined. The iteratee is invoked with the\n     * elements of each group: (...group).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.8.0\n     * @category Array\n     * @param {Array} array The array of grouped elements to process.\n     * @param {Function} [iteratee=_.identity] The function to combine\n     *  regrouped values.\n     * @returns {Array} Returns the new array of regrouped elements.\n     * @example\n     *\n     * var zipped = _.zip([1, 2], [10, 20], [100, 200]);\n     * // => [[1, 10, 100], [2, 20, 200]]\n     *\n     * _.unzipWith(zipped, _.add);\n     * // => [3, 30, 300]\n     */\n    function unzipWith(array, iteratee) {\n      if (!(array && array.length)) {\n        return [];\n      }\n      var result = unzip(array);\n      if (iteratee == null) {\n        return result;\n      }\n      return arrayMap(result, function(group) {\n        return apply(iteratee, undefined, group);\n      });\n    }\n\n    /**\n     * Creates an array excluding all given values using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * **Note:** Unlike `_.pull`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...*} [values] The values to exclude.\n     * @returns {Array} Returns the new array of filtered values.\n     * @see _.difference, _.xor\n     * @example\n     *\n     * _.without([2, 1, 2, 3], 1, 2);\n     * // => [3]\n     */\n    var without = baseRest(function(array, values) {\n      return isArrayLikeObject(array)\n        ? baseDifference(array, values)\n        : [];\n    });\n\n    /**\n     * Creates an array of unique values that is the\n     * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)\n     * of the given arrays. The order of result values is determined by the order\n     * they occur in the arrays.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @returns {Array} Returns the new array of filtered values.\n     * @see _.difference, _.without\n     * @example\n     *\n     * _.xor([2, 1], [2, 3]);\n     * // => [1, 3]\n     */\n    var xor = baseRest(function(arrays) {\n      return baseXor(arrayFilter(arrays, isArrayLikeObject));\n    });\n\n    /**\n     * This method is like `_.xor` except that it accepts `iteratee` which is\n     * invoked for each element of each `arrays` to generate the criterion by\n     * which by which they're compared. The order of result values is determined\n     * by the order they occur in the arrays. The iteratee is invoked with one\n     * argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n     * // => [1.2, 3.4]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 2 }]\n     */\n    var xorBy = baseRest(function(arrays) {\n      var iteratee = last(arrays);\n      if (isArrayLikeObject(iteratee)) {\n        iteratee = undefined;\n      }\n      return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee, 2));\n    });\n\n    /**\n     * This method is like `_.xor` except that it accepts `comparator` which is\n     * invoked to compare elements of `arrays`. The order of result values is\n     * determined by the order they occur in the arrays. The comparator is invoked\n     * with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.xorWith(objects, others, _.isEqual);\n     * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]\n     */\n    var xorWith = baseRest(function(arrays) {\n      var comparator = last(arrays);\n      comparator = typeof comparator == 'function' ? comparator : undefined;\n      return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined, comparator);\n    });\n\n    /**\n     * Creates an array of grouped elements, the first of which contains the\n     * first elements of the given arrays, the second of which contains the\n     * second elements of the given arrays, and so on.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to process.\n     * @returns {Array} Returns the new array of grouped elements.\n     * @example\n     *\n     * _.zip(['a', 'b'], [1, 2], [true, false]);\n     * // => [['a', 1, true], ['b', 2, false]]\n     */\n    var zip = baseRest(unzip);\n\n    /**\n     * This method is like `_.fromPairs` except that it accepts two arrays,\n     * one of property identifiers and one of corresponding values.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.4.0\n     * @category Array\n     * @param {Array} [props=[]] The property identifiers.\n     * @param {Array} [values=[]] The property values.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * _.zipObject(['a', 'b'], [1, 2]);\n     * // => { 'a': 1, 'b': 2 }\n     */\n    function zipObject(props, values) {\n      return baseZipObject(props || [], values || [], assignValue);\n    }\n\n    /**\n     * This method is like `_.zipObject` except that it supports property paths.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.1.0\n     * @category Array\n     * @param {Array} [props=[]] The property identifiers.\n     * @param {Array} [values=[]] The property values.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);\n     * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }\n     */\n    function zipObjectDeep(props, values) {\n      return baseZipObject(props || [], values || [], baseSet);\n    }\n\n    /**\n     * This method is like `_.zip` except that it accepts `iteratee` to specify\n     * how grouped values should be combined. The iteratee is invoked with the\n     * elements of each group: (...group).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.8.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to process.\n     * @param {Function} [iteratee=_.identity] The function to combine\n     *  grouped values.\n     * @returns {Array} Returns the new array of grouped elements.\n     * @example\n     *\n     * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {\n     *   return a + b + c;\n     * });\n     * // => [111, 222]\n     */\n    var zipWith = baseRest(function(arrays) {\n      var length = arrays.length,\n          iteratee = length > 1 ? arrays[length - 1] : undefined;\n\n      iteratee = typeof iteratee == 'function' ? (arrays.pop(), iteratee) : undefined;\n      return unzipWith(arrays, iteratee);\n    });\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a `lodash` wrapper instance that wraps `value` with explicit method\n     * chain sequences enabled. The result of such sequences must be unwrapped\n     * with `_#value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.3.0\n     * @category Seq\n     * @param {*} value The value to wrap.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'age': 36 },\n     *   { 'user': 'fred',    'age': 40 },\n     *   { 'user': 'pebbles', 'age': 1 }\n     * ];\n     *\n     * var youngest = _\n     *   .chain(users)\n     *   .sortBy('age')\n     *   .map(function(o) {\n     *     return o.user + ' is ' + o.age;\n     *   })\n     *   .head()\n     *   .value();\n     * // => 'pebbles is 1'\n     */\n    function chain(value) {\n      var result = lodash(value);\n      result.__chain__ = true;\n      return result;\n    }\n\n    /**\n     * This method invokes `interceptor` and returns `value`. The interceptor\n     * is invoked with one argument; (value). The purpose of this method is to\n     * \"tap into\" a method chain sequence in order to modify intermediate results.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Seq\n     * @param {*} value The value to provide to `interceptor`.\n     * @param {Function} interceptor The function to invoke.\n     * @returns {*} Returns `value`.\n     * @example\n     *\n     * _([1, 2, 3])\n     *  .tap(function(array) {\n     *    // Mutate input array.\n     *    array.pop();\n     *  })\n     *  .reverse()\n     *  .value();\n     * // => [2, 1]\n     */\n    function tap(value, interceptor) {\n      interceptor(value);\n      return value;\n    }\n\n    /**\n     * This method is like `_.tap` except that it returns the result of `interceptor`.\n     * The purpose of this method is to \"pass thru\" values replacing intermediate\n     * results in a method chain sequence.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Seq\n     * @param {*} value The value to provide to `interceptor`.\n     * @param {Function} interceptor The function to invoke.\n     * @returns {*} Returns the result of `interceptor`.\n     * @example\n     *\n     * _('  abc  ')\n     *  .chain()\n     *  .trim()\n     *  .thru(function(value) {\n     *    return [value];\n     *  })\n     *  .value();\n     * // => ['abc']\n     */\n    function thru(value, interceptor) {\n      return interceptor(value);\n    }\n\n    /**\n     * This method is the wrapper version of `_.at`.\n     *\n     * @name at\n     * @memberOf _\n     * @since 1.0.0\n     * @category Seq\n     * @param {...(string|string[])} [paths] The property paths to pick.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };\n     *\n     * _(object).at(['a[0].b.c', 'a[1]']).value();\n     * // => [3, 4]\n     */\n    var wrapperAt = flatRest(function(paths) {\n      var length = paths.length,\n          start = length ? paths[0] : 0,\n          value = this.__wrapped__,\n          interceptor = function(object) { return baseAt(object, paths); };\n\n      if (length > 1 || this.__actions__.length ||\n          !(value instanceof LazyWrapper) || !isIndex(start)) {\n        return this.thru(interceptor);\n      }\n      value = value.slice(start, +start + (length ? 1 : 0));\n      value.__actions__.push({\n        'func': thru,\n        'args': [interceptor],\n        'thisArg': undefined\n      });\n      return new LodashWrapper(value, this.__chain__).thru(function(array) {\n        if (length && !array.length) {\n          array.push(undefined);\n        }\n        return array;\n      });\n    });\n\n    /**\n     * Creates a `lodash` wrapper instance with explicit method chain sequences enabled.\n     *\n     * @name chain\n     * @memberOf _\n     * @since 0.1.0\n     * @category Seq\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36 },\n     *   { 'user': 'fred',   'age': 40 }\n     * ];\n     *\n     * // A sequence without explicit chaining.\n     * _(users).head();\n     * // => { 'user': 'barney', 'age': 36 }\n     *\n     * // A sequence with explicit chaining.\n     * _(users)\n     *   .chain()\n     *   .head()\n     *   .pick('user')\n     *   .value();\n     * // => { 'user': 'barney' }\n     */\n    function wrapperChain() {\n      return chain(this);\n    }\n\n    /**\n     * Executes the chain sequence and returns the wrapped result.\n     *\n     * @name commit\n     * @memberOf _\n     * @since 3.2.0\n     * @category Seq\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var array = [1, 2];\n     * var wrapped = _(array).push(3);\n     *\n     * console.log(array);\n     * // => [1, 2]\n     *\n     * wrapped = wrapped.commit();\n     * console.log(array);\n     * // => [1, 2, 3]\n     *\n     * wrapped.last();\n     * // => 3\n     *\n     * console.log(array);\n     * // => [1, 2, 3]\n     */\n    function wrapperCommit() {\n      return new LodashWrapper(this.value(), this.__chain__);\n    }\n\n    /**\n     * Gets the next value on a wrapped object following the\n     * [iterator protocol](https://mdn.io/iteration_protocols#iterator).\n     *\n     * @name next\n     * @memberOf _\n     * @since 4.0.0\n     * @category Seq\n     * @returns {Object} Returns the next iterator value.\n     * @example\n     *\n     * var wrapped = _([1, 2]);\n     *\n     * wrapped.next();\n     * // => { 'done': false, 'value': 1 }\n     *\n     * wrapped.next();\n     * // => { 'done': false, 'value': 2 }\n     *\n     * wrapped.next();\n     * // => { 'done': true, 'value': undefined }\n     */\n    function wrapperNext() {\n      if (this.__values__ === undefined) {\n        this.__values__ = toArray(this.value());\n      }\n      var done = this.__index__ >= this.__values__.length,\n          value = done ? undefined : this.__values__[this.__index__++];\n\n      return { 'done': done, 'value': value };\n    }\n\n    /**\n     * Enables the wrapper to be iterable.\n     *\n     * @name Symbol.iterator\n     * @memberOf _\n     * @since 4.0.0\n     * @category Seq\n     * @returns {Object} Returns the wrapper object.\n     * @example\n     *\n     * var wrapped = _([1, 2]);\n     *\n     * wrapped[Symbol.iterator]() === wrapped;\n     * // => true\n     *\n     * Array.from(wrapped);\n     * // => [1, 2]\n     */\n    function wrapperToIterator() {\n      return this;\n    }\n\n    /**\n     * Creates a clone of the chain sequence planting `value` as the wrapped value.\n     *\n     * @name plant\n     * @memberOf _\n     * @since 3.2.0\n     * @category Seq\n     * @param {*} value The value to plant.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var wrapped = _([1, 2]).map(square);\n     * var other = wrapped.plant([3, 4]);\n     *\n     * other.value();\n     * // => [9, 16]\n     *\n     * wrapped.value();\n     * // => [1, 4]\n     */\n    function wrapperPlant(value) {\n      var result,\n          parent = this;\n\n      while (parent instanceof baseLodash) {\n        var clone = wrapperClone(parent);\n        clone.__index__ = 0;\n        clone.__values__ = undefined;\n        if (result) {\n          previous.__wrapped__ = clone;\n        } else {\n          result = clone;\n        }\n        var previous = clone;\n        parent = parent.__wrapped__;\n      }\n      previous.__wrapped__ = value;\n      return result;\n    }\n\n    /**\n     * This method is the wrapper version of `_.reverse`.\n     *\n     * **Note:** This method mutates the wrapped array.\n     *\n     * @name reverse\n     * @memberOf _\n     * @since 0.1.0\n     * @category Seq\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var array = [1, 2, 3];\n     *\n     * _(array).reverse().value()\n     * // => [3, 2, 1]\n     *\n     * console.log(array);\n     * // => [3, 2, 1]\n     */\n    function wrapperReverse() {\n      var value = this.__wrapped__;\n      if (value instanceof LazyWrapper) {\n        var wrapped = value;\n        if (this.__actions__.length) {\n          wrapped = new LazyWrapper(this);\n        }\n        wrapped = wrapped.reverse();\n        wrapped.__actions__.push({\n          'func': thru,\n          'args': [reverse],\n          'thisArg': undefined\n        });\n        return new LodashWrapper(wrapped, this.__chain__);\n      }\n      return this.thru(reverse);\n    }\n\n    /**\n     * Executes the chain sequence to resolve the unwrapped value.\n     *\n     * @name value\n     * @memberOf _\n     * @since 0.1.0\n     * @alias toJSON, valueOf\n     * @category Seq\n     * @returns {*} Returns the resolved unwrapped value.\n     * @example\n     *\n     * _([1, 2, 3]).value();\n     * // => [1, 2, 3]\n     */\n    function wrapperValue() {\n      return baseWrapperValue(this.__wrapped__, this.__actions__);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an object composed of keys generated from the results of running\n     * each element of `collection` thru `iteratee`. The corresponding value of\n     * each key is the number of times the key was returned by `iteratee`. The\n     * iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.5.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * _.countBy([6.1, 4.2, 6.3], Math.floor);\n     * // => { '4': 1, '6': 2 }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.countBy(['one', 'two', 'three'], 'length');\n     * // => { '3': 2, '5': 1 }\n     */\n    var countBy = createAggregator(function(result, value, key) {\n      if (hasOwnProperty.call(result, key)) {\n        ++result[key];\n      } else {\n        baseAssignValue(result, key, 1);\n      }\n    });\n\n    /**\n     * Checks if `predicate` returns truthy for **all** elements of `collection`.\n     * Iteration is stopped once `predicate` returns falsey. The predicate is\n     * invoked with three arguments: (value, index|key, collection).\n     *\n     * **Note:** This method returns `true` for\n     * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because\n     * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of\n     * elements of empty collections.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {boolean} Returns `true` if all elements pass the predicate check,\n     *  else `false`.\n     * @example\n     *\n     * _.every([true, 1, null, 'yes'], Boolean);\n     * // => false\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': false },\n     *   { 'user': 'fred',   'age': 40, 'active': false }\n     * ];\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.every(users, { 'user': 'barney', 'active': false });\n     * // => false\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.every(users, ['active', false]);\n     * // => true\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.every(users, 'active');\n     * // => false\n     */\n    function every(collection, predicate, guard) {\n      var func = isArray(collection) ? arrayEvery : baseEvery;\n      if (guard && isIterateeCall(collection, predicate, guard)) {\n        predicate = undefined;\n      }\n      return func(collection, getIteratee(predicate, 3));\n    }\n\n    /**\n     * Iterates over elements of `collection`, returning an array of all elements\n     * `predicate` returns truthy for. The predicate is invoked with three\n     * arguments: (value, index|key, collection).\n     *\n     * **Note:** Unlike `_.remove`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new filtered array.\n     * @see _.reject\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': true },\n     *   { 'user': 'fred',   'age': 40, 'active': false }\n     * ];\n     *\n     * _.filter(users, function(o) { return !o.active; });\n     * // => objects for ['fred']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.filter(users, { 'age': 36, 'active': true });\n     * // => objects for ['barney']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.filter(users, ['active', false]);\n     * // => objects for ['fred']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.filter(users, 'active');\n     * // => objects for ['barney']\n     */\n    function filter(collection, predicate) {\n      var func = isArray(collection) ? arrayFilter : baseFilter;\n      return func(collection, getIteratee(predicate, 3));\n    }\n\n    /**\n     * Iterates over elements of `collection`, returning the first element\n     * `predicate` returns truthy for. The predicate is invoked with three\n     * arguments: (value, index|key, collection).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @returns {*} Returns the matched element, else `undefined`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'age': 36, 'active': true },\n     *   { 'user': 'fred',    'age': 40, 'active': false },\n     *   { 'user': 'pebbles', 'age': 1,  'active': true }\n     * ];\n     *\n     * _.find(users, function(o) { return o.age < 40; });\n     * // => object for 'barney'\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.find(users, { 'age': 1, 'active': true });\n     * // => object for 'pebbles'\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.find(users, ['active', false]);\n     * // => object for 'fred'\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.find(users, 'active');\n     * // => object for 'barney'\n     */\n    var find = createFind(findIndex);\n\n    /**\n     * This method is like `_.find` except that it iterates over elements of\n     * `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=collection.length-1] The index to search from.\n     * @returns {*} Returns the matched element, else `undefined`.\n     * @example\n     *\n     * _.findLast([1, 2, 3, 4], function(n) {\n     *   return n % 2 == 1;\n     * });\n     * // => 3\n     */\n    var findLast = createFind(findLastIndex);\n\n    /**\n     * Creates a flattened array of values by running each element in `collection`\n     * thru `iteratee` and flattening the mapped results. The iteratee is invoked\n     * with three arguments: (value, index|key, collection).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * function duplicate(n) {\n     *   return [n, n];\n     * }\n     *\n     * _.flatMap([1, 2], duplicate);\n     * // => [1, 1, 2, 2]\n     */\n    function flatMap(collection, iteratee) {\n      return baseFlatten(map(collection, iteratee), 1);\n    }\n\n    /**\n     * This method is like `_.flatMap` except that it recursively flattens the\n     * mapped results.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * function duplicate(n) {\n     *   return [[[n, n]]];\n     * }\n     *\n     * _.flatMapDeep([1, 2], duplicate);\n     * // => [1, 1, 2, 2]\n     */\n    function flatMapDeep(collection, iteratee) {\n      return baseFlatten(map(collection, iteratee), INFINITY);\n    }\n\n    /**\n     * This method is like `_.flatMap` except that it recursively flattens the\n     * mapped results up to `depth` times.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {number} [depth=1] The maximum recursion depth.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * function duplicate(n) {\n     *   return [[[n, n]]];\n     * }\n     *\n     * _.flatMapDepth([1, 2], duplicate, 2);\n     * // => [[1, 1], [2, 2]]\n     */\n    function flatMapDepth(collection, iteratee, depth) {\n      depth = depth === undefined ? 1 : toInteger(depth);\n      return baseFlatten(map(collection, iteratee), depth);\n    }\n\n    /**\n     * Iterates over elements of `collection` and invokes `iteratee` for each element.\n     * The iteratee is invoked with three arguments: (value, index|key, collection).\n     * Iteratee functions may exit iteration early by explicitly returning `false`.\n     *\n     * **Note:** As with other \"Collections\" methods, objects with a \"length\"\n     * property are iterated like arrays. To avoid this behavior use `_.forIn`\n     * or `_.forOwn` for object iteration.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @alias each\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     * @see _.forEachRight\n     * @example\n     *\n     * _.forEach([1, 2], function(value) {\n     *   console.log(value);\n     * });\n     * // => Logs `1` then `2`.\n     *\n     * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'a' then 'b' (iteration order is not guaranteed).\n     */\n    function forEach(collection, iteratee) {\n      var func = isArray(collection) ? arrayEach : baseEach;\n      return func(collection, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * This method is like `_.forEach` except that it iterates over elements of\n     * `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @alias eachRight\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     * @see _.forEach\n     * @example\n     *\n     * _.forEachRight([1, 2], function(value) {\n     *   console.log(value);\n     * });\n     * // => Logs `2` then `1`.\n     */\n    function forEachRight(collection, iteratee) {\n      var func = isArray(collection) ? arrayEachRight : baseEachRight;\n      return func(collection, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * Creates an object composed of keys generated from the results of running\n     * each element of `collection` thru `iteratee`. The order of grouped values\n     * is determined by the order they occur in `collection`. The corresponding\n     * value of each key is an array of elements responsible for generating the\n     * key. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * _.groupBy([6.1, 4.2, 6.3], Math.floor);\n     * // => { '4': [4.2], '6': [6.1, 6.3] }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.groupBy(['one', 'two', 'three'], 'length');\n     * // => { '3': ['one', 'two'], '5': ['three'] }\n     */\n    var groupBy = createAggregator(function(result, value, key) {\n      if (hasOwnProperty.call(result, key)) {\n        result[key].push(value);\n      } else {\n        baseAssignValue(result, key, [value]);\n      }\n    });\n\n    /**\n     * Checks if `value` is in `collection`. If `collection` is a string, it's\n     * checked for a substring of `value`, otherwise\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * is used for equality comparisons. If `fromIndex` is negative, it's used as\n     * the offset from the end of `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to inspect.\n     * @param {*} value The value to search for.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.\n     * @returns {boolean} Returns `true` if `value` is found, else `false`.\n     * @example\n     *\n     * _.includes([1, 2, 3], 1);\n     * // => true\n     *\n     * _.includes([1, 2, 3], 1, 2);\n     * // => false\n     *\n     * _.includes({ 'a': 1, 'b': 2 }, 1);\n     * // => true\n     *\n     * _.includes('abcd', 'bc');\n     * // => true\n     */\n    function includes(collection, value, fromIndex, guard) {\n      collection = isArrayLike(collection) ? collection : values(collection);\n      fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0;\n\n      var length = collection.length;\n      if (fromIndex < 0) {\n        fromIndex = nativeMax(length + fromIndex, 0);\n      }\n      return isString(collection)\n        ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)\n        : (!!length && baseIndexOf(collection, value, fromIndex) > -1);\n    }\n\n    /**\n     * Invokes the method at `path` of each element in `collection`, returning\n     * an array of the results of each invoked method. Any additional arguments\n     * are provided to each invoked method. If `path` is a function, it's invoked\n     * for, and `this` bound to, each element in `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Array|Function|string} path The path of the method to invoke or\n     *  the function invoked per iteration.\n     * @param {...*} [args] The arguments to invoke each method with.\n     * @returns {Array} Returns the array of results.\n     * @example\n     *\n     * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');\n     * // => [[1, 5, 7], [1, 2, 3]]\n     *\n     * _.invokeMap([123, 456], String.prototype.split, '');\n     * // => [['1', '2', '3'], ['4', '5', '6']]\n     */\n    var invokeMap = baseRest(function(collection, path, args) {\n      var index = -1,\n          isFunc = typeof path == 'function',\n          result = isArrayLike(collection) ? Array(collection.length) : [];\n\n      baseEach(collection, function(value) {\n        result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);\n      });\n      return result;\n    });\n\n    /**\n     * Creates an object composed of keys generated from the results of running\n     * each element of `collection` thru `iteratee`. The corresponding value of\n     * each key is the last element responsible for generating the key. The\n     * iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * var array = [\n     *   { 'dir': 'left', 'code': 97 },\n     *   { 'dir': 'right', 'code': 100 }\n     * ];\n     *\n     * _.keyBy(array, function(o) {\n     *   return String.fromCharCode(o.code);\n     * });\n     * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }\n     *\n     * _.keyBy(array, 'dir');\n     * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }\n     */\n    var keyBy = createAggregator(function(result, value, key) {\n      baseAssignValue(result, key, value);\n    });\n\n    /**\n     * Creates an array of values by running each element in `collection` thru\n     * `iteratee`. The iteratee is invoked with three arguments:\n     * (value, index|key, collection).\n     *\n     * Many lodash methods are guarded to work as iteratees for methods like\n     * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.\n     *\n     * The guarded methods are:\n     * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,\n     * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,\n     * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,\n     * `template`, `trim`, `trimEnd`, `trimStart`, and `words`\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new mapped array.\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * _.map([4, 8], square);\n     * // => [16, 64]\n     *\n     * _.map({ 'a': 4, 'b': 8 }, square);\n     * // => [16, 64] (iteration order is not guaranteed)\n     *\n     * var users = [\n     *   { 'user': 'barney' },\n     *   { 'user': 'fred' }\n     * ];\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.map(users, 'user');\n     * // => ['barney', 'fred']\n     */\n    function map(collection, iteratee) {\n      var func = isArray(collection) ? arrayMap : baseMap;\n      return func(collection, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * This method is like `_.sortBy` except that it allows specifying the sort\n     * orders of the iteratees to sort by. If `orders` is unspecified, all values\n     * are sorted in ascending order. Otherwise, specify an order of \"desc\" for\n     * descending or \"asc\" for ascending sort order of corresponding values.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]]\n     *  The iteratees to sort by.\n     * @param {string[]} [orders] The sort orders of `iteratees`.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.\n     * @returns {Array} Returns the new sorted array.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'fred',   'age': 48 },\n     *   { 'user': 'barney', 'age': 34 },\n     *   { 'user': 'fred',   'age': 40 },\n     *   { 'user': 'barney', 'age': 36 }\n     * ];\n     *\n     * // Sort by `user` in ascending order and by `age` in descending order.\n     * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);\n     * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]\n     */\n    function orderBy(collection, iteratees, orders, guard) {\n      if (collection == null) {\n        return [];\n      }\n      if (!isArray(iteratees)) {\n        iteratees = iteratees == null ? [] : [iteratees];\n      }\n      orders = guard ? undefined : orders;\n      if (!isArray(orders)) {\n        orders = orders == null ? [] : [orders];\n      }\n      return baseOrderBy(collection, iteratees, orders);\n    }\n\n    /**\n     * Creates an array of elements split into two groups, the first of which\n     * contains elements `predicate` returns truthy for, the second of which\n     * contains elements `predicate` returns falsey for. The predicate is\n     * invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the array of grouped elements.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'age': 36, 'active': false },\n     *   { 'user': 'fred',    'age': 40, 'active': true },\n     *   { 'user': 'pebbles', 'age': 1,  'active': false }\n     * ];\n     *\n     * _.partition(users, function(o) { return o.active; });\n     * // => objects for [['fred'], ['barney', 'pebbles']]\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.partition(users, { 'age': 1, 'active': false });\n     * // => objects for [['pebbles'], ['barney', 'fred']]\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.partition(users, ['active', false]);\n     * // => objects for [['barney', 'pebbles'], ['fred']]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.partition(users, 'active');\n     * // => objects for [['fred'], ['barney', 'pebbles']]\n     */\n    var partition = createAggregator(function(result, value, key) {\n      result[key ? 0 : 1].push(value);\n    }, function() { return [[], []]; });\n\n    /**\n     * Reduces `collection` to a value which is the accumulated result of running\n     * each element in `collection` thru `iteratee`, where each successive\n     * invocation is supplied the return value of the previous. If `accumulator`\n     * is not given, the first element of `collection` is used as the initial\n     * value. The iteratee is invoked with four arguments:\n     * (accumulator, value, index|key, collection).\n     *\n     * Many lodash methods are guarded to work as iteratees for methods like\n     * `_.reduce`, `_.reduceRight`, and `_.transform`.\n     *\n     * The guarded methods are:\n     * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,\n     * and `sortBy`\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [accumulator] The initial value.\n     * @returns {*} Returns the accumulated value.\n     * @see _.reduceRight\n     * @example\n     *\n     * _.reduce([1, 2], function(sum, n) {\n     *   return sum + n;\n     * }, 0);\n     * // => 3\n     *\n     * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {\n     *   (result[value] || (result[value] = [])).push(key);\n     *   return result;\n     * }, {});\n     * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)\n     */\n    function reduce(collection, iteratee, accumulator) {\n      var func = isArray(collection) ? arrayReduce : baseReduce,\n          initAccum = arguments.length < 3;\n\n      return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEach);\n    }\n\n    /**\n     * This method is like `_.reduce` except that it iterates over elements of\n     * `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [accumulator] The initial value.\n     * @returns {*} Returns the accumulated value.\n     * @see _.reduce\n     * @example\n     *\n     * var array = [[0, 1], [2, 3], [4, 5]];\n     *\n     * _.reduceRight(array, function(flattened, other) {\n     *   return flattened.concat(other);\n     * }, []);\n     * // => [4, 5, 2, 3, 0, 1]\n     */\n    function reduceRight(collection, iteratee, accumulator) {\n      var func = isArray(collection) ? arrayReduceRight : baseReduce,\n          initAccum = arguments.length < 3;\n\n      return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEachRight);\n    }\n\n    /**\n     * The opposite of `_.filter`; this method returns the elements of `collection`\n     * that `predicate` does **not** return truthy for.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new filtered array.\n     * @see _.filter\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': false },\n     *   { 'user': 'fred',   'age': 40, 'active': true }\n     * ];\n     *\n     * _.reject(users, function(o) { return !o.active; });\n     * // => objects for ['fred']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.reject(users, { 'age': 40, 'active': true });\n     * // => objects for ['barney']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.reject(users, ['active', false]);\n     * // => objects for ['fred']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.reject(users, 'active');\n     * // => objects for ['barney']\n     */\n    function reject(collection, predicate) {\n      var func = isArray(collection) ? arrayFilter : baseFilter;\n      return func(collection, negate(getIteratee(predicate, 3)));\n    }\n\n    /**\n     * Gets a random element from `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to sample.\n     * @returns {*} Returns the random element.\n     * @example\n     *\n     * _.sample([1, 2, 3, 4]);\n     * // => 2\n     */\n    function sample(collection) {\n      var func = isArray(collection) ? arraySample : baseSample;\n      return func(collection);\n    }\n\n    /**\n     * Gets `n` random elements at unique keys from `collection` up to the\n     * size of `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to sample.\n     * @param {number} [n=1] The number of elements to sample.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the random elements.\n     * @example\n     *\n     * _.sampleSize([1, 2, 3], 2);\n     * // => [3, 1]\n     *\n     * _.sampleSize([1, 2, 3], 4);\n     * // => [2, 3, 1]\n     */\n    function sampleSize(collection, n, guard) {\n      if ((guard ? isIterateeCall(collection, n, guard) : n === undefined)) {\n        n = 1;\n      } else {\n        n = toInteger(n);\n      }\n      var func = isArray(collection) ? arraySampleSize : baseSampleSize;\n      return func(collection, n);\n    }\n\n    /**\n     * Creates an array of shuffled values, using a version of the\n     * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to shuffle.\n     * @returns {Array} Returns the new shuffled array.\n     * @example\n     *\n     * _.shuffle([1, 2, 3, 4]);\n     * // => [4, 1, 3, 2]\n     */\n    function shuffle(collection) {\n      var func = isArray(collection) ? arrayShuffle : baseShuffle;\n      return func(collection);\n    }\n\n    /**\n     * Gets the size of `collection` by returning its length for array-like\n     * values or the number of own enumerable string keyed properties for objects.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to inspect.\n     * @returns {number} Returns the collection size.\n     * @example\n     *\n     * _.size([1, 2, 3]);\n     * // => 3\n     *\n     * _.size({ 'a': 1, 'b': 2 });\n     * // => 2\n     *\n     * _.size('pebbles');\n     * // => 7\n     */\n    function size(collection) {\n      if (collection == null) {\n        return 0;\n      }\n      if (isArrayLike(collection)) {\n        return isString(collection) ? stringSize(collection) : collection.length;\n      }\n      var tag = getTag(collection);\n      if (tag == mapTag || tag == setTag) {\n        return collection.size;\n      }\n      return baseKeys(collection).length;\n    }\n\n    /**\n     * Checks if `predicate` returns truthy for **any** element of `collection`.\n     * Iteration is stopped once `predicate` returns truthy. The predicate is\n     * invoked with three arguments: (value, index|key, collection).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {boolean} Returns `true` if any element passes the predicate check,\n     *  else `false`.\n     * @example\n     *\n     * _.some([null, 0, 'yes', false], Boolean);\n     * // => true\n     *\n     * var users = [\n     *   { 'user': 'barney', 'active': true },\n     *   { 'user': 'fred',   'active': false }\n     * ];\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.some(users, { 'user': 'barney', 'active': false });\n     * // => false\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.some(users, ['active', false]);\n     * // => true\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.some(users, 'active');\n     * // => true\n     */\n    function some(collection, predicate, guard) {\n      var func = isArray(collection) ? arraySome : baseSome;\n      if (guard && isIterateeCall(collection, predicate, guard)) {\n        predicate = undefined;\n      }\n      return func(collection, getIteratee(predicate, 3));\n    }\n\n    /**\n     * Creates an array of elements, sorted in ascending order by the results of\n     * running each element in a collection thru each iteratee. This method\n     * performs a stable sort, that is, it preserves the original sort order of\n     * equal elements. The iteratees are invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {...(Function|Function[])} [iteratees=[_.identity]]\n     *  The iteratees to sort by.\n     * @returns {Array} Returns the new sorted array.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'fred',   'age': 48 },\n     *   { 'user': 'barney', 'age': 36 },\n     *   { 'user': 'fred',   'age': 40 },\n     *   { 'user': 'barney', 'age': 34 }\n     * ];\n     *\n     * _.sortBy(users, [function(o) { return o.user; }]);\n     * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]\n     *\n     * _.sortBy(users, ['user', 'age']);\n     * // => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]]\n     */\n    var sortBy = baseRest(function(collection, iteratees) {\n      if (collection == null) {\n        return [];\n      }\n      var length = iteratees.length;\n      if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {\n        iteratees = [];\n      } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {\n        iteratees = [iteratees[0]];\n      }\n      return baseOrderBy(collection, baseFlatten(iteratees, 1), []);\n    });\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Gets the timestamp of the number of milliseconds that have elapsed since\n     * the Unix epoch (1 January 1970 00:00:00 UTC).\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Date\n     * @returns {number} Returns the timestamp.\n     * @example\n     *\n     * _.defer(function(stamp) {\n     *   console.log(_.now() - stamp);\n     * }, _.now());\n     * // => Logs the number of milliseconds it took for the deferred invocation.\n     */\n    var now = ctxNow || function() {\n      return root.Date.now();\n    };\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * The opposite of `_.before`; this method creates a function that invokes\n     * `func` once it's called `n` or more times.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {number} n The number of calls before `func` is invoked.\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * var saves = ['profile', 'settings'];\n     *\n     * var done = _.after(saves.length, function() {\n     *   console.log('done saving!');\n     * });\n     *\n     * _.forEach(saves, function(type) {\n     *   asyncSave({ 'type': type, 'complete': done });\n     * });\n     * // => Logs 'done saving!' after the two async saves have completed.\n     */\n    function after(n, func) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      n = toInteger(n);\n      return function() {\n        if (--n < 1) {\n          return func.apply(this, arguments);\n        }\n      };\n    }\n\n    /**\n     * Creates a function that invokes `func`, with up to `n` arguments,\n     * ignoring any additional arguments.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} func The function to cap arguments for.\n     * @param {number} [n=func.length] The arity cap.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the new capped function.\n     * @example\n     *\n     * _.map(['6', '8', '10'], _.ary(parseInt, 1));\n     * // => [6, 8, 10]\n     */\n    function ary(func, n, guard) {\n      n = guard ? undefined : n;\n      n = (func && n == null) ? func.length : n;\n      return createWrap(func, WRAP_ARY_FLAG, undefined, undefined, undefined, undefined, n);\n    }\n\n    /**\n     * Creates a function that invokes `func`, with the `this` binding and arguments\n     * of the created function, while it's called less than `n` times. Subsequent\n     * calls to the created function return the result of the last `func` invocation.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {number} n The number of calls at which `func` is no longer invoked.\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * jQuery(element).on('click', _.before(5, addContactToList));\n     * // => Allows adding up to 4 contacts to the list.\n     */\n    function before(n, func) {\n      var result;\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      n = toInteger(n);\n      return function() {\n        if (--n > 0) {\n          result = func.apply(this, arguments);\n        }\n        if (n <= 1) {\n          func = undefined;\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Creates a function that invokes `func` with the `this` binding of `thisArg`\n     * and `partials` prepended to the arguments it receives.\n     *\n     * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,\n     * may be used as a placeholder for partially applied arguments.\n     *\n     * **Note:** Unlike native `Function#bind`, this method doesn't set the \"length\"\n     * property of bound functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to bind.\n     * @param {*} thisArg The `this` binding of `func`.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new bound function.\n     * @example\n     *\n     * function greet(greeting, punctuation) {\n     *   return greeting + ' ' + this.user + punctuation;\n     * }\n     *\n     * var object = { 'user': 'fred' };\n     *\n     * var bound = _.bind(greet, object, 'hi');\n     * bound('!');\n     * // => 'hi fred!'\n     *\n     * // Bound with placeholders.\n     * var bound = _.bind(greet, object, _, '!');\n     * bound('hi');\n     * // => 'hi fred!'\n     */\n    var bind = baseRest(function(func, thisArg, partials) {\n      var bitmask = WRAP_BIND_FLAG;\n      if (partials.length) {\n        var holders = replaceHolders(partials, getHolder(bind));\n        bitmask |= WRAP_PARTIAL_FLAG;\n      }\n      return createWrap(func, bitmask, thisArg, partials, holders);\n    });\n\n    /**\n     * Creates a function that invokes the method at `object[key]` with `partials`\n     * prepended to the arguments it receives.\n     *\n     * This method differs from `_.bind` by allowing bound functions to reference\n     * methods that may be redefined or don't yet exist. See\n     * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern)\n     * for more details.\n     *\n     * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for partially applied arguments.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.10.0\n     * @category Function\n     * @param {Object} object The object to invoke the method on.\n     * @param {string} key The key of the method.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new bound function.\n     * @example\n     *\n     * var object = {\n     *   'user': 'fred',\n     *   'greet': function(greeting, punctuation) {\n     *     return greeting + ' ' + this.user + punctuation;\n     *   }\n     * };\n     *\n     * var bound = _.bindKey(object, 'greet', 'hi');\n     * bound('!');\n     * // => 'hi fred!'\n     *\n     * object.greet = function(greeting, punctuation) {\n     *   return greeting + 'ya ' + this.user + punctuation;\n     * };\n     *\n     * bound('!');\n     * // => 'hiya fred!'\n     *\n     * // Bound with placeholders.\n     * var bound = _.bindKey(object, 'greet', _, '!');\n     * bound('hi');\n     * // => 'hiya fred!'\n     */\n    var bindKey = baseRest(function(object, key, partials) {\n      var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;\n      if (partials.length) {\n        var holders = replaceHolders(partials, getHolder(bindKey));\n        bitmask |= WRAP_PARTIAL_FLAG;\n      }\n      return createWrap(key, bitmask, object, partials, holders);\n    });\n\n    /**\n     * Creates a function that accepts arguments of `func` and either invokes\n     * `func` returning its result, if at least `arity` number of arguments have\n     * been provided, or returns a function that accepts the remaining `func`\n     * arguments, and so on. The arity of `func` may be specified if `func.length`\n     * is not sufficient.\n     *\n     * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,\n     * may be used as a placeholder for provided arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of curried functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Function\n     * @param {Function} func The function to curry.\n     * @param {number} [arity=func.length] The arity of `func`.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the new curried function.\n     * @example\n     *\n     * var abc = function(a, b, c) {\n     *   return [a, b, c];\n     * };\n     *\n     * var curried = _.curry(abc);\n     *\n     * curried(1)(2)(3);\n     * // => [1, 2, 3]\n     *\n     * curried(1, 2)(3);\n     * // => [1, 2, 3]\n     *\n     * curried(1, 2, 3);\n     * // => [1, 2, 3]\n     *\n     * // Curried with placeholders.\n     * curried(1)(_, 3)(2);\n     * // => [1, 2, 3]\n     */\n    function curry(func, arity, guard) {\n      arity = guard ? undefined : arity;\n      var result = createWrap(func, WRAP_CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity);\n      result.placeholder = curry.placeholder;\n      return result;\n    }\n\n    /**\n     * This method is like `_.curry` except that arguments are applied to `func`\n     * in the manner of `_.partialRight` instead of `_.partial`.\n     *\n     * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for provided arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of curried functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} func The function to curry.\n     * @param {number} [arity=func.length] The arity of `func`.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the new curried function.\n     * @example\n     *\n     * var abc = function(a, b, c) {\n     *   return [a, b, c];\n     * };\n     *\n     * var curried = _.curryRight(abc);\n     *\n     * curried(3)(2)(1);\n     * // => [1, 2, 3]\n     *\n     * curried(2, 3)(1);\n     * // => [1, 2, 3]\n     *\n     * curried(1, 2, 3);\n     * // => [1, 2, 3]\n     *\n     * // Curried with placeholders.\n     * curried(3)(1, _)(2);\n     * // => [1, 2, 3]\n     */\n    function curryRight(func, arity, guard) {\n      arity = guard ? undefined : arity;\n      var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity);\n      result.placeholder = curryRight.placeholder;\n      return result;\n    }\n\n    /**\n     * Creates a debounced function that delays invoking `func` until after `wait`\n     * milliseconds have elapsed since the last time the debounced function was\n     * invoked. The debounced function comes with a `cancel` method to cancel\n     * delayed `func` invocations and a `flush` method to immediately invoke them.\n     * Provide `options` to indicate whether `func` should be invoked on the\n     * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n     * with the last arguments provided to the debounced function. Subsequent\n     * calls to the debounced function return the result of the last `func`\n     * invocation.\n     *\n     * **Note:** If `leading` and `trailing` options are `true`, `func` is\n     * invoked on the trailing edge of the timeout only if the debounced function\n     * is invoked more than once during the `wait` timeout.\n     *\n     * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n     * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n     *\n     * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n     * for details over the differences between `_.debounce` and `_.throttle`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to debounce.\n     * @param {number} [wait=0] The number of milliseconds to delay.\n     * @param {Object} [options={}] The options object.\n     * @param {boolean} [options.leading=false]\n     *  Specify invoking on the leading edge of the timeout.\n     * @param {number} [options.maxWait]\n     *  The maximum time `func` is allowed to be delayed before it's invoked.\n     * @param {boolean} [options.trailing=true]\n     *  Specify invoking on the trailing edge of the timeout.\n     * @returns {Function} Returns the new debounced function.\n     * @example\n     *\n     * // Avoid costly calculations while the window size is in flux.\n     * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n     *\n     * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n     * jQuery(element).on('click', _.debounce(sendMail, 300, {\n     *   'leading': true,\n     *   'trailing': false\n     * }));\n     *\n     * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n     * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n     * var source = new EventSource('/stream');\n     * jQuery(source).on('message', debounced);\n     *\n     * // Cancel the trailing debounced invocation.\n     * jQuery(window).on('popstate', debounced.cancel);\n     */\n    function debounce(func, wait, options) {\n      var lastArgs,\n          lastThis,\n          maxWait,\n          result,\n          timerId,\n          lastCallTime,\n          lastInvokeTime = 0,\n          leading = false,\n          maxing = false,\n          trailing = true;\n\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      wait = toNumber(wait) || 0;\n      if (isObject(options)) {\n        leading = !!options.leading;\n        maxing = 'maxWait' in options;\n        maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n        trailing = 'trailing' in options ? !!options.trailing : trailing;\n      }\n\n      function invokeFunc(time) {\n        var args = lastArgs,\n            thisArg = lastThis;\n\n        lastArgs = lastThis = undefined;\n        lastInvokeTime = time;\n        result = func.apply(thisArg, args);\n        return result;\n      }\n\n      function leadingEdge(time) {\n        // Reset any `maxWait` timer.\n        lastInvokeTime = time;\n        // Start the timer for the trailing edge.\n        timerId = setTimeout(timerExpired, wait);\n        // Invoke the leading edge.\n        return leading ? invokeFunc(time) : result;\n      }\n\n      function remainingWait(time) {\n        var timeSinceLastCall = time - lastCallTime,\n            timeSinceLastInvoke = time - lastInvokeTime,\n            result = wait - timeSinceLastCall;\n\n        return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;\n      }\n\n      function shouldInvoke(time) {\n        var timeSinceLastCall = time - lastCallTime,\n            timeSinceLastInvoke = time - lastInvokeTime;\n\n        // Either this is the first call, activity has stopped and we're at the\n        // trailing edge, the system time has gone backwards and we're treating\n        // it as the trailing edge, or we've hit the `maxWait` limit.\n        return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n          (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n      }\n\n      function timerExpired() {\n        var time = now();\n        if (shouldInvoke(time)) {\n          return trailingEdge(time);\n        }\n        // Restart the timer.\n        timerId = setTimeout(timerExpired, remainingWait(time));\n      }\n\n      function trailingEdge(time) {\n        timerId = undefined;\n\n        // Only invoke if we have `lastArgs` which means `func` has been\n        // debounced at least once.\n        if (trailing && lastArgs) {\n          return invokeFunc(time);\n        }\n        lastArgs = lastThis = undefined;\n        return result;\n      }\n\n      function cancel() {\n        if (timerId !== undefined) {\n          clearTimeout(timerId);\n        }\n        lastInvokeTime = 0;\n        lastArgs = lastCallTime = lastThis = timerId = undefined;\n      }\n\n      function flush() {\n        return timerId === undefined ? result : trailingEdge(now());\n      }\n\n      function debounced() {\n        var time = now(),\n            isInvoking = shouldInvoke(time);\n\n        lastArgs = arguments;\n        lastThis = this;\n        lastCallTime = time;\n\n        if (isInvoking) {\n          if (timerId === undefined) {\n            return leadingEdge(lastCallTime);\n          }\n          if (maxing) {\n            // Handle invocations in a tight loop.\n            timerId = setTimeout(timerExpired, wait);\n            return invokeFunc(lastCallTime);\n          }\n        }\n        if (timerId === undefined) {\n          timerId = setTimeout(timerExpired, wait);\n        }\n        return result;\n      }\n      debounced.cancel = cancel;\n      debounced.flush = flush;\n      return debounced;\n    }\n\n    /**\n     * Defers invoking the `func` until the current call stack has cleared. Any\n     * additional arguments are provided to `func` when it's invoked.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to defer.\n     * @param {...*} [args] The arguments to invoke `func` with.\n     * @returns {number} Returns the timer id.\n     * @example\n     *\n     * _.defer(function(text) {\n     *   console.log(text);\n     * }, 'deferred');\n     * // => Logs 'deferred' after one millisecond.\n     */\n    var defer = baseRest(function(func, args) {\n      return baseDelay(func, 1, args);\n    });\n\n    /**\n     * Invokes `func` after `wait` milliseconds. Any additional arguments are\n     * provided to `func` when it's invoked.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to delay.\n     * @param {number} wait The number of milliseconds to delay invocation.\n     * @param {...*} [args] The arguments to invoke `func` with.\n     * @returns {number} Returns the timer id.\n     * @example\n     *\n     * _.delay(function(text) {\n     *   console.log(text);\n     * }, 1000, 'later');\n     * // => Logs 'later' after one second.\n     */\n    var delay = baseRest(function(func, wait, args) {\n      return baseDelay(func, toNumber(wait) || 0, args);\n    });\n\n    /**\n     * Creates a function that invokes `func` with arguments reversed.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Function\n     * @param {Function} func The function to flip arguments for.\n     * @returns {Function} Returns the new flipped function.\n     * @example\n     *\n     * var flipped = _.flip(function() {\n     *   return _.toArray(arguments);\n     * });\n     *\n     * flipped('a', 'b', 'c', 'd');\n     * // => ['d', 'c', 'b', 'a']\n     */\n    function flip(func) {\n      return createWrap(func, WRAP_FLIP_FLAG);\n    }\n\n    /**\n     * Creates a function that memoizes the result of `func`. If `resolver` is\n     * provided, it determines the cache key for storing the result based on the\n     * arguments provided to the memoized function. By default, the first argument\n     * provided to the memoized function is used as the map cache key. The `func`\n     * is invoked with the `this` binding of the memoized function.\n     *\n     * **Note:** The cache is exposed as the `cache` property on the memoized\n     * function. Its creation may be customized by replacing the `_.memoize.Cache`\n     * constructor with one whose instances implement the\n     * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n     * method interface of `clear`, `delete`, `get`, `has`, and `set`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to have its output memoized.\n     * @param {Function} [resolver] The function to resolve the cache key.\n     * @returns {Function} Returns the new memoized function.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2 };\n     * var other = { 'c': 3, 'd': 4 };\n     *\n     * var values = _.memoize(_.values);\n     * values(object);\n     * // => [1, 2]\n     *\n     * values(other);\n     * // => [3, 4]\n     *\n     * object.a = 2;\n     * values(object);\n     * // => [1, 2]\n     *\n     * // Modify the result cache.\n     * values.cache.set(object, ['a', 'b']);\n     * values(object);\n     * // => ['a', 'b']\n     *\n     * // Replace `_.memoize.Cache`.\n     * _.memoize.Cache = WeakMap;\n     */\n    function memoize(func, resolver) {\n      if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      var memoized = function() {\n        var args = arguments,\n            key = resolver ? resolver.apply(this, args) : args[0],\n            cache = memoized.cache;\n\n        if (cache.has(key)) {\n          return cache.get(key);\n        }\n        var result = func.apply(this, args);\n        memoized.cache = cache.set(key, result) || cache;\n        return result;\n      };\n      memoized.cache = new (memoize.Cache || MapCache);\n      return memoized;\n    }\n\n    // Expose `MapCache`.\n    memoize.Cache = MapCache;\n\n    /**\n     * Creates a function that negates the result of the predicate `func`. The\n     * `func` predicate is invoked with the `this` binding and arguments of the\n     * created function.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} predicate The predicate to negate.\n     * @returns {Function} Returns the new negated function.\n     * @example\n     *\n     * function isEven(n) {\n     *   return n % 2 == 0;\n     * }\n     *\n     * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));\n     * // => [1, 3, 5]\n     */\n    function negate(predicate) {\n      if (typeof predicate != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      return function() {\n        var args = arguments;\n        switch (args.length) {\n          case 0: return !predicate.call(this);\n          case 1: return !predicate.call(this, args[0]);\n          case 2: return !predicate.call(this, args[0], args[1]);\n          case 3: return !predicate.call(this, args[0], args[1], args[2]);\n        }\n        return !predicate.apply(this, args);\n      };\n    }\n\n    /**\n     * Creates a function that is restricted to invoking `func` once. Repeat calls\n     * to the function return the value of the first invocation. The `func` is\n     * invoked with the `this` binding and arguments of the created function.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * var initialize = _.once(createApplication);\n     * initialize();\n     * initialize();\n     * // => `createApplication` is invoked once\n     */\n    function once(func) {\n      return before(2, func);\n    }\n\n    /**\n     * Creates a function that invokes `func` with its arguments transformed.\n     *\n     * @static\n     * @since 4.0.0\n     * @memberOf _\n     * @category Function\n     * @param {Function} func The function to wrap.\n     * @param {...(Function|Function[])} [transforms=[_.identity]]\n     *  The argument transforms.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * function doubled(n) {\n     *   return n * 2;\n     * }\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var func = _.overArgs(function(x, y) {\n     *   return [x, y];\n     * }, [square, doubled]);\n     *\n     * func(9, 3);\n     * // => [81, 6]\n     *\n     * func(10, 5);\n     * // => [100, 10]\n     */\n    var overArgs = castRest(function(func, transforms) {\n      transforms = (transforms.length == 1 && isArray(transforms[0]))\n        ? arrayMap(transforms[0], baseUnary(getIteratee()))\n        : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee()));\n\n      var funcsLength = transforms.length;\n      return baseRest(function(args) {\n        var index = -1,\n            length = nativeMin(args.length, funcsLength);\n\n        while (++index < length) {\n          args[index] = transforms[index].call(this, args[index]);\n        }\n        return apply(func, this, args);\n      });\n    });\n\n    /**\n     * Creates a function that invokes `func` with `partials` prepended to the\n     * arguments it receives. This method is like `_.bind` except it does **not**\n     * alter the `this` binding.\n     *\n     * The `_.partial.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for partially applied arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of partially\n     * applied functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.2.0\n     * @category Function\n     * @param {Function} func The function to partially apply arguments to.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new partially applied function.\n     * @example\n     *\n     * function greet(greeting, name) {\n     *   return greeting + ' ' + name;\n     * }\n     *\n     * var sayHelloTo = _.partial(greet, 'hello');\n     * sayHelloTo('fred');\n     * // => 'hello fred'\n     *\n     * // Partially applied with placeholders.\n     * var greetFred = _.partial(greet, _, 'fred');\n     * greetFred('hi');\n     * // => 'hi fred'\n     */\n    var partial = baseRest(function(func, partials) {\n      var holders = replaceHolders(partials, getHolder(partial));\n      return createWrap(func, WRAP_PARTIAL_FLAG, undefined, partials, holders);\n    });\n\n    /**\n     * This method is like `_.partial` except that partially applied arguments\n     * are appended to the arguments it receives.\n     *\n     * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for partially applied arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of partially\n     * applied functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.0.0\n     * @category Function\n     * @param {Function} func The function to partially apply arguments to.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new partially applied function.\n     * @example\n     *\n     * function greet(greeting, name) {\n     *   return greeting + ' ' + name;\n     * }\n     *\n     * var greetFred = _.partialRight(greet, 'fred');\n     * greetFred('hi');\n     * // => 'hi fred'\n     *\n     * // Partially applied with placeholders.\n     * var sayHelloTo = _.partialRight(greet, 'hello', _);\n     * sayHelloTo('fred');\n     * // => 'hello fred'\n     */\n    var partialRight = baseRest(function(func, partials) {\n      var holders = replaceHolders(partials, getHolder(partialRight));\n      return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined, partials, holders);\n    });\n\n    /**\n     * Creates a function that invokes `func` with arguments arranged according\n     * to the specified `indexes` where the argument value at the first index is\n     * provided as the first argument, the argument value at the second index is\n     * provided as the second argument, and so on.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} func The function to rearrange arguments for.\n     * @param {...(number|number[])} indexes The arranged argument indexes.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var rearged = _.rearg(function(a, b, c) {\n     *   return [a, b, c];\n     * }, [2, 0, 1]);\n     *\n     * rearged('b', 'c', 'a')\n     * // => ['a', 'b', 'c']\n     */\n    var rearg = flatRest(function(func, indexes) {\n      return createWrap(func, WRAP_REARG_FLAG, undefined, undefined, undefined, indexes);\n    });\n\n    /**\n     * Creates a function that invokes `func` with the `this` binding of the\n     * created function and arguments from `start` and beyond provided as\n     * an array.\n     *\n     * **Note:** This method is based on the\n     * [rest parameter](https://mdn.io/rest_parameters).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Function\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     * @example\n     *\n     * var say = _.rest(function(what, names) {\n     *   return what + ' ' + _.initial(names).join(', ') +\n     *     (_.size(names) > 1 ? ', & ' : '') + _.last(names);\n     * });\n     *\n     * say('hello', 'fred', 'barney', 'pebbles');\n     * // => 'hello fred, barney, & pebbles'\n     */\n    function rest(func, start) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      start = start === undefined ? start : toInteger(start);\n      return baseRest(func, start);\n    }\n\n    /**\n     * Creates a function that invokes `func` with the `this` binding of the\n     * create function and an array of arguments much like\n     * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply).\n     *\n     * **Note:** This method is based on the\n     * [spread operator](https://mdn.io/spread_operator).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.2.0\n     * @category Function\n     * @param {Function} func The function to spread arguments over.\n     * @param {number} [start=0] The start position of the spread.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var say = _.spread(function(who, what) {\n     *   return who + ' says ' + what;\n     * });\n     *\n     * say(['fred', 'hello']);\n     * // => 'fred says hello'\n     *\n     * var numbers = Promise.all([\n     *   Promise.resolve(40),\n     *   Promise.resolve(36)\n     * ]);\n     *\n     * numbers.then(_.spread(function(x, y) {\n     *   return x + y;\n     * }));\n     * // => a Promise of 76\n     */\n    function spread(func, start) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      start = start == null ? 0 : nativeMax(toInteger(start), 0);\n      return baseRest(function(args) {\n        var array = args[start],\n            otherArgs = castSlice(args, 0, start);\n\n        if (array) {\n          arrayPush(otherArgs, array);\n        }\n        return apply(func, this, otherArgs);\n      });\n    }\n\n    /**\n     * Creates a throttled function that only invokes `func` at most once per\n     * every `wait` milliseconds. The throttled function comes with a `cancel`\n     * method to cancel delayed `func` invocations and a `flush` method to\n     * immediately invoke them. Provide `options` to indicate whether `func`\n     * should be invoked on the leading and/or trailing edge of the `wait`\n     * timeout. The `func` is invoked with the last arguments provided to the\n     * throttled function. Subsequent calls to the throttled function return the\n     * result of the last `func` invocation.\n     *\n     * **Note:** If `leading` and `trailing` options are `true`, `func` is\n     * invoked on the trailing edge of the timeout only if the throttled function\n     * is invoked more than once during the `wait` timeout.\n     *\n     * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n     * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n     *\n     * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n     * for details over the differences between `_.throttle` and `_.debounce`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to throttle.\n     * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n     * @param {Object} [options={}] The options object.\n     * @param {boolean} [options.leading=true]\n     *  Specify invoking on the leading edge of the timeout.\n     * @param {boolean} [options.trailing=true]\n     *  Specify invoking on the trailing edge of the timeout.\n     * @returns {Function} Returns the new throttled function.\n     * @example\n     *\n     * // Avoid excessively updating the position while scrolling.\n     * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n     *\n     * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n     * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n     * jQuery(element).on('click', throttled);\n     *\n     * // Cancel the trailing throttled invocation.\n     * jQuery(window).on('popstate', throttled.cancel);\n     */\n    function throttle(func, wait, options) {\n      var leading = true,\n          trailing = true;\n\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      if (isObject(options)) {\n        leading = 'leading' in options ? !!options.leading : leading;\n        trailing = 'trailing' in options ? !!options.trailing : trailing;\n      }\n      return debounce(func, wait, {\n        'leading': leading,\n        'maxWait': wait,\n        'trailing': trailing\n      });\n    }\n\n    /**\n     * Creates a function that accepts up to one argument, ignoring any\n     * additional arguments.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Function\n     * @param {Function} func The function to cap arguments for.\n     * @returns {Function} Returns the new capped function.\n     * @example\n     *\n     * _.map(['6', '8', '10'], _.unary(parseInt));\n     * // => [6, 8, 10]\n     */\n    function unary(func) {\n      return ary(func, 1);\n    }\n\n    /**\n     * Creates a function that provides `value` to `wrapper` as its first\n     * argument. Any additional arguments provided to the function are appended\n     * to those provided to the `wrapper`. The wrapper is invoked with the `this`\n     * binding of the created function.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {*} value The value to wrap.\n     * @param {Function} [wrapper=identity] The wrapper function.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var p = _.wrap(_.escape, function(func, text) {\n     *   return '<p>' + func(text) + '</p>';\n     * });\n     *\n     * p('fred, barney, & pebbles');\n     * // => '<p>fred, barney, &amp; pebbles</p>'\n     */\n    function wrap(value, wrapper) {\n      return partial(castFunction(wrapper), value);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Casts `value` as an array if it's not one.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.4.0\n     * @category Lang\n     * @param {*} value The value to inspect.\n     * @returns {Array} Returns the cast array.\n     * @example\n     *\n     * _.castArray(1);\n     * // => [1]\n     *\n     * _.castArray({ 'a': 1 });\n     * // => [{ 'a': 1 }]\n     *\n     * _.castArray('abc');\n     * // => ['abc']\n     *\n     * _.castArray(null);\n     * // => [null]\n     *\n     * _.castArray(undefined);\n     * // => [undefined]\n     *\n     * _.castArray();\n     * // => []\n     *\n     * var array = [1, 2, 3];\n     * console.log(_.castArray(array) === array);\n     * // => true\n     */\n    function castArray() {\n      if (!arguments.length) {\n        return [];\n      }\n      var value = arguments[0];\n      return isArray(value) ? value : [value];\n    }\n\n    /**\n     * Creates a shallow clone of `value`.\n     *\n     * **Note:** This method is loosely based on the\n     * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)\n     * and supports cloning arrays, array buffers, booleans, date objects, maps,\n     * numbers, `Object` objects, regexes, sets, strings, symbols, and typed\n     * arrays. The own enumerable properties of `arguments` objects are cloned\n     * as plain objects. An empty object is returned for uncloneable values such\n     * as error objects, functions, DOM nodes, and WeakMaps.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to clone.\n     * @returns {*} Returns the cloned value.\n     * @see _.cloneDeep\n     * @example\n     *\n     * var objects = [{ 'a': 1 }, { 'b': 2 }];\n     *\n     * var shallow = _.clone(objects);\n     * console.log(shallow[0] === objects[0]);\n     * // => true\n     */\n    function clone(value) {\n      return baseClone(value, CLONE_SYMBOLS_FLAG);\n    }\n\n    /**\n     * This method is like `_.clone` except that it accepts `customizer` which\n     * is invoked to produce the cloned value. If `customizer` returns `undefined`,\n     * cloning is handled by the method instead. The `customizer` is invoked with\n     * up to four arguments; (value [, index|key, object, stack]).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to clone.\n     * @param {Function} [customizer] The function to customize cloning.\n     * @returns {*} Returns the cloned value.\n     * @see _.cloneDeepWith\n     * @example\n     *\n     * function customizer(value) {\n     *   if (_.isElement(value)) {\n     *     return value.cloneNode(false);\n     *   }\n     * }\n     *\n     * var el = _.cloneWith(document.body, customizer);\n     *\n     * console.log(el === document.body);\n     * // => false\n     * console.log(el.nodeName);\n     * // => 'BODY'\n     * console.log(el.childNodes.length);\n     * // => 0\n     */\n    function cloneWith(value, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);\n    }\n\n    /**\n     * This method is like `_.clone` except that it recursively clones `value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.0.0\n     * @category Lang\n     * @param {*} value The value to recursively clone.\n     * @returns {*} Returns the deep cloned value.\n     * @see _.clone\n     * @example\n     *\n     * var objects = [{ 'a': 1 }, { 'b': 2 }];\n     *\n     * var deep = _.cloneDeep(objects);\n     * console.log(deep[0] === objects[0]);\n     * // => false\n     */\n    function cloneDeep(value) {\n      return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);\n    }\n\n    /**\n     * This method is like `_.cloneWith` except that it recursively clones `value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to recursively clone.\n     * @param {Function} [customizer] The function to customize cloning.\n     * @returns {*} Returns the deep cloned value.\n     * @see _.cloneWith\n     * @example\n     *\n     * function customizer(value) {\n     *   if (_.isElement(value)) {\n     *     return value.cloneNode(true);\n     *   }\n     * }\n     *\n     * var el = _.cloneDeepWith(document.body, customizer);\n     *\n     * console.log(el === document.body);\n     * // => false\n     * console.log(el.nodeName);\n     * // => 'BODY'\n     * console.log(el.childNodes.length);\n     * // => 20\n     */\n    function cloneDeepWith(value, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);\n    }\n\n    /**\n     * Checks if `object` conforms to `source` by invoking the predicate\n     * properties of `source` with the corresponding property values of `object`.\n     *\n     * **Note:** This method is equivalent to `_.conforms` when `source` is\n     * partially applied.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.14.0\n     * @category Lang\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {boolean} Returns `true` if `object` conforms, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2 };\n     *\n     * _.conformsTo(object, { 'b': function(n) { return n > 1; } });\n     * // => true\n     *\n     * _.conformsTo(object, { 'b': function(n) { return n > 2; } });\n     * // => false\n     */\n    function conformsTo(object, source) {\n      return source == null || baseConformsTo(object, source, keys(source));\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     */\n    function eq(value, other) {\n      return value === other || (value !== value && other !== other);\n    }\n\n    /**\n     * Checks if `value` is greater than `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.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 `value` is greater than `other`,\n     *  else `false`.\n     * @see _.lt\n     * @example\n     *\n     * _.gt(3, 1);\n     * // => true\n     *\n     * _.gt(3, 3);\n     * // => false\n     *\n     * _.gt(1, 3);\n     * // => false\n     */\n    var gt = createRelationalOperation(baseGt);\n\n    /**\n     * Checks if `value` is greater than or equal to `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.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 `value` is greater than or equal to\n     *  `other`, else `false`.\n     * @see _.lte\n     * @example\n     *\n     * _.gte(3, 1);\n     * // => true\n     *\n     * _.gte(3, 3);\n     * // => true\n     *\n     * _.gte(1, 3);\n     * // => false\n     */\n    var gte = createRelationalOperation(function(value, other) {\n      return value >= 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     */\n    var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n      return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n        !propertyIsEnumerable.call(value, 'callee');\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     */\n    var isArray = Array.isArray;\n\n    /**\n     * Checks if `value` is classified as an `ArrayBuffer` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.\n     * @example\n     *\n     * _.isArrayBuffer(new ArrayBuffer(2));\n     * // => true\n     *\n     * _.isArrayBuffer(new Array(2));\n     * // => false\n     */\n    var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;\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     */\n    function 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     */\n    function isArrayLikeObject(value) {\n      return isObjectLike(value) && isArrayLike(value);\n    }\n\n    /**\n     * Checks if `value` is classified as a boolean primitive or 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 boolean, else `false`.\n     * @example\n     *\n     * _.isBoolean(false);\n     * // => true\n     *\n     * _.isBoolean(null);\n     * // => false\n     */\n    function isBoolean(value) {\n      return value === true || value === false ||\n        (isObjectLike(value) && baseGetTag(value) == boolTag);\n    }\n\n    /**\n     * Checks if `value` is a buffer.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n     * @example\n     *\n     * _.isBuffer(new Buffer(2));\n     * // => true\n     *\n     * _.isBuffer(new Uint8Array(2));\n     * // => false\n     */\n    var isBuffer = nativeIsBuffer || stubFalse;\n\n    /**\n     * Checks if `value` is classified as a `Date` 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 date object, else `false`.\n     * @example\n     *\n     * _.isDate(new Date);\n     * // => true\n     *\n     * _.isDate('Mon April 23 2012');\n     * // => false\n     */\n    var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;\n\n    /**\n     * Checks if `value` is likely a DOM element.\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 DOM element, else `false`.\n     * @example\n     *\n     * _.isElement(document.body);\n     * // => true\n     *\n     * _.isElement('<body>');\n     * // => false\n     */\n    function isElement(value) {\n      return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);\n    }\n\n    /**\n     * Checks if `value` is an empty object, collection, map, or set.\n     *\n     * Objects are considered empty if they have no own enumerable string keyed\n     * properties.\n     *\n     * Array-like values such as `arguments` objects, arrays, buffers, strings, or\n     * jQuery-like collections are considered empty if they have a `length` of `0`.\n     * Similarly, maps and sets are considered empty if they have a `size` of `0`.\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 empty, else `false`.\n     * @example\n     *\n     * _.isEmpty(null);\n     * // => true\n     *\n     * _.isEmpty(true);\n     * // => true\n     *\n     * _.isEmpty(1);\n     * // => true\n     *\n     * _.isEmpty([1, 2, 3]);\n     * // => false\n     *\n     * _.isEmpty({ 'a': 1 });\n     * // => false\n     */\n    function isEmpty(value) {\n      if (value == null) {\n        return true;\n      }\n      if (isArrayLike(value) &&\n          (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||\n            isBuffer(value) || isTypedArray(value) || isArguments(value))) {\n        return !value.length;\n      }\n      var tag = getTag(value);\n      if (tag == mapTag || tag == setTag) {\n        return !value.size;\n      }\n      if (isPrototype(value)) {\n        return !baseKeys(value).length;\n      }\n      for (var key in value) {\n        if (hasOwnProperty.call(value, key)) {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    /**\n     * Performs a deep comparison between two values to determine if they are\n     * equivalent.\n     *\n     * **Note:** This method supports comparing arrays, array buffers, booleans,\n     * date objects, error objects, maps, numbers, `Object` objects, regexes,\n     * sets, strings, symbols, and typed arrays. `Object` objects are compared\n     * by their own, not inherited, enumerable properties. Functions and DOM\n     * nodes are compared by strict equality, i.e. `===`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.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     * _.isEqual(object, other);\n     * // => true\n     *\n     * object === other;\n     * // => false\n     */\n    function isEqual(value, other) {\n      return baseIsEqual(value, other);\n    }\n\n    /**\n     * This method is like `_.isEqual` except that it accepts `customizer` which\n     * is invoked to compare values. If `customizer` returns `undefined`, comparisons\n     * are handled by the method instead. The `customizer` is invoked with up to\n     * six arguments: (objValue, othValue [, index|key, object, other, stack]).\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     * @param {Function} [customizer] The function to customize comparisons.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     * @example\n     *\n     * function isGreeting(value) {\n     *   return /^h(?:i|ello)$/.test(value);\n     * }\n     *\n     * function customizer(objValue, othValue) {\n     *   if (isGreeting(objValue) && isGreeting(othValue)) {\n     *     return true;\n     *   }\n     * }\n     *\n     * var array = ['hello', 'goodbye'];\n     * var other = ['hi', 'goodbye'];\n     *\n     * _.isEqualWith(array, other, customizer);\n     * // => true\n     */\n    function isEqualWith(value, other, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      var result = customizer ? customizer(value, other) : undefined;\n      return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result;\n    }\n\n    /**\n     * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,\n     * `SyntaxError`, `TypeError`, or `URIError` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an error object, else `false`.\n     * @example\n     *\n     * _.isError(new Error);\n     * // => true\n     *\n     * _.isError(Error);\n     * // => false\n     */\n    function isError(value) {\n      if (!isObjectLike(value)) {\n        return false;\n      }\n      var tag = baseGetTag(value);\n      return tag == errorTag || tag == domExcTag ||\n        (typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value));\n    }\n\n    /**\n     * Checks if `value` is a finite primitive number.\n     *\n     * **Note:** This method is based on\n     * [`Number.isFinite`](https://mdn.io/Number/isFinite).\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 finite number, else `false`.\n     * @example\n     *\n     * _.isFinite(3);\n     * // => true\n     *\n     * _.isFinite(Number.MIN_VALUE);\n     * // => true\n     *\n     * _.isFinite(Infinity);\n     * // => false\n     *\n     * _.isFinite('3');\n     * // => false\n     */\n    function isFinite(value) {\n      return typeof value == 'number' && nativeIsFinite(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     */\n    function isFunction(value) {\n      if (!isObject(value)) {\n        return false;\n      }\n      // The use of `Object#toString` avoids issues with the `typeof` operator\n      // in Safari 9 which returns 'object' for typed arrays and other constructors.\n      var tag = baseGetTag(value);\n      return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n    }\n\n    /**\n     * Checks if `value` is an integer.\n     *\n     * **Note:** This method is based on\n     * [`Number.isInteger`](https://mdn.io/Number/isInteger).\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 integer, else `false`.\n     * @example\n     *\n     * _.isInteger(3);\n     * // => true\n     *\n     * _.isInteger(Number.MIN_VALUE);\n     * // => false\n     *\n     * _.isInteger(Infinity);\n     * // => false\n     *\n     * _.isInteger('3');\n     * // => false\n     */\n    function isInteger(value) {\n      return typeof value == 'number' && value == toInteger(value);\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     */\n    function 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     */\n    function isObject(value) {\n      var type = typeof value;\n      return value != null && (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     */\n    function isObjectLike(value) {\n      return value != null && typeof value == 'object';\n    }\n\n    /**\n     * Checks if `value` is classified as a `Map` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n     * @example\n     *\n     * _.isMap(new Map);\n     * // => true\n     *\n     * _.isMap(new WeakMap);\n     * // => false\n     */\n    var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;\n\n    /**\n     * Performs a partial deep comparison between `object` and `source` to\n     * determine if `object` contains equivalent property values.\n     *\n     * **Note:** This method is equivalent to `_.matches` when `source` is\n     * partially applied.\n     *\n     * Partial comparisons will match empty array and empty object `source`\n     * values against any array or object value, respectively. See `_.isEqual`\n     * for a list of supported value comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property values to match.\n     * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2 };\n     *\n     * _.isMatch(object, { 'b': 2 });\n     * // => true\n     *\n     * _.isMatch(object, { 'b': 1 });\n     * // => false\n     */\n    function isMatch(object, source) {\n      return object === source || baseIsMatch(object, source, getMatchData(source));\n    }\n\n    /**\n     * This method is like `_.isMatch` except that it accepts `customizer` which\n     * is invoked to compare values. If `customizer` returns `undefined`, comparisons\n     * are handled by the method instead. The `customizer` is invoked with five\n     * arguments: (objValue, srcValue, index|key, object, source).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property values to match.\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n     * @example\n     *\n     * function isGreeting(value) {\n     *   return /^h(?:i|ello)$/.test(value);\n     * }\n     *\n     * function customizer(objValue, srcValue) {\n     *   if (isGreeting(objValue) && isGreeting(srcValue)) {\n     *     return true;\n     *   }\n     * }\n     *\n     * var object = { 'greeting': 'hello' };\n     * var source = { 'greeting': 'hi' };\n     *\n     * _.isMatchWith(object, source, customizer);\n     * // => true\n     */\n    function isMatchWith(object, source, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return baseIsMatch(object, source, getMatchData(source), customizer);\n    }\n\n    /**\n     * Checks if `value` is `NaN`.\n     *\n     * **Note:** This method is based on\n     * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as\n     * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for\n     * `undefined` and other non-number values.\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 `NaN`, else `false`.\n     * @example\n     *\n     * _.isNaN(NaN);\n     * // => true\n     *\n     * _.isNaN(new Number(NaN));\n     * // => true\n     *\n     * isNaN(undefined);\n     * // => true\n     *\n     * _.isNaN(undefined);\n     * // => false\n     */\n    function isNaN(value) {\n      // An `NaN` primitive is the only value that is not equal to itself.\n      // Perform the `toStringTag` check first to avoid errors with some\n      // ActiveX objects in IE.\n      return isNumber(value) && value != +value;\n    }\n\n    /**\n     * Checks if `value` is a pristine native function.\n     *\n     * **Note:** This method can't reliably detect native functions in the presence\n     * of the core-js package because core-js circumvents this kind of detection.\n     * Despite multiple requests, the core-js maintainer has made it clear: any\n     * attempt to fix the detection will be obstructed. As a result, we're left\n     * with little choice but to throw an error. Unfortunately, this also affects\n     * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill),\n     * which rely on core-js.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a native function,\n     *  else `false`.\n     * @example\n     *\n     * _.isNative(Array.prototype.push);\n     * // => true\n     *\n     * _.isNative(_);\n     * // => false\n     */\n    function isNative(value) {\n      if (isMaskable(value)) {\n        throw new Error(CORE_ERROR_TEXT);\n      }\n      return baseIsNative(value);\n    }\n\n    /**\n     * Checks if `value` is `null`.\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 `null`, else `false`.\n     * @example\n     *\n     * _.isNull(null);\n     * // => true\n     *\n     * _.isNull(void 0);\n     * // => false\n     */\n    function isNull(value) {\n      return value === null;\n    }\n\n    /**\n     * Checks if `value` is `null` or `undefined`.\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 nullish, else `false`.\n     * @example\n     *\n     * _.isNil(null);\n     * // => true\n     *\n     * _.isNil(void 0);\n     * // => true\n     *\n     * _.isNil(NaN);\n     * // => false\n     */\n    function isNil(value) {\n      return value == null;\n    }\n\n    /**\n     * Checks if `value` is classified as a `Number` primitive or object.\n     *\n     * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are\n     * classified as numbers, use the `_.isFinite` method.\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 number, else `false`.\n     * @example\n     *\n     * _.isNumber(3);\n     * // => true\n     *\n     * _.isNumber(Number.MIN_VALUE);\n     * // => true\n     *\n     * _.isNumber(Infinity);\n     * // => true\n     *\n     * _.isNumber('3');\n     * // => false\n     */\n    function isNumber(value) {\n      return typeof value == 'number' ||\n        (isObjectLike(value) && baseGetTag(value) == numberTag);\n    }\n\n    /**\n     * Checks if `value` is a plain object, that is, an object created by the\n     * `Object` constructor or one with a `[[Prototype]]` of `null`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.8.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     * }\n     *\n     * _.isPlainObject(new Foo);\n     * // => false\n     *\n     * _.isPlainObject([1, 2, 3]);\n     * // => false\n     *\n     * _.isPlainObject({ 'x': 0, 'y': 0 });\n     * // => true\n     *\n     * _.isPlainObject(Object.create(null));\n     * // => true\n     */\n    function isPlainObject(value) {\n      if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n        return false;\n      }\n      var proto = getPrototype(value);\n      if (proto === null) {\n        return true;\n      }\n      var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n      return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n        funcToString.call(Ctor) == objectCtorString;\n    }\n\n    /**\n     * Checks if `value` is classified as a `RegExp` 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 regexp, else `false`.\n     * @example\n     *\n     * _.isRegExp(/abc/);\n     * // => true\n     *\n     * _.isRegExp('/abc/');\n     * // => false\n     */\n    var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;\n\n    /**\n     * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754\n     * double precision number which isn't the result of a rounded unsafe integer.\n     *\n     * **Note:** This method is based on\n     * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).\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 safe integer, else `false`.\n     * @example\n     *\n     * _.isSafeInteger(3);\n     * // => true\n     *\n     * _.isSafeInteger(Number.MIN_VALUE);\n     * // => false\n     *\n     * _.isSafeInteger(Infinity);\n     * // => false\n     *\n     * _.isSafeInteger('3');\n     * // => false\n     */\n    function isSafeInteger(value) {\n      return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;\n    }\n\n    /**\n     * Checks if `value` is classified as a `Set` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n     * @example\n     *\n     * _.isSet(new Set);\n     * // => true\n     *\n     * _.isSet(new WeakSet);\n     * // => false\n     */\n    var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;\n\n    /**\n     * Checks if `value` is classified as a `String` primitive or object.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a string, else `false`.\n     * @example\n     *\n     * _.isString('abc');\n     * // => true\n     *\n     * _.isString(1);\n     * // => false\n     */\n    function isString(value) {\n      return typeof value == 'string' ||\n        (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);\n    }\n\n    /**\n     * Checks if `value` is classified as a `Symbol` primitive or 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 a symbol, else `false`.\n     * @example\n     *\n     * _.isSymbol(Symbol.iterator);\n     * // => true\n     *\n     * _.isSymbol('abc');\n     * // => false\n     */\n    function isSymbol(value) {\n      return typeof value == 'symbol' ||\n        (isObjectLike(value) && baseGetTag(value) == symbolTag);\n    }\n\n    /**\n     * Checks if `value` is classified as a typed array.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n     * @example\n     *\n     * _.isTypedArray(new Uint8Array);\n     * // => true\n     *\n     * _.isTypedArray([]);\n     * // => false\n     */\n    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\n    /**\n     * Checks if `value` is `undefined`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.\n     * @example\n     *\n     * _.isUndefined(void 0);\n     * // => true\n     *\n     * _.isUndefined(null);\n     * // => false\n     */\n    function isUndefined(value) {\n      return value === undefined;\n    }\n\n    /**\n     * Checks if `value` is classified as a `WeakMap` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a weak map, else `false`.\n     * @example\n     *\n     * _.isWeakMap(new WeakMap);\n     * // => true\n     *\n     * _.isWeakMap(new Map);\n     * // => false\n     */\n    function isWeakMap(value) {\n      return isObjectLike(value) && getTag(value) == weakMapTag;\n    }\n\n    /**\n     * Checks if `value` is classified as a `WeakSet` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a weak set, else `false`.\n     * @example\n     *\n     * _.isWeakSet(new WeakSet);\n     * // => true\n     *\n     * _.isWeakSet(new Set);\n     * // => false\n     */\n    function isWeakSet(value) {\n      return isObjectLike(value) && baseGetTag(value) == weakSetTag;\n    }\n\n    /**\n     * Checks if `value` is less than `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.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 `value` is less than `other`,\n     *  else `false`.\n     * @see _.gt\n     * @example\n     *\n     * _.lt(1, 3);\n     * // => true\n     *\n     * _.lt(3, 3);\n     * // => false\n     *\n     * _.lt(3, 1);\n     * // => false\n     */\n    var lt = createRelationalOperation(baseLt);\n\n    /**\n     * Checks if `value` is less than or equal to `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.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 `value` is less than or equal to\n     *  `other`, else `false`.\n     * @see _.gte\n     * @example\n     *\n     * _.lte(1, 3);\n     * // => true\n     *\n     * _.lte(3, 3);\n     * // => true\n     *\n     * _.lte(3, 1);\n     * // => false\n     */\n    var lte = createRelationalOperation(function(value, other) {\n      return value <= other;\n    });\n\n    /**\n     * Converts `value` to an array.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {Array} Returns the converted array.\n     * @example\n     *\n     * _.toArray({ 'a': 1, 'b': 2 });\n     * // => [1, 2]\n     *\n     * _.toArray('abc');\n     * // => ['a', 'b', 'c']\n     *\n     * _.toArray(1);\n     * // => []\n     *\n     * _.toArray(null);\n     * // => []\n     */\n    function toArray(value) {\n      if (!value) {\n        return [];\n      }\n      if (isArrayLike(value)) {\n        return isString(value) ? stringToArray(value) : copyArray(value);\n      }\n      if (symIterator && value[symIterator]) {\n        return iteratorToArray(value[symIterator]());\n      }\n      var tag = getTag(value),\n          func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values);\n\n      return func(value);\n    }\n\n    /**\n     * Converts `value` to a finite number.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.12.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted number.\n     * @example\n     *\n     * _.toFinite(3.2);\n     * // => 3.2\n     *\n     * _.toFinite(Number.MIN_VALUE);\n     * // => 5e-324\n     *\n     * _.toFinite(Infinity);\n     * // => 1.7976931348623157e+308\n     *\n     * _.toFinite('3.2');\n     * // => 3.2\n     */\n    function toFinite(value) {\n      if (!value) {\n        return value === 0 ? value : 0;\n      }\n      value = toNumber(value);\n      if (value === INFINITY || value === -INFINITY) {\n        var sign = (value < 0 ? -1 : 1);\n        return sign * MAX_INTEGER;\n      }\n      return value === value ? value : 0;\n    }\n\n    /**\n     * Converts `value` to an integer.\n     *\n     * **Note:** This method is loosely based on\n     * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.toInteger(3.2);\n     * // => 3\n     *\n     * _.toInteger(Number.MIN_VALUE);\n     * // => 0\n     *\n     * _.toInteger(Infinity);\n     * // => 1.7976931348623157e+308\n     *\n     * _.toInteger('3.2');\n     * // => 3\n     */\n    function toInteger(value) {\n      var result = toFinite(value),\n          remainder = result % 1;\n\n      return result === result ? (remainder ? result - remainder : result) : 0;\n    }\n\n    /**\n     * Converts `value` to an integer suitable for use as the length of an\n     * array-like object.\n     *\n     * **Note:** This method is 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 convert.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.toLength(3.2);\n     * // => 3\n     *\n     * _.toLength(Number.MIN_VALUE);\n     * // => 0\n     *\n     * _.toLength(Infinity);\n     * // => 4294967295\n     *\n     * _.toLength('3.2');\n     * // => 3\n     */\n    function toLength(value) {\n      return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;\n    }\n\n    /**\n     * Converts `value` to a number.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to process.\n     * @returns {number} Returns the number.\n     * @example\n     *\n     * _.toNumber(3.2);\n     * // => 3.2\n     *\n     * _.toNumber(Number.MIN_VALUE);\n     * // => 5e-324\n     *\n     * _.toNumber(Infinity);\n     * // => Infinity\n     *\n     * _.toNumber('3.2');\n     * // => 3.2\n     */\n    function toNumber(value) {\n      if (typeof value == 'number') {\n        return value;\n      }\n      if (isSymbol(value)) {\n        return NAN;\n      }\n      if (isObject(value)) {\n        var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n        value = isObject(other) ? (other + '') : other;\n      }\n      if (typeof value != 'string') {\n        return value === 0 ? value : +value;\n      }\n      value = value.replace(reTrim, '');\n      var isBinary = reIsBinary.test(value);\n      return (isBinary || reIsOctal.test(value))\n        ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n        : (reIsBadHex.test(value) ? NAN : +value);\n    }\n\n    /**\n     * Converts `value` to a plain object flattening inherited enumerable string\n     * keyed properties of `value` to own properties of the plain object.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {Object} Returns the converted plain object.\n     * @example\n     *\n     * function Foo() {\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.assign({ 'a': 1 }, new Foo);\n     * // => { 'a': 1, 'b': 2 }\n     *\n     * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n     * // => { 'a': 1, 'b': 2, 'c': 3 }\n     */\n    function toPlainObject(value) {\n      return copyObject(value, keysIn(value));\n    }\n\n    /**\n     * Converts `value` to a safe integer. A safe integer can be compared and\n     * represented correctly.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.toSafeInteger(3.2);\n     * // => 3\n     *\n     * _.toSafeInteger(Number.MIN_VALUE);\n     * // => 0\n     *\n     * _.toSafeInteger(Infinity);\n     * // => 9007199254740991\n     *\n     * _.toSafeInteger('3.2');\n     * // => 3\n     */\n    function toSafeInteger(value) {\n      return value\n        ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER)\n        : (value === 0 ? value : 0);\n    }\n\n    /**\n     * Converts `value` to a string. An empty string is returned for `null`\n     * and `undefined` values. The sign of `-0` is preserved.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {string} Returns the converted string.\n     * @example\n     *\n     * _.toString(null);\n     * // => ''\n     *\n     * _.toString(-0);\n     * // => '-0'\n     *\n     * _.toString([1, 2, 3]);\n     * // => '1,2,3'\n     */\n    function toString(value) {\n      return value == null ? '' : baseToString(value);\n    }\n\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     */\n    var assign = createAssigner(function(object, source) {\n      if (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     * This method is like `_.assign` except that it iterates over own and\n     * inherited source properties.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias extend\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @see _.assign\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     * _.assignIn({ 'a': 0 }, new Foo, new Bar);\n     * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }\n     */\n    var assignIn = createAssigner(function(object, source) {\n      copyObject(source, keysIn(source), object);\n    });\n\n    /**\n     * This method is like `_.assignIn` except that it accepts `customizer`\n     * which is invoked to produce the assigned values. If `customizer` returns\n     * `undefined`, assignment is handled by the method instead. The `customizer`\n     * is invoked with five arguments: (objValue, srcValue, key, object, source).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias extendWith\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} sources The source objects.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @see _.assignWith\n     * @example\n     *\n     * function customizer(objValue, srcValue) {\n     *   return _.isUndefined(objValue) ? srcValue : objValue;\n     * }\n     *\n     * var defaults = _.partialRight(_.assignInWith, customizer);\n     *\n     * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n     * // => { 'a': 1, 'b': 2 }\n     */\n    var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {\n      copyObject(source, keysIn(source), object, customizer);\n    });\n\n    /**\n     * This method is like `_.assign` except that it accepts `customizer`\n     * which is invoked to produce the assigned values. If `customizer` returns\n     * `undefined`, assignment is handled by the method instead. The `customizer`\n     * is invoked with five arguments: (objValue, srcValue, key, object, source).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} sources The source objects.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @see _.assignInWith\n     * @example\n     *\n     * function customizer(objValue, srcValue) {\n     *   return _.isUndefined(objValue) ? srcValue : objValue;\n     * }\n     *\n     * var defaults = _.partialRight(_.assignWith, customizer);\n     *\n     * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n     * // => { 'a': 1, 'b': 2 }\n     */\n    var assignWith = createAssigner(function(object, source, srcIndex, customizer) {\n      copyObject(source, keys(source), object, customizer);\n    });\n\n    /**\n     * Creates an array of values corresponding to `paths` of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.0.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {...(string|string[])} [paths] The property paths to pick.\n     * @returns {Array} Returns the picked values.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };\n     *\n     * _.at(object, ['a[0].b.c', 'a[1]']);\n     * // => [3, 4]\n     */\n    var at = flatRest(baseAt);\n\n    /**\n     * Creates an object that inherits from the `prototype` object. If a\n     * `properties` object is given, its own enumerable string keyed properties\n     * are assigned to the created object.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.3.0\n     * @category Object\n     * @param {Object} prototype The object to inherit from.\n     * @param {Object} [properties] The properties to assign to the object.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * function Shape() {\n     *   this.x = 0;\n     *   this.y = 0;\n     * }\n     *\n     * function Circle() {\n     *   Shape.call(this);\n     * }\n     *\n     * Circle.prototype = _.create(Shape.prototype, {\n     *   'constructor': Circle\n     * });\n     *\n     * var circle = new Circle;\n     * circle instanceof Circle;\n     * // => true\n     *\n     * circle instanceof Shape;\n     * // => true\n     */\n    function create(prototype, properties) {\n      var result = baseCreate(prototype);\n      return properties == null ? result : baseAssign(result, properties);\n    }\n\n    /**\n     * Assigns own and inherited enumerable string keyed properties of source\n     * objects to the destination object for all destination properties that\n     * resolve to `undefined`. Source objects are applied from left to right.\n     * Once a property is set, additional values of the same property are ignored.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @see _.defaultsDeep\n     * @example\n     *\n     * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n     * // => { 'a': 1, 'b': 2 }\n     */\n    var defaults = baseRest(function(args) {\n      args.push(undefined, customDefaultsAssignIn);\n      return apply(assignInWith, undefined, args);\n    });\n\n    /**\n     * This method is like `_.defaults` except that it recursively assigns\n     * default properties.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.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 _.defaults\n     * @example\n     *\n     * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } });\n     * // => { 'a': { 'b': 2, 'c': 3 } }\n     */\n    var defaultsDeep = baseRest(function(args) {\n      args.push(undefined, customDefaultsMerge);\n      return apply(mergeWith, undefined, args);\n    });\n\n    /**\n     * This method is like `_.find` except that it returns the key of the first\n     * element `predicate` returns truthy for instead of the element itself.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.1.0\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {string|undefined} Returns the key of the matched element,\n     *  else `undefined`.\n     * @example\n     *\n     * var users = {\n     *   'barney':  { 'age': 36, 'active': true },\n     *   'fred':    { 'age': 40, 'active': false },\n     *   'pebbles': { 'age': 1,  'active': true }\n     * };\n     *\n     * _.findKey(users, function(o) { return o.age < 40; });\n     * // => 'barney' (iteration order is not guaranteed)\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findKey(users, { 'age': 1, 'active': true });\n     * // => 'pebbles'\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findKey(users, ['active', false]);\n     * // => 'fred'\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findKey(users, 'active');\n     * // => 'barney'\n     */\n    function findKey(object, predicate) {\n      return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);\n    }\n\n    /**\n     * This method is like `_.findKey` except that it iterates over elements of\n     * a collection in the opposite order.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {string|undefined} Returns the key of the matched element,\n     *  else `undefined`.\n     * @example\n     *\n     * var users = {\n     *   'barney':  { 'age': 36, 'active': true },\n     *   'fred':    { 'age': 40, 'active': false },\n     *   'pebbles': { 'age': 1,  'active': true }\n     * };\n     *\n     * _.findLastKey(users, function(o) { return o.age < 40; });\n     * // => returns 'pebbles' assuming `_.findKey` returns 'barney'\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findLastKey(users, { 'age': 36, 'active': true });\n     * // => 'barney'\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findLastKey(users, ['active', false]);\n     * // => 'fred'\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findLastKey(users, 'active');\n     * // => 'pebbles'\n     */\n    function findLastKey(object, predicate) {\n      return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);\n    }\n\n    /**\n     * Iterates over own and inherited enumerable string keyed properties of an\n     * object and invokes `iteratee` for each property. The iteratee is invoked\n     * with three arguments: (value, key, object). Iteratee functions may exit\n     * iteration early by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.3.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forInRight\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forIn(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed).\n     */\n    function forIn(object, iteratee) {\n      return object == null\n        ? object\n        : baseFor(object, getIteratee(iteratee, 3), keysIn);\n    }\n\n    /**\n     * This method is like `_.forIn` except that it iterates over properties of\n     * `object` in the opposite order.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forIn\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forInRight(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'.\n     */\n    function forInRight(object, iteratee) {\n      return object == null\n        ? object\n        : baseForRight(object, getIteratee(iteratee, 3), keysIn);\n    }\n\n    /**\n     * Iterates over own enumerable string keyed properties of an object and\n     * invokes `iteratee` for each property. The iteratee is invoked with three\n     * arguments: (value, key, object). Iteratee functions may exit iteration\n     * early by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.3.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forOwnRight\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forOwn(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'a' then 'b' (iteration order is not guaranteed).\n     */\n    function forOwn(object, iteratee) {\n      return object && baseForOwn(object, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * This method is like `_.forOwn` except that it iterates over properties of\n     * `object` in the opposite order.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forOwn\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forOwnRight(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'.\n     */\n    function forOwnRight(object, iteratee) {\n      return object && baseForOwnRight(object, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * Creates an array of function property names from own enumerable properties\n     * of `object`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @returns {Array} Returns the function names.\n     * @see _.functionsIn\n     * @example\n     *\n     * function Foo() {\n     *   this.a = _.constant('a');\n     *   this.b = _.constant('b');\n     * }\n     *\n     * Foo.prototype.c = _.constant('c');\n     *\n     * _.functions(new Foo);\n     * // => ['a', 'b']\n     */\n    function functions(object) {\n      return object == null ? [] : baseFunctions(object, keys(object));\n    }\n\n    /**\n     * Creates an array of function property names from own and inherited\n     * enumerable properties of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @returns {Array} Returns the function names.\n     * @see _.functions\n     * @example\n     *\n     * function Foo() {\n     *   this.a = _.constant('a');\n     *   this.b = _.constant('b');\n     * }\n     *\n     * Foo.prototype.c = _.constant('c');\n     *\n     * _.functionsIn(new Foo);\n     * // => ['a', 'b', 'c']\n     */\n    function functionsIn(object) {\n      return object == null ? [] : baseFunctions(object, keysIn(object));\n    }\n\n    /**\n     * Gets the value at `path` of `object`. If the resolved value is\n     * `undefined`, the `defaultValue` is returned in its place.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the property to get.\n     * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n     * @returns {*} Returns the resolved value.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n     *\n     * _.get(object, 'a[0].b.c');\n     * // => 3\n     *\n     * _.get(object, ['a', '0', 'b', 'c']);\n     * // => 3\n     *\n     * _.get(object, 'a.b.c', 'default');\n     * // => 'default'\n     */\n    function get(object, path, defaultValue) {\n      var result = object == null ? undefined : baseGet(object, path);\n      return result === undefined ? defaultValue : result;\n    }\n\n    /**\n     * Checks if `path` is a direct property of `object`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path to check.\n     * @returns {boolean} Returns `true` if `path` exists, else `false`.\n     * @example\n     *\n     * var object = { 'a': { 'b': 2 } };\n     * var other = _.create({ 'a': _.create({ 'b': 2 }) });\n     *\n     * _.has(object, 'a');\n     * // => true\n     *\n     * _.has(object, 'a.b');\n     * // => true\n     *\n     * _.has(object, ['a', 'b']);\n     * // => true\n     *\n     * _.has(other, 'a');\n     * // => false\n     */\n    function has(object, path) {\n      return object != null && hasPath(object, path, baseHas);\n    }\n\n    /**\n     * Checks if `path` is a direct or inherited property of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path to check.\n     * @returns {boolean} Returns `true` if `path` exists, else `false`.\n     * @example\n     *\n     * var object = _.create({ 'a': _.create({ 'b': 2 }) });\n     *\n     * _.hasIn(object, 'a');\n     * // => true\n     *\n     * _.hasIn(object, 'a.b');\n     * // => true\n     *\n     * _.hasIn(object, ['a', 'b']);\n     * // => true\n     *\n     * _.hasIn(object, 'b');\n     * // => false\n     */\n    function hasIn(object, path) {\n      return object != null && hasPath(object, path, baseHasIn);\n    }\n\n    /**\n     * Creates an object composed of the inverted keys and values of `object`.\n     * If `object` contains duplicate values, subsequent values overwrite\n     * property assignments of previous values.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.7.0\n     * @category Object\n     * @param {Object} object The object to invert.\n     * @returns {Object} Returns the new inverted object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2, 'c': 1 };\n     *\n     * _.invert(object);\n     * // => { '1': 'c', '2': 'b' }\n     */\n    var invert = createInverter(function(result, value, key) {\n      result[value] = key;\n    }, constant(identity));\n\n    /**\n     * This method is like `_.invert` except that the inverted object is generated\n     * from the results of running each element of `object` thru `iteratee`. The\n     * corresponding inverted value of each inverted key is an array of keys\n     * responsible for generating the inverted value. The iteratee is invoked\n     * with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.1.0\n     * @category Object\n     * @param {Object} object The object to invert.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Object} Returns the new inverted object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2, 'c': 1 };\n     *\n     * _.invertBy(object);\n     * // => { '1': ['a', 'c'], '2': ['b'] }\n     *\n     * _.invertBy(object, function(value) {\n     *   return 'group' + value;\n     * });\n     * // => { 'group1': ['a', 'c'], 'group2': ['b'] }\n     */\n    var invertBy = createInverter(function(result, value, key) {\n      if (hasOwnProperty.call(result, value)) {\n        result[value].push(key);\n      } else {\n        result[value] = [key];\n      }\n    }, getIteratee);\n\n    /**\n     * Invokes the method at `path` of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the method to invoke.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {*} Returns the result of the invoked method.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] };\n     *\n     * _.invoke(object, 'a[0].b.c.slice', 1, 3);\n     * // => [2, 3]\n     */\n    var invoke = baseRest(baseInvoke);\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     */\n    function keys(object) {\n      return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n    }\n\n    /**\n     * Creates an array of the own and inherited enumerable property names of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\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     * _.keysIn(new Foo);\n     * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n     */\n    function keysIn(object) {\n      return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n    }\n\n    /**\n     * The opposite of `_.mapValues`; this method creates an object with the\n     * same values as `object` and keys generated by running each own enumerable\n     * string keyed property of `object` thru `iteratee`. The iteratee is invoked\n     * with three arguments: (value, key, object).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.8.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns the new mapped object.\n     * @see _.mapValues\n     * @example\n     *\n     * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {\n     *   return key + value;\n     * });\n     * // => { 'a1': 1, 'b2': 2 }\n     */\n    function mapKeys(object, iteratee) {\n      var result = {};\n      iteratee = getIteratee(iteratee, 3);\n\n      baseForOwn(object, function(value, key, object) {\n        baseAssignValue(result, iteratee(value, key, object), value);\n      });\n      return result;\n    }\n\n    /**\n     * Creates an object with the same keys as `object` and values generated\n     * by running each own enumerable string keyed property of `object` thru\n     * `iteratee`. The iteratee is invoked with three arguments:\n     * (value, key, object).\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns the new mapped object.\n     * @see _.mapKeys\n     * @example\n     *\n     * var users = {\n     *   'fred':    { 'user': 'fred',    'age': 40 },\n     *   'pebbles': { 'user': 'pebbles', 'age': 1 }\n     * };\n     *\n     * _.mapValues(users, function(o) { return o.age; });\n     * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.mapValues(users, 'age');\n     * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\n     */\n    function mapValues(object, iteratee) {\n      var result = {};\n      iteratee = getIteratee(iteratee, 3);\n\n      baseForOwn(object, function(value, key, object) {\n        baseAssignValue(result, key, iteratee(value, key, object));\n      });\n      return result;\n    }\n\n    /**\n     * This method is like `_.assign` except that it recursively merges own and\n     * inherited enumerable string keyed properties of source objects into the\n     * destination object. Source properties that resolve to `undefined` are\n     * skipped if a destination value exists. Array and plain object properties\n     * are merged recursively. Other objects and value types are overridden by\n     * assignment. Source objects are applied from left to right. Subsequent\n     * sources overwrite property assignments of previous sources.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.5.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = {\n     *   'a': [{ 'b': 2 }, { 'd': 4 }]\n     * };\n     *\n     * var other = {\n     *   'a': [{ 'c': 3 }, { 'e': 5 }]\n     * };\n     *\n     * _.merge(object, other);\n     * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }\n     */\n    var merge = createAssigner(function(object, source, srcIndex) {\n      baseMerge(object, source, srcIndex);\n    });\n\n    /**\n     * This method is like `_.merge` except that it accepts `customizer` which\n     * is invoked to produce the merged values of the destination and source\n     * properties. If `customizer` returns `undefined`, merging is handled by the\n     * method instead. The `customizer` is invoked with six arguments:\n     * (objValue, srcValue, key, object, source, stack).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} sources The source objects.\n     * @param {Function} customizer The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * function customizer(objValue, srcValue) {\n     *   if (_.isArray(objValue)) {\n     *     return objValue.concat(srcValue);\n     *   }\n     * }\n     *\n     * var object = { 'a': [1], 'b': [2] };\n     * var other = { 'a': [3], 'b': [4] };\n     *\n     * _.mergeWith(object, other, customizer);\n     * // => { 'a': [1, 3], 'b': [2, 4] }\n     */\n    var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {\n      baseMerge(object, source, srcIndex, customizer);\n    });\n\n    /**\n     * The opposite of `_.pick`; this method creates an object composed of the\n     * own and inherited enumerable property paths of `object` that are not omitted.\n     *\n     * **Note:** This method is considerably slower than `_.pick`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {...(string|string[])} [paths] The property paths to omit.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.omit(object, ['a', 'c']);\n     * // => { 'b': '2' }\n     */\n    var omit = flatRest(function(object, paths) {\n      var result = {};\n      if (object == null) {\n        return result;\n      }\n      var isDeep = false;\n      paths = arrayMap(paths, function(path) {\n        path = castPath(path, object);\n        isDeep || (isDeep = path.length > 1);\n        return path;\n      });\n      copyObject(object, getAllKeysIn(object), result);\n      if (isDeep) {\n        result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);\n      }\n      var length = paths.length;\n      while (length--) {\n        baseUnset(result, paths[length]);\n      }\n      return result;\n    });\n\n    /**\n     * The opposite of `_.pickBy`; this method creates an object composed of\n     * the own and inherited enumerable string keyed properties of `object` that\n     * `predicate` doesn't return truthy for. The predicate is invoked with two\n     * arguments: (value, key).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {Function} [predicate=_.identity] The function invoked per property.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.omitBy(object, _.isNumber);\n     * // => { 'b': '2' }\n     */\n    function omitBy(object, predicate) {\n      return pickBy(object, negate(getIteratee(predicate)));\n    }\n\n    /**\n     * Creates an object composed of the picked `object` properties.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {...(string|string[])} [paths] The property paths to pick.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.pick(object, ['a', 'c']);\n     * // => { 'a': 1, 'c': 3 }\n     */\n    var pick = flatRest(function(object, paths) {\n      return object == null ? {} : basePick(object, paths);\n    });\n\n    /**\n     * Creates an object composed of the `object` properties `predicate` returns\n     * truthy for. The predicate is invoked with two arguments: (value, key).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {Function} [predicate=_.identity] The function invoked per property.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.pickBy(object, _.isNumber);\n     * // => { 'a': 1, 'c': 3 }\n     */\n    function pickBy(object, predicate) {\n      if (object == null) {\n        return {};\n      }\n      var props = arrayMap(getAllKeysIn(object), function(prop) {\n        return [prop];\n      });\n      predicate = getIteratee(predicate);\n      return basePickBy(object, props, function(value, path) {\n        return predicate(value, path[0]);\n      });\n    }\n\n    /**\n     * This method is like `_.get` except that if the resolved value is a\n     * function it's invoked with the `this` binding of its parent object and\n     * its result is returned.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the property to resolve.\n     * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n     * @returns {*} Returns the resolved value.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };\n     *\n     * _.result(object, 'a[0].b.c1');\n     * // => 3\n     *\n     * _.result(object, 'a[0].b.c2');\n     * // => 4\n     *\n     * _.result(object, 'a[0].b.c3', 'default');\n     * // => 'default'\n     *\n     * _.result(object, 'a[0].b.c3', _.constant('default'));\n     * // => 'default'\n     */\n    function result(object, path, defaultValue) {\n      path = castPath(path, object);\n\n      var index = -1,\n          length = path.length;\n\n      // Ensure the loop is entered when path is empty.\n      if (!length) {\n        length = 1;\n        object = undefined;\n      }\n      while (++index < length) {\n        var value = object == null ? undefined : object[toKey(path[index])];\n        if (value === undefined) {\n          index = length;\n          value = defaultValue;\n        }\n        object = isFunction(value) ? value.call(object) : value;\n      }\n      return object;\n    }\n\n    /**\n     * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,\n     * it's created. Arrays are created for missing index properties while objects\n     * are created for all other missing properties. Use `_.setWith` to customize\n     * `path` creation.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n     *\n     * _.set(object, 'a[0].b.c', 4);\n     * console.log(object.a[0].b.c);\n     * // => 4\n     *\n     * _.set(object, ['x', '0', 'y', 'z'], 5);\n     * console.log(object.x[0].y.z);\n     * // => 5\n     */\n    function set(object, path, value) {\n      return object == null ? object : baseSet(object, path, value);\n    }\n\n    /**\n     * This method is like `_.set` except that it accepts `customizer` which is\n     * invoked to produce the objects of `path`.  If `customizer` returns `undefined`\n     * path creation is handled by the method instead. The `customizer` is invoked\n     * with three arguments: (nsValue, key, nsObject).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {*} value The value to set.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = {};\n     *\n     * _.setWith(object, '[0][1]', 'a', Object);\n     * // => { '0': { '1': 'a' } }\n     */\n    function setWith(object, path, value, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return object == null ? object : baseSet(object, path, value, customizer);\n    }\n\n    /**\n     * Creates an array of own enumerable string keyed-value pairs for `object`\n     * which can be consumed by `_.fromPairs`. If `object` is a map or set, its\n     * entries are returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias entries\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the key-value pairs.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.toPairs(new Foo);\n     * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed)\n     */\n    var toPairs = createToPairs(keys);\n\n    /**\n     * Creates an array of own and inherited enumerable string keyed-value pairs\n     * for `object` which can be consumed by `_.fromPairs`. If `object` is a map\n     * or set, its entries are returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias entriesIn\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the key-value pairs.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.toPairsIn(new Foo);\n     * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed)\n     */\n    var toPairsIn = createToPairs(keysIn);\n\n    /**\n     * An alternative to `_.reduce`; this method transforms `object` to a new\n     * `accumulator` object which is the result of running each of its own\n     * enumerable string keyed properties thru `iteratee`, with each invocation\n     * potentially mutating the `accumulator` object. If `accumulator` is not\n     * provided, a new object with the same `[[Prototype]]` will be used. The\n     * iteratee is invoked with four arguments: (accumulator, value, key, object).\n     * Iteratee functions may exit iteration early by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.3.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [accumulator] The custom accumulator value.\n     * @returns {*} Returns the accumulated value.\n     * @example\n     *\n     * _.transform([2, 3, 4], function(result, n) {\n     *   result.push(n *= n);\n     *   return n % 2 == 0;\n     * }, []);\n     * // => [4, 9]\n     *\n     * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {\n     *   (result[value] || (result[value] = [])).push(key);\n     * }, {});\n     * // => { '1': ['a', 'c'], '2': ['b'] }\n     */\n    function transform(object, iteratee, accumulator) {\n      var isArr = isArray(object),\n          isArrLike = isArr || isBuffer(object) || isTypedArray(object);\n\n      iteratee = getIteratee(iteratee, 4);\n      if (accumulator == null) {\n        var Ctor = object && object.constructor;\n        if (isArrLike) {\n          accumulator = isArr ? new Ctor : [];\n        }\n        else if (isObject(object)) {\n          accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};\n        }\n        else {\n          accumulator = {};\n        }\n      }\n      (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) {\n        return iteratee(accumulator, value, index, object);\n      });\n      return accumulator;\n    }\n\n    /**\n     * Removes the property at `path` of `object`.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to unset.\n     * @returns {boolean} Returns `true` if the property is deleted, else `false`.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 7 } }] };\n     * _.unset(object, 'a[0].b.c');\n     * // => true\n     *\n     * console.log(object);\n     * // => { 'a': [{ 'b': {} }] };\n     *\n     * _.unset(object, ['a', '0', 'b', 'c']);\n     * // => true\n     *\n     * console.log(object);\n     * // => { 'a': [{ 'b': {} }] };\n     */\n    function unset(object, path) {\n      return object == null ? true : baseUnset(object, path);\n    }\n\n    /**\n     * This method is like `_.set` except that accepts `updater` to produce the\n     * value to set. Use `_.updateWith` to customize `path` creation. The `updater`\n     * is invoked with one argument: (value).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.6.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {Function} updater The function to produce the updated value.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n     *\n     * _.update(object, 'a[0].b.c', function(n) { return n * n; });\n     * console.log(object.a[0].b.c);\n     * // => 9\n     *\n     * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; });\n     * console.log(object.x[0].y.z);\n     * // => 0\n     */\n    function update(object, path, updater) {\n      return object == null ? object : baseUpdate(object, path, castFunction(updater));\n    }\n\n    /**\n     * This method is like `_.update` except that it accepts `customizer` which is\n     * invoked to produce the objects of `path`.  If `customizer` returns `undefined`\n     * path creation is handled by the method instead. The `customizer` is invoked\n     * with three arguments: (nsValue, key, nsObject).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.6.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {Function} updater The function to produce the updated value.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = {};\n     *\n     * _.updateWith(object, '[0][1]', _.constant('a'), Object);\n     * // => { '0': { '1': 'a' } }\n     */\n    function updateWith(object, path, updater, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);\n    }\n\n    /**\n     * Creates an array of the own enumerable string keyed property values of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects.\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 values.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.values(new Foo);\n     * // => [1, 2] (iteration order is not guaranteed)\n     *\n     * _.values('hi');\n     * // => ['h', 'i']\n     */\n    function values(object) {\n      return object == null ? [] : baseValues(object, keys(object));\n    }\n\n    /**\n     * Creates an array of the own and inherited enumerable string keyed property\n     * values of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property values.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.valuesIn(new Foo);\n     * // => [1, 2, 3] (iteration order is not guaranteed)\n     */\n    function valuesIn(object) {\n      return object == null ? [] : baseValues(object, keysIn(object));\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Clamps `number` within the inclusive `lower` and `upper` bounds.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Number\n     * @param {number} number The number to clamp.\n     * @param {number} [lower] The lower bound.\n     * @param {number} upper The upper bound.\n     * @returns {number} Returns the clamped number.\n     * @example\n     *\n     * _.clamp(-10, -5, 5);\n     * // => -5\n     *\n     * _.clamp(10, -5, 5);\n     * // => 5\n     */\n    function clamp(number, lower, upper) {\n      if (upper === undefined) {\n        upper = lower;\n        lower = undefined;\n      }\n      if (upper !== undefined) {\n        upper = toNumber(upper);\n        upper = upper === upper ? upper : 0;\n      }\n      if (lower !== undefined) {\n        lower = toNumber(lower);\n        lower = lower === lower ? lower : 0;\n      }\n      return baseClamp(toNumber(number), lower, upper);\n    }\n\n    /**\n     * Checks if `n` is between `start` and up to, but not including, `end`. If\n     * `end` is not specified, it's set to `start` with `start` then set to `0`.\n     * If `start` is greater than `end` the params are swapped to support\n     * negative ranges.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.3.0\n     * @category Number\n     * @param {number} number The number to check.\n     * @param {number} [start=0] The start of the range.\n     * @param {number} end The end of the range.\n     * @returns {boolean} Returns `true` if `number` is in the range, else `false`.\n     * @see _.range, _.rangeRight\n     * @example\n     *\n     * _.inRange(3, 2, 4);\n     * // => true\n     *\n     * _.inRange(4, 8);\n     * // => true\n     *\n     * _.inRange(4, 2);\n     * // => false\n     *\n     * _.inRange(2, 2);\n     * // => false\n     *\n     * _.inRange(1.2, 2);\n     * // => true\n     *\n     * _.inRange(5.2, 4);\n     * // => false\n     *\n     * _.inRange(-3, -2, -6);\n     * // => true\n     */\n    function inRange(number, start, end) {\n      start = toFinite(start);\n      if (end === undefined) {\n        end = start;\n        start = 0;\n      } else {\n        end = toFinite(end);\n      }\n      number = toNumber(number);\n      return baseInRange(number, start, end);\n    }\n\n    /**\n     * Produces a random number between the inclusive `lower` and `upper` bounds.\n     * If only one argument is provided a number between `0` and the given number\n     * is returned. If `floating` is `true`, or either `lower` or `upper` are\n     * floats, a floating-point number is returned instead of an integer.\n     *\n     * **Note:** JavaScript follows the IEEE-754 standard for resolving\n     * floating-point values which can produce unexpected results.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.7.0\n     * @category Number\n     * @param {number} [lower=0] The lower bound.\n     * @param {number} [upper=1] The upper bound.\n     * @param {boolean} [floating] Specify returning a floating-point number.\n     * @returns {number} Returns the random number.\n     * @example\n     *\n     * _.random(0, 5);\n     * // => an integer between 0 and 5\n     *\n     * _.random(5);\n     * // => also an integer between 0 and 5\n     *\n     * _.random(5, true);\n     * // => a floating-point number between 0 and 5\n     *\n     * _.random(1.2, 5.2);\n     * // => a floating-point number between 1.2 and 5.2\n     */\n    function random(lower, upper, floating) {\n      if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) {\n        upper = floating = undefined;\n      }\n      if (floating === undefined) {\n        if (typeof upper == 'boolean') {\n          floating = upper;\n          upper = undefined;\n        }\n        else if (typeof lower == 'boolean') {\n          floating = lower;\n          lower = undefined;\n        }\n      }\n      if (lower === undefined && upper === undefined) {\n        lower = 0;\n        upper = 1;\n      }\n      else {\n        lower = toFinite(lower);\n        if (upper === undefined) {\n          upper = lower;\n          lower = 0;\n        } else {\n          upper = toFinite(upper);\n        }\n      }\n      if (lower > upper) {\n        var temp = lower;\n        lower = upper;\n        upper = temp;\n      }\n      if (floating || lower % 1 || upper % 1) {\n        var rand = nativeRandom();\n        return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper);\n      }\n      return baseRandom(lower, upper);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the camel cased string.\n     * @example\n     *\n     * _.camelCase('Foo Bar');\n     * // => 'fooBar'\n     *\n     * _.camelCase('--foo-bar--');\n     * // => 'fooBar'\n     *\n     * _.camelCase('__FOO_BAR__');\n     * // => 'fooBar'\n     */\n    var camelCase = createCompounder(function(result, word, index) {\n      word = word.toLowerCase();\n      return result + (index ? capitalize(word) : word);\n    });\n\n    /**\n     * Converts the first character of `string` to upper case and the remaining\n     * to lower case.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to capitalize.\n     * @returns {string} Returns the capitalized string.\n     * @example\n     *\n     * _.capitalize('FRED');\n     * // => 'Fred'\n     */\n    function capitalize(string) {\n      return upperFirst(toString(string).toLowerCase());\n    }\n\n    /**\n     * Deburrs `string` by converting\n     * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)\n     * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)\n     * letters to basic Latin letters and removing\n     * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to deburr.\n     * @returns {string} Returns the deburred string.\n     * @example\n     *\n     * _.deburr('déjà vu');\n     * // => 'deja vu'\n     */\n    function deburr(string) {\n      string = toString(string);\n      return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');\n    }\n\n    /**\n     * Checks if `string` ends with the given target string.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to inspect.\n     * @param {string} [target] The string to search for.\n     * @param {number} [position=string.length] The position to search up to.\n     * @returns {boolean} Returns `true` if `string` ends with `target`,\n     *  else `false`.\n     * @example\n     *\n     * _.endsWith('abc', 'c');\n     * // => true\n     *\n     * _.endsWith('abc', 'b');\n     * // => false\n     *\n     * _.endsWith('abc', 'b', 2);\n     * // => true\n     */\n    function endsWith(string, target, position) {\n      string = toString(string);\n      target = baseToString(target);\n\n      var length = string.length;\n      position = position === undefined\n        ? length\n        : baseClamp(toInteger(position), 0, length);\n\n      var end = position;\n      position -= target.length;\n      return position >= 0 && string.slice(position, end) == target;\n    }\n\n    /**\n     * Converts the characters \"&\", \"<\", \">\", '\"', and \"'\" in `string` to their\n     * corresponding HTML entities.\n     *\n     * **Note:** No other characters are escaped. To escape additional\n     * characters use a third-party library like [_he_](https://mths.be/he).\n     *\n     * Though the \">\" character is escaped for symmetry, characters like\n     * \">\" and \"/\" don't need escaping in HTML and have no special meaning\n     * unless they're part of a tag or unquoted attribute value. See\n     * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)\n     * (under \"semi-related fun fact\") for more details.\n     *\n     * When working with HTML you should always\n     * [quote attribute values](http://wonko.com/post/html-escaping) to reduce\n     * XSS vectors.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to escape.\n     * @returns {string} Returns the escaped string.\n     * @example\n     *\n     * _.escape('fred, barney, & pebbles');\n     * // => 'fred, barney, &amp; pebbles'\n     */\n    function escape(string) {\n      string = toString(string);\n      return (string && reHasUnescapedHtml.test(string))\n        ? string.replace(reUnescapedHtml, escapeHtmlChar)\n        : string;\n    }\n\n    /**\n     * Escapes the `RegExp` special characters \"^\", \"$\", \"\\\", \".\", \"*\", \"+\",\n     * \"?\", \"(\", \")\", \"[\", \"]\", \"{\", \"}\", and \"|\" in `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to escape.\n     * @returns {string} Returns the escaped string.\n     * @example\n     *\n     * _.escapeRegExp('[lodash](https://lodash.com/)');\n     * // => '\\[lodash\\]\\(https://lodash\\.com/\\)'\n     */\n    function escapeRegExp(string) {\n      string = toString(string);\n      return (string && reHasRegExpChar.test(string))\n        ? string.replace(reRegExpChar, '\\\\$&')\n        : string;\n    }\n\n    /**\n     * Converts `string` to\n     * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the kebab cased string.\n     * @example\n     *\n     * _.kebabCase('Foo Bar');\n     * // => 'foo-bar'\n     *\n     * _.kebabCase('fooBar');\n     * // => 'foo-bar'\n     *\n     * _.kebabCase('__FOO_BAR__');\n     * // => 'foo-bar'\n     */\n    var kebabCase = createCompounder(function(result, word, index) {\n      return result + (index ? '-' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Converts `string`, as space separated words, to lower case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the lower cased string.\n     * @example\n     *\n     * _.lowerCase('--Foo-Bar--');\n     * // => 'foo bar'\n     *\n     * _.lowerCase('fooBar');\n     * // => 'foo bar'\n     *\n     * _.lowerCase('__FOO_BAR__');\n     * // => 'foo bar'\n     */\n    var lowerCase = createCompounder(function(result, word, index) {\n      return result + (index ? ' ' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Converts the first character of `string` to lower case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the converted string.\n     * @example\n     *\n     * _.lowerFirst('Fred');\n     * // => 'fred'\n     *\n     * _.lowerFirst('FRED');\n     * // => 'fRED'\n     */\n    var lowerFirst = createCaseFirst('toLowerCase');\n\n    /**\n     * Pads `string` on the left and right sides if it's shorter than `length`.\n     * Padding characters are truncated if they can't be evenly divided by `length`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.pad('abc', 8);\n     * // => '  abc   '\n     *\n     * _.pad('abc', 8, '_-');\n     * // => '_-abc_-_'\n     *\n     * _.pad('abc', 3);\n     * // => 'abc'\n     */\n    function pad(string, length, chars) {\n      string = toString(string);\n      length = toInteger(length);\n\n      var strLength = length ? stringSize(string) : 0;\n      if (!length || strLength >= length) {\n        return string;\n      }\n      var mid = (length - strLength) / 2;\n      return (\n        createPadding(nativeFloor(mid), chars) +\n        string +\n        createPadding(nativeCeil(mid), chars)\n      );\n    }\n\n    /**\n     * Pads `string` on the right side if it's shorter than `length`. Padding\n     * characters are truncated if they exceed `length`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.padEnd('abc', 6);\n     * // => 'abc   '\n     *\n     * _.padEnd('abc', 6, '_-');\n     * // => 'abc_-_'\n     *\n     * _.padEnd('abc', 3);\n     * // => 'abc'\n     */\n    function padEnd(string, length, chars) {\n      string = toString(string);\n      length = toInteger(length);\n\n      var strLength = length ? stringSize(string) : 0;\n      return (length && strLength < length)\n        ? (string + createPadding(length - strLength, chars))\n        : string;\n    }\n\n    /**\n     * Pads `string` on the left side if it's shorter than `length`. Padding\n     * characters are truncated if they exceed `length`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.padStart('abc', 6);\n     * // => '   abc'\n     *\n     * _.padStart('abc', 6, '_-');\n     * // => '_-_abc'\n     *\n     * _.padStart('abc', 3);\n     * // => 'abc'\n     */\n    function padStart(string, length, chars) {\n      string = toString(string);\n      length = toInteger(length);\n\n      var strLength = length ? stringSize(string) : 0;\n      return (length && strLength < length)\n        ? (createPadding(length - strLength, chars) + string)\n        : string;\n    }\n\n    /**\n     * Converts `string` to an integer of the specified radix. If `radix` is\n     * `undefined` or `0`, a `radix` of `10` is used unless `value` is a\n     * hexadecimal, in which case a `radix` of `16` is used.\n     *\n     * **Note:** This method aligns with the\n     * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.1.0\n     * @category String\n     * @param {string} string The string to convert.\n     * @param {number} [radix=10] The radix to interpret `value` by.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.parseInt('08');\n     * // => 8\n     *\n     * _.map(['6', '08', '10'], _.parseInt);\n     * // => [6, 8, 10]\n     */\n    function parseInt(string, radix, guard) {\n      if (guard || radix == null) {\n        radix = 0;\n      } else if (radix) {\n        radix = +radix;\n      }\n      return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0);\n    }\n\n    /**\n     * Repeats the given string `n` times.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to repeat.\n     * @param {number} [n=1] The number of times to repeat the string.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the repeated string.\n     * @example\n     *\n     * _.repeat('*', 3);\n     * // => '***'\n     *\n     * _.repeat('abc', 2);\n     * // => 'abcabc'\n     *\n     * _.repeat('abc', 0);\n     * // => ''\n     */\n    function repeat(string, n, guard) {\n      if ((guard ? isIterateeCall(string, n, guard) : n === undefined)) {\n        n = 1;\n      } else {\n        n = toInteger(n);\n      }\n      return baseRepeat(toString(string), n);\n    }\n\n    /**\n     * Replaces matches for `pattern` in `string` with `replacement`.\n     *\n     * **Note:** This method is based on\n     * [`String#replace`](https://mdn.io/String/replace).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to modify.\n     * @param {RegExp|string} pattern The pattern to replace.\n     * @param {Function|string} replacement The match replacement.\n     * @returns {string} Returns the modified string.\n     * @example\n     *\n     * _.replace('Hi Fred', 'Fred', 'Barney');\n     * // => 'Hi Barney'\n     */\n    function replace() {\n      var args = arguments,\n          string = toString(args[0]);\n\n      return args.length < 3 ? string : string.replace(args[1], args[2]);\n    }\n\n    /**\n     * Converts `string` to\n     * [snake case](https://en.wikipedia.org/wiki/Snake_case).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the snake cased string.\n     * @example\n     *\n     * _.snakeCase('Foo Bar');\n     * // => 'foo_bar'\n     *\n     * _.snakeCase('fooBar');\n     * // => 'foo_bar'\n     *\n     * _.snakeCase('--FOO-BAR--');\n     * // => 'foo_bar'\n     */\n    var snakeCase = createCompounder(function(result, word, index) {\n      return result + (index ? '_' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Splits `string` by `separator`.\n     *\n     * **Note:** This method is based on\n     * [`String#split`](https://mdn.io/String/split).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to split.\n     * @param {RegExp|string} separator The separator pattern to split by.\n     * @param {number} [limit] The length to truncate results to.\n     * @returns {Array} Returns the string segments.\n     * @example\n     *\n     * _.split('a-b-c', '-', 2);\n     * // => ['a', 'b']\n     */\n    function split(string, separator, limit) {\n      if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) {\n        separator = limit = undefined;\n      }\n      limit = limit === undefined ? MAX_ARRAY_LENGTH : limit >>> 0;\n      if (!limit) {\n        return [];\n      }\n      string = toString(string);\n      if (string && (\n            typeof separator == 'string' ||\n            (separator != null && !isRegExp(separator))\n          )) {\n        separator = baseToString(separator);\n        if (!separator && hasUnicode(string)) {\n          return castSlice(stringToArray(string), 0, limit);\n        }\n      }\n      return string.split(separator, limit);\n    }\n\n    /**\n     * Converts `string` to\n     * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.1.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the start cased string.\n     * @example\n     *\n     * _.startCase('--foo-bar--');\n     * // => 'Foo Bar'\n     *\n     * _.startCase('fooBar');\n     * // => 'Foo Bar'\n     *\n     * _.startCase('__FOO_BAR__');\n     * // => 'FOO BAR'\n     */\n    var startCase = createCompounder(function(result, word, index) {\n      return result + (index ? ' ' : '') + upperFirst(word);\n    });\n\n    /**\n     * Checks if `string` starts with the given target string.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to inspect.\n     * @param {string} [target] The string to search for.\n     * @param {number} [position=0] The position to search from.\n     * @returns {boolean} Returns `true` if `string` starts with `target`,\n     *  else `false`.\n     * @example\n     *\n     * _.startsWith('abc', 'a');\n     * // => true\n     *\n     * _.startsWith('abc', 'b');\n     * // => false\n     *\n     * _.startsWith('abc', 'b', 1);\n     * // => true\n     */\n    function startsWith(string, target, position) {\n      string = toString(string);\n      position = position == null\n        ? 0\n        : baseClamp(toInteger(position), 0, string.length);\n\n      target = baseToString(target);\n      return string.slice(position, position + target.length) == target;\n    }\n\n    /**\n     * Creates a compiled template function that can interpolate data properties\n     * in \"interpolate\" delimiters, HTML-escape interpolated data properties in\n     * \"escape\" delimiters, and execute JavaScript in \"evaluate\" delimiters. Data\n     * properties may be accessed as free variables in the template. If a setting\n     * object is given, it takes precedence over `_.templateSettings` values.\n     *\n     * **Note:** In the development build `_.template` utilizes\n     * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)\n     * for easier debugging.\n     *\n     * For more information on precompiling templates see\n     * [lodash's custom builds documentation](https://lodash.com/custom-builds).\n     *\n     * For more information on Chrome extension sandboxes see\n     * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The template string.\n     * @param {Object} [options={}] The options object.\n     * @param {RegExp} [options.escape=_.templateSettings.escape]\n     *  The HTML \"escape\" delimiter.\n     * @param {RegExp} [options.evaluate=_.templateSettings.evaluate]\n     *  The \"evaluate\" delimiter.\n     * @param {Object} [options.imports=_.templateSettings.imports]\n     *  An object to import into the template as free variables.\n     * @param {RegExp} [options.interpolate=_.templateSettings.interpolate]\n     *  The \"interpolate\" delimiter.\n     * @param {string} [options.sourceURL='lodash.templateSources[n]']\n     *  The sourceURL of the compiled template.\n     * @param {string} [options.variable='obj']\n     *  The data object variable name.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the compiled template function.\n     * @example\n     *\n     * // Use the \"interpolate\" delimiter to create a compiled template.\n     * var compiled = _.template('hello <%= user %>!');\n     * compiled({ 'user': 'fred' });\n     * // => 'hello fred!'\n     *\n     * // Use the HTML \"escape\" delimiter to escape data property values.\n     * var compiled = _.template('<b><%- value %></b>');\n     * compiled({ 'value': '<script>' });\n     * // => '<b>&lt;script&gt;</b>'\n     *\n     * // Use the \"evaluate\" delimiter to execute JavaScript and generate HTML.\n     * var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');\n     * compiled({ 'users': ['fred', 'barney'] });\n     * // => '<li>fred</li><li>barney</li>'\n     *\n     * // Use the internal `print` function in \"evaluate\" delimiters.\n     * var compiled = _.template('<% print(\"hello \" + user); %>!');\n     * compiled({ 'user': 'barney' });\n     * // => 'hello barney!'\n     *\n     * // Use the ES template literal delimiter as an \"interpolate\" delimiter.\n     * // Disable support by replacing the \"interpolate\" delimiter.\n     * var compiled = _.template('hello ${ user }!');\n     * compiled({ 'user': 'pebbles' });\n     * // => 'hello pebbles!'\n     *\n     * // Use backslashes to treat delimiters as plain text.\n     * var compiled = _.template('<%= \"\\\\<%- value %\\\\>\" %>');\n     * compiled({ 'value': 'ignored' });\n     * // => '<%- value %>'\n     *\n     * // Use the `imports` option to import `jQuery` as `jq`.\n     * var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>';\n     * var compiled = _.template(text, { 'imports': { 'jq': jQuery } });\n     * compiled({ 'users': ['fred', 'barney'] });\n     * // => '<li>fred</li><li>barney</li>'\n     *\n     * // Use the `sourceURL` option to specify a custom sourceURL for the template.\n     * var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' });\n     * compiled(data);\n     * // => Find the source of \"greeting.jst\" under the Sources tab or Resources panel of the web inspector.\n     *\n     * // Use the `variable` option to ensure a with-statement isn't used in the compiled template.\n     * var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' });\n     * compiled.source;\n     * // => function(data) {\n     * //   var __t, __p = '';\n     * //   __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!';\n     * //   return __p;\n     * // }\n     *\n     * // Use custom template delimiters.\n     * _.templateSettings.interpolate = /{{([\\s\\S]+?)}}/g;\n     * var compiled = _.template('hello {{ user }}!');\n     * compiled({ 'user': 'mustache' });\n     * // => 'hello mustache!'\n     *\n     * // Use the `source` property to inline compiled templates for meaningful\n     * // line numbers in error messages and stack traces.\n     * fs.writeFileSync(path.join(process.cwd(), 'jst.js'), '\\\n     *   var JST = {\\\n     *     \"main\": ' + _.template(mainText).source + '\\\n     *   };\\\n     * ');\n     */\n    function template(string, options, guard) {\n      // Based on John Resig's `tmpl` implementation\n      // (http://ejohn.org/blog/javascript-micro-templating/)\n      // and Laura Doktorova's doT.js (https://github.com/olado/doT).\n      var settings = lodash.templateSettings;\n\n      if (guard && isIterateeCall(string, options, guard)) {\n        options = undefined;\n      }\n      string = toString(string);\n      options = assignInWith({}, options, settings, customDefaultsAssignIn);\n\n      var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn),\n          importsKeys = keys(imports),\n          importsValues = baseValues(imports, importsKeys);\n\n      var isEscaping,\n          isEvaluating,\n          index = 0,\n          interpolate = options.interpolate || reNoMatch,\n          source = \"__p += '\";\n\n      // Compile the regexp to match each delimiter.\n      var reDelimiters = RegExp(\n        (options.escape || reNoMatch).source + '|' +\n        interpolate.source + '|' +\n        (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +\n        (options.evaluate || reNoMatch).source + '|$'\n      , 'g');\n\n      // Use a sourceURL for easier debugging.\n      var sourceURL = '//# sourceURL=' +\n        ('sourceURL' in options\n          ? options.sourceURL\n          : ('lodash.templateSources[' + (++templateCounter) + ']')\n        ) + '\\n';\n\n      string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {\n        interpolateValue || (interpolateValue = esTemplateValue);\n\n        // Escape characters that can't be included in string literals.\n        source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);\n\n        // Replace delimiters with snippets.\n        if (escapeValue) {\n          isEscaping = true;\n          source += \"' +\\n__e(\" + escapeValue + \") +\\n'\";\n        }\n        if (evaluateValue) {\n          isEvaluating = true;\n          source += \"';\\n\" + evaluateValue + \";\\n__p += '\";\n        }\n        if (interpolateValue) {\n          source += \"' +\\n((__t = (\" + interpolateValue + \")) == null ? '' : __t) +\\n'\";\n        }\n        index = offset + match.length;\n\n        // The JS engine embedded in Adobe products needs `match` returned in\n        // order to produce the correct `offset` value.\n        return match;\n      });\n\n      source += \"';\\n\";\n\n      // If `variable` is not specified wrap a with-statement around the generated\n      // code to add the data object to the top of the scope chain.\n      var variable = options.variable;\n      if (!variable) {\n        source = 'with (obj) {\\n' + source + '\\n}\\n';\n      }\n      // Cleanup code by stripping empty strings.\n      source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)\n        .replace(reEmptyStringMiddle, '$1')\n        .replace(reEmptyStringTrailing, '$1;');\n\n      // Frame code as the function body.\n      source = 'function(' + (variable || 'obj') + ') {\\n' +\n        (variable\n          ? ''\n          : 'obj || (obj = {});\\n'\n        ) +\n        \"var __t, __p = ''\" +\n        (isEscaping\n           ? ', __e = _.escape'\n           : ''\n        ) +\n        (isEvaluating\n          ? ', __j = Array.prototype.join;\\n' +\n            \"function print() { __p += __j.call(arguments, '') }\\n\"\n          : ';\\n'\n        ) +\n        source +\n        'return __p\\n}';\n\n      var result = attempt(function() {\n        return Function(importsKeys, sourceURL + 'return ' + source)\n          .apply(undefined, importsValues);\n      });\n\n      // Provide the compiled function's source by its `toString` method or\n      // the `source` property as a convenience for inlining compiled templates.\n      result.source = source;\n      if (isError(result)) {\n        throw result;\n      }\n      return result;\n    }\n\n    /**\n     * Converts `string`, as a whole, to lower case just like\n     * [String#toLowerCase](https://mdn.io/toLowerCase).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the lower cased string.\n     * @example\n     *\n     * _.toLower('--Foo-Bar--');\n     * // => '--foo-bar--'\n     *\n     * _.toLower('fooBar');\n     * // => 'foobar'\n     *\n     * _.toLower('__FOO_BAR__');\n     * // => '__foo_bar__'\n     */\n    function toLower(value) {\n      return toString(value).toLowerCase();\n    }\n\n    /**\n     * Converts `string`, as a whole, to upper case just like\n     * [String#toUpperCase](https://mdn.io/toUpperCase).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the upper cased string.\n     * @example\n     *\n     * _.toUpper('--foo-bar--');\n     * // => '--FOO-BAR--'\n     *\n     * _.toUpper('fooBar');\n     * // => 'FOOBAR'\n     *\n     * _.toUpper('__foo_bar__');\n     * // => '__FOO_BAR__'\n     */\n    function toUpper(value) {\n      return toString(value).toUpperCase();\n    }\n\n    /**\n     * Removes leading and trailing whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trim('  abc  ');\n     * // => 'abc'\n     *\n     * _.trim('-_-abc-_-', '_-');\n     * // => 'abc'\n     *\n     * _.map(['  foo  ', '  bar  '], _.trim);\n     * // => ['foo', 'bar']\n     */\n    function trim(string, chars, guard) {\n      string = toString(string);\n      if (string && (guard || chars === undefined)) {\n        return string.replace(reTrim, '');\n      }\n      if (!string || !(chars = baseToString(chars))) {\n        return string;\n      }\n      var strSymbols = stringToArray(string),\n          chrSymbols = stringToArray(chars),\n          start = charsStartIndex(strSymbols, chrSymbols),\n          end = charsEndIndex(strSymbols, chrSymbols) + 1;\n\n      return castSlice(strSymbols, start, end).join('');\n    }\n\n    /**\n     * Removes trailing whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trimEnd('  abc  ');\n     * // => '  abc'\n     *\n     * _.trimEnd('-_-abc-_-', '_-');\n     * // => '-_-abc'\n     */\n    function trimEnd(string, chars, guard) {\n      string = toString(string);\n      if (string && (guard || chars === undefined)) {\n        return string.replace(reTrimEnd, '');\n      }\n      if (!string || !(chars = baseToString(chars))) {\n        return string;\n      }\n      var strSymbols = stringToArray(string),\n          end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;\n\n      return castSlice(strSymbols, 0, end).join('');\n    }\n\n    /**\n     * Removes leading whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trimStart('  abc  ');\n     * // => 'abc  '\n     *\n     * _.trimStart('-_-abc-_-', '_-');\n     * // => 'abc-_-'\n     */\n    function trimStart(string, chars, guard) {\n      string = toString(string);\n      if (string && (guard || chars === undefined)) {\n        return string.replace(reTrimStart, '');\n      }\n      if (!string || !(chars = baseToString(chars))) {\n        return string;\n      }\n      var strSymbols = stringToArray(string),\n          start = charsStartIndex(strSymbols, stringToArray(chars));\n\n      return castSlice(strSymbols, start).join('');\n    }\n\n    /**\n     * Truncates `string` if it's longer than the given maximum string length.\n     * The last characters of the truncated string are replaced with the omission\n     * string which defaults to \"...\".\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to truncate.\n     * @param {Object} [options={}] The options object.\n     * @param {number} [options.length=30] The maximum string length.\n     * @param {string} [options.omission='...'] The string to indicate text is omitted.\n     * @param {RegExp|string} [options.separator] The separator pattern to truncate to.\n     * @returns {string} Returns the truncated string.\n     * @example\n     *\n     * _.truncate('hi-diddly-ho there, neighborino');\n     * // => 'hi-diddly-ho there, neighbo...'\n     *\n     * _.truncate('hi-diddly-ho there, neighborino', {\n     *   'length': 24,\n     *   'separator': ' '\n     * });\n     * // => 'hi-diddly-ho there,...'\n     *\n     * _.truncate('hi-diddly-ho there, neighborino', {\n     *   'length': 24,\n     *   'separator': /,? +/\n     * });\n     * // => 'hi-diddly-ho there...'\n     *\n     * _.truncate('hi-diddly-ho there, neighborino', {\n     *   'omission': ' [...]'\n     * });\n     * // => 'hi-diddly-ho there, neig [...]'\n     */\n    function truncate(string, options) {\n      var length = DEFAULT_TRUNC_LENGTH,\n          omission = DEFAULT_TRUNC_OMISSION;\n\n      if (isObject(options)) {\n        var separator = 'separator' in options ? options.separator : separator;\n        length = 'length' in options ? toInteger(options.length) : length;\n        omission = 'omission' in options ? baseToString(options.omission) : omission;\n      }\n      string = toString(string);\n\n      var strLength = string.length;\n      if (hasUnicode(string)) {\n        var strSymbols = stringToArray(string);\n        strLength = strSymbols.length;\n      }\n      if (length >= strLength) {\n        return string;\n      }\n      var end = length - stringSize(omission);\n      if (end < 1) {\n        return omission;\n      }\n      var result = strSymbols\n        ? castSlice(strSymbols, 0, end).join('')\n        : string.slice(0, end);\n\n      if (separator === undefined) {\n        return result + omission;\n      }\n      if (strSymbols) {\n        end += (result.length - end);\n      }\n      if (isRegExp(separator)) {\n        if (string.slice(end).search(separator)) {\n          var match,\n              substring = result;\n\n          if (!separator.global) {\n            separator = RegExp(separator.source, toString(reFlags.exec(separator)) + 'g');\n          }\n          separator.lastIndex = 0;\n          while ((match = separator.exec(substring))) {\n            var newEnd = match.index;\n          }\n          result = result.slice(0, newEnd === undefined ? end : newEnd);\n        }\n      } else if (string.indexOf(baseToString(separator), end) != end) {\n        var index = result.lastIndexOf(separator);\n        if (index > -1) {\n          result = result.slice(0, index);\n        }\n      }\n      return result + omission;\n    }\n\n    /**\n     * The inverse of `_.escape`; this method converts the HTML entities\n     * `&amp;`, `&lt;`, `&gt;`, `&quot;`, and `&#39;` in `string` to\n     * their corresponding characters.\n     *\n     * **Note:** No other HTML entities are unescaped. To unescape additional\n     * HTML entities use a third-party library like [_he_](https://mths.be/he).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.6.0\n     * @category String\n     * @param {string} [string=''] The string to unescape.\n     * @returns {string} Returns the unescaped string.\n     * @example\n     *\n     * _.unescape('fred, barney, &amp; pebbles');\n     * // => 'fred, barney, & pebbles'\n     */\n    function unescape(string) {\n      string = toString(string);\n      return (string && reHasEscapedHtml.test(string))\n        ? string.replace(reEscapedHtml, unescapeHtmlChar)\n        : string;\n    }\n\n    /**\n     * Converts `string`, as space separated words, to upper case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the upper cased string.\n     * @example\n     *\n     * _.upperCase('--foo-bar');\n     * // => 'FOO BAR'\n     *\n     * _.upperCase('fooBar');\n     * // => 'FOO BAR'\n     *\n     * _.upperCase('__foo_bar__');\n     * // => 'FOO BAR'\n     */\n    var upperCase = createCompounder(function(result, word, index) {\n      return result + (index ? ' ' : '') + word.toUpperCase();\n    });\n\n    /**\n     * Converts the first character of `string` to upper case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the converted string.\n     * @example\n     *\n     * _.upperFirst('fred');\n     * // => 'Fred'\n     *\n     * _.upperFirst('FRED');\n     * // => 'FRED'\n     */\n    var upperFirst = createCaseFirst('toUpperCase');\n\n    /**\n     * Splits `string` into an array of its words.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to inspect.\n     * @param {RegExp|string} [pattern] The pattern to match words.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the words of `string`.\n     * @example\n     *\n     * _.words('fred, barney, & pebbles');\n     * // => ['fred', 'barney', 'pebbles']\n     *\n     * _.words('fred, barney, & pebbles', /[^, ]+/g);\n     * // => ['fred', 'barney', '&', 'pebbles']\n     */\n    function words(string, pattern, guard) {\n      string = toString(string);\n      pattern = guard ? undefined : pattern;\n\n      if (pattern === undefined) {\n        return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);\n      }\n      return string.match(pattern) || [];\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Attempts to invoke `func`, returning either the result or the caught error\n     * object. Any additional arguments are provided to `func` when it's invoked.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {Function} func The function to attempt.\n     * @param {...*} [args] The arguments to invoke `func` with.\n     * @returns {*} Returns the `func` result or error object.\n     * @example\n     *\n     * // Avoid throwing errors for invalid selectors.\n     * var elements = _.attempt(function(selector) {\n     *   return document.querySelectorAll(selector);\n     * }, '>_>');\n     *\n     * if (_.isError(elements)) {\n     *   elements = [];\n     * }\n     */\n    var attempt = baseRest(function(func, args) {\n      try {\n        return apply(func, undefined, args);\n      } catch (e) {\n        return isError(e) ? e : new Error(e);\n      }\n    });\n\n    /**\n     * Binds methods of an object to the object itself, overwriting the existing\n     * method.\n     *\n     * **Note:** This method doesn't set the \"length\" property of bound functions.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {Object} object The object to bind and assign the bound methods to.\n     * @param {...(string|string[])} methodNames The object method names to bind.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var view = {\n     *   'label': 'docs',\n     *   'click': function() {\n     *     console.log('clicked ' + this.label);\n     *   }\n     * };\n     *\n     * _.bindAll(view, ['click']);\n     * jQuery(element).on('click', view.click);\n     * // => Logs 'clicked docs' when clicked.\n     */\n    var bindAll = flatRest(function(object, methodNames) {\n      arrayEach(methodNames, function(key) {\n        key = toKey(key);\n        baseAssignValue(object, key, bind(object[key], object));\n      });\n      return object;\n    });\n\n    /**\n     * Creates a function that iterates over `pairs` and invokes the corresponding\n     * function of the first predicate to return truthy. The predicate-function\n     * pairs are invoked with the `this` binding and arguments of the created\n     * function.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {Array} pairs The predicate-function pairs.\n     * @returns {Function} Returns the new composite function.\n     * @example\n     *\n     * var func = _.cond([\n     *   [_.matches({ 'a': 1 }),           _.constant('matches A')],\n     *   [_.conforms({ 'b': _.isNumber }), _.constant('matches B')],\n     *   [_.stubTrue,                      _.constant('no match')]\n     * ]);\n     *\n     * func({ 'a': 1, 'b': 2 });\n     * // => 'matches A'\n     *\n     * func({ 'a': 0, 'b': 1 });\n     * // => 'matches B'\n     *\n     * func({ 'a': '1', 'b': '2' });\n     * // => 'no match'\n     */\n    function cond(pairs) {\n      var length = pairs == null ? 0 : pairs.length,\n          toIteratee = getIteratee();\n\n      pairs = !length ? [] : arrayMap(pairs, function(pair) {\n        if (typeof pair[1] != 'function') {\n          throw new TypeError(FUNC_ERROR_TEXT);\n        }\n        return [toIteratee(pair[0]), pair[1]];\n      });\n\n      return baseRest(function(args) {\n        var index = -1;\n        while (++index < length) {\n          var pair = pairs[index];\n          if (apply(pair[0], this, args)) {\n            return apply(pair[1], this, args);\n          }\n        }\n      });\n    }\n\n    /**\n     * Creates a function that invokes the predicate properties of `source` with\n     * the corresponding property values of a given object, returning `true` if\n     * all predicates return truthy, else `false`.\n     *\n     * **Note:** The created function is equivalent to `_.conformsTo` with\n     * `source` partially applied.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {Function} Returns the new spec function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': 2, 'b': 1 },\n     *   { 'a': 1, 'b': 2 }\n     * ];\n     *\n     * _.filter(objects, _.conforms({ 'b': function(n) { return n > 1; } }));\n     * // => [{ 'a': 1, 'b': 2 }]\n     */\n    function conforms(source) {\n      return baseConforms(baseClone(source, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that returns `value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Util\n     * @param {*} value The value to return from the new function.\n     * @returns {Function} Returns the new constant function.\n     * @example\n     *\n     * var objects = _.times(2, _.constant({ 'a': 1 }));\n     *\n     * console.log(objects);\n     * // => [{ 'a': 1 }, { 'a': 1 }]\n     *\n     * console.log(objects[0] === objects[1]);\n     * // => true\n     */\n    function constant(value) {\n      return function() {\n        return value;\n      };\n    }\n\n    /**\n     * Checks `value` to determine whether a default value should be returned in\n     * its place. The `defaultValue` is returned if `value` is `NaN`, `null`,\n     * or `undefined`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.14.0\n     * @category Util\n     * @param {*} value The value to check.\n     * @param {*} defaultValue The default value.\n     * @returns {*} Returns the resolved value.\n     * @example\n     *\n     * _.defaultTo(1, 10);\n     * // => 1\n     *\n     * _.defaultTo(undefined, 10);\n     * // => 10\n     */\n    function defaultTo(value, defaultValue) {\n      return (value == null || value !== value) ? defaultValue : value;\n    }\n\n    /**\n     * Creates a function that returns the result of invoking the given functions\n     * with the `this` binding of the created function, where each successive\n     * invocation is supplied the return value of the previous.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [funcs] The functions to invoke.\n     * @returns {Function} Returns the new composite function.\n     * @see _.flowRight\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var addSquare = _.flow([_.add, square]);\n     * addSquare(1, 2);\n     * // => 9\n     */\n    var flow = createFlow();\n\n    /**\n     * This method is like `_.flow` except that it creates a function that\n     * invokes the given functions from right to left.\n     *\n     * @static\n     * @since 3.0.0\n     * @memberOf _\n     * @category Util\n     * @param {...(Function|Function[])} [funcs] The functions to invoke.\n     * @returns {Function} Returns the new composite function.\n     * @see _.flow\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var addSquare = _.flowRight([square, _.add]);\n     * addSquare(1, 2);\n     * // => 9\n     */\n    var flowRight = createFlow(true);\n\n    /**\n     * This method returns the first argument it receives.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {*} value Any value.\n     * @returns {*} Returns `value`.\n     * @example\n     *\n     * var object = { 'a': 1 };\n     *\n     * console.log(_.identity(object) === object);\n     * // => true\n     */\n    function identity(value) {\n      return value;\n    }\n\n    /**\n     * Creates a function that invokes `func` with the arguments of the created\n     * function. If `func` is a property name, the created function returns the\n     * property value for a given element. If `func` is an array or object, the\n     * created function returns `true` for elements that contain the equivalent\n     * source properties, otherwise it returns `false`.\n     *\n     * @static\n     * @since 4.0.0\n     * @memberOf _\n     * @category Util\n     * @param {*} [func=_.identity] The value to convert to a callback.\n     * @returns {Function} Returns the callback.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': true },\n     *   { 'user': 'fred',   'age': 40, 'active': false }\n     * ];\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));\n     * // => [{ 'user': 'barney', 'age': 36, 'active': true }]\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.filter(users, _.iteratee(['user', 'fred']));\n     * // => [{ 'user': 'fred', 'age': 40 }]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.map(users, _.iteratee('user'));\n     * // => ['barney', 'fred']\n     *\n     * // Create custom iteratee shorthands.\n     * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {\n     *   return !_.isRegExp(func) ? iteratee(func) : function(string) {\n     *     return func.test(string);\n     *   };\n     * });\n     *\n     * _.filter(['abc', 'def'], /ef/);\n     * // => ['def']\n     */\n    function iteratee(func) {\n      return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that performs a partial deep comparison between a given\n     * object and `source`, returning `true` if the given object has equivalent\n     * property values, else `false`.\n     *\n     * **Note:** The created function is equivalent to `_.isMatch` with `source`\n     * partially applied.\n     *\n     * Partial comparisons will match empty array and empty object `source`\n     * values against any array or object value, respectively. See `_.isEqual`\n     * for a list of supported value comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {Object} source The object of property values to match.\n     * @returns {Function} Returns the new spec function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': 1, 'b': 2, 'c': 3 },\n     *   { 'a': 4, 'b': 5, 'c': 6 }\n     * ];\n     *\n     * _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));\n     * // => [{ 'a': 4, 'b': 5, 'c': 6 }]\n     */\n    function matches(source) {\n      return baseMatches(baseClone(source, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that performs a partial deep comparison between the\n     * value at `path` of a given object to `srcValue`, returning `true` if the\n     * object value is equivalent, else `false`.\n     *\n     * **Note:** Partial comparisons will match empty array and empty object\n     * `srcValue` values against any array or object value, respectively. See\n     * `_.isEqual` for a list of supported value comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.2.0\n     * @category Util\n     * @param {Array|string} path The path of the property to get.\n     * @param {*} srcValue The value to match.\n     * @returns {Function} Returns the new spec function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': 1, 'b': 2, 'c': 3 },\n     *   { 'a': 4, 'b': 5, 'c': 6 }\n     * ];\n     *\n     * _.find(objects, _.matchesProperty('a', 4));\n     * // => { 'a': 4, 'b': 5, 'c': 6 }\n     */\n    function matchesProperty(path, srcValue) {\n      return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that invokes the method at `path` of a given object.\n     * Any additional arguments are provided to the invoked method.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Util\n     * @param {Array|string} path The path of the method to invoke.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {Function} Returns the new invoker function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': { 'b': _.constant(2) } },\n     *   { 'a': { 'b': _.constant(1) } }\n     * ];\n     *\n     * _.map(objects, _.method('a.b'));\n     * // => [2, 1]\n     *\n     * _.map(objects, _.method(['a', 'b']));\n     * // => [2, 1]\n     */\n    var method = baseRest(function(path, args) {\n      return function(object) {\n        return baseInvoke(object, path, args);\n      };\n    });\n\n    /**\n     * The opposite of `_.method`; this method creates a function that invokes\n     * the method at a given path of `object`. Any additional arguments are\n     * provided to the invoked method.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Util\n     * @param {Object} object The object to query.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {Function} Returns the new invoker function.\n     * @example\n     *\n     * var array = _.times(3, _.constant),\n     *     object = { 'a': array, 'b': array, 'c': array };\n     *\n     * _.map(['a[2]', 'c[0]'], _.methodOf(object));\n     * // => [2, 0]\n     *\n     * _.map([['a', '2'], ['c', '0']], _.methodOf(object));\n     * // => [2, 0]\n     */\n    var methodOf = baseRest(function(object, args) {\n      return function(path) {\n        return baseInvoke(object, path, args);\n      };\n    });\n\n    /**\n     * Adds all own enumerable string keyed function properties of a source\n     * object to the destination object. If `object` is a function, then methods\n     * are added to its prototype as well.\n     *\n     * **Note:** Use `_.runInContext` to create a pristine `lodash` function to\n     * avoid conflicts caused by modifying the original.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {Function|Object} [object=lodash] The destination object.\n     * @param {Object} source The object of functions to add.\n     * @param {Object} [options={}] The options object.\n     * @param {boolean} [options.chain=true] Specify whether mixins are chainable.\n     * @returns {Function|Object} Returns `object`.\n     * @example\n     *\n     * function vowels(string) {\n     *   return _.filter(string, function(v) {\n     *     return /[aeiou]/i.test(v);\n     *   });\n     * }\n     *\n     * _.mixin({ 'vowels': vowels });\n     * _.vowels('fred');\n     * // => ['e']\n     *\n     * _('fred').vowels().value();\n     * // => ['e']\n     *\n     * _.mixin({ 'vowels': vowels }, { 'chain': false });\n     * _('fred').vowels();\n     * // => ['e']\n     */\n    function mixin(object, source, options) {\n      var props = keys(source),\n          methodNames = baseFunctions(source, props);\n\n      if (options == null &&\n          !(isObject(source) && (methodNames.length || !props.length))) {\n        options = source;\n        source = object;\n        object = this;\n        methodNames = baseFunctions(source, keys(source));\n      }\n      var chain = !(isObject(options) && 'chain' in options) || !!options.chain,\n          isFunc = isFunction(object);\n\n      arrayEach(methodNames, function(methodName) {\n        var func = source[methodName];\n        object[methodName] = func;\n        if (isFunc) {\n          object.prototype[methodName] = function() {\n            var chainAll = this.__chain__;\n            if (chain || chainAll) {\n              var result = object(this.__wrapped__),\n                  actions = result.__actions__ = copyArray(this.__actions__);\n\n              actions.push({ 'func': func, 'args': arguments, 'thisArg': object });\n              result.__chain__ = chainAll;\n              return result;\n            }\n            return func.apply(object, arrayPush([this.value()], arguments));\n          };\n        }\n      });\n\n      return object;\n    }\n\n    /**\n     * Reverts the `_` variable to its previous value and returns a reference to\n     * the `lodash` function.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @returns {Function} Returns the `lodash` function.\n     * @example\n     *\n     * var lodash = _.noConflict();\n     */\n    function noConflict() {\n      if (root._ === this) {\n        root._ = oldDash;\n      }\n      return this;\n    }\n\n    /**\n     * This method returns `undefined`.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.3.0\n     * @category Util\n     * @example\n     *\n     * _.times(2, _.noop);\n     * // => [undefined, undefined]\n     */\n    function noop() {\n      // No operation performed.\n    }\n\n    /**\n     * Creates a function that gets the argument at index `n`. If `n` is negative,\n     * the nth argument from the end is returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {number} [n=0] The index of the argument to return.\n     * @returns {Function} Returns the new pass-thru function.\n     * @example\n     *\n     * var func = _.nthArg(1);\n     * func('a', 'b', 'c', 'd');\n     * // => 'b'\n     *\n     * var func = _.nthArg(-2);\n     * func('a', 'b', 'c', 'd');\n     * // => 'c'\n     */\n    function nthArg(n) {\n      n = toInteger(n);\n      return baseRest(function(args) {\n        return baseNth(args, n);\n      });\n    }\n\n    /**\n     * Creates a function that invokes `iteratees` with the arguments it receives\n     * and returns their results.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [iteratees=[_.identity]]\n     *  The iteratees to invoke.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var func = _.over([Math.max, Math.min]);\n     *\n     * func(1, 2, 3, 4);\n     * // => [4, 1]\n     */\n    var over = createOver(arrayMap);\n\n    /**\n     * Creates a function that checks if **all** of the `predicates` return\n     * truthy when invoked with the arguments it receives.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [predicates=[_.identity]]\n     *  The predicates to check.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var func = _.overEvery([Boolean, isFinite]);\n     *\n     * func('1');\n     * // => true\n     *\n     * func(null);\n     * // => false\n     *\n     * func(NaN);\n     * // => false\n     */\n    var overEvery = createOver(arrayEvery);\n\n    /**\n     * Creates a function that checks if **any** of the `predicates` return\n     * truthy when invoked with the arguments it receives.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [predicates=[_.identity]]\n     *  The predicates to check.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var func = _.overSome([Boolean, isFinite]);\n     *\n     * func('1');\n     * // => true\n     *\n     * func(null);\n     * // => true\n     *\n     * func(NaN);\n     * // => false\n     */\n    var overSome = createOver(arraySome);\n\n    /**\n     * Creates a function that returns the value at `path` of a given object.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Util\n     * @param {Array|string} path The path of the property to get.\n     * @returns {Function} Returns the new accessor function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': { 'b': 2 } },\n     *   { 'a': { 'b': 1 } }\n     * ];\n     *\n     * _.map(objects, _.property('a.b'));\n     * // => [2, 1]\n     *\n     * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');\n     * // => [1, 2]\n     */\n    function property(path) {\n      return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);\n    }\n\n    /**\n     * The opposite of `_.property`; this method creates a function that returns\n     * the value at a given path of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {Object} object The object to query.\n     * @returns {Function} Returns the new accessor function.\n     * @example\n     *\n     * var array = [0, 1, 2],\n     *     object = { 'a': array, 'b': array, 'c': array };\n     *\n     * _.map(['a[2]', 'c[0]'], _.propertyOf(object));\n     * // => [2, 0]\n     *\n     * _.map([['a', '2'], ['c', '0']], _.propertyOf(object));\n     * // => [2, 0]\n     */\n    function propertyOf(object) {\n      return function(path) {\n        return object == null ? undefined : baseGet(object, path);\n      };\n    }\n\n    /**\n     * Creates an array of numbers (positive and/or negative) progressing from\n     * `start` up to, but not including, `end`. A step of `-1` is used if a negative\n     * `start` is specified without an `end` or `step`. If `end` is not specified,\n     * it's set to `start` with `start` then set to `0`.\n     *\n     * **Note:** JavaScript follows the IEEE-754 standard for resolving\n     * floating-point values which can produce unexpected results.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {number} [start=0] The start of the range.\n     * @param {number} end The end of the range.\n     * @param {number} [step=1] The value to increment or decrement by.\n     * @returns {Array} Returns the range of numbers.\n     * @see _.inRange, _.rangeRight\n     * @example\n     *\n     * _.range(4);\n     * // => [0, 1, 2, 3]\n     *\n     * _.range(-4);\n     * // => [0, -1, -2, -3]\n     *\n     * _.range(1, 5);\n     * // => [1, 2, 3, 4]\n     *\n     * _.range(0, 20, 5);\n     * // => [0, 5, 10, 15]\n     *\n     * _.range(0, -4, -1);\n     * // => [0, -1, -2, -3]\n     *\n     * _.range(1, 4, 0);\n     * // => [1, 1, 1]\n     *\n     * _.range(0);\n     * // => []\n     */\n    var range = createRange();\n\n    /**\n     * This method is like `_.range` except that it populates values in\n     * descending order.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {number} [start=0] The start of the range.\n     * @param {number} end The end of the range.\n     * @param {number} [step=1] The value to increment or decrement by.\n     * @returns {Array} Returns the range of numbers.\n     * @see _.inRange, _.range\n     * @example\n     *\n     * _.rangeRight(4);\n     * // => [3, 2, 1, 0]\n     *\n     * _.rangeRight(-4);\n     * // => [-3, -2, -1, 0]\n     *\n     * _.rangeRight(1, 5);\n     * // => [4, 3, 2, 1]\n     *\n     * _.rangeRight(0, 20, 5);\n     * // => [15, 10, 5, 0]\n     *\n     * _.rangeRight(0, -4, -1);\n     * // => [-3, -2, -1, 0]\n     *\n     * _.rangeRight(1, 4, 0);\n     * // => [1, 1, 1]\n     *\n     * _.rangeRight(0);\n     * // => []\n     */\n    var rangeRight = createRange(true);\n\n    /**\n     * This method returns a new empty array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {Array} Returns the new empty array.\n     * @example\n     *\n     * var arrays = _.times(2, _.stubArray);\n     *\n     * console.log(arrays);\n     * // => [[], []]\n     *\n     * console.log(arrays[0] === arrays[1]);\n     * // => false\n     */\n    function stubArray() {\n      return [];\n    }\n\n    /**\n     * This method returns `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {boolean} Returns `false`.\n     * @example\n     *\n     * _.times(2, _.stubFalse);\n     * // => [false, false]\n     */\n    function stubFalse() {\n      return false;\n    }\n\n    /**\n     * This method returns a new empty object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {Object} Returns the new empty object.\n     * @example\n     *\n     * var objects = _.times(2, _.stubObject);\n     *\n     * console.log(objects);\n     * // => [{}, {}]\n     *\n     * console.log(objects[0] === objects[1]);\n     * // => false\n     */\n    function stubObject() {\n      return {};\n    }\n\n    /**\n     * This method returns an empty string.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {string} Returns the empty string.\n     * @example\n     *\n     * _.times(2, _.stubString);\n     * // => ['', '']\n     */\n    function stubString() {\n      return '';\n    }\n\n    /**\n     * This method returns `true`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {boolean} Returns `true`.\n     * @example\n     *\n     * _.times(2, _.stubTrue);\n     * // => [true, true]\n     */\n    function stubTrue() {\n      return true;\n    }\n\n    /**\n     * Invokes the iteratee `n` times, returning an array of the results of\n     * each invocation. The iteratee is invoked with one argument; (index).\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {number} n The number of times to invoke `iteratee`.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the array of results.\n     * @example\n     *\n     * _.times(3, String);\n     * // => ['0', '1', '2']\n     *\n     *  _.times(4, _.constant(0));\n     * // => [0, 0, 0, 0]\n     */\n    function times(n, iteratee) {\n      n = toInteger(n);\n      if (n < 1 || n > MAX_SAFE_INTEGER) {\n        return [];\n      }\n      var index = MAX_ARRAY_LENGTH,\n          length = nativeMin(n, MAX_ARRAY_LENGTH);\n\n      iteratee = getIteratee(iteratee);\n      n -= MAX_ARRAY_LENGTH;\n\n      var result = baseTimes(length, iteratee);\n      while (++index < n) {\n        iteratee(index);\n      }\n      return result;\n    }\n\n    /**\n     * Converts `value` to a property path array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {*} value The value to convert.\n     * @returns {Array} Returns the new property path array.\n     * @example\n     *\n     * _.toPath('a.b.c');\n     * // => ['a', 'b', 'c']\n     *\n     * _.toPath('a[0].b.c');\n     * // => ['a', '0', 'b', 'c']\n     */\n    function toPath(value) {\n      if (isArray(value)) {\n        return arrayMap(value, toKey);\n      }\n      return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));\n    }\n\n    /**\n     * Generates a unique ID. If `prefix` is given, the ID is appended to it.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {string} [prefix=''] The value to prefix the ID with.\n     * @returns {string} Returns the unique ID.\n     * @example\n     *\n     * _.uniqueId('contact_');\n     * // => 'contact_104'\n     *\n     * _.uniqueId();\n     * // => '105'\n     */\n    function uniqueId(prefix) {\n      var id = ++idCounter;\n      return toString(prefix) + id;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Adds two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.4.0\n     * @category Math\n     * @param {number} augend The first number in an addition.\n     * @param {number} addend The second number in an addition.\n     * @returns {number} Returns the total.\n     * @example\n     *\n     * _.add(6, 4);\n     * // => 10\n     */\n    var add = createMathOperation(function(augend, addend) {\n      return augend + addend;\n    }, 0);\n\n    /**\n     * Computes `number` rounded up to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Math\n     * @param {number} number The number to round up.\n     * @param {number} [precision=0] The precision to round up to.\n     * @returns {number} Returns the rounded up number.\n     * @example\n     *\n     * _.ceil(4.006);\n     * // => 5\n     *\n     * _.ceil(6.004, 2);\n     * // => 6.01\n     *\n     * _.ceil(6040, -2);\n     * // => 6100\n     */\n    var ceil = createRound('ceil');\n\n    /**\n     * Divide two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Math\n     * @param {number} dividend The first number in a division.\n     * @param {number} divisor The second number in a division.\n     * @returns {number} Returns the quotient.\n     * @example\n     *\n     * _.divide(6, 4);\n     * // => 1.5\n     */\n    var divide = createMathOperation(function(dividend, divisor) {\n      return dividend / divisor;\n    }, 1);\n\n    /**\n     * Computes `number` rounded down to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Math\n     * @param {number} number The number to round down.\n     * @param {number} [precision=0] The precision to round down to.\n     * @returns {number} Returns the rounded down number.\n     * @example\n     *\n     * _.floor(4.006);\n     * // => 4\n     *\n     * _.floor(0.046, 2);\n     * // => 0.04\n     *\n     * _.floor(4060, -2);\n     * // => 4000\n     */\n    var floor = createRound('floor');\n\n    /**\n     * Computes the maximum value of `array`. If `array` is empty or falsey,\n     * `undefined` is returned.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {*} Returns the maximum value.\n     * @example\n     *\n     * _.max([4, 2, 8, 6]);\n     * // => 8\n     *\n     * _.max([]);\n     * // => undefined\n     */\n    function max(array) {\n      return (array && array.length)\n        ? baseExtremum(array, identity, baseGt)\n        : undefined;\n    }\n\n    /**\n     * This method is like `_.max` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the criterion by which\n     * the value is ranked. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {*} Returns the maximum value.\n     * @example\n     *\n     * var objects = [{ 'n': 1 }, { 'n': 2 }];\n     *\n     * _.maxBy(objects, function(o) { return o.n; });\n     * // => { 'n': 2 }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.maxBy(objects, 'n');\n     * // => { 'n': 2 }\n     */\n    function maxBy(array, iteratee) {\n      return (array && array.length)\n        ? baseExtremum(array, getIteratee(iteratee, 2), baseGt)\n        : undefined;\n    }\n\n    /**\n     * Computes the mean of the values in `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {number} Returns the mean.\n     * @example\n     *\n     * _.mean([4, 2, 8, 6]);\n     * // => 5\n     */\n    function mean(array) {\n      return baseMean(array, identity);\n    }\n\n    /**\n     * This method is like `_.mean` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the value to be averaged.\n     * The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the mean.\n     * @example\n     *\n     * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];\n     *\n     * _.meanBy(objects, function(o) { return o.n; });\n     * // => 5\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.meanBy(objects, 'n');\n     * // => 5\n     */\n    function meanBy(array, iteratee) {\n      return baseMean(array, getIteratee(iteratee, 2));\n    }\n\n    /**\n     * Computes the minimum value of `array`. If `array` is empty or falsey,\n     * `undefined` is returned.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {*} Returns the minimum value.\n     * @example\n     *\n     * _.min([4, 2, 8, 6]);\n     * // => 2\n     *\n     * _.min([]);\n     * // => undefined\n     */\n    function min(array) {\n      return (array && array.length)\n        ? baseExtremum(array, identity, baseLt)\n        : undefined;\n    }\n\n    /**\n     * This method is like `_.min` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the criterion by which\n     * the value is ranked. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {*} Returns the minimum value.\n     * @example\n     *\n     * var objects = [{ 'n': 1 }, { 'n': 2 }];\n     *\n     * _.minBy(objects, function(o) { return o.n; });\n     * // => { 'n': 1 }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.minBy(objects, 'n');\n     * // => { 'n': 1 }\n     */\n    function minBy(array, iteratee) {\n      return (array && array.length)\n        ? baseExtremum(array, getIteratee(iteratee, 2), baseLt)\n        : undefined;\n    }\n\n    /**\n     * Multiply two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Math\n     * @param {number} multiplier The first number in a multiplication.\n     * @param {number} multiplicand The second number in a multiplication.\n     * @returns {number} Returns the product.\n     * @example\n     *\n     * _.multiply(6, 4);\n     * // => 24\n     */\n    var multiply = createMathOperation(function(multiplier, multiplicand) {\n      return multiplier * multiplicand;\n    }, 1);\n\n    /**\n     * Computes `number` rounded to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Math\n     * @param {number} number The number to round.\n     * @param {number} [precision=0] The precision to round to.\n     * @returns {number} Returns the rounded number.\n     * @example\n     *\n     * _.round(4.006);\n     * // => 4\n     *\n     * _.round(4.006, 2);\n     * // => 4.01\n     *\n     * _.round(4060, -2);\n     * // => 4100\n     */\n    var round = createRound('round');\n\n    /**\n     * Subtract two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {number} minuend The first number in a subtraction.\n     * @param {number} subtrahend The second number in a subtraction.\n     * @returns {number} Returns the difference.\n     * @example\n     *\n     * _.subtract(6, 4);\n     * // => 2\n     */\n    var subtract = createMathOperation(function(minuend, subtrahend) {\n      return minuend - subtrahend;\n    }, 0);\n\n    /**\n     * Computes the sum of the values in `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.4.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {number} Returns the sum.\n     * @example\n     *\n     * _.sum([4, 2, 8, 6]);\n     * // => 20\n     */\n    function sum(array) {\n      return (array && array.length)\n        ? baseSum(array, identity)\n        : 0;\n    }\n\n    /**\n     * This method is like `_.sum` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the value to be summed.\n     * The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the sum.\n     * @example\n     *\n     * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];\n     *\n     * _.sumBy(objects, function(o) { return o.n; });\n     * // => 20\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.sumBy(objects, 'n');\n     * // => 20\n     */\n    function sumBy(array, iteratee) {\n      return (array && array.length)\n        ? baseSum(array, getIteratee(iteratee, 2))\n        : 0;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    // Add methods that return wrapped values in chain sequences.\n    lodash.after = after;\n    lodash.ary = ary;\n    lodash.assign = assign;\n    lodash.assignIn = assignIn;\n    lodash.assignInWith = assignInWith;\n    lodash.assignWith = assignWith;\n    lodash.at = at;\n    lodash.before = before;\n    lodash.bind = bind;\n    lodash.bindAll = bindAll;\n    lodash.bindKey = bindKey;\n    lodash.castArray = castArray;\n    lodash.chain = chain;\n    lodash.chunk = chunk;\n    lodash.compact = compact;\n    lodash.concat = concat;\n    lodash.cond = cond;\n    lodash.conforms = conforms;\n    lodash.constant = constant;\n    lodash.countBy = countBy;\n    lodash.create = create;\n    lodash.curry = curry;\n    lodash.curryRight = curryRight;\n    lodash.debounce = debounce;\n    lodash.defaults = defaults;\n    lodash.defaultsDeep = defaultsDeep;\n    lodash.defer = defer;\n    lodash.delay = delay;\n    lodash.difference = difference;\n    lodash.differenceBy = differenceBy;\n    lodash.differenceWith = differenceWith;\n    lodash.drop = drop;\n    lodash.dropRight = dropRight;\n    lodash.dropRightWhile = dropRightWhile;\n    lodash.dropWhile = dropWhile;\n    lodash.fill = fill;\n    lodash.filter = filter;\n    lodash.flatMap = flatMap;\n    lodash.flatMapDeep = flatMapDeep;\n    lodash.flatMapDepth = flatMapDepth;\n    lodash.flatten = flatten;\n    lodash.flattenDeep = flattenDeep;\n    lodash.flattenDepth = flattenDepth;\n    lodash.flip = flip;\n    lodash.flow = flow;\n    lodash.flowRight = flowRight;\n    lodash.fromPairs = fromPairs;\n    lodash.functions = functions;\n    lodash.functionsIn = functionsIn;\n    lodash.groupBy = groupBy;\n    lodash.initial = initial;\n    lodash.intersection = intersection;\n    lodash.intersectionBy = intersectionBy;\n    lodash.intersectionWith = intersectionWith;\n    lodash.invert = invert;\n    lodash.invertBy = invertBy;\n    lodash.invokeMap = invokeMap;\n    lodash.iteratee = iteratee;\n    lodash.keyBy = keyBy;\n    lodash.keys = keys;\n    lodash.keysIn = keysIn;\n    lodash.map = map;\n    lodash.mapKeys = mapKeys;\n    lodash.mapValues = mapValues;\n    lodash.matches = matches;\n    lodash.matchesProperty = matchesProperty;\n    lodash.memoize = memoize;\n    lodash.merge = merge;\n    lodash.mergeWith = mergeWith;\n    lodash.method = method;\n    lodash.methodOf = methodOf;\n    lodash.mixin = mixin;\n    lodash.negate = negate;\n    lodash.nthArg = nthArg;\n    lodash.omit = omit;\n    lodash.omitBy = omitBy;\n    lodash.once = once;\n    lodash.orderBy = orderBy;\n    lodash.over = over;\n    lodash.overArgs = overArgs;\n    lodash.overEvery = overEvery;\n    lodash.overSome = overSome;\n    lodash.partial = partial;\n    lodash.partialRight = partialRight;\n    lodash.partition = partition;\n    lodash.pick = pick;\n    lodash.pickBy = pickBy;\n    lodash.property = property;\n    lodash.propertyOf = propertyOf;\n    lodash.pull = pull;\n    lodash.pullAll = pullAll;\n    lodash.pullAllBy = pullAllBy;\n    lodash.pullAllWith = pullAllWith;\n    lodash.pullAt = pullAt;\n    lodash.range = range;\n    lodash.rangeRight = rangeRight;\n    lodash.rearg = rearg;\n    lodash.reject = reject;\n    lodash.remove = remove;\n    lodash.rest = rest;\n    lodash.reverse = reverse;\n    lodash.sampleSize = sampleSize;\n    lodash.set = set;\n    lodash.setWith = setWith;\n    lodash.shuffle = shuffle;\n    lodash.slice = slice;\n    lodash.sortBy = sortBy;\n    lodash.sortedUniq = sortedUniq;\n    lodash.sortedUniqBy = sortedUniqBy;\n    lodash.split = split;\n    lodash.spread = spread;\n    lodash.tail = tail;\n    lodash.take = take;\n    lodash.takeRight = takeRight;\n    lodash.takeRightWhile = takeRightWhile;\n    lodash.takeWhile = takeWhile;\n    lodash.tap = tap;\n    lodash.throttle = throttle;\n    lodash.thru = thru;\n    lodash.toArray = toArray;\n    lodash.toPairs = toPairs;\n    lodash.toPairsIn = toPairsIn;\n    lodash.toPath = toPath;\n    lodash.toPlainObject = toPlainObject;\n    lodash.transform = transform;\n    lodash.unary = unary;\n    lodash.union = union;\n    lodash.unionBy = unionBy;\n    lodash.unionWith = unionWith;\n    lodash.uniq = uniq;\n    lodash.uniqBy = uniqBy;\n    lodash.uniqWith = uniqWith;\n    lodash.unset = unset;\n    lodash.unzip = unzip;\n    lodash.unzipWith = unzipWith;\n    lodash.update = update;\n    lodash.updateWith = updateWith;\n    lodash.values = values;\n    lodash.valuesIn = valuesIn;\n    lodash.without = without;\n    lodash.words = words;\n    lodash.wrap = wrap;\n    lodash.xor = xor;\n    lodash.xorBy = xorBy;\n    lodash.xorWith = xorWith;\n    lodash.zip = zip;\n    lodash.zipObject = zipObject;\n    lodash.zipObjectDeep = zipObjectDeep;\n    lodash.zipWith = zipWith;\n\n    // Add aliases.\n    lodash.entries = toPairs;\n    lodash.entriesIn = toPairsIn;\n    lodash.extend = assignIn;\n    lodash.extendWith = assignInWith;\n\n    // Add methods to `lodash.prototype`.\n    mixin(lodash, lodash);\n\n    /*------------------------------------------------------------------------*/\n\n    // Add methods that return unwrapped values in chain sequences.\n    lodash.add = add;\n    lodash.attempt = attempt;\n    lodash.camelCase = camelCase;\n    lodash.capitalize = capitalize;\n    lodash.ceil = ceil;\n    lodash.clamp = clamp;\n    lodash.clone = clone;\n    lodash.cloneDeep = cloneDeep;\n    lodash.cloneDeepWith = cloneDeepWith;\n    lodash.cloneWith = cloneWith;\n    lodash.conformsTo = conformsTo;\n    lodash.deburr = deburr;\n    lodash.defaultTo = defaultTo;\n    lodash.divide = divide;\n    lodash.endsWith = endsWith;\n    lodash.eq = eq;\n    lodash.escape = escape;\n    lodash.escapeRegExp = escapeRegExp;\n    lodash.every = every;\n    lodash.find = find;\n    lodash.findIndex = findIndex;\n    lodash.findKey = findKey;\n    lodash.findLast = findLast;\n    lodash.findLastIndex = findLastIndex;\n    lodash.findLastKey = findLastKey;\n    lodash.floor = floor;\n    lodash.forEach = forEach;\n    lodash.forEachRight = forEachRight;\n    lodash.forIn = forIn;\n    lodash.forInRight = forInRight;\n    lodash.forOwn = forOwn;\n    lodash.forOwnRight = forOwnRight;\n    lodash.get = get;\n    lodash.gt = gt;\n    lodash.gte = gte;\n    lodash.has = has;\n    lodash.hasIn = hasIn;\n    lodash.head = head;\n    lodash.identity = identity;\n    lodash.includes = includes;\n    lodash.indexOf = indexOf;\n    lodash.inRange = inRange;\n    lodash.invoke = invoke;\n    lodash.isArguments = isArguments;\n    lodash.isArray = isArray;\n    lodash.isArrayBuffer = isArrayBuffer;\n    lodash.isArrayLike = isArrayLike;\n    lodash.isArrayLikeObject = isArrayLikeObject;\n    lodash.isBoolean = isBoolean;\n    lodash.isBuffer = isBuffer;\n    lodash.isDate = isDate;\n    lodash.isElement = isElement;\n    lodash.isEmpty = isEmpty;\n    lodash.isEqual = isEqual;\n    lodash.isEqualWith = isEqualWith;\n    lodash.isError = isError;\n    lodash.isFinite = isFinite;\n    lodash.isFunction = isFunction;\n    lodash.isInteger = isInteger;\n    lodash.isLength = isLength;\n    lodash.isMap = isMap;\n    lodash.isMatch = isMatch;\n    lodash.isMatchWith = isMatchWith;\n    lodash.isNaN = isNaN;\n    lodash.isNative = isNative;\n    lodash.isNil = isNil;\n    lodash.isNull = isNull;\n    lodash.isNumber = isNumber;\n    lodash.isObject = isObject;\n    lodash.isObjectLike = isObjectLike;\n    lodash.isPlainObject = isPlainObject;\n    lodash.isRegExp = isRegExp;\n    lodash.isSafeInteger = isSafeInteger;\n    lodash.isSet = isSet;\n    lodash.isString = isString;\n    lodash.isSymbol = isSymbol;\n    lodash.isTypedArray = isTypedArray;\n    lodash.isUndefined = isUndefined;\n    lodash.isWeakMap = isWeakMap;\n    lodash.isWeakSet = isWeakSet;\n    lodash.join = join;\n    lodash.kebabCase = kebabCase;\n    lodash.last = last;\n    lodash.lastIndexOf = lastIndexOf;\n    lodash.lowerCase = lowerCase;\n    lodash.lowerFirst = lowerFirst;\n    lodash.lt = lt;\n    lodash.lte = lte;\n    lodash.max = max;\n    lodash.maxBy = maxBy;\n    lodash.mean = mean;\n    lodash.meanBy = meanBy;\n    lodash.min = min;\n    lodash.minBy = minBy;\n    lodash.stubArray = stubArray;\n    lodash.stubFalse = stubFalse;\n    lodash.stubObject = stubObject;\n    lodash.stubString = stubString;\n    lodash.stubTrue = stubTrue;\n    lodash.multiply = multiply;\n    lodash.nth = nth;\n    lodash.noConflict = noConflict;\n    lodash.noop = noop;\n    lodash.now = now;\n    lodash.pad = pad;\n    lodash.padEnd = padEnd;\n    lodash.padStart = padStart;\n    lodash.parseInt = parseInt;\n    lodash.random = random;\n    lodash.reduce = reduce;\n    lodash.reduceRight = reduceRight;\n    lodash.repeat = repeat;\n    lodash.replace = replace;\n    lodash.result = result;\n    lodash.round = round;\n    lodash.runInContext = runInContext;\n    lodash.sample = sample;\n    lodash.size = size;\n    lodash.snakeCase = snakeCase;\n    lodash.some = some;\n    lodash.sortedIndex = sortedIndex;\n    lodash.sortedIndexBy = sortedIndexBy;\n    lodash.sortedIndexOf = sortedIndexOf;\n    lodash.sortedLastIndex = sortedLastIndex;\n    lodash.sortedLastIndexBy = sortedLastIndexBy;\n    lodash.sortedLastIndexOf = sortedLastIndexOf;\n    lodash.startCase = startCase;\n    lodash.startsWith = startsWith;\n    lodash.subtract = subtract;\n    lodash.sum = sum;\n    lodash.sumBy = sumBy;\n    lodash.template = template;\n    lodash.times = times;\n    lodash.toFinite = toFinite;\n    lodash.toInteger = toInteger;\n    lodash.toLength = toLength;\n    lodash.toLower = toLower;\n    lodash.toNumber = toNumber;\n    lodash.toSafeInteger = toSafeInteger;\n    lodash.toString = toString;\n    lodash.toUpper = toUpper;\n    lodash.trim = trim;\n    lodash.trimEnd = trimEnd;\n    lodash.trimStart = trimStart;\n    lodash.truncate = truncate;\n    lodash.unescape = unescape;\n    lodash.uniqueId = uniqueId;\n    lodash.upperCase = upperCase;\n    lodash.upperFirst = upperFirst;\n\n    // Add aliases.\n    lodash.each = forEach;\n    lodash.eachRight = forEachRight;\n    lodash.first = head;\n\n    mixin(lodash, (function() {\n      var source = {};\n      baseForOwn(lodash, function(func, methodName) {\n        if (!hasOwnProperty.call(lodash.prototype, methodName)) {\n          source[methodName] = func;\n        }\n      });\n      return source;\n    }()), { 'chain': false });\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * The semantic version number.\n     *\n     * @static\n     * @memberOf _\n     * @type {string}\n     */\n    lodash.VERSION = VERSION;\n\n    // Assign default placeholders.\n    arrayEach(['bind', 'bindKey', 'curry', 'curryRight', 'partial', 'partialRight'], function(methodName) {\n      lodash[methodName].placeholder = lodash;\n    });\n\n    // Add `LazyWrapper` methods for `_.drop` and `_.take` variants.\n    arrayEach(['drop', 'take'], function(methodName, index) {\n      LazyWrapper.prototype[methodName] = function(n) {\n        n = n === undefined ? 1 : nativeMax(toInteger(n), 0);\n\n        var result = (this.__filtered__ && !index)\n          ? new LazyWrapper(this)\n          : this.clone();\n\n        if (result.__filtered__) {\n          result.__takeCount__ = nativeMin(n, result.__takeCount__);\n        } else {\n          result.__views__.push({\n            'size': nativeMin(n, MAX_ARRAY_LENGTH),\n            'type': methodName + (result.__dir__ < 0 ? 'Right' : '')\n          });\n        }\n        return result;\n      };\n\n      LazyWrapper.prototype[methodName + 'Right'] = function(n) {\n        return this.reverse()[methodName](n).reverse();\n      };\n    });\n\n    // Add `LazyWrapper` methods that accept an `iteratee` value.\n    arrayEach(['filter', 'map', 'takeWhile'], function(methodName, index) {\n      var type = index + 1,\n          isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;\n\n      LazyWrapper.prototype[methodName] = function(iteratee) {\n        var result = this.clone();\n        result.__iteratees__.push({\n          'iteratee': getIteratee(iteratee, 3),\n          'type': type\n        });\n        result.__filtered__ = result.__filtered__ || isFilter;\n        return result;\n      };\n    });\n\n    // Add `LazyWrapper` methods for `_.head` and `_.last`.\n    arrayEach(['head', 'last'], function(methodName, index) {\n      var takeName = 'take' + (index ? 'Right' : '');\n\n      LazyWrapper.prototype[methodName] = function() {\n        return this[takeName](1).value()[0];\n      };\n    });\n\n    // Add `LazyWrapper` methods for `_.initial` and `_.tail`.\n    arrayEach(['initial', 'tail'], function(methodName, index) {\n      var dropName = 'drop' + (index ? '' : 'Right');\n\n      LazyWrapper.prototype[methodName] = function() {\n        return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);\n      };\n    });\n\n    LazyWrapper.prototype.compact = function() {\n      return this.filter(identity);\n    };\n\n    LazyWrapper.prototype.find = function(predicate) {\n      return this.filter(predicate).head();\n    };\n\n    LazyWrapper.prototype.findLast = function(predicate) {\n      return this.reverse().find(predicate);\n    };\n\n    LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {\n      if (typeof path == 'function') {\n        return new LazyWrapper(this);\n      }\n      return this.map(function(value) {\n        return baseInvoke(value, path, args);\n      });\n    });\n\n    LazyWrapper.prototype.reject = function(predicate) {\n      return this.filter(negate(getIteratee(predicate)));\n    };\n\n    LazyWrapper.prototype.slice = function(start, end) {\n      start = toInteger(start);\n\n      var result = this;\n      if (result.__filtered__ && (start > 0 || end < 0)) {\n        return new LazyWrapper(result);\n      }\n      if (start < 0) {\n        result = result.takeRight(-start);\n      } else if (start) {\n        result = result.drop(start);\n      }\n      if (end !== undefined) {\n        end = toInteger(end);\n        result = end < 0 ? result.dropRight(-end) : result.take(end - start);\n      }\n      return result;\n    };\n\n    LazyWrapper.prototype.takeRightWhile = function(predicate) {\n      return this.reverse().takeWhile(predicate).reverse();\n    };\n\n    LazyWrapper.prototype.toArray = function() {\n      return this.take(MAX_ARRAY_LENGTH);\n    };\n\n    // Add `LazyWrapper` methods to `lodash.prototype`.\n    baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n      var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName),\n          isTaker = /^(?:head|last)$/.test(methodName),\n          lodashFunc = lodash[isTaker ? ('take' + (methodName == 'last' ? 'Right' : '')) : methodName],\n          retUnwrapped = isTaker || /^find/.test(methodName);\n\n      if (!lodashFunc) {\n        return;\n      }\n      lodash.prototype[methodName] = function() {\n        var value = this.__wrapped__,\n            args = isTaker ? [1] : arguments,\n            isLazy = value instanceof LazyWrapper,\n            iteratee = args[0],\n            useLazy = isLazy || isArray(value);\n\n        var interceptor = function(value) {\n          var result = lodashFunc.apply(lodash, arrayPush([value], args));\n          return (isTaker && chainAll) ? result[0] : result;\n        };\n\n        if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) {\n          // Avoid lazy use if the iteratee has a \"length\" value other than `1`.\n          isLazy = useLazy = false;\n        }\n        var chainAll = this.__chain__,\n            isHybrid = !!this.__actions__.length,\n            isUnwrapped = retUnwrapped && !chainAll,\n            onlyLazy = isLazy && !isHybrid;\n\n        if (!retUnwrapped && useLazy) {\n          value = onlyLazy ? value : new LazyWrapper(this);\n          var result = func.apply(value, args);\n          result.__actions__.push({ 'func': thru, 'args': [interceptor], 'thisArg': undefined });\n          return new LodashWrapper(result, chainAll);\n        }\n        if (isUnwrapped && onlyLazy) {\n          return func.apply(this, args);\n        }\n        result = this.thru(interceptor);\n        return isUnwrapped ? (isTaker ? result.value()[0] : result.value()) : result;\n      };\n    });\n\n    // Add `Array` methods to `lodash.prototype`.\n    arrayEach(['pop', 'push', 'shift', 'sort', 'splice', 'unshift'], function(methodName) {\n      var func = arrayProto[methodName],\n          chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru',\n          retUnwrapped = /^(?:pop|shift)$/.test(methodName);\n\n      lodash.prototype[methodName] = function() {\n        var args = arguments;\n        if (retUnwrapped && !this.__chain__) {\n          var value = this.value();\n          return func.apply(isArray(value) ? value : [], args);\n        }\n        return this[chainName](function(value) {\n          return func.apply(isArray(value) ? value : [], args);\n        });\n      };\n    });\n\n    // Map minified method names to their real names.\n    baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n      var lodashFunc = lodash[methodName];\n      if (lodashFunc) {\n        var key = (lodashFunc.name + ''),\n            names = realNames[key] || (realNames[key] = []);\n\n        names.push({ 'name': methodName, 'func': lodashFunc });\n      }\n    });\n\n    realNames[createHybrid(undefined, WRAP_BIND_KEY_FLAG).name] = [{\n      'name': 'wrapper',\n      'func': undefined\n    }];\n\n    // Add methods to `LazyWrapper`.\n    LazyWrapper.prototype.clone = lazyClone;\n    LazyWrapper.prototype.reverse = lazyReverse;\n    LazyWrapper.prototype.value = lazyValue;\n\n    // Add chain sequence methods to the `lodash` wrapper.\n    lodash.prototype.at = wrapperAt;\n    lodash.prototype.chain = wrapperChain;\n    lodash.prototype.commit = wrapperCommit;\n    lodash.prototype.next = wrapperNext;\n    lodash.prototype.plant = wrapperPlant;\n    lodash.prototype.reverse = wrapperReverse;\n    lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;\n\n    // Add lazy aliases.\n    lodash.prototype.first = lodash.prototype.head;\n\n    if (symIterator) {\n      lodash.prototype[symIterator] = wrapperToIterator;\n    }\n    return lodash;\n  });\n\n  /*--------------------------------------------------------------------------*/\n\n  // Export lodash.\n  var _ = runInContext();\n\n  // Some AMD build optimizers, like r.js, check for condition patterns like:\n  if (true) {\n    // Expose Lodash on the global object to prevent errors when Lodash is\n    // loaded by a script tag in the presence of an AMD loader.\n    // See http://requirejs.org/docs/errors.html#mismatch for more details.\n    // Use `_.noConflict` to remove Lodash from the global object.\n    root._ = _;\n\n    // Define as an anonymous module so, through path mapping, it can be\n    // referenced as the \"underscore\" module.\n    !(__WEBPACK_AMD_DEFINE_RESULT__ = function() {\n      return _;\n    }.call(exports, __webpack_require__, exports, module),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n  }\n  // Check for `exports` after `define` in case a build optimizer adds it.\n  else if (freeModule) {\n    // Export for Node.js.\n    (freeModule.exports = _)._ = _;\n    // Export for CommonJS support.\n    freeExports._ = _;\n  }\n  else {\n    // Export to the global object.\n    root._ = _;\n  }\n}.call(this));\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(34), __webpack_require__(134)(module)))\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// Thank's IE8 for his funny defineProperty\nmodule.exports = !__webpack_require__(27)(function(){\n  return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;\n});\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports) {\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nvar global = module.exports = typeof window != 'undefined' && window.Math == Math\n  ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();\nif(typeof __g == 'number')__g = global; // eslint-disable-line no-undef\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar anObject       = __webpack_require__(9)\n  , IE8_DOM_DEFINE = __webpack_require__(67)\n  , toPrimitive    = __webpack_require__(83)\n  , dP             = Object.defineProperty;\n\nexports.f = __webpack_require__(4) ? Object.defineProperty : function defineProperty(O, P, Attributes){\n  anObject(O);\n  P = toPrimitive(P, true);\n  anObject(Attributes);\n  if(IE8_DOM_DEFINE)try {\n    return dP(O, P, Attributes);\n  } catch(e){ /* empty */ }\n  if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');\n  if('value' in Attributes)O[P] = Attributes.value;\n  return O;\n};\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nexports.__esModule = true;\n\nexports.default = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nexports.__esModule = true;\n\nvar _defineProperty = __webpack_require__(58);\n\nvar _defineProperty2 = _interopRequireDefault(_defineProperty);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      (0, _defineProperty2.default)(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar isObject = __webpack_require__(16);\nmodule.exports = function(it){\n  if(!isObject(it))throw TypeError(it + ' is not an object!');\n  return it;\n};\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports) {\n\nvar core = module.exports = {version: '2.4.0'};\nif(typeof __e == 'number')__e = core; // eslint-disable-line no-undef\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports) {\n\nvar hasOwnProperty = {}.hasOwnProperty;\nmodule.exports = function(it, key){\n  return hasOwnProperty.call(it, key);\n};\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar dP         = __webpack_require__(6)\n  , createDesc = __webpack_require__(18);\nmodule.exports = __webpack_require__(4) ? function(object, key, value){\n  return dP.f(object, key, createDesc(1, value));\n} : function(object, key, value){\n  object[key] = value;\n  return object;\n};\n\n/***/ }),\n/* 13 */,\n/* 14 */\n/***/ (function(module, exports) {\n\n// 7.2.1 RequireObjectCoercible(argument)\nmodule.exports = function(it){\n  if(it == undefined)throw TypeError(\"Can't call method on  \" + it);\n  return it;\n};\n\n/***/ }),\n/* 15 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar global    = __webpack_require__(5)\n  , core      = __webpack_require__(10)\n  , ctx       = __webpack_require__(24)\n  , hide      = __webpack_require__(12)\n  , PROTOTYPE = 'prototype';\n\nvar $export = function(type, name, source){\n  var IS_FORCED = type & $export.F\n    , IS_GLOBAL = type & $export.G\n    , IS_STATIC = type & $export.S\n    , IS_PROTO  = type & $export.P\n    , IS_BIND   = type & $export.B\n    , IS_WRAP   = type & $export.W\n    , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})\n    , expProto  = exports[PROTOTYPE]\n    , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]\n    , key, own, out;\n  if(IS_GLOBAL)source = name;\n  for(key in source){\n    // contains in native\n    own = !IS_FORCED && target && target[key] !== undefined;\n    if(own && key in exports)continue;\n    // export native or passed\n    out = own ? target[key] : source[key];\n    // prevent global pollution for namespaces\n    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]\n    // bind timers to global for call from export context\n    : IS_BIND && own ? ctx(out, global)\n    // wrap global constructors for prevent change them in library\n    : IS_WRAP && target[key] == out ? (function(C){\n      var F = function(a, b, c){\n        if(this instanceof C){\n          switch(arguments.length){\n            case 0: return new C;\n            case 1: return new C(a);\n            case 2: return new C(a, b);\n          } return new C(a, b, c);\n        } return C.apply(this, arguments);\n      };\n      F[PROTOTYPE] = C[PROTOTYPE];\n      return F;\n    // make static versions for prototype methods\n    })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;\n    // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%\n    if(IS_PROTO){\n      (exports.virtual || (exports.virtual = {}))[key] = out;\n      // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%\n      if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out);\n    }\n  }\n};\n// type bitmap\n$export.F = 1;   // forced\n$export.G = 2;   // global\n$export.S = 4;   // static\n$export.P = 8;   // proto\n$export.B = 16;  // bind\n$export.W = 32;  // wrap\n$export.U = 64;  // safe\n$export.R = 128; // real proto method for `library` \nmodule.exports = $export;\n\n/***/ }),\n/* 16 */\n/***/ (function(module, exports) {\n\nmodule.exports = function(it){\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n\n/***/ }),\n/* 17 */\n/***/ (function(module, exports) {\n\nmodule.exports = {};\n\n/***/ }),\n/* 18 */\n/***/ (function(module, exports) {\n\nmodule.exports = function(bitmap, value){\n  return {\n    enumerable  : !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable    : !(bitmap & 4),\n    value       : value\n  };\n};\n\n/***/ }),\n/* 19 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar shared = __webpack_require__(29)('keys')\n  , uid    = __webpack_require__(33);\nmodule.exports = function(key){\n  return shared[key] || (shared[key] = uid(key));\n};\n\n/***/ }),\n/* 20 */\n/***/ (function(module, exports) {\n\n// 7.1.4 ToInteger\nvar ceil  = Math.ceil\n  , floor = Math.floor;\nmodule.exports = function(it){\n  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);\n};\n\n/***/ }),\n/* 21 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nfunction objectConverter(columns) {\n  return new Function(\"d\", \"return {\" + columns.map(function(name, i) {\n    return JSON.stringify(name) + \": d[\" + i + \"]\";\n  }).join(\",\") + \"}\");\n}\n\nfunction customConverter(columns, f) {\n  var object = objectConverter(columns);\n  return function(row, i) {\n    return f(object(row), i, columns);\n  };\n}\n\n// Compute unique columns in order of discovery.\nfunction inferColumns(rows) {\n  var columnSet = Object.create(null),\n      columns = [];\n\n  rows.forEach(function(row) {\n    for (var column in row) {\n      if (!(column in columnSet)) {\n        columns.push(columnSet[column] = column);\n      }\n    }\n  });\n\n  return columns;\n}\n\n/* harmony default export */ __webpack_exports__[\"a\"] = function(delimiter) {\n  var reFormat = new RegExp(\"[\\\"\" + delimiter + \"\\n]\"),\n      delimiterCode = delimiter.charCodeAt(0);\n\n  function parse(text, f) {\n    var convert, columns, rows = parseRows(text, function(row, i) {\n      if (convert) return convert(row, i - 1);\n      columns = row, convert = f ? customConverter(row, f) : objectConverter(row);\n    });\n    rows.columns = columns;\n    return rows;\n  }\n\n  function parseRows(text, f) {\n    var EOL = {}, // sentinel value for end-of-line\n        EOF = {}, // sentinel value for end-of-file\n        rows = [], // output rows\n        N = text.length,\n        I = 0, // current character index\n        n = 0, // the current line number\n        t, // the current token\n        eol; // is the current token followed by EOL?\n\n    function token() {\n      if (I >= N) return EOF; // special case: end of file\n      if (eol) return eol = false, EOL; // special case: end of line\n\n      // special case: quotes\n      var j = I, c;\n      if (text.charCodeAt(j) === 34) {\n        var i = j;\n        while (i++ < N) {\n          if (text.charCodeAt(i) === 34) {\n            if (text.charCodeAt(i + 1) !== 34) break;\n            ++i;\n          }\n        }\n        I = i + 2;\n        c = text.charCodeAt(i + 1);\n        if (c === 13) {\n          eol = true;\n          if (text.charCodeAt(i + 2) === 10) ++I;\n        } else if (c === 10) {\n          eol = true;\n        }\n        return text.slice(j + 1, i).replace(/\"\"/g, \"\\\"\");\n      }\n\n      // common case: find next delimiter or newline\n      while (I < N) {\n        var k = 1;\n        c = text.charCodeAt(I++);\n        if (c === 10) eol = true; // \\n\n        else if (c === 13) { eol = true; if (text.charCodeAt(I) === 10) ++I, ++k; } // \\r|\\r\\n\n        else if (c !== delimiterCode) continue;\n        return text.slice(j, I - k);\n      }\n\n      // special case: last token before EOF\n      return text.slice(j);\n    }\n\n    while ((t = token()) !== EOF) {\n      var a = [];\n      while (t !== EOL && t !== EOF) {\n        a.push(t);\n        t = token();\n      }\n      if (f && (a = f(a, n++)) == null) continue;\n      rows.push(a);\n    }\n\n    return rows;\n  }\n\n  function format(rows, columns) {\n    if (columns == null) columns = inferColumns(rows);\n    return [columns.map(formatValue).join(delimiter)].concat(rows.map(function(row) {\n      return columns.map(function(column) {\n        return formatValue(row[column]);\n      }).join(delimiter);\n    })).join(\"\\n\");\n  }\n\n  function formatRows(rows) {\n    return rows.map(formatRow).join(\"\\n\");\n  }\n\n  function formatRow(row) {\n    return row.map(formatValue).join(delimiter);\n  }\n\n  function formatValue(text) {\n    return text == null ? \"\"\n        : reFormat.test(text += \"\") ? \"\\\"\" + text.replace(/\\\"/g, \"\\\"\\\"\") + \"\\\"\"\n        : text;\n  }\n\n  return {\n    parse: parse,\n    parseRows: parseRows,\n    format: format,\n    formatRows: formatRows\n  };\n};\n\n\n/***/ }),\n/* 22 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/*!\n * Vue.js v2.1.10\n * (c) 2014-2017 Evan You\n * Released under the MIT License.\n */\n\n\n/*  */\n\n/**\n * Convert a value to a string that is actually rendered.\n */\nfunction _toString (val) {\n  return val == null\n    ? ''\n    : typeof val === 'object'\n      ? JSON.stringify(val, null, 2)\n      : String(val)\n}\n\n/**\n * Convert a input value to a number for persistence.\n * If the conversion fails, return original string.\n */\nfunction toNumber (val) {\n  var n = parseFloat(val);\n  return isNaN(n) ? val : n\n}\n\n/**\n * Make a map and return a function for checking if a key\n * is in that map.\n */\nfunction makeMap (\n  str,\n  expectsLowerCase\n) {\n  var map = Object.create(null);\n  var list = str.split(',');\n  for (var i = 0; i < list.length; i++) {\n    map[list[i]] = true;\n  }\n  return expectsLowerCase\n    ? function (val) { return map[val.toLowerCase()]; }\n    : function (val) { return map[val]; }\n}\n\n/**\n * Check if a tag is a built-in tag.\n */\nvar isBuiltInTag = makeMap('slot,component', true);\n\n/**\n * Remove an item from an array\n */\nfunction remove$1 (arr, item) {\n  if (arr.length) {\n    var index = arr.indexOf(item);\n    if (index > -1) {\n      return arr.splice(index, 1)\n    }\n  }\n}\n\n/**\n * Check whether the object has the property.\n */\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction hasOwn (obj, key) {\n  return hasOwnProperty.call(obj, key)\n}\n\n/**\n * Check if value is primitive\n */\nfunction isPrimitive (value) {\n  return typeof value === 'string' || typeof value === 'number'\n}\n\n/**\n * Create a cached version of a pure function.\n */\nfunction cached (fn) {\n  var cache = Object.create(null);\n  return (function cachedFn (str) {\n    var hit = cache[str];\n    return hit || (cache[str] = fn(str))\n  })\n}\n\n/**\n * Camelize a hyphen-delimited string.\n */\nvar camelizeRE = /-(\\w)/g;\nvar camelize = cached(function (str) {\n  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })\n});\n\n/**\n * Capitalize a string.\n */\nvar capitalize = cached(function (str) {\n  return str.charAt(0).toUpperCase() + str.slice(1)\n});\n\n/**\n * Hyphenate a camelCase string.\n */\nvar hyphenateRE = /([^-])([A-Z])/g;\nvar hyphenate = cached(function (str) {\n  return str\n    .replace(hyphenateRE, '$1-$2')\n    .replace(hyphenateRE, '$1-$2')\n    .toLowerCase()\n});\n\n/**\n * Simple bind, faster than native\n */\nfunction bind$1 (fn, ctx) {\n  function boundFn (a) {\n    var l = arguments.length;\n    return l\n      ? l > 1\n        ? fn.apply(ctx, arguments)\n        : fn.call(ctx, a)\n      : fn.call(ctx)\n  }\n  // record original fn length\n  boundFn._length = fn.length;\n  return boundFn\n}\n\n/**\n * Convert an Array-like object to a real Array.\n */\nfunction toArray (list, start) {\n  start = start || 0;\n  var i = list.length - start;\n  var ret = new Array(i);\n  while (i--) {\n    ret[i] = list[i + start];\n  }\n  return ret\n}\n\n/**\n * Mix properties into target object.\n */\nfunction extend (to, _from) {\n  for (var key in _from) {\n    to[key] = _from[key];\n  }\n  return to\n}\n\n/**\n * Quick object check - this is primarily used to tell\n * Objects from primitive values when we know the value\n * is a JSON-compliant type.\n */\nfunction isObject (obj) {\n  return obj !== null && typeof obj === 'object'\n}\n\n/**\n * Strict object type check. Only returns true\n * for plain JavaScript objects.\n */\nvar toString = Object.prototype.toString;\nvar OBJECT_STRING = '[object Object]';\nfunction isPlainObject (obj) {\n  return toString.call(obj) === OBJECT_STRING\n}\n\n/**\n * Merge an Array of Objects into a single Object.\n */\nfunction toObject (arr) {\n  var res = {};\n  for (var i = 0; i < arr.length; i++) {\n    if (arr[i]) {\n      extend(res, arr[i]);\n    }\n  }\n  return res\n}\n\n/**\n * Perform no operation.\n */\nfunction noop () {}\n\n/**\n * Always return false.\n */\nvar no = function () { return false; };\n\n/**\n * Return same value\n */\nvar identity = function (_) { return _; };\n\n/**\n * Generate a static keys string from compiler modules.\n */\nfunction genStaticKeys (modules) {\n  return modules.reduce(function (keys, m) {\n    return keys.concat(m.staticKeys || [])\n  }, []).join(',')\n}\n\n/**\n * Check if two values are loosely equal - that is,\n * if they are plain objects, do they have the same shape?\n */\nfunction looseEqual (a, b) {\n  var isObjectA = isObject(a);\n  var isObjectB = isObject(b);\n  if (isObjectA && isObjectB) {\n    return JSON.stringify(a) === JSON.stringify(b)\n  } else if (!isObjectA && !isObjectB) {\n    return String(a) === String(b)\n  } else {\n    return false\n  }\n}\n\nfunction looseIndexOf (arr, val) {\n  for (var i = 0; i < arr.length; i++) {\n    if (looseEqual(arr[i], val)) { return i }\n  }\n  return -1\n}\n\n/*  */\n\nvar config = {\n  /**\n   * Option merge strategies (used in core/util/options)\n   */\n  optionMergeStrategies: Object.create(null),\n\n  /**\n   * Whether to suppress warnings.\n   */\n  silent: false,\n\n  /**\n   * Whether to enable devtools\n   */\n  devtools: \"production\" !== 'production',\n\n  /**\n   * Error handler for watcher errors\n   */\n  errorHandler: null,\n\n  /**\n   * Ignore certain custom elements\n   */\n  ignoredElements: [],\n\n  /**\n   * Custom user key aliases for v-on\n   */\n  keyCodes: Object.create(null),\n\n  /**\n   * Check if a tag is reserved so that it cannot be registered as a\n   * component. This is platform-dependent and may be overwritten.\n   */\n  isReservedTag: no,\n\n  /**\n   * Check if a tag is an unknown element.\n   * Platform-dependent.\n   */\n  isUnknownElement: no,\n\n  /**\n   * Get the namespace of an element\n   */\n  getTagNamespace: noop,\n\n  /**\n   * Parse the real tag name for the specific platform.\n   */\n  parsePlatformTagName: identity,\n\n  /**\n   * Check if an attribute must be bound using property, e.g. value\n   * Platform-dependent.\n   */\n  mustUseProp: no,\n\n  /**\n   * List of asset types that a component can own.\n   */\n  _assetTypes: [\n    'component',\n    'directive',\n    'filter'\n  ],\n\n  /**\n   * List of lifecycle hooks.\n   */\n  _lifecycleHooks: [\n    'beforeCreate',\n    'created',\n    'beforeMount',\n    'mounted',\n    'beforeUpdate',\n    'updated',\n    'beforeDestroy',\n    'destroyed',\n    'activated',\n    'deactivated'\n  ],\n\n  /**\n   * Max circular updates allowed in a scheduler flush cycle.\n   */\n  _maxUpdateCount: 100\n};\n\n/*  */\n\n/**\n * Check if a string starts with $ or _\n */\nfunction isReserved (str) {\n  var c = (str + '').charCodeAt(0);\n  return c === 0x24 || c === 0x5F\n}\n\n/**\n * Define a property.\n */\nfunction def (obj, key, val, enumerable) {\n  Object.defineProperty(obj, key, {\n    value: val,\n    enumerable: !!enumerable,\n    writable: true,\n    configurable: true\n  });\n}\n\n/**\n * Parse simple path.\n */\nvar bailRE = /[^\\w.$]/;\nfunction parsePath (path) {\n  if (bailRE.test(path)) {\n    return\n  } else {\n    var segments = path.split('.');\n    return function (obj) {\n      for (var i = 0; i < segments.length; i++) {\n        if (!obj) { return }\n        obj = obj[segments[i]];\n      }\n      return obj\n    }\n  }\n}\n\n/*  */\n/* globals MutationObserver */\n\n// can we use __proto__?\nvar hasProto = '__proto__' in {};\n\n// Browser environment sniffing\nvar inBrowser = typeof window !== 'undefined';\nvar UA = inBrowser && window.navigator.userAgent.toLowerCase();\nvar isIE = UA && /msie|trident/.test(UA);\nvar isIE9 = UA && UA.indexOf('msie 9.0') > 0;\nvar isEdge = UA && UA.indexOf('edge/') > 0;\nvar isAndroid = UA && UA.indexOf('android') > 0;\nvar isIOS = UA && /iphone|ipad|ipod|ios/.test(UA);\n\n// this needs to be lazy-evaled because vue may be required before\n// vue-server-renderer can set VUE_ENV\nvar _isServer;\nvar isServerRendering = function () {\n  if (_isServer === undefined) {\n    /* istanbul ignore if */\n    if (!inBrowser && typeof global !== 'undefined') {\n      // detect presence of vue-server-renderer and avoid\n      // Webpack shimming the process\n      _isServer = global['process'].env.VUE_ENV === 'server';\n    } else {\n      _isServer = false;\n    }\n  }\n  return _isServer\n};\n\n// detect devtools\nvar devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;\n\n/* istanbul ignore next */\nfunction isNative (Ctor) {\n  return /native code/.test(Ctor.toString())\n}\n\n/**\n * Defer a task to execute it asynchronously.\n */\nvar nextTick = (function () {\n  var callbacks = [];\n  var pending = false;\n  var timerFunc;\n\n  function nextTickHandler () {\n    pending = false;\n    var copies = callbacks.slice(0);\n    callbacks.length = 0;\n    for (var i = 0; i < copies.length; i++) {\n      copies[i]();\n    }\n  }\n\n  // the nextTick behavior leverages the microtask queue, which can be accessed\n  // via either native Promise.then or MutationObserver.\n  // MutationObserver has wider support, however it is seriously bugged in\n  // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It\n  // completely stops working after triggering a few times... so, if native\n  // Promise is available, we will use it:\n  /* istanbul ignore if */\n  if (typeof Promise !== 'undefined' && isNative(Promise)) {\n    var p = Promise.resolve();\n    var logError = function (err) { console.error(err); };\n    timerFunc = function () {\n      p.then(nextTickHandler).catch(logError);\n      // in problematic UIWebViews, Promise.then doesn't completely break, but\n      // it can get stuck in a weird state where callbacks are pushed into the\n      // microtask queue but the queue isn't being flushed, until the browser\n      // needs to do some other work, e.g. handle a timer. Therefore we can\n      // \"force\" the microtask queue to be flushed by adding an empty timer.\n      if (isIOS) { setTimeout(noop); }\n    };\n  } else if (typeof MutationObserver !== 'undefined' && (\n    isNative(MutationObserver) ||\n    // PhantomJS and iOS 7.x\n    MutationObserver.toString() === '[object MutationObserverConstructor]'\n  )) {\n    // use MutationObserver where native Promise is not available,\n    // e.g. PhantomJS IE11, iOS7, Android 4.4\n    var counter = 1;\n    var observer = new MutationObserver(nextTickHandler);\n    var textNode = document.createTextNode(String(counter));\n    observer.observe(textNode, {\n      characterData: true\n    });\n    timerFunc = function () {\n      counter = (counter + 1) % 2;\n      textNode.data = String(counter);\n    };\n  } else {\n    // fallback to setTimeout\n    /* istanbul ignore next */\n    timerFunc = function () {\n      setTimeout(nextTickHandler, 0);\n    };\n  }\n\n  return function queueNextTick (cb, ctx) {\n    var _resolve;\n    callbacks.push(function () {\n      if (cb) { cb.call(ctx); }\n      if (_resolve) { _resolve(ctx); }\n    });\n    if (!pending) {\n      pending = true;\n      timerFunc();\n    }\n    if (!cb && typeof Promise !== 'undefined') {\n      return new Promise(function (resolve) {\n        _resolve = resolve;\n      })\n    }\n  }\n})();\n\nvar _Set;\n/* istanbul ignore if */\nif (typeof Set !== 'undefined' && isNative(Set)) {\n  // use native Set when available.\n  _Set = Set;\n} else {\n  // a non-standard Set polyfill that only works with primitive keys.\n  _Set = (function () {\n    function Set () {\n      this.set = Object.create(null);\n    }\n    Set.prototype.has = function has (key) {\n      return this.set[key] === true\n    };\n    Set.prototype.add = function add (key) {\n      this.set[key] = true;\n    };\n    Set.prototype.clear = function clear () {\n      this.set = Object.create(null);\n    };\n\n    return Set;\n  }());\n}\n\nvar warn = noop;\nvar formatComponentName;\n\nif (false) {\n  var hasConsole = typeof console !== 'undefined';\n\n  warn = function (msg, vm) {\n    if (hasConsole && (!config.silent)) {\n      console.error(\"[Vue warn]: \" + msg + \" \" + (\n        vm ? formatLocation(formatComponentName(vm)) : ''\n      ));\n    }\n  };\n\n  formatComponentName = function (vm) {\n    if (vm.$root === vm) {\n      return 'root instance'\n    }\n    var name = vm._isVue\n      ? vm.$options.name || vm.$options._componentTag\n      : vm.name;\n    return (\n      (name ? (\"component <\" + name + \">\") : \"anonymous component\") +\n      (vm._isVue && vm.$options.__file ? (\" at \" + (vm.$options.__file)) : '')\n    )\n  };\n\n  var formatLocation = function (str) {\n    if (str === 'anonymous component') {\n      str += \" - use the \\\"name\\\" option for better debugging messages.\";\n    }\n    return (\"\\n(found in \" + str + \")\")\n  };\n}\n\n/*  */\n\n\nvar uid$1 = 0;\n\n/**\n * A dep is an observable that can have multiple\n * directives subscribing to it.\n */\nvar Dep = function Dep () {\n  this.id = uid$1++;\n  this.subs = [];\n};\n\nDep.prototype.addSub = function addSub (sub) {\n  this.subs.push(sub);\n};\n\nDep.prototype.removeSub = function removeSub (sub) {\n  remove$1(this.subs, sub);\n};\n\nDep.prototype.depend = function depend () {\n  if (Dep.target) {\n    Dep.target.addDep(this);\n  }\n};\n\nDep.prototype.notify = function notify () {\n  // stablize the subscriber list first\n  var subs = this.subs.slice();\n  for (var i = 0, l = subs.length; i < l; i++) {\n    subs[i].update();\n  }\n};\n\n// the current target watcher being evaluated.\n// this is globally unique because there could be only one\n// watcher being evaluated at any time.\nDep.target = null;\nvar targetStack = [];\n\nfunction pushTarget (_target) {\n  if (Dep.target) { targetStack.push(Dep.target); }\n  Dep.target = _target;\n}\n\nfunction popTarget () {\n  Dep.target = targetStack.pop();\n}\n\n/*\n * not type checking this file because flow doesn't play well with\n * dynamically accessing methods on Array prototype\n */\n\nvar arrayProto = Array.prototype;\nvar arrayMethods = Object.create(arrayProto);[\n  'push',\n  'pop',\n  'shift',\n  'unshift',\n  'splice',\n  'sort',\n  'reverse'\n]\n.forEach(function (method) {\n  // cache original method\n  var original = arrayProto[method];\n  def(arrayMethods, method, function mutator () {\n    var arguments$1 = arguments;\n\n    // avoid leaking arguments:\n    // http://jsperf.com/closure-with-arguments\n    var i = arguments.length;\n    var args = new Array(i);\n    while (i--) {\n      args[i] = arguments$1[i];\n    }\n    var result = original.apply(this, args);\n    var ob = this.__ob__;\n    var inserted;\n    switch (method) {\n      case 'push':\n        inserted = args;\n        break\n      case 'unshift':\n        inserted = args;\n        break\n      case 'splice':\n        inserted = args.slice(2);\n        break\n    }\n    if (inserted) { ob.observeArray(inserted); }\n    // notify change\n    ob.dep.notify();\n    return result\n  });\n});\n\n/*  */\n\nvar arrayKeys = Object.getOwnPropertyNames(arrayMethods);\n\n/**\n * By default, when a reactive property is set, the new value is\n * also converted to become reactive. However when passing down props,\n * we don't want to force conversion because the value may be a nested value\n * under a frozen data structure. Converting it would defeat the optimization.\n */\nvar observerState = {\n  shouldConvert: true,\n  isSettingProps: false\n};\n\n/**\n * Observer class that are attached to each observed\n * object. Once attached, the observer converts target\n * object's property keys into getter/setters that\n * collect dependencies and dispatches updates.\n */\nvar Observer = function Observer (value) {\n  this.value = value;\n  this.dep = new Dep();\n  this.vmCount = 0;\n  def(value, '__ob__', this);\n  if (Array.isArray(value)) {\n    var augment = hasProto\n      ? protoAugment\n      : copyAugment;\n    augment(value, arrayMethods, arrayKeys);\n    this.observeArray(value);\n  } else {\n    this.walk(value);\n  }\n};\n\n/**\n * Walk through each property and convert them into\n * getter/setters. This method should only be called when\n * value type is Object.\n */\nObserver.prototype.walk = function walk (obj) {\n  var keys = Object.keys(obj);\n  for (var i = 0; i < keys.length; i++) {\n    defineReactive$$1(obj, keys[i], obj[keys[i]]);\n  }\n};\n\n/**\n * Observe a list of Array items.\n */\nObserver.prototype.observeArray = function observeArray (items) {\n  for (var i = 0, l = items.length; i < l; i++) {\n    observe(items[i]);\n  }\n};\n\n// helpers\n\n/**\n * Augment an target Object or Array by intercepting\n * the prototype chain using __proto__\n */\nfunction protoAugment (target, src) {\n  /* eslint-disable no-proto */\n  target.__proto__ = src;\n  /* eslint-enable no-proto */\n}\n\n/**\n * Augment an target Object or Array by defining\n * hidden properties.\n */\n/* istanbul ignore next */\nfunction copyAugment (target, src, keys) {\n  for (var i = 0, l = keys.length; i < l; i++) {\n    var key = keys[i];\n    def(target, key, src[key]);\n  }\n}\n\n/**\n * Attempt to create an observer instance for a value,\n * returns the new observer if successfully observed,\n * or the existing observer if the value already has one.\n */\nfunction observe (value, asRootData) {\n  if (!isObject(value)) {\n    return\n  }\n  var ob;\n  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {\n    ob = value.__ob__;\n  } else if (\n    observerState.shouldConvert &&\n    !isServerRendering() &&\n    (Array.isArray(value) || isPlainObject(value)) &&\n    Object.isExtensible(value) &&\n    !value._isVue\n  ) {\n    ob = new Observer(value);\n  }\n  if (asRootData && ob) {\n    ob.vmCount++;\n  }\n  return ob\n}\n\n/**\n * Define a reactive property on an Object.\n */\nfunction defineReactive$$1 (\n  obj,\n  key,\n  val,\n  customSetter\n) {\n  var dep = new Dep();\n\n  var property = Object.getOwnPropertyDescriptor(obj, key);\n  if (property && property.configurable === false) {\n    return\n  }\n\n  // cater for pre-defined getter/setters\n  var getter = property && property.get;\n  var setter = property && property.set;\n\n  var childOb = observe(val);\n  Object.defineProperty(obj, key, {\n    enumerable: true,\n    configurable: true,\n    get: function reactiveGetter () {\n      var value = getter ? getter.call(obj) : val;\n      if (Dep.target) {\n        dep.depend();\n        if (childOb) {\n          childOb.dep.depend();\n        }\n        if (Array.isArray(value)) {\n          dependArray(value);\n        }\n      }\n      return value\n    },\n    set: function reactiveSetter (newVal) {\n      var value = getter ? getter.call(obj) : val;\n      /* eslint-disable no-self-compare */\n      if (newVal === value || (newVal !== newVal && value !== value)) {\n        return\n      }\n      /* eslint-enable no-self-compare */\n      if (false) {\n        customSetter();\n      }\n      if (setter) {\n        setter.call(obj, newVal);\n      } else {\n        val = newVal;\n      }\n      childOb = observe(newVal);\n      dep.notify();\n    }\n  });\n}\n\n/**\n * Set a property on an object. Adds the new property and\n * triggers change notification if the property doesn't\n * already exist.\n */\nfunction set$1 (obj, key, val) {\n  if (Array.isArray(obj)) {\n    obj.length = Math.max(obj.length, key);\n    obj.splice(key, 1, val);\n    return val\n  }\n  if (hasOwn(obj, key)) {\n    obj[key] = val;\n    return\n  }\n  var ob = obj.__ob__;\n  if (obj._isVue || (ob && ob.vmCount)) {\n    \"production\" !== 'production' && warn(\n      'Avoid adding reactive properties to a Vue instance or its root $data ' +\n      'at runtime - declare it upfront in the data option.'\n    );\n    return\n  }\n  if (!ob) {\n    obj[key] = val;\n    return\n  }\n  defineReactive$$1(ob.value, key, val);\n  ob.dep.notify();\n  return val\n}\n\n/**\n * Delete a property and trigger change if necessary.\n */\nfunction del (obj, key) {\n  var ob = obj.__ob__;\n  if (obj._isVue || (ob && ob.vmCount)) {\n    \"production\" !== 'production' && warn(\n      'Avoid deleting properties on a Vue instance or its root $data ' +\n      '- just set it to null.'\n    );\n    return\n  }\n  if (!hasOwn(obj, key)) {\n    return\n  }\n  delete obj[key];\n  if (!ob) {\n    return\n  }\n  ob.dep.notify();\n}\n\n/**\n * Collect dependencies on array elements when the array is touched, since\n * we cannot intercept array element access like property getters.\n */\nfunction dependArray (value) {\n  for (var e = (void 0), i = 0, l = value.length; i < l; i++) {\n    e = value[i];\n    e && e.__ob__ && e.__ob__.dep.depend();\n    if (Array.isArray(e)) {\n      dependArray(e);\n    }\n  }\n}\n\n/*  */\n\n/**\n * Option overwriting strategies are functions that handle\n * how to merge a parent option value and a child option\n * value into the final value.\n */\nvar strats = config.optionMergeStrategies;\n\n/**\n * Options with restrictions\n */\nif (false) {\n  strats.el = strats.propsData = function (parent, child, vm, key) {\n    if (!vm) {\n      warn(\n        \"option \\\"\" + key + \"\\\" can only be used during instance \" +\n        'creation with the `new` keyword.'\n      );\n    }\n    return defaultStrat(parent, child)\n  };\n}\n\n/**\n * Helper that recursively merges two data objects together.\n */\nfunction mergeData (to, from) {\n  if (!from) { return to }\n  var key, toVal, fromVal;\n  var keys = Object.keys(from);\n  for (var i = 0; i < keys.length; i++) {\n    key = keys[i];\n    toVal = to[key];\n    fromVal = from[key];\n    if (!hasOwn(to, key)) {\n      set$1(to, key, fromVal);\n    } else if (isPlainObject(toVal) && isPlainObject(fromVal)) {\n      mergeData(toVal, fromVal);\n    }\n  }\n  return to\n}\n\n/**\n * Data\n */\nstrats.data = function (\n  parentVal,\n  childVal,\n  vm\n) {\n  if (!vm) {\n    // in a Vue.extend merge, both should be functions\n    if (!childVal) {\n      return parentVal\n    }\n    if (typeof childVal !== 'function') {\n      \"production\" !== 'production' && warn(\n        'The \"data\" option should be a function ' +\n        'that returns a per-instance value in component ' +\n        'definitions.',\n        vm\n      );\n      return parentVal\n    }\n    if (!parentVal) {\n      return childVal\n    }\n    // when parentVal & childVal are both present,\n    // we need to return a function that returns the\n    // merged result of both functions... no need to\n    // check if parentVal is a function here because\n    // it has to be a function to pass previous merges.\n    return function mergedDataFn () {\n      return mergeData(\n        childVal.call(this),\n        parentVal.call(this)\n      )\n    }\n  } else if (parentVal || childVal) {\n    return function mergedInstanceDataFn () {\n      // instance merge\n      var instanceData = typeof childVal === 'function'\n        ? childVal.call(vm)\n        : childVal;\n      var defaultData = typeof parentVal === 'function'\n        ? parentVal.call(vm)\n        : undefined;\n      if (instanceData) {\n        return mergeData(instanceData, defaultData)\n      } else {\n        return defaultData\n      }\n    }\n  }\n};\n\n/**\n * Hooks and param attributes are merged as arrays.\n */\nfunction mergeHook (\n  parentVal,\n  childVal\n) {\n  return childVal\n    ? parentVal\n      ? parentVal.concat(childVal)\n      : Array.isArray(childVal)\n        ? childVal\n        : [childVal]\n    : parentVal\n}\n\nconfig._lifecycleHooks.forEach(function (hook) {\n  strats[hook] = mergeHook;\n});\n\n/**\n * Assets\n *\n * When a vm is present (instance creation), we need to do\n * a three-way merge between constructor options, instance\n * options and parent options.\n */\nfunction mergeAssets (parentVal, childVal) {\n  var res = Object.create(parentVal || null);\n  return childVal\n    ? extend(res, childVal)\n    : res\n}\n\nconfig._assetTypes.forEach(function (type) {\n  strats[type + 's'] = mergeAssets;\n});\n\n/**\n * Watchers.\n *\n * Watchers hashes should not overwrite one\n * another, so we merge them as arrays.\n */\nstrats.watch = function (parentVal, childVal) {\n  /* istanbul ignore if */\n  if (!childVal) { return parentVal }\n  if (!parentVal) { return childVal }\n  var ret = {};\n  extend(ret, parentVal);\n  for (var key in childVal) {\n    var parent = ret[key];\n    var child = childVal[key];\n    if (parent && !Array.isArray(parent)) {\n      parent = [parent];\n    }\n    ret[key] = parent\n      ? parent.concat(child)\n      : [child];\n  }\n  return ret\n};\n\n/**\n * Other object hashes.\n */\nstrats.props =\nstrats.methods =\nstrats.computed = function (parentVal, childVal) {\n  if (!childVal) { return parentVal }\n  if (!parentVal) { return childVal }\n  var ret = Object.create(null);\n  extend(ret, parentVal);\n  extend(ret, childVal);\n  return ret\n};\n\n/**\n * Default strategy.\n */\nvar defaultStrat = function (parentVal, childVal) {\n  return childVal === undefined\n    ? parentVal\n    : childVal\n};\n\n/**\n * Validate component names\n */\nfunction checkComponents (options) {\n  for (var key in options.components) {\n    var lower = key.toLowerCase();\n    if (isBuiltInTag(lower) || config.isReservedTag(lower)) {\n      warn(\n        'Do not use built-in or reserved HTML elements as component ' +\n        'id: ' + key\n      );\n    }\n  }\n}\n\n/**\n * Ensure all props option syntax are normalized into the\n * Object-based format.\n */\nfunction normalizeProps (options) {\n  var props = options.props;\n  if (!props) { return }\n  var res = {};\n  var i, val, name;\n  if (Array.isArray(props)) {\n    i = props.length;\n    while (i--) {\n      val = props[i];\n      if (typeof val === 'string') {\n        name = camelize(val);\n        res[name] = { type: null };\n      } else if (false) {\n        warn('props must be strings when using array syntax.');\n      }\n    }\n  } else if (isPlainObject(props)) {\n    for (var key in props) {\n      val = props[key];\n      name = camelize(key);\n      res[name] = isPlainObject(val)\n        ? val\n        : { type: val };\n    }\n  }\n  options.props = res;\n}\n\n/**\n * Normalize raw function directives into object format.\n */\nfunction normalizeDirectives (options) {\n  var dirs = options.directives;\n  if (dirs) {\n    for (var key in dirs) {\n      var def = dirs[key];\n      if (typeof def === 'function') {\n        dirs[key] = { bind: def, update: def };\n      }\n    }\n  }\n}\n\n/**\n * Merge two option objects into a new one.\n * Core utility used in both instantiation and inheritance.\n */\nfunction mergeOptions (\n  parent,\n  child,\n  vm\n) {\n  if (false) {\n    checkComponents(child);\n  }\n  normalizeProps(child);\n  normalizeDirectives(child);\n  var extendsFrom = child.extends;\n  if (extendsFrom) {\n    parent = typeof extendsFrom === 'function'\n      ? mergeOptions(parent, extendsFrom.options, vm)\n      : mergeOptions(parent, extendsFrom, vm);\n  }\n  if (child.mixins) {\n    for (var i = 0, l = child.mixins.length; i < l; i++) {\n      var mixin = child.mixins[i];\n      if (mixin.prototype instanceof Vue$3) {\n        mixin = mixin.options;\n      }\n      parent = mergeOptions(parent, mixin, vm);\n    }\n  }\n  var options = {};\n  var key;\n  for (key in parent) {\n    mergeField(key);\n  }\n  for (key in child) {\n    if (!hasOwn(parent, key)) {\n      mergeField(key);\n    }\n  }\n  function mergeField (key) {\n    var strat = strats[key] || defaultStrat;\n    options[key] = strat(parent[key], child[key], vm, key);\n  }\n  return options\n}\n\n/**\n * Resolve an asset.\n * This function is used because child instances need access\n * to assets defined in its ancestor chain.\n */\nfunction resolveAsset (\n  options,\n  type,\n  id,\n  warnMissing\n) {\n  /* istanbul ignore if */\n  if (typeof id !== 'string') {\n    return\n  }\n  var assets = options[type];\n  // check local registration variations first\n  if (hasOwn(assets, id)) { return assets[id] }\n  var camelizedId = camelize(id);\n  if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }\n  var PascalCaseId = capitalize(camelizedId);\n  if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }\n  // fallback to prototype chain\n  var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];\n  if (false) {\n    warn(\n      'Failed to resolve ' + type.slice(0, -1) + ': ' + id,\n      options\n    );\n  }\n  return res\n}\n\n/*  */\n\nfunction validateProp (\n  key,\n  propOptions,\n  propsData,\n  vm\n) {\n  var prop = propOptions[key];\n  var absent = !hasOwn(propsData, key);\n  var value = propsData[key];\n  // handle boolean props\n  if (isType(Boolean, prop.type)) {\n    if (absent && !hasOwn(prop, 'default')) {\n      value = false;\n    } else if (!isType(String, prop.type) && (value === '' || value === hyphenate(key))) {\n      value = true;\n    }\n  }\n  // check default value\n  if (value === undefined) {\n    value = getPropDefaultValue(vm, prop, key);\n    // since the default value is a fresh copy,\n    // make sure to observe it.\n    var prevShouldConvert = observerState.shouldConvert;\n    observerState.shouldConvert = true;\n    observe(value);\n    observerState.shouldConvert = prevShouldConvert;\n  }\n  if (false) {\n    assertProp(prop, key, value, vm, absent);\n  }\n  return value\n}\n\n/**\n * Get the default value of a prop.\n */\nfunction getPropDefaultValue (vm, prop, key) {\n  // no default, return undefined\n  if (!hasOwn(prop, 'default')) {\n    return undefined\n  }\n  var def = prop.default;\n  // warn against non-factory defaults for Object & Array\n  if (isObject(def)) {\n    \"production\" !== 'production' && warn(\n      'Invalid default value for prop \"' + key + '\": ' +\n      'Props with type Object/Array must use a factory function ' +\n      'to return the default value.',\n      vm\n    );\n  }\n  // the raw prop value was also undefined from previous render,\n  // return previous default value to avoid unnecessary watcher trigger\n  if (vm && vm.$options.propsData &&\n    vm.$options.propsData[key] === undefined &&\n    vm[key] !== undefined) {\n    return vm[key]\n  }\n  // call factory function for non-Function types\n  return typeof def === 'function' && prop.type !== Function\n    ? def.call(vm)\n    : def\n}\n\n/**\n * Assert whether a prop is valid.\n */\nfunction assertProp (\n  prop,\n  name,\n  value,\n  vm,\n  absent\n) {\n  if (prop.required && absent) {\n    warn(\n      'Missing required prop: \"' + name + '\"',\n      vm\n    );\n    return\n  }\n  if (value == null && !prop.required) {\n    return\n  }\n  var type = prop.type;\n  var valid = !type || type === true;\n  var expectedTypes = [];\n  if (type) {\n    if (!Array.isArray(type)) {\n      type = [type];\n    }\n    for (var i = 0; i < type.length && !valid; i++) {\n      var assertedType = assertType(value, type[i]);\n      expectedTypes.push(assertedType.expectedType || '');\n      valid = assertedType.valid;\n    }\n  }\n  if (!valid) {\n    warn(\n      'Invalid prop: type check failed for prop \"' + name + '\".' +\n      ' Expected ' + expectedTypes.map(capitalize).join(', ') +\n      ', got ' + Object.prototype.toString.call(value).slice(8, -1) + '.',\n      vm\n    );\n    return\n  }\n  var validator = prop.validator;\n  if (validator) {\n    if (!validator(value)) {\n      warn(\n        'Invalid prop: custom validator check failed for prop \"' + name + '\".',\n        vm\n      );\n    }\n  }\n}\n\n/**\n * Assert the type of a value\n */\nfunction assertType (value, type) {\n  var valid;\n  var expectedType = getType(type);\n  if (expectedType === 'String') {\n    valid = typeof value === (expectedType = 'string');\n  } else if (expectedType === 'Number') {\n    valid = typeof value === (expectedType = 'number');\n  } else if (expectedType === 'Boolean') {\n    valid = typeof value === (expectedType = 'boolean');\n  } else if (expectedType === 'Function') {\n    valid = typeof value === (expectedType = 'function');\n  } else if (expectedType === 'Object') {\n    valid = isPlainObject(value);\n  } else if (expectedType === 'Array') {\n    valid = Array.isArray(value);\n  } else {\n    valid = value instanceof type;\n  }\n  return {\n    valid: valid,\n    expectedType: expectedType\n  }\n}\n\n/**\n * Use function string name to check built-in types,\n * because a simple equality check will fail when running\n * across different vms / iframes.\n */\nfunction getType (fn) {\n  var match = fn && fn.toString().match(/^\\s*function (\\w+)/);\n  return match && match[1]\n}\n\nfunction isType (type, fn) {\n  if (!Array.isArray(fn)) {\n    return getType(fn) === getType(type)\n  }\n  for (var i = 0, len = fn.length; i < len; i++) {\n    if (getType(fn[i]) === getType(type)) {\n      return true\n    }\n  }\n  /* istanbul ignore next */\n  return false\n}\n\n\n\nvar util = Object.freeze({\n\tdefineReactive: defineReactive$$1,\n\t_toString: _toString,\n\ttoNumber: toNumber,\n\tmakeMap: makeMap,\n\tisBuiltInTag: isBuiltInTag,\n\tremove: remove$1,\n\thasOwn: hasOwn,\n\tisPrimitive: isPrimitive,\n\tcached: cached,\n\tcamelize: camelize,\n\tcapitalize: capitalize,\n\thyphenate: hyphenate,\n\tbind: bind$1,\n\ttoArray: toArray,\n\textend: extend,\n\tisObject: isObject,\n\tisPlainObject: isPlainObject,\n\ttoObject: toObject,\n\tnoop: noop,\n\tno: no,\n\tidentity: identity,\n\tgenStaticKeys: genStaticKeys,\n\tlooseEqual: looseEqual,\n\tlooseIndexOf: looseIndexOf,\n\tisReserved: isReserved,\n\tdef: def,\n\tparsePath: parsePath,\n\thasProto: hasProto,\n\tinBrowser: inBrowser,\n\tUA: UA,\n\tisIE: isIE,\n\tisIE9: isIE9,\n\tisEdge: isEdge,\n\tisAndroid: isAndroid,\n\tisIOS: isIOS,\n\tisServerRendering: isServerRendering,\n\tdevtools: devtools,\n\tnextTick: nextTick,\n\tget _Set () { return _Set; },\n\tmergeOptions: mergeOptions,\n\tresolveAsset: resolveAsset,\n\tget warn () { return warn; },\n\tget formatComponentName () { return formatComponentName; },\n\tvalidateProp: validateProp\n});\n\n/* not type checking this file because flow doesn't play well with Proxy */\n\nvar initProxy;\n\nif (false) {\n  var allowedGlobals = makeMap(\n    'Infinity,undefined,NaN,isFinite,isNaN,' +\n    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +\n    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +\n    'require' // for Webpack/Browserify\n  );\n\n  var warnNonPresent = function (target, key) {\n    warn(\n      \"Property or method \\\"\" + key + \"\\\" is not defined on the instance but \" +\n      \"referenced during render. Make sure to declare reactive data \" +\n      \"properties in the data option.\",\n      target\n    );\n  };\n\n  var hasProxy =\n    typeof Proxy !== 'undefined' &&\n    Proxy.toString().match(/native code/);\n\n  if (hasProxy) {\n    var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta');\n    config.keyCodes = new Proxy(config.keyCodes, {\n      set: function set (target, key, value) {\n        if (isBuiltInModifier(key)) {\n          warn((\"Avoid overwriting built-in modifier in config.keyCodes: .\" + key));\n          return false\n        } else {\n          target[key] = value;\n          return true\n        }\n      }\n    });\n  }\n\n  var hasHandler = {\n    has: function has (target, key) {\n      var has = key in target;\n      var isAllowed = allowedGlobals(key) || key.charAt(0) === '_';\n      if (!has && !isAllowed) {\n        warnNonPresent(target, key);\n      }\n      return has || !isAllowed\n    }\n  };\n\n  var getHandler = {\n    get: function get (target, key) {\n      if (typeof key === 'string' && !(key in target)) {\n        warnNonPresent(target, key);\n      }\n      return target[key]\n    }\n  };\n\n  initProxy = function initProxy (vm) {\n    if (hasProxy) {\n      // determine which proxy handler to use\n      var options = vm.$options;\n      var handlers = options.render && options.render._withStripped\n        ? getHandler\n        : hasHandler;\n      vm._renderProxy = new Proxy(vm, handlers);\n    } else {\n      vm._renderProxy = vm;\n    }\n  };\n}\n\n/*  */\n\nvar VNode = function VNode (\n  tag,\n  data,\n  children,\n  text,\n  elm,\n  context,\n  componentOptions\n) {\n  this.tag = tag;\n  this.data = data;\n  this.children = children;\n  this.text = text;\n  this.elm = elm;\n  this.ns = undefined;\n  this.context = context;\n  this.functionalContext = undefined;\n  this.key = data && data.key;\n  this.componentOptions = componentOptions;\n  this.componentInstance = undefined;\n  this.parent = undefined;\n  this.raw = false;\n  this.isStatic = false;\n  this.isRootInsert = true;\n  this.isComment = false;\n  this.isCloned = false;\n  this.isOnce = false;\n};\n\nvar prototypeAccessors = { child: {} };\n\n// DEPRECATED: alias for componentInstance for backwards compat.\n/* istanbul ignore next */\nprototypeAccessors.child.get = function () {\n  return this.componentInstance\n};\n\nObject.defineProperties( VNode.prototype, prototypeAccessors );\n\nvar createEmptyVNode = function () {\n  var node = new VNode();\n  node.text = '';\n  node.isComment = true;\n  return node\n};\n\nfunction createTextVNode (val) {\n  return new VNode(undefined, undefined, undefined, String(val))\n}\n\n// optimized shallow clone\n// used for static nodes and slot nodes because they may be reused across\n// multiple renders, cloning them avoids errors when DOM manipulations rely\n// on their elm reference.\nfunction cloneVNode (vnode) {\n  var cloned = new VNode(\n    vnode.tag,\n    vnode.data,\n    vnode.children,\n    vnode.text,\n    vnode.elm,\n    vnode.context,\n    vnode.componentOptions\n  );\n  cloned.ns = vnode.ns;\n  cloned.isStatic = vnode.isStatic;\n  cloned.key = vnode.key;\n  cloned.isCloned = true;\n  return cloned\n}\n\nfunction cloneVNodes (vnodes) {\n  var res = new Array(vnodes.length);\n  for (var i = 0; i < vnodes.length; i++) {\n    res[i] = cloneVNode(vnodes[i]);\n  }\n  return res\n}\n\n/*  */\n\nvar hooks = { init: init, prepatch: prepatch, insert: insert, destroy: destroy$1 };\nvar hooksToMerge = Object.keys(hooks);\n\nfunction createComponent (\n  Ctor,\n  data,\n  context,\n  children,\n  tag\n) {\n  if (!Ctor) {\n    return\n  }\n\n  var baseCtor = context.$options._base;\n  if (isObject(Ctor)) {\n    Ctor = baseCtor.extend(Ctor);\n  }\n\n  if (typeof Ctor !== 'function') {\n    if (false) {\n      warn((\"Invalid Component definition: \" + (String(Ctor))), context);\n    }\n    return\n  }\n\n  // async component\n  if (!Ctor.cid) {\n    if (Ctor.resolved) {\n      Ctor = Ctor.resolved;\n    } else {\n      Ctor = resolveAsyncComponent(Ctor, baseCtor, function () {\n        // it's ok to queue this on every render because\n        // $forceUpdate is buffered by the scheduler.\n        context.$forceUpdate();\n      });\n      if (!Ctor) {\n        // return nothing if this is indeed an async component\n        // wait for the callback to trigger parent update.\n        return\n      }\n    }\n  }\n\n  // resolve constructor options in case global mixins are applied after\n  // component constructor creation\n  resolveConstructorOptions(Ctor);\n\n  data = data || {};\n\n  // extract props\n  var propsData = extractProps(data, Ctor);\n\n  // functional component\n  if (Ctor.options.functional) {\n    return createFunctionalComponent(Ctor, propsData, data, context, children)\n  }\n\n  // extract listeners, since these needs to be treated as\n  // child component listeners instead of DOM listeners\n  var listeners = data.on;\n  // replace with listeners with .native modifier\n  data.on = data.nativeOn;\n\n  if (Ctor.options.abstract) {\n    // abstract components do not keep anything\n    // other than props & listeners\n    data = {};\n  }\n\n  // merge component management hooks onto the placeholder node\n  mergeHooks(data);\n\n  // return a placeholder vnode\n  var name = Ctor.options.name || tag;\n  var vnode = new VNode(\n    (\"vue-component-\" + (Ctor.cid) + (name ? (\"-\" + name) : '')),\n    data, undefined, undefined, undefined, context,\n    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }\n  );\n  return vnode\n}\n\nfunction createFunctionalComponent (\n  Ctor,\n  propsData,\n  data,\n  context,\n  children\n) {\n  var props = {};\n  var propOptions = Ctor.options.props;\n  if (propOptions) {\n    for (var key in propOptions) {\n      props[key] = validateProp(key, propOptions, propsData);\n    }\n  }\n  // ensure the createElement function in functional components\n  // gets a unique context - this is necessary for correct named slot check\n  var _context = Object.create(context);\n  var h = function (a, b, c, d) { return createElement(_context, a, b, c, d, true); };\n  var vnode = Ctor.options.render.call(null, h, {\n    props: props,\n    data: data,\n    parent: context,\n    children: children,\n    slots: function () { return resolveSlots(children, context); }\n  });\n  if (vnode instanceof VNode) {\n    vnode.functionalContext = context;\n    if (data.slot) {\n      (vnode.data || (vnode.data = {})).slot = data.slot;\n    }\n  }\n  return vnode\n}\n\nfunction createComponentInstanceForVnode (\n  vnode, // we know it's MountedComponentVNode but flow doesn't\n  parent, // activeInstance in lifecycle state\n  parentElm,\n  refElm\n) {\n  var vnodeComponentOptions = vnode.componentOptions;\n  var options = {\n    _isComponent: true,\n    parent: parent,\n    propsData: vnodeComponentOptions.propsData,\n    _componentTag: vnodeComponentOptions.tag,\n    _parentVnode: vnode,\n    _parentListeners: vnodeComponentOptions.listeners,\n    _renderChildren: vnodeComponentOptions.children,\n    _parentElm: parentElm || null,\n    _refElm: refElm || null\n  };\n  // check inline-template render functions\n  var inlineTemplate = vnode.data.inlineTemplate;\n  if (inlineTemplate) {\n    options.render = inlineTemplate.render;\n    options.staticRenderFns = inlineTemplate.staticRenderFns;\n  }\n  return new vnodeComponentOptions.Ctor(options)\n}\n\nfunction init (\n  vnode,\n  hydrating,\n  parentElm,\n  refElm\n) {\n  if (!vnode.componentInstance || vnode.componentInstance._isDestroyed) {\n    var child = vnode.componentInstance = createComponentInstanceForVnode(\n      vnode,\n      activeInstance,\n      parentElm,\n      refElm\n    );\n    child.$mount(hydrating ? vnode.elm : undefined, hydrating);\n  } else if (vnode.data.keepAlive) {\n    // kept-alive components, treat as a patch\n    var mountedNode = vnode; // work around flow\n    prepatch(mountedNode, mountedNode);\n  }\n}\n\nfunction prepatch (\n  oldVnode,\n  vnode\n) {\n  var options = vnode.componentOptions;\n  var child = vnode.componentInstance = oldVnode.componentInstance;\n  child._updateFromParent(\n    options.propsData, // updated props\n    options.listeners, // updated listeners\n    vnode, // new parent vnode\n    options.children // new children\n  );\n}\n\nfunction insert (vnode) {\n  if (!vnode.componentInstance._isMounted) {\n    vnode.componentInstance._isMounted = true;\n    callHook(vnode.componentInstance, 'mounted');\n  }\n  if (vnode.data.keepAlive) {\n    vnode.componentInstance._inactive = false;\n    callHook(vnode.componentInstance, 'activated');\n  }\n}\n\nfunction destroy$1 (vnode) {\n  if (!vnode.componentInstance._isDestroyed) {\n    if (!vnode.data.keepAlive) {\n      vnode.componentInstance.$destroy();\n    } else {\n      vnode.componentInstance._inactive = true;\n      callHook(vnode.componentInstance, 'deactivated');\n    }\n  }\n}\n\nfunction resolveAsyncComponent (\n  factory,\n  baseCtor,\n  cb\n) {\n  if (factory.requested) {\n    // pool callbacks\n    factory.pendingCallbacks.push(cb);\n  } else {\n    factory.requested = true;\n    var cbs = factory.pendingCallbacks = [cb];\n    var sync = true;\n\n    var resolve = function (res) {\n      if (isObject(res)) {\n        res = baseCtor.extend(res);\n      }\n      // cache resolved\n      factory.resolved = res;\n      // invoke callbacks only if this is not a synchronous resolve\n      // (async resolves are shimmed as synchronous during SSR)\n      if (!sync) {\n        for (var i = 0, l = cbs.length; i < l; i++) {\n          cbs[i](res);\n        }\n      }\n    };\n\n    var reject = function (reason) {\n      \"production\" !== 'production' && warn(\n        \"Failed to resolve async component: \" + (String(factory)) +\n        (reason ? (\"\\nReason: \" + reason) : '')\n      );\n    };\n\n    var res = factory(resolve, reject);\n\n    // handle promise\n    if (res && typeof res.then === 'function' && !factory.resolved) {\n      res.then(resolve, reject);\n    }\n\n    sync = false;\n    // return in case resolved synchronously\n    return factory.resolved\n  }\n}\n\nfunction extractProps (data, Ctor) {\n  // we are only extracting raw values here.\n  // validation and default values are handled in the child\n  // component itself.\n  var propOptions = Ctor.options.props;\n  if (!propOptions) {\n    return\n  }\n  var res = {};\n  var attrs = data.attrs;\n  var props = data.props;\n  var domProps = data.domProps;\n  if (attrs || props || domProps) {\n    for (var key in propOptions) {\n      var altKey = hyphenate(key);\n      checkProp(res, props, key, altKey, true) ||\n      checkProp(res, attrs, key, altKey) ||\n      checkProp(res, domProps, key, altKey);\n    }\n  }\n  return res\n}\n\nfunction checkProp (\n  res,\n  hash,\n  key,\n  altKey,\n  preserve\n) {\n  if (hash) {\n    if (hasOwn(hash, key)) {\n      res[key] = hash[key];\n      if (!preserve) {\n        delete hash[key];\n      }\n      return true\n    } else if (hasOwn(hash, altKey)) {\n      res[key] = hash[altKey];\n      if (!preserve) {\n        delete hash[altKey];\n      }\n      return true\n    }\n  }\n  return false\n}\n\nfunction mergeHooks (data) {\n  if (!data.hook) {\n    data.hook = {};\n  }\n  for (var i = 0; i < hooksToMerge.length; i++) {\n    var key = hooksToMerge[i];\n    var fromParent = data.hook[key];\n    var ours = hooks[key];\n    data.hook[key] = fromParent ? mergeHook$1(ours, fromParent) : ours;\n  }\n}\n\nfunction mergeHook$1 (one, two) {\n  return function (a, b, c, d) {\n    one(a, b, c, d);\n    two(a, b, c, d);\n  }\n}\n\n/*  */\n\nfunction mergeVNodeHook (def, hookKey, hook, key) {\n  key = key + hookKey;\n  var injectedHash = def.__injected || (def.__injected = {});\n  if (!injectedHash[key]) {\n    injectedHash[key] = true;\n    var oldHook = def[hookKey];\n    if (oldHook) {\n      def[hookKey] = function () {\n        oldHook.apply(this, arguments);\n        hook.apply(this, arguments);\n      };\n    } else {\n      def[hookKey] = hook;\n    }\n  }\n}\n\n/*  */\n\nvar normalizeEvent = cached(function (name) {\n  var once = name.charAt(0) === '~'; // Prefixed last, checked first\n  name = once ? name.slice(1) : name;\n  var capture = name.charAt(0) === '!';\n  name = capture ? name.slice(1) : name;\n  return {\n    name: name,\n    once: once,\n    capture: capture\n  }\n});\n\nfunction createEventHandle (fn) {\n  var handle = {\n    fn: fn,\n    invoker: function () {\n      var arguments$1 = arguments;\n\n      var fn = handle.fn;\n      if (Array.isArray(fn)) {\n        for (var i = 0; i < fn.length; i++) {\n          fn[i].apply(null, arguments$1);\n        }\n      } else {\n        fn.apply(null, arguments);\n      }\n    }\n  };\n  return handle\n}\n\nfunction updateListeners (\n  on,\n  oldOn,\n  add,\n  remove$$1,\n  vm\n) {\n  var name, cur, old, event;\n  for (name in on) {\n    cur = on[name];\n    old = oldOn[name];\n    event = normalizeEvent(name);\n    if (!cur) {\n      \"production\" !== 'production' && warn(\n        \"Invalid handler for event \\\"\" + (event.name) + \"\\\": got \" + String(cur),\n        vm\n      );\n    } else if (!old) {\n      if (!cur.invoker) {\n        cur = on[name] = createEventHandle(cur);\n      }\n      add(event.name, cur.invoker, event.once, event.capture);\n    } else if (cur !== old) {\n      old.fn = cur;\n      on[name] = old;\n    }\n  }\n  for (name in oldOn) {\n    if (!on[name]) {\n      event = normalizeEvent(name);\n      remove$$1(event.name, oldOn[name].invoker, event.capture);\n    }\n  }\n}\n\n/*  */\n\n// The template compiler attempts to minimize the need for normalization by\n// statically analyzing the template at compile time.\n//\n// For plain HTML markup, normalization can be completely skipped because the\n// generated render function is guaranteed to return Array<VNode>. There are\n// two cases where extra normalization is needed:\n\n// 1. When the children contains components - because a functional component\n// may return an Array instead of a single root. In this case, just a simple\n// nomralization is needed - if any child is an Array, we flatten the whole\n// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep\n// because functional components already normalize their own children.\nfunction simpleNormalizeChildren (children) {\n  for (var i = 0; i < children.length; i++) {\n    if (Array.isArray(children[i])) {\n      return Array.prototype.concat.apply([], children)\n    }\n  }\n  return children\n}\n\n// 2. When the children contains constrcuts that always generated nested Arrays,\n// e.g. <template>, <slot>, v-for, or when the children is provided by user\n// with hand-written render functions / JSX. In such cases a full normalization\n// is needed to cater to all possible types of children values.\nfunction normalizeChildren (children) {\n  return isPrimitive(children)\n    ? [createTextVNode(children)]\n    : Array.isArray(children)\n      ? normalizeArrayChildren(children)\n      : undefined\n}\n\nfunction normalizeArrayChildren (children, nestedIndex) {\n  var res = [];\n  var i, c, last;\n  for (i = 0; i < children.length; i++) {\n    c = children[i];\n    if (c == null || typeof c === 'boolean') { continue }\n    last = res[res.length - 1];\n    //  nested\n    if (Array.isArray(c)) {\n      res.push.apply(res, normalizeArrayChildren(c, ((nestedIndex || '') + \"_\" + i)));\n    } else if (isPrimitive(c)) {\n      if (last && last.text) {\n        last.text += String(c);\n      } else if (c !== '') {\n        // convert primitive to vnode\n        res.push(createTextVNode(c));\n      }\n    } else {\n      if (c.text && last && last.text) {\n        res[res.length - 1] = createTextVNode(last.text + c.text);\n      } else {\n        // default key for nested array children (likely generated by v-for)\n        if (c.tag && c.key == null && nestedIndex != null) {\n          c.key = \"__vlist\" + nestedIndex + \"_\" + i + \"__\";\n        }\n        res.push(c);\n      }\n    }\n  }\n  return res\n}\n\n/*  */\n\nfunction getFirstComponentChild (children) {\n  return children && children.filter(function (c) { return c && c.componentOptions; })[0]\n}\n\n/*  */\n\nvar SIMPLE_NORMALIZE = 1;\nvar ALWAYS_NORMALIZE = 2;\n\n// wrapper function for providing a more flexible interface\n// without getting yelled at by flow\nfunction createElement (\n  context,\n  tag,\n  data,\n  children,\n  normalizationType,\n  alwaysNormalize\n) {\n  if (Array.isArray(data) || isPrimitive(data)) {\n    normalizationType = children;\n    children = data;\n    data = undefined;\n  }\n  if (alwaysNormalize) { normalizationType = ALWAYS_NORMALIZE; }\n  return _createElement(context, tag, data, children, normalizationType)\n}\n\nfunction _createElement (\n  context,\n  tag,\n  data,\n  children,\n  normalizationType\n) {\n  if (data && data.__ob__) {\n    \"production\" !== 'production' && warn(\n      \"Avoid using observed data object as vnode data: \" + (JSON.stringify(data)) + \"\\n\" +\n      'Always create fresh vnode data objects in each render!',\n      context\n    );\n    return createEmptyVNode()\n  }\n  if (!tag) {\n    // in case of component :is set to falsy value\n    return createEmptyVNode()\n  }\n  // support single function children as default scoped slot\n  if (Array.isArray(children) &&\n      typeof children[0] === 'function') {\n    data = data || {};\n    data.scopedSlots = { default: children[0] };\n    children.length = 0;\n  }\n  if (normalizationType === ALWAYS_NORMALIZE) {\n    children = normalizeChildren(children);\n  } else if (normalizationType === SIMPLE_NORMALIZE) {\n    children = simpleNormalizeChildren(children);\n  }\n  var vnode, ns;\n  if (typeof tag === 'string') {\n    var Ctor;\n    ns = config.getTagNamespace(tag);\n    if (config.isReservedTag(tag)) {\n      // platform built-in elements\n      vnode = new VNode(\n        config.parsePlatformTagName(tag), data, children,\n        undefined, undefined, context\n      );\n    } else if ((Ctor = resolveAsset(context.$options, 'components', tag))) {\n      // component\n      vnode = createComponent(Ctor, data, context, children, tag);\n    } else {\n      // unknown or unlisted namespaced elements\n      // check at runtime because it may get assigned a namespace when its\n      // parent normalizes children\n      vnode = new VNode(\n        tag, data, children,\n        undefined, undefined, context\n      );\n    }\n  } else {\n    // direct component options / constructor\n    vnode = createComponent(tag, data, context, children);\n  }\n  if (vnode) {\n    if (ns) { applyNS(vnode, ns); }\n    return vnode\n  } else {\n    return createEmptyVNode()\n  }\n}\n\nfunction applyNS (vnode, ns) {\n  vnode.ns = ns;\n  if (vnode.tag === 'foreignObject') {\n    // use default namespace inside foreignObject\n    return\n  }\n  if (vnode.children) {\n    for (var i = 0, l = vnode.children.length; i < l; i++) {\n      var child = vnode.children[i];\n      if (child.tag && !child.ns) {\n        applyNS(child, ns);\n      }\n    }\n  }\n}\n\n/*  */\n\nfunction initRender (vm) {\n  vm.$vnode = null; // the placeholder node in parent tree\n  vm._vnode = null; // the root of the child tree\n  vm._staticTrees = null;\n  var parentVnode = vm.$options._parentVnode;\n  var renderContext = parentVnode && parentVnode.context;\n  vm.$slots = resolveSlots(vm.$options._renderChildren, renderContext);\n  vm.$scopedSlots = {};\n  // bind the createElement fn to this instance\n  // so that we get proper render context inside it.\n  // args order: tag, data, children, normalizationType, alwaysNormalize\n  // internal version is used by render functions compiled from templates\n  vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };\n  // normalization is always applied for the public version, used in\n  // user-written render functions.\n  vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };\n}\n\nfunction renderMixin (Vue) {\n  Vue.prototype.$nextTick = function (fn) {\n    return nextTick(fn, this)\n  };\n\n  Vue.prototype._render = function () {\n    var vm = this;\n    var ref = vm.$options;\n    var render = ref.render;\n    var staticRenderFns = ref.staticRenderFns;\n    var _parentVnode = ref._parentVnode;\n\n    if (vm._isMounted) {\n      // clone slot nodes on re-renders\n      for (var key in vm.$slots) {\n        vm.$slots[key] = cloneVNodes(vm.$slots[key]);\n      }\n    }\n\n    if (_parentVnode && _parentVnode.data.scopedSlots) {\n      vm.$scopedSlots = _parentVnode.data.scopedSlots;\n    }\n\n    if (staticRenderFns && !vm._staticTrees) {\n      vm._staticTrees = [];\n    }\n    // set parent vnode. this allows render functions to have access\n    // to the data on the placeholder node.\n    vm.$vnode = _parentVnode;\n    // render self\n    var vnode;\n    try {\n      vnode = render.call(vm._renderProxy, vm.$createElement);\n    } catch (e) {\n      /* istanbul ignore else */\n      if (config.errorHandler) {\n        config.errorHandler.call(null, e, vm);\n      } else {\n        if (false) {\n          warn((\"Error when rendering \" + (formatComponentName(vm)) + \":\"));\n        }\n        throw e\n      }\n      // return previous vnode to prevent render error causing blank component\n      vnode = vm._vnode;\n    }\n    // return empty vnode in case the render function errored out\n    if (!(vnode instanceof VNode)) {\n      if (false) {\n        warn(\n          'Multiple root nodes returned from render function. Render function ' +\n          'should return a single root node.',\n          vm\n        );\n      }\n      vnode = createEmptyVNode();\n    }\n    // set parent\n    vnode.parent = _parentVnode;\n    return vnode\n  };\n\n  // toString for mustaches\n  Vue.prototype._s = _toString;\n  // convert text to vnode\n  Vue.prototype._v = createTextVNode;\n  // number conversion\n  Vue.prototype._n = toNumber;\n  // empty vnode\n  Vue.prototype._e = createEmptyVNode;\n  // loose equal\n  Vue.prototype._q = looseEqual;\n  // loose indexOf\n  Vue.prototype._i = looseIndexOf;\n\n  // render static tree by index\n  Vue.prototype._m = function renderStatic (\n    index,\n    isInFor\n  ) {\n    var tree = this._staticTrees[index];\n    // if has already-rendered static tree and not inside v-for,\n    // we can reuse the same tree by doing a shallow clone.\n    if (tree && !isInFor) {\n      return Array.isArray(tree)\n        ? cloneVNodes(tree)\n        : cloneVNode(tree)\n    }\n    // otherwise, render a fresh tree.\n    tree = this._staticTrees[index] = this.$options.staticRenderFns[index].call(this._renderProxy);\n    markStatic(tree, (\"__static__\" + index), false);\n    return tree\n  };\n\n  // mark node as static (v-once)\n  Vue.prototype._o = function markOnce (\n    tree,\n    index,\n    key\n  ) {\n    markStatic(tree, (\"__once__\" + index + (key ? (\"_\" + key) : \"\")), true);\n    return tree\n  };\n\n  function markStatic (tree, key, isOnce) {\n    if (Array.isArray(tree)) {\n      for (var i = 0; i < tree.length; i++) {\n        if (tree[i] && typeof tree[i] !== 'string') {\n          markStaticNode(tree[i], (key + \"_\" + i), isOnce);\n        }\n      }\n    } else {\n      markStaticNode(tree, key, isOnce);\n    }\n  }\n\n  function markStaticNode (node, key, isOnce) {\n    node.isStatic = true;\n    node.key = key;\n    node.isOnce = isOnce;\n  }\n\n  // filter resolution helper\n  Vue.prototype._f = function resolveFilter (id) {\n    return resolveAsset(this.$options, 'filters', id, true) || identity\n  };\n\n  // render v-for\n  Vue.prototype._l = function renderList (\n    val,\n    render\n  ) {\n    var ret, i, l, keys, key;\n    if (Array.isArray(val) || typeof val === 'string') {\n      ret = new Array(val.length);\n      for (i = 0, l = val.length; i < l; i++) {\n        ret[i] = render(val[i], i);\n      }\n    } else if (typeof val === 'number') {\n      ret = new Array(val);\n      for (i = 0; i < val; i++) {\n        ret[i] = render(i + 1, i);\n      }\n    } else if (isObject(val)) {\n      keys = Object.keys(val);\n      ret = new Array(keys.length);\n      for (i = 0, l = keys.length; i < l; i++) {\n        key = keys[i];\n        ret[i] = render(val[key], key, i);\n      }\n    }\n    return ret\n  };\n\n  // renderSlot\n  Vue.prototype._t = function (\n    name,\n    fallback,\n    props,\n    bindObject\n  ) {\n    var scopedSlotFn = this.$scopedSlots[name];\n    if (scopedSlotFn) { // scoped slot\n      props = props || {};\n      if (bindObject) {\n        extend(props, bindObject);\n      }\n      return scopedSlotFn(props) || fallback\n    } else {\n      var slotNodes = this.$slots[name];\n      // warn duplicate slot usage\n      if (slotNodes && \"production\" !== 'production') {\n        slotNodes._rendered && warn(\n          \"Duplicate presence of slot \\\"\" + name + \"\\\" found in the same render tree \" +\n          \"- this will likely cause render errors.\",\n          this\n        );\n        slotNodes._rendered = true;\n      }\n      return slotNodes || fallback\n    }\n  };\n\n  // apply v-bind object\n  Vue.prototype._b = function bindProps (\n    data,\n    tag,\n    value,\n    asProp\n  ) {\n    if (value) {\n      if (!isObject(value)) {\n        \"production\" !== 'production' && warn(\n          'v-bind without argument expects an Object or Array value',\n          this\n        );\n      } else {\n        if (Array.isArray(value)) {\n          value = toObject(value);\n        }\n        for (var key in value) {\n          if (key === 'class' || key === 'style') {\n            data[key] = value[key];\n          } else {\n            var type = data.attrs && data.attrs.type;\n            var hash = asProp || config.mustUseProp(tag, type, key)\n              ? data.domProps || (data.domProps = {})\n              : data.attrs || (data.attrs = {});\n            hash[key] = value[key];\n          }\n        }\n      }\n    }\n    return data\n  };\n\n  // check v-on keyCodes\n  Vue.prototype._k = function checkKeyCodes (\n    eventKeyCode,\n    key,\n    builtInAlias\n  ) {\n    var keyCodes = config.keyCodes[key] || builtInAlias;\n    if (Array.isArray(keyCodes)) {\n      return keyCodes.indexOf(eventKeyCode) === -1\n    } else {\n      return keyCodes !== eventKeyCode\n    }\n  };\n}\n\nfunction resolveSlots (\n  children,\n  context\n) {\n  var slots = {};\n  if (!children) {\n    return slots\n  }\n  var defaultSlot = [];\n  var name, child;\n  for (var i = 0, l = children.length; i < l; i++) {\n    child = children[i];\n    // named slots should only be respected if the vnode was rendered in the\n    // same context.\n    if ((child.context === context || child.functionalContext === context) &&\n        child.data && (name = child.data.slot)) {\n      var slot = (slots[name] || (slots[name] = []));\n      if (child.tag === 'template') {\n        slot.push.apply(slot, child.children);\n      } else {\n        slot.push(child);\n      }\n    } else {\n      defaultSlot.push(child);\n    }\n  }\n  // ignore single whitespace\n  if (defaultSlot.length && !(\n    defaultSlot.length === 1 &&\n    (defaultSlot[0].text === ' ' || defaultSlot[0].isComment)\n  )) {\n    slots.default = defaultSlot;\n  }\n  return slots\n}\n\n/*  */\n\nfunction initEvents (vm) {\n  vm._events = Object.create(null);\n  vm._hasHookEvent = false;\n  // init parent attached events\n  var listeners = vm.$options._parentListeners;\n  if (listeners) {\n    updateComponentListeners(vm, listeners);\n  }\n}\n\nvar target;\n\nfunction add$1 (event, fn, once) {\n  if (once) {\n    target.$once(event, fn);\n  } else {\n    target.$on(event, fn);\n  }\n}\n\nfunction remove$2 (event, fn) {\n  target.$off(event, fn);\n}\n\nfunction updateComponentListeners (\n  vm,\n  listeners,\n  oldListeners\n) {\n  target = vm;\n  updateListeners(listeners, oldListeners || {}, add$1, remove$2, vm);\n}\n\nfunction eventsMixin (Vue) {\n  var hookRE = /^hook:/;\n  Vue.prototype.$on = function (event, fn) {\n    var vm = this;(vm._events[event] || (vm._events[event] = [])).push(fn);\n    // optimize hook:event cost by using a boolean flag marked at registration\n    // instead of a hash lookup\n    if (hookRE.test(event)) {\n      vm._hasHookEvent = true;\n    }\n    return vm\n  };\n\n  Vue.prototype.$once = function (event, fn) {\n    var vm = this;\n    function on () {\n      vm.$off(event, on);\n      fn.apply(vm, arguments);\n    }\n    on.fn = fn;\n    vm.$on(event, on);\n    return vm\n  };\n\n  Vue.prototype.$off = function (event, fn) {\n    var vm = this;\n    // all\n    if (!arguments.length) {\n      vm._events = Object.create(null);\n      return vm\n    }\n    // specific event\n    var cbs = vm._events[event];\n    if (!cbs) {\n      return vm\n    }\n    if (arguments.length === 1) {\n      vm._events[event] = null;\n      return vm\n    }\n    // specific handler\n    var cb;\n    var i = cbs.length;\n    while (i--) {\n      cb = cbs[i];\n      if (cb === fn || cb.fn === fn) {\n        cbs.splice(i, 1);\n        break\n      }\n    }\n    return vm\n  };\n\n  Vue.prototype.$emit = function (event) {\n    var vm = this;\n    var cbs = vm._events[event];\n    if (cbs) {\n      cbs = cbs.length > 1 ? toArray(cbs) : cbs;\n      var args = toArray(arguments, 1);\n      for (var i = 0, l = cbs.length; i < l; i++) {\n        cbs[i].apply(vm, args);\n      }\n    }\n    return vm\n  };\n}\n\n/*  */\n\nvar activeInstance = null;\n\nfunction initLifecycle (vm) {\n  var options = vm.$options;\n\n  // locate first non-abstract parent\n  var parent = options.parent;\n  if (parent && !options.abstract) {\n    while (parent.$options.abstract && parent.$parent) {\n      parent = parent.$parent;\n    }\n    parent.$children.push(vm);\n  }\n\n  vm.$parent = parent;\n  vm.$root = parent ? parent.$root : vm;\n\n  vm.$children = [];\n  vm.$refs = {};\n\n  vm._watcher = null;\n  vm._inactive = false;\n  vm._isMounted = false;\n  vm._isDestroyed = false;\n  vm._isBeingDestroyed = false;\n}\n\nfunction lifecycleMixin (Vue) {\n  Vue.prototype._mount = function (\n    el,\n    hydrating\n  ) {\n    var vm = this;\n    vm.$el = el;\n    if (!vm.$options.render) {\n      vm.$options.render = createEmptyVNode;\n      if (false) {\n        /* istanbul ignore if */\n        if (vm.$options.template && vm.$options.template.charAt(0) !== '#') {\n          warn(\n            'You are using the runtime-only build of Vue where the template ' +\n            'option is not available. Either pre-compile the templates into ' +\n            'render functions, or use the compiler-included build.',\n            vm\n          );\n        } else {\n          warn(\n            'Failed to mount component: template or render function not defined.',\n            vm\n          );\n        }\n      }\n    }\n    callHook(vm, 'beforeMount');\n    vm._watcher = new Watcher(vm, function updateComponent () {\n      vm._update(vm._render(), hydrating);\n    }, noop);\n    hydrating = false;\n    // manually mounted instance, call mounted on self\n    // mounted is called for render-created child components in its inserted hook\n    if (vm.$vnode == null) {\n      vm._isMounted = true;\n      callHook(vm, 'mounted');\n    }\n    return vm\n  };\n\n  Vue.prototype._update = function (vnode, hydrating) {\n    var vm = this;\n    if (vm._isMounted) {\n      callHook(vm, 'beforeUpdate');\n    }\n    var prevEl = vm.$el;\n    var prevVnode = vm._vnode;\n    var prevActiveInstance = activeInstance;\n    activeInstance = vm;\n    vm._vnode = vnode;\n    // Vue.prototype.__patch__ is injected in entry points\n    // based on the rendering backend used.\n    if (!prevVnode) {\n      // initial render\n      vm.$el = vm.__patch__(\n        vm.$el, vnode, hydrating, false /* removeOnly */,\n        vm.$options._parentElm,\n        vm.$options._refElm\n      );\n    } else {\n      // updates\n      vm.$el = vm.__patch__(prevVnode, vnode);\n    }\n    activeInstance = prevActiveInstance;\n    // update __vue__ reference\n    if (prevEl) {\n      prevEl.__vue__ = null;\n    }\n    if (vm.$el) {\n      vm.$el.__vue__ = vm;\n    }\n    // if parent is an HOC, update its $el as well\n    if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {\n      vm.$parent.$el = vm.$el;\n    }\n    // updated hook is called by the scheduler to ensure that children are\n    // updated in a parent's updated hook.\n  };\n\n  Vue.prototype._updateFromParent = function (\n    propsData,\n    listeners,\n    parentVnode,\n    renderChildren\n  ) {\n    var vm = this;\n    var hasChildren = !!(vm.$options._renderChildren || renderChildren);\n    vm.$options._parentVnode = parentVnode;\n    vm.$vnode = parentVnode; // update vm's placeholder node without re-render\n    if (vm._vnode) { // update child tree's parent\n      vm._vnode.parent = parentVnode;\n    }\n    vm.$options._renderChildren = renderChildren;\n    // update props\n    if (propsData && vm.$options.props) {\n      observerState.shouldConvert = false;\n      if (false) {\n        observerState.isSettingProps = true;\n      }\n      var propKeys = vm.$options._propKeys || [];\n      for (var i = 0; i < propKeys.length; i++) {\n        var key = propKeys[i];\n        vm[key] = validateProp(key, vm.$options.props, propsData, vm);\n      }\n      observerState.shouldConvert = true;\n      if (false) {\n        observerState.isSettingProps = false;\n      }\n      vm.$options.propsData = propsData;\n    }\n    // update listeners\n    if (listeners) {\n      var oldListeners = vm.$options._parentListeners;\n      vm.$options._parentListeners = listeners;\n      updateComponentListeners(vm, listeners, oldListeners);\n    }\n    // resolve slots + force update if has children\n    if (hasChildren) {\n      vm.$slots = resolveSlots(renderChildren, parentVnode.context);\n      vm.$forceUpdate();\n    }\n  };\n\n  Vue.prototype.$forceUpdate = function () {\n    var vm = this;\n    if (vm._watcher) {\n      vm._watcher.update();\n    }\n  };\n\n  Vue.prototype.$destroy = function () {\n    var vm = this;\n    if (vm._isBeingDestroyed) {\n      return\n    }\n    callHook(vm, 'beforeDestroy');\n    vm._isBeingDestroyed = true;\n    // remove self from parent\n    var parent = vm.$parent;\n    if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {\n      remove$1(parent.$children, vm);\n    }\n    // teardown watchers\n    if (vm._watcher) {\n      vm._watcher.teardown();\n    }\n    var i = vm._watchers.length;\n    while (i--) {\n      vm._watchers[i].teardown();\n    }\n    // remove reference from data ob\n    // frozen object may not have observer.\n    if (vm._data.__ob__) {\n      vm._data.__ob__.vmCount--;\n    }\n    // call the last hook...\n    vm._isDestroyed = true;\n    callHook(vm, 'destroyed');\n    // turn off all instance listeners.\n    vm.$off();\n    // remove __vue__ reference\n    if (vm.$el) {\n      vm.$el.__vue__ = null;\n    }\n    // invoke destroy hooks on current rendered tree\n    vm.__patch__(vm._vnode, null);\n  };\n}\n\nfunction callHook (vm, hook) {\n  var handlers = vm.$options[hook];\n  if (handlers) {\n    for (var i = 0, j = handlers.length; i < j; i++) {\n      handlers[i].call(vm);\n    }\n  }\n  if (vm._hasHookEvent) {\n    vm.$emit('hook:' + hook);\n  }\n}\n\n/*  */\n\n\nvar queue = [];\nvar has$1 = {};\nvar circular = {};\nvar waiting = false;\nvar flushing = false;\nvar index = 0;\n\n/**\n * Reset the scheduler's state.\n */\nfunction resetSchedulerState () {\n  queue.length = 0;\n  has$1 = {};\n  if (false) {\n    circular = {};\n  }\n  waiting = flushing = false;\n}\n\n/**\n * Flush both queues and run the watchers.\n */\nfunction flushSchedulerQueue () {\n  flushing = true;\n  var watcher, id, vm;\n\n  // Sort queue before flush.\n  // This ensures that:\n  // 1. Components are updated from parent to child. (because parent is always\n  //    created before the child)\n  // 2. A component's user watchers are run before its render watcher (because\n  //    user watchers are created before the render watcher)\n  // 3. If a component is destroyed during a parent component's watcher run,\n  //    its watchers can be skipped.\n  queue.sort(function (a, b) { return a.id - b.id; });\n\n  // do not cache length because more watchers might be pushed\n  // as we run existing watchers\n  for (index = 0; index < queue.length; index++) {\n    watcher = queue[index];\n    id = watcher.id;\n    has$1[id] = null;\n    watcher.run();\n    // in dev build, check and stop circular updates.\n    if (false) {\n      circular[id] = (circular[id] || 0) + 1;\n      if (circular[id] > config._maxUpdateCount) {\n        warn(\n          'You may have an infinite update loop ' + (\n            watcher.user\n              ? (\"in watcher with expression \\\"\" + (watcher.expression) + \"\\\"\")\n              : \"in a component render function.\"\n          ),\n          watcher.vm\n        );\n        break\n      }\n    }\n  }\n\n  // call updated hooks\n  index = queue.length;\n  while (index--) {\n    watcher = queue[index];\n    vm = watcher.vm;\n    if (vm._watcher === watcher && vm._isMounted) {\n      callHook(vm, 'updated');\n    }\n  }\n\n  // devtool hook\n  /* istanbul ignore if */\n  if (devtools && config.devtools) {\n    devtools.emit('flush');\n  }\n\n  resetSchedulerState();\n}\n\n/**\n * Push a watcher into the watcher queue.\n * Jobs with duplicate IDs will be skipped unless it's\n * pushed when the queue is being flushed.\n */\nfunction queueWatcher (watcher) {\n  var id = watcher.id;\n  if (has$1[id] == null) {\n    has$1[id] = true;\n    if (!flushing) {\n      queue.push(watcher);\n    } else {\n      // if already flushing, splice the watcher based on its id\n      // if already past its id, it will be run next immediately.\n      var i = queue.length - 1;\n      while (i >= 0 && queue[i].id > watcher.id) {\n        i--;\n      }\n      queue.splice(Math.max(i, index) + 1, 0, watcher);\n    }\n    // queue the flush\n    if (!waiting) {\n      waiting = true;\n      nextTick(flushSchedulerQueue);\n    }\n  }\n}\n\n/*  */\n\nvar uid$2 = 0;\n\n/**\n * A watcher parses an expression, collects dependencies,\n * and fires callback when the expression value changes.\n * This is used for both the $watch() api and directives.\n */\nvar Watcher = function Watcher (\n  vm,\n  expOrFn,\n  cb,\n  options\n) {\n  this.vm = vm;\n  vm._watchers.push(this);\n  // options\n  if (options) {\n    this.deep = !!options.deep;\n    this.user = !!options.user;\n    this.lazy = !!options.lazy;\n    this.sync = !!options.sync;\n  } else {\n    this.deep = this.user = this.lazy = this.sync = false;\n  }\n  this.cb = cb;\n  this.id = ++uid$2; // uid for batching\n  this.active = true;\n  this.dirty = this.lazy; // for lazy watchers\n  this.deps = [];\n  this.newDeps = [];\n  this.depIds = new _Set();\n  this.newDepIds = new _Set();\n  this.expression =  false\n    ? expOrFn.toString()\n    : '';\n  // parse expression for getter\n  if (typeof expOrFn === 'function') {\n    this.getter = expOrFn;\n  } else {\n    this.getter = parsePath(expOrFn);\n    if (!this.getter) {\n      this.getter = function () {};\n      \"production\" !== 'production' && warn(\n        \"Failed watching path: \\\"\" + expOrFn + \"\\\" \" +\n        'Watcher only accepts simple dot-delimited paths. ' +\n        'For full control, use a function instead.',\n        vm\n      );\n    }\n  }\n  this.value = this.lazy\n    ? undefined\n    : this.get();\n};\n\n/**\n * Evaluate the getter, and re-collect dependencies.\n */\nWatcher.prototype.get = function get () {\n  pushTarget(this);\n  var value = this.getter.call(this.vm, this.vm);\n  // \"touch\" every property so they are all tracked as\n  // dependencies for deep watching\n  if (this.deep) {\n    traverse(value);\n  }\n  popTarget();\n  this.cleanupDeps();\n  return value\n};\n\n/**\n * Add a dependency to this directive.\n */\nWatcher.prototype.addDep = function addDep (dep) {\n  var id = dep.id;\n  if (!this.newDepIds.has(id)) {\n    this.newDepIds.add(id);\n    this.newDeps.push(dep);\n    if (!this.depIds.has(id)) {\n      dep.addSub(this);\n    }\n  }\n};\n\n/**\n * Clean up for dependency collection.\n */\nWatcher.prototype.cleanupDeps = function cleanupDeps () {\n    var this$1 = this;\n\n  var i = this.deps.length;\n  while (i--) {\n    var dep = this$1.deps[i];\n    if (!this$1.newDepIds.has(dep.id)) {\n      dep.removeSub(this$1);\n    }\n  }\n  var tmp = this.depIds;\n  this.depIds = this.newDepIds;\n  this.newDepIds = tmp;\n  this.newDepIds.clear();\n  tmp = this.deps;\n  this.deps = this.newDeps;\n  this.newDeps = tmp;\n  this.newDeps.length = 0;\n};\n\n/**\n * Subscriber interface.\n * Will be called when a dependency changes.\n */\nWatcher.prototype.update = function update () {\n  /* istanbul ignore else */\n  if (this.lazy) {\n    this.dirty = true;\n  } else if (this.sync) {\n    this.run();\n  } else {\n    queueWatcher(this);\n  }\n};\n\n/**\n * Scheduler job interface.\n * Will be called by the scheduler.\n */\nWatcher.prototype.run = function run () {\n  if (this.active) {\n    var value = this.get();\n    if (\n      value !== this.value ||\n      // Deep watchers and watchers on Object/Arrays should fire even\n      // when the value is the same, because the value may\n      // have mutated.\n      isObject(value) ||\n      this.deep\n    ) {\n      // set new value\n      var oldValue = this.value;\n      this.value = value;\n      if (this.user) {\n        try {\n          this.cb.call(this.vm, value, oldValue);\n        } catch (e) {\n          /* istanbul ignore else */\n          if (config.errorHandler) {\n            config.errorHandler.call(null, e, this.vm);\n          } else {\n            \"production\" !== 'production' && warn(\n              (\"Error in watcher \\\"\" + (this.expression) + \"\\\"\"),\n              this.vm\n            );\n            throw e\n          }\n        }\n      } else {\n        this.cb.call(this.vm, value, oldValue);\n      }\n    }\n  }\n};\n\n/**\n * Evaluate the value of the watcher.\n * This only gets called for lazy watchers.\n */\nWatcher.prototype.evaluate = function evaluate () {\n  this.value = this.get();\n  this.dirty = false;\n};\n\n/**\n * Depend on all deps collected by this watcher.\n */\nWatcher.prototype.depend = function depend () {\n    var this$1 = this;\n\n  var i = this.deps.length;\n  while (i--) {\n    this$1.deps[i].depend();\n  }\n};\n\n/**\n * Remove self from all dependencies' subscriber list.\n */\nWatcher.prototype.teardown = function teardown () {\n    var this$1 = this;\n\n  if (this.active) {\n    // remove self from vm's watcher list\n    // this is a somewhat expensive operation so we skip it\n    // if the vm is being destroyed.\n    if (!this.vm._isBeingDestroyed) {\n      remove$1(this.vm._watchers, this);\n    }\n    var i = this.deps.length;\n    while (i--) {\n      this$1.deps[i].removeSub(this$1);\n    }\n    this.active = false;\n  }\n};\n\n/**\n * Recursively traverse an object to evoke all converted\n * getters, so that every nested property inside the object\n * is collected as a \"deep\" dependency.\n */\nvar seenObjects = new _Set();\nfunction traverse (val) {\n  seenObjects.clear();\n  _traverse(val, seenObjects);\n}\n\nfunction _traverse (val, seen) {\n  var i, keys;\n  var isA = Array.isArray(val);\n  if ((!isA && !isObject(val)) || !Object.isExtensible(val)) {\n    return\n  }\n  if (val.__ob__) {\n    var depId = val.__ob__.dep.id;\n    if (seen.has(depId)) {\n      return\n    }\n    seen.add(depId);\n  }\n  if (isA) {\n    i = val.length;\n    while (i--) { _traverse(val[i], seen); }\n  } else {\n    keys = Object.keys(val);\n    i = keys.length;\n    while (i--) { _traverse(val[keys[i]], seen); }\n  }\n}\n\n/*  */\n\nfunction initState (vm) {\n  vm._watchers = [];\n  var opts = vm.$options;\n  if (opts.props) { initProps(vm, opts.props); }\n  if (opts.methods) { initMethods(vm, opts.methods); }\n  if (opts.data) {\n    initData(vm);\n  } else {\n    observe(vm._data = {}, true /* asRootData */);\n  }\n  if (opts.computed) { initComputed(vm, opts.computed); }\n  if (opts.watch) { initWatch(vm, opts.watch); }\n}\n\nvar isReservedProp = { key: 1, ref: 1, slot: 1 };\n\nfunction initProps (vm, props) {\n  var propsData = vm.$options.propsData || {};\n  var keys = vm.$options._propKeys = Object.keys(props);\n  var isRoot = !vm.$parent;\n  // root instance props should be converted\n  observerState.shouldConvert = isRoot;\n  var loop = function ( i ) {\n    var key = keys[i];\n    /* istanbul ignore else */\n    if (false) {\n      if (isReservedProp[key]) {\n        warn(\n          (\"\\\"\" + key + \"\\\" is a reserved attribute and cannot be used as component prop.\"),\n          vm\n        );\n      }\n      defineReactive$$1(vm, key, validateProp(key, props, propsData, vm), function () {\n        if (vm.$parent && !observerState.isSettingProps) {\n          warn(\n            \"Avoid mutating a prop directly since the value will be \" +\n            \"overwritten whenever the parent component re-renders. \" +\n            \"Instead, use a data or computed property based on the prop's \" +\n            \"value. Prop being mutated: \\\"\" + key + \"\\\"\",\n            vm\n          );\n        }\n      });\n    } else {\n      defineReactive$$1(vm, key, validateProp(key, props, propsData, vm));\n    }\n  };\n\n  for (var i = 0; i < keys.length; i++) loop( i );\n  observerState.shouldConvert = true;\n}\n\nfunction initData (vm) {\n  var data = vm.$options.data;\n  data = vm._data = typeof data === 'function'\n    ? data.call(vm)\n    : data || {};\n  if (!isPlainObject(data)) {\n    data = {};\n    \"production\" !== 'production' && warn(\n      'data functions should return an object:\\n' +\n      'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',\n      vm\n    );\n  }\n  // proxy data on instance\n  var keys = Object.keys(data);\n  var props = vm.$options.props;\n  var i = keys.length;\n  while (i--) {\n    if (props && hasOwn(props, keys[i])) {\n      \"production\" !== 'production' && warn(\n        \"The data property \\\"\" + (keys[i]) + \"\\\" is already declared as a prop. \" +\n        \"Use prop default value instead.\",\n        vm\n      );\n    } else {\n      proxy(vm, keys[i]);\n    }\n  }\n  // observe data\n  observe(data, true /* asRootData */);\n}\n\nvar computedSharedDefinition = {\n  enumerable: true,\n  configurable: true,\n  get: noop,\n  set: noop\n};\n\nfunction initComputed (vm, computed) {\n  for (var key in computed) {\n    /* istanbul ignore if */\n    if (false) {\n      warn(\n        \"existing instance property \\\"\" + key + \"\\\" will be \" +\n        \"overwritten by a computed property with the same name.\",\n        vm\n      );\n    }\n    var userDef = computed[key];\n    if (typeof userDef === 'function') {\n      computedSharedDefinition.get = makeComputedGetter(userDef, vm);\n      computedSharedDefinition.set = noop;\n    } else {\n      computedSharedDefinition.get = userDef.get\n        ? userDef.cache !== false\n          ? makeComputedGetter(userDef.get, vm)\n          : bind$1(userDef.get, vm)\n        : noop;\n      computedSharedDefinition.set = userDef.set\n        ? bind$1(userDef.set, vm)\n        : noop;\n    }\n    Object.defineProperty(vm, key, computedSharedDefinition);\n  }\n}\n\nfunction makeComputedGetter (getter, owner) {\n  var watcher = new Watcher(owner, getter, noop, {\n    lazy: true\n  });\n  return function computedGetter () {\n    if (watcher.dirty) {\n      watcher.evaluate();\n    }\n    if (Dep.target) {\n      watcher.depend();\n    }\n    return watcher.value\n  }\n}\n\nfunction initMethods (vm, methods) {\n  for (var key in methods) {\n    vm[key] = methods[key] == null ? noop : bind$1(methods[key], vm);\n    if (false) {\n      warn(\n        \"method \\\"\" + key + \"\\\" has an undefined value in the component definition. \" +\n        \"Did you reference the function correctly?\",\n        vm\n      );\n    }\n  }\n}\n\nfunction initWatch (vm, watch) {\n  for (var key in watch) {\n    var handler = watch[key];\n    if (Array.isArray(handler)) {\n      for (var i = 0; i < handler.length; i++) {\n        createWatcher(vm, key, handler[i]);\n      }\n    } else {\n      createWatcher(vm, key, handler);\n    }\n  }\n}\n\nfunction createWatcher (vm, key, handler) {\n  var options;\n  if (isPlainObject(handler)) {\n    options = handler;\n    handler = handler.handler;\n  }\n  if (typeof handler === 'string') {\n    handler = vm[handler];\n  }\n  vm.$watch(key, handler, options);\n}\n\nfunction stateMixin (Vue) {\n  // flow somehow has problems with directly declared definition object\n  // when using Object.defineProperty, so we have to procedurally build up\n  // the object here.\n  var dataDef = {};\n  dataDef.get = function () {\n    return this._data\n  };\n  if (false) {\n    dataDef.set = function (newData) {\n      warn(\n        'Avoid replacing instance root $data. ' +\n        'Use nested data properties instead.',\n        this\n      );\n    };\n  }\n  Object.defineProperty(Vue.prototype, '$data', dataDef);\n\n  Vue.prototype.$set = set$1;\n  Vue.prototype.$delete = del;\n\n  Vue.prototype.$watch = function (\n    expOrFn,\n    cb,\n    options\n  ) {\n    var vm = this;\n    options = options || {};\n    options.user = true;\n    var watcher = new Watcher(vm, expOrFn, cb, options);\n    if (options.immediate) {\n      cb.call(vm, watcher.value);\n    }\n    return function unwatchFn () {\n      watcher.teardown();\n    }\n  };\n}\n\nfunction proxy (vm, key) {\n  if (!isReserved(key)) {\n    Object.defineProperty(vm, key, {\n      configurable: true,\n      enumerable: true,\n      get: function proxyGetter () {\n        return vm._data[key]\n      },\n      set: function proxySetter (val) {\n        vm._data[key] = val;\n      }\n    });\n  }\n}\n\n/*  */\n\nvar uid = 0;\n\nfunction initMixin (Vue) {\n  Vue.prototype._init = function (options) {\n    var vm = this;\n    // a uid\n    vm._uid = uid++;\n    // a flag to avoid this being observed\n    vm._isVue = true;\n    // merge options\n    if (options && options._isComponent) {\n      // optimize internal component instantiation\n      // since dynamic options merging is pretty slow, and none of the\n      // internal component options needs special treatment.\n      initInternalComponent(vm, options);\n    } else {\n      vm.$options = mergeOptions(\n        resolveConstructorOptions(vm.constructor),\n        options || {},\n        vm\n      );\n    }\n    /* istanbul ignore else */\n    if (false) {\n      initProxy(vm);\n    } else {\n      vm._renderProxy = vm;\n    }\n    // expose real self\n    vm._self = vm;\n    initLifecycle(vm);\n    initEvents(vm);\n    initRender(vm);\n    callHook(vm, 'beforeCreate');\n    initState(vm);\n    callHook(vm, 'created');\n    if (vm.$options.el) {\n      vm.$mount(vm.$options.el);\n    }\n  };\n}\n\nfunction initInternalComponent (vm, options) {\n  var opts = vm.$options = Object.create(vm.constructor.options);\n  // doing this because it's faster than dynamic enumeration.\n  opts.parent = options.parent;\n  opts.propsData = options.propsData;\n  opts._parentVnode = options._parentVnode;\n  opts._parentListeners = options._parentListeners;\n  opts._renderChildren = options._renderChildren;\n  opts._componentTag = options._componentTag;\n  opts._parentElm = options._parentElm;\n  opts._refElm = options._refElm;\n  if (options.render) {\n    opts.render = options.render;\n    opts.staticRenderFns = options.staticRenderFns;\n  }\n}\n\nfunction resolveConstructorOptions (Ctor) {\n  var options = Ctor.options;\n  if (Ctor.super) {\n    var superOptions = Ctor.super.options;\n    var cachedSuperOptions = Ctor.superOptions;\n    var extendOptions = Ctor.extendOptions;\n    if (superOptions !== cachedSuperOptions) {\n      // super option changed\n      Ctor.superOptions = superOptions;\n      extendOptions.render = options.render;\n      extendOptions.staticRenderFns = options.staticRenderFns;\n      extendOptions._scopeId = options._scopeId;\n      options = Ctor.options = mergeOptions(superOptions, extendOptions);\n      if (options.name) {\n        options.components[options.name] = Ctor;\n      }\n    }\n  }\n  return options\n}\n\nfunction Vue$3 (options) {\n  if (false) {\n    warn('Vue is a constructor and should be called with the `new` keyword');\n  }\n  this._init(options);\n}\n\ninitMixin(Vue$3);\nstateMixin(Vue$3);\neventsMixin(Vue$3);\nlifecycleMixin(Vue$3);\nrenderMixin(Vue$3);\n\n/*  */\n\nfunction initUse (Vue) {\n  Vue.use = function (plugin) {\n    /* istanbul ignore if */\n    if (plugin.installed) {\n      return\n    }\n    // additional parameters\n    var args = toArray(arguments, 1);\n    args.unshift(this);\n    if (typeof plugin.install === 'function') {\n      plugin.install.apply(plugin, args);\n    } else {\n      plugin.apply(null, args);\n    }\n    plugin.installed = true;\n    return this\n  };\n}\n\n/*  */\n\nfunction initMixin$1 (Vue) {\n  Vue.mixin = function (mixin) {\n    this.options = mergeOptions(this.options, mixin);\n  };\n}\n\n/*  */\n\nfunction initExtend (Vue) {\n  /**\n   * Each instance constructor, including Vue, has a unique\n   * cid. This enables us to create wrapped \"child\n   * constructors\" for prototypal inheritance and cache them.\n   */\n  Vue.cid = 0;\n  var cid = 1;\n\n  /**\n   * Class inheritance\n   */\n  Vue.extend = function (extendOptions) {\n    extendOptions = extendOptions || {};\n    var Super = this;\n    var SuperId = Super.cid;\n    var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});\n    if (cachedCtors[SuperId]) {\n      return cachedCtors[SuperId]\n    }\n    var name = extendOptions.name || Super.options.name;\n    if (false) {\n      if (!/^[a-zA-Z][\\w-]*$/.test(name)) {\n        warn(\n          'Invalid component name: \"' + name + '\". Component names ' +\n          'can only contain alphanumeric characters and the hyphen, ' +\n          'and must start with a letter.'\n        );\n      }\n    }\n    var Sub = function VueComponent (options) {\n      this._init(options);\n    };\n    Sub.prototype = Object.create(Super.prototype);\n    Sub.prototype.constructor = Sub;\n    Sub.cid = cid++;\n    Sub.options = mergeOptions(\n      Super.options,\n      extendOptions\n    );\n    Sub['super'] = Super;\n    // allow further extension/mixin/plugin usage\n    Sub.extend = Super.extend;\n    Sub.mixin = Super.mixin;\n    Sub.use = Super.use;\n    // create asset registers, so extended classes\n    // can have their private assets too.\n    config._assetTypes.forEach(function (type) {\n      Sub[type] = Super[type];\n    });\n    // enable recursive self-lookup\n    if (name) {\n      Sub.options.components[name] = Sub;\n    }\n    // keep a reference to the super options at extension time.\n    // later at instantiation we can check if Super's options have\n    // been updated.\n    Sub.superOptions = Super.options;\n    Sub.extendOptions = extendOptions;\n    // cache constructor\n    cachedCtors[SuperId] = Sub;\n    return Sub\n  };\n}\n\n/*  */\n\nfunction initAssetRegisters (Vue) {\n  /**\n   * Create asset registration methods.\n   */\n  config._assetTypes.forEach(function (type) {\n    Vue[type] = function (\n      id,\n      definition\n    ) {\n      if (!definition) {\n        return this.options[type + 's'][id]\n      } else {\n        /* istanbul ignore if */\n        if (false) {\n          if (type === 'component' && config.isReservedTag(id)) {\n            warn(\n              'Do not use built-in or reserved HTML elements as component ' +\n              'id: ' + id\n            );\n          }\n        }\n        if (type === 'component' && isPlainObject(definition)) {\n          definition.name = definition.name || id;\n          definition = this.options._base.extend(definition);\n        }\n        if (type === 'directive' && typeof definition === 'function') {\n          definition = { bind: definition, update: definition };\n        }\n        this.options[type + 's'][id] = definition;\n        return definition\n      }\n    };\n  });\n}\n\n/*  */\n\nvar patternTypes = [String, RegExp];\n\nfunction getComponentName (opts) {\n  return opts && (opts.Ctor.options.name || opts.tag)\n}\n\nfunction matches (pattern, name) {\n  if (typeof pattern === 'string') {\n    return pattern.split(',').indexOf(name) > -1\n  } else {\n    return pattern.test(name)\n  }\n}\n\nfunction pruneCache (cache, filter) {\n  for (var key in cache) {\n    var cachedNode = cache[key];\n    if (cachedNode) {\n      var name = getComponentName(cachedNode.componentOptions);\n      if (name && !filter(name)) {\n        pruneCacheEntry(cachedNode);\n        cache[key] = null;\n      }\n    }\n  }\n}\n\nfunction pruneCacheEntry (vnode) {\n  if (vnode) {\n    if (!vnode.componentInstance._inactive) {\n      callHook(vnode.componentInstance, 'deactivated');\n    }\n    vnode.componentInstance.$destroy();\n  }\n}\n\nvar KeepAlive = {\n  name: 'keep-alive',\n  abstract: true,\n\n  props: {\n    include: patternTypes,\n    exclude: patternTypes\n  },\n\n  created: function created () {\n    this.cache = Object.create(null);\n  },\n\n  destroyed: function destroyed () {\n    var this$1 = this;\n\n    for (var key in this.cache) {\n      pruneCacheEntry(this$1.cache[key]);\n    }\n  },\n\n  watch: {\n    include: function include (val) {\n      pruneCache(this.cache, function (name) { return matches(val, name); });\n    },\n    exclude: function exclude (val) {\n      pruneCache(this.cache, function (name) { return !matches(val, name); });\n    }\n  },\n\n  render: function render () {\n    var vnode = getFirstComponentChild(this.$slots.default);\n    var componentOptions = vnode && vnode.componentOptions;\n    if (componentOptions) {\n      // check pattern\n      var name = getComponentName(componentOptions);\n      if (name && (\n        (this.include && !matches(this.include, name)) ||\n        (this.exclude && matches(this.exclude, name))\n      )) {\n        return vnode\n      }\n      var key = vnode.key == null\n        // same constructor may get registered as different local components\n        // so cid alone is not enough (#3269)\n        ? componentOptions.Ctor.cid + (componentOptions.tag ? (\"::\" + (componentOptions.tag)) : '')\n        : vnode.key;\n      if (this.cache[key]) {\n        vnode.componentInstance = this.cache[key].componentInstance;\n      } else {\n        this.cache[key] = vnode;\n      }\n      vnode.data.keepAlive = true;\n    }\n    return vnode\n  }\n};\n\nvar builtInComponents = {\n  KeepAlive: KeepAlive\n};\n\n/*  */\n\nfunction initGlobalAPI (Vue) {\n  // config\n  var configDef = {};\n  configDef.get = function () { return config; };\n  if (false) {\n    configDef.set = function () {\n      warn(\n        'Do not replace the Vue.config object, set individual fields instead.'\n      );\n    };\n  }\n  Object.defineProperty(Vue, 'config', configDef);\n  Vue.util = util;\n  Vue.set = set$1;\n  Vue.delete = del;\n  Vue.nextTick = nextTick;\n\n  Vue.options = Object.create(null);\n  config._assetTypes.forEach(function (type) {\n    Vue.options[type + 's'] = Object.create(null);\n  });\n\n  // this is used to identify the \"base\" constructor to extend all plain-object\n  // components with in Weex's multi-instance scenarios.\n  Vue.options._base = Vue;\n\n  extend(Vue.options.components, builtInComponents);\n\n  initUse(Vue);\n  initMixin$1(Vue);\n  initExtend(Vue);\n  initAssetRegisters(Vue);\n}\n\ninitGlobalAPI(Vue$3);\n\nObject.defineProperty(Vue$3.prototype, '$isServer', {\n  get: isServerRendering\n});\n\nVue$3.version = '2.1.10';\n\n/*  */\n\n// attributes that should be using props for binding\nvar acceptValue = makeMap('input,textarea,option,select');\nvar mustUseProp = function (tag, type, attr) {\n  return (\n    (attr === 'value' && acceptValue(tag)) && type !== 'button' ||\n    (attr === 'selected' && tag === 'option') ||\n    (attr === 'checked' && tag === 'input') ||\n    (attr === 'muted' && tag === 'video')\n  )\n};\n\nvar isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');\n\nvar isBooleanAttr = makeMap(\n  'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +\n  'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +\n  'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +\n  'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +\n  'required,reversed,scoped,seamless,selected,sortable,translate,' +\n  'truespeed,typemustmatch,visible'\n);\n\nvar xlinkNS = 'http://www.w3.org/1999/xlink';\n\nvar isXlink = function (name) {\n  return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'\n};\n\nvar getXlinkProp = function (name) {\n  return isXlink(name) ? name.slice(6, name.length) : ''\n};\n\nvar isFalsyAttrValue = function (val) {\n  return val == null || val === false\n};\n\n/*  */\n\nfunction genClassForVnode (vnode) {\n  var data = vnode.data;\n  var parentNode = vnode;\n  var childNode = vnode;\n  while (childNode.componentInstance) {\n    childNode = childNode.componentInstance._vnode;\n    if (childNode.data) {\n      data = mergeClassData(childNode.data, data);\n    }\n  }\n  while ((parentNode = parentNode.parent)) {\n    if (parentNode.data) {\n      data = mergeClassData(data, parentNode.data);\n    }\n  }\n  return genClassFromData(data)\n}\n\nfunction mergeClassData (child, parent) {\n  return {\n    staticClass: concat(child.staticClass, parent.staticClass),\n    class: child.class\n      ? [child.class, parent.class]\n      : parent.class\n  }\n}\n\nfunction genClassFromData (data) {\n  var dynamicClass = data.class;\n  var staticClass = data.staticClass;\n  if (staticClass || dynamicClass) {\n    return concat(staticClass, stringifyClass(dynamicClass))\n  }\n  /* istanbul ignore next */\n  return ''\n}\n\nfunction concat (a, b) {\n  return a ? b ? (a + ' ' + b) : a : (b || '')\n}\n\nfunction stringifyClass (value) {\n  var res = '';\n  if (!value) {\n    return res\n  }\n  if (typeof value === 'string') {\n    return value\n  }\n  if (Array.isArray(value)) {\n    var stringified;\n    for (var i = 0, l = value.length; i < l; i++) {\n      if (value[i]) {\n        if ((stringified = stringifyClass(value[i]))) {\n          res += stringified + ' ';\n        }\n      }\n    }\n    return res.slice(0, -1)\n  }\n  if (isObject(value)) {\n    for (var key in value) {\n      if (value[key]) { res += key + ' '; }\n    }\n    return res.slice(0, -1)\n  }\n  /* istanbul ignore next */\n  return res\n}\n\n/*  */\n\nvar namespaceMap = {\n  svg: 'http://www.w3.org/2000/svg',\n  math: 'http://www.w3.org/1998/Math/MathML'\n};\n\nvar isHTMLTag = makeMap(\n  'html,body,base,head,link,meta,style,title,' +\n  'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +\n  'div,dd,dl,dt,figcaption,figure,hr,img,li,main,ol,p,pre,ul,' +\n  'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +\n  's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +\n  'embed,object,param,source,canvas,script,noscript,del,ins,' +\n  'caption,col,colgroup,table,thead,tbody,td,th,tr,' +\n  'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +\n  'output,progress,select,textarea,' +\n  'details,dialog,menu,menuitem,summary,' +\n  'content,element,shadow,template'\n);\n\n// this map is intentionally selective, only covering SVG elements that may\n// contain child elements.\nvar isSVG = makeMap(\n  'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,' +\n  'font-face,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +\n  'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',\n  true\n);\n\nvar isPreTag = function (tag) { return tag === 'pre'; };\n\nvar isReservedTag = function (tag) {\n  return isHTMLTag(tag) || isSVG(tag)\n};\n\nfunction getTagNamespace (tag) {\n  if (isSVG(tag)) {\n    return 'svg'\n  }\n  // basic support for MathML\n  // note it doesn't support other MathML elements being component roots\n  if (tag === 'math') {\n    return 'math'\n  }\n}\n\nvar unknownElementCache = Object.create(null);\nfunction isUnknownElement (tag) {\n  /* istanbul ignore if */\n  if (!inBrowser) {\n    return true\n  }\n  if (isReservedTag(tag)) {\n    return false\n  }\n  tag = tag.toLowerCase();\n  /* istanbul ignore if */\n  if (unknownElementCache[tag] != null) {\n    return unknownElementCache[tag]\n  }\n  var el = document.createElement(tag);\n  if (tag.indexOf('-') > -1) {\n    // http://stackoverflow.com/a/28210364/1070244\n    return (unknownElementCache[tag] = (\n      el.constructor === window.HTMLUnknownElement ||\n      el.constructor === window.HTMLElement\n    ))\n  } else {\n    return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))\n  }\n}\n\n/*  */\n\n/**\n * Query an element selector if it's not an element already.\n */\nfunction query (el) {\n  if (typeof el === 'string') {\n    var selector = el;\n    el = document.querySelector(el);\n    if (!el) {\n      \"production\" !== 'production' && warn(\n        'Cannot find element: ' + selector\n      );\n      return document.createElement('div')\n    }\n  }\n  return el\n}\n\n/*  */\n\nfunction createElement$1 (tagName, vnode) {\n  var elm = document.createElement(tagName);\n  if (tagName !== 'select') {\n    return elm\n  }\n  if (vnode.data && vnode.data.attrs && 'multiple' in vnode.data.attrs) {\n    elm.setAttribute('multiple', 'multiple');\n  }\n  return elm\n}\n\nfunction createElementNS (namespace, tagName) {\n  return document.createElementNS(namespaceMap[namespace], tagName)\n}\n\nfunction createTextNode (text) {\n  return document.createTextNode(text)\n}\n\nfunction createComment (text) {\n  return document.createComment(text)\n}\n\nfunction insertBefore (parentNode, newNode, referenceNode) {\n  parentNode.insertBefore(newNode, referenceNode);\n}\n\nfunction removeChild (node, child) {\n  node.removeChild(child);\n}\n\nfunction appendChild (node, child) {\n  node.appendChild(child);\n}\n\nfunction parentNode (node) {\n  return node.parentNode\n}\n\nfunction nextSibling (node) {\n  return node.nextSibling\n}\n\nfunction tagName (node) {\n  return node.tagName\n}\n\nfunction setTextContent (node, text) {\n  node.textContent = text;\n}\n\nfunction setAttribute (node, key, val) {\n  node.setAttribute(key, val);\n}\n\n\nvar nodeOps = Object.freeze({\n\tcreateElement: createElement$1,\n\tcreateElementNS: createElementNS,\n\tcreateTextNode: createTextNode,\n\tcreateComment: createComment,\n\tinsertBefore: insertBefore,\n\tremoveChild: removeChild,\n\tappendChild: appendChild,\n\tparentNode: parentNode,\n\tnextSibling: nextSibling,\n\ttagName: tagName,\n\tsetTextContent: setTextContent,\n\tsetAttribute: setAttribute\n});\n\n/*  */\n\nvar ref = {\n  create: function create (_, vnode) {\n    registerRef(vnode);\n  },\n  update: function update (oldVnode, vnode) {\n    if (oldVnode.data.ref !== vnode.data.ref) {\n      registerRef(oldVnode, true);\n      registerRef(vnode);\n    }\n  },\n  destroy: function destroy (vnode) {\n    registerRef(vnode, true);\n  }\n};\n\nfunction registerRef (vnode, isRemoval) {\n  var key = vnode.data.ref;\n  if (!key) { return }\n\n  var vm = vnode.context;\n  var ref = vnode.componentInstance || vnode.elm;\n  var refs = vm.$refs;\n  if (isRemoval) {\n    if (Array.isArray(refs[key])) {\n      remove$1(refs[key], ref);\n    } else if (refs[key] === ref) {\n      refs[key] = undefined;\n    }\n  } else {\n    if (vnode.data.refInFor) {\n      if (Array.isArray(refs[key]) && refs[key].indexOf(ref) < 0) {\n        refs[key].push(ref);\n      } else {\n        refs[key] = [ref];\n      }\n    } else {\n      refs[key] = ref;\n    }\n  }\n}\n\n/**\n * Virtual DOM patching algorithm based on Snabbdom by\n * Simon Friis Vindum (@paldepind)\n * Licensed under the MIT License\n * https://github.com/paldepind/snabbdom/blob/master/LICENSE\n *\n * modified by Evan You (@yyx990803)\n *\n\n/*\n * Not type-checking this because this file is perf-critical and the cost\n * of making flow understand it is not worth it.\n */\n\nvar emptyNode = new VNode('', {}, []);\n\nvar hooks$1 = ['create', 'activate', 'update', 'remove', 'destroy'];\n\nfunction isUndef (s) {\n  return s == null\n}\n\nfunction isDef (s) {\n  return s != null\n}\n\nfunction sameVnode (vnode1, vnode2) {\n  return (\n    vnode1.key === vnode2.key &&\n    vnode1.tag === vnode2.tag &&\n    vnode1.isComment === vnode2.isComment &&\n    !vnode1.data === !vnode2.data\n  )\n}\n\nfunction createKeyToOldIdx (children, beginIdx, endIdx) {\n  var i, key;\n  var map = {};\n  for (i = beginIdx; i <= endIdx; ++i) {\n    key = children[i].key;\n    if (isDef(key)) { map[key] = i; }\n  }\n  return map\n}\n\nfunction createPatchFunction (backend) {\n  var i, j;\n  var cbs = {};\n\n  var modules = backend.modules;\n  var nodeOps = backend.nodeOps;\n\n  for (i = 0; i < hooks$1.length; ++i) {\n    cbs[hooks$1[i]] = [];\n    for (j = 0; j < modules.length; ++j) {\n      if (modules[j][hooks$1[i]] !== undefined) { cbs[hooks$1[i]].push(modules[j][hooks$1[i]]); }\n    }\n  }\n\n  function emptyNodeAt (elm) {\n    return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)\n  }\n\n  function createRmCb (childElm, listeners) {\n    function remove$$1 () {\n      if (--remove$$1.listeners === 0) {\n        removeNode(childElm);\n      }\n    }\n    remove$$1.listeners = listeners;\n    return remove$$1\n  }\n\n  function removeNode (el) {\n    var parent = nodeOps.parentNode(el);\n    // element may have already been removed due to v-html / v-text\n    if (parent) {\n      nodeOps.removeChild(parent, el);\n    }\n  }\n\n  var inPre = 0;\n  function createElm (vnode, insertedVnodeQueue, parentElm, refElm, nested) {\n    vnode.isRootInsert = !nested; // for transition enter check\n    if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {\n      return\n    }\n\n    var data = vnode.data;\n    var children = vnode.children;\n    var tag = vnode.tag;\n    if (isDef(tag)) {\n      if (false) {\n        if (data && data.pre) {\n          inPre++;\n        }\n        if (\n          !inPre &&\n          !vnode.ns &&\n          !(config.ignoredElements.length && config.ignoredElements.indexOf(tag) > -1) &&\n          config.isUnknownElement(tag)\n        ) {\n          warn(\n            'Unknown custom element: <' + tag + '> - did you ' +\n            'register the component correctly? For recursive components, ' +\n            'make sure to provide the \"name\" option.',\n            vnode.context\n          );\n        }\n      }\n      vnode.elm = vnode.ns\n        ? nodeOps.createElementNS(vnode.ns, tag)\n        : nodeOps.createElement(tag, vnode);\n      setScope(vnode);\n\n      /* istanbul ignore if */\n      {\n        createChildren(vnode, children, insertedVnodeQueue);\n        if (isDef(data)) {\n          invokeCreateHooks(vnode, insertedVnodeQueue);\n        }\n        insert(parentElm, vnode.elm, refElm);\n      }\n\n      if (false) {\n        inPre--;\n      }\n    } else if (vnode.isComment) {\n      vnode.elm = nodeOps.createComment(vnode.text);\n      insert(parentElm, vnode.elm, refElm);\n    } else {\n      vnode.elm = nodeOps.createTextNode(vnode.text);\n      insert(parentElm, vnode.elm, refElm);\n    }\n  }\n\n  function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {\n    var i = vnode.data;\n    if (isDef(i)) {\n      var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;\n      if (isDef(i = i.hook) && isDef(i = i.init)) {\n        i(vnode, false /* hydrating */, parentElm, refElm);\n      }\n      // after calling the init hook, if the vnode is a child component\n      // it should've created a child instance and mounted it. the child\n      // component also has set the placeholder vnode's elm.\n      // in that case we can just return the element and be done.\n      if (isDef(vnode.componentInstance)) {\n        initComponent(vnode, insertedVnodeQueue);\n        if (isReactivated) {\n          reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);\n        }\n        return true\n      }\n    }\n  }\n\n  function initComponent (vnode, insertedVnodeQueue) {\n    if (vnode.data.pendingInsert) {\n      insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);\n    }\n    vnode.elm = vnode.componentInstance.$el;\n    if (isPatchable(vnode)) {\n      invokeCreateHooks(vnode, insertedVnodeQueue);\n      setScope(vnode);\n    } else {\n      // empty component root.\n      // skip all element-related modules except for ref (#3455)\n      registerRef(vnode);\n      // make sure to invoke the insert hook\n      insertedVnodeQueue.push(vnode);\n    }\n  }\n\n  function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {\n    var i;\n    // hack for #4339: a reactivated component with inner transition\n    // does not trigger because the inner node's created hooks are not called\n    // again. It's not ideal to involve module-specific logic in here but\n    // there doesn't seem to be a better way to do it.\n    var innerNode = vnode;\n    while (innerNode.componentInstance) {\n      innerNode = innerNode.componentInstance._vnode;\n      if (isDef(i = innerNode.data) && isDef(i = i.transition)) {\n        for (i = 0; i < cbs.activate.length; ++i) {\n          cbs.activate[i](emptyNode, innerNode);\n        }\n        insertedVnodeQueue.push(innerNode);\n        break\n      }\n    }\n    // unlike a newly created component,\n    // a reactivated keep-alive component doesn't insert itself\n    insert(parentElm, vnode.elm, refElm);\n  }\n\n  function insert (parent, elm, ref) {\n    if (parent) {\n      if (ref) {\n        nodeOps.insertBefore(parent, elm, ref);\n      } else {\n        nodeOps.appendChild(parent, elm);\n      }\n    }\n  }\n\n  function createChildren (vnode, children, insertedVnodeQueue) {\n    if (Array.isArray(children)) {\n      for (var i = 0; i < children.length; ++i) {\n        createElm(children[i], insertedVnodeQueue, vnode.elm, null, true);\n      }\n    } else if (isPrimitive(vnode.text)) {\n      nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(vnode.text));\n    }\n  }\n\n  function isPatchable (vnode) {\n    while (vnode.componentInstance) {\n      vnode = vnode.componentInstance._vnode;\n    }\n    return isDef(vnode.tag)\n  }\n\n  function invokeCreateHooks (vnode, insertedVnodeQueue) {\n    for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {\n      cbs.create[i$1](emptyNode, vnode);\n    }\n    i = vnode.data.hook; // Reuse variable\n    if (isDef(i)) {\n      if (i.create) { i.create(emptyNode, vnode); }\n      if (i.insert) { insertedVnodeQueue.push(vnode); }\n    }\n  }\n\n  // set scope id attribute for scoped CSS.\n  // this is implemented as a special case to avoid the overhead\n  // of going through the normal attribute patching process.\n  function setScope (vnode) {\n    var i;\n    if (isDef(i = vnode.context) && isDef(i = i.$options._scopeId)) {\n      nodeOps.setAttribute(vnode.elm, i, '');\n    }\n    if (isDef(i = activeInstance) &&\n        i !== vnode.context &&\n        isDef(i = i.$options._scopeId)) {\n      nodeOps.setAttribute(vnode.elm, i, '');\n    }\n  }\n\n  function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm);\n    }\n  }\n\n  function invokeDestroyHook (vnode) {\n    var i, j;\n    var data = vnode.data;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }\n      for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); }\n    }\n    if (isDef(i = vnode.children)) {\n      for (j = 0; j < vnode.children.length; ++j) {\n        invokeDestroyHook(vnode.children[j]);\n      }\n    }\n  }\n\n  function removeVnodes (parentElm, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      var ch = vnodes[startIdx];\n      if (isDef(ch)) {\n        if (isDef(ch.tag)) {\n          removeAndInvokeRemoveHook(ch);\n          invokeDestroyHook(ch);\n        } else { // Text node\n          removeNode(ch.elm);\n        }\n      }\n    }\n  }\n\n  function removeAndInvokeRemoveHook (vnode, rm) {\n    if (rm || isDef(vnode.data)) {\n      var listeners = cbs.remove.length + 1;\n      if (!rm) {\n        // directly removing\n        rm = createRmCb(vnode.elm, listeners);\n      } else {\n        // we have a recursively passed down rm callback\n        // increase the listeners count\n        rm.listeners += listeners;\n      }\n      // recursively invoke hooks on child component root node\n      if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {\n        removeAndInvokeRemoveHook(i, rm);\n      }\n      for (i = 0; i < cbs.remove.length; ++i) {\n        cbs.remove[i](vnode, rm);\n      }\n      if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {\n        i(vnode, rm);\n      } else {\n        rm();\n      }\n    } else {\n      removeNode(vnode.elm);\n    }\n  }\n\n  function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {\n    var oldStartIdx = 0;\n    var newStartIdx = 0;\n    var oldEndIdx = oldCh.length - 1;\n    var oldStartVnode = oldCh[0];\n    var oldEndVnode = oldCh[oldEndIdx];\n    var newEndIdx = newCh.length - 1;\n    var newStartVnode = newCh[0];\n    var newEndVnode = newCh[newEndIdx];\n    var oldKeyToIdx, idxInOld, elmToMove, refElm;\n\n    // removeOnly is a special flag used only by <transition-group>\n    // to ensure removed elements stay in correct relative positions\n    // during leaving transitions\n    var canMove = !removeOnly;\n\n    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n      if (isUndef(oldStartVnode)) {\n        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n      } else if (isUndef(oldEndVnode)) {\n        oldEndVnode = oldCh[--oldEndIdx];\n      } else if (sameVnode(oldStartVnode, newStartVnode)) {\n        patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);\n        canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));\n        oldStartVnode = oldCh[++oldStartIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);\n        canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else {\n        if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }\n        idxInOld = isDef(newStartVnode.key) ? oldKeyToIdx[newStartVnode.key] : null;\n        if (isUndef(idxInOld)) { // New element\n          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        } else {\n          elmToMove = oldCh[idxInOld];\n          /* istanbul ignore if */\n          if (false) {\n            warn(\n              'It seems there are duplicate keys that is causing an update error. ' +\n              'Make sure each v-for item has a unique key.'\n            );\n          }\n          if (sameVnode(elmToMove, newStartVnode)) {\n            patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);\n            oldCh[idxInOld] = undefined;\n            canMove && nodeOps.insertBefore(parentElm, newStartVnode.elm, oldStartVnode.elm);\n            newStartVnode = newCh[++newStartIdx];\n          } else {\n            // same key but different element. treat as new element\n            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);\n            newStartVnode = newCh[++newStartIdx];\n          }\n        }\n      }\n    }\n    if (oldStartIdx > oldEndIdx) {\n      refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;\n      addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);\n    } else if (newStartIdx > newEndIdx) {\n      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n    }\n  }\n\n  function patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly) {\n    if (oldVnode === vnode) {\n      return\n    }\n    // reuse element for static trees.\n    // note we only do this if the vnode is cloned -\n    // if the new node is not cloned it means the render functions have been\n    // reset by the hot-reload-api and we need to do a proper re-render.\n    if (vnode.isStatic &&\n        oldVnode.isStatic &&\n        vnode.key === oldVnode.key &&\n        (vnode.isCloned || vnode.isOnce)) {\n      vnode.elm = oldVnode.elm;\n      vnode.componentInstance = oldVnode.componentInstance;\n      return\n    }\n    var i;\n    var data = vnode.data;\n    var hasData = isDef(data);\n    if (hasData && isDef(i = data.hook) && isDef(i = i.prepatch)) {\n      i(oldVnode, vnode);\n    }\n    var elm = vnode.elm = oldVnode.elm;\n    var oldCh = oldVnode.children;\n    var ch = vnode.children;\n    if (hasData && isPatchable(vnode)) {\n      for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); }\n      if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }\n    }\n    if (isUndef(vnode.text)) {\n      if (isDef(oldCh) && isDef(ch)) {\n        if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }\n      } else if (isDef(ch)) {\n        if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }\n        addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);\n      } else if (isDef(oldCh)) {\n        removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n      } else if (isDef(oldVnode.text)) {\n        nodeOps.setTextContent(elm, '');\n      }\n    } else if (oldVnode.text !== vnode.text) {\n      nodeOps.setTextContent(elm, vnode.text);\n    }\n    if (hasData) {\n      if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); }\n    }\n  }\n\n  function invokeInsertHook (vnode, queue, initial) {\n    // delay insert hooks for component root nodes, invoke them after the\n    // element is really inserted\n    if (initial && vnode.parent) {\n      vnode.parent.data.pendingInsert = queue;\n    } else {\n      for (var i = 0; i < queue.length; ++i) {\n        queue[i].data.hook.insert(queue[i]);\n      }\n    }\n  }\n\n  var bailed = false;\n  // list of modules that can skip create hook during hydration because they\n  // are already rendered on the client or has no need for initialization\n  var isRenderedModule = makeMap('attrs,style,class,staticClass,staticStyle,key');\n\n  // Note: this is a browser-only function so we can assume elms are DOM nodes.\n  function hydrate (elm, vnode, insertedVnodeQueue) {\n    if (false) {\n      if (!assertNodeMatch(elm, vnode)) {\n        return false\n      }\n    }\n    vnode.elm = elm;\n    var tag = vnode.tag;\n    var data = vnode.data;\n    var children = vnode.children;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }\n      if (isDef(i = vnode.componentInstance)) {\n        // child component. it should have hydrated its own tree.\n        initComponent(vnode, insertedVnodeQueue);\n        return true\n      }\n    }\n    if (isDef(tag)) {\n      if (isDef(children)) {\n        // empty element, allow client to pick up and populate children\n        if (!elm.hasChildNodes()) {\n          createChildren(vnode, children, insertedVnodeQueue);\n        } else {\n          var childrenMatch = true;\n          var childNode = elm.firstChild;\n          for (var i$1 = 0; i$1 < children.length; i$1++) {\n            if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue)) {\n              childrenMatch = false;\n              break\n            }\n            childNode = childNode.nextSibling;\n          }\n          // if childNode is not null, it means the actual childNodes list is\n          // longer than the virtual children list.\n          if (!childrenMatch || childNode) {\n            if (false) {\n              bailed = true;\n              console.warn('Parent: ', elm);\n              console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);\n            }\n            return false\n          }\n        }\n      }\n      if (isDef(data)) {\n        for (var key in data) {\n          if (!isRenderedModule(key)) {\n            invokeCreateHooks(vnode, insertedVnodeQueue);\n            break\n          }\n        }\n      }\n    } else if (elm.data !== vnode.text) {\n      elm.data = vnode.text;\n    }\n    return true\n  }\n\n  function assertNodeMatch (node, vnode) {\n    if (vnode.tag) {\n      return (\n        vnode.tag.indexOf('vue-component') === 0 ||\n        vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())\n      )\n    } else {\n      return node.nodeType === (vnode.isComment ? 8 : 3)\n    }\n  }\n\n  return function patch (oldVnode, vnode, hydrating, removeOnly, parentElm, refElm) {\n    if (!vnode) {\n      if (oldVnode) { invokeDestroyHook(oldVnode); }\n      return\n    }\n\n    var isInitialPatch = false;\n    var insertedVnodeQueue = [];\n\n    if (!oldVnode) {\n      // empty mount (likely as component), create new root element\n      isInitialPatch = true;\n      createElm(vnode, insertedVnodeQueue, parentElm, refElm);\n    } else {\n      var isRealElement = isDef(oldVnode.nodeType);\n      if (!isRealElement && sameVnode(oldVnode, vnode)) {\n        // patch existing root node\n        patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly);\n      } else {\n        if (isRealElement) {\n          // mounting to a real element\n          // check if this is server-rendered content and if we can perform\n          // a successful hydration.\n          if (oldVnode.nodeType === 1 && oldVnode.hasAttribute('server-rendered')) {\n            oldVnode.removeAttribute('server-rendered');\n            hydrating = true;\n          }\n          if (hydrating) {\n            if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {\n              invokeInsertHook(vnode, insertedVnodeQueue, true);\n              return oldVnode\n            } else if (false) {\n              warn(\n                'The client-side rendered virtual DOM tree is not matching ' +\n                'server-rendered content. This is likely caused by incorrect ' +\n                'HTML markup, for example nesting block-level elements inside ' +\n                '<p>, or missing <tbody>. Bailing hydration and performing ' +\n                'full client-side render.'\n              );\n            }\n          }\n          // either not server-rendered, or hydration failed.\n          // create an empty node and replace it\n          oldVnode = emptyNodeAt(oldVnode);\n        }\n        // replacing existing element\n        var oldElm = oldVnode.elm;\n        var parentElm$1 = nodeOps.parentNode(oldElm);\n        createElm(\n          vnode,\n          insertedVnodeQueue,\n          // extremely rare edge case: do not insert if old element is in a\n          // leaving transition. Only happens when combining transition +\n          // keep-alive + HOCs. (#4590)\n          oldElm._leaveCb ? null : parentElm$1,\n          nodeOps.nextSibling(oldElm)\n        );\n\n        if (vnode.parent) {\n          // component root element replaced.\n          // update parent placeholder node element, recursively\n          var ancestor = vnode.parent;\n          while (ancestor) {\n            ancestor.elm = vnode.elm;\n            ancestor = ancestor.parent;\n          }\n          if (isPatchable(vnode)) {\n            for (var i = 0; i < cbs.create.length; ++i) {\n              cbs.create[i](emptyNode, vnode.parent);\n            }\n          }\n        }\n\n        if (parentElm$1 !== null) {\n          removeVnodes(parentElm$1, [oldVnode], 0, 0);\n        } else if (isDef(oldVnode.tag)) {\n          invokeDestroyHook(oldVnode);\n        }\n      }\n    }\n\n    invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);\n    return vnode.elm\n  }\n}\n\n/*  */\n\nvar directives = {\n  create: updateDirectives,\n  update: updateDirectives,\n  destroy: function unbindDirectives (vnode) {\n    updateDirectives(vnode, emptyNode);\n  }\n};\n\nfunction updateDirectives (oldVnode, vnode) {\n  if (oldVnode.data.directives || vnode.data.directives) {\n    _update(oldVnode, vnode);\n  }\n}\n\nfunction _update (oldVnode, vnode) {\n  var isCreate = oldVnode === emptyNode;\n  var isDestroy = vnode === emptyNode;\n  var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);\n  var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);\n\n  var dirsWithInsert = [];\n  var dirsWithPostpatch = [];\n\n  var key, oldDir, dir;\n  for (key in newDirs) {\n    oldDir = oldDirs[key];\n    dir = newDirs[key];\n    if (!oldDir) {\n      // new directive, bind\n      callHook$1(dir, 'bind', vnode, oldVnode);\n      if (dir.def && dir.def.inserted) {\n        dirsWithInsert.push(dir);\n      }\n    } else {\n      // existing directive, update\n      dir.oldValue = oldDir.value;\n      callHook$1(dir, 'update', vnode, oldVnode);\n      if (dir.def && dir.def.componentUpdated) {\n        dirsWithPostpatch.push(dir);\n      }\n    }\n  }\n\n  if (dirsWithInsert.length) {\n    var callInsert = function () {\n      for (var i = 0; i < dirsWithInsert.length; i++) {\n        callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);\n      }\n    };\n    if (isCreate) {\n      mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', callInsert, 'dir-insert');\n    } else {\n      callInsert();\n    }\n  }\n\n  if (dirsWithPostpatch.length) {\n    mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'postpatch', function () {\n      for (var i = 0; i < dirsWithPostpatch.length; i++) {\n        callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);\n      }\n    }, 'dir-postpatch');\n  }\n\n  if (!isCreate) {\n    for (key in oldDirs) {\n      if (!newDirs[key]) {\n        // no longer present, unbind\n        callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);\n      }\n    }\n  }\n}\n\nvar emptyModifiers = Object.create(null);\n\nfunction normalizeDirectives$1 (\n  dirs,\n  vm\n) {\n  var res = Object.create(null);\n  if (!dirs) {\n    return res\n  }\n  var i, dir;\n  for (i = 0; i < dirs.length; i++) {\n    dir = dirs[i];\n    if (!dir.modifiers) {\n      dir.modifiers = emptyModifiers;\n    }\n    res[getRawDirName(dir)] = dir;\n    dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);\n  }\n  return res\n}\n\nfunction getRawDirName (dir) {\n  return dir.rawName || ((dir.name) + \".\" + (Object.keys(dir.modifiers || {}).join('.')))\n}\n\nfunction callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {\n  var fn = dir.def && dir.def[hook];\n  if (fn) {\n    fn(vnode.elm, dir, vnode, oldVnode, isDestroy);\n  }\n}\n\nvar baseModules = [\n  ref,\n  directives\n];\n\n/*  */\n\nfunction updateAttrs (oldVnode, vnode) {\n  if (!oldVnode.data.attrs && !vnode.data.attrs) {\n    return\n  }\n  var key, cur, old;\n  var elm = vnode.elm;\n  var oldAttrs = oldVnode.data.attrs || {};\n  var attrs = vnode.data.attrs || {};\n  // clone observed objects, as the user probably wants to mutate it\n  if (attrs.__ob__) {\n    attrs = vnode.data.attrs = extend({}, attrs);\n  }\n\n  for (key in attrs) {\n    cur = attrs[key];\n    old = oldAttrs[key];\n    if (old !== cur) {\n      setAttr(elm, key, cur);\n    }\n  }\n  // #4391: in IE9, setting type can reset value for input[type=radio]\n  /* istanbul ignore if */\n  if (isIE9 && attrs.value !== oldAttrs.value) {\n    setAttr(elm, 'value', attrs.value);\n  }\n  for (key in oldAttrs) {\n    if (attrs[key] == null) {\n      if (isXlink(key)) {\n        elm.removeAttributeNS(xlinkNS, getXlinkProp(key));\n      } else if (!isEnumeratedAttr(key)) {\n        elm.removeAttribute(key);\n      }\n    }\n  }\n}\n\nfunction setAttr (el, key, value) {\n  if (isBooleanAttr(key)) {\n    // set attribute for blank value\n    // e.g. <option disabled>Select one</option>\n    if (isFalsyAttrValue(value)) {\n      el.removeAttribute(key);\n    } else {\n      el.setAttribute(key, key);\n    }\n  } else if (isEnumeratedAttr(key)) {\n    el.setAttribute(key, isFalsyAttrValue(value) || value === 'false' ? 'false' : 'true');\n  } else if (isXlink(key)) {\n    if (isFalsyAttrValue(value)) {\n      el.removeAttributeNS(xlinkNS, getXlinkProp(key));\n    } else {\n      el.setAttributeNS(xlinkNS, key, value);\n    }\n  } else {\n    if (isFalsyAttrValue(value)) {\n      el.removeAttribute(key);\n    } else {\n      el.setAttribute(key, value);\n    }\n  }\n}\n\nvar attrs = {\n  create: updateAttrs,\n  update: updateAttrs\n};\n\n/*  */\n\nfunction updateClass (oldVnode, vnode) {\n  var el = vnode.elm;\n  var data = vnode.data;\n  var oldData = oldVnode.data;\n  if (!data.staticClass && !data.class &&\n      (!oldData || (!oldData.staticClass && !oldData.class))) {\n    return\n  }\n\n  var cls = genClassForVnode(vnode);\n\n  // handle transition classes\n  var transitionClass = el._transitionClasses;\n  if (transitionClass) {\n    cls = concat(cls, stringifyClass(transitionClass));\n  }\n\n  // set the class\n  if (cls !== el._prevClass) {\n    el.setAttribute('class', cls);\n    el._prevClass = cls;\n  }\n}\n\nvar klass = {\n  create: updateClass,\n  update: updateClass\n};\n\n/*  */\n\nvar target$1;\n\nfunction add$2 (\n  event,\n  handler,\n  once,\n  capture\n) {\n  if (once) {\n    var oldHandler = handler;\n    var _target = target$1; // save current target element in closure\n    handler = function (ev) {\n      remove$3(event, handler, capture, _target);\n      arguments.length === 1\n        ? oldHandler(ev)\n        : oldHandler.apply(null, arguments);\n    };\n  }\n  target$1.addEventListener(event, handler, capture);\n}\n\nfunction remove$3 (\n  event,\n  handler,\n  capture,\n  _target\n) {\n  (_target || target$1).removeEventListener(event, handler, capture);\n}\n\nfunction updateDOMListeners (oldVnode, vnode) {\n  if (!oldVnode.data.on && !vnode.data.on) {\n    return\n  }\n  var on = vnode.data.on || {};\n  var oldOn = oldVnode.data.on || {};\n  target$1 = vnode.elm;\n  updateListeners(on, oldOn, add$2, remove$3, vnode.context);\n}\n\nvar events = {\n  create: updateDOMListeners,\n  update: updateDOMListeners\n};\n\n/*  */\n\nfunction updateDOMProps (oldVnode, vnode) {\n  if (!oldVnode.data.domProps && !vnode.data.domProps) {\n    return\n  }\n  var key, cur;\n  var elm = vnode.elm;\n  var oldProps = oldVnode.data.domProps || {};\n  var props = vnode.data.domProps || {};\n  // clone observed objects, as the user probably wants to mutate it\n  if (props.__ob__) {\n    props = vnode.data.domProps = extend({}, props);\n  }\n\n  for (key in oldProps) {\n    if (props[key] == null) {\n      elm[key] = '';\n    }\n  }\n  for (key in props) {\n    cur = props[key];\n    // ignore children if the node has textContent or innerHTML,\n    // as these will throw away existing DOM nodes and cause removal errors\n    // on subsequent patches (#3360)\n    if (key === 'textContent' || key === 'innerHTML') {\n      if (vnode.children) { vnode.children.length = 0; }\n      if (cur === oldProps[key]) { continue }\n    }\n\n    if (key === 'value') {\n      // store value as _value as well since\n      // non-string values will be stringified\n      elm._value = cur;\n      // avoid resetting cursor position when value is the same\n      var strCur = cur == null ? '' : String(cur);\n      if (shouldUpdateValue(elm, vnode, strCur)) {\n        elm.value = strCur;\n      }\n    } else {\n      elm[key] = cur;\n    }\n  }\n}\n\n// check platforms/web/util/attrs.js acceptValue\n\n\nfunction shouldUpdateValue (\n  elm,\n  vnode,\n  checkVal\n) {\n  return (!elm.composing && (\n    vnode.tag === 'option' ||\n    isDirty(elm, checkVal) ||\n    isInputChanged(vnode, checkVal)\n  ))\n}\n\nfunction isDirty (elm, checkVal) {\n  // return true when textbox (.number and .trim) loses focus and its value is not equal to the updated value\n  return document.activeElement !== elm && elm.value !== checkVal\n}\n\nfunction isInputChanged (vnode, newVal) {\n  var value = vnode.elm.value;\n  var modifiers = vnode.elm._vModifiers; // injected by v-model runtime\n  if ((modifiers && modifiers.number) || vnode.elm.type === 'number') {\n    return toNumber(value) !== toNumber(newVal)\n  }\n  if (modifiers && modifiers.trim) {\n    return value.trim() !== newVal.trim()\n  }\n  return value !== newVal\n}\n\nvar domProps = {\n  create: updateDOMProps,\n  update: updateDOMProps\n};\n\n/*  */\n\nvar parseStyleText = cached(function (cssText) {\n  var res = {};\n  var listDelimiter = /;(?![^(]*\\))/g;\n  var propertyDelimiter = /:(.+)/;\n  cssText.split(listDelimiter).forEach(function (item) {\n    if (item) {\n      var tmp = item.split(propertyDelimiter);\n      tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());\n    }\n  });\n  return res\n});\n\n// merge static and dynamic style data on the same vnode\nfunction normalizeStyleData (data) {\n  var style = normalizeStyleBinding(data.style);\n  // static style is pre-processed into an object during compilation\n  // and is always a fresh object, so it's safe to merge into it\n  return data.staticStyle\n    ? extend(data.staticStyle, style)\n    : style\n}\n\n// normalize possible array / string values into Object\nfunction normalizeStyleBinding (bindingStyle) {\n  if (Array.isArray(bindingStyle)) {\n    return toObject(bindingStyle)\n  }\n  if (typeof bindingStyle === 'string') {\n    return parseStyleText(bindingStyle)\n  }\n  return bindingStyle\n}\n\n/**\n * parent component style should be after child's\n * so that parent component's style could override it\n */\nfunction getStyle (vnode, checkChild) {\n  var res = {};\n  var styleData;\n\n  if (checkChild) {\n    var childNode = vnode;\n    while (childNode.componentInstance) {\n      childNode = childNode.componentInstance._vnode;\n      if (childNode.data && (styleData = normalizeStyleData(childNode.data))) {\n        extend(res, styleData);\n      }\n    }\n  }\n\n  if ((styleData = normalizeStyleData(vnode.data))) {\n    extend(res, styleData);\n  }\n\n  var parentNode = vnode;\n  while ((parentNode = parentNode.parent)) {\n    if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {\n      extend(res, styleData);\n    }\n  }\n  return res\n}\n\n/*  */\n\nvar cssVarRE = /^--/;\nvar importantRE = /\\s*!important$/;\nvar setProp = function (el, name, val) {\n  /* istanbul ignore if */\n  if (cssVarRE.test(name)) {\n    el.style.setProperty(name, val);\n  } else if (importantRE.test(val)) {\n    el.style.setProperty(name, val.replace(importantRE, ''), 'important');\n  } else {\n    el.style[normalize(name)] = val;\n  }\n};\n\nvar prefixes = ['Webkit', 'Moz', 'ms'];\n\nvar testEl;\nvar normalize = cached(function (prop) {\n  testEl = testEl || document.createElement('div');\n  prop = camelize(prop);\n  if (prop !== 'filter' && (prop in testEl.style)) {\n    return prop\n  }\n  var upper = prop.charAt(0).toUpperCase() + prop.slice(1);\n  for (var i = 0; i < prefixes.length; i++) {\n    var prefixed = prefixes[i] + upper;\n    if (prefixed in testEl.style) {\n      return prefixed\n    }\n  }\n});\n\nfunction updateStyle (oldVnode, vnode) {\n  var data = vnode.data;\n  var oldData = oldVnode.data;\n\n  if (!data.staticStyle && !data.style &&\n      !oldData.staticStyle && !oldData.style) {\n    return\n  }\n\n  var cur, name;\n  var el = vnode.elm;\n  var oldStaticStyle = oldVnode.data.staticStyle;\n  var oldStyleBinding = oldVnode.data.style || {};\n\n  // if static style exists, stylebinding already merged into it when doing normalizeStyleData\n  var oldStyle = oldStaticStyle || oldStyleBinding;\n\n  var style = normalizeStyleBinding(vnode.data.style) || {};\n\n  vnode.data.style = style.__ob__ ? extend({}, style) : style;\n\n  var newStyle = getStyle(vnode, true);\n\n  for (name in oldStyle) {\n    if (newStyle[name] == null) {\n      setProp(el, name, '');\n    }\n  }\n  for (name in newStyle) {\n    cur = newStyle[name];\n    if (cur !== oldStyle[name]) {\n      // ie9 setting to null has no effect, must use empty string\n      setProp(el, name, cur == null ? '' : cur);\n    }\n  }\n}\n\nvar style = {\n  create: updateStyle,\n  update: updateStyle\n};\n\n/*  */\n\n/**\n * Add class with compatibility for SVG since classList is not supported on\n * SVG elements in IE\n */\nfunction addClass (el, cls) {\n  /* istanbul ignore if */\n  if (!cls || !cls.trim()) {\n    return\n  }\n\n  /* istanbul ignore else */\n  if (el.classList) {\n    if (cls.indexOf(' ') > -1) {\n      cls.split(/\\s+/).forEach(function (c) { return el.classList.add(c); });\n    } else {\n      el.classList.add(cls);\n    }\n  } else {\n    var cur = ' ' + el.getAttribute('class') + ' ';\n    if (cur.indexOf(' ' + cls + ' ') < 0) {\n      el.setAttribute('class', (cur + cls).trim());\n    }\n  }\n}\n\n/**\n * Remove class with compatibility for SVG since classList is not supported on\n * SVG elements in IE\n */\nfunction removeClass (el, cls) {\n  /* istanbul ignore if */\n  if (!cls || !cls.trim()) {\n    return\n  }\n\n  /* istanbul ignore else */\n  if (el.classList) {\n    if (cls.indexOf(' ') > -1) {\n      cls.split(/\\s+/).forEach(function (c) { return el.classList.remove(c); });\n    } else {\n      el.classList.remove(cls);\n    }\n  } else {\n    var cur = ' ' + el.getAttribute('class') + ' ';\n    var tar = ' ' + cls + ' ';\n    while (cur.indexOf(tar) >= 0) {\n      cur = cur.replace(tar, ' ');\n    }\n    el.setAttribute('class', cur.trim());\n  }\n}\n\n/*  */\n\nvar hasTransition = inBrowser && !isIE9;\nvar TRANSITION = 'transition';\nvar ANIMATION = 'animation';\n\n// Transition property/event sniffing\nvar transitionProp = 'transition';\nvar transitionEndEvent = 'transitionend';\nvar animationProp = 'animation';\nvar animationEndEvent = 'animationend';\nif (hasTransition) {\n  /* istanbul ignore if */\n  if (window.ontransitionend === undefined &&\n    window.onwebkittransitionend !== undefined) {\n    transitionProp = 'WebkitTransition';\n    transitionEndEvent = 'webkitTransitionEnd';\n  }\n  if (window.onanimationend === undefined &&\n    window.onwebkitanimationend !== undefined) {\n    animationProp = 'WebkitAnimation';\n    animationEndEvent = 'webkitAnimationEnd';\n  }\n}\n\n// binding to window is necessary to make hot reload work in IE in strict mode\nvar raf = inBrowser && window.requestAnimationFrame\n  ? window.requestAnimationFrame.bind(window)\n  : setTimeout;\n\nfunction nextFrame (fn) {\n  raf(function () {\n    raf(fn);\n  });\n}\n\nfunction addTransitionClass (el, cls) {\n  (el._transitionClasses || (el._transitionClasses = [])).push(cls);\n  addClass(el, cls);\n}\n\nfunction removeTransitionClass (el, cls) {\n  if (el._transitionClasses) {\n    remove$1(el._transitionClasses, cls);\n  }\n  removeClass(el, cls);\n}\n\nfunction whenTransitionEnds (\n  el,\n  expectedType,\n  cb\n) {\n  var ref = getTransitionInfo(el, expectedType);\n  var type = ref.type;\n  var timeout = ref.timeout;\n  var propCount = ref.propCount;\n  if (!type) { return cb() }\n  var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;\n  var ended = 0;\n  var end = function () {\n    el.removeEventListener(event, onEnd);\n    cb();\n  };\n  var onEnd = function (e) {\n    if (e.target === el) {\n      if (++ended >= propCount) {\n        end();\n      }\n    }\n  };\n  setTimeout(function () {\n    if (ended < propCount) {\n      end();\n    }\n  }, timeout + 1);\n  el.addEventListener(event, onEnd);\n}\n\nvar transformRE = /\\b(transform|all)(,|$)/;\n\nfunction getTransitionInfo (el, expectedType) {\n  var styles = window.getComputedStyle(el);\n  var transitioneDelays = styles[transitionProp + 'Delay'].split(', ');\n  var transitionDurations = styles[transitionProp + 'Duration'].split(', ');\n  var transitionTimeout = getTimeout(transitioneDelays, transitionDurations);\n  var animationDelays = styles[animationProp + 'Delay'].split(', ');\n  var animationDurations = styles[animationProp + 'Duration'].split(', ');\n  var animationTimeout = getTimeout(animationDelays, animationDurations);\n\n  var type;\n  var timeout = 0;\n  var propCount = 0;\n  /* istanbul ignore if */\n  if (expectedType === TRANSITION) {\n    if (transitionTimeout > 0) {\n      type = TRANSITION;\n      timeout = transitionTimeout;\n      propCount = transitionDurations.length;\n    }\n  } else if (expectedType === ANIMATION) {\n    if (animationTimeout > 0) {\n      type = ANIMATION;\n      timeout = animationTimeout;\n      propCount = animationDurations.length;\n    }\n  } else {\n    timeout = Math.max(transitionTimeout, animationTimeout);\n    type = timeout > 0\n      ? transitionTimeout > animationTimeout\n        ? TRANSITION\n        : ANIMATION\n      : null;\n    propCount = type\n      ? type === TRANSITION\n        ? transitionDurations.length\n        : animationDurations.length\n      : 0;\n  }\n  var hasTransform =\n    type === TRANSITION &&\n    transformRE.test(styles[transitionProp + 'Property']);\n  return {\n    type: type,\n    timeout: timeout,\n    propCount: propCount,\n    hasTransform: hasTransform\n  }\n}\n\nfunction getTimeout (delays, durations) {\n  /* istanbul ignore next */\n  while (delays.length < durations.length) {\n    delays = delays.concat(delays);\n  }\n\n  return Math.max.apply(null, durations.map(function (d, i) {\n    return toMs(d) + toMs(delays[i])\n  }))\n}\n\nfunction toMs (s) {\n  return Number(s.slice(0, -1)) * 1000\n}\n\n/*  */\n\nfunction enter (vnode, toggleDisplay) {\n  var el = vnode.elm;\n\n  // call leave callback now\n  if (el._leaveCb) {\n    el._leaveCb.cancelled = true;\n    el._leaveCb();\n  }\n\n  var data = resolveTransition(vnode.data.transition);\n  if (!data) {\n    return\n  }\n\n  /* istanbul ignore if */\n  if (el._enterCb || el.nodeType !== 1) {\n    return\n  }\n\n  var css = data.css;\n  var type = data.type;\n  var enterClass = data.enterClass;\n  var enterToClass = data.enterToClass;\n  var enterActiveClass = data.enterActiveClass;\n  var appearClass = data.appearClass;\n  var appearToClass = data.appearToClass;\n  var appearActiveClass = data.appearActiveClass;\n  var beforeEnter = data.beforeEnter;\n  var enter = data.enter;\n  var afterEnter = data.afterEnter;\n  var enterCancelled = data.enterCancelled;\n  var beforeAppear = data.beforeAppear;\n  var appear = data.appear;\n  var afterAppear = data.afterAppear;\n  var appearCancelled = data.appearCancelled;\n\n  // activeInstance will always be the <transition> component managing this\n  // transition. One edge case to check is when the <transition> is placed\n  // as the root node of a child component. In that case we need to check\n  // <transition>'s parent for appear check.\n  var context = activeInstance;\n  var transitionNode = activeInstance.$vnode;\n  while (transitionNode && transitionNode.parent) {\n    transitionNode = transitionNode.parent;\n    context = transitionNode.context;\n  }\n\n  var isAppear = !context._isMounted || !vnode.isRootInsert;\n\n  if (isAppear && !appear && appear !== '') {\n    return\n  }\n\n  var startClass = isAppear ? appearClass : enterClass;\n  var activeClass = isAppear ? appearActiveClass : enterActiveClass;\n  var toClass = isAppear ? appearToClass : enterToClass;\n  var beforeEnterHook = isAppear ? (beforeAppear || beforeEnter) : beforeEnter;\n  var enterHook = isAppear ? (typeof appear === 'function' ? appear : enter) : enter;\n  var afterEnterHook = isAppear ? (afterAppear || afterEnter) : afterEnter;\n  var enterCancelledHook = isAppear ? (appearCancelled || enterCancelled) : enterCancelled;\n\n  var expectsCSS = css !== false && !isIE9;\n  var userWantsControl =\n    enterHook &&\n    // enterHook may be a bound method which exposes\n    // the length of original fn as _length\n    (enterHook._length || enterHook.length) > 1;\n\n  var cb = el._enterCb = once(function () {\n    if (expectsCSS) {\n      removeTransitionClass(el, toClass);\n      removeTransitionClass(el, activeClass);\n    }\n    if (cb.cancelled) {\n      if (expectsCSS) {\n        removeTransitionClass(el, startClass);\n      }\n      enterCancelledHook && enterCancelledHook(el);\n    } else {\n      afterEnterHook && afterEnterHook(el);\n    }\n    el._enterCb = null;\n  });\n\n  if (!vnode.data.show) {\n    // remove pending leave element on enter by injecting an insert hook\n    mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', function () {\n      var parent = el.parentNode;\n      var pendingNode = parent && parent._pending && parent._pending[vnode.key];\n      if (pendingNode &&\n          pendingNode.tag === vnode.tag &&\n          pendingNode.elm._leaveCb) {\n        pendingNode.elm._leaveCb();\n      }\n      enterHook && enterHook(el, cb);\n    }, 'transition-insert');\n  }\n\n  // start enter transition\n  beforeEnterHook && beforeEnterHook(el);\n  if (expectsCSS) {\n    addTransitionClass(el, startClass);\n    addTransitionClass(el, activeClass);\n    nextFrame(function () {\n      addTransitionClass(el, toClass);\n      removeTransitionClass(el, startClass);\n      if (!cb.cancelled && !userWantsControl) {\n        whenTransitionEnds(el, type, cb);\n      }\n    });\n  }\n\n  if (vnode.data.show) {\n    toggleDisplay && toggleDisplay();\n    enterHook && enterHook(el, cb);\n  }\n\n  if (!expectsCSS && !userWantsControl) {\n    cb();\n  }\n}\n\nfunction leave (vnode, rm) {\n  var el = vnode.elm;\n\n  // call enter callback now\n  if (el._enterCb) {\n    el._enterCb.cancelled = true;\n    el._enterCb();\n  }\n\n  var data = resolveTransition(vnode.data.transition);\n  if (!data) {\n    return rm()\n  }\n\n  /* istanbul ignore if */\n  if (el._leaveCb || el.nodeType !== 1) {\n    return\n  }\n\n  var css = data.css;\n  var type = data.type;\n  var leaveClass = data.leaveClass;\n  var leaveToClass = data.leaveToClass;\n  var leaveActiveClass = data.leaveActiveClass;\n  var beforeLeave = data.beforeLeave;\n  var leave = data.leave;\n  var afterLeave = data.afterLeave;\n  var leaveCancelled = data.leaveCancelled;\n  var delayLeave = data.delayLeave;\n\n  var expectsCSS = css !== false && !isIE9;\n  var userWantsControl =\n    leave &&\n    // leave hook may be a bound method which exposes\n    // the length of original fn as _length\n    (leave._length || leave.length) > 1;\n\n  var cb = el._leaveCb = once(function () {\n    if (el.parentNode && el.parentNode._pending) {\n      el.parentNode._pending[vnode.key] = null;\n    }\n    if (expectsCSS) {\n      removeTransitionClass(el, leaveToClass);\n      removeTransitionClass(el, leaveActiveClass);\n    }\n    if (cb.cancelled) {\n      if (expectsCSS) {\n        removeTransitionClass(el, leaveClass);\n      }\n      leaveCancelled && leaveCancelled(el);\n    } else {\n      rm();\n      afterLeave && afterLeave(el);\n    }\n    el._leaveCb = null;\n  });\n\n  if (delayLeave) {\n    delayLeave(performLeave);\n  } else {\n    performLeave();\n  }\n\n  function performLeave () {\n    // the delayed leave may have already been cancelled\n    if (cb.cancelled) {\n      return\n    }\n    // record leaving element\n    if (!vnode.data.show) {\n      (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;\n    }\n    beforeLeave && beforeLeave(el);\n    if (expectsCSS) {\n      addTransitionClass(el, leaveClass);\n      addTransitionClass(el, leaveActiveClass);\n      nextFrame(function () {\n        addTransitionClass(el, leaveToClass);\n        removeTransitionClass(el, leaveClass);\n        if (!cb.cancelled && !userWantsControl) {\n          whenTransitionEnds(el, type, cb);\n        }\n      });\n    }\n    leave && leave(el, cb);\n    if (!expectsCSS && !userWantsControl) {\n      cb();\n    }\n  }\n}\n\nfunction resolveTransition (def$$1) {\n  if (!def$$1) {\n    return\n  }\n  /* istanbul ignore else */\n  if (typeof def$$1 === 'object') {\n    var res = {};\n    if (def$$1.css !== false) {\n      extend(res, autoCssTransition(def$$1.name || 'v'));\n    }\n    extend(res, def$$1);\n    return res\n  } else if (typeof def$$1 === 'string') {\n    return autoCssTransition(def$$1)\n  }\n}\n\nvar autoCssTransition = cached(function (name) {\n  return {\n    enterClass: (name + \"-enter\"),\n    leaveClass: (name + \"-leave\"),\n    appearClass: (name + \"-enter\"),\n    enterToClass: (name + \"-enter-to\"),\n    leaveToClass: (name + \"-leave-to\"),\n    appearToClass: (name + \"-enter-to\"),\n    enterActiveClass: (name + \"-enter-active\"),\n    leaveActiveClass: (name + \"-leave-active\"),\n    appearActiveClass: (name + \"-enter-active\")\n  }\n});\n\nfunction once (fn) {\n  var called = false;\n  return function () {\n    if (!called) {\n      called = true;\n      fn();\n    }\n  }\n}\n\nfunction _enter (_, vnode) {\n  if (!vnode.data.show) {\n    enter(vnode);\n  }\n}\n\nvar transition = inBrowser ? {\n  create: _enter,\n  activate: _enter,\n  remove: function remove (vnode, rm) {\n    /* istanbul ignore else */\n    if (!vnode.data.show) {\n      leave(vnode, rm);\n    } else {\n      rm();\n    }\n  }\n} : {};\n\nvar platformModules = [\n  attrs,\n  klass,\n  events,\n  domProps,\n  style,\n  transition\n];\n\n/*  */\n\n// the directive module should be applied last, after all\n// built-in modules have been applied.\nvar modules = platformModules.concat(baseModules);\n\nvar patch$1 = createPatchFunction({ nodeOps: nodeOps, modules: modules });\n\n/**\n * Not type checking this file because flow doesn't like attaching\n * properties to Elements.\n */\n\nvar modelableTagRE = /^input|select|textarea|vue-component-[0-9]+(-[0-9a-zA-Z_-]*)?$/;\n\n/* istanbul ignore if */\nif (isIE9) {\n  // http://www.matts411.com/post/internet-explorer-9-oninput/\n  document.addEventListener('selectionchange', function () {\n    var el = document.activeElement;\n    if (el && el.vmodel) {\n      trigger(el, 'input');\n    }\n  });\n}\n\nvar model = {\n  inserted: function inserted (el, binding, vnode) {\n    if (false) {\n      if (!modelableTagRE.test(vnode.tag)) {\n        warn(\n          \"v-model is not supported on element type: <\" + (vnode.tag) + \">. \" +\n          'If you are working with contenteditable, it\\'s recommended to ' +\n          'wrap a library dedicated for that purpose inside a custom component.',\n          vnode.context\n        );\n      }\n    }\n    if (vnode.tag === 'select') {\n      var cb = function () {\n        setSelected(el, binding, vnode.context);\n      };\n      cb();\n      /* istanbul ignore if */\n      if (isIE || isEdge) {\n        setTimeout(cb, 0);\n      }\n    } else if (vnode.tag === 'textarea' || el.type === 'text') {\n      el._vModifiers = binding.modifiers;\n      if (!binding.modifiers.lazy) {\n        if (!isAndroid) {\n          el.addEventListener('compositionstart', onCompositionStart);\n          el.addEventListener('compositionend', onCompositionEnd);\n        }\n        /* istanbul ignore if */\n        if (isIE9) {\n          el.vmodel = true;\n        }\n      }\n    }\n  },\n  componentUpdated: function componentUpdated (el, binding, vnode) {\n    if (vnode.tag === 'select') {\n      setSelected(el, binding, vnode.context);\n      // in case the options rendered by v-for have changed,\n      // it's possible that the value is out-of-sync with the rendered options.\n      // detect such cases and filter out values that no longer has a matching\n      // option in the DOM.\n      var needReset = el.multiple\n        ? binding.value.some(function (v) { return hasNoMatchingOption(v, el.options); })\n        : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, el.options);\n      if (needReset) {\n        trigger(el, 'change');\n      }\n    }\n  }\n};\n\nfunction setSelected (el, binding, vm) {\n  var value = binding.value;\n  var isMultiple = el.multiple;\n  if (isMultiple && !Array.isArray(value)) {\n    \"production\" !== 'production' && warn(\n      \"<select multiple v-model=\\\"\" + (binding.expression) + \"\\\"> \" +\n      \"expects an Array value for its binding, but got \" + (Object.prototype.toString.call(value).slice(8, -1)),\n      vm\n    );\n    return\n  }\n  var selected, option;\n  for (var i = 0, l = el.options.length; i < l; i++) {\n    option = el.options[i];\n    if (isMultiple) {\n      selected = looseIndexOf(value, getValue(option)) > -1;\n      if (option.selected !== selected) {\n        option.selected = selected;\n      }\n    } else {\n      if (looseEqual(getValue(option), value)) {\n        if (el.selectedIndex !== i) {\n          el.selectedIndex = i;\n        }\n        return\n      }\n    }\n  }\n  if (!isMultiple) {\n    el.selectedIndex = -1;\n  }\n}\n\nfunction hasNoMatchingOption (value, options) {\n  for (var i = 0, l = options.length; i < l; i++) {\n    if (looseEqual(getValue(options[i]), value)) {\n      return false\n    }\n  }\n  return true\n}\n\nfunction getValue (option) {\n  return '_value' in option\n    ? option._value\n    : option.value\n}\n\nfunction onCompositionStart (e) {\n  e.target.composing = true;\n}\n\nfunction onCompositionEnd (e) {\n  e.target.composing = false;\n  trigger(e.target, 'input');\n}\n\nfunction trigger (el, type) {\n  var e = document.createEvent('HTMLEvents');\n  e.initEvent(type, true, true);\n  el.dispatchEvent(e);\n}\n\n/*  */\n\n// recursively search for possible transition defined inside the component root\nfunction locateNode (vnode) {\n  return vnode.componentInstance && (!vnode.data || !vnode.data.transition)\n    ? locateNode(vnode.componentInstance._vnode)\n    : vnode\n}\n\nvar show = {\n  bind: function bind (el, ref, vnode) {\n    var value = ref.value;\n\n    vnode = locateNode(vnode);\n    var transition = vnode.data && vnode.data.transition;\n    var originalDisplay = el.__vOriginalDisplay =\n      el.style.display === 'none' ? '' : el.style.display;\n    if (value && transition && !isIE9) {\n      vnode.data.show = true;\n      enter(vnode, function () {\n        el.style.display = originalDisplay;\n      });\n    } else {\n      el.style.display = value ? originalDisplay : 'none';\n    }\n  },\n\n  update: function update (el, ref, vnode) {\n    var value = ref.value;\n    var oldValue = ref.oldValue;\n\n    /* istanbul ignore if */\n    if (value === oldValue) { return }\n    vnode = locateNode(vnode);\n    var transition = vnode.data && vnode.data.transition;\n    if (transition && !isIE9) {\n      vnode.data.show = true;\n      if (value) {\n        enter(vnode, function () {\n          el.style.display = el.__vOriginalDisplay;\n        });\n      } else {\n        leave(vnode, function () {\n          el.style.display = 'none';\n        });\n      }\n    } else {\n      el.style.display = value ? el.__vOriginalDisplay : 'none';\n    }\n  },\n\n  unbind: function unbind (\n    el,\n    binding,\n    vnode,\n    oldVnode,\n    isDestroy\n  ) {\n    if (!isDestroy) {\n      el.style.display = el.__vOriginalDisplay;\n    }\n  }\n};\n\nvar platformDirectives = {\n  model: model,\n  show: show\n};\n\n/*  */\n\n// Provides transition support for a single element/component.\n// supports transition mode (out-in / in-out)\n\nvar transitionProps = {\n  name: String,\n  appear: Boolean,\n  css: Boolean,\n  mode: String,\n  type: String,\n  enterClass: String,\n  leaveClass: String,\n  enterToClass: String,\n  leaveToClass: String,\n  enterActiveClass: String,\n  leaveActiveClass: String,\n  appearClass: String,\n  appearActiveClass: String,\n  appearToClass: String\n};\n\n// in case the child is also an abstract component, e.g. <keep-alive>\n// we want to recursively retrieve the real component to be rendered\nfunction getRealChild (vnode) {\n  var compOptions = vnode && vnode.componentOptions;\n  if (compOptions && compOptions.Ctor.options.abstract) {\n    return getRealChild(getFirstComponentChild(compOptions.children))\n  } else {\n    return vnode\n  }\n}\n\nfunction extractTransitionData (comp) {\n  var data = {};\n  var options = comp.$options;\n  // props\n  for (var key in options.propsData) {\n    data[key] = comp[key];\n  }\n  // events.\n  // extract listeners and pass them directly to the transition methods\n  var listeners = options._parentListeners;\n  for (var key$1 in listeners) {\n    data[camelize(key$1)] = listeners[key$1].fn;\n  }\n  return data\n}\n\nfunction placeholder (h, rawChild) {\n  return /\\d-keep-alive$/.test(rawChild.tag)\n    ? h('keep-alive')\n    : null\n}\n\nfunction hasParentTransition (vnode) {\n  while ((vnode = vnode.parent)) {\n    if (vnode.data.transition) {\n      return true\n    }\n  }\n}\n\nfunction isSameChild (child, oldChild) {\n  return oldChild.key === child.key && oldChild.tag === child.tag\n}\n\nvar Transition = {\n  name: 'transition',\n  props: transitionProps,\n  abstract: true,\n\n  render: function render (h) {\n    var this$1 = this;\n\n    var children = this.$slots.default;\n    if (!children) {\n      return\n    }\n\n    // filter out text nodes (possible whitespaces)\n    children = children.filter(function (c) { return c.tag; });\n    /* istanbul ignore if */\n    if (!children.length) {\n      return\n    }\n\n    // warn multiple elements\n    if (false) {\n      warn(\n        '<transition> can only be used on a single element. Use ' +\n        '<transition-group> for lists.',\n        this.$parent\n      );\n    }\n\n    var mode = this.mode;\n\n    // warn invalid mode\n    if (false) {\n      warn(\n        'invalid <transition> mode: ' + mode,\n        this.$parent\n      );\n    }\n\n    var rawChild = children[0];\n\n    // if this is a component root node and the component's\n    // parent container node also has transition, skip.\n    if (hasParentTransition(this.$vnode)) {\n      return rawChild\n    }\n\n    // apply transition data to child\n    // use getRealChild() to ignore abstract components e.g. keep-alive\n    var child = getRealChild(rawChild);\n    /* istanbul ignore if */\n    if (!child) {\n      return rawChild\n    }\n\n    if (this._leaving) {\n      return placeholder(h, rawChild)\n    }\n\n    // ensure a key that is unique to the vnode type and to this transition\n    // component instance. This key will be used to remove pending leaving nodes\n    // during entering.\n    var id = \"__transition-\" + (this._uid) + \"-\";\n    var key = child.key = child.key == null\n      ? id + child.tag\n      : isPrimitive(child.key)\n        ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)\n        : child.key;\n    var data = (child.data || (child.data = {})).transition = extractTransitionData(this);\n    var oldRawChild = this._vnode;\n    var oldChild = getRealChild(oldRawChild);\n\n    // mark v-show\n    // so that the transition module can hand over the control to the directive\n    if (child.data.directives && child.data.directives.some(function (d) { return d.name === 'show'; })) {\n      child.data.show = true;\n    }\n\n    if (oldChild && oldChild.data && !isSameChild(child, oldChild)) {\n      // replace old child transition data with fresh one\n      // important for dynamic transitions!\n      var oldData = oldChild && (oldChild.data.transition = extend({}, data));\n      // handle transition mode\n      if (mode === 'out-in') {\n        // return placeholder node and queue update when leave finishes\n        this._leaving = true;\n        mergeVNodeHook(oldData, 'afterLeave', function () {\n          this$1._leaving = false;\n          this$1.$forceUpdate();\n        }, key);\n        return placeholder(h, rawChild)\n      } else if (mode === 'in-out') {\n        var delayedLeave;\n        var performLeave = function () { delayedLeave(); };\n        mergeVNodeHook(data, 'afterEnter', performLeave, key);\n        mergeVNodeHook(data, 'enterCancelled', performLeave, key);\n        mergeVNodeHook(oldData, 'delayLeave', function (leave) {\n          delayedLeave = leave;\n        }, key);\n      }\n    }\n\n    return rawChild\n  }\n};\n\n/*  */\n\n// Provides transition support for list items.\n// supports move transitions using the FLIP technique.\n\n// Because the vdom's children update algorithm is \"unstable\" - i.e.\n// it doesn't guarantee the relative positioning of removed elements,\n// we force transition-group to update its children into two passes:\n// in the first pass, we remove all nodes that need to be removed,\n// triggering their leaving transition; in the second pass, we insert/move\n// into the final disired state. This way in the second pass removed\n// nodes will remain where they should be.\n\nvar props = extend({\n  tag: String,\n  moveClass: String\n}, transitionProps);\n\ndelete props.mode;\n\nvar TransitionGroup = {\n  props: props,\n\n  render: function render (h) {\n    var tag = this.tag || this.$vnode.data.tag || 'span';\n    var map = Object.create(null);\n    var prevChildren = this.prevChildren = this.children;\n    var rawChildren = this.$slots.default || [];\n    var children = this.children = [];\n    var transitionData = extractTransitionData(this);\n\n    for (var i = 0; i < rawChildren.length; i++) {\n      var c = rawChildren[i];\n      if (c.tag) {\n        if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {\n          children.push(c);\n          map[c.key] = c\n          ;(c.data || (c.data = {})).transition = transitionData;\n        } else if (false) {\n          var opts = c.componentOptions;\n          var name = opts\n            ? (opts.Ctor.options.name || opts.tag)\n            : c.tag;\n          warn((\"<transition-group> children must be keyed: <\" + name + \">\"));\n        }\n      }\n    }\n\n    if (prevChildren) {\n      var kept = [];\n      var removed = [];\n      for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {\n        var c$1 = prevChildren[i$1];\n        c$1.data.transition = transitionData;\n        c$1.data.pos = c$1.elm.getBoundingClientRect();\n        if (map[c$1.key]) {\n          kept.push(c$1);\n        } else {\n          removed.push(c$1);\n        }\n      }\n      this.kept = h(tag, null, kept);\n      this.removed = removed;\n    }\n\n    return h(tag, null, children)\n  },\n\n  beforeUpdate: function beforeUpdate () {\n    // force removing pass\n    this.__patch__(\n      this._vnode,\n      this.kept,\n      false, // hydrating\n      true // removeOnly (!important, avoids unnecessary moves)\n    );\n    this._vnode = this.kept;\n  },\n\n  updated: function updated () {\n    var children = this.prevChildren;\n    var moveClass = this.moveClass || ((this.name || 'v') + '-move');\n    if (!children.length || !this.hasMove(children[0].elm, moveClass)) {\n      return\n    }\n\n    // we divide the work into three loops to avoid mixing DOM reads and writes\n    // in each iteration - which helps prevent layout thrashing.\n    children.forEach(callPendingCbs);\n    children.forEach(recordPosition);\n    children.forEach(applyTranslation);\n\n    // force reflow to put everything in position\n    var f = document.body.offsetHeight; // eslint-disable-line\n\n    children.forEach(function (c) {\n      if (c.data.moved) {\n        var el = c.elm;\n        var s = el.style;\n        addTransitionClass(el, moveClass);\n        s.transform = s.WebkitTransform = s.transitionDuration = '';\n        el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {\n          if (!e || /transform$/.test(e.propertyName)) {\n            el.removeEventListener(transitionEndEvent, cb);\n            el._moveCb = null;\n            removeTransitionClass(el, moveClass);\n          }\n        });\n      }\n    });\n  },\n\n  methods: {\n    hasMove: function hasMove (el, moveClass) {\n      /* istanbul ignore if */\n      if (!hasTransition) {\n        return false\n      }\n      if (this._hasMove != null) {\n        return this._hasMove\n      }\n      addTransitionClass(el, moveClass);\n      var info = getTransitionInfo(el);\n      removeTransitionClass(el, moveClass);\n      return (this._hasMove = info.hasTransform)\n    }\n  }\n};\n\nfunction callPendingCbs (c) {\n  /* istanbul ignore if */\n  if (c.elm._moveCb) {\n    c.elm._moveCb();\n  }\n  /* istanbul ignore if */\n  if (c.elm._enterCb) {\n    c.elm._enterCb();\n  }\n}\n\nfunction recordPosition (c) {\n  c.data.newPos = c.elm.getBoundingClientRect();\n}\n\nfunction applyTranslation (c) {\n  var oldPos = c.data.pos;\n  var newPos = c.data.newPos;\n  var dx = oldPos.left - newPos.left;\n  var dy = oldPos.top - newPos.top;\n  if (dx || dy) {\n    c.data.moved = true;\n    var s = c.elm.style;\n    s.transform = s.WebkitTransform = \"translate(\" + dx + \"px,\" + dy + \"px)\";\n    s.transitionDuration = '0s';\n  }\n}\n\nvar platformComponents = {\n  Transition: Transition,\n  TransitionGroup: TransitionGroup\n};\n\n/*  */\n\n// install platform specific utils\nVue$3.config.isUnknownElement = isUnknownElement;\nVue$3.config.isReservedTag = isReservedTag;\nVue$3.config.getTagNamespace = getTagNamespace;\nVue$3.config.mustUseProp = mustUseProp;\n\n// install platform runtime directives & components\nextend(Vue$3.options.directives, platformDirectives);\nextend(Vue$3.options.components, platformComponents);\n\n// install platform patch function\nVue$3.prototype.__patch__ = inBrowser ? patch$1 : noop;\n\n// wrap mount\nVue$3.prototype.$mount = function (\n  el,\n  hydrating\n) {\n  el = el && inBrowser ? query(el) : undefined;\n  return this._mount(el, hydrating)\n};\n\nif (false) {\n  console[console.info ? 'info' : 'log'](\n    \"You are running Vue in development mode.\\n\" +\n    \"Make sure to turn on production mode when deploying for production.\\n\" +\n    \"See more tips at https://vuejs.org/guide/deployment.html\"\n  );\n}\n\n// devtools global hook\n/* istanbul ignore next */\nsetTimeout(function () {\n  if (config.devtools) {\n    if (devtools) {\n      devtools.emit('init', Vue$3);\n    } else if (\n      false\n    ) {\n      console[console.info ? 'info' : 'log'](\n        'Download the Vue Devtools extension for a better development experience:\\n' +\n        'https://github.com/vuejs/vue-devtools'\n      );\n    }\n  }\n}, 0);\n\n/*  */\n\n// check whether current browser encodes a char inside attribute values\nfunction shouldDecode (content, encoded) {\n  var div = document.createElement('div');\n  div.innerHTML = \"<div a=\\\"\" + content + \"\\\">\";\n  return div.innerHTML.indexOf(encoded) > 0\n}\n\n// #3663\n// IE encodes newlines inside attribute values while other browsers don't\nvar shouldDecodeNewlines = inBrowser ? shouldDecode('\\n', '&#10;') : false;\n\n/*  */\n\nvar decoder;\n\nfunction decode (html) {\n  decoder = decoder || document.createElement('div');\n  decoder.innerHTML = html;\n  return decoder.textContent\n}\n\n/*  */\n\nvar isUnaryTag = makeMap(\n  'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +\n  'link,meta,param,source,track,wbr',\n  true\n);\n\n// Elements that you can, intentionally, leave open\n// (and which close themselves)\nvar canBeLeftOpenTag = makeMap(\n  'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source',\n  true\n);\n\n// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3\n// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content\nvar isNonPhrasingTag = makeMap(\n  'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +\n  'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +\n  'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +\n  'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +\n  'title,tr,track',\n  true\n);\n\n/**\n * Not type-checking this file because it's mostly vendor code.\n */\n\n/*!\n * HTML Parser By John Resig (ejohn.org)\n * Modified by Juriy \"kangax\" Zaytsev\n * Original code by Erik Arvidsson, Mozilla Public License\n * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js\n */\n\n// Regular Expressions for parsing tags and attributes\nvar singleAttrIdentifier = /([^\\s\"'<>/=]+)/;\nvar singleAttrAssign = /(?:=)/;\nvar singleAttrValues = [\n  // attr value double quotes\n  /\"([^\"]*)\"+/.source,\n  // attr value, single quotes\n  /'([^']*)'+/.source,\n  // attr value, no quotes\n  /([^\\s\"'=<>`]+)/.source\n];\nvar attribute = new RegExp(\n  '^\\\\s*' + singleAttrIdentifier.source +\n  '(?:\\\\s*(' + singleAttrAssign.source + ')' +\n  '\\\\s*(?:' + singleAttrValues.join('|') + '))?'\n);\n\n// could use https://www.w3.org/TR/1999/REC-xml-names-19990114/#NT-QName\n// but for Vue templates we can enforce a simple charset\nvar ncname = '[a-zA-Z_][\\\\w\\\\-\\\\.]*';\nvar qnameCapture = '((?:' + ncname + '\\\\:)?' + ncname + ')';\nvar startTagOpen = new RegExp('^<' + qnameCapture);\nvar startTagClose = /^\\s*(\\/?)>/;\nvar endTag = new RegExp('^<\\\\/' + qnameCapture + '[^>]*>');\nvar doctype = /^<!DOCTYPE [^>]+>/i;\nvar comment = /^<!--/;\nvar conditionalComment = /^<!\\[/;\n\nvar IS_REGEX_CAPTURING_BROKEN = false;\n'x'.replace(/x(.)?/g, function (m, g) {\n  IS_REGEX_CAPTURING_BROKEN = g === '';\n});\n\n// Special Elements (can contain anything)\nvar isScriptOrStyle = makeMap('script,style', true);\nvar reCache = {};\n\nvar ltRE = /&lt;/g;\nvar gtRE = /&gt;/g;\nvar nlRE = /&#10;/g;\nvar ampRE = /&amp;/g;\nvar quoteRE = /&quot;/g;\n\nfunction decodeAttr (value, shouldDecodeNewlines) {\n  if (shouldDecodeNewlines) {\n    value = value.replace(nlRE, '\\n');\n  }\n  return value\n    .replace(ltRE, '<')\n    .replace(gtRE, '>')\n    .replace(ampRE, '&')\n    .replace(quoteRE, '\"')\n}\n\nfunction parseHTML (html, options) {\n  var stack = [];\n  var expectHTML = options.expectHTML;\n  var isUnaryTag$$1 = options.isUnaryTag || no;\n  var index = 0;\n  var last, lastTag;\n  while (html) {\n    last = html;\n    // Make sure we're not in a script or style element\n    if (!lastTag || !isScriptOrStyle(lastTag)) {\n      var textEnd = html.indexOf('<');\n      if (textEnd === 0) {\n        // Comment:\n        if (comment.test(html)) {\n          var commentEnd = html.indexOf('-->');\n\n          if (commentEnd >= 0) {\n            advance(commentEnd + 3);\n            continue\n          }\n        }\n\n        // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment\n        if (conditionalComment.test(html)) {\n          var conditionalEnd = html.indexOf(']>');\n\n          if (conditionalEnd >= 0) {\n            advance(conditionalEnd + 2);\n            continue\n          }\n        }\n\n        // Doctype:\n        var doctypeMatch = html.match(doctype);\n        if (doctypeMatch) {\n          advance(doctypeMatch[0].length);\n          continue\n        }\n\n        // End tag:\n        var endTagMatch = html.match(endTag);\n        if (endTagMatch) {\n          var curIndex = index;\n          advance(endTagMatch[0].length);\n          parseEndTag(endTagMatch[1], curIndex, index);\n          continue\n        }\n\n        // Start tag:\n        var startTagMatch = parseStartTag();\n        if (startTagMatch) {\n          handleStartTag(startTagMatch);\n          continue\n        }\n      }\n\n      var text = (void 0), rest$1 = (void 0), next = (void 0);\n      if (textEnd > 0) {\n        rest$1 = html.slice(textEnd);\n        while (\n          !endTag.test(rest$1) &&\n          !startTagOpen.test(rest$1) &&\n          !comment.test(rest$1) &&\n          !conditionalComment.test(rest$1)\n        ) {\n          // < in plain text, be forgiving and treat it as text\n          next = rest$1.indexOf('<', 1);\n          if (next < 0) { break }\n          textEnd += next;\n          rest$1 = html.slice(textEnd);\n        }\n        text = html.substring(0, textEnd);\n        advance(textEnd);\n      }\n\n      if (textEnd < 0) {\n        text = html;\n        html = '';\n      }\n\n      if (options.chars && text) {\n        options.chars(text);\n      }\n    } else {\n      var stackedTag = lastTag.toLowerCase();\n      var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\\\s\\\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));\n      var endTagLength = 0;\n      var rest = html.replace(reStackedTag, function (all, text, endTag) {\n        endTagLength = endTag.length;\n        if (stackedTag !== 'script' && stackedTag !== 'style' && stackedTag !== 'noscript') {\n          text = text\n            .replace(/<!--([\\s\\S]*?)-->/g, '$1')\n            .replace(/<!\\[CDATA\\[([\\s\\S]*?)]]>/g, '$1');\n        }\n        if (options.chars) {\n          options.chars(text);\n        }\n        return ''\n      });\n      index += html.length - rest.length;\n      html = rest;\n      parseEndTag(stackedTag, index - endTagLength, index);\n    }\n\n    if (html === last && options.chars) {\n      options.chars(html);\n      break\n    }\n  }\n\n  // Clean up any remaining tags\n  parseEndTag();\n\n  function advance (n) {\n    index += n;\n    html = html.substring(n);\n  }\n\n  function parseStartTag () {\n    var start = html.match(startTagOpen);\n    if (start) {\n      var match = {\n        tagName: start[1],\n        attrs: [],\n        start: index\n      };\n      advance(start[0].length);\n      var end, attr;\n      while (!(end = html.match(startTagClose)) && (attr = html.match(attribute))) {\n        advance(attr[0].length);\n        match.attrs.push(attr);\n      }\n      if (end) {\n        match.unarySlash = end[1];\n        advance(end[0].length);\n        match.end = index;\n        return match\n      }\n    }\n  }\n\n  function handleStartTag (match) {\n    var tagName = match.tagName;\n    var unarySlash = match.unarySlash;\n\n    if (expectHTML) {\n      if (lastTag === 'p' && isNonPhrasingTag(tagName)) {\n        parseEndTag(lastTag);\n      }\n      if (canBeLeftOpenTag(tagName) && lastTag === tagName) {\n        parseEndTag(tagName);\n      }\n    }\n\n    var unary = isUnaryTag$$1(tagName) || tagName === 'html' && lastTag === 'head' || !!unarySlash;\n\n    var l = match.attrs.length;\n    var attrs = new Array(l);\n    for (var i = 0; i < l; i++) {\n      var args = match.attrs[i];\n      // hackish work around FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778\n      if (IS_REGEX_CAPTURING_BROKEN && args[0].indexOf('\"\"') === -1) {\n        if (args[3] === '') { delete args[3]; }\n        if (args[4] === '') { delete args[4]; }\n        if (args[5] === '') { delete args[5]; }\n      }\n      var value = args[3] || args[4] || args[5] || '';\n      attrs[i] = {\n        name: args[1],\n        value: decodeAttr(\n          value,\n          options.shouldDecodeNewlines\n        )\n      };\n    }\n\n    if (!unary) {\n      stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs });\n      lastTag = tagName;\n      unarySlash = '';\n    }\n\n    if (options.start) {\n      options.start(tagName, attrs, unary, match.start, match.end);\n    }\n  }\n\n  function parseEndTag (tagName, start, end) {\n    var pos, lowerCasedTagName;\n    if (start == null) { start = index; }\n    if (end == null) { end = index; }\n\n    if (tagName) {\n      lowerCasedTagName = tagName.toLowerCase();\n    }\n\n    // Find the closest opened tag of the same type\n    if (tagName) {\n      for (pos = stack.length - 1; pos >= 0; pos--) {\n        if (stack[pos].lowerCasedTag === lowerCasedTagName) {\n          break\n        }\n      }\n    } else {\n      // If no tag name is provided, clean shop\n      pos = 0;\n    }\n\n    if (pos >= 0) {\n      // Close all the open elements, up the stack\n      for (var i = stack.length - 1; i >= pos; i--) {\n        if (options.end) {\n          options.end(stack[i].tag, start, end);\n        }\n      }\n\n      // Remove the open elements from the stack\n      stack.length = pos;\n      lastTag = pos && stack[pos - 1].tag;\n    } else if (lowerCasedTagName === 'br') {\n      if (options.start) {\n        options.start(tagName, [], true, start, end);\n      }\n    } else if (lowerCasedTagName === 'p') {\n      if (options.start) {\n        options.start(tagName, [], false, start, end);\n      }\n      if (options.end) {\n        options.end(tagName, start, end);\n      }\n    }\n  }\n}\n\n/*  */\n\nfunction parseFilters (exp) {\n  var inSingle = false;\n  var inDouble = false;\n  var inTemplateString = false;\n  var inRegex = false;\n  var curly = 0;\n  var square = 0;\n  var paren = 0;\n  var lastFilterIndex = 0;\n  var c, prev, i, expression, filters;\n\n  for (i = 0; i < exp.length; i++) {\n    prev = c;\n    c = exp.charCodeAt(i);\n    if (inSingle) {\n      if (c === 0x27 && prev !== 0x5C) { inSingle = false; }\n    } else if (inDouble) {\n      if (c === 0x22 && prev !== 0x5C) { inDouble = false; }\n    } else if (inTemplateString) {\n      if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }\n    } else if (inRegex) {\n      if (c === 0x2f && prev !== 0x5C) { inRegex = false; }\n    } else if (\n      c === 0x7C && // pipe\n      exp.charCodeAt(i + 1) !== 0x7C &&\n      exp.charCodeAt(i - 1) !== 0x7C &&\n      !curly && !square && !paren\n    ) {\n      if (expression === undefined) {\n        // first filter, end of expression\n        lastFilterIndex = i + 1;\n        expression = exp.slice(0, i).trim();\n      } else {\n        pushFilter();\n      }\n    } else {\n      switch (c) {\n        case 0x22: inDouble = true; break         // \"\n        case 0x27: inSingle = true; break         // '\n        case 0x60: inTemplateString = true; break // `\n        case 0x28: paren++; break                 // (\n        case 0x29: paren--; break                 // )\n        case 0x5B: square++; break                // [\n        case 0x5D: square--; break                // ]\n        case 0x7B: curly++; break                 // {\n        case 0x7D: curly--; break                 // }\n      }\n      if (c === 0x2f) { // /\n        var j = i - 1;\n        var p = (void 0);\n        // find first non-whitespace prev char\n        for (; j >= 0; j--) {\n          p = exp.charAt(j);\n          if (p !== ' ') { break }\n        }\n        if (!p || !/[\\w$]/.test(p)) {\n          inRegex = true;\n        }\n      }\n    }\n  }\n\n  if (expression === undefined) {\n    expression = exp.slice(0, i).trim();\n  } else if (lastFilterIndex !== 0) {\n    pushFilter();\n  }\n\n  function pushFilter () {\n    (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());\n    lastFilterIndex = i + 1;\n  }\n\n  if (filters) {\n    for (i = 0; i < filters.length; i++) {\n      expression = wrapFilter(expression, filters[i]);\n    }\n  }\n\n  return expression\n}\n\nfunction wrapFilter (exp, filter) {\n  var i = filter.indexOf('(');\n  if (i < 0) {\n    // _f: resolveFilter\n    return (\"_f(\\\"\" + filter + \"\\\")(\" + exp + \")\")\n  } else {\n    var name = filter.slice(0, i);\n    var args = filter.slice(i + 1);\n    return (\"_f(\\\"\" + name + \"\\\")(\" + exp + \",\" + args)\n  }\n}\n\n/*  */\n\nvar defaultTagRE = /\\{\\{((?:.|\\n)+?)\\}\\}/g;\nvar regexEscapeRE = /[-.*+?^${}()|[\\]\\/\\\\]/g;\n\nvar buildRegex = cached(function (delimiters) {\n  var open = delimiters[0].replace(regexEscapeRE, '\\\\$&');\n  var close = delimiters[1].replace(regexEscapeRE, '\\\\$&');\n  return new RegExp(open + '((?:.|\\\\n)+?)' + close, 'g')\n});\n\nfunction parseText (\n  text,\n  delimiters\n) {\n  var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;\n  if (!tagRE.test(text)) {\n    return\n  }\n  var tokens = [];\n  var lastIndex = tagRE.lastIndex = 0;\n  var match, index;\n  while ((match = tagRE.exec(text))) {\n    index = match.index;\n    // push text token\n    if (index > lastIndex) {\n      tokens.push(JSON.stringify(text.slice(lastIndex, index)));\n    }\n    // tag token\n    var exp = parseFilters(match[1].trim());\n    tokens.push((\"_s(\" + exp + \")\"));\n    lastIndex = index + match[0].length;\n  }\n  if (lastIndex < text.length) {\n    tokens.push(JSON.stringify(text.slice(lastIndex)));\n  }\n  return tokens.join('+')\n}\n\n/*  */\n\nfunction baseWarn (msg) {\n  console.error((\"[Vue parser]: \" + msg));\n}\n\nfunction pluckModuleFunction (\n  modules,\n  key\n) {\n  return modules\n    ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })\n    : []\n}\n\nfunction addProp (el, name, value) {\n  (el.props || (el.props = [])).push({ name: name, value: value });\n}\n\nfunction addAttr (el, name, value) {\n  (el.attrs || (el.attrs = [])).push({ name: name, value: value });\n}\n\nfunction addDirective (\n  el,\n  name,\n  rawName,\n  value,\n  arg,\n  modifiers\n) {\n  (el.directives || (el.directives = [])).push({ name: name, rawName: rawName, value: value, arg: arg, modifiers: modifiers });\n}\n\nfunction addHandler (\n  el,\n  name,\n  value,\n  modifiers,\n  important\n) {\n  // check capture modifier\n  if (modifiers && modifiers.capture) {\n    delete modifiers.capture;\n    name = '!' + name; // mark the event as captured\n  }\n  if (modifiers && modifiers.once) {\n    delete modifiers.once;\n    name = '~' + name; // mark the event as once\n  }\n  var events;\n  if (modifiers && modifiers.native) {\n    delete modifiers.native;\n    events = el.nativeEvents || (el.nativeEvents = {});\n  } else {\n    events = el.events || (el.events = {});\n  }\n  var newHandler = { value: value, modifiers: modifiers };\n  var handlers = events[name];\n  /* istanbul ignore if */\n  if (Array.isArray(handlers)) {\n    important ? handlers.unshift(newHandler) : handlers.push(newHandler);\n  } else if (handlers) {\n    events[name] = important ? [newHandler, handlers] : [handlers, newHandler];\n  } else {\n    events[name] = newHandler;\n  }\n}\n\nfunction getBindingAttr (\n  el,\n  name,\n  getStatic\n) {\n  var dynamicValue =\n    getAndRemoveAttr(el, ':' + name) ||\n    getAndRemoveAttr(el, 'v-bind:' + name);\n  if (dynamicValue != null) {\n    return parseFilters(dynamicValue)\n  } else if (getStatic !== false) {\n    var staticValue = getAndRemoveAttr(el, name);\n    if (staticValue != null) {\n      return JSON.stringify(staticValue)\n    }\n  }\n}\n\nfunction getAndRemoveAttr (el, name) {\n  var val;\n  if ((val = el.attrsMap[name]) != null) {\n    var list = el.attrsList;\n    for (var i = 0, l = list.length; i < l; i++) {\n      if (list[i].name === name) {\n        list.splice(i, 1);\n        break\n      }\n    }\n  }\n  return val\n}\n\nvar len;\nvar str;\nvar chr;\nvar index$1;\nvar expressionPos;\nvar expressionEndPos;\n\n/**\n * parse directive model to do the array update transform. a[idx] = val => $$a.splice($$idx, 1, val)\n *\n * for loop possible cases:\n *\n * - test\n * - test[idx]\n * - test[test1[idx]]\n * - test[\"a\"][idx]\n * - xxx.test[a[a].test1[idx]]\n * - test.xxx.a[\"asa\"][test1[idx]]\n *\n */\n\nfunction parseModel (val) {\n  str = val;\n  len = str.length;\n  index$1 = expressionPos = expressionEndPos = 0;\n\n  if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {\n    return {\n      exp: val,\n      idx: null\n    }\n  }\n\n  while (!eof()) {\n    chr = next();\n    /* istanbul ignore if */\n    if (isStringStart(chr)) {\n      parseString(chr);\n    } else if (chr === 0x5B) {\n      parseBracket(chr);\n    }\n  }\n\n  return {\n    exp: val.substring(0, expressionPos),\n    idx: val.substring(expressionPos + 1, expressionEndPos)\n  }\n}\n\nfunction next () {\n  return str.charCodeAt(++index$1)\n}\n\nfunction eof () {\n  return index$1 >= len\n}\n\nfunction isStringStart (chr) {\n  return chr === 0x22 || chr === 0x27\n}\n\nfunction parseBracket (chr) {\n  var inBracket = 1;\n  expressionPos = index$1;\n  while (!eof()) {\n    chr = next();\n    if (isStringStart(chr)) {\n      parseString(chr);\n      continue\n    }\n    if (chr === 0x5B) { inBracket++; }\n    if (chr === 0x5D) { inBracket--; }\n    if (inBracket === 0) {\n      expressionEndPos = index$1;\n      break\n    }\n  }\n}\n\nfunction parseString (chr) {\n  var stringQuote = chr;\n  while (!eof()) {\n    chr = next();\n    if (chr === stringQuote) {\n      break\n    }\n  }\n}\n\n/*  */\n\nvar dirRE = /^v-|^@|^:/;\nvar forAliasRE = /(.*?)\\s+(?:in|of)\\s+(.*)/;\nvar forIteratorRE = /\\((\\{[^}]*\\}|[^,]*),([^,]*)(?:,([^,]*))?\\)/;\nvar bindRE = /^:|^v-bind:/;\nvar onRE = /^@|^v-on:/;\nvar argRE = /:(.*)$/;\nvar modifierRE = /\\.[^.]+/g;\n\nvar decodeHTMLCached = cached(decode);\n\n// configurable state\nvar warn$1;\nvar platformGetTagNamespace;\nvar platformMustUseProp;\nvar platformIsPreTag;\nvar preTransforms;\nvar transforms;\nvar postTransforms;\nvar delimiters;\n\n/**\n * Convert HTML string to AST.\n */\nfunction parse (\n  template,\n  options\n) {\n  warn$1 = options.warn || baseWarn;\n  platformGetTagNamespace = options.getTagNamespace || no;\n  platformMustUseProp = options.mustUseProp || no;\n  platformIsPreTag = options.isPreTag || no;\n  preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');\n  transforms = pluckModuleFunction(options.modules, 'transformNode');\n  postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');\n  delimiters = options.delimiters;\n  var stack = [];\n  var preserveWhitespace = options.preserveWhitespace !== false;\n  var root;\n  var currentParent;\n  var inVPre = false;\n  var inPre = false;\n  var warned = false;\n  parseHTML(template, {\n    expectHTML: options.expectHTML,\n    isUnaryTag: options.isUnaryTag,\n    shouldDecodeNewlines: options.shouldDecodeNewlines,\n    start: function start (tag, attrs, unary) {\n      // check namespace.\n      // inherit parent ns if there is one\n      var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);\n\n      // handle IE svg bug\n      /* istanbul ignore if */\n      if (isIE && ns === 'svg') {\n        attrs = guardIESVGBug(attrs);\n      }\n\n      var element = {\n        type: 1,\n        tag: tag,\n        attrsList: attrs,\n        attrsMap: makeAttrsMap(attrs),\n        parent: currentParent,\n        children: []\n      };\n      if (ns) {\n        element.ns = ns;\n      }\n\n      if (isForbiddenTag(element) && !isServerRendering()) {\n        element.forbidden = true;\n        \"production\" !== 'production' && warn$1(\n          'Templates should only be responsible for mapping the state to the ' +\n          'UI. Avoid placing tags with side-effects in your templates, such as ' +\n          \"<\" + tag + \">\" + ', as they will not be parsed.'\n        );\n      }\n\n      // apply pre-transforms\n      for (var i = 0; i < preTransforms.length; i++) {\n        preTransforms[i](element, options);\n      }\n\n      if (!inVPre) {\n        processPre(element);\n        if (element.pre) {\n          inVPre = true;\n        }\n      }\n      if (platformIsPreTag(element.tag)) {\n        inPre = true;\n      }\n      if (inVPre) {\n        processRawAttrs(element);\n      } else {\n        processFor(element);\n        processIf(element);\n        processOnce(element);\n        processKey(element);\n\n        // determine whether this is a plain element after\n        // removing structural attributes\n        element.plain = !element.key && !attrs.length;\n\n        processRef(element);\n        processSlot(element);\n        processComponent(element);\n        for (var i$1 = 0; i$1 < transforms.length; i$1++) {\n          transforms[i$1](element, options);\n        }\n        processAttrs(element);\n      }\n\n      function checkRootConstraints (el) {\n        if (false) {\n          if (el.tag === 'slot' || el.tag === 'template') {\n            warned = true;\n            warn$1(\n              \"Cannot use <\" + (el.tag) + \"> as component root element because it may \" +\n              'contain multiple nodes:\\n' + template\n            );\n          }\n          if (el.attrsMap.hasOwnProperty('v-for')) {\n            warned = true;\n            warn$1(\n              'Cannot use v-for on stateful component root element because ' +\n              'it renders multiple elements:\\n' + template\n            );\n          }\n        }\n      }\n\n      // tree management\n      if (!root) {\n        root = element;\n        checkRootConstraints(root);\n      } else if (!stack.length) {\n        // allow root elements with v-if, v-else-if and v-else\n        if (root.if && (element.elseif || element.else)) {\n          checkRootConstraints(element);\n          addIfCondition(root, {\n            exp: element.elseif,\n            block: element\n          });\n        } else if (false) {\n          warned = true;\n          warn$1(\n            \"Component template should contain exactly one root element:\" +\n            \"\\n\\n\" + template + \"\\n\\n\" +\n            \"If you are using v-if on multiple elements, \" +\n            \"use v-else-if to chain them instead.\"\n          );\n        }\n      }\n      if (currentParent && !element.forbidden) {\n        if (element.elseif || element.else) {\n          processIfConditions(element, currentParent);\n        } else if (element.slotScope) { // scoped slot\n          currentParent.plain = false;\n          var name = element.slotTarget || 'default';(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;\n        } else {\n          currentParent.children.push(element);\n          element.parent = currentParent;\n        }\n      }\n      if (!unary) {\n        currentParent = element;\n        stack.push(element);\n      }\n      // apply post-transforms\n      for (var i$2 = 0; i$2 < postTransforms.length; i$2++) {\n        postTransforms[i$2](element, options);\n      }\n    },\n\n    end: function end () {\n      // remove trailing whitespace\n      var element = stack[stack.length - 1];\n      var lastNode = element.children[element.children.length - 1];\n      if (lastNode && lastNode.type === 3 && lastNode.text === ' ') {\n        element.children.pop();\n      }\n      // pop stack\n      stack.length -= 1;\n      currentParent = stack[stack.length - 1];\n      // check pre state\n      if (element.pre) {\n        inVPre = false;\n      }\n      if (platformIsPreTag(element.tag)) {\n        inPre = false;\n      }\n    },\n\n    chars: function chars (text) {\n      if (!currentParent) {\n        if (false) {\n          warned = true;\n          warn$1(\n            'Component template requires a root element, rather than just text:\\n\\n' + template\n          );\n        }\n        return\n      }\n      // IE textarea placeholder bug\n      /* istanbul ignore if */\n      if (isIE &&\n          currentParent.tag === 'textarea' &&\n          currentParent.attrsMap.placeholder === text) {\n        return\n      }\n      var children = currentParent.children;\n      text = inPre || text.trim()\n        ? decodeHTMLCached(text)\n        // only preserve whitespace if its not right after a starting tag\n        : preserveWhitespace && children.length ? ' ' : '';\n      if (text) {\n        var expression;\n        if (!inVPre && text !== ' ' && (expression = parseText(text, delimiters))) {\n          children.push({\n            type: 2,\n            expression: expression,\n            text: text\n          });\n        } else if (text !== ' ' || children[children.length - 1].text !== ' ') {\n          currentParent.children.push({\n            type: 3,\n            text: text\n          });\n        }\n      }\n    }\n  });\n  return root\n}\n\nfunction processPre (el) {\n  if (getAndRemoveAttr(el, 'v-pre') != null) {\n    el.pre = true;\n  }\n}\n\nfunction processRawAttrs (el) {\n  var l = el.attrsList.length;\n  if (l) {\n    var attrs = el.attrs = new Array(l);\n    for (var i = 0; i < l; i++) {\n      attrs[i] = {\n        name: el.attrsList[i].name,\n        value: JSON.stringify(el.attrsList[i].value)\n      };\n    }\n  } else if (!el.pre) {\n    // non root node in pre blocks with no attributes\n    el.plain = true;\n  }\n}\n\nfunction processKey (el) {\n  var exp = getBindingAttr(el, 'key');\n  if (exp) {\n    if (false) {\n      warn$1(\"<template> cannot be keyed. Place the key on real elements instead.\");\n    }\n    el.key = exp;\n  }\n}\n\nfunction processRef (el) {\n  var ref = getBindingAttr(el, 'ref');\n  if (ref) {\n    el.ref = ref;\n    el.refInFor = checkInFor(el);\n  }\n}\n\nfunction processFor (el) {\n  var exp;\n  if ((exp = getAndRemoveAttr(el, 'v-for'))) {\n    var inMatch = exp.match(forAliasRE);\n    if (!inMatch) {\n      \"production\" !== 'production' && warn$1(\n        (\"Invalid v-for expression: \" + exp)\n      );\n      return\n    }\n    el.for = inMatch[2].trim();\n    var alias = inMatch[1].trim();\n    var iteratorMatch = alias.match(forIteratorRE);\n    if (iteratorMatch) {\n      el.alias = iteratorMatch[1].trim();\n      el.iterator1 = iteratorMatch[2].trim();\n      if (iteratorMatch[3]) {\n        el.iterator2 = iteratorMatch[3].trim();\n      }\n    } else {\n      el.alias = alias;\n    }\n  }\n}\n\nfunction processIf (el) {\n  var exp = getAndRemoveAttr(el, 'v-if');\n  if (exp) {\n    el.if = exp;\n    addIfCondition(el, {\n      exp: exp,\n      block: el\n    });\n  } else {\n    if (getAndRemoveAttr(el, 'v-else') != null) {\n      el.else = true;\n    }\n    var elseif = getAndRemoveAttr(el, 'v-else-if');\n    if (elseif) {\n      el.elseif = elseif;\n    }\n  }\n}\n\nfunction processIfConditions (el, parent) {\n  var prev = findPrevElement(parent.children);\n  if (prev && prev.if) {\n    addIfCondition(prev, {\n      exp: el.elseif,\n      block: el\n    });\n  } else if (false) {\n    warn$1(\n      \"v-\" + (el.elseif ? ('else-if=\"' + el.elseif + '\"') : 'else') + \" \" +\n      \"used on element <\" + (el.tag) + \"> without corresponding v-if.\"\n    );\n  }\n}\n\nfunction findPrevElement (children) {\n  var i = children.length;\n  while (i--) {\n    if (children[i].type === 1) {\n      return children[i]\n    } else {\n      if (false) {\n        warn$1(\n          \"text \\\"\" + (children[i].text.trim()) + \"\\\" between v-if and v-else(-if) \" +\n          \"will be ignored.\"\n        );\n      }\n      children.pop();\n    }\n  }\n}\n\nfunction addIfCondition (el, condition) {\n  if (!el.ifConditions) {\n    el.ifConditions = [];\n  }\n  el.ifConditions.push(condition);\n}\n\nfunction processOnce (el) {\n  var once = getAndRemoveAttr(el, 'v-once');\n  if (once != null) {\n    el.once = true;\n  }\n}\n\nfunction processSlot (el) {\n  if (el.tag === 'slot') {\n    el.slotName = getBindingAttr(el, 'name');\n    if (false) {\n      warn$1(\n        \"`key` does not work on <slot> because slots are abstract outlets \" +\n        \"and can possibly expand into multiple elements. \" +\n        \"Use the key on a wrapping element instead.\"\n      );\n    }\n  } else {\n    var slotTarget = getBindingAttr(el, 'slot');\n    if (slotTarget) {\n      el.slotTarget = slotTarget === '\"\"' ? '\"default\"' : slotTarget;\n    }\n    if (el.tag === 'template') {\n      el.slotScope = getAndRemoveAttr(el, 'scope');\n    }\n  }\n}\n\nfunction processComponent (el) {\n  var binding;\n  if ((binding = getBindingAttr(el, 'is'))) {\n    el.component = binding;\n  }\n  if (getAndRemoveAttr(el, 'inline-template') != null) {\n    el.inlineTemplate = true;\n  }\n}\n\nfunction processAttrs (el) {\n  var list = el.attrsList;\n  var i, l, name, rawName, value, arg, modifiers, isProp;\n  for (i = 0, l = list.length; i < l; i++) {\n    name = rawName = list[i].name;\n    value = list[i].value;\n    if (dirRE.test(name)) {\n      // mark element as dynamic\n      el.hasBindings = true;\n      // modifiers\n      modifiers = parseModifiers(name);\n      if (modifiers) {\n        name = name.replace(modifierRE, '');\n      }\n      if (bindRE.test(name)) { // v-bind\n        name = name.replace(bindRE, '');\n        value = parseFilters(value);\n        isProp = false;\n        if (modifiers) {\n          if (modifiers.prop) {\n            isProp = true;\n            name = camelize(name);\n            if (name === 'innerHtml') { name = 'innerHTML'; }\n          }\n          if (modifiers.camel) {\n            name = camelize(name);\n          }\n        }\n        if (isProp || platformMustUseProp(el.tag, el.attrsMap.type, name)) {\n          addProp(el, name, value);\n        } else {\n          addAttr(el, name, value);\n        }\n      } else if (onRE.test(name)) { // v-on\n        name = name.replace(onRE, '');\n        addHandler(el, name, value, modifiers);\n      } else { // normal directives\n        name = name.replace(dirRE, '');\n        // parse arg\n        var argMatch = name.match(argRE);\n        if (argMatch && (arg = argMatch[1])) {\n          name = name.slice(0, -(arg.length + 1));\n        }\n        addDirective(el, name, rawName, value, arg, modifiers);\n        if (false) {\n          checkForAliasModel(el, value);\n        }\n      }\n    } else {\n      // literal attribute\n      if (false) {\n        var expression = parseText(value, delimiters);\n        if (expression) {\n          warn$1(\n            name + \"=\\\"\" + value + \"\\\": \" +\n            'Interpolation inside attributes has been removed. ' +\n            'Use v-bind or the colon shorthand instead. For example, ' +\n            'instead of <div id=\"{{ val }}\">, use <div :id=\"val\">.'\n          );\n        }\n      }\n      addAttr(el, name, JSON.stringify(value));\n    }\n  }\n}\n\nfunction checkInFor (el) {\n  var parent = el;\n  while (parent) {\n    if (parent.for !== undefined) {\n      return true\n    }\n    parent = parent.parent;\n  }\n  return false\n}\n\nfunction parseModifiers (name) {\n  var match = name.match(modifierRE);\n  if (match) {\n    var ret = {};\n    match.forEach(function (m) { ret[m.slice(1)] = true; });\n    return ret\n  }\n}\n\nfunction makeAttrsMap (attrs) {\n  var map = {};\n  for (var i = 0, l = attrs.length; i < l; i++) {\n    if (false) {\n      warn$1('duplicate attribute: ' + attrs[i].name);\n    }\n    map[attrs[i].name] = attrs[i].value;\n  }\n  return map\n}\n\nfunction isForbiddenTag (el) {\n  return (\n    el.tag === 'style' ||\n    (el.tag === 'script' && (\n      !el.attrsMap.type ||\n      el.attrsMap.type === 'text/javascript'\n    ))\n  )\n}\n\nvar ieNSBug = /^xmlns:NS\\d+/;\nvar ieNSPrefix = /^NS\\d+:/;\n\n/* istanbul ignore next */\nfunction guardIESVGBug (attrs) {\n  var res = [];\n  for (var i = 0; i < attrs.length; i++) {\n    var attr = attrs[i];\n    if (!ieNSBug.test(attr.name)) {\n      attr.name = attr.name.replace(ieNSPrefix, '');\n      res.push(attr);\n    }\n  }\n  return res\n}\n\nfunction checkForAliasModel (el, value) {\n  var _el = el;\n  while (_el) {\n    if (_el.for && _el.alias === value) {\n      warn$1(\n        \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\">: \" +\n        \"You are binding v-model directly to a v-for iteration alias. \" +\n        \"This will not be able to modify the v-for source array because \" +\n        \"writing to the alias is like modifying a function local variable. \" +\n        \"Consider using an array of objects and use v-model on an object property instead.\"\n      );\n    }\n    _el = _el.parent;\n  }\n}\n\n/*  */\n\nvar isStaticKey;\nvar isPlatformReservedTag;\n\nvar genStaticKeysCached = cached(genStaticKeys$1);\n\n/**\n * Goal of the optimizer: walk the generated template AST tree\n * and detect sub-trees that are purely static, i.e. parts of\n * the DOM that never needs to change.\n *\n * Once we detect these sub-trees, we can:\n *\n * 1. Hoist them into constants, so that we no longer need to\n *    create fresh nodes for them on each re-render;\n * 2. Completely skip them in the patching process.\n */\nfunction optimize (root, options) {\n  if (!root) { return }\n  isStaticKey = genStaticKeysCached(options.staticKeys || '');\n  isPlatformReservedTag = options.isReservedTag || no;\n  // first pass: mark all non-static nodes.\n  markStatic(root);\n  // second pass: mark static roots.\n  markStaticRoots(root, false);\n}\n\nfunction genStaticKeys$1 (keys) {\n  return makeMap(\n    'type,tag,attrsList,attrsMap,plain,parent,children,attrs' +\n    (keys ? ',' + keys : '')\n  )\n}\n\nfunction markStatic (node) {\n  node.static = isStatic(node);\n  if (node.type === 1) {\n    // do not make component slot content static. this avoids\n    // 1. components not able to mutate slot nodes\n    // 2. static slot content fails for hot-reloading\n    if (\n      !isPlatformReservedTag(node.tag) &&\n      node.tag !== 'slot' &&\n      node.attrsMap['inline-template'] == null\n    ) {\n      return\n    }\n    for (var i = 0, l = node.children.length; i < l; i++) {\n      var child = node.children[i];\n      markStatic(child);\n      if (!child.static) {\n        node.static = false;\n      }\n    }\n  }\n}\n\nfunction markStaticRoots (node, isInFor) {\n  if (node.type === 1) {\n    if (node.static || node.once) {\n      node.staticInFor = isInFor;\n    }\n    // For a node to qualify as a static root, it should have children that\n    // are not just static text. Otherwise the cost of hoisting out will\n    // outweigh the benefits and it's better off to just always render it fresh.\n    if (node.static && node.children.length && !(\n      node.children.length === 1 &&\n      node.children[0].type === 3\n    )) {\n      node.staticRoot = true;\n      return\n    } else {\n      node.staticRoot = false;\n    }\n    if (node.children) {\n      for (var i = 0, l = node.children.length; i < l; i++) {\n        markStaticRoots(node.children[i], isInFor || !!node.for);\n      }\n    }\n    if (node.ifConditions) {\n      walkThroughConditionsBlocks(node.ifConditions, isInFor);\n    }\n  }\n}\n\nfunction walkThroughConditionsBlocks (conditionBlocks, isInFor) {\n  for (var i = 1, len = conditionBlocks.length; i < len; i++) {\n    markStaticRoots(conditionBlocks[i].block, isInFor);\n  }\n}\n\nfunction isStatic (node) {\n  if (node.type === 2) { // expression\n    return false\n  }\n  if (node.type === 3) { // text\n    return true\n  }\n  return !!(node.pre || (\n    !node.hasBindings && // no dynamic bindings\n    !node.if && !node.for && // not v-if or v-for or v-else\n    !isBuiltInTag(node.tag) && // not a built-in\n    isPlatformReservedTag(node.tag) && // not a component\n    !isDirectChildOfTemplateFor(node) &&\n    Object.keys(node).every(isStaticKey)\n  ))\n}\n\nfunction isDirectChildOfTemplateFor (node) {\n  while (node.parent) {\n    node = node.parent;\n    if (node.tag !== 'template') {\n      return false\n    }\n    if (node.for) {\n      return true\n    }\n  }\n  return false\n}\n\n/*  */\n\nvar fnExpRE = /^\\s*([\\w$_]+|\\([^)]*?\\))\\s*=>|^function\\s*\\(/;\nvar simplePathRE = /^\\s*[A-Za-z_$][\\w$]*(?:\\.[A-Za-z_$][\\w$]*|\\['.*?']|\\[\".*?\"]|\\[\\d+]|\\[[A-Za-z_$][\\w$]*])*\\s*$/;\n\n// keyCode aliases\nvar keyCodes = {\n  esc: 27,\n  tab: 9,\n  enter: 13,\n  space: 32,\n  up: 38,\n  left: 37,\n  right: 39,\n  down: 40,\n  'delete': [8, 46]\n};\n\nvar modifierCode = {\n  stop: '$event.stopPropagation();',\n  prevent: '$event.preventDefault();',\n  self: 'if($event.target !== $event.currentTarget)return;',\n  ctrl: 'if(!$event.ctrlKey)return;',\n  shift: 'if(!$event.shiftKey)return;',\n  alt: 'if(!$event.altKey)return;',\n  meta: 'if(!$event.metaKey)return;'\n};\n\nfunction genHandlers (events, native) {\n  var res = native ? 'nativeOn:{' : 'on:{';\n  for (var name in events) {\n    res += \"\\\"\" + name + \"\\\":\" + (genHandler(name, events[name])) + \",\";\n  }\n  return res.slice(0, -1) + '}'\n}\n\nfunction genHandler (\n  name,\n  handler\n) {\n  if (!handler) {\n    return 'function(){}'\n  } else if (Array.isArray(handler)) {\n    return (\"[\" + (handler.map(function (handler) { return genHandler(name, handler); }).join(',')) + \"]\")\n  } else if (!handler.modifiers) {\n    return fnExpRE.test(handler.value) || simplePathRE.test(handler.value)\n      ? handler.value\n      : (\"function($event){\" + (handler.value) + \"}\")\n  } else {\n    var code = '';\n    var keys = [];\n    for (var key in handler.modifiers) {\n      if (modifierCode[key]) {\n        code += modifierCode[key];\n      } else {\n        keys.push(key);\n      }\n    }\n    if (keys.length) {\n      code = genKeyFilter(keys) + code;\n    }\n    var handlerCode = simplePathRE.test(handler.value)\n      ? handler.value + '($event)'\n      : handler.value;\n    return 'function($event){' + code + handlerCode + '}'\n  }\n}\n\nfunction genKeyFilter (keys) {\n  return (\"if(\" + (keys.map(genFilterCode).join('&&')) + \")return;\")\n}\n\nfunction genFilterCode (key) {\n  var keyVal = parseInt(key, 10);\n  if (keyVal) {\n    return (\"$event.keyCode!==\" + keyVal)\n  }\n  var alias = keyCodes[key];\n  return (\"_k($event.keyCode,\" + (JSON.stringify(key)) + (alias ? ',' + JSON.stringify(alias) : '') + \")\")\n}\n\n/*  */\n\nfunction bind$2 (el, dir) {\n  el.wrapData = function (code) {\n    return (\"_b(\" + code + \",'\" + (el.tag) + \"',\" + (dir.value) + (dir.modifiers && dir.modifiers.prop ? ',true' : '') + \")\")\n  };\n}\n\n/*  */\n\nvar baseDirectives = {\n  bind: bind$2,\n  cloak: noop\n};\n\n/*  */\n\n// configurable state\nvar warn$2;\nvar transforms$1;\nvar dataGenFns;\nvar platformDirectives$1;\nvar isPlatformReservedTag$1;\nvar staticRenderFns;\nvar onceCount;\nvar currentOptions;\n\nfunction generate (\n  ast,\n  options\n) {\n  // save previous staticRenderFns so generate calls can be nested\n  var prevStaticRenderFns = staticRenderFns;\n  var currentStaticRenderFns = staticRenderFns = [];\n  var prevOnceCount = onceCount;\n  onceCount = 0;\n  currentOptions = options;\n  warn$2 = options.warn || baseWarn;\n  transforms$1 = pluckModuleFunction(options.modules, 'transformCode');\n  dataGenFns = pluckModuleFunction(options.modules, 'genData');\n  platformDirectives$1 = options.directives || {};\n  isPlatformReservedTag$1 = options.isReservedTag || no;\n  var code = ast ? genElement(ast) : '_c(\"div\")';\n  staticRenderFns = prevStaticRenderFns;\n  onceCount = prevOnceCount;\n  return {\n    render: (\"with(this){return \" + code + \"}\"),\n    staticRenderFns: currentStaticRenderFns\n  }\n}\n\nfunction genElement (el) {\n  if (el.staticRoot && !el.staticProcessed) {\n    return genStatic(el)\n  } else if (el.once && !el.onceProcessed) {\n    return genOnce(el)\n  } else if (el.for && !el.forProcessed) {\n    return genFor(el)\n  } else if (el.if && !el.ifProcessed) {\n    return genIf(el)\n  } else if (el.tag === 'template' && !el.slotTarget) {\n    return genChildren(el) || 'void 0'\n  } else if (el.tag === 'slot') {\n    return genSlot(el)\n  } else {\n    // component or element\n    var code;\n    if (el.component) {\n      code = genComponent(el.component, el);\n    } else {\n      var data = el.plain ? undefined : genData(el);\n\n      var children = el.inlineTemplate ? null : genChildren(el, true);\n      code = \"_c('\" + (el.tag) + \"'\" + (data ? (\",\" + data) : '') + (children ? (\",\" + children) : '') + \")\";\n    }\n    // module transforms\n    for (var i = 0; i < transforms$1.length; i++) {\n      code = transforms$1[i](el, code);\n    }\n    return code\n  }\n}\n\n// hoist static sub-trees out\nfunction genStatic (el) {\n  el.staticProcessed = true;\n  staticRenderFns.push((\"with(this){return \" + (genElement(el)) + \"}\"));\n  return (\"_m(\" + (staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + \")\")\n}\n\n// v-once\nfunction genOnce (el) {\n  el.onceProcessed = true;\n  if (el.if && !el.ifProcessed) {\n    return genIf(el)\n  } else if (el.staticInFor) {\n    var key = '';\n    var parent = el.parent;\n    while (parent) {\n      if (parent.for) {\n        key = parent.key;\n        break\n      }\n      parent = parent.parent;\n    }\n    if (!key) {\n      \"production\" !== 'production' && warn$2(\n        \"v-once can only be used inside v-for that is keyed. \"\n      );\n      return genElement(el)\n    }\n    return (\"_o(\" + (genElement(el)) + \",\" + (onceCount++) + (key ? (\",\" + key) : \"\") + \")\")\n  } else {\n    return genStatic(el)\n  }\n}\n\nfunction genIf (el) {\n  el.ifProcessed = true; // avoid recursion\n  return genIfConditions(el.ifConditions.slice())\n}\n\nfunction genIfConditions (conditions) {\n  if (!conditions.length) {\n    return '_e()'\n  }\n\n  var condition = conditions.shift();\n  if (condition.exp) {\n    return (\"(\" + (condition.exp) + \")?\" + (genTernaryExp(condition.block)) + \":\" + (genIfConditions(conditions)))\n  } else {\n    return (\"\" + (genTernaryExp(condition.block)))\n  }\n\n  // v-if with v-once should generate code like (a)?_m(0):_m(1)\n  function genTernaryExp (el) {\n    return el.once ? genOnce(el) : genElement(el)\n  }\n}\n\nfunction genFor (el) {\n  var exp = el.for;\n  var alias = el.alias;\n  var iterator1 = el.iterator1 ? (\",\" + (el.iterator1)) : '';\n  var iterator2 = el.iterator2 ? (\",\" + (el.iterator2)) : '';\n  el.forProcessed = true; // avoid recursion\n  return \"_l((\" + exp + \"),\" +\n    \"function(\" + alias + iterator1 + iterator2 + \"){\" +\n      \"return \" + (genElement(el)) +\n    '})'\n}\n\nfunction genData (el) {\n  var data = '{';\n\n  // directives first.\n  // directives may mutate the el's other properties before they are generated.\n  var dirs = genDirectives(el);\n  if (dirs) { data += dirs + ','; }\n\n  // key\n  if (el.key) {\n    data += \"key:\" + (el.key) + \",\";\n  }\n  // ref\n  if (el.ref) {\n    data += \"ref:\" + (el.ref) + \",\";\n  }\n  if (el.refInFor) {\n    data += \"refInFor:true,\";\n  }\n  // pre\n  if (el.pre) {\n    data += \"pre:true,\";\n  }\n  // record original tag name for components using \"is\" attribute\n  if (el.component) {\n    data += \"tag:\\\"\" + (el.tag) + \"\\\",\";\n  }\n  // module data generation functions\n  for (var i = 0; i < dataGenFns.length; i++) {\n    data += dataGenFns[i](el);\n  }\n  // attributes\n  if (el.attrs) {\n    data += \"attrs:{\" + (genProps(el.attrs)) + \"},\";\n  }\n  // DOM props\n  if (el.props) {\n    data += \"domProps:{\" + (genProps(el.props)) + \"},\";\n  }\n  // event handlers\n  if (el.events) {\n    data += (genHandlers(el.events)) + \",\";\n  }\n  if (el.nativeEvents) {\n    data += (genHandlers(el.nativeEvents, true)) + \",\";\n  }\n  // slot target\n  if (el.slotTarget) {\n    data += \"slot:\" + (el.slotTarget) + \",\";\n  }\n  // scoped slots\n  if (el.scopedSlots) {\n    data += (genScopedSlots(el.scopedSlots)) + \",\";\n  }\n  // inline-template\n  if (el.inlineTemplate) {\n    var inlineTemplate = genInlineTemplate(el);\n    if (inlineTemplate) {\n      data += inlineTemplate + \",\";\n    }\n  }\n  data = data.replace(/,$/, '') + '}';\n  // v-bind data wrap\n  if (el.wrapData) {\n    data = el.wrapData(data);\n  }\n  return data\n}\n\nfunction genDirectives (el) {\n  var dirs = el.directives;\n  if (!dirs) { return }\n  var res = 'directives:[';\n  var hasRuntime = false;\n  var i, l, dir, needRuntime;\n  for (i = 0, l = dirs.length; i < l; i++) {\n    dir = dirs[i];\n    needRuntime = true;\n    var gen = platformDirectives$1[dir.name] || baseDirectives[dir.name];\n    if (gen) {\n      // compile-time directive that manipulates AST.\n      // returns true if it also needs a runtime counterpart.\n      needRuntime = !!gen(el, dir, warn$2);\n    }\n    if (needRuntime) {\n      hasRuntime = true;\n      res += \"{name:\\\"\" + (dir.name) + \"\\\",rawName:\\\"\" + (dir.rawName) + \"\\\"\" + (dir.value ? (\",value:(\" + (dir.value) + \"),expression:\" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (\",arg:\\\"\" + (dir.arg) + \"\\\"\") : '') + (dir.modifiers ? (\",modifiers:\" + (JSON.stringify(dir.modifiers))) : '') + \"},\";\n    }\n  }\n  if (hasRuntime) {\n    return res.slice(0, -1) + ']'\n  }\n}\n\nfunction genInlineTemplate (el) {\n  var ast = el.children[0];\n  if (false) {\n    warn$2('Inline-template components must have exactly one child element.');\n  }\n  if (ast.type === 1) {\n    var inlineRenderFns = generate(ast, currentOptions);\n    return (\"inlineTemplate:{render:function(){\" + (inlineRenderFns.render) + \"},staticRenderFns:[\" + (inlineRenderFns.staticRenderFns.map(function (code) { return (\"function(){\" + code + \"}\"); }).join(',')) + \"]}\")\n  }\n}\n\nfunction genScopedSlots (slots) {\n  return (\"scopedSlots:{\" + (Object.keys(slots).map(function (key) { return genScopedSlot(key, slots[key]); }).join(',')) + \"}\")\n}\n\nfunction genScopedSlot (key, el) {\n  return key + \":function(\" + (String(el.attrsMap.scope)) + \"){\" +\n    \"return \" + (el.tag === 'template'\n      ? genChildren(el) || 'void 0'\n      : genElement(el)) + \"}\"\n}\n\nfunction genChildren (el, checkSkip) {\n  var children = el.children;\n  if (children.length) {\n    var el$1 = children[0];\n    // optimize single v-for\n    if (children.length === 1 &&\n        el$1.for &&\n        el$1.tag !== 'template' &&\n        el$1.tag !== 'slot') {\n      return genElement(el$1)\n    }\n    var normalizationType = getNormalizationType(children);\n    return (\"[\" + (children.map(genNode).join(',')) + \"]\" + (checkSkip\n        ? normalizationType ? (\",\" + normalizationType) : ''\n        : ''))\n  }\n}\n\n// determine the normalization needed for the children array.\n// 0: no normalization needed\n// 1: simple normalization needed (possible 1-level deep nested array)\n// 2: full normalization needed\nfunction getNormalizationType (children) {\n  var res = 0;\n  for (var i = 0; i < children.length; i++) {\n    var el = children[i];\n    if (el.type !== 1) {\n      continue\n    }\n    if (needsNormalization(el) ||\n        (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {\n      res = 2;\n      break\n    }\n    if (maybeComponent(el) ||\n        (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {\n      res = 1;\n    }\n  }\n  return res\n}\n\nfunction needsNormalization (el) {\n  return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'\n}\n\nfunction maybeComponent (el) {\n  return !isPlatformReservedTag$1(el.tag)\n}\n\nfunction genNode (node) {\n  if (node.type === 1) {\n    return genElement(node)\n  } else {\n    return genText(node)\n  }\n}\n\nfunction genText (text) {\n  return (\"_v(\" + (text.type === 2\n    ? text.expression // no need for () because already wrapped in _s()\n    : transformSpecialNewlines(JSON.stringify(text.text))) + \")\")\n}\n\nfunction genSlot (el) {\n  var slotName = el.slotName || '\"default\"';\n  var children = genChildren(el);\n  var res = \"_t(\" + slotName + (children ? (\",\" + children) : '');\n  var attrs = el.attrs && (\"{\" + (el.attrs.map(function (a) { return ((camelize(a.name)) + \":\" + (a.value)); }).join(',')) + \"}\");\n  var bind$$1 = el.attrsMap['v-bind'];\n  if ((attrs || bind$$1) && !children) {\n    res += \",null\";\n  }\n  if (attrs) {\n    res += \",\" + attrs;\n  }\n  if (bind$$1) {\n    res += (attrs ? '' : ',null') + \",\" + bind$$1;\n  }\n  return res + ')'\n}\n\n// componentName is el.component, take it as argument to shun flow's pessimistic refinement\nfunction genComponent (componentName, el) {\n  var children = el.inlineTemplate ? null : genChildren(el, true);\n  return (\"_c(\" + componentName + \",\" + (genData(el)) + (children ? (\",\" + children) : '') + \")\")\n}\n\nfunction genProps (props) {\n  var res = '';\n  for (var i = 0; i < props.length; i++) {\n    var prop = props[i];\n    res += \"\\\"\" + (prop.name) + \"\\\":\" + (transformSpecialNewlines(prop.value)) + \",\";\n  }\n  return res.slice(0, -1)\n}\n\n// #3895, #4268\nfunction transformSpecialNewlines (text) {\n  return text\n    .replace(/\\u2028/g, '\\\\u2028')\n    .replace(/\\u2029/g, '\\\\u2029')\n}\n\n/*  */\n\n/**\n * Compile a template.\n */\nfunction compile$1 (\n  template,\n  options\n) {\n  var ast = parse(template.trim(), options);\n  optimize(ast, options);\n  var code = generate(ast, options);\n  return {\n    ast: ast,\n    render: code.render,\n    staticRenderFns: code.staticRenderFns\n  }\n}\n\n/*  */\n\n// operators like typeof, instanceof and in are allowed\nvar prohibitedKeywordRE = new RegExp('\\\\b' + (\n  'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +\n  'super,throw,while,yield,delete,export,import,return,switch,default,' +\n  'extends,finally,continue,debugger,function,arguments'\n).split(',').join('\\\\b|\\\\b') + '\\\\b');\n// check valid identifier for v-for\nvar identRE = /[A-Za-z_$][\\w$]*/;\n// strip strings in expressions\nvar stripStringRE = /'(?:[^'\\\\]|\\\\.)*'|\"(?:[^\"\\\\]|\\\\.)*\"|`(?:[^`\\\\]|\\\\.)*\\$\\{|\\}(?:[^`\\\\]|\\\\.)*`|`(?:[^`\\\\]|\\\\.)*`/g;\n\n// detect problematic expressions in a template\nfunction detectErrors (ast) {\n  var errors = [];\n  if (ast) {\n    checkNode(ast, errors);\n  }\n  return errors\n}\n\nfunction checkNode (node, errors) {\n  if (node.type === 1) {\n    for (var name in node.attrsMap) {\n      if (dirRE.test(name)) {\n        var value = node.attrsMap[name];\n        if (value) {\n          if (name === 'v-for') {\n            checkFor(node, (\"v-for=\\\"\" + value + \"\\\"\"), errors);\n          } else {\n            checkExpression(value, (name + \"=\\\"\" + value + \"\\\"\"), errors);\n          }\n        }\n      }\n    }\n    if (node.children) {\n      for (var i = 0; i < node.children.length; i++) {\n        checkNode(node.children[i], errors);\n      }\n    }\n  } else if (node.type === 2) {\n    checkExpression(node.expression, node.text, errors);\n  }\n}\n\nfunction checkFor (node, text, errors) {\n  checkExpression(node.for || '', text, errors);\n  checkIdentifier(node.alias, 'v-for alias', text, errors);\n  checkIdentifier(node.iterator1, 'v-for iterator', text, errors);\n  checkIdentifier(node.iterator2, 'v-for iterator', text, errors);\n}\n\nfunction checkIdentifier (ident, type, text, errors) {\n  if (typeof ident === 'string' && !identRE.test(ident)) {\n    errors.push((\"- invalid \" + type + \" \\\"\" + ident + \"\\\" in expression: \" + text));\n  }\n}\n\nfunction checkExpression (exp, text, errors) {\n  try {\n    new Function((\"return \" + exp));\n  } catch (e) {\n    var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);\n    if (keywordMatch) {\n      errors.push(\n        \"- avoid using JavaScript keyword as property name: \" +\n        \"\\\"\" + (keywordMatch[0]) + \"\\\" in expression \" + text\n      );\n    } else {\n      errors.push((\"- invalid expression: \" + text));\n    }\n  }\n}\n\n/*  */\n\nfunction transformNode (el, options) {\n  var warn = options.warn || baseWarn;\n  var staticClass = getAndRemoveAttr(el, 'class');\n  if (false) {\n    var expression = parseText(staticClass, options.delimiters);\n    if (expression) {\n      warn(\n        \"class=\\\"\" + staticClass + \"\\\": \" +\n        'Interpolation inside attributes has been removed. ' +\n        'Use v-bind or the colon shorthand instead. For example, ' +\n        'instead of <div class=\"{{ val }}\">, use <div :class=\"val\">.'\n      );\n    }\n  }\n  if (staticClass) {\n    el.staticClass = JSON.stringify(staticClass);\n  }\n  var classBinding = getBindingAttr(el, 'class', false /* getStatic */);\n  if (classBinding) {\n    el.classBinding = classBinding;\n  }\n}\n\nfunction genData$1 (el) {\n  var data = '';\n  if (el.staticClass) {\n    data += \"staticClass:\" + (el.staticClass) + \",\";\n  }\n  if (el.classBinding) {\n    data += \"class:\" + (el.classBinding) + \",\";\n  }\n  return data\n}\n\nvar klass$1 = {\n  staticKeys: ['staticClass'],\n  transformNode: transformNode,\n  genData: genData$1\n};\n\n/*  */\n\nfunction transformNode$1 (el, options) {\n  var warn = options.warn || baseWarn;\n  var staticStyle = getAndRemoveAttr(el, 'style');\n  if (staticStyle) {\n    /* istanbul ignore if */\n    if (false) {\n      var expression = parseText(staticStyle, options.delimiters);\n      if (expression) {\n        warn(\n          \"style=\\\"\" + staticStyle + \"\\\": \" +\n          'Interpolation inside attributes has been removed. ' +\n          'Use v-bind or the colon shorthand instead. For example, ' +\n          'instead of <div style=\"{{ val }}\">, use <div :style=\"val\">.'\n        );\n      }\n    }\n    el.staticStyle = JSON.stringify(parseStyleText(staticStyle));\n  }\n\n  var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);\n  if (styleBinding) {\n    el.styleBinding = styleBinding;\n  }\n}\n\nfunction genData$2 (el) {\n  var data = '';\n  if (el.staticStyle) {\n    data += \"staticStyle:\" + (el.staticStyle) + \",\";\n  }\n  if (el.styleBinding) {\n    data += \"style:(\" + (el.styleBinding) + \"),\";\n  }\n  return data\n}\n\nvar style$1 = {\n  staticKeys: ['staticStyle'],\n  transformNode: transformNode$1,\n  genData: genData$2\n};\n\nvar modules$1 = [\n  klass$1,\n  style$1\n];\n\n/*  */\n\nvar warn$3;\n\nfunction model$1 (\n  el,\n  dir,\n  _warn\n) {\n  warn$3 = _warn;\n  var value = dir.value;\n  var modifiers = dir.modifiers;\n  var tag = el.tag;\n  var type = el.attrsMap.type;\n  if (false) {\n    var dynamicType = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];\n    if (tag === 'input' && dynamicType) {\n      warn$3(\n        \"<input :type=\\\"\" + dynamicType + \"\\\" v-model=\\\"\" + value + \"\\\">:\\n\" +\n        \"v-model does not support dynamic input types. Use v-if branches instead.\"\n      );\n    }\n  }\n  if (tag === 'select') {\n    genSelect(el, value, modifiers);\n  } else if (tag === 'input' && type === 'checkbox') {\n    genCheckboxModel(el, value, modifiers);\n  } else if (tag === 'input' && type === 'radio') {\n    genRadioModel(el, value, modifiers);\n  } else {\n    genDefaultModel(el, value, modifiers);\n  }\n  // ensure runtime directive metadata\n  return true\n}\n\nfunction genCheckboxModel (\n  el,\n  value,\n  modifiers\n) {\n  if (false) {\n    warn$3(\n      \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" checked>:\\n\" +\n      \"inline checked attributes will be ignored when using v-model. \" +\n      'Declare initial values in the component\\'s data option instead.'\n    );\n  }\n  var number = modifiers && modifiers.number;\n  var valueBinding = getBindingAttr(el, 'value') || 'null';\n  var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';\n  var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';\n  addProp(el, 'checked',\n    \"Array.isArray(\" + value + \")\" +\n      \"?_i(\" + value + \",\" + valueBinding + \")>-1\" + (\n        trueValueBinding === 'true'\n          ? (\":(\" + value + \")\")\n          : (\":_q(\" + value + \",\" + trueValueBinding + \")\")\n      )\n  );\n  addHandler(el, 'click',\n    \"var $$a=\" + value + \",\" +\n        '$$el=$event.target,' +\n        \"$$c=$$el.checked?(\" + trueValueBinding + \"):(\" + falseValueBinding + \");\" +\n    'if(Array.isArray($$a)){' +\n      \"var $$v=\" + (number ? '_n(' + valueBinding + ')' : valueBinding) + \",\" +\n          '$$i=_i($$a,$$v);' +\n      \"if($$c){$$i<0&&(\" + value + \"=$$a.concat($$v))}\" +\n      \"else{$$i>-1&&(\" + value + \"=$$a.slice(0,$$i).concat($$a.slice($$i+1)))}\" +\n    \"}else{\" + value + \"=$$c}\",\n    null, true\n  );\n}\n\nfunction genRadioModel (\n    el,\n    value,\n    modifiers\n) {\n  if (false) {\n    warn$3(\n      \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" checked>:\\n\" +\n      \"inline checked attributes will be ignored when using v-model. \" +\n      'Declare initial values in the component\\'s data option instead.'\n    );\n  }\n  var number = modifiers && modifiers.number;\n  var valueBinding = getBindingAttr(el, 'value') || 'null';\n  valueBinding = number ? (\"_n(\" + valueBinding + \")\") : valueBinding;\n  addProp(el, 'checked', (\"_q(\" + value + \",\" + valueBinding + \")\"));\n  addHandler(el, 'click', genAssignmentCode(value, valueBinding), null, true);\n}\n\nfunction genDefaultModel (\n  el,\n  value,\n  modifiers\n) {\n  if (false) {\n    if (el.tag === 'input' && el.attrsMap.value) {\n      warn$3(\n        \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" value=\\\"\" + (el.attrsMap.value) + \"\\\">:\\n\" +\n        'inline value attributes will be ignored when using v-model. ' +\n        'Declare initial values in the component\\'s data option instead.'\n      );\n    }\n    if (el.tag === 'textarea' && el.children.length) {\n      warn$3(\n        \"<textarea v-model=\\\"\" + value + \"\\\">:\\n\" +\n        'inline content inside <textarea> will be ignored when using v-model. ' +\n        'Declare initial values in the component\\'s data option instead.'\n      );\n    }\n  }\n\n  var type = el.attrsMap.type;\n  var ref = modifiers || {};\n  var lazy = ref.lazy;\n  var number = ref.number;\n  var trim = ref.trim;\n  var event = lazy || (isIE && type === 'range') ? 'change' : 'input';\n  var needCompositionGuard = !lazy && type !== 'range';\n  var isNative = el.tag === 'input' || el.tag === 'textarea';\n\n  var valueExpression = isNative\n    ? (\"$event.target.value\" + (trim ? '.trim()' : ''))\n    : trim ? \"(typeof $event === 'string' ? $event.trim() : $event)\" : \"$event\";\n  valueExpression = number || type === 'number'\n    ? (\"_n(\" + valueExpression + \")\")\n    : valueExpression;\n\n  var code = genAssignmentCode(value, valueExpression);\n  if (isNative && needCompositionGuard) {\n    code = \"if($event.target.composing)return;\" + code;\n  }\n\n  // inputs with type=\"file\" are read only and setting the input's\n  // value will throw an error.\n  if (false) {\n    warn$3(\n      \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" type=\\\"file\\\">:\\n\" +\n      \"File inputs are read only. Use a v-on:change listener instead.\"\n    );\n  }\n\n  addProp(el, 'value', isNative ? (\"_s(\" + value + \")\") : (\"(\" + value + \")\"));\n  addHandler(el, event, code, null, true);\n  if (trim || number || type === 'number') {\n    addHandler(el, 'blur', '$forceUpdate()');\n  }\n}\n\nfunction genSelect (\n    el,\n    value,\n    modifiers\n) {\n  if (false) {\n    el.children.some(checkOptionWarning);\n  }\n\n  var number = modifiers && modifiers.number;\n  var assignment = \"Array.prototype.filter\" +\n    \".call($event.target.options,function(o){return o.selected})\" +\n    \".map(function(o){var val = \\\"_value\\\" in o ? o._value : o.value;\" +\n    \"return \" + (number ? '_n(val)' : 'val') + \"})\" +\n    (el.attrsMap.multiple == null ? '[0]' : '');\n\n  var code = genAssignmentCode(value, assignment);\n  addHandler(el, 'change', code, null, true);\n}\n\nfunction checkOptionWarning (option) {\n  if (option.type === 1 &&\n    option.tag === 'option' &&\n    option.attrsMap.selected != null) {\n    warn$3(\n      \"<select v-model=\\\"\" + (option.parent.attrsMap['v-model']) + \"\\\">:\\n\" +\n      'inline selected attributes on <option> will be ignored when using v-model. ' +\n      'Declare initial values in the component\\'s data option instead.'\n    );\n    return true\n  }\n  return false\n}\n\nfunction genAssignmentCode (value, assignment) {\n  var modelRs = parseModel(value);\n  if (modelRs.idx === null) {\n    return (value + \"=\" + assignment)\n  } else {\n    return \"var $$exp = \" + (modelRs.exp) + \", $$idx = \" + (modelRs.idx) + \";\" +\n      \"if (!Array.isArray($$exp)){\" +\n        value + \"=\" + assignment + \"}\" +\n      \"else{$$exp.splice($$idx, 1, \" + assignment + \")}\"\n  }\n}\n\n/*  */\n\nfunction text (el, dir) {\n  if (dir.value) {\n    addProp(el, 'textContent', (\"_s(\" + (dir.value) + \")\"));\n  }\n}\n\n/*  */\n\nfunction html (el, dir) {\n  if (dir.value) {\n    addProp(el, 'innerHTML', (\"_s(\" + (dir.value) + \")\"));\n  }\n}\n\nvar directives$1 = {\n  model: model$1,\n  text: text,\n  html: html\n};\n\n/*  */\n\nvar cache = Object.create(null);\n\nvar baseOptions = {\n  expectHTML: true,\n  modules: modules$1,\n  staticKeys: genStaticKeys(modules$1),\n  directives: directives$1,\n  isReservedTag: isReservedTag,\n  isUnaryTag: isUnaryTag,\n  mustUseProp: mustUseProp,\n  getTagNamespace: getTagNamespace,\n  isPreTag: isPreTag\n};\n\nfunction compile$$1 (\n  template,\n  options\n) {\n  options = options\n    ? extend(extend({}, baseOptions), options)\n    : baseOptions;\n  return compile$1(template, options)\n}\n\nfunction compileToFunctions (\n  template,\n  options,\n  vm\n) {\n  var _warn = (options && options.warn) || warn;\n  // detect possible CSP restriction\n  /* istanbul ignore if */\n  if (false) {\n    try {\n      new Function('return 1');\n    } catch (e) {\n      if (e.toString().match(/unsafe-eval|CSP/)) {\n        _warn(\n          'It seems you are using the standalone build of Vue.js in an ' +\n          'environment with Content Security Policy that prohibits unsafe-eval. ' +\n          'The template compiler cannot work in this environment. Consider ' +\n          'relaxing the policy to allow unsafe-eval or pre-compiling your ' +\n          'templates into render functions.'\n        );\n      }\n    }\n  }\n  var key = options && options.delimiters\n    ? String(options.delimiters) + template\n    : template;\n  if (cache[key]) {\n    return cache[key]\n  }\n  var res = {};\n  var compiled = compile$$1(template, options);\n  res.render = makeFunction(compiled.render);\n  var l = compiled.staticRenderFns.length;\n  res.staticRenderFns = new Array(l);\n  for (var i = 0; i < l; i++) {\n    res.staticRenderFns[i] = makeFunction(compiled.staticRenderFns[i]);\n  }\n  if (false) {\n    if (res.render === noop || res.staticRenderFns.some(function (fn) { return fn === noop; })) {\n      _warn(\n        \"failed to compile template:\\n\\n\" + template + \"\\n\\n\" +\n        detectErrors(compiled.ast).join('\\n') +\n        '\\n\\n',\n        vm\n      );\n    }\n  }\n  return (cache[key] = res)\n}\n\nfunction makeFunction (code) {\n  try {\n    return new Function(code)\n  } catch (e) {\n    return noop\n  }\n}\n\n/*  */\n\nvar idToTemplate = cached(function (id) {\n  var el = query(id);\n  return el && el.innerHTML\n});\n\nvar mount = Vue$3.prototype.$mount;\nVue$3.prototype.$mount = function (\n  el,\n  hydrating\n) {\n  el = el && query(el);\n\n  /* istanbul ignore if */\n  if (el === document.body || el === document.documentElement) {\n    \"production\" !== 'production' && warn(\n      \"Do not mount Vue to <html> or <body> - mount to normal elements instead.\"\n    );\n    return this\n  }\n\n  var options = this.$options;\n  // resolve template/el and convert to render function\n  if (!options.render) {\n    var template = options.template;\n    if (template) {\n      if (typeof template === 'string') {\n        if (template.charAt(0) === '#') {\n          template = idToTemplate(template);\n          /* istanbul ignore if */\n          if (false) {\n            warn(\n              (\"Template element not found or is empty: \" + (options.template)),\n              this\n            );\n          }\n        }\n      } else if (template.nodeType) {\n        template = template.innerHTML;\n      } else {\n        if (false) {\n          warn('invalid template option:' + template, this);\n        }\n        return this\n      }\n    } else if (el) {\n      template = getOuterHTML(el);\n    }\n    if (template) {\n      var ref = compileToFunctions(template, {\n        warn: warn,\n        shouldDecodeNewlines: shouldDecodeNewlines,\n        delimiters: options.delimiters\n      }, this);\n      var render = ref.render;\n      var staticRenderFns = ref.staticRenderFns;\n      options.render = render;\n      options.staticRenderFns = staticRenderFns;\n    }\n  }\n  return mount.call(this, el, hydrating)\n};\n\n/**\n * Get outerHTML of elements, taking care\n * of SVG elements in IE as well.\n */\nfunction getOuterHTML (el) {\n  if (el.outerHTML) {\n    return el.outerHTML\n  } else {\n    var container = document.createElement('div');\n    container.appendChild(el.cloneNode(true));\n    return container.innerHTML\n  }\n}\n\nVue$3.compile = compileToFunctions;\n\nmodule.exports = Vue$3;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(34)))\n\n/***/ }),\n/* 23 */\n/***/ (function(module, exports) {\n\nvar toString = {}.toString;\n\nmodule.exports = function(it){\n  return toString.call(it).slice(8, -1);\n};\n\n/***/ }),\n/* 24 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// optional / simple context binding\nvar aFunction = __webpack_require__(62);\nmodule.exports = function(fn, that, length){\n  aFunction(fn);\n  if(that === undefined)return fn;\n  switch(length){\n    case 1: return function(a){\n      return fn.call(that, a);\n    };\n    case 2: return function(a, b){\n      return fn.call(that, a, b);\n    };\n    case 3: return function(a, b, c){\n      return fn.call(that, a, b, c);\n    };\n  }\n  return function(/* ...args */){\n    return fn.apply(that, arguments);\n  };\n};\n\n/***/ }),\n/* 25 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar isObject = __webpack_require__(16)\n  , document = __webpack_require__(5).document\n  // in old IE typeof document.createElement is 'object'\n  , is = isObject(document) && isObject(document.createElement);\nmodule.exports = function(it){\n  return is ? document.createElement(it) : {};\n};\n\n/***/ }),\n/* 26 */\n/***/ (function(module, exports) {\n\n// IE 8- don't enum bug keys\nmodule.exports = (\n  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'\n).split(',');\n\n/***/ }),\n/* 27 */\n/***/ (function(module, exports) {\n\nmodule.exports = function(exec){\n  try {\n    return !!exec();\n  } catch(e){\n    return true;\n  }\n};\n\n/***/ }),\n/* 28 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar def = __webpack_require__(6).f\n  , has = __webpack_require__(11)\n  , TAG = __webpack_require__(2)('toStringTag');\n\nmodule.exports = function(it, tag, stat){\n  if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});\n};\n\n/***/ }),\n/* 29 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar global = __webpack_require__(5)\n  , SHARED = '__core-js_shared__'\n  , store  = global[SHARED] || (global[SHARED] = {});\nmodule.exports = function(key){\n  return store[key] || (store[key] = {});\n};\n\n/***/ }),\n/* 30 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// to indexed object, toObject with fallback for non-array-like ES3 strings\nvar IObject = __webpack_require__(68)\n  , defined = __webpack_require__(14);\nmodule.exports = function(it){\n  return IObject(defined(it));\n};\n\n/***/ }),\n/* 31 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// 7.1.15 ToLength\nvar toInteger = __webpack_require__(20)\n  , min       = Math.min;\nmodule.exports = function(it){\n  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991\n};\n\n/***/ }),\n/* 32 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// 7.1.13 ToObject(argument)\nvar defined = __webpack_require__(14);\nmodule.exports = function(it){\n  return Object(defined(it));\n};\n\n/***/ }),\n/* 33 */\n/***/ (function(module, exports) {\n\nvar id = 0\n  , px = Math.random();\nmodule.exports = function(key){\n  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));\n};\n\n/***/ }),\n/* 34 */\n/***/ (function(module, exports) {\n\nvar g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n/***/ }),\n/* 35 */,\n/* 36 */,\n/* 37 */,\n/* 38 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/*!\n * vue-resource v1.2.1\n * https://github.com/pagekit/vue-resource\n * Released under the MIT License.\n */\n\n\n\n/**\n * Promises/A+ polyfill v1.1.4 (https://github.com/bramstein/promis)\n */\n\nvar RESOLVED = 0;\nvar REJECTED = 1;\nvar PENDING  = 2;\n\nfunction Promise$1(executor) {\n\n    this.state = PENDING;\n    this.value = undefined;\n    this.deferred = [];\n\n    var promise = this;\n\n    try {\n        executor(function (x) {\n            promise.resolve(x);\n        }, function (r) {\n            promise.reject(r);\n        });\n    } catch (e) {\n        promise.reject(e);\n    }\n}\n\nPromise$1.reject = function (r) {\n    return new Promise$1(function (resolve, reject) {\n        reject(r);\n    });\n};\n\nPromise$1.resolve = function (x) {\n    return new Promise$1(function (resolve, reject) {\n        resolve(x);\n    });\n};\n\nPromise$1.all = function all(iterable) {\n    return new Promise$1(function (resolve, reject) {\n        var count = 0, result = [];\n\n        if (iterable.length === 0) {\n            resolve(result);\n        }\n\n        function resolver(i) {\n            return function (x) {\n                result[i] = x;\n                count += 1;\n\n                if (count === iterable.length) {\n                    resolve(result);\n                }\n            };\n        }\n\n        for (var i = 0; i < iterable.length; i += 1) {\n            Promise$1.resolve(iterable[i]).then(resolver(i), reject);\n        }\n    });\n};\n\nPromise$1.race = function race(iterable) {\n    return new Promise$1(function (resolve, reject) {\n        for (var i = 0; i < iterable.length; i += 1) {\n            Promise$1.resolve(iterable[i]).then(resolve, reject);\n        }\n    });\n};\n\nvar p$1 = Promise$1.prototype;\n\np$1.resolve = function resolve(x) {\n    var promise = this;\n\n    if (promise.state === PENDING) {\n        if (x === promise) {\n            throw new TypeError('Promise settled with itself.');\n        }\n\n        var called = false;\n\n        try {\n            var then = x && x['then'];\n\n            if (x !== null && typeof x === 'object' && typeof then === 'function') {\n                then.call(x, function (x) {\n                    if (!called) {\n                        promise.resolve(x);\n                    }\n                    called = true;\n\n                }, function (r) {\n                    if (!called) {\n                        promise.reject(r);\n                    }\n                    called = true;\n                });\n                return;\n            }\n        } catch (e) {\n            if (!called) {\n                promise.reject(e);\n            }\n            return;\n        }\n\n        promise.state = RESOLVED;\n        promise.value = x;\n        promise.notify();\n    }\n};\n\np$1.reject = function reject(reason) {\n    var promise = this;\n\n    if (promise.state === PENDING) {\n        if (reason === promise) {\n            throw new TypeError('Promise settled with itself.');\n        }\n\n        promise.state = REJECTED;\n        promise.value = reason;\n        promise.notify();\n    }\n};\n\np$1.notify = function notify() {\n    var promise = this;\n\n    nextTick(function () {\n        if (promise.state !== PENDING) {\n            while (promise.deferred.length) {\n                var deferred = promise.deferred.shift(),\n                    onResolved = deferred[0],\n                    onRejected = deferred[1],\n                    resolve = deferred[2],\n                    reject = deferred[3];\n\n                try {\n                    if (promise.state === RESOLVED) {\n                        if (typeof onResolved === 'function') {\n                            resolve(onResolved.call(undefined, promise.value));\n                        } else {\n                            resolve(promise.value);\n                        }\n                    } else if (promise.state === REJECTED) {\n                        if (typeof onRejected === 'function') {\n                            resolve(onRejected.call(undefined, promise.value));\n                        } else {\n                            reject(promise.value);\n                        }\n                    }\n                } catch (e) {\n                    reject(e);\n                }\n            }\n        }\n    });\n};\n\np$1.then = function then(onResolved, onRejected) {\n    var promise = this;\n\n    return new Promise$1(function (resolve, reject) {\n        promise.deferred.push([onResolved, onRejected, resolve, reject]);\n        promise.notify();\n    });\n};\n\np$1.catch = function (onRejected) {\n    return this.then(undefined, onRejected);\n};\n\n/**\n * Promise adapter.\n */\n\nif (typeof Promise === 'undefined') {\n    window.Promise = Promise$1;\n}\n\nfunction PromiseObj(executor, context) {\n\n    if (executor instanceof Promise) {\n        this.promise = executor;\n    } else {\n        this.promise = new Promise(executor.bind(context));\n    }\n\n    this.context = context;\n}\n\nPromiseObj.all = function (iterable, context) {\n    return new PromiseObj(Promise.all(iterable), context);\n};\n\nPromiseObj.resolve = function (value, context) {\n    return new PromiseObj(Promise.resolve(value), context);\n};\n\nPromiseObj.reject = function (reason, context) {\n    return new PromiseObj(Promise.reject(reason), context);\n};\n\nPromiseObj.race = function (iterable, context) {\n    return new PromiseObj(Promise.race(iterable), context);\n};\n\nvar p = PromiseObj.prototype;\n\np.bind = function (context) {\n    this.context = context;\n    return this;\n};\n\np.then = function (fulfilled, rejected) {\n\n    if (fulfilled && fulfilled.bind && this.context) {\n        fulfilled = fulfilled.bind(this.context);\n    }\n\n    if (rejected && rejected.bind && this.context) {\n        rejected = rejected.bind(this.context);\n    }\n\n    return new PromiseObj(this.promise.then(fulfilled, rejected), this.context);\n};\n\np.catch = function (rejected) {\n\n    if (rejected && rejected.bind && this.context) {\n        rejected = rejected.bind(this.context);\n    }\n\n    return new PromiseObj(this.promise.catch(rejected), this.context);\n};\n\np.finally = function (callback) {\n\n    return this.then(function (value) {\n            callback.call(this);\n            return value;\n        }, function (reason) {\n            callback.call(this);\n            return Promise.reject(reason);\n        }\n    );\n};\n\n/**\n * Utility functions.\n */\n\nvar ref = {};\nvar hasOwnProperty = ref.hasOwnProperty;\n\nvar ref$1 = [];\nvar slice = ref$1.slice;\nvar debug = false;\nvar ntick;\n\nvar inBrowser = typeof window !== 'undefined';\n\nvar Util = function (ref) {\n    var config = ref.config;\n    var nextTick = ref.nextTick;\n\n    ntick = nextTick;\n    debug = config.debug || !config.silent;\n};\n\nfunction warn(msg) {\n    if (typeof console !== 'undefined' && debug) {\n        console.warn('[VueResource warn]: ' + msg);\n    }\n}\n\nfunction error(msg) {\n    if (typeof console !== 'undefined') {\n        console.error(msg);\n    }\n}\n\nfunction nextTick(cb, ctx) {\n    return ntick(cb, ctx);\n}\n\nfunction trim(str) {\n    return str ? str.replace(/^\\s*|\\s*$/g, '') : '';\n}\n\nfunction toLower(str) {\n    return str ? str.toLowerCase() : '';\n}\n\nfunction toUpper(str) {\n    return str ? str.toUpperCase() : '';\n}\n\nvar isArray = Array.isArray;\n\nfunction isString(val) {\n    return typeof val === 'string';\n}\n\n\n\nfunction isFunction(val) {\n    return typeof val === 'function';\n}\n\nfunction isObject(obj) {\n    return obj !== null && typeof obj === 'object';\n}\n\nfunction isPlainObject(obj) {\n    return isObject(obj) && Object.getPrototypeOf(obj) == Object.prototype;\n}\n\nfunction isBlob(obj) {\n    return typeof Blob !== 'undefined' && obj instanceof Blob;\n}\n\nfunction isFormData(obj) {\n    return typeof FormData !== 'undefined' && obj instanceof FormData;\n}\n\nfunction when(value, fulfilled, rejected) {\n\n    var promise = PromiseObj.resolve(value);\n\n    if (arguments.length < 2) {\n        return promise;\n    }\n\n    return promise.then(fulfilled, rejected);\n}\n\nfunction options(fn, obj, opts) {\n\n    opts = opts || {};\n\n    if (isFunction(opts)) {\n        opts = opts.call(obj);\n    }\n\n    return merge(fn.bind({$vm: obj, $options: opts}), fn, {$options: opts});\n}\n\nfunction each(obj, iterator) {\n\n    var i, key;\n\n    if (isArray(obj)) {\n        for (i = 0; i < obj.length; i++) {\n            iterator.call(obj[i], obj[i], i);\n        }\n    } else if (isObject(obj)) {\n        for (key in obj) {\n            if (hasOwnProperty.call(obj, key)) {\n                iterator.call(obj[key], obj[key], key);\n            }\n        }\n    }\n\n    return obj;\n}\n\nvar assign = Object.assign || _assign;\n\nfunction merge(target) {\n\n    var args = slice.call(arguments, 1);\n\n    args.forEach(function (source) {\n        _merge(target, source, true);\n    });\n\n    return target;\n}\n\nfunction defaults(target) {\n\n    var args = slice.call(arguments, 1);\n\n    args.forEach(function (source) {\n\n        for (var key in source) {\n            if (target[key] === undefined) {\n                target[key] = source[key];\n            }\n        }\n\n    });\n\n    return target;\n}\n\nfunction _assign(target) {\n\n    var args = slice.call(arguments, 1);\n\n    args.forEach(function (source) {\n        _merge(target, source);\n    });\n\n    return target;\n}\n\nfunction _merge(target, source, deep) {\n    for (var key in source) {\n        if (deep && (isPlainObject(source[key]) || isArray(source[key]))) {\n            if (isPlainObject(source[key]) && !isPlainObject(target[key])) {\n                target[key] = {};\n            }\n            if (isArray(source[key]) && !isArray(target[key])) {\n                target[key] = [];\n            }\n            _merge(target[key], source[key], deep);\n        } else if (source[key] !== undefined) {\n            target[key] = source[key];\n        }\n    }\n}\n\n/**\n * Root Prefix Transform.\n */\n\nvar root = function (options$$1, next) {\n\n    var url = next(options$$1);\n\n    if (isString(options$$1.root) && !url.match(/^(https?:)?\\//)) {\n        url = options$$1.root + '/' + url;\n    }\n\n    return url;\n};\n\n/**\n * Query Parameter Transform.\n */\n\nvar query = function (options$$1, next) {\n\n    var urlParams = Object.keys(Url.options.params), query = {}, url = next(options$$1);\n\n    each(options$$1.params, function (value, key) {\n        if (urlParams.indexOf(key) === -1) {\n            query[key] = value;\n        }\n    });\n\n    query = Url.params(query);\n\n    if (query) {\n        url += (url.indexOf('?') == -1 ? '?' : '&') + query;\n    }\n\n    return url;\n};\n\n/**\n * URL Template v2.0.6 (https://github.com/bramstein/url-template)\n */\n\nfunction expand(url, params, variables) {\n\n    var tmpl = parse(url), expanded = tmpl.expand(params);\n\n    if (variables) {\n        variables.push.apply(variables, tmpl.vars);\n    }\n\n    return expanded;\n}\n\nfunction parse(template) {\n\n    var operators = ['+', '#', '.', '/', ';', '?', '&'], variables = [];\n\n    return {\n        vars: variables,\n        expand: function expand(context) {\n            return template.replace(/\\{([^\\{\\}]+)\\}|([^\\{\\}]+)/g, function (_, expression, literal) {\n                if (expression) {\n\n                    var operator = null, values = [];\n\n                    if (operators.indexOf(expression.charAt(0)) !== -1) {\n                        operator = expression.charAt(0);\n                        expression = expression.substr(1);\n                    }\n\n                    expression.split(/,/g).forEach(function (variable) {\n                        var tmp = /([^:\\*]*)(?::(\\d+)|(\\*))?/.exec(variable);\n                        values.push.apply(values, getValues(context, operator, tmp[1], tmp[2] || tmp[3]));\n                        variables.push(tmp[1]);\n                    });\n\n                    if (operator && operator !== '+') {\n\n                        var separator = ',';\n\n                        if (operator === '?') {\n                            separator = '&';\n                        } else if (operator !== '#') {\n                            separator = operator;\n                        }\n\n                        return (values.length !== 0 ? operator : '') + values.join(separator);\n                    } else {\n                        return values.join(',');\n                    }\n\n                } else {\n                    return encodeReserved(literal);\n                }\n            });\n        }\n    };\n}\n\nfunction getValues(context, operator, key, modifier) {\n\n    var value = context[key], result = [];\n\n    if (isDefined(value) && value !== '') {\n        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {\n            value = value.toString();\n\n            if (modifier && modifier !== '*') {\n                value = value.substring(0, parseInt(modifier, 10));\n            }\n\n            result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : null));\n        } else {\n            if (modifier === '*') {\n                if (Array.isArray(value)) {\n                    value.filter(isDefined).forEach(function (value) {\n                        result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : null));\n                    });\n                } else {\n                    Object.keys(value).forEach(function (k) {\n                        if (isDefined(value[k])) {\n                            result.push(encodeValue(operator, value[k], k));\n                        }\n                    });\n                }\n            } else {\n                var tmp = [];\n\n                if (Array.isArray(value)) {\n                    value.filter(isDefined).forEach(function (value) {\n                        tmp.push(encodeValue(operator, value));\n                    });\n                } else {\n                    Object.keys(value).forEach(function (k) {\n                        if (isDefined(value[k])) {\n                            tmp.push(encodeURIComponent(k));\n                            tmp.push(encodeValue(operator, value[k].toString()));\n                        }\n                    });\n                }\n\n                if (isKeyOperator(operator)) {\n                    result.push(encodeURIComponent(key) + '=' + tmp.join(','));\n                } else if (tmp.length !== 0) {\n                    result.push(tmp.join(','));\n                }\n            }\n        }\n    } else {\n        if (operator === ';') {\n            result.push(encodeURIComponent(key));\n        } else if (value === '' && (operator === '&' || operator === '?')) {\n            result.push(encodeURIComponent(key) + '=');\n        } else if (value === '') {\n            result.push('');\n        }\n    }\n\n    return result;\n}\n\nfunction isDefined(value) {\n    return value !== undefined && value !== null;\n}\n\nfunction isKeyOperator(operator) {\n    return operator === ';' || operator === '&' || operator === '?';\n}\n\nfunction encodeValue(operator, value, key) {\n\n    value = (operator === '+' || operator === '#') ? encodeReserved(value) : encodeURIComponent(value);\n\n    if (key) {\n        return encodeURIComponent(key) + '=' + value;\n    } else {\n        return value;\n    }\n}\n\nfunction encodeReserved(str) {\n    return str.split(/(%[0-9A-Fa-f]{2})/g).map(function (part) {\n        if (!/%[0-9A-Fa-f]/.test(part)) {\n            part = encodeURI(part);\n        }\n        return part;\n    }).join('');\n}\n\n/**\n * URL Template (RFC 6570) Transform.\n */\n\nvar template = function (options) {\n\n    var variables = [], url = expand(options.url, options.params, variables);\n\n    variables.forEach(function (key) {\n        delete options.params[key];\n    });\n\n    return url;\n};\n\n/**\n * Service for URL templating.\n */\n\nfunction Url(url, params) {\n\n    var self = this || {}, options$$1 = url, transform;\n\n    if (isString(url)) {\n        options$$1 = {url: url, params: params};\n    }\n\n    options$$1 = merge({}, Url.options, self.$options, options$$1);\n\n    Url.transforms.forEach(function (handler) {\n        transform = factory(handler, transform, self.$vm);\n    });\n\n    return transform(options$$1);\n}\n\n/**\n * Url options.\n */\n\nUrl.options = {\n    url: '',\n    root: null,\n    params: {}\n};\n\n/**\n * Url transforms.\n */\n\nUrl.transforms = [template, query, root];\n\n/**\n * Encodes a Url parameter string.\n *\n * @param {Object} obj\n */\n\nUrl.params = function (obj) {\n\n    var params = [], escape = encodeURIComponent;\n\n    params.add = function (key, value) {\n\n        if (isFunction(value)) {\n            value = value();\n        }\n\n        if (value === null) {\n            value = '';\n        }\n\n        this.push(escape(key) + '=' + escape(value));\n    };\n\n    serialize(params, obj);\n\n    return params.join('&').replace(/%20/g, '+');\n};\n\n/**\n * Parse a URL and return its components.\n *\n * @param {String} url\n */\n\nUrl.parse = function (url) {\n\n    var el = document.createElement('a');\n\n    if (document.documentMode) {\n        el.href = url;\n        url = el.href;\n    }\n\n    el.href = url;\n\n    return {\n        href: el.href,\n        protocol: el.protocol ? el.protocol.replace(/:$/, '') : '',\n        port: el.port,\n        host: el.host,\n        hostname: el.hostname,\n        pathname: el.pathname.charAt(0) === '/' ? el.pathname : '/' + el.pathname,\n        search: el.search ? el.search.replace(/^\\?/, '') : '',\n        hash: el.hash ? el.hash.replace(/^#/, '') : ''\n    };\n};\n\nfunction factory(handler, next, vm) {\n    return function (options$$1) {\n        return handler.call(vm, options$$1, next);\n    };\n}\n\nfunction serialize(params, obj, scope) {\n\n    var array = isArray(obj), plain = isPlainObject(obj), hash;\n\n    each(obj, function (value, key) {\n\n        hash = isObject(value) || isArray(value);\n\n        if (scope) {\n            key = scope + '[' + (plain || hash ? key : '') + ']';\n        }\n\n        if (!scope && array) {\n            params.add(value.name, value.value);\n        } else if (hash) {\n            serialize(params, value, key);\n        } else {\n            params.add(key, value);\n        }\n    });\n}\n\n/**\n * XDomain client (Internet Explorer).\n */\n\nvar xdrClient = function (request) {\n    return new PromiseObj(function (resolve) {\n\n        var xdr = new XDomainRequest(), handler = function (ref) {\n            var type = ref.type;\n\n\n            var status = 0;\n\n            if (type === 'load') {\n                status = 200;\n            } else if (type === 'error') {\n                status = 500;\n            }\n\n            resolve(request.respondWith(xdr.responseText, {status: status}));\n        };\n\n        request.abort = function () { return xdr.abort(); };\n\n        xdr.open(request.method, request.getUrl());\n\n        if (request.timeout) {\n            xdr.timeout = request.timeout;\n        }\n\n        xdr.onload = handler;\n        xdr.onabort = handler;\n        xdr.onerror = handler;\n        xdr.ontimeout = handler;\n        xdr.onprogress = function () {};\n        xdr.send(request.getBody());\n    });\n};\n\n/**\n * CORS Interceptor.\n */\n\nvar SUPPORTS_CORS = inBrowser && 'withCredentials' in new XMLHttpRequest();\n\nvar cors = function (request, next) {\n\n    if (inBrowser) {\n\n        var orgUrl = Url.parse(location.href);\n        var reqUrl = Url.parse(request.getUrl());\n\n        if (reqUrl.protocol !== orgUrl.protocol || reqUrl.host !== orgUrl.host) {\n\n            request.crossOrigin = true;\n            request.emulateHTTP = false;\n\n            if (!SUPPORTS_CORS) {\n                request.client = xdrClient;\n            }\n        }\n    }\n\n    next();\n};\n\n/**\n * Body Interceptor.\n */\n\nvar body = function (request, next) {\n\n    if (isFormData(request.body)) {\n\n        request.headers.delete('Content-Type');\n\n    } else if (isObject(request.body) || isArray(request.body)) {\n\n        if (request.emulateJSON) {\n            request.body = Url.params(request.body);\n            request.headers.set('Content-Type', 'application/x-www-form-urlencoded');\n        } else {\n            request.body = JSON.stringify(request.body);\n        }\n    }\n\n    next(function (response) {\n\n        Object.defineProperty(response, 'data', {\n\n            get: function get() {\n                return this.body;\n            },\n\n            set: function set(body) {\n                this.body = body;\n            }\n\n        });\n\n        return response.bodyText ? when(response.text(), function (text) {\n\n            var type = response.headers.get('Content-Type') || '';\n\n            if (type.indexOf('application/json') === 0 || isJson(text)) {\n\n                try {\n                    response.body = JSON.parse(text);\n                } catch (e) {\n                    response.body = null;\n                }\n\n            } else {\n                response.body = text;\n            }\n\n            return response;\n\n        }) : response;\n\n    });\n};\n\nfunction isJson(str) {\n\n    var start = str.match(/^\\[|^\\{(?!\\{)/), end = {'[': /]$/, '{': /}$/};\n\n    return start && end[start[0]].test(str);\n}\n\n/**\n * JSONP client (Browser).\n */\n\nvar jsonpClient = function (request) {\n    return new PromiseObj(function (resolve) {\n\n        var name = request.jsonp || 'callback', callback = request.jsonpCallback || '_jsonp' + Math.random().toString(36).substr(2), body = null, handler, script;\n\n        handler = function (ref) {\n            var type = ref.type;\n\n\n            var status = 0;\n\n            if (type === 'load' && body !== null) {\n                status = 200;\n            } else if (type === 'error') {\n                status = 500;\n            }\n\n            if (status && window[callback]) {\n                delete window[callback];\n                document.body.removeChild(script);\n            }\n\n            resolve(request.respondWith(body, {status: status}));\n        };\n\n        window[callback] = function (result) {\n            body = JSON.stringify(result);\n        };\n\n        request.abort = function () {\n            handler({type: 'abort'});\n        };\n\n        request.params[name] = callback;\n\n        if (request.timeout) {\n            setTimeout(request.abort, request.timeout);\n        }\n\n        script = document.createElement('script');\n        script.src = request.getUrl();\n        script.type = 'text/javascript';\n        script.async = true;\n        script.onload = handler;\n        script.onerror = handler;\n\n        document.body.appendChild(script);\n    });\n};\n\n/**\n * JSONP Interceptor.\n */\n\nvar jsonp = function (request, next) {\n\n    if (request.method == 'JSONP') {\n        request.client = jsonpClient;\n    }\n\n    next();\n};\n\n/**\n * Before Interceptor.\n */\n\nvar before = function (request, next) {\n\n    if (isFunction(request.before)) {\n        request.before.call(this, request);\n    }\n\n    next();\n};\n\n/**\n * HTTP method override Interceptor.\n */\n\nvar method = function (request, next) {\n\n    if (request.emulateHTTP && /^(PUT|PATCH|DELETE)$/i.test(request.method)) {\n        request.headers.set('X-HTTP-Method-Override', request.method);\n        request.method = 'POST';\n    }\n\n    next();\n};\n\n/**\n * Header Interceptor.\n */\n\nvar header = function (request, next) {\n\n    var headers = assign({}, Http.headers.common,\n        !request.crossOrigin ? Http.headers.custom : {},\n        Http.headers[toLower(request.method)]\n    );\n\n    each(headers, function (value, name) {\n        if (!request.headers.has(name)) {\n            request.headers.set(name, value);\n        }\n    });\n\n    next();\n};\n\n/**\n * XMLHttp client (Browser).\n */\n\nvar SUPPORTS_BLOB = typeof Blob !== 'undefined' && typeof FileReader !== 'undefined';\n\nvar xhrClient = function (request) {\n    return new PromiseObj(function (resolve) {\n\n        var xhr = new XMLHttpRequest(), handler = function (event) {\n\n            var response = request.respondWith(\n                'response' in xhr ? xhr.response : xhr.responseText, {\n                    status: xhr.status === 1223 ? 204 : xhr.status, // IE9 status bug\n                    statusText: xhr.status === 1223 ? 'No Content' : trim(xhr.statusText)\n                }\n            );\n\n            each(trim(xhr.getAllResponseHeaders()).split('\\n'), function (row) {\n                response.headers.append(row.slice(0, row.indexOf(':')), row.slice(row.indexOf(':') + 1));\n            });\n\n            resolve(response);\n        };\n\n        request.abort = function () { return xhr.abort(); };\n\n        if (request.progress) {\n            if (request.method === 'GET') {\n                xhr.addEventListener('progress', request.progress);\n            } else if (/^(POST|PUT)$/i.test(request.method)) {\n                xhr.upload.addEventListener('progress', request.progress);\n            }\n        }\n\n        xhr.open(request.method, request.getUrl(), true);\n\n        if (request.timeout) {\n            xhr.timeout = request.timeout;\n        }\n\n        if (request.credentials === true) {\n            xhr.withCredentials = true;\n        }\n\n        if (!request.crossOrigin) {\n            request.headers.set('X-Requested-With', 'XMLHttpRequest');\n        }\n\n        if ('responseType' in xhr && SUPPORTS_BLOB) {\n            xhr.responseType = 'blob';\n        }\n\n        request.headers.forEach(function (value, name) {\n            xhr.setRequestHeader(name, value);\n        });\n\n        xhr.onload = handler;\n        xhr.onabort = handler;\n        xhr.onerror = handler;\n        xhr.ontimeout = handler;\n        xhr.send(request.getBody());\n    });\n};\n\n/**\n * Http client (Node).\n */\n\nvar nodeClient = function (request) {\n\n    var client = __webpack_require__(135);\n\n    return new PromiseObj(function (resolve) {\n\n        var url = request.getUrl();\n        var body = request.getBody();\n        var method = request.method;\n        var headers = {}, handler;\n\n        request.headers.forEach(function (value, name) {\n            headers[name] = value;\n        });\n\n        client(url, {body: body, method: method, headers: headers}).then(handler = function (resp) {\n\n            var response = request.respondWith(resp.body, {\n                    status: resp.statusCode,\n                    statusText: trim(resp.statusMessage)\n                }\n            );\n\n            each(resp.headers, function (value, name) {\n                response.headers.set(name, value);\n            });\n\n            resolve(response);\n\n        }, function (error$$1) { return handler(error$$1.response); });\n    });\n};\n\n/**\n * Base client.\n */\n\nvar Client = function (context) {\n\n    var reqHandlers = [sendRequest], resHandlers = [], handler;\n\n    if (!isObject(context)) {\n        context = null;\n    }\n\n    function Client(request) {\n        return new PromiseObj(function (resolve) {\n\n            function exec() {\n\n                handler = reqHandlers.pop();\n\n                if (isFunction(handler)) {\n                    handler.call(context, request, next);\n                } else {\n                    warn((\"Invalid interceptor of type \" + (typeof handler) + \", must be a function\"));\n                    next();\n                }\n            }\n\n            function next(response) {\n\n                if (isFunction(response)) {\n\n                    resHandlers.unshift(response);\n\n                } else if (isObject(response)) {\n\n                    resHandlers.forEach(function (handler) {\n                        response = when(response, function (response) {\n                            return handler.call(context, response) || response;\n                        });\n                    });\n\n                    when(response, resolve);\n\n                    return;\n                }\n\n                exec();\n            }\n\n            exec();\n\n        }, context);\n    }\n\n    Client.use = function (handler) {\n        reqHandlers.push(handler);\n    };\n\n    return Client;\n};\n\nfunction sendRequest(request, resolve) {\n\n    var client = request.client || (inBrowser ? xhrClient : nodeClient);\n\n    resolve(client(request));\n}\n\n/**\n * HTTP Headers.\n */\n\nvar Headers = function Headers(headers) {\n    var this$1 = this;\n\n\n    this.map = {};\n\n    each(headers, function (value, name) { return this$1.append(name, value); });\n};\n\nHeaders.prototype.has = function has (name) {\n    return getName(this.map, name) !== null;\n};\n\nHeaders.prototype.get = function get (name) {\n\n    var list = this.map[getName(this.map, name)];\n\n    return list ? list.join() : null;\n};\n\nHeaders.prototype.getAll = function getAll (name) {\n    return this.map[getName(this.map, name)] || [];\n};\n\nHeaders.prototype.set = function set (name, value) {\n    this.map[normalizeName(getName(this.map, name) || name)] = [trim(value)];\n};\n\nHeaders.prototype.append = function append (name, value){\n\n    var list = this.map[getName(this.map, name)];\n\n    if (list) {\n        list.push(trim(value));\n    } else {\n        this.set(name, value);\n    }\n};\n\nHeaders.prototype.delete = function delete$1 (name){\n    delete this.map[getName(this.map, name)];\n};\n\nHeaders.prototype.deleteAll = function deleteAll (){\n    this.map = {};\n};\n\nHeaders.prototype.forEach = function forEach (callback, thisArg) {\n        var this$1 = this;\n\n    each(this.map, function (list, name) {\n        each(list, function (value) { return callback.call(thisArg, value, name, this$1); });\n    });\n};\n\nfunction getName(map, name) {\n    return Object.keys(map).reduce(function (prev, curr) {\n        return toLower(name) === toLower(curr) ? curr : prev;\n    }, null);\n}\n\nfunction normalizeName(name) {\n\n    if (/[^a-z0-9\\-#$%&'*+.\\^_`|~]/i.test(name)) {\n        throw new TypeError('Invalid character in header field name');\n    }\n\n    return trim(name);\n}\n\n/**\n * HTTP Response.\n */\n\nvar Response = function Response(body, ref) {\n    var url = ref.url;\n    var headers = ref.headers;\n    var status = ref.status;\n    var statusText = ref.statusText;\n\n\n    this.url = url;\n    this.ok = status >= 200 && status < 300;\n    this.status = status || 0;\n    this.statusText = statusText || '';\n    this.headers = new Headers(headers);\n    this.body = body;\n\n    if (isString(body)) {\n\n        this.bodyText = body;\n\n    } else if (isBlob(body)) {\n\n        this.bodyBlob = body;\n\n        if (isBlobText(body)) {\n            this.bodyText = blobText(body);\n        }\n    }\n};\n\nResponse.prototype.blob = function blob () {\n    return when(this.bodyBlob);\n};\n\nResponse.prototype.text = function text () {\n    return when(this.bodyText);\n};\n\nResponse.prototype.json = function json () {\n    return when(this.text(), function (text) { return JSON.parse(text); });\n};\n\nfunction blobText(body) {\n    return new PromiseObj(function (resolve) {\n\n        var reader = new FileReader();\n\n        reader.readAsText(body);\n        reader.onload = function () {\n            resolve(reader.result);\n        };\n\n    });\n}\n\nfunction isBlobText(body) {\n    return body.type.indexOf('text') === 0 || body.type.indexOf('json') !== -1;\n}\n\n/**\n * HTTP Request.\n */\n\nvar Request = function Request(options$$1) {\n\n    this.body = null;\n    this.params = {};\n\n    assign(this, options$$1, {\n        method: toUpper(options$$1.method || 'GET')\n    });\n\n    if (!(this.headers instanceof Headers)) {\n        this.headers = new Headers(this.headers);\n    }\n};\n\nRequest.prototype.getUrl = function getUrl (){\n    return Url(this);\n};\n\nRequest.prototype.getBody = function getBody (){\n    return this.body;\n};\n\nRequest.prototype.respondWith = function respondWith (body, options$$1) {\n    return new Response(body, assign(options$$1 || {}, {url: this.getUrl()}));\n};\n\n/**\n * Service for sending network requests.\n */\n\nvar COMMON_HEADERS = {'Accept': 'application/json, text/plain, */*'};\nvar JSON_CONTENT_TYPE = {'Content-Type': 'application/json;charset=utf-8'};\n\nfunction Http(options$$1) {\n\n    var self = this || {}, client = Client(self.$vm);\n\n    defaults(options$$1 || {}, self.$options, Http.options);\n\n    Http.interceptors.forEach(function (handler) {\n        client.use(handler);\n    });\n\n    return client(new Request(options$$1)).then(function (response) {\n\n        return response.ok ? response : PromiseObj.reject(response);\n\n    }, function (response) {\n\n        if (response instanceof Error) {\n            error(response);\n        }\n\n        return PromiseObj.reject(response);\n    });\n}\n\nHttp.options = {};\n\nHttp.headers = {\n    put: JSON_CONTENT_TYPE,\n    post: JSON_CONTENT_TYPE,\n    patch: JSON_CONTENT_TYPE,\n    delete: JSON_CONTENT_TYPE,\n    common: COMMON_HEADERS,\n    custom: {}\n};\n\nHttp.interceptors = [before, method, body, jsonp, header, cors];\n\n['get', 'delete', 'head', 'jsonp'].forEach(function (method$$1) {\n\n    Http[method$$1] = function (url, options$$1) {\n        return this(assign(options$$1 || {}, {url: url, method: method$$1}));\n    };\n\n});\n\n['post', 'put', 'patch'].forEach(function (method$$1) {\n\n    Http[method$$1] = function (url, body$$1, options$$1) {\n        return this(assign(options$$1 || {}, {url: url, method: method$$1, body: body$$1}));\n    };\n\n});\n\n/**\n * Service for interacting with RESTful services.\n */\n\nfunction Resource(url, params, actions, options$$1) {\n\n    var self = this || {}, resource = {};\n\n    actions = assign({},\n        Resource.actions,\n        actions\n    );\n\n    each(actions, function (action, name) {\n\n        action = merge({url: url, params: assign({}, params)}, options$$1, action);\n\n        resource[name] = function () {\n            return (self.$http || Http)(opts(action, arguments));\n        };\n    });\n\n    return resource;\n}\n\nfunction opts(action, args) {\n\n    var options$$1 = assign({}, action), params = {}, body;\n\n    switch (args.length) {\n\n        case 2:\n\n            params = args[0];\n            body = args[1];\n\n            break;\n\n        case 1:\n\n            if (/^(POST|PUT|PATCH)$/i.test(options$$1.method)) {\n                body = args[0];\n            } else {\n                params = args[0];\n            }\n\n            break;\n\n        case 0:\n\n            break;\n\n        default:\n\n            throw 'Expected up to 2 arguments [params, body], got ' + args.length + ' arguments';\n    }\n\n    options$$1.body = body;\n    options$$1.params = assign({}, options$$1.params, params);\n\n    return options$$1;\n}\n\nResource.actions = {\n\n    get: {method: 'GET'},\n    save: {method: 'POST'},\n    query: {method: 'GET'},\n    update: {method: 'PUT'},\n    remove: {method: 'DELETE'},\n    delete: {method: 'DELETE'}\n\n};\n\n/**\n * Install plugin.\n */\n\nfunction plugin(Vue) {\n\n    if (plugin.installed) {\n        return;\n    }\n\n    Util(Vue);\n\n    Vue.url = Url;\n    Vue.http = Http;\n    Vue.resource = Resource;\n    Vue.Promise = PromiseObj;\n\n    Object.defineProperties(Vue.prototype, {\n\n        $url: {\n            get: function get() {\n                return options(Vue.url, this, this.$options.url);\n            }\n        },\n\n        $http: {\n            get: function get() {\n                return options(Vue.http, this, this.$options.http);\n            }\n        },\n\n        $resource: {\n            get: function get() {\n                return Vue.resource.bind(this);\n            }\n        },\n\n        $promise: {\n            get: function get() {\n                var this$1 = this;\n\n                return function (executor) { return new Vue.Promise(executor, this$1); };\n            }\n        }\n\n    });\n}\n\nif (typeof window !== 'undefined' && window.Vue) {\n    window.Vue.use(plugin);\n}\n\nmodule.exports = plugin;\n\n\n/***/ }),\n/* 39 */,\n/* 40 */,\n/* 41 */,\n/* 42 */,\n/* 43 */,\n/* 44 */,\n/* 45 */,\n/* 46 */,\n/* 47 */,\n/* 48 */,\n/* 49 */,\n/* 50 */,\n/* 51 */,\n/* 52 */,\n/* 53 */,\n/* 54 */,\n/* 55 */,\n/* 56 */,\n/* 57 */\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = { \"default\": __webpack_require__(60), __esModule: true };\n\n/***/ }),\n/* 58 */\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = { \"default\": __webpack_require__(61), __esModule: true };\n\n/***/ }),\n/* 59 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nexports.__esModule = true;\n\nvar _from = __webpack_require__(57);\n\nvar _from2 = _interopRequireDefault(_from);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function (arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {\n      arr2[i] = arr[i];\n    }\n\n    return arr2;\n  } else {\n    return (0, _from2.default)(arr);\n  }\n};\n\n/***/ }),\n/* 60 */\n/***/ (function(module, exports, __webpack_require__) {\n\n__webpack_require__(87);\n__webpack_require__(85);\nmodule.exports = __webpack_require__(10).Array.from;\n\n/***/ }),\n/* 61 */\n/***/ (function(module, exports, __webpack_require__) {\n\n__webpack_require__(86);\nvar $Object = __webpack_require__(10).Object;\nmodule.exports = function defineProperty(it, key, desc){\n  return $Object.defineProperty(it, key, desc);\n};\n\n/***/ }),\n/* 62 */\n/***/ (function(module, exports) {\n\nmodule.exports = function(it){\n  if(typeof it != 'function')throw TypeError(it + ' is not a function!');\n  return it;\n};\n\n/***/ }),\n/* 63 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// false -> Array#indexOf\n// true  -> Array#includes\nvar toIObject = __webpack_require__(30)\n  , toLength  = __webpack_require__(31)\n  , toIndex   = __webpack_require__(82);\nmodule.exports = function(IS_INCLUDES){\n  return function($this, el, fromIndex){\n    var O      = toIObject($this)\n      , length = toLength(O.length)\n      , index  = toIndex(fromIndex, length)\n      , value;\n    // Array#includes uses SameValueZero equality algorithm\n    if(IS_INCLUDES && el != el)while(length > index){\n      value = O[index++];\n      if(value != value)return true;\n    // Array#toIndex ignores holes, Array#includes - not\n    } else for(;length > index; index++)if(IS_INCLUDES || index in O){\n      if(O[index] === el)return IS_INCLUDES || index || 0;\n    } return !IS_INCLUDES && -1;\n  };\n};\n\n/***/ }),\n/* 64 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// getting tag from 19.1.3.6 Object.prototype.toString()\nvar cof = __webpack_require__(23)\n  , TAG = __webpack_require__(2)('toStringTag')\n  // ES3 wrong here\n  , ARG = cof(function(){ return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function(it, key){\n  try {\n    return it[key];\n  } catch(e){ /* empty */ }\n};\n\nmodule.exports = function(it){\n  var O, T, B;\n  return it === undefined ? 'Undefined' : it === null ? 'Null'\n    // @@toStringTag case\n    : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T\n    // builtinTag case\n    : ARG ? cof(O)\n    // ES3 arguments fallback\n    : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;\n};\n\n/***/ }),\n/* 65 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar $defineProperty = __webpack_require__(6)\n  , createDesc      = __webpack_require__(18);\n\nmodule.exports = function(object, index, value){\n  if(index in object)$defineProperty.f(object, index, createDesc(0, value));\n  else object[index] = value;\n};\n\n/***/ }),\n/* 66 */\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = __webpack_require__(5).document && document.documentElement;\n\n/***/ }),\n/* 67 */\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = !__webpack_require__(4) && !__webpack_require__(27)(function(){\n  return Object.defineProperty(__webpack_require__(25)('div'), 'a', {get: function(){ return 7; }}).a != 7;\n});\n\n/***/ }),\n/* 68 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nvar cof = __webpack_require__(23);\nmodule.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){\n  return cof(it) == 'String' ? it.split('') : Object(it);\n};\n\n/***/ }),\n/* 69 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// check on default Array iterator\nvar Iterators  = __webpack_require__(17)\n  , ITERATOR   = __webpack_require__(2)('iterator')\n  , ArrayProto = Array.prototype;\n\nmodule.exports = function(it){\n  return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);\n};\n\n/***/ }),\n/* 70 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// call something on iterator step with safe closing on error\nvar anObject = __webpack_require__(9);\nmodule.exports = function(iterator, fn, value, entries){\n  try {\n    return entries ? fn(anObject(value)[0], value[1]) : fn(value);\n  // 7.4.6 IteratorClose(iterator, completion)\n  } catch(e){\n    var ret = iterator['return'];\n    if(ret !== undefined)anObject(ret.call(iterator));\n    throw e;\n  }\n};\n\n/***/ }),\n/* 71 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar create         = __webpack_require__(75)\n  , descriptor     = __webpack_require__(18)\n  , setToStringTag = __webpack_require__(28)\n  , IteratorPrototype = {};\n\n// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()\n__webpack_require__(12)(IteratorPrototype, __webpack_require__(2)('iterator'), function(){ return this; });\n\nmodule.exports = function(Constructor, NAME, next){\n  Constructor.prototype = create(IteratorPrototype, {next: descriptor(1, next)});\n  setToStringTag(Constructor, NAME + ' Iterator');\n};\n\n/***/ }),\n/* 72 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar LIBRARY        = __webpack_require__(74)\n  , $export        = __webpack_require__(15)\n  , redefine       = __webpack_require__(80)\n  , hide           = __webpack_require__(12)\n  , has            = __webpack_require__(11)\n  , Iterators      = __webpack_require__(17)\n  , $iterCreate    = __webpack_require__(71)\n  , setToStringTag = __webpack_require__(28)\n  , getPrototypeOf = __webpack_require__(77)\n  , ITERATOR       = __webpack_require__(2)('iterator')\n  , BUGGY          = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`\n  , FF_ITERATOR    = '@@iterator'\n  , KEYS           = 'keys'\n  , VALUES         = 'values';\n\nvar returnThis = function(){ return this; };\n\nmodule.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){\n  $iterCreate(Constructor, NAME, next);\n  var getMethod = function(kind){\n    if(!BUGGY && kind in proto)return proto[kind];\n    switch(kind){\n      case KEYS: return function keys(){ return new Constructor(this, kind); };\n      case VALUES: return function values(){ return new Constructor(this, kind); };\n    } return function entries(){ return new Constructor(this, kind); };\n  };\n  var TAG        = NAME + ' Iterator'\n    , DEF_VALUES = DEFAULT == VALUES\n    , VALUES_BUG = false\n    , proto      = Base.prototype\n    , $native    = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]\n    , $default   = $native || getMethod(DEFAULT)\n    , $entries   = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined\n    , $anyNative = NAME == 'Array' ? proto.entries || $native : $native\n    , methods, key, IteratorPrototype;\n  // Fix native\n  if($anyNative){\n    IteratorPrototype = getPrototypeOf($anyNative.call(new Base));\n    if(IteratorPrototype !== Object.prototype){\n      // Set @@toStringTag to native iterators\n      setToStringTag(IteratorPrototype, TAG, true);\n      // fix for some old engines\n      if(!LIBRARY && !has(IteratorPrototype, ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis);\n    }\n  }\n  // fix Array#{values, @@iterator}.name in V8 / FF\n  if(DEF_VALUES && $native && $native.name !== VALUES){\n    VALUES_BUG = true;\n    $default = function values(){ return $native.call(this); };\n  }\n  // Define iterator\n  if((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])){\n    hide(proto, ITERATOR, $default);\n  }\n  // Plug for library\n  Iterators[NAME] = $default;\n  Iterators[TAG]  = returnThis;\n  if(DEFAULT){\n    methods = {\n      values:  DEF_VALUES ? $default : getMethod(VALUES),\n      keys:    IS_SET     ? $default : getMethod(KEYS),\n      entries: $entries\n    };\n    if(FORCED)for(key in methods){\n      if(!(key in proto))redefine(proto, key, methods[key]);\n    } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);\n  }\n  return methods;\n};\n\n/***/ }),\n/* 73 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar ITERATOR     = __webpack_require__(2)('iterator')\n  , SAFE_CLOSING = false;\n\ntry {\n  var riter = [7][ITERATOR]();\n  riter['return'] = function(){ SAFE_CLOSING = true; };\n  Array.from(riter, function(){ throw 2; });\n} catch(e){ /* empty */ }\n\nmodule.exports = function(exec, skipClosing){\n  if(!skipClosing && !SAFE_CLOSING)return false;\n  var safe = false;\n  try {\n    var arr  = [7]\n      , iter = arr[ITERATOR]();\n    iter.next = function(){ return {done: safe = true}; };\n    arr[ITERATOR] = function(){ return iter; };\n    exec(arr);\n  } catch(e){ /* empty */ }\n  return safe;\n};\n\n/***/ }),\n/* 74 */\n/***/ (function(module, exports) {\n\nmodule.exports = true;\n\n/***/ }),\n/* 75 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])\nvar anObject    = __webpack_require__(9)\n  , dPs         = __webpack_require__(76)\n  , enumBugKeys = __webpack_require__(26)\n  , IE_PROTO    = __webpack_require__(19)('IE_PROTO')\n  , Empty       = function(){ /* empty */ }\n  , PROTOTYPE   = 'prototype';\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar createDict = function(){\n  // Thrash, waste and sodomy: IE GC bug\n  var iframe = __webpack_require__(25)('iframe')\n    , i      = enumBugKeys.length\n    , lt     = '<'\n    , gt     = '>'\n    , iframeDocument;\n  iframe.style.display = 'none';\n  __webpack_require__(66).appendChild(iframe);\n  iframe.src = 'javascript:'; // eslint-disable-line no-script-url\n  // createDict = iframe.contentWindow.Object;\n  // html.removeChild(iframe);\n  iframeDocument = iframe.contentWindow.document;\n  iframeDocument.open();\n  iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);\n  iframeDocument.close();\n  createDict = iframeDocument.F;\n  while(i--)delete createDict[PROTOTYPE][enumBugKeys[i]];\n  return createDict();\n};\n\nmodule.exports = Object.create || function create(O, Properties){\n  var result;\n  if(O !== null){\n    Empty[PROTOTYPE] = anObject(O);\n    result = new Empty;\n    Empty[PROTOTYPE] = null;\n    // add \"__proto__\" for Object.getPrototypeOf polyfill\n    result[IE_PROTO] = O;\n  } else result = createDict();\n  return Properties === undefined ? result : dPs(result, Properties);\n};\n\n\n/***/ }),\n/* 76 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar dP       = __webpack_require__(6)\n  , anObject = __webpack_require__(9)\n  , getKeys  = __webpack_require__(79);\n\nmodule.exports = __webpack_require__(4) ? Object.defineProperties : function defineProperties(O, Properties){\n  anObject(O);\n  var keys   = getKeys(Properties)\n    , length = keys.length\n    , i = 0\n    , P;\n  while(length > i)dP.f(O, P = keys[i++], Properties[P]);\n  return O;\n};\n\n/***/ }),\n/* 77 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)\nvar has         = __webpack_require__(11)\n  , toObject    = __webpack_require__(32)\n  , IE_PROTO    = __webpack_require__(19)('IE_PROTO')\n  , ObjectProto = Object.prototype;\n\nmodule.exports = Object.getPrototypeOf || function(O){\n  O = toObject(O);\n  if(has(O, IE_PROTO))return O[IE_PROTO];\n  if(typeof O.constructor == 'function' && O instanceof O.constructor){\n    return O.constructor.prototype;\n  } return O instanceof Object ? ObjectProto : null;\n};\n\n/***/ }),\n/* 78 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar has          = __webpack_require__(11)\n  , toIObject    = __webpack_require__(30)\n  , arrayIndexOf = __webpack_require__(63)(false)\n  , IE_PROTO     = __webpack_require__(19)('IE_PROTO');\n\nmodule.exports = function(object, names){\n  var O      = toIObject(object)\n    , i      = 0\n    , result = []\n    , key;\n  for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);\n  // Don't enum bug & hidden keys\n  while(names.length > i)if(has(O, key = names[i++])){\n    ~arrayIndexOf(result, key) || result.push(key);\n  }\n  return result;\n};\n\n/***/ }),\n/* 79 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// 19.1.2.14 / 15.2.3.14 Object.keys(O)\nvar $keys       = __webpack_require__(78)\n  , enumBugKeys = __webpack_require__(26);\n\nmodule.exports = Object.keys || function keys(O){\n  return $keys(O, enumBugKeys);\n};\n\n/***/ }),\n/* 80 */\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = __webpack_require__(12);\n\n/***/ }),\n/* 81 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar toInteger = __webpack_require__(20)\n  , defined   = __webpack_require__(14);\n// true  -> String#at\n// false -> String#codePointAt\nmodule.exports = function(TO_STRING){\n  return function(that, pos){\n    var s = String(defined(that))\n      , i = toInteger(pos)\n      , l = s.length\n      , a, b;\n    if(i < 0 || i >= l)return TO_STRING ? '' : undefined;\n    a = s.charCodeAt(i);\n    return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff\n      ? TO_STRING ? s.charAt(i) : a\n      : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;\n  };\n};\n\n/***/ }),\n/* 82 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar toInteger = __webpack_require__(20)\n  , max       = Math.max\n  , min       = Math.min;\nmodule.exports = function(index, length){\n  index = toInteger(index);\n  return index < 0 ? max(index + length, 0) : min(index, length);\n};\n\n/***/ }),\n/* 83 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// 7.1.1 ToPrimitive(input [, PreferredType])\nvar isObject = __webpack_require__(16);\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function(it, S){\n  if(!isObject(it))return it;\n  var fn, val;\n  if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n  if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;\n  if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n\n/***/ }),\n/* 84 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar classof   = __webpack_require__(64)\n  , ITERATOR  = __webpack_require__(2)('iterator')\n  , Iterators = __webpack_require__(17);\nmodule.exports = __webpack_require__(10).getIteratorMethod = function(it){\n  if(it != undefined)return it[ITERATOR]\n    || it['@@iterator']\n    || Iterators[classof(it)];\n};\n\n/***/ }),\n/* 85 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar ctx            = __webpack_require__(24)\n  , $export        = __webpack_require__(15)\n  , toObject       = __webpack_require__(32)\n  , call           = __webpack_require__(70)\n  , isArrayIter    = __webpack_require__(69)\n  , toLength       = __webpack_require__(31)\n  , createProperty = __webpack_require__(65)\n  , getIterFn      = __webpack_require__(84);\n\n$export($export.S + $export.F * !__webpack_require__(73)(function(iter){ Array.from(iter); }), 'Array', {\n  // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)\n  from: function from(arrayLike/*, mapfn = undefined, thisArg = undefined*/){\n    var O       = toObject(arrayLike)\n      , C       = typeof this == 'function' ? this : Array\n      , aLen    = arguments.length\n      , mapfn   = aLen > 1 ? arguments[1] : undefined\n      , mapping = mapfn !== undefined\n      , index   = 0\n      , iterFn  = getIterFn(O)\n      , length, result, step, iterator;\n    if(mapping)mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);\n    // if object isn't iterable or it's array with default iterator - use simple case\n    if(iterFn != undefined && !(C == Array && isArrayIter(iterFn))){\n      for(iterator = iterFn.call(O), result = new C; !(step = iterator.next()).done; index++){\n        createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value);\n      }\n    } else {\n      length = toLength(O.length);\n      for(result = new C(length); length > index; index++){\n        createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);\n      }\n    }\n    result.length = index;\n    return result;\n  }\n});\n\n\n/***/ }),\n/* 86 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar $export = __webpack_require__(15);\n// 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes)\n$export($export.S + $export.F * !__webpack_require__(4), 'Object', {defineProperty: __webpack_require__(6).f});\n\n/***/ }),\n/* 87 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar $at  = __webpack_require__(81)(true);\n\n// 21.1.3.27 String.prototype[@@iterator]()\n__webpack_require__(72)(String, 'String', function(iterated){\n  this._t = String(iterated); // target\n  this._i = 0;                // next index\n// 21.1.5.2.1 %StringIteratorPrototype%.next()\n}, function(){\n  var O     = this._t\n    , index = this._i\n    , point;\n  if(index >= O.length)return {value: undefined, done: true};\n  point = $at(O, index);\n  this._i += point.length;\n  return {value: point, done: false};\n});\n\n/***/ }),\n/* 88 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__src_dsv__ = __webpack_require__(21);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return __WEBPACK_IMPORTED_MODULE_0__src_dsv__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__src_csv__ = __webpack_require__(89);\n/* unused harmony reexport csvParse */\n/* unused harmony reexport csvParseRows */\n/* unused harmony reexport csvFormat */\n/* unused harmony reexport csvFormatRows */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__src_tsv__ = __webpack_require__(90);\n/* unused harmony reexport tsvParse */\n/* unused harmony reexport tsvParseRows */\n/* unused harmony reexport tsvFormat */\n/* unused harmony reexport tsvFormatRows */\n\n\n\n\n\n/***/ }),\n/* 89 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__dsv__ = __webpack_require__(21);\n/* unused harmony export csvParse */\n/* unused harmony export csvParseRows */\n/* unused harmony export csvFormat */\n/* unused harmony export csvFormatRows */\n\n\nvar csv = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__dsv__[\"a\" /* default */])(\",\");\n\nvar csvParse = csv.parse;\nvar csvParseRows = csv.parseRows;\nvar csvFormat = csv.format;\nvar csvFormatRows = csv.formatRows;\n\n\n/***/ }),\n/* 90 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__dsv__ = __webpack_require__(21);\n/* unused harmony export tsvParse */\n/* unused harmony export tsvParseRows */\n/* unused harmony export tsvFormat */\n/* unused harmony export tsvFormatRows */\n\n\nvar tsv = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__dsv__[\"a\" /* default */])(\"\\t\");\n\nvar tsvParse = tsv.parse;\nvar tsvParseRows = tsv.parseRows;\nvar tsvFormat = tsv.format;\nvar tsvFormatRows = tsv.formatRows;\n\n\n/***/ }),\n/* 91 */,\n/* 92 */,\n/* 93 */,\n/* 94 */,\n/* 95 */,\n/* 96 */,\n/* 97 */,\n/* 98 */,\n/* 99 */,\n/* 100 */,\n/* 101 */,\n/* 102 */,\n/* 103 */,\n/* 104 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// https://github.com/topojson/topojson Version 2.2.0. Copyright 2016 Mike Bostock.\n(function (global, factory) {\n   true ? factory(exports) :\n  typeof define === 'function' && define.amd ? define(['exports'], factory) :\n  (factory((global.topojson = global.topojson || {})));\n}(this, (function (exports) { 'use strict';\n\n// Computes the bounding box of the specified hash of GeoJSON objects.\nvar bounds = function(objects) {\n  var x0 = Infinity,\n      y0 = Infinity,\n      x1 = -Infinity,\n      y1 = -Infinity;\n\n  function boundGeometry(geometry) {\n    if (geometry && boundGeometryType.hasOwnProperty(geometry.type)) boundGeometryType[geometry.type](geometry);\n  }\n\n  var boundGeometryType = {\n    GeometryCollection: function(o) { o.geometries.forEach(boundGeometry); },\n    Point: function(o) { boundPoint(o.coordinates); },\n    MultiPoint: function(o) { o.coordinates.forEach(boundPoint); },\n    LineString: function(o) { boundLine(o.coordinates); },\n    MultiLineString: function(o) { o.coordinates.forEach(boundLine); },\n    Polygon: function(o) { o.coordinates.forEach(boundLine); },\n    MultiPolygon: function(o) { o.coordinates.forEach(boundMultiLine); }\n  };\n\n  function boundPoint(coordinates) {\n    var x = coordinates[0],\n        y = coordinates[1];\n    if (x < x0) x0 = x;\n    if (x > x1) x1 = x;\n    if (y < y0) y0 = y;\n    if (y > y1) y1 = y;\n  }\n\n  function boundLine(coordinates) {\n    coordinates.forEach(boundPoint);\n  }\n\n  function boundMultiLine(coordinates) {\n    coordinates.forEach(boundLine);\n  }\n\n  for (var key in objects) {\n    boundGeometry(objects[key]);\n  }\n\n  return x1 >= x0 && y1 >= y0 ? [x0, y0, x1, y1] : undefined;\n};\n\nvar hashset = function(size, hash, equal, type, empty) {\n  if (arguments.length === 3) {\n    type = Array;\n    empty = null;\n  }\n\n  var store = new type(size = 1 << Math.max(4, Math.ceil(Math.log(size) / Math.LN2))),\n      mask = size - 1;\n\n  for (var i = 0; i < size; ++i) {\n    store[i] = empty;\n  }\n\n  function add(value) {\n    var index = hash(value) & mask,\n        match = store[index],\n        collisions = 0;\n    while (match != empty) {\n      if (equal(match, value)) return true;\n      if (++collisions >= size) throw new Error(\"full hashset\");\n      match = store[index = (index + 1) & mask];\n    }\n    store[index] = value;\n    return true;\n  }\n\n  function has(value) {\n    var index = hash(value) & mask,\n        match = store[index],\n        collisions = 0;\n    while (match != empty) {\n      if (equal(match, value)) return true;\n      if (++collisions >= size) break;\n      match = store[index = (index + 1) & mask];\n    }\n    return false;\n  }\n\n  function values() {\n    var values = [];\n    for (var i = 0, n = store.length; i < n; ++i) {\n      var match = store[i];\n      if (match != empty) values.push(match);\n    }\n    return values;\n  }\n\n  return {\n    add: add,\n    has: has,\n    values: values\n  };\n};\n\nvar hashmap = function(size, hash, equal, keyType, keyEmpty, valueType) {\n  if (arguments.length === 3) {\n    keyType = valueType = Array;\n    keyEmpty = null;\n  }\n\n  var keystore = new keyType(size = 1 << Math.max(4, Math.ceil(Math.log(size) / Math.LN2))),\n      valstore = new valueType(size),\n      mask = size - 1;\n\n  for (var i = 0; i < size; ++i) {\n    keystore[i] = keyEmpty;\n  }\n\n  function set(key, value) {\n    var index = hash(key) & mask,\n        matchKey = keystore[index],\n        collisions = 0;\n    while (matchKey != keyEmpty) {\n      if (equal(matchKey, key)) return valstore[index] = value;\n      if (++collisions >= size) throw new Error(\"full hashmap\");\n      matchKey = keystore[index = (index + 1) & mask];\n    }\n    keystore[index] = key;\n    valstore[index] = value;\n    return value;\n  }\n\n  function maybeSet(key, value) {\n    var index = hash(key) & mask,\n        matchKey = keystore[index],\n        collisions = 0;\n    while (matchKey != keyEmpty) {\n      if (equal(matchKey, key)) return valstore[index];\n      if (++collisions >= size) throw new Error(\"full hashmap\");\n      matchKey = keystore[index = (index + 1) & mask];\n    }\n    keystore[index] = key;\n    valstore[index] = value;\n    return value;\n  }\n\n  function get(key, missingValue) {\n    var index = hash(key) & mask,\n        matchKey = keystore[index],\n        collisions = 0;\n    while (matchKey != keyEmpty) {\n      if (equal(matchKey, key)) return valstore[index];\n      if (++collisions >= size) break;\n      matchKey = keystore[index = (index + 1) & mask];\n    }\n    return missingValue;\n  }\n\n  function keys() {\n    var keys = [];\n    for (var i = 0, n = keystore.length; i < n; ++i) {\n      var matchKey = keystore[i];\n      if (matchKey != keyEmpty) keys.push(matchKey);\n    }\n    return keys;\n  }\n\n  return {\n    set: set,\n    maybeSet: maybeSet, // set if unset\n    get: get,\n    keys: keys\n  };\n};\n\nvar equalPoint = function(pointA, pointB) {\n  return pointA[0] === pointB[0] && pointA[1] === pointB[1];\n};\n\n// TODO if quantized, use simpler Int32 hashing?\n\nvar buffer = new ArrayBuffer(16);\nvar floats = new Float64Array(buffer);\nvar uints = new Uint32Array(buffer);\n\nvar hashPoint = function(point) {\n  floats[0] = point[0];\n  floats[1] = point[1];\n  var hash = uints[0] ^ uints[1];\n  hash = hash << 5 ^ hash >> 7 ^ uints[2] ^ uints[3];\n  return hash & 0x7fffffff;\n};\n\n// Given an extracted (pre-)topology, identifies all of the junctions. These are\n// the points at which arcs (lines or rings) will need to be cut so that each\n// arc is represented uniquely.\n//\n// A junction is a point where at least one arc deviates from another arc going\n// through the same point. For example, consider the point B. If there is a arc\n// through ABC and another arc through CBA, then B is not a junction because in\n// both cases the adjacent point pairs are {A,C}. However, if there is an\n// additional arc ABD, then {A,D} != {A,C}, and thus B becomes a junction.\n//\n// For a closed ring ABCA, the first point A’s adjacent points are the second\n// and last point {B,C}. For a line, the first and last point are always\n// considered junctions, even if the line is closed; this ensures that a closed\n// line is never rotated.\nvar join = function(topology) {\n  var coordinates = topology.coordinates,\n      lines = topology.lines,\n      rings = topology.rings,\n      indexes = index(),\n      visitedByIndex = new Int32Array(coordinates.length),\n      leftByIndex = new Int32Array(coordinates.length),\n      rightByIndex = new Int32Array(coordinates.length),\n      junctionByIndex = new Int8Array(coordinates.length),\n      junctionCount = 0, // upper bound on number of junctions\n      i, n,\n      previousIndex,\n      currentIndex,\n      nextIndex;\n\n  for (i = 0, n = coordinates.length; i < n; ++i) {\n    visitedByIndex[i] = leftByIndex[i] = rightByIndex[i] = -1;\n  }\n\n  for (i = 0, n = lines.length; i < n; ++i) {\n    var line = lines[i],\n        lineStart = line[0],\n        lineEnd = line[1];\n    currentIndex = indexes[lineStart];\n    nextIndex = indexes[++lineStart];\n    ++junctionCount, junctionByIndex[currentIndex] = 1; // start\n    while (++lineStart <= lineEnd) {\n      sequence(i, previousIndex = currentIndex, currentIndex = nextIndex, nextIndex = indexes[lineStart]);\n    }\n    ++junctionCount, junctionByIndex[nextIndex] = 1; // end\n  }\n\n  for (i = 0, n = coordinates.length; i < n; ++i) {\n    visitedByIndex[i] = -1;\n  }\n\n  for (i = 0, n = rings.length; i < n; ++i) {\n    var ring = rings[i],\n        ringStart = ring[0] + 1,\n        ringEnd = ring[1];\n    previousIndex = indexes[ringEnd - 1];\n    currentIndex = indexes[ringStart - 1];\n    nextIndex = indexes[ringStart];\n    sequence(i, previousIndex, currentIndex, nextIndex);\n    while (++ringStart <= ringEnd) {\n      sequence(i, previousIndex = currentIndex, currentIndex = nextIndex, nextIndex = indexes[ringStart]);\n    }\n  }\n\n  function sequence(i, previousIndex, currentIndex, nextIndex) {\n    if (visitedByIndex[currentIndex] === i) return; // ignore self-intersection\n    visitedByIndex[currentIndex] = i;\n    var leftIndex = leftByIndex[currentIndex];\n    if (leftIndex >= 0) {\n      var rightIndex = rightByIndex[currentIndex];\n      if ((leftIndex !== previousIndex || rightIndex !== nextIndex)\n        && (leftIndex !== nextIndex || rightIndex !== previousIndex)) {\n        ++junctionCount, junctionByIndex[currentIndex] = 1;\n      }\n    } else {\n      leftByIndex[currentIndex] = previousIndex;\n      rightByIndex[currentIndex] = nextIndex;\n    }\n  }\n\n  function index() {\n    var indexByPoint = hashmap(coordinates.length * 1.4, hashIndex, equalIndex, Int32Array, -1, Int32Array),\n        indexes = new Int32Array(coordinates.length);\n\n    for (var i = 0, n = coordinates.length; i < n; ++i) {\n      indexes[i] = indexByPoint.maybeSet(i, i);\n    }\n\n    return indexes;\n  }\n\n  function hashIndex(i) {\n    return hashPoint(coordinates[i]);\n  }\n\n  function equalIndex(i, j) {\n    return equalPoint(coordinates[i], coordinates[j]);\n  }\n\n  visitedByIndex = leftByIndex = rightByIndex = null;\n\n  var junctionByPoint = hashset(junctionCount * 1.4, hashPoint, equalPoint), j;\n\n  // Convert back to a standard hashset by point for caller convenience.\n  for (i = 0, n = coordinates.length; i < n; ++i) {\n    if (junctionByIndex[j = indexes[i]]) {\n      junctionByPoint.add(coordinates[j]);\n    }\n  }\n\n  return junctionByPoint;\n};\n\n// Given an extracted (pre-)topology, cuts (or rotates) arcs so that all shared\n// point sequences are identified. The topology can then be subsequently deduped\n// to remove exact duplicate arcs.\nvar cut = function(topology) {\n  var junctions = join(topology),\n      coordinates = topology.coordinates,\n      lines = topology.lines,\n      rings = topology.rings,\n      next,\n      i, n;\n\n  for (i = 0, n = lines.length; i < n; ++i) {\n    var line = lines[i],\n        lineMid = line[0],\n        lineEnd = line[1];\n    while (++lineMid < lineEnd) {\n      if (junctions.has(coordinates[lineMid])) {\n        next = {0: lineMid, 1: line[1]};\n        line[1] = lineMid;\n        line = line.next = next;\n      }\n    }\n  }\n\n  for (i = 0, n = rings.length; i < n; ++i) {\n    var ring = rings[i],\n        ringStart = ring[0],\n        ringMid = ringStart,\n        ringEnd = ring[1],\n        ringFixed = junctions.has(coordinates[ringStart]);\n    while (++ringMid < ringEnd) {\n      if (junctions.has(coordinates[ringMid])) {\n        if (ringFixed) {\n          next = {0: ringMid, 1: ring[1]};\n          ring[1] = ringMid;\n          ring = ring.next = next;\n        } else { // For the first junction, we can rotate rather than cut.\n          rotateArray(coordinates, ringStart, ringEnd, ringEnd - ringMid);\n          coordinates[ringEnd] = coordinates[ringStart];\n          ringFixed = true;\n          ringMid = ringStart; // restart; we may have skipped junctions\n        }\n      }\n    }\n  }\n\n  return topology;\n};\n\nfunction rotateArray(array, start, end, offset) {\n  reverse(array, start, end);\n  reverse(array, start, start + offset);\n  reverse(array, start + offset, end);\n}\n\nfunction reverse(array, start, end) {\n  for (var mid = start + ((end-- - start) >> 1), t; start < mid; ++start, --end) {\n    t = array[start], array[start] = array[end], array[end] = t;\n  }\n}\n\n// Given a cut topology, combines duplicate arcs.\nvar dedup = function(topology) {\n  var coordinates = topology.coordinates,\n      lines = topology.lines, line,\n      rings = topology.rings, ring,\n      arcCount = lines.length + rings.length,\n      i, n;\n\n  delete topology.lines;\n  delete topology.rings;\n\n  // Count the number of (non-unique) arcs to initialize the hashmap safely.\n  for (i = 0, n = lines.length; i < n; ++i) {\n    line = lines[i]; while (line = line.next) ++arcCount;\n  }\n  for (i = 0, n = rings.length; i < n; ++i) {\n    ring = rings[i]; while (ring = ring.next) ++arcCount;\n  }\n\n  var arcsByEnd = hashmap(arcCount * 2 * 1.4, hashPoint, equalPoint),\n      arcs = topology.arcs = [];\n\n  for (i = 0, n = lines.length; i < n; ++i) {\n    line = lines[i];\n    do {\n      dedupLine(line);\n    } while (line = line.next);\n  }\n\n  for (i = 0, n = rings.length; i < n; ++i) {\n    ring = rings[i];\n    if (ring.next) { // arc is no longer closed\n      do {\n        dedupLine(ring);\n      } while (ring = ring.next);\n    } else {\n      dedupRing(ring);\n    }\n  }\n\n  function dedupLine(arc) {\n    var startPoint,\n        endPoint,\n        startArcs, startArc,\n        endArcs, endArc,\n        i, n;\n\n    // Does this arc match an existing arc in order?\n    if (startArcs = arcsByEnd.get(startPoint = coordinates[arc[0]])) {\n      for (i = 0, n = startArcs.length; i < n; ++i) {\n        startArc = startArcs[i];\n        if (equalLine(startArc, arc)) {\n          arc[0] = startArc[0];\n          arc[1] = startArc[1];\n          return;\n        }\n      }\n    }\n\n    // Does this arc match an existing arc in reverse order?\n    if (endArcs = arcsByEnd.get(endPoint = coordinates[arc[1]])) {\n      for (i = 0, n = endArcs.length; i < n; ++i) {\n        endArc = endArcs[i];\n        if (reverseEqualLine(endArc, arc)) {\n          arc[1] = endArc[0];\n          arc[0] = endArc[1];\n          return;\n        }\n      }\n    }\n\n    if (startArcs) startArcs.push(arc); else arcsByEnd.set(startPoint, [arc]);\n    if (endArcs) endArcs.push(arc); else arcsByEnd.set(endPoint, [arc]);\n    arcs.push(arc);\n  }\n\n  function dedupRing(arc) {\n    var endPoint,\n        endArcs,\n        endArc,\n        i, n;\n\n    // Does this arc match an existing line in order, or reverse order?\n    // Rings are closed, so their start point and end point is the same.\n    if (endArcs = arcsByEnd.get(endPoint = coordinates[arc[0]])) {\n      for (i = 0, n = endArcs.length; i < n; ++i) {\n        endArc = endArcs[i];\n        if (equalRing(endArc, arc)) {\n          arc[0] = endArc[0];\n          arc[1] = endArc[1];\n          return;\n        }\n        if (reverseEqualRing(endArc, arc)) {\n          arc[0] = endArc[1];\n          arc[1] = endArc[0];\n          return;\n        }\n      }\n    }\n\n    // Otherwise, does this arc match an existing ring in order, or reverse order?\n    if (endArcs = arcsByEnd.get(endPoint = coordinates[arc[0] + findMinimumOffset(arc)])) {\n      for (i = 0, n = endArcs.length; i < n; ++i) {\n        endArc = endArcs[i];\n        if (equalRing(endArc, arc)) {\n          arc[0] = endArc[0];\n          arc[1] = endArc[1];\n          return;\n        }\n        if (reverseEqualRing(endArc, arc)) {\n          arc[0] = endArc[1];\n          arc[1] = endArc[0];\n          return;\n        }\n      }\n    }\n\n    if (endArcs) endArcs.push(arc); else arcsByEnd.set(endPoint, [arc]);\n    arcs.push(arc);\n  }\n\n  function equalLine(arcA, arcB) {\n    var ia = arcA[0], ib = arcB[0],\n        ja = arcA[1], jb = arcB[1];\n    if (ia - ja !== ib - jb) return false;\n    for (; ia <= ja; ++ia, ++ib) if (!equalPoint(coordinates[ia], coordinates[ib])) return false;\n    return true;\n  }\n\n  function reverseEqualLine(arcA, arcB) {\n    var ia = arcA[0], ib = arcB[0],\n        ja = arcA[1], jb = arcB[1];\n    if (ia - ja !== ib - jb) return false;\n    for (; ia <= ja; ++ia, --jb) if (!equalPoint(coordinates[ia], coordinates[jb])) return false;\n    return true;\n  }\n\n  function equalRing(arcA, arcB) {\n    var ia = arcA[0], ib = arcB[0],\n        ja = arcA[1], jb = arcB[1],\n        n = ja - ia;\n    if (n !== jb - ib) return false;\n    var ka = findMinimumOffset(arcA),\n        kb = findMinimumOffset(arcB);\n    for (var i = 0; i < n; ++i) {\n      if (!equalPoint(coordinates[ia + (i + ka) % n], coordinates[ib + (i + kb) % n])) return false;\n    }\n    return true;\n  }\n\n  function reverseEqualRing(arcA, arcB) {\n    var ia = arcA[0], ib = arcB[0],\n        ja = arcA[1], jb = arcB[1],\n        n = ja - ia;\n    if (n !== jb - ib) return false;\n    var ka = findMinimumOffset(arcA),\n        kb = n - findMinimumOffset(arcB);\n    for (var i = 0; i < n; ++i) {\n      if (!equalPoint(coordinates[ia + (i + ka) % n], coordinates[jb - (i + kb) % n])) return false;\n    }\n    return true;\n  }\n\n  // Rings are rotated to a consistent, but arbitrary, start point.\n  // This is necessary to detect when a ring and a rotated copy are dupes.\n  function findMinimumOffset(arc) {\n    var start = arc[0],\n        end = arc[1],\n        mid = start,\n        minimum = mid,\n        minimumPoint = coordinates[mid];\n    while (++mid < end) {\n      var point = coordinates[mid];\n      if (point[0] < minimumPoint[0] || point[0] === minimumPoint[0] && point[1] < minimumPoint[1]) {\n        minimum = mid;\n        minimumPoint = point;\n      }\n    }\n    return minimum - start;\n  }\n\n  return topology;\n};\n\n// Given a TopoJSON topology in absolute (quantized) coordinates,\n// converts to fixed-point delta encoding.\n// This is a destructive operation that modifies the given topology!\nvar delta = function(topology) {\n  var arcs = topology.arcs,\n      i = -1,\n      n = arcs.length;\n\n  while (++i < n) {\n    var arc = arcs[i],\n        j = 0,\n        m = arc.length,\n        point = arc[0],\n        x0 = point[0],\n        y0 = point[1],\n        x1,\n        y1;\n    while (++j < m) {\n      point = arc[j];\n      x1 = point[0];\n      y1 = point[1];\n      arc[j] = [x1 - x0, y1 - y0];\n      x0 = x1;\n      y0 = y1;\n    }\n  }\n\n  return topology;\n};\n\n// Extracts the lines and rings from the specified hash of geometry objects.\n//\n// Returns an object with three properties:\n//\n// * coordinates - shared buffer of [x, y] coordinates\n// * lines - lines extracted from the hash, of the form [start, end]\n// * rings - rings extracted from the hash, of the form [start, end]\n//\n// For each ring or line, start and end represent inclusive indexes into the\n// coordinates buffer. For rings (and closed lines), coordinates[start] equals\n// coordinates[end].\n//\n// For each line or polygon geometry in the input hash, including nested\n// geometries as in geometry collections, the `coordinates` array is replaced\n// with an equivalent `arcs` array that, for each line (for line string\n// geometries) or ring (for polygon geometries), points to one of the above\n// lines or rings.\nvar extract = function(objects) {\n  var index = -1,\n      lines = [],\n      rings = [],\n      coordinates = [];\n\n  function extractGeometry(geometry) {\n    if (geometry && extractGeometryType.hasOwnProperty(geometry.type)) extractGeometryType[geometry.type](geometry);\n  }\n\n  var extractGeometryType = {\n    GeometryCollection: function(o) { o.geometries.forEach(extractGeometry); },\n    LineString: function(o) { o.arcs = extractLine(o.coordinates); delete o.coordinates; },\n    MultiLineString: function(o) { o.arcs = o.coordinates.map(extractLine); delete o.coordinates; },\n    Polygon: function(o) { o.arcs = o.coordinates.map(extractRing); delete o.coordinates; },\n    MultiPolygon: function(o) { o.arcs = o.coordinates.map(extractMultiRing); delete o.coordinates; }\n  };\n\n  function extractLine(line) {\n    for (var i = 0, n = line.length; i < n; ++i) coordinates[++index] = line[i];\n    var arc = {0: index - n + 1, 1: index};\n    lines.push(arc);\n    return arc;\n  }\n\n  function extractRing(ring) {\n    for (var i = 0, n = ring.length; i < n; ++i) coordinates[++index] = ring[i];\n    var arc = {0: index - n + 1, 1: index};\n    rings.push(arc);\n    return arc;\n  }\n\n  function extractMultiRing(rings) {\n    return rings.map(extractRing);\n  }\n\n  for (var key in objects) {\n    extractGeometry(objects[key]);\n  }\n\n  return {\n    type: \"Topology\",\n    coordinates: coordinates,\n    lines: lines,\n    rings: rings,\n    objects: objects\n  };\n};\n\n// Given a hash of GeoJSON objects, replaces Features with geometry objects.\n// This is a destructive operation that modifies the input objects!\nvar geometry = function(objects) {\n  var key;\n  for (key in objects) objects[key] = geomifyObject(objects[key]);\n  return objects;\n};\n\nfunction geomifyObject(object) {\n  return (object && geomifyObjectType.hasOwnProperty(object.type)\n      ? geomifyObjectType[object.type]\n      : geomifyGeometry)(object);\n}\n\nfunction geomifyFeature(feature) {\n  var geometry = feature.geometry;\n  if (geometry == null) {\n    feature.type = null;\n  } else {\n    geomifyGeometry(geometry);\n    feature.type = geometry.type;\n    if (geometry.geometries) feature.geometries = geometry.geometries;\n    else if (geometry.coordinates) feature.coordinates = geometry.coordinates;\n    if (geometry.bbox) feature.bbox = geometry.bbox;\n  }\n  delete feature.geometry;\n  return feature;\n}\n\nfunction geomifyGeometry(geometry) {\n  if (!geometry) return {type: null};\n  if (geomifyGeometryType.hasOwnProperty(geometry.type)) geomifyGeometryType[geometry.type](geometry);\n  return geometry;\n}\n\nvar geomifyObjectType = {\n  Feature: geomifyFeature,\n  FeatureCollection: function(collection) {\n    collection.type = \"GeometryCollection\";\n    collection.geometries = collection.features;\n    collection.features.forEach(geomifyFeature);\n    delete collection.features;\n    return collection;\n  }\n};\n\nvar geomifyGeometryType = {\n  GeometryCollection: function(o) {\n    var geometries = o.geometries, i = -1, n = geometries.length;\n    while (++i < n) geometries[i] = geomifyGeometry(geometries[i]);\n  },\n  MultiPoint: function(o) {\n    if (!o.coordinates.length) {\n      o.type = null;\n      delete o.coordinates;\n    } else if (o.coordinates.length < 2) {\n      o.type = \"Point\";\n      o.coordinates = o.coordinates[0];\n    }\n  },\n  LineString: function(o) {\n    if (!o.coordinates.length) {\n      o.type = null;\n      delete o.coordinates;\n    }\n  },\n  MultiLineString: function(o) {\n    for (var lines = o.coordinates, i = 0, N = 0, n = lines.length; i < n; ++i) {\n      var line = lines[i];\n      if (line.length) lines[N++] = line;\n    }\n    if (!N) {\n      o.type = null;\n      delete o.coordinates;\n    } else if (N < 2) {\n      o.type = \"LineString\";\n      o.coordinates = lines[0];\n    } else {\n      o.coordinates.length = N;\n    }\n  },\n  Polygon: function(o) {\n    for (var rings = o.coordinates, i = 0, N = 0, n = rings.length; i < n; ++i) {\n      var ring = rings[i];\n      if (ring.length) rings[N++] = ring;\n    }\n    if (!N) {\n      o.type = null;\n      delete o.coordinates;\n    } else {\n      o.coordinates.length = N;\n    }\n  },\n  MultiPolygon: function(o) {\n    for (var polygons = o.coordinates, j = 0, M = 0, m = polygons.length; j < m; ++j) {\n      for (var rings = polygons[j], i = 0, N = 0, n = rings.length; i < n; ++i) {\n        var ring = rings[i];\n        if (ring.length) rings[N++] = ring;\n      }\n      if (N) {\n        rings.length = N;\n        polygons[M++] = rings;\n      }\n    }\n    if (!M) {\n      o.type = null;\n      delete o.coordinates;\n    } else if (M < 2) {\n      o.type = \"Polygon\";\n      o.coordinates = polygons[0];\n    } else {\n      polygons.length = M;\n    }\n  }\n};\n\nvar prequantize = function(objects, bbox, n) {\n  var x0 = bbox[0],\n      y0 = bbox[1],\n      x1 = bbox[2],\n      y1 = bbox[3],\n      kx = x1 - x0 ? (n - 1) / (x1 - x0) : 1,\n      ky = y1 - y0 ? (n - 1) / (y1 - y0) : 1;\n\n  function quantizePoint(coordinates) {\n    coordinates[0] = Math.round((coordinates[0] - x0) * kx);\n    coordinates[1] = Math.round((coordinates[1] - y0) * ky);\n    return coordinates;\n  }\n\n  function quantizeLine(coordinates) {\n    var i = 0,\n        j = 1,\n        n = coordinates.length,\n        pi = quantizePoint(coordinates[0]),\n        pj,\n        px = pi[0],\n        py = pi[1],\n        x,\n        y;\n\n    while (++i < n) {\n      pi = quantizePoint(coordinates[i]);\n      x = pi[0];\n      y = pi[1];\n      if (x !== px || y !== py) { // skip coincident points\n        pj = coordinates[j++];\n        pj[0] = px = x;\n        pj[1] = py = y;\n      }\n    }\n\n    coordinates.length = j;\n  }\n\n  function quantizeGeometry(o) {\n    if (o && quantizeGeometryType.hasOwnProperty(o.type)) quantizeGeometryType[o.type](o);\n  }\n\n  var quantizeGeometryType = {\n    GeometryCollection: function(o) {\n      o.geometries.forEach(quantizeGeometry);\n    },\n    Point: function(o) {\n      quantizePoint(o.coordinates);\n    },\n    MultiPoint: function(o) {\n      o.coordinates.forEach(quantizePoint);\n    },\n    LineString: function(o) {\n      var line = o.coordinates;\n      quantizeLine(line);\n      if (line.length < 2) line[1] = line[0]; // must have 2+\n    },\n    MultiLineString: function(o) {\n      for (var lines = o.coordinates, i = 0, n = lines.length; i < n; ++i) {\n        var line = lines[i];\n        quantizeLine(line);\n        if (line.length < 2) line[1] = line[0]; // must have 2+\n      }\n    },\n    Polygon: function(o) {\n      for (var rings = o.coordinates, i = 0, n = rings.length; i < n; ++i) {\n        var ring = rings[i];\n        quantizeLine(ring);\n        while (ring.length < 4) ring.push(ring[0]); // must have 4+\n      }\n    },\n    MultiPolygon: function(o) {\n      for (var polygons = o.coordinates, i = 0, n = polygons.length; i < n; ++i) {\n        for (var rings = polygons[i], j = 0, m = rings.length; j < m; ++j) {\n          var ring = rings[j];\n          quantizeLine(ring);\n          while (ring.length < 4) ring.push(ring[0]); // must have 4+\n        }\n      }\n    }\n  };\n\n  for (var key in objects) {\n    quantizeGeometry(objects[key]);\n  }\n\n  return {\n    scale: [1 / kx, 1 / ky],\n    translate: [x0, y0]\n  };\n};\n\n// Constructs the TopoJSON Topology for the specified hash of features.\n// Each object in the specified hash must be a GeoJSON object,\n// meaning FeatureCollection, a Feature or a geometry object.\nvar topology = function(objects, quantization) {\n  var bbox = bounds(geometry(objects)),\n      transform = quantization > 0 && bbox && prequantize(objects, bbox, quantization),\n      topology = dedup(cut(extract(objects))),\n      coordinates = topology.coordinates,\n      indexByArc = hashmap(topology.arcs.length * 1.4, hashArc, equalArc);\n\n  objects = topology.objects; // for garbage collection\n  topology.bbox = bbox;\n  topology.arcs = topology.arcs.map(function(arc, i) {\n    indexByArc.set(arc, i);\n    return coordinates.slice(arc[0], arc[1] + 1);\n  });\n\n  delete topology.coordinates;\n  coordinates = null;\n\n  function indexGeometry(geometry$$1) {\n    if (geometry$$1 && indexGeometryType.hasOwnProperty(geometry$$1.type)) indexGeometryType[geometry$$1.type](geometry$$1);\n  }\n\n  var indexGeometryType = {\n    GeometryCollection: function(o) { o.geometries.forEach(indexGeometry); },\n    LineString: function(o) { o.arcs = indexArcs(o.arcs); },\n    MultiLineString: function(o) { o.arcs = o.arcs.map(indexArcs); },\n    Polygon: function(o) { o.arcs = o.arcs.map(indexArcs); },\n    MultiPolygon: function(o) { o.arcs = o.arcs.map(indexMultiArcs); }\n  };\n\n  function indexArcs(arc) {\n    var indexes = [];\n    do {\n      var index = indexByArc.get(arc);\n      indexes.push(arc[0] < arc[1] ? index : ~index);\n    } while (arc = arc.next);\n    return indexes;\n  }\n\n  function indexMultiArcs(arcs) {\n    return arcs.map(indexArcs);\n  }\n\n  for (var key in objects) {\n    indexGeometry(objects[key]);\n  }\n\n  if (transform) {\n    topology.transform = transform;\n    delta(topology);\n  }\n\n  return topology;\n};\n\nfunction hashArc(arc) {\n  var i = arc[0], j = arc[1], t;\n  if (j < i) t = i, i = j, j = t;\n  return i + 31 * j;\n}\n\nfunction equalArc(arcA, arcB) {\n  var ia = arcA[0], ja = arcA[1],\n      ib = arcB[0], jb = arcB[1], t;\n  if (ja < ia) t = ia, ia = ja, ja = t;\n  if (jb < ib) t = ib, ib = jb, jb = t;\n  return ia === ib && ja === jb;\n}\n\nvar prune = function(topology) {\n  var oldArcs = topology.arcs,\n      newArcs = topology.arcs = [],\n      newArcIndex = -1,\n      newIndexByOldIndex = new Array(oldArcs.length),\n      name;\n\n  function pruneGeometry(o) {\n    switch (o.type) {\n      case \"GeometryCollection\": o.geometries.forEach(pruneGeometry); break;\n      case \"LineString\": pruneArcs(o.arcs); break;\n      case \"MultiLineString\": o.arcs.forEach(pruneArcs); break;\n      case \"Polygon\": o.arcs.forEach(pruneArcs); break;\n      case \"MultiPolygon\": o.arcs.forEach(pruneMultiArcs); break;\n    }\n  }\n\n  function pruneArcs(arcs) {\n    for (var i = 0, n = arcs.length; i < n; ++i) {\n      var oldIndex = arcs[i],\n          oldReverse = oldIndex < 0 && (oldIndex = ~oldIndex, true),\n          newIndex;\n\n      // If this is the first instance of this arc,\n      // record it under its new index.\n      if ((newIndex = newIndexByOldIndex[oldIndex]) == null) {\n        newIndexByOldIndex[oldIndex] = newIndex = ++newArcIndex;\n        newArcs[newIndex] = oldArcs[oldIndex];\n      }\n\n      arcs[i] = oldReverse ? ~newIndex : newIndex;\n    }\n  }\n\n  function pruneMultiArcs(arcs) {\n    arcs.forEach(pruneArcs);\n  }\n\n  for (name in topology.objects) {\n    pruneGeometry(topology.objects[name]);\n  }\n\n  return topology;\n};\n\nvar filter = function(topology, filter) {\n  var name;\n\n  if (filter == null) filter = filterTrue;\n\n  function filterGeometry(o) {\n    switch (o.type) {\n      case \"Polygon\": {\n        o.arcs = filterRings(o.arcs);\n        if (!o.arcs) o.type = null, delete o.arcs;\n        break;\n      }\n      case \"MultiPolygon\": {\n        o.arcs = o.arcs.map(filterRings).filter(filterIdentity);\n        if (!o.arcs.length) o.type = null, delete o.arcs;\n        break;\n      }\n      case \"GeometryCollection\": {\n        o.geometries.forEach(filterGeometry);\n        o.geometries = o.geometries.filter(filterNotNull);\n        if (!o.geometries.length) o.type = null, delete o.geometries;\n        break;\n      }\n    }\n  }\n\n  function filterRings(arcs) {\n    return arcs.length && filterExteriorRing(arcs[0]) // if the exterior is small, ignore any holes\n        ? [arcs.shift()].concat(arcs.filter(filterInteriorRing))\n        : null;\n  }\n\n  function filterExteriorRing(ring) {\n    return filter(ring, false);\n  }\n\n  function filterInteriorRing(ring) {\n    return filter(ring, true);\n  }\n\n  for (name in topology.objects) {\n    filterGeometry(topology.objects[name]);\n  }\n\n  return prune(topology);\n};\n\nfunction filterTrue() {\n  return true;\n}\n\nfunction filterIdentity(x) {\n  return x;\n}\n\nfunction filterNotNull(geometry) {\n  return geometry.type != null;\n}\n\nvar filterAttached = function(topology) {\n  var uniqueRingByArc = {}, // arc index -> index of unique associated ring, or -1 if used by multiple rings\n      ringIndex = 0,\n      name;\n\n  function testGeometry(o) {\n    switch (o.type) {\n      case \"GeometryCollection\": o.geometries.forEach(testGeometry); break;\n      case \"Polygon\": testArcs(o.arcs); break;\n      case \"MultiPolygon\": o.arcs.forEach(testArcs); break;\n    }\n  }\n\n  function testArcs(arcs) {\n    for (var i = 0, n = arcs.length; i < n; ++i, ++ringIndex) {\n      for (var ring = arcs[i], j = 0, m = ring.length; j < m; ++j) {\n        var arc = ring[j];\n        if (arc < 0) arc = ~arc;\n        var uniqueRing = uniqueRingByArc[arc];\n        if (uniqueRing >= 0 && uniqueRing !== ringIndex) uniqueRingByArc[arc] = -1;\n        else uniqueRingByArc[arc] = ringIndex;\n      }\n    }\n  }\n\n  for (name in topology.objects) {\n    testGeometry(topology.objects[name]);\n  }\n\n  return function(ring) {\n    for (var j = 0, m = ring.length, arc; j < m; ++j) {\n      if (arc = ring[j], uniqueRingByArc[arc < 0 ? ~arc : arc] < 0) {\n        return true;\n      }\n    }\n    return false;\n  };\n};\n\nvar identity = function(x) {\n  return x;\n};\n\nvar transform = function(topology) {\n  if ((transform = topology.transform) == null) return identity;\n  var transform,\n      x0,\n      y0,\n      kx = transform.scale[0],\n      ky = transform.scale[1],\n      dx = transform.translate[0],\n      dy = transform.translate[1];\n  return function(point, i) {\n    if (!i) x0 = y0 = 0;\n    point[0] = (x0 += point[0]) * kx + dx;\n    point[1] = (y0 += point[1]) * ky + dy;\n    return point;\n  };\n};\n\nvar bbox = function(topology) {\n  var bbox = topology.bbox;\n\n  function bboxPoint(p0) {\n    p1[0] = p0[0], p1[1] = p0[1], t(p1);\n    if (p1[0] < x0) x0 = p1[0];\n    if (p1[0] > x1) x1 = p1[0];\n    if (p1[1] < y0) y0 = p1[1];\n    if (p1[1] > y1) y1 = p1[1];\n  }\n\n  function bboxGeometry(o) {\n    switch (o.type) {\n      case \"GeometryCollection\": o.geometries.forEach(bboxGeometry); break;\n      case \"Point\": bboxPoint(o.coordinates); break;\n      case \"MultiPoint\": o.coordinates.forEach(bboxPoint); break;\n    }\n  }\n\n  if (!bbox) {\n    var t = transform(topology), p0, p1 = new Array(2), name,\n        x0 = Infinity, y0 = x0, x1 = -x0, y1 = -x0;\n\n    topology.arcs.forEach(function(arc) {\n      var i = -1, n = arc.length;\n      while (++i < n) {\n        p0 = arc[i], p1[0] = p0[0], p1[1] = p0[1], t(p1, i);\n        if (p1[0] < x0) x0 = p1[0];\n        if (p1[0] > x1) x1 = p1[0];\n        if (p1[1] < y0) y0 = p1[1];\n        if (p1[1] > y1) y1 = p1[1];\n      }\n    });\n\n    for (name in topology.objects) {\n      bboxGeometry(topology.objects[name]);\n    }\n\n    bbox = topology.bbox = [x0, y0, x1, y1];\n  }\n\n  return bbox;\n};\n\nvar reverse$1 = function(array, n) {\n  var t, j = array.length, i = j - n;\n  while (i < --j) t = array[i], array[i++] = array[j], array[j] = t;\n};\n\nvar feature = function(topology, o) {\n  return o.type === \"GeometryCollection\"\n      ? {type: \"FeatureCollection\", features: o.geometries.map(function(o) { return feature$1(topology, o); })}\n      : feature$1(topology, o);\n};\n\nfunction feature$1(topology, o) {\n  var id = o.id,\n      bbox = o.bbox,\n      properties = o.properties == null ? {} : o.properties,\n      geometry = object(topology, o);\n  return id == null && bbox == null ? {type: \"Feature\", properties: properties, geometry: geometry}\n      : bbox == null ? {type: \"Feature\", id: id, properties: properties, geometry: geometry}\n      : {type: \"Feature\", id: id, bbox: bbox, properties: properties, geometry: geometry};\n}\n\nfunction object(topology, o) {\n  var transformPoint = transform(topology),\n      arcs = topology.arcs;\n\n  function arc(i, points) {\n    if (points.length) points.pop();\n    for (var a = arcs[i < 0 ? ~i : i], k = 0, n = a.length; k < n; ++k) {\n      points.push(transformPoint(a[k].slice(), k));\n    }\n    if (i < 0) reverse$1(points, n);\n  }\n\n  function point(p) {\n    return transformPoint(p.slice());\n  }\n\n  function line(arcs) {\n    var points = [];\n    for (var i = 0, n = arcs.length; i < n; ++i) arc(arcs[i], points);\n    if (points.length < 2) points.push(points[0].slice());\n    return points;\n  }\n\n  function ring(arcs) {\n    var points = line(arcs);\n    while (points.length < 4) points.push(points[0].slice());\n    return points;\n  }\n\n  function polygon(arcs) {\n    return arcs.map(ring);\n  }\n\n  function geometry(o) {\n    var type = o.type, coordinates;\n    switch (type) {\n      case \"GeometryCollection\": return {type: type, geometries: o.geometries.map(geometry)};\n      case \"Point\": coordinates = point(o.coordinates); break;\n      case \"MultiPoint\": coordinates = o.coordinates.map(point); break;\n      case \"LineString\": coordinates = line(o.arcs); break;\n      case \"MultiLineString\": coordinates = o.arcs.map(line); break;\n      case \"Polygon\": coordinates = polygon(o.arcs); break;\n      case \"MultiPolygon\": coordinates = o.arcs.map(polygon); break;\n      default: return null;\n    }\n    return {type: type, coordinates: coordinates};\n  }\n\n  return geometry(o);\n}\n\nvar stitch = function(topology, arcs) {\n  var stitchedArcs = {},\n      fragmentByStart = {},\n      fragmentByEnd = {},\n      fragments = [],\n      emptyIndex = -1;\n\n  // Stitch empty arcs first, since they may be subsumed by other arcs.\n  arcs.forEach(function(i, j) {\n    var arc = topology.arcs[i < 0 ? ~i : i], t;\n    if (arc.length < 3 && !arc[1][0] && !arc[1][1]) {\n      t = arcs[++emptyIndex], arcs[emptyIndex] = i, arcs[j] = t;\n    }\n  });\n\n  arcs.forEach(function(i) {\n    var e = ends(i),\n        start = e[0],\n        end = e[1],\n        f, g;\n\n    if (f = fragmentByEnd[start]) {\n      delete fragmentByEnd[f.end];\n      f.push(i);\n      f.end = end;\n      if (g = fragmentByStart[end]) {\n        delete fragmentByStart[g.start];\n        var fg = g === f ? f : f.concat(g);\n        fragmentByStart[fg.start = f.start] = fragmentByEnd[fg.end = g.end] = fg;\n      } else {\n        fragmentByStart[f.start] = fragmentByEnd[f.end] = f;\n      }\n    } else if (f = fragmentByStart[end]) {\n      delete fragmentByStart[f.start];\n      f.unshift(i);\n      f.start = start;\n      if (g = fragmentByEnd[start]) {\n        delete fragmentByEnd[g.end];\n        var gf = g === f ? f : g.concat(f);\n        fragmentByStart[gf.start = g.start] = fragmentByEnd[gf.end = f.end] = gf;\n      } else {\n        fragmentByStart[f.start] = fragmentByEnd[f.end] = f;\n      }\n    } else {\n      f = [i];\n      fragmentByStart[f.start = start] = fragmentByEnd[f.end = end] = f;\n    }\n  });\n\n  function ends(i) {\n    var arc = topology.arcs[i < 0 ? ~i : i], p0 = arc[0], p1;\n    if (topology.transform) p1 = [0, 0], arc.forEach(function(dp) { p1[0] += dp[0], p1[1] += dp[1]; });\n    else p1 = arc[arc.length - 1];\n    return i < 0 ? [p1, p0] : [p0, p1];\n  }\n\n  function flush(fragmentByEnd, fragmentByStart) {\n    for (var k in fragmentByEnd) {\n      var f = fragmentByEnd[k];\n      delete fragmentByStart[f.start];\n      delete f.start;\n      delete f.end;\n      f.forEach(function(i) { stitchedArcs[i < 0 ? ~i : i] = 1; });\n      fragments.push(f);\n    }\n  }\n\n  flush(fragmentByEnd, fragmentByStart);\n  flush(fragmentByStart, fragmentByEnd);\n  arcs.forEach(function(i) { if (!stitchedArcs[i < 0 ? ~i : i]) fragments.push([i]); });\n\n  return fragments;\n};\n\nvar mesh = function(topology) {\n  return object(topology, meshArcs.apply(this, arguments));\n};\n\nfunction meshArcs(topology, object$$1, filter) {\n  var arcs, i, n;\n  if (arguments.length > 1) arcs = extractArcs(topology, object$$1, filter);\n  else for (i = 0, arcs = new Array(n = topology.arcs.length); i < n; ++i) arcs[i] = i;\n  return {type: \"MultiLineString\", arcs: stitch(topology, arcs)};\n}\n\nfunction extractArcs(topology, object$$1, filter) {\n  var arcs = [],\n      geomsByArc = [],\n      geom;\n\n  function extract0(i) {\n    var j = i < 0 ? ~i : i;\n    (geomsByArc[j] || (geomsByArc[j] = [])).push({i: i, g: geom});\n  }\n\n  function extract1(arcs) {\n    arcs.forEach(extract0);\n  }\n\n  function extract2(arcs) {\n    arcs.forEach(extract1);\n  }\n\n  function extract3(arcs) {\n    arcs.forEach(extract2);\n  }\n\n  function geometry(o) {\n    switch (geom = o, o.type) {\n      case \"GeometryCollection\": o.geometries.forEach(geometry); break;\n      case \"LineString\": extract1(o.arcs); break;\n      case \"MultiLineString\": case \"Polygon\": extract2(o.arcs); break;\n      case \"MultiPolygon\": extract3(o.arcs); break;\n    }\n  }\n\n  geometry(object$$1);\n\n  geomsByArc.forEach(filter == null\n      ? function(geoms) { arcs.push(geoms[0].i); }\n      : function(geoms) { if (filter(geoms[0].g, geoms[geoms.length - 1].g)) arcs.push(geoms[0].i); });\n\n  return arcs;\n}\n\nfunction planarRingArea(ring) {\n  var i = -1, n = ring.length, a, b = ring[n - 1], area = 0;\n  while (++i < n) a = b, b = ring[i], area += a[0] * b[1] - a[1] * b[0];\n  return Math.abs(area); // Note: doubled area!\n}\n\nvar merge = function(topology) {\n  return object(topology, mergeArcs.apply(this, arguments));\n};\n\nfunction mergeArcs(topology, objects) {\n  var polygonsByArc = {},\n      polygons = [],\n      groups = [];\n\n  objects.forEach(geometry);\n\n  function geometry(o) {\n    switch (o.type) {\n      case \"GeometryCollection\": o.geometries.forEach(geometry); break;\n      case \"Polygon\": extract(o.arcs); break;\n      case \"MultiPolygon\": o.arcs.forEach(extract); break;\n    }\n  }\n\n  function extract(polygon) {\n    polygon.forEach(function(ring) {\n      ring.forEach(function(arc) {\n        (polygonsByArc[arc = arc < 0 ? ~arc : arc] || (polygonsByArc[arc] = [])).push(polygon);\n      });\n    });\n    polygons.push(polygon);\n  }\n\n  function area(ring) {\n    return planarRingArea(object(topology, {type: \"Polygon\", arcs: [ring]}).coordinates[0]);\n  }\n\n  polygons.forEach(function(polygon) {\n    if (!polygon._) {\n      var group = [],\n          neighbors = [polygon];\n      polygon._ = 1;\n      groups.push(group);\n      while (polygon = neighbors.pop()) {\n        group.push(polygon);\n        polygon.forEach(function(ring) {\n          ring.forEach(function(arc) {\n            polygonsByArc[arc < 0 ? ~arc : arc].forEach(function(polygon) {\n              if (!polygon._) {\n                polygon._ = 1;\n                neighbors.push(polygon);\n              }\n            });\n          });\n        });\n      }\n    }\n  });\n\n  polygons.forEach(function(polygon) {\n    delete polygon._;\n  });\n\n  return {\n    type: \"MultiPolygon\",\n    arcs: groups.map(function(polygons) {\n      var arcs = [], n;\n\n      // Extract the exterior (unique) arcs.\n      polygons.forEach(function(polygon) {\n        polygon.forEach(function(ring) {\n          ring.forEach(function(arc) {\n            if (polygonsByArc[arc < 0 ? ~arc : arc].length < 2) {\n              arcs.push(arc);\n            }\n          });\n        });\n      });\n\n      // Stitch the arcs into one or more rings.\n      arcs = stitch(topology, arcs);\n\n      // If more than one ring is returned,\n      // at most one of these rings can be the exterior;\n      // choose the one with the greatest absolute area.\n      if ((n = arcs.length) > 1) {\n        for (var i = 1, k = area(arcs[0]), ki, t; i < n; ++i) {\n          if ((ki = area(arcs[i])) > k) {\n            t = arcs[0], arcs[0] = arcs[i], arcs[i] = t, k = ki;\n          }\n        }\n      }\n\n      return arcs;\n    })\n  };\n}\n\nvar bisect = function(a, x) {\n  var lo = 0, hi = a.length;\n  while (lo < hi) {\n    var mid = lo + hi >>> 1;\n    if (a[mid] < x) lo = mid + 1;\n    else hi = mid;\n  }\n  return lo;\n};\n\nvar neighbors = function(objects) {\n  var indexesByArc = {}, // arc index -> array of object indexes\n      neighbors = objects.map(function() { return []; });\n\n  function line(arcs, i) {\n    arcs.forEach(function(a) {\n      if (a < 0) a = ~a;\n      var o = indexesByArc[a];\n      if (o) o.push(i);\n      else indexesByArc[a] = [i];\n    });\n  }\n\n  function polygon(arcs, i) {\n    arcs.forEach(function(arc) { line(arc, i); });\n  }\n\n  function geometry(o, i) {\n    if (o.type === \"GeometryCollection\") o.geometries.forEach(function(o) { geometry(o, i); });\n    else if (o.type in geometryType) geometryType[o.type](o.arcs, i);\n  }\n\n  var geometryType = {\n    LineString: line,\n    MultiLineString: polygon,\n    Polygon: polygon,\n    MultiPolygon: function(arcs, i) { arcs.forEach(function(arc) { polygon(arc, i); }); }\n  };\n\n  objects.forEach(geometry);\n\n  for (var i in indexesByArc) {\n    for (var indexes = indexesByArc[i], m = indexes.length, j = 0; j < m; ++j) {\n      for (var k = j + 1; k < m; ++k) {\n        var ij = indexes[j], ik = indexes[k], n;\n        if ((n = neighbors[ij])[i = bisect(n, ik)] !== ik) n.splice(i, 0, ik);\n        if ((n = neighbors[ik])[i = bisect(n, ij)] !== ij) n.splice(i, 0, ij);\n      }\n    }\n  }\n\n  return neighbors;\n};\n\nvar quantize = function(topology, n) {\n  if (!((n = Math.floor(n)) >= 2)) throw new Error(\"n must be \\u22652\");\n  if (topology.transform) throw new Error(\"already quantized\");\n  var bb = bbox(topology), name,\n      dx = bb[0], kx = (bb[2] - dx) / (n - 1) || 1,\n      dy = bb[1], ky = (bb[3] - dy) / (n - 1) || 1;\n\n  function quantizePoint(p) {\n    p[0] = Math.round((p[0] - dx) / kx);\n    p[1] = Math.round((p[1] - dy) / ky);\n  }\n\n  function quantizeGeometry(o) {\n    switch (o.type) {\n      case \"GeometryCollection\": o.geometries.forEach(quantizeGeometry); break;\n      case \"Point\": quantizePoint(o.coordinates); break;\n      case \"MultiPoint\": o.coordinates.forEach(quantizePoint); break;\n    }\n  }\n\n  topology.arcs.forEach(function(arc) {\n    var i = 1,\n        j = 1,\n        n = arc.length,\n        pi = arc[0],\n        x0 = pi[0] = Math.round((pi[0] - dx) / kx),\n        y0 = pi[1] = Math.round((pi[1] - dy) / ky),\n        pj,\n        x1,\n        y1;\n\n    for (; i < n; ++i) {\n      pi = arc[i];\n      x1 = Math.round((pi[0] - dx) / kx);\n      y1 = Math.round((pi[1] - dy) / ky);\n      if (x1 !== x0 || y1 !== y0) {\n        pj = arc[j++];\n        pj[0] = x1 - x0, x0 = x1;\n        pj[1] = y1 - y0, y0 = y1;\n      }\n    }\n\n    if (j < 2) {\n      pj = arc[j++];\n      pj[0] = 0;\n      pj[1] = 0;\n    }\n\n    arc.length = j;\n  });\n\n  for (name in topology.objects) {\n    quantizeGeometry(topology.objects[name]);\n  }\n\n  topology.transform = {\n    scale: [kx, ky],\n    translate: [dx, dy]\n  };\n\n  return topology;\n};\n\nvar untransform = function(topology) {\n  if ((transform = topology.transform) == null) return identity;\n  var transform,\n      x0,\n      y0,\n      kx = transform.scale[0],\n      ky = transform.scale[1],\n      dx = transform.translate[0],\n      dy = transform.translate[1];\n  return function(point, i) {\n    if (!i) x0 = y0 = 0;\n    var x1 = Math.round((point[0] - dx) / kx),\n        y1 = Math.round((point[1] - dy) / ky);\n    point[0] = x1 - x0, x0 = x1;\n    point[1] = y1 - y0, y0 = y1;\n    return point;\n  };\n};\n\nfunction planarTriangleArea(triangle) {\n  var a = triangle[0], b = triangle[1], c = triangle[2];\n  return Math.abs((a[0] - c[0]) * (b[1] - a[1]) - (a[0] - b[0]) * (c[1] - a[1]));\n}\n\nfunction planarRingArea$1(ring) {\n  var i = -1, n = ring.length, a, b = ring[n - 1], area = 0;\n  while (++i < n) a = b, b = ring[i], area += a[0] * b[1] - a[1] * b[0];\n  return Math.abs(area) / 2;\n}\n\nvar filterWeight = function(topology, minWeight, weight) {\n  minWeight = minWeight == null ? Number.MIN_VALUE : +minWeight;\n\n  if (weight == null) weight = planarRingArea$1;\n\n  return function(ring, interior) {\n    return weight(feature(topology, {type: \"Polygon\", arcs: [ring]}).geometry.coordinates[0], interior) >= minWeight;\n  };\n};\n\nfunction compare(a, b) {\n  return a[1][2] - b[1][2];\n}\n\nvar newHeap = function() {\n  var heap = {},\n      array = [],\n      size = 0;\n\n  heap.push = function(object) {\n    up(array[object._ = size] = object, size++);\n    return size;\n  };\n\n  heap.pop = function() {\n    if (size <= 0) return;\n    var removed = array[0], object;\n    if (--size > 0) object = array[size], down(array[object._ = 0] = object, 0);\n    return removed;\n  };\n\n  heap.remove = function(removed) {\n    var i = removed._, object;\n    if (array[i] !== removed) return; // invalid request\n    if (i !== --size) object = array[size], (compare(object, removed) < 0 ? up : down)(array[object._ = i] = object, i);\n    return i;\n  };\n\n  function up(object, i) {\n    while (i > 0) {\n      var j = ((i + 1) >> 1) - 1,\n          parent = array[j];\n      if (compare(object, parent) >= 0) break;\n      array[parent._ = i] = parent;\n      array[object._ = i = j] = object;\n    }\n  }\n\n  function down(object, i) {\n    while (true) {\n      var r = (i + 1) << 1,\n          l = r - 1,\n          j = i,\n          child = array[j];\n      if (l < size && compare(array[l], child) < 0) child = array[j = l];\n      if (r < size && compare(array[r], child) < 0) child = array[j = r];\n      if (j === i) break;\n      array[child._ = i] = child;\n      array[object._ = i = j] = object;\n    }\n  }\n\n  return heap;\n};\n\nvar presimplify = function(topology, weight) {\n  var absolute = transform(topology),\n      relative = untransform(topology),\n      heap = newHeap();\n\n  if (weight == null) weight = planarTriangleArea;\n\n  topology.arcs.forEach(function(arc) {\n    var triangles = [],\n        maxWeight = 0,\n        triangle,\n        i,\n        n;\n\n    arc.forEach(absolute);\n\n    for (i = 1, n = arc.length - 1; i < n; ++i) {\n      triangle = arc.slice(i - 1, i + 2);\n      triangle[1][2] = weight(triangle);\n      triangles.push(triangle);\n      heap.push(triangle);\n    }\n\n    // Always keep the arc endpoints!\n    arc[0][2] = arc[n][2] = Infinity;\n\n    for (i = 0, n = triangles.length; i < n; ++i) {\n      triangle = triangles[i];\n      triangle.previous = triangles[i - 1];\n      triangle.next = triangles[i + 1];\n    }\n\n    while (triangle = heap.pop()) {\n      var previous = triangle.previous,\n          next = triangle.next;\n\n      // If the weight of the current point is less than that of the previous\n      // point to be eliminated, use the latter’s weight instead. This ensures\n      // that the current point cannot be eliminated without eliminating\n      // previously- eliminated points.\n      if (triangle[1][2] < maxWeight) triangle[1][2] = maxWeight;\n      else maxWeight = triangle[1][2];\n\n      if (previous) {\n        previous.next = next;\n        previous[2] = triangle[2];\n        update(previous);\n      }\n\n      if (next) {\n        next.previous = previous;\n        next[0] = triangle[0];\n        update(next);\n      }\n    }\n\n    arc.forEach(relative);\n  });\n\n  function update(triangle) {\n    heap.remove(triangle);\n    triangle[1][2] = weight(triangle);\n    heap.push(triangle);\n  }\n\n  return topology;\n};\n\nvar quantile = function(topology, p) {\n  var array = [];\n\n  topology.arcs.forEach(function(arc) {\n    arc.forEach(function(point) {\n      if (isFinite(point[2])) { // Ignore endpoints, whose weight is Infinity.\n        array.push(point[2]);\n      }\n    });\n  });\n\n  return array.length && quantile$1(array.sort(descending), p);\n};\n\nfunction quantile$1(array, p) {\n  if (!(n = array.length)) return;\n  if ((p = +p) <= 0 || n < 2) return array[0];\n  if (p >= 1) return array[n - 1];\n  var n,\n      h = (n - 1) * p,\n      i = Math.floor(h),\n      a = array[i],\n      b = array[i + 1];\n  return a + (b - a) * (h - i);\n}\n\nfunction descending(a, b) {\n  return b - a;\n}\n\nvar simplify = function(topology, minWeight) {\n  minWeight = minWeight == null ? Number.MIN_VALUE : +minWeight;\n\n  // Remove points whose weight is less than the minimum weight.\n  topology.arcs.forEach(topology.transform ? function(arc) {\n    var dx = 0,\n        dy = 0, // accumulate removed points\n        i = -1,\n        j = -1,\n        n = arc.length,\n        source,\n        target;\n\n    while (++i < n) {\n      source = arc[i];\n      if (source[2] >= minWeight) {\n        target = arc[++j];\n        target[0] = source[0] + dx;\n        target[1] = source[1] + dy;\n        dx = dy = 0;\n      } else {\n        dx += source[0];\n        dy += source[1];\n      }\n    }\n\n    arc.length = ++j;\n  } : function(arc) {\n    var i = -1,\n        j = -1,\n        n = arc.length,\n        point;\n\n    while (++i < n) {\n      point = arc[i];\n      if (point[2] >= minWeight) {\n        arc[++j] = point;\n      }\n    }\n\n    arc.length = ++j;\n  });\n\n  // Remove the computed weight for each point, and remove coincident points.\n  // This is done as a separate pass because some coordinates may be shared\n  // between arcs (such as the last point and first point of a cut line).\n  // If the entire arc is empty, retain at least two points (per spec).\n  topology.arcs.forEach(topology.transform ? function(arc) {\n    var i = 0,\n        j = 0,\n        n = arc.length,\n        p = arc[0];\n    p.length = 2;\n    while (++i < n) {\n      p = arc[i];\n      p.length = 2;\n      if (p[0] || p[1]) arc[++j] = p;\n    }\n    arc.length = (j || 1) + 1;\n  } : function(arc) {\n    var i = 0,\n        j = 0,\n        n = arc.length,\n        p = arc[0],\n        x0 = p[0],\n        y0 = p[1],\n        x1,\n        y1;\n    p.length = 2;\n    while (++i < n) {\n      p = arc[i], x1 = p[0], y1 = p[1];\n      p.length = 2;\n      if (x0 !== x1 || y0 !== y1) arc[++j] = p, x0 = x1, y0 = y1;\n    }\n    arc.length = (j || 1) + 1;\n  });\n\n  return topology;\n};\n\nvar pi = Math.PI;\nvar tau = 2 * pi;\nvar fourPi = 4 * pi;\nvar radians = pi / 180;\nvar abs = Math.abs;\nvar atan = Math.atan;\nvar atan2 = Math.atan2;\nvar cos = Math.cos;\nvar max = Math.max;\nvar sin = Math.sin;\nvar sqrt = Math.sqrt;\nvar tan = Math.tan;\n\nfunction sphericalRingArea(ring, interior) {\n  if (!ring.length) return 0;\n  var sum = 0,\n      point = ring[0],\n      lambda0, lambda1 = point[0] * radians, delta,\n      phi1 = (point[1] * radians + tau) / 2,\n      cosPhi0, cosPhi1 = cos(phi1),\n      sinPhi0, sinPhi1 = sin(phi1),\n      i, n, k;\n\n  for (i = 1, n = ring.length; i < n; ++i) {\n    point = ring[i];\n    lambda0 = lambda1, lambda1 = point[0] * radians, delta = lambda1 - lambda0;\n    phi1 = (point[1] * radians + tau) / 2;\n    cosPhi0 = cosPhi1, cosPhi1 = cos(phi1);\n    sinPhi0 = sinPhi1, sinPhi1 = sin(phi1);\n\n    // Spherical excess E for a spherical triangle with vertices: south pole,\n    // previous point, current point. Uses a formula derived from Cagnoli’s\n    // theorem. See Todhunter, Spherical Trig. (1871), Sec. 103, Eq. (2).\n    k = sinPhi0 * sinPhi1;\n    sum += atan2(k * sin(delta), cosPhi0 * cosPhi1 + k * cos(delta));\n  }\n\n  sum = 2 * (sum > pi ? sum - tau : sum < -pi ? sum + tau : sum);\n  if (interior) sum *= -1;\n  return sum < 0 ? sum + fourPi : sum;\n}\n\nfunction sphericalTriangleArea(t) {\n  var lambda0 = t[0][0] * radians, phi0 = t[0][1] * radians, cosPhi0 = cos(phi0), sinPhi0 = sin(phi0),\n      lambda1 = t[1][0] * radians, phi1 = t[1][1] * radians, cosPhi1 = cos(phi1), sinPhi1 = sin(phi1),\n      lambda2 = t[2][0] * radians, phi2 = t[2][1] * radians, cosPhi2 = cos(phi2), sinPhi2 = sin(phi2),\n      a = distance(lambda0, cosPhi0, sinPhi0, lambda1, cosPhi1, sinPhi1),\n      b = distance(lambda1, cosPhi1, sinPhi1, lambda2, cosPhi2, sinPhi2),\n      c = distance(lambda2, cosPhi2, sinPhi2, lambda0, cosPhi0, sinPhi0),\n      s = (a + b + c) / 2;\n  return 4 * atan(sqrt(max(0, tan(s / 2) * tan((s - a) / 2) * tan((s - b) / 2) * tan((s - c) / 2))));\n}\n\nfunction distance(lambda0, sinPhi0, cosPhi0, lambda1, sinPhi1, cosPhi1) {\n  var delta = abs(lambda1 - lambda0),\n      cosDelta = cos(delta),\n      sinDelta = sin(delta),\n      x = cosPhi1 * sinDelta,\n      y = cosPhi0 * sinPhi1 - sinPhi0 * cosPhi1 * cosDelta,\n      z = sinPhi0 * sinPhi1 + cosPhi0 * cosPhi1 * cosDelta;\n  return atan2(sqrt(x * x + y * y), z);\n}\n\nexports.topology = topology;\nexports.filter = filter;\nexports.filterAttached = filterAttached;\nexports.filterWeight = filterWeight;\nexports.planarRingArea = planarRingArea$1;\nexports.planarTriangleArea = planarTriangleArea;\nexports.presimplify = presimplify;\nexports.quantile = quantile;\nexports.simplify = simplify;\nexports.sphericalRingArea = sphericalRingArea;\nexports.sphericalTriangleArea = sphericalTriangleArea;\nexports.bbox = bbox;\nexports.feature = feature;\nexports.merge = merge;\nexports.mergeArcs = mergeArcs;\nexports.mesh = mesh;\nexports.meshArcs = meshArcs;\nexports.neighbors = neighbors;\nexports.quantize = quantize;\nexports.transform = transform;\nexports.untransform = untransform;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n/***/ }),\n/* 105 */,\n/* 106 */,\n/* 107 */,\n/* 108 */,\n/* 109 */,\n/* 110 */,\n/* 111 */,\n/* 112 */,\n/* 113 */,\n/* 114 */,\n/* 115 */,\n/* 116 */,\n/* 117 */,\n/* 118 */,\n/* 119 */,\n/* 120 */,\n/* 121 */,\n/* 122 */,\n/* 123 */,\n/* 124 */,\n/* 125 */,\n/* 126 */,\n/* 127 */,\n/* 128 */,\n/* 129 */,\n/* 130 */,\n/* 131 */,\n/* 132 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n  * vue-router v2.2.1\n  * (c) 2017 Evan You\n  * @license MIT\n  */\n\n\n/*  */\n\nfunction assert (condition, message) {\n  if (!condition) {\n    throw new Error((\"[vue-router] \" + message))\n  }\n}\n\nfunction warn (condition, message) {\n  if (!condition) {\n    typeof console !== 'undefined' && console.warn((\"[vue-router] \" + message));\n  }\n}\n\nvar View = {\n  name: 'router-view',\n  functional: true,\n  props: {\n    name: {\n      type: String,\n      default: 'default'\n    }\n  },\n  render: function render (h, ref) {\n    var props = ref.props;\n    var children = ref.children;\n    var parent = ref.parent;\n    var data = ref.data;\n\n    data.routerView = true;\n\n    var name = props.name;\n    var route = parent.$route;\n    var cache = parent._routerViewCache || (parent._routerViewCache = {});\n\n    // determine current view depth, also check to see if the tree\n    // has been toggled inactive but kept-alive.\n    var depth = 0;\n    var inactive = false;\n    while (parent) {\n      if (parent.$vnode && parent.$vnode.data.routerView) {\n        depth++;\n      }\n      if (parent._inactive) {\n        inactive = true;\n      }\n      parent = parent.$parent;\n    }\n    data.routerViewDepth = depth;\n\n    // render previous view if the tree is inactive and kept-alive\n    if (inactive) {\n      return h(cache[name], data, children)\n    }\n\n    var matched = route.matched[depth];\n    // render empty node if no matched route\n    if (!matched) {\n      cache[name] = null;\n      return h()\n    }\n\n    var component = cache[name] = matched.components[name];\n\n    // inject instance registration hooks\n    var hooks = data.hook || (data.hook = {});\n    hooks.init = function (vnode) {\n      matched.instances[name] = vnode.child;\n    };\n    hooks.prepatch = function (oldVnode, vnode) {\n      matched.instances[name] = vnode.child;\n    };\n    hooks.destroy = function (vnode) {\n      if (matched.instances[name] === vnode.child) {\n        matched.instances[name] = undefined;\n      }\n    };\n\n    // resolve props\n    data.props = resolveProps(route, matched.props && matched.props[name]);\n\n    return h(component, data, children)\n  }\n};\n\nfunction resolveProps (route, config) {\n  switch (typeof config) {\n    case 'undefined':\n      return\n    case 'object':\n      return config\n    case 'function':\n      return config(route)\n    case 'boolean':\n      return config ? route.params : undefined\n    default:\n      warn(false, (\"props in \\\"\" + (route.path) + \"\\\" is a \" + (typeof config) + \", expecting an object, function or boolean.\"));\n  }\n}\n\n/*  */\n\nvar encodeReserveRE = /[!'()*]/g;\nvar encodeReserveReplacer = function (c) { return '%' + c.charCodeAt(0).toString(16); };\nvar commaRE = /%2C/g;\n\n// fixed encodeURIComponent which is more comformant to RFC3986:\n// - escapes [!'()*]\n// - preserve commas\nvar encode = function (str) { return encodeURIComponent(str)\n  .replace(encodeReserveRE, encodeReserveReplacer)\n  .replace(commaRE, ','); };\n\nvar decode = decodeURIComponent;\n\nfunction resolveQuery (\n  query,\n  extraQuery\n) {\n  if ( extraQuery === void 0 ) extraQuery = {};\n\n  if (query) {\n    var parsedQuery;\n    try {\n      parsedQuery = parseQuery(query);\n    } catch (e) {\n      \"production\" !== 'production' && warn(false, e.message);\n      parsedQuery = {};\n    }\n    for (var key in extraQuery) {\n      parsedQuery[key] = extraQuery[key];\n    }\n    return parsedQuery\n  } else {\n    return extraQuery\n  }\n}\n\nfunction parseQuery (query) {\n  var res = {};\n\n  query = query.trim().replace(/^(\\?|#|&)/, '');\n\n  if (!query) {\n    return res\n  }\n\n  query.split('&').forEach(function (param) {\n    var parts = param.replace(/\\+/g, ' ').split('=');\n    var key = decode(parts.shift());\n    var val = parts.length > 0\n      ? decode(parts.join('='))\n      : null;\n\n    if (res[key] === undefined) {\n      res[key] = val;\n    } else if (Array.isArray(res[key])) {\n      res[key].push(val);\n    } else {\n      res[key] = [res[key], val];\n    }\n  });\n\n  return res\n}\n\nfunction stringifyQuery (obj) {\n  var res = obj ? Object.keys(obj).map(function (key) {\n    var val = obj[key];\n\n    if (val === undefined) {\n      return ''\n    }\n\n    if (val === null) {\n      return encode(key)\n    }\n\n    if (Array.isArray(val)) {\n      var result = [];\n      val.slice().forEach(function (val2) {\n        if (val2 === undefined) {\n          return\n        }\n        if (val2 === null) {\n          result.push(encode(key));\n        } else {\n          result.push(encode(key) + '=' + encode(val2));\n        }\n      });\n      return result.join('&')\n    }\n\n    return encode(key) + '=' + encode(val)\n  }).filter(function (x) { return x.length > 0; }).join('&') : null;\n  return res ? (\"?\" + res) : ''\n}\n\n/*  */\n\nvar trailingSlashRE = /\\/?$/;\n\nfunction createRoute (\n  record,\n  location,\n  redirectedFrom\n) {\n  var route = {\n    name: location.name || (record && record.name),\n    meta: (record && record.meta) || {},\n    path: location.path || '/',\n    hash: location.hash || '',\n    query: location.query || {},\n    params: location.params || {},\n    fullPath: getFullPath(location),\n    matched: record ? formatMatch(record) : []\n  };\n  if (redirectedFrom) {\n    route.redirectedFrom = getFullPath(redirectedFrom);\n  }\n  return Object.freeze(route)\n}\n\n// the starting route that represents the initial state\nvar START = createRoute(null, {\n  path: '/'\n});\n\nfunction formatMatch (record) {\n  var res = [];\n  while (record) {\n    res.unshift(record);\n    record = record.parent;\n  }\n  return res\n}\n\nfunction getFullPath (ref) {\n  var path = ref.path;\n  var query = ref.query; if ( query === void 0 ) query = {};\n  var hash = ref.hash; if ( hash === void 0 ) hash = '';\n\n  return (path || '/') + stringifyQuery(query) + hash\n}\n\nfunction isSameRoute (a, b) {\n  if (b === START) {\n    return a === b\n  } else if (!b) {\n    return false\n  } else if (a.path && b.path) {\n    return (\n      a.path.replace(trailingSlashRE, '') === b.path.replace(trailingSlashRE, '') &&\n      a.hash === b.hash &&\n      isObjectEqual(a.query, b.query)\n    )\n  } else if (a.name && b.name) {\n    return (\n      a.name === b.name &&\n      a.hash === b.hash &&\n      isObjectEqual(a.query, b.query) &&\n      isObjectEqual(a.params, b.params)\n    )\n  } else {\n    return false\n  }\n}\n\nfunction isObjectEqual (a, b) {\n  if ( a === void 0 ) a = {};\n  if ( b === void 0 ) b = {};\n\n  var aKeys = Object.keys(a);\n  var bKeys = Object.keys(b);\n  if (aKeys.length !== bKeys.length) {\n    return false\n  }\n  return aKeys.every(function (key) { return String(a[key]) === String(b[key]); })\n}\n\nfunction isIncludedRoute (current, target) {\n  return (\n    current.path.replace(trailingSlashRE, '/').indexOf(\n      target.path.replace(trailingSlashRE, '/')\n    ) === 0 &&\n    (!target.hash || current.hash === target.hash) &&\n    queryIncludes(current.query, target.query)\n  )\n}\n\nfunction queryIncludes (current, target) {\n  for (var key in target) {\n    if (!(key in current)) {\n      return false\n    }\n  }\n  return true\n}\n\n/*  */\n\n// work around weird flow bug\nvar toTypes = [String, Object];\nvar eventTypes = [String, Array];\n\nvar Link = {\n  name: 'router-link',\n  props: {\n    to: {\n      type: toTypes,\n      required: true\n    },\n    tag: {\n      type: String,\n      default: 'a'\n    },\n    exact: Boolean,\n    append: Boolean,\n    replace: Boolean,\n    activeClass: String,\n    event: {\n      type: eventTypes,\n      default: 'click'\n    }\n  },\n  render: function render (h) {\n    var this$1 = this;\n\n    var router = this.$router;\n    var current = this.$route;\n    var ref = router.resolve(this.to, current, this.append);\n    var location = ref.location;\n    var route = ref.route;\n    var href = ref.href;\n    var classes = {};\n    var activeClass = this.activeClass || router.options.linkActiveClass || 'router-link-active';\n    var compareTarget = location.path ? createRoute(null, location) : route;\n    classes[activeClass] = this.exact\n      ? isSameRoute(current, compareTarget)\n      : isIncludedRoute(current, compareTarget);\n\n    var handler = function (e) {\n      if (guardEvent(e)) {\n        if (this$1.replace) {\n          router.replace(location);\n        } else {\n          router.push(location);\n        }\n      }\n    };\n\n    var on = { click: guardEvent };\n    if (Array.isArray(this.event)) {\n      this.event.forEach(function (e) { on[e] = handler; });\n    } else {\n      on[this.event] = handler;\n    }\n\n    var data = {\n      class: classes\n    };\n\n    if (this.tag === 'a') {\n      data.on = on;\n      data.attrs = { href: href };\n    } else {\n      // find the first <a> child and apply listener and href\n      var a = findAnchor(this.$slots.default);\n      if (a) {\n        // in case the <a> is a static node\n        a.isStatic = false;\n        var extend = _Vue.util.extend;\n        var aData = a.data = extend({}, a.data);\n        aData.on = on;\n        var aAttrs = a.data.attrs = extend({}, a.data.attrs);\n        aAttrs.href = href;\n      } else {\n        // doesn't have <a> child, apply listener to self\n        data.on = on;\n      }\n    }\n\n    return h(this.tag, data, this.$slots.default)\n  }\n};\n\nfunction guardEvent (e) {\n  // don't redirect with control keys\n  if (e.metaKey || e.ctrlKey || e.shiftKey) { return }\n  // don't redirect when preventDefault called\n  if (e.defaultPrevented) { return }\n  // don't redirect on right click\n  if (e.button !== undefined && e.button !== 0) { return }\n  // don't redirect if `target=\"_blank\"`\n  if (e.target && e.target.getAttribute) {\n    var target = e.target.getAttribute('target');\n    if (/\\b_blank\\b/i.test(target)) { return }\n  }\n  // this may be a Weex event which doesn't have this method\n  if (e.preventDefault) {\n    e.preventDefault();\n  }\n  return true\n}\n\nfunction findAnchor (children) {\n  if (children) {\n    var child;\n    for (var i = 0; i < children.length; i++) {\n      child = children[i];\n      if (child.tag === 'a') {\n        return child\n      }\n      if (child.children && (child = findAnchor(child.children))) {\n        return child\n      }\n    }\n  }\n}\n\nvar _Vue;\n\nfunction install (Vue) {\n  if (install.installed) { return }\n  install.installed = true;\n\n  _Vue = Vue;\n\n  Object.defineProperty(Vue.prototype, '$router', {\n    get: function get () { return this.$root._router }\n  });\n\n  Object.defineProperty(Vue.prototype, '$route', {\n    get: function get () { return this.$root._route }\n  });\n\n  Vue.mixin({\n    beforeCreate: function beforeCreate () {\n      if (this.$options.router) {\n        this._router = this.$options.router;\n        this._router.init(this);\n        Vue.util.defineReactive(this, '_route', this._router.history.current);\n      }\n    }\n  });\n\n  Vue.component('router-view', View);\n  Vue.component('router-link', Link);\n\n  var strats = Vue.config.optionMergeStrategies;\n  // use the same hook merging strategy for route hooks\n  strats.beforeRouteEnter = strats.beforeRouteLeave = strats.created;\n}\n\n/*  */\n\nvar inBrowser = typeof window !== 'undefined';\n\n/*  */\n\nfunction resolvePath (\n  relative,\n  base,\n  append\n) {\n  if (relative.charAt(0) === '/') {\n    return relative\n  }\n\n  if (relative.charAt(0) === '?' || relative.charAt(0) === '#') {\n    return base + relative\n  }\n\n  var stack = base.split('/');\n\n  // remove trailing segment if:\n  // - not appending\n  // - appending to trailing slash (last segment is empty)\n  if (!append || !stack[stack.length - 1]) {\n    stack.pop();\n  }\n\n  // resolve relative path\n  var segments = relative.replace(/^\\//, '').split('/');\n  for (var i = 0; i < segments.length; i++) {\n    var segment = segments[i];\n    if (segment === '.') {\n      continue\n    } else if (segment === '..') {\n      stack.pop();\n    } else {\n      stack.push(segment);\n    }\n  }\n\n  // ensure leading slash\n  if (stack[0] !== '') {\n    stack.unshift('');\n  }\n\n  return stack.join('/')\n}\n\nfunction parsePath (path) {\n  var hash = '';\n  var query = '';\n\n  var hashIndex = path.indexOf('#');\n  if (hashIndex >= 0) {\n    hash = path.slice(hashIndex);\n    path = path.slice(0, hashIndex);\n  }\n\n  var queryIndex = path.indexOf('?');\n  if (queryIndex >= 0) {\n    query = path.slice(queryIndex + 1);\n    path = path.slice(0, queryIndex);\n  }\n\n  return {\n    path: path,\n    query: query,\n    hash: hash\n  }\n}\n\nfunction cleanPath (path) {\n  return path.replace(/\\/\\//g, '/')\n}\n\n/*  */\n\nfunction createRouteMap (\n  routes,\n  oldPathMap,\n  oldNameMap\n) {\n  var pathMap = oldPathMap || Object.create(null);\n  var nameMap = oldNameMap || Object.create(null);\n\n  routes.forEach(function (route) {\n    addRouteRecord(pathMap, nameMap, route);\n  });\n\n  return {\n    pathMap: pathMap,\n    nameMap: nameMap\n  }\n}\n\nfunction addRouteRecord (\n  pathMap,\n  nameMap,\n  route,\n  parent,\n  matchAs\n) {\n  var path = route.path;\n  var name = route.name;\n  if (false) {\n    assert(path != null, \"\\\"path\\\" is required in a route configuration.\");\n    assert(\n      typeof route.component !== 'string',\n      \"route config \\\"component\\\" for path: \" + (String(path || name)) + \" cannot be a \" +\n      \"string id. Use an actual component instead.\"\n    );\n  }\n\n  var record = {\n    path: normalizePath(path, parent),\n    components: route.components || { default: route.component },\n    instances: {},\n    name: name,\n    parent: parent,\n    matchAs: matchAs,\n    redirect: route.redirect,\n    beforeEnter: route.beforeEnter,\n    meta: route.meta || {},\n    props: route.props == null\n      ? {}\n      : route.components\n        ? route.props\n        : { default: route.props }\n  };\n\n  if (route.children) {\n    // Warn if route is named and has a default child route.\n    // If users navigate to this route by name, the default child will\n    // not be rendered (GH Issue #629)\n    if (false) {\n      if (route.name && route.children.some(function (child) { return /^\\/?$/.test(child.path); })) {\n        warn(\n          false,\n          \"Named Route '\" + (route.name) + \"' has a default child route. \" +\n          \"When navigating to this named route (:to=\\\"{name: '\" + (route.name) + \"'\\\"), \" +\n          \"the default child route will not be rendered. Remove the name from \" +\n          \"this route and use the name of the default child route for named \" +\n          \"links instead.\"\n        );\n      }\n    }\n    route.children.forEach(function (child) {\n      var childMatchAs = matchAs\n        ? cleanPath((matchAs + \"/\" + (child.path)))\n        : undefined;\n      addRouteRecord(pathMap, nameMap, child, record, childMatchAs);\n    });\n  }\n\n  if (route.alias !== undefined) {\n    if (Array.isArray(route.alias)) {\n      route.alias.forEach(function (alias) {\n        var aliasRoute = {\n          path: alias,\n          children: route.children\n        };\n        addRouteRecord(pathMap, nameMap, aliasRoute, parent, record.path);\n      });\n    } else {\n      var aliasRoute = {\n        path: route.alias,\n        children: route.children\n      };\n      addRouteRecord(pathMap, nameMap, aliasRoute, parent, record.path);\n    }\n  }\n\n  if (!pathMap[record.path]) {\n    pathMap[record.path] = record;\n  }\n\n  if (name) {\n    if (!nameMap[name]) {\n      nameMap[name] = record;\n    } else if (false) {\n      warn(\n        false,\n        \"Duplicate named routes definition: \" +\n        \"{ name: \\\"\" + name + \"\\\", path: \\\"\" + (record.path) + \"\\\" }\"\n      );\n    }\n  }\n}\n\nfunction normalizePath (path, parent) {\n  path = path.replace(/\\/$/, '');\n  if (path[0] === '/') { return path }\n  if (parent == null) { return path }\n  return cleanPath(((parent.path) + \"/\" + path))\n}\n\nvar index$1 = Array.isArray || function (arr) {\n  return Object.prototype.toString.call(arr) == '[object Array]';\n};\n\nvar isarray = index$1;\n\n/**\n * Expose `pathToRegexp`.\n */\nvar index = pathToRegexp;\nvar parse_1 = parse;\nvar compile_1 = compile;\nvar tokensToFunction_1 = tokensToFunction;\nvar tokensToRegExp_1 = tokensToRegExp;\n\n/**\n * The main path matching regexp utility.\n *\n * @type {RegExp}\n */\nvar PATH_REGEXP = new RegExp([\n  // Match escaped characters that would otherwise appear in future matches.\n  // This allows the user to escape special characters that won't transform.\n  '(\\\\\\\\.)',\n  // Match Express-style parameters and un-named parameters with a prefix\n  // and optional suffixes. Matches appear as:\n  //\n  // \"/:test(\\\\d+)?\" => [\"/\", \"test\", \"\\d+\", undefined, \"?\", undefined]\n  // \"/route(\\\\d+)\"  => [undefined, undefined, undefined, \"\\d+\", undefined, undefined]\n  // \"/*\"            => [\"/\", undefined, undefined, undefined, undefined, \"*\"]\n  '([\\\\/.])?(?:(?:\\\\:(\\\\w+)(?:\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))?|\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))([+*?])?|(\\\\*))'\n].join('|'), 'g');\n\n/**\n * Parse a string for the raw tokens.\n *\n * @param  {string}  str\n * @param  {Object=} options\n * @return {!Array}\n */\nfunction parse (str, options) {\n  var tokens = [];\n  var key = 0;\n  var index = 0;\n  var path = '';\n  var defaultDelimiter = options && options.delimiter || '/';\n  var res;\n\n  while ((res = PATH_REGEXP.exec(str)) != null) {\n    var m = res[0];\n    var escaped = res[1];\n    var offset = res.index;\n    path += str.slice(index, offset);\n    index = offset + m.length;\n\n    // Ignore already escaped sequences.\n    if (escaped) {\n      path += escaped[1];\n      continue\n    }\n\n    var next = str[index];\n    var prefix = res[2];\n    var name = res[3];\n    var capture = res[4];\n    var group = res[5];\n    var modifier = res[6];\n    var asterisk = res[7];\n\n    // Push the current path onto the tokens.\n    if (path) {\n      tokens.push(path);\n      path = '';\n    }\n\n    var partial = prefix != null && next != null && next !== prefix;\n    var repeat = modifier === '+' || modifier === '*';\n    var optional = modifier === '?' || modifier === '*';\n    var delimiter = res[2] || defaultDelimiter;\n    var pattern = capture || group;\n\n    tokens.push({\n      name: name || key++,\n      prefix: prefix || '',\n      delimiter: delimiter,\n      optional: optional,\n      repeat: repeat,\n      partial: partial,\n      asterisk: !!asterisk,\n      pattern: pattern ? escapeGroup(pattern) : (asterisk ? '.*' : '[^' + escapeString(delimiter) + ']+?')\n    });\n  }\n\n  // Match any characters still remaining.\n  if (index < str.length) {\n    path += str.substr(index);\n  }\n\n  // If the path exists, push it onto the end.\n  if (path) {\n    tokens.push(path);\n  }\n\n  return tokens\n}\n\n/**\n * Compile a string to a template function for the path.\n *\n * @param  {string}             str\n * @param  {Object=}            options\n * @return {!function(Object=, Object=)}\n */\nfunction compile (str, options) {\n  return tokensToFunction(parse(str, options))\n}\n\n/**\n * Prettier encoding of URI path segments.\n *\n * @param  {string}\n * @return {string}\n */\nfunction encodeURIComponentPretty (str) {\n  return encodeURI(str).replace(/[\\/?#]/g, function (c) {\n    return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n  })\n}\n\n/**\n * Encode the asterisk parameter. Similar to `pretty`, but allows slashes.\n *\n * @param  {string}\n * @return {string}\n */\nfunction encodeAsterisk (str) {\n  return encodeURI(str).replace(/[?#]/g, function (c) {\n    return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n  })\n}\n\n/**\n * Expose a method for transforming tokens into the path function.\n */\nfunction tokensToFunction (tokens) {\n  // Compile all the tokens into regexps.\n  var matches = new Array(tokens.length);\n\n  // Compile all the patterns before compilation.\n  for (var i = 0; i < tokens.length; i++) {\n    if (typeof tokens[i] === 'object') {\n      matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$');\n    }\n  }\n\n  return function (obj, opts) {\n    var path = '';\n    var data = obj || {};\n    var options = opts || {};\n    var encode = options.pretty ? encodeURIComponentPretty : encodeURIComponent;\n\n    for (var i = 0; i < tokens.length; i++) {\n      var token = tokens[i];\n\n      if (typeof token === 'string') {\n        path += token;\n\n        continue\n      }\n\n      var value = data[token.name];\n      var segment;\n\n      if (value == null) {\n        if (token.optional) {\n          // Prepend partial segment prefixes.\n          if (token.partial) {\n            path += token.prefix;\n          }\n\n          continue\n        } else {\n          throw new TypeError('Expected \"' + token.name + '\" to be defined')\n        }\n      }\n\n      if (isarray(value)) {\n        if (!token.repeat) {\n          throw new TypeError('Expected \"' + token.name + '\" to not repeat, but received `' + JSON.stringify(value) + '`')\n        }\n\n        if (value.length === 0) {\n          if (token.optional) {\n            continue\n          } else {\n            throw new TypeError('Expected \"' + token.name + '\" to not be empty')\n          }\n        }\n\n        for (var j = 0; j < value.length; j++) {\n          segment = encode(value[j]);\n\n          if (!matches[i].test(segment)) {\n            throw new TypeError('Expected all \"' + token.name + '\" to match \"' + token.pattern + '\", but received `' + JSON.stringify(segment) + '`')\n          }\n\n          path += (j === 0 ? token.prefix : token.delimiter) + segment;\n        }\n\n        continue\n      }\n\n      segment = token.asterisk ? encodeAsterisk(value) : encode(value);\n\n      if (!matches[i].test(segment)) {\n        throw new TypeError('Expected \"' + token.name + '\" to match \"' + token.pattern + '\", but received \"' + segment + '\"')\n      }\n\n      path += token.prefix + segment;\n    }\n\n    return path\n  }\n}\n\n/**\n * Escape a regular expression string.\n *\n * @param  {string} str\n * @return {string}\n */\nfunction escapeString (str) {\n  return str.replace(/([.+*?=^!:${}()[\\]|\\/\\\\])/g, '\\\\$1')\n}\n\n/**\n * Escape the capturing group by escaping special characters and meaning.\n *\n * @param  {string} group\n * @return {string}\n */\nfunction escapeGroup (group) {\n  return group.replace(/([=!:$\\/()])/g, '\\\\$1')\n}\n\n/**\n * Attach the keys as a property of the regexp.\n *\n * @param  {!RegExp} re\n * @param  {Array}   keys\n * @return {!RegExp}\n */\nfunction attachKeys (re, keys) {\n  re.keys = keys;\n  return re\n}\n\n/**\n * Get the flags for a regexp from the options.\n *\n * @param  {Object} options\n * @return {string}\n */\nfunction flags (options) {\n  return options.sensitive ? '' : 'i'\n}\n\n/**\n * Pull out keys from a regexp.\n *\n * @param  {!RegExp} path\n * @param  {!Array}  keys\n * @return {!RegExp}\n */\nfunction regexpToRegexp (path, keys) {\n  // Use a negative lookahead to match only capturing groups.\n  var groups = path.source.match(/\\((?!\\?)/g);\n\n  if (groups) {\n    for (var i = 0; i < groups.length; i++) {\n      keys.push({\n        name: i,\n        prefix: null,\n        delimiter: null,\n        optional: false,\n        repeat: false,\n        partial: false,\n        asterisk: false,\n        pattern: null\n      });\n    }\n  }\n\n  return attachKeys(path, keys)\n}\n\n/**\n * Transform an array into a regexp.\n *\n * @param  {!Array}  path\n * @param  {Array}   keys\n * @param  {!Object} options\n * @return {!RegExp}\n */\nfunction arrayToRegexp (path, keys, options) {\n  var parts = [];\n\n  for (var i = 0; i < path.length; i++) {\n    parts.push(pathToRegexp(path[i], keys, options).source);\n  }\n\n  var regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options));\n\n  return attachKeys(regexp, keys)\n}\n\n/**\n * Create a path regexp from string input.\n *\n * @param  {string}  path\n * @param  {!Array}  keys\n * @param  {!Object} options\n * @return {!RegExp}\n */\nfunction stringToRegexp (path, keys, options) {\n  return tokensToRegExp(parse(path, options), keys, options)\n}\n\n/**\n * Expose a function for taking tokens and returning a RegExp.\n *\n * @param  {!Array}          tokens\n * @param  {(Array|Object)=} keys\n * @param  {Object=}         options\n * @return {!RegExp}\n */\nfunction tokensToRegExp (tokens, keys, options) {\n  if (!isarray(keys)) {\n    options = /** @type {!Object} */ (keys || options);\n    keys = [];\n  }\n\n  options = options || {};\n\n  var strict = options.strict;\n  var end = options.end !== false;\n  var route = '';\n\n  // Iterate over the tokens and create our regexp string.\n  for (var i = 0; i < tokens.length; i++) {\n    var token = tokens[i];\n\n    if (typeof token === 'string') {\n      route += escapeString(token);\n    } else {\n      var prefix = escapeString(token.prefix);\n      var capture = '(?:' + token.pattern + ')';\n\n      keys.push(token);\n\n      if (token.repeat) {\n        capture += '(?:' + prefix + capture + ')*';\n      }\n\n      if (token.optional) {\n        if (!token.partial) {\n          capture = '(?:' + prefix + '(' + capture + '))?';\n        } else {\n          capture = prefix + '(' + capture + ')?';\n        }\n      } else {\n        capture = prefix + '(' + capture + ')';\n      }\n\n      route += capture;\n    }\n  }\n\n  var delimiter = escapeString(options.delimiter || '/');\n  var endsWithDelimiter = route.slice(-delimiter.length) === delimiter;\n\n  // In non-strict mode we allow a slash at the end of match. If the path to\n  // match already ends with a slash, we remove it for consistency. The slash\n  // is valid at the end of a path match, not in the middle. This is important\n  // in non-ending mode, where \"/test/\" shouldn't match \"/test//route\".\n  if (!strict) {\n    route = (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) + '(?:' + delimiter + '(?=$))?';\n  }\n\n  if (end) {\n    route += '$';\n  } else {\n    // In non-ending mode, we need the capturing groups to match as much as\n    // possible by using a positive lookahead to the end or next path segment.\n    route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)';\n  }\n\n  return attachKeys(new RegExp('^' + route, flags(options)), keys)\n}\n\n/**\n * Normalize the given path string, returning a regular expression.\n *\n * An empty array can be passed in for the keys, which will hold the\n * placeholder key descriptions. For example, using `/user/:id`, `keys` will\n * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.\n *\n * @param  {(string|RegExp|Array)} path\n * @param  {(Array|Object)=}       keys\n * @param  {Object=}               options\n * @return {!RegExp}\n */\nfunction pathToRegexp (path, keys, options) {\n  if (!isarray(keys)) {\n    options = /** @type {!Object} */ (keys || options);\n    keys = [];\n  }\n\n  options = options || {};\n\n  if (path instanceof RegExp) {\n    return regexpToRegexp(path, /** @type {!Array} */ (keys))\n  }\n\n  if (isarray(path)) {\n    return arrayToRegexp(/** @type {!Array} */ (path), /** @type {!Array} */ (keys), options)\n  }\n\n  return stringToRegexp(/** @type {string} */ (path), /** @type {!Array} */ (keys), options)\n}\n\nindex.parse = parse_1;\nindex.compile = compile_1;\nindex.tokensToFunction = tokensToFunction_1;\nindex.tokensToRegExp = tokensToRegExp_1;\n\n/*  */\n\nvar regexpCache = Object.create(null);\n\nfunction getRouteRegex (path) {\n  var hit = regexpCache[path];\n  var keys, regexp;\n\n  if (hit) {\n    keys = hit.keys;\n    regexp = hit.regexp;\n  } else {\n    keys = [];\n    regexp = index(path, keys);\n    regexpCache[path] = { keys: keys, regexp: regexp };\n  }\n\n  return { keys: keys, regexp: regexp }\n}\n\nvar regexpCompileCache = Object.create(null);\n\nfunction fillParams (\n  path,\n  params,\n  routeMsg\n) {\n  try {\n    var filler =\n      regexpCompileCache[path] ||\n      (regexpCompileCache[path] = index.compile(path));\n    return filler(params || {}, { pretty: true })\n  } catch (e) {\n    if (false) {\n      warn(false, (\"missing param for \" + routeMsg + \": \" + (e.message)));\n    }\n    return ''\n  }\n}\n\n/*  */\n\nfunction normalizeLocation (\n  raw,\n  current,\n  append\n) {\n  var next = typeof raw === 'string' ? { path: raw } : raw;\n  // named target\n  if (next.name || next._normalized) {\n    return next\n  }\n\n  // relative params\n  if (!next.path && next.params && current) {\n    next = assign({}, next);\n    next._normalized = true;\n    var params = assign(assign({}, current.params), next.params);\n    if (current.name) {\n      next.name = current.name;\n      next.params = params;\n    } else if (current.matched) {\n      var rawPath = current.matched[current.matched.length - 1].path;\n      next.path = fillParams(rawPath, params, (\"path \" + (current.path)));\n    } else if (false) {\n      warn(false, \"relative params navigation requires a current route.\");\n    }\n    return next\n  }\n\n  var parsedPath = parsePath(next.path || '');\n  var basePath = (current && current.path) || '/';\n  var path = parsedPath.path\n    ? resolvePath(parsedPath.path, basePath, append || next.append)\n    : (current && current.path) || '/';\n  var query = resolveQuery(parsedPath.query, next.query);\n  var hash = next.hash || parsedPath.hash;\n  if (hash && hash.charAt(0) !== '#') {\n    hash = \"#\" + hash;\n  }\n\n  return {\n    _normalized: true,\n    path: path,\n    query: query,\n    hash: hash\n  }\n}\n\nfunction assign (a, b) {\n  for (var key in b) {\n    a[key] = b[key];\n  }\n  return a\n}\n\n/*  */\n\nfunction createMatcher (routes) {\n  var ref = createRouteMap(routes);\n  var pathMap = ref.pathMap;\n  var nameMap = ref.nameMap;\n\n  function addRoutes (routes) {\n    createRouteMap(routes, pathMap, nameMap);\n  }\n\n  function match (\n    raw,\n    currentRoute,\n    redirectedFrom\n  ) {\n    var location = normalizeLocation(raw, currentRoute);\n    var name = location.name;\n\n    if (name) {\n      var record = nameMap[name];\n      if (false) {\n        warn(record, (\"Route with name '\" + name + \"' does not exist\"));\n      }\n      var paramNames = getRouteRegex(record.path).keys\n        .filter(function (key) { return !key.optional; })\n        .map(function (key) { return key.name; });\n\n      if (typeof location.params !== 'object') {\n        location.params = {};\n      }\n\n      if (currentRoute && typeof currentRoute.params === 'object') {\n        for (var key in currentRoute.params) {\n          if (!(key in location.params) && paramNames.indexOf(key) > -1) {\n            location.params[key] = currentRoute.params[key];\n          }\n        }\n      }\n\n      if (record) {\n        location.path = fillParams(record.path, location.params, (\"named route \\\"\" + name + \"\\\"\"));\n        return _createRoute(record, location, redirectedFrom)\n      }\n    } else if (location.path) {\n      location.params = {};\n      for (var path in pathMap) {\n        if (matchRoute(path, location.params, location.path)) {\n          return _createRoute(pathMap[path], location, redirectedFrom)\n        }\n      }\n    }\n    // no match\n    return _createRoute(null, location)\n  }\n\n  function redirect (\n    record,\n    location\n  ) {\n    var originalRedirect = record.redirect;\n    var redirect = typeof originalRedirect === 'function'\n        ? originalRedirect(createRoute(record, location))\n        : originalRedirect;\n\n    if (typeof redirect === 'string') {\n      redirect = { path: redirect };\n    }\n\n    if (!redirect || typeof redirect !== 'object') {\n      \"production\" !== 'production' && warn(\n        false, (\"invalid redirect option: \" + (JSON.stringify(redirect)))\n      );\n      return _createRoute(null, location)\n    }\n\n    var re = redirect;\n    var name = re.name;\n    var path = re.path;\n    var query = location.query;\n    var hash = location.hash;\n    var params = location.params;\n    query = re.hasOwnProperty('query') ? re.query : query;\n    hash = re.hasOwnProperty('hash') ? re.hash : hash;\n    params = re.hasOwnProperty('params') ? re.params : params;\n\n    if (name) {\n      // resolved named direct\n      var targetRecord = nameMap[name];\n      if (false) {\n        assert(targetRecord, (\"redirect failed: named route \\\"\" + name + \"\\\" not found.\"));\n      }\n      return match({\n        _normalized: true,\n        name: name,\n        query: query,\n        hash: hash,\n        params: params\n      }, undefined, location)\n    } else if (path) {\n      // 1. resolve relative redirect\n      var rawPath = resolveRecordPath(path, record);\n      // 2. resolve params\n      var resolvedPath = fillParams(rawPath, params, (\"redirect route with path \\\"\" + rawPath + \"\\\"\"));\n      // 3. rematch with existing query and hash\n      return match({\n        _normalized: true,\n        path: resolvedPath,\n        query: query,\n        hash: hash\n      }, undefined, location)\n    } else {\n      warn(false, (\"invalid redirect option: \" + (JSON.stringify(redirect))));\n      return _createRoute(null, location)\n    }\n  }\n\n  function alias (\n    record,\n    location,\n    matchAs\n  ) {\n    var aliasedPath = fillParams(matchAs, location.params, (\"aliased route with path \\\"\" + matchAs + \"\\\"\"));\n    var aliasedMatch = match({\n      _normalized: true,\n      path: aliasedPath\n    });\n    if (aliasedMatch) {\n      var matched = aliasedMatch.matched;\n      var aliasedRecord = matched[matched.length - 1];\n      location.params = aliasedMatch.params;\n      return _createRoute(aliasedRecord, location)\n    }\n    return _createRoute(null, location)\n  }\n\n  function _createRoute (\n    record,\n    location,\n    redirectedFrom\n  ) {\n    if (record && record.redirect) {\n      return redirect(record, redirectedFrom || location)\n    }\n    if (record && record.matchAs) {\n      return alias(record, location, record.matchAs)\n    }\n    return createRoute(record, location, redirectedFrom)\n  }\n\n  return {\n    match: match,\n    addRoutes: addRoutes\n  }\n}\n\nfunction matchRoute (\n  path,\n  params,\n  pathname\n) {\n  var ref = getRouteRegex(path);\n  var regexp = ref.regexp;\n  var keys = ref.keys;\n  var m = pathname.match(regexp);\n\n  if (!m) {\n    return false\n  } else if (!params) {\n    return true\n  }\n\n  for (var i = 1, len = m.length; i < len; ++i) {\n    var key = keys[i - 1];\n    var val = typeof m[i] === 'string' ? decodeURIComponent(m[i]) : m[i];\n    if (key) { params[key.name] = val; }\n  }\n\n  return true\n}\n\nfunction resolveRecordPath (path, record) {\n  return resolvePath(path, record.parent ? record.parent.path : '/', true)\n}\n\n/*  */\n\n\nvar positionStore = Object.create(null);\n\nfunction setupScroll () {\n  window.addEventListener('popstate', function (e) {\n    saveScrollPosition();\n    if (e.state && e.state.key) {\n      setStateKey(e.state.key);\n    }\n  });\n}\n\nfunction handleScroll (\n  router,\n  to,\n  from,\n  isPop\n) {\n  if (!router.app) {\n    return\n  }\n\n  var behavior = router.options.scrollBehavior;\n  if (!behavior) {\n    return\n  }\n\n  if (false) {\n    assert(typeof behavior === 'function', \"scrollBehavior must be a function\");\n  }\n\n  // wait until re-render finishes before scrolling\n  router.app.$nextTick(function () {\n    var position = getScrollPosition();\n    var shouldScroll = behavior(to, from, isPop ? position : null);\n    if (!shouldScroll) {\n      return\n    }\n    var isObject = typeof shouldScroll === 'object';\n    if (isObject && typeof shouldScroll.selector === 'string') {\n      var el = document.querySelector(shouldScroll.selector);\n      if (el) {\n        position = getElementPosition(el);\n      } else if (isValidPosition(shouldScroll)) {\n        position = normalizePosition(shouldScroll);\n      }\n    } else if (isObject && isValidPosition(shouldScroll)) {\n      position = normalizePosition(shouldScroll);\n    }\n\n    if (position) {\n      window.scrollTo(position.x, position.y);\n    }\n  });\n}\n\nfunction saveScrollPosition () {\n  var key = getStateKey();\n  if (key) {\n    positionStore[key] = {\n      x: window.pageXOffset,\n      y: window.pageYOffset\n    };\n  }\n}\n\nfunction getScrollPosition () {\n  var key = getStateKey();\n  if (key) {\n    return positionStore[key]\n  }\n}\n\nfunction getElementPosition (el) {\n  var docRect = document.documentElement.getBoundingClientRect();\n  var elRect = el.getBoundingClientRect();\n  return {\n    x: elRect.left - docRect.left,\n    y: elRect.top - docRect.top\n  }\n}\n\nfunction isValidPosition (obj) {\n  return isNumber(obj.x) || isNumber(obj.y)\n}\n\nfunction normalizePosition (obj) {\n  return {\n    x: isNumber(obj.x) ? obj.x : window.pageXOffset,\n    y: isNumber(obj.y) ? obj.y : window.pageYOffset\n  }\n}\n\nfunction isNumber (v) {\n  return typeof v === 'number'\n}\n\n/*  */\n\nvar supportsPushState = inBrowser && (function () {\n  var ua = window.navigator.userAgent;\n\n  if (\n    (ua.indexOf('Android 2.') !== -1 || ua.indexOf('Android 4.0') !== -1) &&\n    ua.indexOf('Mobile Safari') !== -1 &&\n    ua.indexOf('Chrome') === -1 &&\n    ua.indexOf('Windows Phone') === -1\n  ) {\n    return false\n  }\n\n  return window.history && 'pushState' in window.history\n})();\n\n// use User Timing api (if present) for more accurate key precision\nvar Time = inBrowser && window.performance && window.performance.now\n  ? window.performance\n  : Date;\n\nvar _key = genKey();\n\nfunction genKey () {\n  return Time.now().toFixed(3)\n}\n\nfunction getStateKey () {\n  return _key\n}\n\nfunction setStateKey (key) {\n  _key = key;\n}\n\nfunction pushState (url, replace) {\n  saveScrollPosition();\n  // try...catch the pushState call to get around Safari\n  // DOM Exception 18 where it limits to 100 pushState calls\n  var history = window.history;\n  try {\n    if (replace) {\n      history.replaceState({ key: _key }, '', url);\n    } else {\n      _key = genKey();\n      history.pushState({ key: _key }, '', url);\n    }\n  } catch (e) {\n    window.location[replace ? 'replace' : 'assign'](url);\n  }\n}\n\nfunction replaceState (url) {\n  pushState(url, true);\n}\n\n/*  */\n\nfunction runQueue (queue, fn, cb) {\n  var step = function (index) {\n    if (index >= queue.length) {\n      cb();\n    } else {\n      if (queue[index]) {\n        fn(queue[index], function () {\n          step(index + 1);\n        });\n      } else {\n        step(index + 1);\n      }\n    }\n  };\n  step(0);\n}\n\n/*  */\n\n\nvar History = function History (router, base) {\n  this.router = router;\n  this.base = normalizeBase(base);\n  // start with a route object that stands for \"nowhere\"\n  this.current = START;\n  this.pending = null;\n  this.ready = false;\n  this.readyCbs = [];\n};\n\nHistory.prototype.listen = function listen (cb) {\n  this.cb = cb;\n};\n\nHistory.prototype.onReady = function onReady (cb) {\n  if (this.ready) {\n    cb();\n  } else {\n    this.readyCbs.push(cb);\n  }\n};\n\nHistory.prototype.transitionTo = function transitionTo (location, onComplete, onAbort) {\n    var this$1 = this;\n\n  var route = this.router.match(location, this.current);\n  this.confirmTransition(route, function () {\n    this$1.updateRoute(route);\n    onComplete && onComplete(route);\n    this$1.ensureURL();\n\n    // fire ready cbs once\n    if (!this$1.ready) {\n      this$1.ready = true;\n      this$1.readyCbs.forEach(function (cb) {\n        cb(route);\n      });\n    }\n  }, onAbort);\n};\n\nHistory.prototype.confirmTransition = function confirmTransition (route, onComplete, onAbort) {\n    var this$1 = this;\n\n  var current = this.current;\n  var abort = function () { onAbort && onAbort(); };\n  if (\n    isSameRoute(route, current) &&\n    // in the case the route map has been dynamically appended to\n    route.matched.length === current.matched.length\n  ) {\n    this.ensureURL();\n    return abort()\n  }\n\n  var ref = resolveQueue(this.current.matched, route.matched);\n    var updated = ref.updated;\n    var deactivated = ref.deactivated;\n    var activated = ref.activated;\n\n  var queue = [].concat(\n    // in-component leave guards\n    extractLeaveGuards(deactivated),\n    // global before hooks\n    this.router.beforeHooks,\n    // in-component update hooks\n    extractUpdateHooks(updated),\n    // in-config enter guards\n    activated.map(function (m) { return m.beforeEnter; }),\n    // async components\n    resolveAsyncComponents(activated)\n  );\n\n  this.pending = route;\n  var iterator = function (hook, next) {\n    if (this$1.pending !== route) {\n      return abort()\n    }\n    hook(route, current, function (to) {\n      if (to === false) {\n        // next(false) -> abort navigation, ensure current URL\n        this$1.ensureURL(true);\n        abort();\n      } else if (typeof to === 'string' || typeof to === 'object') {\n        // next('/') or next({ path: '/' }) -> redirect\n        (typeof to === 'object' && to.replace) ? this$1.replace(to) : this$1.push(to);\n        abort();\n      } else {\n        // confirm transition and pass on the value\n        next(to);\n      }\n    });\n  };\n\n  runQueue(queue, iterator, function () {\n    var postEnterCbs = [];\n    var isValid = function () { return this$1.current === route; };\n    var enterGuards = extractEnterGuards(activated, postEnterCbs, isValid);\n    // wait until async components are resolved before\n    // extracting in-component enter guards\n    runQueue(enterGuards, iterator, function () {\n      if (this$1.pending !== route) {\n        return abort()\n      }\n      this$1.pending = null;\n      onComplete(route);\n      if (this$1.router.app) {\n        this$1.router.app.$nextTick(function () {\n          postEnterCbs.forEach(function (cb) { return cb(); });\n        });\n      }\n    });\n  });\n};\n\nHistory.prototype.updateRoute = function updateRoute (route) {\n  var prev = this.current;\n  this.current = route;\n  this.cb && this.cb(route);\n  this.router.afterHooks.forEach(function (hook) {\n    hook && hook(route, prev);\n  });\n};\n\nfunction normalizeBase (base) {\n  if (!base) {\n    if (inBrowser) {\n      // respect <base> tag\n      var baseEl = document.querySelector('base');\n      base = baseEl ? baseEl.getAttribute('href') : '/';\n    } else {\n      base = '/';\n    }\n  }\n  // make sure there's the starting slash\n  if (base.charAt(0) !== '/') {\n    base = '/' + base;\n  }\n  // remove trailing slash\n  return base.replace(/\\/$/, '')\n}\n\nfunction resolveQueue (\n  current,\n  next\n) {\n  var i;\n  var max = Math.max(current.length, next.length);\n  for (i = 0; i < max; i++) {\n    if (current[i] !== next[i]) {\n      break\n    }\n  }\n  return {\n    updated: next.slice(0, i),\n    activated: next.slice(i),\n    deactivated: current.slice(i)\n  }\n}\n\nfunction extractGuards (\n  records,\n  name,\n  bind,\n  reverse\n) {\n  var guards = flatMapComponents(records, function (def, instance, match, key) {\n    var guard = extractGuard(def, name);\n    if (guard) {\n      return Array.isArray(guard)\n        ? guard.map(function (guard) { return bind(guard, instance, match, key); })\n        : bind(guard, instance, match, key)\n    }\n  });\n  return flatten(reverse ? guards.reverse() : guards)\n}\n\nfunction extractGuard (\n  def,\n  key\n) {\n  if (typeof def !== 'function') {\n    // extend now so that global mixins are applied.\n    def = _Vue.extend(def);\n  }\n  return def.options[key]\n}\n\nfunction extractLeaveGuards (deactivated) {\n  return extractGuards(deactivated, 'beforeRouteLeave', bindGuard, true)\n}\n\nfunction extractUpdateHooks (updated) {\n  return extractGuards(updated, 'beforeRouteUpdate', bindGuard)\n}\n\nfunction bindGuard (guard, instance) {\n  return function boundRouteGuard () {\n    return guard.apply(instance, arguments)\n  }\n}\n\nfunction extractEnterGuards (\n  activated,\n  cbs,\n  isValid\n) {\n  return extractGuards(activated, 'beforeRouteEnter', function (guard, _, match, key) {\n    return bindEnterGuard(guard, match, key, cbs, isValid)\n  })\n}\n\nfunction bindEnterGuard (\n  guard,\n  match,\n  key,\n  cbs,\n  isValid\n) {\n  return function routeEnterGuard (to, from, next) {\n    return guard(to, from, function (cb) {\n      next(cb);\n      if (typeof cb === 'function') {\n        cbs.push(function () {\n          // #750\n          // if a router-view is wrapped with an out-in transition,\n          // the instance may not have been registered at this time.\n          // we will need to poll for registration until current route\n          // is no longer valid.\n          poll(cb, match.instances, key, isValid);\n        });\n      }\n    })\n  }\n}\n\nfunction poll (\n  cb, // somehow flow cannot infer this is a function\n  instances,\n  key,\n  isValid\n) {\n  if (instances[key]) {\n    cb(instances[key]);\n  } else if (isValid()) {\n    setTimeout(function () {\n      poll(cb, instances, key, isValid);\n    }, 16);\n  }\n}\n\nfunction resolveAsyncComponents (matched) {\n  return flatMapComponents(matched, function (def, _, match, key) {\n    // if it's a function and doesn't have Vue options attached,\n    // assume it's an async component resolve function.\n    // we are not using Vue's default async resolving mechanism because\n    // we want to halt the navigation until the incoming component has been\n    // resolved.\n    if (typeof def === 'function' && !def.options) {\n      return function (to, from, next) {\n        var resolve = once(function (resolvedDef) {\n          match.components[key] = resolvedDef;\n          next();\n        });\n\n        var reject = once(function (reason) {\n          warn(false, (\"Failed to resolve async component \" + key + \": \" + reason));\n          next(false);\n        });\n\n        var res = def(resolve, reject);\n        if (res && typeof res.then === 'function') {\n          res.then(resolve, reject);\n        }\n      }\n    }\n  })\n}\n\nfunction flatMapComponents (\n  matched,\n  fn\n) {\n  return flatten(matched.map(function (m) {\n    return Object.keys(m.components).map(function (key) { return fn(\n      m.components[key],\n      m.instances[key],\n      m, key\n    ); })\n  }))\n}\n\nfunction flatten (arr) {\n  return Array.prototype.concat.apply([], arr)\n}\n\n// in Webpack 2, require.ensure now also returns a Promise\n// so the resolve/reject functions may get called an extra time\n// if the user uses an arrow function shorthand that happens to\n// return that Promise.\nfunction once (fn) {\n  var called = false;\n  return function () {\n    if (called) { return }\n    called = true;\n    return fn.apply(this, arguments)\n  }\n}\n\n/*  */\n\n\nvar HTML5History = (function (History$$1) {\n  function HTML5History (router, base) {\n    var this$1 = this;\n\n    History$$1.call(this, router, base);\n\n    var expectScroll = router.options.scrollBehavior;\n\n    if (expectScroll) {\n      setupScroll();\n    }\n\n    window.addEventListener('popstate', function (e) {\n      this$1.transitionTo(getLocation(this$1.base), function (route) {\n        if (expectScroll) {\n          handleScroll(router, route, this$1.current, true);\n        }\n      });\n    });\n  }\n\n  if ( History$$1 ) HTML5History.__proto__ = History$$1;\n  HTML5History.prototype = Object.create( History$$1 && History$$1.prototype );\n  HTML5History.prototype.constructor = HTML5History;\n\n  HTML5History.prototype.go = function go (n) {\n    window.history.go(n);\n  };\n\n  HTML5History.prototype.push = function push (location, onComplete, onAbort) {\n    var this$1 = this;\n\n    this.transitionTo(location, function (route) {\n      pushState(cleanPath(this$1.base + route.fullPath));\n      handleScroll(this$1.router, route, this$1.current, false);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  HTML5History.prototype.replace = function replace (location, onComplete, onAbort) {\n    var this$1 = this;\n\n    this.transitionTo(location, function (route) {\n      replaceState(cleanPath(this$1.base + route.fullPath));\n      handleScroll(this$1.router, route, this$1.current, false);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  HTML5History.prototype.ensureURL = function ensureURL (push) {\n    if (getLocation(this.base) !== this.current.fullPath) {\n      var current = cleanPath(this.base + this.current.fullPath);\n      push ? pushState(current) : replaceState(current);\n    }\n  };\n\n  HTML5History.prototype.getCurrentLocation = function getCurrentLocation () {\n    return getLocation(this.base)\n  };\n\n  return HTML5History;\n}(History));\n\nfunction getLocation (base) {\n  var path = window.location.pathname;\n  if (base && path.indexOf(base) === 0) {\n    path = path.slice(base.length);\n  }\n  return (path || '/') + window.location.search + window.location.hash\n}\n\n/*  */\n\n\nvar HashHistory = (function (History$$1) {\n  function HashHistory (router, base, fallback) {\n    History$$1.call(this, router, base);\n    // check history fallback deeplinking\n    if (fallback && checkFallback(this.base)) {\n      return\n    }\n    ensureSlash();\n  }\n\n  if ( History$$1 ) HashHistory.__proto__ = History$$1;\n  HashHistory.prototype = Object.create( History$$1 && History$$1.prototype );\n  HashHistory.prototype.constructor = HashHistory;\n\n  // this is delayed until the app mounts\n  // to avoid the hashchange listener being fired too early\n  HashHistory.prototype.setupListeners = function setupListeners () {\n    var this$1 = this;\n\n    window.addEventListener('hashchange', function () {\n      if (!ensureSlash()) {\n        return\n      }\n      this$1.transitionTo(getHash(), function (route) {\n        replaceHash(route.fullPath);\n      });\n    });\n  };\n\n  HashHistory.prototype.push = function push (location, onComplete, onAbort) {\n    this.transitionTo(location, function (route) {\n      pushHash(route.fullPath);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  HashHistory.prototype.replace = function replace (location, onComplete, onAbort) {\n    this.transitionTo(location, function (route) {\n      replaceHash(route.fullPath);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  HashHistory.prototype.go = function go (n) {\n    window.history.go(n);\n  };\n\n  HashHistory.prototype.ensureURL = function ensureURL (push) {\n    var current = this.current.fullPath;\n    if (getHash() !== current) {\n      push ? pushHash(current) : replaceHash(current);\n    }\n  };\n\n  HashHistory.prototype.getCurrentLocation = function getCurrentLocation () {\n    return getHash()\n  };\n\n  return HashHistory;\n}(History));\n\nfunction checkFallback (base) {\n  var location = getLocation(base);\n  if (!/^\\/#/.test(location)) {\n    window.location.replace(\n      cleanPath(base + '/#' + location)\n    );\n    return true\n  }\n}\n\nfunction ensureSlash () {\n  var path = getHash();\n  if (path.charAt(0) === '/') {\n    return true\n  }\n  replaceHash('/' + path);\n  return false\n}\n\nfunction getHash () {\n  // We can't use window.location.hash here because it's not\n  // consistent across browsers - Firefox will pre-decode it!\n  var href = window.location.href;\n  var index = href.indexOf('#');\n  return index === -1 ? '' : href.slice(index + 1)\n}\n\nfunction pushHash (path) {\n  window.location.hash = path;\n}\n\nfunction replaceHash (path) {\n  var i = window.location.href.indexOf('#');\n  window.location.replace(\n    window.location.href.slice(0, i >= 0 ? i : 0) + '#' + path\n  );\n}\n\n/*  */\n\n\nvar AbstractHistory = (function (History$$1) {\n  function AbstractHistory (router, base) {\n    History$$1.call(this, router, base);\n    this.stack = [];\n    this.index = -1;\n  }\n\n  if ( History$$1 ) AbstractHistory.__proto__ = History$$1;\n  AbstractHistory.prototype = Object.create( History$$1 && History$$1.prototype );\n  AbstractHistory.prototype.constructor = AbstractHistory;\n\n  AbstractHistory.prototype.push = function push (location, onComplete, onAbort) {\n    var this$1 = this;\n\n    this.transitionTo(location, function (route) {\n      this$1.stack = this$1.stack.slice(0, this$1.index + 1).concat(route);\n      this$1.index++;\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  AbstractHistory.prototype.replace = function replace (location, onComplete, onAbort) {\n    var this$1 = this;\n\n    this.transitionTo(location, function (route) {\n      this$1.stack = this$1.stack.slice(0, this$1.index).concat(route);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  AbstractHistory.prototype.go = function go (n) {\n    var this$1 = this;\n\n    var targetIndex = this.index + n;\n    if (targetIndex < 0 || targetIndex >= this.stack.length) {\n      return\n    }\n    var route = this.stack[targetIndex];\n    this.confirmTransition(route, function () {\n      this$1.index = targetIndex;\n      this$1.updateRoute(route);\n    });\n  };\n\n  AbstractHistory.prototype.getCurrentLocation = function getCurrentLocation () {\n    var current = this.stack[this.stack.length - 1];\n    return current ? current.fullPath : '/'\n  };\n\n  AbstractHistory.prototype.ensureURL = function ensureURL () {\n    // noop\n  };\n\n  return AbstractHistory;\n}(History));\n\n/*  */\n\nvar VueRouter = function VueRouter (options) {\n  if ( options === void 0 ) options = {};\n\n  this.app = null;\n  this.apps = [];\n  this.options = options;\n  this.beforeHooks = [];\n  this.afterHooks = [];\n  this.matcher = createMatcher(options.routes || []);\n\n  var mode = options.mode || 'hash';\n  this.fallback = mode === 'history' && !supportsPushState;\n  if (this.fallback) {\n    mode = 'hash';\n  }\n  if (!inBrowser) {\n    mode = 'abstract';\n  }\n  this.mode = mode;\n\n  switch (mode) {\n    case 'history':\n      this.history = new HTML5History(this, options.base);\n      break\n    case 'hash':\n      this.history = new HashHistory(this, options.base, this.fallback);\n      break\n    case 'abstract':\n      this.history = new AbstractHistory(this, options.base);\n      break\n    default:\n      if (false) {\n        assert(false, (\"invalid mode: \" + mode));\n      }\n  }\n};\n\nvar prototypeAccessors = { currentRoute: {} };\n\nVueRouter.prototype.match = function match (\n  raw,\n  current,\n  redirectedFrom\n) {\n  return this.matcher.match(raw, current, redirectedFrom)\n};\n\nprototypeAccessors.currentRoute.get = function () {\n  return this.history && this.history.current\n};\n\nVueRouter.prototype.init = function init (app /* Vue component instance */) {\n    var this$1 = this;\n\n  \"production\" !== 'production' && assert(\n    install.installed,\n    \"not installed. Make sure to call `Vue.use(VueRouter)` \" +\n    \"before creating root instance.\"\n  );\n\n  this.apps.push(app);\n\n  // main app already initialized.\n  if (this.app) {\n    return\n  }\n\n  this.app = app;\n\n  var history = this.history;\n\n  if (history instanceof HTML5History) {\n    history.transitionTo(history.getCurrentLocation());\n  } else if (history instanceof HashHistory) {\n    var setupHashListener = function () {\n      history.setupListeners();\n    };\n    history.transitionTo(\n      history.getCurrentLocation(),\n      setupHashListener,\n      setupHashListener\n    );\n  }\n\n  history.listen(function (route) {\n    this$1.apps.forEach(function (app) {\n      app._route = route;\n    });\n  });\n};\n\nVueRouter.prototype.beforeEach = function beforeEach (fn) {\n  this.beforeHooks.push(fn);\n};\n\nVueRouter.prototype.afterEach = function afterEach (fn) {\n  this.afterHooks.push(fn);\n};\n\nVueRouter.prototype.onReady = function onReady (cb) {\n  this.history.onReady(cb);\n};\n\nVueRouter.prototype.push = function push (location, onComplete, onAbort) {\n  this.history.push(location, onComplete, onAbort);\n};\n\nVueRouter.prototype.replace = function replace (location, onComplete, onAbort) {\n  this.history.replace(location, onComplete, onAbort);\n};\n\nVueRouter.prototype.go = function go (n) {\n  this.history.go(n);\n};\n\nVueRouter.prototype.back = function back () {\n  this.go(-1);\n};\n\nVueRouter.prototype.forward = function forward () {\n  this.go(1);\n};\n\nVueRouter.prototype.getMatchedComponents = function getMatchedComponents (to) {\n  var route = to\n    ? this.resolve(to).route\n    : this.currentRoute;\n  if (!route) {\n    return []\n  }\n  return [].concat.apply([], route.matched.map(function (m) {\n    return Object.keys(m.components).map(function (key) {\n      return m.components[key]\n    })\n  }))\n};\n\nVueRouter.prototype.resolve = function resolve (\n  to,\n  current,\n  append\n) {\n  var location = normalizeLocation(to, current || this.history.current, append);\n  var route = this.match(location, current);\n  var fullPath = route.redirectedFrom || route.fullPath;\n  var base = this.history.base;\n  var href = createHref(base, fullPath, this.mode);\n  return {\n    location: location,\n    route: route,\n    href: href,\n    // for backwards compat\n    normalizedTo: location,\n    resolved: route\n  }\n};\n\nVueRouter.prototype.addRoutes = function addRoutes (routes) {\n  this.matcher.addRoutes(routes);\n  if (this.history.current !== START) {\n    this.history.transitionTo(this.history.getCurrentLocation());\n  }\n};\n\nObject.defineProperties( VueRouter.prototype, prototypeAccessors );\n\nfunction createHref (base, fullPath, mode) {\n  var path = mode === 'hash' ? '#' + fullPath : fullPath;\n  return base ? cleanPath(base + '/' + path) : path\n}\n\nVueRouter.install = install;\nVueRouter.version = '2.2.1';\n\nif (inBrowser && window.Vue) {\n  window.Vue.use(VueRouter);\n}\n\nmodule.exports = VueRouter;\n\n\n/***/ }),\n/* 133 */\n/***/ (function(module, exports) {\n\n/**\n * Translates the list format produced by css-loader into something\n * easier to manipulate.\n */\nmodule.exports = function listToStyles (parentId, list) {\n  var styles = []\n  var newStyles = {}\n  for (var i = 0; i < list.length; i++) {\n    var item = list[i]\n    var id = item[0]\n    var css = item[1]\n    var media = item[2]\n    var sourceMap = item[3]\n    var part = {\n      id: parentId + ':' + i,\n      css: css,\n      media: media,\n      sourceMap: sourceMap\n    }\n    if (!newStyles[id]) {\n      styles.push(newStyles[id] = { id: id, parts: [part] })\n    } else {\n      newStyles[id].parts.push(part)\n    }\n  }\n  return styles\n}\n\n\n/***/ }),\n/* 134 */\n/***/ (function(module, exports) {\n\nmodule.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\tif(!module.children) module.children = [];\r\n\t\tObject.defineProperty(module, \"loaded\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.l;\r\n\t\t\t}\r\n\t\t});\r\n\t\tObject.defineProperty(module, \"id\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.i;\r\n\t\t\t}\r\n\t\t});\r\n\t\tmodule.webpackPolyfill = 1;\r\n\t}\r\n\treturn module;\r\n};\r\n\n\n/***/ }),\n/* 135 */,\n/* 136 */,\n/* 137 */\n/***/ (function(module, exports) {\n\n/*\r\n\tMIT License http://www.opensource.org/licenses/mit-license.php\r\n\tAuthor Tobias Koppers @sokra\r\n*/\r\n// css base code, injected by the css-loader\r\nmodule.exports = function() {\r\n\tvar list = [];\r\n\r\n\t// return the list of modules as css string\r\n\tlist.toString = function toString() {\r\n\t\tvar result = [];\r\n\t\tfor(var i = 0; i < this.length; i++) {\r\n\t\t\tvar item = this[i];\r\n\t\t\tif(item[2]) {\r\n\t\t\t\tresult.push(\"@media \" + item[2] + \"{\" + item[1] + \"}\");\r\n\t\t\t} else {\r\n\t\t\t\tresult.push(item[1]);\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn result.join(\"\");\r\n\t};\r\n\r\n\t// import a list of modules into the list\r\n\tlist.i = function(modules, mediaQuery) {\r\n\t\tif(typeof modules === \"string\")\r\n\t\t\tmodules = [[null, modules, \"\"]];\r\n\t\tvar alreadyImportedModules = {};\r\n\t\tfor(var i = 0; i < this.length; i++) {\r\n\t\t\tvar id = this[i][0];\r\n\t\t\tif(typeof id === \"number\")\r\n\t\t\t\talreadyImportedModules[id] = true;\r\n\t\t}\r\n\t\tfor(i = 0; i < modules.length; i++) {\r\n\t\t\tvar item = modules[i];\r\n\t\t\t// skip already imported module\r\n\t\t\t// this implementation is not 100% perfect for weird media query combinations\r\n\t\t\t//  when a module is imported multiple times with different media queries.\r\n\t\t\t//  I hope this will never occur (Hey this way we have smaller bundles)\r\n\t\t\tif(typeof item[0] !== \"number\" || !alreadyImportedModules[item[0]]) {\r\n\t\t\t\tif(mediaQuery && !item[2]) {\r\n\t\t\t\t\titem[2] = mediaQuery;\r\n\t\t\t\t} else if(mediaQuery) {\r\n\t\t\t\t\titem[2] = \"(\" + item[2] + \") and (\" + mediaQuery + \")\";\r\n\t\t\t\t}\r\n\t\t\t\tlist.push(item);\r\n\t\t\t}\r\n\t\t}\r\n\t};\r\n\treturn list;\r\n};\r\n\n\n/***/ }),\n/* 138 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/*\n  MIT License http://www.opensource.org/licenses/mit-license.php\n  Author Tobias Koppers @sokra\n  Modified by Evan You @yyx990803\n*/\n\nvar hasDocument = typeof document !== 'undefined'\n\nif (typeof DEBUG !== 'undefined' && DEBUG) {\n  if (!hasDocument) {\n    throw new Error(\n    'vue-style-loader cannot be used in a non-browser environment. ' +\n    \"Use { target: 'node' } in your Webpack config to indicate a server-rendering environment.\"\n  ) }\n}\n\nvar listToStyles = __webpack_require__(133)\n\n/*\ntype StyleObject = {\n  id: number;\n  parts: Array<StyleObjectPart>\n}\n\ntype StyleObjectPart = {\n  css: string;\n  media: string;\n  sourceMap: ?string\n}\n*/\n\nvar stylesInDom = {/*\n  [id: number]: {\n    id: number,\n    refs: number,\n    parts: Array<(obj?: StyleObjectPart) => void>\n  }\n*/}\n\nvar head = hasDocument && (document.head || document.getElementsByTagName('head')[0])\nvar singletonElement = null\nvar singletonCounter = 0\nvar isProduction = false\nvar noop = function () {}\n\n// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>\n// tags it will allow on a page\nvar isOldIE = typeof navigator !== 'undefined' && /msie [6-9]\\b/.test(navigator.userAgent.toLowerCase())\n\nmodule.exports = function (parentId, list, _isProduction) {\n  isProduction = _isProduction\n\n  var styles = listToStyles(parentId, list)\n  addStylesToDom(styles)\n\n  return function update (newList) {\n    var mayRemove = []\n    for (var i = 0; i < styles.length; i++) {\n      var item = styles[i]\n      var domStyle = stylesInDom[item.id]\n      domStyle.refs--\n      mayRemove.push(domStyle)\n    }\n    if (newList) {\n      styles = listToStyles(parentId, newList)\n      addStylesToDom(styles)\n    } else {\n      styles = []\n    }\n    for (var i = 0; i < mayRemove.length; i++) {\n      var domStyle = mayRemove[i]\n      if (domStyle.refs === 0) {\n        for (var j = 0; j < domStyle.parts.length; j++) {\n          domStyle.parts[j]()\n        }\n        delete stylesInDom[domStyle.id]\n      }\n    }\n  }\n}\n\nfunction addStylesToDom (styles /* Array<StyleObject> */) {\n  for (var i = 0; i < styles.length; i++) {\n    var item = styles[i]\n    var domStyle = stylesInDom[item.id]\n    if (domStyle) {\n      domStyle.refs++\n      for (var j = 0; j < domStyle.parts.length; j++) {\n        domStyle.parts[j](item.parts[j])\n      }\n      for (; j < item.parts.length; j++) {\n        domStyle.parts.push(addStyle(item.parts[j]))\n      }\n      if (domStyle.parts.length > item.parts.length) {\n        domStyle.parts.length = item.parts.length\n      }\n    } else {\n      var parts = []\n      for (var j = 0; j < item.parts.length; j++) {\n        parts.push(addStyle(item.parts[j]))\n      }\n      stylesInDom[item.id] = { id: item.id, refs: 1, parts: parts }\n    }\n  }\n}\n\nfunction listToStyles (parentId, list) {\n  var styles = []\n  var newStyles = {}\n  for (var i = 0; i < list.length; i++) {\n    var item = list[i]\n    var id = item[0]\n    var css = item[1]\n    var media = item[2]\n    var sourceMap = item[3]\n    var part = { css: css, media: media, sourceMap: sourceMap }\n    if (!newStyles[id]) {\n      part.id = parentId + ':0'\n      styles.push(newStyles[id] = { id: id, parts: [part] })\n    } else {\n      part.id = parentId + ':' + newStyles[id].parts.length\n      newStyles[id].parts.push(part)\n    }\n  }\n  return styles\n}\n\nfunction createStyleElement () {\n  var styleElement = document.createElement('style')\n  styleElement.type = 'text/css'\n  head.appendChild(styleElement)\n  return styleElement\n}\n\nfunction addStyle (obj /* StyleObjectPart */) {\n  var update, remove\n  var styleElement = document.querySelector('style[data-vue-ssr-id~=\"' + obj.id + '\"]')\n  var hasSSR = styleElement != null\n\n  // if in production mode and style is already provided by SSR,\n  // simply do nothing.\n  if (hasSSR && isProduction) {\n    return noop\n  }\n\n  if (isOldIE) {\n    // use singleton mode for IE9.\n    var styleIndex = singletonCounter++\n    styleElement = singletonElement || (singletonElement = createStyleElement())\n    update = applyToSingletonTag.bind(null, styleElement, styleIndex, false)\n    remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true)\n  } else {\n    // use multi-style-tag mode in all other cases\n    styleElement = styleElement || createStyleElement()\n    update = applyToTag.bind(null, styleElement)\n    remove = function () {\n      styleElement.parentNode.removeChild(styleElement)\n    }\n  }\n\n  if (!hasSSR) {\n    update(obj)\n  }\n\n  return function updateStyle (newObj /* StyleObjectPart */) {\n    if (newObj) {\n      if (newObj.css === obj.css &&\n          newObj.media === obj.media &&\n          newObj.sourceMap === obj.sourceMap) {\n        return\n      }\n      update(obj = newObj)\n    } else {\n      remove()\n    }\n  }\n}\n\nvar replaceText = (function () {\n  var textStore = []\n\n  return function (index, replacement) {\n    textStore[index] = replacement\n    return textStore.filter(Boolean).join('\\n')\n  }\n})()\n\nfunction applyToSingletonTag (styleElement, index, remove, obj) {\n  var css = remove ? '' : obj.css\n\n  if (styleElement.styleSheet) {\n    styleElement.styleSheet.cssText = replaceText(index, css)\n  } else {\n    var cssNode = document.createTextNode(css)\n    var childNodes = styleElement.childNodes\n    if (childNodes[index]) styleElement.removeChild(childNodes[index])\n    if (childNodes.length) {\n      styleElement.insertBefore(cssNode, childNodes[index])\n    } else {\n      styleElement.appendChild(cssNode)\n    }\n  }\n}\n\nfunction applyToTag (styleElement, obj) {\n  var css = obj.css\n  var media = obj.media\n  var sourceMap = obj.sourceMap\n\n  if (media) {\n    styleElement.setAttribute('media', media)\n  }\n\n  if (sourceMap) {\n    // https://developer.chrome.com/devtools/docs/javascript-debugging\n    // this makes source maps inside style tags work properly in Chrome\n    css += '\\n/*# sourceURL=' + sourceMap.sources[0] + ' */'\n    // http://stackoverflow.com/a/26603875\n    css += '\\n/*# sourceMappingURL=data:application/json;base64,' + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + ' */'\n  }\n\n  if (styleElement.styleSheet) {\n    styleElement.styleSheet.cssText = css\n  } else {\n    while (styleElement.firstChild) {\n      styleElement.removeChild(styleElement.firstChild)\n    }\n    styleElement.appendChild(document.createTextNode(css))\n  }\n}\n\n\n/***/ })\n]);\n\n\n// WEBPACK FOOTER //\n// static/js/vendor.03b56a03b17565331709.js","module.exports = function normalizeComponent (\n  rawScriptExports,\n  compiledTemplate,\n  scopeId,\n  cssModules\n) {\n  var esModule\n  var scriptExports = rawScriptExports = rawScriptExports || {}\n\n  // ES6 modules interop\n  var type = typeof rawScriptExports.default\n  if (type === 'object' || type === 'function') {\n    esModule = rawScriptExports\n    scriptExports = rawScriptExports.default\n  }\n\n  // Vue.extend constructor export interop\n  var options = typeof scriptExports === 'function'\n    ? scriptExports.options\n    : scriptExports\n\n  // render functions\n  if (compiledTemplate) {\n    options.render = compiledTemplate.render\n    options.staticRenderFns = compiledTemplate.staticRenderFns\n  }\n\n  // scopedId\n  if (scopeId) {\n    options._scopeId = scopeId\n  }\n\n  // inject cssModules\n  if (cssModules) {\n    var computed = options.computed || (options.computed = {})\n    Object.keys(cssModules).forEach(function (key) {\n      var module = cssModules[key]\n      computed[key] = function () { return module }\n    })\n  }\n\n  return {\n    esModule: esModule,\n    exports: scriptExports,\n    options: options\n  }\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/vue-loader/lib/component-normalizer.js\n// module id = 0\n// module chunks = 0","// https://d3js.org Version 4.6.0. Copyright 2017 Mike Bostock.\n(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :\n\ttypeof define === 'function' && define.amd ? define(['exports'], factory) :\n\t(factory((global.d3 = global.d3 || {})));\n}(this, (function (exports) { 'use strict';\n\nvar version = \"4.6.0\";\n\nvar ascending = function(a, b) {\n  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;\n};\n\nvar bisector = function(compare) {\n  if (compare.length === 1) compare = ascendingComparator(compare);\n  return {\n    left: function(a, x, lo, hi) {\n      if (lo == null) lo = 0;\n      if (hi == null) hi = a.length;\n      while (lo < hi) {\n        var mid = lo + hi >>> 1;\n        if (compare(a[mid], x) < 0) lo = mid + 1;\n        else hi = mid;\n      }\n      return lo;\n    },\n    right: function(a, x, lo, hi) {\n      if (lo == null) lo = 0;\n      if (hi == null) hi = a.length;\n      while (lo < hi) {\n        var mid = lo + hi >>> 1;\n        if (compare(a[mid], x) > 0) hi = mid;\n        else lo = mid + 1;\n      }\n      return lo;\n    }\n  };\n};\n\nfunction ascendingComparator(f) {\n  return function(d, x) {\n    return ascending(f(d), x);\n  };\n}\n\nvar ascendingBisect = bisector(ascending);\nvar bisectRight = ascendingBisect.right;\nvar bisectLeft = ascendingBisect.left;\n\nvar descending = function(a, b) {\n  return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;\n};\n\nvar number = function(x) {\n  return x === null ? NaN : +x;\n};\n\nvar variance = function(array, f) {\n  var n = array.length,\n      m = 0,\n      a,\n      d,\n      s = 0,\n      i = -1,\n      j = 0;\n\n  if (f == null) {\n    while (++i < n) {\n      if (!isNaN(a = number(array[i]))) {\n        d = a - m;\n        m += d / ++j;\n        s += d * (a - m);\n      }\n    }\n  }\n\n  else {\n    while (++i < n) {\n      if (!isNaN(a = number(f(array[i], i, array)))) {\n        d = a - m;\n        m += d / ++j;\n        s += d * (a - m);\n      }\n    }\n  }\n\n  if (j > 1) return s / (j - 1);\n};\n\nvar deviation = function(array, f) {\n  var v = variance(array, f);\n  return v ? Math.sqrt(v) : v;\n};\n\nvar extent = function(array, f) {\n  var i = -1,\n      n = array.length,\n      a,\n      b,\n      c;\n\n  if (f == null) {\n    while (++i < n) if ((b = array[i]) != null && b >= b) { a = c = b; break; }\n    while (++i < n) if ((b = array[i]) != null) {\n      if (a > b) a = b;\n      if (c < b) c = b;\n    }\n  }\n\n  else {\n    while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = c = b; break; }\n    while (++i < n) if ((b = f(array[i], i, array)) != null) {\n      if (a > b) a = b;\n      if (c < b) c = b;\n    }\n  }\n\n  return [a, c];\n};\n\nvar array = Array.prototype;\n\nvar slice = array.slice;\nvar map = array.map;\n\nvar constant = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nvar identity = function(x) {\n  return x;\n};\n\nvar sequence = function(start, stop, step) {\n  start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;\n\n  var i = -1,\n      n = Math.max(0, Math.ceil((stop - start) / step)) | 0,\n      range = new Array(n);\n\n  while (++i < n) {\n    range[i] = start + i * step;\n  }\n\n  return range;\n};\n\nvar e10 = Math.sqrt(50);\nvar e5 = Math.sqrt(10);\nvar e2 = Math.sqrt(2);\n\nvar ticks = function(start, stop, count) {\n  var step = tickStep(start, stop, count);\n  return sequence(\n    Math.ceil(start / step) * step,\n    Math.floor(stop / step) * step + step / 2, // inclusive\n    step\n  );\n};\n\nfunction tickStep(start, stop, count) {\n  var step0 = Math.abs(stop - start) / Math.max(0, count),\n      step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)),\n      error = step0 / step1;\n  if (error >= e10) step1 *= 10;\n  else if (error >= e5) step1 *= 5;\n  else if (error >= e2) step1 *= 2;\n  return stop < start ? -step1 : step1;\n}\n\nvar sturges = function(values) {\n  return Math.ceil(Math.log(values.length) / Math.LN2) + 1;\n};\n\nvar histogram = function() {\n  var value = identity,\n      domain = extent,\n      threshold = sturges;\n\n  function histogram(data) {\n    var i,\n        n = data.length,\n        x,\n        values = new Array(n);\n\n    for (i = 0; i < n; ++i) {\n      values[i] = value(data[i], i, data);\n    }\n\n    var xz = domain(values),\n        x0 = xz[0],\n        x1 = xz[1],\n        tz = threshold(values, x0, x1);\n\n    // Convert number of thresholds into uniform thresholds.\n    if (!Array.isArray(tz)) tz = ticks(x0, x1, tz);\n\n    // Remove any thresholds outside the domain.\n    var m = tz.length;\n    while (tz[0] <= x0) tz.shift(), --m;\n    while (tz[m - 1] >= x1) tz.pop(), --m;\n\n    var bins = new Array(m + 1),\n        bin;\n\n    // Initialize bins.\n    for (i = 0; i <= m; ++i) {\n      bin = bins[i] = [];\n      bin.x0 = i > 0 ? tz[i - 1] : x0;\n      bin.x1 = i < m ? tz[i] : x1;\n    }\n\n    // Assign data to bins by value, ignoring any outside the domain.\n    for (i = 0; i < n; ++i) {\n      x = values[i];\n      if (x0 <= x && x <= x1) {\n        bins[bisectRight(tz, x, 0, m)].push(data[i]);\n      }\n    }\n\n    return bins;\n  }\n\n  histogram.value = function(_) {\n    return arguments.length ? (value = typeof _ === \"function\" ? _ : constant(_), histogram) : value;\n  };\n\n  histogram.domain = function(_) {\n    return arguments.length ? (domain = typeof _ === \"function\" ? _ : constant([_[0], _[1]]), histogram) : domain;\n  };\n\n  histogram.thresholds = function(_) {\n    return arguments.length ? (threshold = typeof _ === \"function\" ? _ : Array.isArray(_) ? constant(slice.call(_)) : constant(_), histogram) : threshold;\n  };\n\n  return histogram;\n};\n\nvar threshold = function(array, p, f) {\n  if (f == null) f = number;\n  if (!(n = array.length)) return;\n  if ((p = +p) <= 0 || n < 2) return +f(array[0], 0, array);\n  if (p >= 1) return +f(array[n - 1], n - 1, array);\n  var n,\n      h = (n - 1) * p,\n      i = Math.floor(h),\n      a = +f(array[i], i, array),\n      b = +f(array[i + 1], i + 1, array);\n  return a + (b - a) * (h - i);\n};\n\nvar freedmanDiaconis = function(values, min, max) {\n  values = map.call(values, number).sort(ascending);\n  return Math.ceil((max - min) / (2 * (threshold(values, 0.75) - threshold(values, 0.25)) * Math.pow(values.length, -1 / 3)));\n};\n\nvar scott = function(values, min, max) {\n  return Math.ceil((max - min) / (3.5 * deviation(values) * Math.pow(values.length, -1 / 3)));\n};\n\nvar max = function(array, f) {\n  var i = -1,\n      n = array.length,\n      a,\n      b;\n\n  if (f == null) {\n    while (++i < n) if ((b = array[i]) != null && b >= b) { a = b; break; }\n    while (++i < n) if ((b = array[i]) != null && b > a) a = b;\n  }\n\n  else {\n    while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = b; break; }\n    while (++i < n) if ((b = f(array[i], i, array)) != null && b > a) a = b;\n  }\n\n  return a;\n};\n\nvar mean = function(array, f) {\n  var s = 0,\n      n = array.length,\n      a,\n      i = -1,\n      j = n;\n\n  if (f == null) {\n    while (++i < n) if (!isNaN(a = number(array[i]))) s += a; else --j;\n  }\n\n  else {\n    while (++i < n) if (!isNaN(a = number(f(array[i], i, array)))) s += a; else --j;\n  }\n\n  if (j) return s / j;\n};\n\nvar median = function(array, f) {\n  var numbers = [],\n      n = array.length,\n      a,\n      i = -1;\n\n  if (f == null) {\n    while (++i < n) if (!isNaN(a = number(array[i]))) numbers.push(a);\n  }\n\n  else {\n    while (++i < n) if (!isNaN(a = number(f(array[i], i, array)))) numbers.push(a);\n  }\n\n  return threshold(numbers.sort(ascending), 0.5);\n};\n\nvar merge = function(arrays) {\n  var n = arrays.length,\n      m,\n      i = -1,\n      j = 0,\n      merged,\n      array;\n\n  while (++i < n) j += arrays[i].length;\n  merged = new Array(j);\n\n  while (--n >= 0) {\n    array = arrays[n];\n    m = array.length;\n    while (--m >= 0) {\n      merged[--j] = array[m];\n    }\n  }\n\n  return merged;\n};\n\nvar min = function(array, f) {\n  var i = -1,\n      n = array.length,\n      a,\n      b;\n\n  if (f == null) {\n    while (++i < n) if ((b = array[i]) != null && b >= b) { a = b; break; }\n    while (++i < n) if ((b = array[i]) != null && a > b) a = b;\n  }\n\n  else {\n    while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = b; break; }\n    while (++i < n) if ((b = f(array[i], i, array)) != null && a > b) a = b;\n  }\n\n  return a;\n};\n\nvar pairs = function(array) {\n  var i = 0, n = array.length - 1, p = array[0], pairs = new Array(n < 0 ? 0 : n);\n  while (i < n) pairs[i] = [p, p = array[++i]];\n  return pairs;\n};\n\nvar permute = function(array, indexes) {\n  var i = indexes.length, permutes = new Array(i);\n  while (i--) permutes[i] = array[indexes[i]];\n  return permutes;\n};\n\nvar scan = function(array, compare) {\n  if (!(n = array.length)) return;\n  var i = 0,\n      n,\n      j = 0,\n      xi,\n      xj = array[j];\n\n  if (!compare) compare = ascending;\n\n  while (++i < n) if (compare(xi = array[i], xj) < 0 || compare(xj, xj) !== 0) xj = xi, j = i;\n\n  if (compare(xj, xj) === 0) return j;\n};\n\nvar shuffle = function(array, i0, i1) {\n  var m = (i1 == null ? array.length : i1) - (i0 = i0 == null ? 0 : +i0),\n      t,\n      i;\n\n  while (m) {\n    i = Math.random() * m-- | 0;\n    t = array[m + i0];\n    array[m + i0] = array[i + i0];\n    array[i + i0] = t;\n  }\n\n  return array;\n};\n\nvar sum = function(array, f) {\n  var s = 0,\n      n = array.length,\n      a,\n      i = -1;\n\n  if (f == null) {\n    while (++i < n) if (a = +array[i]) s += a; // Note: zero and null are equivalent.\n  }\n\n  else {\n    while (++i < n) if (a = +f(array[i], i, array)) s += a;\n  }\n\n  return s;\n};\n\nvar transpose = function(matrix) {\n  if (!(n = matrix.length)) return [];\n  for (var i = -1, m = min(matrix, length), transpose = new Array(m); ++i < m;) {\n    for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n;) {\n      row[j] = matrix[j][i];\n    }\n  }\n  return transpose;\n};\n\nfunction length(d) {\n  return d.length;\n}\n\nvar zip = function() {\n  return transpose(arguments);\n};\n\nvar slice$1 = Array.prototype.slice;\n\nvar identity$1 = function(x) {\n  return x;\n};\n\nvar top = 1;\nvar right = 2;\nvar bottom = 3;\nvar left = 4;\nvar epsilon = 1e-6;\n\nfunction translateX(scale0, scale1, d) {\n  var x = scale0(d);\n  return \"translate(\" + (isFinite(x) ? x : scale1(d)) + \",0)\";\n}\n\nfunction translateY(scale0, scale1, d) {\n  var y = scale0(d);\n  return \"translate(0,\" + (isFinite(y) ? y : scale1(d)) + \")\";\n}\n\nfunction center(scale) {\n  var offset = scale.bandwidth() / 2;\n  if (scale.round()) offset = Math.round(offset);\n  return function(d) {\n    return scale(d) + offset;\n  };\n}\n\nfunction entering() {\n  return !this.__axis;\n}\n\nfunction axis(orient, scale) {\n  var tickArguments = [],\n      tickValues = null,\n      tickFormat = null,\n      tickSizeInner = 6,\n      tickSizeOuter = 6,\n      tickPadding = 3;\n\n  function axis(context) {\n    var values = tickValues == null ? (scale.ticks ? scale.ticks.apply(scale, tickArguments) : scale.domain()) : tickValues,\n        format = tickFormat == null ? (scale.tickFormat ? scale.tickFormat.apply(scale, tickArguments) : identity$1) : tickFormat,\n        spacing = Math.max(tickSizeInner, 0) + tickPadding,\n        transform = orient === top || orient === bottom ? translateX : translateY,\n        range = scale.range(),\n        range0 = range[0] + 0.5,\n        range1 = range[range.length - 1] + 0.5,\n        position = (scale.bandwidth ? center : identity$1)(scale.copy()),\n        selection = context.selection ? context.selection() : context,\n        path = selection.selectAll(\".domain\").data([null]),\n        tick = selection.selectAll(\".tick\").data(values, scale).order(),\n        tickExit = tick.exit(),\n        tickEnter = tick.enter().append(\"g\").attr(\"class\", \"tick\"),\n        line = tick.select(\"line\"),\n        text = tick.select(\"text\"),\n        k = orient === top || orient === left ? -1 : 1,\n        x, y = orient === left || orient === right ? (x = \"x\", \"y\") : (x = \"y\", \"x\");\n\n    path = path.merge(path.enter().insert(\"path\", \".tick\")\n        .attr(\"class\", \"domain\")\n        .attr(\"stroke\", \"#000\"));\n\n    tick = tick.merge(tickEnter);\n\n    line = line.merge(tickEnter.append(\"line\")\n        .attr(\"stroke\", \"#000\")\n        .attr(x + \"2\", k * tickSizeInner)\n        .attr(y + \"1\", 0.5)\n        .attr(y + \"2\", 0.5));\n\n    text = text.merge(tickEnter.append(\"text\")\n        .attr(\"fill\", \"#000\")\n        .attr(x, k * spacing)\n        .attr(y, 0.5)\n        .attr(\"dy\", orient === top ? \"0em\" : orient === bottom ? \"0.71em\" : \"0.32em\"));\n\n    if (context !== selection) {\n      path = path.transition(context);\n      tick = tick.transition(context);\n      line = line.transition(context);\n      text = text.transition(context);\n\n      tickExit = tickExit.transition(context)\n          .attr(\"opacity\", epsilon)\n          .attr(\"transform\", function(d) { return transform(position, this.parentNode.__axis || position, d); });\n\n      tickEnter\n          .attr(\"opacity\", epsilon)\n          .attr(\"transform\", function(d) { return transform(this.parentNode.__axis || position, position, d); });\n    }\n\n    tickExit.remove();\n\n    path\n        .attr(\"d\", orient === left || orient == right\n            ? \"M\" + k * tickSizeOuter + \",\" + range0 + \"H0.5V\" + range1 + \"H\" + k * tickSizeOuter\n            : \"M\" + range0 + \",\" + k * tickSizeOuter + \"V0.5H\" + range1 + \"V\" + k * tickSizeOuter);\n\n    tick\n        .attr(\"opacity\", 1)\n        .attr(\"transform\", function(d) { return transform(position, position, d); });\n\n    line\n        .attr(x + \"2\", k * tickSizeInner);\n\n    text\n        .attr(x, k * spacing)\n        .text(format);\n\n    selection.filter(entering)\n        .attr(\"fill\", \"none\")\n        .attr(\"font-size\", 10)\n        .attr(\"font-family\", \"sans-serif\")\n        .attr(\"text-anchor\", orient === right ? \"start\" : orient === left ? \"end\" : \"middle\");\n\n    selection\n        .each(function() { this.__axis = position; });\n  }\n\n  axis.scale = function(_) {\n    return arguments.length ? (scale = _, axis) : scale;\n  };\n\n  axis.ticks = function() {\n    return tickArguments = slice$1.call(arguments), axis;\n  };\n\n  axis.tickArguments = function(_) {\n    return arguments.length ? (tickArguments = _ == null ? [] : slice$1.call(_), axis) : tickArguments.slice();\n  };\n\n  axis.tickValues = function(_) {\n    return arguments.length ? (tickValues = _ == null ? null : slice$1.call(_), axis) : tickValues && tickValues.slice();\n  };\n\n  axis.tickFormat = function(_) {\n    return arguments.length ? (tickFormat = _, axis) : tickFormat;\n  };\n\n  axis.tickSize = function(_) {\n    return arguments.length ? (tickSizeInner = tickSizeOuter = +_, axis) : tickSizeInner;\n  };\n\n  axis.tickSizeInner = function(_) {\n    return arguments.length ? (tickSizeInner = +_, axis) : tickSizeInner;\n  };\n\n  axis.tickSizeOuter = function(_) {\n    return arguments.length ? (tickSizeOuter = +_, axis) : tickSizeOuter;\n  };\n\n  axis.tickPadding = function(_) {\n    return arguments.length ? (tickPadding = +_, axis) : tickPadding;\n  };\n\n  return axis;\n}\n\nfunction axisTop(scale) {\n  return axis(top, scale);\n}\n\nfunction axisRight(scale) {\n  return axis(right, scale);\n}\n\nfunction axisBottom(scale) {\n  return axis(bottom, scale);\n}\n\nfunction axisLeft(scale) {\n  return axis(left, scale);\n}\n\nvar noop = {value: function() {}};\n\nfunction dispatch() {\n  for (var i = 0, n = arguments.length, _ = {}, t; i < n; ++i) {\n    if (!(t = arguments[i] + \"\") || (t in _)) throw new Error(\"illegal type: \" + t);\n    _[t] = [];\n  }\n  return new Dispatch(_);\n}\n\nfunction Dispatch(_) {\n  this._ = _;\n}\n\nfunction parseTypenames(typenames, types) {\n  return typenames.trim().split(/^|\\s+/).map(function(t) {\n    var name = \"\", i = t.indexOf(\".\");\n    if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);\n    if (t && !types.hasOwnProperty(t)) throw new Error(\"unknown type: \" + t);\n    return {type: t, name: name};\n  });\n}\n\nDispatch.prototype = dispatch.prototype = {\n  constructor: Dispatch,\n  on: function(typename, callback) {\n    var _ = this._,\n        T = parseTypenames(typename + \"\", _),\n        t,\n        i = -1,\n        n = T.length;\n\n    // If no callback was specified, return the callback of the given type and name.\n    if (arguments.length < 2) {\n      while (++i < n) if ((t = (typename = T[i]).type) && (t = get(_[t], typename.name))) return t;\n      return;\n    }\n\n    // If a type was specified, set the callback for the given type and name.\n    // Otherwise, if a null callback was specified, remove callbacks of the given name.\n    if (callback != null && typeof callback !== \"function\") throw new Error(\"invalid callback: \" + callback);\n    while (++i < n) {\n      if (t = (typename = T[i]).type) _[t] = set(_[t], typename.name, callback);\n      else if (callback == null) for (t in _) _[t] = set(_[t], typename.name, null);\n    }\n\n    return this;\n  },\n  copy: function() {\n    var copy = {}, _ = this._;\n    for (var t in _) copy[t] = _[t].slice();\n    return new Dispatch(copy);\n  },\n  call: function(type, that) {\n    if ((n = arguments.length - 2) > 0) for (var args = new Array(n), i = 0, n, t; i < n; ++i) args[i] = arguments[i + 2];\n    if (!this._.hasOwnProperty(type)) throw new Error(\"unknown type: \" + type);\n    for (t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);\n  },\n  apply: function(type, that, args) {\n    if (!this._.hasOwnProperty(type)) throw new Error(\"unknown type: \" + type);\n    for (var t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);\n  }\n};\n\nfunction get(type, name) {\n  for (var i = 0, n = type.length, c; i < n; ++i) {\n    if ((c = type[i]).name === name) {\n      return c.value;\n    }\n  }\n}\n\nfunction set(type, name, callback) {\n  for (var i = 0, n = type.length; i < n; ++i) {\n    if (type[i].name === name) {\n      type[i] = noop, type = type.slice(0, i).concat(type.slice(i + 1));\n      break;\n    }\n  }\n  if (callback != null) type.push({name: name, value: callback});\n  return type;\n}\n\nvar xhtml = \"http://www.w3.org/1999/xhtml\";\n\nvar namespaces = {\n  svg: \"http://www.w3.org/2000/svg\",\n  xhtml: xhtml,\n  xlink: \"http://www.w3.org/1999/xlink\",\n  xml: \"http://www.w3.org/XML/1998/namespace\",\n  xmlns: \"http://www.w3.org/2000/xmlns/\"\n};\n\nvar namespace = function(name) {\n  var prefix = name += \"\", i = prefix.indexOf(\":\");\n  if (i >= 0 && (prefix = name.slice(0, i)) !== \"xmlns\") name = name.slice(i + 1);\n  return namespaces.hasOwnProperty(prefix) ? {space: namespaces[prefix], local: name} : name;\n};\n\nfunction creatorInherit(name) {\n  return function() {\n    var document = this.ownerDocument,\n        uri = this.namespaceURI;\n    return uri === xhtml && document.documentElement.namespaceURI === xhtml\n        ? document.createElement(name)\n        : document.createElementNS(uri, name);\n  };\n}\n\nfunction creatorFixed(fullname) {\n  return function() {\n    return this.ownerDocument.createElementNS(fullname.space, fullname.local);\n  };\n}\n\nvar creator = function(name) {\n  var fullname = namespace(name);\n  return (fullname.local\n      ? creatorFixed\n      : creatorInherit)(fullname);\n};\n\nvar nextId = 0;\n\nfunction local$1() {\n  return new Local;\n}\n\nfunction Local() {\n  this._ = \"@\" + (++nextId).toString(36);\n}\n\nLocal.prototype = local$1.prototype = {\n  constructor: Local,\n  get: function(node) {\n    var id = this._;\n    while (!(id in node)) if (!(node = node.parentNode)) return;\n    return node[id];\n  },\n  set: function(node, value) {\n    return node[this._] = value;\n  },\n  remove: function(node) {\n    return this._ in node && delete node[this._];\n  },\n  toString: function() {\n    return this._;\n  }\n};\n\nvar matcher = function(selector) {\n  return function() {\n    return this.matches(selector);\n  };\n};\n\nif (typeof document !== \"undefined\") {\n  var element = document.documentElement;\n  if (!element.matches) {\n    var vendorMatches = element.webkitMatchesSelector\n        || element.msMatchesSelector\n        || element.mozMatchesSelector\n        || element.oMatchesSelector;\n    matcher = function(selector) {\n      return function() {\n        return vendorMatches.call(this, selector);\n      };\n    };\n  }\n}\n\nvar matcher$1 = matcher;\n\nvar filterEvents = {};\n\nexports.event = null;\n\nif (typeof document !== \"undefined\") {\n  var element$1 = document.documentElement;\n  if (!(\"onmouseenter\" in element$1)) {\n    filterEvents = {mouseenter: \"mouseover\", mouseleave: \"mouseout\"};\n  }\n}\n\nfunction filterContextListener(listener, index, group) {\n  listener = contextListener(listener, index, group);\n  return function(event) {\n    var related = event.relatedTarget;\n    if (!related || (related !== this && !(related.compareDocumentPosition(this) & 8))) {\n      listener.call(this, event);\n    }\n  };\n}\n\nfunction contextListener(listener, index, group) {\n  return function(event1) {\n    var event0 = exports.event; // Events can be reentrant (e.g., focus).\n    exports.event = event1;\n    try {\n      listener.call(this, this.__data__, index, group);\n    } finally {\n      exports.event = event0;\n    }\n  };\n}\n\nfunction parseTypenames$1(typenames) {\n  return typenames.trim().split(/^|\\s+/).map(function(t) {\n    var name = \"\", i = t.indexOf(\".\");\n    if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);\n    return {type: t, name: name};\n  });\n}\n\nfunction onRemove(typename) {\n  return function() {\n    var on = this.__on;\n    if (!on) return;\n    for (var j = 0, i = -1, m = on.length, o; j < m; ++j) {\n      if (o = on[j], (!typename.type || o.type === typename.type) && o.name === typename.name) {\n        this.removeEventListener(o.type, o.listener, o.capture);\n      } else {\n        on[++i] = o;\n      }\n    }\n    if (++i) on.length = i;\n    else delete this.__on;\n  };\n}\n\nfunction onAdd(typename, value, capture) {\n  var wrap = filterEvents.hasOwnProperty(typename.type) ? filterContextListener : contextListener;\n  return function(d, i, group) {\n    var on = this.__on, o, listener = wrap(value, i, group);\n    if (on) for (var j = 0, m = on.length; j < m; ++j) {\n      if ((o = on[j]).type === typename.type && o.name === typename.name) {\n        this.removeEventListener(o.type, o.listener, o.capture);\n        this.addEventListener(o.type, o.listener = listener, o.capture = capture);\n        o.value = value;\n        return;\n      }\n    }\n    this.addEventListener(typename.type, listener, capture);\n    o = {type: typename.type, name: typename.name, value: value, listener: listener, capture: capture};\n    if (!on) this.__on = [o];\n    else on.push(o);\n  };\n}\n\nvar selection_on = function(typename, value, capture) {\n  var typenames = parseTypenames$1(typename + \"\"), i, n = typenames.length, t;\n\n  if (arguments.length < 2) {\n    var on = this.node().__on;\n    if (on) for (var j = 0, m = on.length, o; j < m; ++j) {\n      for (i = 0, o = on[j]; i < n; ++i) {\n        if ((t = typenames[i]).type === o.type && t.name === o.name) {\n          return o.value;\n        }\n      }\n    }\n    return;\n  }\n\n  on = value ? onAdd : onRemove;\n  if (capture == null) capture = false;\n  for (i = 0; i < n; ++i) this.each(on(typenames[i], value, capture));\n  return this;\n};\n\nfunction customEvent(event1, listener, that, args) {\n  var event0 = exports.event;\n  event1.sourceEvent = exports.event;\n  exports.event = event1;\n  try {\n    return listener.apply(that, args);\n  } finally {\n    exports.event = event0;\n  }\n}\n\nvar sourceEvent = function() {\n  var current = exports.event, source;\n  while (source = current.sourceEvent) current = source;\n  return current;\n};\n\nvar point = function(node, event) {\n  var svg = node.ownerSVGElement || node;\n\n  if (svg.createSVGPoint) {\n    var point = svg.createSVGPoint();\n    point.x = event.clientX, point.y = event.clientY;\n    point = point.matrixTransform(node.getScreenCTM().inverse());\n    return [point.x, point.y];\n  }\n\n  var rect = node.getBoundingClientRect();\n  return [event.clientX - rect.left - node.clientLeft, event.clientY - rect.top - node.clientTop];\n};\n\nvar mouse = function(node) {\n  var event = sourceEvent();\n  if (event.changedTouches) event = event.changedTouches[0];\n  return point(node, event);\n};\n\nfunction none() {}\n\nvar selector = function(selector) {\n  return selector == null ? none : function() {\n    return this.querySelector(selector);\n  };\n};\n\nvar selection_select = function(select) {\n  if (typeof select !== \"function\") select = selector(select);\n\n  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {\n    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) {\n      if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) {\n        if (\"__data__\" in node) subnode.__data__ = node.__data__;\n        subgroup[i] = subnode;\n      }\n    }\n  }\n\n  return new Selection(subgroups, this._parents);\n};\n\nfunction empty$1() {\n  return [];\n}\n\nvar selectorAll = function(selector) {\n  return selector == null ? empty$1 : function() {\n    return this.querySelectorAll(selector);\n  };\n};\n\nvar selection_selectAll = function(select) {\n  if (typeof select !== \"function\") select = selectorAll(select);\n\n  for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) {\n    for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {\n      if (node = group[i]) {\n        subgroups.push(select.call(node, node.__data__, i, group));\n        parents.push(node);\n      }\n    }\n  }\n\n  return new Selection(subgroups, parents);\n};\n\nvar selection_filter = function(match) {\n  if (typeof match !== \"function\") match = matcher$1(match);\n\n  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {\n    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) {\n      if ((node = group[i]) && match.call(node, node.__data__, i, group)) {\n        subgroup.push(node);\n      }\n    }\n  }\n\n  return new Selection(subgroups, this._parents);\n};\n\nvar sparse = function(update) {\n  return new Array(update.length);\n};\n\nvar selection_enter = function() {\n  return new Selection(this._enter || this._groups.map(sparse), this._parents);\n};\n\nfunction EnterNode(parent, datum) {\n  this.ownerDocument = parent.ownerDocument;\n  this.namespaceURI = parent.namespaceURI;\n  this._next = null;\n  this._parent = parent;\n  this.__data__ = datum;\n}\n\nEnterNode.prototype = {\n  constructor: EnterNode,\n  appendChild: function(child) { return this._parent.insertBefore(child, this._next); },\n  insertBefore: function(child, next) { return this._parent.insertBefore(child, next); },\n  querySelector: function(selector) { return this._parent.querySelector(selector); },\n  querySelectorAll: function(selector) { return this._parent.querySelectorAll(selector); }\n};\n\nvar constant$1 = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nvar keyPrefix = \"$\"; // Protect against keys like “__proto__”.\n\nfunction bindIndex(parent, group, enter, update, exit, data) {\n  var i = 0,\n      node,\n      groupLength = group.length,\n      dataLength = data.length;\n\n  // Put any non-null nodes that fit into update.\n  // Put any null nodes into enter.\n  // Put any remaining data into enter.\n  for (; i < dataLength; ++i) {\n    if (node = group[i]) {\n      node.__data__ = data[i];\n      update[i] = node;\n    } else {\n      enter[i] = new EnterNode(parent, data[i]);\n    }\n  }\n\n  // Put any non-null nodes that don’t fit into exit.\n  for (; i < groupLength; ++i) {\n    if (node = group[i]) {\n      exit[i] = node;\n    }\n  }\n}\n\nfunction bindKey(parent, group, enter, update, exit, data, key) {\n  var i,\n      node,\n      nodeByKeyValue = {},\n      groupLength = group.length,\n      dataLength = data.length,\n      keyValues = new Array(groupLength),\n      keyValue;\n\n  // Compute the key for each node.\n  // If multiple nodes have the same key, the duplicates are added to exit.\n  for (i = 0; i < groupLength; ++i) {\n    if (node = group[i]) {\n      keyValues[i] = keyValue = keyPrefix + key.call(node, node.__data__, i, group);\n      if (keyValue in nodeByKeyValue) {\n        exit[i] = node;\n      } else {\n        nodeByKeyValue[keyValue] = node;\n      }\n    }\n  }\n\n  // Compute the key for each datum.\n  // If there a node associated with this key, join and add it to update.\n  // If there is not (or the key is a duplicate), add it to enter.\n  for (i = 0; i < dataLength; ++i) {\n    keyValue = keyPrefix + key.call(parent, data[i], i, data);\n    if (node = nodeByKeyValue[keyValue]) {\n      update[i] = node;\n      node.__data__ = data[i];\n      nodeByKeyValue[keyValue] = null;\n    } else {\n      enter[i] = new EnterNode(parent, data[i]);\n    }\n  }\n\n  // Add any remaining nodes that were not bound to data to exit.\n  for (i = 0; i < groupLength; ++i) {\n    if ((node = group[i]) && (nodeByKeyValue[keyValues[i]] === node)) {\n      exit[i] = node;\n    }\n  }\n}\n\nvar selection_data = function(value, key) {\n  if (!value) {\n    data = new Array(this.size()), j = -1;\n    this.each(function(d) { data[++j] = d; });\n    return data;\n  }\n\n  var bind = key ? bindKey : bindIndex,\n      parents = this._parents,\n      groups = this._groups;\n\n  if (typeof value !== \"function\") value = constant$1(value);\n\n  for (var m = groups.length, update = new Array(m), enter = new Array(m), exit = new Array(m), j = 0; j < m; ++j) {\n    var parent = parents[j],\n        group = groups[j],\n        groupLength = group.length,\n        data = value.call(parent, parent && parent.__data__, j, parents),\n        dataLength = data.length,\n        enterGroup = enter[j] = new Array(dataLength),\n        updateGroup = update[j] = new Array(dataLength),\n        exitGroup = exit[j] = new Array(groupLength);\n\n    bind(parent, group, enterGroup, updateGroup, exitGroup, data, key);\n\n    // Now connect the enter nodes to their following update node, such that\n    // appendChild can insert the materialized enter node before this node,\n    // rather than at the end of the parent node.\n    for (var i0 = 0, i1 = 0, previous, next; i0 < dataLength; ++i0) {\n      if (previous = enterGroup[i0]) {\n        if (i0 >= i1) i1 = i0 + 1;\n        while (!(next = updateGroup[i1]) && ++i1 < dataLength);\n        previous._next = next || null;\n      }\n    }\n  }\n\n  update = new Selection(update, parents);\n  update._enter = enter;\n  update._exit = exit;\n  return update;\n};\n\nvar selection_exit = function() {\n  return new Selection(this._exit || this._groups.map(sparse), this._parents);\n};\n\nvar selection_merge = function(selection) {\n\n  for (var groups0 = this._groups, groups1 = selection._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) {\n    for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) {\n      if (node = group0[i] || group1[i]) {\n        merge[i] = node;\n      }\n    }\n  }\n\n  for (; j < m0; ++j) {\n    merges[j] = groups0[j];\n  }\n\n  return new Selection(merges, this._parents);\n};\n\nvar selection_order = function() {\n\n  for (var groups = this._groups, j = -1, m = groups.length; ++j < m;) {\n    for (var group = groups[j], i = group.length - 1, next = group[i], node; --i >= 0;) {\n      if (node = group[i]) {\n        if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next);\n        next = node;\n      }\n    }\n  }\n\n  return this;\n};\n\nvar selection_sort = function(compare) {\n  if (!compare) compare = ascending$1;\n\n  function compareNode(a, b) {\n    return a && b ? compare(a.__data__, b.__data__) : !a - !b;\n  }\n\n  for (var groups = this._groups, m = groups.length, sortgroups = new Array(m), j = 0; j < m; ++j) {\n    for (var group = groups[j], n = group.length, sortgroup = sortgroups[j] = new Array(n), node, i = 0; i < n; ++i) {\n      if (node = group[i]) {\n        sortgroup[i] = node;\n      }\n    }\n    sortgroup.sort(compareNode);\n  }\n\n  return new Selection(sortgroups, this._parents).order();\n};\n\nfunction ascending$1(a, b) {\n  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;\n}\n\nvar selection_call = function() {\n  var callback = arguments[0];\n  arguments[0] = this;\n  callback.apply(null, arguments);\n  return this;\n};\n\nvar selection_nodes = function() {\n  var nodes = new Array(this.size()), i = -1;\n  this.each(function() { nodes[++i] = this; });\n  return nodes;\n};\n\nvar selection_node = function() {\n\n  for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {\n    for (var group = groups[j], i = 0, n = group.length; i < n; ++i) {\n      var node = group[i];\n      if (node) return node;\n    }\n  }\n\n  return null;\n};\n\nvar selection_size = function() {\n  var size = 0;\n  this.each(function() { ++size; });\n  return size;\n};\n\nvar selection_empty = function() {\n  return !this.node();\n};\n\nvar selection_each = function(callback) {\n\n  for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {\n    for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) {\n      if (node = group[i]) callback.call(node, node.__data__, i, group);\n    }\n  }\n\n  return this;\n};\n\nfunction attrRemove(name) {\n  return function() {\n    this.removeAttribute(name);\n  };\n}\n\nfunction attrRemoveNS(fullname) {\n  return function() {\n    this.removeAttributeNS(fullname.space, fullname.local);\n  };\n}\n\nfunction attrConstant(name, value) {\n  return function() {\n    this.setAttribute(name, value);\n  };\n}\n\nfunction attrConstantNS(fullname, value) {\n  return function() {\n    this.setAttributeNS(fullname.space, fullname.local, value);\n  };\n}\n\nfunction attrFunction(name, value) {\n  return function() {\n    var v = value.apply(this, arguments);\n    if (v == null) this.removeAttribute(name);\n    else this.setAttribute(name, v);\n  };\n}\n\nfunction attrFunctionNS(fullname, value) {\n  return function() {\n    var v = value.apply(this, arguments);\n    if (v == null) this.removeAttributeNS(fullname.space, fullname.local);\n    else this.setAttributeNS(fullname.space, fullname.local, v);\n  };\n}\n\nvar selection_attr = function(name, value) {\n  var fullname = namespace(name);\n\n  if (arguments.length < 2) {\n    var node = this.node();\n    return fullname.local\n        ? node.getAttributeNS(fullname.space, fullname.local)\n        : node.getAttribute(fullname);\n  }\n\n  return this.each((value == null\n      ? (fullname.local ? attrRemoveNS : attrRemove) : (typeof value === \"function\"\n      ? (fullname.local ? attrFunctionNS : attrFunction)\n      : (fullname.local ? attrConstantNS : attrConstant)))(fullname, value));\n};\n\nvar window = function(node) {\n  return (node.ownerDocument && node.ownerDocument.defaultView) // node is a Node\n      || (node.document && node) // node is a Window\n      || node.defaultView; // node is a Document\n};\n\nfunction styleRemove(name) {\n  return function() {\n    this.style.removeProperty(name);\n  };\n}\n\nfunction styleConstant(name, value, priority) {\n  return function() {\n    this.style.setProperty(name, value, priority);\n  };\n}\n\nfunction styleFunction(name, value, priority) {\n  return function() {\n    var v = value.apply(this, arguments);\n    if (v == null) this.style.removeProperty(name);\n    else this.style.setProperty(name, v, priority);\n  };\n}\n\nvar selection_style = function(name, value, priority) {\n  var node;\n  return arguments.length > 1\n      ? this.each((value == null\n            ? styleRemove : typeof value === \"function\"\n            ? styleFunction\n            : styleConstant)(name, value, priority == null ? \"\" : priority))\n      : window(node = this.node())\n          .getComputedStyle(node, null)\n          .getPropertyValue(name);\n};\n\nfunction propertyRemove(name) {\n  return function() {\n    delete this[name];\n  };\n}\n\nfunction propertyConstant(name, value) {\n  return function() {\n    this[name] = value;\n  };\n}\n\nfunction propertyFunction(name, value) {\n  return function() {\n    var v = value.apply(this, arguments);\n    if (v == null) delete this[name];\n    else this[name] = v;\n  };\n}\n\nvar selection_property = function(name, value) {\n  return arguments.length > 1\n      ? this.each((value == null\n          ? propertyRemove : typeof value === \"function\"\n          ? propertyFunction\n          : propertyConstant)(name, value))\n      : this.node()[name];\n};\n\nfunction classArray(string) {\n  return string.trim().split(/^|\\s+/);\n}\n\nfunction classList(node) {\n  return node.classList || new ClassList(node);\n}\n\nfunction ClassList(node) {\n  this._node = node;\n  this._names = classArray(node.getAttribute(\"class\") || \"\");\n}\n\nClassList.prototype = {\n  add: function(name) {\n    var i = this._names.indexOf(name);\n    if (i < 0) {\n      this._names.push(name);\n      this._node.setAttribute(\"class\", this._names.join(\" \"));\n    }\n  },\n  remove: function(name) {\n    var i = this._names.indexOf(name);\n    if (i >= 0) {\n      this._names.splice(i, 1);\n      this._node.setAttribute(\"class\", this._names.join(\" \"));\n    }\n  },\n  contains: function(name) {\n    return this._names.indexOf(name) >= 0;\n  }\n};\n\nfunction classedAdd(node, names) {\n  var list = classList(node), i = -1, n = names.length;\n  while (++i < n) list.add(names[i]);\n}\n\nfunction classedRemove(node, names) {\n  var list = classList(node), i = -1, n = names.length;\n  while (++i < n) list.remove(names[i]);\n}\n\nfunction classedTrue(names) {\n  return function() {\n    classedAdd(this, names);\n  };\n}\n\nfunction classedFalse(names) {\n  return function() {\n    classedRemove(this, names);\n  };\n}\n\nfunction classedFunction(names, value) {\n  return function() {\n    (value.apply(this, arguments) ? classedAdd : classedRemove)(this, names);\n  };\n}\n\nvar selection_classed = function(name, value) {\n  var names = classArray(name + \"\");\n\n  if (arguments.length < 2) {\n    var list = classList(this.node()), i = -1, n = names.length;\n    while (++i < n) if (!list.contains(names[i])) return false;\n    return true;\n  }\n\n  return this.each((typeof value === \"function\"\n      ? classedFunction : value\n      ? classedTrue\n      : classedFalse)(names, value));\n};\n\nfunction textRemove() {\n  this.textContent = \"\";\n}\n\nfunction textConstant(value) {\n  return function() {\n    this.textContent = value;\n  };\n}\n\nfunction textFunction(value) {\n  return function() {\n    var v = value.apply(this, arguments);\n    this.textContent = v == null ? \"\" : v;\n  };\n}\n\nvar selection_text = function(value) {\n  return arguments.length\n      ? this.each(value == null\n          ? textRemove : (typeof value === \"function\"\n          ? textFunction\n          : textConstant)(value))\n      : this.node().textContent;\n};\n\nfunction htmlRemove() {\n  this.innerHTML = \"\";\n}\n\nfunction htmlConstant(value) {\n  return function() {\n    this.innerHTML = value;\n  };\n}\n\nfunction htmlFunction(value) {\n  return function() {\n    var v = value.apply(this, arguments);\n    this.innerHTML = v == null ? \"\" : v;\n  };\n}\n\nvar selection_html = function(value) {\n  return arguments.length\n      ? this.each(value == null\n          ? htmlRemove : (typeof value === \"function\"\n          ? htmlFunction\n          : htmlConstant)(value))\n      : this.node().innerHTML;\n};\n\nfunction raise() {\n  if (this.nextSibling) this.parentNode.appendChild(this);\n}\n\nvar selection_raise = function() {\n  return this.each(raise);\n};\n\nfunction lower() {\n  if (this.previousSibling) this.parentNode.insertBefore(this, this.parentNode.firstChild);\n}\n\nvar selection_lower = function() {\n  return this.each(lower);\n};\n\nvar selection_append = function(name) {\n  var create = typeof name === \"function\" ? name : creator(name);\n  return this.select(function() {\n    return this.appendChild(create.apply(this, arguments));\n  });\n};\n\nfunction constantNull() {\n  return null;\n}\n\nvar selection_insert = function(name, before) {\n  var create = typeof name === \"function\" ? name : creator(name),\n      select = before == null ? constantNull : typeof before === \"function\" ? before : selector(before);\n  return this.select(function() {\n    return this.insertBefore(create.apply(this, arguments), select.apply(this, arguments) || null);\n  });\n};\n\nfunction remove() {\n  var parent = this.parentNode;\n  if (parent) parent.removeChild(this);\n}\n\nvar selection_remove = function() {\n  return this.each(remove);\n};\n\nvar selection_datum = function(value) {\n  return arguments.length\n      ? this.property(\"__data__\", value)\n      : this.node().__data__;\n};\n\nfunction dispatchEvent(node, type, params) {\n  var window$$1 = window(node),\n      event = window$$1.CustomEvent;\n\n  if (event) {\n    event = new event(type, params);\n  } else {\n    event = window$$1.document.createEvent(\"Event\");\n    if (params) event.initEvent(type, params.bubbles, params.cancelable), event.detail = params.detail;\n    else event.initEvent(type, false, false);\n  }\n\n  node.dispatchEvent(event);\n}\n\nfunction dispatchConstant(type, params) {\n  return function() {\n    return dispatchEvent(this, type, params);\n  };\n}\n\nfunction dispatchFunction(type, params) {\n  return function() {\n    return dispatchEvent(this, type, params.apply(this, arguments));\n  };\n}\n\nvar selection_dispatch = function(type, params) {\n  return this.each((typeof params === \"function\"\n      ? dispatchFunction\n      : dispatchConstant)(type, params));\n};\n\nvar root = [null];\n\nfunction Selection(groups, parents) {\n  this._groups = groups;\n  this._parents = parents;\n}\n\nfunction selection() {\n  return new Selection([[document.documentElement]], root);\n}\n\nSelection.prototype = selection.prototype = {\n  constructor: Selection,\n  select: selection_select,\n  selectAll: selection_selectAll,\n  filter: selection_filter,\n  data: selection_data,\n  enter: selection_enter,\n  exit: selection_exit,\n  merge: selection_merge,\n  order: selection_order,\n  sort: selection_sort,\n  call: selection_call,\n  nodes: selection_nodes,\n  node: selection_node,\n  size: selection_size,\n  empty: selection_empty,\n  each: selection_each,\n  attr: selection_attr,\n  style: selection_style,\n  property: selection_property,\n  classed: selection_classed,\n  text: selection_text,\n  html: selection_html,\n  raise: selection_raise,\n  lower: selection_lower,\n  append: selection_append,\n  insert: selection_insert,\n  remove: selection_remove,\n  datum: selection_datum,\n  on: selection_on,\n  dispatch: selection_dispatch\n};\n\nvar select = function(selector) {\n  return typeof selector === \"string\"\n      ? new Selection([[document.querySelector(selector)]], [document.documentElement])\n      : new Selection([[selector]], root);\n};\n\nvar selectAll = function(selector) {\n  return typeof selector === \"string\"\n      ? new Selection([document.querySelectorAll(selector)], [document.documentElement])\n      : new Selection([selector == null ? [] : selector], root);\n};\n\nvar touch = function(node, touches, identifier) {\n  if (arguments.length < 3) identifier = touches, touches = sourceEvent().changedTouches;\n\n  for (var i = 0, n = touches ? touches.length : 0, touch; i < n; ++i) {\n    if ((touch = touches[i]).identifier === identifier) {\n      return point(node, touch);\n    }\n  }\n\n  return null;\n};\n\nvar touches = function(node, touches) {\n  if (touches == null) touches = sourceEvent().touches;\n\n  for (var i = 0, n = touches ? touches.length : 0, points = new Array(n); i < n; ++i) {\n    points[i] = point(node, touches[i]);\n  }\n\n  return points;\n};\n\nfunction nopropagation() {\n  exports.event.stopImmediatePropagation();\n}\n\nvar noevent = function() {\n  exports.event.preventDefault();\n  exports.event.stopImmediatePropagation();\n};\n\nvar dragDisable = function(view) {\n  var root = view.document.documentElement,\n      selection$$1 = select(view).on(\"dragstart.drag\", noevent, true);\n  if (\"onselectstart\" in root) {\n    selection$$1.on(\"selectstart.drag\", noevent, true);\n  } else {\n    root.__noselect = root.style.MozUserSelect;\n    root.style.MozUserSelect = \"none\";\n  }\n};\n\nfunction yesdrag(view, noclick) {\n  var root = view.document.documentElement,\n      selection$$1 = select(view).on(\"dragstart.drag\", null);\n  if (noclick) {\n    selection$$1.on(\"click.drag\", noevent, true);\n    setTimeout(function() { selection$$1.on(\"click.drag\", null); }, 0);\n  }\n  if (\"onselectstart\" in root) {\n    selection$$1.on(\"selectstart.drag\", null);\n  } else {\n    root.style.MozUserSelect = root.__noselect;\n    delete root.__noselect;\n  }\n}\n\nvar constant$2 = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nfunction DragEvent(target, type, subject, id, active, x, y, dx, dy, dispatch) {\n  this.target = target;\n  this.type = type;\n  this.subject = subject;\n  this.identifier = id;\n  this.active = active;\n  this.x = x;\n  this.y = y;\n  this.dx = dx;\n  this.dy = dy;\n  this._ = dispatch;\n}\n\nDragEvent.prototype.on = function() {\n  var value = this._.on.apply(this._, arguments);\n  return value === this._ ? this : value;\n};\n\n// Ignore right-click, since that should open the context menu.\nfunction defaultFilter$1() {\n  return !exports.event.button;\n}\n\nfunction defaultContainer() {\n  return this.parentNode;\n}\n\nfunction defaultSubject(d) {\n  return d == null ? {x: exports.event.x, y: exports.event.y} : d;\n}\n\nvar drag = function() {\n  var filter = defaultFilter$1,\n      container = defaultContainer,\n      subject = defaultSubject,\n      gestures = {},\n      listeners = dispatch(\"start\", \"drag\", \"end\"),\n      active = 0,\n      mousemoving,\n      touchending;\n\n  function drag(selection$$1) {\n    selection$$1\n        .on(\"mousedown.drag\", mousedowned)\n        .on(\"touchstart.drag\", touchstarted)\n        .on(\"touchmove.drag\", touchmoved)\n        .on(\"touchend.drag touchcancel.drag\", touchended)\n        .style(\"-webkit-tap-highlight-color\", \"rgba(0,0,0,0)\");\n  }\n\n  function mousedowned() {\n    if (touchending || !filter.apply(this, arguments)) return;\n    var gesture = beforestart(\"mouse\", container.apply(this, arguments), mouse, this, arguments);\n    if (!gesture) return;\n    select(exports.event.view).on(\"mousemove.drag\", mousemoved, true).on(\"mouseup.drag\", mouseupped, true);\n    dragDisable(exports.event.view);\n    nopropagation();\n    mousemoving = false;\n    gesture(\"start\");\n  }\n\n  function mousemoved() {\n    noevent();\n    mousemoving = true;\n    gestures.mouse(\"drag\");\n  }\n\n  function mouseupped() {\n    select(exports.event.view).on(\"mousemove.drag mouseup.drag\", null);\n    yesdrag(exports.event.view, mousemoving);\n    noevent();\n    gestures.mouse(\"end\");\n  }\n\n  function touchstarted() {\n    if (!filter.apply(this, arguments)) return;\n    var touches$$1 = exports.event.changedTouches,\n        c = container.apply(this, arguments),\n        n = touches$$1.length, i, gesture;\n\n    for (i = 0; i < n; ++i) {\n      if (gesture = beforestart(touches$$1[i].identifier, c, touch, this, arguments)) {\n        nopropagation();\n        gesture(\"start\");\n      }\n    }\n  }\n\n  function touchmoved() {\n    var touches$$1 = exports.event.changedTouches,\n        n = touches$$1.length, i, gesture;\n\n    for (i = 0; i < n; ++i) {\n      if (gesture = gestures[touches$$1[i].identifier]) {\n        noevent();\n        gesture(\"drag\");\n      }\n    }\n  }\n\n  function touchended() {\n    var touches$$1 = exports.event.changedTouches,\n        n = touches$$1.length, i, gesture;\n\n    if (touchending) clearTimeout(touchending);\n    touchending = setTimeout(function() { touchending = null; }, 500); // Ghost clicks are delayed!\n    for (i = 0; i < n; ++i) {\n      if (gesture = gestures[touches$$1[i].identifier]) {\n        nopropagation();\n        gesture(\"end\");\n      }\n    }\n  }\n\n  function beforestart(id, container, point, that, args) {\n    var p = point(container, id), s, dx, dy,\n        sublisteners = listeners.copy();\n\n    if (!customEvent(new DragEvent(drag, \"beforestart\", s, id, active, p[0], p[1], 0, 0, sublisteners), function() {\n      if ((exports.event.subject = s = subject.apply(that, args)) == null) return false;\n      dx = s.x - p[0] || 0;\n      dy = s.y - p[1] || 0;\n      return true;\n    })) return;\n\n    return function gesture(type) {\n      var p0 = p, n;\n      switch (type) {\n        case \"start\": gestures[id] = gesture, n = active++; break;\n        case \"end\": delete gestures[id], --active; // nobreak\n        case \"drag\": p = point(container, id), n = active; break;\n      }\n      customEvent(new DragEvent(drag, type, s, id, n, p[0] + dx, p[1] + dy, p[0] - p0[0], p[1] - p0[1], sublisteners), sublisteners.apply, sublisteners, [type, that, args]);\n    };\n  }\n\n  drag.filter = function(_) {\n    return arguments.length ? (filter = typeof _ === \"function\" ? _ : constant$2(!!_), drag) : filter;\n  };\n\n  drag.container = function(_) {\n    return arguments.length ? (container = typeof _ === \"function\" ? _ : constant$2(_), drag) : container;\n  };\n\n  drag.subject = function(_) {\n    return arguments.length ? (subject = typeof _ === \"function\" ? _ : constant$2(_), drag) : subject;\n  };\n\n  drag.on = function() {\n    var value = listeners.on.apply(listeners, arguments);\n    return value === listeners ? drag : value;\n  };\n\n  return drag;\n};\n\nvar define = function(constructor, factory, prototype) {\n  constructor.prototype = factory.prototype = prototype;\n  prototype.constructor = constructor;\n};\n\nfunction extend(parent, definition) {\n  var prototype = Object.create(parent.prototype);\n  for (var key in definition) prototype[key] = definition[key];\n  return prototype;\n}\n\nfunction Color() {}\n\nvar darker = 0.7;\nvar brighter = 1 / darker;\n\nvar reI = \"\\\\s*([+-]?\\\\d+)\\\\s*\";\nvar reN = \"\\\\s*([+-]?\\\\d*\\\\.?\\\\d+(?:[eE][+-]?\\\\d+)?)\\\\s*\";\nvar reP = \"\\\\s*([+-]?\\\\d*\\\\.?\\\\d+(?:[eE][+-]?\\\\d+)?)%\\\\s*\";\nvar reHex3 = /^#([0-9a-f]{3})$/;\nvar reHex6 = /^#([0-9a-f]{6})$/;\nvar reRgbInteger = new RegExp(\"^rgb\\\\(\" + [reI, reI, reI] + \"\\\\)$\");\nvar reRgbPercent = new RegExp(\"^rgb\\\\(\" + [reP, reP, reP] + \"\\\\)$\");\nvar reRgbaInteger = new RegExp(\"^rgba\\\\(\" + [reI, reI, reI, reN] + \"\\\\)$\");\nvar reRgbaPercent = new RegExp(\"^rgba\\\\(\" + [reP, reP, reP, reN] + \"\\\\)$\");\nvar reHslPercent = new RegExp(\"^hsl\\\\(\" + [reN, reP, reP] + \"\\\\)$\");\nvar reHslaPercent = new RegExp(\"^hsla\\\\(\" + [reN, reP, reP, reN] + \"\\\\)$\");\n\nvar named = {\n  aliceblue: 0xf0f8ff,\n  antiquewhite: 0xfaebd7,\n  aqua: 0x00ffff,\n  aquamarine: 0x7fffd4,\n  azure: 0xf0ffff,\n  beige: 0xf5f5dc,\n  bisque: 0xffe4c4,\n  black: 0x000000,\n  blanchedalmond: 0xffebcd,\n  blue: 0x0000ff,\n  blueviolet: 0x8a2be2,\n  brown: 0xa52a2a,\n  burlywood: 0xdeb887,\n  cadetblue: 0x5f9ea0,\n  chartreuse: 0x7fff00,\n  chocolate: 0xd2691e,\n  coral: 0xff7f50,\n  cornflowerblue: 0x6495ed,\n  cornsilk: 0xfff8dc,\n  crimson: 0xdc143c,\n  cyan: 0x00ffff,\n  darkblue: 0x00008b,\n  darkcyan: 0x008b8b,\n  darkgoldenrod: 0xb8860b,\n  darkgray: 0xa9a9a9,\n  darkgreen: 0x006400,\n  darkgrey: 0xa9a9a9,\n  darkkhaki: 0xbdb76b,\n  darkmagenta: 0x8b008b,\n  darkolivegreen: 0x556b2f,\n  darkorange: 0xff8c00,\n  darkorchid: 0x9932cc,\n  darkred: 0x8b0000,\n  darksalmon: 0xe9967a,\n  darkseagreen: 0x8fbc8f,\n  darkslateblue: 0x483d8b,\n  darkslategray: 0x2f4f4f,\n  darkslategrey: 0x2f4f4f,\n  darkturquoise: 0x00ced1,\n  darkviolet: 0x9400d3,\n  deeppink: 0xff1493,\n  deepskyblue: 0x00bfff,\n  dimgray: 0x696969,\n  dimgrey: 0x696969,\n  dodgerblue: 0x1e90ff,\n  firebrick: 0xb22222,\n  floralwhite: 0xfffaf0,\n  forestgreen: 0x228b22,\n  fuchsia: 0xff00ff,\n  gainsboro: 0xdcdcdc,\n  ghostwhite: 0xf8f8ff,\n  gold: 0xffd700,\n  goldenrod: 0xdaa520,\n  gray: 0x808080,\n  green: 0x008000,\n  greenyellow: 0xadff2f,\n  grey: 0x808080,\n  honeydew: 0xf0fff0,\n  hotpink: 0xff69b4,\n  indianred: 0xcd5c5c,\n  indigo: 0x4b0082,\n  ivory: 0xfffff0,\n  khaki: 0xf0e68c,\n  lavender: 0xe6e6fa,\n  lavenderblush: 0xfff0f5,\n  lawngreen: 0x7cfc00,\n  lemonchiffon: 0xfffacd,\n  lightblue: 0xadd8e6,\n  lightcoral: 0xf08080,\n  lightcyan: 0xe0ffff,\n  lightgoldenrodyellow: 0xfafad2,\n  lightgray: 0xd3d3d3,\n  lightgreen: 0x90ee90,\n  lightgrey: 0xd3d3d3,\n  lightpink: 0xffb6c1,\n  lightsalmon: 0xffa07a,\n  lightseagreen: 0x20b2aa,\n  lightskyblue: 0x87cefa,\n  lightslategray: 0x778899,\n  lightslategrey: 0x778899,\n  lightsteelblue: 0xb0c4de,\n  lightyellow: 0xffffe0,\n  lime: 0x00ff00,\n  limegreen: 0x32cd32,\n  linen: 0xfaf0e6,\n  magenta: 0xff00ff,\n  maroon: 0x800000,\n  mediumaquamarine: 0x66cdaa,\n  mediumblue: 0x0000cd,\n  mediumorchid: 0xba55d3,\n  mediumpurple: 0x9370db,\n  mediumseagreen: 0x3cb371,\n  mediumslateblue: 0x7b68ee,\n  mediumspringgreen: 0x00fa9a,\n  mediumturquoise: 0x48d1cc,\n  mediumvioletred: 0xc71585,\n  midnightblue: 0x191970,\n  mintcream: 0xf5fffa,\n  mistyrose: 0xffe4e1,\n  moccasin: 0xffe4b5,\n  navajowhite: 0xffdead,\n  navy: 0x000080,\n  oldlace: 0xfdf5e6,\n  olive: 0x808000,\n  olivedrab: 0x6b8e23,\n  orange: 0xffa500,\n  orangered: 0xff4500,\n  orchid: 0xda70d6,\n  palegoldenrod: 0xeee8aa,\n  palegreen: 0x98fb98,\n  paleturquoise: 0xafeeee,\n  palevioletred: 0xdb7093,\n  papayawhip: 0xffefd5,\n  peachpuff: 0xffdab9,\n  peru: 0xcd853f,\n  pink: 0xffc0cb,\n  plum: 0xdda0dd,\n  powderblue: 0xb0e0e6,\n  purple: 0x800080,\n  rebeccapurple: 0x663399,\n  red: 0xff0000,\n  rosybrown: 0xbc8f8f,\n  royalblue: 0x4169e1,\n  saddlebrown: 0x8b4513,\n  salmon: 0xfa8072,\n  sandybrown: 0xf4a460,\n  seagreen: 0x2e8b57,\n  seashell: 0xfff5ee,\n  sienna: 0xa0522d,\n  silver: 0xc0c0c0,\n  skyblue: 0x87ceeb,\n  slateblue: 0x6a5acd,\n  slategray: 0x708090,\n  slategrey: 0x708090,\n  snow: 0xfffafa,\n  springgreen: 0x00ff7f,\n  steelblue: 0x4682b4,\n  tan: 0xd2b48c,\n  teal: 0x008080,\n  thistle: 0xd8bfd8,\n  tomato: 0xff6347,\n  turquoise: 0x40e0d0,\n  violet: 0xee82ee,\n  wheat: 0xf5deb3,\n  white: 0xffffff,\n  whitesmoke: 0xf5f5f5,\n  yellow: 0xffff00,\n  yellowgreen: 0x9acd32\n};\n\ndefine(Color, color, {\n  displayable: function() {\n    return this.rgb().displayable();\n  },\n  toString: function() {\n    return this.rgb() + \"\";\n  }\n});\n\nfunction color(format) {\n  var m;\n  format = (format + \"\").trim().toLowerCase();\n  return (m = reHex3.exec(format)) ? (m = parseInt(m[1], 16), new Rgb((m >> 8 & 0xf) | (m >> 4 & 0x0f0), (m >> 4 & 0xf) | (m & 0xf0), ((m & 0xf) << 4) | (m & 0xf), 1)) // #f00\n      : (m = reHex6.exec(format)) ? rgbn(parseInt(m[1], 16)) // #ff0000\n      : (m = reRgbInteger.exec(format)) ? new Rgb(m[1], m[2], m[3], 1) // rgb(255, 0, 0)\n      : (m = reRgbPercent.exec(format)) ? new Rgb(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) // rgb(100%, 0%, 0%)\n      : (m = reRgbaInteger.exec(format)) ? rgba(m[1], m[2], m[3], m[4]) // rgba(255, 0, 0, 1)\n      : (m = reRgbaPercent.exec(format)) ? rgba(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) // rgb(100%, 0%, 0%, 1)\n      : (m = reHslPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) // hsl(120, 50%, 50%)\n      : (m = reHslaPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) // hsla(120, 50%, 50%, 1)\n      : named.hasOwnProperty(format) ? rgbn(named[format])\n      : format === \"transparent\" ? new Rgb(NaN, NaN, NaN, 0)\n      : null;\n}\n\nfunction rgbn(n) {\n  return new Rgb(n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff, 1);\n}\n\nfunction rgba(r, g, b, a) {\n  if (a <= 0) r = g = b = NaN;\n  return new Rgb(r, g, b, a);\n}\n\nfunction rgbConvert(o) {\n  if (!(o instanceof Color)) o = color(o);\n  if (!o) return new Rgb;\n  o = o.rgb();\n  return new Rgb(o.r, o.g, o.b, o.opacity);\n}\n\nfunction rgb(r, g, b, opacity) {\n  return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity);\n}\n\nfunction Rgb(r, g, b, opacity) {\n  this.r = +r;\n  this.g = +g;\n  this.b = +b;\n  this.opacity = +opacity;\n}\n\ndefine(Rgb, rgb, extend(Color, {\n  brighter: function(k) {\n    k = k == null ? brighter : Math.pow(brighter, k);\n    return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);\n  },\n  darker: function(k) {\n    k = k == null ? darker : Math.pow(darker, k);\n    return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);\n  },\n  rgb: function() {\n    return this;\n  },\n  displayable: function() {\n    return (0 <= this.r && this.r <= 255)\n        && (0 <= this.g && this.g <= 255)\n        && (0 <= this.b && this.b <= 255)\n        && (0 <= this.opacity && this.opacity <= 1);\n  },\n  toString: function() {\n    var a = this.opacity; a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a));\n    return (a === 1 ? \"rgb(\" : \"rgba(\")\n        + Math.max(0, Math.min(255, Math.round(this.r) || 0)) + \", \"\n        + Math.max(0, Math.min(255, Math.round(this.g) || 0)) + \", \"\n        + Math.max(0, Math.min(255, Math.round(this.b) || 0))\n        + (a === 1 ? \")\" : \", \" + a + \")\");\n  }\n}));\n\nfunction hsla(h, s, l, a) {\n  if (a <= 0) h = s = l = NaN;\n  else if (l <= 0 || l >= 1) h = s = NaN;\n  else if (s <= 0) h = NaN;\n  return new Hsl(h, s, l, a);\n}\n\nfunction hslConvert(o) {\n  if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity);\n  if (!(o instanceof Color)) o = color(o);\n  if (!o) return new Hsl;\n  if (o instanceof Hsl) return o;\n  o = o.rgb();\n  var r = o.r / 255,\n      g = o.g / 255,\n      b = o.b / 255,\n      min = Math.min(r, g, b),\n      max = Math.max(r, g, b),\n      h = NaN,\n      s = max - min,\n      l = (max + min) / 2;\n  if (s) {\n    if (r === max) h = (g - b) / s + (g < b) * 6;\n    else if (g === max) h = (b - r) / s + 2;\n    else h = (r - g) / s + 4;\n    s /= l < 0.5 ? max + min : 2 - max - min;\n    h *= 60;\n  } else {\n    s = l > 0 && l < 1 ? 0 : h;\n  }\n  return new Hsl(h, s, l, o.opacity);\n}\n\nfunction hsl(h, s, l, opacity) {\n  return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity);\n}\n\nfunction Hsl(h, s, l, opacity) {\n  this.h = +h;\n  this.s = +s;\n  this.l = +l;\n  this.opacity = +opacity;\n}\n\ndefine(Hsl, hsl, extend(Color, {\n  brighter: function(k) {\n    k = k == null ? brighter : Math.pow(brighter, k);\n    return new Hsl(this.h, this.s, this.l * k, this.opacity);\n  },\n  darker: function(k) {\n    k = k == null ? darker : Math.pow(darker, k);\n    return new Hsl(this.h, this.s, this.l * k, this.opacity);\n  },\n  rgb: function() {\n    var h = this.h % 360 + (this.h < 0) * 360,\n        s = isNaN(h) || isNaN(this.s) ? 0 : this.s,\n        l = this.l,\n        m2 = l + (l < 0.5 ? l : 1 - l) * s,\n        m1 = 2 * l - m2;\n    return new Rgb(\n      hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2),\n      hsl2rgb(h, m1, m2),\n      hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2),\n      this.opacity\n    );\n  },\n  displayable: function() {\n    return (0 <= this.s && this.s <= 1 || isNaN(this.s))\n        && (0 <= this.l && this.l <= 1)\n        && (0 <= this.opacity && this.opacity <= 1);\n  }\n}));\n\n/* From FvD 13.37, CSS Color Module Level 3 */\nfunction hsl2rgb(h, m1, m2) {\n  return (h < 60 ? m1 + (m2 - m1) * h / 60\n      : h < 180 ? m2\n      : h < 240 ? m1 + (m2 - m1) * (240 - h) / 60\n      : m1) * 255;\n}\n\nvar deg2rad = Math.PI / 180;\nvar rad2deg = 180 / Math.PI;\n\nvar Kn = 18;\nvar Xn = 0.950470;\nvar Yn = 1;\nvar Zn = 1.088830;\nvar t0 = 4 / 29;\nvar t1 = 6 / 29;\nvar t2 = 3 * t1 * t1;\nvar t3 = t1 * t1 * t1;\n\nfunction labConvert(o) {\n  if (o instanceof Lab) return new Lab(o.l, o.a, o.b, o.opacity);\n  if (o instanceof Hcl) {\n    var h = o.h * deg2rad;\n    return new Lab(o.l, Math.cos(h) * o.c, Math.sin(h) * o.c, o.opacity);\n  }\n  if (!(o instanceof Rgb)) o = rgbConvert(o);\n  var b = rgb2xyz(o.r),\n      a = rgb2xyz(o.g),\n      l = rgb2xyz(o.b),\n      x = xyz2lab((0.4124564 * b + 0.3575761 * a + 0.1804375 * l) / Xn),\n      y = xyz2lab((0.2126729 * b + 0.7151522 * a + 0.0721750 * l) / Yn),\n      z = xyz2lab((0.0193339 * b + 0.1191920 * a + 0.9503041 * l) / Zn);\n  return new Lab(116 * y - 16, 500 * (x - y), 200 * (y - z), o.opacity);\n}\n\nfunction lab(l, a, b, opacity) {\n  return arguments.length === 1 ? labConvert(l) : new Lab(l, a, b, opacity == null ? 1 : opacity);\n}\n\nfunction Lab(l, a, b, opacity) {\n  this.l = +l;\n  this.a = +a;\n  this.b = +b;\n  this.opacity = +opacity;\n}\n\ndefine(Lab, lab, extend(Color, {\n  brighter: function(k) {\n    return new Lab(this.l + Kn * (k == null ? 1 : k), this.a, this.b, this.opacity);\n  },\n  darker: function(k) {\n    return new Lab(this.l - Kn * (k == null ? 1 : k), this.a, this.b, this.opacity);\n  },\n  rgb: function() {\n    var y = (this.l + 16) / 116,\n        x = isNaN(this.a) ? y : y + this.a / 500,\n        z = isNaN(this.b) ? y : y - this.b / 200;\n    y = Yn * lab2xyz(y);\n    x = Xn * lab2xyz(x);\n    z = Zn * lab2xyz(z);\n    return new Rgb(\n      xyz2rgb( 3.2404542 * x - 1.5371385 * y - 0.4985314 * z), // D65 -> sRGB\n      xyz2rgb(-0.9692660 * x + 1.8760108 * y + 0.0415560 * z),\n      xyz2rgb( 0.0556434 * x - 0.2040259 * y + 1.0572252 * z),\n      this.opacity\n    );\n  }\n}));\n\nfunction xyz2lab(t) {\n  return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0;\n}\n\nfunction lab2xyz(t) {\n  return t > t1 ? t * t * t : t2 * (t - t0);\n}\n\nfunction xyz2rgb(x) {\n  return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055);\n}\n\nfunction rgb2xyz(x) {\n  return (x /= 255) <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4);\n}\n\nfunction hclConvert(o) {\n  if (o instanceof Hcl) return new Hcl(o.h, o.c, o.l, o.opacity);\n  if (!(o instanceof Lab)) o = labConvert(o);\n  var h = Math.atan2(o.b, o.a) * rad2deg;\n  return new Hcl(h < 0 ? h + 360 : h, Math.sqrt(o.a * o.a + o.b * o.b), o.l, o.opacity);\n}\n\nfunction hcl(h, c, l, opacity) {\n  return arguments.length === 1 ? hclConvert(h) : new Hcl(h, c, l, opacity == null ? 1 : opacity);\n}\n\nfunction Hcl(h, c, l, opacity) {\n  this.h = +h;\n  this.c = +c;\n  this.l = +l;\n  this.opacity = +opacity;\n}\n\ndefine(Hcl, hcl, extend(Color, {\n  brighter: function(k) {\n    return new Hcl(this.h, this.c, this.l + Kn * (k == null ? 1 : k), this.opacity);\n  },\n  darker: function(k) {\n    return new Hcl(this.h, this.c, this.l - Kn * (k == null ? 1 : k), this.opacity);\n  },\n  rgb: function() {\n    return labConvert(this).rgb();\n  }\n}));\n\nvar A = -0.14861;\nvar B = +1.78277;\nvar C = -0.29227;\nvar D = -0.90649;\nvar E = +1.97294;\nvar ED = E * D;\nvar EB = E * B;\nvar BC_DA = B * C - D * A;\n\nfunction cubehelixConvert(o) {\n  if (o instanceof Cubehelix) return new Cubehelix(o.h, o.s, o.l, o.opacity);\n  if (!(o instanceof Rgb)) o = rgbConvert(o);\n  var r = o.r / 255,\n      g = o.g / 255,\n      b = o.b / 255,\n      l = (BC_DA * b + ED * r - EB * g) / (BC_DA + ED - EB),\n      bl = b - l,\n      k = (E * (g - l) - C * bl) / D,\n      s = Math.sqrt(k * k + bl * bl) / (E * l * (1 - l)), // NaN if l=0 or l=1\n      h = s ? Math.atan2(k, bl) * rad2deg - 120 : NaN;\n  return new Cubehelix(h < 0 ? h + 360 : h, s, l, o.opacity);\n}\n\nfunction cubehelix(h, s, l, opacity) {\n  return arguments.length === 1 ? cubehelixConvert(h) : new Cubehelix(h, s, l, opacity == null ? 1 : opacity);\n}\n\nfunction Cubehelix(h, s, l, opacity) {\n  this.h = +h;\n  this.s = +s;\n  this.l = +l;\n  this.opacity = +opacity;\n}\n\ndefine(Cubehelix, cubehelix, extend(Color, {\n  brighter: function(k) {\n    k = k == null ? brighter : Math.pow(brighter, k);\n    return new Cubehelix(this.h, this.s, this.l * k, this.opacity);\n  },\n  darker: function(k) {\n    k = k == null ? darker : Math.pow(darker, k);\n    return new Cubehelix(this.h, this.s, this.l * k, this.opacity);\n  },\n  rgb: function() {\n    var h = isNaN(this.h) ? 0 : (this.h + 120) * deg2rad,\n        l = +this.l,\n        a = isNaN(this.s) ? 0 : this.s * l * (1 - l),\n        cosh = Math.cos(h),\n        sinh = Math.sin(h);\n    return new Rgb(\n      255 * (l + a * (A * cosh + B * sinh)),\n      255 * (l + a * (C * cosh + D * sinh)),\n      255 * (l + a * (E * cosh)),\n      this.opacity\n    );\n  }\n}));\n\nfunction basis(t1, v0, v1, v2, v3) {\n  var t2 = t1 * t1, t3 = t2 * t1;\n  return ((1 - 3 * t1 + 3 * t2 - t3) * v0\n      + (4 - 6 * t2 + 3 * t3) * v1\n      + (1 + 3 * t1 + 3 * t2 - 3 * t3) * v2\n      + t3 * v3) / 6;\n}\n\nvar basis$1 = function(values) {\n  var n = values.length - 1;\n  return function(t) {\n    var i = t <= 0 ? (t = 0) : t >= 1 ? (t = 1, n - 1) : Math.floor(t * n),\n        v1 = values[i],\n        v2 = values[i + 1],\n        v0 = i > 0 ? values[i - 1] : 2 * v1 - v2,\n        v3 = i < n - 1 ? values[i + 2] : 2 * v2 - v1;\n    return basis((t - i / n) * n, v0, v1, v2, v3);\n  };\n};\n\nvar basisClosed = function(values) {\n  var n = values.length;\n  return function(t) {\n    var i = Math.floor(((t %= 1) < 0 ? ++t : t) * n),\n        v0 = values[(i + n - 1) % n],\n        v1 = values[i % n],\n        v2 = values[(i + 1) % n],\n        v3 = values[(i + 2) % n];\n    return basis((t - i / n) * n, v0, v1, v2, v3);\n  };\n};\n\nvar constant$3 = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nfunction linear(a, d) {\n  return function(t) {\n    return a + t * d;\n  };\n}\n\nfunction exponential(a, b, y) {\n  return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function(t) {\n    return Math.pow(a + t * b, y);\n  };\n}\n\nfunction hue(a, b) {\n  var d = b - a;\n  return d ? linear(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : constant$3(isNaN(a) ? b : a);\n}\n\nfunction gamma(y) {\n  return (y = +y) === 1 ? nogamma : function(a, b) {\n    return b - a ? exponential(a, b, y) : constant$3(isNaN(a) ? b : a);\n  };\n}\n\nfunction nogamma(a, b) {\n  var d = b - a;\n  return d ? linear(a, d) : constant$3(isNaN(a) ? b : a);\n}\n\nvar interpolateRgb = ((function rgbGamma(y) {\n  var color$$1 = gamma(y);\n\n  function rgb$$1(start, end) {\n    var r = color$$1((start = rgb(start)).r, (end = rgb(end)).r),\n        g = color$$1(start.g, end.g),\n        b = color$$1(start.b, end.b),\n        opacity = nogamma(start.opacity, end.opacity);\n    return function(t) {\n      start.r = r(t);\n      start.g = g(t);\n      start.b = b(t);\n      start.opacity = opacity(t);\n      return start + \"\";\n    };\n  }\n\n  rgb$$1.gamma = rgbGamma;\n\n  return rgb$$1;\n}))(1);\n\nfunction rgbSpline(spline) {\n  return function(colors) {\n    var n = colors.length,\n        r = new Array(n),\n        g = new Array(n),\n        b = new Array(n),\n        i, color$$1;\n    for (i = 0; i < n; ++i) {\n      color$$1 = rgb(colors[i]);\n      r[i] = color$$1.r || 0;\n      g[i] = color$$1.g || 0;\n      b[i] = color$$1.b || 0;\n    }\n    r = spline(r);\n    g = spline(g);\n    b = spline(b);\n    color$$1.opacity = 1;\n    return function(t) {\n      color$$1.r = r(t);\n      color$$1.g = g(t);\n      color$$1.b = b(t);\n      return color$$1 + \"\";\n    };\n  };\n}\n\nvar rgbBasis = rgbSpline(basis$1);\nvar rgbBasisClosed = rgbSpline(basisClosed);\n\nvar array$1 = function(a, b) {\n  var nb = b ? b.length : 0,\n      na = a ? Math.min(nb, a.length) : 0,\n      x = new Array(nb),\n      c = new Array(nb),\n      i;\n\n  for (i = 0; i < na; ++i) x[i] = interpolateValue(a[i], b[i]);\n  for (; i < nb; ++i) c[i] = b[i];\n\n  return function(t) {\n    for (i = 0; i < na; ++i) c[i] = x[i](t);\n    return c;\n  };\n};\n\nvar date = function(a, b) {\n  var d = new Date;\n  return a = +a, b -= a, function(t) {\n    return d.setTime(a + b * t), d;\n  };\n};\n\nvar reinterpolate = function(a, b) {\n  return a = +a, b -= a, function(t) {\n    return a + b * t;\n  };\n};\n\nvar object = function(a, b) {\n  var i = {},\n      c = {},\n      k;\n\n  if (a === null || typeof a !== \"object\") a = {};\n  if (b === null || typeof b !== \"object\") b = {};\n\n  for (k in b) {\n    if (k in a) {\n      i[k] = interpolateValue(a[k], b[k]);\n    } else {\n      c[k] = b[k];\n    }\n  }\n\n  return function(t) {\n    for (k in i) c[k] = i[k](t);\n    return c;\n  };\n};\n\nvar reA = /[-+]?(?:\\d+\\.?\\d*|\\.?\\d+)(?:[eE][-+]?\\d+)?/g;\nvar reB = new RegExp(reA.source, \"g\");\n\nfunction zero(b) {\n  return function() {\n    return b;\n  };\n}\n\nfunction one(b) {\n  return function(t) {\n    return b(t) + \"\";\n  };\n}\n\nvar interpolateString = function(a, b) {\n  var bi = reA.lastIndex = reB.lastIndex = 0, // scan index for next number in b\n      am, // current match in a\n      bm, // current match in b\n      bs, // string preceding current number in b, if any\n      i = -1, // index in s\n      s = [], // string constants and placeholders\n      q = []; // number interpolators\n\n  // Coerce inputs to strings.\n  a = a + \"\", b = b + \"\";\n\n  // Interpolate pairs of numbers in a & b.\n  while ((am = reA.exec(a))\n      && (bm = reB.exec(b))) {\n    if ((bs = bm.index) > bi) { // a string precedes the next number in b\n      bs = b.slice(bi, bs);\n      if (s[i]) s[i] += bs; // coalesce with previous string\n      else s[++i] = bs;\n    }\n    if ((am = am[0]) === (bm = bm[0])) { // numbers in a & b match\n      if (s[i]) s[i] += bm; // coalesce with previous string\n      else s[++i] = bm;\n    } else { // interpolate non-matching numbers\n      s[++i] = null;\n      q.push({i: i, x: reinterpolate(am, bm)});\n    }\n    bi = reB.lastIndex;\n  }\n\n  // Add remains of b.\n  if (bi < b.length) {\n    bs = b.slice(bi);\n    if (s[i]) s[i] += bs; // coalesce with previous string\n    else s[++i] = bs;\n  }\n\n  // Special optimization for only a single match.\n  // Otherwise, interpolate each of the numbers and rejoin the string.\n  return s.length < 2 ? (q[0]\n      ? one(q[0].x)\n      : zero(b))\n      : (b = q.length, function(t) {\n          for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t);\n          return s.join(\"\");\n        });\n};\n\nvar interpolateValue = function(a, b) {\n  var t = typeof b, c;\n  return b == null || t === \"boolean\" ? constant$3(b)\n      : (t === \"number\" ? reinterpolate\n      : t === \"string\" ? ((c = color(b)) ? (b = c, interpolateRgb) : interpolateString)\n      : b instanceof color ? interpolateRgb\n      : b instanceof Date ? date\n      : Array.isArray(b) ? array$1\n      : isNaN(b) ? object\n      : reinterpolate)(a, b);\n};\n\nvar interpolateRound = function(a, b) {\n  return a = +a, b -= a, function(t) {\n    return Math.round(a + b * t);\n  };\n};\n\nvar degrees = 180 / Math.PI;\n\nvar identity$2 = {\n  translateX: 0,\n  translateY: 0,\n  rotate: 0,\n  skewX: 0,\n  scaleX: 1,\n  scaleY: 1\n};\n\nvar decompose = function(a, b, c, d, e, f) {\n  var scaleX, scaleY, skewX;\n  if (scaleX = Math.sqrt(a * a + b * b)) a /= scaleX, b /= scaleX;\n  if (skewX = a * c + b * d) c -= a * skewX, d -= b * skewX;\n  if (scaleY = Math.sqrt(c * c + d * d)) c /= scaleY, d /= scaleY, skewX /= scaleY;\n  if (a * d < b * c) a = -a, b = -b, skewX = -skewX, scaleX = -scaleX;\n  return {\n    translateX: e,\n    translateY: f,\n    rotate: Math.atan2(b, a) * degrees,\n    skewX: Math.atan(skewX) * degrees,\n    scaleX: scaleX,\n    scaleY: scaleY\n  };\n};\n\nvar cssNode;\nvar cssRoot;\nvar cssView;\nvar svgNode;\n\nfunction parseCss(value) {\n  if (value === \"none\") return identity$2;\n  if (!cssNode) cssNode = document.createElement(\"DIV\"), cssRoot = document.documentElement, cssView = document.defaultView;\n  cssNode.style.transform = value;\n  value = cssView.getComputedStyle(cssRoot.appendChild(cssNode), null).getPropertyValue(\"transform\");\n  cssRoot.removeChild(cssNode);\n  value = value.slice(7, -1).split(\",\");\n  return decompose(+value[0], +value[1], +value[2], +value[3], +value[4], +value[5]);\n}\n\nfunction parseSvg(value) {\n  if (value == null) return identity$2;\n  if (!svgNode) svgNode = document.createElementNS(\"http://www.w3.org/2000/svg\", \"g\");\n  svgNode.setAttribute(\"transform\", value);\n  if (!(value = svgNode.transform.baseVal.consolidate())) return identity$2;\n  value = value.matrix;\n  return decompose(value.a, value.b, value.c, value.d, value.e, value.f);\n}\n\nfunction interpolateTransform(parse, pxComma, pxParen, degParen) {\n\n  function pop(s) {\n    return s.length ? s.pop() + \" \" : \"\";\n  }\n\n  function translate(xa, ya, xb, yb, s, q) {\n    if (xa !== xb || ya !== yb) {\n      var i = s.push(\"translate(\", null, pxComma, null, pxParen);\n      q.push({i: i - 4, x: reinterpolate(xa, xb)}, {i: i - 2, x: reinterpolate(ya, yb)});\n    } else if (xb || yb) {\n      s.push(\"translate(\" + xb + pxComma + yb + pxParen);\n    }\n  }\n\n  function rotate(a, b, s, q) {\n    if (a !== b) {\n      if (a - b > 180) b += 360; else if (b - a > 180) a += 360; // shortest path\n      q.push({i: s.push(pop(s) + \"rotate(\", null, degParen) - 2, x: reinterpolate(a, b)});\n    } else if (b) {\n      s.push(pop(s) + \"rotate(\" + b + degParen);\n    }\n  }\n\n  function skewX(a, b, s, q) {\n    if (a !== b) {\n      q.push({i: s.push(pop(s) + \"skewX(\", null, degParen) - 2, x: reinterpolate(a, b)});\n    } else if (b) {\n      s.push(pop(s) + \"skewX(\" + b + degParen);\n    }\n  }\n\n  function scale(xa, ya, xb, yb, s, q) {\n    if (xa !== xb || ya !== yb) {\n      var i = s.push(pop(s) + \"scale(\", null, \",\", null, \")\");\n      q.push({i: i - 4, x: reinterpolate(xa, xb)}, {i: i - 2, x: reinterpolate(ya, yb)});\n    } else if (xb !== 1 || yb !== 1) {\n      s.push(pop(s) + \"scale(\" + xb + \",\" + yb + \")\");\n    }\n  }\n\n  return function(a, b) {\n    var s = [], // string constants and placeholders\n        q = []; // number interpolators\n    a = parse(a), b = parse(b);\n    translate(a.translateX, a.translateY, b.translateX, b.translateY, s, q);\n    rotate(a.rotate, b.rotate, s, q);\n    skewX(a.skewX, b.skewX, s, q);\n    scale(a.scaleX, a.scaleY, b.scaleX, b.scaleY, s, q);\n    a = b = null; // gc\n    return function(t) {\n      var i = -1, n = q.length, o;\n      while (++i < n) s[(o = q[i]).i] = o.x(t);\n      return s.join(\"\");\n    };\n  };\n}\n\nvar interpolateTransformCss = interpolateTransform(parseCss, \"px, \", \"px)\", \"deg)\");\nvar interpolateTransformSvg = interpolateTransform(parseSvg, \", \", \")\", \")\");\n\nvar rho = Math.SQRT2;\nvar rho2 = 2;\nvar rho4 = 4;\nvar epsilon2 = 1e-12;\n\nfunction cosh(x) {\n  return ((x = Math.exp(x)) + 1 / x) / 2;\n}\n\nfunction sinh(x) {\n  return ((x = Math.exp(x)) - 1 / x) / 2;\n}\n\nfunction tanh(x) {\n  return ((x = Math.exp(2 * x)) - 1) / (x + 1);\n}\n\n// p0 = [ux0, uy0, w0]\n// p1 = [ux1, uy1, w1]\nvar interpolateZoom = function(p0, p1) {\n  var ux0 = p0[0], uy0 = p0[1], w0 = p0[2],\n      ux1 = p1[0], uy1 = p1[1], w1 = p1[2],\n      dx = ux1 - ux0,\n      dy = uy1 - uy0,\n      d2 = dx * dx + dy * dy,\n      i,\n      S;\n\n  // Special case for u0 ≅ u1.\n  if (d2 < epsilon2) {\n    S = Math.log(w1 / w0) / rho;\n    i = function(t) {\n      return [\n        ux0 + t * dx,\n        uy0 + t * dy,\n        w0 * Math.exp(rho * t * S)\n      ];\n    };\n  }\n\n  // General case.\n  else {\n    var d1 = Math.sqrt(d2),\n        b0 = (w1 * w1 - w0 * w0 + rho4 * d2) / (2 * w0 * rho2 * d1),\n        b1 = (w1 * w1 - w0 * w0 - rho4 * d2) / (2 * w1 * rho2 * d1),\n        r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0),\n        r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1);\n    S = (r1 - r0) / rho;\n    i = function(t) {\n      var s = t * S,\n          coshr0 = cosh(r0),\n          u = w0 / (rho2 * d1) * (coshr0 * tanh(rho * s + r0) - sinh(r0));\n      return [\n        ux0 + u * dx,\n        uy0 + u * dy,\n        w0 * coshr0 / cosh(rho * s + r0)\n      ];\n    };\n  }\n\n  i.duration = S * 1000;\n\n  return i;\n};\n\nfunction hsl$1(hue$$1) {\n  return function(start, end) {\n    var h = hue$$1((start = hsl(start)).h, (end = hsl(end)).h),\n        s = nogamma(start.s, end.s),\n        l = nogamma(start.l, end.l),\n        opacity = nogamma(start.opacity, end.opacity);\n    return function(t) {\n      start.h = h(t);\n      start.s = s(t);\n      start.l = l(t);\n      start.opacity = opacity(t);\n      return start + \"\";\n    };\n  }\n}\n\nvar hsl$2 = hsl$1(hue);\nvar hslLong = hsl$1(nogamma);\n\nfunction lab$1(start, end) {\n  var l = nogamma((start = lab(start)).l, (end = lab(end)).l),\n      a = nogamma(start.a, end.a),\n      b = nogamma(start.b, end.b),\n      opacity = nogamma(start.opacity, end.opacity);\n  return function(t) {\n    start.l = l(t);\n    start.a = a(t);\n    start.b = b(t);\n    start.opacity = opacity(t);\n    return start + \"\";\n  };\n}\n\nfunction hcl$1(hue$$1) {\n  return function(start, end) {\n    var h = hue$$1((start = hcl(start)).h, (end = hcl(end)).h),\n        c = nogamma(start.c, end.c),\n        l = nogamma(start.l, end.l),\n        opacity = nogamma(start.opacity, end.opacity);\n    return function(t) {\n      start.h = h(t);\n      start.c = c(t);\n      start.l = l(t);\n      start.opacity = opacity(t);\n      return start + \"\";\n    };\n  }\n}\n\nvar hcl$2 = hcl$1(hue);\nvar hclLong = hcl$1(nogamma);\n\nfunction cubehelix$1(hue$$1) {\n  return (function cubehelixGamma(y) {\n    y = +y;\n\n    function cubehelix$$1(start, end) {\n      var h = hue$$1((start = cubehelix(start)).h, (end = cubehelix(end)).h),\n          s = nogamma(start.s, end.s),\n          l = nogamma(start.l, end.l),\n          opacity = nogamma(start.opacity, end.opacity);\n      return function(t) {\n        start.h = h(t);\n        start.s = s(t);\n        start.l = l(Math.pow(t, y));\n        start.opacity = opacity(t);\n        return start + \"\";\n      };\n    }\n\n    cubehelix$$1.gamma = cubehelixGamma;\n\n    return cubehelix$$1;\n  })(1);\n}\n\nvar cubehelix$2 = cubehelix$1(hue);\nvar cubehelixLong = cubehelix$1(nogamma);\n\nvar quantize = function(interpolator, n) {\n  var samples = new Array(n);\n  for (var i = 0; i < n; ++i) samples[i] = interpolator(i / (n - 1));\n  return samples;\n};\n\nvar frame = 0;\nvar timeout = 0;\nvar interval = 0;\nvar pokeDelay = 1000;\nvar taskHead;\nvar taskTail;\nvar clockLast = 0;\nvar clockNow = 0;\nvar clockSkew = 0;\nvar clock = typeof performance === \"object\" && performance.now ? performance : Date;\nvar setFrame = typeof requestAnimationFrame === \"function\" ? requestAnimationFrame : function(f) { setTimeout(f, 17); };\n\nfunction now() {\n  return clockNow || (setFrame(clearNow), clockNow = clock.now() + clockSkew);\n}\n\nfunction clearNow() {\n  clockNow = 0;\n}\n\nfunction Timer() {\n  this._call =\n  this._time =\n  this._next = null;\n}\n\nTimer.prototype = timer.prototype = {\n  constructor: Timer,\n  restart: function(callback, delay, time) {\n    if (typeof callback !== \"function\") throw new TypeError(\"callback is not a function\");\n    time = (time == null ? now() : +time) + (delay == null ? 0 : +delay);\n    if (!this._next && taskTail !== this) {\n      if (taskTail) taskTail._next = this;\n      else taskHead = this;\n      taskTail = this;\n    }\n    this._call = callback;\n    this._time = time;\n    sleep();\n  },\n  stop: function() {\n    if (this._call) {\n      this._call = null;\n      this._time = Infinity;\n      sleep();\n    }\n  }\n};\n\nfunction timer(callback, delay, time) {\n  var t = new Timer;\n  t.restart(callback, delay, time);\n  return t;\n}\n\nfunction timerFlush() {\n  now(); // Get the current time, if not already set.\n  ++frame; // Pretend we’ve set an alarm, if we haven’t already.\n  var t = taskHead, e;\n  while (t) {\n    if ((e = clockNow - t._time) >= 0) t._call.call(null, e);\n    t = t._next;\n  }\n  --frame;\n}\n\nfunction wake() {\n  clockNow = (clockLast = clock.now()) + clockSkew;\n  frame = timeout = 0;\n  try {\n    timerFlush();\n  } finally {\n    frame = 0;\n    nap();\n    clockNow = 0;\n  }\n}\n\nfunction poke() {\n  var now = clock.now(), delay = now - clockLast;\n  if (delay > pokeDelay) clockSkew -= delay, clockLast = now;\n}\n\nfunction nap() {\n  var t0, t1 = taskHead, t2, time = Infinity;\n  while (t1) {\n    if (t1._call) {\n      if (time > t1._time) time = t1._time;\n      t0 = t1, t1 = t1._next;\n    } else {\n      t2 = t1._next, t1._next = null;\n      t1 = t0 ? t0._next = t2 : taskHead = t2;\n    }\n  }\n  taskTail = t0;\n  sleep(time);\n}\n\nfunction sleep(time) {\n  if (frame) return; // Soonest alarm already set, or will be.\n  if (timeout) timeout = clearTimeout(timeout);\n  var delay = time - clockNow;\n  if (delay > 24) {\n    if (time < Infinity) timeout = setTimeout(wake, delay);\n    if (interval) interval = clearInterval(interval);\n  } else {\n    if (!interval) clockLast = clockNow, interval = setInterval(poke, pokeDelay);\n    frame = 1, setFrame(wake);\n  }\n}\n\nvar timeout$1 = function(callback, delay, time) {\n  var t = new Timer;\n  delay = delay == null ? 0 : +delay;\n  t.restart(function(elapsed) {\n    t.stop();\n    callback(elapsed + delay);\n  }, delay, time);\n  return t;\n};\n\nvar interval$1 = function(callback, delay, time) {\n  var t = new Timer, total = delay;\n  if (delay == null) return t.restart(callback, delay, time), t;\n  delay = +delay, time = time == null ? now() : +time;\n  t.restart(function tick(elapsed) {\n    elapsed += total;\n    t.restart(tick, total += delay, time);\n    callback(elapsed);\n  }, delay, time);\n  return t;\n};\n\nvar emptyOn = dispatch(\"start\", \"end\", \"interrupt\");\nvar emptyTween = [];\n\nvar CREATED = 0;\nvar SCHEDULED = 1;\nvar STARTING = 2;\nvar STARTED = 3;\nvar RUNNING = 4;\nvar ENDING = 5;\nvar ENDED = 6;\n\nvar schedule = function(node, name, id, index, group, timing) {\n  var schedules = node.__transition;\n  if (!schedules) node.__transition = {};\n  else if (id in schedules) return;\n  create(node, id, {\n    name: name,\n    index: index, // For context during callback.\n    group: group, // For context during callback.\n    on: emptyOn,\n    tween: emptyTween,\n    time: timing.time,\n    delay: timing.delay,\n    duration: timing.duration,\n    ease: timing.ease,\n    timer: null,\n    state: CREATED\n  });\n};\n\nfunction init(node, id) {\n  var schedule = node.__transition;\n  if (!schedule || !(schedule = schedule[id]) || schedule.state > CREATED) throw new Error(\"too late\");\n  return schedule;\n}\n\nfunction set$1(node, id) {\n  var schedule = node.__transition;\n  if (!schedule || !(schedule = schedule[id]) || schedule.state > STARTING) throw new Error(\"too late\");\n  return schedule;\n}\n\nfunction get$1(node, id) {\n  var schedule = node.__transition;\n  if (!schedule || !(schedule = schedule[id])) throw new Error(\"too late\");\n  return schedule;\n}\n\nfunction create(node, id, self) {\n  var schedules = node.__transition,\n      tween;\n\n  // Initialize the self timer when the transition is created.\n  // Note the actual delay is not known until the first callback!\n  schedules[id] = self;\n  self.timer = timer(schedule, 0, self.time);\n\n  function schedule(elapsed) {\n    self.state = SCHEDULED;\n    self.timer.restart(start, self.delay, self.time);\n\n    // If the elapsed delay is less than our first sleep, start immediately.\n    if (self.delay <= elapsed) start(elapsed - self.delay);\n  }\n\n  function start(elapsed) {\n    var i, j, n, o;\n\n    // If the state is not SCHEDULED, then we previously errored on start.\n    if (self.state !== SCHEDULED) return stop();\n\n    for (i in schedules) {\n      o = schedules[i];\n      if (o.name !== self.name) continue;\n\n      // While this element already has a starting transition during this frame,\n      // defer starting an interrupting transition until that transition has a\n      // chance to tick (and possibly end); see d3/d3-transition#54!\n      if (o.state === STARTED) return timeout$1(start);\n\n      // Interrupt the active transition, if any.\n      // Dispatch the interrupt event.\n      if (o.state === RUNNING) {\n        o.state = ENDED;\n        o.timer.stop();\n        o.on.call(\"interrupt\", node, node.__data__, o.index, o.group);\n        delete schedules[i];\n      }\n\n      // Cancel any pre-empted transitions. No interrupt event is dispatched\n      // because the cancelled transitions never started. Note that this also\n      // removes this transition from the pending list!\n      else if (+i < id) {\n        o.state = ENDED;\n        o.timer.stop();\n        delete schedules[i];\n      }\n    }\n\n    // Defer the first tick to end of the current frame; see d3/d3#1576.\n    // Note the transition may be canceled after start and before the first tick!\n    // Note this must be scheduled before the start event; see d3/d3-transition#16!\n    // Assuming this is successful, subsequent callbacks go straight to tick.\n    timeout$1(function() {\n      if (self.state === STARTED) {\n        self.state = RUNNING;\n        self.timer.restart(tick, self.delay, self.time);\n        tick(elapsed);\n      }\n    });\n\n    // Dispatch the start event.\n    // Note this must be done before the tween are initialized.\n    self.state = STARTING;\n    self.on.call(\"start\", node, node.__data__, self.index, self.group);\n    if (self.state !== STARTING) return; // interrupted\n    self.state = STARTED;\n\n    // Initialize the tween, deleting null tween.\n    tween = new Array(n = self.tween.length);\n    for (i = 0, j = -1; i < n; ++i) {\n      if (o = self.tween[i].value.call(node, node.__data__, self.index, self.group)) {\n        tween[++j] = o;\n      }\n    }\n    tween.length = j + 1;\n  }\n\n  function tick(elapsed) {\n    var t = elapsed < self.duration ? self.ease.call(null, elapsed / self.duration) : (self.timer.restart(stop), self.state = ENDING, 1),\n        i = -1,\n        n = tween.length;\n\n    while (++i < n) {\n      tween[i].call(null, t);\n    }\n\n    // Dispatch the end event.\n    if (self.state === ENDING) {\n      self.on.call(\"end\", node, node.__data__, self.index, self.group);\n      stop();\n    }\n  }\n\n  function stop() {\n    self.state = ENDED;\n    self.timer.stop();\n    delete schedules[id];\n    for (var i in schedules) return; // eslint-disable-line no-unused-vars\n    delete node.__transition;\n  }\n}\n\nvar interrupt = function(node, name) {\n  var schedules = node.__transition,\n      schedule,\n      active,\n      empty = true,\n      i;\n\n  if (!schedules) return;\n\n  name = name == null ? null : name + \"\";\n\n  for (i in schedules) {\n    if ((schedule = schedules[i]).name !== name) { empty = false; continue; }\n    active = schedule.state > STARTING && schedule.state < ENDING;\n    schedule.state = ENDED;\n    schedule.timer.stop();\n    if (active) schedule.on.call(\"interrupt\", node, node.__data__, schedule.index, schedule.group);\n    delete schedules[i];\n  }\n\n  if (empty) delete node.__transition;\n};\n\nvar selection_interrupt = function(name) {\n  return this.each(function() {\n    interrupt(this, name);\n  });\n};\n\nfunction tweenRemove(id, name) {\n  var tween0, tween1;\n  return function() {\n    var schedule = set$1(this, id),\n        tween = schedule.tween;\n\n    // If this node shared tween with the previous node,\n    // just assign the updated shared tween and we’re done!\n    // Otherwise, copy-on-write.\n    if (tween !== tween0) {\n      tween1 = tween0 = tween;\n      for (var i = 0, n = tween1.length; i < n; ++i) {\n        if (tween1[i].name === name) {\n          tween1 = tween1.slice();\n          tween1.splice(i, 1);\n          break;\n        }\n      }\n    }\n\n    schedule.tween = tween1;\n  };\n}\n\nfunction tweenFunction(id, name, value) {\n  var tween0, tween1;\n  if (typeof value !== \"function\") throw new Error;\n  return function() {\n    var schedule = set$1(this, id),\n        tween = schedule.tween;\n\n    // If this node shared tween with the previous node,\n    // just assign the updated shared tween and we’re done!\n    // Otherwise, copy-on-write.\n    if (tween !== tween0) {\n      tween1 = (tween0 = tween).slice();\n      for (var t = {name: name, value: value}, i = 0, n = tween1.length; i < n; ++i) {\n        if (tween1[i].name === name) {\n          tween1[i] = t;\n          break;\n        }\n      }\n      if (i === n) tween1.push(t);\n    }\n\n    schedule.tween = tween1;\n  };\n}\n\nvar transition_tween = function(name, value) {\n  var id = this._id;\n\n  name += \"\";\n\n  if (arguments.length < 2) {\n    var tween = get$1(this.node(), id).tween;\n    for (var i = 0, n = tween.length, t; i < n; ++i) {\n      if ((t = tween[i]).name === name) {\n        return t.value;\n      }\n    }\n    return null;\n  }\n\n  return this.each((value == null ? tweenRemove : tweenFunction)(id, name, value));\n};\n\nfunction tweenValue(transition, name, value) {\n  var id = transition._id;\n\n  transition.each(function() {\n    var schedule = set$1(this, id);\n    (schedule.value || (schedule.value = {}))[name] = value.apply(this, arguments);\n  });\n\n  return function(node) {\n    return get$1(node, id).value[name];\n  };\n}\n\nvar interpolate$$1 = function(a, b) {\n  var c;\n  return (typeof b === \"number\" ? reinterpolate\n      : b instanceof color ? interpolateRgb\n      : (c = color(b)) ? (b = c, interpolateRgb)\n      : interpolateString)(a, b);\n};\n\nfunction attrRemove$1(name) {\n  return function() {\n    this.removeAttribute(name);\n  };\n}\n\nfunction attrRemoveNS$1(fullname) {\n  return function() {\n    this.removeAttributeNS(fullname.space, fullname.local);\n  };\n}\n\nfunction attrConstant$1(name, interpolate$$1, value1) {\n  var value00,\n      interpolate0;\n  return function() {\n    var value0 = this.getAttribute(name);\n    return value0 === value1 ? null\n        : value0 === value00 ? interpolate0\n        : interpolate0 = interpolate$$1(value00 = value0, value1);\n  };\n}\n\nfunction attrConstantNS$1(fullname, interpolate$$1, value1) {\n  var value00,\n      interpolate0;\n  return function() {\n    var value0 = this.getAttributeNS(fullname.space, fullname.local);\n    return value0 === value1 ? null\n        : value0 === value00 ? interpolate0\n        : interpolate0 = interpolate$$1(value00 = value0, value1);\n  };\n}\n\nfunction attrFunction$1(name, interpolate$$1, value) {\n  var value00,\n      value10,\n      interpolate0;\n  return function() {\n    var value0, value1 = value(this);\n    if (value1 == null) return void this.removeAttribute(name);\n    value0 = this.getAttribute(name);\n    return value0 === value1 ? null\n        : value0 === value00 && value1 === value10 ? interpolate0\n        : interpolate0 = interpolate$$1(value00 = value0, value10 = value1);\n  };\n}\n\nfunction attrFunctionNS$1(fullname, interpolate$$1, value) {\n  var value00,\n      value10,\n      interpolate0;\n  return function() {\n    var value0, value1 = value(this);\n    if (value1 == null) return void this.removeAttributeNS(fullname.space, fullname.local);\n    value0 = this.getAttributeNS(fullname.space, fullname.local);\n    return value0 === value1 ? null\n        : value0 === value00 && value1 === value10 ? interpolate0\n        : interpolate0 = interpolate$$1(value00 = value0, value10 = value1);\n  };\n}\n\nvar transition_attr = function(name, value) {\n  var fullname = namespace(name), i = fullname === \"transform\" ? interpolateTransformSvg : interpolate$$1;\n  return this.attrTween(name, typeof value === \"function\"\n      ? (fullname.local ? attrFunctionNS$1 : attrFunction$1)(fullname, i, tweenValue(this, \"attr.\" + name, value))\n      : value == null ? (fullname.local ? attrRemoveNS$1 : attrRemove$1)(fullname)\n      : (fullname.local ? attrConstantNS$1 : attrConstant$1)(fullname, i, value));\n};\n\nfunction attrTweenNS(fullname, value) {\n  function tween() {\n    var node = this, i = value.apply(node, arguments);\n    return i && function(t) {\n      node.setAttributeNS(fullname.space, fullname.local, i(t));\n    };\n  }\n  tween._value = value;\n  return tween;\n}\n\nfunction attrTween(name, value) {\n  function tween() {\n    var node = this, i = value.apply(node, arguments);\n    return i && function(t) {\n      node.setAttribute(name, i(t));\n    };\n  }\n  tween._value = value;\n  return tween;\n}\n\nvar transition_attrTween = function(name, value) {\n  var key = \"attr.\" + name;\n  if (arguments.length < 2) return (key = this.tween(key)) && key._value;\n  if (value == null) return this.tween(key, null);\n  if (typeof value !== \"function\") throw new Error;\n  var fullname = namespace(name);\n  return this.tween(key, (fullname.local ? attrTweenNS : attrTween)(fullname, value));\n};\n\nfunction delayFunction(id, value) {\n  return function() {\n    init(this, id).delay = +value.apply(this, arguments);\n  };\n}\n\nfunction delayConstant(id, value) {\n  return value = +value, function() {\n    init(this, id).delay = value;\n  };\n}\n\nvar transition_delay = function(value) {\n  var id = this._id;\n\n  return arguments.length\n      ? this.each((typeof value === \"function\"\n          ? delayFunction\n          : delayConstant)(id, value))\n      : get$1(this.node(), id).delay;\n};\n\nfunction durationFunction(id, value) {\n  return function() {\n    set$1(this, id).duration = +value.apply(this, arguments);\n  };\n}\n\nfunction durationConstant(id, value) {\n  return value = +value, function() {\n    set$1(this, id).duration = value;\n  };\n}\n\nvar transition_duration = function(value) {\n  var id = this._id;\n\n  return arguments.length\n      ? this.each((typeof value === \"function\"\n          ? durationFunction\n          : durationConstant)(id, value))\n      : get$1(this.node(), id).duration;\n};\n\nfunction easeConstant(id, value) {\n  if (typeof value !== \"function\") throw new Error;\n  return function() {\n    set$1(this, id).ease = value;\n  };\n}\n\nvar transition_ease = function(value) {\n  var id = this._id;\n\n  return arguments.length\n      ? this.each(easeConstant(id, value))\n      : get$1(this.node(), id).ease;\n};\n\nvar transition_filter = function(match) {\n  if (typeof match !== \"function\") match = matcher$1(match);\n\n  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {\n    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) {\n      if ((node = group[i]) && match.call(node, node.__data__, i, group)) {\n        subgroup.push(node);\n      }\n    }\n  }\n\n  return new Transition(subgroups, this._parents, this._name, this._id);\n};\n\nvar transition_merge = function(transition) {\n  if (transition._id !== this._id) throw new Error;\n\n  for (var groups0 = this._groups, groups1 = transition._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) {\n    for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) {\n      if (node = group0[i] || group1[i]) {\n        merge[i] = node;\n      }\n    }\n  }\n\n  for (; j < m0; ++j) {\n    merges[j] = groups0[j];\n  }\n\n  return new Transition(merges, this._parents, this._name, this._id);\n};\n\nfunction start(name) {\n  return (name + \"\").trim().split(/^|\\s+/).every(function(t) {\n    var i = t.indexOf(\".\");\n    if (i >= 0) t = t.slice(0, i);\n    return !t || t === \"start\";\n  });\n}\n\nfunction onFunction(id, name, listener) {\n  var on0, on1, sit = start(name) ? init : set$1;\n  return function() {\n    var schedule = sit(this, id),\n        on = schedule.on;\n\n    // If this node shared a dispatch with the previous node,\n    // just assign the updated shared dispatch and we’re done!\n    // Otherwise, copy-on-write.\n    if (on !== on0) (on1 = (on0 = on).copy()).on(name, listener);\n\n    schedule.on = on1;\n  };\n}\n\nvar transition_on = function(name, listener) {\n  var id = this._id;\n\n  return arguments.length < 2\n      ? get$1(this.node(), id).on.on(name)\n      : this.each(onFunction(id, name, listener));\n};\n\nfunction removeFunction(id) {\n  return function() {\n    var parent = this.parentNode;\n    for (var i in this.__transition) if (+i !== id) return;\n    if (parent) parent.removeChild(this);\n  };\n}\n\nvar transition_remove = function() {\n  return this.on(\"end.remove\", removeFunction(this._id));\n};\n\nvar transition_select = function(select$$1) {\n  var name = this._name,\n      id = this._id;\n\n  if (typeof select$$1 !== \"function\") select$$1 = selector(select$$1);\n\n  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {\n    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) {\n      if ((node = group[i]) && (subnode = select$$1.call(node, node.__data__, i, group))) {\n        if (\"__data__\" in node) subnode.__data__ = node.__data__;\n        subgroup[i] = subnode;\n        schedule(subgroup[i], name, id, i, subgroup, get$1(node, id));\n      }\n    }\n  }\n\n  return new Transition(subgroups, this._parents, name, id);\n};\n\nvar transition_selectAll = function(select$$1) {\n  var name = this._name,\n      id = this._id;\n\n  if (typeof select$$1 !== \"function\") select$$1 = selectorAll(select$$1);\n\n  for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) {\n    for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {\n      if (node = group[i]) {\n        for (var children = select$$1.call(node, node.__data__, i, group), child, inherit = get$1(node, id), k = 0, l = children.length; k < l; ++k) {\n          if (child = children[k]) {\n            schedule(child, name, id, k, children, inherit);\n          }\n        }\n        subgroups.push(children);\n        parents.push(node);\n      }\n    }\n  }\n\n  return new Transition(subgroups, parents, name, id);\n};\n\nvar Selection$1 = selection.prototype.constructor;\n\nvar transition_selection = function() {\n  return new Selection$1(this._groups, this._parents);\n};\n\nfunction styleRemove$1(name, interpolate$$2) {\n  var value00,\n      value10,\n      interpolate0;\n  return function() {\n    var style = window(this).getComputedStyle(this, null),\n        value0 = style.getPropertyValue(name),\n        value1 = (this.style.removeProperty(name), style.getPropertyValue(name));\n    return value0 === value1 ? null\n        : value0 === value00 && value1 === value10 ? interpolate0\n        : interpolate0 = interpolate$$2(value00 = value0, value10 = value1);\n  };\n}\n\nfunction styleRemoveEnd(name) {\n  return function() {\n    this.style.removeProperty(name);\n  };\n}\n\nfunction styleConstant$1(name, interpolate$$2, value1) {\n  var value00,\n      interpolate0;\n  return function() {\n    var value0 = window(this).getComputedStyle(this, null).getPropertyValue(name);\n    return value0 === value1 ? null\n        : value0 === value00 ? interpolate0\n        : interpolate0 = interpolate$$2(value00 = value0, value1);\n  };\n}\n\nfunction styleFunction$1(name, interpolate$$2, value) {\n  var value00,\n      value10,\n      interpolate0;\n  return function() {\n    var style = window(this).getComputedStyle(this, null),\n        value0 = style.getPropertyValue(name),\n        value1 = value(this);\n    if (value1 == null) value1 = (this.style.removeProperty(name), style.getPropertyValue(name));\n    return value0 === value1 ? null\n        : value0 === value00 && value1 === value10 ? interpolate0\n        : interpolate0 = interpolate$$2(value00 = value0, value10 = value1);\n  };\n}\n\nvar transition_style = function(name, value, priority) {\n  var i = (name += \"\") === \"transform\" ? interpolateTransformCss : interpolate$$1;\n  return value == null ? this\n          .styleTween(name, styleRemove$1(name, i))\n          .on(\"end.style.\" + name, styleRemoveEnd(name))\n      : this.styleTween(name, typeof value === \"function\"\n          ? styleFunction$1(name, i, tweenValue(this, \"style.\" + name, value))\n          : styleConstant$1(name, i, value), priority);\n};\n\nfunction styleTween(name, value, priority) {\n  function tween() {\n    var node = this, i = value.apply(node, arguments);\n    return i && function(t) {\n      node.style.setProperty(name, i(t), priority);\n    };\n  }\n  tween._value = value;\n  return tween;\n}\n\nvar transition_styleTween = function(name, value, priority) {\n  var key = \"style.\" + (name += \"\");\n  if (arguments.length < 2) return (key = this.tween(key)) && key._value;\n  if (value == null) return this.tween(key, null);\n  if (typeof value !== \"function\") throw new Error;\n  return this.tween(key, styleTween(name, value, priority == null ? \"\" : priority));\n};\n\nfunction textConstant$1(value) {\n  return function() {\n    this.textContent = value;\n  };\n}\n\nfunction textFunction$1(value) {\n  return function() {\n    var value1 = value(this);\n    this.textContent = value1 == null ? \"\" : value1;\n  };\n}\n\nvar transition_text = function(value) {\n  return this.tween(\"text\", typeof value === \"function\"\n      ? textFunction$1(tweenValue(this, \"text\", value))\n      : textConstant$1(value == null ? \"\" : value + \"\"));\n};\n\nvar transition_transition = function() {\n  var name = this._name,\n      id0 = this._id,\n      id1 = newId();\n\n  for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) {\n    for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {\n      if (node = group[i]) {\n        var inherit = get$1(node, id0);\n        schedule(node, name, id1, i, group, {\n          time: inherit.time + inherit.delay + inherit.duration,\n          delay: 0,\n          duration: inherit.duration,\n          ease: inherit.ease\n        });\n      }\n    }\n  }\n\n  return new Transition(groups, this._parents, name, id1);\n};\n\nvar id = 0;\n\nfunction Transition(groups, parents, name, id) {\n  this._groups = groups;\n  this._parents = parents;\n  this._name = name;\n  this._id = id;\n}\n\nfunction transition(name) {\n  return selection().transition(name);\n}\n\nfunction newId() {\n  return ++id;\n}\n\nvar selection_prototype = selection.prototype;\n\nTransition.prototype = transition.prototype = {\n  constructor: Transition,\n  select: transition_select,\n  selectAll: transition_selectAll,\n  filter: transition_filter,\n  merge: transition_merge,\n  selection: transition_selection,\n  transition: transition_transition,\n  call: selection_prototype.call,\n  nodes: selection_prototype.nodes,\n  node: selection_prototype.node,\n  size: selection_prototype.size,\n  empty: selection_prototype.empty,\n  each: selection_prototype.each,\n  on: transition_on,\n  attr: transition_attr,\n  attrTween: transition_attrTween,\n  style: transition_style,\n  styleTween: transition_styleTween,\n  text: transition_text,\n  remove: transition_remove,\n  tween: transition_tween,\n  delay: transition_delay,\n  duration: transition_duration,\n  ease: transition_ease\n};\n\nfunction linear$1(t) {\n  return +t;\n}\n\nfunction quadIn(t) {\n  return t * t;\n}\n\nfunction quadOut(t) {\n  return t * (2 - t);\n}\n\nfunction quadInOut(t) {\n  return ((t *= 2) <= 1 ? t * t : --t * (2 - t) + 1) / 2;\n}\n\nfunction cubicIn(t) {\n  return t * t * t;\n}\n\nfunction cubicOut(t) {\n  return --t * t * t + 1;\n}\n\nfunction cubicInOut(t) {\n  return ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2;\n}\n\nvar exponent = 3;\n\nvar polyIn = (function custom(e) {\n  e = +e;\n\n  function polyIn(t) {\n    return Math.pow(t, e);\n  }\n\n  polyIn.exponent = custom;\n\n  return polyIn;\n})(exponent);\n\nvar polyOut = (function custom(e) {\n  e = +e;\n\n  function polyOut(t) {\n    return 1 - Math.pow(1 - t, e);\n  }\n\n  polyOut.exponent = custom;\n\n  return polyOut;\n})(exponent);\n\nvar polyInOut = (function custom(e) {\n  e = +e;\n\n  function polyInOut(t) {\n    return ((t *= 2) <= 1 ? Math.pow(t, e) : 2 - Math.pow(2 - t, e)) / 2;\n  }\n\n  polyInOut.exponent = custom;\n\n  return polyInOut;\n})(exponent);\n\nvar pi = Math.PI;\nvar halfPi = pi / 2;\n\nfunction sinIn(t) {\n  return 1 - Math.cos(t * halfPi);\n}\n\nfunction sinOut(t) {\n  return Math.sin(t * halfPi);\n}\n\nfunction sinInOut(t) {\n  return (1 - Math.cos(pi * t)) / 2;\n}\n\nfunction expIn(t) {\n  return Math.pow(2, 10 * t - 10);\n}\n\nfunction expOut(t) {\n  return 1 - Math.pow(2, -10 * t);\n}\n\nfunction expInOut(t) {\n  return ((t *= 2) <= 1 ? Math.pow(2, 10 * t - 10) : 2 - Math.pow(2, 10 - 10 * t)) / 2;\n}\n\nfunction circleIn(t) {\n  return 1 - Math.sqrt(1 - t * t);\n}\n\nfunction circleOut(t) {\n  return Math.sqrt(1 - --t * t);\n}\n\nfunction circleInOut(t) {\n  return ((t *= 2) <= 1 ? 1 - Math.sqrt(1 - t * t) : Math.sqrt(1 - (t -= 2) * t) + 1) / 2;\n}\n\nvar b1 = 4 / 11;\nvar b2 = 6 / 11;\nvar b3 = 8 / 11;\nvar b4 = 3 / 4;\nvar b5 = 9 / 11;\nvar b6 = 10 / 11;\nvar b7 = 15 / 16;\nvar b8 = 21 / 22;\nvar b9 = 63 / 64;\nvar b0 = 1 / b1 / b1;\n\nfunction bounceIn(t) {\n  return 1 - bounceOut(1 - t);\n}\n\nfunction bounceOut(t) {\n  return (t = +t) < b1 ? b0 * t * t : t < b3 ? b0 * (t -= b2) * t + b4 : t < b6 ? b0 * (t -= b5) * t + b7 : b0 * (t -= b8) * t + b9;\n}\n\nfunction bounceInOut(t) {\n  return ((t *= 2) <= 1 ? 1 - bounceOut(1 - t) : bounceOut(t - 1) + 1) / 2;\n}\n\nvar overshoot = 1.70158;\n\nvar backIn = (function custom(s) {\n  s = +s;\n\n  function backIn(t) {\n    return t * t * ((s + 1) * t - s);\n  }\n\n  backIn.overshoot = custom;\n\n  return backIn;\n})(overshoot);\n\nvar backOut = (function custom(s) {\n  s = +s;\n\n  function backOut(t) {\n    return --t * t * ((s + 1) * t + s) + 1;\n  }\n\n  backOut.overshoot = custom;\n\n  return backOut;\n})(overshoot);\n\nvar backInOut = (function custom(s) {\n  s = +s;\n\n  function backInOut(t) {\n    return ((t *= 2) < 1 ? t * t * ((s + 1) * t - s) : (t -= 2) * t * ((s + 1) * t + s) + 2) / 2;\n  }\n\n  backInOut.overshoot = custom;\n\n  return backInOut;\n})(overshoot);\n\nvar tau = 2 * Math.PI;\nvar amplitude = 1;\nvar period = 0.3;\n\nvar elasticIn = (function custom(a, p) {\n  var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau);\n\n  function elasticIn(t) {\n    return a * Math.pow(2, 10 * --t) * Math.sin((s - t) / p);\n  }\n\n  elasticIn.amplitude = function(a) { return custom(a, p * tau); };\n  elasticIn.period = function(p) { return custom(a, p); };\n\n  return elasticIn;\n})(amplitude, period);\n\nvar elasticOut = (function custom(a, p) {\n  var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau);\n\n  function elasticOut(t) {\n    return 1 - a * Math.pow(2, -10 * (t = +t)) * Math.sin((t + s) / p);\n  }\n\n  elasticOut.amplitude = function(a) { return custom(a, p * tau); };\n  elasticOut.period = function(p) { return custom(a, p); };\n\n  return elasticOut;\n})(amplitude, period);\n\nvar elasticInOut = (function custom(a, p) {\n  var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau);\n\n  function elasticInOut(t) {\n    return ((t = t * 2 - 1) < 0\n        ? a * Math.pow(2, 10 * t) * Math.sin((s - t) / p)\n        : 2 - a * Math.pow(2, -10 * t) * Math.sin((s + t) / p)) / 2;\n  }\n\n  elasticInOut.amplitude = function(a) { return custom(a, p * tau); };\n  elasticInOut.period = function(p) { return custom(a, p); };\n\n  return elasticInOut;\n})(amplitude, period);\n\nvar defaultTiming = {\n  time: null, // Set on use.\n  delay: 0,\n  duration: 250,\n  ease: cubicInOut\n};\n\nfunction inherit(node, id) {\n  var timing;\n  while (!(timing = node.__transition) || !(timing = timing[id])) {\n    if (!(node = node.parentNode)) {\n      return defaultTiming.time = now(), defaultTiming;\n    }\n  }\n  return timing;\n}\n\nvar selection_transition = function(name) {\n  var id,\n      timing;\n\n  if (name instanceof Transition) {\n    id = name._id, name = name._name;\n  } else {\n    id = newId(), (timing = defaultTiming).time = now(), name = name == null ? null : name + \"\";\n  }\n\n  for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) {\n    for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {\n      if (node = group[i]) {\n        schedule(node, name, id, i, group, timing || inherit(node, id));\n      }\n    }\n  }\n\n  return new Transition(groups, this._parents, name, id);\n};\n\nselection.prototype.interrupt = selection_interrupt;\nselection.prototype.transition = selection_transition;\n\nvar root$1 = [null];\n\nvar active = function(node, name) {\n  var schedules = node.__transition,\n      schedule,\n      i;\n\n  if (schedules) {\n    name = name == null ? null : name + \"\";\n    for (i in schedules) {\n      if ((schedule = schedules[i]).state > SCHEDULED && schedule.name === name) {\n        return new Transition([[node]], root$1, name, +i);\n      }\n    }\n  }\n\n  return null;\n};\n\nvar constant$4 = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nvar BrushEvent = function(target, type, selection) {\n  this.target = target;\n  this.type = type;\n  this.selection = selection;\n};\n\nfunction nopropagation$1() {\n  exports.event.stopImmediatePropagation();\n}\n\nvar noevent$1 = function() {\n  exports.event.preventDefault();\n  exports.event.stopImmediatePropagation();\n};\n\nvar MODE_DRAG = {name: \"drag\"};\nvar MODE_SPACE = {name: \"space\"};\nvar MODE_HANDLE = {name: \"handle\"};\nvar MODE_CENTER = {name: \"center\"};\n\nvar X = {\n  name: \"x\",\n  handles: [\"e\", \"w\"].map(type),\n  input: function(x, e) { return x && [[x[0], e[0][1]], [x[1], e[1][1]]]; },\n  output: function(xy) { return xy && [xy[0][0], xy[1][0]]; }\n};\n\nvar Y = {\n  name: \"y\",\n  handles: [\"n\", \"s\"].map(type),\n  input: function(y, e) { return y && [[e[0][0], y[0]], [e[1][0], y[1]]]; },\n  output: function(xy) { return xy && [xy[0][1], xy[1][1]]; }\n};\n\nvar XY = {\n  name: \"xy\",\n  handles: [\"n\", \"e\", \"s\", \"w\", \"nw\", \"ne\", \"se\", \"sw\"].map(type),\n  input: function(xy) { return xy; },\n  output: function(xy) { return xy; }\n};\n\nvar cursors = {\n  overlay: \"crosshair\",\n  selection: \"move\",\n  n: \"ns-resize\",\n  e: \"ew-resize\",\n  s: \"ns-resize\",\n  w: \"ew-resize\",\n  nw: \"nwse-resize\",\n  ne: \"nesw-resize\",\n  se: \"nwse-resize\",\n  sw: \"nesw-resize\"\n};\n\nvar flipX = {\n  e: \"w\",\n  w: \"e\",\n  nw: \"ne\",\n  ne: \"nw\",\n  se: \"sw\",\n  sw: \"se\"\n};\n\nvar flipY = {\n  n: \"s\",\n  s: \"n\",\n  nw: \"sw\",\n  ne: \"se\",\n  se: \"ne\",\n  sw: \"nw\"\n};\n\nvar signsX = {\n  overlay: +1,\n  selection: +1,\n  n: null,\n  e: +1,\n  s: null,\n  w: -1,\n  nw: -1,\n  ne: +1,\n  se: +1,\n  sw: -1\n};\n\nvar signsY = {\n  overlay: +1,\n  selection: +1,\n  n: -1,\n  e: null,\n  s: +1,\n  w: null,\n  nw: -1,\n  ne: -1,\n  se: +1,\n  sw: +1\n};\n\nfunction type(t) {\n  return {type: t};\n}\n\n// Ignore right-click, since that should open the context menu.\nfunction defaultFilter() {\n  return !exports.event.button;\n}\n\nfunction defaultExtent() {\n  var svg = this.ownerSVGElement || this;\n  return [[0, 0], [svg.width.baseVal.value, svg.height.baseVal.value]];\n}\n\n// Like d3.local, but with the name “__brush” rather than auto-generated.\nfunction local$$1(node) {\n  while (!node.__brush) if (!(node = node.parentNode)) return;\n  return node.__brush;\n}\n\nfunction empty(extent) {\n  return extent[0][0] === extent[1][0]\n      || extent[0][1] === extent[1][1];\n}\n\nfunction brushSelection(node) {\n  var state = node.__brush;\n  return state ? state.dim.output(state.selection) : null;\n}\n\nfunction brushX() {\n  return brush$1(X);\n}\n\nfunction brushY() {\n  return brush$1(Y);\n}\n\nvar brush = function() {\n  return brush$1(XY);\n};\n\nfunction brush$1(dim) {\n  var extent = defaultExtent,\n      filter = defaultFilter,\n      listeners = dispatch(brush, \"start\", \"brush\", \"end\"),\n      handleSize = 6,\n      touchending;\n\n  function brush(group) {\n    var overlay = group\n        .property(\"__brush\", initialize)\n      .selectAll(\".overlay\")\n      .data([type(\"overlay\")]);\n\n    overlay.enter().append(\"rect\")\n        .attr(\"class\", \"overlay\")\n        .attr(\"pointer-events\", \"all\")\n        .attr(\"cursor\", cursors.overlay)\n      .merge(overlay)\n        .each(function() {\n          var extent = local$$1(this).extent;\n          select(this)\n              .attr(\"x\", extent[0][0])\n              .attr(\"y\", extent[0][1])\n              .attr(\"width\", extent[1][0] - extent[0][0])\n              .attr(\"height\", extent[1][1] - extent[0][1]);\n        });\n\n    group.selectAll(\".selection\")\n      .data([type(\"selection\")])\n      .enter().append(\"rect\")\n        .attr(\"class\", \"selection\")\n        .attr(\"cursor\", cursors.selection)\n        .attr(\"fill\", \"#777\")\n        .attr(\"fill-opacity\", 0.3)\n        .attr(\"stroke\", \"#fff\")\n        .attr(\"shape-rendering\", \"crispEdges\");\n\n    var handle = group.selectAll(\".handle\")\n      .data(dim.handles, function(d) { return d.type; });\n\n    handle.exit().remove();\n\n    handle.enter().append(\"rect\")\n        .attr(\"class\", function(d) { return \"handle handle--\" + d.type; })\n        .attr(\"cursor\", function(d) { return cursors[d.type]; });\n\n    group\n        .each(redraw)\n        .attr(\"fill\", \"none\")\n        .attr(\"pointer-events\", \"all\")\n        .style(\"-webkit-tap-highlight-color\", \"rgba(0,0,0,0)\")\n        .on(\"mousedown.brush touchstart.brush\", started);\n  }\n\n  brush.move = function(group, selection$$1) {\n    if (group.selection) {\n      group\n          .on(\"start.brush\", function() { emitter(this, arguments).beforestart().start(); })\n          .on(\"interrupt.brush end.brush\", function() { emitter(this, arguments).end(); })\n          .tween(\"brush\", function() {\n            var that = this,\n                state = that.__brush,\n                emit = emitter(that, arguments),\n                selection0 = state.selection,\n                selection1 = dim.input(typeof selection$$1 === \"function\" ? selection$$1.apply(this, arguments) : selection$$1, state.extent),\n                i = interpolateValue(selection0, selection1);\n\n            function tween(t) {\n              state.selection = t === 1 && empty(selection1) ? null : i(t);\n              redraw.call(that);\n              emit.brush();\n            }\n\n            return selection0 && selection1 ? tween : tween(1);\n          });\n    } else {\n      group\n          .each(function() {\n            var that = this,\n                args = arguments,\n                state = that.__brush,\n                selection1 = dim.input(typeof selection$$1 === \"function\" ? selection$$1.apply(that, args) : selection$$1, state.extent),\n                emit = emitter(that, args).beforestart();\n\n            interrupt(that);\n            state.selection = selection1 == null || empty(selection1) ? null : selection1;\n            redraw.call(that);\n            emit.start().brush().end();\n          });\n    }\n  };\n\n  function redraw() {\n    var group = select(this),\n        selection$$1 = local$$1(this).selection;\n\n    if (selection$$1) {\n      group.selectAll(\".selection\")\n          .style(\"display\", null)\n          .attr(\"x\", selection$$1[0][0])\n          .attr(\"y\", selection$$1[0][1])\n          .attr(\"width\", selection$$1[1][0] - selection$$1[0][0])\n          .attr(\"height\", selection$$1[1][1] - selection$$1[0][1]);\n\n      group.selectAll(\".handle\")\n          .style(\"display\", null)\n          .attr(\"x\", function(d) { return d.type[d.type.length - 1] === \"e\" ? selection$$1[1][0] - handleSize / 2 : selection$$1[0][0] - handleSize / 2; })\n          .attr(\"y\", function(d) { return d.type[0] === \"s\" ? selection$$1[1][1] - handleSize / 2 : selection$$1[0][1] - handleSize / 2; })\n          .attr(\"width\", function(d) { return d.type === \"n\" || d.type === \"s\" ? selection$$1[1][0] - selection$$1[0][0] + handleSize : handleSize; })\n          .attr(\"height\", function(d) { return d.type === \"e\" || d.type === \"w\" ? selection$$1[1][1] - selection$$1[0][1] + handleSize : handleSize; });\n    }\n\n    else {\n      group.selectAll(\".selection,.handle\")\n          .style(\"display\", \"none\")\n          .attr(\"x\", null)\n          .attr(\"y\", null)\n          .attr(\"width\", null)\n          .attr(\"height\", null);\n    }\n  }\n\n  function emitter(that, args) {\n    return that.__brush.emitter || new Emitter(that, args);\n  }\n\n  function Emitter(that, args) {\n    this.that = that;\n    this.args = args;\n    this.state = that.__brush;\n    this.active = 0;\n  }\n\n  Emitter.prototype = {\n    beforestart: function() {\n      if (++this.active === 1) this.state.emitter = this, this.starting = true;\n      return this;\n    },\n    start: function() {\n      if (this.starting) this.starting = false, this.emit(\"start\");\n      return this;\n    },\n    brush: function() {\n      this.emit(\"brush\");\n      return this;\n    },\n    end: function() {\n      if (--this.active === 0) delete this.state.emitter, this.emit(\"end\");\n      return this;\n    },\n    emit: function(type) {\n      customEvent(new BrushEvent(brush, type, dim.output(this.state.selection)), listeners.apply, listeners, [type, this.that, this.args]);\n    }\n  };\n\n  function started() {\n    if (exports.event.touches) { if (exports.event.changedTouches.length < exports.event.touches.length) return noevent$1(); }\n    else if (touchending) return;\n    if (!filter.apply(this, arguments)) return;\n\n    var that = this,\n        type = exports.event.target.__data__.type,\n        mode = (exports.event.metaKey ? type = \"overlay\" : type) === \"selection\" ? MODE_DRAG : (exports.event.altKey ? MODE_CENTER : MODE_HANDLE),\n        signX = dim === Y ? null : signsX[type],\n        signY = dim === X ? null : signsY[type],\n        state = local$$1(that),\n        extent = state.extent,\n        selection$$1 = state.selection,\n        W = extent[0][0], w0, w1,\n        N = extent[0][1], n0, n1,\n        E = extent[1][0], e0, e1,\n        S = extent[1][1], s0, s1,\n        dx,\n        dy,\n        moving,\n        shifting = signX && signY && exports.event.shiftKey,\n        lockX,\n        lockY,\n        point0 = mouse(that),\n        point = point0,\n        emit = emitter(that, arguments).beforestart();\n\n    if (type === \"overlay\") {\n      state.selection = selection$$1 = [\n        [w0 = dim === Y ? W : point0[0], n0 = dim === X ? N : point0[1]],\n        [e0 = dim === Y ? E : w0, s0 = dim === X ? S : n0]\n      ];\n    } else {\n      w0 = selection$$1[0][0];\n      n0 = selection$$1[0][1];\n      e0 = selection$$1[1][0];\n      s0 = selection$$1[1][1];\n    }\n\n    w1 = w0;\n    n1 = n0;\n    e1 = e0;\n    s1 = s0;\n\n    var group = select(that)\n        .attr(\"pointer-events\", \"none\");\n\n    var overlay = group.selectAll(\".overlay\")\n        .attr(\"cursor\", cursors[type]);\n\n    if (exports.event.touches) {\n      group\n          .on(\"touchmove.brush\", moved, true)\n          .on(\"touchend.brush touchcancel.brush\", ended, true);\n    } else {\n      var view = select(exports.event.view)\n          .on(\"keydown.brush\", keydowned, true)\n          .on(\"keyup.brush\", keyupped, true)\n          .on(\"mousemove.brush\", moved, true)\n          .on(\"mouseup.brush\", ended, true);\n\n      dragDisable(exports.event.view);\n    }\n\n    nopropagation$1();\n    interrupt(that);\n    redraw.call(that);\n    emit.start();\n\n    function moved() {\n      var point1 = mouse(that);\n      if (shifting && !lockX && !lockY) {\n        if (Math.abs(point1[0] - point[0]) > Math.abs(point1[1] - point[1])) lockY = true;\n        else lockX = true;\n      }\n      point = point1;\n      moving = true;\n      noevent$1();\n      move();\n    }\n\n    function move() {\n      var t;\n\n      dx = point[0] - point0[0];\n      dy = point[1] - point0[1];\n\n      switch (mode) {\n        case MODE_SPACE:\n        case MODE_DRAG: {\n          if (signX) dx = Math.max(W - w0, Math.min(E - e0, dx)), w1 = w0 + dx, e1 = e0 + dx;\n          if (signY) dy = Math.max(N - n0, Math.min(S - s0, dy)), n1 = n0 + dy, s1 = s0 + dy;\n          break;\n        }\n        case MODE_HANDLE: {\n          if (signX < 0) dx = Math.max(W - w0, Math.min(E - w0, dx)), w1 = w0 + dx, e1 = e0;\n          else if (signX > 0) dx = Math.max(W - e0, Math.min(E - e0, dx)), w1 = w0, e1 = e0 + dx;\n          if (signY < 0) dy = Math.max(N - n0, Math.min(S - n0, dy)), n1 = n0 + dy, s1 = s0;\n          else if (signY > 0) dy = Math.max(N - s0, Math.min(S - s0, dy)), n1 = n0, s1 = s0 + dy;\n          break;\n        }\n        case MODE_CENTER: {\n          if (signX) w1 = Math.max(W, Math.min(E, w0 - dx * signX)), e1 = Math.max(W, Math.min(E, e0 + dx * signX));\n          if (signY) n1 = Math.max(N, Math.min(S, n0 - dy * signY)), s1 = Math.max(N, Math.min(S, s0 + dy * signY));\n          break;\n        }\n      }\n\n      if (e1 < w1) {\n        signX *= -1;\n        t = w0, w0 = e0, e0 = t;\n        t = w1, w1 = e1, e1 = t;\n        if (type in flipX) overlay.attr(\"cursor\", cursors[type = flipX[type]]);\n      }\n\n      if (s1 < n1) {\n        signY *= -1;\n        t = n0, n0 = s0, s0 = t;\n        t = n1, n1 = s1, s1 = t;\n        if (type in flipY) overlay.attr(\"cursor\", cursors[type = flipY[type]]);\n      }\n\n      if (state.selection) selection$$1 = state.selection; // May be set by brush.move!\n      if (lockX) w1 = selection$$1[0][0], e1 = selection$$1[1][0];\n      if (lockY) n1 = selection$$1[0][1], s1 = selection$$1[1][1];\n\n      if (selection$$1[0][0] !== w1\n          || selection$$1[0][1] !== n1\n          || selection$$1[1][0] !== e1\n          || selection$$1[1][1] !== s1) {\n        state.selection = [[w1, n1], [e1, s1]];\n        redraw.call(that);\n        emit.brush();\n      }\n    }\n\n    function ended() {\n      nopropagation$1();\n      if (exports.event.touches) {\n        if (exports.event.touches.length) return;\n        if (touchending) clearTimeout(touchending);\n        touchending = setTimeout(function() { touchending = null; }, 500); // Ghost clicks are delayed!\n        group.on(\"touchmove.brush touchend.brush touchcancel.brush\", null);\n      } else {\n        yesdrag(exports.event.view, moving);\n        view.on(\"keydown.brush keyup.brush mousemove.brush mouseup.brush\", null);\n      }\n      group.attr(\"pointer-events\", \"all\");\n      overlay.attr(\"cursor\", cursors.overlay);\n      if (state.selection) selection$$1 = state.selection; // May be set by brush.move (on start)!\n      if (empty(selection$$1)) state.selection = null, redraw.call(that);\n      emit.end();\n    }\n\n    function keydowned() {\n      switch (exports.event.keyCode) {\n        case 16: { // SHIFT\n          shifting = signX && signY;\n          break;\n        }\n        case 18: { // ALT\n          if (mode === MODE_HANDLE) {\n            if (signX) e0 = e1 - dx * signX, w0 = w1 + dx * signX;\n            if (signY) s0 = s1 - dy * signY, n0 = n1 + dy * signY;\n            mode = MODE_CENTER;\n            move();\n          }\n          break;\n        }\n        case 32: { // SPACE; takes priority over ALT\n          if (mode === MODE_HANDLE || mode === MODE_CENTER) {\n            if (signX < 0) e0 = e1 - dx; else if (signX > 0) w0 = w1 - dx;\n            if (signY < 0) s0 = s1 - dy; else if (signY > 0) n0 = n1 - dy;\n            mode = MODE_SPACE;\n            overlay.attr(\"cursor\", cursors.selection);\n            move();\n          }\n          break;\n        }\n        default: return;\n      }\n      noevent$1();\n    }\n\n    function keyupped() {\n      switch (exports.event.keyCode) {\n        case 16: { // SHIFT\n          if (shifting) {\n            lockX = lockY = shifting = false;\n            move();\n          }\n          break;\n        }\n        case 18: { // ALT\n          if (mode === MODE_CENTER) {\n            if (signX < 0) e0 = e1; else if (signX > 0) w0 = w1;\n            if (signY < 0) s0 = s1; else if (signY > 0) n0 = n1;\n            mode = MODE_HANDLE;\n            move();\n          }\n          break;\n        }\n        case 32: { // SPACE\n          if (mode === MODE_SPACE) {\n            if (exports.event.altKey) {\n              if (signX) e0 = e1 - dx * signX, w0 = w1 + dx * signX;\n              if (signY) s0 = s1 - dy * signY, n0 = n1 + dy * signY;\n              mode = MODE_CENTER;\n            } else {\n              if (signX < 0) e0 = e1; else if (signX > 0) w0 = w1;\n              if (signY < 0) s0 = s1; else if (signY > 0) n0 = n1;\n              mode = MODE_HANDLE;\n            }\n            overlay.attr(\"cursor\", cursors[type]);\n            move();\n          }\n          break;\n        }\n        default: return;\n      }\n      noevent$1();\n    }\n  }\n\n  function initialize() {\n    var state = this.__brush || {selection: null};\n    state.extent = extent.apply(this, arguments);\n    state.dim = dim;\n    return state;\n  }\n\n  brush.extent = function(_) {\n    return arguments.length ? (extent = typeof _ === \"function\" ? _ : constant$4([[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]]), brush) : extent;\n  };\n\n  brush.filter = function(_) {\n    return arguments.length ? (filter = typeof _ === \"function\" ? _ : constant$4(!!_), brush) : filter;\n  };\n\n  brush.handleSize = function(_) {\n    return arguments.length ? (handleSize = +_, brush) : handleSize;\n  };\n\n  brush.on = function() {\n    var value = listeners.on.apply(listeners, arguments);\n    return value === listeners ? brush : value;\n  };\n\n  return brush;\n}\n\nvar cos = Math.cos;\nvar sin = Math.sin;\nvar pi$1 = Math.PI;\nvar halfPi$1 = pi$1 / 2;\nvar tau$1 = pi$1 * 2;\nvar max$1 = Math.max;\n\nfunction compareValue(compare) {\n  return function(a, b) {\n    return compare(\n      a.source.value + a.target.value,\n      b.source.value + b.target.value\n    );\n  };\n}\n\nvar chord = function() {\n  var padAngle = 0,\n      sortGroups = null,\n      sortSubgroups = null,\n      sortChords = null;\n\n  function chord(matrix) {\n    var n = matrix.length,\n        groupSums = [],\n        groupIndex = sequence(n),\n        subgroupIndex = [],\n        chords = [],\n        groups = chords.groups = new Array(n),\n        subgroups = new Array(n * n),\n        k,\n        x,\n        x0,\n        dx,\n        i,\n        j;\n\n    // Compute the sum.\n    k = 0, i = -1; while (++i < n) {\n      x = 0, j = -1; while (++j < n) {\n        x += matrix[i][j];\n      }\n      groupSums.push(x);\n      subgroupIndex.push(sequence(n));\n      k += x;\n    }\n\n    // Sort groups…\n    if (sortGroups) groupIndex.sort(function(a, b) {\n      return sortGroups(groupSums[a], groupSums[b]);\n    });\n\n    // Sort subgroups…\n    if (sortSubgroups) subgroupIndex.forEach(function(d, i) {\n      d.sort(function(a, b) {\n        return sortSubgroups(matrix[i][a], matrix[i][b]);\n      });\n    });\n\n    // Convert the sum to scaling factor for [0, 2pi].\n    // TODO Allow start and end angle to be specified?\n    // TODO Allow padding to be specified as percentage?\n    k = max$1(0, tau$1 - padAngle * n) / k;\n    dx = k ? padAngle : tau$1 / n;\n\n    // Compute the start and end angle for each group and subgroup.\n    // Note: Opera has a bug reordering object literal properties!\n    x = 0, i = -1; while (++i < n) {\n      x0 = x, j = -1; while (++j < n) {\n        var di = groupIndex[i],\n            dj = subgroupIndex[di][j],\n            v = matrix[di][dj],\n            a0 = x,\n            a1 = x += v * k;\n        subgroups[dj * n + di] = {\n          index: di,\n          subindex: dj,\n          startAngle: a0,\n          endAngle: a1,\n          value: v\n        };\n      }\n      groups[di] = {\n        index: di,\n        startAngle: x0,\n        endAngle: x,\n        value: groupSums[di]\n      };\n      x += dx;\n    }\n\n    // Generate chords for each (non-empty) subgroup-subgroup link.\n    i = -1; while (++i < n) {\n      j = i - 1; while (++j < n) {\n        var source = subgroups[j * n + i],\n            target = subgroups[i * n + j];\n        if (source.value || target.value) {\n          chords.push(source.value < target.value\n              ? {source: target, target: source}\n              : {source: source, target: target});\n        }\n      }\n    }\n\n    return sortChords ? chords.sort(sortChords) : chords;\n  }\n\n  chord.padAngle = function(_) {\n    return arguments.length ? (padAngle = max$1(0, _), chord) : padAngle;\n  };\n\n  chord.sortGroups = function(_) {\n    return arguments.length ? (sortGroups = _, chord) : sortGroups;\n  };\n\n  chord.sortSubgroups = function(_) {\n    return arguments.length ? (sortSubgroups = _, chord) : sortSubgroups;\n  };\n\n  chord.sortChords = function(_) {\n    return arguments.length ? (_ == null ? sortChords = null : (sortChords = compareValue(_))._ = _, chord) : sortChords && sortChords._;\n  };\n\n  return chord;\n};\n\nvar slice$2 = Array.prototype.slice;\n\nvar constant$5 = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nvar pi$2 = Math.PI;\nvar tau$2 = 2 * pi$2;\nvar epsilon$1 = 1e-6;\nvar tauEpsilon = tau$2 - epsilon$1;\n\nfunction Path() {\n  this._x0 = this._y0 = // start of current subpath\n  this._x1 = this._y1 = null; // end of current subpath\n  this._ = \"\";\n}\n\nfunction path() {\n  return new Path;\n}\n\nPath.prototype = path.prototype = {\n  constructor: Path,\n  moveTo: function(x, y) {\n    this._ += \"M\" + (this._x0 = this._x1 = +x) + \",\" + (this._y0 = this._y1 = +y);\n  },\n  closePath: function() {\n    if (this._x1 !== null) {\n      this._x1 = this._x0, this._y1 = this._y0;\n      this._ += \"Z\";\n    }\n  },\n  lineTo: function(x, y) {\n    this._ += \"L\" + (this._x1 = +x) + \",\" + (this._y1 = +y);\n  },\n  quadraticCurveTo: function(x1, y1, x, y) {\n    this._ += \"Q\" + (+x1) + \",\" + (+y1) + \",\" + (this._x1 = +x) + \",\" + (this._y1 = +y);\n  },\n  bezierCurveTo: function(x1, y1, x2, y2, x, y) {\n    this._ += \"C\" + (+x1) + \",\" + (+y1) + \",\" + (+x2) + \",\" + (+y2) + \",\" + (this._x1 = +x) + \",\" + (this._y1 = +y);\n  },\n  arcTo: function(x1, y1, x2, y2, r) {\n    x1 = +x1, y1 = +y1, x2 = +x2, y2 = +y2, r = +r;\n    var x0 = this._x1,\n        y0 = this._y1,\n        x21 = x2 - x1,\n        y21 = y2 - y1,\n        x01 = x0 - x1,\n        y01 = y0 - y1,\n        l01_2 = x01 * x01 + y01 * y01;\n\n    // Is the radius negative? Error.\n    if (r < 0) throw new Error(\"negative radius: \" + r);\n\n    // Is this path empty? Move to (x1,y1).\n    if (this._x1 === null) {\n      this._ += \"M\" + (this._x1 = x1) + \",\" + (this._y1 = y1);\n    }\n\n    // Or, is (x1,y1) coincident with (x0,y0)? Do nothing.\n    else if (!(l01_2 > epsilon$1)) {}\n\n    // Or, are (x0,y0), (x1,y1) and (x2,y2) collinear?\n    // Equivalently, is (x1,y1) coincident with (x2,y2)?\n    // Or, is the radius zero? Line to (x1,y1).\n    else if (!(Math.abs(y01 * x21 - y21 * x01) > epsilon$1) || !r) {\n      this._ += \"L\" + (this._x1 = x1) + \",\" + (this._y1 = y1);\n    }\n\n    // Otherwise, draw an arc!\n    else {\n      var x20 = x2 - x0,\n          y20 = y2 - y0,\n          l21_2 = x21 * x21 + y21 * y21,\n          l20_2 = x20 * x20 + y20 * y20,\n          l21 = Math.sqrt(l21_2),\n          l01 = Math.sqrt(l01_2),\n          l = r * Math.tan((pi$2 - Math.acos((l21_2 + l01_2 - l20_2) / (2 * l21 * l01))) / 2),\n          t01 = l / l01,\n          t21 = l / l21;\n\n      // If the start tangent is not coincident with (x0,y0), line to.\n      if (Math.abs(t01 - 1) > epsilon$1) {\n        this._ += \"L\" + (x1 + t01 * x01) + \",\" + (y1 + t01 * y01);\n      }\n\n      this._ += \"A\" + r + \",\" + r + \",0,0,\" + (+(y01 * x20 > x01 * y20)) + \",\" + (this._x1 = x1 + t21 * x21) + \",\" + (this._y1 = y1 + t21 * y21);\n    }\n  },\n  arc: function(x, y, r, a0, a1, ccw) {\n    x = +x, y = +y, r = +r;\n    var dx = r * Math.cos(a0),\n        dy = r * Math.sin(a0),\n        x0 = x + dx,\n        y0 = y + dy,\n        cw = 1 ^ ccw,\n        da = ccw ? a0 - a1 : a1 - a0;\n\n    // Is the radius negative? Error.\n    if (r < 0) throw new Error(\"negative radius: \" + r);\n\n    // Is this path empty? Move to (x0,y0).\n    if (this._x1 === null) {\n      this._ += \"M\" + x0 + \",\" + y0;\n    }\n\n    // Or, is (x0,y0) not coincident with the previous point? Line to (x0,y0).\n    else if (Math.abs(this._x1 - x0) > epsilon$1 || Math.abs(this._y1 - y0) > epsilon$1) {\n      this._ += \"L\" + x0 + \",\" + y0;\n    }\n\n    // Is this arc empty? We’re done.\n    if (!r) return;\n\n    // Is this a complete circle? Draw two arcs to complete the circle.\n    if (da > tauEpsilon) {\n      this._ += \"A\" + r + \",\" + r + \",0,1,\" + cw + \",\" + (x - dx) + \",\" + (y - dy) + \"A\" + r + \",\" + r + \",0,1,\" + cw + \",\" + (this._x1 = x0) + \",\" + (this._y1 = y0);\n    }\n\n    // Otherwise, draw an arc!\n    else {\n      if (da < 0) da = da % tau$2 + tau$2;\n      this._ += \"A\" + r + \",\" + r + \",0,\" + (+(da >= pi$2)) + \",\" + cw + \",\" + (this._x1 = x + r * Math.cos(a1)) + \",\" + (this._y1 = y + r * Math.sin(a1));\n    }\n  },\n  rect: function(x, y, w, h) {\n    this._ += \"M\" + (this._x0 = this._x1 = +x) + \",\" + (this._y0 = this._y1 = +y) + \"h\" + (+w) + \"v\" + (+h) + \"h\" + (-w) + \"Z\";\n  },\n  toString: function() {\n    return this._;\n  }\n};\n\nfunction defaultSource(d) {\n  return d.source;\n}\n\nfunction defaultTarget(d) {\n  return d.target;\n}\n\nfunction defaultRadius(d) {\n  return d.radius;\n}\n\nfunction defaultStartAngle(d) {\n  return d.startAngle;\n}\n\nfunction defaultEndAngle(d) {\n  return d.endAngle;\n}\n\nvar ribbon = function() {\n  var source = defaultSource,\n      target = defaultTarget,\n      radius = defaultRadius,\n      startAngle = defaultStartAngle,\n      endAngle = defaultEndAngle,\n      context = null;\n\n  function ribbon() {\n    var buffer,\n        argv = slice$2.call(arguments),\n        s = source.apply(this, argv),\n        t = target.apply(this, argv),\n        sr = +radius.apply(this, (argv[0] = s, argv)),\n        sa0 = startAngle.apply(this, argv) - halfPi$1,\n        sa1 = endAngle.apply(this, argv) - halfPi$1,\n        sx0 = sr * cos(sa0),\n        sy0 = sr * sin(sa0),\n        tr = +radius.apply(this, (argv[0] = t, argv)),\n        ta0 = startAngle.apply(this, argv) - halfPi$1,\n        ta1 = endAngle.apply(this, argv) - halfPi$1;\n\n    if (!context) context = buffer = path();\n\n    context.moveTo(sx0, sy0);\n    context.arc(0, 0, sr, sa0, sa1);\n    if (sa0 !== ta0 || sa1 !== ta1) { // TODO sr !== tr?\n      context.quadraticCurveTo(0, 0, tr * cos(ta0), tr * sin(ta0));\n      context.arc(0, 0, tr, ta0, ta1);\n    }\n    context.quadraticCurveTo(0, 0, sx0, sy0);\n    context.closePath();\n\n    if (buffer) return context = null, buffer + \"\" || null;\n  }\n\n  ribbon.radius = function(_) {\n    return arguments.length ? (radius = typeof _ === \"function\" ? _ : constant$5(+_), ribbon) : radius;\n  };\n\n  ribbon.startAngle = function(_) {\n    return arguments.length ? (startAngle = typeof _ === \"function\" ? _ : constant$5(+_), ribbon) : startAngle;\n  };\n\n  ribbon.endAngle = function(_) {\n    return arguments.length ? (endAngle = typeof _ === \"function\" ? _ : constant$5(+_), ribbon) : endAngle;\n  };\n\n  ribbon.source = function(_) {\n    return arguments.length ? (source = _, ribbon) : source;\n  };\n\n  ribbon.target = function(_) {\n    return arguments.length ? (target = _, ribbon) : target;\n  };\n\n  ribbon.context = function(_) {\n    return arguments.length ? ((context = _ == null ? null : _), ribbon) : context;\n  };\n\n  return ribbon;\n};\n\nvar prefix = \"$\";\n\nfunction Map() {}\n\nMap.prototype = map$1.prototype = {\n  constructor: Map,\n  has: function(key) {\n    return (prefix + key) in this;\n  },\n  get: function(key) {\n    return this[prefix + key];\n  },\n  set: function(key, value) {\n    this[prefix + key] = value;\n    return this;\n  },\n  remove: function(key) {\n    var property = prefix + key;\n    return property in this && delete this[property];\n  },\n  clear: function() {\n    for (var property in this) if (property[0] === prefix) delete this[property];\n  },\n  keys: function() {\n    var keys = [];\n    for (var property in this) if (property[0] === prefix) keys.push(property.slice(1));\n    return keys;\n  },\n  values: function() {\n    var values = [];\n    for (var property in this) if (property[0] === prefix) values.push(this[property]);\n    return values;\n  },\n  entries: function() {\n    var entries = [];\n    for (var property in this) if (property[0] === prefix) entries.push({key: property.slice(1), value: this[property]});\n    return entries;\n  },\n  size: function() {\n    var size = 0;\n    for (var property in this) if (property[0] === prefix) ++size;\n    return size;\n  },\n  empty: function() {\n    for (var property in this) if (property[0] === prefix) return false;\n    return true;\n  },\n  each: function(f) {\n    for (var property in this) if (property[0] === prefix) f(this[property], property.slice(1), this);\n  }\n};\n\nfunction map$1(object, f) {\n  var map = new Map;\n\n  // Copy constructor.\n  if (object instanceof Map) object.each(function(value, key) { map.set(key, value); });\n\n  // Index array by numeric index or specified key function.\n  else if (Array.isArray(object)) {\n    var i = -1,\n        n = object.length,\n        o;\n\n    if (f == null) while (++i < n) map.set(i, object[i]);\n    else while (++i < n) map.set(f(o = object[i], i, object), o);\n  }\n\n  // Convert object to map.\n  else if (object) for (var key in object) map.set(key, object[key]);\n\n  return map;\n}\n\nvar nest = function() {\n  var keys = [],\n      sortKeys = [],\n      sortValues,\n      rollup,\n      nest;\n\n  function apply(array, depth, createResult, setResult) {\n    if (depth >= keys.length) return rollup != null\n        ? rollup(array) : (sortValues != null\n        ? array.sort(sortValues)\n        : array);\n\n    var i = -1,\n        n = array.length,\n        key = keys[depth++],\n        keyValue,\n        value,\n        valuesByKey = map$1(),\n        values,\n        result = createResult();\n\n    while (++i < n) {\n      if (values = valuesByKey.get(keyValue = key(value = array[i]) + \"\")) {\n        values.push(value);\n      } else {\n        valuesByKey.set(keyValue, [value]);\n      }\n    }\n\n    valuesByKey.each(function(values, key) {\n      setResult(result, key, apply(values, depth, createResult, setResult));\n    });\n\n    return result;\n  }\n\n  function entries(map, depth) {\n    if (++depth > keys.length) return map;\n    var array, sortKey = sortKeys[depth - 1];\n    if (rollup != null && depth >= keys.length) array = map.entries();\n    else array = [], map.each(function(v, k) { array.push({key: k, values: entries(v, depth)}); });\n    return sortKey != null ? array.sort(function(a, b) { return sortKey(a.key, b.key); }) : array;\n  }\n\n  return nest = {\n    object: function(array) { return apply(array, 0, createObject, setObject); },\n    map: function(array) { return apply(array, 0, createMap, setMap); },\n    entries: function(array) { return entries(apply(array, 0, createMap, setMap), 0); },\n    key: function(d) { keys.push(d); return nest; },\n    sortKeys: function(order) { sortKeys[keys.length - 1] = order; return nest; },\n    sortValues: function(order) { sortValues = order; return nest; },\n    rollup: function(f) { rollup = f; return nest; }\n  };\n};\n\nfunction createObject() {\n  return {};\n}\n\nfunction setObject(object, key, value) {\n  object[key] = value;\n}\n\nfunction createMap() {\n  return map$1();\n}\n\nfunction setMap(map, key, value) {\n  map.set(key, value);\n}\n\nfunction Set() {}\n\nvar proto = map$1.prototype;\n\nSet.prototype = set$2.prototype = {\n  constructor: Set,\n  has: proto.has,\n  add: function(value) {\n    value += \"\";\n    this[prefix + value] = value;\n    return this;\n  },\n  remove: proto.remove,\n  clear: proto.clear,\n  values: proto.keys,\n  size: proto.size,\n  empty: proto.empty,\n  each: proto.each\n};\n\nfunction set$2(object, f) {\n  var set = new Set;\n\n  // Copy constructor.\n  if (object instanceof Set) object.each(function(value) { set.add(value); });\n\n  // Otherwise, assume it’s an array.\n  else if (object) {\n    var i = -1, n = object.length;\n    if (f == null) while (++i < n) set.add(object[i]);\n    else while (++i < n) set.add(f(object[i], i, object));\n  }\n\n  return set;\n}\n\nvar keys = function(map) {\n  var keys = [];\n  for (var key in map) keys.push(key);\n  return keys;\n};\n\nvar values = function(map) {\n  var values = [];\n  for (var key in map) values.push(map[key]);\n  return values;\n};\n\nvar entries = function(map) {\n  var entries = [];\n  for (var key in map) entries.push({key: key, value: map[key]});\n  return entries;\n};\n\nfunction objectConverter(columns) {\n  return new Function(\"d\", \"return {\" + columns.map(function(name, i) {\n    return JSON.stringify(name) + \": d[\" + i + \"]\";\n  }).join(\",\") + \"}\");\n}\n\nfunction customConverter(columns, f) {\n  var object = objectConverter(columns);\n  return function(row, i) {\n    return f(object(row), i, columns);\n  };\n}\n\n// Compute unique columns in order of discovery.\nfunction inferColumns(rows) {\n  var columnSet = Object.create(null),\n      columns = [];\n\n  rows.forEach(function(row) {\n    for (var column in row) {\n      if (!(column in columnSet)) {\n        columns.push(columnSet[column] = column);\n      }\n    }\n  });\n\n  return columns;\n}\n\nvar dsv = function(delimiter) {\n  var reFormat = new RegExp(\"[\\\"\" + delimiter + \"\\n]\"),\n      delimiterCode = delimiter.charCodeAt(0);\n\n  function parse(text, f) {\n    var convert, columns, rows = parseRows(text, function(row, i) {\n      if (convert) return convert(row, i - 1);\n      columns = row, convert = f ? customConverter(row, f) : objectConverter(row);\n    });\n    rows.columns = columns;\n    return rows;\n  }\n\n  function parseRows(text, f) {\n    var EOL = {}, // sentinel value for end-of-line\n        EOF = {}, // sentinel value for end-of-file\n        rows = [], // output rows\n        N = text.length,\n        I = 0, // current character index\n        n = 0, // the current line number\n        t, // the current token\n        eol; // is the current token followed by EOL?\n\n    function token() {\n      if (I >= N) return EOF; // special case: end of file\n      if (eol) return eol = false, EOL; // special case: end of line\n\n      // special case: quotes\n      var j = I, c;\n      if (text.charCodeAt(j) === 34) {\n        var i = j;\n        while (i++ < N) {\n          if (text.charCodeAt(i) === 34) {\n            if (text.charCodeAt(i + 1) !== 34) break;\n            ++i;\n          }\n        }\n        I = i + 2;\n        c = text.charCodeAt(i + 1);\n        if (c === 13) {\n          eol = true;\n          if (text.charCodeAt(i + 2) === 10) ++I;\n        } else if (c === 10) {\n          eol = true;\n        }\n        return text.slice(j + 1, i).replace(/\"\"/g, \"\\\"\");\n      }\n\n      // common case: find next delimiter or newline\n      while (I < N) {\n        var k = 1;\n        c = text.charCodeAt(I++);\n        if (c === 10) eol = true; // \\n\n        else if (c === 13) { eol = true; if (text.charCodeAt(I) === 10) ++I, ++k; } // \\r|\\r\\n\n        else if (c !== delimiterCode) continue;\n        return text.slice(j, I - k);\n      }\n\n      // special case: last token before EOF\n      return text.slice(j);\n    }\n\n    while ((t = token()) !== EOF) {\n      var a = [];\n      while (t !== EOL && t !== EOF) {\n        a.push(t);\n        t = token();\n      }\n      if (f && (a = f(a, n++)) == null) continue;\n      rows.push(a);\n    }\n\n    return rows;\n  }\n\n  function format(rows, columns) {\n    if (columns == null) columns = inferColumns(rows);\n    return [columns.map(formatValue).join(delimiter)].concat(rows.map(function(row) {\n      return columns.map(function(column) {\n        return formatValue(row[column]);\n      }).join(delimiter);\n    })).join(\"\\n\");\n  }\n\n  function formatRows(rows) {\n    return rows.map(formatRow).join(\"\\n\");\n  }\n\n  function formatRow(row) {\n    return row.map(formatValue).join(delimiter);\n  }\n\n  function formatValue(text) {\n    return text == null ? \"\"\n        : reFormat.test(text += \"\") ? \"\\\"\" + text.replace(/\\\"/g, \"\\\"\\\"\") + \"\\\"\"\n        : text;\n  }\n\n  return {\n    parse: parse,\n    parseRows: parseRows,\n    format: format,\n    formatRows: formatRows\n  };\n};\n\nvar csv = dsv(\",\");\n\nvar csvParse = csv.parse;\nvar csvParseRows = csv.parseRows;\nvar csvFormat = csv.format;\nvar csvFormatRows = csv.formatRows;\n\nvar tsv = dsv(\"\\t\");\n\nvar tsvParse = tsv.parse;\nvar tsvParseRows = tsv.parseRows;\nvar tsvFormat = tsv.format;\nvar tsvFormatRows = tsv.formatRows;\n\nvar center$1 = function(x, y) {\n  var nodes;\n\n  if (x == null) x = 0;\n  if (y == null) y = 0;\n\n  function force() {\n    var i,\n        n = nodes.length,\n        node,\n        sx = 0,\n        sy = 0;\n\n    for (i = 0; i < n; ++i) {\n      node = nodes[i], sx += node.x, sy += node.y;\n    }\n\n    for (sx = sx / n - x, sy = sy / n - y, i = 0; i < n; ++i) {\n      node = nodes[i], node.x -= sx, node.y -= sy;\n    }\n  }\n\n  force.initialize = function(_) {\n    nodes = _;\n  };\n\n  force.x = function(_) {\n    return arguments.length ? (x = +_, force) : x;\n  };\n\n  force.y = function(_) {\n    return arguments.length ? (y = +_, force) : y;\n  };\n\n  return force;\n};\n\nvar constant$6 = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nvar jiggle = function() {\n  return (Math.random() - 0.5) * 1e-6;\n};\n\nvar tree_add = function(d) {\n  var x = +this._x.call(null, d),\n      y = +this._y.call(null, d);\n  return add(this.cover(x, y), x, y, d);\n};\n\nfunction add(tree, x, y, d) {\n  if (isNaN(x) || isNaN(y)) return tree; // ignore invalid points\n\n  var parent,\n      node = tree._root,\n      leaf = {data: d},\n      x0 = tree._x0,\n      y0 = tree._y0,\n      x1 = tree._x1,\n      y1 = tree._y1,\n      xm,\n      ym,\n      xp,\n      yp,\n      right,\n      bottom,\n      i,\n      j;\n\n  // If the tree is empty, initialize the root as a leaf.\n  if (!node) return tree._root = leaf, tree;\n\n  // Find the existing leaf for the new point, or add it.\n  while (node.length) {\n    if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm;\n    if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym;\n    if (parent = node, !(node = node[i = bottom << 1 | right])) return parent[i] = leaf, tree;\n  }\n\n  // Is the new point is exactly coincident with the existing point?\n  xp = +tree._x.call(null, node.data);\n  yp = +tree._y.call(null, node.data);\n  if (x === xp && y === yp) return leaf.next = node, parent ? parent[i] = leaf : tree._root = leaf, tree;\n\n  // Otherwise, split the leaf node until the old and new point are separated.\n  do {\n    parent = parent ? parent[i] = new Array(4) : tree._root = new Array(4);\n    if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm;\n    if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym;\n  } while ((i = bottom << 1 | right) === (j = (yp >= ym) << 1 | (xp >= xm)));\n  return parent[j] = node, parent[i] = leaf, tree;\n}\n\nfunction addAll(data) {\n  var d, i, n = data.length,\n      x,\n      y,\n      xz = new Array(n),\n      yz = new Array(n),\n      x0 = Infinity,\n      y0 = Infinity,\n      x1 = -Infinity,\n      y1 = -Infinity;\n\n  // Compute the points and their extent.\n  for (i = 0; i < n; ++i) {\n    if (isNaN(x = +this._x.call(null, d = data[i])) || isNaN(y = +this._y.call(null, d))) continue;\n    xz[i] = x;\n    yz[i] = y;\n    if (x < x0) x0 = x;\n    if (x > x1) x1 = x;\n    if (y < y0) y0 = y;\n    if (y > y1) y1 = y;\n  }\n\n  // If there were no (valid) points, inherit the existing extent.\n  if (x1 < x0) x0 = this._x0, x1 = this._x1;\n  if (y1 < y0) y0 = this._y0, y1 = this._y1;\n\n  // Expand the tree to cover the new points.\n  this.cover(x0, y0).cover(x1, y1);\n\n  // Add the new points.\n  for (i = 0; i < n; ++i) {\n    add(this, xz[i], yz[i], data[i]);\n  }\n\n  return this;\n}\n\nvar tree_cover = function(x, y) {\n  if (isNaN(x = +x) || isNaN(y = +y)) return this; // ignore invalid points\n\n  var x0 = this._x0,\n      y0 = this._y0,\n      x1 = this._x1,\n      y1 = this._y1;\n\n  // If the quadtree has no extent, initialize them.\n  // Integer extent are necessary so that if we later double the extent,\n  // the existing quadrant boundaries don’t change due to floating point error!\n  if (isNaN(x0)) {\n    x1 = (x0 = Math.floor(x)) + 1;\n    y1 = (y0 = Math.floor(y)) + 1;\n  }\n\n  // Otherwise, double repeatedly to cover.\n  else if (x0 > x || x > x1 || y0 > y || y > y1) {\n    var z = x1 - x0,\n        node = this._root,\n        parent,\n        i;\n\n    switch (i = (y < (y0 + y1) / 2) << 1 | (x < (x0 + x1) / 2)) {\n      case 0: {\n        do parent = new Array(4), parent[i] = node, node = parent;\n        while (z *= 2, x1 = x0 + z, y1 = y0 + z, x > x1 || y > y1);\n        break;\n      }\n      case 1: {\n        do parent = new Array(4), parent[i] = node, node = parent;\n        while (z *= 2, x0 = x1 - z, y1 = y0 + z, x0 > x || y > y1);\n        break;\n      }\n      case 2: {\n        do parent = new Array(4), parent[i] = node, node = parent;\n        while (z *= 2, x1 = x0 + z, y0 = y1 - z, x > x1 || y0 > y);\n        break;\n      }\n      case 3: {\n        do parent = new Array(4), parent[i] = node, node = parent;\n        while (z *= 2, x0 = x1 - z, y0 = y1 - z, x0 > x || y0 > y);\n        break;\n      }\n    }\n\n    if (this._root && this._root.length) this._root = node;\n  }\n\n  // If the quadtree covers the point already, just return.\n  else return this;\n\n  this._x0 = x0;\n  this._y0 = y0;\n  this._x1 = x1;\n  this._y1 = y1;\n  return this;\n};\n\nvar tree_data = function() {\n  var data = [];\n  this.visit(function(node) {\n    if (!node.length) do data.push(node.data); while (node = node.next)\n  });\n  return data;\n};\n\nvar tree_extent = function(_) {\n  return arguments.length\n      ? this.cover(+_[0][0], +_[0][1]).cover(+_[1][0], +_[1][1])\n      : isNaN(this._x0) ? undefined : [[this._x0, this._y0], [this._x1, this._y1]];\n};\n\nvar Quad = function(node, x0, y0, x1, y1) {\n  this.node = node;\n  this.x0 = x0;\n  this.y0 = y0;\n  this.x1 = x1;\n  this.y1 = y1;\n};\n\nvar tree_find = function(x, y, radius) {\n  var data,\n      x0 = this._x0,\n      y0 = this._y0,\n      x1,\n      y1,\n      x2,\n      y2,\n      x3 = this._x1,\n      y3 = this._y1,\n      quads = [],\n      node = this._root,\n      q,\n      i;\n\n  if (node) quads.push(new Quad(node, x0, y0, x3, y3));\n  if (radius == null) radius = Infinity;\n  else {\n    x0 = x - radius, y0 = y - radius;\n    x3 = x + radius, y3 = y + radius;\n    radius *= radius;\n  }\n\n  while (q = quads.pop()) {\n\n    // Stop searching if this quadrant can’t contain a closer node.\n    if (!(node = q.node)\n        || (x1 = q.x0) > x3\n        || (y1 = q.y0) > y3\n        || (x2 = q.x1) < x0\n        || (y2 = q.y1) < y0) continue;\n\n    // Bisect the current quadrant.\n    if (node.length) {\n      var xm = (x1 + x2) / 2,\n          ym = (y1 + y2) / 2;\n\n      quads.push(\n        new Quad(node[3], xm, ym, x2, y2),\n        new Quad(node[2], x1, ym, xm, y2),\n        new Quad(node[1], xm, y1, x2, ym),\n        new Quad(node[0], x1, y1, xm, ym)\n      );\n\n      // Visit the closest quadrant first.\n      if (i = (y >= ym) << 1 | (x >= xm)) {\n        q = quads[quads.length - 1];\n        quads[quads.length - 1] = quads[quads.length - 1 - i];\n        quads[quads.length - 1 - i] = q;\n      }\n    }\n\n    // Visit this point. (Visiting coincident points isn’t necessary!)\n    else {\n      var dx = x - +this._x.call(null, node.data),\n          dy = y - +this._y.call(null, node.data),\n          d2 = dx * dx + dy * dy;\n      if (d2 < radius) {\n        var d = Math.sqrt(radius = d2);\n        x0 = x - d, y0 = y - d;\n        x3 = x + d, y3 = y + d;\n        data = node.data;\n      }\n    }\n  }\n\n  return data;\n};\n\nvar tree_remove = function(d) {\n  if (isNaN(x = +this._x.call(null, d)) || isNaN(y = +this._y.call(null, d))) return this; // ignore invalid points\n\n  var parent,\n      node = this._root,\n      retainer,\n      previous,\n      next,\n      x0 = this._x0,\n      y0 = this._y0,\n      x1 = this._x1,\n      y1 = this._y1,\n      x,\n      y,\n      xm,\n      ym,\n      right,\n      bottom,\n      i,\n      j;\n\n  // If the tree is empty, initialize the root as a leaf.\n  if (!node) return this;\n\n  // Find the leaf node for the point.\n  // While descending, also retain the deepest parent with a non-removed sibling.\n  if (node.length) while (true) {\n    if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm;\n    if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym;\n    if (!(parent = node, node = node[i = bottom << 1 | right])) return this;\n    if (!node.length) break;\n    if (parent[(i + 1) & 3] || parent[(i + 2) & 3] || parent[(i + 3) & 3]) retainer = parent, j = i;\n  }\n\n  // Find the point to remove.\n  while (node.data !== d) if (!(previous = node, node = node.next)) return this;\n  if (next = node.next) delete node.next;\n\n  // If there are multiple coincident points, remove just the point.\n  if (previous) return (next ? previous.next = next : delete previous.next), this;\n\n  // If this is the root point, remove it.\n  if (!parent) return this._root = next, this;\n\n  // Remove this leaf.\n  next ? parent[i] = next : delete parent[i];\n\n  // If the parent now contains exactly one leaf, collapse superfluous parents.\n  if ((node = parent[0] || parent[1] || parent[2] || parent[3])\n      && node === (parent[3] || parent[2] || parent[1] || parent[0])\n      && !node.length) {\n    if (retainer) retainer[j] = node;\n    else this._root = node;\n  }\n\n  return this;\n};\n\nfunction removeAll(data) {\n  for (var i = 0, n = data.length; i < n; ++i) this.remove(data[i]);\n  return this;\n}\n\nvar tree_root = function() {\n  return this._root;\n};\n\nvar tree_size = function() {\n  var size = 0;\n  this.visit(function(node) {\n    if (!node.length) do ++size; while (node = node.next)\n  });\n  return size;\n};\n\nvar tree_visit = function(callback) {\n  var quads = [], q, node = this._root, child, x0, y0, x1, y1;\n  if (node) quads.push(new Quad(node, this._x0, this._y0, this._x1, this._y1));\n  while (q = quads.pop()) {\n    if (!callback(node = q.node, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1) && node.length) {\n      var xm = (x0 + x1) / 2, ym = (y0 + y1) / 2;\n      if (child = node[3]) quads.push(new Quad(child, xm, ym, x1, y1));\n      if (child = node[2]) quads.push(new Quad(child, x0, ym, xm, y1));\n      if (child = node[1]) quads.push(new Quad(child, xm, y0, x1, ym));\n      if (child = node[0]) quads.push(new Quad(child, x0, y0, xm, ym));\n    }\n  }\n  return this;\n};\n\nvar tree_visitAfter = function(callback) {\n  var quads = [], next = [], q;\n  if (this._root) quads.push(new Quad(this._root, this._x0, this._y0, this._x1, this._y1));\n  while (q = quads.pop()) {\n    var node = q.node;\n    if (node.length) {\n      var child, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1, xm = (x0 + x1) / 2, ym = (y0 + y1) / 2;\n      if (child = node[0]) quads.push(new Quad(child, x0, y0, xm, ym));\n      if (child = node[1]) quads.push(new Quad(child, xm, y0, x1, ym));\n      if (child = node[2]) quads.push(new Quad(child, x0, ym, xm, y1));\n      if (child = node[3]) quads.push(new Quad(child, xm, ym, x1, y1));\n    }\n    next.push(q);\n  }\n  while (q = next.pop()) {\n    callback(q.node, q.x0, q.y0, q.x1, q.y1);\n  }\n  return this;\n};\n\nfunction defaultX(d) {\n  return d[0];\n}\n\nvar tree_x = function(_) {\n  return arguments.length ? (this._x = _, this) : this._x;\n};\n\nfunction defaultY(d) {\n  return d[1];\n}\n\nvar tree_y = function(_) {\n  return arguments.length ? (this._y = _, this) : this._y;\n};\n\nfunction quadtree(nodes, x, y) {\n  var tree = new Quadtree(x == null ? defaultX : x, y == null ? defaultY : y, NaN, NaN, NaN, NaN);\n  return nodes == null ? tree : tree.addAll(nodes);\n}\n\nfunction Quadtree(x, y, x0, y0, x1, y1) {\n  this._x = x;\n  this._y = y;\n  this._x0 = x0;\n  this._y0 = y0;\n  this._x1 = x1;\n  this._y1 = y1;\n  this._root = undefined;\n}\n\nfunction leaf_copy(leaf) {\n  var copy = {data: leaf.data}, next = copy;\n  while (leaf = leaf.next) next = next.next = {data: leaf.data};\n  return copy;\n}\n\nvar treeProto = quadtree.prototype = Quadtree.prototype;\n\ntreeProto.copy = function() {\n  var copy = new Quadtree(this._x, this._y, this._x0, this._y0, this._x1, this._y1),\n      node = this._root,\n      nodes,\n      child;\n\n  if (!node) return copy;\n\n  if (!node.length) return copy._root = leaf_copy(node), copy;\n\n  nodes = [{source: node, target: copy._root = new Array(4)}];\n  while (node = nodes.pop()) {\n    for (var i = 0; i < 4; ++i) {\n      if (child = node.source[i]) {\n        if (child.length) nodes.push({source: child, target: node.target[i] = new Array(4)});\n        else node.target[i] = leaf_copy(child);\n      }\n    }\n  }\n\n  return copy;\n};\n\ntreeProto.add = tree_add;\ntreeProto.addAll = addAll;\ntreeProto.cover = tree_cover;\ntreeProto.data = tree_data;\ntreeProto.extent = tree_extent;\ntreeProto.find = tree_find;\ntreeProto.remove = tree_remove;\ntreeProto.removeAll = removeAll;\ntreeProto.root = tree_root;\ntreeProto.size = tree_size;\ntreeProto.visit = tree_visit;\ntreeProto.visitAfter = tree_visitAfter;\ntreeProto.x = tree_x;\ntreeProto.y = tree_y;\n\nfunction x(d) {\n  return d.x + d.vx;\n}\n\nfunction y(d) {\n  return d.y + d.vy;\n}\n\nvar collide = function(radius) {\n  var nodes,\n      radii,\n      strength = 1,\n      iterations = 1;\n\n  if (typeof radius !== \"function\") radius = constant$6(radius == null ? 1 : +radius);\n\n  function force() {\n    var i, n = nodes.length,\n        tree,\n        node,\n        xi,\n        yi,\n        ri,\n        ri2;\n\n    for (var k = 0; k < iterations; ++k) {\n      tree = quadtree(nodes, x, y).visitAfter(prepare);\n      for (i = 0; i < n; ++i) {\n        node = nodes[i];\n        ri = radii[node.index], ri2 = ri * ri;\n        xi = node.x + node.vx;\n        yi = node.y + node.vy;\n        tree.visit(apply);\n      }\n    }\n\n    function apply(quad, x0, y0, x1, y1) {\n      var data = quad.data, rj = quad.r, r = ri + rj;\n      if (data) {\n        if (data.index > node.index) {\n          var x = xi - data.x - data.vx,\n              y = yi - data.y - data.vy,\n              l = x * x + y * y;\n          if (l < r * r) {\n            if (x === 0) x = jiggle(), l += x * x;\n            if (y === 0) y = jiggle(), l += y * y;\n            l = (r - (l = Math.sqrt(l))) / l * strength;\n            node.vx += (x *= l) * (r = (rj *= rj) / (ri2 + rj));\n            node.vy += (y *= l) * r;\n            data.vx -= x * (r = 1 - r);\n            data.vy -= y * r;\n          }\n        }\n        return;\n      }\n      return x0 > xi + r || x1 < xi - r || y0 > yi + r || y1 < yi - r;\n    }\n  }\n\n  function prepare(quad) {\n    if (quad.data) return quad.r = radii[quad.data.index];\n    for (var i = quad.r = 0; i < 4; ++i) {\n      if (quad[i] && quad[i].r > quad.r) {\n        quad.r = quad[i].r;\n      }\n    }\n  }\n\n  function initialize() {\n    if (!nodes) return;\n    var i, n = nodes.length, node;\n    radii = new Array(n);\n    for (i = 0; i < n; ++i) node = nodes[i], radii[node.index] = +radius(node, i, nodes);\n  }\n\n  force.initialize = function(_) {\n    nodes = _;\n    initialize();\n  };\n\n  force.iterations = function(_) {\n    return arguments.length ? (iterations = +_, force) : iterations;\n  };\n\n  force.strength = function(_) {\n    return arguments.length ? (strength = +_, force) : strength;\n  };\n\n  force.radius = function(_) {\n    return arguments.length ? (radius = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : radius;\n  };\n\n  return force;\n};\n\nfunction index(d) {\n  return d.index;\n}\n\nfunction find(nodeById, nodeId) {\n  var node = nodeById.get(nodeId);\n  if (!node) throw new Error(\"missing: \" + nodeId);\n  return node;\n}\n\nvar link = function(links) {\n  var id = index,\n      strength = defaultStrength,\n      strengths,\n      distance = constant$6(30),\n      distances,\n      nodes,\n      count,\n      bias,\n      iterations = 1;\n\n  if (links == null) links = [];\n\n  function defaultStrength(link) {\n    return 1 / Math.min(count[link.source.index], count[link.target.index]);\n  }\n\n  function force(alpha) {\n    for (var k = 0, n = links.length; k < iterations; ++k) {\n      for (var i = 0, link, source, target, x, y, l, b; i < n; ++i) {\n        link = links[i], source = link.source, target = link.target;\n        x = target.x + target.vx - source.x - source.vx || jiggle();\n        y = target.y + target.vy - source.y - source.vy || jiggle();\n        l = Math.sqrt(x * x + y * y);\n        l = (l - distances[i]) / l * alpha * strengths[i];\n        x *= l, y *= l;\n        target.vx -= x * (b = bias[i]);\n        target.vy -= y * b;\n        source.vx += x * (b = 1 - b);\n        source.vy += y * b;\n      }\n    }\n  }\n\n  function initialize() {\n    if (!nodes) return;\n\n    var i,\n        n = nodes.length,\n        m = links.length,\n        nodeById = map$1(nodes, id),\n        link;\n\n    for (i = 0, count = new Array(n); i < m; ++i) {\n      link = links[i], link.index = i;\n      if (typeof link.source !== \"object\") link.source = find(nodeById, link.source);\n      if (typeof link.target !== \"object\") link.target = find(nodeById, link.target);\n      count[link.source.index] = (count[link.source.index] || 0) + 1;\n      count[link.target.index] = (count[link.target.index] || 0) + 1;\n    }\n\n    for (i = 0, bias = new Array(m); i < m; ++i) {\n      link = links[i], bias[i] = count[link.source.index] / (count[link.source.index] + count[link.target.index]);\n    }\n\n    strengths = new Array(m), initializeStrength();\n    distances = new Array(m), initializeDistance();\n  }\n\n  function initializeStrength() {\n    if (!nodes) return;\n\n    for (var i = 0, n = links.length; i < n; ++i) {\n      strengths[i] = +strength(links[i], i, links);\n    }\n  }\n\n  function initializeDistance() {\n    if (!nodes) return;\n\n    for (var i = 0, n = links.length; i < n; ++i) {\n      distances[i] = +distance(links[i], i, links);\n    }\n  }\n\n  force.initialize = function(_) {\n    nodes = _;\n    initialize();\n  };\n\n  force.links = function(_) {\n    return arguments.length ? (links = _, initialize(), force) : links;\n  };\n\n  force.id = function(_) {\n    return arguments.length ? (id = _, force) : id;\n  };\n\n  force.iterations = function(_) {\n    return arguments.length ? (iterations = +_, force) : iterations;\n  };\n\n  force.strength = function(_) {\n    return arguments.length ? (strength = typeof _ === \"function\" ? _ : constant$6(+_), initializeStrength(), force) : strength;\n  };\n\n  force.distance = function(_) {\n    return arguments.length ? (distance = typeof _ === \"function\" ? _ : constant$6(+_), initializeDistance(), force) : distance;\n  };\n\n  return force;\n};\n\nfunction x$1(d) {\n  return d.x;\n}\n\nfunction y$1(d) {\n  return d.y;\n}\n\nvar initialRadius = 10;\nvar initialAngle = Math.PI * (3 - Math.sqrt(5));\n\nvar simulation = function(nodes) {\n  var simulation,\n      alpha = 1,\n      alphaMin = 0.001,\n      alphaDecay = 1 - Math.pow(alphaMin, 1 / 300),\n      alphaTarget = 0,\n      velocityDecay = 0.6,\n      forces = map$1(),\n      stepper = timer(step),\n      event = dispatch(\"tick\", \"end\");\n\n  if (nodes == null) nodes = [];\n\n  function step() {\n    tick();\n    event.call(\"tick\", simulation);\n    if (alpha < alphaMin) {\n      stepper.stop();\n      event.call(\"end\", simulation);\n    }\n  }\n\n  function tick() {\n    var i, n = nodes.length, node;\n\n    alpha += (alphaTarget - alpha) * alphaDecay;\n\n    forces.each(function(force) {\n      force(alpha);\n    });\n\n    for (i = 0; i < n; ++i) {\n      node = nodes[i];\n      if (node.fx == null) node.x += node.vx *= velocityDecay;\n      else node.x = node.fx, node.vx = 0;\n      if (node.fy == null) node.y += node.vy *= velocityDecay;\n      else node.y = node.fy, node.vy = 0;\n    }\n  }\n\n  function initializeNodes() {\n    for (var i = 0, n = nodes.length, node; i < n; ++i) {\n      node = nodes[i], node.index = i;\n      if (isNaN(node.x) || isNaN(node.y)) {\n        var radius = initialRadius * Math.sqrt(i), angle = i * initialAngle;\n        node.x = radius * Math.cos(angle);\n        node.y = radius * Math.sin(angle);\n      }\n      if (isNaN(node.vx) || isNaN(node.vy)) {\n        node.vx = node.vy = 0;\n      }\n    }\n  }\n\n  function initializeForce(force) {\n    if (force.initialize) force.initialize(nodes);\n    return force;\n  }\n\n  initializeNodes();\n\n  return simulation = {\n    tick: tick,\n\n    restart: function() {\n      return stepper.restart(step), simulation;\n    },\n\n    stop: function() {\n      return stepper.stop(), simulation;\n    },\n\n    nodes: function(_) {\n      return arguments.length ? (nodes = _, initializeNodes(), forces.each(initializeForce), simulation) : nodes;\n    },\n\n    alpha: function(_) {\n      return arguments.length ? (alpha = +_, simulation) : alpha;\n    },\n\n    alphaMin: function(_) {\n      return arguments.length ? (alphaMin = +_, simulation) : alphaMin;\n    },\n\n    alphaDecay: function(_) {\n      return arguments.length ? (alphaDecay = +_, simulation) : +alphaDecay;\n    },\n\n    alphaTarget: function(_) {\n      return arguments.length ? (alphaTarget = +_, simulation) : alphaTarget;\n    },\n\n    velocityDecay: function(_) {\n      return arguments.length ? (velocityDecay = 1 - _, simulation) : 1 - velocityDecay;\n    },\n\n    force: function(name, _) {\n      return arguments.length > 1 ? ((_ == null ? forces.remove(name) : forces.set(name, initializeForce(_))), simulation) : forces.get(name);\n    },\n\n    find: function(x, y, radius) {\n      var i = 0,\n          n = nodes.length,\n          dx,\n          dy,\n          d2,\n          node,\n          closest;\n\n      if (radius == null) radius = Infinity;\n      else radius *= radius;\n\n      for (i = 0; i < n; ++i) {\n        node = nodes[i];\n        dx = x - node.x;\n        dy = y - node.y;\n        d2 = dx * dx + dy * dy;\n        if (d2 < radius) closest = node, radius = d2;\n      }\n\n      return closest;\n    },\n\n    on: function(name, _) {\n      return arguments.length > 1 ? (event.on(name, _), simulation) : event.on(name);\n    }\n  };\n};\n\nvar manyBody = function() {\n  var nodes,\n      node,\n      alpha,\n      strength = constant$6(-30),\n      strengths,\n      distanceMin2 = 1,\n      distanceMax2 = Infinity,\n      theta2 = 0.81;\n\n  function force(_) {\n    var i, n = nodes.length, tree = quadtree(nodes, x$1, y$1).visitAfter(accumulate);\n    for (alpha = _, i = 0; i < n; ++i) node = nodes[i], tree.visit(apply);\n  }\n\n  function initialize() {\n    if (!nodes) return;\n    var i, n = nodes.length, node;\n    strengths = new Array(n);\n    for (i = 0; i < n; ++i) node = nodes[i], strengths[node.index] = +strength(node, i, nodes);\n  }\n\n  function accumulate(quad) {\n    var strength = 0, q, c, x$$1, y$$1, i;\n\n    // For internal nodes, accumulate forces from child quadrants.\n    if (quad.length) {\n      for (x$$1 = y$$1 = i = 0; i < 4; ++i) {\n        if ((q = quad[i]) && (c = q.value)) {\n          strength += c, x$$1 += c * q.x, y$$1 += c * q.y;\n        }\n      }\n      quad.x = x$$1 / strength;\n      quad.y = y$$1 / strength;\n    }\n\n    // For leaf nodes, accumulate forces from coincident quadrants.\n    else {\n      q = quad;\n      q.x = q.data.x;\n      q.y = q.data.y;\n      do strength += strengths[q.data.index];\n      while (q = q.next);\n    }\n\n    quad.value = strength;\n  }\n\n  function apply(quad, x1, _, x2) {\n    if (!quad.value) return true;\n\n    var x$$1 = quad.x - node.x,\n        y$$1 = quad.y - node.y,\n        w = x2 - x1,\n        l = x$$1 * x$$1 + y$$1 * y$$1;\n\n    // Apply the Barnes-Hut approximation if possible.\n    // Limit forces for very close nodes; randomize direction if coincident.\n    if (w * w / theta2 < l) {\n      if (l < distanceMax2) {\n        if (x$$1 === 0) x$$1 = jiggle(), l += x$$1 * x$$1;\n        if (y$$1 === 0) y$$1 = jiggle(), l += y$$1 * y$$1;\n        if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l);\n        node.vx += x$$1 * quad.value * alpha / l;\n        node.vy += y$$1 * quad.value * alpha / l;\n      }\n      return true;\n    }\n\n    // Otherwise, process points directly.\n    else if (quad.length || l >= distanceMax2) return;\n\n    // Limit forces for very close nodes; randomize direction if coincident.\n    if (quad.data !== node || quad.next) {\n      if (x$$1 === 0) x$$1 = jiggle(), l += x$$1 * x$$1;\n      if (y$$1 === 0) y$$1 = jiggle(), l += y$$1 * y$$1;\n      if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l);\n    }\n\n    do if (quad.data !== node) {\n      w = strengths[quad.data.index] * alpha / l;\n      node.vx += x$$1 * w;\n      node.vy += y$$1 * w;\n    } while (quad = quad.next);\n  }\n\n  force.initialize = function(_) {\n    nodes = _;\n    initialize();\n  };\n\n  force.strength = function(_) {\n    return arguments.length ? (strength = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : strength;\n  };\n\n  force.distanceMin = function(_) {\n    return arguments.length ? (distanceMin2 = _ * _, force) : Math.sqrt(distanceMin2);\n  };\n\n  force.distanceMax = function(_) {\n    return arguments.length ? (distanceMax2 = _ * _, force) : Math.sqrt(distanceMax2);\n  };\n\n  force.theta = function(_) {\n    return arguments.length ? (theta2 = _ * _, force) : Math.sqrt(theta2);\n  };\n\n  return force;\n};\n\nvar x$2 = function(x) {\n  var strength = constant$6(0.1),\n      nodes,\n      strengths,\n      xz;\n\n  if (typeof x !== \"function\") x = constant$6(x == null ? 0 : +x);\n\n  function force(alpha) {\n    for (var i = 0, n = nodes.length, node; i < n; ++i) {\n      node = nodes[i], node.vx += (xz[i] - node.x) * strengths[i] * alpha;\n    }\n  }\n\n  function initialize() {\n    if (!nodes) return;\n    var i, n = nodes.length;\n    strengths = new Array(n);\n    xz = new Array(n);\n    for (i = 0; i < n; ++i) {\n      strengths[i] = isNaN(xz[i] = +x(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes);\n    }\n  }\n\n  force.initialize = function(_) {\n    nodes = _;\n    initialize();\n  };\n\n  force.strength = function(_) {\n    return arguments.length ? (strength = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : strength;\n  };\n\n  force.x = function(_) {\n    return arguments.length ? (x = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : x;\n  };\n\n  return force;\n};\n\nvar y$2 = function(y) {\n  var strength = constant$6(0.1),\n      nodes,\n      strengths,\n      yz;\n\n  if (typeof y !== \"function\") y = constant$6(y == null ? 0 : +y);\n\n  function force(alpha) {\n    for (var i = 0, n = nodes.length, node; i < n; ++i) {\n      node = nodes[i], node.vy += (yz[i] - node.y) * strengths[i] * alpha;\n    }\n  }\n\n  function initialize() {\n    if (!nodes) return;\n    var i, n = nodes.length;\n    strengths = new Array(n);\n    yz = new Array(n);\n    for (i = 0; i < n; ++i) {\n      strengths[i] = isNaN(yz[i] = +y(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes);\n    }\n  }\n\n  force.initialize = function(_) {\n    nodes = _;\n    initialize();\n  };\n\n  force.strength = function(_) {\n    return arguments.length ? (strength = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : strength;\n  };\n\n  force.y = function(_) {\n    return arguments.length ? (y = typeof _ === \"function\" ? _ : constant$6(+_), initialize(), force) : y;\n  };\n\n  return force;\n};\n\n// Computes the decimal coefficient and exponent of the specified number x with\n// significant digits p, where x is positive and p is in [1, 21] or undefined.\n// For example, formatDecimal(1.23) returns [\"123\", 0].\nvar formatDecimal = function(x, p) {\n  if ((i = (x = p ? x.toExponential(p - 1) : x.toExponential()).indexOf(\"e\")) < 0) return null; // NaN, ±Infinity\n  var i, coefficient = x.slice(0, i);\n\n  // The string returned by toExponential either has the form \\d\\.\\d+e[-+]\\d+\n  // (e.g., 1.2e+3) or the form \\de[-+]\\d+ (e.g., 1e+3).\n  return [\n    coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient,\n    +x.slice(i + 1)\n  ];\n};\n\nvar exponent$1 = function(x) {\n  return x = formatDecimal(Math.abs(x)), x ? x[1] : NaN;\n};\n\nvar formatGroup = function(grouping, thousands) {\n  return function(value, width) {\n    var i = value.length,\n        t = [],\n        j = 0,\n        g = grouping[0],\n        length = 0;\n\n    while (i > 0 && g > 0) {\n      if (length + g + 1 > width) g = Math.max(1, width - length);\n      t.push(value.substring(i -= g, i + g));\n      if ((length += g + 1) > width) break;\n      g = grouping[j = (j + 1) % grouping.length];\n    }\n\n    return t.reverse().join(thousands);\n  };\n};\n\nvar formatDefault = function(x, p) {\n  x = x.toPrecision(p);\n\n  out: for (var n = x.length, i = 1, i0 = -1, i1; i < n; ++i) {\n    switch (x[i]) {\n      case \".\": i0 = i1 = i; break;\n      case \"0\": if (i0 === 0) i0 = i; i1 = i; break;\n      case \"e\": break out;\n      default: if (i0 > 0) i0 = 0; break;\n    }\n  }\n\n  return i0 > 0 ? x.slice(0, i0) + x.slice(i1 + 1) : x;\n};\n\nvar prefixExponent;\n\nvar formatPrefixAuto = function(x, p) {\n  var d = formatDecimal(x, p);\n  if (!d) return x + \"\";\n  var coefficient = d[0],\n      exponent = d[1],\n      i = exponent - (prefixExponent = Math.max(-8, Math.min(8, Math.floor(exponent / 3))) * 3) + 1,\n      n = coefficient.length;\n  return i === n ? coefficient\n      : i > n ? coefficient + new Array(i - n + 1).join(\"0\")\n      : i > 0 ? coefficient.slice(0, i) + \".\" + coefficient.slice(i)\n      : \"0.\" + new Array(1 - i).join(\"0\") + formatDecimal(x, Math.max(0, p + i - 1))[0]; // less than 1y!\n};\n\nvar formatRounded = function(x, p) {\n  var d = formatDecimal(x, p);\n  if (!d) return x + \"\";\n  var coefficient = d[0],\n      exponent = d[1];\n  return exponent < 0 ? \"0.\" + new Array(-exponent).join(\"0\") + coefficient\n      : coefficient.length > exponent + 1 ? coefficient.slice(0, exponent + 1) + \".\" + coefficient.slice(exponent + 1)\n      : coefficient + new Array(exponent - coefficient.length + 2).join(\"0\");\n};\n\nvar formatTypes = {\n  \"\": formatDefault,\n  \"%\": function(x, p) { return (x * 100).toFixed(p); },\n  \"b\": function(x) { return Math.round(x).toString(2); },\n  \"c\": function(x) { return x + \"\"; },\n  \"d\": function(x) { return Math.round(x).toString(10); },\n  \"e\": function(x, p) { return x.toExponential(p); },\n  \"f\": function(x, p) { return x.toFixed(p); },\n  \"g\": function(x, p) { return x.toPrecision(p); },\n  \"o\": function(x) { return Math.round(x).toString(8); },\n  \"p\": function(x, p) { return formatRounded(x * 100, p); },\n  \"r\": formatRounded,\n  \"s\": formatPrefixAuto,\n  \"X\": function(x) { return Math.round(x).toString(16).toUpperCase(); },\n  \"x\": function(x) { return Math.round(x).toString(16); }\n};\n\n// [[fill]align][sign][symbol][0][width][,][.precision][type]\nvar re = /^(?:(.)?([<>=^]))?([+\\-\\( ])?([$#])?(0)?(\\d+)?(,)?(\\.\\d+)?([a-z%])?$/i;\n\nvar formatSpecifier = function(specifier) {\n  return new FormatSpecifier(specifier);\n};\n\nfunction FormatSpecifier(specifier) {\n  if (!(match = re.exec(specifier))) throw new Error(\"invalid format: \" + specifier);\n\n  var match,\n      fill = match[1] || \" \",\n      align = match[2] || \">\",\n      sign = match[3] || \"-\",\n      symbol = match[4] || \"\",\n      zero = !!match[5],\n      width = match[6] && +match[6],\n      comma = !!match[7],\n      precision = match[8] && +match[8].slice(1),\n      type = match[9] || \"\";\n\n  // The \"n\" type is an alias for \",g\".\n  if (type === \"n\") comma = true, type = \"g\";\n\n  // Map invalid types to the default format.\n  else if (!formatTypes[type]) type = \"\";\n\n  // If zero fill is specified, padding goes after sign and before digits.\n  if (zero || (fill === \"0\" && align === \"=\")) zero = true, fill = \"0\", align = \"=\";\n\n  this.fill = fill;\n  this.align = align;\n  this.sign = sign;\n  this.symbol = symbol;\n  this.zero = zero;\n  this.width = width;\n  this.comma = comma;\n  this.precision = precision;\n  this.type = type;\n}\n\nFormatSpecifier.prototype.toString = function() {\n  return this.fill\n      + this.align\n      + this.sign\n      + this.symbol\n      + (this.zero ? \"0\" : \"\")\n      + (this.width == null ? \"\" : Math.max(1, this.width | 0))\n      + (this.comma ? \",\" : \"\")\n      + (this.precision == null ? \"\" : \".\" + Math.max(0, this.precision | 0))\n      + this.type;\n};\n\nvar prefixes = [\"y\",\"z\",\"a\",\"f\",\"p\",\"n\",\"\\xB5\",\"m\",\"\",\"k\",\"M\",\"G\",\"T\",\"P\",\"E\",\"Z\",\"Y\"];\n\nfunction identity$3(x) {\n  return x;\n}\n\nvar formatLocale = function(locale) {\n  var group = locale.grouping && locale.thousands ? formatGroup(locale.grouping, locale.thousands) : identity$3,\n      currency = locale.currency,\n      decimal = locale.decimal;\n\n  function newFormat(specifier) {\n    specifier = formatSpecifier(specifier);\n\n    var fill = specifier.fill,\n        align = specifier.align,\n        sign = specifier.sign,\n        symbol = specifier.symbol,\n        zero = specifier.zero,\n        width = specifier.width,\n        comma = specifier.comma,\n        precision = specifier.precision,\n        type = specifier.type;\n\n    // Compute the prefix and suffix.\n    // For SI-prefix, the suffix is lazily computed.\n    var prefix = symbol === \"$\" ? currency[0] : symbol === \"#\" && /[boxX]/.test(type) ? \"0\" + type.toLowerCase() : \"\",\n        suffix = symbol === \"$\" ? currency[1] : /[%p]/.test(type) ? \"%\" : \"\";\n\n    // What format function should we use?\n    // Is this an integer type?\n    // Can this type generate exponential notation?\n    var formatType = formatTypes[type],\n        maybeSuffix = !type || /[defgprs%]/.test(type);\n\n    // Set the default precision if not specified,\n    // or clamp the specified precision to the supported range.\n    // For significant precision, it must be in [1, 21].\n    // For fixed precision, it must be in [0, 20].\n    precision = precision == null ? (type ? 6 : 12)\n        : /[gprs]/.test(type) ? Math.max(1, Math.min(21, precision))\n        : Math.max(0, Math.min(20, precision));\n\n    function format(value) {\n      var valuePrefix = prefix,\n          valueSuffix = suffix,\n          i, n, c;\n\n      if (type === \"c\") {\n        valueSuffix = formatType(value) + valueSuffix;\n        value = \"\";\n      } else {\n        value = +value;\n\n        // Convert negative to positive, and compute the prefix.\n        // Note that -0 is not less than 0, but 1 / -0 is!\n        var valueNegative = (value < 0 || 1 / value < 0) && (value *= -1, true);\n\n        // Perform the initial formatting.\n        value = formatType(value, precision);\n\n        // If the original value was negative, it may be rounded to zero during\n        // formatting; treat this as (positive) zero.\n        if (valueNegative) {\n          i = -1, n = value.length;\n          valueNegative = false;\n          while (++i < n) {\n            if (c = value.charCodeAt(i), (48 < c && c < 58)\n                || (type === \"x\" && 96 < c && c < 103)\n                || (type === \"X\" && 64 < c && c < 71)) {\n              valueNegative = true;\n              break;\n            }\n          }\n        }\n\n        // Compute the prefix and suffix.\n        valuePrefix = (valueNegative ? (sign === \"(\" ? sign : \"-\") : sign === \"-\" || sign === \"(\" ? \"\" : sign) + valuePrefix;\n        valueSuffix = valueSuffix + (type === \"s\" ? prefixes[8 + prefixExponent / 3] : \"\") + (valueNegative && sign === \"(\" ? \")\" : \"\");\n\n        // Break the formatted value into the integer “value” part that can be\n        // grouped, and fractional or exponential “suffix” part that is not.\n        if (maybeSuffix) {\n          i = -1, n = value.length;\n          while (++i < n) {\n            if (c = value.charCodeAt(i), 48 > c || c > 57) {\n              valueSuffix = (c === 46 ? decimal + value.slice(i + 1) : value.slice(i)) + valueSuffix;\n              value = value.slice(0, i);\n              break;\n            }\n          }\n        }\n      }\n\n      // If the fill character is not \"0\", grouping is applied before padding.\n      if (comma && !zero) value = group(value, Infinity);\n\n      // Compute the padding.\n      var length = valuePrefix.length + value.length + valueSuffix.length,\n          padding = length < width ? new Array(width - length + 1).join(fill) : \"\";\n\n      // If the fill character is \"0\", grouping is applied after padding.\n      if (comma && zero) value = group(padding + value, padding.length ? width - valueSuffix.length : Infinity), padding = \"\";\n\n      // Reconstruct the final output based on the desired alignment.\n      switch (align) {\n        case \"<\": return valuePrefix + value + valueSuffix + padding;\n        case \"=\": return valuePrefix + padding + value + valueSuffix;\n        case \"^\": return padding.slice(0, length = padding.length >> 1) + valuePrefix + value + valueSuffix + padding.slice(length);\n      }\n      return padding + valuePrefix + value + valueSuffix;\n    }\n\n    format.toString = function() {\n      return specifier + \"\";\n    };\n\n    return format;\n  }\n\n  function formatPrefix(specifier, value) {\n    var f = newFormat((specifier = formatSpecifier(specifier), specifier.type = \"f\", specifier)),\n        e = Math.max(-8, Math.min(8, Math.floor(exponent$1(value) / 3))) * 3,\n        k = Math.pow(10, -e),\n        prefix = prefixes[8 + e / 3];\n    return function(value) {\n      return f(k * value) + prefix;\n    };\n  }\n\n  return {\n    format: newFormat,\n    formatPrefix: formatPrefix\n  };\n};\n\nvar locale$1;\n\n\n\ndefaultLocale({\n  decimal: \".\",\n  thousands: \",\",\n  grouping: [3],\n  currency: [\"$\", \"\"]\n});\n\nfunction defaultLocale(definition) {\n  locale$1 = formatLocale(definition);\n  exports.format = locale$1.format;\n  exports.formatPrefix = locale$1.formatPrefix;\n  return locale$1;\n}\n\nvar precisionFixed = function(step) {\n  return Math.max(0, -exponent$1(Math.abs(step)));\n};\n\nvar precisionPrefix = function(step, value) {\n  return Math.max(0, Math.max(-8, Math.min(8, Math.floor(exponent$1(value) / 3))) * 3 - exponent$1(Math.abs(step)));\n};\n\nvar precisionRound = function(step, max) {\n  step = Math.abs(step), max = Math.abs(max) - step;\n  return Math.max(0, exponent$1(max) - exponent$1(step)) + 1;\n};\n\n// Adds floating point numbers with twice the normal precision.\n// Reference: J. R. Shewchuk, Adaptive Precision Floating-Point Arithmetic and\n// Fast Robust Geometric Predicates, Discrete & Computational Geometry 18(3)\n// 305–363 (1997).\n// Code adapted from GeographicLib by Charles F. F. Karney,\n// http://geographiclib.sourceforge.net/\n\nvar adder = function() {\n  return new Adder;\n};\n\nfunction Adder() {\n  this.reset();\n}\n\nAdder.prototype = {\n  constructor: Adder,\n  reset: function() {\n    this.s = // rounded value\n    this.t = 0; // exact error\n  },\n  add: function(y) {\n    add$1(temp, y, this.t);\n    add$1(this, temp.s, this.s);\n    if (this.s) this.t += temp.t;\n    else this.s = temp.t;\n  },\n  valueOf: function() {\n    return this.s;\n  }\n};\n\nvar temp = new Adder;\n\nfunction add$1(adder, a, b) {\n  var x = adder.s = a + b,\n      bv = x - a,\n      av = x - bv;\n  adder.t = (a - av) + (b - bv);\n}\n\nvar epsilon$2 = 1e-6;\nvar epsilon2$1 = 1e-12;\nvar pi$3 = Math.PI;\nvar halfPi$2 = pi$3 / 2;\nvar quarterPi = pi$3 / 4;\nvar tau$3 = pi$3 * 2;\n\nvar degrees$1 = 180 / pi$3;\nvar radians = pi$3 / 180;\n\nvar abs = Math.abs;\nvar atan = Math.atan;\nvar atan2 = Math.atan2;\nvar cos$1 = Math.cos;\nvar ceil = Math.ceil;\nvar exp = Math.exp;\n\nvar log = Math.log;\nvar pow = Math.pow;\nvar sin$1 = Math.sin;\nvar sign = Math.sign || function(x) { return x > 0 ? 1 : x < 0 ? -1 : 0; };\nvar sqrt = Math.sqrt;\nvar tan = Math.tan;\n\nfunction acos(x) {\n  return x > 1 ? 0 : x < -1 ? pi$3 : Math.acos(x);\n}\n\nfunction asin(x) {\n  return x > 1 ? halfPi$2 : x < -1 ? -halfPi$2 : Math.asin(x);\n}\n\nfunction haversin(x) {\n  return (x = sin$1(x / 2)) * x;\n}\n\nfunction noop$1() {}\n\nfunction streamGeometry(geometry, stream) {\n  if (geometry && streamGeometryType.hasOwnProperty(geometry.type)) {\n    streamGeometryType[geometry.type](geometry, stream);\n  }\n}\n\nvar streamObjectType = {\n  Feature: function(feature, stream) {\n    streamGeometry(feature.geometry, stream);\n  },\n  FeatureCollection: function(object, stream) {\n    var features = object.features, i = -1, n = features.length;\n    while (++i < n) streamGeometry(features[i].geometry, stream);\n  }\n};\n\nvar streamGeometryType = {\n  Sphere: function(object, stream) {\n    stream.sphere();\n  },\n  Point: function(object, stream) {\n    object = object.coordinates;\n    stream.point(object[0], object[1], object[2]);\n  },\n  MultiPoint: function(object, stream) {\n    var coordinates = object.coordinates, i = -1, n = coordinates.length;\n    while (++i < n) object = coordinates[i], stream.point(object[0], object[1], object[2]);\n  },\n  LineString: function(object, stream) {\n    streamLine(object.coordinates, stream, 0);\n  },\n  MultiLineString: function(object, stream) {\n    var coordinates = object.coordinates, i = -1, n = coordinates.length;\n    while (++i < n) streamLine(coordinates[i], stream, 0);\n  },\n  Polygon: function(object, stream) {\n    streamPolygon(object.coordinates, stream);\n  },\n  MultiPolygon: function(object, stream) {\n    var coordinates = object.coordinates, i = -1, n = coordinates.length;\n    while (++i < n) streamPolygon(coordinates[i], stream);\n  },\n  GeometryCollection: function(object, stream) {\n    var geometries = object.geometries, i = -1, n = geometries.length;\n    while (++i < n) streamGeometry(geometries[i], stream);\n  }\n};\n\nfunction streamLine(coordinates, stream, closed) {\n  var i = -1, n = coordinates.length - closed, coordinate;\n  stream.lineStart();\n  while (++i < n) coordinate = coordinates[i], stream.point(coordinate[0], coordinate[1], coordinate[2]);\n  stream.lineEnd();\n}\n\nfunction streamPolygon(coordinates, stream) {\n  var i = -1, n = coordinates.length;\n  stream.polygonStart();\n  while (++i < n) streamLine(coordinates[i], stream, 1);\n  stream.polygonEnd();\n}\n\nvar geoStream = function(object, stream) {\n  if (object && streamObjectType.hasOwnProperty(object.type)) {\n    streamObjectType[object.type](object, stream);\n  } else {\n    streamGeometry(object, stream);\n  }\n};\n\nvar areaRingSum = adder();\n\nvar areaSum = adder();\nvar lambda00;\nvar phi00;\nvar lambda0;\nvar cosPhi0;\nvar sinPhi0;\n\nvar areaStream = {\n  point: noop$1,\n  lineStart: noop$1,\n  lineEnd: noop$1,\n  polygonStart: function() {\n    areaRingSum.reset();\n    areaStream.lineStart = areaRingStart;\n    areaStream.lineEnd = areaRingEnd;\n  },\n  polygonEnd: function() {\n    var areaRing = +areaRingSum;\n    areaSum.add(areaRing < 0 ? tau$3 + areaRing : areaRing);\n    this.lineStart = this.lineEnd = this.point = noop$1;\n  },\n  sphere: function() {\n    areaSum.add(tau$3);\n  }\n};\n\nfunction areaRingStart() {\n  areaStream.point = areaPointFirst;\n}\n\nfunction areaRingEnd() {\n  areaPoint(lambda00, phi00);\n}\n\nfunction areaPointFirst(lambda, phi) {\n  areaStream.point = areaPoint;\n  lambda00 = lambda, phi00 = phi;\n  lambda *= radians, phi *= radians;\n  lambda0 = lambda, cosPhi0 = cos$1(phi = phi / 2 + quarterPi), sinPhi0 = sin$1(phi);\n}\n\nfunction areaPoint(lambda, phi) {\n  lambda *= radians, phi *= radians;\n  phi = phi / 2 + quarterPi; // half the angular distance from south pole\n\n  // Spherical excess E for a spherical triangle with vertices: south pole,\n  // previous point, current point.  Uses a formula derived from Cagnoli’s\n  // theorem.  See Todhunter, Spherical Trig. (1871), Sec. 103, Eq. (2).\n  var dLambda = lambda - lambda0,\n      sdLambda = dLambda >= 0 ? 1 : -1,\n      adLambda = sdLambda * dLambda,\n      cosPhi = cos$1(phi),\n      sinPhi = sin$1(phi),\n      k = sinPhi0 * sinPhi,\n      u = cosPhi0 * cosPhi + k * cos$1(adLambda),\n      v = k * sdLambda * sin$1(adLambda);\n  areaRingSum.add(atan2(v, u));\n\n  // Advance the previous points.\n  lambda0 = lambda, cosPhi0 = cosPhi, sinPhi0 = sinPhi;\n}\n\nvar area = function(object) {\n  areaSum.reset();\n  geoStream(object, areaStream);\n  return areaSum * 2;\n};\n\nfunction spherical(cartesian) {\n  return [atan2(cartesian[1], cartesian[0]), asin(cartesian[2])];\n}\n\nfunction cartesian(spherical) {\n  var lambda = spherical[0], phi = spherical[1], cosPhi = cos$1(phi);\n  return [cosPhi * cos$1(lambda), cosPhi * sin$1(lambda), sin$1(phi)];\n}\n\nfunction cartesianDot(a, b) {\n  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];\n}\n\nfunction cartesianCross(a, b) {\n  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];\n}\n\n// TODO return a\nfunction cartesianAddInPlace(a, b) {\n  a[0] += b[0], a[1] += b[1], a[2] += b[2];\n}\n\nfunction cartesianScale(vector, k) {\n  return [vector[0] * k, vector[1] * k, vector[2] * k];\n}\n\n// TODO return d\nfunction cartesianNormalizeInPlace(d) {\n  var l = sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);\n  d[0] /= l, d[1] /= l, d[2] /= l;\n}\n\nvar lambda0$1;\nvar phi0;\nvar lambda1;\nvar phi1;\nvar lambda2;\nvar lambda00$1;\nvar phi00$1;\nvar p0;\nvar deltaSum = adder();\nvar ranges;\nvar range;\n\nvar boundsStream = {\n  point: boundsPoint,\n  lineStart: boundsLineStart,\n  lineEnd: boundsLineEnd,\n  polygonStart: function() {\n    boundsStream.point = boundsRingPoint;\n    boundsStream.lineStart = boundsRingStart;\n    boundsStream.lineEnd = boundsRingEnd;\n    deltaSum.reset();\n    areaStream.polygonStart();\n  },\n  polygonEnd: function() {\n    areaStream.polygonEnd();\n    boundsStream.point = boundsPoint;\n    boundsStream.lineStart = boundsLineStart;\n    boundsStream.lineEnd = boundsLineEnd;\n    if (areaRingSum < 0) lambda0$1 = -(lambda1 = 180), phi0 = -(phi1 = 90);\n    else if (deltaSum > epsilon$2) phi1 = 90;\n    else if (deltaSum < -epsilon$2) phi0 = -90;\n    range[0] = lambda0$1, range[1] = lambda1;\n  }\n};\n\nfunction boundsPoint(lambda, phi) {\n  ranges.push(range = [lambda0$1 = lambda, lambda1 = lambda]);\n  if (phi < phi0) phi0 = phi;\n  if (phi > phi1) phi1 = phi;\n}\n\nfunction linePoint(lambda, phi) {\n  var p = cartesian([lambda * radians, phi * radians]);\n  if (p0) {\n    var normal = cartesianCross(p0, p),\n        equatorial = [normal[1], -normal[0], 0],\n        inflection = cartesianCross(equatorial, normal);\n    cartesianNormalizeInPlace(inflection);\n    inflection = spherical(inflection);\n    var delta = lambda - lambda2,\n        sign$$1 = delta > 0 ? 1 : -1,\n        lambdai = inflection[0] * degrees$1 * sign$$1,\n        phii,\n        antimeridian = abs(delta) > 180;\n    if (antimeridian ^ (sign$$1 * lambda2 < lambdai && lambdai < sign$$1 * lambda)) {\n      phii = inflection[1] * degrees$1;\n      if (phii > phi1) phi1 = phii;\n    } else if (lambdai = (lambdai + 360) % 360 - 180, antimeridian ^ (sign$$1 * lambda2 < lambdai && lambdai < sign$$1 * lambda)) {\n      phii = -inflection[1] * degrees$1;\n      if (phii < phi0) phi0 = phii;\n    } else {\n      if (phi < phi0) phi0 = phi;\n      if (phi > phi1) phi1 = phi;\n    }\n    if (antimeridian) {\n      if (lambda < lambda2) {\n        if (angle(lambda0$1, lambda) > angle(lambda0$1, lambda1)) lambda1 = lambda;\n      } else {\n        if (angle(lambda, lambda1) > angle(lambda0$1, lambda1)) lambda0$1 = lambda;\n      }\n    } else {\n      if (lambda1 >= lambda0$1) {\n        if (lambda < lambda0$1) lambda0$1 = lambda;\n        if (lambda > lambda1) lambda1 = lambda;\n      } else {\n        if (lambda > lambda2) {\n          if (angle(lambda0$1, lambda) > angle(lambda0$1, lambda1)) lambda1 = lambda;\n        } else {\n          if (angle(lambda, lambda1) > angle(lambda0$1, lambda1)) lambda0$1 = lambda;\n        }\n      }\n    }\n  } else {\n    ranges.push(range = [lambda0$1 = lambda, lambda1 = lambda]);\n  }\n  if (phi < phi0) phi0 = phi;\n  if (phi > phi1) phi1 = phi;\n  p0 = p, lambda2 = lambda;\n}\n\nfunction boundsLineStart() {\n  boundsStream.point = linePoint;\n}\n\nfunction boundsLineEnd() {\n  range[0] = lambda0$1, range[1] = lambda1;\n  boundsStream.point = boundsPoint;\n  p0 = null;\n}\n\nfunction boundsRingPoint(lambda, phi) {\n  if (p0) {\n    var delta = lambda - lambda2;\n    deltaSum.add(abs(delta) > 180 ? delta + (delta > 0 ? 360 : -360) : delta);\n  } else {\n    lambda00$1 = lambda, phi00$1 = phi;\n  }\n  areaStream.point(lambda, phi);\n  linePoint(lambda, phi);\n}\n\nfunction boundsRingStart() {\n  areaStream.lineStart();\n}\n\nfunction boundsRingEnd() {\n  boundsRingPoint(lambda00$1, phi00$1);\n  areaStream.lineEnd();\n  if (abs(deltaSum) > epsilon$2) lambda0$1 = -(lambda1 = 180);\n  range[0] = lambda0$1, range[1] = lambda1;\n  p0 = null;\n}\n\n// Finds the left-right distance between two longitudes.\n// This is almost the same as (lambda1 - lambda0 + 360°) % 360°, except that we want\n// the distance between ±180° to be 360°.\nfunction angle(lambda0, lambda1) {\n  return (lambda1 -= lambda0) < 0 ? lambda1 + 360 : lambda1;\n}\n\nfunction rangeCompare(a, b) {\n  return a[0] - b[0];\n}\n\nfunction rangeContains(range, x) {\n  return range[0] <= range[1] ? range[0] <= x && x <= range[1] : x < range[0] || range[1] < x;\n}\n\nvar bounds = function(feature) {\n  var i, n, a, b, merged, deltaMax, delta;\n\n  phi1 = lambda1 = -(lambda0$1 = phi0 = Infinity);\n  ranges = [];\n  geoStream(feature, boundsStream);\n\n  // First, sort ranges by their minimum longitudes.\n  if (n = ranges.length) {\n    ranges.sort(rangeCompare);\n\n    // Then, merge any ranges that overlap.\n    for (i = 1, a = ranges[0], merged = [a]; i < n; ++i) {\n      b = ranges[i];\n      if (rangeContains(a, b[0]) || rangeContains(a, b[1])) {\n        if (angle(a[0], b[1]) > angle(a[0], a[1])) a[1] = b[1];\n        if (angle(b[0], a[1]) > angle(a[0], a[1])) a[0] = b[0];\n      } else {\n        merged.push(a = b);\n      }\n    }\n\n    // Finally, find the largest gap between the merged ranges.\n    // The final bounding box will be the inverse of this gap.\n    for (deltaMax = -Infinity, n = merged.length - 1, i = 0, a = merged[n]; i <= n; a = b, ++i) {\n      b = merged[i];\n      if ((delta = angle(a[1], b[0])) > deltaMax) deltaMax = delta, lambda0$1 = b[0], lambda1 = a[1];\n    }\n  }\n\n  ranges = range = null;\n\n  return lambda0$1 === Infinity || phi0 === Infinity\n      ? [[NaN, NaN], [NaN, NaN]]\n      : [[lambda0$1, phi0], [lambda1, phi1]];\n};\n\nvar W0;\nvar W1;\nvar X0;\nvar Y0;\nvar Z0;\nvar X1;\nvar Y1;\nvar Z1;\nvar X2;\nvar Y2;\nvar Z2;\nvar lambda00$2;\nvar phi00$2;\nvar x0;\nvar y0;\nvar z0; // previous point\n\nvar centroidStream = {\n  sphere: noop$1,\n  point: centroidPoint,\n  lineStart: centroidLineStart,\n  lineEnd: centroidLineEnd,\n  polygonStart: function() {\n    centroidStream.lineStart = centroidRingStart;\n    centroidStream.lineEnd = centroidRingEnd;\n  },\n  polygonEnd: function() {\n    centroidStream.lineStart = centroidLineStart;\n    centroidStream.lineEnd = centroidLineEnd;\n  }\n};\n\n// Arithmetic mean of Cartesian vectors.\nfunction centroidPoint(lambda, phi) {\n  lambda *= radians, phi *= radians;\n  var cosPhi = cos$1(phi);\n  centroidPointCartesian(cosPhi * cos$1(lambda), cosPhi * sin$1(lambda), sin$1(phi));\n}\n\nfunction centroidPointCartesian(x, y, z) {\n  ++W0;\n  X0 += (x - X0) / W0;\n  Y0 += (y - Y0) / W0;\n  Z0 += (z - Z0) / W0;\n}\n\nfunction centroidLineStart() {\n  centroidStream.point = centroidLinePointFirst;\n}\n\nfunction centroidLinePointFirst(lambda, phi) {\n  lambda *= radians, phi *= radians;\n  var cosPhi = cos$1(phi);\n  x0 = cosPhi * cos$1(lambda);\n  y0 = cosPhi * sin$1(lambda);\n  z0 = sin$1(phi);\n  centroidStream.point = centroidLinePoint;\n  centroidPointCartesian(x0, y0, z0);\n}\n\nfunction centroidLinePoint(lambda, phi) {\n  lambda *= radians, phi *= radians;\n  var cosPhi = cos$1(phi),\n      x = cosPhi * cos$1(lambda),\n      y = cosPhi * sin$1(lambda),\n      z = sin$1(phi),\n      w = atan2(sqrt((w = y0 * z - z0 * y) * w + (w = z0 * x - x0 * z) * w + (w = x0 * y - y0 * x) * w), x0 * x + y0 * y + z0 * z);\n  W1 += w;\n  X1 += w * (x0 + (x0 = x));\n  Y1 += w * (y0 + (y0 = y));\n  Z1 += w * (z0 + (z0 = z));\n  centroidPointCartesian(x0, y0, z0);\n}\n\nfunction centroidLineEnd() {\n  centroidStream.point = centroidPoint;\n}\n\n// See J. E. Brock, The Inertia Tensor for a Spherical Triangle,\n// J. Applied Mechanics 42, 239 (1975).\nfunction centroidRingStart() {\n  centroidStream.point = centroidRingPointFirst;\n}\n\nfunction centroidRingEnd() {\n  centroidRingPoint(lambda00$2, phi00$2);\n  centroidStream.point = centroidPoint;\n}\n\nfunction centroidRingPointFirst(lambda, phi) {\n  lambda00$2 = lambda, phi00$2 = phi;\n  lambda *= radians, phi *= radians;\n  centroidStream.point = centroidRingPoint;\n  var cosPhi = cos$1(phi);\n  x0 = cosPhi * cos$1(lambda);\n  y0 = cosPhi * sin$1(lambda);\n  z0 = sin$1(phi);\n  centroidPointCartesian(x0, y0, z0);\n}\n\nfunction centroidRingPoint(lambda, phi) {\n  lambda *= radians, phi *= radians;\n  var cosPhi = cos$1(phi),\n      x = cosPhi * cos$1(lambda),\n      y = cosPhi * sin$1(lambda),\n      z = sin$1(phi),\n      cx = y0 * z - z0 * y,\n      cy = z0 * x - x0 * z,\n      cz = x0 * y - y0 * x,\n      m = sqrt(cx * cx + cy * cy + cz * cz),\n      u = x0 * x + y0 * y + z0 * z,\n      v = m && -asin(m) / m, // area weight\n      w = atan2(m, u); // line weight\n  X2 += v * cx;\n  Y2 += v * cy;\n  Z2 += v * cz;\n  W1 += w;\n  X1 += w * (x0 + (x0 = x));\n  Y1 += w * (y0 + (y0 = y));\n  Z1 += w * (z0 + (z0 = z));\n  centroidPointCartesian(x0, y0, z0);\n}\n\nvar centroid = function(object) {\n  W0 = W1 =\n  X0 = Y0 = Z0 =\n  X1 = Y1 = Z1 =\n  X2 = Y2 = Z2 = 0;\n  geoStream(object, centroidStream);\n\n  var x = X2,\n      y = Y2,\n      z = Z2,\n      m = x * x + y * y + z * z;\n\n  // If the area-weighted ccentroid is undefined, fall back to length-weighted ccentroid.\n  if (m < epsilon2$1) {\n    x = X1, y = Y1, z = Z1;\n    // If the feature has zero length, fall back to arithmetic mean of point vectors.\n    if (W1 < epsilon$2) x = X0, y = Y0, z = Z0;\n    m = x * x + y * y + z * z;\n    // If the feature still has an undefined ccentroid, then return.\n    if (m < epsilon2$1) return [NaN, NaN];\n  }\n\n  return [atan2(y, x) * degrees$1, asin(z / sqrt(m)) * degrees$1];\n};\n\nvar constant$7 = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nvar compose = function(a, b) {\n\n  function compose(x, y) {\n    return x = a(x, y), b(x[0], x[1]);\n  }\n\n  if (a.invert && b.invert) compose.invert = function(x, y) {\n    return x = b.invert(x, y), x && a.invert(x[0], x[1]);\n  };\n\n  return compose;\n};\n\nfunction rotationIdentity(lambda, phi) {\n  return [lambda > pi$3 ? lambda - tau$3 : lambda < -pi$3 ? lambda + tau$3 : lambda, phi];\n}\n\nrotationIdentity.invert = rotationIdentity;\n\nfunction rotateRadians(deltaLambda, deltaPhi, deltaGamma) {\n  return (deltaLambda %= tau$3) ? (deltaPhi || deltaGamma ? compose(rotationLambda(deltaLambda), rotationPhiGamma(deltaPhi, deltaGamma))\n    : rotationLambda(deltaLambda))\n    : (deltaPhi || deltaGamma ? rotationPhiGamma(deltaPhi, deltaGamma)\n    : rotationIdentity);\n}\n\nfunction forwardRotationLambda(deltaLambda) {\n  return function(lambda, phi) {\n    return lambda += deltaLambda, [lambda > pi$3 ? lambda - tau$3 : lambda < -pi$3 ? lambda + tau$3 : lambda, phi];\n  };\n}\n\nfunction rotationLambda(deltaLambda) {\n  var rotation = forwardRotationLambda(deltaLambda);\n  rotation.invert = forwardRotationLambda(-deltaLambda);\n  return rotation;\n}\n\nfunction rotationPhiGamma(deltaPhi, deltaGamma) {\n  var cosDeltaPhi = cos$1(deltaPhi),\n      sinDeltaPhi = sin$1(deltaPhi),\n      cosDeltaGamma = cos$1(deltaGamma),\n      sinDeltaGamma = sin$1(deltaGamma);\n\n  function rotation(lambda, phi) {\n    var cosPhi = cos$1(phi),\n        x = cos$1(lambda) * cosPhi,\n        y = sin$1(lambda) * cosPhi,\n        z = sin$1(phi),\n        k = z * cosDeltaPhi + x * sinDeltaPhi;\n    return [\n      atan2(y * cosDeltaGamma - k * sinDeltaGamma, x * cosDeltaPhi - z * sinDeltaPhi),\n      asin(k * cosDeltaGamma + y * sinDeltaGamma)\n    ];\n  }\n\n  rotation.invert = function(lambda, phi) {\n    var cosPhi = cos$1(phi),\n        x = cos$1(lambda) * cosPhi,\n        y = sin$1(lambda) * cosPhi,\n        z = sin$1(phi),\n        k = z * cosDeltaGamma - y * sinDeltaGamma;\n    return [\n      atan2(y * cosDeltaGamma + z * sinDeltaGamma, x * cosDeltaPhi + k * sinDeltaPhi),\n      asin(k * cosDeltaPhi - x * sinDeltaPhi)\n    ];\n  };\n\n  return rotation;\n}\n\nvar rotation = function(rotate) {\n  rotate = rotateRadians(rotate[0] * radians, rotate[1] * radians, rotate.length > 2 ? rotate[2] * radians : 0);\n\n  function forward(coordinates) {\n    coordinates = rotate(coordinates[0] * radians, coordinates[1] * radians);\n    return coordinates[0] *= degrees$1, coordinates[1] *= degrees$1, coordinates;\n  }\n\n  forward.invert = function(coordinates) {\n    coordinates = rotate.invert(coordinates[0] * radians, coordinates[1] * radians);\n    return coordinates[0] *= degrees$1, coordinates[1] *= degrees$1, coordinates;\n  };\n\n  return forward;\n};\n\n// Generates a circle centered at [0°, 0°], with a given radius and precision.\nfunction circleStream(stream, radius, delta, direction, t0, t1) {\n  if (!delta) return;\n  var cosRadius = cos$1(radius),\n      sinRadius = sin$1(radius),\n      step = direction * delta;\n  if (t0 == null) {\n    t0 = radius + direction * tau$3;\n    t1 = radius - step / 2;\n  } else {\n    t0 = circleRadius(cosRadius, t0);\n    t1 = circleRadius(cosRadius, t1);\n    if (direction > 0 ? t0 < t1 : t0 > t1) t0 += direction * tau$3;\n  }\n  for (var point, t = t0; direction > 0 ? t > t1 : t < t1; t -= step) {\n    point = spherical([cosRadius, -sinRadius * cos$1(t), -sinRadius * sin$1(t)]);\n    stream.point(point[0], point[1]);\n  }\n}\n\n// Returns the signed angle of a cartesian point relative to [cosRadius, 0, 0].\nfunction circleRadius(cosRadius, point) {\n  point = cartesian(point), point[0] -= cosRadius;\n  cartesianNormalizeInPlace(point);\n  var radius = acos(-point[1]);\n  return ((-point[2] < 0 ? -radius : radius) + tau$3 - epsilon$2) % tau$3;\n}\n\nvar circle = function() {\n  var center = constant$7([0, 0]),\n      radius = constant$7(90),\n      precision = constant$7(6),\n      ring,\n      rotate,\n      stream = {point: point};\n\n  function point(x, y) {\n    ring.push(x = rotate(x, y));\n    x[0] *= degrees$1, x[1] *= degrees$1;\n  }\n\n  function circle() {\n    var c = center.apply(this, arguments),\n        r = radius.apply(this, arguments) * radians,\n        p = precision.apply(this, arguments) * radians;\n    ring = [];\n    rotate = rotateRadians(-c[0] * radians, -c[1] * radians, 0).invert;\n    circleStream(stream, r, p, 1);\n    c = {type: \"Polygon\", coordinates: [ring]};\n    ring = rotate = null;\n    return c;\n  }\n\n  circle.center = function(_) {\n    return arguments.length ? (center = typeof _ === \"function\" ? _ : constant$7([+_[0], +_[1]]), circle) : center;\n  };\n\n  circle.radius = function(_) {\n    return arguments.length ? (radius = typeof _ === \"function\" ? _ : constant$7(+_), circle) : radius;\n  };\n\n  circle.precision = function(_) {\n    return arguments.length ? (precision = typeof _ === \"function\" ? _ : constant$7(+_), circle) : precision;\n  };\n\n  return circle;\n};\n\nvar clipBuffer = function() {\n  var lines = [],\n      line;\n  return {\n    point: function(x, y) {\n      line.push([x, y]);\n    },\n    lineStart: function() {\n      lines.push(line = []);\n    },\n    lineEnd: noop$1,\n    rejoin: function() {\n      if (lines.length > 1) lines.push(lines.pop().concat(lines.shift()));\n    },\n    result: function() {\n      var result = lines;\n      lines = [];\n      line = null;\n      return result;\n    }\n  };\n};\n\nvar clipLine = function(a, b, x0, y0, x1, y1) {\n  var ax = a[0],\n      ay = a[1],\n      bx = b[0],\n      by = b[1],\n      t0 = 0,\n      t1 = 1,\n      dx = bx - ax,\n      dy = by - ay,\n      r;\n\n  r = x0 - ax;\n  if (!dx && r > 0) return;\n  r /= dx;\n  if (dx < 0) {\n    if (r < t0) return;\n    if (r < t1) t1 = r;\n  } else if (dx > 0) {\n    if (r > t1) return;\n    if (r > t0) t0 = r;\n  }\n\n  r = x1 - ax;\n  if (!dx && r < 0) return;\n  r /= dx;\n  if (dx < 0) {\n    if (r > t1) return;\n    if (r > t0) t0 = r;\n  } else if (dx > 0) {\n    if (r < t0) return;\n    if (r < t1) t1 = r;\n  }\n\n  r = y0 - ay;\n  if (!dy && r > 0) return;\n  r /= dy;\n  if (dy < 0) {\n    if (r < t0) return;\n    if (r < t1) t1 = r;\n  } else if (dy > 0) {\n    if (r > t1) return;\n    if (r > t0) t0 = r;\n  }\n\n  r = y1 - ay;\n  if (!dy && r < 0) return;\n  r /= dy;\n  if (dy < 0) {\n    if (r > t1) return;\n    if (r > t0) t0 = r;\n  } else if (dy > 0) {\n    if (r < t0) return;\n    if (r < t1) t1 = r;\n  }\n\n  if (t0 > 0) a[0] = ax + t0 * dx, a[1] = ay + t0 * dy;\n  if (t1 < 1) b[0] = ax + t1 * dx, b[1] = ay + t1 * dy;\n  return true;\n};\n\nvar pointEqual = function(a, b) {\n  return abs(a[0] - b[0]) < epsilon$2 && abs(a[1] - b[1]) < epsilon$2;\n};\n\nfunction Intersection(point, points, other, entry) {\n  this.x = point;\n  this.z = points;\n  this.o = other; // another intersection\n  this.e = entry; // is an entry?\n  this.v = false; // visited\n  this.n = this.p = null; // next & previous\n}\n\n// A generalized polygon clipping algorithm: given a polygon that has been cut\n// into its visible line segments, and rejoins the segments by interpolating\n// along the clip edge.\nvar clipPolygon = function(segments, compareIntersection, startInside, interpolate, stream) {\n  var subject = [],\n      clip = [],\n      i,\n      n;\n\n  segments.forEach(function(segment) {\n    if ((n = segment.length - 1) <= 0) return;\n    var n, p0 = segment[0], p1 = segment[n], x;\n\n    // If the first and last points of a segment are coincident, then treat as a\n    // closed ring. TODO if all rings are closed, then the winding order of the\n    // exterior ring should be checked.\n    if (pointEqual(p0, p1)) {\n      stream.lineStart();\n      for (i = 0; i < n; ++i) stream.point((p0 = segment[i])[0], p0[1]);\n      stream.lineEnd();\n      return;\n    }\n\n    subject.push(x = new Intersection(p0, segment, null, true));\n    clip.push(x.o = new Intersection(p0, null, x, false));\n    subject.push(x = new Intersection(p1, segment, null, false));\n    clip.push(x.o = new Intersection(p1, null, x, true));\n  });\n\n  if (!subject.length) return;\n\n  clip.sort(compareIntersection);\n  link$1(subject);\n  link$1(clip);\n\n  for (i = 0, n = clip.length; i < n; ++i) {\n    clip[i].e = startInside = !startInside;\n  }\n\n  var start = subject[0],\n      points,\n      point;\n\n  while (1) {\n    // Find first unvisited intersection.\n    var current = start,\n        isSubject = true;\n    while (current.v) if ((current = current.n) === start) return;\n    points = current.z;\n    stream.lineStart();\n    do {\n      current.v = current.o.v = true;\n      if (current.e) {\n        if (isSubject) {\n          for (i = 0, n = points.length; i < n; ++i) stream.point((point = points[i])[0], point[1]);\n        } else {\n          interpolate(current.x, current.n.x, 1, stream);\n        }\n        current = current.n;\n      } else {\n        if (isSubject) {\n          points = current.p.z;\n          for (i = points.length - 1; i >= 0; --i) stream.point((point = points[i])[0], point[1]);\n        } else {\n          interpolate(current.x, current.p.x, -1, stream);\n        }\n        current = current.p;\n      }\n      current = current.o;\n      points = current.z;\n      isSubject = !isSubject;\n    } while (!current.v);\n    stream.lineEnd();\n  }\n};\n\nfunction link$1(array) {\n  if (!(n = array.length)) return;\n  var n,\n      i = 0,\n      a = array[0],\n      b;\n  while (++i < n) {\n    a.n = b = array[i];\n    b.p = a;\n    a = b;\n  }\n  a.n = b = array[0];\n  b.p = a;\n}\n\nvar clipMax = 1e9;\nvar clipMin = -clipMax;\n\n// TODO Use d3-polygon’s polygonContains here for the ring check?\n// TODO Eliminate duplicate buffering in clipBuffer and polygon.push?\n\nfunction clipExtent(x0, y0, x1, y1) {\n\n  function visible(x, y) {\n    return x0 <= x && x <= x1 && y0 <= y && y <= y1;\n  }\n\n  function interpolate(from, to, direction, stream) {\n    var a = 0, a1 = 0;\n    if (from == null\n        || (a = corner(from, direction)) !== (a1 = corner(to, direction))\n        || comparePoint(from, to) < 0 ^ direction > 0) {\n      do stream.point(a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0);\n      while ((a = (a + direction + 4) % 4) !== a1);\n    } else {\n      stream.point(to[0], to[1]);\n    }\n  }\n\n  function corner(p, direction) {\n    return abs(p[0] - x0) < epsilon$2 ? direction > 0 ? 0 : 3\n        : abs(p[0] - x1) < epsilon$2 ? direction > 0 ? 2 : 1\n        : abs(p[1] - y0) < epsilon$2 ? direction > 0 ? 1 : 0\n        : direction > 0 ? 3 : 2; // abs(p[1] - y1) < epsilon\n  }\n\n  function compareIntersection(a, b) {\n    return comparePoint(a.x, b.x);\n  }\n\n  function comparePoint(a, b) {\n    var ca = corner(a, 1),\n        cb = corner(b, 1);\n    return ca !== cb ? ca - cb\n        : ca === 0 ? b[1] - a[1]\n        : ca === 1 ? a[0] - b[0]\n        : ca === 2 ? a[1] - b[1]\n        : b[0] - a[0];\n  }\n\n  return function(stream) {\n    var activeStream = stream,\n        bufferStream = clipBuffer(),\n        segments,\n        polygon,\n        ring,\n        x__, y__, v__, // first point\n        x_, y_, v_, // previous point\n        first,\n        clean;\n\n    var clipStream = {\n      point: point,\n      lineStart: lineStart,\n      lineEnd: lineEnd,\n      polygonStart: polygonStart,\n      polygonEnd: polygonEnd\n    };\n\n    function point(x, y) {\n      if (visible(x, y)) activeStream.point(x, y);\n    }\n\n    function polygonInside() {\n      var winding = 0;\n\n      for (var i = 0, n = polygon.length; i < n; ++i) {\n        for (var ring = polygon[i], j = 1, m = ring.length, point = ring[0], a0, a1, b0 = point[0], b1 = point[1]; j < m; ++j) {\n          a0 = b0, a1 = b1, point = ring[j], b0 = point[0], b1 = point[1];\n          if (a1 <= y1) { if (b1 > y1 && (b0 - a0) * (y1 - a1) > (b1 - a1) * (x0 - a0)) ++winding; }\n          else { if (b1 <= y1 && (b0 - a0) * (y1 - a1) < (b1 - a1) * (x0 - a0)) --winding; }\n        }\n      }\n\n      return winding;\n    }\n\n    // Buffer geometry within a polygon and then clip it en masse.\n    function polygonStart() {\n      activeStream = bufferStream, segments = [], polygon = [], clean = true;\n    }\n\n    function polygonEnd() {\n      var startInside = polygonInside(),\n          cleanInside = clean && startInside,\n          visible = (segments = merge(segments)).length;\n      if (cleanInside || visible) {\n        stream.polygonStart();\n        if (cleanInside) {\n          stream.lineStart();\n          interpolate(null, null, 1, stream);\n          stream.lineEnd();\n        }\n        if (visible) {\n          clipPolygon(segments, compareIntersection, startInside, interpolate, stream);\n        }\n        stream.polygonEnd();\n      }\n      activeStream = stream, segments = polygon = ring = null;\n    }\n\n    function lineStart() {\n      clipStream.point = linePoint;\n      if (polygon) polygon.push(ring = []);\n      first = true;\n      v_ = false;\n      x_ = y_ = NaN;\n    }\n\n    // TODO rather than special-case polygons, simply handle them separately.\n    // Ideally, coincident intersection points should be jittered to avoid\n    // clipping issues.\n    function lineEnd() {\n      if (segments) {\n        linePoint(x__, y__);\n        if (v__ && v_) bufferStream.rejoin();\n        segments.push(bufferStream.result());\n      }\n      clipStream.point = point;\n      if (v_) activeStream.lineEnd();\n    }\n\n    function linePoint(x, y) {\n      var v = visible(x, y);\n      if (polygon) ring.push([x, y]);\n      if (first) {\n        x__ = x, y__ = y, v__ = v;\n        first = false;\n        if (v) {\n          activeStream.lineStart();\n          activeStream.point(x, y);\n        }\n      } else {\n        if (v && v_) activeStream.point(x, y);\n        else {\n          var a = [x_ = Math.max(clipMin, Math.min(clipMax, x_)), y_ = Math.max(clipMin, Math.min(clipMax, y_))],\n              b = [x = Math.max(clipMin, Math.min(clipMax, x)), y = Math.max(clipMin, Math.min(clipMax, y))];\n          if (clipLine(a, b, x0, y0, x1, y1)) {\n            if (!v_) {\n              activeStream.lineStart();\n              activeStream.point(a[0], a[1]);\n            }\n            activeStream.point(b[0], b[1]);\n            if (!v) activeStream.lineEnd();\n            clean = false;\n          } else if (v) {\n            activeStream.lineStart();\n            activeStream.point(x, y);\n            clean = false;\n          }\n        }\n      }\n      x_ = x, y_ = y, v_ = v;\n    }\n\n    return clipStream;\n  };\n}\n\nvar extent$1 = function() {\n  var x0 = 0,\n      y0 = 0,\n      x1 = 960,\n      y1 = 500,\n      cache,\n      cacheStream,\n      clip;\n\n  return clip = {\n    stream: function(stream) {\n      return cache && cacheStream === stream ? cache : cache = clipExtent(x0, y0, x1, y1)(cacheStream = stream);\n    },\n    extent: function(_) {\n      return arguments.length ? (x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1], cache = cacheStream = null, clip) : [[x0, y0], [x1, y1]];\n    }\n  };\n};\n\nvar lengthSum = adder();\nvar lambda0$2;\nvar sinPhi0$1;\nvar cosPhi0$1;\n\nvar lengthStream = {\n  sphere: noop$1,\n  point: noop$1,\n  lineStart: lengthLineStart,\n  lineEnd: noop$1,\n  polygonStart: noop$1,\n  polygonEnd: noop$1\n};\n\nfunction lengthLineStart() {\n  lengthStream.point = lengthPointFirst;\n  lengthStream.lineEnd = lengthLineEnd;\n}\n\nfunction lengthLineEnd() {\n  lengthStream.point = lengthStream.lineEnd = noop$1;\n}\n\nfunction lengthPointFirst(lambda, phi) {\n  lambda *= radians, phi *= radians;\n  lambda0$2 = lambda, sinPhi0$1 = sin$1(phi), cosPhi0$1 = cos$1(phi);\n  lengthStream.point = lengthPoint;\n}\n\nfunction lengthPoint(lambda, phi) {\n  lambda *= radians, phi *= radians;\n  var sinPhi = sin$1(phi),\n      cosPhi = cos$1(phi),\n      delta = abs(lambda - lambda0$2),\n      cosDelta = cos$1(delta),\n      sinDelta = sin$1(delta),\n      x = cosPhi * sinDelta,\n      y = cosPhi0$1 * sinPhi - sinPhi0$1 * cosPhi * cosDelta,\n      z = sinPhi0$1 * sinPhi + cosPhi0$1 * cosPhi * cosDelta;\n  lengthSum.add(atan2(sqrt(x * x + y * y), z));\n  lambda0$2 = lambda, sinPhi0$1 = sinPhi, cosPhi0$1 = cosPhi;\n}\n\nvar length$1 = function(object) {\n  lengthSum.reset();\n  geoStream(object, lengthStream);\n  return +lengthSum;\n};\n\nvar coordinates = [null, null];\nvar object$1 = {type: \"LineString\", coordinates: coordinates};\n\nvar distance = function(a, b) {\n  coordinates[0] = a;\n  coordinates[1] = b;\n  return length$1(object$1);\n};\n\nfunction graticuleX(y0, y1, dy) {\n  var y = sequence(y0, y1 - epsilon$2, dy).concat(y1);\n  return function(x) { return y.map(function(y) { return [x, y]; }); };\n}\n\nfunction graticuleY(x0, x1, dx) {\n  var x = sequence(x0, x1 - epsilon$2, dx).concat(x1);\n  return function(y) { return x.map(function(x) { return [x, y]; }); };\n}\n\nfunction graticule() {\n  var x1, x0, X1, X0,\n      y1, y0, Y1, Y0,\n      dx = 10, dy = dx, DX = 90, DY = 360,\n      x, y, X, Y,\n      precision = 2.5;\n\n  function graticule() {\n    return {type: \"MultiLineString\", coordinates: lines()};\n  }\n\n  function lines() {\n    return sequence(ceil(X0 / DX) * DX, X1, DX).map(X)\n        .concat(sequence(ceil(Y0 / DY) * DY, Y1, DY).map(Y))\n        .concat(sequence(ceil(x0 / dx) * dx, x1, dx).filter(function(x) { return abs(x % DX) > epsilon$2; }).map(x))\n        .concat(sequence(ceil(y0 / dy) * dy, y1, dy).filter(function(y) { return abs(y % DY) > epsilon$2; }).map(y));\n  }\n\n  graticule.lines = function() {\n    return lines().map(function(coordinates) { return {type: \"LineString\", coordinates: coordinates}; });\n  };\n\n  graticule.outline = function() {\n    return {\n      type: \"Polygon\",\n      coordinates: [\n        X(X0).concat(\n        Y(Y1).slice(1),\n        X(X1).reverse().slice(1),\n        Y(Y0).reverse().slice(1))\n      ]\n    };\n  };\n\n  graticule.extent = function(_) {\n    if (!arguments.length) return graticule.extentMinor();\n    return graticule.extentMajor(_).extentMinor(_);\n  };\n\n  graticule.extentMajor = function(_) {\n    if (!arguments.length) return [[X0, Y0], [X1, Y1]];\n    X0 = +_[0][0], X1 = +_[1][0];\n    Y0 = +_[0][1], Y1 = +_[1][1];\n    if (X0 > X1) _ = X0, X0 = X1, X1 = _;\n    if (Y0 > Y1) _ = Y0, Y0 = Y1, Y1 = _;\n    return graticule.precision(precision);\n  };\n\n  graticule.extentMinor = function(_) {\n    if (!arguments.length) return [[x0, y0], [x1, y1]];\n    x0 = +_[0][0], x1 = +_[1][0];\n    y0 = +_[0][1], y1 = +_[1][1];\n    if (x0 > x1) _ = x0, x0 = x1, x1 = _;\n    if (y0 > y1) _ = y0, y0 = y1, y1 = _;\n    return graticule.precision(precision);\n  };\n\n  graticule.step = function(_) {\n    if (!arguments.length) return graticule.stepMinor();\n    return graticule.stepMajor(_).stepMinor(_);\n  };\n\n  graticule.stepMajor = function(_) {\n    if (!arguments.length) return [DX, DY];\n    DX = +_[0], DY = +_[1];\n    return graticule;\n  };\n\n  graticule.stepMinor = function(_) {\n    if (!arguments.length) return [dx, dy];\n    dx = +_[0], dy = +_[1];\n    return graticule;\n  };\n\n  graticule.precision = function(_) {\n    if (!arguments.length) return precision;\n    precision = +_;\n    x = graticuleX(y0, y1, 90);\n    y = graticuleY(x0, x1, precision);\n    X = graticuleX(Y0, Y1, 90);\n    Y = graticuleY(X0, X1, precision);\n    return graticule;\n  };\n\n  return graticule\n      .extentMajor([[-180, -90 + epsilon$2], [180, 90 - epsilon$2]])\n      .extentMinor([[-180, -80 - epsilon$2], [180, 80 + epsilon$2]]);\n}\n\nfunction graticule10() {\n  return graticule()();\n}\n\nvar interpolate$1 = function(a, b) {\n  var x0 = a[0] * radians,\n      y0 = a[1] * radians,\n      x1 = b[0] * radians,\n      y1 = b[1] * radians,\n      cy0 = cos$1(y0),\n      sy0 = sin$1(y0),\n      cy1 = cos$1(y1),\n      sy1 = sin$1(y1),\n      kx0 = cy0 * cos$1(x0),\n      ky0 = cy0 * sin$1(x0),\n      kx1 = cy1 * cos$1(x1),\n      ky1 = cy1 * sin$1(x1),\n      d = 2 * asin(sqrt(haversin(y1 - y0) + cy0 * cy1 * haversin(x1 - x0))),\n      k = sin$1(d);\n\n  var interpolate = d ? function(t) {\n    var B = sin$1(t *= d) / k,\n        A = sin$1(d - t) / k,\n        x = A * kx0 + B * kx1,\n        y = A * ky0 + B * ky1,\n        z = A * sy0 + B * sy1;\n    return [\n      atan2(y, x) * degrees$1,\n      atan2(z, sqrt(x * x + y * y)) * degrees$1\n    ];\n  } : function() {\n    return [x0 * degrees$1, y0 * degrees$1];\n  };\n\n  interpolate.distance = d;\n\n  return interpolate;\n};\n\nvar identity$4 = function(x) {\n  return x;\n};\n\nvar areaSum$1 = adder();\nvar areaRingSum$1 = adder();\nvar x00;\nvar y00;\nvar x0$1;\nvar y0$1;\n\nvar areaStream$1 = {\n  point: noop$1,\n  lineStart: noop$1,\n  lineEnd: noop$1,\n  polygonStart: function() {\n    areaStream$1.lineStart = areaRingStart$1;\n    areaStream$1.lineEnd = areaRingEnd$1;\n  },\n  polygonEnd: function() {\n    areaStream$1.lineStart = areaStream$1.lineEnd = areaStream$1.point = noop$1;\n    areaSum$1.add(abs(areaRingSum$1));\n    areaRingSum$1.reset();\n  },\n  result: function() {\n    var area = areaSum$1 / 2;\n    areaSum$1.reset();\n    return area;\n  }\n};\n\nfunction areaRingStart$1() {\n  areaStream$1.point = areaPointFirst$1;\n}\n\nfunction areaPointFirst$1(x, y) {\n  areaStream$1.point = areaPoint$1;\n  x00 = x0$1 = x, y00 = y0$1 = y;\n}\n\nfunction areaPoint$1(x, y) {\n  areaRingSum$1.add(y0$1 * x - x0$1 * y);\n  x0$1 = x, y0$1 = y;\n}\n\nfunction areaRingEnd$1() {\n  areaPoint$1(x00, y00);\n}\n\nvar x0$2 = Infinity;\nvar y0$2 = x0$2;\nvar x1 = -x0$2;\nvar y1 = x1;\n\nvar boundsStream$1 = {\n  point: boundsPoint$1,\n  lineStart: noop$1,\n  lineEnd: noop$1,\n  polygonStart: noop$1,\n  polygonEnd: noop$1,\n  result: function() {\n    var bounds = [[x0$2, y0$2], [x1, y1]];\n    x1 = y1 = -(y0$2 = x0$2 = Infinity);\n    return bounds;\n  }\n};\n\nfunction boundsPoint$1(x, y) {\n  if (x < x0$2) x0$2 = x;\n  if (x > x1) x1 = x;\n  if (y < y0$2) y0$2 = y;\n  if (y > y1) y1 = y;\n}\n\n// TODO Enforce positive area for exterior, negative area for interior?\n\nvar X0$1 = 0;\nvar Y0$1 = 0;\nvar Z0$1 = 0;\nvar X1$1 = 0;\nvar Y1$1 = 0;\nvar Z1$1 = 0;\nvar X2$1 = 0;\nvar Y2$1 = 0;\nvar Z2$1 = 0;\nvar x00$1;\nvar y00$1;\nvar x0$3;\nvar y0$3;\n\nvar centroidStream$1 = {\n  point: centroidPoint$1,\n  lineStart: centroidLineStart$1,\n  lineEnd: centroidLineEnd$1,\n  polygonStart: function() {\n    centroidStream$1.lineStart = centroidRingStart$1;\n    centroidStream$1.lineEnd = centroidRingEnd$1;\n  },\n  polygonEnd: function() {\n    centroidStream$1.point = centroidPoint$1;\n    centroidStream$1.lineStart = centroidLineStart$1;\n    centroidStream$1.lineEnd = centroidLineEnd$1;\n  },\n  result: function() {\n    var centroid = Z2$1 ? [X2$1 / Z2$1, Y2$1 / Z2$1]\n        : Z1$1 ? [X1$1 / Z1$1, Y1$1 / Z1$1]\n        : Z0$1 ? [X0$1 / Z0$1, Y0$1 / Z0$1]\n        : [NaN, NaN];\n    X0$1 = Y0$1 = Z0$1 =\n    X1$1 = Y1$1 = Z1$1 =\n    X2$1 = Y2$1 = Z2$1 = 0;\n    return centroid;\n  }\n};\n\nfunction centroidPoint$1(x, y) {\n  X0$1 += x;\n  Y0$1 += y;\n  ++Z0$1;\n}\n\nfunction centroidLineStart$1() {\n  centroidStream$1.point = centroidPointFirstLine;\n}\n\nfunction centroidPointFirstLine(x, y) {\n  centroidStream$1.point = centroidPointLine;\n  centroidPoint$1(x0$3 = x, y0$3 = y);\n}\n\nfunction centroidPointLine(x, y) {\n  var dx = x - x0$3, dy = y - y0$3, z = sqrt(dx * dx + dy * dy);\n  X1$1 += z * (x0$3 + x) / 2;\n  Y1$1 += z * (y0$3 + y) / 2;\n  Z1$1 += z;\n  centroidPoint$1(x0$3 = x, y0$3 = y);\n}\n\nfunction centroidLineEnd$1() {\n  centroidStream$1.point = centroidPoint$1;\n}\n\nfunction centroidRingStart$1() {\n  centroidStream$1.point = centroidPointFirstRing;\n}\n\nfunction centroidRingEnd$1() {\n  centroidPointRing(x00$1, y00$1);\n}\n\nfunction centroidPointFirstRing(x, y) {\n  centroidStream$1.point = centroidPointRing;\n  centroidPoint$1(x00$1 = x0$3 = x, y00$1 = y0$3 = y);\n}\n\nfunction centroidPointRing(x, y) {\n  var dx = x - x0$3,\n      dy = y - y0$3,\n      z = sqrt(dx * dx + dy * dy);\n\n  X1$1 += z * (x0$3 + x) / 2;\n  Y1$1 += z * (y0$3 + y) / 2;\n  Z1$1 += z;\n\n  z = y0$3 * x - x0$3 * y;\n  X2$1 += z * (x0$3 + x);\n  Y2$1 += z * (y0$3 + y);\n  Z2$1 += z * 3;\n  centroidPoint$1(x0$3 = x, y0$3 = y);\n}\n\nfunction PathContext(context) {\n  this._context = context;\n}\n\nPathContext.prototype = {\n  _radius: 4.5,\n  pointRadius: function(_) {\n    return this._radius = _, this;\n  },\n  polygonStart: function() {\n    this._line = 0;\n  },\n  polygonEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._point = 0;\n  },\n  lineEnd: function() {\n    if (this._line === 0) this._context.closePath();\n    this._point = NaN;\n  },\n  point: function(x, y) {\n    switch (this._point) {\n      case 0: {\n        this._context.moveTo(x, y);\n        this._point = 1;\n        break;\n      }\n      case 1: {\n        this._context.lineTo(x, y);\n        break;\n      }\n      default: {\n        this._context.moveTo(x + this._radius, y);\n        this._context.arc(x, y, this._radius, 0, tau$3);\n        break;\n      }\n    }\n  },\n  result: noop$1\n};\n\nvar lengthSum$1 = adder();\nvar lengthRing;\nvar x00$2;\nvar y00$2;\nvar x0$4;\nvar y0$4;\n\nvar lengthStream$1 = {\n  point: noop$1,\n  lineStart: function() {\n    lengthStream$1.point = lengthPointFirst$1;\n  },\n  lineEnd: function() {\n    if (lengthRing) lengthPoint$1(x00$2, y00$2);\n    lengthStream$1.point = noop$1;\n  },\n  polygonStart: function() {\n    lengthRing = true;\n  },\n  polygonEnd: function() {\n    lengthRing = null;\n  },\n  result: function() {\n    var length = +lengthSum$1;\n    lengthSum$1.reset();\n    return length;\n  }\n};\n\nfunction lengthPointFirst$1(x, y) {\n  lengthStream$1.point = lengthPoint$1;\n  x00$2 = x0$4 = x, y00$2 = y0$4 = y;\n}\n\nfunction lengthPoint$1(x, y) {\n  x0$4 -= x, y0$4 -= y;\n  lengthSum$1.add(sqrt(x0$4 * x0$4 + y0$4 * y0$4));\n  x0$4 = x, y0$4 = y;\n}\n\nfunction PathString() {\n  this._string = [];\n}\n\nPathString.prototype = {\n  _circle: circle$1(4.5),\n  pointRadius: function(_) {\n    return this._circle = circle$1(_), this;\n  },\n  polygonStart: function() {\n    this._line = 0;\n  },\n  polygonEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._point = 0;\n  },\n  lineEnd: function() {\n    if (this._line === 0) this._string.push(\"Z\");\n    this._point = NaN;\n  },\n  point: function(x, y) {\n    switch (this._point) {\n      case 0: {\n        this._string.push(\"M\", x, \",\", y);\n        this._point = 1;\n        break;\n      }\n      case 1: {\n        this._string.push(\"L\", x, \",\", y);\n        break;\n      }\n      default: {\n        this._string.push(\"M\", x, \",\", y, this._circle);\n        break;\n      }\n    }\n  },\n  result: function() {\n    if (this._string.length) {\n      var result = this._string.join(\"\");\n      this._string = [];\n      return result;\n    }\n  }\n};\n\nfunction circle$1(radius) {\n  return \"m0,\" + radius\n      + \"a\" + radius + \",\" + radius + \" 0 1,1 0,\" + -2 * radius\n      + \"a\" + radius + \",\" + radius + \" 0 1,1 0,\" + 2 * radius\n      + \"z\";\n}\n\nvar index$1 = function(projection, context) {\n  var pointRadius = 4.5,\n      projectionStream,\n      contextStream;\n\n  function path(object) {\n    if (object) {\n      if (typeof pointRadius === \"function\") contextStream.pointRadius(+pointRadius.apply(this, arguments));\n      geoStream(object, projectionStream(contextStream));\n    }\n    return contextStream.result();\n  }\n\n  path.area = function(object) {\n    geoStream(object, projectionStream(areaStream$1));\n    return areaStream$1.result();\n  };\n\n  path.measure = function(object) {\n    geoStream(object, projectionStream(lengthStream$1));\n    return lengthStream$1.result();\n  };\n\n  path.bounds = function(object) {\n    geoStream(object, projectionStream(boundsStream$1));\n    return boundsStream$1.result();\n  };\n\n  path.centroid = function(object) {\n    geoStream(object, projectionStream(centroidStream$1));\n    return centroidStream$1.result();\n  };\n\n  path.projection = function(_) {\n    return arguments.length ? (projectionStream = _ == null ? (projection = null, identity$4) : (projection = _).stream, path) : projection;\n  };\n\n  path.context = function(_) {\n    if (!arguments.length) return context;\n    contextStream = _ == null ? (context = null, new PathString) : new PathContext(context = _);\n    if (typeof pointRadius !== \"function\") contextStream.pointRadius(pointRadius);\n    return path;\n  };\n\n  path.pointRadius = function(_) {\n    if (!arguments.length) return pointRadius;\n    pointRadius = typeof _ === \"function\" ? _ : (contextStream.pointRadius(+_), +_);\n    return path;\n  };\n\n  return path.projection(projection).context(context);\n};\n\nvar sum$1 = adder();\n\nvar polygonContains = function(polygon, point) {\n  var lambda = point[0],\n      phi = point[1],\n      normal = [sin$1(lambda), -cos$1(lambda), 0],\n      angle = 0,\n      winding = 0;\n\n  sum$1.reset();\n\n  for (var i = 0, n = polygon.length; i < n; ++i) {\n    if (!(m = (ring = polygon[i]).length)) continue;\n    var ring,\n        m,\n        point0 = ring[m - 1],\n        lambda0 = point0[0],\n        phi0 = point0[1] / 2 + quarterPi,\n        sinPhi0 = sin$1(phi0),\n        cosPhi0 = cos$1(phi0);\n\n    for (var j = 0; j < m; ++j, lambda0 = lambda1, sinPhi0 = sinPhi1, cosPhi0 = cosPhi1, point0 = point1) {\n      var point1 = ring[j],\n          lambda1 = point1[0],\n          phi1 = point1[1] / 2 + quarterPi,\n          sinPhi1 = sin$1(phi1),\n          cosPhi1 = cos$1(phi1),\n          delta = lambda1 - lambda0,\n          sign$$1 = delta >= 0 ? 1 : -1,\n          absDelta = sign$$1 * delta,\n          antimeridian = absDelta > pi$3,\n          k = sinPhi0 * sinPhi1;\n\n      sum$1.add(atan2(k * sign$$1 * sin$1(absDelta), cosPhi0 * cosPhi1 + k * cos$1(absDelta)));\n      angle += antimeridian ? delta + sign$$1 * tau$3 : delta;\n\n      // Are the longitudes either side of the point’s meridian (lambda),\n      // and are the latitudes smaller than the parallel (phi)?\n      if (antimeridian ^ lambda0 >= lambda ^ lambda1 >= lambda) {\n        var arc = cartesianCross(cartesian(point0), cartesian(point1));\n        cartesianNormalizeInPlace(arc);\n        var intersection = cartesianCross(normal, arc);\n        cartesianNormalizeInPlace(intersection);\n        var phiArc = (antimeridian ^ delta >= 0 ? -1 : 1) * asin(intersection[2]);\n        if (phi > phiArc || phi === phiArc && (arc[0] || arc[1])) {\n          winding += antimeridian ^ delta >= 0 ? 1 : -1;\n        }\n      }\n    }\n  }\n\n  // First, determine whether the South pole is inside or outside:\n  //\n  // It is inside if:\n  // * the polygon winds around it in a clockwise direction.\n  // * the polygon does not (cumulatively) wind around it, but has a negative\n  //   (counter-clockwise) area.\n  //\n  // Second, count the (signed) number of times a segment crosses a lambda\n  // from the point to the South pole.  If it is zero, then the point is the\n  // same side as the South pole.\n\n  return (angle < -epsilon$2 || angle < epsilon$2 && sum$1 < -epsilon$2) ^ (winding & 1);\n};\n\nvar clip = function(pointVisible, clipLine, interpolate, start) {\n  return function(rotate, sink) {\n    var line = clipLine(sink),\n        rotatedStart = rotate.invert(start[0], start[1]),\n        ringBuffer = clipBuffer(),\n        ringSink = clipLine(ringBuffer),\n        polygonStarted = false,\n        polygon,\n        segments,\n        ring;\n\n    var clip = {\n      point: point,\n      lineStart: lineStart,\n      lineEnd: lineEnd,\n      polygonStart: function() {\n        clip.point = pointRing;\n        clip.lineStart = ringStart;\n        clip.lineEnd = ringEnd;\n        segments = [];\n        polygon = [];\n      },\n      polygonEnd: function() {\n        clip.point = point;\n        clip.lineStart = lineStart;\n        clip.lineEnd = lineEnd;\n        segments = merge(segments);\n        var startInside = polygonContains(polygon, rotatedStart);\n        if (segments.length) {\n          if (!polygonStarted) sink.polygonStart(), polygonStarted = true;\n          clipPolygon(segments, compareIntersection, startInside, interpolate, sink);\n        } else if (startInside) {\n          if (!polygonStarted) sink.polygonStart(), polygonStarted = true;\n          sink.lineStart();\n          interpolate(null, null, 1, sink);\n          sink.lineEnd();\n        }\n        if (polygonStarted) sink.polygonEnd(), polygonStarted = false;\n        segments = polygon = null;\n      },\n      sphere: function() {\n        sink.polygonStart();\n        sink.lineStart();\n        interpolate(null, null, 1, sink);\n        sink.lineEnd();\n        sink.polygonEnd();\n      }\n    };\n\n    function point(lambda, phi) {\n      var point = rotate(lambda, phi);\n      if (pointVisible(lambda = point[0], phi = point[1])) sink.point(lambda, phi);\n    }\n\n    function pointLine(lambda, phi) {\n      var point = rotate(lambda, phi);\n      line.point(point[0], point[1]);\n    }\n\n    function lineStart() {\n      clip.point = pointLine;\n      line.lineStart();\n    }\n\n    function lineEnd() {\n      clip.point = point;\n      line.lineEnd();\n    }\n\n    function pointRing(lambda, phi) {\n      ring.push([lambda, phi]);\n      var point = rotate(lambda, phi);\n      ringSink.point(point[0], point[1]);\n    }\n\n    function ringStart() {\n      ringSink.lineStart();\n      ring = [];\n    }\n\n    function ringEnd() {\n      pointRing(ring[0][0], ring[0][1]);\n      ringSink.lineEnd();\n\n      var clean = ringSink.clean(),\n          ringSegments = ringBuffer.result(),\n          i, n = ringSegments.length, m,\n          segment,\n          point;\n\n      ring.pop();\n      polygon.push(ring);\n      ring = null;\n\n      if (!n) return;\n\n      // No intersections.\n      if (clean & 1) {\n        segment = ringSegments[0];\n        if ((m = segment.length - 1) > 0) {\n          if (!polygonStarted) sink.polygonStart(), polygonStarted = true;\n          sink.lineStart();\n          for (i = 0; i < m; ++i) sink.point((point = segment[i])[0], point[1]);\n          sink.lineEnd();\n        }\n        return;\n      }\n\n      // Rejoin connected segments.\n      // TODO reuse ringBuffer.rejoin()?\n      if (n > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift()));\n\n      segments.push(ringSegments.filter(validSegment));\n    }\n\n    return clip;\n  };\n};\n\nfunction validSegment(segment) {\n  return segment.length > 1;\n}\n\n// Intersections are sorted along the clip edge. For both antimeridian cutting\n// and circle clipping, the same comparison is used.\nfunction compareIntersection(a, b) {\n  return ((a = a.x)[0] < 0 ? a[1] - halfPi$2 - epsilon$2 : halfPi$2 - a[1])\n       - ((b = b.x)[0] < 0 ? b[1] - halfPi$2 - epsilon$2 : halfPi$2 - b[1]);\n}\n\nvar clipAntimeridian = clip(\n  function() { return true; },\n  clipAntimeridianLine,\n  clipAntimeridianInterpolate,\n  [-pi$3, -halfPi$2]\n);\n\n// Takes a line and cuts into visible segments. Return values: 0 - there were\n// intersections or the line was empty; 1 - no intersections; 2 - there were\n// intersections, and the first and last segments should be rejoined.\nfunction clipAntimeridianLine(stream) {\n  var lambda0 = NaN,\n      phi0 = NaN,\n      sign0 = NaN,\n      clean; // no intersections\n\n  return {\n    lineStart: function() {\n      stream.lineStart();\n      clean = 1;\n    },\n    point: function(lambda1, phi1) {\n      var sign1 = lambda1 > 0 ? pi$3 : -pi$3,\n          delta = abs(lambda1 - lambda0);\n      if (abs(delta - pi$3) < epsilon$2) { // line crosses a pole\n        stream.point(lambda0, phi0 = (phi0 + phi1) / 2 > 0 ? halfPi$2 : -halfPi$2);\n        stream.point(sign0, phi0);\n        stream.lineEnd();\n        stream.lineStart();\n        stream.point(sign1, phi0);\n        stream.point(lambda1, phi0);\n        clean = 0;\n      } else if (sign0 !== sign1 && delta >= pi$3) { // line crosses antimeridian\n        if (abs(lambda0 - sign0) < epsilon$2) lambda0 -= sign0 * epsilon$2; // handle degeneracies\n        if (abs(lambda1 - sign1) < epsilon$2) lambda1 -= sign1 * epsilon$2;\n        phi0 = clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1);\n        stream.point(sign0, phi0);\n        stream.lineEnd();\n        stream.lineStart();\n        stream.point(sign1, phi0);\n        clean = 0;\n      }\n      stream.point(lambda0 = lambda1, phi0 = phi1);\n      sign0 = sign1;\n    },\n    lineEnd: function() {\n      stream.lineEnd();\n      lambda0 = phi0 = NaN;\n    },\n    clean: function() {\n      return 2 - clean; // if intersections, rejoin first and last segments\n    }\n  };\n}\n\nfunction clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1) {\n  var cosPhi0,\n      cosPhi1,\n      sinLambda0Lambda1 = sin$1(lambda0 - lambda1);\n  return abs(sinLambda0Lambda1) > epsilon$2\n      ? atan((sin$1(phi0) * (cosPhi1 = cos$1(phi1)) * sin$1(lambda1)\n          - sin$1(phi1) * (cosPhi0 = cos$1(phi0)) * sin$1(lambda0))\n          / (cosPhi0 * cosPhi1 * sinLambda0Lambda1))\n      : (phi0 + phi1) / 2;\n}\n\nfunction clipAntimeridianInterpolate(from, to, direction, stream) {\n  var phi;\n  if (from == null) {\n    phi = direction * halfPi$2;\n    stream.point(-pi$3, phi);\n    stream.point(0, phi);\n    stream.point(pi$3, phi);\n    stream.point(pi$3, 0);\n    stream.point(pi$3, -phi);\n    stream.point(0, -phi);\n    stream.point(-pi$3, -phi);\n    stream.point(-pi$3, 0);\n    stream.point(-pi$3, phi);\n  } else if (abs(from[0] - to[0]) > epsilon$2) {\n    var lambda = from[0] < to[0] ? pi$3 : -pi$3;\n    phi = direction * lambda / 2;\n    stream.point(-lambda, phi);\n    stream.point(0, phi);\n    stream.point(lambda, phi);\n  } else {\n    stream.point(to[0], to[1]);\n  }\n}\n\nvar clipCircle = function(radius, delta) {\n  var cr = cos$1(radius),\n      smallRadius = cr > 0,\n      notHemisphere = abs(cr) > epsilon$2; // TODO optimise for this common case\n\n  function interpolate(from, to, direction, stream) {\n    circleStream(stream, radius, delta, direction, from, to);\n  }\n\n  function visible(lambda, phi) {\n    return cos$1(lambda) * cos$1(phi) > cr;\n  }\n\n  // Takes a line and cuts into visible segments. Return values used for polygon\n  // clipping: 0 - there were intersections or the line was empty; 1 - no\n  // intersections 2 - there were intersections, and the first and last segments\n  // should be rejoined.\n  function clipLine(stream) {\n    var point0, // previous point\n        c0, // code for previous point\n        v0, // visibility of previous point\n        v00, // visibility of first point\n        clean; // no intersections\n    return {\n      lineStart: function() {\n        v00 = v0 = false;\n        clean = 1;\n      },\n      point: function(lambda, phi) {\n        var point1 = [lambda, phi],\n            point2,\n            v = visible(lambda, phi),\n            c = smallRadius\n              ? v ? 0 : code(lambda, phi)\n              : v ? code(lambda + (lambda < 0 ? pi$3 : -pi$3), phi) : 0;\n        if (!point0 && (v00 = v0 = v)) stream.lineStart();\n        // Handle degeneracies.\n        // TODO ignore if not clipping polygons.\n        if (v !== v0) {\n          point2 = intersect(point0, point1);\n          if (pointEqual(point0, point2) || pointEqual(point1, point2)) {\n            point1[0] += epsilon$2;\n            point1[1] += epsilon$2;\n            v = visible(point1[0], point1[1]);\n          }\n        }\n        if (v !== v0) {\n          clean = 0;\n          if (v) {\n            // outside going in\n            stream.lineStart();\n            point2 = intersect(point1, point0);\n            stream.point(point2[0], point2[1]);\n          } else {\n            // inside going out\n            point2 = intersect(point0, point1);\n            stream.point(point2[0], point2[1]);\n            stream.lineEnd();\n          }\n          point0 = point2;\n        } else if (notHemisphere && point0 && smallRadius ^ v) {\n          var t;\n          // If the codes for two points are different, or are both zero,\n          // and there this segment intersects with the small circle.\n          if (!(c & c0) && (t = intersect(point1, point0, true))) {\n            clean = 0;\n            if (smallRadius) {\n              stream.lineStart();\n              stream.point(t[0][0], t[0][1]);\n              stream.point(t[1][0], t[1][1]);\n              stream.lineEnd();\n            } else {\n              stream.point(t[1][0], t[1][1]);\n              stream.lineEnd();\n              stream.lineStart();\n              stream.point(t[0][0], t[0][1]);\n            }\n          }\n        }\n        if (v && (!point0 || !pointEqual(point0, point1))) {\n          stream.point(point1[0], point1[1]);\n        }\n        point0 = point1, v0 = v, c0 = c;\n      },\n      lineEnd: function() {\n        if (v0) stream.lineEnd();\n        point0 = null;\n      },\n      // Rejoin first and last segments if there were intersections and the first\n      // and last points were visible.\n      clean: function() {\n        return clean | ((v00 && v0) << 1);\n      }\n    };\n  }\n\n  // Intersects the great circle between a and b with the clip circle.\n  function intersect(a, b, two) {\n    var pa = cartesian(a),\n        pb = cartesian(b);\n\n    // We have two planes, n1.p = d1 and n2.p = d2.\n    // Find intersection line p(t) = c1 n1 + c2 n2 + t (n1 ⨯ n2).\n    var n1 = [1, 0, 0], // normal\n        n2 = cartesianCross(pa, pb),\n        n2n2 = cartesianDot(n2, n2),\n        n1n2 = n2[0], // cartesianDot(n1, n2),\n        determinant = n2n2 - n1n2 * n1n2;\n\n    // Two polar points.\n    if (!determinant) return !two && a;\n\n    var c1 =  cr * n2n2 / determinant,\n        c2 = -cr * n1n2 / determinant,\n        n1xn2 = cartesianCross(n1, n2),\n        A = cartesianScale(n1, c1),\n        B = cartesianScale(n2, c2);\n    cartesianAddInPlace(A, B);\n\n    // Solve |p(t)|^2 = 1.\n    var u = n1xn2,\n        w = cartesianDot(A, u),\n        uu = cartesianDot(u, u),\n        t2 = w * w - uu * (cartesianDot(A, A) - 1);\n\n    if (t2 < 0) return;\n\n    var t = sqrt(t2),\n        q = cartesianScale(u, (-w - t) / uu);\n    cartesianAddInPlace(q, A);\n    q = spherical(q);\n\n    if (!two) return q;\n\n    // Two intersection points.\n    var lambda0 = a[0],\n        lambda1 = b[0],\n        phi0 = a[1],\n        phi1 = b[1],\n        z;\n\n    if (lambda1 < lambda0) z = lambda0, lambda0 = lambda1, lambda1 = z;\n\n    var delta = lambda1 - lambda0,\n        polar = abs(delta - pi$3) < epsilon$2,\n        meridian = polar || delta < epsilon$2;\n\n    if (!polar && phi1 < phi0) z = phi0, phi0 = phi1, phi1 = z;\n\n    // Check that the first point is between a and b.\n    if (meridian\n        ? polar\n          ? phi0 + phi1 > 0 ^ q[1] < (abs(q[0] - lambda0) < epsilon$2 ? phi0 : phi1)\n          : phi0 <= q[1] && q[1] <= phi1\n        : delta > pi$3 ^ (lambda0 <= q[0] && q[0] <= lambda1)) {\n      var q1 = cartesianScale(u, (-w + t) / uu);\n      cartesianAddInPlace(q1, A);\n      return [q, spherical(q1)];\n    }\n  }\n\n  // Generates a 4-bit vector representing the location of a point relative to\n  // the small circle's bounding box.\n  function code(lambda, phi) {\n    var r = smallRadius ? radius : pi$3 - radius,\n        code = 0;\n    if (lambda < -r) code |= 1; // left\n    else if (lambda > r) code |= 2; // right\n    if (phi < -r) code |= 4; // below\n    else if (phi > r) code |= 8; // above\n    return code;\n  }\n\n  return clip(visible, clipLine, interpolate, smallRadius ? [0, -radius] : [-pi$3, radius - pi$3]);\n};\n\nvar transform = function(methods) {\n  return {\n    stream: transformer(methods)\n  };\n};\n\nfunction transformer(methods) {\n  return function(stream) {\n    var s = new TransformStream;\n    for (var key in methods) s[key] = methods[key];\n    s.stream = stream;\n    return s;\n  };\n}\n\nfunction TransformStream() {}\n\nTransformStream.prototype = {\n  constructor: TransformStream,\n  point: function(x, y) { this.stream.point(x, y); },\n  sphere: function() { this.stream.sphere(); },\n  lineStart: function() { this.stream.lineStart(); },\n  lineEnd: function() { this.stream.lineEnd(); },\n  polygonStart: function() { this.stream.polygonStart(); },\n  polygonEnd: function() { this.stream.polygonEnd(); }\n};\n\nfunction fitExtent(projection, extent, object) {\n  var w = extent[1][0] - extent[0][0],\n      h = extent[1][1] - extent[0][1],\n      clip = projection.clipExtent && projection.clipExtent();\n\n  projection\n      .scale(150)\n      .translate([0, 0]);\n\n  if (clip != null) projection.clipExtent(null);\n\n  geoStream(object, projection.stream(boundsStream$1));\n\n  var b = boundsStream$1.result(),\n      k = Math.min(w / (b[1][0] - b[0][0]), h / (b[1][1] - b[0][1])),\n      x = +extent[0][0] + (w - k * (b[1][0] + b[0][0])) / 2,\n      y = +extent[0][1] + (h - k * (b[1][1] + b[0][1])) / 2;\n\n  if (clip != null) projection.clipExtent(clip);\n\n  return projection\n      .scale(k * 150)\n      .translate([x, y]);\n}\n\nfunction fitSize(projection, size, object) {\n  return fitExtent(projection, [[0, 0], size], object);\n}\n\nvar maxDepth = 16;\nvar cosMinDistance = cos$1(30 * radians); // cos(minimum angular distance)\n\nvar resample = function(project, delta2) {\n  return +delta2 ? resample$1(project, delta2) : resampleNone(project);\n};\n\nfunction resampleNone(project) {\n  return transformer({\n    point: function(x, y) {\n      x = project(x, y);\n      this.stream.point(x[0], x[1]);\n    }\n  });\n}\n\nfunction resample$1(project, delta2) {\n\n  function resampleLineTo(x0, y0, lambda0, a0, b0, c0, x1, y1, lambda1, a1, b1, c1, depth, stream) {\n    var dx = x1 - x0,\n        dy = y1 - y0,\n        d2 = dx * dx + dy * dy;\n    if (d2 > 4 * delta2 && depth--) {\n      var a = a0 + a1,\n          b = b0 + b1,\n          c = c0 + c1,\n          m = sqrt(a * a + b * b + c * c),\n          phi2 = asin(c /= m),\n          lambda2 = abs(abs(c) - 1) < epsilon$2 || abs(lambda0 - lambda1) < epsilon$2 ? (lambda0 + lambda1) / 2 : atan2(b, a),\n          p = project(lambda2, phi2),\n          x2 = p[0],\n          y2 = p[1],\n          dx2 = x2 - x0,\n          dy2 = y2 - y0,\n          dz = dy * dx2 - dx * dy2;\n      if (dz * dz / d2 > delta2 // perpendicular projected distance\n          || abs((dx * dx2 + dy * dy2) / d2 - 0.5) > 0.3 // midpoint close to an end\n          || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) { // angular distance\n        resampleLineTo(x0, y0, lambda0, a0, b0, c0, x2, y2, lambda2, a /= m, b /= m, c, depth, stream);\n        stream.point(x2, y2);\n        resampleLineTo(x2, y2, lambda2, a, b, c, x1, y1, lambda1, a1, b1, c1, depth, stream);\n      }\n    }\n  }\n  return function(stream) {\n    var lambda00, x00, y00, a00, b00, c00, // first point\n        lambda0, x0, y0, a0, b0, c0; // previous point\n\n    var resampleStream = {\n      point: point,\n      lineStart: lineStart,\n      lineEnd: lineEnd,\n      polygonStart: function() { stream.polygonStart(); resampleStream.lineStart = ringStart; },\n      polygonEnd: function() { stream.polygonEnd(); resampleStream.lineStart = lineStart; }\n    };\n\n    function point(x, y) {\n      x = project(x, y);\n      stream.point(x[0], x[1]);\n    }\n\n    function lineStart() {\n      x0 = NaN;\n      resampleStream.point = linePoint;\n      stream.lineStart();\n    }\n\n    function linePoint(lambda, phi) {\n      var c = cartesian([lambda, phi]), p = project(lambda, phi);\n      resampleLineTo(x0, y0, lambda0, a0, b0, c0, x0 = p[0], y0 = p[1], lambda0 = lambda, a0 = c[0], b0 = c[1], c0 = c[2], maxDepth, stream);\n      stream.point(x0, y0);\n    }\n\n    function lineEnd() {\n      resampleStream.point = point;\n      stream.lineEnd();\n    }\n\n    function ringStart() {\n      lineStart();\n      resampleStream.point = ringPoint;\n      resampleStream.lineEnd = ringEnd;\n    }\n\n    function ringPoint(lambda, phi) {\n      linePoint(lambda00 = lambda, phi), x00 = x0, y00 = y0, a00 = a0, b00 = b0, c00 = c0;\n      resampleStream.point = linePoint;\n    }\n\n    function ringEnd() {\n      resampleLineTo(x0, y0, lambda0, a0, b0, c0, x00, y00, lambda00, a00, b00, c00, maxDepth, stream);\n      resampleStream.lineEnd = lineEnd;\n      lineEnd();\n    }\n\n    return resampleStream;\n  };\n}\n\nvar transformRadians = transformer({\n  point: function(x, y) {\n    this.stream.point(x * radians, y * radians);\n  }\n});\n\nfunction projection(project) {\n  return projectionMutator(function() { return project; })();\n}\n\nfunction projectionMutator(projectAt) {\n  var project,\n      k = 150, // scale\n      x = 480, y = 250, // translate\n      dx, dy, lambda = 0, phi = 0, // center\n      deltaLambda = 0, deltaPhi = 0, deltaGamma = 0, rotate, projectRotate, // rotate\n      theta = null, preclip = clipAntimeridian, // clip angle\n      x0 = null, y0, x1, y1, postclip = identity$4, // clip extent\n      delta2 = 0.5, projectResample = resample(projectTransform, delta2), // precision\n      cache,\n      cacheStream;\n\n  function projection(point) {\n    point = projectRotate(point[0] * radians, point[1] * radians);\n    return [point[0] * k + dx, dy - point[1] * k];\n  }\n\n  function invert(point) {\n    point = projectRotate.invert((point[0] - dx) / k, (dy - point[1]) / k);\n    return point && [point[0] * degrees$1, point[1] * degrees$1];\n  }\n\n  function projectTransform(x, y) {\n    return x = project(x, y), [x[0] * k + dx, dy - x[1] * k];\n  }\n\n  projection.stream = function(stream) {\n    return cache && cacheStream === stream ? cache : cache = transformRadians(preclip(rotate, projectResample(postclip(cacheStream = stream))));\n  };\n\n  projection.clipAngle = function(_) {\n    return arguments.length ? (preclip = +_ ? clipCircle(theta = _ * radians, 6 * radians) : (theta = null, clipAntimeridian), reset()) : theta * degrees$1;\n  };\n\n  projection.clipExtent = function(_) {\n    return arguments.length ? (postclip = _ == null ? (x0 = y0 = x1 = y1 = null, identity$4) : clipExtent(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]), reset()) : x0 == null ? null : [[x0, y0], [x1, y1]];\n  };\n\n  projection.scale = function(_) {\n    return arguments.length ? (k = +_, recenter()) : k;\n  };\n\n  projection.translate = function(_) {\n    return arguments.length ? (x = +_[0], y = +_[1], recenter()) : [x, y];\n  };\n\n  projection.center = function(_) {\n    return arguments.length ? (lambda = _[0] % 360 * radians, phi = _[1] % 360 * radians, recenter()) : [lambda * degrees$1, phi * degrees$1];\n  };\n\n  projection.rotate = function(_) {\n    return arguments.length ? (deltaLambda = _[0] % 360 * radians, deltaPhi = _[1] % 360 * radians, deltaGamma = _.length > 2 ? _[2] % 360 * radians : 0, recenter()) : [deltaLambda * degrees$1, deltaPhi * degrees$1, deltaGamma * degrees$1];\n  };\n\n  projection.precision = function(_) {\n    return arguments.length ? (projectResample = resample(projectTransform, delta2 = _ * _), reset()) : sqrt(delta2);\n  };\n\n  projection.fitExtent = function(extent, object) {\n    return fitExtent(projection, extent, object);\n  };\n\n  projection.fitSize = function(size, object) {\n    return fitSize(projection, size, object);\n  };\n\n  function recenter() {\n    projectRotate = compose(rotate = rotateRadians(deltaLambda, deltaPhi, deltaGamma), project);\n    var center = project(lambda, phi);\n    dx = x - center[0] * k;\n    dy = y + center[1] * k;\n    return reset();\n  }\n\n  function reset() {\n    cache = cacheStream = null;\n    return projection;\n  }\n\n  return function() {\n    project = projectAt.apply(this, arguments);\n    projection.invert = project.invert && invert;\n    return recenter();\n  };\n}\n\nfunction conicProjection(projectAt) {\n  var phi0 = 0,\n      phi1 = pi$3 / 3,\n      m = projectionMutator(projectAt),\n      p = m(phi0, phi1);\n\n  p.parallels = function(_) {\n    return arguments.length ? m(phi0 = _[0] * radians, phi1 = _[1] * radians) : [phi0 * degrees$1, phi1 * degrees$1];\n  };\n\n  return p;\n}\n\nfunction cylindricalEqualAreaRaw(phi0) {\n  var cosPhi0 = cos$1(phi0);\n\n  function forward(lambda, phi) {\n    return [lambda * cosPhi0, sin$1(phi) / cosPhi0];\n  }\n\n  forward.invert = function(x, y) {\n    return [x / cosPhi0, asin(y * cosPhi0)];\n  };\n\n  return forward;\n}\n\nfunction conicEqualAreaRaw(y0, y1) {\n  var sy0 = sin$1(y0), n = (sy0 + sin$1(y1)) / 2;\n\n  // Are the parallels symmetrical around the Equator?\n  if (abs(n) < epsilon$2) return cylindricalEqualAreaRaw(y0);\n\n  var c = 1 + sy0 * (2 * n - sy0), r0 = sqrt(c) / n;\n\n  function project(x, y) {\n    var r = sqrt(c - 2 * n * sin$1(y)) / n;\n    return [r * sin$1(x *= n), r0 - r * cos$1(x)];\n  }\n\n  project.invert = function(x, y) {\n    var r0y = r0 - y;\n    return [atan2(x, abs(r0y)) / n * sign(r0y), asin((c - (x * x + r0y * r0y) * n * n) / (2 * n))];\n  };\n\n  return project;\n}\n\nvar conicEqualArea = function() {\n  return conicProjection(conicEqualAreaRaw)\n      .scale(155.424)\n      .center([0, 33.6442]);\n};\n\nvar albers = function() {\n  return conicEqualArea()\n      .parallels([29.5, 45.5])\n      .scale(1070)\n      .translate([480, 250])\n      .rotate([96, 0])\n      .center([-0.6, 38.7]);\n};\n\n// The projections must have mutually exclusive clip regions on the sphere,\n// as this will avoid emitting interleaving lines and polygons.\nfunction multiplex(streams) {\n  var n = streams.length;\n  return {\n    point: function(x, y) { var i = -1; while (++i < n) streams[i].point(x, y); },\n    sphere: function() { var i = -1; while (++i < n) streams[i].sphere(); },\n    lineStart: function() { var i = -1; while (++i < n) streams[i].lineStart(); },\n    lineEnd: function() { var i = -1; while (++i < n) streams[i].lineEnd(); },\n    polygonStart: function() { var i = -1; while (++i < n) streams[i].polygonStart(); },\n    polygonEnd: function() { var i = -1; while (++i < n) streams[i].polygonEnd(); }\n  };\n}\n\n// A composite projection for the United States, configured by default for\n// 960×500. The projection also works quite well at 960×600 if you change the\n// scale to 1285 and adjust the translate accordingly. The set of standard\n// parallels for each region comes from USGS, which is published here:\n// http://egsc.usgs.gov/isb/pubs/MapProjections/projections.html#albers\nvar albersUsa = function() {\n  var cache,\n      cacheStream,\n      lower48 = albers(), lower48Point,\n      alaska = conicEqualArea().rotate([154, 0]).center([-2, 58.5]).parallels([55, 65]), alaskaPoint, // EPSG:3338\n      hawaii = conicEqualArea().rotate([157, 0]).center([-3, 19.9]).parallels([8, 18]), hawaiiPoint, // ESRI:102007\n      point, pointStream = {point: function(x, y) { point = [x, y]; }};\n\n  function albersUsa(coordinates) {\n    var x = coordinates[0], y = coordinates[1];\n    return point = null,\n        (lower48Point.point(x, y), point)\n        || (alaskaPoint.point(x, y), point)\n        || (hawaiiPoint.point(x, y), point);\n  }\n\n  albersUsa.invert = function(coordinates) {\n    var k = lower48.scale(),\n        t = lower48.translate(),\n        x = (coordinates[0] - t[0]) / k,\n        y = (coordinates[1] - t[1]) / k;\n    return (y >= 0.120 && y < 0.234 && x >= -0.425 && x < -0.214 ? alaska\n        : y >= 0.166 && y < 0.234 && x >= -0.214 && x < -0.115 ? hawaii\n        : lower48).invert(coordinates);\n  };\n\n  albersUsa.stream = function(stream) {\n    return cache && cacheStream === stream ? cache : cache = multiplex([lower48.stream(cacheStream = stream), alaska.stream(stream), hawaii.stream(stream)]);\n  };\n\n  albersUsa.precision = function(_) {\n    if (!arguments.length) return lower48.precision();\n    lower48.precision(_), alaska.precision(_), hawaii.precision(_);\n    return reset();\n  };\n\n  albersUsa.scale = function(_) {\n    if (!arguments.length) return lower48.scale();\n    lower48.scale(_), alaska.scale(_ * 0.35), hawaii.scale(_);\n    return albersUsa.translate(lower48.translate());\n  };\n\n  albersUsa.translate = function(_) {\n    if (!arguments.length) return lower48.translate();\n    var k = lower48.scale(), x = +_[0], y = +_[1];\n\n    lower48Point = lower48\n        .translate(_)\n        .clipExtent([[x - 0.455 * k, y - 0.238 * k], [x + 0.455 * k, y + 0.238 * k]])\n        .stream(pointStream);\n\n    alaskaPoint = alaska\n        .translate([x - 0.307 * k, y + 0.201 * k])\n        .clipExtent([[x - 0.425 * k + epsilon$2, y + 0.120 * k + epsilon$2], [x - 0.214 * k - epsilon$2, y + 0.234 * k - epsilon$2]])\n        .stream(pointStream);\n\n    hawaiiPoint = hawaii\n        .translate([x - 0.205 * k, y + 0.212 * k])\n        .clipExtent([[x - 0.214 * k + epsilon$2, y + 0.166 * k + epsilon$2], [x - 0.115 * k - epsilon$2, y + 0.234 * k - epsilon$2]])\n        .stream(pointStream);\n\n    return reset();\n  };\n\n  albersUsa.fitExtent = function(extent, object) {\n    return fitExtent(albersUsa, extent, object);\n  };\n\n  albersUsa.fitSize = function(size, object) {\n    return fitSize(albersUsa, size, object);\n  };\n\n  function reset() {\n    cache = cacheStream = null;\n    return albersUsa;\n  }\n\n  return albersUsa.scale(1070);\n};\n\nfunction azimuthalRaw(scale) {\n  return function(x, y) {\n    var cx = cos$1(x),\n        cy = cos$1(y),\n        k = scale(cx * cy);\n    return [\n      k * cy * sin$1(x),\n      k * sin$1(y)\n    ];\n  }\n}\n\nfunction azimuthalInvert(angle) {\n  return function(x, y) {\n    var z = sqrt(x * x + y * y),\n        c = angle(z),\n        sc = sin$1(c),\n        cc = cos$1(c);\n    return [\n      atan2(x * sc, z * cc),\n      asin(z && y * sc / z)\n    ];\n  }\n}\n\nvar azimuthalEqualAreaRaw = azimuthalRaw(function(cxcy) {\n  return sqrt(2 / (1 + cxcy));\n});\n\nazimuthalEqualAreaRaw.invert = azimuthalInvert(function(z) {\n  return 2 * asin(z / 2);\n});\n\nvar azimuthalEqualArea = function() {\n  return projection(azimuthalEqualAreaRaw)\n      .scale(124.75)\n      .clipAngle(180 - 1e-3);\n};\n\nvar azimuthalEquidistantRaw = azimuthalRaw(function(c) {\n  return (c = acos(c)) && c / sin$1(c);\n});\n\nazimuthalEquidistantRaw.invert = azimuthalInvert(function(z) {\n  return z;\n});\n\nvar azimuthalEquidistant = function() {\n  return projection(azimuthalEquidistantRaw)\n      .scale(79.4188)\n      .clipAngle(180 - 1e-3);\n};\n\nfunction mercatorRaw(lambda, phi) {\n  return [lambda, log(tan((halfPi$2 + phi) / 2))];\n}\n\nmercatorRaw.invert = function(x, y) {\n  return [x, 2 * atan(exp(y)) - halfPi$2];\n};\n\nvar mercator = function() {\n  return mercatorProjection(mercatorRaw)\n      .scale(961 / tau$3);\n};\n\nfunction mercatorProjection(project) {\n  var m = projection(project),\n      scale = m.scale,\n      translate = m.translate,\n      clipExtent = m.clipExtent,\n      clipAuto;\n\n  m.scale = function(_) {\n    return arguments.length ? (scale(_), clipAuto && m.clipExtent(null), m) : scale();\n  };\n\n  m.translate = function(_) {\n    return arguments.length ? (translate(_), clipAuto && m.clipExtent(null), m) : translate();\n  };\n\n  m.clipExtent = function(_) {\n    if (!arguments.length) return clipAuto ? null : clipExtent();\n    if (clipAuto = _ == null) {\n      var k = pi$3 * scale(),\n          t = translate();\n      _ = [[t[0] - k, t[1] - k], [t[0] + k, t[1] + k]];\n    }\n    clipExtent(_);\n    return m;\n  };\n\n  return m.clipExtent(null);\n}\n\nfunction tany(y) {\n  return tan((halfPi$2 + y) / 2);\n}\n\nfunction conicConformalRaw(y0, y1) {\n  var cy0 = cos$1(y0),\n      n = y0 === y1 ? sin$1(y0) : log(cy0 / cos$1(y1)) / log(tany(y1) / tany(y0)),\n      f = cy0 * pow(tany(y0), n) / n;\n\n  if (!n) return mercatorRaw;\n\n  function project(x, y) {\n    if (f > 0) { if (y < -halfPi$2 + epsilon$2) y = -halfPi$2 + epsilon$2; }\n    else { if (y > halfPi$2 - epsilon$2) y = halfPi$2 - epsilon$2; }\n    var r = f / pow(tany(y), n);\n    return [r * sin$1(n * x), f - r * cos$1(n * x)];\n  }\n\n  project.invert = function(x, y) {\n    var fy = f - y, r = sign(n) * sqrt(x * x + fy * fy);\n    return [atan2(x, abs(fy)) / n * sign(fy), 2 * atan(pow(f / r, 1 / n)) - halfPi$2];\n  };\n\n  return project;\n}\n\nvar conicConformal = function() {\n  return conicProjection(conicConformalRaw)\n      .scale(109.5)\n      .parallels([30, 30]);\n};\n\nfunction equirectangularRaw(lambda, phi) {\n  return [lambda, phi];\n}\n\nequirectangularRaw.invert = equirectangularRaw;\n\nvar equirectangular = function() {\n  return projection(equirectangularRaw)\n      .scale(152.63);\n};\n\nfunction conicEquidistantRaw(y0, y1) {\n  var cy0 = cos$1(y0),\n      n = y0 === y1 ? sin$1(y0) : (cy0 - cos$1(y1)) / (y1 - y0),\n      g = cy0 / n + y0;\n\n  if (abs(n) < epsilon$2) return equirectangularRaw;\n\n  function project(x, y) {\n    var gy = g - y, nx = n * x;\n    return [gy * sin$1(nx), g - gy * cos$1(nx)];\n  }\n\n  project.invert = function(x, y) {\n    var gy = g - y;\n    return [atan2(x, abs(gy)) / n * sign(gy), g - sign(n) * sqrt(x * x + gy * gy)];\n  };\n\n  return project;\n}\n\nvar conicEquidistant = function() {\n  return conicProjection(conicEquidistantRaw)\n      .scale(131.154)\n      .center([0, 13.9389]);\n};\n\nfunction gnomonicRaw(x, y) {\n  var cy = cos$1(y), k = cos$1(x) * cy;\n  return [cy * sin$1(x) / k, sin$1(y) / k];\n}\n\ngnomonicRaw.invert = azimuthalInvert(atan);\n\nvar gnomonic = function() {\n  return projection(gnomonicRaw)\n      .scale(144.049)\n      .clipAngle(60);\n};\n\nfunction scaleTranslate(kx, ky, tx, ty) {\n  return kx === 1 && ky === 1 && tx === 0 && ty === 0 ? identity$4 : transformer({\n    point: function(x, y) {\n      this.stream.point(x * kx + tx, y * ky + ty);\n    }\n  });\n}\n\nvar identity$5 = function() {\n  var k = 1, tx = 0, ty = 0, sx = 1, sy = 1, transform = identity$4, // scale, translate and reflect\n      x0 = null, y0, x1, y1, clip = identity$4, // clip extent\n      cache,\n      cacheStream,\n      projection;\n\n  function reset() {\n    cache = cacheStream = null;\n    return projection;\n  }\n\n  return projection = {\n    stream: function(stream) {\n      return cache && cacheStream === stream ? cache : cache = transform(clip(cacheStream = stream));\n    },\n    clipExtent: function(_) {\n      return arguments.length ? (clip = _ == null ? (x0 = y0 = x1 = y1 = null, identity$4) : clipExtent(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]), reset()) : x0 == null ? null : [[x0, y0], [x1, y1]];\n    },\n    scale: function(_) {\n      return arguments.length ? (transform = scaleTranslate((k = +_) * sx, k * sy, tx, ty), reset()) : k;\n    },\n    translate: function(_) {\n      return arguments.length ? (transform = scaleTranslate(k * sx, k * sy, tx = +_[0], ty = +_[1]), reset()) : [tx, ty];\n    },\n    reflectX: function(_) {\n      return arguments.length ? (transform = scaleTranslate(k * (sx = _ ? -1 : 1), k * sy, tx, ty), reset()) : sx < 0;\n    },\n    reflectY: function(_) {\n      return arguments.length ? (transform = scaleTranslate(k * sx, k * (sy = _ ? -1 : 1), tx, ty), reset()) : sy < 0;\n    },\n    fitExtent: function(extent, object) {\n      return fitExtent(projection, extent, object);\n    },\n    fitSize: function(size, object) {\n      return fitSize(projection, size, object);\n    }\n  };\n};\n\nfunction orthographicRaw(x, y) {\n  return [cos$1(y) * sin$1(x), sin$1(y)];\n}\n\northographicRaw.invert = azimuthalInvert(asin);\n\nvar orthographic = function() {\n  return projection(orthographicRaw)\n      .scale(249.5)\n      .clipAngle(90 + epsilon$2);\n};\n\nfunction stereographicRaw(x, y) {\n  var cy = cos$1(y), k = 1 + cos$1(x) * cy;\n  return [cy * sin$1(x) / k, sin$1(y) / k];\n}\n\nstereographicRaw.invert = azimuthalInvert(function(z) {\n  return 2 * atan(z);\n});\n\nvar stereographic = function() {\n  return projection(stereographicRaw)\n      .scale(250)\n      .clipAngle(142);\n};\n\nfunction transverseMercatorRaw(lambda, phi) {\n  return [log(tan((halfPi$2 + phi) / 2)), -lambda];\n}\n\ntransverseMercatorRaw.invert = function(x, y) {\n  return [-y, 2 * atan(exp(x)) - halfPi$2];\n};\n\nvar transverseMercator = function() {\n  var m = mercatorProjection(transverseMercatorRaw),\n      center = m.center,\n      rotate = m.rotate;\n\n  m.center = function(_) {\n    return arguments.length ? center([-_[1], _[0]]) : (_ = center(), [_[1], -_[0]]);\n  };\n\n  m.rotate = function(_) {\n    return arguments.length ? rotate([_[0], _[1], _.length > 2 ? _[2] + 90 : 90]) : (_ = rotate(), [_[0], _[1], _[2] - 90]);\n  };\n\n  return rotate([0, 0, 90])\n      .scale(159.155);\n};\n\nfunction defaultSeparation(a, b) {\n  return a.parent === b.parent ? 1 : 2;\n}\n\nfunction meanX(children) {\n  return children.reduce(meanXReduce, 0) / children.length;\n}\n\nfunction meanXReduce(x, c) {\n  return x + c.x;\n}\n\nfunction maxY(children) {\n  return 1 + children.reduce(maxYReduce, 0);\n}\n\nfunction maxYReduce(y, c) {\n  return Math.max(y, c.y);\n}\n\nfunction leafLeft(node) {\n  var children;\n  while (children = node.children) node = children[0];\n  return node;\n}\n\nfunction leafRight(node) {\n  var children;\n  while (children = node.children) node = children[children.length - 1];\n  return node;\n}\n\nvar cluster = function() {\n  var separation = defaultSeparation,\n      dx = 1,\n      dy = 1,\n      nodeSize = false;\n\n  function cluster(root) {\n    var previousNode,\n        x = 0;\n\n    // First walk, computing the initial x & y values.\n    root.eachAfter(function(node) {\n      var children = node.children;\n      if (children) {\n        node.x = meanX(children);\n        node.y = maxY(children);\n      } else {\n        node.x = previousNode ? x += separation(node, previousNode) : 0;\n        node.y = 0;\n        previousNode = node;\n      }\n    });\n\n    var left = leafLeft(root),\n        right = leafRight(root),\n        x0 = left.x - separation(left, right) / 2,\n        x1 = right.x + separation(right, left) / 2;\n\n    // Second walk, normalizing x & y to the desired size.\n    return root.eachAfter(nodeSize ? function(node) {\n      node.x = (node.x - root.x) * dx;\n      node.y = (root.y - node.y) * dy;\n    } : function(node) {\n      node.x = (node.x - x0) / (x1 - x0) * dx;\n      node.y = (1 - (root.y ? node.y / root.y : 1)) * dy;\n    });\n  }\n\n  cluster.separation = function(x) {\n    return arguments.length ? (separation = x, cluster) : separation;\n  };\n\n  cluster.size = function(x) {\n    return arguments.length ? (nodeSize = false, dx = +x[0], dy = +x[1], cluster) : (nodeSize ? null : [dx, dy]);\n  };\n\n  cluster.nodeSize = function(x) {\n    return arguments.length ? (nodeSize = true, dx = +x[0], dy = +x[1], cluster) : (nodeSize ? [dx, dy] : null);\n  };\n\n  return cluster;\n};\n\nfunction count(node) {\n  var sum = 0,\n      children = node.children,\n      i = children && children.length;\n  if (!i) sum = 1;\n  else while (--i >= 0) sum += children[i].value;\n  node.value = sum;\n}\n\nvar node_count = function() {\n  return this.eachAfter(count);\n};\n\nvar node_each = function(callback) {\n  var node = this, current, next = [node], children, i, n;\n  do {\n    current = next.reverse(), next = [];\n    while (node = current.pop()) {\n      callback(node), children = node.children;\n      if (children) for (i = 0, n = children.length; i < n; ++i) {\n        next.push(children[i]);\n      }\n    }\n  } while (next.length);\n  return this;\n};\n\nvar node_eachBefore = function(callback) {\n  var node = this, nodes = [node], children, i;\n  while (node = nodes.pop()) {\n    callback(node), children = node.children;\n    if (children) for (i = children.length - 1; i >= 0; --i) {\n      nodes.push(children[i]);\n    }\n  }\n  return this;\n};\n\nvar node_eachAfter = function(callback) {\n  var node = this, nodes = [node], next = [], children, i, n;\n  while (node = nodes.pop()) {\n    next.push(node), children = node.children;\n    if (children) for (i = 0, n = children.length; i < n; ++i) {\n      nodes.push(children[i]);\n    }\n  }\n  while (node = next.pop()) {\n    callback(node);\n  }\n  return this;\n};\n\nvar node_sum = function(value) {\n  return this.eachAfter(function(node) {\n    var sum = +value(node.data) || 0,\n        children = node.children,\n        i = children && children.length;\n    while (--i >= 0) sum += children[i].value;\n    node.value = sum;\n  });\n};\n\nvar node_sort = function(compare) {\n  return this.eachBefore(function(node) {\n    if (node.children) {\n      node.children.sort(compare);\n    }\n  });\n};\n\nvar node_path = function(end) {\n  var start = this,\n      ancestor = leastCommonAncestor(start, end),\n      nodes = [start];\n  while (start !== ancestor) {\n    start = start.parent;\n    nodes.push(start);\n  }\n  var k = nodes.length;\n  while (end !== ancestor) {\n    nodes.splice(k, 0, end);\n    end = end.parent;\n  }\n  return nodes;\n};\n\nfunction leastCommonAncestor(a, b) {\n  if (a === b) return a;\n  var aNodes = a.ancestors(),\n      bNodes = b.ancestors(),\n      c = null;\n  a = aNodes.pop();\n  b = bNodes.pop();\n  while (a === b) {\n    c = a;\n    a = aNodes.pop();\n    b = bNodes.pop();\n  }\n  return c;\n}\n\nvar node_ancestors = function() {\n  var node = this, nodes = [node];\n  while (node = node.parent) {\n    nodes.push(node);\n  }\n  return nodes;\n};\n\nvar node_descendants = function() {\n  var nodes = [];\n  this.each(function(node) {\n    nodes.push(node);\n  });\n  return nodes;\n};\n\nvar node_leaves = function() {\n  var leaves = [];\n  this.eachBefore(function(node) {\n    if (!node.children) {\n      leaves.push(node);\n    }\n  });\n  return leaves;\n};\n\nvar node_links = function() {\n  var root = this, links = [];\n  root.each(function(node) {\n    if (node !== root) { // Don’t include the root’s parent, if any.\n      links.push({source: node.parent, target: node});\n    }\n  });\n  return links;\n};\n\nfunction hierarchy(data, children) {\n  var root = new Node(data),\n      valued = +data.value && (root.value = data.value),\n      node,\n      nodes = [root],\n      child,\n      childs,\n      i,\n      n;\n\n  if (children == null) children = defaultChildren;\n\n  while (node = nodes.pop()) {\n    if (valued) node.value = +node.data.value;\n    if ((childs = children(node.data)) && (n = childs.length)) {\n      node.children = new Array(n);\n      for (i = n - 1; i >= 0; --i) {\n        nodes.push(child = node.children[i] = new Node(childs[i]));\n        child.parent = node;\n        child.depth = node.depth + 1;\n      }\n    }\n  }\n\n  return root.eachBefore(computeHeight);\n}\n\nfunction node_copy() {\n  return hierarchy(this).eachBefore(copyData);\n}\n\nfunction defaultChildren(d) {\n  return d.children;\n}\n\nfunction copyData(node) {\n  node.data = node.data.data;\n}\n\nfunction computeHeight(node) {\n  var height = 0;\n  do node.height = height;\n  while ((node = node.parent) && (node.height < ++height));\n}\n\nfunction Node(data) {\n  this.data = data;\n  this.depth =\n  this.height = 0;\n  this.parent = null;\n}\n\nNode.prototype = hierarchy.prototype = {\n  constructor: Node,\n  count: node_count,\n  each: node_each,\n  eachAfter: node_eachAfter,\n  eachBefore: node_eachBefore,\n  sum: node_sum,\n  sort: node_sort,\n  path: node_path,\n  ancestors: node_ancestors,\n  descendants: node_descendants,\n  leaves: node_leaves,\n  links: node_links,\n  copy: node_copy\n};\n\nfunction Node$2(value) {\n  this._ = value;\n  this.next = null;\n}\n\nvar shuffle$1 = function(array) {\n  var i,\n      n = (array = array.slice()).length,\n      head = null,\n      node = head;\n\n  while (n) {\n    var next = new Node$2(array[n - 1]);\n    if (node) node = node.next = next;\n    else node = head = next;\n    array[i] = array[--n];\n  }\n\n  return {\n    head: head,\n    tail: node\n  };\n};\n\nvar enclose = function(circles) {\n  return encloseN(shuffle$1(circles), []);\n};\n\nfunction encloses(a, b) {\n  var dx = b.x - a.x,\n      dy = b.y - a.y,\n      dr = a.r - b.r;\n  return dr * dr + 1e-6 > dx * dx + dy * dy;\n}\n\n// Returns the smallest circle that contains circles L and intersects circles B.\nfunction encloseN(L, B) {\n  var circle,\n      l0 = null,\n      l1 = L.head,\n      l2,\n      p1;\n\n  switch (B.length) {\n    case 1: circle = enclose1(B[0]); break;\n    case 2: circle = enclose2(B[0], B[1]); break;\n    case 3: circle = enclose3(B[0], B[1], B[2]); break;\n  }\n\n  while (l1) {\n    p1 = l1._, l2 = l1.next;\n    if (!circle || !encloses(circle, p1)) {\n\n      // Temporarily truncate L before l1.\n      if (l0) L.tail = l0, l0.next = null;\n      else L.head = L.tail = null;\n\n      B.push(p1);\n      circle = encloseN(L, B); // Note: reorders L!\n      B.pop();\n\n      // Move l1 to the front of L and reconnect the truncated list L.\n      if (L.head) l1.next = L.head, L.head = l1;\n      else l1.next = null, L.head = L.tail = l1;\n      l0 = L.tail, l0.next = l2;\n\n    } else {\n      l0 = l1;\n    }\n    l1 = l2;\n  }\n\n  L.tail = l0;\n  return circle;\n}\n\nfunction enclose1(a) {\n  return {\n    x: a.x,\n    y: a.y,\n    r: a.r\n  };\n}\n\nfunction enclose2(a, b) {\n  var x1 = a.x, y1 = a.y, r1 = a.r,\n      x2 = b.x, y2 = b.y, r2 = b.r,\n      x21 = x2 - x1, y21 = y2 - y1, r21 = r2 - r1,\n      l = Math.sqrt(x21 * x21 + y21 * y21);\n  return {\n    x: (x1 + x2 + x21 / l * r21) / 2,\n    y: (y1 + y2 + y21 / l * r21) / 2,\n    r: (l + r1 + r2) / 2\n  };\n}\n\nfunction enclose3(a, b, c) {\n  var x1 = a.x, y1 = a.y, r1 = a.r,\n      x2 = b.x, y2 = b.y, r2 = b.r,\n      x3 = c.x, y3 = c.y, r3 = c.r,\n      a2 = 2 * (x1 - x2),\n      b2 = 2 * (y1 - y2),\n      c2 = 2 * (r2 - r1),\n      d2 = x1 * x1 + y1 * y1 - r1 * r1 - x2 * x2 - y2 * y2 + r2 * r2,\n      a3 = 2 * (x1 - x3),\n      b3 = 2 * (y1 - y3),\n      c3 = 2 * (r3 - r1),\n      d3 = x1 * x1 + y1 * y1 - r1 * r1 - x3 * x3 - y3 * y3 + r3 * r3,\n      ab = a3 * b2 - a2 * b3,\n      xa = (b2 * d3 - b3 * d2) / ab - x1,\n      xb = (b3 * c2 - b2 * c3) / ab,\n      ya = (a3 * d2 - a2 * d3) / ab - y1,\n      yb = (a2 * c3 - a3 * c2) / ab,\n      A = xb * xb + yb * yb - 1,\n      B = 2 * (xa * xb + ya * yb + r1),\n      C = xa * xa + ya * ya - r1 * r1,\n      r = (-B - Math.sqrt(B * B - 4 * A * C)) / (2 * A);\n  return {\n    x: xa + xb * r + x1,\n    y: ya + yb * r + y1,\n    r: r\n  };\n}\n\nfunction place(a, b, c) {\n  var ax = a.x,\n      ay = a.y,\n      da = b.r + c.r,\n      db = a.r + c.r,\n      dx = b.x - ax,\n      dy = b.y - ay,\n      dc = dx * dx + dy * dy;\n  if (dc) {\n    var x = 0.5 + ((db *= db) - (da *= da)) / (2 * dc),\n        y = Math.sqrt(Math.max(0, 2 * da * (db + dc) - (db -= dc) * db - da * da)) / (2 * dc);\n    c.x = ax + x * dx + y * dy;\n    c.y = ay + x * dy - y * dx;\n  } else {\n    c.x = ax + db;\n    c.y = ay;\n  }\n}\n\nfunction intersects(a, b) {\n  var dx = b.x - a.x,\n      dy = b.y - a.y,\n      dr = a.r + b.r;\n  return dr * dr - 1e-6 > dx * dx + dy * dy;\n}\n\nfunction distance1(a, b) {\n  var l = a._.r;\n  while (a !== b) l += 2 * (a = a.next)._.r;\n  return l - b._.r;\n}\n\nfunction distance2(node, x, y) {\n  var a = node._,\n      b = node.next._,\n      ab = a.r + b.r,\n      dx = (a.x * b.r + b.x * a.r) / ab - x,\n      dy = (a.y * b.r + b.y * a.r) / ab - y;\n  return dx * dx + dy * dy;\n}\n\nfunction Node$1(circle) {\n  this._ = circle;\n  this.next = null;\n  this.previous = null;\n}\n\nfunction packEnclose(circles) {\n  if (!(n = circles.length)) return 0;\n\n  var a, b, c, n;\n\n  // Place the first circle.\n  a = circles[0], a.x = 0, a.y = 0;\n  if (!(n > 1)) return a.r;\n\n  // Place the second circle.\n  b = circles[1], a.x = -b.r, b.x = a.r, b.y = 0;\n  if (!(n > 2)) return a.r + b.r;\n\n  // Place the third circle.\n  place(b, a, c = circles[2]);\n\n  // Initialize the weighted centroid.\n  var aa = a.r * a.r,\n      ba = b.r * b.r,\n      ca = c.r * c.r,\n      oa = aa + ba + ca,\n      ox = aa * a.x + ba * b.x + ca * c.x,\n      oy = aa * a.y + ba * b.y + ca * c.y,\n      cx, cy, i, j, k, sj, sk;\n\n  // Initialize the front-chain using the first three circles a, b and c.\n  a = new Node$1(a), b = new Node$1(b), c = new Node$1(c);\n  a.next = c.previous = b;\n  b.next = a.previous = c;\n  c.next = b.previous = a;\n\n  // Attempt to place each remaining circle…\n  pack: for (i = 3; i < n; ++i) {\n    place(a._, b._, c = circles[i]), c = new Node$1(c);\n\n    // Find the closest intersecting circle on the front-chain, if any.\n    // “Closeness” is determined by linear distance along the front-chain.\n    // “Ahead” or “behind” is likewise determined by linear distance.\n    j = b.next, k = a.previous, sj = b._.r, sk = a._.r;\n    do {\n      if (sj <= sk) {\n        if (intersects(j._, c._)) {\n          if (sj + a._.r + b._.r > distance1(j, b)) a = j; else b = j;\n          a.next = b, b.previous = a, --i;\n          continue pack;\n        }\n        sj += j._.r, j = j.next;\n      } else {\n        if (intersects(k._, c._)) {\n          if (distance1(a, k) > sk + a._.r + b._.r) a = k; else b = k;\n          a.next = b, b.previous = a, --i;\n          continue pack;\n        }\n        sk += k._.r, k = k.previous;\n      }\n    } while (j !== k.next);\n\n    // Success! Insert the new circle c between a and b.\n    c.previous = a, c.next = b, a.next = b.previous = b = c;\n\n    // Update the weighted centroid.\n    oa += ca = c._.r * c._.r;\n    ox += ca * c._.x;\n    oy += ca * c._.y;\n\n    // Compute the new closest circle pair to the centroid.\n    aa = distance2(a, cx = ox / oa, cy = oy / oa);\n    while ((c = c.next) !== b) {\n      if ((ca = distance2(c, cx, cy)) < aa) {\n        a = c, aa = ca;\n      }\n    }\n    b = a.next;\n  }\n\n  // Compute the enclosing circle of the front chain.\n  a = [b._], c = b; while ((c = c.next) !== b) a.push(c._); c = enclose(a);\n\n  // Translate the circles to put the enclosing circle around the origin.\n  for (i = 0; i < n; ++i) a = circles[i], a.x -= c.x, a.y -= c.y;\n\n  return c.r;\n}\n\nvar siblings = function(circles) {\n  packEnclose(circles);\n  return circles;\n};\n\nfunction optional(f) {\n  return f == null ? null : required(f);\n}\n\nfunction required(f) {\n  if (typeof f !== \"function\") throw new Error;\n  return f;\n}\n\nfunction constantZero() {\n  return 0;\n}\n\nvar constant$8 = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nfunction defaultRadius$1(d) {\n  return Math.sqrt(d.value);\n}\n\nvar index$2 = function() {\n  var radius = null,\n      dx = 1,\n      dy = 1,\n      padding = constantZero;\n\n  function pack(root) {\n    root.x = dx / 2, root.y = dy / 2;\n    if (radius) {\n      root.eachBefore(radiusLeaf(radius))\n          .eachAfter(packChildren(padding, 0.5))\n          .eachBefore(translateChild(1));\n    } else {\n      root.eachBefore(radiusLeaf(defaultRadius$1))\n          .eachAfter(packChildren(constantZero, 1))\n          .eachAfter(packChildren(padding, root.r / Math.min(dx, dy)))\n          .eachBefore(translateChild(Math.min(dx, dy) / (2 * root.r)));\n    }\n    return root;\n  }\n\n  pack.radius = function(x) {\n    return arguments.length ? (radius = optional(x), pack) : radius;\n  };\n\n  pack.size = function(x) {\n    return arguments.length ? (dx = +x[0], dy = +x[1], pack) : [dx, dy];\n  };\n\n  pack.padding = function(x) {\n    return arguments.length ? (padding = typeof x === \"function\" ? x : constant$8(+x), pack) : padding;\n  };\n\n  return pack;\n};\n\nfunction radiusLeaf(radius) {\n  return function(node) {\n    if (!node.children) {\n      node.r = Math.max(0, +radius(node) || 0);\n    }\n  };\n}\n\nfunction packChildren(padding, k) {\n  return function(node) {\n    if (children = node.children) {\n      var children,\n          i,\n          n = children.length,\n          r = padding(node) * k || 0,\n          e;\n\n      if (r) for (i = 0; i < n; ++i) children[i].r += r;\n      e = packEnclose(children);\n      if (r) for (i = 0; i < n; ++i) children[i].r -= r;\n      node.r = e + r;\n    }\n  };\n}\n\nfunction translateChild(k) {\n  return function(node) {\n    var parent = node.parent;\n    node.r *= k;\n    if (parent) {\n      node.x = parent.x + k * node.x;\n      node.y = parent.y + k * node.y;\n    }\n  };\n}\n\nvar roundNode = function(node) {\n  node.x0 = Math.round(node.x0);\n  node.y0 = Math.round(node.y0);\n  node.x1 = Math.round(node.x1);\n  node.y1 = Math.round(node.y1);\n};\n\nvar treemapDice = function(parent, x0, y0, x1, y1) {\n  var nodes = parent.children,\n      node,\n      i = -1,\n      n = nodes.length,\n      k = parent.value && (x1 - x0) / parent.value;\n\n  while (++i < n) {\n    node = nodes[i], node.y0 = y0, node.y1 = y1;\n    node.x0 = x0, node.x1 = x0 += node.value * k;\n  }\n};\n\nvar partition = function() {\n  var dx = 1,\n      dy = 1,\n      padding = 0,\n      round = false;\n\n  function partition(root) {\n    var n = root.height + 1;\n    root.x0 =\n    root.y0 = padding;\n    root.x1 = dx;\n    root.y1 = dy / n;\n    root.eachBefore(positionNode(dy, n));\n    if (round) root.eachBefore(roundNode);\n    return root;\n  }\n\n  function positionNode(dy, n) {\n    return function(node) {\n      if (node.children) {\n        treemapDice(node, node.x0, dy * (node.depth + 1) / n, node.x1, dy * (node.depth + 2) / n);\n      }\n      var x0 = node.x0,\n          y0 = node.y0,\n          x1 = node.x1 - padding,\n          y1 = node.y1 - padding;\n      if (x1 < x0) x0 = x1 = (x0 + x1) / 2;\n      if (y1 < y0) y0 = y1 = (y0 + y1) / 2;\n      node.x0 = x0;\n      node.y0 = y0;\n      node.x1 = x1;\n      node.y1 = y1;\n    };\n  }\n\n  partition.round = function(x) {\n    return arguments.length ? (round = !!x, partition) : round;\n  };\n\n  partition.size = function(x) {\n    return arguments.length ? (dx = +x[0], dy = +x[1], partition) : [dx, dy];\n  };\n\n  partition.padding = function(x) {\n    return arguments.length ? (padding = +x, partition) : padding;\n  };\n\n  return partition;\n};\n\nvar keyPrefix$1 = \"$\";\nvar preroot = {depth: -1};\nvar ambiguous = {};\n\nfunction defaultId(d) {\n  return d.id;\n}\n\nfunction defaultParentId(d) {\n  return d.parentId;\n}\n\nvar stratify = function() {\n  var id = defaultId,\n      parentId = defaultParentId;\n\n  function stratify(data) {\n    var d,\n        i,\n        n = data.length,\n        root,\n        parent,\n        node,\n        nodes = new Array(n),\n        nodeId,\n        nodeKey,\n        nodeByKey = {};\n\n    for (i = 0; i < n; ++i) {\n      d = data[i], node = nodes[i] = new Node(d);\n      if ((nodeId = id(d, i, data)) != null && (nodeId += \"\")) {\n        nodeKey = keyPrefix$1 + (node.id = nodeId);\n        nodeByKey[nodeKey] = nodeKey in nodeByKey ? ambiguous : node;\n      }\n    }\n\n    for (i = 0; i < n; ++i) {\n      node = nodes[i], nodeId = parentId(data[i], i, data);\n      if (nodeId == null || !(nodeId += \"\")) {\n        if (root) throw new Error(\"multiple roots\");\n        root = node;\n      } else {\n        parent = nodeByKey[keyPrefix$1 + nodeId];\n        if (!parent) throw new Error(\"missing: \" + nodeId);\n        if (parent === ambiguous) throw new Error(\"ambiguous: \" + nodeId);\n        if (parent.children) parent.children.push(node);\n        else parent.children = [node];\n        node.parent = parent;\n      }\n    }\n\n    if (!root) throw new Error(\"no root\");\n    root.parent = preroot;\n    root.eachBefore(function(node) { node.depth = node.parent.depth + 1; --n; }).eachBefore(computeHeight);\n    root.parent = null;\n    if (n > 0) throw new Error(\"cycle\");\n\n    return root;\n  }\n\n  stratify.id = function(x) {\n    return arguments.length ? (id = required(x), stratify) : id;\n  };\n\n  stratify.parentId = function(x) {\n    return arguments.length ? (parentId = required(x), stratify) : parentId;\n  };\n\n  return stratify;\n};\n\nfunction defaultSeparation$1(a, b) {\n  return a.parent === b.parent ? 1 : 2;\n}\n\n// function radialSeparation(a, b) {\n//   return (a.parent === b.parent ? 1 : 2) / a.depth;\n// }\n\n// This function is used to traverse the left contour of a subtree (or\n// subforest). It returns the successor of v on this contour. This successor is\n// either given by the leftmost child of v or by the thread of v. The function\n// returns null if and only if v is on the highest level of its subtree.\nfunction nextLeft(v) {\n  var children = v.children;\n  return children ? children[0] : v.t;\n}\n\n// This function works analogously to nextLeft.\nfunction nextRight(v) {\n  var children = v.children;\n  return children ? children[children.length - 1] : v.t;\n}\n\n// Shifts the current subtree rooted at w+. This is done by increasing\n// prelim(w+) and mod(w+) by shift.\nfunction moveSubtree(wm, wp, shift) {\n  var change = shift / (wp.i - wm.i);\n  wp.c -= change;\n  wp.s += shift;\n  wm.c += change;\n  wp.z += shift;\n  wp.m += shift;\n}\n\n// All other shifts, applied to the smaller subtrees between w- and w+, are\n// performed by this function. To prepare the shifts, we have to adjust\n// change(w+), shift(w+), and change(w-).\nfunction executeShifts(v) {\n  var shift = 0,\n      change = 0,\n      children = v.children,\n      i = children.length,\n      w;\n  while (--i >= 0) {\n    w = children[i];\n    w.z += shift;\n    w.m += shift;\n    shift += w.s + (change += w.c);\n  }\n}\n\n// If vi-’s ancestor is a sibling of v, returns vi-’s ancestor. Otherwise,\n// returns the specified (default) ancestor.\nfunction nextAncestor(vim, v, ancestor) {\n  return vim.a.parent === v.parent ? vim.a : ancestor;\n}\n\nfunction TreeNode(node, i) {\n  this._ = node;\n  this.parent = null;\n  this.children = null;\n  this.A = null; // default ancestor\n  this.a = this; // ancestor\n  this.z = 0; // prelim\n  this.m = 0; // mod\n  this.c = 0; // change\n  this.s = 0; // shift\n  this.t = null; // thread\n  this.i = i; // number\n}\n\nTreeNode.prototype = Object.create(Node.prototype);\n\nfunction treeRoot(root) {\n  var tree = new TreeNode(root, 0),\n      node,\n      nodes = [tree],\n      child,\n      children,\n      i,\n      n;\n\n  while (node = nodes.pop()) {\n    if (children = node._.children) {\n      node.children = new Array(n = children.length);\n      for (i = n - 1; i >= 0; --i) {\n        nodes.push(child = node.children[i] = new TreeNode(children[i], i));\n        child.parent = node;\n      }\n    }\n  }\n\n  (tree.parent = new TreeNode(null, 0)).children = [tree];\n  return tree;\n}\n\n// Node-link tree diagram using the Reingold-Tilford \"tidy\" algorithm\nvar tree = function() {\n  var separation = defaultSeparation$1,\n      dx = 1,\n      dy = 1,\n      nodeSize = null;\n\n  function tree(root) {\n    var t = treeRoot(root);\n\n    // Compute the layout using Buchheim et al.’s algorithm.\n    t.eachAfter(firstWalk), t.parent.m = -t.z;\n    t.eachBefore(secondWalk);\n\n    // If a fixed node size is specified, scale x and y.\n    if (nodeSize) root.eachBefore(sizeNode);\n\n    // If a fixed tree size is specified, scale x and y based on the extent.\n    // Compute the left-most, right-most, and depth-most nodes for extents.\n    else {\n      var left = root,\n          right = root,\n          bottom = root;\n      root.eachBefore(function(node) {\n        if (node.x < left.x) left = node;\n        if (node.x > right.x) right = node;\n        if (node.depth > bottom.depth) bottom = node;\n      });\n      var s = left === right ? 1 : separation(left, right) / 2,\n          tx = s - left.x,\n          kx = dx / (right.x + s + tx),\n          ky = dy / (bottom.depth || 1);\n      root.eachBefore(function(node) {\n        node.x = (node.x + tx) * kx;\n        node.y = node.depth * ky;\n      });\n    }\n\n    return root;\n  }\n\n  // Computes a preliminary x-coordinate for v. Before that, FIRST WALK is\n  // applied recursively to the children of v, as well as the function\n  // APPORTION. After spacing out the children by calling EXECUTE SHIFTS, the\n  // node v is placed to the midpoint of its outermost children.\n  function firstWalk(v) {\n    var children = v.children,\n        siblings = v.parent.children,\n        w = v.i ? siblings[v.i - 1] : null;\n    if (children) {\n      executeShifts(v);\n      var midpoint = (children[0].z + children[children.length - 1].z) / 2;\n      if (w) {\n        v.z = w.z + separation(v._, w._);\n        v.m = v.z - midpoint;\n      } else {\n        v.z = midpoint;\n      }\n    } else if (w) {\n      v.z = w.z + separation(v._, w._);\n    }\n    v.parent.A = apportion(v, w, v.parent.A || siblings[0]);\n  }\n\n  // Computes all real x-coordinates by summing up the modifiers recursively.\n  function secondWalk(v) {\n    v._.x = v.z + v.parent.m;\n    v.m += v.parent.m;\n  }\n\n  // The core of the algorithm. Here, a new subtree is combined with the\n  // previous subtrees. Threads are used to traverse the inside and outside\n  // contours of the left and right subtree up to the highest common level. The\n  // vertices used for the traversals are vi+, vi-, vo-, and vo+, where the\n  // superscript o means outside and i means inside, the subscript - means left\n  // subtree and + means right subtree. For summing up the modifiers along the\n  // contour, we use respective variables si+, si-, so-, and so+. Whenever two\n  // nodes of the inside contours conflict, we compute the left one of the\n  // greatest uncommon ancestors using the function ANCESTOR and call MOVE\n  // SUBTREE to shift the subtree and prepare the shifts of smaller subtrees.\n  // Finally, we add a new thread (if necessary).\n  function apportion(v, w, ancestor) {\n    if (w) {\n      var vip = v,\n          vop = v,\n          vim = w,\n          vom = vip.parent.children[0],\n          sip = vip.m,\n          sop = vop.m,\n          sim = vim.m,\n          som = vom.m,\n          shift;\n      while (vim = nextRight(vim), vip = nextLeft(vip), vim && vip) {\n        vom = nextLeft(vom);\n        vop = nextRight(vop);\n        vop.a = v;\n        shift = vim.z + sim - vip.z - sip + separation(vim._, vip._);\n        if (shift > 0) {\n          moveSubtree(nextAncestor(vim, v, ancestor), v, shift);\n          sip += shift;\n          sop += shift;\n        }\n        sim += vim.m;\n        sip += vip.m;\n        som += vom.m;\n        sop += vop.m;\n      }\n      if (vim && !nextRight(vop)) {\n        vop.t = vim;\n        vop.m += sim - sop;\n      }\n      if (vip && !nextLeft(vom)) {\n        vom.t = vip;\n        vom.m += sip - som;\n        ancestor = v;\n      }\n    }\n    return ancestor;\n  }\n\n  function sizeNode(node) {\n    node.x *= dx;\n    node.y = node.depth * dy;\n  }\n\n  tree.separation = function(x) {\n    return arguments.length ? (separation = x, tree) : separation;\n  };\n\n  tree.size = function(x) {\n    return arguments.length ? (nodeSize = false, dx = +x[0], dy = +x[1], tree) : (nodeSize ? null : [dx, dy]);\n  };\n\n  tree.nodeSize = function(x) {\n    return arguments.length ? (nodeSize = true, dx = +x[0], dy = +x[1], tree) : (nodeSize ? [dx, dy] : null);\n  };\n\n  return tree;\n};\n\nvar treemapSlice = function(parent, x0, y0, x1, y1) {\n  var nodes = parent.children,\n      node,\n      i = -1,\n      n = nodes.length,\n      k = parent.value && (y1 - y0) / parent.value;\n\n  while (++i < n) {\n    node = nodes[i], node.x0 = x0, node.x1 = x1;\n    node.y0 = y0, node.y1 = y0 += node.value * k;\n  }\n};\n\nvar phi = (1 + Math.sqrt(5)) / 2;\n\nfunction squarifyRatio(ratio, parent, x0, y0, x1, y1) {\n  var rows = [],\n      nodes = parent.children,\n      row,\n      nodeValue,\n      i0 = 0,\n      i1 = 0,\n      n = nodes.length,\n      dx, dy,\n      value = parent.value,\n      sumValue,\n      minValue,\n      maxValue,\n      newRatio,\n      minRatio,\n      alpha,\n      beta;\n\n  while (i0 < n) {\n    dx = x1 - x0, dy = y1 - y0;\n\n    // Find the next non-empty node.\n    do sumValue = nodes[i1++].value; while (!sumValue && i1 < n);\n    minValue = maxValue = sumValue;\n    alpha = Math.max(dy / dx, dx / dy) / (value * ratio);\n    beta = sumValue * sumValue * alpha;\n    minRatio = Math.max(maxValue / beta, beta / minValue);\n\n    // Keep adding nodes while the aspect ratio maintains or improves.\n    for (; i1 < n; ++i1) {\n      sumValue += nodeValue = nodes[i1].value;\n      if (nodeValue < minValue) minValue = nodeValue;\n      if (nodeValue > maxValue) maxValue = nodeValue;\n      beta = sumValue * sumValue * alpha;\n      newRatio = Math.max(maxValue / beta, beta / minValue);\n      if (newRatio > minRatio) { sumValue -= nodeValue; break; }\n      minRatio = newRatio;\n    }\n\n    // Position and record the row orientation.\n    rows.push(row = {value: sumValue, dice: dx < dy, children: nodes.slice(i0, i1)});\n    if (row.dice) treemapDice(row, x0, y0, x1, value ? y0 += dy * sumValue / value : y1);\n    else treemapSlice(row, x0, y0, value ? x0 += dx * sumValue / value : x1, y1);\n    value -= sumValue, i0 = i1;\n  }\n\n  return rows;\n}\n\nvar squarify = ((function custom(ratio) {\n\n  function squarify(parent, x0, y0, x1, y1) {\n    squarifyRatio(ratio, parent, x0, y0, x1, y1);\n  }\n\n  squarify.ratio = function(x) {\n    return custom((x = +x) > 1 ? x : 1);\n  };\n\n  return squarify;\n}))(phi);\n\nvar index$3 = function() {\n  var tile = squarify,\n      round = false,\n      dx = 1,\n      dy = 1,\n      paddingStack = [0],\n      paddingInner = constantZero,\n      paddingTop = constantZero,\n      paddingRight = constantZero,\n      paddingBottom = constantZero,\n      paddingLeft = constantZero;\n\n  function treemap(root) {\n    root.x0 =\n    root.y0 = 0;\n    root.x1 = dx;\n    root.y1 = dy;\n    root.eachBefore(positionNode);\n    paddingStack = [0];\n    if (round) root.eachBefore(roundNode);\n    return root;\n  }\n\n  function positionNode(node) {\n    var p = paddingStack[node.depth],\n        x0 = node.x0 + p,\n        y0 = node.y0 + p,\n        x1 = node.x1 - p,\n        y1 = node.y1 - p;\n    if (x1 < x0) x0 = x1 = (x0 + x1) / 2;\n    if (y1 < y0) y0 = y1 = (y0 + y1) / 2;\n    node.x0 = x0;\n    node.y0 = y0;\n    node.x1 = x1;\n    node.y1 = y1;\n    if (node.children) {\n      p = paddingStack[node.depth + 1] = paddingInner(node) / 2;\n      x0 += paddingLeft(node) - p;\n      y0 += paddingTop(node) - p;\n      x1 -= paddingRight(node) - p;\n      y1 -= paddingBottom(node) - p;\n      if (x1 < x0) x0 = x1 = (x0 + x1) / 2;\n      if (y1 < y0) y0 = y1 = (y0 + y1) / 2;\n      tile(node, x0, y0, x1, y1);\n    }\n  }\n\n  treemap.round = function(x) {\n    return arguments.length ? (round = !!x, treemap) : round;\n  };\n\n  treemap.size = function(x) {\n    return arguments.length ? (dx = +x[0], dy = +x[1], treemap) : [dx, dy];\n  };\n\n  treemap.tile = function(x) {\n    return arguments.length ? (tile = required(x), treemap) : tile;\n  };\n\n  treemap.padding = function(x) {\n    return arguments.length ? treemap.paddingInner(x).paddingOuter(x) : treemap.paddingInner();\n  };\n\n  treemap.paddingInner = function(x) {\n    return arguments.length ? (paddingInner = typeof x === \"function\" ? x : constant$8(+x), treemap) : paddingInner;\n  };\n\n  treemap.paddingOuter = function(x) {\n    return arguments.length ? treemap.paddingTop(x).paddingRight(x).paddingBottom(x).paddingLeft(x) : treemap.paddingTop();\n  };\n\n  treemap.paddingTop = function(x) {\n    return arguments.length ? (paddingTop = typeof x === \"function\" ? x : constant$8(+x), treemap) : paddingTop;\n  };\n\n  treemap.paddingRight = function(x) {\n    return arguments.length ? (paddingRight = typeof x === \"function\" ? x : constant$8(+x), treemap) : paddingRight;\n  };\n\n  treemap.paddingBottom = function(x) {\n    return arguments.length ? (paddingBottom = typeof x === \"function\" ? x : constant$8(+x), treemap) : paddingBottom;\n  };\n\n  treemap.paddingLeft = function(x) {\n    return arguments.length ? (paddingLeft = typeof x === \"function\" ? x : constant$8(+x), treemap) : paddingLeft;\n  };\n\n  return treemap;\n};\n\nvar binary = function(parent, x0, y0, x1, y1) {\n  var nodes = parent.children,\n      i, n = nodes.length,\n      sum, sums = new Array(n + 1);\n\n  for (sums[0] = sum = i = 0; i < n; ++i) {\n    sums[i + 1] = sum += nodes[i].value;\n  }\n\n  partition(0, n, parent.value, x0, y0, x1, y1);\n\n  function partition(i, j, value, x0, y0, x1, y1) {\n    if (i >= j - 1) {\n      var node = nodes[i];\n      node.x0 = x0, node.y0 = y0;\n      node.x1 = x1, node.y1 = y1;\n      return;\n    }\n\n    var valueOffset = sums[i],\n        valueTarget = (value / 2) + valueOffset,\n        k = i + 1,\n        hi = j - 1;\n\n    while (k < hi) {\n      var mid = k + hi >>> 1;\n      if (sums[mid] < valueTarget) k = mid + 1;\n      else hi = mid;\n    }\n\n    var valueLeft = sums[k] - valueOffset,\n        valueRight = value - valueLeft;\n\n    if ((y1 - y0) > (x1 - x0)) {\n      var yk = (y0 * valueRight + y1 * valueLeft) / value;\n      partition(i, k, valueLeft, x0, y0, x1, yk);\n      partition(k, j, valueRight, x0, yk, x1, y1);\n    } else {\n      var xk = (x0 * valueRight + x1 * valueLeft) / value;\n      partition(i, k, valueLeft, x0, y0, xk, y1);\n      partition(k, j, valueRight, xk, y0, x1, y1);\n    }\n  }\n};\n\nvar sliceDice = function(parent, x0, y0, x1, y1) {\n  (parent.depth & 1 ? treemapSlice : treemapDice)(parent, x0, y0, x1, y1);\n};\n\nvar resquarify = ((function custom(ratio) {\n\n  function resquarify(parent, x0, y0, x1, y1) {\n    if ((rows = parent._squarify) && (rows.ratio === ratio)) {\n      var rows,\n          row,\n          nodes,\n          i,\n          j = -1,\n          n,\n          m = rows.length,\n          value = parent.value;\n\n      while (++j < m) {\n        row = rows[j], nodes = row.children;\n        for (i = row.value = 0, n = nodes.length; i < n; ++i) row.value += nodes[i].value;\n        if (row.dice) treemapDice(row, x0, y0, x1, y0 += (y1 - y0) * row.value / value);\n        else treemapSlice(row, x0, y0, x0 += (x1 - x0) * row.value / value, y1);\n        value -= row.value;\n      }\n    } else {\n      parent._squarify = rows = squarifyRatio(ratio, parent, x0, y0, x1, y1);\n      rows.ratio = ratio;\n    }\n  }\n\n  resquarify.ratio = function(x) {\n    return custom((x = +x) > 1 ? x : 1);\n  };\n\n  return resquarify;\n}))(phi);\n\nvar area$1 = function(polygon) {\n  var i = -1,\n      n = polygon.length,\n      a,\n      b = polygon[n - 1],\n      area = 0;\n\n  while (++i < n) {\n    a = b;\n    b = polygon[i];\n    area += a[1] * b[0] - a[0] * b[1];\n  }\n\n  return area / 2;\n};\n\nvar centroid$1 = function(polygon) {\n  var i = -1,\n      n = polygon.length,\n      x = 0,\n      y = 0,\n      a,\n      b = polygon[n - 1],\n      c,\n      k = 0;\n\n  while (++i < n) {\n    a = b;\n    b = polygon[i];\n    k += c = a[0] * b[1] - b[0] * a[1];\n    x += (a[0] + b[0]) * c;\n    y += (a[1] + b[1]) * c;\n  }\n\n  return k *= 3, [x / k, y / k];\n};\n\n// Returns the 2D cross product of AB and AC vectors, i.e., the z-component of\n// the 3D cross product in a quadrant I Cartesian coordinate system (+x is\n// right, +y is up). Returns a positive value if ABC is counter-clockwise,\n// negative if clockwise, and zero if the points are collinear.\nvar cross = function(a, b, c) {\n  return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);\n};\n\nfunction lexicographicOrder(a, b) {\n  return a[0] - b[0] || a[1] - b[1];\n}\n\n// Computes the upper convex hull per the monotone chain algorithm.\n// Assumes points.length >= 3, is sorted by x, unique in y.\n// Returns an array of indices into points in left-to-right order.\nfunction computeUpperHullIndexes(points) {\n  var n = points.length,\n      indexes = [0, 1],\n      size = 2;\n\n  for (var i = 2; i < n; ++i) {\n    while (size > 1 && cross(points[indexes[size - 2]], points[indexes[size - 1]], points[i]) <= 0) --size;\n    indexes[size++] = i;\n  }\n\n  return indexes.slice(0, size); // remove popped points\n}\n\nvar hull = function(points) {\n  if ((n = points.length) < 3) return null;\n\n  var i,\n      n,\n      sortedPoints = new Array(n),\n      flippedPoints = new Array(n);\n\n  for (i = 0; i < n; ++i) sortedPoints[i] = [+points[i][0], +points[i][1], i];\n  sortedPoints.sort(lexicographicOrder);\n  for (i = 0; i < n; ++i) flippedPoints[i] = [sortedPoints[i][0], -sortedPoints[i][1]];\n\n  var upperIndexes = computeUpperHullIndexes(sortedPoints),\n      lowerIndexes = computeUpperHullIndexes(flippedPoints);\n\n  // Construct the hull polygon, removing possible duplicate endpoints.\n  var skipLeft = lowerIndexes[0] === upperIndexes[0],\n      skipRight = lowerIndexes[lowerIndexes.length - 1] === upperIndexes[upperIndexes.length - 1],\n      hull = [];\n\n  // Add upper hull in right-to-l order.\n  // Then add lower hull in left-to-right order.\n  for (i = upperIndexes.length - 1; i >= 0; --i) hull.push(points[sortedPoints[upperIndexes[i]][2]]);\n  for (i = +skipLeft; i < lowerIndexes.length - skipRight; ++i) hull.push(points[sortedPoints[lowerIndexes[i]][2]]);\n\n  return hull;\n};\n\nvar contains = function(polygon, point) {\n  var n = polygon.length,\n      p = polygon[n - 1],\n      x = point[0], y = point[1],\n      x0 = p[0], y0 = p[1],\n      x1, y1,\n      inside = false;\n\n  for (var i = 0; i < n; ++i) {\n    p = polygon[i], x1 = p[0], y1 = p[1];\n    if (((y1 > y) !== (y0 > y)) && (x < (x0 - x1) * (y - y1) / (y0 - y1) + x1)) inside = !inside;\n    x0 = x1, y0 = y1;\n  }\n\n  return inside;\n};\n\nvar length$2 = function(polygon) {\n  var i = -1,\n      n = polygon.length,\n      b = polygon[n - 1],\n      xa,\n      ya,\n      xb = b[0],\n      yb = b[1],\n      perimeter = 0;\n\n  while (++i < n) {\n    xa = xb;\n    ya = yb;\n    b = polygon[i];\n    xb = b[0];\n    yb = b[1];\n    xa -= xb;\n    ya -= yb;\n    perimeter += Math.sqrt(xa * xa + ya * ya);\n  }\n\n  return perimeter;\n};\n\nvar slice$3 = [].slice;\n\nvar noabort = {};\n\nfunction Queue(size) {\n  if (!(size >= 1)) throw new Error;\n  this._size = size;\n  this._call =\n  this._error = null;\n  this._tasks = [];\n  this._data = [];\n  this._waiting =\n  this._active =\n  this._ended =\n  this._start = 0; // inside a synchronous task callback?\n}\n\nQueue.prototype = queue.prototype = {\n  constructor: Queue,\n  defer: function(callback) {\n    if (typeof callback !== \"function\" || this._call) throw new Error;\n    if (this._error != null) return this;\n    var t = slice$3.call(arguments, 1);\n    t.push(callback);\n    ++this._waiting, this._tasks.push(t);\n    poke$1(this);\n    return this;\n  },\n  abort: function() {\n    if (this._error == null) abort(this, new Error(\"abort\"));\n    return this;\n  },\n  await: function(callback) {\n    if (typeof callback !== \"function\" || this._call) throw new Error;\n    this._call = function(error, results) { callback.apply(null, [error].concat(results)); };\n    maybeNotify(this);\n    return this;\n  },\n  awaitAll: function(callback) {\n    if (typeof callback !== \"function\" || this._call) throw new Error;\n    this._call = callback;\n    maybeNotify(this);\n    return this;\n  }\n};\n\nfunction poke$1(q) {\n  if (!q._start) {\n    try { start$1(q); } // let the current task complete\n    catch (e) {\n      if (q._tasks[q._ended + q._active - 1]) abort(q, e); // task errored synchronously\n      else if (!q._data) throw e; // await callback errored synchronously\n    }\n  }\n}\n\nfunction start$1(q) {\n  while (q._start = q._waiting && q._active < q._size) {\n    var i = q._ended + q._active,\n        t = q._tasks[i],\n        j = t.length - 1,\n        c = t[j];\n    t[j] = end(q, i);\n    --q._waiting, ++q._active;\n    t = c.apply(null, t);\n    if (!q._tasks[i]) continue; // task finished synchronously\n    q._tasks[i] = t || noabort;\n  }\n}\n\nfunction end(q, i) {\n  return function(e, r) {\n    if (!q._tasks[i]) return; // ignore multiple callbacks\n    --q._active, ++q._ended;\n    q._tasks[i] = null;\n    if (q._error != null) return; // ignore secondary errors\n    if (e != null) {\n      abort(q, e);\n    } else {\n      q._data[i] = r;\n      if (q._waiting) poke$1(q);\n      else maybeNotify(q);\n    }\n  };\n}\n\nfunction abort(q, e) {\n  var i = q._tasks.length, t;\n  q._error = e; // ignore active callbacks\n  q._data = undefined; // allow gc\n  q._waiting = NaN; // prevent starting\n\n  while (--i >= 0) {\n    if (t = q._tasks[i]) {\n      q._tasks[i] = null;\n      if (t.abort) {\n        try { t.abort(); }\n        catch (e) { /* ignore */ }\n      }\n    }\n  }\n\n  q._active = NaN; // allow notification\n  maybeNotify(q);\n}\n\nfunction maybeNotify(q) {\n  if (!q._active && q._call) {\n    var d = q._data;\n    q._data = undefined; // allow gc\n    q._call(q._error, d);\n  }\n}\n\nfunction queue(concurrency) {\n  return new Queue(arguments.length ? +concurrency : Infinity);\n}\n\nvar uniform = function(min, max) {\n  min = min == null ? 0 : +min;\n  max = max == null ? 1 : +max;\n  if (arguments.length === 1) max = min, min = 0;\n  else max -= min;\n  return function() {\n    return Math.random() * max + min;\n  };\n};\n\nvar normal = function(mu, sigma) {\n  var x, r;\n  mu = mu == null ? 0 : +mu;\n  sigma = sigma == null ? 1 : +sigma;\n  return function() {\n    var y;\n\n    // If available, use the second previously-generated uniform random.\n    if (x != null) y = x, x = null;\n\n    // Otherwise, generate a new x and y.\n    else do {\n      x = Math.random() * 2 - 1;\n      y = Math.random() * 2 - 1;\n      r = x * x + y * y;\n    } while (!r || r > 1);\n\n    return mu + sigma * y * Math.sqrt(-2 * Math.log(r) / r);\n  };\n};\n\nvar logNormal = function() {\n  var randomNormal = normal.apply(this, arguments);\n  return function() {\n    return Math.exp(randomNormal());\n  };\n};\n\nvar irwinHall = function(n) {\n  return function() {\n    for (var sum = 0, i = 0; i < n; ++i) sum += Math.random();\n    return sum;\n  };\n};\n\nvar bates = function(n) {\n  var randomIrwinHall = irwinHall(n);\n  return function() {\n    return randomIrwinHall() / n;\n  };\n};\n\nvar exponential$1 = function(lambda) {\n  return function() {\n    return -Math.log(1 - Math.random()) / lambda;\n  };\n};\n\nvar request = function(url, callback) {\n  var request,\n      event = dispatch(\"beforesend\", \"progress\", \"load\", \"error\"),\n      mimeType,\n      headers = map$1(),\n      xhr = new XMLHttpRequest,\n      user = null,\n      password = null,\n      response,\n      responseType,\n      timeout = 0;\n\n  // If IE does not support CORS, use XDomainRequest.\n  if (typeof XDomainRequest !== \"undefined\"\n      && !(\"withCredentials\" in xhr)\n      && /^(http(s)?:)?\\/\\//.test(url)) xhr = new XDomainRequest;\n\n  \"onload\" in xhr\n      ? xhr.onload = xhr.onerror = xhr.ontimeout = respond\n      : xhr.onreadystatechange = function(o) { xhr.readyState > 3 && respond(o); };\n\n  function respond(o) {\n    var status = xhr.status, result;\n    if (!status && hasResponse(xhr)\n        || status >= 200 && status < 300\n        || status === 304) {\n      if (response) {\n        try {\n          result = response.call(request, xhr);\n        } catch (e) {\n          event.call(\"error\", request, e);\n          return;\n        }\n      } else {\n        result = xhr;\n      }\n      event.call(\"load\", request, result);\n    } else {\n      event.call(\"error\", request, o);\n    }\n  }\n\n  xhr.onprogress = function(e) {\n    event.call(\"progress\", request, e);\n  };\n\n  request = {\n    header: function(name, value) {\n      name = (name + \"\").toLowerCase();\n      if (arguments.length < 2) return headers.get(name);\n      if (value == null) headers.remove(name);\n      else headers.set(name, value + \"\");\n      return request;\n    },\n\n    // If mimeType is non-null and no Accept header is set, a default is used.\n    mimeType: function(value) {\n      if (!arguments.length) return mimeType;\n      mimeType = value == null ? null : value + \"\";\n      return request;\n    },\n\n    // Specifies what type the response value should take;\n    // for instance, arraybuffer, blob, document, or text.\n    responseType: function(value) {\n      if (!arguments.length) return responseType;\n      responseType = value;\n      return request;\n    },\n\n    timeout: function(value) {\n      if (!arguments.length) return timeout;\n      timeout = +value;\n      return request;\n    },\n\n    user: function(value) {\n      return arguments.length < 1 ? user : (user = value == null ? null : value + \"\", request);\n    },\n\n    password: function(value) {\n      return arguments.length < 1 ? password : (password = value == null ? null : value + \"\", request);\n    },\n\n    // Specify how to convert the response content to a specific type;\n    // changes the callback value on \"load\" events.\n    response: function(value) {\n      response = value;\n      return request;\n    },\n\n    // Alias for send(\"GET\", …).\n    get: function(data, callback) {\n      return request.send(\"GET\", data, callback);\n    },\n\n    // Alias for send(\"POST\", …).\n    post: function(data, callback) {\n      return request.send(\"POST\", data, callback);\n    },\n\n    // If callback is non-null, it will be used for error and load events.\n    send: function(method, data, callback) {\n      xhr.open(method, url, true, user, password);\n      if (mimeType != null && !headers.has(\"accept\")) headers.set(\"accept\", mimeType + \",*/*\");\n      if (xhr.setRequestHeader) headers.each(function(value, name) { xhr.setRequestHeader(name, value); });\n      if (mimeType != null && xhr.overrideMimeType) xhr.overrideMimeType(mimeType);\n      if (responseType != null) xhr.responseType = responseType;\n      if (timeout > 0) xhr.timeout = timeout;\n      if (callback == null && typeof data === \"function\") callback = data, data = null;\n      if (callback != null && callback.length === 1) callback = fixCallback(callback);\n      if (callback != null) request.on(\"error\", callback).on(\"load\", function(xhr) { callback(null, xhr); });\n      event.call(\"beforesend\", request, xhr);\n      xhr.send(data == null ? null : data);\n      return request;\n    },\n\n    abort: function() {\n      xhr.abort();\n      return request;\n    },\n\n    on: function() {\n      var value = event.on.apply(event, arguments);\n      return value === event ? request : value;\n    }\n  };\n\n  if (callback != null) {\n    if (typeof callback !== \"function\") throw new Error(\"invalid callback: \" + callback);\n    return request.get(callback);\n  }\n\n  return request;\n};\n\nfunction fixCallback(callback) {\n  return function(error, xhr) {\n    callback(error == null ? xhr : null);\n  };\n}\n\nfunction hasResponse(xhr) {\n  var type = xhr.responseType;\n  return type && type !== \"text\"\n      ? xhr.response // null on error\n      : xhr.responseText; // \"\" on error\n}\n\nvar type$1 = function(defaultMimeType, response) {\n  return function(url, callback) {\n    var r = request(url).mimeType(defaultMimeType).response(response);\n    if (callback != null) {\n      if (typeof callback !== \"function\") throw new Error(\"invalid callback: \" + callback);\n      return r.get(callback);\n    }\n    return r;\n  };\n};\n\nvar html = type$1(\"text/html\", function(xhr) {\n  return document.createRange().createContextualFragment(xhr.responseText);\n});\n\nvar json = type$1(\"application/json\", function(xhr) {\n  return JSON.parse(xhr.responseText);\n});\n\nvar text = type$1(\"text/plain\", function(xhr) {\n  return xhr.responseText;\n});\n\nvar xml = type$1(\"application/xml\", function(xhr) {\n  var xml = xhr.responseXML;\n  if (!xml) throw new Error(\"parse error\");\n  return xml;\n});\n\nvar dsv$1 = function(defaultMimeType, parse) {\n  return function(url, row, callback) {\n    if (arguments.length < 3) callback = row, row = null;\n    var r = request(url).mimeType(defaultMimeType);\n    r.row = function(_) { return arguments.length ? r.response(responseOf(parse, row = _)) : row; };\n    r.row(row);\n    return callback ? r.get(callback) : r;\n  };\n};\n\nfunction responseOf(parse, row) {\n  return function(request$$1) {\n    return parse(request$$1.responseText, row);\n  };\n}\n\nvar csv$1 = dsv$1(\"text/csv\", csvParse);\n\nvar tsv$1 = dsv$1(\"text/tab-separated-values\", tsvParse);\n\nvar array$2 = Array.prototype;\n\nvar map$3 = array$2.map;\nvar slice$4 = array$2.slice;\n\nvar implicit = {name: \"implicit\"};\n\nfunction ordinal(range) {\n  var index = map$1(),\n      domain = [],\n      unknown = implicit;\n\n  range = range == null ? [] : slice$4.call(range);\n\n  function scale(d) {\n    var key = d + \"\", i = index.get(key);\n    if (!i) {\n      if (unknown !== implicit) return unknown;\n      index.set(key, i = domain.push(d));\n    }\n    return range[(i - 1) % range.length];\n  }\n\n  scale.domain = function(_) {\n    if (!arguments.length) return domain.slice();\n    domain = [], index = map$1();\n    var i = -1, n = _.length, d, key;\n    while (++i < n) if (!index.has(key = (d = _[i]) + \"\")) index.set(key, domain.push(d));\n    return scale;\n  };\n\n  scale.range = function(_) {\n    return arguments.length ? (range = slice$4.call(_), scale) : range.slice();\n  };\n\n  scale.unknown = function(_) {\n    return arguments.length ? (unknown = _, scale) : unknown;\n  };\n\n  scale.copy = function() {\n    return ordinal()\n        .domain(domain)\n        .range(range)\n        .unknown(unknown);\n  };\n\n  return scale;\n}\n\nfunction band() {\n  var scale = ordinal().unknown(undefined),\n      domain = scale.domain,\n      ordinalRange = scale.range,\n      range$$1 = [0, 1],\n      step,\n      bandwidth,\n      round = false,\n      paddingInner = 0,\n      paddingOuter = 0,\n      align = 0.5;\n\n  delete scale.unknown;\n\n  function rescale() {\n    var n = domain().length,\n        reverse = range$$1[1] < range$$1[0],\n        start = range$$1[reverse - 0],\n        stop = range$$1[1 - reverse];\n    step = (stop - start) / Math.max(1, n - paddingInner + paddingOuter * 2);\n    if (round) step = Math.floor(step);\n    start += (stop - start - step * (n - paddingInner)) * align;\n    bandwidth = step * (1 - paddingInner);\n    if (round) start = Math.round(start), bandwidth = Math.round(bandwidth);\n    var values = sequence(n).map(function(i) { return start + step * i; });\n    return ordinalRange(reverse ? values.reverse() : values);\n  }\n\n  scale.domain = function(_) {\n    return arguments.length ? (domain(_), rescale()) : domain();\n  };\n\n  scale.range = function(_) {\n    return arguments.length ? (range$$1 = [+_[0], +_[1]], rescale()) : range$$1.slice();\n  };\n\n  scale.rangeRound = function(_) {\n    return range$$1 = [+_[0], +_[1]], round = true, rescale();\n  };\n\n  scale.bandwidth = function() {\n    return bandwidth;\n  };\n\n  scale.step = function() {\n    return step;\n  };\n\n  scale.round = function(_) {\n    return arguments.length ? (round = !!_, rescale()) : round;\n  };\n\n  scale.padding = function(_) {\n    return arguments.length ? (paddingInner = paddingOuter = Math.max(0, Math.min(1, _)), rescale()) : paddingInner;\n  };\n\n  scale.paddingInner = function(_) {\n    return arguments.length ? (paddingInner = Math.max(0, Math.min(1, _)), rescale()) : paddingInner;\n  };\n\n  scale.paddingOuter = function(_) {\n    return arguments.length ? (paddingOuter = Math.max(0, Math.min(1, _)), rescale()) : paddingOuter;\n  };\n\n  scale.align = function(_) {\n    return arguments.length ? (align = Math.max(0, Math.min(1, _)), rescale()) : align;\n  };\n\n  scale.copy = function() {\n    return band()\n        .domain(domain())\n        .range(range$$1)\n        .round(round)\n        .paddingInner(paddingInner)\n        .paddingOuter(paddingOuter)\n        .align(align);\n  };\n\n  return rescale();\n}\n\nfunction pointish(scale) {\n  var copy = scale.copy;\n\n  scale.padding = scale.paddingOuter;\n  delete scale.paddingInner;\n  delete scale.paddingOuter;\n\n  scale.copy = function() {\n    return pointish(copy());\n  };\n\n  return scale;\n}\n\nfunction point$1() {\n  return pointish(band().paddingInner(1));\n}\n\nvar constant$9 = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nvar number$1 = function(x) {\n  return +x;\n};\n\nvar unit = [0, 1];\n\nfunction deinterpolateLinear(a, b) {\n  return (b -= (a = +a))\n      ? function(x) { return (x - a) / b; }\n      : constant$9(b);\n}\n\nfunction deinterpolateClamp(deinterpolate) {\n  return function(a, b) {\n    var d = deinterpolate(a = +a, b = +b);\n    return function(x) { return x <= a ? 0 : x >= b ? 1 : d(x); };\n  };\n}\n\nfunction reinterpolateClamp(reinterpolate) {\n  return function(a, b) {\n    var r = reinterpolate(a = +a, b = +b);\n    return function(t) { return t <= 0 ? a : t >= 1 ? b : r(t); };\n  };\n}\n\nfunction bimap(domain, range$$1, deinterpolate, reinterpolate) {\n  var d0 = domain[0], d1 = domain[1], r0 = range$$1[0], r1 = range$$1[1];\n  if (d1 < d0) d0 = deinterpolate(d1, d0), r0 = reinterpolate(r1, r0);\n  else d0 = deinterpolate(d0, d1), r0 = reinterpolate(r0, r1);\n  return function(x) { return r0(d0(x)); };\n}\n\nfunction polymap(domain, range$$1, deinterpolate, reinterpolate) {\n  var j = Math.min(domain.length, range$$1.length) - 1,\n      d = new Array(j),\n      r = new Array(j),\n      i = -1;\n\n  // Reverse descending domains.\n  if (domain[j] < domain[0]) {\n    domain = domain.slice().reverse();\n    range$$1 = range$$1.slice().reverse();\n  }\n\n  while (++i < j) {\n    d[i] = deinterpolate(domain[i], domain[i + 1]);\n    r[i] = reinterpolate(range$$1[i], range$$1[i + 1]);\n  }\n\n  return function(x) {\n    var i = bisectRight(domain, x, 1, j) - 1;\n    return r[i](d[i](x));\n  };\n}\n\nfunction copy(source, target) {\n  return target\n      .domain(source.domain())\n      .range(source.range())\n      .interpolate(source.interpolate())\n      .clamp(source.clamp());\n}\n\n// deinterpolate(a, b)(x) takes a domain value x in [a,b] and returns the corresponding parameter t in [0,1].\n// reinterpolate(a, b)(t) takes a parameter t in [0,1] and returns the corresponding domain value x in [a,b].\nfunction continuous(deinterpolate, reinterpolate) {\n  var domain = unit,\n      range$$1 = unit,\n      interpolate$$1 = interpolateValue,\n      clamp = false,\n      piecewise,\n      output,\n      input;\n\n  function rescale() {\n    piecewise = Math.min(domain.length, range$$1.length) > 2 ? polymap : bimap;\n    output = input = null;\n    return scale;\n  }\n\n  function scale(x) {\n    return (output || (output = piecewise(domain, range$$1, clamp ? deinterpolateClamp(deinterpolate) : deinterpolate, interpolate$$1)))(+x);\n  }\n\n  scale.invert = function(y) {\n    return (input || (input = piecewise(range$$1, domain, deinterpolateLinear, clamp ? reinterpolateClamp(reinterpolate) : reinterpolate)))(+y);\n  };\n\n  scale.domain = function(_) {\n    return arguments.length ? (domain = map$3.call(_, number$1), rescale()) : domain.slice();\n  };\n\n  scale.range = function(_) {\n    return arguments.length ? (range$$1 = slice$4.call(_), rescale()) : range$$1.slice();\n  };\n\n  scale.rangeRound = function(_) {\n    return range$$1 = slice$4.call(_), interpolate$$1 = interpolateRound, rescale();\n  };\n\n  scale.clamp = function(_) {\n    return arguments.length ? (clamp = !!_, rescale()) : clamp;\n  };\n\n  scale.interpolate = function(_) {\n    return arguments.length ? (interpolate$$1 = _, rescale()) : interpolate$$1;\n  };\n\n  return rescale();\n}\n\nvar tickFormat = function(domain, count, specifier) {\n  var start = domain[0],\n      stop = domain[domain.length - 1],\n      step = tickStep(start, stop, count == null ? 10 : count),\n      precision;\n  specifier = formatSpecifier(specifier == null ? \",f\" : specifier);\n  switch (specifier.type) {\n    case \"s\": {\n      var value = Math.max(Math.abs(start), Math.abs(stop));\n      if (specifier.precision == null && !isNaN(precision = precisionPrefix(step, value))) specifier.precision = precision;\n      return exports.formatPrefix(specifier, value);\n    }\n    case \"\":\n    case \"e\":\n    case \"g\":\n    case \"p\":\n    case \"r\": {\n      if (specifier.precision == null && !isNaN(precision = precisionRound(step, Math.max(Math.abs(start), Math.abs(stop))))) specifier.precision = precision - (specifier.type === \"e\");\n      break;\n    }\n    case \"f\":\n    case \"%\": {\n      if (specifier.precision == null && !isNaN(precision = precisionFixed(step))) specifier.precision = precision - (specifier.type === \"%\") * 2;\n      break;\n    }\n  }\n  return exports.format(specifier);\n};\n\nfunction linearish(scale) {\n  var domain = scale.domain;\n\n  scale.ticks = function(count) {\n    var d = domain();\n    return ticks(d[0], d[d.length - 1], count == null ? 10 : count);\n  };\n\n  scale.tickFormat = function(count, specifier) {\n    return tickFormat(domain(), count, specifier);\n  };\n\n  scale.nice = function(count) {\n    var d = domain(),\n        i = d.length - 1,\n        n = count == null ? 10 : count,\n        start = d[0],\n        stop = d[i],\n        step = tickStep(start, stop, n);\n\n    if (step) {\n      step = tickStep(Math.floor(start / step) * step, Math.ceil(stop / step) * step, n);\n      d[0] = Math.floor(start / step) * step;\n      d[i] = Math.ceil(stop / step) * step;\n      domain(d);\n    }\n\n    return scale;\n  };\n\n  return scale;\n}\n\nfunction linear$2() {\n  var scale = continuous(deinterpolateLinear, reinterpolate);\n\n  scale.copy = function() {\n    return copy(scale, linear$2());\n  };\n\n  return linearish(scale);\n}\n\nfunction identity$6() {\n  var domain = [0, 1];\n\n  function scale(x) {\n    return +x;\n  }\n\n  scale.invert = scale;\n\n  scale.domain = scale.range = function(_) {\n    return arguments.length ? (domain = map$3.call(_, number$1), scale) : domain.slice();\n  };\n\n  scale.copy = function() {\n    return identity$6().domain(domain);\n  };\n\n  return linearish(scale);\n}\n\nvar nice = function(domain, interval) {\n  domain = domain.slice();\n\n  var i0 = 0,\n      i1 = domain.length - 1,\n      x0 = domain[i0],\n      x1 = domain[i1],\n      t;\n\n  if (x1 < x0) {\n    t = i0, i0 = i1, i1 = t;\n    t = x0, x0 = x1, x1 = t;\n  }\n\n  domain[i0] = interval.floor(x0);\n  domain[i1] = interval.ceil(x1);\n  return domain;\n};\n\nfunction deinterpolate(a, b) {\n  return (b = Math.log(b / a))\n      ? function(x) { return Math.log(x / a) / b; }\n      : constant$9(b);\n}\n\nfunction reinterpolate$1(a, b) {\n  return a < 0\n      ? function(t) { return -Math.pow(-b, t) * Math.pow(-a, 1 - t); }\n      : function(t) { return Math.pow(b, t) * Math.pow(a, 1 - t); };\n}\n\nfunction pow10(x) {\n  return isFinite(x) ? +(\"1e\" + x) : x < 0 ? 0 : x;\n}\n\nfunction powp(base) {\n  return base === 10 ? pow10\n      : base === Math.E ? Math.exp\n      : function(x) { return Math.pow(base, x); };\n}\n\nfunction logp(base) {\n  return base === Math.E ? Math.log\n      : base === 10 && Math.log10\n      || base === 2 && Math.log2\n      || (base = Math.log(base), function(x) { return Math.log(x) / base; });\n}\n\nfunction reflect(f) {\n  return function(x) {\n    return -f(-x);\n  };\n}\n\nfunction log$1() {\n  var scale = continuous(deinterpolate, reinterpolate$1).domain([1, 10]),\n      domain = scale.domain,\n      base = 10,\n      logs = logp(10),\n      pows = powp(10);\n\n  function rescale() {\n    logs = logp(base), pows = powp(base);\n    if (domain()[0] < 0) logs = reflect(logs), pows = reflect(pows);\n    return scale;\n  }\n\n  scale.base = function(_) {\n    return arguments.length ? (base = +_, rescale()) : base;\n  };\n\n  scale.domain = function(_) {\n    return arguments.length ? (domain(_), rescale()) : domain();\n  };\n\n  scale.ticks = function(count) {\n    var d = domain(),\n        u = d[0],\n        v = d[d.length - 1],\n        r;\n\n    if (r = v < u) i = u, u = v, v = i;\n\n    var i = logs(u),\n        j = logs(v),\n        p,\n        k,\n        t,\n        n = count == null ? 10 : +count,\n        z = [];\n\n    if (!(base % 1) && j - i < n) {\n      i = Math.round(i) - 1, j = Math.round(j) + 1;\n      if (u > 0) for (; i < j; ++i) {\n        for (k = 1, p = pows(i); k < base; ++k) {\n          t = p * k;\n          if (t < u) continue;\n          if (t > v) break;\n          z.push(t);\n        }\n      } else for (; i < j; ++i) {\n        for (k = base - 1, p = pows(i); k >= 1; --k) {\n          t = p * k;\n          if (t < u) continue;\n          if (t > v) break;\n          z.push(t);\n        }\n      }\n    } else {\n      z = ticks(i, j, Math.min(j - i, n)).map(pows);\n    }\n\n    return r ? z.reverse() : z;\n  };\n\n  scale.tickFormat = function(count, specifier) {\n    if (specifier == null) specifier = base === 10 ? \".0e\" : \",\";\n    if (typeof specifier !== \"function\") specifier = exports.format(specifier);\n    if (count === Infinity) return specifier;\n    if (count == null) count = 10;\n    var k = Math.max(1, base * count / scale.ticks().length); // TODO fast estimate?\n    return function(d) {\n      var i = d / pows(Math.round(logs(d)));\n      if (i * base < base - 0.5) i *= base;\n      return i <= k ? specifier(d) : \"\";\n    };\n  };\n\n  scale.nice = function() {\n    return domain(nice(domain(), {\n      floor: function(x) { return pows(Math.floor(logs(x))); },\n      ceil: function(x) { return pows(Math.ceil(logs(x))); }\n    }));\n  };\n\n  scale.copy = function() {\n    return copy(scale, log$1().base(base));\n  };\n\n  return scale;\n}\n\nfunction raise$1(x, exponent) {\n  return x < 0 ? -Math.pow(-x, exponent) : Math.pow(x, exponent);\n}\n\nfunction pow$1() {\n  var exponent = 1,\n      scale = continuous(deinterpolate, reinterpolate),\n      domain = scale.domain;\n\n  function deinterpolate(a, b) {\n    return (b = raise$1(b, exponent) - (a = raise$1(a, exponent)))\n        ? function(x) { return (raise$1(x, exponent) - a) / b; }\n        : constant$9(b);\n  }\n\n  function reinterpolate(a, b) {\n    b = raise$1(b, exponent) - (a = raise$1(a, exponent));\n    return function(t) { return raise$1(a + b * t, 1 / exponent); };\n  }\n\n  scale.exponent = function(_) {\n    return arguments.length ? (exponent = +_, domain(domain())) : exponent;\n  };\n\n  scale.copy = function() {\n    return copy(scale, pow$1().exponent(exponent));\n  };\n\n  return linearish(scale);\n}\n\nfunction sqrt$1() {\n  return pow$1().exponent(0.5);\n}\n\nfunction quantile$$1() {\n  var domain = [],\n      range$$1 = [],\n      thresholds = [];\n\n  function rescale() {\n    var i = 0, n = Math.max(1, range$$1.length);\n    thresholds = new Array(n - 1);\n    while (++i < n) thresholds[i - 1] = threshold(domain, i / n);\n    return scale;\n  }\n\n  function scale(x) {\n    if (!isNaN(x = +x)) return range$$1[bisectRight(thresholds, x)];\n  }\n\n  scale.invertExtent = function(y) {\n    var i = range$$1.indexOf(y);\n    return i < 0 ? [NaN, NaN] : [\n      i > 0 ? thresholds[i - 1] : domain[0],\n      i < thresholds.length ? thresholds[i] : domain[domain.length - 1]\n    ];\n  };\n\n  scale.domain = function(_) {\n    if (!arguments.length) return domain.slice();\n    domain = [];\n    for (var i = 0, n = _.length, d; i < n; ++i) if (d = _[i], d != null && !isNaN(d = +d)) domain.push(d);\n    domain.sort(ascending);\n    return rescale();\n  };\n\n  scale.range = function(_) {\n    return arguments.length ? (range$$1 = slice$4.call(_), rescale()) : range$$1.slice();\n  };\n\n  scale.quantiles = function() {\n    return thresholds.slice();\n  };\n\n  scale.copy = function() {\n    return quantile$$1()\n        .domain(domain)\n        .range(range$$1);\n  };\n\n  return scale;\n}\n\nfunction quantize$1() {\n  var x0 = 0,\n      x1 = 1,\n      n = 1,\n      domain = [0.5],\n      range$$1 = [0, 1];\n\n  function scale(x) {\n    if (x <= x) return range$$1[bisectRight(domain, x, 0, n)];\n  }\n\n  function rescale() {\n    var i = -1;\n    domain = new Array(n);\n    while (++i < n) domain[i] = ((i + 1) * x1 - (i - n) * x0) / (n + 1);\n    return scale;\n  }\n\n  scale.domain = function(_) {\n    return arguments.length ? (x0 = +_[0], x1 = +_[1], rescale()) : [x0, x1];\n  };\n\n  scale.range = function(_) {\n    return arguments.length ? (n = (range$$1 = slice$4.call(_)).length - 1, rescale()) : range$$1.slice();\n  };\n\n  scale.invertExtent = function(y) {\n    var i = range$$1.indexOf(y);\n    return i < 0 ? [NaN, NaN]\n        : i < 1 ? [x0, domain[0]]\n        : i >= n ? [domain[n - 1], x1]\n        : [domain[i - 1], domain[i]];\n  };\n\n  scale.copy = function() {\n    return quantize$1()\n        .domain([x0, x1])\n        .range(range$$1);\n  };\n\n  return linearish(scale);\n}\n\nfunction threshold$1() {\n  var domain = [0.5],\n      range$$1 = [0, 1],\n      n = 1;\n\n  function scale(x) {\n    if (x <= x) return range$$1[bisectRight(domain, x, 0, n)];\n  }\n\n  scale.domain = function(_) {\n    return arguments.length ? (domain = slice$4.call(_), n = Math.min(domain.length, range$$1.length - 1), scale) : domain.slice();\n  };\n\n  scale.range = function(_) {\n    return arguments.length ? (range$$1 = slice$4.call(_), n = Math.min(domain.length, range$$1.length - 1), scale) : range$$1.slice();\n  };\n\n  scale.invertExtent = function(y) {\n    var i = range$$1.indexOf(y);\n    return [domain[i - 1], domain[i]];\n  };\n\n  scale.copy = function() {\n    return threshold$1()\n        .domain(domain)\n        .range(range$$1);\n  };\n\n  return scale;\n}\n\nvar t0$1 = new Date;\nvar t1$1 = new Date;\n\nfunction newInterval(floori, offseti, count, field) {\n\n  function interval(date) {\n    return floori(date = new Date(+date)), date;\n  }\n\n  interval.floor = interval;\n\n  interval.ceil = function(date) {\n    return floori(date = new Date(date - 1)), offseti(date, 1), floori(date), date;\n  };\n\n  interval.round = function(date) {\n    var d0 = interval(date),\n        d1 = interval.ceil(date);\n    return date - d0 < d1 - date ? d0 : d1;\n  };\n\n  interval.offset = function(date, step) {\n    return offseti(date = new Date(+date), step == null ? 1 : Math.floor(step)), date;\n  };\n\n  interval.range = function(start, stop, step) {\n    var range = [];\n    start = interval.ceil(start);\n    step = step == null ? 1 : Math.floor(step);\n    if (!(start < stop) || !(step > 0)) return range; // also handles Invalid Date\n    do range.push(new Date(+start)); while (offseti(start, step), floori(start), start < stop)\n    return range;\n  };\n\n  interval.filter = function(test) {\n    return newInterval(function(date) {\n      if (date >= date) while (floori(date), !test(date)) date.setTime(date - 1);\n    }, function(date, step) {\n      if (date >= date) while (--step >= 0) while (offseti(date, 1), !test(date)) {} // eslint-disable-line no-empty\n    });\n  };\n\n  if (count) {\n    interval.count = function(start, end) {\n      t0$1.setTime(+start), t1$1.setTime(+end);\n      floori(t0$1), floori(t1$1);\n      return Math.floor(count(t0$1, t1$1));\n    };\n\n    interval.every = function(step) {\n      step = Math.floor(step);\n      return !isFinite(step) || !(step > 0) ? null\n          : !(step > 1) ? interval\n          : interval.filter(field\n              ? function(d) { return field(d) % step === 0; }\n              : function(d) { return interval.count(0, d) % step === 0; });\n    };\n  }\n\n  return interval;\n}\n\nvar millisecond = newInterval(function() {\n  // noop\n}, function(date, step) {\n  date.setTime(+date + step);\n}, function(start, end) {\n  return end - start;\n});\n\n// An optimized implementation for this simple case.\nmillisecond.every = function(k) {\n  k = Math.floor(k);\n  if (!isFinite(k) || !(k > 0)) return null;\n  if (!(k > 1)) return millisecond;\n  return newInterval(function(date) {\n    date.setTime(Math.floor(date / k) * k);\n  }, function(date, step) {\n    date.setTime(+date + step * k);\n  }, function(start, end) {\n    return (end - start) / k;\n  });\n};\n\nvar milliseconds = millisecond.range;\n\nvar durationSecond$1 = 1e3;\nvar durationMinute$1 = 6e4;\nvar durationHour$1 = 36e5;\nvar durationDay$1 = 864e5;\nvar durationWeek$1 = 6048e5;\n\nvar second = newInterval(function(date) {\n  date.setTime(Math.floor(date / durationSecond$1) * durationSecond$1);\n}, function(date, step) {\n  date.setTime(+date + step * durationSecond$1);\n}, function(start, end) {\n  return (end - start) / durationSecond$1;\n}, function(date) {\n  return date.getUTCSeconds();\n});\n\nvar seconds = second.range;\n\nvar minute = newInterval(function(date) {\n  date.setTime(Math.floor(date / durationMinute$1) * durationMinute$1);\n}, function(date, step) {\n  date.setTime(+date + step * durationMinute$1);\n}, function(start, end) {\n  return (end - start) / durationMinute$1;\n}, function(date) {\n  return date.getMinutes();\n});\n\nvar minutes = minute.range;\n\nvar hour = newInterval(function(date) {\n  var offset = date.getTimezoneOffset() * durationMinute$1 % durationHour$1;\n  if (offset < 0) offset += durationHour$1;\n  date.setTime(Math.floor((+date - offset) / durationHour$1) * durationHour$1 + offset);\n}, function(date, step) {\n  date.setTime(+date + step * durationHour$1);\n}, function(start, end) {\n  return (end - start) / durationHour$1;\n}, function(date) {\n  return date.getHours();\n});\n\nvar hours = hour.range;\n\nvar day = newInterval(function(date) {\n  date.setHours(0, 0, 0, 0);\n}, function(date, step) {\n  date.setDate(date.getDate() + step);\n}, function(start, end) {\n  return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute$1) / durationDay$1;\n}, function(date) {\n  return date.getDate() - 1;\n});\n\nvar days = day.range;\n\nfunction weekday(i) {\n  return newInterval(function(date) {\n    date.setDate(date.getDate() - (date.getDay() + 7 - i) % 7);\n    date.setHours(0, 0, 0, 0);\n  }, function(date, step) {\n    date.setDate(date.getDate() + step * 7);\n  }, function(start, end) {\n    return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute$1) / durationWeek$1;\n  });\n}\n\nvar sunday = weekday(0);\nvar monday = weekday(1);\nvar tuesday = weekday(2);\nvar wednesday = weekday(3);\nvar thursday = weekday(4);\nvar friday = weekday(5);\nvar saturday = weekday(6);\n\nvar sundays = sunday.range;\nvar mondays = monday.range;\nvar tuesdays = tuesday.range;\nvar wednesdays = wednesday.range;\nvar thursdays = thursday.range;\nvar fridays = friday.range;\nvar saturdays = saturday.range;\n\nvar month = newInterval(function(date) {\n  date.setDate(1);\n  date.setHours(0, 0, 0, 0);\n}, function(date, step) {\n  date.setMonth(date.getMonth() + step);\n}, function(start, end) {\n  return end.getMonth() - start.getMonth() + (end.getFullYear() - start.getFullYear()) * 12;\n}, function(date) {\n  return date.getMonth();\n});\n\nvar months = month.range;\n\nvar year = newInterval(function(date) {\n  date.setMonth(0, 1);\n  date.setHours(0, 0, 0, 0);\n}, function(date, step) {\n  date.setFullYear(date.getFullYear() + step);\n}, function(start, end) {\n  return end.getFullYear() - start.getFullYear();\n}, function(date) {\n  return date.getFullYear();\n});\n\n// An optimized implementation for this simple case.\nyear.every = function(k) {\n  return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : newInterval(function(date) {\n    date.setFullYear(Math.floor(date.getFullYear() / k) * k);\n    date.setMonth(0, 1);\n    date.setHours(0, 0, 0, 0);\n  }, function(date, step) {\n    date.setFullYear(date.getFullYear() + step * k);\n  });\n};\n\nvar years = year.range;\n\nvar utcMinute = newInterval(function(date) {\n  date.setUTCSeconds(0, 0);\n}, function(date, step) {\n  date.setTime(+date + step * durationMinute$1);\n}, function(start, end) {\n  return (end - start) / durationMinute$1;\n}, function(date) {\n  return date.getUTCMinutes();\n});\n\nvar utcMinutes = utcMinute.range;\n\nvar utcHour = newInterval(function(date) {\n  date.setUTCMinutes(0, 0, 0);\n}, function(date, step) {\n  date.setTime(+date + step * durationHour$1);\n}, function(start, end) {\n  return (end - start) / durationHour$1;\n}, function(date) {\n  return date.getUTCHours();\n});\n\nvar utcHours = utcHour.range;\n\nvar utcDay = newInterval(function(date) {\n  date.setUTCHours(0, 0, 0, 0);\n}, function(date, step) {\n  date.setUTCDate(date.getUTCDate() + step);\n}, function(start, end) {\n  return (end - start) / durationDay$1;\n}, function(date) {\n  return date.getUTCDate() - 1;\n});\n\nvar utcDays = utcDay.range;\n\nfunction utcWeekday(i) {\n  return newInterval(function(date) {\n    date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 7 - i) % 7);\n    date.setUTCHours(0, 0, 0, 0);\n  }, function(date, step) {\n    date.setUTCDate(date.getUTCDate() + step * 7);\n  }, function(start, end) {\n    return (end - start) / durationWeek$1;\n  });\n}\n\nvar utcSunday = utcWeekday(0);\nvar utcMonday = utcWeekday(1);\nvar utcTuesday = utcWeekday(2);\nvar utcWednesday = utcWeekday(3);\nvar utcThursday = utcWeekday(4);\nvar utcFriday = utcWeekday(5);\nvar utcSaturday = utcWeekday(6);\n\nvar utcSundays = utcSunday.range;\nvar utcMondays = utcMonday.range;\nvar utcTuesdays = utcTuesday.range;\nvar utcWednesdays = utcWednesday.range;\nvar utcThursdays = utcThursday.range;\nvar utcFridays = utcFriday.range;\nvar utcSaturdays = utcSaturday.range;\n\nvar utcMonth = newInterval(function(date) {\n  date.setUTCDate(1);\n  date.setUTCHours(0, 0, 0, 0);\n}, function(date, step) {\n  date.setUTCMonth(date.getUTCMonth() + step);\n}, function(start, end) {\n  return end.getUTCMonth() - start.getUTCMonth() + (end.getUTCFullYear() - start.getUTCFullYear()) * 12;\n}, function(date) {\n  return date.getUTCMonth();\n});\n\nvar utcMonths = utcMonth.range;\n\nvar utcYear = newInterval(function(date) {\n  date.setUTCMonth(0, 1);\n  date.setUTCHours(0, 0, 0, 0);\n}, function(date, step) {\n  date.setUTCFullYear(date.getUTCFullYear() + step);\n}, function(start, end) {\n  return end.getUTCFullYear() - start.getUTCFullYear();\n}, function(date) {\n  return date.getUTCFullYear();\n});\n\n// An optimized implementation for this simple case.\nutcYear.every = function(k) {\n  return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : newInterval(function(date) {\n    date.setUTCFullYear(Math.floor(date.getUTCFullYear() / k) * k);\n    date.setUTCMonth(0, 1);\n    date.setUTCHours(0, 0, 0, 0);\n  }, function(date, step) {\n    date.setUTCFullYear(date.getUTCFullYear() + step * k);\n  });\n};\n\nvar utcYears = utcYear.range;\n\nfunction localDate(d) {\n  if (0 <= d.y && d.y < 100) {\n    var date = new Date(-1, d.m, d.d, d.H, d.M, d.S, d.L);\n    date.setFullYear(d.y);\n    return date;\n  }\n  return new Date(d.y, d.m, d.d, d.H, d.M, d.S, d.L);\n}\n\nfunction utcDate(d) {\n  if (0 <= d.y && d.y < 100) {\n    var date = new Date(Date.UTC(-1, d.m, d.d, d.H, d.M, d.S, d.L));\n    date.setUTCFullYear(d.y);\n    return date;\n  }\n  return new Date(Date.UTC(d.y, d.m, d.d, d.H, d.M, d.S, d.L));\n}\n\nfunction newYear(y) {\n  return {y: y, m: 0, d: 1, H: 0, M: 0, S: 0, L: 0};\n}\n\nfunction formatLocale$1(locale) {\n  var locale_dateTime = locale.dateTime,\n      locale_date = locale.date,\n      locale_time = locale.time,\n      locale_periods = locale.periods,\n      locale_weekdays = locale.days,\n      locale_shortWeekdays = locale.shortDays,\n      locale_months = locale.months,\n      locale_shortMonths = locale.shortMonths;\n\n  var periodRe = formatRe(locale_periods),\n      periodLookup = formatLookup(locale_periods),\n      weekdayRe = formatRe(locale_weekdays),\n      weekdayLookup = formatLookup(locale_weekdays),\n      shortWeekdayRe = formatRe(locale_shortWeekdays),\n      shortWeekdayLookup = formatLookup(locale_shortWeekdays),\n      monthRe = formatRe(locale_months),\n      monthLookup = formatLookup(locale_months),\n      shortMonthRe = formatRe(locale_shortMonths),\n      shortMonthLookup = formatLookup(locale_shortMonths);\n\n  var formats = {\n    \"a\": formatShortWeekday,\n    \"A\": formatWeekday,\n    \"b\": formatShortMonth,\n    \"B\": formatMonth,\n    \"c\": null,\n    \"d\": formatDayOfMonth,\n    \"e\": formatDayOfMonth,\n    \"H\": formatHour24,\n    \"I\": formatHour12,\n    \"j\": formatDayOfYear,\n    \"L\": formatMilliseconds,\n    \"m\": formatMonthNumber,\n    \"M\": formatMinutes,\n    \"p\": formatPeriod,\n    \"S\": formatSeconds,\n    \"U\": formatWeekNumberSunday,\n    \"w\": formatWeekdayNumber,\n    \"W\": formatWeekNumberMonday,\n    \"x\": null,\n    \"X\": null,\n    \"y\": formatYear,\n    \"Y\": formatFullYear,\n    \"Z\": formatZone,\n    \"%\": formatLiteralPercent\n  };\n\n  var utcFormats = {\n    \"a\": formatUTCShortWeekday,\n    \"A\": formatUTCWeekday,\n    \"b\": formatUTCShortMonth,\n    \"B\": formatUTCMonth,\n    \"c\": null,\n    \"d\": formatUTCDayOfMonth,\n    \"e\": formatUTCDayOfMonth,\n    \"H\": formatUTCHour24,\n    \"I\": formatUTCHour12,\n    \"j\": formatUTCDayOfYear,\n    \"L\": formatUTCMilliseconds,\n    \"m\": formatUTCMonthNumber,\n    \"M\": formatUTCMinutes,\n    \"p\": formatUTCPeriod,\n    \"S\": formatUTCSeconds,\n    \"U\": formatUTCWeekNumberSunday,\n    \"w\": formatUTCWeekdayNumber,\n    \"W\": formatUTCWeekNumberMonday,\n    \"x\": null,\n    \"X\": null,\n    \"y\": formatUTCYear,\n    \"Y\": formatUTCFullYear,\n    \"Z\": formatUTCZone,\n    \"%\": formatLiteralPercent\n  };\n\n  var parses = {\n    \"a\": parseShortWeekday,\n    \"A\": parseWeekday,\n    \"b\": parseShortMonth,\n    \"B\": parseMonth,\n    \"c\": parseLocaleDateTime,\n    \"d\": parseDayOfMonth,\n    \"e\": parseDayOfMonth,\n    \"H\": parseHour24,\n    \"I\": parseHour24,\n    \"j\": parseDayOfYear,\n    \"L\": parseMilliseconds,\n    \"m\": parseMonthNumber,\n    \"M\": parseMinutes,\n    \"p\": parsePeriod,\n    \"S\": parseSeconds,\n    \"U\": parseWeekNumberSunday,\n    \"w\": parseWeekdayNumber,\n    \"W\": parseWeekNumberMonday,\n    \"x\": parseLocaleDate,\n    \"X\": parseLocaleTime,\n    \"y\": parseYear,\n    \"Y\": parseFullYear,\n    \"Z\": parseZone,\n    \"%\": parseLiteralPercent\n  };\n\n  // These recursive directive definitions must be deferred.\n  formats.x = newFormat(locale_date, formats);\n  formats.X = newFormat(locale_time, formats);\n  formats.c = newFormat(locale_dateTime, formats);\n  utcFormats.x = newFormat(locale_date, utcFormats);\n  utcFormats.X = newFormat(locale_time, utcFormats);\n  utcFormats.c = newFormat(locale_dateTime, utcFormats);\n\n  function newFormat(specifier, formats) {\n    return function(date) {\n      var string = [],\n          i = -1,\n          j = 0,\n          n = specifier.length,\n          c,\n          pad,\n          format;\n\n      if (!(date instanceof Date)) date = new Date(+date);\n\n      while (++i < n) {\n        if (specifier.charCodeAt(i) === 37) {\n          string.push(specifier.slice(j, i));\n          if ((pad = pads[c = specifier.charAt(++i)]) != null) c = specifier.charAt(++i);\n          else pad = c === \"e\" ? \" \" : \"0\";\n          if (format = formats[c]) c = format(date, pad);\n          string.push(c);\n          j = i + 1;\n        }\n      }\n\n      string.push(specifier.slice(j, i));\n      return string.join(\"\");\n    };\n  }\n\n  function newParse(specifier, newDate) {\n    return function(string) {\n      var d = newYear(1900),\n          i = parseSpecifier(d, specifier, string += \"\", 0);\n      if (i != string.length) return null;\n\n      // The am-pm flag is 0 for AM, and 1 for PM.\n      if (\"p\" in d) d.H = d.H % 12 + d.p * 12;\n\n      // Convert day-of-week and week-of-year to day-of-year.\n      if (\"W\" in d || \"U\" in d) {\n        if (!(\"w\" in d)) d.w = \"W\" in d ? 1 : 0;\n        var day$$1 = \"Z\" in d ? utcDate(newYear(d.y)).getUTCDay() : newDate(newYear(d.y)).getDay();\n        d.m = 0;\n        d.d = \"W\" in d ? (d.w + 6) % 7 + d.W * 7 - (day$$1 + 5) % 7 : d.w + d.U * 7 - (day$$1 + 6) % 7;\n      }\n\n      // If a time zone is specified, all fields are interpreted as UTC and then\n      // offset according to the specified time zone.\n      if (\"Z\" in d) {\n        d.H += d.Z / 100 | 0;\n        d.M += d.Z % 100;\n        return utcDate(d);\n      }\n\n      // Otherwise, all fields are in local time.\n      return newDate(d);\n    };\n  }\n\n  function parseSpecifier(d, specifier, string, j) {\n    var i = 0,\n        n = specifier.length,\n        m = string.length,\n        c,\n        parse;\n\n    while (i < n) {\n      if (j >= m) return -1;\n      c = specifier.charCodeAt(i++);\n      if (c === 37) {\n        c = specifier.charAt(i++);\n        parse = parses[c in pads ? specifier.charAt(i++) : c];\n        if (!parse || ((j = parse(d, string, j)) < 0)) return -1;\n      } else if (c != string.charCodeAt(j++)) {\n        return -1;\n      }\n    }\n\n    return j;\n  }\n\n  function parsePeriod(d, string, i) {\n    var n = periodRe.exec(string.slice(i));\n    return n ? (d.p = periodLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n  }\n\n  function parseShortWeekday(d, string, i) {\n    var n = shortWeekdayRe.exec(string.slice(i));\n    return n ? (d.w = shortWeekdayLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n  }\n\n  function parseWeekday(d, string, i) {\n    var n = weekdayRe.exec(string.slice(i));\n    return n ? (d.w = weekdayLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n  }\n\n  function parseShortMonth(d, string, i) {\n    var n = shortMonthRe.exec(string.slice(i));\n    return n ? (d.m = shortMonthLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n  }\n\n  function parseMonth(d, string, i) {\n    var n = monthRe.exec(string.slice(i));\n    return n ? (d.m = monthLookup[n[0].toLowerCase()], i + n[0].length) : -1;\n  }\n\n  function parseLocaleDateTime(d, string, i) {\n    return parseSpecifier(d, locale_dateTime, string, i);\n  }\n\n  function parseLocaleDate(d, string, i) {\n    return parseSpecifier(d, locale_date, string, i);\n  }\n\n  function parseLocaleTime(d, string, i) {\n    return parseSpecifier(d, locale_time, string, i);\n  }\n\n  function formatShortWeekday(d) {\n    return locale_shortWeekdays[d.getDay()];\n  }\n\n  function formatWeekday(d) {\n    return locale_weekdays[d.getDay()];\n  }\n\n  function formatShortMonth(d) {\n    return locale_shortMonths[d.getMonth()];\n  }\n\n  function formatMonth(d) {\n    return locale_months[d.getMonth()];\n  }\n\n  function formatPeriod(d) {\n    return locale_periods[+(d.getHours() >= 12)];\n  }\n\n  function formatUTCShortWeekday(d) {\n    return locale_shortWeekdays[d.getUTCDay()];\n  }\n\n  function formatUTCWeekday(d) {\n    return locale_weekdays[d.getUTCDay()];\n  }\n\n  function formatUTCShortMonth(d) {\n    return locale_shortMonths[d.getUTCMonth()];\n  }\n\n  function formatUTCMonth(d) {\n    return locale_months[d.getUTCMonth()];\n  }\n\n  function formatUTCPeriod(d) {\n    return locale_periods[+(d.getUTCHours() >= 12)];\n  }\n\n  return {\n    format: function(specifier) {\n      var f = newFormat(specifier += \"\", formats);\n      f.toString = function() { return specifier; };\n      return f;\n    },\n    parse: function(specifier) {\n      var p = newParse(specifier += \"\", localDate);\n      p.toString = function() { return specifier; };\n      return p;\n    },\n    utcFormat: function(specifier) {\n      var f = newFormat(specifier += \"\", utcFormats);\n      f.toString = function() { return specifier; };\n      return f;\n    },\n    utcParse: function(specifier) {\n      var p = newParse(specifier, utcDate);\n      p.toString = function() { return specifier; };\n      return p;\n    }\n  };\n}\n\nvar pads = {\"-\": \"\", \"_\": \" \", \"0\": \"0\"};\nvar numberRe = /^\\s*\\d+/;\nvar percentRe = /^%/;\nvar requoteRe = /[\\\\\\^\\$\\*\\+\\?\\|\\[\\]\\(\\)\\.\\{\\}]/g;\n\nfunction pad(value, fill, width) {\n  var sign = value < 0 ? \"-\" : \"\",\n      string = (sign ? -value : value) + \"\",\n      length = string.length;\n  return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string);\n}\n\nfunction requote(s) {\n  return s.replace(requoteRe, \"\\\\$&\");\n}\n\nfunction formatRe(names) {\n  return new RegExp(\"^(?:\" + names.map(requote).join(\"|\") + \")\", \"i\");\n}\n\nfunction formatLookup(names) {\n  var map = {}, i = -1, n = names.length;\n  while (++i < n) map[names[i].toLowerCase()] = i;\n  return map;\n}\n\nfunction parseWeekdayNumber(d, string, i) {\n  var n = numberRe.exec(string.slice(i, i + 1));\n  return n ? (d.w = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseWeekNumberSunday(d, string, i) {\n  var n = numberRe.exec(string.slice(i));\n  return n ? (d.U = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseWeekNumberMonday(d, string, i) {\n  var n = numberRe.exec(string.slice(i));\n  return n ? (d.W = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseFullYear(d, string, i) {\n  var n = numberRe.exec(string.slice(i, i + 4));\n  return n ? (d.y = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseYear(d, string, i) {\n  var n = numberRe.exec(string.slice(i, i + 2));\n  return n ? (d.y = +n[0] + (+n[0] > 68 ? 1900 : 2000), i + n[0].length) : -1;\n}\n\nfunction parseZone(d, string, i) {\n  var n = /^(Z)|([+-]\\d\\d)(?:\\:?(\\d\\d))?/.exec(string.slice(i, i + 6));\n  return n ? (d.Z = n[1] ? 0 : -(n[2] + (n[3] || \"00\")), i + n[0].length) : -1;\n}\n\nfunction parseMonthNumber(d, string, i) {\n  var n = numberRe.exec(string.slice(i, i + 2));\n  return n ? (d.m = n[0] - 1, i + n[0].length) : -1;\n}\n\nfunction parseDayOfMonth(d, string, i) {\n  var n = numberRe.exec(string.slice(i, i + 2));\n  return n ? (d.d = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseDayOfYear(d, string, i) {\n  var n = numberRe.exec(string.slice(i, i + 3));\n  return n ? (d.m = 0, d.d = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseHour24(d, string, i) {\n  var n = numberRe.exec(string.slice(i, i + 2));\n  return n ? (d.H = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseMinutes(d, string, i) {\n  var n = numberRe.exec(string.slice(i, i + 2));\n  return n ? (d.M = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseSeconds(d, string, i) {\n  var n = numberRe.exec(string.slice(i, i + 2));\n  return n ? (d.S = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseMilliseconds(d, string, i) {\n  var n = numberRe.exec(string.slice(i, i + 3));\n  return n ? (d.L = +n[0], i + n[0].length) : -1;\n}\n\nfunction parseLiteralPercent(d, string, i) {\n  var n = percentRe.exec(string.slice(i, i + 1));\n  return n ? i + n[0].length : -1;\n}\n\nfunction formatDayOfMonth(d, p) {\n  return pad(d.getDate(), p, 2);\n}\n\nfunction formatHour24(d, p) {\n  return pad(d.getHours(), p, 2);\n}\n\nfunction formatHour12(d, p) {\n  return pad(d.getHours() % 12 || 12, p, 2);\n}\n\nfunction formatDayOfYear(d, p) {\n  return pad(1 + day.count(year(d), d), p, 3);\n}\n\nfunction formatMilliseconds(d, p) {\n  return pad(d.getMilliseconds(), p, 3);\n}\n\nfunction formatMonthNumber(d, p) {\n  return pad(d.getMonth() + 1, p, 2);\n}\n\nfunction formatMinutes(d, p) {\n  return pad(d.getMinutes(), p, 2);\n}\n\nfunction formatSeconds(d, p) {\n  return pad(d.getSeconds(), p, 2);\n}\n\nfunction formatWeekNumberSunday(d, p) {\n  return pad(sunday.count(year(d), d), p, 2);\n}\n\nfunction formatWeekdayNumber(d) {\n  return d.getDay();\n}\n\nfunction formatWeekNumberMonday(d, p) {\n  return pad(monday.count(year(d), d), p, 2);\n}\n\nfunction formatYear(d, p) {\n  return pad(d.getFullYear() % 100, p, 2);\n}\n\nfunction formatFullYear(d, p) {\n  return pad(d.getFullYear() % 10000, p, 4);\n}\n\nfunction formatZone(d) {\n  var z = d.getTimezoneOffset();\n  return (z > 0 ? \"-\" : (z *= -1, \"+\"))\n      + pad(z / 60 | 0, \"0\", 2)\n      + pad(z % 60, \"0\", 2);\n}\n\nfunction formatUTCDayOfMonth(d, p) {\n  return pad(d.getUTCDate(), p, 2);\n}\n\nfunction formatUTCHour24(d, p) {\n  return pad(d.getUTCHours(), p, 2);\n}\n\nfunction formatUTCHour12(d, p) {\n  return pad(d.getUTCHours() % 12 || 12, p, 2);\n}\n\nfunction formatUTCDayOfYear(d, p) {\n  return pad(1 + utcDay.count(utcYear(d), d), p, 3);\n}\n\nfunction formatUTCMilliseconds(d, p) {\n  return pad(d.getUTCMilliseconds(), p, 3);\n}\n\nfunction formatUTCMonthNumber(d, p) {\n  return pad(d.getUTCMonth() + 1, p, 2);\n}\n\nfunction formatUTCMinutes(d, p) {\n  return pad(d.getUTCMinutes(), p, 2);\n}\n\nfunction formatUTCSeconds(d, p) {\n  return pad(d.getUTCSeconds(), p, 2);\n}\n\nfunction formatUTCWeekNumberSunday(d, p) {\n  return pad(utcSunday.count(utcYear(d), d), p, 2);\n}\n\nfunction formatUTCWeekdayNumber(d) {\n  return d.getUTCDay();\n}\n\nfunction formatUTCWeekNumberMonday(d, p) {\n  return pad(utcMonday.count(utcYear(d), d), p, 2);\n}\n\nfunction formatUTCYear(d, p) {\n  return pad(d.getUTCFullYear() % 100, p, 2);\n}\n\nfunction formatUTCFullYear(d, p) {\n  return pad(d.getUTCFullYear() % 10000, p, 4);\n}\n\nfunction formatUTCZone() {\n  return \"+0000\";\n}\n\nfunction formatLiteralPercent() {\n  return \"%\";\n}\n\nvar locale$2;\n\n\n\n\n\ndefaultLocale$1({\n  dateTime: \"%x, %X\",\n  date: \"%-m/%-d/%Y\",\n  time: \"%-I:%M:%S %p\",\n  periods: [\"AM\", \"PM\"],\n  days: [\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"],\n  shortDays: [\"Sun\", \"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\"],\n  months: [\"January\", \"February\", \"March\", \"April\", \"May\", \"June\", \"July\", \"August\", \"September\", \"October\", \"November\", \"December\"],\n  shortMonths: [\"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"Jun\", \"Jul\", \"Aug\", \"Sep\", \"Oct\", \"Nov\", \"Dec\"]\n});\n\nfunction defaultLocale$1(definition) {\n  locale$2 = formatLocale$1(definition);\n  exports.timeFormat = locale$2.format;\n  exports.timeParse = locale$2.parse;\n  exports.utcFormat = locale$2.utcFormat;\n  exports.utcParse = locale$2.utcParse;\n  return locale$2;\n}\n\nvar isoSpecifier = \"%Y-%m-%dT%H:%M:%S.%LZ\";\n\nfunction formatIsoNative(date) {\n  return date.toISOString();\n}\n\nvar formatIso = Date.prototype.toISOString\n    ? formatIsoNative\n    : exports.utcFormat(isoSpecifier);\n\nfunction parseIsoNative(string) {\n  var date = new Date(string);\n  return isNaN(date) ? null : date;\n}\n\nvar parseIso = +new Date(\"2000-01-01T00:00:00.000Z\")\n    ? parseIsoNative\n    : exports.utcParse(isoSpecifier);\n\nvar durationSecond = 1000;\nvar durationMinute = durationSecond * 60;\nvar durationHour = durationMinute * 60;\nvar durationDay = durationHour * 24;\nvar durationWeek = durationDay * 7;\nvar durationMonth = durationDay * 30;\nvar durationYear = durationDay * 365;\n\nfunction date$1(t) {\n  return new Date(t);\n}\n\nfunction number$2(t) {\n  return t instanceof Date ? +t : +new Date(+t);\n}\n\nfunction calendar(year$$1, month$$1, week, day$$1, hour$$1, minute$$1, second$$1, millisecond$$1, format) {\n  var scale = continuous(deinterpolateLinear, reinterpolate),\n      invert = scale.invert,\n      domain = scale.domain;\n\n  var formatMillisecond = format(\".%L\"),\n      formatSecond = format(\":%S\"),\n      formatMinute = format(\"%I:%M\"),\n      formatHour = format(\"%I %p\"),\n      formatDay = format(\"%a %d\"),\n      formatWeek = format(\"%b %d\"),\n      formatMonth = format(\"%B\"),\n      formatYear = format(\"%Y\");\n\n  var tickIntervals = [\n    [second$$1,  1,      durationSecond],\n    [second$$1,  5,  5 * durationSecond],\n    [second$$1, 15, 15 * durationSecond],\n    [second$$1, 30, 30 * durationSecond],\n    [minute$$1,  1,      durationMinute],\n    [minute$$1,  5,  5 * durationMinute],\n    [minute$$1, 15, 15 * durationMinute],\n    [minute$$1, 30, 30 * durationMinute],\n    [  hour$$1,  1,      durationHour  ],\n    [  hour$$1,  3,  3 * durationHour  ],\n    [  hour$$1,  6,  6 * durationHour  ],\n    [  hour$$1, 12, 12 * durationHour  ],\n    [   day$$1,  1,      durationDay   ],\n    [   day$$1,  2,  2 * durationDay   ],\n    [  week,  1,      durationWeek  ],\n    [ month$$1,  1,      durationMonth ],\n    [ month$$1,  3,  3 * durationMonth ],\n    [  year$$1,  1,      durationYear  ]\n  ];\n\n  function tickFormat(date) {\n    return (second$$1(date) < date ? formatMillisecond\n        : minute$$1(date) < date ? formatSecond\n        : hour$$1(date) < date ? formatMinute\n        : day$$1(date) < date ? formatHour\n        : month$$1(date) < date ? (week(date) < date ? formatDay : formatWeek)\n        : year$$1(date) < date ? formatMonth\n        : formatYear)(date);\n  }\n\n  function tickInterval(interval, start, stop, step) {\n    if (interval == null) interval = 10;\n\n    // If a desired tick count is specified, pick a reasonable tick interval\n    // based on the extent of the domain and a rough estimate of tick size.\n    // Otherwise, assume interval is already a time interval and use it.\n    if (typeof interval === \"number\") {\n      var target = Math.abs(stop - start) / interval,\n          i = bisector(function(i) { return i[2]; }).right(tickIntervals, target);\n      if (i === tickIntervals.length) {\n        step = tickStep(start / durationYear, stop / durationYear, interval);\n        interval = year$$1;\n      } else if (i) {\n        i = tickIntervals[target / tickIntervals[i - 1][2] < tickIntervals[i][2] / target ? i - 1 : i];\n        step = i[1];\n        interval = i[0];\n      } else {\n        step = tickStep(start, stop, interval);\n        interval = millisecond$$1;\n      }\n    }\n\n    return step == null ? interval : interval.every(step);\n  }\n\n  scale.invert = function(y) {\n    return new Date(invert(y));\n  };\n\n  scale.domain = function(_) {\n    return arguments.length ? domain(map$3.call(_, number$2)) : domain().map(date$1);\n  };\n\n  scale.ticks = function(interval, step) {\n    var d = domain(),\n        t0 = d[0],\n        t1 = d[d.length - 1],\n        r = t1 < t0,\n        t;\n    if (r) t = t0, t0 = t1, t1 = t;\n    t = tickInterval(interval, t0, t1, step);\n    t = t ? t.range(t0, t1 + 1) : []; // inclusive stop\n    return r ? t.reverse() : t;\n  };\n\n  scale.tickFormat = function(count, specifier) {\n    return specifier == null ? tickFormat : format(specifier);\n  };\n\n  scale.nice = function(interval, step) {\n    var d = domain();\n    return (interval = tickInterval(interval, d[0], d[d.length - 1], step))\n        ? domain(nice(d, interval))\n        : scale;\n  };\n\n  scale.copy = function() {\n    return copy(scale, calendar(year$$1, month$$1, week, day$$1, hour$$1, minute$$1, second$$1, millisecond$$1, format));\n  };\n\n  return scale;\n}\n\nvar time = function() {\n  return calendar(year, month, sunday, day, hour, minute, second, millisecond, exports.timeFormat).domain([new Date(2000, 0, 1), new Date(2000, 0, 2)]);\n};\n\nvar utcTime = function() {\n  return calendar(utcYear, utcMonth, utcSunday, utcDay, utcHour, utcMinute, second, millisecond, exports.utcFormat).domain([Date.UTC(2000, 0, 1), Date.UTC(2000, 0, 2)]);\n};\n\nvar colors = function(s) {\n  return s.match(/.{6}/g).map(function(x) {\n    return \"#\" + x;\n  });\n};\n\nvar category10 = colors(\"1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf\");\n\nvar category20b = colors(\"393b795254a36b6ecf9c9ede6379398ca252b5cf6bcedb9c8c6d31bd9e39e7ba52e7cb94843c39ad494ad6616be7969c7b4173a55194ce6dbdde9ed6\");\n\nvar category20c = colors(\"3182bd6baed69ecae1c6dbefe6550dfd8d3cfdae6bfdd0a231a35474c476a1d99bc7e9c0756bb19e9ac8bcbddcdadaeb636363969696bdbdbdd9d9d9\");\n\nvar category20 = colors(\"1f77b4aec7e8ff7f0effbb782ca02c98df8ad62728ff98969467bdc5b0d58c564bc49c94e377c2f7b6d27f7f7fc7c7c7bcbd22dbdb8d17becf9edae5\");\n\nvar cubehelix$3 = cubehelixLong(cubehelix(300, 0.5, 0.0), cubehelix(-240, 0.5, 1.0));\n\nvar warm = cubehelixLong(cubehelix(-100, 0.75, 0.35), cubehelix(80, 1.50, 0.8));\n\nvar cool = cubehelixLong(cubehelix(260, 0.75, 0.35), cubehelix(80, 1.50, 0.8));\n\nvar rainbow = cubehelix();\n\nvar rainbow$1 = function(t) {\n  if (t < 0 || t > 1) t -= Math.floor(t);\n  var ts = Math.abs(t - 0.5);\n  rainbow.h = 360 * t - 100;\n  rainbow.s = 1.5 - 1.5 * ts;\n  rainbow.l = 0.8 - 0.9 * ts;\n  return rainbow + \"\";\n};\n\nfunction ramp(range) {\n  var n = range.length;\n  return function(t) {\n    return range[Math.max(0, Math.min(n - 1, Math.floor(t * n)))];\n  };\n}\n\nvar viridis = ramp(colors(\"44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725\"));\n\nvar magma = ramp(colors(\"00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf\"));\n\nvar inferno = ramp(colors(\"00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4\"));\n\nvar plasma = ramp(colors(\"0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921\"));\n\nfunction sequential(interpolator) {\n  var x0 = 0,\n      x1 = 1,\n      clamp = false;\n\n  function scale(x) {\n    var t = (x - x0) / (x1 - x0);\n    return interpolator(clamp ? Math.max(0, Math.min(1, t)) : t);\n  }\n\n  scale.domain = function(_) {\n    return arguments.length ? (x0 = +_[0], x1 = +_[1], scale) : [x0, x1];\n  };\n\n  scale.clamp = function(_) {\n    return arguments.length ? (clamp = !!_, scale) : clamp;\n  };\n\n  scale.interpolator = function(_) {\n    return arguments.length ? (interpolator = _, scale) : interpolator;\n  };\n\n  scale.copy = function() {\n    return sequential(interpolator).domain([x0, x1]).clamp(clamp);\n  };\n\n  return linearish(scale);\n}\n\nvar constant$10 = function(x) {\n  return function constant() {\n    return x;\n  };\n};\n\nvar epsilon$3 = 1e-12;\nvar pi$4 = Math.PI;\nvar halfPi$3 = pi$4 / 2;\nvar tau$4 = 2 * pi$4;\n\nfunction arcInnerRadius(d) {\n  return d.innerRadius;\n}\n\nfunction arcOuterRadius(d) {\n  return d.outerRadius;\n}\n\nfunction arcStartAngle(d) {\n  return d.startAngle;\n}\n\nfunction arcEndAngle(d) {\n  return d.endAngle;\n}\n\nfunction arcPadAngle(d) {\n  return d && d.padAngle; // Note: optional!\n}\n\nfunction asin$1(x) {\n  return x >= 1 ? halfPi$3 : x <= -1 ? -halfPi$3 : Math.asin(x);\n}\n\nfunction intersect(x0, y0, x1, y1, x2, y2, x3, y3) {\n  var x10 = x1 - x0, y10 = y1 - y0,\n      x32 = x3 - x2, y32 = y3 - y2,\n      t = (x32 * (y0 - y2) - y32 * (x0 - x2)) / (y32 * x10 - x32 * y10);\n  return [x0 + t * x10, y0 + t * y10];\n}\n\n// Compute perpendicular offset line of length rc.\n// http://mathworld.wolfram.com/Circle-LineIntersection.html\nfunction cornerTangents(x0, y0, x1, y1, r1, rc, cw) {\n  var x01 = x0 - x1,\n      y01 = y0 - y1,\n      lo = (cw ? rc : -rc) / Math.sqrt(x01 * x01 + y01 * y01),\n      ox = lo * y01,\n      oy = -lo * x01,\n      x11 = x0 + ox,\n      y11 = y0 + oy,\n      x10 = x1 + ox,\n      y10 = y1 + oy,\n      x00 = (x11 + x10) / 2,\n      y00 = (y11 + y10) / 2,\n      dx = x10 - x11,\n      dy = y10 - y11,\n      d2 = dx * dx + dy * dy,\n      r = r1 - rc,\n      D = x11 * y10 - x10 * y11,\n      d = (dy < 0 ? -1 : 1) * Math.sqrt(Math.max(0, r * r * d2 - D * D)),\n      cx0 = (D * dy - dx * d) / d2,\n      cy0 = (-D * dx - dy * d) / d2,\n      cx1 = (D * dy + dx * d) / d2,\n      cy1 = (-D * dx + dy * d) / d2,\n      dx0 = cx0 - x00,\n      dy0 = cy0 - y00,\n      dx1 = cx1 - x00,\n      dy1 = cy1 - y00;\n\n  // Pick the closer of the two intersection points.\n  // TODO Is there a faster way to determine which intersection to use?\n  if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) cx0 = cx1, cy0 = cy1;\n\n  return {\n    cx: cx0,\n    cy: cy0,\n    x01: -ox,\n    y01: -oy,\n    x11: cx0 * (r1 / r - 1),\n    y11: cy0 * (r1 / r - 1)\n  };\n}\n\nvar arc = function() {\n  var innerRadius = arcInnerRadius,\n      outerRadius = arcOuterRadius,\n      cornerRadius = constant$10(0),\n      padRadius = null,\n      startAngle = arcStartAngle,\n      endAngle = arcEndAngle,\n      padAngle = arcPadAngle,\n      context = null;\n\n  function arc() {\n    var buffer,\n        r,\n        r0 = +innerRadius.apply(this, arguments),\n        r1 = +outerRadius.apply(this, arguments),\n        a0 = startAngle.apply(this, arguments) - halfPi$3,\n        a1 = endAngle.apply(this, arguments) - halfPi$3,\n        da = Math.abs(a1 - a0),\n        cw = a1 > a0;\n\n    if (!context) context = buffer = path();\n\n    // Ensure that the outer radius is always larger than the inner radius.\n    if (r1 < r0) r = r1, r1 = r0, r0 = r;\n\n    // Is it a point?\n    if (!(r1 > epsilon$3)) context.moveTo(0, 0);\n\n    // Or is it a circle or annulus?\n    else if (da > tau$4 - epsilon$3) {\n      context.moveTo(r1 * Math.cos(a0), r1 * Math.sin(a0));\n      context.arc(0, 0, r1, a0, a1, !cw);\n      if (r0 > epsilon$3) {\n        context.moveTo(r0 * Math.cos(a1), r0 * Math.sin(a1));\n        context.arc(0, 0, r0, a1, a0, cw);\n      }\n    }\n\n    // Or is it a circular or annular sector?\n    else {\n      var a01 = a0,\n          a11 = a1,\n          a00 = a0,\n          a10 = a1,\n          da0 = da,\n          da1 = da,\n          ap = padAngle.apply(this, arguments) / 2,\n          rp = (ap > epsilon$3) && (padRadius ? +padRadius.apply(this, arguments) : Math.sqrt(r0 * r0 + r1 * r1)),\n          rc = Math.min(Math.abs(r1 - r0) / 2, +cornerRadius.apply(this, arguments)),\n          rc0 = rc,\n          rc1 = rc,\n          t0,\n          t1;\n\n      // Apply padding? Note that since r1 ≥ r0, da1 ≥ da0.\n      if (rp > epsilon$3) {\n        var p0 = asin$1(rp / r0 * Math.sin(ap)),\n            p1 = asin$1(rp / r1 * Math.sin(ap));\n        if ((da0 -= p0 * 2) > epsilon$3) p0 *= (cw ? 1 : -1), a00 += p0, a10 -= p0;\n        else da0 = 0, a00 = a10 = (a0 + a1) / 2;\n        if ((da1 -= p1 * 2) > epsilon$3) p1 *= (cw ? 1 : -1), a01 += p1, a11 -= p1;\n        else da1 = 0, a01 = a11 = (a0 + a1) / 2;\n      }\n\n      var x01 = r1 * Math.cos(a01),\n          y01 = r1 * Math.sin(a01),\n          x10 = r0 * Math.cos(a10),\n          y10 = r0 * Math.sin(a10);\n\n      // Apply rounded corners?\n      if (rc > epsilon$3) {\n        var x11 = r1 * Math.cos(a11),\n            y11 = r1 * Math.sin(a11),\n            x00 = r0 * Math.cos(a00),\n            y00 = r0 * Math.sin(a00);\n\n        // Restrict the corner radius according to the sector angle.\n        if (da < pi$4) {\n          var oc = da0 > epsilon$3 ? intersect(x01, y01, x00, y00, x11, y11, x10, y10) : [x10, y10],\n              ax = x01 - oc[0],\n              ay = y01 - oc[1],\n              bx = x11 - oc[0],\n              by = y11 - oc[1],\n              kc = 1 / Math.sin(Math.acos((ax * bx + ay * by) / (Math.sqrt(ax * ax + ay * ay) * Math.sqrt(bx * bx + by * by))) / 2),\n              lc = Math.sqrt(oc[0] * oc[0] + oc[1] * oc[1]);\n          rc0 = Math.min(rc, (r0 - lc) / (kc - 1));\n          rc1 = Math.min(rc, (r1 - lc) / (kc + 1));\n        }\n      }\n\n      // Is the sector collapsed to a line?\n      if (!(da1 > epsilon$3)) context.moveTo(x01, y01);\n\n      // Does the sector’s outer ring have rounded corners?\n      else if (rc1 > epsilon$3) {\n        t0 = cornerTangents(x00, y00, x01, y01, r1, rc1, cw);\n        t1 = cornerTangents(x11, y11, x10, y10, r1, rc1, cw);\n\n        context.moveTo(t0.cx + t0.x01, t0.cy + t0.y01);\n\n        // Have the corners merged?\n        if (rc1 < rc) context.arc(t0.cx, t0.cy, rc1, Math.atan2(t0.y01, t0.x01), Math.atan2(t1.y01, t1.x01), !cw);\n\n        // Otherwise, draw the two corners and the ring.\n        else {\n          context.arc(t0.cx, t0.cy, rc1, Math.atan2(t0.y01, t0.x01), Math.atan2(t0.y11, t0.x11), !cw);\n          context.arc(0, 0, r1, Math.atan2(t0.cy + t0.y11, t0.cx + t0.x11), Math.atan2(t1.cy + t1.y11, t1.cx + t1.x11), !cw);\n          context.arc(t1.cx, t1.cy, rc1, Math.atan2(t1.y11, t1.x11), Math.atan2(t1.y01, t1.x01), !cw);\n        }\n      }\n\n      // Or is the outer ring just a circular arc?\n      else context.moveTo(x01, y01), context.arc(0, 0, r1, a01, a11, !cw);\n\n      // Is there no inner ring, and it’s a circular sector?\n      // Or perhaps it’s an annular sector collapsed due to padding?\n      if (!(r0 > epsilon$3) || !(da0 > epsilon$3)) context.lineTo(x10, y10);\n\n      // Does the sector’s inner ring (or point) have rounded corners?\n      else if (rc0 > epsilon$3) {\n        t0 = cornerTangents(x10, y10, x11, y11, r0, -rc0, cw);\n        t1 = cornerTangents(x01, y01, x00, y00, r0, -rc0, cw);\n\n        context.lineTo(t0.cx + t0.x01, t0.cy + t0.y01);\n\n        // Have the corners merged?\n        if (rc0 < rc) context.arc(t0.cx, t0.cy, rc0, Math.atan2(t0.y01, t0.x01), Math.atan2(t1.y01, t1.x01), !cw);\n\n        // Otherwise, draw the two corners and the ring.\n        else {\n          context.arc(t0.cx, t0.cy, rc0, Math.atan2(t0.y01, t0.x01), Math.atan2(t0.y11, t0.x11), !cw);\n          context.arc(0, 0, r0, Math.atan2(t0.cy + t0.y11, t0.cx + t0.x11), Math.atan2(t1.cy + t1.y11, t1.cx + t1.x11), cw);\n          context.arc(t1.cx, t1.cy, rc0, Math.atan2(t1.y11, t1.x11), Math.atan2(t1.y01, t1.x01), !cw);\n        }\n      }\n\n      // Or is the inner ring just a circular arc?\n      else context.arc(0, 0, r0, a10, a00, cw);\n    }\n\n    context.closePath();\n\n    if (buffer) return context = null, buffer + \"\" || null;\n  }\n\n  arc.centroid = function() {\n    var r = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2,\n        a = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - pi$4 / 2;\n    return [Math.cos(a) * r, Math.sin(a) * r];\n  };\n\n  arc.innerRadius = function(_) {\n    return arguments.length ? (innerRadius = typeof _ === \"function\" ? _ : constant$10(+_), arc) : innerRadius;\n  };\n\n  arc.outerRadius = function(_) {\n    return arguments.length ? (outerRadius = typeof _ === \"function\" ? _ : constant$10(+_), arc) : outerRadius;\n  };\n\n  arc.cornerRadius = function(_) {\n    return arguments.length ? (cornerRadius = typeof _ === \"function\" ? _ : constant$10(+_), arc) : cornerRadius;\n  };\n\n  arc.padRadius = function(_) {\n    return arguments.length ? (padRadius = _ == null ? null : typeof _ === \"function\" ? _ : constant$10(+_), arc) : padRadius;\n  };\n\n  arc.startAngle = function(_) {\n    return arguments.length ? (startAngle = typeof _ === \"function\" ? _ : constant$10(+_), arc) : startAngle;\n  };\n\n  arc.endAngle = function(_) {\n    return arguments.length ? (endAngle = typeof _ === \"function\" ? _ : constant$10(+_), arc) : endAngle;\n  };\n\n  arc.padAngle = function(_) {\n    return arguments.length ? (padAngle = typeof _ === \"function\" ? _ : constant$10(+_), arc) : padAngle;\n  };\n\n  arc.context = function(_) {\n    return arguments.length ? ((context = _ == null ? null : _), arc) : context;\n  };\n\n  return arc;\n};\n\nfunction Linear(context) {\n  this._context = context;\n}\n\nLinear.prototype = {\n  areaStart: function() {\n    this._line = 0;\n  },\n  areaEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._point = 0;\n  },\n  lineEnd: function() {\n    if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n    this._line = 1 - this._line;\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n    switch (this._point) {\n      case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n      case 1: this._point = 2; // proceed\n      default: this._context.lineTo(x, y); break;\n    }\n  }\n};\n\nvar curveLinear = function(context) {\n  return new Linear(context);\n};\n\nfunction x$3(p) {\n  return p[0];\n}\n\nfunction y$3(p) {\n  return p[1];\n}\n\nvar line = function() {\n  var x$$1 = x$3,\n      y$$1 = y$3,\n      defined = constant$10(true),\n      context = null,\n      curve = curveLinear,\n      output = null;\n\n  function line(data) {\n    var i,\n        n = data.length,\n        d,\n        defined0 = false,\n        buffer;\n\n    if (context == null) output = curve(buffer = path());\n\n    for (i = 0; i <= n; ++i) {\n      if (!(i < n && defined(d = data[i], i, data)) === defined0) {\n        if (defined0 = !defined0) output.lineStart();\n        else output.lineEnd();\n      }\n      if (defined0) output.point(+x$$1(d, i, data), +y$$1(d, i, data));\n    }\n\n    if (buffer) return output = null, buffer + \"\" || null;\n  }\n\n  line.x = function(_) {\n    return arguments.length ? (x$$1 = typeof _ === \"function\" ? _ : constant$10(+_), line) : x$$1;\n  };\n\n  line.y = function(_) {\n    return arguments.length ? (y$$1 = typeof _ === \"function\" ? _ : constant$10(+_), line) : y$$1;\n  };\n\n  line.defined = function(_) {\n    return arguments.length ? (defined = typeof _ === \"function\" ? _ : constant$10(!!_), line) : defined;\n  };\n\n  line.curve = function(_) {\n    return arguments.length ? (curve = _, context != null && (output = curve(context)), line) : curve;\n  };\n\n  line.context = function(_) {\n    return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), line) : context;\n  };\n\n  return line;\n};\n\nvar area$2 = function() {\n  var x0 = x$3,\n      x1 = null,\n      y0 = constant$10(0),\n      y1 = y$3,\n      defined = constant$10(true),\n      context = null,\n      curve = curveLinear,\n      output = null;\n\n  function area(data) {\n    var i,\n        j,\n        k,\n        n = data.length,\n        d,\n        defined0 = false,\n        buffer,\n        x0z = new Array(n),\n        y0z = new Array(n);\n\n    if (context == null) output = curve(buffer = path());\n\n    for (i = 0; i <= n; ++i) {\n      if (!(i < n && defined(d = data[i], i, data)) === defined0) {\n        if (defined0 = !defined0) {\n          j = i;\n          output.areaStart();\n          output.lineStart();\n        } else {\n          output.lineEnd();\n          output.lineStart();\n          for (k = i - 1; k >= j; --k) {\n            output.point(x0z[k], y0z[k]);\n          }\n          output.lineEnd();\n          output.areaEnd();\n        }\n      }\n      if (defined0) {\n        x0z[i] = +x0(d, i, data), y0z[i] = +y0(d, i, data);\n        output.point(x1 ? +x1(d, i, data) : x0z[i], y1 ? +y1(d, i, data) : y0z[i]);\n      }\n    }\n\n    if (buffer) return output = null, buffer + \"\" || null;\n  }\n\n  function arealine() {\n    return line().defined(defined).curve(curve).context(context);\n  }\n\n  area.x = function(_) {\n    return arguments.length ? (x0 = typeof _ === \"function\" ? _ : constant$10(+_), x1 = null, area) : x0;\n  };\n\n  area.x0 = function(_) {\n    return arguments.length ? (x0 = typeof _ === \"function\" ? _ : constant$10(+_), area) : x0;\n  };\n\n  area.x1 = function(_) {\n    return arguments.length ? (x1 = _ == null ? null : typeof _ === \"function\" ? _ : constant$10(+_), area) : x1;\n  };\n\n  area.y = function(_) {\n    return arguments.length ? (y0 = typeof _ === \"function\" ? _ : constant$10(+_), y1 = null, area) : y0;\n  };\n\n  area.y0 = function(_) {\n    return arguments.length ? (y0 = typeof _ === \"function\" ? _ : constant$10(+_), area) : y0;\n  };\n\n  area.y1 = function(_) {\n    return arguments.length ? (y1 = _ == null ? null : typeof _ === \"function\" ? _ : constant$10(+_), area) : y1;\n  };\n\n  area.lineX0 =\n  area.lineY0 = function() {\n    return arealine().x(x0).y(y0);\n  };\n\n  area.lineY1 = function() {\n    return arealine().x(x0).y(y1);\n  };\n\n  area.lineX1 = function() {\n    return arealine().x(x1).y(y0);\n  };\n\n  area.defined = function(_) {\n    return arguments.length ? (defined = typeof _ === \"function\" ? _ : constant$10(!!_), area) : defined;\n  };\n\n  area.curve = function(_) {\n    return arguments.length ? (curve = _, context != null && (output = curve(context)), area) : curve;\n  };\n\n  area.context = function(_) {\n    return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), area) : context;\n  };\n\n  return area;\n};\n\nvar descending$1 = function(a, b) {\n  return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;\n};\n\nvar identity$7 = function(d) {\n  return d;\n};\n\nvar pie = function() {\n  var value = identity$7,\n      sortValues = descending$1,\n      sort = null,\n      startAngle = constant$10(0),\n      endAngle = constant$10(tau$4),\n      padAngle = constant$10(0);\n\n  function pie(data) {\n    var i,\n        n = data.length,\n        j,\n        k,\n        sum = 0,\n        index = new Array(n),\n        arcs = new Array(n),\n        a0 = +startAngle.apply(this, arguments),\n        da = Math.min(tau$4, Math.max(-tau$4, endAngle.apply(this, arguments) - a0)),\n        a1,\n        p = Math.min(Math.abs(da) / n, padAngle.apply(this, arguments)),\n        pa = p * (da < 0 ? -1 : 1),\n        v;\n\n    for (i = 0; i < n; ++i) {\n      if ((v = arcs[index[i] = i] = +value(data[i], i, data)) > 0) {\n        sum += v;\n      }\n    }\n\n    // Optionally sort the arcs by previously-computed values or by data.\n    if (sortValues != null) index.sort(function(i, j) { return sortValues(arcs[i], arcs[j]); });\n    else if (sort != null) index.sort(function(i, j) { return sort(data[i], data[j]); });\n\n    // Compute the arcs! They are stored in the original data's order.\n    for (i = 0, k = sum ? (da - n * pa) / sum : 0; i < n; ++i, a0 = a1) {\n      j = index[i], v = arcs[j], a1 = a0 + (v > 0 ? v * k : 0) + pa, arcs[j] = {\n        data: data[j],\n        index: i,\n        value: v,\n        startAngle: a0,\n        endAngle: a1,\n        padAngle: p\n      };\n    }\n\n    return arcs;\n  }\n\n  pie.value = function(_) {\n    return arguments.length ? (value = typeof _ === \"function\" ? _ : constant$10(+_), pie) : value;\n  };\n\n  pie.sortValues = function(_) {\n    return arguments.length ? (sortValues = _, sort = null, pie) : sortValues;\n  };\n\n  pie.sort = function(_) {\n    return arguments.length ? (sort = _, sortValues = null, pie) : sort;\n  };\n\n  pie.startAngle = function(_) {\n    return arguments.length ? (startAngle = typeof _ === \"function\" ? _ : constant$10(+_), pie) : startAngle;\n  };\n\n  pie.endAngle = function(_) {\n    return arguments.length ? (endAngle = typeof _ === \"function\" ? _ : constant$10(+_), pie) : endAngle;\n  };\n\n  pie.padAngle = function(_) {\n    return arguments.length ? (padAngle = typeof _ === \"function\" ? _ : constant$10(+_), pie) : padAngle;\n  };\n\n  return pie;\n};\n\nvar curveRadialLinear = curveRadial(curveLinear);\n\nfunction Radial(curve) {\n  this._curve = curve;\n}\n\nRadial.prototype = {\n  areaStart: function() {\n    this._curve.areaStart();\n  },\n  areaEnd: function() {\n    this._curve.areaEnd();\n  },\n  lineStart: function() {\n    this._curve.lineStart();\n  },\n  lineEnd: function() {\n    this._curve.lineEnd();\n  },\n  point: function(a, r) {\n    this._curve.point(r * Math.sin(a), r * -Math.cos(a));\n  }\n};\n\nfunction curveRadial(curve) {\n\n  function radial(context) {\n    return new Radial(curve(context));\n  }\n\n  radial._curve = curve;\n\n  return radial;\n}\n\nfunction radialLine(l) {\n  var c = l.curve;\n\n  l.angle = l.x, delete l.x;\n  l.radius = l.y, delete l.y;\n\n  l.curve = function(_) {\n    return arguments.length ? c(curveRadial(_)) : c()._curve;\n  };\n\n  return l;\n}\n\nvar radialLine$1 = function() {\n  return radialLine(line().curve(curveRadialLinear));\n};\n\nvar radialArea = function() {\n  var a = area$2().curve(curveRadialLinear),\n      c = a.curve,\n      x0 = a.lineX0,\n      x1 = a.lineX1,\n      y0 = a.lineY0,\n      y1 = a.lineY1;\n\n  a.angle = a.x, delete a.x;\n  a.startAngle = a.x0, delete a.x0;\n  a.endAngle = a.x1, delete a.x1;\n  a.radius = a.y, delete a.y;\n  a.innerRadius = a.y0, delete a.y0;\n  a.outerRadius = a.y1, delete a.y1;\n  a.lineStartAngle = function() { return radialLine(x0()); }, delete a.lineX0;\n  a.lineEndAngle = function() { return radialLine(x1()); }, delete a.lineX1;\n  a.lineInnerRadius = function() { return radialLine(y0()); }, delete a.lineY0;\n  a.lineOuterRadius = function() { return radialLine(y1()); }, delete a.lineY1;\n\n  a.curve = function(_) {\n    return arguments.length ? c(curveRadial(_)) : c()._curve;\n  };\n\n  return a;\n};\n\nvar circle$2 = {\n  draw: function(context, size) {\n    var r = Math.sqrt(size / pi$4);\n    context.moveTo(r, 0);\n    context.arc(0, 0, r, 0, tau$4);\n  }\n};\n\nvar cross$1 = {\n  draw: function(context, size) {\n    var r = Math.sqrt(size / 5) / 2;\n    context.moveTo(-3 * r, -r);\n    context.lineTo(-r, -r);\n    context.lineTo(-r, -3 * r);\n    context.lineTo(r, -3 * r);\n    context.lineTo(r, -r);\n    context.lineTo(3 * r, -r);\n    context.lineTo(3 * r, r);\n    context.lineTo(r, r);\n    context.lineTo(r, 3 * r);\n    context.lineTo(-r, 3 * r);\n    context.lineTo(-r, r);\n    context.lineTo(-3 * r, r);\n    context.closePath();\n  }\n};\n\nvar tan30 = Math.sqrt(1 / 3);\nvar tan30_2 = tan30 * 2;\n\nvar diamond = {\n  draw: function(context, size) {\n    var y = Math.sqrt(size / tan30_2),\n        x = y * tan30;\n    context.moveTo(0, -y);\n    context.lineTo(x, 0);\n    context.lineTo(0, y);\n    context.lineTo(-x, 0);\n    context.closePath();\n  }\n};\n\nvar ka = 0.89081309152928522810;\nvar kr = Math.sin(pi$4 / 10) / Math.sin(7 * pi$4 / 10);\nvar kx = Math.sin(tau$4 / 10) * kr;\nvar ky = -Math.cos(tau$4 / 10) * kr;\n\nvar star = {\n  draw: function(context, size) {\n    var r = Math.sqrt(size * ka),\n        x = kx * r,\n        y = ky * r;\n    context.moveTo(0, -r);\n    context.lineTo(x, y);\n    for (var i = 1; i < 5; ++i) {\n      var a = tau$4 * i / 5,\n          c = Math.cos(a),\n          s = Math.sin(a);\n      context.lineTo(s * r, -c * r);\n      context.lineTo(c * x - s * y, s * x + c * y);\n    }\n    context.closePath();\n  }\n};\n\nvar square = {\n  draw: function(context, size) {\n    var w = Math.sqrt(size),\n        x = -w / 2;\n    context.rect(x, x, w, w);\n  }\n};\n\nvar sqrt3 = Math.sqrt(3);\n\nvar triangle = {\n  draw: function(context, size) {\n    var y = -Math.sqrt(size / (sqrt3 * 3));\n    context.moveTo(0, y * 2);\n    context.lineTo(-sqrt3 * y, -y);\n    context.lineTo(sqrt3 * y, -y);\n    context.closePath();\n  }\n};\n\nvar c = -0.5;\nvar s = Math.sqrt(3) / 2;\nvar k = 1 / Math.sqrt(12);\nvar a = (k / 2 + 1) * 3;\n\nvar wye = {\n  draw: function(context, size) {\n    var r = Math.sqrt(size / a),\n        x0 = r / 2,\n        y0 = r * k,\n        x1 = x0,\n        y1 = r * k + r,\n        x2 = -x1,\n        y2 = y1;\n    context.moveTo(x0, y0);\n    context.lineTo(x1, y1);\n    context.lineTo(x2, y2);\n    context.lineTo(c * x0 - s * y0, s * x0 + c * y0);\n    context.lineTo(c * x1 - s * y1, s * x1 + c * y1);\n    context.lineTo(c * x2 - s * y2, s * x2 + c * y2);\n    context.lineTo(c * x0 + s * y0, c * y0 - s * x0);\n    context.lineTo(c * x1 + s * y1, c * y1 - s * x1);\n    context.lineTo(c * x2 + s * y2, c * y2 - s * x2);\n    context.closePath();\n  }\n};\n\nvar symbols = [\n  circle$2,\n  cross$1,\n  diamond,\n  square,\n  star,\n  triangle,\n  wye\n];\n\nvar symbol = function() {\n  var type = constant$10(circle$2),\n      size = constant$10(64),\n      context = null;\n\n  function symbol() {\n    var buffer;\n    if (!context) context = buffer = path();\n    type.apply(this, arguments).draw(context, +size.apply(this, arguments));\n    if (buffer) return context = null, buffer + \"\" || null;\n  }\n\n  symbol.type = function(_) {\n    return arguments.length ? (type = typeof _ === \"function\" ? _ : constant$10(_), symbol) : type;\n  };\n\n  symbol.size = function(_) {\n    return arguments.length ? (size = typeof _ === \"function\" ? _ : constant$10(+_), symbol) : size;\n  };\n\n  symbol.context = function(_) {\n    return arguments.length ? (context = _ == null ? null : _, symbol) : context;\n  };\n\n  return symbol;\n};\n\nvar noop$2 = function() {};\n\nfunction point$2(that, x, y) {\n  that._context.bezierCurveTo(\n    (2 * that._x0 + that._x1) / 3,\n    (2 * that._y0 + that._y1) / 3,\n    (that._x0 + 2 * that._x1) / 3,\n    (that._y0 + 2 * that._y1) / 3,\n    (that._x0 + 4 * that._x1 + x) / 6,\n    (that._y0 + 4 * that._y1 + y) / 6\n  );\n}\n\nfunction Basis(context) {\n  this._context = context;\n}\n\nBasis.prototype = {\n  areaStart: function() {\n    this._line = 0;\n  },\n  areaEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._x0 = this._x1 =\n    this._y0 = this._y1 = NaN;\n    this._point = 0;\n  },\n  lineEnd: function() {\n    switch (this._point) {\n      case 3: point$2(this, this._x1, this._y1); // proceed\n      case 2: this._context.lineTo(this._x1, this._y1); break;\n    }\n    if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n    this._line = 1 - this._line;\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n    switch (this._point) {\n      case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n      case 1: this._point = 2; break;\n      case 2: this._point = 3; this._context.lineTo((5 * this._x0 + this._x1) / 6, (5 * this._y0 + this._y1) / 6); // proceed\n      default: point$2(this, x, y); break;\n    }\n    this._x0 = this._x1, this._x1 = x;\n    this._y0 = this._y1, this._y1 = y;\n  }\n};\n\nvar basis$2 = function(context) {\n  return new Basis(context);\n};\n\nfunction BasisClosed(context) {\n  this._context = context;\n}\n\nBasisClosed.prototype = {\n  areaStart: noop$2,\n  areaEnd: noop$2,\n  lineStart: function() {\n    this._x0 = this._x1 = this._x2 = this._x3 = this._x4 =\n    this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = NaN;\n    this._point = 0;\n  },\n  lineEnd: function() {\n    switch (this._point) {\n      case 1: {\n        this._context.moveTo(this._x2, this._y2);\n        this._context.closePath();\n        break;\n      }\n      case 2: {\n        this._context.moveTo((this._x2 + 2 * this._x3) / 3, (this._y2 + 2 * this._y3) / 3);\n        this._context.lineTo((this._x3 + 2 * this._x2) / 3, (this._y3 + 2 * this._y2) / 3);\n        this._context.closePath();\n        break;\n      }\n      case 3: {\n        this.point(this._x2, this._y2);\n        this.point(this._x3, this._y3);\n        this.point(this._x4, this._y4);\n        break;\n      }\n    }\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n    switch (this._point) {\n      case 0: this._point = 1; this._x2 = x, this._y2 = y; break;\n      case 1: this._point = 2; this._x3 = x, this._y3 = y; break;\n      case 2: this._point = 3; this._x4 = x, this._y4 = y; this._context.moveTo((this._x0 + 4 * this._x1 + x) / 6, (this._y0 + 4 * this._y1 + y) / 6); break;\n      default: point$2(this, x, y); break;\n    }\n    this._x0 = this._x1, this._x1 = x;\n    this._y0 = this._y1, this._y1 = y;\n  }\n};\n\nvar basisClosed$1 = function(context) {\n  return new BasisClosed(context);\n};\n\nfunction BasisOpen(context) {\n  this._context = context;\n}\n\nBasisOpen.prototype = {\n  areaStart: function() {\n    this._line = 0;\n  },\n  areaEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._x0 = this._x1 =\n    this._y0 = this._y1 = NaN;\n    this._point = 0;\n  },\n  lineEnd: function() {\n    if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath();\n    this._line = 1 - this._line;\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n    switch (this._point) {\n      case 0: this._point = 1; break;\n      case 1: this._point = 2; break;\n      case 2: this._point = 3; var x0 = (this._x0 + 4 * this._x1 + x) / 6, y0 = (this._y0 + 4 * this._y1 + y) / 6; this._line ? this._context.lineTo(x0, y0) : this._context.moveTo(x0, y0); break;\n      case 3: this._point = 4; // proceed\n      default: point$2(this, x, y); break;\n    }\n    this._x0 = this._x1, this._x1 = x;\n    this._y0 = this._y1, this._y1 = y;\n  }\n};\n\nvar basisOpen = function(context) {\n  return new BasisOpen(context);\n};\n\nfunction Bundle(context, beta) {\n  this._basis = new Basis(context);\n  this._beta = beta;\n}\n\nBundle.prototype = {\n  lineStart: function() {\n    this._x = [];\n    this._y = [];\n    this._basis.lineStart();\n  },\n  lineEnd: function() {\n    var x = this._x,\n        y = this._y,\n        j = x.length - 1;\n\n    if (j > 0) {\n      var x0 = x[0],\n          y0 = y[0],\n          dx = x[j] - x0,\n          dy = y[j] - y0,\n          i = -1,\n          t;\n\n      while (++i <= j) {\n        t = i / j;\n        this._basis.point(\n          this._beta * x[i] + (1 - this._beta) * (x0 + t * dx),\n          this._beta * y[i] + (1 - this._beta) * (y0 + t * dy)\n        );\n      }\n    }\n\n    this._x = this._y = null;\n    this._basis.lineEnd();\n  },\n  point: function(x, y) {\n    this._x.push(+x);\n    this._y.push(+y);\n  }\n};\n\nvar bundle = ((function custom(beta) {\n\n  function bundle(context) {\n    return beta === 1 ? new Basis(context) : new Bundle(context, beta);\n  }\n\n  bundle.beta = function(beta) {\n    return custom(+beta);\n  };\n\n  return bundle;\n}))(0.85);\n\nfunction point$3(that, x, y) {\n  that._context.bezierCurveTo(\n    that._x1 + that._k * (that._x2 - that._x0),\n    that._y1 + that._k * (that._y2 - that._y0),\n    that._x2 + that._k * (that._x1 - x),\n    that._y2 + that._k * (that._y1 - y),\n    that._x2,\n    that._y2\n  );\n}\n\nfunction Cardinal(context, tension) {\n  this._context = context;\n  this._k = (1 - tension) / 6;\n}\n\nCardinal.prototype = {\n  areaStart: function() {\n    this._line = 0;\n  },\n  areaEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._x0 = this._x1 = this._x2 =\n    this._y0 = this._y1 = this._y2 = NaN;\n    this._point = 0;\n  },\n  lineEnd: function() {\n    switch (this._point) {\n      case 2: this._context.lineTo(this._x2, this._y2); break;\n      case 3: point$3(this, this._x1, this._y1); break;\n    }\n    if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n    this._line = 1 - this._line;\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n    switch (this._point) {\n      case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n      case 1: this._point = 2; this._x1 = x, this._y1 = y; break;\n      case 2: this._point = 3; // proceed\n      default: point$3(this, x, y); break;\n    }\n    this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n    this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n  }\n};\n\nvar cardinal = ((function custom(tension) {\n\n  function cardinal(context) {\n    return new Cardinal(context, tension);\n  }\n\n  cardinal.tension = function(tension) {\n    return custom(+tension);\n  };\n\n  return cardinal;\n}))(0);\n\nfunction CardinalClosed(context, tension) {\n  this._context = context;\n  this._k = (1 - tension) / 6;\n}\n\nCardinalClosed.prototype = {\n  areaStart: noop$2,\n  areaEnd: noop$2,\n  lineStart: function() {\n    this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 =\n    this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN;\n    this._point = 0;\n  },\n  lineEnd: function() {\n    switch (this._point) {\n      case 1: {\n        this._context.moveTo(this._x3, this._y3);\n        this._context.closePath();\n        break;\n      }\n      case 2: {\n        this._context.lineTo(this._x3, this._y3);\n        this._context.closePath();\n        break;\n      }\n      case 3: {\n        this.point(this._x3, this._y3);\n        this.point(this._x4, this._y4);\n        this.point(this._x5, this._y5);\n        break;\n      }\n    }\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n    switch (this._point) {\n      case 0: this._point = 1; this._x3 = x, this._y3 = y; break;\n      case 1: this._point = 2; this._context.moveTo(this._x4 = x, this._y4 = y); break;\n      case 2: this._point = 3; this._x5 = x, this._y5 = y; break;\n      default: point$3(this, x, y); break;\n    }\n    this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n    this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n  }\n};\n\nvar cardinalClosed = ((function custom(tension) {\n\n  function cardinal(context) {\n    return new CardinalClosed(context, tension);\n  }\n\n  cardinal.tension = function(tension) {\n    return custom(+tension);\n  };\n\n  return cardinal;\n}))(0);\n\nfunction CardinalOpen(context, tension) {\n  this._context = context;\n  this._k = (1 - tension) / 6;\n}\n\nCardinalOpen.prototype = {\n  areaStart: function() {\n    this._line = 0;\n  },\n  areaEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._x0 = this._x1 = this._x2 =\n    this._y0 = this._y1 = this._y2 = NaN;\n    this._point = 0;\n  },\n  lineEnd: function() {\n    if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath();\n    this._line = 1 - this._line;\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n    switch (this._point) {\n      case 0: this._point = 1; break;\n      case 1: this._point = 2; break;\n      case 2: this._point = 3; this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2); break;\n      case 3: this._point = 4; // proceed\n      default: point$3(this, x, y); break;\n    }\n    this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n    this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n  }\n};\n\nvar cardinalOpen = ((function custom(tension) {\n\n  function cardinal(context) {\n    return new CardinalOpen(context, tension);\n  }\n\n  cardinal.tension = function(tension) {\n    return custom(+tension);\n  };\n\n  return cardinal;\n}))(0);\n\nfunction point$4(that, x, y) {\n  var x1 = that._x1,\n      y1 = that._y1,\n      x2 = that._x2,\n      y2 = that._y2;\n\n  if (that._l01_a > epsilon$3) {\n    var a = 2 * that._l01_2a + 3 * that._l01_a * that._l12_a + that._l12_2a,\n        n = 3 * that._l01_a * (that._l01_a + that._l12_a);\n    x1 = (x1 * a - that._x0 * that._l12_2a + that._x2 * that._l01_2a) / n;\n    y1 = (y1 * a - that._y0 * that._l12_2a + that._y2 * that._l01_2a) / n;\n  }\n\n  if (that._l23_a > epsilon$3) {\n    var b = 2 * that._l23_2a + 3 * that._l23_a * that._l12_a + that._l12_2a,\n        m = 3 * that._l23_a * (that._l23_a + that._l12_a);\n    x2 = (x2 * b + that._x1 * that._l23_2a - x * that._l12_2a) / m;\n    y2 = (y2 * b + that._y1 * that._l23_2a - y * that._l12_2a) / m;\n  }\n\n  that._context.bezierCurveTo(x1, y1, x2, y2, that._x2, that._y2);\n}\n\nfunction CatmullRom(context, alpha) {\n  this._context = context;\n  this._alpha = alpha;\n}\n\nCatmullRom.prototype = {\n  areaStart: function() {\n    this._line = 0;\n  },\n  areaEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._x0 = this._x1 = this._x2 =\n    this._y0 = this._y1 = this._y2 = NaN;\n    this._l01_a = this._l12_a = this._l23_a =\n    this._l01_2a = this._l12_2a = this._l23_2a =\n    this._point = 0;\n  },\n  lineEnd: function() {\n    switch (this._point) {\n      case 2: this._context.lineTo(this._x2, this._y2); break;\n      case 3: this.point(this._x2, this._y2); break;\n    }\n    if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n    this._line = 1 - this._line;\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n\n    if (this._point) {\n      var x23 = this._x2 - x,\n          y23 = this._y2 - y;\n      this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));\n    }\n\n    switch (this._point) {\n      case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n      case 1: this._point = 2; break;\n      case 2: this._point = 3; // proceed\n      default: point$4(this, x, y); break;\n    }\n\n    this._l01_a = this._l12_a, this._l12_a = this._l23_a;\n    this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;\n    this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n    this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n  }\n};\n\nvar catmullRom = ((function custom(alpha) {\n\n  function catmullRom(context) {\n    return alpha ? new CatmullRom(context, alpha) : new Cardinal(context, 0);\n  }\n\n  catmullRom.alpha = function(alpha) {\n    return custom(+alpha);\n  };\n\n  return catmullRom;\n}))(0.5);\n\nfunction CatmullRomClosed(context, alpha) {\n  this._context = context;\n  this._alpha = alpha;\n}\n\nCatmullRomClosed.prototype = {\n  areaStart: noop$2,\n  areaEnd: noop$2,\n  lineStart: function() {\n    this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 =\n    this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN;\n    this._l01_a = this._l12_a = this._l23_a =\n    this._l01_2a = this._l12_2a = this._l23_2a =\n    this._point = 0;\n  },\n  lineEnd: function() {\n    switch (this._point) {\n      case 1: {\n        this._context.moveTo(this._x3, this._y3);\n        this._context.closePath();\n        break;\n      }\n      case 2: {\n        this._context.lineTo(this._x3, this._y3);\n        this._context.closePath();\n        break;\n      }\n      case 3: {\n        this.point(this._x3, this._y3);\n        this.point(this._x4, this._y4);\n        this.point(this._x5, this._y5);\n        break;\n      }\n    }\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n\n    if (this._point) {\n      var x23 = this._x2 - x,\n          y23 = this._y2 - y;\n      this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));\n    }\n\n    switch (this._point) {\n      case 0: this._point = 1; this._x3 = x, this._y3 = y; break;\n      case 1: this._point = 2; this._context.moveTo(this._x4 = x, this._y4 = y); break;\n      case 2: this._point = 3; this._x5 = x, this._y5 = y; break;\n      default: point$4(this, x, y); break;\n    }\n\n    this._l01_a = this._l12_a, this._l12_a = this._l23_a;\n    this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;\n    this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n    this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n  }\n};\n\nvar catmullRomClosed = ((function custom(alpha) {\n\n  function catmullRom(context) {\n    return alpha ? new CatmullRomClosed(context, alpha) : new CardinalClosed(context, 0);\n  }\n\n  catmullRom.alpha = function(alpha) {\n    return custom(+alpha);\n  };\n\n  return catmullRom;\n}))(0.5);\n\nfunction CatmullRomOpen(context, alpha) {\n  this._context = context;\n  this._alpha = alpha;\n}\n\nCatmullRomOpen.prototype = {\n  areaStart: function() {\n    this._line = 0;\n  },\n  areaEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._x0 = this._x1 = this._x2 =\n    this._y0 = this._y1 = this._y2 = NaN;\n    this._l01_a = this._l12_a = this._l23_a =\n    this._l01_2a = this._l12_2a = this._l23_2a =\n    this._point = 0;\n  },\n  lineEnd: function() {\n    if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath();\n    this._line = 1 - this._line;\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n\n    if (this._point) {\n      var x23 = this._x2 - x,\n          y23 = this._y2 - y;\n      this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));\n    }\n\n    switch (this._point) {\n      case 0: this._point = 1; break;\n      case 1: this._point = 2; break;\n      case 2: this._point = 3; this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2); break;\n      case 3: this._point = 4; // proceed\n      default: point$4(this, x, y); break;\n    }\n\n    this._l01_a = this._l12_a, this._l12_a = this._l23_a;\n    this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;\n    this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;\n    this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;\n  }\n};\n\nvar catmullRomOpen = ((function custom(alpha) {\n\n  function catmullRom(context) {\n    return alpha ? new CatmullRomOpen(context, alpha) : new CardinalOpen(context, 0);\n  }\n\n  catmullRom.alpha = function(alpha) {\n    return custom(+alpha);\n  };\n\n  return catmullRom;\n}))(0.5);\n\nfunction LinearClosed(context) {\n  this._context = context;\n}\n\nLinearClosed.prototype = {\n  areaStart: noop$2,\n  areaEnd: noop$2,\n  lineStart: function() {\n    this._point = 0;\n  },\n  lineEnd: function() {\n    if (this._point) this._context.closePath();\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n    if (this._point) this._context.lineTo(x, y);\n    else this._point = 1, this._context.moveTo(x, y);\n  }\n};\n\nvar linearClosed = function(context) {\n  return new LinearClosed(context);\n};\n\nfunction sign$1(x) {\n  return x < 0 ? -1 : 1;\n}\n\n// Calculate the slopes of the tangents (Hermite-type interpolation) based on\n// the following paper: Steffen, M. 1990. A Simple Method for Monotonic\n// Interpolation in One Dimension. Astronomy and Astrophysics, Vol. 239, NO.\n// NOV(II), P. 443, 1990.\nfunction slope3(that, x2, y2) {\n  var h0 = that._x1 - that._x0,\n      h1 = x2 - that._x1,\n      s0 = (that._y1 - that._y0) / (h0 || h1 < 0 && -0),\n      s1 = (y2 - that._y1) / (h1 || h0 < 0 && -0),\n      p = (s0 * h1 + s1 * h0) / (h0 + h1);\n  return (sign$1(s0) + sign$1(s1)) * Math.min(Math.abs(s0), Math.abs(s1), 0.5 * Math.abs(p)) || 0;\n}\n\n// Calculate a one-sided slope.\nfunction slope2(that, t) {\n  var h = that._x1 - that._x0;\n  return h ? (3 * (that._y1 - that._y0) / h - t) / 2 : t;\n}\n\n// According to https://en.wikipedia.org/wiki/Cubic_Hermite_spline#Representations\n// \"you can express cubic Hermite interpolation in terms of cubic Bézier curves\n// with respect to the four values p0, p0 + m0 / 3, p1 - m1 / 3, p1\".\nfunction point$5(that, t0, t1) {\n  var x0 = that._x0,\n      y0 = that._y0,\n      x1 = that._x1,\n      y1 = that._y1,\n      dx = (x1 - x0) / 3;\n  that._context.bezierCurveTo(x0 + dx, y0 + dx * t0, x1 - dx, y1 - dx * t1, x1, y1);\n}\n\nfunction MonotoneX(context) {\n  this._context = context;\n}\n\nMonotoneX.prototype = {\n  areaStart: function() {\n    this._line = 0;\n  },\n  areaEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._x0 = this._x1 =\n    this._y0 = this._y1 =\n    this._t0 = NaN;\n    this._point = 0;\n  },\n  lineEnd: function() {\n    switch (this._point) {\n      case 2: this._context.lineTo(this._x1, this._y1); break;\n      case 3: point$5(this, this._t0, slope2(this, this._t0)); break;\n    }\n    if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n    this._line = 1 - this._line;\n  },\n  point: function(x, y) {\n    var t1 = NaN;\n\n    x = +x, y = +y;\n    if (x === this._x1 && y === this._y1) return; // Ignore coincident points.\n    switch (this._point) {\n      case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n      case 1: this._point = 2; break;\n      case 2: this._point = 3; point$5(this, slope2(this, t1 = slope3(this, x, y)), t1); break;\n      default: point$5(this, this._t0, t1 = slope3(this, x, y)); break;\n    }\n\n    this._x0 = this._x1, this._x1 = x;\n    this._y0 = this._y1, this._y1 = y;\n    this._t0 = t1;\n  }\n};\n\nfunction MonotoneY(context) {\n  this._context = new ReflectContext(context);\n}\n\n(MonotoneY.prototype = Object.create(MonotoneX.prototype)).point = function(x, y) {\n  MonotoneX.prototype.point.call(this, y, x);\n};\n\nfunction ReflectContext(context) {\n  this._context = context;\n}\n\nReflectContext.prototype = {\n  moveTo: function(x, y) { this._context.moveTo(y, x); },\n  closePath: function() { this._context.closePath(); },\n  lineTo: function(x, y) { this._context.lineTo(y, x); },\n  bezierCurveTo: function(x1, y1, x2, y2, x, y) { this._context.bezierCurveTo(y1, x1, y2, x2, y, x); }\n};\n\nfunction monotoneX(context) {\n  return new MonotoneX(context);\n}\n\nfunction monotoneY(context) {\n  return new MonotoneY(context);\n}\n\nfunction Natural(context) {\n  this._context = context;\n}\n\nNatural.prototype = {\n  areaStart: function() {\n    this._line = 0;\n  },\n  areaEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._x = [];\n    this._y = [];\n  },\n  lineEnd: function() {\n    var x = this._x,\n        y = this._y,\n        n = x.length;\n\n    if (n) {\n      this._line ? this._context.lineTo(x[0], y[0]) : this._context.moveTo(x[0], y[0]);\n      if (n === 2) {\n        this._context.lineTo(x[1], y[1]);\n      } else {\n        var px = controlPoints(x),\n            py = controlPoints(y);\n        for (var i0 = 0, i1 = 1; i1 < n; ++i0, ++i1) {\n          this._context.bezierCurveTo(px[0][i0], py[0][i0], px[1][i0], py[1][i0], x[i1], y[i1]);\n        }\n      }\n    }\n\n    if (this._line || (this._line !== 0 && n === 1)) this._context.closePath();\n    this._line = 1 - this._line;\n    this._x = this._y = null;\n  },\n  point: function(x, y) {\n    this._x.push(+x);\n    this._y.push(+y);\n  }\n};\n\n// See https://www.particleincell.com/2012/bezier-splines/ for derivation.\nfunction controlPoints(x) {\n  var i,\n      n = x.length - 1,\n      m,\n      a = new Array(n),\n      b = new Array(n),\n      r = new Array(n);\n  a[0] = 0, b[0] = 2, r[0] = x[0] + 2 * x[1];\n  for (i = 1; i < n - 1; ++i) a[i] = 1, b[i] = 4, r[i] = 4 * x[i] + 2 * x[i + 1];\n  a[n - 1] = 2, b[n - 1] = 7, r[n - 1] = 8 * x[n - 1] + x[n];\n  for (i = 1; i < n; ++i) m = a[i] / b[i - 1], b[i] -= m, r[i] -= m * r[i - 1];\n  a[n - 1] = r[n - 1] / b[n - 1];\n  for (i = n - 2; i >= 0; --i) a[i] = (r[i] - a[i + 1]) / b[i];\n  b[n - 1] = (x[n] + a[n - 1]) / 2;\n  for (i = 0; i < n - 1; ++i) b[i] = 2 * x[i + 1] - a[i + 1];\n  return [a, b];\n}\n\nvar natural = function(context) {\n  return new Natural(context);\n};\n\nfunction Step(context, t) {\n  this._context = context;\n  this._t = t;\n}\n\nStep.prototype = {\n  areaStart: function() {\n    this._line = 0;\n  },\n  areaEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._x = this._y = NaN;\n    this._point = 0;\n  },\n  lineEnd: function() {\n    if (0 < this._t && this._t < 1 && this._point === 2) this._context.lineTo(this._x, this._y);\n    if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();\n    if (this._line >= 0) this._t = 1 - this._t, this._line = 1 - this._line;\n  },\n  point: function(x, y) {\n    x = +x, y = +y;\n    switch (this._point) {\n      case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;\n      case 1: this._point = 2; // proceed\n      default: {\n        if (this._t <= 0) {\n          this._context.lineTo(this._x, y);\n          this._context.lineTo(x, y);\n        } else {\n          var x1 = this._x * (1 - this._t) + x * this._t;\n          this._context.lineTo(x1, this._y);\n          this._context.lineTo(x1, y);\n        }\n        break;\n      }\n    }\n    this._x = x, this._y = y;\n  }\n};\n\nvar step = function(context) {\n  return new Step(context, 0.5);\n};\n\nfunction stepBefore(context) {\n  return new Step(context, 0);\n}\n\nfunction stepAfter(context) {\n  return new Step(context, 1);\n}\n\nvar slice$5 = Array.prototype.slice;\n\nvar none$1 = function(series, order) {\n  if (!((n = series.length) > 1)) return;\n  for (var i = 1, s0, s1 = series[order[0]], n, m = s1.length; i < n; ++i) {\n    s0 = s1, s1 = series[order[i]];\n    for (var j = 0; j < m; ++j) {\n      s1[j][1] += s1[j][0] = isNaN(s0[j][1]) ? s0[j][0] : s0[j][1];\n    }\n  }\n};\n\nvar none$2 = function(series) {\n  var n = series.length, o = new Array(n);\n  while (--n >= 0) o[n] = n;\n  return o;\n};\n\nfunction stackValue(d, key) {\n  return d[key];\n}\n\nvar stack = function() {\n  var keys = constant$10([]),\n      order = none$2,\n      offset = none$1,\n      value = stackValue;\n\n  function stack(data) {\n    var kz = keys.apply(this, arguments),\n        i,\n        m = data.length,\n        n = kz.length,\n        sz = new Array(n),\n        oz;\n\n    for (i = 0; i < n; ++i) {\n      for (var ki = kz[i], si = sz[i] = new Array(m), j = 0, sij; j < m; ++j) {\n        si[j] = sij = [0, +value(data[j], ki, j, data)];\n        sij.data = data[j];\n      }\n      si.key = ki;\n    }\n\n    for (i = 0, oz = order(sz); i < n; ++i) {\n      sz[oz[i]].index = i;\n    }\n\n    offset(sz, oz);\n    return sz;\n  }\n\n  stack.keys = function(_) {\n    return arguments.length ? (keys = typeof _ === \"function\" ? _ : constant$10(slice$5.call(_)), stack) : keys;\n  };\n\n  stack.value = function(_) {\n    return arguments.length ? (value = typeof _ === \"function\" ? _ : constant$10(+_), stack) : value;\n  };\n\n  stack.order = function(_) {\n    return arguments.length ? (order = _ == null ? none$2 : typeof _ === \"function\" ? _ : constant$10(slice$5.call(_)), stack) : order;\n  };\n\n  stack.offset = function(_) {\n    return arguments.length ? (offset = _ == null ? none$1 : _, stack) : offset;\n  };\n\n  return stack;\n};\n\nvar expand = function(series, order) {\n  if (!((n = series.length) > 0)) return;\n  for (var i, n, j = 0, m = series[0].length, y; j < m; ++j) {\n    for (y = i = 0; i < n; ++i) y += series[i][j][1] || 0;\n    if (y) for (i = 0; i < n; ++i) series[i][j][1] /= y;\n  }\n  none$1(series, order);\n};\n\nvar silhouette = function(series, order) {\n  if (!((n = series.length) > 0)) return;\n  for (var j = 0, s0 = series[order[0]], n, m = s0.length; j < m; ++j) {\n    for (var i = 0, y = 0; i < n; ++i) y += series[i][j][1] || 0;\n    s0[j][1] += s0[j][0] = -y / 2;\n  }\n  none$1(series, order);\n};\n\nvar wiggle = function(series, order) {\n  if (!((n = series.length) > 0) || !((m = (s0 = series[order[0]]).length) > 0)) return;\n  for (var y = 0, j = 1, s0, m, n; j < m; ++j) {\n    for (var i = 0, s1 = 0, s2 = 0; i < n; ++i) {\n      var si = series[order[i]],\n          sij0 = si[j][1] || 0,\n          sij1 = si[j - 1][1] || 0,\n          s3 = (sij0 - sij1) / 2;\n      for (var k = 0; k < i; ++k) {\n        var sk = series[order[k]],\n            skj0 = sk[j][1] || 0,\n            skj1 = sk[j - 1][1] || 0;\n        s3 += skj0 - skj1;\n      }\n      s1 += sij0, s2 += s3 * sij0;\n    }\n    s0[j - 1][1] += s0[j - 1][0] = y;\n    if (s1) y -= s2 / s1;\n  }\n  s0[j - 1][1] += s0[j - 1][0] = y;\n  none$1(series, order);\n};\n\nvar ascending$2 = function(series) {\n  var sums = series.map(sum$2);\n  return none$2(series).sort(function(a, b) { return sums[a] - sums[b]; });\n};\n\nfunction sum$2(series) {\n  var s = 0, i = -1, n = series.length, v;\n  while (++i < n) if (v = +series[i][1]) s += v;\n  return s;\n}\n\nvar descending$2 = function(series) {\n  return ascending$2(series).reverse();\n};\n\nvar insideOut = function(series) {\n  var n = series.length,\n      i,\n      j,\n      sums = series.map(sum$2),\n      order = none$2(series).sort(function(a, b) { return sums[b] - sums[a]; }),\n      top = 0,\n      bottom = 0,\n      tops = [],\n      bottoms = [];\n\n  for (i = 0; i < n; ++i) {\n    j = order[i];\n    if (top < bottom) {\n      top += sums[j];\n      tops.push(j);\n    } else {\n      bottom += sums[j];\n      bottoms.push(j);\n    }\n  }\n\n  return bottoms.reverse().concat(tops);\n};\n\nvar reverse = function(series) {\n  return none$2(series).reverse();\n};\n\nvar constant$11 = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nfunction x$4(d) {\n  return d[0];\n}\n\nfunction y$4(d) {\n  return d[1];\n}\n\nfunction RedBlackTree() {\n  this._ = null; // root node\n}\n\nfunction RedBlackNode(node) {\n  node.U = // parent node\n  node.C = // color - true for red, false for black\n  node.L = // left node\n  node.R = // right node\n  node.P = // previous node\n  node.N = null; // next node\n}\n\nRedBlackTree.prototype = {\n  constructor: RedBlackTree,\n\n  insert: function(after, node) {\n    var parent, grandpa, uncle;\n\n    if (after) {\n      node.P = after;\n      node.N = after.N;\n      if (after.N) after.N.P = node;\n      after.N = node;\n      if (after.R) {\n        after = after.R;\n        while (after.L) after = after.L;\n        after.L = node;\n      } else {\n        after.R = node;\n      }\n      parent = after;\n    } else if (this._) {\n      after = RedBlackFirst(this._);\n      node.P = null;\n      node.N = after;\n      after.P = after.L = node;\n      parent = after;\n    } else {\n      node.P = node.N = null;\n      this._ = node;\n      parent = null;\n    }\n    node.L = node.R = null;\n    node.U = parent;\n    node.C = true;\n\n    after = node;\n    while (parent && parent.C) {\n      grandpa = parent.U;\n      if (parent === grandpa.L) {\n        uncle = grandpa.R;\n        if (uncle && uncle.C) {\n          parent.C = uncle.C = false;\n          grandpa.C = true;\n          after = grandpa;\n        } else {\n          if (after === parent.R) {\n            RedBlackRotateLeft(this, parent);\n            after = parent;\n            parent = after.U;\n          }\n          parent.C = false;\n          grandpa.C = true;\n          RedBlackRotateRight(this, grandpa);\n        }\n      } else {\n        uncle = grandpa.L;\n        if (uncle && uncle.C) {\n          parent.C = uncle.C = false;\n          grandpa.C = true;\n          after = grandpa;\n        } else {\n          if (after === parent.L) {\n            RedBlackRotateRight(this, parent);\n            after = parent;\n            parent = after.U;\n          }\n          parent.C = false;\n          grandpa.C = true;\n          RedBlackRotateLeft(this, grandpa);\n        }\n      }\n      parent = after.U;\n    }\n    this._.C = false;\n  },\n\n  remove: function(node) {\n    if (node.N) node.N.P = node.P;\n    if (node.P) node.P.N = node.N;\n    node.N = node.P = null;\n\n    var parent = node.U,\n        sibling,\n        left = node.L,\n        right = node.R,\n        next,\n        red;\n\n    if (!left) next = right;\n    else if (!right) next = left;\n    else next = RedBlackFirst(right);\n\n    if (parent) {\n      if (parent.L === node) parent.L = next;\n      else parent.R = next;\n    } else {\n      this._ = next;\n    }\n\n    if (left && right) {\n      red = next.C;\n      next.C = node.C;\n      next.L = left;\n      left.U = next;\n      if (next !== right) {\n        parent = next.U;\n        next.U = node.U;\n        node = next.R;\n        parent.L = node;\n        next.R = right;\n        right.U = next;\n      } else {\n        next.U = parent;\n        parent = next;\n        node = next.R;\n      }\n    } else {\n      red = node.C;\n      node = next;\n    }\n\n    if (node) node.U = parent;\n    if (red) return;\n    if (node && node.C) { node.C = false; return; }\n\n    do {\n      if (node === this._) break;\n      if (node === parent.L) {\n        sibling = parent.R;\n        if (sibling.C) {\n          sibling.C = false;\n          parent.C = true;\n          RedBlackRotateLeft(this, parent);\n          sibling = parent.R;\n        }\n        if ((sibling.L && sibling.L.C)\n            || (sibling.R && sibling.R.C)) {\n          if (!sibling.R || !sibling.R.C) {\n            sibling.L.C = false;\n            sibling.C = true;\n            RedBlackRotateRight(this, sibling);\n            sibling = parent.R;\n          }\n          sibling.C = parent.C;\n          parent.C = sibling.R.C = false;\n          RedBlackRotateLeft(this, parent);\n          node = this._;\n          break;\n        }\n      } else {\n        sibling = parent.L;\n        if (sibling.C) {\n          sibling.C = false;\n          parent.C = true;\n          RedBlackRotateRight(this, parent);\n          sibling = parent.L;\n        }\n        if ((sibling.L && sibling.L.C)\n          || (sibling.R && sibling.R.C)) {\n          if (!sibling.L || !sibling.L.C) {\n            sibling.R.C = false;\n            sibling.C = true;\n            RedBlackRotateLeft(this, sibling);\n            sibling = parent.L;\n          }\n          sibling.C = parent.C;\n          parent.C = sibling.L.C = false;\n          RedBlackRotateRight(this, parent);\n          node = this._;\n          break;\n        }\n      }\n      sibling.C = true;\n      node = parent;\n      parent = parent.U;\n    } while (!node.C);\n\n    if (node) node.C = false;\n  }\n};\n\nfunction RedBlackRotateLeft(tree, node) {\n  var p = node,\n      q = node.R,\n      parent = p.U;\n\n  if (parent) {\n    if (parent.L === p) parent.L = q;\n    else parent.R = q;\n  } else {\n    tree._ = q;\n  }\n\n  q.U = parent;\n  p.U = q;\n  p.R = q.L;\n  if (p.R) p.R.U = p;\n  q.L = p;\n}\n\nfunction RedBlackRotateRight(tree, node) {\n  var p = node,\n      q = node.L,\n      parent = p.U;\n\n  if (parent) {\n    if (parent.L === p) parent.L = q;\n    else parent.R = q;\n  } else {\n    tree._ = q;\n  }\n\n  q.U = parent;\n  p.U = q;\n  p.L = q.R;\n  if (p.L) p.L.U = p;\n  q.R = p;\n}\n\nfunction RedBlackFirst(node) {\n  while (node.L) node = node.L;\n  return node;\n}\n\nfunction createEdge(left, right, v0, v1) {\n  var edge = [null, null],\n      index = edges.push(edge) - 1;\n  edge.left = left;\n  edge.right = right;\n  if (v0) setEdgeEnd(edge, left, right, v0);\n  if (v1) setEdgeEnd(edge, right, left, v1);\n  cells[left.index].halfedges.push(index);\n  cells[right.index].halfedges.push(index);\n  return edge;\n}\n\nfunction createBorderEdge(left, v0, v1) {\n  var edge = [v0, v1];\n  edge.left = left;\n  return edge;\n}\n\nfunction setEdgeEnd(edge, left, right, vertex) {\n  if (!edge[0] && !edge[1]) {\n    edge[0] = vertex;\n    edge.left = left;\n    edge.right = right;\n  } else if (edge.left === right) {\n    edge[1] = vertex;\n  } else {\n    edge[0] = vertex;\n  }\n}\n\n// Liang–Barsky line clipping.\nfunction clipEdge(edge, x0, y0, x1, y1) {\n  var a = edge[0],\n      b = edge[1],\n      ax = a[0],\n      ay = a[1],\n      bx = b[0],\n      by = b[1],\n      t0 = 0,\n      t1 = 1,\n      dx = bx - ax,\n      dy = by - ay,\n      r;\n\n  r = x0 - ax;\n  if (!dx && r > 0) return;\n  r /= dx;\n  if (dx < 0) {\n    if (r < t0) return;\n    if (r < t1) t1 = r;\n  } else if (dx > 0) {\n    if (r > t1) return;\n    if (r > t0) t0 = r;\n  }\n\n  r = x1 - ax;\n  if (!dx && r < 0) return;\n  r /= dx;\n  if (dx < 0) {\n    if (r > t1) return;\n    if (r > t0) t0 = r;\n  } else if (dx > 0) {\n    if (r < t0) return;\n    if (r < t1) t1 = r;\n  }\n\n  r = y0 - ay;\n  if (!dy && r > 0) return;\n  r /= dy;\n  if (dy < 0) {\n    if (r < t0) return;\n    if (r < t1) t1 = r;\n  } else if (dy > 0) {\n    if (r > t1) return;\n    if (r > t0) t0 = r;\n  }\n\n  r = y1 - ay;\n  if (!dy && r < 0) return;\n  r /= dy;\n  if (dy < 0) {\n    if (r > t1) return;\n    if (r > t0) t0 = r;\n  } else if (dy > 0) {\n    if (r < t0) return;\n    if (r < t1) t1 = r;\n  }\n\n  if (!(t0 > 0) && !(t1 < 1)) return true; // TODO Better check?\n\n  if (t0 > 0) edge[0] = [ax + t0 * dx, ay + t0 * dy];\n  if (t1 < 1) edge[1] = [ax + t1 * dx, ay + t1 * dy];\n  return true;\n}\n\nfunction connectEdge(edge, x0, y0, x1, y1) {\n  var v1 = edge[1];\n  if (v1) return true;\n\n  var v0 = edge[0],\n      left = edge.left,\n      right = edge.right,\n      lx = left[0],\n      ly = left[1],\n      rx = right[0],\n      ry = right[1],\n      fx = (lx + rx) / 2,\n      fy = (ly + ry) / 2,\n      fm,\n      fb;\n\n  if (ry === ly) {\n    if (fx < x0 || fx >= x1) return;\n    if (lx > rx) {\n      if (!v0) v0 = [fx, y0];\n      else if (v0[1] >= y1) return;\n      v1 = [fx, y1];\n    } else {\n      if (!v0) v0 = [fx, y1];\n      else if (v0[1] < y0) return;\n      v1 = [fx, y0];\n    }\n  } else {\n    fm = (lx - rx) / (ry - ly);\n    fb = fy - fm * fx;\n    if (fm < -1 || fm > 1) {\n      if (lx > rx) {\n        if (!v0) v0 = [(y0 - fb) / fm, y0];\n        else if (v0[1] >= y1) return;\n        v1 = [(y1 - fb) / fm, y1];\n      } else {\n        if (!v0) v0 = [(y1 - fb) / fm, y1];\n        else if (v0[1] < y0) return;\n        v1 = [(y0 - fb) / fm, y0];\n      }\n    } else {\n      if (ly < ry) {\n        if (!v0) v0 = [x0, fm * x0 + fb];\n        else if (v0[0] >= x1) return;\n        v1 = [x1, fm * x1 + fb];\n      } else {\n        if (!v0) v0 = [x1, fm * x1 + fb];\n        else if (v0[0] < x0) return;\n        v1 = [x0, fm * x0 + fb];\n      }\n    }\n  }\n\n  edge[0] = v0;\n  edge[1] = v1;\n  return true;\n}\n\nfunction clipEdges(x0, y0, x1, y1) {\n  var i = edges.length,\n      edge;\n\n  while (i--) {\n    if (!connectEdge(edge = edges[i], x0, y0, x1, y1)\n        || !clipEdge(edge, x0, y0, x1, y1)\n        || !(Math.abs(edge[0][0] - edge[1][0]) > epsilon$4\n            || Math.abs(edge[0][1] - edge[1][1]) > epsilon$4)) {\n      delete edges[i];\n    }\n  }\n}\n\nfunction createCell(site) {\n  return cells[site.index] = {\n    site: site,\n    halfedges: []\n  };\n}\n\nfunction cellHalfedgeAngle(cell, edge) {\n  var site = cell.site,\n      va = edge.left,\n      vb = edge.right;\n  if (site === vb) vb = va, va = site;\n  if (vb) return Math.atan2(vb[1] - va[1], vb[0] - va[0]);\n  if (site === va) va = edge[1], vb = edge[0];\n  else va = edge[0], vb = edge[1];\n  return Math.atan2(va[0] - vb[0], vb[1] - va[1]);\n}\n\nfunction cellHalfedgeStart(cell, edge) {\n  return edge[+(edge.left !== cell.site)];\n}\n\nfunction cellHalfedgeEnd(cell, edge) {\n  return edge[+(edge.left === cell.site)];\n}\n\nfunction sortCellHalfedges() {\n  for (var i = 0, n = cells.length, cell, halfedges, j, m; i < n; ++i) {\n    if ((cell = cells[i]) && (m = (halfedges = cell.halfedges).length)) {\n      var index = new Array(m),\n          array = new Array(m);\n      for (j = 0; j < m; ++j) index[j] = j, array[j] = cellHalfedgeAngle(cell, edges[halfedges[j]]);\n      index.sort(function(i, j) { return array[j] - array[i]; });\n      for (j = 0; j < m; ++j) array[j] = halfedges[index[j]];\n      for (j = 0; j < m; ++j) halfedges[j] = array[j];\n    }\n  }\n}\n\nfunction clipCells(x0, y0, x1, y1) {\n  var nCells = cells.length,\n      iCell,\n      cell,\n      site,\n      iHalfedge,\n      halfedges,\n      nHalfedges,\n      start,\n      startX,\n      startY,\n      end,\n      endX,\n      endY,\n      cover = true;\n\n  for (iCell = 0; iCell < nCells; ++iCell) {\n    if (cell = cells[iCell]) {\n      site = cell.site;\n      halfedges = cell.halfedges;\n      iHalfedge = halfedges.length;\n\n      // Remove any dangling clipped edges.\n      while (iHalfedge--) {\n        if (!edges[halfedges[iHalfedge]]) {\n          halfedges.splice(iHalfedge, 1);\n        }\n      }\n\n      // Insert any border edges as necessary.\n      iHalfedge = 0, nHalfedges = halfedges.length;\n      while (iHalfedge < nHalfedges) {\n        end = cellHalfedgeEnd(cell, edges[halfedges[iHalfedge]]), endX = end[0], endY = end[1];\n        start = cellHalfedgeStart(cell, edges[halfedges[++iHalfedge % nHalfedges]]), startX = start[0], startY = start[1];\n        if (Math.abs(endX - startX) > epsilon$4 || Math.abs(endY - startY) > epsilon$4) {\n          halfedges.splice(iHalfedge, 0, edges.push(createBorderEdge(site, end,\n              Math.abs(endX - x0) < epsilon$4 && y1 - endY > epsilon$4 ? [x0, Math.abs(startX - x0) < epsilon$4 ? startY : y1]\n              : Math.abs(endY - y1) < epsilon$4 && x1 - endX > epsilon$4 ? [Math.abs(startY - y1) < epsilon$4 ? startX : x1, y1]\n              : Math.abs(endX - x1) < epsilon$4 && endY - y0 > epsilon$4 ? [x1, Math.abs(startX - x1) < epsilon$4 ? startY : y0]\n              : Math.abs(endY - y0) < epsilon$4 && endX - x0 > epsilon$4 ? [Math.abs(startY - y0) < epsilon$4 ? startX : x0, y0]\n              : null)) - 1);\n          ++nHalfedges;\n        }\n      }\n\n      if (nHalfedges) cover = false;\n    }\n  }\n\n  // If there weren’t any edges, have the closest site cover the extent.\n  // It doesn’t matter which corner of the extent we measure!\n  if (cover) {\n    var dx, dy, d2, dc = Infinity;\n\n    for (iCell = 0, cover = null; iCell < nCells; ++iCell) {\n      if (cell = cells[iCell]) {\n        site = cell.site;\n        dx = site[0] - x0;\n        dy = site[1] - y0;\n        d2 = dx * dx + dy * dy;\n        if (d2 < dc) dc = d2, cover = cell;\n      }\n    }\n\n    if (cover) {\n      var v00 = [x0, y0], v01 = [x0, y1], v11 = [x1, y1], v10 = [x1, y0];\n      cover.halfedges.push(\n        edges.push(createBorderEdge(site = cover.site, v00, v01)) - 1,\n        edges.push(createBorderEdge(site, v01, v11)) - 1,\n        edges.push(createBorderEdge(site, v11, v10)) - 1,\n        edges.push(createBorderEdge(site, v10, v00)) - 1\n      );\n    }\n  }\n\n  // Lastly delete any cells with no edges; these were entirely clipped.\n  for (iCell = 0; iCell < nCells; ++iCell) {\n    if (cell = cells[iCell]) {\n      if (!cell.halfedges.length) {\n        delete cells[iCell];\n      }\n    }\n  }\n}\n\nvar circlePool = [];\n\nvar firstCircle;\n\nfunction Circle() {\n  RedBlackNode(this);\n  this.x =\n  this.y =\n  this.arc =\n  this.site =\n  this.cy = null;\n}\n\nfunction attachCircle(arc) {\n  var lArc = arc.P,\n      rArc = arc.N;\n\n  if (!lArc || !rArc) return;\n\n  var lSite = lArc.site,\n      cSite = arc.site,\n      rSite = rArc.site;\n\n  if (lSite === rSite) return;\n\n  var bx = cSite[0],\n      by = cSite[1],\n      ax = lSite[0] - bx,\n      ay = lSite[1] - by,\n      cx = rSite[0] - bx,\n      cy = rSite[1] - by;\n\n  var d = 2 * (ax * cy - ay * cx);\n  if (d >= -epsilon2$2) return;\n\n  var ha = ax * ax + ay * ay,\n      hc = cx * cx + cy * cy,\n      x = (cy * ha - ay * hc) / d,\n      y = (ax * hc - cx * ha) / d;\n\n  var circle = circlePool.pop() || new Circle;\n  circle.arc = arc;\n  circle.site = cSite;\n  circle.x = x + bx;\n  circle.y = (circle.cy = y + by) + Math.sqrt(x * x + y * y); // y bottom\n\n  arc.circle = circle;\n\n  var before = null,\n      node = circles._;\n\n  while (node) {\n    if (circle.y < node.y || (circle.y === node.y && circle.x <= node.x)) {\n      if (node.L) node = node.L;\n      else { before = node.P; break; }\n    } else {\n      if (node.R) node = node.R;\n      else { before = node; break; }\n    }\n  }\n\n  circles.insert(before, circle);\n  if (!before) firstCircle = circle;\n}\n\nfunction detachCircle(arc) {\n  var circle = arc.circle;\n  if (circle) {\n    if (!circle.P) firstCircle = circle.N;\n    circles.remove(circle);\n    circlePool.push(circle);\n    RedBlackNode(circle);\n    arc.circle = null;\n  }\n}\n\nvar beachPool = [];\n\nfunction Beach() {\n  RedBlackNode(this);\n  this.edge =\n  this.site =\n  this.circle = null;\n}\n\nfunction createBeach(site) {\n  var beach = beachPool.pop() || new Beach;\n  beach.site = site;\n  return beach;\n}\n\nfunction detachBeach(beach) {\n  detachCircle(beach);\n  beaches.remove(beach);\n  beachPool.push(beach);\n  RedBlackNode(beach);\n}\n\nfunction removeBeach(beach) {\n  var circle = beach.circle,\n      x = circle.x,\n      y = circle.cy,\n      vertex = [x, y],\n      previous = beach.P,\n      next = beach.N,\n      disappearing = [beach];\n\n  detachBeach(beach);\n\n  var lArc = previous;\n  while (lArc.circle\n      && Math.abs(x - lArc.circle.x) < epsilon$4\n      && Math.abs(y - lArc.circle.cy) < epsilon$4) {\n    previous = lArc.P;\n    disappearing.unshift(lArc);\n    detachBeach(lArc);\n    lArc = previous;\n  }\n\n  disappearing.unshift(lArc);\n  detachCircle(lArc);\n\n  var rArc = next;\n  while (rArc.circle\n      && Math.abs(x - rArc.circle.x) < epsilon$4\n      && Math.abs(y - rArc.circle.cy) < epsilon$4) {\n    next = rArc.N;\n    disappearing.push(rArc);\n    detachBeach(rArc);\n    rArc = next;\n  }\n\n  disappearing.push(rArc);\n  detachCircle(rArc);\n\n  var nArcs = disappearing.length,\n      iArc;\n  for (iArc = 1; iArc < nArcs; ++iArc) {\n    rArc = disappearing[iArc];\n    lArc = disappearing[iArc - 1];\n    setEdgeEnd(rArc.edge, lArc.site, rArc.site, vertex);\n  }\n\n  lArc = disappearing[0];\n  rArc = disappearing[nArcs - 1];\n  rArc.edge = createEdge(lArc.site, rArc.site, null, vertex);\n\n  attachCircle(lArc);\n  attachCircle(rArc);\n}\n\nfunction addBeach(site) {\n  var x = site[0],\n      directrix = site[1],\n      lArc,\n      rArc,\n      dxl,\n      dxr,\n      node = beaches._;\n\n  while (node) {\n    dxl = leftBreakPoint(node, directrix) - x;\n    if (dxl > epsilon$4) node = node.L; else {\n      dxr = x - rightBreakPoint(node, directrix);\n      if (dxr > epsilon$4) {\n        if (!node.R) {\n          lArc = node;\n          break;\n        }\n        node = node.R;\n      } else {\n        if (dxl > -epsilon$4) {\n          lArc = node.P;\n          rArc = node;\n        } else if (dxr > -epsilon$4) {\n          lArc = node;\n          rArc = node.N;\n        } else {\n          lArc = rArc = node;\n        }\n        break;\n      }\n    }\n  }\n\n  createCell(site);\n  var newArc = createBeach(site);\n  beaches.insert(lArc, newArc);\n\n  if (!lArc && !rArc) return;\n\n  if (lArc === rArc) {\n    detachCircle(lArc);\n    rArc = createBeach(lArc.site);\n    beaches.insert(newArc, rArc);\n    newArc.edge = rArc.edge = createEdge(lArc.site, newArc.site);\n    attachCircle(lArc);\n    attachCircle(rArc);\n    return;\n  }\n\n  if (!rArc) { // && lArc\n    newArc.edge = createEdge(lArc.site, newArc.site);\n    return;\n  }\n\n  // else lArc !== rArc\n  detachCircle(lArc);\n  detachCircle(rArc);\n\n  var lSite = lArc.site,\n      ax = lSite[0],\n      ay = lSite[1],\n      bx = site[0] - ax,\n      by = site[1] - ay,\n      rSite = rArc.site,\n      cx = rSite[0] - ax,\n      cy = rSite[1] - ay,\n      d = 2 * (bx * cy - by * cx),\n      hb = bx * bx + by * by,\n      hc = cx * cx + cy * cy,\n      vertex = [(cy * hb - by * hc) / d + ax, (bx * hc - cx * hb) / d + ay];\n\n  setEdgeEnd(rArc.edge, lSite, rSite, vertex);\n  newArc.edge = createEdge(lSite, site, null, vertex);\n  rArc.edge = createEdge(site, rSite, null, vertex);\n  attachCircle(lArc);\n  attachCircle(rArc);\n}\n\nfunction leftBreakPoint(arc, directrix) {\n  var site = arc.site,\n      rfocx = site[0],\n      rfocy = site[1],\n      pby2 = rfocy - directrix;\n\n  if (!pby2) return rfocx;\n\n  var lArc = arc.P;\n  if (!lArc) return -Infinity;\n\n  site = lArc.site;\n  var lfocx = site[0],\n      lfocy = site[1],\n      plby2 = lfocy - directrix;\n\n  if (!plby2) return lfocx;\n\n  var hl = lfocx - rfocx,\n      aby2 = 1 / pby2 - 1 / plby2,\n      b = hl / plby2;\n\n  if (aby2) return (-b + Math.sqrt(b * b - 2 * aby2 * (hl * hl / (-2 * plby2) - lfocy + plby2 / 2 + rfocy - pby2 / 2))) / aby2 + rfocx;\n\n  return (rfocx + lfocx) / 2;\n}\n\nfunction rightBreakPoint(arc, directrix) {\n  var rArc = arc.N;\n  if (rArc) return leftBreakPoint(rArc, directrix);\n  var site = arc.site;\n  return site[1] === directrix ? site[0] : Infinity;\n}\n\nvar epsilon$4 = 1e-6;\nvar epsilon2$2 = 1e-12;\nvar beaches;\nvar cells;\nvar circles;\nvar edges;\n\nfunction triangleArea(a, b, c) {\n  return (a[0] - c[0]) * (b[1] - a[1]) - (a[0] - b[0]) * (c[1] - a[1]);\n}\n\nfunction lexicographic(a, b) {\n  return b[1] - a[1]\n      || b[0] - a[0];\n}\n\nfunction Diagram(sites, extent) {\n  var site = sites.sort(lexicographic).pop(),\n      x,\n      y,\n      circle;\n\n  edges = [];\n  cells = new Array(sites.length);\n  beaches = new RedBlackTree;\n  circles = new RedBlackTree;\n\n  while (true) {\n    circle = firstCircle;\n    if (site && (!circle || site[1] < circle.y || (site[1] === circle.y && site[0] < circle.x))) {\n      if (site[0] !== x || site[1] !== y) {\n        addBeach(site);\n        x = site[0], y = site[1];\n      }\n      site = sites.pop();\n    } else if (circle) {\n      removeBeach(circle.arc);\n    } else {\n      break;\n    }\n  }\n\n  sortCellHalfedges();\n\n  if (extent) {\n    var x0 = +extent[0][0],\n        y0 = +extent[0][1],\n        x1 = +extent[1][0],\n        y1 = +extent[1][1];\n    clipEdges(x0, y0, x1, y1);\n    clipCells(x0, y0, x1, y1);\n  }\n\n  this.edges = edges;\n  this.cells = cells;\n\n  beaches =\n  circles =\n  edges =\n  cells = null;\n}\n\nDiagram.prototype = {\n  constructor: Diagram,\n\n  polygons: function() {\n    var edges = this.edges;\n\n    return this.cells.map(function(cell) {\n      var polygon = cell.halfedges.map(function(i) { return cellHalfedgeStart(cell, edges[i]); });\n      polygon.data = cell.site.data;\n      return polygon;\n    });\n  },\n\n  triangles: function() {\n    var triangles = [],\n        edges = this.edges;\n\n    this.cells.forEach(function(cell, i) {\n      if (!(m = (halfedges = cell.halfedges).length)) return;\n      var site = cell.site,\n          halfedges,\n          j = -1,\n          m,\n          s0,\n          e1 = edges[halfedges[m - 1]],\n          s1 = e1.left === site ? e1.right : e1.left;\n\n      while (++j < m) {\n        s0 = s1;\n        e1 = edges[halfedges[j]];\n        s1 = e1.left === site ? e1.right : e1.left;\n        if (s0 && s1 && i < s0.index && i < s1.index && triangleArea(site, s0, s1) < 0) {\n          triangles.push([site.data, s0.data, s1.data]);\n        }\n      }\n    });\n\n    return triangles;\n  },\n\n  links: function() {\n    return this.edges.filter(function(edge) {\n      return edge.right;\n    }).map(function(edge) {\n      return {\n        source: edge.left.data,\n        target: edge.right.data\n      };\n    });\n  },\n\n  find: function(x, y, radius) {\n    var that = this, i0, i1 = that._found || 0, n = that.cells.length, cell;\n\n    // Use the previously-found cell, or start with an arbitrary one.\n    while (!(cell = that.cells[i1])) if (++i1 >= n) return null;\n    var dx = x - cell.site[0], dy = y - cell.site[1], d2 = dx * dx + dy * dy;\n\n    // Traverse the half-edges to find a closer cell, if any.\n    do {\n      cell = that.cells[i0 = i1], i1 = null;\n      cell.halfedges.forEach(function(e) {\n        var edge = that.edges[e], v = edge.left;\n        if ((v === cell.site || !v) && !(v = edge.right)) return;\n        var vx = x - v[0], vy = y - v[1], v2 = vx * vx + vy * vy;\n        if (v2 < d2) d2 = v2, i1 = v.index;\n      });\n    } while (i1 !== null);\n\n    that._found = i0;\n\n    return radius == null || d2 <= radius * radius ? cell.site : null;\n  }\n};\n\nvar voronoi = function() {\n  var x$$1 = x$4,\n      y$$1 = y$4,\n      extent = null;\n\n  function voronoi(data) {\n    return new Diagram(data.map(function(d, i) {\n      var s = [Math.round(x$$1(d, i, data) / epsilon$4) * epsilon$4, Math.round(y$$1(d, i, data) / epsilon$4) * epsilon$4];\n      s.index = i;\n      s.data = d;\n      return s;\n    }), extent);\n  }\n\n  voronoi.polygons = function(data) {\n    return voronoi(data).polygons();\n  };\n\n  voronoi.links = function(data) {\n    return voronoi(data).links();\n  };\n\n  voronoi.triangles = function(data) {\n    return voronoi(data).triangles();\n  };\n\n  voronoi.x = function(_) {\n    return arguments.length ? (x$$1 = typeof _ === \"function\" ? _ : constant$11(+_), voronoi) : x$$1;\n  };\n\n  voronoi.y = function(_) {\n    return arguments.length ? (y$$1 = typeof _ === \"function\" ? _ : constant$11(+_), voronoi) : y$$1;\n  };\n\n  voronoi.extent = function(_) {\n    return arguments.length ? (extent = _ == null ? null : [[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]], voronoi) : extent && [[extent[0][0], extent[0][1]], [extent[1][0], extent[1][1]]];\n  };\n\n  voronoi.size = function(_) {\n    return arguments.length ? (extent = _ == null ? null : [[0, 0], [+_[0], +_[1]]], voronoi) : extent && [extent[1][0] - extent[0][0], extent[1][1] - extent[0][1]];\n  };\n\n  return voronoi;\n};\n\nvar constant$12 = function(x) {\n  return function() {\n    return x;\n  };\n};\n\nfunction ZoomEvent(target, type, transform) {\n  this.target = target;\n  this.type = type;\n  this.transform = transform;\n}\n\nfunction Transform(k, x, y) {\n  this.k = k;\n  this.x = x;\n  this.y = y;\n}\n\nTransform.prototype = {\n  constructor: Transform,\n  scale: function(k) {\n    return k === 1 ? this : new Transform(this.k * k, this.x, this.y);\n  },\n  translate: function(x, y) {\n    return x === 0 & y === 0 ? this : new Transform(this.k, this.x + this.k * x, this.y + this.k * y);\n  },\n  apply: function(point) {\n    return [point[0] * this.k + this.x, point[1] * this.k + this.y];\n  },\n  applyX: function(x) {\n    return x * this.k + this.x;\n  },\n  applyY: function(y) {\n    return y * this.k + this.y;\n  },\n  invert: function(location) {\n    return [(location[0] - this.x) / this.k, (location[1] - this.y) / this.k];\n  },\n  invertX: function(x) {\n    return (x - this.x) / this.k;\n  },\n  invertY: function(y) {\n    return (y - this.y) / this.k;\n  },\n  rescaleX: function(x) {\n    return x.copy().domain(x.range().map(this.invertX, this).map(x.invert, x));\n  },\n  rescaleY: function(y) {\n    return y.copy().domain(y.range().map(this.invertY, this).map(y.invert, y));\n  },\n  toString: function() {\n    return \"translate(\" + this.x + \",\" + this.y + \") scale(\" + this.k + \")\";\n  }\n};\n\nvar identity$8 = new Transform(1, 0, 0);\n\ntransform$1.prototype = Transform.prototype;\n\nfunction transform$1(node) {\n  return node.__zoom || identity$8;\n}\n\nfunction nopropagation$2() {\n  exports.event.stopImmediatePropagation();\n}\n\nvar noevent$2 = function() {\n  exports.event.preventDefault();\n  exports.event.stopImmediatePropagation();\n};\n\n// Ignore right-click, since that should open the context menu.\nfunction defaultFilter$2() {\n  return !exports.event.button;\n}\n\nfunction defaultExtent$1() {\n  var e = this, w, h;\n  if (e instanceof SVGElement) {\n    e = e.ownerSVGElement || e;\n    w = e.width.baseVal.value;\n    h = e.height.baseVal.value;\n  } else {\n    w = e.clientWidth;\n    h = e.clientHeight;\n  }\n  return [[0, 0], [w, h]];\n}\n\nfunction defaultTransform() {\n  return this.__zoom || identity$8;\n}\n\nvar zoom = function() {\n  var filter = defaultFilter$2,\n      extent = defaultExtent$1,\n      k0 = 0,\n      k1 = Infinity,\n      x0 = -k1,\n      x1 = k1,\n      y0 = x0,\n      y1 = x1,\n      duration = 250,\n      interpolate$$1 = interpolateZoom,\n      gestures = [],\n      listeners = dispatch(\"start\", \"zoom\", \"end\"),\n      touchstarting,\n      touchending,\n      touchDelay = 500,\n      wheelDelay = 150;\n\n  function zoom(selection$$1) {\n    selection$$1\n        .on(\"wheel.zoom\", wheeled)\n        .on(\"mousedown.zoom\", mousedowned)\n        .on(\"dblclick.zoom\", dblclicked)\n        .on(\"touchstart.zoom\", touchstarted)\n        .on(\"touchmove.zoom\", touchmoved)\n        .on(\"touchend.zoom touchcancel.zoom\", touchended)\n        .style(\"-webkit-tap-highlight-color\", \"rgba(0,0,0,0)\")\n        .property(\"__zoom\", defaultTransform);\n  }\n\n  zoom.transform = function(collection, transform) {\n    var selection$$1 = collection.selection ? collection.selection() : collection;\n    selection$$1.property(\"__zoom\", defaultTransform);\n    if (collection !== selection$$1) {\n      schedule(collection, transform);\n    } else {\n      selection$$1.interrupt().each(function() {\n        gesture(this, arguments)\n            .start()\n            .zoom(null, typeof transform === \"function\" ? transform.apply(this, arguments) : transform)\n            .end();\n      });\n    }\n  };\n\n  zoom.scaleBy = function(selection$$1, k) {\n    zoom.scaleTo(selection$$1, function() {\n      var k0 = this.__zoom.k,\n          k1 = typeof k === \"function\" ? k.apply(this, arguments) : k;\n      return k0 * k1;\n    });\n  };\n\n  zoom.scaleTo = function(selection$$1, k) {\n    zoom.transform(selection$$1, function() {\n      var e = extent.apply(this, arguments),\n          t0 = this.__zoom,\n          p0 = centroid(e),\n          p1 = t0.invert(p0),\n          k1 = typeof k === \"function\" ? k.apply(this, arguments) : k;\n      return constrain(translate(scale(t0, k1), p0, p1), e);\n    });\n  };\n\n  zoom.translateBy = function(selection$$1, x, y) {\n    zoom.transform(selection$$1, function() {\n      return constrain(this.__zoom.translate(\n        typeof x === \"function\" ? x.apply(this, arguments) : x,\n        typeof y === \"function\" ? y.apply(this, arguments) : y\n      ), extent.apply(this, arguments));\n    });\n  };\n\n  function scale(transform, k) {\n    k = Math.max(k0, Math.min(k1, k));\n    return k === transform.k ? transform : new Transform(k, transform.x, transform.y);\n  }\n\n  function translate(transform, p0, p1) {\n    var x = p0[0] - p1[0] * transform.k, y = p0[1] - p1[1] * transform.k;\n    return x === transform.x && y === transform.y ? transform : new Transform(transform.k, x, y);\n  }\n\n  function constrain(transform, extent) {\n    var dx0 = transform.invertX(extent[0][0]) - x0,\n        dx1 = transform.invertX(extent[1][0]) - x1,\n        dy0 = transform.invertY(extent[0][1]) - y0,\n        dy1 = transform.invertY(extent[1][1]) - y1;\n    return transform.translate(\n      dx1 > dx0 ? (dx0 + dx1) / 2 : Math.min(0, dx0) || Math.max(0, dx1),\n      dy1 > dy0 ? (dy0 + dy1) / 2 : Math.min(0, dy0) || Math.max(0, dy1)\n    );\n  }\n\n  function centroid(extent) {\n    return [(+extent[0][0] + +extent[1][0]) / 2, (+extent[0][1] + +extent[1][1]) / 2];\n  }\n\n  function schedule(transition$$1, transform, center) {\n    transition$$1\n        .on(\"start.zoom\", function() { gesture(this, arguments).start(); })\n        .on(\"interrupt.zoom end.zoom\", function() { gesture(this, arguments).end(); })\n        .tween(\"zoom\", function() {\n          var that = this,\n              args = arguments,\n              g = gesture(that, args),\n              e = extent.apply(that, args),\n              p = center || centroid(e),\n              w = Math.max(e[1][0] - e[0][0], e[1][1] - e[0][1]),\n              a = that.__zoom,\n              b = typeof transform === \"function\" ? transform.apply(that, args) : transform,\n              i = interpolate$$1(a.invert(p).concat(w / a.k), b.invert(p).concat(w / b.k));\n          return function(t) {\n            if (t === 1) t = b; // Avoid rounding error on end.\n            else { var l = i(t), k = w / l[2]; t = new Transform(k, p[0] - l[0] * k, p[1] - l[1] * k); }\n            g.zoom(null, t);\n          };\n        });\n  }\n\n  function gesture(that, args) {\n    for (var i = 0, n = gestures.length, g; i < n; ++i) {\n      if ((g = gestures[i]).that === that) {\n        return g;\n      }\n    }\n    return new Gesture(that, args);\n  }\n\n  function Gesture(that, args) {\n    this.that = that;\n    this.args = args;\n    this.index = -1;\n    this.active = 0;\n    this.extent = extent.apply(that, args);\n  }\n\n  Gesture.prototype = {\n    start: function() {\n      if (++this.active === 1) {\n        this.index = gestures.push(this) - 1;\n        this.emit(\"start\");\n      }\n      return this;\n    },\n    zoom: function(key, transform) {\n      if (this.mouse && key !== \"mouse\") this.mouse[1] = transform.invert(this.mouse[0]);\n      if (this.touch0 && key !== \"touch\") this.touch0[1] = transform.invert(this.touch0[0]);\n      if (this.touch1 && key !== \"touch\") this.touch1[1] = transform.invert(this.touch1[0]);\n      this.that.__zoom = transform;\n      this.emit(\"zoom\");\n      return this;\n    },\n    end: function() {\n      if (--this.active === 0) {\n        gestures.splice(this.index, 1);\n        this.index = -1;\n        this.emit(\"end\");\n      }\n      return this;\n    },\n    emit: function(type) {\n      customEvent(new ZoomEvent(zoom, type, this.that.__zoom), listeners.apply, listeners, [type, this.that, this.args]);\n    }\n  };\n\n  function wheeled() {\n    if (!filter.apply(this, arguments)) return;\n    var g = gesture(this, arguments),\n        t = this.__zoom,\n        k = Math.max(k0, Math.min(k1, t.k * Math.pow(2, -exports.event.deltaY * (exports.event.deltaMode ? 120 : 1) / 500))),\n        p = mouse(this);\n\n    // If the mouse is in the same location as before, reuse it.\n    // If there were recent wheel events, reset the wheel idle timeout.\n    if (g.wheel) {\n      if (g.mouse[0][0] !== p[0] || g.mouse[0][1] !== p[1]) {\n        g.mouse[1] = t.invert(g.mouse[0] = p);\n      }\n      clearTimeout(g.wheel);\n    }\n\n    // If this wheel event won’t trigger a transform change, ignore it.\n    else if (t.k === k) return;\n\n    // Otherwise, capture the mouse point and location at the start.\n    else {\n      g.mouse = [p, t.invert(p)];\n      interrupt(this);\n      g.start();\n    }\n\n    noevent$2();\n    g.wheel = setTimeout(wheelidled, wheelDelay);\n    g.zoom(\"mouse\", constrain(translate(scale(t, k), g.mouse[0], g.mouse[1]), g.extent));\n\n    function wheelidled() {\n      g.wheel = null;\n      g.end();\n    }\n  }\n\n  function mousedowned() {\n    if (touchending || !filter.apply(this, arguments)) return;\n    var g = gesture(this, arguments),\n        v = select(exports.event.view).on(\"mousemove.zoom\", mousemoved, true).on(\"mouseup.zoom\", mouseupped, true),\n        p = mouse(this);\n\n    dragDisable(exports.event.view);\n    nopropagation$2();\n    g.mouse = [p, this.__zoom.invert(p)];\n    interrupt(this);\n    g.start();\n\n    function mousemoved() {\n      noevent$2();\n      g.moved = true;\n      g.zoom(\"mouse\", constrain(translate(g.that.__zoom, g.mouse[0] = mouse(g.that), g.mouse[1]), g.extent));\n    }\n\n    function mouseupped() {\n      v.on(\"mousemove.zoom mouseup.zoom\", null);\n      yesdrag(exports.event.view, g.moved);\n      noevent$2();\n      g.end();\n    }\n  }\n\n  function dblclicked() {\n    if (!filter.apply(this, arguments)) return;\n    var t0 = this.__zoom,\n        p0 = mouse(this),\n        p1 = t0.invert(p0),\n        k1 = t0.k * (exports.event.shiftKey ? 0.5 : 2),\n        t1 = constrain(translate(scale(t0, k1), p0, p1), extent.apply(this, arguments));\n\n    noevent$2();\n    if (duration > 0) select(this).transition().duration(duration).call(schedule, t1, p0);\n    else select(this).call(zoom.transform, t1);\n  }\n\n  function touchstarted() {\n    if (!filter.apply(this, arguments)) return;\n    var g = gesture(this, arguments),\n        touches$$1 = exports.event.changedTouches,\n        started,\n        n = touches$$1.length, i, t, p;\n\n    nopropagation$2();\n    for (i = 0; i < n; ++i) {\n      t = touches$$1[i], p = touch(this, touches$$1, t.identifier);\n      p = [p, this.__zoom.invert(p), t.identifier];\n      if (!g.touch0) g.touch0 = p, started = true;\n      else if (!g.touch1) g.touch1 = p;\n    }\n\n    // If this is a dbltap, reroute to the (optional) dblclick.zoom handler.\n    if (touchstarting) {\n      touchstarting = clearTimeout(touchstarting);\n      if (!g.touch1) {\n        g.end();\n        p = select(this).on(\"dblclick.zoom\");\n        if (p) p.apply(this, arguments);\n        return;\n      }\n    }\n\n    if (started) {\n      touchstarting = setTimeout(function() { touchstarting = null; }, touchDelay);\n      interrupt(this);\n      g.start();\n    }\n  }\n\n  function touchmoved() {\n    var g = gesture(this, arguments),\n        touches$$1 = exports.event.changedTouches,\n        n = touches$$1.length, i, t, p, l;\n\n    noevent$2();\n    if (touchstarting) touchstarting = clearTimeout(touchstarting);\n    for (i = 0; i < n; ++i) {\n      t = touches$$1[i], p = touch(this, touches$$1, t.identifier);\n      if (g.touch0 && g.touch0[2] === t.identifier) g.touch0[0] = p;\n      else if (g.touch1 && g.touch1[2] === t.identifier) g.touch1[0] = p;\n    }\n    t = g.that.__zoom;\n    if (g.touch1) {\n      var p0 = g.touch0[0], l0 = g.touch0[1],\n          p1 = g.touch1[0], l1 = g.touch1[1],\n          dp = (dp = p1[0] - p0[0]) * dp + (dp = p1[1] - p0[1]) * dp,\n          dl = (dl = l1[0] - l0[0]) * dl + (dl = l1[1] - l0[1]) * dl;\n      t = scale(t, Math.sqrt(dp / dl));\n      p = [(p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2];\n      l = [(l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2];\n    }\n    else if (g.touch0) p = g.touch0[0], l = g.touch0[1];\n    else return;\n    g.zoom(\"touch\", constrain(translate(t, p, l), g.extent));\n  }\n\n  function touchended() {\n    var g = gesture(this, arguments),\n        touches$$1 = exports.event.changedTouches,\n        n = touches$$1.length, i, t;\n\n    nopropagation$2();\n    if (touchending) clearTimeout(touchending);\n    touchending = setTimeout(function() { touchending = null; }, touchDelay);\n    for (i = 0; i < n; ++i) {\n      t = touches$$1[i];\n      if (g.touch0 && g.touch0[2] === t.identifier) delete g.touch0;\n      else if (g.touch1 && g.touch1[2] === t.identifier) delete g.touch1;\n    }\n    if (g.touch1 && !g.touch0) g.touch0 = g.touch1, delete g.touch1;\n    if (!g.touch0) g.end();\n  }\n\n  zoom.filter = function(_) {\n    return arguments.length ? (filter = typeof _ === \"function\" ? _ : constant$12(!!_), zoom) : filter;\n  };\n\n  zoom.extent = function(_) {\n    return arguments.length ? (extent = typeof _ === \"function\" ? _ : constant$12([[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]]), zoom) : extent;\n  };\n\n  zoom.scaleExtent = function(_) {\n    return arguments.length ? (k0 = +_[0], k1 = +_[1], zoom) : [k0, k1];\n  };\n\n  zoom.translateExtent = function(_) {\n    return arguments.length ? (x0 = +_[0][0], x1 = +_[1][0], y0 = +_[0][1], y1 = +_[1][1], zoom) : [[x0, y0], [x1, y1]];\n  };\n\n  zoom.duration = function(_) {\n    return arguments.length ? (duration = +_, zoom) : duration;\n  };\n\n  zoom.interpolate = function(_) {\n    return arguments.length ? (interpolate$$1 = _, zoom) : interpolate$$1;\n  };\n\n  zoom.on = function() {\n    var value = listeners.on.apply(listeners, arguments);\n    return value === listeners ? zoom : value;\n  };\n\n  return zoom;\n};\n\nexports.version = version;\nexports.bisect = bisectRight;\nexports.bisectRight = bisectRight;\nexports.bisectLeft = bisectLeft;\nexports.ascending = ascending;\nexports.bisector = bisector;\nexports.descending = descending;\nexports.deviation = deviation;\nexports.extent = extent;\nexports.histogram = histogram;\nexports.thresholdFreedmanDiaconis = freedmanDiaconis;\nexports.thresholdScott = scott;\nexports.thresholdSturges = sturges;\nexports.max = max;\nexports.mean = mean;\nexports.median = median;\nexports.merge = merge;\nexports.min = min;\nexports.pairs = pairs;\nexports.permute = permute;\nexports.quantile = threshold;\nexports.range = sequence;\nexports.scan = scan;\nexports.shuffle = shuffle;\nexports.sum = sum;\nexports.ticks = ticks;\nexports.tickStep = tickStep;\nexports.transpose = transpose;\nexports.variance = variance;\nexports.zip = zip;\nexports.axisTop = axisTop;\nexports.axisRight = axisRight;\nexports.axisBottom = axisBottom;\nexports.axisLeft = axisLeft;\nexports.brush = brush;\nexports.brushX = brushX;\nexports.brushY = brushY;\nexports.brushSelection = brushSelection;\nexports.chord = chord;\nexports.ribbon = ribbon;\nexports.nest = nest;\nexports.set = set$2;\nexports.map = map$1;\nexports.keys = keys;\nexports.values = values;\nexports.entries = entries;\nexports.color = color;\nexports.rgb = rgb;\nexports.hsl = hsl;\nexports.lab = lab;\nexports.hcl = hcl;\nexports.cubehelix = cubehelix;\nexports.dispatch = dispatch;\nexports.drag = drag;\nexports.dragDisable = dragDisable;\nexports.dragEnable = yesdrag;\nexports.dsvFormat = dsv;\nexports.csvParse = csvParse;\nexports.csvParseRows = csvParseRows;\nexports.csvFormat = csvFormat;\nexports.csvFormatRows = csvFormatRows;\nexports.tsvParse = tsvParse;\nexports.tsvParseRows = tsvParseRows;\nexports.tsvFormat = tsvFormat;\nexports.tsvFormatRows = tsvFormatRows;\nexports.easeLinear = linear$1;\nexports.easeQuad = quadInOut;\nexports.easeQuadIn = quadIn;\nexports.easeQuadOut = quadOut;\nexports.easeQuadInOut = quadInOut;\nexports.easeCubic = cubicInOut;\nexports.easeCubicIn = cubicIn;\nexports.easeCubicOut = cubicOut;\nexports.easeCubicInOut = cubicInOut;\nexports.easePoly = polyInOut;\nexports.easePolyIn = polyIn;\nexports.easePolyOut = polyOut;\nexports.easePolyInOut = polyInOut;\nexports.easeSin = sinInOut;\nexports.easeSinIn = sinIn;\nexports.easeSinOut = sinOut;\nexports.easeSinInOut = sinInOut;\nexports.easeExp = expInOut;\nexports.easeExpIn = expIn;\nexports.easeExpOut = expOut;\nexports.easeExpInOut = expInOut;\nexports.easeCircle = circleInOut;\nexports.easeCircleIn = circleIn;\nexports.easeCircleOut = circleOut;\nexports.easeCircleInOut = circleInOut;\nexports.easeBounce = bounceOut;\nexports.easeBounceIn = bounceIn;\nexports.easeBounceOut = bounceOut;\nexports.easeBounceInOut = bounceInOut;\nexports.easeBack = backInOut;\nexports.easeBackIn = backIn;\nexports.easeBackOut = backOut;\nexports.easeBackInOut = backInOut;\nexports.easeElastic = elasticOut;\nexports.easeElasticIn = elasticIn;\nexports.easeElasticOut = elasticOut;\nexports.easeElasticInOut = elasticInOut;\nexports.forceCenter = center$1;\nexports.forceCollide = collide;\nexports.forceLink = link;\nexports.forceManyBody = manyBody;\nexports.forceSimulation = simulation;\nexports.forceX = x$2;\nexports.forceY = y$2;\nexports.formatDefaultLocale = defaultLocale;\nexports.formatLocale = formatLocale;\nexports.formatSpecifier = formatSpecifier;\nexports.precisionFixed = precisionFixed;\nexports.precisionPrefix = precisionPrefix;\nexports.precisionRound = precisionRound;\nexports.geoArea = area;\nexports.geoBounds = bounds;\nexports.geoCentroid = centroid;\nexports.geoCircle = circle;\nexports.geoClipExtent = extent$1;\nexports.geoDistance = distance;\nexports.geoGraticule = graticule;\nexports.geoGraticule10 = graticule10;\nexports.geoInterpolate = interpolate$1;\nexports.geoLength = length$1;\nexports.geoPath = index$1;\nexports.geoAlbers = albers;\nexports.geoAlbersUsa = albersUsa;\nexports.geoAzimuthalEqualArea = azimuthalEqualArea;\nexports.geoAzimuthalEqualAreaRaw = azimuthalEqualAreaRaw;\nexports.geoAzimuthalEquidistant = azimuthalEquidistant;\nexports.geoAzimuthalEquidistantRaw = azimuthalEquidistantRaw;\nexports.geoConicConformal = conicConformal;\nexports.geoConicConformalRaw = conicConformalRaw;\nexports.geoConicEqualArea = conicEqualArea;\nexports.geoConicEqualAreaRaw = conicEqualAreaRaw;\nexports.geoConicEquidistant = conicEquidistant;\nexports.geoConicEquidistantRaw = conicEquidistantRaw;\nexports.geoEquirectangular = equirectangular;\nexports.geoEquirectangularRaw = equirectangularRaw;\nexports.geoGnomonic = gnomonic;\nexports.geoGnomonicRaw = gnomonicRaw;\nexports.geoIdentity = identity$5;\nexports.geoProjection = projection;\nexports.geoProjectionMutator = projectionMutator;\nexports.geoMercator = mercator;\nexports.geoMercatorRaw = mercatorRaw;\nexports.geoOrthographic = orthographic;\nexports.geoOrthographicRaw = orthographicRaw;\nexports.geoStereographic = stereographic;\nexports.geoStereographicRaw = stereographicRaw;\nexports.geoTransverseMercator = transverseMercator;\nexports.geoTransverseMercatorRaw = transverseMercatorRaw;\nexports.geoRotation = rotation;\nexports.geoStream = geoStream;\nexports.geoTransform = transform;\nexports.cluster = cluster;\nexports.hierarchy = hierarchy;\nexports.pack = index$2;\nexports.packSiblings = siblings;\nexports.packEnclose = enclose;\nexports.partition = partition;\nexports.stratify = stratify;\nexports.tree = tree;\nexports.treemap = index$3;\nexports.treemapBinary = binary;\nexports.treemapDice = treemapDice;\nexports.treemapSlice = treemapSlice;\nexports.treemapSliceDice = sliceDice;\nexports.treemapSquarify = squarify;\nexports.treemapResquarify = resquarify;\nexports.interpolate = interpolateValue;\nexports.interpolateArray = array$1;\nexports.interpolateBasis = basis$1;\nexports.interpolateBasisClosed = basisClosed;\nexports.interpolateDate = date;\nexports.interpolateNumber = reinterpolate;\nexports.interpolateObject = object;\nexports.interpolateRound = interpolateRound;\nexports.interpolateString = interpolateString;\nexports.interpolateTransformCss = interpolateTransformCss;\nexports.interpolateTransformSvg = interpolateTransformSvg;\nexports.interpolateZoom = interpolateZoom;\nexports.interpolateRgb = interpolateRgb;\nexports.interpolateRgbBasis = rgbBasis;\nexports.interpolateRgbBasisClosed = rgbBasisClosed;\nexports.interpolateHsl = hsl$2;\nexports.interpolateHslLong = hslLong;\nexports.interpolateLab = lab$1;\nexports.interpolateHcl = hcl$2;\nexports.interpolateHclLong = hclLong;\nexports.interpolateCubehelix = cubehelix$2;\nexports.interpolateCubehelixLong = cubehelixLong;\nexports.quantize = quantize;\nexports.path = path;\nexports.polygonArea = area$1;\nexports.polygonCentroid = centroid$1;\nexports.polygonHull = hull;\nexports.polygonContains = contains;\nexports.polygonLength = length$2;\nexports.quadtree = quadtree;\nexports.queue = queue;\nexports.randomUniform = uniform;\nexports.randomNormal = normal;\nexports.randomLogNormal = logNormal;\nexports.randomBates = bates;\nexports.randomIrwinHall = irwinHall;\nexports.randomExponential = exponential$1;\nexports.request = request;\nexports.html = html;\nexports.json = json;\nexports.text = text;\nexports.xml = xml;\nexports.csv = csv$1;\nexports.tsv = tsv$1;\nexports.scaleBand = band;\nexports.scalePoint = point$1;\nexports.scaleIdentity = identity$6;\nexports.scaleLinear = linear$2;\nexports.scaleLog = log$1;\nexports.scaleOrdinal = ordinal;\nexports.scaleImplicit = implicit;\nexports.scalePow = pow$1;\nexports.scaleSqrt = sqrt$1;\nexports.scaleQuantile = quantile$$1;\nexports.scaleQuantize = quantize$1;\nexports.scaleThreshold = threshold$1;\nexports.scaleTime = time;\nexports.scaleUtc = utcTime;\nexports.schemeCategory10 = category10;\nexports.schemeCategory20b = category20b;\nexports.schemeCategory20c = category20c;\nexports.schemeCategory20 = category20;\nexports.interpolateCubehelixDefault = cubehelix$3;\nexports.interpolateRainbow = rainbow$1;\nexports.interpolateWarm = warm;\nexports.interpolateCool = cool;\nexports.interpolateViridis = viridis;\nexports.interpolateMagma = magma;\nexports.interpolateInferno = inferno;\nexports.interpolatePlasma = plasma;\nexports.scaleSequential = sequential;\nexports.creator = creator;\nexports.local = local$1;\nexports.matcher = matcher$1;\nexports.mouse = mouse;\nexports.namespace = namespace;\nexports.namespaces = namespaces;\nexports.select = select;\nexports.selectAll = selectAll;\nexports.selection = selection;\nexports.selector = selector;\nexports.selectorAll = selectorAll;\nexports.touch = touch;\nexports.touches = touches;\nexports.window = window;\nexports.customEvent = customEvent;\nexports.arc = arc;\nexports.area = area$2;\nexports.line = line;\nexports.pie = pie;\nexports.radialArea = radialArea;\nexports.radialLine = radialLine$1;\nexports.symbol = symbol;\nexports.symbols = symbols;\nexports.symbolCircle = circle$2;\nexports.symbolCross = cross$1;\nexports.symbolDiamond = diamond;\nexports.symbolSquare = square;\nexports.symbolStar = star;\nexports.symbolTriangle = triangle;\nexports.symbolWye = wye;\nexports.curveBasisClosed = basisClosed$1;\nexports.curveBasisOpen = basisOpen;\nexports.curveBasis = basis$2;\nexports.curveBundle = bundle;\nexports.curveCardinalClosed = cardinalClosed;\nexports.curveCardinalOpen = cardinalOpen;\nexports.curveCardinal = cardinal;\nexports.curveCatmullRomClosed = catmullRomClosed;\nexports.curveCatmullRomOpen = catmullRomOpen;\nexports.curveCatmullRom = catmullRom;\nexports.curveLinearClosed = linearClosed;\nexports.curveLinear = curveLinear;\nexports.curveMonotoneX = monotoneX;\nexports.curveMonotoneY = monotoneY;\nexports.curveNatural = natural;\nexports.curveStep = step;\nexports.curveStepAfter = stepAfter;\nexports.curveStepBefore = stepBefore;\nexports.stack = stack;\nexports.stackOffsetExpand = expand;\nexports.stackOffsetNone = none$1;\nexports.stackOffsetSilhouette = silhouette;\nexports.stackOffsetWiggle = wiggle;\nexports.stackOrderAscending = ascending$2;\nexports.stackOrderDescending = descending$2;\nexports.stackOrderInsideOut = insideOut;\nexports.stackOrderNone = none$2;\nexports.stackOrderReverse = reverse;\nexports.timeInterval = newInterval;\nexports.timeMillisecond = millisecond;\nexports.timeMilliseconds = milliseconds;\nexports.utcMillisecond = millisecond;\nexports.utcMilliseconds = milliseconds;\nexports.timeSecond = second;\nexports.timeSeconds = seconds;\nexports.utcSecond = second;\nexports.utcSeconds = seconds;\nexports.timeMinute = minute;\nexports.timeMinutes = minutes;\nexports.timeHour = hour;\nexports.timeHours = hours;\nexports.timeDay = day;\nexports.timeDays = days;\nexports.timeWeek = sunday;\nexports.timeWeeks = sundays;\nexports.timeSunday = sunday;\nexports.timeSundays = sundays;\nexports.timeMonday = monday;\nexports.timeMondays = mondays;\nexports.timeTuesday = tuesday;\nexports.timeTuesdays = tuesdays;\nexports.timeWednesday = wednesday;\nexports.timeWednesdays = wednesdays;\nexports.timeThursday = thursday;\nexports.timeThursdays = thursdays;\nexports.timeFriday = friday;\nexports.timeFridays = fridays;\nexports.timeSaturday = saturday;\nexports.timeSaturdays = saturdays;\nexports.timeMonth = month;\nexports.timeMonths = months;\nexports.timeYear = year;\nexports.timeYears = years;\nexports.utcMinute = utcMinute;\nexports.utcMinutes = utcMinutes;\nexports.utcHour = utcHour;\nexports.utcHours = utcHours;\nexports.utcDay = utcDay;\nexports.utcDays = utcDays;\nexports.utcWeek = utcSunday;\nexports.utcWeeks = utcSundays;\nexports.utcSunday = utcSunday;\nexports.utcSundays = utcSundays;\nexports.utcMonday = utcMonday;\nexports.utcMondays = utcMondays;\nexports.utcTuesday = utcTuesday;\nexports.utcTuesdays = utcTuesdays;\nexports.utcWednesday = utcWednesday;\nexports.utcWednesdays = utcWednesdays;\nexports.utcThursday = utcThursday;\nexports.utcThursdays = utcThursdays;\nexports.utcFriday = utcFriday;\nexports.utcFridays = utcFridays;\nexports.utcSaturday = utcSaturday;\nexports.utcSaturdays = utcSaturdays;\nexports.utcMonth = utcMonth;\nexports.utcMonths = utcMonths;\nexports.utcYear = utcYear;\nexports.utcYears = utcYears;\nexports.timeFormatDefaultLocale = defaultLocale$1;\nexports.timeFormatLocale = formatLocale$1;\nexports.isoFormat = formatIso;\nexports.isoParse = parseIso;\nexports.now = now;\nexports.timer = timer;\nexports.timerFlush = timerFlush;\nexports.timeout = timeout$1;\nexports.interval = interval$1;\nexports.transition = transition;\nexports.active = active;\nexports.interrupt = interrupt;\nexports.voronoi = voronoi;\nexports.zoom = zoom;\nexports.zoomTransform = transform$1;\nexports.zoomIdentity = identity$8;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3/build/d3.js\n// module id = 1\n// module chunks = 0","var store      = require('./_shared')('wks')\n  , uid        = require('./_uid')\n  , Symbol     = require('./_global').Symbol\n  , USE_SYMBOL = typeof Symbol == 'function';\n\nvar $exports = module.exports = function(name){\n  return store[name] || (store[name] =\n    USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));\n};\n\n$exports.store = store;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_wks.js\n// module id = 2\n// module chunks = 0","/**\n * @license\n * Lodash <https://lodash.com/>\n * Copyright JS Foundation and other contributors <https://js.foundation/>\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;(function() {\n\n  /** Used as a safe reference for `undefined` in pre-ES5 environments. */\n  var undefined;\n\n  /** Used as the semantic version number. */\n  var VERSION = '4.17.4';\n\n  /** Used as the size to enable large array optimizations. */\n  var LARGE_ARRAY_SIZE = 200;\n\n  /** Error message constants. */\n  var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',\n      FUNC_ERROR_TEXT = 'Expected a function';\n\n  /** Used to stand-in for `undefined` hash values. */\n  var HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n  /** Used as the maximum memoize cache size. */\n  var MAX_MEMOIZE_SIZE = 500;\n\n  /** Used as the internal argument placeholder. */\n  var PLACEHOLDER = '__lodash_placeholder__';\n\n  /** Used to compose bitmasks for cloning. */\n  var CLONE_DEEP_FLAG = 1,\n      CLONE_FLAT_FLAG = 2,\n      CLONE_SYMBOLS_FLAG = 4;\n\n  /** Used to compose bitmasks for value comparisons. */\n  var COMPARE_PARTIAL_FLAG = 1,\n      COMPARE_UNORDERED_FLAG = 2;\n\n  /** Used to compose bitmasks for function metadata. */\n  var WRAP_BIND_FLAG = 1,\n      WRAP_BIND_KEY_FLAG = 2,\n      WRAP_CURRY_BOUND_FLAG = 4,\n      WRAP_CURRY_FLAG = 8,\n      WRAP_CURRY_RIGHT_FLAG = 16,\n      WRAP_PARTIAL_FLAG = 32,\n      WRAP_PARTIAL_RIGHT_FLAG = 64,\n      WRAP_ARY_FLAG = 128,\n      WRAP_REARG_FLAG = 256,\n      WRAP_FLIP_FLAG = 512;\n\n  /** Used as default options for `_.truncate`. */\n  var DEFAULT_TRUNC_LENGTH = 30,\n      DEFAULT_TRUNC_OMISSION = '...';\n\n  /** Used to detect hot functions by number of calls within a span of milliseconds. */\n  var HOT_COUNT = 800,\n      HOT_SPAN = 16;\n\n  /** Used to indicate the type of lazy iteratees. */\n  var LAZY_FILTER_FLAG = 1,\n      LAZY_MAP_FLAG = 2,\n      LAZY_WHILE_FLAG = 3;\n\n  /** Used as references for various `Number` constants. */\n  var INFINITY = 1 / 0,\n      MAX_SAFE_INTEGER = 9007199254740991,\n      MAX_INTEGER = 1.7976931348623157e+308,\n      NAN = 0 / 0;\n\n  /** Used as references for the maximum length and index of an array. */\n  var MAX_ARRAY_LENGTH = 4294967295,\n      MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,\n      HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;\n\n  /** Used to associate wrap methods with their bit flags. */\n  var wrapFlags = [\n    ['ary', WRAP_ARY_FLAG],\n    ['bind', WRAP_BIND_FLAG],\n    ['bindKey', WRAP_BIND_KEY_FLAG],\n    ['curry', WRAP_CURRY_FLAG],\n    ['curryRight', WRAP_CURRY_RIGHT_FLAG],\n    ['flip', WRAP_FLIP_FLAG],\n    ['partial', WRAP_PARTIAL_FLAG],\n    ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],\n    ['rearg', WRAP_REARG_FLAG]\n  ];\n\n  /** `Object#toString` result references. */\n  var argsTag = '[object Arguments]',\n      arrayTag = '[object Array]',\n      asyncTag = '[object AsyncFunction]',\n      boolTag = '[object Boolean]',\n      dateTag = '[object Date]',\n      domExcTag = '[object DOMException]',\n      errorTag = '[object Error]',\n      funcTag = '[object Function]',\n      genTag = '[object GeneratorFunction]',\n      mapTag = '[object Map]',\n      numberTag = '[object Number]',\n      nullTag = '[object Null]',\n      objectTag = '[object Object]',\n      promiseTag = '[object Promise]',\n      proxyTag = '[object Proxy]',\n      regexpTag = '[object RegExp]',\n      setTag = '[object Set]',\n      stringTag = '[object String]',\n      symbolTag = '[object Symbol]',\n      undefinedTag = '[object Undefined]',\n      weakMapTag = '[object WeakMap]',\n      weakSetTag = '[object WeakSet]';\n\n  var arrayBufferTag = '[object ArrayBuffer]',\n      dataViewTag = '[object DataView]',\n      float32Tag = '[object Float32Array]',\n      float64Tag = '[object Float64Array]',\n      int8Tag = '[object Int8Array]',\n      int16Tag = '[object Int16Array]',\n      int32Tag = '[object Int32Array]',\n      uint8Tag = '[object Uint8Array]',\n      uint8ClampedTag = '[object Uint8ClampedArray]',\n      uint16Tag = '[object Uint16Array]',\n      uint32Tag = '[object Uint32Array]';\n\n  /** Used to match empty string literals in compiled template source. */\n  var reEmptyStringLeading = /\\b__p \\+= '';/g,\n      reEmptyStringMiddle = /\\b(__p \\+=) '' \\+/g,\n      reEmptyStringTrailing = /(__e\\(.*?\\)|\\b__t\\)) \\+\\n'';/g;\n\n  /** Used to match HTML entities and HTML characters. */\n  var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,\n      reUnescapedHtml = /[&<>\"']/g,\n      reHasEscapedHtml = RegExp(reEscapedHtml.source),\n      reHasUnescapedHtml = RegExp(reUnescapedHtml.source);\n\n  /** Used to match template delimiters. */\n  var reEscape = /<%-([\\s\\S]+?)%>/g,\n      reEvaluate = /<%([\\s\\S]+?)%>/g,\n      reInterpolate = /<%=([\\s\\S]+?)%>/g;\n\n  /** Used to match property names within property paths. */\n  var reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/,\n      reIsPlainProp = /^\\w*$/,\n      reLeadingDot = /^\\./,\n      rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\n\n  /**\n   * Used to match `RegExp`\n   * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n   */\n  var reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g,\n      reHasRegExpChar = RegExp(reRegExpChar.source);\n\n  /** Used to match leading and trailing whitespace. */\n  var reTrim = /^\\s+|\\s+$/g,\n      reTrimStart = /^\\s+/,\n      reTrimEnd = /\\s+$/;\n\n  /** Used to match wrap detail comments. */\n  var reWrapComment = /\\{(?:\\n\\/\\* \\[wrapped with .+\\] \\*\\/)?\\n?/,\n      reWrapDetails = /\\{\\n\\/\\* \\[wrapped with (.+)\\] \\*/,\n      reSplitDetails = /,? & /;\n\n  /** Used to match words composed of alphanumeric characters. */\n  var reAsciiWord = /[^\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\x7f]+/g;\n\n  /** Used to match backslashes in property paths. */\n  var reEscapeChar = /\\\\(\\\\)?/g;\n\n  /**\n   * Used to match\n   * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).\n   */\n  var reEsTemplate = /\\$\\{([^\\\\}]*(?:\\\\.[^\\\\}]*)*)\\}/g;\n\n  /** Used to match `RegExp` flags from their coerced string values. */\n  var reFlags = /\\w*$/;\n\n  /** Used to detect bad signed hexadecimal string values. */\n  var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n  /** Used to detect binary string values. */\n  var reIsBinary = /^0b[01]+$/i;\n\n  /** Used to detect host constructors (Safari). */\n  var reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n  /** Used to detect octal string values. */\n  var reIsOctal = /^0o[0-7]+$/i;\n\n  /** Used to detect unsigned integer values. */\n  var reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n  /** Used to match Latin Unicode letters (excluding mathematical operators). */\n  var reLatin = /[\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\xff\\u0100-\\u017f]/g;\n\n  /** Used to ensure capturing order of template delimiters. */\n  var reNoMatch = /($^)/;\n\n  /** Used to match unescaped characters in compiled string literals. */\n  var reUnescapedString = /['\\n\\r\\u2028\\u2029\\\\]/g;\n\n  /** Used to compose unicode character classes. */\n  var rsAstralRange = '\\\\ud800-\\\\udfff',\n      rsComboMarksRange = '\\\\u0300-\\\\u036f',\n      reComboHalfMarksRange = '\\\\ufe20-\\\\ufe2f',\n      rsComboSymbolsRange = '\\\\u20d0-\\\\u20ff',\n      rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,\n      rsDingbatRange = '\\\\u2700-\\\\u27bf',\n      rsLowerRange = 'a-z\\\\xdf-\\\\xf6\\\\xf8-\\\\xff',\n      rsMathOpRange = '\\\\xac\\\\xb1\\\\xd7\\\\xf7',\n      rsNonCharRange = '\\\\x00-\\\\x2f\\\\x3a-\\\\x40\\\\x5b-\\\\x60\\\\x7b-\\\\xbf',\n      rsPunctuationRange = '\\\\u2000-\\\\u206f',\n      rsSpaceRange = ' \\\\t\\\\x0b\\\\f\\\\xa0\\\\ufeff\\\\n\\\\r\\\\u2028\\\\u2029\\\\u1680\\\\u180e\\\\u2000\\\\u2001\\\\u2002\\\\u2003\\\\u2004\\\\u2005\\\\u2006\\\\u2007\\\\u2008\\\\u2009\\\\u200a\\\\u202f\\\\u205f\\\\u3000',\n      rsUpperRange = 'A-Z\\\\xc0-\\\\xd6\\\\xd8-\\\\xde',\n      rsVarRange = '\\\\ufe0e\\\\ufe0f',\n      rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;\n\n  /** Used to compose unicode capture groups. */\n  var rsApos = \"['\\u2019]\",\n      rsAstral = '[' + rsAstralRange + ']',\n      rsBreak = '[' + rsBreakRange + ']',\n      rsCombo = '[' + rsComboRange + ']',\n      rsDigits = '\\\\d+',\n      rsDingbat = '[' + rsDingbatRange + ']',\n      rsLower = '[' + rsLowerRange + ']',\n      rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',\n      rsFitz = '\\\\ud83c[\\\\udffb-\\\\udfff]',\n      rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',\n      rsNonAstral = '[^' + rsAstralRange + ']',\n      rsRegional = '(?:\\\\ud83c[\\\\udde6-\\\\uddff]){2}',\n      rsSurrPair = '[\\\\ud800-\\\\udbff][\\\\udc00-\\\\udfff]',\n      rsUpper = '[' + rsUpperRange + ']',\n      rsZWJ = '\\\\u200d';\n\n  /** Used to compose unicode regexes. */\n  var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',\n      rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',\n      rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',\n      rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',\n      reOptMod = rsModifier + '?',\n      rsOptVar = '[' + rsVarRange + ']?',\n      rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',\n      rsOrdLower = '\\\\d*(?:(?:1st|2nd|3rd|(?![123])\\\\dth)\\\\b)',\n      rsOrdUpper = '\\\\d*(?:(?:1ST|2ND|3RD|(?![123])\\\\dTH)\\\\b)',\n      rsSeq = rsOptVar + reOptMod + rsOptJoin,\n      rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,\n      rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';\n\n  /** Used to match apostrophes. */\n  var reApos = RegExp(rsApos, 'g');\n\n  /**\n   * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and\n   * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).\n   */\n  var reComboMark = RegExp(rsCombo, 'g');\n\n  /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */\n  var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');\n\n  /** Used to match complex or compound words. */\n  var reUnicodeWord = RegExp([\n    rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',\n    rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',\n    rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,\n    rsUpper + '+' + rsOptContrUpper,\n    rsOrdUpper,\n    rsOrdLower,\n    rsDigits,\n    rsEmoji\n  ].join('|'), 'g');\n\n  /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */\n  var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboRange + rsVarRange + ']');\n\n  /** Used to detect strings that need a more robust regexp to match words. */\n  var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;\n\n  /** Used to assign default `context` object properties. */\n  var contextProps = [\n    'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array',\n    'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object',\n    'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array',\n    'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',\n    '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout'\n  ];\n\n  /** Used to make template sourceURLs easier to identify. */\n  var templateCounter = -1;\n\n  /** Used to identify `toStringTag` values of typed arrays. */\n  var typedArrayTags = {};\n  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\n  typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\n  typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\n  typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\n  typedArrayTags[uint32Tag] = true;\n  typedArrayTags[argsTag] = typedArrayTags[arrayTag] =\n  typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\n  typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\n  typedArrayTags[errorTag] = typedArrayTags[funcTag] =\n  typedArrayTags[mapTag] = typedArrayTags[numberTag] =\n  typedArrayTags[objectTag] = typedArrayTags[regexpTag] =\n  typedArrayTags[setTag] = typedArrayTags[stringTag] =\n  typedArrayTags[weakMapTag] = false;\n\n  /** Used to identify `toStringTag` values supported by `_.clone`. */\n  var cloneableTags = {};\n  cloneableTags[argsTag] = cloneableTags[arrayTag] =\n  cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\n  cloneableTags[boolTag] = cloneableTags[dateTag] =\n  cloneableTags[float32Tag] = cloneableTags[float64Tag] =\n  cloneableTags[int8Tag] = cloneableTags[int16Tag] =\n  cloneableTags[int32Tag] = cloneableTags[mapTag] =\n  cloneableTags[numberTag] = cloneableTags[objectTag] =\n  cloneableTags[regexpTag] = cloneableTags[setTag] =\n  cloneableTags[stringTag] = cloneableTags[symbolTag] =\n  cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\n  cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\n  cloneableTags[errorTag] = cloneableTags[funcTag] =\n  cloneableTags[weakMapTag] = false;\n\n  /** Used to map Latin Unicode letters to basic Latin letters. */\n  var deburredLetters = {\n    // Latin-1 Supplement block.\n    '\\xc0': 'A',  '\\xc1': 'A', '\\xc2': 'A', '\\xc3': 'A', '\\xc4': 'A', '\\xc5': 'A',\n    '\\xe0': 'a',  '\\xe1': 'a', '\\xe2': 'a', '\\xe3': 'a', '\\xe4': 'a', '\\xe5': 'a',\n    '\\xc7': 'C',  '\\xe7': 'c',\n    '\\xd0': 'D',  '\\xf0': 'd',\n    '\\xc8': 'E',  '\\xc9': 'E', '\\xca': 'E', '\\xcb': 'E',\n    '\\xe8': 'e',  '\\xe9': 'e', '\\xea': 'e', '\\xeb': 'e',\n    '\\xcc': 'I',  '\\xcd': 'I', '\\xce': 'I', '\\xcf': 'I',\n    '\\xec': 'i',  '\\xed': 'i', '\\xee': 'i', '\\xef': 'i',\n    '\\xd1': 'N',  '\\xf1': 'n',\n    '\\xd2': 'O',  '\\xd3': 'O', '\\xd4': 'O', '\\xd5': 'O', '\\xd6': 'O', '\\xd8': 'O',\n    '\\xf2': 'o',  '\\xf3': 'o', '\\xf4': 'o', '\\xf5': 'o', '\\xf6': 'o', '\\xf8': 'o',\n    '\\xd9': 'U',  '\\xda': 'U', '\\xdb': 'U', '\\xdc': 'U',\n    '\\xf9': 'u',  '\\xfa': 'u', '\\xfb': 'u', '\\xfc': 'u',\n    '\\xdd': 'Y',  '\\xfd': 'y', '\\xff': 'y',\n    '\\xc6': 'Ae', '\\xe6': 'ae',\n    '\\xde': 'Th', '\\xfe': 'th',\n    '\\xdf': 'ss',\n    // Latin Extended-A block.\n    '\\u0100': 'A',  '\\u0102': 'A', '\\u0104': 'A',\n    '\\u0101': 'a',  '\\u0103': 'a', '\\u0105': 'a',\n    '\\u0106': 'C',  '\\u0108': 'C', '\\u010a': 'C', '\\u010c': 'C',\n    '\\u0107': 'c',  '\\u0109': 'c', '\\u010b': 'c', '\\u010d': 'c',\n    '\\u010e': 'D',  '\\u0110': 'D', '\\u010f': 'd', '\\u0111': 'd',\n    '\\u0112': 'E',  '\\u0114': 'E', '\\u0116': 'E', '\\u0118': 'E', '\\u011a': 'E',\n    '\\u0113': 'e',  '\\u0115': 'e', '\\u0117': 'e', '\\u0119': 'e', '\\u011b': 'e',\n    '\\u011c': 'G',  '\\u011e': 'G', '\\u0120': 'G', '\\u0122': 'G',\n    '\\u011d': 'g',  '\\u011f': 'g', '\\u0121': 'g', '\\u0123': 'g',\n    '\\u0124': 'H',  '\\u0126': 'H', '\\u0125': 'h', '\\u0127': 'h',\n    '\\u0128': 'I',  '\\u012a': 'I', '\\u012c': 'I', '\\u012e': 'I', '\\u0130': 'I',\n    '\\u0129': 'i',  '\\u012b': 'i', '\\u012d': 'i', '\\u012f': 'i', '\\u0131': 'i',\n    '\\u0134': 'J',  '\\u0135': 'j',\n    '\\u0136': 'K',  '\\u0137': 'k', '\\u0138': 'k',\n    '\\u0139': 'L',  '\\u013b': 'L', '\\u013d': 'L', '\\u013f': 'L', '\\u0141': 'L',\n    '\\u013a': 'l',  '\\u013c': 'l', '\\u013e': 'l', '\\u0140': 'l', '\\u0142': 'l',\n    '\\u0143': 'N',  '\\u0145': 'N', '\\u0147': 'N', '\\u014a': 'N',\n    '\\u0144': 'n',  '\\u0146': 'n', '\\u0148': 'n', '\\u014b': 'n',\n    '\\u014c': 'O',  '\\u014e': 'O', '\\u0150': 'O',\n    '\\u014d': 'o',  '\\u014f': 'o', '\\u0151': 'o',\n    '\\u0154': 'R',  '\\u0156': 'R', '\\u0158': 'R',\n    '\\u0155': 'r',  '\\u0157': 'r', '\\u0159': 'r',\n    '\\u015a': 'S',  '\\u015c': 'S', '\\u015e': 'S', '\\u0160': 'S',\n    '\\u015b': 's',  '\\u015d': 's', '\\u015f': 's', '\\u0161': 's',\n    '\\u0162': 'T',  '\\u0164': 'T', '\\u0166': 'T',\n    '\\u0163': 't',  '\\u0165': 't', '\\u0167': 't',\n    '\\u0168': 'U',  '\\u016a': 'U', '\\u016c': 'U', '\\u016e': 'U', '\\u0170': 'U', '\\u0172': 'U',\n    '\\u0169': 'u',  '\\u016b': 'u', '\\u016d': 'u', '\\u016f': 'u', '\\u0171': 'u', '\\u0173': 'u',\n    '\\u0174': 'W',  '\\u0175': 'w',\n    '\\u0176': 'Y',  '\\u0177': 'y', '\\u0178': 'Y',\n    '\\u0179': 'Z',  '\\u017b': 'Z', '\\u017d': 'Z',\n    '\\u017a': 'z',  '\\u017c': 'z', '\\u017e': 'z',\n    '\\u0132': 'IJ', '\\u0133': 'ij',\n    '\\u0152': 'Oe', '\\u0153': 'oe',\n    '\\u0149': \"'n\", '\\u017f': 's'\n  };\n\n  /** Used to map characters to HTML entities. */\n  var htmlEscapes = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#39;'\n  };\n\n  /** Used to map HTML entities to characters. */\n  var htmlUnescapes = {\n    '&amp;': '&',\n    '&lt;': '<',\n    '&gt;': '>',\n    '&quot;': '\"',\n    '&#39;': \"'\"\n  };\n\n  /** Used to escape characters for inclusion in compiled string literals. */\n  var stringEscapes = {\n    '\\\\': '\\\\',\n    \"'\": \"'\",\n    '\\n': 'n',\n    '\\r': 'r',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  /** Built-in method references without a dependency on `root`. */\n  var freeParseFloat = parseFloat,\n      freeParseInt = parseInt;\n\n  /** Detect free variable `global` from Node.js. */\n  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n  /** Detect free variable `self`. */\n  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n  /** Used as a reference to the global object. */\n  var root = freeGlobal || freeSelf || Function('return this')();\n\n  /** Detect free variable `exports`. */\n  var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n  /** Detect free variable `module`. */\n  var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n  /** Detect the popular CommonJS extension `module.exports`. */\n  var moduleExports = freeModule && freeModule.exports === freeExports;\n\n  /** Detect free variable `process` from Node.js. */\n  var freeProcess = moduleExports && freeGlobal.process;\n\n  /** Used to access faster Node.js helpers. */\n  var nodeUtil = (function() {\n    try {\n      return freeProcess && freeProcess.binding && freeProcess.binding('util');\n    } catch (e) {}\n  }());\n\n  /* Node.js helper references. */\n  var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,\n      nodeIsDate = nodeUtil && nodeUtil.isDate,\n      nodeIsMap = nodeUtil && nodeUtil.isMap,\n      nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,\n      nodeIsSet = nodeUtil && nodeUtil.isSet,\n      nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n  /*--------------------------------------------------------------------------*/\n\n  /**\n   * Adds the key-value `pair` to `map`.\n   *\n   * @private\n   * @param {Object} map The map to modify.\n   * @param {Array} pair The key-value pair to add.\n   * @returns {Object} Returns `map`.\n   */\n  function addMapEntry(map, pair) {\n    // Don't return `map.set` because it's not chainable in IE 11.\n    map.set(pair[0], pair[1]);\n    return map;\n  }\n\n  /**\n   * Adds `value` to `set`.\n   *\n   * @private\n   * @param {Object} set The set to modify.\n   * @param {*} value The value to add.\n   * @returns {Object} Returns `set`.\n   */\n  function addSetEntry(set, value) {\n    // Don't return `set.add` because it's not chainable in IE 11.\n    set.add(value);\n    return set;\n  }\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   */\n  function 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   * A specialized version of `baseAggregator` for arrays.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} setter The function to set `accumulator` values.\n   * @param {Function} iteratee The iteratee to transform keys.\n   * @param {Object} accumulator The initial aggregated object.\n   * @returns {Function} Returns `accumulator`.\n   */\n  function arrayAggregator(array, setter, iteratee, accumulator) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      var value = array[index];\n      setter(accumulator, value, iteratee(value), array);\n    }\n    return accumulator;\n  }\n\n  /**\n   * A specialized version of `_.forEach` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {Array} Returns `array`.\n   */\n  function arrayEach(array, iteratee) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (iteratee(array[index], index, array) === false) {\n        break;\n      }\n    }\n    return array;\n  }\n\n  /**\n   * A specialized version of `_.forEachRight` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {Array} Returns `array`.\n   */\n  function arrayEachRight(array, iteratee) {\n    var length = array == null ? 0 : array.length;\n\n    while (length--) {\n      if (iteratee(array[length], length, array) === false) {\n        break;\n      }\n    }\n    return array;\n  }\n\n  /**\n   * A specialized version of `_.every` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} predicate The function invoked per iteration.\n   * @returns {boolean} Returns `true` if all elements pass the predicate check,\n   *  else `false`.\n   */\n  function arrayEvery(array, predicate) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (!predicate(array[index], index, array)) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * A specialized version of `_.filter` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} predicate The function invoked per iteration.\n   * @returns {Array} Returns the new filtered array.\n   */\n  function arrayFilter(array, predicate) {\n    var index = -1,\n        length = array == null ? 0 : array.length,\n        resIndex = 0,\n        result = [];\n\n    while (++index < length) {\n      var value = array[index];\n      if (predicate(value, index, array)) {\n        result[resIndex++] = value;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * A specialized version of `_.includes` for arrays without support for\n   * specifying an index to search from.\n   *\n   * @private\n   * @param {Array} [array] The array to inspect.\n   * @param {*} target The value to search for.\n   * @returns {boolean} Returns `true` if `target` is found, else `false`.\n   */\n  function arrayIncludes(array, value) {\n    var length = array == null ? 0 : array.length;\n    return !!length && baseIndexOf(array, value, 0) > -1;\n  }\n\n  /**\n   * This function is like `arrayIncludes` except that it accepts a comparator.\n   *\n   * @private\n   * @param {Array} [array] The array to inspect.\n   * @param {*} target The value to search for.\n   * @param {Function} comparator The comparator invoked per element.\n   * @returns {boolean} Returns `true` if `target` is found, else `false`.\n   */\n  function arrayIncludesWith(array, value, comparator) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (comparator(value, array[index])) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * A specialized version of `_.map` for arrays without support for iteratee\n   * shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {Array} Returns the new mapped array.\n   */\n  function arrayMap(array, iteratee) {\n    var index = -1,\n        length = array == null ? 0 : array.length,\n        result = Array(length);\n\n    while (++index < length) {\n      result[index] = iteratee(array[index], index, array);\n    }\n    return result;\n  }\n\n  /**\n   * Appends the elements of `values` to `array`.\n   *\n   * @private\n   * @param {Array} array The array to modify.\n   * @param {Array} values The values to append.\n   * @returns {Array} Returns `array`.\n   */\n  function arrayPush(array, values) {\n    var index = -1,\n        length = values.length,\n        offset = array.length;\n\n    while (++index < length) {\n      array[offset + index] = values[index];\n    }\n    return array;\n  }\n\n  /**\n   * A specialized version of `_.reduce` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @param {*} [accumulator] The initial value.\n   * @param {boolean} [initAccum] Specify using the first element of `array` as\n   *  the initial value.\n   * @returns {*} Returns the accumulated value.\n   */\n  function arrayReduce(array, iteratee, accumulator, initAccum) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    if (initAccum && length) {\n      accumulator = array[++index];\n    }\n    while (++index < length) {\n      accumulator = iteratee(accumulator, array[index], index, array);\n    }\n    return accumulator;\n  }\n\n  /**\n   * A specialized version of `_.reduceRight` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @param {*} [accumulator] The initial value.\n   * @param {boolean} [initAccum] Specify using the last element of `array` as\n   *  the initial value.\n   * @returns {*} Returns the accumulated value.\n   */\n  function arrayReduceRight(array, iteratee, accumulator, initAccum) {\n    var length = array == null ? 0 : array.length;\n    if (initAccum && length) {\n      accumulator = array[--length];\n    }\n    while (length--) {\n      accumulator = iteratee(accumulator, array[length], length, array);\n    }\n    return accumulator;\n  }\n\n  /**\n   * A specialized version of `_.some` for arrays without support for iteratee\n   * shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} predicate The function invoked per iteration.\n   * @returns {boolean} Returns `true` if any element passes the predicate check,\n   *  else `false`.\n   */\n  function arraySome(array, predicate) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (predicate(array[index], index, array)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Gets the size of an ASCII `string`.\n   *\n   * @private\n   * @param {string} string The string inspect.\n   * @returns {number} Returns the string size.\n   */\n  var asciiSize = baseProperty('length');\n\n  /**\n   * Converts an ASCII `string` to an array.\n   *\n   * @private\n   * @param {string} string The string to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function asciiToArray(string) {\n    return string.split('');\n  }\n\n  /**\n   * Splits an ASCII `string` into an array of its words.\n   *\n   * @private\n   * @param {string} The string to inspect.\n   * @returns {Array} Returns the words of `string`.\n   */\n  function asciiWords(string) {\n    return string.match(reAsciiWord) || [];\n  }\n\n  /**\n   * The base implementation of methods like `_.findKey` and `_.findLastKey`,\n   * without support for iteratee shorthands, which iterates over `collection`\n   * using `eachFunc`.\n   *\n   * @private\n   * @param {Array|Object} collection The collection to inspect.\n   * @param {Function} predicate The function invoked per iteration.\n   * @param {Function} eachFunc The function to iterate over `collection`.\n   * @returns {*} Returns the found element or its key, else `undefined`.\n   */\n  function baseFindKey(collection, predicate, eachFunc) {\n    var result;\n    eachFunc(collection, function(value, key, collection) {\n      if (predicate(value, key, collection)) {\n        result = key;\n        return false;\n      }\n    });\n    return result;\n  }\n\n  /**\n   * The base implementation of `_.findIndex` and `_.findLastIndex` without\n   * support for iteratee shorthands.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {Function} predicate The function invoked per iteration.\n   * @param {number} fromIndex The index to search from.\n   * @param {boolean} [fromRight] Specify iterating from right to left.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function baseFindIndex(array, predicate, fromIndex, fromRight) {\n    var length = array.length,\n        index = fromIndex + (fromRight ? 1 : -1);\n\n    while ((fromRight ? index-- : ++index < length)) {\n      if (predicate(array[index], index, array)) {\n        return index;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * The base implementation of `_.indexOf` without `fromIndex` bounds checks.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function baseIndexOf(array, value, fromIndex) {\n    return value === value\n      ? strictIndexOf(array, value, fromIndex)\n      : baseFindIndex(array, baseIsNaN, fromIndex);\n  }\n\n  /**\n   * This function is like `baseIndexOf` except that it accepts a comparator.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @param {Function} comparator The comparator invoked per element.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function baseIndexOfWith(array, value, fromIndex, comparator) {\n    var index = fromIndex - 1,\n        length = array.length;\n\n    while (++index < length) {\n      if (comparator(array[index], value)) {\n        return index;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * The base implementation of `_.isNaN` without support for number objects.\n   *\n   * @private\n   * @param {*} value The value to check.\n   * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n   */\n  function baseIsNaN(value) {\n    return value !== value;\n  }\n\n  /**\n   * The base implementation of `_.mean` and `_.meanBy` without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} array The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {number} Returns the mean.\n   */\n  function baseMean(array, iteratee) {\n    var length = array == null ? 0 : array.length;\n    return length ? (baseSum(array, iteratee) / length) : NAN;\n  }\n\n  /**\n   * The base implementation of `_.property` without support for deep paths.\n   *\n   * @private\n   * @param {string} key The key of the property to get.\n   * @returns {Function} Returns the new accessor function.\n   */\n  function baseProperty(key) {\n    return function(object) {\n      return object == null ? undefined : object[key];\n    };\n  }\n\n  /**\n   * The base implementation of `_.propertyOf` without support for deep paths.\n   *\n   * @private\n   * @param {Object} object The object to query.\n   * @returns {Function} Returns the new accessor function.\n   */\n  function basePropertyOf(object) {\n    return function(key) {\n      return object == null ? undefined : object[key];\n    };\n  }\n\n  /**\n   * The base implementation of `_.reduce` and `_.reduceRight`, without support\n   * for iteratee shorthands, which iterates over `collection` using `eachFunc`.\n   *\n   * @private\n   * @param {Array|Object} collection The collection to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @param {*} accumulator The initial value.\n   * @param {boolean} initAccum Specify using the first or last element of\n   *  `collection` as the initial value.\n   * @param {Function} eachFunc The function to iterate over `collection`.\n   * @returns {*} Returns the accumulated value.\n   */\n  function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {\n    eachFunc(collection, function(value, index, collection) {\n      accumulator = initAccum\n        ? (initAccum = false, value)\n        : iteratee(accumulator, value, index, collection);\n    });\n    return accumulator;\n  }\n\n  /**\n   * The base implementation of `_.sortBy` which uses `comparer` to define the\n   * sort order of `array` and replaces criteria objects with their corresponding\n   * values.\n   *\n   * @private\n   * @param {Array} array The array to sort.\n   * @param {Function} comparer The function to define sort order.\n   * @returns {Array} Returns `array`.\n   */\n  function baseSortBy(array, comparer) {\n    var length = array.length;\n\n    array.sort(comparer);\n    while (length--) {\n      array[length] = array[length].value;\n    }\n    return array;\n  }\n\n  /**\n   * The base implementation of `_.sum` and `_.sumBy` without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} array The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {number} Returns the sum.\n   */\n  function baseSum(array, iteratee) {\n    var result,\n        index = -1,\n        length = array.length;\n\n    while (++index < length) {\n      var current = iteratee(array[index]);\n      if (current !== undefined) {\n        result = result === undefined ? current : (result + current);\n      }\n    }\n    return result;\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   */\n  function 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   * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array\n   * of key-value pairs for `object` corresponding to the property names of `props`.\n   *\n   * @private\n   * @param {Object} object The object to query.\n   * @param {Array} props The property names to get values for.\n   * @returns {Object} Returns the key-value pairs.\n   */\n  function baseToPairs(object, props) {\n    return arrayMap(props, function(key) {\n      return [key, object[key]];\n    });\n  }\n\n  /**\n   * The base implementation of `_.unary` without support for storing metadata.\n   *\n   * @private\n   * @param {Function} func The function to cap arguments for.\n   * @returns {Function} Returns the new capped function.\n   */\n  function baseUnary(func) {\n    return function(value) {\n      return func(value);\n    };\n  }\n\n  /**\n   * The base implementation of `_.values` and `_.valuesIn` which creates an\n   * array of `object` property values corresponding to the property names\n   * of `props`.\n   *\n   * @private\n   * @param {Object} object The object to query.\n   * @param {Array} props The property names to get values for.\n   * @returns {Object} Returns the array of property values.\n   */\n  function baseValues(object, props) {\n    return arrayMap(props, function(key) {\n      return object[key];\n    });\n  }\n\n  /**\n   * Checks if a `cache` value for `key` exists.\n   *\n   * @private\n   * @param {Object} cache The cache to query.\n   * @param {string} key The key of the entry to check.\n   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n   */\n  function cacheHas(cache, key) {\n    return cache.has(key);\n  }\n\n  /**\n   * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol\n   * that is not found in the character symbols.\n   *\n   * @private\n   * @param {Array} strSymbols The string symbols to inspect.\n   * @param {Array} chrSymbols The character symbols to find.\n   * @returns {number} Returns the index of the first unmatched string symbol.\n   */\n  function charsStartIndex(strSymbols, chrSymbols) {\n    var index = -1,\n        length = strSymbols.length;\n\n    while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}\n    return index;\n  }\n\n  /**\n   * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol\n   * that is not found in the character symbols.\n   *\n   * @private\n   * @param {Array} strSymbols The string symbols to inspect.\n   * @param {Array} chrSymbols The character symbols to find.\n   * @returns {number} Returns the index of the last unmatched string symbol.\n   */\n  function charsEndIndex(strSymbols, chrSymbols) {\n    var index = strSymbols.length;\n\n    while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}\n    return index;\n  }\n\n  /**\n   * Gets the number of `placeholder` occurrences in `array`.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} placeholder The placeholder to search for.\n   * @returns {number} Returns the placeholder count.\n   */\n  function countHolders(array, placeholder) {\n    var length = array.length,\n        result = 0;\n\n    while (length--) {\n      if (array[length] === placeholder) {\n        ++result;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A\n   * letters to basic Latin letters.\n   *\n   * @private\n   * @param {string} letter The matched letter to deburr.\n   * @returns {string} Returns the deburred letter.\n   */\n  var deburrLetter = basePropertyOf(deburredLetters);\n\n  /**\n   * Used by `_.escape` to convert characters to HTML entities.\n   *\n   * @private\n   * @param {string} chr The matched character to escape.\n   * @returns {string} Returns the escaped character.\n   */\n  var escapeHtmlChar = basePropertyOf(htmlEscapes);\n\n  /**\n   * Used by `_.template` to escape characters for inclusion in compiled string literals.\n   *\n   * @private\n   * @param {string} chr The matched character to escape.\n   * @returns {string} Returns the escaped character.\n   */\n  function escapeStringChar(chr) {\n    return '\\\\' + stringEscapes[chr];\n  }\n\n  /**\n   * Gets the value at `key` of `object`.\n   *\n   * @private\n   * @param {Object} [object] The object to query.\n   * @param {string} key The key of the property to get.\n   * @returns {*} Returns the property value.\n   */\n  function getValue(object, key) {\n    return object == null ? undefined : object[key];\n  }\n\n  /**\n   * Checks if `string` contains Unicode symbols.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {boolean} Returns `true` if a symbol is found, else `false`.\n   */\n  function hasUnicode(string) {\n    return reHasUnicode.test(string);\n  }\n\n  /**\n   * Checks if `string` contains a word composed of Unicode symbols.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {boolean} Returns `true` if a word is found, else `false`.\n   */\n  function hasUnicodeWord(string) {\n    return reHasUnicodeWord.test(string);\n  }\n\n  /**\n   * Converts `iterator` to an array.\n   *\n   * @private\n   * @param {Object} iterator The iterator to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function iteratorToArray(iterator) {\n    var data,\n        result = [];\n\n    while (!(data = iterator.next()).done) {\n      result.push(data.value);\n    }\n    return result;\n  }\n\n  /**\n   * Converts `map` to its key-value pairs.\n   *\n   * @private\n   * @param {Object} map The map to convert.\n   * @returns {Array} Returns the key-value pairs.\n   */\n  function mapToArray(map) {\n    var index = -1,\n        result = Array(map.size);\n\n    map.forEach(function(value, key) {\n      result[++index] = [key, value];\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   */\n  function overArg(func, transform) {\n    return function(arg) {\n      return func(transform(arg));\n    };\n  }\n\n  /**\n   * Replaces all `placeholder` elements in `array` with an internal placeholder\n   * and returns an array of their indexes.\n   *\n   * @private\n   * @param {Array} array The array to modify.\n   * @param {*} placeholder The placeholder to replace.\n   * @returns {Array} Returns the new array of placeholder indexes.\n   */\n  function replaceHolders(array, placeholder) {\n    var index = -1,\n        length = array.length,\n        resIndex = 0,\n        result = [];\n\n    while (++index < length) {\n      var value = array[index];\n      if (value === placeholder || value === PLACEHOLDER) {\n        array[index] = PLACEHOLDER;\n        result[resIndex++] = index;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Converts `set` to an array of its values.\n   *\n   * @private\n   * @param {Object} set The set to convert.\n   * @returns {Array} Returns the values.\n   */\n  function setToArray(set) {\n    var index = -1,\n        result = Array(set.size);\n\n    set.forEach(function(value) {\n      result[++index] = value;\n    });\n    return result;\n  }\n\n  /**\n   * Converts `set` to its value-value pairs.\n   *\n   * @private\n   * @param {Object} set The set to convert.\n   * @returns {Array} Returns the value-value pairs.\n   */\n  function setToPairs(set) {\n    var index = -1,\n        result = Array(set.size);\n\n    set.forEach(function(value) {\n      result[++index] = [value, value];\n    });\n    return result;\n  }\n\n  /**\n   * A specialized version of `_.indexOf` which performs strict equality\n   * comparisons of values, i.e. `===`.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function strictIndexOf(array, value, fromIndex) {\n    var index = fromIndex - 1,\n        length = array.length;\n\n    while (++index < length) {\n      if (array[index] === value) {\n        return index;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * A specialized version of `_.lastIndexOf` which performs strict equality\n   * comparisons of values, i.e. `===`.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function strictLastIndexOf(array, value, fromIndex) {\n    var index = fromIndex + 1;\n    while (index--) {\n      if (array[index] === value) {\n        return index;\n      }\n    }\n    return index;\n  }\n\n  /**\n   * Gets the number of symbols in `string`.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {number} Returns the string size.\n   */\n  function stringSize(string) {\n    return hasUnicode(string)\n      ? unicodeSize(string)\n      : asciiSize(string);\n  }\n\n  /**\n   * Converts `string` to an array.\n   *\n   * @private\n   * @param {string} string The string to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function stringToArray(string) {\n    return hasUnicode(string)\n      ? unicodeToArray(string)\n      : asciiToArray(string);\n  }\n\n  /**\n   * Used by `_.unescape` to convert HTML entities to characters.\n   *\n   * @private\n   * @param {string} chr The matched character to unescape.\n   * @returns {string} Returns the unescaped character.\n   */\n  var unescapeHtmlChar = basePropertyOf(htmlUnescapes);\n\n  /**\n   * Gets the size of a Unicode `string`.\n   *\n   * @private\n   * @param {string} string The string inspect.\n   * @returns {number} Returns the string size.\n   */\n  function unicodeSize(string) {\n    var result = reUnicode.lastIndex = 0;\n    while (reUnicode.test(string)) {\n      ++result;\n    }\n    return result;\n  }\n\n  /**\n   * Converts a Unicode `string` to an array.\n   *\n   * @private\n   * @param {string} string The string to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function unicodeToArray(string) {\n    return string.match(reUnicode) || [];\n  }\n\n  /**\n   * Splits a Unicode `string` into an array of its words.\n   *\n   * @private\n   * @param {string} The string to inspect.\n   * @returns {Array} Returns the words of `string`.\n   */\n  function unicodeWords(string) {\n    return string.match(reUnicodeWord) || [];\n  }\n\n  /*--------------------------------------------------------------------------*/\n\n  /**\n   * Create a new pristine `lodash` function using the `context` object.\n   *\n   * @static\n   * @memberOf _\n   * @since 1.1.0\n   * @category Util\n   * @param {Object} [context=root] The context object.\n   * @returns {Function} Returns a new `lodash` function.\n   * @example\n   *\n   * _.mixin({ 'foo': _.constant('foo') });\n   *\n   * var lodash = _.runInContext();\n   * lodash.mixin({ 'bar': lodash.constant('bar') });\n   *\n   * _.isFunction(_.foo);\n   * // => true\n   * _.isFunction(_.bar);\n   * // => false\n   *\n   * lodash.isFunction(lodash.foo);\n   * // => false\n   * lodash.isFunction(lodash.bar);\n   * // => true\n   *\n   * // Create a suped-up `defer` in Node.js.\n   * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;\n   */\n  var runInContext = (function runInContext(context) {\n    context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps));\n\n    /** Built-in constructor references. */\n    var Array = context.Array,\n        Date = context.Date,\n        Error = context.Error,\n        Function = context.Function,\n        Math = context.Math,\n        Object = context.Object,\n        RegExp = context.RegExp,\n        String = context.String,\n        TypeError = context.TypeError;\n\n    /** Used for built-in method references. */\n    var arrayProto = Array.prototype,\n        funcProto = Function.prototype,\n        objectProto = Object.prototype;\n\n    /** Used to detect overreaching core-js shims. */\n    var coreJsData = context['__core-js_shared__'];\n\n    /** Used to resolve the decompiled source of functions. */\n    var funcToString = funcProto.toString;\n\n    /** Used to check objects for own properties. */\n    var hasOwnProperty = objectProto.hasOwnProperty;\n\n    /** Used to generate unique IDs. */\n    var idCounter = 0;\n\n    /** Used to detect methods masquerading as native. */\n    var maskSrcKey = (function() {\n      var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n      return uid ? ('Symbol(src)_1.' + uid) : '';\n    }());\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     */\n    var nativeObjectToString = objectProto.toString;\n\n    /** Used to infer the `Object` constructor. */\n    var objectCtorString = funcToString.call(Object);\n\n    /** Used to restore the original `_` reference in `_.noConflict`. */\n    var oldDash = root._;\n\n    /** Used to detect if a method is native. */\n    var reIsNative = RegExp('^' +\n      funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n      .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n    );\n\n    /** Built-in value references. */\n    var Buffer = moduleExports ? context.Buffer : undefined,\n        Symbol = context.Symbol,\n        Uint8Array = context.Uint8Array,\n        allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,\n        getPrototype = overArg(Object.getPrototypeOf, Object),\n        objectCreate = Object.create,\n        propertyIsEnumerable = objectProto.propertyIsEnumerable,\n        splice = arrayProto.splice,\n        spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined,\n        symIterator = Symbol ? Symbol.iterator : undefined,\n        symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n    var defineProperty = (function() {\n      try {\n        var func = getNative(Object, 'defineProperty');\n        func({}, '', {});\n        return func;\n      } catch (e) {}\n    }());\n\n    /** Mocked built-ins. */\n    var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout,\n        ctxNow = Date && Date.now !== root.Date.now && Date.now,\n        ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;\n\n    /* Built-in method references for those with the same name as other `lodash` methods. */\n    var nativeCeil = Math.ceil,\n        nativeFloor = Math.floor,\n        nativeGetSymbols = Object.getOwnPropertySymbols,\n        nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n        nativeIsFinite = context.isFinite,\n        nativeJoin = arrayProto.join,\n        nativeKeys = overArg(Object.keys, Object),\n        nativeMax = Math.max,\n        nativeMin = Math.min,\n        nativeNow = Date.now,\n        nativeParseInt = context.parseInt,\n        nativeRandom = Math.random,\n        nativeReverse = arrayProto.reverse;\n\n    /* Built-in method references that are verified to be native. */\n    var DataView = getNative(context, 'DataView'),\n        Map = getNative(context, 'Map'),\n        Promise = getNative(context, 'Promise'),\n        Set = getNative(context, 'Set'),\n        WeakMap = getNative(context, 'WeakMap'),\n        nativeCreate = getNative(Object, 'create');\n\n    /** Used to store function metadata. */\n    var metaMap = WeakMap && new WeakMap;\n\n    /** Used to lookup unminified function names. */\n    var realNames = {};\n\n    /** Used to detect maps, sets, and weakmaps. */\n    var dataViewCtorString = toSource(DataView),\n        mapCtorString = toSource(Map),\n        promiseCtorString = toSource(Promise),\n        setCtorString = toSource(Set),\n        weakMapCtorString = toSource(WeakMap);\n\n    /** Used to convert symbols to primitives and strings. */\n    var symbolProto = Symbol ? Symbol.prototype : undefined,\n        symbolValueOf = symbolProto ? symbolProto.valueOf : undefined,\n        symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a `lodash` object which wraps `value` to enable implicit method\n     * chain sequences. Methods that operate on and return arrays, collections,\n     * and functions can be chained together. Methods that retrieve a single value\n     * or may return a primitive value will automatically end the chain sequence\n     * and return the unwrapped value. Otherwise, the value must be unwrapped\n     * with `_#value`.\n     *\n     * Explicit chain sequences, which must be unwrapped with `_#value`, may be\n     * enabled using `_.chain`.\n     *\n     * The execution of chained methods is lazy, that is, it's deferred until\n     * `_#value` is implicitly or explicitly called.\n     *\n     * Lazy evaluation allows several methods to support shortcut fusion.\n     * Shortcut fusion is an optimization to merge iteratee calls; this avoids\n     * the creation of intermediate arrays and can greatly reduce the number of\n     * iteratee executions. Sections of a chain sequence qualify for shortcut\n     * fusion if the section is applied to an array and iteratees accept only\n     * one argument. The heuristic for whether a section qualifies for shortcut\n     * fusion is subject to change.\n     *\n     * Chaining is supported in custom builds as long as the `_#value` method is\n     * directly or indirectly included in the build.\n     *\n     * In addition to lodash methods, wrappers have `Array` and `String` methods.\n     *\n     * The wrapper `Array` methods are:\n     * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`\n     *\n     * The wrapper `String` methods are:\n     * `replace` and `split`\n     *\n     * The wrapper methods that support shortcut fusion are:\n     * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,\n     * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,\n     * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`\n     *\n     * The chainable wrapper methods are:\n     * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,\n     * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,\n     * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,\n     * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,\n     * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,\n     * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,\n     * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,\n     * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,\n     * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,\n     * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,\n     * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,\n     * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,\n     * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,\n     * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,\n     * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,\n     * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,\n     * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,\n     * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,\n     * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,\n     * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,\n     * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,\n     * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,\n     * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,\n     * `zipObject`, `zipObjectDeep`, and `zipWith`\n     *\n     * The wrapper methods that are **not** chainable by default are:\n     * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,\n     * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,\n     * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,\n     * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,\n     * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,\n     * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,\n     * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,\n     * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,\n     * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,\n     * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,\n     * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,\n     * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,\n     * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,\n     * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,\n     * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,\n     * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,\n     * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,\n     * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,\n     * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,\n     * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,\n     * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,\n     * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,\n     * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,\n     * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,\n     * `upperFirst`, `value`, and `words`\n     *\n     * @name _\n     * @constructor\n     * @category Seq\n     * @param {*} value The value to wrap in a `lodash` instance.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var wrapped = _([1, 2, 3]);\n     *\n     * // Returns an unwrapped value.\n     * wrapped.reduce(_.add);\n     * // => 6\n     *\n     * // Returns a wrapped value.\n     * var squares = wrapped.map(square);\n     *\n     * _.isArray(squares);\n     * // => false\n     *\n     * _.isArray(squares.value());\n     * // => true\n     */\n    function lodash(value) {\n      if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {\n        if (value instanceof LodashWrapper) {\n          return value;\n        }\n        if (hasOwnProperty.call(value, '__wrapped__')) {\n          return wrapperClone(value);\n        }\n      }\n      return new LodashWrapper(value);\n    }\n\n    /**\n     * The base implementation of `_.create` without support for assigning\n     * properties to the created object.\n     *\n     * @private\n     * @param {Object} proto The object to inherit from.\n     * @returns {Object} Returns the new object.\n     */\n    var baseCreate = (function() {\n      function object() {}\n      return function(proto) {\n        if (!isObject(proto)) {\n          return {};\n        }\n        if (objectCreate) {\n          return objectCreate(proto);\n        }\n        object.prototype = proto;\n        var result = new object;\n        object.prototype = undefined;\n        return result;\n      };\n    }());\n\n    /**\n     * The function whose prototype chain sequence wrappers inherit from.\n     *\n     * @private\n     */\n    function baseLodash() {\n      // No operation performed.\n    }\n\n    /**\n     * The base constructor for creating `lodash` wrapper objects.\n     *\n     * @private\n     * @param {*} value The value to wrap.\n     * @param {boolean} [chainAll] Enable explicit method chain sequences.\n     */\n    function LodashWrapper(value, chainAll) {\n      this.__wrapped__ = value;\n      this.__actions__ = [];\n      this.__chain__ = !!chainAll;\n      this.__index__ = 0;\n      this.__values__ = undefined;\n    }\n\n    /**\n     * By default, the template delimiters used by lodash are like those in\n     * embedded Ruby (ERB) as well as ES2015 template strings. Change the\n     * following template settings to use alternative delimiters.\n     *\n     * @static\n     * @memberOf _\n     * @type {Object}\n     */\n    lodash.templateSettings = {\n\n      /**\n       * Used to detect `data` property values to be HTML-escaped.\n       *\n       * @memberOf _.templateSettings\n       * @type {RegExp}\n       */\n      'escape': reEscape,\n\n      /**\n       * Used to detect code to be evaluated.\n       *\n       * @memberOf _.templateSettings\n       * @type {RegExp}\n       */\n      'evaluate': reEvaluate,\n\n      /**\n       * Used to detect `data` property values to inject.\n       *\n       * @memberOf _.templateSettings\n       * @type {RegExp}\n       */\n      'interpolate': reInterpolate,\n\n      /**\n       * Used to reference the data object in the template text.\n       *\n       * @memberOf _.templateSettings\n       * @type {string}\n       */\n      'variable': '',\n\n      /**\n       * Used to import variables into the compiled template.\n       *\n       * @memberOf _.templateSettings\n       * @type {Object}\n       */\n      'imports': {\n\n        /**\n         * A reference to the `lodash` function.\n         *\n         * @memberOf _.templateSettings.imports\n         * @type {Function}\n         */\n        '_': lodash\n      }\n    };\n\n    // Ensure wrappers are instances of `baseLodash`.\n    lodash.prototype = baseLodash.prototype;\n    lodash.prototype.constructor = lodash;\n\n    LodashWrapper.prototype = baseCreate(baseLodash.prototype);\n    LodashWrapper.prototype.constructor = LodashWrapper;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.\n     *\n     * @private\n     * @constructor\n     * @param {*} value The value to wrap.\n     */\n    function LazyWrapper(value) {\n      this.__wrapped__ = value;\n      this.__actions__ = [];\n      this.__dir__ = 1;\n      this.__filtered__ = false;\n      this.__iteratees__ = [];\n      this.__takeCount__ = MAX_ARRAY_LENGTH;\n      this.__views__ = [];\n    }\n\n    /**\n     * Creates a clone of the lazy wrapper object.\n     *\n     * @private\n     * @name clone\n     * @memberOf LazyWrapper\n     * @returns {Object} Returns the cloned `LazyWrapper` object.\n     */\n    function lazyClone() {\n      var result = new LazyWrapper(this.__wrapped__);\n      result.__actions__ = copyArray(this.__actions__);\n      result.__dir__ = this.__dir__;\n      result.__filtered__ = this.__filtered__;\n      result.__iteratees__ = copyArray(this.__iteratees__);\n      result.__takeCount__ = this.__takeCount__;\n      result.__views__ = copyArray(this.__views__);\n      return result;\n    }\n\n    /**\n     * Reverses the direction of lazy iteration.\n     *\n     * @private\n     * @name reverse\n     * @memberOf LazyWrapper\n     * @returns {Object} Returns the new reversed `LazyWrapper` object.\n     */\n    function lazyReverse() {\n      if (this.__filtered__) {\n        var result = new LazyWrapper(this);\n        result.__dir__ = -1;\n        result.__filtered__ = true;\n      } else {\n        result = this.clone();\n        result.__dir__ *= -1;\n      }\n      return result;\n    }\n\n    /**\n     * Extracts the unwrapped value from its lazy wrapper.\n     *\n     * @private\n     * @name value\n     * @memberOf LazyWrapper\n     * @returns {*} Returns the unwrapped value.\n     */\n    function lazyValue() {\n      var array = this.__wrapped__.value(),\n          dir = this.__dir__,\n          isArr = isArray(array),\n          isRight = dir < 0,\n          arrLength = isArr ? array.length : 0,\n          view = getView(0, arrLength, this.__views__),\n          start = view.start,\n          end = view.end,\n          length = end - start,\n          index = isRight ? end : (start - 1),\n          iteratees = this.__iteratees__,\n          iterLength = iteratees.length,\n          resIndex = 0,\n          takeCount = nativeMin(length, this.__takeCount__);\n\n      if (!isArr || (!isRight && arrLength == length && takeCount == length)) {\n        return baseWrapperValue(array, this.__actions__);\n      }\n      var result = [];\n\n      outer:\n      while (length-- && resIndex < takeCount) {\n        index += dir;\n\n        var iterIndex = -1,\n            value = array[index];\n\n        while (++iterIndex < iterLength) {\n          var data = iteratees[iterIndex],\n              iteratee = data.iteratee,\n              type = data.type,\n              computed = iteratee(value);\n\n          if (type == LAZY_MAP_FLAG) {\n            value = computed;\n          } else if (!computed) {\n            if (type == LAZY_FILTER_FLAG) {\n              continue outer;\n            } else {\n              break outer;\n            }\n          }\n        }\n        result[resIndex++] = value;\n      }\n      return result;\n    }\n\n    // Ensure `LazyWrapper` is an instance of `baseLodash`.\n    LazyWrapper.prototype = baseCreate(baseLodash.prototype);\n    LazyWrapper.prototype.constructor = LazyWrapper;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a hash object.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function Hash(entries) {\n      var index = -1,\n          length = entries == null ? 0 : entries.length;\n\n      this.clear();\n      while (++index < length) {\n        var entry = entries[index];\n        this.set(entry[0], entry[1]);\n      }\n    }\n\n    /**\n     * Removes all key-value entries from the hash.\n     *\n     * @private\n     * @name clear\n     * @memberOf Hash\n     */\n    function hashClear() {\n      this.__data__ = nativeCreate ? nativeCreate(null) : {};\n      this.size = 0;\n    }\n\n    /**\n     * Removes `key` and its value from the hash.\n     *\n     * @private\n     * @name delete\n     * @memberOf Hash\n     * @param {Object} hash The hash to modify.\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function hashDelete(key) {\n      var result = this.has(key) && delete this.__data__[key];\n      this.size -= result ? 1 : 0;\n      return result;\n    }\n\n    /**\n     * Gets the hash value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf Hash\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function hashGet(key) {\n      var data = this.__data__;\n      if (nativeCreate) {\n        var result = data[key];\n        return result === HASH_UNDEFINED ? undefined : result;\n      }\n      return hasOwnProperty.call(data, key) ? data[key] : undefined;\n    }\n\n    /**\n     * Checks if a hash value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf Hash\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function hashHas(key) {\n      var data = this.__data__;\n      return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n    }\n\n    /**\n     * Sets the hash `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf Hash\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the hash instance.\n     */\n    function hashSet(key, value) {\n      var data = this.__data__;\n      this.size += this.has(key) ? 0 : 1;\n      data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n      return this;\n    }\n\n    // Add methods to `Hash`.\n    Hash.prototype.clear = hashClear;\n    Hash.prototype['delete'] = hashDelete;\n    Hash.prototype.get = hashGet;\n    Hash.prototype.has = hashHas;\n    Hash.prototype.set = hashSet;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an list cache object.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function ListCache(entries) {\n      var index = -1,\n          length = entries == null ? 0 : entries.length;\n\n      this.clear();\n      while (++index < length) {\n        var entry = entries[index];\n        this.set(entry[0], entry[1]);\n      }\n    }\n\n    /**\n     * Removes all key-value entries from the list cache.\n     *\n     * @private\n     * @name clear\n     * @memberOf ListCache\n     */\n    function listCacheClear() {\n      this.__data__ = [];\n      this.size = 0;\n    }\n\n    /**\n     * Removes `key` and its value from the list cache.\n     *\n     * @private\n     * @name delete\n     * @memberOf ListCache\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function listCacheDelete(key) {\n      var data = this.__data__,\n          index = assocIndexOf(data, key);\n\n      if (index < 0) {\n        return false;\n      }\n      var lastIndex = data.length - 1;\n      if (index == lastIndex) {\n        data.pop();\n      } else {\n        splice.call(data, index, 1);\n      }\n      --this.size;\n      return true;\n    }\n\n    /**\n     * Gets the list cache value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf ListCache\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function listCacheGet(key) {\n      var data = this.__data__,\n          index = assocIndexOf(data, key);\n\n      return index < 0 ? undefined : data[index][1];\n    }\n\n    /**\n     * Checks if a list cache value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf ListCache\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function listCacheHas(key) {\n      return assocIndexOf(this.__data__, key) > -1;\n    }\n\n    /**\n     * Sets the list cache `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf ListCache\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the list cache instance.\n     */\n    function listCacheSet(key, value) {\n      var data = this.__data__,\n          index = assocIndexOf(data, key);\n\n      if (index < 0) {\n        ++this.size;\n        data.push([key, value]);\n      } else {\n        data[index][1] = value;\n      }\n      return this;\n    }\n\n    // Add methods to `ListCache`.\n    ListCache.prototype.clear = listCacheClear;\n    ListCache.prototype['delete'] = listCacheDelete;\n    ListCache.prototype.get = listCacheGet;\n    ListCache.prototype.has = listCacheHas;\n    ListCache.prototype.set = listCacheSet;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a map cache object to store key-value pairs.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function MapCache(entries) {\n      var index = -1,\n          length = entries == null ? 0 : entries.length;\n\n      this.clear();\n      while (++index < length) {\n        var entry = entries[index];\n        this.set(entry[0], entry[1]);\n      }\n    }\n\n    /**\n     * Removes all key-value entries from the map.\n     *\n     * @private\n     * @name clear\n     * @memberOf MapCache\n     */\n    function mapCacheClear() {\n      this.size = 0;\n      this.__data__ = {\n        'hash': new Hash,\n        'map': new (Map || ListCache),\n        'string': new Hash\n      };\n    }\n\n    /**\n     * Removes `key` and its value from the map.\n     *\n     * @private\n     * @name delete\n     * @memberOf MapCache\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function mapCacheDelete(key) {\n      var result = getMapData(this, key)['delete'](key);\n      this.size -= result ? 1 : 0;\n      return result;\n    }\n\n    /**\n     * Gets the map value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf MapCache\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function mapCacheGet(key) {\n      return getMapData(this, key).get(key);\n    }\n\n    /**\n     * Checks if a map value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf MapCache\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function mapCacheHas(key) {\n      return getMapData(this, key).has(key);\n    }\n\n    /**\n     * Sets the map `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf MapCache\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the map cache instance.\n     */\n    function mapCacheSet(key, value) {\n      var data = getMapData(this, key),\n          size = data.size;\n\n      data.set(key, value);\n      this.size += data.size == size ? 0 : 1;\n      return this;\n    }\n\n    // Add methods to `MapCache`.\n    MapCache.prototype.clear = mapCacheClear;\n    MapCache.prototype['delete'] = mapCacheDelete;\n    MapCache.prototype.get = mapCacheGet;\n    MapCache.prototype.has = mapCacheHas;\n    MapCache.prototype.set = mapCacheSet;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     *\n     * Creates an array cache object to store unique values.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [values] The values to cache.\n     */\n    function SetCache(values) {\n      var index = -1,\n          length = values == null ? 0 : values.length;\n\n      this.__data__ = new MapCache;\n      while (++index < length) {\n        this.add(values[index]);\n      }\n    }\n\n    /**\n     * Adds `value` to the array cache.\n     *\n     * @private\n     * @name add\n     * @memberOf SetCache\n     * @alias push\n     * @param {*} value The value to cache.\n     * @returns {Object} Returns the cache instance.\n     */\n    function setCacheAdd(value) {\n      this.__data__.set(value, HASH_UNDEFINED);\n      return this;\n    }\n\n    /**\n     * Checks if `value` is in the array cache.\n     *\n     * @private\n     * @name has\n     * @memberOf SetCache\n     * @param {*} value The value to search for.\n     * @returns {number} Returns `true` if `value` is found, else `false`.\n     */\n    function setCacheHas(value) {\n      return this.__data__.has(value);\n    }\n\n    // Add methods to `SetCache`.\n    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\n    SetCache.prototype.has = setCacheHas;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a stack cache object to store key-value pairs.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function Stack(entries) {\n      var data = this.__data__ = new ListCache(entries);\n      this.size = data.size;\n    }\n\n    /**\n     * Removes all key-value entries from the stack.\n     *\n     * @private\n     * @name clear\n     * @memberOf Stack\n     */\n    function stackClear() {\n      this.__data__ = new ListCache;\n      this.size = 0;\n    }\n\n    /**\n     * Removes `key` and its value from the stack.\n     *\n     * @private\n     * @name delete\n     * @memberOf Stack\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function stackDelete(key) {\n      var data = this.__data__,\n          result = data['delete'](key);\n\n      this.size = data.size;\n      return result;\n    }\n\n    /**\n     * Gets the stack value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf Stack\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function stackGet(key) {\n      return this.__data__.get(key);\n    }\n\n    /**\n     * Checks if a stack value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf Stack\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function stackHas(key) {\n      return this.__data__.has(key);\n    }\n\n    /**\n     * Sets the stack `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf Stack\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the stack cache instance.\n     */\n    function stackSet(key, value) {\n      var data = this.__data__;\n      if (data instanceof ListCache) {\n        var pairs = data.__data__;\n        if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n          pairs.push([key, value]);\n          this.size = ++data.size;\n          return this;\n        }\n        data = this.__data__ = new MapCache(pairs);\n      }\n      data.set(key, value);\n      this.size = data.size;\n      return this;\n    }\n\n    // Add methods to `Stack`.\n    Stack.prototype.clear = stackClear;\n    Stack.prototype['delete'] = stackDelete;\n    Stack.prototype.get = stackGet;\n    Stack.prototype.has = stackHas;\n    Stack.prototype.set = stackSet;\n\n    /*------------------------------------------------------------------------*/\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     */\n    function arrayLikeKeys(value, inherited) {\n      var isArr = isArray(value),\n          isArg = !isArr && isArguments(value),\n          isBuff = !isArr && !isArg && isBuffer(value),\n          isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n          skipIndexes = isArr || isArg || isBuff || isType,\n          result = skipIndexes ? baseTimes(value.length, String) : [],\n          length = result.length;\n\n      for (var key in value) {\n        if ((inherited || hasOwnProperty.call(value, key)) &&\n            !(skipIndexes && (\n               // Safari 9 has enumerable `arguments.length` in strict mode.\n               key == 'length' ||\n               // Node.js 0.10 has enumerable non-index properties on buffers.\n               (isBuff && (key == 'offset' || key == 'parent')) ||\n               // PhantomJS 2 has enumerable non-index properties on typed arrays.\n               (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n               // Skip index properties.\n               isIndex(key, length)\n            ))) {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * A specialized version of `_.sample` for arrays.\n     *\n     * @private\n     * @param {Array} array The array to sample.\n     * @returns {*} Returns the random element.\n     */\n    function arraySample(array) {\n      var length = array.length;\n      return length ? array[baseRandom(0, length - 1)] : undefined;\n    }\n\n    /**\n     * A specialized version of `_.sampleSize` for arrays.\n     *\n     * @private\n     * @param {Array} array The array to sample.\n     * @param {number} n The number of elements to sample.\n     * @returns {Array} Returns the random elements.\n     */\n    function arraySampleSize(array, n) {\n      return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));\n    }\n\n    /**\n     * A specialized version of `_.shuffle` for arrays.\n     *\n     * @private\n     * @param {Array} array The array to shuffle.\n     * @returns {Array} Returns the new shuffled array.\n     */\n    function arrayShuffle(array) {\n      return shuffleSelf(copyArray(array));\n    }\n\n    /**\n     * This function is like `assignValue` except that it doesn't assign\n     * `undefined` values.\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     */\n    function assignMergeValue(object, key, value) {\n      if ((value !== undefined && !eq(object[key], value)) ||\n          (value === undefined && !(key in object))) {\n        baseAssignValue(object, key, value);\n      }\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     */\n    function 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        baseAssignValue(object, key, value);\n      }\n    }\n\n    /**\n     * Gets the index at which the `key` is found in `array` of key-value pairs.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {*} key The key to search for.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     */\n    function assocIndexOf(array, key) {\n      var length = array.length;\n      while (length--) {\n        if (eq(array[length][0], key)) {\n          return length;\n        }\n      }\n      return -1;\n    }\n\n    /**\n     * Aggregates elements of `collection` on `accumulator` with keys transformed\n     * by `iteratee` and values set by `setter`.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} setter The function to set `accumulator` values.\n     * @param {Function} iteratee The iteratee to transform keys.\n     * @param {Object} accumulator The initial aggregated object.\n     * @returns {Function} Returns `accumulator`.\n     */\n    function baseAggregator(collection, setter, iteratee, accumulator) {\n      baseEach(collection, function(value, key, collection) {\n        setter(accumulator, value, iteratee(value), collection);\n      });\n      return accumulator;\n    }\n\n    /**\n     * The base implementation of `_.assign` without support for multiple sources\n     * or `customizer` functions.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @returns {Object} Returns `object`.\n     */\n    function baseAssign(object, source) {\n      return object && copyObject(source, keys(source), object);\n    }\n\n    /**\n     * The base implementation of `_.assignIn` without support for multiple sources\n     * or `customizer` functions.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @returns {Object} Returns `object`.\n     */\n    function baseAssignIn(object, source) {\n      return object && copyObject(source, keysIn(source), object);\n    }\n\n    /**\n     * The base implementation of `assignValue` and `assignMergeValue` without\n     * value checks.\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     */\n    function baseAssignValue(object, key, value) {\n      if (key == '__proto__' && defineProperty) {\n        defineProperty(object, key, {\n          'configurable': true,\n          'enumerable': true,\n          'value': value,\n          'writable': true\n        });\n      } else {\n        object[key] = value;\n      }\n    }\n\n    /**\n     * The base implementation of `_.at` without support for individual paths.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {string[]} paths The property paths to pick.\n     * @returns {Array} Returns the picked elements.\n     */\n    function baseAt(object, paths) {\n      var index = -1,\n          length = paths.length,\n          result = Array(length),\n          skip = object == null;\n\n      while (++index < length) {\n        result[index] = skip ? undefined : get(object, paths[index]);\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.clamp` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {number} number The number to clamp.\n     * @param {number} [lower] The lower bound.\n     * @param {number} upper The upper bound.\n     * @returns {number} Returns the clamped number.\n     */\n    function baseClamp(number, lower, upper) {\n      if (number === number) {\n        if (upper !== undefined) {\n          number = number <= upper ? number : upper;\n        }\n        if (lower !== undefined) {\n          number = number >= lower ? number : lower;\n        }\n      }\n      return number;\n    }\n\n    /**\n     * The base implementation of `_.clone` and `_.cloneDeep` which tracks\n     * traversed objects.\n     *\n     * @private\n     * @param {*} value The value to clone.\n     * @param {boolean} bitmask The bitmask flags.\n     *  1 - Deep clone\n     *  2 - Flatten inherited properties\n     *  4 - Clone symbols\n     * @param {Function} [customizer] The function to customize cloning.\n     * @param {string} [key] The key of `value`.\n     * @param {Object} [object] The parent object of `value`.\n     * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n     * @returns {*} Returns the cloned value.\n     */\n    function baseClone(value, bitmask, customizer, key, object, stack) {\n      var result,\n          isDeep = bitmask & CLONE_DEEP_FLAG,\n          isFlat = bitmask & CLONE_FLAT_FLAG,\n          isFull = bitmask & CLONE_SYMBOLS_FLAG;\n\n      if (customizer) {\n        result = object ? customizer(value, key, object, stack) : customizer(value);\n      }\n      if (result !== undefined) {\n        return result;\n      }\n      if (!isObject(value)) {\n        return value;\n      }\n      var isArr = isArray(value);\n      if (isArr) {\n        result = initCloneArray(value);\n        if (!isDeep) {\n          return copyArray(value, result);\n        }\n      } else {\n        var tag = getTag(value),\n            isFunc = tag == funcTag || tag == genTag;\n\n        if (isBuffer(value)) {\n          return cloneBuffer(value, isDeep);\n        }\n        if (tag == objectTag || tag == argsTag || (isFunc && !object)) {\n          result = (isFlat || isFunc) ? {} : initCloneObject(value);\n          if (!isDeep) {\n            return isFlat\n              ? copySymbolsIn(value, baseAssignIn(result, value))\n              : copySymbols(value, baseAssign(result, value));\n          }\n        } else {\n          if (!cloneableTags[tag]) {\n            return object ? value : {};\n          }\n          result = initCloneByTag(value, tag, baseClone, isDeep);\n        }\n      }\n      // Check for circular references and return its corresponding clone.\n      stack || (stack = new Stack);\n      var stacked = stack.get(value);\n      if (stacked) {\n        return stacked;\n      }\n      stack.set(value, result);\n\n      var keysFunc = isFull\n        ? (isFlat ? getAllKeysIn : getAllKeys)\n        : (isFlat ? keysIn : keys);\n\n      var props = isArr ? undefined : keysFunc(value);\n      arrayEach(props || value, function(subValue, key) {\n        if (props) {\n          key = subValue;\n          subValue = value[key];\n        }\n        // Recursively populate clone (susceptible to call stack limits).\n        assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.conforms` which doesn't clone `source`.\n     *\n     * @private\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {Function} Returns the new spec function.\n     */\n    function baseConforms(source) {\n      var props = keys(source);\n      return function(object) {\n        return baseConformsTo(object, source, props);\n      };\n    }\n\n    /**\n     * The base implementation of `_.conformsTo` which accepts `props` to check.\n     *\n     * @private\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {boolean} Returns `true` if `object` conforms, else `false`.\n     */\n    function baseConformsTo(object, source, props) {\n      var length = props.length;\n      if (object == null) {\n        return !length;\n      }\n      object = Object(object);\n      while (length--) {\n        var key = props[length],\n            predicate = source[key],\n            value = object[key];\n\n        if ((value === undefined && !(key in object)) || !predicate(value)) {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    /**\n     * The base implementation of `_.delay` and `_.defer` which accepts `args`\n     * to provide to `func`.\n     *\n     * @private\n     * @param {Function} func The function to delay.\n     * @param {number} wait The number of milliseconds to delay invocation.\n     * @param {Array} args The arguments to provide to `func`.\n     * @returns {number|Object} Returns the timer id or timeout object.\n     */\n    function baseDelay(func, wait, args) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      return setTimeout(function() { func.apply(undefined, args); }, wait);\n    }\n\n    /**\n     * The base implementation of methods like `_.difference` without support\n     * for excluding multiple arrays or iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {Array} values The values to exclude.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     */\n    function baseDifference(array, values, iteratee, comparator) {\n      var index = -1,\n          includes = arrayIncludes,\n          isCommon = true,\n          length = array.length,\n          result = [],\n          valuesLength = values.length;\n\n      if (!length) {\n        return result;\n      }\n      if (iteratee) {\n        values = arrayMap(values, baseUnary(iteratee));\n      }\n      if (comparator) {\n        includes = arrayIncludesWith;\n        isCommon = false;\n      }\n      else if (values.length >= LARGE_ARRAY_SIZE) {\n        includes = cacheHas;\n        isCommon = false;\n        values = new SetCache(values);\n      }\n      outer:\n      while (++index < length) {\n        var value = array[index],\n            computed = iteratee == null ? value : iteratee(value);\n\n        value = (comparator || value !== 0) ? value : 0;\n        if (isCommon && computed === computed) {\n          var valuesIndex = valuesLength;\n          while (valuesIndex--) {\n            if (values[valuesIndex] === computed) {\n              continue outer;\n            }\n          }\n          result.push(value);\n        }\n        else if (!includes(values, computed, comparator)) {\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.forEach` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     */\n    var baseEach = createBaseEach(baseForOwn);\n\n    /**\n     * The base implementation of `_.forEachRight` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     */\n    var baseEachRight = createBaseEach(baseForOwnRight, true);\n\n    /**\n     * The base implementation of `_.every` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {boolean} Returns `true` if all elements pass the predicate check,\n     *  else `false`\n     */\n    function baseEvery(collection, predicate) {\n      var result = true;\n      baseEach(collection, function(value, index, collection) {\n        result = !!predicate(value, index, collection);\n        return result;\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of methods like `_.max` and `_.min` which accepts a\n     * `comparator` to determine the extremum value.\n     *\n     * @private\n     * @param {Array} array The array to iterate over.\n     * @param {Function} iteratee The iteratee invoked per iteration.\n     * @param {Function} comparator The comparator used to compare values.\n     * @returns {*} Returns the extremum value.\n     */\n    function baseExtremum(array, iteratee, comparator) {\n      var index = -1,\n          length = array.length;\n\n      while (++index < length) {\n        var value = array[index],\n            current = iteratee(value);\n\n        if (current != null && (computed === undefined\n              ? (current === current && !isSymbol(current))\n              : comparator(current, computed)\n            )) {\n          var computed = current,\n              result = value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.fill` without an iteratee call guard.\n     *\n     * @private\n     * @param {Array} array The array to fill.\n     * @param {*} value The value to fill `array` with.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns `array`.\n     */\n    function baseFill(array, value, start, end) {\n      var length = array.length;\n\n      start = toInteger(start);\n      if (start < 0) {\n        start = -start > length ? 0 : (length + start);\n      }\n      end = (end === undefined || end > length) ? length : toInteger(end);\n      if (end < 0) {\n        end += length;\n      }\n      end = start > end ? 0 : toLength(end);\n      while (start < end) {\n        array[start++] = value;\n      }\n      return array;\n    }\n\n    /**\n     * The base implementation of `_.filter` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {Array} Returns the new filtered array.\n     */\n    function baseFilter(collection, predicate) {\n      var result = [];\n      baseEach(collection, function(value, index, collection) {\n        if (predicate(value, index, collection)) {\n          result.push(value);\n        }\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.flatten` with support for restricting flattening.\n     *\n     * @private\n     * @param {Array} array The array to flatten.\n     * @param {number} depth The maximum recursion depth.\n     * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.\n     * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.\n     * @param {Array} [result=[]] The initial result value.\n     * @returns {Array} Returns the new flattened array.\n     */\n    function baseFlatten(array, depth, predicate, isStrict, result) {\n      var index = -1,\n          length = array.length;\n\n      predicate || (predicate = isFlattenable);\n      result || (result = []);\n\n      while (++index < length) {\n        var value = array[index];\n        if (depth > 0 && predicate(value)) {\n          if (depth > 1) {\n            // Recursively flatten arrays (susceptible to call stack limits).\n            baseFlatten(value, depth - 1, predicate, isStrict, result);\n          } else {\n            arrayPush(result, value);\n          }\n        } else if (!isStrict) {\n          result[result.length] = value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `baseForOwn` which iterates over `object`\n     * properties returned by `keysFunc` and invokes `iteratee` for each property.\n     * Iteratee functions may exit iteration early by explicitly returning `false`.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @param {Function} keysFunc The function to get the keys of `object`.\n     * @returns {Object} Returns `object`.\n     */\n    var baseFor = createBaseFor();\n\n    /**\n     * This function is like `baseFor` except that it iterates over properties\n     * in the opposite order.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @param {Function} keysFunc The function to get the keys of `object`.\n     * @returns {Object} Returns `object`.\n     */\n    var baseForRight = createBaseFor(true);\n\n    /**\n     * The base implementation of `_.forOwn` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     */\n    function baseForOwn(object, iteratee) {\n      return object && baseFor(object, iteratee, keys);\n    }\n\n    /**\n     * The base implementation of `_.forOwnRight` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     */\n    function baseForOwnRight(object, iteratee) {\n      return object && baseForRight(object, iteratee, keys);\n    }\n\n    /**\n     * The base implementation of `_.functions` which creates an array of\n     * `object` function property names filtered from `props`.\n     *\n     * @private\n     * @param {Object} object The object to inspect.\n     * @param {Array} props The property names to filter.\n     * @returns {Array} Returns the function names.\n     */\n    function baseFunctions(object, props) {\n      return arrayFilter(props, function(key) {\n        return isFunction(object[key]);\n      });\n    }\n\n    /**\n     * The base implementation of `_.get` without support for default values.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the property to get.\n     * @returns {*} Returns the resolved value.\n     */\n    function baseGet(object, path) {\n      path = castPath(path, object);\n\n      var index = 0,\n          length = path.length;\n\n      while (object != null && index < length) {\n        object = object[toKey(path[index++])];\n      }\n      return (index && index == length) ? object : undefined;\n    }\n\n    /**\n     * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n     * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n     * symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Function} keysFunc The function to get the keys of `object`.\n     * @param {Function} symbolsFunc The function to get the symbols of `object`.\n     * @returns {Array} Returns the array of property names and symbols.\n     */\n    function baseGetAllKeys(object, keysFunc, symbolsFunc) {\n      var result = keysFunc(object);\n      return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n    }\n\n    /**\n     * The base implementation of `getTag` without fallbacks for buggy environments.\n     *\n     * @private\n     * @param {*} value The value to query.\n     * @returns {string} Returns the `toStringTag`.\n     */\n    function baseGetTag(value) {\n      if (value == null) {\n        return value === undefined ? undefinedTag : nullTag;\n      }\n      return (symToStringTag && symToStringTag in Object(value))\n        ? getRawTag(value)\n        : objectToString(value);\n    }\n\n    /**\n     * The base implementation of `_.gt` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is greater than `other`,\n     *  else `false`.\n     */\n    function baseGt(value, other) {\n      return value > other;\n    }\n\n    /**\n     * The base implementation of `_.has` without support for deep paths.\n     *\n     * @private\n     * @param {Object} [object] The object to query.\n     * @param {Array|string} key The key to check.\n     * @returns {boolean} Returns `true` if `key` exists, else `false`.\n     */\n    function baseHas(object, key) {\n      return object != null && hasOwnProperty.call(object, key);\n    }\n\n    /**\n     * The base implementation of `_.hasIn` without support for deep paths.\n     *\n     * @private\n     * @param {Object} [object] The object to query.\n     * @param {Array|string} key The key to check.\n     * @returns {boolean} Returns `true` if `key` exists, else `false`.\n     */\n    function baseHasIn(object, key) {\n      return object != null && key in Object(object);\n    }\n\n    /**\n     * The base implementation of `_.inRange` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {number} number The number to check.\n     * @param {number} start The start of the range.\n     * @param {number} end The end of the range.\n     * @returns {boolean} Returns `true` if `number` is in the range, else `false`.\n     */\n    function baseInRange(number, start, end) {\n      return number >= nativeMin(start, end) && number < nativeMax(start, end);\n    }\n\n    /**\n     * The base implementation of methods like `_.intersection`, without support\n     * for iteratee shorthands, that accepts an array of arrays to inspect.\n     *\n     * @private\n     * @param {Array} arrays The arrays to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of shared values.\n     */\n    function baseIntersection(arrays, iteratee, comparator) {\n      var includes = comparator ? arrayIncludesWith : arrayIncludes,\n          length = arrays[0].length,\n          othLength = arrays.length,\n          othIndex = othLength,\n          caches = Array(othLength),\n          maxLength = Infinity,\n          result = [];\n\n      while (othIndex--) {\n        var array = arrays[othIndex];\n        if (othIndex && iteratee) {\n          array = arrayMap(array, baseUnary(iteratee));\n        }\n        maxLength = nativeMin(array.length, maxLength);\n        caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))\n          ? new SetCache(othIndex && array)\n          : undefined;\n      }\n      array = arrays[0];\n\n      var index = -1,\n          seen = caches[0];\n\n      outer:\n      while (++index < length && result.length < maxLength) {\n        var value = array[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        value = (comparator || value !== 0) ? value : 0;\n        if (!(seen\n              ? cacheHas(seen, computed)\n              : includes(result, computed, comparator)\n            )) {\n          othIndex = othLength;\n          while (--othIndex) {\n            var cache = caches[othIndex];\n            if (!(cache\n                  ? cacheHas(cache, computed)\n                  : includes(arrays[othIndex], computed, comparator))\n                ) {\n              continue outer;\n            }\n          }\n          if (seen) {\n            seen.push(computed);\n          }\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.invert` and `_.invertBy` which inverts\n     * `object` with values transformed by `iteratee` and set by `setter`.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} setter The function to set `accumulator` values.\n     * @param {Function} iteratee The iteratee to transform values.\n     * @param {Object} accumulator The initial inverted object.\n     * @returns {Function} Returns `accumulator`.\n     */\n    function baseInverter(object, setter, iteratee, accumulator) {\n      baseForOwn(object, function(value, key, object) {\n        setter(accumulator, iteratee(value), key, object);\n      });\n      return accumulator;\n    }\n\n    /**\n     * The base implementation of `_.invoke` without support for individual\n     * method arguments.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the method to invoke.\n     * @param {Array} args The arguments to invoke the method with.\n     * @returns {*} Returns the result of the invoked method.\n     */\n    function baseInvoke(object, path, args) {\n      path = castPath(path, object);\n      object = parent(object, path);\n      var func = object == null ? object : object[toKey(last(path))];\n      return func == null ? undefined : apply(func, object, args);\n    }\n\n    /**\n     * The base implementation of `_.isArguments`.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n     */\n    function baseIsArguments(value) {\n      return isObjectLike(value) && baseGetTag(value) == argsTag;\n    }\n\n    /**\n     * The base implementation of `_.isArrayBuffer` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.\n     */\n    function baseIsArrayBuffer(value) {\n      return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;\n    }\n\n    /**\n     * The base implementation of `_.isDate` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a date object, else `false`.\n     */\n    function baseIsDate(value) {\n      return isObjectLike(value) && baseGetTag(value) == dateTag;\n    }\n\n    /**\n     * The base implementation of `_.isEqual` which supports partial comparisons\n     * and tracks traversed objects.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @param {boolean} bitmask The bitmask flags.\n     *  1 - Unordered comparison\n     *  2 - Partial comparison\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     */\n    function baseIsEqual(value, other, bitmask, customizer, stack) {\n      if (value === other) {\n        return true;\n      }\n      if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n        return value !== value && other !== other;\n      }\n      return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n    }\n\n    /**\n     * A specialized version of `baseIsEqual` for arrays and objects which performs\n     * deep comparisons and tracks traversed objects enabling objects with circular\n     * references to be compared.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n     */\n    function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n      var objIsArr = isArray(object),\n          othIsArr = isArray(other),\n          objTag = objIsArr ? arrayTag : getTag(object),\n          othTag = othIsArr ? arrayTag : getTag(other);\n\n      objTag = objTag == argsTag ? objectTag : objTag;\n      othTag = othTag == argsTag ? objectTag : othTag;\n\n      var objIsObj = objTag == objectTag,\n          othIsObj = othTag == objectTag,\n          isSameTag = objTag == othTag;\n\n      if (isSameTag && isBuffer(object)) {\n        if (!isBuffer(other)) {\n          return false;\n        }\n        objIsArr = true;\n        objIsObj = false;\n      }\n      if (isSameTag && !objIsObj) {\n        stack || (stack = new Stack);\n        return (objIsArr || isTypedArray(object))\n          ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n          : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n      }\n      if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n        var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n            othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n        if (objIsWrapped || othIsWrapped) {\n          var objUnwrapped = objIsWrapped ? object.value() : object,\n              othUnwrapped = othIsWrapped ? other.value() : other;\n\n          stack || (stack = new Stack);\n          return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n        }\n      }\n      if (!isSameTag) {\n        return false;\n      }\n      stack || (stack = new Stack);\n      return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n    }\n\n    /**\n     * The base implementation of `_.isMap` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n     */\n    function baseIsMap(value) {\n      return isObjectLike(value) && getTag(value) == mapTag;\n    }\n\n    /**\n     * The base implementation of `_.isMatch` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property values to match.\n     * @param {Array} matchData The property names, values, and compare flags to match.\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n     */\n    function baseIsMatch(object, source, matchData, customizer) {\n      var index = matchData.length,\n          length = index,\n          noCustomizer = !customizer;\n\n      if (object == null) {\n        return !length;\n      }\n      object = Object(object);\n      while (index--) {\n        var data = matchData[index];\n        if ((noCustomizer && data[2])\n              ? data[1] !== object[data[0]]\n              : !(data[0] in object)\n            ) {\n          return false;\n        }\n      }\n      while (++index < length) {\n        data = matchData[index];\n        var key = data[0],\n            objValue = object[key],\n            srcValue = data[1];\n\n        if (noCustomizer && data[2]) {\n          if (objValue === undefined && !(key in object)) {\n            return false;\n          }\n        } else {\n          var stack = new Stack;\n          if (customizer) {\n            var result = customizer(objValue, srcValue, key, object, source, stack);\n          }\n          if (!(result === undefined\n                ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)\n                : result\n              )) {\n            return false;\n          }\n        }\n      }\n      return true;\n    }\n\n    /**\n     * The base implementation of `_.isNative` without bad shim checks.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a native function,\n     *  else `false`.\n     */\n    function baseIsNative(value) {\n      if (!isObject(value) || isMasked(value)) {\n        return false;\n      }\n      var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n      return pattern.test(toSource(value));\n    }\n\n    /**\n     * The base implementation of `_.isRegExp` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.\n     */\n    function baseIsRegExp(value) {\n      return isObjectLike(value) && baseGetTag(value) == regexpTag;\n    }\n\n    /**\n     * The base implementation of `_.isSet` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n     */\n    function baseIsSet(value) {\n      return isObjectLike(value) && getTag(value) == setTag;\n    }\n\n    /**\n     * The base implementation of `_.isTypedArray` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n     */\n    function baseIsTypedArray(value) {\n      return isObjectLike(value) &&\n        isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n    }\n\n    /**\n     * The base implementation of `_.iteratee`.\n     *\n     * @private\n     * @param {*} [value=_.identity] The value to convert to an iteratee.\n     * @returns {Function} Returns the iteratee.\n     */\n    function baseIteratee(value) {\n      // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.\n      // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.\n      if (typeof value == 'function') {\n        return value;\n      }\n      if (value == null) {\n        return identity;\n      }\n      if (typeof value == 'object') {\n        return isArray(value)\n          ? baseMatchesProperty(value[0], value[1])\n          : baseMatches(value);\n      }\n      return property(value);\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     */\n    function 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 `_.keysIn` 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     */\n    function baseKeysIn(object) {\n      if (!isObject(object)) {\n        return nativeKeysIn(object);\n      }\n      var isProto = isPrototype(object),\n          result = [];\n\n      for (var key in object) {\n        if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.lt` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is less than `other`,\n     *  else `false`.\n     */\n    function baseLt(value, other) {\n      return value < other;\n    }\n\n    /**\n     * The base implementation of `_.map` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array} Returns the new mapped array.\n     */\n    function baseMap(collection, iteratee) {\n      var index = -1,\n          result = isArrayLike(collection) ? Array(collection.length) : [];\n\n      baseEach(collection, function(value, key, collection) {\n        result[++index] = iteratee(value, key, collection);\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.matches` which doesn't clone `source`.\n     *\n     * @private\n     * @param {Object} source The object of property values to match.\n     * @returns {Function} Returns the new spec function.\n     */\n    function baseMatches(source) {\n      var matchData = getMatchData(source);\n      if (matchData.length == 1 && matchData[0][2]) {\n        return matchesStrictComparable(matchData[0][0], matchData[0][1]);\n      }\n      return function(object) {\n        return object === source || baseIsMatch(object, source, matchData);\n      };\n    }\n\n    /**\n     * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.\n     *\n     * @private\n     * @param {string} path The path of the property to get.\n     * @param {*} srcValue The value to match.\n     * @returns {Function} Returns the new spec function.\n     */\n    function baseMatchesProperty(path, srcValue) {\n      if (isKey(path) && isStrictComparable(srcValue)) {\n        return matchesStrictComparable(toKey(path), srcValue);\n      }\n      return function(object) {\n        var objValue = get(object, path);\n        return (objValue === undefined && objValue === srcValue)\n          ? hasIn(object, path)\n          : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);\n      };\n    }\n\n    /**\n     * The base implementation of `_.merge` without support for multiple sources.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @param {number} srcIndex The index of `source`.\n     * @param {Function} [customizer] The function to customize merged values.\n     * @param {Object} [stack] Tracks traversed source values and their merged\n     *  counterparts.\n     */\n    function baseMerge(object, source, srcIndex, customizer, stack) {\n      if (object === source) {\n        return;\n      }\n      baseFor(source, function(srcValue, key) {\n        if (isObject(srcValue)) {\n          stack || (stack = new Stack);\n          baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n        }\n        else {\n          var newValue = customizer\n            ? customizer(object[key], srcValue, (key + ''), object, source, stack)\n            : undefined;\n\n          if (newValue === undefined) {\n            newValue = srcValue;\n          }\n          assignMergeValue(object, key, newValue);\n        }\n      }, keysIn);\n    }\n\n    /**\n     * A specialized version of `baseMerge` for arrays and objects which performs\n     * deep merges and tracks traversed objects enabling objects with circular\n     * references to be merged.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @param {string} key The key of the value to merge.\n     * @param {number} srcIndex The index of `source`.\n     * @param {Function} mergeFunc The function to merge values.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @param {Object} [stack] Tracks traversed source values and their merged\n     *  counterparts.\n     */\n    function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n      var objValue = object[key],\n          srcValue = source[key],\n          stacked = stack.get(srcValue);\n\n      if (stacked) {\n        assignMergeValue(object, key, stacked);\n        return;\n      }\n      var newValue = customizer\n        ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n        : undefined;\n\n      var isCommon = newValue === undefined;\n\n      if (isCommon) {\n        var isArr = isArray(srcValue),\n            isBuff = !isArr && isBuffer(srcValue),\n            isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n\n        newValue = srcValue;\n        if (isArr || isBuff || isTyped) {\n          if (isArray(objValue)) {\n            newValue = objValue;\n          }\n          else if (isArrayLikeObject(objValue)) {\n            newValue = copyArray(objValue);\n          }\n          else if (isBuff) {\n            isCommon = false;\n            newValue = cloneBuffer(srcValue, true);\n          }\n          else if (isTyped) {\n            isCommon = false;\n            newValue = cloneTypedArray(srcValue, true);\n          }\n          else {\n            newValue = [];\n          }\n        }\n        else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n          newValue = objValue;\n          if (isArguments(objValue)) {\n            newValue = toPlainObject(objValue);\n          }\n          else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {\n            newValue = initCloneObject(srcValue);\n          }\n        }\n        else {\n          isCommon = false;\n        }\n      }\n      if (isCommon) {\n        // Recursively merge objects and arrays (susceptible to call stack limits).\n        stack.set(srcValue, newValue);\n        mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n        stack['delete'](srcValue);\n      }\n      assignMergeValue(object, key, newValue);\n    }\n\n    /**\n     * The base implementation of `_.nth` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {Array} array The array to query.\n     * @param {number} n The index of the element to return.\n     * @returns {*} Returns the nth element of `array`.\n     */\n    function baseNth(array, n) {\n      var length = array.length;\n      if (!length) {\n        return;\n      }\n      n += n < 0 ? length : 0;\n      return isIndex(n, length) ? array[n] : undefined;\n    }\n\n    /**\n     * The base implementation of `_.orderBy` without param guards.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.\n     * @param {string[]} orders The sort orders of `iteratees`.\n     * @returns {Array} Returns the new sorted array.\n     */\n    function baseOrderBy(collection, iteratees, orders) {\n      var index = -1;\n      iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(getIteratee()));\n\n      var result = baseMap(collection, function(value, key, collection) {\n        var criteria = arrayMap(iteratees, function(iteratee) {\n          return iteratee(value);\n        });\n        return { 'criteria': criteria, 'index': ++index, 'value': value };\n      });\n\n      return baseSortBy(result, function(object, other) {\n        return compareMultiple(object, other, orders);\n      });\n    }\n\n    /**\n     * The base implementation of `_.pick` without support for individual\n     * property identifiers.\n     *\n     * @private\n     * @param {Object} object The source object.\n     * @param {string[]} paths The property paths to pick.\n     * @returns {Object} Returns the new object.\n     */\n    function basePick(object, paths) {\n      return basePickBy(object, paths, function(value, path) {\n        return hasIn(object, path);\n      });\n    }\n\n    /**\n     * The base implementation of  `_.pickBy` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The source object.\n     * @param {string[]} paths The property paths to pick.\n     * @param {Function} predicate The function invoked per property.\n     * @returns {Object} Returns the new object.\n     */\n    function basePickBy(object, paths, predicate) {\n      var index = -1,\n          length = paths.length,\n          result = {};\n\n      while (++index < length) {\n        var path = paths[index],\n            value = baseGet(object, path);\n\n        if (predicate(value, path)) {\n          baseSet(result, castPath(path, object), value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * A specialized version of `baseProperty` which supports deep paths.\n     *\n     * @private\n     * @param {Array|string} path The path of the property to get.\n     * @returns {Function} Returns the new accessor function.\n     */\n    function basePropertyDeep(path) {\n      return function(object) {\n        return baseGet(object, path);\n      };\n    }\n\n    /**\n     * The base implementation of `_.pullAllBy` without support for iteratee\n     * shorthands.\n     *\n     * @private\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns `array`.\n     */\n    function basePullAll(array, values, iteratee, comparator) {\n      var indexOf = comparator ? baseIndexOfWith : baseIndexOf,\n          index = -1,\n          length = values.length,\n          seen = array;\n\n      if (array === values) {\n        values = copyArray(values);\n      }\n      if (iteratee) {\n        seen = arrayMap(array, baseUnary(iteratee));\n      }\n      while (++index < length) {\n        var fromIndex = 0,\n            value = values[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {\n          if (seen !== array) {\n            splice.call(seen, fromIndex, 1);\n          }\n          splice.call(array, fromIndex, 1);\n        }\n      }\n      return array;\n    }\n\n    /**\n     * The base implementation of `_.pullAt` without support for individual\n     * indexes or capturing the removed elements.\n     *\n     * @private\n     * @param {Array} array The array to modify.\n     * @param {number[]} indexes The indexes of elements to remove.\n     * @returns {Array} Returns `array`.\n     */\n    function basePullAt(array, indexes) {\n      var length = array ? indexes.length : 0,\n          lastIndex = length - 1;\n\n      while (length--) {\n        var index = indexes[length];\n        if (length == lastIndex || index !== previous) {\n          var previous = index;\n          if (isIndex(index)) {\n            splice.call(array, index, 1);\n          } else {\n            baseUnset(array, index);\n          }\n        }\n      }\n      return array;\n    }\n\n    /**\n     * The base implementation of `_.random` without support for returning\n     * floating-point numbers.\n     *\n     * @private\n     * @param {number} lower The lower bound.\n     * @param {number} upper The upper bound.\n     * @returns {number} Returns the random number.\n     */\n    function baseRandom(lower, upper) {\n      return lower + nativeFloor(nativeRandom() * (upper - lower + 1));\n    }\n\n    /**\n     * The base implementation of `_.range` and `_.rangeRight` which doesn't\n     * coerce arguments.\n     *\n     * @private\n     * @param {number} start The start of the range.\n     * @param {number} end The end of the range.\n     * @param {number} step The value to increment or decrement by.\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Array} Returns the range of numbers.\n     */\n    function baseRange(start, end, step, fromRight) {\n      var index = -1,\n          length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),\n          result = Array(length);\n\n      while (length--) {\n        result[fromRight ? length : ++index] = start;\n        start += step;\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.repeat` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {string} string The string to repeat.\n     * @param {number} n The number of times to repeat the string.\n     * @returns {string} Returns the repeated string.\n     */\n    function baseRepeat(string, n) {\n      var result = '';\n      if (!string || n < 1 || n > MAX_SAFE_INTEGER) {\n        return result;\n      }\n      // Leverage the exponentiation by squaring algorithm for a faster repeat.\n      // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.\n      do {\n        if (n % 2) {\n          result += string;\n        }\n        n = nativeFloor(n / 2);\n        if (n) {\n          string += string;\n        }\n      } while (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     */\n    function baseRest(func, start) {\n      return setToString(overRest(func, start, identity), func + '');\n    }\n\n    /**\n     * The base implementation of `_.sample`.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to sample.\n     * @returns {*} Returns the random element.\n     */\n    function baseSample(collection) {\n      return arraySample(values(collection));\n    }\n\n    /**\n     * The base implementation of `_.sampleSize` without param guards.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to sample.\n     * @param {number} n The number of elements to sample.\n     * @returns {Array} Returns the random elements.\n     */\n    function baseSampleSize(collection, n) {\n      var array = values(collection);\n      return shuffleSelf(array, baseClamp(n, 0, array.length));\n    }\n\n    /**\n     * The base implementation of `_.set`.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {*} value The value to set.\n     * @param {Function} [customizer] The function to customize path creation.\n     * @returns {Object} Returns `object`.\n     */\n    function baseSet(object, path, value, customizer) {\n      if (!isObject(object)) {\n        return object;\n      }\n      path = castPath(path, object);\n\n      var index = -1,\n          length = path.length,\n          lastIndex = length - 1,\n          nested = object;\n\n      while (nested != null && ++index < length) {\n        var key = toKey(path[index]),\n            newValue = value;\n\n        if (index != lastIndex) {\n          var objValue = nested[key];\n          newValue = customizer ? customizer(objValue, key, nested) : undefined;\n          if (newValue === undefined) {\n            newValue = isObject(objValue)\n              ? objValue\n              : (isIndex(path[index + 1]) ? [] : {});\n          }\n        }\n        assignValue(nested, key, newValue);\n        nested = nested[key];\n      }\n      return object;\n    }\n\n    /**\n     * The base implementation of `setData` without support for hot loop shorting.\n     *\n     * @private\n     * @param {Function} func The function to associate metadata with.\n     * @param {*} data The metadata.\n     * @returns {Function} Returns `func`.\n     */\n    var baseSetData = !metaMap ? identity : function(func, data) {\n      metaMap.set(func, data);\n      return func;\n    };\n\n    /**\n     * The base implementation of `setToString` without support for hot loop shorting.\n     *\n     * @private\n     * @param {Function} func The function to modify.\n     * @param {Function} string The `toString` result.\n     * @returns {Function} Returns `func`.\n     */\n    var baseSetToString = !defineProperty ? identity : function(func, string) {\n      return defineProperty(func, 'toString', {\n        'configurable': true,\n        'enumerable': false,\n        'value': constant(string),\n        'writable': true\n      });\n    };\n\n    /**\n     * The base implementation of `_.shuffle`.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to shuffle.\n     * @returns {Array} Returns the new shuffled array.\n     */\n    function baseShuffle(collection) {\n      return shuffleSelf(values(collection));\n    }\n\n    /**\n     * The base implementation of `_.slice` without an iteratee call guard.\n     *\n     * @private\n     * @param {Array} array The array to slice.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns the slice of `array`.\n     */\n    function baseSlice(array, start, end) {\n      var index = -1,\n          length = array.length;\n\n      if (start < 0) {\n        start = -start > length ? 0 : (length + start);\n      }\n      end = end > length ? length : end;\n      if (end < 0) {\n        end += length;\n      }\n      length = start > end ? 0 : ((end - start) >>> 0);\n      start >>>= 0;\n\n      var result = Array(length);\n      while (++index < length) {\n        result[index] = array[index + start];\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.some` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {boolean} Returns `true` if any element passes the predicate check,\n     *  else `false`.\n     */\n    function baseSome(collection, predicate) {\n      var result;\n\n      baseEach(collection, function(value, index, collection) {\n        result = predicate(value, index, collection);\n        return !result;\n      });\n      return !!result;\n    }\n\n    /**\n     * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which\n     * performs a binary search of `array` to determine the index at which `value`\n     * should be inserted into `array` in order to maintain its sort order.\n     *\n     * @private\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {boolean} [retHighest] Specify returning the highest qualified index.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     */\n    function baseSortedIndex(array, value, retHighest) {\n      var low = 0,\n          high = array == null ? low : array.length;\n\n      if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {\n        while (low < high) {\n          var mid = (low + high) >>> 1,\n              computed = array[mid];\n\n          if (computed !== null && !isSymbol(computed) &&\n              (retHighest ? (computed <= value) : (computed < value))) {\n            low = mid + 1;\n          } else {\n            high = mid;\n          }\n        }\n        return high;\n      }\n      return baseSortedIndexBy(array, value, identity, retHighest);\n    }\n\n    /**\n     * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`\n     * which invokes `iteratee` for `value` and each element of `array` to compute\n     * their sort ranking. The iteratee is invoked with one argument; (value).\n     *\n     * @private\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {Function} iteratee The iteratee invoked per element.\n     * @param {boolean} [retHighest] Specify returning the highest qualified index.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     */\n    function baseSortedIndexBy(array, value, iteratee, retHighest) {\n      value = iteratee(value);\n\n      var low = 0,\n          high = array == null ? 0 : array.length,\n          valIsNaN = value !== value,\n          valIsNull = value === null,\n          valIsSymbol = isSymbol(value),\n          valIsUndefined = value === undefined;\n\n      while (low < high) {\n        var mid = nativeFloor((low + high) / 2),\n            computed = iteratee(array[mid]),\n            othIsDefined = computed !== undefined,\n            othIsNull = computed === null,\n            othIsReflexive = computed === computed,\n            othIsSymbol = isSymbol(computed);\n\n        if (valIsNaN) {\n          var setLow = retHighest || othIsReflexive;\n        } else if (valIsUndefined) {\n          setLow = othIsReflexive && (retHighest || othIsDefined);\n        } else if (valIsNull) {\n          setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);\n        } else if (valIsSymbol) {\n          setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);\n        } else if (othIsNull || othIsSymbol) {\n          setLow = false;\n        } else {\n          setLow = retHighest ? (computed <= value) : (computed < value);\n        }\n        if (setLow) {\n          low = mid + 1;\n        } else {\n          high = mid;\n        }\n      }\n      return nativeMin(high, MAX_ARRAY_INDEX);\n    }\n\n    /**\n     * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without\n     * support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     */\n    function baseSortedUniq(array, iteratee) {\n      var index = -1,\n          length = array.length,\n          resIndex = 0,\n          result = [];\n\n      while (++index < length) {\n        var value = array[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        if (!index || !eq(computed, seen)) {\n          var seen = computed;\n          result[resIndex++] = value === 0 ? 0 : value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.toNumber` which doesn't ensure correct\n     * conversions of binary, hexadecimal, or octal string values.\n     *\n     * @private\n     * @param {*} value The value to process.\n     * @returns {number} Returns the number.\n     */\n    function baseToNumber(value) {\n      if (typeof value == 'number') {\n        return value;\n      }\n      if (isSymbol(value)) {\n        return NAN;\n      }\n      return +value;\n    }\n\n    /**\n     * The base implementation of `_.toString` which doesn't convert nullish\n     * values to empty strings.\n     *\n     * @private\n     * @param {*} value The value to process.\n     * @returns {string} Returns the string.\n     */\n    function baseToString(value) {\n      // Exit early for strings to avoid a performance hit in some environments.\n      if (typeof value == 'string') {\n        return value;\n      }\n      if (isArray(value)) {\n        // Recursively convert values (susceptible to call stack limits).\n        return arrayMap(value, baseToString) + '';\n      }\n      if (isSymbol(value)) {\n        return symbolToString ? symbolToString.call(value) : '';\n      }\n      var result = (value + '');\n      return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n    }\n\n    /**\n     * The base implementation of `_.uniqBy` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     */\n    function baseUniq(array, iteratee, comparator) {\n      var index = -1,\n          includes = arrayIncludes,\n          length = array.length,\n          isCommon = true,\n          result = [],\n          seen = result;\n\n      if (comparator) {\n        isCommon = false;\n        includes = arrayIncludesWith;\n      }\n      else if (length >= LARGE_ARRAY_SIZE) {\n        var set = iteratee ? null : createSet(array);\n        if (set) {\n          return setToArray(set);\n        }\n        isCommon = false;\n        includes = cacheHas;\n        seen = new SetCache;\n      }\n      else {\n        seen = iteratee ? [] : result;\n      }\n      outer:\n      while (++index < length) {\n        var value = array[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        value = (comparator || value !== 0) ? value : 0;\n        if (isCommon && computed === computed) {\n          var seenIndex = seen.length;\n          while (seenIndex--) {\n            if (seen[seenIndex] === computed) {\n              continue outer;\n            }\n          }\n          if (iteratee) {\n            seen.push(computed);\n          }\n          result.push(value);\n        }\n        else if (!includes(seen, computed, comparator)) {\n          if (seen !== result) {\n            seen.push(computed);\n          }\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.unset`.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The property path to unset.\n     * @returns {boolean} Returns `true` if the property is deleted, else `false`.\n     */\n    function baseUnset(object, path) {\n      path = castPath(path, object);\n      object = parent(object, path);\n      return object == null || delete object[toKey(last(path))];\n    }\n\n    /**\n     * The base implementation of `_.update`.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to update.\n     * @param {Function} updater The function to produce the updated value.\n     * @param {Function} [customizer] The function to customize path creation.\n     * @returns {Object} Returns `object`.\n     */\n    function baseUpdate(object, path, updater, customizer) {\n      return baseSet(object, path, updater(baseGet(object, path)), customizer);\n    }\n\n    /**\n     * The base implementation of methods like `_.dropWhile` and `_.takeWhile`\n     * without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to query.\n     * @param {Function} predicate The function invoked per iteration.\n     * @param {boolean} [isDrop] Specify dropping elements instead of taking them.\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Array} Returns the slice of `array`.\n     */\n    function baseWhile(array, predicate, isDrop, fromRight) {\n      var length = array.length,\n          index = fromRight ? length : -1;\n\n      while ((fromRight ? index-- : ++index < length) &&\n        predicate(array[index], index, array)) {}\n\n      return isDrop\n        ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length))\n        : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index));\n    }\n\n    /**\n     * The base implementation of `wrapperValue` which returns the result of\n     * performing a sequence of actions on the unwrapped `value`, where each\n     * successive action is supplied the return value of the previous.\n     *\n     * @private\n     * @param {*} value The unwrapped value.\n     * @param {Array} actions Actions to perform to resolve the unwrapped value.\n     * @returns {*} Returns the resolved value.\n     */\n    function baseWrapperValue(value, actions) {\n      var result = value;\n      if (result instanceof LazyWrapper) {\n        result = result.value();\n      }\n      return arrayReduce(actions, function(result, action) {\n        return action.func.apply(action.thisArg, arrayPush([result], action.args));\n      }, result);\n    }\n\n    /**\n     * The base implementation of methods like `_.xor`, without support for\n     * iteratee shorthands, that accepts an array of arrays to inspect.\n     *\n     * @private\n     * @param {Array} arrays The arrays to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of values.\n     */\n    function baseXor(arrays, iteratee, comparator) {\n      var length = arrays.length;\n      if (length < 2) {\n        return length ? baseUniq(arrays[0]) : [];\n      }\n      var index = -1,\n          result = Array(length);\n\n      while (++index < length) {\n        var array = arrays[index],\n            othIndex = -1;\n\n        while (++othIndex < length) {\n          if (othIndex != index) {\n            result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);\n          }\n        }\n      }\n      return baseUniq(baseFlatten(result, 1), iteratee, comparator);\n    }\n\n    /**\n     * This base implementation of `_.zipObject` which assigns values using `assignFunc`.\n     *\n     * @private\n     * @param {Array} props The property identifiers.\n     * @param {Array} values The property values.\n     * @param {Function} assignFunc The function to assign values.\n     * @returns {Object} Returns the new object.\n     */\n    function baseZipObject(props, values, assignFunc) {\n      var index = -1,\n          length = props.length,\n          valsLength = values.length,\n          result = {};\n\n      while (++index < length) {\n        var value = index < valsLength ? values[index] : undefined;\n        assignFunc(result, props[index], value);\n      }\n      return result;\n    }\n\n    /**\n     * Casts `value` to an empty array if it's not an array like object.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @returns {Array|Object} Returns the cast array-like object.\n     */\n    function castArrayLikeObject(value) {\n      return isArrayLikeObject(value) ? value : [];\n    }\n\n    /**\n     * Casts `value` to `identity` if it's not a function.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @returns {Function} Returns cast function.\n     */\n    function castFunction(value) {\n      return typeof value == 'function' ? value : identity;\n    }\n\n    /**\n     * Casts `value` to a path array if it's not one.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @param {Object} [object] The object to query keys on.\n     * @returns {Array} Returns the cast property path array.\n     */\n    function castPath(value, object) {\n      if (isArray(value)) {\n        return value;\n      }\n      return isKey(value, object) ? [value] : stringToPath(toString(value));\n    }\n\n    /**\n     * A `baseRest` alias which can be replaced with `identity` by module\n     * replacement plugins.\n     *\n     * @private\n     * @type {Function}\n     * @param {Function} func The function to apply a rest parameter to.\n     * @returns {Function} Returns the new function.\n     */\n    var castRest = baseRest;\n\n    /**\n     * Casts `array` to a slice if it's needed.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {number} start The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns the cast slice.\n     */\n    function castSlice(array, start, end) {\n      var length = array.length;\n      end = end === undefined ? length : end;\n      return (!start && end >= length) ? array : baseSlice(array, start, end);\n    }\n\n    /**\n     * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout).\n     *\n     * @private\n     * @param {number|Object} id The timer id or timeout object of the timer to clear.\n     */\n    var clearTimeout = ctxClearTimeout || function(id) {\n      return root.clearTimeout(id);\n    };\n\n    /**\n     * Creates a clone of  `buffer`.\n     *\n     * @private\n     * @param {Buffer} buffer The buffer to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Buffer} Returns the cloned buffer.\n     */\n    function cloneBuffer(buffer, isDeep) {\n      if (isDeep) {\n        return buffer.slice();\n      }\n      var length = buffer.length,\n          result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n      buffer.copy(result);\n      return result;\n    }\n\n    /**\n     * Creates a clone of `arrayBuffer`.\n     *\n     * @private\n     * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n     * @returns {ArrayBuffer} Returns the cloned array buffer.\n     */\n    function cloneArrayBuffer(arrayBuffer) {\n      var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n      new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n      return result;\n    }\n\n    /**\n     * Creates a clone of `dataView`.\n     *\n     * @private\n     * @param {Object} dataView The data view to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the cloned data view.\n     */\n    function cloneDataView(dataView, isDeep) {\n      var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n      return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n    }\n\n    /**\n     * Creates a clone of `map`.\n     *\n     * @private\n     * @param {Object} map The map to clone.\n     * @param {Function} cloneFunc The function to clone values.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the cloned map.\n     */\n    function cloneMap(map, isDeep, cloneFunc) {\n      var array = isDeep ? cloneFunc(mapToArray(map), CLONE_DEEP_FLAG) : mapToArray(map);\n      return arrayReduce(array, addMapEntry, new map.constructor);\n    }\n\n    /**\n     * Creates a clone of `regexp`.\n     *\n     * @private\n     * @param {Object} regexp The regexp to clone.\n     * @returns {Object} Returns the cloned regexp.\n     */\n    function cloneRegExp(regexp) {\n      var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n      result.lastIndex = regexp.lastIndex;\n      return result;\n    }\n\n    /**\n     * Creates a clone of `set`.\n     *\n     * @private\n     * @param {Object} set The set to clone.\n     * @param {Function} cloneFunc The function to clone values.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the cloned set.\n     */\n    function cloneSet(set, isDeep, cloneFunc) {\n      var array = isDeep ? cloneFunc(setToArray(set), CLONE_DEEP_FLAG) : setToArray(set);\n      return arrayReduce(array, addSetEntry, new set.constructor);\n    }\n\n    /**\n     * Creates a clone of the `symbol` object.\n     *\n     * @private\n     * @param {Object} symbol The symbol object to clone.\n     * @returns {Object} Returns the cloned symbol object.\n     */\n    function cloneSymbol(symbol) {\n      return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};\n    }\n\n    /**\n     * Creates a clone of `typedArray`.\n     *\n     * @private\n     * @param {Object} typedArray The typed array to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the cloned typed array.\n     */\n    function cloneTypedArray(typedArray, isDeep) {\n      var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n      return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n    }\n\n    /**\n     * Compares values to sort them in ascending order.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {number} Returns the sort order indicator for `value`.\n     */\n    function compareAscending(value, other) {\n      if (value !== other) {\n        var valIsDefined = value !== undefined,\n            valIsNull = value === null,\n            valIsReflexive = value === value,\n            valIsSymbol = isSymbol(value);\n\n        var othIsDefined = other !== undefined,\n            othIsNull = other === null,\n            othIsReflexive = other === other,\n            othIsSymbol = isSymbol(other);\n\n        if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||\n            (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||\n            (valIsNull && othIsDefined && othIsReflexive) ||\n            (!valIsDefined && othIsReflexive) ||\n            !valIsReflexive) {\n          return 1;\n        }\n        if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||\n            (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||\n            (othIsNull && valIsDefined && valIsReflexive) ||\n            (!othIsDefined && valIsReflexive) ||\n            !othIsReflexive) {\n          return -1;\n        }\n      }\n      return 0;\n    }\n\n    /**\n     * Used by `_.orderBy` to compare multiple properties of a value to another\n     * and stable sort them.\n     *\n     * If `orders` is unspecified, all values are sorted in ascending order. Otherwise,\n     * specify an order of \"desc\" for descending or \"asc\" for ascending sort order\n     * of corresponding values.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {boolean[]|string[]} orders The order to sort by for each property.\n     * @returns {number} Returns the sort order indicator for `object`.\n     */\n    function compareMultiple(object, other, orders) {\n      var index = -1,\n          objCriteria = object.criteria,\n          othCriteria = other.criteria,\n          length = objCriteria.length,\n          ordersLength = orders.length;\n\n      while (++index < length) {\n        var result = compareAscending(objCriteria[index], othCriteria[index]);\n        if (result) {\n          if (index >= ordersLength) {\n            return result;\n          }\n          var order = orders[index];\n          return result * (order == 'desc' ? -1 : 1);\n        }\n      }\n      // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications\n      // that causes it, under certain circumstances, to provide the same value for\n      // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247\n      // for more details.\n      //\n      // This also ensures a stable sort in V8 and other engines.\n      // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.\n      return object.index - other.index;\n    }\n\n    /**\n     * Creates an array that is the composition of partially applied arguments,\n     * placeholders, and provided arguments into a single array of arguments.\n     *\n     * @private\n     * @param {Array} args The provided arguments.\n     * @param {Array} partials The arguments to prepend to those provided.\n     * @param {Array} holders The `partials` placeholder indexes.\n     * @params {boolean} [isCurried] Specify composing for a curried function.\n     * @returns {Array} Returns the new array of composed arguments.\n     */\n    function composeArgs(args, partials, holders, isCurried) {\n      var argsIndex = -1,\n          argsLength = args.length,\n          holdersLength = holders.length,\n          leftIndex = -1,\n          leftLength = partials.length,\n          rangeLength = nativeMax(argsLength - holdersLength, 0),\n          result = Array(leftLength + rangeLength),\n          isUncurried = !isCurried;\n\n      while (++leftIndex < leftLength) {\n        result[leftIndex] = partials[leftIndex];\n      }\n      while (++argsIndex < holdersLength) {\n        if (isUncurried || argsIndex < argsLength) {\n          result[holders[argsIndex]] = args[argsIndex];\n        }\n      }\n      while (rangeLength--) {\n        result[leftIndex++] = args[argsIndex++];\n      }\n      return result;\n    }\n\n    /**\n     * This function is like `composeArgs` except that the arguments composition\n     * is tailored for `_.partialRight`.\n     *\n     * @private\n     * @param {Array} args The provided arguments.\n     * @param {Array} partials The arguments to append to those provided.\n     * @param {Array} holders The `partials` placeholder indexes.\n     * @params {boolean} [isCurried] Specify composing for a curried function.\n     * @returns {Array} Returns the new array of composed arguments.\n     */\n    function composeArgsRight(args, partials, holders, isCurried) {\n      var argsIndex = -1,\n          argsLength = args.length,\n          holdersIndex = -1,\n          holdersLength = holders.length,\n          rightIndex = -1,\n          rightLength = partials.length,\n          rangeLength = nativeMax(argsLength - holdersLength, 0),\n          result = Array(rangeLength + rightLength),\n          isUncurried = !isCurried;\n\n      while (++argsIndex < rangeLength) {\n        result[argsIndex] = args[argsIndex];\n      }\n      var offset = argsIndex;\n      while (++rightIndex < rightLength) {\n        result[offset + rightIndex] = partials[rightIndex];\n      }\n      while (++holdersIndex < holdersLength) {\n        if (isUncurried || argsIndex < argsLength) {\n          result[offset + holders[holdersIndex]] = args[argsIndex++];\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Copies the values of `source` to `array`.\n     *\n     * @private\n     * @param {Array} source The array to copy values from.\n     * @param {Array} [array=[]] The array to copy values to.\n     * @returns {Array} Returns `array`.\n     */\n    function copyArray(source, array) {\n      var index = -1,\n          length = source.length;\n\n      array || (array = Array(length));\n      while (++index < length) {\n        array[index] = source[index];\n      }\n      return array;\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     */\n    function copyObject(source, props, object, customizer) {\n      var isNew = !object;\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        if (newValue === undefined) {\n          newValue = source[key];\n        }\n        if (isNew) {\n          baseAssignValue(object, key, newValue);\n        } else {\n          assignValue(object, key, newValue);\n        }\n      }\n      return object;\n    }\n\n    /**\n     * Copies own symbols of `source` to `object`.\n     *\n     * @private\n     * @param {Object} source The object to copy symbols from.\n     * @param {Object} [object={}] The object to copy symbols to.\n     * @returns {Object} Returns `object`.\n     */\n    function copySymbols(source, object) {\n      return copyObject(source, getSymbols(source), object);\n    }\n\n    /**\n     * Copies own and inherited symbols of `source` to `object`.\n     *\n     * @private\n     * @param {Object} source The object to copy symbols from.\n     * @param {Object} [object={}] The object to copy symbols to.\n     * @returns {Object} Returns `object`.\n     */\n    function copySymbolsIn(source, object) {\n      return copyObject(source, getSymbolsIn(source), object);\n    }\n\n    /**\n     * Creates a function like `_.groupBy`.\n     *\n     * @private\n     * @param {Function} setter The function to set accumulator values.\n     * @param {Function} [initializer] The accumulator object initializer.\n     * @returns {Function} Returns the new aggregator function.\n     */\n    function createAggregator(setter, initializer) {\n      return function(collection, iteratee) {\n        var func = isArray(collection) ? arrayAggregator : baseAggregator,\n            accumulator = initializer ? initializer() : {};\n\n        return func(collection, setter, getIteratee(iteratee, 2), accumulator);\n      };\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     */\n    function 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     * Creates a `baseEach` or `baseEachRight` function.\n     *\n     * @private\n     * @param {Function} eachFunc The function to iterate over a collection.\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new base function.\n     */\n    function createBaseEach(eachFunc, fromRight) {\n      return function(collection, iteratee) {\n        if (collection == null) {\n          return collection;\n        }\n        if (!isArrayLike(collection)) {\n          return eachFunc(collection, iteratee);\n        }\n        var length = collection.length,\n            index = fromRight ? length : -1,\n            iterable = Object(collection);\n\n        while ((fromRight ? index-- : ++index < length)) {\n          if (iteratee(iterable[index], index, iterable) === false) {\n            break;\n          }\n        }\n        return collection;\n      };\n    }\n\n    /**\n     * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n     *\n     * @private\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new base function.\n     */\n    function createBaseFor(fromRight) {\n      return function(object, iteratee, keysFunc) {\n        var index = -1,\n            iterable = Object(object),\n            props = keysFunc(object),\n            length = props.length;\n\n        while (length--) {\n          var key = props[fromRight ? length : ++index];\n          if (iteratee(iterable[key], key, iterable) === false) {\n            break;\n          }\n        }\n        return object;\n      };\n    }\n\n    /**\n     * Creates a function that wraps `func` to invoke it with the optional `this`\n     * binding of `thisArg`.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createBind(func, bitmask, thisArg) {\n      var isBind = bitmask & WRAP_BIND_FLAG,\n          Ctor = createCtor(func);\n\n      function wrapper() {\n        var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n        return fn.apply(isBind ? thisArg : this, arguments);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a function like `_.lowerFirst`.\n     *\n     * @private\n     * @param {string} methodName The name of the `String` case method to use.\n     * @returns {Function} Returns the new case function.\n     */\n    function createCaseFirst(methodName) {\n      return function(string) {\n        string = toString(string);\n\n        var strSymbols = hasUnicode(string)\n          ? stringToArray(string)\n          : undefined;\n\n        var chr = strSymbols\n          ? strSymbols[0]\n          : string.charAt(0);\n\n        var trailing = strSymbols\n          ? castSlice(strSymbols, 1).join('')\n          : string.slice(1);\n\n        return chr[methodName]() + trailing;\n      };\n    }\n\n    /**\n     * Creates a function like `_.camelCase`.\n     *\n     * @private\n     * @param {Function} callback The function to combine each word.\n     * @returns {Function} Returns the new compounder function.\n     */\n    function createCompounder(callback) {\n      return function(string) {\n        return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');\n      };\n    }\n\n    /**\n     * Creates a function that produces an instance of `Ctor` regardless of\n     * whether it was invoked as part of a `new` expression or by `call` or `apply`.\n     *\n     * @private\n     * @param {Function} Ctor The constructor to wrap.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createCtor(Ctor) {\n      return function() {\n        // Use a `switch` statement to work with class constructors. See\n        // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist\n        // for more details.\n        var args = arguments;\n        switch (args.length) {\n          case 0: return new Ctor;\n          case 1: return new Ctor(args[0]);\n          case 2: return new Ctor(args[0], args[1]);\n          case 3: return new Ctor(args[0], args[1], args[2]);\n          case 4: return new Ctor(args[0], args[1], args[2], args[3]);\n          case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]);\n          case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);\n          case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);\n        }\n        var thisBinding = baseCreate(Ctor.prototype),\n            result = Ctor.apply(thisBinding, args);\n\n        // Mimic the constructor's `return` behavior.\n        // See https://es5.github.io/#x13.2.2 for more details.\n        return isObject(result) ? result : thisBinding;\n      };\n    }\n\n    /**\n     * Creates a function that wraps `func` to enable currying.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {number} arity The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createCurry(func, bitmask, arity) {\n      var Ctor = createCtor(func);\n\n      function wrapper() {\n        var length = arguments.length,\n            args = Array(length),\n            index = length,\n            placeholder = getHolder(wrapper);\n\n        while (index--) {\n          args[index] = arguments[index];\n        }\n        var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder)\n          ? []\n          : replaceHolders(args, placeholder);\n\n        length -= holders.length;\n        if (length < arity) {\n          return createRecurry(\n            func, bitmask, createHybrid, wrapper.placeholder, undefined,\n            args, holders, undefined, undefined, arity - length);\n        }\n        var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n        return apply(fn, this, args);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a `_.find` or `_.findLast` function.\n     *\n     * @private\n     * @param {Function} findIndexFunc The function to find the collection index.\n     * @returns {Function} Returns the new find function.\n     */\n    function createFind(findIndexFunc) {\n      return function(collection, predicate, fromIndex) {\n        var iterable = Object(collection);\n        if (!isArrayLike(collection)) {\n          var iteratee = getIteratee(predicate, 3);\n          collection = keys(collection);\n          predicate = function(key) { return iteratee(iterable[key], key, iterable); };\n        }\n        var index = findIndexFunc(collection, predicate, fromIndex);\n        return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;\n      };\n    }\n\n    /**\n     * Creates a `_.flow` or `_.flowRight` function.\n     *\n     * @private\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new flow function.\n     */\n    function createFlow(fromRight) {\n      return flatRest(function(funcs) {\n        var length = funcs.length,\n            index = length,\n            prereq = LodashWrapper.prototype.thru;\n\n        if (fromRight) {\n          funcs.reverse();\n        }\n        while (index--) {\n          var func = funcs[index];\n          if (typeof func != 'function') {\n            throw new TypeError(FUNC_ERROR_TEXT);\n          }\n          if (prereq && !wrapper && getFuncName(func) == 'wrapper') {\n            var wrapper = new LodashWrapper([], true);\n          }\n        }\n        index = wrapper ? index : length;\n        while (++index < length) {\n          func = funcs[index];\n\n          var funcName = getFuncName(func),\n              data = funcName == 'wrapper' ? getData(func) : undefined;\n\n          if (data && isLaziable(data[0]) &&\n                data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) &&\n                !data[4].length && data[9] == 1\n              ) {\n            wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);\n          } else {\n            wrapper = (func.length == 1 && isLaziable(func))\n              ? wrapper[funcName]()\n              : wrapper.thru(func);\n          }\n        }\n        return function() {\n          var args = arguments,\n              value = args[0];\n\n          if (wrapper && args.length == 1 && isArray(value)) {\n            return wrapper.plant(value).value();\n          }\n          var index = 0,\n              result = length ? funcs[index].apply(this, args) : value;\n\n          while (++index < length) {\n            result = funcs[index].call(this, result);\n          }\n          return result;\n        };\n      });\n    }\n\n    /**\n     * Creates a function that wraps `func` to invoke it with optional `this`\n     * binding of `thisArg`, partial application, and currying.\n     *\n     * @private\n     * @param {Function|string} func The function or method name to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @param {Array} [partials] The arguments to prepend to those provided to\n     *  the new function.\n     * @param {Array} [holders] The `partials` placeholder indexes.\n     * @param {Array} [partialsRight] The arguments to append to those provided\n     *  to the new function.\n     * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.\n     * @param {Array} [argPos] The argument positions of the new function.\n     * @param {number} [ary] The arity cap of `func`.\n     * @param {number} [arity] The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {\n      var isAry = bitmask & WRAP_ARY_FLAG,\n          isBind = bitmask & WRAP_BIND_FLAG,\n          isBindKey = bitmask & WRAP_BIND_KEY_FLAG,\n          isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG),\n          isFlip = bitmask & WRAP_FLIP_FLAG,\n          Ctor = isBindKey ? undefined : createCtor(func);\n\n      function wrapper() {\n        var length = arguments.length,\n            args = Array(length),\n            index = length;\n\n        while (index--) {\n          args[index] = arguments[index];\n        }\n        if (isCurried) {\n          var placeholder = getHolder(wrapper),\n              holdersCount = countHolders(args, placeholder);\n        }\n        if (partials) {\n          args = composeArgs(args, partials, holders, isCurried);\n        }\n        if (partialsRight) {\n          args = composeArgsRight(args, partialsRight, holdersRight, isCurried);\n        }\n        length -= holdersCount;\n        if (isCurried && length < arity) {\n          var newHolders = replaceHolders(args, placeholder);\n          return createRecurry(\n            func, bitmask, createHybrid, wrapper.placeholder, thisArg,\n            args, newHolders, argPos, ary, arity - length\n          );\n        }\n        var thisBinding = isBind ? thisArg : this,\n            fn = isBindKey ? thisBinding[func] : func;\n\n        length = args.length;\n        if (argPos) {\n          args = reorder(args, argPos);\n        } else if (isFlip && length > 1) {\n          args.reverse();\n        }\n        if (isAry && ary < length) {\n          args.length = ary;\n        }\n        if (this && this !== root && this instanceof wrapper) {\n          fn = Ctor || createCtor(fn);\n        }\n        return fn.apply(thisBinding, args);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a function like `_.invertBy`.\n     *\n     * @private\n     * @param {Function} setter The function to set accumulator values.\n     * @param {Function} toIteratee The function to resolve iteratees.\n     * @returns {Function} Returns the new inverter function.\n     */\n    function createInverter(setter, toIteratee) {\n      return function(object, iteratee) {\n        return baseInverter(object, setter, toIteratee(iteratee), {});\n      };\n    }\n\n    /**\n     * Creates a function that performs a mathematical operation on two values.\n     *\n     * @private\n     * @param {Function} operator The function to perform the operation.\n     * @param {number} [defaultValue] The value used for `undefined` arguments.\n     * @returns {Function} Returns the new mathematical operation function.\n     */\n    function createMathOperation(operator, defaultValue) {\n      return function(value, other) {\n        var result;\n        if (value === undefined && other === undefined) {\n          return defaultValue;\n        }\n        if (value !== undefined) {\n          result = value;\n        }\n        if (other !== undefined) {\n          if (result === undefined) {\n            return other;\n          }\n          if (typeof value == 'string' || typeof other == 'string') {\n            value = baseToString(value);\n            other = baseToString(other);\n          } else {\n            value = baseToNumber(value);\n            other = baseToNumber(other);\n          }\n          result = operator(value, other);\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Creates a function like `_.over`.\n     *\n     * @private\n     * @param {Function} arrayFunc The function to iterate over iteratees.\n     * @returns {Function} Returns the new over function.\n     */\n    function createOver(arrayFunc) {\n      return flatRest(function(iteratees) {\n        iteratees = arrayMap(iteratees, baseUnary(getIteratee()));\n        return baseRest(function(args) {\n          var thisArg = this;\n          return arrayFunc(iteratees, function(iteratee) {\n            return apply(iteratee, thisArg, args);\n          });\n        });\n      });\n    }\n\n    /**\n     * Creates the padding for `string` based on `length`. The `chars` string\n     * is truncated if the number of characters exceeds `length`.\n     *\n     * @private\n     * @param {number} length The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padding for `string`.\n     */\n    function createPadding(length, chars) {\n      chars = chars === undefined ? ' ' : baseToString(chars);\n\n      var charsLength = chars.length;\n      if (charsLength < 2) {\n        return charsLength ? baseRepeat(chars, length) : chars;\n      }\n      var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));\n      return hasUnicode(chars)\n        ? castSlice(stringToArray(result), 0, length).join('')\n        : result.slice(0, length);\n    }\n\n    /**\n     * Creates a function that wraps `func` to invoke it with the `this` binding\n     * of `thisArg` and `partials` prepended to the arguments it receives.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {*} thisArg The `this` binding of `func`.\n     * @param {Array} partials The arguments to prepend to those provided to\n     *  the new function.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createPartial(func, bitmask, thisArg, partials) {\n      var isBind = bitmask & WRAP_BIND_FLAG,\n          Ctor = createCtor(func);\n\n      function wrapper() {\n        var argsIndex = -1,\n            argsLength = arguments.length,\n            leftIndex = -1,\n            leftLength = partials.length,\n            args = Array(leftLength + argsLength),\n            fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n\n        while (++leftIndex < leftLength) {\n          args[leftIndex] = partials[leftIndex];\n        }\n        while (argsLength--) {\n          args[leftIndex++] = arguments[++argsIndex];\n        }\n        return apply(fn, isBind ? thisArg : this, args);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a `_.range` or `_.rangeRight` function.\n     *\n     * @private\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new range function.\n     */\n    function createRange(fromRight) {\n      return function(start, end, step) {\n        if (step && typeof step != 'number' && isIterateeCall(start, end, step)) {\n          end = step = undefined;\n        }\n        // Ensure the sign of `-0` is preserved.\n        start = toFinite(start);\n        if (end === undefined) {\n          end = start;\n          start = 0;\n        } else {\n          end = toFinite(end);\n        }\n        step = step === undefined ? (start < end ? 1 : -1) : toFinite(step);\n        return baseRange(start, end, step, fromRight);\n      };\n    }\n\n    /**\n     * Creates a function that performs a relational operation on two values.\n     *\n     * @private\n     * @param {Function} operator The function to perform the operation.\n     * @returns {Function} Returns the new relational operation function.\n     */\n    function createRelationalOperation(operator) {\n      return function(value, other) {\n        if (!(typeof value == 'string' && typeof other == 'string')) {\n          value = toNumber(value);\n          other = toNumber(other);\n        }\n        return operator(value, other);\n      };\n    }\n\n    /**\n     * Creates a function that wraps `func` to continue currying.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {Function} wrapFunc The function to create the `func` wrapper.\n     * @param {*} placeholder The placeholder value.\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @param {Array} [partials] The arguments to prepend to those provided to\n     *  the new function.\n     * @param {Array} [holders] The `partials` placeholder indexes.\n     * @param {Array} [argPos] The argument positions of the new function.\n     * @param {number} [ary] The arity cap of `func`.\n     * @param {number} [arity] The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {\n      var isCurry = bitmask & WRAP_CURRY_FLAG,\n          newHolders = isCurry ? holders : undefined,\n          newHoldersRight = isCurry ? undefined : holders,\n          newPartials = isCurry ? partials : undefined,\n          newPartialsRight = isCurry ? undefined : partials;\n\n      bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);\n      bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);\n\n      if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {\n        bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);\n      }\n      var newData = [\n        func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,\n        newHoldersRight, argPos, ary, arity\n      ];\n\n      var result = wrapFunc.apply(undefined, newData);\n      if (isLaziable(func)) {\n        setData(result, newData);\n      }\n      result.placeholder = placeholder;\n      return setWrapToString(result, func, bitmask);\n    }\n\n    /**\n     * Creates a function like `_.round`.\n     *\n     * @private\n     * @param {string} methodName The name of the `Math` method to use when rounding.\n     * @returns {Function} Returns the new round function.\n     */\n    function createRound(methodName) {\n      var func = Math[methodName];\n      return function(number, precision) {\n        number = toNumber(number);\n        precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);\n        if (precision) {\n          // Shift with exponential notation to avoid floating-point issues.\n          // See [MDN](https://mdn.io/round#Examples) for more details.\n          var pair = (toString(number) + 'e').split('e'),\n              value = func(pair[0] + 'e' + (+pair[1] + precision));\n\n          pair = (toString(value) + 'e').split('e');\n          return +(pair[0] + 'e' + (+pair[1] - precision));\n        }\n        return func(number);\n      };\n    }\n\n    /**\n     * Creates a set object of `values`.\n     *\n     * @private\n     * @param {Array} values The values to add to the set.\n     * @returns {Object} Returns the new set.\n     */\n    var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {\n      return new Set(values);\n    };\n\n    /**\n     * Creates a `_.toPairs` or `_.toPairsIn` function.\n     *\n     * @private\n     * @param {Function} keysFunc The function to get the keys of a given object.\n     * @returns {Function} Returns the new pairs function.\n     */\n    function createToPairs(keysFunc) {\n      return function(object) {\n        var tag = getTag(object);\n        if (tag == mapTag) {\n          return mapToArray(object);\n        }\n        if (tag == setTag) {\n          return setToPairs(object);\n        }\n        return baseToPairs(object, keysFunc(object));\n      };\n    }\n\n    /**\n     * Creates a function that either curries or invokes `func` with optional\n     * `this` binding and partially applied arguments.\n     *\n     * @private\n     * @param {Function|string} func The function or method name to wrap.\n     * @param {number} bitmask The bitmask flags.\n     *    1 - `_.bind`\n     *    2 - `_.bindKey`\n     *    4 - `_.curry` or `_.curryRight` of a bound function\n     *    8 - `_.curry`\n     *   16 - `_.curryRight`\n     *   32 - `_.partial`\n     *   64 - `_.partialRight`\n     *  128 - `_.rearg`\n     *  256 - `_.ary`\n     *  512 - `_.flip`\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @param {Array} [partials] The arguments to be partially applied.\n     * @param {Array} [holders] The `partials` placeholder indexes.\n     * @param {Array} [argPos] The argument positions of the new function.\n     * @param {number} [ary] The arity cap of `func`.\n     * @param {number} [arity] The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {\n      var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;\n      if (!isBindKey && typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      var length = partials ? partials.length : 0;\n      if (!length) {\n        bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);\n        partials = holders = undefined;\n      }\n      ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0);\n      arity = arity === undefined ? arity : toInteger(arity);\n      length -= holders ? holders.length : 0;\n\n      if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {\n        var partialsRight = partials,\n            holdersRight = holders;\n\n        partials = holders = undefined;\n      }\n      var data = isBindKey ? undefined : getData(func);\n\n      var newData = [\n        func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,\n        argPos, ary, arity\n      ];\n\n      if (data) {\n        mergeData(newData, data);\n      }\n      func = newData[0];\n      bitmask = newData[1];\n      thisArg = newData[2];\n      partials = newData[3];\n      holders = newData[4];\n      arity = newData[9] = newData[9] === undefined\n        ? (isBindKey ? 0 : func.length)\n        : nativeMax(newData[9] - length, 0);\n\n      if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {\n        bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);\n      }\n      if (!bitmask || bitmask == WRAP_BIND_FLAG) {\n        var result = createBind(func, bitmask, thisArg);\n      } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {\n        result = createCurry(func, bitmask, arity);\n      } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {\n        result = createPartial(func, bitmask, thisArg, partials);\n      } else {\n        result = createHybrid.apply(undefined, newData);\n      }\n      var setter = data ? baseSetData : setData;\n      return setWrapToString(setter(result, newData), func, bitmask);\n    }\n\n    /**\n     * Used by `_.defaults` to customize its `_.assignIn` use to assign properties\n     * of source objects to the destination object for all destination properties\n     * that resolve to `undefined`.\n     *\n     * @private\n     * @param {*} objValue The destination value.\n     * @param {*} srcValue The source value.\n     * @param {string} key The key of the property to assign.\n     * @param {Object} object The parent object of `objValue`.\n     * @returns {*} Returns the value to assign.\n     */\n    function customDefaultsAssignIn(objValue, srcValue, key, object) {\n      if (objValue === undefined ||\n          (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) {\n        return srcValue;\n      }\n      return objValue;\n    }\n\n    /**\n     * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source\n     * objects into destination objects that are passed thru.\n     *\n     * @private\n     * @param {*} objValue The destination value.\n     * @param {*} srcValue The source value.\n     * @param {string} key The key of the property to merge.\n     * @param {Object} object The parent object of `objValue`.\n     * @param {Object} source The parent object of `srcValue`.\n     * @param {Object} [stack] Tracks traversed source values and their merged\n     *  counterparts.\n     * @returns {*} Returns the value to assign.\n     */\n    function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {\n      if (isObject(objValue) && isObject(srcValue)) {\n        // Recursively merge objects and arrays (susceptible to call stack limits).\n        stack.set(srcValue, objValue);\n        baseMerge(objValue, srcValue, undefined, customDefaultsMerge, stack);\n        stack['delete'](srcValue);\n      }\n      return objValue;\n    }\n\n    /**\n     * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain\n     * objects.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @param {string} key The key of the property to inspect.\n     * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.\n     */\n    function customOmitClone(value) {\n      return isPlainObject(value) ? undefined : value;\n    }\n\n    /**\n     * A specialized version of `baseIsEqualDeep` for arrays with support for\n     * partial deep comparisons.\n     *\n     * @private\n     * @param {Array} array The array to compare.\n     * @param {Array} other The other array to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} stack Tracks traversed `array` and `other` objects.\n     * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n     */\n    function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n      var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n          arrLength = array.length,\n          othLength = other.length;\n\n      if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n        return false;\n      }\n      // Assume cyclic values are equal.\n      var stacked = stack.get(array);\n      if (stacked && stack.get(other)) {\n        return stacked == other;\n      }\n      var index = -1,\n          result = true,\n          seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n      stack.set(array, other);\n      stack.set(other, array);\n\n      // Ignore non-index properties.\n      while (++index < arrLength) {\n        var arrValue = array[index],\n            othValue = other[index];\n\n        if (customizer) {\n          var compared = isPartial\n            ? customizer(othValue, arrValue, index, other, array, stack)\n            : customizer(arrValue, othValue, index, array, other, stack);\n        }\n        if (compared !== undefined) {\n          if (compared) {\n            continue;\n          }\n          result = false;\n          break;\n        }\n        // Recursively compare arrays (susceptible to call stack limits).\n        if (seen) {\n          if (!arraySome(other, function(othValue, othIndex) {\n                if (!cacheHas(seen, othIndex) &&\n                    (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n                  return seen.push(othIndex);\n                }\n              })) {\n            result = false;\n            break;\n          }\n        } else if (!(\n              arrValue === othValue ||\n                equalFunc(arrValue, othValue, bitmask, customizer, stack)\n            )) {\n          result = false;\n          break;\n        }\n      }\n      stack['delete'](array);\n      stack['delete'](other);\n      return result;\n    }\n\n    /**\n     * A specialized version of `baseIsEqualDeep` for comparing objects of\n     * the same `toStringTag`.\n     *\n     * **Note:** This function only supports comparing values with tags of\n     * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {string} tag The `toStringTag` of the objects to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} stack Tracks traversed `object` and `other` objects.\n     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n     */\n    function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n      switch (tag) {\n        case dataViewTag:\n          if ((object.byteLength != other.byteLength) ||\n              (object.byteOffset != other.byteOffset)) {\n            return false;\n          }\n          object = object.buffer;\n          other = other.buffer;\n\n        case arrayBufferTag:\n          if ((object.byteLength != other.byteLength) ||\n              !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n            return false;\n          }\n          return true;\n\n        case boolTag:\n        case dateTag:\n        case numberTag:\n          // Coerce booleans to `1` or `0` and dates to milliseconds.\n          // Invalid dates are coerced to `NaN`.\n          return eq(+object, +other);\n\n        case errorTag:\n          return object.name == other.name && object.message == other.message;\n\n        case regexpTag:\n        case stringTag:\n          // Coerce regexes to strings and treat strings, primitives and objects,\n          // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n          // for more details.\n          return object == (other + '');\n\n        case mapTag:\n          var convert = mapToArray;\n\n        case setTag:\n          var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n          convert || (convert = setToArray);\n\n          if (object.size != other.size && !isPartial) {\n            return false;\n          }\n          // Assume cyclic values are equal.\n          var stacked = stack.get(object);\n          if (stacked) {\n            return stacked == other;\n          }\n          bitmask |= COMPARE_UNORDERED_FLAG;\n\n          // Recursively compare objects (susceptible to call stack limits).\n          stack.set(object, other);\n          var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n          stack['delete'](object);\n          return result;\n\n        case symbolTag:\n          if (symbolValueOf) {\n            return symbolValueOf.call(object) == symbolValueOf.call(other);\n          }\n      }\n      return false;\n    }\n\n    /**\n     * A specialized version of `baseIsEqualDeep` for objects with support for\n     * partial deep comparisons.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} stack Tracks traversed `object` and `other` objects.\n     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n     */\n    function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n      var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n          objProps = getAllKeys(object),\n          objLength = objProps.length,\n          othProps = getAllKeys(other),\n          othLength = othProps.length;\n\n      if (objLength != othLength && !isPartial) {\n        return false;\n      }\n      var index = objLength;\n      while (index--) {\n        var key = objProps[index];\n        if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n          return false;\n        }\n      }\n      // Assume cyclic values are equal.\n      var stacked = stack.get(object);\n      if (stacked && stack.get(other)) {\n        return stacked == other;\n      }\n      var result = true;\n      stack.set(object, other);\n      stack.set(other, object);\n\n      var skipCtor = isPartial;\n      while (++index < objLength) {\n        key = objProps[index];\n        var objValue = object[key],\n            othValue = other[key];\n\n        if (customizer) {\n          var compared = isPartial\n            ? customizer(othValue, objValue, key, other, object, stack)\n            : customizer(objValue, othValue, key, object, other, stack);\n        }\n        // Recursively compare objects (susceptible to call stack limits).\n        if (!(compared === undefined\n              ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n              : compared\n            )) {\n          result = false;\n          break;\n        }\n        skipCtor || (skipCtor = key == 'constructor');\n      }\n      if (result && !skipCtor) {\n        var objCtor = object.constructor,\n            othCtor = other.constructor;\n\n        // Non `Object` object instances with different constructors are not equal.\n        if (objCtor != othCtor &&\n            ('constructor' in object && 'constructor' in other) &&\n            !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n              typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n          result = false;\n        }\n      }\n      stack['delete'](object);\n      stack['delete'](other);\n      return result;\n    }\n\n    /**\n     * A specialized version of `baseRest` which flattens the rest array.\n     *\n     * @private\n     * @param {Function} func The function to apply a rest parameter to.\n     * @returns {Function} Returns the new function.\n     */\n    function flatRest(func) {\n      return setToString(overRest(func, undefined, flatten), func + '');\n    }\n\n    /**\n     * Creates an array of own enumerable property names and symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names and symbols.\n     */\n    function getAllKeys(object) {\n      return baseGetAllKeys(object, keys, getSymbols);\n    }\n\n    /**\n     * Creates an array of own and inherited enumerable property names and\n     * symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names and symbols.\n     */\n    function getAllKeysIn(object) {\n      return baseGetAllKeys(object, keysIn, getSymbolsIn);\n    }\n\n    /**\n     * Gets metadata for `func`.\n     *\n     * @private\n     * @param {Function} func The function to query.\n     * @returns {*} Returns the metadata for `func`.\n     */\n    var getData = !metaMap ? noop : function(func) {\n      return metaMap.get(func);\n    };\n\n    /**\n     * Gets the name of `func`.\n     *\n     * @private\n     * @param {Function} func The function to query.\n     * @returns {string} Returns the function name.\n     */\n    function getFuncName(func) {\n      var result = (func.name + ''),\n          array = realNames[result],\n          length = hasOwnProperty.call(realNames, result) ? array.length : 0;\n\n      while (length--) {\n        var data = array[length],\n            otherFunc = data.func;\n        if (otherFunc == null || otherFunc == func) {\n          return data.name;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Gets the argument placeholder value for `func`.\n     *\n     * @private\n     * @param {Function} func The function to inspect.\n     * @returns {*} Returns the placeholder value.\n     */\n    function getHolder(func) {\n      var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func;\n      return object.placeholder;\n    }\n\n    /**\n     * Gets the appropriate \"iteratee\" function. If `_.iteratee` is customized,\n     * this function returns the custom method, otherwise it returns `baseIteratee`.\n     * If arguments are provided, the chosen function is invoked with them and\n     * its result is returned.\n     *\n     * @private\n     * @param {*} [value] The value to convert to an iteratee.\n     * @param {number} [arity] The arity of the created iteratee.\n     * @returns {Function} Returns the chosen function or its result.\n     */\n    function getIteratee() {\n      var result = lodash.iteratee || iteratee;\n      result = result === iteratee ? baseIteratee : result;\n      return arguments.length ? result(arguments[0], arguments[1]) : result;\n    }\n\n    /**\n     * Gets the data for `map`.\n     *\n     * @private\n     * @param {Object} map The map to query.\n     * @param {string} key The reference key.\n     * @returns {*} Returns the map data.\n     */\n    function getMapData(map, key) {\n      var data = map.__data__;\n      return isKeyable(key)\n        ? data[typeof key == 'string' ? 'string' : 'hash']\n        : data.map;\n    }\n\n    /**\n     * Gets the property names, values, and compare flags of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the match data of `object`.\n     */\n    function getMatchData(object) {\n      var result = keys(object),\n          length = result.length;\n\n      while (length--) {\n        var key = result[length],\n            value = object[key];\n\n        result[length] = [key, value, isStrictComparable(value)];\n      }\n      return result;\n    }\n\n    /**\n     * Gets the native function at `key` of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {string} key The key of the method to get.\n     * @returns {*} Returns the function if it's native, else `undefined`.\n     */\n    function getNative(object, key) {\n      var value = getValue(object, key);\n      return baseIsNative(value) ? value : undefined;\n    }\n\n    /**\n     * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n     *\n     * @private\n     * @param {*} value The value to query.\n     * @returns {string} Returns the raw `toStringTag`.\n     */\n    function getRawTag(value) {\n      var isOwn = hasOwnProperty.call(value, symToStringTag),\n          tag = value[symToStringTag];\n\n      try {\n        value[symToStringTag] = undefined;\n        var unmasked = true;\n      } catch (e) {}\n\n      var result = nativeObjectToString.call(value);\n      if (unmasked) {\n        if (isOwn) {\n          value[symToStringTag] = tag;\n        } else {\n          delete value[symToStringTag];\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Creates an array of the own enumerable symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of symbols.\n     */\n    var getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n      if (object == null) {\n        return [];\n      }\n      object = Object(object);\n      return arrayFilter(nativeGetSymbols(object), function(symbol) {\n        return propertyIsEnumerable.call(object, symbol);\n      });\n    };\n\n    /**\n     * Creates an array of the own and inherited enumerable symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of symbols.\n     */\n    var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {\n      var result = [];\n      while (object) {\n        arrayPush(result, getSymbols(object));\n        object = getPrototype(object);\n      }\n      return result;\n    };\n\n    /**\n     * Gets the `toStringTag` of `value`.\n     *\n     * @private\n     * @param {*} value The value to query.\n     * @returns {string} Returns the `toStringTag`.\n     */\n    var getTag = baseGetTag;\n\n    // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\n    if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n        (Map && getTag(new Map) != mapTag) ||\n        (Promise && getTag(Promise.resolve()) != promiseTag) ||\n        (Set && getTag(new Set) != setTag) ||\n        (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n      getTag = function(value) {\n        var result = baseGetTag(value),\n            Ctor = result == objectTag ? value.constructor : undefined,\n            ctorString = Ctor ? toSource(Ctor) : '';\n\n        if (ctorString) {\n          switch (ctorString) {\n            case dataViewCtorString: return dataViewTag;\n            case mapCtorString: return mapTag;\n            case promiseCtorString: return promiseTag;\n            case setCtorString: return setTag;\n            case weakMapCtorString: return weakMapTag;\n          }\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Gets the view, applying any `transforms` to the `start` and `end` positions.\n     *\n     * @private\n     * @param {number} start The start of the view.\n     * @param {number} end The end of the view.\n     * @param {Array} transforms The transformations to apply to the view.\n     * @returns {Object} Returns an object containing the `start` and `end`\n     *  positions of the view.\n     */\n    function getView(start, end, transforms) {\n      var index = -1,\n          length = transforms.length;\n\n      while (++index < length) {\n        var data = transforms[index],\n            size = data.size;\n\n        switch (data.type) {\n          case 'drop':      start += size; break;\n          case 'dropRight': end -= size; break;\n          case 'take':      end = nativeMin(end, start + size); break;\n          case 'takeRight': start = nativeMax(start, end - size); break;\n        }\n      }\n      return { 'start': start, 'end': end };\n    }\n\n    /**\n     * Extracts wrapper details from the `source` body comment.\n     *\n     * @private\n     * @param {string} source The source to inspect.\n     * @returns {Array} Returns the wrapper details.\n     */\n    function getWrapDetails(source) {\n      var match = source.match(reWrapDetails);\n      return match ? match[1].split(reSplitDetails) : [];\n    }\n\n    /**\n     * Checks if `path` exists on `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path to check.\n     * @param {Function} hasFunc The function to check properties.\n     * @returns {boolean} Returns `true` if `path` exists, else `false`.\n     */\n    function hasPath(object, path, hasFunc) {\n      path = castPath(path, object);\n\n      var index = -1,\n          length = path.length,\n          result = false;\n\n      while (++index < length) {\n        var key = toKey(path[index]);\n        if (!(result = object != null && hasFunc(object, key))) {\n          break;\n        }\n        object = object[key];\n      }\n      if (result || ++index != length) {\n        return result;\n      }\n      length = object == null ? 0 : object.length;\n      return !!length && isLength(length) && isIndex(key, length) &&\n        (isArray(object) || isArguments(object));\n    }\n\n    /**\n     * Initializes an array clone.\n     *\n     * @private\n     * @param {Array} array The array to clone.\n     * @returns {Array} Returns the initialized clone.\n     */\n    function initCloneArray(array) {\n      var length = array.length,\n          result = array.constructor(length);\n\n      // Add properties assigned by `RegExp#exec`.\n      if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n        result.index = array.index;\n        result.input = array.input;\n      }\n      return result;\n    }\n\n    /**\n     * Initializes an object clone.\n     *\n     * @private\n     * @param {Object} object The object to clone.\n     * @returns {Object} Returns the initialized clone.\n     */\n    function initCloneObject(object) {\n      return (typeof object.constructor == 'function' && !isPrototype(object))\n        ? baseCreate(getPrototype(object))\n        : {};\n    }\n\n    /**\n     * Initializes an object clone based on its `toStringTag`.\n     *\n     * **Note:** This function only supports cloning values with tags of\n     * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n     *\n     * @private\n     * @param {Object} object The object to clone.\n     * @param {string} tag The `toStringTag` of the object to clone.\n     * @param {Function} cloneFunc The function to clone values.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the initialized clone.\n     */\n    function initCloneByTag(object, tag, cloneFunc, isDeep) {\n      var Ctor = object.constructor;\n      switch (tag) {\n        case arrayBufferTag:\n          return cloneArrayBuffer(object);\n\n        case boolTag:\n        case dateTag:\n          return new Ctor(+object);\n\n        case dataViewTag:\n          return cloneDataView(object, isDeep);\n\n        case float32Tag: case float64Tag:\n        case int8Tag: case int16Tag: case int32Tag:\n        case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n          return cloneTypedArray(object, isDeep);\n\n        case mapTag:\n          return cloneMap(object, isDeep, cloneFunc);\n\n        case numberTag:\n        case stringTag:\n          return new Ctor(object);\n\n        case regexpTag:\n          return cloneRegExp(object);\n\n        case setTag:\n          return cloneSet(object, isDeep, cloneFunc);\n\n        case symbolTag:\n          return cloneSymbol(object);\n      }\n    }\n\n    /**\n     * Inserts wrapper `details` in a comment at the top of the `source` body.\n     *\n     * @private\n     * @param {string} source The source to modify.\n     * @returns {Array} details The details to insert.\n     * @returns {string} Returns the modified source.\n     */\n    function insertWrapDetails(source, details) {\n      var length = details.length;\n      if (!length) {\n        return source;\n      }\n      var lastIndex = length - 1;\n      details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex];\n      details = details.join(length > 2 ? ', ' : ' ');\n      return source.replace(reWrapComment, '{\\n/* [wrapped with ' + details + '] */\\n');\n    }\n\n    /**\n     * Checks if `value` is a flattenable `arguments` object or array.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.\n     */\n    function isFlattenable(value) {\n      return isArray(value) || isArguments(value) ||\n        !!(spreadableSymbol && value && value[spreadableSymbol]);\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     */\n    function 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     */\n    function 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 a property name and not a property path.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @param {Object} [object] The object to query keys on.\n     * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n     */\n    function isKey(value, object) {\n      if (isArray(value)) {\n        return false;\n      }\n      var type = typeof value;\n      if (type == 'number' || type == 'symbol' || type == 'boolean' ||\n          value == null || isSymbol(value)) {\n        return true;\n      }\n      return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||\n        (object != null && value in Object(object));\n    }\n\n    /**\n     * Checks if `value` is suitable for use as unique object key.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n     */\n    function isKeyable(value) {\n      var type = typeof value;\n      return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n        ? (value !== '__proto__')\n        : (value === null);\n    }\n\n    /**\n     * Checks if `func` has a lazy counterpart.\n     *\n     * @private\n     * @param {Function} func The function to check.\n     * @returns {boolean} Returns `true` if `func` has a lazy counterpart,\n     *  else `false`.\n     */\n    function isLaziable(func) {\n      var funcName = getFuncName(func),\n          other = lodash[funcName];\n\n      if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) {\n        return false;\n      }\n      if (func === other) {\n        return true;\n      }\n      var data = getData(other);\n      return !!data && func === data[0];\n    }\n\n    /**\n     * Checks if `func` has its source masked.\n     *\n     * @private\n     * @param {Function} func The function to check.\n     * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n     */\n    function isMasked(func) {\n      return !!maskSrcKey && (maskSrcKey in func);\n    }\n\n    /**\n     * Checks if `func` is capable of being masked.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `func` is maskable, else `false`.\n     */\n    var isMaskable = coreJsData ? isFunction : stubFalse;\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     */\n    function 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     * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` if suitable for strict\n     *  equality comparisons, else `false`.\n     */\n    function isStrictComparable(value) {\n      return value === value && !isObject(value);\n    }\n\n    /**\n     * A specialized version of `matchesProperty` for source values suitable\n     * for strict equality comparisons, i.e. `===`.\n     *\n     * @private\n     * @param {string} key The key of the property to get.\n     * @param {*} srcValue The value to match.\n     * @returns {Function} Returns the new spec function.\n     */\n    function matchesStrictComparable(key, srcValue) {\n      return function(object) {\n        if (object == null) {\n          return false;\n        }\n        return object[key] === srcValue &&\n          (srcValue !== undefined || (key in Object(object)));\n      };\n    }\n\n    /**\n     * A specialized version of `_.memoize` which clears the memoized function's\n     * cache when it exceeds `MAX_MEMOIZE_SIZE`.\n     *\n     * @private\n     * @param {Function} func The function to have its output memoized.\n     * @returns {Function} Returns the new memoized function.\n     */\n    function memoizeCapped(func) {\n      var result = memoize(func, function(key) {\n        if (cache.size === MAX_MEMOIZE_SIZE) {\n          cache.clear();\n        }\n        return key;\n      });\n\n      var cache = result.cache;\n      return result;\n    }\n\n    /**\n     * Merges the function metadata of `source` into `data`.\n     *\n     * Merging metadata reduces the number of wrappers used to invoke a function.\n     * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`\n     * may be applied regardless of execution order. Methods like `_.ary` and\n     * `_.rearg` modify function arguments, making the order in which they are\n     * executed important, preventing the merging of metadata. However, we make\n     * an exception for a safe combined case where curried functions have `_.ary`\n     * and or `_.rearg` applied.\n     *\n     * @private\n     * @param {Array} data The destination metadata.\n     * @param {Array} source The source metadata.\n     * @returns {Array} Returns `data`.\n     */\n    function mergeData(data, source) {\n      var bitmask = data[1],\n          srcBitmask = source[1],\n          newBitmask = bitmask | srcBitmask,\n          isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);\n\n      var isCombo =\n        ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) ||\n        ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) ||\n        ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));\n\n      // Exit early if metadata can't be merged.\n      if (!(isCommon || isCombo)) {\n        return data;\n      }\n      // Use source `thisArg` if available.\n      if (srcBitmask & WRAP_BIND_FLAG) {\n        data[2] = source[2];\n        // Set when currying a bound function.\n        newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;\n      }\n      // Compose partial arguments.\n      var value = source[3];\n      if (value) {\n        var partials = data[3];\n        data[3] = partials ? composeArgs(partials, value, source[4]) : value;\n        data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];\n      }\n      // Compose partial right arguments.\n      value = source[5];\n      if (value) {\n        partials = data[5];\n        data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;\n        data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];\n      }\n      // Use source `argPos` if available.\n      value = source[7];\n      if (value) {\n        data[7] = value;\n      }\n      // Use source `ary` if it's smaller.\n      if (srcBitmask & WRAP_ARY_FLAG) {\n        data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);\n      }\n      // Use source `arity` if one is not provided.\n      if (data[9] == null) {\n        data[9] = source[9];\n      }\n      // Use source `func` and merge bitmasks.\n      data[0] = source[0];\n      data[1] = newBitmask;\n\n      return data;\n    }\n\n    /**\n     * This function is like\n     * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n     * except that it includes inherited enumerable properties.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     */\n    function nativeKeysIn(object) {\n      var result = [];\n      if (object != null) {\n        for (var key in Object(object)) {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Converts `value` to a string using `Object.prototype.toString`.\n     *\n     * @private\n     * @param {*} value The value to convert.\n     * @returns {string} Returns the converted string.\n     */\n    function objectToString(value) {\n      return nativeObjectToString.call(value);\n    }\n\n    /**\n     * A specialized version of `baseRest` which transforms the rest array.\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     * @param {Function} transform The rest array transform.\n     * @returns {Function} Returns the new function.\n     */\n    function overRest(func, start, transform) {\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] = transform(array);\n        return apply(func, this, otherArgs);\n      };\n    }\n\n    /**\n     * Gets the parent value at `path` of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array} path The path to get the parent value of.\n     * @returns {*} Returns the parent value.\n     */\n    function parent(object, path) {\n      return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));\n    }\n\n    /**\n     * Reorder `array` according to the specified indexes where the element at\n     * the first index is assigned as the first element, the element at\n     * the second index is assigned as the second element, and so on.\n     *\n     * @private\n     * @param {Array} array The array to reorder.\n     * @param {Array} indexes The arranged array indexes.\n     * @returns {Array} Returns `array`.\n     */\n    function reorder(array, indexes) {\n      var arrLength = array.length,\n          length = nativeMin(indexes.length, arrLength),\n          oldArray = copyArray(array);\n\n      while (length--) {\n        var index = indexes[length];\n        array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined;\n      }\n      return array;\n    }\n\n    /**\n     * Sets metadata for `func`.\n     *\n     * **Note:** If this function becomes hot, i.e. is invoked a lot in a short\n     * period of time, it will trip its breaker and transition to an identity\n     * function to avoid garbage collection pauses in V8. See\n     * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070)\n     * for more details.\n     *\n     * @private\n     * @param {Function} func The function to associate metadata with.\n     * @param {*} data The metadata.\n     * @returns {Function} Returns `func`.\n     */\n    var setData = shortOut(baseSetData);\n\n    /**\n     * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout).\n     *\n     * @private\n     * @param {Function} func The function to delay.\n     * @param {number} wait The number of milliseconds to delay invocation.\n     * @returns {number|Object} Returns the timer id or timeout object.\n     */\n    var setTimeout = ctxSetTimeout || function(func, wait) {\n      return root.setTimeout(func, wait);\n    };\n\n    /**\n     * Sets the `toString` method of `func` to return `string`.\n     *\n     * @private\n     * @param {Function} func The function to modify.\n     * @param {Function} string The `toString` result.\n     * @returns {Function} Returns `func`.\n     */\n    var setToString = shortOut(baseSetToString);\n\n    /**\n     * Sets the `toString` method of `wrapper` to mimic the source of `reference`\n     * with wrapper details in a comment at the top of the source body.\n     *\n     * @private\n     * @param {Function} wrapper The function to modify.\n     * @param {Function} reference The reference function.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @returns {Function} Returns `wrapper`.\n     */\n    function setWrapToString(wrapper, reference, bitmask) {\n      var source = (reference + '');\n      return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));\n    }\n\n    /**\n     * Creates a function that'll short out and invoke `identity` instead\n     * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n     * milliseconds.\n     *\n     * @private\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new shortable function.\n     */\n    function shortOut(func) {\n      var count = 0,\n          lastCalled = 0;\n\n      return function() {\n        var stamp = nativeNow(),\n            remaining = HOT_SPAN - (stamp - lastCalled);\n\n        lastCalled = stamp;\n        if (remaining > 0) {\n          if (++count >= HOT_COUNT) {\n            return arguments[0];\n          }\n        } else {\n          count = 0;\n        }\n        return func.apply(undefined, arguments);\n      };\n    }\n\n    /**\n     * A specialized version of `_.shuffle` which mutates and sets the size of `array`.\n     *\n     * @private\n     * @param {Array} array The array to shuffle.\n     * @param {number} [size=array.length] The size of `array`.\n     * @returns {Array} Returns `array`.\n     */\n    function shuffleSelf(array, size) {\n      var index = -1,\n          length = array.length,\n          lastIndex = length - 1;\n\n      size = size === undefined ? length : size;\n      while (++index < size) {\n        var rand = baseRandom(index, lastIndex),\n            value = array[rand];\n\n        array[rand] = array[index];\n        array[index] = value;\n      }\n      array.length = size;\n      return array;\n    }\n\n    /**\n     * Converts `string` to a property path array.\n     *\n     * @private\n     * @param {string} string The string to convert.\n     * @returns {Array} Returns the property path array.\n     */\n    var stringToPath = memoizeCapped(function(string) {\n      var result = [];\n      if (reLeadingDot.test(string)) {\n        result.push('');\n      }\n      string.replace(rePropName, function(match, number, quote, string) {\n        result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));\n      });\n      return result;\n    });\n\n    /**\n     * Converts `value` to a string key if it's not a string or symbol.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @returns {string|symbol} Returns the key.\n     */\n    function toKey(value) {\n      if (typeof value == 'string' || isSymbol(value)) {\n        return value;\n      }\n      var result = (value + '');\n      return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n    }\n\n    /**\n     * Converts `func` to its source code.\n     *\n     * @private\n     * @param {Function} func The function to convert.\n     * @returns {string} Returns the source code.\n     */\n    function toSource(func) {\n      if (func != null) {\n        try {\n          return funcToString.call(func);\n        } catch (e) {}\n        try {\n          return (func + '');\n        } catch (e) {}\n      }\n      return '';\n    }\n\n    /**\n     * Updates wrapper `details` based on `bitmask` flags.\n     *\n     * @private\n     * @returns {Array} details The details to modify.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @returns {Array} Returns `details`.\n     */\n    function updateWrapDetails(details, bitmask) {\n      arrayEach(wrapFlags, function(pair) {\n        var value = '_.' + pair[0];\n        if ((bitmask & pair[1]) && !arrayIncludes(details, value)) {\n          details.push(value);\n        }\n      });\n      return details.sort();\n    }\n\n    /**\n     * Creates a clone of `wrapper`.\n     *\n     * @private\n     * @param {Object} wrapper The wrapper to clone.\n     * @returns {Object} Returns the cloned wrapper.\n     */\n    function wrapperClone(wrapper) {\n      if (wrapper instanceof LazyWrapper) {\n        return wrapper.clone();\n      }\n      var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);\n      result.__actions__ = copyArray(wrapper.__actions__);\n      result.__index__  = wrapper.__index__;\n      result.__values__ = wrapper.__values__;\n      return result;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an array of elements split into groups the length of `size`.\n     * If `array` can't be split evenly, the final chunk will be the remaining\n     * elements.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to process.\n     * @param {number} [size=1] The length of each chunk\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the new array of chunks.\n     * @example\n     *\n     * _.chunk(['a', 'b', 'c', 'd'], 2);\n     * // => [['a', 'b'], ['c', 'd']]\n     *\n     * _.chunk(['a', 'b', 'c', 'd'], 3);\n     * // => [['a', 'b', 'c'], ['d']]\n     */\n    function chunk(array, size, guard) {\n      if ((guard ? isIterateeCall(array, size, guard) : size === undefined)) {\n        size = 1;\n      } else {\n        size = nativeMax(toInteger(size), 0);\n      }\n      var length = array == null ? 0 : array.length;\n      if (!length || size < 1) {\n        return [];\n      }\n      var index = 0,\n          resIndex = 0,\n          result = Array(nativeCeil(length / size));\n\n      while (index < length) {\n        result[resIndex++] = baseSlice(array, index, (index += size));\n      }\n      return result;\n    }\n\n    /**\n     * Creates an array with all falsey values removed. The values `false`, `null`,\n     * `0`, `\"\"`, `undefined`, and `NaN` are falsey.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to compact.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * _.compact([0, 1, false, 2, '', 3]);\n     * // => [1, 2, 3]\n     */\n    function compact(array) {\n      var index = -1,\n          length = array == null ? 0 : array.length,\n          resIndex = 0,\n          result = [];\n\n      while (++index < length) {\n        var value = array[index];\n        if (value) {\n          result[resIndex++] = value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Creates a new array concatenating `array` with any additional arrays\n     * and/or values.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to concatenate.\n     * @param {...*} [values] The values to concatenate.\n     * @returns {Array} Returns the new concatenated array.\n     * @example\n     *\n     * var array = [1];\n     * var other = _.concat(array, 2, [3], [[4]]);\n     *\n     * console.log(other);\n     * // => [1, 2, 3, [4]]\n     *\n     * console.log(array);\n     * // => [1]\n     */\n    function concat() {\n      var length = arguments.length;\n      if (!length) {\n        return [];\n      }\n      var args = Array(length - 1),\n          array = arguments[0],\n          index = length;\n\n      while (index--) {\n        args[index - 1] = arguments[index];\n      }\n      return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));\n    }\n\n    /**\n     * Creates an array of `array` values not included in the other given arrays\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons. The order and references of result values are\n     * determined by the first array.\n     *\n     * **Note:** Unlike `_.pullAll`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...Array} [values] The values to exclude.\n     * @returns {Array} Returns the new array of filtered values.\n     * @see _.without, _.xor\n     * @example\n     *\n     * _.difference([2, 1], [2, 3]);\n     * // => [1]\n     */\n    var difference = baseRest(function(array, values) {\n      return isArrayLikeObject(array)\n        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))\n        : [];\n    });\n\n    /**\n     * This method is like `_.difference` except that it accepts `iteratee` which\n     * is invoked for each element of `array` and `values` to generate the criterion\n     * by which they're compared. The order and references of result values are\n     * determined by the first array. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * **Note:** Unlike `_.pullAllBy`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...Array} [values] The values to exclude.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n     * // => [1.2]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');\n     * // => [{ 'x': 2 }]\n     */\n    var differenceBy = baseRest(function(array, values) {\n      var iteratee = last(values);\n      if (isArrayLikeObject(iteratee)) {\n        iteratee = undefined;\n      }\n      return isArrayLikeObject(array)\n        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), getIteratee(iteratee, 2))\n        : [];\n    });\n\n    /**\n     * This method is like `_.difference` except that it accepts `comparator`\n     * which is invoked to compare elements of `array` to `values`. The order and\n     * references of result values are determined by the first array. The comparator\n     * is invoked with two arguments: (arrVal, othVal).\n     *\n     * **Note:** Unlike `_.pullAllWith`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...Array} [values] The values to exclude.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     *\n     * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual);\n     * // => [{ 'x': 2, 'y': 1 }]\n     */\n    var differenceWith = baseRest(function(array, values) {\n      var comparator = last(values);\n      if (isArrayLikeObject(comparator)) {\n        comparator = undefined;\n      }\n      return isArrayLikeObject(array)\n        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined, comparator)\n        : [];\n    });\n\n    /**\n     * Creates a slice of `array` with `n` elements dropped from the beginning.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.5.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to drop.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.drop([1, 2, 3]);\n     * // => [2, 3]\n     *\n     * _.drop([1, 2, 3], 2);\n     * // => [3]\n     *\n     * _.drop([1, 2, 3], 5);\n     * // => []\n     *\n     * _.drop([1, 2, 3], 0);\n     * // => [1, 2, 3]\n     */\n    function drop(array, n, guard) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      n = (guard || n === undefined) ? 1 : toInteger(n);\n      return baseSlice(array, n < 0 ? 0 : n, length);\n    }\n\n    /**\n     * Creates a slice of `array` with `n` elements dropped from the end.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to drop.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.dropRight([1, 2, 3]);\n     * // => [1, 2]\n     *\n     * _.dropRight([1, 2, 3], 2);\n     * // => [1]\n     *\n     * _.dropRight([1, 2, 3], 5);\n     * // => []\n     *\n     * _.dropRight([1, 2, 3], 0);\n     * // => [1, 2, 3]\n     */\n    function dropRight(array, n, guard) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      n = (guard || n === undefined) ? 1 : toInteger(n);\n      n = length - n;\n      return baseSlice(array, 0, n < 0 ? 0 : n);\n    }\n\n    /**\n     * Creates a slice of `array` excluding elements dropped from the end.\n     * Elements are dropped until `predicate` returns falsey. The predicate is\n     * invoked with three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': true },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': false }\n     * ];\n     *\n     * _.dropRightWhile(users, function(o) { return !o.active; });\n     * // => objects for ['barney']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false });\n     * // => objects for ['barney', 'fred']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.dropRightWhile(users, ['active', false]);\n     * // => objects for ['barney']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.dropRightWhile(users, 'active');\n     * // => objects for ['barney', 'fred', 'pebbles']\n     */\n    function dropRightWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3), true, true)\n        : [];\n    }\n\n    /**\n     * Creates a slice of `array` excluding elements dropped from the beginning.\n     * Elements are dropped until `predicate` returns falsey. The predicate is\n     * invoked with three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': false },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': true }\n     * ];\n     *\n     * _.dropWhile(users, function(o) { return !o.active; });\n     * // => objects for ['pebbles']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.dropWhile(users, { 'user': 'barney', 'active': false });\n     * // => objects for ['fred', 'pebbles']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.dropWhile(users, ['active', false]);\n     * // => objects for ['pebbles']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.dropWhile(users, 'active');\n     * // => objects for ['barney', 'fred', 'pebbles']\n     */\n    function dropWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3), true)\n        : [];\n    }\n\n    /**\n     * Fills elements of `array` with `value` from `start` up to, but not\n     * including, `end`.\n     *\n     * **Note:** This method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.2.0\n     * @category Array\n     * @param {Array} array The array to fill.\n     * @param {*} value The value to fill `array` with.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [1, 2, 3];\n     *\n     * _.fill(array, 'a');\n     * console.log(array);\n     * // => ['a', 'a', 'a']\n     *\n     * _.fill(Array(3), 2);\n     * // => [2, 2, 2]\n     *\n     * _.fill([4, 6, 8, 10], '*', 1, 3);\n     * // => [4, '*', '*', 10]\n     */\n    function fill(array, value, start, end) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {\n        start = 0;\n        end = length;\n      }\n      return baseFill(array, value, start, end);\n    }\n\n    /**\n     * This method is like `_.find` except that it returns the index of the first\n     * element `predicate` returns truthy for instead of the element itself.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @returns {number} Returns the index of the found element, else `-1`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': false },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': true }\n     * ];\n     *\n     * _.findIndex(users, function(o) { return o.user == 'barney'; });\n     * // => 0\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findIndex(users, { 'user': 'fred', 'active': false });\n     * // => 1\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findIndex(users, ['active', false]);\n     * // => 0\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findIndex(users, 'active');\n     * // => 2\n     */\n    function findIndex(array, predicate, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = fromIndex == null ? 0 : toInteger(fromIndex);\n      if (index < 0) {\n        index = nativeMax(length + index, 0);\n      }\n      return baseFindIndex(array, getIteratee(predicate, 3), index);\n    }\n\n    /**\n     * This method is like `_.findIndex` except that it iterates over elements\n     * of `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=array.length-1] The index to search from.\n     * @returns {number} Returns the index of the found element, else `-1`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': true },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': false }\n     * ];\n     *\n     * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; });\n     * // => 2\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findLastIndex(users, { 'user': 'barney', 'active': true });\n     * // => 0\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findLastIndex(users, ['active', false]);\n     * // => 2\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findLastIndex(users, 'active');\n     * // => 0\n     */\n    function findLastIndex(array, predicate, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = length - 1;\n      if (fromIndex !== undefined) {\n        index = toInteger(fromIndex);\n        index = fromIndex < 0\n          ? nativeMax(length + index, 0)\n          : nativeMin(index, length - 1);\n      }\n      return baseFindIndex(array, getIteratee(predicate, 3), index, true);\n    }\n\n    /**\n     * Flattens `array` a single level deep.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to flatten.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * _.flatten([1, [2, [3, [4]], 5]]);\n     * // => [1, 2, [3, [4]], 5]\n     */\n    function flatten(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseFlatten(array, 1) : [];\n    }\n\n    /**\n     * Recursively flattens `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to flatten.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * _.flattenDeep([1, [2, [3, [4]], 5]]);\n     * // => [1, 2, 3, 4, 5]\n     */\n    function flattenDeep(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseFlatten(array, INFINITY) : [];\n    }\n\n    /**\n     * Recursively flatten `array` up to `depth` times.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.4.0\n     * @category Array\n     * @param {Array} array The array to flatten.\n     * @param {number} [depth=1] The maximum recursion depth.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * var array = [1, [2, [3, [4]], 5]];\n     *\n     * _.flattenDepth(array, 1);\n     * // => [1, 2, [3, [4]], 5]\n     *\n     * _.flattenDepth(array, 2);\n     * // => [1, 2, 3, [4], 5]\n     */\n    function flattenDepth(array, depth) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      depth = depth === undefined ? 1 : toInteger(depth);\n      return baseFlatten(array, depth);\n    }\n\n    /**\n     * The inverse of `_.toPairs`; this method returns an object composed\n     * from key-value `pairs`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} pairs The key-value pairs.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * _.fromPairs([['a', 1], ['b', 2]]);\n     * // => { 'a': 1, 'b': 2 }\n     */\n    function fromPairs(pairs) {\n      var index = -1,\n          length = pairs == null ? 0 : pairs.length,\n          result = {};\n\n      while (++index < length) {\n        var pair = pairs[index];\n        result[pair[0]] = pair[1];\n      }\n      return result;\n    }\n\n    /**\n     * Gets the first element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @alias first\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {*} Returns the first element of `array`.\n     * @example\n     *\n     * _.head([1, 2, 3]);\n     * // => 1\n     *\n     * _.head([]);\n     * // => undefined\n     */\n    function head(array) {\n      return (array && array.length) ? array[0] : undefined;\n    }\n\n    /**\n     * Gets the index at which the first occurrence of `value` is found in `array`\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons. If `fromIndex` is negative, it's used as the\n     * offset from the end of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.indexOf([1, 2, 1, 2], 2);\n     * // => 1\n     *\n     * // Search from the `fromIndex`.\n     * _.indexOf([1, 2, 1, 2], 2, 2);\n     * // => 3\n     */\n    function indexOf(array, value, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = fromIndex == null ? 0 : toInteger(fromIndex);\n      if (index < 0) {\n        index = nativeMax(length + index, 0);\n      }\n      return baseIndexOf(array, value, index);\n    }\n\n    /**\n     * Gets all but the last element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.initial([1, 2, 3]);\n     * // => [1, 2]\n     */\n    function initial(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseSlice(array, 0, -1) : [];\n    }\n\n    /**\n     * Creates an array of unique values that are included in all given arrays\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons. The order and references of result values are\n     * determined by the first array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @returns {Array} Returns the new array of intersecting values.\n     * @example\n     *\n     * _.intersection([2, 1], [2, 3]);\n     * // => [2]\n     */\n    var intersection = baseRest(function(arrays) {\n      var mapped = arrayMap(arrays, castArrayLikeObject);\n      return (mapped.length && mapped[0] === arrays[0])\n        ? baseIntersection(mapped)\n        : [];\n    });\n\n    /**\n     * This method is like `_.intersection` except that it accepts `iteratee`\n     * which is invoked for each element of each `arrays` to generate the criterion\n     * by which they're compared. The order and references of result values are\n     * determined by the first array. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of intersecting values.\n     * @example\n     *\n     * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n     * // => [2.1]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 1 }]\n     */\n    var intersectionBy = baseRest(function(arrays) {\n      var iteratee = last(arrays),\n          mapped = arrayMap(arrays, castArrayLikeObject);\n\n      if (iteratee === last(mapped)) {\n        iteratee = undefined;\n      } else {\n        mapped.pop();\n      }\n      return (mapped.length && mapped[0] === arrays[0])\n        ? baseIntersection(mapped, getIteratee(iteratee, 2))\n        : [];\n    });\n\n    /**\n     * This method is like `_.intersection` except that it accepts `comparator`\n     * which is invoked to compare elements of `arrays`. The order and references\n     * of result values are determined by the first array. The comparator is\n     * invoked with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of intersecting values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.intersectionWith(objects, others, _.isEqual);\n     * // => [{ 'x': 1, 'y': 2 }]\n     */\n    var intersectionWith = baseRest(function(arrays) {\n      var comparator = last(arrays),\n          mapped = arrayMap(arrays, castArrayLikeObject);\n\n      comparator = typeof comparator == 'function' ? comparator : undefined;\n      if (comparator) {\n        mapped.pop();\n      }\n      return (mapped.length && mapped[0] === arrays[0])\n        ? baseIntersection(mapped, undefined, comparator)\n        : [];\n    });\n\n    /**\n     * Converts all elements in `array` into a string separated by `separator`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to convert.\n     * @param {string} [separator=','] The element separator.\n     * @returns {string} Returns the joined string.\n     * @example\n     *\n     * _.join(['a', 'b', 'c'], '~');\n     * // => 'a~b~c'\n     */\n    function join(array, separator) {\n      return array == null ? '' : nativeJoin.call(array, separator);\n    }\n\n    /**\n     * Gets the last element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {*} Returns the last element of `array`.\n     * @example\n     *\n     * _.last([1, 2, 3]);\n     * // => 3\n     */\n    function last(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? array[length - 1] : undefined;\n    }\n\n    /**\n     * This method is like `_.indexOf` except that it iterates over elements of\n     * `array` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @param {number} [fromIndex=array.length-1] The index to search from.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.lastIndexOf([1, 2, 1, 2], 2);\n     * // => 3\n     *\n     * // Search from the `fromIndex`.\n     * _.lastIndexOf([1, 2, 1, 2], 2, 2);\n     * // => 1\n     */\n    function lastIndexOf(array, value, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = length;\n      if (fromIndex !== undefined) {\n        index = toInteger(fromIndex);\n        index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);\n      }\n      return value === value\n        ? strictLastIndexOf(array, value, index)\n        : baseFindIndex(array, baseIsNaN, index, true);\n    }\n\n    /**\n     * Gets the element at index `n` of `array`. If `n` is negative, the nth\n     * element from the end is returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.11.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=0] The index of the element to return.\n     * @returns {*} Returns the nth element of `array`.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'd'];\n     *\n     * _.nth(array, 1);\n     * // => 'b'\n     *\n     * _.nth(array, -2);\n     * // => 'c';\n     */\n    function nth(array, n) {\n      return (array && array.length) ? baseNth(array, toInteger(n)) : undefined;\n    }\n\n    /**\n     * Removes all given values from `array` using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove`\n     * to remove elements from an array by predicate.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {...*} [values] The values to remove.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'a', 'b', 'c'];\n     *\n     * _.pull(array, 'a', 'c');\n     * console.log(array);\n     * // => ['b', 'b']\n     */\n    var pull = baseRest(pullAll);\n\n    /**\n     * This method is like `_.pull` except that it accepts an array of values to remove.\n     *\n     * **Note:** Unlike `_.difference`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'a', 'b', 'c'];\n     *\n     * _.pullAll(array, ['a', 'c']);\n     * console.log(array);\n     * // => ['b', 'b']\n     */\n    function pullAll(array, values) {\n      return (array && array.length && values && values.length)\n        ? basePullAll(array, values)\n        : array;\n    }\n\n    /**\n     * This method is like `_.pullAll` except that it accepts `iteratee` which is\n     * invoked for each element of `array` and `values` to generate the criterion\n     * by which they're compared. The iteratee is invoked with one argument: (value).\n     *\n     * **Note:** Unlike `_.differenceBy`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];\n     *\n     * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');\n     * console.log(array);\n     * // => [{ 'x': 2 }]\n     */\n    function pullAllBy(array, values, iteratee) {\n      return (array && array.length && values && values.length)\n        ? basePullAll(array, values, getIteratee(iteratee, 2))\n        : array;\n    }\n\n    /**\n     * This method is like `_.pullAll` except that it accepts `comparator` which\n     * is invoked to compare elements of `array` to `values`. The comparator is\n     * invoked with two arguments: (arrVal, othVal).\n     *\n     * **Note:** Unlike `_.differenceWith`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.6.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];\n     *\n     * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);\n     * console.log(array);\n     * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]\n     */\n    function pullAllWith(array, values, comparator) {\n      return (array && array.length && values && values.length)\n        ? basePullAll(array, values, undefined, comparator)\n        : array;\n    }\n\n    /**\n     * Removes elements from `array` corresponding to `indexes` and returns an\n     * array of removed elements.\n     *\n     * **Note:** Unlike `_.at`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {...(number|number[])} [indexes] The indexes of elements to remove.\n     * @returns {Array} Returns the new array of removed elements.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'd'];\n     * var pulled = _.pullAt(array, [1, 3]);\n     *\n     * console.log(array);\n     * // => ['a', 'c']\n     *\n     * console.log(pulled);\n     * // => ['b', 'd']\n     */\n    var pullAt = flatRest(function(array, indexes) {\n      var length = array == null ? 0 : array.length,\n          result = baseAt(array, indexes);\n\n      basePullAt(array, arrayMap(indexes, function(index) {\n        return isIndex(index, length) ? +index : index;\n      }).sort(compareAscending));\n\n      return result;\n    });\n\n    /**\n     * Removes all elements from `array` that `predicate` returns truthy for\n     * and returns an array of the removed elements. The predicate is invoked\n     * with three arguments: (value, index, array).\n     *\n     * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull`\n     * to pull elements from an array by value.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new array of removed elements.\n     * @example\n     *\n     * var array = [1, 2, 3, 4];\n     * var evens = _.remove(array, function(n) {\n     *   return n % 2 == 0;\n     * });\n     *\n     * console.log(array);\n     * // => [1, 3]\n     *\n     * console.log(evens);\n     * // => [2, 4]\n     */\n    function remove(array, predicate) {\n      var result = [];\n      if (!(array && array.length)) {\n        return result;\n      }\n      var index = -1,\n          indexes = [],\n          length = array.length;\n\n      predicate = getIteratee(predicate, 3);\n      while (++index < length) {\n        var value = array[index];\n        if (predicate(value, index, array)) {\n          result.push(value);\n          indexes.push(index);\n        }\n      }\n      basePullAt(array, indexes);\n      return result;\n    }\n\n    /**\n     * Reverses `array` so that the first element becomes the last, the second\n     * element becomes the second to last, and so on.\n     *\n     * **Note:** This method mutates `array` and is based on\n     * [`Array#reverse`](https://mdn.io/Array/reverse).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [1, 2, 3];\n     *\n     * _.reverse(array);\n     * // => [3, 2, 1]\n     *\n     * console.log(array);\n     * // => [3, 2, 1]\n     */\n    function reverse(array) {\n      return array == null ? array : nativeReverse.call(array);\n    }\n\n    /**\n     * Creates a slice of `array` from `start` up to, but not including, `end`.\n     *\n     * **Note:** This method is used instead of\n     * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are\n     * returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to slice.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns the slice of `array`.\n     */\n    function slice(array, start, end) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      if (end && typeof end != 'number' && isIterateeCall(array, start, end)) {\n        start = 0;\n        end = length;\n      }\n      else {\n        start = start == null ? 0 : toInteger(start);\n        end = end === undefined ? length : toInteger(end);\n      }\n      return baseSlice(array, start, end);\n    }\n\n    /**\n     * Uses a binary search to determine the lowest index at which `value`\n     * should be inserted into `array` in order to maintain its sort order.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * _.sortedIndex([30, 50], 40);\n     * // => 1\n     */\n    function sortedIndex(array, value) {\n      return baseSortedIndex(array, value);\n    }\n\n    /**\n     * This method is like `_.sortedIndex` except that it accepts `iteratee`\n     * which is invoked for `value` and each element of `array` to compute their\n     * sort ranking. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * var objects = [{ 'x': 4 }, { 'x': 5 }];\n     *\n     * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });\n     * // => 0\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.sortedIndexBy(objects, { 'x': 4 }, 'x');\n     * // => 0\n     */\n    function sortedIndexBy(array, value, iteratee) {\n      return baseSortedIndexBy(array, value, getIteratee(iteratee, 2));\n    }\n\n    /**\n     * This method is like `_.indexOf` except that it performs a binary\n     * search on a sorted `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.sortedIndexOf([4, 5, 5, 5, 6], 5);\n     * // => 1\n     */\n    function sortedIndexOf(array, value) {\n      var length = array == null ? 0 : array.length;\n      if (length) {\n        var index = baseSortedIndex(array, value);\n        if (index < length && eq(array[index], value)) {\n          return index;\n        }\n      }\n      return -1;\n    }\n\n    /**\n     * This method is like `_.sortedIndex` except that it returns the highest\n     * index at which `value` should be inserted into `array` in order to\n     * maintain its sort order.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * _.sortedLastIndex([4, 5, 5, 5, 6], 5);\n     * // => 4\n     */\n    function sortedLastIndex(array, value) {\n      return baseSortedIndex(array, value, true);\n    }\n\n    /**\n     * This method is like `_.sortedLastIndex` except that it accepts `iteratee`\n     * which is invoked for `value` and each element of `array` to compute their\n     * sort ranking. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * var objects = [{ 'x': 4 }, { 'x': 5 }];\n     *\n     * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });\n     * // => 1\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x');\n     * // => 1\n     */\n    function sortedLastIndexBy(array, value, iteratee) {\n      return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true);\n    }\n\n    /**\n     * This method is like `_.lastIndexOf` except that it performs a binary\n     * search on a sorted `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5);\n     * // => 3\n     */\n    function sortedLastIndexOf(array, value) {\n      var length = array == null ? 0 : array.length;\n      if (length) {\n        var index = baseSortedIndex(array, value, true) - 1;\n        if (eq(array[index], value)) {\n          return index;\n        }\n      }\n      return -1;\n    }\n\n    /**\n     * This method is like `_.uniq` except that it's designed and optimized\n     * for sorted arrays.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.sortedUniq([1, 1, 2]);\n     * // => [1, 2]\n     */\n    function sortedUniq(array) {\n      return (array && array.length)\n        ? baseSortedUniq(array)\n        : [];\n    }\n\n    /**\n     * This method is like `_.uniqBy` except that it's designed and optimized\n     * for sorted arrays.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);\n     * // => [1.1, 2.3]\n     */\n    function sortedUniqBy(array, iteratee) {\n      return (array && array.length)\n        ? baseSortedUniq(array, getIteratee(iteratee, 2))\n        : [];\n    }\n\n    /**\n     * Gets all but the first element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.tail([1, 2, 3]);\n     * // => [2, 3]\n     */\n    function tail(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseSlice(array, 1, length) : [];\n    }\n\n    /**\n     * Creates a slice of `array` with `n` elements taken from the beginning.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to take.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.take([1, 2, 3]);\n     * // => [1]\n     *\n     * _.take([1, 2, 3], 2);\n     * // => [1, 2]\n     *\n     * _.take([1, 2, 3], 5);\n     * // => [1, 2, 3]\n     *\n     * _.take([1, 2, 3], 0);\n     * // => []\n     */\n    function take(array, n, guard) {\n      if (!(array && array.length)) {\n        return [];\n      }\n      n = (guard || n === undefined) ? 1 : toInteger(n);\n      return baseSlice(array, 0, n < 0 ? 0 : n);\n    }\n\n    /**\n     * Creates a slice of `array` with `n` elements taken from the end.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to take.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.takeRight([1, 2, 3]);\n     * // => [3]\n     *\n     * _.takeRight([1, 2, 3], 2);\n     * // => [2, 3]\n     *\n     * _.takeRight([1, 2, 3], 5);\n     * // => [1, 2, 3]\n     *\n     * _.takeRight([1, 2, 3], 0);\n     * // => []\n     */\n    function takeRight(array, n, guard) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      n = (guard || n === undefined) ? 1 : toInteger(n);\n      n = length - n;\n      return baseSlice(array, n < 0 ? 0 : n, length);\n    }\n\n    /**\n     * Creates a slice of `array` with elements taken from the end. Elements are\n     * taken until `predicate` returns falsey. The predicate is invoked with\n     * three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': true },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': false }\n     * ];\n     *\n     * _.takeRightWhile(users, function(o) { return !o.active; });\n     * // => objects for ['fred', 'pebbles']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false });\n     * // => objects for ['pebbles']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.takeRightWhile(users, ['active', false]);\n     * // => objects for ['fred', 'pebbles']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.takeRightWhile(users, 'active');\n     * // => []\n     */\n    function takeRightWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3), false, true)\n        : [];\n    }\n\n    /**\n     * Creates a slice of `array` with elements taken from the beginning. Elements\n     * are taken until `predicate` returns falsey. The predicate is invoked with\n     * three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': false },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': true }\n     * ];\n     *\n     * _.takeWhile(users, function(o) { return !o.active; });\n     * // => objects for ['barney', 'fred']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.takeWhile(users, { 'user': 'barney', 'active': false });\n     * // => objects for ['barney']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.takeWhile(users, ['active', false]);\n     * // => objects for ['barney', 'fred']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.takeWhile(users, 'active');\n     * // => []\n     */\n    function takeWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3))\n        : [];\n    }\n\n    /**\n     * Creates an array of unique values, in order, from all given arrays using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @returns {Array} Returns the new array of combined values.\n     * @example\n     *\n     * _.union([2], [1, 2]);\n     * // => [2, 1]\n     */\n    var union = baseRest(function(arrays) {\n      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));\n    });\n\n    /**\n     * This method is like `_.union` except that it accepts `iteratee` which is\n     * invoked for each element of each `arrays` to generate the criterion by\n     * which uniqueness is computed. Result values are chosen from the first\n     * array in which the value occurs. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of combined values.\n     * @example\n     *\n     * _.unionBy([2.1], [1.2, 2.3], Math.floor);\n     * // => [2.1, 1.2]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 1 }, { 'x': 2 }]\n     */\n    var unionBy = baseRest(function(arrays) {\n      var iteratee = last(arrays);\n      if (isArrayLikeObject(iteratee)) {\n        iteratee = undefined;\n      }\n      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee, 2));\n    });\n\n    /**\n     * This method is like `_.union` except that it accepts `comparator` which\n     * is invoked to compare elements of `arrays`. Result values are chosen from\n     * the first array in which the value occurs. The comparator is invoked\n     * with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of combined values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.unionWith(objects, others, _.isEqual);\n     * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]\n     */\n    var unionWith = baseRest(function(arrays) {\n      var comparator = last(arrays);\n      comparator = typeof comparator == 'function' ? comparator : undefined;\n      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined, comparator);\n    });\n\n    /**\n     * Creates a duplicate-free version of an array, using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons, in which only the first occurrence of each element\n     * is kept. The order of result values is determined by the order they occur\n     * in the array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.uniq([2, 1, 2]);\n     * // => [2, 1]\n     */\n    function uniq(array) {\n      return (array && array.length) ? baseUniq(array) : [];\n    }\n\n    /**\n     * This method is like `_.uniq` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the criterion by which\n     * uniqueness is computed. The order of result values is determined by the\n     * order they occur in the array. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.uniqBy([2.1, 1.2, 2.3], Math.floor);\n     * // => [2.1, 1.2]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 1 }, { 'x': 2 }]\n     */\n    function uniqBy(array, iteratee) {\n      return (array && array.length) ? baseUniq(array, getIteratee(iteratee, 2)) : [];\n    }\n\n    /**\n     * This method is like `_.uniq` except that it accepts `comparator` which\n     * is invoked to compare elements of `array`. The order of result values is\n     * determined by the order they occur in the array.The comparator is invoked\n     * with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.uniqWith(objects, _.isEqual);\n     * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]\n     */\n    function uniqWith(array, comparator) {\n      comparator = typeof comparator == 'function' ? comparator : undefined;\n      return (array && array.length) ? baseUniq(array, undefined, comparator) : [];\n    }\n\n    /**\n     * This method is like `_.zip` except that it accepts an array of grouped\n     * elements and creates an array regrouping the elements to their pre-zip\n     * configuration.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.2.0\n     * @category Array\n     * @param {Array} array The array of grouped elements to process.\n     * @returns {Array} Returns the new array of regrouped elements.\n     * @example\n     *\n     * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]);\n     * // => [['a', 1, true], ['b', 2, false]]\n     *\n     * _.unzip(zipped);\n     * // => [['a', 'b'], [1, 2], [true, false]]\n     */\n    function unzip(array) {\n      if (!(array && array.length)) {\n        return [];\n      }\n      var length = 0;\n      array = arrayFilter(array, function(group) {\n        if (isArrayLikeObject(group)) {\n          length = nativeMax(group.length, length);\n          return true;\n        }\n      });\n      return baseTimes(length, function(index) {\n        return arrayMap(array, baseProperty(index));\n      });\n    }\n\n    /**\n     * This method is like `_.unzip` except that it accepts `iteratee` to specify\n     * how regrouped values should be combined. The iteratee is invoked with the\n     * elements of each group: (...group).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.8.0\n     * @category Array\n     * @param {Array} array The array of grouped elements to process.\n     * @param {Function} [iteratee=_.identity] The function to combine\n     *  regrouped values.\n     * @returns {Array} Returns the new array of regrouped elements.\n     * @example\n     *\n     * var zipped = _.zip([1, 2], [10, 20], [100, 200]);\n     * // => [[1, 10, 100], [2, 20, 200]]\n     *\n     * _.unzipWith(zipped, _.add);\n     * // => [3, 30, 300]\n     */\n    function unzipWith(array, iteratee) {\n      if (!(array && array.length)) {\n        return [];\n      }\n      var result = unzip(array);\n      if (iteratee == null) {\n        return result;\n      }\n      return arrayMap(result, function(group) {\n        return apply(iteratee, undefined, group);\n      });\n    }\n\n    /**\n     * Creates an array excluding all given values using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * **Note:** Unlike `_.pull`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...*} [values] The values to exclude.\n     * @returns {Array} Returns the new array of filtered values.\n     * @see _.difference, _.xor\n     * @example\n     *\n     * _.without([2, 1, 2, 3], 1, 2);\n     * // => [3]\n     */\n    var without = baseRest(function(array, values) {\n      return isArrayLikeObject(array)\n        ? baseDifference(array, values)\n        : [];\n    });\n\n    /**\n     * Creates an array of unique values that is the\n     * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)\n     * of the given arrays. The order of result values is determined by the order\n     * they occur in the arrays.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @returns {Array} Returns the new array of filtered values.\n     * @see _.difference, _.without\n     * @example\n     *\n     * _.xor([2, 1], [2, 3]);\n     * // => [1, 3]\n     */\n    var xor = baseRest(function(arrays) {\n      return baseXor(arrayFilter(arrays, isArrayLikeObject));\n    });\n\n    /**\n     * This method is like `_.xor` except that it accepts `iteratee` which is\n     * invoked for each element of each `arrays` to generate the criterion by\n     * which by which they're compared. The order of result values is determined\n     * by the order they occur in the arrays. The iteratee is invoked with one\n     * argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n     * // => [1.2, 3.4]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 2 }]\n     */\n    var xorBy = baseRest(function(arrays) {\n      var iteratee = last(arrays);\n      if (isArrayLikeObject(iteratee)) {\n        iteratee = undefined;\n      }\n      return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee, 2));\n    });\n\n    /**\n     * This method is like `_.xor` except that it accepts `comparator` which is\n     * invoked to compare elements of `arrays`. The order of result values is\n     * determined by the order they occur in the arrays. The comparator is invoked\n     * with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.xorWith(objects, others, _.isEqual);\n     * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]\n     */\n    var xorWith = baseRest(function(arrays) {\n      var comparator = last(arrays);\n      comparator = typeof comparator == 'function' ? comparator : undefined;\n      return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined, comparator);\n    });\n\n    /**\n     * Creates an array of grouped elements, the first of which contains the\n     * first elements of the given arrays, the second of which contains the\n     * second elements of the given arrays, and so on.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to process.\n     * @returns {Array} Returns the new array of grouped elements.\n     * @example\n     *\n     * _.zip(['a', 'b'], [1, 2], [true, false]);\n     * // => [['a', 1, true], ['b', 2, false]]\n     */\n    var zip = baseRest(unzip);\n\n    /**\n     * This method is like `_.fromPairs` except that it accepts two arrays,\n     * one of property identifiers and one of corresponding values.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.4.0\n     * @category Array\n     * @param {Array} [props=[]] The property identifiers.\n     * @param {Array} [values=[]] The property values.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * _.zipObject(['a', 'b'], [1, 2]);\n     * // => { 'a': 1, 'b': 2 }\n     */\n    function zipObject(props, values) {\n      return baseZipObject(props || [], values || [], assignValue);\n    }\n\n    /**\n     * This method is like `_.zipObject` except that it supports property paths.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.1.0\n     * @category Array\n     * @param {Array} [props=[]] The property identifiers.\n     * @param {Array} [values=[]] The property values.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);\n     * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }\n     */\n    function zipObjectDeep(props, values) {\n      return baseZipObject(props || [], values || [], baseSet);\n    }\n\n    /**\n     * This method is like `_.zip` except that it accepts `iteratee` to specify\n     * how grouped values should be combined. The iteratee is invoked with the\n     * elements of each group: (...group).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.8.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to process.\n     * @param {Function} [iteratee=_.identity] The function to combine\n     *  grouped values.\n     * @returns {Array} Returns the new array of grouped elements.\n     * @example\n     *\n     * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {\n     *   return a + b + c;\n     * });\n     * // => [111, 222]\n     */\n    var zipWith = baseRest(function(arrays) {\n      var length = arrays.length,\n          iteratee = length > 1 ? arrays[length - 1] : undefined;\n\n      iteratee = typeof iteratee == 'function' ? (arrays.pop(), iteratee) : undefined;\n      return unzipWith(arrays, iteratee);\n    });\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a `lodash` wrapper instance that wraps `value` with explicit method\n     * chain sequences enabled. The result of such sequences must be unwrapped\n     * with `_#value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.3.0\n     * @category Seq\n     * @param {*} value The value to wrap.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'age': 36 },\n     *   { 'user': 'fred',    'age': 40 },\n     *   { 'user': 'pebbles', 'age': 1 }\n     * ];\n     *\n     * var youngest = _\n     *   .chain(users)\n     *   .sortBy('age')\n     *   .map(function(o) {\n     *     return o.user + ' is ' + o.age;\n     *   })\n     *   .head()\n     *   .value();\n     * // => 'pebbles is 1'\n     */\n    function chain(value) {\n      var result = lodash(value);\n      result.__chain__ = true;\n      return result;\n    }\n\n    /**\n     * This method invokes `interceptor` and returns `value`. The interceptor\n     * is invoked with one argument; (value). The purpose of this method is to\n     * \"tap into\" a method chain sequence in order to modify intermediate results.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Seq\n     * @param {*} value The value to provide to `interceptor`.\n     * @param {Function} interceptor The function to invoke.\n     * @returns {*} Returns `value`.\n     * @example\n     *\n     * _([1, 2, 3])\n     *  .tap(function(array) {\n     *    // Mutate input array.\n     *    array.pop();\n     *  })\n     *  .reverse()\n     *  .value();\n     * // => [2, 1]\n     */\n    function tap(value, interceptor) {\n      interceptor(value);\n      return value;\n    }\n\n    /**\n     * This method is like `_.tap` except that it returns the result of `interceptor`.\n     * The purpose of this method is to \"pass thru\" values replacing intermediate\n     * results in a method chain sequence.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Seq\n     * @param {*} value The value to provide to `interceptor`.\n     * @param {Function} interceptor The function to invoke.\n     * @returns {*} Returns the result of `interceptor`.\n     * @example\n     *\n     * _('  abc  ')\n     *  .chain()\n     *  .trim()\n     *  .thru(function(value) {\n     *    return [value];\n     *  })\n     *  .value();\n     * // => ['abc']\n     */\n    function thru(value, interceptor) {\n      return interceptor(value);\n    }\n\n    /**\n     * This method is the wrapper version of `_.at`.\n     *\n     * @name at\n     * @memberOf _\n     * @since 1.0.0\n     * @category Seq\n     * @param {...(string|string[])} [paths] The property paths to pick.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };\n     *\n     * _(object).at(['a[0].b.c', 'a[1]']).value();\n     * // => [3, 4]\n     */\n    var wrapperAt = flatRest(function(paths) {\n      var length = paths.length,\n          start = length ? paths[0] : 0,\n          value = this.__wrapped__,\n          interceptor = function(object) { return baseAt(object, paths); };\n\n      if (length > 1 || this.__actions__.length ||\n          !(value instanceof LazyWrapper) || !isIndex(start)) {\n        return this.thru(interceptor);\n      }\n      value = value.slice(start, +start + (length ? 1 : 0));\n      value.__actions__.push({\n        'func': thru,\n        'args': [interceptor],\n        'thisArg': undefined\n      });\n      return new LodashWrapper(value, this.__chain__).thru(function(array) {\n        if (length && !array.length) {\n          array.push(undefined);\n        }\n        return array;\n      });\n    });\n\n    /**\n     * Creates a `lodash` wrapper instance with explicit method chain sequences enabled.\n     *\n     * @name chain\n     * @memberOf _\n     * @since 0.1.0\n     * @category Seq\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36 },\n     *   { 'user': 'fred',   'age': 40 }\n     * ];\n     *\n     * // A sequence without explicit chaining.\n     * _(users).head();\n     * // => { 'user': 'barney', 'age': 36 }\n     *\n     * // A sequence with explicit chaining.\n     * _(users)\n     *   .chain()\n     *   .head()\n     *   .pick('user')\n     *   .value();\n     * // => { 'user': 'barney' }\n     */\n    function wrapperChain() {\n      return chain(this);\n    }\n\n    /**\n     * Executes the chain sequence and returns the wrapped result.\n     *\n     * @name commit\n     * @memberOf _\n     * @since 3.2.0\n     * @category Seq\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var array = [1, 2];\n     * var wrapped = _(array).push(3);\n     *\n     * console.log(array);\n     * // => [1, 2]\n     *\n     * wrapped = wrapped.commit();\n     * console.log(array);\n     * // => [1, 2, 3]\n     *\n     * wrapped.last();\n     * // => 3\n     *\n     * console.log(array);\n     * // => [1, 2, 3]\n     */\n    function wrapperCommit() {\n      return new LodashWrapper(this.value(), this.__chain__);\n    }\n\n    /**\n     * Gets the next value on a wrapped object following the\n     * [iterator protocol](https://mdn.io/iteration_protocols#iterator).\n     *\n     * @name next\n     * @memberOf _\n     * @since 4.0.0\n     * @category Seq\n     * @returns {Object} Returns the next iterator value.\n     * @example\n     *\n     * var wrapped = _([1, 2]);\n     *\n     * wrapped.next();\n     * // => { 'done': false, 'value': 1 }\n     *\n     * wrapped.next();\n     * // => { 'done': false, 'value': 2 }\n     *\n     * wrapped.next();\n     * // => { 'done': true, 'value': undefined }\n     */\n    function wrapperNext() {\n      if (this.__values__ === undefined) {\n        this.__values__ = toArray(this.value());\n      }\n      var done = this.__index__ >= this.__values__.length,\n          value = done ? undefined : this.__values__[this.__index__++];\n\n      return { 'done': done, 'value': value };\n    }\n\n    /**\n     * Enables the wrapper to be iterable.\n     *\n     * @name Symbol.iterator\n     * @memberOf _\n     * @since 4.0.0\n     * @category Seq\n     * @returns {Object} Returns the wrapper object.\n     * @example\n     *\n     * var wrapped = _([1, 2]);\n     *\n     * wrapped[Symbol.iterator]() === wrapped;\n     * // => true\n     *\n     * Array.from(wrapped);\n     * // => [1, 2]\n     */\n    function wrapperToIterator() {\n      return this;\n    }\n\n    /**\n     * Creates a clone of the chain sequence planting `value` as the wrapped value.\n     *\n     * @name plant\n     * @memberOf _\n     * @since 3.2.0\n     * @category Seq\n     * @param {*} value The value to plant.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var wrapped = _([1, 2]).map(square);\n     * var other = wrapped.plant([3, 4]);\n     *\n     * other.value();\n     * // => [9, 16]\n     *\n     * wrapped.value();\n     * // => [1, 4]\n     */\n    function wrapperPlant(value) {\n      var result,\n          parent = this;\n\n      while (parent instanceof baseLodash) {\n        var clone = wrapperClone(parent);\n        clone.__index__ = 0;\n        clone.__values__ = undefined;\n        if (result) {\n          previous.__wrapped__ = clone;\n        } else {\n          result = clone;\n        }\n        var previous = clone;\n        parent = parent.__wrapped__;\n      }\n      previous.__wrapped__ = value;\n      return result;\n    }\n\n    /**\n     * This method is the wrapper version of `_.reverse`.\n     *\n     * **Note:** This method mutates the wrapped array.\n     *\n     * @name reverse\n     * @memberOf _\n     * @since 0.1.0\n     * @category Seq\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var array = [1, 2, 3];\n     *\n     * _(array).reverse().value()\n     * // => [3, 2, 1]\n     *\n     * console.log(array);\n     * // => [3, 2, 1]\n     */\n    function wrapperReverse() {\n      var value = this.__wrapped__;\n      if (value instanceof LazyWrapper) {\n        var wrapped = value;\n        if (this.__actions__.length) {\n          wrapped = new LazyWrapper(this);\n        }\n        wrapped = wrapped.reverse();\n        wrapped.__actions__.push({\n          'func': thru,\n          'args': [reverse],\n          'thisArg': undefined\n        });\n        return new LodashWrapper(wrapped, this.__chain__);\n      }\n      return this.thru(reverse);\n    }\n\n    /**\n     * Executes the chain sequence to resolve the unwrapped value.\n     *\n     * @name value\n     * @memberOf _\n     * @since 0.1.0\n     * @alias toJSON, valueOf\n     * @category Seq\n     * @returns {*} Returns the resolved unwrapped value.\n     * @example\n     *\n     * _([1, 2, 3]).value();\n     * // => [1, 2, 3]\n     */\n    function wrapperValue() {\n      return baseWrapperValue(this.__wrapped__, this.__actions__);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an object composed of keys generated from the results of running\n     * each element of `collection` thru `iteratee`. The corresponding value of\n     * each key is the number of times the key was returned by `iteratee`. The\n     * iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.5.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * _.countBy([6.1, 4.2, 6.3], Math.floor);\n     * // => { '4': 1, '6': 2 }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.countBy(['one', 'two', 'three'], 'length');\n     * // => { '3': 2, '5': 1 }\n     */\n    var countBy = createAggregator(function(result, value, key) {\n      if (hasOwnProperty.call(result, key)) {\n        ++result[key];\n      } else {\n        baseAssignValue(result, key, 1);\n      }\n    });\n\n    /**\n     * Checks if `predicate` returns truthy for **all** elements of `collection`.\n     * Iteration is stopped once `predicate` returns falsey. The predicate is\n     * invoked with three arguments: (value, index|key, collection).\n     *\n     * **Note:** This method returns `true` for\n     * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because\n     * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of\n     * elements of empty collections.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {boolean} Returns `true` if all elements pass the predicate check,\n     *  else `false`.\n     * @example\n     *\n     * _.every([true, 1, null, 'yes'], Boolean);\n     * // => false\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': false },\n     *   { 'user': 'fred',   'age': 40, 'active': false }\n     * ];\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.every(users, { 'user': 'barney', 'active': false });\n     * // => false\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.every(users, ['active', false]);\n     * // => true\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.every(users, 'active');\n     * // => false\n     */\n    function every(collection, predicate, guard) {\n      var func = isArray(collection) ? arrayEvery : baseEvery;\n      if (guard && isIterateeCall(collection, predicate, guard)) {\n        predicate = undefined;\n      }\n      return func(collection, getIteratee(predicate, 3));\n    }\n\n    /**\n     * Iterates over elements of `collection`, returning an array of all elements\n     * `predicate` returns truthy for. The predicate is invoked with three\n     * arguments: (value, index|key, collection).\n     *\n     * **Note:** Unlike `_.remove`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new filtered array.\n     * @see _.reject\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': true },\n     *   { 'user': 'fred',   'age': 40, 'active': false }\n     * ];\n     *\n     * _.filter(users, function(o) { return !o.active; });\n     * // => objects for ['fred']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.filter(users, { 'age': 36, 'active': true });\n     * // => objects for ['barney']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.filter(users, ['active', false]);\n     * // => objects for ['fred']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.filter(users, 'active');\n     * // => objects for ['barney']\n     */\n    function filter(collection, predicate) {\n      var func = isArray(collection) ? arrayFilter : baseFilter;\n      return func(collection, getIteratee(predicate, 3));\n    }\n\n    /**\n     * Iterates over elements of `collection`, returning the first element\n     * `predicate` returns truthy for. The predicate is invoked with three\n     * arguments: (value, index|key, collection).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @returns {*} Returns the matched element, else `undefined`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'age': 36, 'active': true },\n     *   { 'user': 'fred',    'age': 40, 'active': false },\n     *   { 'user': 'pebbles', 'age': 1,  'active': true }\n     * ];\n     *\n     * _.find(users, function(o) { return o.age < 40; });\n     * // => object for 'barney'\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.find(users, { 'age': 1, 'active': true });\n     * // => object for 'pebbles'\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.find(users, ['active', false]);\n     * // => object for 'fred'\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.find(users, 'active');\n     * // => object for 'barney'\n     */\n    var find = createFind(findIndex);\n\n    /**\n     * This method is like `_.find` except that it iterates over elements of\n     * `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=collection.length-1] The index to search from.\n     * @returns {*} Returns the matched element, else `undefined`.\n     * @example\n     *\n     * _.findLast([1, 2, 3, 4], function(n) {\n     *   return n % 2 == 1;\n     * });\n     * // => 3\n     */\n    var findLast = createFind(findLastIndex);\n\n    /**\n     * Creates a flattened array of values by running each element in `collection`\n     * thru `iteratee` and flattening the mapped results. The iteratee is invoked\n     * with three arguments: (value, index|key, collection).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * function duplicate(n) {\n     *   return [n, n];\n     * }\n     *\n     * _.flatMap([1, 2], duplicate);\n     * // => [1, 1, 2, 2]\n     */\n    function flatMap(collection, iteratee) {\n      return baseFlatten(map(collection, iteratee), 1);\n    }\n\n    /**\n     * This method is like `_.flatMap` except that it recursively flattens the\n     * mapped results.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * function duplicate(n) {\n     *   return [[[n, n]]];\n     * }\n     *\n     * _.flatMapDeep([1, 2], duplicate);\n     * // => [1, 1, 2, 2]\n     */\n    function flatMapDeep(collection, iteratee) {\n      return baseFlatten(map(collection, iteratee), INFINITY);\n    }\n\n    /**\n     * This method is like `_.flatMap` except that it recursively flattens the\n     * mapped results up to `depth` times.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {number} [depth=1] The maximum recursion depth.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * function duplicate(n) {\n     *   return [[[n, n]]];\n     * }\n     *\n     * _.flatMapDepth([1, 2], duplicate, 2);\n     * // => [[1, 1], [2, 2]]\n     */\n    function flatMapDepth(collection, iteratee, depth) {\n      depth = depth === undefined ? 1 : toInteger(depth);\n      return baseFlatten(map(collection, iteratee), depth);\n    }\n\n    /**\n     * Iterates over elements of `collection` and invokes `iteratee` for each element.\n     * The iteratee is invoked with three arguments: (value, index|key, collection).\n     * Iteratee functions may exit iteration early by explicitly returning `false`.\n     *\n     * **Note:** As with other \"Collections\" methods, objects with a \"length\"\n     * property are iterated like arrays. To avoid this behavior use `_.forIn`\n     * or `_.forOwn` for object iteration.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @alias each\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     * @see _.forEachRight\n     * @example\n     *\n     * _.forEach([1, 2], function(value) {\n     *   console.log(value);\n     * });\n     * // => Logs `1` then `2`.\n     *\n     * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'a' then 'b' (iteration order is not guaranteed).\n     */\n    function forEach(collection, iteratee) {\n      var func = isArray(collection) ? arrayEach : baseEach;\n      return func(collection, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * This method is like `_.forEach` except that it iterates over elements of\n     * `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @alias eachRight\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     * @see _.forEach\n     * @example\n     *\n     * _.forEachRight([1, 2], function(value) {\n     *   console.log(value);\n     * });\n     * // => Logs `2` then `1`.\n     */\n    function forEachRight(collection, iteratee) {\n      var func = isArray(collection) ? arrayEachRight : baseEachRight;\n      return func(collection, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * Creates an object composed of keys generated from the results of running\n     * each element of `collection` thru `iteratee`. The order of grouped values\n     * is determined by the order they occur in `collection`. The corresponding\n     * value of each key is an array of elements responsible for generating the\n     * key. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * _.groupBy([6.1, 4.2, 6.3], Math.floor);\n     * // => { '4': [4.2], '6': [6.1, 6.3] }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.groupBy(['one', 'two', 'three'], 'length');\n     * // => { '3': ['one', 'two'], '5': ['three'] }\n     */\n    var groupBy = createAggregator(function(result, value, key) {\n      if (hasOwnProperty.call(result, key)) {\n        result[key].push(value);\n      } else {\n        baseAssignValue(result, key, [value]);\n      }\n    });\n\n    /**\n     * Checks if `value` is in `collection`. If `collection` is a string, it's\n     * checked for a substring of `value`, otherwise\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * is used for equality comparisons. If `fromIndex` is negative, it's used as\n     * the offset from the end of `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to inspect.\n     * @param {*} value The value to search for.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.\n     * @returns {boolean} Returns `true` if `value` is found, else `false`.\n     * @example\n     *\n     * _.includes([1, 2, 3], 1);\n     * // => true\n     *\n     * _.includes([1, 2, 3], 1, 2);\n     * // => false\n     *\n     * _.includes({ 'a': 1, 'b': 2 }, 1);\n     * // => true\n     *\n     * _.includes('abcd', 'bc');\n     * // => true\n     */\n    function includes(collection, value, fromIndex, guard) {\n      collection = isArrayLike(collection) ? collection : values(collection);\n      fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0;\n\n      var length = collection.length;\n      if (fromIndex < 0) {\n        fromIndex = nativeMax(length + fromIndex, 0);\n      }\n      return isString(collection)\n        ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)\n        : (!!length && baseIndexOf(collection, value, fromIndex) > -1);\n    }\n\n    /**\n     * Invokes the method at `path` of each element in `collection`, returning\n     * an array of the results of each invoked method. Any additional arguments\n     * are provided to each invoked method. If `path` is a function, it's invoked\n     * for, and `this` bound to, each element in `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Array|Function|string} path The path of the method to invoke or\n     *  the function invoked per iteration.\n     * @param {...*} [args] The arguments to invoke each method with.\n     * @returns {Array} Returns the array of results.\n     * @example\n     *\n     * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');\n     * // => [[1, 5, 7], [1, 2, 3]]\n     *\n     * _.invokeMap([123, 456], String.prototype.split, '');\n     * // => [['1', '2', '3'], ['4', '5', '6']]\n     */\n    var invokeMap = baseRest(function(collection, path, args) {\n      var index = -1,\n          isFunc = typeof path == 'function',\n          result = isArrayLike(collection) ? Array(collection.length) : [];\n\n      baseEach(collection, function(value) {\n        result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);\n      });\n      return result;\n    });\n\n    /**\n     * Creates an object composed of keys generated from the results of running\n     * each element of `collection` thru `iteratee`. The corresponding value of\n     * each key is the last element responsible for generating the key. The\n     * iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * var array = [\n     *   { 'dir': 'left', 'code': 97 },\n     *   { 'dir': 'right', 'code': 100 }\n     * ];\n     *\n     * _.keyBy(array, function(o) {\n     *   return String.fromCharCode(o.code);\n     * });\n     * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }\n     *\n     * _.keyBy(array, 'dir');\n     * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }\n     */\n    var keyBy = createAggregator(function(result, value, key) {\n      baseAssignValue(result, key, value);\n    });\n\n    /**\n     * Creates an array of values by running each element in `collection` thru\n     * `iteratee`. The iteratee is invoked with three arguments:\n     * (value, index|key, collection).\n     *\n     * Many lodash methods are guarded to work as iteratees for methods like\n     * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.\n     *\n     * The guarded methods are:\n     * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,\n     * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,\n     * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,\n     * `template`, `trim`, `trimEnd`, `trimStart`, and `words`\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new mapped array.\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * _.map([4, 8], square);\n     * // => [16, 64]\n     *\n     * _.map({ 'a': 4, 'b': 8 }, square);\n     * // => [16, 64] (iteration order is not guaranteed)\n     *\n     * var users = [\n     *   { 'user': 'barney' },\n     *   { 'user': 'fred' }\n     * ];\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.map(users, 'user');\n     * // => ['barney', 'fred']\n     */\n    function map(collection, iteratee) {\n      var func = isArray(collection) ? arrayMap : baseMap;\n      return func(collection, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * This method is like `_.sortBy` except that it allows specifying the sort\n     * orders of the iteratees to sort by. If `orders` is unspecified, all values\n     * are sorted in ascending order. Otherwise, specify an order of \"desc\" for\n     * descending or \"asc\" for ascending sort order of corresponding values.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]]\n     *  The iteratees to sort by.\n     * @param {string[]} [orders] The sort orders of `iteratees`.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.\n     * @returns {Array} Returns the new sorted array.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'fred',   'age': 48 },\n     *   { 'user': 'barney', 'age': 34 },\n     *   { 'user': 'fred',   'age': 40 },\n     *   { 'user': 'barney', 'age': 36 }\n     * ];\n     *\n     * // Sort by `user` in ascending order and by `age` in descending order.\n     * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);\n     * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]\n     */\n    function orderBy(collection, iteratees, orders, guard) {\n      if (collection == null) {\n        return [];\n      }\n      if (!isArray(iteratees)) {\n        iteratees = iteratees == null ? [] : [iteratees];\n      }\n      orders = guard ? undefined : orders;\n      if (!isArray(orders)) {\n        orders = orders == null ? [] : [orders];\n      }\n      return baseOrderBy(collection, iteratees, orders);\n    }\n\n    /**\n     * Creates an array of elements split into two groups, the first of which\n     * contains elements `predicate` returns truthy for, the second of which\n     * contains elements `predicate` returns falsey for. The predicate is\n     * invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the array of grouped elements.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'age': 36, 'active': false },\n     *   { 'user': 'fred',    'age': 40, 'active': true },\n     *   { 'user': 'pebbles', 'age': 1,  'active': false }\n     * ];\n     *\n     * _.partition(users, function(o) { return o.active; });\n     * // => objects for [['fred'], ['barney', 'pebbles']]\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.partition(users, { 'age': 1, 'active': false });\n     * // => objects for [['pebbles'], ['barney', 'fred']]\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.partition(users, ['active', false]);\n     * // => objects for [['barney', 'pebbles'], ['fred']]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.partition(users, 'active');\n     * // => objects for [['fred'], ['barney', 'pebbles']]\n     */\n    var partition = createAggregator(function(result, value, key) {\n      result[key ? 0 : 1].push(value);\n    }, function() { return [[], []]; });\n\n    /**\n     * Reduces `collection` to a value which is the accumulated result of running\n     * each element in `collection` thru `iteratee`, where each successive\n     * invocation is supplied the return value of the previous. If `accumulator`\n     * is not given, the first element of `collection` is used as the initial\n     * value. The iteratee is invoked with four arguments:\n     * (accumulator, value, index|key, collection).\n     *\n     * Many lodash methods are guarded to work as iteratees for methods like\n     * `_.reduce`, `_.reduceRight`, and `_.transform`.\n     *\n     * The guarded methods are:\n     * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,\n     * and `sortBy`\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [accumulator] The initial value.\n     * @returns {*} Returns the accumulated value.\n     * @see _.reduceRight\n     * @example\n     *\n     * _.reduce([1, 2], function(sum, n) {\n     *   return sum + n;\n     * }, 0);\n     * // => 3\n     *\n     * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {\n     *   (result[value] || (result[value] = [])).push(key);\n     *   return result;\n     * }, {});\n     * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)\n     */\n    function reduce(collection, iteratee, accumulator) {\n      var func = isArray(collection) ? arrayReduce : baseReduce,\n          initAccum = arguments.length < 3;\n\n      return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEach);\n    }\n\n    /**\n     * This method is like `_.reduce` except that it iterates over elements of\n     * `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [accumulator] The initial value.\n     * @returns {*} Returns the accumulated value.\n     * @see _.reduce\n     * @example\n     *\n     * var array = [[0, 1], [2, 3], [4, 5]];\n     *\n     * _.reduceRight(array, function(flattened, other) {\n     *   return flattened.concat(other);\n     * }, []);\n     * // => [4, 5, 2, 3, 0, 1]\n     */\n    function reduceRight(collection, iteratee, accumulator) {\n      var func = isArray(collection) ? arrayReduceRight : baseReduce,\n          initAccum = arguments.length < 3;\n\n      return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEachRight);\n    }\n\n    /**\n     * The opposite of `_.filter`; this method returns the elements of `collection`\n     * that `predicate` does **not** return truthy for.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new filtered array.\n     * @see _.filter\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': false },\n     *   { 'user': 'fred',   'age': 40, 'active': true }\n     * ];\n     *\n     * _.reject(users, function(o) { return !o.active; });\n     * // => objects for ['fred']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.reject(users, { 'age': 40, 'active': true });\n     * // => objects for ['barney']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.reject(users, ['active', false]);\n     * // => objects for ['fred']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.reject(users, 'active');\n     * // => objects for ['barney']\n     */\n    function reject(collection, predicate) {\n      var func = isArray(collection) ? arrayFilter : baseFilter;\n      return func(collection, negate(getIteratee(predicate, 3)));\n    }\n\n    /**\n     * Gets a random element from `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to sample.\n     * @returns {*} Returns the random element.\n     * @example\n     *\n     * _.sample([1, 2, 3, 4]);\n     * // => 2\n     */\n    function sample(collection) {\n      var func = isArray(collection) ? arraySample : baseSample;\n      return func(collection);\n    }\n\n    /**\n     * Gets `n` random elements at unique keys from `collection` up to the\n     * size of `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to sample.\n     * @param {number} [n=1] The number of elements to sample.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the random elements.\n     * @example\n     *\n     * _.sampleSize([1, 2, 3], 2);\n     * // => [3, 1]\n     *\n     * _.sampleSize([1, 2, 3], 4);\n     * // => [2, 3, 1]\n     */\n    function sampleSize(collection, n, guard) {\n      if ((guard ? isIterateeCall(collection, n, guard) : n === undefined)) {\n        n = 1;\n      } else {\n        n = toInteger(n);\n      }\n      var func = isArray(collection) ? arraySampleSize : baseSampleSize;\n      return func(collection, n);\n    }\n\n    /**\n     * Creates an array of shuffled values, using a version of the\n     * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to shuffle.\n     * @returns {Array} Returns the new shuffled array.\n     * @example\n     *\n     * _.shuffle([1, 2, 3, 4]);\n     * // => [4, 1, 3, 2]\n     */\n    function shuffle(collection) {\n      var func = isArray(collection) ? arrayShuffle : baseShuffle;\n      return func(collection);\n    }\n\n    /**\n     * Gets the size of `collection` by returning its length for array-like\n     * values or the number of own enumerable string keyed properties for objects.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to inspect.\n     * @returns {number} Returns the collection size.\n     * @example\n     *\n     * _.size([1, 2, 3]);\n     * // => 3\n     *\n     * _.size({ 'a': 1, 'b': 2 });\n     * // => 2\n     *\n     * _.size('pebbles');\n     * // => 7\n     */\n    function size(collection) {\n      if (collection == null) {\n        return 0;\n      }\n      if (isArrayLike(collection)) {\n        return isString(collection) ? stringSize(collection) : collection.length;\n      }\n      var tag = getTag(collection);\n      if (tag == mapTag || tag == setTag) {\n        return collection.size;\n      }\n      return baseKeys(collection).length;\n    }\n\n    /**\n     * Checks if `predicate` returns truthy for **any** element of `collection`.\n     * Iteration is stopped once `predicate` returns truthy. The predicate is\n     * invoked with three arguments: (value, index|key, collection).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {boolean} Returns `true` if any element passes the predicate check,\n     *  else `false`.\n     * @example\n     *\n     * _.some([null, 0, 'yes', false], Boolean);\n     * // => true\n     *\n     * var users = [\n     *   { 'user': 'barney', 'active': true },\n     *   { 'user': 'fred',   'active': false }\n     * ];\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.some(users, { 'user': 'barney', 'active': false });\n     * // => false\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.some(users, ['active', false]);\n     * // => true\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.some(users, 'active');\n     * // => true\n     */\n    function some(collection, predicate, guard) {\n      var func = isArray(collection) ? arraySome : baseSome;\n      if (guard && isIterateeCall(collection, predicate, guard)) {\n        predicate = undefined;\n      }\n      return func(collection, getIteratee(predicate, 3));\n    }\n\n    /**\n     * Creates an array of elements, sorted in ascending order by the results of\n     * running each element in a collection thru each iteratee. This method\n     * performs a stable sort, that is, it preserves the original sort order of\n     * equal elements. The iteratees are invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {...(Function|Function[])} [iteratees=[_.identity]]\n     *  The iteratees to sort by.\n     * @returns {Array} Returns the new sorted array.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'fred',   'age': 48 },\n     *   { 'user': 'barney', 'age': 36 },\n     *   { 'user': 'fred',   'age': 40 },\n     *   { 'user': 'barney', 'age': 34 }\n     * ];\n     *\n     * _.sortBy(users, [function(o) { return o.user; }]);\n     * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]\n     *\n     * _.sortBy(users, ['user', 'age']);\n     * // => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]]\n     */\n    var sortBy = baseRest(function(collection, iteratees) {\n      if (collection == null) {\n        return [];\n      }\n      var length = iteratees.length;\n      if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {\n        iteratees = [];\n      } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {\n        iteratees = [iteratees[0]];\n      }\n      return baseOrderBy(collection, baseFlatten(iteratees, 1), []);\n    });\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Gets the timestamp of the number of milliseconds that have elapsed since\n     * the Unix epoch (1 January 1970 00:00:00 UTC).\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Date\n     * @returns {number} Returns the timestamp.\n     * @example\n     *\n     * _.defer(function(stamp) {\n     *   console.log(_.now() - stamp);\n     * }, _.now());\n     * // => Logs the number of milliseconds it took for the deferred invocation.\n     */\n    var now = ctxNow || function() {\n      return root.Date.now();\n    };\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * The opposite of `_.before`; this method creates a function that invokes\n     * `func` once it's called `n` or more times.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {number} n The number of calls before `func` is invoked.\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * var saves = ['profile', 'settings'];\n     *\n     * var done = _.after(saves.length, function() {\n     *   console.log('done saving!');\n     * });\n     *\n     * _.forEach(saves, function(type) {\n     *   asyncSave({ 'type': type, 'complete': done });\n     * });\n     * // => Logs 'done saving!' after the two async saves have completed.\n     */\n    function after(n, func) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      n = toInteger(n);\n      return function() {\n        if (--n < 1) {\n          return func.apply(this, arguments);\n        }\n      };\n    }\n\n    /**\n     * Creates a function that invokes `func`, with up to `n` arguments,\n     * ignoring any additional arguments.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} func The function to cap arguments for.\n     * @param {number} [n=func.length] The arity cap.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the new capped function.\n     * @example\n     *\n     * _.map(['6', '8', '10'], _.ary(parseInt, 1));\n     * // => [6, 8, 10]\n     */\n    function ary(func, n, guard) {\n      n = guard ? undefined : n;\n      n = (func && n == null) ? func.length : n;\n      return createWrap(func, WRAP_ARY_FLAG, undefined, undefined, undefined, undefined, n);\n    }\n\n    /**\n     * Creates a function that invokes `func`, with the `this` binding and arguments\n     * of the created function, while it's called less than `n` times. Subsequent\n     * calls to the created function return the result of the last `func` invocation.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {number} n The number of calls at which `func` is no longer invoked.\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * jQuery(element).on('click', _.before(5, addContactToList));\n     * // => Allows adding up to 4 contacts to the list.\n     */\n    function before(n, func) {\n      var result;\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      n = toInteger(n);\n      return function() {\n        if (--n > 0) {\n          result = func.apply(this, arguments);\n        }\n        if (n <= 1) {\n          func = undefined;\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Creates a function that invokes `func` with the `this` binding of `thisArg`\n     * and `partials` prepended to the arguments it receives.\n     *\n     * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,\n     * may be used as a placeholder for partially applied arguments.\n     *\n     * **Note:** Unlike native `Function#bind`, this method doesn't set the \"length\"\n     * property of bound functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to bind.\n     * @param {*} thisArg The `this` binding of `func`.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new bound function.\n     * @example\n     *\n     * function greet(greeting, punctuation) {\n     *   return greeting + ' ' + this.user + punctuation;\n     * }\n     *\n     * var object = { 'user': 'fred' };\n     *\n     * var bound = _.bind(greet, object, 'hi');\n     * bound('!');\n     * // => 'hi fred!'\n     *\n     * // Bound with placeholders.\n     * var bound = _.bind(greet, object, _, '!');\n     * bound('hi');\n     * // => 'hi fred!'\n     */\n    var bind = baseRest(function(func, thisArg, partials) {\n      var bitmask = WRAP_BIND_FLAG;\n      if (partials.length) {\n        var holders = replaceHolders(partials, getHolder(bind));\n        bitmask |= WRAP_PARTIAL_FLAG;\n      }\n      return createWrap(func, bitmask, thisArg, partials, holders);\n    });\n\n    /**\n     * Creates a function that invokes the method at `object[key]` with `partials`\n     * prepended to the arguments it receives.\n     *\n     * This method differs from `_.bind` by allowing bound functions to reference\n     * methods that may be redefined or don't yet exist. See\n     * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern)\n     * for more details.\n     *\n     * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for partially applied arguments.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.10.0\n     * @category Function\n     * @param {Object} object The object to invoke the method on.\n     * @param {string} key The key of the method.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new bound function.\n     * @example\n     *\n     * var object = {\n     *   'user': 'fred',\n     *   'greet': function(greeting, punctuation) {\n     *     return greeting + ' ' + this.user + punctuation;\n     *   }\n     * };\n     *\n     * var bound = _.bindKey(object, 'greet', 'hi');\n     * bound('!');\n     * // => 'hi fred!'\n     *\n     * object.greet = function(greeting, punctuation) {\n     *   return greeting + 'ya ' + this.user + punctuation;\n     * };\n     *\n     * bound('!');\n     * // => 'hiya fred!'\n     *\n     * // Bound with placeholders.\n     * var bound = _.bindKey(object, 'greet', _, '!');\n     * bound('hi');\n     * // => 'hiya fred!'\n     */\n    var bindKey = baseRest(function(object, key, partials) {\n      var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;\n      if (partials.length) {\n        var holders = replaceHolders(partials, getHolder(bindKey));\n        bitmask |= WRAP_PARTIAL_FLAG;\n      }\n      return createWrap(key, bitmask, object, partials, holders);\n    });\n\n    /**\n     * Creates a function that accepts arguments of `func` and either invokes\n     * `func` returning its result, if at least `arity` number of arguments have\n     * been provided, or returns a function that accepts the remaining `func`\n     * arguments, and so on. The arity of `func` may be specified if `func.length`\n     * is not sufficient.\n     *\n     * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,\n     * may be used as a placeholder for provided arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of curried functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Function\n     * @param {Function} func The function to curry.\n     * @param {number} [arity=func.length] The arity of `func`.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the new curried function.\n     * @example\n     *\n     * var abc = function(a, b, c) {\n     *   return [a, b, c];\n     * };\n     *\n     * var curried = _.curry(abc);\n     *\n     * curried(1)(2)(3);\n     * // => [1, 2, 3]\n     *\n     * curried(1, 2)(3);\n     * // => [1, 2, 3]\n     *\n     * curried(1, 2, 3);\n     * // => [1, 2, 3]\n     *\n     * // Curried with placeholders.\n     * curried(1)(_, 3)(2);\n     * // => [1, 2, 3]\n     */\n    function curry(func, arity, guard) {\n      arity = guard ? undefined : arity;\n      var result = createWrap(func, WRAP_CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity);\n      result.placeholder = curry.placeholder;\n      return result;\n    }\n\n    /**\n     * This method is like `_.curry` except that arguments are applied to `func`\n     * in the manner of `_.partialRight` instead of `_.partial`.\n     *\n     * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for provided arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of curried functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} func The function to curry.\n     * @param {number} [arity=func.length] The arity of `func`.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the new curried function.\n     * @example\n     *\n     * var abc = function(a, b, c) {\n     *   return [a, b, c];\n     * };\n     *\n     * var curried = _.curryRight(abc);\n     *\n     * curried(3)(2)(1);\n     * // => [1, 2, 3]\n     *\n     * curried(2, 3)(1);\n     * // => [1, 2, 3]\n     *\n     * curried(1, 2, 3);\n     * // => [1, 2, 3]\n     *\n     * // Curried with placeholders.\n     * curried(3)(1, _)(2);\n     * // => [1, 2, 3]\n     */\n    function curryRight(func, arity, guard) {\n      arity = guard ? undefined : arity;\n      var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity);\n      result.placeholder = curryRight.placeholder;\n      return result;\n    }\n\n    /**\n     * Creates a debounced function that delays invoking `func` until after `wait`\n     * milliseconds have elapsed since the last time the debounced function was\n     * invoked. The debounced function comes with a `cancel` method to cancel\n     * delayed `func` invocations and a `flush` method to immediately invoke them.\n     * Provide `options` to indicate whether `func` should be invoked on the\n     * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n     * with the last arguments provided to the debounced function. Subsequent\n     * calls to the debounced function return the result of the last `func`\n     * invocation.\n     *\n     * **Note:** If `leading` and `trailing` options are `true`, `func` is\n     * invoked on the trailing edge of the timeout only if the debounced function\n     * is invoked more than once during the `wait` timeout.\n     *\n     * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n     * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n     *\n     * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n     * for details over the differences between `_.debounce` and `_.throttle`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to debounce.\n     * @param {number} [wait=0] The number of milliseconds to delay.\n     * @param {Object} [options={}] The options object.\n     * @param {boolean} [options.leading=false]\n     *  Specify invoking on the leading edge of the timeout.\n     * @param {number} [options.maxWait]\n     *  The maximum time `func` is allowed to be delayed before it's invoked.\n     * @param {boolean} [options.trailing=true]\n     *  Specify invoking on the trailing edge of the timeout.\n     * @returns {Function} Returns the new debounced function.\n     * @example\n     *\n     * // Avoid costly calculations while the window size is in flux.\n     * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n     *\n     * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n     * jQuery(element).on('click', _.debounce(sendMail, 300, {\n     *   'leading': true,\n     *   'trailing': false\n     * }));\n     *\n     * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n     * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n     * var source = new EventSource('/stream');\n     * jQuery(source).on('message', debounced);\n     *\n     * // Cancel the trailing debounced invocation.\n     * jQuery(window).on('popstate', debounced.cancel);\n     */\n    function debounce(func, wait, options) {\n      var lastArgs,\n          lastThis,\n          maxWait,\n          result,\n          timerId,\n          lastCallTime,\n          lastInvokeTime = 0,\n          leading = false,\n          maxing = false,\n          trailing = true;\n\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      wait = toNumber(wait) || 0;\n      if (isObject(options)) {\n        leading = !!options.leading;\n        maxing = 'maxWait' in options;\n        maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n        trailing = 'trailing' in options ? !!options.trailing : trailing;\n      }\n\n      function invokeFunc(time) {\n        var args = lastArgs,\n            thisArg = lastThis;\n\n        lastArgs = lastThis = undefined;\n        lastInvokeTime = time;\n        result = func.apply(thisArg, args);\n        return result;\n      }\n\n      function leadingEdge(time) {\n        // Reset any `maxWait` timer.\n        lastInvokeTime = time;\n        // Start the timer for the trailing edge.\n        timerId = setTimeout(timerExpired, wait);\n        // Invoke the leading edge.\n        return leading ? invokeFunc(time) : result;\n      }\n\n      function remainingWait(time) {\n        var timeSinceLastCall = time - lastCallTime,\n            timeSinceLastInvoke = time - lastInvokeTime,\n            result = wait - timeSinceLastCall;\n\n        return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;\n      }\n\n      function shouldInvoke(time) {\n        var timeSinceLastCall = time - lastCallTime,\n            timeSinceLastInvoke = time - lastInvokeTime;\n\n        // Either this is the first call, activity has stopped and we're at the\n        // trailing edge, the system time has gone backwards and we're treating\n        // it as the trailing edge, or we've hit the `maxWait` limit.\n        return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n          (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n      }\n\n      function timerExpired() {\n        var time = now();\n        if (shouldInvoke(time)) {\n          return trailingEdge(time);\n        }\n        // Restart the timer.\n        timerId = setTimeout(timerExpired, remainingWait(time));\n      }\n\n      function trailingEdge(time) {\n        timerId = undefined;\n\n        // Only invoke if we have `lastArgs` which means `func` has been\n        // debounced at least once.\n        if (trailing && lastArgs) {\n          return invokeFunc(time);\n        }\n        lastArgs = lastThis = undefined;\n        return result;\n      }\n\n      function cancel() {\n        if (timerId !== undefined) {\n          clearTimeout(timerId);\n        }\n        lastInvokeTime = 0;\n        lastArgs = lastCallTime = lastThis = timerId = undefined;\n      }\n\n      function flush() {\n        return timerId === undefined ? result : trailingEdge(now());\n      }\n\n      function debounced() {\n        var time = now(),\n            isInvoking = shouldInvoke(time);\n\n        lastArgs = arguments;\n        lastThis = this;\n        lastCallTime = time;\n\n        if (isInvoking) {\n          if (timerId === undefined) {\n            return leadingEdge(lastCallTime);\n          }\n          if (maxing) {\n            // Handle invocations in a tight loop.\n            timerId = setTimeout(timerExpired, wait);\n            return invokeFunc(lastCallTime);\n          }\n        }\n        if (timerId === undefined) {\n          timerId = setTimeout(timerExpired, wait);\n        }\n        return result;\n      }\n      debounced.cancel = cancel;\n      debounced.flush = flush;\n      return debounced;\n    }\n\n    /**\n     * Defers invoking the `func` until the current call stack has cleared. Any\n     * additional arguments are provided to `func` when it's invoked.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to defer.\n     * @param {...*} [args] The arguments to invoke `func` with.\n     * @returns {number} Returns the timer id.\n     * @example\n     *\n     * _.defer(function(text) {\n     *   console.log(text);\n     * }, 'deferred');\n     * // => Logs 'deferred' after one millisecond.\n     */\n    var defer = baseRest(function(func, args) {\n      return baseDelay(func, 1, args);\n    });\n\n    /**\n     * Invokes `func` after `wait` milliseconds. Any additional arguments are\n     * provided to `func` when it's invoked.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to delay.\n     * @param {number} wait The number of milliseconds to delay invocation.\n     * @param {...*} [args] The arguments to invoke `func` with.\n     * @returns {number} Returns the timer id.\n     * @example\n     *\n     * _.delay(function(text) {\n     *   console.log(text);\n     * }, 1000, 'later');\n     * // => Logs 'later' after one second.\n     */\n    var delay = baseRest(function(func, wait, args) {\n      return baseDelay(func, toNumber(wait) || 0, args);\n    });\n\n    /**\n     * Creates a function that invokes `func` with arguments reversed.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Function\n     * @param {Function} func The function to flip arguments for.\n     * @returns {Function} Returns the new flipped function.\n     * @example\n     *\n     * var flipped = _.flip(function() {\n     *   return _.toArray(arguments);\n     * });\n     *\n     * flipped('a', 'b', 'c', 'd');\n     * // => ['d', 'c', 'b', 'a']\n     */\n    function flip(func) {\n      return createWrap(func, WRAP_FLIP_FLAG);\n    }\n\n    /**\n     * Creates a function that memoizes the result of `func`. If `resolver` is\n     * provided, it determines the cache key for storing the result based on the\n     * arguments provided to the memoized function. By default, the first argument\n     * provided to the memoized function is used as the map cache key. The `func`\n     * is invoked with the `this` binding of the memoized function.\n     *\n     * **Note:** The cache is exposed as the `cache` property on the memoized\n     * function. Its creation may be customized by replacing the `_.memoize.Cache`\n     * constructor with one whose instances implement the\n     * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n     * method interface of `clear`, `delete`, `get`, `has`, and `set`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to have its output memoized.\n     * @param {Function} [resolver] The function to resolve the cache key.\n     * @returns {Function} Returns the new memoized function.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2 };\n     * var other = { 'c': 3, 'd': 4 };\n     *\n     * var values = _.memoize(_.values);\n     * values(object);\n     * // => [1, 2]\n     *\n     * values(other);\n     * // => [3, 4]\n     *\n     * object.a = 2;\n     * values(object);\n     * // => [1, 2]\n     *\n     * // Modify the result cache.\n     * values.cache.set(object, ['a', 'b']);\n     * values(object);\n     * // => ['a', 'b']\n     *\n     * // Replace `_.memoize.Cache`.\n     * _.memoize.Cache = WeakMap;\n     */\n    function memoize(func, resolver) {\n      if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      var memoized = function() {\n        var args = arguments,\n            key = resolver ? resolver.apply(this, args) : args[0],\n            cache = memoized.cache;\n\n        if (cache.has(key)) {\n          return cache.get(key);\n        }\n        var result = func.apply(this, args);\n        memoized.cache = cache.set(key, result) || cache;\n        return result;\n      };\n      memoized.cache = new (memoize.Cache || MapCache);\n      return memoized;\n    }\n\n    // Expose `MapCache`.\n    memoize.Cache = MapCache;\n\n    /**\n     * Creates a function that negates the result of the predicate `func`. The\n     * `func` predicate is invoked with the `this` binding and arguments of the\n     * created function.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} predicate The predicate to negate.\n     * @returns {Function} Returns the new negated function.\n     * @example\n     *\n     * function isEven(n) {\n     *   return n % 2 == 0;\n     * }\n     *\n     * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));\n     * // => [1, 3, 5]\n     */\n    function negate(predicate) {\n      if (typeof predicate != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      return function() {\n        var args = arguments;\n        switch (args.length) {\n          case 0: return !predicate.call(this);\n          case 1: return !predicate.call(this, args[0]);\n          case 2: return !predicate.call(this, args[0], args[1]);\n          case 3: return !predicate.call(this, args[0], args[1], args[2]);\n        }\n        return !predicate.apply(this, args);\n      };\n    }\n\n    /**\n     * Creates a function that is restricted to invoking `func` once. Repeat calls\n     * to the function return the value of the first invocation. The `func` is\n     * invoked with the `this` binding and arguments of the created function.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * var initialize = _.once(createApplication);\n     * initialize();\n     * initialize();\n     * // => `createApplication` is invoked once\n     */\n    function once(func) {\n      return before(2, func);\n    }\n\n    /**\n     * Creates a function that invokes `func` with its arguments transformed.\n     *\n     * @static\n     * @since 4.0.0\n     * @memberOf _\n     * @category Function\n     * @param {Function} func The function to wrap.\n     * @param {...(Function|Function[])} [transforms=[_.identity]]\n     *  The argument transforms.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * function doubled(n) {\n     *   return n * 2;\n     * }\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var func = _.overArgs(function(x, y) {\n     *   return [x, y];\n     * }, [square, doubled]);\n     *\n     * func(9, 3);\n     * // => [81, 6]\n     *\n     * func(10, 5);\n     * // => [100, 10]\n     */\n    var overArgs = castRest(function(func, transforms) {\n      transforms = (transforms.length == 1 && isArray(transforms[0]))\n        ? arrayMap(transforms[0], baseUnary(getIteratee()))\n        : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee()));\n\n      var funcsLength = transforms.length;\n      return baseRest(function(args) {\n        var index = -1,\n            length = nativeMin(args.length, funcsLength);\n\n        while (++index < length) {\n          args[index] = transforms[index].call(this, args[index]);\n        }\n        return apply(func, this, args);\n      });\n    });\n\n    /**\n     * Creates a function that invokes `func` with `partials` prepended to the\n     * arguments it receives. This method is like `_.bind` except it does **not**\n     * alter the `this` binding.\n     *\n     * The `_.partial.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for partially applied arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of partially\n     * applied functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.2.0\n     * @category Function\n     * @param {Function} func The function to partially apply arguments to.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new partially applied function.\n     * @example\n     *\n     * function greet(greeting, name) {\n     *   return greeting + ' ' + name;\n     * }\n     *\n     * var sayHelloTo = _.partial(greet, 'hello');\n     * sayHelloTo('fred');\n     * // => 'hello fred'\n     *\n     * // Partially applied with placeholders.\n     * var greetFred = _.partial(greet, _, 'fred');\n     * greetFred('hi');\n     * // => 'hi fred'\n     */\n    var partial = baseRest(function(func, partials) {\n      var holders = replaceHolders(partials, getHolder(partial));\n      return createWrap(func, WRAP_PARTIAL_FLAG, undefined, partials, holders);\n    });\n\n    /**\n     * This method is like `_.partial` except that partially applied arguments\n     * are appended to the arguments it receives.\n     *\n     * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for partially applied arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of partially\n     * applied functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.0.0\n     * @category Function\n     * @param {Function} func The function to partially apply arguments to.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new partially applied function.\n     * @example\n     *\n     * function greet(greeting, name) {\n     *   return greeting + ' ' + name;\n     * }\n     *\n     * var greetFred = _.partialRight(greet, 'fred');\n     * greetFred('hi');\n     * // => 'hi fred'\n     *\n     * // Partially applied with placeholders.\n     * var sayHelloTo = _.partialRight(greet, 'hello', _);\n     * sayHelloTo('fred');\n     * // => 'hello fred'\n     */\n    var partialRight = baseRest(function(func, partials) {\n      var holders = replaceHolders(partials, getHolder(partialRight));\n      return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined, partials, holders);\n    });\n\n    /**\n     * Creates a function that invokes `func` with arguments arranged according\n     * to the specified `indexes` where the argument value at the first index is\n     * provided as the first argument, the argument value at the second index is\n     * provided as the second argument, and so on.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} func The function to rearrange arguments for.\n     * @param {...(number|number[])} indexes The arranged argument indexes.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var rearged = _.rearg(function(a, b, c) {\n     *   return [a, b, c];\n     * }, [2, 0, 1]);\n     *\n     * rearged('b', 'c', 'a')\n     * // => ['a', 'b', 'c']\n     */\n    var rearg = flatRest(function(func, indexes) {\n      return createWrap(func, WRAP_REARG_FLAG, undefined, undefined, undefined, indexes);\n    });\n\n    /**\n     * Creates a function that invokes `func` with the `this` binding of the\n     * created function and arguments from `start` and beyond provided as\n     * an array.\n     *\n     * **Note:** This method is based on the\n     * [rest parameter](https://mdn.io/rest_parameters).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Function\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     * @example\n     *\n     * var say = _.rest(function(what, names) {\n     *   return what + ' ' + _.initial(names).join(', ') +\n     *     (_.size(names) > 1 ? ', & ' : '') + _.last(names);\n     * });\n     *\n     * say('hello', 'fred', 'barney', 'pebbles');\n     * // => 'hello fred, barney, & pebbles'\n     */\n    function rest(func, start) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      start = start === undefined ? start : toInteger(start);\n      return baseRest(func, start);\n    }\n\n    /**\n     * Creates a function that invokes `func` with the `this` binding of the\n     * create function and an array of arguments much like\n     * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply).\n     *\n     * **Note:** This method is based on the\n     * [spread operator](https://mdn.io/spread_operator).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.2.0\n     * @category Function\n     * @param {Function} func The function to spread arguments over.\n     * @param {number} [start=0] The start position of the spread.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var say = _.spread(function(who, what) {\n     *   return who + ' says ' + what;\n     * });\n     *\n     * say(['fred', 'hello']);\n     * // => 'fred says hello'\n     *\n     * var numbers = Promise.all([\n     *   Promise.resolve(40),\n     *   Promise.resolve(36)\n     * ]);\n     *\n     * numbers.then(_.spread(function(x, y) {\n     *   return x + y;\n     * }));\n     * // => a Promise of 76\n     */\n    function spread(func, start) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      start = start == null ? 0 : nativeMax(toInteger(start), 0);\n      return baseRest(function(args) {\n        var array = args[start],\n            otherArgs = castSlice(args, 0, start);\n\n        if (array) {\n          arrayPush(otherArgs, array);\n        }\n        return apply(func, this, otherArgs);\n      });\n    }\n\n    /**\n     * Creates a throttled function that only invokes `func` at most once per\n     * every `wait` milliseconds. The throttled function comes with a `cancel`\n     * method to cancel delayed `func` invocations and a `flush` method to\n     * immediately invoke them. Provide `options` to indicate whether `func`\n     * should be invoked on the leading and/or trailing edge of the `wait`\n     * timeout. The `func` is invoked with the last arguments provided to the\n     * throttled function. Subsequent calls to the throttled function return the\n     * result of the last `func` invocation.\n     *\n     * **Note:** If `leading` and `trailing` options are `true`, `func` is\n     * invoked on the trailing edge of the timeout only if the throttled function\n     * is invoked more than once during the `wait` timeout.\n     *\n     * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n     * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n     *\n     * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n     * for details over the differences between `_.throttle` and `_.debounce`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to throttle.\n     * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n     * @param {Object} [options={}] The options object.\n     * @param {boolean} [options.leading=true]\n     *  Specify invoking on the leading edge of the timeout.\n     * @param {boolean} [options.trailing=true]\n     *  Specify invoking on the trailing edge of the timeout.\n     * @returns {Function} Returns the new throttled function.\n     * @example\n     *\n     * // Avoid excessively updating the position while scrolling.\n     * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n     *\n     * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n     * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n     * jQuery(element).on('click', throttled);\n     *\n     * // Cancel the trailing throttled invocation.\n     * jQuery(window).on('popstate', throttled.cancel);\n     */\n    function throttle(func, wait, options) {\n      var leading = true,\n          trailing = true;\n\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      if (isObject(options)) {\n        leading = 'leading' in options ? !!options.leading : leading;\n        trailing = 'trailing' in options ? !!options.trailing : trailing;\n      }\n      return debounce(func, wait, {\n        'leading': leading,\n        'maxWait': wait,\n        'trailing': trailing\n      });\n    }\n\n    /**\n     * Creates a function that accepts up to one argument, ignoring any\n     * additional arguments.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Function\n     * @param {Function} func The function to cap arguments for.\n     * @returns {Function} Returns the new capped function.\n     * @example\n     *\n     * _.map(['6', '8', '10'], _.unary(parseInt));\n     * // => [6, 8, 10]\n     */\n    function unary(func) {\n      return ary(func, 1);\n    }\n\n    /**\n     * Creates a function that provides `value` to `wrapper` as its first\n     * argument. Any additional arguments provided to the function are appended\n     * to those provided to the `wrapper`. The wrapper is invoked with the `this`\n     * binding of the created function.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {*} value The value to wrap.\n     * @param {Function} [wrapper=identity] The wrapper function.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var p = _.wrap(_.escape, function(func, text) {\n     *   return '<p>' + func(text) + '</p>';\n     * });\n     *\n     * p('fred, barney, & pebbles');\n     * // => '<p>fred, barney, &amp; pebbles</p>'\n     */\n    function wrap(value, wrapper) {\n      return partial(castFunction(wrapper), value);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Casts `value` as an array if it's not one.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.4.0\n     * @category Lang\n     * @param {*} value The value to inspect.\n     * @returns {Array} Returns the cast array.\n     * @example\n     *\n     * _.castArray(1);\n     * // => [1]\n     *\n     * _.castArray({ 'a': 1 });\n     * // => [{ 'a': 1 }]\n     *\n     * _.castArray('abc');\n     * // => ['abc']\n     *\n     * _.castArray(null);\n     * // => [null]\n     *\n     * _.castArray(undefined);\n     * // => [undefined]\n     *\n     * _.castArray();\n     * // => []\n     *\n     * var array = [1, 2, 3];\n     * console.log(_.castArray(array) === array);\n     * // => true\n     */\n    function castArray() {\n      if (!arguments.length) {\n        return [];\n      }\n      var value = arguments[0];\n      return isArray(value) ? value : [value];\n    }\n\n    /**\n     * Creates a shallow clone of `value`.\n     *\n     * **Note:** This method is loosely based on the\n     * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)\n     * and supports cloning arrays, array buffers, booleans, date objects, maps,\n     * numbers, `Object` objects, regexes, sets, strings, symbols, and typed\n     * arrays. The own enumerable properties of `arguments` objects are cloned\n     * as plain objects. An empty object is returned for uncloneable values such\n     * as error objects, functions, DOM nodes, and WeakMaps.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to clone.\n     * @returns {*} Returns the cloned value.\n     * @see _.cloneDeep\n     * @example\n     *\n     * var objects = [{ 'a': 1 }, { 'b': 2 }];\n     *\n     * var shallow = _.clone(objects);\n     * console.log(shallow[0] === objects[0]);\n     * // => true\n     */\n    function clone(value) {\n      return baseClone(value, CLONE_SYMBOLS_FLAG);\n    }\n\n    /**\n     * This method is like `_.clone` except that it accepts `customizer` which\n     * is invoked to produce the cloned value. If `customizer` returns `undefined`,\n     * cloning is handled by the method instead. The `customizer` is invoked with\n     * up to four arguments; (value [, index|key, object, stack]).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to clone.\n     * @param {Function} [customizer] The function to customize cloning.\n     * @returns {*} Returns the cloned value.\n     * @see _.cloneDeepWith\n     * @example\n     *\n     * function customizer(value) {\n     *   if (_.isElement(value)) {\n     *     return value.cloneNode(false);\n     *   }\n     * }\n     *\n     * var el = _.cloneWith(document.body, customizer);\n     *\n     * console.log(el === document.body);\n     * // => false\n     * console.log(el.nodeName);\n     * // => 'BODY'\n     * console.log(el.childNodes.length);\n     * // => 0\n     */\n    function cloneWith(value, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);\n    }\n\n    /**\n     * This method is like `_.clone` except that it recursively clones `value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.0.0\n     * @category Lang\n     * @param {*} value The value to recursively clone.\n     * @returns {*} Returns the deep cloned value.\n     * @see _.clone\n     * @example\n     *\n     * var objects = [{ 'a': 1 }, { 'b': 2 }];\n     *\n     * var deep = _.cloneDeep(objects);\n     * console.log(deep[0] === objects[0]);\n     * // => false\n     */\n    function cloneDeep(value) {\n      return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);\n    }\n\n    /**\n     * This method is like `_.cloneWith` except that it recursively clones `value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to recursively clone.\n     * @param {Function} [customizer] The function to customize cloning.\n     * @returns {*} Returns the deep cloned value.\n     * @see _.cloneWith\n     * @example\n     *\n     * function customizer(value) {\n     *   if (_.isElement(value)) {\n     *     return value.cloneNode(true);\n     *   }\n     * }\n     *\n     * var el = _.cloneDeepWith(document.body, customizer);\n     *\n     * console.log(el === document.body);\n     * // => false\n     * console.log(el.nodeName);\n     * // => 'BODY'\n     * console.log(el.childNodes.length);\n     * // => 20\n     */\n    function cloneDeepWith(value, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);\n    }\n\n    /**\n     * Checks if `object` conforms to `source` by invoking the predicate\n     * properties of `source` with the corresponding property values of `object`.\n     *\n     * **Note:** This method is equivalent to `_.conforms` when `source` is\n     * partially applied.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.14.0\n     * @category Lang\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {boolean} Returns `true` if `object` conforms, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2 };\n     *\n     * _.conformsTo(object, { 'b': function(n) { return n > 1; } });\n     * // => true\n     *\n     * _.conformsTo(object, { 'b': function(n) { return n > 2; } });\n     * // => false\n     */\n    function conformsTo(object, source) {\n      return source == null || baseConformsTo(object, source, keys(source));\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     */\n    function eq(value, other) {\n      return value === other || (value !== value && other !== other);\n    }\n\n    /**\n     * Checks if `value` is greater than `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.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 `value` is greater than `other`,\n     *  else `false`.\n     * @see _.lt\n     * @example\n     *\n     * _.gt(3, 1);\n     * // => true\n     *\n     * _.gt(3, 3);\n     * // => false\n     *\n     * _.gt(1, 3);\n     * // => false\n     */\n    var gt = createRelationalOperation(baseGt);\n\n    /**\n     * Checks if `value` is greater than or equal to `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.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 `value` is greater than or equal to\n     *  `other`, else `false`.\n     * @see _.lte\n     * @example\n     *\n     * _.gte(3, 1);\n     * // => true\n     *\n     * _.gte(3, 3);\n     * // => true\n     *\n     * _.gte(1, 3);\n     * // => false\n     */\n    var gte = createRelationalOperation(function(value, other) {\n      return value >= 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     */\n    var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n      return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n        !propertyIsEnumerable.call(value, 'callee');\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     */\n    var isArray = Array.isArray;\n\n    /**\n     * Checks if `value` is classified as an `ArrayBuffer` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.\n     * @example\n     *\n     * _.isArrayBuffer(new ArrayBuffer(2));\n     * // => true\n     *\n     * _.isArrayBuffer(new Array(2));\n     * // => false\n     */\n    var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;\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     */\n    function 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     */\n    function isArrayLikeObject(value) {\n      return isObjectLike(value) && isArrayLike(value);\n    }\n\n    /**\n     * Checks if `value` is classified as a boolean primitive or 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 boolean, else `false`.\n     * @example\n     *\n     * _.isBoolean(false);\n     * // => true\n     *\n     * _.isBoolean(null);\n     * // => false\n     */\n    function isBoolean(value) {\n      return value === true || value === false ||\n        (isObjectLike(value) && baseGetTag(value) == boolTag);\n    }\n\n    /**\n     * Checks if `value` is a buffer.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n     * @example\n     *\n     * _.isBuffer(new Buffer(2));\n     * // => true\n     *\n     * _.isBuffer(new Uint8Array(2));\n     * // => false\n     */\n    var isBuffer = nativeIsBuffer || stubFalse;\n\n    /**\n     * Checks if `value` is classified as a `Date` 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 date object, else `false`.\n     * @example\n     *\n     * _.isDate(new Date);\n     * // => true\n     *\n     * _.isDate('Mon April 23 2012');\n     * // => false\n     */\n    var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;\n\n    /**\n     * Checks if `value` is likely a DOM element.\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 DOM element, else `false`.\n     * @example\n     *\n     * _.isElement(document.body);\n     * // => true\n     *\n     * _.isElement('<body>');\n     * // => false\n     */\n    function isElement(value) {\n      return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);\n    }\n\n    /**\n     * Checks if `value` is an empty object, collection, map, or set.\n     *\n     * Objects are considered empty if they have no own enumerable string keyed\n     * properties.\n     *\n     * Array-like values such as `arguments` objects, arrays, buffers, strings, or\n     * jQuery-like collections are considered empty if they have a `length` of `0`.\n     * Similarly, maps and sets are considered empty if they have a `size` of `0`.\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 empty, else `false`.\n     * @example\n     *\n     * _.isEmpty(null);\n     * // => true\n     *\n     * _.isEmpty(true);\n     * // => true\n     *\n     * _.isEmpty(1);\n     * // => true\n     *\n     * _.isEmpty([1, 2, 3]);\n     * // => false\n     *\n     * _.isEmpty({ 'a': 1 });\n     * // => false\n     */\n    function isEmpty(value) {\n      if (value == null) {\n        return true;\n      }\n      if (isArrayLike(value) &&\n          (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||\n            isBuffer(value) || isTypedArray(value) || isArguments(value))) {\n        return !value.length;\n      }\n      var tag = getTag(value);\n      if (tag == mapTag || tag == setTag) {\n        return !value.size;\n      }\n      if (isPrototype(value)) {\n        return !baseKeys(value).length;\n      }\n      for (var key in value) {\n        if (hasOwnProperty.call(value, key)) {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    /**\n     * Performs a deep comparison between two values to determine if they are\n     * equivalent.\n     *\n     * **Note:** This method supports comparing arrays, array buffers, booleans,\n     * date objects, error objects, maps, numbers, `Object` objects, regexes,\n     * sets, strings, symbols, and typed arrays. `Object` objects are compared\n     * by their own, not inherited, enumerable properties. Functions and DOM\n     * nodes are compared by strict equality, i.e. `===`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.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     * _.isEqual(object, other);\n     * // => true\n     *\n     * object === other;\n     * // => false\n     */\n    function isEqual(value, other) {\n      return baseIsEqual(value, other);\n    }\n\n    /**\n     * This method is like `_.isEqual` except that it accepts `customizer` which\n     * is invoked to compare values. If `customizer` returns `undefined`, comparisons\n     * are handled by the method instead. The `customizer` is invoked with up to\n     * six arguments: (objValue, othValue [, index|key, object, other, stack]).\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     * @param {Function} [customizer] The function to customize comparisons.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     * @example\n     *\n     * function isGreeting(value) {\n     *   return /^h(?:i|ello)$/.test(value);\n     * }\n     *\n     * function customizer(objValue, othValue) {\n     *   if (isGreeting(objValue) && isGreeting(othValue)) {\n     *     return true;\n     *   }\n     * }\n     *\n     * var array = ['hello', 'goodbye'];\n     * var other = ['hi', 'goodbye'];\n     *\n     * _.isEqualWith(array, other, customizer);\n     * // => true\n     */\n    function isEqualWith(value, other, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      var result = customizer ? customizer(value, other) : undefined;\n      return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result;\n    }\n\n    /**\n     * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,\n     * `SyntaxError`, `TypeError`, or `URIError` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an error object, else `false`.\n     * @example\n     *\n     * _.isError(new Error);\n     * // => true\n     *\n     * _.isError(Error);\n     * // => false\n     */\n    function isError(value) {\n      if (!isObjectLike(value)) {\n        return false;\n      }\n      var tag = baseGetTag(value);\n      return tag == errorTag || tag == domExcTag ||\n        (typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value));\n    }\n\n    /**\n     * Checks if `value` is a finite primitive number.\n     *\n     * **Note:** This method is based on\n     * [`Number.isFinite`](https://mdn.io/Number/isFinite).\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 finite number, else `false`.\n     * @example\n     *\n     * _.isFinite(3);\n     * // => true\n     *\n     * _.isFinite(Number.MIN_VALUE);\n     * // => true\n     *\n     * _.isFinite(Infinity);\n     * // => false\n     *\n     * _.isFinite('3');\n     * // => false\n     */\n    function isFinite(value) {\n      return typeof value == 'number' && nativeIsFinite(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     */\n    function isFunction(value) {\n      if (!isObject(value)) {\n        return false;\n      }\n      // The use of `Object#toString` avoids issues with the `typeof` operator\n      // in Safari 9 which returns 'object' for typed arrays and other constructors.\n      var tag = baseGetTag(value);\n      return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n    }\n\n    /**\n     * Checks if `value` is an integer.\n     *\n     * **Note:** This method is based on\n     * [`Number.isInteger`](https://mdn.io/Number/isInteger).\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 integer, else `false`.\n     * @example\n     *\n     * _.isInteger(3);\n     * // => true\n     *\n     * _.isInteger(Number.MIN_VALUE);\n     * // => false\n     *\n     * _.isInteger(Infinity);\n     * // => false\n     *\n     * _.isInteger('3');\n     * // => false\n     */\n    function isInteger(value) {\n      return typeof value == 'number' && value == toInteger(value);\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     */\n    function 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     */\n    function isObject(value) {\n      var type = typeof value;\n      return value != null && (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     */\n    function isObjectLike(value) {\n      return value != null && typeof value == 'object';\n    }\n\n    /**\n     * Checks if `value` is classified as a `Map` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n     * @example\n     *\n     * _.isMap(new Map);\n     * // => true\n     *\n     * _.isMap(new WeakMap);\n     * // => false\n     */\n    var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;\n\n    /**\n     * Performs a partial deep comparison between `object` and `source` to\n     * determine if `object` contains equivalent property values.\n     *\n     * **Note:** This method is equivalent to `_.matches` when `source` is\n     * partially applied.\n     *\n     * Partial comparisons will match empty array and empty object `source`\n     * values against any array or object value, respectively. See `_.isEqual`\n     * for a list of supported value comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property values to match.\n     * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2 };\n     *\n     * _.isMatch(object, { 'b': 2 });\n     * // => true\n     *\n     * _.isMatch(object, { 'b': 1 });\n     * // => false\n     */\n    function isMatch(object, source) {\n      return object === source || baseIsMatch(object, source, getMatchData(source));\n    }\n\n    /**\n     * This method is like `_.isMatch` except that it accepts `customizer` which\n     * is invoked to compare values. If `customizer` returns `undefined`, comparisons\n     * are handled by the method instead. The `customizer` is invoked with five\n     * arguments: (objValue, srcValue, index|key, object, source).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property values to match.\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n     * @example\n     *\n     * function isGreeting(value) {\n     *   return /^h(?:i|ello)$/.test(value);\n     * }\n     *\n     * function customizer(objValue, srcValue) {\n     *   if (isGreeting(objValue) && isGreeting(srcValue)) {\n     *     return true;\n     *   }\n     * }\n     *\n     * var object = { 'greeting': 'hello' };\n     * var source = { 'greeting': 'hi' };\n     *\n     * _.isMatchWith(object, source, customizer);\n     * // => true\n     */\n    function isMatchWith(object, source, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return baseIsMatch(object, source, getMatchData(source), customizer);\n    }\n\n    /**\n     * Checks if `value` is `NaN`.\n     *\n     * **Note:** This method is based on\n     * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as\n     * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for\n     * `undefined` and other non-number values.\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 `NaN`, else `false`.\n     * @example\n     *\n     * _.isNaN(NaN);\n     * // => true\n     *\n     * _.isNaN(new Number(NaN));\n     * // => true\n     *\n     * isNaN(undefined);\n     * // => true\n     *\n     * _.isNaN(undefined);\n     * // => false\n     */\n    function isNaN(value) {\n      // An `NaN` primitive is the only value that is not equal to itself.\n      // Perform the `toStringTag` check first to avoid errors with some\n      // ActiveX objects in IE.\n      return isNumber(value) && value != +value;\n    }\n\n    /**\n     * Checks if `value` is a pristine native function.\n     *\n     * **Note:** This method can't reliably detect native functions in the presence\n     * of the core-js package because core-js circumvents this kind of detection.\n     * Despite multiple requests, the core-js maintainer has made it clear: any\n     * attempt to fix the detection will be obstructed. As a result, we're left\n     * with little choice but to throw an error. Unfortunately, this also affects\n     * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill),\n     * which rely on core-js.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a native function,\n     *  else `false`.\n     * @example\n     *\n     * _.isNative(Array.prototype.push);\n     * // => true\n     *\n     * _.isNative(_);\n     * // => false\n     */\n    function isNative(value) {\n      if (isMaskable(value)) {\n        throw new Error(CORE_ERROR_TEXT);\n      }\n      return baseIsNative(value);\n    }\n\n    /**\n     * Checks if `value` is `null`.\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 `null`, else `false`.\n     * @example\n     *\n     * _.isNull(null);\n     * // => true\n     *\n     * _.isNull(void 0);\n     * // => false\n     */\n    function isNull(value) {\n      return value === null;\n    }\n\n    /**\n     * Checks if `value` is `null` or `undefined`.\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 nullish, else `false`.\n     * @example\n     *\n     * _.isNil(null);\n     * // => true\n     *\n     * _.isNil(void 0);\n     * // => true\n     *\n     * _.isNil(NaN);\n     * // => false\n     */\n    function isNil(value) {\n      return value == null;\n    }\n\n    /**\n     * Checks if `value` is classified as a `Number` primitive or object.\n     *\n     * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are\n     * classified as numbers, use the `_.isFinite` method.\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 number, else `false`.\n     * @example\n     *\n     * _.isNumber(3);\n     * // => true\n     *\n     * _.isNumber(Number.MIN_VALUE);\n     * // => true\n     *\n     * _.isNumber(Infinity);\n     * // => true\n     *\n     * _.isNumber('3');\n     * // => false\n     */\n    function isNumber(value) {\n      return typeof value == 'number' ||\n        (isObjectLike(value) && baseGetTag(value) == numberTag);\n    }\n\n    /**\n     * Checks if `value` is a plain object, that is, an object created by the\n     * `Object` constructor or one with a `[[Prototype]]` of `null`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.8.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     * }\n     *\n     * _.isPlainObject(new Foo);\n     * // => false\n     *\n     * _.isPlainObject([1, 2, 3]);\n     * // => false\n     *\n     * _.isPlainObject({ 'x': 0, 'y': 0 });\n     * // => true\n     *\n     * _.isPlainObject(Object.create(null));\n     * // => true\n     */\n    function isPlainObject(value) {\n      if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n        return false;\n      }\n      var proto = getPrototype(value);\n      if (proto === null) {\n        return true;\n      }\n      var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n      return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n        funcToString.call(Ctor) == objectCtorString;\n    }\n\n    /**\n     * Checks if `value` is classified as a `RegExp` 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 regexp, else `false`.\n     * @example\n     *\n     * _.isRegExp(/abc/);\n     * // => true\n     *\n     * _.isRegExp('/abc/');\n     * // => false\n     */\n    var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;\n\n    /**\n     * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754\n     * double precision number which isn't the result of a rounded unsafe integer.\n     *\n     * **Note:** This method is based on\n     * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).\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 safe integer, else `false`.\n     * @example\n     *\n     * _.isSafeInteger(3);\n     * // => true\n     *\n     * _.isSafeInteger(Number.MIN_VALUE);\n     * // => false\n     *\n     * _.isSafeInteger(Infinity);\n     * // => false\n     *\n     * _.isSafeInteger('3');\n     * // => false\n     */\n    function isSafeInteger(value) {\n      return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;\n    }\n\n    /**\n     * Checks if `value` is classified as a `Set` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n     * @example\n     *\n     * _.isSet(new Set);\n     * // => true\n     *\n     * _.isSet(new WeakSet);\n     * // => false\n     */\n    var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;\n\n    /**\n     * Checks if `value` is classified as a `String` primitive or object.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a string, else `false`.\n     * @example\n     *\n     * _.isString('abc');\n     * // => true\n     *\n     * _.isString(1);\n     * // => false\n     */\n    function isString(value) {\n      return typeof value == 'string' ||\n        (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);\n    }\n\n    /**\n     * Checks if `value` is classified as a `Symbol` primitive or 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 a symbol, else `false`.\n     * @example\n     *\n     * _.isSymbol(Symbol.iterator);\n     * // => true\n     *\n     * _.isSymbol('abc');\n     * // => false\n     */\n    function isSymbol(value) {\n      return typeof value == 'symbol' ||\n        (isObjectLike(value) && baseGetTag(value) == symbolTag);\n    }\n\n    /**\n     * Checks if `value` is classified as a typed array.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n     * @example\n     *\n     * _.isTypedArray(new Uint8Array);\n     * // => true\n     *\n     * _.isTypedArray([]);\n     * // => false\n     */\n    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\n    /**\n     * Checks if `value` is `undefined`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.\n     * @example\n     *\n     * _.isUndefined(void 0);\n     * // => true\n     *\n     * _.isUndefined(null);\n     * // => false\n     */\n    function isUndefined(value) {\n      return value === undefined;\n    }\n\n    /**\n     * Checks if `value` is classified as a `WeakMap` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a weak map, else `false`.\n     * @example\n     *\n     * _.isWeakMap(new WeakMap);\n     * // => true\n     *\n     * _.isWeakMap(new Map);\n     * // => false\n     */\n    function isWeakMap(value) {\n      return isObjectLike(value) && getTag(value) == weakMapTag;\n    }\n\n    /**\n     * Checks if `value` is classified as a `WeakSet` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a weak set, else `false`.\n     * @example\n     *\n     * _.isWeakSet(new WeakSet);\n     * // => true\n     *\n     * _.isWeakSet(new Set);\n     * // => false\n     */\n    function isWeakSet(value) {\n      return isObjectLike(value) && baseGetTag(value) == weakSetTag;\n    }\n\n    /**\n     * Checks if `value` is less than `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.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 `value` is less than `other`,\n     *  else `false`.\n     * @see _.gt\n     * @example\n     *\n     * _.lt(1, 3);\n     * // => true\n     *\n     * _.lt(3, 3);\n     * // => false\n     *\n     * _.lt(3, 1);\n     * // => false\n     */\n    var lt = createRelationalOperation(baseLt);\n\n    /**\n     * Checks if `value` is less than or equal to `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.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 `value` is less than or equal to\n     *  `other`, else `false`.\n     * @see _.gte\n     * @example\n     *\n     * _.lte(1, 3);\n     * // => true\n     *\n     * _.lte(3, 3);\n     * // => true\n     *\n     * _.lte(3, 1);\n     * // => false\n     */\n    var lte = createRelationalOperation(function(value, other) {\n      return value <= other;\n    });\n\n    /**\n     * Converts `value` to an array.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {Array} Returns the converted array.\n     * @example\n     *\n     * _.toArray({ 'a': 1, 'b': 2 });\n     * // => [1, 2]\n     *\n     * _.toArray('abc');\n     * // => ['a', 'b', 'c']\n     *\n     * _.toArray(1);\n     * // => []\n     *\n     * _.toArray(null);\n     * // => []\n     */\n    function toArray(value) {\n      if (!value) {\n        return [];\n      }\n      if (isArrayLike(value)) {\n        return isString(value) ? stringToArray(value) : copyArray(value);\n      }\n      if (symIterator && value[symIterator]) {\n        return iteratorToArray(value[symIterator]());\n      }\n      var tag = getTag(value),\n          func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values);\n\n      return func(value);\n    }\n\n    /**\n     * Converts `value` to a finite number.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.12.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted number.\n     * @example\n     *\n     * _.toFinite(3.2);\n     * // => 3.2\n     *\n     * _.toFinite(Number.MIN_VALUE);\n     * // => 5e-324\n     *\n     * _.toFinite(Infinity);\n     * // => 1.7976931348623157e+308\n     *\n     * _.toFinite('3.2');\n     * // => 3.2\n     */\n    function toFinite(value) {\n      if (!value) {\n        return value === 0 ? value : 0;\n      }\n      value = toNumber(value);\n      if (value === INFINITY || value === -INFINITY) {\n        var sign = (value < 0 ? -1 : 1);\n        return sign * MAX_INTEGER;\n      }\n      return value === value ? value : 0;\n    }\n\n    /**\n     * Converts `value` to an integer.\n     *\n     * **Note:** This method is loosely based on\n     * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.toInteger(3.2);\n     * // => 3\n     *\n     * _.toInteger(Number.MIN_VALUE);\n     * // => 0\n     *\n     * _.toInteger(Infinity);\n     * // => 1.7976931348623157e+308\n     *\n     * _.toInteger('3.2');\n     * // => 3\n     */\n    function toInteger(value) {\n      var result = toFinite(value),\n          remainder = result % 1;\n\n      return result === result ? (remainder ? result - remainder : result) : 0;\n    }\n\n    /**\n     * Converts `value` to an integer suitable for use as the length of an\n     * array-like object.\n     *\n     * **Note:** This method is 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 convert.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.toLength(3.2);\n     * // => 3\n     *\n     * _.toLength(Number.MIN_VALUE);\n     * // => 0\n     *\n     * _.toLength(Infinity);\n     * // => 4294967295\n     *\n     * _.toLength('3.2');\n     * // => 3\n     */\n    function toLength(value) {\n      return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;\n    }\n\n    /**\n     * Converts `value` to a number.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to process.\n     * @returns {number} Returns the number.\n     * @example\n     *\n     * _.toNumber(3.2);\n     * // => 3.2\n     *\n     * _.toNumber(Number.MIN_VALUE);\n     * // => 5e-324\n     *\n     * _.toNumber(Infinity);\n     * // => Infinity\n     *\n     * _.toNumber('3.2');\n     * // => 3.2\n     */\n    function toNumber(value) {\n      if (typeof value == 'number') {\n        return value;\n      }\n      if (isSymbol(value)) {\n        return NAN;\n      }\n      if (isObject(value)) {\n        var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n        value = isObject(other) ? (other + '') : other;\n      }\n      if (typeof value != 'string') {\n        return value === 0 ? value : +value;\n      }\n      value = value.replace(reTrim, '');\n      var isBinary = reIsBinary.test(value);\n      return (isBinary || reIsOctal.test(value))\n        ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n        : (reIsBadHex.test(value) ? NAN : +value);\n    }\n\n    /**\n     * Converts `value` to a plain object flattening inherited enumerable string\n     * keyed properties of `value` to own properties of the plain object.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {Object} Returns the converted plain object.\n     * @example\n     *\n     * function Foo() {\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.assign({ 'a': 1 }, new Foo);\n     * // => { 'a': 1, 'b': 2 }\n     *\n     * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n     * // => { 'a': 1, 'b': 2, 'c': 3 }\n     */\n    function toPlainObject(value) {\n      return copyObject(value, keysIn(value));\n    }\n\n    /**\n     * Converts `value` to a safe integer. A safe integer can be compared and\n     * represented correctly.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.toSafeInteger(3.2);\n     * // => 3\n     *\n     * _.toSafeInteger(Number.MIN_VALUE);\n     * // => 0\n     *\n     * _.toSafeInteger(Infinity);\n     * // => 9007199254740991\n     *\n     * _.toSafeInteger('3.2');\n     * // => 3\n     */\n    function toSafeInteger(value) {\n      return value\n        ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER)\n        : (value === 0 ? value : 0);\n    }\n\n    /**\n     * Converts `value` to a string. An empty string is returned for `null`\n     * and `undefined` values. The sign of `-0` is preserved.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {string} Returns the converted string.\n     * @example\n     *\n     * _.toString(null);\n     * // => ''\n     *\n     * _.toString(-0);\n     * // => '-0'\n     *\n     * _.toString([1, 2, 3]);\n     * // => '1,2,3'\n     */\n    function toString(value) {\n      return value == null ? '' : baseToString(value);\n    }\n\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     */\n    var assign = createAssigner(function(object, source) {\n      if (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     * This method is like `_.assign` except that it iterates over own and\n     * inherited source properties.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias extend\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @see _.assign\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     * _.assignIn({ 'a': 0 }, new Foo, new Bar);\n     * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }\n     */\n    var assignIn = createAssigner(function(object, source) {\n      copyObject(source, keysIn(source), object);\n    });\n\n    /**\n     * This method is like `_.assignIn` except that it accepts `customizer`\n     * which is invoked to produce the assigned values. If `customizer` returns\n     * `undefined`, assignment is handled by the method instead. The `customizer`\n     * is invoked with five arguments: (objValue, srcValue, key, object, source).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias extendWith\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} sources The source objects.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @see _.assignWith\n     * @example\n     *\n     * function customizer(objValue, srcValue) {\n     *   return _.isUndefined(objValue) ? srcValue : objValue;\n     * }\n     *\n     * var defaults = _.partialRight(_.assignInWith, customizer);\n     *\n     * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n     * // => { 'a': 1, 'b': 2 }\n     */\n    var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {\n      copyObject(source, keysIn(source), object, customizer);\n    });\n\n    /**\n     * This method is like `_.assign` except that it accepts `customizer`\n     * which is invoked to produce the assigned values. If `customizer` returns\n     * `undefined`, assignment is handled by the method instead. The `customizer`\n     * is invoked with five arguments: (objValue, srcValue, key, object, source).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} sources The source objects.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @see _.assignInWith\n     * @example\n     *\n     * function customizer(objValue, srcValue) {\n     *   return _.isUndefined(objValue) ? srcValue : objValue;\n     * }\n     *\n     * var defaults = _.partialRight(_.assignWith, customizer);\n     *\n     * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n     * // => { 'a': 1, 'b': 2 }\n     */\n    var assignWith = createAssigner(function(object, source, srcIndex, customizer) {\n      copyObject(source, keys(source), object, customizer);\n    });\n\n    /**\n     * Creates an array of values corresponding to `paths` of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.0.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {...(string|string[])} [paths] The property paths to pick.\n     * @returns {Array} Returns the picked values.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };\n     *\n     * _.at(object, ['a[0].b.c', 'a[1]']);\n     * // => [3, 4]\n     */\n    var at = flatRest(baseAt);\n\n    /**\n     * Creates an object that inherits from the `prototype` object. If a\n     * `properties` object is given, its own enumerable string keyed properties\n     * are assigned to the created object.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.3.0\n     * @category Object\n     * @param {Object} prototype The object to inherit from.\n     * @param {Object} [properties] The properties to assign to the object.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * function Shape() {\n     *   this.x = 0;\n     *   this.y = 0;\n     * }\n     *\n     * function Circle() {\n     *   Shape.call(this);\n     * }\n     *\n     * Circle.prototype = _.create(Shape.prototype, {\n     *   'constructor': Circle\n     * });\n     *\n     * var circle = new Circle;\n     * circle instanceof Circle;\n     * // => true\n     *\n     * circle instanceof Shape;\n     * // => true\n     */\n    function create(prototype, properties) {\n      var result = baseCreate(prototype);\n      return properties == null ? result : baseAssign(result, properties);\n    }\n\n    /**\n     * Assigns own and inherited enumerable string keyed properties of source\n     * objects to the destination object for all destination properties that\n     * resolve to `undefined`. Source objects are applied from left to right.\n     * Once a property is set, additional values of the same property are ignored.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @see _.defaultsDeep\n     * @example\n     *\n     * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n     * // => { 'a': 1, 'b': 2 }\n     */\n    var defaults = baseRest(function(args) {\n      args.push(undefined, customDefaultsAssignIn);\n      return apply(assignInWith, undefined, args);\n    });\n\n    /**\n     * This method is like `_.defaults` except that it recursively assigns\n     * default properties.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.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 _.defaults\n     * @example\n     *\n     * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } });\n     * // => { 'a': { 'b': 2, 'c': 3 } }\n     */\n    var defaultsDeep = baseRest(function(args) {\n      args.push(undefined, customDefaultsMerge);\n      return apply(mergeWith, undefined, args);\n    });\n\n    /**\n     * This method is like `_.find` except that it returns the key of the first\n     * element `predicate` returns truthy for instead of the element itself.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.1.0\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {string|undefined} Returns the key of the matched element,\n     *  else `undefined`.\n     * @example\n     *\n     * var users = {\n     *   'barney':  { 'age': 36, 'active': true },\n     *   'fred':    { 'age': 40, 'active': false },\n     *   'pebbles': { 'age': 1,  'active': true }\n     * };\n     *\n     * _.findKey(users, function(o) { return o.age < 40; });\n     * // => 'barney' (iteration order is not guaranteed)\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findKey(users, { 'age': 1, 'active': true });\n     * // => 'pebbles'\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findKey(users, ['active', false]);\n     * // => 'fred'\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findKey(users, 'active');\n     * // => 'barney'\n     */\n    function findKey(object, predicate) {\n      return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);\n    }\n\n    /**\n     * This method is like `_.findKey` except that it iterates over elements of\n     * a collection in the opposite order.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {string|undefined} Returns the key of the matched element,\n     *  else `undefined`.\n     * @example\n     *\n     * var users = {\n     *   'barney':  { 'age': 36, 'active': true },\n     *   'fred':    { 'age': 40, 'active': false },\n     *   'pebbles': { 'age': 1,  'active': true }\n     * };\n     *\n     * _.findLastKey(users, function(o) { return o.age < 40; });\n     * // => returns 'pebbles' assuming `_.findKey` returns 'barney'\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findLastKey(users, { 'age': 36, 'active': true });\n     * // => 'barney'\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findLastKey(users, ['active', false]);\n     * // => 'fred'\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findLastKey(users, 'active');\n     * // => 'pebbles'\n     */\n    function findLastKey(object, predicate) {\n      return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);\n    }\n\n    /**\n     * Iterates over own and inherited enumerable string keyed properties of an\n     * object and invokes `iteratee` for each property. The iteratee is invoked\n     * with three arguments: (value, key, object). Iteratee functions may exit\n     * iteration early by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.3.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forInRight\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forIn(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed).\n     */\n    function forIn(object, iteratee) {\n      return object == null\n        ? object\n        : baseFor(object, getIteratee(iteratee, 3), keysIn);\n    }\n\n    /**\n     * This method is like `_.forIn` except that it iterates over properties of\n     * `object` in the opposite order.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forIn\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forInRight(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'.\n     */\n    function forInRight(object, iteratee) {\n      return object == null\n        ? object\n        : baseForRight(object, getIteratee(iteratee, 3), keysIn);\n    }\n\n    /**\n     * Iterates over own enumerable string keyed properties of an object and\n     * invokes `iteratee` for each property. The iteratee is invoked with three\n     * arguments: (value, key, object). Iteratee functions may exit iteration\n     * early by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.3.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forOwnRight\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forOwn(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'a' then 'b' (iteration order is not guaranteed).\n     */\n    function forOwn(object, iteratee) {\n      return object && baseForOwn(object, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * This method is like `_.forOwn` except that it iterates over properties of\n     * `object` in the opposite order.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forOwn\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forOwnRight(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'.\n     */\n    function forOwnRight(object, iteratee) {\n      return object && baseForOwnRight(object, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * Creates an array of function property names from own enumerable properties\n     * of `object`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @returns {Array} Returns the function names.\n     * @see _.functionsIn\n     * @example\n     *\n     * function Foo() {\n     *   this.a = _.constant('a');\n     *   this.b = _.constant('b');\n     * }\n     *\n     * Foo.prototype.c = _.constant('c');\n     *\n     * _.functions(new Foo);\n     * // => ['a', 'b']\n     */\n    function functions(object) {\n      return object == null ? [] : baseFunctions(object, keys(object));\n    }\n\n    /**\n     * Creates an array of function property names from own and inherited\n     * enumerable properties of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @returns {Array} Returns the function names.\n     * @see _.functions\n     * @example\n     *\n     * function Foo() {\n     *   this.a = _.constant('a');\n     *   this.b = _.constant('b');\n     * }\n     *\n     * Foo.prototype.c = _.constant('c');\n     *\n     * _.functionsIn(new Foo);\n     * // => ['a', 'b', 'c']\n     */\n    function functionsIn(object) {\n      return object == null ? [] : baseFunctions(object, keysIn(object));\n    }\n\n    /**\n     * Gets the value at `path` of `object`. If the resolved value is\n     * `undefined`, the `defaultValue` is returned in its place.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the property to get.\n     * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n     * @returns {*} Returns the resolved value.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n     *\n     * _.get(object, 'a[0].b.c');\n     * // => 3\n     *\n     * _.get(object, ['a', '0', 'b', 'c']);\n     * // => 3\n     *\n     * _.get(object, 'a.b.c', 'default');\n     * // => 'default'\n     */\n    function get(object, path, defaultValue) {\n      var result = object == null ? undefined : baseGet(object, path);\n      return result === undefined ? defaultValue : result;\n    }\n\n    /**\n     * Checks if `path` is a direct property of `object`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path to check.\n     * @returns {boolean} Returns `true` if `path` exists, else `false`.\n     * @example\n     *\n     * var object = { 'a': { 'b': 2 } };\n     * var other = _.create({ 'a': _.create({ 'b': 2 }) });\n     *\n     * _.has(object, 'a');\n     * // => true\n     *\n     * _.has(object, 'a.b');\n     * // => true\n     *\n     * _.has(object, ['a', 'b']);\n     * // => true\n     *\n     * _.has(other, 'a');\n     * // => false\n     */\n    function has(object, path) {\n      return object != null && hasPath(object, path, baseHas);\n    }\n\n    /**\n     * Checks if `path` is a direct or inherited property of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path to check.\n     * @returns {boolean} Returns `true` if `path` exists, else `false`.\n     * @example\n     *\n     * var object = _.create({ 'a': _.create({ 'b': 2 }) });\n     *\n     * _.hasIn(object, 'a');\n     * // => true\n     *\n     * _.hasIn(object, 'a.b');\n     * // => true\n     *\n     * _.hasIn(object, ['a', 'b']);\n     * // => true\n     *\n     * _.hasIn(object, 'b');\n     * // => false\n     */\n    function hasIn(object, path) {\n      return object != null && hasPath(object, path, baseHasIn);\n    }\n\n    /**\n     * Creates an object composed of the inverted keys and values of `object`.\n     * If `object` contains duplicate values, subsequent values overwrite\n     * property assignments of previous values.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.7.0\n     * @category Object\n     * @param {Object} object The object to invert.\n     * @returns {Object} Returns the new inverted object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2, 'c': 1 };\n     *\n     * _.invert(object);\n     * // => { '1': 'c', '2': 'b' }\n     */\n    var invert = createInverter(function(result, value, key) {\n      result[value] = key;\n    }, constant(identity));\n\n    /**\n     * This method is like `_.invert` except that the inverted object is generated\n     * from the results of running each element of `object` thru `iteratee`. The\n     * corresponding inverted value of each inverted key is an array of keys\n     * responsible for generating the inverted value. The iteratee is invoked\n     * with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.1.0\n     * @category Object\n     * @param {Object} object The object to invert.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Object} Returns the new inverted object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2, 'c': 1 };\n     *\n     * _.invertBy(object);\n     * // => { '1': ['a', 'c'], '2': ['b'] }\n     *\n     * _.invertBy(object, function(value) {\n     *   return 'group' + value;\n     * });\n     * // => { 'group1': ['a', 'c'], 'group2': ['b'] }\n     */\n    var invertBy = createInverter(function(result, value, key) {\n      if (hasOwnProperty.call(result, value)) {\n        result[value].push(key);\n      } else {\n        result[value] = [key];\n      }\n    }, getIteratee);\n\n    /**\n     * Invokes the method at `path` of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the method to invoke.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {*} Returns the result of the invoked method.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] };\n     *\n     * _.invoke(object, 'a[0].b.c.slice', 1, 3);\n     * // => [2, 3]\n     */\n    var invoke = baseRest(baseInvoke);\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     */\n    function keys(object) {\n      return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n    }\n\n    /**\n     * Creates an array of the own and inherited enumerable property names of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\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     * _.keysIn(new Foo);\n     * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n     */\n    function keysIn(object) {\n      return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n    }\n\n    /**\n     * The opposite of `_.mapValues`; this method creates an object with the\n     * same values as `object` and keys generated by running each own enumerable\n     * string keyed property of `object` thru `iteratee`. The iteratee is invoked\n     * with three arguments: (value, key, object).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.8.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns the new mapped object.\n     * @see _.mapValues\n     * @example\n     *\n     * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {\n     *   return key + value;\n     * });\n     * // => { 'a1': 1, 'b2': 2 }\n     */\n    function mapKeys(object, iteratee) {\n      var result = {};\n      iteratee = getIteratee(iteratee, 3);\n\n      baseForOwn(object, function(value, key, object) {\n        baseAssignValue(result, iteratee(value, key, object), value);\n      });\n      return result;\n    }\n\n    /**\n     * Creates an object with the same keys as `object` and values generated\n     * by running each own enumerable string keyed property of `object` thru\n     * `iteratee`. The iteratee is invoked with three arguments:\n     * (value, key, object).\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns the new mapped object.\n     * @see _.mapKeys\n     * @example\n     *\n     * var users = {\n     *   'fred':    { 'user': 'fred',    'age': 40 },\n     *   'pebbles': { 'user': 'pebbles', 'age': 1 }\n     * };\n     *\n     * _.mapValues(users, function(o) { return o.age; });\n     * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.mapValues(users, 'age');\n     * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\n     */\n    function mapValues(object, iteratee) {\n      var result = {};\n      iteratee = getIteratee(iteratee, 3);\n\n      baseForOwn(object, function(value, key, object) {\n        baseAssignValue(result, key, iteratee(value, key, object));\n      });\n      return result;\n    }\n\n    /**\n     * This method is like `_.assign` except that it recursively merges own and\n     * inherited enumerable string keyed properties of source objects into the\n     * destination object. Source properties that resolve to `undefined` are\n     * skipped if a destination value exists. Array and plain object properties\n     * are merged recursively. Other objects and value types are overridden by\n     * assignment. Source objects are applied from left to right. Subsequent\n     * sources overwrite property assignments of previous sources.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.5.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = {\n     *   'a': [{ 'b': 2 }, { 'd': 4 }]\n     * };\n     *\n     * var other = {\n     *   'a': [{ 'c': 3 }, { 'e': 5 }]\n     * };\n     *\n     * _.merge(object, other);\n     * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }\n     */\n    var merge = createAssigner(function(object, source, srcIndex) {\n      baseMerge(object, source, srcIndex);\n    });\n\n    /**\n     * This method is like `_.merge` except that it accepts `customizer` which\n     * is invoked to produce the merged values of the destination and source\n     * properties. If `customizer` returns `undefined`, merging is handled by the\n     * method instead. The `customizer` is invoked with six arguments:\n     * (objValue, srcValue, key, object, source, stack).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} sources The source objects.\n     * @param {Function} customizer The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * function customizer(objValue, srcValue) {\n     *   if (_.isArray(objValue)) {\n     *     return objValue.concat(srcValue);\n     *   }\n     * }\n     *\n     * var object = { 'a': [1], 'b': [2] };\n     * var other = { 'a': [3], 'b': [4] };\n     *\n     * _.mergeWith(object, other, customizer);\n     * // => { 'a': [1, 3], 'b': [2, 4] }\n     */\n    var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {\n      baseMerge(object, source, srcIndex, customizer);\n    });\n\n    /**\n     * The opposite of `_.pick`; this method creates an object composed of the\n     * own and inherited enumerable property paths of `object` that are not omitted.\n     *\n     * **Note:** This method is considerably slower than `_.pick`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {...(string|string[])} [paths] The property paths to omit.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.omit(object, ['a', 'c']);\n     * // => { 'b': '2' }\n     */\n    var omit = flatRest(function(object, paths) {\n      var result = {};\n      if (object == null) {\n        return result;\n      }\n      var isDeep = false;\n      paths = arrayMap(paths, function(path) {\n        path = castPath(path, object);\n        isDeep || (isDeep = path.length > 1);\n        return path;\n      });\n      copyObject(object, getAllKeysIn(object), result);\n      if (isDeep) {\n        result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);\n      }\n      var length = paths.length;\n      while (length--) {\n        baseUnset(result, paths[length]);\n      }\n      return result;\n    });\n\n    /**\n     * The opposite of `_.pickBy`; this method creates an object composed of\n     * the own and inherited enumerable string keyed properties of `object` that\n     * `predicate` doesn't return truthy for. The predicate is invoked with two\n     * arguments: (value, key).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {Function} [predicate=_.identity] The function invoked per property.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.omitBy(object, _.isNumber);\n     * // => { 'b': '2' }\n     */\n    function omitBy(object, predicate) {\n      return pickBy(object, negate(getIteratee(predicate)));\n    }\n\n    /**\n     * Creates an object composed of the picked `object` properties.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {...(string|string[])} [paths] The property paths to pick.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.pick(object, ['a', 'c']);\n     * // => { 'a': 1, 'c': 3 }\n     */\n    var pick = flatRest(function(object, paths) {\n      return object == null ? {} : basePick(object, paths);\n    });\n\n    /**\n     * Creates an object composed of the `object` properties `predicate` returns\n     * truthy for. The predicate is invoked with two arguments: (value, key).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {Function} [predicate=_.identity] The function invoked per property.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.pickBy(object, _.isNumber);\n     * // => { 'a': 1, 'c': 3 }\n     */\n    function pickBy(object, predicate) {\n      if (object == null) {\n        return {};\n      }\n      var props = arrayMap(getAllKeysIn(object), function(prop) {\n        return [prop];\n      });\n      predicate = getIteratee(predicate);\n      return basePickBy(object, props, function(value, path) {\n        return predicate(value, path[0]);\n      });\n    }\n\n    /**\n     * This method is like `_.get` except that if the resolved value is a\n     * function it's invoked with the `this` binding of its parent object and\n     * its result is returned.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the property to resolve.\n     * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n     * @returns {*} Returns the resolved value.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };\n     *\n     * _.result(object, 'a[0].b.c1');\n     * // => 3\n     *\n     * _.result(object, 'a[0].b.c2');\n     * // => 4\n     *\n     * _.result(object, 'a[0].b.c3', 'default');\n     * // => 'default'\n     *\n     * _.result(object, 'a[0].b.c3', _.constant('default'));\n     * // => 'default'\n     */\n    function result(object, path, defaultValue) {\n      path = castPath(path, object);\n\n      var index = -1,\n          length = path.length;\n\n      // Ensure the loop is entered when path is empty.\n      if (!length) {\n        length = 1;\n        object = undefined;\n      }\n      while (++index < length) {\n        var value = object == null ? undefined : object[toKey(path[index])];\n        if (value === undefined) {\n          index = length;\n          value = defaultValue;\n        }\n        object = isFunction(value) ? value.call(object) : value;\n      }\n      return object;\n    }\n\n    /**\n     * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,\n     * it's created. Arrays are created for missing index properties while objects\n     * are created for all other missing properties. Use `_.setWith` to customize\n     * `path` creation.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n     *\n     * _.set(object, 'a[0].b.c', 4);\n     * console.log(object.a[0].b.c);\n     * // => 4\n     *\n     * _.set(object, ['x', '0', 'y', 'z'], 5);\n     * console.log(object.x[0].y.z);\n     * // => 5\n     */\n    function set(object, path, value) {\n      return object == null ? object : baseSet(object, path, value);\n    }\n\n    /**\n     * This method is like `_.set` except that it accepts `customizer` which is\n     * invoked to produce the objects of `path`.  If `customizer` returns `undefined`\n     * path creation is handled by the method instead. The `customizer` is invoked\n     * with three arguments: (nsValue, key, nsObject).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {*} value The value to set.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = {};\n     *\n     * _.setWith(object, '[0][1]', 'a', Object);\n     * // => { '0': { '1': 'a' } }\n     */\n    function setWith(object, path, value, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return object == null ? object : baseSet(object, path, value, customizer);\n    }\n\n    /**\n     * Creates an array of own enumerable string keyed-value pairs for `object`\n     * which can be consumed by `_.fromPairs`. If `object` is a map or set, its\n     * entries are returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias entries\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the key-value pairs.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.toPairs(new Foo);\n     * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed)\n     */\n    var toPairs = createToPairs(keys);\n\n    /**\n     * Creates an array of own and inherited enumerable string keyed-value pairs\n     * for `object` which can be consumed by `_.fromPairs`. If `object` is a map\n     * or set, its entries are returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias entriesIn\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the key-value pairs.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.toPairsIn(new Foo);\n     * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed)\n     */\n    var toPairsIn = createToPairs(keysIn);\n\n    /**\n     * An alternative to `_.reduce`; this method transforms `object` to a new\n     * `accumulator` object which is the result of running each of its own\n     * enumerable string keyed properties thru `iteratee`, with each invocation\n     * potentially mutating the `accumulator` object. If `accumulator` is not\n     * provided, a new object with the same `[[Prototype]]` will be used. The\n     * iteratee is invoked with four arguments: (accumulator, value, key, object).\n     * Iteratee functions may exit iteration early by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.3.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [accumulator] The custom accumulator value.\n     * @returns {*} Returns the accumulated value.\n     * @example\n     *\n     * _.transform([2, 3, 4], function(result, n) {\n     *   result.push(n *= n);\n     *   return n % 2 == 0;\n     * }, []);\n     * // => [4, 9]\n     *\n     * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {\n     *   (result[value] || (result[value] = [])).push(key);\n     * }, {});\n     * // => { '1': ['a', 'c'], '2': ['b'] }\n     */\n    function transform(object, iteratee, accumulator) {\n      var isArr = isArray(object),\n          isArrLike = isArr || isBuffer(object) || isTypedArray(object);\n\n      iteratee = getIteratee(iteratee, 4);\n      if (accumulator == null) {\n        var Ctor = object && object.constructor;\n        if (isArrLike) {\n          accumulator = isArr ? new Ctor : [];\n        }\n        else if (isObject(object)) {\n          accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};\n        }\n        else {\n          accumulator = {};\n        }\n      }\n      (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) {\n        return iteratee(accumulator, value, index, object);\n      });\n      return accumulator;\n    }\n\n    /**\n     * Removes the property at `path` of `object`.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to unset.\n     * @returns {boolean} Returns `true` if the property is deleted, else `false`.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 7 } }] };\n     * _.unset(object, 'a[0].b.c');\n     * // => true\n     *\n     * console.log(object);\n     * // => { 'a': [{ 'b': {} }] };\n     *\n     * _.unset(object, ['a', '0', 'b', 'c']);\n     * // => true\n     *\n     * console.log(object);\n     * // => { 'a': [{ 'b': {} }] };\n     */\n    function unset(object, path) {\n      return object == null ? true : baseUnset(object, path);\n    }\n\n    /**\n     * This method is like `_.set` except that accepts `updater` to produce the\n     * value to set. Use `_.updateWith` to customize `path` creation. The `updater`\n     * is invoked with one argument: (value).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.6.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {Function} updater The function to produce the updated value.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n     *\n     * _.update(object, 'a[0].b.c', function(n) { return n * n; });\n     * console.log(object.a[0].b.c);\n     * // => 9\n     *\n     * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; });\n     * console.log(object.x[0].y.z);\n     * // => 0\n     */\n    function update(object, path, updater) {\n      return object == null ? object : baseUpdate(object, path, castFunction(updater));\n    }\n\n    /**\n     * This method is like `_.update` except that it accepts `customizer` which is\n     * invoked to produce the objects of `path`.  If `customizer` returns `undefined`\n     * path creation is handled by the method instead. The `customizer` is invoked\n     * with three arguments: (nsValue, key, nsObject).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.6.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {Function} updater The function to produce the updated value.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = {};\n     *\n     * _.updateWith(object, '[0][1]', _.constant('a'), Object);\n     * // => { '0': { '1': 'a' } }\n     */\n    function updateWith(object, path, updater, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);\n    }\n\n    /**\n     * Creates an array of the own enumerable string keyed property values of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects.\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 values.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.values(new Foo);\n     * // => [1, 2] (iteration order is not guaranteed)\n     *\n     * _.values('hi');\n     * // => ['h', 'i']\n     */\n    function values(object) {\n      return object == null ? [] : baseValues(object, keys(object));\n    }\n\n    /**\n     * Creates an array of the own and inherited enumerable string keyed property\n     * values of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property values.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.valuesIn(new Foo);\n     * // => [1, 2, 3] (iteration order is not guaranteed)\n     */\n    function valuesIn(object) {\n      return object == null ? [] : baseValues(object, keysIn(object));\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Clamps `number` within the inclusive `lower` and `upper` bounds.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Number\n     * @param {number} number The number to clamp.\n     * @param {number} [lower] The lower bound.\n     * @param {number} upper The upper bound.\n     * @returns {number} Returns the clamped number.\n     * @example\n     *\n     * _.clamp(-10, -5, 5);\n     * // => -5\n     *\n     * _.clamp(10, -5, 5);\n     * // => 5\n     */\n    function clamp(number, lower, upper) {\n      if (upper === undefined) {\n        upper = lower;\n        lower = undefined;\n      }\n      if (upper !== undefined) {\n        upper = toNumber(upper);\n        upper = upper === upper ? upper : 0;\n      }\n      if (lower !== undefined) {\n        lower = toNumber(lower);\n        lower = lower === lower ? lower : 0;\n      }\n      return baseClamp(toNumber(number), lower, upper);\n    }\n\n    /**\n     * Checks if `n` is between `start` and up to, but not including, `end`. If\n     * `end` is not specified, it's set to `start` with `start` then set to `0`.\n     * If `start` is greater than `end` the params are swapped to support\n     * negative ranges.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.3.0\n     * @category Number\n     * @param {number} number The number to check.\n     * @param {number} [start=0] The start of the range.\n     * @param {number} end The end of the range.\n     * @returns {boolean} Returns `true` if `number` is in the range, else `false`.\n     * @see _.range, _.rangeRight\n     * @example\n     *\n     * _.inRange(3, 2, 4);\n     * // => true\n     *\n     * _.inRange(4, 8);\n     * // => true\n     *\n     * _.inRange(4, 2);\n     * // => false\n     *\n     * _.inRange(2, 2);\n     * // => false\n     *\n     * _.inRange(1.2, 2);\n     * // => true\n     *\n     * _.inRange(5.2, 4);\n     * // => false\n     *\n     * _.inRange(-3, -2, -6);\n     * // => true\n     */\n    function inRange(number, start, end) {\n      start = toFinite(start);\n      if (end === undefined) {\n        end = start;\n        start = 0;\n      } else {\n        end = toFinite(end);\n      }\n      number = toNumber(number);\n      return baseInRange(number, start, end);\n    }\n\n    /**\n     * Produces a random number between the inclusive `lower` and `upper` bounds.\n     * If only one argument is provided a number between `0` and the given number\n     * is returned. If `floating` is `true`, or either `lower` or `upper` are\n     * floats, a floating-point number is returned instead of an integer.\n     *\n     * **Note:** JavaScript follows the IEEE-754 standard for resolving\n     * floating-point values which can produce unexpected results.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.7.0\n     * @category Number\n     * @param {number} [lower=0] The lower bound.\n     * @param {number} [upper=1] The upper bound.\n     * @param {boolean} [floating] Specify returning a floating-point number.\n     * @returns {number} Returns the random number.\n     * @example\n     *\n     * _.random(0, 5);\n     * // => an integer between 0 and 5\n     *\n     * _.random(5);\n     * // => also an integer between 0 and 5\n     *\n     * _.random(5, true);\n     * // => a floating-point number between 0 and 5\n     *\n     * _.random(1.2, 5.2);\n     * // => a floating-point number between 1.2 and 5.2\n     */\n    function random(lower, upper, floating) {\n      if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) {\n        upper = floating = undefined;\n      }\n      if (floating === undefined) {\n        if (typeof upper == 'boolean') {\n          floating = upper;\n          upper = undefined;\n        }\n        else if (typeof lower == 'boolean') {\n          floating = lower;\n          lower = undefined;\n        }\n      }\n      if (lower === undefined && upper === undefined) {\n        lower = 0;\n        upper = 1;\n      }\n      else {\n        lower = toFinite(lower);\n        if (upper === undefined) {\n          upper = lower;\n          lower = 0;\n        } else {\n          upper = toFinite(upper);\n        }\n      }\n      if (lower > upper) {\n        var temp = lower;\n        lower = upper;\n        upper = temp;\n      }\n      if (floating || lower % 1 || upper % 1) {\n        var rand = nativeRandom();\n        return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper);\n      }\n      return baseRandom(lower, upper);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the camel cased string.\n     * @example\n     *\n     * _.camelCase('Foo Bar');\n     * // => 'fooBar'\n     *\n     * _.camelCase('--foo-bar--');\n     * // => 'fooBar'\n     *\n     * _.camelCase('__FOO_BAR__');\n     * // => 'fooBar'\n     */\n    var camelCase = createCompounder(function(result, word, index) {\n      word = word.toLowerCase();\n      return result + (index ? capitalize(word) : word);\n    });\n\n    /**\n     * Converts the first character of `string` to upper case and the remaining\n     * to lower case.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to capitalize.\n     * @returns {string} Returns the capitalized string.\n     * @example\n     *\n     * _.capitalize('FRED');\n     * // => 'Fred'\n     */\n    function capitalize(string) {\n      return upperFirst(toString(string).toLowerCase());\n    }\n\n    /**\n     * Deburrs `string` by converting\n     * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)\n     * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)\n     * letters to basic Latin letters and removing\n     * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to deburr.\n     * @returns {string} Returns the deburred string.\n     * @example\n     *\n     * _.deburr('déjà vu');\n     * // => 'deja vu'\n     */\n    function deburr(string) {\n      string = toString(string);\n      return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');\n    }\n\n    /**\n     * Checks if `string` ends with the given target string.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to inspect.\n     * @param {string} [target] The string to search for.\n     * @param {number} [position=string.length] The position to search up to.\n     * @returns {boolean} Returns `true` if `string` ends with `target`,\n     *  else `false`.\n     * @example\n     *\n     * _.endsWith('abc', 'c');\n     * // => true\n     *\n     * _.endsWith('abc', 'b');\n     * // => false\n     *\n     * _.endsWith('abc', 'b', 2);\n     * // => true\n     */\n    function endsWith(string, target, position) {\n      string = toString(string);\n      target = baseToString(target);\n\n      var length = string.length;\n      position = position === undefined\n        ? length\n        : baseClamp(toInteger(position), 0, length);\n\n      var end = position;\n      position -= target.length;\n      return position >= 0 && string.slice(position, end) == target;\n    }\n\n    /**\n     * Converts the characters \"&\", \"<\", \">\", '\"', and \"'\" in `string` to their\n     * corresponding HTML entities.\n     *\n     * **Note:** No other characters are escaped. To escape additional\n     * characters use a third-party library like [_he_](https://mths.be/he).\n     *\n     * Though the \">\" character is escaped for symmetry, characters like\n     * \">\" and \"/\" don't need escaping in HTML and have no special meaning\n     * unless they're part of a tag or unquoted attribute value. See\n     * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)\n     * (under \"semi-related fun fact\") for more details.\n     *\n     * When working with HTML you should always\n     * [quote attribute values](http://wonko.com/post/html-escaping) to reduce\n     * XSS vectors.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to escape.\n     * @returns {string} Returns the escaped string.\n     * @example\n     *\n     * _.escape('fred, barney, & pebbles');\n     * // => 'fred, barney, &amp; pebbles'\n     */\n    function escape(string) {\n      string = toString(string);\n      return (string && reHasUnescapedHtml.test(string))\n        ? string.replace(reUnescapedHtml, escapeHtmlChar)\n        : string;\n    }\n\n    /**\n     * Escapes the `RegExp` special characters \"^\", \"$\", \"\\\", \".\", \"*\", \"+\",\n     * \"?\", \"(\", \")\", \"[\", \"]\", \"{\", \"}\", and \"|\" in `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to escape.\n     * @returns {string} Returns the escaped string.\n     * @example\n     *\n     * _.escapeRegExp('[lodash](https://lodash.com/)');\n     * // => '\\[lodash\\]\\(https://lodash\\.com/\\)'\n     */\n    function escapeRegExp(string) {\n      string = toString(string);\n      return (string && reHasRegExpChar.test(string))\n        ? string.replace(reRegExpChar, '\\\\$&')\n        : string;\n    }\n\n    /**\n     * Converts `string` to\n     * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the kebab cased string.\n     * @example\n     *\n     * _.kebabCase('Foo Bar');\n     * // => 'foo-bar'\n     *\n     * _.kebabCase('fooBar');\n     * // => 'foo-bar'\n     *\n     * _.kebabCase('__FOO_BAR__');\n     * // => 'foo-bar'\n     */\n    var kebabCase = createCompounder(function(result, word, index) {\n      return result + (index ? '-' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Converts `string`, as space separated words, to lower case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the lower cased string.\n     * @example\n     *\n     * _.lowerCase('--Foo-Bar--');\n     * // => 'foo bar'\n     *\n     * _.lowerCase('fooBar');\n     * // => 'foo bar'\n     *\n     * _.lowerCase('__FOO_BAR__');\n     * // => 'foo bar'\n     */\n    var lowerCase = createCompounder(function(result, word, index) {\n      return result + (index ? ' ' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Converts the first character of `string` to lower case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the converted string.\n     * @example\n     *\n     * _.lowerFirst('Fred');\n     * // => 'fred'\n     *\n     * _.lowerFirst('FRED');\n     * // => 'fRED'\n     */\n    var lowerFirst = createCaseFirst('toLowerCase');\n\n    /**\n     * Pads `string` on the left and right sides if it's shorter than `length`.\n     * Padding characters are truncated if they can't be evenly divided by `length`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.pad('abc', 8);\n     * // => '  abc   '\n     *\n     * _.pad('abc', 8, '_-');\n     * // => '_-abc_-_'\n     *\n     * _.pad('abc', 3);\n     * // => 'abc'\n     */\n    function pad(string, length, chars) {\n      string = toString(string);\n      length = toInteger(length);\n\n      var strLength = length ? stringSize(string) : 0;\n      if (!length || strLength >= length) {\n        return string;\n      }\n      var mid = (length - strLength) / 2;\n      return (\n        createPadding(nativeFloor(mid), chars) +\n        string +\n        createPadding(nativeCeil(mid), chars)\n      );\n    }\n\n    /**\n     * Pads `string` on the right side if it's shorter than `length`. Padding\n     * characters are truncated if they exceed `length`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.padEnd('abc', 6);\n     * // => 'abc   '\n     *\n     * _.padEnd('abc', 6, '_-');\n     * // => 'abc_-_'\n     *\n     * _.padEnd('abc', 3);\n     * // => 'abc'\n     */\n    function padEnd(string, length, chars) {\n      string = toString(string);\n      length = toInteger(length);\n\n      var strLength = length ? stringSize(string) : 0;\n      return (length && strLength < length)\n        ? (string + createPadding(length - strLength, chars))\n        : string;\n    }\n\n    /**\n     * Pads `string` on the left side if it's shorter than `length`. Padding\n     * characters are truncated if they exceed `length`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.padStart('abc', 6);\n     * // => '   abc'\n     *\n     * _.padStart('abc', 6, '_-');\n     * // => '_-_abc'\n     *\n     * _.padStart('abc', 3);\n     * // => 'abc'\n     */\n    function padStart(string, length, chars) {\n      string = toString(string);\n      length = toInteger(length);\n\n      var strLength = length ? stringSize(string) : 0;\n      return (length && strLength < length)\n        ? (createPadding(length - strLength, chars) + string)\n        : string;\n    }\n\n    /**\n     * Converts `string` to an integer of the specified radix. If `radix` is\n     * `undefined` or `0`, a `radix` of `10` is used unless `value` is a\n     * hexadecimal, in which case a `radix` of `16` is used.\n     *\n     * **Note:** This method aligns with the\n     * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.1.0\n     * @category String\n     * @param {string} string The string to convert.\n     * @param {number} [radix=10] The radix to interpret `value` by.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.parseInt('08');\n     * // => 8\n     *\n     * _.map(['6', '08', '10'], _.parseInt);\n     * // => [6, 8, 10]\n     */\n    function parseInt(string, radix, guard) {\n      if (guard || radix == null) {\n        radix = 0;\n      } else if (radix) {\n        radix = +radix;\n      }\n      return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0);\n    }\n\n    /**\n     * Repeats the given string `n` times.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to repeat.\n     * @param {number} [n=1] The number of times to repeat the string.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the repeated string.\n     * @example\n     *\n     * _.repeat('*', 3);\n     * // => '***'\n     *\n     * _.repeat('abc', 2);\n     * // => 'abcabc'\n     *\n     * _.repeat('abc', 0);\n     * // => ''\n     */\n    function repeat(string, n, guard) {\n      if ((guard ? isIterateeCall(string, n, guard) : n === undefined)) {\n        n = 1;\n      } else {\n        n = toInteger(n);\n      }\n      return baseRepeat(toString(string), n);\n    }\n\n    /**\n     * Replaces matches for `pattern` in `string` with `replacement`.\n     *\n     * **Note:** This method is based on\n     * [`String#replace`](https://mdn.io/String/replace).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to modify.\n     * @param {RegExp|string} pattern The pattern to replace.\n     * @param {Function|string} replacement The match replacement.\n     * @returns {string} Returns the modified string.\n     * @example\n     *\n     * _.replace('Hi Fred', 'Fred', 'Barney');\n     * // => 'Hi Barney'\n     */\n    function replace() {\n      var args = arguments,\n          string = toString(args[0]);\n\n      return args.length < 3 ? string : string.replace(args[1], args[2]);\n    }\n\n    /**\n     * Converts `string` to\n     * [snake case](https://en.wikipedia.org/wiki/Snake_case).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the snake cased string.\n     * @example\n     *\n     * _.snakeCase('Foo Bar');\n     * // => 'foo_bar'\n     *\n     * _.snakeCase('fooBar');\n     * // => 'foo_bar'\n     *\n     * _.snakeCase('--FOO-BAR--');\n     * // => 'foo_bar'\n     */\n    var snakeCase = createCompounder(function(result, word, index) {\n      return result + (index ? '_' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Splits `string` by `separator`.\n     *\n     * **Note:** This method is based on\n     * [`String#split`](https://mdn.io/String/split).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to split.\n     * @param {RegExp|string} separator The separator pattern to split by.\n     * @param {number} [limit] The length to truncate results to.\n     * @returns {Array} Returns the string segments.\n     * @example\n     *\n     * _.split('a-b-c', '-', 2);\n     * // => ['a', 'b']\n     */\n    function split(string, separator, limit) {\n      if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) {\n        separator = limit = undefined;\n      }\n      limit = limit === undefined ? MAX_ARRAY_LENGTH : limit >>> 0;\n      if (!limit) {\n        return [];\n      }\n      string = toString(string);\n      if (string && (\n            typeof separator == 'string' ||\n            (separator != null && !isRegExp(separator))\n          )) {\n        separator = baseToString(separator);\n        if (!separator && hasUnicode(string)) {\n          return castSlice(stringToArray(string), 0, limit);\n        }\n      }\n      return string.split(separator, limit);\n    }\n\n    /**\n     * Converts `string` to\n     * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.1.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the start cased string.\n     * @example\n     *\n     * _.startCase('--foo-bar--');\n     * // => 'Foo Bar'\n     *\n     * _.startCase('fooBar');\n     * // => 'Foo Bar'\n     *\n     * _.startCase('__FOO_BAR__');\n     * // => 'FOO BAR'\n     */\n    var startCase = createCompounder(function(result, word, index) {\n      return result + (index ? ' ' : '') + upperFirst(word);\n    });\n\n    /**\n     * Checks if `string` starts with the given target string.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to inspect.\n     * @param {string} [target] The string to search for.\n     * @param {number} [position=0] The position to search from.\n     * @returns {boolean} Returns `true` if `string` starts with `target`,\n     *  else `false`.\n     * @example\n     *\n     * _.startsWith('abc', 'a');\n     * // => true\n     *\n     * _.startsWith('abc', 'b');\n     * // => false\n     *\n     * _.startsWith('abc', 'b', 1);\n     * // => true\n     */\n    function startsWith(string, target, position) {\n      string = toString(string);\n      position = position == null\n        ? 0\n        : baseClamp(toInteger(position), 0, string.length);\n\n      target = baseToString(target);\n      return string.slice(position, position + target.length) == target;\n    }\n\n    /**\n     * Creates a compiled template function that can interpolate data properties\n     * in \"interpolate\" delimiters, HTML-escape interpolated data properties in\n     * \"escape\" delimiters, and execute JavaScript in \"evaluate\" delimiters. Data\n     * properties may be accessed as free variables in the template. If a setting\n     * object is given, it takes precedence over `_.templateSettings` values.\n     *\n     * **Note:** In the development build `_.template` utilizes\n     * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)\n     * for easier debugging.\n     *\n     * For more information on precompiling templates see\n     * [lodash's custom builds documentation](https://lodash.com/custom-builds).\n     *\n     * For more information on Chrome extension sandboxes see\n     * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The template string.\n     * @param {Object} [options={}] The options object.\n     * @param {RegExp} [options.escape=_.templateSettings.escape]\n     *  The HTML \"escape\" delimiter.\n     * @param {RegExp} [options.evaluate=_.templateSettings.evaluate]\n     *  The \"evaluate\" delimiter.\n     * @param {Object} [options.imports=_.templateSettings.imports]\n     *  An object to import into the template as free variables.\n     * @param {RegExp} [options.interpolate=_.templateSettings.interpolate]\n     *  The \"interpolate\" delimiter.\n     * @param {string} [options.sourceURL='lodash.templateSources[n]']\n     *  The sourceURL of the compiled template.\n     * @param {string} [options.variable='obj']\n     *  The data object variable name.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the compiled template function.\n     * @example\n     *\n     * // Use the \"interpolate\" delimiter to create a compiled template.\n     * var compiled = _.template('hello <%= user %>!');\n     * compiled({ 'user': 'fred' });\n     * // => 'hello fred!'\n     *\n     * // Use the HTML \"escape\" delimiter to escape data property values.\n     * var compiled = _.template('<b><%- value %></b>');\n     * compiled({ 'value': '<script>' });\n     * // => '<b>&lt;script&gt;</b>'\n     *\n     * // Use the \"evaluate\" delimiter to execute JavaScript and generate HTML.\n     * var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');\n     * compiled({ 'users': ['fred', 'barney'] });\n     * // => '<li>fred</li><li>barney</li>'\n     *\n     * // Use the internal `print` function in \"evaluate\" delimiters.\n     * var compiled = _.template('<% print(\"hello \" + user); %>!');\n     * compiled({ 'user': 'barney' });\n     * // => 'hello barney!'\n     *\n     * // Use the ES template literal delimiter as an \"interpolate\" delimiter.\n     * // Disable support by replacing the \"interpolate\" delimiter.\n     * var compiled = _.template('hello ${ user }!');\n     * compiled({ 'user': 'pebbles' });\n     * // => 'hello pebbles!'\n     *\n     * // Use backslashes to treat delimiters as plain text.\n     * var compiled = _.template('<%= \"\\\\<%- value %\\\\>\" %>');\n     * compiled({ 'value': 'ignored' });\n     * // => '<%- value %>'\n     *\n     * // Use the `imports` option to import `jQuery` as `jq`.\n     * var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>';\n     * var compiled = _.template(text, { 'imports': { 'jq': jQuery } });\n     * compiled({ 'users': ['fred', 'barney'] });\n     * // => '<li>fred</li><li>barney</li>'\n     *\n     * // Use the `sourceURL` option to specify a custom sourceURL for the template.\n     * var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' });\n     * compiled(data);\n     * // => Find the source of \"greeting.jst\" under the Sources tab or Resources panel of the web inspector.\n     *\n     * // Use the `variable` option to ensure a with-statement isn't used in the compiled template.\n     * var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' });\n     * compiled.source;\n     * // => function(data) {\n     * //   var __t, __p = '';\n     * //   __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!';\n     * //   return __p;\n     * // }\n     *\n     * // Use custom template delimiters.\n     * _.templateSettings.interpolate = /{{([\\s\\S]+?)}}/g;\n     * var compiled = _.template('hello {{ user }}!');\n     * compiled({ 'user': 'mustache' });\n     * // => 'hello mustache!'\n     *\n     * // Use the `source` property to inline compiled templates for meaningful\n     * // line numbers in error messages and stack traces.\n     * fs.writeFileSync(path.join(process.cwd(), 'jst.js'), '\\\n     *   var JST = {\\\n     *     \"main\": ' + _.template(mainText).source + '\\\n     *   };\\\n     * ');\n     */\n    function template(string, options, guard) {\n      // Based on John Resig's `tmpl` implementation\n      // (http://ejohn.org/blog/javascript-micro-templating/)\n      // and Laura Doktorova's doT.js (https://github.com/olado/doT).\n      var settings = lodash.templateSettings;\n\n      if (guard && isIterateeCall(string, options, guard)) {\n        options = undefined;\n      }\n      string = toString(string);\n      options = assignInWith({}, options, settings, customDefaultsAssignIn);\n\n      var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn),\n          importsKeys = keys(imports),\n          importsValues = baseValues(imports, importsKeys);\n\n      var isEscaping,\n          isEvaluating,\n          index = 0,\n          interpolate = options.interpolate || reNoMatch,\n          source = \"__p += '\";\n\n      // Compile the regexp to match each delimiter.\n      var reDelimiters = RegExp(\n        (options.escape || reNoMatch).source + '|' +\n        interpolate.source + '|' +\n        (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +\n        (options.evaluate || reNoMatch).source + '|$'\n      , 'g');\n\n      // Use a sourceURL for easier debugging.\n      var sourceURL = '//# sourceURL=' +\n        ('sourceURL' in options\n          ? options.sourceURL\n          : ('lodash.templateSources[' + (++templateCounter) + ']')\n        ) + '\\n';\n\n      string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {\n        interpolateValue || (interpolateValue = esTemplateValue);\n\n        // Escape characters that can't be included in string literals.\n        source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);\n\n        // Replace delimiters with snippets.\n        if (escapeValue) {\n          isEscaping = true;\n          source += \"' +\\n__e(\" + escapeValue + \") +\\n'\";\n        }\n        if (evaluateValue) {\n          isEvaluating = true;\n          source += \"';\\n\" + evaluateValue + \";\\n__p += '\";\n        }\n        if (interpolateValue) {\n          source += \"' +\\n((__t = (\" + interpolateValue + \")) == null ? '' : __t) +\\n'\";\n        }\n        index = offset + match.length;\n\n        // The JS engine embedded in Adobe products needs `match` returned in\n        // order to produce the correct `offset` value.\n        return match;\n      });\n\n      source += \"';\\n\";\n\n      // If `variable` is not specified wrap a with-statement around the generated\n      // code to add the data object to the top of the scope chain.\n      var variable = options.variable;\n      if (!variable) {\n        source = 'with (obj) {\\n' + source + '\\n}\\n';\n      }\n      // Cleanup code by stripping empty strings.\n      source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)\n        .replace(reEmptyStringMiddle, '$1')\n        .replace(reEmptyStringTrailing, '$1;');\n\n      // Frame code as the function body.\n      source = 'function(' + (variable || 'obj') + ') {\\n' +\n        (variable\n          ? ''\n          : 'obj || (obj = {});\\n'\n        ) +\n        \"var __t, __p = ''\" +\n        (isEscaping\n           ? ', __e = _.escape'\n           : ''\n        ) +\n        (isEvaluating\n          ? ', __j = Array.prototype.join;\\n' +\n            \"function print() { __p += __j.call(arguments, '') }\\n\"\n          : ';\\n'\n        ) +\n        source +\n        'return __p\\n}';\n\n      var result = attempt(function() {\n        return Function(importsKeys, sourceURL + 'return ' + source)\n          .apply(undefined, importsValues);\n      });\n\n      // Provide the compiled function's source by its `toString` method or\n      // the `source` property as a convenience for inlining compiled templates.\n      result.source = source;\n      if (isError(result)) {\n        throw result;\n      }\n      return result;\n    }\n\n    /**\n     * Converts `string`, as a whole, to lower case just like\n     * [String#toLowerCase](https://mdn.io/toLowerCase).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the lower cased string.\n     * @example\n     *\n     * _.toLower('--Foo-Bar--');\n     * // => '--foo-bar--'\n     *\n     * _.toLower('fooBar');\n     * // => 'foobar'\n     *\n     * _.toLower('__FOO_BAR__');\n     * // => '__foo_bar__'\n     */\n    function toLower(value) {\n      return toString(value).toLowerCase();\n    }\n\n    /**\n     * Converts `string`, as a whole, to upper case just like\n     * [String#toUpperCase](https://mdn.io/toUpperCase).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the upper cased string.\n     * @example\n     *\n     * _.toUpper('--foo-bar--');\n     * // => '--FOO-BAR--'\n     *\n     * _.toUpper('fooBar');\n     * // => 'FOOBAR'\n     *\n     * _.toUpper('__foo_bar__');\n     * // => '__FOO_BAR__'\n     */\n    function toUpper(value) {\n      return toString(value).toUpperCase();\n    }\n\n    /**\n     * Removes leading and trailing whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trim('  abc  ');\n     * // => 'abc'\n     *\n     * _.trim('-_-abc-_-', '_-');\n     * // => 'abc'\n     *\n     * _.map(['  foo  ', '  bar  '], _.trim);\n     * // => ['foo', 'bar']\n     */\n    function trim(string, chars, guard) {\n      string = toString(string);\n      if (string && (guard || chars === undefined)) {\n        return string.replace(reTrim, '');\n      }\n      if (!string || !(chars = baseToString(chars))) {\n        return string;\n      }\n      var strSymbols = stringToArray(string),\n          chrSymbols = stringToArray(chars),\n          start = charsStartIndex(strSymbols, chrSymbols),\n          end = charsEndIndex(strSymbols, chrSymbols) + 1;\n\n      return castSlice(strSymbols, start, end).join('');\n    }\n\n    /**\n     * Removes trailing whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trimEnd('  abc  ');\n     * // => '  abc'\n     *\n     * _.trimEnd('-_-abc-_-', '_-');\n     * // => '-_-abc'\n     */\n    function trimEnd(string, chars, guard) {\n      string = toString(string);\n      if (string && (guard || chars === undefined)) {\n        return string.replace(reTrimEnd, '');\n      }\n      if (!string || !(chars = baseToString(chars))) {\n        return string;\n      }\n      var strSymbols = stringToArray(string),\n          end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;\n\n      return castSlice(strSymbols, 0, end).join('');\n    }\n\n    /**\n     * Removes leading whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trimStart('  abc  ');\n     * // => 'abc  '\n     *\n     * _.trimStart('-_-abc-_-', '_-');\n     * // => 'abc-_-'\n     */\n    function trimStart(string, chars, guard) {\n      string = toString(string);\n      if (string && (guard || chars === undefined)) {\n        return string.replace(reTrimStart, '');\n      }\n      if (!string || !(chars = baseToString(chars))) {\n        return string;\n      }\n      var strSymbols = stringToArray(string),\n          start = charsStartIndex(strSymbols, stringToArray(chars));\n\n      return castSlice(strSymbols, start).join('');\n    }\n\n    /**\n     * Truncates `string` if it's longer than the given maximum string length.\n     * The last characters of the truncated string are replaced with the omission\n     * string which defaults to \"...\".\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to truncate.\n     * @param {Object} [options={}] The options object.\n     * @param {number} [options.length=30] The maximum string length.\n     * @param {string} [options.omission='...'] The string to indicate text is omitted.\n     * @param {RegExp|string} [options.separator] The separator pattern to truncate to.\n     * @returns {string} Returns the truncated string.\n     * @example\n     *\n     * _.truncate('hi-diddly-ho there, neighborino');\n     * // => 'hi-diddly-ho there, neighbo...'\n     *\n     * _.truncate('hi-diddly-ho there, neighborino', {\n     *   'length': 24,\n     *   'separator': ' '\n     * });\n     * // => 'hi-diddly-ho there,...'\n     *\n     * _.truncate('hi-diddly-ho there, neighborino', {\n     *   'length': 24,\n     *   'separator': /,? +/\n     * });\n     * // => 'hi-diddly-ho there...'\n     *\n     * _.truncate('hi-diddly-ho there, neighborino', {\n     *   'omission': ' [...]'\n     * });\n     * // => 'hi-diddly-ho there, neig [...]'\n     */\n    function truncate(string, options) {\n      var length = DEFAULT_TRUNC_LENGTH,\n          omission = DEFAULT_TRUNC_OMISSION;\n\n      if (isObject(options)) {\n        var separator = 'separator' in options ? options.separator : separator;\n        length = 'length' in options ? toInteger(options.length) : length;\n        omission = 'omission' in options ? baseToString(options.omission) : omission;\n      }\n      string = toString(string);\n\n      var strLength = string.length;\n      if (hasUnicode(string)) {\n        var strSymbols = stringToArray(string);\n        strLength = strSymbols.length;\n      }\n      if (length >= strLength) {\n        return string;\n      }\n      var end = length - stringSize(omission);\n      if (end < 1) {\n        return omission;\n      }\n      var result = strSymbols\n        ? castSlice(strSymbols, 0, end).join('')\n        : string.slice(0, end);\n\n      if (separator === undefined) {\n        return result + omission;\n      }\n      if (strSymbols) {\n        end += (result.length - end);\n      }\n      if (isRegExp(separator)) {\n        if (string.slice(end).search(separator)) {\n          var match,\n              substring = result;\n\n          if (!separator.global) {\n            separator = RegExp(separator.source, toString(reFlags.exec(separator)) + 'g');\n          }\n          separator.lastIndex = 0;\n          while ((match = separator.exec(substring))) {\n            var newEnd = match.index;\n          }\n          result = result.slice(0, newEnd === undefined ? end : newEnd);\n        }\n      } else if (string.indexOf(baseToString(separator), end) != end) {\n        var index = result.lastIndexOf(separator);\n        if (index > -1) {\n          result = result.slice(0, index);\n        }\n      }\n      return result + omission;\n    }\n\n    /**\n     * The inverse of `_.escape`; this method converts the HTML entities\n     * `&amp;`, `&lt;`, `&gt;`, `&quot;`, and `&#39;` in `string` to\n     * their corresponding characters.\n     *\n     * **Note:** No other HTML entities are unescaped. To unescape additional\n     * HTML entities use a third-party library like [_he_](https://mths.be/he).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.6.0\n     * @category String\n     * @param {string} [string=''] The string to unescape.\n     * @returns {string} Returns the unescaped string.\n     * @example\n     *\n     * _.unescape('fred, barney, &amp; pebbles');\n     * // => 'fred, barney, & pebbles'\n     */\n    function unescape(string) {\n      string = toString(string);\n      return (string && reHasEscapedHtml.test(string))\n        ? string.replace(reEscapedHtml, unescapeHtmlChar)\n        : string;\n    }\n\n    /**\n     * Converts `string`, as space separated words, to upper case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the upper cased string.\n     * @example\n     *\n     * _.upperCase('--foo-bar');\n     * // => 'FOO BAR'\n     *\n     * _.upperCase('fooBar');\n     * // => 'FOO BAR'\n     *\n     * _.upperCase('__foo_bar__');\n     * // => 'FOO BAR'\n     */\n    var upperCase = createCompounder(function(result, word, index) {\n      return result + (index ? ' ' : '') + word.toUpperCase();\n    });\n\n    /**\n     * Converts the first character of `string` to upper case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the converted string.\n     * @example\n     *\n     * _.upperFirst('fred');\n     * // => 'Fred'\n     *\n     * _.upperFirst('FRED');\n     * // => 'FRED'\n     */\n    var upperFirst = createCaseFirst('toUpperCase');\n\n    /**\n     * Splits `string` into an array of its words.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to inspect.\n     * @param {RegExp|string} [pattern] The pattern to match words.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the words of `string`.\n     * @example\n     *\n     * _.words('fred, barney, & pebbles');\n     * // => ['fred', 'barney', 'pebbles']\n     *\n     * _.words('fred, barney, & pebbles', /[^, ]+/g);\n     * // => ['fred', 'barney', '&', 'pebbles']\n     */\n    function words(string, pattern, guard) {\n      string = toString(string);\n      pattern = guard ? undefined : pattern;\n\n      if (pattern === undefined) {\n        return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);\n      }\n      return string.match(pattern) || [];\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Attempts to invoke `func`, returning either the result or the caught error\n     * object. Any additional arguments are provided to `func` when it's invoked.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {Function} func The function to attempt.\n     * @param {...*} [args] The arguments to invoke `func` with.\n     * @returns {*} Returns the `func` result or error object.\n     * @example\n     *\n     * // Avoid throwing errors for invalid selectors.\n     * var elements = _.attempt(function(selector) {\n     *   return document.querySelectorAll(selector);\n     * }, '>_>');\n     *\n     * if (_.isError(elements)) {\n     *   elements = [];\n     * }\n     */\n    var attempt = baseRest(function(func, args) {\n      try {\n        return apply(func, undefined, args);\n      } catch (e) {\n        return isError(e) ? e : new Error(e);\n      }\n    });\n\n    /**\n     * Binds methods of an object to the object itself, overwriting the existing\n     * method.\n     *\n     * **Note:** This method doesn't set the \"length\" property of bound functions.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {Object} object The object to bind and assign the bound methods to.\n     * @param {...(string|string[])} methodNames The object method names to bind.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var view = {\n     *   'label': 'docs',\n     *   'click': function() {\n     *     console.log('clicked ' + this.label);\n     *   }\n     * };\n     *\n     * _.bindAll(view, ['click']);\n     * jQuery(element).on('click', view.click);\n     * // => Logs 'clicked docs' when clicked.\n     */\n    var bindAll = flatRest(function(object, methodNames) {\n      arrayEach(methodNames, function(key) {\n        key = toKey(key);\n        baseAssignValue(object, key, bind(object[key], object));\n      });\n      return object;\n    });\n\n    /**\n     * Creates a function that iterates over `pairs` and invokes the corresponding\n     * function of the first predicate to return truthy. The predicate-function\n     * pairs are invoked with the `this` binding and arguments of the created\n     * function.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {Array} pairs The predicate-function pairs.\n     * @returns {Function} Returns the new composite function.\n     * @example\n     *\n     * var func = _.cond([\n     *   [_.matches({ 'a': 1 }),           _.constant('matches A')],\n     *   [_.conforms({ 'b': _.isNumber }), _.constant('matches B')],\n     *   [_.stubTrue,                      _.constant('no match')]\n     * ]);\n     *\n     * func({ 'a': 1, 'b': 2 });\n     * // => 'matches A'\n     *\n     * func({ 'a': 0, 'b': 1 });\n     * // => 'matches B'\n     *\n     * func({ 'a': '1', 'b': '2' });\n     * // => 'no match'\n     */\n    function cond(pairs) {\n      var length = pairs == null ? 0 : pairs.length,\n          toIteratee = getIteratee();\n\n      pairs = !length ? [] : arrayMap(pairs, function(pair) {\n        if (typeof pair[1] != 'function') {\n          throw new TypeError(FUNC_ERROR_TEXT);\n        }\n        return [toIteratee(pair[0]), pair[1]];\n      });\n\n      return baseRest(function(args) {\n        var index = -1;\n        while (++index < length) {\n          var pair = pairs[index];\n          if (apply(pair[0], this, args)) {\n            return apply(pair[1], this, args);\n          }\n        }\n      });\n    }\n\n    /**\n     * Creates a function that invokes the predicate properties of `source` with\n     * the corresponding property values of a given object, returning `true` if\n     * all predicates return truthy, else `false`.\n     *\n     * **Note:** The created function is equivalent to `_.conformsTo` with\n     * `source` partially applied.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {Function} Returns the new spec function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': 2, 'b': 1 },\n     *   { 'a': 1, 'b': 2 }\n     * ];\n     *\n     * _.filter(objects, _.conforms({ 'b': function(n) { return n > 1; } }));\n     * // => [{ 'a': 1, 'b': 2 }]\n     */\n    function conforms(source) {\n      return baseConforms(baseClone(source, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that returns `value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Util\n     * @param {*} value The value to return from the new function.\n     * @returns {Function} Returns the new constant function.\n     * @example\n     *\n     * var objects = _.times(2, _.constant({ 'a': 1 }));\n     *\n     * console.log(objects);\n     * // => [{ 'a': 1 }, { 'a': 1 }]\n     *\n     * console.log(objects[0] === objects[1]);\n     * // => true\n     */\n    function constant(value) {\n      return function() {\n        return value;\n      };\n    }\n\n    /**\n     * Checks `value` to determine whether a default value should be returned in\n     * its place. The `defaultValue` is returned if `value` is `NaN`, `null`,\n     * or `undefined`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.14.0\n     * @category Util\n     * @param {*} value The value to check.\n     * @param {*} defaultValue The default value.\n     * @returns {*} Returns the resolved value.\n     * @example\n     *\n     * _.defaultTo(1, 10);\n     * // => 1\n     *\n     * _.defaultTo(undefined, 10);\n     * // => 10\n     */\n    function defaultTo(value, defaultValue) {\n      return (value == null || value !== value) ? defaultValue : value;\n    }\n\n    /**\n     * Creates a function that returns the result of invoking the given functions\n     * with the `this` binding of the created function, where each successive\n     * invocation is supplied the return value of the previous.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [funcs] The functions to invoke.\n     * @returns {Function} Returns the new composite function.\n     * @see _.flowRight\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var addSquare = _.flow([_.add, square]);\n     * addSquare(1, 2);\n     * // => 9\n     */\n    var flow = createFlow();\n\n    /**\n     * This method is like `_.flow` except that it creates a function that\n     * invokes the given functions from right to left.\n     *\n     * @static\n     * @since 3.0.0\n     * @memberOf _\n     * @category Util\n     * @param {...(Function|Function[])} [funcs] The functions to invoke.\n     * @returns {Function} Returns the new composite function.\n     * @see _.flow\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var addSquare = _.flowRight([square, _.add]);\n     * addSquare(1, 2);\n     * // => 9\n     */\n    var flowRight = createFlow(true);\n\n    /**\n     * This method returns the first argument it receives.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {*} value Any value.\n     * @returns {*} Returns `value`.\n     * @example\n     *\n     * var object = { 'a': 1 };\n     *\n     * console.log(_.identity(object) === object);\n     * // => true\n     */\n    function identity(value) {\n      return value;\n    }\n\n    /**\n     * Creates a function that invokes `func` with the arguments of the created\n     * function. If `func` is a property name, the created function returns the\n     * property value for a given element. If `func` is an array or object, the\n     * created function returns `true` for elements that contain the equivalent\n     * source properties, otherwise it returns `false`.\n     *\n     * @static\n     * @since 4.0.0\n     * @memberOf _\n     * @category Util\n     * @param {*} [func=_.identity] The value to convert to a callback.\n     * @returns {Function} Returns the callback.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': true },\n     *   { 'user': 'fred',   'age': 40, 'active': false }\n     * ];\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));\n     * // => [{ 'user': 'barney', 'age': 36, 'active': true }]\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.filter(users, _.iteratee(['user', 'fred']));\n     * // => [{ 'user': 'fred', 'age': 40 }]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.map(users, _.iteratee('user'));\n     * // => ['barney', 'fred']\n     *\n     * // Create custom iteratee shorthands.\n     * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {\n     *   return !_.isRegExp(func) ? iteratee(func) : function(string) {\n     *     return func.test(string);\n     *   };\n     * });\n     *\n     * _.filter(['abc', 'def'], /ef/);\n     * // => ['def']\n     */\n    function iteratee(func) {\n      return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that performs a partial deep comparison between a given\n     * object and `source`, returning `true` if the given object has equivalent\n     * property values, else `false`.\n     *\n     * **Note:** The created function is equivalent to `_.isMatch` with `source`\n     * partially applied.\n     *\n     * Partial comparisons will match empty array and empty object `source`\n     * values against any array or object value, respectively. See `_.isEqual`\n     * for a list of supported value comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {Object} source The object of property values to match.\n     * @returns {Function} Returns the new spec function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': 1, 'b': 2, 'c': 3 },\n     *   { 'a': 4, 'b': 5, 'c': 6 }\n     * ];\n     *\n     * _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));\n     * // => [{ 'a': 4, 'b': 5, 'c': 6 }]\n     */\n    function matches(source) {\n      return baseMatches(baseClone(source, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that performs a partial deep comparison between the\n     * value at `path` of a given object to `srcValue`, returning `true` if the\n     * object value is equivalent, else `false`.\n     *\n     * **Note:** Partial comparisons will match empty array and empty object\n     * `srcValue` values against any array or object value, respectively. See\n     * `_.isEqual` for a list of supported value comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.2.0\n     * @category Util\n     * @param {Array|string} path The path of the property to get.\n     * @param {*} srcValue The value to match.\n     * @returns {Function} Returns the new spec function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': 1, 'b': 2, 'c': 3 },\n     *   { 'a': 4, 'b': 5, 'c': 6 }\n     * ];\n     *\n     * _.find(objects, _.matchesProperty('a', 4));\n     * // => { 'a': 4, 'b': 5, 'c': 6 }\n     */\n    function matchesProperty(path, srcValue) {\n      return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that invokes the method at `path` of a given object.\n     * Any additional arguments are provided to the invoked method.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Util\n     * @param {Array|string} path The path of the method to invoke.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {Function} Returns the new invoker function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': { 'b': _.constant(2) } },\n     *   { 'a': { 'b': _.constant(1) } }\n     * ];\n     *\n     * _.map(objects, _.method('a.b'));\n     * // => [2, 1]\n     *\n     * _.map(objects, _.method(['a', 'b']));\n     * // => [2, 1]\n     */\n    var method = baseRest(function(path, args) {\n      return function(object) {\n        return baseInvoke(object, path, args);\n      };\n    });\n\n    /**\n     * The opposite of `_.method`; this method creates a function that invokes\n     * the method at a given path of `object`. Any additional arguments are\n     * provided to the invoked method.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Util\n     * @param {Object} object The object to query.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {Function} Returns the new invoker function.\n     * @example\n     *\n     * var array = _.times(3, _.constant),\n     *     object = { 'a': array, 'b': array, 'c': array };\n     *\n     * _.map(['a[2]', 'c[0]'], _.methodOf(object));\n     * // => [2, 0]\n     *\n     * _.map([['a', '2'], ['c', '0']], _.methodOf(object));\n     * // => [2, 0]\n     */\n    var methodOf = baseRest(function(object, args) {\n      return function(path) {\n        return baseInvoke(object, path, args);\n      };\n    });\n\n    /**\n     * Adds all own enumerable string keyed function properties of a source\n     * object to the destination object. If `object` is a function, then methods\n     * are added to its prototype as well.\n     *\n     * **Note:** Use `_.runInContext` to create a pristine `lodash` function to\n     * avoid conflicts caused by modifying the original.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {Function|Object} [object=lodash] The destination object.\n     * @param {Object} source The object of functions to add.\n     * @param {Object} [options={}] The options object.\n     * @param {boolean} [options.chain=true] Specify whether mixins are chainable.\n     * @returns {Function|Object} Returns `object`.\n     * @example\n     *\n     * function vowels(string) {\n     *   return _.filter(string, function(v) {\n     *     return /[aeiou]/i.test(v);\n     *   });\n     * }\n     *\n     * _.mixin({ 'vowels': vowels });\n     * _.vowels('fred');\n     * // => ['e']\n     *\n     * _('fred').vowels().value();\n     * // => ['e']\n     *\n     * _.mixin({ 'vowels': vowels }, { 'chain': false });\n     * _('fred').vowels();\n     * // => ['e']\n     */\n    function mixin(object, source, options) {\n      var props = keys(source),\n          methodNames = baseFunctions(source, props);\n\n      if (options == null &&\n          !(isObject(source) && (methodNames.length || !props.length))) {\n        options = source;\n        source = object;\n        object = this;\n        methodNames = baseFunctions(source, keys(source));\n      }\n      var chain = !(isObject(options) && 'chain' in options) || !!options.chain,\n          isFunc = isFunction(object);\n\n      arrayEach(methodNames, function(methodName) {\n        var func = source[methodName];\n        object[methodName] = func;\n        if (isFunc) {\n          object.prototype[methodName] = function() {\n            var chainAll = this.__chain__;\n            if (chain || chainAll) {\n              var result = object(this.__wrapped__),\n                  actions = result.__actions__ = copyArray(this.__actions__);\n\n              actions.push({ 'func': func, 'args': arguments, 'thisArg': object });\n              result.__chain__ = chainAll;\n              return result;\n            }\n            return func.apply(object, arrayPush([this.value()], arguments));\n          };\n        }\n      });\n\n      return object;\n    }\n\n    /**\n     * Reverts the `_` variable to its previous value and returns a reference to\n     * the `lodash` function.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @returns {Function} Returns the `lodash` function.\n     * @example\n     *\n     * var lodash = _.noConflict();\n     */\n    function noConflict() {\n      if (root._ === this) {\n        root._ = oldDash;\n      }\n      return this;\n    }\n\n    /**\n     * This method returns `undefined`.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.3.0\n     * @category Util\n     * @example\n     *\n     * _.times(2, _.noop);\n     * // => [undefined, undefined]\n     */\n    function noop() {\n      // No operation performed.\n    }\n\n    /**\n     * Creates a function that gets the argument at index `n`. If `n` is negative,\n     * the nth argument from the end is returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {number} [n=0] The index of the argument to return.\n     * @returns {Function} Returns the new pass-thru function.\n     * @example\n     *\n     * var func = _.nthArg(1);\n     * func('a', 'b', 'c', 'd');\n     * // => 'b'\n     *\n     * var func = _.nthArg(-2);\n     * func('a', 'b', 'c', 'd');\n     * // => 'c'\n     */\n    function nthArg(n) {\n      n = toInteger(n);\n      return baseRest(function(args) {\n        return baseNth(args, n);\n      });\n    }\n\n    /**\n     * Creates a function that invokes `iteratees` with the arguments it receives\n     * and returns their results.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [iteratees=[_.identity]]\n     *  The iteratees to invoke.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var func = _.over([Math.max, Math.min]);\n     *\n     * func(1, 2, 3, 4);\n     * // => [4, 1]\n     */\n    var over = createOver(arrayMap);\n\n    /**\n     * Creates a function that checks if **all** of the `predicates` return\n     * truthy when invoked with the arguments it receives.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [predicates=[_.identity]]\n     *  The predicates to check.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var func = _.overEvery([Boolean, isFinite]);\n     *\n     * func('1');\n     * // => true\n     *\n     * func(null);\n     * // => false\n     *\n     * func(NaN);\n     * // => false\n     */\n    var overEvery = createOver(arrayEvery);\n\n    /**\n     * Creates a function that checks if **any** of the `predicates` return\n     * truthy when invoked with the arguments it receives.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [predicates=[_.identity]]\n     *  The predicates to check.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var func = _.overSome([Boolean, isFinite]);\n     *\n     * func('1');\n     * // => true\n     *\n     * func(null);\n     * // => true\n     *\n     * func(NaN);\n     * // => false\n     */\n    var overSome = createOver(arraySome);\n\n    /**\n     * Creates a function that returns the value at `path` of a given object.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Util\n     * @param {Array|string} path The path of the property to get.\n     * @returns {Function} Returns the new accessor function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': { 'b': 2 } },\n     *   { 'a': { 'b': 1 } }\n     * ];\n     *\n     * _.map(objects, _.property('a.b'));\n     * // => [2, 1]\n     *\n     * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');\n     * // => [1, 2]\n     */\n    function property(path) {\n      return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);\n    }\n\n    /**\n     * The opposite of `_.property`; this method creates a function that returns\n     * the value at a given path of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {Object} object The object to query.\n     * @returns {Function} Returns the new accessor function.\n     * @example\n     *\n     * var array = [0, 1, 2],\n     *     object = { 'a': array, 'b': array, 'c': array };\n     *\n     * _.map(['a[2]', 'c[0]'], _.propertyOf(object));\n     * // => [2, 0]\n     *\n     * _.map([['a', '2'], ['c', '0']], _.propertyOf(object));\n     * // => [2, 0]\n     */\n    function propertyOf(object) {\n      return function(path) {\n        return object == null ? undefined : baseGet(object, path);\n      };\n    }\n\n    /**\n     * Creates an array of numbers (positive and/or negative) progressing from\n     * `start` up to, but not including, `end`. A step of `-1` is used if a negative\n     * `start` is specified without an `end` or `step`. If `end` is not specified,\n     * it's set to `start` with `start` then set to `0`.\n     *\n     * **Note:** JavaScript follows the IEEE-754 standard for resolving\n     * floating-point values which can produce unexpected results.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {number} [start=0] The start of the range.\n     * @param {number} end The end of the range.\n     * @param {number} [step=1] The value to increment or decrement by.\n     * @returns {Array} Returns the range of numbers.\n     * @see _.inRange, _.rangeRight\n     * @example\n     *\n     * _.range(4);\n     * // => [0, 1, 2, 3]\n     *\n     * _.range(-4);\n     * // => [0, -1, -2, -3]\n     *\n     * _.range(1, 5);\n     * // => [1, 2, 3, 4]\n     *\n     * _.range(0, 20, 5);\n     * // => [0, 5, 10, 15]\n     *\n     * _.range(0, -4, -1);\n     * // => [0, -1, -2, -3]\n     *\n     * _.range(1, 4, 0);\n     * // => [1, 1, 1]\n     *\n     * _.range(0);\n     * // => []\n     */\n    var range = createRange();\n\n    /**\n     * This method is like `_.range` except that it populates values in\n     * descending order.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {number} [start=0] The start of the range.\n     * @param {number} end The end of the range.\n     * @param {number} [step=1] The value to increment or decrement by.\n     * @returns {Array} Returns the range of numbers.\n     * @see _.inRange, _.range\n     * @example\n     *\n     * _.rangeRight(4);\n     * // => [3, 2, 1, 0]\n     *\n     * _.rangeRight(-4);\n     * // => [-3, -2, -1, 0]\n     *\n     * _.rangeRight(1, 5);\n     * // => [4, 3, 2, 1]\n     *\n     * _.rangeRight(0, 20, 5);\n     * // => [15, 10, 5, 0]\n     *\n     * _.rangeRight(0, -4, -1);\n     * // => [-3, -2, -1, 0]\n     *\n     * _.rangeRight(1, 4, 0);\n     * // => [1, 1, 1]\n     *\n     * _.rangeRight(0);\n     * // => []\n     */\n    var rangeRight = createRange(true);\n\n    /**\n     * This method returns a new empty array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {Array} Returns the new empty array.\n     * @example\n     *\n     * var arrays = _.times(2, _.stubArray);\n     *\n     * console.log(arrays);\n     * // => [[], []]\n     *\n     * console.log(arrays[0] === arrays[1]);\n     * // => false\n     */\n    function stubArray() {\n      return [];\n    }\n\n    /**\n     * This method returns `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {boolean} Returns `false`.\n     * @example\n     *\n     * _.times(2, _.stubFalse);\n     * // => [false, false]\n     */\n    function stubFalse() {\n      return false;\n    }\n\n    /**\n     * This method returns a new empty object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {Object} Returns the new empty object.\n     * @example\n     *\n     * var objects = _.times(2, _.stubObject);\n     *\n     * console.log(objects);\n     * // => [{}, {}]\n     *\n     * console.log(objects[0] === objects[1]);\n     * // => false\n     */\n    function stubObject() {\n      return {};\n    }\n\n    /**\n     * This method returns an empty string.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {string} Returns the empty string.\n     * @example\n     *\n     * _.times(2, _.stubString);\n     * // => ['', '']\n     */\n    function stubString() {\n      return '';\n    }\n\n    /**\n     * This method returns `true`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {boolean} Returns `true`.\n     * @example\n     *\n     * _.times(2, _.stubTrue);\n     * // => [true, true]\n     */\n    function stubTrue() {\n      return true;\n    }\n\n    /**\n     * Invokes the iteratee `n` times, returning an array of the results of\n     * each invocation. The iteratee is invoked with one argument; (index).\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {number} n The number of times to invoke `iteratee`.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the array of results.\n     * @example\n     *\n     * _.times(3, String);\n     * // => ['0', '1', '2']\n     *\n     *  _.times(4, _.constant(0));\n     * // => [0, 0, 0, 0]\n     */\n    function times(n, iteratee) {\n      n = toInteger(n);\n      if (n < 1 || n > MAX_SAFE_INTEGER) {\n        return [];\n      }\n      var index = MAX_ARRAY_LENGTH,\n          length = nativeMin(n, MAX_ARRAY_LENGTH);\n\n      iteratee = getIteratee(iteratee);\n      n -= MAX_ARRAY_LENGTH;\n\n      var result = baseTimes(length, iteratee);\n      while (++index < n) {\n        iteratee(index);\n      }\n      return result;\n    }\n\n    /**\n     * Converts `value` to a property path array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {*} value The value to convert.\n     * @returns {Array} Returns the new property path array.\n     * @example\n     *\n     * _.toPath('a.b.c');\n     * // => ['a', 'b', 'c']\n     *\n     * _.toPath('a[0].b.c');\n     * // => ['a', '0', 'b', 'c']\n     */\n    function toPath(value) {\n      if (isArray(value)) {\n        return arrayMap(value, toKey);\n      }\n      return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));\n    }\n\n    /**\n     * Generates a unique ID. If `prefix` is given, the ID is appended to it.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {string} [prefix=''] The value to prefix the ID with.\n     * @returns {string} Returns the unique ID.\n     * @example\n     *\n     * _.uniqueId('contact_');\n     * // => 'contact_104'\n     *\n     * _.uniqueId();\n     * // => '105'\n     */\n    function uniqueId(prefix) {\n      var id = ++idCounter;\n      return toString(prefix) + id;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Adds two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.4.0\n     * @category Math\n     * @param {number} augend The first number in an addition.\n     * @param {number} addend The second number in an addition.\n     * @returns {number} Returns the total.\n     * @example\n     *\n     * _.add(6, 4);\n     * // => 10\n     */\n    var add = createMathOperation(function(augend, addend) {\n      return augend + addend;\n    }, 0);\n\n    /**\n     * Computes `number` rounded up to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Math\n     * @param {number} number The number to round up.\n     * @param {number} [precision=0] The precision to round up to.\n     * @returns {number} Returns the rounded up number.\n     * @example\n     *\n     * _.ceil(4.006);\n     * // => 5\n     *\n     * _.ceil(6.004, 2);\n     * // => 6.01\n     *\n     * _.ceil(6040, -2);\n     * // => 6100\n     */\n    var ceil = createRound('ceil');\n\n    /**\n     * Divide two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Math\n     * @param {number} dividend The first number in a division.\n     * @param {number} divisor The second number in a division.\n     * @returns {number} Returns the quotient.\n     * @example\n     *\n     * _.divide(6, 4);\n     * // => 1.5\n     */\n    var divide = createMathOperation(function(dividend, divisor) {\n      return dividend / divisor;\n    }, 1);\n\n    /**\n     * Computes `number` rounded down to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Math\n     * @param {number} number The number to round down.\n     * @param {number} [precision=0] The precision to round down to.\n     * @returns {number} Returns the rounded down number.\n     * @example\n     *\n     * _.floor(4.006);\n     * // => 4\n     *\n     * _.floor(0.046, 2);\n     * // => 0.04\n     *\n     * _.floor(4060, -2);\n     * // => 4000\n     */\n    var floor = createRound('floor');\n\n    /**\n     * Computes the maximum value of `array`. If `array` is empty or falsey,\n     * `undefined` is returned.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {*} Returns the maximum value.\n     * @example\n     *\n     * _.max([4, 2, 8, 6]);\n     * // => 8\n     *\n     * _.max([]);\n     * // => undefined\n     */\n    function max(array) {\n      return (array && array.length)\n        ? baseExtremum(array, identity, baseGt)\n        : undefined;\n    }\n\n    /**\n     * This method is like `_.max` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the criterion by which\n     * the value is ranked. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {*} Returns the maximum value.\n     * @example\n     *\n     * var objects = [{ 'n': 1 }, { 'n': 2 }];\n     *\n     * _.maxBy(objects, function(o) { return o.n; });\n     * // => { 'n': 2 }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.maxBy(objects, 'n');\n     * // => { 'n': 2 }\n     */\n    function maxBy(array, iteratee) {\n      return (array && array.length)\n        ? baseExtremum(array, getIteratee(iteratee, 2), baseGt)\n        : undefined;\n    }\n\n    /**\n     * Computes the mean of the values in `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {number} Returns the mean.\n     * @example\n     *\n     * _.mean([4, 2, 8, 6]);\n     * // => 5\n     */\n    function mean(array) {\n      return baseMean(array, identity);\n    }\n\n    /**\n     * This method is like `_.mean` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the value to be averaged.\n     * The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the mean.\n     * @example\n     *\n     * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];\n     *\n     * _.meanBy(objects, function(o) { return o.n; });\n     * // => 5\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.meanBy(objects, 'n');\n     * // => 5\n     */\n    function meanBy(array, iteratee) {\n      return baseMean(array, getIteratee(iteratee, 2));\n    }\n\n    /**\n     * Computes the minimum value of `array`. If `array` is empty or falsey,\n     * `undefined` is returned.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {*} Returns the minimum value.\n     * @example\n     *\n     * _.min([4, 2, 8, 6]);\n     * // => 2\n     *\n     * _.min([]);\n     * // => undefined\n     */\n    function min(array) {\n      return (array && array.length)\n        ? baseExtremum(array, identity, baseLt)\n        : undefined;\n    }\n\n    /**\n     * This method is like `_.min` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the criterion by which\n     * the value is ranked. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {*} Returns the minimum value.\n     * @example\n     *\n     * var objects = [{ 'n': 1 }, { 'n': 2 }];\n     *\n     * _.minBy(objects, function(o) { return o.n; });\n     * // => { 'n': 1 }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.minBy(objects, 'n');\n     * // => { 'n': 1 }\n     */\n    function minBy(array, iteratee) {\n      return (array && array.length)\n        ? baseExtremum(array, getIteratee(iteratee, 2), baseLt)\n        : undefined;\n    }\n\n    /**\n     * Multiply two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Math\n     * @param {number} multiplier The first number in a multiplication.\n     * @param {number} multiplicand The second number in a multiplication.\n     * @returns {number} Returns the product.\n     * @example\n     *\n     * _.multiply(6, 4);\n     * // => 24\n     */\n    var multiply = createMathOperation(function(multiplier, multiplicand) {\n      return multiplier * multiplicand;\n    }, 1);\n\n    /**\n     * Computes `number` rounded to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Math\n     * @param {number} number The number to round.\n     * @param {number} [precision=0] The precision to round to.\n     * @returns {number} Returns the rounded number.\n     * @example\n     *\n     * _.round(4.006);\n     * // => 4\n     *\n     * _.round(4.006, 2);\n     * // => 4.01\n     *\n     * _.round(4060, -2);\n     * // => 4100\n     */\n    var round = createRound('round');\n\n    /**\n     * Subtract two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {number} minuend The first number in a subtraction.\n     * @param {number} subtrahend The second number in a subtraction.\n     * @returns {number} Returns the difference.\n     * @example\n     *\n     * _.subtract(6, 4);\n     * // => 2\n     */\n    var subtract = createMathOperation(function(minuend, subtrahend) {\n      return minuend - subtrahend;\n    }, 0);\n\n    /**\n     * Computes the sum of the values in `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.4.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {number} Returns the sum.\n     * @example\n     *\n     * _.sum([4, 2, 8, 6]);\n     * // => 20\n     */\n    function sum(array) {\n      return (array && array.length)\n        ? baseSum(array, identity)\n        : 0;\n    }\n\n    /**\n     * This method is like `_.sum` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the value to be summed.\n     * The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the sum.\n     * @example\n     *\n     * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];\n     *\n     * _.sumBy(objects, function(o) { return o.n; });\n     * // => 20\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.sumBy(objects, 'n');\n     * // => 20\n     */\n    function sumBy(array, iteratee) {\n      return (array && array.length)\n        ? baseSum(array, getIteratee(iteratee, 2))\n        : 0;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    // Add methods that return wrapped values in chain sequences.\n    lodash.after = after;\n    lodash.ary = ary;\n    lodash.assign = assign;\n    lodash.assignIn = assignIn;\n    lodash.assignInWith = assignInWith;\n    lodash.assignWith = assignWith;\n    lodash.at = at;\n    lodash.before = before;\n    lodash.bind = bind;\n    lodash.bindAll = bindAll;\n    lodash.bindKey = bindKey;\n    lodash.castArray = castArray;\n    lodash.chain = chain;\n    lodash.chunk = chunk;\n    lodash.compact = compact;\n    lodash.concat = concat;\n    lodash.cond = cond;\n    lodash.conforms = conforms;\n    lodash.constant = constant;\n    lodash.countBy = countBy;\n    lodash.create = create;\n    lodash.curry = curry;\n    lodash.curryRight = curryRight;\n    lodash.debounce = debounce;\n    lodash.defaults = defaults;\n    lodash.defaultsDeep = defaultsDeep;\n    lodash.defer = defer;\n    lodash.delay = delay;\n    lodash.difference = difference;\n    lodash.differenceBy = differenceBy;\n    lodash.differenceWith = differenceWith;\n    lodash.drop = drop;\n    lodash.dropRight = dropRight;\n    lodash.dropRightWhile = dropRightWhile;\n    lodash.dropWhile = dropWhile;\n    lodash.fill = fill;\n    lodash.filter = filter;\n    lodash.flatMap = flatMap;\n    lodash.flatMapDeep = flatMapDeep;\n    lodash.flatMapDepth = flatMapDepth;\n    lodash.flatten = flatten;\n    lodash.flattenDeep = flattenDeep;\n    lodash.flattenDepth = flattenDepth;\n    lodash.flip = flip;\n    lodash.flow = flow;\n    lodash.flowRight = flowRight;\n    lodash.fromPairs = fromPairs;\n    lodash.functions = functions;\n    lodash.functionsIn = functionsIn;\n    lodash.groupBy = groupBy;\n    lodash.initial = initial;\n    lodash.intersection = intersection;\n    lodash.intersectionBy = intersectionBy;\n    lodash.intersectionWith = intersectionWith;\n    lodash.invert = invert;\n    lodash.invertBy = invertBy;\n    lodash.invokeMap = invokeMap;\n    lodash.iteratee = iteratee;\n    lodash.keyBy = keyBy;\n    lodash.keys = keys;\n    lodash.keysIn = keysIn;\n    lodash.map = map;\n    lodash.mapKeys = mapKeys;\n    lodash.mapValues = mapValues;\n    lodash.matches = matches;\n    lodash.matchesProperty = matchesProperty;\n    lodash.memoize = memoize;\n    lodash.merge = merge;\n    lodash.mergeWith = mergeWith;\n    lodash.method = method;\n    lodash.methodOf = methodOf;\n    lodash.mixin = mixin;\n    lodash.negate = negate;\n    lodash.nthArg = nthArg;\n    lodash.omit = omit;\n    lodash.omitBy = omitBy;\n    lodash.once = once;\n    lodash.orderBy = orderBy;\n    lodash.over = over;\n    lodash.overArgs = overArgs;\n    lodash.overEvery = overEvery;\n    lodash.overSome = overSome;\n    lodash.partial = partial;\n    lodash.partialRight = partialRight;\n    lodash.partition = partition;\n    lodash.pick = pick;\n    lodash.pickBy = pickBy;\n    lodash.property = property;\n    lodash.propertyOf = propertyOf;\n    lodash.pull = pull;\n    lodash.pullAll = pullAll;\n    lodash.pullAllBy = pullAllBy;\n    lodash.pullAllWith = pullAllWith;\n    lodash.pullAt = pullAt;\n    lodash.range = range;\n    lodash.rangeRight = rangeRight;\n    lodash.rearg = rearg;\n    lodash.reject = reject;\n    lodash.remove = remove;\n    lodash.rest = rest;\n    lodash.reverse = reverse;\n    lodash.sampleSize = sampleSize;\n    lodash.set = set;\n    lodash.setWith = setWith;\n    lodash.shuffle = shuffle;\n    lodash.slice = slice;\n    lodash.sortBy = sortBy;\n    lodash.sortedUniq = sortedUniq;\n    lodash.sortedUniqBy = sortedUniqBy;\n    lodash.split = split;\n    lodash.spread = spread;\n    lodash.tail = tail;\n    lodash.take = take;\n    lodash.takeRight = takeRight;\n    lodash.takeRightWhile = takeRightWhile;\n    lodash.takeWhile = takeWhile;\n    lodash.tap = tap;\n    lodash.throttle = throttle;\n    lodash.thru = thru;\n    lodash.toArray = toArray;\n    lodash.toPairs = toPairs;\n    lodash.toPairsIn = toPairsIn;\n    lodash.toPath = toPath;\n    lodash.toPlainObject = toPlainObject;\n    lodash.transform = transform;\n    lodash.unary = unary;\n    lodash.union = union;\n    lodash.unionBy = unionBy;\n    lodash.unionWith = unionWith;\n    lodash.uniq = uniq;\n    lodash.uniqBy = uniqBy;\n    lodash.uniqWith = uniqWith;\n    lodash.unset = unset;\n    lodash.unzip = unzip;\n    lodash.unzipWith = unzipWith;\n    lodash.update = update;\n    lodash.updateWith = updateWith;\n    lodash.values = values;\n    lodash.valuesIn = valuesIn;\n    lodash.without = without;\n    lodash.words = words;\n    lodash.wrap = wrap;\n    lodash.xor = xor;\n    lodash.xorBy = xorBy;\n    lodash.xorWith = xorWith;\n    lodash.zip = zip;\n    lodash.zipObject = zipObject;\n    lodash.zipObjectDeep = zipObjectDeep;\n    lodash.zipWith = zipWith;\n\n    // Add aliases.\n    lodash.entries = toPairs;\n    lodash.entriesIn = toPairsIn;\n    lodash.extend = assignIn;\n    lodash.extendWith = assignInWith;\n\n    // Add methods to `lodash.prototype`.\n    mixin(lodash, lodash);\n\n    /*------------------------------------------------------------------------*/\n\n    // Add methods that return unwrapped values in chain sequences.\n    lodash.add = add;\n    lodash.attempt = attempt;\n    lodash.camelCase = camelCase;\n    lodash.capitalize = capitalize;\n    lodash.ceil = ceil;\n    lodash.clamp = clamp;\n    lodash.clone = clone;\n    lodash.cloneDeep = cloneDeep;\n    lodash.cloneDeepWith = cloneDeepWith;\n    lodash.cloneWith = cloneWith;\n    lodash.conformsTo = conformsTo;\n    lodash.deburr = deburr;\n    lodash.defaultTo = defaultTo;\n    lodash.divide = divide;\n    lodash.endsWith = endsWith;\n    lodash.eq = eq;\n    lodash.escape = escape;\n    lodash.escapeRegExp = escapeRegExp;\n    lodash.every = every;\n    lodash.find = find;\n    lodash.findIndex = findIndex;\n    lodash.findKey = findKey;\n    lodash.findLast = findLast;\n    lodash.findLastIndex = findLastIndex;\n    lodash.findLastKey = findLastKey;\n    lodash.floor = floor;\n    lodash.forEach = forEach;\n    lodash.forEachRight = forEachRight;\n    lodash.forIn = forIn;\n    lodash.forInRight = forInRight;\n    lodash.forOwn = forOwn;\n    lodash.forOwnRight = forOwnRight;\n    lodash.get = get;\n    lodash.gt = gt;\n    lodash.gte = gte;\n    lodash.has = has;\n    lodash.hasIn = hasIn;\n    lodash.head = head;\n    lodash.identity = identity;\n    lodash.includes = includes;\n    lodash.indexOf = indexOf;\n    lodash.inRange = inRange;\n    lodash.invoke = invoke;\n    lodash.isArguments = isArguments;\n    lodash.isArray = isArray;\n    lodash.isArrayBuffer = isArrayBuffer;\n    lodash.isArrayLike = isArrayLike;\n    lodash.isArrayLikeObject = isArrayLikeObject;\n    lodash.isBoolean = isBoolean;\n    lodash.isBuffer = isBuffer;\n    lodash.isDate = isDate;\n    lodash.isElement = isElement;\n    lodash.isEmpty = isEmpty;\n    lodash.isEqual = isEqual;\n    lodash.isEqualWith = isEqualWith;\n    lodash.isError = isError;\n    lodash.isFinite = isFinite;\n    lodash.isFunction = isFunction;\n    lodash.isInteger = isInteger;\n    lodash.isLength = isLength;\n    lodash.isMap = isMap;\n    lodash.isMatch = isMatch;\n    lodash.isMatchWith = isMatchWith;\n    lodash.isNaN = isNaN;\n    lodash.isNative = isNative;\n    lodash.isNil = isNil;\n    lodash.isNull = isNull;\n    lodash.isNumber = isNumber;\n    lodash.isObject = isObject;\n    lodash.isObjectLike = isObjectLike;\n    lodash.isPlainObject = isPlainObject;\n    lodash.isRegExp = isRegExp;\n    lodash.isSafeInteger = isSafeInteger;\n    lodash.isSet = isSet;\n    lodash.isString = isString;\n    lodash.isSymbol = isSymbol;\n    lodash.isTypedArray = isTypedArray;\n    lodash.isUndefined = isUndefined;\n    lodash.isWeakMap = isWeakMap;\n    lodash.isWeakSet = isWeakSet;\n    lodash.join = join;\n    lodash.kebabCase = kebabCase;\n    lodash.last = last;\n    lodash.lastIndexOf = lastIndexOf;\n    lodash.lowerCase = lowerCase;\n    lodash.lowerFirst = lowerFirst;\n    lodash.lt = lt;\n    lodash.lte = lte;\n    lodash.max = max;\n    lodash.maxBy = maxBy;\n    lodash.mean = mean;\n    lodash.meanBy = meanBy;\n    lodash.min = min;\n    lodash.minBy = minBy;\n    lodash.stubArray = stubArray;\n    lodash.stubFalse = stubFalse;\n    lodash.stubObject = stubObject;\n    lodash.stubString = stubString;\n    lodash.stubTrue = stubTrue;\n    lodash.multiply = multiply;\n    lodash.nth = nth;\n    lodash.noConflict = noConflict;\n    lodash.noop = noop;\n    lodash.now = now;\n    lodash.pad = pad;\n    lodash.padEnd = padEnd;\n    lodash.padStart = padStart;\n    lodash.parseInt = parseInt;\n    lodash.random = random;\n    lodash.reduce = reduce;\n    lodash.reduceRight = reduceRight;\n    lodash.repeat = repeat;\n    lodash.replace = replace;\n    lodash.result = result;\n    lodash.round = round;\n    lodash.runInContext = runInContext;\n    lodash.sample = sample;\n    lodash.size = size;\n    lodash.snakeCase = snakeCase;\n    lodash.some = some;\n    lodash.sortedIndex = sortedIndex;\n    lodash.sortedIndexBy = sortedIndexBy;\n    lodash.sortedIndexOf = sortedIndexOf;\n    lodash.sortedLastIndex = sortedLastIndex;\n    lodash.sortedLastIndexBy = sortedLastIndexBy;\n    lodash.sortedLastIndexOf = sortedLastIndexOf;\n    lodash.startCase = startCase;\n    lodash.startsWith = startsWith;\n    lodash.subtract = subtract;\n    lodash.sum = sum;\n    lodash.sumBy = sumBy;\n    lodash.template = template;\n    lodash.times = times;\n    lodash.toFinite = toFinite;\n    lodash.toInteger = toInteger;\n    lodash.toLength = toLength;\n    lodash.toLower = toLower;\n    lodash.toNumber = toNumber;\n    lodash.toSafeInteger = toSafeInteger;\n    lodash.toString = toString;\n    lodash.toUpper = toUpper;\n    lodash.trim = trim;\n    lodash.trimEnd = trimEnd;\n    lodash.trimStart = trimStart;\n    lodash.truncate = truncate;\n    lodash.unescape = unescape;\n    lodash.uniqueId = uniqueId;\n    lodash.upperCase = upperCase;\n    lodash.upperFirst = upperFirst;\n\n    // Add aliases.\n    lodash.each = forEach;\n    lodash.eachRight = forEachRight;\n    lodash.first = head;\n\n    mixin(lodash, (function() {\n      var source = {};\n      baseForOwn(lodash, function(func, methodName) {\n        if (!hasOwnProperty.call(lodash.prototype, methodName)) {\n          source[methodName] = func;\n        }\n      });\n      return source;\n    }()), { 'chain': false });\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * The semantic version number.\n     *\n     * @static\n     * @memberOf _\n     * @type {string}\n     */\n    lodash.VERSION = VERSION;\n\n    // Assign default placeholders.\n    arrayEach(['bind', 'bindKey', 'curry', 'curryRight', 'partial', 'partialRight'], function(methodName) {\n      lodash[methodName].placeholder = lodash;\n    });\n\n    // Add `LazyWrapper` methods for `_.drop` and `_.take` variants.\n    arrayEach(['drop', 'take'], function(methodName, index) {\n      LazyWrapper.prototype[methodName] = function(n) {\n        n = n === undefined ? 1 : nativeMax(toInteger(n), 0);\n\n        var result = (this.__filtered__ && !index)\n          ? new LazyWrapper(this)\n          : this.clone();\n\n        if (result.__filtered__) {\n          result.__takeCount__ = nativeMin(n, result.__takeCount__);\n        } else {\n          result.__views__.push({\n            'size': nativeMin(n, MAX_ARRAY_LENGTH),\n            'type': methodName + (result.__dir__ < 0 ? 'Right' : '')\n          });\n        }\n        return result;\n      };\n\n      LazyWrapper.prototype[methodName + 'Right'] = function(n) {\n        return this.reverse()[methodName](n).reverse();\n      };\n    });\n\n    // Add `LazyWrapper` methods that accept an `iteratee` value.\n    arrayEach(['filter', 'map', 'takeWhile'], function(methodName, index) {\n      var type = index + 1,\n          isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;\n\n      LazyWrapper.prototype[methodName] = function(iteratee) {\n        var result = this.clone();\n        result.__iteratees__.push({\n          'iteratee': getIteratee(iteratee, 3),\n          'type': type\n        });\n        result.__filtered__ = result.__filtered__ || isFilter;\n        return result;\n      };\n    });\n\n    // Add `LazyWrapper` methods for `_.head` and `_.last`.\n    arrayEach(['head', 'last'], function(methodName, index) {\n      var takeName = 'take' + (index ? 'Right' : '');\n\n      LazyWrapper.prototype[methodName] = function() {\n        return this[takeName](1).value()[0];\n      };\n    });\n\n    // Add `LazyWrapper` methods for `_.initial` and `_.tail`.\n    arrayEach(['initial', 'tail'], function(methodName, index) {\n      var dropName = 'drop' + (index ? '' : 'Right');\n\n      LazyWrapper.prototype[methodName] = function() {\n        return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);\n      };\n    });\n\n    LazyWrapper.prototype.compact = function() {\n      return this.filter(identity);\n    };\n\n    LazyWrapper.prototype.find = function(predicate) {\n      return this.filter(predicate).head();\n    };\n\n    LazyWrapper.prototype.findLast = function(predicate) {\n      return this.reverse().find(predicate);\n    };\n\n    LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {\n      if (typeof path == 'function') {\n        return new LazyWrapper(this);\n      }\n      return this.map(function(value) {\n        return baseInvoke(value, path, args);\n      });\n    });\n\n    LazyWrapper.prototype.reject = function(predicate) {\n      return this.filter(negate(getIteratee(predicate)));\n    };\n\n    LazyWrapper.prototype.slice = function(start, end) {\n      start = toInteger(start);\n\n      var result = this;\n      if (result.__filtered__ && (start > 0 || end < 0)) {\n        return new LazyWrapper(result);\n      }\n      if (start < 0) {\n        result = result.takeRight(-start);\n      } else if (start) {\n        result = result.drop(start);\n      }\n      if (end !== undefined) {\n        end = toInteger(end);\n        result = end < 0 ? result.dropRight(-end) : result.take(end - start);\n      }\n      return result;\n    };\n\n    LazyWrapper.prototype.takeRightWhile = function(predicate) {\n      return this.reverse().takeWhile(predicate).reverse();\n    };\n\n    LazyWrapper.prototype.toArray = function() {\n      return this.take(MAX_ARRAY_LENGTH);\n    };\n\n    // Add `LazyWrapper` methods to `lodash.prototype`.\n    baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n      var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName),\n          isTaker = /^(?:head|last)$/.test(methodName),\n          lodashFunc = lodash[isTaker ? ('take' + (methodName == 'last' ? 'Right' : '')) : methodName],\n          retUnwrapped = isTaker || /^find/.test(methodName);\n\n      if (!lodashFunc) {\n        return;\n      }\n      lodash.prototype[methodName] = function() {\n        var value = this.__wrapped__,\n            args = isTaker ? [1] : arguments,\n            isLazy = value instanceof LazyWrapper,\n            iteratee = args[0],\n            useLazy = isLazy || isArray(value);\n\n        var interceptor = function(value) {\n          var result = lodashFunc.apply(lodash, arrayPush([value], args));\n          return (isTaker && chainAll) ? result[0] : result;\n        };\n\n        if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) {\n          // Avoid lazy use if the iteratee has a \"length\" value other than `1`.\n          isLazy = useLazy = false;\n        }\n        var chainAll = this.__chain__,\n            isHybrid = !!this.__actions__.length,\n            isUnwrapped = retUnwrapped && !chainAll,\n            onlyLazy = isLazy && !isHybrid;\n\n        if (!retUnwrapped && useLazy) {\n          value = onlyLazy ? value : new LazyWrapper(this);\n          var result = func.apply(value, args);\n          result.__actions__.push({ 'func': thru, 'args': [interceptor], 'thisArg': undefined });\n          return new LodashWrapper(result, chainAll);\n        }\n        if (isUnwrapped && onlyLazy) {\n          return func.apply(this, args);\n        }\n        result = this.thru(interceptor);\n        return isUnwrapped ? (isTaker ? result.value()[0] : result.value()) : result;\n      };\n    });\n\n    // Add `Array` methods to `lodash.prototype`.\n    arrayEach(['pop', 'push', 'shift', 'sort', 'splice', 'unshift'], function(methodName) {\n      var func = arrayProto[methodName],\n          chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru',\n          retUnwrapped = /^(?:pop|shift)$/.test(methodName);\n\n      lodash.prototype[methodName] = function() {\n        var args = arguments;\n        if (retUnwrapped && !this.__chain__) {\n          var value = this.value();\n          return func.apply(isArray(value) ? value : [], args);\n        }\n        return this[chainName](function(value) {\n          return func.apply(isArray(value) ? value : [], args);\n        });\n      };\n    });\n\n    // Map minified method names to their real names.\n    baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n      var lodashFunc = lodash[methodName];\n      if (lodashFunc) {\n        var key = (lodashFunc.name + ''),\n            names = realNames[key] || (realNames[key] = []);\n\n        names.push({ 'name': methodName, 'func': lodashFunc });\n      }\n    });\n\n    realNames[createHybrid(undefined, WRAP_BIND_KEY_FLAG).name] = [{\n      'name': 'wrapper',\n      'func': undefined\n    }];\n\n    // Add methods to `LazyWrapper`.\n    LazyWrapper.prototype.clone = lazyClone;\n    LazyWrapper.prototype.reverse = lazyReverse;\n    LazyWrapper.prototype.value = lazyValue;\n\n    // Add chain sequence methods to the `lodash` wrapper.\n    lodash.prototype.at = wrapperAt;\n    lodash.prototype.chain = wrapperChain;\n    lodash.prototype.commit = wrapperCommit;\n    lodash.prototype.next = wrapperNext;\n    lodash.prototype.plant = wrapperPlant;\n    lodash.prototype.reverse = wrapperReverse;\n    lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;\n\n    // Add lazy aliases.\n    lodash.prototype.first = lodash.prototype.head;\n\n    if (symIterator) {\n      lodash.prototype[symIterator] = wrapperToIterator;\n    }\n    return lodash;\n  });\n\n  /*--------------------------------------------------------------------------*/\n\n  // Export lodash.\n  var _ = runInContext();\n\n  // Some AMD build optimizers, like r.js, check for condition patterns like:\n  if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {\n    // Expose Lodash on the global object to prevent errors when Lodash is\n    // loaded by a script tag in the presence of an AMD loader.\n    // See http://requirejs.org/docs/errors.html#mismatch for more details.\n    // Use `_.noConflict` to remove Lodash from the global object.\n    root._ = _;\n\n    // Define as an anonymous module so, through path mapping, it can be\n    // referenced as the \"underscore\" module.\n    define(function() {\n      return _;\n    });\n  }\n  // Check for `exports` after `define` in case a build optimizer adds it.\n  else if (freeModule) {\n    // Export for Node.js.\n    (freeModule.exports = _)._ = _;\n    // Export for CommonJS support.\n    freeExports._ = _;\n  }\n  else {\n    // Export to the global object.\n    root._ = _;\n  }\n}.call(this));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/lodash.js\n// module id = 3\n// module chunks = 0","// Thank's IE8 for his funny defineProperty\nmodule.exports = !require('./_fails')(function(){\n  return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_descriptors.js\n// module id = 4\n// module chunks = 0","// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nvar global = module.exports = typeof window != 'undefined' && window.Math == Math\n  ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();\nif(typeof __g == 'number')__g = global; // eslint-disable-line no-undef\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_global.js\n// module id = 5\n// module chunks = 0","var anObject       = require('./_an-object')\n  , IE8_DOM_DEFINE = require('./_ie8-dom-define')\n  , toPrimitive    = require('./_to-primitive')\n  , dP             = Object.defineProperty;\n\nexports.f = require('./_descriptors') ? Object.defineProperty : function defineProperty(O, P, Attributes){\n  anObject(O);\n  P = toPrimitive(P, true);\n  anObject(Attributes);\n  if(IE8_DOM_DEFINE)try {\n    return dP(O, P, Attributes);\n  } catch(e){ /* empty */ }\n  if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');\n  if('value' in Attributes)O[P] = Attributes.value;\n  return O;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-dp.js\n// module id = 6\n// module chunks = 0","\"use strict\";\n\nexports.__esModule = true;\n\nexports.default = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/helpers/classCallCheck.js\n// module id = 7\n// module chunks = 0","\"use strict\";\n\nexports.__esModule = true;\n\nvar _defineProperty = require(\"../core-js/object/define-property\");\n\nvar _defineProperty2 = _interopRequireDefault(_defineProperty);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      (0, _defineProperty2.default)(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/helpers/createClass.js\n// module id = 8\n// module chunks = 0","var isObject = require('./_is-object');\nmodule.exports = function(it){\n  if(!isObject(it))throw TypeError(it + ' is not an object!');\n  return it;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_an-object.js\n// module id = 9\n// module chunks = 0","var core = module.exports = {version: '2.4.0'};\nif(typeof __e == 'number')__e = core; // eslint-disable-line no-undef\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_core.js\n// module id = 10\n// module chunks = 0","var hasOwnProperty = {}.hasOwnProperty;\nmodule.exports = function(it, key){\n  return hasOwnProperty.call(it, key);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_has.js\n// module id = 11\n// module chunks = 0","var dP         = require('./_object-dp')\n  , createDesc = require('./_property-desc');\nmodule.exports = require('./_descriptors') ? function(object, key, value){\n  return dP.f(object, key, createDesc(1, value));\n} : function(object, key, value){\n  object[key] = value;\n  return object;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_hide.js\n// module id = 12\n// module chunks = 0","// 7.2.1 RequireObjectCoercible(argument)\nmodule.exports = function(it){\n  if(it == undefined)throw TypeError(\"Can't call method on  \" + it);\n  return it;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_defined.js\n// module id = 14\n// module chunks = 0","var global    = require('./_global')\n  , core      = require('./_core')\n  , ctx       = require('./_ctx')\n  , hide      = require('./_hide')\n  , PROTOTYPE = 'prototype';\n\nvar $export = function(type, name, source){\n  var IS_FORCED = type & $export.F\n    , IS_GLOBAL = type & $export.G\n    , IS_STATIC = type & $export.S\n    , IS_PROTO  = type & $export.P\n    , IS_BIND   = type & $export.B\n    , IS_WRAP   = type & $export.W\n    , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})\n    , expProto  = exports[PROTOTYPE]\n    , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]\n    , key, own, out;\n  if(IS_GLOBAL)source = name;\n  for(key in source){\n    // contains in native\n    own = !IS_FORCED && target && target[key] !== undefined;\n    if(own && key in exports)continue;\n    // export native or passed\n    out = own ? target[key] : source[key];\n    // prevent global pollution for namespaces\n    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]\n    // bind timers to global for call from export context\n    : IS_BIND && own ? ctx(out, global)\n    // wrap global constructors for prevent change them in library\n    : IS_WRAP && target[key] == out ? (function(C){\n      var F = function(a, b, c){\n        if(this instanceof C){\n          switch(arguments.length){\n            case 0: return new C;\n            case 1: return new C(a);\n            case 2: return new C(a, b);\n          } return new C(a, b, c);\n        } return C.apply(this, arguments);\n      };\n      F[PROTOTYPE] = C[PROTOTYPE];\n      return F;\n    // make static versions for prototype methods\n    })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;\n    // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%\n    if(IS_PROTO){\n      (exports.virtual || (exports.virtual = {}))[key] = out;\n      // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%\n      if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out);\n    }\n  }\n};\n// type bitmap\n$export.F = 1;   // forced\n$export.G = 2;   // global\n$export.S = 4;   // static\n$export.P = 8;   // proto\n$export.B = 16;  // bind\n$export.W = 32;  // wrap\n$export.U = 64;  // safe\n$export.R = 128; // real proto method for `library` \nmodule.exports = $export;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_export.js\n// module id = 15\n// module chunks = 0","module.exports = function(it){\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_is-object.js\n// module id = 16\n// module chunks = 0","module.exports = {};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iterators.js\n// module id = 17\n// module chunks = 0","module.exports = function(bitmap, value){\n  return {\n    enumerable  : !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable    : !(bitmap & 4),\n    value       : value\n  };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_property-desc.js\n// module id = 18\n// module chunks = 0","var shared = require('./_shared')('keys')\n  , uid    = require('./_uid');\nmodule.exports = function(key){\n  return shared[key] || (shared[key] = uid(key));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_shared-key.js\n// module id = 19\n// module chunks = 0","// 7.1.4 ToInteger\nvar ceil  = Math.ceil\n  , floor = Math.floor;\nmodule.exports = function(it){\n  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-integer.js\n// module id = 20\n// module chunks = 0","function objectConverter(columns) {\n  return new Function(\"d\", \"return {\" + columns.map(function(name, i) {\n    return JSON.stringify(name) + \": d[\" + i + \"]\";\n  }).join(\",\") + \"}\");\n}\n\nfunction customConverter(columns, f) {\n  var object = objectConverter(columns);\n  return function(row, i) {\n    return f(object(row), i, columns);\n  };\n}\n\n// Compute unique columns in order of discovery.\nfunction inferColumns(rows) {\n  var columnSet = Object.create(null),\n      columns = [];\n\n  rows.forEach(function(row) {\n    for (var column in row) {\n      if (!(column in columnSet)) {\n        columns.push(columnSet[column] = column);\n      }\n    }\n  });\n\n  return columns;\n}\n\nexport default function(delimiter) {\n  var reFormat = new RegExp(\"[\\\"\" + delimiter + \"\\n]\"),\n      delimiterCode = delimiter.charCodeAt(0);\n\n  function parse(text, f) {\n    var convert, columns, rows = parseRows(text, function(row, i) {\n      if (convert) return convert(row, i - 1);\n      columns = row, convert = f ? customConverter(row, f) : objectConverter(row);\n    });\n    rows.columns = columns;\n    return rows;\n  }\n\n  function parseRows(text, f) {\n    var EOL = {}, // sentinel value for end-of-line\n        EOF = {}, // sentinel value for end-of-file\n        rows = [], // output rows\n        N = text.length,\n        I = 0, // current character index\n        n = 0, // the current line number\n        t, // the current token\n        eol; // is the current token followed by EOL?\n\n    function token() {\n      if (I >= N) return EOF; // special case: end of file\n      if (eol) return eol = false, EOL; // special case: end of line\n\n      // special case: quotes\n      var j = I, c;\n      if (text.charCodeAt(j) === 34) {\n        var i = j;\n        while (i++ < N) {\n          if (text.charCodeAt(i) === 34) {\n            if (text.charCodeAt(i + 1) !== 34) break;\n            ++i;\n          }\n        }\n        I = i + 2;\n        c = text.charCodeAt(i + 1);\n        if (c === 13) {\n          eol = true;\n          if (text.charCodeAt(i + 2) === 10) ++I;\n        } else if (c === 10) {\n          eol = true;\n        }\n        return text.slice(j + 1, i).replace(/\"\"/g, \"\\\"\");\n      }\n\n      // common case: find next delimiter or newline\n      while (I < N) {\n        var k = 1;\n        c = text.charCodeAt(I++);\n        if (c === 10) eol = true; // \\n\n        else if (c === 13) { eol = true; if (text.charCodeAt(I) === 10) ++I, ++k; } // \\r|\\r\\n\n        else if (c !== delimiterCode) continue;\n        return text.slice(j, I - k);\n      }\n\n      // special case: last token before EOF\n      return text.slice(j);\n    }\n\n    while ((t = token()) !== EOF) {\n      var a = [];\n      while (t !== EOL && t !== EOF) {\n        a.push(t);\n        t = token();\n      }\n      if (f && (a = f(a, n++)) == null) continue;\n      rows.push(a);\n    }\n\n    return rows;\n  }\n\n  function format(rows, columns) {\n    if (columns == null) columns = inferColumns(rows);\n    return [columns.map(formatValue).join(delimiter)].concat(rows.map(function(row) {\n      return columns.map(function(column) {\n        return formatValue(row[column]);\n      }).join(delimiter);\n    })).join(\"\\n\");\n  }\n\n  function formatRows(rows) {\n    return rows.map(formatRow).join(\"\\n\");\n  }\n\n  function formatRow(row) {\n    return row.map(formatValue).join(delimiter);\n  }\n\n  function formatValue(text) {\n    return text == null ? \"\"\n        : reFormat.test(text += \"\") ? \"\\\"\" + text.replace(/\\\"/g, \"\\\"\\\"\") + \"\\\"\"\n        : text;\n  }\n\n  return {\n    parse: parse,\n    parseRows: parseRows,\n    format: format,\n    formatRows: formatRows\n  };\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3-dsv/src/dsv.js\n// module id = 21\n// module chunks = 0","/*!\n * Vue.js v2.1.10\n * (c) 2014-2017 Evan You\n * Released under the MIT License.\n */\n'use strict';\n\n/*  */\n\n/**\n * Convert a value to a string that is actually rendered.\n */\nfunction _toString (val) {\n  return val == null\n    ? ''\n    : typeof val === 'object'\n      ? JSON.stringify(val, null, 2)\n      : String(val)\n}\n\n/**\n * Convert a input value to a number for persistence.\n * If the conversion fails, return original string.\n */\nfunction toNumber (val) {\n  var n = parseFloat(val);\n  return isNaN(n) ? val : n\n}\n\n/**\n * Make a map and return a function for checking if a key\n * is in that map.\n */\nfunction makeMap (\n  str,\n  expectsLowerCase\n) {\n  var map = Object.create(null);\n  var list = str.split(',');\n  for (var i = 0; i < list.length; i++) {\n    map[list[i]] = true;\n  }\n  return expectsLowerCase\n    ? function (val) { return map[val.toLowerCase()]; }\n    : function (val) { return map[val]; }\n}\n\n/**\n * Check if a tag is a built-in tag.\n */\nvar isBuiltInTag = makeMap('slot,component', true);\n\n/**\n * Remove an item from an array\n */\nfunction remove$1 (arr, item) {\n  if (arr.length) {\n    var index = arr.indexOf(item);\n    if (index > -1) {\n      return arr.splice(index, 1)\n    }\n  }\n}\n\n/**\n * Check whether the object has the property.\n */\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction hasOwn (obj, key) {\n  return hasOwnProperty.call(obj, key)\n}\n\n/**\n * Check if value is primitive\n */\nfunction isPrimitive (value) {\n  return typeof value === 'string' || typeof value === 'number'\n}\n\n/**\n * Create a cached version of a pure function.\n */\nfunction cached (fn) {\n  var cache = Object.create(null);\n  return (function cachedFn (str) {\n    var hit = cache[str];\n    return hit || (cache[str] = fn(str))\n  })\n}\n\n/**\n * Camelize a hyphen-delimited string.\n */\nvar camelizeRE = /-(\\w)/g;\nvar camelize = cached(function (str) {\n  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })\n});\n\n/**\n * Capitalize a string.\n */\nvar capitalize = cached(function (str) {\n  return str.charAt(0).toUpperCase() + str.slice(1)\n});\n\n/**\n * Hyphenate a camelCase string.\n */\nvar hyphenateRE = /([^-])([A-Z])/g;\nvar hyphenate = cached(function (str) {\n  return str\n    .replace(hyphenateRE, '$1-$2')\n    .replace(hyphenateRE, '$1-$2')\n    .toLowerCase()\n});\n\n/**\n * Simple bind, faster than native\n */\nfunction bind$1 (fn, ctx) {\n  function boundFn (a) {\n    var l = arguments.length;\n    return l\n      ? l > 1\n        ? fn.apply(ctx, arguments)\n        : fn.call(ctx, a)\n      : fn.call(ctx)\n  }\n  // record original fn length\n  boundFn._length = fn.length;\n  return boundFn\n}\n\n/**\n * Convert an Array-like object to a real Array.\n */\nfunction toArray (list, start) {\n  start = start || 0;\n  var i = list.length - start;\n  var ret = new Array(i);\n  while (i--) {\n    ret[i] = list[i + start];\n  }\n  return ret\n}\n\n/**\n * Mix properties into target object.\n */\nfunction extend (to, _from) {\n  for (var key in _from) {\n    to[key] = _from[key];\n  }\n  return to\n}\n\n/**\n * Quick object check - this is primarily used to tell\n * Objects from primitive values when we know the value\n * is a JSON-compliant type.\n */\nfunction isObject (obj) {\n  return obj !== null && typeof obj === 'object'\n}\n\n/**\n * Strict object type check. Only returns true\n * for plain JavaScript objects.\n */\nvar toString = Object.prototype.toString;\nvar OBJECT_STRING = '[object Object]';\nfunction isPlainObject (obj) {\n  return toString.call(obj) === OBJECT_STRING\n}\n\n/**\n * Merge an Array of Objects into a single Object.\n */\nfunction toObject (arr) {\n  var res = {};\n  for (var i = 0; i < arr.length; i++) {\n    if (arr[i]) {\n      extend(res, arr[i]);\n    }\n  }\n  return res\n}\n\n/**\n * Perform no operation.\n */\nfunction noop () {}\n\n/**\n * Always return false.\n */\nvar no = function () { return false; };\n\n/**\n * Return same value\n */\nvar identity = function (_) { return _; };\n\n/**\n * Generate a static keys string from compiler modules.\n */\nfunction genStaticKeys (modules) {\n  return modules.reduce(function (keys, m) {\n    return keys.concat(m.staticKeys || [])\n  }, []).join(',')\n}\n\n/**\n * Check if two values are loosely equal - that is,\n * if they are plain objects, do they have the same shape?\n */\nfunction looseEqual (a, b) {\n  var isObjectA = isObject(a);\n  var isObjectB = isObject(b);\n  if (isObjectA && isObjectB) {\n    return JSON.stringify(a) === JSON.stringify(b)\n  } else if (!isObjectA && !isObjectB) {\n    return String(a) === String(b)\n  } else {\n    return false\n  }\n}\n\nfunction looseIndexOf (arr, val) {\n  for (var i = 0; i < arr.length; i++) {\n    if (looseEqual(arr[i], val)) { return i }\n  }\n  return -1\n}\n\n/*  */\n\nvar config = {\n  /**\n   * Option merge strategies (used in core/util/options)\n   */\n  optionMergeStrategies: Object.create(null),\n\n  /**\n   * Whether to suppress warnings.\n   */\n  silent: false,\n\n  /**\n   * Whether to enable devtools\n   */\n  devtools: process.env.NODE_ENV !== 'production',\n\n  /**\n   * Error handler for watcher errors\n   */\n  errorHandler: null,\n\n  /**\n   * Ignore certain custom elements\n   */\n  ignoredElements: [],\n\n  /**\n   * Custom user key aliases for v-on\n   */\n  keyCodes: Object.create(null),\n\n  /**\n   * Check if a tag is reserved so that it cannot be registered as a\n   * component. This is platform-dependent and may be overwritten.\n   */\n  isReservedTag: no,\n\n  /**\n   * Check if a tag is an unknown element.\n   * Platform-dependent.\n   */\n  isUnknownElement: no,\n\n  /**\n   * Get the namespace of an element\n   */\n  getTagNamespace: noop,\n\n  /**\n   * Parse the real tag name for the specific platform.\n   */\n  parsePlatformTagName: identity,\n\n  /**\n   * Check if an attribute must be bound using property, e.g. value\n   * Platform-dependent.\n   */\n  mustUseProp: no,\n\n  /**\n   * List of asset types that a component can own.\n   */\n  _assetTypes: [\n    'component',\n    'directive',\n    'filter'\n  ],\n\n  /**\n   * List of lifecycle hooks.\n   */\n  _lifecycleHooks: [\n    'beforeCreate',\n    'created',\n    'beforeMount',\n    'mounted',\n    'beforeUpdate',\n    'updated',\n    'beforeDestroy',\n    'destroyed',\n    'activated',\n    'deactivated'\n  ],\n\n  /**\n   * Max circular updates allowed in a scheduler flush cycle.\n   */\n  _maxUpdateCount: 100\n};\n\n/*  */\n\n/**\n * Check if a string starts with $ or _\n */\nfunction isReserved (str) {\n  var c = (str + '').charCodeAt(0);\n  return c === 0x24 || c === 0x5F\n}\n\n/**\n * Define a property.\n */\nfunction def (obj, key, val, enumerable) {\n  Object.defineProperty(obj, key, {\n    value: val,\n    enumerable: !!enumerable,\n    writable: true,\n    configurable: true\n  });\n}\n\n/**\n * Parse simple path.\n */\nvar bailRE = /[^\\w.$]/;\nfunction parsePath (path) {\n  if (bailRE.test(path)) {\n    return\n  } else {\n    var segments = path.split('.');\n    return function (obj) {\n      for (var i = 0; i < segments.length; i++) {\n        if (!obj) { return }\n        obj = obj[segments[i]];\n      }\n      return obj\n    }\n  }\n}\n\n/*  */\n/* globals MutationObserver */\n\n// can we use __proto__?\nvar hasProto = '__proto__' in {};\n\n// Browser environment sniffing\nvar inBrowser = typeof window !== 'undefined';\nvar UA = inBrowser && window.navigator.userAgent.toLowerCase();\nvar isIE = UA && /msie|trident/.test(UA);\nvar isIE9 = UA && UA.indexOf('msie 9.0') > 0;\nvar isEdge = UA && UA.indexOf('edge/') > 0;\nvar isAndroid = UA && UA.indexOf('android') > 0;\nvar isIOS = UA && /iphone|ipad|ipod|ios/.test(UA);\n\n// this needs to be lazy-evaled because vue may be required before\n// vue-server-renderer can set VUE_ENV\nvar _isServer;\nvar isServerRendering = function () {\n  if (_isServer === undefined) {\n    /* istanbul ignore if */\n    if (!inBrowser && typeof global !== 'undefined') {\n      // detect presence of vue-server-renderer and avoid\n      // Webpack shimming the process\n      _isServer = global['process'].env.VUE_ENV === 'server';\n    } else {\n      _isServer = false;\n    }\n  }\n  return _isServer\n};\n\n// detect devtools\nvar devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;\n\n/* istanbul ignore next */\nfunction isNative (Ctor) {\n  return /native code/.test(Ctor.toString())\n}\n\n/**\n * Defer a task to execute it asynchronously.\n */\nvar nextTick = (function () {\n  var callbacks = [];\n  var pending = false;\n  var timerFunc;\n\n  function nextTickHandler () {\n    pending = false;\n    var copies = callbacks.slice(0);\n    callbacks.length = 0;\n    for (var i = 0; i < copies.length; i++) {\n      copies[i]();\n    }\n  }\n\n  // the nextTick behavior leverages the microtask queue, which can be accessed\n  // via either native Promise.then or MutationObserver.\n  // MutationObserver has wider support, however it is seriously bugged in\n  // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It\n  // completely stops working after triggering a few times... so, if native\n  // Promise is available, we will use it:\n  /* istanbul ignore if */\n  if (typeof Promise !== 'undefined' && isNative(Promise)) {\n    var p = Promise.resolve();\n    var logError = function (err) { console.error(err); };\n    timerFunc = function () {\n      p.then(nextTickHandler).catch(logError);\n      // in problematic UIWebViews, Promise.then doesn't completely break, but\n      // it can get stuck in a weird state where callbacks are pushed into the\n      // microtask queue but the queue isn't being flushed, until the browser\n      // needs to do some other work, e.g. handle a timer. Therefore we can\n      // \"force\" the microtask queue to be flushed by adding an empty timer.\n      if (isIOS) { setTimeout(noop); }\n    };\n  } else if (typeof MutationObserver !== 'undefined' && (\n    isNative(MutationObserver) ||\n    // PhantomJS and iOS 7.x\n    MutationObserver.toString() === '[object MutationObserverConstructor]'\n  )) {\n    // use MutationObserver where native Promise is not available,\n    // e.g. PhantomJS IE11, iOS7, Android 4.4\n    var counter = 1;\n    var observer = new MutationObserver(nextTickHandler);\n    var textNode = document.createTextNode(String(counter));\n    observer.observe(textNode, {\n      characterData: true\n    });\n    timerFunc = function () {\n      counter = (counter + 1) % 2;\n      textNode.data = String(counter);\n    };\n  } else {\n    // fallback to setTimeout\n    /* istanbul ignore next */\n    timerFunc = function () {\n      setTimeout(nextTickHandler, 0);\n    };\n  }\n\n  return function queueNextTick (cb, ctx) {\n    var _resolve;\n    callbacks.push(function () {\n      if (cb) { cb.call(ctx); }\n      if (_resolve) { _resolve(ctx); }\n    });\n    if (!pending) {\n      pending = true;\n      timerFunc();\n    }\n    if (!cb && typeof Promise !== 'undefined') {\n      return new Promise(function (resolve) {\n        _resolve = resolve;\n      })\n    }\n  }\n})();\n\nvar _Set;\n/* istanbul ignore if */\nif (typeof Set !== 'undefined' && isNative(Set)) {\n  // use native Set when available.\n  _Set = Set;\n} else {\n  // a non-standard Set polyfill that only works with primitive keys.\n  _Set = (function () {\n    function Set () {\n      this.set = Object.create(null);\n    }\n    Set.prototype.has = function has (key) {\n      return this.set[key] === true\n    };\n    Set.prototype.add = function add (key) {\n      this.set[key] = true;\n    };\n    Set.prototype.clear = function clear () {\n      this.set = Object.create(null);\n    };\n\n    return Set;\n  }());\n}\n\nvar warn = noop;\nvar formatComponentName;\n\nif (process.env.NODE_ENV !== 'production') {\n  var hasConsole = typeof console !== 'undefined';\n\n  warn = function (msg, vm) {\n    if (hasConsole && (!config.silent)) {\n      console.error(\"[Vue warn]: \" + msg + \" \" + (\n        vm ? formatLocation(formatComponentName(vm)) : ''\n      ));\n    }\n  };\n\n  formatComponentName = function (vm) {\n    if (vm.$root === vm) {\n      return 'root instance'\n    }\n    var name = vm._isVue\n      ? vm.$options.name || vm.$options._componentTag\n      : vm.name;\n    return (\n      (name ? (\"component <\" + name + \">\") : \"anonymous component\") +\n      (vm._isVue && vm.$options.__file ? (\" at \" + (vm.$options.__file)) : '')\n    )\n  };\n\n  var formatLocation = function (str) {\n    if (str === 'anonymous component') {\n      str += \" - use the \\\"name\\\" option for better debugging messages.\";\n    }\n    return (\"\\n(found in \" + str + \")\")\n  };\n}\n\n/*  */\n\n\nvar uid$1 = 0;\n\n/**\n * A dep is an observable that can have multiple\n * directives subscribing to it.\n */\nvar Dep = function Dep () {\n  this.id = uid$1++;\n  this.subs = [];\n};\n\nDep.prototype.addSub = function addSub (sub) {\n  this.subs.push(sub);\n};\n\nDep.prototype.removeSub = function removeSub (sub) {\n  remove$1(this.subs, sub);\n};\n\nDep.prototype.depend = function depend () {\n  if (Dep.target) {\n    Dep.target.addDep(this);\n  }\n};\n\nDep.prototype.notify = function notify () {\n  // stablize the subscriber list first\n  var subs = this.subs.slice();\n  for (var i = 0, l = subs.length; i < l; i++) {\n    subs[i].update();\n  }\n};\n\n// the current target watcher being evaluated.\n// this is globally unique because there could be only one\n// watcher being evaluated at any time.\nDep.target = null;\nvar targetStack = [];\n\nfunction pushTarget (_target) {\n  if (Dep.target) { targetStack.push(Dep.target); }\n  Dep.target = _target;\n}\n\nfunction popTarget () {\n  Dep.target = targetStack.pop();\n}\n\n/*\n * not type checking this file because flow doesn't play well with\n * dynamically accessing methods on Array prototype\n */\n\nvar arrayProto = Array.prototype;\nvar arrayMethods = Object.create(arrayProto);[\n  'push',\n  'pop',\n  'shift',\n  'unshift',\n  'splice',\n  'sort',\n  'reverse'\n]\n.forEach(function (method) {\n  // cache original method\n  var original = arrayProto[method];\n  def(arrayMethods, method, function mutator () {\n    var arguments$1 = arguments;\n\n    // avoid leaking arguments:\n    // http://jsperf.com/closure-with-arguments\n    var i = arguments.length;\n    var args = new Array(i);\n    while (i--) {\n      args[i] = arguments$1[i];\n    }\n    var result = original.apply(this, args);\n    var ob = this.__ob__;\n    var inserted;\n    switch (method) {\n      case 'push':\n        inserted = args;\n        break\n      case 'unshift':\n        inserted = args;\n        break\n      case 'splice':\n        inserted = args.slice(2);\n        break\n    }\n    if (inserted) { ob.observeArray(inserted); }\n    // notify change\n    ob.dep.notify();\n    return result\n  });\n});\n\n/*  */\n\nvar arrayKeys = Object.getOwnPropertyNames(arrayMethods);\n\n/**\n * By default, when a reactive property is set, the new value is\n * also converted to become reactive. However when passing down props,\n * we don't want to force conversion because the value may be a nested value\n * under a frozen data structure. Converting it would defeat the optimization.\n */\nvar observerState = {\n  shouldConvert: true,\n  isSettingProps: false\n};\n\n/**\n * Observer class that are attached to each observed\n * object. Once attached, the observer converts target\n * object's property keys into getter/setters that\n * collect dependencies and dispatches updates.\n */\nvar Observer = function Observer (value) {\n  this.value = value;\n  this.dep = new Dep();\n  this.vmCount = 0;\n  def(value, '__ob__', this);\n  if (Array.isArray(value)) {\n    var augment = hasProto\n      ? protoAugment\n      : copyAugment;\n    augment(value, arrayMethods, arrayKeys);\n    this.observeArray(value);\n  } else {\n    this.walk(value);\n  }\n};\n\n/**\n * Walk through each property and convert them into\n * getter/setters. This method should only be called when\n * value type is Object.\n */\nObserver.prototype.walk = function walk (obj) {\n  var keys = Object.keys(obj);\n  for (var i = 0; i < keys.length; i++) {\n    defineReactive$$1(obj, keys[i], obj[keys[i]]);\n  }\n};\n\n/**\n * Observe a list of Array items.\n */\nObserver.prototype.observeArray = function observeArray (items) {\n  for (var i = 0, l = items.length; i < l; i++) {\n    observe(items[i]);\n  }\n};\n\n// helpers\n\n/**\n * Augment an target Object or Array by intercepting\n * the prototype chain using __proto__\n */\nfunction protoAugment (target, src) {\n  /* eslint-disable no-proto */\n  target.__proto__ = src;\n  /* eslint-enable no-proto */\n}\n\n/**\n * Augment an target Object or Array by defining\n * hidden properties.\n */\n/* istanbul ignore next */\nfunction copyAugment (target, src, keys) {\n  for (var i = 0, l = keys.length; i < l; i++) {\n    var key = keys[i];\n    def(target, key, src[key]);\n  }\n}\n\n/**\n * Attempt to create an observer instance for a value,\n * returns the new observer if successfully observed,\n * or the existing observer if the value already has one.\n */\nfunction observe (value, asRootData) {\n  if (!isObject(value)) {\n    return\n  }\n  var ob;\n  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {\n    ob = value.__ob__;\n  } else if (\n    observerState.shouldConvert &&\n    !isServerRendering() &&\n    (Array.isArray(value) || isPlainObject(value)) &&\n    Object.isExtensible(value) &&\n    !value._isVue\n  ) {\n    ob = new Observer(value);\n  }\n  if (asRootData && ob) {\n    ob.vmCount++;\n  }\n  return ob\n}\n\n/**\n * Define a reactive property on an Object.\n */\nfunction defineReactive$$1 (\n  obj,\n  key,\n  val,\n  customSetter\n) {\n  var dep = new Dep();\n\n  var property = Object.getOwnPropertyDescriptor(obj, key);\n  if (property && property.configurable === false) {\n    return\n  }\n\n  // cater for pre-defined getter/setters\n  var getter = property && property.get;\n  var setter = property && property.set;\n\n  var childOb = observe(val);\n  Object.defineProperty(obj, key, {\n    enumerable: true,\n    configurable: true,\n    get: function reactiveGetter () {\n      var value = getter ? getter.call(obj) : val;\n      if (Dep.target) {\n        dep.depend();\n        if (childOb) {\n          childOb.dep.depend();\n        }\n        if (Array.isArray(value)) {\n          dependArray(value);\n        }\n      }\n      return value\n    },\n    set: function reactiveSetter (newVal) {\n      var value = getter ? getter.call(obj) : val;\n      /* eslint-disable no-self-compare */\n      if (newVal === value || (newVal !== newVal && value !== value)) {\n        return\n      }\n      /* eslint-enable no-self-compare */\n      if (process.env.NODE_ENV !== 'production' && customSetter) {\n        customSetter();\n      }\n      if (setter) {\n        setter.call(obj, newVal);\n      } else {\n        val = newVal;\n      }\n      childOb = observe(newVal);\n      dep.notify();\n    }\n  });\n}\n\n/**\n * Set a property on an object. Adds the new property and\n * triggers change notification if the property doesn't\n * already exist.\n */\nfunction set$1 (obj, key, val) {\n  if (Array.isArray(obj)) {\n    obj.length = Math.max(obj.length, key);\n    obj.splice(key, 1, val);\n    return val\n  }\n  if (hasOwn(obj, key)) {\n    obj[key] = val;\n    return\n  }\n  var ob = obj.__ob__;\n  if (obj._isVue || (ob && ob.vmCount)) {\n    process.env.NODE_ENV !== 'production' && warn(\n      'Avoid adding reactive properties to a Vue instance or its root $data ' +\n      'at runtime - declare it upfront in the data option.'\n    );\n    return\n  }\n  if (!ob) {\n    obj[key] = val;\n    return\n  }\n  defineReactive$$1(ob.value, key, val);\n  ob.dep.notify();\n  return val\n}\n\n/**\n * Delete a property and trigger change if necessary.\n */\nfunction del (obj, key) {\n  var ob = obj.__ob__;\n  if (obj._isVue || (ob && ob.vmCount)) {\n    process.env.NODE_ENV !== 'production' && warn(\n      'Avoid deleting properties on a Vue instance or its root $data ' +\n      '- just set it to null.'\n    );\n    return\n  }\n  if (!hasOwn(obj, key)) {\n    return\n  }\n  delete obj[key];\n  if (!ob) {\n    return\n  }\n  ob.dep.notify();\n}\n\n/**\n * Collect dependencies on array elements when the array is touched, since\n * we cannot intercept array element access like property getters.\n */\nfunction dependArray (value) {\n  for (var e = (void 0), i = 0, l = value.length; i < l; i++) {\n    e = value[i];\n    e && e.__ob__ && e.__ob__.dep.depend();\n    if (Array.isArray(e)) {\n      dependArray(e);\n    }\n  }\n}\n\n/*  */\n\n/**\n * Option overwriting strategies are functions that handle\n * how to merge a parent option value and a child option\n * value into the final value.\n */\nvar strats = config.optionMergeStrategies;\n\n/**\n * Options with restrictions\n */\nif (process.env.NODE_ENV !== 'production') {\n  strats.el = strats.propsData = function (parent, child, vm, key) {\n    if (!vm) {\n      warn(\n        \"option \\\"\" + key + \"\\\" can only be used during instance \" +\n        'creation with the `new` keyword.'\n      );\n    }\n    return defaultStrat(parent, child)\n  };\n}\n\n/**\n * Helper that recursively merges two data objects together.\n */\nfunction mergeData (to, from) {\n  if (!from) { return to }\n  var key, toVal, fromVal;\n  var keys = Object.keys(from);\n  for (var i = 0; i < keys.length; i++) {\n    key = keys[i];\n    toVal = to[key];\n    fromVal = from[key];\n    if (!hasOwn(to, key)) {\n      set$1(to, key, fromVal);\n    } else if (isPlainObject(toVal) && isPlainObject(fromVal)) {\n      mergeData(toVal, fromVal);\n    }\n  }\n  return to\n}\n\n/**\n * Data\n */\nstrats.data = function (\n  parentVal,\n  childVal,\n  vm\n) {\n  if (!vm) {\n    // in a Vue.extend merge, both should be functions\n    if (!childVal) {\n      return parentVal\n    }\n    if (typeof childVal !== 'function') {\n      process.env.NODE_ENV !== 'production' && warn(\n        'The \"data\" option should be a function ' +\n        'that returns a per-instance value in component ' +\n        'definitions.',\n        vm\n      );\n      return parentVal\n    }\n    if (!parentVal) {\n      return childVal\n    }\n    // when parentVal & childVal are both present,\n    // we need to return a function that returns the\n    // merged result of both functions... no need to\n    // check if parentVal is a function here because\n    // it has to be a function to pass previous merges.\n    return function mergedDataFn () {\n      return mergeData(\n        childVal.call(this),\n        parentVal.call(this)\n      )\n    }\n  } else if (parentVal || childVal) {\n    return function mergedInstanceDataFn () {\n      // instance merge\n      var instanceData = typeof childVal === 'function'\n        ? childVal.call(vm)\n        : childVal;\n      var defaultData = typeof parentVal === 'function'\n        ? parentVal.call(vm)\n        : undefined;\n      if (instanceData) {\n        return mergeData(instanceData, defaultData)\n      } else {\n        return defaultData\n      }\n    }\n  }\n};\n\n/**\n * Hooks and param attributes are merged as arrays.\n */\nfunction mergeHook (\n  parentVal,\n  childVal\n) {\n  return childVal\n    ? parentVal\n      ? parentVal.concat(childVal)\n      : Array.isArray(childVal)\n        ? childVal\n        : [childVal]\n    : parentVal\n}\n\nconfig._lifecycleHooks.forEach(function (hook) {\n  strats[hook] = mergeHook;\n});\n\n/**\n * Assets\n *\n * When a vm is present (instance creation), we need to do\n * a three-way merge between constructor options, instance\n * options and parent options.\n */\nfunction mergeAssets (parentVal, childVal) {\n  var res = Object.create(parentVal || null);\n  return childVal\n    ? extend(res, childVal)\n    : res\n}\n\nconfig._assetTypes.forEach(function (type) {\n  strats[type + 's'] = mergeAssets;\n});\n\n/**\n * Watchers.\n *\n * Watchers hashes should not overwrite one\n * another, so we merge them as arrays.\n */\nstrats.watch = function (parentVal, childVal) {\n  /* istanbul ignore if */\n  if (!childVal) { return parentVal }\n  if (!parentVal) { return childVal }\n  var ret = {};\n  extend(ret, parentVal);\n  for (var key in childVal) {\n    var parent = ret[key];\n    var child = childVal[key];\n    if (parent && !Array.isArray(parent)) {\n      parent = [parent];\n    }\n    ret[key] = parent\n      ? parent.concat(child)\n      : [child];\n  }\n  return ret\n};\n\n/**\n * Other object hashes.\n */\nstrats.props =\nstrats.methods =\nstrats.computed = function (parentVal, childVal) {\n  if (!childVal) { return parentVal }\n  if (!parentVal) { return childVal }\n  var ret = Object.create(null);\n  extend(ret, parentVal);\n  extend(ret, childVal);\n  return ret\n};\n\n/**\n * Default strategy.\n */\nvar defaultStrat = function (parentVal, childVal) {\n  return childVal === undefined\n    ? parentVal\n    : childVal\n};\n\n/**\n * Validate component names\n */\nfunction checkComponents (options) {\n  for (var key in options.components) {\n    var lower = key.toLowerCase();\n    if (isBuiltInTag(lower) || config.isReservedTag(lower)) {\n      warn(\n        'Do not use built-in or reserved HTML elements as component ' +\n        'id: ' + key\n      );\n    }\n  }\n}\n\n/**\n * Ensure all props option syntax are normalized into the\n * Object-based format.\n */\nfunction normalizeProps (options) {\n  var props = options.props;\n  if (!props) { return }\n  var res = {};\n  var i, val, name;\n  if (Array.isArray(props)) {\n    i = props.length;\n    while (i--) {\n      val = props[i];\n      if (typeof val === 'string') {\n        name = camelize(val);\n        res[name] = { type: null };\n      } else if (process.env.NODE_ENV !== 'production') {\n        warn('props must be strings when using array syntax.');\n      }\n    }\n  } else if (isPlainObject(props)) {\n    for (var key in props) {\n      val = props[key];\n      name = camelize(key);\n      res[name] = isPlainObject(val)\n        ? val\n        : { type: val };\n    }\n  }\n  options.props = res;\n}\n\n/**\n * Normalize raw function directives into object format.\n */\nfunction normalizeDirectives (options) {\n  var dirs = options.directives;\n  if (dirs) {\n    for (var key in dirs) {\n      var def = dirs[key];\n      if (typeof def === 'function') {\n        dirs[key] = { bind: def, update: def };\n      }\n    }\n  }\n}\n\n/**\n * Merge two option objects into a new one.\n * Core utility used in both instantiation and inheritance.\n */\nfunction mergeOptions (\n  parent,\n  child,\n  vm\n) {\n  if (process.env.NODE_ENV !== 'production') {\n    checkComponents(child);\n  }\n  normalizeProps(child);\n  normalizeDirectives(child);\n  var extendsFrom = child.extends;\n  if (extendsFrom) {\n    parent = typeof extendsFrom === 'function'\n      ? mergeOptions(parent, extendsFrom.options, vm)\n      : mergeOptions(parent, extendsFrom, vm);\n  }\n  if (child.mixins) {\n    for (var i = 0, l = child.mixins.length; i < l; i++) {\n      var mixin = child.mixins[i];\n      if (mixin.prototype instanceof Vue$3) {\n        mixin = mixin.options;\n      }\n      parent = mergeOptions(parent, mixin, vm);\n    }\n  }\n  var options = {};\n  var key;\n  for (key in parent) {\n    mergeField(key);\n  }\n  for (key in child) {\n    if (!hasOwn(parent, key)) {\n      mergeField(key);\n    }\n  }\n  function mergeField (key) {\n    var strat = strats[key] || defaultStrat;\n    options[key] = strat(parent[key], child[key], vm, key);\n  }\n  return options\n}\n\n/**\n * Resolve an asset.\n * This function is used because child instances need access\n * to assets defined in its ancestor chain.\n */\nfunction resolveAsset (\n  options,\n  type,\n  id,\n  warnMissing\n) {\n  /* istanbul ignore if */\n  if (typeof id !== 'string') {\n    return\n  }\n  var assets = options[type];\n  // check local registration variations first\n  if (hasOwn(assets, id)) { return assets[id] }\n  var camelizedId = camelize(id);\n  if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }\n  var PascalCaseId = capitalize(camelizedId);\n  if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }\n  // fallback to prototype chain\n  var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];\n  if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {\n    warn(\n      'Failed to resolve ' + type.slice(0, -1) + ': ' + id,\n      options\n    );\n  }\n  return res\n}\n\n/*  */\n\nfunction validateProp (\n  key,\n  propOptions,\n  propsData,\n  vm\n) {\n  var prop = propOptions[key];\n  var absent = !hasOwn(propsData, key);\n  var value = propsData[key];\n  // handle boolean props\n  if (isType(Boolean, prop.type)) {\n    if (absent && !hasOwn(prop, 'default')) {\n      value = false;\n    } else if (!isType(String, prop.type) && (value === '' || value === hyphenate(key))) {\n      value = true;\n    }\n  }\n  // check default value\n  if (value === undefined) {\n    value = getPropDefaultValue(vm, prop, key);\n    // since the default value is a fresh copy,\n    // make sure to observe it.\n    var prevShouldConvert = observerState.shouldConvert;\n    observerState.shouldConvert = true;\n    observe(value);\n    observerState.shouldConvert = prevShouldConvert;\n  }\n  if (process.env.NODE_ENV !== 'production') {\n    assertProp(prop, key, value, vm, absent);\n  }\n  return value\n}\n\n/**\n * Get the default value of a prop.\n */\nfunction getPropDefaultValue (vm, prop, key) {\n  // no default, return undefined\n  if (!hasOwn(prop, 'default')) {\n    return undefined\n  }\n  var def = prop.default;\n  // warn against non-factory defaults for Object & Array\n  if (isObject(def)) {\n    process.env.NODE_ENV !== 'production' && warn(\n      'Invalid default value for prop \"' + key + '\": ' +\n      'Props with type Object/Array must use a factory function ' +\n      'to return the default value.',\n      vm\n    );\n  }\n  // the raw prop value was also undefined from previous render,\n  // return previous default value to avoid unnecessary watcher trigger\n  if (vm && vm.$options.propsData &&\n    vm.$options.propsData[key] === undefined &&\n    vm[key] !== undefined) {\n    return vm[key]\n  }\n  // call factory function for non-Function types\n  return typeof def === 'function' && prop.type !== Function\n    ? def.call(vm)\n    : def\n}\n\n/**\n * Assert whether a prop is valid.\n */\nfunction assertProp (\n  prop,\n  name,\n  value,\n  vm,\n  absent\n) {\n  if (prop.required && absent) {\n    warn(\n      'Missing required prop: \"' + name + '\"',\n      vm\n    );\n    return\n  }\n  if (value == null && !prop.required) {\n    return\n  }\n  var type = prop.type;\n  var valid = !type || type === true;\n  var expectedTypes = [];\n  if (type) {\n    if (!Array.isArray(type)) {\n      type = [type];\n    }\n    for (var i = 0; i < type.length && !valid; i++) {\n      var assertedType = assertType(value, type[i]);\n      expectedTypes.push(assertedType.expectedType || '');\n      valid = assertedType.valid;\n    }\n  }\n  if (!valid) {\n    warn(\n      'Invalid prop: type check failed for prop \"' + name + '\".' +\n      ' Expected ' + expectedTypes.map(capitalize).join(', ') +\n      ', got ' + Object.prototype.toString.call(value).slice(8, -1) + '.',\n      vm\n    );\n    return\n  }\n  var validator = prop.validator;\n  if (validator) {\n    if (!validator(value)) {\n      warn(\n        'Invalid prop: custom validator check failed for prop \"' + name + '\".',\n        vm\n      );\n    }\n  }\n}\n\n/**\n * Assert the type of a value\n */\nfunction assertType (value, type) {\n  var valid;\n  var expectedType = getType(type);\n  if (expectedType === 'String') {\n    valid = typeof value === (expectedType = 'string');\n  } else if (expectedType === 'Number') {\n    valid = typeof value === (expectedType = 'number');\n  } else if (expectedType === 'Boolean') {\n    valid = typeof value === (expectedType = 'boolean');\n  } else if (expectedType === 'Function') {\n    valid = typeof value === (expectedType = 'function');\n  } else if (expectedType === 'Object') {\n    valid = isPlainObject(value);\n  } else if (expectedType === 'Array') {\n    valid = Array.isArray(value);\n  } else {\n    valid = value instanceof type;\n  }\n  return {\n    valid: valid,\n    expectedType: expectedType\n  }\n}\n\n/**\n * Use function string name to check built-in types,\n * because a simple equality check will fail when running\n * across different vms / iframes.\n */\nfunction getType (fn) {\n  var match = fn && fn.toString().match(/^\\s*function (\\w+)/);\n  return match && match[1]\n}\n\nfunction isType (type, fn) {\n  if (!Array.isArray(fn)) {\n    return getType(fn) === getType(type)\n  }\n  for (var i = 0, len = fn.length; i < len; i++) {\n    if (getType(fn[i]) === getType(type)) {\n      return true\n    }\n  }\n  /* istanbul ignore next */\n  return false\n}\n\n\n\nvar util = Object.freeze({\n\tdefineReactive: defineReactive$$1,\n\t_toString: _toString,\n\ttoNumber: toNumber,\n\tmakeMap: makeMap,\n\tisBuiltInTag: isBuiltInTag,\n\tremove: remove$1,\n\thasOwn: hasOwn,\n\tisPrimitive: isPrimitive,\n\tcached: cached,\n\tcamelize: camelize,\n\tcapitalize: capitalize,\n\thyphenate: hyphenate,\n\tbind: bind$1,\n\ttoArray: toArray,\n\textend: extend,\n\tisObject: isObject,\n\tisPlainObject: isPlainObject,\n\ttoObject: toObject,\n\tnoop: noop,\n\tno: no,\n\tidentity: identity,\n\tgenStaticKeys: genStaticKeys,\n\tlooseEqual: looseEqual,\n\tlooseIndexOf: looseIndexOf,\n\tisReserved: isReserved,\n\tdef: def,\n\tparsePath: parsePath,\n\thasProto: hasProto,\n\tinBrowser: inBrowser,\n\tUA: UA,\n\tisIE: isIE,\n\tisIE9: isIE9,\n\tisEdge: isEdge,\n\tisAndroid: isAndroid,\n\tisIOS: isIOS,\n\tisServerRendering: isServerRendering,\n\tdevtools: devtools,\n\tnextTick: nextTick,\n\tget _Set () { return _Set; },\n\tmergeOptions: mergeOptions,\n\tresolveAsset: resolveAsset,\n\tget warn () { return warn; },\n\tget formatComponentName () { return formatComponentName; },\n\tvalidateProp: validateProp\n});\n\n/* not type checking this file because flow doesn't play well with Proxy */\n\nvar initProxy;\n\nif (process.env.NODE_ENV !== 'production') {\n  var allowedGlobals = makeMap(\n    'Infinity,undefined,NaN,isFinite,isNaN,' +\n    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +\n    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +\n    'require' // for Webpack/Browserify\n  );\n\n  var warnNonPresent = function (target, key) {\n    warn(\n      \"Property or method \\\"\" + key + \"\\\" is not defined on the instance but \" +\n      \"referenced during render. Make sure to declare reactive data \" +\n      \"properties in the data option.\",\n      target\n    );\n  };\n\n  var hasProxy =\n    typeof Proxy !== 'undefined' &&\n    Proxy.toString().match(/native code/);\n\n  if (hasProxy) {\n    var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta');\n    config.keyCodes = new Proxy(config.keyCodes, {\n      set: function set (target, key, value) {\n        if (isBuiltInModifier(key)) {\n          warn((\"Avoid overwriting built-in modifier in config.keyCodes: .\" + key));\n          return false\n        } else {\n          target[key] = value;\n          return true\n        }\n      }\n    });\n  }\n\n  var hasHandler = {\n    has: function has (target, key) {\n      var has = key in target;\n      var isAllowed = allowedGlobals(key) || key.charAt(0) === '_';\n      if (!has && !isAllowed) {\n        warnNonPresent(target, key);\n      }\n      return has || !isAllowed\n    }\n  };\n\n  var getHandler = {\n    get: function get (target, key) {\n      if (typeof key === 'string' && !(key in target)) {\n        warnNonPresent(target, key);\n      }\n      return target[key]\n    }\n  };\n\n  initProxy = function initProxy (vm) {\n    if (hasProxy) {\n      // determine which proxy handler to use\n      var options = vm.$options;\n      var handlers = options.render && options.render._withStripped\n        ? getHandler\n        : hasHandler;\n      vm._renderProxy = new Proxy(vm, handlers);\n    } else {\n      vm._renderProxy = vm;\n    }\n  };\n}\n\n/*  */\n\nvar VNode = function VNode (\n  tag,\n  data,\n  children,\n  text,\n  elm,\n  context,\n  componentOptions\n) {\n  this.tag = tag;\n  this.data = data;\n  this.children = children;\n  this.text = text;\n  this.elm = elm;\n  this.ns = undefined;\n  this.context = context;\n  this.functionalContext = undefined;\n  this.key = data && data.key;\n  this.componentOptions = componentOptions;\n  this.componentInstance = undefined;\n  this.parent = undefined;\n  this.raw = false;\n  this.isStatic = false;\n  this.isRootInsert = true;\n  this.isComment = false;\n  this.isCloned = false;\n  this.isOnce = false;\n};\n\nvar prototypeAccessors = { child: {} };\n\n// DEPRECATED: alias for componentInstance for backwards compat.\n/* istanbul ignore next */\nprototypeAccessors.child.get = function () {\n  return this.componentInstance\n};\n\nObject.defineProperties( VNode.prototype, prototypeAccessors );\n\nvar createEmptyVNode = function () {\n  var node = new VNode();\n  node.text = '';\n  node.isComment = true;\n  return node\n};\n\nfunction createTextVNode (val) {\n  return new VNode(undefined, undefined, undefined, String(val))\n}\n\n// optimized shallow clone\n// used for static nodes and slot nodes because they may be reused across\n// multiple renders, cloning them avoids errors when DOM manipulations rely\n// on their elm reference.\nfunction cloneVNode (vnode) {\n  var cloned = new VNode(\n    vnode.tag,\n    vnode.data,\n    vnode.children,\n    vnode.text,\n    vnode.elm,\n    vnode.context,\n    vnode.componentOptions\n  );\n  cloned.ns = vnode.ns;\n  cloned.isStatic = vnode.isStatic;\n  cloned.key = vnode.key;\n  cloned.isCloned = true;\n  return cloned\n}\n\nfunction cloneVNodes (vnodes) {\n  var res = new Array(vnodes.length);\n  for (var i = 0; i < vnodes.length; i++) {\n    res[i] = cloneVNode(vnodes[i]);\n  }\n  return res\n}\n\n/*  */\n\nvar hooks = { init: init, prepatch: prepatch, insert: insert, destroy: destroy$1 };\nvar hooksToMerge = Object.keys(hooks);\n\nfunction createComponent (\n  Ctor,\n  data,\n  context,\n  children,\n  tag\n) {\n  if (!Ctor) {\n    return\n  }\n\n  var baseCtor = context.$options._base;\n  if (isObject(Ctor)) {\n    Ctor = baseCtor.extend(Ctor);\n  }\n\n  if (typeof Ctor !== 'function') {\n    if (process.env.NODE_ENV !== 'production') {\n      warn((\"Invalid Component definition: \" + (String(Ctor))), context);\n    }\n    return\n  }\n\n  // async component\n  if (!Ctor.cid) {\n    if (Ctor.resolved) {\n      Ctor = Ctor.resolved;\n    } else {\n      Ctor = resolveAsyncComponent(Ctor, baseCtor, function () {\n        // it's ok to queue this on every render because\n        // $forceUpdate is buffered by the scheduler.\n        context.$forceUpdate();\n      });\n      if (!Ctor) {\n        // return nothing if this is indeed an async component\n        // wait for the callback to trigger parent update.\n        return\n      }\n    }\n  }\n\n  // resolve constructor options in case global mixins are applied after\n  // component constructor creation\n  resolveConstructorOptions(Ctor);\n\n  data = data || {};\n\n  // extract props\n  var propsData = extractProps(data, Ctor);\n\n  // functional component\n  if (Ctor.options.functional) {\n    return createFunctionalComponent(Ctor, propsData, data, context, children)\n  }\n\n  // extract listeners, since these needs to be treated as\n  // child component listeners instead of DOM listeners\n  var listeners = data.on;\n  // replace with listeners with .native modifier\n  data.on = data.nativeOn;\n\n  if (Ctor.options.abstract) {\n    // abstract components do not keep anything\n    // other than props & listeners\n    data = {};\n  }\n\n  // merge component management hooks onto the placeholder node\n  mergeHooks(data);\n\n  // return a placeholder vnode\n  var name = Ctor.options.name || tag;\n  var vnode = new VNode(\n    (\"vue-component-\" + (Ctor.cid) + (name ? (\"-\" + name) : '')),\n    data, undefined, undefined, undefined, context,\n    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }\n  );\n  return vnode\n}\n\nfunction createFunctionalComponent (\n  Ctor,\n  propsData,\n  data,\n  context,\n  children\n) {\n  var props = {};\n  var propOptions = Ctor.options.props;\n  if (propOptions) {\n    for (var key in propOptions) {\n      props[key] = validateProp(key, propOptions, propsData);\n    }\n  }\n  // ensure the createElement function in functional components\n  // gets a unique context - this is necessary for correct named slot check\n  var _context = Object.create(context);\n  var h = function (a, b, c, d) { return createElement(_context, a, b, c, d, true); };\n  var vnode = Ctor.options.render.call(null, h, {\n    props: props,\n    data: data,\n    parent: context,\n    children: children,\n    slots: function () { return resolveSlots(children, context); }\n  });\n  if (vnode instanceof VNode) {\n    vnode.functionalContext = context;\n    if (data.slot) {\n      (vnode.data || (vnode.data = {})).slot = data.slot;\n    }\n  }\n  return vnode\n}\n\nfunction createComponentInstanceForVnode (\n  vnode, // we know it's MountedComponentVNode but flow doesn't\n  parent, // activeInstance in lifecycle state\n  parentElm,\n  refElm\n) {\n  var vnodeComponentOptions = vnode.componentOptions;\n  var options = {\n    _isComponent: true,\n    parent: parent,\n    propsData: vnodeComponentOptions.propsData,\n    _componentTag: vnodeComponentOptions.tag,\n    _parentVnode: vnode,\n    _parentListeners: vnodeComponentOptions.listeners,\n    _renderChildren: vnodeComponentOptions.children,\n    _parentElm: parentElm || null,\n    _refElm: refElm || null\n  };\n  // check inline-template render functions\n  var inlineTemplate = vnode.data.inlineTemplate;\n  if (inlineTemplate) {\n    options.render = inlineTemplate.render;\n    options.staticRenderFns = inlineTemplate.staticRenderFns;\n  }\n  return new vnodeComponentOptions.Ctor(options)\n}\n\nfunction init (\n  vnode,\n  hydrating,\n  parentElm,\n  refElm\n) {\n  if (!vnode.componentInstance || vnode.componentInstance._isDestroyed) {\n    var child = vnode.componentInstance = createComponentInstanceForVnode(\n      vnode,\n      activeInstance,\n      parentElm,\n      refElm\n    );\n    child.$mount(hydrating ? vnode.elm : undefined, hydrating);\n  } else if (vnode.data.keepAlive) {\n    // kept-alive components, treat as a patch\n    var mountedNode = vnode; // work around flow\n    prepatch(mountedNode, mountedNode);\n  }\n}\n\nfunction prepatch (\n  oldVnode,\n  vnode\n) {\n  var options = vnode.componentOptions;\n  var child = vnode.componentInstance = oldVnode.componentInstance;\n  child._updateFromParent(\n    options.propsData, // updated props\n    options.listeners, // updated listeners\n    vnode, // new parent vnode\n    options.children // new children\n  );\n}\n\nfunction insert (vnode) {\n  if (!vnode.componentInstance._isMounted) {\n    vnode.componentInstance._isMounted = true;\n    callHook(vnode.componentInstance, 'mounted');\n  }\n  if (vnode.data.keepAlive) {\n    vnode.componentInstance._inactive = false;\n    callHook(vnode.componentInstance, 'activated');\n  }\n}\n\nfunction destroy$1 (vnode) {\n  if (!vnode.componentInstance._isDestroyed) {\n    if (!vnode.data.keepAlive) {\n      vnode.componentInstance.$destroy();\n    } else {\n      vnode.componentInstance._inactive = true;\n      callHook(vnode.componentInstance, 'deactivated');\n    }\n  }\n}\n\nfunction resolveAsyncComponent (\n  factory,\n  baseCtor,\n  cb\n) {\n  if (factory.requested) {\n    // pool callbacks\n    factory.pendingCallbacks.push(cb);\n  } else {\n    factory.requested = true;\n    var cbs = factory.pendingCallbacks = [cb];\n    var sync = true;\n\n    var resolve = function (res) {\n      if (isObject(res)) {\n        res = baseCtor.extend(res);\n      }\n      // cache resolved\n      factory.resolved = res;\n      // invoke callbacks only if this is not a synchronous resolve\n      // (async resolves are shimmed as synchronous during SSR)\n      if (!sync) {\n        for (var i = 0, l = cbs.length; i < l; i++) {\n          cbs[i](res);\n        }\n      }\n    };\n\n    var reject = function (reason) {\n      process.env.NODE_ENV !== 'production' && warn(\n        \"Failed to resolve async component: \" + (String(factory)) +\n        (reason ? (\"\\nReason: \" + reason) : '')\n      );\n    };\n\n    var res = factory(resolve, reject);\n\n    // handle promise\n    if (res && typeof res.then === 'function' && !factory.resolved) {\n      res.then(resolve, reject);\n    }\n\n    sync = false;\n    // return in case resolved synchronously\n    return factory.resolved\n  }\n}\n\nfunction extractProps (data, Ctor) {\n  // we are only extracting raw values here.\n  // validation and default values are handled in the child\n  // component itself.\n  var propOptions = Ctor.options.props;\n  if (!propOptions) {\n    return\n  }\n  var res = {};\n  var attrs = data.attrs;\n  var props = data.props;\n  var domProps = data.domProps;\n  if (attrs || props || domProps) {\n    for (var key in propOptions) {\n      var altKey = hyphenate(key);\n      checkProp(res, props, key, altKey, true) ||\n      checkProp(res, attrs, key, altKey) ||\n      checkProp(res, domProps, key, altKey);\n    }\n  }\n  return res\n}\n\nfunction checkProp (\n  res,\n  hash,\n  key,\n  altKey,\n  preserve\n) {\n  if (hash) {\n    if (hasOwn(hash, key)) {\n      res[key] = hash[key];\n      if (!preserve) {\n        delete hash[key];\n      }\n      return true\n    } else if (hasOwn(hash, altKey)) {\n      res[key] = hash[altKey];\n      if (!preserve) {\n        delete hash[altKey];\n      }\n      return true\n    }\n  }\n  return false\n}\n\nfunction mergeHooks (data) {\n  if (!data.hook) {\n    data.hook = {};\n  }\n  for (var i = 0; i < hooksToMerge.length; i++) {\n    var key = hooksToMerge[i];\n    var fromParent = data.hook[key];\n    var ours = hooks[key];\n    data.hook[key] = fromParent ? mergeHook$1(ours, fromParent) : ours;\n  }\n}\n\nfunction mergeHook$1 (one, two) {\n  return function (a, b, c, d) {\n    one(a, b, c, d);\n    two(a, b, c, d);\n  }\n}\n\n/*  */\n\nfunction mergeVNodeHook (def, hookKey, hook, key) {\n  key = key + hookKey;\n  var injectedHash = def.__injected || (def.__injected = {});\n  if (!injectedHash[key]) {\n    injectedHash[key] = true;\n    var oldHook = def[hookKey];\n    if (oldHook) {\n      def[hookKey] = function () {\n        oldHook.apply(this, arguments);\n        hook.apply(this, arguments);\n      };\n    } else {\n      def[hookKey] = hook;\n    }\n  }\n}\n\n/*  */\n\nvar normalizeEvent = cached(function (name) {\n  var once = name.charAt(0) === '~'; // Prefixed last, checked first\n  name = once ? name.slice(1) : name;\n  var capture = name.charAt(0) === '!';\n  name = capture ? name.slice(1) : name;\n  return {\n    name: name,\n    once: once,\n    capture: capture\n  }\n});\n\nfunction createEventHandle (fn) {\n  var handle = {\n    fn: fn,\n    invoker: function () {\n      var arguments$1 = arguments;\n\n      var fn = handle.fn;\n      if (Array.isArray(fn)) {\n        for (var i = 0; i < fn.length; i++) {\n          fn[i].apply(null, arguments$1);\n        }\n      } else {\n        fn.apply(null, arguments);\n      }\n    }\n  };\n  return handle\n}\n\nfunction updateListeners (\n  on,\n  oldOn,\n  add,\n  remove$$1,\n  vm\n) {\n  var name, cur, old, event;\n  for (name in on) {\n    cur = on[name];\n    old = oldOn[name];\n    event = normalizeEvent(name);\n    if (!cur) {\n      process.env.NODE_ENV !== 'production' && warn(\n        \"Invalid handler for event \\\"\" + (event.name) + \"\\\": got \" + String(cur),\n        vm\n      );\n    } else if (!old) {\n      if (!cur.invoker) {\n        cur = on[name] = createEventHandle(cur);\n      }\n      add(event.name, cur.invoker, event.once, event.capture);\n    } else if (cur !== old) {\n      old.fn = cur;\n      on[name] = old;\n    }\n  }\n  for (name in oldOn) {\n    if (!on[name]) {\n      event = normalizeEvent(name);\n      remove$$1(event.name, oldOn[name].invoker, event.capture);\n    }\n  }\n}\n\n/*  */\n\n// The template compiler attempts to minimize the need for normalization by\n// statically analyzing the template at compile time.\n//\n// For plain HTML markup, normalization can be completely skipped because the\n// generated render function is guaranteed to return Array<VNode>. There are\n// two cases where extra normalization is needed:\n\n// 1. When the children contains components - because a functional component\n// may return an Array instead of a single root. In this case, just a simple\n// nomralization is needed - if any child is an Array, we flatten the whole\n// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep\n// because functional components already normalize their own children.\nfunction simpleNormalizeChildren (children) {\n  for (var i = 0; i < children.length; i++) {\n    if (Array.isArray(children[i])) {\n      return Array.prototype.concat.apply([], children)\n    }\n  }\n  return children\n}\n\n// 2. When the children contains constrcuts that always generated nested Arrays,\n// e.g. <template>, <slot>, v-for, or when the children is provided by user\n// with hand-written render functions / JSX. In such cases a full normalization\n// is needed to cater to all possible types of children values.\nfunction normalizeChildren (children) {\n  return isPrimitive(children)\n    ? [createTextVNode(children)]\n    : Array.isArray(children)\n      ? normalizeArrayChildren(children)\n      : undefined\n}\n\nfunction normalizeArrayChildren (children, nestedIndex) {\n  var res = [];\n  var i, c, last;\n  for (i = 0; i < children.length; i++) {\n    c = children[i];\n    if (c == null || typeof c === 'boolean') { continue }\n    last = res[res.length - 1];\n    //  nested\n    if (Array.isArray(c)) {\n      res.push.apply(res, normalizeArrayChildren(c, ((nestedIndex || '') + \"_\" + i)));\n    } else if (isPrimitive(c)) {\n      if (last && last.text) {\n        last.text += String(c);\n      } else if (c !== '') {\n        // convert primitive to vnode\n        res.push(createTextVNode(c));\n      }\n    } else {\n      if (c.text && last && last.text) {\n        res[res.length - 1] = createTextVNode(last.text + c.text);\n      } else {\n        // default key for nested array children (likely generated by v-for)\n        if (c.tag && c.key == null && nestedIndex != null) {\n          c.key = \"__vlist\" + nestedIndex + \"_\" + i + \"__\";\n        }\n        res.push(c);\n      }\n    }\n  }\n  return res\n}\n\n/*  */\n\nfunction getFirstComponentChild (children) {\n  return children && children.filter(function (c) { return c && c.componentOptions; })[0]\n}\n\n/*  */\n\nvar SIMPLE_NORMALIZE = 1;\nvar ALWAYS_NORMALIZE = 2;\n\n// wrapper function for providing a more flexible interface\n// without getting yelled at by flow\nfunction createElement (\n  context,\n  tag,\n  data,\n  children,\n  normalizationType,\n  alwaysNormalize\n) {\n  if (Array.isArray(data) || isPrimitive(data)) {\n    normalizationType = children;\n    children = data;\n    data = undefined;\n  }\n  if (alwaysNormalize) { normalizationType = ALWAYS_NORMALIZE; }\n  return _createElement(context, tag, data, children, normalizationType)\n}\n\nfunction _createElement (\n  context,\n  tag,\n  data,\n  children,\n  normalizationType\n) {\n  if (data && data.__ob__) {\n    process.env.NODE_ENV !== 'production' && warn(\n      \"Avoid using observed data object as vnode data: \" + (JSON.stringify(data)) + \"\\n\" +\n      'Always create fresh vnode data objects in each render!',\n      context\n    );\n    return createEmptyVNode()\n  }\n  if (!tag) {\n    // in case of component :is set to falsy value\n    return createEmptyVNode()\n  }\n  // support single function children as default scoped slot\n  if (Array.isArray(children) &&\n      typeof children[0] === 'function') {\n    data = data || {};\n    data.scopedSlots = { default: children[0] };\n    children.length = 0;\n  }\n  if (normalizationType === ALWAYS_NORMALIZE) {\n    children = normalizeChildren(children);\n  } else if (normalizationType === SIMPLE_NORMALIZE) {\n    children = simpleNormalizeChildren(children);\n  }\n  var vnode, ns;\n  if (typeof tag === 'string') {\n    var Ctor;\n    ns = config.getTagNamespace(tag);\n    if (config.isReservedTag(tag)) {\n      // platform built-in elements\n      vnode = new VNode(\n        config.parsePlatformTagName(tag), data, children,\n        undefined, undefined, context\n      );\n    } else if ((Ctor = resolveAsset(context.$options, 'components', tag))) {\n      // component\n      vnode = createComponent(Ctor, data, context, children, tag);\n    } else {\n      // unknown or unlisted namespaced elements\n      // check at runtime because it may get assigned a namespace when its\n      // parent normalizes children\n      vnode = new VNode(\n        tag, data, children,\n        undefined, undefined, context\n      );\n    }\n  } else {\n    // direct component options / constructor\n    vnode = createComponent(tag, data, context, children);\n  }\n  if (vnode) {\n    if (ns) { applyNS(vnode, ns); }\n    return vnode\n  } else {\n    return createEmptyVNode()\n  }\n}\n\nfunction applyNS (vnode, ns) {\n  vnode.ns = ns;\n  if (vnode.tag === 'foreignObject') {\n    // use default namespace inside foreignObject\n    return\n  }\n  if (vnode.children) {\n    for (var i = 0, l = vnode.children.length; i < l; i++) {\n      var child = vnode.children[i];\n      if (child.tag && !child.ns) {\n        applyNS(child, ns);\n      }\n    }\n  }\n}\n\n/*  */\n\nfunction initRender (vm) {\n  vm.$vnode = null; // the placeholder node in parent tree\n  vm._vnode = null; // the root of the child tree\n  vm._staticTrees = null;\n  var parentVnode = vm.$options._parentVnode;\n  var renderContext = parentVnode && parentVnode.context;\n  vm.$slots = resolveSlots(vm.$options._renderChildren, renderContext);\n  vm.$scopedSlots = {};\n  // bind the createElement fn to this instance\n  // so that we get proper render context inside it.\n  // args order: tag, data, children, normalizationType, alwaysNormalize\n  // internal version is used by render functions compiled from templates\n  vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };\n  // normalization is always applied for the public version, used in\n  // user-written render functions.\n  vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };\n}\n\nfunction renderMixin (Vue) {\n  Vue.prototype.$nextTick = function (fn) {\n    return nextTick(fn, this)\n  };\n\n  Vue.prototype._render = function () {\n    var vm = this;\n    var ref = vm.$options;\n    var render = ref.render;\n    var staticRenderFns = ref.staticRenderFns;\n    var _parentVnode = ref._parentVnode;\n\n    if (vm._isMounted) {\n      // clone slot nodes on re-renders\n      for (var key in vm.$slots) {\n        vm.$slots[key] = cloneVNodes(vm.$slots[key]);\n      }\n    }\n\n    if (_parentVnode && _parentVnode.data.scopedSlots) {\n      vm.$scopedSlots = _parentVnode.data.scopedSlots;\n    }\n\n    if (staticRenderFns && !vm._staticTrees) {\n      vm._staticTrees = [];\n    }\n    // set parent vnode. this allows render functions to have access\n    // to the data on the placeholder node.\n    vm.$vnode = _parentVnode;\n    // render self\n    var vnode;\n    try {\n      vnode = render.call(vm._renderProxy, vm.$createElement);\n    } catch (e) {\n      /* istanbul ignore else */\n      if (config.errorHandler) {\n        config.errorHandler.call(null, e, vm);\n      } else {\n        if (process.env.NODE_ENV !== 'production') {\n          warn((\"Error when rendering \" + (formatComponentName(vm)) + \":\"));\n        }\n        throw e\n      }\n      // return previous vnode to prevent render error causing blank component\n      vnode = vm._vnode;\n    }\n    // return empty vnode in case the render function errored out\n    if (!(vnode instanceof VNode)) {\n      if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {\n        warn(\n          'Multiple root nodes returned from render function. Render function ' +\n          'should return a single root node.',\n          vm\n        );\n      }\n      vnode = createEmptyVNode();\n    }\n    // set parent\n    vnode.parent = _parentVnode;\n    return vnode\n  };\n\n  // toString for mustaches\n  Vue.prototype._s = _toString;\n  // convert text to vnode\n  Vue.prototype._v = createTextVNode;\n  // number conversion\n  Vue.prototype._n = toNumber;\n  // empty vnode\n  Vue.prototype._e = createEmptyVNode;\n  // loose equal\n  Vue.prototype._q = looseEqual;\n  // loose indexOf\n  Vue.prototype._i = looseIndexOf;\n\n  // render static tree by index\n  Vue.prototype._m = function renderStatic (\n    index,\n    isInFor\n  ) {\n    var tree = this._staticTrees[index];\n    // if has already-rendered static tree and not inside v-for,\n    // we can reuse the same tree by doing a shallow clone.\n    if (tree && !isInFor) {\n      return Array.isArray(tree)\n        ? cloneVNodes(tree)\n        : cloneVNode(tree)\n    }\n    // otherwise, render a fresh tree.\n    tree = this._staticTrees[index] = this.$options.staticRenderFns[index].call(this._renderProxy);\n    markStatic(tree, (\"__static__\" + index), false);\n    return tree\n  };\n\n  // mark node as static (v-once)\n  Vue.prototype._o = function markOnce (\n    tree,\n    index,\n    key\n  ) {\n    markStatic(tree, (\"__once__\" + index + (key ? (\"_\" + key) : \"\")), true);\n    return tree\n  };\n\n  function markStatic (tree, key, isOnce) {\n    if (Array.isArray(tree)) {\n      for (var i = 0; i < tree.length; i++) {\n        if (tree[i] && typeof tree[i] !== 'string') {\n          markStaticNode(tree[i], (key + \"_\" + i), isOnce);\n        }\n      }\n    } else {\n      markStaticNode(tree, key, isOnce);\n    }\n  }\n\n  function markStaticNode (node, key, isOnce) {\n    node.isStatic = true;\n    node.key = key;\n    node.isOnce = isOnce;\n  }\n\n  // filter resolution helper\n  Vue.prototype._f = function resolveFilter (id) {\n    return resolveAsset(this.$options, 'filters', id, true) || identity\n  };\n\n  // render v-for\n  Vue.prototype._l = function renderList (\n    val,\n    render\n  ) {\n    var ret, i, l, keys, key;\n    if (Array.isArray(val) || typeof val === 'string') {\n      ret = new Array(val.length);\n      for (i = 0, l = val.length; i < l; i++) {\n        ret[i] = render(val[i], i);\n      }\n    } else if (typeof val === 'number') {\n      ret = new Array(val);\n      for (i = 0; i < val; i++) {\n        ret[i] = render(i + 1, i);\n      }\n    } else if (isObject(val)) {\n      keys = Object.keys(val);\n      ret = new Array(keys.length);\n      for (i = 0, l = keys.length; i < l; i++) {\n        key = keys[i];\n        ret[i] = render(val[key], key, i);\n      }\n    }\n    return ret\n  };\n\n  // renderSlot\n  Vue.prototype._t = function (\n    name,\n    fallback,\n    props,\n    bindObject\n  ) {\n    var scopedSlotFn = this.$scopedSlots[name];\n    if (scopedSlotFn) { // scoped slot\n      props = props || {};\n      if (bindObject) {\n        extend(props, bindObject);\n      }\n      return scopedSlotFn(props) || fallback\n    } else {\n      var slotNodes = this.$slots[name];\n      // warn duplicate slot usage\n      if (slotNodes && process.env.NODE_ENV !== 'production') {\n        slotNodes._rendered && warn(\n          \"Duplicate presence of slot \\\"\" + name + \"\\\" found in the same render tree \" +\n          \"- this will likely cause render errors.\",\n          this\n        );\n        slotNodes._rendered = true;\n      }\n      return slotNodes || fallback\n    }\n  };\n\n  // apply v-bind object\n  Vue.prototype._b = function bindProps (\n    data,\n    tag,\n    value,\n    asProp\n  ) {\n    if (value) {\n      if (!isObject(value)) {\n        process.env.NODE_ENV !== 'production' && warn(\n          'v-bind without argument expects an Object or Array value',\n          this\n        );\n      } else {\n        if (Array.isArray(value)) {\n          value = toObject(value);\n        }\n        for (var key in value) {\n          if (key === 'class' || key === 'style') {\n            data[key] = value[key];\n          } else {\n            var type = data.attrs && data.attrs.type;\n            var hash = asProp || config.mustUseProp(tag, type, key)\n              ? data.domProps || (data.domProps = {})\n              : data.attrs || (data.attrs = {});\n            hash[key] = value[key];\n          }\n        }\n      }\n    }\n    return data\n  };\n\n  // check v-on keyCodes\n  Vue.prototype._k = function checkKeyCodes (\n    eventKeyCode,\n    key,\n    builtInAlias\n  ) {\n    var keyCodes = config.keyCodes[key] || builtInAlias;\n    if (Array.isArray(keyCodes)) {\n      return keyCodes.indexOf(eventKeyCode) === -1\n    } else {\n      return keyCodes !== eventKeyCode\n    }\n  };\n}\n\nfunction resolveSlots (\n  children,\n  context\n) {\n  var slots = {};\n  if (!children) {\n    return slots\n  }\n  var defaultSlot = [];\n  var name, child;\n  for (var i = 0, l = children.length; i < l; i++) {\n    child = children[i];\n    // named slots should only be respected if the vnode was rendered in the\n    // same context.\n    if ((child.context === context || child.functionalContext === context) &&\n        child.data && (name = child.data.slot)) {\n      var slot = (slots[name] || (slots[name] = []));\n      if (child.tag === 'template') {\n        slot.push.apply(slot, child.children);\n      } else {\n        slot.push(child);\n      }\n    } else {\n      defaultSlot.push(child);\n    }\n  }\n  // ignore single whitespace\n  if (defaultSlot.length && !(\n    defaultSlot.length === 1 &&\n    (defaultSlot[0].text === ' ' || defaultSlot[0].isComment)\n  )) {\n    slots.default = defaultSlot;\n  }\n  return slots\n}\n\n/*  */\n\nfunction initEvents (vm) {\n  vm._events = Object.create(null);\n  vm._hasHookEvent = false;\n  // init parent attached events\n  var listeners = vm.$options._parentListeners;\n  if (listeners) {\n    updateComponentListeners(vm, listeners);\n  }\n}\n\nvar target;\n\nfunction add$1 (event, fn, once) {\n  if (once) {\n    target.$once(event, fn);\n  } else {\n    target.$on(event, fn);\n  }\n}\n\nfunction remove$2 (event, fn) {\n  target.$off(event, fn);\n}\n\nfunction updateComponentListeners (\n  vm,\n  listeners,\n  oldListeners\n) {\n  target = vm;\n  updateListeners(listeners, oldListeners || {}, add$1, remove$2, vm);\n}\n\nfunction eventsMixin (Vue) {\n  var hookRE = /^hook:/;\n  Vue.prototype.$on = function (event, fn) {\n    var vm = this;(vm._events[event] || (vm._events[event] = [])).push(fn);\n    // optimize hook:event cost by using a boolean flag marked at registration\n    // instead of a hash lookup\n    if (hookRE.test(event)) {\n      vm._hasHookEvent = true;\n    }\n    return vm\n  };\n\n  Vue.prototype.$once = function (event, fn) {\n    var vm = this;\n    function on () {\n      vm.$off(event, on);\n      fn.apply(vm, arguments);\n    }\n    on.fn = fn;\n    vm.$on(event, on);\n    return vm\n  };\n\n  Vue.prototype.$off = function (event, fn) {\n    var vm = this;\n    // all\n    if (!arguments.length) {\n      vm._events = Object.create(null);\n      return vm\n    }\n    // specific event\n    var cbs = vm._events[event];\n    if (!cbs) {\n      return vm\n    }\n    if (arguments.length === 1) {\n      vm._events[event] = null;\n      return vm\n    }\n    // specific handler\n    var cb;\n    var i = cbs.length;\n    while (i--) {\n      cb = cbs[i];\n      if (cb === fn || cb.fn === fn) {\n        cbs.splice(i, 1);\n        break\n      }\n    }\n    return vm\n  };\n\n  Vue.prototype.$emit = function (event) {\n    var vm = this;\n    var cbs = vm._events[event];\n    if (cbs) {\n      cbs = cbs.length > 1 ? toArray(cbs) : cbs;\n      var args = toArray(arguments, 1);\n      for (var i = 0, l = cbs.length; i < l; i++) {\n        cbs[i].apply(vm, args);\n      }\n    }\n    return vm\n  };\n}\n\n/*  */\n\nvar activeInstance = null;\n\nfunction initLifecycle (vm) {\n  var options = vm.$options;\n\n  // locate first non-abstract parent\n  var parent = options.parent;\n  if (parent && !options.abstract) {\n    while (parent.$options.abstract && parent.$parent) {\n      parent = parent.$parent;\n    }\n    parent.$children.push(vm);\n  }\n\n  vm.$parent = parent;\n  vm.$root = parent ? parent.$root : vm;\n\n  vm.$children = [];\n  vm.$refs = {};\n\n  vm._watcher = null;\n  vm._inactive = false;\n  vm._isMounted = false;\n  vm._isDestroyed = false;\n  vm._isBeingDestroyed = false;\n}\n\nfunction lifecycleMixin (Vue) {\n  Vue.prototype._mount = function (\n    el,\n    hydrating\n  ) {\n    var vm = this;\n    vm.$el = el;\n    if (!vm.$options.render) {\n      vm.$options.render = createEmptyVNode;\n      if (process.env.NODE_ENV !== 'production') {\n        /* istanbul ignore if */\n        if (vm.$options.template && vm.$options.template.charAt(0) !== '#') {\n          warn(\n            'You are using the runtime-only build of Vue where the template ' +\n            'option is not available. Either pre-compile the templates into ' +\n            'render functions, or use the compiler-included build.',\n            vm\n          );\n        } else {\n          warn(\n            'Failed to mount component: template or render function not defined.',\n            vm\n          );\n        }\n      }\n    }\n    callHook(vm, 'beforeMount');\n    vm._watcher = new Watcher(vm, function updateComponent () {\n      vm._update(vm._render(), hydrating);\n    }, noop);\n    hydrating = false;\n    // manually mounted instance, call mounted on self\n    // mounted is called for render-created child components in its inserted hook\n    if (vm.$vnode == null) {\n      vm._isMounted = true;\n      callHook(vm, 'mounted');\n    }\n    return vm\n  };\n\n  Vue.prototype._update = function (vnode, hydrating) {\n    var vm = this;\n    if (vm._isMounted) {\n      callHook(vm, 'beforeUpdate');\n    }\n    var prevEl = vm.$el;\n    var prevVnode = vm._vnode;\n    var prevActiveInstance = activeInstance;\n    activeInstance = vm;\n    vm._vnode = vnode;\n    // Vue.prototype.__patch__ is injected in entry points\n    // based on the rendering backend used.\n    if (!prevVnode) {\n      // initial render\n      vm.$el = vm.__patch__(\n        vm.$el, vnode, hydrating, false /* removeOnly */,\n        vm.$options._parentElm,\n        vm.$options._refElm\n      );\n    } else {\n      // updates\n      vm.$el = vm.__patch__(prevVnode, vnode);\n    }\n    activeInstance = prevActiveInstance;\n    // update __vue__ reference\n    if (prevEl) {\n      prevEl.__vue__ = null;\n    }\n    if (vm.$el) {\n      vm.$el.__vue__ = vm;\n    }\n    // if parent is an HOC, update its $el as well\n    if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {\n      vm.$parent.$el = vm.$el;\n    }\n    // updated hook is called by the scheduler to ensure that children are\n    // updated in a parent's updated hook.\n  };\n\n  Vue.prototype._updateFromParent = function (\n    propsData,\n    listeners,\n    parentVnode,\n    renderChildren\n  ) {\n    var vm = this;\n    var hasChildren = !!(vm.$options._renderChildren || renderChildren);\n    vm.$options._parentVnode = parentVnode;\n    vm.$vnode = parentVnode; // update vm's placeholder node without re-render\n    if (vm._vnode) { // update child tree's parent\n      vm._vnode.parent = parentVnode;\n    }\n    vm.$options._renderChildren = renderChildren;\n    // update props\n    if (propsData && vm.$options.props) {\n      observerState.shouldConvert = false;\n      if (process.env.NODE_ENV !== 'production') {\n        observerState.isSettingProps = true;\n      }\n      var propKeys = vm.$options._propKeys || [];\n      for (var i = 0; i < propKeys.length; i++) {\n        var key = propKeys[i];\n        vm[key] = validateProp(key, vm.$options.props, propsData, vm);\n      }\n      observerState.shouldConvert = true;\n      if (process.env.NODE_ENV !== 'production') {\n        observerState.isSettingProps = false;\n      }\n      vm.$options.propsData = propsData;\n    }\n    // update listeners\n    if (listeners) {\n      var oldListeners = vm.$options._parentListeners;\n      vm.$options._parentListeners = listeners;\n      updateComponentListeners(vm, listeners, oldListeners);\n    }\n    // resolve slots + force update if has children\n    if (hasChildren) {\n      vm.$slots = resolveSlots(renderChildren, parentVnode.context);\n      vm.$forceUpdate();\n    }\n  };\n\n  Vue.prototype.$forceUpdate = function () {\n    var vm = this;\n    if (vm._watcher) {\n      vm._watcher.update();\n    }\n  };\n\n  Vue.prototype.$destroy = function () {\n    var vm = this;\n    if (vm._isBeingDestroyed) {\n      return\n    }\n    callHook(vm, 'beforeDestroy');\n    vm._isBeingDestroyed = true;\n    // remove self from parent\n    var parent = vm.$parent;\n    if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {\n      remove$1(parent.$children, vm);\n    }\n    // teardown watchers\n    if (vm._watcher) {\n      vm._watcher.teardown();\n    }\n    var i = vm._watchers.length;\n    while (i--) {\n      vm._watchers[i].teardown();\n    }\n    // remove reference from data ob\n    // frozen object may not have observer.\n    if (vm._data.__ob__) {\n      vm._data.__ob__.vmCount--;\n    }\n    // call the last hook...\n    vm._isDestroyed = true;\n    callHook(vm, 'destroyed');\n    // turn off all instance listeners.\n    vm.$off();\n    // remove __vue__ reference\n    if (vm.$el) {\n      vm.$el.__vue__ = null;\n    }\n    // invoke destroy hooks on current rendered tree\n    vm.__patch__(vm._vnode, null);\n  };\n}\n\nfunction callHook (vm, hook) {\n  var handlers = vm.$options[hook];\n  if (handlers) {\n    for (var i = 0, j = handlers.length; i < j; i++) {\n      handlers[i].call(vm);\n    }\n  }\n  if (vm._hasHookEvent) {\n    vm.$emit('hook:' + hook);\n  }\n}\n\n/*  */\n\n\nvar queue = [];\nvar has$1 = {};\nvar circular = {};\nvar waiting = false;\nvar flushing = false;\nvar index = 0;\n\n/**\n * Reset the scheduler's state.\n */\nfunction resetSchedulerState () {\n  queue.length = 0;\n  has$1 = {};\n  if (process.env.NODE_ENV !== 'production') {\n    circular = {};\n  }\n  waiting = flushing = false;\n}\n\n/**\n * Flush both queues and run the watchers.\n */\nfunction flushSchedulerQueue () {\n  flushing = true;\n  var watcher, id, vm;\n\n  // Sort queue before flush.\n  // This ensures that:\n  // 1. Components are updated from parent to child. (because parent is always\n  //    created before the child)\n  // 2. A component's user watchers are run before its render watcher (because\n  //    user watchers are created before the render watcher)\n  // 3. If a component is destroyed during a parent component's watcher run,\n  //    its watchers can be skipped.\n  queue.sort(function (a, b) { return a.id - b.id; });\n\n  // do not cache length because more watchers might be pushed\n  // as we run existing watchers\n  for (index = 0; index < queue.length; index++) {\n    watcher = queue[index];\n    id = watcher.id;\n    has$1[id] = null;\n    watcher.run();\n    // in dev build, check and stop circular updates.\n    if (process.env.NODE_ENV !== 'production' && has$1[id] != null) {\n      circular[id] = (circular[id] || 0) + 1;\n      if (circular[id] > config._maxUpdateCount) {\n        warn(\n          'You may have an infinite update loop ' + (\n            watcher.user\n              ? (\"in watcher with expression \\\"\" + (watcher.expression) + \"\\\"\")\n              : \"in a component render function.\"\n          ),\n          watcher.vm\n        );\n        break\n      }\n    }\n  }\n\n  // call updated hooks\n  index = queue.length;\n  while (index--) {\n    watcher = queue[index];\n    vm = watcher.vm;\n    if (vm._watcher === watcher && vm._isMounted) {\n      callHook(vm, 'updated');\n    }\n  }\n\n  // devtool hook\n  /* istanbul ignore if */\n  if (devtools && config.devtools) {\n    devtools.emit('flush');\n  }\n\n  resetSchedulerState();\n}\n\n/**\n * Push a watcher into the watcher queue.\n * Jobs with duplicate IDs will be skipped unless it's\n * pushed when the queue is being flushed.\n */\nfunction queueWatcher (watcher) {\n  var id = watcher.id;\n  if (has$1[id] == null) {\n    has$1[id] = true;\n    if (!flushing) {\n      queue.push(watcher);\n    } else {\n      // if already flushing, splice the watcher based on its id\n      // if already past its id, it will be run next immediately.\n      var i = queue.length - 1;\n      while (i >= 0 && queue[i].id > watcher.id) {\n        i--;\n      }\n      queue.splice(Math.max(i, index) + 1, 0, watcher);\n    }\n    // queue the flush\n    if (!waiting) {\n      waiting = true;\n      nextTick(flushSchedulerQueue);\n    }\n  }\n}\n\n/*  */\n\nvar uid$2 = 0;\n\n/**\n * A watcher parses an expression, collects dependencies,\n * and fires callback when the expression value changes.\n * This is used for both the $watch() api and directives.\n */\nvar Watcher = function Watcher (\n  vm,\n  expOrFn,\n  cb,\n  options\n) {\n  this.vm = vm;\n  vm._watchers.push(this);\n  // options\n  if (options) {\n    this.deep = !!options.deep;\n    this.user = !!options.user;\n    this.lazy = !!options.lazy;\n    this.sync = !!options.sync;\n  } else {\n    this.deep = this.user = this.lazy = this.sync = false;\n  }\n  this.cb = cb;\n  this.id = ++uid$2; // uid for batching\n  this.active = true;\n  this.dirty = this.lazy; // for lazy watchers\n  this.deps = [];\n  this.newDeps = [];\n  this.depIds = new _Set();\n  this.newDepIds = new _Set();\n  this.expression = process.env.NODE_ENV !== 'production'\n    ? expOrFn.toString()\n    : '';\n  // parse expression for getter\n  if (typeof expOrFn === 'function') {\n    this.getter = expOrFn;\n  } else {\n    this.getter = parsePath(expOrFn);\n    if (!this.getter) {\n      this.getter = function () {};\n      process.env.NODE_ENV !== 'production' && warn(\n        \"Failed watching path: \\\"\" + expOrFn + \"\\\" \" +\n        'Watcher only accepts simple dot-delimited paths. ' +\n        'For full control, use a function instead.',\n        vm\n      );\n    }\n  }\n  this.value = this.lazy\n    ? undefined\n    : this.get();\n};\n\n/**\n * Evaluate the getter, and re-collect dependencies.\n */\nWatcher.prototype.get = function get () {\n  pushTarget(this);\n  var value = this.getter.call(this.vm, this.vm);\n  // \"touch\" every property so they are all tracked as\n  // dependencies for deep watching\n  if (this.deep) {\n    traverse(value);\n  }\n  popTarget();\n  this.cleanupDeps();\n  return value\n};\n\n/**\n * Add a dependency to this directive.\n */\nWatcher.prototype.addDep = function addDep (dep) {\n  var id = dep.id;\n  if (!this.newDepIds.has(id)) {\n    this.newDepIds.add(id);\n    this.newDeps.push(dep);\n    if (!this.depIds.has(id)) {\n      dep.addSub(this);\n    }\n  }\n};\n\n/**\n * Clean up for dependency collection.\n */\nWatcher.prototype.cleanupDeps = function cleanupDeps () {\n    var this$1 = this;\n\n  var i = this.deps.length;\n  while (i--) {\n    var dep = this$1.deps[i];\n    if (!this$1.newDepIds.has(dep.id)) {\n      dep.removeSub(this$1);\n    }\n  }\n  var tmp = this.depIds;\n  this.depIds = this.newDepIds;\n  this.newDepIds = tmp;\n  this.newDepIds.clear();\n  tmp = this.deps;\n  this.deps = this.newDeps;\n  this.newDeps = tmp;\n  this.newDeps.length = 0;\n};\n\n/**\n * Subscriber interface.\n * Will be called when a dependency changes.\n */\nWatcher.prototype.update = function update () {\n  /* istanbul ignore else */\n  if (this.lazy) {\n    this.dirty = true;\n  } else if (this.sync) {\n    this.run();\n  } else {\n    queueWatcher(this);\n  }\n};\n\n/**\n * Scheduler job interface.\n * Will be called by the scheduler.\n */\nWatcher.prototype.run = function run () {\n  if (this.active) {\n    var value = this.get();\n    if (\n      value !== this.value ||\n      // Deep watchers and watchers on Object/Arrays should fire even\n      // when the value is the same, because the value may\n      // have mutated.\n      isObject(value) ||\n      this.deep\n    ) {\n      // set new value\n      var oldValue = this.value;\n      this.value = value;\n      if (this.user) {\n        try {\n          this.cb.call(this.vm, value, oldValue);\n        } catch (e) {\n          /* istanbul ignore else */\n          if (config.errorHandler) {\n            config.errorHandler.call(null, e, this.vm);\n          } else {\n            process.env.NODE_ENV !== 'production' && warn(\n              (\"Error in watcher \\\"\" + (this.expression) + \"\\\"\"),\n              this.vm\n            );\n            throw e\n          }\n        }\n      } else {\n        this.cb.call(this.vm, value, oldValue);\n      }\n    }\n  }\n};\n\n/**\n * Evaluate the value of the watcher.\n * This only gets called for lazy watchers.\n */\nWatcher.prototype.evaluate = function evaluate () {\n  this.value = this.get();\n  this.dirty = false;\n};\n\n/**\n * Depend on all deps collected by this watcher.\n */\nWatcher.prototype.depend = function depend () {\n    var this$1 = this;\n\n  var i = this.deps.length;\n  while (i--) {\n    this$1.deps[i].depend();\n  }\n};\n\n/**\n * Remove self from all dependencies' subscriber list.\n */\nWatcher.prototype.teardown = function teardown () {\n    var this$1 = this;\n\n  if (this.active) {\n    // remove self from vm's watcher list\n    // this is a somewhat expensive operation so we skip it\n    // if the vm is being destroyed.\n    if (!this.vm._isBeingDestroyed) {\n      remove$1(this.vm._watchers, this);\n    }\n    var i = this.deps.length;\n    while (i--) {\n      this$1.deps[i].removeSub(this$1);\n    }\n    this.active = false;\n  }\n};\n\n/**\n * Recursively traverse an object to evoke all converted\n * getters, so that every nested property inside the object\n * is collected as a \"deep\" dependency.\n */\nvar seenObjects = new _Set();\nfunction traverse (val) {\n  seenObjects.clear();\n  _traverse(val, seenObjects);\n}\n\nfunction _traverse (val, seen) {\n  var i, keys;\n  var isA = Array.isArray(val);\n  if ((!isA && !isObject(val)) || !Object.isExtensible(val)) {\n    return\n  }\n  if (val.__ob__) {\n    var depId = val.__ob__.dep.id;\n    if (seen.has(depId)) {\n      return\n    }\n    seen.add(depId);\n  }\n  if (isA) {\n    i = val.length;\n    while (i--) { _traverse(val[i], seen); }\n  } else {\n    keys = Object.keys(val);\n    i = keys.length;\n    while (i--) { _traverse(val[keys[i]], seen); }\n  }\n}\n\n/*  */\n\nfunction initState (vm) {\n  vm._watchers = [];\n  var opts = vm.$options;\n  if (opts.props) { initProps(vm, opts.props); }\n  if (opts.methods) { initMethods(vm, opts.methods); }\n  if (opts.data) {\n    initData(vm);\n  } else {\n    observe(vm._data = {}, true /* asRootData */);\n  }\n  if (opts.computed) { initComputed(vm, opts.computed); }\n  if (opts.watch) { initWatch(vm, opts.watch); }\n}\n\nvar isReservedProp = { key: 1, ref: 1, slot: 1 };\n\nfunction initProps (vm, props) {\n  var propsData = vm.$options.propsData || {};\n  var keys = vm.$options._propKeys = Object.keys(props);\n  var isRoot = !vm.$parent;\n  // root instance props should be converted\n  observerState.shouldConvert = isRoot;\n  var loop = function ( i ) {\n    var key = keys[i];\n    /* istanbul ignore else */\n    if (process.env.NODE_ENV !== 'production') {\n      if (isReservedProp[key]) {\n        warn(\n          (\"\\\"\" + key + \"\\\" is a reserved attribute and cannot be used as component prop.\"),\n          vm\n        );\n      }\n      defineReactive$$1(vm, key, validateProp(key, props, propsData, vm), function () {\n        if (vm.$parent && !observerState.isSettingProps) {\n          warn(\n            \"Avoid mutating a prop directly since the value will be \" +\n            \"overwritten whenever the parent component re-renders. \" +\n            \"Instead, use a data or computed property based on the prop's \" +\n            \"value. Prop being mutated: \\\"\" + key + \"\\\"\",\n            vm\n          );\n        }\n      });\n    } else {\n      defineReactive$$1(vm, key, validateProp(key, props, propsData, vm));\n    }\n  };\n\n  for (var i = 0; i < keys.length; i++) loop( i );\n  observerState.shouldConvert = true;\n}\n\nfunction initData (vm) {\n  var data = vm.$options.data;\n  data = vm._data = typeof data === 'function'\n    ? data.call(vm)\n    : data || {};\n  if (!isPlainObject(data)) {\n    data = {};\n    process.env.NODE_ENV !== 'production' && warn(\n      'data functions should return an object:\\n' +\n      'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',\n      vm\n    );\n  }\n  // proxy data on instance\n  var keys = Object.keys(data);\n  var props = vm.$options.props;\n  var i = keys.length;\n  while (i--) {\n    if (props && hasOwn(props, keys[i])) {\n      process.env.NODE_ENV !== 'production' && warn(\n        \"The data property \\\"\" + (keys[i]) + \"\\\" is already declared as a prop. \" +\n        \"Use prop default value instead.\",\n        vm\n      );\n    } else {\n      proxy(vm, keys[i]);\n    }\n  }\n  // observe data\n  observe(data, true /* asRootData */);\n}\n\nvar computedSharedDefinition = {\n  enumerable: true,\n  configurable: true,\n  get: noop,\n  set: noop\n};\n\nfunction initComputed (vm, computed) {\n  for (var key in computed) {\n    /* istanbul ignore if */\n    if (process.env.NODE_ENV !== 'production' && key in vm) {\n      warn(\n        \"existing instance property \\\"\" + key + \"\\\" will be \" +\n        \"overwritten by a computed property with the same name.\",\n        vm\n      );\n    }\n    var userDef = computed[key];\n    if (typeof userDef === 'function') {\n      computedSharedDefinition.get = makeComputedGetter(userDef, vm);\n      computedSharedDefinition.set = noop;\n    } else {\n      computedSharedDefinition.get = userDef.get\n        ? userDef.cache !== false\n          ? makeComputedGetter(userDef.get, vm)\n          : bind$1(userDef.get, vm)\n        : noop;\n      computedSharedDefinition.set = userDef.set\n        ? bind$1(userDef.set, vm)\n        : noop;\n    }\n    Object.defineProperty(vm, key, computedSharedDefinition);\n  }\n}\n\nfunction makeComputedGetter (getter, owner) {\n  var watcher = new Watcher(owner, getter, noop, {\n    lazy: true\n  });\n  return function computedGetter () {\n    if (watcher.dirty) {\n      watcher.evaluate();\n    }\n    if (Dep.target) {\n      watcher.depend();\n    }\n    return watcher.value\n  }\n}\n\nfunction initMethods (vm, methods) {\n  for (var key in methods) {\n    vm[key] = methods[key] == null ? noop : bind$1(methods[key], vm);\n    if (process.env.NODE_ENV !== 'production' && methods[key] == null) {\n      warn(\n        \"method \\\"\" + key + \"\\\" has an undefined value in the component definition. \" +\n        \"Did you reference the function correctly?\",\n        vm\n      );\n    }\n  }\n}\n\nfunction initWatch (vm, watch) {\n  for (var key in watch) {\n    var handler = watch[key];\n    if (Array.isArray(handler)) {\n      for (var i = 0; i < handler.length; i++) {\n        createWatcher(vm, key, handler[i]);\n      }\n    } else {\n      createWatcher(vm, key, handler);\n    }\n  }\n}\n\nfunction createWatcher (vm, key, handler) {\n  var options;\n  if (isPlainObject(handler)) {\n    options = handler;\n    handler = handler.handler;\n  }\n  if (typeof handler === 'string') {\n    handler = vm[handler];\n  }\n  vm.$watch(key, handler, options);\n}\n\nfunction stateMixin (Vue) {\n  // flow somehow has problems with directly declared definition object\n  // when using Object.defineProperty, so we have to procedurally build up\n  // the object here.\n  var dataDef = {};\n  dataDef.get = function () {\n    return this._data\n  };\n  if (process.env.NODE_ENV !== 'production') {\n    dataDef.set = function (newData) {\n      warn(\n        'Avoid replacing instance root $data. ' +\n        'Use nested data properties instead.',\n        this\n      );\n    };\n  }\n  Object.defineProperty(Vue.prototype, '$data', dataDef);\n\n  Vue.prototype.$set = set$1;\n  Vue.prototype.$delete = del;\n\n  Vue.prototype.$watch = function (\n    expOrFn,\n    cb,\n    options\n  ) {\n    var vm = this;\n    options = options || {};\n    options.user = true;\n    var watcher = new Watcher(vm, expOrFn, cb, options);\n    if (options.immediate) {\n      cb.call(vm, watcher.value);\n    }\n    return function unwatchFn () {\n      watcher.teardown();\n    }\n  };\n}\n\nfunction proxy (vm, key) {\n  if (!isReserved(key)) {\n    Object.defineProperty(vm, key, {\n      configurable: true,\n      enumerable: true,\n      get: function proxyGetter () {\n        return vm._data[key]\n      },\n      set: function proxySetter (val) {\n        vm._data[key] = val;\n      }\n    });\n  }\n}\n\n/*  */\n\nvar uid = 0;\n\nfunction initMixin (Vue) {\n  Vue.prototype._init = function (options) {\n    var vm = this;\n    // a uid\n    vm._uid = uid++;\n    // a flag to avoid this being observed\n    vm._isVue = true;\n    // merge options\n    if (options && options._isComponent) {\n      // optimize internal component instantiation\n      // since dynamic options merging is pretty slow, and none of the\n      // internal component options needs special treatment.\n      initInternalComponent(vm, options);\n    } else {\n      vm.$options = mergeOptions(\n        resolveConstructorOptions(vm.constructor),\n        options || {},\n        vm\n      );\n    }\n    /* istanbul ignore else */\n    if (process.env.NODE_ENV !== 'production') {\n      initProxy(vm);\n    } else {\n      vm._renderProxy = vm;\n    }\n    // expose real self\n    vm._self = vm;\n    initLifecycle(vm);\n    initEvents(vm);\n    initRender(vm);\n    callHook(vm, 'beforeCreate');\n    initState(vm);\n    callHook(vm, 'created');\n    if (vm.$options.el) {\n      vm.$mount(vm.$options.el);\n    }\n  };\n}\n\nfunction initInternalComponent (vm, options) {\n  var opts = vm.$options = Object.create(vm.constructor.options);\n  // doing this because it's faster than dynamic enumeration.\n  opts.parent = options.parent;\n  opts.propsData = options.propsData;\n  opts._parentVnode = options._parentVnode;\n  opts._parentListeners = options._parentListeners;\n  opts._renderChildren = options._renderChildren;\n  opts._componentTag = options._componentTag;\n  opts._parentElm = options._parentElm;\n  opts._refElm = options._refElm;\n  if (options.render) {\n    opts.render = options.render;\n    opts.staticRenderFns = options.staticRenderFns;\n  }\n}\n\nfunction resolveConstructorOptions (Ctor) {\n  var options = Ctor.options;\n  if (Ctor.super) {\n    var superOptions = Ctor.super.options;\n    var cachedSuperOptions = Ctor.superOptions;\n    var extendOptions = Ctor.extendOptions;\n    if (superOptions !== cachedSuperOptions) {\n      // super option changed\n      Ctor.superOptions = superOptions;\n      extendOptions.render = options.render;\n      extendOptions.staticRenderFns = options.staticRenderFns;\n      extendOptions._scopeId = options._scopeId;\n      options = Ctor.options = mergeOptions(superOptions, extendOptions);\n      if (options.name) {\n        options.components[options.name] = Ctor;\n      }\n    }\n  }\n  return options\n}\n\nfunction Vue$3 (options) {\n  if (process.env.NODE_ENV !== 'production' &&\n    !(this instanceof Vue$3)) {\n    warn('Vue is a constructor and should be called with the `new` keyword');\n  }\n  this._init(options);\n}\n\ninitMixin(Vue$3);\nstateMixin(Vue$3);\neventsMixin(Vue$3);\nlifecycleMixin(Vue$3);\nrenderMixin(Vue$3);\n\n/*  */\n\nfunction initUse (Vue) {\n  Vue.use = function (plugin) {\n    /* istanbul ignore if */\n    if (plugin.installed) {\n      return\n    }\n    // additional parameters\n    var args = toArray(arguments, 1);\n    args.unshift(this);\n    if (typeof plugin.install === 'function') {\n      plugin.install.apply(plugin, args);\n    } else {\n      plugin.apply(null, args);\n    }\n    plugin.installed = true;\n    return this\n  };\n}\n\n/*  */\n\nfunction initMixin$1 (Vue) {\n  Vue.mixin = function (mixin) {\n    this.options = mergeOptions(this.options, mixin);\n  };\n}\n\n/*  */\n\nfunction initExtend (Vue) {\n  /**\n   * Each instance constructor, including Vue, has a unique\n   * cid. This enables us to create wrapped \"child\n   * constructors\" for prototypal inheritance and cache them.\n   */\n  Vue.cid = 0;\n  var cid = 1;\n\n  /**\n   * Class inheritance\n   */\n  Vue.extend = function (extendOptions) {\n    extendOptions = extendOptions || {};\n    var Super = this;\n    var SuperId = Super.cid;\n    var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});\n    if (cachedCtors[SuperId]) {\n      return cachedCtors[SuperId]\n    }\n    var name = extendOptions.name || Super.options.name;\n    if (process.env.NODE_ENV !== 'production') {\n      if (!/^[a-zA-Z][\\w-]*$/.test(name)) {\n        warn(\n          'Invalid component name: \"' + name + '\". Component names ' +\n          'can only contain alphanumeric characters and the hyphen, ' +\n          'and must start with a letter.'\n        );\n      }\n    }\n    var Sub = function VueComponent (options) {\n      this._init(options);\n    };\n    Sub.prototype = Object.create(Super.prototype);\n    Sub.prototype.constructor = Sub;\n    Sub.cid = cid++;\n    Sub.options = mergeOptions(\n      Super.options,\n      extendOptions\n    );\n    Sub['super'] = Super;\n    // allow further extension/mixin/plugin usage\n    Sub.extend = Super.extend;\n    Sub.mixin = Super.mixin;\n    Sub.use = Super.use;\n    // create asset registers, so extended classes\n    // can have their private assets too.\n    config._assetTypes.forEach(function (type) {\n      Sub[type] = Super[type];\n    });\n    // enable recursive self-lookup\n    if (name) {\n      Sub.options.components[name] = Sub;\n    }\n    // keep a reference to the super options at extension time.\n    // later at instantiation we can check if Super's options have\n    // been updated.\n    Sub.superOptions = Super.options;\n    Sub.extendOptions = extendOptions;\n    // cache constructor\n    cachedCtors[SuperId] = Sub;\n    return Sub\n  };\n}\n\n/*  */\n\nfunction initAssetRegisters (Vue) {\n  /**\n   * Create asset registration methods.\n   */\n  config._assetTypes.forEach(function (type) {\n    Vue[type] = function (\n      id,\n      definition\n    ) {\n      if (!definition) {\n        return this.options[type + 's'][id]\n      } else {\n        /* istanbul ignore if */\n        if (process.env.NODE_ENV !== 'production') {\n          if (type === 'component' && config.isReservedTag(id)) {\n            warn(\n              'Do not use built-in or reserved HTML elements as component ' +\n              'id: ' + id\n            );\n          }\n        }\n        if (type === 'component' && isPlainObject(definition)) {\n          definition.name = definition.name || id;\n          definition = this.options._base.extend(definition);\n        }\n        if (type === 'directive' && typeof definition === 'function') {\n          definition = { bind: definition, update: definition };\n        }\n        this.options[type + 's'][id] = definition;\n        return definition\n      }\n    };\n  });\n}\n\n/*  */\n\nvar patternTypes = [String, RegExp];\n\nfunction getComponentName (opts) {\n  return opts && (opts.Ctor.options.name || opts.tag)\n}\n\nfunction matches (pattern, name) {\n  if (typeof pattern === 'string') {\n    return pattern.split(',').indexOf(name) > -1\n  } else {\n    return pattern.test(name)\n  }\n}\n\nfunction pruneCache (cache, filter) {\n  for (var key in cache) {\n    var cachedNode = cache[key];\n    if (cachedNode) {\n      var name = getComponentName(cachedNode.componentOptions);\n      if (name && !filter(name)) {\n        pruneCacheEntry(cachedNode);\n        cache[key] = null;\n      }\n    }\n  }\n}\n\nfunction pruneCacheEntry (vnode) {\n  if (vnode) {\n    if (!vnode.componentInstance._inactive) {\n      callHook(vnode.componentInstance, 'deactivated');\n    }\n    vnode.componentInstance.$destroy();\n  }\n}\n\nvar KeepAlive = {\n  name: 'keep-alive',\n  abstract: true,\n\n  props: {\n    include: patternTypes,\n    exclude: patternTypes\n  },\n\n  created: function created () {\n    this.cache = Object.create(null);\n  },\n\n  destroyed: function destroyed () {\n    var this$1 = this;\n\n    for (var key in this.cache) {\n      pruneCacheEntry(this$1.cache[key]);\n    }\n  },\n\n  watch: {\n    include: function include (val) {\n      pruneCache(this.cache, function (name) { return matches(val, name); });\n    },\n    exclude: function exclude (val) {\n      pruneCache(this.cache, function (name) { return !matches(val, name); });\n    }\n  },\n\n  render: function render () {\n    var vnode = getFirstComponentChild(this.$slots.default);\n    var componentOptions = vnode && vnode.componentOptions;\n    if (componentOptions) {\n      // check pattern\n      var name = getComponentName(componentOptions);\n      if (name && (\n        (this.include && !matches(this.include, name)) ||\n        (this.exclude && matches(this.exclude, name))\n      )) {\n        return vnode\n      }\n      var key = vnode.key == null\n        // same constructor may get registered as different local components\n        // so cid alone is not enough (#3269)\n        ? componentOptions.Ctor.cid + (componentOptions.tag ? (\"::\" + (componentOptions.tag)) : '')\n        : vnode.key;\n      if (this.cache[key]) {\n        vnode.componentInstance = this.cache[key].componentInstance;\n      } else {\n        this.cache[key] = vnode;\n      }\n      vnode.data.keepAlive = true;\n    }\n    return vnode\n  }\n};\n\nvar builtInComponents = {\n  KeepAlive: KeepAlive\n};\n\n/*  */\n\nfunction initGlobalAPI (Vue) {\n  // config\n  var configDef = {};\n  configDef.get = function () { return config; };\n  if (process.env.NODE_ENV !== 'production') {\n    configDef.set = function () {\n      warn(\n        'Do not replace the Vue.config object, set individual fields instead.'\n      );\n    };\n  }\n  Object.defineProperty(Vue, 'config', configDef);\n  Vue.util = util;\n  Vue.set = set$1;\n  Vue.delete = del;\n  Vue.nextTick = nextTick;\n\n  Vue.options = Object.create(null);\n  config._assetTypes.forEach(function (type) {\n    Vue.options[type + 's'] = Object.create(null);\n  });\n\n  // this is used to identify the \"base\" constructor to extend all plain-object\n  // components with in Weex's multi-instance scenarios.\n  Vue.options._base = Vue;\n\n  extend(Vue.options.components, builtInComponents);\n\n  initUse(Vue);\n  initMixin$1(Vue);\n  initExtend(Vue);\n  initAssetRegisters(Vue);\n}\n\ninitGlobalAPI(Vue$3);\n\nObject.defineProperty(Vue$3.prototype, '$isServer', {\n  get: isServerRendering\n});\n\nVue$3.version = '2.1.10';\n\n/*  */\n\n// attributes that should be using props for binding\nvar acceptValue = makeMap('input,textarea,option,select');\nvar mustUseProp = function (tag, type, attr) {\n  return (\n    (attr === 'value' && acceptValue(tag)) && type !== 'button' ||\n    (attr === 'selected' && tag === 'option') ||\n    (attr === 'checked' && tag === 'input') ||\n    (attr === 'muted' && tag === 'video')\n  )\n};\n\nvar isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');\n\nvar isBooleanAttr = makeMap(\n  'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +\n  'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +\n  'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +\n  'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +\n  'required,reversed,scoped,seamless,selected,sortable,translate,' +\n  'truespeed,typemustmatch,visible'\n);\n\nvar xlinkNS = 'http://www.w3.org/1999/xlink';\n\nvar isXlink = function (name) {\n  return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'\n};\n\nvar getXlinkProp = function (name) {\n  return isXlink(name) ? name.slice(6, name.length) : ''\n};\n\nvar isFalsyAttrValue = function (val) {\n  return val == null || val === false\n};\n\n/*  */\n\nfunction genClassForVnode (vnode) {\n  var data = vnode.data;\n  var parentNode = vnode;\n  var childNode = vnode;\n  while (childNode.componentInstance) {\n    childNode = childNode.componentInstance._vnode;\n    if (childNode.data) {\n      data = mergeClassData(childNode.data, data);\n    }\n  }\n  while ((parentNode = parentNode.parent)) {\n    if (parentNode.data) {\n      data = mergeClassData(data, parentNode.data);\n    }\n  }\n  return genClassFromData(data)\n}\n\nfunction mergeClassData (child, parent) {\n  return {\n    staticClass: concat(child.staticClass, parent.staticClass),\n    class: child.class\n      ? [child.class, parent.class]\n      : parent.class\n  }\n}\n\nfunction genClassFromData (data) {\n  var dynamicClass = data.class;\n  var staticClass = data.staticClass;\n  if (staticClass || dynamicClass) {\n    return concat(staticClass, stringifyClass(dynamicClass))\n  }\n  /* istanbul ignore next */\n  return ''\n}\n\nfunction concat (a, b) {\n  return a ? b ? (a + ' ' + b) : a : (b || '')\n}\n\nfunction stringifyClass (value) {\n  var res = '';\n  if (!value) {\n    return res\n  }\n  if (typeof value === 'string') {\n    return value\n  }\n  if (Array.isArray(value)) {\n    var stringified;\n    for (var i = 0, l = value.length; i < l; i++) {\n      if (value[i]) {\n        if ((stringified = stringifyClass(value[i]))) {\n          res += stringified + ' ';\n        }\n      }\n    }\n    return res.slice(0, -1)\n  }\n  if (isObject(value)) {\n    for (var key in value) {\n      if (value[key]) { res += key + ' '; }\n    }\n    return res.slice(0, -1)\n  }\n  /* istanbul ignore next */\n  return res\n}\n\n/*  */\n\nvar namespaceMap = {\n  svg: 'http://www.w3.org/2000/svg',\n  math: 'http://www.w3.org/1998/Math/MathML'\n};\n\nvar isHTMLTag = makeMap(\n  'html,body,base,head,link,meta,style,title,' +\n  'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +\n  'div,dd,dl,dt,figcaption,figure,hr,img,li,main,ol,p,pre,ul,' +\n  'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +\n  's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +\n  'embed,object,param,source,canvas,script,noscript,del,ins,' +\n  'caption,col,colgroup,table,thead,tbody,td,th,tr,' +\n  'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +\n  'output,progress,select,textarea,' +\n  'details,dialog,menu,menuitem,summary,' +\n  'content,element,shadow,template'\n);\n\n// this map is intentionally selective, only covering SVG elements that may\n// contain child elements.\nvar isSVG = makeMap(\n  'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,' +\n  'font-face,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +\n  'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',\n  true\n);\n\nvar isPreTag = function (tag) { return tag === 'pre'; };\n\nvar isReservedTag = function (tag) {\n  return isHTMLTag(tag) || isSVG(tag)\n};\n\nfunction getTagNamespace (tag) {\n  if (isSVG(tag)) {\n    return 'svg'\n  }\n  // basic support for MathML\n  // note it doesn't support other MathML elements being component roots\n  if (tag === 'math') {\n    return 'math'\n  }\n}\n\nvar unknownElementCache = Object.create(null);\nfunction isUnknownElement (tag) {\n  /* istanbul ignore if */\n  if (!inBrowser) {\n    return true\n  }\n  if (isReservedTag(tag)) {\n    return false\n  }\n  tag = tag.toLowerCase();\n  /* istanbul ignore if */\n  if (unknownElementCache[tag] != null) {\n    return unknownElementCache[tag]\n  }\n  var el = document.createElement(tag);\n  if (tag.indexOf('-') > -1) {\n    // http://stackoverflow.com/a/28210364/1070244\n    return (unknownElementCache[tag] = (\n      el.constructor === window.HTMLUnknownElement ||\n      el.constructor === window.HTMLElement\n    ))\n  } else {\n    return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))\n  }\n}\n\n/*  */\n\n/**\n * Query an element selector if it's not an element already.\n */\nfunction query (el) {\n  if (typeof el === 'string') {\n    var selector = el;\n    el = document.querySelector(el);\n    if (!el) {\n      process.env.NODE_ENV !== 'production' && warn(\n        'Cannot find element: ' + selector\n      );\n      return document.createElement('div')\n    }\n  }\n  return el\n}\n\n/*  */\n\nfunction createElement$1 (tagName, vnode) {\n  var elm = document.createElement(tagName);\n  if (tagName !== 'select') {\n    return elm\n  }\n  if (vnode.data && vnode.data.attrs && 'multiple' in vnode.data.attrs) {\n    elm.setAttribute('multiple', 'multiple');\n  }\n  return elm\n}\n\nfunction createElementNS (namespace, tagName) {\n  return document.createElementNS(namespaceMap[namespace], tagName)\n}\n\nfunction createTextNode (text) {\n  return document.createTextNode(text)\n}\n\nfunction createComment (text) {\n  return document.createComment(text)\n}\n\nfunction insertBefore (parentNode, newNode, referenceNode) {\n  parentNode.insertBefore(newNode, referenceNode);\n}\n\nfunction removeChild (node, child) {\n  node.removeChild(child);\n}\n\nfunction appendChild (node, child) {\n  node.appendChild(child);\n}\n\nfunction parentNode (node) {\n  return node.parentNode\n}\n\nfunction nextSibling (node) {\n  return node.nextSibling\n}\n\nfunction tagName (node) {\n  return node.tagName\n}\n\nfunction setTextContent (node, text) {\n  node.textContent = text;\n}\n\nfunction setAttribute (node, key, val) {\n  node.setAttribute(key, val);\n}\n\n\nvar nodeOps = Object.freeze({\n\tcreateElement: createElement$1,\n\tcreateElementNS: createElementNS,\n\tcreateTextNode: createTextNode,\n\tcreateComment: createComment,\n\tinsertBefore: insertBefore,\n\tremoveChild: removeChild,\n\tappendChild: appendChild,\n\tparentNode: parentNode,\n\tnextSibling: nextSibling,\n\ttagName: tagName,\n\tsetTextContent: setTextContent,\n\tsetAttribute: setAttribute\n});\n\n/*  */\n\nvar ref = {\n  create: function create (_, vnode) {\n    registerRef(vnode);\n  },\n  update: function update (oldVnode, vnode) {\n    if (oldVnode.data.ref !== vnode.data.ref) {\n      registerRef(oldVnode, true);\n      registerRef(vnode);\n    }\n  },\n  destroy: function destroy (vnode) {\n    registerRef(vnode, true);\n  }\n};\n\nfunction registerRef (vnode, isRemoval) {\n  var key = vnode.data.ref;\n  if (!key) { return }\n\n  var vm = vnode.context;\n  var ref = vnode.componentInstance || vnode.elm;\n  var refs = vm.$refs;\n  if (isRemoval) {\n    if (Array.isArray(refs[key])) {\n      remove$1(refs[key], ref);\n    } else if (refs[key] === ref) {\n      refs[key] = undefined;\n    }\n  } else {\n    if (vnode.data.refInFor) {\n      if (Array.isArray(refs[key]) && refs[key].indexOf(ref) < 0) {\n        refs[key].push(ref);\n      } else {\n        refs[key] = [ref];\n      }\n    } else {\n      refs[key] = ref;\n    }\n  }\n}\n\n/**\n * Virtual DOM patching algorithm based on Snabbdom by\n * Simon Friis Vindum (@paldepind)\n * Licensed under the MIT License\n * https://github.com/paldepind/snabbdom/blob/master/LICENSE\n *\n * modified by Evan You (@yyx990803)\n *\n\n/*\n * Not type-checking this because this file is perf-critical and the cost\n * of making flow understand it is not worth it.\n */\n\nvar emptyNode = new VNode('', {}, []);\n\nvar hooks$1 = ['create', 'activate', 'update', 'remove', 'destroy'];\n\nfunction isUndef (s) {\n  return s == null\n}\n\nfunction isDef (s) {\n  return s != null\n}\n\nfunction sameVnode (vnode1, vnode2) {\n  return (\n    vnode1.key === vnode2.key &&\n    vnode1.tag === vnode2.tag &&\n    vnode1.isComment === vnode2.isComment &&\n    !vnode1.data === !vnode2.data\n  )\n}\n\nfunction createKeyToOldIdx (children, beginIdx, endIdx) {\n  var i, key;\n  var map = {};\n  for (i = beginIdx; i <= endIdx; ++i) {\n    key = children[i].key;\n    if (isDef(key)) { map[key] = i; }\n  }\n  return map\n}\n\nfunction createPatchFunction (backend) {\n  var i, j;\n  var cbs = {};\n\n  var modules = backend.modules;\n  var nodeOps = backend.nodeOps;\n\n  for (i = 0; i < hooks$1.length; ++i) {\n    cbs[hooks$1[i]] = [];\n    for (j = 0; j < modules.length; ++j) {\n      if (modules[j][hooks$1[i]] !== undefined) { cbs[hooks$1[i]].push(modules[j][hooks$1[i]]); }\n    }\n  }\n\n  function emptyNodeAt (elm) {\n    return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)\n  }\n\n  function createRmCb (childElm, listeners) {\n    function remove$$1 () {\n      if (--remove$$1.listeners === 0) {\n        removeNode(childElm);\n      }\n    }\n    remove$$1.listeners = listeners;\n    return remove$$1\n  }\n\n  function removeNode (el) {\n    var parent = nodeOps.parentNode(el);\n    // element may have already been removed due to v-html / v-text\n    if (parent) {\n      nodeOps.removeChild(parent, el);\n    }\n  }\n\n  var inPre = 0;\n  function createElm (vnode, insertedVnodeQueue, parentElm, refElm, nested) {\n    vnode.isRootInsert = !nested; // for transition enter check\n    if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {\n      return\n    }\n\n    var data = vnode.data;\n    var children = vnode.children;\n    var tag = vnode.tag;\n    if (isDef(tag)) {\n      if (process.env.NODE_ENV !== 'production') {\n        if (data && data.pre) {\n          inPre++;\n        }\n        if (\n          !inPre &&\n          !vnode.ns &&\n          !(config.ignoredElements.length && config.ignoredElements.indexOf(tag) > -1) &&\n          config.isUnknownElement(tag)\n        ) {\n          warn(\n            'Unknown custom element: <' + tag + '> - did you ' +\n            'register the component correctly? For recursive components, ' +\n            'make sure to provide the \"name\" option.',\n            vnode.context\n          );\n        }\n      }\n      vnode.elm = vnode.ns\n        ? nodeOps.createElementNS(vnode.ns, tag)\n        : nodeOps.createElement(tag, vnode);\n      setScope(vnode);\n\n      /* istanbul ignore if */\n      {\n        createChildren(vnode, children, insertedVnodeQueue);\n        if (isDef(data)) {\n          invokeCreateHooks(vnode, insertedVnodeQueue);\n        }\n        insert(parentElm, vnode.elm, refElm);\n      }\n\n      if (process.env.NODE_ENV !== 'production' && data && data.pre) {\n        inPre--;\n      }\n    } else if (vnode.isComment) {\n      vnode.elm = nodeOps.createComment(vnode.text);\n      insert(parentElm, vnode.elm, refElm);\n    } else {\n      vnode.elm = nodeOps.createTextNode(vnode.text);\n      insert(parentElm, vnode.elm, refElm);\n    }\n  }\n\n  function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {\n    var i = vnode.data;\n    if (isDef(i)) {\n      var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;\n      if (isDef(i = i.hook) && isDef(i = i.init)) {\n        i(vnode, false /* hydrating */, parentElm, refElm);\n      }\n      // after calling the init hook, if the vnode is a child component\n      // it should've created a child instance and mounted it. the child\n      // component also has set the placeholder vnode's elm.\n      // in that case we can just return the element and be done.\n      if (isDef(vnode.componentInstance)) {\n        initComponent(vnode, insertedVnodeQueue);\n        if (isReactivated) {\n          reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);\n        }\n        return true\n      }\n    }\n  }\n\n  function initComponent (vnode, insertedVnodeQueue) {\n    if (vnode.data.pendingInsert) {\n      insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);\n    }\n    vnode.elm = vnode.componentInstance.$el;\n    if (isPatchable(vnode)) {\n      invokeCreateHooks(vnode, insertedVnodeQueue);\n      setScope(vnode);\n    } else {\n      // empty component root.\n      // skip all element-related modules except for ref (#3455)\n      registerRef(vnode);\n      // make sure to invoke the insert hook\n      insertedVnodeQueue.push(vnode);\n    }\n  }\n\n  function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {\n    var i;\n    // hack for #4339: a reactivated component with inner transition\n    // does not trigger because the inner node's created hooks are not called\n    // again. It's not ideal to involve module-specific logic in here but\n    // there doesn't seem to be a better way to do it.\n    var innerNode = vnode;\n    while (innerNode.componentInstance) {\n      innerNode = innerNode.componentInstance._vnode;\n      if (isDef(i = innerNode.data) && isDef(i = i.transition)) {\n        for (i = 0; i < cbs.activate.length; ++i) {\n          cbs.activate[i](emptyNode, innerNode);\n        }\n        insertedVnodeQueue.push(innerNode);\n        break\n      }\n    }\n    // unlike a newly created component,\n    // a reactivated keep-alive component doesn't insert itself\n    insert(parentElm, vnode.elm, refElm);\n  }\n\n  function insert (parent, elm, ref) {\n    if (parent) {\n      if (ref) {\n        nodeOps.insertBefore(parent, elm, ref);\n      } else {\n        nodeOps.appendChild(parent, elm);\n      }\n    }\n  }\n\n  function createChildren (vnode, children, insertedVnodeQueue) {\n    if (Array.isArray(children)) {\n      for (var i = 0; i < children.length; ++i) {\n        createElm(children[i], insertedVnodeQueue, vnode.elm, null, true);\n      }\n    } else if (isPrimitive(vnode.text)) {\n      nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(vnode.text));\n    }\n  }\n\n  function isPatchable (vnode) {\n    while (vnode.componentInstance) {\n      vnode = vnode.componentInstance._vnode;\n    }\n    return isDef(vnode.tag)\n  }\n\n  function invokeCreateHooks (vnode, insertedVnodeQueue) {\n    for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {\n      cbs.create[i$1](emptyNode, vnode);\n    }\n    i = vnode.data.hook; // Reuse variable\n    if (isDef(i)) {\n      if (i.create) { i.create(emptyNode, vnode); }\n      if (i.insert) { insertedVnodeQueue.push(vnode); }\n    }\n  }\n\n  // set scope id attribute for scoped CSS.\n  // this is implemented as a special case to avoid the overhead\n  // of going through the normal attribute patching process.\n  function setScope (vnode) {\n    var i;\n    if (isDef(i = vnode.context) && isDef(i = i.$options._scopeId)) {\n      nodeOps.setAttribute(vnode.elm, i, '');\n    }\n    if (isDef(i = activeInstance) &&\n        i !== vnode.context &&\n        isDef(i = i.$options._scopeId)) {\n      nodeOps.setAttribute(vnode.elm, i, '');\n    }\n  }\n\n  function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm);\n    }\n  }\n\n  function invokeDestroyHook (vnode) {\n    var i, j;\n    var data = vnode.data;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }\n      for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); }\n    }\n    if (isDef(i = vnode.children)) {\n      for (j = 0; j < vnode.children.length; ++j) {\n        invokeDestroyHook(vnode.children[j]);\n      }\n    }\n  }\n\n  function removeVnodes (parentElm, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      var ch = vnodes[startIdx];\n      if (isDef(ch)) {\n        if (isDef(ch.tag)) {\n          removeAndInvokeRemoveHook(ch);\n          invokeDestroyHook(ch);\n        } else { // Text node\n          removeNode(ch.elm);\n        }\n      }\n    }\n  }\n\n  function removeAndInvokeRemoveHook (vnode, rm) {\n    if (rm || isDef(vnode.data)) {\n      var listeners = cbs.remove.length + 1;\n      if (!rm) {\n        // directly removing\n        rm = createRmCb(vnode.elm, listeners);\n      } else {\n        // we have a recursively passed down rm callback\n        // increase the listeners count\n        rm.listeners += listeners;\n      }\n      // recursively invoke hooks on child component root node\n      if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {\n        removeAndInvokeRemoveHook(i, rm);\n      }\n      for (i = 0; i < cbs.remove.length; ++i) {\n        cbs.remove[i](vnode, rm);\n      }\n      if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {\n        i(vnode, rm);\n      } else {\n        rm();\n      }\n    } else {\n      removeNode(vnode.elm);\n    }\n  }\n\n  function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {\n    var oldStartIdx = 0;\n    var newStartIdx = 0;\n    var oldEndIdx = oldCh.length - 1;\n    var oldStartVnode = oldCh[0];\n    var oldEndVnode = oldCh[oldEndIdx];\n    var newEndIdx = newCh.length - 1;\n    var newStartVnode = newCh[0];\n    var newEndVnode = newCh[newEndIdx];\n    var oldKeyToIdx, idxInOld, elmToMove, refElm;\n\n    // removeOnly is a special flag used only by <transition-group>\n    // to ensure removed elements stay in correct relative positions\n    // during leaving transitions\n    var canMove = !removeOnly;\n\n    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n      if (isUndef(oldStartVnode)) {\n        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n      } else if (isUndef(oldEndVnode)) {\n        oldEndVnode = oldCh[--oldEndIdx];\n      } else if (sameVnode(oldStartVnode, newStartVnode)) {\n        patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);\n        canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));\n        oldStartVnode = oldCh[++oldStartIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);\n        canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else {\n        if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }\n        idxInOld = isDef(newStartVnode.key) ? oldKeyToIdx[newStartVnode.key] : null;\n        if (isUndef(idxInOld)) { // New element\n          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        } else {\n          elmToMove = oldCh[idxInOld];\n          /* istanbul ignore if */\n          if (process.env.NODE_ENV !== 'production' && !elmToMove) {\n            warn(\n              'It seems there are duplicate keys that is causing an update error. ' +\n              'Make sure each v-for item has a unique key.'\n            );\n          }\n          if (sameVnode(elmToMove, newStartVnode)) {\n            patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);\n            oldCh[idxInOld] = undefined;\n            canMove && nodeOps.insertBefore(parentElm, newStartVnode.elm, oldStartVnode.elm);\n            newStartVnode = newCh[++newStartIdx];\n          } else {\n            // same key but different element. treat as new element\n            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);\n            newStartVnode = newCh[++newStartIdx];\n          }\n        }\n      }\n    }\n    if (oldStartIdx > oldEndIdx) {\n      refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;\n      addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);\n    } else if (newStartIdx > newEndIdx) {\n      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n    }\n  }\n\n  function patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly) {\n    if (oldVnode === vnode) {\n      return\n    }\n    // reuse element for static trees.\n    // note we only do this if the vnode is cloned -\n    // if the new node is not cloned it means the render functions have been\n    // reset by the hot-reload-api and we need to do a proper re-render.\n    if (vnode.isStatic &&\n        oldVnode.isStatic &&\n        vnode.key === oldVnode.key &&\n        (vnode.isCloned || vnode.isOnce)) {\n      vnode.elm = oldVnode.elm;\n      vnode.componentInstance = oldVnode.componentInstance;\n      return\n    }\n    var i;\n    var data = vnode.data;\n    var hasData = isDef(data);\n    if (hasData && isDef(i = data.hook) && isDef(i = i.prepatch)) {\n      i(oldVnode, vnode);\n    }\n    var elm = vnode.elm = oldVnode.elm;\n    var oldCh = oldVnode.children;\n    var ch = vnode.children;\n    if (hasData && isPatchable(vnode)) {\n      for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); }\n      if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }\n    }\n    if (isUndef(vnode.text)) {\n      if (isDef(oldCh) && isDef(ch)) {\n        if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }\n      } else if (isDef(ch)) {\n        if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }\n        addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);\n      } else if (isDef(oldCh)) {\n        removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n      } else if (isDef(oldVnode.text)) {\n        nodeOps.setTextContent(elm, '');\n      }\n    } else if (oldVnode.text !== vnode.text) {\n      nodeOps.setTextContent(elm, vnode.text);\n    }\n    if (hasData) {\n      if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); }\n    }\n  }\n\n  function invokeInsertHook (vnode, queue, initial) {\n    // delay insert hooks for component root nodes, invoke them after the\n    // element is really inserted\n    if (initial && vnode.parent) {\n      vnode.parent.data.pendingInsert = queue;\n    } else {\n      for (var i = 0; i < queue.length; ++i) {\n        queue[i].data.hook.insert(queue[i]);\n      }\n    }\n  }\n\n  var bailed = false;\n  // list of modules that can skip create hook during hydration because they\n  // are already rendered on the client or has no need for initialization\n  var isRenderedModule = makeMap('attrs,style,class,staticClass,staticStyle,key');\n\n  // Note: this is a browser-only function so we can assume elms are DOM nodes.\n  function hydrate (elm, vnode, insertedVnodeQueue) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (!assertNodeMatch(elm, vnode)) {\n        return false\n      }\n    }\n    vnode.elm = elm;\n    var tag = vnode.tag;\n    var data = vnode.data;\n    var children = vnode.children;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }\n      if (isDef(i = vnode.componentInstance)) {\n        // child component. it should have hydrated its own tree.\n        initComponent(vnode, insertedVnodeQueue);\n        return true\n      }\n    }\n    if (isDef(tag)) {\n      if (isDef(children)) {\n        // empty element, allow client to pick up and populate children\n        if (!elm.hasChildNodes()) {\n          createChildren(vnode, children, insertedVnodeQueue);\n        } else {\n          var childrenMatch = true;\n          var childNode = elm.firstChild;\n          for (var i$1 = 0; i$1 < children.length; i$1++) {\n            if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue)) {\n              childrenMatch = false;\n              break\n            }\n            childNode = childNode.nextSibling;\n          }\n          // if childNode is not null, it means the actual childNodes list is\n          // longer than the virtual children list.\n          if (!childrenMatch || childNode) {\n            if (process.env.NODE_ENV !== 'production' &&\n                typeof console !== 'undefined' &&\n                !bailed) {\n              bailed = true;\n              console.warn('Parent: ', elm);\n              console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);\n            }\n            return false\n          }\n        }\n      }\n      if (isDef(data)) {\n        for (var key in data) {\n          if (!isRenderedModule(key)) {\n            invokeCreateHooks(vnode, insertedVnodeQueue);\n            break\n          }\n        }\n      }\n    } else if (elm.data !== vnode.text) {\n      elm.data = vnode.text;\n    }\n    return true\n  }\n\n  function assertNodeMatch (node, vnode) {\n    if (vnode.tag) {\n      return (\n        vnode.tag.indexOf('vue-component') === 0 ||\n        vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())\n      )\n    } else {\n      return node.nodeType === (vnode.isComment ? 8 : 3)\n    }\n  }\n\n  return function patch (oldVnode, vnode, hydrating, removeOnly, parentElm, refElm) {\n    if (!vnode) {\n      if (oldVnode) { invokeDestroyHook(oldVnode); }\n      return\n    }\n\n    var isInitialPatch = false;\n    var insertedVnodeQueue = [];\n\n    if (!oldVnode) {\n      // empty mount (likely as component), create new root element\n      isInitialPatch = true;\n      createElm(vnode, insertedVnodeQueue, parentElm, refElm);\n    } else {\n      var isRealElement = isDef(oldVnode.nodeType);\n      if (!isRealElement && sameVnode(oldVnode, vnode)) {\n        // patch existing root node\n        patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly);\n      } else {\n        if (isRealElement) {\n          // mounting to a real element\n          // check if this is server-rendered content and if we can perform\n          // a successful hydration.\n          if (oldVnode.nodeType === 1 && oldVnode.hasAttribute('server-rendered')) {\n            oldVnode.removeAttribute('server-rendered');\n            hydrating = true;\n          }\n          if (hydrating) {\n            if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {\n              invokeInsertHook(vnode, insertedVnodeQueue, true);\n              return oldVnode\n            } else if (process.env.NODE_ENV !== 'production') {\n              warn(\n                'The client-side rendered virtual DOM tree is not matching ' +\n                'server-rendered content. This is likely caused by incorrect ' +\n                'HTML markup, for example nesting block-level elements inside ' +\n                '<p>, or missing <tbody>. Bailing hydration and performing ' +\n                'full client-side render.'\n              );\n            }\n          }\n          // either not server-rendered, or hydration failed.\n          // create an empty node and replace it\n          oldVnode = emptyNodeAt(oldVnode);\n        }\n        // replacing existing element\n        var oldElm = oldVnode.elm;\n        var parentElm$1 = nodeOps.parentNode(oldElm);\n        createElm(\n          vnode,\n          insertedVnodeQueue,\n          // extremely rare edge case: do not insert if old element is in a\n          // leaving transition. Only happens when combining transition +\n          // keep-alive + HOCs. (#4590)\n          oldElm._leaveCb ? null : parentElm$1,\n          nodeOps.nextSibling(oldElm)\n        );\n\n        if (vnode.parent) {\n          // component root element replaced.\n          // update parent placeholder node element, recursively\n          var ancestor = vnode.parent;\n          while (ancestor) {\n            ancestor.elm = vnode.elm;\n            ancestor = ancestor.parent;\n          }\n          if (isPatchable(vnode)) {\n            for (var i = 0; i < cbs.create.length; ++i) {\n              cbs.create[i](emptyNode, vnode.parent);\n            }\n          }\n        }\n\n        if (parentElm$1 !== null) {\n          removeVnodes(parentElm$1, [oldVnode], 0, 0);\n        } else if (isDef(oldVnode.tag)) {\n          invokeDestroyHook(oldVnode);\n        }\n      }\n    }\n\n    invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);\n    return vnode.elm\n  }\n}\n\n/*  */\n\nvar directives = {\n  create: updateDirectives,\n  update: updateDirectives,\n  destroy: function unbindDirectives (vnode) {\n    updateDirectives(vnode, emptyNode);\n  }\n};\n\nfunction updateDirectives (oldVnode, vnode) {\n  if (oldVnode.data.directives || vnode.data.directives) {\n    _update(oldVnode, vnode);\n  }\n}\n\nfunction _update (oldVnode, vnode) {\n  var isCreate = oldVnode === emptyNode;\n  var isDestroy = vnode === emptyNode;\n  var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);\n  var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);\n\n  var dirsWithInsert = [];\n  var dirsWithPostpatch = [];\n\n  var key, oldDir, dir;\n  for (key in newDirs) {\n    oldDir = oldDirs[key];\n    dir = newDirs[key];\n    if (!oldDir) {\n      // new directive, bind\n      callHook$1(dir, 'bind', vnode, oldVnode);\n      if (dir.def && dir.def.inserted) {\n        dirsWithInsert.push(dir);\n      }\n    } else {\n      // existing directive, update\n      dir.oldValue = oldDir.value;\n      callHook$1(dir, 'update', vnode, oldVnode);\n      if (dir.def && dir.def.componentUpdated) {\n        dirsWithPostpatch.push(dir);\n      }\n    }\n  }\n\n  if (dirsWithInsert.length) {\n    var callInsert = function () {\n      for (var i = 0; i < dirsWithInsert.length; i++) {\n        callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);\n      }\n    };\n    if (isCreate) {\n      mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', callInsert, 'dir-insert');\n    } else {\n      callInsert();\n    }\n  }\n\n  if (dirsWithPostpatch.length) {\n    mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'postpatch', function () {\n      for (var i = 0; i < dirsWithPostpatch.length; i++) {\n        callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);\n      }\n    }, 'dir-postpatch');\n  }\n\n  if (!isCreate) {\n    for (key in oldDirs) {\n      if (!newDirs[key]) {\n        // no longer present, unbind\n        callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);\n      }\n    }\n  }\n}\n\nvar emptyModifiers = Object.create(null);\n\nfunction normalizeDirectives$1 (\n  dirs,\n  vm\n) {\n  var res = Object.create(null);\n  if (!dirs) {\n    return res\n  }\n  var i, dir;\n  for (i = 0; i < dirs.length; i++) {\n    dir = dirs[i];\n    if (!dir.modifiers) {\n      dir.modifiers = emptyModifiers;\n    }\n    res[getRawDirName(dir)] = dir;\n    dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);\n  }\n  return res\n}\n\nfunction getRawDirName (dir) {\n  return dir.rawName || ((dir.name) + \".\" + (Object.keys(dir.modifiers || {}).join('.')))\n}\n\nfunction callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {\n  var fn = dir.def && dir.def[hook];\n  if (fn) {\n    fn(vnode.elm, dir, vnode, oldVnode, isDestroy);\n  }\n}\n\nvar baseModules = [\n  ref,\n  directives\n];\n\n/*  */\n\nfunction updateAttrs (oldVnode, vnode) {\n  if (!oldVnode.data.attrs && !vnode.data.attrs) {\n    return\n  }\n  var key, cur, old;\n  var elm = vnode.elm;\n  var oldAttrs = oldVnode.data.attrs || {};\n  var attrs = vnode.data.attrs || {};\n  // clone observed objects, as the user probably wants to mutate it\n  if (attrs.__ob__) {\n    attrs = vnode.data.attrs = extend({}, attrs);\n  }\n\n  for (key in attrs) {\n    cur = attrs[key];\n    old = oldAttrs[key];\n    if (old !== cur) {\n      setAttr(elm, key, cur);\n    }\n  }\n  // #4391: in IE9, setting type can reset value for input[type=radio]\n  /* istanbul ignore if */\n  if (isIE9 && attrs.value !== oldAttrs.value) {\n    setAttr(elm, 'value', attrs.value);\n  }\n  for (key in oldAttrs) {\n    if (attrs[key] == null) {\n      if (isXlink(key)) {\n        elm.removeAttributeNS(xlinkNS, getXlinkProp(key));\n      } else if (!isEnumeratedAttr(key)) {\n        elm.removeAttribute(key);\n      }\n    }\n  }\n}\n\nfunction setAttr (el, key, value) {\n  if (isBooleanAttr(key)) {\n    // set attribute for blank value\n    // e.g. <option disabled>Select one</option>\n    if (isFalsyAttrValue(value)) {\n      el.removeAttribute(key);\n    } else {\n      el.setAttribute(key, key);\n    }\n  } else if (isEnumeratedAttr(key)) {\n    el.setAttribute(key, isFalsyAttrValue(value) || value === 'false' ? 'false' : 'true');\n  } else if (isXlink(key)) {\n    if (isFalsyAttrValue(value)) {\n      el.removeAttributeNS(xlinkNS, getXlinkProp(key));\n    } else {\n      el.setAttributeNS(xlinkNS, key, value);\n    }\n  } else {\n    if (isFalsyAttrValue(value)) {\n      el.removeAttribute(key);\n    } else {\n      el.setAttribute(key, value);\n    }\n  }\n}\n\nvar attrs = {\n  create: updateAttrs,\n  update: updateAttrs\n};\n\n/*  */\n\nfunction updateClass (oldVnode, vnode) {\n  var el = vnode.elm;\n  var data = vnode.data;\n  var oldData = oldVnode.data;\n  if (!data.staticClass && !data.class &&\n      (!oldData || (!oldData.staticClass && !oldData.class))) {\n    return\n  }\n\n  var cls = genClassForVnode(vnode);\n\n  // handle transition classes\n  var transitionClass = el._transitionClasses;\n  if (transitionClass) {\n    cls = concat(cls, stringifyClass(transitionClass));\n  }\n\n  // set the class\n  if (cls !== el._prevClass) {\n    el.setAttribute('class', cls);\n    el._prevClass = cls;\n  }\n}\n\nvar klass = {\n  create: updateClass,\n  update: updateClass\n};\n\n/*  */\n\nvar target$1;\n\nfunction add$2 (\n  event,\n  handler,\n  once,\n  capture\n) {\n  if (once) {\n    var oldHandler = handler;\n    var _target = target$1; // save current target element in closure\n    handler = function (ev) {\n      remove$3(event, handler, capture, _target);\n      arguments.length === 1\n        ? oldHandler(ev)\n        : oldHandler.apply(null, arguments);\n    };\n  }\n  target$1.addEventListener(event, handler, capture);\n}\n\nfunction remove$3 (\n  event,\n  handler,\n  capture,\n  _target\n) {\n  (_target || target$1).removeEventListener(event, handler, capture);\n}\n\nfunction updateDOMListeners (oldVnode, vnode) {\n  if (!oldVnode.data.on && !vnode.data.on) {\n    return\n  }\n  var on = vnode.data.on || {};\n  var oldOn = oldVnode.data.on || {};\n  target$1 = vnode.elm;\n  updateListeners(on, oldOn, add$2, remove$3, vnode.context);\n}\n\nvar events = {\n  create: updateDOMListeners,\n  update: updateDOMListeners\n};\n\n/*  */\n\nfunction updateDOMProps (oldVnode, vnode) {\n  if (!oldVnode.data.domProps && !vnode.data.domProps) {\n    return\n  }\n  var key, cur;\n  var elm = vnode.elm;\n  var oldProps = oldVnode.data.domProps || {};\n  var props = vnode.data.domProps || {};\n  // clone observed objects, as the user probably wants to mutate it\n  if (props.__ob__) {\n    props = vnode.data.domProps = extend({}, props);\n  }\n\n  for (key in oldProps) {\n    if (props[key] == null) {\n      elm[key] = '';\n    }\n  }\n  for (key in props) {\n    cur = props[key];\n    // ignore children if the node has textContent or innerHTML,\n    // as these will throw away existing DOM nodes and cause removal errors\n    // on subsequent patches (#3360)\n    if (key === 'textContent' || key === 'innerHTML') {\n      if (vnode.children) { vnode.children.length = 0; }\n      if (cur === oldProps[key]) { continue }\n    }\n\n    if (key === 'value') {\n      // store value as _value as well since\n      // non-string values will be stringified\n      elm._value = cur;\n      // avoid resetting cursor position when value is the same\n      var strCur = cur == null ? '' : String(cur);\n      if (shouldUpdateValue(elm, vnode, strCur)) {\n        elm.value = strCur;\n      }\n    } else {\n      elm[key] = cur;\n    }\n  }\n}\n\n// check platforms/web/util/attrs.js acceptValue\n\n\nfunction shouldUpdateValue (\n  elm,\n  vnode,\n  checkVal\n) {\n  return (!elm.composing && (\n    vnode.tag === 'option' ||\n    isDirty(elm, checkVal) ||\n    isInputChanged(vnode, checkVal)\n  ))\n}\n\nfunction isDirty (elm, checkVal) {\n  // return true when textbox (.number and .trim) loses focus and its value is not equal to the updated value\n  return document.activeElement !== elm && elm.value !== checkVal\n}\n\nfunction isInputChanged (vnode, newVal) {\n  var value = vnode.elm.value;\n  var modifiers = vnode.elm._vModifiers; // injected by v-model runtime\n  if ((modifiers && modifiers.number) || vnode.elm.type === 'number') {\n    return toNumber(value) !== toNumber(newVal)\n  }\n  if (modifiers && modifiers.trim) {\n    return value.trim() !== newVal.trim()\n  }\n  return value !== newVal\n}\n\nvar domProps = {\n  create: updateDOMProps,\n  update: updateDOMProps\n};\n\n/*  */\n\nvar parseStyleText = cached(function (cssText) {\n  var res = {};\n  var listDelimiter = /;(?![^(]*\\))/g;\n  var propertyDelimiter = /:(.+)/;\n  cssText.split(listDelimiter).forEach(function (item) {\n    if (item) {\n      var tmp = item.split(propertyDelimiter);\n      tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());\n    }\n  });\n  return res\n});\n\n// merge static and dynamic style data on the same vnode\nfunction normalizeStyleData (data) {\n  var style = normalizeStyleBinding(data.style);\n  // static style is pre-processed into an object during compilation\n  // and is always a fresh object, so it's safe to merge into it\n  return data.staticStyle\n    ? extend(data.staticStyle, style)\n    : style\n}\n\n// normalize possible array / string values into Object\nfunction normalizeStyleBinding (bindingStyle) {\n  if (Array.isArray(bindingStyle)) {\n    return toObject(bindingStyle)\n  }\n  if (typeof bindingStyle === 'string') {\n    return parseStyleText(bindingStyle)\n  }\n  return bindingStyle\n}\n\n/**\n * parent component style should be after child's\n * so that parent component's style could override it\n */\nfunction getStyle (vnode, checkChild) {\n  var res = {};\n  var styleData;\n\n  if (checkChild) {\n    var childNode = vnode;\n    while (childNode.componentInstance) {\n      childNode = childNode.componentInstance._vnode;\n      if (childNode.data && (styleData = normalizeStyleData(childNode.data))) {\n        extend(res, styleData);\n      }\n    }\n  }\n\n  if ((styleData = normalizeStyleData(vnode.data))) {\n    extend(res, styleData);\n  }\n\n  var parentNode = vnode;\n  while ((parentNode = parentNode.parent)) {\n    if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {\n      extend(res, styleData);\n    }\n  }\n  return res\n}\n\n/*  */\n\nvar cssVarRE = /^--/;\nvar importantRE = /\\s*!important$/;\nvar setProp = function (el, name, val) {\n  /* istanbul ignore if */\n  if (cssVarRE.test(name)) {\n    el.style.setProperty(name, val);\n  } else if (importantRE.test(val)) {\n    el.style.setProperty(name, val.replace(importantRE, ''), 'important');\n  } else {\n    el.style[normalize(name)] = val;\n  }\n};\n\nvar prefixes = ['Webkit', 'Moz', 'ms'];\n\nvar testEl;\nvar normalize = cached(function (prop) {\n  testEl = testEl || document.createElement('div');\n  prop = camelize(prop);\n  if (prop !== 'filter' && (prop in testEl.style)) {\n    return prop\n  }\n  var upper = prop.charAt(0).toUpperCase() + prop.slice(1);\n  for (var i = 0; i < prefixes.length; i++) {\n    var prefixed = prefixes[i] + upper;\n    if (prefixed in testEl.style) {\n      return prefixed\n    }\n  }\n});\n\nfunction updateStyle (oldVnode, vnode) {\n  var data = vnode.data;\n  var oldData = oldVnode.data;\n\n  if (!data.staticStyle && !data.style &&\n      !oldData.staticStyle && !oldData.style) {\n    return\n  }\n\n  var cur, name;\n  var el = vnode.elm;\n  var oldStaticStyle = oldVnode.data.staticStyle;\n  var oldStyleBinding = oldVnode.data.style || {};\n\n  // if static style exists, stylebinding already merged into it when doing normalizeStyleData\n  var oldStyle = oldStaticStyle || oldStyleBinding;\n\n  var style = normalizeStyleBinding(vnode.data.style) || {};\n\n  vnode.data.style = style.__ob__ ? extend({}, style) : style;\n\n  var newStyle = getStyle(vnode, true);\n\n  for (name in oldStyle) {\n    if (newStyle[name] == null) {\n      setProp(el, name, '');\n    }\n  }\n  for (name in newStyle) {\n    cur = newStyle[name];\n    if (cur !== oldStyle[name]) {\n      // ie9 setting to null has no effect, must use empty string\n      setProp(el, name, cur == null ? '' : cur);\n    }\n  }\n}\n\nvar style = {\n  create: updateStyle,\n  update: updateStyle\n};\n\n/*  */\n\n/**\n * Add class with compatibility for SVG since classList is not supported on\n * SVG elements in IE\n */\nfunction addClass (el, cls) {\n  /* istanbul ignore if */\n  if (!cls || !cls.trim()) {\n    return\n  }\n\n  /* istanbul ignore else */\n  if (el.classList) {\n    if (cls.indexOf(' ') > -1) {\n      cls.split(/\\s+/).forEach(function (c) { return el.classList.add(c); });\n    } else {\n      el.classList.add(cls);\n    }\n  } else {\n    var cur = ' ' + el.getAttribute('class') + ' ';\n    if (cur.indexOf(' ' + cls + ' ') < 0) {\n      el.setAttribute('class', (cur + cls).trim());\n    }\n  }\n}\n\n/**\n * Remove class with compatibility for SVG since classList is not supported on\n * SVG elements in IE\n */\nfunction removeClass (el, cls) {\n  /* istanbul ignore if */\n  if (!cls || !cls.trim()) {\n    return\n  }\n\n  /* istanbul ignore else */\n  if (el.classList) {\n    if (cls.indexOf(' ') > -1) {\n      cls.split(/\\s+/).forEach(function (c) { return el.classList.remove(c); });\n    } else {\n      el.classList.remove(cls);\n    }\n  } else {\n    var cur = ' ' + el.getAttribute('class') + ' ';\n    var tar = ' ' + cls + ' ';\n    while (cur.indexOf(tar) >= 0) {\n      cur = cur.replace(tar, ' ');\n    }\n    el.setAttribute('class', cur.trim());\n  }\n}\n\n/*  */\n\nvar hasTransition = inBrowser && !isIE9;\nvar TRANSITION = 'transition';\nvar ANIMATION = 'animation';\n\n// Transition property/event sniffing\nvar transitionProp = 'transition';\nvar transitionEndEvent = 'transitionend';\nvar animationProp = 'animation';\nvar animationEndEvent = 'animationend';\nif (hasTransition) {\n  /* istanbul ignore if */\n  if (window.ontransitionend === undefined &&\n    window.onwebkittransitionend !== undefined) {\n    transitionProp = 'WebkitTransition';\n    transitionEndEvent = 'webkitTransitionEnd';\n  }\n  if (window.onanimationend === undefined &&\n    window.onwebkitanimationend !== undefined) {\n    animationProp = 'WebkitAnimation';\n    animationEndEvent = 'webkitAnimationEnd';\n  }\n}\n\n// binding to window is necessary to make hot reload work in IE in strict mode\nvar raf = inBrowser && window.requestAnimationFrame\n  ? window.requestAnimationFrame.bind(window)\n  : setTimeout;\n\nfunction nextFrame (fn) {\n  raf(function () {\n    raf(fn);\n  });\n}\n\nfunction addTransitionClass (el, cls) {\n  (el._transitionClasses || (el._transitionClasses = [])).push(cls);\n  addClass(el, cls);\n}\n\nfunction removeTransitionClass (el, cls) {\n  if (el._transitionClasses) {\n    remove$1(el._transitionClasses, cls);\n  }\n  removeClass(el, cls);\n}\n\nfunction whenTransitionEnds (\n  el,\n  expectedType,\n  cb\n) {\n  var ref = getTransitionInfo(el, expectedType);\n  var type = ref.type;\n  var timeout = ref.timeout;\n  var propCount = ref.propCount;\n  if (!type) { return cb() }\n  var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;\n  var ended = 0;\n  var end = function () {\n    el.removeEventListener(event, onEnd);\n    cb();\n  };\n  var onEnd = function (e) {\n    if (e.target === el) {\n      if (++ended >= propCount) {\n        end();\n      }\n    }\n  };\n  setTimeout(function () {\n    if (ended < propCount) {\n      end();\n    }\n  }, timeout + 1);\n  el.addEventListener(event, onEnd);\n}\n\nvar transformRE = /\\b(transform|all)(,|$)/;\n\nfunction getTransitionInfo (el, expectedType) {\n  var styles = window.getComputedStyle(el);\n  var transitioneDelays = styles[transitionProp + 'Delay'].split(', ');\n  var transitionDurations = styles[transitionProp + 'Duration'].split(', ');\n  var transitionTimeout = getTimeout(transitioneDelays, transitionDurations);\n  var animationDelays = styles[animationProp + 'Delay'].split(', ');\n  var animationDurations = styles[animationProp + 'Duration'].split(', ');\n  var animationTimeout = getTimeout(animationDelays, animationDurations);\n\n  var type;\n  var timeout = 0;\n  var propCount = 0;\n  /* istanbul ignore if */\n  if (expectedType === TRANSITION) {\n    if (transitionTimeout > 0) {\n      type = TRANSITION;\n      timeout = transitionTimeout;\n      propCount = transitionDurations.length;\n    }\n  } else if (expectedType === ANIMATION) {\n    if (animationTimeout > 0) {\n      type = ANIMATION;\n      timeout = animationTimeout;\n      propCount = animationDurations.length;\n    }\n  } else {\n    timeout = Math.max(transitionTimeout, animationTimeout);\n    type = timeout > 0\n      ? transitionTimeout > animationTimeout\n        ? TRANSITION\n        : ANIMATION\n      : null;\n    propCount = type\n      ? type === TRANSITION\n        ? transitionDurations.length\n        : animationDurations.length\n      : 0;\n  }\n  var hasTransform =\n    type === TRANSITION &&\n    transformRE.test(styles[transitionProp + 'Property']);\n  return {\n    type: type,\n    timeout: timeout,\n    propCount: propCount,\n    hasTransform: hasTransform\n  }\n}\n\nfunction getTimeout (delays, durations) {\n  /* istanbul ignore next */\n  while (delays.length < durations.length) {\n    delays = delays.concat(delays);\n  }\n\n  return Math.max.apply(null, durations.map(function (d, i) {\n    return toMs(d) + toMs(delays[i])\n  }))\n}\n\nfunction toMs (s) {\n  return Number(s.slice(0, -1)) * 1000\n}\n\n/*  */\n\nfunction enter (vnode, toggleDisplay) {\n  var el = vnode.elm;\n\n  // call leave callback now\n  if (el._leaveCb) {\n    el._leaveCb.cancelled = true;\n    el._leaveCb();\n  }\n\n  var data = resolveTransition(vnode.data.transition);\n  if (!data) {\n    return\n  }\n\n  /* istanbul ignore if */\n  if (el._enterCb || el.nodeType !== 1) {\n    return\n  }\n\n  var css = data.css;\n  var type = data.type;\n  var enterClass = data.enterClass;\n  var enterToClass = data.enterToClass;\n  var enterActiveClass = data.enterActiveClass;\n  var appearClass = data.appearClass;\n  var appearToClass = data.appearToClass;\n  var appearActiveClass = data.appearActiveClass;\n  var beforeEnter = data.beforeEnter;\n  var enter = data.enter;\n  var afterEnter = data.afterEnter;\n  var enterCancelled = data.enterCancelled;\n  var beforeAppear = data.beforeAppear;\n  var appear = data.appear;\n  var afterAppear = data.afterAppear;\n  var appearCancelled = data.appearCancelled;\n\n  // activeInstance will always be the <transition> component managing this\n  // transition. One edge case to check is when the <transition> is placed\n  // as the root node of a child component. In that case we need to check\n  // <transition>'s parent for appear check.\n  var context = activeInstance;\n  var transitionNode = activeInstance.$vnode;\n  while (transitionNode && transitionNode.parent) {\n    transitionNode = transitionNode.parent;\n    context = transitionNode.context;\n  }\n\n  var isAppear = !context._isMounted || !vnode.isRootInsert;\n\n  if (isAppear && !appear && appear !== '') {\n    return\n  }\n\n  var startClass = isAppear ? appearClass : enterClass;\n  var activeClass = isAppear ? appearActiveClass : enterActiveClass;\n  var toClass = isAppear ? appearToClass : enterToClass;\n  var beforeEnterHook = isAppear ? (beforeAppear || beforeEnter) : beforeEnter;\n  var enterHook = isAppear ? (typeof appear === 'function' ? appear : enter) : enter;\n  var afterEnterHook = isAppear ? (afterAppear || afterEnter) : afterEnter;\n  var enterCancelledHook = isAppear ? (appearCancelled || enterCancelled) : enterCancelled;\n\n  var expectsCSS = css !== false && !isIE9;\n  var userWantsControl =\n    enterHook &&\n    // enterHook may be a bound method which exposes\n    // the length of original fn as _length\n    (enterHook._length || enterHook.length) > 1;\n\n  var cb = el._enterCb = once(function () {\n    if (expectsCSS) {\n      removeTransitionClass(el, toClass);\n      removeTransitionClass(el, activeClass);\n    }\n    if (cb.cancelled) {\n      if (expectsCSS) {\n        removeTransitionClass(el, startClass);\n      }\n      enterCancelledHook && enterCancelledHook(el);\n    } else {\n      afterEnterHook && afterEnterHook(el);\n    }\n    el._enterCb = null;\n  });\n\n  if (!vnode.data.show) {\n    // remove pending leave element on enter by injecting an insert hook\n    mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', function () {\n      var parent = el.parentNode;\n      var pendingNode = parent && parent._pending && parent._pending[vnode.key];\n      if (pendingNode &&\n          pendingNode.tag === vnode.tag &&\n          pendingNode.elm._leaveCb) {\n        pendingNode.elm._leaveCb();\n      }\n      enterHook && enterHook(el, cb);\n    }, 'transition-insert');\n  }\n\n  // start enter transition\n  beforeEnterHook && beforeEnterHook(el);\n  if (expectsCSS) {\n    addTransitionClass(el, startClass);\n    addTransitionClass(el, activeClass);\n    nextFrame(function () {\n      addTransitionClass(el, toClass);\n      removeTransitionClass(el, startClass);\n      if (!cb.cancelled && !userWantsControl) {\n        whenTransitionEnds(el, type, cb);\n      }\n    });\n  }\n\n  if (vnode.data.show) {\n    toggleDisplay && toggleDisplay();\n    enterHook && enterHook(el, cb);\n  }\n\n  if (!expectsCSS && !userWantsControl) {\n    cb();\n  }\n}\n\nfunction leave (vnode, rm) {\n  var el = vnode.elm;\n\n  // call enter callback now\n  if (el._enterCb) {\n    el._enterCb.cancelled = true;\n    el._enterCb();\n  }\n\n  var data = resolveTransition(vnode.data.transition);\n  if (!data) {\n    return rm()\n  }\n\n  /* istanbul ignore if */\n  if (el._leaveCb || el.nodeType !== 1) {\n    return\n  }\n\n  var css = data.css;\n  var type = data.type;\n  var leaveClass = data.leaveClass;\n  var leaveToClass = data.leaveToClass;\n  var leaveActiveClass = data.leaveActiveClass;\n  var beforeLeave = data.beforeLeave;\n  var leave = data.leave;\n  var afterLeave = data.afterLeave;\n  var leaveCancelled = data.leaveCancelled;\n  var delayLeave = data.delayLeave;\n\n  var expectsCSS = css !== false && !isIE9;\n  var userWantsControl =\n    leave &&\n    // leave hook may be a bound method which exposes\n    // the length of original fn as _length\n    (leave._length || leave.length) > 1;\n\n  var cb = el._leaveCb = once(function () {\n    if (el.parentNode && el.parentNode._pending) {\n      el.parentNode._pending[vnode.key] = null;\n    }\n    if (expectsCSS) {\n      removeTransitionClass(el, leaveToClass);\n      removeTransitionClass(el, leaveActiveClass);\n    }\n    if (cb.cancelled) {\n      if (expectsCSS) {\n        removeTransitionClass(el, leaveClass);\n      }\n      leaveCancelled && leaveCancelled(el);\n    } else {\n      rm();\n      afterLeave && afterLeave(el);\n    }\n    el._leaveCb = null;\n  });\n\n  if (delayLeave) {\n    delayLeave(performLeave);\n  } else {\n    performLeave();\n  }\n\n  function performLeave () {\n    // the delayed leave may have already been cancelled\n    if (cb.cancelled) {\n      return\n    }\n    // record leaving element\n    if (!vnode.data.show) {\n      (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;\n    }\n    beforeLeave && beforeLeave(el);\n    if (expectsCSS) {\n      addTransitionClass(el, leaveClass);\n      addTransitionClass(el, leaveActiveClass);\n      nextFrame(function () {\n        addTransitionClass(el, leaveToClass);\n        removeTransitionClass(el, leaveClass);\n        if (!cb.cancelled && !userWantsControl) {\n          whenTransitionEnds(el, type, cb);\n        }\n      });\n    }\n    leave && leave(el, cb);\n    if (!expectsCSS && !userWantsControl) {\n      cb();\n    }\n  }\n}\n\nfunction resolveTransition (def$$1) {\n  if (!def$$1) {\n    return\n  }\n  /* istanbul ignore else */\n  if (typeof def$$1 === 'object') {\n    var res = {};\n    if (def$$1.css !== false) {\n      extend(res, autoCssTransition(def$$1.name || 'v'));\n    }\n    extend(res, def$$1);\n    return res\n  } else if (typeof def$$1 === 'string') {\n    return autoCssTransition(def$$1)\n  }\n}\n\nvar autoCssTransition = cached(function (name) {\n  return {\n    enterClass: (name + \"-enter\"),\n    leaveClass: (name + \"-leave\"),\n    appearClass: (name + \"-enter\"),\n    enterToClass: (name + \"-enter-to\"),\n    leaveToClass: (name + \"-leave-to\"),\n    appearToClass: (name + \"-enter-to\"),\n    enterActiveClass: (name + \"-enter-active\"),\n    leaveActiveClass: (name + \"-leave-active\"),\n    appearActiveClass: (name + \"-enter-active\")\n  }\n});\n\nfunction once (fn) {\n  var called = false;\n  return function () {\n    if (!called) {\n      called = true;\n      fn();\n    }\n  }\n}\n\nfunction _enter (_, vnode) {\n  if (!vnode.data.show) {\n    enter(vnode);\n  }\n}\n\nvar transition = inBrowser ? {\n  create: _enter,\n  activate: _enter,\n  remove: function remove (vnode, rm) {\n    /* istanbul ignore else */\n    if (!vnode.data.show) {\n      leave(vnode, rm);\n    } else {\n      rm();\n    }\n  }\n} : {};\n\nvar platformModules = [\n  attrs,\n  klass,\n  events,\n  domProps,\n  style,\n  transition\n];\n\n/*  */\n\n// the directive module should be applied last, after all\n// built-in modules have been applied.\nvar modules = platformModules.concat(baseModules);\n\nvar patch$1 = createPatchFunction({ nodeOps: nodeOps, modules: modules });\n\n/**\n * Not type checking this file because flow doesn't like attaching\n * properties to Elements.\n */\n\nvar modelableTagRE = /^input|select|textarea|vue-component-[0-9]+(-[0-9a-zA-Z_-]*)?$/;\n\n/* istanbul ignore if */\nif (isIE9) {\n  // http://www.matts411.com/post/internet-explorer-9-oninput/\n  document.addEventListener('selectionchange', function () {\n    var el = document.activeElement;\n    if (el && el.vmodel) {\n      trigger(el, 'input');\n    }\n  });\n}\n\nvar model = {\n  inserted: function inserted (el, binding, vnode) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (!modelableTagRE.test(vnode.tag)) {\n        warn(\n          \"v-model is not supported on element type: <\" + (vnode.tag) + \">. \" +\n          'If you are working with contenteditable, it\\'s recommended to ' +\n          'wrap a library dedicated for that purpose inside a custom component.',\n          vnode.context\n        );\n      }\n    }\n    if (vnode.tag === 'select') {\n      var cb = function () {\n        setSelected(el, binding, vnode.context);\n      };\n      cb();\n      /* istanbul ignore if */\n      if (isIE || isEdge) {\n        setTimeout(cb, 0);\n      }\n    } else if (vnode.tag === 'textarea' || el.type === 'text') {\n      el._vModifiers = binding.modifiers;\n      if (!binding.modifiers.lazy) {\n        if (!isAndroid) {\n          el.addEventListener('compositionstart', onCompositionStart);\n          el.addEventListener('compositionend', onCompositionEnd);\n        }\n        /* istanbul ignore if */\n        if (isIE9) {\n          el.vmodel = true;\n        }\n      }\n    }\n  },\n  componentUpdated: function componentUpdated (el, binding, vnode) {\n    if (vnode.tag === 'select') {\n      setSelected(el, binding, vnode.context);\n      // in case the options rendered by v-for have changed,\n      // it's possible that the value is out-of-sync with the rendered options.\n      // detect such cases and filter out values that no longer has a matching\n      // option in the DOM.\n      var needReset = el.multiple\n        ? binding.value.some(function (v) { return hasNoMatchingOption(v, el.options); })\n        : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, el.options);\n      if (needReset) {\n        trigger(el, 'change');\n      }\n    }\n  }\n};\n\nfunction setSelected (el, binding, vm) {\n  var value = binding.value;\n  var isMultiple = el.multiple;\n  if (isMultiple && !Array.isArray(value)) {\n    process.env.NODE_ENV !== 'production' && warn(\n      \"<select multiple v-model=\\\"\" + (binding.expression) + \"\\\"> \" +\n      \"expects an Array value for its binding, but got \" + (Object.prototype.toString.call(value).slice(8, -1)),\n      vm\n    );\n    return\n  }\n  var selected, option;\n  for (var i = 0, l = el.options.length; i < l; i++) {\n    option = el.options[i];\n    if (isMultiple) {\n      selected = looseIndexOf(value, getValue(option)) > -1;\n      if (option.selected !== selected) {\n        option.selected = selected;\n      }\n    } else {\n      if (looseEqual(getValue(option), value)) {\n        if (el.selectedIndex !== i) {\n          el.selectedIndex = i;\n        }\n        return\n      }\n    }\n  }\n  if (!isMultiple) {\n    el.selectedIndex = -1;\n  }\n}\n\nfunction hasNoMatchingOption (value, options) {\n  for (var i = 0, l = options.length; i < l; i++) {\n    if (looseEqual(getValue(options[i]), value)) {\n      return false\n    }\n  }\n  return true\n}\n\nfunction getValue (option) {\n  return '_value' in option\n    ? option._value\n    : option.value\n}\n\nfunction onCompositionStart (e) {\n  e.target.composing = true;\n}\n\nfunction onCompositionEnd (e) {\n  e.target.composing = false;\n  trigger(e.target, 'input');\n}\n\nfunction trigger (el, type) {\n  var e = document.createEvent('HTMLEvents');\n  e.initEvent(type, true, true);\n  el.dispatchEvent(e);\n}\n\n/*  */\n\n// recursively search for possible transition defined inside the component root\nfunction locateNode (vnode) {\n  return vnode.componentInstance && (!vnode.data || !vnode.data.transition)\n    ? locateNode(vnode.componentInstance._vnode)\n    : vnode\n}\n\nvar show = {\n  bind: function bind (el, ref, vnode) {\n    var value = ref.value;\n\n    vnode = locateNode(vnode);\n    var transition = vnode.data && vnode.data.transition;\n    var originalDisplay = el.__vOriginalDisplay =\n      el.style.display === 'none' ? '' : el.style.display;\n    if (value && transition && !isIE9) {\n      vnode.data.show = true;\n      enter(vnode, function () {\n        el.style.display = originalDisplay;\n      });\n    } else {\n      el.style.display = value ? originalDisplay : 'none';\n    }\n  },\n\n  update: function update (el, ref, vnode) {\n    var value = ref.value;\n    var oldValue = ref.oldValue;\n\n    /* istanbul ignore if */\n    if (value === oldValue) { return }\n    vnode = locateNode(vnode);\n    var transition = vnode.data && vnode.data.transition;\n    if (transition && !isIE9) {\n      vnode.data.show = true;\n      if (value) {\n        enter(vnode, function () {\n          el.style.display = el.__vOriginalDisplay;\n        });\n      } else {\n        leave(vnode, function () {\n          el.style.display = 'none';\n        });\n      }\n    } else {\n      el.style.display = value ? el.__vOriginalDisplay : 'none';\n    }\n  },\n\n  unbind: function unbind (\n    el,\n    binding,\n    vnode,\n    oldVnode,\n    isDestroy\n  ) {\n    if (!isDestroy) {\n      el.style.display = el.__vOriginalDisplay;\n    }\n  }\n};\n\nvar platformDirectives = {\n  model: model,\n  show: show\n};\n\n/*  */\n\n// Provides transition support for a single element/component.\n// supports transition mode (out-in / in-out)\n\nvar transitionProps = {\n  name: String,\n  appear: Boolean,\n  css: Boolean,\n  mode: String,\n  type: String,\n  enterClass: String,\n  leaveClass: String,\n  enterToClass: String,\n  leaveToClass: String,\n  enterActiveClass: String,\n  leaveActiveClass: String,\n  appearClass: String,\n  appearActiveClass: String,\n  appearToClass: String\n};\n\n// in case the child is also an abstract component, e.g. <keep-alive>\n// we want to recursively retrieve the real component to be rendered\nfunction getRealChild (vnode) {\n  var compOptions = vnode && vnode.componentOptions;\n  if (compOptions && compOptions.Ctor.options.abstract) {\n    return getRealChild(getFirstComponentChild(compOptions.children))\n  } else {\n    return vnode\n  }\n}\n\nfunction extractTransitionData (comp) {\n  var data = {};\n  var options = comp.$options;\n  // props\n  for (var key in options.propsData) {\n    data[key] = comp[key];\n  }\n  // events.\n  // extract listeners and pass them directly to the transition methods\n  var listeners = options._parentListeners;\n  for (var key$1 in listeners) {\n    data[camelize(key$1)] = listeners[key$1].fn;\n  }\n  return data\n}\n\nfunction placeholder (h, rawChild) {\n  return /\\d-keep-alive$/.test(rawChild.tag)\n    ? h('keep-alive')\n    : null\n}\n\nfunction hasParentTransition (vnode) {\n  while ((vnode = vnode.parent)) {\n    if (vnode.data.transition) {\n      return true\n    }\n  }\n}\n\nfunction isSameChild (child, oldChild) {\n  return oldChild.key === child.key && oldChild.tag === child.tag\n}\n\nvar Transition = {\n  name: 'transition',\n  props: transitionProps,\n  abstract: true,\n\n  render: function render (h) {\n    var this$1 = this;\n\n    var children = this.$slots.default;\n    if (!children) {\n      return\n    }\n\n    // filter out text nodes (possible whitespaces)\n    children = children.filter(function (c) { return c.tag; });\n    /* istanbul ignore if */\n    if (!children.length) {\n      return\n    }\n\n    // warn multiple elements\n    if (process.env.NODE_ENV !== 'production' && children.length > 1) {\n      warn(\n        '<transition> can only be used on a single element. Use ' +\n        '<transition-group> for lists.',\n        this.$parent\n      );\n    }\n\n    var mode = this.mode;\n\n    // warn invalid mode\n    if (process.env.NODE_ENV !== 'production' &&\n        mode && mode !== 'in-out' && mode !== 'out-in') {\n      warn(\n        'invalid <transition> mode: ' + mode,\n        this.$parent\n      );\n    }\n\n    var rawChild = children[0];\n\n    // if this is a component root node and the component's\n    // parent container node also has transition, skip.\n    if (hasParentTransition(this.$vnode)) {\n      return rawChild\n    }\n\n    // apply transition data to child\n    // use getRealChild() to ignore abstract components e.g. keep-alive\n    var child = getRealChild(rawChild);\n    /* istanbul ignore if */\n    if (!child) {\n      return rawChild\n    }\n\n    if (this._leaving) {\n      return placeholder(h, rawChild)\n    }\n\n    // ensure a key that is unique to the vnode type and to this transition\n    // component instance. This key will be used to remove pending leaving nodes\n    // during entering.\n    var id = \"__transition-\" + (this._uid) + \"-\";\n    var key = child.key = child.key == null\n      ? id + child.tag\n      : isPrimitive(child.key)\n        ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)\n        : child.key;\n    var data = (child.data || (child.data = {})).transition = extractTransitionData(this);\n    var oldRawChild = this._vnode;\n    var oldChild = getRealChild(oldRawChild);\n\n    // mark v-show\n    // so that the transition module can hand over the control to the directive\n    if (child.data.directives && child.data.directives.some(function (d) { return d.name === 'show'; })) {\n      child.data.show = true;\n    }\n\n    if (oldChild && oldChild.data && !isSameChild(child, oldChild)) {\n      // replace old child transition data with fresh one\n      // important for dynamic transitions!\n      var oldData = oldChild && (oldChild.data.transition = extend({}, data));\n      // handle transition mode\n      if (mode === 'out-in') {\n        // return placeholder node and queue update when leave finishes\n        this._leaving = true;\n        mergeVNodeHook(oldData, 'afterLeave', function () {\n          this$1._leaving = false;\n          this$1.$forceUpdate();\n        }, key);\n        return placeholder(h, rawChild)\n      } else if (mode === 'in-out') {\n        var delayedLeave;\n        var performLeave = function () { delayedLeave(); };\n        mergeVNodeHook(data, 'afterEnter', performLeave, key);\n        mergeVNodeHook(data, 'enterCancelled', performLeave, key);\n        mergeVNodeHook(oldData, 'delayLeave', function (leave) {\n          delayedLeave = leave;\n        }, key);\n      }\n    }\n\n    return rawChild\n  }\n};\n\n/*  */\n\n// Provides transition support for list items.\n// supports move transitions using the FLIP technique.\n\n// Because the vdom's children update algorithm is \"unstable\" - i.e.\n// it doesn't guarantee the relative positioning of removed elements,\n// we force transition-group to update its children into two passes:\n// in the first pass, we remove all nodes that need to be removed,\n// triggering their leaving transition; in the second pass, we insert/move\n// into the final disired state. This way in the second pass removed\n// nodes will remain where they should be.\n\nvar props = extend({\n  tag: String,\n  moveClass: String\n}, transitionProps);\n\ndelete props.mode;\n\nvar TransitionGroup = {\n  props: props,\n\n  render: function render (h) {\n    var tag = this.tag || this.$vnode.data.tag || 'span';\n    var map = Object.create(null);\n    var prevChildren = this.prevChildren = this.children;\n    var rawChildren = this.$slots.default || [];\n    var children = this.children = [];\n    var transitionData = extractTransitionData(this);\n\n    for (var i = 0; i < rawChildren.length; i++) {\n      var c = rawChildren[i];\n      if (c.tag) {\n        if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {\n          children.push(c);\n          map[c.key] = c\n          ;(c.data || (c.data = {})).transition = transitionData;\n        } else if (process.env.NODE_ENV !== 'production') {\n          var opts = c.componentOptions;\n          var name = opts\n            ? (opts.Ctor.options.name || opts.tag)\n            : c.tag;\n          warn((\"<transition-group> children must be keyed: <\" + name + \">\"));\n        }\n      }\n    }\n\n    if (prevChildren) {\n      var kept = [];\n      var removed = [];\n      for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {\n        var c$1 = prevChildren[i$1];\n        c$1.data.transition = transitionData;\n        c$1.data.pos = c$1.elm.getBoundingClientRect();\n        if (map[c$1.key]) {\n          kept.push(c$1);\n        } else {\n          removed.push(c$1);\n        }\n      }\n      this.kept = h(tag, null, kept);\n      this.removed = removed;\n    }\n\n    return h(tag, null, children)\n  },\n\n  beforeUpdate: function beforeUpdate () {\n    // force removing pass\n    this.__patch__(\n      this._vnode,\n      this.kept,\n      false, // hydrating\n      true // removeOnly (!important, avoids unnecessary moves)\n    );\n    this._vnode = this.kept;\n  },\n\n  updated: function updated () {\n    var children = this.prevChildren;\n    var moveClass = this.moveClass || ((this.name || 'v') + '-move');\n    if (!children.length || !this.hasMove(children[0].elm, moveClass)) {\n      return\n    }\n\n    // we divide the work into three loops to avoid mixing DOM reads and writes\n    // in each iteration - which helps prevent layout thrashing.\n    children.forEach(callPendingCbs);\n    children.forEach(recordPosition);\n    children.forEach(applyTranslation);\n\n    // force reflow to put everything in position\n    var f = document.body.offsetHeight; // eslint-disable-line\n\n    children.forEach(function (c) {\n      if (c.data.moved) {\n        var el = c.elm;\n        var s = el.style;\n        addTransitionClass(el, moveClass);\n        s.transform = s.WebkitTransform = s.transitionDuration = '';\n        el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {\n          if (!e || /transform$/.test(e.propertyName)) {\n            el.removeEventListener(transitionEndEvent, cb);\n            el._moveCb = null;\n            removeTransitionClass(el, moveClass);\n          }\n        });\n      }\n    });\n  },\n\n  methods: {\n    hasMove: function hasMove (el, moveClass) {\n      /* istanbul ignore if */\n      if (!hasTransition) {\n        return false\n      }\n      if (this._hasMove != null) {\n        return this._hasMove\n      }\n      addTransitionClass(el, moveClass);\n      var info = getTransitionInfo(el);\n      removeTransitionClass(el, moveClass);\n      return (this._hasMove = info.hasTransform)\n    }\n  }\n};\n\nfunction callPendingCbs (c) {\n  /* istanbul ignore if */\n  if (c.elm._moveCb) {\n    c.elm._moveCb();\n  }\n  /* istanbul ignore if */\n  if (c.elm._enterCb) {\n    c.elm._enterCb();\n  }\n}\n\nfunction recordPosition (c) {\n  c.data.newPos = c.elm.getBoundingClientRect();\n}\n\nfunction applyTranslation (c) {\n  var oldPos = c.data.pos;\n  var newPos = c.data.newPos;\n  var dx = oldPos.left - newPos.left;\n  var dy = oldPos.top - newPos.top;\n  if (dx || dy) {\n    c.data.moved = true;\n    var s = c.elm.style;\n    s.transform = s.WebkitTransform = \"translate(\" + dx + \"px,\" + dy + \"px)\";\n    s.transitionDuration = '0s';\n  }\n}\n\nvar platformComponents = {\n  Transition: Transition,\n  TransitionGroup: TransitionGroup\n};\n\n/*  */\n\n// install platform specific utils\nVue$3.config.isUnknownElement = isUnknownElement;\nVue$3.config.isReservedTag = isReservedTag;\nVue$3.config.getTagNamespace = getTagNamespace;\nVue$3.config.mustUseProp = mustUseProp;\n\n// install platform runtime directives & components\nextend(Vue$3.options.directives, platformDirectives);\nextend(Vue$3.options.components, platformComponents);\n\n// install platform patch function\nVue$3.prototype.__patch__ = inBrowser ? patch$1 : noop;\n\n// wrap mount\nVue$3.prototype.$mount = function (\n  el,\n  hydrating\n) {\n  el = el && inBrowser ? query(el) : undefined;\n  return this._mount(el, hydrating)\n};\n\nif (process.env.NODE_ENV !== 'production' &&\n    inBrowser && typeof console !== 'undefined') {\n  console[console.info ? 'info' : 'log'](\n    \"You are running Vue in development mode.\\n\" +\n    \"Make sure to turn on production mode when deploying for production.\\n\" +\n    \"See more tips at https://vuejs.org/guide/deployment.html\"\n  );\n}\n\n// devtools global hook\n/* istanbul ignore next */\nsetTimeout(function () {\n  if (config.devtools) {\n    if (devtools) {\n      devtools.emit('init', Vue$3);\n    } else if (\n      process.env.NODE_ENV !== 'production' &&\n      inBrowser && !isEdge && /Chrome\\/\\d+/.test(window.navigator.userAgent)\n    ) {\n      console[console.info ? 'info' : 'log'](\n        'Download the Vue Devtools extension for a better development experience:\\n' +\n        'https://github.com/vuejs/vue-devtools'\n      );\n    }\n  }\n}, 0);\n\n/*  */\n\n// check whether current browser encodes a char inside attribute values\nfunction shouldDecode (content, encoded) {\n  var div = document.createElement('div');\n  div.innerHTML = \"<div a=\\\"\" + content + \"\\\">\";\n  return div.innerHTML.indexOf(encoded) > 0\n}\n\n// #3663\n// IE encodes newlines inside attribute values while other browsers don't\nvar shouldDecodeNewlines = inBrowser ? shouldDecode('\\n', '&#10;') : false;\n\n/*  */\n\nvar decoder;\n\nfunction decode (html) {\n  decoder = decoder || document.createElement('div');\n  decoder.innerHTML = html;\n  return decoder.textContent\n}\n\n/*  */\n\nvar isUnaryTag = makeMap(\n  'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +\n  'link,meta,param,source,track,wbr',\n  true\n);\n\n// Elements that you can, intentionally, leave open\n// (and which close themselves)\nvar canBeLeftOpenTag = makeMap(\n  'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source',\n  true\n);\n\n// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3\n// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content\nvar isNonPhrasingTag = makeMap(\n  'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +\n  'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +\n  'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +\n  'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +\n  'title,tr,track',\n  true\n);\n\n/**\n * Not type-checking this file because it's mostly vendor code.\n */\n\n/*!\n * HTML Parser By John Resig (ejohn.org)\n * Modified by Juriy \"kangax\" Zaytsev\n * Original code by Erik Arvidsson, Mozilla Public License\n * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js\n */\n\n// Regular Expressions for parsing tags and attributes\nvar singleAttrIdentifier = /([^\\s\"'<>/=]+)/;\nvar singleAttrAssign = /(?:=)/;\nvar singleAttrValues = [\n  // attr value double quotes\n  /\"([^\"]*)\"+/.source,\n  // attr value, single quotes\n  /'([^']*)'+/.source,\n  // attr value, no quotes\n  /([^\\s\"'=<>`]+)/.source\n];\nvar attribute = new RegExp(\n  '^\\\\s*' + singleAttrIdentifier.source +\n  '(?:\\\\s*(' + singleAttrAssign.source + ')' +\n  '\\\\s*(?:' + singleAttrValues.join('|') + '))?'\n);\n\n// could use https://www.w3.org/TR/1999/REC-xml-names-19990114/#NT-QName\n// but for Vue templates we can enforce a simple charset\nvar ncname = '[a-zA-Z_][\\\\w\\\\-\\\\.]*';\nvar qnameCapture = '((?:' + ncname + '\\\\:)?' + ncname + ')';\nvar startTagOpen = new RegExp('^<' + qnameCapture);\nvar startTagClose = /^\\s*(\\/?)>/;\nvar endTag = new RegExp('^<\\\\/' + qnameCapture + '[^>]*>');\nvar doctype = /^<!DOCTYPE [^>]+>/i;\nvar comment = /^<!--/;\nvar conditionalComment = /^<!\\[/;\n\nvar IS_REGEX_CAPTURING_BROKEN = false;\n'x'.replace(/x(.)?/g, function (m, g) {\n  IS_REGEX_CAPTURING_BROKEN = g === '';\n});\n\n// Special Elements (can contain anything)\nvar isScriptOrStyle = makeMap('script,style', true);\nvar reCache = {};\n\nvar ltRE = /&lt;/g;\nvar gtRE = /&gt;/g;\nvar nlRE = /&#10;/g;\nvar ampRE = /&amp;/g;\nvar quoteRE = /&quot;/g;\n\nfunction decodeAttr (value, shouldDecodeNewlines) {\n  if (shouldDecodeNewlines) {\n    value = value.replace(nlRE, '\\n');\n  }\n  return value\n    .replace(ltRE, '<')\n    .replace(gtRE, '>')\n    .replace(ampRE, '&')\n    .replace(quoteRE, '\"')\n}\n\nfunction parseHTML (html, options) {\n  var stack = [];\n  var expectHTML = options.expectHTML;\n  var isUnaryTag$$1 = options.isUnaryTag || no;\n  var index = 0;\n  var last, lastTag;\n  while (html) {\n    last = html;\n    // Make sure we're not in a script or style element\n    if (!lastTag || !isScriptOrStyle(lastTag)) {\n      var textEnd = html.indexOf('<');\n      if (textEnd === 0) {\n        // Comment:\n        if (comment.test(html)) {\n          var commentEnd = html.indexOf('-->');\n\n          if (commentEnd >= 0) {\n            advance(commentEnd + 3);\n            continue\n          }\n        }\n\n        // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment\n        if (conditionalComment.test(html)) {\n          var conditionalEnd = html.indexOf(']>');\n\n          if (conditionalEnd >= 0) {\n            advance(conditionalEnd + 2);\n            continue\n          }\n        }\n\n        // Doctype:\n        var doctypeMatch = html.match(doctype);\n        if (doctypeMatch) {\n          advance(doctypeMatch[0].length);\n          continue\n        }\n\n        // End tag:\n        var endTagMatch = html.match(endTag);\n        if (endTagMatch) {\n          var curIndex = index;\n          advance(endTagMatch[0].length);\n          parseEndTag(endTagMatch[1], curIndex, index);\n          continue\n        }\n\n        // Start tag:\n        var startTagMatch = parseStartTag();\n        if (startTagMatch) {\n          handleStartTag(startTagMatch);\n          continue\n        }\n      }\n\n      var text = (void 0), rest$1 = (void 0), next = (void 0);\n      if (textEnd > 0) {\n        rest$1 = html.slice(textEnd);\n        while (\n          !endTag.test(rest$1) &&\n          !startTagOpen.test(rest$1) &&\n          !comment.test(rest$1) &&\n          !conditionalComment.test(rest$1)\n        ) {\n          // < in plain text, be forgiving and treat it as text\n          next = rest$1.indexOf('<', 1);\n          if (next < 0) { break }\n          textEnd += next;\n          rest$1 = html.slice(textEnd);\n        }\n        text = html.substring(0, textEnd);\n        advance(textEnd);\n      }\n\n      if (textEnd < 0) {\n        text = html;\n        html = '';\n      }\n\n      if (options.chars && text) {\n        options.chars(text);\n      }\n    } else {\n      var stackedTag = lastTag.toLowerCase();\n      var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\\\s\\\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));\n      var endTagLength = 0;\n      var rest = html.replace(reStackedTag, function (all, text, endTag) {\n        endTagLength = endTag.length;\n        if (stackedTag !== 'script' && stackedTag !== 'style' && stackedTag !== 'noscript') {\n          text = text\n            .replace(/<!--([\\s\\S]*?)-->/g, '$1')\n            .replace(/<!\\[CDATA\\[([\\s\\S]*?)]]>/g, '$1');\n        }\n        if (options.chars) {\n          options.chars(text);\n        }\n        return ''\n      });\n      index += html.length - rest.length;\n      html = rest;\n      parseEndTag(stackedTag, index - endTagLength, index);\n    }\n\n    if (html === last && options.chars) {\n      options.chars(html);\n      break\n    }\n  }\n\n  // Clean up any remaining tags\n  parseEndTag();\n\n  function advance (n) {\n    index += n;\n    html = html.substring(n);\n  }\n\n  function parseStartTag () {\n    var start = html.match(startTagOpen);\n    if (start) {\n      var match = {\n        tagName: start[1],\n        attrs: [],\n        start: index\n      };\n      advance(start[0].length);\n      var end, attr;\n      while (!(end = html.match(startTagClose)) && (attr = html.match(attribute))) {\n        advance(attr[0].length);\n        match.attrs.push(attr);\n      }\n      if (end) {\n        match.unarySlash = end[1];\n        advance(end[0].length);\n        match.end = index;\n        return match\n      }\n    }\n  }\n\n  function handleStartTag (match) {\n    var tagName = match.tagName;\n    var unarySlash = match.unarySlash;\n\n    if (expectHTML) {\n      if (lastTag === 'p' && isNonPhrasingTag(tagName)) {\n        parseEndTag(lastTag);\n      }\n      if (canBeLeftOpenTag(tagName) && lastTag === tagName) {\n        parseEndTag(tagName);\n      }\n    }\n\n    var unary = isUnaryTag$$1(tagName) || tagName === 'html' && lastTag === 'head' || !!unarySlash;\n\n    var l = match.attrs.length;\n    var attrs = new Array(l);\n    for (var i = 0; i < l; i++) {\n      var args = match.attrs[i];\n      // hackish work around FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778\n      if (IS_REGEX_CAPTURING_BROKEN && args[0].indexOf('\"\"') === -1) {\n        if (args[3] === '') { delete args[3]; }\n        if (args[4] === '') { delete args[4]; }\n        if (args[5] === '') { delete args[5]; }\n      }\n      var value = args[3] || args[4] || args[5] || '';\n      attrs[i] = {\n        name: args[1],\n        value: decodeAttr(\n          value,\n          options.shouldDecodeNewlines\n        )\n      };\n    }\n\n    if (!unary) {\n      stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs });\n      lastTag = tagName;\n      unarySlash = '';\n    }\n\n    if (options.start) {\n      options.start(tagName, attrs, unary, match.start, match.end);\n    }\n  }\n\n  function parseEndTag (tagName, start, end) {\n    var pos, lowerCasedTagName;\n    if (start == null) { start = index; }\n    if (end == null) { end = index; }\n\n    if (tagName) {\n      lowerCasedTagName = tagName.toLowerCase();\n    }\n\n    // Find the closest opened tag of the same type\n    if (tagName) {\n      for (pos = stack.length - 1; pos >= 0; pos--) {\n        if (stack[pos].lowerCasedTag === lowerCasedTagName) {\n          break\n        }\n      }\n    } else {\n      // If no tag name is provided, clean shop\n      pos = 0;\n    }\n\n    if (pos >= 0) {\n      // Close all the open elements, up the stack\n      for (var i = stack.length - 1; i >= pos; i--) {\n        if (options.end) {\n          options.end(stack[i].tag, start, end);\n        }\n      }\n\n      // Remove the open elements from the stack\n      stack.length = pos;\n      lastTag = pos && stack[pos - 1].tag;\n    } else if (lowerCasedTagName === 'br') {\n      if (options.start) {\n        options.start(tagName, [], true, start, end);\n      }\n    } else if (lowerCasedTagName === 'p') {\n      if (options.start) {\n        options.start(tagName, [], false, start, end);\n      }\n      if (options.end) {\n        options.end(tagName, start, end);\n      }\n    }\n  }\n}\n\n/*  */\n\nfunction parseFilters (exp) {\n  var inSingle = false;\n  var inDouble = false;\n  var inTemplateString = false;\n  var inRegex = false;\n  var curly = 0;\n  var square = 0;\n  var paren = 0;\n  var lastFilterIndex = 0;\n  var c, prev, i, expression, filters;\n\n  for (i = 0; i < exp.length; i++) {\n    prev = c;\n    c = exp.charCodeAt(i);\n    if (inSingle) {\n      if (c === 0x27 && prev !== 0x5C) { inSingle = false; }\n    } else if (inDouble) {\n      if (c === 0x22 && prev !== 0x5C) { inDouble = false; }\n    } else if (inTemplateString) {\n      if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }\n    } else if (inRegex) {\n      if (c === 0x2f && prev !== 0x5C) { inRegex = false; }\n    } else if (\n      c === 0x7C && // pipe\n      exp.charCodeAt(i + 1) !== 0x7C &&\n      exp.charCodeAt(i - 1) !== 0x7C &&\n      !curly && !square && !paren\n    ) {\n      if (expression === undefined) {\n        // first filter, end of expression\n        lastFilterIndex = i + 1;\n        expression = exp.slice(0, i).trim();\n      } else {\n        pushFilter();\n      }\n    } else {\n      switch (c) {\n        case 0x22: inDouble = true; break         // \"\n        case 0x27: inSingle = true; break         // '\n        case 0x60: inTemplateString = true; break // `\n        case 0x28: paren++; break                 // (\n        case 0x29: paren--; break                 // )\n        case 0x5B: square++; break                // [\n        case 0x5D: square--; break                // ]\n        case 0x7B: curly++; break                 // {\n        case 0x7D: curly--; break                 // }\n      }\n      if (c === 0x2f) { // /\n        var j = i - 1;\n        var p = (void 0);\n        // find first non-whitespace prev char\n        for (; j >= 0; j--) {\n          p = exp.charAt(j);\n          if (p !== ' ') { break }\n        }\n        if (!p || !/[\\w$]/.test(p)) {\n          inRegex = true;\n        }\n      }\n    }\n  }\n\n  if (expression === undefined) {\n    expression = exp.slice(0, i).trim();\n  } else if (lastFilterIndex !== 0) {\n    pushFilter();\n  }\n\n  function pushFilter () {\n    (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());\n    lastFilterIndex = i + 1;\n  }\n\n  if (filters) {\n    for (i = 0; i < filters.length; i++) {\n      expression = wrapFilter(expression, filters[i]);\n    }\n  }\n\n  return expression\n}\n\nfunction wrapFilter (exp, filter) {\n  var i = filter.indexOf('(');\n  if (i < 0) {\n    // _f: resolveFilter\n    return (\"_f(\\\"\" + filter + \"\\\")(\" + exp + \")\")\n  } else {\n    var name = filter.slice(0, i);\n    var args = filter.slice(i + 1);\n    return (\"_f(\\\"\" + name + \"\\\")(\" + exp + \",\" + args)\n  }\n}\n\n/*  */\n\nvar defaultTagRE = /\\{\\{((?:.|\\n)+?)\\}\\}/g;\nvar regexEscapeRE = /[-.*+?^${}()|[\\]\\/\\\\]/g;\n\nvar buildRegex = cached(function (delimiters) {\n  var open = delimiters[0].replace(regexEscapeRE, '\\\\$&');\n  var close = delimiters[1].replace(regexEscapeRE, '\\\\$&');\n  return new RegExp(open + '((?:.|\\\\n)+?)' + close, 'g')\n});\n\nfunction parseText (\n  text,\n  delimiters\n) {\n  var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;\n  if (!tagRE.test(text)) {\n    return\n  }\n  var tokens = [];\n  var lastIndex = tagRE.lastIndex = 0;\n  var match, index;\n  while ((match = tagRE.exec(text))) {\n    index = match.index;\n    // push text token\n    if (index > lastIndex) {\n      tokens.push(JSON.stringify(text.slice(lastIndex, index)));\n    }\n    // tag token\n    var exp = parseFilters(match[1].trim());\n    tokens.push((\"_s(\" + exp + \")\"));\n    lastIndex = index + match[0].length;\n  }\n  if (lastIndex < text.length) {\n    tokens.push(JSON.stringify(text.slice(lastIndex)));\n  }\n  return tokens.join('+')\n}\n\n/*  */\n\nfunction baseWarn (msg) {\n  console.error((\"[Vue parser]: \" + msg));\n}\n\nfunction pluckModuleFunction (\n  modules,\n  key\n) {\n  return modules\n    ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })\n    : []\n}\n\nfunction addProp (el, name, value) {\n  (el.props || (el.props = [])).push({ name: name, value: value });\n}\n\nfunction addAttr (el, name, value) {\n  (el.attrs || (el.attrs = [])).push({ name: name, value: value });\n}\n\nfunction addDirective (\n  el,\n  name,\n  rawName,\n  value,\n  arg,\n  modifiers\n) {\n  (el.directives || (el.directives = [])).push({ name: name, rawName: rawName, value: value, arg: arg, modifiers: modifiers });\n}\n\nfunction addHandler (\n  el,\n  name,\n  value,\n  modifiers,\n  important\n) {\n  // check capture modifier\n  if (modifiers && modifiers.capture) {\n    delete modifiers.capture;\n    name = '!' + name; // mark the event as captured\n  }\n  if (modifiers && modifiers.once) {\n    delete modifiers.once;\n    name = '~' + name; // mark the event as once\n  }\n  var events;\n  if (modifiers && modifiers.native) {\n    delete modifiers.native;\n    events = el.nativeEvents || (el.nativeEvents = {});\n  } else {\n    events = el.events || (el.events = {});\n  }\n  var newHandler = { value: value, modifiers: modifiers };\n  var handlers = events[name];\n  /* istanbul ignore if */\n  if (Array.isArray(handlers)) {\n    important ? handlers.unshift(newHandler) : handlers.push(newHandler);\n  } else if (handlers) {\n    events[name] = important ? [newHandler, handlers] : [handlers, newHandler];\n  } else {\n    events[name] = newHandler;\n  }\n}\n\nfunction getBindingAttr (\n  el,\n  name,\n  getStatic\n) {\n  var dynamicValue =\n    getAndRemoveAttr(el, ':' + name) ||\n    getAndRemoveAttr(el, 'v-bind:' + name);\n  if (dynamicValue != null) {\n    return parseFilters(dynamicValue)\n  } else if (getStatic !== false) {\n    var staticValue = getAndRemoveAttr(el, name);\n    if (staticValue != null) {\n      return JSON.stringify(staticValue)\n    }\n  }\n}\n\nfunction getAndRemoveAttr (el, name) {\n  var val;\n  if ((val = el.attrsMap[name]) != null) {\n    var list = el.attrsList;\n    for (var i = 0, l = list.length; i < l; i++) {\n      if (list[i].name === name) {\n        list.splice(i, 1);\n        break\n      }\n    }\n  }\n  return val\n}\n\nvar len;\nvar str;\nvar chr;\nvar index$1;\nvar expressionPos;\nvar expressionEndPos;\n\n/**\n * parse directive model to do the array update transform. a[idx] = val => $$a.splice($$idx, 1, val)\n *\n * for loop possible cases:\n *\n * - test\n * - test[idx]\n * - test[test1[idx]]\n * - test[\"a\"][idx]\n * - xxx.test[a[a].test1[idx]]\n * - test.xxx.a[\"asa\"][test1[idx]]\n *\n */\n\nfunction parseModel (val) {\n  str = val;\n  len = str.length;\n  index$1 = expressionPos = expressionEndPos = 0;\n\n  if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {\n    return {\n      exp: val,\n      idx: null\n    }\n  }\n\n  while (!eof()) {\n    chr = next();\n    /* istanbul ignore if */\n    if (isStringStart(chr)) {\n      parseString(chr);\n    } else if (chr === 0x5B) {\n      parseBracket(chr);\n    }\n  }\n\n  return {\n    exp: val.substring(0, expressionPos),\n    idx: val.substring(expressionPos + 1, expressionEndPos)\n  }\n}\n\nfunction next () {\n  return str.charCodeAt(++index$1)\n}\n\nfunction eof () {\n  return index$1 >= len\n}\n\nfunction isStringStart (chr) {\n  return chr === 0x22 || chr === 0x27\n}\n\nfunction parseBracket (chr) {\n  var inBracket = 1;\n  expressionPos = index$1;\n  while (!eof()) {\n    chr = next();\n    if (isStringStart(chr)) {\n      parseString(chr);\n      continue\n    }\n    if (chr === 0x5B) { inBracket++; }\n    if (chr === 0x5D) { inBracket--; }\n    if (inBracket === 0) {\n      expressionEndPos = index$1;\n      break\n    }\n  }\n}\n\nfunction parseString (chr) {\n  var stringQuote = chr;\n  while (!eof()) {\n    chr = next();\n    if (chr === stringQuote) {\n      break\n    }\n  }\n}\n\n/*  */\n\nvar dirRE = /^v-|^@|^:/;\nvar forAliasRE = /(.*?)\\s+(?:in|of)\\s+(.*)/;\nvar forIteratorRE = /\\((\\{[^}]*\\}|[^,]*),([^,]*)(?:,([^,]*))?\\)/;\nvar bindRE = /^:|^v-bind:/;\nvar onRE = /^@|^v-on:/;\nvar argRE = /:(.*)$/;\nvar modifierRE = /\\.[^.]+/g;\n\nvar decodeHTMLCached = cached(decode);\n\n// configurable state\nvar warn$1;\nvar platformGetTagNamespace;\nvar platformMustUseProp;\nvar platformIsPreTag;\nvar preTransforms;\nvar transforms;\nvar postTransforms;\nvar delimiters;\n\n/**\n * Convert HTML string to AST.\n */\nfunction parse (\n  template,\n  options\n) {\n  warn$1 = options.warn || baseWarn;\n  platformGetTagNamespace = options.getTagNamespace || no;\n  platformMustUseProp = options.mustUseProp || no;\n  platformIsPreTag = options.isPreTag || no;\n  preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');\n  transforms = pluckModuleFunction(options.modules, 'transformNode');\n  postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');\n  delimiters = options.delimiters;\n  var stack = [];\n  var preserveWhitespace = options.preserveWhitespace !== false;\n  var root;\n  var currentParent;\n  var inVPre = false;\n  var inPre = false;\n  var warned = false;\n  parseHTML(template, {\n    expectHTML: options.expectHTML,\n    isUnaryTag: options.isUnaryTag,\n    shouldDecodeNewlines: options.shouldDecodeNewlines,\n    start: function start (tag, attrs, unary) {\n      // check namespace.\n      // inherit parent ns if there is one\n      var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);\n\n      // handle IE svg bug\n      /* istanbul ignore if */\n      if (isIE && ns === 'svg') {\n        attrs = guardIESVGBug(attrs);\n      }\n\n      var element = {\n        type: 1,\n        tag: tag,\n        attrsList: attrs,\n        attrsMap: makeAttrsMap(attrs),\n        parent: currentParent,\n        children: []\n      };\n      if (ns) {\n        element.ns = ns;\n      }\n\n      if (isForbiddenTag(element) && !isServerRendering()) {\n        element.forbidden = true;\n        process.env.NODE_ENV !== 'production' && warn$1(\n          'Templates should only be responsible for mapping the state to the ' +\n          'UI. Avoid placing tags with side-effects in your templates, such as ' +\n          \"<\" + tag + \">\" + ', as they will not be parsed.'\n        );\n      }\n\n      // apply pre-transforms\n      for (var i = 0; i < preTransforms.length; i++) {\n        preTransforms[i](element, options);\n      }\n\n      if (!inVPre) {\n        processPre(element);\n        if (element.pre) {\n          inVPre = true;\n        }\n      }\n      if (platformIsPreTag(element.tag)) {\n        inPre = true;\n      }\n      if (inVPre) {\n        processRawAttrs(element);\n      } else {\n        processFor(element);\n        processIf(element);\n        processOnce(element);\n        processKey(element);\n\n        // determine whether this is a plain element after\n        // removing structural attributes\n        element.plain = !element.key && !attrs.length;\n\n        processRef(element);\n        processSlot(element);\n        processComponent(element);\n        for (var i$1 = 0; i$1 < transforms.length; i$1++) {\n          transforms[i$1](element, options);\n        }\n        processAttrs(element);\n      }\n\n      function checkRootConstraints (el) {\n        if (process.env.NODE_ENV !== 'production' && !warned) {\n          if (el.tag === 'slot' || el.tag === 'template') {\n            warned = true;\n            warn$1(\n              \"Cannot use <\" + (el.tag) + \"> as component root element because it may \" +\n              'contain multiple nodes:\\n' + template\n            );\n          }\n          if (el.attrsMap.hasOwnProperty('v-for')) {\n            warned = true;\n            warn$1(\n              'Cannot use v-for on stateful component root element because ' +\n              'it renders multiple elements:\\n' + template\n            );\n          }\n        }\n      }\n\n      // tree management\n      if (!root) {\n        root = element;\n        checkRootConstraints(root);\n      } else if (!stack.length) {\n        // allow root elements with v-if, v-else-if and v-else\n        if (root.if && (element.elseif || element.else)) {\n          checkRootConstraints(element);\n          addIfCondition(root, {\n            exp: element.elseif,\n            block: element\n          });\n        } else if (process.env.NODE_ENV !== 'production' && !warned) {\n          warned = true;\n          warn$1(\n            \"Component template should contain exactly one root element:\" +\n            \"\\n\\n\" + template + \"\\n\\n\" +\n            \"If you are using v-if on multiple elements, \" +\n            \"use v-else-if to chain them instead.\"\n          );\n        }\n      }\n      if (currentParent && !element.forbidden) {\n        if (element.elseif || element.else) {\n          processIfConditions(element, currentParent);\n        } else if (element.slotScope) { // scoped slot\n          currentParent.plain = false;\n          var name = element.slotTarget || 'default';(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;\n        } else {\n          currentParent.children.push(element);\n          element.parent = currentParent;\n        }\n      }\n      if (!unary) {\n        currentParent = element;\n        stack.push(element);\n      }\n      // apply post-transforms\n      for (var i$2 = 0; i$2 < postTransforms.length; i$2++) {\n        postTransforms[i$2](element, options);\n      }\n    },\n\n    end: function end () {\n      // remove trailing whitespace\n      var element = stack[stack.length - 1];\n      var lastNode = element.children[element.children.length - 1];\n      if (lastNode && lastNode.type === 3 && lastNode.text === ' ') {\n        element.children.pop();\n      }\n      // pop stack\n      stack.length -= 1;\n      currentParent = stack[stack.length - 1];\n      // check pre state\n      if (element.pre) {\n        inVPre = false;\n      }\n      if (platformIsPreTag(element.tag)) {\n        inPre = false;\n      }\n    },\n\n    chars: function chars (text) {\n      if (!currentParent) {\n        if (process.env.NODE_ENV !== 'production' && !warned && text === template) {\n          warned = true;\n          warn$1(\n            'Component template requires a root element, rather than just text:\\n\\n' + template\n          );\n        }\n        return\n      }\n      // IE textarea placeholder bug\n      /* istanbul ignore if */\n      if (isIE &&\n          currentParent.tag === 'textarea' &&\n          currentParent.attrsMap.placeholder === text) {\n        return\n      }\n      var children = currentParent.children;\n      text = inPre || text.trim()\n        ? decodeHTMLCached(text)\n        // only preserve whitespace if its not right after a starting tag\n        : preserveWhitespace && children.length ? ' ' : '';\n      if (text) {\n        var expression;\n        if (!inVPre && text !== ' ' && (expression = parseText(text, delimiters))) {\n          children.push({\n            type: 2,\n            expression: expression,\n            text: text\n          });\n        } else if (text !== ' ' || children[children.length - 1].text !== ' ') {\n          currentParent.children.push({\n            type: 3,\n            text: text\n          });\n        }\n      }\n    }\n  });\n  return root\n}\n\nfunction processPre (el) {\n  if (getAndRemoveAttr(el, 'v-pre') != null) {\n    el.pre = true;\n  }\n}\n\nfunction processRawAttrs (el) {\n  var l = el.attrsList.length;\n  if (l) {\n    var attrs = el.attrs = new Array(l);\n    for (var i = 0; i < l; i++) {\n      attrs[i] = {\n        name: el.attrsList[i].name,\n        value: JSON.stringify(el.attrsList[i].value)\n      };\n    }\n  } else if (!el.pre) {\n    // non root node in pre blocks with no attributes\n    el.plain = true;\n  }\n}\n\nfunction processKey (el) {\n  var exp = getBindingAttr(el, 'key');\n  if (exp) {\n    if (process.env.NODE_ENV !== 'production' && el.tag === 'template') {\n      warn$1(\"<template> cannot be keyed. Place the key on real elements instead.\");\n    }\n    el.key = exp;\n  }\n}\n\nfunction processRef (el) {\n  var ref = getBindingAttr(el, 'ref');\n  if (ref) {\n    el.ref = ref;\n    el.refInFor = checkInFor(el);\n  }\n}\n\nfunction processFor (el) {\n  var exp;\n  if ((exp = getAndRemoveAttr(el, 'v-for'))) {\n    var inMatch = exp.match(forAliasRE);\n    if (!inMatch) {\n      process.env.NODE_ENV !== 'production' && warn$1(\n        (\"Invalid v-for expression: \" + exp)\n      );\n      return\n    }\n    el.for = inMatch[2].trim();\n    var alias = inMatch[1].trim();\n    var iteratorMatch = alias.match(forIteratorRE);\n    if (iteratorMatch) {\n      el.alias = iteratorMatch[1].trim();\n      el.iterator1 = iteratorMatch[2].trim();\n      if (iteratorMatch[3]) {\n        el.iterator2 = iteratorMatch[3].trim();\n      }\n    } else {\n      el.alias = alias;\n    }\n  }\n}\n\nfunction processIf (el) {\n  var exp = getAndRemoveAttr(el, 'v-if');\n  if (exp) {\n    el.if = exp;\n    addIfCondition(el, {\n      exp: exp,\n      block: el\n    });\n  } else {\n    if (getAndRemoveAttr(el, 'v-else') != null) {\n      el.else = true;\n    }\n    var elseif = getAndRemoveAttr(el, 'v-else-if');\n    if (elseif) {\n      el.elseif = elseif;\n    }\n  }\n}\n\nfunction processIfConditions (el, parent) {\n  var prev = findPrevElement(parent.children);\n  if (prev && prev.if) {\n    addIfCondition(prev, {\n      exp: el.elseif,\n      block: el\n    });\n  } else if (process.env.NODE_ENV !== 'production') {\n    warn$1(\n      \"v-\" + (el.elseif ? ('else-if=\"' + el.elseif + '\"') : 'else') + \" \" +\n      \"used on element <\" + (el.tag) + \"> without corresponding v-if.\"\n    );\n  }\n}\n\nfunction findPrevElement (children) {\n  var i = children.length;\n  while (i--) {\n    if (children[i].type === 1) {\n      return children[i]\n    } else {\n      if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {\n        warn$1(\n          \"text \\\"\" + (children[i].text.trim()) + \"\\\" between v-if and v-else(-if) \" +\n          \"will be ignored.\"\n        );\n      }\n      children.pop();\n    }\n  }\n}\n\nfunction addIfCondition (el, condition) {\n  if (!el.ifConditions) {\n    el.ifConditions = [];\n  }\n  el.ifConditions.push(condition);\n}\n\nfunction processOnce (el) {\n  var once = getAndRemoveAttr(el, 'v-once');\n  if (once != null) {\n    el.once = true;\n  }\n}\n\nfunction processSlot (el) {\n  if (el.tag === 'slot') {\n    el.slotName = getBindingAttr(el, 'name');\n    if (process.env.NODE_ENV !== 'production' && el.key) {\n      warn$1(\n        \"`key` does not work on <slot> because slots are abstract outlets \" +\n        \"and can possibly expand into multiple elements. \" +\n        \"Use the key on a wrapping element instead.\"\n      );\n    }\n  } else {\n    var slotTarget = getBindingAttr(el, 'slot');\n    if (slotTarget) {\n      el.slotTarget = slotTarget === '\"\"' ? '\"default\"' : slotTarget;\n    }\n    if (el.tag === 'template') {\n      el.slotScope = getAndRemoveAttr(el, 'scope');\n    }\n  }\n}\n\nfunction processComponent (el) {\n  var binding;\n  if ((binding = getBindingAttr(el, 'is'))) {\n    el.component = binding;\n  }\n  if (getAndRemoveAttr(el, 'inline-template') != null) {\n    el.inlineTemplate = true;\n  }\n}\n\nfunction processAttrs (el) {\n  var list = el.attrsList;\n  var i, l, name, rawName, value, arg, modifiers, isProp;\n  for (i = 0, l = list.length; i < l; i++) {\n    name = rawName = list[i].name;\n    value = list[i].value;\n    if (dirRE.test(name)) {\n      // mark element as dynamic\n      el.hasBindings = true;\n      // modifiers\n      modifiers = parseModifiers(name);\n      if (modifiers) {\n        name = name.replace(modifierRE, '');\n      }\n      if (bindRE.test(name)) { // v-bind\n        name = name.replace(bindRE, '');\n        value = parseFilters(value);\n        isProp = false;\n        if (modifiers) {\n          if (modifiers.prop) {\n            isProp = true;\n            name = camelize(name);\n            if (name === 'innerHtml') { name = 'innerHTML'; }\n          }\n          if (modifiers.camel) {\n            name = camelize(name);\n          }\n        }\n        if (isProp || platformMustUseProp(el.tag, el.attrsMap.type, name)) {\n          addProp(el, name, value);\n        } else {\n          addAttr(el, name, value);\n        }\n      } else if (onRE.test(name)) { // v-on\n        name = name.replace(onRE, '');\n        addHandler(el, name, value, modifiers);\n      } else { // normal directives\n        name = name.replace(dirRE, '');\n        // parse arg\n        var argMatch = name.match(argRE);\n        if (argMatch && (arg = argMatch[1])) {\n          name = name.slice(0, -(arg.length + 1));\n        }\n        addDirective(el, name, rawName, value, arg, modifiers);\n        if (process.env.NODE_ENV !== 'production' && name === 'model') {\n          checkForAliasModel(el, value);\n        }\n      }\n    } else {\n      // literal attribute\n      if (process.env.NODE_ENV !== 'production') {\n        var expression = parseText(value, delimiters);\n        if (expression) {\n          warn$1(\n            name + \"=\\\"\" + value + \"\\\": \" +\n            'Interpolation inside attributes has been removed. ' +\n            'Use v-bind or the colon shorthand instead. For example, ' +\n            'instead of <div id=\"{{ val }}\">, use <div :id=\"val\">.'\n          );\n        }\n      }\n      addAttr(el, name, JSON.stringify(value));\n    }\n  }\n}\n\nfunction checkInFor (el) {\n  var parent = el;\n  while (parent) {\n    if (parent.for !== undefined) {\n      return true\n    }\n    parent = parent.parent;\n  }\n  return false\n}\n\nfunction parseModifiers (name) {\n  var match = name.match(modifierRE);\n  if (match) {\n    var ret = {};\n    match.forEach(function (m) { ret[m.slice(1)] = true; });\n    return ret\n  }\n}\n\nfunction makeAttrsMap (attrs) {\n  var map = {};\n  for (var i = 0, l = attrs.length; i < l; i++) {\n    if (process.env.NODE_ENV !== 'production' && map[attrs[i].name] && !isIE) {\n      warn$1('duplicate attribute: ' + attrs[i].name);\n    }\n    map[attrs[i].name] = attrs[i].value;\n  }\n  return map\n}\n\nfunction isForbiddenTag (el) {\n  return (\n    el.tag === 'style' ||\n    (el.tag === 'script' && (\n      !el.attrsMap.type ||\n      el.attrsMap.type === 'text/javascript'\n    ))\n  )\n}\n\nvar ieNSBug = /^xmlns:NS\\d+/;\nvar ieNSPrefix = /^NS\\d+:/;\n\n/* istanbul ignore next */\nfunction guardIESVGBug (attrs) {\n  var res = [];\n  for (var i = 0; i < attrs.length; i++) {\n    var attr = attrs[i];\n    if (!ieNSBug.test(attr.name)) {\n      attr.name = attr.name.replace(ieNSPrefix, '');\n      res.push(attr);\n    }\n  }\n  return res\n}\n\nfunction checkForAliasModel (el, value) {\n  var _el = el;\n  while (_el) {\n    if (_el.for && _el.alias === value) {\n      warn$1(\n        \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\">: \" +\n        \"You are binding v-model directly to a v-for iteration alias. \" +\n        \"This will not be able to modify the v-for source array because \" +\n        \"writing to the alias is like modifying a function local variable. \" +\n        \"Consider using an array of objects and use v-model on an object property instead.\"\n      );\n    }\n    _el = _el.parent;\n  }\n}\n\n/*  */\n\nvar isStaticKey;\nvar isPlatformReservedTag;\n\nvar genStaticKeysCached = cached(genStaticKeys$1);\n\n/**\n * Goal of the optimizer: walk the generated template AST tree\n * and detect sub-trees that are purely static, i.e. parts of\n * the DOM that never needs to change.\n *\n * Once we detect these sub-trees, we can:\n *\n * 1. Hoist them into constants, so that we no longer need to\n *    create fresh nodes for them on each re-render;\n * 2. Completely skip them in the patching process.\n */\nfunction optimize (root, options) {\n  if (!root) { return }\n  isStaticKey = genStaticKeysCached(options.staticKeys || '');\n  isPlatformReservedTag = options.isReservedTag || no;\n  // first pass: mark all non-static nodes.\n  markStatic(root);\n  // second pass: mark static roots.\n  markStaticRoots(root, false);\n}\n\nfunction genStaticKeys$1 (keys) {\n  return makeMap(\n    'type,tag,attrsList,attrsMap,plain,parent,children,attrs' +\n    (keys ? ',' + keys : '')\n  )\n}\n\nfunction markStatic (node) {\n  node.static = isStatic(node);\n  if (node.type === 1) {\n    // do not make component slot content static. this avoids\n    // 1. components not able to mutate slot nodes\n    // 2. static slot content fails for hot-reloading\n    if (\n      !isPlatformReservedTag(node.tag) &&\n      node.tag !== 'slot' &&\n      node.attrsMap['inline-template'] == null\n    ) {\n      return\n    }\n    for (var i = 0, l = node.children.length; i < l; i++) {\n      var child = node.children[i];\n      markStatic(child);\n      if (!child.static) {\n        node.static = false;\n      }\n    }\n  }\n}\n\nfunction markStaticRoots (node, isInFor) {\n  if (node.type === 1) {\n    if (node.static || node.once) {\n      node.staticInFor = isInFor;\n    }\n    // For a node to qualify as a static root, it should have children that\n    // are not just static text. Otherwise the cost of hoisting out will\n    // outweigh the benefits and it's better off to just always render it fresh.\n    if (node.static && node.children.length && !(\n      node.children.length === 1 &&\n      node.children[0].type === 3\n    )) {\n      node.staticRoot = true;\n      return\n    } else {\n      node.staticRoot = false;\n    }\n    if (node.children) {\n      for (var i = 0, l = node.children.length; i < l; i++) {\n        markStaticRoots(node.children[i], isInFor || !!node.for);\n      }\n    }\n    if (node.ifConditions) {\n      walkThroughConditionsBlocks(node.ifConditions, isInFor);\n    }\n  }\n}\n\nfunction walkThroughConditionsBlocks (conditionBlocks, isInFor) {\n  for (var i = 1, len = conditionBlocks.length; i < len; i++) {\n    markStaticRoots(conditionBlocks[i].block, isInFor);\n  }\n}\n\nfunction isStatic (node) {\n  if (node.type === 2) { // expression\n    return false\n  }\n  if (node.type === 3) { // text\n    return true\n  }\n  return !!(node.pre || (\n    !node.hasBindings && // no dynamic bindings\n    !node.if && !node.for && // not v-if or v-for or v-else\n    !isBuiltInTag(node.tag) && // not a built-in\n    isPlatformReservedTag(node.tag) && // not a component\n    !isDirectChildOfTemplateFor(node) &&\n    Object.keys(node).every(isStaticKey)\n  ))\n}\n\nfunction isDirectChildOfTemplateFor (node) {\n  while (node.parent) {\n    node = node.parent;\n    if (node.tag !== 'template') {\n      return false\n    }\n    if (node.for) {\n      return true\n    }\n  }\n  return false\n}\n\n/*  */\n\nvar fnExpRE = /^\\s*([\\w$_]+|\\([^)]*?\\))\\s*=>|^function\\s*\\(/;\nvar simplePathRE = /^\\s*[A-Za-z_$][\\w$]*(?:\\.[A-Za-z_$][\\w$]*|\\['.*?']|\\[\".*?\"]|\\[\\d+]|\\[[A-Za-z_$][\\w$]*])*\\s*$/;\n\n// keyCode aliases\nvar keyCodes = {\n  esc: 27,\n  tab: 9,\n  enter: 13,\n  space: 32,\n  up: 38,\n  left: 37,\n  right: 39,\n  down: 40,\n  'delete': [8, 46]\n};\n\nvar modifierCode = {\n  stop: '$event.stopPropagation();',\n  prevent: '$event.preventDefault();',\n  self: 'if($event.target !== $event.currentTarget)return;',\n  ctrl: 'if(!$event.ctrlKey)return;',\n  shift: 'if(!$event.shiftKey)return;',\n  alt: 'if(!$event.altKey)return;',\n  meta: 'if(!$event.metaKey)return;'\n};\n\nfunction genHandlers (events, native) {\n  var res = native ? 'nativeOn:{' : 'on:{';\n  for (var name in events) {\n    res += \"\\\"\" + name + \"\\\":\" + (genHandler(name, events[name])) + \",\";\n  }\n  return res.slice(0, -1) + '}'\n}\n\nfunction genHandler (\n  name,\n  handler\n) {\n  if (!handler) {\n    return 'function(){}'\n  } else if (Array.isArray(handler)) {\n    return (\"[\" + (handler.map(function (handler) { return genHandler(name, handler); }).join(',')) + \"]\")\n  } else if (!handler.modifiers) {\n    return fnExpRE.test(handler.value) || simplePathRE.test(handler.value)\n      ? handler.value\n      : (\"function($event){\" + (handler.value) + \"}\")\n  } else {\n    var code = '';\n    var keys = [];\n    for (var key in handler.modifiers) {\n      if (modifierCode[key]) {\n        code += modifierCode[key];\n      } else {\n        keys.push(key);\n      }\n    }\n    if (keys.length) {\n      code = genKeyFilter(keys) + code;\n    }\n    var handlerCode = simplePathRE.test(handler.value)\n      ? handler.value + '($event)'\n      : handler.value;\n    return 'function($event){' + code + handlerCode + '}'\n  }\n}\n\nfunction genKeyFilter (keys) {\n  return (\"if(\" + (keys.map(genFilterCode).join('&&')) + \")return;\")\n}\n\nfunction genFilterCode (key) {\n  var keyVal = parseInt(key, 10);\n  if (keyVal) {\n    return (\"$event.keyCode!==\" + keyVal)\n  }\n  var alias = keyCodes[key];\n  return (\"_k($event.keyCode,\" + (JSON.stringify(key)) + (alias ? ',' + JSON.stringify(alias) : '') + \")\")\n}\n\n/*  */\n\nfunction bind$2 (el, dir) {\n  el.wrapData = function (code) {\n    return (\"_b(\" + code + \",'\" + (el.tag) + \"',\" + (dir.value) + (dir.modifiers && dir.modifiers.prop ? ',true' : '') + \")\")\n  };\n}\n\n/*  */\n\nvar baseDirectives = {\n  bind: bind$2,\n  cloak: noop\n};\n\n/*  */\n\n// configurable state\nvar warn$2;\nvar transforms$1;\nvar dataGenFns;\nvar platformDirectives$1;\nvar isPlatformReservedTag$1;\nvar staticRenderFns;\nvar onceCount;\nvar currentOptions;\n\nfunction generate (\n  ast,\n  options\n) {\n  // save previous staticRenderFns so generate calls can be nested\n  var prevStaticRenderFns = staticRenderFns;\n  var currentStaticRenderFns = staticRenderFns = [];\n  var prevOnceCount = onceCount;\n  onceCount = 0;\n  currentOptions = options;\n  warn$2 = options.warn || baseWarn;\n  transforms$1 = pluckModuleFunction(options.modules, 'transformCode');\n  dataGenFns = pluckModuleFunction(options.modules, 'genData');\n  platformDirectives$1 = options.directives || {};\n  isPlatformReservedTag$1 = options.isReservedTag || no;\n  var code = ast ? genElement(ast) : '_c(\"div\")';\n  staticRenderFns = prevStaticRenderFns;\n  onceCount = prevOnceCount;\n  return {\n    render: (\"with(this){return \" + code + \"}\"),\n    staticRenderFns: currentStaticRenderFns\n  }\n}\n\nfunction genElement (el) {\n  if (el.staticRoot && !el.staticProcessed) {\n    return genStatic(el)\n  } else if (el.once && !el.onceProcessed) {\n    return genOnce(el)\n  } else if (el.for && !el.forProcessed) {\n    return genFor(el)\n  } else if (el.if && !el.ifProcessed) {\n    return genIf(el)\n  } else if (el.tag === 'template' && !el.slotTarget) {\n    return genChildren(el) || 'void 0'\n  } else if (el.tag === 'slot') {\n    return genSlot(el)\n  } else {\n    // component or element\n    var code;\n    if (el.component) {\n      code = genComponent(el.component, el);\n    } else {\n      var data = el.plain ? undefined : genData(el);\n\n      var children = el.inlineTemplate ? null : genChildren(el, true);\n      code = \"_c('\" + (el.tag) + \"'\" + (data ? (\",\" + data) : '') + (children ? (\",\" + children) : '') + \")\";\n    }\n    // module transforms\n    for (var i = 0; i < transforms$1.length; i++) {\n      code = transforms$1[i](el, code);\n    }\n    return code\n  }\n}\n\n// hoist static sub-trees out\nfunction genStatic (el) {\n  el.staticProcessed = true;\n  staticRenderFns.push((\"with(this){return \" + (genElement(el)) + \"}\"));\n  return (\"_m(\" + (staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + \")\")\n}\n\n// v-once\nfunction genOnce (el) {\n  el.onceProcessed = true;\n  if (el.if && !el.ifProcessed) {\n    return genIf(el)\n  } else if (el.staticInFor) {\n    var key = '';\n    var parent = el.parent;\n    while (parent) {\n      if (parent.for) {\n        key = parent.key;\n        break\n      }\n      parent = parent.parent;\n    }\n    if (!key) {\n      process.env.NODE_ENV !== 'production' && warn$2(\n        \"v-once can only be used inside v-for that is keyed. \"\n      );\n      return genElement(el)\n    }\n    return (\"_o(\" + (genElement(el)) + \",\" + (onceCount++) + (key ? (\",\" + key) : \"\") + \")\")\n  } else {\n    return genStatic(el)\n  }\n}\n\nfunction genIf (el) {\n  el.ifProcessed = true; // avoid recursion\n  return genIfConditions(el.ifConditions.slice())\n}\n\nfunction genIfConditions (conditions) {\n  if (!conditions.length) {\n    return '_e()'\n  }\n\n  var condition = conditions.shift();\n  if (condition.exp) {\n    return (\"(\" + (condition.exp) + \")?\" + (genTernaryExp(condition.block)) + \":\" + (genIfConditions(conditions)))\n  } else {\n    return (\"\" + (genTernaryExp(condition.block)))\n  }\n\n  // v-if with v-once should generate code like (a)?_m(0):_m(1)\n  function genTernaryExp (el) {\n    return el.once ? genOnce(el) : genElement(el)\n  }\n}\n\nfunction genFor (el) {\n  var exp = el.for;\n  var alias = el.alias;\n  var iterator1 = el.iterator1 ? (\",\" + (el.iterator1)) : '';\n  var iterator2 = el.iterator2 ? (\",\" + (el.iterator2)) : '';\n  el.forProcessed = true; // avoid recursion\n  return \"_l((\" + exp + \"),\" +\n    \"function(\" + alias + iterator1 + iterator2 + \"){\" +\n      \"return \" + (genElement(el)) +\n    '})'\n}\n\nfunction genData (el) {\n  var data = '{';\n\n  // directives first.\n  // directives may mutate the el's other properties before they are generated.\n  var dirs = genDirectives(el);\n  if (dirs) { data += dirs + ','; }\n\n  // key\n  if (el.key) {\n    data += \"key:\" + (el.key) + \",\";\n  }\n  // ref\n  if (el.ref) {\n    data += \"ref:\" + (el.ref) + \",\";\n  }\n  if (el.refInFor) {\n    data += \"refInFor:true,\";\n  }\n  // pre\n  if (el.pre) {\n    data += \"pre:true,\";\n  }\n  // record original tag name for components using \"is\" attribute\n  if (el.component) {\n    data += \"tag:\\\"\" + (el.tag) + \"\\\",\";\n  }\n  // module data generation functions\n  for (var i = 0; i < dataGenFns.length; i++) {\n    data += dataGenFns[i](el);\n  }\n  // attributes\n  if (el.attrs) {\n    data += \"attrs:{\" + (genProps(el.attrs)) + \"},\";\n  }\n  // DOM props\n  if (el.props) {\n    data += \"domProps:{\" + (genProps(el.props)) + \"},\";\n  }\n  // event handlers\n  if (el.events) {\n    data += (genHandlers(el.events)) + \",\";\n  }\n  if (el.nativeEvents) {\n    data += (genHandlers(el.nativeEvents, true)) + \",\";\n  }\n  // slot target\n  if (el.slotTarget) {\n    data += \"slot:\" + (el.slotTarget) + \",\";\n  }\n  // scoped slots\n  if (el.scopedSlots) {\n    data += (genScopedSlots(el.scopedSlots)) + \",\";\n  }\n  // inline-template\n  if (el.inlineTemplate) {\n    var inlineTemplate = genInlineTemplate(el);\n    if (inlineTemplate) {\n      data += inlineTemplate + \",\";\n    }\n  }\n  data = data.replace(/,$/, '') + '}';\n  // v-bind data wrap\n  if (el.wrapData) {\n    data = el.wrapData(data);\n  }\n  return data\n}\n\nfunction genDirectives (el) {\n  var dirs = el.directives;\n  if (!dirs) { return }\n  var res = 'directives:[';\n  var hasRuntime = false;\n  var i, l, dir, needRuntime;\n  for (i = 0, l = dirs.length; i < l; i++) {\n    dir = dirs[i];\n    needRuntime = true;\n    var gen = platformDirectives$1[dir.name] || baseDirectives[dir.name];\n    if (gen) {\n      // compile-time directive that manipulates AST.\n      // returns true if it also needs a runtime counterpart.\n      needRuntime = !!gen(el, dir, warn$2);\n    }\n    if (needRuntime) {\n      hasRuntime = true;\n      res += \"{name:\\\"\" + (dir.name) + \"\\\",rawName:\\\"\" + (dir.rawName) + \"\\\"\" + (dir.value ? (\",value:(\" + (dir.value) + \"),expression:\" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (\",arg:\\\"\" + (dir.arg) + \"\\\"\") : '') + (dir.modifiers ? (\",modifiers:\" + (JSON.stringify(dir.modifiers))) : '') + \"},\";\n    }\n  }\n  if (hasRuntime) {\n    return res.slice(0, -1) + ']'\n  }\n}\n\nfunction genInlineTemplate (el) {\n  var ast = el.children[0];\n  if (process.env.NODE_ENV !== 'production' && (\n    el.children.length > 1 || ast.type !== 1\n  )) {\n    warn$2('Inline-template components must have exactly one child element.');\n  }\n  if (ast.type === 1) {\n    var inlineRenderFns = generate(ast, currentOptions);\n    return (\"inlineTemplate:{render:function(){\" + (inlineRenderFns.render) + \"},staticRenderFns:[\" + (inlineRenderFns.staticRenderFns.map(function (code) { return (\"function(){\" + code + \"}\"); }).join(',')) + \"]}\")\n  }\n}\n\nfunction genScopedSlots (slots) {\n  return (\"scopedSlots:{\" + (Object.keys(slots).map(function (key) { return genScopedSlot(key, slots[key]); }).join(',')) + \"}\")\n}\n\nfunction genScopedSlot (key, el) {\n  return key + \":function(\" + (String(el.attrsMap.scope)) + \"){\" +\n    \"return \" + (el.tag === 'template'\n      ? genChildren(el) || 'void 0'\n      : genElement(el)) + \"}\"\n}\n\nfunction genChildren (el, checkSkip) {\n  var children = el.children;\n  if (children.length) {\n    var el$1 = children[0];\n    // optimize single v-for\n    if (children.length === 1 &&\n        el$1.for &&\n        el$1.tag !== 'template' &&\n        el$1.tag !== 'slot') {\n      return genElement(el$1)\n    }\n    var normalizationType = getNormalizationType(children);\n    return (\"[\" + (children.map(genNode).join(',')) + \"]\" + (checkSkip\n        ? normalizationType ? (\",\" + normalizationType) : ''\n        : ''))\n  }\n}\n\n// determine the normalization needed for the children array.\n// 0: no normalization needed\n// 1: simple normalization needed (possible 1-level deep nested array)\n// 2: full normalization needed\nfunction getNormalizationType (children) {\n  var res = 0;\n  for (var i = 0; i < children.length; i++) {\n    var el = children[i];\n    if (el.type !== 1) {\n      continue\n    }\n    if (needsNormalization(el) ||\n        (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {\n      res = 2;\n      break\n    }\n    if (maybeComponent(el) ||\n        (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {\n      res = 1;\n    }\n  }\n  return res\n}\n\nfunction needsNormalization (el) {\n  return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'\n}\n\nfunction maybeComponent (el) {\n  return !isPlatformReservedTag$1(el.tag)\n}\n\nfunction genNode (node) {\n  if (node.type === 1) {\n    return genElement(node)\n  } else {\n    return genText(node)\n  }\n}\n\nfunction genText (text) {\n  return (\"_v(\" + (text.type === 2\n    ? text.expression // no need for () because already wrapped in _s()\n    : transformSpecialNewlines(JSON.stringify(text.text))) + \")\")\n}\n\nfunction genSlot (el) {\n  var slotName = el.slotName || '\"default\"';\n  var children = genChildren(el);\n  var res = \"_t(\" + slotName + (children ? (\",\" + children) : '');\n  var attrs = el.attrs && (\"{\" + (el.attrs.map(function (a) { return ((camelize(a.name)) + \":\" + (a.value)); }).join(',')) + \"}\");\n  var bind$$1 = el.attrsMap['v-bind'];\n  if ((attrs || bind$$1) && !children) {\n    res += \",null\";\n  }\n  if (attrs) {\n    res += \",\" + attrs;\n  }\n  if (bind$$1) {\n    res += (attrs ? '' : ',null') + \",\" + bind$$1;\n  }\n  return res + ')'\n}\n\n// componentName is el.component, take it as argument to shun flow's pessimistic refinement\nfunction genComponent (componentName, el) {\n  var children = el.inlineTemplate ? null : genChildren(el, true);\n  return (\"_c(\" + componentName + \",\" + (genData(el)) + (children ? (\",\" + children) : '') + \")\")\n}\n\nfunction genProps (props) {\n  var res = '';\n  for (var i = 0; i < props.length; i++) {\n    var prop = props[i];\n    res += \"\\\"\" + (prop.name) + \"\\\":\" + (transformSpecialNewlines(prop.value)) + \",\";\n  }\n  return res.slice(0, -1)\n}\n\n// #3895, #4268\nfunction transformSpecialNewlines (text) {\n  return text\n    .replace(/\\u2028/g, '\\\\u2028')\n    .replace(/\\u2029/g, '\\\\u2029')\n}\n\n/*  */\n\n/**\n * Compile a template.\n */\nfunction compile$1 (\n  template,\n  options\n) {\n  var ast = parse(template.trim(), options);\n  optimize(ast, options);\n  var code = generate(ast, options);\n  return {\n    ast: ast,\n    render: code.render,\n    staticRenderFns: code.staticRenderFns\n  }\n}\n\n/*  */\n\n// operators like typeof, instanceof and in are allowed\nvar prohibitedKeywordRE = new RegExp('\\\\b' + (\n  'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +\n  'super,throw,while,yield,delete,export,import,return,switch,default,' +\n  'extends,finally,continue,debugger,function,arguments'\n).split(',').join('\\\\b|\\\\b') + '\\\\b');\n// check valid identifier for v-for\nvar identRE = /[A-Za-z_$][\\w$]*/;\n// strip strings in expressions\nvar stripStringRE = /'(?:[^'\\\\]|\\\\.)*'|\"(?:[^\"\\\\]|\\\\.)*\"|`(?:[^`\\\\]|\\\\.)*\\$\\{|\\}(?:[^`\\\\]|\\\\.)*`|`(?:[^`\\\\]|\\\\.)*`/g;\n\n// detect problematic expressions in a template\nfunction detectErrors (ast) {\n  var errors = [];\n  if (ast) {\n    checkNode(ast, errors);\n  }\n  return errors\n}\n\nfunction checkNode (node, errors) {\n  if (node.type === 1) {\n    for (var name in node.attrsMap) {\n      if (dirRE.test(name)) {\n        var value = node.attrsMap[name];\n        if (value) {\n          if (name === 'v-for') {\n            checkFor(node, (\"v-for=\\\"\" + value + \"\\\"\"), errors);\n          } else {\n            checkExpression(value, (name + \"=\\\"\" + value + \"\\\"\"), errors);\n          }\n        }\n      }\n    }\n    if (node.children) {\n      for (var i = 0; i < node.children.length; i++) {\n        checkNode(node.children[i], errors);\n      }\n    }\n  } else if (node.type === 2) {\n    checkExpression(node.expression, node.text, errors);\n  }\n}\n\nfunction checkFor (node, text, errors) {\n  checkExpression(node.for || '', text, errors);\n  checkIdentifier(node.alias, 'v-for alias', text, errors);\n  checkIdentifier(node.iterator1, 'v-for iterator', text, errors);\n  checkIdentifier(node.iterator2, 'v-for iterator', text, errors);\n}\n\nfunction checkIdentifier (ident, type, text, errors) {\n  if (typeof ident === 'string' && !identRE.test(ident)) {\n    errors.push((\"- invalid \" + type + \" \\\"\" + ident + \"\\\" in expression: \" + text));\n  }\n}\n\nfunction checkExpression (exp, text, errors) {\n  try {\n    new Function((\"return \" + exp));\n  } catch (e) {\n    var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);\n    if (keywordMatch) {\n      errors.push(\n        \"- avoid using JavaScript keyword as property name: \" +\n        \"\\\"\" + (keywordMatch[0]) + \"\\\" in expression \" + text\n      );\n    } else {\n      errors.push((\"- invalid expression: \" + text));\n    }\n  }\n}\n\n/*  */\n\nfunction transformNode (el, options) {\n  var warn = options.warn || baseWarn;\n  var staticClass = getAndRemoveAttr(el, 'class');\n  if (process.env.NODE_ENV !== 'production' && staticClass) {\n    var expression = parseText(staticClass, options.delimiters);\n    if (expression) {\n      warn(\n        \"class=\\\"\" + staticClass + \"\\\": \" +\n        'Interpolation inside attributes has been removed. ' +\n        'Use v-bind or the colon shorthand instead. For example, ' +\n        'instead of <div class=\"{{ val }}\">, use <div :class=\"val\">.'\n      );\n    }\n  }\n  if (staticClass) {\n    el.staticClass = JSON.stringify(staticClass);\n  }\n  var classBinding = getBindingAttr(el, 'class', false /* getStatic */);\n  if (classBinding) {\n    el.classBinding = classBinding;\n  }\n}\n\nfunction genData$1 (el) {\n  var data = '';\n  if (el.staticClass) {\n    data += \"staticClass:\" + (el.staticClass) + \",\";\n  }\n  if (el.classBinding) {\n    data += \"class:\" + (el.classBinding) + \",\";\n  }\n  return data\n}\n\nvar klass$1 = {\n  staticKeys: ['staticClass'],\n  transformNode: transformNode,\n  genData: genData$1\n};\n\n/*  */\n\nfunction transformNode$1 (el, options) {\n  var warn = options.warn || baseWarn;\n  var staticStyle = getAndRemoveAttr(el, 'style');\n  if (staticStyle) {\n    /* istanbul ignore if */\n    if (process.env.NODE_ENV !== 'production') {\n      var expression = parseText(staticStyle, options.delimiters);\n      if (expression) {\n        warn(\n          \"style=\\\"\" + staticStyle + \"\\\": \" +\n          'Interpolation inside attributes has been removed. ' +\n          'Use v-bind or the colon shorthand instead. For example, ' +\n          'instead of <div style=\"{{ val }}\">, use <div :style=\"val\">.'\n        );\n      }\n    }\n    el.staticStyle = JSON.stringify(parseStyleText(staticStyle));\n  }\n\n  var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);\n  if (styleBinding) {\n    el.styleBinding = styleBinding;\n  }\n}\n\nfunction genData$2 (el) {\n  var data = '';\n  if (el.staticStyle) {\n    data += \"staticStyle:\" + (el.staticStyle) + \",\";\n  }\n  if (el.styleBinding) {\n    data += \"style:(\" + (el.styleBinding) + \"),\";\n  }\n  return data\n}\n\nvar style$1 = {\n  staticKeys: ['staticStyle'],\n  transformNode: transformNode$1,\n  genData: genData$2\n};\n\nvar modules$1 = [\n  klass$1,\n  style$1\n];\n\n/*  */\n\nvar warn$3;\n\nfunction model$1 (\n  el,\n  dir,\n  _warn\n) {\n  warn$3 = _warn;\n  var value = dir.value;\n  var modifiers = dir.modifiers;\n  var tag = el.tag;\n  var type = el.attrsMap.type;\n  if (process.env.NODE_ENV !== 'production') {\n    var dynamicType = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];\n    if (tag === 'input' && dynamicType) {\n      warn$3(\n        \"<input :type=\\\"\" + dynamicType + \"\\\" v-model=\\\"\" + value + \"\\\">:\\n\" +\n        \"v-model does not support dynamic input types. Use v-if branches instead.\"\n      );\n    }\n  }\n  if (tag === 'select') {\n    genSelect(el, value, modifiers);\n  } else if (tag === 'input' && type === 'checkbox') {\n    genCheckboxModel(el, value, modifiers);\n  } else if (tag === 'input' && type === 'radio') {\n    genRadioModel(el, value, modifiers);\n  } else {\n    genDefaultModel(el, value, modifiers);\n  }\n  // ensure runtime directive metadata\n  return true\n}\n\nfunction genCheckboxModel (\n  el,\n  value,\n  modifiers\n) {\n  if (process.env.NODE_ENV !== 'production' &&\n    el.attrsMap.checked != null) {\n    warn$3(\n      \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" checked>:\\n\" +\n      \"inline checked attributes will be ignored when using v-model. \" +\n      'Declare initial values in the component\\'s data option instead.'\n    );\n  }\n  var number = modifiers && modifiers.number;\n  var valueBinding = getBindingAttr(el, 'value') || 'null';\n  var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';\n  var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';\n  addProp(el, 'checked',\n    \"Array.isArray(\" + value + \")\" +\n      \"?_i(\" + value + \",\" + valueBinding + \")>-1\" + (\n        trueValueBinding === 'true'\n          ? (\":(\" + value + \")\")\n          : (\":_q(\" + value + \",\" + trueValueBinding + \")\")\n      )\n  );\n  addHandler(el, 'click',\n    \"var $$a=\" + value + \",\" +\n        '$$el=$event.target,' +\n        \"$$c=$$el.checked?(\" + trueValueBinding + \"):(\" + falseValueBinding + \");\" +\n    'if(Array.isArray($$a)){' +\n      \"var $$v=\" + (number ? '_n(' + valueBinding + ')' : valueBinding) + \",\" +\n          '$$i=_i($$a,$$v);' +\n      \"if($$c){$$i<0&&(\" + value + \"=$$a.concat($$v))}\" +\n      \"else{$$i>-1&&(\" + value + \"=$$a.slice(0,$$i).concat($$a.slice($$i+1)))}\" +\n    \"}else{\" + value + \"=$$c}\",\n    null, true\n  );\n}\n\nfunction genRadioModel (\n    el,\n    value,\n    modifiers\n) {\n  if (process.env.NODE_ENV !== 'production' &&\n    el.attrsMap.checked != null) {\n    warn$3(\n      \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" checked>:\\n\" +\n      \"inline checked attributes will be ignored when using v-model. \" +\n      'Declare initial values in the component\\'s data option instead.'\n    );\n  }\n  var number = modifiers && modifiers.number;\n  var valueBinding = getBindingAttr(el, 'value') || 'null';\n  valueBinding = number ? (\"_n(\" + valueBinding + \")\") : valueBinding;\n  addProp(el, 'checked', (\"_q(\" + value + \",\" + valueBinding + \")\"));\n  addHandler(el, 'click', genAssignmentCode(value, valueBinding), null, true);\n}\n\nfunction genDefaultModel (\n  el,\n  value,\n  modifiers\n) {\n  if (process.env.NODE_ENV !== 'production') {\n    if (el.tag === 'input' && el.attrsMap.value) {\n      warn$3(\n        \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" value=\\\"\" + (el.attrsMap.value) + \"\\\">:\\n\" +\n        'inline value attributes will be ignored when using v-model. ' +\n        'Declare initial values in the component\\'s data option instead.'\n      );\n    }\n    if (el.tag === 'textarea' && el.children.length) {\n      warn$3(\n        \"<textarea v-model=\\\"\" + value + \"\\\">:\\n\" +\n        'inline content inside <textarea> will be ignored when using v-model. ' +\n        'Declare initial values in the component\\'s data option instead.'\n      );\n    }\n  }\n\n  var type = el.attrsMap.type;\n  var ref = modifiers || {};\n  var lazy = ref.lazy;\n  var number = ref.number;\n  var trim = ref.trim;\n  var event = lazy || (isIE && type === 'range') ? 'change' : 'input';\n  var needCompositionGuard = !lazy && type !== 'range';\n  var isNative = el.tag === 'input' || el.tag === 'textarea';\n\n  var valueExpression = isNative\n    ? (\"$event.target.value\" + (trim ? '.trim()' : ''))\n    : trim ? \"(typeof $event === 'string' ? $event.trim() : $event)\" : \"$event\";\n  valueExpression = number || type === 'number'\n    ? (\"_n(\" + valueExpression + \")\")\n    : valueExpression;\n\n  var code = genAssignmentCode(value, valueExpression);\n  if (isNative && needCompositionGuard) {\n    code = \"if($event.target.composing)return;\" + code;\n  }\n\n  // inputs with type=\"file\" are read only and setting the input's\n  // value will throw an error.\n  if (process.env.NODE_ENV !== 'production' &&\n      type === 'file') {\n    warn$3(\n      \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" type=\\\"file\\\">:\\n\" +\n      \"File inputs are read only. Use a v-on:change listener instead.\"\n    );\n  }\n\n  addProp(el, 'value', isNative ? (\"_s(\" + value + \")\") : (\"(\" + value + \")\"));\n  addHandler(el, event, code, null, true);\n  if (trim || number || type === 'number') {\n    addHandler(el, 'blur', '$forceUpdate()');\n  }\n}\n\nfunction genSelect (\n    el,\n    value,\n    modifiers\n) {\n  if (process.env.NODE_ENV !== 'production') {\n    el.children.some(checkOptionWarning);\n  }\n\n  var number = modifiers && modifiers.number;\n  var assignment = \"Array.prototype.filter\" +\n    \".call($event.target.options,function(o){return o.selected})\" +\n    \".map(function(o){var val = \\\"_value\\\" in o ? o._value : o.value;\" +\n    \"return \" + (number ? '_n(val)' : 'val') + \"})\" +\n    (el.attrsMap.multiple == null ? '[0]' : '');\n\n  var code = genAssignmentCode(value, assignment);\n  addHandler(el, 'change', code, null, true);\n}\n\nfunction checkOptionWarning (option) {\n  if (option.type === 1 &&\n    option.tag === 'option' &&\n    option.attrsMap.selected != null) {\n    warn$3(\n      \"<select v-model=\\\"\" + (option.parent.attrsMap['v-model']) + \"\\\">:\\n\" +\n      'inline selected attributes on <option> will be ignored when using v-model. ' +\n      'Declare initial values in the component\\'s data option instead.'\n    );\n    return true\n  }\n  return false\n}\n\nfunction genAssignmentCode (value, assignment) {\n  var modelRs = parseModel(value);\n  if (modelRs.idx === null) {\n    return (value + \"=\" + assignment)\n  } else {\n    return \"var $$exp = \" + (modelRs.exp) + \", $$idx = \" + (modelRs.idx) + \";\" +\n      \"if (!Array.isArray($$exp)){\" +\n        value + \"=\" + assignment + \"}\" +\n      \"else{$$exp.splice($$idx, 1, \" + assignment + \")}\"\n  }\n}\n\n/*  */\n\nfunction text (el, dir) {\n  if (dir.value) {\n    addProp(el, 'textContent', (\"_s(\" + (dir.value) + \")\"));\n  }\n}\n\n/*  */\n\nfunction html (el, dir) {\n  if (dir.value) {\n    addProp(el, 'innerHTML', (\"_s(\" + (dir.value) + \")\"));\n  }\n}\n\nvar directives$1 = {\n  model: model$1,\n  text: text,\n  html: html\n};\n\n/*  */\n\nvar cache = Object.create(null);\n\nvar baseOptions = {\n  expectHTML: true,\n  modules: modules$1,\n  staticKeys: genStaticKeys(modules$1),\n  directives: directives$1,\n  isReservedTag: isReservedTag,\n  isUnaryTag: isUnaryTag,\n  mustUseProp: mustUseProp,\n  getTagNamespace: getTagNamespace,\n  isPreTag: isPreTag\n};\n\nfunction compile$$1 (\n  template,\n  options\n) {\n  options = options\n    ? extend(extend({}, baseOptions), options)\n    : baseOptions;\n  return compile$1(template, options)\n}\n\nfunction compileToFunctions (\n  template,\n  options,\n  vm\n) {\n  var _warn = (options && options.warn) || warn;\n  // detect possible CSP restriction\n  /* istanbul ignore if */\n  if (process.env.NODE_ENV !== 'production') {\n    try {\n      new Function('return 1');\n    } catch (e) {\n      if (e.toString().match(/unsafe-eval|CSP/)) {\n        _warn(\n          'It seems you are using the standalone build of Vue.js in an ' +\n          'environment with Content Security Policy that prohibits unsafe-eval. ' +\n          'The template compiler cannot work in this environment. Consider ' +\n          'relaxing the policy to allow unsafe-eval or pre-compiling your ' +\n          'templates into render functions.'\n        );\n      }\n    }\n  }\n  var key = options && options.delimiters\n    ? String(options.delimiters) + template\n    : template;\n  if (cache[key]) {\n    return cache[key]\n  }\n  var res = {};\n  var compiled = compile$$1(template, options);\n  res.render = makeFunction(compiled.render);\n  var l = compiled.staticRenderFns.length;\n  res.staticRenderFns = new Array(l);\n  for (var i = 0; i < l; i++) {\n    res.staticRenderFns[i] = makeFunction(compiled.staticRenderFns[i]);\n  }\n  if (process.env.NODE_ENV !== 'production') {\n    if (res.render === noop || res.staticRenderFns.some(function (fn) { return fn === noop; })) {\n      _warn(\n        \"failed to compile template:\\n\\n\" + template + \"\\n\\n\" +\n        detectErrors(compiled.ast).join('\\n') +\n        '\\n\\n',\n        vm\n      );\n    }\n  }\n  return (cache[key] = res)\n}\n\nfunction makeFunction (code) {\n  try {\n    return new Function(code)\n  } catch (e) {\n    return noop\n  }\n}\n\n/*  */\n\nvar idToTemplate = cached(function (id) {\n  var el = query(id);\n  return el && el.innerHTML\n});\n\nvar mount = Vue$3.prototype.$mount;\nVue$3.prototype.$mount = function (\n  el,\n  hydrating\n) {\n  el = el && query(el);\n\n  /* istanbul ignore if */\n  if (el === document.body || el === document.documentElement) {\n    process.env.NODE_ENV !== 'production' && warn(\n      \"Do not mount Vue to <html> or <body> - mount to normal elements instead.\"\n    );\n    return this\n  }\n\n  var options = this.$options;\n  // resolve template/el and convert to render function\n  if (!options.render) {\n    var template = options.template;\n    if (template) {\n      if (typeof template === 'string') {\n        if (template.charAt(0) === '#') {\n          template = idToTemplate(template);\n          /* istanbul ignore if */\n          if (process.env.NODE_ENV !== 'production' && !template) {\n            warn(\n              (\"Template element not found or is empty: \" + (options.template)),\n              this\n            );\n          }\n        }\n      } else if (template.nodeType) {\n        template = template.innerHTML;\n      } else {\n        if (process.env.NODE_ENV !== 'production') {\n          warn('invalid template option:' + template, this);\n        }\n        return this\n      }\n    } else if (el) {\n      template = getOuterHTML(el);\n    }\n    if (template) {\n      var ref = compileToFunctions(template, {\n        warn: warn,\n        shouldDecodeNewlines: shouldDecodeNewlines,\n        delimiters: options.delimiters\n      }, this);\n      var render = ref.render;\n      var staticRenderFns = ref.staticRenderFns;\n      options.render = render;\n      options.staticRenderFns = staticRenderFns;\n    }\n  }\n  return mount.call(this, el, hydrating)\n};\n\n/**\n * Get outerHTML of elements, taking care\n * of SVG elements in IE as well.\n */\nfunction getOuterHTML (el) {\n  if (el.outerHTML) {\n    return el.outerHTML\n  } else {\n    var container = document.createElement('div');\n    container.appendChild(el.cloneNode(true));\n    return container.innerHTML\n  }\n}\n\nVue$3.compile = compileToFunctions;\n\nmodule.exports = Vue$3;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/vue/dist/vue.common.js\n// module id = 22\n// module chunks = 0","var toString = {}.toString;\n\nmodule.exports = function(it){\n  return toString.call(it).slice(8, -1);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_cof.js\n// module id = 23\n// module chunks = 0","// optional / simple context binding\nvar aFunction = require('./_a-function');\nmodule.exports = function(fn, that, length){\n  aFunction(fn);\n  if(that === undefined)return fn;\n  switch(length){\n    case 1: return function(a){\n      return fn.call(that, a);\n    };\n    case 2: return function(a, b){\n      return fn.call(that, a, b);\n    };\n    case 3: return function(a, b, c){\n      return fn.call(that, a, b, c);\n    };\n  }\n  return function(/* ...args */){\n    return fn.apply(that, arguments);\n  };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_ctx.js\n// module id = 24\n// module chunks = 0","var isObject = require('./_is-object')\n  , document = require('./_global').document\n  // in old IE typeof document.createElement is 'object'\n  , is = isObject(document) && isObject(document.createElement);\nmodule.exports = function(it){\n  return is ? document.createElement(it) : {};\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_dom-create.js\n// module id = 25\n// module chunks = 0","// IE 8- don't enum bug keys\nmodule.exports = (\n  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'\n).split(',');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_enum-bug-keys.js\n// module id = 26\n// module chunks = 0","module.exports = function(exec){\n  try {\n    return !!exec();\n  } catch(e){\n    return true;\n  }\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_fails.js\n// module id = 27\n// module chunks = 0","var def = require('./_object-dp').f\n  , has = require('./_has')\n  , TAG = require('./_wks')('toStringTag');\n\nmodule.exports = function(it, tag, stat){\n  if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_set-to-string-tag.js\n// module id = 28\n// module chunks = 0","var global = require('./_global')\n  , SHARED = '__core-js_shared__'\n  , store  = global[SHARED] || (global[SHARED] = {});\nmodule.exports = function(key){\n  return store[key] || (store[key] = {});\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_shared.js\n// module id = 29\n// module chunks = 0","// to indexed object, toObject with fallback for non-array-like ES3 strings\nvar IObject = require('./_iobject')\n  , defined = require('./_defined');\nmodule.exports = function(it){\n  return IObject(defined(it));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-iobject.js\n// module id = 30\n// module chunks = 0","// 7.1.15 ToLength\nvar toInteger = require('./_to-integer')\n  , min       = Math.min;\nmodule.exports = function(it){\n  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-length.js\n// module id = 31\n// module chunks = 0","// 7.1.13 ToObject(argument)\nvar defined = require('./_defined');\nmodule.exports = function(it){\n  return Object(defined(it));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-object.js\n// module id = 32\n// module chunks = 0","var id = 0\n  , px = Math.random();\nmodule.exports = function(key){\n  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_uid.js\n// module id = 33\n// module chunks = 0","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/global.js\n// module id = 34\n// module chunks = 0","/*!\n * vue-resource v1.2.1\n * https://github.com/pagekit/vue-resource\n * Released under the MIT License.\n */\n\n'use strict';\n\n/**\n * Promises/A+ polyfill v1.1.4 (https://github.com/bramstein/promis)\n */\n\nvar RESOLVED = 0;\nvar REJECTED = 1;\nvar PENDING  = 2;\n\nfunction Promise$1(executor) {\n\n    this.state = PENDING;\n    this.value = undefined;\n    this.deferred = [];\n\n    var promise = this;\n\n    try {\n        executor(function (x) {\n            promise.resolve(x);\n        }, function (r) {\n            promise.reject(r);\n        });\n    } catch (e) {\n        promise.reject(e);\n    }\n}\n\nPromise$1.reject = function (r) {\n    return new Promise$1(function (resolve, reject) {\n        reject(r);\n    });\n};\n\nPromise$1.resolve = function (x) {\n    return new Promise$1(function (resolve, reject) {\n        resolve(x);\n    });\n};\n\nPromise$1.all = function all(iterable) {\n    return new Promise$1(function (resolve, reject) {\n        var count = 0, result = [];\n\n        if (iterable.length === 0) {\n            resolve(result);\n        }\n\n        function resolver(i) {\n            return function (x) {\n                result[i] = x;\n                count += 1;\n\n                if (count === iterable.length) {\n                    resolve(result);\n                }\n            };\n        }\n\n        for (var i = 0; i < iterable.length; i += 1) {\n            Promise$1.resolve(iterable[i]).then(resolver(i), reject);\n        }\n    });\n};\n\nPromise$1.race = function race(iterable) {\n    return new Promise$1(function (resolve, reject) {\n        for (var i = 0; i < iterable.length; i += 1) {\n            Promise$1.resolve(iterable[i]).then(resolve, reject);\n        }\n    });\n};\n\nvar p$1 = Promise$1.prototype;\n\np$1.resolve = function resolve(x) {\n    var promise = this;\n\n    if (promise.state === PENDING) {\n        if (x === promise) {\n            throw new TypeError('Promise settled with itself.');\n        }\n\n        var called = false;\n\n        try {\n            var then = x && x['then'];\n\n            if (x !== null && typeof x === 'object' && typeof then === 'function') {\n                then.call(x, function (x) {\n                    if (!called) {\n                        promise.resolve(x);\n                    }\n                    called = true;\n\n                }, function (r) {\n                    if (!called) {\n                        promise.reject(r);\n                    }\n                    called = true;\n                });\n                return;\n            }\n        } catch (e) {\n            if (!called) {\n                promise.reject(e);\n            }\n            return;\n        }\n\n        promise.state = RESOLVED;\n        promise.value = x;\n        promise.notify();\n    }\n};\n\np$1.reject = function reject(reason) {\n    var promise = this;\n\n    if (promise.state === PENDING) {\n        if (reason === promise) {\n            throw new TypeError('Promise settled with itself.');\n        }\n\n        promise.state = REJECTED;\n        promise.value = reason;\n        promise.notify();\n    }\n};\n\np$1.notify = function notify() {\n    var promise = this;\n\n    nextTick(function () {\n        if (promise.state !== PENDING) {\n            while (promise.deferred.length) {\n                var deferred = promise.deferred.shift(),\n                    onResolved = deferred[0],\n                    onRejected = deferred[1],\n                    resolve = deferred[2],\n                    reject = deferred[3];\n\n                try {\n                    if (promise.state === RESOLVED) {\n                        if (typeof onResolved === 'function') {\n                            resolve(onResolved.call(undefined, promise.value));\n                        } else {\n                            resolve(promise.value);\n                        }\n                    } else if (promise.state === REJECTED) {\n                        if (typeof onRejected === 'function') {\n                            resolve(onRejected.call(undefined, promise.value));\n                        } else {\n                            reject(promise.value);\n                        }\n                    }\n                } catch (e) {\n                    reject(e);\n                }\n            }\n        }\n    });\n};\n\np$1.then = function then(onResolved, onRejected) {\n    var promise = this;\n\n    return new Promise$1(function (resolve, reject) {\n        promise.deferred.push([onResolved, onRejected, resolve, reject]);\n        promise.notify();\n    });\n};\n\np$1.catch = function (onRejected) {\n    return this.then(undefined, onRejected);\n};\n\n/**\n * Promise adapter.\n */\n\nif (typeof Promise === 'undefined') {\n    window.Promise = Promise$1;\n}\n\nfunction PromiseObj(executor, context) {\n\n    if (executor instanceof Promise) {\n        this.promise = executor;\n    } else {\n        this.promise = new Promise(executor.bind(context));\n    }\n\n    this.context = context;\n}\n\nPromiseObj.all = function (iterable, context) {\n    return new PromiseObj(Promise.all(iterable), context);\n};\n\nPromiseObj.resolve = function (value, context) {\n    return new PromiseObj(Promise.resolve(value), context);\n};\n\nPromiseObj.reject = function (reason, context) {\n    return new PromiseObj(Promise.reject(reason), context);\n};\n\nPromiseObj.race = function (iterable, context) {\n    return new PromiseObj(Promise.race(iterable), context);\n};\n\nvar p = PromiseObj.prototype;\n\np.bind = function (context) {\n    this.context = context;\n    return this;\n};\n\np.then = function (fulfilled, rejected) {\n\n    if (fulfilled && fulfilled.bind && this.context) {\n        fulfilled = fulfilled.bind(this.context);\n    }\n\n    if (rejected && rejected.bind && this.context) {\n        rejected = rejected.bind(this.context);\n    }\n\n    return new PromiseObj(this.promise.then(fulfilled, rejected), this.context);\n};\n\np.catch = function (rejected) {\n\n    if (rejected && rejected.bind && this.context) {\n        rejected = rejected.bind(this.context);\n    }\n\n    return new PromiseObj(this.promise.catch(rejected), this.context);\n};\n\np.finally = function (callback) {\n\n    return this.then(function (value) {\n            callback.call(this);\n            return value;\n        }, function (reason) {\n            callback.call(this);\n            return Promise.reject(reason);\n        }\n    );\n};\n\n/**\n * Utility functions.\n */\n\nvar ref = {};\nvar hasOwnProperty = ref.hasOwnProperty;\n\nvar ref$1 = [];\nvar slice = ref$1.slice;\nvar debug = false;\nvar ntick;\n\nvar inBrowser = typeof window !== 'undefined';\n\nvar Util = function (ref) {\n    var config = ref.config;\n    var nextTick = ref.nextTick;\n\n    ntick = nextTick;\n    debug = config.debug || !config.silent;\n};\n\nfunction warn(msg) {\n    if (typeof console !== 'undefined' && debug) {\n        console.warn('[VueResource warn]: ' + msg);\n    }\n}\n\nfunction error(msg) {\n    if (typeof console !== 'undefined') {\n        console.error(msg);\n    }\n}\n\nfunction nextTick(cb, ctx) {\n    return ntick(cb, ctx);\n}\n\nfunction trim(str) {\n    return str ? str.replace(/^\\s*|\\s*$/g, '') : '';\n}\n\nfunction toLower(str) {\n    return str ? str.toLowerCase() : '';\n}\n\nfunction toUpper(str) {\n    return str ? str.toUpperCase() : '';\n}\n\nvar isArray = Array.isArray;\n\nfunction isString(val) {\n    return typeof val === 'string';\n}\n\n\n\nfunction isFunction(val) {\n    return typeof val === 'function';\n}\n\nfunction isObject(obj) {\n    return obj !== null && typeof obj === 'object';\n}\n\nfunction isPlainObject(obj) {\n    return isObject(obj) && Object.getPrototypeOf(obj) == Object.prototype;\n}\n\nfunction isBlob(obj) {\n    return typeof Blob !== 'undefined' && obj instanceof Blob;\n}\n\nfunction isFormData(obj) {\n    return typeof FormData !== 'undefined' && obj instanceof FormData;\n}\n\nfunction when(value, fulfilled, rejected) {\n\n    var promise = PromiseObj.resolve(value);\n\n    if (arguments.length < 2) {\n        return promise;\n    }\n\n    return promise.then(fulfilled, rejected);\n}\n\nfunction options(fn, obj, opts) {\n\n    opts = opts || {};\n\n    if (isFunction(opts)) {\n        opts = opts.call(obj);\n    }\n\n    return merge(fn.bind({$vm: obj, $options: opts}), fn, {$options: opts});\n}\n\nfunction each(obj, iterator) {\n\n    var i, key;\n\n    if (isArray(obj)) {\n        for (i = 0; i < obj.length; i++) {\n            iterator.call(obj[i], obj[i], i);\n        }\n    } else if (isObject(obj)) {\n        for (key in obj) {\n            if (hasOwnProperty.call(obj, key)) {\n                iterator.call(obj[key], obj[key], key);\n            }\n        }\n    }\n\n    return obj;\n}\n\nvar assign = Object.assign || _assign;\n\nfunction merge(target) {\n\n    var args = slice.call(arguments, 1);\n\n    args.forEach(function (source) {\n        _merge(target, source, true);\n    });\n\n    return target;\n}\n\nfunction defaults(target) {\n\n    var args = slice.call(arguments, 1);\n\n    args.forEach(function (source) {\n\n        for (var key in source) {\n            if (target[key] === undefined) {\n                target[key] = source[key];\n            }\n        }\n\n    });\n\n    return target;\n}\n\nfunction _assign(target) {\n\n    var args = slice.call(arguments, 1);\n\n    args.forEach(function (source) {\n        _merge(target, source);\n    });\n\n    return target;\n}\n\nfunction _merge(target, source, deep) {\n    for (var key in source) {\n        if (deep && (isPlainObject(source[key]) || isArray(source[key]))) {\n            if (isPlainObject(source[key]) && !isPlainObject(target[key])) {\n                target[key] = {};\n            }\n            if (isArray(source[key]) && !isArray(target[key])) {\n                target[key] = [];\n            }\n            _merge(target[key], source[key], deep);\n        } else if (source[key] !== undefined) {\n            target[key] = source[key];\n        }\n    }\n}\n\n/**\n * Root Prefix Transform.\n */\n\nvar root = function (options$$1, next) {\n\n    var url = next(options$$1);\n\n    if (isString(options$$1.root) && !url.match(/^(https?:)?\\//)) {\n        url = options$$1.root + '/' + url;\n    }\n\n    return url;\n};\n\n/**\n * Query Parameter Transform.\n */\n\nvar query = function (options$$1, next) {\n\n    var urlParams = Object.keys(Url.options.params), query = {}, url = next(options$$1);\n\n    each(options$$1.params, function (value, key) {\n        if (urlParams.indexOf(key) === -1) {\n            query[key] = value;\n        }\n    });\n\n    query = Url.params(query);\n\n    if (query) {\n        url += (url.indexOf('?') == -1 ? '?' : '&') + query;\n    }\n\n    return url;\n};\n\n/**\n * URL Template v2.0.6 (https://github.com/bramstein/url-template)\n */\n\nfunction expand(url, params, variables) {\n\n    var tmpl = parse(url), expanded = tmpl.expand(params);\n\n    if (variables) {\n        variables.push.apply(variables, tmpl.vars);\n    }\n\n    return expanded;\n}\n\nfunction parse(template) {\n\n    var operators = ['+', '#', '.', '/', ';', '?', '&'], variables = [];\n\n    return {\n        vars: variables,\n        expand: function expand(context) {\n            return template.replace(/\\{([^\\{\\}]+)\\}|([^\\{\\}]+)/g, function (_, expression, literal) {\n                if (expression) {\n\n                    var operator = null, values = [];\n\n                    if (operators.indexOf(expression.charAt(0)) !== -1) {\n                        operator = expression.charAt(0);\n                        expression = expression.substr(1);\n                    }\n\n                    expression.split(/,/g).forEach(function (variable) {\n                        var tmp = /([^:\\*]*)(?::(\\d+)|(\\*))?/.exec(variable);\n                        values.push.apply(values, getValues(context, operator, tmp[1], tmp[2] || tmp[3]));\n                        variables.push(tmp[1]);\n                    });\n\n                    if (operator && operator !== '+') {\n\n                        var separator = ',';\n\n                        if (operator === '?') {\n                            separator = '&';\n                        } else if (operator !== '#') {\n                            separator = operator;\n                        }\n\n                        return (values.length !== 0 ? operator : '') + values.join(separator);\n                    } else {\n                        return values.join(',');\n                    }\n\n                } else {\n                    return encodeReserved(literal);\n                }\n            });\n        }\n    };\n}\n\nfunction getValues(context, operator, key, modifier) {\n\n    var value = context[key], result = [];\n\n    if (isDefined(value) && value !== '') {\n        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {\n            value = value.toString();\n\n            if (modifier && modifier !== '*') {\n                value = value.substring(0, parseInt(modifier, 10));\n            }\n\n            result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : null));\n        } else {\n            if (modifier === '*') {\n                if (Array.isArray(value)) {\n                    value.filter(isDefined).forEach(function (value) {\n                        result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : null));\n                    });\n                } else {\n                    Object.keys(value).forEach(function (k) {\n                        if (isDefined(value[k])) {\n                            result.push(encodeValue(operator, value[k], k));\n                        }\n                    });\n                }\n            } else {\n                var tmp = [];\n\n                if (Array.isArray(value)) {\n                    value.filter(isDefined).forEach(function (value) {\n                        tmp.push(encodeValue(operator, value));\n                    });\n                } else {\n                    Object.keys(value).forEach(function (k) {\n                        if (isDefined(value[k])) {\n                            tmp.push(encodeURIComponent(k));\n                            tmp.push(encodeValue(operator, value[k].toString()));\n                        }\n                    });\n                }\n\n                if (isKeyOperator(operator)) {\n                    result.push(encodeURIComponent(key) + '=' + tmp.join(','));\n                } else if (tmp.length !== 0) {\n                    result.push(tmp.join(','));\n                }\n            }\n        }\n    } else {\n        if (operator === ';') {\n            result.push(encodeURIComponent(key));\n        } else if (value === '' && (operator === '&' || operator === '?')) {\n            result.push(encodeURIComponent(key) + '=');\n        } else if (value === '') {\n            result.push('');\n        }\n    }\n\n    return result;\n}\n\nfunction isDefined(value) {\n    return value !== undefined && value !== null;\n}\n\nfunction isKeyOperator(operator) {\n    return operator === ';' || operator === '&' || operator === '?';\n}\n\nfunction encodeValue(operator, value, key) {\n\n    value = (operator === '+' || operator === '#') ? encodeReserved(value) : encodeURIComponent(value);\n\n    if (key) {\n        return encodeURIComponent(key) + '=' + value;\n    } else {\n        return value;\n    }\n}\n\nfunction encodeReserved(str) {\n    return str.split(/(%[0-9A-Fa-f]{2})/g).map(function (part) {\n        if (!/%[0-9A-Fa-f]/.test(part)) {\n            part = encodeURI(part);\n        }\n        return part;\n    }).join('');\n}\n\n/**\n * URL Template (RFC 6570) Transform.\n */\n\nvar template = function (options) {\n\n    var variables = [], url = expand(options.url, options.params, variables);\n\n    variables.forEach(function (key) {\n        delete options.params[key];\n    });\n\n    return url;\n};\n\n/**\n * Service for URL templating.\n */\n\nfunction Url(url, params) {\n\n    var self = this || {}, options$$1 = url, transform;\n\n    if (isString(url)) {\n        options$$1 = {url: url, params: params};\n    }\n\n    options$$1 = merge({}, Url.options, self.$options, options$$1);\n\n    Url.transforms.forEach(function (handler) {\n        transform = factory(handler, transform, self.$vm);\n    });\n\n    return transform(options$$1);\n}\n\n/**\n * Url options.\n */\n\nUrl.options = {\n    url: '',\n    root: null,\n    params: {}\n};\n\n/**\n * Url transforms.\n */\n\nUrl.transforms = [template, query, root];\n\n/**\n * Encodes a Url parameter string.\n *\n * @param {Object} obj\n */\n\nUrl.params = function (obj) {\n\n    var params = [], escape = encodeURIComponent;\n\n    params.add = function (key, value) {\n\n        if (isFunction(value)) {\n            value = value();\n        }\n\n        if (value === null) {\n            value = '';\n        }\n\n        this.push(escape(key) + '=' + escape(value));\n    };\n\n    serialize(params, obj);\n\n    return params.join('&').replace(/%20/g, '+');\n};\n\n/**\n * Parse a URL and return its components.\n *\n * @param {String} url\n */\n\nUrl.parse = function (url) {\n\n    var el = document.createElement('a');\n\n    if (document.documentMode) {\n        el.href = url;\n        url = el.href;\n    }\n\n    el.href = url;\n\n    return {\n        href: el.href,\n        protocol: el.protocol ? el.protocol.replace(/:$/, '') : '',\n        port: el.port,\n        host: el.host,\n        hostname: el.hostname,\n        pathname: el.pathname.charAt(0) === '/' ? el.pathname : '/' + el.pathname,\n        search: el.search ? el.search.replace(/^\\?/, '') : '',\n        hash: el.hash ? el.hash.replace(/^#/, '') : ''\n    };\n};\n\nfunction factory(handler, next, vm) {\n    return function (options$$1) {\n        return handler.call(vm, options$$1, next);\n    };\n}\n\nfunction serialize(params, obj, scope) {\n\n    var array = isArray(obj), plain = isPlainObject(obj), hash;\n\n    each(obj, function (value, key) {\n\n        hash = isObject(value) || isArray(value);\n\n        if (scope) {\n            key = scope + '[' + (plain || hash ? key : '') + ']';\n        }\n\n        if (!scope && array) {\n            params.add(value.name, value.value);\n        } else if (hash) {\n            serialize(params, value, key);\n        } else {\n            params.add(key, value);\n        }\n    });\n}\n\n/**\n * XDomain client (Internet Explorer).\n */\n\nvar xdrClient = function (request) {\n    return new PromiseObj(function (resolve) {\n\n        var xdr = new XDomainRequest(), handler = function (ref) {\n            var type = ref.type;\n\n\n            var status = 0;\n\n            if (type === 'load') {\n                status = 200;\n            } else if (type === 'error') {\n                status = 500;\n            }\n\n            resolve(request.respondWith(xdr.responseText, {status: status}));\n        };\n\n        request.abort = function () { return xdr.abort(); };\n\n        xdr.open(request.method, request.getUrl());\n\n        if (request.timeout) {\n            xdr.timeout = request.timeout;\n        }\n\n        xdr.onload = handler;\n        xdr.onabort = handler;\n        xdr.onerror = handler;\n        xdr.ontimeout = handler;\n        xdr.onprogress = function () {};\n        xdr.send(request.getBody());\n    });\n};\n\n/**\n * CORS Interceptor.\n */\n\nvar SUPPORTS_CORS = inBrowser && 'withCredentials' in new XMLHttpRequest();\n\nvar cors = function (request, next) {\n\n    if (inBrowser) {\n\n        var orgUrl = Url.parse(location.href);\n        var reqUrl = Url.parse(request.getUrl());\n\n        if (reqUrl.protocol !== orgUrl.protocol || reqUrl.host !== orgUrl.host) {\n\n            request.crossOrigin = true;\n            request.emulateHTTP = false;\n\n            if (!SUPPORTS_CORS) {\n                request.client = xdrClient;\n            }\n        }\n    }\n\n    next();\n};\n\n/**\n * Body Interceptor.\n */\n\nvar body = function (request, next) {\n\n    if (isFormData(request.body)) {\n\n        request.headers.delete('Content-Type');\n\n    } else if (isObject(request.body) || isArray(request.body)) {\n\n        if (request.emulateJSON) {\n            request.body = Url.params(request.body);\n            request.headers.set('Content-Type', 'application/x-www-form-urlencoded');\n        } else {\n            request.body = JSON.stringify(request.body);\n        }\n    }\n\n    next(function (response) {\n\n        Object.defineProperty(response, 'data', {\n\n            get: function get() {\n                return this.body;\n            },\n\n            set: function set(body) {\n                this.body = body;\n            }\n\n        });\n\n        return response.bodyText ? when(response.text(), function (text) {\n\n            var type = response.headers.get('Content-Type') || '';\n\n            if (type.indexOf('application/json') === 0 || isJson(text)) {\n\n                try {\n                    response.body = JSON.parse(text);\n                } catch (e) {\n                    response.body = null;\n                }\n\n            } else {\n                response.body = text;\n            }\n\n            return response;\n\n        }) : response;\n\n    });\n};\n\nfunction isJson(str) {\n\n    var start = str.match(/^\\[|^\\{(?!\\{)/), end = {'[': /]$/, '{': /}$/};\n\n    return start && end[start[0]].test(str);\n}\n\n/**\n * JSONP client (Browser).\n */\n\nvar jsonpClient = function (request) {\n    return new PromiseObj(function (resolve) {\n\n        var name = request.jsonp || 'callback', callback = request.jsonpCallback || '_jsonp' + Math.random().toString(36).substr(2), body = null, handler, script;\n\n        handler = function (ref) {\n            var type = ref.type;\n\n\n            var status = 0;\n\n            if (type === 'load' && body !== null) {\n                status = 200;\n            } else if (type === 'error') {\n                status = 500;\n            }\n\n            if (status && window[callback]) {\n                delete window[callback];\n                document.body.removeChild(script);\n            }\n\n            resolve(request.respondWith(body, {status: status}));\n        };\n\n        window[callback] = function (result) {\n            body = JSON.stringify(result);\n        };\n\n        request.abort = function () {\n            handler({type: 'abort'});\n        };\n\n        request.params[name] = callback;\n\n        if (request.timeout) {\n            setTimeout(request.abort, request.timeout);\n        }\n\n        script = document.createElement('script');\n        script.src = request.getUrl();\n        script.type = 'text/javascript';\n        script.async = true;\n        script.onload = handler;\n        script.onerror = handler;\n\n        document.body.appendChild(script);\n    });\n};\n\n/**\n * JSONP Interceptor.\n */\n\nvar jsonp = function (request, next) {\n\n    if (request.method == 'JSONP') {\n        request.client = jsonpClient;\n    }\n\n    next();\n};\n\n/**\n * Before Interceptor.\n */\n\nvar before = function (request, next) {\n\n    if (isFunction(request.before)) {\n        request.before.call(this, request);\n    }\n\n    next();\n};\n\n/**\n * HTTP method override Interceptor.\n */\n\nvar method = function (request, next) {\n\n    if (request.emulateHTTP && /^(PUT|PATCH|DELETE)$/i.test(request.method)) {\n        request.headers.set('X-HTTP-Method-Override', request.method);\n        request.method = 'POST';\n    }\n\n    next();\n};\n\n/**\n * Header Interceptor.\n */\n\nvar header = function (request, next) {\n\n    var headers = assign({}, Http.headers.common,\n        !request.crossOrigin ? Http.headers.custom : {},\n        Http.headers[toLower(request.method)]\n    );\n\n    each(headers, function (value, name) {\n        if (!request.headers.has(name)) {\n            request.headers.set(name, value);\n        }\n    });\n\n    next();\n};\n\n/**\n * XMLHttp client (Browser).\n */\n\nvar SUPPORTS_BLOB = typeof Blob !== 'undefined' && typeof FileReader !== 'undefined';\n\nvar xhrClient = function (request) {\n    return new PromiseObj(function (resolve) {\n\n        var xhr = new XMLHttpRequest(), handler = function (event) {\n\n            var response = request.respondWith(\n                'response' in xhr ? xhr.response : xhr.responseText, {\n                    status: xhr.status === 1223 ? 204 : xhr.status, // IE9 status bug\n                    statusText: xhr.status === 1223 ? 'No Content' : trim(xhr.statusText)\n                }\n            );\n\n            each(trim(xhr.getAllResponseHeaders()).split('\\n'), function (row) {\n                response.headers.append(row.slice(0, row.indexOf(':')), row.slice(row.indexOf(':') + 1));\n            });\n\n            resolve(response);\n        };\n\n        request.abort = function () { return xhr.abort(); };\n\n        if (request.progress) {\n            if (request.method === 'GET') {\n                xhr.addEventListener('progress', request.progress);\n            } else if (/^(POST|PUT)$/i.test(request.method)) {\n                xhr.upload.addEventListener('progress', request.progress);\n            }\n        }\n\n        xhr.open(request.method, request.getUrl(), true);\n\n        if (request.timeout) {\n            xhr.timeout = request.timeout;\n        }\n\n        if (request.credentials === true) {\n            xhr.withCredentials = true;\n        }\n\n        if (!request.crossOrigin) {\n            request.headers.set('X-Requested-With', 'XMLHttpRequest');\n        }\n\n        if ('responseType' in xhr && SUPPORTS_BLOB) {\n            xhr.responseType = 'blob';\n        }\n\n        request.headers.forEach(function (value, name) {\n            xhr.setRequestHeader(name, value);\n        });\n\n        xhr.onload = handler;\n        xhr.onabort = handler;\n        xhr.onerror = handler;\n        xhr.ontimeout = handler;\n        xhr.send(request.getBody());\n    });\n};\n\n/**\n * Http client (Node).\n */\n\nvar nodeClient = function (request) {\n\n    var client = require('got');\n\n    return new PromiseObj(function (resolve) {\n\n        var url = request.getUrl();\n        var body = request.getBody();\n        var method = request.method;\n        var headers = {}, handler;\n\n        request.headers.forEach(function (value, name) {\n            headers[name] = value;\n        });\n\n        client(url, {body: body, method: method, headers: headers}).then(handler = function (resp) {\n\n            var response = request.respondWith(resp.body, {\n                    status: resp.statusCode,\n                    statusText: trim(resp.statusMessage)\n                }\n            );\n\n            each(resp.headers, function (value, name) {\n                response.headers.set(name, value);\n            });\n\n            resolve(response);\n\n        }, function (error$$1) { return handler(error$$1.response); });\n    });\n};\n\n/**\n * Base client.\n */\n\nvar Client = function (context) {\n\n    var reqHandlers = [sendRequest], resHandlers = [], handler;\n\n    if (!isObject(context)) {\n        context = null;\n    }\n\n    function Client(request) {\n        return new PromiseObj(function (resolve) {\n\n            function exec() {\n\n                handler = reqHandlers.pop();\n\n                if (isFunction(handler)) {\n                    handler.call(context, request, next);\n                } else {\n                    warn((\"Invalid interceptor of type \" + (typeof handler) + \", must be a function\"));\n                    next();\n                }\n            }\n\n            function next(response) {\n\n                if (isFunction(response)) {\n\n                    resHandlers.unshift(response);\n\n                } else if (isObject(response)) {\n\n                    resHandlers.forEach(function (handler) {\n                        response = when(response, function (response) {\n                            return handler.call(context, response) || response;\n                        });\n                    });\n\n                    when(response, resolve);\n\n                    return;\n                }\n\n                exec();\n            }\n\n            exec();\n\n        }, context);\n    }\n\n    Client.use = function (handler) {\n        reqHandlers.push(handler);\n    };\n\n    return Client;\n};\n\nfunction sendRequest(request, resolve) {\n\n    var client = request.client || (inBrowser ? xhrClient : nodeClient);\n\n    resolve(client(request));\n}\n\n/**\n * HTTP Headers.\n */\n\nvar Headers = function Headers(headers) {\n    var this$1 = this;\n\n\n    this.map = {};\n\n    each(headers, function (value, name) { return this$1.append(name, value); });\n};\n\nHeaders.prototype.has = function has (name) {\n    return getName(this.map, name) !== null;\n};\n\nHeaders.prototype.get = function get (name) {\n\n    var list = this.map[getName(this.map, name)];\n\n    return list ? list.join() : null;\n};\n\nHeaders.prototype.getAll = function getAll (name) {\n    return this.map[getName(this.map, name)] || [];\n};\n\nHeaders.prototype.set = function set (name, value) {\n    this.map[normalizeName(getName(this.map, name) || name)] = [trim(value)];\n};\n\nHeaders.prototype.append = function append (name, value){\n\n    var list = this.map[getName(this.map, name)];\n\n    if (list) {\n        list.push(trim(value));\n    } else {\n        this.set(name, value);\n    }\n};\n\nHeaders.prototype.delete = function delete$1 (name){\n    delete this.map[getName(this.map, name)];\n};\n\nHeaders.prototype.deleteAll = function deleteAll (){\n    this.map = {};\n};\n\nHeaders.prototype.forEach = function forEach (callback, thisArg) {\n        var this$1 = this;\n\n    each(this.map, function (list, name) {\n        each(list, function (value) { return callback.call(thisArg, value, name, this$1); });\n    });\n};\n\nfunction getName(map, name) {\n    return Object.keys(map).reduce(function (prev, curr) {\n        return toLower(name) === toLower(curr) ? curr : prev;\n    }, null);\n}\n\nfunction normalizeName(name) {\n\n    if (/[^a-z0-9\\-#$%&'*+.\\^_`|~]/i.test(name)) {\n        throw new TypeError('Invalid character in header field name');\n    }\n\n    return trim(name);\n}\n\n/**\n * HTTP Response.\n */\n\nvar Response = function Response(body, ref) {\n    var url = ref.url;\n    var headers = ref.headers;\n    var status = ref.status;\n    var statusText = ref.statusText;\n\n\n    this.url = url;\n    this.ok = status >= 200 && status < 300;\n    this.status = status || 0;\n    this.statusText = statusText || '';\n    this.headers = new Headers(headers);\n    this.body = body;\n\n    if (isString(body)) {\n\n        this.bodyText = body;\n\n    } else if (isBlob(body)) {\n\n        this.bodyBlob = body;\n\n        if (isBlobText(body)) {\n            this.bodyText = blobText(body);\n        }\n    }\n};\n\nResponse.prototype.blob = function blob () {\n    return when(this.bodyBlob);\n};\n\nResponse.prototype.text = function text () {\n    return when(this.bodyText);\n};\n\nResponse.prototype.json = function json () {\n    return when(this.text(), function (text) { return JSON.parse(text); });\n};\n\nfunction blobText(body) {\n    return new PromiseObj(function (resolve) {\n\n        var reader = new FileReader();\n\n        reader.readAsText(body);\n        reader.onload = function () {\n            resolve(reader.result);\n        };\n\n    });\n}\n\nfunction isBlobText(body) {\n    return body.type.indexOf('text') === 0 || body.type.indexOf('json') !== -1;\n}\n\n/**\n * HTTP Request.\n */\n\nvar Request = function Request(options$$1) {\n\n    this.body = null;\n    this.params = {};\n\n    assign(this, options$$1, {\n        method: toUpper(options$$1.method || 'GET')\n    });\n\n    if (!(this.headers instanceof Headers)) {\n        this.headers = new Headers(this.headers);\n    }\n};\n\nRequest.prototype.getUrl = function getUrl (){\n    return Url(this);\n};\n\nRequest.prototype.getBody = function getBody (){\n    return this.body;\n};\n\nRequest.prototype.respondWith = function respondWith (body, options$$1) {\n    return new Response(body, assign(options$$1 || {}, {url: this.getUrl()}));\n};\n\n/**\n * Service for sending network requests.\n */\n\nvar COMMON_HEADERS = {'Accept': 'application/json, text/plain, */*'};\nvar JSON_CONTENT_TYPE = {'Content-Type': 'application/json;charset=utf-8'};\n\nfunction Http(options$$1) {\n\n    var self = this || {}, client = Client(self.$vm);\n\n    defaults(options$$1 || {}, self.$options, Http.options);\n\n    Http.interceptors.forEach(function (handler) {\n        client.use(handler);\n    });\n\n    return client(new Request(options$$1)).then(function (response) {\n\n        return response.ok ? response : PromiseObj.reject(response);\n\n    }, function (response) {\n\n        if (response instanceof Error) {\n            error(response);\n        }\n\n        return PromiseObj.reject(response);\n    });\n}\n\nHttp.options = {};\n\nHttp.headers = {\n    put: JSON_CONTENT_TYPE,\n    post: JSON_CONTENT_TYPE,\n    patch: JSON_CONTENT_TYPE,\n    delete: JSON_CONTENT_TYPE,\n    common: COMMON_HEADERS,\n    custom: {}\n};\n\nHttp.interceptors = [before, method, body, jsonp, header, cors];\n\n['get', 'delete', 'head', 'jsonp'].forEach(function (method$$1) {\n\n    Http[method$$1] = function (url, options$$1) {\n        return this(assign(options$$1 || {}, {url: url, method: method$$1}));\n    };\n\n});\n\n['post', 'put', 'patch'].forEach(function (method$$1) {\n\n    Http[method$$1] = function (url, body$$1, options$$1) {\n        return this(assign(options$$1 || {}, {url: url, method: method$$1, body: body$$1}));\n    };\n\n});\n\n/**\n * Service for interacting with RESTful services.\n */\n\nfunction Resource(url, params, actions, options$$1) {\n\n    var self = this || {}, resource = {};\n\n    actions = assign({},\n        Resource.actions,\n        actions\n    );\n\n    each(actions, function (action, name) {\n\n        action = merge({url: url, params: assign({}, params)}, options$$1, action);\n\n        resource[name] = function () {\n            return (self.$http || Http)(opts(action, arguments));\n        };\n    });\n\n    return resource;\n}\n\nfunction opts(action, args) {\n\n    var options$$1 = assign({}, action), params = {}, body;\n\n    switch (args.length) {\n\n        case 2:\n\n            params = args[0];\n            body = args[1];\n\n            break;\n\n        case 1:\n\n            if (/^(POST|PUT|PATCH)$/i.test(options$$1.method)) {\n                body = args[0];\n            } else {\n                params = args[0];\n            }\n\n            break;\n\n        case 0:\n\n            break;\n\n        default:\n\n            throw 'Expected up to 2 arguments [params, body], got ' + args.length + ' arguments';\n    }\n\n    options$$1.body = body;\n    options$$1.params = assign({}, options$$1.params, params);\n\n    return options$$1;\n}\n\nResource.actions = {\n\n    get: {method: 'GET'},\n    save: {method: 'POST'},\n    query: {method: 'GET'},\n    update: {method: 'PUT'},\n    remove: {method: 'DELETE'},\n    delete: {method: 'DELETE'}\n\n};\n\n/**\n * Install plugin.\n */\n\nfunction plugin(Vue) {\n\n    if (plugin.installed) {\n        return;\n    }\n\n    Util(Vue);\n\n    Vue.url = Url;\n    Vue.http = Http;\n    Vue.resource = Resource;\n    Vue.Promise = PromiseObj;\n\n    Object.defineProperties(Vue.prototype, {\n\n        $url: {\n            get: function get() {\n                return options(Vue.url, this, this.$options.url);\n            }\n        },\n\n        $http: {\n            get: function get() {\n                return options(Vue.http, this, this.$options.http);\n            }\n        },\n\n        $resource: {\n            get: function get() {\n                return Vue.resource.bind(this);\n            }\n        },\n\n        $promise: {\n            get: function get() {\n                var this$1 = this;\n\n                return function (executor) { return new Vue.Promise(executor, this$1); };\n            }\n        }\n\n    });\n}\n\nif (typeof window !== 'undefined' && window.Vue) {\n    window.Vue.use(plugin);\n}\n\nmodule.exports = plugin;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/vue-resource/dist/vue-resource.common.js\n// module id = 38\n// module chunks = 0","module.exports = { \"default\": require(\"core-js/library/fn/array/from\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/array/from.js\n// module id = 57\n// module chunks = 0","module.exports = { \"default\": require(\"core-js/library/fn/object/define-property\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/object/define-property.js\n// module id = 58\n// module chunks = 0","\"use strict\";\n\nexports.__esModule = true;\n\nvar _from = require(\"../core-js/array/from\");\n\nvar _from2 = _interopRequireDefault(_from);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function (arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {\n      arr2[i] = arr[i];\n    }\n\n    return arr2;\n  } else {\n    return (0, _from2.default)(arr);\n  }\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/helpers/toConsumableArray.js\n// module id = 59\n// module chunks = 0","require('../../modules/es6.string.iterator');\nrequire('../../modules/es6.array.from');\nmodule.exports = require('../../modules/_core').Array.from;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/fn/array/from.js\n// module id = 60\n// module chunks = 0","require('../../modules/es6.object.define-property');\nvar $Object = require('../../modules/_core').Object;\nmodule.exports = function defineProperty(it, key, desc){\n  return $Object.defineProperty(it, key, desc);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/fn/object/define-property.js\n// module id = 61\n// module chunks = 0","module.exports = function(it){\n  if(typeof it != 'function')throw TypeError(it + ' is not a function!');\n  return it;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_a-function.js\n// module id = 62\n// module chunks = 0","// false -> Array#indexOf\n// true  -> Array#includes\nvar toIObject = require('./_to-iobject')\n  , toLength  = require('./_to-length')\n  , toIndex   = require('./_to-index');\nmodule.exports = function(IS_INCLUDES){\n  return function($this, el, fromIndex){\n    var O      = toIObject($this)\n      , length = toLength(O.length)\n      , index  = toIndex(fromIndex, length)\n      , value;\n    // Array#includes uses SameValueZero equality algorithm\n    if(IS_INCLUDES && el != el)while(length > index){\n      value = O[index++];\n      if(value != value)return true;\n    // Array#toIndex ignores holes, Array#includes - not\n    } else for(;length > index; index++)if(IS_INCLUDES || index in O){\n      if(O[index] === el)return IS_INCLUDES || index || 0;\n    } return !IS_INCLUDES && -1;\n  };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_array-includes.js\n// module id = 63\n// module chunks = 0","// getting tag from 19.1.3.6 Object.prototype.toString()\nvar cof = require('./_cof')\n  , TAG = require('./_wks')('toStringTag')\n  // ES3 wrong here\n  , ARG = cof(function(){ return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function(it, key){\n  try {\n    return it[key];\n  } catch(e){ /* empty */ }\n};\n\nmodule.exports = function(it){\n  var O, T, B;\n  return it === undefined ? 'Undefined' : it === null ? 'Null'\n    // @@toStringTag case\n    : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T\n    // builtinTag case\n    : ARG ? cof(O)\n    // ES3 arguments fallback\n    : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_classof.js\n// module id = 64\n// module chunks = 0","'use strict';\nvar $defineProperty = require('./_object-dp')\n  , createDesc      = require('./_property-desc');\n\nmodule.exports = function(object, index, value){\n  if(index in object)$defineProperty.f(object, index, createDesc(0, value));\n  else object[index] = value;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_create-property.js\n// module id = 65\n// module chunks = 0","module.exports = require('./_global').document && document.documentElement;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_html.js\n// module id = 66\n// module chunks = 0","module.exports = !require('./_descriptors') && !require('./_fails')(function(){\n  return Object.defineProperty(require('./_dom-create')('div'), 'a', {get: function(){ return 7; }}).a != 7;\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_ie8-dom-define.js\n// module id = 67\n// module chunks = 0","// fallback for non-array-like ES3 and non-enumerable old V8 strings\nvar cof = require('./_cof');\nmodule.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){\n  return cof(it) == 'String' ? it.split('') : Object(it);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iobject.js\n// module id = 68\n// module chunks = 0","// check on default Array iterator\nvar Iterators  = require('./_iterators')\n  , ITERATOR   = require('./_wks')('iterator')\n  , ArrayProto = Array.prototype;\n\nmodule.exports = function(it){\n  return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_is-array-iter.js\n// module id = 69\n// module chunks = 0","// call something on iterator step with safe closing on error\nvar anObject = require('./_an-object');\nmodule.exports = function(iterator, fn, value, entries){\n  try {\n    return entries ? fn(anObject(value)[0], value[1]) : fn(value);\n  // 7.4.6 IteratorClose(iterator, completion)\n  } catch(e){\n    var ret = iterator['return'];\n    if(ret !== undefined)anObject(ret.call(iterator));\n    throw e;\n  }\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iter-call.js\n// module id = 70\n// module chunks = 0","'use strict';\nvar create         = require('./_object-create')\n  , descriptor     = require('./_property-desc')\n  , setToStringTag = require('./_set-to-string-tag')\n  , IteratorPrototype = {};\n\n// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()\nrequire('./_hide')(IteratorPrototype, require('./_wks')('iterator'), function(){ return this; });\n\nmodule.exports = function(Constructor, NAME, next){\n  Constructor.prototype = create(IteratorPrototype, {next: descriptor(1, next)});\n  setToStringTag(Constructor, NAME + ' Iterator');\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iter-create.js\n// module id = 71\n// module chunks = 0","'use strict';\nvar LIBRARY        = require('./_library')\n  , $export        = require('./_export')\n  , redefine       = require('./_redefine')\n  , hide           = require('./_hide')\n  , has            = require('./_has')\n  , Iterators      = require('./_iterators')\n  , $iterCreate    = require('./_iter-create')\n  , setToStringTag = require('./_set-to-string-tag')\n  , getPrototypeOf = require('./_object-gpo')\n  , ITERATOR       = require('./_wks')('iterator')\n  , BUGGY          = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`\n  , FF_ITERATOR    = '@@iterator'\n  , KEYS           = 'keys'\n  , VALUES         = 'values';\n\nvar returnThis = function(){ return this; };\n\nmodule.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){\n  $iterCreate(Constructor, NAME, next);\n  var getMethod = function(kind){\n    if(!BUGGY && kind in proto)return proto[kind];\n    switch(kind){\n      case KEYS: return function keys(){ return new Constructor(this, kind); };\n      case VALUES: return function values(){ return new Constructor(this, kind); };\n    } return function entries(){ return new Constructor(this, kind); };\n  };\n  var TAG        = NAME + ' Iterator'\n    , DEF_VALUES = DEFAULT == VALUES\n    , VALUES_BUG = false\n    , proto      = Base.prototype\n    , $native    = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]\n    , $default   = $native || getMethod(DEFAULT)\n    , $entries   = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined\n    , $anyNative = NAME == 'Array' ? proto.entries || $native : $native\n    , methods, key, IteratorPrototype;\n  // Fix native\n  if($anyNative){\n    IteratorPrototype = getPrototypeOf($anyNative.call(new Base));\n    if(IteratorPrototype !== Object.prototype){\n      // Set @@toStringTag to native iterators\n      setToStringTag(IteratorPrototype, TAG, true);\n      // fix for some old engines\n      if(!LIBRARY && !has(IteratorPrototype, ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis);\n    }\n  }\n  // fix Array#{values, @@iterator}.name in V8 / FF\n  if(DEF_VALUES && $native && $native.name !== VALUES){\n    VALUES_BUG = true;\n    $default = function values(){ return $native.call(this); };\n  }\n  // Define iterator\n  if((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])){\n    hide(proto, ITERATOR, $default);\n  }\n  // Plug for library\n  Iterators[NAME] = $default;\n  Iterators[TAG]  = returnThis;\n  if(DEFAULT){\n    methods = {\n      values:  DEF_VALUES ? $default : getMethod(VALUES),\n      keys:    IS_SET     ? $default : getMethod(KEYS),\n      entries: $entries\n    };\n    if(FORCED)for(key in methods){\n      if(!(key in proto))redefine(proto, key, methods[key]);\n    } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);\n  }\n  return methods;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iter-define.js\n// module id = 72\n// module chunks = 0","var ITERATOR     = require('./_wks')('iterator')\n  , SAFE_CLOSING = false;\n\ntry {\n  var riter = [7][ITERATOR]();\n  riter['return'] = function(){ SAFE_CLOSING = true; };\n  Array.from(riter, function(){ throw 2; });\n} catch(e){ /* empty */ }\n\nmodule.exports = function(exec, skipClosing){\n  if(!skipClosing && !SAFE_CLOSING)return false;\n  var safe = false;\n  try {\n    var arr  = [7]\n      , iter = arr[ITERATOR]();\n    iter.next = function(){ return {done: safe = true}; };\n    arr[ITERATOR] = function(){ return iter; };\n    exec(arr);\n  } catch(e){ /* empty */ }\n  return safe;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iter-detect.js\n// module id = 73\n// module chunks = 0","module.exports = true;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_library.js\n// module id = 74\n// module chunks = 0","// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])\nvar anObject    = require('./_an-object')\n  , dPs         = require('./_object-dps')\n  , enumBugKeys = require('./_enum-bug-keys')\n  , IE_PROTO    = require('./_shared-key')('IE_PROTO')\n  , Empty       = function(){ /* empty */ }\n  , PROTOTYPE   = 'prototype';\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar createDict = function(){\n  // Thrash, waste and sodomy: IE GC bug\n  var iframe = require('./_dom-create')('iframe')\n    , i      = enumBugKeys.length\n    , lt     = '<'\n    , gt     = '>'\n    , iframeDocument;\n  iframe.style.display = 'none';\n  require('./_html').appendChild(iframe);\n  iframe.src = 'javascript:'; // eslint-disable-line no-script-url\n  // createDict = iframe.contentWindow.Object;\n  // html.removeChild(iframe);\n  iframeDocument = iframe.contentWindow.document;\n  iframeDocument.open();\n  iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);\n  iframeDocument.close();\n  createDict = iframeDocument.F;\n  while(i--)delete createDict[PROTOTYPE][enumBugKeys[i]];\n  return createDict();\n};\n\nmodule.exports = Object.create || function create(O, Properties){\n  var result;\n  if(O !== null){\n    Empty[PROTOTYPE] = anObject(O);\n    result = new Empty;\n    Empty[PROTOTYPE] = null;\n    // add \"__proto__\" for Object.getPrototypeOf polyfill\n    result[IE_PROTO] = O;\n  } else result = createDict();\n  return Properties === undefined ? result : dPs(result, Properties);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-create.js\n// module id = 75\n// module chunks = 0","var dP       = require('./_object-dp')\n  , anObject = require('./_an-object')\n  , getKeys  = require('./_object-keys');\n\nmodule.exports = require('./_descriptors') ? Object.defineProperties : function defineProperties(O, Properties){\n  anObject(O);\n  var keys   = getKeys(Properties)\n    , length = keys.length\n    , i = 0\n    , P;\n  while(length > i)dP.f(O, P = keys[i++], Properties[P]);\n  return O;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-dps.js\n// module id = 76\n// module chunks = 0","// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)\nvar has         = require('./_has')\n  , toObject    = require('./_to-object')\n  , IE_PROTO    = require('./_shared-key')('IE_PROTO')\n  , ObjectProto = Object.prototype;\n\nmodule.exports = Object.getPrototypeOf || function(O){\n  O = toObject(O);\n  if(has(O, IE_PROTO))return O[IE_PROTO];\n  if(typeof O.constructor == 'function' && O instanceof O.constructor){\n    return O.constructor.prototype;\n  } return O instanceof Object ? ObjectProto : null;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-gpo.js\n// module id = 77\n// module chunks = 0","var has          = require('./_has')\n  , toIObject    = require('./_to-iobject')\n  , arrayIndexOf = require('./_array-includes')(false)\n  , IE_PROTO     = require('./_shared-key')('IE_PROTO');\n\nmodule.exports = function(object, names){\n  var O      = toIObject(object)\n    , i      = 0\n    , result = []\n    , key;\n  for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);\n  // Don't enum bug & hidden keys\n  while(names.length > i)if(has(O, key = names[i++])){\n    ~arrayIndexOf(result, key) || result.push(key);\n  }\n  return result;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-keys-internal.js\n// module id = 78\n// module chunks = 0","// 19.1.2.14 / 15.2.3.14 Object.keys(O)\nvar $keys       = require('./_object-keys-internal')\n  , enumBugKeys = require('./_enum-bug-keys');\n\nmodule.exports = Object.keys || function keys(O){\n  return $keys(O, enumBugKeys);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-keys.js\n// module id = 79\n// module chunks = 0","module.exports = require('./_hide');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_redefine.js\n// module id = 80\n// module chunks = 0","var toInteger = require('./_to-integer')\n  , defined   = require('./_defined');\n// true  -> String#at\n// false -> String#codePointAt\nmodule.exports = function(TO_STRING){\n  return function(that, pos){\n    var s = String(defined(that))\n      , i = toInteger(pos)\n      , l = s.length\n      , a, b;\n    if(i < 0 || i >= l)return TO_STRING ? '' : undefined;\n    a = s.charCodeAt(i);\n    return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff\n      ? TO_STRING ? s.charAt(i) : a\n      : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;\n  };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_string-at.js\n// module id = 81\n// module chunks = 0","var toInteger = require('./_to-integer')\n  , max       = Math.max\n  , min       = Math.min;\nmodule.exports = function(index, length){\n  index = toInteger(index);\n  return index < 0 ? max(index + length, 0) : min(index, length);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-index.js\n// module id = 82\n// module chunks = 0","// 7.1.1 ToPrimitive(input [, PreferredType])\nvar isObject = require('./_is-object');\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function(it, S){\n  if(!isObject(it))return it;\n  var fn, val;\n  if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n  if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;\n  if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-primitive.js\n// module id = 83\n// module chunks = 0","var classof   = require('./_classof')\n  , ITERATOR  = require('./_wks')('iterator')\n  , Iterators = require('./_iterators');\nmodule.exports = require('./_core').getIteratorMethod = function(it){\n  if(it != undefined)return it[ITERATOR]\n    || it['@@iterator']\n    || Iterators[classof(it)];\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/core.get-iterator-method.js\n// module id = 84\n// module chunks = 0","'use strict';\nvar ctx            = require('./_ctx')\n  , $export        = require('./_export')\n  , toObject       = require('./_to-object')\n  , call           = require('./_iter-call')\n  , isArrayIter    = require('./_is-array-iter')\n  , toLength       = require('./_to-length')\n  , createProperty = require('./_create-property')\n  , getIterFn      = require('./core.get-iterator-method');\n\n$export($export.S + $export.F * !require('./_iter-detect')(function(iter){ Array.from(iter); }), 'Array', {\n  // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)\n  from: function from(arrayLike/*, mapfn = undefined, thisArg = undefined*/){\n    var O       = toObject(arrayLike)\n      , C       = typeof this == 'function' ? this : Array\n      , aLen    = arguments.length\n      , mapfn   = aLen > 1 ? arguments[1] : undefined\n      , mapping = mapfn !== undefined\n      , index   = 0\n      , iterFn  = getIterFn(O)\n      , length, result, step, iterator;\n    if(mapping)mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);\n    // if object isn't iterable or it's array with default iterator - use simple case\n    if(iterFn != undefined && !(C == Array && isArrayIter(iterFn))){\n      for(iterator = iterFn.call(O), result = new C; !(step = iterator.next()).done; index++){\n        createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value);\n      }\n    } else {\n      length = toLength(O.length);\n      for(result = new C(length); length > index; index++){\n        createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);\n      }\n    }\n    result.length = index;\n    return result;\n  }\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es6.array.from.js\n// module id = 85\n// module chunks = 0","var $export = require('./_export');\n// 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes)\n$export($export.S + $export.F * !require('./_descriptors'), 'Object', {defineProperty: require('./_object-dp').f});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es6.object.define-property.js\n// module id = 86\n// module chunks = 0","'use strict';\nvar $at  = require('./_string-at')(true);\n\n// 21.1.3.27 String.prototype[@@iterator]()\nrequire('./_iter-define')(String, 'String', function(iterated){\n  this._t = String(iterated); // target\n  this._i = 0;                // next index\n// 21.1.5.2.1 %StringIteratorPrototype%.next()\n}, function(){\n  var O     = this._t\n    , index = this._i\n    , point;\n  if(index >= O.length)return {value: undefined, done: true};\n  point = $at(O, index);\n  this._i += point.length;\n  return {value: point, done: false};\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es6.string.iterator.js\n// module id = 87\n// module chunks = 0","import dsv from \"./dsv\";\n\nvar csv = dsv(\",\");\n\nexport var csvParse = csv.parse;\nexport var csvParseRows = csv.parseRows;\nexport var csvFormat = csv.format;\nexport var csvFormatRows = csv.formatRows;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3-dsv/src/csv.js\n// module id = 89\n// module chunks = 0","import dsv from \"./dsv\";\n\nvar tsv = dsv(\"\\t\");\n\nexport var tsvParse = tsv.parse;\nexport var tsvParseRows = tsv.parseRows;\nexport var tsvFormat = tsv.format;\nexport var tsvFormatRows = tsv.formatRows;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/d3-dsv/src/tsv.js\n// module id = 90\n// module chunks = 0","// https://github.com/topojson/topojson Version 2.2.0. Copyright 2016 Mike Bostock.\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :\n  typeof define === 'function' && define.amd ? define(['exports'], factory) :\n  (factory((global.topojson = global.topojson || {})));\n}(this, (function (exports) { 'use strict';\n\n// Computes the bounding box of the specified hash of GeoJSON objects.\nvar bounds = function(objects) {\n  var x0 = Infinity,\n      y0 = Infinity,\n      x1 = -Infinity,\n      y1 = -Infinity;\n\n  function boundGeometry(geometry) {\n    if (geometry && boundGeometryType.hasOwnProperty(geometry.type)) boundGeometryType[geometry.type](geometry);\n  }\n\n  var boundGeometryType = {\n    GeometryCollection: function(o) { o.geometries.forEach(boundGeometry); },\n    Point: function(o) { boundPoint(o.coordinates); },\n    MultiPoint: function(o) { o.coordinates.forEach(boundPoint); },\n    LineString: function(o) { boundLine(o.coordinates); },\n    MultiLineString: function(o) { o.coordinates.forEach(boundLine); },\n    Polygon: function(o) { o.coordinates.forEach(boundLine); },\n    MultiPolygon: function(o) { o.coordinates.forEach(boundMultiLine); }\n  };\n\n  function boundPoint(coordinates) {\n    var x = coordinates[0],\n        y = coordinates[1];\n    if (x < x0) x0 = x;\n    if (x > x1) x1 = x;\n    if (y < y0) y0 = y;\n    if (y > y1) y1 = y;\n  }\n\n  function boundLine(coordinates) {\n    coordinates.forEach(boundPoint);\n  }\n\n  function boundMultiLine(coordinates) {\n    coordinates.forEach(boundLine);\n  }\n\n  for (var key in objects) {\n    boundGeometry(objects[key]);\n  }\n\n  return x1 >= x0 && y1 >= y0 ? [x0, y0, x1, y1] : undefined;\n};\n\nvar hashset = function(size, hash, equal, type, empty) {\n  if (arguments.length === 3) {\n    type = Array;\n    empty = null;\n  }\n\n  var store = new type(size = 1 << Math.max(4, Math.ceil(Math.log(size) / Math.LN2))),\n      mask = size - 1;\n\n  for (var i = 0; i < size; ++i) {\n    store[i] = empty;\n  }\n\n  function add(value) {\n    var index = hash(value) & mask,\n        match = store[index],\n        collisions = 0;\n    while (match != empty) {\n      if (equal(match, value)) return true;\n      if (++collisions >= size) throw new Error(\"full hashset\");\n      match = store[index = (index + 1) & mask];\n    }\n    store[index] = value;\n    return true;\n  }\n\n  function has(value) {\n    var index = hash(value) & mask,\n        match = store[index],\n        collisions = 0;\n    while (match != empty) {\n      if (equal(match, value)) return true;\n      if (++collisions >= size) break;\n      match = store[index = (index + 1) & mask];\n    }\n    return false;\n  }\n\n  function values() {\n    var values = [];\n    for (var i = 0, n = store.length; i < n; ++i) {\n      var match = store[i];\n      if (match != empty) values.push(match);\n    }\n    return values;\n  }\n\n  return {\n    add: add,\n    has: has,\n    values: values\n  };\n};\n\nvar hashmap = function(size, hash, equal, keyType, keyEmpty, valueType) {\n  if (arguments.length === 3) {\n    keyType = valueType = Array;\n    keyEmpty = null;\n  }\n\n  var keystore = new keyType(size = 1 << Math.max(4, Math.ceil(Math.log(size) / Math.LN2))),\n      valstore = new valueType(size),\n      mask = size - 1;\n\n  for (var i = 0; i < size; ++i) {\n    keystore[i] = keyEmpty;\n  }\n\n  function set(key, value) {\n    var index = hash(key) & mask,\n        matchKey = keystore[index],\n        collisions = 0;\n    while (matchKey != keyEmpty) {\n      if (equal(matchKey, key)) return valstore[index] = value;\n      if (++collisions >= size) throw new Error(\"full hashmap\");\n      matchKey = keystore[index = (index + 1) & mask];\n    }\n    keystore[index] = key;\n    valstore[index] = value;\n    return value;\n  }\n\n  function maybeSet(key, value) {\n    var index = hash(key) & mask,\n        matchKey = keystore[index],\n        collisions = 0;\n    while (matchKey != keyEmpty) {\n      if (equal(matchKey, key)) return valstore[index];\n      if (++collisions >= size) throw new Error(\"full hashmap\");\n      matchKey = keystore[index = (index + 1) & mask];\n    }\n    keystore[index] = key;\n    valstore[index] = value;\n    return value;\n  }\n\n  function get(key, missingValue) {\n    var index = hash(key) & mask,\n        matchKey = keystore[index],\n        collisions = 0;\n    while (matchKey != keyEmpty) {\n      if (equal(matchKey, key)) return valstore[index];\n      if (++collisions >= size) break;\n      matchKey = keystore[index = (index + 1) & mask];\n    }\n    return missingValue;\n  }\n\n  function keys() {\n    var keys = [];\n    for (var i = 0, n = keystore.length; i < n; ++i) {\n      var matchKey = keystore[i];\n      if (matchKey != keyEmpty) keys.push(matchKey);\n    }\n    return keys;\n  }\n\n  return {\n    set: set,\n    maybeSet: maybeSet, // set if unset\n    get: get,\n    keys: keys\n  };\n};\n\nvar equalPoint = function(pointA, pointB) {\n  return pointA[0] === pointB[0] && pointA[1] === pointB[1];\n};\n\n// TODO if quantized, use simpler Int32 hashing?\n\nvar buffer = new ArrayBuffer(16);\nvar floats = new Float64Array(buffer);\nvar uints = new Uint32Array(buffer);\n\nvar hashPoint = function(point) {\n  floats[0] = point[0];\n  floats[1] = point[1];\n  var hash = uints[0] ^ uints[1];\n  hash = hash << 5 ^ hash >> 7 ^ uints[2] ^ uints[3];\n  return hash & 0x7fffffff;\n};\n\n// Given an extracted (pre-)topology, identifies all of the junctions. These are\n// the points at which arcs (lines or rings) will need to be cut so that each\n// arc is represented uniquely.\n//\n// A junction is a point where at least one arc deviates from another arc going\n// through the same point. For example, consider the point B. If there is a arc\n// through ABC and another arc through CBA, then B is not a junction because in\n// both cases the adjacent point pairs are {A,C}. However, if there is an\n// additional arc ABD, then {A,D} != {A,C}, and thus B becomes a junction.\n//\n// For a closed ring ABCA, the first point A’s adjacent points are the second\n// and last point {B,C}. For a line, the first and last point are always\n// considered junctions, even if the line is closed; this ensures that a closed\n// line is never rotated.\nvar join = function(topology) {\n  var coordinates = topology.coordinates,\n      lines = topology.lines,\n      rings = topology.rings,\n      indexes = index(),\n      visitedByIndex = new Int32Array(coordinates.length),\n      leftByIndex = new Int32Array(coordinates.length),\n      rightByIndex = new Int32Array(coordinates.length),\n      junctionByIndex = new Int8Array(coordinates.length),\n      junctionCount = 0, // upper bound on number of junctions\n      i, n,\n      previousIndex,\n      currentIndex,\n      nextIndex;\n\n  for (i = 0, n = coordinates.length; i < n; ++i) {\n    visitedByIndex[i] = leftByIndex[i] = rightByIndex[i] = -1;\n  }\n\n  for (i = 0, n = lines.length; i < n; ++i) {\n    var line = lines[i],\n        lineStart = line[0],\n        lineEnd = line[1];\n    currentIndex = indexes[lineStart];\n    nextIndex = indexes[++lineStart];\n    ++junctionCount, junctionByIndex[currentIndex] = 1; // start\n    while (++lineStart <= lineEnd) {\n      sequence(i, previousIndex = currentIndex, currentIndex = nextIndex, nextIndex = indexes[lineStart]);\n    }\n    ++junctionCount, junctionByIndex[nextIndex] = 1; // end\n  }\n\n  for (i = 0, n = coordinates.length; i < n; ++i) {\n    visitedByIndex[i] = -1;\n  }\n\n  for (i = 0, n = rings.length; i < n; ++i) {\n    var ring = rings[i],\n        ringStart = ring[0] + 1,\n        ringEnd = ring[1];\n    previousIndex = indexes[ringEnd - 1];\n    currentIndex = indexes[ringStart - 1];\n    nextIndex = indexes[ringStart];\n    sequence(i, previousIndex, currentIndex, nextIndex);\n    while (++ringStart <= ringEnd) {\n      sequence(i, previousIndex = currentIndex, currentIndex = nextIndex, nextIndex = indexes[ringStart]);\n    }\n  }\n\n  function sequence(i, previousIndex, currentIndex, nextIndex) {\n    if (visitedByIndex[currentIndex] === i) return; // ignore self-intersection\n    visitedByIndex[currentIndex] = i;\n    var leftIndex = leftByIndex[currentIndex];\n    if (leftIndex >= 0) {\n      var rightIndex = rightByIndex[currentIndex];\n      if ((leftIndex !== previousIndex || rightIndex !== nextIndex)\n        && (leftIndex !== nextIndex || rightIndex !== previousIndex)) {\n        ++junctionCount, junctionByIndex[currentIndex] = 1;\n      }\n    } else {\n      leftByIndex[currentIndex] = previousIndex;\n      rightByIndex[currentIndex] = nextIndex;\n    }\n  }\n\n  function index() {\n    var indexByPoint = hashmap(coordinates.length * 1.4, hashIndex, equalIndex, Int32Array, -1, Int32Array),\n        indexes = new Int32Array(coordinates.length);\n\n    for (var i = 0, n = coordinates.length; i < n; ++i) {\n      indexes[i] = indexByPoint.maybeSet(i, i);\n    }\n\n    return indexes;\n  }\n\n  function hashIndex(i) {\n    return hashPoint(coordinates[i]);\n  }\n\n  function equalIndex(i, j) {\n    return equalPoint(coordinates[i], coordinates[j]);\n  }\n\n  visitedByIndex = leftByIndex = rightByIndex = null;\n\n  var junctionByPoint = hashset(junctionCount * 1.4, hashPoint, equalPoint), j;\n\n  // Convert back to a standard hashset by point for caller convenience.\n  for (i = 0, n = coordinates.length; i < n; ++i) {\n    if (junctionByIndex[j = indexes[i]]) {\n      junctionByPoint.add(coordinates[j]);\n    }\n  }\n\n  return junctionByPoint;\n};\n\n// Given an extracted (pre-)topology, cuts (or rotates) arcs so that all shared\n// point sequences are identified. The topology can then be subsequently deduped\n// to remove exact duplicate arcs.\nvar cut = function(topology) {\n  var junctions = join(topology),\n      coordinates = topology.coordinates,\n      lines = topology.lines,\n      rings = topology.rings,\n      next,\n      i, n;\n\n  for (i = 0, n = lines.length; i < n; ++i) {\n    var line = lines[i],\n        lineMid = line[0],\n        lineEnd = line[1];\n    while (++lineMid < lineEnd) {\n      if (junctions.has(coordinates[lineMid])) {\n        next = {0: lineMid, 1: line[1]};\n        line[1] = lineMid;\n        line = line.next = next;\n      }\n    }\n  }\n\n  for (i = 0, n = rings.length; i < n; ++i) {\n    var ring = rings[i],\n        ringStart = ring[0],\n        ringMid = ringStart,\n        ringEnd = ring[1],\n        ringFixed = junctions.has(coordinates[ringStart]);\n    while (++ringMid < ringEnd) {\n      if (junctions.has(coordinates[ringMid])) {\n        if (ringFixed) {\n          next = {0: ringMid, 1: ring[1]};\n          ring[1] = ringMid;\n          ring = ring.next = next;\n        } else { // For the first junction, we can rotate rather than cut.\n          rotateArray(coordinates, ringStart, ringEnd, ringEnd - ringMid);\n          coordinates[ringEnd] = coordinates[ringStart];\n          ringFixed = true;\n          ringMid = ringStart; // restart; we may have skipped junctions\n        }\n      }\n    }\n  }\n\n  return topology;\n};\n\nfunction rotateArray(array, start, end, offset) {\n  reverse(array, start, end);\n  reverse(array, start, start + offset);\n  reverse(array, start + offset, end);\n}\n\nfunction reverse(array, start, end) {\n  for (var mid = start + ((end-- - start) >> 1), t; start < mid; ++start, --end) {\n    t = array[start], array[start] = array[end], array[end] = t;\n  }\n}\n\n// Given a cut topology, combines duplicate arcs.\nvar dedup = function(topology) {\n  var coordinates = topology.coordinates,\n      lines = topology.lines, line,\n      rings = topology.rings, ring,\n      arcCount = lines.length + rings.length,\n      i, n;\n\n  delete topology.lines;\n  delete topology.rings;\n\n  // Count the number of (non-unique) arcs to initialize the hashmap safely.\n  for (i = 0, n = lines.length; i < n; ++i) {\n    line = lines[i]; while (line = line.next) ++arcCount;\n  }\n  for (i = 0, n = rings.length; i < n; ++i) {\n    ring = rings[i]; while (ring = ring.next) ++arcCount;\n  }\n\n  var arcsByEnd = hashmap(arcCount * 2 * 1.4, hashPoint, equalPoint),\n      arcs = topology.arcs = [];\n\n  for (i = 0, n = lines.length; i < n; ++i) {\n    line = lines[i];\n    do {\n      dedupLine(line);\n    } while (line = line.next);\n  }\n\n  for (i = 0, n = rings.length; i < n; ++i) {\n    ring = rings[i];\n    if (ring.next) { // arc is no longer closed\n      do {\n        dedupLine(ring);\n      } while (ring = ring.next);\n    } else {\n      dedupRing(ring);\n    }\n  }\n\n  function dedupLine(arc) {\n    var startPoint,\n        endPoint,\n        startArcs, startArc,\n        endArcs, endArc,\n        i, n;\n\n    // Does this arc match an existing arc in order?\n    if (startArcs = arcsByEnd.get(startPoint = coordinates[arc[0]])) {\n      for (i = 0, n = startArcs.length; i < n; ++i) {\n        startArc = startArcs[i];\n        if (equalLine(startArc, arc)) {\n          arc[0] = startArc[0];\n          arc[1] = startArc[1];\n          return;\n        }\n      }\n    }\n\n    // Does this arc match an existing arc in reverse order?\n    if (endArcs = arcsByEnd.get(endPoint = coordinates[arc[1]])) {\n      for (i = 0, n = endArcs.length; i < n; ++i) {\n        endArc = endArcs[i];\n        if (reverseEqualLine(endArc, arc)) {\n          arc[1] = endArc[0];\n          arc[0] = endArc[1];\n          return;\n        }\n      }\n    }\n\n    if (startArcs) startArcs.push(arc); else arcsByEnd.set(startPoint, [arc]);\n    if (endArcs) endArcs.push(arc); else arcsByEnd.set(endPoint, [arc]);\n    arcs.push(arc);\n  }\n\n  function dedupRing(arc) {\n    var endPoint,\n        endArcs,\n        endArc,\n        i, n;\n\n    // Does this arc match an existing line in order, or reverse order?\n    // Rings are closed, so their start point and end point is the same.\n    if (endArcs = arcsByEnd.get(endPoint = coordinates[arc[0]])) {\n      for (i = 0, n = endArcs.length; i < n; ++i) {\n        endArc = endArcs[i];\n        if (equalRing(endArc, arc)) {\n          arc[0] = endArc[0];\n          arc[1] = endArc[1];\n          return;\n        }\n        if (reverseEqualRing(endArc, arc)) {\n          arc[0] = endArc[1];\n          arc[1] = endArc[0];\n          return;\n        }\n      }\n    }\n\n    // Otherwise, does this arc match an existing ring in order, or reverse order?\n    if (endArcs = arcsByEnd.get(endPoint = coordinates[arc[0] + findMinimumOffset(arc)])) {\n      for (i = 0, n = endArcs.length; i < n; ++i) {\n        endArc = endArcs[i];\n        if (equalRing(endArc, arc)) {\n          arc[0] = endArc[0];\n          arc[1] = endArc[1];\n          return;\n        }\n        if (reverseEqualRing(endArc, arc)) {\n          arc[0] = endArc[1];\n          arc[1] = endArc[0];\n          return;\n        }\n      }\n    }\n\n    if (endArcs) endArcs.push(arc); else arcsByEnd.set(endPoint, [arc]);\n    arcs.push(arc);\n  }\n\n  function equalLine(arcA, arcB) {\n    var ia = arcA[0], ib = arcB[0],\n        ja = arcA[1], jb = arcB[1];\n    if (ia - ja !== ib - jb) return false;\n    for (; ia <= ja; ++ia, ++ib) if (!equalPoint(coordinates[ia], coordinates[ib])) return false;\n    return true;\n  }\n\n  function reverseEqualLine(arcA, arcB) {\n    var ia = arcA[0], ib = arcB[0],\n        ja = arcA[1], jb = arcB[1];\n    if (ia - ja !== ib - jb) return false;\n    for (; ia <= ja; ++ia, --jb) if (!equalPoint(coordinates[ia], coordinates[jb])) return false;\n    return true;\n  }\n\n  function equalRing(arcA, arcB) {\n    var ia = arcA[0], ib = arcB[0],\n        ja = arcA[1], jb = arcB[1],\n        n = ja - ia;\n    if (n !== jb - ib) return false;\n    var ka = findMinimumOffset(arcA),\n        kb = findMinimumOffset(arcB);\n    for (var i = 0; i < n; ++i) {\n      if (!equalPoint(coordinates[ia + (i + ka) % n], coordinates[ib + (i + kb) % n])) return false;\n    }\n    return true;\n  }\n\n  function reverseEqualRing(arcA, arcB) {\n    var ia = arcA[0], ib = arcB[0],\n        ja = arcA[1], jb = arcB[1],\n        n = ja - ia;\n    if (n !== jb - ib) return false;\n    var ka = findMinimumOffset(arcA),\n        kb = n - findMinimumOffset(arcB);\n    for (var i = 0; i < n; ++i) {\n      if (!equalPoint(coordinates[ia + (i + ka) % n], coordinates[jb - (i + kb) % n])) return false;\n    }\n    return true;\n  }\n\n  // Rings are rotated to a consistent, but arbitrary, start point.\n  // This is necessary to detect when a ring and a rotated copy are dupes.\n  function findMinimumOffset(arc) {\n    var start = arc[0],\n        end = arc[1],\n        mid = start,\n        minimum = mid,\n        minimumPoint = coordinates[mid];\n    while (++mid < end) {\n      var point = coordinates[mid];\n      if (point[0] < minimumPoint[0] || point[0] === minimumPoint[0] && point[1] < minimumPoint[1]) {\n        minimum = mid;\n        minimumPoint = point;\n      }\n    }\n    return minimum - start;\n  }\n\n  return topology;\n};\n\n// Given a TopoJSON topology in absolute (quantized) coordinates,\n// converts to fixed-point delta encoding.\n// This is a destructive operation that modifies the given topology!\nvar delta = function(topology) {\n  var arcs = topology.arcs,\n      i = -1,\n      n = arcs.length;\n\n  while (++i < n) {\n    var arc = arcs[i],\n        j = 0,\n        m = arc.length,\n        point = arc[0],\n        x0 = point[0],\n        y0 = point[1],\n        x1,\n        y1;\n    while (++j < m) {\n      point = arc[j];\n      x1 = point[0];\n      y1 = point[1];\n      arc[j] = [x1 - x0, y1 - y0];\n      x0 = x1;\n      y0 = y1;\n    }\n  }\n\n  return topology;\n};\n\n// Extracts the lines and rings from the specified hash of geometry objects.\n//\n// Returns an object with three properties:\n//\n// * coordinates - shared buffer of [x, y] coordinates\n// * lines - lines extracted from the hash, of the form [start, end]\n// * rings - rings extracted from the hash, of the form [start, end]\n//\n// For each ring or line, start and end represent inclusive indexes into the\n// coordinates buffer. For rings (and closed lines), coordinates[start] equals\n// coordinates[end].\n//\n// For each line or polygon geometry in the input hash, including nested\n// geometries as in geometry collections, the `coordinates` array is replaced\n// with an equivalent `arcs` array that, for each line (for line string\n// geometries) or ring (for polygon geometries), points to one of the above\n// lines or rings.\nvar extract = function(objects) {\n  var index = -1,\n      lines = [],\n      rings = [],\n      coordinates = [];\n\n  function extractGeometry(geometry) {\n    if (geometry && extractGeometryType.hasOwnProperty(geometry.type)) extractGeometryType[geometry.type](geometry);\n  }\n\n  var extractGeometryType = {\n    GeometryCollection: function(o) { o.geometries.forEach(extractGeometry); },\n    LineString: function(o) { o.arcs = extractLine(o.coordinates); delete o.coordinates; },\n    MultiLineString: function(o) { o.arcs = o.coordinates.map(extractLine); delete o.coordinates; },\n    Polygon: function(o) { o.arcs = o.coordinates.map(extractRing); delete o.coordinates; },\n    MultiPolygon: function(o) { o.arcs = o.coordinates.map(extractMultiRing); delete o.coordinates; }\n  };\n\n  function extractLine(line) {\n    for (var i = 0, n = line.length; i < n; ++i) coordinates[++index] = line[i];\n    var arc = {0: index - n + 1, 1: index};\n    lines.push(arc);\n    return arc;\n  }\n\n  function extractRing(ring) {\n    for (var i = 0, n = ring.length; i < n; ++i) coordinates[++index] = ring[i];\n    var arc = {0: index - n + 1, 1: index};\n    rings.push(arc);\n    return arc;\n  }\n\n  function extractMultiRing(rings) {\n    return rings.map(extractRing);\n  }\n\n  for (var key in objects) {\n    extractGeometry(objects[key]);\n  }\n\n  return {\n    type: \"Topology\",\n    coordinates: coordinates,\n    lines: lines,\n    rings: rings,\n    objects: objects\n  };\n};\n\n// Given a hash of GeoJSON objects, replaces Features with geometry objects.\n// This is a destructive operation that modifies the input objects!\nvar geometry = function(objects) {\n  var key;\n  for (key in objects) objects[key] = geomifyObject(objects[key]);\n  return objects;\n};\n\nfunction geomifyObject(object) {\n  return (object && geomifyObjectType.hasOwnProperty(object.type)\n      ? geomifyObjectType[object.type]\n      : geomifyGeometry)(object);\n}\n\nfunction geomifyFeature(feature) {\n  var geometry = feature.geometry;\n  if (geometry == null) {\n    feature.type = null;\n  } else {\n    geomifyGeometry(geometry);\n    feature.type = geometry.type;\n    if (geometry.geometries) feature.geometries = geometry.geometries;\n    else if (geometry.coordinates) feature.coordinates = geometry.coordinates;\n    if (geometry.bbox) feature.bbox = geometry.bbox;\n  }\n  delete feature.geometry;\n  return feature;\n}\n\nfunction geomifyGeometry(geometry) {\n  if (!geometry) return {type: null};\n  if (geomifyGeometryType.hasOwnProperty(geometry.type)) geomifyGeometryType[geometry.type](geometry);\n  return geometry;\n}\n\nvar geomifyObjectType = {\n  Feature: geomifyFeature,\n  FeatureCollection: function(collection) {\n    collection.type = \"GeometryCollection\";\n    collection.geometries = collection.features;\n    collection.features.forEach(geomifyFeature);\n    delete collection.features;\n    return collection;\n  }\n};\n\nvar geomifyGeometryType = {\n  GeometryCollection: function(o) {\n    var geometries = o.geometries, i = -1, n = geometries.length;\n    while (++i < n) geometries[i] = geomifyGeometry(geometries[i]);\n  },\n  MultiPoint: function(o) {\n    if (!o.coordinates.length) {\n      o.type = null;\n      delete o.coordinates;\n    } else if (o.coordinates.length < 2) {\n      o.type = \"Point\";\n      o.coordinates = o.coordinates[0];\n    }\n  },\n  LineString: function(o) {\n    if (!o.coordinates.length) {\n      o.type = null;\n      delete o.coordinates;\n    }\n  },\n  MultiLineString: function(o) {\n    for (var lines = o.coordinates, i = 0, N = 0, n = lines.length; i < n; ++i) {\n      var line = lines[i];\n      if (line.length) lines[N++] = line;\n    }\n    if (!N) {\n      o.type = null;\n      delete o.coordinates;\n    } else if (N < 2) {\n      o.type = \"LineString\";\n      o.coordinates = lines[0];\n    } else {\n      o.coordinates.length = N;\n    }\n  },\n  Polygon: function(o) {\n    for (var rings = o.coordinates, i = 0, N = 0, n = rings.length; i < n; ++i) {\n      var ring = rings[i];\n      if (ring.length) rings[N++] = ring;\n    }\n    if (!N) {\n      o.type = null;\n      delete o.coordinates;\n    } else {\n      o.coordinates.length = N;\n    }\n  },\n  MultiPolygon: function(o) {\n    for (var polygons = o.coordinates, j = 0, M = 0, m = polygons.length; j < m; ++j) {\n      for (var rings = polygons[j], i = 0, N = 0, n = rings.length; i < n; ++i) {\n        var ring = rings[i];\n        if (ring.length) rings[N++] = ring;\n      }\n      if (N) {\n        rings.length = N;\n        polygons[M++] = rings;\n      }\n    }\n    if (!M) {\n      o.type = null;\n      delete o.coordinates;\n    } else if (M < 2) {\n      o.type = \"Polygon\";\n      o.coordinates = polygons[0];\n    } else {\n      polygons.length = M;\n    }\n  }\n};\n\nvar prequantize = function(objects, bbox, n) {\n  var x0 = bbox[0],\n      y0 = bbox[1],\n      x1 = bbox[2],\n      y1 = bbox[3],\n      kx = x1 - x0 ? (n - 1) / (x1 - x0) : 1,\n      ky = y1 - y0 ? (n - 1) / (y1 - y0) : 1;\n\n  function quantizePoint(coordinates) {\n    coordinates[0] = Math.round((coordinates[0] - x0) * kx);\n    coordinates[1] = Math.round((coordinates[1] - y0) * ky);\n    return coordinates;\n  }\n\n  function quantizeLine(coordinates) {\n    var i = 0,\n        j = 1,\n        n = coordinates.length,\n        pi = quantizePoint(coordinates[0]),\n        pj,\n        px = pi[0],\n        py = pi[1],\n        x,\n        y;\n\n    while (++i < n) {\n      pi = quantizePoint(coordinates[i]);\n      x = pi[0];\n      y = pi[1];\n      if (x !== px || y !== py) { // skip coincident points\n        pj = coordinates[j++];\n        pj[0] = px = x;\n        pj[1] = py = y;\n      }\n    }\n\n    coordinates.length = j;\n  }\n\n  function quantizeGeometry(o) {\n    if (o && quantizeGeometryType.hasOwnProperty(o.type)) quantizeGeometryType[o.type](o);\n  }\n\n  var quantizeGeometryType = {\n    GeometryCollection: function(o) {\n      o.geometries.forEach(quantizeGeometry);\n    },\n    Point: function(o) {\n      quantizePoint(o.coordinates);\n    },\n    MultiPoint: function(o) {\n      o.coordinates.forEach(quantizePoint);\n    },\n    LineString: function(o) {\n      var line = o.coordinates;\n      quantizeLine(line);\n      if (line.length < 2) line[1] = line[0]; // must have 2+\n    },\n    MultiLineString: function(o) {\n      for (var lines = o.coordinates, i = 0, n = lines.length; i < n; ++i) {\n        var line = lines[i];\n        quantizeLine(line);\n        if (line.length < 2) line[1] = line[0]; // must have 2+\n      }\n    },\n    Polygon: function(o) {\n      for (var rings = o.coordinates, i = 0, n = rings.length; i < n; ++i) {\n        var ring = rings[i];\n        quantizeLine(ring);\n        while (ring.length < 4) ring.push(ring[0]); // must have 4+\n      }\n    },\n    MultiPolygon: function(o) {\n      for (var polygons = o.coordinates, i = 0, n = polygons.length; i < n; ++i) {\n        for (var rings = polygons[i], j = 0, m = rings.length; j < m; ++j) {\n          var ring = rings[j];\n          quantizeLine(ring);\n          while (ring.length < 4) ring.push(ring[0]); // must have 4+\n        }\n      }\n    }\n  };\n\n  for (var key in objects) {\n    quantizeGeometry(objects[key]);\n  }\n\n  return {\n    scale: [1 / kx, 1 / ky],\n    translate: [x0, y0]\n  };\n};\n\n// Constructs the TopoJSON Topology for the specified hash of features.\n// Each object in the specified hash must be a GeoJSON object,\n// meaning FeatureCollection, a Feature or a geometry object.\nvar topology = function(objects, quantization) {\n  var bbox = bounds(geometry(objects)),\n      transform = quantization > 0 && bbox && prequantize(objects, bbox, quantization),\n      topology = dedup(cut(extract(objects))),\n      coordinates = topology.coordinates,\n      indexByArc = hashmap(topology.arcs.length * 1.4, hashArc, equalArc);\n\n  objects = topology.objects; // for garbage collection\n  topology.bbox = bbox;\n  topology.arcs = topology.arcs.map(function(arc, i) {\n    indexByArc.set(arc, i);\n    return coordinates.slice(arc[0], arc[1] + 1);\n  });\n\n  delete topology.coordinates;\n  coordinates = null;\n\n  function indexGeometry(geometry$$1) {\n    if (geometry$$1 && indexGeometryType.hasOwnProperty(geometry$$1.type)) indexGeometryType[geometry$$1.type](geometry$$1);\n  }\n\n  var indexGeometryType = {\n    GeometryCollection: function(o) { o.geometries.forEach(indexGeometry); },\n    LineString: function(o) { o.arcs = indexArcs(o.arcs); },\n    MultiLineString: function(o) { o.arcs = o.arcs.map(indexArcs); },\n    Polygon: function(o) { o.arcs = o.arcs.map(indexArcs); },\n    MultiPolygon: function(o) { o.arcs = o.arcs.map(indexMultiArcs); }\n  };\n\n  function indexArcs(arc) {\n    var indexes = [];\n    do {\n      var index = indexByArc.get(arc);\n      indexes.push(arc[0] < arc[1] ? index : ~index);\n    } while (arc = arc.next);\n    return indexes;\n  }\n\n  function indexMultiArcs(arcs) {\n    return arcs.map(indexArcs);\n  }\n\n  for (var key in objects) {\n    indexGeometry(objects[key]);\n  }\n\n  if (transform) {\n    topology.transform = transform;\n    delta(topology);\n  }\n\n  return topology;\n};\n\nfunction hashArc(arc) {\n  var i = arc[0], j = arc[1], t;\n  if (j < i) t = i, i = j, j = t;\n  return i + 31 * j;\n}\n\nfunction equalArc(arcA, arcB) {\n  var ia = arcA[0], ja = arcA[1],\n      ib = arcB[0], jb = arcB[1], t;\n  if (ja < ia) t = ia, ia = ja, ja = t;\n  if (jb < ib) t = ib, ib = jb, jb = t;\n  return ia === ib && ja === jb;\n}\n\nvar prune = function(topology) {\n  var oldArcs = topology.arcs,\n      newArcs = topology.arcs = [],\n      newArcIndex = -1,\n      newIndexByOldIndex = new Array(oldArcs.length),\n      name;\n\n  function pruneGeometry(o) {\n    switch (o.type) {\n      case \"GeometryCollection\": o.geometries.forEach(pruneGeometry); break;\n      case \"LineString\": pruneArcs(o.arcs); break;\n      case \"MultiLineString\": o.arcs.forEach(pruneArcs); break;\n      case \"Polygon\": o.arcs.forEach(pruneArcs); break;\n      case \"MultiPolygon\": o.arcs.forEach(pruneMultiArcs); break;\n    }\n  }\n\n  function pruneArcs(arcs) {\n    for (var i = 0, n = arcs.length; i < n; ++i) {\n      var oldIndex = arcs[i],\n          oldReverse = oldIndex < 0 && (oldIndex = ~oldIndex, true),\n          newIndex;\n\n      // If this is the first instance of this arc,\n      // record it under its new index.\n      if ((newIndex = newIndexByOldIndex[oldIndex]) == null) {\n        newIndexByOldIndex[oldIndex] = newIndex = ++newArcIndex;\n        newArcs[newIndex] = oldArcs[oldIndex];\n      }\n\n      arcs[i] = oldReverse ? ~newIndex : newIndex;\n    }\n  }\n\n  function pruneMultiArcs(arcs) {\n    arcs.forEach(pruneArcs);\n  }\n\n  for (name in topology.objects) {\n    pruneGeometry(topology.objects[name]);\n  }\n\n  return topology;\n};\n\nvar filter = function(topology, filter) {\n  var name;\n\n  if (filter == null) filter = filterTrue;\n\n  function filterGeometry(o) {\n    switch (o.type) {\n      case \"Polygon\": {\n        o.arcs = filterRings(o.arcs);\n        if (!o.arcs) o.type = null, delete o.arcs;\n        break;\n      }\n      case \"MultiPolygon\": {\n        o.arcs = o.arcs.map(filterRings).filter(filterIdentity);\n        if (!o.arcs.length) o.type = null, delete o.arcs;\n        break;\n      }\n      case \"GeometryCollection\": {\n        o.geometries.forEach(filterGeometry);\n        o.geometries = o.geometries.filter(filterNotNull);\n        if (!o.geometries.length) o.type = null, delete o.geometries;\n        break;\n      }\n    }\n  }\n\n  function filterRings(arcs) {\n    return arcs.length && filterExteriorRing(arcs[0]) // if the exterior is small, ignore any holes\n        ? [arcs.shift()].concat(arcs.filter(filterInteriorRing))\n        : null;\n  }\n\n  function filterExteriorRing(ring) {\n    return filter(ring, false);\n  }\n\n  function filterInteriorRing(ring) {\n    return filter(ring, true);\n  }\n\n  for (name in topology.objects) {\n    filterGeometry(topology.objects[name]);\n  }\n\n  return prune(topology);\n};\n\nfunction filterTrue() {\n  return true;\n}\n\nfunction filterIdentity(x) {\n  return x;\n}\n\nfunction filterNotNull(geometry) {\n  return geometry.type != null;\n}\n\nvar filterAttached = function(topology) {\n  var uniqueRingByArc = {}, // arc index -> index of unique associated ring, or -1 if used by multiple rings\n      ringIndex = 0,\n      name;\n\n  function testGeometry(o) {\n    switch (o.type) {\n      case \"GeometryCollection\": o.geometries.forEach(testGeometry); break;\n      case \"Polygon\": testArcs(o.arcs); break;\n      case \"MultiPolygon\": o.arcs.forEach(testArcs); break;\n    }\n  }\n\n  function testArcs(arcs) {\n    for (var i = 0, n = arcs.length; i < n; ++i, ++ringIndex) {\n      for (var ring = arcs[i], j = 0, m = ring.length; j < m; ++j) {\n        var arc = ring[j];\n        if (arc < 0) arc = ~arc;\n        var uniqueRing = uniqueRingByArc[arc];\n        if (uniqueRing >= 0 && uniqueRing !== ringIndex) uniqueRingByArc[arc] = -1;\n        else uniqueRingByArc[arc] = ringIndex;\n      }\n    }\n  }\n\n  for (name in topology.objects) {\n    testGeometry(topology.objects[name]);\n  }\n\n  return function(ring) {\n    for (var j = 0, m = ring.length, arc; j < m; ++j) {\n      if (arc = ring[j], uniqueRingByArc[arc < 0 ? ~arc : arc] < 0) {\n        return true;\n      }\n    }\n    return false;\n  };\n};\n\nvar identity = function(x) {\n  return x;\n};\n\nvar transform = function(topology) {\n  if ((transform = topology.transform) == null) return identity;\n  var transform,\n      x0,\n      y0,\n      kx = transform.scale[0],\n      ky = transform.scale[1],\n      dx = transform.translate[0],\n      dy = transform.translate[1];\n  return function(point, i) {\n    if (!i) x0 = y0 = 0;\n    point[0] = (x0 += point[0]) * kx + dx;\n    point[1] = (y0 += point[1]) * ky + dy;\n    return point;\n  };\n};\n\nvar bbox = function(topology) {\n  var bbox = topology.bbox;\n\n  function bboxPoint(p0) {\n    p1[0] = p0[0], p1[1] = p0[1], t(p1);\n    if (p1[0] < x0) x0 = p1[0];\n    if (p1[0] > x1) x1 = p1[0];\n    if (p1[1] < y0) y0 = p1[1];\n    if (p1[1] > y1) y1 = p1[1];\n  }\n\n  function bboxGeometry(o) {\n    switch (o.type) {\n      case \"GeometryCollection\": o.geometries.forEach(bboxGeometry); break;\n      case \"Point\": bboxPoint(o.coordinates); break;\n      case \"MultiPoint\": o.coordinates.forEach(bboxPoint); break;\n    }\n  }\n\n  if (!bbox) {\n    var t = transform(topology), p0, p1 = new Array(2), name,\n        x0 = Infinity, y0 = x0, x1 = -x0, y1 = -x0;\n\n    topology.arcs.forEach(function(arc) {\n      var i = -1, n = arc.length;\n      while (++i < n) {\n        p0 = arc[i], p1[0] = p0[0], p1[1] = p0[1], t(p1, i);\n        if (p1[0] < x0) x0 = p1[0];\n        if (p1[0] > x1) x1 = p1[0];\n        if (p1[1] < y0) y0 = p1[1];\n        if (p1[1] > y1) y1 = p1[1];\n      }\n    });\n\n    for (name in topology.objects) {\n      bboxGeometry(topology.objects[name]);\n    }\n\n    bbox = topology.bbox = [x0, y0, x1, y1];\n  }\n\n  return bbox;\n};\n\nvar reverse$1 = function(array, n) {\n  var t, j = array.length, i = j - n;\n  while (i < --j) t = array[i], array[i++] = array[j], array[j] = t;\n};\n\nvar feature = function(topology, o) {\n  return o.type === \"GeometryCollection\"\n      ? {type: \"FeatureCollection\", features: o.geometries.map(function(o) { return feature$1(topology, o); })}\n      : feature$1(topology, o);\n};\n\nfunction feature$1(topology, o) {\n  var id = o.id,\n      bbox = o.bbox,\n      properties = o.properties == null ? {} : o.properties,\n      geometry = object(topology, o);\n  return id == null && bbox == null ? {type: \"Feature\", properties: properties, geometry: geometry}\n      : bbox == null ? {type: \"Feature\", id: id, properties: properties, geometry: geometry}\n      : {type: \"Feature\", id: id, bbox: bbox, properties: properties, geometry: geometry};\n}\n\nfunction object(topology, o) {\n  var transformPoint = transform(topology),\n      arcs = topology.arcs;\n\n  function arc(i, points) {\n    if (points.length) points.pop();\n    for (var a = arcs[i < 0 ? ~i : i], k = 0, n = a.length; k < n; ++k) {\n      points.push(transformPoint(a[k].slice(), k));\n    }\n    if (i < 0) reverse$1(points, n);\n  }\n\n  function point(p) {\n    return transformPoint(p.slice());\n  }\n\n  function line(arcs) {\n    var points = [];\n    for (var i = 0, n = arcs.length; i < n; ++i) arc(arcs[i], points);\n    if (points.length < 2) points.push(points[0].slice());\n    return points;\n  }\n\n  function ring(arcs) {\n    var points = line(arcs);\n    while (points.length < 4) points.push(points[0].slice());\n    return points;\n  }\n\n  function polygon(arcs) {\n    return arcs.map(ring);\n  }\n\n  function geometry(o) {\n    var type = o.type, coordinates;\n    switch (type) {\n      case \"GeometryCollection\": return {type: type, geometries: o.geometries.map(geometry)};\n      case \"Point\": coordinates = point(o.coordinates); break;\n      case \"MultiPoint\": coordinates = o.coordinates.map(point); break;\n      case \"LineString\": coordinates = line(o.arcs); break;\n      case \"MultiLineString\": coordinates = o.arcs.map(line); break;\n      case \"Polygon\": coordinates = polygon(o.arcs); break;\n      case \"MultiPolygon\": coordinates = o.arcs.map(polygon); break;\n      default: return null;\n    }\n    return {type: type, coordinates: coordinates};\n  }\n\n  return geometry(o);\n}\n\nvar stitch = function(topology, arcs) {\n  var stitchedArcs = {},\n      fragmentByStart = {},\n      fragmentByEnd = {},\n      fragments = [],\n      emptyIndex = -1;\n\n  // Stitch empty arcs first, since they may be subsumed by other arcs.\n  arcs.forEach(function(i, j) {\n    var arc = topology.arcs[i < 0 ? ~i : i], t;\n    if (arc.length < 3 && !arc[1][0] && !arc[1][1]) {\n      t = arcs[++emptyIndex], arcs[emptyIndex] = i, arcs[j] = t;\n    }\n  });\n\n  arcs.forEach(function(i) {\n    var e = ends(i),\n        start = e[0],\n        end = e[1],\n        f, g;\n\n    if (f = fragmentByEnd[start]) {\n      delete fragmentByEnd[f.end];\n      f.push(i);\n      f.end = end;\n      if (g = fragmentByStart[end]) {\n        delete fragmentByStart[g.start];\n        var fg = g === f ? f : f.concat(g);\n        fragmentByStart[fg.start = f.start] = fragmentByEnd[fg.end = g.end] = fg;\n      } else {\n        fragmentByStart[f.start] = fragmentByEnd[f.end] = f;\n      }\n    } else if (f = fragmentByStart[end]) {\n      delete fragmentByStart[f.start];\n      f.unshift(i);\n      f.start = start;\n      if (g = fragmentByEnd[start]) {\n        delete fragmentByEnd[g.end];\n        var gf = g === f ? f : g.concat(f);\n        fragmentByStart[gf.start = g.start] = fragmentByEnd[gf.end = f.end] = gf;\n      } else {\n        fragmentByStart[f.start] = fragmentByEnd[f.end] = f;\n      }\n    } else {\n      f = [i];\n      fragmentByStart[f.start = start] = fragmentByEnd[f.end = end] = f;\n    }\n  });\n\n  function ends(i) {\n    var arc = topology.arcs[i < 0 ? ~i : i], p0 = arc[0], p1;\n    if (topology.transform) p1 = [0, 0], arc.forEach(function(dp) { p1[0] += dp[0], p1[1] += dp[1]; });\n    else p1 = arc[arc.length - 1];\n    return i < 0 ? [p1, p0] : [p0, p1];\n  }\n\n  function flush(fragmentByEnd, fragmentByStart) {\n    for (var k in fragmentByEnd) {\n      var f = fragmentByEnd[k];\n      delete fragmentByStart[f.start];\n      delete f.start;\n      delete f.end;\n      f.forEach(function(i) { stitchedArcs[i < 0 ? ~i : i] = 1; });\n      fragments.push(f);\n    }\n  }\n\n  flush(fragmentByEnd, fragmentByStart);\n  flush(fragmentByStart, fragmentByEnd);\n  arcs.forEach(function(i) { if (!stitchedArcs[i < 0 ? ~i : i]) fragments.push([i]); });\n\n  return fragments;\n};\n\nvar mesh = function(topology) {\n  return object(topology, meshArcs.apply(this, arguments));\n};\n\nfunction meshArcs(topology, object$$1, filter) {\n  var arcs, i, n;\n  if (arguments.length > 1) arcs = extractArcs(topology, object$$1, filter);\n  else for (i = 0, arcs = new Array(n = topology.arcs.length); i < n; ++i) arcs[i] = i;\n  return {type: \"MultiLineString\", arcs: stitch(topology, arcs)};\n}\n\nfunction extractArcs(topology, object$$1, filter) {\n  var arcs = [],\n      geomsByArc = [],\n      geom;\n\n  function extract0(i) {\n    var j = i < 0 ? ~i : i;\n    (geomsByArc[j] || (geomsByArc[j] = [])).push({i: i, g: geom});\n  }\n\n  function extract1(arcs) {\n    arcs.forEach(extract0);\n  }\n\n  function extract2(arcs) {\n    arcs.forEach(extract1);\n  }\n\n  function extract3(arcs) {\n    arcs.forEach(extract2);\n  }\n\n  function geometry(o) {\n    switch (geom = o, o.type) {\n      case \"GeometryCollection\": o.geometries.forEach(geometry); break;\n      case \"LineString\": extract1(o.arcs); break;\n      case \"MultiLineString\": case \"Polygon\": extract2(o.arcs); break;\n      case \"MultiPolygon\": extract3(o.arcs); break;\n    }\n  }\n\n  geometry(object$$1);\n\n  geomsByArc.forEach(filter == null\n      ? function(geoms) { arcs.push(geoms[0].i); }\n      : function(geoms) { if (filter(geoms[0].g, geoms[geoms.length - 1].g)) arcs.push(geoms[0].i); });\n\n  return arcs;\n}\n\nfunction planarRingArea(ring) {\n  var i = -1, n = ring.length, a, b = ring[n - 1], area = 0;\n  while (++i < n) a = b, b = ring[i], area += a[0] * b[1] - a[1] * b[0];\n  return Math.abs(area); // Note: doubled area!\n}\n\nvar merge = function(topology) {\n  return object(topology, mergeArcs.apply(this, arguments));\n};\n\nfunction mergeArcs(topology, objects) {\n  var polygonsByArc = {},\n      polygons = [],\n      groups = [];\n\n  objects.forEach(geometry);\n\n  function geometry(o) {\n    switch (o.type) {\n      case \"GeometryCollection\": o.geometries.forEach(geometry); break;\n      case \"Polygon\": extract(o.arcs); break;\n      case \"MultiPolygon\": o.arcs.forEach(extract); break;\n    }\n  }\n\n  function extract(polygon) {\n    polygon.forEach(function(ring) {\n      ring.forEach(function(arc) {\n        (polygonsByArc[arc = arc < 0 ? ~arc : arc] || (polygonsByArc[arc] = [])).push(polygon);\n      });\n    });\n    polygons.push(polygon);\n  }\n\n  function area(ring) {\n    return planarRingArea(object(topology, {type: \"Polygon\", arcs: [ring]}).coordinates[0]);\n  }\n\n  polygons.forEach(function(polygon) {\n    if (!polygon._) {\n      var group = [],\n          neighbors = [polygon];\n      polygon._ = 1;\n      groups.push(group);\n      while (polygon = neighbors.pop()) {\n        group.push(polygon);\n        polygon.forEach(function(ring) {\n          ring.forEach(function(arc) {\n            polygonsByArc[arc < 0 ? ~arc : arc].forEach(function(polygon) {\n              if (!polygon._) {\n                polygon._ = 1;\n                neighbors.push(polygon);\n              }\n            });\n          });\n        });\n      }\n    }\n  });\n\n  polygons.forEach(function(polygon) {\n    delete polygon._;\n  });\n\n  return {\n    type: \"MultiPolygon\",\n    arcs: groups.map(function(polygons) {\n      var arcs = [], n;\n\n      // Extract the exterior (unique) arcs.\n      polygons.forEach(function(polygon) {\n        polygon.forEach(function(ring) {\n          ring.forEach(function(arc) {\n            if (polygonsByArc[arc < 0 ? ~arc : arc].length < 2) {\n              arcs.push(arc);\n            }\n          });\n        });\n      });\n\n      // Stitch the arcs into one or more rings.\n      arcs = stitch(topology, arcs);\n\n      // If more than one ring is returned,\n      // at most one of these rings can be the exterior;\n      // choose the one with the greatest absolute area.\n      if ((n = arcs.length) > 1) {\n        for (var i = 1, k = area(arcs[0]), ki, t; i < n; ++i) {\n          if ((ki = area(arcs[i])) > k) {\n            t = arcs[0], arcs[0] = arcs[i], arcs[i] = t, k = ki;\n          }\n        }\n      }\n\n      return arcs;\n    })\n  };\n}\n\nvar bisect = function(a, x) {\n  var lo = 0, hi = a.length;\n  while (lo < hi) {\n    var mid = lo + hi >>> 1;\n    if (a[mid] < x) lo = mid + 1;\n    else hi = mid;\n  }\n  return lo;\n};\n\nvar neighbors = function(objects) {\n  var indexesByArc = {}, // arc index -> array of object indexes\n      neighbors = objects.map(function() { return []; });\n\n  function line(arcs, i) {\n    arcs.forEach(function(a) {\n      if (a < 0) a = ~a;\n      var o = indexesByArc[a];\n      if (o) o.push(i);\n      else indexesByArc[a] = [i];\n    });\n  }\n\n  function polygon(arcs, i) {\n    arcs.forEach(function(arc) { line(arc, i); });\n  }\n\n  function geometry(o, i) {\n    if (o.type === \"GeometryCollection\") o.geometries.forEach(function(o) { geometry(o, i); });\n    else if (o.type in geometryType) geometryType[o.type](o.arcs, i);\n  }\n\n  var geometryType = {\n    LineString: line,\n    MultiLineString: polygon,\n    Polygon: polygon,\n    MultiPolygon: function(arcs, i) { arcs.forEach(function(arc) { polygon(arc, i); }); }\n  };\n\n  objects.forEach(geometry);\n\n  for (var i in indexesByArc) {\n    for (var indexes = indexesByArc[i], m = indexes.length, j = 0; j < m; ++j) {\n      for (var k = j + 1; k < m; ++k) {\n        var ij = indexes[j], ik = indexes[k], n;\n        if ((n = neighbors[ij])[i = bisect(n, ik)] !== ik) n.splice(i, 0, ik);\n        if ((n = neighbors[ik])[i = bisect(n, ij)] !== ij) n.splice(i, 0, ij);\n      }\n    }\n  }\n\n  return neighbors;\n};\n\nvar quantize = function(topology, n) {\n  if (!((n = Math.floor(n)) >= 2)) throw new Error(\"n must be \\u22652\");\n  if (topology.transform) throw new Error(\"already quantized\");\n  var bb = bbox(topology), name,\n      dx = bb[0], kx = (bb[2] - dx) / (n - 1) || 1,\n      dy = bb[1], ky = (bb[3] - dy) / (n - 1) || 1;\n\n  function quantizePoint(p) {\n    p[0] = Math.round((p[0] - dx) / kx);\n    p[1] = Math.round((p[1] - dy) / ky);\n  }\n\n  function quantizeGeometry(o) {\n    switch (o.type) {\n      case \"GeometryCollection\": o.geometries.forEach(quantizeGeometry); break;\n      case \"Point\": quantizePoint(o.coordinates); break;\n      case \"MultiPoint\": o.coordinates.forEach(quantizePoint); break;\n    }\n  }\n\n  topology.arcs.forEach(function(arc) {\n    var i = 1,\n        j = 1,\n        n = arc.length,\n        pi = arc[0],\n        x0 = pi[0] = Math.round((pi[0] - dx) / kx),\n        y0 = pi[1] = Math.round((pi[1] - dy) / ky),\n        pj,\n        x1,\n        y1;\n\n    for (; i < n; ++i) {\n      pi = arc[i];\n      x1 = Math.round((pi[0] - dx) / kx);\n      y1 = Math.round((pi[1] - dy) / ky);\n      if (x1 !== x0 || y1 !== y0) {\n        pj = arc[j++];\n        pj[0] = x1 - x0, x0 = x1;\n        pj[1] = y1 - y0, y0 = y1;\n      }\n    }\n\n    if (j < 2) {\n      pj = arc[j++];\n      pj[0] = 0;\n      pj[1] = 0;\n    }\n\n    arc.length = j;\n  });\n\n  for (name in topology.objects) {\n    quantizeGeometry(topology.objects[name]);\n  }\n\n  topology.transform = {\n    scale: [kx, ky],\n    translate: [dx, dy]\n  };\n\n  return topology;\n};\n\nvar untransform = function(topology) {\n  if ((transform = topology.transform) == null) return identity;\n  var transform,\n      x0,\n      y0,\n      kx = transform.scale[0],\n      ky = transform.scale[1],\n      dx = transform.translate[0],\n      dy = transform.translate[1];\n  return function(point, i) {\n    if (!i) x0 = y0 = 0;\n    var x1 = Math.round((point[0] - dx) / kx),\n        y1 = Math.round((point[1] - dy) / ky);\n    point[0] = x1 - x0, x0 = x1;\n    point[1] = y1 - y0, y0 = y1;\n    return point;\n  };\n};\n\nfunction planarTriangleArea(triangle) {\n  var a = triangle[0], b = triangle[1], c = triangle[2];\n  return Math.abs((a[0] - c[0]) * (b[1] - a[1]) - (a[0] - b[0]) * (c[1] - a[1]));\n}\n\nfunction planarRingArea$1(ring) {\n  var i = -1, n = ring.length, a, b = ring[n - 1], area = 0;\n  while (++i < n) a = b, b = ring[i], area += a[0] * b[1] - a[1] * b[0];\n  return Math.abs(area) / 2;\n}\n\nvar filterWeight = function(topology, minWeight, weight) {\n  minWeight = minWeight == null ? Number.MIN_VALUE : +minWeight;\n\n  if (weight == null) weight = planarRingArea$1;\n\n  return function(ring, interior) {\n    return weight(feature(topology, {type: \"Polygon\", arcs: [ring]}).geometry.coordinates[0], interior) >= minWeight;\n  };\n};\n\nfunction compare(a, b) {\n  return a[1][2] - b[1][2];\n}\n\nvar newHeap = function() {\n  var heap = {},\n      array = [],\n      size = 0;\n\n  heap.push = function(object) {\n    up(array[object._ = size] = object, size++);\n    return size;\n  };\n\n  heap.pop = function() {\n    if (size <= 0) return;\n    var removed = array[0], object;\n    if (--size > 0) object = array[size], down(array[object._ = 0] = object, 0);\n    return removed;\n  };\n\n  heap.remove = function(removed) {\n    var i = removed._, object;\n    if (array[i] !== removed) return; // invalid request\n    if (i !== --size) object = array[size], (compare(object, removed) < 0 ? up : down)(array[object._ = i] = object, i);\n    return i;\n  };\n\n  function up(object, i) {\n    while (i > 0) {\n      var j = ((i + 1) >> 1) - 1,\n          parent = array[j];\n      if (compare(object, parent) >= 0) break;\n      array[parent._ = i] = parent;\n      array[object._ = i = j] = object;\n    }\n  }\n\n  function down(object, i) {\n    while (true) {\n      var r = (i + 1) << 1,\n          l = r - 1,\n          j = i,\n          child = array[j];\n      if (l < size && compare(array[l], child) < 0) child = array[j = l];\n      if (r < size && compare(array[r], child) < 0) child = array[j = r];\n      if (j === i) break;\n      array[child._ = i] = child;\n      array[object._ = i = j] = object;\n    }\n  }\n\n  return heap;\n};\n\nvar presimplify = function(topology, weight) {\n  var absolute = transform(topology),\n      relative = untransform(topology),\n      heap = newHeap();\n\n  if (weight == null) weight = planarTriangleArea;\n\n  topology.arcs.forEach(function(arc) {\n    var triangles = [],\n        maxWeight = 0,\n        triangle,\n        i,\n        n;\n\n    arc.forEach(absolute);\n\n    for (i = 1, n = arc.length - 1; i < n; ++i) {\n      triangle = arc.slice(i - 1, i + 2);\n      triangle[1][2] = weight(triangle);\n      triangles.push(triangle);\n      heap.push(triangle);\n    }\n\n    // Always keep the arc endpoints!\n    arc[0][2] = arc[n][2] = Infinity;\n\n    for (i = 0, n = triangles.length; i < n; ++i) {\n      triangle = triangles[i];\n      triangle.previous = triangles[i - 1];\n      triangle.next = triangles[i + 1];\n    }\n\n    while (triangle = heap.pop()) {\n      var previous = triangle.previous,\n          next = triangle.next;\n\n      // If the weight of the current point is less than that of the previous\n      // point to be eliminated, use the latter’s weight instead. This ensures\n      // that the current point cannot be eliminated without eliminating\n      // previously- eliminated points.\n      if (triangle[1][2] < maxWeight) triangle[1][2] = maxWeight;\n      else maxWeight = triangle[1][2];\n\n      if (previous) {\n        previous.next = next;\n        previous[2] = triangle[2];\n        update(previous);\n      }\n\n      if (next) {\n        next.previous = previous;\n        next[0] = triangle[0];\n        update(next);\n      }\n    }\n\n    arc.forEach(relative);\n  });\n\n  function update(triangle) {\n    heap.remove(triangle);\n    triangle[1][2] = weight(triangle);\n    heap.push(triangle);\n  }\n\n  return topology;\n};\n\nvar quantile = function(topology, p) {\n  var array = [];\n\n  topology.arcs.forEach(function(arc) {\n    arc.forEach(function(point) {\n      if (isFinite(point[2])) { // Ignore endpoints, whose weight is Infinity.\n        array.push(point[2]);\n      }\n    });\n  });\n\n  return array.length && quantile$1(array.sort(descending), p);\n};\n\nfunction quantile$1(array, p) {\n  if (!(n = array.length)) return;\n  if ((p = +p) <= 0 || n < 2) return array[0];\n  if (p >= 1) return array[n - 1];\n  var n,\n      h = (n - 1) * p,\n      i = Math.floor(h),\n      a = array[i],\n      b = array[i + 1];\n  return a + (b - a) * (h - i);\n}\n\nfunction descending(a, b) {\n  return b - a;\n}\n\nvar simplify = function(topology, minWeight) {\n  minWeight = minWeight == null ? Number.MIN_VALUE : +minWeight;\n\n  // Remove points whose weight is less than the minimum weight.\n  topology.arcs.forEach(topology.transform ? function(arc) {\n    var dx = 0,\n        dy = 0, // accumulate removed points\n        i = -1,\n        j = -1,\n        n = arc.length,\n        source,\n        target;\n\n    while (++i < n) {\n      source = arc[i];\n      if (source[2] >= minWeight) {\n        target = arc[++j];\n        target[0] = source[0] + dx;\n        target[1] = source[1] + dy;\n        dx = dy = 0;\n      } else {\n        dx += source[0];\n        dy += source[1];\n      }\n    }\n\n    arc.length = ++j;\n  } : function(arc) {\n    var i = -1,\n        j = -1,\n        n = arc.length,\n        point;\n\n    while (++i < n) {\n      point = arc[i];\n      if (point[2] >= minWeight) {\n        arc[++j] = point;\n      }\n    }\n\n    arc.length = ++j;\n  });\n\n  // Remove the computed weight for each point, and remove coincident points.\n  // This is done as a separate pass because some coordinates may be shared\n  // between arcs (such as the last point and first point of a cut line).\n  // If the entire arc is empty, retain at least two points (per spec).\n  topology.arcs.forEach(topology.transform ? function(arc) {\n    var i = 0,\n        j = 0,\n        n = arc.length,\n        p = arc[0];\n    p.length = 2;\n    while (++i < n) {\n      p = arc[i];\n      p.length = 2;\n      if (p[0] || p[1]) arc[++j] = p;\n    }\n    arc.length = (j || 1) + 1;\n  } : function(arc) {\n    var i = 0,\n        j = 0,\n        n = arc.length,\n        p = arc[0],\n        x0 = p[0],\n        y0 = p[1],\n        x1,\n        y1;\n    p.length = 2;\n    while (++i < n) {\n      p = arc[i], x1 = p[0], y1 = p[1];\n      p.length = 2;\n      if (x0 !== x1 || y0 !== y1) arc[++j] = p, x0 = x1, y0 = y1;\n    }\n    arc.length = (j || 1) + 1;\n  });\n\n  return topology;\n};\n\nvar pi = Math.PI;\nvar tau = 2 * pi;\nvar fourPi = 4 * pi;\nvar radians = pi / 180;\nvar abs = Math.abs;\nvar atan = Math.atan;\nvar atan2 = Math.atan2;\nvar cos = Math.cos;\nvar max = Math.max;\nvar sin = Math.sin;\nvar sqrt = Math.sqrt;\nvar tan = Math.tan;\n\nfunction sphericalRingArea(ring, interior) {\n  if (!ring.length) return 0;\n  var sum = 0,\n      point = ring[0],\n      lambda0, lambda1 = point[0] * radians, delta,\n      phi1 = (point[1] * radians + tau) / 2,\n      cosPhi0, cosPhi1 = cos(phi1),\n      sinPhi0, sinPhi1 = sin(phi1),\n      i, n, k;\n\n  for (i = 1, n = ring.length; i < n; ++i) {\n    point = ring[i];\n    lambda0 = lambda1, lambda1 = point[0] * radians, delta = lambda1 - lambda0;\n    phi1 = (point[1] * radians + tau) / 2;\n    cosPhi0 = cosPhi1, cosPhi1 = cos(phi1);\n    sinPhi0 = sinPhi1, sinPhi1 = sin(phi1);\n\n    // Spherical excess E for a spherical triangle with vertices: south pole,\n    // previous point, current point. Uses a formula derived from Cagnoli’s\n    // theorem. See Todhunter, Spherical Trig. (1871), Sec. 103, Eq. (2).\n    k = sinPhi0 * sinPhi1;\n    sum += atan2(k * sin(delta), cosPhi0 * cosPhi1 + k * cos(delta));\n  }\n\n  sum = 2 * (sum > pi ? sum - tau : sum < -pi ? sum + tau : sum);\n  if (interior) sum *= -1;\n  return sum < 0 ? sum + fourPi : sum;\n}\n\nfunction sphericalTriangleArea(t) {\n  var lambda0 = t[0][0] * radians, phi0 = t[0][1] * radians, cosPhi0 = cos(phi0), sinPhi0 = sin(phi0),\n      lambda1 = t[1][0] * radians, phi1 = t[1][1] * radians, cosPhi1 = cos(phi1), sinPhi1 = sin(phi1),\n      lambda2 = t[2][0] * radians, phi2 = t[2][1] * radians, cosPhi2 = cos(phi2), sinPhi2 = sin(phi2),\n      a = distance(lambda0, cosPhi0, sinPhi0, lambda1, cosPhi1, sinPhi1),\n      b = distance(lambda1, cosPhi1, sinPhi1, lambda2, cosPhi2, sinPhi2),\n      c = distance(lambda2, cosPhi2, sinPhi2, lambda0, cosPhi0, sinPhi0),\n      s = (a + b + c) / 2;\n  return 4 * atan(sqrt(max(0, tan(s / 2) * tan((s - a) / 2) * tan((s - b) / 2) * tan((s - c) / 2))));\n}\n\nfunction distance(lambda0, sinPhi0, cosPhi0, lambda1, sinPhi1, cosPhi1) {\n  var delta = abs(lambda1 - lambda0),\n      cosDelta = cos(delta),\n      sinDelta = sin(delta),\n      x = cosPhi1 * sinDelta,\n      y = cosPhi0 * sinPhi1 - sinPhi0 * cosPhi1 * cosDelta,\n      z = sinPhi0 * sinPhi1 + cosPhi0 * cosPhi1 * cosDelta;\n  return atan2(sqrt(x * x + y * y), z);\n}\n\nexports.topology = topology;\nexports.filter = filter;\nexports.filterAttached = filterAttached;\nexports.filterWeight = filterWeight;\nexports.planarRingArea = planarRingArea$1;\nexports.planarTriangleArea = planarTriangleArea;\nexports.presimplify = presimplify;\nexports.quantile = quantile;\nexports.simplify = simplify;\nexports.sphericalRingArea = sphericalRingArea;\nexports.sphericalTriangleArea = sphericalTriangleArea;\nexports.bbox = bbox;\nexports.feature = feature;\nexports.merge = merge;\nexports.mergeArcs = mergeArcs;\nexports.mesh = mesh;\nexports.meshArcs = meshArcs;\nexports.neighbors = neighbors;\nexports.quantize = quantize;\nexports.transform = transform;\nexports.untransform = untransform;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/topojson/dist/topojson.js\n// module id = 104\n// module chunks = 0","/**\n  * vue-router v2.2.1\n  * (c) 2017 Evan You\n  * @license MIT\n  */\n'use strict';\n\n/*  */\n\nfunction assert (condition, message) {\n  if (!condition) {\n    throw new Error((\"[vue-router] \" + message))\n  }\n}\n\nfunction warn (condition, message) {\n  if (!condition) {\n    typeof console !== 'undefined' && console.warn((\"[vue-router] \" + message));\n  }\n}\n\nvar View = {\n  name: 'router-view',\n  functional: true,\n  props: {\n    name: {\n      type: String,\n      default: 'default'\n    }\n  },\n  render: function render (h, ref) {\n    var props = ref.props;\n    var children = ref.children;\n    var parent = ref.parent;\n    var data = ref.data;\n\n    data.routerView = true;\n\n    var name = props.name;\n    var route = parent.$route;\n    var cache = parent._routerViewCache || (parent._routerViewCache = {});\n\n    // determine current view depth, also check to see if the tree\n    // has been toggled inactive but kept-alive.\n    var depth = 0;\n    var inactive = false;\n    while (parent) {\n      if (parent.$vnode && parent.$vnode.data.routerView) {\n        depth++;\n      }\n      if (parent._inactive) {\n        inactive = true;\n      }\n      parent = parent.$parent;\n    }\n    data.routerViewDepth = depth;\n\n    // render previous view if the tree is inactive and kept-alive\n    if (inactive) {\n      return h(cache[name], data, children)\n    }\n\n    var matched = route.matched[depth];\n    // render empty node if no matched route\n    if (!matched) {\n      cache[name] = null;\n      return h()\n    }\n\n    var component = cache[name] = matched.components[name];\n\n    // inject instance registration hooks\n    var hooks = data.hook || (data.hook = {});\n    hooks.init = function (vnode) {\n      matched.instances[name] = vnode.child;\n    };\n    hooks.prepatch = function (oldVnode, vnode) {\n      matched.instances[name] = vnode.child;\n    };\n    hooks.destroy = function (vnode) {\n      if (matched.instances[name] === vnode.child) {\n        matched.instances[name] = undefined;\n      }\n    };\n\n    // resolve props\n    data.props = resolveProps(route, matched.props && matched.props[name]);\n\n    return h(component, data, children)\n  }\n};\n\nfunction resolveProps (route, config) {\n  switch (typeof config) {\n    case 'undefined':\n      return\n    case 'object':\n      return config\n    case 'function':\n      return config(route)\n    case 'boolean':\n      return config ? route.params : undefined\n    default:\n      warn(false, (\"props in \\\"\" + (route.path) + \"\\\" is a \" + (typeof config) + \", expecting an object, function or boolean.\"));\n  }\n}\n\n/*  */\n\nvar encodeReserveRE = /[!'()*]/g;\nvar encodeReserveReplacer = function (c) { return '%' + c.charCodeAt(0).toString(16); };\nvar commaRE = /%2C/g;\n\n// fixed encodeURIComponent which is more comformant to RFC3986:\n// - escapes [!'()*]\n// - preserve commas\nvar encode = function (str) { return encodeURIComponent(str)\n  .replace(encodeReserveRE, encodeReserveReplacer)\n  .replace(commaRE, ','); };\n\nvar decode = decodeURIComponent;\n\nfunction resolveQuery (\n  query,\n  extraQuery\n) {\n  if ( extraQuery === void 0 ) extraQuery = {};\n\n  if (query) {\n    var parsedQuery;\n    try {\n      parsedQuery = parseQuery(query);\n    } catch (e) {\n      process.env.NODE_ENV !== 'production' && warn(false, e.message);\n      parsedQuery = {};\n    }\n    for (var key in extraQuery) {\n      parsedQuery[key] = extraQuery[key];\n    }\n    return parsedQuery\n  } else {\n    return extraQuery\n  }\n}\n\nfunction parseQuery (query) {\n  var res = {};\n\n  query = query.trim().replace(/^(\\?|#|&)/, '');\n\n  if (!query) {\n    return res\n  }\n\n  query.split('&').forEach(function (param) {\n    var parts = param.replace(/\\+/g, ' ').split('=');\n    var key = decode(parts.shift());\n    var val = parts.length > 0\n      ? decode(parts.join('='))\n      : null;\n\n    if (res[key] === undefined) {\n      res[key] = val;\n    } else if (Array.isArray(res[key])) {\n      res[key].push(val);\n    } else {\n      res[key] = [res[key], val];\n    }\n  });\n\n  return res\n}\n\nfunction stringifyQuery (obj) {\n  var res = obj ? Object.keys(obj).map(function (key) {\n    var val = obj[key];\n\n    if (val === undefined) {\n      return ''\n    }\n\n    if (val === null) {\n      return encode(key)\n    }\n\n    if (Array.isArray(val)) {\n      var result = [];\n      val.slice().forEach(function (val2) {\n        if (val2 === undefined) {\n          return\n        }\n        if (val2 === null) {\n          result.push(encode(key));\n        } else {\n          result.push(encode(key) + '=' + encode(val2));\n        }\n      });\n      return result.join('&')\n    }\n\n    return encode(key) + '=' + encode(val)\n  }).filter(function (x) { return x.length > 0; }).join('&') : null;\n  return res ? (\"?\" + res) : ''\n}\n\n/*  */\n\nvar trailingSlashRE = /\\/?$/;\n\nfunction createRoute (\n  record,\n  location,\n  redirectedFrom\n) {\n  var route = {\n    name: location.name || (record && record.name),\n    meta: (record && record.meta) || {},\n    path: location.path || '/',\n    hash: location.hash || '',\n    query: location.query || {},\n    params: location.params || {},\n    fullPath: getFullPath(location),\n    matched: record ? formatMatch(record) : []\n  };\n  if (redirectedFrom) {\n    route.redirectedFrom = getFullPath(redirectedFrom);\n  }\n  return Object.freeze(route)\n}\n\n// the starting route that represents the initial state\nvar START = createRoute(null, {\n  path: '/'\n});\n\nfunction formatMatch (record) {\n  var res = [];\n  while (record) {\n    res.unshift(record);\n    record = record.parent;\n  }\n  return res\n}\n\nfunction getFullPath (ref) {\n  var path = ref.path;\n  var query = ref.query; if ( query === void 0 ) query = {};\n  var hash = ref.hash; if ( hash === void 0 ) hash = '';\n\n  return (path || '/') + stringifyQuery(query) + hash\n}\n\nfunction isSameRoute (a, b) {\n  if (b === START) {\n    return a === b\n  } else if (!b) {\n    return false\n  } else if (a.path && b.path) {\n    return (\n      a.path.replace(trailingSlashRE, '') === b.path.replace(trailingSlashRE, '') &&\n      a.hash === b.hash &&\n      isObjectEqual(a.query, b.query)\n    )\n  } else if (a.name && b.name) {\n    return (\n      a.name === b.name &&\n      a.hash === b.hash &&\n      isObjectEqual(a.query, b.query) &&\n      isObjectEqual(a.params, b.params)\n    )\n  } else {\n    return false\n  }\n}\n\nfunction isObjectEqual (a, b) {\n  if ( a === void 0 ) a = {};\n  if ( b === void 0 ) b = {};\n\n  var aKeys = Object.keys(a);\n  var bKeys = Object.keys(b);\n  if (aKeys.length !== bKeys.length) {\n    return false\n  }\n  return aKeys.every(function (key) { return String(a[key]) === String(b[key]); })\n}\n\nfunction isIncludedRoute (current, target) {\n  return (\n    current.path.replace(trailingSlashRE, '/').indexOf(\n      target.path.replace(trailingSlashRE, '/')\n    ) === 0 &&\n    (!target.hash || current.hash === target.hash) &&\n    queryIncludes(current.query, target.query)\n  )\n}\n\nfunction queryIncludes (current, target) {\n  for (var key in target) {\n    if (!(key in current)) {\n      return false\n    }\n  }\n  return true\n}\n\n/*  */\n\n// work around weird flow bug\nvar toTypes = [String, Object];\nvar eventTypes = [String, Array];\n\nvar Link = {\n  name: 'router-link',\n  props: {\n    to: {\n      type: toTypes,\n      required: true\n    },\n    tag: {\n      type: String,\n      default: 'a'\n    },\n    exact: Boolean,\n    append: Boolean,\n    replace: Boolean,\n    activeClass: String,\n    event: {\n      type: eventTypes,\n      default: 'click'\n    }\n  },\n  render: function render (h) {\n    var this$1 = this;\n\n    var router = this.$router;\n    var current = this.$route;\n    var ref = router.resolve(this.to, current, this.append);\n    var location = ref.location;\n    var route = ref.route;\n    var href = ref.href;\n    var classes = {};\n    var activeClass = this.activeClass || router.options.linkActiveClass || 'router-link-active';\n    var compareTarget = location.path ? createRoute(null, location) : route;\n    classes[activeClass] = this.exact\n      ? isSameRoute(current, compareTarget)\n      : isIncludedRoute(current, compareTarget);\n\n    var handler = function (e) {\n      if (guardEvent(e)) {\n        if (this$1.replace) {\n          router.replace(location);\n        } else {\n          router.push(location);\n        }\n      }\n    };\n\n    var on = { click: guardEvent };\n    if (Array.isArray(this.event)) {\n      this.event.forEach(function (e) { on[e] = handler; });\n    } else {\n      on[this.event] = handler;\n    }\n\n    var data = {\n      class: classes\n    };\n\n    if (this.tag === 'a') {\n      data.on = on;\n      data.attrs = { href: href };\n    } else {\n      // find the first <a> child and apply listener and href\n      var a = findAnchor(this.$slots.default);\n      if (a) {\n        // in case the <a> is a static node\n        a.isStatic = false;\n        var extend = _Vue.util.extend;\n        var aData = a.data = extend({}, a.data);\n        aData.on = on;\n        var aAttrs = a.data.attrs = extend({}, a.data.attrs);\n        aAttrs.href = href;\n      } else {\n        // doesn't have <a> child, apply listener to self\n        data.on = on;\n      }\n    }\n\n    return h(this.tag, data, this.$slots.default)\n  }\n};\n\nfunction guardEvent (e) {\n  // don't redirect with control keys\n  if (e.metaKey || e.ctrlKey || e.shiftKey) { return }\n  // don't redirect when preventDefault called\n  if (e.defaultPrevented) { return }\n  // don't redirect on right click\n  if (e.button !== undefined && e.button !== 0) { return }\n  // don't redirect if `target=\"_blank\"`\n  if (e.target && e.target.getAttribute) {\n    var target = e.target.getAttribute('target');\n    if (/\\b_blank\\b/i.test(target)) { return }\n  }\n  // this may be a Weex event which doesn't have this method\n  if (e.preventDefault) {\n    e.preventDefault();\n  }\n  return true\n}\n\nfunction findAnchor (children) {\n  if (children) {\n    var child;\n    for (var i = 0; i < children.length; i++) {\n      child = children[i];\n      if (child.tag === 'a') {\n        return child\n      }\n      if (child.children && (child = findAnchor(child.children))) {\n        return child\n      }\n    }\n  }\n}\n\nvar _Vue;\n\nfunction install (Vue) {\n  if (install.installed) { return }\n  install.installed = true;\n\n  _Vue = Vue;\n\n  Object.defineProperty(Vue.prototype, '$router', {\n    get: function get () { return this.$root._router }\n  });\n\n  Object.defineProperty(Vue.prototype, '$route', {\n    get: function get () { return this.$root._route }\n  });\n\n  Vue.mixin({\n    beforeCreate: function beforeCreate () {\n      if (this.$options.router) {\n        this._router = this.$options.router;\n        this._router.init(this);\n        Vue.util.defineReactive(this, '_route', this._router.history.current);\n      }\n    }\n  });\n\n  Vue.component('router-view', View);\n  Vue.component('router-link', Link);\n\n  var strats = Vue.config.optionMergeStrategies;\n  // use the same hook merging strategy for route hooks\n  strats.beforeRouteEnter = strats.beforeRouteLeave = strats.created;\n}\n\n/*  */\n\nvar inBrowser = typeof window !== 'undefined';\n\n/*  */\n\nfunction resolvePath (\n  relative,\n  base,\n  append\n) {\n  if (relative.charAt(0) === '/') {\n    return relative\n  }\n\n  if (relative.charAt(0) === '?' || relative.charAt(0) === '#') {\n    return base + relative\n  }\n\n  var stack = base.split('/');\n\n  // remove trailing segment if:\n  // - not appending\n  // - appending to trailing slash (last segment is empty)\n  if (!append || !stack[stack.length - 1]) {\n    stack.pop();\n  }\n\n  // resolve relative path\n  var segments = relative.replace(/^\\//, '').split('/');\n  for (var i = 0; i < segments.length; i++) {\n    var segment = segments[i];\n    if (segment === '.') {\n      continue\n    } else if (segment === '..') {\n      stack.pop();\n    } else {\n      stack.push(segment);\n    }\n  }\n\n  // ensure leading slash\n  if (stack[0] !== '') {\n    stack.unshift('');\n  }\n\n  return stack.join('/')\n}\n\nfunction parsePath (path) {\n  var hash = '';\n  var query = '';\n\n  var hashIndex = path.indexOf('#');\n  if (hashIndex >= 0) {\n    hash = path.slice(hashIndex);\n    path = path.slice(0, hashIndex);\n  }\n\n  var queryIndex = path.indexOf('?');\n  if (queryIndex >= 0) {\n    query = path.slice(queryIndex + 1);\n    path = path.slice(0, queryIndex);\n  }\n\n  return {\n    path: path,\n    query: query,\n    hash: hash\n  }\n}\n\nfunction cleanPath (path) {\n  return path.replace(/\\/\\//g, '/')\n}\n\n/*  */\n\nfunction createRouteMap (\n  routes,\n  oldPathMap,\n  oldNameMap\n) {\n  var pathMap = oldPathMap || Object.create(null);\n  var nameMap = oldNameMap || Object.create(null);\n\n  routes.forEach(function (route) {\n    addRouteRecord(pathMap, nameMap, route);\n  });\n\n  return {\n    pathMap: pathMap,\n    nameMap: nameMap\n  }\n}\n\nfunction addRouteRecord (\n  pathMap,\n  nameMap,\n  route,\n  parent,\n  matchAs\n) {\n  var path = route.path;\n  var name = route.name;\n  if (process.env.NODE_ENV !== 'production') {\n    assert(path != null, \"\\\"path\\\" is required in a route configuration.\");\n    assert(\n      typeof route.component !== 'string',\n      \"route config \\\"component\\\" for path: \" + (String(path || name)) + \" cannot be a \" +\n      \"string id. Use an actual component instead.\"\n    );\n  }\n\n  var record = {\n    path: normalizePath(path, parent),\n    components: route.components || { default: route.component },\n    instances: {},\n    name: name,\n    parent: parent,\n    matchAs: matchAs,\n    redirect: route.redirect,\n    beforeEnter: route.beforeEnter,\n    meta: route.meta || {},\n    props: route.props == null\n      ? {}\n      : route.components\n        ? route.props\n        : { default: route.props }\n  };\n\n  if (route.children) {\n    // Warn if route is named and has a default child route.\n    // If users navigate to this route by name, the default child will\n    // not be rendered (GH Issue #629)\n    if (process.env.NODE_ENV !== 'production') {\n      if (route.name && route.children.some(function (child) { return /^\\/?$/.test(child.path); })) {\n        warn(\n          false,\n          \"Named Route '\" + (route.name) + \"' has a default child route. \" +\n          \"When navigating to this named route (:to=\\\"{name: '\" + (route.name) + \"'\\\"), \" +\n          \"the default child route will not be rendered. Remove the name from \" +\n          \"this route and use the name of the default child route for named \" +\n          \"links instead.\"\n        );\n      }\n    }\n    route.children.forEach(function (child) {\n      var childMatchAs = matchAs\n        ? cleanPath((matchAs + \"/\" + (child.path)))\n        : undefined;\n      addRouteRecord(pathMap, nameMap, child, record, childMatchAs);\n    });\n  }\n\n  if (route.alias !== undefined) {\n    if (Array.isArray(route.alias)) {\n      route.alias.forEach(function (alias) {\n        var aliasRoute = {\n          path: alias,\n          children: route.children\n        };\n        addRouteRecord(pathMap, nameMap, aliasRoute, parent, record.path);\n      });\n    } else {\n      var aliasRoute = {\n        path: route.alias,\n        children: route.children\n      };\n      addRouteRecord(pathMap, nameMap, aliasRoute, parent, record.path);\n    }\n  }\n\n  if (!pathMap[record.path]) {\n    pathMap[record.path] = record;\n  }\n\n  if (name) {\n    if (!nameMap[name]) {\n      nameMap[name] = record;\n    } else if (process.env.NODE_ENV !== 'production' && !matchAs) {\n      warn(\n        false,\n        \"Duplicate named routes definition: \" +\n        \"{ name: \\\"\" + name + \"\\\", path: \\\"\" + (record.path) + \"\\\" }\"\n      );\n    }\n  }\n}\n\nfunction normalizePath (path, parent) {\n  path = path.replace(/\\/$/, '');\n  if (path[0] === '/') { return path }\n  if (parent == null) { return path }\n  return cleanPath(((parent.path) + \"/\" + path))\n}\n\nvar index$1 = Array.isArray || function (arr) {\n  return Object.prototype.toString.call(arr) == '[object Array]';\n};\n\nvar isarray = index$1;\n\n/**\n * Expose `pathToRegexp`.\n */\nvar index = pathToRegexp;\nvar parse_1 = parse;\nvar compile_1 = compile;\nvar tokensToFunction_1 = tokensToFunction;\nvar tokensToRegExp_1 = tokensToRegExp;\n\n/**\n * The main path matching regexp utility.\n *\n * @type {RegExp}\n */\nvar PATH_REGEXP = new RegExp([\n  // Match escaped characters that would otherwise appear in future matches.\n  // This allows the user to escape special characters that won't transform.\n  '(\\\\\\\\.)',\n  // Match Express-style parameters and un-named parameters with a prefix\n  // and optional suffixes. Matches appear as:\n  //\n  // \"/:test(\\\\d+)?\" => [\"/\", \"test\", \"\\d+\", undefined, \"?\", undefined]\n  // \"/route(\\\\d+)\"  => [undefined, undefined, undefined, \"\\d+\", undefined, undefined]\n  // \"/*\"            => [\"/\", undefined, undefined, undefined, undefined, \"*\"]\n  '([\\\\/.])?(?:(?:\\\\:(\\\\w+)(?:\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))?|\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))([+*?])?|(\\\\*))'\n].join('|'), 'g');\n\n/**\n * Parse a string for the raw tokens.\n *\n * @param  {string}  str\n * @param  {Object=} options\n * @return {!Array}\n */\nfunction parse (str, options) {\n  var tokens = [];\n  var key = 0;\n  var index = 0;\n  var path = '';\n  var defaultDelimiter = options && options.delimiter || '/';\n  var res;\n\n  while ((res = PATH_REGEXP.exec(str)) != null) {\n    var m = res[0];\n    var escaped = res[1];\n    var offset = res.index;\n    path += str.slice(index, offset);\n    index = offset + m.length;\n\n    // Ignore already escaped sequences.\n    if (escaped) {\n      path += escaped[1];\n      continue\n    }\n\n    var next = str[index];\n    var prefix = res[2];\n    var name = res[3];\n    var capture = res[4];\n    var group = res[5];\n    var modifier = res[6];\n    var asterisk = res[7];\n\n    // Push the current path onto the tokens.\n    if (path) {\n      tokens.push(path);\n      path = '';\n    }\n\n    var partial = prefix != null && next != null && next !== prefix;\n    var repeat = modifier === '+' || modifier === '*';\n    var optional = modifier === '?' || modifier === '*';\n    var delimiter = res[2] || defaultDelimiter;\n    var pattern = capture || group;\n\n    tokens.push({\n      name: name || key++,\n      prefix: prefix || '',\n      delimiter: delimiter,\n      optional: optional,\n      repeat: repeat,\n      partial: partial,\n      asterisk: !!asterisk,\n      pattern: pattern ? escapeGroup(pattern) : (asterisk ? '.*' : '[^' + escapeString(delimiter) + ']+?')\n    });\n  }\n\n  // Match any characters still remaining.\n  if (index < str.length) {\n    path += str.substr(index);\n  }\n\n  // If the path exists, push it onto the end.\n  if (path) {\n    tokens.push(path);\n  }\n\n  return tokens\n}\n\n/**\n * Compile a string to a template function for the path.\n *\n * @param  {string}             str\n * @param  {Object=}            options\n * @return {!function(Object=, Object=)}\n */\nfunction compile (str, options) {\n  return tokensToFunction(parse(str, options))\n}\n\n/**\n * Prettier encoding of URI path segments.\n *\n * @param  {string}\n * @return {string}\n */\nfunction encodeURIComponentPretty (str) {\n  return encodeURI(str).replace(/[\\/?#]/g, function (c) {\n    return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n  })\n}\n\n/**\n * Encode the asterisk parameter. Similar to `pretty`, but allows slashes.\n *\n * @param  {string}\n * @return {string}\n */\nfunction encodeAsterisk (str) {\n  return encodeURI(str).replace(/[?#]/g, function (c) {\n    return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n  })\n}\n\n/**\n * Expose a method for transforming tokens into the path function.\n */\nfunction tokensToFunction (tokens) {\n  // Compile all the tokens into regexps.\n  var matches = new Array(tokens.length);\n\n  // Compile all the patterns before compilation.\n  for (var i = 0; i < tokens.length; i++) {\n    if (typeof tokens[i] === 'object') {\n      matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$');\n    }\n  }\n\n  return function (obj, opts) {\n    var path = '';\n    var data = obj || {};\n    var options = opts || {};\n    var encode = options.pretty ? encodeURIComponentPretty : encodeURIComponent;\n\n    for (var i = 0; i < tokens.length; i++) {\n      var token = tokens[i];\n\n      if (typeof token === 'string') {\n        path += token;\n\n        continue\n      }\n\n      var value = data[token.name];\n      var segment;\n\n      if (value == null) {\n        if (token.optional) {\n          // Prepend partial segment prefixes.\n          if (token.partial) {\n            path += token.prefix;\n          }\n\n          continue\n        } else {\n          throw new TypeError('Expected \"' + token.name + '\" to be defined')\n        }\n      }\n\n      if (isarray(value)) {\n        if (!token.repeat) {\n          throw new TypeError('Expected \"' + token.name + '\" to not repeat, but received `' + JSON.stringify(value) + '`')\n        }\n\n        if (value.length === 0) {\n          if (token.optional) {\n            continue\n          } else {\n            throw new TypeError('Expected \"' + token.name + '\" to not be empty')\n          }\n        }\n\n        for (var j = 0; j < value.length; j++) {\n          segment = encode(value[j]);\n\n          if (!matches[i].test(segment)) {\n            throw new TypeError('Expected all \"' + token.name + '\" to match \"' + token.pattern + '\", but received `' + JSON.stringify(segment) + '`')\n          }\n\n          path += (j === 0 ? token.prefix : token.delimiter) + segment;\n        }\n\n        continue\n      }\n\n      segment = token.asterisk ? encodeAsterisk(value) : encode(value);\n\n      if (!matches[i].test(segment)) {\n        throw new TypeError('Expected \"' + token.name + '\" to match \"' + token.pattern + '\", but received \"' + segment + '\"')\n      }\n\n      path += token.prefix + segment;\n    }\n\n    return path\n  }\n}\n\n/**\n * Escape a regular expression string.\n *\n * @param  {string} str\n * @return {string}\n */\nfunction escapeString (str) {\n  return str.replace(/([.+*?=^!:${}()[\\]|\\/\\\\])/g, '\\\\$1')\n}\n\n/**\n * Escape the capturing group by escaping special characters and meaning.\n *\n * @param  {string} group\n * @return {string}\n */\nfunction escapeGroup (group) {\n  return group.replace(/([=!:$\\/()])/g, '\\\\$1')\n}\n\n/**\n * Attach the keys as a property of the regexp.\n *\n * @param  {!RegExp} re\n * @param  {Array}   keys\n * @return {!RegExp}\n */\nfunction attachKeys (re, keys) {\n  re.keys = keys;\n  return re\n}\n\n/**\n * Get the flags for a regexp from the options.\n *\n * @param  {Object} options\n * @return {string}\n */\nfunction flags (options) {\n  return options.sensitive ? '' : 'i'\n}\n\n/**\n * Pull out keys from a regexp.\n *\n * @param  {!RegExp} path\n * @param  {!Array}  keys\n * @return {!RegExp}\n */\nfunction regexpToRegexp (path, keys) {\n  // Use a negative lookahead to match only capturing groups.\n  var groups = path.source.match(/\\((?!\\?)/g);\n\n  if (groups) {\n    for (var i = 0; i < groups.length; i++) {\n      keys.push({\n        name: i,\n        prefix: null,\n        delimiter: null,\n        optional: false,\n        repeat: false,\n        partial: false,\n        asterisk: false,\n        pattern: null\n      });\n    }\n  }\n\n  return attachKeys(path, keys)\n}\n\n/**\n * Transform an array into a regexp.\n *\n * @param  {!Array}  path\n * @param  {Array}   keys\n * @param  {!Object} options\n * @return {!RegExp}\n */\nfunction arrayToRegexp (path, keys, options) {\n  var parts = [];\n\n  for (var i = 0; i < path.length; i++) {\n    parts.push(pathToRegexp(path[i], keys, options).source);\n  }\n\n  var regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options));\n\n  return attachKeys(regexp, keys)\n}\n\n/**\n * Create a path regexp from string input.\n *\n * @param  {string}  path\n * @param  {!Array}  keys\n * @param  {!Object} options\n * @return {!RegExp}\n */\nfunction stringToRegexp (path, keys, options) {\n  return tokensToRegExp(parse(path, options), keys, options)\n}\n\n/**\n * Expose a function for taking tokens and returning a RegExp.\n *\n * @param  {!Array}          tokens\n * @param  {(Array|Object)=} keys\n * @param  {Object=}         options\n * @return {!RegExp}\n */\nfunction tokensToRegExp (tokens, keys, options) {\n  if (!isarray(keys)) {\n    options = /** @type {!Object} */ (keys || options);\n    keys = [];\n  }\n\n  options = options || {};\n\n  var strict = options.strict;\n  var end = options.end !== false;\n  var route = '';\n\n  // Iterate over the tokens and create our regexp string.\n  for (var i = 0; i < tokens.length; i++) {\n    var token = tokens[i];\n\n    if (typeof token === 'string') {\n      route += escapeString(token);\n    } else {\n      var prefix = escapeString(token.prefix);\n      var capture = '(?:' + token.pattern + ')';\n\n      keys.push(token);\n\n      if (token.repeat) {\n        capture += '(?:' + prefix + capture + ')*';\n      }\n\n      if (token.optional) {\n        if (!token.partial) {\n          capture = '(?:' + prefix + '(' + capture + '))?';\n        } else {\n          capture = prefix + '(' + capture + ')?';\n        }\n      } else {\n        capture = prefix + '(' + capture + ')';\n      }\n\n      route += capture;\n    }\n  }\n\n  var delimiter = escapeString(options.delimiter || '/');\n  var endsWithDelimiter = route.slice(-delimiter.length) === delimiter;\n\n  // In non-strict mode we allow a slash at the end of match. If the path to\n  // match already ends with a slash, we remove it for consistency. The slash\n  // is valid at the end of a path match, not in the middle. This is important\n  // in non-ending mode, where \"/test/\" shouldn't match \"/test//route\".\n  if (!strict) {\n    route = (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) + '(?:' + delimiter + '(?=$))?';\n  }\n\n  if (end) {\n    route += '$';\n  } else {\n    // In non-ending mode, we need the capturing groups to match as much as\n    // possible by using a positive lookahead to the end or next path segment.\n    route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)';\n  }\n\n  return attachKeys(new RegExp('^' + route, flags(options)), keys)\n}\n\n/**\n * Normalize the given path string, returning a regular expression.\n *\n * An empty array can be passed in for the keys, which will hold the\n * placeholder key descriptions. For example, using `/user/:id`, `keys` will\n * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.\n *\n * @param  {(string|RegExp|Array)} path\n * @param  {(Array|Object)=}       keys\n * @param  {Object=}               options\n * @return {!RegExp}\n */\nfunction pathToRegexp (path, keys, options) {\n  if (!isarray(keys)) {\n    options = /** @type {!Object} */ (keys || options);\n    keys = [];\n  }\n\n  options = options || {};\n\n  if (path instanceof RegExp) {\n    return regexpToRegexp(path, /** @type {!Array} */ (keys))\n  }\n\n  if (isarray(path)) {\n    return arrayToRegexp(/** @type {!Array} */ (path), /** @type {!Array} */ (keys), options)\n  }\n\n  return stringToRegexp(/** @type {string} */ (path), /** @type {!Array} */ (keys), options)\n}\n\nindex.parse = parse_1;\nindex.compile = compile_1;\nindex.tokensToFunction = tokensToFunction_1;\nindex.tokensToRegExp = tokensToRegExp_1;\n\n/*  */\n\nvar regexpCache = Object.create(null);\n\nfunction getRouteRegex (path) {\n  var hit = regexpCache[path];\n  var keys, regexp;\n\n  if (hit) {\n    keys = hit.keys;\n    regexp = hit.regexp;\n  } else {\n    keys = [];\n    regexp = index(path, keys);\n    regexpCache[path] = { keys: keys, regexp: regexp };\n  }\n\n  return { keys: keys, regexp: regexp }\n}\n\nvar regexpCompileCache = Object.create(null);\n\nfunction fillParams (\n  path,\n  params,\n  routeMsg\n) {\n  try {\n    var filler =\n      regexpCompileCache[path] ||\n      (regexpCompileCache[path] = index.compile(path));\n    return filler(params || {}, { pretty: true })\n  } catch (e) {\n    if (process.env.NODE_ENV !== 'production') {\n      warn(false, (\"missing param for \" + routeMsg + \": \" + (e.message)));\n    }\n    return ''\n  }\n}\n\n/*  */\n\nfunction normalizeLocation (\n  raw,\n  current,\n  append\n) {\n  var next = typeof raw === 'string' ? { path: raw } : raw;\n  // named target\n  if (next.name || next._normalized) {\n    return next\n  }\n\n  // relative params\n  if (!next.path && next.params && current) {\n    next = assign({}, next);\n    next._normalized = true;\n    var params = assign(assign({}, current.params), next.params);\n    if (current.name) {\n      next.name = current.name;\n      next.params = params;\n    } else if (current.matched) {\n      var rawPath = current.matched[current.matched.length - 1].path;\n      next.path = fillParams(rawPath, params, (\"path \" + (current.path)));\n    } else if (process.env.NODE_ENV !== 'production') {\n      warn(false, \"relative params navigation requires a current route.\");\n    }\n    return next\n  }\n\n  var parsedPath = parsePath(next.path || '');\n  var basePath = (current && current.path) || '/';\n  var path = parsedPath.path\n    ? resolvePath(parsedPath.path, basePath, append || next.append)\n    : (current && current.path) || '/';\n  var query = resolveQuery(parsedPath.query, next.query);\n  var hash = next.hash || parsedPath.hash;\n  if (hash && hash.charAt(0) !== '#') {\n    hash = \"#\" + hash;\n  }\n\n  return {\n    _normalized: true,\n    path: path,\n    query: query,\n    hash: hash\n  }\n}\n\nfunction assign (a, b) {\n  for (var key in b) {\n    a[key] = b[key];\n  }\n  return a\n}\n\n/*  */\n\nfunction createMatcher (routes) {\n  var ref = createRouteMap(routes);\n  var pathMap = ref.pathMap;\n  var nameMap = ref.nameMap;\n\n  function addRoutes (routes) {\n    createRouteMap(routes, pathMap, nameMap);\n  }\n\n  function match (\n    raw,\n    currentRoute,\n    redirectedFrom\n  ) {\n    var location = normalizeLocation(raw, currentRoute);\n    var name = location.name;\n\n    if (name) {\n      var record = nameMap[name];\n      if (process.env.NODE_ENV !== 'production') {\n        warn(record, (\"Route with name '\" + name + \"' does not exist\"));\n      }\n      var paramNames = getRouteRegex(record.path).keys\n        .filter(function (key) { return !key.optional; })\n        .map(function (key) { return key.name; });\n\n      if (typeof location.params !== 'object') {\n        location.params = {};\n      }\n\n      if (currentRoute && typeof currentRoute.params === 'object') {\n        for (var key in currentRoute.params) {\n          if (!(key in location.params) && paramNames.indexOf(key) > -1) {\n            location.params[key] = currentRoute.params[key];\n          }\n        }\n      }\n\n      if (record) {\n        location.path = fillParams(record.path, location.params, (\"named route \\\"\" + name + \"\\\"\"));\n        return _createRoute(record, location, redirectedFrom)\n      }\n    } else if (location.path) {\n      location.params = {};\n      for (var path in pathMap) {\n        if (matchRoute(path, location.params, location.path)) {\n          return _createRoute(pathMap[path], location, redirectedFrom)\n        }\n      }\n    }\n    // no match\n    return _createRoute(null, location)\n  }\n\n  function redirect (\n    record,\n    location\n  ) {\n    var originalRedirect = record.redirect;\n    var redirect = typeof originalRedirect === 'function'\n        ? originalRedirect(createRoute(record, location))\n        : originalRedirect;\n\n    if (typeof redirect === 'string') {\n      redirect = { path: redirect };\n    }\n\n    if (!redirect || typeof redirect !== 'object') {\n      process.env.NODE_ENV !== 'production' && warn(\n        false, (\"invalid redirect option: \" + (JSON.stringify(redirect)))\n      );\n      return _createRoute(null, location)\n    }\n\n    var re = redirect;\n    var name = re.name;\n    var path = re.path;\n    var query = location.query;\n    var hash = location.hash;\n    var params = location.params;\n    query = re.hasOwnProperty('query') ? re.query : query;\n    hash = re.hasOwnProperty('hash') ? re.hash : hash;\n    params = re.hasOwnProperty('params') ? re.params : params;\n\n    if (name) {\n      // resolved named direct\n      var targetRecord = nameMap[name];\n      if (process.env.NODE_ENV !== 'production') {\n        assert(targetRecord, (\"redirect failed: named route \\\"\" + name + \"\\\" not found.\"));\n      }\n      return match({\n        _normalized: true,\n        name: name,\n        query: query,\n        hash: hash,\n        params: params\n      }, undefined, location)\n    } else if (path) {\n      // 1. resolve relative redirect\n      var rawPath = resolveRecordPath(path, record);\n      // 2. resolve params\n      var resolvedPath = fillParams(rawPath, params, (\"redirect route with path \\\"\" + rawPath + \"\\\"\"));\n      // 3. rematch with existing query and hash\n      return match({\n        _normalized: true,\n        path: resolvedPath,\n        query: query,\n        hash: hash\n      }, undefined, location)\n    } else {\n      warn(false, (\"invalid redirect option: \" + (JSON.stringify(redirect))));\n      return _createRoute(null, location)\n    }\n  }\n\n  function alias (\n    record,\n    location,\n    matchAs\n  ) {\n    var aliasedPath = fillParams(matchAs, location.params, (\"aliased route with path \\\"\" + matchAs + \"\\\"\"));\n    var aliasedMatch = match({\n      _normalized: true,\n      path: aliasedPath\n    });\n    if (aliasedMatch) {\n      var matched = aliasedMatch.matched;\n      var aliasedRecord = matched[matched.length - 1];\n      location.params = aliasedMatch.params;\n      return _createRoute(aliasedRecord, location)\n    }\n    return _createRoute(null, location)\n  }\n\n  function _createRoute (\n    record,\n    location,\n    redirectedFrom\n  ) {\n    if (record && record.redirect) {\n      return redirect(record, redirectedFrom || location)\n    }\n    if (record && record.matchAs) {\n      return alias(record, location, record.matchAs)\n    }\n    return createRoute(record, location, redirectedFrom)\n  }\n\n  return {\n    match: match,\n    addRoutes: addRoutes\n  }\n}\n\nfunction matchRoute (\n  path,\n  params,\n  pathname\n) {\n  var ref = getRouteRegex(path);\n  var regexp = ref.regexp;\n  var keys = ref.keys;\n  var m = pathname.match(regexp);\n\n  if (!m) {\n    return false\n  } else if (!params) {\n    return true\n  }\n\n  for (var i = 1, len = m.length; i < len; ++i) {\n    var key = keys[i - 1];\n    var val = typeof m[i] === 'string' ? decodeURIComponent(m[i]) : m[i];\n    if (key) { params[key.name] = val; }\n  }\n\n  return true\n}\n\nfunction resolveRecordPath (path, record) {\n  return resolvePath(path, record.parent ? record.parent.path : '/', true)\n}\n\n/*  */\n\n\nvar positionStore = Object.create(null);\n\nfunction setupScroll () {\n  window.addEventListener('popstate', function (e) {\n    saveScrollPosition();\n    if (e.state && e.state.key) {\n      setStateKey(e.state.key);\n    }\n  });\n}\n\nfunction handleScroll (\n  router,\n  to,\n  from,\n  isPop\n) {\n  if (!router.app) {\n    return\n  }\n\n  var behavior = router.options.scrollBehavior;\n  if (!behavior) {\n    return\n  }\n\n  if (process.env.NODE_ENV !== 'production') {\n    assert(typeof behavior === 'function', \"scrollBehavior must be a function\");\n  }\n\n  // wait until re-render finishes before scrolling\n  router.app.$nextTick(function () {\n    var position = getScrollPosition();\n    var shouldScroll = behavior(to, from, isPop ? position : null);\n    if (!shouldScroll) {\n      return\n    }\n    var isObject = typeof shouldScroll === 'object';\n    if (isObject && typeof shouldScroll.selector === 'string') {\n      var el = document.querySelector(shouldScroll.selector);\n      if (el) {\n        position = getElementPosition(el);\n      } else if (isValidPosition(shouldScroll)) {\n        position = normalizePosition(shouldScroll);\n      }\n    } else if (isObject && isValidPosition(shouldScroll)) {\n      position = normalizePosition(shouldScroll);\n    }\n\n    if (position) {\n      window.scrollTo(position.x, position.y);\n    }\n  });\n}\n\nfunction saveScrollPosition () {\n  var key = getStateKey();\n  if (key) {\n    positionStore[key] = {\n      x: window.pageXOffset,\n      y: window.pageYOffset\n    };\n  }\n}\n\nfunction getScrollPosition () {\n  var key = getStateKey();\n  if (key) {\n    return positionStore[key]\n  }\n}\n\nfunction getElementPosition (el) {\n  var docRect = document.documentElement.getBoundingClientRect();\n  var elRect = el.getBoundingClientRect();\n  return {\n    x: elRect.left - docRect.left,\n    y: elRect.top - docRect.top\n  }\n}\n\nfunction isValidPosition (obj) {\n  return isNumber(obj.x) || isNumber(obj.y)\n}\n\nfunction normalizePosition (obj) {\n  return {\n    x: isNumber(obj.x) ? obj.x : window.pageXOffset,\n    y: isNumber(obj.y) ? obj.y : window.pageYOffset\n  }\n}\n\nfunction isNumber (v) {\n  return typeof v === 'number'\n}\n\n/*  */\n\nvar supportsPushState = inBrowser && (function () {\n  var ua = window.navigator.userAgent;\n\n  if (\n    (ua.indexOf('Android 2.') !== -1 || ua.indexOf('Android 4.0') !== -1) &&\n    ua.indexOf('Mobile Safari') !== -1 &&\n    ua.indexOf('Chrome') === -1 &&\n    ua.indexOf('Windows Phone') === -1\n  ) {\n    return false\n  }\n\n  return window.history && 'pushState' in window.history\n})();\n\n// use User Timing api (if present) for more accurate key precision\nvar Time = inBrowser && window.performance && window.performance.now\n  ? window.performance\n  : Date;\n\nvar _key = genKey();\n\nfunction genKey () {\n  return Time.now().toFixed(3)\n}\n\nfunction getStateKey () {\n  return _key\n}\n\nfunction setStateKey (key) {\n  _key = key;\n}\n\nfunction pushState (url, replace) {\n  saveScrollPosition();\n  // try...catch the pushState call to get around Safari\n  // DOM Exception 18 where it limits to 100 pushState calls\n  var history = window.history;\n  try {\n    if (replace) {\n      history.replaceState({ key: _key }, '', url);\n    } else {\n      _key = genKey();\n      history.pushState({ key: _key }, '', url);\n    }\n  } catch (e) {\n    window.location[replace ? 'replace' : 'assign'](url);\n  }\n}\n\nfunction replaceState (url) {\n  pushState(url, true);\n}\n\n/*  */\n\nfunction runQueue (queue, fn, cb) {\n  var step = function (index) {\n    if (index >= queue.length) {\n      cb();\n    } else {\n      if (queue[index]) {\n        fn(queue[index], function () {\n          step(index + 1);\n        });\n      } else {\n        step(index + 1);\n      }\n    }\n  };\n  step(0);\n}\n\n/*  */\n\n\nvar History = function History (router, base) {\n  this.router = router;\n  this.base = normalizeBase(base);\n  // start with a route object that stands for \"nowhere\"\n  this.current = START;\n  this.pending = null;\n  this.ready = false;\n  this.readyCbs = [];\n};\n\nHistory.prototype.listen = function listen (cb) {\n  this.cb = cb;\n};\n\nHistory.prototype.onReady = function onReady (cb) {\n  if (this.ready) {\n    cb();\n  } else {\n    this.readyCbs.push(cb);\n  }\n};\n\nHistory.prototype.transitionTo = function transitionTo (location, onComplete, onAbort) {\n    var this$1 = this;\n\n  var route = this.router.match(location, this.current);\n  this.confirmTransition(route, function () {\n    this$1.updateRoute(route);\n    onComplete && onComplete(route);\n    this$1.ensureURL();\n\n    // fire ready cbs once\n    if (!this$1.ready) {\n      this$1.ready = true;\n      this$1.readyCbs.forEach(function (cb) {\n        cb(route);\n      });\n    }\n  }, onAbort);\n};\n\nHistory.prototype.confirmTransition = function confirmTransition (route, onComplete, onAbort) {\n    var this$1 = this;\n\n  var current = this.current;\n  var abort = function () { onAbort && onAbort(); };\n  if (\n    isSameRoute(route, current) &&\n    // in the case the route map has been dynamically appended to\n    route.matched.length === current.matched.length\n  ) {\n    this.ensureURL();\n    return abort()\n  }\n\n  var ref = resolveQueue(this.current.matched, route.matched);\n    var updated = ref.updated;\n    var deactivated = ref.deactivated;\n    var activated = ref.activated;\n\n  var queue = [].concat(\n    // in-component leave guards\n    extractLeaveGuards(deactivated),\n    // global before hooks\n    this.router.beforeHooks,\n    // in-component update hooks\n    extractUpdateHooks(updated),\n    // in-config enter guards\n    activated.map(function (m) { return m.beforeEnter; }),\n    // async components\n    resolveAsyncComponents(activated)\n  );\n\n  this.pending = route;\n  var iterator = function (hook, next) {\n    if (this$1.pending !== route) {\n      return abort()\n    }\n    hook(route, current, function (to) {\n      if (to === false) {\n        // next(false) -> abort navigation, ensure current URL\n        this$1.ensureURL(true);\n        abort();\n      } else if (typeof to === 'string' || typeof to === 'object') {\n        // next('/') or next({ path: '/' }) -> redirect\n        (typeof to === 'object' && to.replace) ? this$1.replace(to) : this$1.push(to);\n        abort();\n      } else {\n        // confirm transition and pass on the value\n        next(to);\n      }\n    });\n  };\n\n  runQueue(queue, iterator, function () {\n    var postEnterCbs = [];\n    var isValid = function () { return this$1.current === route; };\n    var enterGuards = extractEnterGuards(activated, postEnterCbs, isValid);\n    // wait until async components are resolved before\n    // extracting in-component enter guards\n    runQueue(enterGuards, iterator, function () {\n      if (this$1.pending !== route) {\n        return abort()\n      }\n      this$1.pending = null;\n      onComplete(route);\n      if (this$1.router.app) {\n        this$1.router.app.$nextTick(function () {\n          postEnterCbs.forEach(function (cb) { return cb(); });\n        });\n      }\n    });\n  });\n};\n\nHistory.prototype.updateRoute = function updateRoute (route) {\n  var prev = this.current;\n  this.current = route;\n  this.cb && this.cb(route);\n  this.router.afterHooks.forEach(function (hook) {\n    hook && hook(route, prev);\n  });\n};\n\nfunction normalizeBase (base) {\n  if (!base) {\n    if (inBrowser) {\n      // respect <base> tag\n      var baseEl = document.querySelector('base');\n      base = baseEl ? baseEl.getAttribute('href') : '/';\n    } else {\n      base = '/';\n    }\n  }\n  // make sure there's the starting slash\n  if (base.charAt(0) !== '/') {\n    base = '/' + base;\n  }\n  // remove trailing slash\n  return base.replace(/\\/$/, '')\n}\n\nfunction resolveQueue (\n  current,\n  next\n) {\n  var i;\n  var max = Math.max(current.length, next.length);\n  for (i = 0; i < max; i++) {\n    if (current[i] !== next[i]) {\n      break\n    }\n  }\n  return {\n    updated: next.slice(0, i),\n    activated: next.slice(i),\n    deactivated: current.slice(i)\n  }\n}\n\nfunction extractGuards (\n  records,\n  name,\n  bind,\n  reverse\n) {\n  var guards = flatMapComponents(records, function (def, instance, match, key) {\n    var guard = extractGuard(def, name);\n    if (guard) {\n      return Array.isArray(guard)\n        ? guard.map(function (guard) { return bind(guard, instance, match, key); })\n        : bind(guard, instance, match, key)\n    }\n  });\n  return flatten(reverse ? guards.reverse() : guards)\n}\n\nfunction extractGuard (\n  def,\n  key\n) {\n  if (typeof def !== 'function') {\n    // extend now so that global mixins are applied.\n    def = _Vue.extend(def);\n  }\n  return def.options[key]\n}\n\nfunction extractLeaveGuards (deactivated) {\n  return extractGuards(deactivated, 'beforeRouteLeave', bindGuard, true)\n}\n\nfunction extractUpdateHooks (updated) {\n  return extractGuards(updated, 'beforeRouteUpdate', bindGuard)\n}\n\nfunction bindGuard (guard, instance) {\n  return function boundRouteGuard () {\n    return guard.apply(instance, arguments)\n  }\n}\n\nfunction extractEnterGuards (\n  activated,\n  cbs,\n  isValid\n) {\n  return extractGuards(activated, 'beforeRouteEnter', function (guard, _, match, key) {\n    return bindEnterGuard(guard, match, key, cbs, isValid)\n  })\n}\n\nfunction bindEnterGuard (\n  guard,\n  match,\n  key,\n  cbs,\n  isValid\n) {\n  return function routeEnterGuard (to, from, next) {\n    return guard(to, from, function (cb) {\n      next(cb);\n      if (typeof cb === 'function') {\n        cbs.push(function () {\n          // #750\n          // if a router-view is wrapped with an out-in transition,\n          // the instance may not have been registered at this time.\n          // we will need to poll for registration until current route\n          // is no longer valid.\n          poll(cb, match.instances, key, isValid);\n        });\n      }\n    })\n  }\n}\n\nfunction poll (\n  cb, // somehow flow cannot infer this is a function\n  instances,\n  key,\n  isValid\n) {\n  if (instances[key]) {\n    cb(instances[key]);\n  } else if (isValid()) {\n    setTimeout(function () {\n      poll(cb, instances, key, isValid);\n    }, 16);\n  }\n}\n\nfunction resolveAsyncComponents (matched) {\n  return flatMapComponents(matched, function (def, _, match, key) {\n    // if it's a function and doesn't have Vue options attached,\n    // assume it's an async component resolve function.\n    // we are not using Vue's default async resolving mechanism because\n    // we want to halt the navigation until the incoming component has been\n    // resolved.\n    if (typeof def === 'function' && !def.options) {\n      return function (to, from, next) {\n        var resolve = once(function (resolvedDef) {\n          match.components[key] = resolvedDef;\n          next();\n        });\n\n        var reject = once(function (reason) {\n          warn(false, (\"Failed to resolve async component \" + key + \": \" + reason));\n          next(false);\n        });\n\n        var res = def(resolve, reject);\n        if (res && typeof res.then === 'function') {\n          res.then(resolve, reject);\n        }\n      }\n    }\n  })\n}\n\nfunction flatMapComponents (\n  matched,\n  fn\n) {\n  return flatten(matched.map(function (m) {\n    return Object.keys(m.components).map(function (key) { return fn(\n      m.components[key],\n      m.instances[key],\n      m, key\n    ); })\n  }))\n}\n\nfunction flatten (arr) {\n  return Array.prototype.concat.apply([], arr)\n}\n\n// in Webpack 2, require.ensure now also returns a Promise\n// so the resolve/reject functions may get called an extra time\n// if the user uses an arrow function shorthand that happens to\n// return that Promise.\nfunction once (fn) {\n  var called = false;\n  return function () {\n    if (called) { return }\n    called = true;\n    return fn.apply(this, arguments)\n  }\n}\n\n/*  */\n\n\nvar HTML5History = (function (History$$1) {\n  function HTML5History (router, base) {\n    var this$1 = this;\n\n    History$$1.call(this, router, base);\n\n    var expectScroll = router.options.scrollBehavior;\n\n    if (expectScroll) {\n      setupScroll();\n    }\n\n    window.addEventListener('popstate', function (e) {\n      this$1.transitionTo(getLocation(this$1.base), function (route) {\n        if (expectScroll) {\n          handleScroll(router, route, this$1.current, true);\n        }\n      });\n    });\n  }\n\n  if ( History$$1 ) HTML5History.__proto__ = History$$1;\n  HTML5History.prototype = Object.create( History$$1 && History$$1.prototype );\n  HTML5History.prototype.constructor = HTML5History;\n\n  HTML5History.prototype.go = function go (n) {\n    window.history.go(n);\n  };\n\n  HTML5History.prototype.push = function push (location, onComplete, onAbort) {\n    var this$1 = this;\n\n    this.transitionTo(location, function (route) {\n      pushState(cleanPath(this$1.base + route.fullPath));\n      handleScroll(this$1.router, route, this$1.current, false);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  HTML5History.prototype.replace = function replace (location, onComplete, onAbort) {\n    var this$1 = this;\n\n    this.transitionTo(location, function (route) {\n      replaceState(cleanPath(this$1.base + route.fullPath));\n      handleScroll(this$1.router, route, this$1.current, false);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  HTML5History.prototype.ensureURL = function ensureURL (push) {\n    if (getLocation(this.base) !== this.current.fullPath) {\n      var current = cleanPath(this.base + this.current.fullPath);\n      push ? pushState(current) : replaceState(current);\n    }\n  };\n\n  HTML5History.prototype.getCurrentLocation = function getCurrentLocation () {\n    return getLocation(this.base)\n  };\n\n  return HTML5History;\n}(History));\n\nfunction getLocation (base) {\n  var path = window.location.pathname;\n  if (base && path.indexOf(base) === 0) {\n    path = path.slice(base.length);\n  }\n  return (path || '/') + window.location.search + window.location.hash\n}\n\n/*  */\n\n\nvar HashHistory = (function (History$$1) {\n  function HashHistory (router, base, fallback) {\n    History$$1.call(this, router, base);\n    // check history fallback deeplinking\n    if (fallback && checkFallback(this.base)) {\n      return\n    }\n    ensureSlash();\n  }\n\n  if ( History$$1 ) HashHistory.__proto__ = History$$1;\n  HashHistory.prototype = Object.create( History$$1 && History$$1.prototype );\n  HashHistory.prototype.constructor = HashHistory;\n\n  // this is delayed until the app mounts\n  // to avoid the hashchange listener being fired too early\n  HashHistory.prototype.setupListeners = function setupListeners () {\n    var this$1 = this;\n\n    window.addEventListener('hashchange', function () {\n      if (!ensureSlash()) {\n        return\n      }\n      this$1.transitionTo(getHash(), function (route) {\n        replaceHash(route.fullPath);\n      });\n    });\n  };\n\n  HashHistory.prototype.push = function push (location, onComplete, onAbort) {\n    this.transitionTo(location, function (route) {\n      pushHash(route.fullPath);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  HashHistory.prototype.replace = function replace (location, onComplete, onAbort) {\n    this.transitionTo(location, function (route) {\n      replaceHash(route.fullPath);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  HashHistory.prototype.go = function go (n) {\n    window.history.go(n);\n  };\n\n  HashHistory.prototype.ensureURL = function ensureURL (push) {\n    var current = this.current.fullPath;\n    if (getHash() !== current) {\n      push ? pushHash(current) : replaceHash(current);\n    }\n  };\n\n  HashHistory.prototype.getCurrentLocation = function getCurrentLocation () {\n    return getHash()\n  };\n\n  return HashHistory;\n}(History));\n\nfunction checkFallback (base) {\n  var location = getLocation(base);\n  if (!/^\\/#/.test(location)) {\n    window.location.replace(\n      cleanPath(base + '/#' + location)\n    );\n    return true\n  }\n}\n\nfunction ensureSlash () {\n  var path = getHash();\n  if (path.charAt(0) === '/') {\n    return true\n  }\n  replaceHash('/' + path);\n  return false\n}\n\nfunction getHash () {\n  // We can't use window.location.hash here because it's not\n  // consistent across browsers - Firefox will pre-decode it!\n  var href = window.location.href;\n  var index = href.indexOf('#');\n  return index === -1 ? '' : href.slice(index + 1)\n}\n\nfunction pushHash (path) {\n  window.location.hash = path;\n}\n\nfunction replaceHash (path) {\n  var i = window.location.href.indexOf('#');\n  window.location.replace(\n    window.location.href.slice(0, i >= 0 ? i : 0) + '#' + path\n  );\n}\n\n/*  */\n\n\nvar AbstractHistory = (function (History$$1) {\n  function AbstractHistory (router, base) {\n    History$$1.call(this, router, base);\n    this.stack = [];\n    this.index = -1;\n  }\n\n  if ( History$$1 ) AbstractHistory.__proto__ = History$$1;\n  AbstractHistory.prototype = Object.create( History$$1 && History$$1.prototype );\n  AbstractHistory.prototype.constructor = AbstractHistory;\n\n  AbstractHistory.prototype.push = function push (location, onComplete, onAbort) {\n    var this$1 = this;\n\n    this.transitionTo(location, function (route) {\n      this$1.stack = this$1.stack.slice(0, this$1.index + 1).concat(route);\n      this$1.index++;\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  AbstractHistory.prototype.replace = function replace (location, onComplete, onAbort) {\n    var this$1 = this;\n\n    this.transitionTo(location, function (route) {\n      this$1.stack = this$1.stack.slice(0, this$1.index).concat(route);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  AbstractHistory.prototype.go = function go (n) {\n    var this$1 = this;\n\n    var targetIndex = this.index + n;\n    if (targetIndex < 0 || targetIndex >= this.stack.length) {\n      return\n    }\n    var route = this.stack[targetIndex];\n    this.confirmTransition(route, function () {\n      this$1.index = targetIndex;\n      this$1.updateRoute(route);\n    });\n  };\n\n  AbstractHistory.prototype.getCurrentLocation = function getCurrentLocation () {\n    var current = this.stack[this.stack.length - 1];\n    return current ? current.fullPath : '/'\n  };\n\n  AbstractHistory.prototype.ensureURL = function ensureURL () {\n    // noop\n  };\n\n  return AbstractHistory;\n}(History));\n\n/*  */\n\nvar VueRouter = function VueRouter (options) {\n  if ( options === void 0 ) options = {};\n\n  this.app = null;\n  this.apps = [];\n  this.options = options;\n  this.beforeHooks = [];\n  this.afterHooks = [];\n  this.matcher = createMatcher(options.routes || []);\n\n  var mode = options.mode || 'hash';\n  this.fallback = mode === 'history' && !supportsPushState;\n  if (this.fallback) {\n    mode = 'hash';\n  }\n  if (!inBrowser) {\n    mode = 'abstract';\n  }\n  this.mode = mode;\n\n  switch (mode) {\n    case 'history':\n      this.history = new HTML5History(this, options.base);\n      break\n    case 'hash':\n      this.history = new HashHistory(this, options.base, this.fallback);\n      break\n    case 'abstract':\n      this.history = new AbstractHistory(this, options.base);\n      break\n    default:\n      if (process.env.NODE_ENV !== 'production') {\n        assert(false, (\"invalid mode: \" + mode));\n      }\n  }\n};\n\nvar prototypeAccessors = { currentRoute: {} };\n\nVueRouter.prototype.match = function match (\n  raw,\n  current,\n  redirectedFrom\n) {\n  return this.matcher.match(raw, current, redirectedFrom)\n};\n\nprototypeAccessors.currentRoute.get = function () {\n  return this.history && this.history.current\n};\n\nVueRouter.prototype.init = function init (app /* Vue component instance */) {\n    var this$1 = this;\n\n  process.env.NODE_ENV !== 'production' && assert(\n    install.installed,\n    \"not installed. Make sure to call `Vue.use(VueRouter)` \" +\n    \"before creating root instance.\"\n  );\n\n  this.apps.push(app);\n\n  // main app already initialized.\n  if (this.app) {\n    return\n  }\n\n  this.app = app;\n\n  var history = this.history;\n\n  if (history instanceof HTML5History) {\n    history.transitionTo(history.getCurrentLocation());\n  } else if (history instanceof HashHistory) {\n    var setupHashListener = function () {\n      history.setupListeners();\n    };\n    history.transitionTo(\n      history.getCurrentLocation(),\n      setupHashListener,\n      setupHashListener\n    );\n  }\n\n  history.listen(function (route) {\n    this$1.apps.forEach(function (app) {\n      app._route = route;\n    });\n  });\n};\n\nVueRouter.prototype.beforeEach = function beforeEach (fn) {\n  this.beforeHooks.push(fn);\n};\n\nVueRouter.prototype.afterEach = function afterEach (fn) {\n  this.afterHooks.push(fn);\n};\n\nVueRouter.prototype.onReady = function onReady (cb) {\n  this.history.onReady(cb);\n};\n\nVueRouter.prototype.push = function push (location, onComplete, onAbort) {\n  this.history.push(location, onComplete, onAbort);\n};\n\nVueRouter.prototype.replace = function replace (location, onComplete, onAbort) {\n  this.history.replace(location, onComplete, onAbort);\n};\n\nVueRouter.prototype.go = function go (n) {\n  this.history.go(n);\n};\n\nVueRouter.prototype.back = function back () {\n  this.go(-1);\n};\n\nVueRouter.prototype.forward = function forward () {\n  this.go(1);\n};\n\nVueRouter.prototype.getMatchedComponents = function getMatchedComponents (to) {\n  var route = to\n    ? this.resolve(to).route\n    : this.currentRoute;\n  if (!route) {\n    return []\n  }\n  return [].concat.apply([], route.matched.map(function (m) {\n    return Object.keys(m.components).map(function (key) {\n      return m.components[key]\n    })\n  }))\n};\n\nVueRouter.prototype.resolve = function resolve (\n  to,\n  current,\n  append\n) {\n  var location = normalizeLocation(to, current || this.history.current, append);\n  var route = this.match(location, current);\n  var fullPath = route.redirectedFrom || route.fullPath;\n  var base = this.history.base;\n  var href = createHref(base, fullPath, this.mode);\n  return {\n    location: location,\n    route: route,\n    href: href,\n    // for backwards compat\n    normalizedTo: location,\n    resolved: route\n  }\n};\n\nVueRouter.prototype.addRoutes = function addRoutes (routes) {\n  this.matcher.addRoutes(routes);\n  if (this.history.current !== START) {\n    this.history.transitionTo(this.history.getCurrentLocation());\n  }\n};\n\nObject.defineProperties( VueRouter.prototype, prototypeAccessors );\n\nfunction createHref (base, fullPath, mode) {\n  var path = mode === 'hash' ? '#' + fullPath : fullPath;\n  return base ? cleanPath(base + '/' + path) : path\n}\n\nVueRouter.install = install;\nVueRouter.version = '2.2.1';\n\nif (inBrowser && window.Vue) {\n  window.Vue.use(VueRouter);\n}\n\nmodule.exports = VueRouter;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/vue-router/dist/vue-router.common.js\n// module id = 132\n// module chunks = 0","/**\n * Translates the list format produced by css-loader into something\n * easier to manipulate.\n */\nmodule.exports = function listToStyles (parentId, list) {\n  var styles = []\n  var newStyles = {}\n  for (var i = 0; i < list.length; i++) {\n    var item = list[i]\n    var id = item[0]\n    var css = item[1]\n    var media = item[2]\n    var sourceMap = item[3]\n    var part = {\n      id: parentId + ':' + i,\n      css: css,\n      media: media,\n      sourceMap: sourceMap\n    }\n    if (!newStyles[id]) {\n      styles.push(newStyles[id] = { id: id, parts: [part] })\n    } else {\n      newStyles[id].parts.push(part)\n    }\n  }\n  return styles\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/vue-style-loader/lib/listToStyles.js\n// module id = 133\n// module chunks = 0","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\tif(!module.children) module.children = [];\r\n\t\tObject.defineProperty(module, \"loaded\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.l;\r\n\t\t\t}\r\n\t\t});\r\n\t\tObject.defineProperty(module, \"id\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.i;\r\n\t\t\t}\r\n\t\t});\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 = 134\n// module chunks = 0","/*\r\n\tMIT License http://www.opensource.org/licenses/mit-license.php\r\n\tAuthor Tobias Koppers @sokra\r\n*/\r\n// css base code, injected by the css-loader\r\nmodule.exports = function() {\r\n\tvar list = [];\r\n\r\n\t// return the list of modules as css string\r\n\tlist.toString = function toString() {\r\n\t\tvar result = [];\r\n\t\tfor(var i = 0; i < this.length; i++) {\r\n\t\t\tvar item = this[i];\r\n\t\t\tif(item[2]) {\r\n\t\t\t\tresult.push(\"@media \" + item[2] + \"{\" + item[1] + \"}\");\r\n\t\t\t} else {\r\n\t\t\t\tresult.push(item[1]);\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn result.join(\"\");\r\n\t};\r\n\r\n\t// import a list of modules into the list\r\n\tlist.i = function(modules, mediaQuery) {\r\n\t\tif(typeof modules === \"string\")\r\n\t\t\tmodules = [[null, modules, \"\"]];\r\n\t\tvar alreadyImportedModules = {};\r\n\t\tfor(var i = 0; i < this.length; i++) {\r\n\t\t\tvar id = this[i][0];\r\n\t\t\tif(typeof id === \"number\")\r\n\t\t\t\talreadyImportedModules[id] = true;\r\n\t\t}\r\n\t\tfor(i = 0; i < modules.length; i++) {\r\n\t\t\tvar item = modules[i];\r\n\t\t\t// skip already imported module\r\n\t\t\t// this implementation is not 100% perfect for weird media query combinations\r\n\t\t\t//  when a module is imported multiple times with different media queries.\r\n\t\t\t//  I hope this will never occur (Hey this way we have smaller bundles)\r\n\t\t\tif(typeof item[0] !== \"number\" || !alreadyImportedModules[item[0]]) {\r\n\t\t\t\tif(mediaQuery && !item[2]) {\r\n\t\t\t\t\titem[2] = mediaQuery;\r\n\t\t\t\t} else if(mediaQuery) {\r\n\t\t\t\t\titem[2] = \"(\" + item[2] + \") and (\" + mediaQuery + \")\";\r\n\t\t\t\t}\r\n\t\t\t\tlist.push(item);\r\n\t\t\t}\r\n\t\t}\r\n\t};\r\n\treturn list;\r\n};\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/css-loader/lib/css-base.js\n// module id = 137\n// module chunks = 0","/*\n  MIT License http://www.opensource.org/licenses/mit-license.php\n  Author Tobias Koppers @sokra\n  Modified by Evan You @yyx990803\n*/\n\nvar hasDocument = typeof document !== 'undefined'\n\nif (typeof DEBUG !== 'undefined' && DEBUG) {\n  if (!hasDocument) {\n    throw new Error(\n    'vue-style-loader cannot be used in a non-browser environment. ' +\n    \"Use { target: 'node' } in your Webpack config to indicate a server-rendering environment.\"\n  ) }\n}\n\nvar listToStyles = require('./listToStyles')\n\n/*\ntype StyleObject = {\n  id: number;\n  parts: Array<StyleObjectPart>\n}\n\ntype StyleObjectPart = {\n  css: string;\n  media: string;\n  sourceMap: ?string\n}\n*/\n\nvar stylesInDom = {/*\n  [id: number]: {\n    id: number,\n    refs: number,\n    parts: Array<(obj?: StyleObjectPart) => void>\n  }\n*/}\n\nvar head = hasDocument && (document.head || document.getElementsByTagName('head')[0])\nvar singletonElement = null\nvar singletonCounter = 0\nvar isProduction = false\nvar noop = function () {}\n\n// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>\n// tags it will allow on a page\nvar isOldIE = typeof navigator !== 'undefined' && /msie [6-9]\\b/.test(navigator.userAgent.toLowerCase())\n\nmodule.exports = function (parentId, list, _isProduction) {\n  isProduction = _isProduction\n\n  var styles = listToStyles(parentId, list)\n  addStylesToDom(styles)\n\n  return function update (newList) {\n    var mayRemove = []\n    for (var i = 0; i < styles.length; i++) {\n      var item = styles[i]\n      var domStyle = stylesInDom[item.id]\n      domStyle.refs--\n      mayRemove.push(domStyle)\n    }\n    if (newList) {\n      styles = listToStyles(parentId, newList)\n      addStylesToDom(styles)\n    } else {\n      styles = []\n    }\n    for (var i = 0; i < mayRemove.length; i++) {\n      var domStyle = mayRemove[i]\n      if (domStyle.refs === 0) {\n        for (var j = 0; j < domStyle.parts.length; j++) {\n          domStyle.parts[j]()\n        }\n        delete stylesInDom[domStyle.id]\n      }\n    }\n  }\n}\n\nfunction addStylesToDom (styles /* Array<StyleObject> */) {\n  for (var i = 0; i < styles.length; i++) {\n    var item = styles[i]\n    var domStyle = stylesInDom[item.id]\n    if (domStyle) {\n      domStyle.refs++\n      for (var j = 0; j < domStyle.parts.length; j++) {\n        domStyle.parts[j](item.parts[j])\n      }\n      for (; j < item.parts.length; j++) {\n        domStyle.parts.push(addStyle(item.parts[j]))\n      }\n      if (domStyle.parts.length > item.parts.length) {\n        domStyle.parts.length = item.parts.length\n      }\n    } else {\n      var parts = []\n      for (var j = 0; j < item.parts.length; j++) {\n        parts.push(addStyle(item.parts[j]))\n      }\n      stylesInDom[item.id] = { id: item.id, refs: 1, parts: parts }\n    }\n  }\n}\n\nfunction listToStyles (parentId, list) {\n  var styles = []\n  var newStyles = {}\n  for (var i = 0; i < list.length; i++) {\n    var item = list[i]\n    var id = item[0]\n    var css = item[1]\n    var media = item[2]\n    var sourceMap = item[3]\n    var part = { css: css, media: media, sourceMap: sourceMap }\n    if (!newStyles[id]) {\n      part.id = parentId + ':0'\n      styles.push(newStyles[id] = { id: id, parts: [part] })\n    } else {\n      part.id = parentId + ':' + newStyles[id].parts.length\n      newStyles[id].parts.push(part)\n    }\n  }\n  return styles\n}\n\nfunction createStyleElement () {\n  var styleElement = document.createElement('style')\n  styleElement.type = 'text/css'\n  head.appendChild(styleElement)\n  return styleElement\n}\n\nfunction addStyle (obj /* StyleObjectPart */) {\n  var update, remove\n  var styleElement = document.querySelector('style[data-vue-ssr-id~=\"' + obj.id + '\"]')\n  var hasSSR = styleElement != null\n\n  // if in production mode and style is already provided by SSR,\n  // simply do nothing.\n  if (hasSSR && isProduction) {\n    return noop\n  }\n\n  if (isOldIE) {\n    // use singleton mode for IE9.\n    var styleIndex = singletonCounter++\n    styleElement = singletonElement || (singletonElement = createStyleElement())\n    update = applyToSingletonTag.bind(null, styleElement, styleIndex, false)\n    remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true)\n  } else {\n    // use multi-style-tag mode in all other cases\n    styleElement = styleElement || createStyleElement()\n    update = applyToTag.bind(null, styleElement)\n    remove = function () {\n      styleElement.parentNode.removeChild(styleElement)\n    }\n  }\n\n  if (!hasSSR) {\n    update(obj)\n  }\n\n  return function updateStyle (newObj /* StyleObjectPart */) {\n    if (newObj) {\n      if (newObj.css === obj.css &&\n          newObj.media === obj.media &&\n          newObj.sourceMap === obj.sourceMap) {\n        return\n      }\n      update(obj = newObj)\n    } else {\n      remove()\n    }\n  }\n}\n\nvar replaceText = (function () {\n  var textStore = []\n\n  return function (index, replacement) {\n    textStore[index] = replacement\n    return textStore.filter(Boolean).join('\\n')\n  }\n})()\n\nfunction applyToSingletonTag (styleElement, index, remove, obj) {\n  var css = remove ? '' : obj.css\n\n  if (styleElement.styleSheet) {\n    styleElement.styleSheet.cssText = replaceText(index, css)\n  } else {\n    var cssNode = document.createTextNode(css)\n    var childNodes = styleElement.childNodes\n    if (childNodes[index]) styleElement.removeChild(childNodes[index])\n    if (childNodes.length) {\n      styleElement.insertBefore(cssNode, childNodes[index])\n    } else {\n      styleElement.appendChild(cssNode)\n    }\n  }\n}\n\nfunction applyToTag (styleElement, obj) {\n  var css = obj.css\n  var media = obj.media\n  var sourceMap = obj.sourceMap\n\n  if (media) {\n    styleElement.setAttribute('media', media)\n  }\n\n  if (sourceMap) {\n    // https://developer.chrome.com/devtools/docs/javascript-debugging\n    // this makes source maps inside style tags work properly in Chrome\n    css += '\\n/*# sourceURL=' + sourceMap.sources[0] + ' */'\n    // http://stackoverflow.com/a/26603875\n    css += '\\n/*# sourceMappingURL=data:application/json;base64,' + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + ' */'\n  }\n\n  if (styleElement.styleSheet) {\n    styleElement.styleSheet.cssText = css\n  } else {\n    while (styleElement.firstChild) {\n      styleElement.removeChild(styleElement.firstChild)\n    }\n    styleElement.appendChild(document.createTextNode(css))\n  }\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/vue-style-loader/lib/addStylesClient.js\n// module id = 138\n// module chunks = 0"],"sourceRoot":""}