{"version":3,"sources":["webpack:///./src/components/QDataSearchBox.vue?b3eb","webpack:///./src/components/QDataDeliveryList.vue?e87f","webpack:///./src/components/QDataDeliveryList.vue","webpack:///./src/components/QDataDeliveryList.vue?0615","webpack:///./src/components/QDataDeliveryList.vue?baec","webpack:///./src/views/QDataSubscriptionsPage.vue?a090","webpack:///./src/components/SubscriptionQualityDataRow.vue?1e63","webpack:///./src/components/SubscriptionQualityDataSubscriptionRow.vue?fcd2","webpack:///./src/components/SubscriptionQualityDataSubscriptionRow.vue","webpack:///./src/components/SubscriptionQualityDataSubscriptionRow.vue?c54d","webpack:///./src/components/SubscriptionQualityDataSubscriptionRow.vue?6456","webpack:///./src/components/SubscriptionQualityDataRow.vue","webpack:///./src/components/SubscriptionQualityDataRow.vue?0ea0","webpack:///./src/components/SubscriptionQualityDataRow.vue?afb4","webpack:///./src/views/QDataSubscriptionsPage.vue","webpack:///./src/views/QDataSubscriptionsPage.vue?4d76","webpack:///./src/views/QDataSubscriptionsPage.vue?3736","webpack:///./src/views/QDataDeliveryPage.vue?4604","webpack:///./src/components/QDataPredictedParametersList.vue?4a29","webpack:///./src/components/QDataScanner.vue?eac1","webpack:///./src/components/QDataDeliveryMessagesFilter.vue?90b4","webpack:///./node_modules/lodash/lodash.js","webpack:///./src/components/SubscriptionQualityDataRow.vue?0eb5","webpack:///./src/components/general/TextBox.vue?86e4","webpack:///./src/components/general/TextBox.vue","webpack:///./src/components/general/TextBox.vue?43b9","webpack:///./src/components/general/TextBox.vue?41a7","webpack:///./src/views/QDataDeliveryPage.vue?0919","webpack:///./src/components/QDataTextileParameters.vue?46ec","webpack:///./src/components/QDataDetailedParameterRow.vue?ff2c","webpack:///./src/components/QDataDetailedParameterRow.vue","webpack:///./src/components/QDataDetailedParameterRow.vue?b880","webpack:///./src/components/QDataDetailedParameterRow.vue?276b","webpack:///./src/components/QDataParameterList.vue?99ed","webpack:///./src/components/QDataParameterList.vue","webpack:///./src/components/QDataParameterList.vue?be4f","webpack:///./src/components/QDataParameterList.vue?bbc1","webpack:///./src/models/ParameterDisplayData.ts","webpack:///./src/components/QDataTextileParameters.vue","webpack:///./src/components/QDataTextileParameters.vue?ce1e","webpack:///./src/components/QDataTextileParameters.vue?696d","webpack:///./src/components/QDataPaperParameters.vue?3e5f","webpack:///./src/components/QDataPredictedParametersList.vue?3f77","webpack:///./src/components/QDataPredictedParametersList.vue","webpack:///./src/components/QDataPredictedParametersList.vue?9423","webpack:///./src/components/QDataPredictedParametersList.vue?b4bb","webpack:///./src/store/modules/deliveryMessagePredictedParameters.ts","webpack:///./src/components/QDataPaperParameters.vue","webpack:///./src/components/QDataPaperParameters.vue?c072","webpack:///./src/components/QDataPaperParameters.vue?e811","webpack:///./src/components/QDataDeliveryNavigation.vue?9f76","webpack:///./src/components/QDataDeliveryNavigation.vue","webpack:///./src/components/QDataDeliveryNavigation.vue?503c","webpack:///./src/components/QDataDeliveryNavigation.vue?97cc","webpack:///./src/components/QDataDeliveryMetadata.vue?81f6","webpack:///./src/components/QDataDeliveryMetadata.vue","webpack:///./src/components/QDataDeliveryMetadata.vue?8ae0","webpack:///./src/components/QDataDeliveryMetadata.vue?2847","webpack:///./src/store/modules/deliveryMessageQualityData.ts","webpack:///./src/models/QualityData/DeliveryMessageDetails.ts","webpack:///./src/models/QualityData/DeliveryMessage.ts","webpack:///./src/store/modules/deliveryMessage.ts","webpack:///./src/views/QDataDeliveryPage.vue","webpack:///./src/views/QDataDeliveryPage.vue?d800","webpack:///./src/views/QDataDeliveryPage.vue?fb9e","webpack:///./src/services/QualityDataService.ts","webpack:///./src/components/QDataParameterList.vue?c36a","webpack:///./src/views/QDataPage.vue?9654","webpack:///./src/components/QDataDeliveryMessagesFilter.vue?84e0","webpack:///./src/components/QDataDeliveryMessagesFilter.vue","webpack:///./src/components/QDataDeliveryMessagesFilter.vue?8af1","webpack:///./src/components/QDataDeliveryMessagesFilter.vue?29dd","webpack:///./src/components/QDataChart.vue?570d","webpack:///./src/store/modules/parameterQualityDataAverages.ts","webpack:///./src/components/QDataChart.vue","webpack:///./src/components/QDataChart.vue?396b","webpack:///./src/components/QDataChart.vue?ec3c","webpack:///./src/views/QDataPage.vue","webpack:///./src/views/QDataPage.vue?60cb","webpack:///./src/views/QDataPage.vue?1b10","webpack:///./src/components/QDataChart.vue?d65d","webpack:///./src/models/QualityData/SuggestionType.ts","webpack:///./src/views/QDataSearchPage.vue?8620","webpack:///./src/views/QDataSearchPage.vue","webpack:///./src/views/QDataSearchPage.vue?dc37","webpack:///./src/views/QDataSearchPage.vue?2477","webpack:///./src/components/QDataSearchBox.vue?f312","webpack:///./src/components/general/CustomAutoSuggest.vue?8869","webpack:///./node_modules/vue-autosuggest/dist/vue-autosuggest.esm.js","webpack:///./src/components/general/CustomAutoSuggest.vue","webpack:///./src/components/general/CustomAutoSuggest.vue?8222","webpack:///./src/components/general/CustomAutoSuggest.vue?fa34","webpack:///./src/components/QDataSearchBox.vue","webpack:///./src/components/QDataSearchBox.vue?a2af","webpack:///./src/components/QDataSearchBox.vue?73c3","webpack:///./src/views/QDataUnitSearchPage.vue?8458","webpack:///./src/views/QDataSubscriptionsPage.vue?4153","webpack:///./src/views/QDataUnitSearchPage.vue?c3e1","webpack:///./src/store/modules/deliveryMessagesUnitSearch.ts","webpack:///./src/components/QDataScanner.vue?14c9","webpack:///./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js","webpack:///./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js","webpack:///./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js","webpack:///./node_modules/@babel/runtime/helpers/esm/slicedToArray.js","webpack:///./src/components/QDataScannerOverlay.vue","webpack:///./src/components/QDataScannerOverlay.vue?e819","webpack:///./src/components/QDataScannerOverlay.vue?4091","webpack:///./src/components/QDataScannerOverlay.vue?4371","webpack:///./src/components/QDataScanner.vue","webpack:///./src/components/QDataScanner.vue?04e8","webpack:///./src/components/QDataScanner.vue?3716","webpack:///./src/views/QDataUnitSearchPage.vue","webpack:///./src/views/QDataUnitSearchPage.vue?448a","webpack:///./src/views/QDataUnitSearchPage.vue?23f2","webpack:///./src/components/QDataDetailedParameterRow.vue?95fc","webpack:///./src/components/QDataUnitList.vue?de69","webpack:///./src/components/QDataUnitList.vue","webpack:///./src/components/QDataUnitList.vue?6eb9","webpack:///./src/components/QDataUnitList.vue?67c4","webpack:///./src/components/general/Panelista.vue?4bd6","webpack:///./src/components/general/Panelista.vue","webpack:///./src/components/general/Panelista.vue?e16e","webpack:///./src/components/general/Panelista.vue?75c0"],"names":["render","_vm","this","_h","$createElement","_c","_self","deliveryMessages","attrs","columns","rows","downloadingDataSheet","$t","on","onSendCheckedRows","onDeliveryMessageClick","onCheckedAll","_e","staticRenderFns","text","toString","property","alignRight","map","deliveryMessage","properties","number","customerReference","orderId","product","getProductDisplayNames","quantity","totalQuantity","numberOfUnits","deliveryDate","date","destination","deliveryAddressDestinationLocality","isClickable","isChecked","downloadAll","undefined","searchTerm","deliveryMessagesRange","details","x","productDisplayName","join","row","$emit","checkedAll","checkedRows","checkedDeliveryMessages","forEach","push","downloadDataSheet","onDownloadExcel","deliveryNumbers","message","downloadDeliveriesQualityDataAsExcel","totalNumberOfDeliveries","isSearchByDate","fromDate","toDate","deliveryMessagesProductsSelected","isSearchByTerm","catch","error","Consoler","debugWarn","errorMessage","type","Message","EventBus","Config","AddMessageEvent","finally","required","components","Table","component","breadcrumbs","staticClass","_v","_s","isLoading","errorLoading","subscriptions","_l","subscription","index","key","onEditSubscription","onCreateSubscription","$event","loadSubscriptions","onRestoreDeletedSubscription","errorActivating","errorInactivating","errorRestoring","createOrUpdateSubscription","ref","createNotUpdate","onCreatedSubscription","onUpdatedSubscription","class","isExpanded","nonDeletedSubscriptions","subscriptionInfoDetails","onEditQualityDataSubscription","onDeleteQualityDataSubscription","deletedSubscriptions","onRestoreQualityDataSubscription","deleteSubscription","name","isDeletingSubscription","errorDeletingSubscription","onConfirmDeleteSubscription","deleted","preventDefault","onEditClick","apply","arguments","canEdit","onDeleteClick","onRestoreClick","descriptionText","SubscriptionType","QualityData","qualityData","frequency","customersText","productsText","parametersText","$tc","enableForAllMyCustomers","enableForSpecificCustomerIds","length","n","allText","toLowerCase","enableForAllMyProducts","enableForSpecificProductNames","enableForAllMyPaperParameters","enableForAllMyTextileParameters","paperParametersCount","enableForSpecificParameters","filter","p","enabledForPaperPulp","textileParametersCount","enabledForTextilePulp","some","Permissions","hasPermission","PermissionType","IsAllowedToEditSubscriptions","default","SubscriptionEditorModal","SubscriptionActiveSwitch","deletedDate","subscriptionDetails","$nextTick","$refs","confirmDeleteModal","show","dispatchDelete","id","subscriptionType","then","SubscriptionQualityDataSubscriptionRow","ConfirmModal","allSubscriptions","routeName","routeTrackingInfo","$route","stopTrackPage","force","dispatchAdd","loading","dispatchLoad","commitComplete","subscriptionEditorModal","changeActiveStatusForSubscription","dispatchRestore","model","active","updatingSubscriptionType","dispatchChangeActiveStatus","isSubscribed","DefaultLayout","Breadcrumbs","Messages","SubscriptionQualityDataRow","VERSION","LARGE_ARRAY_SIZE","CORE_ERROR_TEXT","FUNC_ERROR_TEXT","INVALID_TEMPL_VAR_ERROR_TEXT","HASH_UNDEFINED","MAX_MEMOIZE_SIZE","PLACEHOLDER","CLONE_DEEP_FLAG","CLONE_FLAT_FLAG","CLONE_SYMBOLS_FLAG","COMPARE_PARTIAL_FLAG","COMPARE_UNORDERED_FLAG","WRAP_BIND_FLAG","WRAP_BIND_KEY_FLAG","WRAP_CURRY_BOUND_FLAG","WRAP_CURRY_FLAG","WRAP_CURRY_RIGHT_FLAG","WRAP_PARTIAL_FLAG","WRAP_PARTIAL_RIGHT_FLAG","WRAP_ARY_FLAG","WRAP_REARG_FLAG","WRAP_FLIP_FLAG","DEFAULT_TRUNC_LENGTH","DEFAULT_TRUNC_OMISSION","HOT_COUNT","HOT_SPAN","LAZY_FILTER_FLAG","LAZY_MAP_FLAG","LAZY_WHILE_FLAG","INFINITY","MAX_SAFE_INTEGER","MAX_INTEGER","NAN","MAX_ARRAY_LENGTH","MAX_ARRAY_INDEX","HALF_MAX_ARRAY_LENGTH","wrapFlags","argsTag","arrayTag","asyncTag","boolTag","dateTag","domExcTag","errorTag","funcTag","genTag","mapTag","numberTag","nullTag","objectTag","promiseTag","proxyTag","regexpTag","setTag","stringTag","symbolTag","undefinedTag","weakMapTag","weakSetTag","arrayBufferTag","dataViewTag","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint8ClampedTag","uint16Tag","uint32Tag","reEmptyStringLeading","reEmptyStringMiddle","reEmptyStringTrailing","reEscapedHtml","reUnescapedHtml","reHasEscapedHtml","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","rsAstralRange","rsComboMarksRange","reComboHalfMarksRange","rsComboSymbolsRange","rsComboRange","rsDingbatRange","rsLowerRange","rsMathOpRange","rsNonCharRange","rsPunctuationRange","rsSpaceRange","rsUpperRange","rsVarRange","rsBreakRange","rsApos","rsAstral","rsBreak","rsCombo","rsDigits","rsDingbat","rsLower","rsMisc","rsFitz","rsModifier","rsNonAstral","rsRegional","rsSurrPair","rsUpper","rsZWJ","rsMiscLower","rsMiscUpper","rsOptContrLower","rsOptContrUpper","reOptMod","rsOptVar","rsOptJoin","rsOrdLower","rsOrdUpper","rsSeq","rsEmoji","rsSymbol","reApos","reComboMark","reUnicode","reUnicodeWord","reHasUnicode","reHasUnicodeWord","contextProps","templateCounter","typedArrayTags","cloneableTags","deburredLetters","htmlEscapes","htmlUnescapes","stringEscapes","freeParseFloat","parseFloat","freeParseInt","parseInt","freeGlobal","global","Object","freeSelf","self","root","Function","freeExports","exports","nodeType","freeModule","module","moduleExports","freeProcess","process","nodeUtil","types","require","binding","e","nodeIsArrayBuffer","isArrayBuffer","nodeIsDate","isDate","nodeIsMap","isMap","nodeIsRegExp","isRegExp","nodeIsSet","isSet","nodeIsTypedArray","isTypedArray","func","thisArg","args","call","arrayAggregator","array","setter","iteratee","accumulator","value","arrayEach","arrayEachRight","arrayEvery","predicate","arrayFilter","resIndex","result","arrayIncludes","baseIndexOf","arrayIncludesWith","comparator","arrayMap","Array","arrayPush","values","offset","arrayReduce","initAccum","arrayReduceRight","arraySome","asciiSize","baseProperty","asciiToArray","string","split","asciiWords","match","baseFindKey","collection","eachFunc","baseFindIndex","fromIndex","fromRight","strictIndexOf","baseIsNaN","baseIndexOfWith","baseMean","baseSum","object","basePropertyOf","baseReduce","baseSortBy","comparer","sort","current","baseTimes","baseToPairs","props","baseTrim","slice","trimmedEndIndex","replace","baseUnary","baseValues","cacheHas","cache","has","charsStartIndex","strSymbols","chrSymbols","charsEndIndex","countHolders","placeholder","deburrLetter","escapeHtmlChar","escapeStringChar","chr","getValue","hasUnicode","test","hasUnicodeWord","iteratorToArray","iterator","data","next","done","mapToArray","size","overArg","transform","arg","replaceHolders","setToArray","set","setToPairs","strictLastIndexOf","stringSize","unicodeSize","stringToArray","unicodeToArray","charAt","unescapeHtmlChar","lastIndex","unicodeWords","runInContext","context","_","defaults","pick","Date","Error","Math","String","TypeError","arrayProto","prototype","funcProto","objectProto","coreJsData","funcToString","hasOwnProperty","idCounter","maskSrcKey","uid","exec","keys","IE_PROTO","nativeObjectToString","objectCtorString","oldDash","reIsNative","Buffer","Symbol","Uint8Array","allocUnsafe","getPrototype","getPrototypeOf","objectCreate","create","propertyIsEnumerable","splice","spreadableSymbol","isConcatSpreadable","symIterator","symToStringTag","toStringTag","defineProperty","getNative","ctxClearTimeout","clearTimeout","ctxNow","now","ctxSetTimeout","setTimeout","nativeCeil","ceil","nativeFloor","floor","nativeGetSymbols","getOwnPropertySymbols","nativeIsBuffer","isBuffer","nativeIsFinite","isFinite","nativeJoin","nativeKeys","nativeMax","max","nativeMin","min","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","isArray","LazyWrapper","LodashWrapper","wrapperClone","baseCreate","proto","isObject","baseLodash","chainAll","__wrapped__","__actions__","__chain__","__index__","__values__","__dir__","__filtered__","__iteratees__","__takeCount__","__views__","lazyClone","copyArray","lazyReverse","clone","lazyValue","dir","isArr","isRight","arrLength","view","getView","start","end","iteratees","iterLength","takeCount","baseWrapperValue","outer","iterIndex","computed","Hash","entries","clear","entry","hashClear","__data__","hashDelete","hashGet","hashHas","hashSet","ListCache","listCacheClear","listCacheDelete","assocIndexOf","pop","listCacheGet","listCacheHas","listCacheSet","MapCache","mapCacheClear","mapCacheDelete","getMapData","mapCacheGet","get","mapCacheHas","mapCacheSet","SetCache","add","setCacheAdd","setCacheHas","Stack","stackClear","stackDelete","stackGet","stackHas","stackSet","pairs","arrayLikeKeys","inherited","isArg","isArguments","isBuff","isType","skipIndexes","isIndex","arraySample","baseRandom","arraySampleSize","shuffleSelf","baseClamp","arrayShuffle","assignMergeValue","eq","baseAssignValue","assignValue","objValue","baseAggregator","baseEach","baseAssign","copyObject","baseAssignIn","keysIn","baseAt","paths","skip","lower","upper","baseClone","bitmask","customizer","stack","isDeep","isFlat","isFull","initCloneArray","tag","getTag","isFunc","cloneBuffer","initCloneObject","copySymbolsIn","copySymbols","initCloneByTag","stacked","subValue","keysFunc","getAllKeysIn","getAllKeys","baseConforms","baseConformsTo","baseDelay","wait","baseDifference","includes","isCommon","valuesLength","valuesIndex","templateSettings","constructor","createBaseEach","baseForOwn","baseEachRight","baseForOwnRight","baseEvery","baseExtremum","isSymbol","baseFill","toInteger","toLength","baseFilter","baseFlatten","depth","isStrict","isFlattenable","baseFor","createBaseFor","baseForRight","baseFunctions","isFunction","baseGet","path","castPath","toKey","baseGetAllKeys","symbolsFunc","baseGetTag","getRawTag","objectToString","baseGt","other","baseHas","baseHasIn","baseInRange","baseIntersection","arrays","othLength","othIndex","caches","maxLength","Infinity","seen","baseInverter","baseInvoke","parent","last","baseIsArguments","baseIsArrayBuffer","baseIsDate","baseIsEqual","baseIsEqualDeep","equalFunc","objIsArr","othIsArr","objTag","othTag","objIsObj","othIsObj","isSameTag","equalArrays","equalByTag","objIsWrapped","othIsWrapped","objUnwrapped","othUnwrapped","equalObjects","baseIsMap","baseIsMatch","matchData","noCustomizer","srcValue","baseIsNative","isMasked","pattern","baseIsRegExp","baseIsSet","baseIsTypedArray","isLength","baseIteratee","identity","baseMatchesProperty","baseMatches","baseKeys","isPrototype","baseKeysIn","nativeKeysIn","isProto","baseLt","baseMap","isArrayLike","getMatchData","matchesStrictComparable","isKey","isStrictComparable","hasIn","baseMerge","srcIndex","baseMergeDeep","newValue","safeGet","mergeFunc","isTyped","isArrayLikeObject","cloneTypedArray","isPlainObject","toPlainObject","baseNth","baseOrderBy","orders","getIteratee","criteria","compareMultiple","basePick","basePickBy","baseSet","basePropertyDeep","basePullAll","indexOf","basePullAt","indexes","previous","baseUnset","baseRange","step","baseRepeat","baseRest","setToString","overRest","baseSample","baseSampleSize","nested","baseSetData","baseSetToString","constant","baseShuffle","baseSlice","baseSome","baseSortedIndex","retHighest","low","high","mid","baseSortedIndexBy","valIsNaN","valIsNull","valIsSymbol","valIsUndefined","othIsDefined","othIsNull","othIsReflexive","othIsSymbol","setLow","baseSortedUniq","baseToNumber","baseToString","baseUniq","createSet","seenIndex","baseUpdate","updater","baseWhile","isDrop","actions","action","baseXor","baseZipObject","assignFunc","valsLength","castArrayLikeObject","castFunction","stringToPath","castRest","castSlice","buffer","copy","cloneArrayBuffer","arrayBuffer","byteLength","cloneDataView","dataView","byteOffset","cloneRegExp","regexp","cloneSymbol","symbol","typedArray","compareAscending","valIsDefined","valIsReflexive","objCriteria","othCriteria","ordersLength","order","composeArgs","partials","holders","isCurried","argsIndex","argsLength","holdersLength","leftIndex","leftLength","rangeLength","isUncurried","composeArgsRight","holdersIndex","rightIndex","rightLength","isNew","getSymbols","getSymbolsIn","createAggregator","initializer","createAssigner","assigner","sources","guard","isIterateeCall","iterable","createBind","isBind","Ctor","createCtor","wrapper","fn","createCaseFirst","methodName","trailing","createCompounder","callback","words","deburr","thisBinding","createCurry","arity","getHolder","createRecurry","createHybrid","createFind","findIndexFunc","createFlow","flatRest","funcs","prereq","thru","getFuncName","funcName","getData","isLaziable","plant","partialsRight","holdersRight","argPos","ary","isAry","isBindKey","isFlip","holdersCount","newHolders","reorder","createInverter","toIteratee","createMathOperation","operator","defaultValue","createOver","arrayFunc","createPadding","chars","charsLength","createPartial","createRange","toFinite","createRelationalOperation","toNumber","wrapFunc","isCurry","newHoldersRight","newPartials","newPartialsRight","newData","setData","setWrapToString","createRound","precision","pair","noop","createToPairs","createWrap","mergeData","customDefaultsAssignIn","customDefaultsMerge","customOmitClone","isPartial","arrStacked","othStacked","arrValue","othValue","compared","convert","objProps","objLength","othProps","objStacked","skipCtor","objCtor","othCtor","flatten","otherFunc","isKeyable","isOwn","unmasked","stubArray","transforms","getWrapDetails","hasPath","hasFunc","input","insertWrapDetails","ArrayBuffer","resolve","ctorString","isMaskable","stubFalse","memoizeCapped","memoize","srcBitmask","newBitmask","isCombo","otherArgs","oldArray","shortOut","reference","updateWrapDetails","count","lastCalled","stamp","remaining","rand","charCodeAt","quote","subString","chunk","compact","concat","difference","differenceBy","differenceWith","drop","dropRight","dropRightWhile","dropWhile","fill","findIndex","findLastIndex","flattenDeep","flattenDepth","fromPairs","head","initial","intersection","mapped","intersectionBy","intersectionWith","separator","lastIndexOf","nth","pull","pullAll","pullAllBy","pullAllWith","pullAt","remove","sortedIndex","sortedIndexBy","sortedIndexOf","sortedLastIndex","sortedLastIndexBy","sortedLastIndexOf","sortedUniq","sortedUniqBy","tail","take","takeRight","takeRightWhile","takeWhile","union","unionBy","unionWith","uniq","uniqBy","uniqWith","unzip","group","unzipWith","without","xor","xorBy","xorWith","zip","zipObject","zipObjectDeep","zipWith","chain","tap","interceptor","wrapperAt","wrapperChain","wrapperCommit","wrapperNext","toArray","wrapperToIterator","wrapperPlant","wrapperReverse","wrapped","wrapperValue","countBy","every","find","findLast","flatMap","flatMapDeep","flatMapDepth","forEachRight","groupBy","isString","invokeMap","keyBy","orderBy","partition","reduce","reduceRight","reject","negate","sample","sampleSize","shuffle","sortBy","after","before","bind","bindKey","curry","curryRight","debounce","options","lastArgs","lastThis","maxWait","timerId","lastCallTime","lastInvokeTime","leading","maxing","invokeFunc","time","leadingEdge","timerExpired","remainingWait","timeSinceLastCall","timeSinceLastInvoke","timeWaiting","shouldInvoke","trailingEdge","cancel","flush","debounced","isInvoking","defer","delay","flip","resolver","memoized","Cache","once","overArgs","funcsLength","partial","partialRight","rearg","rest","spread","throttle","unary","wrap","castArray","cloneWith","cloneDeep","cloneDeepWith","conformsTo","gt","gte","isBoolean","isElement","isEmpty","isEqual","isEqualWith","isError","isInteger","isMatch","isMatchWith","isNaN","isNumber","isNative","isNull","isNil","isSafeInteger","isUndefined","isWeakMap","isWeakSet","lt","lte","sign","remainder","isBinary","toSafeInteger","assign","assignIn","assignInWith","assignWith","at","propsIndex","propsLength","defaultsDeep","mergeWith","findKey","findLastKey","forIn","forInRight","forOwn","forOwnRight","functions","functionsIn","invert","invertBy","invoke","mapKeys","mapValues","merge","omit","omitBy","pickBy","prop","setWith","toPairs","toPairsIn","isArrLike","unset","update","updateWith","valuesIn","clamp","inRange","floating","temp","camelCase","word","capitalize","upperFirst","endsWith","target","position","escape","escapeRegExp","kebabCase","lowerCase","lowerFirst","pad","strLength","padEnd","padStart","radix","repeat","snakeCase","limit","startCase","startsWith","template","settings","isEscaping","isEvaluating","imports","importsKeys","importsValues","interpolate","reDelimiters","evaluate","sourceURL","escapeValue","interpolateValue","esTemplateValue","evaluateValue","variable","attempt","toLower","toUpper","toUpperCase","trim","trimEnd","trimStart","truncate","omission","search","substring","newEnd","unescape","upperCase","bindAll","methodNames","cond","conforms","defaultTo","flow","flowRight","matches","matchesProperty","method","methodOf","mixin","noConflict","nthArg","over","overEvery","overSome","propertyOf","range","rangeRight","stubObject","stubString","stubTrue","times","toPath","uniqueId","prefix","augend","addend","divide","dividend","divisor","maxBy","mean","meanBy","minBy","multiply","multiplier","multiplicand","round","subtract","minuend","subtrahend","sum","sumBy","entriesIn","extend","extendWith","each","eachRight","first","isFilter","takeName","dropName","checkIteratee","isTaker","lodashFunc","retUnwrapped","isLazy","useLazy","isHybrid","isUnwrapped","onlyLazy","chainName","commit","toJSON","backgroundColor","mainText","secondaryText","selectedUnit","deliveryMessageParameters","deliveryMessageQualityData","pulpType","deliveryMessageNumber","queryData","eudrDownloadsEnabled","isDeliveryDateAfterEudrDate","downloadingEudrDataCsv","downloadEudrDataCsv","onPaperPredictedRevolutionsChange","deliveryMessageUnits","deliveryMessageAverageValues","errorLoadingQData","detailedParameter","minorParameters","icon","parameter","displayName","measuringStandard","_f","numberOfDecimals","unit","psolParameterId","AlkaliResistanceR18","AshContent","BrightnessOnline","Coarseness","DirtContentOnline","ExtractiveContent","FibreLength","FibreWidth","Ph","Viscosity","Xylan","parameterValue","parameterMeasuringStandard","unitOfMeasurement","standard","AlphaCellulose","CalciumContent","CopperContent","IronContent","ManganeseContent","MoistureContent","SiliconContent","detailedParameterIds","parameterId","getParameter","hasParameter","minorParameterIds","parameters","averageValue","averageValues","measuringStandards","parameterValueAvg","QDataDetailedParameterRow","QDataParameterList","revolutionsSelectOptions","loadingPredictedParameters","errorPredictedParameters","predictedParameters","currentRevolutions","onRevolutionsChange","getPredictedParameterText","parameterValueActual","parameterValueTypical","common","getDataFor","payload","setLoading","setLoadingComplete","setLoadingError","hasFreshDataFor","item","revolutions","currentlyLoadingPromise","isCurrentlyLoading","debugLog","loadingPromise","getPredictedParameters","response","commitSetLoadingComplete","commitSetLoadingError","commitSetLoading","clearData","namespaced","dynamic","store","deliveryMessagePredictedParametersModule","isFeatureEnabled","FeatureFlagNames","Pfi","loadDeliveryMessagePredictedParameters","possibleRevolutions","val","isPredictedParametersEnabled","setRevolutions","QDataPredictedParametersList","SelectBox","resultsRoute","backToResultsLinkText","currentDeliveryMessageIndexInTotal","totalCount","previousDeliveryMessageRoute","scopedSlots","_u","href","navigate","doManualPreviousOrNextDeliveryMessage","onManualPreviousOrNextRouteClick","nextDeliveryMessageRoute","by","term","from","to","productNames","pageIndex","pageSize","queryMatchesDatesSearch","queryMatchesTermSearch","results","items","getPreviousOrNextDeliveryMessageRoute","dm","currentDeliveryMessageIndexInResult","query","queryBy","ByDates","isSameSearch","ByTerm","datesSearch","termSearch","previousNotNext","hasResultsForCurrentQuery","wantedDeliveryMessage","params","pageCount","newPageIndex","$router","invoiceNumbers","detail","style","getProductStyle","deliverySupplierDisplayName","deliverySupplierNumber","invoiceNumber","background","getProductColor","productColorCategory","getByDeliveryMessage","deliveryMessageQualityDataModule","copyDeliveryMessageDetails","deliveryMessageDetails","productName","copyDeliveryMessage","deliveryMessageCopy","getDeliveryMessage","deliveryMessageModule","beforeRoute","i18n","tc","stoppedInAdvance","notFound","registerHooks","PulpType","Textile","Paper","hasUnitsFromBeforeAndAfterBreakpoint","units","unitId","u","queryText","queryType","routeQuery","routeParams","initialize","loadDeliveryMessageQualityData","EudrDownloads","deliveryDateString","ex","eudrDownloadsFromDate","dateString","Settings","EudrDownloadsFromDate","downloadDeliveryQualityDataAsExcel","paperPredictedRevolutions","downloadDeliveryMessageEudrDataAsCsv","immediate","deep","QDataSearchBox","QDataTextileParameters","QDataPaperParameters","QDataUnitList","QDataDeliveryNavigation","QDataDeliveryMetadata","TextBox","QualityDataService","ids","toDateString","downloadFile","deliveryMessageNumbers","dateFrom","dateTo","image","formData","FormData","append","post","headers","qualityDataService","selectedProductNames","products","selectedParameter","parametersWithAverages","onDeliveryMessagesFilter","onParameterChange","onProductsChange","loadingAverages","errorAverages","aSearchHasBeenDone","errorDeliveries","deliveryMessagesCount","onQDataDeliveryListClick","paginationRoutes","onPageSizeChanged","loadingDeliveries","dateRange","dateRangeShortcuts","startOfToday","maxRangeLengthInMonths","onUpdate","actualProductNames","productOptions","onProductsTreeSelectSelect","_m","actualParameter","parameterSelectOptions","onActualParameterInput","Dates","label","createDateRangeShortcuts","shortcuts","startOfYear","getFullYear","getDateANumbersOfMonthsInThePast","startOfLastYear","endOfLastYear","v","selectedProductName","CustomDateRangePicker","TreeSelect","averages","chartOptions","setLoadedDate","clearLoadedDate","clearLoading","setLoadingPromise","loadingId","loadingPromiseForId","needToReLoad","commitClearParameterQualityDataAverages","getAverages","commitSetParameterQualityDataAverages","commitSetLoadedDate","commitClearLoading","commitSetLoadingPromise","parameterQualityDataAveragesModule","linkColor","deliveryLink","router","currentRoute","r","parameterResults","parameterUnitOfMeasurement","parameterNumberOfDecimals","productAverages","a","allAverageValues","parameterMinimumMinValue","parameterMaximumMaxValue","parameterMinValues","allMinimumValues","t","parameterMaxValues","allMaximumValues","series","average","getTime","y","dashStyle","color","events","legendItemClick","referenceLines","chart","s","referenceLine","visible","hide","f","totalAverageValue","averagesDates","getReferenceSeriesLine","parameterValues","title","xAxis","labels","fontSize","yAxis","align","textAlign","reserveSpace","rotation","minPadding","maxPadding","grid","enabled","gridLineColor","softMin","chartMin","softMax","chartMax","chartSeries","height","zoomType","marginTop","spacing","plotOptions","lineWidth","spline","marker","lineColor","fillColor","radius","line","tooltip","pointFormatter","qdataPoint","html","outside","hideDelay","stickOnContact","credits","useUTC","$moment","isBefore","lineType","isTypical","Helpers","HexToRGB","getFromDate","getToDate","showInLegend","highcharts","previousPageRoute","generateQuery","nextPageRoute","numberPageRoute","page","firstPageRoute","lastPageRoute","initializeDeliveryMessagesParameters","loadData","initializeSelectedParameter","findParameter","newPageSize","updateQuery","onlyReplaceExistingRoute","downloading","downloadingExcel","all","loadDeliveriesByDates","loadParameterAveragesByDates","searchParameters","QDataDeliveryMessagesFilter","QDataDeliveryList","QDataChart","Pagination","Panelista","SuggestionType","domProps","subtitle","noDataText","loadDeliveriesByTerm","suggestions","onInput","onSubmit","onReset","onSelect","routeNameQDataUnitSearch","inputProps","getSuggestionValue","onItemChanged","onSelected","isOpen","_k","keyCode","onEnter","suggestion","selectedItem","displayValue","$$v","expression","slot","onResetClick","DefaultSection","section","currentIndex","Number","renderSuggestion","normalizeItemFunction","componentAttrPrefix","componentAttrIdAutosuggest","_currentIndex","list","methods","getItemIndex","start_index","getItemByIndex","onMouseEnter","currentTarget","getAttribute","onMouseLeave","beforeSection","$scopedSlots","afterSectionDefault","afterSectionNamed","i","className","role","ulClass","o","liClass","l","liAttributes","mouseenter","mouseleave","_key","hasClass","addClass","removeClass","classList","INDEX_IS_FOCUSED_ON_INPUT","defaultSectionConfig","VueAutosuggest","_t","_g","_b","internal_inputProps","autocomplete","internalValue","inputHandler","keydown","handleKeyStroke","listeners","_componentAttrClassAutosuggestResultsContainer","_componentAttrClassAutosuggestResults","computedSections","getSectionRef","refInFor","normalizeItem","updateCurrentIndex","shouldRenderSuggestions","sectionConfigs","componentAttrClassAutosuggestResultsContainer","componentAttrClassAutosuggestResults","searchInputOriginal","currentItem","didSelectFromOptions","defaultInputProps","clientXMouseDownInitial","$listeners","click","ensureItemVisible","selected","setChangeItem","totalResults","end_index","watch","handler","created","mounted","document","addEventListener","onDocumentMouseUp","onDocumentMouseDown","beforeDestroy","removeEventListener","setCurrentIndex","$el","querySelector","clientHeight","scrollTop","offsetTop","clickedOnScrollbar","clientWidth","tagName","getBoundingClientRect","clientX","left","contains","VueAutosuggestPlugin","install","window","Vue","use","hasSelected","autosuggestComponent","autosuggest","focus","getSuggestions","onValue","goToSearchPage","getDisplayValue","numberOfMatches","matchedTerm","DeliveryMessage","commitClearSearch","Unit","goToDeliveryPage","newQuery","clearValue","customAutoSuggest","CustomAutoSuggest","onUnitScanned","directives","rawName","composing","unitIdsInput","onScanClick","showGeneralError","notFoundErrorHtml","showNotFoundError","searchHasBeenDone","unitsFound","unitsAverageValues","unitIds","getUnits","commitSetDeliveryMessagesUnitSearch","commitClearDeliveryMessagesUnitSearch","commitClearLoadedDate","deliveryMessagesUnitSearchModule","noUnitIdFound","videoSize","takeAndAnalyzePhoto","currentCameraDevice","cameraDevicesSelectOptions","onCameraChange","onCloseClick","isViewfinderStyleUnitId","onUnitIdClick","onBarcodeClick","proxy","_arrayWithHoles","arr","_iterableToArrayLimit","_arr","_n","_d","_i","err","_nonIterableRest","_slicedToArray","arrayWithHoles","iterableToArrayLimit","unsupportedIterableToArray","nonIterableRest","ViewfinderStyle","overlayClicked","x1","y1","x2","y2","totalWidth","totalHeight","UnitId","totalArea","horizontalScaleUnitId","horizontalScaleBarcode","viewfinderWidth","viewfinderArea","viewfinderStyle","overlay","scannerCanvas","width","Width","Height","redraw","canvas","ctx","getContext","viewfinder","getViewfinderCoordinates","clearRect","fillStyle","fillRect","userProfile","selectedCameraDeviceId","deviceId","commitClearSelectedCameraDeviceId","commitSetSelectedCameraDeviceId","videostream","stream","cameraDevice","device","cameraDevices","element","video","videosize","scannerOverlay","videoOverlay","videoElement","videoWidth","videoHeight","foundCameras","navigator","mediaDevices","enumerateDevices","devices","dev","kind","videoStream","getTracks","track","stop","getUserMedia","facingMode","ideal","srcObject","modal","showModal","getBackFacingCameras","backFacingCameras","getAllCameras","allCameras","switchCamera","resizeVideoElement","screenWidth","documentElement","screenHeight","screenAspectRatio","cameraResolution","getVideoResolution","cameraAspectRatio","$set","takePhoto","blob","scanImageForUnitId","createElement","drawImage","toBlob","hideModal","setViewfinderStyle","Barcode","Modal","QDataScannerOverlay","QDataScanning","customerNumber","selectedCustomer","unitsNotFound","tpm","userContacts","contact","responsibility","email","phoneNumber","unitsLookedFor","initializeAndStopTrackPage","route","loadUnitsFromQuery","loadUserContacts","resetSearchTerms","loadUnits","clearUnits","checkIfToShowNotFoundError","newIds","queryIds","onlyUnique","unitsToFind","getUnitsToFind","scanner","trackException","dispatchClear","downloadUnitsQualityDataAsExcel","QDataScanner","column","getDeliveryMessageRoute","getDeliveryQualityData","getDisplayName","isSortable","fixedOnMobile","parametersToShow","showDeliveryLink","getUnitQualityData","psolParameterIds","getPanelList","src","script","setAttribute","async","appendChild"],"mappings":"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","file":"js/qdata.ca99c0ee.js","sourcesContent":["export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--9-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--9-oneOf-1-1!../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--9-oneOf-1-2!../../node_modules/sass-loader/dist/cjs.js??ref--9-oneOf-1-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataSearchBox.vue?vue&type=style&index=0&id=3a53a952&scoped=true&lang=scss&\"","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return (_vm.deliveryMessages.length)?_c('Table',{attrs:{\"columns\":_vm.columns,\"rows\":_vm.rows,\"usePagination\":false,\"checkable\":true,\"disableCheckedActionButton\":_vm.downloadingDataSheet,\"checkedActionButtonText\":_vm.$t('qDataPage.exportToExcel')},on:{\"checkedActionClick\":_vm.onSendCheckedRows,\"rowClick\":_vm.onDeliveryMessageClick,\"checkedAll\":_vm.onCheckedAll}}):_vm._e()}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\r\nimport { Component, Vue, Prop } from 'vue-property-decorator';\r\nimport { DeliveryMessage } from '@/models/QualityData/DeliveryMessage';\r\nimport Table, { TableColumn, TableRow } from './general/Table.vue';\r\nimport { numberFilter } from '@/filters/number';\r\nimport { dateFilter } from '@/filters/date';\r\nimport qualityDataService from '@/services/QualityDataService';\r\nimport { Consoler } from '@/utils/Consoler';\r\nimport { Message, MessageType } from '@/models/Message';\r\nimport { EventBus } from '@/utils/EventBus';\r\nimport { Config } from '@/utils/Config';\r\nimport { DateRange } from '@/models/DateRange';\r\n\r\ninterface DeliveryMessageTableRow extends TableRow {\r\n  deliveryMessage: DeliveryMessage;\r\n}\r\n\r\n@Component({\r\n  components: {\r\n    Table,\r\n  },\r\n})\r\nexport default class QDataDeliveryList extends Vue {\r\n  @Prop({ required: true })\r\n  public deliveryMessages!: DeliveryMessage[];\r\n  @Prop({ required: false })\r\n  private deliveryMessagesRange: DateRange | undefined;\r\n  @Prop({ required: true })\r\n  private totalNumberOfDeliveries!: number;\r\n  @Prop({ required: false })\r\n  private deliveryMessagesProductsSelected: string[] | undefined;\r\n  @Prop({ required: false })\r\n  private searchTerm: string | undefined;\r\n\r\n  private downloadingDataSheet: boolean = false;\r\n  private downloadAll: boolean = false;\r\n\r\n  private get columns(): TableColumn[] {\r\n    return [\r\n      {\r\n        text: this.$t('qDataDeliveryList.number').toString(),\r\n        property: 'number',\r\n      },\r\n      {\r\n        text: this.$t('qDataDeliveryList.customerReference').toString(),\r\n        property: 'customerReference',\r\n      },\r\n      {\r\n        text: this.$t('qDataDeliveryList.orderId').toString(),\r\n        property: 'orderId',\r\n      },\r\n      {\r\n        text: this.$t('qDataDeliveryList.product').toString(),\r\n        property: 'product',\r\n      },\r\n      {\r\n        text: this.$t('qDataDeliveryList.quantity').toString(),\r\n        property: 'quantity',\r\n        alignRight: true,\r\n      },\r\n      {\r\n        text: this.$t('qDataDeliveryList.numberOfUnits').toString(),\r\n        property: 'numberOfUnits',\r\n        alignRight: true,\r\n      },\r\n      {\r\n        text: this.$t('qDataDeliveryList.deliveryDate').toString(),\r\n        property: 'deliveryDate',\r\n      },\r\n      {\r\n        text: this.$t('qDataDeliveryList.destination').toString(),\r\n        property: 'destination',\r\n      },\r\n    ];\r\n  }\r\n\r\n  private get rows(): DeliveryMessageTableRow[] {\r\n    return this.deliveryMessages.map((deliveryMessage) => {\r\n      const properties: { [key: string]: string | number } = {\r\n        number: deliveryMessage.number,\r\n        customerReference: deliveryMessage.customerReference,\r\n        orderId: deliveryMessage.orderId,\r\n        product: this.getProductDisplayNames(deliveryMessage),\r\n        quantity: `${numberFilter(deliveryMessage.totalQuantity) ?? ''} t`,\r\n        numberOfUnits: numberFilter(deliveryMessage.numberOfUnits) ?? '',\r\n        deliveryDate: dateFilter(deliveryMessage.deliveryDate),\r\n        destination: deliveryMessage.deliveryAddressDestinationLocality,\r\n      };\r\n      return {\r\n        properties,\r\n        deliveryMessage,\r\n        isClickable: true,\r\n        isChecked: false,\r\n      };\r\n    });\r\n  }\r\n\r\n  private get isSearchByTerm(): boolean {\r\n    return this.downloadAll && this.searchTerm !== undefined;\r\n  }\r\n\r\n  private get isSearchByDate(): boolean {\r\n    return this.downloadAll && this.deliveryMessagesRange !== undefined;\r\n  }\r\n\r\n  private getProductDisplayNames(deliveryMessage: DeliveryMessage): string {\r\n    return deliveryMessage.details.map((x) => x.productDisplayName).join(',');\r\n  }\r\n\r\n  private onDeliveryMessageClick(row: DeliveryMessageTableRow) {\r\n    this.$emit('click', row.deliveryMessage);\r\n  }\r\n\r\n  private onDownloadExcel() {\r\n    this.$emit('downloadExcel', this.downloadingDataSheet);\r\n  }\r\n\r\n  private onCheckedAll(checkedAll: boolean) {\r\n    this.downloadAll = checkedAll;\r\n  }\r\n\r\n  private onSendCheckedRows(checkedRows: DeliveryMessageTableRow[]) {\r\n    const checkedDeliveryMessages: DeliveryMessage[] = [];\r\n    checkedRows.forEach((row) => {\r\n      checkedDeliveryMessages.push(row.deliveryMessage);\r\n    });\r\n\r\n    this.downloadDataSheet(checkedDeliveryMessages);\r\n  }\r\n\r\n  private async downloadDataSheet(checkedDeliveryMessages: DeliveryMessage[]) {\r\n    this.downloadingDataSheet = true;\r\n    this.onDownloadExcel();\r\n    const deliveryNumbers = checkedDeliveryMessages.map(\r\n      (message) => message.number\r\n    );\r\n\r\n    await qualityDataService\r\n      .downloadDeliveriesQualityDataAsExcel(\r\n        deliveryNumbers,\r\n        undefined,\r\n        this.totalNumberOfDeliveries,\r\n        this.downloadAll,\r\n        this.isSearchByDate ? this.deliveryMessagesRange!.fromDate : undefined,\r\n        this.isSearchByDate ? this.deliveryMessagesRange!.toDate : undefined,\r\n        this.isSearchByDate\r\n          ? this.deliveryMessagesProductsSelected!\r\n          : undefined,\r\n        this.isSearchByTerm ? this.searchTerm : undefined\r\n      )\r\n      .catch((error) => {\r\n        Consoler.debugWarn('Error downloading data sheet', error);\r\n        const errorMessage: Message = {\r\n          text: this.$t('qDataPage.errorDownloadingDataSheet').toString(),\r\n          type: MessageType.error,\r\n        };\r\n        EventBus.$emit(Config.AddMessageEvent, errorMessage);\r\n      })\r\n      .finally(() => {\r\n        this.downloadingDataSheet = false;\r\n        this.onDownloadExcel();\r\n      });\r\n  }\r\n}\r\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataDeliveryList.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataDeliveryList.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./QDataDeliveryList.vue?vue&type=template&id=9615c9f8&\"\nimport script from \"./QDataDeliveryList.vue?vue&type=script&lang=ts&\"\nexport * from \"./QDataDeliveryList.vue?vue&type=script&lang=ts&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('DefaultLayout',[_c('Breadcrumbs',{attrs:{\"items\":_vm.breadcrumbs}}),_c('Messages'),_c('div',{staticClass:\"container-fluid mt-3\"},[_c('h1',{staticClass:\"t-heading-3\"},[_vm._v(_vm._s(_vm.$t('subscriptionsPage.title')))]),_c('span',{staticClass:\"o-line\"}),(_vm.errorLoading)?_c('div',{staticClass:\"c-alert c-alert--red mb-2\"},[_c('span',{staticClass:\"c-alert__text\"},[_vm._v(_vm._s(_vm.$t('subscriptionsPage.errorLoading')))])]):_vm._e(),(!_vm.isLoading && !_vm.errorLoading)?_c('div',{staticClass:\"mt-5\"},[(_vm.subscriptions.length)?_c('div',_vm._l((_vm.subscriptions),function(subscription,index){return _c('div',{key:(index + \"|main\"),staticClass:\"subscription-row d-flex flex-column flex-md-row flex-wrap align-items-md-center justify-content-between u-full-width py-2\"},[_c('SubscriptionQualityDataRow',{attrs:{\"subscription\":subscription},on:{\"edit\":_vm.onEditSubscription,\"create\":_vm.onCreateSubscription,\"delete\":function($event){return _vm.loadSubscriptions(true)},\"restore\":_vm.onRestoreDeletedSubscription}})],1)}),0):_c('div',[_vm._v(_vm._s(_vm.$t('subscriptionsPage.noData')))])]):_vm._e(),(_vm.errorActivating)?_c('div',{staticClass:\"c-alert c-alert--red mt-3\"},[_c('div',{staticClass:\"c-alert__text\"},[_vm._v(\" \"+_vm._s(_vm.$t('subscriptionsPage.errorActivating'))+\" \")]),_c('span',{staticClass:\"c-alert__close\",on:{\"click\":function($event){_vm.errorActivating = false}}})]):_vm._e(),(_vm.errorInactivating)?_c('div',{staticClass:\"c-alert c-alert--red mt-3\"},[_c('div',{staticClass:\"c-alert__text\"},[_vm._v(\" \"+_vm._s(_vm.$t('subscriptionsPage.errorInactivating'))+\" \")]),_c('span',{staticClass:\"c-alert__close\",on:{\"click\":function($event){_vm.errorInactivating = false}}})]):_vm._e(),(_vm.errorRestoring)?_c('div',{staticClass:\"c-alert c-alert--red mt-3\"},[_c('div',{staticClass:\"c-alert__text\"},[_vm._v(\" \"+_vm._s(_vm.$t('subscriptionsPage.errorRestoring'))+\" \")]),_c('span',{staticClass:\"c-alert__close\",on:{\"click\":function($event){_vm.errorRestoring = false}}})]):_vm._e()]),(_vm.createOrUpdateSubscription !== null)?_c('SubscriptionEditorModal',{ref:\"subscriptionEditorModal\",attrs:{\"subscriptionType\":_vm.createOrUpdateSubscription.subscription.type,\"subscriptionInfoDetails\":_vm.createOrUpdateSubscription.details,\"createNotUpdate\":_vm.createOrUpdateSubscription.createNotUpdate},on:{\"created\":_vm.onCreatedSubscription,\"updated\":_vm.onUpdatedSubscription}}):_vm._e()],1)}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:\"u-full-width\"},[_c('div',{staticClass:\"c-accordion c-accordion--light-grey p-0\"},[_c('div',{staticClass:\"c-accordion__item u-border--none\",class:{\n        'is-open': _vm.subscription.isExpanded,\n      }},[_c('a',{staticClass:\"c-accordion__toggle js-accordion-trigger px-0\"},[_c('div',{staticClass:\"d-inline-flex flex-column align-items-start u-color-black\"},[_c('div',{staticClass:\"t-heading-5 mb-1\"},[_vm._v(\" \"+_vm._s(_vm.$t((\"subscriptionTypes.\" + (_vm.subscription.type) + \".title\")))+\" \")]),_c('div',{staticClass:\"line-height-1 t-body-regular-sans-serif\"},[_vm._v(\" \"+_vm._s(_vm.$t((\"subscriptionTypes.\" + (_vm.subscription.type) + \".description\")))+\" \")])])]),_c('div',{staticClass:\"c-accordion__content pl-0 pt-3\"},[_c('div',{staticClass:\"mb-3\"},[_vm._v(\" \"+_vm._s(_vm.$t(\"subscriptionQualityDataRow.description\"))+\" \")]),_c('button',{staticClass:\"o-button--black o-button mb-4\",attrs:{\"type\":\"button\"},on:{\"click\":_vm.onCreateSubscription}},[_vm._v(\" \"+_vm._s(_vm.$t(\"subscriptionQualityDataRow.create\"))+\" \")]),_c('div',{staticClass:\"t-heading-6 u-thin mb-1\"},[_vm._v(\" \"+_vm._s(_vm.$t(\"subscriptionQualityDataRow.subscriptions\"))+\" \")]),(_vm.nonDeletedSubscriptions.length)?_c('div',{staticClass:\"mx-2\"},_vm._l((_vm.nonDeletedSubscriptions),function(subscriptionInfoDetails,index){return _c('SubscriptionQualityDataSubscriptionRow',{key:index,staticClass:\"quality-data-subscription-row py-2\",attrs:{\"subscriptionInfoDetails\":subscriptionInfoDetails},on:{\"edit\":function($event){return _vm.onEditQualityDataSubscription(subscriptionInfoDetails)},\"delete\":function($event){return _vm.onDeleteQualityDataSubscription(subscriptionInfoDetails)}}})}),1):_vm._e(),_c('div',{staticClass:\"o-line o-line--black-20 o-line--thin mb-3\"}),_c('div',{staticClass:\"t-heading-6 u-thin mb-1 mt-2\"},[_vm._v(\" \"+_vm._s(_vm.$t(\"subscriptionQualityDataRow.deletedSubscriptions\"))+\" \")]),(_vm.deletedSubscriptions.length)?_c('div',{staticClass:\"mx-2\"},_vm._l((_vm.deletedSubscriptions),function(subscriptionInfoDetails,index){return _c('SubscriptionQualityDataSubscriptionRow',{key:index,staticClass:\"quality-data-subscription-row py-2\",attrs:{\"deleted\":true,\"subscriptionInfoDetails\":subscriptionInfoDetails},on:{\"restore\":function($event){return _vm.onRestoreQualityDataSubscription(subscriptionInfoDetails)}}})}),1):_vm._e()])])]),(_vm.deleteSubscription !== null)?_c('ConfirmModal',{ref:\"confirmDeleteModal\",attrs:{\"title\":_vm.$t('subscriptionQualityDataRow.confirmDeleteModal.title'),\"description\":_vm.$t('subscriptionQualityDataRow.confirmDeleteModal.description', [\n        _vm.deleteSubscription.name ]),\"confirmButtonText\":_vm.$t('subscriptionQualityDataRow.confirmDeleteModal.delete'),\"confirmIsDanger\":true,\"disabled\":_vm.isDeletingSubscription,\"showError\":_vm.errorDeletingSubscription,\"errorText\":_vm.$t('subscriptionQualityDataRow.confirmDeleteModal.errorText'),\"closeableByOutsideClickAndEscKey\":false},on:{\"confirm\":_vm.onConfirmDeleteSubscription}}):_vm._e()],1)}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',[_c('div',{staticClass:\"row\"},[_c('div',{staticClass:\"col-8 col-lg-4 t-body-regular-small-bold\"},[_c('span',[_vm._v(_vm._s(_vm.subscriptionInfoDetails.name))]),(!_vm.deleted)?_c('a',{staticClass:\"ml-2\",attrs:{\"href\":\"\"},on:{\"click\":function($event){$event.preventDefault();return _vm.onEditClick.apply(null, arguments)}}},[_vm._v(_vm._s(_vm.$t('subscriptionQualityDataSubscriptionRow.edit')))]):_vm._e(),(!_vm.deleted && _vm.canEdit)?_c('a',{staticClass:\"ml-2\",attrs:{\"href\":\"\"},on:{\"click\":function($event){$event.preventDefault();return _vm.onDeleteClick.apply(null, arguments)}}},[_vm._v(_vm._s(_vm.$t('subscriptionQualityDataSubscriptionRow.delete')))]):_vm._e(),(_vm.deleted && _vm.canEdit)?_c('a',{staticClass:\"ml-2\",attrs:{\"href\":\"\"},on:{\"click\":function($event){$event.preventDefault();return _vm.onRestoreClick.apply(null, arguments)}}},[_vm._v(_vm._s(_vm.$t('subscriptionQualityDataSubscriptionRow.restore')))]):_vm._e()]),_c('div',{staticClass:\"col-12 col-lg-4 order-last order-lg-0\"},[_c('span',[_vm._v(_vm._s(_vm.descriptionText))])]),_c('div',{staticClass:\"col-4\"},[_c('div',{staticClass:\"u-align-right\"},[(!_vm.deleted)?_c('SubscriptionActiveSwitch',{attrs:{\"subscriptionType\":_vm.SubscriptionType,\"subscriptionInfoDetails\":_vm.subscriptionInfoDetails}}):_vm._e()],1)])])])}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\r\nimport { Component, Prop, Vue } from 'vue-property-decorator';\r\nimport SubscriptionEditorModal from '@/components/SubscriptionEditorModal.vue';\r\nimport SubscriptionActiveSwitch from './SubscriptionActiveSwitch.vue';\r\nimport { SubscriptionInfoDetails } from '@/models/Subscriptions/SubscriptionInfoDetails';\r\nimport { SubscriptionType } from '@/models/Subscriptions/SubscriptionType';\r\nimport { PermissionType } from '@/models/UserProfile/PermissionType';\r\nimport { Permissions } from '@/utils/Permissions';\r\n\r\n@Component({\r\n  components: { SubscriptionEditorModal, SubscriptionActiveSwitch },\r\n})\r\nexport default class SubscriptionQualityDataSubscriptionRow extends Vue {\r\n  @Prop({ required: true })\r\n  public subscriptionInfoDetails!: SubscriptionInfoDetails;\r\n  @Prop({ required: false, default: () => false })\r\n  public deleted!: boolean;\r\n\r\n  private readonly SubscriptionType: SubscriptionType =\r\n    SubscriptionType.QualityData;\r\n\r\n  private get descriptionText(): string {\r\n    return this.$t('subscriptionQualityDataSubscriptionRow.description.base', [\r\n      this.$t(\r\n        `userSubscriptionQualityDataFrequency.${this.subscriptionInfoDetails.qualityData?.frequency}`\r\n      ),\r\n      this.customersText,\r\n      this.productsText,\r\n      this.parametersText,\r\n    ]).toString();\r\n  }\r\n\r\n  private get customersText(): string {\r\n    return this.$tc(\r\n      'pluralization.customers',\r\n      this.subscriptionInfoDetails.enableForAllMyCustomers\r\n        ? 999\r\n        : this.subscriptionInfoDetails.enableForSpecificCustomerIds.length,\r\n      {\r\n        n: this.subscriptionInfoDetails.enableForAllMyCustomers\r\n          ? this.allText\r\n          : this.subscriptionInfoDetails.enableForSpecificCustomerIds.length,\r\n      }\r\n    ).toLowerCase();\r\n  }\r\n\r\n  private get productsText(): string {\r\n    return this.$tc(\r\n      'pluralization.products',\r\n      this.subscriptionInfoDetails.enableForAllMyProducts\r\n        ? 999\r\n        : this.subscriptionInfoDetails.enableForSpecificProductNames.length,\r\n      {\r\n        n: this.subscriptionInfoDetails.enableForAllMyProducts\r\n          ? this.allText\r\n          : this.subscriptionInfoDetails.enableForSpecificProductNames.length,\r\n      }\r\n    ).toLowerCase();\r\n  }\r\n\r\n  private get parametersText(): string {\r\n    // \"all paper & textile parameters\"\r\n    if (\r\n      this.subscriptionInfoDetails.enableForAllMyPaperParameters &&\r\n      this.subscriptionInfoDetails.enableForAllMyTextileParameters\r\n    ) {\r\n      return this.$t(\r\n        'subscriptionQualityDataSubscriptionRow.description.parameter.allPaperAndTextile'\r\n      ).toString();\r\n    }\r\n\r\n    const paperParametersCount: number = this.subscriptionInfoDetails\r\n      .enableForAllMyPaperParameters\r\n      ? 999\r\n      : this.subscriptionInfoDetails.enableForSpecificParameters.filter(\r\n          (p) => p.enabledForPaperPulp\r\n        ).length;\r\n    const textileParametersCount: number = this.subscriptionInfoDetails\r\n      .enableForAllMyTextileParameters\r\n      ? 999\r\n      : this.subscriptionInfoDetails.enableForSpecificParameters.filter(\r\n          (p) => p.enabledForTextilePulp\r\n        ).length;\r\n\r\n    // \"all/X paper parameters, all/X textile parameters\"\r\n    if (\r\n      (this.subscriptionInfoDetails.enableForAllMyPaperParameters ||\r\n        this.subscriptionInfoDetails.enableForSpecificParameters.some(\r\n          (p) => p.enabledForPaperPulp\r\n        )) &&\r\n      (this.subscriptionInfoDetails.enableForAllMyTextileParameters ||\r\n        this.subscriptionInfoDetails.enableForSpecificParameters.some(\r\n          (p) => p.enabledForTextilePulp\r\n        ))\r\n    ) {\r\n      return this.$t(\r\n        'subscriptionQualityDataSubscriptionRow.description.parameter.paperAndTextile',\r\n        [\r\n          this.subscriptionInfoDetails.enableForAllMyPaperParameters\r\n            ? this.allText\r\n            : paperParametersCount.toString(),\r\n          this.$tc(\r\n            'pluralization.parametersWithoutNumber',\r\n            paperParametersCount,\r\n            {\r\n              n: this.subscriptionInfoDetails.enableForAllMyPaperParameters\r\n                ? this.allText\r\n                : paperParametersCount,\r\n            }\r\n          ).toLowerCase(),\r\n          this.subscriptionInfoDetails.enableForAllMyTextileParameters\r\n            ? this.allText\r\n            : textileParametersCount.toString(),\r\n          this.$tc(\r\n            'pluralization.parametersWithoutNumber',\r\n            textileParametersCount,\r\n            {\r\n              n: this.subscriptionInfoDetails.enableForAllMyTextileParameters\r\n                ? this.allText\r\n                : textileParametersCount,\r\n            }\r\n          ).toLowerCase(),\r\n        ]\r\n      ).toString();\r\n    }\r\n\r\n    // \"all/X parameters\" (when only paper)\r\n    if (\r\n      this.subscriptionInfoDetails.enableForAllMyPaperParameters ||\r\n      this.subscriptionInfoDetails.enableForSpecificParameters.some(\r\n        (p) => p.enabledForPaperPulp\r\n      )\r\n    ) {\r\n      return this.$t(\r\n        'subscriptionQualityDataSubscriptionRow.description.parameter.paperOrTextile',\r\n        [\r\n          this.subscriptionInfoDetails.enableForAllMyPaperParameters\r\n            ? this.allText\r\n            : paperParametersCount.toString(),\r\n          this.$tc(\r\n            'pluralization.parametersWithoutNumber',\r\n            paperParametersCount,\r\n            {\r\n              n: this.subscriptionInfoDetails.enableForAllMyPaperParameters\r\n                ? this.allText\r\n                : paperParametersCount,\r\n            }\r\n          ).toLowerCase(),\r\n        ]\r\n      ).toString();\r\n    }\r\n\r\n    // \"all/X parameters\" (when only textile)\r\n    if (\r\n      this.subscriptionInfoDetails.enableForAllMyTextileParameters ||\r\n      this.subscriptionInfoDetails.enableForSpecificParameters.some(\r\n        (p) => p.enabledForTextilePulp\r\n      )\r\n    ) {\r\n      return this.$t(\r\n        'subscriptionQualityDataSubscriptionRow.description.parameter.paperOrTextile',\r\n        [\r\n          this.subscriptionInfoDetails.enableForAllMyTextileParameters\r\n            ? this.allText\r\n            : textileParametersCount.toString(),\r\n          this.$tc(\r\n            'pluralization.parametersWithoutNumber',\r\n            textileParametersCount,\r\n            {\r\n              n: this.subscriptionInfoDetails.enableForAllMyTextileParameters\r\n                ? this.allText\r\n                : textileParametersCount,\r\n            }\r\n          ).toLowerCase(),\r\n        ]\r\n      ).toString();\r\n    }\r\n\r\n    return '';\r\n  }\r\n\r\n  private get canEdit(): boolean {\r\n    return Permissions.hasPermission(\r\n      PermissionType.IsAllowedToEditSubscriptions\r\n    );\r\n  }\r\n\r\n  private get allText(): string {\r\n    return this.$t('subscriptionQualityDataSubscriptionRow.all').toString();\r\n  }\r\n\r\n  private onEditClick(): void {\r\n    this.$emit('edit');\r\n  }\r\n\r\n  private onDeleteClick(): void {\r\n    this.$emit('delete');\r\n  }\r\n\r\n  private onRestoreClick(): void {\r\n    this.$emit('restore');\r\n  }\r\n}\r\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./SubscriptionQualityDataSubscriptionRow.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./SubscriptionQualityDataSubscriptionRow.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./SubscriptionQualityDataSubscriptionRow.vue?vue&type=template&id=8344541e&\"\nimport script from \"./SubscriptionQualityDataSubscriptionRow.vue?vue&type=script&lang=ts&\"\nexport * from \"./SubscriptionQualityDataSubscriptionRow.vue?vue&type=script&lang=ts&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\r\nimport { Component, Prop, Vue } from 'vue-property-decorator';\r\nimport { SubscriptionInfo } from '@/models/Subscriptions/SubscriptionInfo';\r\nimport { SubscriptionInfoDetails } from '@/models/Subscriptions/SubscriptionInfoDetails';\r\nimport { SubscriptionType } from '@/models/Subscriptions/SubscriptionType';\r\nimport SubscriptionQualityDataSubscriptionRow from './SubscriptionQualityDataSubscriptionRow.vue';\r\nimport ConfirmModal from './general/ConfirmModal.vue';\r\nimport { subscriptionsModule } from '@/store/modules/subscriptions';\r\n\r\n@Component({\r\n  components: {\r\n    SubscriptionQualityDataSubscriptionRow,\r\n    ConfirmModal,\r\n  },\r\n})\r\nexport default class SubscriptionQualityDataRow extends Vue {\r\n  @Prop({ required: true })\r\n  public subscription!: SubscriptionInfo;\r\n\r\n  private deleteSubscription: SubscriptionInfoDetails | null = null;\r\n  private isDeletingSubscription: boolean = false;\r\n  private errorDeletingSubscription: boolean = false;\r\n  private isRestoringSubscription: boolean = false;\r\n  private errorRestoringSubscription: boolean = false;\r\n\r\n  private get nonDeletedSubscriptions(): SubscriptionInfoDetails[] {\r\n    return this.subscription.subscriptions.filter(\r\n      (subscription) =>\r\n        subscription.deletedDate === null ||\r\n        subscription.deletedDate === undefined\r\n    );\r\n  }\r\n\r\n  private get deletedSubscriptions(): SubscriptionInfoDetails[] {\r\n    return this.subscription.subscriptions.filter(\r\n      (subscription) =>\r\n        subscription.deletedDate !== null &&\r\n        subscription.deletedDate !== undefined\r\n    );\r\n  }\r\n\r\n  private onRestoreQualityDataSubscription(\r\n    subscriptionDetails: SubscriptionInfoDetails\r\n  ): void {\r\n    this.$emit('restore', this.subscription, subscriptionDetails);\r\n  }\r\n\r\n  private onCreateSubscription(): void {\r\n    this.$emit('create', this.subscription);\r\n  }\r\n\r\n  private onEditQualityDataSubscription(\r\n    subscriptionDetails: SubscriptionInfoDetails\r\n  ): void {\r\n    this.$emit('edit', this.subscription, subscriptionDetails);\r\n  }\r\n\r\n  private onDeleteQualityDataSubscription(\r\n    subscription: SubscriptionInfoDetails\r\n  ): void {\r\n    this.errorDeletingSubscription = false;\r\n    this.isDeletingSubscription = false;\r\n    this.deleteSubscription = subscription;\r\n\r\n    this.$nextTick(() => {\r\n      (this.$refs.confirmDeleteModal as ConfirmModal).show();\r\n    });\r\n  }\r\n\r\n  private onConfirmDeleteSubscription(): void {\r\n    if (this.deleteSubscription === null) {\r\n      return;\r\n    }\r\n\r\n    this.errorDeletingSubscription = false;\r\n    this.isDeletingSubscription = true;\r\n\r\n    subscriptionsModule\r\n      .dispatchDelete({\r\n        id: this.deleteSubscription.id,\r\n        subscriptionType: SubscriptionType.QualityData,\r\n      })\r\n      .then(() => {\r\n        this.deleteSubscription = null;\r\n        this.$emit('delete');\r\n      })\r\n      .catch(() => {\r\n        this.errorDeletingSubscription = true;\r\n      })\r\n      .finally(() => {\r\n        this.isDeletingSubscription = false;\r\n      });\r\n  }\r\n}\r\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./SubscriptionQualityDataRow.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./SubscriptionQualityDataRow.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./SubscriptionQualityDataRow.vue?vue&type=template&id=6f71fcdb&\"\nimport script from \"./SubscriptionQualityDataRow.vue?vue&type=script&lang=ts&\"\nexport * from \"./SubscriptionQualityDataRow.vue?vue&type=script&lang=ts&\"\nimport style0 from \"./SubscriptionQualityDataRow.vue?vue&type=style&index=0&lang=scss&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\r\nimport { Component, Vue } from 'vue-property-decorator';\r\nimport DefaultLayout from '@/layouts/DefaultLayout.vue';\r\nimport Breadcrumbs from '@/components/general/Breadcrumbs.vue';\r\nimport Messages from '@/components/general/Messages.vue';\r\nimport SubscriptionEditorModal from '@/components/SubscriptionEditorModal.vue';\r\nimport { subscriptionsModule } from '@/store/modules/subscriptions';\r\nimport { loadingModule } from '@/store/modules/loading';\r\nimport { SubscriptionInfo } from '@/models/Subscriptions/SubscriptionInfo';\r\nimport { SubscriptionType } from '@/models/Subscriptions/SubscriptionType';\r\nimport { routeNameQDataSubscriptions } from '@/router/routes';\r\nimport { Breadcrumb } from '@/models/Breadcrumb';\r\nimport telemetryService, {\r\n  RouteTrackingInfo,\r\n} from '@/services/TelemetryService';\r\nimport { getRouteTrackingInfo } from '@/router/functions';\r\nimport SubscriptionQualityDataRow from '@/components/SubscriptionQualityDataRow.vue';\r\nimport { SubscriptionInfoDetails } from '@/models/Subscriptions/SubscriptionInfoDetails';\r\n\r\n@Component({\r\n  components: {\r\n    DefaultLayout,\r\n    Breadcrumbs,\r\n    Messages,\r\n    SubscriptionEditorModal,\r\n    SubscriptionQualityDataRow,\r\n  },\r\n})\r\nexport default class QDataSubscriptionsPage extends Vue {\r\n  private readonly SubscriptionType = SubscriptionType;\r\n\r\n  private routeTrackingInfo: RouteTrackingInfo = {};\r\n  private errorLoading: boolean = false;\r\n  private errorActivating: boolean = false;\r\n  private errorInactivating: boolean = false;\r\n  private errorRestoring: boolean = false;\r\n  private createOrUpdateSubscription: {\r\n    createNotUpdate: boolean;\r\n    subscription: SubscriptionInfo;\r\n    details: SubscriptionInfoDetails | null;\r\n  } | null = null;\r\n  private updatingSubscriptionType: SubscriptionType | null = null;\r\n\r\n  private get isLoading(): boolean {\r\n    return loadingModule.isLoading;\r\n  }\r\n\r\n  private get subscriptions(): SubscriptionInfo[] {\r\n    const allSubscriptions = subscriptionsModule.subscriptions ?? [];\r\n    return allSubscriptions.filter(\r\n      (subscription) => subscription.type === SubscriptionType.QualityData\r\n    );\r\n  }\r\n\r\n  private get breadcrumbs(): Breadcrumb[] {\r\n    return [\r\n      {\r\n        routeName: routeNameQDataSubscriptions,\r\n        name: this.$t('breadcrumbs.' + routeNameQDataSubscriptions).toString(),\r\n      },\r\n    ];\r\n  }\r\n\r\n  private created(): void {\r\n    this.routeTrackingInfo = getRouteTrackingInfo(this.$route);\r\n    this.loadSubscriptions().finally(() => {\r\n      telemetryService.stopTrackPage(this.routeTrackingInfo);\r\n    });\r\n  }\r\n\r\n  private async loadSubscriptions(force?: boolean): Promise<void> {\r\n    this.errorLoading = false;\r\n    const loading = await loadingModule.dispatchAdd(\r\n      this.$t('loading.subscriptions').toString()\r\n    );\r\n\r\n    return subscriptionsModule\r\n      .dispatchLoad(force === true ? { force } : undefined)\r\n      .catch(() => {\r\n        this.errorLoading = true;\r\n      })\r\n      .finally(() => {\r\n        loadingModule.commitComplete(loading);\r\n      });\r\n  }\r\n\r\n  private onCreateSubscription(subscription: SubscriptionInfo): void {\r\n    this.createOrUpdateSubscription = {\r\n      createNotUpdate: true,\r\n      subscription,\r\n      details: null,\r\n    };\r\n\r\n    this.$nextTick(() => {\r\n      (this.$refs.subscriptionEditorModal as SubscriptionEditorModal).show();\r\n    });\r\n  }\r\n\r\n  private onEditSubscription(\r\n    subscription: SubscriptionInfo,\r\n    details: SubscriptionInfoDetails\r\n  ): void {\r\n    this.createOrUpdateSubscription = {\r\n      createNotUpdate: false,\r\n      subscription,\r\n      details,\r\n    };\r\n\r\n    this.$nextTick(() => {\r\n      (this.$refs.subscriptionEditorModal as SubscriptionEditorModal).show();\r\n    });\r\n  }\r\n\r\n  private onActivateSubscription(\r\n    subscription: SubscriptionInfo,\r\n    subscriptionDetails: SubscriptionInfoDetails\r\n  ): void {\r\n    this.changeActiveStatusForSubscription(\r\n      subscription,\r\n      subscriptionDetails,\r\n      true\r\n    );\r\n  }\r\n  private onInactivateSubscription(\r\n    subscription: SubscriptionInfo,\r\n    subscriptionDetails: SubscriptionInfoDetails\r\n  ): void {\r\n    this.changeActiveStatusForSubscription(\r\n      subscription,\r\n      subscriptionDetails,\r\n      false\r\n    );\r\n  }\r\n\r\n  private async onRestoreDeletedSubscription(\r\n    subscription: SubscriptionInfo,\r\n    subscriptionDetails: SubscriptionInfoDetails\r\n  ): Promise<void> {\r\n    this.errorRestoring = false;\r\n\r\n    const loading = await loadingModule.dispatchAdd(\r\n      this.$t('loading.restoringSubscription').toString()\r\n    );\r\n\r\n    subscriptionsModule\r\n      .dispatchRestore({\r\n        id: subscriptionDetails.id,\r\n        model: subscription,\r\n      })\r\n      .then(() => {\r\n        this.loadSubscriptions(true);\r\n      })\r\n      .catch(() => {\r\n        this.errorRestoring = true;\r\n      })\r\n      .finally(() => {\r\n        loadingModule.commitComplete(loading);\r\n      });\r\n  }\r\n\r\n  private changeActiveStatusForSubscription(\r\n    subscription: SubscriptionInfo,\r\n    subscriptionDetails: SubscriptionInfoDetails,\r\n    active: boolean\r\n  ): void {\r\n    this.errorActivating = false;\r\n    this.errorInactivating = false;\r\n    this.updatingSubscriptionType = subscription.type;\r\n\r\n    subscriptionsModule\r\n      .dispatchChangeActiveStatus({\r\n        id: subscriptionDetails.id,\r\n        model: {\r\n          type: subscription.type,\r\n          active,\r\n        },\r\n      })\r\n      .then(() => {\r\n        this.loadSubscriptions(true);\r\n      })\r\n      .catch(() => {\r\n        if (active) {\r\n          this.errorActivating = true;\r\n        } else {\r\n          this.errorInactivating = true;\r\n        }\r\n\r\n        // Reset the subscribe status\r\n        subscription.isSubscribed = !subscription.isSubscribed;\r\n      })\r\n      .finally(() => {\r\n        this.updatingSubscriptionType = null;\r\n      });\r\n  }\r\n\r\n  private onCreatedSubscription(): void {\r\n    this.createOrUpdateSubscription = null;\r\n    this.loadSubscriptions(true);\r\n  }\r\n\r\n  private onUpdatedSubscription(): void {\r\n    this.createOrUpdateSubscription = null;\r\n    this.loadSubscriptions(true);\r\n  }\r\n}\r\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataSubscriptionsPage.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataSubscriptionsPage.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./QDataSubscriptionsPage.vue?vue&type=template&id=9ef0aa96&\"\nimport script from \"./QDataSubscriptionsPage.vue?vue&type=script&lang=ts&\"\nexport * from \"./QDataSubscriptionsPage.vue?vue&type=script&lang=ts&\"\nimport style0 from \"./QDataSubscriptionsPage.vue?vue&type=style&index=0&lang=scss&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--9-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--9-oneOf-1-1!../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--9-oneOf-1-2!../../node_modules/sass-loader/dist/cjs.js??ref--9-oneOf-1-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataDeliveryPage.vue?vue&type=style&index=0&id=88cf523c&scoped=true&lang=scss&\"","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--9-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--9-oneOf-1-1!../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--9-oneOf-1-2!../../node_modules/sass-loader/dist/cjs.js??ref--9-oneOf-1-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataPredictedParametersList.vue?vue&type=style&index=0&id=57af7754&scoped=true&lang=scss&\"","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--9-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--9-oneOf-1-1!../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--9-oneOf-1-2!../../node_modules/sass-loader/dist/cjs.js??ref--9-oneOf-1-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataScanner.vue?vue&type=style&index=0&id=58cee623&scoped=true&lang=scss&\"","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--9-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--9-oneOf-1-1!../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--9-oneOf-1-2!../../node_modules/sass-loader/dist/cjs.js??ref--9-oneOf-1-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataDeliveryMessagesFilter.vue?vue&type=style&index=0&id=82f2148e&scoped=true&lang=scss&\"","/**\n * @license\n * Lodash <https://lodash.com/>\n * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n;(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    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#39;'\n  };\n\n  /** Used to map HTML entities to characters. */\n  var htmlUnescapes = {\n    '&amp;': '&',\n    '&lt;': '<',\n    '&gt;': '>',\n    '&quot;': '\"',\n    '&#39;': \"'\"\n  };\n\n  /** Used to escape characters for inclusion in compiled string literals. */\n  var stringEscapes = {\n    '\\\\': '\\\\',\n    \"'\": \"'\",\n    '\\n': 'n',\n    '\\r': 'r',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  /** Built-in method references without a dependency on `root`. */\n  var freeParseFloat = parseFloat,\n      freeParseInt = parseInt;\n\n  /** Detect free variable `global` from Node.js. */\n  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n  /** Detect free variable `self`. */\n  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n  /** Used as a reference to the global object. */\n  var root = freeGlobal || freeSelf || Function('return this')();\n\n  /** Detect free variable `exports`. */\n  var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n  /** Detect free variable `module`. */\n  var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n  /** Detect the popular CommonJS extension `module.exports`. */\n  var moduleExports = freeModule && freeModule.exports === freeExports;\n\n  /** Detect free variable `process` from Node.js. */\n  var freeProcess = moduleExports && freeGlobal.process;\n\n  /** Used to access faster Node.js helpers. */\n  var nodeUtil = (function() {\n    try {\n      // 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 '<p>' + func(text) + '</p>';\n     * });\n     *\n     * p('fred, barney, & pebbles');\n     * // => '<p>fred, barney, &amp; pebbles</p>'\n     */\n    function wrap(value, wrapper) {\n      return partial(castFunction(wrapper), value);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Casts `value` as an array if it's not one.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.4.0\n     * @category Lang\n     * @param {*} value The value to inspect.\n     * @returns {Array} Returns the cast array.\n     * @example\n     *\n     * _.castArray(1);\n     * // => [1]\n     *\n     * _.castArray({ 'a': 1 });\n     * // => [{ 'a': 1 }]\n     *\n     * _.castArray('abc');\n     * // => ['abc']\n     *\n     * _.castArray(null);\n     * // => [null]\n     *\n     * _.castArray(undefined);\n     * // => [undefined]\n     *\n     * _.castArray();\n     * // => []\n     *\n     * var array = [1, 2, 3];\n     * console.log(_.castArray(array) === array);\n     * // => true\n     */\n    function castArray() {\n      if (!arguments.length) {\n        return [];\n      }\n      var value = arguments[0];\n      return isArray(value) ? value : [value];\n    }\n\n    /**\n     * Creates a shallow clone of `value`.\n     *\n     * **Note:** This method is loosely based on the\n     * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)\n     * and supports cloning arrays, array buffers, booleans, date objects, maps,\n     * numbers, `Object` objects, regexes, sets, strings, symbols, and typed\n     * arrays. The own enumerable properties of `arguments` objects are cloned\n     * as plain objects. An empty object is returned for uncloneable values such\n     * as error objects, functions, DOM nodes, and WeakMaps.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to clone.\n     * @returns {*} Returns the cloned value.\n     * @see _.cloneDeep\n     * @example\n     *\n     * var objects = [{ 'a': 1 }, { 'b': 2 }];\n     *\n     * var shallow = _.clone(objects);\n     * console.log(shallow[0] === objects[0]);\n     * // => true\n     */\n    function clone(value) {\n      return baseClone(value, CLONE_SYMBOLS_FLAG);\n    }\n\n    /**\n     * This method is like `_.clone` except that it accepts `customizer` which\n     * is invoked to produce the cloned value. If `customizer` returns `undefined`,\n     * cloning is handled by the method instead. The `customizer` is invoked with\n     * up to four arguments; (value [, index|key, object, stack]).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to clone.\n     * @param {Function} [customizer] The function to customize cloning.\n     * @returns {*} Returns the cloned value.\n     * @see _.cloneDeepWith\n     * @example\n     *\n     * function customizer(value) {\n     *   if (_.isElement(value)) {\n     *     return value.cloneNode(false);\n     *   }\n     * }\n     *\n     * var el = _.cloneWith(document.body, customizer);\n     *\n     * console.log(el === document.body);\n     * // => false\n     * console.log(el.nodeName);\n     * // => 'BODY'\n     * console.log(el.childNodes.length);\n     * // => 0\n     */\n    function cloneWith(value, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);\n    }\n\n    /**\n     * This method is like `_.clone` except that it recursively clones `value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.0.0\n     * @category Lang\n     * @param {*} value The value to recursively clone.\n     * @returns {*} Returns the deep cloned value.\n     * @see _.clone\n     * @example\n     *\n     * var objects = [{ 'a': 1 }, { 'b': 2 }];\n     *\n     * var deep = _.cloneDeep(objects);\n     * console.log(deep[0] === objects[0]);\n     * // => false\n     */\n    function cloneDeep(value) {\n      return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);\n    }\n\n    /**\n     * This method is like `_.cloneWith` except that it recursively clones `value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to recursively clone.\n     * @param {Function} [customizer] The function to customize cloning.\n     * @returns {*} Returns the deep cloned value.\n     * @see _.cloneWith\n     * @example\n     *\n     * function customizer(value) {\n     *   if (_.isElement(value)) {\n     *     return value.cloneNode(true);\n     *   }\n     * }\n     *\n     * var el = _.cloneDeepWith(document.body, customizer);\n     *\n     * console.log(el === document.body);\n     * // => false\n     * console.log(el.nodeName);\n     * // => 'BODY'\n     * console.log(el.childNodes.length);\n     * // => 20\n     */\n    function cloneDeepWith(value, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);\n    }\n\n    /**\n     * Checks if `object` conforms to `source` by invoking the predicate\n     * properties of `source` with the corresponding property values of `object`.\n     *\n     * **Note:** This method is equivalent to `_.conforms` when `source` is\n     * partially applied.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.14.0\n     * @category Lang\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {boolean} Returns `true` if `object` conforms, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2 };\n     *\n     * _.conformsTo(object, { 'b': function(n) { return n > 1; } });\n     * // => true\n     *\n     * _.conformsTo(object, { 'b': function(n) { return n > 2; } });\n     * // => false\n     */\n    function conformsTo(object, source) {\n      return source == null || baseConformsTo(object, source, keys(source));\n    }\n\n    /**\n     * Performs a\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * comparison between two values to determine if they are equivalent.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1 };\n     * var other = { 'a': 1 };\n     *\n     * _.eq(object, object);\n     * // => true\n     *\n     * _.eq(object, other);\n     * // => false\n     *\n     * _.eq('a', 'a');\n     * // => true\n     *\n     * _.eq('a', Object('a'));\n     * // => false\n     *\n     * _.eq(NaN, NaN);\n     * // => true\n     */\n    function eq(value, other) {\n      return value === other || (value !== value && other !== other);\n    }\n\n    /**\n     * Checks if `value` is greater than `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is greater than `other`,\n     *  else `false`.\n     * @see _.lt\n     * @example\n     *\n     * _.gt(3, 1);\n     * // => true\n     *\n     * _.gt(3, 3);\n     * // => false\n     *\n     * _.gt(1, 3);\n     * // => false\n     */\n    var gt = createRelationalOperation(baseGt);\n\n    /**\n     * Checks if `value` is greater than or equal to `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is greater than or equal to\n     *  `other`, else `false`.\n     * @see _.lte\n     * @example\n     *\n     * _.gte(3, 1);\n     * // => true\n     *\n     * _.gte(3, 3);\n     * // => true\n     *\n     * _.gte(1, 3);\n     * // => false\n     */\n    var gte = createRelationalOperation(function(value, other) {\n      return value >= other;\n    });\n\n    /**\n     * Checks if `value` is likely an `arguments` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n     *  else `false`.\n     * @example\n     *\n     * _.isArguments(function() { return arguments; }());\n     * // => true\n     *\n     * _.isArguments([1, 2, 3]);\n     * // => false\n     */\n    var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n      return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n        !propertyIsEnumerable.call(value, 'callee');\n    };\n\n    /**\n     * Checks if `value` is classified as an `Array` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n     * @example\n     *\n     * _.isArray([1, 2, 3]);\n     * // => true\n     *\n     * _.isArray(document.body.children);\n     * // => false\n     *\n     * _.isArray('abc');\n     * // => false\n     *\n     * _.isArray(_.noop);\n     * // => false\n     */\n    var isArray = Array.isArray;\n\n    /**\n     * Checks if `value` is classified as an `ArrayBuffer` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.\n     * @example\n     *\n     * _.isArrayBuffer(new ArrayBuffer(2));\n     * // => true\n     *\n     * _.isArrayBuffer(new Array(2));\n     * // => false\n     */\n    var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;\n\n    /**\n     * Checks if `value` is array-like. A value is considered array-like if it's\n     * not a function and has a `value.length` that's an integer greater than or\n     * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n     * @example\n     *\n     * _.isArrayLike([1, 2, 3]);\n     * // => true\n     *\n     * _.isArrayLike(document.body.children);\n     * // => true\n     *\n     * _.isArrayLike('abc');\n     * // => true\n     *\n     * _.isArrayLike(_.noop);\n     * // => false\n     */\n    function isArrayLike(value) {\n      return value != null && isLength(value.length) && !isFunction(value);\n    }\n\n    /**\n     * This method is like `_.isArrayLike` except that it also checks if `value`\n     * is an object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array-like object,\n     *  else `false`.\n     * @example\n     *\n     * _.isArrayLikeObject([1, 2, 3]);\n     * // => true\n     *\n     * _.isArrayLikeObject(document.body.children);\n     * // => true\n     *\n     * _.isArrayLikeObject('abc');\n     * // => false\n     *\n     * _.isArrayLikeObject(_.noop);\n     * // => false\n     */\n    function isArrayLikeObject(value) {\n      return isObjectLike(value) && isArrayLike(value);\n    }\n\n    /**\n     * Checks if `value` is classified as a boolean primitive or object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a boolean, else `false`.\n     * @example\n     *\n     * _.isBoolean(false);\n     * // => true\n     *\n     * _.isBoolean(null);\n     * // => false\n     */\n    function isBoolean(value) {\n      return value === true || value === false ||\n        (isObjectLike(value) && baseGetTag(value) == boolTag);\n    }\n\n    /**\n     * Checks if `value` is a buffer.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n     * @example\n     *\n     * _.isBuffer(new Buffer(2));\n     * // => true\n     *\n     * _.isBuffer(new Uint8Array(2));\n     * // => false\n     */\n    var isBuffer = nativeIsBuffer || stubFalse;\n\n    /**\n     * Checks if `value` is classified as a `Date` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a date object, else `false`.\n     * @example\n     *\n     * _.isDate(new Date);\n     * // => true\n     *\n     * _.isDate('Mon April 23 2012');\n     * // => false\n     */\n    var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;\n\n    /**\n     * Checks if `value` is likely a DOM element.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.\n     * @example\n     *\n     * _.isElement(document.body);\n     * // => true\n     *\n     * _.isElement('<body>');\n     * // => false\n     */\n    function isElement(value) {\n      return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);\n    }\n\n    /**\n     * Checks if `value` is an empty object, collection, map, or set.\n     *\n     * Objects are considered empty if they have no own enumerable string keyed\n     * properties.\n     *\n     * Array-like values such as `arguments` objects, arrays, buffers, strings, or\n     * jQuery-like collections are considered empty if they have a `length` of `0`.\n     * Similarly, maps and sets are considered empty if they have a `size` of `0`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is empty, else `false`.\n     * @example\n     *\n     * _.isEmpty(null);\n     * // => true\n     *\n     * _.isEmpty(true);\n     * // => true\n     *\n     * _.isEmpty(1);\n     * // => true\n     *\n     * _.isEmpty([1, 2, 3]);\n     * // => false\n     *\n     * _.isEmpty({ 'a': 1 });\n     * // => false\n     */\n    function isEmpty(value) {\n      if (value == null) {\n        return true;\n      }\n      if (isArrayLike(value) &&\n          (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||\n            isBuffer(value) || isTypedArray(value) || isArguments(value))) {\n        return !value.length;\n      }\n      var tag = getTag(value);\n      if (tag == mapTag || tag == setTag) {\n        return !value.size;\n      }\n      if (isPrototype(value)) {\n        return !baseKeys(value).length;\n      }\n      for (var key in value) {\n        if (hasOwnProperty.call(value, key)) {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    /**\n     * Performs a deep comparison between two values to determine if they are\n     * equivalent.\n     *\n     * **Note:** This method supports comparing arrays, array buffers, booleans,\n     * date objects, error objects, maps, numbers, `Object` objects, regexes,\n     * sets, strings, symbols, and typed arrays. `Object` objects are compared\n     * by their own, not inherited, enumerable properties. Functions and DOM\n     * nodes are compared by strict equality, i.e. `===`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1 };\n     * var other = { 'a': 1 };\n     *\n     * _.isEqual(object, other);\n     * // => true\n     *\n     * object === other;\n     * // => false\n     */\n    function isEqual(value, other) {\n      return baseIsEqual(value, other);\n    }\n\n    /**\n     * This method is like `_.isEqual` except that it accepts `customizer` which\n     * is invoked to compare values. If `customizer` returns `undefined`, comparisons\n     * are handled by the method instead. The `customizer` is invoked with up to\n     * six arguments: (objValue, othValue [, index|key, object, other, stack]).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     * @example\n     *\n     * function isGreeting(value) {\n     *   return /^h(?:i|ello)$/.test(value);\n     * }\n     *\n     * function customizer(objValue, othValue) {\n     *   if (isGreeting(objValue) && isGreeting(othValue)) {\n     *     return true;\n     *   }\n     * }\n     *\n     * var array = ['hello', 'goodbye'];\n     * var other = ['hi', 'goodbye'];\n     *\n     * _.isEqualWith(array, other, customizer);\n     * // => true\n     */\n    function isEqualWith(value, other, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      var result = customizer ? customizer(value, other) : undefined;\n      return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result;\n    }\n\n    /**\n     * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,\n     * `SyntaxError`, `TypeError`, or `URIError` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an error object, else `false`.\n     * @example\n     *\n     * _.isError(new Error);\n     * // => true\n     *\n     * _.isError(Error);\n     * // => false\n     */\n    function isError(value) {\n      if (!isObjectLike(value)) {\n        return false;\n      }\n      var tag = baseGetTag(value);\n      return tag == errorTag || tag == domExcTag ||\n        (typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value));\n    }\n\n    /**\n     * Checks if `value` is a finite primitive number.\n     *\n     * **Note:** This method is based on\n     * [`Number.isFinite`](https://mdn.io/Number/isFinite).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a finite number, else `false`.\n     * @example\n     *\n     * _.isFinite(3);\n     * // => true\n     *\n     * _.isFinite(Number.MIN_VALUE);\n     * // => true\n     *\n     * _.isFinite(Infinity);\n     * // => false\n     *\n     * _.isFinite('3');\n     * // => false\n     */\n    function isFinite(value) {\n      return typeof value == 'number' && nativeIsFinite(value);\n    }\n\n    /**\n     * Checks if `value` is classified as a `Function` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n     * @example\n     *\n     * _.isFunction(_);\n     * // => true\n     *\n     * _.isFunction(/abc/);\n     * // => false\n     */\n    function isFunction(value) {\n      if (!isObject(value)) {\n        return false;\n      }\n      // The use of `Object#toString` avoids issues with the `typeof` operator\n      // in Safari 9 which returns 'object' for typed arrays and other constructors.\n      var tag = baseGetTag(value);\n      return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n    }\n\n    /**\n     * Checks if `value` is an integer.\n     *\n     * **Note:** This method is based on\n     * [`Number.isInteger`](https://mdn.io/Number/isInteger).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an integer, else `false`.\n     * @example\n     *\n     * _.isInteger(3);\n     * // => true\n     *\n     * _.isInteger(Number.MIN_VALUE);\n     * // => false\n     *\n     * _.isInteger(Infinity);\n     * // => false\n     *\n     * _.isInteger('3');\n     * // => false\n     */\n    function isInteger(value) {\n      return typeof value == 'number' && value == toInteger(value);\n    }\n\n    /**\n     * Checks if `value` is a valid array-like length.\n     *\n     * **Note:** This method is loosely based on\n     * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n     * @example\n     *\n     * _.isLength(3);\n     * // => true\n     *\n     * _.isLength(Number.MIN_VALUE);\n     * // => false\n     *\n     * _.isLength(Infinity);\n     * // => false\n     *\n     * _.isLength('3');\n     * // => false\n     */\n    function isLength(value) {\n      return typeof value == 'number' &&\n        value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n    }\n\n    /**\n     * Checks if `value` is the\n     * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n     * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n     * @example\n     *\n     * _.isObject({});\n     * // => true\n     *\n     * _.isObject([1, 2, 3]);\n     * // => true\n     *\n     * _.isObject(_.noop);\n     * // => true\n     *\n     * _.isObject(null);\n     * // => false\n     */\n    function isObject(value) {\n      var type = typeof value;\n      return value != null && (type == 'object' || type == 'function');\n    }\n\n    /**\n     * Checks if `value` is object-like. A value is object-like if it's not `null`\n     * and has a `typeof` result of \"object\".\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n     * @example\n     *\n     * _.isObjectLike({});\n     * // => true\n     *\n     * _.isObjectLike([1, 2, 3]);\n     * // => true\n     *\n     * _.isObjectLike(_.noop);\n     * // => false\n     *\n     * _.isObjectLike(null);\n     * // => false\n     */\n    function isObjectLike(value) {\n      return value != null && typeof value == 'object';\n    }\n\n    /**\n     * Checks if `value` is classified as a `Map` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n     * @example\n     *\n     * _.isMap(new Map);\n     * // => true\n     *\n     * _.isMap(new WeakMap);\n     * // => false\n     */\n    var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;\n\n    /**\n     * Performs a partial deep comparison between `object` and `source` to\n     * determine if `object` contains equivalent property values.\n     *\n     * **Note:** This method is equivalent to `_.matches` when `source` is\n     * partially applied.\n     *\n     * Partial comparisons will match empty array and empty object `source`\n     * values against any array or object value, respectively. See `_.isEqual`\n     * for a list of supported value comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property values to match.\n     * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2 };\n     *\n     * _.isMatch(object, { 'b': 2 });\n     * // => true\n     *\n     * _.isMatch(object, { 'b': 1 });\n     * // => false\n     */\n    function isMatch(object, source) {\n      return object === source || baseIsMatch(object, source, getMatchData(source));\n    }\n\n    /**\n     * This method is like `_.isMatch` except that it accepts `customizer` which\n     * is invoked to compare values. If `customizer` returns `undefined`, comparisons\n     * are handled by the method instead. The `customizer` is invoked with five\n     * arguments: (objValue, srcValue, index|key, object, source).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property values to match.\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n     * @example\n     *\n     * function isGreeting(value) {\n     *   return /^h(?:i|ello)$/.test(value);\n     * }\n     *\n     * function customizer(objValue, srcValue) {\n     *   if (isGreeting(objValue) && isGreeting(srcValue)) {\n     *     return true;\n     *   }\n     * }\n     *\n     * var object = { 'greeting': 'hello' };\n     * var source = { 'greeting': 'hi' };\n     *\n     * _.isMatchWith(object, source, customizer);\n     * // => true\n     */\n    function isMatchWith(object, source, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return baseIsMatch(object, source, getMatchData(source), customizer);\n    }\n\n    /**\n     * Checks if `value` is `NaN`.\n     *\n     * **Note:** This method is based on\n     * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as\n     * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for\n     * `undefined` and other non-number values.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n     * @example\n     *\n     * _.isNaN(NaN);\n     * // => true\n     *\n     * _.isNaN(new Number(NaN));\n     * // => true\n     *\n     * isNaN(undefined);\n     * // => true\n     *\n     * _.isNaN(undefined);\n     * // => false\n     */\n    function isNaN(value) {\n      // An `NaN` primitive is the only value that is not equal to itself.\n      // Perform the `toStringTag` check first to avoid errors with some\n      // ActiveX objects in IE.\n      return isNumber(value) && value != +value;\n    }\n\n    /**\n     * Checks if `value` is a pristine native function.\n     *\n     * **Note:** This method can't reliably detect native functions in the presence\n     * of the core-js package because core-js circumvents this kind of detection.\n     * Despite multiple requests, the core-js maintainer has made it clear: any\n     * attempt to fix the detection will be obstructed. As a result, we're left\n     * with little choice but to throw an error. Unfortunately, this also affects\n     * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill),\n     * which rely on core-js.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a native function,\n     *  else `false`.\n     * @example\n     *\n     * _.isNative(Array.prototype.push);\n     * // => true\n     *\n     * _.isNative(_);\n     * // => false\n     */\n    function isNative(value) {\n      if (isMaskable(value)) {\n        throw new Error(CORE_ERROR_TEXT);\n      }\n      return baseIsNative(value);\n    }\n\n    /**\n     * Checks if `value` is `null`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is `null`, else `false`.\n     * @example\n     *\n     * _.isNull(null);\n     * // => true\n     *\n     * _.isNull(void 0);\n     * // => false\n     */\n    function isNull(value) {\n      return value === null;\n    }\n\n    /**\n     * Checks if `value` is `null` or `undefined`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is nullish, else `false`.\n     * @example\n     *\n     * _.isNil(null);\n     * // => true\n     *\n     * _.isNil(void 0);\n     * // => true\n     *\n     * _.isNil(NaN);\n     * // => false\n     */\n    function isNil(value) {\n      return value == null;\n    }\n\n    /**\n     * Checks if `value` is classified as a `Number` primitive or object.\n     *\n     * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are\n     * classified as numbers, use the `_.isFinite` method.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a number, else `false`.\n     * @example\n     *\n     * _.isNumber(3);\n     * // => true\n     *\n     * _.isNumber(Number.MIN_VALUE);\n     * // => true\n     *\n     * _.isNumber(Infinity);\n     * // => true\n     *\n     * _.isNumber('3');\n     * // => false\n     */\n    function isNumber(value) {\n      return typeof value == 'number' ||\n        (isObjectLike(value) && baseGetTag(value) == numberTag);\n    }\n\n    /**\n     * Checks if `value` is a plain object, that is, an object created by the\n     * `Object` constructor or one with a `[[Prototype]]` of `null`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.8.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     * }\n     *\n     * _.isPlainObject(new Foo);\n     * // => false\n     *\n     * _.isPlainObject([1, 2, 3]);\n     * // => false\n     *\n     * _.isPlainObject({ 'x': 0, 'y': 0 });\n     * // => true\n     *\n     * _.isPlainObject(Object.create(null));\n     * // => true\n     */\n    function isPlainObject(value) {\n      if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n        return false;\n      }\n      var proto = getPrototype(value);\n      if (proto === null) {\n        return true;\n      }\n      var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n      return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n        funcToString.call(Ctor) == objectCtorString;\n    }\n\n    /**\n     * Checks if `value` is classified as a `RegExp` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.\n     * @example\n     *\n     * _.isRegExp(/abc/);\n     * // => true\n     *\n     * _.isRegExp('/abc/');\n     * // => false\n     */\n    var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;\n\n    /**\n     * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754\n     * double precision number which isn't the result of a rounded unsafe integer.\n     *\n     * **Note:** This method is based on\n     * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`.\n     * @example\n     *\n     * _.isSafeInteger(3);\n     * // => true\n     *\n     * _.isSafeInteger(Number.MIN_VALUE);\n     * // => false\n     *\n     * _.isSafeInteger(Infinity);\n     * // => false\n     *\n     * _.isSafeInteger('3');\n     * // => false\n     */\n    function isSafeInteger(value) {\n      return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;\n    }\n\n    /**\n     * Checks if `value` is classified as a `Set` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n     * @example\n     *\n     * _.isSet(new Set);\n     * // => true\n     *\n     * _.isSet(new WeakSet);\n     * // => false\n     */\n    var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;\n\n    /**\n     * Checks if `value` is classified as a `String` primitive or object.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a string, else `false`.\n     * @example\n     *\n     * _.isString('abc');\n     * // => true\n     *\n     * _.isString(1);\n     * // => false\n     */\n    function isString(value) {\n      return typeof value == 'string' ||\n        (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);\n    }\n\n    /**\n     * Checks if `value` is classified as a `Symbol` primitive or object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n     * @example\n     *\n     * _.isSymbol(Symbol.iterator);\n     * // => true\n     *\n     * _.isSymbol('abc');\n     * // => false\n     */\n    function isSymbol(value) {\n      return typeof value == 'symbol' ||\n        (isObjectLike(value) && baseGetTag(value) == symbolTag);\n    }\n\n    /**\n     * Checks if `value` is classified as a typed array.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n     * @example\n     *\n     * _.isTypedArray(new Uint8Array);\n     * // => true\n     *\n     * _.isTypedArray([]);\n     * // => false\n     */\n    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\n    /**\n     * Checks if `value` is `undefined`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.\n     * @example\n     *\n     * _.isUndefined(void 0);\n     * // => true\n     *\n     * _.isUndefined(null);\n     * // => false\n     */\n    function isUndefined(value) {\n      return value === undefined;\n    }\n\n    /**\n     * Checks if `value` is classified as a `WeakMap` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a weak map, else `false`.\n     * @example\n     *\n     * _.isWeakMap(new WeakMap);\n     * // => true\n     *\n     * _.isWeakMap(new Map);\n     * // => false\n     */\n    function isWeakMap(value) {\n      return isObjectLike(value) && getTag(value) == weakMapTag;\n    }\n\n    /**\n     * Checks if `value` is classified as a `WeakSet` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a weak set, else `false`.\n     * @example\n     *\n     * _.isWeakSet(new WeakSet);\n     * // => true\n     *\n     * _.isWeakSet(new Set);\n     * // => false\n     */\n    function isWeakSet(value) {\n      return isObjectLike(value) && baseGetTag(value) == weakSetTag;\n    }\n\n    /**\n     * Checks if `value` is less than `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is less than `other`,\n     *  else `false`.\n     * @see _.gt\n     * @example\n     *\n     * _.lt(1, 3);\n     * // => true\n     *\n     * _.lt(3, 3);\n     * // => false\n     *\n     * _.lt(3, 1);\n     * // => false\n     */\n    var lt = createRelationalOperation(baseLt);\n\n    /**\n     * Checks if `value` is less than or equal to `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is less than or equal to\n     *  `other`, else `false`.\n     * @see _.gte\n     * @example\n     *\n     * _.lte(1, 3);\n     * // => true\n     *\n     * _.lte(3, 3);\n     * // => true\n     *\n     * _.lte(3, 1);\n     * // => false\n     */\n    var lte = createRelationalOperation(function(value, other) {\n      return value <= other;\n    });\n\n    /**\n     * Converts `value` to an array.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {Array} Returns the converted array.\n     * @example\n     *\n     * _.toArray({ 'a': 1, 'b': 2 });\n     * // => [1, 2]\n     *\n     * _.toArray('abc');\n     * // => ['a', 'b', 'c']\n     *\n     * _.toArray(1);\n     * // => []\n     *\n     * _.toArray(null);\n     * // => []\n     */\n    function toArray(value) {\n      if (!value) {\n        return [];\n      }\n      if (isArrayLike(value)) {\n        return isString(value) ? stringToArray(value) : copyArray(value);\n      }\n      if (symIterator && value[symIterator]) {\n        return iteratorToArray(value[symIterator]());\n      }\n      var tag = getTag(value),\n          func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values);\n\n      return func(value);\n    }\n\n    /**\n     * Converts `value` to a finite number.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.12.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted number.\n     * @example\n     *\n     * _.toFinite(3.2);\n     * // => 3.2\n     *\n     * _.toFinite(Number.MIN_VALUE);\n     * // => 5e-324\n     *\n     * _.toFinite(Infinity);\n     * // => 1.7976931348623157e+308\n     *\n     * _.toFinite('3.2');\n     * // => 3.2\n     */\n    function toFinite(value) {\n      if (!value) {\n        return value === 0 ? value : 0;\n      }\n      value = toNumber(value);\n      if (value === INFINITY || value === -INFINITY) {\n        var sign = (value < 0 ? -1 : 1);\n        return sign * MAX_INTEGER;\n      }\n      return value === value ? value : 0;\n    }\n\n    /**\n     * Converts `value` to an integer.\n     *\n     * **Note:** This method is loosely based on\n     * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.toInteger(3.2);\n     * // => 3\n     *\n     * _.toInteger(Number.MIN_VALUE);\n     * // => 0\n     *\n     * _.toInteger(Infinity);\n     * // => 1.7976931348623157e+308\n     *\n     * _.toInteger('3.2');\n     * // => 3\n     */\n    function toInteger(value) {\n      var result = toFinite(value),\n          remainder = result % 1;\n\n      return result === result ? (remainder ? result - remainder : result) : 0;\n    }\n\n    /**\n     * Converts `value` to an integer suitable for use as the length of an\n     * array-like object.\n     *\n     * **Note:** This method is based on\n     * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.toLength(3.2);\n     * // => 3\n     *\n     * _.toLength(Number.MIN_VALUE);\n     * // => 0\n     *\n     * _.toLength(Infinity);\n     * // => 4294967295\n     *\n     * _.toLength('3.2');\n     * // => 3\n     */\n    function toLength(value) {\n      return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;\n    }\n\n    /**\n     * Converts `value` to a number.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to process.\n     * @returns {number} Returns the number.\n     * @example\n     *\n     * _.toNumber(3.2);\n     * // => 3.2\n     *\n     * _.toNumber(Number.MIN_VALUE);\n     * // => 5e-324\n     *\n     * _.toNumber(Infinity);\n     * // => Infinity\n     *\n     * _.toNumber('3.2');\n     * // => 3.2\n     */\n    function toNumber(value) {\n      if (typeof value == 'number') {\n        return value;\n      }\n      if (isSymbol(value)) {\n        return NAN;\n      }\n      if (isObject(value)) {\n        var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n        value = isObject(other) ? (other + '') : other;\n      }\n      if (typeof value != 'string') {\n        return value === 0 ? value : +value;\n      }\n      value = 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, &amp; pebbles'\n     */\n    function escape(string) {\n      string = toString(string);\n      return (string && reHasUnescapedHtml.test(string))\n        ? string.replace(reUnescapedHtml, escapeHtmlChar)\n        : string;\n    }\n\n    /**\n     * Escapes the `RegExp` special characters \"^\", \"$\", \"\\\", \".\", \"*\", \"+\",\n     * \"?\", \"(\", \")\", \"[\", \"]\", \"{\", \"}\", and \"|\" in `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to escape.\n     * @returns {string} Returns the escaped string.\n     * @example\n     *\n     * _.escapeRegExp('[lodash](https://lodash.com/)');\n     * // => '\\[lodash\\]\\(https://lodash\\.com/\\)'\n     */\n    function escapeRegExp(string) {\n      string = toString(string);\n      return (string && reHasRegExpChar.test(string))\n        ? string.replace(reRegExpChar, '\\\\$&')\n        : string;\n    }\n\n    /**\n     * Converts `string` to\n     * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the kebab cased string.\n     * @example\n     *\n     * _.kebabCase('Foo Bar');\n     * // => 'foo-bar'\n     *\n     * _.kebabCase('fooBar');\n     * // => 'foo-bar'\n     *\n     * _.kebabCase('__FOO_BAR__');\n     * // => 'foo-bar'\n     */\n    var kebabCase = createCompounder(function(result, word, index) {\n      return result + (index ? '-' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Converts `string`, as space separated words, to lower case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the lower cased string.\n     * @example\n     *\n     * _.lowerCase('--Foo-Bar--');\n     * // => 'foo bar'\n     *\n     * _.lowerCase('fooBar');\n     * // => 'foo bar'\n     *\n     * _.lowerCase('__FOO_BAR__');\n     * // => 'foo bar'\n     */\n    var lowerCase = createCompounder(function(result, word, index) {\n      return result + (index ? ' ' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Converts the first character of `string` to lower case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the converted string.\n     * @example\n     *\n     * _.lowerFirst('Fred');\n     * // => 'fred'\n     *\n     * _.lowerFirst('FRED');\n     * // => 'fRED'\n     */\n    var lowerFirst = createCaseFirst('toLowerCase');\n\n    /**\n     * Pads `string` on the left and right sides if it's shorter than `length`.\n     * Padding characters are truncated if they can't be evenly divided by `length`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.pad('abc', 8);\n     * // => '  abc   '\n     *\n     * _.pad('abc', 8, '_-');\n     * // => '_-abc_-_'\n     *\n     * _.pad('abc', 3);\n     * // => 'abc'\n     */\n    function pad(string, length, chars) {\n      string = toString(string);\n      length = toInteger(length);\n\n      var strLength = length ? stringSize(string) : 0;\n      if (!length || strLength >= length) {\n        return string;\n      }\n      var mid = (length - strLength) / 2;\n      return (\n        createPadding(nativeFloor(mid), chars) +\n        string +\n        createPadding(nativeCeil(mid), chars)\n      );\n    }\n\n    /**\n     * Pads `string` on the right side if it's shorter than `length`. Padding\n     * characters are truncated if they exceed `length`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.padEnd('abc', 6);\n     * // => 'abc   '\n     *\n     * _.padEnd('abc', 6, '_-');\n     * // => 'abc_-_'\n     *\n     * _.padEnd('abc', 3);\n     * // => 'abc'\n     */\n    function padEnd(string, length, chars) {\n      string = toString(string);\n      length = toInteger(length);\n\n      var strLength = length ? stringSize(string) : 0;\n      return (length && strLength < length)\n        ? (string + createPadding(length - strLength, chars))\n        : string;\n    }\n\n    /**\n     * Pads `string` on the left side if it's shorter than `length`. Padding\n     * characters are truncated if they exceed `length`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.padStart('abc', 6);\n     * // => '   abc'\n     *\n     * _.padStart('abc', 6, '_-');\n     * // => '_-_abc'\n     *\n     * _.padStart('abc', 3);\n     * // => 'abc'\n     */\n    function padStart(string, length, chars) {\n      string = toString(string);\n      length = toInteger(length);\n\n      var strLength = length ? stringSize(string) : 0;\n      return (length && strLength < length)\n        ? (createPadding(length - strLength, chars) + string)\n        : string;\n    }\n\n    /**\n     * Converts `string` to an integer of the specified radix. If `radix` is\n     * `undefined` or `0`, a `radix` of `10` is used unless `value` is a\n     * hexadecimal, in which case a `radix` of `16` is used.\n     *\n     * **Note:** This method aligns with the\n     * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.1.0\n     * @category String\n     * @param {string} string The string to convert.\n     * @param {number} [radix=10] The radix to interpret `value` by.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.parseInt('08');\n     * // => 8\n     *\n     * _.map(['6', '08', '10'], _.parseInt);\n     * // => [6, 8, 10]\n     */\n    function parseInt(string, radix, guard) {\n      if (guard || radix == null) {\n        radix = 0;\n      } else if (radix) {\n        radix = +radix;\n      }\n      return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0);\n    }\n\n    /**\n     * Repeats the given string `n` times.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to repeat.\n     * @param {number} [n=1] The number of times to repeat the string.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the repeated string.\n     * @example\n     *\n     * _.repeat('*', 3);\n     * // => '***'\n     *\n     * _.repeat('abc', 2);\n     * // => 'abcabc'\n     *\n     * _.repeat('abc', 0);\n     * // => ''\n     */\n    function repeat(string, n, guard) {\n      if ((guard ? isIterateeCall(string, n, guard) : n === undefined)) {\n        n = 1;\n      } else {\n        n = toInteger(n);\n      }\n      return baseRepeat(toString(string), n);\n    }\n\n    /**\n     * Replaces matches for `pattern` in `string` with `replacement`.\n     *\n     * **Note:** This method is based on\n     * [`String#replace`](https://mdn.io/String/replace).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to modify.\n     * @param {RegExp|string} pattern The pattern to replace.\n     * @param {Function|string} replacement The match replacement.\n     * @returns {string} Returns the modified string.\n     * @example\n     *\n     * _.replace('Hi Fred', 'Fred', 'Barney');\n     * // => 'Hi Barney'\n     */\n    function replace() {\n      var args = arguments,\n          string = toString(args[0]);\n\n      return args.length < 3 ? string : string.replace(args[1], args[2]);\n    }\n\n    /**\n     * Converts `string` to\n     * [snake case](https://en.wikipedia.org/wiki/Snake_case).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the snake cased string.\n     * @example\n     *\n     * _.snakeCase('Foo Bar');\n     * // => 'foo_bar'\n     *\n     * _.snakeCase('fooBar');\n     * // => 'foo_bar'\n     *\n     * _.snakeCase('--FOO-BAR--');\n     * // => 'foo_bar'\n     */\n    var snakeCase = createCompounder(function(result, word, index) {\n      return result + (index ? '_' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Splits `string` by `separator`.\n     *\n     * **Note:** This method is based on\n     * [`String#split`](https://mdn.io/String/split).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to split.\n     * @param {RegExp|string} separator The separator pattern to split by.\n     * @param {number} [limit] The length to truncate results to.\n     * @returns {Array} Returns the string segments.\n     * @example\n     *\n     * _.split('a-b-c', '-', 2);\n     * // => ['a', 'b']\n     */\n    function split(string, separator, limit) {\n      if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) {\n        separator = limit = undefined;\n      }\n      limit = limit === undefined ? MAX_ARRAY_LENGTH : limit >>> 0;\n      if (!limit) {\n        return [];\n      }\n      string = toString(string);\n      if (string && (\n            typeof separator == 'string' ||\n            (separator != null && !isRegExp(separator))\n          )) {\n        separator = baseToString(separator);\n        if (!separator && hasUnicode(string)) {\n          return castSlice(stringToArray(string), 0, limit);\n        }\n      }\n      return string.split(separator, limit);\n    }\n\n    /**\n     * Converts `string` to\n     * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.1.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the start cased string.\n     * @example\n     *\n     * _.startCase('--foo-bar--');\n     * // => 'Foo Bar'\n     *\n     * _.startCase('fooBar');\n     * // => 'Foo Bar'\n     *\n     * _.startCase('__FOO_BAR__');\n     * // => 'FOO BAR'\n     */\n    var startCase = createCompounder(function(result, word, index) {\n      return result + (index ? ' ' : '') + upperFirst(word);\n    });\n\n    /**\n     * Checks if `string` starts with the given target string.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to inspect.\n     * @param {string} [target] The string to search for.\n     * @param {number} [position=0] The position to search from.\n     * @returns {boolean} Returns `true` if `string` starts with `target`,\n     *  else `false`.\n     * @example\n     *\n     * _.startsWith('abc', 'a');\n     * // => true\n     *\n     * _.startsWith('abc', 'b');\n     * // => false\n     *\n     * _.startsWith('abc', 'b', 1);\n     * // => true\n     */\n    function startsWith(string, target, position) {\n      string = toString(string);\n      position = position == null\n        ? 0\n        : baseClamp(toInteger(position), 0, string.length);\n\n      target = baseToString(target);\n      return string.slice(position, position + target.length) == target;\n    }\n\n    /**\n     * Creates a compiled template function that can interpolate data properties\n     * in \"interpolate\" delimiters, HTML-escape interpolated data properties in\n     * \"escape\" delimiters, and execute JavaScript in \"evaluate\" delimiters. Data\n     * properties may be accessed as free variables in the template. If a setting\n     * object is given, it takes precedence over `_.templateSettings` values.\n     *\n     * **Note:** In the development build `_.template` utilizes\n     * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)\n     * for easier debugging.\n     *\n     * For more information on precompiling templates see\n     * [lodash's custom builds documentation](https://lodash.com/custom-builds).\n     *\n     * For more information on Chrome extension sandboxes see\n     * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The template string.\n     * @param {Object} [options={}] The options object.\n     * @param {RegExp} [options.escape=_.templateSettings.escape]\n     *  The HTML \"escape\" delimiter.\n     * @param {RegExp} [options.evaluate=_.templateSettings.evaluate]\n     *  The \"evaluate\" delimiter.\n     * @param {Object} [options.imports=_.templateSettings.imports]\n     *  An object to import into the template as free variables.\n     * @param {RegExp} [options.interpolate=_.templateSettings.interpolate]\n     *  The \"interpolate\" delimiter.\n     * @param {string} [options.sourceURL='lodash.templateSources[n]']\n     *  The sourceURL of the compiled template.\n     * @param {string} [options.variable='obj']\n     *  The data object variable name.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the compiled template function.\n     * @example\n     *\n     * // Use the \"interpolate\" delimiter to create a compiled template.\n     * var compiled = _.template('hello <%= user %>!');\n     * compiled({ 'user': 'fred' });\n     * // => 'hello fred!'\n     *\n     * // Use the HTML \"escape\" delimiter to escape data property values.\n     * var compiled = _.template('<b><%- value %></b>');\n     * compiled({ 'value': '<script>' });\n     * // => '<b>&lt;script&gt;</b>'\n     *\n     * // Use the \"evaluate\" delimiter to execute JavaScript and generate HTML.\n     * var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');\n     * compiled({ 'users': ['fred', 'barney'] });\n     * // => '<li>fred</li><li>barney</li>'\n     *\n     * // Use the internal `print` function in \"evaluate\" delimiters.\n     * var compiled = _.template('<% print(\"hello \" + user); %>!');\n     * compiled({ 'user': 'barney' });\n     * // => 'hello barney!'\n     *\n     * // Use the ES template literal delimiter as an \"interpolate\" delimiter.\n     * // Disable support by replacing the \"interpolate\" delimiter.\n     * var compiled = _.template('hello ${ user }!');\n     * compiled({ 'user': 'pebbles' });\n     * // => 'hello pebbles!'\n     *\n     * // Use backslashes to treat delimiters as plain text.\n     * var compiled = _.template('<%= \"\\\\<%- value %\\\\>\" %>');\n     * compiled({ 'value': 'ignored' });\n     * // => '<%- value %>'\n     *\n     * // Use the `imports` option to import `jQuery` as `jq`.\n     * var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>';\n     * var compiled = _.template(text, { 'imports': { 'jq': jQuery } });\n     * compiled({ 'users': ['fred', 'barney'] });\n     * // => '<li>fred</li><li>barney</li>'\n     *\n     * // Use the `sourceURL` option to specify a custom sourceURL for the template.\n     * var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' });\n     * compiled(data);\n     * // => Find the source of \"greeting.jst\" under the Sources tab or Resources panel of the web inspector.\n     *\n     * // Use the `variable` option to ensure a with-statement isn't used in the compiled template.\n     * var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' });\n     * compiled.source;\n     * // => function(data) {\n     * //   var __t, __p = '';\n     * //   __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!';\n     * //   return __p;\n     * // }\n     *\n     * // Use custom template delimiters.\n     * _.templateSettings.interpolate = /{{([\\s\\S]+?)}}/g;\n     * var compiled = _.template('hello {{ user }}!');\n     * compiled({ 'user': 'mustache' });\n     * // => 'hello mustache!'\n     *\n     * // Use the `source` property to inline compiled templates for meaningful\n     * // line numbers in error messages and stack traces.\n     * fs.writeFileSync(path.join(process.cwd(), 'jst.js'), '\\\n     *   var JST = {\\\n     *     \"main\": ' + _.template(mainText).source + '\\\n     *   };\\\n     * ');\n     */\n    function template(string, options, guard) {\n      // Based on John Resig's `tmpl` implementation\n      // (http://ejohn.org/blog/javascript-micro-templating/)\n      // and Laura Doktorova's doT.js (https://github.com/olado/doT).\n      var settings = lodash.templateSettings;\n\n      if (guard && isIterateeCall(string, options, guard)) {\n        options = undefined;\n      }\n      string = toString(string);\n      options = assignInWith({}, options, settings, customDefaultsAssignIn);\n\n      var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn),\n          importsKeys = keys(imports),\n          importsValues = baseValues(imports, importsKeys);\n\n      var isEscaping,\n          isEvaluating,\n          index = 0,\n          interpolate = options.interpolate || reNoMatch,\n          source = \"__p += '\";\n\n      // Compile the regexp to match each delimiter.\n      var reDelimiters = RegExp(\n        (options.escape || reNoMatch).source + '|' +\n        interpolate.source + '|' +\n        (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +\n        (options.evaluate || reNoMatch).source + '|$'\n      , 'g');\n\n      // Use a sourceURL for easier debugging.\n      // The sourceURL gets injected into the source that's eval-ed, so be careful\n      // to normalize all kinds of whitespace, so e.g. newlines (and unicode versions of it) can't sneak in\n      // and escape the comment, thus injecting code that gets evaled.\n      var sourceURL = '//# sourceURL=' +\n        (hasOwnProperty.call(options, 'sourceURL')\n          ? (options.sourceURL + '').replace(/\\s/g, ' ')\n          : ('lodash.templateSources[' + (++templateCounter) + ']')\n        ) + '\\n';\n\n      string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {\n        interpolateValue || (interpolateValue = esTemplateValue);\n\n        // Escape characters that can't be included in string literals.\n        source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);\n\n        // Replace delimiters with snippets.\n        if (escapeValue) {\n          isEscaping = true;\n          source += \"' +\\n__e(\" + escapeValue + \") +\\n'\";\n        }\n        if (evaluateValue) {\n          isEvaluating = true;\n          source += \"';\\n\" + evaluateValue + \";\\n__p += '\";\n        }\n        if (interpolateValue) {\n          source += \"' +\\n((__t = (\" + interpolateValue + \")) == null ? '' : __t) +\\n'\";\n        }\n        index = offset + match.length;\n\n        // The JS engine embedded in Adobe products needs `match` returned in\n        // order to produce the correct `offset` value.\n        return match;\n      });\n\n      source += \"';\\n\";\n\n      // If `variable` is not specified wrap a with-statement around the generated\n      // code to add the data object to the top of the scope chain.\n      var variable = hasOwnProperty.call(options, 'variable') && options.variable;\n      if (!variable) {\n        source = 'with (obj) {\\n' + source + '\\n}\\n';\n      }\n      // Throw an error if a forbidden character was found in `variable`, to prevent\n      // potential command injection attacks.\n      else if (reForbiddenIdentifierChars.test(variable)) {\n        throw new Error(INVALID_TEMPL_VAR_ERROR_TEXT);\n      }\n\n      // Cleanup code by stripping empty strings.\n      source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)\n        .replace(reEmptyStringMiddle, '$1')\n        .replace(reEmptyStringTrailing, '$1;');\n\n      // Frame code as the function body.\n      source = 'function(' + (variable || 'obj') + ') {\\n' +\n        (variable\n          ? ''\n          : 'obj || (obj = {});\\n'\n        ) +\n        \"var __t, __p = ''\" +\n        (isEscaping\n           ? ', __e = _.escape'\n           : ''\n        ) +\n        (isEvaluating\n          ? ', __j = Array.prototype.join;\\n' +\n            \"function print() { __p += __j.call(arguments, '') }\\n\"\n          : ';\\n'\n        ) +\n        source +\n        'return __p\\n}';\n\n      var result = attempt(function() {\n        return Function(importsKeys, sourceURL + 'return ' + source)\n          .apply(undefined, importsValues);\n      });\n\n      // Provide the compiled function's source by its `toString` method or\n      // the `source` property as a convenience for inlining compiled templates.\n      result.source = source;\n      if (isError(result)) {\n        throw result;\n      }\n      return result;\n    }\n\n    /**\n     * Converts `string`, as a whole, to lower case just like\n     * [String#toLowerCase](https://mdn.io/toLowerCase).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the lower cased string.\n     * @example\n     *\n     * _.toLower('--Foo-Bar--');\n     * // => '--foo-bar--'\n     *\n     * _.toLower('fooBar');\n     * // => 'foobar'\n     *\n     * _.toLower('__FOO_BAR__');\n     * // => '__foo_bar__'\n     */\n    function toLower(value) {\n      return toString(value).toLowerCase();\n    }\n\n    /**\n     * Converts `string`, as a whole, to upper case just like\n     * [String#toUpperCase](https://mdn.io/toUpperCase).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the upper cased string.\n     * @example\n     *\n     * _.toUpper('--foo-bar--');\n     * // => '--FOO-BAR--'\n     *\n     * _.toUpper('fooBar');\n     * // => 'FOOBAR'\n     *\n     * _.toUpper('__foo_bar__');\n     * // => '__FOO_BAR__'\n     */\n    function toUpper(value) {\n      return toString(value).toUpperCase();\n    }\n\n    /**\n     * Removes leading and trailing whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trim('  abc  ');\n     * // => 'abc'\n     *\n     * _.trim('-_-abc-_-', '_-');\n     * // => 'abc'\n     *\n     * _.map(['  foo  ', '  bar  '], _.trim);\n     * // => ['foo', 'bar']\n     */\n    function trim(string, chars, guard) {\n      string = toString(string);\n      if (string && (guard || chars === undefined)) {\n        return baseTrim(string);\n      }\n      if (!string || !(chars = baseToString(chars))) {\n        return string;\n      }\n      var strSymbols = stringToArray(string),\n          chrSymbols = stringToArray(chars),\n          start = charsStartIndex(strSymbols, chrSymbols),\n          end = charsEndIndex(strSymbols, chrSymbols) + 1;\n\n      return castSlice(strSymbols, start, end).join('');\n    }\n\n    /**\n     * Removes trailing whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trimEnd('  abc  ');\n     * // => '  abc'\n     *\n     * _.trimEnd('-_-abc-_-', '_-');\n     * // => '-_-abc'\n     */\n    function trimEnd(string, chars, guard) {\n      string = toString(string);\n      if (string && (guard || chars === undefined)) {\n        return string.slice(0, trimmedEndIndex(string) + 1);\n      }\n      if (!string || !(chars = baseToString(chars))) {\n        return string;\n      }\n      var strSymbols = stringToArray(string),\n          end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;\n\n      return castSlice(strSymbols, 0, end).join('');\n    }\n\n    /**\n     * Removes leading whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trimStart('  abc  ');\n     * // => 'abc  '\n     *\n     * _.trimStart('-_-abc-_-', '_-');\n     * // => 'abc-_-'\n     */\n    function trimStart(string, chars, guard) {\n      string = toString(string);\n      if (string && (guard || chars === undefined)) {\n        return string.replace(reTrimStart, '');\n      }\n      if (!string || !(chars = baseToString(chars))) {\n        return string;\n      }\n      var strSymbols = stringToArray(string),\n          start = charsStartIndex(strSymbols, stringToArray(chars));\n\n      return castSlice(strSymbols, start).join('');\n    }\n\n    /**\n     * Truncates `string` if it's longer than the given maximum string length.\n     * The last characters of the truncated string are replaced with the omission\n     * string which defaults to \"...\".\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to truncate.\n     * @param {Object} [options={}] The options object.\n     * @param {number} [options.length=30] The maximum string length.\n     * @param {string} [options.omission='...'] The string to indicate text is omitted.\n     * @param {RegExp|string} [options.separator] The separator pattern to truncate to.\n     * @returns {string} Returns the truncated string.\n     * @example\n     *\n     * _.truncate('hi-diddly-ho there, neighborino');\n     * // => 'hi-diddly-ho there, neighbo...'\n     *\n     * _.truncate('hi-diddly-ho there, neighborino', {\n     *   'length': 24,\n     *   'separator': ' '\n     * });\n     * // => 'hi-diddly-ho there,...'\n     *\n     * _.truncate('hi-diddly-ho there, neighborino', {\n     *   'length': 24,\n     *   'separator': /,? +/\n     * });\n     * // => 'hi-diddly-ho there...'\n     *\n     * _.truncate('hi-diddly-ho there, neighborino', {\n     *   'omission': ' [...]'\n     * });\n     * // => 'hi-diddly-ho there, neig [...]'\n     */\n    function truncate(string, options) {\n      var length = DEFAULT_TRUNC_LENGTH,\n          omission = DEFAULT_TRUNC_OMISSION;\n\n      if (isObject(options)) {\n        var separator = 'separator' in options ? options.separator : separator;\n        length = 'length' in options ? toInteger(options.length) : length;\n        omission = 'omission' in options ? baseToString(options.omission) : omission;\n      }\n      string = toString(string);\n\n      var strLength = string.length;\n      if (hasUnicode(string)) {\n        var strSymbols = stringToArray(string);\n        strLength = strSymbols.length;\n      }\n      if (length >= strLength) {\n        return string;\n      }\n      var end = length - stringSize(omission);\n      if (end < 1) {\n        return omission;\n      }\n      var result = strSymbols\n        ? castSlice(strSymbols, 0, end).join('')\n        : string.slice(0, end);\n\n      if (separator === undefined) {\n        return result + omission;\n      }\n      if (strSymbols) {\n        end += (result.length - end);\n      }\n      if (isRegExp(separator)) {\n        if (string.slice(end).search(separator)) {\n          var match,\n              substring = result;\n\n          if (!separator.global) {\n            separator = RegExp(separator.source, toString(reFlags.exec(separator)) + 'g');\n          }\n          separator.lastIndex = 0;\n          while ((match = separator.exec(substring))) {\n            var newEnd = match.index;\n          }\n          result = result.slice(0, newEnd === undefined ? end : newEnd);\n        }\n      } else if (string.indexOf(baseToString(separator), end) != end) {\n        var index = result.lastIndexOf(separator);\n        if (index > -1) {\n          result = result.slice(0, index);\n        }\n      }\n      return result + omission;\n    }\n\n    /**\n     * The inverse of `_.escape`; this method converts the HTML entities\n     * `&amp;`, `&lt;`, `&gt;`, `&quot;`, and `&#39;` in `string` to\n     * their corresponding characters.\n     *\n     * **Note:** No other HTML entities are unescaped. To unescape additional\n     * HTML entities use a third-party library like [_he_](https://mths.be/he).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.6.0\n     * @category String\n     * @param {string} [string=''] The string to unescape.\n     * @returns {string} Returns the unescaped string.\n     * @example\n     *\n     * _.unescape('fred, barney, &amp; pebbles');\n     * // => 'fred, barney, & pebbles'\n     */\n    function unescape(string) {\n      string = toString(string);\n      return (string && reHasEscapedHtml.test(string))\n        ? string.replace(reEscapedHtml, unescapeHtmlChar)\n        : string;\n    }\n\n    /**\n     * Converts `string`, as space separated words, to upper case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the upper cased string.\n     * @example\n     *\n     * _.upperCase('--foo-bar');\n     * // => 'FOO BAR'\n     *\n     * _.upperCase('fooBar');\n     * // => 'FOO BAR'\n     *\n     * _.upperCase('__foo_bar__');\n     * // => 'FOO BAR'\n     */\n    var upperCase = createCompounder(function(result, word, index) {\n      return result + (index ? ' ' : '') + word.toUpperCase();\n    });\n\n    /**\n     * Converts the first character of `string` to upper case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the converted string.\n     * @example\n     *\n     * _.upperFirst('fred');\n     * // => 'Fred'\n     *\n     * _.upperFirst('FRED');\n     * // => 'FRED'\n     */\n    var upperFirst = createCaseFirst('toUpperCase');\n\n    /**\n     * Splits `string` into an array of its words.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to inspect.\n     * @param {RegExp|string} [pattern] The pattern to match words.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the words of `string`.\n     * @example\n     *\n     * _.words('fred, barney, & pebbles');\n     * // => ['fred', 'barney', 'pebbles']\n     *\n     * _.words('fred, barney, & pebbles', /[^, ]+/g);\n     * // => ['fred', 'barney', '&', 'pebbles']\n     */\n    function words(string, pattern, guard) {\n      string = toString(string);\n      pattern = guard ? undefined : pattern;\n\n      if (pattern === undefined) {\n        return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);\n      }\n      return string.match(pattern) || [];\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Attempts to invoke `func`, returning either the result or the caught error\n     * object. Any additional arguments are provided to `func` when it's invoked.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {Function} func The function to attempt.\n     * @param {...*} [args] The arguments to invoke `func` with.\n     * @returns {*} Returns the `func` result or error object.\n     * @example\n     *\n     * // Avoid throwing errors for invalid selectors.\n     * var elements = _.attempt(function(selector) {\n     *   return document.querySelectorAll(selector);\n     * }, '>_>');\n     *\n     * if (_.isError(elements)) {\n     *   elements = [];\n     * }\n     */\n    var attempt = baseRest(function(func, args) {\n      try {\n        return apply(func, undefined, args);\n      } catch (e) {\n        return isError(e) ? e : new Error(e);\n      }\n    });\n\n    /**\n     * Binds methods of an object to the object itself, overwriting the existing\n     * method.\n     *\n     * **Note:** This method doesn't set the \"length\" property of bound functions.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {Object} object The object to bind and assign the bound methods to.\n     * @param {...(string|string[])} methodNames The object method names to bind.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var view = {\n     *   'label': 'docs',\n     *   'click': function() {\n     *     console.log('clicked ' + this.label);\n     *   }\n     * };\n     *\n     * _.bindAll(view, ['click']);\n     * jQuery(element).on('click', view.click);\n     * // => Logs 'clicked docs' when clicked.\n     */\n    var bindAll = flatRest(function(object, methodNames) {\n      arrayEach(methodNames, function(key) {\n        key = toKey(key);\n        baseAssignValue(object, key, bind(object[key], object));\n      });\n      return object;\n    });\n\n    /**\n     * Creates a function that iterates over `pairs` and invokes the corresponding\n     * function of the first predicate to return truthy. The predicate-function\n     * pairs are invoked with the `this` binding and arguments of the created\n     * function.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {Array} pairs The predicate-function pairs.\n     * @returns {Function} Returns the new composite function.\n     * @example\n     *\n     * var func = _.cond([\n     *   [_.matches({ 'a': 1 }),           _.constant('matches A')],\n     *   [_.conforms({ 'b': _.isNumber }), _.constant('matches B')],\n     *   [_.stubTrue,                      _.constant('no match')]\n     * ]);\n     *\n     * func({ 'a': 1, 'b': 2 });\n     * // => 'matches A'\n     *\n     * func({ 'a': 0, 'b': 1 });\n     * // => 'matches B'\n     *\n     * func({ 'a': '1', 'b': '2' });\n     * // => 'no match'\n     */\n    function cond(pairs) {\n      var length = pairs == null ? 0 : pairs.length,\n          toIteratee = getIteratee();\n\n      pairs = !length ? [] : arrayMap(pairs, function(pair) {\n        if (typeof pair[1] != 'function') {\n          throw new TypeError(FUNC_ERROR_TEXT);\n        }\n        return [toIteratee(pair[0]), pair[1]];\n      });\n\n      return baseRest(function(args) {\n        var index = -1;\n        while (++index < length) {\n          var pair = pairs[index];\n          if (apply(pair[0], this, args)) {\n            return apply(pair[1], this, args);\n          }\n        }\n      });\n    }\n\n    /**\n     * Creates a function that invokes the predicate properties of `source` with\n     * the corresponding property values of a given object, returning `true` if\n     * all predicates return truthy, else `false`.\n     *\n     * **Note:** The created function is equivalent to `_.conformsTo` with\n     * `source` partially applied.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {Function} Returns the new spec function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': 2, 'b': 1 },\n     *   { 'a': 1, 'b': 2 }\n     * ];\n     *\n     * _.filter(objects, _.conforms({ 'b': function(n) { return n > 1; } }));\n     * // => [{ 'a': 1, 'b': 2 }]\n     */\n    function conforms(source) {\n      return baseConforms(baseClone(source, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that returns `value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Util\n     * @param {*} value The value to return from the new function.\n     * @returns {Function} Returns the new constant function.\n     * @example\n     *\n     * var objects = _.times(2, _.constant({ 'a': 1 }));\n     *\n     * console.log(objects);\n     * // => [{ 'a': 1 }, { 'a': 1 }]\n     *\n     * console.log(objects[0] === objects[1]);\n     * // => true\n     */\n    function constant(value) {\n      return function() {\n        return value;\n      };\n    }\n\n    /**\n     * Checks `value` to determine whether a default value should be returned in\n     * its place. The `defaultValue` is returned if `value` is `NaN`, `null`,\n     * or `undefined`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.14.0\n     * @category Util\n     * @param {*} value The value to check.\n     * @param {*} defaultValue The default value.\n     * @returns {*} Returns the resolved value.\n     * @example\n     *\n     * _.defaultTo(1, 10);\n     * // => 1\n     *\n     * _.defaultTo(undefined, 10);\n     * // => 10\n     */\n    function defaultTo(value, defaultValue) {\n      return (value == null || value !== value) ? defaultValue : value;\n    }\n\n    /**\n     * Creates a function that returns the result of invoking the given functions\n     * with the `this` binding of the created function, where each successive\n     * invocation is supplied the return value of the previous.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [funcs] The functions to invoke.\n     * @returns {Function} Returns the new composite function.\n     * @see _.flowRight\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var addSquare = _.flow([_.add, square]);\n     * addSquare(1, 2);\n     * // => 9\n     */\n    var flow = createFlow();\n\n    /**\n     * This method is like `_.flow` except that it creates a function that\n     * invokes the given functions from right to left.\n     *\n     * @static\n     * @since 3.0.0\n     * @memberOf _\n     * @category Util\n     * @param {...(Function|Function[])} [funcs] The functions to invoke.\n     * @returns {Function} Returns the new composite function.\n     * @see _.flow\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var addSquare = _.flowRight([square, _.add]);\n     * addSquare(1, 2);\n     * // => 9\n     */\n    var flowRight = createFlow(true);\n\n    /**\n     * This method returns the first argument it receives.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {*} value Any value.\n     * @returns {*} Returns `value`.\n     * @example\n     *\n     * var object = { 'a': 1 };\n     *\n     * console.log(_.identity(object) === object);\n     * // => true\n     */\n    function identity(value) {\n      return value;\n    }\n\n    /**\n     * Creates a function that invokes `func` with the arguments of the created\n     * function. If `func` is a property name, the created function returns the\n     * property value for a given element. If `func` is an array or object, the\n     * created function returns `true` for elements that contain the equivalent\n     * source properties, otherwise it returns `false`.\n     *\n     * @static\n     * @since 4.0.0\n     * @memberOf _\n     * @category Util\n     * @param {*} [func=_.identity] The value to convert to a callback.\n     * @returns {Function} Returns the callback.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': true },\n     *   { 'user': 'fred',   'age': 40, 'active': false }\n     * ];\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));\n     * // => [{ 'user': 'barney', 'age': 36, 'active': true }]\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.filter(users, _.iteratee(['user', 'fred']));\n     * // => [{ 'user': 'fred', 'age': 40 }]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.map(users, _.iteratee('user'));\n     * // => ['barney', 'fred']\n     *\n     * // Create custom iteratee shorthands.\n     * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {\n     *   return !_.isRegExp(func) ? iteratee(func) : function(string) {\n     *     return func.test(string);\n     *   };\n     * });\n     *\n     * _.filter(['abc', 'def'], /ef/);\n     * // => ['def']\n     */\n    function iteratee(func) {\n      return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that performs a partial deep comparison between a given\n     * object and `source`, returning `true` if the given object has equivalent\n     * property values, else `false`.\n     *\n     * **Note:** The created function is equivalent to `_.isMatch` with `source`\n     * partially applied.\n     *\n     * Partial comparisons will match empty array and empty object `source`\n     * values against any array or object value, respectively. See `_.isEqual`\n     * for a list of supported value comparisons.\n     *\n     * **Note:** Multiple values can be checked by combining several matchers\n     * using `_.overSome`\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {Object} source The object of property values to match.\n     * @returns {Function} Returns the new spec function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': 1, 'b': 2, 'c': 3 },\n     *   { 'a': 4, 'b': 5, 'c': 6 }\n     * ];\n     *\n     * _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));\n     * // => [{ 'a': 4, 'b': 5, 'c': 6 }]\n     *\n     * // Checking for several possible values\n     * _.filter(objects, _.overSome([_.matches({ 'a': 1 }), _.matches({ 'a': 4 })]));\n     * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]\n     */\n    function matches(source) {\n      return baseMatches(baseClone(source, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that performs a partial deep comparison between the\n     * value at `path` of a given object to `srcValue`, returning `true` if the\n     * object value is equivalent, else `false`.\n     *\n     * **Note:** Partial comparisons will match empty array and empty object\n     * `srcValue` values against any array or object value, respectively. See\n     * `_.isEqual` for a list of supported value comparisons.\n     *\n     * **Note:** Multiple values can be checked by combining several matchers\n     * using `_.overSome`\n     *\n     * @static\n     * @memberOf _\n     * @since 3.2.0\n     * @category Util\n     * @param {Array|string} path The path of the property to get.\n     * @param {*} srcValue The value to match.\n     * @returns {Function} Returns the new spec function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': 1, 'b': 2, 'c': 3 },\n     *   { 'a': 4, 'b': 5, 'c': 6 }\n     * ];\n     *\n     * _.find(objects, _.matchesProperty('a', 4));\n     * // => { 'a': 4, 'b': 5, 'c': 6 }\n     *\n     * // Checking for several possible values\n     * _.filter(objects, _.overSome([_.matchesProperty('a', 1), _.matchesProperty('a', 4)]));\n     * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]\n     */\n    function matchesProperty(path, srcValue) {\n      return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that invokes the method at `path` of a given object.\n     * Any additional arguments are provided to the invoked method.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Util\n     * @param {Array|string} path The path of the method to invoke.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {Function} Returns the new invoker function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': { 'b': _.constant(2) } },\n     *   { 'a': { 'b': _.constant(1) } }\n     * ];\n     *\n     * _.map(objects, _.method('a.b'));\n     * // => [2, 1]\n     *\n     * _.map(objects, _.method(['a', 'b']));\n     * // => [2, 1]\n     */\n    var method = baseRest(function(path, args) {\n      return function(object) {\n        return baseInvoke(object, path, args);\n      };\n    });\n\n    /**\n     * The opposite of `_.method`; this method creates a function that invokes\n     * the method at a given path of `object`. Any additional arguments are\n     * provided to the invoked method.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Util\n     * @param {Object} object The object to query.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {Function} Returns the new invoker function.\n     * @example\n     *\n     * var array = _.times(3, _.constant),\n     *     object = { 'a': array, 'b': array, 'c': array };\n     *\n     * _.map(['a[2]', 'c[0]'], _.methodOf(object));\n     * // => [2, 0]\n     *\n     * _.map([['a', '2'], ['c', '0']], _.methodOf(object));\n     * // => [2, 0]\n     */\n    var methodOf = baseRest(function(object, args) {\n      return function(path) {\n        return baseInvoke(object, path, args);\n      };\n    });\n\n    /**\n     * Adds all own enumerable string keyed function properties of a source\n     * object to the destination object. If `object` is a function, then methods\n     * are added to its prototype as well.\n     *\n     * **Note:** Use `_.runInContext` to create a pristine `lodash` function to\n     * avoid conflicts caused by modifying the original.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {Function|Object} [object=lodash] The destination object.\n     * @param {Object} source The object of functions to add.\n     * @param {Object} [options={}] The options object.\n     * @param {boolean} [options.chain=true] Specify whether mixins are chainable.\n     * @returns {Function|Object} Returns `object`.\n     * @example\n     *\n     * function vowels(string) {\n     *   return _.filter(string, function(v) {\n     *     return /[aeiou]/i.test(v);\n     *   });\n     * }\n     *\n     * _.mixin({ 'vowels': vowels });\n     * _.vowels('fred');\n     * // => ['e']\n     *\n     * _('fred').vowels().value();\n     * // => ['e']\n     *\n     * _.mixin({ 'vowels': vowels }, { 'chain': false });\n     * _('fred').vowels();\n     * // => ['e']\n     */\n    function mixin(object, source, options) {\n      var props = keys(source),\n          methodNames = baseFunctions(source, props);\n\n      if (options == null &&\n          !(isObject(source) && (methodNames.length || !props.length))) {\n        options = source;\n        source = object;\n        object = this;\n        methodNames = baseFunctions(source, keys(source));\n      }\n      var chain = !(isObject(options) && 'chain' in options) || !!options.chain,\n          isFunc = isFunction(object);\n\n      arrayEach(methodNames, function(methodName) {\n        var func = source[methodName];\n        object[methodName] = func;\n        if (isFunc) {\n          object.prototype[methodName] = function() {\n            var chainAll = this.__chain__;\n            if (chain || chainAll) {\n              var result = object(this.__wrapped__),\n                  actions = result.__actions__ = copyArray(this.__actions__);\n\n              actions.push({ 'func': func, 'args': arguments, 'thisArg': object });\n              result.__chain__ = chainAll;\n              return result;\n            }\n            return func.apply(object, arrayPush([this.value()], arguments));\n          };\n        }\n      });\n\n      return object;\n    }\n\n    /**\n     * Reverts the `_` variable to its previous value and returns a reference to\n     * the `lodash` function.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @returns {Function} Returns the `lodash` function.\n     * @example\n     *\n     * var lodash = _.noConflict();\n     */\n    function noConflict() {\n      if (root._ === this) {\n        root._ = oldDash;\n      }\n      return this;\n    }\n\n    /**\n     * This method returns `undefined`.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.3.0\n     * @category Util\n     * @example\n     *\n     * _.times(2, _.noop);\n     * // => [undefined, undefined]\n     */\n    function noop() {\n      // No operation performed.\n    }\n\n    /**\n     * Creates a function that gets the argument at index `n`. If `n` is negative,\n     * the nth argument from the end is returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {number} [n=0] The index of the argument to return.\n     * @returns {Function} Returns the new pass-thru function.\n     * @example\n     *\n     * var func = _.nthArg(1);\n     * func('a', 'b', 'c', 'd');\n     * // => 'b'\n     *\n     * var func = _.nthArg(-2);\n     * func('a', 'b', 'c', 'd');\n     * // => 'c'\n     */\n    function nthArg(n) {\n      n = toInteger(n);\n      return baseRest(function(args) {\n        return baseNth(args, n);\n      });\n    }\n\n    /**\n     * Creates a function that invokes `iteratees` with the arguments it receives\n     * and returns their results.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [iteratees=[_.identity]]\n     *  The iteratees to invoke.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var func = _.over([Math.max, Math.min]);\n     *\n     * func(1, 2, 3, 4);\n     * // => [4, 1]\n     */\n    var over = createOver(arrayMap);\n\n    /**\n     * Creates a function that checks if **all** of the `predicates` return\n     * truthy when invoked with the arguments it receives.\n     *\n     * Following shorthands are possible for providing predicates.\n     * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.\n     * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [predicates=[_.identity]]\n     *  The predicates to check.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var func = _.overEvery([Boolean, isFinite]);\n     *\n     * func('1');\n     * // => true\n     *\n     * func(null);\n     * // => false\n     *\n     * func(NaN);\n     * // => false\n     */\n    var overEvery = createOver(arrayEvery);\n\n    /**\n     * Creates a function that checks if **any** of the `predicates` return\n     * truthy when invoked with the arguments it receives.\n     *\n     * Following shorthands are possible for providing predicates.\n     * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.\n     * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [predicates=[_.identity]]\n     *  The predicates to check.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var func = _.overSome([Boolean, isFinite]);\n     *\n     * func('1');\n     * // => true\n     *\n     * func(null);\n     * // => true\n     *\n     * func(NaN);\n     * // => false\n     *\n     * var matchesFunc = _.overSome([{ 'a': 1 }, { 'a': 2 }])\n     * var matchesPropertyFunc = _.overSome([['a', 1], ['a', 2]])\n     */\n    var overSome = createOver(arraySome);\n\n    /**\n     * Creates a function that returns the value at `path` of a given object.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Util\n     * @param {Array|string} path The path of the property to get.\n     * @returns {Function} Returns the new accessor function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': { 'b': 2 } },\n     *   { 'a': { 'b': 1 } }\n     * ];\n     *\n     * _.map(objects, _.property('a.b'));\n     * // => [2, 1]\n     *\n     * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');\n     * // => [1, 2]\n     */\n    function property(path) {\n      return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);\n    }\n\n    /**\n     * The opposite of `_.property`; this method creates a function that returns\n     * the value at a given path of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {Object} object The object to query.\n     * @returns {Function} Returns the new accessor function.\n     * @example\n     *\n     * var array = [0, 1, 2],\n     *     object = { 'a': array, 'b': array, 'c': array };\n     *\n     * _.map(['a[2]', 'c[0]'], _.propertyOf(object));\n     * // => [2, 0]\n     *\n     * _.map([['a', '2'], ['c', '0']], _.propertyOf(object));\n     * // => [2, 0]\n     */\n    function propertyOf(object) {\n      return function(path) {\n        return object == null ? undefined : baseGet(object, path);\n      };\n    }\n\n    /**\n     * Creates an array of numbers (positive and/or negative) progressing from\n     * `start` up to, but not including, `end`. A step of `-1` is used if a negative\n     * `start` is specified without an `end` or `step`. If `end` is not specified,\n     * it's set to `start` with `start` then set to `0`.\n     *\n     * **Note:** JavaScript follows the IEEE-754 standard for resolving\n     * floating-point values which can produce unexpected results.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {number} [start=0] The start of the range.\n     * @param {number} end The end of the range.\n     * @param {number} [step=1] The value to increment or decrement by.\n     * @returns {Array} Returns the range of numbers.\n     * @see _.inRange, _.rangeRight\n     * @example\n     *\n     * _.range(4);\n     * // => [0, 1, 2, 3]\n     *\n     * _.range(-4);\n     * // => [0, -1, -2, -3]\n     *\n     * _.range(1, 5);\n     * // => [1, 2, 3, 4]\n     *\n     * _.range(0, 20, 5);\n     * // => [0, 5, 10, 15]\n     *\n     * _.range(0, -4, -1);\n     * // => [0, -1, -2, -3]\n     *\n     * _.range(1, 4, 0);\n     * // => [1, 1, 1]\n     *\n     * _.range(0);\n     * // => []\n     */\n    var range = createRange();\n\n    /**\n     * This method is like `_.range` except that it populates values in\n     * descending order.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {number} [start=0] The start of the range.\n     * @param {number} end The end of the range.\n     * @param {number} [step=1] The value to increment or decrement by.\n     * @returns {Array} Returns the range of numbers.\n     * @see _.inRange, _.range\n     * @example\n     *\n     * _.rangeRight(4);\n     * // => [3, 2, 1, 0]\n     *\n     * _.rangeRight(-4);\n     * // => [-3, -2, -1, 0]\n     *\n     * _.rangeRight(1, 5);\n     * // => [4, 3, 2, 1]\n     *\n     * _.rangeRight(0, 20, 5);\n     * // => [15, 10, 5, 0]\n     *\n     * _.rangeRight(0, -4, -1);\n     * // => [-3, -2, -1, 0]\n     *\n     * _.rangeRight(1, 4, 0);\n     * // => [1, 1, 1]\n     *\n     * _.rangeRight(0);\n     * // => []\n     */\n    var rangeRight = createRange(true);\n\n    /**\n     * This method returns a new empty array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {Array} Returns the new empty array.\n     * @example\n     *\n     * var arrays = _.times(2, _.stubArray);\n     *\n     * console.log(arrays);\n     * // => [[], []]\n     *\n     * console.log(arrays[0] === arrays[1]);\n     * // => false\n     */\n    function stubArray() {\n      return [];\n    }\n\n    /**\n     * This method returns `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {boolean} Returns `false`.\n     * @example\n     *\n     * _.times(2, _.stubFalse);\n     * // => [false, false]\n     */\n    function stubFalse() {\n      return false;\n    }\n\n    /**\n     * This method returns a new empty object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {Object} Returns the new empty object.\n     * @example\n     *\n     * var objects = _.times(2, _.stubObject);\n     *\n     * console.log(objects);\n     * // => [{}, {}]\n     *\n     * console.log(objects[0] === objects[1]);\n     * // => false\n     */\n    function stubObject() {\n      return {};\n    }\n\n    /**\n     * This method returns an empty string.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {string} Returns the empty string.\n     * @example\n     *\n     * _.times(2, _.stubString);\n     * // => ['', '']\n     */\n    function stubString() {\n      return '';\n    }\n\n    /**\n     * This method returns `true`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {boolean} Returns `true`.\n     * @example\n     *\n     * _.times(2, _.stubTrue);\n     * // => [true, true]\n     */\n    function stubTrue() {\n      return true;\n    }\n\n    /**\n     * Invokes the iteratee `n` times, returning an array of the results of\n     * each invocation. The iteratee is invoked with one argument; (index).\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {number} n The number of times to invoke `iteratee`.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the array of results.\n     * @example\n     *\n     * _.times(3, String);\n     * // => ['0', '1', '2']\n     *\n     *  _.times(4, _.constant(0));\n     * // => [0, 0, 0, 0]\n     */\n    function times(n, iteratee) {\n      n = toInteger(n);\n      if (n < 1 || n > MAX_SAFE_INTEGER) {\n        return [];\n      }\n      var index = MAX_ARRAY_LENGTH,\n          length = nativeMin(n, MAX_ARRAY_LENGTH);\n\n      iteratee = getIteratee(iteratee);\n      n -= MAX_ARRAY_LENGTH;\n\n      var result = baseTimes(length, iteratee);\n      while (++index < n) {\n        iteratee(index);\n      }\n      return result;\n    }\n\n    /**\n     * Converts `value` to a property path array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {*} value The value to convert.\n     * @returns {Array} Returns the new property path array.\n     * @example\n     *\n     * _.toPath('a.b.c');\n     * // => ['a', 'b', 'c']\n     *\n     * _.toPath('a[0].b.c');\n     * // => ['a', '0', 'b', 'c']\n     */\n    function toPath(value) {\n      if (isArray(value)) {\n        return arrayMap(value, toKey);\n      }\n      return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));\n    }\n\n    /**\n     * Generates a unique ID. If `prefix` is given, the ID is appended to it.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {string} [prefix=''] The value to prefix the ID with.\n     * @returns {string} Returns the unique ID.\n     * @example\n     *\n     * _.uniqueId('contact_');\n     * // => 'contact_104'\n     *\n     * _.uniqueId();\n     * // => '105'\n     */\n    function uniqueId(prefix) {\n      var id = ++idCounter;\n      return toString(prefix) + id;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Adds two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.4.0\n     * @category Math\n     * @param {number} augend The first number in an addition.\n     * @param {number} addend The second number in an addition.\n     * @returns {number} Returns the total.\n     * @example\n     *\n     * _.add(6, 4);\n     * // => 10\n     */\n    var add = createMathOperation(function(augend, addend) {\n      return augend + addend;\n    }, 0);\n\n    /**\n     * Computes `number` rounded up to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Math\n     * @param {number} number The number to round up.\n     * @param {number} [precision=0] The precision to round up to.\n     * @returns {number} Returns the rounded up number.\n     * @example\n     *\n     * _.ceil(4.006);\n     * // => 5\n     *\n     * _.ceil(6.004, 2);\n     * // => 6.01\n     *\n     * _.ceil(6040, -2);\n     * // => 6100\n     */\n    var ceil = createRound('ceil');\n\n    /**\n     * Divide two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Math\n     * @param {number} dividend The first number in a division.\n     * @param {number} divisor The second number in a division.\n     * @returns {number} Returns the quotient.\n     * @example\n     *\n     * _.divide(6, 4);\n     * // => 1.5\n     */\n    var divide = createMathOperation(function(dividend, divisor) {\n      return dividend / divisor;\n    }, 1);\n\n    /**\n     * Computes `number` rounded down to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Math\n     * @param {number} number The number to round down.\n     * @param {number} [precision=0] The precision to round down to.\n     * @returns {number} Returns the rounded down number.\n     * @example\n     *\n     * _.floor(4.006);\n     * // => 4\n     *\n     * _.floor(0.046, 2);\n     * // => 0.04\n     *\n     * _.floor(4060, -2);\n     * // => 4000\n     */\n    var floor = createRound('floor');\n\n    /**\n     * Computes the maximum value of `array`. If `array` is empty or falsey,\n     * `undefined` is returned.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {*} Returns the maximum value.\n     * @example\n     *\n     * _.max([4, 2, 8, 6]);\n     * // => 8\n     *\n     * _.max([]);\n     * // => undefined\n     */\n    function max(array) {\n      return (array && array.length)\n        ? baseExtremum(array, identity, baseGt)\n        : undefined;\n    }\n\n    /**\n     * This method is like `_.max` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the criterion by which\n     * the value is ranked. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {*} Returns the maximum value.\n     * @example\n     *\n     * var objects = [{ 'n': 1 }, { 'n': 2 }];\n     *\n     * _.maxBy(objects, function(o) { return o.n; });\n     * // => { 'n': 2 }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.maxBy(objects, 'n');\n     * // => { 'n': 2 }\n     */\n    function maxBy(array, iteratee) {\n      return (array && array.length)\n        ? baseExtremum(array, getIteratee(iteratee, 2), baseGt)\n        : undefined;\n    }\n\n    /**\n     * Computes the mean of the values in `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {number} Returns the mean.\n     * @example\n     *\n     * _.mean([4, 2, 8, 6]);\n     * // => 5\n     */\n    function mean(array) {\n      return baseMean(array, identity);\n    }\n\n    /**\n     * This method is like `_.mean` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the value to be averaged.\n     * The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the mean.\n     * @example\n     *\n     * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];\n     *\n     * _.meanBy(objects, function(o) { return o.n; });\n     * // => 5\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.meanBy(objects, 'n');\n     * // => 5\n     */\n    function meanBy(array, iteratee) {\n      return baseMean(array, getIteratee(iteratee, 2));\n    }\n\n    /**\n     * Computes the minimum value of `array`. If `array` is empty or falsey,\n     * `undefined` is returned.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {*} Returns the minimum value.\n     * @example\n     *\n     * _.min([4, 2, 8, 6]);\n     * // => 2\n     *\n     * _.min([]);\n     * // => undefined\n     */\n    function min(array) {\n      return (array && array.length)\n        ? baseExtremum(array, identity, baseLt)\n        : undefined;\n    }\n\n    /**\n     * This method is like `_.min` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the criterion by which\n     * the value is ranked. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {*} Returns the minimum value.\n     * @example\n     *\n     * var objects = [{ 'n': 1 }, { 'n': 2 }];\n     *\n     * _.minBy(objects, function(o) { return o.n; });\n     * // => { 'n': 1 }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.minBy(objects, 'n');\n     * // => { 'n': 1 }\n     */\n    function minBy(array, iteratee) {\n      return (array && array.length)\n        ? baseExtremum(array, getIteratee(iteratee, 2), baseLt)\n        : undefined;\n    }\n\n    /**\n     * Multiply two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Math\n     * @param {number} multiplier The first number in a multiplication.\n     * @param {number} multiplicand The second number in a multiplication.\n     * @returns {number} Returns the product.\n     * @example\n     *\n     * _.multiply(6, 4);\n     * // => 24\n     */\n    var multiply = createMathOperation(function(multiplier, multiplicand) {\n      return multiplier * multiplicand;\n    }, 1);\n\n    /**\n     * Computes `number` rounded to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Math\n     * @param {number} number The number to round.\n     * @param {number} [precision=0] The precision to round to.\n     * @returns {number} Returns the rounded number.\n     * @example\n     *\n     * _.round(4.006);\n     * // => 4\n     *\n     * _.round(4.006, 2);\n     * // => 4.01\n     *\n     * _.round(4060, -2);\n     * // => 4100\n     */\n    var round = createRound('round');\n\n    /**\n     * Subtract two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {number} minuend The first number in a subtraction.\n     * @param {number} subtrahend The second number in a subtraction.\n     * @returns {number} Returns the difference.\n     * @example\n     *\n     * _.subtract(6, 4);\n     * // => 2\n     */\n    var subtract = createMathOperation(function(minuend, subtrahend) {\n      return minuend - subtrahend;\n    }, 0);\n\n    /**\n     * Computes the sum of the values in `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.4.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {number} Returns the sum.\n     * @example\n     *\n     * _.sum([4, 2, 8, 6]);\n     * // => 20\n     */\n    function sum(array) {\n      return (array && array.length)\n        ? baseSum(array, identity)\n        : 0;\n    }\n\n    /**\n     * This method is like `_.sum` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the value to be summed.\n     * The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the sum.\n     * @example\n     *\n     * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];\n     *\n     * _.sumBy(objects, function(o) { return o.n; });\n     * // => 20\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.sumBy(objects, 'n');\n     * // => 20\n     */\n    function sumBy(array, iteratee) {\n      return (array && array.length)\n        ? baseSum(array, getIteratee(iteratee, 2))\n        : 0;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    // Add methods that return wrapped values in chain sequences.\n    lodash.after = after;\n    lodash.ary = ary;\n    lodash.assign = assign;\n    lodash.assignIn = assignIn;\n    lodash.assignInWith = assignInWith;\n    lodash.assignWith = assignWith;\n    lodash.at = at;\n    lodash.before = before;\n    lodash.bind = bind;\n    lodash.bindAll = bindAll;\n    lodash.bindKey = bindKey;\n    lodash.castArray = castArray;\n    lodash.chain = chain;\n    lodash.chunk = chunk;\n    lodash.compact = compact;\n    lodash.concat = concat;\n    lodash.cond = cond;\n    lodash.conforms = conforms;\n    lodash.constant = constant;\n    lodash.countBy = countBy;\n    lodash.create = create;\n    lodash.curry = curry;\n    lodash.curryRight = curryRight;\n    lodash.debounce = debounce;\n    lodash.defaults = defaults;\n    lodash.defaultsDeep = defaultsDeep;\n    lodash.defer = defer;\n    lodash.delay = delay;\n    lodash.difference = difference;\n    lodash.differenceBy = differenceBy;\n    lodash.differenceWith = differenceWith;\n    lodash.drop = drop;\n    lodash.dropRight = dropRight;\n    lodash.dropRightWhile = dropRightWhile;\n    lodash.dropWhile = dropWhile;\n    lodash.fill = fill;\n    lodash.filter = filter;\n    lodash.flatMap = flatMap;\n    lodash.flatMapDeep = flatMapDeep;\n    lodash.flatMapDepth = flatMapDepth;\n    lodash.flatten = flatten;\n    lodash.flattenDeep = flattenDeep;\n    lodash.flattenDepth = flattenDepth;\n    lodash.flip = flip;\n    lodash.flow = flow;\n    lodash.flowRight = flowRight;\n    lodash.fromPairs = fromPairs;\n    lodash.functions = functions;\n    lodash.functionsIn = functionsIn;\n    lodash.groupBy = groupBy;\n    lodash.initial = initial;\n    lodash.intersection = intersection;\n    lodash.intersectionBy = intersectionBy;\n    lodash.intersectionWith = intersectionWith;\n    lodash.invert = invert;\n    lodash.invertBy = invertBy;\n    lodash.invokeMap = invokeMap;\n    lodash.iteratee = iteratee;\n    lodash.keyBy = keyBy;\n    lodash.keys = keys;\n    lodash.keysIn = keysIn;\n    lodash.map = map;\n    lodash.mapKeys = mapKeys;\n    lodash.mapValues = mapValues;\n    lodash.matches = matches;\n    lodash.matchesProperty = matchesProperty;\n    lodash.memoize = memoize;\n    lodash.merge = merge;\n    lodash.mergeWith = mergeWith;\n    lodash.method = method;\n    lodash.methodOf = methodOf;\n    lodash.mixin = mixin;\n    lodash.negate = negate;\n    lodash.nthArg = nthArg;\n    lodash.omit = omit;\n    lodash.omitBy = omitBy;\n    lodash.once = once;\n    lodash.orderBy = orderBy;\n    lodash.over = over;\n    lodash.overArgs = overArgs;\n    lodash.overEvery = overEvery;\n    lodash.overSome = overSome;\n    lodash.partial = partial;\n    lodash.partialRight = partialRight;\n    lodash.partition = partition;\n    lodash.pick = pick;\n    lodash.pickBy = pickBy;\n    lodash.property = property;\n    lodash.propertyOf = propertyOf;\n    lodash.pull = pull;\n    lodash.pullAll = pullAll;\n    lodash.pullAllBy = pullAllBy;\n    lodash.pullAllWith = pullAllWith;\n    lodash.pullAt = pullAt;\n    lodash.range = range;\n    lodash.rangeRight = rangeRight;\n    lodash.rearg = rearg;\n    lodash.reject = reject;\n    lodash.remove = remove;\n    lodash.rest = rest;\n    lodash.reverse = reverse;\n    lodash.sampleSize = sampleSize;\n    lodash.set = set;\n    lodash.setWith = setWith;\n    lodash.shuffle = shuffle;\n    lodash.slice = slice;\n    lodash.sortBy = sortBy;\n    lodash.sortedUniq = sortedUniq;\n    lodash.sortedUniqBy = sortedUniqBy;\n    lodash.split = split;\n    lodash.spread = spread;\n    lodash.tail = tail;\n    lodash.take = take;\n    lodash.takeRight = takeRight;\n    lodash.takeRightWhile = takeRightWhile;\n    lodash.takeWhile = takeWhile;\n    lodash.tap = tap;\n    lodash.throttle = throttle;\n    lodash.thru = thru;\n    lodash.toArray = toArray;\n    lodash.toPairs = toPairs;\n    lodash.toPairsIn = toPairsIn;\n    lodash.toPath = toPath;\n    lodash.toPlainObject = toPlainObject;\n    lodash.transform = transform;\n    lodash.unary = unary;\n    lodash.union = union;\n    lodash.unionBy = unionBy;\n    lodash.unionWith = unionWith;\n    lodash.uniq = uniq;\n    lodash.uniqBy = uniqBy;\n    lodash.uniqWith = uniqWith;\n    lodash.unset = unset;\n    lodash.unzip = unzip;\n    lodash.unzipWith = unzipWith;\n    lodash.update = update;\n    lodash.updateWith = updateWith;\n    lodash.values = values;\n    lodash.valuesIn = valuesIn;\n    lodash.without = without;\n    lodash.words = words;\n    lodash.wrap = wrap;\n    lodash.xor = xor;\n    lodash.xorBy = xorBy;\n    lodash.xorWith = xorWith;\n    lodash.zip = zip;\n    lodash.zipObject = zipObject;\n    lodash.zipObjectDeep = zipObjectDeep;\n    lodash.zipWith = zipWith;\n\n    // Add aliases.\n    lodash.entries = toPairs;\n    lodash.entriesIn = toPairsIn;\n    lodash.extend = assignIn;\n    lodash.extendWith = assignInWith;\n\n    // Add methods to `lodash.prototype`.\n    mixin(lodash, lodash);\n\n    /*------------------------------------------------------------------------*/\n\n    // Add methods that return unwrapped values in chain sequences.\n    lodash.add = add;\n    lodash.attempt = attempt;\n    lodash.camelCase = camelCase;\n    lodash.capitalize = capitalize;\n    lodash.ceil = ceil;\n    lodash.clamp = clamp;\n    lodash.clone = clone;\n    lodash.cloneDeep = cloneDeep;\n    lodash.cloneDeepWith = cloneDeepWith;\n    lodash.cloneWith = cloneWith;\n    lodash.conformsTo = conformsTo;\n    lodash.deburr = deburr;\n    lodash.defaultTo = defaultTo;\n    lodash.divide = divide;\n    lodash.endsWith = endsWith;\n    lodash.eq = eq;\n    lodash.escape = escape;\n    lodash.escapeRegExp = escapeRegExp;\n    lodash.every = every;\n    lodash.find = find;\n    lodash.findIndex = findIndex;\n    lodash.findKey = findKey;\n    lodash.findLast = findLast;\n    lodash.findLastIndex = findLastIndex;\n    lodash.findLastKey = findLastKey;\n    lodash.floor = floor;\n    lodash.forEach = forEach;\n    lodash.forEachRight = forEachRight;\n    lodash.forIn = forIn;\n    lodash.forInRight = forInRight;\n    lodash.forOwn = forOwn;\n    lodash.forOwnRight = forOwnRight;\n    lodash.get = get;\n    lodash.gt = gt;\n    lodash.gte = gte;\n    lodash.has = has;\n    lodash.hasIn = hasIn;\n    lodash.head = head;\n    lodash.identity = identity;\n    lodash.includes = includes;\n    lodash.indexOf = indexOf;\n    lodash.inRange = inRange;\n    lodash.invoke = invoke;\n    lodash.isArguments = isArguments;\n    lodash.isArray = isArray;\n    lodash.isArrayBuffer = isArrayBuffer;\n    lodash.isArrayLike = isArrayLike;\n    lodash.isArrayLikeObject = isArrayLikeObject;\n    lodash.isBoolean = isBoolean;\n    lodash.isBuffer = isBuffer;\n    lodash.isDate = isDate;\n    lodash.isElement = isElement;\n    lodash.isEmpty = isEmpty;\n    lodash.isEqual = isEqual;\n    lodash.isEqualWith = isEqualWith;\n    lodash.isError = isError;\n    lodash.isFinite = isFinite;\n    lodash.isFunction = isFunction;\n    lodash.isInteger = isInteger;\n    lodash.isLength = isLength;\n    lodash.isMap = isMap;\n    lodash.isMatch = isMatch;\n    lodash.isMatchWith = isMatchWith;\n    lodash.isNaN = isNaN;\n    lodash.isNative = isNative;\n    lodash.isNil = isNil;\n    lodash.isNull = isNull;\n    lodash.isNumber = isNumber;\n    lodash.isObject = isObject;\n    lodash.isObjectLike = isObjectLike;\n    lodash.isPlainObject = isPlainObject;\n    lodash.isRegExp = isRegExp;\n    lodash.isSafeInteger = isSafeInteger;\n    lodash.isSet = isSet;\n    lodash.isString = isString;\n    lodash.isSymbol = isSymbol;\n    lodash.isTypedArray = isTypedArray;\n    lodash.isUndefined = isUndefined;\n    lodash.isWeakMap = isWeakMap;\n    lodash.isWeakSet = isWeakSet;\n    lodash.join = join;\n    lodash.kebabCase = kebabCase;\n    lodash.last = last;\n    lodash.lastIndexOf = lastIndexOf;\n    lodash.lowerCase = lowerCase;\n    lodash.lowerFirst = lowerFirst;\n    lodash.lt = lt;\n    lodash.lte = lte;\n    lodash.max = max;\n    lodash.maxBy = maxBy;\n    lodash.mean = mean;\n    lodash.meanBy = meanBy;\n    lodash.min = min;\n    lodash.minBy = minBy;\n    lodash.stubArray = stubArray;\n    lodash.stubFalse = stubFalse;\n    lodash.stubObject = stubObject;\n    lodash.stubString = stubString;\n    lodash.stubTrue = stubTrue;\n    lodash.multiply = multiply;\n    lodash.nth = nth;\n    lodash.noConflict = noConflict;\n    lodash.noop = noop;\n    lodash.now = now;\n    lodash.pad = pad;\n    lodash.padEnd = padEnd;\n    lodash.padStart = padStart;\n    lodash.parseInt = parseInt;\n    lodash.random = random;\n    lodash.reduce = reduce;\n    lodash.reduceRight = reduceRight;\n    lodash.repeat = repeat;\n    lodash.replace = replace;\n    lodash.result = result;\n    lodash.round = round;\n    lodash.runInContext = runInContext;\n    lodash.sample = sample;\n    lodash.size = size;\n    lodash.snakeCase = snakeCase;\n    lodash.some = some;\n    lodash.sortedIndex = sortedIndex;\n    lodash.sortedIndexBy = sortedIndexBy;\n    lodash.sortedIndexOf = sortedIndexOf;\n    lodash.sortedLastIndex = sortedLastIndex;\n    lodash.sortedLastIndexBy = sortedLastIndexBy;\n    lodash.sortedLastIndexOf = sortedLastIndexOf;\n    lodash.startCase = startCase;\n    lodash.startsWith = startsWith;\n    lodash.subtract = subtract;\n    lodash.sum = sum;\n    lodash.sumBy = sumBy;\n    lodash.template = template;\n    lodash.times = times;\n    lodash.toFinite = toFinite;\n    lodash.toInteger = toInteger;\n    lodash.toLength = toLength;\n    lodash.toLower = toLower;\n    lodash.toNumber = toNumber;\n    lodash.toSafeInteger = toSafeInteger;\n    lodash.toString = toString;\n    lodash.toUpper = toUpper;\n    lodash.trim = trim;\n    lodash.trimEnd = trimEnd;\n    lodash.trimStart = trimStart;\n    lodash.truncate = truncate;\n    lodash.unescape = unescape;\n    lodash.uniqueId = uniqueId;\n    lodash.upperCase = upperCase;\n    lodash.upperFirst = upperFirst;\n\n    // Add aliases.\n    lodash.each = forEach;\n    lodash.eachRight = forEachRight;\n    lodash.first = head;\n\n    mixin(lodash, (function() {\n      var source = {};\n      baseForOwn(lodash, function(func, methodName) {\n        if (!hasOwnProperty.call(lodash.prototype, methodName)) {\n          source[methodName] = func;\n        }\n      });\n      return source;\n    }()), { 'chain': false });\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * The semantic version number.\n     *\n     * @static\n     * @memberOf _\n     * @type {string}\n     */\n    lodash.VERSION = VERSION;\n\n    // Assign default placeholders.\n    arrayEach(['bind', 'bindKey', 'curry', 'curryRight', 'partial', 'partialRight'], function(methodName) {\n      lodash[methodName].placeholder = lodash;\n    });\n\n    // Add `LazyWrapper` methods for `_.drop` and `_.take` variants.\n    arrayEach(['drop', 'take'], function(methodName, index) {\n      LazyWrapper.prototype[methodName] = function(n) {\n        n = n === undefined ? 1 : nativeMax(toInteger(n), 0);\n\n        var result = (this.__filtered__ && !index)\n          ? new LazyWrapper(this)\n          : this.clone();\n\n        if (result.__filtered__) {\n          result.__takeCount__ = nativeMin(n, result.__takeCount__);\n        } else {\n          result.__views__.push({\n            'size': nativeMin(n, MAX_ARRAY_LENGTH),\n            'type': methodName + (result.__dir__ < 0 ? 'Right' : '')\n          });\n        }\n        return result;\n      };\n\n      LazyWrapper.prototype[methodName + 'Right'] = function(n) {\n        return this.reverse()[methodName](n).reverse();\n      };\n    });\n\n    // Add `LazyWrapper` methods that accept an `iteratee` value.\n    arrayEach(['filter', 'map', 'takeWhile'], function(methodName, index) {\n      var type = index + 1,\n          isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;\n\n      LazyWrapper.prototype[methodName] = function(iteratee) {\n        var result = this.clone();\n        result.__iteratees__.push({\n          'iteratee': getIteratee(iteratee, 3),\n          'type': type\n        });\n        result.__filtered__ = result.__filtered__ || isFilter;\n        return result;\n      };\n    });\n\n    // Add `LazyWrapper` methods for `_.head` and `_.last`.\n    arrayEach(['head', 'last'], function(methodName, index) {\n      var takeName = 'take' + (index ? 'Right' : '');\n\n      LazyWrapper.prototype[methodName] = function() {\n        return this[takeName](1).value()[0];\n      };\n    });\n\n    // Add `LazyWrapper` methods for `_.initial` and `_.tail`.\n    arrayEach(['initial', 'tail'], function(methodName, index) {\n      var dropName = 'drop' + (index ? '' : 'Right');\n\n      LazyWrapper.prototype[methodName] = function() {\n        return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);\n      };\n    });\n\n    LazyWrapper.prototype.compact = function() {\n      return this.filter(identity);\n    };\n\n    LazyWrapper.prototype.find = function(predicate) {\n      return this.filter(predicate).head();\n    };\n\n    LazyWrapper.prototype.findLast = function(predicate) {\n      return this.reverse().find(predicate);\n    };\n\n    LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {\n      if (typeof path == 'function') {\n        return new LazyWrapper(this);\n      }\n      return this.map(function(value) {\n        return baseInvoke(value, path, args);\n      });\n    });\n\n    LazyWrapper.prototype.reject = function(predicate) {\n      return this.filter(negate(getIteratee(predicate)));\n    };\n\n    LazyWrapper.prototype.slice = function(start, end) {\n      start = toInteger(start);\n\n      var result = this;\n      if (result.__filtered__ && (start > 0 || end < 0)) {\n        return new LazyWrapper(result);\n      }\n      if (start < 0) {\n        result = result.takeRight(-start);\n      } else if (start) {\n        result = result.drop(start);\n      }\n      if (end !== undefined) {\n        end = toInteger(end);\n        result = end < 0 ? result.dropRight(-end) : result.take(end - start);\n      }\n      return result;\n    };\n\n    LazyWrapper.prototype.takeRightWhile = function(predicate) {\n      return this.reverse().takeWhile(predicate).reverse();\n    };\n\n    LazyWrapper.prototype.toArray = function() {\n      return this.take(MAX_ARRAY_LENGTH);\n    };\n\n    // Add `LazyWrapper` methods to `lodash.prototype`.\n    baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n      var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName),\n          isTaker = /^(?:head|last)$/.test(methodName),\n          lodashFunc = lodash[isTaker ? ('take' + (methodName == 'last' ? 'Right' : '')) : methodName],\n          retUnwrapped = isTaker || /^find/.test(methodName);\n\n      if (!lodashFunc) {\n        return;\n      }\n      lodash.prototype[methodName] = function() {\n        var value = this.__wrapped__,\n            args = isTaker ? [1] : arguments,\n            isLazy = value instanceof LazyWrapper,\n            iteratee = args[0],\n            useLazy = isLazy || isArray(value);\n\n        var interceptor = function(value) {\n          var result = lodashFunc.apply(lodash, arrayPush([value], args));\n          return (isTaker && chainAll) ? result[0] : result;\n        };\n\n        if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) {\n          // Avoid lazy use if the iteratee has a \"length\" value other than `1`.\n          isLazy = useLazy = false;\n        }\n        var chainAll = this.__chain__,\n            isHybrid = !!this.__actions__.length,\n            isUnwrapped = retUnwrapped && !chainAll,\n            onlyLazy = isLazy && !isHybrid;\n\n        if (!retUnwrapped && useLazy) {\n          value = onlyLazy ? value : new LazyWrapper(this);\n          var result = func.apply(value, args);\n          result.__actions__.push({ 'func': thru, 'args': [interceptor], 'thisArg': undefined });\n          return new LodashWrapper(result, chainAll);\n        }\n        if (isUnwrapped && onlyLazy) {\n          return func.apply(this, args);\n        }\n        result = this.thru(interceptor);\n        return isUnwrapped ? (isTaker ? result.value()[0] : result.value()) : result;\n      };\n    });\n\n    // Add `Array` methods to `lodash.prototype`.\n    arrayEach(['pop', 'push', 'shift', 'sort', 'splice', 'unshift'], function(methodName) {\n      var func = arrayProto[methodName],\n          chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru',\n          retUnwrapped = /^(?:pop|shift)$/.test(methodName);\n\n      lodash.prototype[methodName] = function() {\n        var args = arguments;\n        if (retUnwrapped && !this.__chain__) {\n          var value = this.value();\n          return func.apply(isArray(value) ? value : [], args);\n        }\n        return this[chainName](function(value) {\n          return func.apply(isArray(value) ? value : [], args);\n        });\n      };\n    });\n\n    // Map minified method names to their real names.\n    baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n      var lodashFunc = lodash[methodName];\n      if (lodashFunc) {\n        var key = lodashFunc.name + '';\n        if (!hasOwnProperty.call(realNames, key)) {\n          realNames[key] = [];\n        }\n        realNames[key].push({ 'name': methodName, 'func': lodashFunc });\n      }\n    });\n\n    realNames[createHybrid(undefined, WRAP_BIND_KEY_FLAG).name] = [{\n      'name': 'wrapper',\n      'func': undefined\n    }];\n\n    // Add methods to `LazyWrapper`.\n    LazyWrapper.prototype.clone = lazyClone;\n    LazyWrapper.prototype.reverse = lazyReverse;\n    LazyWrapper.prototype.value = lazyValue;\n\n    // Add chain sequence methods to the `lodash` wrapper.\n    lodash.prototype.at = wrapperAt;\n    lodash.prototype.chain = wrapperChain;\n    lodash.prototype.commit = wrapperCommit;\n    lodash.prototype.next = wrapperNext;\n    lodash.prototype.plant = wrapperPlant;\n    lodash.prototype.reverse = wrapperReverse;\n    lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;\n\n    // Add lazy aliases.\n    lodash.prototype.first = lodash.prototype.head;\n\n    if (symIterator) {\n      lodash.prototype[symIterator] = wrapperToIterator;\n    }\n    return lodash;\n  });\n\n  /*--------------------------------------------------------------------------*/\n\n  // Export lodash.\n  var _ = runInContext();\n\n  // Some AMD build optimizers, like r.js, check for condition patterns like:\n  if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {\n    // Expose Lodash on the global object to prevent errors when Lodash is\n    // loaded by a script tag in the presence of an AMD loader.\n    // See http://requirejs.org/docs/errors.html#mismatch for more details.\n    // Use `_.noConflict` to remove Lodash from the global object.\n    root._ = _;\n\n    // Define as an anonymous module so, through path mapping, it can be\n    // referenced as the \"underscore\" module.\n    define(function() {\n      return _;\n    });\n  }\n  // Check for `exports` after `define` in case a build optimizer adds it.\n  else if (freeModule) {\n    // Export for Node.js.\n    (freeModule.exports = _)._ = _;\n    // Export for CommonJS support.\n    freeExports._ = _;\n  }\n  else {\n    // Export to the global object.\n    root._ = _;\n  }\n}.call(this));\n","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--9-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--9-oneOf-1-1!../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--9-oneOf-1-2!../../node_modules/sass-loader/dist/cjs.js??ref--9-oneOf-1-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./SubscriptionQualityDataRow.vue?vue&type=style&index=0&lang=scss&\"","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:\"c-text c-text--padding c-text--width-small mb-3\",class:'u-background-color-' + _vm.backgroundColor},[_c('p',{staticClass:\"t-body-regular-small\"},[_vm._v(\" \"+_vm._s(_vm.mainText)+\" \")]),_c('p',{staticClass:\"t-body-regular-small\"},[_vm._v(\" \"+_vm._s(_vm.secondaryText)+\" \")])])}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","\n\n\n\n\n\n\n\n\n\n\n\n\n\n\r\nimport { Component, Vue, Prop } from 'vue-property-decorator';\r\n\r\n@Component({})\r\nexport default class TextBox extends Vue {\r\n  @Prop({ required: true })\r\n  private mainText!: string;\r\n  @Prop({ required: true })\r\n  private secondaryText!: string;\r\n  @Prop({ required: true })\r\n  private backgroundColor!: string;\r\n}\r\n","import mod from \"-!../../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../../node_modules/thread-loader/dist/cjs.js!../../../node_modules/babel-loader/lib/index.js!../../../node_modules/ts-loader/index.js??ref--15-3!../../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./TextBox.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../../node_modules/thread-loader/dist/cjs.js!../../../node_modules/babel-loader/lib/index.js!../../../node_modules/ts-loader/index.js??ref--15-3!../../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./TextBox.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./TextBox.vue?vue&type=template&id=5b25b16c&\"\nimport script from \"./TextBox.vue?vue&type=script&lang=ts&\"\nexport * from \"./TextBox.vue?vue&type=script&lang=ts&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('DefaultLayout',[_c('Breadcrumbs',{attrs:{\"items\":_vm.breadcrumbs}}),_c('Messages'),_c('div',{staticClass:\"container-fluid mt-3\"},[_c('div',{staticClass:\"d-flex flex-row justify-content-between flex-wrap align-items-center\"},[_c('h1',{staticClass:\"t-heading-3 pr-2\"},[_vm._v(_vm._s(_vm.$t('qDataDeliveryPage.title')))]),_c('div',{staticClass:\"d-align-self-end\"},[_c('QDataSearchBox',{attrs:{\"value\":_vm.searchTerm}})],1)]),_c('span',{staticClass:\"o-line\"}),(_vm.selectedUnit)?_c('div',{staticClass:\"mb-4\"},[_c('h2',{staticClass:\"t-heading-4\"},[_vm._v(\" \"+_vm._s(_vm.$t('qDataDeliveryPage.unitTitle', [_vm.selectedUnit.id]))+\" \")]),_c('QDataUnitList',{attrs:{\"parameters\":_vm.deliveryMessageParameters,\"pulpType\":_vm.deliveryMessageQualityData.pulpType,\"units\":[_vm.selectedUnit]}})],1):_vm._e(),(_vm.deliveryMessage)?[_c('div',{staticClass:\"d-flex flex-column flex-md-row justify-content-between flex-wrap align-items-md-center\"},[(!_vm.selectedUnit)?_c('h2',{staticClass:\"content-title t-heading-4\"},[_vm._v(\" \"+_vm._s(_vm.$t('qDataDeliveryPage.metadata.title.default'))+\" \"),_c('span',{staticClass:\"u-background-color-yellow px-1\"},[_vm._v(_vm._s(_vm.deliveryMessageNumber))])]):_c('h3',{staticClass:\"content-title t-heading-5\"},[_vm._v(\" \"+_vm._s(_vm.$t('qDataDeliveryPage.metadata.title.withSelectedUnit'))+\" \"),_c('span',{staticClass:\"u-background-color-yellow px-1\"},[_vm._v(_vm._s(_vm.deliveryMessageNumber))])]),_c('QDataDeliveryNavigation',{staticClass:\"mb-2 mb-md-0\",attrs:{\"deliveryMessageNumber\":_vm.deliveryMessageNumber,\"queryData\":_vm.queryData}})],1),_c('div',{staticClass:\"row mt-4 mb-5\"},[_c('div',{staticClass:\"col-12 col-xl-3\"},[_c('QDataDeliveryMetadata',{attrs:{\"deliveryMessage\":_vm.deliveryMessage}}),_c('button',{staticClass:\"o-button o-button--small o-button--black mt-3 mr-1\",attrs:{\"type\":\"button\",\"disabled\":_vm.downloadingDataSheet},on:{\"click\":_vm.downloadDataSheet}},[_c('i',{staticClass:\"o-search-input__button-icon mdi mdi-file-download-outline mr-1\"}),_vm._v(\" \"+_vm._s(_vm.$t('qDataDeliveryPage.metadata.downloadData'))+\" \")]),(\n              _vm.eudrDownloadsEnabled &&\n              _vm.isDeliveryDateAfterEudrDate(_vm.deliveryMessage.deliveryDate)\n            )?[_c('button',{staticClass:\"o-button o-button--small o-button--black mt-3\",attrs:{\"type\":\"button\",\"disabled\":_vm.downloadingEudrDataCsv},on:{\"click\":_vm.downloadEudrDataCsv}},[_c('i',{staticClass:\"o-search-input__button-icon mdi mdi-file-download-outline mr-1\"}),_vm._v(\" \"+_vm._s(_vm.$t('qDataDeliveryPage.metadata.downloadEudrData'))+\" \")])]:_vm._e()],2),_c('div',{staticClass:\"col-12 col-xl-9 pt-4 pt-xl-0\"},[(_vm.isPulpTypeTextile)?_c('QDataTextileParameters',{attrs:{\"deliveryMessage\":_vm.deliveryMessageQualityData}}):(_vm.isPulpTypePaper)?_c('QDataPaperParameters',{attrs:{\"deliveryMessage\":_vm.deliveryMessageQualityData},on:{\"revolutionsChange\":_vm.onPaperPredictedRevolutionsChange}}):_vm._e()],1),_c('div',{staticClass:\"c-text c-text--padding c-text--width-small t-body-regular-small\"},[(_vm.isPulpTypePaper)?_c('span',[_vm._v(\" \"+_vm._s(_vm.$t('qDataDeliveryPage.fiberUpdate'))+\" \")]):_vm._e()])]),(_vm.hasUnitsFromBeforeAndAfterBreakpoint)?_c('TextBox',{attrs:{\"mainText\":_vm.$t('qDataDeliveryPage.fibreSwitchDisclaimer'),\"secondaryText\":_vm.$t('qDataDeliveryPage.fibreSwitchDisclaimerSecondPart'),\"backgroundColor\":'yellow-50'}}):_vm._e(),(_vm.deliveryMessageUnits.length)?[_c('h3',{staticClass:\"t-heading-5 mt-4\"},[_vm._v(\" \"+_vm._s(_vm.$t('qDataDeliveryPage.units.title', [_vm.deliveryMessageUnits.length]))+\" \")]),_c('QDataUnitList',{attrs:{\"parameters\":_vm.deliveryMessageParameters,\"pulpType\":_vm.deliveryMessageQualityData.pulpType,\"units\":_vm.deliveryMessageUnits,\"averageValues\":_vm.deliveryMessageAverageValues}})]:(!_vm.isLoading && !_vm.errorLoadingQData)?_c('div',{staticClass:\"mt-4\"},[_vm._v(\" \"+_vm._s(_vm.$t('qDataDeliveryPage.units.none'))+\" \")]):_vm._e(),(_vm.errorLoadingQData)?_c('div',{staticClass:\"c-alert c-alert--red\",attrs:{\"data-element-id\":\"qDataDeliveryPageErrorAlert\"}},[_c('span',{staticClass:\"c-alert__text\"},[_vm._v(_vm._s(_vm.$t('qDataDeliveryPage.errorLoadingQData')))]),_c('span',{staticClass:\"js-toggle-hidden c-alert__close\",attrs:{\"data-element-id\":\"qDataDeliveryPageErrorAlert\"}})]):_vm._e()]:_vm._e()],2)],1)}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:\"row\"},[_c('div',{staticClass:\"col-12 col-md-6 offset-xl-1\"},_vm._l((_vm.detailedParameters),function(detailedParameter,index){return _c('QDataDetailedParameterRow',{key:index,staticClass:\"mr-md-2 ml-xl-2\",attrs:{\"parameter\":detailedParameter}})}),1),_c('div',{staticClass:\"col-12 col-md-5 col-xl-4 offset-md-1\"},[_c('div',{staticClass:\"mt-5 mt-md-0 grey-box-shadow\"},[_c('QDataParameterList',{attrs:{\"parameters\":_vm.minorParameters}})],1)])])}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:\"c-detailed-parameter-row d-flex u-border-bottom--sm\"},[_c('div',{staticClass:\"d-flex align-items-center\"},[(_vm.icon)?_c('img',{staticClass:\"qdicon\",attrs:{\"src\":'/img/qdata/parameterIcons/' + _vm.icon,\"alt\":\"\"}}):_vm._e()]),_c('div',{staticClass:\"d-flex flex-column justify-content-center ml-2\"},[_c('h4',{staticClass:\"t-heading-6 mb-0 mt-0\"},[_vm._v(\" \"+_vm._s(_vm.parameter.displayName)+\" \")]),(_vm.parameter.measuringStandard)?_c('div',{staticClass:\"t-body-regular-small\"},[_vm._v(\" \"+_vm._s(_vm.parameter.measuringStandard)+\" \")]):_vm._e()]),_c('div',{staticClass:\"d-flex flex-fill flex-column justify-content-center align-items-end\"},[(_vm.parameter.value !== undefined)?_c('strong',[_vm._v(_vm._s(_vm._f(\"number\")(_vm.parameter.value,_vm.parameter.numberOfDecimals))+\" \"+_vm._s(_vm.parameter.unit))]):_c('span',[_vm._v(\"-\")])])])}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\r\nimport { Component, Vue, Prop } from 'vue-property-decorator';\r\nimport { ParameterPsolId } from '@/models/PsolParameterId';\r\nimport { ParameterDisplayData } from '@/models/ParameterDisplayData';\r\n\r\n@Component\r\nexport default class QDataDetailedParameterRow extends Vue {\r\n  @Prop({ required: true })\r\n  private parameter!: ParameterDisplayData;\r\n\r\n  private get icon(): string | null {\r\n    switch (this.parameter.psolParameterId) {\r\n      case ParameterPsolId.AlkaliResistanceR18:\r\n        return 'alkali-resistance-r18.svg';\r\n      case ParameterPsolId.AshContent:\r\n        return 'ash-content.svg';\r\n      case ParameterPsolId.BrightnessOnline:\r\n        return 'brightness-online.svg';\r\n      case ParameterPsolId.Coarseness:\r\n        return 'coarseness.svg';\r\n      case ParameterPsolId.DirtContentOnline:\r\n        return 'dirt-content-online.svg';\r\n      case ParameterPsolId.ExtractiveContent:\r\n        return 'extractive-content.svg';\r\n      case ParameterPsolId.FibreLength:\r\n        return 'fibre-length.svg';\r\n      case ParameterPsolId.FibreWidth:\r\n        return 'fibre-width.svg';\r\n      case ParameterPsolId.Ph:\r\n        return 'ph.svg';\r\n      case ParameterPsolId.Viscosity:\r\n        return 'viscosity.svg';\r\n      case ParameterPsolId.Xylan:\r\n        return 'xylan.svg';\r\n      default:\r\n        return null;\r\n    }\r\n  }\r\n}\r\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataDetailedParameterRow.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataDetailedParameterRow.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./QDataDetailedParameterRow.vue?vue&type=template&id=7a9b8157&scoped=true&\"\nimport script from \"./QDataDetailedParameterRow.vue?vue&type=script&lang=ts&\"\nexport * from \"./QDataDetailedParameterRow.vue?vue&type=script&lang=ts&\"\nimport style0 from \"./QDataDetailedParameterRow.vue?vue&type=style&index=0&id=7a9b8157&scoped=true&lang=scss&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  \"7a9b8157\",\n  null\n  \n)\n\nexport default component.exports","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:\"px-3 py-2\"},[_c('table',_vm._l((_vm.parameters),function(parameter,index){return _c('tr',{key:index},[_c('td',[_c('span',{staticClass:\"t-body-regular-small-bold\"},[_vm._v(_vm._s(parameter.displayName))])]),_c('td',{staticClass:\"value-column pl-3 pl-md-1\"},[(parameter.value !== undefined)?_c('span',{staticClass:\"t-body-regular-small-bold\"},[_c('strong',[_vm._v(_vm._s(_vm._f(\"number\")(parameter.value,parameter.numberOfDecimals)))]),_vm._v(\" \"+_vm._s(parameter.unit)+\" \")]):_c('span',[_vm._v(\"-\")])])])}),0)])}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\r\nimport { Component, Vue, Prop } from 'vue-property-decorator';\r\nimport { ParameterDisplayData } from '@/models/ParameterDisplayData';\r\n\r\n@Component\r\nexport default class QDataParameterList extends Vue {\r\n  @Prop({ required: true })\r\n  private parameters!: ParameterDisplayData[];\r\n}\r\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataParameterList.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataParameterList.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./QDataParameterList.vue?vue&type=template&id=4362eccc&scoped=true&\"\nimport script from \"./QDataParameterList.vue?vue&type=script&lang=ts&\"\nexport * from \"./QDataParameterList.vue?vue&type=script&lang=ts&\"\nimport style0 from \"./QDataParameterList.vue?vue&type=style&index=0&id=4362eccc&scoped=true&lang=scss&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  \"4362eccc\",\n  null\n  \n)\n\nexport default component.exports","import { ParameterPsolId } from '@/models/PsolParameterId';\r\nimport { GeneralParameter } from './QualityData/GeneralParameter';\r\nimport { MeasuringStandard } from './QualityData/MeasuringStandard';\r\n\r\nexport class ParameterDisplayData {\r\n  private readonly parameter?: GeneralParameter;\r\n  private readonly parameterValue?: number;\r\n  private readonly parameterMeasuringStandard?: MeasuringStandard;\r\n\r\n  constructor(\r\n    parameter?: GeneralParameter,\r\n    parameterValue?: number,\r\n    parameterMeasuringStandard?: MeasuringStandard\r\n  ) {\r\n    this.parameter = parameter;\r\n    this.parameterValue = parameterValue;\r\n    this.parameterMeasuringStandard = parameterMeasuringStandard;\r\n  }\r\n\r\n  public get hasParameter(): boolean {\r\n    return this.parameter !== undefined;\r\n  }\r\n\r\n  public get psolParameterId(): ParameterPsolId | undefined {\r\n    return this.parameter?.psolParameterId;\r\n  }\r\n\r\n  public get unit(): string | undefined {\r\n    return this.parameter?.unitOfMeasurement;\r\n  }\r\n\r\n  public get numberOfDecimals(): number | undefined {\r\n    return this.parameter?.numberOfDecimals;\r\n  }\r\n\r\n  public get value(): number | undefined {\r\n    return this.parameterValue;\r\n  }\r\n\r\n  public get displayName(): string | undefined {\r\n    return this.parameter?.displayName;\r\n  }\r\n\r\n  public get measuringStandard(): string | undefined {\r\n    return this.parameterMeasuringStandard?.standard;\r\n  }\r\n}\r\n","\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\r\nimport { Component, Vue, Prop } from 'vue-property-decorator';\r\nimport { GeneralQualityDataForDeliveryMessage } from '@/models/QualityData/GeneralQualityDataForDeliveryMessage';\r\nimport QDataDetailedParameterRow from '@/components/QDataDetailedParameterRow.vue';\r\nimport QDataParameterList from '@/components/QDataParameterList.vue';\r\nimport { ParameterPsolId } from '@/models/PsolParameterId';\r\nimport { ParameterDisplayData } from '@/models/ParameterDisplayData';\r\n\r\n@Component({\r\n  components: {\r\n    QDataDetailedParameterRow,\r\n    QDataParameterList,\r\n  },\r\n})\r\nexport default class QDataTextileParameters extends Vue {\r\n  @Prop({ required: true })\r\n  public deliveryMessage!: GeneralQualityDataForDeliveryMessage;\r\n\r\n  private readonly detailedParameterIds: ParameterPsolId[] = [\r\n    ParameterPsolId.AlkaliResistanceR18,\r\n    ParameterPsolId.AshContent,\r\n    ParameterPsolId.BrightnessOnline,\r\n    ParameterPsolId.ExtractiveContent,\r\n    ParameterPsolId.Viscosity,\r\n    ParameterPsolId.Xylan,\r\n  ];\r\n\r\n  private readonly minorParameterIds: ParameterPsolId[] = [\r\n    ParameterPsolId.AlphaCellulose,\r\n    ParameterPsolId.CalciumContent,\r\n    ParameterPsolId.CopperContent,\r\n    ParameterPsolId.IronContent,\r\n    ParameterPsolId.ManganeseContent,\r\n    ParameterPsolId.MoistureContent,\r\n    ParameterPsolId.SiliconContent,\r\n  ];\r\n\r\n  private get detailedParameters(): ParameterDisplayData[] {\r\n    return this.detailedParameterIds\r\n      .map((parameterId) => this.getParameter(parameterId))\r\n      .filter((p) => p.hasParameter);\r\n  }\r\n\r\n  private get minorParameters(): ParameterDisplayData[] {\r\n    return this.minorParameterIds\r\n      .map((parameterId) => this.getParameter(parameterId))\r\n      .filter((p) => p.hasParameter);\r\n  }\r\n\r\n  private getParameter(psolParameterId: ParameterPsolId): ParameterDisplayData {\r\n    const parameter = this.deliveryMessage.parameters.find(\r\n      (x) => x.psolParameterId === psolParameterId\r\n    );\r\n\r\n    const averageValue = this.deliveryMessage.averageValues.find(\r\n      (x) => x.parameterId === parameter?.id\r\n    );\r\n\r\n    const measuringStandard = this.deliveryMessage.measuringStandards.find(\r\n      (p) => p.parameterId === parameter?.id\r\n    );\r\n\r\n    return new ParameterDisplayData(\r\n      parameter,\r\n      averageValue?.parameterValueAvg,\r\n      measuringStandard\r\n    );\r\n  }\r\n}\r\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataTextileParameters.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataTextileParameters.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./QDataTextileParameters.vue?vue&type=template&id=411cf0cf&\"\nimport script from \"./QDataTextileParameters.vue?vue&type=script&lang=ts&\"\nexport * from \"./QDataTextileParameters.vue?vue&type=script&lang=ts&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:\"row\"},[_c('div',{staticClass:\"col-12 col-md-6\"},_vm._l((_vm.detailedParameters),function(detailedParameter,index){return _c('QDataDetailedParameterRow',{key:index,staticClass:\"mr-md-2 ml-xl-2\",attrs:{\"parameter\":detailedParameter}})}),1),(_vm.isPredictedParametersEnabled)?_c('div',{staticClass:\"col-12 col-md-6\"},[_c('h3',{staticClass:\"t-heading-6 mt-5 mt-md-0\"},[_vm._v(\" \"+_vm._s(_vm.$t('qDataPaperParameters.predictedParameters.title'))+\" \")]),(_vm.loadingPredictedParameters)?_c('div',{staticClass:\"u-position-relative\"},[_c('div',{staticClass:\"o-loader o-loader--absolute mt-6\"})]):_vm._e(),(\n        _vm.revolutionsSelectOptions.length &&\n        (_vm.loadingPredictedParameters ||\n          _vm.errorPredictedParameters ||\n          _vm.predictedParameters)\n      )?_c('SelectBox',{staticClass:\"d-inline-block mb-1 mb-md-2\",attrs:{\"value\":_vm.currentRevolutions,\"options\":_vm.revolutionsSelectOptions,\"disabled\":_vm.loadingPredictedParameters},on:{\"input\":_vm.onRevolutionsChange}}):_vm._e(),(\n        !_vm.loadingPredictedParameters &&\n        !_vm.errorPredictedParameters &&\n        _vm.predictedParameters\n      )?_c('div',{staticClass:\"u-full-width\"},[(_vm.predictedParameters.qualityData.length)?_c('QDataPredictedParametersList',{attrs:{\"predictedParameters\":_vm.predictedParameters}}):(!_vm.loadingPredictedParameters)?_c('span',{staticClass:\"t-body-regular-small-bold\"},[_vm._v(\" \"+_vm._s(_vm.$t('qDataPaperParameters.predictedParameters.noData'))+\" \")]):_vm._e()],1):_vm._e(),(_vm.errorPredictedParameters)?_c('div',{staticClass:\"c-alert c-alert--red mt-2\",attrs:{\"data-element-id\":\"qDataPaperParametersPredictedErrorAlert\"}},[_c('span',{staticClass:\"c-alert__text\"},[_vm._v(_vm._s(_vm.$t('qDataPaperParameters.predictedParameters.error')))]),_c('span',{staticClass:\"js-toggle-hidden c-alert__close\",attrs:{\"data-element-id\":\"qDataPaperParametersPredictedErrorAlert\"}})]):_vm._e()],1):_vm._e()])}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return (_vm.predictedParameters.qualityData.length)?_c('div',{staticClass:\"c-table c-table--no-divider c-table--dense c-table--striped\"},[_c('div',{staticClass:\"c-table__scroll-container\"},[_c('table',{staticClass:\"t-body-regular-small-bold\"},[_c('thead',[_c('tr',[_c('th'),_c('th',{staticClass:\"nowrap u-text-right\"},[_vm._v(\" \"+_vm._s(_vm.$t('qDataPredictedParametersList.yourDelivery'))+\" \")]),_c('th',{staticClass:\"nowrap u-text-right\"},[_vm._v(\" \"+_vm._s(_vm.$t('qDataPredictedParametersList.typicalValue'))+\" \"),_c('span',[_vm._v(\"*\")])])])]),_c('tbody',_vm._l((_vm.predictedParameters.qualityData),function(qualityData,index){return _c('tr',{key:index},[_c('td',[_vm._v(\" \"+_vm._s(_vm.getPredictedParameterText(qualityData.parameterId))+\" \")]),_c('td',{staticClass:\"u-text-right\"},[(qualityData.parameterValueActual)?[_c('strong',[_vm._v(_vm._s(_vm._f(\"number\")(qualityData.parameterValueActual)))])]:_vm._e()],2),_c('td',{staticClass:\"u-text-right\"},[(qualityData.parameterValueTypical)?[_vm._v(_vm._s(_vm._f(\"number\")(qualityData.parameterValueTypical)))]:_vm._e()],2)])}),0)])])]):_vm._e()}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\r\nimport { Component, Vue, Prop } from 'vue-property-decorator';\r\nimport { PredictedQualityDataByDeliveryMessage } from '@/models/QualityData/PredictedQualityDataByDeliveryMessage';\r\n\r\n@Component\r\nexport default class QDataPredictedParametersList extends Vue {\r\n  @Prop({ required: true })\r\n  public predictedParameters!: PredictedQualityDataByDeliveryMessage | null;\r\n\r\n  private getPredictedParameterText(parameterId: number): string {\r\n    if (this.predictedParameters === null) {\r\n      return '';\r\n    }\r\n    const parameter = this.predictedParameters.parameters.find(\r\n      (x) => x.id === parameterId\r\n    );\r\n    if (parameter === undefined) {\r\n      return '';\r\n    }\r\n    let text = parameter.displayName;\r\n    if (parameter.unitOfMeasurement) {\r\n      text += `, ${parameter.unitOfMeasurement}`;\r\n    }\r\n    return text;\r\n  }\r\n}\r\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataPredictedParametersList.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataPredictedParametersList.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./QDataPredictedParametersList.vue?vue&type=template&id=57af7754&scoped=true&\"\nimport script from \"./QDataPredictedParametersList.vue?vue&type=script&lang=ts&\"\nexport * from \"./QDataPredictedParametersList.vue?vue&type=script&lang=ts&\"\nimport style0 from \"./QDataPredictedParametersList.vue?vue&type=style&index=0&id=57af7754&scoped=true&lang=scss&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  \"57af7754\",\n  null\n  \n)\n\nexport default component.exports","import { Consoler } from '@/utils/Consoler';\r\nimport { store } from '@/store';\r\nimport {\r\n  Module,\r\n  VuexModule,\r\n  Mutation,\r\n  Action,\r\n  getModule,\r\n} from 'vuex-module-decorators';\r\nimport qualityDataService from '@/services/QualityDataService';\r\nimport { PredictedQualityDataByDeliveryMessage } from '@/models/QualityData/PredictedQualityDataByDeliveryMessage';\r\nimport { CommonArrayStore } from '../commonArrayStore';\r\n\r\n@Module({\r\n  namespaced: true,\r\n  name: 'deliveryMessagePredictedParameters',\r\n  dynamic: true,\r\n  store,\r\n})\r\nclass DeliveryMessagePredictedParametersModule extends VuexModule {\r\n  private common = new CommonArrayStore<\r\n    PredictedQualityDataByDeliveryMessage,\r\n    string\r\n  >(60); // reLoadMinMinutesInterval\r\n\r\n  // ---------------\r\n  // ### Getters ###\r\n  // ---------------\r\n\r\n  public get item() {\r\n    return (id: string) => this.common.getDataFor(id);\r\n  }\r\n\r\n  // -----------------\r\n  // ### Mutations ###\r\n  // -----------------\r\n\r\n  @Mutation private commitSetLoading(payload: {\r\n    id: string;\r\n    loadingPromise: Promise<PredictedQualityDataByDeliveryMessage>;\r\n    clearData?: boolean;\r\n  }) {\r\n    this.common.setLoading(payload);\r\n  }\r\n  @Mutation private commitSetLoadingComplete(payload: {\r\n    id: string;\r\n    data: PredictedQualityDataByDeliveryMessage;\r\n  }) {\r\n    this.common.setLoadingComplete(payload);\r\n  }\r\n  @Mutation private commitSetLoadingError(payload: {\r\n    id: string;\r\n    error?: any;\r\n    clearData?: boolean;\r\n  }) {\r\n    this.common.setLoadingError(payload);\r\n  }\r\n\r\n  // ---------------\r\n  // ### Actions ###\r\n  // ---------------\r\n\r\n  @Action\r\n  public async dispatchLoad(payload: {\r\n    deliveryMessageNumber: string;\r\n    revolutions?: number;\r\n  }): Promise<PredictedQualityDataByDeliveryMessage> {\r\n    // If recently loaded, return\r\n    if (\r\n      this.common.hasFreshDataFor(payload.deliveryMessageNumber) &&\r\n      this.item(payload.deliveryMessageNumber)!.revolutions ===\r\n        payload.revolutions\r\n    ) {\r\n      return Promise.resolve(this.item(payload.deliveryMessageNumber)!);\r\n    }\r\n\r\n    const currentlyLoadingPromise = this.common.isCurrentlyLoading(\r\n      payload.deliveryMessageNumber\r\n    );\r\n    if (currentlyLoadingPromise) {\r\n      Consoler.debugLog(\r\n        'Already loading, waiting for existing load to finish',\r\n        'deliveryMessagePredictedParameters'\r\n      );\r\n      return currentlyLoadingPromise;\r\n    }\r\n\r\n    const loadingPromise = qualityDataService\r\n      .getPredictedParameters(\r\n        payload.deliveryMessageNumber,\r\n        payload.revolutions\r\n      )\r\n      .then((response) => {\r\n        this.commitSetLoadingComplete({\r\n          id: payload.deliveryMessageNumber,\r\n          data: response,\r\n        });\r\n        Consoler.debugLog(\r\n          'Load deliveryMessagePredictedParameters success',\r\n          response\r\n        );\r\n        return Promise.resolve(response);\r\n      })\r\n      .catch((error) => {\r\n        Consoler.debugWarn(\r\n          'Load deliveryMessagePredictedParameters failed',\r\n          error\r\n        );\r\n        this.commitSetLoadingError({\r\n          id: payload.deliveryMessageNumber,\r\n          error,\r\n        });\r\n        return Promise.reject(error);\r\n      });\r\n\r\n    this.commitSetLoading({\r\n      id: payload.deliveryMessageNumber,\r\n      loadingPromise,\r\n      clearData: true,\r\n    });\r\n\r\n    return loadingPromise;\r\n  }\r\n}\r\n\r\nexport const deliveryMessagePredictedParametersModule = getModule(\r\n  DeliveryMessagePredictedParametersModule\r\n);\r\n","\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\r\nimport { Component, Vue, Prop } from 'vue-property-decorator';\r\nimport { GeneralQualityDataForDeliveryMessage } from '@/models/QualityData/GeneralQualityDataForDeliveryMessage';\r\nimport QDataDetailedParameterRow from '@/components/QDataDetailedParameterRow.vue';\r\nimport QDataParameterList from '@/components/QDataParameterList.vue';\r\nimport QDataPredictedParametersList from '@/components/QDataPredictedParametersList.vue';\r\nimport SelectBox, { SelectOption } from '@/components/general/SelectBox.vue';\r\nimport { ParameterPsolId } from '@/models/PsolParameterId';\r\nimport { deliveryMessagePredictedParametersModule } from '@/store/modules/deliveryMessagePredictedParameters';\r\nimport { PredictedQualityDataByDeliveryMessage } from '@/models/QualityData/PredictedQualityDataByDeliveryMessage';\r\nimport { Permissions } from '@/utils/Permissions';\r\nimport { FeatureFlagNames } from '@/models/FeatureFlagNames';\r\nimport { ParameterDisplayData } from '@/models/ParameterDisplayData';\r\nimport { Consoler } from '@/utils/Consoler';\r\n\r\n@Component({\r\n  components: {\r\n    QDataDetailedParameterRow,\r\n    QDataParameterList,\r\n    QDataPredictedParametersList,\r\n    SelectBox,\r\n  },\r\n})\r\nexport default class QDataPaperParameters extends Vue {\r\n  @Prop({ required: true })\r\n  public deliveryMessage!: GeneralQualityDataForDeliveryMessage;\r\n\r\n  private readonly detailedParameterIds: ParameterPsolId[] = [\r\n    ParameterPsolId.BrightnessOnline,\r\n    ParameterPsolId.DirtContentOnline,\r\n    ParameterPsolId.FibreLength,\r\n    ParameterPsolId.FibreWidth,\r\n    ParameterPsolId.Coarseness,\r\n    ParameterPsolId.Ph,\r\n  ];\r\n\r\n  private loadingPredictedParameters: boolean = false;\r\n  private errorPredictedParameters: boolean = false;\r\n\r\n  private currentRevolutions: number | undefined = undefined;\r\n\r\n  private get isPredictedParametersEnabled(): boolean {\r\n    return Permissions.isFeatureEnabled(FeatureFlagNames.Pfi);\r\n  }\r\n\r\n  private get detailedParameters(): ParameterDisplayData[] {\r\n    return this.detailedParameterIds\r\n      .map((parameterId) => this.getParameter(parameterId))\r\n      .filter((p) => p.hasParameter);\r\n  }\r\n\r\n  private get predictedParameters(): PredictedQualityDataByDeliveryMessage | null {\r\n    const item = deliveryMessagePredictedParametersModule.item(\r\n      this.deliveryMessage.number\r\n    );\r\n\r\n    if (\r\n      item &&\r\n      this.currentRevolutions &&\r\n      item.revolutions !== this.currentRevolutions\r\n    ) {\r\n      Consoler.debugLog(\r\n        'Module data has wrong revolutions, reloading..',\r\n        this.currentRevolutions\r\n      );\r\n      this.loadDeliveryMessagePredictedParameters(this.currentRevolutions);\r\n      return null;\r\n    }\r\n\r\n    return item;\r\n  }\r\n\r\n  private get revolutionsSelectOptions(): SelectOption[] {\r\n    if (this.predictedParameters === null) {\r\n      return [];\r\n    }\r\n    return this.predictedParameters.possibleRevolutions.map((revolutions) => ({\r\n      value: revolutions,\r\n      text: this.$t(\r\n        'qDataPaperParameters.predictedParameters.revolutionsSelectText',\r\n        [revolutions]\r\n      ).toString(),\r\n    }));\r\n  }\r\n\r\n  private created() {\r\n    this.loadDeliveryMessagePredictedParameters();\r\n  }\r\n\r\n  private getParameter(psolParameterId: ParameterPsolId): ParameterDisplayData {\r\n    const parameter = this.deliveryMessage.parameters.find(\r\n      (x) => x.psolParameterId === psolParameterId\r\n    );\r\n\r\n    const averageValue = this.deliveryMessage.averageValues.find(\r\n      (x) => x.parameterId === parameter?.id\r\n    );\r\n\r\n    const measuringStandard = this.deliveryMessage.measuringStandards.find(\r\n      (p) => p.parameterId === parameter?.id\r\n    );\r\n\r\n    return new ParameterDisplayData(\r\n      parameter,\r\n      averageValue?.parameterValueAvg,\r\n      measuringStandard\r\n    );\r\n  }\r\n\r\n  private onRevolutionsChange(val: number) {\r\n    this.loadDeliveryMessagePredictedParameters(val);\r\n  }\r\n\r\n  private async loadDeliveryMessagePredictedParameters(revolutions?: number) {\r\n    if (!this.isPredictedParametersEnabled) {\r\n      return;\r\n    }\r\n\r\n    this.loadingPredictedParameters = true;\r\n    this.errorPredictedParameters = false;\r\n\r\n    this.setRevolutions(revolutions);\r\n\r\n    deliveryMessagePredictedParametersModule\r\n      .dispatchLoad({\r\n        deliveryMessageNumber: this.deliveryMessage.number,\r\n        revolutions,\r\n      })\r\n      .then((response) => {\r\n        if (revolutions === undefined) {\r\n          this.setRevolutions(response.revolutions);\r\n        }\r\n      })\r\n      .catch(() => {\r\n        this.errorPredictedParameters = true;\r\n      })\r\n      .finally(() => {\r\n        this.loadingPredictedParameters = false;\r\n      });\r\n  }\r\n\r\n  private setRevolutions(revolutions: number | undefined) {\r\n    this.currentRevolutions = revolutions;\r\n    this.$emit('revolutionsChange', this.currentRevolutions);\r\n  }\r\n}\r\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataPaperParameters.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataPaperParameters.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./QDataPaperParameters.vue?vue&type=template&id=4c9e3f0d&\"\nimport script from \"./QDataPaperParameters.vue?vue&type=script&lang=ts&\"\nexport * from \"./QDataPaperParameters.vue?vue&type=script&lang=ts&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return (_vm.hasResultsForCurrentQuery)?_c('div',{staticClass:\"d-flex flex-wrap\"},[(_vm.resultsRoute)?_c('div',{staticClass:\"mr-2\"},[_c('router-link',{attrs:{\"to\":_vm.resultsRoute}},[_vm._v(_vm._s(_vm.backToResultsLinkText))]),(_vm.currentDeliveryMessageIndexInTotal >= 0)?[_vm._v(\":\")]:_vm._e()],2):_vm._e(),(_vm.currentDeliveryMessageIndexInTotal >= 0)?_c('div',{staticClass:\"nowrap\"},[_c('span',{staticClass:\"nowrap\"},[_vm._v(_vm._s(_vm.$t('qDataDeliveryNavigation.text', [ _vm.currentDeliveryMessageIndexInTotal, _vm.totalCount ])))]),_c('div',{staticClass:\"d-inline d-print-none\"},[(_vm.previousDeliveryMessageRoute && !_vm.loading)?_c('router-link',{attrs:{\"to\":_vm.previousDeliveryMessageRoute},scopedSlots:_vm._u([{key:\"default\",fn:function(ref){\nvar href = ref.href;\nvar navigate = ref.navigate;\nreturn [_c('a',{staticClass:\"ml-2\",attrs:{\"href\":href},on:{\"click\":navigate}},[_c('i',{staticClass:\"material-icons md-24\"},[_vm._v(\"navigate_before\")])])]}}],null,false,569201389)}):(_vm.doManualPreviousOrNextDeliveryMessage(true) && !_vm.loading)?_c('a',{staticClass:\"ml-2\",attrs:{\"href\":\"\"},on:{\"click\":function($event){$event.preventDefault();return _vm.onManualPreviousOrNextRouteClick(true)}}},[_c('i',{staticClass:\"material-icons md-24\"},[_vm._v(\"navigate_before\")])]):_c('span',{staticClass:\"ml-2\"},[_c('i',{staticClass:\"material-icons md-24 u-color-sodra-black-10\"},[_vm._v(\"navigate_before\")])]),(_vm.nextDeliveryMessageRoute && !_vm.loading)?_c('router-link',{attrs:{\"to\":_vm.nextDeliveryMessageRoute},scopedSlots:_vm._u([{key:\"default\",fn:function(ref){\nvar href = ref.href;\nvar navigate = ref.navigate;\nreturn [_c('a',{staticClass:\"ml-1\",attrs:{\"href\":href},on:{\"click\":navigate}},[_c('i',{staticClass:\"material-icons md-24\"},[_vm._v(\"navigate_next\")])])]}}],null,false,3031624592)}):(_vm.doManualPreviousOrNextDeliveryMessage(false) && !_vm.loading)?_c('a',{staticClass:\"ml-2\",attrs:{\"href\":\"\"},on:{\"click\":function($event){$event.preventDefault();return _vm.onManualPreviousOrNextRouteClick(false)}}},[_c('i',{staticClass:\"material-icons md-24\"},[_vm._v(\"navigate_next\")])]):_c('span',{staticClass:\"ml-2\"},[_c('i',{staticClass:\"material-icons md-24 u-color-sodra-black-10\"},[_vm._v(\"navigate_next\")])])],1)]):_vm._e()]):_vm._e()}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\r\nimport { Component, Vue, Prop } from 'vue-property-decorator';\r\nimport {\r\n  ByDatesSearch,\r\n  ByTermSearch,\r\n  deliveryMessagesModule,\r\n  QueryType,\r\n  Search,\r\n} from '@/store/modules/deliveryMessages';\r\nimport {\r\n  routeNameQData,\r\n  routeNameQDataDelivery,\r\n  routeNameQDataSearch,\r\n} from '@/router/routes';\r\nimport { RawLocation } from 'vue-router';\r\nimport {\r\n  defaultPageSize,\r\n  copyQDataPageQueryFromRoute,\r\n  QDataQueryData,\r\n  getQDataPageQueryText,\r\n} from '@/utils/RoutingForQData';\r\nimport { DeliveryMessage } from '@/models/QualityData/DeliveryMessage';\r\nimport { Consoler } from '@/utils/Consoler';\r\nimport { loadingModule } from '@/store/modules/loading';\r\n\r\n@Component\r\nexport default class QDataDeliveryNavigation extends Vue {\r\n  @Prop({ required: true }) private deliveryMessageNumber!: string;\r\n  @Prop({ required: true }) private queryData!: QDataQueryData | null;\r\n\r\n  private loading: boolean = false;\r\n\r\n  private get by(): QueryType | null {\r\n    return this.queryData?.by ?? null;\r\n  }\r\n\r\n  private get term(): string | null {\r\n    return this.queryData?.term ?? null;\r\n  }\r\n\r\n  private get type(): string | null {\r\n    return this.queryData?.type ?? null;\r\n  }\r\n\r\n  private get from(): Date | null {\r\n    return this.queryData?.from ?? null;\r\n  }\r\n\r\n  private get to(): Date | null {\r\n    return this.queryData?.to ?? null;\r\n  }\r\n\r\n  private get productNames(): string[] {\r\n    return this.queryData?.productNames ?? [];\r\n  }\r\n\r\n  private get pageIndex(): number {\r\n    return this.queryData?.pageIndex ?? 0;\r\n  }\r\n\r\n  private get pageSize(): number {\r\n    return this.queryData?.pageSize ?? defaultPageSize;\r\n  }\r\n\r\n  private get hasResultsForCurrentQuery(): boolean {\r\n    return this.queryMatchesDatesSearch || this.queryMatchesTermSearch;\r\n  }\r\n\r\n  private get deliveryMessages(): DeliveryMessage[] {\r\n    return deliveryMessagesModule.search?.results?.items ?? [];\r\n  }\r\n\r\n  private get previousDeliveryMessageRoute(): RawLocation | null {\r\n    return this.getPreviousOrNextDeliveryMessageRoute(true);\r\n  }\r\n\r\n  private get nextDeliveryMessageRoute(): RawLocation | null {\r\n    return this.getPreviousOrNextDeliveryMessageRoute(false);\r\n  }\r\n\r\n  private get currentDeliveryMessageIndexInResult(): number {\r\n    return (\r\n      this.deliveryMessages.findIndex(\r\n        (dm) => dm.number === this.deliveryMessageNumber\r\n      ) ?? -1\r\n    );\r\n  }\r\n\r\n  private get currentDeliveryMessageIndexInTotal(): number {\r\n    if (!deliveryMessagesModule.search) {\r\n      return -1;\r\n    }\r\n\r\n    return this.currentDeliveryMessageIndexInResult >= 0\r\n      ? deliveryMessagesModule.search.pageIndex *\r\n          deliveryMessagesModule.search.pageSize +\r\n          (this.currentDeliveryMessageIndexInResult + 1)\r\n      : -1;\r\n  }\r\n\r\n  private get totalCount(): number {\r\n    return deliveryMessagesModule.search?.results?.totalCount ?? 0;\r\n  }\r\n\r\n  private get backToResultsLinkText(): string {\r\n    return getQDataPageQueryText(this.$route);\r\n  }\r\n\r\n  private get resultsRoute(): RawLocation | null {\r\n    if (!deliveryMessagesModule.search) {\r\n      return null;\r\n    }\r\n\r\n    if (this.queryMatchesDatesSearch) {\r\n      return {\r\n        name: routeNameQData,\r\n        query: copyQDataPageQueryFromRoute(this.$route),\r\n      };\r\n    } else if (this.queryMatchesTermSearch) {\r\n      return {\r\n        name: routeNameQDataSearch,\r\n        query: copyQDataPageQueryFromRoute(this.$route),\r\n      };\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  private get queryMatchesDatesSearch(): boolean {\r\n    if (\r\n      !deliveryMessagesModule.search ||\r\n      deliveryMessagesModule.search.queryBy !== QueryType.ByDates\r\n    ) {\r\n      return false;\r\n    }\r\n    const search = deliveryMessagesModule.search as ByDatesSearch;\r\n    return search.isSameSearch(this.from, this.to, this.productNames);\r\n  }\r\n\r\n  private get queryMatchesTermSearch(): boolean {\r\n    if (\r\n      !deliveryMessagesModule.search ||\r\n      deliveryMessagesModule.search.queryBy !== QueryType.ByTerm\r\n    ) {\r\n      return false;\r\n    }\r\n    const search = deliveryMessagesModule.search as ByTermSearch;\r\n    return search.isSameSearch(this.term, this.type);\r\n  }\r\n\r\n  private created(): void {\r\n    let search: Search | null = null;\r\n\r\n    if (this.from && this.to) {\r\n      const datesSearch = new ByDatesSearch();\r\n\r\n      datesSearch.from = this.from;\r\n      datesSearch.to = this.to;\r\n      datesSearch.productNames = this.productNames;\r\n\r\n      search = datesSearch;\r\n    } else if (this.term) {\r\n      const termSearch = new ByTermSearch();\r\n\r\n      termSearch.term = this.term;\r\n      termSearch.type = this.type;\r\n\r\n      search = termSearch;\r\n    }\r\n\r\n    if (search) {\r\n      search.pageIndex = this.pageIndex;\r\n      search.pageSize = this.pageSize;\r\n\r\n      deliveryMessagesModule.dispatchLoad(search).finally(() => {\r\n        this.loading = false;\r\n      });\r\n    } else {\r\n      this.loading = false;\r\n    }\r\n  }\r\n\r\n  private getPreviousOrNextDeliveryMessageRoute(\r\n    previousNotNext: boolean\r\n  ): RawLocation | null {\r\n    if (this.deliveryMessages.length < 1 || !this.hasResultsForCurrentQuery) {\r\n      return null;\r\n    }\r\n\r\n    if (\r\n      (previousNotNext && this.currentDeliveryMessageIndexInResult > 0) ||\r\n      (!previousNotNext &&\r\n        this.currentDeliveryMessageIndexInResult >= 0 &&\r\n        this.currentDeliveryMessageIndexInResult <\r\n          this.deliveryMessages.length - 1)\r\n    ) {\r\n      const wantedDeliveryMessage =\r\n        this.deliveryMessages[\r\n          this.currentDeliveryMessageIndexInResult + (previousNotNext ? -1 : 1)\r\n        ];\r\n\r\n      return {\r\n        name: routeNameQDataDelivery,\r\n        query: copyQDataPageQueryFromRoute(this.$route),\r\n        params: { deliveryMessageNumber: wantedDeliveryMessage.number },\r\n      };\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  private doManualPreviousOrNextDeliveryMessage(\r\n    previousNotNext: boolean\r\n  ): boolean {\r\n    if (\r\n      !this.hasResultsForCurrentQuery ||\r\n      deliveryMessagesModule.search === null\r\n    ) {\r\n      return false;\r\n    }\r\n\r\n    if (\r\n      previousNotNext &&\r\n      this.currentDeliveryMessageIndexInResult === 0 &&\r\n      this.pageIndex > 0\r\n    ) {\r\n      return true;\r\n    } else if (\r\n      !previousNotNext &&\r\n      this.currentDeliveryMessageIndexInResult + 1 === this.pageSize &&\r\n      this.pageIndex + 1 <\r\n        (deliveryMessagesModule.search?.results?.pageCount ?? 0)\r\n    ) {\r\n      return true;\r\n    } else {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  private async onManualPreviousOrNextRouteClick(previousNotNext: boolean) {\r\n    this.loading = true;\r\n    const newPageIndex = this.pageIndex + (previousNotNext ? -1 : 1);\r\n\r\n    let search: Search | null = null;\r\n\r\n    if (this.by === QueryType.ByDates) {\r\n      const datesSearch = new ByDatesSearch();\r\n\r\n      datesSearch.from = this.from;\r\n      datesSearch.to = this.to;\r\n      datesSearch.productNames = this.productNames;\r\n\r\n      search = datesSearch;\r\n    } else if (this.by === QueryType.ByTerm) {\r\n      const termSearch = new ByTermSearch();\r\n\r\n      termSearch.term = this.term;\r\n      termSearch.type = this.type;\r\n\r\n      search = termSearch;\r\n    } else {\r\n      this.loading = false;\r\n      return;\r\n    }\r\n\r\n    search.pageIndex = newPageIndex;\r\n    search.pageSize = this.pageSize;\r\n\r\n    const loading = await loadingModule.dispatchAdd(\r\n      this.$t('loading.qDataDeliveryNavigation_ChangePage').toString()\r\n    );\r\n\r\n    Consoler.debugLog(\r\n      'Doing manual loading of another search result (with a new pageIndex) to try get the wanted delivery message',\r\n      search\r\n    );\r\n    deliveryMessagesModule\r\n      .dispatchLoad(search)\r\n      .then(() => {\r\n        if (this.deliveryMessages.length === 0) {\r\n          Consoler.debugWarn(\r\n            'Fetched new search result but no delivery messages in the results to go to...'\r\n          );\r\n          return;\r\n        }\r\n\r\n        this.$router.push({\r\n          name: routeNameQDataDelivery,\r\n          query: copyQDataPageQueryFromRoute(this.$route, newPageIndex),\r\n          params: {\r\n            deliveryMessageNumber:\r\n              this.deliveryMessages[\r\n                previousNotNext ? this.deliveryMessages.length - 1 : 0\r\n              ].number,\r\n          },\r\n        });\r\n      })\r\n      .finally(() => {\r\n        this.loading = false;\r\n        loadingModule.commitComplete(loading);\r\n      });\r\n  }\r\n}\r\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataDeliveryNavigation.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataDeliveryNavigation.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./QDataDeliveryNavigation.vue?vue&type=template&id=29e3b7a7&\"\nimport script from \"./QDataDeliveryNavigation.vue?vue&type=script&lang=ts&\"\nexport * from \"./QDataDeliveryNavigation.vue?vue&type=script&lang=ts&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return (_vm.deliveryMessage)?_c('table',{staticClass:\"keyvalue\"},[_c('tbody',[_c('tr',[_c('th',[_vm._v(_vm._s(_vm.$t('qDataDeliveryPage.metadata.customerReference'))+\":\")]),_c('td',[_c('span',[_vm._v(_vm._s(_vm.deliveryMessage.customerReference))])])]),_c('tr',[_c('th',[_vm._v(_vm._s(_vm.$t('qDataDeliveryPage.metadata.orderId'))+\":\")]),_c('td',[_c('span',[_vm._v(_vm._s(_vm.deliveryMessage.orderId))])])]),_c('tr',[_c('th',[_vm._v(_vm._s(_vm.$t('qDataDeliveryPage.metadata.invoiceNumbers'))+\":\")]),_c('td',[_c('span',[_vm._v(_vm._s(_vm.invoiceNumbers))])])]),_c('tr',[_c('th',[_vm._v(_vm._s(_vm.$t('qDataDeliveryPage.metadata.products'))+\":\")]),_c('td',_vm._l((_vm.deliveryMessage.details),function(detail,index){return _c('span',{key:index,staticClass:\"o-chip u-color-white u-print-color pr-1\",style:(_vm.getProductStyle(detail))},[_c('b',[_vm._v(_vm._s(detail.productDisplayName))])])}),0)]),_c('tr',[_c('th',[_vm._v(_vm._s(_vm.$t('qDataDeliveryPage.metadata.units'))+\":\")]),_c('td',[_c('span',[_vm._v(_vm._s(_vm._f(\"number\")(_vm.deliveryMessage.numberOfUnits)))])])]),_c('tr',[_c('th',[_vm._v(_vm._s(_vm.$t('qDataDeliveryPage.metadata.volume'))+\":\")]),_c('td',[_c('span',[_vm._v(_vm._s(_vm._f(\"number\")(_vm.deliveryMessage.totalQuantity))+\" t\")])])]),_c('tr',[_c('th',[_vm._v(_vm._s(_vm.$t('qDataDeliveryPage.metadata.destination'))+\":\")]),_c('td',[_c('span',[_vm._v(\" \"+_vm._s(_vm.deliveryMessage.deliveryAddressDestinationLocality)+\" \")])])]),(\n        _vm.deliveryMessage.deliverySupplierDisplayName ||\n        _vm.deliveryMessage.deliverySupplierNumber\n      )?_c('tr',[_c('th',[_vm._v(_vm._s(_vm.$t('qDataDeliveryPage.metadata.from'))+\":\")]),_c('td',[_c('span',[_vm._v(\" \"+_vm._s(_vm.$t('qDataDeliveryPage.metadata.fromValue', [ _vm.deliveryMessage.deliverySupplierDisplayName ? _vm.deliveryMessage.deliverySupplierDisplayName : _vm.deliveryMessage.deliverySupplierNumber ]))+\" \")])])]):_vm._e(),_c('tr',[_c('th',[_vm._v(_vm._s(_vm.$t('qDataDeliveryPage.metadata.deliveryDate'))+\":\")]),_c('td',[_c('span',[_vm._v(\" \"+_vm._s(_vm._f(\"date\")(_vm.deliveryMessage.deliveryDate))+\" \")])])])])]):_vm._e()}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\r\nimport { Component, Vue, Prop } from 'vue-property-decorator';\r\nimport { Config } from '@/utils/Config';\r\nimport { DeliveryMessage } from '@/models/QualityData/DeliveryMessage';\r\nimport { DeliveryMessageDetails } from '@/models/QualityData/DeliveryMessageDetails';\r\n\r\n@Component\r\nexport default class QDataDeliveryMetadata extends Vue {\r\n  @Prop({ required: true })\r\n  public deliveryMessage!: DeliveryMessage;\r\n\r\n  private get invoiceNumbers(): string {\r\n    return this.deliveryMessage.details.map((x) => x.invoiceNumber).join(', ');\r\n  }\r\n\r\n  private getProductStyle(detail: DeliveryMessageDetails): any {\r\n    return {\r\n      background: Config.getProductColor(detail.productColorCategory),\r\n    };\r\n  }\r\n}\r\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataDeliveryMetadata.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataDeliveryMetadata.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./QDataDeliveryMetadata.vue?vue&type=template&id=5f55766e&\"\nimport script from \"./QDataDeliveryMetadata.vue?vue&type=script&lang=ts&\"\nexport * from \"./QDataDeliveryMetadata.vue?vue&type=script&lang=ts&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","import { Consoler } from '@/utils/Consoler';\r\nimport { store } from '@/store';\r\nimport {\r\n  Module,\r\n  VuexModule,\r\n  Mutation,\r\n  Action,\r\n  getModule,\r\n} from 'vuex-module-decorators';\r\nimport qualityDataService from '@/services/QualityDataService';\r\nimport { GeneralQualityDataForDeliveryMessage } from '@/models/QualityData/GeneralQualityDataForDeliveryMessage';\r\nimport { CommonArrayStore } from '../commonArrayStore';\r\n\r\n@Module({\r\n  namespaced: true,\r\n  name: 'deliveryMessageQualityData',\r\n  dynamic: true,\r\n  store,\r\n})\r\nclass DeliveryMessageQualityDataModule extends VuexModule {\r\n  private common = new CommonArrayStore<\r\n    GeneralQualityDataForDeliveryMessage,\r\n    string\r\n  >(20); // reLoadMinMinutesInterval\r\n\r\n  // ---------------\r\n  // ### Getters ###\r\n  // ---------------\r\n\r\n  public get item() {\r\n    return (id: string) => this.common.getDataFor(id);\r\n  }\r\n\r\n  // -----------------\r\n  // ### Mutations ###\r\n  // -----------------\r\n\r\n  @Mutation private commitSetLoading(payload: {\r\n    id: string;\r\n    loadingPromise: Promise<GeneralQualityDataForDeliveryMessage>;\r\n    clearData?: boolean;\r\n  }) {\r\n    this.common.setLoading(payload);\r\n  }\r\n  @Mutation private commitSetLoadingComplete(payload: {\r\n    id: string;\r\n    data: GeneralQualityDataForDeliveryMessage;\r\n  }) {\r\n    this.common.setLoadingComplete(payload);\r\n  }\r\n  @Mutation private commitSetLoadingError(payload: {\r\n    id: string;\r\n    error?: any;\r\n    clearData?: boolean;\r\n  }) {\r\n    this.common.setLoadingError(payload);\r\n  }\r\n\r\n  // ---------------\r\n  // ### Actions ###\r\n  // ---------------\r\n\r\n  @Action\r\n  public async dispatchLoad(\r\n    deliveryMessageNumber: string\r\n  ): Promise<GeneralQualityDataForDeliveryMessage> {\r\n    // If recently loaded, return\r\n    if (this.common.hasFreshDataFor(deliveryMessageNumber)) {\r\n      return Promise.resolve(this.item(deliveryMessageNumber)!);\r\n    }\r\n\r\n    const currentlyLoadingPromise = this.common.isCurrentlyLoading(\r\n      deliveryMessageNumber\r\n    );\r\n    if (currentlyLoadingPromise) {\r\n      Consoler.debugLog(\r\n        'Already loading, waiting for existing load to finish',\r\n        'deliveryMessageQualityData'\r\n      );\r\n      return currentlyLoadingPromise;\r\n    }\r\n\r\n    const loadingPromise = qualityDataService\r\n      .getByDeliveryMessage(deliveryMessageNumber)\r\n      .then((response) => {\r\n        this.commitSetLoadingComplete({\r\n          id: deliveryMessageNumber,\r\n          data: response,\r\n        });\r\n        Consoler.debugLog('Load deliveryMessageQualityData success', response);\r\n        return Promise.resolve(response);\r\n      })\r\n      .catch((error) => {\r\n        Consoler.debugWarn('Load deliveryMessageQualityData failed', error);\r\n        this.commitSetLoadingError({ id: deliveryMessageNumber, error });\r\n        return Promise.reject(error);\r\n      });\r\n\r\n    this.commitSetLoading({\r\n      id: deliveryMessageNumber,\r\n      loadingPromise,\r\n      clearData: true,\r\n    });\r\n\r\n    return loadingPromise;\r\n  }\r\n}\r\n\r\nexport const deliveryMessageQualityDataModule = getModule(\r\n  DeliveryMessageQualityDataModule\r\n);\r\n","export interface DeliveryMessageDetails {\r\n  quantity?: number;\r\n  invoiceNumber: string;\r\n  productName: string;\r\n  productDisplayName: string;\r\n  productColorCategory: string;\r\n}\r\n\r\nexport function copyDeliveryMessageDetails(\r\n  deliveryMessageDetails: DeliveryMessageDetails\r\n): DeliveryMessageDetails {\r\n  return {\r\n    quantity: deliveryMessageDetails.quantity,\r\n    invoiceNumber: deliveryMessageDetails.invoiceNumber,\r\n    productName: deliveryMessageDetails.productName,\r\n    productDisplayName: deliveryMessageDetails.productDisplayName,\r\n    productColorCategory: deliveryMessageDetails.productColorCategory,\r\n  };\r\n}\r\n","import {\r\n  copyDeliveryMessageDetails,\r\n  DeliveryMessageDetails,\r\n} from './DeliveryMessageDetails';\r\n\r\nexport interface DeliveryMessage {\r\n  number: string;\r\n  deliveryDate: string;\r\n  deliveryAddressDestinationLocality: string;\r\n  numberOfUnits: number;\r\n  customerReference: string;\r\n  orderId: string;\r\n  deliverySupplierDisplayName: string;\r\n  deliverySupplierNumber: string;\r\n  totalQuantity: number;\r\n  details: DeliveryMessageDetails[];\r\n}\r\n\r\nexport function copyDeliveryMessage(\r\n  deliveryMessage: DeliveryMessage\r\n): DeliveryMessage {\r\n  return {\r\n    number: deliveryMessage.number,\r\n    deliveryDate: deliveryMessage.deliveryDate,\r\n    deliveryAddressDestinationLocality:\r\n      deliveryMessage.deliveryAddressDestinationLocality,\r\n    numberOfUnits: deliveryMessage.numberOfUnits,\r\n    customerReference: deliveryMessage.customerReference,\r\n    orderId: deliveryMessage.orderId,\r\n    deliverySupplierDisplayName: deliveryMessage.deliverySupplierDisplayName,\r\n    deliverySupplierNumber: deliveryMessage.deliverySupplierNumber,\r\n    totalQuantity: deliveryMessage.totalQuantity,\r\n    details: deliveryMessage.details.map((deliveryMessageDetails) =>\r\n      copyDeliveryMessageDetails(deliveryMessageDetails)\r\n    ),\r\n  };\r\n}\r\n","import { Consoler } from '@/utils/Consoler';\r\nimport { store } from '@/store';\r\nimport {\r\n  Module,\r\n  VuexModule,\r\n  Mutation,\r\n  Action,\r\n  getModule,\r\n} from 'vuex-module-decorators';\r\nimport {\r\n  copyDeliveryMessage,\r\n  DeliveryMessage,\r\n} from '@/models/QualityData/DeliveryMessage';\r\nimport { CommonArrayStore } from '../commonArrayStore';\r\nimport { deliveryMessagesModule } from './deliveryMessages';\r\nimport deliveryMessageService from '@/services/DeliveryMessageService';\r\n\r\n@Module({\r\n  namespaced: true,\r\n  name: 'deliveryMessage',\r\n  dynamic: true,\r\n  store,\r\n})\r\nclass DeliveryMessageModule extends VuexModule {\r\n  private common = new CommonArrayStore<DeliveryMessage, string>(20); // reLoadMinMinutesInterval\r\n\r\n  // ---------------\r\n  // ### Getters ###\r\n  // ---------------\r\n\r\n  public get item() {\r\n    return (id: string) => this.common.getDataFor(id);\r\n  }\r\n\r\n  // -----------------\r\n  // ### Mutations ###\r\n  // -----------------\r\n\r\n  @Mutation private commitSetLoading(payload: {\r\n    id: string;\r\n    loadingPromise: Promise<DeliveryMessage>;\r\n    clearData?: boolean;\r\n  }) {\r\n    this.common.setLoading(payload);\r\n  }\r\n  @Mutation private commitSetLoadingComplete(payload: {\r\n    id: string;\r\n    data: DeliveryMessage;\r\n  }) {\r\n    this.common.setLoadingComplete(payload);\r\n  }\r\n  @Mutation private commitSetLoadingError(payload: {\r\n    id: string;\r\n    error?: any;\r\n    clearData?: boolean;\r\n  }) {\r\n    this.common.setLoadingError(payload);\r\n  }\r\n\r\n  // ---------------\r\n  // ### Actions ###\r\n  // ---------------\r\n\r\n  @Action\r\n  public async dispatchLoad(\r\n    deliveryMessageNumber: string\r\n  ): Promise<DeliveryMessage> {\r\n    // If recently loaded, return\r\n    if (this.common.hasFreshDataFor(deliveryMessageNumber)) {\r\n      return Promise.resolve(this.item(deliveryMessageNumber)!);\r\n    }\r\n\r\n    const currentlyLoadingPromise = this.common.isCurrentlyLoading(\r\n      deliveryMessageNumber\r\n    );\r\n    if (currentlyLoadingPromise) {\r\n      Consoler.debugLog(\r\n        'Already loading, waiting for existing load to finish',\r\n        'deliveryMessage'\r\n      );\r\n      return currentlyLoadingPromise;\r\n    }\r\n\r\n    // Check if deliveryMessagesModule have the wanted delivery message\r\n    const deliveryMessage =\r\n      deliveryMessagesModule.search?.results?.items?.find(\r\n        (dm) => dm.number === deliveryMessageNumber\r\n      ) ?? null;\r\n    if (deliveryMessage) {\r\n      const deliveryMessageCopy = copyDeliveryMessage(deliveryMessage);\r\n      this.commitSetLoadingComplete({\r\n        id: deliveryMessageNumber,\r\n        data: deliveryMessageCopy,\r\n      });\r\n      Consoler.debugLog(\r\n        'Load deliveryMessage success, used deliveryMessagesModule result',\r\n        deliveryMessageCopy\r\n      );\r\n      return Promise.resolve(deliveryMessageCopy);\r\n    }\r\n\r\n    const loadingPromise = deliveryMessageService\r\n      .getDeliveryMessage(deliveryMessageNumber)\r\n      .then((response) => {\r\n        this.commitSetLoadingComplete({\r\n          id: deliveryMessageNumber,\r\n          data: response,\r\n        });\r\n        Consoler.debugLog('Load deliveryMessage success', response);\r\n        return Promise.resolve(response);\r\n      })\r\n      .catch((error) => {\r\n        Consoler.debugWarn('Load deliveryMessage failed', error);\r\n        this.commitSetLoadingError({ id: deliveryMessageNumber, error });\r\n        return Promise.reject(error);\r\n      });\r\n\r\n    this.commitSetLoading({\r\n      id: deliveryMessageNumber,\r\n      loadingPromise,\r\n      clearData: true,\r\n    });\r\n\r\n    return loadingPromise;\r\n  }\r\n}\r\n\r\nexport const deliveryMessageModule = getModule(DeliveryMessageModule);\r\n","\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\r\nimport { Component, Vue, Watch } from 'vue-property-decorator';\r\nimport DefaultLayout from '@/layouts/DefaultLayout.vue';\r\nimport Breadcrumbs from '@/components/general/Breadcrumbs.vue';\r\nimport Messages from '@/components/general/Messages.vue';\r\nimport { Permissions } from '@/utils/Permissions';\r\nimport QDataTextileParameters from '@/components/QDataTextileParameters.vue';\r\nimport QDataPaperParameters from '@/components/QDataPaperParameters.vue';\r\nimport QDataSearchBox from '@/components/QDataSearchBox.vue';\r\nimport QDataUnitList from '@/components/QDataUnitList.vue';\r\nimport QDataDeliveryNavigation from '@/components/QDataDeliveryNavigation.vue';\r\nimport QDataDeliveryMetadata from '@/components/QDataDeliveryMetadata.vue';\r\nimport { deliveryMessageQualityDataModule } from '@/store/modules/deliveryMessageQualityData';\r\nimport {\r\n  routeNameQData,\r\n  routeNameQDataDelivery,\r\n  routeNameQDataSearch,\r\n} from '@/router/routes';\r\nimport { DeliveryMessage } from '@/models/QualityData/DeliveryMessage';\r\nimport { deliveryMessageModule } from '@/store/modules/deliveryMessage';\r\nimport {\r\n  deliveryMessagesModule,\r\n  QueryType,\r\n} from '@/store/modules/deliveryMessages';\r\nimport { GeneralQualityDataForDeliveryMessage } from '@/models/QualityData/GeneralQualityDataForDeliveryMessage';\r\nimport { Consoler } from '@/utils/Consoler';\r\nimport { loadingModule } from '@/store/modules/loading';\r\nimport i18n from '@/i18n/i18n';\r\nimport { Unit } from '@/models/QualityData/Unit';\r\nimport qualityDataService from '../services/QualityDataService';\r\nimport deliveryMessageService from '@/services/DeliveryMessageService';\r\nimport { ParameterValueAverage } from '@/models/QualityData/ParameterValueAverage';\r\nimport {\r\n  copyQDataPageQueryFromRoute,\r\n  getQDataPageQueryData,\r\n  getQDataPageQueryText,\r\n  getQDataQueryType,\r\n  QDataQueryData,\r\n} from '@/utils/RoutingForQData';\r\nimport { PulpType } from '@/models/QualityData/PulpType';\r\nimport { Config } from '@/utils/Config';\r\nimport { EventBus } from '@/utils/EventBus';\r\nimport { Message, MessageType } from '@/models/Message';\r\nimport { RawLocation, Route } from 'vue-router';\r\nimport { Breadcrumb } from '@/models/Breadcrumb';\r\nimport {\r\n  getNotFoundOrErrorLocation,\r\n  getRouteTrackingInfo,\r\n} from '@/router/functions';\r\nimport telemetryService, {\r\n  RouteTrackingInfo,\r\n} from '@/services/TelemetryService';\r\nimport { GeneralParameter } from '@/models/QualityData/GeneralParameter';\r\nimport TextBox from '@/components/general/TextBox.vue';\r\nimport { FeatureFlagNames } from '@/models/FeatureFlagNames';\r\n\r\nComponent.registerHooks(['beforeRouteEnter', 'beforeRouteUpdate']);\r\n\r\nasync function beforeRoute(\r\n  to: Route,\r\n  from: Route,\r\n  next: (to?: RawLocation | void) => void\r\n): Promise<void> {\r\n  const loading = await loadingModule.dispatchAdd(\r\n    i18n.tc('loading.qDataDeliveryPage.deliveryMessage').toString()\r\n  );\r\n  deliveryMessageModule\r\n    .dispatchLoad(to.params.deliveryMessageNumber)\r\n    .then(() => {\r\n      // Delivery message found, continue\r\n      next();\r\n    })\r\n    .catch(() => {\r\n      // Delivery message not found, stop tracking and show 404 page\r\n      telemetryService.stopTrackPage(getRouteTrackingInfo(to), {\r\n        stoppedInAdvance: true,\r\n        notFound: true,\r\n      });\r\n      next(getNotFoundOrErrorLocation(to));\r\n    })\r\n    .finally(() => {\r\n      loadingModule.commitComplete(loading);\r\n    });\r\n}\r\n\r\n@Component({\r\n  components: {\r\n    DefaultLayout,\r\n    Breadcrumbs,\r\n    Messages,\r\n    QDataSearchBox,\r\n    QDataTextileParameters,\r\n    QDataPaperParameters,\r\n    QDataUnitList,\r\n    QDataDeliveryNavigation,\r\n    QDataDeliveryMetadata,\r\n    TextBox,\r\n  },\r\n})\r\nexport default class QDataDeliveryPage extends Vue {\r\n  private routeTrackingInfo: RouteTrackingInfo = {};\r\n  private deliveryMessageNumber: string = '';\r\n  private queryData: QDataQueryData | null = null;\r\n  private errorLoadingQData: boolean = false;\r\n  private downloadingDataSheet: boolean = false;\r\n  private downloadingEudrDataCsv: boolean = false;\r\n  private paperPredictedRevolutions: number | undefined = undefined;\r\n\r\n  private get isLoading(): boolean {\r\n    return loadingModule.isLoading;\r\n  }\r\n\r\n  private get deliveryMessage(): DeliveryMessage | null {\r\n    return deliveryMessageModule.item(this.deliveryMessageNumber);\r\n  }\r\n\r\n  private get deliveryMessages(): DeliveryMessage[] {\r\n    return deliveryMessagesModule.search?.results?.items ?? [];\r\n  }\r\n\r\n  private get deliveryMessageQualityData(): GeneralQualityDataForDeliveryMessage | null {\r\n    return deliveryMessageQualityDataModule.item(this.deliveryMessageNumber);\r\n  }\r\n\r\n  private get isPulpTypeTextile(): boolean {\r\n    return (\r\n      this.deliveryMessageQualityData !== null &&\r\n      this.deliveryMessageQualityData.pulpType === PulpType.Textile\r\n    );\r\n  }\r\n\r\n  private get isPulpTypePaper(): boolean {\r\n    return (\r\n      this.deliveryMessageQualityData !== null &&\r\n      this.deliveryMessageQualityData.pulpType === PulpType.Paper\r\n    );\r\n  }\r\n\r\n  private get deliveryMessageAverageValues(): ParameterValueAverage[] {\r\n    return this.deliveryMessageQualityData !== null\r\n      ? this.deliveryMessageQualityData.averageValues\r\n      : [];\r\n  }\r\n\r\n  private get hasUnitsFromBeforeAndAfterBreakpoint(): boolean {\r\n    return this.deliveryMessageQualityData !== null\r\n      ? this.deliveryMessageQualityData.hasUnitsFromBeforeAndAfterBreakpoint\r\n      : false;\r\n  }\r\n\r\n  private get deliveryMessageUnits(): Unit[] {\r\n    return this.deliveryMessageQualityData !== null\r\n      ? this.deliveryMessageQualityData.units\r\n      : [];\r\n  }\r\n\r\n  private get deliveryMessageParameters(): GeneralParameter[] {\r\n    return this.deliveryMessageQualityData !== null\r\n      ? this.deliveryMessageQualityData.parameters\r\n      : [];\r\n  }\r\n\r\n  private get selectedUnit(): Unit | null {\r\n    const unitId = this.$route.query.unitId;\r\n    if (!unitId) {\r\n      return null;\r\n    }\r\n\r\n    const unit = this.deliveryMessageUnits.find((u) => u.id === unitId);\r\n    return unit ?? null;\r\n  }\r\n\r\n  private get searchTerm(): string {\r\n    return this.$route.query.term?.toString() ?? '';\r\n  }\r\n\r\n  private get breadcrumbs(): Breadcrumb[] {\r\n    // Q-data -> [\"term\" OR dates] -> Delivery number\r\n    const query = copyQDataPageQueryFromRoute(this.$route);\r\n    const queryText = getQDataPageQueryText(this.$route);\r\n    const queryType = getQDataQueryType(this.$route);\r\n\r\n    const items: Breadcrumb[] = [\r\n      {\r\n        routeName: routeNameQData,\r\n        name: this.$t('breadcrumbs.' + routeNameQData).toString(),\r\n      },\r\n    ];\r\n    // Only add dates/term if any in query\r\n    if (queryText !== '' && queryType !== null) {\r\n      items.push({\r\n        routeName:\r\n          queryType === QueryType.ByDates\r\n            ? routeNameQData\r\n            : routeNameQDataSearch,\r\n        routeQuery: query,\r\n        name: queryText,\r\n      });\r\n    }\r\n    items.push({\r\n      routeName: routeNameQDataDelivery,\r\n      routeParams: {\r\n        deliveryMessageNumber: this.$route.params.deliveryMessageNumber,\r\n      },\r\n      routeQuery: query,\r\n      name: this.$t('breadcrumbs.' + routeNameQDataDelivery, [\r\n        this.$route.params.deliveryMessageNumber,\r\n      ]).toString(),\r\n    });\r\n    return items;\r\n  }\r\n\r\n  public async beforeRouteEnter(\r\n    to: Route,\r\n    from: Route,\r\n    next: (to?: RawLocation | void) => void\r\n  ): Promise<void> {\r\n    await beforeRoute(to, from, next);\r\n  }\r\n\r\n  public async beforeRouteUpdate(\r\n    to: Route,\r\n    from: Route,\r\n    next: (to?: RawLocation | void) => void\r\n  ): Promise<void> {\r\n    await beforeRoute(to, from, next);\r\n  }\r\n\r\n  @Watch('$route', { immediate: false, deep: true })\r\n  private onRouteChange(): void {\r\n    this.routeTrackingInfo = getRouteTrackingInfo(this.$route);\r\n    this.initialize().finally(() => {\r\n      telemetryService.stopTrackPage(this.routeTrackingInfo);\r\n    });\r\n  }\r\n\r\n  private created(): void {\r\n    this.routeTrackingInfo = getRouteTrackingInfo(this.$route);\r\n    this.initialize().finally(() => {\r\n      telemetryService.stopTrackPage(this.routeTrackingInfo);\r\n    });\r\n  }\r\n\r\n  private initialize(): Promise<void> {\r\n    this.deliveryMessageNumber = this.$route.params.deliveryMessageNumber;\r\n    this.queryData = getQDataPageQueryData(this.$route);\r\n    return this.loadDeliveryMessageQualityData();\r\n  }\r\n\r\n  private async loadDeliveryMessageQualityData(): Promise<void> {\r\n    const loading = await loadingModule.dispatchAdd(\r\n      i18n.tc('loading.qDataDeliveryPage.qData').toString()\r\n    );\r\n    this.errorLoadingQData = false;\r\n\r\n    return deliveryMessageQualityDataModule\r\n      .dispatchLoad(this.deliveryMessageNumber)\r\n      .then(() => undefined)\r\n      .catch(() => {\r\n        this.errorLoadingQData = true;\r\n      })\r\n      .finally(() => {\r\n        loadingModule.commitComplete(loading);\r\n      });\r\n  }\r\n\r\n  private get eudrDownloadsEnabled(): boolean {\r\n    return Permissions.isFeatureEnabled(FeatureFlagNames.EudrDownloads);\r\n  }\r\n\r\n  private isDeliveryDateAfterEudrDate(\r\n    deliveryDateString: string | null\r\n  ): boolean {\r\n    if (deliveryDateString === null || deliveryDateString === undefined) {\r\n      return false;\r\n    }\r\n\r\n    var deliveryDate: Date | null = null;\r\n\r\n    try {\r\n      deliveryDate = new Date(deliveryDateString!);\r\n    } catch (ex: any) {\r\n      Consoler.debugLog(\r\n        `Failed to parse deliveryDateString ${deliveryDateString} to a Date object`\r\n      );\r\n\r\n      return false;\r\n    }\r\n\r\n    if (deliveryDate! >= this.eudrDownloadsFromDate) {\r\n      return true;\r\n    }\r\n\r\n    return false;\r\n  }\r\n\r\n  private get eudrDownloadsFromDate(): Date {\r\n    const dateString = Config.Settings.EudrDownloadsFromDate;\r\n\r\n    try {\r\n      return new Date(dateString);\r\n    } catch (ex: any) {\r\n      Consoler.debugLog(\r\n        `Failed getting a correct date from Config.Settings.EudrDownloadsFromDate: ${dateString}`\r\n      );\r\n    }\r\n    return new Date('2050-01-01T00:00:00');\r\n  }\r\n\r\n  private async downloadDataSheet() {\r\n    this.downloadingDataSheet = true;\r\n\r\n    await qualityDataService\r\n      .downloadDeliveryQualityDataAsExcel(\r\n        this.deliveryMessageNumber,\r\n        this.paperPredictedRevolutions\r\n      )\r\n      .catch((error) => {\r\n        Consoler.debugWarn('Error downloading data sheet', error);\r\n        const errorMessage: Message = {\r\n          text: this.$t(\r\n            'qDataDeliveryPage.errorDownloadingDataSheet'\r\n          ).toString(),\r\n          type: MessageType.error,\r\n        };\r\n        EventBus.$emit(Config.AddMessageEvent, errorMessage);\r\n      })\r\n      .finally(() => {\r\n        this.downloadingDataSheet = false;\r\n      });\r\n  }\r\n\r\n  private async downloadEudrDataCsv() {\r\n    this.downloadingEudrDataCsv = true;\r\n\r\n    await deliveryMessageService\r\n      .downloadDeliveryMessageEudrDataAsCsv(this.deliveryMessageNumber)\r\n      .catch((error) => {\r\n        Consoler.debugWarn('Error downloading EUDR data', error);\r\n        const errorMessage: Message = {\r\n          text: this.$t(\r\n            'qDataDeliveryPage.errorDownloadingEudrData'\r\n          ).toString(),\r\n          type: MessageType.error,\r\n        };\r\n        EventBus.$emit(Config.AddMessageEvent, errorMessage);\r\n      })\r\n      .finally(() => {\r\n        this.downloadingEudrDataCsv = false;\r\n      });\r\n  }\r\n\r\n  private onPaperPredictedRevolutionsChange(revolutions: number | undefined) {\r\n    this.paperPredictedRevolutions = revolutions;\r\n  }\r\n}\r\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataDeliveryPage.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataDeliveryPage.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./QDataDeliveryPage.vue?vue&type=template&id=88cf523c&scoped=true&\"\nimport script from \"./QDataDeliveryPage.vue?vue&type=script&lang=ts&\"\nexport * from \"./QDataDeliveryPage.vue?vue&type=script&lang=ts&\"\nimport style0 from \"./QDataDeliveryPage.vue?vue&type=style&index=0&id=88cf523c&scoped=true&lang=scss&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  \"88cf523c\",\n  null\n  \n)\n\nexport default component.exports","import { fileNameDateFilter } from '@/filters/fileNameDate';\r\nimport * as AverageQualityDataByDates from '@/models/QualityData/AverageQualityDataByDates';\r\nimport * as PredictedQualityDataByDeliveryMessage from '@/models/QualityData/PredictedQualityDataByDeliveryMessage';\r\nimport { GeneralQualityDataForDeliveryMessage } from '@/models/QualityData/GeneralQualityDataForDeliveryMessage';\r\nimport { Suggestion } from '@/models/QualityData/Suggestion';\r\nimport { GeneralQualityDataForUnits } from '@/models/QualityData/GeneralQualityDataForUnits';\r\nimport moment from 'moment';\r\nimport { arrayParamsSerializer, BaseServiceDefinition } from './BaseService';\r\n\r\nclass QualityDataService extends BaseServiceDefinition {\r\n  constructor() {\r\n    super();\r\n  }\r\n\r\n  public getUnits(ids: string[]): Promise<GeneralQualityDataForUnits> {\r\n    return this.get('/api/v1/qualityData/units', { ids }, arrayParamsSerializer)\r\n      .then((response) => {\r\n        return { ...response.data, ...{ ids } };\r\n      })\r\n      .catch((error) => {\r\n        return Promise.reject(error);\r\n      });\r\n  }\r\n\r\n  public getByDeliveryMessage(\r\n    deliveryMessageNumber: string\r\n  ): Promise<GeneralQualityDataForDeliveryMessage> {\r\n    return this.get(\r\n      '/api/v1/qualityData/deliverymessages/' + deliveryMessageNumber\r\n    )\r\n      .then((response) => {\r\n        return response.data;\r\n      })\r\n      .catch((error) => {\r\n        return Promise.reject(error);\r\n      });\r\n  }\r\n\r\n  public getPredictedParameters(\r\n    deliveryMessageNumber: string,\r\n    revolutions?: number\r\n  ): Promise<PredictedQualityDataByDeliveryMessage.PredictedQualityDataByDeliveryMessage> {\r\n    return this.get(\r\n      '/api/v1/qualityData/deliveryMessages/' +\r\n        deliveryMessageNumber +\r\n        '/predictedParameters',\r\n      { revolutions }\r\n    )\r\n      .then((response) => {\r\n        return response.data;\r\n      })\r\n      .catch((error) => {\r\n        return Promise.reject(error);\r\n      });\r\n  }\r\n\r\n  public getSuggestions(term: string): Promise<Suggestion[]> {\r\n    return this.get('/api/v1/qualityData/suggestions', { term })\r\n      .then((response) => {\r\n        return response.data;\r\n      })\r\n      .catch((error) => {\r\n        return Promise.reject(error);\r\n      });\r\n  }\r\n\r\n  public getAverages(\r\n    fromDate: Date,\r\n    toDate: Date,\r\n    productNames?: string[]\r\n  ): Promise<AverageQualityDataByDates.AverageQualityDataByDates> {\r\n    return this.get(\r\n      '/api/v1/qualityData/parameters',\r\n      {\r\n        fromDate: fromDate.toDateString(),\r\n        toDate: toDate.toDateString(),\r\n        productNames,\r\n      },\r\n      arrayParamsSerializer\r\n    )\r\n      .then((response) => {\r\n        return response.data;\r\n      })\r\n      .catch((error) => {\r\n        return Promise.reject(error);\r\n      });\r\n  }\r\n\r\n  public async downloadDeliveryQualityDataAsExcel(\r\n    deliveryMessageNumber: string,\r\n    revolutions?: number\r\n  ): Promise<void> {\r\n    await this.downloadFile(\r\n      `/api/v1/qualitydata/deliverymessages/${deliveryMessageNumber}/excel`,\r\n      `Q-Data_delivery_${deliveryMessageNumber}.xlsx`,\r\n      { revolutions }\r\n    );\r\n  }\r\n\r\n  public async downloadDeliveriesQualityDataAsExcel(\r\n    deliveryMessageNumbers: string[],\r\n    revolutions?: number,\r\n    pageSize?: number,\r\n    downloadAll?: boolean,\r\n    fromDate?: Date,\r\n    toDate?: Date,\r\n    productNames?: string[],\r\n    searchTerm?: string\r\n  ): Promise<void> {\r\n    await this.downloadFile(\r\n      `/api/v1/qualitydata/deliverymessages/excel`,\r\n      `Q-Data_deliveries_${fileNameDateFilter(moment())}.xlsx`,\r\n      {\r\n        deliveryMessageNumbers,\r\n        revolutions,\r\n        pageSize,\r\n        downloadAll,\r\n        dateFrom: fromDate?.toDateString(),\r\n        dateTo: toDate?.toDateString(),\r\n        productNames,\r\n        searchTerm,\r\n      },\r\n      arrayParamsSerializer\r\n    );\r\n  }\r\n\r\n  public async downloadUnitsQualityDataAsExcel(ids: string[]): Promise<void> {\r\n    await this.downloadFile(\r\n      '/api/v1/qualityData/units/excel',\r\n      `Q-Data_units_${fileNameDateFilter(moment())}.xlsx`,\r\n      { ids },\r\n      arrayParamsSerializer\r\n    );\r\n  }\r\n\r\n  public async scanImageForUnitId(image: any): Promise<string | undefined> {\r\n    try {\r\n      const formData = new FormData();\r\n\r\n      formData.append('imageFile', image);\r\n\r\n      const response = await this.post('/api/v1/qualityData/units', formData, {\r\n        headers: { 'Content-Type': 'multipart/form-data' },\r\n      });\r\n\r\n      const unitId = response.data;\r\n\r\n      return unitId;\r\n    } catch (error) {\r\n      return Promise.reject(error);\r\n    }\r\n  }\r\n}\r\n\r\nconst qualityDataService: QualityDataService = new QualityDataService();\r\n\r\nexport default qualityDataService;\r\n","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--9-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--9-oneOf-1-1!../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--9-oneOf-1-2!../../node_modules/sass-loader/dist/cjs.js??ref--9-oneOf-1-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataParameterList.vue?vue&type=style&index=0&id=4362eccc&scoped=true&lang=scss&\"","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('DefaultLayout',[_c('Breadcrumbs',{attrs:{\"items\":_vm.breadcrumbs}}),_c('Messages'),_c('div',{staticClass:\"container-fluid mt-3\"},[_c('div',{staticClass:\"d-flex flex-row justify-content-between flex-wrap align-items-center\"},[_c('h1',{staticClass:\"t-heading-3 pr-2\"},[_vm._v(_vm._s(_vm.$t('qDataPage.title')))]),_c('div',{staticClass:\"d-align-self-end\"},[_c('QDataSearchBox')],1)]),_c('span',{staticClass:\"o-line\"}),_c('div',{staticClass:\"d-flex flex-row\"},[_c('QDataDeliveryMessagesFilter',{staticClass:\"mb-3\",attrs:{\"dateRange\":_vm.deliveryMessagesRange,\"selectedProductNames\":_vm.selectedProductNames,\"products\":_vm.products,\"showProductsFilter\":_vm.products.length,\"selectedParameter\":_vm.selectedParameter,\"parameters\":_vm.parametersWithAverages,\"showParameterFilter\":_vm.parametersWithAverages.length && _vm.deliveryMessages.length},on:{\"filter\":_vm.onDeliveryMessagesFilter,\"parameterChange\":_vm.onParameterChange,\"productsChange\":_vm.onProductsChange}})],1),(_vm.hasUnitsFromBeforeAndAfterBreakpoint)?_c('TextBox',{attrs:{\"mainText\":_vm.$t('qDataPage.fibreSwitchDisclaimer'),\"secondaryText\":_vm.$t('qDataPage.fibreSwitchDisclaimerSecondPart'),\"backgroundColor\":'yellow-50'}}):_vm._e(),(_vm.deliveryMessages.length)?_c('QDataChart',{attrs:{\"loading\":_vm.loadingAverages,\"error\":_vm.errorAverages,\"selectedParameter\":_vm.selectedParameter,\"selectedProductNames\":_vm.selectedProductNames}}):_vm._e(),(_vm.errorDeliveries)?_c('div',{staticClass:\"c-alert c-alert--red mb-2\"},[_c('span',{staticClass:\"c-alert__text\"},[_vm._v(_vm._s(_vm.$t('qDataPage.error')))])]):_vm._e(),_c('div',{staticClass:\"row\"},[_c('div',{staticClass:\"col-12 mb-3\"},[(_vm.loadingDeliveries)?_c('div',{staticClass:\"u-position-relative u-min-height-300\"},[_c('span',{staticClass:\"o-loader o-loader--absolute\"})]):_vm._e(),(_vm.downloadingExcel)?_c('div',[_c('span',{staticClass:\"o-loader o-loader--absolute\"})]):_vm._e(),(_vm.aSearchHasBeenDone && !_vm.errorDeliveries)?[(_vm.deliveryMessages.length)?[_c('h3',{staticClass:\"t-heading-5 mb-3\"},[_vm._v(\" \"+_vm._s(_vm.$t('qDataPage.subtitle', [_vm.totalCount]))+\" \")]),_c('QDataDeliveryList',{staticClass:\"mb-3\",attrs:{\"deliveryMessages\":_vm.deliveryMessages,\"deliveryMessagesRange\":_vm.deliveryMessagesRange,\"totalNumberOfDeliveries\":_vm.deliveryMessagesCount,\"deliveryMessagesProductsSelected\":_vm.selectedProductNames},on:{\"click\":_vm.onQDataDeliveryListClick,\"downloadExcel\":_vm.onDownloadExcel}}),_c('Pagination',{attrs:{\"pageIndex\":_vm.pageIndex,\"pageCount\":_vm.pageCount,\"pageSize\":_vm.pageSize,\"routes\":_vm.paginationRoutes},on:{\"pageSizeChanged\":_vm.onPageSizeChanged}})]:(!_vm.loadingDeliveries)?_c('div',[(_vm.selectedProductNames.length && _vm.products.length)?[_vm._v(\" \"+_vm._s(_vm.$t('qDataPage.noData.withProductsFilter'))+\" \")]:[_vm._v(\" \"+_vm._s(_vm.$t('qDataPage.noData.withoutProductsFilter'))+\" \")]],2):_vm._e()]:_vm._e()],2)])],1)],1)}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:\"d-flex flex-wrap\"},[(_vm.dateRange)?_c('CustomDateRangePicker',{staticClass:\"u-xs-full-width mr-sm-3 mb-1\",attrs:{\"dateRange\":_vm.dateRange,\"shortcuts\":_vm.dateRangeShortcuts,\"maxDate\":_vm.startOfToday,\"maxRangeLengthInMonths\":_vm.maxRangeLengthInMonths},on:{\"update\":_vm.onUpdate}}):_vm._e(),(_vm.showProductsFilter)?_c('TreeSelect',{staticClass:\"the-tree-select u-xs-full-width mr-sm-3 mb-1\",attrs:{\"value\":_vm.actualProductNames,\"options\":_vm.productOptions,\"placeholder\":_vm.$t('qDataDeliveryMessagesFilter.productsPlaceholder'),\"clearable\":true},on:{\"select\":_vm.onProductsTreeSelectSelect}}):_vm._e(),(_vm.showParameterFilter)?_c('div',{staticClass:\"c-form-element-group c-form-element-group--prepend u-xs-full-width mb-1\"},[_vm._m(0),_c('SelectBox',{staticClass:\"u-xs-full-width\",attrs:{\"value\":_vm.actualParameter,\"options\":_vm.parameterSelectOptions},on:{\"input\":_vm.onActualParameterInput}})],1):_vm._e()],1)}\nvar staticRenderFns = [function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('span',{staticClass:\"c-form-element-group__prepend\"},[_c('span',{staticClass:\"mdi mdi-chart-timeline-variant\"})])}]\n\nexport { render, staticRenderFns }","\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\r\nimport { Component, Vue, Prop, Watch } from 'vue-property-decorator';\r\nimport CustomDateRangePicker from '@/components/general/CustomDateRangePicker.vue';\r\nimport SelectBox, { SelectOption } from '@/components/general/SelectBox.vue';\r\nimport TreeSelect, {\r\n  TreeSelectNode,\r\n} from '@/components/general/TreeSelect.vue';\r\nimport { Dates } from '@/utils/Dates';\r\nimport { DeliveryMessageProduct } from '@/models/QualityData/DeliveryMessageProduct';\r\nimport { DateRange } from '@/models/DateRange';\r\nimport { DateRangeShortcut } from '@/models/DateRangeShortcut';\r\nimport { GeneralParameter } from '@/models/QualityData/GeneralParameter';\r\n\r\n@Component({\r\n  components: {\r\n    CustomDateRangePicker,\r\n    SelectBox,\r\n    TreeSelect,\r\n  },\r\n})\r\nexport default class QDataDeliveryMessagesFilter extends Vue {\r\n  @Prop({ required: true })\r\n  private dateRange!: DateRange | null;\r\n\r\n  @Prop({ required: true })\r\n  private selectedProductNames!: string[];\r\n\r\n  @Prop({ required: true })\r\n  private products!: DeliveryMessageProduct[];\r\n\r\n  @Prop({ required: false, default: () => true })\r\n  private showProductsFilter!: boolean;\r\n\r\n  @Prop({ required: true })\r\n  private selectedParameter!: GeneralParameter;\r\n\r\n  @Prop({ required: true })\r\n  private parameters!: GeneralParameter[];\r\n\r\n  @Prop({ required: false, default: () => true })\r\n  private showParameterFilter!: boolean;\r\n\r\n  private readonly maxRangeLengthInMonths: number = 12;\r\n\r\n  private dateRangeShortcuts: DateRangeShortcut[] = [];\r\n  private actualParameter: GeneralParameter | null = null;\r\n  private actualProductNames: string[] = [];\r\n\r\n  private get startOfToday(): Date {\r\n    return Dates.startOfToday();\r\n  }\r\n\r\n  private get productOptions(): TreeSelectNode[] {\r\n    return this.products.map((product) => ({\r\n      id: product.productName,\r\n      label: product.productDisplayName,\r\n    }));\r\n  }\r\n\r\n  private get parameterSelectOptions(): SelectOption[] {\r\n    return this.parameters.map((parameter) => ({\r\n      value: parameter,\r\n      text: parameter.displayName,\r\n    }));\r\n  }\r\n\r\n  @Watch('selectedParameter', { immediate: false, deep: false })\r\n  private onSelectedParameterChange(val: GeneralParameter) {\r\n    this.actualParameter = val;\r\n  }\r\n\r\n  @Watch('selectedProductNames', { immediate: false, deep: false })\r\n  private onSelectedProductNamesChange(val: string[]) {\r\n    this.actualProductNames = val;\r\n  }\r\n\r\n  private created(): void {\r\n    this.actualParameter = this.selectedParameter;\r\n    this.actualProductNames = this.selectedProductNames;\r\n\r\n    this.dateRangeShortcuts = this.createDateRangeShortcuts();\r\n  }\r\n\r\n  private createDateRangeShortcuts(): DateRangeShortcut[] {\r\n    const shortcuts: DateRangeShortcut[] = [];\r\n\r\n    shortcuts.push({\r\n      text: this.$t('qDataDeliveryMessagesFilter.ranges.today').toString(),\r\n      range: {\r\n        fromDate: this.startOfToday,\r\n        toDate: this.startOfToday,\r\n      },\r\n    });\r\n    shortcuts.push({\r\n      text: this.$t(\r\n        'qDataDeliveryMessagesFilter.ranges.currentYear'\r\n      ).toString(),\r\n      range: {\r\n        fromDate: Dates.startOfYear(this.startOfToday.getFullYear()),\r\n        toDate: this.startOfToday,\r\n      },\r\n    });\r\n    shortcuts.push({\r\n      text: this.$t('qDataDeliveryMessagesFilter.ranges.pastMonth').toString(),\r\n      range: {\r\n        fromDate: Dates.getDateANumbersOfMonthsInThePast(1),\r\n        toDate: this.startOfToday,\r\n      },\r\n    });\r\n    shortcuts.push({\r\n      text: this.$t(\r\n        'qDataDeliveryMessagesFilter.ranges.past3Months'\r\n      ).toString(),\r\n      range: {\r\n        fromDate: Dates.getDateANumbersOfMonthsInThePast(3),\r\n        toDate: this.startOfToday,\r\n      },\r\n    });\r\n    shortcuts.push({\r\n      text: this.$t(\r\n        'qDataDeliveryMessagesFilter.ranges.past6Months'\r\n      ).toString(),\r\n      range: {\r\n        fromDate: Dates.getDateANumbersOfMonthsInThePast(6),\r\n        toDate: this.startOfToday,\r\n      },\r\n    });\r\n    shortcuts.push({\r\n      text: this.$t('qDataDeliveryMessagesFilter.ranges.pastYear').toString(),\r\n      range: {\r\n        fromDate: Dates.getDateANumbersOfMonthsInThePast(12),\r\n        toDate: this.startOfToday,\r\n      },\r\n    });\r\n    shortcuts.push({\r\n      text: this.$t('qDataDeliveryMessagesFilter.ranges.lastYear').toString(),\r\n      range: {\r\n        fromDate: Dates.startOfLastYear(),\r\n        toDate: Dates.endOfLastYear(),\r\n      },\r\n    });\r\n\r\n    return shortcuts;\r\n  }\r\n\r\n  private onActualParameterInput(val: GeneralParameter) {\r\n    this.$emit('parameterChange', val);\r\n  }\r\n\r\n  private onProductsTreeSelectSelect(val: string[]) {\r\n    if (\r\n      val.length !== this.selectedProductNames.length ||\r\n      val.some(\r\n        (v) =>\r\n          !this.selectedProductNames.find(\r\n            (selectedProductName) => selectedProductName === v\r\n          )\r\n      )\r\n    ) {\r\n      this.$emit('productsChange', val);\r\n    }\r\n  }\r\n\r\n  private onUpdate(dateRange: DateRange): void {\r\n    this.$emit('filter', dateRange);\r\n  }\r\n}\r\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataDeliveryMessagesFilter.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataDeliveryMessagesFilter.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./QDataDeliveryMessagesFilter.vue?vue&type=template&id=82f2148e&scoped=true&\"\nimport script from \"./QDataDeliveryMessagesFilter.vue?vue&type=script&lang=ts&\"\nexport * from \"./QDataDeliveryMessagesFilter.vue?vue&type=script&lang=ts&\"\nimport style0 from \"./QDataDeliveryMessagesFilter.vue?vue&type=style&index=0&id=82f2148e&scoped=true&lang=scss&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  \"82f2148e\",\n  null\n  \n)\n\nexport default component.exports","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:\"q-data-chart row\"},[_c('div',{staticClass:\"col-12\"},[(_vm.loading)?_c('div',{staticClass:\"u-position-relative\"},[_c('div',{staticClass:\"o-loader o-loader--absolute mt-5\"})]):_vm._e(),(!_vm.error && (_vm.loading || _vm.averages.length))?_c('highcharts',{attrs:{\"options\":_vm.chartOptions}}):_c('div',[(_vm.error)?_c('div',{staticClass:\"c-alert c-alert--red mb-2\",attrs:{\"data-element-id\":\"qDataChartErrorAlert\"}},[_c('span',{staticClass:\"c-alert__text\"},[_vm._v(_vm._s(_vm.$t('qDataChart.error')))]),_c('span',{staticClass:\"js-toggle-hidden c-alert__close\",attrs:{\"data-element-id\":\"qDataChartErrorAlert\"}})]):(_vm.selectedParameter)?_c('p',{staticClass:\"u-text-center pt-5\"},[_vm._v(\" \"+_vm._s(_vm.$t('qDataChart.noDataForParameter', [_vm.selectedParameter.displayName]))+\" \")]):_vm._e()])],1)])}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","import { CommonStore } from '@/store/common';\r\nimport { store } from '@/store';\r\n\r\nimport {\r\n  Module,\r\n  VuexModule,\r\n  Mutation,\r\n  Action,\r\n  getModule,\r\n} from 'vuex-module-decorators';\r\nimport qualityDataService from '@/services/QualityDataService';\r\nimport { AverageQualityDataByDates } from '@/models/QualityData/AverageQualityDataByDates';\r\n\r\ninterface Data {\r\n  fromDate: Date;\r\n  toDate: Date;\r\n  results: AverageQualityDataByDates;\r\n}\r\n\r\n@Module({\r\n  namespaced: true,\r\n  name: 'parameterQualityDataAverages',\r\n  dynamic: true,\r\n  store,\r\n})\r\nclass ParameterQualityDataAveragesModule extends VuexModule {\r\n  public data: Data | null = null;\r\n\r\n  private common = new CommonStore(10); // reLoadMinMinutesInterval\r\n\r\n  // ---------------\r\n  // ### Getters ###\r\n  // ---------------\r\n\r\n  public get loading() {\r\n    return this.common.loading;\r\n  }\r\n\r\n  // -----------------\r\n  // ### Mutations ###\r\n  // -----------------\r\n\r\n  @Mutation public commitSetParameterQualityDataAverages(payload: Data) {\r\n    this.data = payload;\r\n  }\r\n\r\n  @Mutation public commitClearParameterQualityDataAverages() {\r\n    this.data = null;\r\n  }\r\n\r\n  // From common:\r\n  @Mutation private commitSetLoadedDate() {\r\n    this.common.setLoadedDate();\r\n  }\r\n  @Mutation private commitClearLoadedDate() {\r\n    this.common.clearLoadedDate();\r\n  }\r\n  @Mutation private commitSetLoadingError(payload: { error: any }) {\r\n    this.common.setLoadingError(payload);\r\n  }\r\n  @Mutation private commitSetLoading() {\r\n    this.common.setLoading();\r\n  }\r\n  @Mutation private commitClearLoading() {\r\n    this.common.clearLoading();\r\n  }\r\n  @Mutation private commitSetLoadingPromise(payload: {\r\n    loadingPromise: Promise<void>;\r\n    loadingPromiseForId: any;\r\n  }) {\r\n    this.common.setLoadingPromise(payload);\r\n  }\r\n\r\n  // ---------------\r\n  // ### Actions ###\r\n  // ---------------\r\n\r\n  @Action\r\n  public async dispatchLoad(payload: {\r\n    fromDate: Date;\r\n    toDate: Date;\r\n  }): Promise<void> {\r\n    const loadingId = `${payload.fromDate.toString()}|${payload.toDate.toString()}`;\r\n\r\n    if (\r\n      this.data !== null &&\r\n      this.loading.loadingPromiseForId === loadingId &&\r\n      !this.common.needToReLoad()\r\n    ) {\r\n      return Promise.resolve();\r\n    }\r\n\r\n    if (this.common.isCurrentlyLoading(loadingId)) {\r\n      return this.common.loading.loadingPromise;\r\n    }\r\n\r\n    this.commitSetLoading();\r\n    this.commitClearParameterQualityDataAverages();\r\n\r\n    const loadingPromise = qualityDataService\r\n      .getAverages(payload.fromDate, payload.toDate)\r\n      .then((response) => {\r\n        const data: Data = {\r\n          fromDate: payload.fromDate,\r\n          toDate: payload.toDate,\r\n          results: response,\r\n        };\r\n\r\n        this.commitSetParameterQualityDataAverages(data);\r\n        this.commitSetLoadedDate();\r\n        this.commitClearLoading();\r\n      })\r\n      .catch((error) => {\r\n        this.commitSetLoadingError({ error });\r\n\r\n        return Promise.reject(error);\r\n      });\r\n\r\n    this.commitSetLoadingPromise({\r\n      loadingPromise,\r\n      loadingPromiseForId: loadingId,\r\n    });\r\n\r\n    return loadingPromise;\r\n  }\r\n}\r\n\r\nexport const parameterQualityDataAveragesModule = getModule(\r\n  ParameterQualityDataAveragesModule\r\n);\r\n","\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\r\nimport { Component, Vue, Prop } from 'vue-property-decorator';\r\nimport {\r\n  DashStyleValue,\r\n  Options,\r\n  PointOptionsObject,\r\n  SeriesOptionsType,\r\n} from 'highcharts';\r\nimport { Chart } from 'highcharts-vue';\r\nimport { Config } from '@/utils/Config';\r\nimport { parameterQualityDataAveragesModule } from '@/store/modules/parameterQualityDataAverages';\r\nimport { Helpers } from '@/utils/Helpers';\r\nimport router from '@/router';\r\nimport { routeNameQDataDelivery } from '@/router/routes';\r\nimport { copyQDataPageQueryFromRoute } from '@/utils/RoutingForQData';\r\nimport { numberFilter } from '@/filters/number';\r\nimport {\r\n  ParameterAverage,\r\n  ProductAverage,\r\n  ParameterValue,\r\n} from '@/models/QualityData/AverageQualityDataByDates';\r\nimport { GeneralParameter } from '@/models/QualityData/GeneralParameter';\r\n\r\nconst linkColor = '#007a93';\r\n\r\nfunction deliveryLink(deliveryMessageNumber: string): string {\r\n  return router.resolve({\r\n    name: routeNameQDataDelivery,\r\n    query: copyQDataPageQueryFromRoute(router.currentRoute),\r\n    params: {\r\n      deliveryMessageNumber,\r\n    },\r\n  }).href;\r\n}\r\n\r\ninterface QDataPointOptionsObjects extends PointOptionsObject {\r\n  deliveryMessageNumbers?: string[];\r\n  unitOfMeasurement?: string;\r\n  numberOfDecimals?: number;\r\n}\r\n\r\n@Component({\r\n  components: {\r\n    highcharts: Chart,\r\n  },\r\n})\r\nexport default class QDataChart extends Vue {\r\n  @Prop({ required: true })\r\n  private selectedParameter!: GeneralParameter | null;\r\n  @Prop({ required: true })\r\n  private selectedProductNames!: string[];\r\n  @Prop({ required: false, default: () => false }) private loading!: boolean;\r\n  @Prop({ required: false, default: () => false }) private error!: boolean;\r\n\r\n  private get averagesDates(): { from: Date; to: Date } | null {\r\n    return parameterQualityDataAveragesModule.data !== null\r\n      ? {\r\n          from: parameterQualityDataAveragesModule.data.fromDate,\r\n          to: parameterQualityDataAveragesModule.data.toDate,\r\n        }\r\n      : null;\r\n  }\r\n\r\n  private get parameterResults(): ParameterAverage | null {\r\n    return parameterQualityDataAveragesModule.data !== null &&\r\n      this.selectedParameter !== null\r\n      ? parameterQualityDataAveragesModule.data.results.averageValues.find(\r\n          (r) => r.parameter.id === this.selectedParameter?.id\r\n        ) ?? null\r\n      : null;\r\n  }\r\n\r\n  private get unitOfMeasurement(): string | undefined {\r\n    return this.parameterResults?.parameterUnitOfMeasurement;\r\n  }\r\n\r\n  private get numberOfDecimals(): number | undefined {\r\n    return this.parameterResults?.parameterNumberOfDecimals;\r\n  }\r\n\r\n  private get averages(): ProductAverage[] {\r\n    if (this.parameterResults === null) {\r\n      return [];\r\n    }\r\n\r\n    return this.parameterResults.averageValues.filter(\r\n      (productAverages) =>\r\n        this.selectedProductNames.length === 0 ||\r\n        this.selectedProductNames.some(\r\n          (productName) => productName === productAverages.productName\r\n        )\r\n    );\r\n  }\r\n\r\n  private get allAverageValues(): number[] {\r\n    return this.averages\r\n      .flatMap((a) => a.averageValues)\r\n      .filter((a) => a.parameterValueAvg !== undefined)\r\n      .map((a) => a.parameterValueAvg as number);\r\n  }\r\n\r\n  private get chartMin(): number | undefined {\r\n    if (this.allAverageValues.length === 0) {\r\n      return undefined;\r\n    }\r\n    if (this.parameterMinimumMinValue) {\r\n      return Math.min(this.parameterMinimumMinValue, ...this.allAverageValues);\r\n    } else {\r\n      return Math.min(...this.allAverageValues);\r\n    }\r\n  }\r\n\r\n  private get chartMax(): number | undefined {\r\n    if (this.allAverageValues.length === 0) {\r\n      return undefined;\r\n    }\r\n    if (this.parameterMaximumMaxValue) {\r\n      return Math.max(this.parameterMaximumMaxValue, ...this.allAverageValues);\r\n    } else {\r\n      return Math.max(...this.allAverageValues);\r\n    }\r\n  }\r\n\r\n  private get parameterMinimumMinValue(): number | null {\r\n    const values: ProductAverage[] = this.averages.filter(\r\n      (a) => a.parameterMinValues.length > 0\r\n    );\r\n    let allMinimumValues: number[] = [];\r\n    for (let v of values) {\r\n      for (let t of v.parameterMinValues) {\r\n        allMinimumValues.push(t.value);\r\n      }\r\n    }\r\n    if (allMinimumValues.length === 0) {\r\n      return null;\r\n    }\r\n    return Math.min(...allMinimumValues);\r\n  }\r\n\r\n  private get parameterMaximumMaxValue(): number | null {\r\n    const values: ProductAverage[] = this.averages.filter(\r\n      (a) => a.parameterMaxValues.length > 0\r\n    );\r\n    let allMaximumValues: number[] = [];\r\n    for (let v of values) {\r\n      for (let t of v.parameterMinValues) {\r\n        allMaximumValues.push(t.value);\r\n      }\r\n    }\r\n    if (allMaximumValues.length === 0) {\r\n      return null;\r\n    }\r\n    return Math.max(...allMaximumValues);\r\n  }\r\n\r\n  private get chartSeries(): SeriesOptionsType[] {\r\n    const series: SeriesOptionsType[] = [];\r\n\r\n    for (const productAverages of this.averages) {\r\n      const data: QDataPointOptionsObjects[] =\r\n        productAverages.averageValues.map((average) => {\r\n          return {\r\n            x: new Date(average.date).getTime(),\r\n            y: average.parameterValueAvg,\r\n            deliveryMessageNumbers: average.deliveryMessageNumbers,\r\n            unitOfMeasurement: this.unitOfMeasurement,\r\n            numberOfDecimals: this.numberOfDecimals,\r\n          };\r\n        });\r\n\r\n      series.push({\r\n        id: productAverages.productName + '|',\r\n        name: productAverages.productDisplayName,\r\n        type: 'spline',\r\n        dashStyle: 'Solid',\r\n        data,\r\n        color: Config.getProductColor(productAverages.productColorCategory),\r\n        events: {\r\n          legendItemClick: function () {\r\n            const referenceLines = this.chart.series.filter(\r\n              (s) =>\r\n                s.options.id &&\r\n                s.options.id !== this.options.id &&\r\n                s.options.id.indexOf(this.options.id ?? '') === 0\r\n            );\r\n            for (const referenceLine of referenceLines) {\r\n              if (this.visible) {\r\n                referenceLine.hide();\r\n              } else {\r\n                referenceLine.show();\r\n              }\r\n            }\r\n          },\r\n        },\r\n      });\r\n\r\n      if (productAverages.totalAverageValue && this.averagesDates !== null) {\r\n        series.push(this.getReferenceSeriesLine(productAverages, 'average'));\r\n      }\r\n\r\n      if (\r\n        productAverages.parameterMaxValues.length > 0 &&\r\n        this.averagesDates !== null\r\n      ) {\r\n        series.push(this.getReferenceSeriesLine(productAverages, 'upper'));\r\n      }\r\n      if (\r\n        productAverages.parameterMinValues.length > 0 &&\r\n        this.averagesDates !== null\r\n      ) {\r\n        series.push(this.getReferenceSeriesLine(productAverages, 'lower'));\r\n      }\r\n      if (\r\n        productAverages.parameterValues.length > 0 &&\r\n        this.averagesDates !== null\r\n      ) {\r\n        series.push(this.getReferenceSeriesLine(productAverages, 'typical'));\r\n      }\r\n    }\r\n\r\n    return series;\r\n  }\r\n\r\n  private get chartOptions(): Options {\r\n    return {\r\n      title: {\r\n        text: '',\r\n      },\r\n      xAxis: {\r\n        type: 'datetime',\r\n        title: {\r\n          text: null,\r\n        },\r\n        labels: {\r\n          style: {\r\n            fontSize: '12px',\r\n          },\r\n        },\r\n      },\r\n      yAxis: {\r\n        title: {\r\n          text: this.unitOfMeasurement,\r\n          align: 'high',\r\n          textAlign: 'left',\r\n          reserveSpace: false,\r\n          rotation: 0,\r\n          y: -15,\r\n          x: 2,\r\n        },\r\n        labels: {\r\n          style: {\r\n            fontSize: '12px',\r\n          },\r\n        },\r\n        minPadding: this.parameterMinimumMinValue ? 0.05 : 0.25,\r\n        maxPadding: this.parameterMaximumMaxValue ? 0.05 : 0.25,\r\n        grid: {\r\n          enabled: false,\r\n        },\r\n        gridLineColor: '#ddd',\r\n        softMin: this.chartMin,\r\n        softMax: this.chartMax,\r\n      },\r\n      series: this.chartSeries,\r\n      chart: {\r\n        height: 230,\r\n        backgroundColor: 'transparent',\r\n        zoomType: 'x',\r\n        marginTop: this.unitOfMeasurement !== null ? 25 : undefined,\r\n        spacing: [0, 0, 0, 0],\r\n      },\r\n      plotOptions: {\r\n        series: {\r\n          lineWidth: 3,\r\n        },\r\n        spline: {\r\n          marker: {\r\n            enabled: undefined,\r\n            lineColor: undefined,\r\n            lineWidth: 2,\r\n            fillColor: '#fff',\r\n            radius: 5,\r\n            symbol: 'circle',\r\n          },\r\n        },\r\n        line: {\r\n          marker: {\r\n            enabled: false,\r\n            lineColor: undefined,\r\n            lineWidth: 1,\r\n            radius: 1,\r\n            symbol: 'circle',\r\n          },\r\n        },\r\n      },\r\n      tooltip: {\r\n        pointFormatter: function () {\r\n          const qdataPoint: QDataPointOptionsObjects =\r\n            this as unknown as QDataPointOptionsObjects;\r\n          let html = `<span style=\"color:${this.color}\">&#9679;</span> ${\r\n            this.series.name\r\n          }: <b>${numberFilter(this.y, qdataPoint?.numberOfDecimals)} ${\r\n            qdataPoint?.unitOfMeasurement\r\n          }</b><br>`;\r\n          if (\r\n            qdataPoint &&\r\n            qdataPoint.deliveryMessageNumbers &&\r\n            qdataPoint.deliveryMessageNumbers.length\r\n          ) {\r\n            html += '<span style=\"padding-top: 6px; opacity: 0;\">-</span><br>';\r\n            for (const deliveryMessageNumber of qdataPoint.deliveryMessageNumbers) {\r\n              html += `<a href=\"${deliveryLink(\r\n                deliveryMessageNumber\r\n              )}\" style=\"color: ${linkColor}\">Delivery ${deliveryMessageNumber}</a><br>`;\r\n            }\r\n          }\r\n          return html;\r\n        },\r\n        outside: true,\r\n        hideDelay: 2000,\r\n        stickOnContact: true,\r\n      },\r\n      credits: {\r\n        enabled: false,\r\n      },\r\n      time: {\r\n        useUTC: false,\r\n      },\r\n    };\r\n  }\r\n\r\n  private getFromDate(fromDate?: string): string {\r\n    return fromDate === undefined ||\r\n      this.$moment(fromDate).isBefore(this.averagesDates!.from)\r\n      ? this.averagesDates!.from.toString()\r\n      : fromDate;\r\n  }\r\n\r\n  private getToDate(toDate?: string): string {\r\n    return toDate === undefined ||\r\n      this.$moment(toDate).isBefore(this.averagesDates!.to)\r\n      ? this.averagesDates!.to.toString()\r\n      : toDate;\r\n  }\r\n\r\n  private getReferenceSeriesLine(\r\n    productAverages: ProductAverage,\r\n    lineType: 'upper' | 'lower' | 'typical' | 'average'\r\n  ): SeriesOptionsType {\r\n    if (this.averagesDates === null) {\r\n      // Should never happen if null-check is done before this\r\n      return { type: 'line' };\r\n    }\r\n\r\n    const isTypical = lineType === 'typical';\r\n    let dashStyle: DashStyleValue = 'Dash';\r\n    const lineWidth = isTypical ? 1 : 2;\r\n\r\n    const color = Helpers.HexToRGB(\r\n      Config.getProductColor(productAverages.productColorCategory),\r\n      isTypical ? 1 : 0.7\r\n    );\r\n\r\n    const name = this.$t(`qDataChart.referenceLines.${lineType}`, [\r\n      productAverages.productDisplayName,\r\n    ]).toString();\r\n\r\n    let parameterValues: ParameterValue[] = [];\r\n    switch (lineType) {\r\n      case 'upper':\r\n        productAverages.parameterMaxValues.forEach((value) => {\r\n          parameterValues.push({\r\n            value: value.value,\r\n            fromDate: this.getFromDate(value.fromDate),\r\n            toDate: this.getToDate(value.toDate),\r\n          });\r\n        });\r\n        break;\r\n      case 'lower':\r\n        productAverages.parameterMinValues.forEach((value) => {\r\n          parameterValues.push({\r\n            value: value.value,\r\n            fromDate: this.getFromDate(value.fromDate),\r\n            toDate: this.getToDate(value.toDate),\r\n          });\r\n        });\r\n        break;\r\n      case 'typical':\r\n        productAverages.parameterValues.forEach((value) => {\r\n          parameterValues.push({\r\n            value: value.value,\r\n            fromDate: this.getFromDate(value.fromDate),\r\n            toDate: this.getToDate(value.toDate),\r\n          });\r\n        });\r\n        dashStyle = 'Dot';\r\n        break;\r\n      case 'average':\r\n        parameterValues.push({\r\n          value: productAverages.totalAverageValue ?? 0,\r\n          fromDate: this.averagesDates.from.toString(),\r\n          toDate: this.averagesDates.to.toString(),\r\n        });\r\n        dashStyle = 'LongDash';\r\n        break;\r\n    }\r\n\r\n    let data: QDataPointOptionsObjects[] = [];\r\n\r\n    parameterValues.forEach((value) => {\r\n      data.push({\r\n        x: value.fromDate\r\n          ? new Date(value.fromDate).getTime()\r\n          : this.averagesDates!.from.getTime(),\r\n        y: value.value,\r\n        unitOfMeasurement: this.unitOfMeasurement,\r\n        numberOfDecimals: this.numberOfDecimals,\r\n      });\r\n      data.push({\r\n        x: value.toDate\r\n          ? new Date(value.toDate).getTime()\r\n          : this.averagesDates!.to.getTime(),\r\n        y: value.value,\r\n        unitOfMeasurement: this.unitOfMeasurement,\r\n        numberOfDecimals: this.numberOfDecimals,\r\n      });\r\n    });\r\n\r\n    return {\r\n      id: productAverages.productName + '|' + lineType,\r\n      name,\r\n      type: 'line',\r\n      dashStyle,\r\n      lineWidth,\r\n      data,\r\n      color,\r\n      showInLegend: false,\r\n    };\r\n  }\r\n}\r\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataChart.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataChart.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./QDataChart.vue?vue&type=template&id=1e13ded4&scoped=true&\"\nimport script from \"./QDataChart.vue?vue&type=script&lang=ts&\"\nexport * from \"./QDataChart.vue?vue&type=script&lang=ts&\"\nimport style0 from \"./QDataChart.vue?vue&type=style&index=0&id=1e13ded4&scoped=true&lang=scss&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  \"1e13ded4\",\n  null\n  \n)\n\nexport default component.exports","\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\r\nimport { Component, Vue, Watch } from 'vue-property-decorator';\r\nimport DefaultLayout from '@/layouts/DefaultLayout.vue';\r\nimport Breadcrumbs from '@/components/general/Breadcrumbs.vue';\r\nimport QDataDeliveryMessagesFilter from '@/components/QDataDeliveryMessagesFilter.vue';\r\nimport QDataSearchBox from '@/components/QDataSearchBox.vue';\r\nimport Messages from '@/components/general/Messages.vue';\r\nimport QDataDeliveryList from '@/components/QDataDeliveryList.vue';\r\nimport QDataChart from '@/components/QDataChart.vue';\r\nimport Pagination, {\r\n  PaginationRoutes,\r\n} from '@/components/general/Pagination.vue';\r\nimport {\r\n  ByDatesSearch,\r\n  deliveryMessagesModule,\r\n  QueryType,\r\n} from '@/store/modules/deliveryMessages';\r\nimport { parameterQualityDataAveragesModule } from '@/store/modules/parameterQualityDataAverages';\r\nimport { DeliveryMessage } from '@/models/QualityData/DeliveryMessage';\r\nimport { routeNameQDataDelivery, routeNameQData } from '@/router/routes';\r\nimport { Dates } from '@/utils/Dates';\r\nimport {\r\n  compareQDataPageQuery,\r\n  copyQDataPageQueryFromRoute,\r\n  defaultPageSize,\r\n  generateQDataPageQuery,\r\n  getQDataPageQueryData,\r\n  getQDataPageQueryText,\r\n} from '@/utils/RoutingForQData';\r\nimport { ParameterPsolId } from '@/models/PsolParameterId';\r\nimport { DeliveryMessageProduct } from '@/models/QualityData/DeliveryMessageProduct';\r\nimport { DateRange } from '@/models/DateRange';\r\nimport { Breadcrumb } from '@/models/Breadcrumb';\r\nimport telemetryService, {\r\n  RouteTrackingInfo,\r\n} from '@/services/TelemetryService';\r\nimport {\r\n  createParamsWithProgrammaticRouting,\r\n  getRouteTrackingInfo,\r\n  hasProgrammaticRoutingParam,\r\n} from '@/router/functions';\r\nimport { GeneralParameter } from '@/models/QualityData/GeneralParameter';\r\nimport Panelista from '@/components/general/Panelista.vue';\r\nimport TextBox from '@/components/general/TextBox.vue';\r\n\r\n@Component({\r\n  components: {\r\n    DefaultLayout,\r\n    Breadcrumbs,\r\n    Messages,\r\n    QDataDeliveryMessagesFilter,\r\n    QDataSearchBox,\r\n    QDataDeliveryList,\r\n    QDataChart,\r\n    Pagination,\r\n    Panelista,\r\n    TextBox,\r\n  },\r\n})\r\nexport default class QDataPage extends Vue {\r\n  private routeTrackingInfo: RouteTrackingInfo = {};\r\n\r\n  private downloadingExcel: boolean = false;\r\n  private loadingDeliveries: boolean = false;\r\n  private loadingAverages: boolean = false;\r\n  private errorDeliveries: boolean = false;\r\n  private errorAverages: boolean = false;\r\n  private aSearchHasBeenDone: boolean = false;\r\n\r\n  private deliveryMessagesRange: DateRange | null = null;\r\n  private selectedProductNames: string[] = [];\r\n  private selectedParameter: GeneralParameter | null = null;\r\n  private pageIndex: number = 0;\r\n  private pageSize: number = defaultPageSize;\r\n\r\n  private get deliveryMessages(): DeliveryMessage[] {\r\n    return deliveryMessagesModule.search?.results?.items ?? [];\r\n  }\r\n\r\n  private get deliveryMessagesCount(): number {\r\n    return deliveryMessagesModule.search?.results?.totalCount ?? 0;\r\n  }\r\n\r\n  private get hasUnitsFromBeforeAndAfterBreakpoint(): boolean {\r\n    return (\r\n      deliveryMessagesModule.search?.hasUnitsFromBeforeAndAfterBreakpoint ??\r\n      false\r\n    );\r\n  }\r\n\r\n  private get pageCount(): number {\r\n    return deliveryMessagesModule.search?.results?.pageCount ?? 0;\r\n  }\r\n  private get totalCount(): number {\r\n    return deliveryMessagesModule.search?.results?.totalCount ?? 0;\r\n  }\r\n  private get products(): DeliveryMessageProduct[] {\r\n    return parameterQualityDataAveragesModule.data?.results.products ?? [];\r\n  }\r\n\r\n  private get parametersWithAverages(): GeneralParameter[] {\r\n    return parameterQualityDataAveragesModule.data !== null\r\n      ? parameterQualityDataAveragesModule.data?.results.averageValues.map(\r\n          (average) => average.parameter\r\n        )\r\n      : [];\r\n  }\r\n\r\n  private get paginationRoutes(): PaginationRoutes {\r\n    return {\r\n      previousPageRoute: {\r\n        name: routeNameQData,\r\n        query: this.generateQuery(this.pageIndex - 1),\r\n      },\r\n      nextPageRoute: {\r\n        name: routeNameQData,\r\n        query: this.generateQuery(this.pageIndex + 1),\r\n      },\r\n      numberPageRoute: (page: number) => {\r\n        return {\r\n          name: routeNameQData,\r\n          query: this.generateQuery(page - 1),\r\n        };\r\n      },\r\n      firstPageRoute: {\r\n        name: routeNameQData,\r\n        query: this.generateQuery(0),\r\n      },\r\n      lastPageRoute: {\r\n        name: routeNameQData,\r\n        query: this.generateQuery(this.pageCount - 1),\r\n      },\r\n    };\r\n  }\r\n\r\n  private get breadcrumbs(): Breadcrumb[] {\r\n    // Q-data -> [dates]\r\n    const query = copyQDataPageQueryFromRoute(this.$route);\r\n    const items: Breadcrumb[] = [\r\n      {\r\n        routeName: routeNameQData,\r\n        name: this.$t('breadcrumbs.' + routeNameQData).toString(),\r\n      },\r\n    ];\r\n    // Only add dates if any in query\r\n    const queryText = getQDataPageQueryText(this.$route);\r\n    if (queryText !== '') {\r\n      items.push({\r\n        routeName: routeNameQData,\r\n        routeQuery: query,\r\n        name: queryText,\r\n      });\r\n    }\r\n    return items;\r\n  }\r\n\r\n  @Watch('$route', { immediate: false, deep: true })\r\n  private onRouteChange(): void {\r\n    this.routeTrackingInfo = getRouteTrackingInfo(this.$route);\r\n    this.initializeDeliveryMessagesParameters();\r\n    this.loadData().finally(() => {\r\n      if (!hasProgrammaticRoutingParam(this.$route)) {\r\n        telemetryService.stopTrackPage(this.routeTrackingInfo);\r\n      }\r\n\r\n      this.initializeSelectedParameter();\r\n    });\r\n  }\r\n\r\n  private initializeSelectedParameter(): void {\r\n    const data = getQDataPageQueryData(this.$route);\r\n\r\n    let findParameter = (\r\n      psolParameterId?: ParameterPsolId\r\n    ): GeneralParameter | undefined => {\r\n      return this.parametersWithAverages.find(\r\n        (parameter) => parameter.psolParameterId == psolParameterId\r\n      );\r\n    };\r\n\r\n    let parameter =\r\n      findParameter(data?.parameter) ?? this.parametersWithAverages[0];\r\n\r\n    if (!parameter) {\r\n      return;\r\n    }\r\n\r\n    this.selectedParameter = parameter;\r\n  }\r\n\r\n  private created(): void {\r\n    this.routeTrackingInfo = getRouteTrackingInfo(this.$route);\r\n    this.initializeDeliveryMessagesParameters();\r\n    this.loadData().finally(() => {\r\n      telemetryService.stopTrackPage(this.routeTrackingInfo);\r\n\r\n      this.initializeSelectedParameter();\r\n    });\r\n  }\r\n\r\n  private onPageSizeChanged(newPageSize: number): void {\r\n    this.pageSize = newPageSize;\r\n    this.pageIndex = 0;\r\n    this.updateQuery();\r\n  }\r\n\r\n  private initializeDeliveryMessagesParameters(): void {\r\n    const queryData = getQDataPageQueryData(this.$route);\r\n\r\n    // If having valid dates from query...\r\n    if (queryData !== null && queryData.from && queryData.to) {\r\n      this.deliveryMessagesRange = {\r\n        fromDate: queryData.from,\r\n        toDate: queryData.to,\r\n      };\r\n    } else {\r\n      // ... otherwise use some default values\r\n      this.deliveryMessagesRange = {\r\n        fromDate: Dates.getDateANumbersOfMonthsInThePast(1),\r\n        toDate: Dates.startOfToday(),\r\n      };\r\n    }\r\n\r\n    if (queryData !== null && queryData.productNames) {\r\n      this.selectedProductNames = queryData.productNames;\r\n    } else {\r\n      this.selectedProductNames = [];\r\n    }\r\n\r\n    this.pageIndex = queryData !== null ? queryData.pageIndex : 0;\r\n    this.pageSize = queryData !== null ? queryData.pageSize : defaultPageSize;\r\n  }\r\n\r\n  // Updates the query (if any changes) which then changes the $route and the @Watch is triggered\r\n  private updateQuery(onlyReplaceExistingRoute: boolean = false): boolean {\r\n    const query = this.generateQuery();\r\n\r\n    if (!compareQDataPageQuery(this.$route, query)) {\r\n      if (onlyReplaceExistingRoute) {\r\n        this.$router.replace({\r\n          query,\r\n          params: createParamsWithProgrammaticRouting(),\r\n        });\r\n      } else {\r\n        this.$router.push({ query });\r\n      }\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  private generateQuery(newPageIndex?: number): any {\r\n    return generateQDataPageQuery({\r\n      by: QueryType.ByDates,\r\n      from: this.deliveryMessagesRange?.fromDate ?? undefined,\r\n      to: this.deliveryMessagesRange?.toDate ?? undefined,\r\n      parameter: this.selectedParameter?.psolParameterId ?? undefined,\r\n      productNames:\r\n        this.selectedProductNames.length > 0\r\n          ? this.selectedProductNames\r\n          : undefined,\r\n      pageIndex: newPageIndex !== undefined ? newPageIndex : this.pageIndex,\r\n      pageSize: this.pageSize,\r\n    });\r\n  }\r\n\r\n  private onDeliveryMessagesFilter(range: DateRange): void {\r\n    this.deliveryMessagesRange = range;\r\n    this.pageIndex = 0;\r\n\r\n    if (!this.updateQuery()) {\r\n      this.loadData();\r\n    }\r\n  }\r\n\r\n  private onDownloadExcel(downloading: boolean): void {\r\n    this.downloadingExcel = downloading;\r\n  }\r\n\r\n  private onProductsChange(val: string[]): void {\r\n    this.selectedProductNames = val;\r\n    this.pageIndex = 0;\r\n\r\n    if (!this.updateQuery()) {\r\n      this.loadData();\r\n    }\r\n  }\r\n\r\n  private onParameterChange(val: GeneralParameter): void {\r\n    this.selectedParameter = val;\r\n    this.updateQuery(true);\r\n  }\r\n\r\n  private onQDataDeliveryListClick(deliveryMessage: DeliveryMessage): void {\r\n    const query = this.generateQuery();\r\n    this.$router.push({\r\n      name: routeNameQDataDelivery,\r\n      params: { deliveryMessageNumber: deliveryMessage.number },\r\n      query,\r\n    });\r\n  }\r\n\r\n  private loadData(): Promise<void> {\r\n    return Promise.all([\r\n      this.loadDeliveriesByDates(),\r\n      this.loadParameterAveragesByDates(),\r\n    ]).then(() => undefined);\r\n  }\r\n\r\n  private loadDeliveriesByDates(): Promise<void> {\r\n    if (this.deliveryMessagesRange === null) {\r\n      return Promise.reject('No delivery message range!');\r\n    }\r\n\r\n    this.loadingDeliveries = true;\r\n    this.errorDeliveries = false;\r\n\r\n    const searchParameters = new ByDatesSearch();\r\n    searchParameters.from = this.deliveryMessagesRange.fromDate;\r\n    searchParameters.to = this.deliveryMessagesRange.toDate;\r\n    searchParameters.productNames = this.selectedProductNames;\r\n    searchParameters.pageIndex = this.pageIndex;\r\n    searchParameters.pageSize = this.pageSize;\r\n\r\n    return deliveryMessagesModule\r\n      .dispatchLoad(searchParameters)\r\n      .then(() => {\r\n        this.aSearchHasBeenDone = true;\r\n      })\r\n      .catch(() => {\r\n        this.errorDeliveries = true;\r\n      })\r\n      .finally(() => {\r\n        this.loadingDeliveries = false;\r\n      });\r\n  }\r\n\r\n  private loadParameterAveragesByDates(): Promise<void> {\r\n    if (this.deliveryMessagesRange === null) {\r\n      return Promise.reject('No delivery message range!');\r\n    }\r\n\r\n    this.loadingAverages = true;\r\n    this.errorAverages = false;\r\n\r\n    return parameterQualityDataAveragesModule\r\n      .dispatchLoad({\r\n        fromDate: this.deliveryMessagesRange.fromDate,\r\n        toDate: this.deliveryMessagesRange.toDate,\r\n      })\r\n      .catch(() => {\r\n        this.errorAverages = true;\r\n      })\r\n      .finally(() => {\r\n        this.loadingAverages = false;\r\n      });\r\n  }\r\n}\r\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataPage.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataPage.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./QDataPage.vue?vue&type=template&id=12a9f070&\"\nimport script from \"./QDataPage.vue?vue&type=script&lang=ts&\"\nexport * from \"./QDataPage.vue?vue&type=script&lang=ts&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--9-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--9-oneOf-1-1!../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--9-oneOf-1-2!../../node_modules/sass-loader/dist/cjs.js??ref--9-oneOf-1-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataChart.vue?vue&type=style&index=0&id=1e13ded4&scoped=true&lang=scss&\"","export enum SuggestionType {\r\n  DeliveryMessage = 'DeliveryMessage',\r\n  DeliveryMessageCustomerReference = 'DeliveryMessageCustomerReference',\r\n  DeliveryMessageOrder = 'DeliveryMessageOrder',\r\n  Invoice = 'Invoice',\r\n  Unit = 'Unit',\r\n}\r\n","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('DefaultLayout',[_c('Breadcrumbs',{attrs:{\"items\":_vm.breadcrumbs}}),_c('Messages'),_c('div',{staticClass:\"container-fluid mt-3\"},[_c('div',{staticClass:\"d-flex flex-row justify-content-between flex-wrap align-items-center\"},[_c('h1',{staticClass:\"t-heading-3 pr-2\"},[_vm._v(_vm._s(_vm.$t('qDataSearchPage.title')))]),_c('div',{staticClass:\"d-align-self-end\"},[_c('QDataSearchBox',{attrs:{\"value\":_vm.searchTerm}})],1)]),_c('span',{staticClass:\"o-line\"}),(_vm.error)?_c('div',{staticClass:\"c-alert c-alert--red mb-2\"},[_c('span',{staticClass:\"c-alert__text\"},[_vm._v(_vm._s(_vm.$t('qDataSearchPage.error')))])]):_vm._e(),_c('div',{staticClass:\"row\"},[_c('div',{staticClass:\"col-12 mb-3\"},[(_vm.loading)?_c('div',{staticClass:\"u-position-relative u-min-height-300\"},[_c('span',{staticClass:\"o-loader o-loader--absolute\"})]):_vm._e(),(_vm.aSearchHasBeenDone && !_vm.error)?[(_vm.deliveryMessages.length)?[_c('h3',{staticClass:\"t-heading-5 mb-3\",domProps:{\"innerHTML\":_vm._s(_vm.subtitle)}}),_c('QDataDeliveryList',{staticClass:\"mb-3\",attrs:{\"deliveryMessages\":_vm.deliveryMessages,\"totalNumberOfDeliveries\":_vm.deliveryMessagesCount,\"searchTerm\":_vm.searchTerm},on:{\"click\":_vm.onQDataDeliveryListClick}}),_c('Pagination',{attrs:{\"pageIndex\":_vm.pageIndex,\"pageCount\":_vm.pageCount,\"pageSize\":_vm.pageSize,\"routes\":_vm.paginationRoutes},on:{\"pageSizeChanged\":_vm.onPageSizeChanged}})]:_c('div',{staticClass:\"mt-2\",domProps:{\"innerHTML\":_vm._s(_vm.noDataText)}})]:_vm._e()],2)])])],1)}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\r\nimport { Component, Vue, Watch } from 'vue-property-decorator';\r\nimport DefaultLayout from '@/layouts/DefaultLayout.vue';\r\nimport Breadcrumbs from '@/components/general/Breadcrumbs.vue';\r\nimport Messages from '@/components/general/Messages.vue';\r\nimport QDataDeliveryList from '@/components/QDataDeliveryList.vue';\r\nimport QDataSearchBox from '@/components/QDataSearchBox.vue';\r\nimport Pagination, {\r\n  PaginationRoutes,\r\n} from '@/components/general/Pagination.vue';\r\nimport {\r\n  compareQDataPageQuery,\r\n  copyQDataPageQueryFromRoute,\r\n  defaultPageSize,\r\n  generateQDataPageQuery,\r\n  getQDataPageQueryData,\r\n  getQDataPageQueryText,\r\n} from '@/utils/RoutingForQData';\r\nimport { DeliveryMessage } from '@/models/QualityData/DeliveryMessage';\r\nimport {\r\n  ByTermSearch,\r\n  deliveryMessagesModule,\r\n  QueryType,\r\n} from '@/store/modules/deliveryMessages';\r\nimport {\r\n  routeNameQData,\r\n  routeNameQDataSearch,\r\n  routeNameQDataDelivery,\r\n} from '@/router/routes';\r\nimport { Breadcrumb } from '@/models/Breadcrumb';\r\nimport telemetryService, {\r\n  RouteTrackingInfo,\r\n} from '@/services/TelemetryService';\r\nimport { getRouteTrackingInfo } from '@/router/functions';\r\n\r\n@Component({\r\n  components: {\r\n    DefaultLayout,\r\n    Breadcrumbs,\r\n    Messages,\r\n    QDataDeliveryList,\r\n    Pagination,\r\n    QDataSearchBox,\r\n  },\r\n})\r\nexport default class QDataSearchPage extends Vue {\r\n  private routeTrackingInfo: RouteTrackingInfo = {};\r\n  private loading: boolean = false;\r\n  private error: boolean = false;\r\n  private aSearchHasBeenDone: boolean = false;\r\n\r\n  private pageIndex: number = 0;\r\n  private pageSize: number = defaultPageSize;\r\n\r\n  private term: string | null = null;\r\n  private type: string | null = null;\r\n\r\n  private get deliveryMessages(): DeliveryMessage[] {\r\n    return deliveryMessagesModule.search?.results?.items ?? [];\r\n  }\r\n\r\n  private get deliveryMessagesCount(): number {\r\n    return deliveryMessagesModule.search?.results?.totalCount ?? 0;\r\n  }\r\n\r\n  private get searchTerm(): string {\r\n    return this.$route.query.term?.toString() ?? '';\r\n  }\r\n\r\n  private get summary(): string {\r\n    if (this.type) {\r\n      return this.$t('qDataSearchPage.summaryWithType', [\r\n        this.term,\r\n        this.$t(`suggestionType.${this.type}`).toString(),\r\n        this.totalCount,\r\n      ]).toString();\r\n    }\r\n\r\n    return this.$t('qDataSearchPage.summaryWithoutType', [\r\n      this.term,\r\n      this.totalCount,\r\n    ]).toString();\r\n  }\r\n\r\n  private get subtitle(): string {\r\n    if (this.loading || !this.aSearchHasBeenDone) {\r\n      return '';\r\n    }\r\n\r\n    return this.type\r\n      ? this.$t('qDataSearchPage.subtitle.withType', [\r\n          this.term,\r\n          this.totalCount,\r\n          this.$t(`suggestionType.${this.type}`).toString(),\r\n        ]).toString()\r\n      : this.$t('qDataSearchPage.subtitle.noType', [\r\n          this.term,\r\n          this.totalCount,\r\n        ]).toString();\r\n  }\r\n\r\n  private get noDataText(): string {\r\n    if (this.loading || !this.aSearchHasBeenDone) {\r\n      return '';\r\n    }\r\n\r\n    return this.type\r\n      ? this.$t('qDataSearchPage.noData.withType', [\r\n          this.term,\r\n          this.$t(`suggestionType.${this.type}`).toString(),\r\n        ]).toString()\r\n      : this.$t('qDataSearchPage.noData.noType', [this.term]).toString();\r\n  }\r\n\r\n  private get pageCount(): number {\r\n    return deliveryMessagesModule.search?.results?.pageCount ?? 0;\r\n  }\r\n\r\n  private get totalCount(): number {\r\n    return deliveryMessagesModule.search?.results?.totalCount ?? 0;\r\n  }\r\n\r\n  private get paginationRoutes(): PaginationRoutes {\r\n    return {\r\n      previousPageRoute: {\r\n        name: routeNameQDataSearch,\r\n        query: this.generateQuery(this.pageIndex - 1),\r\n      },\r\n      nextPageRoute: {\r\n        name: routeNameQDataSearch,\r\n        query: this.generateQuery(this.pageIndex + 1),\r\n      },\r\n      numberPageRoute: (page: number) => {\r\n        return {\r\n          name: routeNameQDataSearch,\r\n          query: this.generateQuery(page - 1),\r\n        };\r\n      },\r\n      firstPageRoute: {\r\n        name: routeNameQDataSearch,\r\n        query: this.generateQuery(0),\r\n      },\r\n      lastPageRoute: {\r\n        name: routeNameQDataSearch,\r\n        query: this.generateQuery(this.pageCount - 1),\r\n      },\r\n    };\r\n  }\r\n\r\n  private get breadcrumbs(): Breadcrumb[] {\r\n    // Q-data -> \"term\"\r\n    const query = copyQDataPageQueryFromRoute(this.$route);\r\n    const queryText = getQDataPageQueryText(this.$route);\r\n    return [\r\n      {\r\n        routeName: routeNameQData,\r\n        name: this.$t('breadcrumbs.' + routeNameQData).toString(),\r\n      },\r\n      {\r\n        routeName: routeNameQDataSearch,\r\n        routeQuery: query,\r\n        name: queryText,\r\n      },\r\n    ];\r\n  }\r\n\r\n  @Watch('$route', { immediate: false, deep: true })\r\n  private onRouteChange(): void {\r\n    this.routeTrackingInfo = getRouteTrackingInfo(this.$route);\r\n    this.initializeDeliveryMessagesParameters();\r\n    this.loadDeliveriesByTerm().finally(() => {\r\n      telemetryService.stopTrackPage(this.routeTrackingInfo);\r\n    });\r\n  }\r\n\r\n  private created(): void {\r\n    this.routeTrackingInfo = getRouteTrackingInfo(this.$route);\r\n    this.initializeDeliveryMessagesParameters();\r\n    this.loadDeliveriesByTerm().finally(() => {\r\n      telemetryService.stopTrackPage(this.routeTrackingInfo);\r\n    });\r\n  }\r\n\r\n  private onPageSizeChanged(newPageSize: number): void {\r\n    this.pageSize = newPageSize;\r\n    this.pageIndex = 0;\r\n    this.updateQuery();\r\n  }\r\n\r\n  private initializeDeliveryMessagesParameters(): void {\r\n    const queryData = getQDataPageQueryData(this.$route);\r\n\r\n    this.term = queryData?.term ?? null;\r\n    this.type = queryData?.type ?? null;\r\n    this.pageIndex = queryData?.pageIndex ?? 0;\r\n    this.pageSize = queryData?.pageSize ?? defaultPageSize;\r\n  }\r\n\r\n  // Updates the query (if any changes) which then changes the $route and the @Watch is triggered\r\n  private updateQuery(): boolean {\r\n    const query = this.generateQuery();\r\n\r\n    if (!compareQDataPageQuery(this.$route, query)) {\r\n      this.$router.push({ query });\r\n\r\n      return true;\r\n    }\r\n\r\n    return false;\r\n  }\r\n\r\n  private generateQuery(newPageIndex?: number): any {\r\n    return generateQDataPageQuery({\r\n      by: QueryType.ByTerm,\r\n      term: this.term ?? undefined,\r\n      type: this.type ?? undefined,\r\n      pageIndex: newPageIndex !== undefined ? newPageIndex : this.pageIndex,\r\n      pageSize: this.pageSize,\r\n    });\r\n  }\r\n\r\n  private loadDeliveriesByTerm(): Promise<void> {\r\n    this.loading = true;\r\n    this.error = false;\r\n\r\n    const search = new ByTermSearch();\r\n\r\n    search.term = this.term;\r\n    search.type = this.type;\r\n    search.pageIndex = this.pageIndex;\r\n    search.pageSize = this.pageSize;\r\n\r\n    return deliveryMessagesModule\r\n      .dispatchLoad(search)\r\n      .then(() => {\r\n        this.aSearchHasBeenDone = true;\r\n      })\r\n      .catch(() => {\r\n        this.error = true;\r\n      })\r\n      .finally(() => {\r\n        this.loading = false;\r\n      });\r\n  }\r\n\r\n  private onQDataDeliveryListClick(deliveryMessage: DeliveryMessage): void {\r\n    const query = this.generateQuery();\r\n    this.$router.push({\r\n      name: routeNameQDataDelivery,\r\n      params: { deliveryMessageNumber: deliveryMessage.number },\r\n      query,\r\n    });\r\n  }\r\n}\r\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataSearchPage.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataSearchPage.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./QDataSearchPage.vue?vue&type=template&id=44976bc1&\"\nimport script from \"./QDataSearchPage.vue?vue&type=script&lang=ts&\"\nexport * from \"./QDataSearchPage.vue?vue&type=script&lang=ts&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:\"d-flex flex-wrap\"},[_c('CustomAutoSuggest',{ref:\"customAutoSuggest\",staticClass:\"qDataSearchBox-customAutoSuggest mr-2 my-1\",attrs:{\"suggestions\":_vm.suggestions,\"placeholder\":_vm.$t('qDataSearchBox.searchPlaceholder'),\"value\":_vm.newValue,\"showClear\":_vm.newValue === _vm.value && _vm.newValue !== ''},on:{\"input\":_vm.onInput,\"submit\":_vm.onSubmit,\"reset\":_vm.onReset,\"select\":_vm.onSelect}}),_c('router-link',{staticClass:\"o-button o-button--blue-50 my-1\",attrs:{\"to\":{ name: _vm.routeNameQDataUnitSearch }}},[_vm._v(_vm._s(_vm.$t('qDataSearchBox.unitSearch')))])],1)}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('form',{on:{\"submit\":function($event){$event.preventDefault();return _vm.onSubmit.apply(null, arguments)}}},[_c('div',{staticClass:\"custom-auto-suggest o-search-input u-full-width @@modifiers\"},[_c('vue-autosuggest',{ref:\"autosuggest\",attrs:{\"suggestions\":_vm.suggestions,\"input-props\":_vm.inputProps,\"get-suggestion-value\":_vm.getSuggestionValue,\"component-attr-id-autosuggest\":\"custom-auto-suggest\",\"component-attr-prefix\":\"custom-auto-suggest\",\"component-attr-class-autosuggest-results-container\":\"custom-auto-suggest__container\"},on:{\"input\":_vm.onInput,\"item-changed\":_vm.onItemChanged,\"selected\":_vm.onSelected,\"opened\":function($event){_vm.isOpen = true},\"closed\":function($event){_vm.isOpen = false},\"keyup\":function($event){if(!$event.type.indexOf('key')&&_vm._k($event.keyCode,\"enter\",13,$event.key,\"Enter\")){ return null; }return _vm.onEnter.apply(null, arguments)}},scopedSlots:_vm._u([{key:\"default\",fn:function(ref){\nvar suggestion = ref.suggestion;\nreturn [_c('div',{staticClass:\"custom-auto-suggest__suggestion-item t-body-regular-small-bold px-3 py-2\",class:{\n            'custom-auto-suggest__suggestion-item--selected':\n              suggestion.item === _vm.selectedItem,\n          },domProps:{\"innerHTML\":_vm._s(suggestion.item.displayValue)}})]}}]),model:{value:(_vm.newValue),callback:function ($$v) {_vm.newValue=$$v},expression:\"newValue\"}},[_c('template',{slot:\"after-input\"},[(_vm.showClear)?_c('button',{staticClass:\"o-search-input__button\",attrs:{\"type\":\"button\"},on:{\"click\":function($event){$event.preventDefault();return _vm.onResetClick.apply(null, arguments)}}},[_c('i',{staticClass:\"o-search-input__button-icon mdi mdi-close-circle\"})]):_c('button',{staticClass:\"o-search-input__button\",attrs:{\"type\":\"submit\"}},[_c('i',{staticClass:\"material-icons o-search-input__button-icon\"},[_vm._v(\"search\")])])])],2)],1)])}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","var DefaultSection={name:\"default-section\",props:{section:{type:Object,required:!0},currentIndex:{type:[Number,String],required:!1,default:1/0},renderSuggestion:{type:Function,required:!1},normalizeItemFunction:{type:Function,required:!0},componentAttrPrefix:{type:String,required:!0},componentAttrIdAutosuggest:{type:String,required:!0}},data:function(){return{_currentIndex:this.currentIndex}},computed:{list:function(){var t=this.section,e=t.limit,n=t.data;return n.length<e&&(e=n.length),n.slice(0,e)}},methods:{getItemIndex:function(t){return this.section.start_index+t},getItemByIndex:function(t){return this.section.data[t]},onMouseEnter:function(t){var e=parseInt(t.currentTarget.getAttribute(\"data-suggestion-index\"));this._currentIndex=e,this.$emit(\"updateCurrentIndex\",e)},onMouseLeave:function(){this.$emit(\"updateCurrentIndex\",null)}},render:function(t){var e=this,n=this.componentAttrPrefix,s={beforeSection:this.$scopedSlots[\"before-section-\"+this.section.name],afterSectionDefault:this.$scopedSlots[\"after-section\"],afterSectionNamed:this.$scopedSlots[\"after-section-\"+this.section.name]},i=n+\"__results-before \"+n+\"__results-before--\"+this.section.name,r=s.beforeSection&&s.beforeSection({section:this.section,className:i})||[];return t(\"ul\",{attrs:{role:\"listbox\",\"aria-labelledby\":this.section.label&&this.componentAttrIdAutosuggest+\"-\"+this.section.label},class:this.section.ulClass},[r[0]&&r[0]||this.section.label&&t(\"li\",{class:i,id:this.componentAttrIdAutosuggest+\"-\"+this.section.label},this.section.label)||\"\",this.list.map(function(s,i){var r,o=e.normalizeItemFunction(e.section.name,e.section.type,e.section.label,e.section.liClass,s),u=e.getItemIndex(i),l=e._currentIndex===u||parseInt(e.currentIndex)===u;return t(\"li\",{attrs:Object.assign({},{role:\"option\",\"data-suggestion-index\":u,\"data-section-name\":o.name,id:n+\"__results-item--\"+u},o.liAttributes),key:u,class:Object.assign((r={},r[n+\"__results-item--highlighted\"]=l,r[n+\"__results-item\"]=!0,r),o.liClass),on:{mouseenter:e.onMouseEnter,mouseleave:e.onMouseLeave}},[e.renderSuggestion?e.renderSuggestion(o):e.$scopedSlots.default&&e.$scopedSlots.default({_key:i,suggestion:o})])}),s.afterSectionDefault&&s.afterSectionDefault({section:this.section,className:n+\"__results-after \"+n+\"__results-after--\"+this.section.name}),s.afterSectionNamed&&s.afterSectionNamed({section:this.section,className:n+\"__results_after \"+n+\"__results-after--\"+this.section.name})])}};function hasClass(t,e){return!!t.className.match(new RegExp(\"(\\\\s|^)\"+e+\"(\\\\s|$)\"))}function addClass(t,e){hasClass(t,e)||(t.className+=\" \"+e)}function removeClass(t,e){t.classList&&t.classList.remove(e)}var INDEX_IS_FOCUSED_ON_INPUT=-1,defaultSectionConfig={name:\"default\",type:\"default-section\"},VueAutosuggest={render:function(){var t=this,e=t.$createElement,n=t._self._c||e;return n(\"div\",{attrs:{id:t.componentAttrIdAutosuggest}},[t._t(\"before-input\"),n(\"div\",{attrs:{role:\"combobox\",\"aria-expanded\":t.isOpen?\"true\":\"false\",\"aria-haspopup\":\"listbox\",\"aria-owns\":t.componentAttrIdAutosuggest+\"-\"+t.componentAttrPrefix+\"__results\"}},[n(\"input\",t._g(t._b({class:[t.isOpen?t.componentAttrPrefix+\"__input--open\":\"\",t.internal_inputProps.class],attrs:{type:t.internal_inputProps.type,autocomplete:t.internal_inputProps.autocomplete,\"aria-autocomplete\":\"list\",\"aria-activedescendant\":t.isOpen&&null!==t.currentIndex?t.componentAttrPrefix+\"__results-item--\"+t.currentIndex:\"\",\"aria-controls\":t.componentAttrIdAutosuggest+\"-\"+t.componentAttrPrefix+\"__results\"},domProps:{value:t.internalValue},on:{input:t.inputHandler,keydown:t.handleKeyStroke}},\"input\",t.internal_inputProps,!1),t.listeners))]),t._t(\"after-input\"),t._v(\" \"),n(\"div\",{class:t._componentAttrClassAutosuggestResultsContainer,attrs:{id:t.componentAttrIdAutosuggest+\"-\"+t.componentAttrPrefix+\"__results\"}},[t.isOpen?n(\"div\",{class:t._componentAttrClassAutosuggestResults,attrs:{\"aria-labelledby\":t.componentAttrIdAutosuggest}},[t._t(\"before-suggestions\"),t._v(\" \"),t._l(t.computedSections,function(e,s){return n(e.type,{key:t.getSectionRef(\"\"+e.name+s),ref:t.getSectionRef(\"\"+e.name+s),refInFor:!0,tag:\"component\",attrs:{\"current-index\":t.currentIndex,\"normalize-item-function\":t.normalizeItem,\"render-suggestion\":t.renderSuggestion,section:e,\"component-attr-prefix\":t.componentAttrPrefix,\"component-attr-id-autosuggest\":t.componentAttrIdAutosuggest},on:{updateCurrentIndex:t.updateCurrentIndex},scopedSlots:t._u([{key:\"before-section-\"+(e.name||e.label),fn:function(n){var s=n.section,i=n.className;return[t._t(\"before-section-\"+(e.name||e.label),null,{section:s,className:i})]}},{key:\"default\",fn:function(e){var n=e.suggestion,s=e._key;return[t._t(\"default\",[t._v(\" \"+t._s(n.item)+\" \")],{suggestion:n,index:s})]}},{key:\"after-section-\"+(e.name||e.label),fn:function(n){var s=n.section;return[t._t(\"after-section-\"+(e.name||e.label),null,{section:s})]}},{key:\"after-section\",fn:function(e){var n=e.section;return[t._t(\"after-section\",null,{section:n})]}}])})}),t._v(\" \"),t._t(\"after-suggestions\")],2):t._e(),t._v(\" \"),t._t(\"after-suggestions-container\")],2)],2)},staticRenderFns:[],name:\"Autosuggest\",components:{DefaultSection:DefaultSection},props:{value:{type:String,default:null},inputProps:{type:Object,required:!0},limit:{type:Number,required:!1,default:1/0},suggestions:{type:Array,required:!0},renderSuggestion:{type:Function,required:!1,default:null},getSuggestionValue:{type:Function,required:!1,default:function(t){var e=t.item;return\"object\"==typeof e&&e.hasOwnProperty(\"name\")?e.name:e}},shouldRenderSuggestions:{type:Function,required:!1,default:function(t,e){return t>0&&!e}},sectionConfigs:{type:Object,required:!1,default:function(){return{default:{onSelected:null}}}},onSelected:{type:Function,required:!1,default:null},componentAttrIdAutosuggest:{type:String,required:!1,default:\"autosuggest\"},componentAttrClassAutosuggestResultsContainer:{type:String,required:!1,default:null},componentAttrClassAutosuggestResults:{type:String,required:!1,default:null},componentAttrPrefix:{type:String,required:!1,default:\"autosuggest\"}},data:function(){return{internalValue:null,searchInputOriginal:null,currentIndex:null,currentItem:null,loading:!1,didSelectFromOptions:!1,defaultInputProps:{type:\"text\",autocomplete:\"off\"},clientXMouseDownInitial:null}},computed:{internal_inputProps:function(){return Object.assign({},this.defaultInputProps,this.inputProps)},listeners:function(){var t=this;return Object.assign({},this.$listeners,{input:function(t){},click:function(){t.loading=!1,t.$listeners.click&&t.$listeners.click(t.currentItem),t.$nextTick(function(){t.ensureItemVisible(t.currentItem,t.currentIndex)})},selected:function(){t.currentItem&&t.sectionConfigs[t.currentItem.name]&&t.sectionConfigs[t.currentItem.name].onSelected?t.sectionConfigs[t.currentItem.name].onSelected(t.currentItem,t.searchInputOriginal):t.sectionConfigs.default.onSelected?t.sectionConfigs.default.onSelected(null,t.searchInputOriginal):t.$listeners.selected&&t.$emit(\"selected\",t.currentItem,t.currentIndex),t.setChangeItem(null)}})},isOpen:function(){return this.shouldRenderSuggestions(this.totalResults,this.loading)},computedSections:function(){var t=this,e=0;return this.suggestions.map(function(n){if(n.data){var s,i,r,o,u=n.name?n.name:defaultSectionConfig.name,l=null;t.sectionConfigs[u]&&(s=t.sectionConfigs[u].limit,r=t.sectionConfigs[u].type,i=t.sectionConfigs[u].label,o=t.sectionConfigs[u].ulClass,l=t.sectionConfigs[u].liClass),r=r||defaultSectionConfig.type,s=(s=s||t.limit)||1/0,s=n.data.length<s?n.data.length:s;var a={name:u,label:i=i||n.label,type:r,limit:s,data:n.data,start_index:e,end_index:e+s-1,ulClass:o,liClass:l};return e+=s,a}})},totalResults:function(){return this.computedSections.reduce(function(t,e){if(!e)return t;var n=e.limit,s=e.data;return t+(s.length>=n?n:s.length)},0)},_componentAttrClassAutosuggestResultsContainer:function(){return this.componentAttrClassAutosuggestResultsContainer||this.componentAttrPrefix+\"__results-container\"},_componentAttrClassAutosuggestResults:function(){return this.componentAttrClassAutosuggestResults||this.componentAttrPrefix+\"__results\"}},watch:{value:{handler:function(t){this.internalValue=t},immediate:!0},isOpen:{handler:function(t,e){t!==e&&this.$emit(t?\"opened\":\"closed\")},immediate:!0}},created:function(){this.loading=!0},mounted:function(){document.addEventListener(\"mouseup\",this.onDocumentMouseUp),document.addEventListener(\"mousedown\",this.onDocumentMouseDown)},beforeDestroy:function(){document.removeEventListener(\"mouseup\",this.onDocumentMouseUp),document.removeEventListener(\"mousedown\",this.onDocumentMouseDown)},methods:{inputHandler:function(t){var e=t.target.value;this.$emit(\"input\",e),this.internalValue=e,this.didSelectFromOptions||(this.searchInputOriginal=e,this.currentIndex=null)},getSectionRef:function(t){return\"computed_section_\"+t},getItemByIndex:function(t){var e=!1;if(null===t)return e;for(var n=0;n<this.computedSections.length;n++)if(t>=this.computedSections[n].start_index&&t<=this.computedSections[n].end_index){var s=t-this.computedSections[n].start_index,i=this.computedSections[n].name,r=this.$refs[this.getSectionRef(\"\"+i+n)][0];if(r){e=this.normalizeItem(this.computedSections[n].name,this.computedSections[n].type,r.section.label,r.section.liClass,r.getItemByIndex(s));break}}return e},handleKeyStroke:function(t){var e=this,n=t.keyCode;if(!([16,9,17,18,91,93].indexOf(n)>-1)){var s=!this.isOpen;if(this.loading=!1,this.didSelectFromOptions=!1,this.isOpen)switch(n){case 40:case 38:if(t.preventDefault(),38===n&&null===this.currentIndex)break;var i=40===n?1:-1,r=Math.max((parseInt(this.currentIndex)||0)+(s?0:i),INDEX_IS_FOCUSED_ON_INPUT);this.setCurrentIndex(r,this.totalResults),this.didSelectFromOptions=!0,this.totalResults>0&&this.currentIndex>=0?(this.setChangeItem(this.getItemByIndex(this.currentIndex)),this.didSelectFromOptions=!0):this.currentIndex===INDEX_IS_FOCUSED_ON_INPUT&&(this.setChangeItem(null),this.internalValue=this.searchInputOriginal,t.preventDefault()),this.$nextTick(function(){e.ensureItemVisible(e.currentItem,e.currentIndex)});break;case 13:t.preventDefault(),this.totalResults>0&&this.currentIndex>=0&&(this.setChangeItem(this.getItemByIndex(this.currentIndex),!0),this.didSelectFromOptions=!0),this.loading=!0,this.listeners.selected(this.didSelectFromOptions);break;case 27:this.loading=!0,this.currentIndex=null,this.internalValue=this.searchInputOriginal,this.$emit(\"input\",this.searchInputOriginal),t.preventDefault()}}},setChangeItem:function(t,e){if(void 0===e&&(e=!1),null!==this.currentIndex&&t){if(t){this.currentItem=t,this.$emit(\"item-changed\",t,this.currentIndex);var n=this.getSuggestionValue(t);this.internalValue=n,e&&(this.searchInputOriginal=n),this.ensureItemVisible(t,this.currentIndex)}}else this.currentItem=null,this.$emit(\"item-changed\",null,null)},normalizeItem:function(t,e,n,s,i){return{name:t,type:e,label:n,liClass:i.liClass||s,item:i}},ensureItemVisible:function(t,e,n){var s=this.$el.querySelector(n||\".\"+this._componentAttrClassAutosuggestResults);if(s){var i=s.querySelector(\"#\"+this.componentAttrPrefix+\"__results-item--\"+e);if(i){var r=s.clientHeight,o=s.scrollTop,u=i.clientHeight,l=i.offsetTop;u+l>=o+r?s.scrollTop=u+l-r:l<o&&o>0&&(s.scrollTop=l)}}},updateCurrentIndex:function(t){this.setCurrentIndex(t,-1,!0)},clickedOnScrollbar:function(t,e){var n=this.$el.querySelector(\".\"+this._componentAttrClassAutosuggestResults),s=n&&n.clientWidth<=e+17&&e+17<=n.clientWidth+34;return\"DIV\"===t.target.tagName&&n&&s||!1},onDocumentMouseDown:function(t){var e=t.target.getBoundingClientRect?t.target.getBoundingClientRect():0;this.clientXMouseDownInitial=t.clientX-e.left},onDocumentMouseUp:function(t){if(!this.$el.contains(t.target))return this.loading=!0,void(this.currentIndex=null);\"INPUT\"===t.target.tagName||this.clickedOnScrollbar(t,this.clientXMouseDownInitial)||(this.loading=!0,this.didSelectFromOptions=!0,this.setChangeItem(this.getItemByIndex(this.currentIndex),!0),this.listeners.selected(!0))},setCurrentIndex:function(t,e,n){void 0===e&&(e=-1),void 0===n&&(n=!1);var s=t;n||(null===this.currentIndex||t>=e)&&(s=0);this.currentIndex=s;var i=this.$el.querySelector(\"#\"+this.componentAttrPrefix+\"__results-item--\"+this.currentIndex),r=this.componentAttrPrefix+\"__results-item--highlighted\";this.$el.querySelector(\".\"+r)&&removeClass(this.$el.querySelector(\".\"+r),r),i&&addClass(i,r)}}},VueAutosuggestPlugin={install:function(t){t.component(\"vue-autosuggest-default-section\",DefaultSection),t.component(\"vue-autosuggest\",VueAutosuggest)}};\"undefined\"!=typeof window&&window.Vue&&window.Vue.use(VueAutosuggestPlugin);export default VueAutosuggestPlugin;export{VueAutosuggest,DefaultSection};\n","\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\r\nimport { Component, Vue, Prop, Watch } from 'vue-property-decorator';\r\nimport { VueAutosuggest } from 'vue-autosuggest';\r\nimport VueComponent from 'vue/types';\r\n\r\nexport interface SuggestionItem {\r\n  value: string;\r\n  displayValue: string;\r\n}\r\n\r\n@Component({\r\n  components: {\r\n    VueAutosuggest,\r\n  },\r\n})\r\nexport default class CustomAutoSuggest extends Vue {\r\n  @Prop({ required: false, default: () => '' })\r\n  private value!: string;\r\n\r\n  @Prop({ required: false, default: () => false })\r\n  private showClear!: boolean;\r\n\r\n  @Prop({ required: false })\r\n  private placeholder!: string;\r\n\r\n  @Prop({ required: true })\r\n  private suggestions!: Array<{\r\n    data: SuggestionItem[];\r\n  }>;\r\n\r\n  private newValue: string = '';\r\n\r\n  private isOpen: boolean = false;\r\n\r\n  // is used to prevent onEnter to emit submit event after an onSelected has been triggered\r\n  private hasSelected: boolean = false;\r\n\r\n  private inputProps:\r\n    | {\r\n        name: string;\r\n        class: string;\r\n        placeholder: string;\r\n      }\r\n    | undefined = undefined;\r\n\r\n  private selectedItem: SuggestionItem | null = null;\r\n\r\n  public clearValue(): void {\r\n    this.newValue = '';\r\n    this.selectedItem = null;\r\n  }\r\n\r\n  private created() {\r\n    this.inputProps = {\r\n      name: 'custom-auto-suggest__input',\r\n      class: 'o-search-input__input',\r\n      placeholder: this.placeholder,\r\n    };\r\n    this.newValue = this.value;\r\n  }\r\n\r\n  // Watch value change\r\n  @Watch('value', { immediate: true, deep: false })\r\n  private onValueChange(val: any) {\r\n    this.newValue = val;\r\n  }\r\n\r\n  private onSubmit() {\r\n    this.$emit('submit');\r\n  }\r\n\r\n  private onEnter() {\r\n    if (this.selectedItem === null && !this.hasSelected) {\r\n      this.$emit('submit');\r\n    }\r\n  }\r\n\r\n  private onResetClick() {\r\n    this.$emit('reset');\r\n\r\n    this.$nextTick(() => {\r\n      const autosuggestComponent = this.$refs.autosuggest as VueComponent;\r\n      if (autosuggestComponent) {\r\n        autosuggestComponent.$el.querySelector('input')?.focus();\r\n      }\r\n    });\r\n  }\r\n\r\n  private onInput(value: string): void {\r\n    this.$emit('input', value);\r\n  }\r\n\r\n  private onItemChanged(suggestion: { item: SuggestionItem }): void {\r\n    if (!suggestion) {\r\n      this.selectedItem = null;\r\n\r\n      return;\r\n    }\r\n\r\n    this.selectedItem = suggestion.item;\r\n  }\r\n\r\n  private onSelected(): void {\r\n    if (this.selectedItem !== null) {\r\n      this.hasSelected = true;\r\n      this.$emit('select', { item: this.selectedItem, value: this.newValue });\r\n    }\r\n  }\r\n\r\n  private getSuggestionValue(suggestion: { item: SuggestionItem }): string {\r\n    if (!suggestion) {\r\n      return '';\r\n    }\r\n\r\n    return suggestion.item.value;\r\n  }\r\n}\r\n","import mod from \"-!../../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../../node_modules/thread-loader/dist/cjs.js!../../../node_modules/babel-loader/lib/index.js!../../../node_modules/ts-loader/index.js??ref--15-3!../../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./CustomAutoSuggest.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../../node_modules/thread-loader/dist/cjs.js!../../../node_modules/babel-loader/lib/index.js!../../../node_modules/ts-loader/index.js??ref--15-3!../../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./CustomAutoSuggest.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./CustomAutoSuggest.vue?vue&type=template&id=53b11c19&\"\nimport script from \"./CustomAutoSuggest.vue?vue&type=script&lang=ts&\"\nexport * from \"./CustomAutoSuggest.vue?vue&type=script&lang=ts&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\r\nimport { debounce } from 'lodash';\r\nimport { Component, Prop, Vue, Watch } from 'vue-property-decorator';\r\nimport CustomAutoSuggest, {\r\n  SuggestionItem,\r\n} from '@/components/general/CustomAutoSuggest.vue';\r\nimport qualityDataService from '@/services/QualityDataService';\r\nimport { Consoler } from '@/utils/Consoler';\r\nimport {\r\n  routeNameQDataDelivery,\r\n  routeNameQDataUnitSearch,\r\n  routeNameQDataSearch,\r\n} from '@/router/routes';\r\nimport {\r\n  deliveryMessagesModule,\r\n  QueryType,\r\n} from '@/store/modules/deliveryMessages';\r\nimport {\r\n  generateQDataPageQuery,\r\n  defaultPageSize,\r\n  compareQDataPageQuery,\r\n} from '@/utils/RoutingForQData';\r\nimport { SuggestionType } from '@/models/QualityData/SuggestionType';\r\nimport { Suggestion } from '@/models/QualityData/Suggestion';\r\n\r\ninterface QDataSuggestionItem extends SuggestionItem {\r\n  term: string;\r\n  type: SuggestionType;\r\n  deliveryMessageNumber?: string;\r\n}\r\n\r\n@Component({\r\n  components: {\r\n    CustomAutoSuggest,\r\n  },\r\n})\r\nexport default class QDataSearchBox extends Vue {\r\n  @Prop({ required: false, default: () => '' })\r\n  private value!: string;\r\n\r\n  private readonly routeNameQDataUnitSearch = routeNameQDataUnitSearch;\r\n\r\n  private newValue: string = '';\r\n  private onValue = debounce(() => this.getSuggestions(), 600);\r\n\r\n  private suggestions: Array<{\r\n    data: QDataSuggestionItem[];\r\n  }> = [];\r\n\r\n  private created() {\r\n    this.newValue = this.value;\r\n  }\r\n\r\n  // Watch value change\r\n  @Watch('value', { immediate: true, deep: false })\r\n  private onValueChange(val: any) {\r\n    this.newValue = val;\r\n  }\r\n\r\n  private onInput(value: string): void {\r\n    const newValue = value.trim();\r\n\r\n    if (this.newValue === newValue) {\r\n      return;\r\n    }\r\n\r\n    this.newValue = newValue;\r\n    this.onValue();\r\n  }\r\n\r\n  private onSubmit(): void {\r\n    this.goToSearchPage(this.newValue, null);\r\n  }\r\n\r\n  private onReset(): void {\r\n    this.newValue = '';\r\n  }\r\n\r\n  private getSuggestions(): Promise<void> {\r\n    if (!this.newValue) {\r\n      this.suggestions = [];\r\n\r\n      return Promise.resolve();\r\n    }\r\n\r\n    const getDisplayValue = (suggestion: Suggestion): string => {\r\n      if (suggestion.numberOfMatches > 1) {\r\n        return this.$t('qDataSearchBox.suggestionWithMultipleMatches', [\r\n          this.$t(`suggestionType.${suggestion.type}`).toString(),\r\n          suggestion.matchedTerm,\r\n        ]).toString();\r\n      }\r\n\r\n      if (suggestion.type === SuggestionType.DeliveryMessage) {\r\n        return this.$t('qDataSearchBox.suggestionWithOneMatchOnDelivery', [\r\n          suggestion.match,\r\n        ]).toString();\r\n      }\r\n\r\n      return this.$t('qDataSearchBox.suggestionWithOneMatch', [\r\n        suggestion.match,\r\n        this.$t(`suggestionType.${suggestion.type}`).toString(),\r\n        suggestion.matchedTerm,\r\n      ]).toString();\r\n    };\r\n\r\n    return qualityDataService\r\n      .getSuggestions(this.newValue)\r\n      .then((response) => {\r\n        this.suggestions = [\r\n          {\r\n            data: response.map((suggestion) => ({\r\n              value: suggestion.matchedTerm,\r\n              displayValue: getDisplayValue(suggestion),\r\n              term: suggestion.matchedTerm,\r\n              type: suggestion.type,\r\n              deliveryMessageNumber: suggestion.match,\r\n            })),\r\n          },\r\n        ];\r\n      })\r\n      .catch((error) => {\r\n        Consoler.debugLog('Failed to get suggestions', error);\r\n      });\r\n  }\r\n\r\n  private onSelect(suggestion: {\r\n    item: QDataSuggestionItem | null;\r\n    value: string | null;\r\n  }): void {\r\n    Consoler.debugLog('Suggestion selected', suggestion);\r\n\r\n    if (suggestion.item) {\r\n      if (suggestion.item.deliveryMessageNumber) {\r\n        deliveryMessagesModule.commitClearSearch();\r\n\r\n        if (suggestion.item.type === SuggestionType.Unit) {\r\n          this.goToDeliveryPage(\r\n            suggestion.item.deliveryMessageNumber,\r\n            suggestion.item.term\r\n          );\r\n        } else {\r\n          this.goToDeliveryPage(suggestion.item.deliveryMessageNumber);\r\n        }\r\n      } else {\r\n        this.goToSearchPage(suggestion.item.term, suggestion.item.type);\r\n      }\r\n    } else {\r\n      this.goToSearchPage(suggestion.value, null);\r\n    }\r\n  }\r\n\r\n  private goToSearchPage(\r\n    term: string | null,\r\n    type: string | null = null\r\n  ): void {\r\n    if (!term) {\r\n      return;\r\n    }\r\n\r\n    const newQuery = generateQDataPageQuery({\r\n      by: QueryType.ByTerm,\r\n      term,\r\n      type: type ?? undefined,\r\n      pageIndex: 0,\r\n      pageSize: defaultPageSize,\r\n    });\r\n\r\n    if (!compareQDataPageQuery(this.$route, newQuery)) {\r\n      this.$router.push({\r\n        name: routeNameQDataSearch,\r\n        query: newQuery,\r\n      });\r\n    }\r\n  }\r\n\r\n  private goToDeliveryPage(\r\n    deliveryMessageNumber: string,\r\n    unitId?: string\r\n  ): void {\r\n    if (\r\n      this.$route.name === routeNameQDataDelivery &&\r\n      this.$route.params.deliveryMessageNumber === deliveryMessageNumber &&\r\n      this.$route.query.unitId === unitId\r\n    ) {\r\n      this.clearValue();\r\n      return;\r\n    }\r\n\r\n    const query: any = {};\r\n\r\n    if (unitId !== undefined) {\r\n      query.unitId = unitId;\r\n    }\r\n\r\n    this.$router.push({\r\n      name: routeNameQDataDelivery,\r\n      params: { deliveryMessageNumber },\r\n      query,\r\n    });\r\n  }\r\n\r\n  private clearValue(): void {\r\n    (this.$refs.customAutoSuggest as CustomAutoSuggest).clearValue();\r\n  }\r\n}\r\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataSearchBox.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataSearchBox.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./QDataSearchBox.vue?vue&type=template&id=3a53a952&scoped=true&\"\nimport script from \"./QDataSearchBox.vue?vue&type=script&lang=ts&\"\nexport * from \"./QDataSearchBox.vue?vue&type=script&lang=ts&\"\nimport style0 from \"./QDataSearchBox.vue?vue&type=style&index=0&id=3a53a952&scoped=true&lang=scss&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  \"3a53a952\",\n  null\n  \n)\n\nexport default component.exports","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--9-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--9-oneOf-1-1!../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--9-oneOf-1-2!../../node_modules/sass-loader/dist/cjs.js??ref--9-oneOf-1-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataUnitSearchPage.vue?vue&type=style&index=0&id=366b473e&scoped=true&lang=scss&\"","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--9-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--9-oneOf-1-1!../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--9-oneOf-1-2!../../node_modules/sass-loader/dist/cjs.js??ref--9-oneOf-1-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataSubscriptionsPage.vue?vue&type=style&index=0&lang=scss&\"","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('DefaultLayout',[_c('Breadcrumbs',{attrs:{\"items\":_vm.breadcrumbs}}),_c('Messages'),_c('div',{staticClass:\"container-fluid mt-3\"},[_c('div',{staticClass:\"d-flex flex-row justify-content-between flex-wrap align-items-center\"},[_c('h1',{staticClass:\"t-heading-3 pr-2\"},[_vm._v(\" \"+_vm._s(_vm.$t('qDataUnitSearchPage.title'))+\" \")]),_c('div',{staticClass:\"d-align-self-end\"},[_c('QDataSearchBox')],1)]),_c('span',{staticClass:\"o-line\"}),(_vm.isQdataScanningEnabled)?_c('div',{staticClass:\"col-4\"},[_c('QDataScanner',{ref:\"scanner\",on:{\"unitScanned\":_vm.onUnitScanned}})],1):_vm._e(),_c('div',{staticClass:\"c-form c-form--light-grey p-0 mb-3\"},[_c('form',{on:{\"submit\":function($event){$event.preventDefault();return _vm.onSubmit.apply(null, arguments)}}},[_c('div',{staticClass:\"row\"},[_c('div',{staticClass:\"col-12 col-lg-6\"},[_c('div',{staticClass:\"mb-2\"},[_c('textarea',{directives:[{name:\"model\",rawName:\"v-model\",value:(_vm.unitIdsInput),expression:\"unitIdsInput\"}],staticClass:\"o-textarea u-full-width mb-0\",attrs:{\"name\":\"query\",\"placeholder\":_vm.$t('qDataUnitSearchPage.searchPlaceholder'),\"disabled\":_vm.loading},domProps:{\"value\":(_vm.unitIdsInput)},on:{\"input\":function($event){if($event.target.composing){ return; }_vm.unitIdsInput=$event.target.value}}})]),_c('div',[_c('button',{staticClass:\"o-button o-button--blue\",attrs:{\"type\":\"submit\",\"disabled\":_vm.loading}},[_vm._v(\" \"+_vm._s(_vm.$t('qDataUnitSearchPage.submit'))+\" \")]),(_vm.isQdataScanningEnabled)?_c('button',{staticClass:\"o-button o-button--blue ml-1\",on:{\"click\":function($event){$event.preventDefault();return _vm.onScanClick.apply(null, arguments)}}},[_vm._v(\" \"+_vm._s(_vm.$t('qDataUnitSearchPage.scan'))+\" \")]):_vm._e(),_c('button',{directives:[{name:\"show\",rawName:\"v-show\",value:(_vm.unitIdsInput),expression:\"unitIdsInput\"}],staticClass:\"o-button o-button--white ml-2\",attrs:{\"type\":\"button\",\"disabled\":_vm.loading},on:{\"click\":_vm.onResetClick}},[_vm._v(\" \"+_vm._s(_vm.$t('qDataUnitSearchPage.reset'))+\" \")])])])])])]),(_vm.showGeneralError)?_c('div',{staticClass:\"c-alert c-alert--red mb-2\"},[_c('div',{staticClass:\"c-alert__text\"},[_vm._v(\" \"+_vm._s(_vm.$t('qDataUnitSearchPage.generalError'))+\" \")]),_c('span',{staticClass:\"c-alert__close\",on:{\"click\":function($event){_vm.showGeneralError = false}}})]):_vm._e(),(_vm.showNotFoundError)?_c('div',{staticClass:\"c-alert c-alert--yellow\"},[_c('div',{staticClass:\"c-alert__text\",domProps:{\"innerHTML\":_vm._s(_vm.notFoundErrorHtml)}}),_c('span',{staticClass:\"c-alert__close\",on:{\"click\":function($event){_vm.showNotFoundError = false}}})]):_vm._e(),(_vm.loading)?_c('div',{staticClass:\"u-position-relative u-min-height-300\"},[_c('span',{staticClass:\"o-loader o-loader--absolute\"})]):_vm._e(),(!_vm.loading && _vm.searchHasBeenDone)?[_c('h3',{staticClass:\"t-heading-5 mt-4\"},[(_vm.unitsFound.length === 1)?[_vm._v(_vm._s(_vm.$t('qDataUnitSearchPage.unitsTitle.one', [_vm.unitsFound.length])))]:[_vm._v(_vm._s(_vm.$t('qDataUnitSearchPage.unitsTitle.multiple', [_vm.unitsFound.length])))]],2),_c('QDataUnitList',{attrs:{\"parameters\":_vm.parameters,\"units\":_vm.unitsFound,\"averageValues\":_vm.unitsAverageValues,\"pulpType\":_vm.pulpType,\"showDeliveryLink\":true}})]:_vm._e(),_c('button',{directives:[{name:\"show\",rawName:\"v-show\",value:(_vm.searchHasBeenDone && _vm.unitsFound.length > 0),expression:\"searchHasBeenDone && unitsFound.length > 0\"}],staticClass:\"o-button o-button--black mt-2\",attrs:{\"type\":\"button\",\"disabled\":_vm.loading || _vm.downloadingDataSheet},on:{\"click\":_vm.downloadDataSheet}},[_vm._v(\" \"+_vm._s(_vm.$t('qDataUnitSearchPage.download'))+\" \")])],2)],1)}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","import { CommonStore } from '@/store/common';\r\nimport { Consoler } from '@/utils/Consoler';\r\nimport { store } from '@/store';\r\n\r\nimport {\r\n  Module,\r\n  VuexModule,\r\n  Mutation,\r\n  Action,\r\n  getModule,\r\n} from 'vuex-module-decorators';\r\nimport qualityDataService from '@/services/QualityDataService';\r\nimport { GeneralQualityDataForUnits } from '@/models/QualityData/GeneralQualityDataForUnits';\r\n\r\n@Module({\r\n  namespaced: true,\r\n  name: 'deliveryMessagesUnitSearchModule',\r\n  dynamic: true,\r\n  store,\r\n})\r\nclass DeliveryMessagesUnitSearchModule extends VuexModule {\r\n  public search: GeneralQualityDataForUnits | null = null;\r\n\r\n  private common = new CommonStore(10); // reLoadMinMinutesInterval\r\n\r\n  // ---------------\r\n  // ### Getters ###\r\n  // ---------------\r\n\r\n  public get loading() {\r\n    return this.common.loading;\r\n  }\r\n\r\n  // -----------------\r\n  // ### Mutations ###\r\n  // -----------------\r\n\r\n  @Mutation private commitSetDeliveryMessagesUnitSearch(\r\n    payload: GeneralQualityDataForUnits\r\n  ) {\r\n    this.search = payload;\r\n  }\r\n\r\n  @Mutation private commitClearDeliveryMessagesUnitSearch() {\r\n    this.search = null;\r\n  }\r\n\r\n  // From common:\r\n  @Mutation private commitSetLoadedDate() {\r\n    this.common.setLoadedDate();\r\n  }\r\n  @Mutation private commitClearLoadedDate() {\r\n    this.common.clearLoadedDate();\r\n  }\r\n  @Mutation private commitSetLoadingError(payload: { error: any }) {\r\n    this.common.setLoadingError(payload);\r\n  }\r\n  @Mutation private commitSetLoading() {\r\n    this.common.setLoading();\r\n  }\r\n  @Mutation private commitClearLoading() {\r\n    this.common.clearLoading();\r\n  }\r\n  @Mutation private commitSetLoadingPromise(payload: {\r\n    loadingPromise: Promise<void>;\r\n    loadingPromiseForId: any;\r\n  }) {\r\n    this.common.setLoadingPromise(payload);\r\n  }\r\n\r\n  // ---------------\r\n  // ### Actions ###\r\n  // ---------------\r\n\r\n  @Action\r\n  public async dispatchLoad(payload: { unitIds: string[] }): Promise<void> {\r\n    if (\r\n      this.search !== null &&\r\n      payload.unitIds.length === this.search.ids.length &&\r\n      payload.unitIds.every((unitId) =>\r\n        this.search?.ids.find((id) => unitId === id)\r\n      ) &&\r\n      !this.common.needToReLoad()\r\n    ) {\r\n      return Promise.resolve();\r\n    }\r\n    this.commitSetLoading();\r\n\r\n    return qualityDataService\r\n      .getUnits(payload.unitIds)\r\n      .then((response) => {\r\n        Consoler.debugLog(\r\n          'Load deliveryMessagesUnitSearch success',\r\n          payload.unitIds,\r\n          response\r\n        );\r\n\r\n        this.commitSetDeliveryMessagesUnitSearch(response);\r\n        this.commitSetLoadedDate();\r\n        this.commitClearLoading();\r\n      })\r\n      .catch((error) => {\r\n        this.commitSetLoadingError(error);\r\n        Consoler.debugWarn(\r\n          'Load deliveryMessagesUnitSearch failed',\r\n          payload.unitIds,\r\n          error\r\n        );\r\n        return Promise.reject(error);\r\n      });\r\n  }\r\n\r\n  @Action\r\n  public async dispatchClear() {\r\n    Consoler.debugLog('Clearing deliveryMessagesUnits');\r\n    this.commitClearDeliveryMessagesUnitSearch();\r\n    this.commitClearLoadedDate();\r\n  }\r\n}\r\n\r\nexport const deliveryMessagesUnitSearchModule = getModule(\r\n  DeliveryMessagesUnitSearchModule\r\n);\r\n","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',[_c('Modal',{ref:\"modal\",attrs:{\"id\":\"scanWithCameraModal\",\"title\":_vm.$t(\"qDataScanner.title\"),\"showFooter\":false,\"isLarge\":true,\"closeableByOutsideClickAndEscKey\":true},scopedSlots:_vm._u([{key:\"body\",fn:function(){return [_c('div',{ref:\"fullscreen\",staticClass:\"qDataScanner-fullscreen\"},[(_vm.errorNoUnitIdFound)?_c('div',{staticClass:\"c-alert c-alert--red mb-3\",attrs:{\"data-element-id\":\"qDataScanner-errorNoUnitId\"}},[_c('span',{staticClass:\"c-alert__text\"},[_vm._v(_vm._s(_vm.$t('qDataScanner.error.noUnitId'))+\" \")]),_c('span',{staticClass:\"c-alert__close\",attrs:{\"data-element-id\":\"qDataScanner-errorNoUnitId\"},on:{\"click\":function($event){_vm.noUnitIdFound = false}}})]):_vm._e(),_c('div',{ref:\"scanner\",staticClass:\"qDataScanner-scanner\"},[(_vm.videoStream)?_c('QDataScannerOverlay',{ref:\"videoOverlay\",staticClass:\"qDataScanner-videoOverlay\",attrs:{\"size\":_vm.videoSize},on:{\"scan\":_vm.takeAndAnalyzePhoto}}):_vm._e(),_c('video',{ref:\"video\",staticClass:\"qDataScanner-video\",attrs:{\"autoplay\":\"\"}}),(_vm.videoStream)?_c('SelectBox',{staticClass:\"align-left u-position-absolute u-is-bottom mb-2 ml-2\",attrs:{\"value\":_vm.currentCameraDevice,\"options\":_vm.cameraDevicesSelectOptions},on:{\"input\":_vm.onCameraChange}}):_vm._e(),_c('div',{staticClass:\"js-modal-close-trigger c-modal__close\",on:{\"click\":function($event){$event.preventDefault();return _vm.onCloseClick.apply(null, arguments)}}},[_c('span',{staticClass:\"material-icons c-modal__close__icon\"},[_vm._v(\"close\")])]),_c('div',{staticClass:\"align-right u-is-bottom u-position-absolute\"},[_c('a',{staticClass:\"o-round-button me-2 mb-2 ml-2\",class:(\"o-round-button--\" + (_vm.isViewfinderStyleUnitId ? 'yellow' : 'light-grey')),on:{\"click\":_vm.onUnitIdClick}},[_c('i',{staticClass:\"material-symbols-outlined\"},[_vm._v(\" document_scanner \")])]),_c('a',{staticClass:\"o-round-button me-2 mb-2 ml-2\",class:(\"o-round-button--\" + (_vm.isViewfinderStyleUnitId ? 'light-grey' : 'yellow')),on:{\"click\":_vm.onBarcodeClick}},[_c('i',{staticClass:\"material-symbols-outlined\"},[_vm._v(\" barcode_scanner \")])])])],1)])]},proxy:true}])})],1)}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","export default function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}","export default function _iterableToArrayLimit(arr, i) {\n  if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _e = undefined;\n\n  try {\n    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}","export default function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}","import arrayWithHoles from \"./arrayWithHoles.js\";\nimport iterableToArrayLimit from \"./iterableToArrayLimit.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableRest from \"./nonIterableRest.js\";\nexport default function _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}","\n\n\n\n\n\n\n\n\r\nimport { Vue, Prop, Component, Watch } from 'vue-property-decorator';\r\nimport { Consoler } from '@/utils/Consoler';\r\n\r\nexport enum ViewfinderStyle {\r\n  UnitId,\r\n  Barcode,\r\n}\r\n\r\nexport class Rectangle {\r\n  x1: number = 0;\r\n  y1: number = 0;\r\n  x2: number = 0;\r\n  y2: number = 0;\r\n\r\n  constructor(x1: number = 0, y1: number = 0, x2: number = 0, y2: number = 0) {\r\n    this.x1 = x1;\r\n    this.y1 = y1;\r\n    this.x2 = x2;\r\n    this.y2 = y2;\r\n  }\r\n}\r\n\r\nclass Viewfinder {\r\n  // Percentage of canvas total width\r\n  buttonWidthPercentage: number = 10;\r\n\r\n  public getViewfinderCoordinates(\r\n    totalWidth: number,\r\n    totalHeight: number,\r\n    style: ViewfinderStyle = ViewfinderStyle.UnitId\r\n  ): [Rectangle, Rectangle] {\r\n    const totalArea = new Rectangle(0, 0, totalWidth, totalHeight);\r\n\r\n    const horizontalScaleUnitId = 0.9;\r\n    const horizontalScaleBarcode = 0.8;\r\n\r\n    const x1 =\r\n      totalWidth / 2 -\r\n      (totalWidth *\r\n        (style == ViewfinderStyle.UnitId\r\n          ? horizontalScaleUnitId\r\n          : horizontalScaleBarcode)) /\r\n        2;\r\n    const x2 =\r\n      totalWidth / 2 +\r\n      (totalWidth *\r\n        (style == ViewfinderStyle.UnitId\r\n          ? horizontalScaleUnitId\r\n          : horizontalScaleBarcode)) /\r\n        2;\r\n\r\n    const viewfinderWidth = x2 - x1;\r\n\r\n    const y1 =\r\n      totalHeight / 2 -\r\n      viewfinderWidth * (style === ViewfinderStyle.UnitId ? 1 / 14.0 : 1 / 5.0);\r\n\r\n    const y2 =\r\n      totalHeight / 2 +\r\n      viewfinderWidth * (style === ViewfinderStyle.UnitId ? 1 / 14.0 : 1 / 5.0);\r\n\r\n    const viewfinderArea = new Rectangle(\r\n      Math.floor(x1),\r\n      Math.floor(y1),\r\n      Math.floor(x2),\r\n      Math.floor(y2)\r\n    );\r\n\r\n    return [totalArea, viewfinderArea];\r\n  }\r\n}\r\n\r\n@Component\r\nexport default class QDataScannerOverlay extends Vue {\r\n  @Prop({ required: true })\r\n  private size!: [number, number];\r\n  private viewfinder = new Viewfinder();\r\n  private viewfinderStyle = ViewfinderStyle.UnitId;\r\n\r\n  private get Width(): number {\r\n    return this.size[0];\r\n  }\r\n\r\n  private get Height(): number {\r\n    return this.size[1];\r\n  }\r\n\r\n  public setViewfinderStyle(style: ViewfinderStyle): void {\r\n    this.viewfinderStyle = style;\r\n  }\r\n\r\n  @Watch('size', { immediate: true, deep: true })\r\n  private onSizeChanged() {\r\n    Consoler.debugLog(\r\n      'Size of video element changed. Recalculating and redrawing overlay canvas'\r\n    );\r\n    var overlay = this.$refs.scannerCanvas as HTMLCanvasElement;\r\n\r\n    if (overlay === null || overlay === undefined) {\r\n      return;\r\n    }\r\n\r\n    overlay.width = this.Width;\r\n    overlay.height = this.Height;\r\n\r\n    this.redraw();\r\n  }\r\n\r\n  public redraw(): void {\r\n    var canvas = this.$refs.scannerCanvas as HTMLCanvasElement;\r\n    const ctx = canvas.getContext('2d');\r\n\r\n    const [totalArea, viewfinderArea] =\r\n      this.viewfinder.getViewfinderCoordinates(\r\n        this.Width,\r\n        this.Height,\r\n        this.viewfinderStyle\r\n      );\r\n\r\n    // Clear the canvas\r\n    ctx!.clearRect(0, 0, this.Width, this.Height);\r\n\r\n    // Draw dimmed area\r\n    ctx!.fillStyle = '#00000033';\r\n    ctx!.fillRect(totalArea.x1, totalArea.y1, totalArea.x2, totalArea.y2);\r\n\r\n    // Cutout from dimmed area\r\n    ctx!.clearRect(\r\n      viewfinderArea.x1,\r\n      viewfinderArea.y1,\r\n      viewfinderArea.x2 - viewfinderArea.x1,\r\n      viewfinderArea.y2 - viewfinderArea.y1\r\n    );\r\n  }\r\n\r\n  public getViewfinderCoordinates(\r\n    totalWidth: number,\r\n    totalHeight: number\r\n  ): [Rectangle, Rectangle] {\r\n    return this.viewfinder.getViewfinderCoordinates(\r\n      totalWidth,\r\n      totalHeight,\r\n      this.viewfinderStyle\r\n    );\r\n  }\r\n\r\n  private overlayClicked(): void {\r\n    this.$emit('scan');\r\n  }\r\n}\r\n","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('canvas',{ref:\"scannerCanvas\",staticClass:\"material-icons\",on:{\"click\":_vm.overlayClicked}})}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataScannerOverlay.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataScannerOverlay.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./QDataScannerOverlay.vue?vue&type=template&id=6f772cac&\"\nimport script from \"./QDataScannerOverlay.vue?vue&type=script&lang=ts&\"\nexport * from \"./QDataScannerOverlay.vue?vue&type=script&lang=ts&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\r\nimport { Component, Vue } from 'vue-property-decorator';\r\nimport Modal from '@/components/general/Modal.vue';\r\nimport QDataScannerOverlay, {\r\n  ViewfinderStyle,\r\n} from '@/components/QDataScannerOverlay.vue';\r\nimport qualityDataService from '@/services/QualityDataService';\r\nimport { userProfileModule } from '@/store/modules/userProfile';\r\nimport { Consoler } from '@/utils/Consoler';\r\nimport SelectBox, { SelectOption } from './general/SelectBox.vue';\r\n\r\n@Component({\r\n  components: {\r\n    Modal,\r\n    QDataScannerOverlay,\r\n    SelectBox,\r\n  },\r\n})\r\nexport default class QDataScanner extends Vue {\r\n  private videostream: MediaStream | null = null;\r\n  private videosize: [number, number] = [0, 0];\r\n  private noUnitIdFound: boolean = false;\r\n  private viewfinderStyle: ViewfinderStyle = ViewfinderStyle.UnitId;\r\n  private cameraDevices: Array<string> = new Array<string>();\r\n  private cameraDevice: string | null = null;\r\n\r\n  private set selectedCameraDeviceId(deviceId: string | null) {\r\n    if (deviceId === null) {\r\n      userProfileModule?.commitClearSelectedCameraDeviceId();\r\n    } else {\r\n      userProfileModule?.commitSetSelectedCameraDeviceId(deviceId);\r\n    }\r\n  }\r\n  private get selectedCameraDeviceId(): string | null {\r\n    return userProfileModule?.selectedCameraDeviceId;\r\n  }\r\n\r\n  private get isViewfinderStyleUnitId(): boolean {\r\n    return this.viewfinderStyle === ViewfinderStyle.UnitId;\r\n  }\r\n\r\n  private get errorNoUnitIdFound(): boolean {\r\n    return this.noUnitIdFound;\r\n  }\r\n\r\n  private set videoStream(stream: MediaStream | null) {\r\n    this.videostream = stream;\r\n  }\r\n  private get videoStream(): MediaStream | null {\r\n    if (this.videostream === null || this.videostream === undefined) {\r\n      return null;\r\n    }\r\n\r\n    return this.videostream;\r\n  }\r\n\r\n  private set currentCameraDevice(device: string | null) {\r\n    this.cameraDevice = device;\r\n  }\r\n  private get currentCameraDevice(): string | null {\r\n    return this.cameraDevice;\r\n  }\r\n\r\n  private get cameraDevicesSelectOptions(): SelectOption[] {\r\n    if (this.cameraDevices === null) {\r\n      return [];\r\n    }\r\n    return this.cameraDevices.map((cameraDevice, index) => ({\r\n      value: cameraDevice,\r\n      text: this.$t('qDataScanner.cameraDevice', [index]).toString(),\r\n    }));\r\n  }\r\n\r\n  private get videoElement(): HTMLVideoElement {\r\n    const element = this.$refs.video as HTMLVideoElement;\r\n\r\n    return element;\r\n  }\r\n\r\n  public get videoSize(): [number, number] {\r\n    return this.videosize;\r\n  }\r\n\r\n  private get scannerOverlay(): QDataScannerOverlay | null {\r\n    const scannerOverlay = this.$refs.videoOverlay as QDataScannerOverlay;\r\n\r\n    return scannerOverlay;\r\n  }\r\n\r\n  public getVideoResolution(): [width: number, height: number] {\r\n    const videoElement = this.videoElement;\r\n\r\n    return videoElement !== null\r\n      ? [videoElement.videoWidth, videoElement.videoHeight]\r\n      : [0, 0];\r\n  }\r\n\r\n  private async getBackFacingCameras(): Promise<Array<string>> {\r\n    var foundCameras = Array<string>();\r\n\r\n    await navigator.mediaDevices\r\n      .enumerateDevices()\r\n      .then((devices) => {\r\n        devices.forEach((dev) => {\r\n          if (\r\n            dev.kind === 'videoinput' &&\r\n            dev.label.toLowerCase().includes('back')\r\n          ) {\r\n            Consoler.debugLog(\r\n              `Found a back facing video device, id: ${dev.deviceId}`\r\n            );\r\n            foundCameras.push(dev.deviceId);\r\n          }\r\n        });\r\n      })\r\n      .catch((error) => {\r\n        Consoler.debugLog('Failed enumerating camera devices', error);\r\n      });\r\n\r\n    return foundCameras;\r\n  }\r\n\r\n  private async getAllCameras(): Promise<Array<string>> {\r\n    var foundCameras = Array<string>();\r\n\r\n    await navigator.mediaDevices\r\n      .enumerateDevices()\r\n      .then((devices) => {\r\n        devices.forEach((dev) => {\r\n          if (dev.kind === 'videoinput') {\r\n            Consoler.debugLog(`Found a video device ${dev.deviceId}`);\r\n            foundCameras.push(dev.deviceId);\r\n          }\r\n        });\r\n      })\r\n      .catch((error) => {\r\n        Consoler.debugLog('Failed enumerating camera devices', error);\r\n      });\r\n\r\n    return foundCameras;\r\n  }\r\n\r\n  private async switchCamera(): Promise<void> {\r\n    // Closes (if any) currently running video tracks.\r\n    if (this.videoStream) {\r\n      this.videoStream.getTracks().forEach((track) => {\r\n        track.stop();\r\n      });\r\n    }\r\n\r\n    // Request permissions for, and attempt to start video stream.\r\n    await navigator.mediaDevices\r\n      .getUserMedia({\r\n        video: {\r\n          deviceId: this.currentCameraDevice!,\r\n          facingMode: 'environment',\r\n          width: { ideal: 3840 },\r\n          height: { ideal: 2160 },\r\n        },\r\n      })\r\n      .then((stream) => {\r\n        var video = this.videoElement;\r\n        video.srcObject = stream;\r\n        this.videoStream = stream;\r\n\r\n        // We got access to the camera. Save the camera device id in LocalStorage\r\n        this.selectedCameraDeviceId = this.currentCameraDevice;\r\n      })\r\n      .catch((error) => {\r\n        Consoler.debugLog('Error switching camera:', error);\r\n        // Clearing the saved camera to avoid users getting stuck with a chosen camera not working.\r\n        this.selectedCameraDeviceId = null;\r\n      });\r\n\r\n    return;\r\n  }\r\n\r\n  public async show(): Promise<void> {\r\n    (this.$refs.modal as Modal).showModal();\r\n\r\n    const backFacingCameras = await this.getBackFacingCameras();\r\n    if (backFacingCameras.length > 0) {\r\n      this.cameraDevices = backFacingCameras;\r\n    } else {\r\n      Consoler.debugLog(\r\n        'Found no explicitly back facing cameras. Attempting to get all cameras'\r\n      );\r\n\r\n      const allCameras = await this.getAllCameras();\r\n      if (allCameras.length > 0) {\r\n        this.cameraDevices = allCameras;\r\n      }\r\n    }\r\n\r\n    if (this.cameraDevices.length == 0) {\r\n      Consoler.debugLog('Failed getting camera devices');\r\n      return;\r\n    }\r\n\r\n    const selectedCameraDeviceId = this.selectedCameraDeviceId;\r\n    if (\r\n      selectedCameraDeviceId === null ||\r\n      !this.cameraDevices.includes(selectedCameraDeviceId)\r\n    ) {\r\n      this.currentCameraDevice = this.cameraDevices[0];\r\n    } else {\r\n      this.currentCameraDevice = selectedCameraDeviceId;\r\n    }\r\n\r\n    this.switchCamera();\r\n\r\n    this.videoElement.addEventListener('resize', this.resizeVideoElement, {\r\n      once: true,\r\n    });\r\n  }\r\n\r\n  public async resizeVideoElement(): Promise<void> {\r\n    const videoElement = this.videoElement;\r\n\r\n    window.removeEventListener('resize', this.resizeVideoElement);\r\n\r\n    const screenWidth = document.documentElement.clientWidth;\r\n    const screenHeight = document.documentElement.clientHeight;\r\n    const screenAspectRatio = screenHeight / screenWidth;\r\n\r\n    var cameraResolution = this.getVideoResolution();\r\n    var cameraAspectRatio = cameraResolution[1] / cameraResolution[0];\r\n\r\n    if (cameraAspectRatio >= screenAspectRatio) {\r\n      // Height limited\r\n      videoElement.height = screenHeight;\r\n      videoElement.width = screenHeight / cameraAspectRatio;\r\n    } else {\r\n      // Width limited\r\n      videoElement.width = screenWidth;\r\n      videoElement.height = screenWidth * cameraAspectRatio;\r\n    }\r\n\r\n    this.$set(this.videosize, 0, videoElement.width);\r\n    this.$set(this.videosize, 1, videoElement.height);\r\n\r\n    window.addEventListener('resize', this.resizeVideoElement);\r\n  }\r\n\r\n  private async takeAndAnalyzePhoto(): Promise<void> {\r\n    var blob = await this.takePhoto();\r\n\r\n    var unitId: string | undefined = undefined;\r\n    try {\r\n      unitId = await qualityDataService.scanImageForUnitId(blob);\r\n      this.$emit('unitScanned', unitId);\r\n      this.onCloseClick();\r\n    } catch (error: any) {\r\n      Consoler.debugLog('Did not get a unitId in response', error);\r\n      this.noUnitIdFound = true;\r\n    }\r\n  }\r\n\r\n  private async takePhoto(): Promise<Blob | undefined> {\r\n    // Total size (resolution) of the video stream\r\n    const [videoWidth, videoHeight] = this.getVideoResolution();\r\n\r\n    // Get the coordinates for the viewfinder scaled to the video resolution\r\n    const [_, viewfinderArea] = this.scannerOverlay!.getViewfinderCoordinates(\r\n      videoWidth,\r\n      videoHeight\r\n    );\r\n\r\n    // Create a canvas with the size of the viewfinder to render\r\n    // the video snapshot to\r\n    const canvas = document.createElement('canvas');\r\n    const ctx = canvas.getContext('2d');\r\n\r\n    canvas.width = viewfinderArea.x2 - viewfinderArea.x1;\r\n    canvas.height = viewfinderArea.y2 - viewfinderArea.y1;\r\n\r\n    // Render the video snapshot to the canvas\r\n    ctx!.drawImage(\r\n      this.videoElement,\r\n      viewfinderArea.x1,\r\n      viewfinderArea.y1,\r\n      viewfinderArea.x2 - viewfinderArea.x1,\r\n      viewfinderArea.y2 - viewfinderArea.y1,\r\n      0,\r\n      0,\r\n      canvas.width,\r\n      canvas.height\r\n    );\r\n\r\n    const blob = await new Promise((resolve) =>\r\n      canvas.toBlob(resolve, 'image/jpeg')\r\n    );\r\n\r\n    return blob as Blob;\r\n  }\r\n\r\n  public onCameraChange(val: any): void {\r\n    Consoler.debugLog(`Changed camera to device: ${val}`);\r\n    this.currentCameraDevice = val;\r\n    this.switchCamera();\r\n  }\r\n\r\n  public onCloseClick(): void {\r\n    (this.$refs.modal as Modal).hideModal();\r\n  }\r\n\r\n  public onUnitIdClick(): void {\r\n    this.viewfinderStyle = ViewfinderStyle.UnitId;\r\n\r\n    const overlay = this.scannerOverlay;\r\n    overlay?.setViewfinderStyle(this.viewfinderStyle);\r\n    overlay?.redraw();\r\n  }\r\n\r\n  public onBarcodeClick(): void {\r\n    this.viewfinderStyle = ViewfinderStyle.Barcode;\r\n\r\n    const overlay = this.scannerOverlay;\r\n    overlay?.setViewfinderStyle(this.viewfinderStyle);\r\n    overlay?.redraw();\r\n  }\r\n}\r\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataScanner.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataScanner.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./QDataScanner.vue?vue&type=template&id=58cee623&scoped=true&\"\nimport script from \"./QDataScanner.vue?vue&type=script&lang=ts&\"\nexport * from \"./QDataScanner.vue?vue&type=script&lang=ts&\"\nimport style0 from \"./QDataScanner.vue?vue&type=style&index=0&id=58cee623&scoped=true&lang=scss&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  \"58cee623\",\n  null\n  \n)\n\nexport default component.exports","\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\r\nimport { Component, Vue, Watch } from 'vue-property-decorator';\r\nimport DefaultLayout from '@/layouts/DefaultLayout.vue';\r\nimport Breadcrumbs from '@/components/general/Breadcrumbs.vue';\r\nimport Messages from '@/components/general/Messages.vue';\r\nimport QDataSearchBox from '@/components/QDataSearchBox.vue';\r\nimport QDataUnitList from '@/components/QDataUnitList.vue';\r\nimport SelectBox from '@/components/general/SelectBox.vue';\r\nimport { deliveryMessagesUnitSearchModule } from '@/store/modules/deliveryMessagesUnitSearch';\r\nimport { Unit } from '@/models/QualityData/Unit';\r\nimport { routeNameQData, routeNameQDataUnitSearch } from '@/router/routes';\r\nimport { ParameterValueAverage } from '@/models/QualityData/ParameterValueAverage';\r\nimport { GeneralQualityDataForUnits } from '@/models/QualityData/GeneralQualityDataForUnits';\r\nimport qualityDataService from '@/services/QualityDataService';\r\nimport { PulpType } from '@/models/QualityData/PulpType';\r\nimport { Consoler } from '@/utils/Consoler';\r\nimport { Message, MessageType } from '@/models/Message';\r\nimport { EventBus } from '@/utils/EventBus';\r\nimport { Config } from '@/utils/Config';\r\nimport { Breadcrumb } from '@/models/Breadcrumb';\r\nimport telemetryService, {\r\n  RouteTrackingInfo,\r\n} from '@/services/TelemetryService';\r\nimport { getRouteTrackingInfo } from '@/router/functions';\r\nimport { userProfileModule } from '@/store/modules/userProfile';\r\nimport { userContactsModule } from '@/store/modules/userContacts';\r\nimport { Route } from 'vue-router';\r\nimport { GeneralParameter } from '@/models/QualityData/GeneralParameter';\r\nimport QDataScanner from '@/components/QDataScanner.vue';\r\nimport { FeatureFlagNames } from '@/models/FeatureFlagNames';\r\nimport { Permissions } from '@/utils/Permissions';\r\n\r\n@Component({\r\n  components: {\r\n    DefaultLayout,\r\n    Breadcrumbs,\r\n    Messages,\r\n    QDataSearchBox,\r\n    QDataUnitList,\r\n    SelectBox,\r\n    QDataScanner,\r\n  },\r\n})\r\nexport default class QDataUnitSearchPage extends Vue {\r\n  private routeTrackingInfo: RouteTrackingInfo = {};\r\n  private loading: boolean = false;\r\n  private downloadingDataSheet: boolean = false;\r\n  private showGeneralError: boolean = false;\r\n  private showNotFoundError: boolean = false;\r\n\r\n  private unitIdsInput: string = '';\r\n\r\n  private get search(): GeneralQualityDataForUnits | null {\r\n    return deliveryMessagesUnitSearchModule.search;\r\n  }\r\n\r\n  private get isQdataScanningEnabled(): boolean {\r\n    return Permissions.isFeatureEnabled(FeatureFlagNames.QDataScanning);\r\n  }\r\n\r\n  private get searchHasBeenDone(): boolean {\r\n    return this.search !== null;\r\n  }\r\n\r\n  private get unitsFound(): Unit[] {\r\n    return this.search !== null ? this.search.units : [];\r\n  }\r\n\r\n  private get parameters(): GeneralParameter[] {\r\n    return this.search !== null ? this.search.parameters : [];\r\n  }\r\n\r\n  private get pulpType(): PulpType | undefined {\r\n    return this.search !== null ? this.search.pulpType : undefined;\r\n  }\r\n\r\n  private get notFoundErrorHtml(): string {\r\n    const customerNumber = userProfileModule.selectedCustomer?.number;\r\n\r\n    const unitsNotFound = this.unitsNotFound\r\n      .map((term) => `<b>${term}</b>`)\r\n      .join(', ');\r\n\r\n    if (!customerNumber) {\r\n      return this.$t('qDataUnitSearchPage.notFoundError', [\r\n        unitsNotFound,\r\n      ]).toString();\r\n    }\r\n\r\n    const tpm = (userContactsModule.item(customerNumber) ?? []).find(\r\n      (contact) => (contact.responsibility ?? '').indexOf('TPM') != -1\r\n    );\r\n\r\n    if (!tpm || !(tpm.email ?? tpm.phoneNumber)) {\r\n      return this.$t('qDataUnitSearchPage.notFoundError', [\r\n        unitsNotFound,\r\n      ]).toString();\r\n    }\r\n\r\n    if (tpm.email) {\r\n      return this.$t('qDataUnitSearchPage.notFoundTpmWithEmailError', [\r\n        unitsNotFound,\r\n        tpm.name,\r\n        tpm.email,\r\n      ]).toString();\r\n    }\r\n\r\n    return this.$t('qDataUnitSearchPage.notFoundTpmWithPhoneNumberError', [\r\n      unitsNotFound,\r\n      tpm.name,\r\n      tpm.phoneNumber,\r\n    ]).toString();\r\n  }\r\n\r\n  private get unitsNotFound(): string[] {\r\n    const unitsFound = this.unitsFound.map((unit) => unit.id);\r\n\r\n    const unitsLookedFor = this.search !== null ? this.search.ids : [];\r\n\r\n    return unitsLookedFor.filter((id) => !unitsFound.includes(id));\r\n  }\r\n\r\n  private get unitsAverageValues(): ParameterValueAverage[] {\r\n    return this.search !== null ? this.search.averageValues : [];\r\n  }\r\n\r\n  private get breadcrumbs(): Breadcrumb[] {\r\n    // Q-data -> Search multiple units\r\n    return [\r\n      {\r\n        routeName: routeNameQData,\r\n        name: this.$t('breadcrumbs.' + routeNameQData).toString(),\r\n      },\r\n      {\r\n        routeName: routeNameQDataUnitSearch,\r\n        routeQuery: { ids: this.$route.query.ids },\r\n        name: this.$t('breadcrumbs.' + routeNameQDataUnitSearch).toString(),\r\n      },\r\n    ];\r\n  }\r\n\r\n  public onUnitScanned(unitId: string | undefined): void {\r\n    if (!unitId) {\r\n      return;\r\n    }\r\n\r\n    this.unitIdsInput = unitId;\r\n  }\r\n\r\n  @Watch('$route', { immediate: false, deep: true })\r\n  private onRouteChange(): void {\r\n    this.initializeAndStopTrackPage(this.$route);\r\n  }\r\n\r\n  private created(): void {\r\n    this.initializeAndStopTrackPage(this.$route);\r\n  }\r\n\r\n  private initializeAndStopTrackPage(route: Route): void {\r\n    this.routeTrackingInfo = getRouteTrackingInfo(route);\r\n    this.initialize().finally(() => {\r\n      telemetryService.stopTrackPage(this.routeTrackingInfo);\r\n    });\r\n  }\r\n\r\n  private async initialize(): Promise<void> {\r\n    await Promise.all([this.loadUnitsFromQuery(), this.loadUserContacts()]);\r\n    this.resetSearchTerms();\r\n  }\r\n\r\n  private loadUnitsFromQuery(): Promise<void> {\r\n    const unitIds = this.$route.query.ids\r\n      ? this.$route.query.ids.toString().split(',')\r\n      : [];\r\n\r\n    if (unitIds.length > 0) {\r\n      return this.loadUnits(unitIds).catch(() => {\r\n        // Do nothing, just catch error\r\n      });\r\n    } else if (this.unitsFound.length > 0) {\r\n      return this.clearUnits();\r\n    } else {\r\n      this.checkIfToShowNotFoundError();\r\n      return Promise.resolve();\r\n    }\r\n  }\r\n\r\n  private resetSearchTerms() {\r\n    this.unitIdsInput =\r\n      this.search !== null && this.search.ids.length > 0\r\n        ? this.search.ids.join('\\n')\r\n        : '';\r\n  }\r\n\r\n  private updateQuery(newIds?: string[]): boolean {\r\n    const queryIds =\r\n      newIds !== undefined\r\n        ? newIds.length > 0\r\n          ? newIds.map((id) => id).join(',')\r\n          : undefined\r\n        : this.unitsFound.length > 0\r\n        ? this.unitsFound.map((unit) => unit.id).join(',')\r\n        : undefined;\r\n\r\n    if (this.$route.query.ids === queryIds) {\r\n      this.resetSearchTerms();\r\n      return false;\r\n    }\r\n\r\n    this.$router.replace({\r\n      name: routeNameQDataUnitSearch,\r\n      query: {\r\n        ids: queryIds,\r\n      },\r\n    });\r\n\r\n    return true;\r\n  }\r\n\r\n  private checkIfToShowNotFoundError() {\r\n    if (this.unitsNotFound.length > 0) {\r\n      this.showNotFoundError = true;\r\n    }\r\n  }\r\n\r\n  private getUnitsToFind(): string[] {\r\n    function onlyUnique(value: string, index: number, self: string[]) {\r\n      return self.indexOf(value) === index;\r\n    }\r\n\r\n    return this.unitIdsInput\r\n      .split('\\n')\r\n      .filter((id) => id !== '')\r\n      .filter(onlyUnique);\r\n  }\r\n\r\n  private onSubmit(): void {\r\n    const unitsToFind = this.getUnitsToFind();\r\n\r\n    if (unitsToFind.length === 0) {\r\n      return;\r\n    }\r\n\r\n    this.updateQuery(unitsToFind);\r\n  }\r\n\r\n  private onScanClick(): void {\r\n    (this.$refs.scanner as QDataScanner).show();\r\n  }\r\n\r\n  private onResetClick() {\r\n    this.unitIdsInput = '';\r\n  }\r\n\r\n  private async loadUnits(unitIds: string[]): Promise<void> {\r\n    this.loading = true;\r\n    this.showGeneralError = false;\r\n    this.showNotFoundError = false;\r\n\r\n    return deliveryMessagesUnitSearchModule\r\n      .dispatchLoad({ unitIds })\r\n      .then(() => {\r\n        this.checkIfToShowNotFoundError();\r\n      })\r\n      .catch(() => {\r\n        this.clearUnits(); // This has to be done after the dispatchLoad for the search comparison to work\r\n        this.showGeneralError = true;\r\n        return Promise.reject();\r\n      })\r\n      .finally(() => {\r\n        this.loading = false;\r\n      });\r\n  }\r\n\r\n  private async loadUserContacts(): Promise<void> {\r\n    const customerNumber = userProfileModule.selectedCustomer?.number;\r\n\r\n    if (!customerNumber) {\r\n      return;\r\n    }\r\n\r\n    try {\r\n      await userContactsModule.dispatchLoad(customerNumber);\r\n    } catch (error) {\r\n      telemetryService.trackException(error as Error);\r\n    }\r\n  }\r\n\r\n  private async clearUnits(): Promise<void> {\r\n    return deliveryMessagesUnitSearchModule.dispatchClear();\r\n  }\r\n\r\n  private async downloadDataSheet() {\r\n    this.downloadingDataSheet = true;\r\n\r\n    await qualityDataService\r\n      .downloadUnitsQualityDataAsExcel(this.getUnitsToFind())\r\n      .catch((error) => {\r\n        Consoler.debugWarn('Error downloading data sheet', error);\r\n        const errorMessage: Message = {\r\n          text: this.$t(\r\n            'qDataUnitSearchPage.errorDownloadingDataSheet'\r\n          ).toString(),\r\n          type: MessageType.error,\r\n        };\r\n        EventBus.$emit(Config.AddMessageEvent, errorMessage);\r\n      })\r\n      .finally(() => {\r\n        this.downloadingDataSheet = false;\r\n      });\r\n  }\r\n}\r\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataUnitSearchPage.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataUnitSearchPage.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./QDataUnitSearchPage.vue?vue&type=template&id=366b473e&scoped=true&\"\nimport script from \"./QDataUnitSearchPage.vue?vue&type=script&lang=ts&\"\nexport * from \"./QDataUnitSearchPage.vue?vue&type=script&lang=ts&\"\nimport style0 from \"./QDataUnitSearchPage.vue?vue&type=style&index=0&id=366b473e&scoped=true&lang=scss&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  \"366b473e\",\n  null\n  \n)\n\nexport default component.exports","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--9-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--9-oneOf-1-1!../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--9-oneOf-1-2!../../node_modules/sass-loader/dist/cjs.js??ref--9-oneOf-1-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataDetailedParameterRow.vue?vue&type=style&index=0&id=7a9b8157&scoped=true&lang=scss&\"","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',[(_vm.units.length)?_c('Table',{attrs:{\"columns\":_vm.columns,\"rows\":_vm.rows,\"usePagination\":true},scopedSlots:_vm._u([{key:\"default\",fn:function(ref){\nvar row = ref.row;\nvar column = ref.column;\nreturn [(column.property === 'deliveryMessage')?[(row.unit.deliveryMessageNumber)?[_c('router-link',{attrs:{\"to\":_vm.getDeliveryMessageRoute(row.unit)}},[_vm._v(_vm._s(row.unit.deliveryMessageNumber))])]:_vm._e()]:[_vm._v(\" \"+_vm._s(row.properties[column.property])+\" \")]]}}],null,false,861873453)},[(_vm.averageValues.length)?_c('template',{slot:\"footer\"},[_c('tfoot',[_c('tr',[_c('td',{attrs:{\"colspan\":\"2\"}},[_vm._v(_vm._s(_vm.$t('qDataUnitList.footerPretext')))]),_vm._l((_vm.parametersToShow),function(parameter,index){return _c('td',{key:index},[_c('b',[_vm._v(\" \"+_vm._s(_vm._f(\"number\")(_vm.getDeliveryQualityData(parameter),parameter.numberOfDecimals)))])])}),(_vm.showDeliveryLink)?_c('td'):_vm._e()],2)])]):_vm._e()],2):_vm._e()],1)}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\r\nimport { Component, Vue, Prop } from 'vue-property-decorator';\r\nimport Table, { TableColumn, TableRow } from '@/components/general/Table.vue';\r\nimport { Unit } from '@/models/QualityData/Unit';\r\nimport { ParameterValueAverage } from '@/models/QualityData/ParameterValueAverage';\r\nimport { PulpType } from '@/models/QualityData/PulpType';\r\nimport { Location } from 'vue-router';\r\nimport { routeNameQDataDelivery } from '@/router/routes';\r\nimport { ParameterPsolId } from '@/models/PsolParameterId';\r\nimport { numberFilter } from '@/filters/number';\r\nimport { GeneralParameter } from '@/models/QualityData/GeneralParameter';\r\n\r\ninterface UnitTableRow extends TableRow {\r\n  unit: Unit;\r\n}\r\n\r\n@Component({\r\n  components: {\r\n    Table,\r\n  },\r\n})\r\nexport default class QDataUnitList extends Vue {\r\n  @Prop({ required: true })\r\n  public units!: Unit[];\r\n\r\n  @Prop({ required: true })\r\n  public parameters!: GeneralParameter[];\r\n\r\n  @Prop({ required: true })\r\n  public pulpType!: PulpType;\r\n\r\n  @Prop({ required: false, default: () => [] })\r\n  public averageValues!: ParameterValueAverage[];\r\n\r\n  @Prop({ required: false, default: () => false })\r\n  public showDeliveryLink!: boolean;\r\n\r\n  private get columns(): TableColumn[] {\r\n    const getDisplayName = (parameter: GeneralParameter) => {\r\n      if (!parameter.unitOfMeasurement) {\r\n        return parameter.displayName;\r\n      }\r\n\r\n      return `${parameter.displayName}\\n(${parameter.unitOfMeasurement})`;\r\n    };\r\n\r\n    let columns: TableColumn[] = [\r\n      {\r\n        text: this.$t('qDataUnitList.unitId').toString(),\r\n        property: 'unitId',\r\n        isSortable: true,\r\n        fixedOnMobile: true,\r\n      },\r\n      {\r\n        text: this.$t('qDataUnitList.product').toString(),\r\n        property: 'product',\r\n        isSortable: true,\r\n      },\r\n      ...this.parametersToShow.map((parameter) => ({\r\n        text: getDisplayName(parameter),\r\n        property: `parameterId${parameter.id}`,\r\n        isSortable: true,\r\n      })),\r\n    ];\r\n\r\n    if (this.showDeliveryLink) {\r\n      columns.push({\r\n        text: this.$t('qDataUnitList.deliveryMessage').toString(),\r\n        property: 'deliveryMessage',\r\n      });\r\n    }\r\n\r\n    return columns;\r\n  }\r\n\r\n  private get rows(): UnitTableRow[] {\r\n    return this.units.map((unit) => {\r\n      const properties: { [key: string]: string | number } = {\r\n        unitId: unit.id,\r\n        product: unit.productDisplayName,\r\n      };\r\n\r\n      this.parametersToShow.forEach((parameter) => {\r\n        properties[`parameterId${parameter.id}`] =\r\n          numberFilter(\r\n            this.getUnitQualityData(unit, parameter.id),\r\n            parameter.numberOfDecimals\r\n          ) ?? '';\r\n      });\r\n\r\n      return {\r\n        properties,\r\n        unit,\r\n      };\r\n    });\r\n  }\r\n\r\n  private get parametersToShow(): GeneralParameter[] {\r\n    var psolParameterIds: ParameterPsolId[];\r\n\r\n    if (this.pulpType === PulpType.Textile) {\r\n      psolParameterIds = [\r\n        ParameterPsolId.AlkaliResistanceR18,\r\n        ParameterPsolId.AshContent,\r\n        ParameterPsolId.BrightnessOnline,\r\n        ParameterPsolId.ExtractiveContent,\r\n        ParameterPsolId.Viscosity,\r\n        ParameterPsolId.Xylan,\r\n      ];\r\n    } else {\r\n      psolParameterIds = [\r\n        ParameterPsolId.BrightnessOnline,\r\n        ParameterPsolId.FibreLength,\r\n        ParameterPsolId.DirtContentOnline,\r\n        ParameterPsolId.FibreWidth,\r\n        ParameterPsolId.Coarseness,\r\n        ParameterPsolId.Ph,\r\n      ];\r\n    }\r\n\r\n    return this.parameters.filter(\r\n      (parameter) => psolParameterIds.indexOf(parameter.psolParameterId) !== -1\r\n    );\r\n  }\r\n\r\n  private getUnitQualityData(\r\n    unit: Unit,\r\n    parameterId: number\r\n  ): number | undefined {\r\n    const result = unit.qualityData.find((x) => x.parameterId === parameterId);\r\n\r\n    return result?.parameterValue;\r\n  }\r\n\r\n  private getDeliveryQualityData(\r\n    parameter: GeneralParameter\r\n  ): number | undefined {\r\n    const result = this.averageValues.find(\r\n      (x) => x.parameterId === parameter.id\r\n    );\r\n\r\n    return result?.parameterValueAvg;\r\n  }\r\n\r\n  private getDeliveryMessageRoute(unit: Unit): Location | null {\r\n    if (!unit.deliveryMessageNumber) {\r\n      return null;\r\n    }\r\n\r\n    return {\r\n      name: routeNameQDataDelivery,\r\n      params: { deliveryMessageNumber: unit.deliveryMessageNumber },\r\n    };\r\n  }\r\n}\r\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataUnitList.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/ts-loader/index.js??ref--15-3!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./QDataUnitList.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./QDataUnitList.vue?vue&type=template&id=1cb92c7e&\"\nimport script from \"./QDataUnitList.vue?vue&type=script&lang=ts&\"\nexport * from \"./QDataUnitList.vue?vue&type=script&lang=ts&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{class:'panelista-widget-' + _vm.id})}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","\n\n\n\n\r\nimport { Component, Vue, Prop } from 'vue-property-decorator';\r\n\r\n@Component({})\r\nexport default class Panelista extends Vue {\r\n  @Prop({ required: true })\r\n  private id!: string;\r\n\r\n  private created(): void {\r\n    this.getPanelList();\r\n  }\r\n\r\n  private getPanelList() {\r\n    [\r\n      `https://panelista.com/embeds/widgets/${this.id}.js`,\r\n      'https://panelista.com/embeds/widget.js',\r\n    ].map((src) => {\r\n      var script = document.createElement('script');\r\n      script.setAttribute('data-panelista-id', this.id);\r\n      script.src = src;\r\n      script.async = false;\r\n      document.head.appendChild(script);\r\n    });\r\n  }\r\n}\r\n","import mod from \"-!../../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../../node_modules/thread-loader/dist/cjs.js!../../../node_modules/babel-loader/lib/index.js!../../../node_modules/ts-loader/index.js??ref--15-3!../../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Panelista.vue?vue&type=script&lang=ts&\"; export default mod; export * from \"-!../../../node_modules/cache-loader/dist/cjs.js??ref--15-0!../../../node_modules/thread-loader/dist/cjs.js!../../../node_modules/babel-loader/lib/index.js!../../../node_modules/ts-loader/index.js??ref--15-3!../../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Panelista.vue?vue&type=script&lang=ts&\"","import { render, staticRenderFns } from \"./Panelista.vue?vue&type=template&id=9b49666a&\"\nimport script from \"./Panelista.vue?vue&type=script&lang=ts&\"\nexport * from \"./Panelista.vue?vue&type=script&lang=ts&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports"],"sourceRoot":""}