{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./node_modules/youtube-iframe/index.js","webpack:///(webpack)/buildin/module.js","webpack:///./node_modules/dom7/node_modules/ssr-window/dist/ssr-window.esm.js","webpack:///./node_modules/dom7/dist/dom7.modular.js","webpack:///./node_modules/ssr-window/dist/ssr-window.esm.js","webpack:///./node_modules/swiper/dist/js/swiper.esm.bundle.js","webpack:///./Static/javascript/helpers/nodeListToArray.ts","webpack:///(webpack)/buildin/global.js","webpack:///./Static/javascript/pages/homepage/index.ts","webpack:///./Static/javascript/modules/multi-carousel.ts","webpack:///./node_modules/lodash/lodash.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","window","YouTubeIframeLoader","src","loading","loaded","listeners","load","callback","_this","this","push","setTimeout","done","onYouTubeIframeAPIReady","script","document","createElement","type","body","appendChild","length","pop","YT","webpackPolyfill","deprecate","paths","children","isObject","obj","constructor","extend","target","keys","forEach","doc","ssrDocument","addEventListener","removeEventListener","activeElement","blur","nodeName","querySelector","querySelectorAll","getElementById","createEvent","initEvent","childNodes","style","setAttribute","getElementsByTagName","createElementNS","importNode","location","hash","host","hostname","href","origin","pathname","protocol","search","win","navigator","userAgent","history","replaceState","pushState","go","back","CustomEvent","getComputedStyle","getPropertyValue","Image","Date","screen","clearTimeout","matchMedia","Dom7","arr","self","$","selector","context","els","tempParent","html","trim","indexOf","toCreate","innerHTML","match","split","nodeType","unique","uniqueArray","fn","Class","Methods","addClass","className","classes","j","classList","add","removeClass","remove","hasClass","contains","toggleClass","toggle","attr","attrs","arguments","getAttribute","attrName","removeAttr","removeAttribute","data","el","dom7ElementDataStorage","dataKey","transform","elStyle","webkitTransform","transition","duration","webkitTransitionDuration","transitionDuration","on","args","eventType","targetSelector","listener","capture","handleLiveEvent","e","eventData","dom7EventData","unshift","is","apply","parents","k","handleEvent","undefined","events","event","dom7LiveListeners","proxyListener","dom7Listeners","off","handlers","handler","dom7proxy","splice","trigger","evt","detail","bubbles","cancelable","filter","dataIndex","dispatchEvent","transitionEnd","dom","fireCallBack","outerWidth","includeMargins","styles","offsetWidth","parseFloat","outerHeight","offsetHeight","offset","box","getBoundingClientRect","clientTop","clientLeft","scrollTop","scrollY","scrollLeft","scrollX","top","left","css","props","prop","each","text","textContent","compareWith","matches","webkitMatchesSelector","msMatchesSelector","index","child","previousSibling","eq","returnIndex","append","newChild","tempDiv","firstChild","prepend","insertBefore","next","nextElementSibling","nextAll","nextEls","prev","previousElementSibling","prevAll","prevEls","parent","parentNode","closest","find","foundElements","found","removeChild","toAdd","methodName","Utils","nextTick","delay","now","axis","matrix","curTransform","transformMatrix","curStyle","WebKitCSSMatrix","map","a","replace","join","MozTransform","OTransform","MsTransform","msTransform","toString","m41","m42","url","query","params","param","urlToParse","paramsPart","decodeURIComponent","to","nextSource","keysArray","nextIndex","len","nextKey","desc","getOwnPropertyDescriptor","testDiv","touch","Modernizr","maxTouchPoints","DocumentTouch","pointerEvents","pointerEnabled","PointerEvent","prefixedPointerEvents","msPointerEnabled","transforms3d","csstransforms3d","flexbox","observer","passiveListener","supportsPassive","opts","gestures","isIE","isEdge","isSafari","ua","toLowerCase","isUiWebView","test","SwiperClass","eventsListeners","eventName","priority","method","onceHandler","f7proxy","eventHandler","Array","isArray","slice","instanceParams","instance","moduleName","modulesParams","moduleParams","modulePropName","moduleProp","moduleEventName","components","use","proto","static","install","installModule","update","updateSize","swiper","width","height","$el","clientWidth","clientHeight","isHorizontal","isVertical","parseInt","size","updateSlides","$wrapperEl","swiperSize","rtlTranslate","rtl","wrongRTL","isVirtual","virtual","enabled","previousSlidesLength","slides","slideClass","slidesLength","snapGrid","slidesGrid","slidesSizesGrid","offsetBefore","slidesOffsetBefore","offsetAfter","slidesOffsetAfter","previousSnapGridLength","previousSlidesGridLength","slidesNumberEvenToRows","slideSize","spaceBetween","slidePosition","prevSlideSize","virtualSize","marginLeft","marginTop","marginRight","marginBottom","slidesPerColumn","Math","floor","ceil","slidesPerView","slidesPerColumnFill","max","slidesPerRow","numFullColumns","slide","newSlideOrderIndex","column","row","slidesPerGroup","groupIndex","order","slideStyles","currentTransform","currentWebKitTransform","roundLengths","paddingLeft","paddingRight","boxSizing","paddingTop","paddingBottom","swiperSlideSize","centeredSlides","abs","newSlidesGrid","effect","setWrapperSize","slidesGridItem","centerInsufficientSlides","allSlidesSize","slideSizeValue","allSlidesOffset","snap","snapIndex","emit","watchOverflow","checkOverflow","watchSlidesProgress","watchSlidesVisibility","updateSlidesOffset","updateAutoHeight","speed","activeSlides","newHeight","setTransition","activeIndex","swiperSlideOffset","offsetLeft","offsetTop","updateSlidesProgress","translate","offsetCenter","slideVisibleClass","visibleSlidesIndexes","visibleSlides","slideProgress","minTranslate","slideBefore","slideAfter","progress","updateProgress","translatesDiff","maxTranslate","isBeginning","isEnd","wasBeginning","wasEnd","updateSlidesClasses","realIndex","activeSlide","slideActiveClass","slideNextClass","slidePrevClass","slideDuplicateActiveClass","slideDuplicateNextClass","slideDuplicatePrevClass","loop","slideDuplicateClass","nextSlide","prevSlide","updateActiveIndex","newActiveIndex","previousIndex","previousRealIndex","previousSnapIndex","normalizeSlideIndex","initialized","runCallbacksOnInit","updateClickedSlide","slideFound","clickedSlide","clickedIndex","slideToClickedSlide","getTranslate","virtualTranslate","currentTranslate","setTranslate","byController","newProgress","x","y","previousTranslate","transitionStart","runCallbacks","direction","autoHeight","dir","animating","slideTo","internal","slideIndex","preventInteractionOnTransition","initialSlide","allowSlideNext","allowSlidePrev","onSlideToWrapperTransitionEnd","destroyed","slideToLoop","newIndex","loopedSlides","slideNext","loopFix","_clientLeft","slidePrev","normalize","val","normalizedTranslate","normalizedSnapGrid","prevSnap","prevIndex","slideReset","slideToClosest","currentSnap","slidesPerViewDynamic","slideToIndex","loopCreate","loopFillGroupWithBlank","blankSlidesNum","blankNode","slideBlankClass","loopAdditionalSlides","prependSlides","appendSlides","cloneNode","diff","loopDestroy","grabCursor","setGrabCursor","moving","simulateTouch","isLocked","cursor","unsetGrabCursor","manipulation","appendSlide","prependSlide","addSlide","activeIndexBuffer","baseLength","slidesBuffer","currentSlide","removeSlide","slidesIndexes","indexToRemove","removeAllSlides","device","ios","android","androidChrome","desktop","windows","iphone","ipod","ipad","cordova","phonegap","os","osVersion","webView","osVersionArr","metaViewport","minimalUi","pixelRatio","devicePixelRatio","onTouchStart","touchEventsData","touches","originalEvent","isTouchEvent","which","button","isTouched","isMoved","noSwiping","noSwipingSelector","noSwipingClass","allowClick","swipeHandler","currentX","targetTouches","pageX","currentY","pageY","startX","startY","edgeSwipeDetection","iOSEdgeSwipeDetection","edgeSwipeThreshold","iOSEdgeSwipeThreshold","allowTouchCallbacks","isScrolling","startMoving","touchStartTime","swipeDirection","threshold","allowThresholdMove","preventDefault","formElements","shouldPreventDefault","allowTouchMove","touchStartPreventDefault","touchStartForcePreventDefault","onTouchMove","preventedByNestedSwiper","touchReleaseOnEdges","diffX","diffY","sqrt","touchAngle","atan2","PI","touchMoveStopPropagation","nested","stopPropagation","startTranslate","allowMomentumBounce","touchRatio","disableParentSwiper","resistanceRatio","resistance","followFinger","freeMode","velocities","position","time","onTouchEnd","touchEndTime","timeDiff","lastClickTime","clickTimeout","currentPos","freeModeMomentum","lastMoveEvent","velocityEvent","distance","velocity","freeModeMinimumVelocity","freeModeMomentumVelocityRatio","momentumDuration","freeModeMomentumRatio","momentumDistance","newPosition","afterBouncePosition","doBounce","bounceAmount","freeModeMomentumBounceRatio","needsLoopFix","freeModeMomentumBounce","freeModeSticky","once","longSwipesMs","stopIndex","groupSize","ratio","longSwipes","longSwipesRatio","shortSwipes","onResize","breakpoints","setBreakpoint","newTranslate","min","autoplay","running","paused","run","preventClicks","preventClicksPropagation","stopImmediatePropagation","defaults","init","touchEventsTarget","breakpointsInverse","uniqueNavElements","preloadImages","updateOnImagesReady","passiveListeners","containerModifierClass","wrapperClass","prototypes","attachEvents","touchEvents","wrapperEl","onClick","start","passive","move","end","detachEvents","breakpoint","getBreakpoint","currentBreakpoint","breakpointOnlyParams","paramValue","breakpointParams","originalParams","directionChanged","needsReLoop","changeDirection","points","point","sort","b","innerWidth","wasLocked","navigation","addClasses","classNames","suffixes","suffix","removeClasses","images","loadImage","imageEl","srcset","sizes","checkForComplete","image","onReady","complete","onload","onerror","imagesLoaded","imagesToLoad","currentSrc","extendedDefaults","super","prototypeGroup","protoMethod","moduleParamName","swiperParams","useModulesParams","passedParams","swipers","containerEl","newParams","touchEventsTouch","touchEventsDesktop","useModules","spv","breakLoop","translateValue","translated","newDirection","needUpdate","currentDirection","slideEl","deleteInstance","cleanStyles","deleteProps","newDefaults","Device$1","Support$1","support","Browser$1","browser","Resize","resize","resizeHandler","orientationChangeHandler","Observer","func","MutationObserver","WebkitMutationObserver","options","ObserverFunc","mutations","observerUpdate","requestAnimationFrame","observe","attributes","childList","characterData","observers","observeParents","containerParents","attach","observeSlideChildren","disconnect","Observer$1","destroy","Virtual","force","addSlidesBefore","addSlidesAfter","from","previousFrom","previousTo","previousSlidesGrid","renderSlide","previousOffset","offsetProp","slidesAfter","slidesBefore","onRendered","lazy","renderExternal","slidesToRender","prependIndexes","appendIndexes","cache","$slideEl","numberOfNewSlides","newCache","cachedIndex","Virtual$1","overwriteParams","Keyboard","kc","keyCode","charCode","shiftKey","altKey","ctrlKey","metaKey","keyboard","onlyInViewport","inView","windowWidth","windowHeight","innerHeight","swiperOffset","swiperCoord","returnValue","handle","Keyboard$1","enable","disable","Mousewheel","lastScrollTime","isSupported","element","implementation","hasFeature","isEventSupported","sX","sY","pX","pY","wheelDelta","wheelDeltaY","wheelDeltaX","HORIZONTAL_AXIS","deltaY","deltaX","deltaMode","spinX","spinY","pixelX","pixelY","mouseEntered","mousewheel","releaseOnEdges","delta","rtlFactor","forceToAxis","invert","sensitivity","timeout","autoplayDisableOnInteraction","stop","getTime","eventsTarged","handleMouseEnter","handleMouseLeave","Navigation","$nextEl","$prevEl","disabledClass","lockClass","nextEl","prevEl","onNextClick","onPrevClick","Pagination","pagination","current","total","paginationType","bullets","firstIndex","lastIndex","midIndex","dynamicBullets","bulletSize","dynamicMainBullets","dynamicBulletIndex","bulletActiveClass","bullet","$bullet","bulletIndex","$firstDisplayedBullet","$lastDisplayedBullet","dynamicBulletsLength","bulletsOffset","currentClass","formatFractionCurrent","totalClass","formatFractionTotal","progressbarDirection","progressbarOpposite","scale","scaleX","scaleY","progressbarFillClass","renderCustom","paginationHTML","numberOfBullets","renderBullet","bulletClass","bulletElement","renderFraction","renderProgressbar","clickable","clickableClass","modifierClass","progressbarOppositeClass","hiddenClass","Scrollbar","scrollbar","dragSize","trackSize","$dragEl","newSize","newPos","hide","opacity","divider","moveDivider","display","clientX","clientY","dragStartPos","positionRatio","getPointerPosition","setDragPosition","dragTimeout","snapOnRelease","activeListener","onDragStart","onDragMove","onDragEnd","$swiperEl","dragClass","dragEl","draggable","enableDraggable","disableDraggable","Parallax","currentOpacity","currentScale","parallax","setTransform","parallaxEl","$parallaxEl","parallaxDuration","Zoom","x1","y1","x2","y2","zoom","gesture","fakeGestureTouched","fakeGestureMoved","scaleStart","getDistanceBetweenTouches","$imageEl","$imageWrapEl","containerClass","maxRatio","isScaling","scaleMove","minRatio","changedTouches","touchesStart","slideWidth","slideHeight","scaledWidth","scaledHeight","minX","maxX","minY","maxY","touchesCurrent","prevPositionX","prevPositionY","prevTime","momentumDurationX","momentumDurationY","momentumDistanceX","newPositionX","momentumDistanceY","newPositionY","out","in","touchX","touchY","offsetX","offsetY","translateX","translateY","imageWidth","imageHeight","translateMinX","translateMinY","translateMaxX","translateMaxY","zoomedSlideClass","onGestureStart","onGestureChange","onGestureEnd","Lazy","loadInDuplicate","$images","elementClass","loadedClass","loadingClass","imageIndex","background","preloaderClass","slideOriginalIndex","originalSlide","loadInSlide","duplicatedSlide","slideExist","initialImageLoaded","elIndex","loadPrevNext","loadPrevNextAmount","amount","maxIndex","minIndex","Controller","LinearSpline","binarySearch","guess","array","i1","i3","interpolate","controller","spline","controlled","control","multiplier","controlledTranslate","setControlledTranslate","by","getInterpolateFunction","inverse","setControlledTransition","a11y","makeElFocusable","addElRole","role","addElLabel","label","disableEl","enableEl","$targetEl","notify","lastSlideMessage","nextSlideMessage","firstSlideMessage","prevSlideMessage","click","message","notification","liveRegion","bulletEl","$bulletEl","paginationBulletMessage","onEnterKey","History","hashNavigation","getPathValues","scrollToSlide","setHistoryPopState","pathArray","part","slugify","includes","currentState","state","HashNavigation","newHash","watchState","onHashCange","Autoplay","$activeSlideEl","reverseDirection","stopOnLastSlide","waitForTransition","onTransitionEnd","Fade","tx","ty","slideOpacity","fadeEffect","crossFade","eventTriggered","triggerEvents","Cube","swiperWidth","swiperHeight","cubeEffect","$cubeShadowEl","wrapperRotate","shadow","slideAngle","round","tz","slideShadows","shadowBefore","shadowAfter","shadowOffset","shadowScale","shadowAngle","sin","cos","scale1","scale2","zFactor","Flip","flipEffect","limitRotation","rotateY","rotateX","zIndex","Coverflow","coverflowEffect","center","rotate","depth","offsetMultiplier","modifier","translateZ","stretch","slideTransform","$shadowBeforeEl","$shadowAfterEl","perspectiveOrigin","Thumbs","thumbs","thumbsParams","swiperCreated","thumbsContainerClass","onThumbClick","thumbsSwiper","slideThumbActiveClass","currentIndex","initial","newThumbsIndex","currentThumbsIndex","prevThumbsIndex","nextThumbsIndex","thumbsToActivate","thumbActiveClass","hideOnClick","isHidden","number","render","loadOnTransitionStart","notificationClass","updateNavigation","updatePagination","setHistory","setHash","disableOnInteraction","pause","nodeList","g","Function","gallery","multiCarousel","homepageCarouselContainer","secondaryCarousel","primaryCarousel","secondarySlider","autoplayVideo","autoPauseVideos","primarySlider","slideChangeTransitionEnd","handleSlide","videos","initCallback","initVisibleVideos","videoControlButtons","nodeListToArray","setupVideoButtonsEventListener","slider","totalSlideCount","setActiveSlides","debounce","previousSlide","pauseInactiveVideos","activeSlideCount","inactiveSlides","enableSlide","disableSlide","slideInfo","activeSlideVideo","youtubeInit","nativeVideoInit","togglePlayerState","pauseVid","youtubeIframe","slideControl","playerID","id","youtubePlayer","Player","playerVars","rel","showinfo","ecver","playVid","getPlayerState","togglePlayButton","player","videoElement","videoSource","video","playVideo","play","pauseVideo","boolean","item","tabIndex","hasAttribute","FUNC_ERROR_TEXT","PLACEHOLDER","wrapFlags","argsTag","arrayTag","boolTag","dateTag","errorTag","funcTag","genTag","mapTag","numberTag","objectTag","regexpTag","setTag","stringTag","symbolTag","weakMapTag","arrayBufferTag","dataViewTag","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint16Tag","uint32Tag","reEmptyStringLeading","reEmptyStringMiddle","reEmptyStringTrailing","reEscapedHtml","reUnescapedHtml","reHasEscapedHtml","RegExp","source","reHasUnescapedHtml","reEscape","reEvaluate","reInterpolate","reIsDeepProp","reIsPlainProp","rePropName","reRegExpChar","reHasRegExpChar","reTrimStart","reWhitespace","reWrapComment","reWrapDetails","reSplitDetails","reAsciiWord","reForbiddenIdentifierChars","reEscapeChar","reEsTemplate","reFlags","reIsBadHex","reIsBinary","reIsHostCtor","reIsOctal","reIsUint","reLatin","reNoMatch","reUnescapedString","rsComboRange","rsComboMarksRange","rsBreakRange","rsMathOpRange","rsAstral","rsBreak","rsCombo","rsDigits","rsDingbat","rsLower","rsMisc","rsFitz","rsNonAstral","rsRegional","rsSurrPair","rsUpper","rsMiscLower","rsMiscUpper","reOptMod","rsSeq","rsEmoji","rsSymbol","reApos","reComboMark","reUnicode","reUnicodeWord","reHasUnicode","reHasUnicodeWord","contextProps","templateCounter","typedArrayTags","cloneableTags","stringEscapes","freeParseFloat","freeParseInt","freeGlobal","global","freeSelf","root","freeExports","freeModule","moduleExports","freeProcess","process","nodeUtil","types","require","binding","nodeIsArrayBuffer","isArrayBuffer","nodeIsDate","isDate","nodeIsMap","isMap","nodeIsRegExp","isRegExp","nodeIsSet","isSet","nodeIsTypedArray","isTypedArray","thisArg","arrayAggregator","setter","iteratee","accumulator","arrayEach","arrayEachRight","arrayEvery","predicate","arrayFilter","resIndex","result","arrayIncludes","baseIndexOf","arrayIncludesWith","comparator","arrayMap","arrayPush","values","arrayReduce","initAccum","arrayReduceRight","arraySome","asciiSize","baseProperty","baseFindKey","collection","eachFunc","baseFindIndex","fromIndex","fromRight","strictIndexOf","baseIsNaN","baseIndexOfWith","baseMean","baseSum","basePropertyOf","baseReduce","baseTimes","baseTrim","string","trimmedEndIndex","baseUnary","baseValues","cacheHas","has","charsStartIndex","strSymbols","chrSymbols","charsEndIndex","countHolders","placeholder","deburrLetter","escapeHtmlChar","escapeStringChar","chr","hasUnicode","mapToArray","overArg","arg","replaceHolders","setToArray","set","setToPairs","stringSize","unicodeSize","stringToArray","unicodeToArray","asciiToArray","charAt","unescapeHtmlChar","_","runInContext","uid","pick","Error","String","TypeError","arrayProto","funcProto","objectProto","coreJsData","funcToString","idCounter","maskSrcKey","exec","IE_PROTO","nativeObjectToString","objectCtorString","oldDash","reIsNative","Buffer","Uint8Array","allocUnsafe","getPrototype","getPrototypeOf","objectCreate","propertyIsEnumerable","spreadableSymbol","isConcatSpreadable","symIterator","iterator","symToStringTag","getNative","ctxClearTimeout","ctxNow","ctxSetTimeout","nativeCeil","nativeFloor","nativeGetSymbols","getOwnPropertySymbols","nativeIsBuffer","isBuffer","nativeIsFinite","isFinite","nativeJoin","nativeKeys","nativeMax","nativeMin","nativeNow","nativeParseInt","nativeRandom","random","nativeReverse","reverse","DataView","Map","Promise","Set","WeakMap","nativeCreate","metaMap","realNames","dataViewCtorString","toSource","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","symbolProto","symbolValueOf","valueOf","symbolToString","lodash","isObjectLike","LazyWrapper","LodashWrapper","wrapperClone","baseCreate","baseLodash","chainAll","__wrapped__","__actions__","__chain__","__index__","__values__","__dir__","__filtered__","__iteratees__","__takeCount__","__views__","Hash","entries","clear","entry","ListCache","MapCache","SetCache","__data__","Stack","arrayLikeKeys","inherited","isArr","isArg","isArguments","isBuff","isType","skipIndexes","isIndex","arraySample","baseRandom","arraySampleSize","shuffleSelf","copyArray","baseClamp","arrayShuffle","assignMergeValue","baseAssignValue","assignValue","objValue","assocIndexOf","baseAggregator","baseEach","baseAssign","copyObject","baseAt","skip","lower","upper","baseClone","bitmask","customizer","stack","isDeep","isFlat","isFull","input","initCloneArray","tag","getTag","isFunc","cloneBuffer","initCloneObject","getSymbolsIn","copySymbolsIn","keysIn","baseAssignIn","getSymbols","copySymbols","Ctor","cloneArrayBuffer","dataView","buffer","byteOffset","byteLength","cloneDataView","cloneTypedArray","regexp","cloneRegExp","symbol","initCloneByTag","stacked","subValue","getAllKeysIn","getAllKeys","baseConformsTo","baseDelay","wait","baseDifference","isCommon","valuesLength","outer","computed","valuesIndex","templateSettings","getMapData","pairs","LARGE_ARRAY_SIZE","createBaseEach","baseForOwn","baseEachRight","baseForOwnRight","baseEvery","baseExtremum","isSymbol","baseFilter","baseFlatten","isStrict","isFlattenable","baseFor","createBaseFor","baseForRight","baseFunctions","isFunction","baseGet","path","castPath","toKey","baseGetAllKeys","keysFunc","symbolsFunc","baseGetTag","isOwn","unmasked","getRawTag","objectToString","baseGt","other","baseHas","baseHasIn","baseIntersection","arrays","othLength","othIndex","caches","maxLength","Infinity","seen","baseInvoke","last","baseIsArguments","baseIsEqual","equalFunc","objIsArr","othIsArr","objTag","othTag","objIsObj","othIsObj","isSameTag","equalArrays","convert","isPartial","equalByTag","objIsWrapped","othIsWrapped","objUnwrapped","othUnwrapped","objProps","objLength","objStacked","othStacked","skipCtor","othValue","compared","objCtor","othCtor","equalObjects","baseIsEqualDeep","baseIsMatch","matchData","noCustomizer","srcValue","COMPARE_PARTIAL_FLAG","baseIsNative","baseIteratee","identity","baseMatchesProperty","baseMatches","baseKeys","isPrototype","baseKeysIn","nativeKeysIn","isProto","baseLt","baseMap","isArrayLike","getMatchData","matchesStrictComparable","isKey","isStrictComparable","hasIn","baseMerge","srcIndex","mergeFunc","safeGet","newValue","isTyped","isArrayLikeObject","isPlainObject","toPlainObject","baseMergeDeep","baseNth","baseOrderBy","iteratees","orders","getIteratee","comparer","baseSortBy","objCriteria","criteria","othCriteria","ordersLength","compareAscending","compareMultiple","basePickBy","baseSet","basePullAll","basePullAt","indexes","previous","baseUnset","baseRepeat","baseRest","setToString","overRest","baseSample","baseSampleSize","baseSetData","baseSetToString","constant","baseShuffle","baseSlice","baseSome","baseSortedIndex","retHighest","low","high","MAX_ARRAY_LENGTH","mid","baseSortedIndexBy","valIsNaN","valIsNull","valIsSymbol","valIsUndefined","othIsDefined","othIsNull","othIsReflexive","othIsSymbol","setLow","baseSortedUniq","baseToNumber","baseToString","baseUniq","createSet","seenIndex","baseUpdate","updater","baseWhile","isDrop","baseWrapperValue","actions","action","baseXor","baseZipObject","assignFunc","valsLength","castArrayLikeObject","castFunction","stringToPath","castRest","castSlice","copy","arrayBuffer","typedArray","valIsDefined","valIsReflexive","composeArgs","partials","holders","isCurried","argsIndex","argsLength","holdersLength","leftIndex","leftLength","rangeLength","isUncurried","composeArgsRight","holdersIndex","rightIndex","rightLength","isNew","createAggregator","initializer","createAssigner","assigner","sources","guard","isIterateeCall","iterable","createCaseFirst","trailing","createCompounder","words","deburr","createCtor","thisBinding","createFind","findIndexFunc","createFlow","flatRest","funcs","prereq","thru","wrapper","getFuncName","funcName","getData","isLaziable","plant","createHybrid","partialsRight","holdersRight","argPos","ary","arity","isAry","isBind","isBindKey","isFlip","getHolder","holdersCount","newHolders","createRecurry","reorder","createInverter","toIteratee","baseInverter","createMathOperation","operator","defaultValue","createOver","arrayFunc","createPadding","chars","charsLength","createRange","step","toFinite","baseRange","createRelationalOperation","toNumber","wrapFunc","isCurry","newData","setData","setWrapToString","createRound","precision","toInteger","pair","noop","createToPairs","baseToPairs","createWrap","srcBitmask","newBitmask","isCombo","mergeData","createCurry","createPartial","createBind","customDefaultsAssignIn","customDefaultsMerge","customOmitClone","arrLength","arrStacked","arrValue","flatten","otherFunc","getValue","stubArray","hasPath","hasFunc","isLength","ArrayBuffer","resolve","ctorString","isMaskable","stubFalse","otherArgs","oldArray","shortOut","reference","details","insertWrapDetails","updateWrapDetails","getWrapDetails","count","lastCalled","stamp","remaining","rand","memoize","memoizeCapped","charCodeAt","quote","subString","clone","difference","differenceBy","differenceWith","findIndex","findLastIndex","head","intersection","mapped","intersectionBy","intersectionWith","pull","pullAll","pullAt","union","unionBy","unionWith","unzip","group","unzipWith","without","xor","xorBy","xorWith","zip","zipWith","chain","interceptor","wrapperAt","countBy","findLast","forEachRight","groupBy","invokeMap","keyBy","partition","sortBy","before","bindKey","WRAP_BIND_FLAG","lastArgs","lastThis","maxWait","timerId","lastCallTime","lastInvokeTime","leading","maxing","invokeFunc","leadingEdge","timerExpired","shouldInvoke","timeSinceLastCall","trailingEdge","timeWaiting","remainingWait","debounced","isInvoking","cancel","flush","defer","resolver","memoized","Cache","negate","overArgs","transforms","funcsLength","partial","partialRight","rearg","gt","gte","isError","isInteger","isNumber","isString","lt","lte","toArray","iteratorToArray","remainder","toLength","isBinary","assign","assignIn","assignInWith","assignWith","at","propsIndex","propsLength","defaultsDeep","mergeWith","invertBy","invoke","merge","omit","CLONE_DEEP_FLAG","basePick","pickBy","toPairs","toPairsIn","camelCase","word","capitalize","upperFirst","kebabCase","lowerCase","lowerFirst","snakeCase","startCase","upperCase","toUpperCase","pattern","hasUnicodeWord","unicodeWords","asciiWords","attempt","bindAll","methodNames","flow","flowRight","methodOf","mixin","over","overEvery","overSome","basePropertyDeep","range","rangeRight","augend","addend","divide","dividend","divisor","multiply","multiplicand","subtract","minuend","subtrahend","after","castArray","chunk","compact","concat","cond","conforms","baseConforms","properties","curry","curryRight","drop","dropRight","dropRightWhile","dropWhile","fill","baseFill","flatMap","flatMapDeep","flatMapDepth","flattenDeep","flattenDepth","flip","fromPairs","functions","functionsIn","mapKeys","mapValues","matchesProperty","nthArg","omitBy","orderBy","propertyOf","pullAllBy","pullAllWith","reject","rest","sampleSize","setWith","shuffle","sortedUniq","sortedUniqBy","separator","limit","spread","tail","take","takeRight","takeRightWhile","takeWhile","tap","throttle","toPath","isArrLike","unary","uniq","uniqBy","uniqWith","unset","updateWith","valuesIn","wrap","zipObject","zipObjectDeep","entriesIn","extendWith","clamp","cloneDeep","cloneDeepWith","cloneWith","conformsTo","defaultTo","endsWith","escape","escapeRegExp","every","findKey","findLastKey","forIn","forInRight","forOwn","forOwnRight","inRange","baseInRange","isBoolean","isElement","isEmpty","isEqual","isEqualWith","isMatch","isMatchWith","isNaN","isNative","isNil","isNull","isSafeInteger","isUndefined","isWeakMap","isWeakSet","lastIndexOf","strictLastIndexOf","maxBy","mean","meanBy","minBy","stubObject","stubString","stubTrue","nth","noConflict","pad","strLength","padEnd","padStart","radix","floating","temp","reduce","reduceRight","repeat","sample","some","sortedIndex","sortedIndexBy","sortedIndexOf","sortedLastIndex","sortedLastIndexBy","sortedLastIndexOf","startsWith","sum","sumBy","template","settings","isEscaping","isEvaluating","imports","importsKeys","importsValues","reDelimiters","evaluate","sourceURL","escapeValue","interpolateValue","esTemplateValue","evaluateValue","variable","times","toLower","toSafeInteger","toUpper","trimEnd","trimStart","truncate","omission","substring","newEnd","unescape","uniqueId","prefix","eachRight","first","VERSION","isFilter","takeName","dropName","checkIteratee","isTaker","lodashFunc","retUnwrapped","isLazy","useLazy","isHybrid","isUnwrapped","onlyLazy","chainName","isRight","view","getView","iterLength","takeCount","iterIndex","commit","wrapped","toJSON"],"mappings":"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","file":"/javascript/pages/homepage/index.bundle.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 65);\n","(function(window) {\n\tvar YouTubeIframeLoader = {\n\t\tsrc: 'https://www.youtube.com/iframe_api',\n\t\tloading: false,\n\t\tloaded: false,\n\t\tlisteners: [],\n\n\t\tload: function(callback) {\n\t\t\tvar _this = this;\n\t\t\tthis.listeners.push(callback);\n\n\t\t\tif(this.loaded) {\n\t\t\t\tsetTimeout(function() {\n\t\t\t\t\t_this.done();\n\t\t\t\t});\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif(this.loading) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tthis.loading = true;\n\n\t\t\twindow.onYouTubeIframeAPIReady = function() {\n\t\t\t\t_this.loaded = true;\n\t\t\t\t_this.done();\n\t\t\t};\n\n\t\t\tvar script = document.createElement('script');\n\t\t\tscript.type = 'text/javascript';\n\t\t\tscript.src = this.src;\n\t\t\tdocument.body.appendChild(script);\n\t\t},\n\n\t\tdone: function() {\n\t\t\tdelete window.onYouTubeIframeAPIReady;\n\n\t\t\twhile(this.listeners.length) {\n\t\t\t\tthis.listeners.pop()(window.YT);\n\t\t\t}\n\t\t}\n\t};\n\n\tif(typeof module !== 'undefined' && module.exports) {\n\t\tmodule.exports = YouTubeIframeLoader;\n\t} else {\n\t\twindow.YouTubeIframeLoader = YouTubeIframeLoader;\n\t}\n}(window));\n","module.exports = function(module) {\n\tif (!module.webpackPolyfill) {\n\t\tmodule.deprecate = function() {};\n\t\tmodule.paths = [];\n\t\t// module.parent = undefined by default\n\t\tif (!module.children) module.children = [];\n\t\tObject.defineProperty(module, \"loaded\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.l;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"id\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.i;\n\t\t\t}\n\t\t});\n\t\tmodule.webpackPolyfill = 1;\n\t}\n\treturn module;\n};\n","/**\n * SSR Window 2.0.0\n * Better handling for window object in SSR environment\n * https://github.com/nolimits4web/ssr-window\n *\n * Copyright 2020, Vladimir Kharlampidi\n *\n * Licensed under MIT\n *\n * Released on: May 12, 2020\n */\n/* eslint-disable no-param-reassign */\nfunction isObject(obj) {\n return (obj !== null &&\n typeof obj === 'object' &&\n 'constructor' in obj &&\n obj.constructor === Object);\n}\nfunction extend(target, src) {\n if (target === void 0) { target = {}; }\n if (src === void 0) { src = {}; }\n Object.keys(src).forEach(function (key) {\n if (typeof target[key] === 'undefined')\n target[key] = src[key];\n else if (isObject(src[key]) &&\n isObject(target[key]) &&\n Object.keys(src[key]).length > 0) {\n extend(target[key], src[key]);\n }\n });\n}\n\nvar doc = typeof document !== 'undefined' ? document : {};\nvar ssrDocument = {\n body: {},\n addEventListener: function () { },\n removeEventListener: function () { },\n activeElement: {\n blur: function () { },\n nodeName: '',\n },\n querySelector: function () {\n return null;\n },\n querySelectorAll: function () {\n return [];\n },\n getElementById: function () {\n return null;\n },\n createEvent: function () {\n return {\n initEvent: function () { },\n };\n },\n createElement: function () {\n return {\n children: [],\n childNodes: [],\n style: {},\n setAttribute: function () { },\n getElementsByTagName: function () {\n return [];\n },\n };\n },\n createElementNS: function () {\n return {};\n },\n importNode: function () {\n return null;\n },\n location: {\n hash: '',\n host: '',\n hostname: '',\n href: '',\n origin: '',\n pathname: '',\n protocol: '',\n search: '',\n },\n};\nextend(doc, ssrDocument);\n\nvar win = typeof window !== 'undefined' ? window : {};\nvar ssrWindow = {\n document: ssrDocument,\n navigator: {\n userAgent: '',\n },\n location: {\n hash: '',\n host: '',\n hostname: '',\n href: '',\n origin: '',\n pathname: '',\n protocol: '',\n search: '',\n },\n history: {\n replaceState: function () { },\n pushState: function () { },\n go: function () { },\n back: function () { },\n },\n CustomEvent: function CustomEvent() {\n return this;\n },\n addEventListener: function () { },\n removeEventListener: function () { },\n getComputedStyle: function () {\n return {\n getPropertyValue: function () {\n return '';\n },\n };\n },\n Image: function () { },\n Date: function () { },\n screen: {},\n setTimeout: function () { },\n clearTimeout: function () { },\n matchMedia: function () {\n return {};\n },\n};\nextend(win, ssrWindow);\n\nexport { doc as document, extend, win as window };\n","/**\n * Dom7 2.1.5\n * Minimalistic JavaScript library for DOM manipulation, with a jQuery-compatible API\n * http://framework7.io/docs/dom.html\n *\n * Copyright 2020, Vladimir Kharlampidi\n * The iDangero.us\n * http://www.idangero.us/\n *\n * Licensed under MIT\n *\n * Released on: May 15, 2020\n */\nimport { document, window } from 'ssr-window';\n\nclass Dom7 {\n constructor(arr) {\n const self = this;\n // Create array-like object\n for (let i = 0; i < arr.length; i += 1) {\n self[i] = arr[i];\n }\n self.length = arr.length;\n // Return collection with methods\n return this;\n }\n}\n\nfunction $(selector, context) {\n const arr = [];\n let i = 0;\n if (selector && !context) {\n if (selector instanceof Dom7) {\n return selector;\n }\n }\n if (selector) {\n // String\n if (typeof selector === 'string') {\n let els;\n let tempParent;\n const html = selector.trim();\n if (html.indexOf('<') >= 0 && html.indexOf('>') >= 0) {\n let toCreate = 'div';\n if (html.indexOf(':~]/)) {\n // Pure ID selector\n els = [document.getElementById(selector.trim().split('#')[1])];\n } else {\n // Other selectors\n els = (context || document).querySelectorAll(selector.trim());\n }\n for (i = 0; i < els.length; i += 1) {\n if (els[i]) arr.push(els[i]);\n }\n }\n } else if (selector.nodeType || selector === window || selector === document) {\n // Node/element\n arr.push(selector);\n } else if (selector.length > 0 && selector[0].nodeType) {\n // Array of elements or instance of Dom\n for (i = 0; i < selector.length; i += 1) {\n arr.push(selector[i]);\n }\n }\n }\n return new Dom7(arr);\n}\n\n$.fn = Dom7.prototype;\n$.Class = Dom7;\n$.Dom7 = Dom7;\n\nfunction unique(arr) {\n const uniqueArray = [];\n for (let i = 0; i < arr.length; i += 1) {\n if (uniqueArray.indexOf(arr[i]) === -1) uniqueArray.push(arr[i]);\n }\n return uniqueArray;\n}\nfunction toCamelCase(string) {\n return string.toLowerCase().replace(/-(.)/g, (match, group1) => group1.toUpperCase());\n}\n\nfunction requestAnimationFrame(callback) {\n if (window.requestAnimationFrame) return window.requestAnimationFrame(callback);\n else if (window.webkitRequestAnimationFrame) return window.webkitRequestAnimationFrame(callback);\n return window.setTimeout(callback, 1000 / 60);\n}\nfunction cancelAnimationFrame(id) {\n if (window.cancelAnimationFrame) return window.cancelAnimationFrame(id);\n else if (window.webkitCancelAnimationFrame) return window.webkitCancelAnimationFrame(id);\n return window.clearTimeout(id);\n}\n\n// Classes and attributes\nfunction addClass(className) {\n if (typeof className === 'undefined') {\n return this;\n }\n const classes = className.split(' ');\n for (let i = 0; i < classes.length; i += 1) {\n for (let j = 0; j < this.length; j += 1) {\n if (typeof this[j] !== 'undefined' && typeof this[j].classList !== 'undefined') this[j].classList.add(classes[i]);\n }\n }\n return this;\n}\nfunction removeClass(className) {\n const classes = className.split(' ');\n for (let i = 0; i < classes.length; i += 1) {\n for (let j = 0; j < this.length; j += 1) {\n if (typeof this[j] !== 'undefined' && typeof this[j].classList !== 'undefined') this[j].classList.remove(classes[i]);\n }\n }\n return this;\n}\nfunction hasClass(className) {\n if (!this[0]) return false;\n return this[0].classList.contains(className);\n}\nfunction toggleClass(className) {\n const classes = className.split(' ');\n for (let i = 0; i < classes.length; i += 1) {\n for (let j = 0; j < this.length; j += 1) {\n if (typeof this[j] !== 'undefined' && typeof this[j].classList !== 'undefined') this[j].classList.toggle(classes[i]);\n }\n }\n return this;\n}\nfunction attr(attrs, value) {\n if (arguments.length === 1 && typeof attrs === 'string') {\n // Get attr\n if (this[0]) return this[0].getAttribute(attrs);\n return undefined;\n }\n\n // Set attrs\n for (let i = 0; i < this.length; i += 1) {\n if (arguments.length === 2) {\n // String\n this[i].setAttribute(attrs, value);\n } else {\n // Object\n // eslint-disable-next-line\n for (const attrName in attrs) {\n this[i][attrName] = attrs[attrName];\n this[i].setAttribute(attrName, attrs[attrName]);\n }\n }\n }\n return this;\n}\n// eslint-disable-next-line\nfunction removeAttr(attr) {\n for (let i = 0; i < this.length; i += 1) {\n this[i].removeAttribute(attr);\n }\n return this;\n}\n// eslint-disable-next-line\nfunction prop(props, value) {\n if (arguments.length === 1 && typeof props === 'string') {\n // Get prop\n if (this[0]) return this[0][props];\n } else {\n // Set props\n for (let i = 0; i < this.length; i += 1) {\n if (arguments.length === 2) {\n // String\n this[i][props] = value;\n } else {\n // Object\n // eslint-disable-next-line\n for (const propName in props) {\n this[i][propName] = props[propName];\n }\n }\n }\n return this;\n }\n}\nfunction data(key, value) {\n let el;\n if (typeof value === 'undefined') {\n el = this[0];\n // Get value\n if (el) {\n if (el.dom7ElementDataStorage && (key in el.dom7ElementDataStorage)) {\n return el.dom7ElementDataStorage[key];\n }\n\n const dataKey = el.getAttribute(`data-${key}`);\n if (dataKey) {\n return dataKey;\n }\n return undefined;\n }\n return undefined;\n }\n\n // Set value\n for (let i = 0; i < this.length; i += 1) {\n el = this[i];\n if (!el.dom7ElementDataStorage) el.dom7ElementDataStorage = {};\n el.dom7ElementDataStorage[key] = value;\n }\n return this;\n}\nfunction removeData(key) {\n for (let i = 0; i < this.length; i += 1) {\n const el = this[i];\n if (el.dom7ElementDataStorage && el.dom7ElementDataStorage[key]) {\n el.dom7ElementDataStorage[key] = null;\n delete el.dom7ElementDataStorage[key];\n }\n }\n}\nfunction dataset() {\n const el = this[0];\n if (!el) return undefined;\n const dataset = {}; // eslint-disable-line\n if (el.dataset) {\n // eslint-disable-next-line\n for (const dataKey in el.dataset) {\n dataset[dataKey] = el.dataset[dataKey];\n }\n } else {\n for (let i = 0; i < el.attributes.length; i += 1) {\n // eslint-disable-next-line\n const attr = el.attributes[i];\n if (attr.name.indexOf('data-') >= 0) {\n dataset[toCamelCase(attr.name.split('data-')[1])] = attr.value;\n }\n }\n }\n // eslint-disable-next-line\n for (const key in dataset) {\n if (dataset[key] === 'false') dataset[key] = false;\n else if (dataset[key] === 'true') dataset[key] = true;\n else if (parseFloat(dataset[key]) === dataset[key] * 1) dataset[key] *= 1;\n }\n return dataset;\n}\nfunction val(value) {\n const dom = this;\n if (typeof value === 'undefined') {\n if (dom[0]) {\n if (dom[0].multiple && dom[0].nodeName.toLowerCase() === 'select') {\n const values = [];\n for (let i = 0; i < dom[0].selectedOptions.length; i += 1) {\n values.push(dom[0].selectedOptions[i].value);\n }\n return values;\n }\n return dom[0].value;\n }\n return undefined;\n }\n\n for (let i = 0; i < dom.length; i += 1) {\n const el = dom[i];\n if (Array.isArray(value) && el.multiple && el.nodeName.toLowerCase() === 'select') {\n for (let j = 0; j < el.options.length; j += 1) {\n el.options[j].selected = value.indexOf(el.options[j].value) >= 0;\n }\n } else {\n el.value = value;\n }\n }\n return dom;\n}\n// Transforms\n// eslint-disable-next-line\nfunction transform(transform) {\n for (let i = 0; i < this.length; i += 1) {\n const elStyle = this[i].style;\n elStyle.webkitTransform = transform;\n elStyle.transform = transform;\n }\n return this;\n}\nfunction transition(duration) {\n if (typeof duration !== 'string') {\n duration = `${duration}ms`; // eslint-disable-line\n }\n for (let i = 0; i < this.length; i += 1) {\n const elStyle = this[i].style;\n elStyle.webkitTransitionDuration = duration;\n elStyle.transitionDuration = duration;\n }\n return this;\n}\n// Events\nfunction on(...args) {\n let [eventType, targetSelector, listener, capture] = args;\n if (typeof args[1] === 'function') {\n [eventType, listener, capture] = args;\n targetSelector = undefined;\n }\n if (!capture) capture = false;\n\n function handleLiveEvent(e) {\n const target = e.target;\n if (!target) return;\n const eventData = e.target.dom7EventData || [];\n if (eventData.indexOf(e) < 0) {\n eventData.unshift(e);\n }\n if ($(target).is(targetSelector)) listener.apply(target, eventData);\n else {\n const parents = $(target).parents(); // eslint-disable-line\n for (let k = 0; k < parents.length; k += 1) {\n if ($(parents[k]).is(targetSelector)) listener.apply(parents[k], eventData);\n }\n }\n }\n function handleEvent(e) {\n const eventData = e && e.target ? e.target.dom7EventData || [] : [];\n if (eventData.indexOf(e) < 0) {\n eventData.unshift(e);\n }\n listener.apply(this, eventData);\n }\n const events = eventType.split(' ');\n let j;\n for (let i = 0; i < this.length; i += 1) {\n const el = this[i];\n if (!targetSelector) {\n for (j = 0; j < events.length; j += 1) {\n const event = events[j];\n if (!el.dom7Listeners) el.dom7Listeners = {};\n if (!el.dom7Listeners[event]) el.dom7Listeners[event] = [];\n el.dom7Listeners[event].push({\n listener,\n proxyListener: handleEvent,\n });\n el.addEventListener(event, handleEvent, capture);\n }\n } else {\n // Live events\n for (j = 0; j < events.length; j += 1) {\n const event = events[j];\n if (!el.dom7LiveListeners) el.dom7LiveListeners = {};\n if (!el.dom7LiveListeners[event]) el.dom7LiveListeners[event] = [];\n el.dom7LiveListeners[event].push({\n listener,\n proxyListener: handleLiveEvent,\n });\n el.addEventListener(event, handleLiveEvent, capture);\n }\n }\n }\n return this;\n}\nfunction off(...args) {\n let [eventType, targetSelector, listener, capture] = args;\n if (typeof args[1] === 'function') {\n [eventType, listener, capture] = args;\n targetSelector = undefined;\n }\n if (!capture) capture = false;\n\n const events = eventType.split(' ');\n for (let i = 0; i < events.length; i += 1) {\n const event = events[i];\n for (let j = 0; j < this.length; j += 1) {\n const el = this[j];\n let handlers;\n if (!targetSelector && el.dom7Listeners) {\n handlers = el.dom7Listeners[event];\n } else if (targetSelector && el.dom7LiveListeners) {\n handlers = el.dom7LiveListeners[event];\n }\n if (handlers && handlers.length) {\n for (let k = handlers.length - 1; k >= 0; k -= 1) {\n const handler = handlers[k];\n if (listener && handler.listener === listener) {\n el.removeEventListener(event, handler.proxyListener, capture);\n handlers.splice(k, 1);\n } else if (listener && handler.listener && handler.listener.dom7proxy && handler.listener.dom7proxy === listener) {\n el.removeEventListener(event, handler.proxyListener, capture);\n handlers.splice(k, 1);\n } else if (!listener) {\n el.removeEventListener(event, handler.proxyListener, capture);\n handlers.splice(k, 1);\n }\n }\n }\n }\n }\n return this;\n}\nfunction once(...args) {\n const dom = this;\n let [eventName, targetSelector, listener, capture] = args;\n if (typeof args[1] === 'function') {\n [eventName, listener, capture] = args;\n targetSelector = undefined;\n }\n function onceHandler(...eventArgs) {\n listener.apply(this, eventArgs);\n dom.off(eventName, targetSelector, onceHandler, capture);\n if (onceHandler.dom7proxy) {\n delete onceHandler.dom7proxy;\n }\n }\n onceHandler.dom7proxy = listener;\n return dom.on(eventName, targetSelector, onceHandler, capture);\n}\nfunction trigger(...args) {\n const events = args[0].split(' ');\n const eventData = args[1];\n for (let i = 0; i < events.length; i += 1) {\n const event = events[i];\n for (let j = 0; j < this.length; j += 1) {\n const el = this[j];\n let evt;\n try {\n evt = new window.CustomEvent(event, {\n detail: eventData,\n bubbles: true,\n cancelable: true,\n });\n } catch (e) {\n evt = document.createEvent('Event');\n evt.initEvent(event, true, true);\n evt.detail = eventData;\n }\n // eslint-disable-next-line\n el.dom7EventData = args.filter((data, dataIndex) => dataIndex > 0);\n el.dispatchEvent(evt);\n el.dom7EventData = [];\n delete el.dom7EventData;\n }\n }\n return this;\n}\nfunction transitionEnd(callback) {\n const events = ['webkitTransitionEnd', 'transitionend'];\n const dom = this;\n let i;\n function fireCallBack(e) {\n /* jshint validthis:true */\n if (e.target !== this) return;\n callback.call(this, e);\n for (i = 0; i < events.length; i += 1) {\n dom.off(events[i], fireCallBack);\n }\n }\n if (callback) {\n for (i = 0; i < events.length; i += 1) {\n dom.on(events[i], fireCallBack);\n }\n }\n return this;\n}\nfunction animationEnd(callback) {\n const events = ['webkitAnimationEnd', 'animationend'];\n const dom = this;\n let i;\n function fireCallBack(e) {\n if (e.target !== this) return;\n callback.call(this, e);\n for (i = 0; i < events.length; i += 1) {\n dom.off(events[i], fireCallBack);\n }\n }\n if (callback) {\n for (i = 0; i < events.length; i += 1) {\n dom.on(events[i], fireCallBack);\n }\n }\n return this;\n}\n// Sizing/Styles\nfunction width() {\n if (this[0] === window) {\n return window.innerWidth;\n }\n\n if (this.length > 0) {\n return parseFloat(this.css('width'));\n }\n\n return null;\n}\nfunction outerWidth(includeMargins) {\n if (this.length > 0) {\n if (includeMargins) {\n // eslint-disable-next-line\n const styles = this.styles();\n return this[0].offsetWidth + parseFloat(styles.getPropertyValue('margin-right')) + parseFloat(styles.getPropertyValue('margin-left'));\n }\n return this[0].offsetWidth;\n }\n return null;\n}\nfunction height() {\n if (this[0] === window) {\n return window.innerHeight;\n }\n\n if (this.length > 0) {\n return parseFloat(this.css('height'));\n }\n\n return null;\n}\nfunction outerHeight(includeMargins) {\n if (this.length > 0) {\n if (includeMargins) {\n // eslint-disable-next-line\n const styles = this.styles();\n return this[0].offsetHeight + parseFloat(styles.getPropertyValue('margin-top')) + parseFloat(styles.getPropertyValue('margin-bottom'));\n }\n return this[0].offsetHeight;\n }\n return null;\n}\nfunction offset() {\n if (this.length > 0) {\n const el = this[0];\n const box = el.getBoundingClientRect();\n const body = document.body;\n const clientTop = el.clientTop || body.clientTop || 0;\n const clientLeft = el.clientLeft || body.clientLeft || 0;\n const scrollTop = el === window ? window.scrollY : el.scrollTop;\n const scrollLeft = el === window ? window.scrollX : el.scrollLeft;\n return {\n top: (box.top + scrollTop) - clientTop,\n left: (box.left + scrollLeft) - clientLeft,\n };\n }\n\n return null;\n}\nfunction hide() {\n for (let i = 0; i < this.length; i += 1) {\n this[i].style.display = 'none';\n }\n return this;\n}\nfunction show() {\n for (let i = 0; i < this.length; i += 1) {\n const el = this[i];\n if (el.style.display === 'none') {\n el.style.display = '';\n }\n if (window.getComputedStyle(el, null).getPropertyValue('display') === 'none') {\n // Still not visible\n el.style.display = 'block';\n }\n }\n return this;\n}\nfunction styles() {\n if (this[0]) return window.getComputedStyle(this[0], null);\n return {};\n}\nfunction css(props, value) {\n let i;\n if (arguments.length === 1) {\n if (typeof props === 'string') {\n if (this[0]) return window.getComputedStyle(this[0], null).getPropertyValue(props);\n } else {\n for (i = 0; i < this.length; i += 1) {\n // eslint-disable-next-line\n for (let prop in props) {\n this[i].style[prop] = props[prop];\n }\n }\n return this;\n }\n }\n if (arguments.length === 2 && typeof props === 'string') {\n for (i = 0; i < this.length; i += 1) {\n this[i].style[props] = value;\n }\n return this;\n }\n return this;\n}\n\n// Dom manipulation\nfunction toArray() {\n const arr = [];\n for (let i = 0; i < this.length; i += 1) {\n arr.push(this[i]);\n }\n return arr;\n}\n// Iterate over the collection passing elements to `callback`\nfunction each(callback) {\n // Don't bother continuing without a callback\n if (!callback) return this;\n // Iterate over the current collection\n for (let i = 0; i < this.length; i += 1) {\n // If the callback returns false\n if (callback.call(this[i], i, this[i]) === false) {\n // End the loop early\n return this;\n }\n }\n // Return `this` to allow chained DOM operations\n return this;\n}\nfunction forEach(callback) {\n // Don't bother continuing without a callback\n if (!callback) return this;\n // Iterate over the current collection\n for (let i = 0; i < this.length; i += 1) {\n // If the callback returns false\n if (callback.call(this[i], this[i], i) === false) {\n // End the loop early\n return this;\n }\n }\n // Return `this` to allow chained DOM operations\n return this;\n}\nfunction filter(callback) {\n const matchedItems = [];\n const dom = this;\n for (let i = 0; i < dom.length; i += 1) {\n if (callback.call(dom[i], i, dom[i])) matchedItems.push(dom[i]);\n }\n return new Dom7(matchedItems);\n}\nfunction map(callback) {\n const modifiedItems = [];\n const dom = this;\n for (let i = 0; i < dom.length; i += 1) {\n modifiedItems.push(callback.call(dom[i], i, dom[i]));\n }\n return new Dom7(modifiedItems);\n}\n// eslint-disable-next-line\nfunction html(html) {\n if (typeof html === 'undefined') {\n return this[0] ? this[0].innerHTML : undefined;\n }\n\n for (let i = 0; i < this.length; i += 1) {\n this[i].innerHTML = html;\n }\n return this;\n}\n// eslint-disable-next-line\nfunction text(text) {\n if (typeof text === 'undefined') {\n if (this[0]) {\n return this[0].textContent.trim();\n }\n return null;\n }\n\n for (let i = 0; i < this.length; i += 1) {\n this[i].textContent = text;\n }\n return this;\n}\nfunction is(selector) {\n const el = this[0];\n let compareWith;\n let i;\n if (!el || typeof selector === 'undefined') return false;\n if (typeof selector === 'string') {\n if (el.matches) return el.matches(selector);\n else if (el.webkitMatchesSelector) return el.webkitMatchesSelector(selector);\n else if (el.msMatchesSelector) return el.msMatchesSelector(selector);\n\n compareWith = $(selector);\n for (i = 0; i < compareWith.length; i += 1) {\n if (compareWith[i] === el) return true;\n }\n return false;\n } else if (selector === document) return el === document;\n else if (selector === window) return el === window;\n\n if (selector.nodeType || selector instanceof Dom7) {\n compareWith = selector.nodeType ? [selector] : selector;\n for (i = 0; i < compareWith.length; i += 1) {\n if (compareWith[i] === el) return true;\n }\n return false;\n }\n return false;\n}\nfunction indexOf(el) {\n for (let i = 0; i < this.length; i += 1) {\n if (this[i] === el) return i;\n }\n return -1;\n}\nfunction index() {\n let child = this[0];\n let i;\n if (child) {\n i = 0;\n // eslint-disable-next-line\n while ((child = child.previousSibling) !== null) {\n if (child.nodeType === 1) i += 1;\n }\n return i;\n }\n return undefined;\n}\n// eslint-disable-next-line\nfunction eq(index) {\n if (typeof index === 'undefined') return this;\n const length = this.length;\n let returnIndex;\n if (index > length - 1) {\n return new Dom7([]);\n }\n if (index < 0) {\n returnIndex = length + index;\n if (returnIndex < 0) return new Dom7([]);\n return new Dom7([this[returnIndex]]);\n }\n return new Dom7([this[index]]);\n}\nfunction append(...args) {\n let newChild;\n\n for (let k = 0; k < args.length; k += 1) {\n newChild = args[k];\n for (let i = 0; i < this.length; i += 1) {\n if (typeof newChild === 'string') {\n const tempDiv = document.createElement('div');\n tempDiv.innerHTML = newChild;\n while (tempDiv.firstChild) {\n this[i].appendChild(tempDiv.firstChild);\n }\n } else if (newChild instanceof Dom7) {\n for (let j = 0; j < newChild.length; j += 1) {\n this[i].appendChild(newChild[j]);\n }\n } else {\n this[i].appendChild(newChild);\n }\n }\n }\n\n return this;\n}\n// eslint-disable-next-line\nfunction appendTo(parent) {\n $(parent).append(this);\n return this;\n}\nfunction prepend(newChild) {\n let i;\n let j;\n for (i = 0; i < this.length; i += 1) {\n if (typeof newChild === 'string') {\n const tempDiv = document.createElement('div');\n tempDiv.innerHTML = newChild;\n for (j = tempDiv.childNodes.length - 1; j >= 0; j -= 1) {\n this[i].insertBefore(tempDiv.childNodes[j], this[i].childNodes[0]);\n }\n } else if (newChild instanceof Dom7) {\n for (j = 0; j < newChild.length; j += 1) {\n this[i].insertBefore(newChild[j], this[i].childNodes[0]);\n }\n } else {\n this[i].insertBefore(newChild, this[i].childNodes[0]);\n }\n }\n return this;\n}\n// eslint-disable-next-line\nfunction prependTo(parent) {\n $(parent).prepend(this);\n return this;\n}\nfunction insertBefore(selector) {\n const before = $(selector);\n for (let i = 0; i < this.length; i += 1) {\n if (before.length === 1) {\n before[0].parentNode.insertBefore(this[i], before[0]);\n } else if (before.length > 1) {\n for (let j = 0; j < before.length; j += 1) {\n before[j].parentNode.insertBefore(this[i].cloneNode(true), before[j]);\n }\n }\n }\n}\nfunction insertAfter(selector) {\n const after = $(selector);\n for (let i = 0; i < this.length; i += 1) {\n if (after.length === 1) {\n after[0].parentNode.insertBefore(this[i], after[0].nextSibling);\n } else if (after.length > 1) {\n for (let j = 0; j < after.length; j += 1) {\n after[j].parentNode.insertBefore(this[i].cloneNode(true), after[j].nextSibling);\n }\n }\n }\n}\nfunction next(selector) {\n if (this.length > 0) {\n if (selector) {\n if (this[0].nextElementSibling && $(this[0].nextElementSibling).is(selector)) {\n return new Dom7([this[0].nextElementSibling]);\n }\n return new Dom7([]);\n }\n\n if (this[0].nextElementSibling) return new Dom7([this[0].nextElementSibling]);\n return new Dom7([]);\n }\n return new Dom7([]);\n}\nfunction nextAll(selector) {\n const nextEls = [];\n let el = this[0];\n if (!el) return new Dom7([]);\n while (el.nextElementSibling) {\n const next = el.nextElementSibling; // eslint-disable-line\n if (selector) {\n if ($(next).is(selector)) nextEls.push(next);\n } else nextEls.push(next);\n el = next;\n }\n return new Dom7(nextEls);\n}\nfunction prev(selector) {\n if (this.length > 0) {\n const el = this[0];\n if (selector) {\n if (el.previousElementSibling && $(el.previousElementSibling).is(selector)) {\n return new Dom7([el.previousElementSibling]);\n }\n return new Dom7([]);\n }\n\n if (el.previousElementSibling) return new Dom7([el.previousElementSibling]);\n return new Dom7([]);\n }\n return new Dom7([]);\n}\nfunction prevAll(selector) {\n const prevEls = [];\n let el = this[0];\n if (!el) return new Dom7([]);\n while (el.previousElementSibling) {\n const prev = el.previousElementSibling; // eslint-disable-line\n if (selector) {\n if ($(prev).is(selector)) prevEls.push(prev);\n } else prevEls.push(prev);\n el = prev;\n }\n return new Dom7(prevEls);\n}\nfunction siblings(selector) {\n return this.nextAll(selector).add(this.prevAll(selector));\n}\nfunction parent(selector) {\n const parents = []; // eslint-disable-line\n for (let i = 0; i < this.length; i += 1) {\n if (this[i].parentNode !== null) {\n if (selector) {\n if ($(this[i].parentNode).is(selector)) parents.push(this[i].parentNode);\n } else {\n parents.push(this[i].parentNode);\n }\n }\n }\n return $(unique(parents));\n}\nfunction parents(selector) {\n const parents = []; // eslint-disable-line\n for (let i = 0; i < this.length; i += 1) {\n let parent = this[i].parentNode; // eslint-disable-line\n while (parent) {\n if (selector) {\n if ($(parent).is(selector)) parents.push(parent);\n } else {\n parents.push(parent);\n }\n parent = parent.parentNode;\n }\n }\n return $(unique(parents));\n}\nfunction closest(selector) {\n let closest = this; // eslint-disable-line\n if (typeof selector === 'undefined') {\n return new Dom7([]);\n }\n if (!closest.is(selector)) {\n closest = closest.parents(selector).eq(0);\n }\n return closest;\n}\nfunction find(selector) {\n const foundElements = [];\n for (let i = 0; i < this.length; i += 1) {\n const found = this[i].querySelectorAll(selector);\n for (let j = 0; j < found.length; j += 1) {\n foundElements.push(found[j]);\n }\n }\n return new Dom7(foundElements);\n}\nfunction children(selector) {\n const children = []; // eslint-disable-line\n for (let i = 0; i < this.length; i += 1) {\n const childNodes = this[i].childNodes;\n\n for (let j = 0; j < childNodes.length; j += 1) {\n if (!selector) {\n if (childNodes[j].nodeType === 1) children.push(childNodes[j]);\n } else if (childNodes[j].nodeType === 1 && $(childNodes[j]).is(selector)) {\n children.push(childNodes[j]);\n }\n }\n }\n return new Dom7(unique(children));\n}\nfunction remove() {\n for (let i = 0; i < this.length; i += 1) {\n if (this[i].parentNode) this[i].parentNode.removeChild(this[i]);\n }\n return this;\n}\nfunction detach() {\n return this.remove();\n}\nfunction add(...args) {\n const dom = this;\n let i;\n let j;\n for (i = 0; i < args.length; i += 1) {\n const toAdd = $(args[i]);\n for (j = 0; j < toAdd.length; j += 1) {\n dom[dom.length] = toAdd[j];\n dom.length += 1;\n }\n }\n return dom;\n}\nfunction empty() {\n for (let i = 0; i < this.length; i += 1) {\n const el = this[i];\n if (el.nodeType === 1) {\n for (let j = 0; j < el.childNodes.length; j += 1) {\n if (el.childNodes[j].parentNode) {\n el.childNodes[j].parentNode.removeChild(el.childNodes[j]);\n }\n }\n el.textContent = '';\n }\n }\n return this;\n}\n\nfunction scrollTo(...args) {\n let [left, top, duration, easing, callback] = args;\n if (args.length === 4 && typeof easing === 'function') {\n callback = easing;\n [left, top, duration, callback, easing] = args;\n }\n if (typeof easing === 'undefined') easing = 'swing';\n\n return this.each(function animate() {\n const el = this;\n let currentTop;\n let currentLeft;\n let maxTop;\n let maxLeft;\n let newTop;\n let newLeft;\n let scrollTop; // eslint-disable-line\n let scrollLeft; // eslint-disable-line\n let animateTop = top > 0 || top === 0;\n let animateLeft = left > 0 || left === 0;\n if (typeof easing === 'undefined') {\n easing = 'swing';\n }\n if (animateTop) {\n currentTop = el.scrollTop;\n if (!duration) {\n el.scrollTop = top;\n }\n }\n if (animateLeft) {\n currentLeft = el.scrollLeft;\n if (!duration) {\n el.scrollLeft = left;\n }\n }\n if (!duration) return;\n if (animateTop) {\n maxTop = el.scrollHeight - el.offsetHeight;\n newTop = Math.max(Math.min(top, maxTop), 0);\n }\n if (animateLeft) {\n maxLeft = el.scrollWidth - el.offsetWidth;\n newLeft = Math.max(Math.min(left, maxLeft), 0);\n }\n let startTime = null;\n if (animateTop && newTop === currentTop) animateTop = false;\n if (animateLeft && newLeft === currentLeft) animateLeft = false;\n function render(time = new Date().getTime()) {\n if (startTime === null) {\n startTime = time;\n }\n const progress = Math.max(Math.min((time - startTime) / duration, 1), 0);\n const easeProgress = easing === 'linear' ? progress : (0.5 - (Math.cos(progress * Math.PI) / 2));\n let done;\n if (animateTop) scrollTop = currentTop + (easeProgress * (newTop - currentTop));\n if (animateLeft) scrollLeft = currentLeft + (easeProgress * (newLeft - currentLeft));\n if (animateTop && newTop > currentTop && scrollTop >= newTop) {\n el.scrollTop = newTop;\n done = true;\n }\n if (animateTop && newTop < currentTop && scrollTop <= newTop) {\n el.scrollTop = newTop;\n done = true;\n }\n if (animateLeft && newLeft > currentLeft && scrollLeft >= newLeft) {\n el.scrollLeft = newLeft;\n done = true;\n }\n if (animateLeft && newLeft < currentLeft && scrollLeft <= newLeft) {\n el.scrollLeft = newLeft;\n done = true;\n }\n\n if (done) {\n if (callback) callback();\n return;\n }\n if (animateTop) el.scrollTop = scrollTop;\n if (animateLeft) el.scrollLeft = scrollLeft;\n requestAnimationFrame(render);\n }\n requestAnimationFrame(render);\n });\n}\n// scrollTop(top, duration, easing, callback) {\nfunction scrollTop(...args) {\n let [top, duration, easing, callback] = args;\n if (args.length === 3 && typeof easing === 'function') {\n [top, duration, callback, easing] = args;\n }\n const dom = this;\n if (typeof top === 'undefined') {\n if (dom.length > 0) return dom[0].scrollTop;\n return null;\n }\n return dom.scrollTo(undefined, top, duration, easing, callback);\n}\nfunction scrollLeft(...args) {\n let [left, duration, easing, callback] = args;\n if (args.length === 3 && typeof easing === 'function') {\n [left, duration, callback, easing] = args;\n }\n const dom = this;\n if (typeof left === 'undefined') {\n if (dom.length > 0) return dom[0].scrollLeft;\n return null;\n }\n return dom.scrollTo(left, undefined, duration, easing, callback);\n}\n\nfunction animate(initialProps, initialParams) {\n const els = this;\n const a = {\n props: Object.assign({}, initialProps),\n params: Object.assign({\n duration: 300,\n easing: 'swing', // or 'linear'\n /* Callbacks\n begin(elements)\n complete(elements)\n progress(elements, complete, remaining, start, tweenValue)\n */\n }, initialParams),\n\n elements: els,\n animating: false,\n que: [],\n\n easingProgress(easing, progress) {\n if (easing === 'swing') {\n return 0.5 - (Math.cos(progress * Math.PI) / 2);\n }\n if (typeof easing === 'function') {\n return easing(progress);\n }\n return progress;\n },\n stop() {\n if (a.frameId) {\n cancelAnimationFrame(a.frameId);\n }\n a.animating = false;\n a.elements.each((index, el) => {\n const element = el;\n delete element.dom7AnimateInstance;\n });\n a.que = [];\n },\n done(complete) {\n a.animating = false;\n a.elements.each((index, el) => {\n const element = el;\n delete element.dom7AnimateInstance;\n });\n if (complete) complete(els);\n if (a.que.length > 0) {\n const que = a.que.shift();\n a.animate(que[0], que[1]);\n }\n },\n animate(props, params) {\n if (a.animating) {\n a.que.push([props, params]);\n return a;\n }\n const elements = [];\n\n // Define & Cache Initials & Units\n a.elements.each((index, el) => {\n let initialFullValue;\n let initialValue;\n let unit;\n let finalValue;\n let finalFullValue;\n\n if (!el.dom7AnimateInstance) a.elements[index].dom7AnimateInstance = a;\n\n elements[index] = {\n container: el,\n };\n Object.keys(props).forEach((prop) => {\n initialFullValue = window.getComputedStyle(el, null).getPropertyValue(prop).replace(',', '.');\n initialValue = parseFloat(initialFullValue);\n unit = initialFullValue.replace(initialValue, '');\n finalValue = parseFloat(props[prop]);\n finalFullValue = props[prop] + unit;\n elements[index][prop] = {\n initialFullValue,\n initialValue,\n unit,\n finalValue,\n finalFullValue,\n currentValue: initialValue,\n };\n });\n });\n\n let startTime = null;\n let time;\n let elementsDone = 0;\n let propsDone = 0;\n let done;\n let began = false;\n\n a.animating = true;\n\n function render() {\n time = new Date().getTime();\n let progress;\n let easeProgress;\n // let el;\n if (!began) {\n began = true;\n if (params.begin) params.begin(els);\n }\n if (startTime === null) {\n startTime = time;\n }\n if (params.progress) {\n // eslint-disable-next-line\n params.progress(els, Math.max(Math.min((time - startTime) / params.duration, 1), 0), ((startTime + params.duration) - time < 0 ? 0 : (startTime + params.duration) - time), startTime);\n }\n\n elements.forEach((element) => {\n const el = element;\n if (done || el.done) return;\n Object.keys(props).forEach((prop) => {\n if (done || el.done) return;\n progress = Math.max(Math.min((time - startTime) / params.duration, 1), 0);\n easeProgress = a.easingProgress(params.easing, progress);\n const { initialValue, finalValue, unit } = el[prop];\n el[prop].currentValue = initialValue + (easeProgress * (finalValue - initialValue));\n const currentValue = el[prop].currentValue;\n\n if (\n (finalValue > initialValue && currentValue >= finalValue) ||\n (finalValue < initialValue && currentValue <= finalValue)) {\n el.container.style[prop] = finalValue + unit;\n propsDone += 1;\n if (propsDone === Object.keys(props).length) {\n el.done = true;\n elementsDone += 1;\n }\n if (elementsDone === elements.length) {\n done = true;\n }\n }\n if (done) {\n a.done(params.complete);\n return;\n }\n el.container.style[prop] = currentValue + unit;\n });\n });\n if (done) return;\n // Then call\n a.frameId = requestAnimationFrame(render);\n }\n a.frameId = requestAnimationFrame(render);\n return a;\n },\n };\n\n if (a.elements.length === 0) {\n return els;\n }\n\n let animateInstance;\n for (let i = 0; i < a.elements.length; i += 1) {\n if (a.elements[i].dom7AnimateInstance) {\n animateInstance = a.elements[i].dom7AnimateInstance;\n } else a.elements[i].dom7AnimateInstance = a;\n }\n if (!animateInstance) {\n animateInstance = a;\n }\n\n if (initialProps === 'stop') {\n animateInstance.stop();\n } else {\n animateInstance.animate(a.props, a.params);\n }\n\n return els;\n}\n\nfunction stop() {\n const els = this;\n for (let i = 0; i < els.length; i += 1) {\n if (els[i].dom7AnimateInstance) {\n els[i].dom7AnimateInstance.stop();\n }\n }\n}\n\nconst noTrigger = ('resize scroll').split(' ');\nfunction eventShortcut(name, ...args) {\n if (typeof args[0] === 'undefined') {\n for (let i = 0; i < this.length; i += 1) {\n if (noTrigger.indexOf(name) < 0) {\n if (name in this[i]) this[i][name]();\n else {\n $(this[i]).trigger(name);\n }\n }\n }\n return this;\n }\n return this.on(name, ...args);\n}\n\nfunction click(...args) {\n return eventShortcut.bind(this)('click', ...args);\n}\nfunction blur(...args) {\n return eventShortcut.bind(this)('blur', ...args);\n}\nfunction focus(...args) {\n return eventShortcut.bind(this)('focus', ...args);\n}\nfunction focusin(...args) {\n return eventShortcut.bind(this)('focusin', ...args);\n}\nfunction focusout(...args) {\n return eventShortcut.bind(this)('focusout', ...args);\n}\nfunction keyup(...args) {\n return eventShortcut.bind(this)('keyup', ...args);\n}\nfunction keydown(...args) {\n return eventShortcut.bind(this)('keydown', ...args);\n}\nfunction keypress(...args) {\n return eventShortcut.bind(this)('keypress', ...args);\n}\nfunction submit(...args) {\n return eventShortcut.bind(this)('submit', ...args);\n}\nfunction change(...args) {\n return eventShortcut.bind(this)('change', ...args);\n}\nfunction mousedown(...args) {\n return eventShortcut.bind(this)('mousedown', ...args);\n}\nfunction mousemove(...args) {\n return eventShortcut.bind(this)('mousemove', ...args);\n}\nfunction mouseup(...args) {\n return eventShortcut.bind(this)('mouseup', ...args);\n}\nfunction mouseenter(...args) {\n return eventShortcut.bind(this)('mouseenter', ...args);\n}\nfunction mouseleave(...args) {\n return eventShortcut.bind(this)('mouseleave', ...args);\n}\nfunction mouseout(...args) {\n return eventShortcut.bind(this)('mouseout', ...args);\n}\nfunction mouseover(...args) {\n return eventShortcut.bind(this)('mouseover', ...args);\n}\nfunction touchstart(...args) {\n return eventShortcut.bind(this)('touchstart', ...args);\n}\nfunction touchend(...args) {\n return eventShortcut.bind(this)('touchend', ...args);\n}\nfunction touchmove(...args) {\n return eventShortcut.bind(this)('touchmove', ...args);\n}\nfunction resize(...args) {\n return eventShortcut.bind(this)('resize', ...args);\n}\nfunction scroll(...args) {\n return eventShortcut.bind(this)('scroll', ...args);\n}\n\nexport { $, addClass, removeClass, hasClass, toggleClass, attr, removeAttr, prop, data, removeData, dataset, val, transform, transition, on, off, once, trigger, transitionEnd, animationEnd, width, outerWidth, height, outerHeight, offset, hide, show, styles, css, toArray, each, forEach, filter, map, html, text, is, indexOf, index, eq, append, appendTo, prepend, prependTo, insertBefore, insertAfter, next, nextAll, prev, prevAll, siblings, parent, parents, closest, find, children, remove, detach, add, empty, scrollTo, scrollTop, scrollLeft, animate, stop, click, blur, focus, focusin, focusout, keyup, keydown, keypress, submit, change, mousedown, mousemove, mouseup, mouseenter, mouseleave, mouseout, mouseover, touchstart, touchend, touchmove, resize, scroll };\n","/**\n * SSR Window 1.0.1\n * Better handling for window object in SSR environment\n * https://github.com/nolimits4web/ssr-window\n *\n * Copyright 2018, Vladimir Kharlampidi\n *\n * Licensed under MIT\n *\n * Released on: July 18, 2018\n */\nvar doc = (typeof document === 'undefined') ? {\n body: {},\n addEventListener: function addEventListener() {},\n removeEventListener: function removeEventListener() {},\n activeElement: {\n blur: function blur() {},\n nodeName: '',\n },\n querySelector: function querySelector() {\n return null;\n },\n querySelectorAll: function querySelectorAll() {\n return [];\n },\n getElementById: function getElementById() {\n return null;\n },\n createEvent: function createEvent() {\n return {\n initEvent: function initEvent() {},\n };\n },\n createElement: function createElement() {\n return {\n children: [],\n childNodes: [],\n style: {},\n setAttribute: function setAttribute() {},\n getElementsByTagName: function getElementsByTagName() {\n return [];\n },\n };\n },\n location: { hash: '' },\n} : document; // eslint-disable-line\n\nvar win = (typeof window === 'undefined') ? {\n document: doc,\n navigator: {\n userAgent: '',\n },\n location: {},\n history: {},\n CustomEvent: function CustomEvent() {\n return this;\n },\n addEventListener: function addEventListener() {},\n removeEventListener: function removeEventListener() {},\n getComputedStyle: function getComputedStyle() {\n return {\n getPropertyValue: function getPropertyValue() {\n return '';\n },\n };\n },\n Image: function Image() {},\n Date: function Date() {},\n screen: {},\n setTimeout: function setTimeout() {},\n clearTimeout: function clearTimeout() {},\n} : window; // eslint-disable-line\n\nexport { win as window, doc as document };\n","/**\n * Swiper 4.5.1\n * Most modern mobile touch slider and framework with hardware accelerated transitions\n * http://www.idangero.us/swiper/\n *\n * Copyright 2014-2019 Vladimir Kharlampidi\n *\n * Released under the MIT License\n *\n * Released on: September 13, 2019\n */\n\nimport { $, addClass, removeClass, hasClass, toggleClass, attr, removeAttr, data, transform, transition as transition$1, on, off, trigger, transitionEnd as transitionEnd$1, outerWidth, outerHeight, offset, css, each, html, text, is, index, eq, append, prepend, next, nextAll, prev, prevAll, parent, parents, closest, find, children, remove, add, styles } from 'dom7/dist/dom7.modular';\nimport { window, document } from 'ssr-window';\n\nconst Methods = {\n addClass,\n removeClass,\n hasClass,\n toggleClass,\n attr,\n removeAttr,\n data,\n transform,\n transition: transition$1,\n on,\n off,\n trigger,\n transitionEnd: transitionEnd$1,\n outerWidth,\n outerHeight,\n offset,\n css,\n each,\n html,\n text,\n is,\n index,\n eq,\n append,\n prepend,\n next,\n nextAll,\n prev,\n prevAll,\n parent,\n parents,\n closest,\n find,\n children,\n remove,\n add,\n styles,\n};\n\nObject.keys(Methods).forEach((methodName) => {\n $.fn[methodName] = $.fn[methodName] || Methods[methodName];\n});\n\nconst Utils = {\n deleteProps(obj) {\n const object = obj;\n Object.keys(object).forEach((key) => {\n try {\n object[key] = null;\n } catch (e) {\n // no getter for object\n }\n try {\n delete object[key];\n } catch (e) {\n // something got wrong\n }\n });\n },\n nextTick(callback, delay = 0) {\n return setTimeout(callback, delay);\n },\n now() {\n return Date.now();\n },\n getTranslate(el, axis = 'x') {\n let matrix;\n let curTransform;\n let transformMatrix;\n\n const curStyle = window.getComputedStyle(el, null);\n\n if (window.WebKitCSSMatrix) {\n curTransform = curStyle.transform || curStyle.webkitTransform;\n if (curTransform.split(',').length > 6) {\n curTransform = curTransform.split(', ').map((a) => a.replace(',', '.')).join(', ');\n }\n // Some old versions of Webkit choke when 'none' is passed; pass\n // empty string instead in this case\n transformMatrix = new window.WebKitCSSMatrix(curTransform === 'none' ? '' : curTransform);\n } else {\n transformMatrix = curStyle.MozTransform || curStyle.OTransform || curStyle.MsTransform || curStyle.msTransform || curStyle.transform || curStyle.getPropertyValue('transform').replace('translate(', 'matrix(1, 0, 0, 1,');\n matrix = transformMatrix.toString().split(',');\n }\n\n if (axis === 'x') {\n // Latest Chrome and webkits Fix\n if (window.WebKitCSSMatrix) curTransform = transformMatrix.m41;\n // Crazy IE10 Matrix\n else if (matrix.length === 16) curTransform = parseFloat(matrix[12]);\n // Normal Browsers\n else curTransform = parseFloat(matrix[4]);\n }\n if (axis === 'y') {\n // Latest Chrome and webkits Fix\n if (window.WebKitCSSMatrix) curTransform = transformMatrix.m42;\n // Crazy IE10 Matrix\n else if (matrix.length === 16) curTransform = parseFloat(matrix[13]);\n // Normal Browsers\n else curTransform = parseFloat(matrix[5]);\n }\n return curTransform || 0;\n },\n parseUrlQuery(url) {\n const query = {};\n let urlToParse = url || window.location.href;\n let i;\n let params;\n let param;\n let length;\n if (typeof urlToParse === 'string' && urlToParse.length) {\n urlToParse = urlToParse.indexOf('?') > -1 ? urlToParse.replace(/\\S*\\?/, '') : '';\n params = urlToParse.split('&').filter((paramsPart) => paramsPart !== '');\n length = params.length;\n\n for (i = 0; i < length; i += 1) {\n param = params[i].replace(/#\\S+/g, '').split('=');\n query[decodeURIComponent(param[0])] = typeof param[1] === 'undefined' ? undefined : decodeURIComponent(param[1]) || '';\n }\n }\n return query;\n },\n isObject(o) {\n return typeof o === 'object' && o !== null && o.constructor && o.constructor === Object;\n },\n extend(...args) {\n const to = Object(args[0]);\n for (let i = 1; i < args.length; i += 1) {\n const nextSource = args[i];\n if (nextSource !== undefined && nextSource !== null) {\n const keysArray = Object.keys(Object(nextSource));\n for (let nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex += 1) {\n const nextKey = keysArray[nextIndex];\n const desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);\n if (desc !== undefined && desc.enumerable) {\n if (Utils.isObject(to[nextKey]) && Utils.isObject(nextSource[nextKey])) {\n Utils.extend(to[nextKey], nextSource[nextKey]);\n } else if (!Utils.isObject(to[nextKey]) && Utils.isObject(nextSource[nextKey])) {\n to[nextKey] = {};\n Utils.extend(to[nextKey], nextSource[nextKey]);\n } else {\n to[nextKey] = nextSource[nextKey];\n }\n }\n }\n }\n }\n return to;\n },\n};\n\nconst Support = (function Support() {\n const testDiv = document.createElement('div');\n return {\n touch: (window.Modernizr && window.Modernizr.touch === true) || (function checkTouch() {\n return !!((window.navigator.maxTouchPoints > 0) || ('ontouchstart' in window) || (window.DocumentTouch && document instanceof window.DocumentTouch));\n }()),\n\n pointerEvents: !!(window.navigator.pointerEnabled || window.PointerEvent || ('maxTouchPoints' in window.navigator && window.navigator.maxTouchPoints > 0)),\n prefixedPointerEvents: !!window.navigator.msPointerEnabled,\n\n transition: (function checkTransition() {\n const style = testDiv.style;\n return ('transition' in style || 'webkitTransition' in style || 'MozTransition' in style);\n }()),\n transforms3d: (window.Modernizr && window.Modernizr.csstransforms3d === true) || (function checkTransforms3d() {\n const style = testDiv.style;\n return ('webkitPerspective' in style || 'MozPerspective' in style || 'OPerspective' in style || 'MsPerspective' in style || 'perspective' in style);\n }()),\n\n flexbox: (function checkFlexbox() {\n const style = testDiv.style;\n const styles = ('alignItems webkitAlignItems webkitBoxAlign msFlexAlign mozBoxAlign webkitFlexDirection msFlexDirection mozBoxDirection mozBoxOrient webkitBoxDirection webkitBoxOrient').split(' ');\n for (let i = 0; i < styles.length; i += 1) {\n if (styles[i] in style) return true;\n }\n return false;\n }()),\n\n observer: (function checkObserver() {\n return ('MutationObserver' in window || 'WebkitMutationObserver' in window);\n }()),\n\n passiveListener: (function checkPassiveListener() {\n let supportsPassive = false;\n try {\n const opts = Object.defineProperty({}, 'passive', {\n // eslint-disable-next-line\n get() {\n supportsPassive = true;\n },\n });\n window.addEventListener('testPassiveListener', null, opts);\n } catch (e) {\n // No support\n }\n return supportsPassive;\n }()),\n\n gestures: (function checkGestures() {\n return 'ongesturestart' in window;\n }()),\n };\n}());\n\nconst Browser = (function Browser() {\n function isSafari() {\n const ua = window.navigator.userAgent.toLowerCase();\n return (ua.indexOf('safari') >= 0 && ua.indexOf('chrome') < 0 && ua.indexOf('android') < 0);\n }\n return {\n isIE: !!window.navigator.userAgent.match(/Trident/g) || !!window.navigator.userAgent.match(/MSIE/g),\n isEdge: !!window.navigator.userAgent.match(/Edge/g),\n isSafari: isSafari(),\n isUiWebView: /(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/i.test(window.navigator.userAgent),\n };\n}());\n\nclass SwiperClass {\n constructor(params = {}) {\n const self = this;\n self.params = params;\n\n // Events\n self.eventsListeners = {};\n\n if (self.params && self.params.on) {\n Object.keys(self.params.on).forEach((eventName) => {\n self.on(eventName, self.params.on[eventName]);\n });\n }\n }\n\n on(events, handler, priority) {\n const self = this;\n if (typeof handler !== 'function') return self;\n const method = priority ? 'unshift' : 'push';\n events.split(' ').forEach((event) => {\n if (!self.eventsListeners[event]) self.eventsListeners[event] = [];\n self.eventsListeners[event][method](handler);\n });\n return self;\n }\n\n once(events, handler, priority) {\n const self = this;\n if (typeof handler !== 'function') return self;\n function onceHandler(...args) {\n handler.apply(self, args);\n self.off(events, onceHandler);\n if (onceHandler.f7proxy) {\n delete onceHandler.f7proxy;\n }\n }\n onceHandler.f7proxy = handler;\n return self.on(events, onceHandler, priority);\n }\n\n off(events, handler) {\n const self = this;\n if (!self.eventsListeners) return self;\n events.split(' ').forEach((event) => {\n if (typeof handler === 'undefined') {\n self.eventsListeners[event] = [];\n } else if (self.eventsListeners[event] && self.eventsListeners[event].length) {\n self.eventsListeners[event].forEach((eventHandler, index) => {\n if (eventHandler === handler || (eventHandler.f7proxy && eventHandler.f7proxy === handler)) {\n self.eventsListeners[event].splice(index, 1);\n }\n });\n }\n });\n return self;\n }\n\n emit(...args) {\n const self = this;\n if (!self.eventsListeners) return self;\n let events;\n let data;\n let context;\n if (typeof args[0] === 'string' || Array.isArray(args[0])) {\n events = args[0];\n data = args.slice(1, args.length);\n context = self;\n } else {\n events = args[0].events;\n data = args[0].data;\n context = args[0].context || self;\n }\n const eventsArray = Array.isArray(events) ? events : events.split(' ');\n eventsArray.forEach((event) => {\n if (self.eventsListeners && self.eventsListeners[event]) {\n const handlers = [];\n self.eventsListeners[event].forEach((eventHandler) => {\n handlers.push(eventHandler);\n });\n handlers.forEach((eventHandler) => {\n eventHandler.apply(context, data);\n });\n }\n });\n return self;\n }\n\n useModulesParams(instanceParams) {\n const instance = this;\n if (!instance.modules) return;\n Object.keys(instance.modules).forEach((moduleName) => {\n const module = instance.modules[moduleName];\n // Extend params\n if (module.params) {\n Utils.extend(instanceParams, module.params);\n }\n });\n }\n\n useModules(modulesParams = {}) {\n const instance = this;\n if (!instance.modules) return;\n Object.keys(instance.modules).forEach((moduleName) => {\n const module = instance.modules[moduleName];\n const moduleParams = modulesParams[moduleName] || {};\n // Extend instance methods and props\n if (module.instance) {\n Object.keys(module.instance).forEach((modulePropName) => {\n const moduleProp = module.instance[modulePropName];\n if (typeof moduleProp === 'function') {\n instance[modulePropName] = moduleProp.bind(instance);\n } else {\n instance[modulePropName] = moduleProp;\n }\n });\n }\n // Add event listeners\n if (module.on && instance.on) {\n Object.keys(module.on).forEach((moduleEventName) => {\n instance.on(moduleEventName, module.on[moduleEventName]);\n });\n }\n\n // Module create callback\n if (module.create) {\n module.create.bind(instance)(moduleParams);\n }\n });\n }\n\n static set components(components) {\n const Class = this;\n if (!Class.use) return;\n Class.use(components);\n }\n\n static installModule(module, ...params) {\n const Class = this;\n if (!Class.prototype.modules) Class.prototype.modules = {};\n const name = module.name || (`${Object.keys(Class.prototype.modules).length}_${Utils.now()}`);\n Class.prototype.modules[name] = module;\n // Prototype\n if (module.proto) {\n Object.keys(module.proto).forEach((key) => {\n Class.prototype[key] = module.proto[key];\n });\n }\n // Class\n if (module.static) {\n Object.keys(module.static).forEach((key) => {\n Class[key] = module.static[key];\n });\n }\n // Callback\n if (module.install) {\n module.install.apply(Class, params);\n }\n return Class;\n }\n\n static use(module, ...params) {\n const Class = this;\n if (Array.isArray(module)) {\n module.forEach((m) => Class.installModule(m));\n return Class;\n }\n return Class.installModule(module, ...params);\n }\n}\n\nfunction updateSize () {\n const swiper = this;\n let width;\n let height;\n const $el = swiper.$el;\n if (typeof swiper.params.width !== 'undefined') {\n width = swiper.params.width;\n } else {\n width = $el[0].clientWidth;\n }\n if (typeof swiper.params.height !== 'undefined') {\n height = swiper.params.height;\n } else {\n height = $el[0].clientHeight;\n }\n if ((width === 0 && swiper.isHorizontal()) || (height === 0 && swiper.isVertical())) {\n return;\n }\n\n // Subtract paddings\n width = width - parseInt($el.css('padding-left'), 10) - parseInt($el.css('padding-right'), 10);\n height = height - parseInt($el.css('padding-top'), 10) - parseInt($el.css('padding-bottom'), 10);\n\n Utils.extend(swiper, {\n width,\n height,\n size: swiper.isHorizontal() ? width : height,\n });\n}\n\nfunction updateSlides () {\n const swiper = this;\n const params = swiper.params;\n\n const {\n $wrapperEl, size: swiperSize, rtlTranslate: rtl, wrongRTL,\n } = swiper;\n const isVirtual = swiper.virtual && params.virtual.enabled;\n const previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;\n const slides = $wrapperEl.children(`.${swiper.params.slideClass}`);\n const slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;\n let snapGrid = [];\n const slidesGrid = [];\n const slidesSizesGrid = [];\n\n let offsetBefore = params.slidesOffsetBefore;\n if (typeof offsetBefore === 'function') {\n offsetBefore = params.slidesOffsetBefore.call(swiper);\n }\n\n let offsetAfter = params.slidesOffsetAfter;\n if (typeof offsetAfter === 'function') {\n offsetAfter = params.slidesOffsetAfter.call(swiper);\n }\n\n const previousSnapGridLength = swiper.snapGrid.length;\n const previousSlidesGridLength = swiper.snapGrid.length;\n\n let spaceBetween = params.spaceBetween;\n let slidePosition = -offsetBefore;\n let prevSlideSize = 0;\n let index = 0;\n if (typeof swiperSize === 'undefined') {\n return;\n }\n if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {\n spaceBetween = (parseFloat(spaceBetween.replace('%', '')) / 100) * swiperSize;\n }\n\n swiper.virtualSize = -spaceBetween;\n\n // reset margins\n if (rtl) slides.css({ marginLeft: '', marginTop: '' });\n else slides.css({ marginRight: '', marginBottom: '' });\n\n let slidesNumberEvenToRows;\n if (params.slidesPerColumn > 1) {\n if (Math.floor(slidesLength / params.slidesPerColumn) === slidesLength / swiper.params.slidesPerColumn) {\n slidesNumberEvenToRows = slidesLength;\n } else {\n slidesNumberEvenToRows = Math.ceil(slidesLength / params.slidesPerColumn) * params.slidesPerColumn;\n }\n if (params.slidesPerView !== 'auto' && params.slidesPerColumnFill === 'row') {\n slidesNumberEvenToRows = Math.max(slidesNumberEvenToRows, params.slidesPerView * params.slidesPerColumn);\n }\n }\n\n // Calc slides\n let slideSize;\n const slidesPerColumn = params.slidesPerColumn;\n const slidesPerRow = slidesNumberEvenToRows / slidesPerColumn;\n const numFullColumns = Math.floor(slidesLength / params.slidesPerColumn);\n for (let i = 0; i < slidesLength; i += 1) {\n slideSize = 0;\n const slide = slides.eq(i);\n if (params.slidesPerColumn > 1) {\n // Set slides order\n let newSlideOrderIndex;\n let column;\n let row;\n if (\n (params.slidesPerColumnFill === 'column')\n || (params.slidesPerColumnFill === 'row' && params.slidesPerGroup > 1)\n ) {\n if (params.slidesPerColumnFill === 'column') {\n column = Math.floor(i / slidesPerColumn);\n row = i - (column * slidesPerColumn);\n if (column > numFullColumns || (column === numFullColumns && row === slidesPerColumn - 1)) {\n row += 1;\n if (row >= slidesPerColumn) {\n row = 0;\n column += 1;\n }\n }\n } else {\n const groupIndex = Math.floor(i / params.slidesPerGroup);\n row = Math.floor(i / params.slidesPerView) - groupIndex * params.slidesPerColumn;\n column = i - row * params.slidesPerView - groupIndex * params.slidesPerView;\n }\n newSlideOrderIndex = column + ((row * slidesNumberEvenToRows) / slidesPerColumn);\n slide\n .css({\n '-webkit-box-ordinal-group': newSlideOrderIndex,\n '-moz-box-ordinal-group': newSlideOrderIndex,\n '-ms-flex-order': newSlideOrderIndex,\n '-webkit-order': newSlideOrderIndex,\n order: newSlideOrderIndex,\n });\n } else {\n row = Math.floor(i / slidesPerRow);\n column = i - (row * slidesPerRow);\n }\n slide\n .css(\n `margin-${swiper.isHorizontal() ? 'top' : 'left'}`,\n (row !== 0 && params.spaceBetween) && (`${params.spaceBetween}px`)\n )\n .attr('data-swiper-column', column)\n .attr('data-swiper-row', row);\n }\n if (slide.css('display') === 'none') continue; // eslint-disable-line\n\n if (params.slidesPerView === 'auto') {\n const slideStyles = window.getComputedStyle(slide[0], null);\n const currentTransform = slide[0].style.transform;\n const currentWebKitTransform = slide[0].style.webkitTransform;\n if (currentTransform) {\n slide[0].style.transform = 'none';\n }\n if (currentWebKitTransform) {\n slide[0].style.webkitTransform = 'none';\n }\n if (params.roundLengths) {\n slideSize = swiper.isHorizontal()\n ? slide.outerWidth(true)\n : slide.outerHeight(true);\n } else {\n // eslint-disable-next-line\n if (swiper.isHorizontal()) {\n const width = parseFloat(slideStyles.getPropertyValue('width'));\n const paddingLeft = parseFloat(slideStyles.getPropertyValue('padding-left'));\n const paddingRight = parseFloat(slideStyles.getPropertyValue('padding-right'));\n const marginLeft = parseFloat(slideStyles.getPropertyValue('margin-left'));\n const marginRight = parseFloat(slideStyles.getPropertyValue('margin-right'));\n const boxSizing = slideStyles.getPropertyValue('box-sizing');\n if (boxSizing && boxSizing === 'border-box' && !Browser.isIE) {\n slideSize = width + marginLeft + marginRight;\n } else {\n slideSize = width + paddingLeft + paddingRight + marginLeft + marginRight;\n }\n } else {\n const height = parseFloat(slideStyles.getPropertyValue('height'));\n const paddingTop = parseFloat(slideStyles.getPropertyValue('padding-top'));\n const paddingBottom = parseFloat(slideStyles.getPropertyValue('padding-bottom'));\n const marginTop = parseFloat(slideStyles.getPropertyValue('margin-top'));\n const marginBottom = parseFloat(slideStyles.getPropertyValue('margin-bottom'));\n const boxSizing = slideStyles.getPropertyValue('box-sizing');\n if (boxSizing && boxSizing === 'border-box' && !Browser.isIE) {\n slideSize = height + marginTop + marginBottom;\n } else {\n slideSize = height + paddingTop + paddingBottom + marginTop + marginBottom;\n }\n }\n }\n if (currentTransform) {\n slide[0].style.transform = currentTransform;\n }\n if (currentWebKitTransform) {\n slide[0].style.webkitTransform = currentWebKitTransform;\n }\n if (params.roundLengths) slideSize = Math.floor(slideSize);\n } else {\n slideSize = (swiperSize - ((params.slidesPerView - 1) * spaceBetween)) / params.slidesPerView;\n if (params.roundLengths) slideSize = Math.floor(slideSize);\n\n if (slides[i]) {\n if (swiper.isHorizontal()) {\n slides[i].style.width = `${slideSize}px`;\n } else {\n slides[i].style.height = `${slideSize}px`;\n }\n }\n }\n if (slides[i]) {\n slides[i].swiperSlideSize = slideSize;\n }\n slidesSizesGrid.push(slideSize);\n\n\n if (params.centeredSlides) {\n slidePosition = slidePosition + (slideSize / 2) + (prevSlideSize / 2) + spaceBetween;\n if (prevSlideSize === 0 && i !== 0) slidePosition = slidePosition - (swiperSize / 2) - spaceBetween;\n if (i === 0) slidePosition = slidePosition - (swiperSize / 2) - spaceBetween;\n if (Math.abs(slidePosition) < 1 / 1000) slidePosition = 0;\n if (params.roundLengths) slidePosition = Math.floor(slidePosition);\n if ((index) % params.slidesPerGroup === 0) snapGrid.push(slidePosition);\n slidesGrid.push(slidePosition);\n } else {\n if (params.roundLengths) slidePosition = Math.floor(slidePosition);\n if ((index) % params.slidesPerGroup === 0) snapGrid.push(slidePosition);\n slidesGrid.push(slidePosition);\n slidePosition = slidePosition + slideSize + spaceBetween;\n }\n\n swiper.virtualSize += slideSize + spaceBetween;\n\n prevSlideSize = slideSize;\n\n index += 1;\n }\n swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;\n let newSlidesGrid;\n\n if (\n rtl && wrongRTL && (params.effect === 'slide' || params.effect === 'coverflow')) {\n $wrapperEl.css({ width: `${swiper.virtualSize + params.spaceBetween}px` });\n }\n if (!Support.flexbox || params.setWrapperSize) {\n if (swiper.isHorizontal()) $wrapperEl.css({ width: `${swiper.virtualSize + params.spaceBetween}px` });\n else $wrapperEl.css({ height: `${swiper.virtualSize + params.spaceBetween}px` });\n }\n\n if (params.slidesPerColumn > 1) {\n swiper.virtualSize = (slideSize + params.spaceBetween) * slidesNumberEvenToRows;\n swiper.virtualSize = Math.ceil(swiper.virtualSize / params.slidesPerColumn) - params.spaceBetween;\n if (swiper.isHorizontal()) $wrapperEl.css({ width: `${swiper.virtualSize + params.spaceBetween}px` });\n else $wrapperEl.css({ height: `${swiper.virtualSize + params.spaceBetween}px` });\n if (params.centeredSlides) {\n newSlidesGrid = [];\n for (let i = 0; i < snapGrid.length; i += 1) {\n let slidesGridItem = snapGrid[i];\n if (params.roundLengths) slidesGridItem = Math.floor(slidesGridItem);\n if (snapGrid[i] < swiper.virtualSize + snapGrid[0]) newSlidesGrid.push(slidesGridItem);\n }\n snapGrid = newSlidesGrid;\n }\n }\n\n // Remove last grid elements depending on width\n if (!params.centeredSlides) {\n newSlidesGrid = [];\n for (let i = 0; i < snapGrid.length; i += 1) {\n let slidesGridItem = snapGrid[i];\n if (params.roundLengths) slidesGridItem = Math.floor(slidesGridItem);\n if (snapGrid[i] <= swiper.virtualSize - swiperSize) {\n newSlidesGrid.push(slidesGridItem);\n }\n }\n snapGrid = newSlidesGrid;\n if (Math.floor(swiper.virtualSize - swiperSize) - Math.floor(snapGrid[snapGrid.length - 1]) > 1) {\n snapGrid.push(swiper.virtualSize - swiperSize);\n }\n }\n if (snapGrid.length === 0) snapGrid = [0];\n\n if (params.spaceBetween !== 0) {\n if (swiper.isHorizontal()) {\n if (rtl) slides.css({ marginLeft: `${spaceBetween}px` });\n else slides.css({ marginRight: `${spaceBetween}px` });\n } else slides.css({ marginBottom: `${spaceBetween}px` });\n }\n\n if (params.centerInsufficientSlides) {\n let allSlidesSize = 0;\n slidesSizesGrid.forEach((slideSizeValue) => {\n allSlidesSize += slideSizeValue + (params.spaceBetween ? params.spaceBetween : 0);\n });\n allSlidesSize -= params.spaceBetween;\n if (allSlidesSize < swiperSize) {\n const allSlidesOffset = (swiperSize - allSlidesSize) / 2;\n snapGrid.forEach((snap, snapIndex) => {\n snapGrid[snapIndex] = snap - allSlidesOffset;\n });\n slidesGrid.forEach((snap, snapIndex) => {\n slidesGrid[snapIndex] = snap + allSlidesOffset;\n });\n }\n }\n\n Utils.extend(swiper, {\n slides,\n snapGrid,\n slidesGrid,\n slidesSizesGrid,\n });\n\n if (slidesLength !== previousSlidesLength) {\n swiper.emit('slidesLengthChange');\n }\n if (snapGrid.length !== previousSnapGridLength) {\n if (swiper.params.watchOverflow) swiper.checkOverflow();\n swiper.emit('snapGridLengthChange');\n }\n if (slidesGrid.length !== previousSlidesGridLength) {\n swiper.emit('slidesGridLengthChange');\n }\n\n if (params.watchSlidesProgress || params.watchSlidesVisibility) {\n swiper.updateSlidesOffset();\n }\n}\n\nfunction updateAutoHeight (speed) {\n const swiper = this;\n const activeSlides = [];\n let newHeight = 0;\n let i;\n if (typeof speed === 'number') {\n swiper.setTransition(speed);\n } else if (speed === true) {\n swiper.setTransition(swiper.params.speed);\n }\n // Find slides currently in view\n if (swiper.params.slidesPerView !== 'auto' && swiper.params.slidesPerView > 1) {\n for (i = 0; i < Math.ceil(swiper.params.slidesPerView); i += 1) {\n const index = swiper.activeIndex + i;\n if (index > swiper.slides.length) break;\n activeSlides.push(swiper.slides.eq(index)[0]);\n }\n } else {\n activeSlides.push(swiper.slides.eq(swiper.activeIndex)[0]);\n }\n\n // Find new height from highest slide in view\n for (i = 0; i < activeSlides.length; i += 1) {\n if (typeof activeSlides[i] !== 'undefined') {\n const height = activeSlides[i].offsetHeight;\n newHeight = height > newHeight ? height : newHeight;\n }\n }\n\n // Update Height\n if (newHeight) swiper.$wrapperEl.css('height', `${newHeight}px`);\n}\n\nfunction updateSlidesOffset () {\n const swiper = this;\n const slides = swiper.slides;\n for (let i = 0; i < slides.length; i += 1) {\n slides[i].swiperSlideOffset = swiper.isHorizontal() ? slides[i].offsetLeft : slides[i].offsetTop;\n }\n}\n\nfunction updateSlidesProgress (translate = (this && this.translate) || 0) {\n const swiper = this;\n const params = swiper.params;\n\n const { slides, rtlTranslate: rtl } = swiper;\n\n if (slides.length === 0) return;\n if (typeof slides[0].swiperSlideOffset === 'undefined') swiper.updateSlidesOffset();\n\n let offsetCenter = -translate;\n if (rtl) offsetCenter = translate;\n\n // Visible Slides\n slides.removeClass(params.slideVisibleClass);\n\n swiper.visibleSlidesIndexes = [];\n swiper.visibleSlides = [];\n\n for (let i = 0; i < slides.length; i += 1) {\n const slide = slides[i];\n const slideProgress = (\n (offsetCenter + (params.centeredSlides ? swiper.minTranslate() : 0)) - slide.swiperSlideOffset\n ) / (slide.swiperSlideSize + params.spaceBetween);\n if (params.watchSlidesVisibility) {\n const slideBefore = -(offsetCenter - slide.swiperSlideOffset);\n const slideAfter = slideBefore + swiper.slidesSizesGrid[i];\n const isVisible = (slideBefore >= 0 && slideBefore < swiper.size - 1)\n || (slideAfter > 1 && slideAfter <= swiper.size)\n || (slideBefore <= 0 && slideAfter >= swiper.size);\n if (isVisible) {\n swiper.visibleSlides.push(slide);\n swiper.visibleSlidesIndexes.push(i);\n slides.eq(i).addClass(params.slideVisibleClass);\n }\n }\n slide.progress = rtl ? -slideProgress : slideProgress;\n }\n swiper.visibleSlides = $(swiper.visibleSlides);\n}\n\nfunction updateProgress (translate = (this && this.translate) || 0) {\n const swiper = this;\n const params = swiper.params;\n\n const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();\n let { progress, isBeginning, isEnd } = swiper;\n const wasBeginning = isBeginning;\n const wasEnd = isEnd;\n if (translatesDiff === 0) {\n progress = 0;\n isBeginning = true;\n isEnd = true;\n } else {\n progress = (translate - swiper.minTranslate()) / (translatesDiff);\n isBeginning = progress <= 0;\n isEnd = progress >= 1;\n }\n Utils.extend(swiper, {\n progress,\n isBeginning,\n isEnd,\n });\n\n if (params.watchSlidesProgress || params.watchSlidesVisibility) swiper.updateSlidesProgress(translate);\n\n if (isBeginning && !wasBeginning) {\n swiper.emit('reachBeginning toEdge');\n }\n if (isEnd && !wasEnd) {\n swiper.emit('reachEnd toEdge');\n }\n if ((wasBeginning && !isBeginning) || (wasEnd && !isEnd)) {\n swiper.emit('fromEdge');\n }\n\n swiper.emit('progress', progress);\n}\n\nfunction updateSlidesClasses () {\n const swiper = this;\n\n const {\n slides, params, $wrapperEl, activeIndex, realIndex,\n } = swiper;\n const isVirtual = swiper.virtual && params.virtual.enabled;\n\n slides.removeClass(`${params.slideActiveClass} ${params.slideNextClass} ${params.slidePrevClass} ${params.slideDuplicateActiveClass} ${params.slideDuplicateNextClass} ${params.slideDuplicatePrevClass}`);\n\n let activeSlide;\n if (isVirtual) {\n activeSlide = swiper.$wrapperEl.find(`.${params.slideClass}[data-swiper-slide-index=\"${activeIndex}\"]`);\n } else {\n activeSlide = slides.eq(activeIndex);\n }\n\n // Active classes\n activeSlide.addClass(params.slideActiveClass);\n\n if (params.loop) {\n // Duplicate to all looped slides\n if (activeSlide.hasClass(params.slideDuplicateClass)) {\n $wrapperEl\n .children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index=\"${realIndex}\"]`)\n .addClass(params.slideDuplicateActiveClass);\n } else {\n $wrapperEl\n .children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index=\"${realIndex}\"]`)\n .addClass(params.slideDuplicateActiveClass);\n }\n }\n // Next Slide\n let nextSlide = activeSlide.nextAll(`.${params.slideClass}`).eq(0).addClass(params.slideNextClass);\n if (params.loop && nextSlide.length === 0) {\n nextSlide = slides.eq(0);\n nextSlide.addClass(params.slideNextClass);\n }\n // Prev Slide\n let prevSlide = activeSlide.prevAll(`.${params.slideClass}`).eq(0).addClass(params.slidePrevClass);\n if (params.loop && prevSlide.length === 0) {\n prevSlide = slides.eq(-1);\n prevSlide.addClass(params.slidePrevClass);\n }\n if (params.loop) {\n // Duplicate to all looped slides\n if (nextSlide.hasClass(params.slideDuplicateClass)) {\n $wrapperEl\n .children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index=\"${nextSlide.attr('data-swiper-slide-index')}\"]`)\n .addClass(params.slideDuplicateNextClass);\n } else {\n $wrapperEl\n .children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index=\"${nextSlide.attr('data-swiper-slide-index')}\"]`)\n .addClass(params.slideDuplicateNextClass);\n }\n if (prevSlide.hasClass(params.slideDuplicateClass)) {\n $wrapperEl\n .children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index=\"${prevSlide.attr('data-swiper-slide-index')}\"]`)\n .addClass(params.slideDuplicatePrevClass);\n } else {\n $wrapperEl\n .children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index=\"${prevSlide.attr('data-swiper-slide-index')}\"]`)\n .addClass(params.slideDuplicatePrevClass);\n }\n }\n}\n\nfunction updateActiveIndex (newActiveIndex) {\n const swiper = this;\n const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;\n const {\n slidesGrid, snapGrid, params, activeIndex: previousIndex, realIndex: previousRealIndex, snapIndex: previousSnapIndex,\n } = swiper;\n let activeIndex = newActiveIndex;\n let snapIndex;\n if (typeof activeIndex === 'undefined') {\n for (let i = 0; i < slidesGrid.length; i += 1) {\n if (typeof slidesGrid[i + 1] !== 'undefined') {\n if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1] - ((slidesGrid[i + 1] - slidesGrid[i]) / 2)) {\n activeIndex = i;\n } else if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1]) {\n activeIndex = i + 1;\n }\n } else if (translate >= slidesGrid[i]) {\n activeIndex = i;\n }\n }\n // Normalize slideIndex\n if (params.normalizeSlideIndex) {\n if (activeIndex < 0 || typeof activeIndex === 'undefined') activeIndex = 0;\n }\n }\n if (snapGrid.indexOf(translate) >= 0) {\n snapIndex = snapGrid.indexOf(translate);\n } else {\n snapIndex = Math.floor(activeIndex / params.slidesPerGroup);\n }\n if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;\n if (activeIndex === previousIndex) {\n if (snapIndex !== previousSnapIndex) {\n swiper.snapIndex = snapIndex;\n swiper.emit('snapIndexChange');\n }\n return;\n }\n\n // Get real index\n const realIndex = parseInt(swiper.slides.eq(activeIndex).attr('data-swiper-slide-index') || activeIndex, 10);\n\n Utils.extend(swiper, {\n snapIndex,\n realIndex,\n previousIndex,\n activeIndex,\n });\n swiper.emit('activeIndexChange');\n swiper.emit('snapIndexChange');\n if (previousRealIndex !== realIndex) {\n swiper.emit('realIndexChange');\n }\n if (swiper.initialized || swiper.runCallbacksOnInit) {\n swiper.emit('slideChange');\n }\n}\n\nfunction updateClickedSlide (e) {\n const swiper = this;\n const params = swiper.params;\n const slide = $(e.target).closest(`.${params.slideClass}`)[0];\n let slideFound = false;\n if (slide) {\n for (let i = 0; i < swiper.slides.length; i += 1) {\n if (swiper.slides[i] === slide) slideFound = true;\n }\n }\n\n if (slide && slideFound) {\n swiper.clickedSlide = slide;\n if (swiper.virtual && swiper.params.virtual.enabled) {\n swiper.clickedIndex = parseInt($(slide).attr('data-swiper-slide-index'), 10);\n } else {\n swiper.clickedIndex = $(slide).index();\n }\n } else {\n swiper.clickedSlide = undefined;\n swiper.clickedIndex = undefined;\n return;\n }\n if (params.slideToClickedSlide && swiper.clickedIndex !== undefined && swiper.clickedIndex !== swiper.activeIndex) {\n swiper.slideToClickedSlide();\n }\n}\n\nvar update = {\n updateSize,\n updateSlides,\n updateAutoHeight,\n updateSlidesOffset,\n updateSlidesProgress,\n updateProgress,\n updateSlidesClasses,\n updateActiveIndex,\n updateClickedSlide,\n};\n\nfunction getTranslate (axis = this.isHorizontal() ? 'x' : 'y') {\n const swiper = this;\n\n const {\n params, rtlTranslate: rtl, translate, $wrapperEl,\n } = swiper;\n\n if (params.virtualTranslate) {\n return rtl ? -translate : translate;\n }\n\n let currentTranslate = Utils.getTranslate($wrapperEl[0], axis);\n if (rtl) currentTranslate = -currentTranslate;\n\n return currentTranslate || 0;\n}\n\nfunction setTranslate (translate, byController) {\n const swiper = this;\n const {\n rtlTranslate: rtl, params, $wrapperEl, progress,\n } = swiper;\n let x = 0;\n let y = 0;\n const z = 0;\n\n if (swiper.isHorizontal()) {\n x = rtl ? -translate : translate;\n } else {\n y = translate;\n }\n\n if (params.roundLengths) {\n x = Math.floor(x);\n y = Math.floor(y);\n }\n\n if (!params.virtualTranslate) {\n if (Support.transforms3d) $wrapperEl.transform(`translate3d(${x}px, ${y}px, ${z}px)`);\n else $wrapperEl.transform(`translate(${x}px, ${y}px)`);\n }\n swiper.previousTranslate = swiper.translate;\n swiper.translate = swiper.isHorizontal() ? x : y;\n\n // Check if we need to update progress\n let newProgress;\n const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();\n if (translatesDiff === 0) {\n newProgress = 0;\n } else {\n newProgress = (translate - swiper.minTranslate()) / (translatesDiff);\n }\n if (newProgress !== progress) {\n swiper.updateProgress(translate);\n }\n\n swiper.emit('setTranslate', swiper.translate, byController);\n}\n\nfunction minTranslate () {\n return (-this.snapGrid[0]);\n}\n\nfunction maxTranslate () {\n return (-this.snapGrid[this.snapGrid.length - 1]);\n}\n\nvar translate = {\n getTranslate,\n setTranslate,\n minTranslate,\n maxTranslate,\n};\n\nfunction setTransition (duration, byController) {\n const swiper = this;\n\n swiper.$wrapperEl.transition(duration);\n\n swiper.emit('setTransition', duration, byController);\n}\n\nfunction transitionStart (runCallbacks = true, direction) {\n const swiper = this;\n const { activeIndex, params, previousIndex } = swiper;\n if (params.autoHeight) {\n swiper.updateAutoHeight();\n }\n\n let dir = direction;\n if (!dir) {\n if (activeIndex > previousIndex) dir = 'next';\n else if (activeIndex < previousIndex) dir = 'prev';\n else dir = 'reset';\n }\n\n swiper.emit('transitionStart');\n\n if (runCallbacks && activeIndex !== previousIndex) {\n if (dir === 'reset') {\n swiper.emit('slideResetTransitionStart');\n return;\n }\n swiper.emit('slideChangeTransitionStart');\n if (dir === 'next') {\n swiper.emit('slideNextTransitionStart');\n } else {\n swiper.emit('slidePrevTransitionStart');\n }\n }\n}\n\nfunction transitionEnd (runCallbacks = true, direction) {\n const swiper = this;\n const { activeIndex, previousIndex } = swiper;\n swiper.animating = false;\n swiper.setTransition(0);\n\n let dir = direction;\n if (!dir) {\n if (activeIndex > previousIndex) dir = 'next';\n else if (activeIndex < previousIndex) dir = 'prev';\n else dir = 'reset';\n }\n\n swiper.emit('transitionEnd');\n\n if (runCallbacks && activeIndex !== previousIndex) {\n if (dir === 'reset') {\n swiper.emit('slideResetTransitionEnd');\n return;\n }\n swiper.emit('slideChangeTransitionEnd');\n if (dir === 'next') {\n swiper.emit('slideNextTransitionEnd');\n } else {\n swiper.emit('slidePrevTransitionEnd');\n }\n }\n}\n\nvar transition = {\n setTransition,\n transitionStart,\n transitionEnd,\n};\n\nfunction slideTo (index = 0, speed = this.params.speed, runCallbacks = true, internal) {\n const swiper = this;\n let slideIndex = index;\n if (slideIndex < 0) slideIndex = 0;\n\n const {\n params, snapGrid, slidesGrid, previousIndex, activeIndex, rtlTranslate: rtl,\n } = swiper;\n if (swiper.animating && params.preventInteractionOnTransition) {\n return false;\n }\n\n let snapIndex = Math.floor(slideIndex / params.slidesPerGroup);\n if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;\n\n if ((activeIndex || params.initialSlide || 0) === (previousIndex || 0) && runCallbacks) {\n swiper.emit('beforeSlideChangeStart');\n }\n\n const translate = -snapGrid[snapIndex];\n\n // Update progress\n swiper.updateProgress(translate);\n\n // Normalize slideIndex\n if (params.normalizeSlideIndex) {\n for (let i = 0; i < slidesGrid.length; i += 1) {\n if (-Math.floor(translate * 100) >= Math.floor(slidesGrid[i] * 100)) {\n slideIndex = i;\n }\n }\n }\n // Directions locks\n if (swiper.initialized && slideIndex !== activeIndex) {\n if (!swiper.allowSlideNext && translate < swiper.translate && translate < swiper.minTranslate()) {\n return false;\n }\n if (!swiper.allowSlidePrev && translate > swiper.translate && translate > swiper.maxTranslate()) {\n if ((activeIndex || 0) !== slideIndex) return false;\n }\n }\n\n let direction;\n if (slideIndex > activeIndex) direction = 'next';\n else if (slideIndex < activeIndex) direction = 'prev';\n else direction = 'reset';\n\n\n // Update Index\n if ((rtl && -translate === swiper.translate) || (!rtl && translate === swiper.translate)) {\n swiper.updateActiveIndex(slideIndex);\n // Update Height\n if (params.autoHeight) {\n swiper.updateAutoHeight();\n }\n swiper.updateSlidesClasses();\n if (params.effect !== 'slide') {\n swiper.setTranslate(translate);\n }\n if (direction !== 'reset') {\n swiper.transitionStart(runCallbacks, direction);\n swiper.transitionEnd(runCallbacks, direction);\n }\n return false;\n }\n\n if (speed === 0 || !Support.transition) {\n swiper.setTransition(0);\n swiper.setTranslate(translate);\n swiper.updateActiveIndex(slideIndex);\n swiper.updateSlidesClasses();\n swiper.emit('beforeTransitionStart', speed, internal);\n swiper.transitionStart(runCallbacks, direction);\n swiper.transitionEnd(runCallbacks, direction);\n } else {\n swiper.setTransition(speed);\n swiper.setTranslate(translate);\n swiper.updateActiveIndex(slideIndex);\n swiper.updateSlidesClasses();\n swiper.emit('beforeTransitionStart', speed, internal);\n swiper.transitionStart(runCallbacks, direction);\n if (!swiper.animating) {\n swiper.animating = true;\n if (!swiper.onSlideToWrapperTransitionEnd) {\n swiper.onSlideToWrapperTransitionEnd = function transitionEnd(e) {\n if (!swiper || swiper.destroyed) return;\n if (e.target !== this) return;\n swiper.$wrapperEl[0].removeEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);\n swiper.$wrapperEl[0].removeEventListener('webkitTransitionEnd', swiper.onSlideToWrapperTransitionEnd);\n swiper.onSlideToWrapperTransitionEnd = null;\n delete swiper.onSlideToWrapperTransitionEnd;\n swiper.transitionEnd(runCallbacks, direction);\n };\n }\n swiper.$wrapperEl[0].addEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);\n swiper.$wrapperEl[0].addEventListener('webkitTransitionEnd', swiper.onSlideToWrapperTransitionEnd);\n }\n }\n\n return true;\n}\n\nfunction slideToLoop (index = 0, speed = this.params.speed, runCallbacks = true, internal) {\n const swiper = this;\n let newIndex = index;\n if (swiper.params.loop) {\n newIndex += swiper.loopedSlides;\n }\n\n return swiper.slideTo(newIndex, speed, runCallbacks, internal);\n}\n\n/* eslint no-unused-vars: \"off\" */\nfunction slideNext (speed = this.params.speed, runCallbacks = true, internal) {\n const swiper = this;\n const { params, animating } = swiper;\n if (params.loop) {\n if (animating) return false;\n swiper.loopFix();\n // eslint-disable-next-line\n swiper._clientLeft = swiper.$wrapperEl[0].clientLeft;\n return swiper.slideTo(swiper.activeIndex + params.slidesPerGroup, speed, runCallbacks, internal);\n }\n return swiper.slideTo(swiper.activeIndex + params.slidesPerGroup, speed, runCallbacks, internal);\n}\n\n/* eslint no-unused-vars: \"off\" */\nfunction slidePrev (speed = this.params.speed, runCallbacks = true, internal) {\n const swiper = this;\n const {\n params, animating, snapGrid, slidesGrid, rtlTranslate,\n } = swiper;\n\n if (params.loop) {\n if (animating) return false;\n swiper.loopFix();\n // eslint-disable-next-line\n swiper._clientLeft = swiper.$wrapperEl[0].clientLeft;\n }\n const translate = rtlTranslate ? swiper.translate : -swiper.translate;\n function normalize(val) {\n if (val < 0) return -Math.floor(Math.abs(val));\n return Math.floor(val);\n }\n const normalizedTranslate = normalize(translate);\n const normalizedSnapGrid = snapGrid.map((val) => normalize(val));\n const normalizedSlidesGrid = slidesGrid.map((val) => normalize(val));\n\n const currentSnap = snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate)];\n const prevSnap = snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate) - 1];\n let prevIndex;\n if (typeof prevSnap !== 'undefined') {\n prevIndex = slidesGrid.indexOf(prevSnap);\n if (prevIndex < 0) prevIndex = swiper.activeIndex - 1;\n }\n return swiper.slideTo(prevIndex, speed, runCallbacks, internal);\n}\n\n/* eslint no-unused-vars: \"off\" */\nfunction slideReset (speed = this.params.speed, runCallbacks = true, internal) {\n const swiper = this;\n return swiper.slideTo(swiper.activeIndex, speed, runCallbacks, internal);\n}\n\n/* eslint no-unused-vars: \"off\" */\nfunction slideToClosest (speed = this.params.speed, runCallbacks = true, internal) {\n const swiper = this;\n let index = swiper.activeIndex;\n const snapIndex = Math.floor(index / swiper.params.slidesPerGroup);\n\n if (snapIndex < swiper.snapGrid.length - 1) {\n const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;\n\n const currentSnap = swiper.snapGrid[snapIndex];\n const nextSnap = swiper.snapGrid[snapIndex + 1];\n\n if ((translate - currentSnap) > (nextSnap - currentSnap) / 2) {\n index = swiper.params.slidesPerGroup;\n }\n }\n\n return swiper.slideTo(index, speed, runCallbacks, internal);\n}\n\nfunction slideToClickedSlide () {\n const swiper = this;\n const { params, $wrapperEl } = swiper;\n\n const slidesPerView = params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : params.slidesPerView;\n let slideToIndex = swiper.clickedIndex;\n let realIndex;\n if (params.loop) {\n if (swiper.animating) return;\n realIndex = parseInt($(swiper.clickedSlide).attr('data-swiper-slide-index'), 10);\n if (params.centeredSlides) {\n if (\n (slideToIndex < swiper.loopedSlides - (slidesPerView / 2))\n || (slideToIndex > (swiper.slides.length - swiper.loopedSlides) + (slidesPerView / 2))\n ) {\n swiper.loopFix();\n slideToIndex = $wrapperEl\n .children(`.${params.slideClass}[data-swiper-slide-index=\"${realIndex}\"]:not(.${params.slideDuplicateClass})`)\n .eq(0)\n .index();\n\n Utils.nextTick(() => {\n swiper.slideTo(slideToIndex);\n });\n } else {\n swiper.slideTo(slideToIndex);\n }\n } else if (slideToIndex > swiper.slides.length - slidesPerView) {\n swiper.loopFix();\n slideToIndex = $wrapperEl\n .children(`.${params.slideClass}[data-swiper-slide-index=\"${realIndex}\"]:not(.${params.slideDuplicateClass})`)\n .eq(0)\n .index();\n\n Utils.nextTick(() => {\n swiper.slideTo(slideToIndex);\n });\n } else {\n swiper.slideTo(slideToIndex);\n }\n } else {\n swiper.slideTo(slideToIndex);\n }\n}\n\nvar slide = {\n slideTo,\n slideToLoop,\n slideNext,\n slidePrev,\n slideReset,\n slideToClosest,\n slideToClickedSlide,\n};\n\nfunction loopCreate () {\n const swiper = this;\n const { params, $wrapperEl } = swiper;\n // Remove duplicated slides\n $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}`).remove();\n\n let slides = $wrapperEl.children(`.${params.slideClass}`);\n\n if (params.loopFillGroupWithBlank) {\n const blankSlidesNum = params.slidesPerGroup - (slides.length % params.slidesPerGroup);\n if (blankSlidesNum !== params.slidesPerGroup) {\n for (let i = 0; i < blankSlidesNum; i += 1) {\n const blankNode = $(document.createElement('div')).addClass(`${params.slideClass} ${params.slideBlankClass}`);\n $wrapperEl.append(blankNode);\n }\n slides = $wrapperEl.children(`.${params.slideClass}`);\n }\n }\n\n if (params.slidesPerView === 'auto' && !params.loopedSlides) params.loopedSlides = slides.length;\n\n swiper.loopedSlides = parseInt(params.loopedSlides || params.slidesPerView, 10);\n swiper.loopedSlides += params.loopAdditionalSlides;\n if (swiper.loopedSlides > slides.length) {\n swiper.loopedSlides = slides.length;\n }\n\n const prependSlides = [];\n const appendSlides = [];\n slides.each((index, el) => {\n const slide = $(el);\n if (index < swiper.loopedSlides) appendSlides.push(el);\n if (index < slides.length && index >= slides.length - swiper.loopedSlides) prependSlides.push(el);\n slide.attr('data-swiper-slide-index', index);\n });\n for (let i = 0; i < appendSlides.length; i += 1) {\n $wrapperEl.append($(appendSlides[i].cloneNode(true)).addClass(params.slideDuplicateClass));\n }\n for (let i = prependSlides.length - 1; i >= 0; i -= 1) {\n $wrapperEl.prepend($(prependSlides[i].cloneNode(true)).addClass(params.slideDuplicateClass));\n }\n}\n\nfunction loopFix () {\n const swiper = this;\n const {\n params, activeIndex, slides, loopedSlides, allowSlidePrev, allowSlideNext, snapGrid, rtlTranslate: rtl,\n } = swiper;\n let newIndex;\n swiper.allowSlidePrev = true;\n swiper.allowSlideNext = true;\n\n const snapTranslate = -snapGrid[activeIndex];\n const diff = snapTranslate - swiper.getTranslate();\n\n\n // Fix For Negative Oversliding\n if (activeIndex < loopedSlides) {\n newIndex = (slides.length - (loopedSlides * 3)) + activeIndex;\n newIndex += loopedSlides;\n const slideChanged = swiper.slideTo(newIndex, 0, false, true);\n if (slideChanged && diff !== 0) {\n swiper.setTranslate((rtl ? -swiper.translate : swiper.translate) - diff);\n }\n } else if ((params.slidesPerView === 'auto' && activeIndex >= loopedSlides * 2) || (activeIndex >= slides.length - loopedSlides)) {\n // Fix For Positive Oversliding\n newIndex = -slides.length + activeIndex + loopedSlides;\n newIndex += loopedSlides;\n const slideChanged = swiper.slideTo(newIndex, 0, false, true);\n if (slideChanged && diff !== 0) {\n swiper.setTranslate((rtl ? -swiper.translate : swiper.translate) - diff);\n }\n }\n swiper.allowSlidePrev = allowSlidePrev;\n swiper.allowSlideNext = allowSlideNext;\n}\n\nfunction loopDestroy () {\n const swiper = this;\n const { $wrapperEl, params, slides } = swiper;\n $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass},.${params.slideClass}.${params.slideBlankClass}`).remove();\n slides.removeAttr('data-swiper-slide-index');\n}\n\nvar loop = {\n loopCreate,\n loopFix,\n loopDestroy,\n};\n\nfunction setGrabCursor (moving) {\n const swiper = this;\n if (Support.touch || !swiper.params.simulateTouch || (swiper.params.watchOverflow && swiper.isLocked)) return;\n const el = swiper.el;\n el.style.cursor = 'move';\n el.style.cursor = moving ? '-webkit-grabbing' : '-webkit-grab';\n el.style.cursor = moving ? '-moz-grabbin' : '-moz-grab';\n el.style.cursor = moving ? 'grabbing' : 'grab';\n}\n\nfunction unsetGrabCursor () {\n const swiper = this;\n if (Support.touch || (swiper.params.watchOverflow && swiper.isLocked)) return;\n swiper.el.style.cursor = '';\n}\n\nvar grabCursor = {\n setGrabCursor,\n unsetGrabCursor,\n};\n\nfunction appendSlide (slides) {\n const swiper = this;\n const { $wrapperEl, params } = swiper;\n if (params.loop) {\n swiper.loopDestroy();\n }\n if (typeof slides === 'object' && 'length' in slides) {\n for (let i = 0; i < slides.length; i += 1) {\n if (slides[i]) $wrapperEl.append(slides[i]);\n }\n } else {\n $wrapperEl.append(slides);\n }\n if (params.loop) {\n swiper.loopCreate();\n }\n if (!(params.observer && Support.observer)) {\n swiper.update();\n }\n}\n\nfunction prependSlide (slides) {\n const swiper = this;\n const { params, $wrapperEl, activeIndex } = swiper;\n\n if (params.loop) {\n swiper.loopDestroy();\n }\n let newActiveIndex = activeIndex + 1;\n if (typeof slides === 'object' && 'length' in slides) {\n for (let i = 0; i < slides.length; i += 1) {\n if (slides[i]) $wrapperEl.prepend(slides[i]);\n }\n newActiveIndex = activeIndex + slides.length;\n } else {\n $wrapperEl.prepend(slides);\n }\n if (params.loop) {\n swiper.loopCreate();\n }\n if (!(params.observer && Support.observer)) {\n swiper.update();\n }\n swiper.slideTo(newActiveIndex, 0, false);\n}\n\nfunction addSlide (index, slides) {\n const swiper = this;\n const { $wrapperEl, params, activeIndex } = swiper;\n let activeIndexBuffer = activeIndex;\n if (params.loop) {\n activeIndexBuffer -= swiper.loopedSlides;\n swiper.loopDestroy();\n swiper.slides = $wrapperEl.children(`.${params.slideClass}`);\n }\n const baseLength = swiper.slides.length;\n if (index <= 0) {\n swiper.prependSlide(slides);\n return;\n }\n if (index >= baseLength) {\n swiper.appendSlide(slides);\n return;\n }\n let newActiveIndex = activeIndexBuffer > index ? activeIndexBuffer + 1 : activeIndexBuffer;\n\n const slidesBuffer = [];\n for (let i = baseLength - 1; i >= index; i -= 1) {\n const currentSlide = swiper.slides.eq(i);\n currentSlide.remove();\n slidesBuffer.unshift(currentSlide);\n }\n\n if (typeof slides === 'object' && 'length' in slides) {\n for (let i = 0; i < slides.length; i += 1) {\n if (slides[i]) $wrapperEl.append(slides[i]);\n }\n newActiveIndex = activeIndexBuffer > index ? activeIndexBuffer + slides.length : activeIndexBuffer;\n } else {\n $wrapperEl.append(slides);\n }\n\n for (let i = 0; i < slidesBuffer.length; i += 1) {\n $wrapperEl.append(slidesBuffer[i]);\n }\n\n if (params.loop) {\n swiper.loopCreate();\n }\n if (!(params.observer && Support.observer)) {\n swiper.update();\n }\n if (params.loop) {\n swiper.slideTo(newActiveIndex + swiper.loopedSlides, 0, false);\n } else {\n swiper.slideTo(newActiveIndex, 0, false);\n }\n}\n\nfunction removeSlide (slidesIndexes) {\n const swiper = this;\n const { params, $wrapperEl, activeIndex } = swiper;\n\n let activeIndexBuffer = activeIndex;\n if (params.loop) {\n activeIndexBuffer -= swiper.loopedSlides;\n swiper.loopDestroy();\n swiper.slides = $wrapperEl.children(`.${params.slideClass}`);\n }\n let newActiveIndex = activeIndexBuffer;\n let indexToRemove;\n\n if (typeof slidesIndexes === 'object' && 'length' in slidesIndexes) {\n for (let i = 0; i < slidesIndexes.length; i += 1) {\n indexToRemove = slidesIndexes[i];\n if (swiper.slides[indexToRemove]) swiper.slides.eq(indexToRemove).remove();\n if (indexToRemove < newActiveIndex) newActiveIndex -= 1;\n }\n newActiveIndex = Math.max(newActiveIndex, 0);\n } else {\n indexToRemove = slidesIndexes;\n if (swiper.slides[indexToRemove]) swiper.slides.eq(indexToRemove).remove();\n if (indexToRemove < newActiveIndex) newActiveIndex -= 1;\n newActiveIndex = Math.max(newActiveIndex, 0);\n }\n\n if (params.loop) {\n swiper.loopCreate();\n }\n\n if (!(params.observer && Support.observer)) {\n swiper.update();\n }\n if (params.loop) {\n swiper.slideTo(newActiveIndex + swiper.loopedSlides, 0, false);\n } else {\n swiper.slideTo(newActiveIndex, 0, false);\n }\n}\n\nfunction removeAllSlides () {\n const swiper = this;\n\n const slidesIndexes = [];\n for (let i = 0; i < swiper.slides.length; i += 1) {\n slidesIndexes.push(i);\n }\n swiper.removeSlide(slidesIndexes);\n}\n\nvar manipulation = {\n appendSlide,\n prependSlide,\n addSlide,\n removeSlide,\n removeAllSlides,\n};\n\nconst Device = (function Device() {\n const ua = window.navigator.userAgent;\n\n const device = {\n ios: false,\n android: false,\n androidChrome: false,\n desktop: false,\n windows: false,\n iphone: false,\n ipod: false,\n ipad: false,\n cordova: window.cordova || window.phonegap,\n phonegap: window.cordova || window.phonegap,\n };\n\n const windows = ua.match(/(Windows Phone);?[\\s\\/]+([\\d.]+)?/); // eslint-disable-line\n const android = ua.match(/(Android);?[\\s\\/]+([\\d.]+)?/); // eslint-disable-line\n const ipad = ua.match(/(iPad).*OS\\s([\\d_]+)/);\n const ipod = ua.match(/(iPod)(.*OS\\s([\\d_]+))?/);\n const iphone = !ipad && ua.match(/(iPhone\\sOS|iOS)\\s([\\d_]+)/);\n\n\n // Windows\n if (windows) {\n device.os = 'windows';\n device.osVersion = windows[2];\n device.windows = true;\n }\n // Android\n if (android && !windows) {\n device.os = 'android';\n device.osVersion = android[2];\n device.android = true;\n device.androidChrome = ua.toLowerCase().indexOf('chrome') >= 0;\n }\n if (ipad || iphone || ipod) {\n device.os = 'ios';\n device.ios = true;\n }\n // iOS\n if (iphone && !ipod) {\n device.osVersion = iphone[2].replace(/_/g, '.');\n device.iphone = true;\n }\n if (ipad) {\n device.osVersion = ipad[2].replace(/_/g, '.');\n device.ipad = true;\n }\n if (ipod) {\n device.osVersion = ipod[3] ? ipod[3].replace(/_/g, '.') : null;\n device.iphone = true;\n }\n // iOS 8+ changed UA\n if (device.ios && device.osVersion && ua.indexOf('Version/') >= 0) {\n if (device.osVersion.split('.')[0] === '10') {\n device.osVersion = ua.toLowerCase().split('version/')[1].split(' ')[0];\n }\n }\n\n // Desktop\n device.desktop = !(device.os || device.android || device.webView);\n\n // Webview\n device.webView = (iphone || ipad || ipod) && ua.match(/.*AppleWebKit(?!.*Safari)/i);\n\n // Minimal UI\n if (device.os && device.os === 'ios') {\n const osVersionArr = device.osVersion.split('.');\n const metaViewport = document.querySelector('meta[name=\"viewport\"]');\n device.minimalUi = !device.webView\n && (ipod || iphone)\n && (osVersionArr[0] * 1 === 7 ? osVersionArr[1] * 1 >= 1 : osVersionArr[0] * 1 > 7)\n && metaViewport && metaViewport.getAttribute('content').indexOf('minimal-ui') >= 0;\n }\n\n // Pixel Ratio\n device.pixelRatio = window.devicePixelRatio || 1;\n\n // Export object\n return device;\n}());\n\nfunction onTouchStart (event) {\n const swiper = this;\n const data = swiper.touchEventsData;\n const { params, touches } = swiper;\n if (swiper.animating && params.preventInteractionOnTransition) {\n return;\n }\n let e = event;\n if (e.originalEvent) e = e.originalEvent;\n data.isTouchEvent = e.type === 'touchstart';\n if (!data.isTouchEvent && 'which' in e && e.which === 3) return;\n if (!data.isTouchEvent && 'button' in e && e.button > 0) return;\n if (data.isTouched && data.isMoved) return;\n if (params.noSwiping && $(e.target).closest(params.noSwipingSelector ? params.noSwipingSelector : `.${params.noSwipingClass}`)[0]) {\n swiper.allowClick = true;\n return;\n }\n if (params.swipeHandler) {\n if (!$(e).closest(params.swipeHandler)[0]) return;\n }\n\n touches.currentX = e.type === 'touchstart' ? e.targetTouches[0].pageX : e.pageX;\n touches.currentY = e.type === 'touchstart' ? e.targetTouches[0].pageY : e.pageY;\n const startX = touches.currentX;\n const startY = touches.currentY;\n\n // Do NOT start if iOS edge swipe is detected. Otherwise iOS app (UIWebView) cannot swipe-to-go-back anymore\n\n const edgeSwipeDetection = params.edgeSwipeDetection || params.iOSEdgeSwipeDetection;\n const edgeSwipeThreshold = params.edgeSwipeThreshold || params.iOSEdgeSwipeThreshold;\n if (\n edgeSwipeDetection\n && ((startX <= edgeSwipeThreshold)\n || (startX >= window.screen.width - edgeSwipeThreshold))\n ) {\n return;\n }\n\n Utils.extend(data, {\n isTouched: true,\n isMoved: false,\n allowTouchCallbacks: true,\n isScrolling: undefined,\n startMoving: undefined,\n });\n\n touches.startX = startX;\n touches.startY = startY;\n data.touchStartTime = Utils.now();\n swiper.allowClick = true;\n swiper.updateSize();\n swiper.swipeDirection = undefined;\n if (params.threshold > 0) data.allowThresholdMove = false;\n if (e.type !== 'touchstart') {\n let preventDefault = true;\n if ($(e.target).is(data.formElements)) preventDefault = false;\n if (\n document.activeElement\n && $(document.activeElement).is(data.formElements)\n && document.activeElement !== e.target\n ) {\n document.activeElement.blur();\n }\n\n const shouldPreventDefault = preventDefault && swiper.allowTouchMove && params.touchStartPreventDefault;\n if (params.touchStartForcePreventDefault || shouldPreventDefault) {\n e.preventDefault();\n }\n }\n swiper.emit('touchStart', e);\n}\n\nfunction onTouchMove (event) {\n const swiper = this;\n const data = swiper.touchEventsData;\n const { params, touches, rtlTranslate: rtl } = swiper;\n let e = event;\n if (e.originalEvent) e = e.originalEvent;\n if (!data.isTouched) {\n if (data.startMoving && data.isScrolling) {\n swiper.emit('touchMoveOpposite', e);\n }\n return;\n }\n if (data.isTouchEvent && e.type === 'mousemove') return;\n const pageX = e.type === 'touchmove' ? e.targetTouches[0].pageX : e.pageX;\n const pageY = e.type === 'touchmove' ? e.targetTouches[0].pageY : e.pageY;\n if (e.preventedByNestedSwiper) {\n touches.startX = pageX;\n touches.startY = pageY;\n return;\n }\n if (!swiper.allowTouchMove) {\n // isMoved = true;\n swiper.allowClick = false;\n if (data.isTouched) {\n Utils.extend(touches, {\n startX: pageX,\n startY: pageY,\n currentX: pageX,\n currentY: pageY,\n });\n data.touchStartTime = Utils.now();\n }\n return;\n }\n if (data.isTouchEvent && params.touchReleaseOnEdges && !params.loop) {\n if (swiper.isVertical()) {\n // Vertical\n if (\n (pageY < touches.startY && swiper.translate <= swiper.maxTranslate())\n || (pageY > touches.startY && swiper.translate >= swiper.minTranslate())\n ) {\n data.isTouched = false;\n data.isMoved = false;\n return;\n }\n } else if (\n (pageX < touches.startX && swiper.translate <= swiper.maxTranslate())\n || (pageX > touches.startX && swiper.translate >= swiper.minTranslate())\n ) {\n return;\n }\n }\n if (data.isTouchEvent && document.activeElement) {\n if (e.target === document.activeElement && $(e.target).is(data.formElements)) {\n data.isMoved = true;\n swiper.allowClick = false;\n return;\n }\n }\n if (data.allowTouchCallbacks) {\n swiper.emit('touchMove', e);\n }\n if (e.targetTouches && e.targetTouches.length > 1) return;\n\n touches.currentX = pageX;\n touches.currentY = pageY;\n\n const diffX = touches.currentX - touches.startX;\n const diffY = touches.currentY - touches.startY;\n if (swiper.params.threshold && Math.sqrt((diffX ** 2) + (diffY ** 2)) < swiper.params.threshold) return;\n\n if (typeof data.isScrolling === 'undefined') {\n let touchAngle;\n if ((swiper.isHorizontal() && touches.currentY === touches.startY) || (swiper.isVertical() && touches.currentX === touches.startX)) {\n data.isScrolling = false;\n } else {\n // eslint-disable-next-line\n if ((diffX * diffX) + (diffY * diffY) >= 25) {\n touchAngle = (Math.atan2(Math.abs(diffY), Math.abs(diffX)) * 180) / Math.PI;\n data.isScrolling = swiper.isHorizontal() ? touchAngle > params.touchAngle : (90 - touchAngle > params.touchAngle);\n }\n }\n }\n if (data.isScrolling) {\n swiper.emit('touchMoveOpposite', e);\n }\n if (typeof data.startMoving === 'undefined') {\n if (touches.currentX !== touches.startX || touches.currentY !== touches.startY) {\n data.startMoving = true;\n }\n }\n if (data.isScrolling) {\n data.isTouched = false;\n return;\n }\n if (!data.startMoving) {\n return;\n }\n swiper.allowClick = false;\n e.preventDefault();\n if (params.touchMoveStopPropagation && !params.nested) {\n e.stopPropagation();\n }\n\n if (!data.isMoved) {\n if (params.loop) {\n swiper.loopFix();\n }\n data.startTranslate = swiper.getTranslate();\n swiper.setTransition(0);\n if (swiper.animating) {\n swiper.$wrapperEl.trigger('webkitTransitionEnd transitionend');\n }\n data.allowMomentumBounce = false;\n // Grab Cursor\n if (params.grabCursor && (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) {\n swiper.setGrabCursor(true);\n }\n swiper.emit('sliderFirstMove', e);\n }\n swiper.emit('sliderMove', e);\n data.isMoved = true;\n\n let diff = swiper.isHorizontal() ? diffX : diffY;\n touches.diff = diff;\n\n diff *= params.touchRatio;\n if (rtl) diff = -diff;\n\n swiper.swipeDirection = diff > 0 ? 'prev' : 'next';\n data.currentTranslate = diff + data.startTranslate;\n\n let disableParentSwiper = true;\n let resistanceRatio = params.resistanceRatio;\n if (params.touchReleaseOnEdges) {\n resistanceRatio = 0;\n }\n if ((diff > 0 && data.currentTranslate > swiper.minTranslate())) {\n disableParentSwiper = false;\n if (params.resistance) data.currentTranslate = (swiper.minTranslate() - 1) + ((-swiper.minTranslate() + data.startTranslate + diff) ** resistanceRatio);\n } else if (diff < 0 && data.currentTranslate < swiper.maxTranslate()) {\n disableParentSwiper = false;\n if (params.resistance) data.currentTranslate = (swiper.maxTranslate() + 1) - ((swiper.maxTranslate() - data.startTranslate - diff) ** resistanceRatio);\n }\n\n if (disableParentSwiper) {\n e.preventedByNestedSwiper = true;\n }\n\n // Directions locks\n if (!swiper.allowSlideNext && swiper.swipeDirection === 'next' && data.currentTranslate < data.startTranslate) {\n data.currentTranslate = data.startTranslate;\n }\n if (!swiper.allowSlidePrev && swiper.swipeDirection === 'prev' && data.currentTranslate > data.startTranslate) {\n data.currentTranslate = data.startTranslate;\n }\n\n\n // Threshold\n if (params.threshold > 0) {\n if (Math.abs(diff) > params.threshold || data.allowThresholdMove) {\n if (!data.allowThresholdMove) {\n data.allowThresholdMove = true;\n touches.startX = touches.currentX;\n touches.startY = touches.currentY;\n data.currentTranslate = data.startTranslate;\n touches.diff = swiper.isHorizontal() ? touches.currentX - touches.startX : touches.currentY - touches.startY;\n return;\n }\n } else {\n data.currentTranslate = data.startTranslate;\n return;\n }\n }\n\n if (!params.followFinger) return;\n\n // Update active index in free mode\n if (params.freeMode || params.watchSlidesProgress || params.watchSlidesVisibility) {\n swiper.updateActiveIndex();\n swiper.updateSlidesClasses();\n }\n if (params.freeMode) {\n // Velocity\n if (data.velocities.length === 0) {\n data.velocities.push({\n position: touches[swiper.isHorizontal() ? 'startX' : 'startY'],\n time: data.touchStartTime,\n });\n }\n data.velocities.push({\n position: touches[swiper.isHorizontal() ? 'currentX' : 'currentY'],\n time: Utils.now(),\n });\n }\n // Update progress\n swiper.updateProgress(data.currentTranslate);\n // Update translate\n swiper.setTranslate(data.currentTranslate);\n}\n\nfunction onTouchEnd (event) {\n const swiper = this;\n const data = swiper.touchEventsData;\n\n const {\n params, touches, rtlTranslate: rtl, $wrapperEl, slidesGrid, snapGrid,\n } = swiper;\n let e = event;\n if (e.originalEvent) e = e.originalEvent;\n if (data.allowTouchCallbacks) {\n swiper.emit('touchEnd', e);\n }\n data.allowTouchCallbacks = false;\n if (!data.isTouched) {\n if (data.isMoved && params.grabCursor) {\n swiper.setGrabCursor(false);\n }\n data.isMoved = false;\n data.startMoving = false;\n return;\n }\n // Return Grab Cursor\n if (params.grabCursor && data.isMoved && data.isTouched && (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) {\n swiper.setGrabCursor(false);\n }\n\n // Time diff\n const touchEndTime = Utils.now();\n const timeDiff = touchEndTime - data.touchStartTime;\n\n // Tap, doubleTap, Click\n if (swiper.allowClick) {\n swiper.updateClickedSlide(e);\n swiper.emit('tap', e);\n if (timeDiff < 300 && (touchEndTime - data.lastClickTime) > 300) {\n if (data.clickTimeout) clearTimeout(data.clickTimeout);\n data.clickTimeout = Utils.nextTick(() => {\n if (!swiper || swiper.destroyed) return;\n swiper.emit('click', e);\n }, 300);\n }\n if (timeDiff < 300 && (touchEndTime - data.lastClickTime) < 300) {\n if (data.clickTimeout) clearTimeout(data.clickTimeout);\n swiper.emit('doubleTap', e);\n }\n }\n\n data.lastClickTime = Utils.now();\n Utils.nextTick(() => {\n if (!swiper.destroyed) swiper.allowClick = true;\n });\n\n if (!data.isTouched || !data.isMoved || !swiper.swipeDirection || touches.diff === 0 || data.currentTranslate === data.startTranslate) {\n data.isTouched = false;\n data.isMoved = false;\n data.startMoving = false;\n return;\n }\n data.isTouched = false;\n data.isMoved = false;\n data.startMoving = false;\n\n let currentPos;\n if (params.followFinger) {\n currentPos = rtl ? swiper.translate : -swiper.translate;\n } else {\n currentPos = -data.currentTranslate;\n }\n\n if (params.freeMode) {\n if (currentPos < -swiper.minTranslate()) {\n swiper.slideTo(swiper.activeIndex);\n return;\n }\n if (currentPos > -swiper.maxTranslate()) {\n if (swiper.slides.length < snapGrid.length) {\n swiper.slideTo(snapGrid.length - 1);\n } else {\n swiper.slideTo(swiper.slides.length - 1);\n }\n return;\n }\n\n if (params.freeModeMomentum) {\n if (data.velocities.length > 1) {\n const lastMoveEvent = data.velocities.pop();\n const velocityEvent = data.velocities.pop();\n\n const distance = lastMoveEvent.position - velocityEvent.position;\n const time = lastMoveEvent.time - velocityEvent.time;\n swiper.velocity = distance / time;\n swiper.velocity /= 2;\n if (Math.abs(swiper.velocity) < params.freeModeMinimumVelocity) {\n swiper.velocity = 0;\n }\n // this implies that the user stopped moving a finger then released.\n // There would be no events with distance zero, so the last event is stale.\n if (time > 150 || (Utils.now() - lastMoveEvent.time) > 300) {\n swiper.velocity = 0;\n }\n } else {\n swiper.velocity = 0;\n }\n swiper.velocity *= params.freeModeMomentumVelocityRatio;\n\n data.velocities.length = 0;\n let momentumDuration = 1000 * params.freeModeMomentumRatio;\n const momentumDistance = swiper.velocity * momentumDuration;\n\n let newPosition = swiper.translate + momentumDistance;\n if (rtl) newPosition = -newPosition;\n\n let doBounce = false;\n let afterBouncePosition;\n const bounceAmount = Math.abs(swiper.velocity) * 20 * params.freeModeMomentumBounceRatio;\n let needsLoopFix;\n if (newPosition < swiper.maxTranslate()) {\n if (params.freeModeMomentumBounce) {\n if (newPosition + swiper.maxTranslate() < -bounceAmount) {\n newPosition = swiper.maxTranslate() - bounceAmount;\n }\n afterBouncePosition = swiper.maxTranslate();\n doBounce = true;\n data.allowMomentumBounce = true;\n } else {\n newPosition = swiper.maxTranslate();\n }\n if (params.loop && params.centeredSlides) needsLoopFix = true;\n } else if (newPosition > swiper.minTranslate()) {\n if (params.freeModeMomentumBounce) {\n if (newPosition - swiper.minTranslate() > bounceAmount) {\n newPosition = swiper.minTranslate() + bounceAmount;\n }\n afterBouncePosition = swiper.minTranslate();\n doBounce = true;\n data.allowMomentumBounce = true;\n } else {\n newPosition = swiper.minTranslate();\n }\n if (params.loop && params.centeredSlides) needsLoopFix = true;\n } else if (params.freeModeSticky) {\n let nextSlide;\n for (let j = 0; j < snapGrid.length; j += 1) {\n if (snapGrid[j] > -newPosition) {\n nextSlide = j;\n break;\n }\n }\n\n if (Math.abs(snapGrid[nextSlide] - newPosition) < Math.abs(snapGrid[nextSlide - 1] - newPosition) || swiper.swipeDirection === 'next') {\n newPosition = snapGrid[nextSlide];\n } else {\n newPosition = snapGrid[nextSlide - 1];\n }\n newPosition = -newPosition;\n }\n if (needsLoopFix) {\n swiper.once('transitionEnd', () => {\n swiper.loopFix();\n });\n }\n // Fix duration\n if (swiper.velocity !== 0) {\n if (rtl) {\n momentumDuration = Math.abs((-newPosition - swiper.translate) / swiper.velocity);\n } else {\n momentumDuration = Math.abs((newPosition - swiper.translate) / swiper.velocity);\n }\n } else if (params.freeModeSticky) {\n swiper.slideToClosest();\n return;\n }\n\n if (params.freeModeMomentumBounce && doBounce) {\n swiper.updateProgress(afterBouncePosition);\n swiper.setTransition(momentumDuration);\n swiper.setTranslate(newPosition);\n swiper.transitionStart(true, swiper.swipeDirection);\n swiper.animating = true;\n $wrapperEl.transitionEnd(() => {\n if (!swiper || swiper.destroyed || !data.allowMomentumBounce) return;\n swiper.emit('momentumBounce');\n\n swiper.setTransition(params.speed);\n swiper.setTranslate(afterBouncePosition);\n $wrapperEl.transitionEnd(() => {\n if (!swiper || swiper.destroyed) return;\n swiper.transitionEnd();\n });\n });\n } else if (swiper.velocity) {\n swiper.updateProgress(newPosition);\n swiper.setTransition(momentumDuration);\n swiper.setTranslate(newPosition);\n swiper.transitionStart(true, swiper.swipeDirection);\n if (!swiper.animating) {\n swiper.animating = true;\n $wrapperEl.transitionEnd(() => {\n if (!swiper || swiper.destroyed) return;\n swiper.transitionEnd();\n });\n }\n } else {\n swiper.updateProgress(newPosition);\n }\n\n swiper.updateActiveIndex();\n swiper.updateSlidesClasses();\n } else if (params.freeModeSticky) {\n swiper.slideToClosest();\n return;\n }\n\n if (!params.freeModeMomentum || timeDiff >= params.longSwipesMs) {\n swiper.updateProgress();\n swiper.updateActiveIndex();\n swiper.updateSlidesClasses();\n }\n return;\n }\n\n // Find current slide\n let stopIndex = 0;\n let groupSize = swiper.slidesSizesGrid[0];\n for (let i = 0; i < slidesGrid.length; i += params.slidesPerGroup) {\n if (typeof slidesGrid[i + params.slidesPerGroup] !== 'undefined') {\n if (currentPos >= slidesGrid[i] && currentPos < slidesGrid[i + params.slidesPerGroup]) {\n stopIndex = i;\n groupSize = slidesGrid[i + params.slidesPerGroup] - slidesGrid[i];\n }\n } else if (currentPos >= slidesGrid[i]) {\n stopIndex = i;\n groupSize = slidesGrid[slidesGrid.length - 1] - slidesGrid[slidesGrid.length - 2];\n }\n }\n\n // Find current slide size\n const ratio = (currentPos - slidesGrid[stopIndex]) / groupSize;\n\n if (timeDiff > params.longSwipesMs) {\n // Long touches\n if (!params.longSwipes) {\n swiper.slideTo(swiper.activeIndex);\n return;\n }\n if (swiper.swipeDirection === 'next') {\n if (ratio >= params.longSwipesRatio) swiper.slideTo(stopIndex + params.slidesPerGroup);\n else swiper.slideTo(stopIndex);\n }\n if (swiper.swipeDirection === 'prev') {\n if (ratio > (1 - params.longSwipesRatio)) swiper.slideTo(stopIndex + params.slidesPerGroup);\n else swiper.slideTo(stopIndex);\n }\n } else {\n // Short swipes\n if (!params.shortSwipes) {\n swiper.slideTo(swiper.activeIndex);\n return;\n }\n if (swiper.swipeDirection === 'next') {\n swiper.slideTo(stopIndex + params.slidesPerGroup);\n }\n if (swiper.swipeDirection === 'prev') {\n swiper.slideTo(stopIndex);\n }\n }\n}\n\nfunction onResize () {\n const swiper = this;\n\n const { params, el } = swiper;\n\n if (el && el.offsetWidth === 0) return;\n\n // Breakpoints\n if (params.breakpoints) {\n swiper.setBreakpoint();\n }\n\n // Save locks\n const { allowSlideNext, allowSlidePrev, snapGrid } = swiper;\n\n // Disable locks on resize\n swiper.allowSlideNext = true;\n swiper.allowSlidePrev = true;\n\n swiper.updateSize();\n swiper.updateSlides();\n\n if (params.freeMode) {\n const newTranslate = Math.min(Math.max(swiper.translate, swiper.maxTranslate()), swiper.minTranslate());\n swiper.setTranslate(newTranslate);\n swiper.updateActiveIndex();\n swiper.updateSlidesClasses();\n\n if (params.autoHeight) {\n swiper.updateAutoHeight();\n }\n } else {\n swiper.updateSlidesClasses();\n if ((params.slidesPerView === 'auto' || params.slidesPerView > 1) && swiper.isEnd && !swiper.params.centeredSlides) {\n swiper.slideTo(swiper.slides.length - 1, 0, false, true);\n } else {\n swiper.slideTo(swiper.activeIndex, 0, false, true);\n }\n }\n if (swiper.autoplay && swiper.autoplay.running && swiper.autoplay.paused) {\n swiper.autoplay.run();\n }\n // Return locks after resize\n swiper.allowSlidePrev = allowSlidePrev;\n swiper.allowSlideNext = allowSlideNext;\n\n if (swiper.params.watchOverflow && snapGrid !== swiper.snapGrid) {\n swiper.checkOverflow();\n }\n}\n\nfunction onClick (e) {\n const swiper = this;\n if (!swiper.allowClick) {\n if (swiper.params.preventClicks) e.preventDefault();\n if (swiper.params.preventClicksPropagation && swiper.animating) {\n e.stopPropagation();\n e.stopImmediatePropagation();\n }\n }\n}\n\nfunction attachEvents() {\n const swiper = this;\n const {\n params, touchEvents, el, wrapperEl,\n } = swiper;\n\n {\n swiper.onTouchStart = onTouchStart.bind(swiper);\n swiper.onTouchMove = onTouchMove.bind(swiper);\n swiper.onTouchEnd = onTouchEnd.bind(swiper);\n }\n\n swiper.onClick = onClick.bind(swiper);\n\n const target = params.touchEventsTarget === 'container' ? el : wrapperEl;\n const capture = !!params.nested;\n\n // Touch Events\n {\n if (!Support.touch && (Support.pointerEvents || Support.prefixedPointerEvents)) {\n target.addEventListener(touchEvents.start, swiper.onTouchStart, false);\n document.addEventListener(touchEvents.move, swiper.onTouchMove, capture);\n document.addEventListener(touchEvents.end, swiper.onTouchEnd, false);\n } else {\n if (Support.touch) {\n const passiveListener = touchEvents.start === 'touchstart' && Support.passiveListener && params.passiveListeners ? { passive: true, capture: false } : false;\n target.addEventListener(touchEvents.start, swiper.onTouchStart, passiveListener);\n target.addEventListener(touchEvents.move, swiper.onTouchMove, Support.passiveListener ? { passive: false, capture } : capture);\n target.addEventListener(touchEvents.end, swiper.onTouchEnd, passiveListener);\n }\n if ((params.simulateTouch && !Device.ios && !Device.android) || (params.simulateTouch && !Support.touch && Device.ios)) {\n target.addEventListener('mousedown', swiper.onTouchStart, false);\n document.addEventListener('mousemove', swiper.onTouchMove, capture);\n document.addEventListener('mouseup', swiper.onTouchEnd, false);\n }\n }\n // Prevent Links Clicks\n if (params.preventClicks || params.preventClicksPropagation) {\n target.addEventListener('click', swiper.onClick, true);\n }\n }\n\n // Resize handler\n swiper.on((Device.ios || Device.android ? 'resize orientationchange observerUpdate' : 'resize observerUpdate'), onResize, true);\n}\n\nfunction detachEvents() {\n const swiper = this;\n\n const {\n params, touchEvents, el, wrapperEl,\n } = swiper;\n\n const target = params.touchEventsTarget === 'container' ? el : wrapperEl;\n const capture = !!params.nested;\n\n // Touch Events\n {\n if (!Support.touch && (Support.pointerEvents || Support.prefixedPointerEvents)) {\n target.removeEventListener(touchEvents.start, swiper.onTouchStart, false);\n document.removeEventListener(touchEvents.move, swiper.onTouchMove, capture);\n document.removeEventListener(touchEvents.end, swiper.onTouchEnd, false);\n } else {\n if (Support.touch) {\n const passiveListener = touchEvents.start === 'onTouchStart' && Support.passiveListener && params.passiveListeners ? { passive: true, capture: false } : false;\n target.removeEventListener(touchEvents.start, swiper.onTouchStart, passiveListener);\n target.removeEventListener(touchEvents.move, swiper.onTouchMove, capture);\n target.removeEventListener(touchEvents.end, swiper.onTouchEnd, passiveListener);\n }\n if ((params.simulateTouch && !Device.ios && !Device.android) || (params.simulateTouch && !Support.touch && Device.ios)) {\n target.removeEventListener('mousedown', swiper.onTouchStart, false);\n document.removeEventListener('mousemove', swiper.onTouchMove, capture);\n document.removeEventListener('mouseup', swiper.onTouchEnd, false);\n }\n }\n // Prevent Links Clicks\n if (params.preventClicks || params.preventClicksPropagation) {\n target.removeEventListener('click', swiper.onClick, true);\n }\n }\n\n // Resize handler\n swiper.off((Device.ios || Device.android ? 'resize orientationchange observerUpdate' : 'resize observerUpdate'), onResize);\n}\n\nvar events = {\n attachEvents,\n detachEvents,\n};\n\nfunction setBreakpoint () {\n const swiper = this;\n const {\n activeIndex, initialized, loopedSlides = 0, params,\n } = swiper;\n const breakpoints = params.breakpoints;\n if (!breakpoints || (breakpoints && Object.keys(breakpoints).length === 0)) return;\n\n // Set breakpoint for window width and update parameters\n const breakpoint = swiper.getBreakpoint(breakpoints);\n\n if (breakpoint && swiper.currentBreakpoint !== breakpoint) {\n const breakpointOnlyParams = breakpoint in breakpoints ? breakpoints[breakpoint] : undefined;\n if (breakpointOnlyParams) {\n ['slidesPerView', 'spaceBetween', 'slidesPerGroup'].forEach((param) => {\n const paramValue = breakpointOnlyParams[param];\n if (typeof paramValue === 'undefined') return;\n if (param === 'slidesPerView' && (paramValue === 'AUTO' || paramValue === 'auto')) {\n breakpointOnlyParams[param] = 'auto';\n } else if (param === 'slidesPerView') {\n breakpointOnlyParams[param] = parseFloat(paramValue);\n } else {\n breakpointOnlyParams[param] = parseInt(paramValue, 10);\n }\n });\n }\n\n const breakpointParams = breakpointOnlyParams || swiper.originalParams;\n const directionChanged = breakpointParams.direction && breakpointParams.direction !== params.direction;\n const needsReLoop = params.loop && (breakpointParams.slidesPerView !== params.slidesPerView || directionChanged);\n\n if (directionChanged && initialized) {\n swiper.changeDirection();\n }\n\n Utils.extend(swiper.params, breakpointParams);\n\n Utils.extend(swiper, {\n allowTouchMove: swiper.params.allowTouchMove,\n allowSlideNext: swiper.params.allowSlideNext,\n allowSlidePrev: swiper.params.allowSlidePrev,\n });\n\n swiper.currentBreakpoint = breakpoint;\n\n if (needsReLoop && initialized) {\n swiper.loopDestroy();\n swiper.loopCreate();\n swiper.updateSlides();\n swiper.slideTo((activeIndex - loopedSlides) + swiper.loopedSlides, 0, false);\n }\n\n swiper.emit('breakpoint', breakpointParams);\n }\n}\n\nfunction getBreakpoint (breakpoints) {\n const swiper = this;\n // Get breakpoint for window width\n if (!breakpoints) return undefined;\n let breakpoint = false;\n const points = [];\n Object.keys(breakpoints).forEach((point) => {\n points.push(point);\n });\n points.sort((a, b) => parseInt(a, 10) - parseInt(b, 10));\n for (let i = 0; i < points.length; i += 1) {\n const point = points[i];\n if (swiper.params.breakpointsInverse) {\n if (point <= window.innerWidth) {\n breakpoint = point;\n }\n } else if (point >= window.innerWidth && !breakpoint) {\n breakpoint = point;\n }\n }\n return breakpoint || 'max';\n}\n\nvar breakpoints = { setBreakpoint, getBreakpoint };\n\nfunction addClasses () {\n const swiper = this;\n const {\n classNames, params, rtl, $el,\n } = swiper;\n const suffixes = [];\n\n suffixes.push('initialized');\n suffixes.push(params.direction);\n\n if (params.freeMode) {\n suffixes.push('free-mode');\n }\n if (!Support.flexbox) {\n suffixes.push('no-flexbox');\n }\n if (params.autoHeight) {\n suffixes.push('autoheight');\n }\n if (rtl) {\n suffixes.push('rtl');\n }\n if (params.slidesPerColumn > 1) {\n suffixes.push('multirow');\n }\n if (Device.android) {\n suffixes.push('android');\n }\n if (Device.ios) {\n suffixes.push('ios');\n }\n // WP8 Touch Events Fix\n if ((Browser.isIE || Browser.isEdge) && (Support.pointerEvents || Support.prefixedPointerEvents)) {\n suffixes.push(`wp8-${params.direction}`);\n }\n\n suffixes.forEach((suffix) => {\n classNames.push(params.containerModifierClass + suffix);\n });\n\n $el.addClass(classNames.join(' '));\n}\n\nfunction removeClasses () {\n const swiper = this;\n const { $el, classNames } = swiper;\n\n $el.removeClass(classNames.join(' '));\n}\n\nvar classes = { addClasses, removeClasses };\n\nfunction loadImage (imageEl, src, srcset, sizes, checkForComplete, callback) {\n let image;\n function onReady() {\n if (callback) callback();\n }\n if (!imageEl.complete || !checkForComplete) {\n if (src) {\n image = new window.Image();\n image.onload = onReady;\n image.onerror = onReady;\n if (sizes) {\n image.sizes = sizes;\n }\n if (srcset) {\n image.srcset = srcset;\n }\n if (src) {\n image.src = src;\n }\n } else {\n onReady();\n }\n } else {\n // image already loaded...\n onReady();\n }\n}\n\nfunction preloadImages () {\n const swiper = this;\n swiper.imagesToLoad = swiper.$el.find('img');\n function onReady() {\n if (typeof swiper === 'undefined' || swiper === null || !swiper || swiper.destroyed) return;\n if (swiper.imagesLoaded !== undefined) swiper.imagesLoaded += 1;\n if (swiper.imagesLoaded === swiper.imagesToLoad.length) {\n if (swiper.params.updateOnImagesReady) swiper.update();\n swiper.emit('imagesReady');\n }\n }\n for (let i = 0; i < swiper.imagesToLoad.length; i += 1) {\n const imageEl = swiper.imagesToLoad[i];\n swiper.loadImage(\n imageEl,\n imageEl.currentSrc || imageEl.getAttribute('src'),\n imageEl.srcset || imageEl.getAttribute('srcset'),\n imageEl.sizes || imageEl.getAttribute('sizes'),\n true,\n onReady\n );\n }\n}\n\nvar images = {\n loadImage,\n preloadImages,\n};\n\nfunction checkOverflow() {\n const swiper = this;\n const wasLocked = swiper.isLocked;\n\n swiper.isLocked = swiper.snapGrid.length === 1;\n swiper.allowSlideNext = !swiper.isLocked;\n swiper.allowSlidePrev = !swiper.isLocked;\n\n // events\n if (wasLocked !== swiper.isLocked) swiper.emit(swiper.isLocked ? 'lock' : 'unlock');\n\n if (wasLocked && wasLocked !== swiper.isLocked) {\n swiper.isEnd = false;\n swiper.navigation.update();\n }\n}\n\nvar checkOverflow$1 = { checkOverflow };\n\nvar defaults = {\n init: true,\n direction: 'horizontal',\n touchEventsTarget: 'container',\n initialSlide: 0,\n speed: 300,\n //\n preventInteractionOnTransition: false,\n\n // To support iOS's swipe-to-go-back gesture (when being used in-app, with UIWebView).\n edgeSwipeDetection: false,\n edgeSwipeThreshold: 20,\n\n // Free mode\n freeMode: false,\n freeModeMomentum: true,\n freeModeMomentumRatio: 1,\n freeModeMomentumBounce: true,\n freeModeMomentumBounceRatio: 1,\n freeModeMomentumVelocityRatio: 1,\n freeModeSticky: false,\n freeModeMinimumVelocity: 0.02,\n\n // Autoheight\n autoHeight: false,\n\n // Set wrapper width\n setWrapperSize: false,\n\n // Virtual Translate\n virtualTranslate: false,\n\n // Effects\n effect: 'slide', // 'slide' or 'fade' or 'cube' or 'coverflow' or 'flip'\n\n // Breakpoints\n breakpoints: undefined,\n breakpointsInverse: false,\n\n // Slides grid\n spaceBetween: 0,\n slidesPerView: 1,\n slidesPerColumn: 1,\n slidesPerColumnFill: 'column',\n slidesPerGroup: 1,\n centeredSlides: false,\n slidesOffsetBefore: 0, // in px\n slidesOffsetAfter: 0, // in px\n normalizeSlideIndex: true,\n centerInsufficientSlides: false,\n\n // Disable swiper and hide navigation when container not overflow\n watchOverflow: false,\n\n // Round length\n roundLengths: false,\n\n // Touches\n touchRatio: 1,\n touchAngle: 45,\n simulateTouch: true,\n shortSwipes: true,\n longSwipes: true,\n longSwipesRatio: 0.5,\n longSwipesMs: 300,\n followFinger: true,\n allowTouchMove: true,\n threshold: 0,\n touchMoveStopPropagation: true,\n touchStartPreventDefault: true,\n touchStartForcePreventDefault: false,\n touchReleaseOnEdges: false,\n\n // Unique Navigation Elements\n uniqueNavElements: true,\n\n // Resistance\n resistance: true,\n resistanceRatio: 0.85,\n\n // Progress\n watchSlidesProgress: false,\n watchSlidesVisibility: false,\n\n // Cursor\n grabCursor: false,\n\n // Clicks\n preventClicks: true,\n preventClicksPropagation: true,\n slideToClickedSlide: false,\n\n // Images\n preloadImages: true,\n updateOnImagesReady: true,\n\n // loop\n loop: false,\n loopAdditionalSlides: 0,\n loopedSlides: null,\n loopFillGroupWithBlank: false,\n\n // Swiping/no swiping\n allowSlidePrev: true,\n allowSlideNext: true,\n swipeHandler: null, // '.swipe-handler',\n noSwiping: true,\n noSwipingClass: 'swiper-no-swiping',\n noSwipingSelector: null,\n\n // Passive Listeners\n passiveListeners: true,\n\n // NS\n containerModifierClass: 'swiper-container-', // NEW\n slideClass: 'swiper-slide',\n slideBlankClass: 'swiper-slide-invisible-blank',\n slideActiveClass: 'swiper-slide-active',\n slideDuplicateActiveClass: 'swiper-slide-duplicate-active',\n slideVisibleClass: 'swiper-slide-visible',\n slideDuplicateClass: 'swiper-slide-duplicate',\n slideNextClass: 'swiper-slide-next',\n slideDuplicateNextClass: 'swiper-slide-duplicate-next',\n slidePrevClass: 'swiper-slide-prev',\n slideDuplicatePrevClass: 'swiper-slide-duplicate-prev',\n wrapperClass: 'swiper-wrapper',\n\n // Callbacks\n runCallbacksOnInit: true,\n};\n\n/* eslint no-param-reassign: \"off\" */\n\nconst prototypes = {\n update,\n translate,\n transition,\n slide,\n loop,\n grabCursor,\n manipulation,\n events,\n breakpoints,\n checkOverflow: checkOverflow$1,\n classes,\n images,\n};\n\nconst extendedDefaults = {};\n\nclass Swiper extends SwiperClass {\n constructor(...args) {\n let el;\n let params;\n if (args.length === 1 && args[0].constructor && args[0].constructor === Object) {\n params = args[0];\n } else {\n [el, params] = args;\n }\n if (!params) params = {};\n\n params = Utils.extend({}, params);\n if (el && !params.el) params.el = el;\n\n super(params);\n\n Object.keys(prototypes).forEach((prototypeGroup) => {\n Object.keys(prototypes[prototypeGroup]).forEach((protoMethod) => {\n if (!Swiper.prototype[protoMethod]) {\n Swiper.prototype[protoMethod] = prototypes[prototypeGroup][protoMethod];\n }\n });\n });\n\n // Swiper Instance\n const swiper = this;\n if (typeof swiper.modules === 'undefined') {\n swiper.modules = {};\n }\n Object.keys(swiper.modules).forEach((moduleName) => {\n const module = swiper.modules[moduleName];\n if (module.params) {\n const moduleParamName = Object.keys(module.params)[0];\n const moduleParams = module.params[moduleParamName];\n if (typeof moduleParams !== 'object' || moduleParams === null) return;\n if (!(moduleParamName in params && 'enabled' in moduleParams)) return;\n if (params[moduleParamName] === true) {\n params[moduleParamName] = { enabled: true };\n }\n if (\n typeof params[moduleParamName] === 'object'\n && !('enabled' in params[moduleParamName])\n ) {\n params[moduleParamName].enabled = true;\n }\n if (!params[moduleParamName]) params[moduleParamName] = { enabled: false };\n }\n });\n\n // Extend defaults with modules params\n const swiperParams = Utils.extend({}, defaults);\n swiper.useModulesParams(swiperParams);\n\n // Extend defaults with passed params\n swiper.params = Utils.extend({}, swiperParams, extendedDefaults, params);\n swiper.originalParams = Utils.extend({}, swiper.params);\n swiper.passedParams = Utils.extend({}, params);\n\n // Save Dom lib\n swiper.$ = $;\n\n // Find el\n const $el = $(swiper.params.el);\n el = $el[0];\n\n if (!el) {\n return undefined;\n }\n\n if ($el.length > 1) {\n const swipers = [];\n $el.each((index, containerEl) => {\n const newParams = Utils.extend({}, params, { el: containerEl });\n swipers.push(new Swiper(newParams));\n });\n return swipers;\n }\n\n el.swiper = swiper;\n $el.data('swiper', swiper);\n\n // Find Wrapper\n const $wrapperEl = $el.children(`.${swiper.params.wrapperClass}`);\n\n // Extend Swiper\n Utils.extend(swiper, {\n $el,\n el,\n $wrapperEl,\n wrapperEl: $wrapperEl[0],\n\n // Classes\n classNames: [],\n\n // Slides\n slides: $(),\n slidesGrid: [],\n snapGrid: [],\n slidesSizesGrid: [],\n\n // isDirection\n isHorizontal() {\n return swiper.params.direction === 'horizontal';\n },\n isVertical() {\n return swiper.params.direction === 'vertical';\n },\n // RTL\n rtl: (el.dir.toLowerCase() === 'rtl' || $el.css('direction') === 'rtl'),\n rtlTranslate: swiper.params.direction === 'horizontal' && (el.dir.toLowerCase() === 'rtl' || $el.css('direction') === 'rtl'),\n wrongRTL: $wrapperEl.css('display') === '-webkit-box',\n\n // Indexes\n activeIndex: 0,\n realIndex: 0,\n\n //\n isBeginning: true,\n isEnd: false,\n\n // Props\n translate: 0,\n previousTranslate: 0,\n progress: 0,\n velocity: 0,\n animating: false,\n\n // Locks\n allowSlideNext: swiper.params.allowSlideNext,\n allowSlidePrev: swiper.params.allowSlidePrev,\n\n // Touch Events\n touchEvents: (function touchEvents() {\n const touch = ['touchstart', 'touchmove', 'touchend'];\n let desktop = ['mousedown', 'mousemove', 'mouseup'];\n if (Support.pointerEvents) {\n desktop = ['pointerdown', 'pointermove', 'pointerup'];\n } else if (Support.prefixedPointerEvents) {\n desktop = ['MSPointerDown', 'MSPointerMove', 'MSPointerUp'];\n }\n swiper.touchEventsTouch = {\n start: touch[0],\n move: touch[1],\n end: touch[2],\n };\n swiper.touchEventsDesktop = {\n start: desktop[0],\n move: desktop[1],\n end: desktop[2],\n };\n return Support.touch || !swiper.params.simulateTouch ? swiper.touchEventsTouch : swiper.touchEventsDesktop;\n }()),\n touchEventsData: {\n isTouched: undefined,\n isMoved: undefined,\n allowTouchCallbacks: undefined,\n touchStartTime: undefined,\n isScrolling: undefined,\n currentTranslate: undefined,\n startTranslate: undefined,\n allowThresholdMove: undefined,\n // Form elements to match\n formElements: 'input, select, option, textarea, button, video',\n // Last click time\n lastClickTime: Utils.now(),\n clickTimeout: undefined,\n // Velocities\n velocities: [],\n allowMomentumBounce: undefined,\n isTouchEvent: undefined,\n startMoving: undefined,\n },\n\n // Clicks\n allowClick: true,\n\n // Touches\n allowTouchMove: swiper.params.allowTouchMove,\n\n touches: {\n startX: 0,\n startY: 0,\n currentX: 0,\n currentY: 0,\n diff: 0,\n },\n\n // Images\n imagesToLoad: [],\n imagesLoaded: 0,\n\n });\n\n // Install Modules\n swiper.useModules();\n\n // Init\n if (swiper.params.init) {\n swiper.init();\n }\n\n // Return app instance\n return swiper;\n }\n\n slidesPerViewDynamic() {\n const swiper = this;\n const {\n params, slides, slidesGrid, size: swiperSize, activeIndex,\n } = swiper;\n let spv = 1;\n if (params.centeredSlides) {\n let slideSize = slides[activeIndex].swiperSlideSize;\n let breakLoop;\n for (let i = activeIndex + 1; i < slides.length; i += 1) {\n if (slides[i] && !breakLoop) {\n slideSize += slides[i].swiperSlideSize;\n spv += 1;\n if (slideSize > swiperSize) breakLoop = true;\n }\n }\n for (let i = activeIndex - 1; i >= 0; i -= 1) {\n if (slides[i] && !breakLoop) {\n slideSize += slides[i].swiperSlideSize;\n spv += 1;\n if (slideSize > swiperSize) breakLoop = true;\n }\n }\n } else {\n for (let i = activeIndex + 1; i < slides.length; i += 1) {\n if (slidesGrid[i] - slidesGrid[activeIndex] < swiperSize) {\n spv += 1;\n }\n }\n }\n return spv;\n }\n\n update() {\n const swiper = this;\n if (!swiper || swiper.destroyed) return;\n const { snapGrid, params } = swiper;\n // Breakpoints\n if (params.breakpoints) {\n swiper.setBreakpoint();\n }\n swiper.updateSize();\n swiper.updateSlides();\n swiper.updateProgress();\n swiper.updateSlidesClasses();\n\n function setTranslate() {\n const translateValue = swiper.rtlTranslate ? swiper.translate * -1 : swiper.translate;\n const newTranslate = Math.min(Math.max(translateValue, swiper.maxTranslate()), swiper.minTranslate());\n swiper.setTranslate(newTranslate);\n swiper.updateActiveIndex();\n swiper.updateSlidesClasses();\n }\n let translated;\n if (swiper.params.freeMode) {\n setTranslate();\n if (swiper.params.autoHeight) {\n swiper.updateAutoHeight();\n }\n } else {\n if ((swiper.params.slidesPerView === 'auto' || swiper.params.slidesPerView > 1) && swiper.isEnd && !swiper.params.centeredSlides) {\n translated = swiper.slideTo(swiper.slides.length - 1, 0, false, true);\n } else {\n translated = swiper.slideTo(swiper.activeIndex, 0, false, true);\n }\n if (!translated) {\n setTranslate();\n }\n }\n if (params.watchOverflow && snapGrid !== swiper.snapGrid) {\n swiper.checkOverflow();\n }\n swiper.emit('update');\n }\n\n changeDirection(newDirection, needUpdate = true) {\n const swiper = this;\n const currentDirection = swiper.params.direction;\n if (!newDirection) {\n // eslint-disable-next-line\n newDirection = currentDirection === 'horizontal' ? 'vertical' : 'horizontal';\n }\n if ((newDirection === currentDirection) || (newDirection !== 'horizontal' && newDirection !== 'vertical')) {\n return swiper;\n }\n\n swiper.$el\n .removeClass(`${swiper.params.containerModifierClass}${currentDirection} wp8-${currentDirection}`)\n .addClass(`${swiper.params.containerModifierClass}${newDirection}`);\n\n if ((Browser.isIE || Browser.isEdge) && (Support.pointerEvents || Support.prefixedPointerEvents)) {\n swiper.$el.addClass(`${swiper.params.containerModifierClass}wp8-${newDirection}`);\n }\n\n swiper.params.direction = newDirection;\n\n swiper.slides.each((slideIndex, slideEl) => {\n if (newDirection === 'vertical') {\n slideEl.style.width = '';\n } else {\n slideEl.style.height = '';\n }\n });\n\n swiper.emit('changeDirection');\n if (needUpdate) swiper.update();\n\n return swiper;\n }\n\n init() {\n const swiper = this;\n if (swiper.initialized) return;\n\n swiper.emit('beforeInit');\n\n // Set breakpoint\n if (swiper.params.breakpoints) {\n swiper.setBreakpoint();\n }\n\n // Add Classes\n swiper.addClasses();\n\n // Create loop\n if (swiper.params.loop) {\n swiper.loopCreate();\n }\n\n // Update size\n swiper.updateSize();\n\n // Update slides\n swiper.updateSlides();\n\n if (swiper.params.watchOverflow) {\n swiper.checkOverflow();\n }\n\n // Set Grab Cursor\n if (swiper.params.grabCursor) {\n swiper.setGrabCursor();\n }\n\n if (swiper.params.preloadImages) {\n swiper.preloadImages();\n }\n\n // Slide To Initial Slide\n if (swiper.params.loop) {\n swiper.slideTo(swiper.params.initialSlide + swiper.loopedSlides, 0, swiper.params.runCallbacksOnInit);\n } else {\n swiper.slideTo(swiper.params.initialSlide, 0, swiper.params.runCallbacksOnInit);\n }\n\n // Attach events\n swiper.attachEvents();\n\n // Init Flag\n swiper.initialized = true;\n\n // Emit\n swiper.emit('init');\n }\n\n destroy(deleteInstance = true, cleanStyles = true) {\n const swiper = this;\n const {\n params, $el, $wrapperEl, slides,\n } = swiper;\n\n if (typeof swiper.params === 'undefined' || swiper.destroyed) {\n return null;\n }\n\n swiper.emit('beforeDestroy');\n\n // Init Flag\n swiper.initialized = false;\n\n // Detach events\n swiper.detachEvents();\n\n // Destroy loop\n if (params.loop) {\n swiper.loopDestroy();\n }\n\n // Cleanup styles\n if (cleanStyles) {\n swiper.removeClasses();\n $el.removeAttr('style');\n $wrapperEl.removeAttr('style');\n if (slides && slides.length) {\n slides\n .removeClass([\n params.slideVisibleClass,\n params.slideActiveClass,\n params.slideNextClass,\n params.slidePrevClass,\n ].join(' '))\n .removeAttr('style')\n .removeAttr('data-swiper-slide-index')\n .removeAttr('data-swiper-column')\n .removeAttr('data-swiper-row');\n }\n }\n\n swiper.emit('destroy');\n\n // Detach emitter events\n Object.keys(swiper.eventsListeners).forEach((eventName) => {\n swiper.off(eventName);\n });\n\n if (deleteInstance !== false) {\n swiper.$el[0].swiper = null;\n swiper.$el.data('swiper', null);\n Utils.deleteProps(swiper);\n }\n swiper.destroyed = true;\n\n return null;\n }\n\n static extendDefaults(newDefaults) {\n Utils.extend(extendedDefaults, newDefaults);\n }\n\n static get extendedDefaults() {\n return extendedDefaults;\n }\n\n static get defaults() {\n return defaults;\n }\n\n static get Class() {\n return SwiperClass;\n }\n\n static get $() {\n return $;\n }\n}\n\nvar Device$1 = {\n name: 'device',\n proto: {\n device: Device,\n },\n static: {\n device: Device,\n },\n};\n\nvar Support$1 = {\n name: 'support',\n proto: {\n support: Support,\n },\n static: {\n support: Support,\n },\n};\n\nvar Browser$1 = {\n name: 'browser',\n proto: {\n browser: Browser,\n },\n static: {\n browser: Browser,\n },\n};\n\nvar Resize = {\n name: 'resize',\n create() {\n const swiper = this;\n Utils.extend(swiper, {\n resize: {\n resizeHandler() {\n if (!swiper || swiper.destroyed || !swiper.initialized) return;\n swiper.emit('beforeResize');\n swiper.emit('resize');\n },\n orientationChangeHandler() {\n if (!swiper || swiper.destroyed || !swiper.initialized) return;\n swiper.emit('orientationchange');\n },\n },\n });\n },\n on: {\n init() {\n const swiper = this;\n // Emit resize\n window.addEventListener('resize', swiper.resize.resizeHandler);\n\n // Emit orientationchange\n window.addEventListener('orientationchange', swiper.resize.orientationChangeHandler);\n },\n destroy() {\n const swiper = this;\n window.removeEventListener('resize', swiper.resize.resizeHandler);\n window.removeEventListener('orientationchange', swiper.resize.orientationChangeHandler);\n },\n },\n};\n\nconst Observer = {\n func: window.MutationObserver || window.WebkitMutationObserver,\n attach(target, options = {}) {\n const swiper = this;\n\n const ObserverFunc = Observer.func;\n const observer = new ObserverFunc((mutations) => {\n // The observerUpdate event should only be triggered\n // once despite the number of mutations. Additional\n // triggers are redundant and are very costly\n if (mutations.length === 1) {\n swiper.emit('observerUpdate', mutations[0]);\n return;\n }\n const observerUpdate = function observerUpdate() {\n swiper.emit('observerUpdate', mutations[0]);\n };\n\n if (window.requestAnimationFrame) {\n window.requestAnimationFrame(observerUpdate);\n } else {\n window.setTimeout(observerUpdate, 0);\n }\n });\n\n observer.observe(target, {\n attributes: typeof options.attributes === 'undefined' ? true : options.attributes,\n childList: typeof options.childList === 'undefined' ? true : options.childList,\n characterData: typeof options.characterData === 'undefined' ? true : options.characterData,\n });\n\n swiper.observer.observers.push(observer);\n },\n init() {\n const swiper = this;\n if (!Support.observer || !swiper.params.observer) return;\n if (swiper.params.observeParents) {\n const containerParents = swiper.$el.parents();\n for (let i = 0; i < containerParents.length; i += 1) {\n swiper.observer.attach(containerParents[i]);\n }\n }\n // Observe container\n swiper.observer.attach(swiper.$el[0], { childList: swiper.params.observeSlideChildren });\n\n // Observe wrapper\n swiper.observer.attach(swiper.$wrapperEl[0], { attributes: false });\n },\n destroy() {\n const swiper = this;\n swiper.observer.observers.forEach((observer) => {\n observer.disconnect();\n });\n swiper.observer.observers = [];\n },\n};\n\nvar Observer$1 = {\n name: 'observer',\n params: {\n observer: false,\n observeParents: false,\n observeSlideChildren: false,\n },\n create() {\n const swiper = this;\n Utils.extend(swiper, {\n observer: {\n init: Observer.init.bind(swiper),\n attach: Observer.attach.bind(swiper),\n destroy: Observer.destroy.bind(swiper),\n observers: [],\n },\n });\n },\n on: {\n init() {\n const swiper = this;\n swiper.observer.init();\n },\n destroy() {\n const swiper = this;\n swiper.observer.destroy();\n },\n },\n};\n\nconst Virtual = {\n update(force) {\n const swiper = this;\n const { slidesPerView, slidesPerGroup, centeredSlides } = swiper.params;\n const { addSlidesBefore, addSlidesAfter } = swiper.params.virtual;\n const {\n from: previousFrom,\n to: previousTo,\n slides,\n slidesGrid: previousSlidesGrid,\n renderSlide,\n offset: previousOffset,\n } = swiper.virtual;\n swiper.updateActiveIndex();\n const activeIndex = swiper.activeIndex || 0;\n\n let offsetProp;\n if (swiper.rtlTranslate) offsetProp = 'right';\n else offsetProp = swiper.isHorizontal() ? 'left' : 'top';\n\n let slidesAfter;\n let slidesBefore;\n if (centeredSlides) {\n slidesAfter = Math.floor(slidesPerView / 2) + slidesPerGroup + addSlidesBefore;\n slidesBefore = Math.floor(slidesPerView / 2) + slidesPerGroup + addSlidesAfter;\n } else {\n slidesAfter = slidesPerView + (slidesPerGroup - 1) + addSlidesBefore;\n slidesBefore = slidesPerGroup + addSlidesAfter;\n }\n const from = Math.max((activeIndex || 0) - slidesBefore, 0);\n const to = Math.min((activeIndex || 0) + slidesAfter, slides.length - 1);\n const offset = (swiper.slidesGrid[from] || 0) - (swiper.slidesGrid[0] || 0);\n\n Utils.extend(swiper.virtual, {\n from,\n to,\n offset,\n slidesGrid: swiper.slidesGrid,\n });\n\n function onRendered() {\n swiper.updateSlides();\n swiper.updateProgress();\n swiper.updateSlidesClasses();\n if (swiper.lazy && swiper.params.lazy.enabled) {\n swiper.lazy.load();\n }\n }\n\n if (previousFrom === from && previousTo === to && !force) {\n if (swiper.slidesGrid !== previousSlidesGrid && offset !== previousOffset) {\n swiper.slides.css(offsetProp, `${offset}px`);\n }\n swiper.updateProgress();\n return;\n }\n if (swiper.params.virtual.renderExternal) {\n swiper.params.virtual.renderExternal.call(swiper, {\n offset,\n from,\n to,\n slides: (function getSlides() {\n const slidesToRender = [];\n for (let i = from; i <= to; i += 1) {\n slidesToRender.push(slides[i]);\n }\n return slidesToRender;\n }()),\n });\n onRendered();\n return;\n }\n const prependIndexes = [];\n const appendIndexes = [];\n if (force) {\n swiper.$wrapperEl.find(`.${swiper.params.slideClass}`).remove();\n } else {\n for (let i = previousFrom; i <= previousTo; i += 1) {\n if (i < from || i > to) {\n swiper.$wrapperEl.find(`.${swiper.params.slideClass}[data-swiper-slide-index=\"${i}\"]`).remove();\n }\n }\n }\n for (let i = 0; i < slides.length; i += 1) {\n if (i >= from && i <= to) {\n if (typeof previousTo === 'undefined' || force) {\n appendIndexes.push(i);\n } else {\n if (i > previousTo) appendIndexes.push(i);\n if (i < previousFrom) prependIndexes.push(i);\n }\n }\n }\n appendIndexes.forEach((index) => {\n swiper.$wrapperEl.append(renderSlide(slides[index], index));\n });\n prependIndexes.sort((a, b) => b - a).forEach((index) => {\n swiper.$wrapperEl.prepend(renderSlide(slides[index], index));\n });\n swiper.$wrapperEl.children('.swiper-slide').css(offsetProp, `${offset}px`);\n onRendered();\n },\n renderSlide(slide, index) {\n const swiper = this;\n const params = swiper.params.virtual;\n if (params.cache && swiper.virtual.cache[index]) {\n return swiper.virtual.cache[index];\n }\n const $slideEl = params.renderSlide\n ? $(params.renderSlide.call(swiper, slide, index))\n : $(`
${slide}
`);\n if (!$slideEl.attr('data-swiper-slide-index')) $slideEl.attr('data-swiper-slide-index', index);\n if (params.cache) swiper.virtual.cache[index] = $slideEl;\n return $slideEl;\n },\n appendSlide(slides) {\n const swiper = this;\n if (typeof slides === 'object' && 'length' in slides) {\n for (let i = 0; i < slides.length; i += 1) {\n if (slides[i]) swiper.virtual.slides.push(slides[i]);\n }\n } else {\n swiper.virtual.slides.push(slides);\n }\n swiper.virtual.update(true);\n },\n prependSlide(slides) {\n const swiper = this;\n const activeIndex = swiper.activeIndex;\n let newActiveIndex = activeIndex + 1;\n let numberOfNewSlides = 1;\n\n if (Array.isArray(slides)) {\n for (let i = 0; i < slides.length; i += 1) {\n if (slides[i]) swiper.virtual.slides.unshift(slides[i]);\n }\n newActiveIndex = activeIndex + slides.length;\n numberOfNewSlides = slides.length;\n } else {\n swiper.virtual.slides.unshift(slides);\n }\n if (swiper.params.virtual.cache) {\n const cache = swiper.virtual.cache;\n const newCache = {};\n Object.keys(cache).forEach((cachedIndex) => {\n newCache[parseInt(cachedIndex, 10) + numberOfNewSlides] = cache[cachedIndex];\n });\n swiper.virtual.cache = newCache;\n }\n swiper.virtual.update(true);\n swiper.slideTo(newActiveIndex, 0);\n },\n removeSlide(slidesIndexes) {\n const swiper = this;\n if (typeof slidesIndexes === 'undefined' || slidesIndexes === null) return;\n let activeIndex = swiper.activeIndex;\n if (Array.isArray(slidesIndexes)) {\n for (let i = slidesIndexes.length - 1; i >= 0; i -= 1) {\n swiper.virtual.slides.splice(slidesIndexes[i], 1);\n if (swiper.params.virtual.cache) {\n delete swiper.virtual.cache[slidesIndexes[i]];\n }\n if (slidesIndexes[i] < activeIndex) activeIndex -= 1;\n activeIndex = Math.max(activeIndex, 0);\n }\n } else {\n swiper.virtual.slides.splice(slidesIndexes, 1);\n if (swiper.params.virtual.cache) {\n delete swiper.virtual.cache[slidesIndexes];\n }\n if (slidesIndexes < activeIndex) activeIndex -= 1;\n activeIndex = Math.max(activeIndex, 0);\n }\n swiper.virtual.update(true);\n swiper.slideTo(activeIndex, 0);\n },\n removeAllSlides() {\n const swiper = this;\n swiper.virtual.slides = [];\n if (swiper.params.virtual.cache) {\n swiper.virtual.cache = {};\n }\n swiper.virtual.update(true);\n swiper.slideTo(0, 0);\n },\n};\n\nvar Virtual$1 = {\n name: 'virtual',\n params: {\n virtual: {\n enabled: false,\n slides: [],\n cache: true,\n renderSlide: null,\n renderExternal: null,\n addSlidesBefore: 0,\n addSlidesAfter: 0,\n },\n },\n create() {\n const swiper = this;\n Utils.extend(swiper, {\n virtual: {\n update: Virtual.update.bind(swiper),\n appendSlide: Virtual.appendSlide.bind(swiper),\n prependSlide: Virtual.prependSlide.bind(swiper),\n removeSlide: Virtual.removeSlide.bind(swiper),\n removeAllSlides: Virtual.removeAllSlides.bind(swiper),\n renderSlide: Virtual.renderSlide.bind(swiper),\n slides: swiper.params.virtual.slides,\n cache: {},\n },\n });\n },\n on: {\n beforeInit() {\n const swiper = this;\n if (!swiper.params.virtual.enabled) return;\n swiper.classNames.push(`${swiper.params.containerModifierClass}virtual`);\n const overwriteParams = {\n watchSlidesProgress: true,\n };\n Utils.extend(swiper.params, overwriteParams);\n Utils.extend(swiper.originalParams, overwriteParams);\n\n if (!swiper.params.initialSlide) {\n swiper.virtual.update();\n }\n },\n setTranslate() {\n const swiper = this;\n if (!swiper.params.virtual.enabled) return;\n swiper.virtual.update();\n },\n },\n};\n\nconst Keyboard = {\n handle(event) {\n const swiper = this;\n const { rtlTranslate: rtl } = swiper;\n let e = event;\n if (e.originalEvent) e = e.originalEvent; // jquery fix\n const kc = e.keyCode || e.charCode;\n // Directions locks\n if (!swiper.allowSlideNext && ((swiper.isHorizontal() && kc === 39) || (swiper.isVertical() && kc === 40) || kc === 34)) {\n return false;\n }\n if (!swiper.allowSlidePrev && ((swiper.isHorizontal() && kc === 37) || (swiper.isVertical() && kc === 38) || kc === 33)) {\n return false;\n }\n if (e.shiftKey || e.altKey || e.ctrlKey || e.metaKey) {\n return undefined;\n }\n if (document.activeElement && document.activeElement.nodeName && (document.activeElement.nodeName.toLowerCase() === 'input' || document.activeElement.nodeName.toLowerCase() === 'textarea')) {\n return undefined;\n }\n if (swiper.params.keyboard.onlyInViewport && (kc === 33 || kc === 34 || kc === 37 || kc === 39 || kc === 38 || kc === 40)) {\n let inView = false;\n // Check that swiper should be inside of visible area of window\n if (swiper.$el.parents(`.${swiper.params.slideClass}`).length > 0 && swiper.$el.parents(`.${swiper.params.slideActiveClass}`).length === 0) {\n return undefined;\n }\n const windowWidth = window.innerWidth;\n const windowHeight = window.innerHeight;\n const swiperOffset = swiper.$el.offset();\n if (rtl) swiperOffset.left -= swiper.$el[0].scrollLeft;\n const swiperCoord = [\n [swiperOffset.left, swiperOffset.top],\n [swiperOffset.left + swiper.width, swiperOffset.top],\n [swiperOffset.left, swiperOffset.top + swiper.height],\n [swiperOffset.left + swiper.width, swiperOffset.top + swiper.height],\n ];\n for (let i = 0; i < swiperCoord.length; i += 1) {\n const point = swiperCoord[i];\n if (\n point[0] >= 0 && point[0] <= windowWidth\n && point[1] >= 0 && point[1] <= windowHeight\n ) {\n inView = true;\n }\n }\n if (!inView) return undefined;\n }\n if (swiper.isHorizontal()) {\n if (kc === 33 || kc === 34 || kc === 37 || kc === 39) {\n if (e.preventDefault) e.preventDefault();\n else e.returnValue = false;\n }\n if (((kc === 34 || kc === 39) && !rtl) || ((kc === 33 || kc === 37) && rtl)) swiper.slideNext();\n if (((kc === 33 || kc === 37) && !rtl) || ((kc === 34 || kc === 39) && rtl)) swiper.slidePrev();\n } else {\n if (kc === 33 || kc === 34 || kc === 38 || kc === 40) {\n if (e.preventDefault) e.preventDefault();\n else e.returnValue = false;\n }\n if (kc === 34 || kc === 40) swiper.slideNext();\n if (kc === 33 || kc === 38) swiper.slidePrev();\n }\n swiper.emit('keyPress', kc);\n return undefined;\n },\n enable() {\n const swiper = this;\n if (swiper.keyboard.enabled) return;\n $(document).on('keydown', swiper.keyboard.handle);\n swiper.keyboard.enabled = true;\n },\n disable() {\n const swiper = this;\n if (!swiper.keyboard.enabled) return;\n $(document).off('keydown', swiper.keyboard.handle);\n swiper.keyboard.enabled = false;\n },\n};\n\nvar Keyboard$1 = {\n name: 'keyboard',\n params: {\n keyboard: {\n enabled: false,\n onlyInViewport: true,\n },\n },\n create() {\n const swiper = this;\n Utils.extend(swiper, {\n keyboard: {\n enabled: false,\n enable: Keyboard.enable.bind(swiper),\n disable: Keyboard.disable.bind(swiper),\n handle: Keyboard.handle.bind(swiper),\n },\n });\n },\n on: {\n init() {\n const swiper = this;\n if (swiper.params.keyboard.enabled) {\n swiper.keyboard.enable();\n }\n },\n destroy() {\n const swiper = this;\n if (swiper.keyboard.enabled) {\n swiper.keyboard.disable();\n }\n },\n },\n};\n\nfunction isEventSupported() {\n const eventName = 'onwheel';\n let isSupported = eventName in document;\n\n if (!isSupported) {\n const element = document.createElement('div');\n element.setAttribute(eventName, 'return;');\n isSupported = typeof element[eventName] === 'function';\n }\n\n if (!isSupported\n && document.implementation\n && document.implementation.hasFeature\n // always returns true in newer browsers as per the standard.\n // @see http://dom.spec.whatwg.org/#dom-domimplementation-hasfeature\n && document.implementation.hasFeature('', '') !== true\n ) {\n // This is the only way to test support for the `wheel` event in IE9+.\n isSupported = document.implementation.hasFeature('Events.wheel', '3.0');\n }\n\n return isSupported;\n}\nconst Mousewheel = {\n lastScrollTime: Utils.now(),\n event: (function getEvent() {\n if (window.navigator.userAgent.indexOf('firefox') > -1) return 'DOMMouseScroll';\n return isEventSupported() ? 'wheel' : 'mousewheel';\n }()),\n normalize(e) {\n // Reasonable defaults\n const PIXEL_STEP = 10;\n const LINE_HEIGHT = 40;\n const PAGE_HEIGHT = 800;\n\n let sX = 0;\n let sY = 0; // spinX, spinY\n let pX = 0;\n let pY = 0; // pixelX, pixelY\n\n // Legacy\n if ('detail' in e) {\n sY = e.detail;\n }\n if ('wheelDelta' in e) {\n sY = -e.wheelDelta / 120;\n }\n if ('wheelDeltaY' in e) {\n sY = -e.wheelDeltaY / 120;\n }\n if ('wheelDeltaX' in e) {\n sX = -e.wheelDeltaX / 120;\n }\n\n // side scrolling on FF with DOMMouseScroll\n if ('axis' in e && e.axis === e.HORIZONTAL_AXIS) {\n sX = sY;\n sY = 0;\n }\n\n pX = sX * PIXEL_STEP;\n pY = sY * PIXEL_STEP;\n\n if ('deltaY' in e) {\n pY = e.deltaY;\n }\n if ('deltaX' in e) {\n pX = e.deltaX;\n }\n\n if ((pX || pY) && e.deltaMode) {\n if (e.deltaMode === 1) { // delta in LINE units\n pX *= LINE_HEIGHT;\n pY *= LINE_HEIGHT;\n } else { // delta in PAGE units\n pX *= PAGE_HEIGHT;\n pY *= PAGE_HEIGHT;\n }\n }\n\n // Fall-back if spin cannot be determined\n if (pX && !sX) {\n sX = (pX < 1) ? -1 : 1;\n }\n if (pY && !sY) {\n sY = (pY < 1) ? -1 : 1;\n }\n\n return {\n spinX: sX,\n spinY: sY,\n pixelX: pX,\n pixelY: pY,\n };\n },\n handleMouseEnter() {\n const swiper = this;\n swiper.mouseEntered = true;\n },\n handleMouseLeave() {\n const swiper = this;\n swiper.mouseEntered = false;\n },\n handle(event) {\n let e = event;\n const swiper = this;\n const params = swiper.params.mousewheel;\n\n if (!swiper.mouseEntered && !params.releaseOnEdges) return true;\n\n if (e.originalEvent) e = e.originalEvent; // jquery fix\n let delta = 0;\n const rtlFactor = swiper.rtlTranslate ? -1 : 1;\n\n const data = Mousewheel.normalize(e);\n\n if (params.forceToAxis) {\n if (swiper.isHorizontal()) {\n if (Math.abs(data.pixelX) > Math.abs(data.pixelY)) delta = data.pixelX * rtlFactor;\n else return true;\n } else if (Math.abs(data.pixelY) > Math.abs(data.pixelX)) delta = data.pixelY;\n else return true;\n } else {\n delta = Math.abs(data.pixelX) > Math.abs(data.pixelY) ? -data.pixelX * rtlFactor : -data.pixelY;\n }\n\n if (delta === 0) return true;\n\n if (params.invert) delta = -delta;\n\n if (!swiper.params.freeMode) {\n if (Utils.now() - swiper.mousewheel.lastScrollTime > 60) {\n if (delta < 0) {\n if ((!swiper.isEnd || swiper.params.loop) && !swiper.animating) {\n swiper.slideNext();\n swiper.emit('scroll', e);\n } else if (params.releaseOnEdges) return true;\n } else if ((!swiper.isBeginning || swiper.params.loop) && !swiper.animating) {\n swiper.slidePrev();\n swiper.emit('scroll', e);\n } else if (params.releaseOnEdges) return true;\n }\n swiper.mousewheel.lastScrollTime = (new window.Date()).getTime();\n } else {\n // Freemode or scrollContainer:\n if (swiper.params.loop) {\n swiper.loopFix();\n }\n let position = swiper.getTranslate() + (delta * params.sensitivity);\n const wasBeginning = swiper.isBeginning;\n const wasEnd = swiper.isEnd;\n\n if (position >= swiper.minTranslate()) position = swiper.minTranslate();\n if (position <= swiper.maxTranslate()) position = swiper.maxTranslate();\n\n swiper.setTransition(0);\n swiper.setTranslate(position);\n swiper.updateProgress();\n swiper.updateActiveIndex();\n swiper.updateSlidesClasses();\n\n if ((!wasBeginning && swiper.isBeginning) || (!wasEnd && swiper.isEnd)) {\n swiper.updateSlidesClasses();\n }\n\n if (swiper.params.freeModeSticky) {\n clearTimeout(swiper.mousewheel.timeout);\n swiper.mousewheel.timeout = Utils.nextTick(() => {\n swiper.slideToClosest();\n }, 300);\n }\n // Emit event\n swiper.emit('scroll', e);\n\n // Stop autoplay\n if (swiper.params.autoplay && swiper.params.autoplayDisableOnInteraction) swiper.autoplay.stop();\n // Return page scroll on edge positions\n if (position === swiper.minTranslate() || position === swiper.maxTranslate()) return true;\n }\n\n if (e.preventDefault) e.preventDefault();\n else e.returnValue = false;\n return false;\n },\n enable() {\n const swiper = this;\n if (!Mousewheel.event) return false;\n if (swiper.mousewheel.enabled) return false;\n let target = swiper.$el;\n if (swiper.params.mousewheel.eventsTarged !== 'container') {\n target = $(swiper.params.mousewheel.eventsTarged);\n }\n target.on('mouseenter', swiper.mousewheel.handleMouseEnter);\n target.on('mouseleave', swiper.mousewheel.handleMouseLeave);\n target.on(Mousewheel.event, swiper.mousewheel.handle);\n swiper.mousewheel.enabled = true;\n return true;\n },\n disable() {\n const swiper = this;\n if (!Mousewheel.event) return false;\n if (!swiper.mousewheel.enabled) return false;\n let target = swiper.$el;\n if (swiper.params.mousewheel.eventsTarged !== 'container') {\n target = $(swiper.params.mousewheel.eventsTarged);\n }\n target.off(Mousewheel.event, swiper.mousewheel.handle);\n swiper.mousewheel.enabled = false;\n return true;\n },\n};\n\nvar Mousewheel$1 = {\n name: 'mousewheel',\n params: {\n mousewheel: {\n enabled: false,\n releaseOnEdges: false,\n invert: false,\n forceToAxis: false,\n sensitivity: 1,\n eventsTarged: 'container',\n },\n },\n create() {\n const swiper = this;\n Utils.extend(swiper, {\n mousewheel: {\n enabled: false,\n enable: Mousewheel.enable.bind(swiper),\n disable: Mousewheel.disable.bind(swiper),\n handle: Mousewheel.handle.bind(swiper),\n handleMouseEnter: Mousewheel.handleMouseEnter.bind(swiper),\n handleMouseLeave: Mousewheel.handleMouseLeave.bind(swiper),\n lastScrollTime: Utils.now(),\n },\n });\n },\n on: {\n init() {\n const swiper = this;\n if (swiper.params.mousewheel.enabled) swiper.mousewheel.enable();\n },\n destroy() {\n const swiper = this;\n if (swiper.mousewheel.enabled) swiper.mousewheel.disable();\n },\n },\n};\n\nconst Navigation = {\n update() {\n // Update Navigation Buttons\n const swiper = this;\n const params = swiper.params.navigation;\n\n if (swiper.params.loop) return;\n const { $nextEl, $prevEl } = swiper.navigation;\n\n if ($prevEl && $prevEl.length > 0) {\n if (swiper.isBeginning) {\n $prevEl.addClass(params.disabledClass);\n } else {\n $prevEl.removeClass(params.disabledClass);\n }\n $prevEl[swiper.params.watchOverflow && swiper.isLocked ? 'addClass' : 'removeClass'](params.lockClass);\n }\n if ($nextEl && $nextEl.length > 0) {\n if (swiper.isEnd) {\n $nextEl.addClass(params.disabledClass);\n } else {\n $nextEl.removeClass(params.disabledClass);\n }\n $nextEl[swiper.params.watchOverflow && swiper.isLocked ? 'addClass' : 'removeClass'](params.lockClass);\n }\n },\n onPrevClick(e) {\n const swiper = this;\n e.preventDefault();\n if (swiper.isBeginning && !swiper.params.loop) return;\n swiper.slidePrev();\n },\n onNextClick(e) {\n const swiper = this;\n e.preventDefault();\n if (swiper.isEnd && !swiper.params.loop) return;\n swiper.slideNext();\n },\n init() {\n const swiper = this;\n const params = swiper.params.navigation;\n if (!(params.nextEl || params.prevEl)) return;\n\n let $nextEl;\n let $prevEl;\n if (params.nextEl) {\n $nextEl = $(params.nextEl);\n if (\n swiper.params.uniqueNavElements\n && typeof params.nextEl === 'string'\n && $nextEl.length > 1\n && swiper.$el.find(params.nextEl).length === 1\n ) {\n $nextEl = swiper.$el.find(params.nextEl);\n }\n }\n if (params.prevEl) {\n $prevEl = $(params.prevEl);\n if (\n swiper.params.uniqueNavElements\n && typeof params.prevEl === 'string'\n && $prevEl.length > 1\n && swiper.$el.find(params.prevEl).length === 1\n ) {\n $prevEl = swiper.$el.find(params.prevEl);\n }\n }\n\n if ($nextEl && $nextEl.length > 0) {\n $nextEl.on('click', swiper.navigation.onNextClick);\n }\n if ($prevEl && $prevEl.length > 0) {\n $prevEl.on('click', swiper.navigation.onPrevClick);\n }\n\n Utils.extend(swiper.navigation, {\n $nextEl,\n nextEl: $nextEl && $nextEl[0],\n $prevEl,\n prevEl: $prevEl && $prevEl[0],\n });\n },\n destroy() {\n const swiper = this;\n const { $nextEl, $prevEl } = swiper.navigation;\n if ($nextEl && $nextEl.length) {\n $nextEl.off('click', swiper.navigation.onNextClick);\n $nextEl.removeClass(swiper.params.navigation.disabledClass);\n }\n if ($prevEl && $prevEl.length) {\n $prevEl.off('click', swiper.navigation.onPrevClick);\n $prevEl.removeClass(swiper.params.navigation.disabledClass);\n }\n },\n};\n\nvar Navigation$1 = {\n name: 'navigation',\n params: {\n navigation: {\n nextEl: null,\n prevEl: null,\n\n hideOnClick: false,\n disabledClass: 'swiper-button-disabled',\n hiddenClass: 'swiper-button-hidden',\n lockClass: 'swiper-button-lock',\n },\n },\n create() {\n const swiper = this;\n Utils.extend(swiper, {\n navigation: {\n init: Navigation.init.bind(swiper),\n update: Navigation.update.bind(swiper),\n destroy: Navigation.destroy.bind(swiper),\n onNextClick: Navigation.onNextClick.bind(swiper),\n onPrevClick: Navigation.onPrevClick.bind(swiper),\n },\n });\n },\n on: {\n init() {\n const swiper = this;\n swiper.navigation.init();\n swiper.navigation.update();\n },\n toEdge() {\n const swiper = this;\n swiper.navigation.update();\n },\n fromEdge() {\n const swiper = this;\n swiper.navigation.update();\n },\n destroy() {\n const swiper = this;\n swiper.navigation.destroy();\n },\n click(e) {\n const swiper = this;\n const { $nextEl, $prevEl } = swiper.navigation;\n if (\n swiper.params.navigation.hideOnClick\n && !$(e.target).is($prevEl)\n && !$(e.target).is($nextEl)\n ) {\n let isHidden;\n if ($nextEl) {\n isHidden = $nextEl.hasClass(swiper.params.navigation.hiddenClass);\n } else if ($prevEl) {\n isHidden = $prevEl.hasClass(swiper.params.navigation.hiddenClass);\n }\n if (isHidden === true) {\n swiper.emit('navigationShow', swiper);\n } else {\n swiper.emit('navigationHide', swiper);\n }\n if ($nextEl) {\n $nextEl.toggleClass(swiper.params.navigation.hiddenClass);\n }\n if ($prevEl) {\n $prevEl.toggleClass(swiper.params.navigation.hiddenClass);\n }\n }\n },\n },\n};\n\nconst Pagination = {\n update() {\n // Render || Update Pagination bullets/items\n const swiper = this;\n const rtl = swiper.rtl;\n const params = swiper.params.pagination;\n if (!params.el || !swiper.pagination.el || !swiper.pagination.$el || swiper.pagination.$el.length === 0) return;\n const slidesLength = swiper.virtual && swiper.params.virtual.enabled ? swiper.virtual.slides.length : swiper.slides.length;\n const $el = swiper.pagination.$el;\n // Current/Total\n let current;\n const total = swiper.params.loop ? Math.ceil((slidesLength - (swiper.loopedSlides * 2)) / swiper.params.slidesPerGroup) : swiper.snapGrid.length;\n if (swiper.params.loop) {\n current = Math.ceil((swiper.activeIndex - swiper.loopedSlides) / swiper.params.slidesPerGroup);\n if (current > slidesLength - 1 - (swiper.loopedSlides * 2)) {\n current -= (slidesLength - (swiper.loopedSlides * 2));\n }\n if (current > total - 1) current -= total;\n if (current < 0 && swiper.params.paginationType !== 'bullets') current = total + current;\n } else if (typeof swiper.snapIndex !== 'undefined') {\n current = swiper.snapIndex;\n } else {\n current = swiper.activeIndex || 0;\n }\n // Types\n if (params.type === 'bullets' && swiper.pagination.bullets && swiper.pagination.bullets.length > 0) {\n const bullets = swiper.pagination.bullets;\n let firstIndex;\n let lastIndex;\n let midIndex;\n if (params.dynamicBullets) {\n swiper.pagination.bulletSize = bullets.eq(0)[swiper.isHorizontal() ? 'outerWidth' : 'outerHeight'](true);\n $el.css(swiper.isHorizontal() ? 'width' : 'height', `${swiper.pagination.bulletSize * (params.dynamicMainBullets + 4)}px`);\n if (params.dynamicMainBullets > 1 && swiper.previousIndex !== undefined) {\n swiper.pagination.dynamicBulletIndex += (current - swiper.previousIndex);\n if (swiper.pagination.dynamicBulletIndex > (params.dynamicMainBullets - 1)) {\n swiper.pagination.dynamicBulletIndex = params.dynamicMainBullets - 1;\n } else if (swiper.pagination.dynamicBulletIndex < 0) {\n swiper.pagination.dynamicBulletIndex = 0;\n }\n }\n firstIndex = current - swiper.pagination.dynamicBulletIndex;\n lastIndex = firstIndex + (Math.min(bullets.length, params.dynamicMainBullets) - 1);\n midIndex = (lastIndex + firstIndex) / 2;\n }\n bullets.removeClass(`${params.bulletActiveClass} ${params.bulletActiveClass}-next ${params.bulletActiveClass}-next-next ${params.bulletActiveClass}-prev ${params.bulletActiveClass}-prev-prev ${params.bulletActiveClass}-main`);\n if ($el.length > 1) {\n bullets.each((index, bullet) => {\n const $bullet = $(bullet);\n const bulletIndex = $bullet.index();\n if (bulletIndex === current) {\n $bullet.addClass(params.bulletActiveClass);\n }\n if (params.dynamicBullets) {\n if (bulletIndex >= firstIndex && bulletIndex <= lastIndex) {\n $bullet.addClass(`${params.bulletActiveClass}-main`);\n }\n if (bulletIndex === firstIndex) {\n $bullet\n .prev()\n .addClass(`${params.bulletActiveClass}-prev`)\n .prev()\n .addClass(`${params.bulletActiveClass}-prev-prev`);\n }\n if (bulletIndex === lastIndex) {\n $bullet\n .next()\n .addClass(`${params.bulletActiveClass}-next`)\n .next()\n .addClass(`${params.bulletActiveClass}-next-next`);\n }\n }\n });\n } else {\n const $bullet = bullets.eq(current);\n $bullet.addClass(params.bulletActiveClass);\n if (params.dynamicBullets) {\n const $firstDisplayedBullet = bullets.eq(firstIndex);\n const $lastDisplayedBullet = bullets.eq(lastIndex);\n for (let i = firstIndex; i <= lastIndex; i += 1) {\n bullets.eq(i).addClass(`${params.bulletActiveClass}-main`);\n }\n $firstDisplayedBullet\n .prev()\n .addClass(`${params.bulletActiveClass}-prev`)\n .prev()\n .addClass(`${params.bulletActiveClass}-prev-prev`);\n $lastDisplayedBullet\n .next()\n .addClass(`${params.bulletActiveClass}-next`)\n .next()\n .addClass(`${params.bulletActiveClass}-next-next`);\n }\n }\n if (params.dynamicBullets) {\n const dynamicBulletsLength = Math.min(bullets.length, params.dynamicMainBullets + 4);\n const bulletsOffset = (((swiper.pagination.bulletSize * dynamicBulletsLength) - (swiper.pagination.bulletSize)) / 2) - (midIndex * swiper.pagination.bulletSize);\n const offsetProp = rtl ? 'right' : 'left';\n bullets.css(swiper.isHorizontal() ? offsetProp : 'top', `${bulletsOffset}px`);\n }\n }\n if (params.type === 'fraction') {\n $el.find(`.${params.currentClass}`).text(params.formatFractionCurrent(current + 1));\n $el.find(`.${params.totalClass}`).text(params.formatFractionTotal(total));\n }\n if (params.type === 'progressbar') {\n let progressbarDirection;\n if (params.progressbarOpposite) {\n progressbarDirection = swiper.isHorizontal() ? 'vertical' : 'horizontal';\n } else {\n progressbarDirection = swiper.isHorizontal() ? 'horizontal' : 'vertical';\n }\n const scale = (current + 1) / total;\n let scaleX = 1;\n let scaleY = 1;\n if (progressbarDirection === 'horizontal') {\n scaleX = scale;\n } else {\n scaleY = scale;\n }\n $el.find(`.${params.progressbarFillClass}`).transform(`translate3d(0,0,0) scaleX(${scaleX}) scaleY(${scaleY})`).transition(swiper.params.speed);\n }\n if (params.type === 'custom' && params.renderCustom) {\n $el.html(params.renderCustom(swiper, current + 1, total));\n swiper.emit('paginationRender', swiper, $el[0]);\n } else {\n swiper.emit('paginationUpdate', swiper, $el[0]);\n }\n $el[swiper.params.watchOverflow && swiper.isLocked ? 'addClass' : 'removeClass'](params.lockClass);\n },\n render() {\n // Render Container\n const swiper = this;\n const params = swiper.params.pagination;\n if (!params.el || !swiper.pagination.el || !swiper.pagination.$el || swiper.pagination.$el.length === 0) return;\n const slidesLength = swiper.virtual && swiper.params.virtual.enabled ? swiper.virtual.slides.length : swiper.slides.length;\n\n const $el = swiper.pagination.$el;\n let paginationHTML = '';\n if (params.type === 'bullets') {\n const numberOfBullets = swiper.params.loop ? Math.ceil((slidesLength - (swiper.loopedSlides * 2)) / swiper.params.slidesPerGroup) : swiper.snapGrid.length;\n for (let i = 0; i < numberOfBullets; i += 1) {\n if (params.renderBullet) {\n paginationHTML += params.renderBullet.call(swiper, i, params.bulletClass);\n } else {\n paginationHTML += `<${params.bulletElement} class=\"${params.bulletClass}\">`;\n }\n }\n $el.html(paginationHTML);\n swiper.pagination.bullets = $el.find(`.${params.bulletClass}`);\n }\n if (params.type === 'fraction') {\n if (params.renderFraction) {\n paginationHTML = params.renderFraction.call(swiper, params.currentClass, params.totalClass);\n } else {\n paginationHTML = ``\n + ' / '\n + ``;\n }\n $el.html(paginationHTML);\n }\n if (params.type === 'progressbar') {\n if (params.renderProgressbar) {\n paginationHTML = params.renderProgressbar.call(swiper, params.progressbarFillClass);\n } else {\n paginationHTML = ``;\n }\n $el.html(paginationHTML);\n }\n if (params.type !== 'custom') {\n swiper.emit('paginationRender', swiper.pagination.$el[0]);\n }\n },\n init() {\n const swiper = this;\n const params = swiper.params.pagination;\n if (!params.el) return;\n\n let $el = $(params.el);\n if ($el.length === 0) return;\n\n if (\n swiper.params.uniqueNavElements\n && typeof params.el === 'string'\n && $el.length > 1\n && swiper.$el.find(params.el).length === 1\n ) {\n $el = swiper.$el.find(params.el);\n }\n\n if (params.type === 'bullets' && params.clickable) {\n $el.addClass(params.clickableClass);\n }\n\n $el.addClass(params.modifierClass + params.type);\n\n if (params.type === 'bullets' && params.dynamicBullets) {\n $el.addClass(`${params.modifierClass}${params.type}-dynamic`);\n swiper.pagination.dynamicBulletIndex = 0;\n if (params.dynamicMainBullets < 1) {\n params.dynamicMainBullets = 1;\n }\n }\n if (params.type === 'progressbar' && params.progressbarOpposite) {\n $el.addClass(params.progressbarOppositeClass);\n }\n\n if (params.clickable) {\n $el.on('click', `.${params.bulletClass}`, function onClick(e) {\n e.preventDefault();\n let index = $(this).index() * swiper.params.slidesPerGroup;\n if (swiper.params.loop) index += swiper.loopedSlides;\n swiper.slideTo(index);\n });\n }\n\n Utils.extend(swiper.pagination, {\n $el,\n el: $el[0],\n });\n },\n destroy() {\n const swiper = this;\n const params = swiper.params.pagination;\n if (!params.el || !swiper.pagination.el || !swiper.pagination.$el || swiper.pagination.$el.length === 0) return;\n const $el = swiper.pagination.$el;\n\n $el.removeClass(params.hiddenClass);\n $el.removeClass(params.modifierClass + params.type);\n if (swiper.pagination.bullets) swiper.pagination.bullets.removeClass(params.bulletActiveClass);\n if (params.clickable) {\n $el.off('click', `.${params.bulletClass}`);\n }\n },\n};\n\nvar Pagination$1 = {\n name: 'pagination',\n params: {\n pagination: {\n el: null,\n bulletElement: 'span',\n clickable: false,\n hideOnClick: false,\n renderBullet: null,\n renderProgressbar: null,\n renderFraction: null,\n renderCustom: null,\n progressbarOpposite: false,\n type: 'bullets', // 'bullets' or 'progressbar' or 'fraction' or 'custom'\n dynamicBullets: false,\n dynamicMainBullets: 1,\n formatFractionCurrent: (number) => number,\n formatFractionTotal: (number) => number,\n bulletClass: 'swiper-pagination-bullet',\n bulletActiveClass: 'swiper-pagination-bullet-active',\n modifierClass: 'swiper-pagination-', // NEW\n currentClass: 'swiper-pagination-current',\n totalClass: 'swiper-pagination-total',\n hiddenClass: 'swiper-pagination-hidden',\n progressbarFillClass: 'swiper-pagination-progressbar-fill',\n progressbarOppositeClass: 'swiper-pagination-progressbar-opposite',\n clickableClass: 'swiper-pagination-clickable', // NEW\n lockClass: 'swiper-pagination-lock',\n },\n },\n create() {\n const swiper = this;\n Utils.extend(swiper, {\n pagination: {\n init: Pagination.init.bind(swiper),\n render: Pagination.render.bind(swiper),\n update: Pagination.update.bind(swiper),\n destroy: Pagination.destroy.bind(swiper),\n dynamicBulletIndex: 0,\n },\n });\n },\n on: {\n init() {\n const swiper = this;\n swiper.pagination.init();\n swiper.pagination.render();\n swiper.pagination.update();\n },\n activeIndexChange() {\n const swiper = this;\n if (swiper.params.loop) {\n swiper.pagination.update();\n } else if (typeof swiper.snapIndex === 'undefined') {\n swiper.pagination.update();\n }\n },\n snapIndexChange() {\n const swiper = this;\n if (!swiper.params.loop) {\n swiper.pagination.update();\n }\n },\n slidesLengthChange() {\n const swiper = this;\n if (swiper.params.loop) {\n swiper.pagination.render();\n swiper.pagination.update();\n }\n },\n snapGridLengthChange() {\n const swiper = this;\n if (!swiper.params.loop) {\n swiper.pagination.render();\n swiper.pagination.update();\n }\n },\n destroy() {\n const swiper = this;\n swiper.pagination.destroy();\n },\n click(e) {\n const swiper = this;\n if (\n swiper.params.pagination.el\n && swiper.params.pagination.hideOnClick\n && swiper.pagination.$el.length > 0\n && !$(e.target).hasClass(swiper.params.pagination.bulletClass)\n ) {\n const isHidden = swiper.pagination.$el.hasClass(swiper.params.pagination.hiddenClass);\n if (isHidden === true) {\n swiper.emit('paginationShow', swiper);\n } else {\n swiper.emit('paginationHide', swiper);\n }\n swiper.pagination.$el.toggleClass(swiper.params.pagination.hiddenClass);\n }\n },\n },\n};\n\nconst Scrollbar = {\n setTranslate() {\n const swiper = this;\n if (!swiper.params.scrollbar.el || !swiper.scrollbar.el) return;\n const { scrollbar, rtlTranslate: rtl, progress } = swiper;\n const {\n dragSize, trackSize, $dragEl, $el,\n } = scrollbar;\n const params = swiper.params.scrollbar;\n\n let newSize = dragSize;\n let newPos = (trackSize - dragSize) * progress;\n if (rtl) {\n newPos = -newPos;\n if (newPos > 0) {\n newSize = dragSize - newPos;\n newPos = 0;\n } else if (-newPos + dragSize > trackSize) {\n newSize = trackSize + newPos;\n }\n } else if (newPos < 0) {\n newSize = dragSize + newPos;\n newPos = 0;\n } else if (newPos + dragSize > trackSize) {\n newSize = trackSize - newPos;\n }\n if (swiper.isHorizontal()) {\n if (Support.transforms3d) {\n $dragEl.transform(`translate3d(${newPos}px, 0, 0)`);\n } else {\n $dragEl.transform(`translateX(${newPos}px)`);\n }\n $dragEl[0].style.width = `${newSize}px`;\n } else {\n if (Support.transforms3d) {\n $dragEl.transform(`translate3d(0px, ${newPos}px, 0)`);\n } else {\n $dragEl.transform(`translateY(${newPos}px)`);\n }\n $dragEl[0].style.height = `${newSize}px`;\n }\n if (params.hide) {\n clearTimeout(swiper.scrollbar.timeout);\n $el[0].style.opacity = 1;\n swiper.scrollbar.timeout = setTimeout(() => {\n $el[0].style.opacity = 0;\n $el.transition(400);\n }, 1000);\n }\n },\n setTransition(duration) {\n const swiper = this;\n if (!swiper.params.scrollbar.el || !swiper.scrollbar.el) return;\n swiper.scrollbar.$dragEl.transition(duration);\n },\n updateSize() {\n const swiper = this;\n if (!swiper.params.scrollbar.el || !swiper.scrollbar.el) return;\n\n const { scrollbar } = swiper;\n const { $dragEl, $el } = scrollbar;\n\n $dragEl[0].style.width = '';\n $dragEl[0].style.height = '';\n const trackSize = swiper.isHorizontal() ? $el[0].offsetWidth : $el[0].offsetHeight;\n\n const divider = swiper.size / swiper.virtualSize;\n const moveDivider = divider * (trackSize / swiper.size);\n let dragSize;\n if (swiper.params.scrollbar.dragSize === 'auto') {\n dragSize = trackSize * divider;\n } else {\n dragSize = parseInt(swiper.params.scrollbar.dragSize, 10);\n }\n\n if (swiper.isHorizontal()) {\n $dragEl[0].style.width = `${dragSize}px`;\n } else {\n $dragEl[0].style.height = `${dragSize}px`;\n }\n\n if (divider >= 1) {\n $el[0].style.display = 'none';\n } else {\n $el[0].style.display = '';\n }\n if (swiper.params.scrollbar.hide) {\n $el[0].style.opacity = 0;\n }\n Utils.extend(scrollbar, {\n trackSize,\n divider,\n moveDivider,\n dragSize,\n });\n scrollbar.$el[swiper.params.watchOverflow && swiper.isLocked ? 'addClass' : 'removeClass'](swiper.params.scrollbar.lockClass);\n },\n getPointerPosition(e) {\n const swiper = this;\n if (swiper.isHorizontal()) {\n return ((e.type === 'touchstart' || e.type === 'touchmove') ? e.targetTouches[0].pageX : e.pageX || e.clientX);\n }\n return ((e.type === 'touchstart' || e.type === 'touchmove') ? e.targetTouches[0].pageY : e.pageY || e.clientY);\n },\n setDragPosition(e) {\n const swiper = this;\n const { scrollbar, rtlTranslate: rtl } = swiper;\n const {\n $el,\n dragSize,\n trackSize,\n dragStartPos,\n } = scrollbar;\n\n let positionRatio;\n positionRatio = ((scrollbar.getPointerPosition(e)) - $el.offset()[swiper.isHorizontal() ? 'left' : 'top']\n - (dragStartPos !== null ? dragStartPos : dragSize / 2)) / (trackSize - dragSize);\n positionRatio = Math.max(Math.min(positionRatio, 1), 0);\n if (rtl) {\n positionRatio = 1 - positionRatio;\n }\n\n const position = swiper.minTranslate() + ((swiper.maxTranslate() - swiper.minTranslate()) * positionRatio);\n\n swiper.updateProgress(position);\n swiper.setTranslate(position);\n swiper.updateActiveIndex();\n swiper.updateSlidesClasses();\n },\n onDragStart(e) {\n const swiper = this;\n const params = swiper.params.scrollbar;\n const { scrollbar, $wrapperEl } = swiper;\n const { $el, $dragEl } = scrollbar;\n swiper.scrollbar.isTouched = true;\n swiper.scrollbar.dragStartPos = (e.target === $dragEl[0] || e.target === $dragEl)\n ? scrollbar.getPointerPosition(e) - e.target.getBoundingClientRect()[swiper.isHorizontal() ? 'left' : 'top'] : null;\n e.preventDefault();\n e.stopPropagation();\n\n $wrapperEl.transition(100);\n $dragEl.transition(100);\n scrollbar.setDragPosition(e);\n\n clearTimeout(swiper.scrollbar.dragTimeout);\n\n $el.transition(0);\n if (params.hide) {\n $el.css('opacity', 1);\n }\n swiper.emit('scrollbarDragStart', e);\n },\n onDragMove(e) {\n const swiper = this;\n const { scrollbar, $wrapperEl } = swiper;\n const { $el, $dragEl } = scrollbar;\n\n if (!swiper.scrollbar.isTouched) return;\n if (e.preventDefault) e.preventDefault();\n else e.returnValue = false;\n scrollbar.setDragPosition(e);\n $wrapperEl.transition(0);\n $el.transition(0);\n $dragEl.transition(0);\n swiper.emit('scrollbarDragMove', e);\n },\n onDragEnd(e) {\n const swiper = this;\n\n const params = swiper.params.scrollbar;\n const { scrollbar } = swiper;\n const { $el } = scrollbar;\n\n if (!swiper.scrollbar.isTouched) return;\n swiper.scrollbar.isTouched = false;\n if (params.hide) {\n clearTimeout(swiper.scrollbar.dragTimeout);\n swiper.scrollbar.dragTimeout = Utils.nextTick(() => {\n $el.css('opacity', 0);\n $el.transition(400);\n }, 1000);\n }\n swiper.emit('scrollbarDragEnd', e);\n if (params.snapOnRelease) {\n swiper.slideToClosest();\n }\n },\n enableDraggable() {\n const swiper = this;\n if (!swiper.params.scrollbar.el) return;\n const {\n scrollbar, touchEventsTouch, touchEventsDesktop, params,\n } = swiper;\n const $el = scrollbar.$el;\n const target = $el[0];\n const activeListener = Support.passiveListener && params.passiveListeners ? { passive: false, capture: false } : false;\n const passiveListener = Support.passiveListener && params.passiveListeners ? { passive: true, capture: false } : false;\n if (!Support.touch) {\n target.addEventListener(touchEventsDesktop.start, swiper.scrollbar.onDragStart, activeListener);\n document.addEventListener(touchEventsDesktop.move, swiper.scrollbar.onDragMove, activeListener);\n document.addEventListener(touchEventsDesktop.end, swiper.scrollbar.onDragEnd, passiveListener);\n } else {\n target.addEventListener(touchEventsTouch.start, swiper.scrollbar.onDragStart, activeListener);\n target.addEventListener(touchEventsTouch.move, swiper.scrollbar.onDragMove, activeListener);\n target.addEventListener(touchEventsTouch.end, swiper.scrollbar.onDragEnd, passiveListener);\n }\n },\n disableDraggable() {\n const swiper = this;\n if (!swiper.params.scrollbar.el) return;\n const {\n scrollbar, touchEventsTouch, touchEventsDesktop, params,\n } = swiper;\n const $el = scrollbar.$el;\n const target = $el[0];\n const activeListener = Support.passiveListener && params.passiveListeners ? { passive: false, capture: false } : false;\n const passiveListener = Support.passiveListener && params.passiveListeners ? { passive: true, capture: false } : false;\n if (!Support.touch) {\n target.removeEventListener(touchEventsDesktop.start, swiper.scrollbar.onDragStart, activeListener);\n document.removeEventListener(touchEventsDesktop.move, swiper.scrollbar.onDragMove, activeListener);\n document.removeEventListener(touchEventsDesktop.end, swiper.scrollbar.onDragEnd, passiveListener);\n } else {\n target.removeEventListener(touchEventsTouch.start, swiper.scrollbar.onDragStart, activeListener);\n target.removeEventListener(touchEventsTouch.move, swiper.scrollbar.onDragMove, activeListener);\n target.removeEventListener(touchEventsTouch.end, swiper.scrollbar.onDragEnd, passiveListener);\n }\n },\n init() {\n const swiper = this;\n if (!swiper.params.scrollbar.el) return;\n const { scrollbar, $el: $swiperEl } = swiper;\n const params = swiper.params.scrollbar;\n\n let $el = $(params.el);\n if (swiper.params.uniqueNavElements && typeof params.el === 'string' && $el.length > 1 && $swiperEl.find(params.el).length === 1) {\n $el = $swiperEl.find(params.el);\n }\n\n let $dragEl = $el.find(`.${swiper.params.scrollbar.dragClass}`);\n if ($dragEl.length === 0) {\n $dragEl = $(`
`);\n $el.append($dragEl);\n }\n\n Utils.extend(scrollbar, {\n $el,\n el: $el[0],\n $dragEl,\n dragEl: $dragEl[0],\n });\n\n if (params.draggable) {\n scrollbar.enableDraggable();\n }\n },\n destroy() {\n const swiper = this;\n swiper.scrollbar.disableDraggable();\n },\n};\n\nvar Scrollbar$1 = {\n name: 'scrollbar',\n params: {\n scrollbar: {\n el: null,\n dragSize: 'auto',\n hide: false,\n draggable: false,\n snapOnRelease: true,\n lockClass: 'swiper-scrollbar-lock',\n dragClass: 'swiper-scrollbar-drag',\n },\n },\n create() {\n const swiper = this;\n Utils.extend(swiper, {\n scrollbar: {\n init: Scrollbar.init.bind(swiper),\n destroy: Scrollbar.destroy.bind(swiper),\n updateSize: Scrollbar.updateSize.bind(swiper),\n setTranslate: Scrollbar.setTranslate.bind(swiper),\n setTransition: Scrollbar.setTransition.bind(swiper),\n enableDraggable: Scrollbar.enableDraggable.bind(swiper),\n disableDraggable: Scrollbar.disableDraggable.bind(swiper),\n setDragPosition: Scrollbar.setDragPosition.bind(swiper),\n getPointerPosition: Scrollbar.getPointerPosition.bind(swiper),\n onDragStart: Scrollbar.onDragStart.bind(swiper),\n onDragMove: Scrollbar.onDragMove.bind(swiper),\n onDragEnd: Scrollbar.onDragEnd.bind(swiper),\n isTouched: false,\n timeout: null,\n dragTimeout: null,\n },\n });\n },\n on: {\n init() {\n const swiper = this;\n swiper.scrollbar.init();\n swiper.scrollbar.updateSize();\n swiper.scrollbar.setTranslate();\n },\n update() {\n const swiper = this;\n swiper.scrollbar.updateSize();\n },\n resize() {\n const swiper = this;\n swiper.scrollbar.updateSize();\n },\n observerUpdate() {\n const swiper = this;\n swiper.scrollbar.updateSize();\n },\n setTranslate() {\n const swiper = this;\n swiper.scrollbar.setTranslate();\n },\n setTransition(duration) {\n const swiper = this;\n swiper.scrollbar.setTransition(duration);\n },\n destroy() {\n const swiper = this;\n swiper.scrollbar.destroy();\n },\n },\n};\n\nconst Parallax = {\n setTransform(el, progress) {\n const swiper = this;\n const { rtl } = swiper;\n\n const $el = $(el);\n const rtlFactor = rtl ? -1 : 1;\n\n const p = $el.attr('data-swiper-parallax') || '0';\n let x = $el.attr('data-swiper-parallax-x');\n let y = $el.attr('data-swiper-parallax-y');\n const scale = $el.attr('data-swiper-parallax-scale');\n const opacity = $el.attr('data-swiper-parallax-opacity');\n\n if (x || y) {\n x = x || '0';\n y = y || '0';\n } else if (swiper.isHorizontal()) {\n x = p;\n y = '0';\n } else {\n y = p;\n x = '0';\n }\n\n if ((x).indexOf('%') >= 0) {\n x = `${parseInt(x, 10) * progress * rtlFactor}%`;\n } else {\n x = `${x * progress * rtlFactor}px`;\n }\n if ((y).indexOf('%') >= 0) {\n y = `${parseInt(y, 10) * progress}%`;\n } else {\n y = `${y * progress}px`;\n }\n\n if (typeof opacity !== 'undefined' && opacity !== null) {\n const currentOpacity = opacity - ((opacity - 1) * (1 - Math.abs(progress)));\n $el[0].style.opacity = currentOpacity;\n }\n if (typeof scale === 'undefined' || scale === null) {\n $el.transform(`translate3d(${x}, ${y}, 0px)`);\n } else {\n const currentScale = scale - ((scale - 1) * (1 - Math.abs(progress)));\n $el.transform(`translate3d(${x}, ${y}, 0px) scale(${currentScale})`);\n }\n },\n setTranslate() {\n const swiper = this;\n const {\n $el, slides, progress, snapGrid,\n } = swiper;\n $el.children('[data-swiper-parallax], [data-swiper-parallax-x], [data-swiper-parallax-y], [data-swiper-parallax-opacity], [data-swiper-parallax-scale]')\n .each((index, el) => {\n swiper.parallax.setTransform(el, progress);\n });\n slides.each((slideIndex, slideEl) => {\n let slideProgress = slideEl.progress;\n if (swiper.params.slidesPerGroup > 1 && swiper.params.slidesPerView !== 'auto') {\n slideProgress += Math.ceil(slideIndex / 2) - (progress * (snapGrid.length - 1));\n }\n slideProgress = Math.min(Math.max(slideProgress, -1), 1);\n $(slideEl).find('[data-swiper-parallax], [data-swiper-parallax-x], [data-swiper-parallax-y], [data-swiper-parallax-opacity], [data-swiper-parallax-scale]')\n .each((index, el) => {\n swiper.parallax.setTransform(el, slideProgress);\n });\n });\n },\n setTransition(duration = this.params.speed) {\n const swiper = this;\n const { $el } = swiper;\n $el.find('[data-swiper-parallax], [data-swiper-parallax-x], [data-swiper-parallax-y], [data-swiper-parallax-opacity], [data-swiper-parallax-scale]')\n .each((index, parallaxEl) => {\n const $parallaxEl = $(parallaxEl);\n let parallaxDuration = parseInt($parallaxEl.attr('data-swiper-parallax-duration'), 10) || duration;\n if (duration === 0) parallaxDuration = 0;\n $parallaxEl.transition(parallaxDuration);\n });\n },\n};\n\nvar Parallax$1 = {\n name: 'parallax',\n params: {\n parallax: {\n enabled: false,\n },\n },\n create() {\n const swiper = this;\n Utils.extend(swiper, {\n parallax: {\n setTransform: Parallax.setTransform.bind(swiper),\n setTranslate: Parallax.setTranslate.bind(swiper),\n setTransition: Parallax.setTransition.bind(swiper),\n },\n });\n },\n on: {\n beforeInit() {\n const swiper = this;\n if (!swiper.params.parallax.enabled) return;\n swiper.params.watchSlidesProgress = true;\n swiper.originalParams.watchSlidesProgress = true;\n },\n init() {\n const swiper = this;\n if (!swiper.params.parallax.enabled) return;\n swiper.parallax.setTranslate();\n },\n setTranslate() {\n const swiper = this;\n if (!swiper.params.parallax.enabled) return;\n swiper.parallax.setTranslate();\n },\n setTransition(duration) {\n const swiper = this;\n if (!swiper.params.parallax.enabled) return;\n swiper.parallax.setTransition(duration);\n },\n },\n};\n\nconst Zoom = {\n // Calc Scale From Multi-touches\n getDistanceBetweenTouches(e) {\n if (e.targetTouches.length < 2) return 1;\n const x1 = e.targetTouches[0].pageX;\n const y1 = e.targetTouches[0].pageY;\n const x2 = e.targetTouches[1].pageX;\n const y2 = e.targetTouches[1].pageY;\n const distance = Math.sqrt(((x2 - x1) ** 2) + ((y2 - y1) ** 2));\n return distance;\n },\n // Events\n onGestureStart(e) {\n const swiper = this;\n const params = swiper.params.zoom;\n const zoom = swiper.zoom;\n const { gesture } = zoom;\n zoom.fakeGestureTouched = false;\n zoom.fakeGestureMoved = false;\n if (!Support.gestures) {\n if (e.type !== 'touchstart' || (e.type === 'touchstart' && e.targetTouches.length < 2)) {\n return;\n }\n zoom.fakeGestureTouched = true;\n gesture.scaleStart = Zoom.getDistanceBetweenTouches(e);\n }\n if (!gesture.$slideEl || !gesture.$slideEl.length) {\n gesture.$slideEl = $(e.target).closest('.swiper-slide');\n if (gesture.$slideEl.length === 0) gesture.$slideEl = swiper.slides.eq(swiper.activeIndex);\n gesture.$imageEl = gesture.$slideEl.find('img, svg, canvas');\n gesture.$imageWrapEl = gesture.$imageEl.parent(`.${params.containerClass}`);\n gesture.maxRatio = gesture.$imageWrapEl.attr('data-swiper-zoom') || params.maxRatio;\n if (gesture.$imageWrapEl.length === 0) {\n gesture.$imageEl = undefined;\n return;\n }\n }\n gesture.$imageEl.transition(0);\n swiper.zoom.isScaling = true;\n },\n onGestureChange(e) {\n const swiper = this;\n const params = swiper.params.zoom;\n const zoom = swiper.zoom;\n const { gesture } = zoom;\n if (!Support.gestures) {\n if (e.type !== 'touchmove' || (e.type === 'touchmove' && e.targetTouches.length < 2)) {\n return;\n }\n zoom.fakeGestureMoved = true;\n gesture.scaleMove = Zoom.getDistanceBetweenTouches(e);\n }\n if (!gesture.$imageEl || gesture.$imageEl.length === 0) return;\n if (Support.gestures) {\n zoom.scale = e.scale * zoom.currentScale;\n } else {\n zoom.scale = (gesture.scaleMove / gesture.scaleStart) * zoom.currentScale;\n }\n if (zoom.scale > gesture.maxRatio) {\n zoom.scale = (gesture.maxRatio - 1) + (((zoom.scale - gesture.maxRatio) + 1) ** 0.5);\n }\n if (zoom.scale < params.minRatio) {\n zoom.scale = (params.minRatio + 1) - (((params.minRatio - zoom.scale) + 1) ** 0.5);\n }\n gesture.$imageEl.transform(`translate3d(0,0,0) scale(${zoom.scale})`);\n },\n onGestureEnd(e) {\n const swiper = this;\n const params = swiper.params.zoom;\n const zoom = swiper.zoom;\n const { gesture } = zoom;\n if (!Support.gestures) {\n if (!zoom.fakeGestureTouched || !zoom.fakeGestureMoved) {\n return;\n }\n if (e.type !== 'touchend' || (e.type === 'touchend' && e.changedTouches.length < 2 && !Device.android)) {\n return;\n }\n zoom.fakeGestureTouched = false;\n zoom.fakeGestureMoved = false;\n }\n if (!gesture.$imageEl || gesture.$imageEl.length === 0) return;\n zoom.scale = Math.max(Math.min(zoom.scale, gesture.maxRatio), params.minRatio);\n gesture.$imageEl.transition(swiper.params.speed).transform(`translate3d(0,0,0) scale(${zoom.scale})`);\n zoom.currentScale = zoom.scale;\n zoom.isScaling = false;\n if (zoom.scale === 1) gesture.$slideEl = undefined;\n },\n onTouchStart(e) {\n const swiper = this;\n const zoom = swiper.zoom;\n const { gesture, image } = zoom;\n if (!gesture.$imageEl || gesture.$imageEl.length === 0) return;\n if (image.isTouched) return;\n if (Device.android) e.preventDefault();\n image.isTouched = true;\n image.touchesStart.x = e.type === 'touchstart' ? e.targetTouches[0].pageX : e.pageX;\n image.touchesStart.y = e.type === 'touchstart' ? e.targetTouches[0].pageY : e.pageY;\n },\n onTouchMove(e) {\n const swiper = this;\n const zoom = swiper.zoom;\n const { gesture, image, velocity } = zoom;\n if (!gesture.$imageEl || gesture.$imageEl.length === 0) return;\n swiper.allowClick = false;\n if (!image.isTouched || !gesture.$slideEl) return;\n\n if (!image.isMoved) {\n image.width = gesture.$imageEl[0].offsetWidth;\n image.height = gesture.$imageEl[0].offsetHeight;\n image.startX = Utils.getTranslate(gesture.$imageWrapEl[0], 'x') || 0;\n image.startY = Utils.getTranslate(gesture.$imageWrapEl[0], 'y') || 0;\n gesture.slideWidth = gesture.$slideEl[0].offsetWidth;\n gesture.slideHeight = gesture.$slideEl[0].offsetHeight;\n gesture.$imageWrapEl.transition(0);\n if (swiper.rtl) {\n image.startX = -image.startX;\n image.startY = -image.startY;\n }\n }\n // Define if we need image drag\n const scaledWidth = image.width * zoom.scale;\n const scaledHeight = image.height * zoom.scale;\n\n if (scaledWidth < gesture.slideWidth && scaledHeight < gesture.slideHeight) return;\n\n image.minX = Math.min(((gesture.slideWidth / 2) - (scaledWidth / 2)), 0);\n image.maxX = -image.minX;\n image.minY = Math.min(((gesture.slideHeight / 2) - (scaledHeight / 2)), 0);\n image.maxY = -image.minY;\n\n image.touchesCurrent.x = e.type === 'touchmove' ? e.targetTouches[0].pageX : e.pageX;\n image.touchesCurrent.y = e.type === 'touchmove' ? e.targetTouches[0].pageY : e.pageY;\n\n if (!image.isMoved && !zoom.isScaling) {\n if (\n swiper.isHorizontal()\n && (\n (Math.floor(image.minX) === Math.floor(image.startX) && image.touchesCurrent.x < image.touchesStart.x)\n || (Math.floor(image.maxX) === Math.floor(image.startX) && image.touchesCurrent.x > image.touchesStart.x)\n )\n ) {\n image.isTouched = false;\n return;\n } if (\n !swiper.isHorizontal()\n && (\n (Math.floor(image.minY) === Math.floor(image.startY) && image.touchesCurrent.y < image.touchesStart.y)\n || (Math.floor(image.maxY) === Math.floor(image.startY) && image.touchesCurrent.y > image.touchesStart.y)\n )\n ) {\n image.isTouched = false;\n return;\n }\n }\n e.preventDefault();\n e.stopPropagation();\n\n image.isMoved = true;\n image.currentX = (image.touchesCurrent.x - image.touchesStart.x) + image.startX;\n image.currentY = (image.touchesCurrent.y - image.touchesStart.y) + image.startY;\n\n if (image.currentX < image.minX) {\n image.currentX = (image.minX + 1) - (((image.minX - image.currentX) + 1) ** 0.8);\n }\n if (image.currentX > image.maxX) {\n image.currentX = (image.maxX - 1) + (((image.currentX - image.maxX) + 1) ** 0.8);\n }\n\n if (image.currentY < image.minY) {\n image.currentY = (image.minY + 1) - (((image.minY - image.currentY) + 1) ** 0.8);\n }\n if (image.currentY > image.maxY) {\n image.currentY = (image.maxY - 1) + (((image.currentY - image.maxY) + 1) ** 0.8);\n }\n\n // Velocity\n if (!velocity.prevPositionX) velocity.prevPositionX = image.touchesCurrent.x;\n if (!velocity.prevPositionY) velocity.prevPositionY = image.touchesCurrent.y;\n if (!velocity.prevTime) velocity.prevTime = Date.now();\n velocity.x = (image.touchesCurrent.x - velocity.prevPositionX) / (Date.now() - velocity.prevTime) / 2;\n velocity.y = (image.touchesCurrent.y - velocity.prevPositionY) / (Date.now() - velocity.prevTime) / 2;\n if (Math.abs(image.touchesCurrent.x - velocity.prevPositionX) < 2) velocity.x = 0;\n if (Math.abs(image.touchesCurrent.y - velocity.prevPositionY) < 2) velocity.y = 0;\n velocity.prevPositionX = image.touchesCurrent.x;\n velocity.prevPositionY = image.touchesCurrent.y;\n velocity.prevTime = Date.now();\n\n gesture.$imageWrapEl.transform(`translate3d(${image.currentX}px, ${image.currentY}px,0)`);\n },\n onTouchEnd() {\n const swiper = this;\n const zoom = swiper.zoom;\n const { gesture, image, velocity } = zoom;\n if (!gesture.$imageEl || gesture.$imageEl.length === 0) return;\n if (!image.isTouched || !image.isMoved) {\n image.isTouched = false;\n image.isMoved = false;\n return;\n }\n image.isTouched = false;\n image.isMoved = false;\n let momentumDurationX = 300;\n let momentumDurationY = 300;\n const momentumDistanceX = velocity.x * momentumDurationX;\n const newPositionX = image.currentX + momentumDistanceX;\n const momentumDistanceY = velocity.y * momentumDurationY;\n const newPositionY = image.currentY + momentumDistanceY;\n\n // Fix duration\n if (velocity.x !== 0) momentumDurationX = Math.abs((newPositionX - image.currentX) / velocity.x);\n if (velocity.y !== 0) momentumDurationY = Math.abs((newPositionY - image.currentY) / velocity.y);\n const momentumDuration = Math.max(momentumDurationX, momentumDurationY);\n\n image.currentX = newPositionX;\n image.currentY = newPositionY;\n\n // Define if we need image drag\n const scaledWidth = image.width * zoom.scale;\n const scaledHeight = image.height * zoom.scale;\n image.minX = Math.min(((gesture.slideWidth / 2) - (scaledWidth / 2)), 0);\n image.maxX = -image.minX;\n image.minY = Math.min(((gesture.slideHeight / 2) - (scaledHeight / 2)), 0);\n image.maxY = -image.minY;\n image.currentX = Math.max(Math.min(image.currentX, image.maxX), image.minX);\n image.currentY = Math.max(Math.min(image.currentY, image.maxY), image.minY);\n\n gesture.$imageWrapEl.transition(momentumDuration).transform(`translate3d(${image.currentX}px, ${image.currentY}px,0)`);\n },\n onTransitionEnd() {\n const swiper = this;\n const zoom = swiper.zoom;\n const { gesture } = zoom;\n if (gesture.$slideEl && swiper.previousIndex !== swiper.activeIndex) {\n gesture.$imageEl.transform('translate3d(0,0,0) scale(1)');\n gesture.$imageWrapEl.transform('translate3d(0,0,0)');\n\n zoom.scale = 1;\n zoom.currentScale = 1;\n\n gesture.$slideEl = undefined;\n gesture.$imageEl = undefined;\n gesture.$imageWrapEl = undefined;\n }\n },\n // Toggle Zoom\n toggle(e) {\n const swiper = this;\n const zoom = swiper.zoom;\n\n if (zoom.scale && zoom.scale !== 1) {\n // Zoom Out\n zoom.out();\n } else {\n // Zoom In\n zoom.in(e);\n }\n },\n in(e) {\n const swiper = this;\n\n const zoom = swiper.zoom;\n const params = swiper.params.zoom;\n const { gesture, image } = zoom;\n\n if (!gesture.$slideEl) {\n gesture.$slideEl = swiper.clickedSlide ? $(swiper.clickedSlide) : swiper.slides.eq(swiper.activeIndex);\n gesture.$imageEl = gesture.$slideEl.find('img, svg, canvas');\n gesture.$imageWrapEl = gesture.$imageEl.parent(`.${params.containerClass}`);\n }\n if (!gesture.$imageEl || gesture.$imageEl.length === 0) return;\n\n gesture.$slideEl.addClass(`${params.zoomedSlideClass}`);\n\n let touchX;\n let touchY;\n let offsetX;\n let offsetY;\n let diffX;\n let diffY;\n let translateX;\n let translateY;\n let imageWidth;\n let imageHeight;\n let scaledWidth;\n let scaledHeight;\n let translateMinX;\n let translateMinY;\n let translateMaxX;\n let translateMaxY;\n let slideWidth;\n let slideHeight;\n\n if (typeof image.touchesStart.x === 'undefined' && e) {\n touchX = e.type === 'touchend' ? e.changedTouches[0].pageX : e.pageX;\n touchY = e.type === 'touchend' ? e.changedTouches[0].pageY : e.pageY;\n } else {\n touchX = image.touchesStart.x;\n touchY = image.touchesStart.y;\n }\n\n zoom.scale = gesture.$imageWrapEl.attr('data-swiper-zoom') || params.maxRatio;\n zoom.currentScale = gesture.$imageWrapEl.attr('data-swiper-zoom') || params.maxRatio;\n if (e) {\n slideWidth = gesture.$slideEl[0].offsetWidth;\n slideHeight = gesture.$slideEl[0].offsetHeight;\n offsetX = gesture.$slideEl.offset().left;\n offsetY = gesture.$slideEl.offset().top;\n diffX = (offsetX + (slideWidth / 2)) - touchX;\n diffY = (offsetY + (slideHeight / 2)) - touchY;\n\n imageWidth = gesture.$imageEl[0].offsetWidth;\n imageHeight = gesture.$imageEl[0].offsetHeight;\n scaledWidth = imageWidth * zoom.scale;\n scaledHeight = imageHeight * zoom.scale;\n\n translateMinX = Math.min(((slideWidth / 2) - (scaledWidth / 2)), 0);\n translateMinY = Math.min(((slideHeight / 2) - (scaledHeight / 2)), 0);\n translateMaxX = -translateMinX;\n translateMaxY = -translateMinY;\n\n translateX = diffX * zoom.scale;\n translateY = diffY * zoom.scale;\n\n if (translateX < translateMinX) {\n translateX = translateMinX;\n }\n if (translateX > translateMaxX) {\n translateX = translateMaxX;\n }\n\n if (translateY < translateMinY) {\n translateY = translateMinY;\n }\n if (translateY > translateMaxY) {\n translateY = translateMaxY;\n }\n } else {\n translateX = 0;\n translateY = 0;\n }\n gesture.$imageWrapEl.transition(300).transform(`translate3d(${translateX}px, ${translateY}px,0)`);\n gesture.$imageEl.transition(300).transform(`translate3d(0,0,0) scale(${zoom.scale})`);\n },\n out() {\n const swiper = this;\n\n const zoom = swiper.zoom;\n const params = swiper.params.zoom;\n const { gesture } = zoom;\n\n if (!gesture.$slideEl) {\n gesture.$slideEl = swiper.clickedSlide ? $(swiper.clickedSlide) : swiper.slides.eq(swiper.activeIndex);\n gesture.$imageEl = gesture.$slideEl.find('img, svg, canvas');\n gesture.$imageWrapEl = gesture.$imageEl.parent(`.${params.containerClass}`);\n }\n if (!gesture.$imageEl || gesture.$imageEl.length === 0) return;\n\n zoom.scale = 1;\n zoom.currentScale = 1;\n gesture.$imageWrapEl.transition(300).transform('translate3d(0,0,0)');\n gesture.$imageEl.transition(300).transform('translate3d(0,0,0) scale(1)');\n gesture.$slideEl.removeClass(`${params.zoomedSlideClass}`);\n gesture.$slideEl = undefined;\n },\n // Attach/Detach Events\n enable() {\n const swiper = this;\n const zoom = swiper.zoom;\n if (zoom.enabled) return;\n zoom.enabled = true;\n\n const passiveListener = swiper.touchEvents.start === 'touchstart' && Support.passiveListener && swiper.params.passiveListeners ? { passive: true, capture: false } : false;\n\n // Scale image\n if (Support.gestures) {\n swiper.$wrapperEl.on('gesturestart', '.swiper-slide', zoom.onGestureStart, passiveListener);\n swiper.$wrapperEl.on('gesturechange', '.swiper-slide', zoom.onGestureChange, passiveListener);\n swiper.$wrapperEl.on('gestureend', '.swiper-slide', zoom.onGestureEnd, passiveListener);\n } else if (swiper.touchEvents.start === 'touchstart') {\n swiper.$wrapperEl.on(swiper.touchEvents.start, '.swiper-slide', zoom.onGestureStart, passiveListener);\n swiper.$wrapperEl.on(swiper.touchEvents.move, '.swiper-slide', zoom.onGestureChange, passiveListener);\n swiper.$wrapperEl.on(swiper.touchEvents.end, '.swiper-slide', zoom.onGestureEnd, passiveListener);\n }\n\n // Move image\n swiper.$wrapperEl.on(swiper.touchEvents.move, `.${swiper.params.zoom.containerClass}`, zoom.onTouchMove);\n },\n disable() {\n const swiper = this;\n const zoom = swiper.zoom;\n if (!zoom.enabled) return;\n\n swiper.zoom.enabled = false;\n\n const passiveListener = swiper.touchEvents.start === 'touchstart' && Support.passiveListener && swiper.params.passiveListeners ? { passive: true, capture: false } : false;\n\n // Scale image\n if (Support.gestures) {\n swiper.$wrapperEl.off('gesturestart', '.swiper-slide', zoom.onGestureStart, passiveListener);\n swiper.$wrapperEl.off('gesturechange', '.swiper-slide', zoom.onGestureChange, passiveListener);\n swiper.$wrapperEl.off('gestureend', '.swiper-slide', zoom.onGestureEnd, passiveListener);\n } else if (swiper.touchEvents.start === 'touchstart') {\n swiper.$wrapperEl.off(swiper.touchEvents.start, '.swiper-slide', zoom.onGestureStart, passiveListener);\n swiper.$wrapperEl.off(swiper.touchEvents.move, '.swiper-slide', zoom.onGestureChange, passiveListener);\n swiper.$wrapperEl.off(swiper.touchEvents.end, '.swiper-slide', zoom.onGestureEnd, passiveListener);\n }\n\n // Move image\n swiper.$wrapperEl.off(swiper.touchEvents.move, `.${swiper.params.zoom.containerClass}`, zoom.onTouchMove);\n },\n};\n\nvar Zoom$1 = {\n name: 'zoom',\n params: {\n zoom: {\n enabled: false,\n maxRatio: 3,\n minRatio: 1,\n toggle: true,\n containerClass: 'swiper-zoom-container',\n zoomedSlideClass: 'swiper-slide-zoomed',\n },\n },\n create() {\n const swiper = this;\n const zoom = {\n enabled: false,\n scale: 1,\n currentScale: 1,\n isScaling: false,\n gesture: {\n $slideEl: undefined,\n slideWidth: undefined,\n slideHeight: undefined,\n $imageEl: undefined,\n $imageWrapEl: undefined,\n maxRatio: 3,\n },\n image: {\n isTouched: undefined,\n isMoved: undefined,\n currentX: undefined,\n currentY: undefined,\n minX: undefined,\n minY: undefined,\n maxX: undefined,\n maxY: undefined,\n width: undefined,\n height: undefined,\n startX: undefined,\n startY: undefined,\n touchesStart: {},\n touchesCurrent: {},\n },\n velocity: {\n x: undefined,\n y: undefined,\n prevPositionX: undefined,\n prevPositionY: undefined,\n prevTime: undefined,\n },\n };\n\n ('onGestureStart onGestureChange onGestureEnd onTouchStart onTouchMove onTouchEnd onTransitionEnd toggle enable disable in out').split(' ').forEach((methodName) => {\n zoom[methodName] = Zoom[methodName].bind(swiper);\n });\n Utils.extend(swiper, {\n zoom,\n });\n\n let scale = 1;\n Object.defineProperty(swiper.zoom, 'scale', {\n get() {\n return scale;\n },\n set(value) {\n if (scale !== value) {\n const imageEl = swiper.zoom.gesture.$imageEl ? swiper.zoom.gesture.$imageEl[0] : undefined;\n const slideEl = swiper.zoom.gesture.$slideEl ? swiper.zoom.gesture.$slideEl[0] : undefined;\n swiper.emit('zoomChange', value, imageEl, slideEl);\n }\n scale = value;\n },\n });\n },\n on: {\n init() {\n const swiper = this;\n if (swiper.params.zoom.enabled) {\n swiper.zoom.enable();\n }\n },\n destroy() {\n const swiper = this;\n swiper.zoom.disable();\n },\n touchStart(e) {\n const swiper = this;\n if (!swiper.zoom.enabled) return;\n swiper.zoom.onTouchStart(e);\n },\n touchEnd(e) {\n const swiper = this;\n if (!swiper.zoom.enabled) return;\n swiper.zoom.onTouchEnd(e);\n },\n doubleTap(e) {\n const swiper = this;\n if (swiper.params.zoom.enabled && swiper.zoom.enabled && swiper.params.zoom.toggle) {\n swiper.zoom.toggle(e);\n }\n },\n transitionEnd() {\n const swiper = this;\n if (swiper.zoom.enabled && swiper.params.zoom.enabled) {\n swiper.zoom.onTransitionEnd();\n }\n },\n },\n};\n\nconst Lazy = {\n loadInSlide(index, loadInDuplicate = true) {\n const swiper = this;\n const params = swiper.params.lazy;\n if (typeof index === 'undefined') return;\n if (swiper.slides.length === 0) return;\n const isVirtual = swiper.virtual && swiper.params.virtual.enabled;\n\n const $slideEl = isVirtual\n ? swiper.$wrapperEl.children(`.${swiper.params.slideClass}[data-swiper-slide-index=\"${index}\"]`)\n : swiper.slides.eq(index);\n\n let $images = $slideEl.find(`.${params.elementClass}:not(.${params.loadedClass}):not(.${params.loadingClass})`);\n if ($slideEl.hasClass(params.elementClass) && !$slideEl.hasClass(params.loadedClass) && !$slideEl.hasClass(params.loadingClass)) {\n $images = $images.add($slideEl[0]);\n }\n if ($images.length === 0) return;\n\n $images.each((imageIndex, imageEl) => {\n const $imageEl = $(imageEl);\n $imageEl.addClass(params.loadingClass);\n\n const background = $imageEl.attr('data-background');\n const src = $imageEl.attr('data-src');\n const srcset = $imageEl.attr('data-srcset');\n const sizes = $imageEl.attr('data-sizes');\n\n swiper.loadImage($imageEl[0], (src || background), srcset, sizes, false, () => {\n if (typeof swiper === 'undefined' || swiper === null || !swiper || (swiper && !swiper.params) || swiper.destroyed) return;\n if (background) {\n $imageEl.css('background-image', `url(\"${background}\")`);\n $imageEl.removeAttr('data-background');\n } else {\n if (srcset) {\n $imageEl.attr('srcset', srcset);\n $imageEl.removeAttr('data-srcset');\n }\n if (sizes) {\n $imageEl.attr('sizes', sizes);\n $imageEl.removeAttr('data-sizes');\n }\n if (src) {\n $imageEl.attr('src', src);\n $imageEl.removeAttr('data-src');\n }\n }\n\n $imageEl.addClass(params.loadedClass).removeClass(params.loadingClass);\n $slideEl.find(`.${params.preloaderClass}`).remove();\n if (swiper.params.loop && loadInDuplicate) {\n const slideOriginalIndex = $slideEl.attr('data-swiper-slide-index');\n if ($slideEl.hasClass(swiper.params.slideDuplicateClass)) {\n const originalSlide = swiper.$wrapperEl.children(`[data-swiper-slide-index=\"${slideOriginalIndex}\"]:not(.${swiper.params.slideDuplicateClass})`);\n swiper.lazy.loadInSlide(originalSlide.index(), false);\n } else {\n const duplicatedSlide = swiper.$wrapperEl.children(`.${swiper.params.slideDuplicateClass}[data-swiper-slide-index=\"${slideOriginalIndex}\"]`);\n swiper.lazy.loadInSlide(duplicatedSlide.index(), false);\n }\n }\n swiper.emit('lazyImageReady', $slideEl[0], $imageEl[0]);\n });\n\n swiper.emit('lazyImageLoad', $slideEl[0], $imageEl[0]);\n });\n },\n load() {\n const swiper = this;\n const {\n $wrapperEl, params: swiperParams, slides, activeIndex,\n } = swiper;\n const isVirtual = swiper.virtual && swiperParams.virtual.enabled;\n const params = swiperParams.lazy;\n\n let slidesPerView = swiperParams.slidesPerView;\n if (slidesPerView === 'auto') {\n slidesPerView = 0;\n }\n\n function slideExist(index) {\n if (isVirtual) {\n if ($wrapperEl.children(`.${swiperParams.slideClass}[data-swiper-slide-index=\"${index}\"]`).length) {\n return true;\n }\n } else if (slides[index]) return true;\n return false;\n }\n function slideIndex(slideEl) {\n if (isVirtual) {\n return $(slideEl).attr('data-swiper-slide-index');\n }\n return $(slideEl).index();\n }\n\n if (!swiper.lazy.initialImageLoaded) swiper.lazy.initialImageLoaded = true;\n if (swiper.params.watchSlidesVisibility) {\n $wrapperEl.children(`.${swiperParams.slideVisibleClass}`).each((elIndex, slideEl) => {\n const index = isVirtual ? $(slideEl).attr('data-swiper-slide-index') : $(slideEl).index();\n swiper.lazy.loadInSlide(index);\n });\n } else if (slidesPerView > 1) {\n for (let i = activeIndex; i < activeIndex + slidesPerView; i += 1) {\n if (slideExist(i)) swiper.lazy.loadInSlide(i);\n }\n } else {\n swiper.lazy.loadInSlide(activeIndex);\n }\n if (params.loadPrevNext) {\n if (slidesPerView > 1 || (params.loadPrevNextAmount && params.loadPrevNextAmount > 1)) {\n const amount = params.loadPrevNextAmount;\n const spv = slidesPerView;\n const maxIndex = Math.min(activeIndex + spv + Math.max(amount, spv), slides.length);\n const minIndex = Math.max(activeIndex - Math.max(spv, amount), 0);\n // Next Slides\n for (let i = activeIndex + slidesPerView; i < maxIndex; i += 1) {\n if (slideExist(i)) swiper.lazy.loadInSlide(i);\n }\n // Prev Slides\n for (let i = minIndex; i < activeIndex; i += 1) {\n if (slideExist(i)) swiper.lazy.loadInSlide(i);\n }\n } else {\n const nextSlide = $wrapperEl.children(`.${swiperParams.slideNextClass}`);\n if (nextSlide.length > 0) swiper.lazy.loadInSlide(slideIndex(nextSlide));\n\n const prevSlide = $wrapperEl.children(`.${swiperParams.slidePrevClass}`);\n if (prevSlide.length > 0) swiper.lazy.loadInSlide(slideIndex(prevSlide));\n }\n }\n },\n};\n\nvar Lazy$1 = {\n name: 'lazy',\n params: {\n lazy: {\n enabled: false,\n loadPrevNext: false,\n loadPrevNextAmount: 1,\n loadOnTransitionStart: false,\n\n elementClass: 'swiper-lazy',\n loadingClass: 'swiper-lazy-loading',\n loadedClass: 'swiper-lazy-loaded',\n preloaderClass: 'swiper-lazy-preloader',\n },\n },\n create() {\n const swiper = this;\n Utils.extend(swiper, {\n lazy: {\n initialImageLoaded: false,\n load: Lazy.load.bind(swiper),\n loadInSlide: Lazy.loadInSlide.bind(swiper),\n },\n });\n },\n on: {\n beforeInit() {\n const swiper = this;\n if (swiper.params.lazy.enabled && swiper.params.preloadImages) {\n swiper.params.preloadImages = false;\n }\n },\n init() {\n const swiper = this;\n if (swiper.params.lazy.enabled && !swiper.params.loop && swiper.params.initialSlide === 0) {\n swiper.lazy.load();\n }\n },\n scroll() {\n const swiper = this;\n if (swiper.params.freeMode && !swiper.params.freeModeSticky) {\n swiper.lazy.load();\n }\n },\n resize() {\n const swiper = this;\n if (swiper.params.lazy.enabled) {\n swiper.lazy.load();\n }\n },\n scrollbarDragMove() {\n const swiper = this;\n if (swiper.params.lazy.enabled) {\n swiper.lazy.load();\n }\n },\n transitionStart() {\n const swiper = this;\n if (swiper.params.lazy.enabled) {\n if (swiper.params.lazy.loadOnTransitionStart || (!swiper.params.lazy.loadOnTransitionStart && !swiper.lazy.initialImageLoaded)) {\n swiper.lazy.load();\n }\n }\n },\n transitionEnd() {\n const swiper = this;\n if (swiper.params.lazy.enabled && !swiper.params.lazy.loadOnTransitionStart) {\n swiper.lazy.load();\n }\n },\n },\n};\n\n/* eslint no-bitwise: [\"error\", { \"allow\": [\">>\"] }] */\n\nconst Controller = {\n LinearSpline: function LinearSpline(x, y) {\n const binarySearch = (function search() {\n let maxIndex;\n let minIndex;\n let guess;\n return (array, val) => {\n minIndex = -1;\n maxIndex = array.length;\n while (maxIndex - minIndex > 1) {\n guess = maxIndex + minIndex >> 1;\n if (array[guess] <= val) {\n minIndex = guess;\n } else {\n maxIndex = guess;\n }\n }\n return maxIndex;\n };\n }());\n this.x = x;\n this.y = y;\n this.lastIndex = x.length - 1;\n // Given an x value (x2), return the expected y2 value:\n // (x1,y1) is the known point before given value,\n // (x3,y3) is the known point after given value.\n let i1;\n let i3;\n\n this.interpolate = function interpolate(x2) {\n if (!x2) return 0;\n\n // Get the indexes of x1 and x3 (the array indexes before and after given x2):\n i3 = binarySearch(this.x, x2);\n i1 = i3 - 1;\n\n // We have our indexes i1 & i3, so we can calculate already:\n // y2 := ((x2−x1) × (y3−y1)) ÷ (x3−x1) + y1\n return (((x2 - this.x[i1]) * (this.y[i3] - this.y[i1])) / (this.x[i3] - this.x[i1])) + this.y[i1];\n };\n return this;\n },\n // xxx: for now i will just save one spline function to to\n getInterpolateFunction(c) {\n const swiper = this;\n if (!swiper.controller.spline) {\n swiper.controller.spline = swiper.params.loop\n ? new Controller.LinearSpline(swiper.slidesGrid, c.slidesGrid)\n : new Controller.LinearSpline(swiper.snapGrid, c.snapGrid);\n }\n },\n setTranslate(setTranslate, byController) {\n const swiper = this;\n const controlled = swiper.controller.control;\n let multiplier;\n let controlledTranslate;\n function setControlledTranslate(c) {\n // this will create an Interpolate function based on the snapGrids\n // x is the Grid of the scrolled scroller and y will be the controlled scroller\n // it makes sense to create this only once and recall it for the interpolation\n // the function does a lot of value caching for performance\n const translate = swiper.rtlTranslate ? -swiper.translate : swiper.translate;\n if (swiper.params.controller.by === 'slide') {\n swiper.controller.getInterpolateFunction(c);\n // i am not sure why the values have to be multiplicated this way, tried to invert the snapGrid\n // but it did not work out\n controlledTranslate = -swiper.controller.spline.interpolate(-translate);\n }\n\n if (!controlledTranslate || swiper.params.controller.by === 'container') {\n multiplier = (c.maxTranslate() - c.minTranslate()) / (swiper.maxTranslate() - swiper.minTranslate());\n controlledTranslate = ((translate - swiper.minTranslate()) * multiplier) + c.minTranslate();\n }\n\n if (swiper.params.controller.inverse) {\n controlledTranslate = c.maxTranslate() - controlledTranslate;\n }\n c.updateProgress(controlledTranslate);\n c.setTranslate(controlledTranslate, swiper);\n c.updateActiveIndex();\n c.updateSlidesClasses();\n }\n if (Array.isArray(controlled)) {\n for (let i = 0; i < controlled.length; i += 1) {\n if (controlled[i] !== byController && controlled[i] instanceof Swiper) {\n setControlledTranslate(controlled[i]);\n }\n }\n } else if (controlled instanceof Swiper && byController !== controlled) {\n setControlledTranslate(controlled);\n }\n },\n setTransition(duration, byController) {\n const swiper = this;\n const controlled = swiper.controller.control;\n let i;\n function setControlledTransition(c) {\n c.setTransition(duration, swiper);\n if (duration !== 0) {\n c.transitionStart();\n if (c.params.autoHeight) {\n Utils.nextTick(() => {\n c.updateAutoHeight();\n });\n }\n c.$wrapperEl.transitionEnd(() => {\n if (!controlled) return;\n if (c.params.loop && swiper.params.controller.by === 'slide') {\n c.loopFix();\n }\n c.transitionEnd();\n });\n }\n }\n if (Array.isArray(controlled)) {\n for (i = 0; i < controlled.length; i += 1) {\n if (controlled[i] !== byController && controlled[i] instanceof Swiper) {\n setControlledTransition(controlled[i]);\n }\n }\n } else if (controlled instanceof Swiper && byController !== controlled) {\n setControlledTransition(controlled);\n }\n },\n};\nvar Controller$1 = {\n name: 'controller',\n params: {\n controller: {\n control: undefined,\n inverse: false,\n by: 'slide', // or 'container'\n },\n },\n create() {\n const swiper = this;\n Utils.extend(swiper, {\n controller: {\n control: swiper.params.controller.control,\n getInterpolateFunction: Controller.getInterpolateFunction.bind(swiper),\n setTranslate: Controller.setTranslate.bind(swiper),\n setTransition: Controller.setTransition.bind(swiper),\n },\n });\n },\n on: {\n update() {\n const swiper = this;\n if (!swiper.controller.control) return;\n if (swiper.controller.spline) {\n swiper.controller.spline = undefined;\n delete swiper.controller.spline;\n }\n },\n resize() {\n const swiper = this;\n if (!swiper.controller.control) return;\n if (swiper.controller.spline) {\n swiper.controller.spline = undefined;\n delete swiper.controller.spline;\n }\n },\n observerUpdate() {\n const swiper = this;\n if (!swiper.controller.control) return;\n if (swiper.controller.spline) {\n swiper.controller.spline = undefined;\n delete swiper.controller.spline;\n }\n },\n setTranslate(translate, byController) {\n const swiper = this;\n if (!swiper.controller.control) return;\n swiper.controller.setTranslate(translate, byController);\n },\n setTransition(duration, byController) {\n const swiper = this;\n if (!swiper.controller.control) return;\n swiper.controller.setTransition(duration, byController);\n },\n },\n};\n\nconst a11y = {\n makeElFocusable($el) {\n $el.attr('tabIndex', '0');\n return $el;\n },\n addElRole($el, role) {\n $el.attr('role', role);\n return $el;\n },\n addElLabel($el, label) {\n $el.attr('aria-label', label);\n return $el;\n },\n disableEl($el) {\n $el.attr('aria-disabled', true);\n return $el;\n },\n enableEl($el) {\n $el.attr('aria-disabled', false);\n return $el;\n },\n onEnterKey(e) {\n const swiper = this;\n const params = swiper.params.a11y;\n if (e.keyCode !== 13) return;\n const $targetEl = $(e.target);\n if (swiper.navigation && swiper.navigation.$nextEl && $targetEl.is(swiper.navigation.$nextEl)) {\n if (!(swiper.isEnd && !swiper.params.loop)) {\n swiper.slideNext();\n }\n if (swiper.isEnd) {\n swiper.a11y.notify(params.lastSlideMessage);\n } else {\n swiper.a11y.notify(params.nextSlideMessage);\n }\n }\n if (swiper.navigation && swiper.navigation.$prevEl && $targetEl.is(swiper.navigation.$prevEl)) {\n if (!(swiper.isBeginning && !swiper.params.loop)) {\n swiper.slidePrev();\n }\n if (swiper.isBeginning) {\n swiper.a11y.notify(params.firstSlideMessage);\n } else {\n swiper.a11y.notify(params.prevSlideMessage);\n }\n }\n if (swiper.pagination && $targetEl.is(`.${swiper.params.pagination.bulletClass}`)) {\n $targetEl[0].click();\n }\n },\n notify(message) {\n const swiper = this;\n const notification = swiper.a11y.liveRegion;\n if (notification.length === 0) return;\n notification.html('');\n notification.html(message);\n },\n updateNavigation() {\n const swiper = this;\n\n if (swiper.params.loop) return;\n const { $nextEl, $prevEl } = swiper.navigation;\n\n if ($prevEl && $prevEl.length > 0) {\n if (swiper.isBeginning) {\n swiper.a11y.disableEl($prevEl);\n } else {\n swiper.a11y.enableEl($prevEl);\n }\n }\n if ($nextEl && $nextEl.length > 0) {\n if (swiper.isEnd) {\n swiper.a11y.disableEl($nextEl);\n } else {\n swiper.a11y.enableEl($nextEl);\n }\n }\n },\n updatePagination() {\n const swiper = this;\n const params = swiper.params.a11y;\n if (swiper.pagination && swiper.params.pagination.clickable && swiper.pagination.bullets && swiper.pagination.bullets.length) {\n swiper.pagination.bullets.each((bulletIndex, bulletEl) => {\n const $bulletEl = $(bulletEl);\n swiper.a11y.makeElFocusable($bulletEl);\n swiper.a11y.addElRole($bulletEl, 'button');\n swiper.a11y.addElLabel($bulletEl, params.paginationBulletMessage.replace(/{{index}}/, $bulletEl.index() + 1));\n });\n }\n },\n init() {\n const swiper = this;\n\n swiper.$el.append(swiper.a11y.liveRegion);\n\n // Navigation\n const params = swiper.params.a11y;\n let $nextEl;\n let $prevEl;\n if (swiper.navigation && swiper.navigation.$nextEl) {\n $nextEl = swiper.navigation.$nextEl;\n }\n if (swiper.navigation && swiper.navigation.$prevEl) {\n $prevEl = swiper.navigation.$prevEl;\n }\n if ($nextEl) {\n swiper.a11y.makeElFocusable($nextEl);\n swiper.a11y.addElRole($nextEl, 'button');\n swiper.a11y.addElLabel($nextEl, params.nextSlideMessage);\n $nextEl.on('keydown', swiper.a11y.onEnterKey);\n }\n if ($prevEl) {\n swiper.a11y.makeElFocusable($prevEl);\n swiper.a11y.addElRole($prevEl, 'button');\n swiper.a11y.addElLabel($prevEl, params.prevSlideMessage);\n $prevEl.on('keydown', swiper.a11y.onEnterKey);\n }\n\n // Pagination\n if (swiper.pagination && swiper.params.pagination.clickable && swiper.pagination.bullets && swiper.pagination.bullets.length) {\n swiper.pagination.$el.on('keydown', `.${swiper.params.pagination.bulletClass}`, swiper.a11y.onEnterKey);\n }\n },\n destroy() {\n const swiper = this;\n if (swiper.a11y.liveRegion && swiper.a11y.liveRegion.length > 0) swiper.a11y.liveRegion.remove();\n\n let $nextEl;\n let $prevEl;\n if (swiper.navigation && swiper.navigation.$nextEl) {\n $nextEl = swiper.navigation.$nextEl;\n }\n if (swiper.navigation && swiper.navigation.$prevEl) {\n $prevEl = swiper.navigation.$prevEl;\n }\n if ($nextEl) {\n $nextEl.off('keydown', swiper.a11y.onEnterKey);\n }\n if ($prevEl) {\n $prevEl.off('keydown', swiper.a11y.onEnterKey);\n }\n\n // Pagination\n if (swiper.pagination && swiper.params.pagination.clickable && swiper.pagination.bullets && swiper.pagination.bullets.length) {\n swiper.pagination.$el.off('keydown', `.${swiper.params.pagination.bulletClass}`, swiper.a11y.onEnterKey);\n }\n },\n};\nvar A11y = {\n name: 'a11y',\n params: {\n a11y: {\n enabled: true,\n notificationClass: 'swiper-notification',\n prevSlideMessage: 'Previous slide',\n nextSlideMessage: 'Next slide',\n firstSlideMessage: 'This is the first slide',\n lastSlideMessage: 'This is the last slide',\n paginationBulletMessage: 'Go to slide {{index}}',\n },\n },\n create() {\n const swiper = this;\n Utils.extend(swiper, {\n a11y: {\n liveRegion: $(``),\n },\n });\n Object.keys(a11y).forEach((methodName) => {\n swiper.a11y[methodName] = a11y[methodName].bind(swiper);\n });\n },\n on: {\n init() {\n const swiper = this;\n if (!swiper.params.a11y.enabled) return;\n swiper.a11y.init();\n swiper.a11y.updateNavigation();\n },\n toEdge() {\n const swiper = this;\n if (!swiper.params.a11y.enabled) return;\n swiper.a11y.updateNavigation();\n },\n fromEdge() {\n const swiper = this;\n if (!swiper.params.a11y.enabled) return;\n swiper.a11y.updateNavigation();\n },\n paginationUpdate() {\n const swiper = this;\n if (!swiper.params.a11y.enabled) return;\n swiper.a11y.updatePagination();\n },\n destroy() {\n const swiper = this;\n if (!swiper.params.a11y.enabled) return;\n swiper.a11y.destroy();\n },\n },\n};\n\nconst History = {\n init() {\n const swiper = this;\n if (!swiper.params.history) return;\n if (!window.history || !window.history.pushState) {\n swiper.params.history.enabled = false;\n swiper.params.hashNavigation.enabled = true;\n return;\n }\n const history = swiper.history;\n history.initialized = true;\n history.paths = History.getPathValues();\n if (!history.paths.key && !history.paths.value) return;\n history.scrollToSlide(0, history.paths.value, swiper.params.runCallbacksOnInit);\n if (!swiper.params.history.replaceState) {\n window.addEventListener('popstate', swiper.history.setHistoryPopState);\n }\n },\n destroy() {\n const swiper = this;\n if (!swiper.params.history.replaceState) {\n window.removeEventListener('popstate', swiper.history.setHistoryPopState);\n }\n },\n setHistoryPopState() {\n const swiper = this;\n swiper.history.paths = History.getPathValues();\n swiper.history.scrollToSlide(swiper.params.speed, swiper.history.paths.value, false);\n },\n getPathValues() {\n const pathArray = window.location.pathname.slice(1).split('/').filter((part) => part !== '');\n const total = pathArray.length;\n const key = pathArray[total - 2];\n const value = pathArray[total - 1];\n return { key, value };\n },\n setHistory(key, index) {\n const swiper = this;\n if (!swiper.history.initialized || !swiper.params.history.enabled) return;\n const slide = swiper.slides.eq(index);\n let value = History.slugify(slide.attr('data-history'));\n if (!window.location.pathname.includes(key)) {\n value = `${key}/${value}`;\n }\n const currentState = window.history.state;\n if (currentState && currentState.value === value) {\n return;\n }\n if (swiper.params.history.replaceState) {\n window.history.replaceState({ value }, null, value);\n } else {\n window.history.pushState({ value }, null, value);\n }\n },\n slugify(text) {\n return text.toString()\n .replace(/\\s+/g, '-')\n .replace(/[^\\w-]+/g, '')\n .replace(/--+/g, '-')\n .replace(/^-+/, '')\n .replace(/-+$/, '');\n },\n scrollToSlide(speed, value, runCallbacks) {\n const swiper = this;\n if (value) {\n for (let i = 0, length = swiper.slides.length; i < length; i += 1) {\n const slide = swiper.slides.eq(i);\n const slideHistory = History.slugify(slide.attr('data-history'));\n if (slideHistory === value && !slide.hasClass(swiper.params.slideDuplicateClass)) {\n const index = slide.index();\n swiper.slideTo(index, speed, runCallbacks);\n }\n }\n } else {\n swiper.slideTo(0, speed, runCallbacks);\n }\n },\n};\n\nvar History$1 = {\n name: 'history',\n params: {\n history: {\n enabled: false,\n replaceState: false,\n key: 'slides',\n },\n },\n create() {\n const swiper = this;\n Utils.extend(swiper, {\n history: {\n init: History.init.bind(swiper),\n setHistory: History.setHistory.bind(swiper),\n setHistoryPopState: History.setHistoryPopState.bind(swiper),\n scrollToSlide: History.scrollToSlide.bind(swiper),\n destroy: History.destroy.bind(swiper),\n },\n });\n },\n on: {\n init() {\n const swiper = this;\n if (swiper.params.history.enabled) {\n swiper.history.init();\n }\n },\n destroy() {\n const swiper = this;\n if (swiper.params.history.enabled) {\n swiper.history.destroy();\n }\n },\n transitionEnd() {\n const swiper = this;\n if (swiper.history.initialized) {\n swiper.history.setHistory(swiper.params.history.key, swiper.activeIndex);\n }\n },\n },\n};\n\nconst HashNavigation = {\n onHashCange() {\n const swiper = this;\n const newHash = document.location.hash.replace('#', '');\n const activeSlideHash = swiper.slides.eq(swiper.activeIndex).attr('data-hash');\n if (newHash !== activeSlideHash) {\n const newIndex = swiper.$wrapperEl.children(`.${swiper.params.slideClass}[data-hash=\"${newHash}\"]`).index();\n if (typeof newIndex === 'undefined') return;\n swiper.slideTo(newIndex);\n }\n },\n setHash() {\n const swiper = this;\n if (!swiper.hashNavigation.initialized || !swiper.params.hashNavigation.enabled) return;\n if (swiper.params.hashNavigation.replaceState && window.history && window.history.replaceState) {\n window.history.replaceState(null, null, (`#${swiper.slides.eq(swiper.activeIndex).attr('data-hash')}` || ''));\n } else {\n const slide = swiper.slides.eq(swiper.activeIndex);\n const hash = slide.attr('data-hash') || slide.attr('data-history');\n document.location.hash = hash || '';\n }\n },\n init() {\n const swiper = this;\n if (!swiper.params.hashNavigation.enabled || (swiper.params.history && swiper.params.history.enabled)) return;\n swiper.hashNavigation.initialized = true;\n const hash = document.location.hash.replace('#', '');\n if (hash) {\n const speed = 0;\n for (let i = 0, length = swiper.slides.length; i < length; i += 1) {\n const slide = swiper.slides.eq(i);\n const slideHash = slide.attr('data-hash') || slide.attr('data-history');\n if (slideHash === hash && !slide.hasClass(swiper.params.slideDuplicateClass)) {\n const index = slide.index();\n swiper.slideTo(index, speed, swiper.params.runCallbacksOnInit, true);\n }\n }\n }\n if (swiper.params.hashNavigation.watchState) {\n $(window).on('hashchange', swiper.hashNavigation.onHashCange);\n }\n },\n destroy() {\n const swiper = this;\n if (swiper.params.hashNavigation.watchState) {\n $(window).off('hashchange', swiper.hashNavigation.onHashCange);\n }\n },\n};\nvar HashNavigation$1 = {\n name: 'hash-navigation',\n params: {\n hashNavigation: {\n enabled: false,\n replaceState: false,\n watchState: false,\n },\n },\n create() {\n const swiper = this;\n Utils.extend(swiper, {\n hashNavigation: {\n initialized: false,\n init: HashNavigation.init.bind(swiper),\n destroy: HashNavigation.destroy.bind(swiper),\n setHash: HashNavigation.setHash.bind(swiper),\n onHashCange: HashNavigation.onHashCange.bind(swiper),\n },\n });\n },\n on: {\n init() {\n const swiper = this;\n if (swiper.params.hashNavigation.enabled) {\n swiper.hashNavigation.init();\n }\n },\n destroy() {\n const swiper = this;\n if (swiper.params.hashNavigation.enabled) {\n swiper.hashNavigation.destroy();\n }\n },\n transitionEnd() {\n const swiper = this;\n if (swiper.hashNavigation.initialized) {\n swiper.hashNavigation.setHash();\n }\n },\n },\n};\n\n/* eslint no-underscore-dangle: \"off\" */\n\nconst Autoplay = {\n run() {\n const swiper = this;\n const $activeSlideEl = swiper.slides.eq(swiper.activeIndex);\n let delay = swiper.params.autoplay.delay;\n if ($activeSlideEl.attr('data-swiper-autoplay')) {\n delay = $activeSlideEl.attr('data-swiper-autoplay') || swiper.params.autoplay.delay;\n }\n clearTimeout(swiper.autoplay.timeout);\n swiper.autoplay.timeout = Utils.nextTick(() => {\n if (swiper.params.autoplay.reverseDirection) {\n if (swiper.params.loop) {\n swiper.loopFix();\n swiper.slidePrev(swiper.params.speed, true, true);\n swiper.emit('autoplay');\n } else if (!swiper.isBeginning) {\n swiper.slidePrev(swiper.params.speed, true, true);\n swiper.emit('autoplay');\n } else if (!swiper.params.autoplay.stopOnLastSlide) {\n swiper.slideTo(swiper.slides.length - 1, swiper.params.speed, true, true);\n swiper.emit('autoplay');\n } else {\n swiper.autoplay.stop();\n }\n } else if (swiper.params.loop) {\n swiper.loopFix();\n swiper.slideNext(swiper.params.speed, true, true);\n swiper.emit('autoplay');\n } else if (!swiper.isEnd) {\n swiper.slideNext(swiper.params.speed, true, true);\n swiper.emit('autoplay');\n } else if (!swiper.params.autoplay.stopOnLastSlide) {\n swiper.slideTo(0, swiper.params.speed, true, true);\n swiper.emit('autoplay');\n } else {\n swiper.autoplay.stop();\n }\n }, delay);\n },\n start() {\n const swiper = this;\n if (typeof swiper.autoplay.timeout !== 'undefined') return false;\n if (swiper.autoplay.running) return false;\n swiper.autoplay.running = true;\n swiper.emit('autoplayStart');\n swiper.autoplay.run();\n return true;\n },\n stop() {\n const swiper = this;\n if (!swiper.autoplay.running) return false;\n if (typeof swiper.autoplay.timeout === 'undefined') return false;\n\n if (swiper.autoplay.timeout) {\n clearTimeout(swiper.autoplay.timeout);\n swiper.autoplay.timeout = undefined;\n }\n swiper.autoplay.running = false;\n swiper.emit('autoplayStop');\n return true;\n },\n pause(speed) {\n const swiper = this;\n if (!swiper.autoplay.running) return;\n if (swiper.autoplay.paused) return;\n if (swiper.autoplay.timeout) clearTimeout(swiper.autoplay.timeout);\n swiper.autoplay.paused = true;\n if (speed === 0 || !swiper.params.autoplay.waitForTransition) {\n swiper.autoplay.paused = false;\n swiper.autoplay.run();\n } else {\n swiper.$wrapperEl[0].addEventListener('transitionend', swiper.autoplay.onTransitionEnd);\n swiper.$wrapperEl[0].addEventListener('webkitTransitionEnd', swiper.autoplay.onTransitionEnd);\n }\n },\n};\n\nvar Autoplay$1 = {\n name: 'autoplay',\n params: {\n autoplay: {\n enabled: false,\n delay: 3000,\n waitForTransition: true,\n disableOnInteraction: true,\n stopOnLastSlide: false,\n reverseDirection: false,\n },\n },\n create() {\n const swiper = this;\n Utils.extend(swiper, {\n autoplay: {\n running: false,\n paused: false,\n run: Autoplay.run.bind(swiper),\n start: Autoplay.start.bind(swiper),\n stop: Autoplay.stop.bind(swiper),\n pause: Autoplay.pause.bind(swiper),\n onTransitionEnd(e) {\n if (!swiper || swiper.destroyed || !swiper.$wrapperEl) return;\n if (e.target !== this) return;\n swiper.$wrapperEl[0].removeEventListener('transitionend', swiper.autoplay.onTransitionEnd);\n swiper.$wrapperEl[0].removeEventListener('webkitTransitionEnd', swiper.autoplay.onTransitionEnd);\n swiper.autoplay.paused = false;\n if (!swiper.autoplay.running) {\n swiper.autoplay.stop();\n } else {\n swiper.autoplay.run();\n }\n },\n },\n });\n },\n on: {\n init() {\n const swiper = this;\n if (swiper.params.autoplay.enabled) {\n swiper.autoplay.start();\n }\n },\n beforeTransitionStart(speed, internal) {\n const swiper = this;\n if (swiper.autoplay.running) {\n if (internal || !swiper.params.autoplay.disableOnInteraction) {\n swiper.autoplay.pause(speed);\n } else {\n swiper.autoplay.stop();\n }\n }\n },\n sliderFirstMove() {\n const swiper = this;\n if (swiper.autoplay.running) {\n if (swiper.params.autoplay.disableOnInteraction) {\n swiper.autoplay.stop();\n } else {\n swiper.autoplay.pause();\n }\n }\n },\n destroy() {\n const swiper = this;\n if (swiper.autoplay.running) {\n swiper.autoplay.stop();\n }\n },\n },\n};\n\nconst Fade = {\n setTranslate() {\n const swiper = this;\n const { slides } = swiper;\n for (let i = 0; i < slides.length; i += 1) {\n const $slideEl = swiper.slides.eq(i);\n const offset = $slideEl[0].swiperSlideOffset;\n let tx = -offset;\n if (!swiper.params.virtualTranslate) tx -= swiper.translate;\n let ty = 0;\n if (!swiper.isHorizontal()) {\n ty = tx;\n tx = 0;\n }\n const slideOpacity = swiper.params.fadeEffect.crossFade\n ? Math.max(1 - Math.abs($slideEl[0].progress), 0)\n : 1 + Math.min(Math.max($slideEl[0].progress, -1), 0);\n $slideEl\n .css({\n opacity: slideOpacity,\n })\n .transform(`translate3d(${tx}px, ${ty}px, 0px)`);\n }\n },\n setTransition(duration) {\n const swiper = this;\n const { slides, $wrapperEl } = swiper;\n slides.transition(duration);\n if (swiper.params.virtualTranslate && duration !== 0) {\n let eventTriggered = false;\n slides.transitionEnd(() => {\n if (eventTriggered) return;\n if (!swiper || swiper.destroyed) return;\n eventTriggered = true;\n swiper.animating = false;\n const triggerEvents = ['webkitTransitionEnd', 'transitionend'];\n for (let i = 0; i < triggerEvents.length; i += 1) {\n $wrapperEl.trigger(triggerEvents[i]);\n }\n });\n }\n },\n};\n\nvar EffectFade = {\n name: 'effect-fade',\n params: {\n fadeEffect: {\n crossFade: false,\n },\n },\n create() {\n const swiper = this;\n Utils.extend(swiper, {\n fadeEffect: {\n setTranslate: Fade.setTranslate.bind(swiper),\n setTransition: Fade.setTransition.bind(swiper),\n },\n });\n },\n on: {\n beforeInit() {\n const swiper = this;\n if (swiper.params.effect !== 'fade') return;\n swiper.classNames.push(`${swiper.params.containerModifierClass}fade`);\n const overwriteParams = {\n slidesPerView: 1,\n slidesPerColumn: 1,\n slidesPerGroup: 1,\n watchSlidesProgress: true,\n spaceBetween: 0,\n virtualTranslate: true,\n };\n Utils.extend(swiper.params, overwriteParams);\n Utils.extend(swiper.originalParams, overwriteParams);\n },\n setTranslate() {\n const swiper = this;\n if (swiper.params.effect !== 'fade') return;\n swiper.fadeEffect.setTranslate();\n },\n setTransition(duration) {\n const swiper = this;\n if (swiper.params.effect !== 'fade') return;\n swiper.fadeEffect.setTransition(duration);\n },\n },\n};\n\nconst Cube = {\n setTranslate() {\n const swiper = this;\n const {\n $el, $wrapperEl, slides, width: swiperWidth, height: swiperHeight, rtlTranslate: rtl, size: swiperSize,\n } = swiper;\n const params = swiper.params.cubeEffect;\n const isHorizontal = swiper.isHorizontal();\n const isVirtual = swiper.virtual && swiper.params.virtual.enabled;\n let wrapperRotate = 0;\n let $cubeShadowEl;\n if (params.shadow) {\n if (isHorizontal) {\n $cubeShadowEl = $wrapperEl.find('.swiper-cube-shadow');\n if ($cubeShadowEl.length === 0) {\n $cubeShadowEl = $('
');\n $wrapperEl.append($cubeShadowEl);\n }\n $cubeShadowEl.css({ height: `${swiperWidth}px` });\n } else {\n $cubeShadowEl = $el.find('.swiper-cube-shadow');\n if ($cubeShadowEl.length === 0) {\n $cubeShadowEl = $('
');\n $el.append($cubeShadowEl);\n }\n }\n }\n for (let i = 0; i < slides.length; i += 1) {\n const $slideEl = slides.eq(i);\n let slideIndex = i;\n if (isVirtual) {\n slideIndex = parseInt($slideEl.attr('data-swiper-slide-index'), 10);\n }\n let slideAngle = slideIndex * 90;\n let round = Math.floor(slideAngle / 360);\n if (rtl) {\n slideAngle = -slideAngle;\n round = Math.floor(-slideAngle / 360);\n }\n const progress = Math.max(Math.min($slideEl[0].progress, 1), -1);\n let tx = 0;\n let ty = 0;\n let tz = 0;\n if (slideIndex % 4 === 0) {\n tx = -round * 4 * swiperSize;\n tz = 0;\n } else if ((slideIndex - 1) % 4 === 0) {\n tx = 0;\n tz = -round * 4 * swiperSize;\n } else if ((slideIndex - 2) % 4 === 0) {\n tx = swiperSize + (round * 4 * swiperSize);\n tz = swiperSize;\n } else if ((slideIndex - 3) % 4 === 0) {\n tx = -swiperSize;\n tz = (3 * swiperSize) + (swiperSize * 4 * round);\n }\n if (rtl) {\n tx = -tx;\n }\n\n if (!isHorizontal) {\n ty = tx;\n tx = 0;\n }\n\n const transform = `rotateX(${isHorizontal ? 0 : -slideAngle}deg) rotateY(${isHorizontal ? slideAngle : 0}deg) translate3d(${tx}px, ${ty}px, ${tz}px)`;\n if (progress <= 1 && progress > -1) {\n wrapperRotate = (slideIndex * 90) + (progress * 90);\n if (rtl) wrapperRotate = (-slideIndex * 90) - (progress * 90);\n }\n $slideEl.transform(transform);\n if (params.slideShadows) {\n // Set shadows\n let shadowBefore = isHorizontal ? $slideEl.find('.swiper-slide-shadow-left') : $slideEl.find('.swiper-slide-shadow-top');\n let shadowAfter = isHorizontal ? $slideEl.find('.swiper-slide-shadow-right') : $slideEl.find('.swiper-slide-shadow-bottom');\n if (shadowBefore.length === 0) {\n shadowBefore = $(`
`);\n $slideEl.append(shadowBefore);\n }\n if (shadowAfter.length === 0) {\n shadowAfter = $(`
`);\n $slideEl.append(shadowAfter);\n }\n if (shadowBefore.length) shadowBefore[0].style.opacity = Math.max(-progress, 0);\n if (shadowAfter.length) shadowAfter[0].style.opacity = Math.max(progress, 0);\n }\n }\n $wrapperEl.css({\n '-webkit-transform-origin': `50% 50% -${swiperSize / 2}px`,\n '-moz-transform-origin': `50% 50% -${swiperSize / 2}px`,\n '-ms-transform-origin': `50% 50% -${swiperSize / 2}px`,\n 'transform-origin': `50% 50% -${swiperSize / 2}px`,\n });\n\n if (params.shadow) {\n if (isHorizontal) {\n $cubeShadowEl.transform(`translate3d(0px, ${(swiperWidth / 2) + params.shadowOffset}px, ${-swiperWidth / 2}px) rotateX(90deg) rotateZ(0deg) scale(${params.shadowScale})`);\n } else {\n const shadowAngle = Math.abs(wrapperRotate) - (Math.floor(Math.abs(wrapperRotate) / 90) * 90);\n const multiplier = 1.5 - (\n (Math.sin((shadowAngle * 2 * Math.PI) / 360) / 2)\n + (Math.cos((shadowAngle * 2 * Math.PI) / 360) / 2)\n );\n const scale1 = params.shadowScale;\n const scale2 = params.shadowScale / multiplier;\n const offset = params.shadowOffset;\n $cubeShadowEl.transform(`scale3d(${scale1}, 1, ${scale2}) translate3d(0px, ${(swiperHeight / 2) + offset}px, ${-swiperHeight / 2 / scale2}px) rotateX(-90deg)`);\n }\n }\n const zFactor = (Browser.isSafari || Browser.isUiWebView) ? (-swiperSize / 2) : 0;\n $wrapperEl\n .transform(`translate3d(0px,0,${zFactor}px) rotateX(${swiper.isHorizontal() ? 0 : wrapperRotate}deg) rotateY(${swiper.isHorizontal() ? -wrapperRotate : 0}deg)`);\n },\n setTransition(duration) {\n const swiper = this;\n const { $el, slides } = swiper;\n slides\n .transition(duration)\n .find('.swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left')\n .transition(duration);\n if (swiper.params.cubeEffect.shadow && !swiper.isHorizontal()) {\n $el.find('.swiper-cube-shadow').transition(duration);\n }\n },\n};\n\nvar EffectCube = {\n name: 'effect-cube',\n params: {\n cubeEffect: {\n slideShadows: true,\n shadow: true,\n shadowOffset: 20,\n shadowScale: 0.94,\n },\n },\n create() {\n const swiper = this;\n Utils.extend(swiper, {\n cubeEffect: {\n setTranslate: Cube.setTranslate.bind(swiper),\n setTransition: Cube.setTransition.bind(swiper),\n },\n });\n },\n on: {\n beforeInit() {\n const swiper = this;\n if (swiper.params.effect !== 'cube') return;\n swiper.classNames.push(`${swiper.params.containerModifierClass}cube`);\n swiper.classNames.push(`${swiper.params.containerModifierClass}3d`);\n const overwriteParams = {\n slidesPerView: 1,\n slidesPerColumn: 1,\n slidesPerGroup: 1,\n watchSlidesProgress: true,\n resistanceRatio: 0,\n spaceBetween: 0,\n centeredSlides: false,\n virtualTranslate: true,\n };\n Utils.extend(swiper.params, overwriteParams);\n Utils.extend(swiper.originalParams, overwriteParams);\n },\n setTranslate() {\n const swiper = this;\n if (swiper.params.effect !== 'cube') return;\n swiper.cubeEffect.setTranslate();\n },\n setTransition(duration) {\n const swiper = this;\n if (swiper.params.effect !== 'cube') return;\n swiper.cubeEffect.setTransition(duration);\n },\n },\n};\n\nconst Flip = {\n setTranslate() {\n const swiper = this;\n const { slides, rtlTranslate: rtl } = swiper;\n for (let i = 0; i < slides.length; i += 1) {\n const $slideEl = slides.eq(i);\n let progress = $slideEl[0].progress;\n if (swiper.params.flipEffect.limitRotation) {\n progress = Math.max(Math.min($slideEl[0].progress, 1), -1);\n }\n const offset = $slideEl[0].swiperSlideOffset;\n const rotate = -180 * progress;\n let rotateY = rotate;\n let rotateX = 0;\n let tx = -offset;\n let ty = 0;\n if (!swiper.isHorizontal()) {\n ty = tx;\n tx = 0;\n rotateX = -rotateY;\n rotateY = 0;\n } else if (rtl) {\n rotateY = -rotateY;\n }\n\n $slideEl[0].style.zIndex = -Math.abs(Math.round(progress)) + slides.length;\n\n if (swiper.params.flipEffect.slideShadows) {\n // Set shadows\n let shadowBefore = swiper.isHorizontal() ? $slideEl.find('.swiper-slide-shadow-left') : $slideEl.find('.swiper-slide-shadow-top');\n let shadowAfter = swiper.isHorizontal() ? $slideEl.find('.swiper-slide-shadow-right') : $slideEl.find('.swiper-slide-shadow-bottom');\n if (shadowBefore.length === 0) {\n shadowBefore = $(`
`);\n $slideEl.append(shadowBefore);\n }\n if (shadowAfter.length === 0) {\n shadowAfter = $(`
`);\n $slideEl.append(shadowAfter);\n }\n if (shadowBefore.length) shadowBefore[0].style.opacity = Math.max(-progress, 0);\n if (shadowAfter.length) shadowAfter[0].style.opacity = Math.max(progress, 0);\n }\n $slideEl\n .transform(`translate3d(${tx}px, ${ty}px, 0px) rotateX(${rotateX}deg) rotateY(${rotateY}deg)`);\n }\n },\n setTransition(duration) {\n const swiper = this;\n const { slides, activeIndex, $wrapperEl } = swiper;\n slides\n .transition(duration)\n .find('.swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left')\n .transition(duration);\n if (swiper.params.virtualTranslate && duration !== 0) {\n let eventTriggered = false;\n // eslint-disable-next-line\n slides.eq(activeIndex).transitionEnd(function onTransitionEnd() {\n if (eventTriggered) return;\n if (!swiper || swiper.destroyed) return;\n // if (!$(this).hasClass(swiper.params.slideActiveClass)) return;\n eventTriggered = true;\n swiper.animating = false;\n const triggerEvents = ['webkitTransitionEnd', 'transitionend'];\n for (let i = 0; i < triggerEvents.length; i += 1) {\n $wrapperEl.trigger(triggerEvents[i]);\n }\n });\n }\n },\n};\n\nvar EffectFlip = {\n name: 'effect-flip',\n params: {\n flipEffect: {\n slideShadows: true,\n limitRotation: true,\n },\n },\n create() {\n const swiper = this;\n Utils.extend(swiper, {\n flipEffect: {\n setTranslate: Flip.setTranslate.bind(swiper),\n setTransition: Flip.setTransition.bind(swiper),\n },\n });\n },\n on: {\n beforeInit() {\n const swiper = this;\n if (swiper.params.effect !== 'flip') return;\n swiper.classNames.push(`${swiper.params.containerModifierClass}flip`);\n swiper.classNames.push(`${swiper.params.containerModifierClass}3d`);\n const overwriteParams = {\n slidesPerView: 1,\n slidesPerColumn: 1,\n slidesPerGroup: 1,\n watchSlidesProgress: true,\n spaceBetween: 0,\n virtualTranslate: true,\n };\n Utils.extend(swiper.params, overwriteParams);\n Utils.extend(swiper.originalParams, overwriteParams);\n },\n setTranslate() {\n const swiper = this;\n if (swiper.params.effect !== 'flip') return;\n swiper.flipEffect.setTranslate();\n },\n setTransition(duration) {\n const swiper = this;\n if (swiper.params.effect !== 'flip') return;\n swiper.flipEffect.setTransition(duration);\n },\n },\n};\n\nconst Coverflow = {\n setTranslate() {\n const swiper = this;\n const {\n width: swiperWidth, height: swiperHeight, slides, $wrapperEl, slidesSizesGrid,\n } = swiper;\n const params = swiper.params.coverflowEffect;\n const isHorizontal = swiper.isHorizontal();\n const transform = swiper.translate;\n const center = isHorizontal ? -transform + (swiperWidth / 2) : -transform + (swiperHeight / 2);\n const rotate = isHorizontal ? params.rotate : -params.rotate;\n const translate = params.depth;\n // Each slide offset from center\n for (let i = 0, length = slides.length; i < length; i += 1) {\n const $slideEl = slides.eq(i);\n const slideSize = slidesSizesGrid[i];\n const slideOffset = $slideEl[0].swiperSlideOffset;\n const offsetMultiplier = ((center - slideOffset - (slideSize / 2)) / slideSize) * params.modifier;\n\n let rotateY = isHorizontal ? rotate * offsetMultiplier : 0;\n let rotateX = isHorizontal ? 0 : rotate * offsetMultiplier;\n // var rotateZ = 0\n let translateZ = -translate * Math.abs(offsetMultiplier);\n\n let translateY = isHorizontal ? 0 : params.stretch * (offsetMultiplier);\n let translateX = isHorizontal ? params.stretch * (offsetMultiplier) : 0;\n\n // Fix for ultra small values\n if (Math.abs(translateX) < 0.001) translateX = 0;\n if (Math.abs(translateY) < 0.001) translateY = 0;\n if (Math.abs(translateZ) < 0.001) translateZ = 0;\n if (Math.abs(rotateY) < 0.001) rotateY = 0;\n if (Math.abs(rotateX) < 0.001) rotateX = 0;\n\n const slideTransform = `translate3d(${translateX}px,${translateY}px,${translateZ}px) rotateX(${rotateX}deg) rotateY(${rotateY}deg)`;\n\n $slideEl.transform(slideTransform);\n $slideEl[0].style.zIndex = -Math.abs(Math.round(offsetMultiplier)) + 1;\n if (params.slideShadows) {\n // Set shadows\n let $shadowBeforeEl = isHorizontal ? $slideEl.find('.swiper-slide-shadow-left') : $slideEl.find('.swiper-slide-shadow-top');\n let $shadowAfterEl = isHorizontal ? $slideEl.find('.swiper-slide-shadow-right') : $slideEl.find('.swiper-slide-shadow-bottom');\n if ($shadowBeforeEl.length === 0) {\n $shadowBeforeEl = $(`
`);\n $slideEl.append($shadowBeforeEl);\n }\n if ($shadowAfterEl.length === 0) {\n $shadowAfterEl = $(`
`);\n $slideEl.append($shadowAfterEl);\n }\n if ($shadowBeforeEl.length) $shadowBeforeEl[0].style.opacity = offsetMultiplier > 0 ? offsetMultiplier : 0;\n if ($shadowAfterEl.length) $shadowAfterEl[0].style.opacity = (-offsetMultiplier) > 0 ? -offsetMultiplier : 0;\n }\n }\n\n // Set correct perspective for IE10\n if (Support.pointerEvents || Support.prefixedPointerEvents) {\n const ws = $wrapperEl[0].style;\n ws.perspectiveOrigin = `${center}px 50%`;\n }\n },\n setTransition(duration) {\n const swiper = this;\n swiper.slides\n .transition(duration)\n .find('.swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left')\n .transition(duration);\n },\n};\n\nvar EffectCoverflow = {\n name: 'effect-coverflow',\n params: {\n coverflowEffect: {\n rotate: 50,\n stretch: 0,\n depth: 100,\n modifier: 1,\n slideShadows: true,\n },\n },\n create() {\n const swiper = this;\n Utils.extend(swiper, {\n coverflowEffect: {\n setTranslate: Coverflow.setTranslate.bind(swiper),\n setTransition: Coverflow.setTransition.bind(swiper),\n },\n });\n },\n on: {\n beforeInit() {\n const swiper = this;\n if (swiper.params.effect !== 'coverflow') return;\n\n swiper.classNames.push(`${swiper.params.containerModifierClass}coverflow`);\n swiper.classNames.push(`${swiper.params.containerModifierClass}3d`);\n\n swiper.params.watchSlidesProgress = true;\n swiper.originalParams.watchSlidesProgress = true;\n },\n setTranslate() {\n const swiper = this;\n if (swiper.params.effect !== 'coverflow') return;\n swiper.coverflowEffect.setTranslate();\n },\n setTransition(duration) {\n const swiper = this;\n if (swiper.params.effect !== 'coverflow') return;\n swiper.coverflowEffect.setTransition(duration);\n },\n },\n};\n\nconst Thumbs = {\n init() {\n const swiper = this;\n const { thumbs: thumbsParams } = swiper.params;\n const SwiperClass = swiper.constructor;\n if (thumbsParams.swiper instanceof SwiperClass) {\n swiper.thumbs.swiper = thumbsParams.swiper;\n Utils.extend(swiper.thumbs.swiper.originalParams, {\n watchSlidesProgress: true,\n slideToClickedSlide: false,\n });\n Utils.extend(swiper.thumbs.swiper.params, {\n watchSlidesProgress: true,\n slideToClickedSlide: false,\n });\n } else if (Utils.isObject(thumbsParams.swiper)) {\n swiper.thumbs.swiper = new SwiperClass(Utils.extend({}, thumbsParams.swiper, {\n watchSlidesVisibility: true,\n watchSlidesProgress: true,\n slideToClickedSlide: false,\n }));\n swiper.thumbs.swiperCreated = true;\n }\n swiper.thumbs.swiper.$el.addClass(swiper.params.thumbs.thumbsContainerClass);\n swiper.thumbs.swiper.on('tap', swiper.thumbs.onThumbClick);\n },\n onThumbClick() {\n const swiper = this;\n const thumbsSwiper = swiper.thumbs.swiper;\n if (!thumbsSwiper) return;\n const clickedIndex = thumbsSwiper.clickedIndex;\n const clickedSlide = thumbsSwiper.clickedSlide;\n if (clickedSlide && $(clickedSlide).hasClass(swiper.params.thumbs.slideThumbActiveClass)) return;\n if (typeof clickedIndex === 'undefined' || clickedIndex === null) return;\n let slideToIndex;\n if (thumbsSwiper.params.loop) {\n slideToIndex = parseInt($(thumbsSwiper.clickedSlide).attr('data-swiper-slide-index'), 10);\n } else {\n slideToIndex = clickedIndex;\n }\n if (swiper.params.loop) {\n let currentIndex = swiper.activeIndex;\n if (swiper.slides.eq(currentIndex).hasClass(swiper.params.slideDuplicateClass)) {\n swiper.loopFix();\n // eslint-disable-next-line\n swiper._clientLeft = swiper.$wrapperEl[0].clientLeft;\n currentIndex = swiper.activeIndex;\n }\n const prevIndex = swiper.slides.eq(currentIndex).prevAll(`[data-swiper-slide-index=\"${slideToIndex}\"]`).eq(0).index();\n const nextIndex = swiper.slides.eq(currentIndex).nextAll(`[data-swiper-slide-index=\"${slideToIndex}\"]`).eq(0).index();\n if (typeof prevIndex === 'undefined') slideToIndex = nextIndex;\n else if (typeof nextIndex === 'undefined') slideToIndex = prevIndex;\n else if (nextIndex - currentIndex < currentIndex - prevIndex) slideToIndex = nextIndex;\n else slideToIndex = prevIndex;\n }\n swiper.slideTo(slideToIndex);\n },\n update(initial) {\n const swiper = this;\n const thumbsSwiper = swiper.thumbs.swiper;\n if (!thumbsSwiper) return;\n\n const slidesPerView = thumbsSwiper.params.slidesPerView === 'auto'\n ? thumbsSwiper.slidesPerViewDynamic()\n : thumbsSwiper.params.slidesPerView;\n\n if (swiper.realIndex !== thumbsSwiper.realIndex) {\n let currentThumbsIndex = thumbsSwiper.activeIndex;\n let newThumbsIndex;\n if (thumbsSwiper.params.loop) {\n if (thumbsSwiper.slides.eq(currentThumbsIndex).hasClass(thumbsSwiper.params.slideDuplicateClass)) {\n thumbsSwiper.loopFix();\n // eslint-disable-next-line\n thumbsSwiper._clientLeft = thumbsSwiper.$wrapperEl[0].clientLeft;\n currentThumbsIndex = thumbsSwiper.activeIndex;\n }\n // Find actual thumbs index to slide to\n const prevThumbsIndex = thumbsSwiper.slides.eq(currentThumbsIndex).prevAll(`[data-swiper-slide-index=\"${swiper.realIndex}\"]`).eq(0).index();\n const nextThumbsIndex = thumbsSwiper.slides.eq(currentThumbsIndex).nextAll(`[data-swiper-slide-index=\"${swiper.realIndex}\"]`).eq(0).index();\n if (typeof prevThumbsIndex === 'undefined') newThumbsIndex = nextThumbsIndex;\n else if (typeof nextThumbsIndex === 'undefined') newThumbsIndex = prevThumbsIndex;\n else if (nextThumbsIndex - currentThumbsIndex === currentThumbsIndex - prevThumbsIndex) newThumbsIndex = currentThumbsIndex;\n else if (nextThumbsIndex - currentThumbsIndex < currentThumbsIndex - prevThumbsIndex) newThumbsIndex = nextThumbsIndex;\n else newThumbsIndex = prevThumbsIndex;\n } else {\n newThumbsIndex = swiper.realIndex;\n }\n if (thumbsSwiper.visibleSlidesIndexes && thumbsSwiper.visibleSlidesIndexes.indexOf(newThumbsIndex) < 0) {\n if (thumbsSwiper.params.centeredSlides) {\n if (newThumbsIndex > currentThumbsIndex) {\n newThumbsIndex = newThumbsIndex - Math.floor(slidesPerView / 2) + 1;\n } else {\n newThumbsIndex = newThumbsIndex + Math.floor(slidesPerView / 2) - 1;\n }\n } else if (newThumbsIndex > currentThumbsIndex) {\n newThumbsIndex = newThumbsIndex - slidesPerView + 1;\n }\n thumbsSwiper.slideTo(newThumbsIndex, initial ? 0 : undefined);\n }\n }\n\n // Activate thumbs\n let thumbsToActivate = 1;\n const thumbActiveClass = swiper.params.thumbs.slideThumbActiveClass;\n\n if (swiper.params.slidesPerView > 1 && !swiper.params.centeredSlides) {\n thumbsToActivate = swiper.params.slidesPerView;\n }\n\n thumbsSwiper.slides.removeClass(thumbActiveClass);\n if (thumbsSwiper.params.loop || thumbsSwiper.params.virtual) {\n for (let i = 0; i < thumbsToActivate; i += 1) {\n thumbsSwiper.$wrapperEl.children(`[data-swiper-slide-index=\"${swiper.realIndex + i}\"]`).addClass(thumbActiveClass);\n }\n } else {\n for (let i = 0; i < thumbsToActivate; i += 1) {\n thumbsSwiper.slides.eq(swiper.realIndex + i).addClass(thumbActiveClass);\n }\n }\n },\n};\nvar Thumbs$1 = {\n name: 'thumbs',\n params: {\n thumbs: {\n swiper: null,\n slideThumbActiveClass: 'swiper-slide-thumb-active',\n thumbsContainerClass: 'swiper-container-thumbs',\n },\n },\n create() {\n const swiper = this;\n Utils.extend(swiper, {\n thumbs: {\n swiper: null,\n init: Thumbs.init.bind(swiper),\n update: Thumbs.update.bind(swiper),\n onThumbClick: Thumbs.onThumbClick.bind(swiper),\n },\n });\n },\n on: {\n beforeInit() {\n const swiper = this;\n const { thumbs } = swiper.params;\n if (!thumbs || !thumbs.swiper) return;\n swiper.thumbs.init();\n swiper.thumbs.update(true);\n },\n slideChange() {\n const swiper = this;\n if (!swiper.thumbs.swiper) return;\n swiper.thumbs.update();\n },\n update() {\n const swiper = this;\n if (!swiper.thumbs.swiper) return;\n swiper.thumbs.update();\n },\n resize() {\n const swiper = this;\n if (!swiper.thumbs.swiper) return;\n swiper.thumbs.update();\n },\n observerUpdate() {\n const swiper = this;\n if (!swiper.thumbs.swiper) return;\n swiper.thumbs.update();\n },\n setTransition(duration) {\n const swiper = this;\n const thumbsSwiper = swiper.thumbs.swiper;\n if (!thumbsSwiper) return;\n thumbsSwiper.setTransition(duration);\n },\n beforeDestroy() {\n const swiper = this;\n const thumbsSwiper = swiper.thumbs.swiper;\n if (!thumbsSwiper) return;\n if (swiper.thumbs.swiperCreated && thumbsSwiper) {\n thumbsSwiper.destroy();\n }\n },\n },\n};\n\n// Swiper Class\n\nconst components = [\n Device$1,\n Support$1,\n Browser$1,\n Resize,\n Observer$1,\n Virtual$1,\n Keyboard$1,\n Mousewheel$1,\n Navigation$1,\n Pagination$1,\n Scrollbar$1,\n Parallax$1,\n Zoom$1,\n Lazy$1,\n Controller$1,\n A11y,\n History$1,\n HashNavigation$1,\n Autoplay$1,\n EffectFade,\n EffectCube,\n EffectFlip,\n EffectCoverflow,\n Thumbs$1\n];\n\nif (typeof Swiper.use === 'undefined') {\n Swiper.use = Swiper.Class.use;\n Swiper.installModule = Swiper.Class.installModule;\n}\n\nSwiper.use(components);\n\nexport default Swiper;\n","export function nodeListToArray(nodeList: NodeList) {\r\n return Array.prototype.slice.call(nodeList);\r\n}","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","import { multiCarousel } from '../../modules/multi-carousel';\r\nimport { nodeListToArray } from '../../helpers/nodeListToArray';\r\nimport { SimpleVideoControls } from '../../modules/simple-video-controls';\r\n\r\n(function () {\r\n // Gallery Init\r\n let gallery = document.querySelector('[data-homepage-carousel-container]') as HTMLElement;\r\n new multiCarousel(gallery);\r\n})();\r\n\r\n\r\n","import Swiper from 'swiper';\r\nimport { nodeListToArray } from '../helpers/nodeListToArray';\r\nimport * as YouTubeIframeLoader from 'youtube-iframe';\r\nimport { debounce } from 'lodash';\r\n\r\n\r\nexport class multiCarousel {\r\n activeSlides: any[];\r\n inactiveSlides: any[];\r\n previousSlide: any;\r\n activeIndex: any;\r\n slides: any;\r\n previousIndex: number; // swiper's previousIndex implementation doesn't work with loop: true so we need to do it manually\r\n videos: any;\r\n autoPauseVideos: boolean;\r\n activeSlideCount: number;\r\n totalSlideCount: number;\r\n videoControlButtons: any[];\r\n secondaryCarousel: HTMLElement;\r\n primaryCarousel: HTMLElement;\r\n primarySlider: any;\r\n secondarySlider: any;\r\n carouselContainer: HTMLElement;\r\n\r\n\r\n constructor(homepageCarouselContainer: HTMLElement) {\r\n this.secondaryCarousel = homepageCarouselContainer.querySelector('[data-homepage-secondary-carousel]') as HTMLElement;\r\n this.primaryCarousel = homepageCarouselContainer.querySelector('[data-homepage-primary-carousel') as HTMLElement;\r\n this.init();\r\n }\r\n\r\n\r\n init() {\r\n this.secondarySlider = new Swiper(this.secondaryCarousel, {\r\n containerClass: 'callout-carousel-container',\r\n slidesPerView: 1,\r\n spaceBetween: 0,\r\n navigation: {\r\n nextEl: \".swiper-btn-next\",\r\n prevEl: \".swiper-btn-prev\",\r\n },\r\n pagination: {\r\n el: '.swiper-pagination',\r\n type: 'bullets',\r\n clickable: true,\r\n },\r\n effect: 'fade',\r\n fadeEffect: {\r\n crossFade: true\r\n },\r\n autoHeight: true,\r\n loop: true,\r\n autoplayVideo: true,\r\n autoPauseVideos: true,\r\n simulateTouch: false,\r\n preventClicks: true,\r\n allowTouchMove: false,\r\n speed: 500\r\n })\r\n\r\n this.primarySlider = new Swiper(this.primaryCarousel, {\r\n containerClass: 'callout-carousel-container',\r\n slidesPerView: 1,\r\n spaceBetween: 0,\r\n navigation: {\r\n nextEl: \".swiper-btn-next\",\r\n prevEl: \".swiper-btn-prev\",\r\n },\r\n pagination: {\r\n el: '.swiper-pagination',\r\n type: 'bullets',\r\n clickable: true,\r\n },\r\n autoHeight: false,\r\n loop: true,\r\n autoplayVideo: true,\r\n autoPauseVideos: true,\r\n simulateTouch: true,\r\n preventClicks: false,\r\n allowTouchMove: true,\r\n on: {\r\n slideChangeTransitionEnd: this.handleSlide.bind(this),\r\n },\r\n });\r\n\r\n this.videos = {};\r\n this.initCallback(this.primarySlider);\r\n this.initVisibleVideos;\r\n\r\n this.videoControlButtons = nodeListToArray(document.querySelectorAll('[data-controls-video]'));\r\n if (this.videoControlButtons) {\r\n this.setupVideoButtonsEventListener();\r\n }\r\n this.primarySlider.controller.control = this.secondarySlider;\r\n }\r\n\r\n initCallback(slider) {\r\n this.activeIndex = this.primarySlider.activeIndex;\r\n this.totalSlideCount = this.primarySlider.slides.length;\r\n this.primarySlider.updateSlides();\r\n this.setActiveSlides();\r\n this.slides = this.primarySlider.slides;\r\n\r\n if (window.matchMedia('(min-width: 640px)')) {\r\n this.initVisibleVideos();\r\n }\r\n\r\n window.addEventListener(\r\n 'resize',\r\n debounce(() => {\r\n if (window.matchMedia('(min-width: 640px)')) {\r\n this.initVisibleVideos();\r\n }\r\n }))\r\n\r\n }\r\n\r\n\r\n handleSlide() {\r\n if (this.primarySlider) {\r\n\r\n\r\n this.previousIndex = this.activeIndex;\r\n this.previousSlide = this.primarySlider.slides[this.previousIndex];\r\n this.activeIndex = this.primarySlider.activeIndex;\r\n this.setActiveSlides();\r\n this.initVisibleVideos();\r\n if (this.autoPauseVideos) {\r\n this.pauseInactiveVideos();\r\n }\r\n }\r\n\r\n }\r\n\r\n setActiveSlides() {\r\n this.activeSlideCount = this.primarySlider.originalParams.slidesPerView as number;\r\n this.activeSlides = [];\r\n this.inactiveSlides = [];\r\n const lastIndex = (this.activeIndex + this.activeSlideCount - 1) % (this.totalSlideCount - 1);\r\n for (let i = 0; i < this.primarySlider.slides.length; i++) {\r\n const slide = this.primarySlider.slides[i];\r\n const inRange = lastIndex < this.activeIndex ?\r\n i >= this.activeIndex || i < lastIndex\r\n : i >= this.activeIndex && i <= lastIndex;\r\n if (inRange) {\r\n this.activeSlides.push({ slide: slide, index: i });\r\n this.enableSlide(slide);\r\n }\r\n else {\r\n this.inactiveSlides.push({ slide: slide, index: i });\r\n this.disableSlide(slide);\r\n }\r\n }\r\n }\r\n\r\n\r\n initVisibleVideos() {\r\n this.activeSlides.forEach(slideInfo => {\r\n const slide = slideInfo.slide;\r\n const activeSlideVideo = slide.querySelector('[data-video-type]');\r\n if (activeSlideVideo) {\r\n const videoType = activeSlideVideo.getAttribute('data-video-type');\r\n if (videoType == 'youtube') {\r\n this.youtubeInit(slide, slideInfo.index);\r\n }\r\n else {\r\n this.nativeVideoInit(slide, slideInfo.index);\r\n }\r\n }\r\n });\r\n }\r\n\r\n setupVideoButtonsEventListener() {\r\n this.videoControlButtons.forEach(button => {\r\n button.addEventListener('click', (e) => {\r\n this.togglePlayerState(button);\r\n });\r\n });\r\n }\r\n\r\n pauseInactiveVideos() {\r\n this.inactiveSlides.forEach(slideInfo => {\r\n if (this.videos[slideInfo.index]) {\r\n this.pauseVid(slideInfo.slide, slideInfo.index)\r\n }\r\n })\r\n }\r\n\r\n\r\n youtubeInit(slide, index) {\r\n const youtubeIframe = slide.querySelector('iframe');\r\n const secondarySlide = this.secondarySlider.slides[index]\r\n const slideControl = secondarySlide.querySelector('[data-controls-video]');\r\n if (!youtubeIframe.src) {\r\n YouTubeIframeLoader.load(YT => {\r\n const playerID = `youtube-player-${this.primaryCarousel.getAttribute('data-unique-id')}-${index}`;\r\n youtubeIframe.id = playerID;\r\n youtubeIframe.src = youtubeIframe.getAttribute('data-src');\r\n\r\n const youtubePlayer = new YT.Player(playerID, {\r\n playerVars: { rel: 0, showinfo: 0, ecver: 2 },\r\n events: {\r\n 'onReady': () => {\r\n this.playVid(slide, index)\r\n },\r\n 'onStateChange': () => {\r\n let state = youtubePlayer.getPlayerState()\r\n if (state == 0 || state == 2) {\r\n this.togglePlayButton(slideControl, false)\r\n }\r\n if (state == 1) {\r\n this.togglePlayButton(slideControl, true)\r\n }\r\n }\r\n }\r\n });\r\n this.videos[index] = { type: \"youtube\", player: youtubePlayer };\r\n });\r\n }\r\n\r\n }\r\n\r\n nativeVideoInit(slide, index) {\r\n const videoElement = slide.querySelector('video');\r\n const secondarySlide = this.secondarySlider.slides[index]\r\n const slideControl = secondarySlide.querySelector('[data-controls-video]');\r\n if (videoElement) {\r\n const videoSource = videoElement.querySelector('source');\r\n if (!videoSource.src) {\r\n videoSource.src = videoSource.getAttribute('data-src');\r\n videoElement.load();\r\n videoElement.addEventListener('loadeddata', () => {\r\n this.playVid(slide, index)\r\n videoElement.addEventListener('ended', (event) => {\r\n this.togglePlayButton(slideControl, false)\r\n });\r\n });\r\n this.videos[index] = { type: \"native\", player: videoElement };\r\n\r\n }\r\n }\r\n }\r\n\r\n playVid(slide, index) {\r\n const video = this.videos[index];\r\n const player = video.player;\r\n const secondarySlide = this.secondarySlider.slides[index]\r\n const slideControl = secondarySlide.querySelector('[data-controls-video]');\r\n\r\n if (video.type == 'youtube') {\r\n if (player.getPlayerState() != 1) {\r\n player.playVideo();\r\n }\r\n }\r\n\r\n else {\r\n player.play();\r\n }\r\n\r\n this.togglePlayButton(slideControl, true)\r\n }\r\n\r\n pauseVid(slide, index) {\r\n const video = this.videos[index];\r\n const player = video.player;\r\n const secondarySlide = this.secondarySlider.slides[index]\r\n const slideControl = secondarySlide.querySelector('[data-controls-video]');\r\n\r\n if (video.type == 'youtube') {\r\n if (player.getPlayerState() == 1) {\r\n player.pauseVideo();\r\n }\r\n }\r\n else {\r\n if (!player.paused) {\r\n player.pause();\r\n }\r\n }\r\n\r\n this.togglePlayButton(slideControl, false)\r\n }\r\n\r\n togglePlayButton(el, boolean) {\r\n el.setAttribute('aria-pressed', boolean)\r\n }\r\n\r\n togglePlayerState(button) {\r\n let slide = this.primarySlider.slides[this.primarySlider.activeIndex]\r\n let index = this.primarySlider.activeIndex\r\n let video = this.videos[index];\r\n let player = video.player;\r\n\r\n if (video.type == 'youtube') {\r\n\r\n if (player.getPlayerState() == 1) {\r\n this.pauseVid(slide, index)\r\n this.togglePlayButton(button, false)\r\n }\r\n else {\r\n this.playVid(slide, index)\r\n this.togglePlayButton(button, true)\r\n }\r\n }\r\n else if (video.type == 'native') {\r\n if (player.paused) {\r\n player.play()\r\n this.togglePlayButton(button, true)\r\n }\r\n else {\r\n this.pauseVid(slide, index)\r\n this.togglePlayButton(button, false)\r\n\r\n }\r\n }\r\n }\r\n\r\n\r\n disableSlide(slide) {\r\n // disable tabbing on tabbable content by default to stop trapping keyboard, and hide from screenreader users\r\n const tabbableContent = Array.prototype.slice.call(slide.querySelectorAll('a, input, button, area, object, select, iframe, video, audio'));\r\n tabbableContent.forEach(item => {\r\n item.tabIndex = -1;\r\n });\r\n slide.setAttribute('aria-hidden', 'true');\r\n }\r\n\r\n enableSlide(slide) {\r\n // enable tabbing on active slide and show to screenreader users\r\n const tabbableContent = Array.prototype.slice.call(slide.querySelectorAll('a, input, button, area, object, select, iframe, video, audio'));\r\n tabbableContent.forEach(item => {\r\n if (!item.hasAttribute('data-prevent-focus')) {\r\n item.tabIndex = 0;\r\n }\r\n });\r\n slide.setAttribute('aria-hidden', 'false');\r\n }\r\n\r\n\r\n\r\n}","/**\n * @license\n * Lodash \n * Copyright OpenJS Foundation and other contributors \n * Released under MIT license \n * Based on Underscore.js 1.8.3 \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.21';\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 INVALID_TEMPL_VAR_ERROR_TEXT = 'Invalid `variable` option passed into `_.template`';\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 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 whitespace. */\n var reTrimStart = /^\\s+/;\n\n /** Used to match a single whitespace character. */\n var reWhitespace = /\\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 /**\n * Used to validate the `validate` option in `_.template` variable.\n *\n * Forbids characters which could potentially change the meaning of the function argument definition:\n * - \"(),\" (modification of function parameters)\n * - \"=\" (default value)\n * - \"[]{}\" (destructuring of function parameters)\n * - \"/\" (beginning of a comment)\n * - whitespace\n */\n var reForbiddenIdentifierChars = /[()=,{}\\[\\]\\/\\s]/;\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|[A-Z_])',\n rsOrdUpper = '\\\\d*(?:1ST|2ND|3RD|(?![123])\\\\dTH)(?=\\\\b|[a-z_])',\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 '&': '&',\n '<': '<',\n '>': '>',\n '\"': '"',\n \"'\": '''\n };\n\n /** Used to map HTML entities to characters. */\n var htmlUnescapes = {\n '&': '&',\n '<': '<',\n '>': '>',\n '"': '\"',\n ''': \"'\"\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 // Use `util.types` for Node.js 10+.\n var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n if (types) {\n return types;\n }\n\n // Legacy `process.binding('util')` for Node.js < 10.\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 * 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 `_.trim`.\n *\n * @private\n * @param {string} string The string to trim.\n * @returns {string} Returns the trimmed string.\n */\n function baseTrim(string) {\n return string\n ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')\n : string;\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 `_.trim` and `_.trimEnd` to get the index of the last non-whitespace\n * character of `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the index of the last non-whitespace character.\n */\n function trimmedEndIndex(string) {\n var index = string.length;\n\n while (index-- && reWhitespace.test(string.charAt(index))) {}\n return index;\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, 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 if (isSet(value)) {\n value.forEach(function(subValue) {\n result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));\n });\n } else if (isMap(value)) {\n value.forEach(function(subValue, key) {\n result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));\n });\n }\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 stack || (stack = new Stack);\n if (isObject(srcValue)) {\n baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n }\n else {\n var newValue = customizer\n ? customizer(safeGet(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 = safeGet(object, key),\n srcValue = safeGet(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) || 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 if (iteratees.length) {\n iteratees = arrayMap(iteratees, function(iteratee) {\n if (isArray(iteratee)) {\n return function(value) {\n return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);\n }\n }\n return iteratee;\n });\n } else {\n iteratees = [identity];\n }\n\n var index = -1;\n iteratees = arrayMap(iteratees, 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 (key === '__proto__' || key === 'constructor' || key === 'prototype') {\n return object;\n }\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 var low = 0,\n high = array == null ? 0 : array.length;\n if (high === 0) {\n return 0;\n }\n\n value = iteratee(value);\n var 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 `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 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 && nativeIsFinite(number)) {\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 // Check that cyclic values are equal.\n var arrStacked = stack.get(array);\n var othStacked = stack.get(other);\n if (arrStacked && othStacked) {\n return arrStacked == other && othStacked == array;\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 // Check that cyclic values are equal.\n var objStacked = stack.get(object);\n var othStacked = stack.get(other);\n if (objStacked && othStacked) {\n return objStacked == other && othStacked == object;\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 = new 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`, `Map`, `Number`, `RegExp`, `Set`, 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 {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the initialized clone.\n */\n function initCloneByTag(object, tag, 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 new Ctor;\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 new Ctor;\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 var type = typeof value;\n length = length == null ? MAX_SAFE_INTEGER : length;\n\n return !!length &&\n (type == 'number' ||\n (type != 'symbol' && 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 * Gets the value at `key`, unless `key` is \"__proto__\" or \"constructor\".\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 safeGet(object, key) {\n if (key === 'constructor' && typeof object[key] === 'function') {\n return;\n }\n\n if (key == '__proto__') {\n return;\n }\n\n return object[key];\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 (string.charCodeAt(0) === 46 /* . */) {\n result.push('');\n }\n string.replace(rePropName, function(match, number, quote, subString) {\n result.push(quote ? subString.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 * // Combining several predicates using `_.overEvery` or `_.overSome`.\n * _.filter(users, _.overSome([{ 'age': 36 }, ['age', 40]]));\n * // => objects for ['fred', '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': 30 },\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', 30]]\n *\n * _.sortBy(users, ['user', 'age']);\n * // => objects for [['barney', 34], ['barney', 36], ['fred', 30], ['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 timeWaiting = wait - timeSinceLastCall;\n\n return maxing\n ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n : timeWaiting;\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 clearTimeout(timerId);\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 '

' + func(text) + '

';\n * });\n *\n * p('fred, barney, & pebbles');\n * // => '

fred, barney, & pebbles

'\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('');\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 = baseTrim(value);\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(object, sources) {\n object = Object(object);\n\n var index = -1;\n var length = sources.length;\n var guard = length > 2 ? sources[2] : undefined;\n\n if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n length = 1;\n }\n\n while (++index < length) {\n var source = sources[index];\n var props = keysIn(source);\n var propsIndex = -1;\n var propsLength = props.length;\n\n while (++propsIndex < propsLength) {\n var key = props[propsIndex];\n var value = object[key];\n\n if (value === undefined ||\n (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {\n object[key] = source[key];\n }\n }\n }\n\n return object;\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 if (value != null &&\n typeof value.toString != 'function') {\n value = nativeObjectToString.call(value);\n }\n\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 (value != null &&\n typeof value.toString != 'function') {\n value = nativeObjectToString.call(value);\n }\n\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, & 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('<%- value %>');\n * compiled({ 'value': '