d3vue/static/js/vendor.d7f56de7848fa2082505.js.map

{"version":3,"sources":["webpack:///static/js/vendor.d7f56de7848fa2082505.js","webpack:///./~/vue-loader/lib/component-normalizer.js","webpack:///./~/core-js/library/modules/_wks.js","webpack:///./~/core-js/library/modules/_global.js","webpack:///./~/d3/build/d3.js","webpack:///./~/core-js/library/modules/_an-object.js","webpack:///./~/core-js/library/modules/_descriptors.js","webpack:///./~/core-js/library/modules/_has.js","webpack:///./~/core-js/library/modules/_hide.js","webpack:///./~/core-js/library/modules/_object-dp.js","webpack:///./~/core-js/library/modules/_core.js","webpack:///./~/core-js/library/modules/_defined.js","webpack:///./~/core-js/library/modules/_is-object.js","webpack:///./~/core-js/library/modules/_iterators.js","webpack:///./~/core-js/library/modules/_property-desc.js","webpack:///./~/core-js/library/modules/_shared-key.js","webpack:///./~/core-js/library/modules/_to-integer.js","webpack:///./~/vue/dist/vue.common.js","webpack:///./~/core-js/library/modules/_cof.js","webpack:///./~/core-js/library/modules/_ctx.js","webpack:///./~/core-js/library/modules/_dom-create.js","webpack:///./~/core-js/library/modules/_enum-bug-keys.js","webpack:///./~/core-js/library/modules/_export.js","webpack:///./~/core-js/library/modules/_fails.js","webpack:///./~/core-js/library/modules/_set-to-string-tag.js","webpack:///./~/core-js/library/modules/_shared.js","webpack:///./~/core-js/library/modules/_to-iobject.js","webpack:///./~/core-js/library/modules/_to-length.js","webpack:///./~/core-js/library/modules/_to-object.js","webpack:///./~/core-js/library/modules/_uid.js","webpack:///(webpack)/buildin/global.js","webpack:///./~/babel-runtime/core-js/array/from.js","webpack:///./~/babel-runtime/helpers/toConsumableArray.js","webpack:///./~/core-js/library/fn/array/from.js","webpack:///./~/core-js/library/modules/_a-function.js","webpack:///./~/core-js/library/modules/_array-includes.js","webpack:///./~/core-js/library/modules/_classof.js","webpack:///./~/core-js/library/modules/_create-property.js","webpack:///./~/core-js/library/modules/_html.js","webpack:///./~/core-js/library/modules/_ie8-dom-define.js","webpack:///./~/core-js/library/modules/_iobject.js","webpack:///./~/core-js/library/modules/_is-array-iter.js","webpack:///./~/core-js/library/modules/_iter-call.js","webpack:///./~/core-js/library/modules/_iter-create.js","webpack:///./~/core-js/library/modules/_iter-define.js","webpack:///./~/core-js/library/modules/_iter-detect.js","webpack:///./~/core-js/library/modules/_library.js","webpack:///./~/core-js/library/modules/_object-create.js","webpack:///./~/core-js/library/modules/_object-dps.js","webpack:///./~/core-js/library/modules/_object-gpo.js","webpack:///./~/core-js/library/modules/_object-keys-internal.js","webpack:///./~/core-js/library/modules/_object-keys.js","webpack:///./~/core-js/library/modules/_redefine.js","webpack:///./~/core-js/library/modules/_string-at.js","webpack:///./~/core-js/library/modules/_to-index.js","webpack:///./~/core-js/library/modules/_to-primitive.js","webpack:///./~/core-js/library/modules/core.get-iterator-method.js","webpack:///./~/core-js/library/modules/es6.array.from.js","webpack:///./~/core-js/library/modules/es6.string.iterator.js","webpack:///./~/lodash/lodash.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__","store","uid","Symbol","USE_SYMBOL","$exports","name","global","window","Math","self","Function","__g","factory","this","ascendingComparator","f","d","x","ascending","tickStep","start","stop","count","step0","abs","max","step1","pow","floor","log","LN10","error","e10","e5","e2","length","translateX","scale0","scale1","isFinite","translateY","y","center","scale","offset","bandwidth","round","entering","__axis","axis","orient","context","values","tickValues","ticks","apply","tickArguments","domain","format","tickFormat","identity$1","spacing","tickSizeInner","tickPadding","transform","top","bottom","range","range0","range1","position","copy","selection","path","selectAll","data","tick","order","tickExit","exit","tickEnter","enter","append","attr","line","select","text","k","left","right","merge","insert","transition","epsilon","parentNode","remove","tickSizeOuter","filter","each","_","arguments","slice$1","call","slice","tickSize","axisTop","axisRight","axisBottom","axisLeft","dispatch","t","i","n","Error","Dispatch","parseTypenames","typenames","types","trim","split","map","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","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","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","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","isObject","it","dP","createDesc","anObject","IE8_DOM_DEFINE","toPrimitive","O","Attributes","core","__e","bitmap","enumerable","configurable","writable","shared","_toString","val","String","toNumber","parseFloat","makeMap","str","expectsLowerCase","remove$1","arr","item","hasOwn","obj","isPrimitive","cached","fn","hit","bind$1","ctx","boundFn","_length","toArray","ret","_from","isPlainObject","OBJECT_STRING","toObject","res","genStaticKeys","modules","staticKeys","looseEqual","isObjectA","isObjectB","looseIndexOf","isReserved","def","parsePath","bailRE","isNative","Ctor","pushTarget","_target","Dep","targetStack","popTarget","protoAugment","src","__proto__","copyAugment","observe","asRootData","ob","__ob__","Observer","observerState","shouldConvert","isServerRendering","isExtensible","_isVue","vmCount","defineReactive$$1","customSetter","dep","getOwnPropertyDescriptor","getter","setter","childOb","depend","dependArray","newVal","notify","del","mergeData","toVal","fromVal","mergeHook","parentVal","childVal","mergeAssets","normalizeProps","props","camelize","normalizeDirectives","dirs","directives","mergeOptions","vm","mergeField","strat","strats","defaultStrat","extendsFrom","extends","mixins","mixin","Vue$3","resolveAsset","warnMissing","assets","camelizedId","PascalCaseId","capitalize","validateProp","propOptions","propsData","prop","absent","isType","Boolean","hyphenate","getPropDefaultValue","prevShouldConvert","$options","getType","len","createTextVNode","VNode","cloneVNode","vnode","cloned","tag","elm","componentOptions","ns","isStatic","isCloned","cloneVNodes","vnodes","createComponent","baseCtor","_base","cid","resolved","resolveAsyncComponent","$forceUpdate","resolveConstructorOptions","extractProps","functional","createFunctionalComponent","nativeOn","abstract","mergeHooks","slots","resolveSlots","functionalContext","slot","createComponentInstanceForVnode","parentElm","refElm","vnodeComponentOptions","_isComponent","_componentTag","_parentVnode","_parentListeners","_renderChildren","_parentElm","_refElm","inlineTemplate","hydrating","componentInstance","_isDestroyed","activeInstance","$mount","keepAlive","mountedNode","prepatch","oldVnode","_updateFromParent","_isMounted","callHook","_inactive","destroy$1","$destroy","requested","cbs","pendingCallbacks","sync","resolve","reject","reason","then","attrs","domProps","checkProp","hash","preserve","hook","hooksToMerge","fromParent","ours","hooks","mergeHook$1","mergeVNodeHook","hookKey","injectedHash","__injected","oldHook","createEventHandle","invoker","arguments$1","updateListeners","oldOn","remove$$1","cur","old","normalizeEvent","once","simpleNormalizeChildren","normalizeChildren","normalizeArrayChildren","nestedIndex","last","getFirstComponentChild","normalizationType","alwaysNormalize","ALWAYS_NORMALIZE","_createElement","createEmptyVNode","scopedSlots","SIMPLE_NORMALIZE","config","getTagNamespace","isReservedTag","parsePlatformTagName","applyNS","initRender","$vnode","_vnode","_staticTrees","parentVnode","renderContext","$slots","$scopedSlots","_c","$createElement","renderMixin","Vue","markStatic","isOnce","markStaticNode","$nextTick","nextTick","_render","ref","_renderProxy","errorHandler","_s","_v","_n","_e","_q","_i","_m","isInFor","_o","_f","_l","fallback","bindObject","scopedSlotFn","slotNodes","_b","asProp","mustUseProp","eventKeyCode","builtInAlias","keyCodes","defaultSlot","isComment","initEvents","_events","_hasHookEvent","updateComponentListeners","$once","$on","remove$2","$off","oldListeners","eventsMixin","hookRE","$emit","initLifecycle","$parent","$children","$root","$refs","_watcher","_isBeingDestroyed","lifecycleMixin","_mount","el","$el","Watcher","_update","prevEl","prevVnode","prevActiveInstance","__patch__","__vue__","renderChildren","hasChildren","propKeys","_propKeys","teardown","_watchers","handlers","resetSchedulerState","has$1","waiting","flushing","flushSchedulerQueue","watcher","run","devtools","queueWatcher","traverse","seenObjects","_traverse","seen","isA","depId","initState","opts","initProps","initMethods","initData","initComputed","watch","initWatch","isRoot","loop","proxy","userDef","computedSharedDefinition","makeComputedGetter","owner","lazy","dirty","evaluate","handler","createWatcher","$watch","stateMixin","dataDef","$set","$delete","expOrFn","immediate","initMixin","_init","_uid","initInternalComponent","_self","super","superOptions","cachedSuperOptions","extendOptions","components","initUse","use","plugin","installed","install","initMixin$1","initExtend","Super","SuperId","cachedCtors","_Ctor","Sub","_assetTypes","initAssetRegisters","getComponentName","pattern","pruneCache","cachedNode","pruneCacheEntry","initGlobalAPI","configDef","util","delete","builtInComponents","genClassForVnode","childNode","mergeClassData","genClassFromData","staticClass","class","dynamicClass","stringifyClass","stringified","isSVG","isUnknownElement","inBrowser","unknownElementCache","HTMLUnknownElement","HTMLElement","query","createElement$1","tagName","namespaceMap","createTextNode","createComment","newNode","referenceNode","setTextContent","registerRef","isRemoval","refs","refInFor","isUndef","isDef","sameVnode","vnode1","vnode2","createKeyToOldIdx","beginIdx","endIdx","createPatchFunction","backend","emptyNodeAt","nodeOps","createRmCb","childElm","removeNode","createElm","insertedVnodeQueue","nested","isRootInsert","setScope","createChildren","invokeCreateHooks","isReactivated","initComponent","reactivateComponent","pendingInsert","isPatchable","innerNode","activate","emptyNode","i$1","addVnodes","startIdx","invokeDestroyHook","destroy","removeVnodes","ch","removeAndInvokeRemoveHook","rm","updateChildren","oldCh","newCh","removeOnly","oldKeyToIdx","idxInOld","elmToMove","oldStartIdx","newStartIdx","oldEndIdx","oldStartVnode","oldEndVnode","newEndIdx","newStartVnode","newEndVnode","canMove","patchVnode","hasData","postpatch","invokeInsertHook","initial","hydrate","hasChildNodes","childrenMatch","isRenderedModule","hooks$1","isInitialPatch","isRealElement","nodeType","hasAttribute","oldElm","parentElm$1","_leaveCb","updateDirectives","oldDir","dir","isCreate","isDestroy","oldDirs","normalizeDirectives$1","newDirs","dirsWithInsert","dirsWithPostpatch","oldValue","callHook$1","componentUpdated","inserted","callInsert","modifiers","emptyModifiers","getRawDirName","rawName","updateAttrs","oldAttrs","setAttr","isIE9","isXlink","xlinkNS","getXlinkProp","isEnumeratedAttr","isBooleanAttr","isFalsyAttrValue","updateClass","oldData","cls","transitionClass","_transitionClasses","_prevClass","add$2","oldHandler","target$1","ev","remove$3","updateDOMListeners","updateDOMProps","oldProps","strCur","shouldUpdateValue","checkVal","composing","isDirty","isInputChanged","activeElement","_vModifiers","normalizeStyleData","normalizeStyleBinding","staticStyle","bindingStyle","parseStyleText","getStyle","checkChild","styleData","updateStyle","oldStaticStyle","oldStyleBinding","oldStyle","newStyle","setProp","addClass","removeClass","tar","nextFrame","raf","addTransitionClass","removeTransitionClass","whenTransitionEnds","expectedType","getTransitionInfo","propCount","TRANSITION","transitionEndEvent","animationEndEvent","onEnd","styles","transitioneDelays","transitionProp","transitionDurations","transitionTimeout","getTimeout","animationDelays","animationProp","animationDurations","animationTimeout","ANIMATION","hasTransform","transformRE","delays","durations","toMs","Number","toggleDisplay","cancelled","resolveTransition","_enterCb","css","enterClass","enterToClass","enterActiveClass","appearClass","appearToClass","appearActiveClass","beforeEnter","afterEnter","enterCancelled","beforeAppear","appear","afterAppear","appearCancelled","transitionNode","isAppear","startClass","activeClass","toClass","beforeEnterHook","enterHook","afterEnterHook","enterCancelledHook","expectsCSS","userWantsControl","show","pendingNode","_pending","leave","performLeave","beforeLeave","leaveClass","leaveActiveClass","leaveToClass","afterLeave","leaveCancelled","delayLeave","def$$1","autoCssTransition","called","setSelected","binding","isMultiple","multiple","selected","option","getValue","selectedIndex","hasNoMatchingOption","onCompositionStart","onCompositionEnd","trigger","locateNode","getRealChild","compOptions","extractTransitionData","comp","key$1","placeholder","rawChild","hasParentTransition","isSameChild","oldChild","callPendingCbs","_moveCb","recordPosition","newPos","applyTranslation","oldPos","pos","WebkitTransform","transitionDuration","shouldDecode","content","encoded","div","decode","decoder","decodeAttr","shouldDecodeNewlines","nlRE","ltRE","gtRE","ampRE","quoteRE","parseHTML","advance","parseStartTag","startTagOpen","startTagClose","attribute","unarySlash","handleStartTag","expectHTML","lastTag","isNonPhrasingTag","parseEndTag","canBeLeftOpenTag","unary","isUnaryTag$$1","IS_REGEX_CAPTURING_BROKEN","lowerCasedTag","lowerCasedTagName","isUnaryTag","no","isScriptOrStyle","stackedTag","reStackedTag","reCache","endTagLength","rest","all","endTag","chars","textEnd","comment","commentEnd","conditionalComment","conditionalEnd","doctypeMatch","doctype","endTagMatch","curIndex","startTagMatch","rest$1","parseFilters","pushFilter","filters","lastFilterIndex","prev","expression","inSingle","inDouble","inTemplateString","inRegex","curly","paren","wrapFilter","parseText","delimiters","tagRE","buildRegex","defaultTagRE","tokens","baseWarn","msg","console","pluckModuleFunction","addProp","addAttr","addDirective","arg","addHandler","important","events","native","nativeEvents","newHandler","getBindingAttr","getStatic","dynamicValue","getAndRemoveAttr","staticValue","attrsMap","attrsList","parseModel","expressionPos","expressionEndPos","lastIndexOf","idx","eof","chr","isStringStart","parseString","parseBracket","inBracket","stringQuote","template","warn$1","warn","platformGetTagNamespace","platformMustUseProp","platformIsPreTag","isPreTag","preTransforms","transforms","postTransforms","currentParent","preserveWhitespace","inVPre","inPre","checkRootConstraints","isIE","guardIESVGBug","makeAttrsMap","isForbiddenTag","forbidden","processPre","pre","processRawAttrs","processFor","processIf","processOnce","processKey","plain","processRef","processSlot","processComponent","processAttrs","if","elseif","else","addIfCondition","block","processIfConditions","slotScope","slotTarget","i$2","lastNode","decodeHTMLCached","checkInFor","inMatch","forAliasRE","for","alias","iteratorMatch","forIteratorRE","iterator1","iterator2","findPrevElement","condition","ifConditions","slotName","component","isProp","dirRE","hasBindings","parseModifiers","modifierRE","bindRE","camel","onRE","argMatch","argRE","ieNSBug","ieNSPrefix","optimize","isStaticKey","genStaticKeysCached","isPlatformReservedTag","markStaticRoots","genStaticKeys$1","static","staticInFor","staticRoot","walkThroughConditionsBlocks","conditionBlocks","isBuiltInTag","isDirectChildOfTemplateFor","genHandlers","genHandler","modifierCode","genKeyFilter","handlerCode","simplePathRE","fnExpRE","genFilterCode","keyVal","bind$2","wrapData","generate","ast","prevStaticRenderFns","currentStaticRenderFns","prevOnceCount","onceCount","currentOptions","warn$2","transforms$1","dataGenFns","platformDirectives$1","isPlatformReservedTag$1","genElement","staticProcessed","genStatic","onceProcessed","genOnce","forProcessed","genFor","ifProcessed","genIf","genSlot","genComponent","genData","genChildren","genIfConditions","conditions","genTernaryExp","genDirectives","genProps","genScopedSlots","genInlineTemplate","needRuntime","hasRuntime","gen","baseDirectives","inlineRenderFns","genScopedSlot","scope","checkSkip","el$1","getNormalizationType","genNode","needsNormalization","some","maybeComponent","genText","transformSpecialNewlines","bind$$1","componentName","compile$1","transformNode","classBinding","genData$1","transformNode$1","styleBinding","genData$2","model$1","_warn","warn$3","genSelect","genCheckboxModel","genRadioModel","genDefaultModel","valueBinding","trueValueBinding","falseValueBinding","genAssignmentCode","needCompositionGuard","valueExpression","assignment","modelRs","compile$$1","baseOptions","compileToFunctions","compiled","makeFunction","getOuterHTML","outerHTML","cloneNode","_isServer","_Set","camelizeRE","hyphenateRE","optionMergeStrategies","silent","ignoredElements","_lifecycleHooks","_maxUpdateCount","hasProto","UA","navigator","userAgent","isEdge","isAndroid","isIOS","env","VUE_ENV","__VUE_DEVTOOLS_GLOBAL_HOOK__","nextTickHandler","pending","copies","callbacks","timerFunc","Promise","logError","err","catch","MutationObserver","counter","observer","textNode","characterData","_resolve","formatComponentName","uid$1","subs","addSub","sub","removeSub","addDep","arrayProto","arrayMethods","original","observeArray","arrayKeys","getOwnPropertyNames","isSettingProps","augment","walk","items","instanceData","defaultData","freeze","defineReactive","raw","prototypeAccessors","defineProperties","uid$2","deep","deps","newDeps","depIds","newDepIds","cleanupDeps","this$1","tmp","patternTypes","KeepAlive","include","exclude","created","destroyed","testEl","acceptValue","math","isHTMLTag","baseModules","klass","cssText","listDelimiter","propertyDelimiter","cssVarRE","importantRE","normalize","upper","prefixed","hasTransition","ontransitionend","onwebkittransitionend","onanimationend","onwebkitanimationend","platformModules","patch$1","vmodel","model","needReset","originalDisplay","__vOriginalDisplay","display","unbind","platformDirectives","transitionProps","_leaving","oldRawChild","delayedLeave","moveClass","TransitionGroup","prevChildren","rawChildren","transitionData","kept","removed","c$1","beforeUpdate","updated","hasMove","body","offsetHeight","propertyName","_hasMove","info","platformComponents","singleAttrIdentifier","singleAttrAssign","singleAttrValues","ncname","qnameCapture","regexEscapeRE","close","esc","tab","up","down","prevent","ctrl","alt","meta","cloak","klass$1","style$1","modules$1","directives$1","idToTemplate","mount","compile","aFunction","is","hide","PROTOTYPE","$export","own","IS_FORCED","F","IS_GLOBAL","G","IS_STATIC","IS_PROTO","IS_BIND","IS_WRAP","expProto","virtual","TAG","stat","SHARED","IObject","toInteger","eval","__esModule","_interopRequireDefault","_from2","arr2","toIObject","toLength","toIndex","IS_INCLUDES","$this","fromIndex","cof","ARG","tryGet","callee","$defineProperty","propertyIsEnumerable","Iterators","ITERATOR","ArrayProto","iterator","descriptor","setToStringTag","IteratorPrototype","Constructor","NAME","LIBRARY","redefine","$iterCreate","getPrototypeOf","BUGGY","FF_ITERATOR","KEYS","VALUES","returnThis","Base","DEFAULT","IS_SET","FORCED","getMethod","kind","DEF_VALUES","VALUES_BUG","$native","$default","$entries","$anyNative","SAFE_CLOSING","riter","skipClosing","safe","iter","done","dPs","enumBugKeys","IE_PROTO","Empty","createDict","iframeDocument","iframe","lt","gt","contentWindow","write","Properties","getKeys","ObjectProto","arrayIndexOf","$keys","TO_STRING","classof","getIteratorMethod","isArrayIter","createProperty","getIterFn","arrayLike","aLen","mapfn","mapping","iterFn","$at","iterated","__WEBPACK_AMD_DEFINE_RESULT__","addMapEntry","pair","addSetEntry","func","thisArg","arrayAggregator","iteratee","accumulator","arrayEach","arrayEachRight","arrayEvery","predicate","arrayFilter","resIndex","arrayIncludes","baseIndexOf","arrayIncludesWith","comparator","arrayMap","arrayPush","arrayReduce","initAccum","arrayReduceRight","arraySome","asciiToArray","asciiWords","reAsciiWord","baseFindKey","eachFunc","baseFindIndex","fromRight","strictIndexOf","baseIsNaN","baseIndexOfWith","baseMean","baseSum","NAN","baseProperty","basePropertyOf","baseReduce","baseSortBy","comparer","baseTimes","baseToPairs","baseUnary","baseValues","cacheHas","charsStartIndex","strSymbols","chrSymbols","charsEndIndex","countHolders","escapeStringChar","stringEscapes","hasUnicode","reHasUnicode","hasUnicodeWord","reHasUnicodeWord","iteratorToArray","mapToArray","overArg","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","freeParseInt","freeGlobal","freeSelf","freeExports","freeModule","moduleExports","freeProcess","process","nodeUtil","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","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","mapCacheDelete","getMapData","mapCacheGet","mapCacheHas","mapCacheSet","SetCache","setCacheAdd","setCacheHas","Stack","stackClear","stackDelete","stackGet","stackHas","stackSet","arrayLikeKeys","inherited","isArg","isArguments","isBuff","isBuffer","skipIndexes","isIndex","arraySample","baseRandom","arraySampleSize","shuffleSelf","baseClamp","arrayShuffle","assignMergeValue","eq","baseAssignValue","assignValue","objValue","baseAggregator","baseEach","baseAssign","copyObject","baseAssignIn","keysIn","baseAt","paths","skip","baseClone","bitmask","customizer","isDeep","isFlat","isFull","initCloneArray","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","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","baseInverter","baseInvoke","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","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","toPlainObject","baseNth","baseOrderBy","orders","getIteratee","criteria","compareMultiple","basePick","basePickBy","baseSet","basePropertyDeep","basePullAll","basePullAt","baseUnset","nativeFloor","nativeRandom","baseRange","nativeCeil","baseRepeat","baseRest","setToString","overRest","baseSample","baseSampleSize","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","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","charsLength","createPartial","toFinite","createRelationalOperation","wrapFunc","isCurry","newHoldersRight","newPartials","newPartialsRight","newData","setData","setWrapToString","createRound","createToPairs","createWrap","baseSetData","customDefaultsAssignIn","objectProto","customDefaultsMerge","customOmitClone","isPartial","arrValue","othValue","compared","message","objProps","objLength","othProps","skipCtor","objCtor","othCtor","flatten","realNames","otherFunc","isKeyable","getNative","isOwn","unmasked","nativeObjectToString","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","separator","nativeJoin","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","wrapperToIterator","wrapperPlant","wrapperReverse","wrapped","wrapperValue","flatMap","flatMapDeep","flatMapDepth","forEachRight","baseEachRight","isString","orderBy","reduceRight","negate","sample","sampleSize","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","spread","throttle","partial","castArray","cloneWith","cloneDeep","cloneDeepWith","conformsTo","isBoolean","isElement","isEmpty","isEqual","isEqualWith","isError","nativeIsFinite","isInteger","isMatch","isMatchWith","isNumber","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","setWith","isArrLike","unset","updateWith","valuesIn","inRange","floating","upperFirst","endsWith","escape","escapeRegExp","strLength","padEnd","padStart","radix","nativeParseInt","repeat","limit","startsWith","settings","templateSettings","assignInWith","isEscaping","isEvaluating","imports","importsKeys","importsValues","reDelimiters","sourceURL","escapeValue","esTemplateValue","evaluateValue","variable","attempt","toLower","toUpper","trimEnd","trimStart","truncate","omission","search","newEnd","unescape","cond","conforms","defaultTo","matchesProperty","methodNames","noConflict","oldDash","nthArg","propertyOf","stubArray","stubFalse","stubObject","stubString","stubTrue","times","toPath","uniqueId","idCounter","maxBy","meanBy","minBy","sumBy","defaults","pick","funcProto","coreJsData","Buffer","objectCreate","isConcatSpreadable","toStringTag","ctxClearTimeout","ctxNow","ctxSetTimeout","nativeGetSymbols","getOwnPropertySymbols","nativeIsBuffer","DataView","WeakMap","metaMap","dataViewCtorString","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","symbolProto","baseSetToString","castRest","ArrayBuffer","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","gte","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","resolveProps","route","resolveQuery","extraQuery","parsedQuery","parseQuery","param","parts","stringifyQuery","encode","val2","createRoute","record","redirectedFrom","fullPath","getFullPath","matched","formatMatch","isSameRoute","START","trailingSlashRE","isObjectEqual","aKeys","bKeys","isIncludedRoute","queryIncludes","guardEvent","ctrlKey","defaultPrevented","findAnchor","_Vue","_router","_route","beforeCreate","router","history","View","Link","beforeRouteEnter","beforeRouteLeave","resolvePath","relative","hashIndex","queryIndex","cleanPath","createRouteMap","routes","oldPathMap","oldNameMap","pathMap","nameMap","addRouteRecord","matchAs","normalizePath","instances","redirect","childMatchAs","aliasRoute","defaultDelimiter","PATH_REGEXP","escaped","modifier","asterisk","escapeGroup","escapeString","substr","tokensToFunction","encodeURIComponentPretty","encodeURI","encodeAsterisk","pretty","encodeURIComponent","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","pathname","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","instance","extractGuard","extractLeaveGuards","bindGuard","extractUpdateHooks","extractEnterGuards","isValid","bindEnterGuard","poll","resolveAsyncComponents","resolvedDef","getLocation","checkFallback","ensureSlash","getHash","replaceHash","href","pushHash","createHref","routerView","$route","_routerViewCache","inactive","routerViewDepth","encodeReserveRE","encodeReserveReplacer","commaRE","toTypes","eventTypes","exact","$router","classes","linkActiveClass","compareTarget","click","aData","aAttrs","parse_1","compile_1","tokensToFunction_1","tokensToRegExp_1","supportsPushState","ua","History","ready","readyCbs","listen","onReady","transitionTo","onComplete","onAbort","confirmTransition","updateRoute","ensureURL","beforeHooks","postEnterCbs","enterGuards","afterHooks","HTML5History","History$$1","expectScroll","go","getCurrentLocation","HashHistory","setupListeners","AbstractHistory","targetIndex","VueRouter","apps","setupHashListener","beforeEach","afterEach","back","getMatchedComponents","normalizedTo","newStyles","media","sourceMap","part","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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CAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,KAAAC,IAAA,KACAC,IAAA,KAAAC,IAAA,KACAC,IAAA,KAEAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IACAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAAAC,IAAA,IAC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AgmB,YACAhmB,EAAA1zF,YACA0zF,EAAAkqB,WACAlqB,EAAA3qI,UACA2qI,EAAA6e,SACA7e,EAAA8e,cACA9e,EAAA+e,YACA/e,EAAAqnB,YACArnB,EAAAkrB,gBACAlrB,EAAA7lE,SACA6lE,EAAA9hI,SACA8hI,EAAAipB,cACAjpB,EAAAkpB,gBACAlpB,EAAAmpB,kBACAnpB,EAAAob,QACApb,EAAAqb,aACArb,EAAAsb,kBACAtb,EAAAub,aACAvb,EAAA1wH,QACA0wH,EAAAj3I,UACAi3I,EAAAke,WACAle,EAAAme,eACAne,EAAAoe,gBACApe,EAAAkZ,WACAlZ,EAAA0b,eACA1b,EAAA2b,gBACA3b,EAAAogB,QACApgB,EAAAksB,QACAlsB,EAAAmsB,aACAnsB,EAAA4b,aACA5b,EAAA8iB,aACA9iB,EAAA+iB,eACA/iB,EAAAoqB,WACApqB,EAAAlpC,WACAkpC,EAAA/tE,gBACA+tE,EAAAqpB,kBACArpB,EAAAspB,oBACAtpB,EAAA9nH,UACA8nH,EAAAorB,YACAprB,EAAAqqB,aACArqB,EAAAlc,YACAkc,EAAAsqB,SACAtqB,EAAAt9I,QACAs9I,EAAAuF,UACAvF,EAAA11I,OACA01I,EAAAgjB,WACAhjB,EAAAijB,aACAjjB,EAAAtxF,WACAsxF,EAAAkmB,mBACAlmB,EAAAma,WACAna,EAAAx3I,SACAw3I,EAAAmrB,aACAnrB,EAAA7jE,UACA6jE,EAAAosB,YACApsB,EAAAzgD,SACAygD,EAAA0e,UACA1e,EAAAsmB,UACAtmB,EAAAsrB,QACAtrB,EAAAkjB,UACAljB,EAAAz5C,QACAy5C,EAAAwe,WACAxe,EAAAqsB,QACArsB,EAAAwqB,YACAxqB,EAAAssB,aACAtsB,EAAAusB,YACAvsB,EAAA0gB,WACA1gB,EAAA0qB,gBACA1qB,EAAAlpE,aACAkpE,EAAAsnB,QACAtnB,EAAAmjB,UACAnjB,EAAAp5H,YACAo5H,EAAAumB,cACAvmB,EAAAupB,QACAvpB,EAAAgc,WACAhc,EAAAic,aACAjc,EAAAkc,eACAlc,EAAAwpB,UACAxpB,EAAA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","file":"static/js/vendor.d7f56de7848fa2082505.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\nvar store      = __webpack_require__(25)('wks')\n  , uid        = __webpack_require__(29)\n  , Symbol     = __webpack_require__(2).Symbol\n  , USE_SYMBOL = typeof Symbol == 'function';\n\nvar $exports = module.exports = function(name){\n  return store[name] || (store[name] =\n    USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));\n};\n\n$exports.store = store;\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports) {\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nvar global = module.exports = typeof window != 'undefined' && window.Math == Math\n  ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();\nif(typeof __g == 'number')__g = global; // eslint-disable-line no-undef\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\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/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar isObject = __webpack_require__(12);\nmodule.exports = function(it){\n  if(!isObject(it))throw TypeError(it + ' is not an object!');\n  return it;\n};\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// Thank's IE8 for his funny defineProperty\nmodule.exports = !__webpack_require__(23)(function(){\n  return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;\n});\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports) {\n\nvar hasOwnProperty = {}.hasOwnProperty;\nmodule.exports = function(it, key){\n  return hasOwnProperty.call(it, key);\n};\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar dP         = __webpack_require__(8)\n  , createDesc = __webpack_require__(14);\nmodule.exports = __webpack_require__(5) ? 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/* 8 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar anObject       = __webpack_require__(4)\n  , IE8_DOM_DEFINE = __webpack_require__(51)\n  , toPrimitive    = __webpack_require__(67)\n  , dP             = Object.defineProperty;\n\nexports.f = __webpack_require__(5) ? 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/* 9 */,\n/* 10 */\n/***/ (function(module, exports) {\n\nvar core = module.exports = {version: '2.4.0'};\nif(typeof __e == 'number')__e = core; // eslint-disable-line no-undef\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports) {\n\n// 7.2.1 RequireObjectCoercible(argument)\nmodule.exports = function(it){\n  if(it == undefined)throw TypeError(\"Can't call method on  \" + it);\n  return it;\n};\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports) {\n\nmodule.exports = function(it){\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports) {\n\nmodule.exports = {};\n\n/***/ }),\n/* 14 */\n/***/ (function(module, exports) {\n\nmodule.exports = function(bitmap, value){\n  return {\n    enumerable  : !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable    : !(bitmap & 4),\n    value       : value\n  };\n};\n\n/***/ }),\n/* 15 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar shared = __webpack_require__(25)('keys')\n  , uid    = __webpack_require__(29);\nmodule.exports = function(key){\n  return shared[key] || (shared[key] = uid(key));\n};\n\n/***/ }),\n/* 16 */\n/***/ (function(module, exports) {\n\n// 7.1.4 ToInteger\nvar ceil  = Math.ceil\n  , floor = Math.floor;\nmodule.exports = function(it){\n  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);\n};\n\n/***/ }),\n/* 17 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/*!\n * Vue.js v2.1.10\n * (c) 2014-2017 Evan You\n * Released under the MIT License.\n */\n\n\n/*  */\n\n/**\n * Convert a value to a string that is actually rendered.\n */\nfunction _toString (val) {\n  return val == null\n    ? ''\n    : typeof val === 'object'\n      ? JSON.stringify(val, null, 2)\n      : String(val)\n}\n\n/**\n * Convert a input value to a number for persistence.\n * If the conversion fails, return original string.\n */\nfunction toNumber (val) {\n  var n = parseFloat(val);\n  return isNaN(n) ? val : n\n}\n\n/**\n * Make a map and return a function for checking if a key\n * is in that map.\n */\nfunction makeMap (\n  str,\n  expectsLowerCase\n) {\n  var map = Object.create(null);\n  var list = str.split(',');\n  for (var i = 0; i < list.length; i++) {\n    map[list[i]] = true;\n  }\n  return expectsLowerCase\n    ? function (val) { return map[val.toLowerCase()]; }\n    : function (val) { return map[val]; }\n}\n\n/**\n * Check if a tag is a built-in tag.\n */\nvar isBuiltInTag = makeMap('slot,component', true);\n\n/**\n * Remove an item from an array\n */\nfunction remove$1 (arr, item) {\n  if (arr.length) {\n    var index = arr.indexOf(item);\n    if (index > -1) {\n      return arr.splice(index, 1)\n    }\n  }\n}\n\n/**\n * Check whether the object has the property.\n */\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction hasOwn (obj, key) {\n  return hasOwnProperty.call(obj, key)\n}\n\n/**\n * Check if value is primitive\n */\nfunction isPrimitive (value) {\n  return typeof value === 'string' || typeof value === 'number'\n}\n\n/**\n * Create a cached version of a pure function.\n */\nfunction cached (fn) {\n  var cache = Object.create(null);\n  return (function cachedFn (str) {\n    var hit = cache[str];\n    return hit || (cache[str] = fn(str))\n  })\n}\n\n/**\n * Camelize a hyphen-delimited string.\n */\nvar camelizeRE = /-(\\w)/g;\nvar camelize = cached(function (str) {\n  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })\n});\n\n/**\n * Capitalize a string.\n */\nvar capitalize = cached(function (str) {\n  return str.charAt(0).toUpperCase() + str.slice(1)\n});\n\n/**\n * Hyphenate a camelCase string.\n */\nvar hyphenateRE = /([^-])([A-Z])/g;\nvar hyphenate = cached(function (str) {\n  return str\n    .replace(hyphenateRE, '$1-$2')\n    .replace(hyphenateRE, '$1-$2')\n    .toLowerCase()\n});\n\n/**\n * Simple bind, faster than native\n */\nfunction bind$1 (fn, ctx) {\n  function boundFn (a) {\n    var l = arguments.length;\n    return l\n      ? l > 1\n        ? fn.apply(ctx, arguments)\n        : fn.call(ctx, a)\n      : fn.call(ctx)\n  }\n  // record original fn length\n  boundFn._length = fn.length;\n  return boundFn\n}\n\n/**\n * Convert an Array-like object to a real Array.\n */\nfunction toArray (list, start) {\n  start = start || 0;\n  var i = list.length - start;\n  var ret = new Array(i);\n  while (i--) {\n    ret[i] = list[i + start];\n  }\n  return ret\n}\n\n/**\n * Mix properties into target object.\n */\nfunction extend (to, _from) {\n  for (var key in _from) {\n    to[key] = _from[key];\n  }\n  return to\n}\n\n/**\n * Quick object check - this is primarily used to tell\n * Objects from primitive values when we know the value\n * is a JSON-compliant type.\n */\nfunction isObject (obj) {\n  return obj !== null && typeof obj === 'object'\n}\n\n/**\n * Strict object type check. Only returns true\n * for plain JavaScript objects.\n */\nvar toString = Object.prototype.toString;\nvar OBJECT_STRING = '[object Object]';\nfunction isPlainObject (obj) {\n  return toString.call(obj) === OBJECT_STRING\n}\n\n/**\n * Merge an Array of Objects into a single Object.\n */\nfunction toObject (arr) {\n  var res = {};\n  for (var i = 0; i < arr.length; i++) {\n    if (arr[i]) {\n      extend(res, arr[i]);\n    }\n  }\n  return res\n}\n\n/**\n * Perform no operation.\n */\nfunction noop () {}\n\n/**\n * Always return false.\n */\nvar no = function () { return false; };\n\n/**\n * Return same value\n */\nvar identity = function (_) { return _; };\n\n/**\n * Generate a static keys string from compiler modules.\n */\nfunction genStaticKeys (modules) {\n  return modules.reduce(function (keys, m) {\n    return keys.concat(m.staticKeys || [])\n  }, []).join(',')\n}\n\n/**\n * Check if two values are loosely equal - that is,\n * if they are plain objects, do they have the same shape?\n */\nfunction looseEqual (a, b) {\n  var isObjectA = isObject(a);\n  var isObjectB = isObject(b);\n  if (isObjectA && isObjectB) {\n    return JSON.stringify(a) === JSON.stringify(b)\n  } else if (!isObjectA && !isObjectB) {\n    return String(a) === String(b)\n  } else {\n    return false\n  }\n}\n\nfunction looseIndexOf (arr, val) {\n  for (var i = 0; i < arr.length; i++) {\n    if (looseEqual(arr[i], val)) { return i }\n  }\n  return -1\n}\n\n/*  */\n\nvar config = {\n  /**\n   * Option merge strategies (used in core/util/options)\n   */\n  optionMergeStrategies: Object.create(null),\n\n  /**\n   * Whether to suppress warnings.\n   */\n  silent: false,\n\n  /**\n   * Whether to enable devtools\n   */\n  devtools: \"production\" !== 'production',\n\n  /**\n   * Error handler for watcher errors\n   */\n  errorHandler: null,\n\n  /**\n   * Ignore certain custom elements\n   */\n  ignoredElements: [],\n\n  /**\n   * Custom user key aliases for v-on\n   */\n  keyCodes: Object.create(null),\n\n  /**\n   * Check if a tag is reserved so that it cannot be registered as a\n   * component. This is platform-dependent and may be overwritten.\n   */\n  isReservedTag: no,\n\n  /**\n   * Check if a tag is an unknown element.\n   * Platform-dependent.\n   */\n  isUnknownElement: no,\n\n  /**\n   * Get the namespace of an element\n   */\n  getTagNamespace: noop,\n\n  /**\n   * Parse the real tag name for the specific platform.\n   */\n  parsePlatformTagName: identity,\n\n  /**\n   * Check if an attribute must be bound using property, e.g. value\n   * Platform-dependent.\n   */\n  mustUseProp: no,\n\n  /**\n   * List of asset types that a component can own.\n   */\n  _assetTypes: [\n    'component',\n    'directive',\n    'filter'\n  ],\n\n  /**\n   * List of lifecycle hooks.\n   */\n  _lifecycleHooks: [\n    'beforeCreate',\n    'created',\n    'beforeMount',\n    'mounted',\n    'beforeUpdate',\n    'updated',\n    'beforeDestroy',\n    'destroyed',\n    'activated',\n    'deactivated'\n  ],\n\n  /**\n   * Max circular updates allowed in a scheduler flush cycle.\n   */\n  _maxUpdateCount: 100\n};\n\n/*  */\n\n/**\n * Check if a string starts with $ or _\n */\nfunction isReserved (str) {\n  var c = (str + '').charCodeAt(0);\n  return c === 0x24 || c === 0x5F\n}\n\n/**\n * Define a property.\n */\nfunction def (obj, key, val, enumerable) {\n  Object.defineProperty(obj, key, {\n    value: val,\n    enumerable: !!enumerable,\n    writable: true,\n    configurable: true\n  });\n}\n\n/**\n * Parse simple path.\n */\nvar bailRE = /[^\\w.$]/;\nfunction parsePath (path) {\n  if (bailRE.test(path)) {\n    return\n  } else {\n    var segments = path.split('.');\n    return function (obj) {\n      for (var i = 0; i < segments.length; i++) {\n        if (!obj) { return }\n        obj = obj[segments[i]];\n      }\n      return obj\n    }\n  }\n}\n\n/*  */\n/* globals MutationObserver */\n\n// can we use __proto__?\nvar hasProto = '__proto__' in {};\n\n// Browser environment sniffing\nvar inBrowser = typeof window !== 'undefined';\nvar UA = inBrowser && window.navigator.userAgent.toLowerCase();\nvar isIE = UA && /msie|trident/.test(UA);\nvar isIE9 = UA && UA.indexOf('msie 9.0') > 0;\nvar isEdge = UA && UA.indexOf('edge/') > 0;\nvar isAndroid = UA && UA.indexOf('android') > 0;\nvar isIOS = UA && /iphone|ipad|ipod|ios/.test(UA);\n\n// this needs to be lazy-evaled because vue may be required before\n// vue-server-renderer can set VUE_ENV\nvar _isServer;\nvar isServerRendering = function () {\n  if (_isServer === undefined) {\n    /* istanbul ignore if */\n    if (!inBrowser && typeof global !== 'undefined') {\n      // detect presence of vue-server-renderer and avoid\n      // Webpack shimming the process\n      _isServer = global['process'].env.VUE_ENV === 'server';\n    } else {\n      _isServer = false;\n    }\n  }\n  return _isServer\n};\n\n// detect devtools\nvar devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;\n\n/* istanbul ignore next */\nfunction isNative (Ctor) {\n  return /native code/.test(Ctor.toString())\n}\n\n/**\n * Defer a task to execute it asynchronously.\n */\nvar nextTick = (function () {\n  var callbacks = [];\n  var pending = false;\n  var timerFunc;\n\n  function nextTickHandler () {\n    pending = false;\n    var copies = callbacks.slice(0);\n    callbacks.length = 0;\n    for (var i = 0; i < copies.length; i++) {\n      copies[i]();\n    }\n  }\n\n  // the nextTick behavior leverages the microtask queue, which can be accessed\n  // via either native Promise.then or MutationObserver.\n  // MutationObserver has wider support, however it is seriously bugged in\n  // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It\n  // completely stops working after triggering a few times... so, if native\n  // Promise is available, we will use it:\n  /* istanbul ignore if */\n  if (typeof Promise !== 'undefined' && isNative(Promise)) {\n    var p = Promise.resolve();\n    var logError = function (err) { console.error(err); };\n    timerFunc = function () {\n      p.then(nextTickHandler).catch(logError);\n      // in problematic UIWebViews, Promise.then doesn't completely break, but\n      // it can get stuck in a weird state where callbacks are pushed into the\n      // microtask queue but the queue isn't being flushed, until the browser\n      // needs to do some other work, e.g. handle a timer. Therefore we can\n      // \"force\" the microtask queue to be flushed by adding an empty timer.\n      if (isIOS) { setTimeout(noop); }\n    };\n  } else if (typeof MutationObserver !== 'undefined' && (\n    isNative(MutationObserver) ||\n    // PhantomJS and iOS 7.x\n    MutationObserver.toString() === '[object MutationObserverConstructor]'\n  )) {\n    // use MutationObserver where native Promise is not available,\n    // e.g. PhantomJS IE11, iOS7, Android 4.4\n    var counter = 1;\n    var observer = new MutationObserver(nextTickHandler);\n    var textNode = document.createTextNode(String(counter));\n    observer.observe(textNode, {\n      characterData: true\n    });\n    timerFunc = function () {\n      counter = (counter + 1) % 2;\n      textNode.data = String(counter);\n    };\n  } else {\n    // fallback to setTimeout\n    /* istanbul ignore next */\n    timerFunc = function () {\n      setTimeout(nextTickHandler, 0);\n    };\n  }\n\n  return function queueNextTick (cb, ctx) {\n    var _resolve;\n    callbacks.push(function () {\n      if (cb) { cb.call(ctx); }\n      if (_resolve) { _resolve(ctx); }\n    });\n    if (!pending) {\n      pending = true;\n      timerFunc();\n    }\n    if (!cb && typeof Promise !== 'undefined') {\n      return new Promise(function (resolve) {\n        _resolve = resolve;\n      })\n    }\n  }\n})();\n\nvar _Set;\n/* istanbul ignore if */\nif (typeof Set !== 'undefined' && isNative(Set)) {\n  // use native Set when available.\n  _Set = Set;\n} else {\n  // a non-standard Set polyfill that only works with primitive keys.\n  _Set = (function () {\n    function Set () {\n      this.set = Object.create(null);\n    }\n    Set.prototype.has = function has (key) {\n      return this.set[key] === true\n    };\n    Set.prototype.add = function add (key) {\n      this.set[key] = true;\n    };\n    Set.prototype.clear = function clear () {\n      this.set = Object.create(null);\n    };\n\n    return Set;\n  }());\n}\n\nvar warn = noop;\nvar formatComponentName;\n\nif (false) {\n  var hasConsole = typeof console !== 'undefined';\n\n  warn = function (msg, vm) {\n    if (hasConsole && (!config.silent)) {\n      console.error(\"[Vue warn]: \" + msg + \" \" + (\n        vm ? formatLocation(formatComponentName(vm)) : ''\n      ));\n    }\n  };\n\n  formatComponentName = function (vm) {\n    if (vm.$root === vm) {\n      return 'root instance'\n    }\n    var name = vm._isVue\n      ? vm.$options.name || vm.$options._componentTag\n      : vm.name;\n    return (\n      (name ? (\"component <\" + name + \">\") : \"anonymous component\") +\n      (vm._isVue && vm.$options.__file ? (\" at \" + (vm.$options.__file)) : '')\n    )\n  };\n\n  var formatLocation = function (str) {\n    if (str === 'anonymous component') {\n      str += \" - use the \\\"name\\\" option for better debugging messages.\";\n    }\n    return (\"\\n(found in \" + str + \")\")\n  };\n}\n\n/*  */\n\n\nvar uid$1 = 0;\n\n/**\n * A dep is an observable that can have multiple\n * directives subscribing to it.\n */\nvar Dep = function Dep () {\n  this.id = uid$1++;\n  this.subs = [];\n};\n\nDep.prototype.addSub = function addSub (sub) {\n  this.subs.push(sub);\n};\n\nDep.prototype.removeSub = function removeSub (sub) {\n  remove$1(this.subs, sub);\n};\n\nDep.prototype.depend = function depend () {\n  if (Dep.target) {\n    Dep.target.addDep(this);\n  }\n};\n\nDep.prototype.notify = function notify () {\n  // stablize the subscriber list first\n  var subs = this.subs.slice();\n  for (var i = 0, l = subs.length; i < l; i++) {\n    subs[i].update();\n  }\n};\n\n// the current target watcher being evaluated.\n// this is globally unique because there could be only one\n// watcher being evaluated at any time.\nDep.target = null;\nvar targetStack = [];\n\nfunction pushTarget (_target) {\n  if (Dep.target) { targetStack.push(Dep.target); }\n  Dep.target = _target;\n}\n\nfunction popTarget () {\n  Dep.target = targetStack.pop();\n}\n\n/*\n * not type checking this file because flow doesn't play well with\n * dynamically accessing methods on Array prototype\n */\n\nvar arrayProto = Array.prototype;\nvar arrayMethods = Object.create(arrayProto);[\n  'push',\n  'pop',\n  'shift',\n  'unshift',\n  'splice',\n  'sort',\n  'reverse'\n]\n.forEach(function (method) {\n  // cache original method\n  var original = arrayProto[method];\n  def(arrayMethods, method, function mutator () {\n    var arguments$1 = arguments;\n\n    // avoid leaking arguments:\n    // http://jsperf.com/closure-with-arguments\n    var i = arguments.length;\n    var args = new Array(i);\n    while (i--) {\n      args[i] = arguments$1[i];\n    }\n    var result = original.apply(this, args);\n    var ob = this.__ob__;\n    var inserted;\n    switch (method) {\n      case 'push':\n        inserted = args;\n        break\n      case 'unshift':\n        inserted = args;\n        break\n      case 'splice':\n        inserted = args.slice(2);\n        break\n    }\n    if (inserted) { ob.observeArray(inserted); }\n    // notify change\n    ob.dep.notify();\n    return result\n  });\n});\n\n/*  */\n\nvar arrayKeys = Object.getOwnPropertyNames(arrayMethods);\n\n/**\n * By default, when a reactive property is set, the new value is\n * also converted to become reactive. However when passing down props,\n * we don't want to force conversion because the value may be a nested value\n * under a frozen data structure. Converting it would defeat the optimization.\n */\nvar observerState = {\n  shouldConvert: true,\n  isSettingProps: false\n};\n\n/**\n * Observer class that are attached to each observed\n * object. Once attached, the observer converts target\n * object's property keys into getter/setters that\n * collect dependencies and dispatches updates.\n */\nvar Observer = function Observer (value) {\n  this.value = value;\n  this.dep = new Dep();\n  this.vmCount = 0;\n  def(value, '__ob__', this);\n  if (Array.isArray(value)) {\n    var augment = hasProto\n      ? protoAugment\n      : copyAugment;\n    augment(value, arrayMethods, arrayKeys);\n    this.observeArray(value);\n  } else {\n    this.walk(value);\n  }\n};\n\n/**\n * Walk through each property and convert them into\n * getter/setters. This method should only be called when\n * value type is Object.\n */\nObserver.prototype.walk = function walk (obj) {\n  var keys = Object.keys(obj);\n  for (var i = 0; i < keys.length; i++) {\n    defineReactive$$1(obj, keys[i], obj[keys[i]]);\n  }\n};\n\n/**\n * Observe a list of Array items.\n */\nObserver.prototype.observeArray = function observeArray (items) {\n  for (var i = 0, l = items.length; i < l; i++) {\n    observe(items[i]);\n  }\n};\n\n// helpers\n\n/**\n * Augment an target Object or Array by intercepting\n * the prototype chain using __proto__\n */\nfunction protoAugment (target, src) {\n  /* eslint-disable no-proto */\n  target.__proto__ = src;\n  /* eslint-enable no-proto */\n}\n\n/**\n * Augment an target Object or Array by defining\n * hidden properties.\n */\n/* istanbul ignore next */\nfunction copyAugment (target, src, keys) {\n  for (var i = 0, l = keys.length; i < l; i++) {\n    var key = keys[i];\n    def(target, key, src[key]);\n  }\n}\n\n/**\n * Attempt to create an observer instance for a value,\n * returns the new observer if successfully observed,\n * or the existing observer if the value already has one.\n */\nfunction observe (value, asRootData) {\n  if (!isObject(value)) {\n    return\n  }\n  var ob;\n  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {\n    ob = value.__ob__;\n  } else if (\n    observerState.shouldConvert &&\n    !isServerRendering() &&\n    (Array.isArray(value) || isPlainObject(value)) &&\n    Object.isExtensible(value) &&\n    !value._isVue\n  ) {\n    ob = new Observer(value);\n  }\n  if (asRootData && ob) {\n    ob.vmCount++;\n  }\n  return ob\n}\n\n/**\n * Define a reactive property on an Object.\n */\nfunction defineReactive$$1 (\n  obj,\n  key,\n  val,\n  customSetter\n) {\n  var dep = new Dep();\n\n  var property = Object.getOwnPropertyDescriptor(obj, key);\n  if (property && property.configurable === false) {\n    return\n  }\n\n  // cater for pre-defined getter/setters\n  var getter = property && property.get;\n  var setter = property && property.set;\n\n  var childOb = observe(val);\n  Object.defineProperty(obj, key, {\n    enumerable: true,\n    configurable: true,\n    get: function reactiveGetter () {\n      var value = getter ? getter.call(obj) : val;\n      if (Dep.target) {\n        dep.depend();\n        if (childOb) {\n          childOb.dep.depend();\n        }\n        if (Array.isArray(value)) {\n          dependArray(value);\n        }\n      }\n      return value\n    },\n    set: function reactiveSetter (newVal) {\n      var value = getter ? getter.call(obj) : val;\n      /* eslint-disable no-self-compare */\n      if (newVal === value || (newVal !== newVal && value !== value)) {\n        return\n      }\n      /* eslint-enable no-self-compare */\n      if (false) {\n        customSetter();\n      }\n      if (setter) {\n        setter.call(obj, newVal);\n      } else {\n        val = newVal;\n      }\n      childOb = observe(newVal);\n      dep.notify();\n    }\n  });\n}\n\n/**\n * Set a property on an object. Adds the new property and\n * triggers change notification if the property doesn't\n * already exist.\n */\nfunction set$1 (obj, key, val) {\n  if (Array.isArray(obj)) {\n    obj.length = Math.max(obj.length, key);\n    obj.splice(key, 1, val);\n    return val\n  }\n  if (hasOwn(obj, key)) {\n    obj[key] = val;\n    return\n  }\n  var ob = obj.__ob__;\n  if (obj._isVue || (ob && ob.vmCount)) {\n    \"production\" !== 'production' && warn(\n      'Avoid adding reactive properties to a Vue instance or its root $data ' +\n      'at runtime - declare it upfront in the data option.'\n    );\n    return\n  }\n  if (!ob) {\n    obj[key] = val;\n    return\n  }\n  defineReactive$$1(ob.value, key, val);\n  ob.dep.notify();\n  return val\n}\n\n/**\n * Delete a property and trigger change if necessary.\n */\nfunction del (obj, key) {\n  var ob = obj.__ob__;\n  if (obj._isVue || (ob && ob.vmCount)) {\n    \"production\" !== 'production' && warn(\n      'Avoid deleting properties on a Vue instance or its root $data ' +\n      '- just set it to null.'\n    );\n    return\n  }\n  if (!hasOwn(obj, key)) {\n    return\n  }\n  delete obj[key];\n  if (!ob) {\n    return\n  }\n  ob.dep.notify();\n}\n\n/**\n * Collect dependencies on array elements when the array is touched, since\n * we cannot intercept array element access like property getters.\n */\nfunction dependArray (value) {\n  for (var e = (void 0), i = 0, l = value.length; i < l; i++) {\n    e = value[i];\n    e && e.__ob__ && e.__ob__.dep.depend();\n    if (Array.isArray(e)) {\n      dependArray(e);\n    }\n  }\n}\n\n/*  */\n\n/**\n * Option overwriting strategies are functions that handle\n * how to merge a parent option value and a child option\n * value into the final value.\n */\nvar strats = config.optionMergeStrategies;\n\n/**\n * Options with restrictions\n */\nif (false) {\n  strats.el = strats.propsData = function (parent, child, vm, key) {\n    if (!vm) {\n      warn(\n        \"option \\\"\" + key + \"\\\" can only be used during instance \" +\n        'creation with the `new` keyword.'\n      );\n    }\n    return defaultStrat(parent, child)\n  };\n}\n\n/**\n * Helper that recursively merges two data objects together.\n */\nfunction mergeData (to, from) {\n  if (!from) { return to }\n  var key, toVal, fromVal;\n  var keys = Object.keys(from);\n  for (var i = 0; i < keys.length; i++) {\n    key = keys[i];\n    toVal = to[key];\n    fromVal = from[key];\n    if (!hasOwn(to, key)) {\n      set$1(to, key, fromVal);\n    } else if (isPlainObject(toVal) && isPlainObject(fromVal)) {\n      mergeData(toVal, fromVal);\n    }\n  }\n  return to\n}\n\n/**\n * Data\n */\nstrats.data = function (\n  parentVal,\n  childVal,\n  vm\n) {\n  if (!vm) {\n    // in a Vue.extend merge, both should be functions\n    if (!childVal) {\n      return parentVal\n    }\n    if (typeof childVal !== 'function') {\n      \"production\" !== 'production' && warn(\n        'The \"data\" option should be a function ' +\n        'that returns a per-instance value in component ' +\n        'definitions.',\n        vm\n      );\n      return parentVal\n    }\n    if (!parentVal) {\n      return childVal\n    }\n    // when parentVal & childVal are both present,\n    // we need to return a function that returns the\n    // merged result of both functions... no need to\n    // check if parentVal is a function here because\n    // it has to be a function to pass previous merges.\n    return function mergedDataFn () {\n      return mergeData(\n        childVal.call(this),\n        parentVal.call(this)\n      )\n    }\n  } else if (parentVal || childVal) {\n    return function mergedInstanceDataFn () {\n      // instance merge\n      var instanceData = typeof childVal === 'function'\n        ? childVal.call(vm)\n        : childVal;\n      var defaultData = typeof parentVal === 'function'\n        ? parentVal.call(vm)\n        : undefined;\n      if (instanceData) {\n        return mergeData(instanceData, defaultData)\n      } else {\n        return defaultData\n      }\n    }\n  }\n};\n\n/**\n * Hooks and param attributes are merged as arrays.\n */\nfunction mergeHook (\n  parentVal,\n  childVal\n) {\n  return childVal\n    ? parentVal\n      ? parentVal.concat(childVal)\n      : Array.isArray(childVal)\n        ? childVal\n        : [childVal]\n    : parentVal\n}\n\nconfig._lifecycleHooks.forEach(function (hook) {\n  strats[hook] = mergeHook;\n});\n\n/**\n * Assets\n *\n * When a vm is present (instance creation), we need to do\n * a three-way merge between constructor options, instance\n * options and parent options.\n */\nfunction mergeAssets (parentVal, childVal) {\n  var res = Object.create(parentVal || null);\n  return childVal\n    ? extend(res, childVal)\n    : res\n}\n\nconfig._assetTypes.forEach(function (type) {\n  strats[type + 's'] = mergeAssets;\n});\n\n/**\n * Watchers.\n *\n * Watchers hashes should not overwrite one\n * another, so we merge them as arrays.\n */\nstrats.watch = function (parentVal, childVal) {\n  /* istanbul ignore if */\n  if (!childVal) { return parentVal }\n  if (!parentVal) { return childVal }\n  var ret = {};\n  extend(ret, parentVal);\n  for (var key in childVal) {\n    var parent = ret[key];\n    var child = childVal[key];\n    if (parent && !Array.isArray(parent)) {\n      parent = [parent];\n    }\n    ret[key] = parent\n      ? parent.concat(child)\n      : [child];\n  }\n  return ret\n};\n\n/**\n * Other object hashes.\n */\nstrats.props =\nstrats.methods =\nstrats.computed = function (parentVal, childVal) {\n  if (!childVal) { return parentVal }\n  if (!parentVal) { return childVal }\n  var ret = Object.create(null);\n  extend(ret, parentVal);\n  extend(ret, childVal);\n  return ret\n};\n\n/**\n * Default strategy.\n */\nvar defaultStrat = function (parentVal, childVal) {\n  return childVal === undefined\n    ? parentVal\n    : childVal\n};\n\n/**\n * Validate component names\n */\nfunction checkComponents (options) {\n  for (var key in options.components) {\n    var lower = key.toLowerCase();\n    if (isBuiltInTag(lower) || config.isReservedTag(lower)) {\n      warn(\n        'Do not use built-in or reserved HTML elements as component ' +\n        'id: ' + key\n      );\n    }\n  }\n}\n\n/**\n * Ensure all props option syntax are normalized into the\n * Object-based format.\n */\nfunction normalizeProps (options) {\n  var props = options.props;\n  if (!props) { return }\n  var res = {};\n  var i, val, name;\n  if (Array.isArray(props)) {\n    i = props.length;\n    while (i--) {\n      val = props[i];\n      if (typeof val === 'string') {\n        name = camelize(val);\n        res[name] = { type: null };\n      } else if (false) {\n        warn('props must be strings when using array syntax.');\n      }\n    }\n  } else if (isPlainObject(props)) {\n    for (var key in props) {\n      val = props[key];\n      name = camelize(key);\n      res[name] = isPlainObject(val)\n        ? val\n        : { type: val };\n    }\n  }\n  options.props = res;\n}\n\n/**\n * Normalize raw function directives into object format.\n */\nfunction normalizeDirectives (options) {\n  var dirs = options.directives;\n  if (dirs) {\n    for (var key in dirs) {\n      var def = dirs[key];\n      if (typeof def === 'function') {\n        dirs[key] = { bind: def, update: def };\n      }\n    }\n  }\n}\n\n/**\n * Merge two option objects into a new one.\n * Core utility used in both instantiation and inheritance.\n */\nfunction mergeOptions (\n  parent,\n  child,\n  vm\n) {\n  if (false) {\n    checkComponents(child);\n  }\n  normalizeProps(child);\n  normalizeDirectives(child);\n  var extendsFrom = child.extends;\n  if (extendsFrom) {\n    parent = typeof extendsFrom === 'function'\n      ? mergeOptions(parent, extendsFrom.options, vm)\n      : mergeOptions(parent, extendsFrom, vm);\n  }\n  if (child.mixins) {\n    for (var i = 0, l = child.mixins.length; i < l; i++) {\n      var mixin = child.mixins[i];\n      if (mixin.prototype instanceof Vue$3) {\n        mixin = mixin.options;\n      }\n      parent = mergeOptions(parent, mixin, vm);\n    }\n  }\n  var options = {};\n  var key;\n  for (key in parent) {\n    mergeField(key);\n  }\n  for (key in child) {\n    if (!hasOwn(parent, key)) {\n      mergeField(key);\n    }\n  }\n  function mergeField (key) {\n    var strat = strats[key] || defaultStrat;\n    options[key] = strat(parent[key], child[key], vm, key);\n  }\n  return options\n}\n\n/**\n * Resolve an asset.\n * This function is used because child instances need access\n * to assets defined in its ancestor chain.\n */\nfunction resolveAsset (\n  options,\n  type,\n  id,\n  warnMissing\n) {\n  /* istanbul ignore if */\n  if (typeof id !== 'string') {\n    return\n  }\n  var assets = options[type];\n  // check local registration variations first\n  if (hasOwn(assets, id)) { return assets[id] }\n  var camelizedId = camelize(id);\n  if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }\n  var PascalCaseId = capitalize(camelizedId);\n  if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }\n  // fallback to prototype chain\n  var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];\n  if (false) {\n    warn(\n      'Failed to resolve ' + type.slice(0, -1) + ': ' + id,\n      options\n    );\n  }\n  return res\n}\n\n/*  */\n\nfunction validateProp (\n  key,\n  propOptions,\n  propsData,\n  vm\n) {\n  var prop = propOptions[key];\n  var absent = !hasOwn(propsData, key);\n  var value = propsData[key];\n  // handle boolean props\n  if (isType(Boolean, prop.type)) {\n    if (absent && !hasOwn(prop, 'default')) {\n      value = false;\n    } else if (!isType(String, prop.type) && (value === '' || value === hyphenate(key))) {\n      value = true;\n    }\n  }\n  // check default value\n  if (value === undefined) {\n    value = getPropDefaultValue(vm, prop, key);\n    // since the default value is a fresh copy,\n    // make sure to observe it.\n    var prevShouldConvert = observerState.shouldConvert;\n    observerState.shouldConvert = true;\n    observe(value);\n    observerState.shouldConvert = prevShouldConvert;\n  }\n  if (false) {\n    assertProp(prop, key, value, vm, absent);\n  }\n  return value\n}\n\n/**\n * Get the default value of a prop.\n */\nfunction getPropDefaultValue (vm, prop, key) {\n  // no default, return undefined\n  if (!hasOwn(prop, 'default')) {\n    return undefined\n  }\n  var def = prop.default;\n  // warn against non-factory defaults for Object & Array\n  if (isObject(def)) {\n    \"production\" !== 'production' && warn(\n      'Invalid default value for prop \"' + key + '\": ' +\n      'Props with type Object/Array must use a factory function ' +\n      'to return the default value.',\n      vm\n    );\n  }\n  // the raw prop value was also undefined from previous render,\n  // return previous default value to avoid unnecessary watcher trigger\n  if (vm && vm.$options.propsData &&\n    vm.$options.propsData[key] === undefined &&\n    vm[key] !== undefined) {\n    return vm[key]\n  }\n  // call factory function for non-Function types\n  return typeof def === 'function' && prop.type !== Function\n    ? def.call(vm)\n    : def\n}\n\n/**\n * Assert whether a prop is valid.\n */\nfunction assertProp (\n  prop,\n  name,\n  value,\n  vm,\n  absent\n) {\n  if (prop.required && absent) {\n    warn(\n      'Missing required prop: \"' + name + '\"',\n      vm\n    );\n    return\n  }\n  if (value == null && !prop.required) {\n    return\n  }\n  var type = prop.type;\n  var valid = !type || type === true;\n  var expectedTypes = [];\n  if (type) {\n    if (!Array.isArray(type)) {\n      type = [type];\n    }\n    for (var i = 0; i < type.length && !valid; i++) {\n      var assertedType = assertType(value, type[i]);\n      expectedTypes.push(assertedType.expectedType || '');\n      valid = assertedType.valid;\n    }\n  }\n  if (!valid) {\n    warn(\n      'Invalid prop: type check failed for prop \"' + name + '\".' +\n      ' Expected ' + expectedTypes.map(capitalize).join(', ') +\n      ', got ' + Object.prototype.toString.call(value).slice(8, -1) + '.',\n      vm\n    );\n    return\n  }\n  var validator = prop.validator;\n  if (validator) {\n    if (!validator(value)) {\n      warn(\n        'Invalid prop: custom validator check failed for prop \"' + name + '\".',\n        vm\n      );\n    }\n  }\n}\n\n/**\n * Assert the type of a value\n */\nfunction assertType (value, type) {\n  var valid;\n  var expectedType = getType(type);\n  if (expectedType === 'String') {\n    valid = typeof value === (expectedType = 'string');\n  } else if (expectedType === 'Number') {\n    valid = typeof value === (expectedType = 'number');\n  } else if (expectedType === 'Boolean') {\n    valid = typeof value === (expectedType = 'boolean');\n  } else if (expectedType === 'Function') {\n    valid = typeof value === (expectedType = 'function');\n  } else if (expectedType === 'Object') {\n    valid = isPlainObject(value);\n  } else if (expectedType === 'Array') {\n    valid = Array.isArray(value);\n  } else {\n    valid = value instanceof type;\n  }\n  return {\n    valid: valid,\n    expectedType: expectedType\n  }\n}\n\n/**\n * Use function string name to check built-in types,\n * because a simple equality check will fail when running\n * across different vms / iframes.\n */\nfunction getType (fn) {\n  var match = fn && fn.toString().match(/^\\s*function (\\w+)/);\n  return match && match[1]\n}\n\nfunction isType (type, fn) {\n  if (!Array.isArray(fn)) {\n    return getType(fn) === getType(type)\n  }\n  for (var i = 0, len = fn.length; i < len; i++) {\n    if (getType(fn[i]) === getType(type)) {\n      return true\n    }\n  }\n  /* istanbul ignore next */\n  return false\n}\n\n\n\nvar util = Object.freeze({\n\tdefineReactive: defineReactive$$1,\n\t_toString: _toString,\n\ttoNumber: toNumber,\n\tmakeMap: makeMap,\n\tisBuiltInTag: isBuiltInTag,\n\tremove: remove$1,\n\thasOwn: hasOwn,\n\tisPrimitive: isPrimitive,\n\tcached: cached,\n\tcamelize: camelize,\n\tcapitalize: capitalize,\n\thyphenate: hyphenate,\n\tbind: bind$1,\n\ttoArray: toArray,\n\textend: extend,\n\tisObject: isObject,\n\tisPlainObject: isPlainObject,\n\ttoObject: toObject,\n\tnoop: noop,\n\tno: no,\n\tidentity: identity,\n\tgenStaticKeys: genStaticKeys,\n\tlooseEqual: looseEqual,\n\tlooseIndexOf: looseIndexOf,\n\tisReserved: isReserved,\n\tdef: def,\n\tparsePath: parsePath,\n\thasProto: hasProto,\n\tinBrowser: inBrowser,\n\tUA: UA,\n\tisIE: isIE,\n\tisIE9: isIE9,\n\tisEdge: isEdge,\n\tisAndroid: isAndroid,\n\tisIOS: isIOS,\n\tisServerRendering: isServerRendering,\n\tdevtools: devtools,\n\tnextTick: nextTick,\n\tget _Set () { return _Set; },\n\tmergeOptions: mergeOptions,\n\tresolveAsset: resolveAsset,\n\tget warn () { return warn; },\n\tget formatComponentName () { return formatComponentName; },\n\tvalidateProp: validateProp\n});\n\n/* not type checking this file because flow doesn't play well with Proxy */\n\nvar initProxy;\n\nif (false) {\n  var allowedGlobals = makeMap(\n    'Infinity,undefined,NaN,isFinite,isNaN,' +\n    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +\n    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +\n    'require' // for Webpack/Browserify\n  );\n\n  var warnNonPresent = function (target, key) {\n    warn(\n      \"Property or method \\\"\" + key + \"\\\" is not defined on the instance but \" +\n      \"referenced during render. Make sure to declare reactive data \" +\n      \"properties in the data option.\",\n      target\n    );\n  };\n\n  var hasProxy =\n    typeof Proxy !== 'undefined' &&\n    Proxy.toString().match(/native code/);\n\n  if (hasProxy) {\n    var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta');\n    config.keyCodes = new Proxy(config.keyCodes, {\n      set: function set (target, key, value) {\n        if (isBuiltInModifier(key)) {\n          warn((\"Avoid overwriting built-in modifier in config.keyCodes: .\" + key));\n          return false\n        } else {\n          target[key] = value;\n          return true\n        }\n      }\n    });\n  }\n\n  var hasHandler = {\n    has: function has (target, key) {\n      var has = key in target;\n      var isAllowed = allowedGlobals(key) || key.charAt(0) === '_';\n      if (!has && !isAllowed) {\n        warnNonPresent(target, key);\n      }\n      return has || !isAllowed\n    }\n  };\n\n  var getHandler = {\n    get: function get (target, key) {\n      if (typeof key === 'string' && !(key in target)) {\n        warnNonPresent(target, key);\n      }\n      return target[key]\n    }\n  };\n\n  initProxy = function initProxy (vm) {\n    if (hasProxy) {\n      // determine which proxy handler to use\n      var options = vm.$options;\n      var handlers = options.render && options.render._withStripped\n        ? getHandler\n        : hasHandler;\n      vm._renderProxy = new Proxy(vm, handlers);\n    } else {\n      vm._renderProxy = vm;\n    }\n  };\n}\n\n/*  */\n\nvar VNode = function VNode (\n  tag,\n  data,\n  children,\n  text,\n  elm,\n  context,\n  componentOptions\n) {\n  this.tag = tag;\n  this.data = data;\n  this.children = children;\n  this.text = text;\n  this.elm = elm;\n  this.ns = undefined;\n  this.context = context;\n  this.functionalContext = undefined;\n  this.key = data && data.key;\n  this.componentOptions = componentOptions;\n  this.componentInstance = undefined;\n  this.parent = undefined;\n  this.raw = false;\n  this.isStatic = false;\n  this.isRootInsert = true;\n  this.isComment = false;\n  this.isCloned = false;\n  this.isOnce = false;\n};\n\nvar prototypeAccessors = { child: {} };\n\n// DEPRECATED: alias for componentInstance for backwards compat.\n/* istanbul ignore next */\nprototypeAccessors.child.get = function () {\n  return this.componentInstance\n};\n\nObject.defineProperties( VNode.prototype, prototypeAccessors );\n\nvar createEmptyVNode = function () {\n  var node = new VNode();\n  node.text = '';\n  node.isComment = true;\n  return node\n};\n\nfunction createTextVNode (val) {\n  return new VNode(undefined, undefined, undefined, String(val))\n}\n\n// optimized shallow clone\n// used for static nodes and slot nodes because they may be reused across\n// multiple renders, cloning them avoids errors when DOM manipulations rely\n// on their elm reference.\nfunction cloneVNode (vnode) {\n  var cloned = new VNode(\n    vnode.tag,\n    vnode.data,\n    vnode.children,\n    vnode.text,\n    vnode.elm,\n    vnode.context,\n    vnode.componentOptions\n  );\n  cloned.ns = vnode.ns;\n  cloned.isStatic = vnode.isStatic;\n  cloned.key = vnode.key;\n  cloned.isCloned = true;\n  return cloned\n}\n\nfunction cloneVNodes (vnodes) {\n  var res = new Array(vnodes.length);\n  for (var i = 0; i < vnodes.length; i++) {\n    res[i] = cloneVNode(vnodes[i]);\n  }\n  return res\n}\n\n/*  */\n\nvar hooks = { init: init, prepatch: prepatch, insert: insert, destroy: destroy$1 };\nvar hooksToMerge = Object.keys(hooks);\n\nfunction createComponent (\n  Ctor,\n  data,\n  context,\n  children,\n  tag\n) {\n  if (!Ctor) {\n    return\n  }\n\n  var baseCtor = context.$options._base;\n  if (isObject(Ctor)) {\n    Ctor = baseCtor.extend(Ctor);\n  }\n\n  if (typeof Ctor !== 'function') {\n    if (false) {\n      warn((\"Invalid Component definition: \" + (String(Ctor))), context);\n    }\n    return\n  }\n\n  // async component\n  if (!Ctor.cid) {\n    if (Ctor.resolved) {\n      Ctor = Ctor.resolved;\n    } else {\n      Ctor = resolveAsyncComponent(Ctor, baseCtor, function () {\n        // it's ok to queue this on every render because\n        // $forceUpdate is buffered by the scheduler.\n        context.$forceUpdate();\n      });\n      if (!Ctor) {\n        // return nothing if this is indeed an async component\n        // wait for the callback to trigger parent update.\n        return\n      }\n    }\n  }\n\n  // resolve constructor options in case global mixins are applied after\n  // component constructor creation\n  resolveConstructorOptions(Ctor);\n\n  data = data || {};\n\n  // extract props\n  var propsData = extractProps(data, Ctor);\n\n  // functional component\n  if (Ctor.options.functional) {\n    return createFunctionalComponent(Ctor, propsData, data, context, children)\n  }\n\n  // extract listeners, since these needs to be treated as\n  // child component listeners instead of DOM listeners\n  var listeners = data.on;\n  // replace with listeners with .native modifier\n  data.on = data.nativeOn;\n\n  if (Ctor.options.abstract) {\n    // abstract components do not keep anything\n    // other than props & listeners\n    data = {};\n  }\n\n  // merge component management hooks onto the placeholder node\n  mergeHooks(data);\n\n  // return a placeholder vnode\n  var name = Ctor.options.name || tag;\n  var vnode = new VNode(\n    (\"vue-component-\" + (Ctor.cid) + (name ? (\"-\" + name) : '')),\n    data, undefined, undefined, undefined, context,\n    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }\n  );\n  return vnode\n}\n\nfunction createFunctionalComponent (\n  Ctor,\n  propsData,\n  data,\n  context,\n  children\n) {\n  var props = {};\n  var propOptions = Ctor.options.props;\n  if (propOptions) {\n    for (var key in propOptions) {\n      props[key] = validateProp(key, propOptions, propsData);\n    }\n  }\n  // ensure the createElement function in functional components\n  // gets a unique context - this is necessary for correct named slot check\n  var _context = Object.create(context);\n  var h = function (a, b, c, d) { return createElement(_context, a, b, c, d, true); };\n  var vnode = Ctor.options.render.call(null, h, {\n    props: props,\n    data: data,\n    parent: context,\n    children: children,\n    slots: function () { return resolveSlots(children, context); }\n  });\n  if (vnode instanceof VNode) {\n    vnode.functionalContext = context;\n    if (data.slot) {\n      (vnode.data || (vnode.data = {})).slot = data.slot;\n    }\n  }\n  return vnode\n}\n\nfunction createComponentInstanceForVnode (\n  vnode, // we know it's MountedComponentVNode but flow doesn't\n  parent, // activeInstance in lifecycle state\n  parentElm,\n  refElm\n) {\n  var vnodeComponentOptions = vnode.componentOptions;\n  var options = {\n    _isComponent: true,\n    parent: parent,\n    propsData: vnodeComponentOptions.propsData,\n    _componentTag: vnodeComponentOptions.tag,\n    _parentVnode: vnode,\n    _parentListeners: vnodeComponentOptions.listeners,\n    _renderChildren: vnodeComponentOptions.children,\n    _parentElm: parentElm || null,\n    _refElm: refElm || null\n  };\n  // check inline-template render functions\n  var inlineTemplate = vnode.data.inlineTemplate;\n  if (inlineTemplate) {\n    options.render = inlineTemplate.render;\n    options.staticRenderFns = inlineTemplate.staticRenderFns;\n  }\n  return new vnodeComponentOptions.Ctor(options)\n}\n\nfunction init (\n  vnode,\n  hydrating,\n  parentElm,\n  refElm\n) {\n  if (!vnode.componentInstance || vnode.componentInstance._isDestroyed) {\n    var child = vnode.componentInstance = createComponentInstanceForVnode(\n      vnode,\n      activeInstance,\n      parentElm,\n      refElm\n    );\n    child.$mount(hydrating ? vnode.elm : undefined, hydrating);\n  } else if (vnode.data.keepAlive) {\n    // kept-alive components, treat as a patch\n    var mountedNode = vnode; // work around flow\n    prepatch(mountedNode, mountedNode);\n  }\n}\n\nfunction prepatch (\n  oldVnode,\n  vnode\n) {\n  var options = vnode.componentOptions;\n  var child = vnode.componentInstance = oldVnode.componentInstance;\n  child._updateFromParent(\n    options.propsData, // updated props\n    options.listeners, // updated listeners\n    vnode, // new parent vnode\n    options.children // new children\n  );\n}\n\nfunction insert (vnode) {\n  if (!vnode.componentInstance._isMounted) {\n    vnode.componentInstance._isMounted = true;\n    callHook(vnode.componentInstance, 'mounted');\n  }\n  if (vnode.data.keepAlive) {\n    vnode.componentInstance._inactive = false;\n    callHook(vnode.componentInstance, 'activated');\n  }\n}\n\nfunction destroy$1 (vnode) {\n  if (!vnode.componentInstance._isDestroyed) {\n    if (!vnode.data.keepAlive) {\n      vnode.componentInstance.$destroy();\n    } else {\n      vnode.componentInstance._inactive = true;\n      callHook(vnode.componentInstance, 'deactivated');\n    }\n  }\n}\n\nfunction resolveAsyncComponent (\n  factory,\n  baseCtor,\n  cb\n) {\n  if (factory.requested) {\n    // pool callbacks\n    factory.pendingCallbacks.push(cb);\n  } else {\n    factory.requested = true;\n    var cbs = factory.pendingCallbacks = [cb];\n    var sync = true;\n\n    var resolve = function (res) {\n      if (isObject(res)) {\n        res = baseCtor.extend(res);\n      }\n      // cache resolved\n      factory.resolved = res;\n      // invoke callbacks only if this is not a synchronous resolve\n      // (async resolves are shimmed as synchronous during SSR)\n      if (!sync) {\n        for (var i = 0, l = cbs.length; i < l; i++) {\n          cbs[i](res);\n        }\n      }\n    };\n\n    var reject = function (reason) {\n      \"production\" !== 'production' && warn(\n        \"Failed to resolve async component: \" + (String(factory)) +\n        (reason ? (\"\\nReason: \" + reason) : '')\n      );\n    };\n\n    var res = factory(resolve, reject);\n\n    // handle promise\n    if (res && typeof res.then === 'function' && !factory.resolved) {\n      res.then(resolve, reject);\n    }\n\n    sync = false;\n    // return in case resolved synchronously\n    return factory.resolved\n  }\n}\n\nfunction extractProps (data, Ctor) {\n  // we are only extracting raw values here.\n  // validation and default values are handled in the child\n  // component itself.\n  var propOptions = Ctor.options.props;\n  if (!propOptions) {\n    return\n  }\n  var res = {};\n  var attrs = data.attrs;\n  var props = data.props;\n  var domProps = data.domProps;\n  if (attrs || props || domProps) {\n    for (var key in propOptions) {\n      var altKey = hyphenate(key);\n      checkProp(res, props, key, altKey, true) ||\n      checkProp(res, attrs, key, altKey) ||\n      checkProp(res, domProps, key, altKey);\n    }\n  }\n  return res\n}\n\nfunction checkProp (\n  res,\n  hash,\n  key,\n  altKey,\n  preserve\n) {\n  if (hash) {\n    if (hasOwn(hash, key)) {\n      res[key] = hash[key];\n      if (!preserve) {\n        delete hash[key];\n      }\n      return true\n    } else if (hasOwn(hash, altKey)) {\n      res[key] = hash[altKey];\n      if (!preserve) {\n        delete hash[altKey];\n      }\n      return true\n    }\n  }\n  return false\n}\n\nfunction mergeHooks (data) {\n  if (!data.hook) {\n    data.hook = {};\n  }\n  for (var i = 0; i < hooksToMerge.length; i++) {\n    var key = hooksToMerge[i];\n    var fromParent = data.hook[key];\n    var ours = hooks[key];\n    data.hook[key] = fromParent ? mergeHook$1(ours, fromParent) : ours;\n  }\n}\n\nfunction mergeHook$1 (one, two) {\n  return function (a, b, c, d) {\n    one(a, b, c, d);\n    two(a, b, c, d);\n  }\n}\n\n/*  */\n\nfunction mergeVNodeHook (def, hookKey, hook, key) {\n  key = key + hookKey;\n  var injectedHash = def.__injected || (def.__injected = {});\n  if (!injectedHash[key]) {\n    injectedHash[key] = true;\n    var oldHook = def[hookKey];\n    if (oldHook) {\n      def[hookKey] = function () {\n        oldHook.apply(this, arguments);\n        hook.apply(this, arguments);\n      };\n    } else {\n      def[hookKey] = hook;\n    }\n  }\n}\n\n/*  */\n\nvar normalizeEvent = cached(function (name) {\n  var once = name.charAt(0) === '~'; // Prefixed last, checked first\n  name = once ? name.slice(1) : name;\n  var capture = name.charAt(0) === '!';\n  name = capture ? name.slice(1) : name;\n  return {\n    name: name,\n    once: once,\n    capture: capture\n  }\n});\n\nfunction createEventHandle (fn) {\n  var handle = {\n    fn: fn,\n    invoker: function () {\n      var arguments$1 = arguments;\n\n      var fn = handle.fn;\n      if (Array.isArray(fn)) {\n        for (var i = 0; i < fn.length; i++) {\n          fn[i].apply(null, arguments$1);\n        }\n      } else {\n        fn.apply(null, arguments);\n      }\n    }\n  };\n  return handle\n}\n\nfunction updateListeners (\n  on,\n  oldOn,\n  add,\n  remove$$1,\n  vm\n) {\n  var name, cur, old, event;\n  for (name in on) {\n    cur = on[name];\n    old = oldOn[name];\n    event = normalizeEvent(name);\n    if (!cur) {\n      \"production\" !== 'production' && warn(\n        \"Invalid handler for event \\\"\" + (event.name) + \"\\\": got \" + String(cur),\n        vm\n      );\n    } else if (!old) {\n      if (!cur.invoker) {\n        cur = on[name] = createEventHandle(cur);\n      }\n      add(event.name, cur.invoker, event.once, event.capture);\n    } else if (cur !== old) {\n      old.fn = cur;\n      on[name] = old;\n    }\n  }\n  for (name in oldOn) {\n    if (!on[name]) {\n      event = normalizeEvent(name);\n      remove$$1(event.name, oldOn[name].invoker, event.capture);\n    }\n  }\n}\n\n/*  */\n\n// The template compiler attempts to minimize the need for normalization by\n// statically analyzing the template at compile time.\n//\n// For plain HTML markup, normalization can be completely skipped because the\n// generated render function is guaranteed to return Array<VNode>. There are\n// two cases where extra normalization is needed:\n\n// 1. When the children contains components - because a functional component\n// may return an Array instead of a single root. In this case, just a simple\n// nomralization is needed - if any child is an Array, we flatten the whole\n// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep\n// because functional components already normalize their own children.\nfunction simpleNormalizeChildren (children) {\n  for (var i = 0; i < children.length; i++) {\n    if (Array.isArray(children[i])) {\n      return Array.prototype.concat.apply([], children)\n    }\n  }\n  return children\n}\n\n// 2. When the children contains constrcuts that always generated nested Arrays,\n// e.g. <template>, <slot>, v-for, or when the children is provided by user\n// with hand-written render functions / JSX. In such cases a full normalization\n// is needed to cater to all possible types of children values.\nfunction normalizeChildren (children) {\n  return isPrimitive(children)\n    ? [createTextVNode(children)]\n    : Array.isArray(children)\n      ? normalizeArrayChildren(children)\n      : undefined\n}\n\nfunction normalizeArrayChildren (children, nestedIndex) {\n  var res = [];\n  var i, c, last;\n  for (i = 0; i < children.length; i++) {\n    c = children[i];\n    if (c == null || typeof c === 'boolean') { continue }\n    last = res[res.length - 1];\n    //  nested\n    if (Array.isArray(c)) {\n      res.push.apply(res, normalizeArrayChildren(c, ((nestedIndex || '') + \"_\" + i)));\n    } else if (isPrimitive(c)) {\n      if (last && last.text) {\n        last.text += String(c);\n      } else if (c !== '') {\n        // convert primitive to vnode\n        res.push(createTextVNode(c));\n      }\n    } else {\n      if (c.text && last && last.text) {\n        res[res.length - 1] = createTextVNode(last.text + c.text);\n      } else {\n        // default key for nested array children (likely generated by v-for)\n        if (c.tag && c.key == null && nestedIndex != null) {\n          c.key = \"__vlist\" + nestedIndex + \"_\" + i + \"__\";\n        }\n        res.push(c);\n      }\n    }\n  }\n  return res\n}\n\n/*  */\n\nfunction getFirstComponentChild (children) {\n  return children && children.filter(function (c) { return c && c.componentOptions; })[0]\n}\n\n/*  */\n\nvar SIMPLE_NORMALIZE = 1;\nvar ALWAYS_NORMALIZE = 2;\n\n// wrapper function for providing a more flexible interface\n// without getting yelled at by flow\nfunction createElement (\n  context,\n  tag,\n  data,\n  children,\n  normalizationType,\n  alwaysNormalize\n) {\n  if (Array.isArray(data) || isPrimitive(data)) {\n    normalizationType = children;\n    children = data;\n    data = undefined;\n  }\n  if (alwaysNormalize) { normalizationType = ALWAYS_NORMALIZE; }\n  return _createElement(context, tag, data, children, normalizationType)\n}\n\nfunction _createElement (\n  context,\n  tag,\n  data,\n  children,\n  normalizationType\n) {\n  if (data && data.__ob__) {\n    \"production\" !== 'production' && warn(\n      \"Avoid using observed data object as vnode data: \" + (JSON.stringify(data)) + \"\\n\" +\n      'Always create fresh vnode data objects in each render!',\n      context\n    );\n    return createEmptyVNode()\n  }\n  if (!tag) {\n    // in case of component :is set to falsy value\n    return createEmptyVNode()\n  }\n  // support single function children as default scoped slot\n  if (Array.isArray(children) &&\n      typeof children[0] === 'function') {\n    data = data || {};\n    data.scopedSlots = { default: children[0] };\n    children.length = 0;\n  }\n  if (normalizationType === ALWAYS_NORMALIZE) {\n    children = normalizeChildren(children);\n  } else if (normalizationType === SIMPLE_NORMALIZE) {\n    children = simpleNormalizeChildren(children);\n  }\n  var vnode, ns;\n  if (typeof tag === 'string') {\n    var Ctor;\n    ns = config.getTagNamespace(tag);\n    if (config.isReservedTag(tag)) {\n      // platform built-in elements\n      vnode = new VNode(\n        config.parsePlatformTagName(tag), data, children,\n        undefined, undefined, context\n      );\n    } else if ((Ctor = resolveAsset(context.$options, 'components', tag))) {\n      // component\n      vnode = createComponent(Ctor, data, context, children, tag);\n    } else {\n      // unknown or unlisted namespaced elements\n      // check at runtime because it may get assigned a namespace when its\n      // parent normalizes children\n      vnode = new VNode(\n        tag, data, children,\n        undefined, undefined, context\n      );\n    }\n  } else {\n    // direct component options / constructor\n    vnode = createComponent(tag, data, context, children);\n  }\n  if (vnode) {\n    if (ns) { applyNS(vnode, ns); }\n    return vnode\n  } else {\n    return createEmptyVNode()\n  }\n}\n\nfunction applyNS (vnode, ns) {\n  vnode.ns = ns;\n  if (vnode.tag === 'foreignObject') {\n    // use default namespace inside foreignObject\n    return\n  }\n  if (vnode.children) {\n    for (var i = 0, l = vnode.children.length; i < l; i++) {\n      var child = vnode.children[i];\n      if (child.tag && !child.ns) {\n        applyNS(child, ns);\n      }\n    }\n  }\n}\n\n/*  */\n\nfunction initRender (vm) {\n  vm.$vnode = null; // the placeholder node in parent tree\n  vm._vnode = null; // the root of the child tree\n  vm._staticTrees = null;\n  var parentVnode = vm.$options._parentVnode;\n  var renderContext = parentVnode && parentVnode.context;\n  vm.$slots = resolveSlots(vm.$options._renderChildren, renderContext);\n  vm.$scopedSlots = {};\n  // bind the createElement fn to this instance\n  // so that we get proper render context inside it.\n  // args order: tag, data, children, normalizationType, alwaysNormalize\n  // internal version is used by render functions compiled from templates\n  vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };\n  // normalization is always applied for the public version, used in\n  // user-written render functions.\n  vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };\n}\n\nfunction renderMixin (Vue) {\n  Vue.prototype.$nextTick = function (fn) {\n    return nextTick(fn, this)\n  };\n\n  Vue.prototype._render = function () {\n    var vm = this;\n    var ref = vm.$options;\n    var render = ref.render;\n    var staticRenderFns = ref.staticRenderFns;\n    var _parentVnode = ref._parentVnode;\n\n    if (vm._isMounted) {\n      // clone slot nodes on re-renders\n      for (var key in vm.$slots) {\n        vm.$slots[key] = cloneVNodes(vm.$slots[key]);\n      }\n    }\n\n    if (_parentVnode && _parentVnode.data.scopedSlots) {\n      vm.$scopedSlots = _parentVnode.data.scopedSlots;\n    }\n\n    if (staticRenderFns && !vm._staticTrees) {\n      vm._staticTrees = [];\n    }\n    // set parent vnode. this allows render functions to have access\n    // to the data on the placeholder node.\n    vm.$vnode = _parentVnode;\n    // render self\n    var vnode;\n    try {\n      vnode = render.call(vm._renderProxy, vm.$createElement);\n    } catch (e) {\n      /* istanbul ignore else */\n      if (config.errorHandler) {\n        config.errorHandler.call(null, e, vm);\n      } else {\n        if (false) {\n          warn((\"Error when rendering \" + (formatComponentName(vm)) + \":\"));\n        }\n        throw e\n      }\n      // return previous vnode to prevent render error causing blank component\n      vnode = vm._vnode;\n    }\n    // return empty vnode in case the render function errored out\n    if (!(vnode instanceof VNode)) {\n      if (false) {\n        warn(\n          'Multiple root nodes returned from render function. Render function ' +\n          'should return a single root node.',\n          vm\n        );\n      }\n      vnode = createEmptyVNode();\n    }\n    // set parent\n    vnode.parent = _parentVnode;\n    return vnode\n  };\n\n  // toString for mustaches\n  Vue.prototype._s = _toString;\n  // convert text to vnode\n  Vue.prototype._v = createTextVNode;\n  // number conversion\n  Vue.prototype._n = toNumber;\n  // empty vnode\n  Vue.prototype._e = createEmptyVNode;\n  // loose equal\n  Vue.prototype._q = looseEqual;\n  // loose indexOf\n  Vue.prototype._i = looseIndexOf;\n\n  // render static tree by index\n  Vue.prototype._m = function renderStatic (\n    index,\n    isInFor\n  ) {\n    var tree = this._staticTrees[index];\n    // if has already-rendered static tree and not inside v-for,\n    // we can reuse the same tree by doing a shallow clone.\n    if (tree && !isInFor) {\n      return Array.isArray(tree)\n        ? cloneVNodes(tree)\n        : cloneVNode(tree)\n    }\n    // otherwise, render a fresh tree.\n    tree = this._staticTrees[index] = this.$options.staticRenderFns[index].call(this._renderProxy);\n    markStatic(tree, (\"__static__\" + index), false);\n    return tree\n  };\n\n  // mark node as static (v-once)\n  Vue.prototype._o = function markOnce (\n    tree,\n    index,\n    key\n  ) {\n    markStatic(tree, (\"__once__\" + index + (key ? (\"_\" + key) : \"\")), true);\n    return tree\n  };\n\n  function markStatic (tree, key, isOnce) {\n    if (Array.isArray(tree)) {\n      for (var i = 0; i < tree.length; i++) {\n        if (tree[i] && typeof tree[i] !== 'string') {\n          markStaticNode(tree[i], (key + \"_\" + i), isOnce);\n        }\n      }\n    } else {\n      markStaticNode(tree, key, isOnce);\n    }\n  }\n\n  function markStaticNode (node, key, isOnce) {\n    node.isStatic = true;\n    node.key = key;\n    node.isOnce = isOnce;\n  }\n\n  // filter resolution helper\n  Vue.prototype._f = function resolveFilter (id) {\n    return resolveAsset(this.$options, 'filters', id, true) || identity\n  };\n\n  // render v-for\n  Vue.prototype._l = function renderList (\n    val,\n    render\n  ) {\n    var ret, i, l, keys, key;\n    if (Array.isArray(val) || typeof val === 'string') {\n      ret = new Array(val.length);\n      for (i = 0, l = val.length; i < l; i++) {\n        ret[i] = render(val[i], i);\n      }\n    } else if (typeof val === 'number') {\n      ret = new Array(val);\n      for (i = 0; i < val; i++) {\n        ret[i] = render(i + 1, i);\n      }\n    } else if (isObject(val)) {\n      keys = Object.keys(val);\n      ret = new Array(keys.length);\n      for (i = 0, l = keys.length; i < l; i++) {\n        key = keys[i];\n        ret[i] = render(val[key], key, i);\n      }\n    }\n    return ret\n  };\n\n  // renderSlot\n  Vue.prototype._t = function (\n    name,\n    fallback,\n    props,\n    bindObject\n  ) {\n    var scopedSlotFn = this.$scopedSlots[name];\n    if (scopedSlotFn) { // scoped slot\n      props = props || {};\n      if (bindObject) {\n        extend(props, bindObject);\n      }\n      return scopedSlotFn(props) || fallback\n    } else {\n      var slotNodes = this.$slots[name];\n      // warn duplicate slot usage\n      if (slotNodes && \"production\" !== 'production') {\n        slotNodes._rendered && warn(\n          \"Duplicate presence of slot \\\"\" + name + \"\\\" found in the same render tree \" +\n          \"- this will likely cause render errors.\",\n          this\n        );\n        slotNodes._rendered = true;\n      }\n      return slotNodes || fallback\n    }\n  };\n\n  // apply v-bind object\n  Vue.prototype._b = function bindProps (\n    data,\n    tag,\n    value,\n    asProp\n  ) {\n    if (value) {\n      if (!isObject(value)) {\n        \"production\" !== 'production' && warn(\n          'v-bind without argument expects an Object or Array value',\n          this\n        );\n      } else {\n        if (Array.isArray(value)) {\n          value = toObject(value);\n        }\n        for (var key in value) {\n          if (key === 'class' || key === 'style') {\n            data[key] = value[key];\n          } else {\n            var type = data.attrs && data.attrs.type;\n            var hash = asProp || config.mustUseProp(tag, type, key)\n              ? data.domProps || (data.domProps = {})\n              : data.attrs || (data.attrs = {});\n            hash[key] = value[key];\n          }\n        }\n      }\n    }\n    return data\n  };\n\n  // check v-on keyCodes\n  Vue.prototype._k = function checkKeyCodes (\n    eventKeyCode,\n    key,\n    builtInAlias\n  ) {\n    var keyCodes = config.keyCodes[key] || builtInAlias;\n    if (Array.isArray(keyCodes)) {\n      return keyCodes.indexOf(eventKeyCode) === -1\n    } else {\n      return keyCodes !== eventKeyCode\n    }\n  };\n}\n\nfunction resolveSlots (\n  children,\n  context\n) {\n  var slots = {};\n  if (!children) {\n    return slots\n  }\n  var defaultSlot = [];\n  var name, child;\n  for (var i = 0, l = children.length; i < l; i++) {\n    child = children[i];\n    // named slots should only be respected if the vnode was rendered in the\n    // same context.\n    if ((child.context === context || child.functionalContext === context) &&\n        child.data && (name = child.data.slot)) {\n      var slot = (slots[name] || (slots[name] = []));\n      if (child.tag === 'template') {\n        slot.push.apply(slot, child.children);\n      } else {\n        slot.push(child);\n      }\n    } else {\n      defaultSlot.push(child);\n    }\n  }\n  // ignore single whitespace\n  if (defaultSlot.length && !(\n    defaultSlot.length === 1 &&\n    (defaultSlot[0].text === ' ' || defaultSlot[0].isComment)\n  )) {\n    slots.default = defaultSlot;\n  }\n  return slots\n}\n\n/*  */\n\nfunction initEvents (vm) {\n  vm._events = Object.create(null);\n  vm._hasHookEvent = false;\n  // init parent attached events\n  var listeners = vm.$options._parentListeners;\n  if (listeners) {\n    updateComponentListeners(vm, listeners);\n  }\n}\n\nvar target;\n\nfunction add$1 (event, fn, once) {\n  if (once) {\n    target.$once(event, fn);\n  } else {\n    target.$on(event, fn);\n  }\n}\n\nfunction remove$2 (event, fn) {\n  target.$off(event, fn);\n}\n\nfunction updateComponentListeners (\n  vm,\n  listeners,\n  oldListeners\n) {\n  target = vm;\n  updateListeners(listeners, oldListeners || {}, add$1, remove$2, vm);\n}\n\nfunction eventsMixin (Vue) {\n  var hookRE = /^hook:/;\n  Vue.prototype.$on = function (event, fn) {\n    var vm = this;(vm._events[event] || (vm._events[event] = [])).push(fn);\n    // optimize hook:event cost by using a boolean flag marked at registration\n    // instead of a hash lookup\n    if (hookRE.test(event)) {\n      vm._hasHookEvent = true;\n    }\n    return vm\n  };\n\n  Vue.prototype.$once = function (event, fn) {\n    var vm = this;\n    function on () {\n      vm.$off(event, on);\n      fn.apply(vm, arguments);\n    }\n    on.fn = fn;\n    vm.$on(event, on);\n    return vm\n  };\n\n  Vue.prototype.$off = function (event, fn) {\n    var vm = this;\n    // all\n    if (!arguments.length) {\n      vm._events = Object.create(null);\n      return vm\n    }\n    // specific event\n    var cbs = vm._events[event];\n    if (!cbs) {\n      return vm\n    }\n    if (arguments.length === 1) {\n      vm._events[event] = null;\n      return vm\n    }\n    // specific handler\n    var cb;\n    var i = cbs.length;\n    while (i--) {\n      cb = cbs[i];\n      if (cb === fn || cb.fn === fn) {\n        cbs.splice(i, 1);\n        break\n      }\n    }\n    return vm\n  };\n\n  Vue.prototype.$emit = function (event) {\n    var vm = this;\n    var cbs = vm._events[event];\n    if (cbs) {\n      cbs = cbs.length > 1 ? toArray(cbs) : cbs;\n      var args = toArray(arguments, 1);\n      for (var i = 0, l = cbs.length; i < l; i++) {\n        cbs[i].apply(vm, args);\n      }\n    }\n    return vm\n  };\n}\n\n/*  */\n\nvar activeInstance = null;\n\nfunction initLifecycle (vm) {\n  var options = vm.$options;\n\n  // locate first non-abstract parent\n  var parent = options.parent;\n  if (parent && !options.abstract) {\n    while (parent.$options.abstract && parent.$parent) {\n      parent = parent.$parent;\n    }\n    parent.$children.push(vm);\n  }\n\n  vm.$parent = parent;\n  vm.$root = parent ? parent.$root : vm;\n\n  vm.$children = [];\n  vm.$refs = {};\n\n  vm._watcher = null;\n  vm._inactive = false;\n  vm._isMounted = false;\n  vm._isDestroyed = false;\n  vm._isBeingDestroyed = false;\n}\n\nfunction lifecycleMixin (Vue) {\n  Vue.prototype._mount = function (\n    el,\n    hydrating\n  ) {\n    var vm = this;\n    vm.$el = el;\n    if (!vm.$options.render) {\n      vm.$options.render = createEmptyVNode;\n      if (false) {\n        /* istanbul ignore if */\n        if (vm.$options.template && vm.$options.template.charAt(0) !== '#') {\n          warn(\n            'You are using the runtime-only build of Vue where the template ' +\n            'option is not available. Either pre-compile the templates into ' +\n            'render functions, or use the compiler-included build.',\n            vm\n          );\n        } else {\n          warn(\n            'Failed to mount component: template or render function not defined.',\n            vm\n          );\n        }\n      }\n    }\n    callHook(vm, 'beforeMount');\n    vm._watcher = new Watcher(vm, function updateComponent () {\n      vm._update(vm._render(), hydrating);\n    }, noop);\n    hydrating = false;\n    // manually mounted instance, call mounted on self\n    // mounted is called for render-created child components in its inserted hook\n    if (vm.$vnode == null) {\n      vm._isMounted = true;\n      callHook(vm, 'mounted');\n    }\n    return vm\n  };\n\n  Vue.prototype._update = function (vnode, hydrating) {\n    var vm = this;\n    if (vm._isMounted) {\n      callHook(vm, 'beforeUpdate');\n    }\n    var prevEl = vm.$el;\n    var prevVnode = vm._vnode;\n    var prevActiveInstance = activeInstance;\n    activeInstance = vm;\n    vm._vnode = vnode;\n    // Vue.prototype.__patch__ is injected in entry points\n    // based on the rendering backend used.\n    if (!prevVnode) {\n      // initial render\n      vm.$el = vm.__patch__(\n        vm.$el, vnode, hydrating, false /* removeOnly */,\n        vm.$options._parentElm,\n        vm.$options._refElm\n      );\n    } else {\n      // updates\n      vm.$el = vm.__patch__(prevVnode, vnode);\n    }\n    activeInstance = prevActiveInstance;\n    // update __vue__ reference\n    if (prevEl) {\n      prevEl.__vue__ = null;\n    }\n    if (vm.$el) {\n      vm.$el.__vue__ = vm;\n    }\n    // if parent is an HOC, update its $el as well\n    if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {\n      vm.$parent.$el = vm.$el;\n    }\n    // updated hook is called by the scheduler to ensure that children are\n    // updated in a parent's updated hook.\n  };\n\n  Vue.prototype._updateFromParent = function (\n    propsData,\n    listeners,\n    parentVnode,\n    renderChildren\n  ) {\n    var vm = this;\n    var hasChildren = !!(vm.$options._renderChildren || renderChildren);\n    vm.$options._parentVnode = parentVnode;\n    vm.$vnode = parentVnode; // update vm's placeholder node without re-render\n    if (vm._vnode) { // update child tree's parent\n      vm._vnode.parent = parentVnode;\n    }\n    vm.$options._renderChildren = renderChildren;\n    // update props\n    if (propsData && vm.$options.props) {\n      observerState.shouldConvert = false;\n      if (false) {\n        observerState.isSettingProps = true;\n      }\n      var propKeys = vm.$options._propKeys || [];\n      for (var i = 0; i < propKeys.length; i++) {\n        var key = propKeys[i];\n        vm[key] = validateProp(key, vm.$options.props, propsData, vm);\n      }\n      observerState.shouldConvert = true;\n      if (false) {\n        observerState.isSettingProps = false;\n      }\n      vm.$options.propsData = propsData;\n    }\n    // update listeners\n    if (listeners) {\n      var oldListeners = vm.$options._parentListeners;\n      vm.$options._parentListeners = listeners;\n      updateComponentListeners(vm, listeners, oldListeners);\n    }\n    // resolve slots + force update if has children\n    if (hasChildren) {\n      vm.$slots = resolveSlots(renderChildren, parentVnode.context);\n      vm.$forceUpdate();\n    }\n  };\n\n  Vue.prototype.$forceUpdate = function () {\n    var vm = this;\n    if (vm._watcher) {\n      vm._watcher.update();\n    }\n  };\n\n  Vue.prototype.$destroy = function () {\n    var vm = this;\n    if (vm._isBeingDestroyed) {\n      return\n    }\n    callHook(vm, 'beforeDestroy');\n    vm._isBeingDestroyed = true;\n    // remove self from parent\n    var parent = vm.$parent;\n    if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {\n      remove$1(parent.$children, vm);\n    }\n    // teardown watchers\n    if (vm._watcher) {\n      vm._watcher.teardown();\n    }\n    var i = vm._watchers.length;\n    while (i--) {\n      vm._watchers[i].teardown();\n    }\n    // remove reference from data ob\n    // frozen object may not have observer.\n    if (vm._data.__ob__) {\n      vm._data.__ob__.vmCount--;\n    }\n    // call the last hook...\n    vm._isDestroyed = true;\n    callHook(vm, 'destroyed');\n    // turn off all instance listeners.\n    vm.$off();\n    // remove __vue__ reference\n    if (vm.$el) {\n      vm.$el.__vue__ = null;\n    }\n    // invoke destroy hooks on current rendered tree\n    vm.__patch__(vm._vnode, null);\n  };\n}\n\nfunction callHook (vm, hook) {\n  var handlers = vm.$options[hook];\n  if (handlers) {\n    for (var i = 0, j = handlers.length; i < j; i++) {\n      handlers[i].call(vm);\n    }\n  }\n  if (vm._hasHookEvent) {\n    vm.$emit('hook:' + hook);\n  }\n}\n\n/*  */\n\n\nvar queue = [];\nvar has$1 = {};\nvar circular = {};\nvar waiting = false;\nvar flushing = false;\nvar index = 0;\n\n/**\n * Reset the scheduler's state.\n */\nfunction resetSchedulerState () {\n  queue.length = 0;\n  has$1 = {};\n  if (false) {\n    circular = {};\n  }\n  waiting = flushing = false;\n}\n\n/**\n * Flush both queues and run the watchers.\n */\nfunction flushSchedulerQueue () {\n  flushing = true;\n  var watcher, id, vm;\n\n  // Sort queue before flush.\n  // This ensures that:\n  // 1. Components are updated from parent to child. (because parent is always\n  //    created before the child)\n  // 2. A component's user watchers are run before its render watcher (because\n  //    user watchers are created before the render watcher)\n  // 3. If a component is destroyed during a parent component's watcher run,\n  //    its watchers can be skipped.\n  queue.sort(function (a, b) { return a.id - b.id; });\n\n  // do not cache length because more watchers might be pushed\n  // as we run existing watchers\n  for (index = 0; index < queue.length; index++) {\n    watcher = queue[index];\n    id = watcher.id;\n    has$1[id] = null;\n    watcher.run();\n    // in dev build, check and stop circular updates.\n    if (false) {\n      circular[id] = (circular[id] || 0) + 1;\n      if (circular[id] > config._maxUpdateCount) {\n        warn(\n          'You may have an infinite update loop ' + (\n            watcher.user\n              ? (\"in watcher with expression \\\"\" + (watcher.expression) + \"\\\"\")\n              : \"in a component render function.\"\n          ),\n          watcher.vm\n        );\n        break\n      }\n    }\n  }\n\n  // call updated hooks\n  index = queue.length;\n  while (index--) {\n    watcher = queue[index];\n    vm = watcher.vm;\n    if (vm._watcher === watcher && vm._isMounted) {\n      callHook(vm, 'updated');\n    }\n  }\n\n  // devtool hook\n  /* istanbul ignore if */\n  if (devtools && config.devtools) {\n    devtools.emit('flush');\n  }\n\n  resetSchedulerState();\n}\n\n/**\n * Push a watcher into the watcher queue.\n * Jobs with duplicate IDs will be skipped unless it's\n * pushed when the queue is being flushed.\n */\nfunction queueWatcher (watcher) {\n  var id = watcher.id;\n  if (has$1[id] == null) {\n    has$1[id] = true;\n    if (!flushing) {\n      queue.push(watcher);\n    } else {\n      // if already flushing, splice the watcher based on its id\n      // if already past its id, it will be run next immediately.\n      var i = queue.length - 1;\n      while (i >= 0 && queue[i].id > watcher.id) {\n        i--;\n      }\n      queue.splice(Math.max(i, index) + 1, 0, watcher);\n    }\n    // queue the flush\n    if (!waiting) {\n      waiting = true;\n      nextTick(flushSchedulerQueue);\n    }\n  }\n}\n\n/*  */\n\nvar uid$2 = 0;\n\n/**\n * A watcher parses an expression, collects dependencies,\n * and fires callback when the expression value changes.\n * This is used for both the $watch() api and directives.\n */\nvar Watcher = function Watcher (\n  vm,\n  expOrFn,\n  cb,\n  options\n) {\n  this.vm = vm;\n  vm._watchers.push(this);\n  // options\n  if (options) {\n    this.deep = !!options.deep;\n    this.user = !!options.user;\n    this.lazy = !!options.lazy;\n    this.sync = !!options.sync;\n  } else {\n    this.deep = this.user = this.lazy = this.sync = false;\n  }\n  this.cb = cb;\n  this.id = ++uid$2; // uid for batching\n  this.active = true;\n  this.dirty = this.lazy; // for lazy watchers\n  this.deps = [];\n  this.newDeps = [];\n  this.depIds = new _Set();\n  this.newDepIds = new _Set();\n  this.expression =  false\n    ? expOrFn.toString()\n    : '';\n  // parse expression for getter\n  if (typeof expOrFn === 'function') {\n    this.getter = expOrFn;\n  } else {\n    this.getter = parsePath(expOrFn);\n    if (!this.getter) {\n      this.getter = function () {};\n      \"production\" !== 'production' && warn(\n        \"Failed watching path: \\\"\" + expOrFn + \"\\\" \" +\n        'Watcher only accepts simple dot-delimited paths. ' +\n        'For full control, use a function instead.',\n        vm\n      );\n    }\n  }\n  this.value = this.lazy\n    ? undefined\n    : this.get();\n};\n\n/**\n * Evaluate the getter, and re-collect dependencies.\n */\nWatcher.prototype.get = function get () {\n  pushTarget(this);\n  var value = this.getter.call(this.vm, this.vm);\n  // \"touch\" every property so they are all tracked as\n  // dependencies for deep watching\n  if (this.deep) {\n    traverse(value);\n  }\n  popTarget();\n  this.cleanupDeps();\n  return value\n};\n\n/**\n * Add a dependency to this directive.\n */\nWatcher.prototype.addDep = function addDep (dep) {\n  var id = dep.id;\n  if (!this.newDepIds.has(id)) {\n    this.newDepIds.add(id);\n    this.newDeps.push(dep);\n    if (!this.depIds.has(id)) {\n      dep.addSub(this);\n    }\n  }\n};\n\n/**\n * Clean up for dependency collection.\n */\nWatcher.prototype.cleanupDeps = function cleanupDeps () {\n    var this$1 = this;\n\n  var i = this.deps.length;\n  while (i--) {\n    var dep = this$1.deps[i];\n    if (!this$1.newDepIds.has(dep.id)) {\n      dep.removeSub(this$1);\n    }\n  }\n  var tmp = this.depIds;\n  this.depIds = this.newDepIds;\n  this.newDepIds = tmp;\n  this.newDepIds.clear();\n  tmp = this.deps;\n  this.deps = this.newDeps;\n  this.newDeps = tmp;\n  this.newDeps.length = 0;\n};\n\n/**\n * Subscriber interface.\n * Will be called when a dependency changes.\n */\nWatcher.prototype.update = function update () {\n  /* istanbul ignore else */\n  if (this.lazy) {\n    this.dirty = true;\n  } else if (this.sync) {\n    this.run();\n  } else {\n    queueWatcher(this);\n  }\n};\n\n/**\n * Scheduler job interface.\n * Will be called by the scheduler.\n */\nWatcher.prototype.run = function run () {\n  if (this.active) {\n    var value = this.get();\n    if (\n      value !== this.value ||\n      // Deep watchers and watchers on Object/Arrays should fire even\n      // when the value is the same, because the value may\n      // have mutated.\n      isObject(value) ||\n      this.deep\n    ) {\n      // set new value\n      var oldValue = this.value;\n      this.value = value;\n      if (this.user) {\n        try {\n          this.cb.call(this.vm, value, oldValue);\n        } catch (e) {\n          /* istanbul ignore else */\n          if (config.errorHandler) {\n            config.errorHandler.call(null, e, this.vm);\n          } else {\n            \"production\" !== 'production' && warn(\n              (\"Error in watcher \\\"\" + (this.expression) + \"\\\"\"),\n              this.vm\n            );\n            throw e\n          }\n        }\n      } else {\n        this.cb.call(this.vm, value, oldValue);\n      }\n    }\n  }\n};\n\n/**\n * Evaluate the value of the watcher.\n * This only gets called for lazy watchers.\n */\nWatcher.prototype.evaluate = function evaluate () {\n  this.value = this.get();\n  this.dirty = false;\n};\n\n/**\n * Depend on all deps collected by this watcher.\n */\nWatcher.prototype.depend = function depend () {\n    var this$1 = this;\n\n  var i = this.deps.length;\n  while (i--) {\n    this$1.deps[i].depend();\n  }\n};\n\n/**\n * Remove self from all dependencies' subscriber list.\n */\nWatcher.prototype.teardown = function teardown () {\n    var this$1 = this;\n\n  if (this.active) {\n    // remove self from vm's watcher list\n    // this is a somewhat expensive operation so we skip it\n    // if the vm is being destroyed.\n    if (!this.vm._isBeingDestroyed) {\n      remove$1(this.vm._watchers, this);\n    }\n    var i = this.deps.length;\n    while (i--) {\n      this$1.deps[i].removeSub(this$1);\n    }\n    this.active = false;\n  }\n};\n\n/**\n * Recursively traverse an object to evoke all converted\n * getters, so that every nested property inside the object\n * is collected as a \"deep\" dependency.\n */\nvar seenObjects = new _Set();\nfunction traverse (val) {\n  seenObjects.clear();\n  _traverse(val, seenObjects);\n}\n\nfunction _traverse (val, seen) {\n  var i, keys;\n  var isA = Array.isArray(val);\n  if ((!isA && !isObject(val)) || !Object.isExtensible(val)) {\n    return\n  }\n  if (val.__ob__) {\n    var depId = val.__ob__.dep.id;\n    if (seen.has(depId)) {\n      return\n    }\n    seen.add(depId);\n  }\n  if (isA) {\n    i = val.length;\n    while (i--) { _traverse(val[i], seen); }\n  } else {\n    keys = Object.keys(val);\n    i = keys.length;\n    while (i--) { _traverse(val[keys[i]], seen); }\n  }\n}\n\n/*  */\n\nfunction initState (vm) {\n  vm._watchers = [];\n  var opts = vm.$options;\n  if (opts.props) { initProps(vm, opts.props); }\n  if (opts.methods) { initMethods(vm, opts.methods); }\n  if (opts.data) {\n    initData(vm);\n  } else {\n    observe(vm._data = {}, true /* asRootData */);\n  }\n  if (opts.computed) { initComputed(vm, opts.computed); }\n  if (opts.watch) { initWatch(vm, opts.watch); }\n}\n\nvar isReservedProp = { key: 1, ref: 1, slot: 1 };\n\nfunction initProps (vm, props) {\n  var propsData = vm.$options.propsData || {};\n  var keys = vm.$options._propKeys = Object.keys(props);\n  var isRoot = !vm.$parent;\n  // root instance props should be converted\n  observerState.shouldConvert = isRoot;\n  var loop = function ( i ) {\n    var key = keys[i];\n    /* istanbul ignore else */\n    if (false) {\n      if (isReservedProp[key]) {\n        warn(\n          (\"\\\"\" + key + \"\\\" is a reserved attribute and cannot be used as component prop.\"),\n          vm\n        );\n      }\n      defineReactive$$1(vm, key, validateProp(key, props, propsData, vm), function () {\n        if (vm.$parent && !observerState.isSettingProps) {\n          warn(\n            \"Avoid mutating a prop directly since the value will be \" +\n            \"overwritten whenever the parent component re-renders. \" +\n            \"Instead, use a data or computed property based on the prop's \" +\n            \"value. Prop being mutated: \\\"\" + key + \"\\\"\",\n            vm\n          );\n        }\n      });\n    } else {\n      defineReactive$$1(vm, key, validateProp(key, props, propsData, vm));\n    }\n  };\n\n  for (var i = 0; i < keys.length; i++) loop( i );\n  observerState.shouldConvert = true;\n}\n\nfunction initData (vm) {\n  var data = vm.$options.data;\n  data = vm._data = typeof data === 'function'\n    ? data.call(vm)\n    : data || {};\n  if (!isPlainObject(data)) {\n    data = {};\n    \"production\" !== 'production' && warn(\n      'data functions should return an object:\\n' +\n      'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',\n      vm\n    );\n  }\n  // proxy data on instance\n  var keys = Object.keys(data);\n  var props = vm.$options.props;\n  var i = keys.length;\n  while (i--) {\n    if (props && hasOwn(props, keys[i])) {\n      \"production\" !== 'production' && warn(\n        \"The data property \\\"\" + (keys[i]) + \"\\\" is already declared as a prop. \" +\n        \"Use prop default value instead.\",\n        vm\n      );\n    } else {\n      proxy(vm, keys[i]);\n    }\n  }\n  // observe data\n  observe(data, true /* asRootData */);\n}\n\nvar computedSharedDefinition = {\n  enumerable: true,\n  configurable: true,\n  get: noop,\n  set: noop\n};\n\nfunction initComputed (vm, computed) {\n  for (var key in computed) {\n    /* istanbul ignore if */\n    if (false) {\n      warn(\n        \"existing instance property \\\"\" + key + \"\\\" will be \" +\n        \"overwritten by a computed property with the same name.\",\n        vm\n      );\n    }\n    var userDef = computed[key];\n    if (typeof userDef === 'function') {\n      computedSharedDefinition.get = makeComputedGetter(userDef, vm);\n      computedSharedDefinition.set = noop;\n    } else {\n      computedSharedDefinition.get = userDef.get\n        ? userDef.cache !== false\n          ? makeComputedGetter(userDef.get, vm)\n          : bind$1(userDef.get, vm)\n        : noop;\n      computedSharedDefinition.set = userDef.set\n        ? bind$1(userDef.set, vm)\n        : noop;\n    }\n    Object.defineProperty(vm, key, computedSharedDefinition);\n  }\n}\n\nfunction makeComputedGetter (getter, owner) {\n  var watcher = new Watcher(owner, getter, noop, {\n    lazy: true\n  });\n  return function computedGetter () {\n    if (watcher.dirty) {\n      watcher.evaluate();\n    }\n    if (Dep.target) {\n      watcher.depend();\n    }\n    return watcher.value\n  }\n}\n\nfunction initMethods (vm, methods) {\n  for (var key in methods) {\n    vm[key] = methods[key] == null ? noop : bind$1(methods[key], vm);\n    if (false) {\n      warn(\n        \"method \\\"\" + key + \"\\\" has an undefined value in the component definition. \" +\n        \"Did you reference the function correctly?\",\n        vm\n      );\n    }\n  }\n}\n\nfunction initWatch (vm, watch) {\n  for (var key in watch) {\n    var handler = watch[key];\n    if (Array.isArray(handler)) {\n      for (var i = 0; i < handler.length; i++) {\n        createWatcher(vm, key, handler[i]);\n      }\n    } else {\n      createWatcher(vm, key, handler);\n    }\n  }\n}\n\nfunction createWatcher (vm, key, handler) {\n  var options;\n  if (isPlainObject(handler)) {\n    options = handler;\n    handler = handler.handler;\n  }\n  if (typeof handler === 'string') {\n    handler = vm[handler];\n  }\n  vm.$watch(key, handler, options);\n}\n\nfunction stateMixin (Vue) {\n  // flow somehow has problems with directly declared definition object\n  // when using Object.defineProperty, so we have to procedurally build up\n  // the object here.\n  var dataDef = {};\n  dataDef.get = function () {\n    return this._data\n  };\n  if (false) {\n    dataDef.set = function (newData) {\n      warn(\n        'Avoid replacing instance root $data. ' +\n        'Use nested data properties instead.',\n        this\n      );\n    };\n  }\n  Object.defineProperty(Vue.prototype, '$data', dataDef);\n\n  Vue.prototype.$set = set$1;\n  Vue.prototype.$delete = del;\n\n  Vue.prototype.$watch = function (\n    expOrFn,\n    cb,\n    options\n  ) {\n    var vm = this;\n    options = options || {};\n    options.user = true;\n    var watcher = new Watcher(vm, expOrFn, cb, options);\n    if (options.immediate) {\n      cb.call(vm, watcher.value);\n    }\n    return function unwatchFn () {\n      watcher.teardown();\n    }\n  };\n}\n\nfunction proxy (vm, key) {\n  if (!isReserved(key)) {\n    Object.defineProperty(vm, key, {\n      configurable: true,\n      enumerable: true,\n      get: function proxyGetter () {\n        return vm._data[key]\n      },\n      set: function proxySetter (val) {\n        vm._data[key] = val;\n      }\n    });\n  }\n}\n\n/*  */\n\nvar uid = 0;\n\nfunction initMixin (Vue) {\n  Vue.prototype._init = function (options) {\n    var vm = this;\n    // a uid\n    vm._uid = uid++;\n    // a flag to avoid this being observed\n    vm._isVue = true;\n    // merge options\n    if (options && options._isComponent) {\n      // optimize internal component instantiation\n      // since dynamic options merging is pretty slow, and none of the\n      // internal component options needs special treatment.\n      initInternalComponent(vm, options);\n    } else {\n      vm.$options = mergeOptions(\n        resolveConstructorOptions(vm.constructor),\n        options || {},\n        vm\n      );\n    }\n    /* istanbul ignore else */\n    if (false) {\n      initProxy(vm);\n    } else {\n      vm._renderProxy = vm;\n    }\n    // expose real self\n    vm._self = vm;\n    initLifecycle(vm);\n    initEvents(vm);\n    initRender(vm);\n    callHook(vm, 'beforeCreate');\n    initState(vm);\n    callHook(vm, 'created');\n    if (vm.$options.el) {\n      vm.$mount(vm.$options.el);\n    }\n  };\n}\n\nfunction initInternalComponent (vm, options) {\n  var opts = vm.$options = Object.create(vm.constructor.options);\n  // doing this because it's faster than dynamic enumeration.\n  opts.parent = options.parent;\n  opts.propsData = options.propsData;\n  opts._parentVnode = options._parentVnode;\n  opts._parentListeners = options._parentListeners;\n  opts._renderChildren = options._renderChildren;\n  opts._componentTag = options._componentTag;\n  opts._parentElm = options._parentElm;\n  opts._refElm = options._refElm;\n  if (options.render) {\n    opts.render = options.render;\n    opts.staticRenderFns = options.staticRenderFns;\n  }\n}\n\nfunction resolveConstructorOptions (Ctor) {\n  var options = Ctor.options;\n  if (Ctor.super) {\n    var superOptions = Ctor.super.options;\n    var cachedSuperOptions = Ctor.superOptions;\n    var extendOptions = Ctor.extendOptions;\n    if (superOptions !== cachedSuperOptions) {\n      // super option changed\n      Ctor.superOptions = superOptions;\n      extendOptions.render = options.render;\n      extendOptions.staticRenderFns = options.staticRenderFns;\n      extendOptions._scopeId = options._scopeId;\n      options = Ctor.options = mergeOptions(superOptions, extendOptions);\n      if (options.name) {\n        options.components[options.name] = Ctor;\n      }\n    }\n  }\n  return options\n}\n\nfunction Vue$3 (options) {\n  if (false) {\n    warn('Vue is a constructor and should be called with the `new` keyword');\n  }\n  this._init(options);\n}\n\ninitMixin(Vue$3);\nstateMixin(Vue$3);\neventsMixin(Vue$3);\nlifecycleMixin(Vue$3);\nrenderMixin(Vue$3);\n\n/*  */\n\nfunction initUse (Vue) {\n  Vue.use = function (plugin) {\n    /* istanbul ignore if */\n    if (plugin.installed) {\n      return\n    }\n    // additional parameters\n    var args = toArray(arguments, 1);\n    args.unshift(this);\n    if (typeof plugin.install === 'function') {\n      plugin.install.apply(plugin, args);\n    } else {\n      plugin.apply(null, args);\n    }\n    plugin.installed = true;\n    return this\n  };\n}\n\n/*  */\n\nfunction initMixin$1 (Vue) {\n  Vue.mixin = function (mixin) {\n    this.options = mergeOptions(this.options, mixin);\n  };\n}\n\n/*  */\n\nfunction initExtend (Vue) {\n  /**\n   * Each instance constructor, including Vue, has a unique\n   * cid. This enables us to create wrapped \"child\n   * constructors\" for prototypal inheritance and cache them.\n   */\n  Vue.cid = 0;\n  var cid = 1;\n\n  /**\n   * Class inheritance\n   */\n  Vue.extend = function (extendOptions) {\n    extendOptions = extendOptions || {};\n    var Super = this;\n    var SuperId = Super.cid;\n    var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});\n    if (cachedCtors[SuperId]) {\n      return cachedCtors[SuperId]\n    }\n    var name = extendOptions.name || Super.options.name;\n    if (false) {\n      if (!/^[a-zA-Z][\\w-]*$/.test(name)) {\n        warn(\n          'Invalid component name: \"' + name + '\". Component names ' +\n          'can only contain alphanumeric characters and the hyphen, ' +\n          'and must start with a letter.'\n        );\n      }\n    }\n    var Sub = function VueComponent (options) {\n      this._init(options);\n    };\n    Sub.prototype = Object.create(Super.prototype);\n    Sub.prototype.constructor = Sub;\n    Sub.cid = cid++;\n    Sub.options = mergeOptions(\n      Super.options,\n      extendOptions\n    );\n    Sub['super'] = Super;\n    // allow further extension/mixin/plugin usage\n    Sub.extend = Super.extend;\n    Sub.mixin = Super.mixin;\n    Sub.use = Super.use;\n    // create asset registers, so extended classes\n    // can have their private assets too.\n    config._assetTypes.forEach(function (type) {\n      Sub[type] = Super[type];\n    });\n    // enable recursive self-lookup\n    if (name) {\n      Sub.options.components[name] = Sub;\n    }\n    // keep a reference to the super options at extension time.\n    // later at instantiation we can check if Super's options have\n    // been updated.\n    Sub.superOptions = Super.options;\n    Sub.extendOptions = extendOptions;\n    // cache constructor\n    cachedCtors[SuperId] = Sub;\n    return Sub\n  };\n}\n\n/*  */\n\nfunction initAssetRegisters (Vue) {\n  /**\n   * Create asset registration methods.\n   */\n  config._assetTypes.forEach(function (type) {\n    Vue[type] = function (\n      id,\n      definition\n    ) {\n      if (!definition) {\n        return this.options[type + 's'][id]\n      } else {\n        /* istanbul ignore if */\n        if (false) {\n          if (type === 'component' && config.isReservedTag(id)) {\n            warn(\n              'Do not use built-in or reserved HTML elements as component ' +\n              'id: ' + id\n            );\n          }\n        }\n        if (type === 'component' && isPlainObject(definition)) {\n          definition.name = definition.name || id;\n          definition = this.options._base.extend(definition);\n        }\n        if (type === 'directive' && typeof definition === 'function') {\n          definition = { bind: definition, update: definition };\n        }\n        this.options[type + 's'][id] = definition;\n        return definition\n      }\n    };\n  });\n}\n\n/*  */\n\nvar patternTypes = [String, RegExp];\n\nfunction getComponentName (opts) {\n  return opts && (opts.Ctor.options.name || opts.tag)\n}\n\nfunction matches (pattern, name) {\n  if (typeof pattern === 'string') {\n    return pattern.split(',').indexOf(name) > -1\n  } else {\n    return pattern.test(name)\n  }\n}\n\nfunction pruneCache (cache, filter) {\n  for (var key in cache) {\n    var cachedNode = cache[key];\n    if (cachedNode) {\n      var name = getComponentName(cachedNode.componentOptions);\n      if (name && !filter(name)) {\n        pruneCacheEntry(cachedNode);\n        cache[key] = null;\n      }\n    }\n  }\n}\n\nfunction pruneCacheEntry (vnode) {\n  if (vnode) {\n    if (!vnode.componentInstance._inactive) {\n      callHook(vnode.componentInstance, 'deactivated');\n    }\n    vnode.componentInstance.$destroy();\n  }\n}\n\nvar KeepAlive = {\n  name: 'keep-alive',\n  abstract: true,\n\n  props: {\n    include: patternTypes,\n    exclude: patternTypes\n  },\n\n  created: function created () {\n    this.cache = Object.create(null);\n  },\n\n  destroyed: function destroyed () {\n    var this$1 = this;\n\n    for (var key in this.cache) {\n      pruneCacheEntry(this$1.cache[key]);\n    }\n  },\n\n  watch: {\n    include: function include (val) {\n      pruneCache(this.cache, function (name) { return matches(val, name); });\n    },\n    exclude: function exclude (val) {\n      pruneCache(this.cache, function (name) { return !matches(val, name); });\n    }\n  },\n\n  render: function render () {\n    var vnode = getFirstComponentChild(this.$slots.default);\n    var componentOptions = vnode && vnode.componentOptions;\n    if (componentOptions) {\n      // check pattern\n      var name = getComponentName(componentOptions);\n      if (name && (\n        (this.include && !matches(this.include, name)) ||\n        (this.exclude && matches(this.exclude, name))\n      )) {\n        return vnode\n      }\n      var key = vnode.key == null\n        // same constructor may get registered as different local components\n        // so cid alone is not enough (#3269)\n        ? componentOptions.Ctor.cid + (componentOptions.tag ? (\"::\" + (componentOptions.tag)) : '')\n        : vnode.key;\n      if (this.cache[key]) {\n        vnode.componentInstance = this.cache[key].componentInstance;\n      } else {\n        this.cache[key] = vnode;\n      }\n      vnode.data.keepAlive = true;\n    }\n    return vnode\n  }\n};\n\nvar builtInComponents = {\n  KeepAlive: KeepAlive\n};\n\n/*  */\n\nfunction initGlobalAPI (Vue) {\n  // config\n  var configDef = {};\n  configDef.get = function () { return config; };\n  if (false) {\n    configDef.set = function () {\n      warn(\n        'Do not replace the Vue.config object, set individual fields instead.'\n      );\n    };\n  }\n  Object.defineProperty(Vue, 'config', configDef);\n  Vue.util = util;\n  Vue.set = set$1;\n  Vue.delete = del;\n  Vue.nextTick = nextTick;\n\n  Vue.options = Object.create(null);\n  config._assetTypes.forEach(function (type) {\n    Vue.options[type + 's'] = Object.create(null);\n  });\n\n  // this is used to identify the \"base\" constructor to extend all plain-object\n  // components with in Weex's multi-instance scenarios.\n  Vue.options._base = Vue;\n\n  extend(Vue.options.components, builtInComponents);\n\n  initUse(Vue);\n  initMixin$1(Vue);\n  initExtend(Vue);\n  initAssetRegisters(Vue);\n}\n\ninitGlobalAPI(Vue$3);\n\nObject.defineProperty(Vue$3.prototype, '$isServer', {\n  get: isServerRendering\n});\n\nVue$3.version = '2.1.10';\n\n/*  */\n\n// attributes that should be using props for binding\nvar acceptValue = makeMap('input,textarea,option,select');\nvar mustUseProp = function (tag, type, attr) {\n  return (\n    (attr === 'value' && acceptValue(tag)) && type !== 'button' ||\n    (attr === 'selected' && tag === 'option') ||\n    (attr === 'checked' && tag === 'input') ||\n    (attr === 'muted' && tag === 'video')\n  )\n};\n\nvar isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');\n\nvar isBooleanAttr = makeMap(\n  'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +\n  'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +\n  'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +\n  'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +\n  'required,reversed,scoped,seamless,selected,sortable,translate,' +\n  'truespeed,typemustmatch,visible'\n);\n\nvar xlinkNS = 'http://www.w3.org/1999/xlink';\n\nvar isXlink = function (name) {\n  return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'\n};\n\nvar getXlinkProp = function (name) {\n  return isXlink(name) ? name.slice(6, name.length) : ''\n};\n\nvar isFalsyAttrValue = function (val) {\n  return val == null || val === false\n};\n\n/*  */\n\nfunction genClassForVnode (vnode) {\n  var data = vnode.data;\n  var parentNode = vnode;\n  var childNode = vnode;\n  while (childNode.componentInstance) {\n    childNode = childNode.componentInstance._vnode;\n    if (childNode.data) {\n      data = mergeClassData(childNode.data, data);\n    }\n  }\n  while ((parentNode = parentNode.parent)) {\n    if (parentNode.data) {\n      data = mergeClassData(data, parentNode.data);\n    }\n  }\n  return genClassFromData(data)\n}\n\nfunction mergeClassData (child, parent) {\n  return {\n    staticClass: concat(child.staticClass, parent.staticClass),\n    class: child.class\n      ? [child.class, parent.class]\n      : parent.class\n  }\n}\n\nfunction genClassFromData (data) {\n  var dynamicClass = data.class;\n  var staticClass = data.staticClass;\n  if (staticClass || dynamicClass) {\n    return concat(staticClass, stringifyClass(dynamicClass))\n  }\n  /* istanbul ignore next */\n  return ''\n}\n\nfunction concat (a, b) {\n  return a ? b ? (a + ' ' + b) : a : (b || '')\n}\n\nfunction stringifyClass (value) {\n  var res = '';\n  if (!value) {\n    return res\n  }\n  if (typeof value === 'string') {\n    return value\n  }\n  if (Array.isArray(value)) {\n    var stringified;\n    for (var i = 0, l = value.length; i < l; i++) {\n      if (value[i]) {\n        if ((stringified = stringifyClass(value[i]))) {\n          res += stringified + ' ';\n        }\n      }\n    }\n    return res.slice(0, -1)\n  }\n  if (isObject(value)) {\n    for (var key in value) {\n      if (value[key]) { res += key + ' '; }\n    }\n    return res.slice(0, -1)\n  }\n  /* istanbul ignore next */\n  return res\n}\n\n/*  */\n\nvar namespaceMap = {\n  svg: 'http://www.w3.org/2000/svg',\n  math: 'http://www.w3.org/1998/Math/MathML'\n};\n\nvar isHTMLTag = makeMap(\n  'html,body,base,head,link,meta,style,title,' +\n  'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +\n  'div,dd,dl,dt,figcaption,figure,hr,img,li,main,ol,p,pre,ul,' +\n  'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +\n  's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +\n  'embed,object,param,source,canvas,script,noscript,del,ins,' +\n  'caption,col,colgroup,table,thead,tbody,td,th,tr,' +\n  'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +\n  'output,progress,select,textarea,' +\n  'details,dialog,menu,menuitem,summary,' +\n  'content,element,shadow,template'\n);\n\n// this map is intentionally selective, only covering SVG elements that may\n// contain child elements.\nvar isSVG = makeMap(\n  'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,' +\n  'font-face,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +\n  'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',\n  true\n);\n\nvar isPreTag = function (tag) { return tag === 'pre'; };\n\nvar isReservedTag = function (tag) {\n  return isHTMLTag(tag) || isSVG(tag)\n};\n\nfunction getTagNamespace (tag) {\n  if (isSVG(tag)) {\n    return 'svg'\n  }\n  // basic support for MathML\n  // note it doesn't support other MathML elements being component roots\n  if (tag === 'math') {\n    return 'math'\n  }\n}\n\nvar unknownElementCache = Object.create(null);\nfunction isUnknownElement (tag) {\n  /* istanbul ignore if */\n  if (!inBrowser) {\n    return true\n  }\n  if (isReservedTag(tag)) {\n    return false\n  }\n  tag = tag.toLowerCase();\n  /* istanbul ignore if */\n  if (unknownElementCache[tag] != null) {\n    return unknownElementCache[tag]\n  }\n  var el = document.createElement(tag);\n  if (tag.indexOf('-') > -1) {\n    // http://stackoverflow.com/a/28210364/1070244\n    return (unknownElementCache[tag] = (\n      el.constructor === window.HTMLUnknownElement ||\n      el.constructor === window.HTMLElement\n    ))\n  } else {\n    return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))\n  }\n}\n\n/*  */\n\n/**\n * Query an element selector if it's not an element already.\n */\nfunction query (el) {\n  if (typeof el === 'string') {\n    var selector = el;\n    el = document.querySelector(el);\n    if (!el) {\n      \"production\" !== 'production' && warn(\n        'Cannot find element: ' + selector\n      );\n      return document.createElement('div')\n    }\n  }\n  return el\n}\n\n/*  */\n\nfunction createElement$1 (tagName, vnode) {\n  var elm = document.createElement(tagName);\n  if (tagName !== 'select') {\n    return elm\n  }\n  if (vnode.data && vnode.data.attrs && 'multiple' in vnode.data.attrs) {\n    elm.setAttribute('multiple', 'multiple');\n  }\n  return elm\n}\n\nfunction createElementNS (namespace, tagName) {\n  return document.createElementNS(namespaceMap[namespace], tagName)\n}\n\nfunction createTextNode (text) {\n  return document.createTextNode(text)\n}\n\nfunction createComment (text) {\n  return document.createComment(text)\n}\n\nfunction insertBefore (parentNode, newNode, referenceNode) {\n  parentNode.insertBefore(newNode, referenceNode);\n}\n\nfunction removeChild (node, child) {\n  node.removeChild(child);\n}\n\nfunction appendChild (node, child) {\n  node.appendChild(child);\n}\n\nfunction parentNode (node) {\n  return node.parentNode\n}\n\nfunction nextSibling (node) {\n  return node.nextSibling\n}\n\nfunction tagName (node) {\n  return node.tagName\n}\n\nfunction setTextContent (node, text) {\n  node.textContent = text;\n}\n\nfunction setAttribute (node, key, val) {\n  node.setAttribute(key, val);\n}\n\n\nvar nodeOps = Object.freeze({\n\tcreateElement: createElement$1,\n\tcreateElementNS: createElementNS,\n\tcreateTextNode: createTextNode,\n\tcreateComment: createComment,\n\tinsertBefore: insertBefore,\n\tremoveChild: removeChild,\n\tappendChild: appendChild,\n\tparentNode: parentNode,\n\tnextSibling: nextSibling,\n\ttagName: tagName,\n\tsetTextContent: setTextContent,\n\tsetAttribute: setAttribute\n});\n\n/*  */\n\nvar ref = {\n  create: function create (_, vnode) {\n    registerRef(vnode);\n  },\n  update: function update (oldVnode, vnode) {\n    if (oldVnode.data.ref !== vnode.data.ref) {\n      registerRef(oldVnode, true);\n      registerRef(vnode);\n    }\n  },\n  destroy: function destroy (vnode) {\n    registerRef(vnode, true);\n  }\n};\n\nfunction registerRef (vnode, isRemoval) {\n  var key = vnode.data.ref;\n  if (!key) { return }\n\n  var vm = vnode.context;\n  var ref = vnode.componentInstance || vnode.elm;\n  var refs = vm.$refs;\n  if (isRemoval) {\n    if (Array.isArray(refs[key])) {\n      remove$1(refs[key], ref);\n    } else if (refs[key] === ref) {\n      refs[key] = undefined;\n    }\n  } else {\n    if (vnode.data.refInFor) {\n      if (Array.isArray(refs[key]) && refs[key].indexOf(ref) < 0) {\n        refs[key].push(ref);\n      } else {\n        refs[key] = [ref];\n      }\n    } else {\n      refs[key] = ref;\n    }\n  }\n}\n\n/**\n * Virtual DOM patching algorithm based on Snabbdom by\n * Simon Friis Vindum (@paldepind)\n * Licensed under the MIT License\n * https://github.com/paldepind/snabbdom/blob/master/LICENSE\n *\n * modified by Evan You (@yyx990803)\n *\n\n/*\n * Not type-checking this because this file is perf-critical and the cost\n * of making flow understand it is not worth it.\n */\n\nvar emptyNode = new VNode('', {}, []);\n\nvar hooks$1 = ['create', 'activate', 'update', 'remove', 'destroy'];\n\nfunction isUndef (s) {\n  return s == null\n}\n\nfunction isDef (s) {\n  return s != null\n}\n\nfunction sameVnode (vnode1, vnode2) {\n  return (\n    vnode1.key === vnode2.key &&\n    vnode1.tag === vnode2.tag &&\n    vnode1.isComment === vnode2.isComment &&\n    !vnode1.data === !vnode2.data\n  )\n}\n\nfunction createKeyToOldIdx (children, beginIdx, endIdx) {\n  var i, key;\n  var map = {};\n  for (i = beginIdx; i <= endIdx; ++i) {\n    key = children[i].key;\n    if (isDef(key)) { map[key] = i; }\n  }\n  return map\n}\n\nfunction createPatchFunction (backend) {\n  var i, j;\n  var cbs = {};\n\n  var modules = backend.modules;\n  var nodeOps = backend.nodeOps;\n\n  for (i = 0; i < hooks$1.length; ++i) {\n    cbs[hooks$1[i]] = [];\n    for (j = 0; j < modules.length; ++j) {\n      if (modules[j][hooks$1[i]] !== undefined) { cbs[hooks$1[i]].push(modules[j][hooks$1[i]]); }\n    }\n  }\n\n  function emptyNodeAt (elm) {\n    return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)\n  }\n\n  function createRmCb (childElm, listeners) {\n    function remove$$1 () {\n      if (--remove$$1.listeners === 0) {\n        removeNode(childElm);\n      }\n    }\n    remove$$1.listeners = listeners;\n    return remove$$1\n  }\n\n  function removeNode (el) {\n    var parent = nodeOps.parentNode(el);\n    // element may have already been removed due to v-html / v-text\n    if (parent) {\n      nodeOps.removeChild(parent, el);\n    }\n  }\n\n  var inPre = 0;\n  function createElm (vnode, insertedVnodeQueue, parentElm, refElm, nested) {\n    vnode.isRootInsert = !nested; // for transition enter check\n    if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {\n      return\n    }\n\n    var data = vnode.data;\n    var children = vnode.children;\n    var tag = vnode.tag;\n    if (isDef(tag)) {\n      if (false) {\n        if (data && data.pre) {\n          inPre++;\n        }\n        if (\n          !inPre &&\n          !vnode.ns &&\n          !(config.ignoredElements.length && config.ignoredElements.indexOf(tag) > -1) &&\n          config.isUnknownElement(tag)\n        ) {\n          warn(\n            'Unknown custom element: <' + tag + '> - did you ' +\n            'register the component correctly? For recursive components, ' +\n            'make sure to provide the \"name\" option.',\n            vnode.context\n          );\n        }\n      }\n      vnode.elm = vnode.ns\n        ? nodeOps.createElementNS(vnode.ns, tag)\n        : nodeOps.createElement(tag, vnode);\n      setScope(vnode);\n\n      /* istanbul ignore if */\n      {\n        createChildren(vnode, children, insertedVnodeQueue);\n        if (isDef(data)) {\n          invokeCreateHooks(vnode, insertedVnodeQueue);\n        }\n        insert(parentElm, vnode.elm, refElm);\n      }\n\n      if (false) {\n        inPre--;\n      }\n    } else if (vnode.isComment) {\n      vnode.elm = nodeOps.createComment(vnode.text);\n      insert(parentElm, vnode.elm, refElm);\n    } else {\n      vnode.elm = nodeOps.createTextNode(vnode.text);\n      insert(parentElm, vnode.elm, refElm);\n    }\n  }\n\n  function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {\n    var i = vnode.data;\n    if (isDef(i)) {\n      var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;\n      if (isDef(i = i.hook) && isDef(i = i.init)) {\n        i(vnode, false /* hydrating */, parentElm, refElm);\n      }\n      // after calling the init hook, if the vnode is a child component\n      // it should've created a child instance and mounted it. the child\n      // component also has set the placeholder vnode's elm.\n      // in that case we can just return the element and be done.\n      if (isDef(vnode.componentInstance)) {\n        initComponent(vnode, insertedVnodeQueue);\n        if (isReactivated) {\n          reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);\n        }\n        return true\n      }\n    }\n  }\n\n  function initComponent (vnode, insertedVnodeQueue) {\n    if (vnode.data.pendingInsert) {\n      insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);\n    }\n    vnode.elm = vnode.componentInstance.$el;\n    if (isPatchable(vnode)) {\n      invokeCreateHooks(vnode, insertedVnodeQueue);\n      setScope(vnode);\n    } else {\n      // empty component root.\n      // skip all element-related modules except for ref (#3455)\n      registerRef(vnode);\n      // make sure to invoke the insert hook\n      insertedVnodeQueue.push(vnode);\n    }\n  }\n\n  function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {\n    var i;\n    // hack for #4339: a reactivated component with inner transition\n    // does not trigger because the inner node's created hooks are not called\n    // again. It's not ideal to involve module-specific logic in here but\n    // there doesn't seem to be a better way to do it.\n    var innerNode = vnode;\n    while (innerNode.componentInstance) {\n      innerNode = innerNode.componentInstance._vnode;\n      if (isDef(i = innerNode.data) && isDef(i = i.transition)) {\n        for (i = 0; i < cbs.activate.length; ++i) {\n          cbs.activate[i](emptyNode, innerNode);\n        }\n        insertedVnodeQueue.push(innerNode);\n        break\n      }\n    }\n    // unlike a newly created component,\n    // a reactivated keep-alive component doesn't insert itself\n    insert(parentElm, vnode.elm, refElm);\n  }\n\n  function insert (parent, elm, ref) {\n    if (parent) {\n      if (ref) {\n        nodeOps.insertBefore(parent, elm, ref);\n      } else {\n        nodeOps.appendChild(parent, elm);\n      }\n    }\n  }\n\n  function createChildren (vnode, children, insertedVnodeQueue) {\n    if (Array.isArray(children)) {\n      for (var i = 0; i < children.length; ++i) {\n        createElm(children[i], insertedVnodeQueue, vnode.elm, null, true);\n      }\n    } else if (isPrimitive(vnode.text)) {\n      nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(vnode.text));\n    }\n  }\n\n  function isPatchable (vnode) {\n    while (vnode.componentInstance) {\n      vnode = vnode.componentInstance._vnode;\n    }\n    return isDef(vnode.tag)\n  }\n\n  function invokeCreateHooks (vnode, insertedVnodeQueue) {\n    for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {\n      cbs.create[i$1](emptyNode, vnode);\n    }\n    i = vnode.data.hook; // Reuse variable\n    if (isDef(i)) {\n      if (i.create) { i.create(emptyNode, vnode); }\n      if (i.insert) { insertedVnodeQueue.push(vnode); }\n    }\n  }\n\n  // set scope id attribute for scoped CSS.\n  // this is implemented as a special case to avoid the overhead\n  // of going through the normal attribute patching process.\n  function setScope (vnode) {\n    var i;\n    if (isDef(i = vnode.context) && isDef(i = i.$options._scopeId)) {\n      nodeOps.setAttribute(vnode.elm, i, '');\n    }\n    if (isDef(i = activeInstance) &&\n        i !== vnode.context &&\n        isDef(i = i.$options._scopeId)) {\n      nodeOps.setAttribute(vnode.elm, i, '');\n    }\n  }\n\n  function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm);\n    }\n  }\n\n  function invokeDestroyHook (vnode) {\n    var i, j;\n    var data = vnode.data;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }\n      for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); }\n    }\n    if (isDef(i = vnode.children)) {\n      for (j = 0; j < vnode.children.length; ++j) {\n        invokeDestroyHook(vnode.children[j]);\n      }\n    }\n  }\n\n  function removeVnodes (parentElm, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      var ch = vnodes[startIdx];\n      if (isDef(ch)) {\n        if (isDef(ch.tag)) {\n          removeAndInvokeRemoveHook(ch);\n          invokeDestroyHook(ch);\n        } else { // Text node\n          removeNode(ch.elm);\n        }\n      }\n    }\n  }\n\n  function removeAndInvokeRemoveHook (vnode, rm) {\n    if (rm || isDef(vnode.data)) {\n      var listeners = cbs.remove.length + 1;\n      if (!rm) {\n        // directly removing\n        rm = createRmCb(vnode.elm, listeners);\n      } else {\n        // we have a recursively passed down rm callback\n        // increase the listeners count\n        rm.listeners += listeners;\n      }\n      // recursively invoke hooks on child component root node\n      if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {\n        removeAndInvokeRemoveHook(i, rm);\n      }\n      for (i = 0; i < cbs.remove.length; ++i) {\n        cbs.remove[i](vnode, rm);\n      }\n      if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {\n        i(vnode, rm);\n      } else {\n        rm();\n      }\n    } else {\n      removeNode(vnode.elm);\n    }\n  }\n\n  function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {\n    var oldStartIdx = 0;\n    var newStartIdx = 0;\n    var oldEndIdx = oldCh.length - 1;\n    var oldStartVnode = oldCh[0];\n    var oldEndVnode = oldCh[oldEndIdx];\n    var newEndIdx = newCh.length - 1;\n    var newStartVnode = newCh[0];\n    var newEndVnode = newCh[newEndIdx];\n    var oldKeyToIdx, idxInOld, elmToMove, refElm;\n\n    // removeOnly is a special flag used only by <transition-group>\n    // to ensure removed elements stay in correct relative positions\n    // during leaving transitions\n    var canMove = !removeOnly;\n\n    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n      if (isUndef(oldStartVnode)) {\n        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n      } else if (isUndef(oldEndVnode)) {\n        oldEndVnode = oldCh[--oldEndIdx];\n      } else if (sameVnode(oldStartVnode, newStartVnode)) {\n        patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);\n        canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));\n        oldStartVnode = oldCh[++oldStartIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);\n        canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else {\n        if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }\n        idxInOld = isDef(newStartVnode.key) ? oldKeyToIdx[newStartVnode.key] : null;\n        if (isUndef(idxInOld)) { // New element\n          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        } else {\n          elmToMove = oldCh[idxInOld];\n          /* istanbul ignore if */\n          if (false) {\n            warn(\n              'It seems there are duplicate keys that is causing an update error. ' +\n              'Make sure each v-for item has a unique key.'\n            );\n          }\n          if (sameVnode(elmToMove, newStartVnode)) {\n            patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);\n            oldCh[idxInOld] = undefined;\n            canMove && nodeOps.insertBefore(parentElm, newStartVnode.elm, oldStartVnode.elm);\n            newStartVnode = newCh[++newStartIdx];\n          } else {\n            // same key but different element. treat as new element\n            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);\n            newStartVnode = newCh[++newStartIdx];\n          }\n        }\n      }\n    }\n    if (oldStartIdx > oldEndIdx) {\n      refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;\n      addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);\n    } else if (newStartIdx > newEndIdx) {\n      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n    }\n  }\n\n  function patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly) {\n    if (oldVnode === vnode) {\n      return\n    }\n    // reuse element for static trees.\n    // note we only do this if the vnode is cloned -\n    // if the new node is not cloned it means the render functions have been\n    // reset by the hot-reload-api and we need to do a proper re-render.\n    if (vnode.isStatic &&\n        oldVnode.isStatic &&\n        vnode.key === oldVnode.key &&\n        (vnode.isCloned || vnode.isOnce)) {\n      vnode.elm = oldVnode.elm;\n      vnode.componentInstance = oldVnode.componentInstance;\n      return\n    }\n    var i;\n    var data = vnode.data;\n    var hasData = isDef(data);\n    if (hasData && isDef(i = data.hook) && isDef(i = i.prepatch)) {\n      i(oldVnode, vnode);\n    }\n    var elm = vnode.elm = oldVnode.elm;\n    var oldCh = oldVnode.children;\n    var ch = vnode.children;\n    if (hasData && isPatchable(vnode)) {\n      for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); }\n      if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }\n    }\n    if (isUndef(vnode.text)) {\n      if (isDef(oldCh) && isDef(ch)) {\n        if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }\n      } else if (isDef(ch)) {\n        if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }\n        addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);\n      } else if (isDef(oldCh)) {\n        removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n      } else if (isDef(oldVnode.text)) {\n        nodeOps.setTextContent(elm, '');\n      }\n    } else if (oldVnode.text !== vnode.text) {\n      nodeOps.setTextContent(elm, vnode.text);\n    }\n    if (hasData) {\n      if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); }\n    }\n  }\n\n  function invokeInsertHook (vnode, queue, initial) {\n    // delay insert hooks for component root nodes, invoke them after the\n    // element is really inserted\n    if (initial && vnode.parent) {\n      vnode.parent.data.pendingInsert = queue;\n    } else {\n      for (var i = 0; i < queue.length; ++i) {\n        queue[i].data.hook.insert(queue[i]);\n      }\n    }\n  }\n\n  var bailed = false;\n  // list of modules that can skip create hook during hydration because they\n  // are already rendered on the client or has no need for initialization\n  var isRenderedModule = makeMap('attrs,style,class,staticClass,staticStyle,key');\n\n  // Note: this is a browser-only function so we can assume elms are DOM nodes.\n  function hydrate (elm, vnode, insertedVnodeQueue) {\n    if (false) {\n      if (!assertNodeMatch(elm, vnode)) {\n        return false\n      }\n    }\n    vnode.elm = elm;\n    var tag = vnode.tag;\n    var data = vnode.data;\n    var children = vnode.children;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }\n      if (isDef(i = vnode.componentInstance)) {\n        // child component. it should have hydrated its own tree.\n        initComponent(vnode, insertedVnodeQueue);\n        return true\n      }\n    }\n    if (isDef(tag)) {\n      if (isDef(children)) {\n        // empty element, allow client to pick up and populate children\n        if (!elm.hasChildNodes()) {\n          createChildren(vnode, children, insertedVnodeQueue);\n        } else {\n          var childrenMatch = true;\n          var childNode = elm.firstChild;\n          for (var i$1 = 0; i$1 < children.length; i$1++) {\n            if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue)) {\n              childrenMatch = false;\n              break\n            }\n            childNode = childNode.nextSibling;\n          }\n          // if childNode is not null, it means the actual childNodes list is\n          // longer than the virtual children list.\n          if (!childrenMatch || childNode) {\n            if (false) {\n              bailed = true;\n              console.warn('Parent: ', elm);\n              console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);\n            }\n            return false\n          }\n        }\n      }\n      if (isDef(data)) {\n        for (var key in data) {\n          if (!isRenderedModule(key)) {\n            invokeCreateHooks(vnode, insertedVnodeQueue);\n            break\n          }\n        }\n      }\n    } else if (elm.data !== vnode.text) {\n      elm.data = vnode.text;\n    }\n    return true\n  }\n\n  function assertNodeMatch (node, vnode) {\n    if (vnode.tag) {\n      return (\n        vnode.tag.indexOf('vue-component') === 0 ||\n        vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())\n      )\n    } else {\n      return node.nodeType === (vnode.isComment ? 8 : 3)\n    }\n  }\n\n  return function patch (oldVnode, vnode, hydrating, removeOnly, parentElm, refElm) {\n    if (!vnode) {\n      if (oldVnode) { invokeDestroyHook(oldVnode); }\n      return\n    }\n\n    var isInitialPatch = false;\n    var insertedVnodeQueue = [];\n\n    if (!oldVnode) {\n      // empty mount (likely as component), create new root element\n      isInitialPatch = true;\n      createElm(vnode, insertedVnodeQueue, parentElm, refElm);\n    } else {\n      var isRealElement = isDef(oldVnode.nodeType);\n      if (!isRealElement && sameVnode(oldVnode, vnode)) {\n        // patch existing root node\n        patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly);\n      } else {\n        if (isRealElement) {\n          // mounting to a real element\n          // check if this is server-rendered content and if we can perform\n          // a successful hydration.\n          if (oldVnode.nodeType === 1 && oldVnode.hasAttribute('server-rendered')) {\n            oldVnode.removeAttribute('server-rendered');\n            hydrating = true;\n          }\n          if (hydrating) {\n            if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {\n              invokeInsertHook(vnode, insertedVnodeQueue, true);\n              return oldVnode\n            } else if (false) {\n              warn(\n                'The client-side rendered virtual DOM tree is not matching ' +\n                'server-rendered content. This is likely caused by incorrect ' +\n                'HTML markup, for example nesting block-level elements inside ' +\n                '<p>, or missing <tbody>. Bailing hydration and performing ' +\n                'full client-side render.'\n              );\n            }\n          }\n          // either not server-rendered, or hydration failed.\n          // create an empty node and replace it\n          oldVnode = emptyNodeAt(oldVnode);\n        }\n        // replacing existing element\n        var oldElm = oldVnode.elm;\n        var parentElm$1 = nodeOps.parentNode(oldElm);\n        createElm(\n          vnode,\n          insertedVnodeQueue,\n          // extremely rare edge case: do not insert if old element is in a\n          // leaving transition. Only happens when combining transition +\n          // keep-alive + HOCs. (#4590)\n          oldElm._leaveCb ? null : parentElm$1,\n          nodeOps.nextSibling(oldElm)\n        );\n\n        if (vnode.parent) {\n          // component root element replaced.\n          // update parent placeholder node element, recursively\n          var ancestor = vnode.parent;\n          while (ancestor) {\n            ancestor.elm = vnode.elm;\n            ancestor = ancestor.parent;\n          }\n          if (isPatchable(vnode)) {\n            for (var i = 0; i < cbs.create.length; ++i) {\n              cbs.create[i](emptyNode, vnode.parent);\n            }\n          }\n        }\n\n        if (parentElm$1 !== null) {\n          removeVnodes(parentElm$1, [oldVnode], 0, 0);\n        } else if (isDef(oldVnode.tag)) {\n          invokeDestroyHook(oldVnode);\n        }\n      }\n    }\n\n    invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);\n    return vnode.elm\n  }\n}\n\n/*  */\n\nvar directives = {\n  create: updateDirectives,\n  update: updateDirectives,\n  destroy: function unbindDirectives (vnode) {\n    updateDirectives(vnode, emptyNode);\n  }\n};\n\nfunction updateDirectives (oldVnode, vnode) {\n  if (oldVnode.data.directives || vnode.data.directives) {\n    _update(oldVnode, vnode);\n  }\n}\n\nfunction _update (oldVnode, vnode) {\n  var isCreate = oldVnode === emptyNode;\n  var isDestroy = vnode === emptyNode;\n  var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);\n  var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);\n\n  var dirsWithInsert = [];\n  var dirsWithPostpatch = [];\n\n  var key, oldDir, dir;\n  for (key in newDirs) {\n    oldDir = oldDirs[key];\n    dir = newDirs[key];\n    if (!oldDir) {\n      // new directive, bind\n      callHook$1(dir, 'bind', vnode, oldVnode);\n      if (dir.def && dir.def.inserted) {\n        dirsWithInsert.push(dir);\n      }\n    } else {\n      // existing directive, update\n      dir.oldValue = oldDir.value;\n      callHook$1(dir, 'update', vnode, oldVnode);\n      if (dir.def && dir.def.componentUpdated) {\n        dirsWithPostpatch.push(dir);\n      }\n    }\n  }\n\n  if (dirsWithInsert.length) {\n    var callInsert = function () {\n      for (var i = 0; i < dirsWithInsert.length; i++) {\n        callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);\n      }\n    };\n    if (isCreate) {\n      mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', callInsert, 'dir-insert');\n    } else {\n      callInsert();\n    }\n  }\n\n  if (dirsWithPostpatch.length) {\n    mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'postpatch', function () {\n      for (var i = 0; i < dirsWithPostpatch.length; i++) {\n        callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);\n      }\n    }, 'dir-postpatch');\n  }\n\n  if (!isCreate) {\n    for (key in oldDirs) {\n      if (!newDirs[key]) {\n        // no longer present, unbind\n        callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);\n      }\n    }\n  }\n}\n\nvar emptyModifiers = Object.create(null);\n\nfunction normalizeDirectives$1 (\n  dirs,\n  vm\n) {\n  var res = Object.create(null);\n  if (!dirs) {\n    return res\n  }\n  var i, dir;\n  for (i = 0; i < dirs.length; i++) {\n    dir = dirs[i];\n    if (!dir.modifiers) {\n      dir.modifiers = emptyModifiers;\n    }\n    res[getRawDirName(dir)] = dir;\n    dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);\n  }\n  return res\n}\n\nfunction getRawDirName (dir) {\n  return dir.rawName || ((dir.name) + \".\" + (Object.keys(dir.modifiers || {}).join('.')))\n}\n\nfunction callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {\n  var fn = dir.def && dir.def[hook];\n  if (fn) {\n    fn(vnode.elm, dir, vnode, oldVnode, isDestroy);\n  }\n}\n\nvar baseModules = [\n  ref,\n  directives\n];\n\n/*  */\n\nfunction updateAttrs (oldVnode, vnode) {\n  if (!oldVnode.data.attrs && !vnode.data.attrs) {\n    return\n  }\n  var key, cur, old;\n  var elm = vnode.elm;\n  var oldAttrs = oldVnode.data.attrs || {};\n  var attrs = vnode.data.attrs || {};\n  // clone observed objects, as the user probably wants to mutate it\n  if (attrs.__ob__) {\n    attrs = vnode.data.attrs = extend({}, attrs);\n  }\n\n  for (key in attrs) {\n    cur = attrs[key];\n    old = oldAttrs[key];\n    if (old !== cur) {\n      setAttr(elm, key, cur);\n    }\n  }\n  // #4391: in IE9, setting type can reset value for input[type=radio]\n  /* istanbul ignore if */\n  if (isIE9 && attrs.value !== oldAttrs.value) {\n    setAttr(elm, 'value', attrs.value);\n  }\n  for (key in oldAttrs) {\n    if (attrs[key] == null) {\n      if (isXlink(key)) {\n        elm.removeAttributeNS(xlinkNS, getXlinkProp(key));\n      } else if (!isEnumeratedAttr(key)) {\n        elm.removeAttribute(key);\n      }\n    }\n  }\n}\n\nfunction setAttr (el, key, value) {\n  if (isBooleanAttr(key)) {\n    // set attribute for blank value\n    // e.g. <option disabled>Select one</option>\n    if (isFalsyAttrValue(value)) {\n      el.removeAttribute(key);\n    } else {\n      el.setAttribute(key, key);\n    }\n  } else if (isEnumeratedAttr(key)) {\n    el.setAttribute(key, isFalsyAttrValue(value) || value === 'false' ? 'false' : 'true');\n  } else if (isXlink(key)) {\n    if (isFalsyAttrValue(value)) {\n      el.removeAttributeNS(xlinkNS, getXlinkProp(key));\n    } else {\n      el.setAttributeNS(xlinkNS, key, value);\n    }\n  } else {\n    if (isFalsyAttrValue(value)) {\n      el.removeAttribute(key);\n    } else {\n      el.setAttribute(key, value);\n    }\n  }\n}\n\nvar attrs = {\n  create: updateAttrs,\n  update: updateAttrs\n};\n\n/*  */\n\nfunction updateClass (oldVnode, vnode) {\n  var el = vnode.elm;\n  var data = vnode.data;\n  var oldData = oldVnode.data;\n  if (!data.staticClass && !data.class &&\n      (!oldData || (!oldData.staticClass && !oldData.class))) {\n    return\n  }\n\n  var cls = genClassForVnode(vnode);\n\n  // handle transition classes\n  var transitionClass = el._transitionClasses;\n  if (transitionClass) {\n    cls = concat(cls, stringifyClass(transitionClass));\n  }\n\n  // set the class\n  if (cls !== el._prevClass) {\n    el.setAttribute('class', cls);\n    el._prevClass = cls;\n  }\n}\n\nvar klass = {\n  create: updateClass,\n  update: updateClass\n};\n\n/*  */\n\nvar target$1;\n\nfunction add$2 (\n  event,\n  handler,\n  once,\n  capture\n) {\n  if (once) {\n    var oldHandler = handler;\n    var _target = target$1; // save current target element in closure\n    handler = function (ev) {\n      remove$3(event, handler, capture, _target);\n      arguments.length === 1\n        ? oldHandler(ev)\n        : oldHandler.apply(null, arguments);\n    };\n  }\n  target$1.addEventListener(event, handler, capture);\n}\n\nfunction remove$3 (\n  event,\n  handler,\n  capture,\n  _target\n) {\n  (_target || target$1).removeEventListener(event, handler, capture);\n}\n\nfunction updateDOMListeners (oldVnode, vnode) {\n  if (!oldVnode.data.on && !vnode.data.on) {\n    return\n  }\n  var on = vnode.data.on || {};\n  var oldOn = oldVnode.data.on || {};\n  target$1 = vnode.elm;\n  updateListeners(on, oldOn, add$2, remove$3, vnode.context);\n}\n\nvar events = {\n  create: updateDOMListeners,\n  update: updateDOMListeners\n};\n\n/*  */\n\nfunction updateDOMProps (oldVnode, vnode) {\n  if (!oldVnode.data.domProps && !vnode.data.domProps) {\n    return\n  }\n  var key, cur;\n  var elm = vnode.elm;\n  var oldProps = oldVnode.data.domProps || {};\n  var props = vnode.data.domProps || {};\n  // clone observed objects, as the user probably wants to mutate it\n  if (props.__ob__) {\n    props = vnode.data.domProps = extend({}, props);\n  }\n\n  for (key in oldProps) {\n    if (props[key] == null) {\n      elm[key] = '';\n    }\n  }\n  for (key in props) {\n    cur = props[key];\n    // ignore children if the node has textContent or innerHTML,\n    // as these will throw away existing DOM nodes and cause removal errors\n    // on subsequent patches (#3360)\n    if (key === 'textContent' || key === 'innerHTML') {\n      if (vnode.children) { vnode.children.length = 0; }\n      if (cur === oldProps[key]) { continue }\n    }\n\n    if (key === 'value') {\n      // store value as _value as well since\n      // non-string values will be stringified\n      elm._value = cur;\n      // avoid resetting cursor position when value is the same\n      var strCur = cur == null ? '' : String(cur);\n      if (shouldUpdateValue(elm, vnode, strCur)) {\n        elm.value = strCur;\n      }\n    } else {\n      elm[key] = cur;\n    }\n  }\n}\n\n// check platforms/web/util/attrs.js acceptValue\n\n\nfunction shouldUpdateValue (\n  elm,\n  vnode,\n  checkVal\n) {\n  return (!elm.composing && (\n    vnode.tag === 'option' ||\n    isDirty(elm, checkVal) ||\n    isInputChanged(vnode, checkVal)\n  ))\n}\n\nfunction isDirty (elm, checkVal) {\n  // return true when textbox (.number and .trim) loses focus and its value is not equal to the updated value\n  return document.activeElement !== elm && elm.value !== checkVal\n}\n\nfunction isInputChanged (vnode, newVal) {\n  var value = vnode.elm.value;\n  var modifiers = vnode.elm._vModifiers; // injected by v-model runtime\n  if ((modifiers && modifiers.number) || vnode.elm.type === 'number') {\n    return toNumber(value) !== toNumber(newVal)\n  }\n  if (modifiers && modifiers.trim) {\n    return value.trim() !== newVal.trim()\n  }\n  return value !== newVal\n}\n\nvar domProps = {\n  create: updateDOMProps,\n  update: updateDOMProps\n};\n\n/*  */\n\nvar parseStyleText = cached(function (cssText) {\n  var res = {};\n  var listDelimiter = /;(?![^(]*\\))/g;\n  var propertyDelimiter = /:(.+)/;\n  cssText.split(listDelimiter).forEach(function (item) {\n    if (item) {\n      var tmp = item.split(propertyDelimiter);\n      tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());\n    }\n  });\n  return res\n});\n\n// merge static and dynamic style data on the same vnode\nfunction normalizeStyleData (data) {\n  var style = normalizeStyleBinding(data.style);\n  // static style is pre-processed into an object during compilation\n  // and is always a fresh object, so it's safe to merge into it\n  return data.staticStyle\n    ? extend(data.staticStyle, style)\n    : style\n}\n\n// normalize possible array / string values into Object\nfunction normalizeStyleBinding (bindingStyle) {\n  if (Array.isArray(bindingStyle)) {\n    return toObject(bindingStyle)\n  }\n  if (typeof bindingStyle === 'string') {\n    return parseStyleText(bindingStyle)\n  }\n  return bindingStyle\n}\n\n/**\n * parent component style should be after child's\n * so that parent component's style could override it\n */\nfunction getStyle (vnode, checkChild) {\n  var res = {};\n  var styleData;\n\n  if (checkChild) {\n    var childNode = vnode;\n    while (childNode.componentInstance) {\n      childNode = childNode.componentInstance._vnode;\n      if (childNode.data && (styleData = normalizeStyleData(childNode.data))) {\n        extend(res, styleData);\n      }\n    }\n  }\n\n  if ((styleData = normalizeStyleData(vnode.data))) {\n    extend(res, styleData);\n  }\n\n  var parentNode = vnode;\n  while ((parentNode = parentNode.parent)) {\n    if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {\n      extend(res, styleData);\n    }\n  }\n  return res\n}\n\n/*  */\n\nvar cssVarRE = /^--/;\nvar importantRE = /\\s*!important$/;\nvar setProp = function (el, name, val) {\n  /* istanbul ignore if */\n  if (cssVarRE.test(name)) {\n    el.style.setProperty(name, val);\n  } else if (importantRE.test(val)) {\n    el.style.setProperty(name, val.replace(importantRE, ''), 'important');\n  } else {\n    el.style[normalize(name)] = val;\n  }\n};\n\nvar prefixes = ['Webkit', 'Moz', 'ms'];\n\nvar testEl;\nvar normalize = cached(function (prop) {\n  testEl = testEl || document.createElement('div');\n  prop = camelize(prop);\n  if (prop !== 'filter' && (prop in testEl.style)) {\n    return prop\n  }\n  var upper = prop.charAt(0).toUpperCase() + prop.slice(1);\n  for (var i = 0; i < prefixes.length; i++) {\n    var prefixed = prefixes[i] + upper;\n    if (prefixed in testEl.style) {\n      return prefixed\n    }\n  }\n});\n\nfunction updateStyle (oldVnode, vnode) {\n  var data = vnode.data;\n  var oldData = oldVnode.data;\n\n  if (!data.staticStyle && !data.style &&\n      !oldData.staticStyle && !oldData.style) {\n    return\n  }\n\n  var cur, name;\n  var el = vnode.elm;\n  var oldStaticStyle = oldVnode.data.staticStyle;\n  var oldStyleBinding = oldVnode.data.style || {};\n\n  // if static style exists, stylebinding already merged into it when doing normalizeStyleData\n  var oldStyle = oldStaticStyle || oldStyleBinding;\n\n  var style = normalizeStyleBinding(vnode.data.style) || {};\n\n  vnode.data.style = style.__ob__ ? extend({}, style) : style;\n\n  var newStyle = getStyle(vnode, true);\n\n  for (name in oldStyle) {\n    if (newStyle[name] == null) {\n      setProp(el, name, '');\n    }\n  }\n  for (name in newStyle) {\n    cur = newStyle[name];\n    if (cur !== oldStyle[name]) {\n      // ie9 setting to null has no effect, must use empty string\n      setProp(el, name, cur == null ? '' : cur);\n    }\n  }\n}\n\nvar style = {\n  create: updateStyle,\n  update: updateStyle\n};\n\n/*  */\n\n/**\n * Add class with compatibility for SVG since classList is not supported on\n * SVG elements in IE\n */\nfunction addClass (el, cls) {\n  /* istanbul ignore if */\n  if (!cls || !cls.trim()) {\n    return\n  }\n\n  /* istanbul ignore else */\n  if (el.classList) {\n    if (cls.indexOf(' ') > -1) {\n      cls.split(/\\s+/).forEach(function (c) { return el.classList.add(c); });\n    } else {\n      el.classList.add(cls);\n    }\n  } else {\n    var cur = ' ' + el.getAttribute('class') + ' ';\n    if (cur.indexOf(' ' + cls + ' ') < 0) {\n      el.setAttribute('class', (cur + cls).trim());\n    }\n  }\n}\n\n/**\n * Remove class with compatibility for SVG since classList is not supported on\n * SVG elements in IE\n */\nfunction removeClass (el, cls) {\n  /* istanbul ignore if */\n  if (!cls || !cls.trim()) {\n    return\n  }\n\n  /* istanbul ignore else */\n  if (el.classList) {\n    if (cls.indexOf(' ') > -1) {\n      cls.split(/\\s+/).forEach(function (c) { return el.classList.remove(c); });\n    } else {\n      el.classList.remove(cls);\n    }\n  } else {\n    var cur = ' ' + el.getAttribute('class') + ' ';\n    var tar = ' ' + cls + ' ';\n    while (cur.indexOf(tar) >= 0) {\n      cur = cur.replace(tar, ' ');\n    }\n    el.setAttribute('class', cur.trim());\n  }\n}\n\n/*  */\n\nvar hasTransition = inBrowser && !isIE9;\nvar TRANSITION = 'transition';\nvar ANIMATION = 'animation';\n\n// Transition property/event sniffing\nvar transitionProp = 'transition';\nvar transitionEndEvent = 'transitionend';\nvar animationProp = 'animation';\nvar animationEndEvent = 'animationend';\nif (hasTransition) {\n  /* istanbul ignore if */\n  if (window.ontransitionend === undefined &&\n    window.onwebkittransitionend !== undefined) {\n    transitionProp = 'WebkitTransition';\n    transitionEndEvent = 'webkitTransitionEnd';\n  }\n  if (window.onanimationend === undefined &&\n    window.onwebkitanimationend !== undefined) {\n    animationProp = 'WebkitAnimation';\n    animationEndEvent = 'webkitAnimationEnd';\n  }\n}\n\n// binding to window is necessary to make hot reload work in IE in strict mode\nvar raf = inBrowser && window.requestAnimationFrame\n  ? window.requestAnimationFrame.bind(window)\n  : setTimeout;\n\nfunction nextFrame (fn) {\n  raf(function () {\n    raf(fn);\n  });\n}\n\nfunction addTransitionClass (el, cls) {\n  (el._transitionClasses || (el._transitionClasses = [])).push(cls);\n  addClass(el, cls);\n}\n\nfunction removeTransitionClass (el, cls) {\n  if (el._transitionClasses) {\n    remove$1(el._transitionClasses, cls);\n  }\n  removeClass(el, cls);\n}\n\nfunction whenTransitionEnds (\n  el,\n  expectedType,\n  cb\n) {\n  var ref = getTransitionInfo(el, expectedType);\n  var type = ref.type;\n  var timeout = ref.timeout;\n  var propCount = ref.propCount;\n  if (!type) { return cb() }\n  var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;\n  var ended = 0;\n  var end = function () {\n    el.removeEventListener(event, onEnd);\n    cb();\n  };\n  var onEnd = function (e) {\n    if (e.target === el) {\n      if (++ended >= propCount) {\n        end();\n      }\n    }\n  };\n  setTimeout(function () {\n    if (ended < propCount) {\n      end();\n    }\n  }, timeout + 1);\n  el.addEventListener(event, onEnd);\n}\n\nvar transformRE = /\\b(transform|all)(,|$)/;\n\nfunction getTransitionInfo (el, expectedType) {\n  var styles = window.getComputedStyle(el);\n  var transitioneDelays = styles[transitionProp + 'Delay'].split(', ');\n  var transitionDurations = styles[transitionProp + 'Duration'].split(', ');\n  var transitionTimeout = getTimeout(transitioneDelays, transitionDurations);\n  var animationDelays = styles[animationProp + 'Delay'].split(', ');\n  var animationDurations = styles[animationProp + 'Duration'].split(', ');\n  var animationTimeout = getTimeout(animationDelays, animationDurations);\n\n  var type;\n  var timeout = 0;\n  var propCount = 0;\n  /* istanbul ignore if */\n  if (expectedType === TRANSITION) {\n    if (transitionTimeout > 0) {\n      type = TRANSITION;\n      timeout = transitionTimeout;\n      propCount = transitionDurations.length;\n    }\n  } else if (expectedType === ANIMATION) {\n    if (animationTimeout > 0) {\n      type = ANIMATION;\n      timeout = animationTimeout;\n      propCount = animationDurations.length;\n    }\n  } else {\n    timeout = Math.max(transitionTimeout, animationTimeout);\n    type = timeout > 0\n      ? transitionTimeout > animationTimeout\n        ? TRANSITION\n        : ANIMATION\n      : null;\n    propCount = type\n      ? type === TRANSITION\n        ? transitionDurations.length\n        : animationDurations.length\n      : 0;\n  }\n  var hasTransform =\n    type === TRANSITION &&\n    transformRE.test(styles[transitionProp + 'Property']);\n  return {\n    type: type,\n    timeout: timeout,\n    propCount: propCount,\n    hasTransform: hasTransform\n  }\n}\n\nfunction getTimeout (delays, durations) {\n  /* istanbul ignore next */\n  while (delays.length < durations.length) {\n    delays = delays.concat(delays);\n  }\n\n  return Math.max.apply(null, durations.map(function (d, i) {\n    return toMs(d) + toMs(delays[i])\n  }))\n}\n\nfunction toMs (s) {\n  return Number(s.slice(0, -1)) * 1000\n}\n\n/*  */\n\nfunction enter (vnode, toggleDisplay) {\n  var el = vnode.elm;\n\n  // call leave callback now\n  if (el._leaveCb) {\n    el._leaveCb.cancelled = true;\n    el._leaveCb();\n  }\n\n  var data = resolveTransition(vnode.data.transition);\n  if (!data) {\n    return\n  }\n\n  /* istanbul ignore if */\n  if (el._enterCb || el.nodeType !== 1) {\n    return\n  }\n\n  var css = data.css;\n  var type = data.type;\n  var enterClass = data.enterClass;\n  var enterToClass = data.enterToClass;\n  var enterActiveClass = data.enterActiveClass;\n  var appearClass = data.appearClass;\n  var appearToClass = data.appearToClass;\n  var appearActiveClass = data.appearActiveClass;\n  var beforeEnter = data.beforeEnter;\n  var enter = data.enter;\n  var afterEnter = data.afterEnter;\n  var enterCancelled = data.enterCancelled;\n  var beforeAppear = data.beforeAppear;\n  var appear = data.appear;\n  var afterAppear = data.afterAppear;\n  var appearCancelled = data.appearCancelled;\n\n  // activeInstance will always be the <transition> component managing this\n  // transition. One edge case to check is when the <transition> is placed\n  // as the root node of a child component. In that case we need to check\n  // <transition>'s parent for appear check.\n  var context = activeInstance;\n  var transitionNode = activeInstance.$vnode;\n  while (transitionNode && transitionNode.parent) {\n    transitionNode = transitionNode.parent;\n    context = transitionNode.context;\n  }\n\n  var isAppear = !context._isMounted || !vnode.isRootInsert;\n\n  if (isAppear && !appear && appear !== '') {\n    return\n  }\n\n  var startClass = isAppear ? appearClass : enterClass;\n  var activeClass = isAppear ? appearActiveClass : enterActiveClass;\n  var toClass = isAppear ? appearToClass : enterToClass;\n  var beforeEnterHook = isAppear ? (beforeAppear || beforeEnter) : beforeEnter;\n  var enterHook = isAppear ? (typeof appear === 'function' ? appear : enter) : enter;\n  var afterEnterHook = isAppear ? (afterAppear || afterEnter) : afterEnter;\n  var enterCancelledHook = isAppear ? (appearCancelled || enterCancelled) : enterCancelled;\n\n  var expectsCSS = css !== false && !isIE9;\n  var userWantsControl =\n    enterHook &&\n    // enterHook may be a bound method which exposes\n    // the length of original fn as _length\n    (enterHook._length || enterHook.length) > 1;\n\n  var cb = el._enterCb = once(function () {\n    if (expectsCSS) {\n      removeTransitionClass(el, toClass);\n      removeTransitionClass(el, activeClass);\n    }\n    if (cb.cancelled) {\n      if (expectsCSS) {\n        removeTransitionClass(el, startClass);\n      }\n      enterCancelledHook && enterCancelledHook(el);\n    } else {\n      afterEnterHook && afterEnterHook(el);\n    }\n    el._enterCb = null;\n  });\n\n  if (!vnode.data.show) {\n    // remove pending leave element on enter by injecting an insert hook\n    mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', function () {\n      var parent = el.parentNode;\n      var pendingNode = parent && parent._pending && parent._pending[vnode.key];\n      if (pendingNode &&\n          pendingNode.tag === vnode.tag &&\n          pendingNode.elm._leaveCb) {\n        pendingNode.elm._leaveCb();\n      }\n      enterHook && enterHook(el, cb);\n    }, 'transition-insert');\n  }\n\n  // start enter transition\n  beforeEnterHook && beforeEnterHook(el);\n  if (expectsCSS) {\n    addTransitionClass(el, startClass);\n    addTransitionClass(el, activeClass);\n    nextFrame(function () {\n      addTransitionClass(el, toClass);\n      removeTransitionClass(el, startClass);\n      if (!cb.cancelled && !userWantsControl) {\n        whenTransitionEnds(el, type, cb);\n      }\n    });\n  }\n\n  if (vnode.data.show) {\n    toggleDisplay && toggleDisplay();\n    enterHook && enterHook(el, cb);\n  }\n\n  if (!expectsCSS && !userWantsControl) {\n    cb();\n  }\n}\n\nfunction leave (vnode, rm) {\n  var el = vnode.elm;\n\n  // call enter callback now\n  if (el._enterCb) {\n    el._enterCb.cancelled = true;\n    el._enterCb();\n  }\n\n  var data = resolveTransition(vnode.data.transition);\n  if (!data) {\n    return rm()\n  }\n\n  /* istanbul ignore if */\n  if (el._leaveCb || el.nodeType !== 1) {\n    return\n  }\n\n  var css = data.css;\n  var type = data.type;\n  var leaveClass = data.leaveClass;\n  var leaveToClass = data.leaveToClass;\n  var leaveActiveClass = data.leaveActiveClass;\n  var beforeLeave = data.beforeLeave;\n  var leave = data.leave;\n  var afterLeave = data.afterLeave;\n  var leaveCancelled = data.leaveCancelled;\n  var delayLeave = data.delayLeave;\n\n  var expectsCSS = css !== false && !isIE9;\n  var userWantsControl =\n    leave &&\n    // leave hook may be a bound method which exposes\n    // the length of original fn as _length\n    (leave._length || leave.length) > 1;\n\n  var cb = el._leaveCb = once(function () {\n    if (el.parentNode && el.parentNode._pending) {\n      el.parentNode._pending[vnode.key] = null;\n    }\n    if (expectsCSS) {\n      removeTransitionClass(el, leaveToClass);\n      removeTransitionClass(el, leaveActiveClass);\n    }\n    if (cb.cancelled) {\n      if (expectsCSS) {\n        removeTransitionClass(el, leaveClass);\n      }\n      leaveCancelled && leaveCancelled(el);\n    } else {\n      rm();\n      afterLeave && afterLeave(el);\n    }\n    el._leaveCb = null;\n  });\n\n  if (delayLeave) {\n    delayLeave(performLeave);\n  } else {\n    performLeave();\n  }\n\n  function performLeave () {\n    // the delayed leave may have already been cancelled\n    if (cb.cancelled) {\n      return\n    }\n    // record leaving element\n    if (!vnode.data.show) {\n      (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;\n    }\n    beforeLeave && beforeLeave(el);\n    if (expectsCSS) {\n      addTransitionClass(el, leaveClass);\n      addTransitionClass(el, leaveActiveClass);\n      nextFrame(function () {\n        addTransitionClass(el, leaveToClass);\n        removeTransitionClass(el, leaveClass);\n        if (!cb.cancelled && !userWantsControl) {\n          whenTransitionEnds(el, type, cb);\n        }\n      });\n    }\n    leave && leave(el, cb);\n    if (!expectsCSS && !userWantsControl) {\n      cb();\n    }\n  }\n}\n\nfunction resolveTransition (def$$1) {\n  if (!def$$1) {\n    return\n  }\n  /* istanbul ignore else */\n  if (typeof def$$1 === 'object') {\n    var res = {};\n    if (def$$1.css !== false) {\n      extend(res, autoCssTransition(def$$1.name || 'v'));\n    }\n    extend(res, def$$1);\n    return res\n  } else if (typeof def$$1 === 'string') {\n    return autoCssTransition(def$$1)\n  }\n}\n\nvar autoCssTransition = cached(function (name) {\n  return {\n    enterClass: (name + \"-enter\"),\n    leaveClass: (name + \"-leave\"),\n    appearClass: (name + \"-enter\"),\n    enterToClass: (name + \"-enter-to\"),\n    leaveToClass: (name + \"-leave-to\"),\n    appearToClass: (name + \"-enter-to\"),\n    enterActiveClass: (name + \"-enter-active\"),\n    leaveActiveClass: (name + \"-leave-active\"),\n    appearActiveClass: (name + \"-enter-active\")\n  }\n});\n\nfunction once (fn) {\n  var called = false;\n  return function () {\n    if (!called) {\n      called = true;\n      fn();\n    }\n  }\n}\n\nfunction _enter (_, vnode) {\n  if (!vnode.data.show) {\n    enter(vnode);\n  }\n}\n\nvar transition = inBrowser ? {\n  create: _enter,\n  activate: _enter,\n  remove: function remove (vnode, rm) {\n    /* istanbul ignore else */\n    if (!vnode.data.show) {\n      leave(vnode, rm);\n    } else {\n      rm();\n    }\n  }\n} : {};\n\nvar platformModules = [\n  attrs,\n  klass,\n  events,\n  domProps,\n  style,\n  transition\n];\n\n/*  */\n\n// the directive module should be applied last, after all\n// built-in modules have been applied.\nvar modules = platformModules.concat(baseModules);\n\nvar patch$1 = createPatchFunction({ nodeOps: nodeOps, modules: modules });\n\n/**\n * Not type checking this file because flow doesn't like attaching\n * properties to Elements.\n */\n\nvar modelableTagRE = /^input|select|textarea|vue-component-[0-9]+(-[0-9a-zA-Z_-]*)?$/;\n\n/* istanbul ignore if */\nif (isIE9) {\n  // http://www.matts411.com/post/internet-explorer-9-oninput/\n  document.addEventListener('selectionchange', function () {\n    var el = document.activeElement;\n    if (el && el.vmodel) {\n      trigger(el, 'input');\n    }\n  });\n}\n\nvar model = {\n  inserted: function inserted (el, binding, vnode) {\n    if (false) {\n      if (!modelableTagRE.test(vnode.tag)) {\n        warn(\n          \"v-model is not supported on element type: <\" + (vnode.tag) + \">. \" +\n          'If you are working with contenteditable, it\\'s recommended to ' +\n          'wrap a library dedicated for that purpose inside a custom component.',\n          vnode.context\n        );\n      }\n    }\n    if (vnode.tag === 'select') {\n      var cb = function () {\n        setSelected(el, binding, vnode.context);\n      };\n      cb();\n      /* istanbul ignore if */\n      if (isIE || isEdge) {\n        setTimeout(cb, 0);\n      }\n    } else if (vnode.tag === 'textarea' || el.type === 'text') {\n      el._vModifiers = binding.modifiers;\n      if (!binding.modifiers.lazy) {\n        if (!isAndroid) {\n          el.addEventListener('compositionstart', onCompositionStart);\n          el.addEventListener('compositionend', onCompositionEnd);\n        }\n        /* istanbul ignore if */\n        if (isIE9) {\n          el.vmodel = true;\n        }\n      }\n    }\n  },\n  componentUpdated: function componentUpdated (el, binding, vnode) {\n    if (vnode.tag === 'select') {\n      setSelected(el, binding, vnode.context);\n      // in case the options rendered by v-for have changed,\n      // it's possible that the value is out-of-sync with the rendered options.\n      // detect such cases and filter out values that no longer has a matching\n      // option in the DOM.\n      var needReset = el.multiple\n        ? binding.value.some(function (v) { return hasNoMatchingOption(v, el.options); })\n        : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, el.options);\n      if (needReset) {\n        trigger(el, 'change');\n      }\n    }\n  }\n};\n\nfunction setSelected (el, binding, vm) {\n  var value = binding.value;\n  var isMultiple = el.multiple;\n  if (isMultiple && !Array.isArray(value)) {\n    \"production\" !== 'production' && warn(\n      \"<select multiple v-model=\\\"\" + (binding.expression) + \"\\\"> \" +\n      \"expects an Array value for its binding, but got \" + (Object.prototype.toString.call(value).slice(8, -1)),\n      vm\n    );\n    return\n  }\n  var selected, option;\n  for (var i = 0, l = el.options.length; i < l; i++) {\n    option = el.options[i];\n    if (isMultiple) {\n      selected = looseIndexOf(value, getValue(option)) > -1;\n      if (option.selected !== selected) {\n        option.selected = selected;\n      }\n    } else {\n      if (looseEqual(getValue(option), value)) {\n        if (el.selectedIndex !== i) {\n          el.selectedIndex = i;\n        }\n        return\n      }\n    }\n  }\n  if (!isMultiple) {\n    el.selectedIndex = -1;\n  }\n}\n\nfunction hasNoMatchingOption (value, options) {\n  for (var i = 0, l = options.length; i < l; i++) {\n    if (looseEqual(getValue(options[i]), value)) {\n      return false\n    }\n  }\n  return true\n}\n\nfunction getValue (option) {\n  return '_value' in option\n    ? option._value\n    : option.value\n}\n\nfunction onCompositionStart (e) {\n  e.target.composing = true;\n}\n\nfunction onCompositionEnd (e) {\n  e.target.composing = false;\n  trigger(e.target, 'input');\n}\n\nfunction trigger (el, type) {\n  var e = document.createEvent('HTMLEvents');\n  e.initEvent(type, true, true);\n  el.dispatchEvent(e);\n}\n\n/*  */\n\n// recursively search for possible transition defined inside the component root\nfunction locateNode (vnode) {\n  return vnode.componentInstance && (!vnode.data || !vnode.data.transition)\n    ? locateNode(vnode.componentInstance._vnode)\n    : vnode\n}\n\nvar show = {\n  bind: function bind (el, ref, vnode) {\n    var value = ref.value;\n\n    vnode = locateNode(vnode);\n    var transition = vnode.data && vnode.data.transition;\n    var originalDisplay = el.__vOriginalDisplay =\n      el.style.display === 'none' ? '' : el.style.display;\n    if (value && transition && !isIE9) {\n      vnode.data.show = true;\n      enter(vnode, function () {\n        el.style.display = originalDisplay;\n      });\n    } else {\n      el.style.display = value ? originalDisplay : 'none';\n    }\n  },\n\n  update: function update (el, ref, vnode) {\n    var value = ref.value;\n    var oldValue = ref.oldValue;\n\n    /* istanbul ignore if */\n    if (value === oldValue) { return }\n    vnode = locateNode(vnode);\n    var transition = vnode.data && vnode.data.transition;\n    if (transition && !isIE9) {\n      vnode.data.show = true;\n      if (value) {\n        enter(vnode, function () {\n          el.style.display = el.__vOriginalDisplay;\n        });\n      } else {\n        leave(vnode, function () {\n          el.style.display = 'none';\n        });\n      }\n    } else {\n      el.style.display = value ? el.__vOriginalDisplay : 'none';\n    }\n  },\n\n  unbind: function unbind (\n    el,\n    binding,\n    vnode,\n    oldVnode,\n    isDestroy\n  ) {\n    if (!isDestroy) {\n      el.style.display = el.__vOriginalDisplay;\n    }\n  }\n};\n\nvar platformDirectives = {\n  model: model,\n  show: show\n};\n\n/*  */\n\n// Provides transition support for a single element/component.\n// supports transition mode (out-in / in-out)\n\nvar transitionProps = {\n  name: String,\n  appear: Boolean,\n  css: Boolean,\n  mode: String,\n  type: String,\n  enterClass: String,\n  leaveClass: String,\n  enterToClass: String,\n  leaveToClass: String,\n  enterActiveClass: String,\n  leaveActiveClass: String,\n  appearClass: String,\n  appearActiveClass: String,\n  appearToClass: String\n};\n\n// in case the child is also an abstract component, e.g. <keep-alive>\n// we want to recursively retrieve the real component to be rendered\nfunction getRealChild (vnode) {\n  var compOptions = vnode && vnode.componentOptions;\n  if (compOptions && compOptions.Ctor.options.abstract) {\n    return getRealChild(getFirstComponentChild(compOptions.children))\n  } else {\n    return vnode\n  }\n}\n\nfunction extractTransitionData (comp) {\n  var data = {};\n  var options = comp.$options;\n  // props\n  for (var key in options.propsData) {\n    data[key] = comp[key];\n  }\n  // events.\n  // extract listeners and pass them directly to the transition methods\n  var listeners = options._parentListeners;\n  for (var key$1 in listeners) {\n    data[camelize(key$1)] = listeners[key$1].fn;\n  }\n  return data\n}\n\nfunction placeholder (h, rawChild) {\n  return /\\d-keep-alive$/.test(rawChild.tag)\n    ? h('keep-alive')\n    : null\n}\n\nfunction hasParentTransition (vnode) {\n  while ((vnode = vnode.parent)) {\n    if (vnode.data.transition) {\n      return true\n    }\n  }\n}\n\nfunction isSameChild (child, oldChild) {\n  return oldChild.key === child.key && oldChild.tag === child.tag\n}\n\nvar Transition = {\n  name: 'transition',\n  props: transitionProps,\n  abstract: true,\n\n  render: function render (h) {\n    var this$1 = this;\n\n    var children = this.$slots.default;\n    if (!children) {\n      return\n    }\n\n    // filter out text nodes (possible whitespaces)\n    children = children.filter(function (c) { return c.tag; });\n    /* istanbul ignore if */\n    if (!children.length) {\n      return\n    }\n\n    // warn multiple elements\n    if (false) {\n      warn(\n        '<transition> can only be used on a single element. Use ' +\n        '<transition-group> for lists.',\n        this.$parent\n      );\n    }\n\n    var mode = this.mode;\n\n    // warn invalid mode\n    if (false) {\n      warn(\n        'invalid <transition> mode: ' + mode,\n        this.$parent\n      );\n    }\n\n    var rawChild = children[0];\n\n    // if this is a component root node and the component's\n    // parent container node also has transition, skip.\n    if (hasParentTransition(this.$vnode)) {\n      return rawChild\n    }\n\n    // apply transition data to child\n    // use getRealChild() to ignore abstract components e.g. keep-alive\n    var child = getRealChild(rawChild);\n    /* istanbul ignore if */\n    if (!child) {\n      return rawChild\n    }\n\n    if (this._leaving) {\n      return placeholder(h, rawChild)\n    }\n\n    // ensure a key that is unique to the vnode type and to this transition\n    // component instance. This key will be used to remove pending leaving nodes\n    // during entering.\n    var id = \"__transition-\" + (this._uid) + \"-\";\n    var key = child.key = child.key == null\n      ? id + child.tag\n      : isPrimitive(child.key)\n        ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)\n        : child.key;\n    var data = (child.data || (child.data = {})).transition = extractTransitionData(this);\n    var oldRawChild = this._vnode;\n    var oldChild = getRealChild(oldRawChild);\n\n    // mark v-show\n    // so that the transition module can hand over the control to the directive\n    if (child.data.directives && child.data.directives.some(function (d) { return d.name === 'show'; })) {\n      child.data.show = true;\n    }\n\n    if (oldChild && oldChild.data && !isSameChild(child, oldChild)) {\n      // replace old child transition data with fresh one\n      // important for dynamic transitions!\n      var oldData = oldChild && (oldChild.data.transition = extend({}, data));\n      // handle transition mode\n      if (mode === 'out-in') {\n        // return placeholder node and queue update when leave finishes\n        this._leaving = true;\n        mergeVNodeHook(oldData, 'afterLeave', function () {\n          this$1._leaving = false;\n          this$1.$forceUpdate();\n        }, key);\n        return placeholder(h, rawChild)\n      } else if (mode === 'in-out') {\n        var delayedLeave;\n        var performLeave = function () { delayedLeave(); };\n        mergeVNodeHook(data, 'afterEnter', performLeave, key);\n        mergeVNodeHook(data, 'enterCancelled', performLeave, key);\n        mergeVNodeHook(oldData, 'delayLeave', function (leave) {\n          delayedLeave = leave;\n        }, key);\n      }\n    }\n\n    return rawChild\n  }\n};\n\n/*  */\n\n// Provides transition support for list items.\n// supports move transitions using the FLIP technique.\n\n// Because the vdom's children update algorithm is \"unstable\" - i.e.\n// it doesn't guarantee the relative positioning of removed elements,\n// we force transition-group to update its children into two passes:\n// in the first pass, we remove all nodes that need to be removed,\n// triggering their leaving transition; in the second pass, we insert/move\n// into the final disired state. This way in the second pass removed\n// nodes will remain where they should be.\n\nvar props = extend({\n  tag: String,\n  moveClass: String\n}, transitionProps);\n\ndelete props.mode;\n\nvar TransitionGroup = {\n  props: props,\n\n  render: function render (h) {\n    var tag = this.tag || this.$vnode.data.tag || 'span';\n    var map = Object.create(null);\n    var prevChildren = this.prevChildren = this.children;\n    var rawChildren = this.$slots.default || [];\n    var children = this.children = [];\n    var transitionData = extractTransitionData(this);\n\n    for (var i = 0; i < rawChildren.length; i++) {\n      var c = rawChildren[i];\n      if (c.tag) {\n        if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {\n          children.push(c);\n          map[c.key] = c\n          ;(c.data || (c.data = {})).transition = transitionData;\n        } else if (false) {\n          var opts = c.componentOptions;\n          var name = opts\n            ? (opts.Ctor.options.name || opts.tag)\n            : c.tag;\n          warn((\"<transition-group> children must be keyed: <\" + name + \">\"));\n        }\n      }\n    }\n\n    if (prevChildren) {\n      var kept = [];\n      var removed = [];\n      for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {\n        var c$1 = prevChildren[i$1];\n        c$1.data.transition = transitionData;\n        c$1.data.pos = c$1.elm.getBoundingClientRect();\n        if (map[c$1.key]) {\n          kept.push(c$1);\n        } else {\n          removed.push(c$1);\n        }\n      }\n      this.kept = h(tag, null, kept);\n      this.removed = removed;\n    }\n\n    return h(tag, null, children)\n  },\n\n  beforeUpdate: function beforeUpdate () {\n    // force removing pass\n    this.__patch__(\n      this._vnode,\n      this.kept,\n      false, // hydrating\n      true // removeOnly (!important, avoids unnecessary moves)\n    );\n    this._vnode = this.kept;\n  },\n\n  updated: function updated () {\n    var children = this.prevChildren;\n    var moveClass = this.moveClass || ((this.name || 'v') + '-move');\n    if (!children.length || !this.hasMove(children[0].elm, moveClass)) {\n      return\n    }\n\n    // we divide the work into three loops to avoid mixing DOM reads and writes\n    // in each iteration - which helps prevent layout thrashing.\n    children.forEach(callPendingCbs);\n    children.forEach(recordPosition);\n    children.forEach(applyTranslation);\n\n    // force reflow to put everything in position\n    var f = document.body.offsetHeight; // eslint-disable-line\n\n    children.forEach(function (c) {\n      if (c.data.moved) {\n        var el = c.elm;\n        var s = el.style;\n        addTransitionClass(el, moveClass);\n        s.transform = s.WebkitTransform = s.transitionDuration = '';\n        el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {\n          if (!e || /transform$/.test(e.propertyName)) {\n            el.removeEventListener(transitionEndEvent, cb);\n            el._moveCb = null;\n            removeTransitionClass(el, moveClass);\n          }\n        });\n      }\n    });\n  },\n\n  methods: {\n    hasMove: function hasMove (el, moveClass) {\n      /* istanbul ignore if */\n      if (!hasTransition) {\n        return false\n      }\n      if (this._hasMove != null) {\n        return this._hasMove\n      }\n      addTransitionClass(el, moveClass);\n      var info = getTransitionInfo(el);\n      removeTransitionClass(el, moveClass);\n      return (this._hasMove = info.hasTransform)\n    }\n  }\n};\n\nfunction callPendingCbs (c) {\n  /* istanbul ignore if */\n  if (c.elm._moveCb) {\n    c.elm._moveCb();\n  }\n  /* istanbul ignore if */\n  if (c.elm._enterCb) {\n    c.elm._enterCb();\n  }\n}\n\nfunction recordPosition (c) {\n  c.data.newPos = c.elm.getBoundingClientRect();\n}\n\nfunction applyTranslation (c) {\n  var oldPos = c.data.pos;\n  var newPos = c.data.newPos;\n  var dx = oldPos.left - newPos.left;\n  var dy = oldPos.top - newPos.top;\n  if (dx || dy) {\n    c.data.moved = true;\n    var s = c.elm.style;\n    s.transform = s.WebkitTransform = \"translate(\" + dx + \"px,\" + dy + \"px)\";\n    s.transitionDuration = '0s';\n  }\n}\n\nvar platformComponents = {\n  Transition: Transition,\n  TransitionGroup: TransitionGroup\n};\n\n/*  */\n\n// install platform specific utils\nVue$3.config.isUnknownElement = isUnknownElement;\nVue$3.config.isReservedTag = isReservedTag;\nVue$3.config.getTagNamespace = getTagNamespace;\nVue$3.config.mustUseProp = mustUseProp;\n\n// install platform runtime directives & components\nextend(Vue$3.options.directives, platformDirectives);\nextend(Vue$3.options.components, platformComponents);\n\n// install platform patch function\nVue$3.prototype.__patch__ = inBrowser ? patch$1 : noop;\n\n// wrap mount\nVue$3.prototype.$mount = function (\n  el,\n  hydrating\n) {\n  el = el && inBrowser ? query(el) : undefined;\n  return this._mount(el, hydrating)\n};\n\nif (false) {\n  console[console.info ? 'info' : 'log'](\n    \"You are running Vue in development mode.\\n\" +\n    \"Make sure to turn on production mode when deploying for production.\\n\" +\n    \"See more tips at https://vuejs.org/guide/deployment.html\"\n  );\n}\n\n// devtools global hook\n/* istanbul ignore next */\nsetTimeout(function () {\n  if (config.devtools) {\n    if (devtools) {\n      devtools.emit('init', Vue$3);\n    } else if (\n      false\n    ) {\n      console[console.info ? 'info' : 'log'](\n        'Download the Vue Devtools extension for a better development experience:\\n' +\n        'https://github.com/vuejs/vue-devtools'\n      );\n    }\n  }\n}, 0);\n\n/*  */\n\n// check whether current browser encodes a char inside attribute values\nfunction shouldDecode (content, encoded) {\n  var div = document.createElement('div');\n  div.innerHTML = \"<div a=\\\"\" + content + \"\\\">\";\n  return div.innerHTML.indexOf(encoded) > 0\n}\n\n// #3663\n// IE encodes newlines inside attribute values while other browsers don't\nvar shouldDecodeNewlines = inBrowser ? shouldDecode('\\n', '&#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__(30)))\n\n/***/ }),\n/* 18 */\n/***/ (function(module, exports) {\n\nvar toString = {}.toString;\n\nmodule.exports = function(it){\n  return toString.call(it).slice(8, -1);\n};\n\n/***/ }),\n/* 19 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// optional / simple context binding\nvar aFunction = __webpack_require__(46);\nmodule.exports = function(fn, that, length){\n  aFunction(fn);\n  if(that === undefined)return fn;\n  switch(length){\n    case 1: return function(a){\n      return fn.call(that, a);\n    };\n    case 2: return function(a, b){\n      return fn.call(that, a, b);\n    };\n    case 3: return function(a, b, c){\n      return fn.call(that, a, b, c);\n    };\n  }\n  return function(/* ...args */){\n    return fn.apply(that, arguments);\n  };\n};\n\n/***/ }),\n/* 20 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar isObject = __webpack_require__(12)\n  , document = __webpack_require__(2).document\n  // in old IE typeof document.createElement is 'object'\n  , is = isObject(document) && isObject(document.createElement);\nmodule.exports = function(it){\n  return is ? document.createElement(it) : {};\n};\n\n/***/ }),\n/* 21 */\n/***/ (function(module, exports) {\n\n// IE 8- don't enum bug keys\nmodule.exports = (\n  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'\n).split(',');\n\n/***/ }),\n/* 22 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar global    = __webpack_require__(2)\n  , core      = __webpack_require__(10)\n  , ctx       = __webpack_require__(19)\n  , hide      = __webpack_require__(7)\n  , PROTOTYPE = 'prototype';\n\nvar $export = function(type, name, source){\n  var IS_FORCED = type & $export.F\n    , IS_GLOBAL = type & $export.G\n    , IS_STATIC = type & $export.S\n    , IS_PROTO  = type & $export.P\n    , IS_BIND   = type & $export.B\n    , IS_WRAP   = type & $export.W\n    , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})\n    , expProto  = exports[PROTOTYPE]\n    , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]\n    , key, own, out;\n  if(IS_GLOBAL)source = name;\n  for(key in source){\n    // contains in native\n    own = !IS_FORCED && target && target[key] !== undefined;\n    if(own && key in exports)continue;\n    // export native or passed\n    out = own ? target[key] : source[key];\n    // prevent global pollution for namespaces\n    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]\n    // bind timers to global for call from export context\n    : IS_BIND && own ? ctx(out, global)\n    // wrap global constructors for prevent change them in library\n    : IS_WRAP && target[key] == out ? (function(C){\n      var F = function(a, b, c){\n        if(this instanceof C){\n          switch(arguments.length){\n            case 0: return new C;\n            case 1: return new C(a);\n            case 2: return new C(a, b);\n          } return new C(a, b, c);\n        } return C.apply(this, arguments);\n      };\n      F[PROTOTYPE] = C[PROTOTYPE];\n      return F;\n    // make static versions for prototype methods\n    })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;\n    // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%\n    if(IS_PROTO){\n      (exports.virtual || (exports.virtual = {}))[key] = out;\n      // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%\n      if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out);\n    }\n  }\n};\n// type bitmap\n$export.F = 1;   // forced\n$export.G = 2;   // global\n$export.S = 4;   // static\n$export.P = 8;   // proto\n$export.B = 16;  // bind\n$export.W = 32;  // wrap\n$export.U = 64;  // safe\n$export.R = 128; // real proto method for `library` \nmodule.exports = $export;\n\n/***/ }),\n/* 23 */\n/***/ (function(module, exports) {\n\nmodule.exports = function(exec){\n  try {\n    return !!exec();\n  } catch(e){\n    return true;\n  }\n};\n\n/***/ }),\n/* 24 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar def = __webpack_require__(8).f\n  , has = __webpack_require__(6)\n  , TAG = __webpack_require__(1)('toStringTag');\n\nmodule.exports = function(it, tag, stat){\n  if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});\n};\n\n/***/ }),\n/* 25 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar global = __webpack_require__(2)\n  , SHARED = '__core-js_shared__'\n  , store  = global[SHARED] || (global[SHARED] = {});\nmodule.exports = function(key){\n  return store[key] || (store[key] = {});\n};\n\n/***/ }),\n/* 26 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// to indexed object, toObject with fallback for non-array-like ES3 strings\nvar IObject = __webpack_require__(52)\n  , defined = __webpack_require__(11);\nmodule.exports = function(it){\n  return IObject(defined(it));\n};\n\n/***/ }),\n/* 27 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// 7.1.15 ToLength\nvar toInteger = __webpack_require__(16)\n  , min       = Math.min;\nmodule.exports = function(it){\n  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991\n};\n\n/***/ }),\n/* 28 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// 7.1.13 ToObject(argument)\nvar defined = __webpack_require__(11);\nmodule.exports = function(it){\n  return Object(defined(it));\n};\n\n/***/ }),\n/* 29 */\n/***/ (function(module, exports) {\n\nvar id = 0\n  , px = Math.random();\nmodule.exports = function(key){\n  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));\n};\n\n/***/ }),\n/* 30 */\n/***/ (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/* 31 */,\n/* 32 */,\n/* 33 */,\n/* 34 */,\n/* 35 */,\n/* 36 */,\n/* 37 */,\n/* 38 */,\n/* 39 */,\n/* 40 */,\n/* 41 */,\n/* 42 */,\n/* 43 */\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = { \"default\": __webpack_require__(45), __esModule: true };\n\n/***/ }),\n/* 44 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nexports.__esModule = true;\n\nvar _from = __webpack_require__(43);\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/* 45 */\n/***/ (function(module, exports, __webpack_require__) {\n\n__webpack_require__(70);\n__webpack_require__(69);\nmodule.exports = __webpack_require__(10).Array.from;\n\n/***/ }),\n/* 46 */\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/* 47 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// false -> Array#indexOf\n// true  -> Array#includes\nvar toIObject = __webpack_require__(26)\n  , toLength  = __webpack_require__(27)\n  , toIndex   = __webpack_require__(66);\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/* 48 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// getting tag from 19.1.3.6 Object.prototype.toString()\nvar cof = __webpack_require__(18)\n  , TAG = __webpack_require__(1)('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/* 49 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar $defineProperty = __webpack_require__(8)\n  , createDesc      = __webpack_require__(14);\n\nmodule.exports = function(object, index, value){\n  if(index in object)$defineProperty.f(object, index, createDesc(0, value));\n  else object[index] = value;\n};\n\n/***/ }),\n/* 50 */\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = __webpack_require__(2).document && document.documentElement;\n\n/***/ }),\n/* 51 */\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = !__webpack_require__(5) && !__webpack_require__(23)(function(){\n  return Object.defineProperty(__webpack_require__(20)('div'), 'a', {get: function(){ return 7; }}).a != 7;\n});\n\n/***/ }),\n/* 52 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nvar cof = __webpack_require__(18);\nmodule.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){\n  return cof(it) == 'String' ? it.split('') : Object(it);\n};\n\n/***/ }),\n/* 53 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// check on default Array iterator\nvar Iterators  = __webpack_require__(13)\n  , ITERATOR   = __webpack_require__(1)('iterator')\n  , ArrayProto = Array.prototype;\n\nmodule.exports = function(it){\n  return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);\n};\n\n/***/ }),\n/* 54 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// call something on iterator step with safe closing on error\nvar anObject = __webpack_require__(4);\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/* 55 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar create         = __webpack_require__(59)\n  , descriptor     = __webpack_require__(14)\n  , setToStringTag = __webpack_require__(24)\n  , IteratorPrototype = {};\n\n// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()\n__webpack_require__(7)(IteratorPrototype, __webpack_require__(1)('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/* 56 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar LIBRARY        = __webpack_require__(58)\n  , $export        = __webpack_require__(22)\n  , redefine       = __webpack_require__(64)\n  , hide           = __webpack_require__(7)\n  , has            = __webpack_require__(6)\n  , Iterators      = __webpack_require__(13)\n  , $iterCreate    = __webpack_require__(55)\n  , setToStringTag = __webpack_require__(24)\n  , getPrototypeOf = __webpack_require__(61)\n  , ITERATOR       = __webpack_require__(1)('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/* 57 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar ITERATOR     = __webpack_require__(1)('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/* 58 */\n/***/ (function(module, exports) {\n\nmodule.exports = true;\n\n/***/ }),\n/* 59 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])\nvar anObject    = __webpack_require__(4)\n  , dPs         = __webpack_require__(60)\n  , enumBugKeys = __webpack_require__(21)\n  , IE_PROTO    = __webpack_require__(15)('IE_PROTO')\n  , Empty       = function(){ /* empty */ }\n  , PROTOTYPE   = 'prototype';\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar createDict = function(){\n  // Thrash, waste and sodomy: IE GC bug\n  var iframe = __webpack_require__(20)('iframe')\n    , i      = enumBugKeys.length\n    , lt     = '<'\n    , gt     = '>'\n    , iframeDocument;\n  iframe.style.display = 'none';\n  __webpack_require__(50).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/* 60 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar dP       = __webpack_require__(8)\n  , anObject = __webpack_require__(4)\n  , getKeys  = __webpack_require__(63);\n\nmodule.exports = __webpack_require__(5) ? 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/* 61 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)\nvar has         = __webpack_require__(6)\n  , toObject    = __webpack_require__(28)\n  , IE_PROTO    = __webpack_require__(15)('IE_PROTO')\n  , ObjectProto = Object.prototype;\n\nmodule.exports = Object.getPrototypeOf || function(O){\n  O = toObject(O);\n  if(has(O, IE_PROTO))return O[IE_PROTO];\n  if(typeof O.constructor == 'function' && O instanceof O.constructor){\n    return O.constructor.prototype;\n  } return O instanceof Object ? ObjectProto : null;\n};\n\n/***/ }),\n/* 62 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar has          = __webpack_require__(6)\n  , toIObject    = __webpack_require__(26)\n  , arrayIndexOf = __webpack_require__(47)(false)\n  , IE_PROTO     = __webpack_require__(15)('IE_PROTO');\n\nmodule.exports = function(object, names){\n  var O      = toIObject(object)\n    , i      = 0\n    , result = []\n    , key;\n  for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);\n  // Don't enum bug & hidden keys\n  while(names.length > i)if(has(O, key = names[i++])){\n    ~arrayIndexOf(result, key) || result.push(key);\n  }\n  return result;\n};\n\n/***/ }),\n/* 63 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// 19.1.2.14 / 15.2.3.14 Object.keys(O)\nvar $keys       = __webpack_require__(62)\n  , enumBugKeys = __webpack_require__(21);\n\nmodule.exports = Object.keys || function keys(O){\n  return $keys(O, enumBugKeys);\n};\n\n/***/ }),\n/* 64 */\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = __webpack_require__(7);\n\n/***/ }),\n/* 65 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar toInteger = __webpack_require__(16)\n  , defined   = __webpack_require__(11);\n// true  -> String#at\n// false -> String#codePointAt\nmodule.exports = function(TO_STRING){\n  return function(that, pos){\n    var s = String(defined(that))\n      , i = toInteger(pos)\n      , l = s.length\n      , a, b;\n    if(i < 0 || i >= l)return TO_STRING ? '' : undefined;\n    a = s.charCodeAt(i);\n    return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff\n      ? TO_STRING ? s.charAt(i) : a\n      : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;\n  };\n};\n\n/***/ }),\n/* 66 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar toInteger = __webpack_require__(16)\n  , max       = Math.max\n  , min       = Math.min;\nmodule.exports = function(index, length){\n  index = toInteger(index);\n  return index < 0 ? max(index + length, 0) : min(index, length);\n};\n\n/***/ }),\n/* 67 */\n/***/ (function(module, exports, __webpack_require__) {\n\n// 7.1.1 ToPrimitive(input [, PreferredType])\nvar isObject = __webpack_require__(12);\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function(it, S){\n  if(!isObject(it))return it;\n  var fn, val;\n  if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n  if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;\n  if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n\n/***/ }),\n/* 68 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar classof   = __webpack_require__(48)\n  , ITERATOR  = __webpack_require__(1)('iterator')\n  , Iterators = __webpack_require__(13);\nmodule.exports = __webpack_require__(10).getIteratorMethod = function(it){\n  if(it != undefined)return it[ITERATOR]\n    || it['@@iterator']\n    || Iterators[classof(it)];\n};\n\n/***/ }),\n/* 69 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar ctx            = __webpack_require__(19)\n  , $export        = __webpack_require__(22)\n  , toObject       = __webpack_require__(28)\n  , call           = __webpack_require__(54)\n  , isArrayIter    = __webpack_require__(53)\n  , toLength       = __webpack_require__(27)\n  , createProperty = __webpack_require__(49)\n  , getIterFn      = __webpack_require__(68);\n\n$export($export.S + $export.F * !__webpack_require__(57)(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/* 70 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar $at  = __webpack_require__(65)(true);\n\n// 21.1.3.27 String.prototype[@@iterator]()\n__webpack_require__(56)(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/* 71 */,\n/* 72 */,\n/* 73 */,\n/* 74 */,\n/* 75 */,\n/* 76 */,\n/* 77 */,\n/* 78 */\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__(30), __webpack_require__(98)(module)))\n\n/***/ }),\n/* 79 */,\n/* 80 */,\n/* 81 */,\n/* 82 */,\n/* 83 */,\n/* 84 */,\n/* 85 */,\n/* 86 */,\n/* 87 */,\n/* 88 */,\n/* 89 */,\n/* 90 */,\n/* 91 */,\n/* 92 */,\n/* 93 */,\n/* 94 */,\n/* 95 */,\n/* 96 */\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/* 97 */\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/* 98 */\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/* 99 */,\n/* 100 */\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/* 101 */\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__(97)\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.d7f56de7848fa2082505.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","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 = 1\n// module chunks = 0","// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nvar global = module.exports = typeof window != 'undefined' && window.Math == Math\n  ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();\nif(typeof __g == 'number')__g = global; // eslint-disable-line no-undef\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_global.js\n// module id = 2\n// module chunks = 0","// 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 = 3\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 = 4\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 = 5\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 = 6\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 = 7\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 = 8\n// module chunks = 0","var core = module.exports = {version: '2.4.0'};\nif(typeof __e == 'number')__e = core; // eslint-disable-line no-undef\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_core.js\n// module id = 10\n// module chunks = 0","// 7.2.1 RequireObjectCoercible(argument)\nmodule.exports = function(it){\n  if(it == undefined)throw TypeError(\"Can't call method on  \" + it);\n  return it;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_defined.js\n// module id = 11\n// module chunks = 0","module.exports = function(it){\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_is-object.js\n// module id = 12\n// module chunks = 0","module.exports = {};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iterators.js\n// module id = 13\n// module chunks = 0","module.exports = function(bitmap, value){\n  return {\n    enumerable  : !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable    : !(bitmap & 4),\n    value       : value\n  };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_property-desc.js\n// module id = 14\n// module chunks = 0","var shared = require('./_shared')('keys')\n  , uid    = require('./_uid');\nmodule.exports = function(key){\n  return shared[key] || (shared[key] = uid(key));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_shared-key.js\n// module id = 15\n// module chunks = 0","// 7.1.4 ToInteger\nvar ceil  = Math.ceil\n  , floor = Math.floor;\nmodule.exports = function(it){\n  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-integer.js\n// module id = 16\n// module chunks = 0","/*!\n * Vue.js v2.1.10\n * (c) 2014-2017 Evan You\n * Released under the MIT License.\n */\n'use strict';\n\n/*  */\n\n/**\n * Convert a value to a string that is actually rendered.\n */\nfunction _toString (val) {\n  return val == null\n    ? ''\n    : typeof val === 'object'\n      ? JSON.stringify(val, null, 2)\n      : String(val)\n}\n\n/**\n * Convert a input value to a number for persistence.\n * If the conversion fails, return original string.\n */\nfunction toNumber (val) {\n  var n = parseFloat(val);\n  return isNaN(n) ? val : n\n}\n\n/**\n * Make a map and return a function for checking if a key\n * is in that map.\n */\nfunction makeMap (\n  str,\n  expectsLowerCase\n) {\n  var map = Object.create(null);\n  var list = str.split(',');\n  for (var i = 0; i < list.length; i++) {\n    map[list[i]] = true;\n  }\n  return expectsLowerCase\n    ? function (val) { return map[val.toLowerCase()]; }\n    : function (val) { return map[val]; }\n}\n\n/**\n * Check if a tag is a built-in tag.\n */\nvar isBuiltInTag = makeMap('slot,component', true);\n\n/**\n * Remove an item from an array\n */\nfunction remove$1 (arr, item) {\n  if (arr.length) {\n    var index = arr.indexOf(item);\n    if (index > -1) {\n      return arr.splice(index, 1)\n    }\n  }\n}\n\n/**\n * Check whether the object has the property.\n */\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction hasOwn (obj, key) {\n  return hasOwnProperty.call(obj, key)\n}\n\n/**\n * Check if value is primitive\n */\nfunction isPrimitive (value) {\n  return typeof value === 'string' || typeof value === 'number'\n}\n\n/**\n * Create a cached version of a pure function.\n */\nfunction cached (fn) {\n  var cache = Object.create(null);\n  return (function cachedFn (str) {\n    var hit = cache[str];\n    return hit || (cache[str] = fn(str))\n  })\n}\n\n/**\n * Camelize a hyphen-delimited string.\n */\nvar camelizeRE = /-(\\w)/g;\nvar camelize = cached(function (str) {\n  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })\n});\n\n/**\n * Capitalize a string.\n */\nvar capitalize = cached(function (str) {\n  return str.charAt(0).toUpperCase() + str.slice(1)\n});\n\n/**\n * Hyphenate a camelCase string.\n */\nvar hyphenateRE = /([^-])([A-Z])/g;\nvar hyphenate = cached(function (str) {\n  return str\n    .replace(hyphenateRE, '$1-$2')\n    .replace(hyphenateRE, '$1-$2')\n    .toLowerCase()\n});\n\n/**\n * Simple bind, faster than native\n */\nfunction bind$1 (fn, ctx) {\n  function boundFn (a) {\n    var l = arguments.length;\n    return l\n      ? l > 1\n        ? fn.apply(ctx, arguments)\n        : fn.call(ctx, a)\n      : fn.call(ctx)\n  }\n  // record original fn length\n  boundFn._length = fn.length;\n  return boundFn\n}\n\n/**\n * Convert an Array-like object to a real Array.\n */\nfunction toArray (list, start) {\n  start = start || 0;\n  var i = list.length - start;\n  var ret = new Array(i);\n  while (i--) {\n    ret[i] = list[i + start];\n  }\n  return ret\n}\n\n/**\n * Mix properties into target object.\n */\nfunction extend (to, _from) {\n  for (var key in _from) {\n    to[key] = _from[key];\n  }\n  return to\n}\n\n/**\n * Quick object check - this is primarily used to tell\n * Objects from primitive values when we know the value\n * is a JSON-compliant type.\n */\nfunction isObject (obj) {\n  return obj !== null && typeof obj === 'object'\n}\n\n/**\n * Strict object type check. Only returns true\n * for plain JavaScript objects.\n */\nvar toString = Object.prototype.toString;\nvar OBJECT_STRING = '[object Object]';\nfunction isPlainObject (obj) {\n  return toString.call(obj) === OBJECT_STRING\n}\n\n/**\n * Merge an Array of Objects into a single Object.\n */\nfunction toObject (arr) {\n  var res = {};\n  for (var i = 0; i < arr.length; i++) {\n    if (arr[i]) {\n      extend(res, arr[i]);\n    }\n  }\n  return res\n}\n\n/**\n * Perform no operation.\n */\nfunction noop () {}\n\n/**\n * Always return false.\n */\nvar no = function () { return false; };\n\n/**\n * Return same value\n */\nvar identity = function (_) { return _; };\n\n/**\n * Generate a static keys string from compiler modules.\n */\nfunction genStaticKeys (modules) {\n  return modules.reduce(function (keys, m) {\n    return keys.concat(m.staticKeys || [])\n  }, []).join(',')\n}\n\n/**\n * Check if two values are loosely equal - that is,\n * if they are plain objects, do they have the same shape?\n */\nfunction looseEqual (a, b) {\n  var isObjectA = isObject(a);\n  var isObjectB = isObject(b);\n  if (isObjectA && isObjectB) {\n    return JSON.stringify(a) === JSON.stringify(b)\n  } else if (!isObjectA && !isObjectB) {\n    return String(a) === String(b)\n  } else {\n    return false\n  }\n}\n\nfunction looseIndexOf (arr, val) {\n  for (var i = 0; i < arr.length; i++) {\n    if (looseEqual(arr[i], val)) { return i }\n  }\n  return -1\n}\n\n/*  */\n\nvar config = {\n  /**\n   * Option merge strategies (used in core/util/options)\n   */\n  optionMergeStrategies: Object.create(null),\n\n  /**\n   * Whether to suppress warnings.\n   */\n  silent: false,\n\n  /**\n   * Whether to enable devtools\n   */\n  devtools: process.env.NODE_ENV !== 'production',\n\n  /**\n   * Error handler for watcher errors\n   */\n  errorHandler: null,\n\n  /**\n   * Ignore certain custom elements\n   */\n  ignoredElements: [],\n\n  /**\n   * Custom user key aliases for v-on\n   */\n  keyCodes: Object.create(null),\n\n  /**\n   * Check if a tag is reserved so that it cannot be registered as a\n   * component. This is platform-dependent and may be overwritten.\n   */\n  isReservedTag: no,\n\n  /**\n   * Check if a tag is an unknown element.\n   * Platform-dependent.\n   */\n  isUnknownElement: no,\n\n  /**\n   * Get the namespace of an element\n   */\n  getTagNamespace: noop,\n\n  /**\n   * Parse the real tag name for the specific platform.\n   */\n  parsePlatformTagName: identity,\n\n  /**\n   * Check if an attribute must be bound using property, e.g. value\n   * Platform-dependent.\n   */\n  mustUseProp: no,\n\n  /**\n   * List of asset types that a component can own.\n   */\n  _assetTypes: [\n    'component',\n    'directive',\n    'filter'\n  ],\n\n  /**\n   * List of lifecycle hooks.\n   */\n  _lifecycleHooks: [\n    'beforeCreate',\n    'created',\n    'beforeMount',\n    'mounted',\n    'beforeUpdate',\n    'updated',\n    'beforeDestroy',\n    'destroyed',\n    'activated',\n    'deactivated'\n  ],\n\n  /**\n   * Max circular updates allowed in a scheduler flush cycle.\n   */\n  _maxUpdateCount: 100\n};\n\n/*  */\n\n/**\n * Check if a string starts with $ or _\n */\nfunction isReserved (str) {\n  var c = (str + '').charCodeAt(0);\n  return c === 0x24 || c === 0x5F\n}\n\n/**\n * Define a property.\n */\nfunction def (obj, key, val, enumerable) {\n  Object.defineProperty(obj, key, {\n    value: val,\n    enumerable: !!enumerable,\n    writable: true,\n    configurable: true\n  });\n}\n\n/**\n * Parse simple path.\n */\nvar bailRE = /[^\\w.$]/;\nfunction parsePath (path) {\n  if (bailRE.test(path)) {\n    return\n  } else {\n    var segments = path.split('.');\n    return function (obj) {\n      for (var i = 0; i < segments.length; i++) {\n        if (!obj) { return }\n        obj = obj[segments[i]];\n      }\n      return obj\n    }\n  }\n}\n\n/*  */\n/* globals MutationObserver */\n\n// can we use __proto__?\nvar hasProto = '__proto__' in {};\n\n// Browser environment sniffing\nvar inBrowser = typeof window !== 'undefined';\nvar UA = inBrowser && window.navigator.userAgent.toLowerCase();\nvar isIE = UA && /msie|trident/.test(UA);\nvar isIE9 = UA && UA.indexOf('msie 9.0') > 0;\nvar isEdge = UA && UA.indexOf('edge/') > 0;\nvar isAndroid = UA && UA.indexOf('android') > 0;\nvar isIOS = UA && /iphone|ipad|ipod|ios/.test(UA);\n\n// this needs to be lazy-evaled because vue may be required before\n// vue-server-renderer can set VUE_ENV\nvar _isServer;\nvar isServerRendering = function () {\n  if (_isServer === undefined) {\n    /* istanbul ignore if */\n    if (!inBrowser && typeof global !== 'undefined') {\n      // detect presence of vue-server-renderer and avoid\n      // Webpack shimming the process\n      _isServer = global['process'].env.VUE_ENV === 'server';\n    } else {\n      _isServer = false;\n    }\n  }\n  return _isServer\n};\n\n// detect devtools\nvar devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;\n\n/* istanbul ignore next */\nfunction isNative (Ctor) {\n  return /native code/.test(Ctor.toString())\n}\n\n/**\n * Defer a task to execute it asynchronously.\n */\nvar nextTick = (function () {\n  var callbacks = [];\n  var pending = false;\n  var timerFunc;\n\n  function nextTickHandler () {\n    pending = false;\n    var copies = callbacks.slice(0);\n    callbacks.length = 0;\n    for (var i = 0; i < copies.length; i++) {\n      copies[i]();\n    }\n  }\n\n  // the nextTick behavior leverages the microtask queue, which can be accessed\n  // via either native Promise.then or MutationObserver.\n  // MutationObserver has wider support, however it is seriously bugged in\n  // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It\n  // completely stops working after triggering a few times... so, if native\n  // Promise is available, we will use it:\n  /* istanbul ignore if */\n  if (typeof Promise !== 'undefined' && isNative(Promise)) {\n    var p = Promise.resolve();\n    var logError = function (err) { console.error(err); };\n    timerFunc = function () {\n      p.then(nextTickHandler).catch(logError);\n      // in problematic UIWebViews, Promise.then doesn't completely break, but\n      // it can get stuck in a weird state where callbacks are pushed into the\n      // microtask queue but the queue isn't being flushed, until the browser\n      // needs to do some other work, e.g. handle a timer. Therefore we can\n      // \"force\" the microtask queue to be flushed by adding an empty timer.\n      if (isIOS) { setTimeout(noop); }\n    };\n  } else if (typeof MutationObserver !== 'undefined' && (\n    isNative(MutationObserver) ||\n    // PhantomJS and iOS 7.x\n    MutationObserver.toString() === '[object MutationObserverConstructor]'\n  )) {\n    // use MutationObserver where native Promise is not available,\n    // e.g. PhantomJS IE11, iOS7, Android 4.4\n    var counter = 1;\n    var observer = new MutationObserver(nextTickHandler);\n    var textNode = document.createTextNode(String(counter));\n    observer.observe(textNode, {\n      characterData: true\n    });\n    timerFunc = function () {\n      counter = (counter + 1) % 2;\n      textNode.data = String(counter);\n    };\n  } else {\n    // fallback to setTimeout\n    /* istanbul ignore next */\n    timerFunc = function () {\n      setTimeout(nextTickHandler, 0);\n    };\n  }\n\n  return function queueNextTick (cb, ctx) {\n    var _resolve;\n    callbacks.push(function () {\n      if (cb) { cb.call(ctx); }\n      if (_resolve) { _resolve(ctx); }\n    });\n    if (!pending) {\n      pending = true;\n      timerFunc();\n    }\n    if (!cb && typeof Promise !== 'undefined') {\n      return new Promise(function (resolve) {\n        _resolve = resolve;\n      })\n    }\n  }\n})();\n\nvar _Set;\n/* istanbul ignore if */\nif (typeof Set !== 'undefined' && isNative(Set)) {\n  // use native Set when available.\n  _Set = Set;\n} else {\n  // a non-standard Set polyfill that only works with primitive keys.\n  _Set = (function () {\n    function Set () {\n      this.set = Object.create(null);\n    }\n    Set.prototype.has = function has (key) {\n      return this.set[key] === true\n    };\n    Set.prototype.add = function add (key) {\n      this.set[key] = true;\n    };\n    Set.prototype.clear = function clear () {\n      this.set = Object.create(null);\n    };\n\n    return Set;\n  }());\n}\n\nvar warn = noop;\nvar formatComponentName;\n\nif (process.env.NODE_ENV !== 'production') {\n  var hasConsole = typeof console !== 'undefined';\n\n  warn = function (msg, vm) {\n    if (hasConsole && (!config.silent)) {\n      console.error(\"[Vue warn]: \" + msg + \" \" + (\n        vm ? formatLocation(formatComponentName(vm)) : ''\n      ));\n    }\n  };\n\n  formatComponentName = function (vm) {\n    if (vm.$root === vm) {\n      return 'root instance'\n    }\n    var name = vm._isVue\n      ? vm.$options.name || vm.$options._componentTag\n      : vm.name;\n    return (\n      (name ? (\"component <\" + name + \">\") : \"anonymous component\") +\n      (vm._isVue && vm.$options.__file ? (\" at \" + (vm.$options.__file)) : '')\n    )\n  };\n\n  var formatLocation = function (str) {\n    if (str === 'anonymous component') {\n      str += \" - use the \\\"name\\\" option for better debugging messages.\";\n    }\n    return (\"\\n(found in \" + str + \")\")\n  };\n}\n\n/*  */\n\n\nvar uid$1 = 0;\n\n/**\n * A dep is an observable that can have multiple\n * directives subscribing to it.\n */\nvar Dep = function Dep () {\n  this.id = uid$1++;\n  this.subs = [];\n};\n\nDep.prototype.addSub = function addSub (sub) {\n  this.subs.push(sub);\n};\n\nDep.prototype.removeSub = function removeSub (sub) {\n  remove$1(this.subs, sub);\n};\n\nDep.prototype.depend = function depend () {\n  if (Dep.target) {\n    Dep.target.addDep(this);\n  }\n};\n\nDep.prototype.notify = function notify () {\n  // stablize the subscriber list first\n  var subs = this.subs.slice();\n  for (var i = 0, l = subs.length; i < l; i++) {\n    subs[i].update();\n  }\n};\n\n// the current target watcher being evaluated.\n// this is globally unique because there could be only one\n// watcher being evaluated at any time.\nDep.target = null;\nvar targetStack = [];\n\nfunction pushTarget (_target) {\n  if (Dep.target) { targetStack.push(Dep.target); }\n  Dep.target = _target;\n}\n\nfunction popTarget () {\n  Dep.target = targetStack.pop();\n}\n\n/*\n * not type checking this file because flow doesn't play well with\n * dynamically accessing methods on Array prototype\n */\n\nvar arrayProto = Array.prototype;\nvar arrayMethods = Object.create(arrayProto);[\n  'push',\n  'pop',\n  'shift',\n  'unshift',\n  'splice',\n  'sort',\n  'reverse'\n]\n.forEach(function (method) {\n  // cache original method\n  var original = arrayProto[method];\n  def(arrayMethods, method, function mutator () {\n    var arguments$1 = arguments;\n\n    // avoid leaking arguments:\n    // http://jsperf.com/closure-with-arguments\n    var i = arguments.length;\n    var args = new Array(i);\n    while (i--) {\n      args[i] = arguments$1[i];\n    }\n    var result = original.apply(this, args);\n    var ob = this.__ob__;\n    var inserted;\n    switch (method) {\n      case 'push':\n        inserted = args;\n        break\n      case 'unshift':\n        inserted = args;\n        break\n      case 'splice':\n        inserted = args.slice(2);\n        break\n    }\n    if (inserted) { ob.observeArray(inserted); }\n    // notify change\n    ob.dep.notify();\n    return result\n  });\n});\n\n/*  */\n\nvar arrayKeys = Object.getOwnPropertyNames(arrayMethods);\n\n/**\n * By default, when a reactive property is set, the new value is\n * also converted to become reactive. However when passing down props,\n * we don't want to force conversion because the value may be a nested value\n * under a frozen data structure. Converting it would defeat the optimization.\n */\nvar observerState = {\n  shouldConvert: true,\n  isSettingProps: false\n};\n\n/**\n * Observer class that are attached to each observed\n * object. Once attached, the observer converts target\n * object's property keys into getter/setters that\n * collect dependencies and dispatches updates.\n */\nvar Observer = function Observer (value) {\n  this.value = value;\n  this.dep = new Dep();\n  this.vmCount = 0;\n  def(value, '__ob__', this);\n  if (Array.isArray(value)) {\n    var augment = hasProto\n      ? protoAugment\n      : copyAugment;\n    augment(value, arrayMethods, arrayKeys);\n    this.observeArray(value);\n  } else {\n    this.walk(value);\n  }\n};\n\n/**\n * Walk through each property and convert them into\n * getter/setters. This method should only be called when\n * value type is Object.\n */\nObserver.prototype.walk = function walk (obj) {\n  var keys = Object.keys(obj);\n  for (var i = 0; i < keys.length; i++) {\n    defineReactive$$1(obj, keys[i], obj[keys[i]]);\n  }\n};\n\n/**\n * Observe a list of Array items.\n */\nObserver.prototype.observeArray = function observeArray (items) {\n  for (var i = 0, l = items.length; i < l; i++) {\n    observe(items[i]);\n  }\n};\n\n// helpers\n\n/**\n * Augment an target Object or Array by intercepting\n * the prototype chain using __proto__\n */\nfunction protoAugment (target, src) {\n  /* eslint-disable no-proto */\n  target.__proto__ = src;\n  /* eslint-enable no-proto */\n}\n\n/**\n * Augment an target Object or Array by defining\n * hidden properties.\n */\n/* istanbul ignore next */\nfunction copyAugment (target, src, keys) {\n  for (var i = 0, l = keys.length; i < l; i++) {\n    var key = keys[i];\n    def(target, key, src[key]);\n  }\n}\n\n/**\n * Attempt to create an observer instance for a value,\n * returns the new observer if successfully observed,\n * or the existing observer if the value already has one.\n */\nfunction observe (value, asRootData) {\n  if (!isObject(value)) {\n    return\n  }\n  var ob;\n  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {\n    ob = value.__ob__;\n  } else if (\n    observerState.shouldConvert &&\n    !isServerRendering() &&\n    (Array.isArray(value) || isPlainObject(value)) &&\n    Object.isExtensible(value) &&\n    !value._isVue\n  ) {\n    ob = new Observer(value);\n  }\n  if (asRootData && ob) {\n    ob.vmCount++;\n  }\n  return ob\n}\n\n/**\n * Define a reactive property on an Object.\n */\nfunction defineReactive$$1 (\n  obj,\n  key,\n  val,\n  customSetter\n) {\n  var dep = new Dep();\n\n  var property = Object.getOwnPropertyDescriptor(obj, key);\n  if (property && property.configurable === false) {\n    return\n  }\n\n  // cater for pre-defined getter/setters\n  var getter = property && property.get;\n  var setter = property && property.set;\n\n  var childOb = observe(val);\n  Object.defineProperty(obj, key, {\n    enumerable: true,\n    configurable: true,\n    get: function reactiveGetter () {\n      var value = getter ? getter.call(obj) : val;\n      if (Dep.target) {\n        dep.depend();\n        if (childOb) {\n          childOb.dep.depend();\n        }\n        if (Array.isArray(value)) {\n          dependArray(value);\n        }\n      }\n      return value\n    },\n    set: function reactiveSetter (newVal) {\n      var value = getter ? getter.call(obj) : val;\n      /* eslint-disable no-self-compare */\n      if (newVal === value || (newVal !== newVal && value !== value)) {\n        return\n      }\n      /* eslint-enable no-self-compare */\n      if (process.env.NODE_ENV !== 'production' && customSetter) {\n        customSetter();\n      }\n      if (setter) {\n        setter.call(obj, newVal);\n      } else {\n        val = newVal;\n      }\n      childOb = observe(newVal);\n      dep.notify();\n    }\n  });\n}\n\n/**\n * Set a property on an object. Adds the new property and\n * triggers change notification if the property doesn't\n * already exist.\n */\nfunction set$1 (obj, key, val) {\n  if (Array.isArray(obj)) {\n    obj.length = Math.max(obj.length, key);\n    obj.splice(key, 1, val);\n    return val\n  }\n  if (hasOwn(obj, key)) {\n    obj[key] = val;\n    return\n  }\n  var ob = obj.__ob__;\n  if (obj._isVue || (ob && ob.vmCount)) {\n    process.env.NODE_ENV !== 'production' && warn(\n      'Avoid adding reactive properties to a Vue instance or its root $data ' +\n      'at runtime - declare it upfront in the data option.'\n    );\n    return\n  }\n  if (!ob) {\n    obj[key] = val;\n    return\n  }\n  defineReactive$$1(ob.value, key, val);\n  ob.dep.notify();\n  return val\n}\n\n/**\n * Delete a property and trigger change if necessary.\n */\nfunction del (obj, key) {\n  var ob = obj.__ob__;\n  if (obj._isVue || (ob && ob.vmCount)) {\n    process.env.NODE_ENV !== 'production' && warn(\n      'Avoid deleting properties on a Vue instance or its root $data ' +\n      '- just set it to null.'\n    );\n    return\n  }\n  if (!hasOwn(obj, key)) {\n    return\n  }\n  delete obj[key];\n  if (!ob) {\n    return\n  }\n  ob.dep.notify();\n}\n\n/**\n * Collect dependencies on array elements when the array is touched, since\n * we cannot intercept array element access like property getters.\n */\nfunction dependArray (value) {\n  for (var e = (void 0), i = 0, l = value.length; i < l; i++) {\n    e = value[i];\n    e && e.__ob__ && e.__ob__.dep.depend();\n    if (Array.isArray(e)) {\n      dependArray(e);\n    }\n  }\n}\n\n/*  */\n\n/**\n * Option overwriting strategies are functions that handle\n * how to merge a parent option value and a child option\n * value into the final value.\n */\nvar strats = config.optionMergeStrategies;\n\n/**\n * Options with restrictions\n */\nif (process.env.NODE_ENV !== 'production') {\n  strats.el = strats.propsData = function (parent, child, vm, key) {\n    if (!vm) {\n      warn(\n        \"option \\\"\" + key + \"\\\" can only be used during instance \" +\n        'creation with the `new` keyword.'\n      );\n    }\n    return defaultStrat(parent, child)\n  };\n}\n\n/**\n * Helper that recursively merges two data objects together.\n */\nfunction mergeData (to, from) {\n  if (!from) { return to }\n  var key, toVal, fromVal;\n  var keys = Object.keys(from);\n  for (var i = 0; i < keys.length; i++) {\n    key = keys[i];\n    toVal = to[key];\n    fromVal = from[key];\n    if (!hasOwn(to, key)) {\n      set$1(to, key, fromVal);\n    } else if (isPlainObject(toVal) && isPlainObject(fromVal)) {\n      mergeData(toVal, fromVal);\n    }\n  }\n  return to\n}\n\n/**\n * Data\n */\nstrats.data = function (\n  parentVal,\n  childVal,\n  vm\n) {\n  if (!vm) {\n    // in a Vue.extend merge, both should be functions\n    if (!childVal) {\n      return parentVal\n    }\n    if (typeof childVal !== 'function') {\n      process.env.NODE_ENV !== 'production' && warn(\n        'The \"data\" option should be a function ' +\n        'that returns a per-instance value in component ' +\n        'definitions.',\n        vm\n      );\n      return parentVal\n    }\n    if (!parentVal) {\n      return childVal\n    }\n    // when parentVal & childVal are both present,\n    // we need to return a function that returns the\n    // merged result of both functions... no need to\n    // check if parentVal is a function here because\n    // it has to be a function to pass previous merges.\n    return function mergedDataFn () {\n      return mergeData(\n        childVal.call(this),\n        parentVal.call(this)\n      )\n    }\n  } else if (parentVal || childVal) {\n    return function mergedInstanceDataFn () {\n      // instance merge\n      var instanceData = typeof childVal === 'function'\n        ? childVal.call(vm)\n        : childVal;\n      var defaultData = typeof parentVal === 'function'\n        ? parentVal.call(vm)\n        : undefined;\n      if (instanceData) {\n        return mergeData(instanceData, defaultData)\n      } else {\n        return defaultData\n      }\n    }\n  }\n};\n\n/**\n * Hooks and param attributes are merged as arrays.\n */\nfunction mergeHook (\n  parentVal,\n  childVal\n) {\n  return childVal\n    ? parentVal\n      ? parentVal.concat(childVal)\n      : Array.isArray(childVal)\n        ? childVal\n        : [childVal]\n    : parentVal\n}\n\nconfig._lifecycleHooks.forEach(function (hook) {\n  strats[hook] = mergeHook;\n});\n\n/**\n * Assets\n *\n * When a vm is present (instance creation), we need to do\n * a three-way merge between constructor options, instance\n * options and parent options.\n */\nfunction mergeAssets (parentVal, childVal) {\n  var res = Object.create(parentVal || null);\n  return childVal\n    ? extend(res, childVal)\n    : res\n}\n\nconfig._assetTypes.forEach(function (type) {\n  strats[type + 's'] = mergeAssets;\n});\n\n/**\n * Watchers.\n *\n * Watchers hashes should not overwrite one\n * another, so we merge them as arrays.\n */\nstrats.watch = function (parentVal, childVal) {\n  /* istanbul ignore if */\n  if (!childVal) { return parentVal }\n  if (!parentVal) { return childVal }\n  var ret = {};\n  extend(ret, parentVal);\n  for (var key in childVal) {\n    var parent = ret[key];\n    var child = childVal[key];\n    if (parent && !Array.isArray(parent)) {\n      parent = [parent];\n    }\n    ret[key] = parent\n      ? parent.concat(child)\n      : [child];\n  }\n  return ret\n};\n\n/**\n * Other object hashes.\n */\nstrats.props =\nstrats.methods =\nstrats.computed = function (parentVal, childVal) {\n  if (!childVal) { return parentVal }\n  if (!parentVal) { return childVal }\n  var ret = Object.create(null);\n  extend(ret, parentVal);\n  extend(ret, childVal);\n  return ret\n};\n\n/**\n * Default strategy.\n */\nvar defaultStrat = function (parentVal, childVal) {\n  return childVal === undefined\n    ? parentVal\n    : childVal\n};\n\n/**\n * Validate component names\n */\nfunction checkComponents (options) {\n  for (var key in options.components) {\n    var lower = key.toLowerCase();\n    if (isBuiltInTag(lower) || config.isReservedTag(lower)) {\n      warn(\n        'Do not use built-in or reserved HTML elements as component ' +\n        'id: ' + key\n      );\n    }\n  }\n}\n\n/**\n * Ensure all props option syntax are normalized into the\n * Object-based format.\n */\nfunction normalizeProps (options) {\n  var props = options.props;\n  if (!props) { return }\n  var res = {};\n  var i, val, name;\n  if (Array.isArray(props)) {\n    i = props.length;\n    while (i--) {\n      val = props[i];\n      if (typeof val === 'string') {\n        name = camelize(val);\n        res[name] = { type: null };\n      } else if (process.env.NODE_ENV !== 'production') {\n        warn('props must be strings when using array syntax.');\n      }\n    }\n  } else if (isPlainObject(props)) {\n    for (var key in props) {\n      val = props[key];\n      name = camelize(key);\n      res[name] = isPlainObject(val)\n        ? val\n        : { type: val };\n    }\n  }\n  options.props = res;\n}\n\n/**\n * Normalize raw function directives into object format.\n */\nfunction normalizeDirectives (options) {\n  var dirs = options.directives;\n  if (dirs) {\n    for (var key in dirs) {\n      var def = dirs[key];\n      if (typeof def === 'function') {\n        dirs[key] = { bind: def, update: def };\n      }\n    }\n  }\n}\n\n/**\n * Merge two option objects into a new one.\n * Core utility used in both instantiation and inheritance.\n */\nfunction mergeOptions (\n  parent,\n  child,\n  vm\n) {\n  if (process.env.NODE_ENV !== 'production') {\n    checkComponents(child);\n  }\n  normalizeProps(child);\n  normalizeDirectives(child);\n  var extendsFrom = child.extends;\n  if (extendsFrom) {\n    parent = typeof extendsFrom === 'function'\n      ? mergeOptions(parent, extendsFrom.options, vm)\n      : mergeOptions(parent, extendsFrom, vm);\n  }\n  if (child.mixins) {\n    for (var i = 0, l = child.mixins.length; i < l; i++) {\n      var mixin = child.mixins[i];\n      if (mixin.prototype instanceof Vue$3) {\n        mixin = mixin.options;\n      }\n      parent = mergeOptions(parent, mixin, vm);\n    }\n  }\n  var options = {};\n  var key;\n  for (key in parent) {\n    mergeField(key);\n  }\n  for (key in child) {\n    if (!hasOwn(parent, key)) {\n      mergeField(key);\n    }\n  }\n  function mergeField (key) {\n    var strat = strats[key] || defaultStrat;\n    options[key] = strat(parent[key], child[key], vm, key);\n  }\n  return options\n}\n\n/**\n * Resolve an asset.\n * This function is used because child instances need access\n * to assets defined in its ancestor chain.\n */\nfunction resolveAsset (\n  options,\n  type,\n  id,\n  warnMissing\n) {\n  /* istanbul ignore if */\n  if (typeof id !== 'string') {\n    return\n  }\n  var assets = options[type];\n  // check local registration variations first\n  if (hasOwn(assets, id)) { return assets[id] }\n  var camelizedId = camelize(id);\n  if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }\n  var PascalCaseId = capitalize(camelizedId);\n  if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }\n  // fallback to prototype chain\n  var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];\n  if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {\n    warn(\n      'Failed to resolve ' + type.slice(0, -1) + ': ' + id,\n      options\n    );\n  }\n  return res\n}\n\n/*  */\n\nfunction validateProp (\n  key,\n  propOptions,\n  propsData,\n  vm\n) {\n  var prop = propOptions[key];\n  var absent = !hasOwn(propsData, key);\n  var value = propsData[key];\n  // handle boolean props\n  if (isType(Boolean, prop.type)) {\n    if (absent && !hasOwn(prop, 'default')) {\n      value = false;\n    } else if (!isType(String, prop.type) && (value === '' || value === hyphenate(key))) {\n      value = true;\n    }\n  }\n  // check default value\n  if (value === undefined) {\n    value = getPropDefaultValue(vm, prop, key);\n    // since the default value is a fresh copy,\n    // make sure to observe it.\n    var prevShouldConvert = observerState.shouldConvert;\n    observerState.shouldConvert = true;\n    observe(value);\n    observerState.shouldConvert = prevShouldConvert;\n  }\n  if (process.env.NODE_ENV !== 'production') {\n    assertProp(prop, key, value, vm, absent);\n  }\n  return value\n}\n\n/**\n * Get the default value of a prop.\n */\nfunction getPropDefaultValue (vm, prop, key) {\n  // no default, return undefined\n  if (!hasOwn(prop, 'default')) {\n    return undefined\n  }\n  var def = prop.default;\n  // warn against non-factory defaults for Object & Array\n  if (isObject(def)) {\n    process.env.NODE_ENV !== 'production' && warn(\n      'Invalid default value for prop \"' + key + '\": ' +\n      'Props with type Object/Array must use a factory function ' +\n      'to return the default value.',\n      vm\n    );\n  }\n  // the raw prop value was also undefined from previous render,\n  // return previous default value to avoid unnecessary watcher trigger\n  if (vm && vm.$options.propsData &&\n    vm.$options.propsData[key] === undefined &&\n    vm[key] !== undefined) {\n    return vm[key]\n  }\n  // call factory function for non-Function types\n  return typeof def === 'function' && prop.type !== Function\n    ? def.call(vm)\n    : def\n}\n\n/**\n * Assert whether a prop is valid.\n */\nfunction assertProp (\n  prop,\n  name,\n  value,\n  vm,\n  absent\n) {\n  if (prop.required && absent) {\n    warn(\n      'Missing required prop: \"' + name + '\"',\n      vm\n    );\n    return\n  }\n  if (value == null && !prop.required) {\n    return\n  }\n  var type = prop.type;\n  var valid = !type || type === true;\n  var expectedTypes = [];\n  if (type) {\n    if (!Array.isArray(type)) {\n      type = [type];\n    }\n    for (var i = 0; i < type.length && !valid; i++) {\n      var assertedType = assertType(value, type[i]);\n      expectedTypes.push(assertedType.expectedType || '');\n      valid = assertedType.valid;\n    }\n  }\n  if (!valid) {\n    warn(\n      'Invalid prop: type check failed for prop \"' + name + '\".' +\n      ' Expected ' + expectedTypes.map(capitalize).join(', ') +\n      ', got ' + Object.prototype.toString.call(value).slice(8, -1) + '.',\n      vm\n    );\n    return\n  }\n  var validator = prop.validator;\n  if (validator) {\n    if (!validator(value)) {\n      warn(\n        'Invalid prop: custom validator check failed for prop \"' + name + '\".',\n        vm\n      );\n    }\n  }\n}\n\n/**\n * Assert the type of a value\n */\nfunction assertType (value, type) {\n  var valid;\n  var expectedType = getType(type);\n  if (expectedType === 'String') {\n    valid = typeof value === (expectedType = 'string');\n  } else if (expectedType === 'Number') {\n    valid = typeof value === (expectedType = 'number');\n  } else if (expectedType === 'Boolean') {\n    valid = typeof value === (expectedType = 'boolean');\n  } else if (expectedType === 'Function') {\n    valid = typeof value === (expectedType = 'function');\n  } else if (expectedType === 'Object') {\n    valid = isPlainObject(value);\n  } else if (expectedType === 'Array') {\n    valid = Array.isArray(value);\n  } else {\n    valid = value instanceof type;\n  }\n  return {\n    valid: valid,\n    expectedType: expectedType\n  }\n}\n\n/**\n * Use function string name to check built-in types,\n * because a simple equality check will fail when running\n * across different vms / iframes.\n */\nfunction getType (fn) {\n  var match = fn && fn.toString().match(/^\\s*function (\\w+)/);\n  return match && match[1]\n}\n\nfunction isType (type, fn) {\n  if (!Array.isArray(fn)) {\n    return getType(fn) === getType(type)\n  }\n  for (var i = 0, len = fn.length; i < len; i++) {\n    if (getType(fn[i]) === getType(type)) {\n      return true\n    }\n  }\n  /* istanbul ignore next */\n  return false\n}\n\n\n\nvar util = Object.freeze({\n\tdefineReactive: defineReactive$$1,\n\t_toString: _toString,\n\ttoNumber: toNumber,\n\tmakeMap: makeMap,\n\tisBuiltInTag: isBuiltInTag,\n\tremove: remove$1,\n\thasOwn: hasOwn,\n\tisPrimitive: isPrimitive,\n\tcached: cached,\n\tcamelize: camelize,\n\tcapitalize: capitalize,\n\thyphenate: hyphenate,\n\tbind: bind$1,\n\ttoArray: toArray,\n\textend: extend,\n\tisObject: isObject,\n\tisPlainObject: isPlainObject,\n\ttoObject: toObject,\n\tnoop: noop,\n\tno: no,\n\tidentity: identity,\n\tgenStaticKeys: genStaticKeys,\n\tlooseEqual: looseEqual,\n\tlooseIndexOf: looseIndexOf,\n\tisReserved: isReserved,\n\tdef: def,\n\tparsePath: parsePath,\n\thasProto: hasProto,\n\tinBrowser: inBrowser,\n\tUA: UA,\n\tisIE: isIE,\n\tisIE9: isIE9,\n\tisEdge: isEdge,\n\tisAndroid: isAndroid,\n\tisIOS: isIOS,\n\tisServerRendering: isServerRendering,\n\tdevtools: devtools,\n\tnextTick: nextTick,\n\tget _Set () { return _Set; },\n\tmergeOptions: mergeOptions,\n\tresolveAsset: resolveAsset,\n\tget warn () { return warn; },\n\tget formatComponentName () { return formatComponentName; },\n\tvalidateProp: validateProp\n});\n\n/* not type checking this file because flow doesn't play well with Proxy */\n\nvar initProxy;\n\nif (process.env.NODE_ENV !== 'production') {\n  var allowedGlobals = makeMap(\n    'Infinity,undefined,NaN,isFinite,isNaN,' +\n    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +\n    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +\n    'require' // for Webpack/Browserify\n  );\n\n  var warnNonPresent = function (target, key) {\n    warn(\n      \"Property or method \\\"\" + key + \"\\\" is not defined on the instance but \" +\n      \"referenced during render. Make sure to declare reactive data \" +\n      \"properties in the data option.\",\n      target\n    );\n  };\n\n  var hasProxy =\n    typeof Proxy !== 'undefined' &&\n    Proxy.toString().match(/native code/);\n\n  if (hasProxy) {\n    var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta');\n    config.keyCodes = new Proxy(config.keyCodes, {\n      set: function set (target, key, value) {\n        if (isBuiltInModifier(key)) {\n          warn((\"Avoid overwriting built-in modifier in config.keyCodes: .\" + key));\n          return false\n        } else {\n          target[key] = value;\n          return true\n        }\n      }\n    });\n  }\n\n  var hasHandler = {\n    has: function has (target, key) {\n      var has = key in target;\n      var isAllowed = allowedGlobals(key) || key.charAt(0) === '_';\n      if (!has && !isAllowed) {\n        warnNonPresent(target, key);\n      }\n      return has || !isAllowed\n    }\n  };\n\n  var getHandler = {\n    get: function get (target, key) {\n      if (typeof key === 'string' && !(key in target)) {\n        warnNonPresent(target, key);\n      }\n      return target[key]\n    }\n  };\n\n  initProxy = function initProxy (vm) {\n    if (hasProxy) {\n      // determine which proxy handler to use\n      var options = vm.$options;\n      var handlers = options.render && options.render._withStripped\n        ? getHandler\n        : hasHandler;\n      vm._renderProxy = new Proxy(vm, handlers);\n    } else {\n      vm._renderProxy = vm;\n    }\n  };\n}\n\n/*  */\n\nvar VNode = function VNode (\n  tag,\n  data,\n  children,\n  text,\n  elm,\n  context,\n  componentOptions\n) {\n  this.tag = tag;\n  this.data = data;\n  this.children = children;\n  this.text = text;\n  this.elm = elm;\n  this.ns = undefined;\n  this.context = context;\n  this.functionalContext = undefined;\n  this.key = data && data.key;\n  this.componentOptions = componentOptions;\n  this.componentInstance = undefined;\n  this.parent = undefined;\n  this.raw = false;\n  this.isStatic = false;\n  this.isRootInsert = true;\n  this.isComment = false;\n  this.isCloned = false;\n  this.isOnce = false;\n};\n\nvar prototypeAccessors = { child: {} };\n\n// DEPRECATED: alias for componentInstance for backwards compat.\n/* istanbul ignore next */\nprototypeAccessors.child.get = function () {\n  return this.componentInstance\n};\n\nObject.defineProperties( VNode.prototype, prototypeAccessors );\n\nvar createEmptyVNode = function () {\n  var node = new VNode();\n  node.text = '';\n  node.isComment = true;\n  return node\n};\n\nfunction createTextVNode (val) {\n  return new VNode(undefined, undefined, undefined, String(val))\n}\n\n// optimized shallow clone\n// used for static nodes and slot nodes because they may be reused across\n// multiple renders, cloning them avoids errors when DOM manipulations rely\n// on their elm reference.\nfunction cloneVNode (vnode) {\n  var cloned = new VNode(\n    vnode.tag,\n    vnode.data,\n    vnode.children,\n    vnode.text,\n    vnode.elm,\n    vnode.context,\n    vnode.componentOptions\n  );\n  cloned.ns = vnode.ns;\n  cloned.isStatic = vnode.isStatic;\n  cloned.key = vnode.key;\n  cloned.isCloned = true;\n  return cloned\n}\n\nfunction cloneVNodes (vnodes) {\n  var res = new Array(vnodes.length);\n  for (var i = 0; i < vnodes.length; i++) {\n    res[i] = cloneVNode(vnodes[i]);\n  }\n  return res\n}\n\n/*  */\n\nvar hooks = { init: init, prepatch: prepatch, insert: insert, destroy: destroy$1 };\nvar hooksToMerge = Object.keys(hooks);\n\nfunction createComponent (\n  Ctor,\n  data,\n  context,\n  children,\n  tag\n) {\n  if (!Ctor) {\n    return\n  }\n\n  var baseCtor = context.$options._base;\n  if (isObject(Ctor)) {\n    Ctor = baseCtor.extend(Ctor);\n  }\n\n  if (typeof Ctor !== 'function') {\n    if (process.env.NODE_ENV !== 'production') {\n      warn((\"Invalid Component definition: \" + (String(Ctor))), context);\n    }\n    return\n  }\n\n  // async component\n  if (!Ctor.cid) {\n    if (Ctor.resolved) {\n      Ctor = Ctor.resolved;\n    } else {\n      Ctor = resolveAsyncComponent(Ctor, baseCtor, function () {\n        // it's ok to queue this on every render because\n        // $forceUpdate is buffered by the scheduler.\n        context.$forceUpdate();\n      });\n      if (!Ctor) {\n        // return nothing if this is indeed an async component\n        // wait for the callback to trigger parent update.\n        return\n      }\n    }\n  }\n\n  // resolve constructor options in case global mixins are applied after\n  // component constructor creation\n  resolveConstructorOptions(Ctor);\n\n  data = data || {};\n\n  // extract props\n  var propsData = extractProps(data, Ctor);\n\n  // functional component\n  if (Ctor.options.functional) {\n    return createFunctionalComponent(Ctor, propsData, data, context, children)\n  }\n\n  // extract listeners, since these needs to be treated as\n  // child component listeners instead of DOM listeners\n  var listeners = data.on;\n  // replace with listeners with .native modifier\n  data.on = data.nativeOn;\n\n  if (Ctor.options.abstract) {\n    // abstract components do not keep anything\n    // other than props & listeners\n    data = {};\n  }\n\n  // merge component management hooks onto the placeholder node\n  mergeHooks(data);\n\n  // return a placeholder vnode\n  var name = Ctor.options.name || tag;\n  var vnode = new VNode(\n    (\"vue-component-\" + (Ctor.cid) + (name ? (\"-\" + name) : '')),\n    data, undefined, undefined, undefined, context,\n    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }\n  );\n  return vnode\n}\n\nfunction createFunctionalComponent (\n  Ctor,\n  propsData,\n  data,\n  context,\n  children\n) {\n  var props = {};\n  var propOptions = Ctor.options.props;\n  if (propOptions) {\n    for (var key in propOptions) {\n      props[key] = validateProp(key, propOptions, propsData);\n    }\n  }\n  // ensure the createElement function in functional components\n  // gets a unique context - this is necessary for correct named slot check\n  var _context = Object.create(context);\n  var h = function (a, b, c, d) { return createElement(_context, a, b, c, d, true); };\n  var vnode = Ctor.options.render.call(null, h, {\n    props: props,\n    data: data,\n    parent: context,\n    children: children,\n    slots: function () { return resolveSlots(children, context); }\n  });\n  if (vnode instanceof VNode) {\n    vnode.functionalContext = context;\n    if (data.slot) {\n      (vnode.data || (vnode.data = {})).slot = data.slot;\n    }\n  }\n  return vnode\n}\n\nfunction createComponentInstanceForVnode (\n  vnode, // we know it's MountedComponentVNode but flow doesn't\n  parent, // activeInstance in lifecycle state\n  parentElm,\n  refElm\n) {\n  var vnodeComponentOptions = vnode.componentOptions;\n  var options = {\n    _isComponent: true,\n    parent: parent,\n    propsData: vnodeComponentOptions.propsData,\n    _componentTag: vnodeComponentOptions.tag,\n    _parentVnode: vnode,\n    _parentListeners: vnodeComponentOptions.listeners,\n    _renderChildren: vnodeComponentOptions.children,\n    _parentElm: parentElm || null,\n    _refElm: refElm || null\n  };\n  // check inline-template render functions\n  var inlineTemplate = vnode.data.inlineTemplate;\n  if (inlineTemplate) {\n    options.render = inlineTemplate.render;\n    options.staticRenderFns = inlineTemplate.staticRenderFns;\n  }\n  return new vnodeComponentOptions.Ctor(options)\n}\n\nfunction init (\n  vnode,\n  hydrating,\n  parentElm,\n  refElm\n) {\n  if (!vnode.componentInstance || vnode.componentInstance._isDestroyed) {\n    var child = vnode.componentInstance = createComponentInstanceForVnode(\n      vnode,\n      activeInstance,\n      parentElm,\n      refElm\n    );\n    child.$mount(hydrating ? vnode.elm : undefined, hydrating);\n  } else if (vnode.data.keepAlive) {\n    // kept-alive components, treat as a patch\n    var mountedNode = vnode; // work around flow\n    prepatch(mountedNode, mountedNode);\n  }\n}\n\nfunction prepatch (\n  oldVnode,\n  vnode\n) {\n  var options = vnode.componentOptions;\n  var child = vnode.componentInstance = oldVnode.componentInstance;\n  child._updateFromParent(\n    options.propsData, // updated props\n    options.listeners, // updated listeners\n    vnode, // new parent vnode\n    options.children // new children\n  );\n}\n\nfunction insert (vnode) {\n  if (!vnode.componentInstance._isMounted) {\n    vnode.componentInstance._isMounted = true;\n    callHook(vnode.componentInstance, 'mounted');\n  }\n  if (vnode.data.keepAlive) {\n    vnode.componentInstance._inactive = false;\n    callHook(vnode.componentInstance, 'activated');\n  }\n}\n\nfunction destroy$1 (vnode) {\n  if (!vnode.componentInstance._isDestroyed) {\n    if (!vnode.data.keepAlive) {\n      vnode.componentInstance.$destroy();\n    } else {\n      vnode.componentInstance._inactive = true;\n      callHook(vnode.componentInstance, 'deactivated');\n    }\n  }\n}\n\nfunction resolveAsyncComponent (\n  factory,\n  baseCtor,\n  cb\n) {\n  if (factory.requested) {\n    // pool callbacks\n    factory.pendingCallbacks.push(cb);\n  } else {\n    factory.requested = true;\n    var cbs = factory.pendingCallbacks = [cb];\n    var sync = true;\n\n    var resolve = function (res) {\n      if (isObject(res)) {\n        res = baseCtor.extend(res);\n      }\n      // cache resolved\n      factory.resolved = res;\n      // invoke callbacks only if this is not a synchronous resolve\n      // (async resolves are shimmed as synchronous during SSR)\n      if (!sync) {\n        for (var i = 0, l = cbs.length; i < l; i++) {\n          cbs[i](res);\n        }\n      }\n    };\n\n    var reject = function (reason) {\n      process.env.NODE_ENV !== 'production' && warn(\n        \"Failed to resolve async component: \" + (String(factory)) +\n        (reason ? (\"\\nReason: \" + reason) : '')\n      );\n    };\n\n    var res = factory(resolve, reject);\n\n    // handle promise\n    if (res && typeof res.then === 'function' && !factory.resolved) {\n      res.then(resolve, reject);\n    }\n\n    sync = false;\n    // return in case resolved synchronously\n    return factory.resolved\n  }\n}\n\nfunction extractProps (data, Ctor) {\n  // we are only extracting raw values here.\n  // validation and default values are handled in the child\n  // component itself.\n  var propOptions = Ctor.options.props;\n  if (!propOptions) {\n    return\n  }\n  var res = {};\n  var attrs = data.attrs;\n  var props = data.props;\n  var domProps = data.domProps;\n  if (attrs || props || domProps) {\n    for (var key in propOptions) {\n      var altKey = hyphenate(key);\n      checkProp(res, props, key, altKey, true) ||\n      checkProp(res, attrs, key, altKey) ||\n      checkProp(res, domProps, key, altKey);\n    }\n  }\n  return res\n}\n\nfunction checkProp (\n  res,\n  hash,\n  key,\n  altKey,\n  preserve\n) {\n  if (hash) {\n    if (hasOwn(hash, key)) {\n      res[key] = hash[key];\n      if (!preserve) {\n        delete hash[key];\n      }\n      return true\n    } else if (hasOwn(hash, altKey)) {\n      res[key] = hash[altKey];\n      if (!preserve) {\n        delete hash[altKey];\n      }\n      return true\n    }\n  }\n  return false\n}\n\nfunction mergeHooks (data) {\n  if (!data.hook) {\n    data.hook = {};\n  }\n  for (var i = 0; i < hooksToMerge.length; i++) {\n    var key = hooksToMerge[i];\n    var fromParent = data.hook[key];\n    var ours = hooks[key];\n    data.hook[key] = fromParent ? mergeHook$1(ours, fromParent) : ours;\n  }\n}\n\nfunction mergeHook$1 (one, two) {\n  return function (a, b, c, d) {\n    one(a, b, c, d);\n    two(a, b, c, d);\n  }\n}\n\n/*  */\n\nfunction mergeVNodeHook (def, hookKey, hook, key) {\n  key = key + hookKey;\n  var injectedHash = def.__injected || (def.__injected = {});\n  if (!injectedHash[key]) {\n    injectedHash[key] = true;\n    var oldHook = def[hookKey];\n    if (oldHook) {\n      def[hookKey] = function () {\n        oldHook.apply(this, arguments);\n        hook.apply(this, arguments);\n      };\n    } else {\n      def[hookKey] = hook;\n    }\n  }\n}\n\n/*  */\n\nvar normalizeEvent = cached(function (name) {\n  var once = name.charAt(0) === '~'; // Prefixed last, checked first\n  name = once ? name.slice(1) : name;\n  var capture = name.charAt(0) === '!';\n  name = capture ? name.slice(1) : name;\n  return {\n    name: name,\n    once: once,\n    capture: capture\n  }\n});\n\nfunction createEventHandle (fn) {\n  var handle = {\n    fn: fn,\n    invoker: function () {\n      var arguments$1 = arguments;\n\n      var fn = handle.fn;\n      if (Array.isArray(fn)) {\n        for (var i = 0; i < fn.length; i++) {\n          fn[i].apply(null, arguments$1);\n        }\n      } else {\n        fn.apply(null, arguments);\n      }\n    }\n  };\n  return handle\n}\n\nfunction updateListeners (\n  on,\n  oldOn,\n  add,\n  remove$$1,\n  vm\n) {\n  var name, cur, old, event;\n  for (name in on) {\n    cur = on[name];\n    old = oldOn[name];\n    event = normalizeEvent(name);\n    if (!cur) {\n      process.env.NODE_ENV !== 'production' && warn(\n        \"Invalid handler for event \\\"\" + (event.name) + \"\\\": got \" + String(cur),\n        vm\n      );\n    } else if (!old) {\n      if (!cur.invoker) {\n        cur = on[name] = createEventHandle(cur);\n      }\n      add(event.name, cur.invoker, event.once, event.capture);\n    } else if (cur !== old) {\n      old.fn = cur;\n      on[name] = old;\n    }\n  }\n  for (name in oldOn) {\n    if (!on[name]) {\n      event = normalizeEvent(name);\n      remove$$1(event.name, oldOn[name].invoker, event.capture);\n    }\n  }\n}\n\n/*  */\n\n// The template compiler attempts to minimize the need for normalization by\n// statically analyzing the template at compile time.\n//\n// For plain HTML markup, normalization can be completely skipped because the\n// generated render function is guaranteed to return Array<VNode>. There are\n// two cases where extra normalization is needed:\n\n// 1. When the children contains components - because a functional component\n// may return an Array instead of a single root. In this case, just a simple\n// nomralization is needed - if any child is an Array, we flatten the whole\n// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep\n// because functional components already normalize their own children.\nfunction simpleNormalizeChildren (children) {\n  for (var i = 0; i < children.length; i++) {\n    if (Array.isArray(children[i])) {\n      return Array.prototype.concat.apply([], children)\n    }\n  }\n  return children\n}\n\n// 2. When the children contains constrcuts that always generated nested Arrays,\n// e.g. <template>, <slot>, v-for, or when the children is provided by user\n// with hand-written render functions / JSX. In such cases a full normalization\n// is needed to cater to all possible types of children values.\nfunction normalizeChildren (children) {\n  return isPrimitive(children)\n    ? [createTextVNode(children)]\n    : Array.isArray(children)\n      ? normalizeArrayChildren(children)\n      : undefined\n}\n\nfunction normalizeArrayChildren (children, nestedIndex) {\n  var res = [];\n  var i, c, last;\n  for (i = 0; i < children.length; i++) {\n    c = children[i];\n    if (c == null || typeof c === 'boolean') { continue }\n    last = res[res.length - 1];\n    //  nested\n    if (Array.isArray(c)) {\n      res.push.apply(res, normalizeArrayChildren(c, ((nestedIndex || '') + \"_\" + i)));\n    } else if (isPrimitive(c)) {\n      if (last && last.text) {\n        last.text += String(c);\n      } else if (c !== '') {\n        // convert primitive to vnode\n        res.push(createTextVNode(c));\n      }\n    } else {\n      if (c.text && last && last.text) {\n        res[res.length - 1] = createTextVNode(last.text + c.text);\n      } else {\n        // default key for nested array children (likely generated by v-for)\n        if (c.tag && c.key == null && nestedIndex != null) {\n          c.key = \"__vlist\" + nestedIndex + \"_\" + i + \"__\";\n        }\n        res.push(c);\n      }\n    }\n  }\n  return res\n}\n\n/*  */\n\nfunction getFirstComponentChild (children) {\n  return children && children.filter(function (c) { return c && c.componentOptions; })[0]\n}\n\n/*  */\n\nvar SIMPLE_NORMALIZE = 1;\nvar ALWAYS_NORMALIZE = 2;\n\n// wrapper function for providing a more flexible interface\n// without getting yelled at by flow\nfunction createElement (\n  context,\n  tag,\n  data,\n  children,\n  normalizationType,\n  alwaysNormalize\n) {\n  if (Array.isArray(data) || isPrimitive(data)) {\n    normalizationType = children;\n    children = data;\n    data = undefined;\n  }\n  if (alwaysNormalize) { normalizationType = ALWAYS_NORMALIZE; }\n  return _createElement(context, tag, data, children, normalizationType)\n}\n\nfunction _createElement (\n  context,\n  tag,\n  data,\n  children,\n  normalizationType\n) {\n  if (data && data.__ob__) {\n    process.env.NODE_ENV !== 'production' && warn(\n      \"Avoid using observed data object as vnode data: \" + (JSON.stringify(data)) + \"\\n\" +\n      'Always create fresh vnode data objects in each render!',\n      context\n    );\n    return createEmptyVNode()\n  }\n  if (!tag) {\n    // in case of component :is set to falsy value\n    return createEmptyVNode()\n  }\n  // support single function children as default scoped slot\n  if (Array.isArray(children) &&\n      typeof children[0] === 'function') {\n    data = data || {};\n    data.scopedSlots = { default: children[0] };\n    children.length = 0;\n  }\n  if (normalizationType === ALWAYS_NORMALIZE) {\n    children = normalizeChildren(children);\n  } else if (normalizationType === SIMPLE_NORMALIZE) {\n    children = simpleNormalizeChildren(children);\n  }\n  var vnode, ns;\n  if (typeof tag === 'string') {\n    var Ctor;\n    ns = config.getTagNamespace(tag);\n    if (config.isReservedTag(tag)) {\n      // platform built-in elements\n      vnode = new VNode(\n        config.parsePlatformTagName(tag), data, children,\n        undefined, undefined, context\n      );\n    } else if ((Ctor = resolveAsset(context.$options, 'components', tag))) {\n      // component\n      vnode = createComponent(Ctor, data, context, children, tag);\n    } else {\n      // unknown or unlisted namespaced elements\n      // check at runtime because it may get assigned a namespace when its\n      // parent normalizes children\n      vnode = new VNode(\n        tag, data, children,\n        undefined, undefined, context\n      );\n    }\n  } else {\n    // direct component options / constructor\n    vnode = createComponent(tag, data, context, children);\n  }\n  if (vnode) {\n    if (ns) { applyNS(vnode, ns); }\n    return vnode\n  } else {\n    return createEmptyVNode()\n  }\n}\n\nfunction applyNS (vnode, ns) {\n  vnode.ns = ns;\n  if (vnode.tag === 'foreignObject') {\n    // use default namespace inside foreignObject\n    return\n  }\n  if (vnode.children) {\n    for (var i = 0, l = vnode.children.length; i < l; i++) {\n      var child = vnode.children[i];\n      if (child.tag && !child.ns) {\n        applyNS(child, ns);\n      }\n    }\n  }\n}\n\n/*  */\n\nfunction initRender (vm) {\n  vm.$vnode = null; // the placeholder node in parent tree\n  vm._vnode = null; // the root of the child tree\n  vm._staticTrees = null;\n  var parentVnode = vm.$options._parentVnode;\n  var renderContext = parentVnode && parentVnode.context;\n  vm.$slots = resolveSlots(vm.$options._renderChildren, renderContext);\n  vm.$scopedSlots = {};\n  // bind the createElement fn to this instance\n  // so that we get proper render context inside it.\n  // args order: tag, data, children, normalizationType, alwaysNormalize\n  // internal version is used by render functions compiled from templates\n  vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };\n  // normalization is always applied for the public version, used in\n  // user-written render functions.\n  vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };\n}\n\nfunction renderMixin (Vue) {\n  Vue.prototype.$nextTick = function (fn) {\n    return nextTick(fn, this)\n  };\n\n  Vue.prototype._render = function () {\n    var vm = this;\n    var ref = vm.$options;\n    var render = ref.render;\n    var staticRenderFns = ref.staticRenderFns;\n    var _parentVnode = ref._parentVnode;\n\n    if (vm._isMounted) {\n      // clone slot nodes on re-renders\n      for (var key in vm.$slots) {\n        vm.$slots[key] = cloneVNodes(vm.$slots[key]);\n      }\n    }\n\n    if (_parentVnode && _parentVnode.data.scopedSlots) {\n      vm.$scopedSlots = _parentVnode.data.scopedSlots;\n    }\n\n    if (staticRenderFns && !vm._staticTrees) {\n      vm._staticTrees = [];\n    }\n    // set parent vnode. this allows render functions to have access\n    // to the data on the placeholder node.\n    vm.$vnode = _parentVnode;\n    // render self\n    var vnode;\n    try {\n      vnode = render.call(vm._renderProxy, vm.$createElement);\n    } catch (e) {\n      /* istanbul ignore else */\n      if (config.errorHandler) {\n        config.errorHandler.call(null, e, vm);\n      } else {\n        if (process.env.NODE_ENV !== 'production') {\n          warn((\"Error when rendering \" + (formatComponentName(vm)) + \":\"));\n        }\n        throw e\n      }\n      // return previous vnode to prevent render error causing blank component\n      vnode = vm._vnode;\n    }\n    // return empty vnode in case the render function errored out\n    if (!(vnode instanceof VNode)) {\n      if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {\n        warn(\n          'Multiple root nodes returned from render function. Render function ' +\n          'should return a single root node.',\n          vm\n        );\n      }\n      vnode = createEmptyVNode();\n    }\n    // set parent\n    vnode.parent = _parentVnode;\n    return vnode\n  };\n\n  // toString for mustaches\n  Vue.prototype._s = _toString;\n  // convert text to vnode\n  Vue.prototype._v = createTextVNode;\n  // number conversion\n  Vue.prototype._n = toNumber;\n  // empty vnode\n  Vue.prototype._e = createEmptyVNode;\n  // loose equal\n  Vue.prototype._q = looseEqual;\n  // loose indexOf\n  Vue.prototype._i = looseIndexOf;\n\n  // render static tree by index\n  Vue.prototype._m = function renderStatic (\n    index,\n    isInFor\n  ) {\n    var tree = this._staticTrees[index];\n    // if has already-rendered static tree and not inside v-for,\n    // we can reuse the same tree by doing a shallow clone.\n    if (tree && !isInFor) {\n      return Array.isArray(tree)\n        ? cloneVNodes(tree)\n        : cloneVNode(tree)\n    }\n    // otherwise, render a fresh tree.\n    tree = this._staticTrees[index] = this.$options.staticRenderFns[index].call(this._renderProxy);\n    markStatic(tree, (\"__static__\" + index), false);\n    return tree\n  };\n\n  // mark node as static (v-once)\n  Vue.prototype._o = function markOnce (\n    tree,\n    index,\n    key\n  ) {\n    markStatic(tree, (\"__once__\" + index + (key ? (\"_\" + key) : \"\")), true);\n    return tree\n  };\n\n  function markStatic (tree, key, isOnce) {\n    if (Array.isArray(tree)) {\n      for (var i = 0; i < tree.length; i++) {\n        if (tree[i] && typeof tree[i] !== 'string') {\n          markStaticNode(tree[i], (key + \"_\" + i), isOnce);\n        }\n      }\n    } else {\n      markStaticNode(tree, key, isOnce);\n    }\n  }\n\n  function markStaticNode (node, key, isOnce) {\n    node.isStatic = true;\n    node.key = key;\n    node.isOnce = isOnce;\n  }\n\n  // filter resolution helper\n  Vue.prototype._f = function resolveFilter (id) {\n    return resolveAsset(this.$options, 'filters', id, true) || identity\n  };\n\n  // render v-for\n  Vue.prototype._l = function renderList (\n    val,\n    render\n  ) {\n    var ret, i, l, keys, key;\n    if (Array.isArray(val) || typeof val === 'string') {\n      ret = new Array(val.length);\n      for (i = 0, l = val.length; i < l; i++) {\n        ret[i] = render(val[i], i);\n      }\n    } else if (typeof val === 'number') {\n      ret = new Array(val);\n      for (i = 0; i < val; i++) {\n        ret[i] = render(i + 1, i);\n      }\n    } else if (isObject(val)) {\n      keys = Object.keys(val);\n      ret = new Array(keys.length);\n      for (i = 0, l = keys.length; i < l; i++) {\n        key = keys[i];\n        ret[i] = render(val[key], key, i);\n      }\n    }\n    return ret\n  };\n\n  // renderSlot\n  Vue.prototype._t = function (\n    name,\n    fallback,\n    props,\n    bindObject\n  ) {\n    var scopedSlotFn = this.$scopedSlots[name];\n    if (scopedSlotFn) { // scoped slot\n      props = props || {};\n      if (bindObject) {\n        extend(props, bindObject);\n      }\n      return scopedSlotFn(props) || fallback\n    } else {\n      var slotNodes = this.$slots[name];\n      // warn duplicate slot usage\n      if (slotNodes && process.env.NODE_ENV !== 'production') {\n        slotNodes._rendered && warn(\n          \"Duplicate presence of slot \\\"\" + name + \"\\\" found in the same render tree \" +\n          \"- this will likely cause render errors.\",\n          this\n        );\n        slotNodes._rendered = true;\n      }\n      return slotNodes || fallback\n    }\n  };\n\n  // apply v-bind object\n  Vue.prototype._b = function bindProps (\n    data,\n    tag,\n    value,\n    asProp\n  ) {\n    if (value) {\n      if (!isObject(value)) {\n        process.env.NODE_ENV !== 'production' && warn(\n          'v-bind without argument expects an Object or Array value',\n          this\n        );\n      } else {\n        if (Array.isArray(value)) {\n          value = toObject(value);\n        }\n        for (var key in value) {\n          if (key === 'class' || key === 'style') {\n            data[key] = value[key];\n          } else {\n            var type = data.attrs && data.attrs.type;\n            var hash = asProp || config.mustUseProp(tag, type, key)\n              ? data.domProps || (data.domProps = {})\n              : data.attrs || (data.attrs = {});\n            hash[key] = value[key];\n          }\n        }\n      }\n    }\n    return data\n  };\n\n  // check v-on keyCodes\n  Vue.prototype._k = function checkKeyCodes (\n    eventKeyCode,\n    key,\n    builtInAlias\n  ) {\n    var keyCodes = config.keyCodes[key] || builtInAlias;\n    if (Array.isArray(keyCodes)) {\n      return keyCodes.indexOf(eventKeyCode) === -1\n    } else {\n      return keyCodes !== eventKeyCode\n    }\n  };\n}\n\nfunction resolveSlots (\n  children,\n  context\n) {\n  var slots = {};\n  if (!children) {\n    return slots\n  }\n  var defaultSlot = [];\n  var name, child;\n  for (var i = 0, l = children.length; i < l; i++) {\n    child = children[i];\n    // named slots should only be respected if the vnode was rendered in the\n    // same context.\n    if ((child.context === context || child.functionalContext === context) &&\n        child.data && (name = child.data.slot)) {\n      var slot = (slots[name] || (slots[name] = []));\n      if (child.tag === 'template') {\n        slot.push.apply(slot, child.children);\n      } else {\n        slot.push(child);\n      }\n    } else {\n      defaultSlot.push(child);\n    }\n  }\n  // ignore single whitespace\n  if (defaultSlot.length && !(\n    defaultSlot.length === 1 &&\n    (defaultSlot[0].text === ' ' || defaultSlot[0].isComment)\n  )) {\n    slots.default = defaultSlot;\n  }\n  return slots\n}\n\n/*  */\n\nfunction initEvents (vm) {\n  vm._events = Object.create(null);\n  vm._hasHookEvent = false;\n  // init parent attached events\n  var listeners = vm.$options._parentListeners;\n  if (listeners) {\n    updateComponentListeners(vm, listeners);\n  }\n}\n\nvar target;\n\nfunction add$1 (event, fn, once) {\n  if (once) {\n    target.$once(event, fn);\n  } else {\n    target.$on(event, fn);\n  }\n}\n\nfunction remove$2 (event, fn) {\n  target.$off(event, fn);\n}\n\nfunction updateComponentListeners (\n  vm,\n  listeners,\n  oldListeners\n) {\n  target = vm;\n  updateListeners(listeners, oldListeners || {}, add$1, remove$2, vm);\n}\n\nfunction eventsMixin (Vue) {\n  var hookRE = /^hook:/;\n  Vue.prototype.$on = function (event, fn) {\n    var vm = this;(vm._events[event] || (vm._events[event] = [])).push(fn);\n    // optimize hook:event cost by using a boolean flag marked at registration\n    // instead of a hash lookup\n    if (hookRE.test(event)) {\n      vm._hasHookEvent = true;\n    }\n    return vm\n  };\n\n  Vue.prototype.$once = function (event, fn) {\n    var vm = this;\n    function on () {\n      vm.$off(event, on);\n      fn.apply(vm, arguments);\n    }\n    on.fn = fn;\n    vm.$on(event, on);\n    return vm\n  };\n\n  Vue.prototype.$off = function (event, fn) {\n    var vm = this;\n    // all\n    if (!arguments.length) {\n      vm._events = Object.create(null);\n      return vm\n    }\n    // specific event\n    var cbs = vm._events[event];\n    if (!cbs) {\n      return vm\n    }\n    if (arguments.length === 1) {\n      vm._events[event] = null;\n      return vm\n    }\n    // specific handler\n    var cb;\n    var i = cbs.length;\n    while (i--) {\n      cb = cbs[i];\n      if (cb === fn || cb.fn === fn) {\n        cbs.splice(i, 1);\n        break\n      }\n    }\n    return vm\n  };\n\n  Vue.prototype.$emit = function (event) {\n    var vm = this;\n    var cbs = vm._events[event];\n    if (cbs) {\n      cbs = cbs.length > 1 ? toArray(cbs) : cbs;\n      var args = toArray(arguments, 1);\n      for (var i = 0, l = cbs.length; i < l; i++) {\n        cbs[i].apply(vm, args);\n      }\n    }\n    return vm\n  };\n}\n\n/*  */\n\nvar activeInstance = null;\n\nfunction initLifecycle (vm) {\n  var options = vm.$options;\n\n  // locate first non-abstract parent\n  var parent = options.parent;\n  if (parent && !options.abstract) {\n    while (parent.$options.abstract && parent.$parent) {\n      parent = parent.$parent;\n    }\n    parent.$children.push(vm);\n  }\n\n  vm.$parent = parent;\n  vm.$root = parent ? parent.$root : vm;\n\n  vm.$children = [];\n  vm.$refs = {};\n\n  vm._watcher = null;\n  vm._inactive = false;\n  vm._isMounted = false;\n  vm._isDestroyed = false;\n  vm._isBeingDestroyed = false;\n}\n\nfunction lifecycleMixin (Vue) {\n  Vue.prototype._mount = function (\n    el,\n    hydrating\n  ) {\n    var vm = this;\n    vm.$el = el;\n    if (!vm.$options.render) {\n      vm.$options.render = createEmptyVNode;\n      if (process.env.NODE_ENV !== 'production') {\n        /* istanbul ignore if */\n        if (vm.$options.template && vm.$options.template.charAt(0) !== '#') {\n          warn(\n            'You are using the runtime-only build of Vue where the template ' +\n            'option is not available. Either pre-compile the templates into ' +\n            'render functions, or use the compiler-included build.',\n            vm\n          );\n        } else {\n          warn(\n            'Failed to mount component: template or render function not defined.',\n            vm\n          );\n        }\n      }\n    }\n    callHook(vm, 'beforeMount');\n    vm._watcher = new Watcher(vm, function updateComponent () {\n      vm._update(vm._render(), hydrating);\n    }, noop);\n    hydrating = false;\n    // manually mounted instance, call mounted on self\n    // mounted is called for render-created child components in its inserted hook\n    if (vm.$vnode == null) {\n      vm._isMounted = true;\n      callHook(vm, 'mounted');\n    }\n    return vm\n  };\n\n  Vue.prototype._update = function (vnode, hydrating) {\n    var vm = this;\n    if (vm._isMounted) {\n      callHook(vm, 'beforeUpdate');\n    }\n    var prevEl = vm.$el;\n    var prevVnode = vm._vnode;\n    var prevActiveInstance = activeInstance;\n    activeInstance = vm;\n    vm._vnode = vnode;\n    // Vue.prototype.__patch__ is injected in entry points\n    // based on the rendering backend used.\n    if (!prevVnode) {\n      // initial render\n      vm.$el = vm.__patch__(\n        vm.$el, vnode, hydrating, false /* removeOnly */,\n        vm.$options._parentElm,\n        vm.$options._refElm\n      );\n    } else {\n      // updates\n      vm.$el = vm.__patch__(prevVnode, vnode);\n    }\n    activeInstance = prevActiveInstance;\n    // update __vue__ reference\n    if (prevEl) {\n      prevEl.__vue__ = null;\n    }\n    if (vm.$el) {\n      vm.$el.__vue__ = vm;\n    }\n    // if parent is an HOC, update its $el as well\n    if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {\n      vm.$parent.$el = vm.$el;\n    }\n    // updated hook is called by the scheduler to ensure that children are\n    // updated in a parent's updated hook.\n  };\n\n  Vue.prototype._updateFromParent = function (\n    propsData,\n    listeners,\n    parentVnode,\n    renderChildren\n  ) {\n    var vm = this;\n    var hasChildren = !!(vm.$options._renderChildren || renderChildren);\n    vm.$options._parentVnode = parentVnode;\n    vm.$vnode = parentVnode; // update vm's placeholder node without re-render\n    if (vm._vnode) { // update child tree's parent\n      vm._vnode.parent = parentVnode;\n    }\n    vm.$options._renderChildren = renderChildren;\n    // update props\n    if (propsData && vm.$options.props) {\n      observerState.shouldConvert = false;\n      if (process.env.NODE_ENV !== 'production') {\n        observerState.isSettingProps = true;\n      }\n      var propKeys = vm.$options._propKeys || [];\n      for (var i = 0; i < propKeys.length; i++) {\n        var key = propKeys[i];\n        vm[key] = validateProp(key, vm.$options.props, propsData, vm);\n      }\n      observerState.shouldConvert = true;\n      if (process.env.NODE_ENV !== 'production') {\n        observerState.isSettingProps = false;\n      }\n      vm.$options.propsData = propsData;\n    }\n    // update listeners\n    if (listeners) {\n      var oldListeners = vm.$options._parentListeners;\n      vm.$options._parentListeners = listeners;\n      updateComponentListeners(vm, listeners, oldListeners);\n    }\n    // resolve slots + force update if has children\n    if (hasChildren) {\n      vm.$slots = resolveSlots(renderChildren, parentVnode.context);\n      vm.$forceUpdate();\n    }\n  };\n\n  Vue.prototype.$forceUpdate = function () {\n    var vm = this;\n    if (vm._watcher) {\n      vm._watcher.update();\n    }\n  };\n\n  Vue.prototype.$destroy = function () {\n    var vm = this;\n    if (vm._isBeingDestroyed) {\n      return\n    }\n    callHook(vm, 'beforeDestroy');\n    vm._isBeingDestroyed = true;\n    // remove self from parent\n    var parent = vm.$parent;\n    if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {\n      remove$1(parent.$children, vm);\n    }\n    // teardown watchers\n    if (vm._watcher) {\n      vm._watcher.teardown();\n    }\n    var i = vm._watchers.length;\n    while (i--) {\n      vm._watchers[i].teardown();\n    }\n    // remove reference from data ob\n    // frozen object may not have observer.\n    if (vm._data.__ob__) {\n      vm._data.__ob__.vmCount--;\n    }\n    // call the last hook...\n    vm._isDestroyed = true;\n    callHook(vm, 'destroyed');\n    // turn off all instance listeners.\n    vm.$off();\n    // remove __vue__ reference\n    if (vm.$el) {\n      vm.$el.__vue__ = null;\n    }\n    // invoke destroy hooks on current rendered tree\n    vm.__patch__(vm._vnode, null);\n  };\n}\n\nfunction callHook (vm, hook) {\n  var handlers = vm.$options[hook];\n  if (handlers) {\n    for (var i = 0, j = handlers.length; i < j; i++) {\n      handlers[i].call(vm);\n    }\n  }\n  if (vm._hasHookEvent) {\n    vm.$emit('hook:' + hook);\n  }\n}\n\n/*  */\n\n\nvar queue = [];\nvar has$1 = {};\nvar circular = {};\nvar waiting = false;\nvar flushing = false;\nvar index = 0;\n\n/**\n * Reset the scheduler's state.\n */\nfunction resetSchedulerState () {\n  queue.length = 0;\n  has$1 = {};\n  if (process.env.NODE_ENV !== 'production') {\n    circular = {};\n  }\n  waiting = flushing = false;\n}\n\n/**\n * Flush both queues and run the watchers.\n */\nfunction flushSchedulerQueue () {\n  flushing = true;\n  var watcher, id, vm;\n\n  // Sort queue before flush.\n  // This ensures that:\n  // 1. Components are updated from parent to child. (because parent is always\n  //    created before the child)\n  // 2. A component's user watchers are run before its render watcher (because\n  //    user watchers are created before the render watcher)\n  // 3. If a component is destroyed during a parent component's watcher run,\n  //    its watchers can be skipped.\n  queue.sort(function (a, b) { return a.id - b.id; });\n\n  // do not cache length because more watchers might be pushed\n  // as we run existing watchers\n  for (index = 0; index < queue.length; index++) {\n    watcher = queue[index];\n    id = watcher.id;\n    has$1[id] = null;\n    watcher.run();\n    // in dev build, check and stop circular updates.\n    if (process.env.NODE_ENV !== 'production' && has$1[id] != null) {\n      circular[id] = (circular[id] || 0) + 1;\n      if (circular[id] > config._maxUpdateCount) {\n        warn(\n          'You may have an infinite update loop ' + (\n            watcher.user\n              ? (\"in watcher with expression \\\"\" + (watcher.expression) + \"\\\"\")\n              : \"in a component render function.\"\n          ),\n          watcher.vm\n        );\n        break\n      }\n    }\n  }\n\n  // call updated hooks\n  index = queue.length;\n  while (index--) {\n    watcher = queue[index];\n    vm = watcher.vm;\n    if (vm._watcher === watcher && vm._isMounted) {\n      callHook(vm, 'updated');\n    }\n  }\n\n  // devtool hook\n  /* istanbul ignore if */\n  if (devtools && config.devtools) {\n    devtools.emit('flush');\n  }\n\n  resetSchedulerState();\n}\n\n/**\n * Push a watcher into the watcher queue.\n * Jobs with duplicate IDs will be skipped unless it's\n * pushed when the queue is being flushed.\n */\nfunction queueWatcher (watcher) {\n  var id = watcher.id;\n  if (has$1[id] == null) {\n    has$1[id] = true;\n    if (!flushing) {\n      queue.push(watcher);\n    } else {\n      // if already flushing, splice the watcher based on its id\n      // if already past its id, it will be run next immediately.\n      var i = queue.length - 1;\n      while (i >= 0 && queue[i].id > watcher.id) {\n        i--;\n      }\n      queue.splice(Math.max(i, index) + 1, 0, watcher);\n    }\n    // queue the flush\n    if (!waiting) {\n      waiting = true;\n      nextTick(flushSchedulerQueue);\n    }\n  }\n}\n\n/*  */\n\nvar uid$2 = 0;\n\n/**\n * A watcher parses an expression, collects dependencies,\n * and fires callback when the expression value changes.\n * This is used for both the $watch() api and directives.\n */\nvar Watcher = function Watcher (\n  vm,\n  expOrFn,\n  cb,\n  options\n) {\n  this.vm = vm;\n  vm._watchers.push(this);\n  // options\n  if (options) {\n    this.deep = !!options.deep;\n    this.user = !!options.user;\n    this.lazy = !!options.lazy;\n    this.sync = !!options.sync;\n  } else {\n    this.deep = this.user = this.lazy = this.sync = false;\n  }\n  this.cb = cb;\n  this.id = ++uid$2; // uid for batching\n  this.active = true;\n  this.dirty = this.lazy; // for lazy watchers\n  this.deps = [];\n  this.newDeps = [];\n  this.depIds = new _Set();\n  this.newDepIds = new _Set();\n  this.expression = process.env.NODE_ENV !== 'production'\n    ? expOrFn.toString()\n    : '';\n  // parse expression for getter\n  if (typeof expOrFn === 'function') {\n    this.getter = expOrFn;\n  } else {\n    this.getter = parsePath(expOrFn);\n    if (!this.getter) {\n      this.getter = function () {};\n      process.env.NODE_ENV !== 'production' && warn(\n        \"Failed watching path: \\\"\" + expOrFn + \"\\\" \" +\n        'Watcher only accepts simple dot-delimited paths. ' +\n        'For full control, use a function instead.',\n        vm\n      );\n    }\n  }\n  this.value = this.lazy\n    ? undefined\n    : this.get();\n};\n\n/**\n * Evaluate the getter, and re-collect dependencies.\n */\nWatcher.prototype.get = function get () {\n  pushTarget(this);\n  var value = this.getter.call(this.vm, this.vm);\n  // \"touch\" every property so they are all tracked as\n  // dependencies for deep watching\n  if (this.deep) {\n    traverse(value);\n  }\n  popTarget();\n  this.cleanupDeps();\n  return value\n};\n\n/**\n * Add a dependency to this directive.\n */\nWatcher.prototype.addDep = function addDep (dep) {\n  var id = dep.id;\n  if (!this.newDepIds.has(id)) {\n    this.newDepIds.add(id);\n    this.newDeps.push(dep);\n    if (!this.depIds.has(id)) {\n      dep.addSub(this);\n    }\n  }\n};\n\n/**\n * Clean up for dependency collection.\n */\nWatcher.prototype.cleanupDeps = function cleanupDeps () {\n    var this$1 = this;\n\n  var i = this.deps.length;\n  while (i--) {\n    var dep = this$1.deps[i];\n    if (!this$1.newDepIds.has(dep.id)) {\n      dep.removeSub(this$1);\n    }\n  }\n  var tmp = this.depIds;\n  this.depIds = this.newDepIds;\n  this.newDepIds = tmp;\n  this.newDepIds.clear();\n  tmp = this.deps;\n  this.deps = this.newDeps;\n  this.newDeps = tmp;\n  this.newDeps.length = 0;\n};\n\n/**\n * Subscriber interface.\n * Will be called when a dependency changes.\n */\nWatcher.prototype.update = function update () {\n  /* istanbul ignore else */\n  if (this.lazy) {\n    this.dirty = true;\n  } else if (this.sync) {\n    this.run();\n  } else {\n    queueWatcher(this);\n  }\n};\n\n/**\n * Scheduler job interface.\n * Will be called by the scheduler.\n */\nWatcher.prototype.run = function run () {\n  if (this.active) {\n    var value = this.get();\n    if (\n      value !== this.value ||\n      // Deep watchers and watchers on Object/Arrays should fire even\n      // when the value is the same, because the value may\n      // have mutated.\n      isObject(value) ||\n      this.deep\n    ) {\n      // set new value\n      var oldValue = this.value;\n      this.value = value;\n      if (this.user) {\n        try {\n          this.cb.call(this.vm, value, oldValue);\n        } catch (e) {\n          /* istanbul ignore else */\n          if (config.errorHandler) {\n            config.errorHandler.call(null, e, this.vm);\n          } else {\n            process.env.NODE_ENV !== 'production' && warn(\n              (\"Error in watcher \\\"\" + (this.expression) + \"\\\"\"),\n              this.vm\n            );\n            throw e\n          }\n        }\n      } else {\n        this.cb.call(this.vm, value, oldValue);\n      }\n    }\n  }\n};\n\n/**\n * Evaluate the value of the watcher.\n * This only gets called for lazy watchers.\n */\nWatcher.prototype.evaluate = function evaluate () {\n  this.value = this.get();\n  this.dirty = false;\n};\n\n/**\n * Depend on all deps collected by this watcher.\n */\nWatcher.prototype.depend = function depend () {\n    var this$1 = this;\n\n  var i = this.deps.length;\n  while (i--) {\n    this$1.deps[i].depend();\n  }\n};\n\n/**\n * Remove self from all dependencies' subscriber list.\n */\nWatcher.prototype.teardown = function teardown () {\n    var this$1 = this;\n\n  if (this.active) {\n    // remove self from vm's watcher list\n    // this is a somewhat expensive operation so we skip it\n    // if the vm is being destroyed.\n    if (!this.vm._isBeingDestroyed) {\n      remove$1(this.vm._watchers, this);\n    }\n    var i = this.deps.length;\n    while (i--) {\n      this$1.deps[i].removeSub(this$1);\n    }\n    this.active = false;\n  }\n};\n\n/**\n * Recursively traverse an object to evoke all converted\n * getters, so that every nested property inside the object\n * is collected as a \"deep\" dependency.\n */\nvar seenObjects = new _Set();\nfunction traverse (val) {\n  seenObjects.clear();\n  _traverse(val, seenObjects);\n}\n\nfunction _traverse (val, seen) {\n  var i, keys;\n  var isA = Array.isArray(val);\n  if ((!isA && !isObject(val)) || !Object.isExtensible(val)) {\n    return\n  }\n  if (val.__ob__) {\n    var depId = val.__ob__.dep.id;\n    if (seen.has(depId)) {\n      return\n    }\n    seen.add(depId);\n  }\n  if (isA) {\n    i = val.length;\n    while (i--) { _traverse(val[i], seen); }\n  } else {\n    keys = Object.keys(val);\n    i = keys.length;\n    while (i--) { _traverse(val[keys[i]], seen); }\n  }\n}\n\n/*  */\n\nfunction initState (vm) {\n  vm._watchers = [];\n  var opts = vm.$options;\n  if (opts.props) { initProps(vm, opts.props); }\n  if (opts.methods) { initMethods(vm, opts.methods); }\n  if (opts.data) {\n    initData(vm);\n  } else {\n    observe(vm._data = {}, true /* asRootData */);\n  }\n  if (opts.computed) { initComputed(vm, opts.computed); }\n  if (opts.watch) { initWatch(vm, opts.watch); }\n}\n\nvar isReservedProp = { key: 1, ref: 1, slot: 1 };\n\nfunction initProps (vm, props) {\n  var propsData = vm.$options.propsData || {};\n  var keys = vm.$options._propKeys = Object.keys(props);\n  var isRoot = !vm.$parent;\n  // root instance props should be converted\n  observerState.shouldConvert = isRoot;\n  var loop = function ( i ) {\n    var key = keys[i];\n    /* istanbul ignore else */\n    if (process.env.NODE_ENV !== 'production') {\n      if (isReservedProp[key]) {\n        warn(\n          (\"\\\"\" + key + \"\\\" is a reserved attribute and cannot be used as component prop.\"),\n          vm\n        );\n      }\n      defineReactive$$1(vm, key, validateProp(key, props, propsData, vm), function () {\n        if (vm.$parent && !observerState.isSettingProps) {\n          warn(\n            \"Avoid mutating a prop directly since the value will be \" +\n            \"overwritten whenever the parent component re-renders. \" +\n            \"Instead, use a data or computed property based on the prop's \" +\n            \"value. Prop being mutated: \\\"\" + key + \"\\\"\",\n            vm\n          );\n        }\n      });\n    } else {\n      defineReactive$$1(vm, key, validateProp(key, props, propsData, vm));\n    }\n  };\n\n  for (var i = 0; i < keys.length; i++) loop( i );\n  observerState.shouldConvert = true;\n}\n\nfunction initData (vm) {\n  var data = vm.$options.data;\n  data = vm._data = typeof data === 'function'\n    ? data.call(vm)\n    : data || {};\n  if (!isPlainObject(data)) {\n    data = {};\n    process.env.NODE_ENV !== 'production' && warn(\n      'data functions should return an object:\\n' +\n      'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',\n      vm\n    );\n  }\n  // proxy data on instance\n  var keys = Object.keys(data);\n  var props = vm.$options.props;\n  var i = keys.length;\n  while (i--) {\n    if (props && hasOwn(props, keys[i])) {\n      process.env.NODE_ENV !== 'production' && warn(\n        \"The data property \\\"\" + (keys[i]) + \"\\\" is already declared as a prop. \" +\n        \"Use prop default value instead.\",\n        vm\n      );\n    } else {\n      proxy(vm, keys[i]);\n    }\n  }\n  // observe data\n  observe(data, true /* asRootData */);\n}\n\nvar computedSharedDefinition = {\n  enumerable: true,\n  configurable: true,\n  get: noop,\n  set: noop\n};\n\nfunction initComputed (vm, computed) {\n  for (var key in computed) {\n    /* istanbul ignore if */\n    if (process.env.NODE_ENV !== 'production' && key in vm) {\n      warn(\n        \"existing instance property \\\"\" + key + \"\\\" will be \" +\n        \"overwritten by a computed property with the same name.\",\n        vm\n      );\n    }\n    var userDef = computed[key];\n    if (typeof userDef === 'function') {\n      computedSharedDefinition.get = makeComputedGetter(userDef, vm);\n      computedSharedDefinition.set = noop;\n    } else {\n      computedSharedDefinition.get = userDef.get\n        ? userDef.cache !== false\n          ? makeComputedGetter(userDef.get, vm)\n          : bind$1(userDef.get, vm)\n        : noop;\n      computedSharedDefinition.set = userDef.set\n        ? bind$1(userDef.set, vm)\n        : noop;\n    }\n    Object.defineProperty(vm, key, computedSharedDefinition);\n  }\n}\n\nfunction makeComputedGetter (getter, owner) {\n  var watcher = new Watcher(owner, getter, noop, {\n    lazy: true\n  });\n  return function computedGetter () {\n    if (watcher.dirty) {\n      watcher.evaluate();\n    }\n    if (Dep.target) {\n      watcher.depend();\n    }\n    return watcher.value\n  }\n}\n\nfunction initMethods (vm, methods) {\n  for (var key in methods) {\n    vm[key] = methods[key] == null ? noop : bind$1(methods[key], vm);\n    if (process.env.NODE_ENV !== 'production' && methods[key] == null) {\n      warn(\n        \"method \\\"\" + key + \"\\\" has an undefined value in the component definition. \" +\n        \"Did you reference the function correctly?\",\n        vm\n      );\n    }\n  }\n}\n\nfunction initWatch (vm, watch) {\n  for (var key in watch) {\n    var handler = watch[key];\n    if (Array.isArray(handler)) {\n      for (var i = 0; i < handler.length; i++) {\n        createWatcher(vm, key, handler[i]);\n      }\n    } else {\n      createWatcher(vm, key, handler);\n    }\n  }\n}\n\nfunction createWatcher (vm, key, handler) {\n  var options;\n  if (isPlainObject(handler)) {\n    options = handler;\n    handler = handler.handler;\n  }\n  if (typeof handler === 'string') {\n    handler = vm[handler];\n  }\n  vm.$watch(key, handler, options);\n}\n\nfunction stateMixin (Vue) {\n  // flow somehow has problems with directly declared definition object\n  // when using Object.defineProperty, so we have to procedurally build up\n  // the object here.\n  var dataDef = {};\n  dataDef.get = function () {\n    return this._data\n  };\n  if (process.env.NODE_ENV !== 'production') {\n    dataDef.set = function (newData) {\n      warn(\n        'Avoid replacing instance root $data. ' +\n        'Use nested data properties instead.',\n        this\n      );\n    };\n  }\n  Object.defineProperty(Vue.prototype, '$data', dataDef);\n\n  Vue.prototype.$set = set$1;\n  Vue.prototype.$delete = del;\n\n  Vue.prototype.$watch = function (\n    expOrFn,\n    cb,\n    options\n  ) {\n    var vm = this;\n    options = options || {};\n    options.user = true;\n    var watcher = new Watcher(vm, expOrFn, cb, options);\n    if (options.immediate) {\n      cb.call(vm, watcher.value);\n    }\n    return function unwatchFn () {\n      watcher.teardown();\n    }\n  };\n}\n\nfunction proxy (vm, key) {\n  if (!isReserved(key)) {\n    Object.defineProperty(vm, key, {\n      configurable: true,\n      enumerable: true,\n      get: function proxyGetter () {\n        return vm._data[key]\n      },\n      set: function proxySetter (val) {\n        vm._data[key] = val;\n      }\n    });\n  }\n}\n\n/*  */\n\nvar uid = 0;\n\nfunction initMixin (Vue) {\n  Vue.prototype._init = function (options) {\n    var vm = this;\n    // a uid\n    vm._uid = uid++;\n    // a flag to avoid this being observed\n    vm._isVue = true;\n    // merge options\n    if (options && options._isComponent) {\n      // optimize internal component instantiation\n      // since dynamic options merging is pretty slow, and none of the\n      // internal component options needs special treatment.\n      initInternalComponent(vm, options);\n    } else {\n      vm.$options = mergeOptions(\n        resolveConstructorOptions(vm.constructor),\n        options || {},\n        vm\n      );\n    }\n    /* istanbul ignore else */\n    if (process.env.NODE_ENV !== 'production') {\n      initProxy(vm);\n    } else {\n      vm._renderProxy = vm;\n    }\n    // expose real self\n    vm._self = vm;\n    initLifecycle(vm);\n    initEvents(vm);\n    initRender(vm);\n    callHook(vm, 'beforeCreate');\n    initState(vm);\n    callHook(vm, 'created');\n    if (vm.$options.el) {\n      vm.$mount(vm.$options.el);\n    }\n  };\n}\n\nfunction initInternalComponent (vm, options) {\n  var opts = vm.$options = Object.create(vm.constructor.options);\n  // doing this because it's faster than dynamic enumeration.\n  opts.parent = options.parent;\n  opts.propsData = options.propsData;\n  opts._parentVnode = options._parentVnode;\n  opts._parentListeners = options._parentListeners;\n  opts._renderChildren = options._renderChildren;\n  opts._componentTag = options._componentTag;\n  opts._parentElm = options._parentElm;\n  opts._refElm = options._refElm;\n  if (options.render) {\n    opts.render = options.render;\n    opts.staticRenderFns = options.staticRenderFns;\n  }\n}\n\nfunction resolveConstructorOptions (Ctor) {\n  var options = Ctor.options;\n  if (Ctor.super) {\n    var superOptions = Ctor.super.options;\n    var cachedSuperOptions = Ctor.superOptions;\n    var extendOptions = Ctor.extendOptions;\n    if (superOptions !== cachedSuperOptions) {\n      // super option changed\n      Ctor.superOptions = superOptions;\n      extendOptions.render = options.render;\n      extendOptions.staticRenderFns = options.staticRenderFns;\n      extendOptions._scopeId = options._scopeId;\n      options = Ctor.options = mergeOptions(superOptions, extendOptions);\n      if (options.name) {\n        options.components[options.name] = Ctor;\n      }\n    }\n  }\n  return options\n}\n\nfunction Vue$3 (options) {\n  if (process.env.NODE_ENV !== 'production' &&\n    !(this instanceof Vue$3)) {\n    warn('Vue is a constructor and should be called with the `new` keyword');\n  }\n  this._init(options);\n}\n\ninitMixin(Vue$3);\nstateMixin(Vue$3);\neventsMixin(Vue$3);\nlifecycleMixin(Vue$3);\nrenderMixin(Vue$3);\n\n/*  */\n\nfunction initUse (Vue) {\n  Vue.use = function (plugin) {\n    /* istanbul ignore if */\n    if (plugin.installed) {\n      return\n    }\n    // additional parameters\n    var args = toArray(arguments, 1);\n    args.unshift(this);\n    if (typeof plugin.install === 'function') {\n      plugin.install.apply(plugin, args);\n    } else {\n      plugin.apply(null, args);\n    }\n    plugin.installed = true;\n    return this\n  };\n}\n\n/*  */\n\nfunction initMixin$1 (Vue) {\n  Vue.mixin = function (mixin) {\n    this.options = mergeOptions(this.options, mixin);\n  };\n}\n\n/*  */\n\nfunction initExtend (Vue) {\n  /**\n   * Each instance constructor, including Vue, has a unique\n   * cid. This enables us to create wrapped \"child\n   * constructors\" for prototypal inheritance and cache them.\n   */\n  Vue.cid = 0;\n  var cid = 1;\n\n  /**\n   * Class inheritance\n   */\n  Vue.extend = function (extendOptions) {\n    extendOptions = extendOptions || {};\n    var Super = this;\n    var SuperId = Super.cid;\n    var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});\n    if (cachedCtors[SuperId]) {\n      return cachedCtors[SuperId]\n    }\n    var name = extendOptions.name || Super.options.name;\n    if (process.env.NODE_ENV !== 'production') {\n      if (!/^[a-zA-Z][\\w-]*$/.test(name)) {\n        warn(\n          'Invalid component name: \"' + name + '\". Component names ' +\n          'can only contain alphanumeric characters and the hyphen, ' +\n          'and must start with a letter.'\n        );\n      }\n    }\n    var Sub = function VueComponent (options) {\n      this._init(options);\n    };\n    Sub.prototype = Object.create(Super.prototype);\n    Sub.prototype.constructor = Sub;\n    Sub.cid = cid++;\n    Sub.options = mergeOptions(\n      Super.options,\n      extendOptions\n    );\n    Sub['super'] = Super;\n    // allow further extension/mixin/plugin usage\n    Sub.extend = Super.extend;\n    Sub.mixin = Super.mixin;\n    Sub.use = Super.use;\n    // create asset registers, so extended classes\n    // can have their private assets too.\n    config._assetTypes.forEach(function (type) {\n      Sub[type] = Super[type];\n    });\n    // enable recursive self-lookup\n    if (name) {\n      Sub.options.components[name] = Sub;\n    }\n    // keep a reference to the super options at extension time.\n    // later at instantiation we can check if Super's options have\n    // been updated.\n    Sub.superOptions = Super.options;\n    Sub.extendOptions = extendOptions;\n    // cache constructor\n    cachedCtors[SuperId] = Sub;\n    return Sub\n  };\n}\n\n/*  */\n\nfunction initAssetRegisters (Vue) {\n  /**\n   * Create asset registration methods.\n   */\n  config._assetTypes.forEach(function (type) {\n    Vue[type] = function (\n      id,\n      definition\n    ) {\n      if (!definition) {\n        return this.options[type + 's'][id]\n      } else {\n        /* istanbul ignore if */\n        if (process.env.NODE_ENV !== 'production') {\n          if (type === 'component' && config.isReservedTag(id)) {\n            warn(\n              'Do not use built-in or reserved HTML elements as component ' +\n              'id: ' + id\n            );\n          }\n        }\n        if (type === 'component' && isPlainObject(definition)) {\n          definition.name = definition.name || id;\n          definition = this.options._base.extend(definition);\n        }\n        if (type === 'directive' && typeof definition === 'function') {\n          definition = { bind: definition, update: definition };\n        }\n        this.options[type + 's'][id] = definition;\n        return definition\n      }\n    };\n  });\n}\n\n/*  */\n\nvar patternTypes = [String, RegExp];\n\nfunction getComponentName (opts) {\n  return opts && (opts.Ctor.options.name || opts.tag)\n}\n\nfunction matches (pattern, name) {\n  if (typeof pattern === 'string') {\n    return pattern.split(',').indexOf(name) > -1\n  } else {\n    return pattern.test(name)\n  }\n}\n\nfunction pruneCache (cache, filter) {\n  for (var key in cache) {\n    var cachedNode = cache[key];\n    if (cachedNode) {\n      var name = getComponentName(cachedNode.componentOptions);\n      if (name && !filter(name)) {\n        pruneCacheEntry(cachedNode);\n        cache[key] = null;\n      }\n    }\n  }\n}\n\nfunction pruneCacheEntry (vnode) {\n  if (vnode) {\n    if (!vnode.componentInstance._inactive) {\n      callHook(vnode.componentInstance, 'deactivated');\n    }\n    vnode.componentInstance.$destroy();\n  }\n}\n\nvar KeepAlive = {\n  name: 'keep-alive',\n  abstract: true,\n\n  props: {\n    include: patternTypes,\n    exclude: patternTypes\n  },\n\n  created: function created () {\n    this.cache = Object.create(null);\n  },\n\n  destroyed: function destroyed () {\n    var this$1 = this;\n\n    for (var key in this.cache) {\n      pruneCacheEntry(this$1.cache[key]);\n    }\n  },\n\n  watch: {\n    include: function include (val) {\n      pruneCache(this.cache, function (name) { return matches(val, name); });\n    },\n    exclude: function exclude (val) {\n      pruneCache(this.cache, function (name) { return !matches(val, name); });\n    }\n  },\n\n  render: function render () {\n    var vnode = getFirstComponentChild(this.$slots.default);\n    var componentOptions = vnode && vnode.componentOptions;\n    if (componentOptions) {\n      // check pattern\n      var name = getComponentName(componentOptions);\n      if (name && (\n        (this.include && !matches(this.include, name)) ||\n        (this.exclude && matches(this.exclude, name))\n      )) {\n        return vnode\n      }\n      var key = vnode.key == null\n        // same constructor may get registered as different local components\n        // so cid alone is not enough (#3269)\n        ? componentOptions.Ctor.cid + (componentOptions.tag ? (\"::\" + (componentOptions.tag)) : '')\n        : vnode.key;\n      if (this.cache[key]) {\n        vnode.componentInstance = this.cache[key].componentInstance;\n      } else {\n        this.cache[key] = vnode;\n      }\n      vnode.data.keepAlive = true;\n    }\n    return vnode\n  }\n};\n\nvar builtInComponents = {\n  KeepAlive: KeepAlive\n};\n\n/*  */\n\nfunction initGlobalAPI (Vue) {\n  // config\n  var configDef = {};\n  configDef.get = function () { return config; };\n  if (process.env.NODE_ENV !== 'production') {\n    configDef.set = function () {\n      warn(\n        'Do not replace the Vue.config object, set individual fields instead.'\n      );\n    };\n  }\n  Object.defineProperty(Vue, 'config', configDef);\n  Vue.util = util;\n  Vue.set = set$1;\n  Vue.delete = del;\n  Vue.nextTick = nextTick;\n\n  Vue.options = Object.create(null);\n  config._assetTypes.forEach(function (type) {\n    Vue.options[type + 's'] = Object.create(null);\n  });\n\n  // this is used to identify the \"base\" constructor to extend all plain-object\n  // components with in Weex's multi-instance scenarios.\n  Vue.options._base = Vue;\n\n  extend(Vue.options.components, builtInComponents);\n\n  initUse(Vue);\n  initMixin$1(Vue);\n  initExtend(Vue);\n  initAssetRegisters(Vue);\n}\n\ninitGlobalAPI(Vue$3);\n\nObject.defineProperty(Vue$3.prototype, '$isServer', {\n  get: isServerRendering\n});\n\nVue$3.version = '2.1.10';\n\n/*  */\n\n// attributes that should be using props for binding\nvar acceptValue = makeMap('input,textarea,option,select');\nvar mustUseProp = function (tag, type, attr) {\n  return (\n    (attr === 'value' && acceptValue(tag)) && type !== 'button' ||\n    (attr === 'selected' && tag === 'option') ||\n    (attr === 'checked' && tag === 'input') ||\n    (attr === 'muted' && tag === 'video')\n  )\n};\n\nvar isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');\n\nvar isBooleanAttr = makeMap(\n  'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +\n  'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +\n  'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +\n  'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +\n  'required,reversed,scoped,seamless,selected,sortable,translate,' +\n  'truespeed,typemustmatch,visible'\n);\n\nvar xlinkNS = 'http://www.w3.org/1999/xlink';\n\nvar isXlink = function (name) {\n  return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'\n};\n\nvar getXlinkProp = function (name) {\n  return isXlink(name) ? name.slice(6, name.length) : ''\n};\n\nvar isFalsyAttrValue = function (val) {\n  return val == null || val === false\n};\n\n/*  */\n\nfunction genClassForVnode (vnode) {\n  var data = vnode.data;\n  var parentNode = vnode;\n  var childNode = vnode;\n  while (childNode.componentInstance) {\n    childNode = childNode.componentInstance._vnode;\n    if (childNode.data) {\n      data = mergeClassData(childNode.data, data);\n    }\n  }\n  while ((parentNode = parentNode.parent)) {\n    if (parentNode.data) {\n      data = mergeClassData(data, parentNode.data);\n    }\n  }\n  return genClassFromData(data)\n}\n\nfunction mergeClassData (child, parent) {\n  return {\n    staticClass: concat(child.staticClass, parent.staticClass),\n    class: child.class\n      ? [child.class, parent.class]\n      : parent.class\n  }\n}\n\nfunction genClassFromData (data) {\n  var dynamicClass = data.class;\n  var staticClass = data.staticClass;\n  if (staticClass || dynamicClass) {\n    return concat(staticClass, stringifyClass(dynamicClass))\n  }\n  /* istanbul ignore next */\n  return ''\n}\n\nfunction concat (a, b) {\n  return a ? b ? (a + ' ' + b) : a : (b || '')\n}\n\nfunction stringifyClass (value) {\n  var res = '';\n  if (!value) {\n    return res\n  }\n  if (typeof value === 'string') {\n    return value\n  }\n  if (Array.isArray(value)) {\n    var stringified;\n    for (var i = 0, l = value.length; i < l; i++) {\n      if (value[i]) {\n        if ((stringified = stringifyClass(value[i]))) {\n          res += stringified + ' ';\n        }\n      }\n    }\n    return res.slice(0, -1)\n  }\n  if (isObject(value)) {\n    for (var key in value) {\n      if (value[key]) { res += key + ' '; }\n    }\n    return res.slice(0, -1)\n  }\n  /* istanbul ignore next */\n  return res\n}\n\n/*  */\n\nvar namespaceMap = {\n  svg: 'http://www.w3.org/2000/svg',\n  math: 'http://www.w3.org/1998/Math/MathML'\n};\n\nvar isHTMLTag = makeMap(\n  'html,body,base,head,link,meta,style,title,' +\n  'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +\n  'div,dd,dl,dt,figcaption,figure,hr,img,li,main,ol,p,pre,ul,' +\n  'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +\n  's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +\n  'embed,object,param,source,canvas,script,noscript,del,ins,' +\n  'caption,col,colgroup,table,thead,tbody,td,th,tr,' +\n  'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +\n  'output,progress,select,textarea,' +\n  'details,dialog,menu,menuitem,summary,' +\n  'content,element,shadow,template'\n);\n\n// this map is intentionally selective, only covering SVG elements that may\n// contain child elements.\nvar isSVG = makeMap(\n  'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,' +\n  'font-face,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +\n  'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',\n  true\n);\n\nvar isPreTag = function (tag) { return tag === 'pre'; };\n\nvar isReservedTag = function (tag) {\n  return isHTMLTag(tag) || isSVG(tag)\n};\n\nfunction getTagNamespace (tag) {\n  if (isSVG(tag)) {\n    return 'svg'\n  }\n  // basic support for MathML\n  // note it doesn't support other MathML elements being component roots\n  if (tag === 'math') {\n    return 'math'\n  }\n}\n\nvar unknownElementCache = Object.create(null);\nfunction isUnknownElement (tag) {\n  /* istanbul ignore if */\n  if (!inBrowser) {\n    return true\n  }\n  if (isReservedTag(tag)) {\n    return false\n  }\n  tag = tag.toLowerCase();\n  /* istanbul ignore if */\n  if (unknownElementCache[tag] != null) {\n    return unknownElementCache[tag]\n  }\n  var el = document.createElement(tag);\n  if (tag.indexOf('-') > -1) {\n    // http://stackoverflow.com/a/28210364/1070244\n    return (unknownElementCache[tag] = (\n      el.constructor === window.HTMLUnknownElement ||\n      el.constructor === window.HTMLElement\n    ))\n  } else {\n    return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))\n  }\n}\n\n/*  */\n\n/**\n * Query an element selector if it's not an element already.\n */\nfunction query (el) {\n  if (typeof el === 'string') {\n    var selector = el;\n    el = document.querySelector(el);\n    if (!el) {\n      process.env.NODE_ENV !== 'production' && warn(\n        'Cannot find element: ' + selector\n      );\n      return document.createElement('div')\n    }\n  }\n  return el\n}\n\n/*  */\n\nfunction createElement$1 (tagName, vnode) {\n  var elm = document.createElement(tagName);\n  if (tagName !== 'select') {\n    return elm\n  }\n  if (vnode.data && vnode.data.attrs && 'multiple' in vnode.data.attrs) {\n    elm.setAttribute('multiple', 'multiple');\n  }\n  return elm\n}\n\nfunction createElementNS (namespace, tagName) {\n  return document.createElementNS(namespaceMap[namespace], tagName)\n}\n\nfunction createTextNode (text) {\n  return document.createTextNode(text)\n}\n\nfunction createComment (text) {\n  return document.createComment(text)\n}\n\nfunction insertBefore (parentNode, newNode, referenceNode) {\n  parentNode.insertBefore(newNode, referenceNode);\n}\n\nfunction removeChild (node, child) {\n  node.removeChild(child);\n}\n\nfunction appendChild (node, child) {\n  node.appendChild(child);\n}\n\nfunction parentNode (node) {\n  return node.parentNode\n}\n\nfunction nextSibling (node) {\n  return node.nextSibling\n}\n\nfunction tagName (node) {\n  return node.tagName\n}\n\nfunction setTextContent (node, text) {\n  node.textContent = text;\n}\n\nfunction setAttribute (node, key, val) {\n  node.setAttribute(key, val);\n}\n\n\nvar nodeOps = Object.freeze({\n\tcreateElement: createElement$1,\n\tcreateElementNS: createElementNS,\n\tcreateTextNode: createTextNode,\n\tcreateComment: createComment,\n\tinsertBefore: insertBefore,\n\tremoveChild: removeChild,\n\tappendChild: appendChild,\n\tparentNode: parentNode,\n\tnextSibling: nextSibling,\n\ttagName: tagName,\n\tsetTextContent: setTextContent,\n\tsetAttribute: setAttribute\n});\n\n/*  */\n\nvar ref = {\n  create: function create (_, vnode) {\n    registerRef(vnode);\n  },\n  update: function update (oldVnode, vnode) {\n    if (oldVnode.data.ref !== vnode.data.ref) {\n      registerRef(oldVnode, true);\n      registerRef(vnode);\n    }\n  },\n  destroy: function destroy (vnode) {\n    registerRef(vnode, true);\n  }\n};\n\nfunction registerRef (vnode, isRemoval) {\n  var key = vnode.data.ref;\n  if (!key) { return }\n\n  var vm = vnode.context;\n  var ref = vnode.componentInstance || vnode.elm;\n  var refs = vm.$refs;\n  if (isRemoval) {\n    if (Array.isArray(refs[key])) {\n      remove$1(refs[key], ref);\n    } else if (refs[key] === ref) {\n      refs[key] = undefined;\n    }\n  } else {\n    if (vnode.data.refInFor) {\n      if (Array.isArray(refs[key]) && refs[key].indexOf(ref) < 0) {\n        refs[key].push(ref);\n      } else {\n        refs[key] = [ref];\n      }\n    } else {\n      refs[key] = ref;\n    }\n  }\n}\n\n/**\n * Virtual DOM patching algorithm based on Snabbdom by\n * Simon Friis Vindum (@paldepind)\n * Licensed under the MIT License\n * https://github.com/paldepind/snabbdom/blob/master/LICENSE\n *\n * modified by Evan You (@yyx990803)\n *\n\n/*\n * Not type-checking this because this file is perf-critical and the cost\n * of making flow understand it is not worth it.\n */\n\nvar emptyNode = new VNode('', {}, []);\n\nvar hooks$1 = ['create', 'activate', 'update', 'remove', 'destroy'];\n\nfunction isUndef (s) {\n  return s == null\n}\n\nfunction isDef (s) {\n  return s != null\n}\n\nfunction sameVnode (vnode1, vnode2) {\n  return (\n    vnode1.key === vnode2.key &&\n    vnode1.tag === vnode2.tag &&\n    vnode1.isComment === vnode2.isComment &&\n    !vnode1.data === !vnode2.data\n  )\n}\n\nfunction createKeyToOldIdx (children, beginIdx, endIdx) {\n  var i, key;\n  var map = {};\n  for (i = beginIdx; i <= endIdx; ++i) {\n    key = children[i].key;\n    if (isDef(key)) { map[key] = i; }\n  }\n  return map\n}\n\nfunction createPatchFunction (backend) {\n  var i, j;\n  var cbs = {};\n\n  var modules = backend.modules;\n  var nodeOps = backend.nodeOps;\n\n  for (i = 0; i < hooks$1.length; ++i) {\n    cbs[hooks$1[i]] = [];\n    for (j = 0; j < modules.length; ++j) {\n      if (modules[j][hooks$1[i]] !== undefined) { cbs[hooks$1[i]].push(modules[j][hooks$1[i]]); }\n    }\n  }\n\n  function emptyNodeAt (elm) {\n    return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)\n  }\n\n  function createRmCb (childElm, listeners) {\n    function remove$$1 () {\n      if (--remove$$1.listeners === 0) {\n        removeNode(childElm);\n      }\n    }\n    remove$$1.listeners = listeners;\n    return remove$$1\n  }\n\n  function removeNode (el) {\n    var parent = nodeOps.parentNode(el);\n    // element may have already been removed due to v-html / v-text\n    if (parent) {\n      nodeOps.removeChild(parent, el);\n    }\n  }\n\n  var inPre = 0;\n  function createElm (vnode, insertedVnodeQueue, parentElm, refElm, nested) {\n    vnode.isRootInsert = !nested; // for transition enter check\n    if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {\n      return\n    }\n\n    var data = vnode.data;\n    var children = vnode.children;\n    var tag = vnode.tag;\n    if (isDef(tag)) {\n      if (process.env.NODE_ENV !== 'production') {\n        if (data && data.pre) {\n          inPre++;\n        }\n        if (\n          !inPre &&\n          !vnode.ns &&\n          !(config.ignoredElements.length && config.ignoredElements.indexOf(tag) > -1) &&\n          config.isUnknownElement(tag)\n        ) {\n          warn(\n            'Unknown custom element: <' + tag + '> - did you ' +\n            'register the component correctly? For recursive components, ' +\n            'make sure to provide the \"name\" option.',\n            vnode.context\n          );\n        }\n      }\n      vnode.elm = vnode.ns\n        ? nodeOps.createElementNS(vnode.ns, tag)\n        : nodeOps.createElement(tag, vnode);\n      setScope(vnode);\n\n      /* istanbul ignore if */\n      {\n        createChildren(vnode, children, insertedVnodeQueue);\n        if (isDef(data)) {\n          invokeCreateHooks(vnode, insertedVnodeQueue);\n        }\n        insert(parentElm, vnode.elm, refElm);\n      }\n\n      if (process.env.NODE_ENV !== 'production' && data && data.pre) {\n        inPre--;\n      }\n    } else if (vnode.isComment) {\n      vnode.elm = nodeOps.createComment(vnode.text);\n      insert(parentElm, vnode.elm, refElm);\n    } else {\n      vnode.elm = nodeOps.createTextNode(vnode.text);\n      insert(parentElm, vnode.elm, refElm);\n    }\n  }\n\n  function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {\n    var i = vnode.data;\n    if (isDef(i)) {\n      var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;\n      if (isDef(i = i.hook) && isDef(i = i.init)) {\n        i(vnode, false /* hydrating */, parentElm, refElm);\n      }\n      // after calling the init hook, if the vnode is a child component\n      // it should've created a child instance and mounted it. the child\n      // component also has set the placeholder vnode's elm.\n      // in that case we can just return the element and be done.\n      if (isDef(vnode.componentInstance)) {\n        initComponent(vnode, insertedVnodeQueue);\n        if (isReactivated) {\n          reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);\n        }\n        return true\n      }\n    }\n  }\n\n  function initComponent (vnode, insertedVnodeQueue) {\n    if (vnode.data.pendingInsert) {\n      insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);\n    }\n    vnode.elm = vnode.componentInstance.$el;\n    if (isPatchable(vnode)) {\n      invokeCreateHooks(vnode, insertedVnodeQueue);\n      setScope(vnode);\n    } else {\n      // empty component root.\n      // skip all element-related modules except for ref (#3455)\n      registerRef(vnode);\n      // make sure to invoke the insert hook\n      insertedVnodeQueue.push(vnode);\n    }\n  }\n\n  function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {\n    var i;\n    // hack for #4339: a reactivated component with inner transition\n    // does not trigger because the inner node's created hooks are not called\n    // again. It's not ideal to involve module-specific logic in here but\n    // there doesn't seem to be a better way to do it.\n    var innerNode = vnode;\n    while (innerNode.componentInstance) {\n      innerNode = innerNode.componentInstance._vnode;\n      if (isDef(i = innerNode.data) && isDef(i = i.transition)) {\n        for (i = 0; i < cbs.activate.length; ++i) {\n          cbs.activate[i](emptyNode, innerNode);\n        }\n        insertedVnodeQueue.push(innerNode);\n        break\n      }\n    }\n    // unlike a newly created component,\n    // a reactivated keep-alive component doesn't insert itself\n    insert(parentElm, vnode.elm, refElm);\n  }\n\n  function insert (parent, elm, ref) {\n    if (parent) {\n      if (ref) {\n        nodeOps.insertBefore(parent, elm, ref);\n      } else {\n        nodeOps.appendChild(parent, elm);\n      }\n    }\n  }\n\n  function createChildren (vnode, children, insertedVnodeQueue) {\n    if (Array.isArray(children)) {\n      for (var i = 0; i < children.length; ++i) {\n        createElm(children[i], insertedVnodeQueue, vnode.elm, null, true);\n      }\n    } else if (isPrimitive(vnode.text)) {\n      nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(vnode.text));\n    }\n  }\n\n  function isPatchable (vnode) {\n    while (vnode.componentInstance) {\n      vnode = vnode.componentInstance._vnode;\n    }\n    return isDef(vnode.tag)\n  }\n\n  function invokeCreateHooks (vnode, insertedVnodeQueue) {\n    for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {\n      cbs.create[i$1](emptyNode, vnode);\n    }\n    i = vnode.data.hook; // Reuse variable\n    if (isDef(i)) {\n      if (i.create) { i.create(emptyNode, vnode); }\n      if (i.insert) { insertedVnodeQueue.push(vnode); }\n    }\n  }\n\n  // set scope id attribute for scoped CSS.\n  // this is implemented as a special case to avoid the overhead\n  // of going through the normal attribute patching process.\n  function setScope (vnode) {\n    var i;\n    if (isDef(i = vnode.context) && isDef(i = i.$options._scopeId)) {\n      nodeOps.setAttribute(vnode.elm, i, '');\n    }\n    if (isDef(i = activeInstance) &&\n        i !== vnode.context &&\n        isDef(i = i.$options._scopeId)) {\n      nodeOps.setAttribute(vnode.elm, i, '');\n    }\n  }\n\n  function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm);\n    }\n  }\n\n  function invokeDestroyHook (vnode) {\n    var i, j;\n    var data = vnode.data;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }\n      for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); }\n    }\n    if (isDef(i = vnode.children)) {\n      for (j = 0; j < vnode.children.length; ++j) {\n        invokeDestroyHook(vnode.children[j]);\n      }\n    }\n  }\n\n  function removeVnodes (parentElm, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      var ch = vnodes[startIdx];\n      if (isDef(ch)) {\n        if (isDef(ch.tag)) {\n          removeAndInvokeRemoveHook(ch);\n          invokeDestroyHook(ch);\n        } else { // Text node\n          removeNode(ch.elm);\n        }\n      }\n    }\n  }\n\n  function removeAndInvokeRemoveHook (vnode, rm) {\n    if (rm || isDef(vnode.data)) {\n      var listeners = cbs.remove.length + 1;\n      if (!rm) {\n        // directly removing\n        rm = createRmCb(vnode.elm, listeners);\n      } else {\n        // we have a recursively passed down rm callback\n        // increase the listeners count\n        rm.listeners += listeners;\n      }\n      // recursively invoke hooks on child component root node\n      if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {\n        removeAndInvokeRemoveHook(i, rm);\n      }\n      for (i = 0; i < cbs.remove.length; ++i) {\n        cbs.remove[i](vnode, rm);\n      }\n      if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {\n        i(vnode, rm);\n      } else {\n        rm();\n      }\n    } else {\n      removeNode(vnode.elm);\n    }\n  }\n\n  function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {\n    var oldStartIdx = 0;\n    var newStartIdx = 0;\n    var oldEndIdx = oldCh.length - 1;\n    var oldStartVnode = oldCh[0];\n    var oldEndVnode = oldCh[oldEndIdx];\n    var newEndIdx = newCh.length - 1;\n    var newStartVnode = newCh[0];\n    var newEndVnode = newCh[newEndIdx];\n    var oldKeyToIdx, idxInOld, elmToMove, refElm;\n\n    // removeOnly is a special flag used only by <transition-group>\n    // to ensure removed elements stay in correct relative positions\n    // during leaving transitions\n    var canMove = !removeOnly;\n\n    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n      if (isUndef(oldStartVnode)) {\n        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n      } else if (isUndef(oldEndVnode)) {\n        oldEndVnode = oldCh[--oldEndIdx];\n      } else if (sameVnode(oldStartVnode, newStartVnode)) {\n        patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);\n        canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));\n        oldStartVnode = oldCh[++oldStartIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);\n        canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else {\n        if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }\n        idxInOld = isDef(newStartVnode.key) ? oldKeyToIdx[newStartVnode.key] : null;\n        if (isUndef(idxInOld)) { // New element\n          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        } else {\n          elmToMove = oldCh[idxInOld];\n          /* istanbul ignore if */\n          if (process.env.NODE_ENV !== 'production' && !elmToMove) {\n            warn(\n              'It seems there are duplicate keys that is causing an update error. ' +\n              'Make sure each v-for item has a unique key.'\n            );\n          }\n          if (sameVnode(elmToMove, newStartVnode)) {\n            patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);\n            oldCh[idxInOld] = undefined;\n            canMove && nodeOps.insertBefore(parentElm, newStartVnode.elm, oldStartVnode.elm);\n            newStartVnode = newCh[++newStartIdx];\n          } else {\n            // same key but different element. treat as new element\n            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);\n            newStartVnode = newCh[++newStartIdx];\n          }\n        }\n      }\n    }\n    if (oldStartIdx > oldEndIdx) {\n      refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;\n      addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);\n    } else if (newStartIdx > newEndIdx) {\n      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n    }\n  }\n\n  function patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly) {\n    if (oldVnode === vnode) {\n      return\n    }\n    // reuse element for static trees.\n    // note we only do this if the vnode is cloned -\n    // if the new node is not cloned it means the render functions have been\n    // reset by the hot-reload-api and we need to do a proper re-render.\n    if (vnode.isStatic &&\n        oldVnode.isStatic &&\n        vnode.key === oldVnode.key &&\n        (vnode.isCloned || vnode.isOnce)) {\n      vnode.elm = oldVnode.elm;\n      vnode.componentInstance = oldVnode.componentInstance;\n      return\n    }\n    var i;\n    var data = vnode.data;\n    var hasData = isDef(data);\n    if (hasData && isDef(i = data.hook) && isDef(i = i.prepatch)) {\n      i(oldVnode, vnode);\n    }\n    var elm = vnode.elm = oldVnode.elm;\n    var oldCh = oldVnode.children;\n    var ch = vnode.children;\n    if (hasData && isPatchable(vnode)) {\n      for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); }\n      if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }\n    }\n    if (isUndef(vnode.text)) {\n      if (isDef(oldCh) && isDef(ch)) {\n        if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }\n      } else if (isDef(ch)) {\n        if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }\n        addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);\n      } else if (isDef(oldCh)) {\n        removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n      } else if (isDef(oldVnode.text)) {\n        nodeOps.setTextContent(elm, '');\n      }\n    } else if (oldVnode.text !== vnode.text) {\n      nodeOps.setTextContent(elm, vnode.text);\n    }\n    if (hasData) {\n      if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); }\n    }\n  }\n\n  function invokeInsertHook (vnode, queue, initial) {\n    // delay insert hooks for component root nodes, invoke them after the\n    // element is really inserted\n    if (initial && vnode.parent) {\n      vnode.parent.data.pendingInsert = queue;\n    } else {\n      for (var i = 0; i < queue.length; ++i) {\n        queue[i].data.hook.insert(queue[i]);\n      }\n    }\n  }\n\n  var bailed = false;\n  // list of modules that can skip create hook during hydration because they\n  // are already rendered on the client or has no need for initialization\n  var isRenderedModule = makeMap('attrs,style,class,staticClass,staticStyle,key');\n\n  // Note: this is a browser-only function so we can assume elms are DOM nodes.\n  function hydrate (elm, vnode, insertedVnodeQueue) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (!assertNodeMatch(elm, vnode)) {\n        return false\n      }\n    }\n    vnode.elm = elm;\n    var tag = vnode.tag;\n    var data = vnode.data;\n    var children = vnode.children;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }\n      if (isDef(i = vnode.componentInstance)) {\n        // child component. it should have hydrated its own tree.\n        initComponent(vnode, insertedVnodeQueue);\n        return true\n      }\n    }\n    if (isDef(tag)) {\n      if (isDef(children)) {\n        // empty element, allow client to pick up and populate children\n        if (!elm.hasChildNodes()) {\n          createChildren(vnode, children, insertedVnodeQueue);\n        } else {\n          var childrenMatch = true;\n          var childNode = elm.firstChild;\n          for (var i$1 = 0; i$1 < children.length; i$1++) {\n            if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue)) {\n              childrenMatch = false;\n              break\n            }\n            childNode = childNode.nextSibling;\n          }\n          // if childNode is not null, it means the actual childNodes list is\n          // longer than the virtual children list.\n          if (!childrenMatch || childNode) {\n            if (process.env.NODE_ENV !== 'production' &&\n                typeof console !== 'undefined' &&\n                !bailed) {\n              bailed = true;\n              console.warn('Parent: ', elm);\n              console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);\n            }\n            return false\n          }\n        }\n      }\n      if (isDef(data)) {\n        for (var key in data) {\n          if (!isRenderedModule(key)) {\n            invokeCreateHooks(vnode, insertedVnodeQueue);\n            break\n          }\n        }\n      }\n    } else if (elm.data !== vnode.text) {\n      elm.data = vnode.text;\n    }\n    return true\n  }\n\n  function assertNodeMatch (node, vnode) {\n    if (vnode.tag) {\n      return (\n        vnode.tag.indexOf('vue-component') === 0 ||\n        vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())\n      )\n    } else {\n      return node.nodeType === (vnode.isComment ? 8 : 3)\n    }\n  }\n\n  return function patch (oldVnode, vnode, hydrating, removeOnly, parentElm, refElm) {\n    if (!vnode) {\n      if (oldVnode) { invokeDestroyHook(oldVnode); }\n      return\n    }\n\n    var isInitialPatch = false;\n    var insertedVnodeQueue = [];\n\n    if (!oldVnode) {\n      // empty mount (likely as component), create new root element\n      isInitialPatch = true;\n      createElm(vnode, insertedVnodeQueue, parentElm, refElm);\n    } else {\n      var isRealElement = isDef(oldVnode.nodeType);\n      if (!isRealElement && sameVnode(oldVnode, vnode)) {\n        // patch existing root node\n        patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly);\n      } else {\n        if (isRealElement) {\n          // mounting to a real element\n          // check if this is server-rendered content and if we can perform\n          // a successful hydration.\n          if (oldVnode.nodeType === 1 && oldVnode.hasAttribute('server-rendered')) {\n            oldVnode.removeAttribute('server-rendered');\n            hydrating = true;\n          }\n          if (hydrating) {\n            if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {\n              invokeInsertHook(vnode, insertedVnodeQueue, true);\n              return oldVnode\n            } else if (process.env.NODE_ENV !== 'production') {\n              warn(\n                'The client-side rendered virtual DOM tree is not matching ' +\n                'server-rendered content. This is likely caused by incorrect ' +\n                'HTML markup, for example nesting block-level elements inside ' +\n                '<p>, or missing <tbody>. Bailing hydration and performing ' +\n                'full client-side render.'\n              );\n            }\n          }\n          // either not server-rendered, or hydration failed.\n          // create an empty node and replace it\n          oldVnode = emptyNodeAt(oldVnode);\n        }\n        // replacing existing element\n        var oldElm = oldVnode.elm;\n        var parentElm$1 = nodeOps.parentNode(oldElm);\n        createElm(\n          vnode,\n          insertedVnodeQueue,\n          // extremely rare edge case: do not insert if old element is in a\n          // leaving transition. Only happens when combining transition +\n          // keep-alive + HOCs. (#4590)\n          oldElm._leaveCb ? null : parentElm$1,\n          nodeOps.nextSibling(oldElm)\n        );\n\n        if (vnode.parent) {\n          // component root element replaced.\n          // update parent placeholder node element, recursively\n          var ancestor = vnode.parent;\n          while (ancestor) {\n            ancestor.elm = vnode.elm;\n            ancestor = ancestor.parent;\n          }\n          if (isPatchable(vnode)) {\n            for (var i = 0; i < cbs.create.length; ++i) {\n              cbs.create[i](emptyNode, vnode.parent);\n            }\n          }\n        }\n\n        if (parentElm$1 !== null) {\n          removeVnodes(parentElm$1, [oldVnode], 0, 0);\n        } else if (isDef(oldVnode.tag)) {\n          invokeDestroyHook(oldVnode);\n        }\n      }\n    }\n\n    invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);\n    return vnode.elm\n  }\n}\n\n/*  */\n\nvar directives = {\n  create: updateDirectives,\n  update: updateDirectives,\n  destroy: function unbindDirectives (vnode) {\n    updateDirectives(vnode, emptyNode);\n  }\n};\n\nfunction updateDirectives (oldVnode, vnode) {\n  if (oldVnode.data.directives || vnode.data.directives) {\n    _update(oldVnode, vnode);\n  }\n}\n\nfunction _update (oldVnode, vnode) {\n  var isCreate = oldVnode === emptyNode;\n  var isDestroy = vnode === emptyNode;\n  var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);\n  var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);\n\n  var dirsWithInsert = [];\n  var dirsWithPostpatch = [];\n\n  var key, oldDir, dir;\n  for (key in newDirs) {\n    oldDir = oldDirs[key];\n    dir = newDirs[key];\n    if (!oldDir) {\n      // new directive, bind\n      callHook$1(dir, 'bind', vnode, oldVnode);\n      if (dir.def && dir.def.inserted) {\n        dirsWithInsert.push(dir);\n      }\n    } else {\n      // existing directive, update\n      dir.oldValue = oldDir.value;\n      callHook$1(dir, 'update', vnode, oldVnode);\n      if (dir.def && dir.def.componentUpdated) {\n        dirsWithPostpatch.push(dir);\n      }\n    }\n  }\n\n  if (dirsWithInsert.length) {\n    var callInsert = function () {\n      for (var i = 0; i < dirsWithInsert.length; i++) {\n        callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);\n      }\n    };\n    if (isCreate) {\n      mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', callInsert, 'dir-insert');\n    } else {\n      callInsert();\n    }\n  }\n\n  if (dirsWithPostpatch.length) {\n    mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'postpatch', function () {\n      for (var i = 0; i < dirsWithPostpatch.length; i++) {\n        callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);\n      }\n    }, 'dir-postpatch');\n  }\n\n  if (!isCreate) {\n    for (key in oldDirs) {\n      if (!newDirs[key]) {\n        // no longer present, unbind\n        callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);\n      }\n    }\n  }\n}\n\nvar emptyModifiers = Object.create(null);\n\nfunction normalizeDirectives$1 (\n  dirs,\n  vm\n) {\n  var res = Object.create(null);\n  if (!dirs) {\n    return res\n  }\n  var i, dir;\n  for (i = 0; i < dirs.length; i++) {\n    dir = dirs[i];\n    if (!dir.modifiers) {\n      dir.modifiers = emptyModifiers;\n    }\n    res[getRawDirName(dir)] = dir;\n    dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);\n  }\n  return res\n}\n\nfunction getRawDirName (dir) {\n  return dir.rawName || ((dir.name) + \".\" + (Object.keys(dir.modifiers || {}).join('.')))\n}\n\nfunction callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {\n  var fn = dir.def && dir.def[hook];\n  if (fn) {\n    fn(vnode.elm, dir, vnode, oldVnode, isDestroy);\n  }\n}\n\nvar baseModules = [\n  ref,\n  directives\n];\n\n/*  */\n\nfunction updateAttrs (oldVnode, vnode) {\n  if (!oldVnode.data.attrs && !vnode.data.attrs) {\n    return\n  }\n  var key, cur, old;\n  var elm = vnode.elm;\n  var oldAttrs = oldVnode.data.attrs || {};\n  var attrs = vnode.data.attrs || {};\n  // clone observed objects, as the user probably wants to mutate it\n  if (attrs.__ob__) {\n    attrs = vnode.data.attrs = extend({}, attrs);\n  }\n\n  for (key in attrs) {\n    cur = attrs[key];\n    old = oldAttrs[key];\n    if (old !== cur) {\n      setAttr(elm, key, cur);\n    }\n  }\n  // #4391: in IE9, setting type can reset value for input[type=radio]\n  /* istanbul ignore if */\n  if (isIE9 && attrs.value !== oldAttrs.value) {\n    setAttr(elm, 'value', attrs.value);\n  }\n  for (key in oldAttrs) {\n    if (attrs[key] == null) {\n      if (isXlink(key)) {\n        elm.removeAttributeNS(xlinkNS, getXlinkProp(key));\n      } else if (!isEnumeratedAttr(key)) {\n        elm.removeAttribute(key);\n      }\n    }\n  }\n}\n\nfunction setAttr (el, key, value) {\n  if (isBooleanAttr(key)) {\n    // set attribute for blank value\n    // e.g. <option disabled>Select one</option>\n    if (isFalsyAttrValue(value)) {\n      el.removeAttribute(key);\n    } else {\n      el.setAttribute(key, key);\n    }\n  } else if (isEnumeratedAttr(key)) {\n    el.setAttribute(key, isFalsyAttrValue(value) || value === 'false' ? 'false' : 'true');\n  } else if (isXlink(key)) {\n    if (isFalsyAttrValue(value)) {\n      el.removeAttributeNS(xlinkNS, getXlinkProp(key));\n    } else {\n      el.setAttributeNS(xlinkNS, key, value);\n    }\n  } else {\n    if (isFalsyAttrValue(value)) {\n      el.removeAttribute(key);\n    } else {\n      el.setAttribute(key, value);\n    }\n  }\n}\n\nvar attrs = {\n  create: updateAttrs,\n  update: updateAttrs\n};\n\n/*  */\n\nfunction updateClass (oldVnode, vnode) {\n  var el = vnode.elm;\n  var data = vnode.data;\n  var oldData = oldVnode.data;\n  if (!data.staticClass && !data.class &&\n      (!oldData || (!oldData.staticClass && !oldData.class))) {\n    return\n  }\n\n  var cls = genClassForVnode(vnode);\n\n  // handle transition classes\n  var transitionClass = el._transitionClasses;\n  if (transitionClass) {\n    cls = concat(cls, stringifyClass(transitionClass));\n  }\n\n  // set the class\n  if (cls !== el._prevClass) {\n    el.setAttribute('class', cls);\n    el._prevClass = cls;\n  }\n}\n\nvar klass = {\n  create: updateClass,\n  update: updateClass\n};\n\n/*  */\n\nvar target$1;\n\nfunction add$2 (\n  event,\n  handler,\n  once,\n  capture\n) {\n  if (once) {\n    var oldHandler = handler;\n    var _target = target$1; // save current target element in closure\n    handler = function (ev) {\n      remove$3(event, handler, capture, _target);\n      arguments.length === 1\n        ? oldHandler(ev)\n        : oldHandler.apply(null, arguments);\n    };\n  }\n  target$1.addEventListener(event, handler, capture);\n}\n\nfunction remove$3 (\n  event,\n  handler,\n  capture,\n  _target\n) {\n  (_target || target$1).removeEventListener(event, handler, capture);\n}\n\nfunction updateDOMListeners (oldVnode, vnode) {\n  if (!oldVnode.data.on && !vnode.data.on) {\n    return\n  }\n  var on = vnode.data.on || {};\n  var oldOn = oldVnode.data.on || {};\n  target$1 = vnode.elm;\n  updateListeners(on, oldOn, add$2, remove$3, vnode.context);\n}\n\nvar events = {\n  create: updateDOMListeners,\n  update: updateDOMListeners\n};\n\n/*  */\n\nfunction updateDOMProps (oldVnode, vnode) {\n  if (!oldVnode.data.domProps && !vnode.data.domProps) {\n    return\n  }\n  var key, cur;\n  var elm = vnode.elm;\n  var oldProps = oldVnode.data.domProps || {};\n  var props = vnode.data.domProps || {};\n  // clone observed objects, as the user probably wants to mutate it\n  if (props.__ob__) {\n    props = vnode.data.domProps = extend({}, props);\n  }\n\n  for (key in oldProps) {\n    if (props[key] == null) {\n      elm[key] = '';\n    }\n  }\n  for (key in props) {\n    cur = props[key];\n    // ignore children if the node has textContent or innerHTML,\n    // as these will throw away existing DOM nodes and cause removal errors\n    // on subsequent patches (#3360)\n    if (key === 'textContent' || key === 'innerHTML') {\n      if (vnode.children) { vnode.children.length = 0; }\n      if (cur === oldProps[key]) { continue }\n    }\n\n    if (key === 'value') {\n      // store value as _value as well since\n      // non-string values will be stringified\n      elm._value = cur;\n      // avoid resetting cursor position when value is the same\n      var strCur = cur == null ? '' : String(cur);\n      if (shouldUpdateValue(elm, vnode, strCur)) {\n        elm.value = strCur;\n      }\n    } else {\n      elm[key] = cur;\n    }\n  }\n}\n\n// check platforms/web/util/attrs.js acceptValue\n\n\nfunction shouldUpdateValue (\n  elm,\n  vnode,\n  checkVal\n) {\n  return (!elm.composing && (\n    vnode.tag === 'option' ||\n    isDirty(elm, checkVal) ||\n    isInputChanged(vnode, checkVal)\n  ))\n}\n\nfunction isDirty (elm, checkVal) {\n  // return true when textbox (.number and .trim) loses focus and its value is not equal to the updated value\n  return document.activeElement !== elm && elm.value !== checkVal\n}\n\nfunction isInputChanged (vnode, newVal) {\n  var value = vnode.elm.value;\n  var modifiers = vnode.elm._vModifiers; // injected by v-model runtime\n  if ((modifiers && modifiers.number) || vnode.elm.type === 'number') {\n    return toNumber(value) !== toNumber(newVal)\n  }\n  if (modifiers && modifiers.trim) {\n    return value.trim() !== newVal.trim()\n  }\n  return value !== newVal\n}\n\nvar domProps = {\n  create: updateDOMProps,\n  update: updateDOMProps\n};\n\n/*  */\n\nvar parseStyleText = cached(function (cssText) {\n  var res = {};\n  var listDelimiter = /;(?![^(]*\\))/g;\n  var propertyDelimiter = /:(.+)/;\n  cssText.split(listDelimiter).forEach(function (item) {\n    if (item) {\n      var tmp = item.split(propertyDelimiter);\n      tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());\n    }\n  });\n  return res\n});\n\n// merge static and dynamic style data on the same vnode\nfunction normalizeStyleData (data) {\n  var style = normalizeStyleBinding(data.style);\n  // static style is pre-processed into an object during compilation\n  // and is always a fresh object, so it's safe to merge into it\n  return data.staticStyle\n    ? extend(data.staticStyle, style)\n    : style\n}\n\n// normalize possible array / string values into Object\nfunction normalizeStyleBinding (bindingStyle) {\n  if (Array.isArray(bindingStyle)) {\n    return toObject(bindingStyle)\n  }\n  if (typeof bindingStyle === 'string') {\n    return parseStyleText(bindingStyle)\n  }\n  return bindingStyle\n}\n\n/**\n * parent component style should be after child's\n * so that parent component's style could override it\n */\nfunction getStyle (vnode, checkChild) {\n  var res = {};\n  var styleData;\n\n  if (checkChild) {\n    var childNode = vnode;\n    while (childNode.componentInstance) {\n      childNode = childNode.componentInstance._vnode;\n      if (childNode.data && (styleData = normalizeStyleData(childNode.data))) {\n        extend(res, styleData);\n      }\n    }\n  }\n\n  if ((styleData = normalizeStyleData(vnode.data))) {\n    extend(res, styleData);\n  }\n\n  var parentNode = vnode;\n  while ((parentNode = parentNode.parent)) {\n    if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {\n      extend(res, styleData);\n    }\n  }\n  return res\n}\n\n/*  */\n\nvar cssVarRE = /^--/;\nvar importantRE = /\\s*!important$/;\nvar setProp = function (el, name, val) {\n  /* istanbul ignore if */\n  if (cssVarRE.test(name)) {\n    el.style.setProperty(name, val);\n  } else if (importantRE.test(val)) {\n    el.style.setProperty(name, val.replace(importantRE, ''), 'important');\n  } else {\n    el.style[normalize(name)] = val;\n  }\n};\n\nvar prefixes = ['Webkit', 'Moz', 'ms'];\n\nvar testEl;\nvar normalize = cached(function (prop) {\n  testEl = testEl || document.createElement('div');\n  prop = camelize(prop);\n  if (prop !== 'filter' && (prop in testEl.style)) {\n    return prop\n  }\n  var upper = prop.charAt(0).toUpperCase() + prop.slice(1);\n  for (var i = 0; i < prefixes.length; i++) {\n    var prefixed = prefixes[i] + upper;\n    if (prefixed in testEl.style) {\n      return prefixed\n    }\n  }\n});\n\nfunction updateStyle (oldVnode, vnode) {\n  var data = vnode.data;\n  var oldData = oldVnode.data;\n\n  if (!data.staticStyle && !data.style &&\n      !oldData.staticStyle && !oldData.style) {\n    return\n  }\n\n  var cur, name;\n  var el = vnode.elm;\n  var oldStaticStyle = oldVnode.data.staticStyle;\n  var oldStyleBinding = oldVnode.data.style || {};\n\n  // if static style exists, stylebinding already merged into it when doing normalizeStyleData\n  var oldStyle = oldStaticStyle || oldStyleBinding;\n\n  var style = normalizeStyleBinding(vnode.data.style) || {};\n\n  vnode.data.style = style.__ob__ ? extend({}, style) : style;\n\n  var newStyle = getStyle(vnode, true);\n\n  for (name in oldStyle) {\n    if (newStyle[name] == null) {\n      setProp(el, name, '');\n    }\n  }\n  for (name in newStyle) {\n    cur = newStyle[name];\n    if (cur !== oldStyle[name]) {\n      // ie9 setting to null has no effect, must use empty string\n      setProp(el, name, cur == null ? '' : cur);\n    }\n  }\n}\n\nvar style = {\n  create: updateStyle,\n  update: updateStyle\n};\n\n/*  */\n\n/**\n * Add class with compatibility for SVG since classList is not supported on\n * SVG elements in IE\n */\nfunction addClass (el, cls) {\n  /* istanbul ignore if */\n  if (!cls || !cls.trim()) {\n    return\n  }\n\n  /* istanbul ignore else */\n  if (el.classList) {\n    if (cls.indexOf(' ') > -1) {\n      cls.split(/\\s+/).forEach(function (c) { return el.classList.add(c); });\n    } else {\n      el.classList.add(cls);\n    }\n  } else {\n    var cur = ' ' + el.getAttribute('class') + ' ';\n    if (cur.indexOf(' ' + cls + ' ') < 0) {\n      el.setAttribute('class', (cur + cls).trim());\n    }\n  }\n}\n\n/**\n * Remove class with compatibility for SVG since classList is not supported on\n * SVG elements in IE\n */\nfunction removeClass (el, cls) {\n  /* istanbul ignore if */\n  if (!cls || !cls.trim()) {\n    return\n  }\n\n  /* istanbul ignore else */\n  if (el.classList) {\n    if (cls.indexOf(' ') > -1) {\n      cls.split(/\\s+/).forEach(function (c) { return el.classList.remove(c); });\n    } else {\n      el.classList.remove(cls);\n    }\n  } else {\n    var cur = ' ' + el.getAttribute('class') + ' ';\n    var tar = ' ' + cls + ' ';\n    while (cur.indexOf(tar) >= 0) {\n      cur = cur.replace(tar, ' ');\n    }\n    el.setAttribute('class', cur.trim());\n  }\n}\n\n/*  */\n\nvar hasTransition = inBrowser && !isIE9;\nvar TRANSITION = 'transition';\nvar ANIMATION = 'animation';\n\n// Transition property/event sniffing\nvar transitionProp = 'transition';\nvar transitionEndEvent = 'transitionend';\nvar animationProp = 'animation';\nvar animationEndEvent = 'animationend';\nif (hasTransition) {\n  /* istanbul ignore if */\n  if (window.ontransitionend === undefined &&\n    window.onwebkittransitionend !== undefined) {\n    transitionProp = 'WebkitTransition';\n    transitionEndEvent = 'webkitTransitionEnd';\n  }\n  if (window.onanimationend === undefined &&\n    window.onwebkitanimationend !== undefined) {\n    animationProp = 'WebkitAnimation';\n    animationEndEvent = 'webkitAnimationEnd';\n  }\n}\n\n// binding to window is necessary to make hot reload work in IE in strict mode\nvar raf = inBrowser && window.requestAnimationFrame\n  ? window.requestAnimationFrame.bind(window)\n  : setTimeout;\n\nfunction nextFrame (fn) {\n  raf(function () {\n    raf(fn);\n  });\n}\n\nfunction addTransitionClass (el, cls) {\n  (el._transitionClasses || (el._transitionClasses = [])).push(cls);\n  addClass(el, cls);\n}\n\nfunction removeTransitionClass (el, cls) {\n  if (el._transitionClasses) {\n    remove$1(el._transitionClasses, cls);\n  }\n  removeClass(el, cls);\n}\n\nfunction whenTransitionEnds (\n  el,\n  expectedType,\n  cb\n) {\n  var ref = getTransitionInfo(el, expectedType);\n  var type = ref.type;\n  var timeout = ref.timeout;\n  var propCount = ref.propCount;\n  if (!type) { return cb() }\n  var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;\n  var ended = 0;\n  var end = function () {\n    el.removeEventListener(event, onEnd);\n    cb();\n  };\n  var onEnd = function (e) {\n    if (e.target === el) {\n      if (++ended >= propCount) {\n        end();\n      }\n    }\n  };\n  setTimeout(function () {\n    if (ended < propCount) {\n      end();\n    }\n  }, timeout + 1);\n  el.addEventListener(event, onEnd);\n}\n\nvar transformRE = /\\b(transform|all)(,|$)/;\n\nfunction getTransitionInfo (el, expectedType) {\n  var styles = window.getComputedStyle(el);\n  var transitioneDelays = styles[transitionProp + 'Delay'].split(', ');\n  var transitionDurations = styles[transitionProp + 'Duration'].split(', ');\n  var transitionTimeout = getTimeout(transitioneDelays, transitionDurations);\n  var animationDelays = styles[animationProp + 'Delay'].split(', ');\n  var animationDurations = styles[animationProp + 'Duration'].split(', ');\n  var animationTimeout = getTimeout(animationDelays, animationDurations);\n\n  var type;\n  var timeout = 0;\n  var propCount = 0;\n  /* istanbul ignore if */\n  if (expectedType === TRANSITION) {\n    if (transitionTimeout > 0) {\n      type = TRANSITION;\n      timeout = transitionTimeout;\n      propCount = transitionDurations.length;\n    }\n  } else if (expectedType === ANIMATION) {\n    if (animationTimeout > 0) {\n      type = ANIMATION;\n      timeout = animationTimeout;\n      propCount = animationDurations.length;\n    }\n  } else {\n    timeout = Math.max(transitionTimeout, animationTimeout);\n    type = timeout > 0\n      ? transitionTimeout > animationTimeout\n        ? TRANSITION\n        : ANIMATION\n      : null;\n    propCount = type\n      ? type === TRANSITION\n        ? transitionDurations.length\n        : animationDurations.length\n      : 0;\n  }\n  var hasTransform =\n    type === TRANSITION &&\n    transformRE.test(styles[transitionProp + 'Property']);\n  return {\n    type: type,\n    timeout: timeout,\n    propCount: propCount,\n    hasTransform: hasTransform\n  }\n}\n\nfunction getTimeout (delays, durations) {\n  /* istanbul ignore next */\n  while (delays.length < durations.length) {\n    delays = delays.concat(delays);\n  }\n\n  return Math.max.apply(null, durations.map(function (d, i) {\n    return toMs(d) + toMs(delays[i])\n  }))\n}\n\nfunction toMs (s) {\n  return Number(s.slice(0, -1)) * 1000\n}\n\n/*  */\n\nfunction enter (vnode, toggleDisplay) {\n  var el = vnode.elm;\n\n  // call leave callback now\n  if (el._leaveCb) {\n    el._leaveCb.cancelled = true;\n    el._leaveCb();\n  }\n\n  var data = resolveTransition(vnode.data.transition);\n  if (!data) {\n    return\n  }\n\n  /* istanbul ignore if */\n  if (el._enterCb || el.nodeType !== 1) {\n    return\n  }\n\n  var css = data.css;\n  var type = data.type;\n  var enterClass = data.enterClass;\n  var enterToClass = data.enterToClass;\n  var enterActiveClass = data.enterActiveClass;\n  var appearClass = data.appearClass;\n  var appearToClass = data.appearToClass;\n  var appearActiveClass = data.appearActiveClass;\n  var beforeEnter = data.beforeEnter;\n  var enter = data.enter;\n  var afterEnter = data.afterEnter;\n  var enterCancelled = data.enterCancelled;\n  var beforeAppear = data.beforeAppear;\n  var appear = data.appear;\n  var afterAppear = data.afterAppear;\n  var appearCancelled = data.appearCancelled;\n\n  // activeInstance will always be the <transition> component managing this\n  // transition. One edge case to check is when the <transition> is placed\n  // as the root node of a child component. In that case we need to check\n  // <transition>'s parent for appear check.\n  var context = activeInstance;\n  var transitionNode = activeInstance.$vnode;\n  while (transitionNode && transitionNode.parent) {\n    transitionNode = transitionNode.parent;\n    context = transitionNode.context;\n  }\n\n  var isAppear = !context._isMounted || !vnode.isRootInsert;\n\n  if (isAppear && !appear && appear !== '') {\n    return\n  }\n\n  var startClass = isAppear ? appearClass : enterClass;\n  var activeClass = isAppear ? appearActiveClass : enterActiveClass;\n  var toClass = isAppear ? appearToClass : enterToClass;\n  var beforeEnterHook = isAppear ? (beforeAppear || beforeEnter) : beforeEnter;\n  var enterHook = isAppear ? (typeof appear === 'function' ? appear : enter) : enter;\n  var afterEnterHook = isAppear ? (afterAppear || afterEnter) : afterEnter;\n  var enterCancelledHook = isAppear ? (appearCancelled || enterCancelled) : enterCancelled;\n\n  var expectsCSS = css !== false && !isIE9;\n  var userWantsControl =\n    enterHook &&\n    // enterHook may be a bound method which exposes\n    // the length of original fn as _length\n    (enterHook._length || enterHook.length) > 1;\n\n  var cb = el._enterCb = once(function () {\n    if (expectsCSS) {\n      removeTransitionClass(el, toClass);\n      removeTransitionClass(el, activeClass);\n    }\n    if (cb.cancelled) {\n      if (expectsCSS) {\n        removeTransitionClass(el, startClass);\n      }\n      enterCancelledHook && enterCancelledHook(el);\n    } else {\n      afterEnterHook && afterEnterHook(el);\n    }\n    el._enterCb = null;\n  });\n\n  if (!vnode.data.show) {\n    // remove pending leave element on enter by injecting an insert hook\n    mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', function () {\n      var parent = el.parentNode;\n      var pendingNode = parent && parent._pending && parent._pending[vnode.key];\n      if (pendingNode &&\n          pendingNode.tag === vnode.tag &&\n          pendingNode.elm._leaveCb) {\n        pendingNode.elm._leaveCb();\n      }\n      enterHook && enterHook(el, cb);\n    }, 'transition-insert');\n  }\n\n  // start enter transition\n  beforeEnterHook && beforeEnterHook(el);\n  if (expectsCSS) {\n    addTransitionClass(el, startClass);\n    addTransitionClass(el, activeClass);\n    nextFrame(function () {\n      addTransitionClass(el, toClass);\n      removeTransitionClass(el, startClass);\n      if (!cb.cancelled && !userWantsControl) {\n        whenTransitionEnds(el, type, cb);\n      }\n    });\n  }\n\n  if (vnode.data.show) {\n    toggleDisplay && toggleDisplay();\n    enterHook && enterHook(el, cb);\n  }\n\n  if (!expectsCSS && !userWantsControl) {\n    cb();\n  }\n}\n\nfunction leave (vnode, rm) {\n  var el = vnode.elm;\n\n  // call enter callback now\n  if (el._enterCb) {\n    el._enterCb.cancelled = true;\n    el._enterCb();\n  }\n\n  var data = resolveTransition(vnode.data.transition);\n  if (!data) {\n    return rm()\n  }\n\n  /* istanbul ignore if */\n  if (el._leaveCb || el.nodeType !== 1) {\n    return\n  }\n\n  var css = data.css;\n  var type = data.type;\n  var leaveClass = data.leaveClass;\n  var leaveToClass = data.leaveToClass;\n  var leaveActiveClass = data.leaveActiveClass;\n  var beforeLeave = data.beforeLeave;\n  var leave = data.leave;\n  var afterLeave = data.afterLeave;\n  var leaveCancelled = data.leaveCancelled;\n  var delayLeave = data.delayLeave;\n\n  var expectsCSS = css !== false && !isIE9;\n  var userWantsControl =\n    leave &&\n    // leave hook may be a bound method which exposes\n    // the length of original fn as _length\n    (leave._length || leave.length) > 1;\n\n  var cb = el._leaveCb = once(function () {\n    if (el.parentNode && el.parentNode._pending) {\n      el.parentNode._pending[vnode.key] = null;\n    }\n    if (expectsCSS) {\n      removeTransitionClass(el, leaveToClass);\n      removeTransitionClass(el, leaveActiveClass);\n    }\n    if (cb.cancelled) {\n      if (expectsCSS) {\n        removeTransitionClass(el, leaveClass);\n      }\n      leaveCancelled && leaveCancelled(el);\n    } else {\n      rm();\n      afterLeave && afterLeave(el);\n    }\n    el._leaveCb = null;\n  });\n\n  if (delayLeave) {\n    delayLeave(performLeave);\n  } else {\n    performLeave();\n  }\n\n  function performLeave () {\n    // the delayed leave may have already been cancelled\n    if (cb.cancelled) {\n      return\n    }\n    // record leaving element\n    if (!vnode.data.show) {\n      (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;\n    }\n    beforeLeave && beforeLeave(el);\n    if (expectsCSS) {\n      addTransitionClass(el, leaveClass);\n      addTransitionClass(el, leaveActiveClass);\n      nextFrame(function () {\n        addTransitionClass(el, leaveToClass);\n        removeTransitionClass(el, leaveClass);\n        if (!cb.cancelled && !userWantsControl) {\n          whenTransitionEnds(el, type, cb);\n        }\n      });\n    }\n    leave && leave(el, cb);\n    if (!expectsCSS && !userWantsControl) {\n      cb();\n    }\n  }\n}\n\nfunction resolveTransition (def$$1) {\n  if (!def$$1) {\n    return\n  }\n  /* istanbul ignore else */\n  if (typeof def$$1 === 'object') {\n    var res = {};\n    if (def$$1.css !== false) {\n      extend(res, autoCssTransition(def$$1.name || 'v'));\n    }\n    extend(res, def$$1);\n    return res\n  } else if (typeof def$$1 === 'string') {\n    return autoCssTransition(def$$1)\n  }\n}\n\nvar autoCssTransition = cached(function (name) {\n  return {\n    enterClass: (name + \"-enter\"),\n    leaveClass: (name + \"-leave\"),\n    appearClass: (name + \"-enter\"),\n    enterToClass: (name + \"-enter-to\"),\n    leaveToClass: (name + \"-leave-to\"),\n    appearToClass: (name + \"-enter-to\"),\n    enterActiveClass: (name + \"-enter-active\"),\n    leaveActiveClass: (name + \"-leave-active\"),\n    appearActiveClass: (name + \"-enter-active\")\n  }\n});\n\nfunction once (fn) {\n  var called = false;\n  return function () {\n    if (!called) {\n      called = true;\n      fn();\n    }\n  }\n}\n\nfunction _enter (_, vnode) {\n  if (!vnode.data.show) {\n    enter(vnode);\n  }\n}\n\nvar transition = inBrowser ? {\n  create: _enter,\n  activate: _enter,\n  remove: function remove (vnode, rm) {\n    /* istanbul ignore else */\n    if (!vnode.data.show) {\n      leave(vnode, rm);\n    } else {\n      rm();\n    }\n  }\n} : {};\n\nvar platformModules = [\n  attrs,\n  klass,\n  events,\n  domProps,\n  style,\n  transition\n];\n\n/*  */\n\n// the directive module should be applied last, after all\n// built-in modules have been applied.\nvar modules = platformModules.concat(baseModules);\n\nvar patch$1 = createPatchFunction({ nodeOps: nodeOps, modules: modules });\n\n/**\n * Not type checking this file because flow doesn't like attaching\n * properties to Elements.\n */\n\nvar modelableTagRE = /^input|select|textarea|vue-component-[0-9]+(-[0-9a-zA-Z_-]*)?$/;\n\n/* istanbul ignore if */\nif (isIE9) {\n  // http://www.matts411.com/post/internet-explorer-9-oninput/\n  document.addEventListener('selectionchange', function () {\n    var el = document.activeElement;\n    if (el && el.vmodel) {\n      trigger(el, 'input');\n    }\n  });\n}\n\nvar model = {\n  inserted: function inserted (el, binding, vnode) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (!modelableTagRE.test(vnode.tag)) {\n        warn(\n          \"v-model is not supported on element type: <\" + (vnode.tag) + \">. \" +\n          'If you are working with contenteditable, it\\'s recommended to ' +\n          'wrap a library dedicated for that purpose inside a custom component.',\n          vnode.context\n        );\n      }\n    }\n    if (vnode.tag === 'select') {\n      var cb = function () {\n        setSelected(el, binding, vnode.context);\n      };\n      cb();\n      /* istanbul ignore if */\n      if (isIE || isEdge) {\n        setTimeout(cb, 0);\n      }\n    } else if (vnode.tag === 'textarea' || el.type === 'text') {\n      el._vModifiers = binding.modifiers;\n      if (!binding.modifiers.lazy) {\n        if (!isAndroid) {\n          el.addEventListener('compositionstart', onCompositionStart);\n          el.addEventListener('compositionend', onCompositionEnd);\n        }\n        /* istanbul ignore if */\n        if (isIE9) {\n          el.vmodel = true;\n        }\n      }\n    }\n  },\n  componentUpdated: function componentUpdated (el, binding, vnode) {\n    if (vnode.tag === 'select') {\n      setSelected(el, binding, vnode.context);\n      // in case the options rendered by v-for have changed,\n      // it's possible that the value is out-of-sync with the rendered options.\n      // detect such cases and filter out values that no longer has a matching\n      // option in the DOM.\n      var needReset = el.multiple\n        ? binding.value.some(function (v) { return hasNoMatchingOption(v, el.options); })\n        : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, el.options);\n      if (needReset) {\n        trigger(el, 'change');\n      }\n    }\n  }\n};\n\nfunction setSelected (el, binding, vm) {\n  var value = binding.value;\n  var isMultiple = el.multiple;\n  if (isMultiple && !Array.isArray(value)) {\n    process.env.NODE_ENV !== 'production' && warn(\n      \"<select multiple v-model=\\\"\" + (binding.expression) + \"\\\"> \" +\n      \"expects an Array value for its binding, but got \" + (Object.prototype.toString.call(value).slice(8, -1)),\n      vm\n    );\n    return\n  }\n  var selected, option;\n  for (var i = 0, l = el.options.length; i < l; i++) {\n    option = el.options[i];\n    if (isMultiple) {\n      selected = looseIndexOf(value, getValue(option)) > -1;\n      if (option.selected !== selected) {\n        option.selected = selected;\n      }\n    } else {\n      if (looseEqual(getValue(option), value)) {\n        if (el.selectedIndex !== i) {\n          el.selectedIndex = i;\n        }\n        return\n      }\n    }\n  }\n  if (!isMultiple) {\n    el.selectedIndex = -1;\n  }\n}\n\nfunction hasNoMatchingOption (value, options) {\n  for (var i = 0, l = options.length; i < l; i++) {\n    if (looseEqual(getValue(options[i]), value)) {\n      return false\n    }\n  }\n  return true\n}\n\nfunction getValue (option) {\n  return '_value' in option\n    ? option._value\n    : option.value\n}\n\nfunction onCompositionStart (e) {\n  e.target.composing = true;\n}\n\nfunction onCompositionEnd (e) {\n  e.target.composing = false;\n  trigger(e.target, 'input');\n}\n\nfunction trigger (el, type) {\n  var e = document.createEvent('HTMLEvents');\n  e.initEvent(type, true, true);\n  el.dispatchEvent(e);\n}\n\n/*  */\n\n// recursively search for possible transition defined inside the component root\nfunction locateNode (vnode) {\n  return vnode.componentInstance && (!vnode.data || !vnode.data.transition)\n    ? locateNode(vnode.componentInstance._vnode)\n    : vnode\n}\n\nvar show = {\n  bind: function bind (el, ref, vnode) {\n    var value = ref.value;\n\n    vnode = locateNode(vnode);\n    var transition = vnode.data && vnode.data.transition;\n    var originalDisplay = el.__vOriginalDisplay =\n      el.style.display === 'none' ? '' : el.style.display;\n    if (value && transition && !isIE9) {\n      vnode.data.show = true;\n      enter(vnode, function () {\n        el.style.display = originalDisplay;\n      });\n    } else {\n      el.style.display = value ? originalDisplay : 'none';\n    }\n  },\n\n  update: function update (el, ref, vnode) {\n    var value = ref.value;\n    var oldValue = ref.oldValue;\n\n    /* istanbul ignore if */\n    if (value === oldValue) { return }\n    vnode = locateNode(vnode);\n    var transition = vnode.data && vnode.data.transition;\n    if (transition && !isIE9) {\n      vnode.data.show = true;\n      if (value) {\n        enter(vnode, function () {\n          el.style.display = el.__vOriginalDisplay;\n        });\n      } else {\n        leave(vnode, function () {\n          el.style.display = 'none';\n        });\n      }\n    } else {\n      el.style.display = value ? el.__vOriginalDisplay : 'none';\n    }\n  },\n\n  unbind: function unbind (\n    el,\n    binding,\n    vnode,\n    oldVnode,\n    isDestroy\n  ) {\n    if (!isDestroy) {\n      el.style.display = el.__vOriginalDisplay;\n    }\n  }\n};\n\nvar platformDirectives = {\n  model: model,\n  show: show\n};\n\n/*  */\n\n// Provides transition support for a single element/component.\n// supports transition mode (out-in / in-out)\n\nvar transitionProps = {\n  name: String,\n  appear: Boolean,\n  css: Boolean,\n  mode: String,\n  type: String,\n  enterClass: String,\n  leaveClass: String,\n  enterToClass: String,\n  leaveToClass: String,\n  enterActiveClass: String,\n  leaveActiveClass: String,\n  appearClass: String,\n  appearActiveClass: String,\n  appearToClass: String\n};\n\n// in case the child is also an abstract component, e.g. <keep-alive>\n// we want to recursively retrieve the real component to be rendered\nfunction getRealChild (vnode) {\n  var compOptions = vnode && vnode.componentOptions;\n  if (compOptions && compOptions.Ctor.options.abstract) {\n    return getRealChild(getFirstComponentChild(compOptions.children))\n  } else {\n    return vnode\n  }\n}\n\nfunction extractTransitionData (comp) {\n  var data = {};\n  var options = comp.$options;\n  // props\n  for (var key in options.propsData) {\n    data[key] = comp[key];\n  }\n  // events.\n  // extract listeners and pass them directly to the transition methods\n  var listeners = options._parentListeners;\n  for (var key$1 in listeners) {\n    data[camelize(key$1)] = listeners[key$1].fn;\n  }\n  return data\n}\n\nfunction placeholder (h, rawChild) {\n  return /\\d-keep-alive$/.test(rawChild.tag)\n    ? h('keep-alive')\n    : null\n}\n\nfunction hasParentTransition (vnode) {\n  while ((vnode = vnode.parent)) {\n    if (vnode.data.transition) {\n      return true\n    }\n  }\n}\n\nfunction isSameChild (child, oldChild) {\n  return oldChild.key === child.key && oldChild.tag === child.tag\n}\n\nvar Transition = {\n  name: 'transition',\n  props: transitionProps,\n  abstract: true,\n\n  render: function render (h) {\n    var this$1 = this;\n\n    var children = this.$slots.default;\n    if (!children) {\n      return\n    }\n\n    // filter out text nodes (possible whitespaces)\n    children = children.filter(function (c) { return c.tag; });\n    /* istanbul ignore if */\n    if (!children.length) {\n      return\n    }\n\n    // warn multiple elements\n    if (process.env.NODE_ENV !== 'production' && children.length > 1) {\n      warn(\n        '<transition> can only be used on a single element. Use ' +\n        '<transition-group> for lists.',\n        this.$parent\n      );\n    }\n\n    var mode = this.mode;\n\n    // warn invalid mode\n    if (process.env.NODE_ENV !== 'production' &&\n        mode && mode !== 'in-out' && mode !== 'out-in') {\n      warn(\n        'invalid <transition> mode: ' + mode,\n        this.$parent\n      );\n    }\n\n    var rawChild = children[0];\n\n    // if this is a component root node and the component's\n    // parent container node also has transition, skip.\n    if (hasParentTransition(this.$vnode)) {\n      return rawChild\n    }\n\n    // apply transition data to child\n    // use getRealChild() to ignore abstract components e.g. keep-alive\n    var child = getRealChild(rawChild);\n    /* istanbul ignore if */\n    if (!child) {\n      return rawChild\n    }\n\n    if (this._leaving) {\n      return placeholder(h, rawChild)\n    }\n\n    // ensure a key that is unique to the vnode type and to this transition\n    // component instance. This key will be used to remove pending leaving nodes\n    // during entering.\n    var id = \"__transition-\" + (this._uid) + \"-\";\n    var key = child.key = child.key == null\n      ? id + child.tag\n      : isPrimitive(child.key)\n        ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)\n        : child.key;\n    var data = (child.data || (child.data = {})).transition = extractTransitionData(this);\n    var oldRawChild = this._vnode;\n    var oldChild = getRealChild(oldRawChild);\n\n    // mark v-show\n    // so that the transition module can hand over the control to the directive\n    if (child.data.directives && child.data.directives.some(function (d) { return d.name === 'show'; })) {\n      child.data.show = true;\n    }\n\n    if (oldChild && oldChild.data && !isSameChild(child, oldChild)) {\n      // replace old child transition data with fresh one\n      // important for dynamic transitions!\n      var oldData = oldChild && (oldChild.data.transition = extend({}, data));\n      // handle transition mode\n      if (mode === 'out-in') {\n        // return placeholder node and queue update when leave finishes\n        this._leaving = true;\n        mergeVNodeHook(oldData, 'afterLeave', function () {\n          this$1._leaving = false;\n          this$1.$forceUpdate();\n        }, key);\n        return placeholder(h, rawChild)\n      } else if (mode === 'in-out') {\n        var delayedLeave;\n        var performLeave = function () { delayedLeave(); };\n        mergeVNodeHook(data, 'afterEnter', performLeave, key);\n        mergeVNodeHook(data, 'enterCancelled', performLeave, key);\n        mergeVNodeHook(oldData, 'delayLeave', function (leave) {\n          delayedLeave = leave;\n        }, key);\n      }\n    }\n\n    return rawChild\n  }\n};\n\n/*  */\n\n// Provides transition support for list items.\n// supports move transitions using the FLIP technique.\n\n// Because the vdom's children update algorithm is \"unstable\" - i.e.\n// it doesn't guarantee the relative positioning of removed elements,\n// we force transition-group to update its children into two passes:\n// in the first pass, we remove all nodes that need to be removed,\n// triggering their leaving transition; in the second pass, we insert/move\n// into the final disired state. This way in the second pass removed\n// nodes will remain where they should be.\n\nvar props = extend({\n  tag: String,\n  moveClass: String\n}, transitionProps);\n\ndelete props.mode;\n\nvar TransitionGroup = {\n  props: props,\n\n  render: function render (h) {\n    var tag = this.tag || this.$vnode.data.tag || 'span';\n    var map = Object.create(null);\n    var prevChildren = this.prevChildren = this.children;\n    var rawChildren = this.$slots.default || [];\n    var children = this.children = [];\n    var transitionData = extractTransitionData(this);\n\n    for (var i = 0; i < rawChildren.length; i++) {\n      var c = rawChildren[i];\n      if (c.tag) {\n        if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {\n          children.push(c);\n          map[c.key] = c\n          ;(c.data || (c.data = {})).transition = transitionData;\n        } else if (process.env.NODE_ENV !== 'production') {\n          var opts = c.componentOptions;\n          var name = opts\n            ? (opts.Ctor.options.name || opts.tag)\n            : c.tag;\n          warn((\"<transition-group> children must be keyed: <\" + name + \">\"));\n        }\n      }\n    }\n\n    if (prevChildren) {\n      var kept = [];\n      var removed = [];\n      for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {\n        var c$1 = prevChildren[i$1];\n        c$1.data.transition = transitionData;\n        c$1.data.pos = c$1.elm.getBoundingClientRect();\n        if (map[c$1.key]) {\n          kept.push(c$1);\n        } else {\n          removed.push(c$1);\n        }\n      }\n      this.kept = h(tag, null, kept);\n      this.removed = removed;\n    }\n\n    return h(tag, null, children)\n  },\n\n  beforeUpdate: function beforeUpdate () {\n    // force removing pass\n    this.__patch__(\n      this._vnode,\n      this.kept,\n      false, // hydrating\n      true // removeOnly (!important, avoids unnecessary moves)\n    );\n    this._vnode = this.kept;\n  },\n\n  updated: function updated () {\n    var children = this.prevChildren;\n    var moveClass = this.moveClass || ((this.name || 'v') + '-move');\n    if (!children.length || !this.hasMove(children[0].elm, moveClass)) {\n      return\n    }\n\n    // we divide the work into three loops to avoid mixing DOM reads and writes\n    // in each iteration - which helps prevent layout thrashing.\n    children.forEach(callPendingCbs);\n    children.forEach(recordPosition);\n    children.forEach(applyTranslation);\n\n    // force reflow to put everything in position\n    var f = document.body.offsetHeight; // eslint-disable-line\n\n    children.forEach(function (c) {\n      if (c.data.moved) {\n        var el = c.elm;\n        var s = el.style;\n        addTransitionClass(el, moveClass);\n        s.transform = s.WebkitTransform = s.transitionDuration = '';\n        el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {\n          if (!e || /transform$/.test(e.propertyName)) {\n            el.removeEventListener(transitionEndEvent, cb);\n            el._moveCb = null;\n            removeTransitionClass(el, moveClass);\n          }\n        });\n      }\n    });\n  },\n\n  methods: {\n    hasMove: function hasMove (el, moveClass) {\n      /* istanbul ignore if */\n      if (!hasTransition) {\n        return false\n      }\n      if (this._hasMove != null) {\n        return this._hasMove\n      }\n      addTransitionClass(el, moveClass);\n      var info = getTransitionInfo(el);\n      removeTransitionClass(el, moveClass);\n      return (this._hasMove = info.hasTransform)\n    }\n  }\n};\n\nfunction callPendingCbs (c) {\n  /* istanbul ignore if */\n  if (c.elm._moveCb) {\n    c.elm._moveCb();\n  }\n  /* istanbul ignore if */\n  if (c.elm._enterCb) {\n    c.elm._enterCb();\n  }\n}\n\nfunction recordPosition (c) {\n  c.data.newPos = c.elm.getBoundingClientRect();\n}\n\nfunction applyTranslation (c) {\n  var oldPos = c.data.pos;\n  var newPos = c.data.newPos;\n  var dx = oldPos.left - newPos.left;\n  var dy = oldPos.top - newPos.top;\n  if (dx || dy) {\n    c.data.moved = true;\n    var s = c.elm.style;\n    s.transform = s.WebkitTransform = \"translate(\" + dx + \"px,\" + dy + \"px)\";\n    s.transitionDuration = '0s';\n  }\n}\n\nvar platformComponents = {\n  Transition: Transition,\n  TransitionGroup: TransitionGroup\n};\n\n/*  */\n\n// install platform specific utils\nVue$3.config.isUnknownElement = isUnknownElement;\nVue$3.config.isReservedTag = isReservedTag;\nVue$3.config.getTagNamespace = getTagNamespace;\nVue$3.config.mustUseProp = mustUseProp;\n\n// install platform runtime directives & components\nextend(Vue$3.options.directives, platformDirectives);\nextend(Vue$3.options.components, platformComponents);\n\n// install platform patch function\nVue$3.prototype.__patch__ = inBrowser ? patch$1 : noop;\n\n// wrap mount\nVue$3.prototype.$mount = function (\n  el,\n  hydrating\n) {\n  el = el && inBrowser ? query(el) : undefined;\n  return this._mount(el, hydrating)\n};\n\nif (process.env.NODE_ENV !== 'production' &&\n    inBrowser && typeof console !== 'undefined') {\n  console[console.info ? 'info' : 'log'](\n    \"You are running Vue in development mode.\\n\" +\n    \"Make sure to turn on production mode when deploying for production.\\n\" +\n    \"See more tips at https://vuejs.org/guide/deployment.html\"\n  );\n}\n\n// devtools global hook\n/* istanbul ignore next */\nsetTimeout(function () {\n  if (config.devtools) {\n    if (devtools) {\n      devtools.emit('init', Vue$3);\n    } else if (\n      process.env.NODE_ENV !== 'production' &&\n      inBrowser && !isEdge && /Chrome\\/\\d+/.test(window.navigator.userAgent)\n    ) {\n      console[console.info ? 'info' : 'log'](\n        'Download the Vue Devtools extension for a better development experience:\\n' +\n        'https://github.com/vuejs/vue-devtools'\n      );\n    }\n  }\n}, 0);\n\n/*  */\n\n// check whether current browser encodes a char inside attribute values\nfunction shouldDecode (content, encoded) {\n  var div = document.createElement('div');\n  div.innerHTML = \"<div a=\\\"\" + content + \"\\\">\";\n  return div.innerHTML.indexOf(encoded) > 0\n}\n\n// #3663\n// IE encodes newlines inside attribute values while other browsers don't\nvar shouldDecodeNewlines = inBrowser ? shouldDecode('\\n', '&#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 = 17\n// module chunks = 0","var toString = {}.toString;\n\nmodule.exports = function(it){\n  return toString.call(it).slice(8, -1);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_cof.js\n// module id = 18\n// module chunks = 0","// optional / simple context binding\nvar aFunction = require('./_a-function');\nmodule.exports = function(fn, that, length){\n  aFunction(fn);\n  if(that === undefined)return fn;\n  switch(length){\n    case 1: return function(a){\n      return fn.call(that, a);\n    };\n    case 2: return function(a, b){\n      return fn.call(that, a, b);\n    };\n    case 3: return function(a, b, c){\n      return fn.call(that, a, b, c);\n    };\n  }\n  return function(/* ...args */){\n    return fn.apply(that, arguments);\n  };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_ctx.js\n// module id = 19\n// module chunks = 0","var isObject = require('./_is-object')\n  , document = require('./_global').document\n  // in old IE typeof document.createElement is 'object'\n  , is = isObject(document) && isObject(document.createElement);\nmodule.exports = function(it){\n  return is ? document.createElement(it) : {};\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_dom-create.js\n// module id = 20\n// module chunks = 0","// IE 8- don't enum bug keys\nmodule.exports = (\n  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'\n).split(',');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_enum-bug-keys.js\n// module id = 21\n// module chunks = 0","var global    = require('./_global')\n  , core      = require('./_core')\n  , ctx       = require('./_ctx')\n  , hide      = require('./_hide')\n  , PROTOTYPE = 'prototype';\n\nvar $export = function(type, name, source){\n  var IS_FORCED = type & $export.F\n    , IS_GLOBAL = type & $export.G\n    , IS_STATIC = type & $export.S\n    , IS_PROTO  = type & $export.P\n    , IS_BIND   = type & $export.B\n    , IS_WRAP   = type & $export.W\n    , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})\n    , expProto  = exports[PROTOTYPE]\n    , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]\n    , key, own, out;\n  if(IS_GLOBAL)source = name;\n  for(key in source){\n    // contains in native\n    own = !IS_FORCED && target && target[key] !== undefined;\n    if(own && key in exports)continue;\n    // export native or passed\n    out = own ? target[key] : source[key];\n    // prevent global pollution for namespaces\n    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]\n    // bind timers to global for call from export context\n    : IS_BIND && own ? ctx(out, global)\n    // wrap global constructors for prevent change them in library\n    : IS_WRAP && target[key] == out ? (function(C){\n      var F = function(a, b, c){\n        if(this instanceof C){\n          switch(arguments.length){\n            case 0: return new C;\n            case 1: return new C(a);\n            case 2: return new C(a, b);\n          } return new C(a, b, c);\n        } return C.apply(this, arguments);\n      };\n      F[PROTOTYPE] = C[PROTOTYPE];\n      return F;\n    // make static versions for prototype methods\n    })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;\n    // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%\n    if(IS_PROTO){\n      (exports.virtual || (exports.virtual = {}))[key] = out;\n      // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%\n      if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out);\n    }\n  }\n};\n// type bitmap\n$export.F = 1;   // forced\n$export.G = 2;   // global\n$export.S = 4;   // static\n$export.P = 8;   // proto\n$export.B = 16;  // bind\n$export.W = 32;  // wrap\n$export.U = 64;  // safe\n$export.R = 128; // real proto method for `library` \nmodule.exports = $export;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_export.js\n// module id = 22\n// module chunks = 0","module.exports = function(exec){\n  try {\n    return !!exec();\n  } catch(e){\n    return true;\n  }\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_fails.js\n// module id = 23\n// module chunks = 0","var def = require('./_object-dp').f\n  , has = require('./_has')\n  , TAG = require('./_wks')('toStringTag');\n\nmodule.exports = function(it, tag, stat){\n  if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_set-to-string-tag.js\n// module id = 24\n// module chunks = 0","var global = require('./_global')\n  , SHARED = '__core-js_shared__'\n  , store  = global[SHARED] || (global[SHARED] = {});\nmodule.exports = function(key){\n  return store[key] || (store[key] = {});\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_shared.js\n// module id = 25\n// module chunks = 0","// to indexed object, toObject with fallback for non-array-like ES3 strings\nvar IObject = require('./_iobject')\n  , defined = require('./_defined');\nmodule.exports = function(it){\n  return IObject(defined(it));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-iobject.js\n// module id = 26\n// module chunks = 0","// 7.1.15 ToLength\nvar toInteger = require('./_to-integer')\n  , min       = Math.min;\nmodule.exports = function(it){\n  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-length.js\n// module id = 27\n// module chunks = 0","// 7.1.13 ToObject(argument)\nvar defined = require('./_defined');\nmodule.exports = function(it){\n  return Object(defined(it));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-object.js\n// module id = 28\n// module chunks = 0","var id = 0\n  , px = Math.random();\nmodule.exports = function(key){\n  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_uid.js\n// module id = 29\n// module chunks = 0","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 = 30\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 = 43\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 = 44\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 = 45\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 = 46\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 = 47\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 = 48\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 = 49\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 = 50\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 = 51\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 = 52\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 = 53\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 = 54\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 = 55\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 = 56\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 = 57\n// module chunks = 0","module.exports = true;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_library.js\n// module id = 58\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 = 59\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 = 60\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 = 61\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 = 62\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 = 63\n// module chunks = 0","module.exports = require('./_hide');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_redefine.js\n// module id = 64\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 = 65\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 = 66\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 = 67\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 = 68\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 = 69\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 = 70\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 = 78\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 = 96\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 = 97\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 = 98\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 = 100\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 = 101\n// module chunks = 0"],"sourceRoot":""}