{"version":3,"sources":["webpack:///./src/components/QDataSearchBox.vue?b3eb","webpack:///./src/components/QDataDeliveryList.vue?f81d","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/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?00fd","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?6104","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/QDataDeliveryPage.vue?90c3","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","revolutionsSelectOptions","staticClass","attrs","currentRevolution","downloadingDataSheet","on","onRevolutionsChange","_e","columns","rows","$t","onSendCheckedRows","onDeliveryMessageClick","onCheckedAll","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","possibleRevolutions","revolution","value","val","required","components","Table","SelectBox","component","breadcrumbs","_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","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","loadingPredictedParameters","errorPredictedParameters","predictedParameters","currentRevolutions","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","isPredictedParametersEnabled","setRevolutions","QDataPredictedParametersList","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","deliveryId","setDeliveryAsReceived","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.aed967c0.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('div',[(_vm.revolutionsSelectOptions.length)?_c('SelectBox',{staticClass:\"mb-1 mb-md-2\",attrs:{\"value\":_vm.currentRevolution,\"options\":_vm.revolutionsSelectOptions,\"disabled\":_vm.downloadingDataSheet},on:{\"input\":_vm.onRevolutionsChange}}):_vm._e(),_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}})],1):_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\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\nimport SelectBox, { SelectOption } from '@/components/general/SelectBox.vue';\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    SelectBox,\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  @Prop({ required: true })\r\n  private possibleRevolutions!: number[];\r\n\r\n  private downloadingDataSheet: boolean = false;\r\n  private downloadAll: boolean = false;\r\n  private currentRevolution: number = 2000;\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        this.currentRevolution,\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  private get revolutionsSelectOptions(): SelectOption[] {\r\n    return this.possibleRevolutions.map((revolution) => ({\r\n      value: revolution,\r\n      text: this.$t('qDataDeliveryList.revolutionsSelectText', [\r\n        revolution,\r\n      ]).toString(),\r\n    }));\r\n  }\r\n  private onRevolutionsChange(val: number) {\r\n    this.currentRevolution = val;\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=1dc0e56a&\"\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!./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()],1),_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  @Action\r\n  public async dispatchSetDeliveryAsReceived(\r\n    deliveryId: string\r\n  ): Promise<void> {\r\n    return deliveryMessageService\r\n      .setDeliveryAsReceived(deliveryId)\r\n      .then(() => {\r\n        Consoler.debugLog('Set delivery as received success');\r\n      })\r\n      .catch((error) => {\r\n        Consoler.debugWarn('Set delivery as Received failed', error);\r\n        return Promise.reject(error);\r\n      });\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\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 this.deliveryMessageQualityData\r\n      ? this.deliveryMessageQualityData.pulpType === PulpType.Textile\r\n      : false;\r\n  }\r\n\r\n  private get isPulpTypePaper(): boolean {\r\n    return this.deliveryMessageQualityData\r\n      ? this.deliveryMessageQualityData.pulpType === PulpType.Paper\r\n      : false;\r\n  }\r\n\r\n  private get deliveryMessageAverageValues(): ParameterValueAverage[] {\r\n    return this.deliveryMessageQualityData\r\n      ? this.deliveryMessageQualityData.averageValues\r\n      : [];\r\n  }\r\n\r\n  private get hasUnitsFromBeforeAndAfterBreakpoint(): boolean {\r\n    return this.deliveryMessageQualityData\r\n      ? this.deliveryMessageQualityData.hasUnitsFromBeforeAndAfterBreakpoint\r\n      : false;\r\n  }\r\n\r\n  private get deliveryMessageUnits(): Unit[] {\r\n    return this.deliveryMessageQualityData\r\n      ? this.deliveryMessageQualityData.units\r\n      : [];\r\n  }\r\n\r\n  private get deliveryMessageParameters(): GeneralParameter[] {\r\n    return this.deliveryMessageQualityData\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.debugWarn(\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.debugWarn(\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=a6affc1e&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=a6affc1e&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  \"a6affc1e\",\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,\"possibleRevolutions\":_vm.possibleRevolutions},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\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 possibleRevolutions(): number[] {\r\n    return deliveryMessagesModule.search?.possibleRevolutions ?? [];\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=31fa07be&\"\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!./QDataDeliveryPage.vue?vue&type=style&index=0&id=a6affc1e&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!./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":""}